/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * This file contains the code to add new disk_type and partition
 * definitions to a format data file.
 */
#include "global.h"

#include <ctype.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>
#include <errno.h>
#include <memory.h>
#include <sys/fcntl.h>
#include <sys/param.h>
#include <time.h>
#include <sys/time.h>
#include <stdarg.h>

#include "add_definition.h"
#include "misc.h"
#include "partition.h"
#include "menu_command.h"
#include "startup.h"

extern	struct	ctlr_type ctlr_types[];
extern	int	nctypes;

extern	int	errno;

/* Function prototypes */
#ifdef	__STDC__

static void	add_disktype(FILE *fd, struct disk_info *disk_info);
static void	add_partition(FILE *fd, struct disk_info *,
		struct partition_info *);
static int	add_entry(int col, FILE *fd, char *format, ...);

#else	/* __STDC__ */

static void	add_disktype();
static void	add_partition();
static int	add_entry();

#endif	/* __STDC__ */

/*
 * Add new definitions for the current disk/partition to a format data file.
 */
int
add_definition(void)
{
	FILE	*fd;
	char	*filename;
	time_t	clock;
	char	*prompt;
	union {
		int	xfoo;
		char	deflt_str[MAXPATHLEN];
	} x;

	/*
	 * There must be a current disk and partition table
	 */
	if (cur_disk == NULL) {
		err_print("No Current Disk.\n");
		return (0);
	}
	if (cur_dtype == NULL) {
		err_print("Current disk type is not set.\n");
		return (-1);
	}
	if (cur_parts == NULL) {
		err_print("Current partition is not set.\n");
		return (-1);
	}
	/*
	 * If neither the disk definition nor the partition
	 * information has been changed, there's nothing to save.
	 */
	if (cur_dtype->dtype_filename != NULL &&
	    cur_parts->pinfo_filename != NULL) {
		err_print("\
Neither the disk type nor the partitioning has been changed.\n");
		return (-1);
	}
	/*
	 * If saving the partition, and it's unnamed, the user should name
	 * it first.
	 */
	if (cur_parts->pinfo_name == NULL) {
		assert(cur_parts->pinfo_filename == NULL);
		err_print("Please name this partition type before saving it\n");
		return (-1);
	}
	/*
	 * Let the user know what we're doing
	 */
	if (cur_dtype->dtype_filename == NULL &&
	    cur_parts->pinfo_filename == NULL) {
		fmt_print("Saving new disk and partition definitions\n");
	} else if (cur_dtype->dtype_filename == NULL) {
		fmt_print("Saving new disk definition\n");
	} else {
		assert(cur_parts->pinfo_filename == NULL);
		fmt_print("Saving new partition definition\n");
	}
	/*
	 * Ask for the file to which to append the new definitions
	 */
	prompt = "Enter file name";
	(void) strcpy(x.deflt_str, "./format.dat");
	filename = (char *)(uintptr_t)input(FIO_OSTR, prompt,
	    ':', NULL, &x.xfoo, DATA_INPUT);
	assert(filename != NULL);
	/*
	 * Open the file in append mode, or create it, if necessary
	 */
	if ((fd = fopen(filename, "a")) == NULL) {
		err_print("Cannot open `%s' - %s\n", filename,
		    strerror(errno));
		destroy_data(filename);
		return (-1);
	}
	/*
	 * Write a header for the new definitions
	 */
	if ((cur_dtype->dtype_filename == NULL) &&
	    (cur_parts->pinfo_filename == NULL)) {
		(void) fprintf(fd, "#\n# New disk/partition type ");
	} else if (cur_dtype->dtype_filename == NULL) {
		(void) fprintf(fd, "#\n# New disk type ");
	} else {
		(void) fprintf(fd, "#\n# New partition type ");
	}
	(void) time(&clock);
	(void) fprintf(fd, " saved on %s#\n", ctime(&clock));
	/*
	 * Save the new definitions
	 */
	if (cur_dtype->dtype_filename == NULL) {
		add_disktype(fd, cur_disk);
	}
	if (cur_parts->pinfo_filename == NULL) {
		add_partition(fd, cur_disk, cur_parts);
	}
	/*
	 * We're finished.  Clean up
	 */
	(void) fclose(fd);
	destroy_data(filename);
	return (0);
}

/*
 * Add a disk_type definition to the file fd
 */
static void
add_disktype(FILE *fd, struct disk_info *disk_info)
{
	int			col;
	struct disk_type	*disk_type;

	disk_type = disk_info->disk_type;

	(void) fprintf(fd, "disk_type = \"%s\" \\\n",
	    disk_type->dtype_asciilabel);
	col = add_entry(0, fd, " : ctlr = %s",
	    ((disk_info->disk_ctlr)->ctlr_ctype)->ctype_name);

	col = add_entry(col, fd, " : ncyl = %d", disk_type->dtype_ncyl);

	col = add_entry(col, fd, " : acyl = %d", disk_type->dtype_acyl);

	col = add_entry(col, fd, " : pcyl = %d", disk_type->dtype_pcyl);

	col = add_entry(col, fd, " : nhead = %d", disk_type->dtype_nhead);

	if (disk_type->dtype_options & SUP_PHEAD) {
		col = add_entry(col, fd, " : phead = %d",
		    disk_type->dtype_phead);
	}

	col = add_entry(col, fd, " : nsect = %d", disk_type->dtype_nsect);

	if (disk_type->dtype_options & SUP_PSECT) {
		col = add_entry(col, fd, " : psect = %d",
		    disk_type->dtype_psect);
	}

	if (disk_type->dtype_options & SUP_BPT) {
		col = add_entry(col, fd, " : bpt = %d", disk_type->dtype_bpt);
	}

	col = add_entry(col, fd, " : rpm = %d", disk_type->dtype_rpm);

	if (disk_type->dtype_options & SUP_FMTTIME) {
		col = add_entry(col, fd, " : fmt_time = %d",
		    disk_type->dtype_fmt_time);
	}

	if (disk_type->dtype_options & SUP_CYLSKEW) {
		col = add_entry(col, fd, " : cyl_skew = %d",
		    disk_type->dtype_cyl_skew);
	}

	if (disk_type->dtype_options & SUP_TRKSKEW) {
		col = add_entry(col, fd, " : trk_skew = %d",
		    disk_type->dtype_trk_skew);
	}

	if (disk_type->dtype_options & SUP_TRKS_ZONE) {
		col = add_entry(col, fd, " : trks_zone = %d",
		    disk_type->dtype_trks_zone);
	}

	if (disk_type->dtype_options & SUP_ATRKS) {
		col = add_entry(col, fd, " : atrks = %d",
		    disk_type->dtype_atrks);
	}

	if (disk_type->dtype_options & SUP_ASECT) {
		col = add_entry(col, fd, " : asect = %d",
		    disk_type->dtype_asect);
	}

	if (disk_type->dtype_options & SUP_CACHE) {
		col = add_entry(col, fd, " : cache = %d",
		    disk_type->dtype_cache);
	}

	if (disk_type->dtype_options & SUP_PREFETCH) {
		col = add_entry(col, fd, " : prefetch = %d",
		    disk_type->dtype_threshold);
	}

	if (disk_type->dtype_options & SUP_CACHE_MIN) {
		col = add_entry(col, fd, " : min_prefetch = %d",
		    disk_type->dtype_prefetch_min);
	}

	if (disk_type->dtype_options & SUP_CACHE_MAX) {
		col = add_entry(col, fd, " : max_prefetch = %d",
		    disk_type->dtype_prefetch_max);
	}

	if (disk_type->dtype_options & SUP_BPS) {
		col = add_entry(col, fd, " : bps = %d",
		    disk_type->dtype_bps);
	}

	if (disk_type->dtype_options & SUP_DRTYPE) {
		col = add_entry(col, fd, " : drive_type = %d",
		    disk_type->dtype_dr_type);
	}

	/*
	 * Terminate the last line, and print one blank line
	 */
	(void) fprintf(fd, col == 0 ? "\n" : "\n\n");
}



/*
 * Once we exceed this length, wrap to a new line
 */
#define	MAX_COLUMNS	50

/*
 * Add a partition definition to the file fd
 */
static void
add_partition(FILE *fd, struct disk_info *disk_info,
    struct partition_info *part)
{
	int			col;
	int			i;
	struct disk_type	*disk_type;
	struct dk_map32		*pp;
	char			*s;

#if defined(_SUNOS_VTOC_8)
	struct dk_map2		*pv;

#elif defined(_SUNOS_VTOC_16)
	struct dkl_partition	*pv;

#else
#error No VTOC format defined.
#endif			/* defined (_SUNOS_VTOC_8) */
	struct dk_map2		*dv;

	disk_type = disk_info->disk_type;

	(void) fprintf(fd, "partition = \"%s\" \\\n", part->pinfo_name);
	(void) fprintf(fd, "\t : disk = \"%s\" : ctlr = %s \\\n",
	    disk_type->dtype_asciilabel,
	    ((disk_info->disk_ctlr)->ctlr_ctype)->ctype_name);

	/*
	 * Print the specifications for each useful partition
	 */
	col = 0;
	pp = part->pinfo_map;
	pv = part->vtoc.v_part;
	dv = default_vtoc_map;
	for (i = 0; i < NDKMAP; i++, pp++, pv++, dv++) {
		if (pp->dkl_nblk != 0) {
			col = add_entry(col, fd, " : %c = ",
			    i + PARTITION_BASE);
			if (pv->p_tag != dv->p_tag ||
			    pv->p_flag != dv->p_flag) {
				s = find_string(ptag_choices, (int)pv->p_tag);
				if (s != NULL) {
					col = add_entry(col, fd, " %s,", s);
				}
				s = find_string(pflag_choices, (int)pv->p_flag);
				if (s != NULL) {
					col = add_entry(col, fd, " %s,", s);
				}
			}
			col = add_entry(col, fd, " %d, %d", pp->dkl_cylno,
			    pp->dkl_nblk);
		}
	}

	/*
	 * Terminate the last line, and print one blank line
	 */
	(void) fprintf(fd, col == 0 ? "\n" : "\n\n");
}

/*
 * Add an entry to the file fd.  col is the current starting column.
 * Return the resulting new column position.
 */
/*PRINTFLIKE3*/
static int
add_entry(int col, FILE *fd, char *format, ...)
{
	va_list	ap;
	va_start(ap, format);

	if (col > MAX_COLUMNS) {
		(void) fprintf(fd, " \\\n");
		col = 0;
	}
	if (col == 0) {
		col += fprintf(fd, "\t");
	}
	col += vfprintf(fd, format, ap);
	va_end(ap);

	return (col);
}