/* @(#)xdisk.c	1.27 00/05/07 Copyright 1991 J. Schilling */
#ifndef lint
static	char sccsid[] =
	"@(#)xdisk.c	1.27 00/05/07 Copyright 1991 J. Schilling";
#endif
/*
 *	Routines to handle external disk definitions
 *
 *	Copyright (c) 1991 J. Schilling
 */
/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; see the file COPYING.  If not, write to
 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include <mconfig.h>
#include <stdio.h>
#include <standard.h>
#include <stdxlib.h>
#include <strdefs.h>
#include <schily.h>
#include <sys/types.h>
#ifdef	HAVE_STDC_HEADERS
#	include <stddef.h>
#	define	soff(str, fld)	offsetof(struct str, fld)
#else
#	include <struct.h>
#	define	soff(str, fld)	fldoff(str, fld)
#endif
#include <scg/scsireg.h>
#include <scg/scsitransp.h>

#include "fmt.h"

#ifdef	FMT
extern	int	xdebug;
extern	int	debug;
extern	int	save_mp;
extern	int	autoformat;
#else
	int	xdebug = 1;
#endif

struct  dsk_fnd {
	struct disk	disk;
	int		match;
	char		name[512];
};

LOCAL	struct dsk_fnd *expand_df	__PR((struct dsk_fnd *, int));
LOCAL	BOOL	fuzzy_capacity	__PR((struct disk *, struct dsk_fnd *));
EXPORT	BOOL	pdisk_eql	__PR((struct disk *dp1, struct disk *dp2));
LOCAL	BOOL	add_disk	__PR((char *, struct disk *, struct dsk_fnd *));
LOCAL	void	check_deflt	__PR((struct dsk_fnd *, int *, int));
LOCAL	void	use_disk	__PR((struct disk *, struct dsk_fnd *, int));
LOCAL	void	select_disk	__PR((SCSI *scgp, struct disk *, struct dsk_fnd *, int, int));
EXPORT	BOOL	get_ext_diskdata __PR((SCSI *scgp, char *name, struct disk *dp));
LOCAL	int	do_disk		__PR((char *, struct disk *, BOOL));
LOCAL	void	set_diskitem	__PR((struct disk *, char *, char *, char *));
LOCAL	BOOL	set_diskvar	__PR((char *, struct disk *));
LOCAL	void	copy_disk	__PR((struct disk *, struct disk *));
EXPORT	int	cmp_disk	__PR((struct disk *dp1, struct disk *dp2));
LOCAL	BOOL	disk_eql	__PR((struct disk *, struct disk *));
EXPORT	BOOL	has_error_rec_params	__PR((struct disk *dp));
EXPORT	BOOL	has_disre_params __PR((struct disk *dp));
LOCAL	void	copy_vendor_info __PR((char *, struct scsi_inquiry *));
EXPORT	void	prdisk		__PR((FILE *f, struct disk *dp, struct scsi_inquiry *ip));
EXPORT	int	need_params		__PR((struct disk *dp, int type));
EXPORT	int	need_label_params	__PR((struct disk *dp));
EXPORT	int	need_geom_params	__PR((struct disk *dp));
EXPORT	int	need_scsi_params	__PR((struct disk *dp));
EXPORT	int	need_error_rec_params	__PR((struct disk *dp));
EXPORT	int	need_disre_params	__PR((struct disk *dp));


#define	K_NONE	0x01	/* This entry is not used but might be in database */
#define	K_NDB	0x02	/* This entry must not be in the database */
#define	K_LABEL	0x04	/* This is a label - not a disk - parameter */
#define	K_IGN	0x08	/* Inore this entry when comparing parameters */
#define	K_COPY	0x10	/* Copy this parameter even if dest is initialized */
#define	K_INIT	0x20	/* Copy over only to non initialized parameters */
#define	K_BOOL	0x40	/* This is a boolean entry */

#define	K_GEOM	0x0100	/* This is a disk geometry parameter */
#define	K_SCSI	0x0200	/* This is a SCSI parameter */
#define	K_ERREC	0x0400	/* This is an error recovery parameter */
#define	K_DISRE	0x0800	/* This is a disconnect/reconnect parameter */

#define	K_N	0x1000	/* We don't need to fill this out */

#define	lfld(ptr, off)		((long *)( ((char *)(ptr)) + (off)))

struct keyw {
	char	*name;
	int	flags;
	int	off;
} keyw[] = {

/* Disk Label geometry */
{ "lhead",		K_INIT|K_LABEL,		soff(disk, lhead) },
{ "lacyl",		K_INIT|K_LABEL,		soff(disk, lacyl) },
{ "lpcyl",		K_INIT|K_LABEL,		soff(disk, lpcyl) },
{ "lncyl",		K_INIT|K_LABEL,		soff(disk, lncyl) },
{ "lspt",		K_INIT|K_LABEL,		soff(disk, lspt) },
{ "lapc",		K_INIT|K_LABEL|K_N,	soff(disk, lapc) },

/* Disk Geometry */
{ "nhead",		K_INIT|K_GEOM,		soff(disk, nhead) },
{ "pcyl",		K_INIT|K_GEOM,		soff(disk, pcyl) },
{ "atrk",		K_INIT|K_GEOM,		soff(disk, atrk) },
{ "tpz",		K_INIT|K_GEOM,		soff(disk, tpz) },
{ "spt",		K_INIT|K_GEOM,		soff(disk, spt) },
{ "mintpz",		K_INIT|K_GEOM|K_N|K_NDB,soff(disk, mintpz) },
{ "maxtpz",		K_INIT|K_GEOM|K_N|K_NDB,soff(disk, maxtpz) },
{ "aspz",		K_INIT|K_GEOM,		soff(disk, aspz) },
{ "secsize",		K_INIT|K_GEOM,		soff(disk, secsize) },
{ "phys_secsize",	K_INIT|K_GEOM|K_N,	soff(disk, phys_secsize) },
			/*
			 * ignore capacity on compares
			 * use fuzzy compare instead
			 */
{ "capacity",		K_INIT|K_N|K_IGN,	soff(disk, capacity) },
{ "min_capacity",	K_NONE|K_N,		soff(disk, dummy) },
{ "rpm",		K_INIT|K_GEOM,		soff(disk, rpm) },
{ "track_skew",		K_INIT|K_GEOM,		soff(disk, track_skew) },
{ "cyl_skew",		K_INIT|K_GEOM,		soff(disk, cyl_skew) },

{ "reduced_curr",	K_INIT|K_GEOM|K_N,	soff(disk, reduced_curr) },
{ "write_precomp",	K_INIT|K_GEOM|K_N,	soff(disk, write_precomp) },
{ "step_rate",		K_INIT|K_GEOM|K_N,	soff(disk, step_rate) },

{ "rot_pos_locking",	K_INIT|K_GEOM|K_N,	soff(disk, rot_pos_locking) },
{ "rotational_off",	K_INIT|K_GEOM|K_N,	soff(disk, rotational_off) },

{ "interleave",		K_INIT|K_GEOM,		soff(disk, interleave) },
{ "fmt_pattern",	K_INIT|K_GEOM,		soff(disk, fmt_pattern) },

{ "fmt_mode",		K_INIT|K_GEOM|K_N,	soff(disk, fmt_mode) },
{ "spare_band_size",	K_INIT|K_GEOM|K_N,	soff(disk, spare_band_size) },

/* SCSI parameters */
{ "def_lst_format",	K_INIT|K_SCSI,		soff(disk, def_lst_format) },
{ "split_wv_cmd",	K_INIT|K_SCSI|K_BOOL,	soff(disk, split_wv_cmd) },

/* Error recovery */
{ "rd_retry_count",	K_INIT|K_ERREC|K_N,	soff(disk, rd_retry_count) },
{ "wr_retry_count",	K_INIT|K_ERREC|K_N,	soff(disk, wr_retry_count) },
{ "recov_timelim",	K_INIT|K_ERREC|K_N,	soff(disk, recov_timelim) },

/* Disconnect / reconnect */
{ "buf_full_ratio",	K_INIT|K_DISRE|K_N,	soff(disk, buf_full_ratio) },
{ "buf_empt_ratio",	K_INIT|K_DISRE|K_N,	soff(disk, buf_empt_ratio) },
{ "bus_inact_limit",	K_INIT|K_DISRE|K_N,	soff(disk, bus_inact_limit) },
{ "disc_time_limit",	K_INIT|K_DISRE|K_N,	soff(disk, disc_time_limit) },
{ "conn_time_limit",	K_INIT|K_DISRE|K_N,	soff(disk, conn_time_limit) },
{ "max_burst_size",	K_INIT|K_DISRE|K_N,	soff(disk, max_burst_size) },
{ "data_tr_dis_ctl",	K_INIT|K_DISRE|K_N,	soff(disk, data_tr_dis_ctl) },

/* Common device control */
{ "queue_alg_mod",	K_INIT|K_SCSI|K_N,	soff(disk, queue_alg_mod) },
{ "dis_queuing",	K_INIT|K_SCSI|K_BOOL|K_N,
						soff(disk, dis_queuing) },

{ "gap1",		K_INIT|K_IGN,		soff(disk, gap1) },
{ "gap2",		K_INIT|K_IGN,		soff(disk, gap2) },
{ "int_cyl",		K_INIT|K_IGN|K_N,	soff(disk, int_cyl) },
{ "fmt_time",		K_INIT|K_IGN,		soff(disk, fmt_time) },
{ "fmt_timeout",	K_INIT|K_IGN|K_N,	soff(disk, fmt_timeout) },
{ "veri_time",		K_INIT|K_IGN|K_N,	soff(disk, veri_time) },
{ "veri_count",		K_INIT|K_IGN|K_N,	soff(disk, veri_count) },
{ "wr_veri_count",	K_INIT|K_IGN|K_N,	soff(disk, wr_veri_count) },
{ "veri_loops",		K_INIT|K_IGN|K_N,	soff(disk, veri_loops) },
{ "default_data",	K_INIT|K_IGN|K_N|K_BOOL,soff(disk, default_data) },
{ "bridge_controller",	K_INIT|K_SCSI|K_IGN|K_N|K_BOOL,
						soff(disk, bridge_controller) },

};

#define NKEYW	(sizeof(keyw) / sizeof (keyw[0]))

struct keyw	*keywNKEYW = &keyw[NKEYW];

#ifdef	FMT
#else
main(ac, av)
	int	ac;
	char	**av;
{
	char	*name;
	struct disk	test_disk;

	if (ac > 1)
		name = av[1];
	else {
		name = "QUANTUM P105S 910-10-94xA.1 ";
		test_disk.nhead = 6;
		test_disk.pcyl = 1019;
	}

	if (!opendatfile("sformat.dat"))
		return;

	get_ext_diskdata(name, &test_disk);

	closedatfile();
}
#endif

LOCAL struct dsk_fnd *expand_df(df, found)
	struct dsk_fnd	*df;
	int		found;
{
	struct dsk_fnd	*xdf;

	xdf = (struct  dsk_fnd *) realloc(df,
					sizeof(struct  dsk_fnd) * (found+1));
	disk_null(&xdf[found].disk, 1);
	return (xdf);
}

LOCAL BOOL fuzzy_capacity(dp, df)
	struct disk	*dp;
	struct dsk_fnd	*df;
{
	double	dc;	/* current disk */
	double	fc;	/* found disk from database */

	/*
	 * if capacity is not known this is a match
	 */
	if (dp->capacity < 0 || df->disk.capacity < 0)
		return (TRUE);

	if (dp->secsize < 0)
		dc = dp->capacity * 512.0;
	else
		dc = dp->capacity * (dp->secsize * 1.0);
	if (df->disk.secsize < 0) {
		if (dp->secsize > 0)
			fc = df->disk.capacity * (dp->secsize * 1.0);
		else
			fc = df->disk.capacity * 512.0;
	} else
		fc = df->disk.capacity * (df->disk.secsize * 1.0);

	if (debug || xdebug) {
		printf("fuzzy_cap current: %g found: %g (limits: %g, %g)\n",
						dc, fc, dc/1.3, dc*1.3);
	}

	/*
	 * XXX NOTE:	Some versions of Sunpro C compile 1.3 t0 1.0 if
	 * XXX		in german locale.
	 * XXX		If fuzzy capacity does not work as expected:
	 * XXX		check your C-compiler.
	 */
	if ((dc * 1.3) < fc || (dc / 1.3) > fc)
		return (FALSE);

	if (xdebug) printf("fuzzy_cap: TRUE\n");
	return (TRUE);
}

EXPORT BOOL pdisk_eql(dp1, dp2)
	struct disk	*dp1;
	struct disk	*dp2;
{
	return ((dp1->nhead <= 0 || dp1->nhead == dp2->nhead) &&
			(dp1->pcyl <= 0 || dp1->pcyl == dp2->pcyl));
}

LOCAL BOOL add_disk(name, dp, df)
	char		*name;
	struct disk	*dp;
	struct dsk_fnd	*df;
{
	if (pdisk_eql(dp, &df->disk) && fuzzy_capacity(dp, df)) {
		strcpy(df->name, name);
		return (TRUE);
	}
	return (FALSE);
}

LOCAL void check_deflt(df, deflt, found)
	struct dsk_fnd	*df;
	int		*deflt;
	int		found;
{
	if (df->disk.default_data > 0) {
		if (*deflt >= 0) {
			if (!autoformat) {
				datfileerr("second default_data for '%s'",
					df->name);
			} else {
				comerrno(EX_BAD,
					"Die Datenbasis besitzt mehrere default Diskparameter fuer diese Platte.\n");
			/* NOTREACHED */
			}
		} else {
			*deflt = found;
		}
	}
}

LOCAL void use_disk(dp, df, this)
	struct disk	*dp;
	struct dsk_fnd	*df;
	int		this;
{
	copy_disk(&df[this].disk, dp);
	if (dp->disk_type)
		free(dp->disk_type);
	dp->disk_type = permstring(df[this].name);
}

#define	item_equal(a, b)	(((a) <  0 && (b) <  0) || ((a) == (b)))

LOCAL void select_disk(scgp, dp, df, found, deflt)
	SCSI		*scgp;
	struct disk	*dp;
	struct dsk_fnd	*df;
	int		found;
	int		deflt;
{
	int	i;
	int	this = -1;
	int	match= -1;
	int	max = -1;
	int	ndbentry = found;
	BOOL	selected = FALSE;
	BOOL	bridge	 = FALSE;

	for (i = 0; i < found; i++) {
		df[i].match = cmp_disk(dp, &df[i].disk);
		if (df[i].match > max &&
			item_equal(dp->secsize, df[i].disk.secsize) &&
			/*
			 * Sony Format Mode
			 */
			item_equal(dp->fmt_mode, df[i].disk.fmt_mode)) {
			max = df[i].match;
			match = i;
		}
		if (disk_eql(dp, &df[i].disk))
			this = i;
	}
	if (this < 0) {
		/*
		 * This disk is not known in database.
		 * Create an entry for it (name == INQUIRY).
		 */
		this = i;
		disk_null(&df[this].disk, 0);
		copy_disk(dp, &df[this].disk);
		df[this].disk.flags |= D_DISK_CURRENT;
		df[this].match = cmp_disk(dp, &df[this].disk);
		copy_vendor_info(df[this].name, scgp->inq);
		found++;
	}
	/*
	 * If the disk is unformatted or has no label
	 * use default database entry au current selection.
	 * Otherwise use current disk settings.
	 */
	if(dp->formatted <= 0)
		this = (deflt < 0) ? this : deflt;

	for (i = 0; i < ndbentry; i++) {
		if (df[0].disk.bridge_controller > 0)
			bridge = TRUE;
	}

	max = 0;
	if (autoformat) {
		if (deflt < 0) {
			/* Paranoia */
			comerrno(EX_BAD,
				"Die Datenbasis besitzt keine default Diskparameter fuer diese Platte.\n");
			/* NOTREACHED */
		}
		use_disk(dp, df, this=deflt);
	} else do {
		if (xdebug) printf("found: %d deflt: %d this: %d match: %d\n",
						found, deflt, this, match);

		if ((deflt >= 0) && (deflt != this)) {
			printf("WARNING: disk settings differ from default\n");
			selected = TRUE;
		}
		if (found > ndbentry) {
			printf("WARNING: disk settings differ from all database entries\n");
			if (bridge) {
				printf("\tThis may because an unknown disk is connected to the controller\n");
				printf("\tor because the current disk is not formatted as noted in database.\n");
				printf("\tIf this is an unknown disk, use the current parameters ...\n");
				printf("\totherwise:\n");
			}
			printf("\tCheck if you really want the disk settings to be\n");
			printf("\tdifferent from the settings in the database entry.\n");
			selected = TRUE;
		}
		if ((found > 1 && deflt < 0) ||
			  (found > 1 && (selected ||
			  	yes("Select alternate disk type? ")))) {
			printf("Available disk types:\n");
			for (i = 0; i < found; i++) {
				printf("%s%2d)%s%s(%2d)\t\"%s\"\n",
							i==this ? "*":" ",
							i,
							i==deflt ? "+":" ",
							i==match ? "~":" ",
							df[i].match,
							df[i].name);
			}
			if (max++ == 0 && ndbentry == 1 && found > 1 && 
					!yes("Don't use database entry or view selection? ")) {
				this = 0;	/* The one and only database entry */
				selected = FALSE;
			} else {
				getint("Select disk", &this, 0, found - 1);
				selected = TRUE;
			}
		}
		use_disk(dp, df, this);

		if(found > 1 && selected)
			prdisk(stdout, dp, scgp->inq);

	} while(selected && found > 1 && !yes("Use this disk parameters? "));

	if (deflt < 0)
		deflt = 0;
	if (this >= ndbentry) {
		printf("WARNING: using non database entry\n");
		printf("If you deny the next question there will be no label from data base.\n");
		if (yes("Use label list from default entry? ")) {
			dp->disk_type = permstring(df[deflt].name);
			dp->default_part = df[deflt].disk.default_part;
		}
		if (dp->mode_pages == 0 && df[deflt].disk.mode_pages) {
			printf("If you deny the next question there will be no mode pages from data base.\n");
			if (yes("Use mode page list from default entry? "))
				dp->mode_pages = df[deflt].disk.mode_pages;
		}
	}
}

EXPORT
BOOL get_ext_diskdata(scgp, name, dp)
	SCSI		*scgp;
	char		*name;
	struct disk	*dp;
{
	int	found = 0;
	int	inq_found = 0;		/* Vendor & Product */
	int	firmw_found = 0;	/* Vendor & Product & Firmware */
	BOOL	ign_firmw = FALSE;
	int	deflt = -1;
	char	nbuf[512];
	struct  dsk_fnd *disks_found;

again:
	if (rewinddatfile() < 0)
		return (FALSE);

	if (xdebug)
		printf("scan for disk: %.28s\n", name);

	disks_found = (struct  dsk_fnd *) malloc(sizeof (struct  dsk_fnd));
	disk_null(&disks_found[found].disk, 1);

	/*
	 * scan for next disk entry
	 */
	while (scanfortable("disk_type", NULL)) {
		int	i;
		strcpy(nbuf, curword());
		/*
		 * parse current disk entry and tell if it matched
		 */
		switch (i=do_disk(name, &disks_found[found].disk, ign_firmw)) {

		case D_INQ_FOUND|D_FIRMW_FOUND:
			firmw_found++;
			disks_found[found].disk.flags |=
						D_INQ_FOUND|D_FIRMW_FOUND;
			if (add_disk(nbuf, dp, &disks_found[found])) {
				check_deflt(&disks_found[found], &deflt, found);
				disks_found[found].disk.flags |=
						D_DISK_FOUND;
				found++;
				disks_found = expand_df(disks_found, found);
			}
			break;
		case D_INQ_FOUND:
			inq_found++;
			/*
			 * Don't increment found here,
			 * we must not use this entry.
			 */
			break;
		default:
			printf("illegal return code %X from do_disk()\n", i);
		case 0:	break;
		}
	}
	if (found) {
		/*
		 * Wenn nur ein Eintrag vorhanden ist, dann ist er
		 * in jedem Fall der Default Eintrag.
		 */
		if (found == 1)
			deflt = 0;
		printf("Default Disk type: '%s'\n", 
				deflt < 0 ? "none" : disks_found[deflt].name);
		if(deflt < 0 && autoformat) {
			comerrno(EX_BAD,
				"Die Datenbasis besitzt keine default Diskparameter fuer diese Platte.\n");
			/* NOTREACHED */
		}
		if (deflt >= 0 && disks_found[deflt].disk.default_part) {
			printf("Default partition: '%s'\n",
					disks_found[deflt].disk.default_part);
		} else if (autoformat) {
			comerrno(EX_BAD,
				"Die Datenbasis besitzt keine default Partition fuer diese Platte.\n");
			/* NOTREACHED */
		}
		if (deflt >= 0 && disks_found[deflt].disk.mode_pages) {
			printf("Mode Pages:        '%s'\n",
					disks_found[deflt].disk.mode_pages);
		}
		if (autoformat ||
			!yes("Ignore database disk parameters from '%s'? ",
							datfilename())) {
			select_disk(scgp, dp, disks_found, found, deflt);
			free(disks_found);
			return (TRUE);
		}
	} else if (autoformat) {
		;			/* Checked below */
	} else if (firmw_found) {
		errmsgno(EX_BAD,
			"WARNING: Inquiry OK (%d controller matches) but no disk found.\n", firmw_found);
	} else if (inq_found) {
		errmsgno(EX_BAD,
			"WARNING: Inquiry OK (%d controller matches) but no matching firmware found.\n", inq_found);
		if (yes("Try to use entry for other firmware? ")) {
			ign_firmw = TRUE;
			goto again;
		} else {
			/*
			 * Report that we found vendor & product.
			 */
			dp->flags |= D_INQ_FOUND;
		}
	}
	if (autoformat) {
		comerrno(EX_BAD,
			"Diese Platte besitzt keine Produktfreigabe.\n");
		/* NOTREACHED */
	}
	free(disks_found);
	return (FALSE);
}


/*---------------------------------------------------------------------------
|
|	Parst einen Disk Eintrag in der Steuerungsdatei
|	Returnwert zeigt an, ob dieser Eintrag passend war.
|
+---------------------------------------------------------------------------*/

LOCAL
int do_disk(name, dp, ign_firmw)
	char		*name;
	struct disk	*dp;
	BOOL		ign_firmw;
{
	char	inqname[80];
	char	defpart[80];
	char	mpages[80];
	int	ret = 0;

	disk_null(dp, 0);
	if (xdebug) printf("do_disk: line: %d curword: '%s'\n",
						getlineno(), curword());
	(void)garbage(skipwhite(peekword()));
	if (!nextline())
		return (FALSE);

	while (scanforline(NULL, NULL) != NULL) {
		if ((ret & D_FIRMW_FOUND) == 0)
			inqname[0] = defpart[0] = mpages[0] = 0;

		set_diskitem(dp, inqname, defpart, mpages);
		if ((ret & D_FIRMW_FOUND) == 0 && *inqname) {
			if (xdebug) {
				printf("name: %.28s\n", name);
				printf("DATA: %.28s\n", inqname);
			}
			/*
			 * allow short inquiry entry in database
			 * to match i.e. all firmware
			 */
			if (strncmp(name, inqname, strlen(inqname)) == 0)
				ret = D_INQ_FOUND|D_FIRMW_FOUND;
			else if (strncmp(name, inqname, 24) == 0) {
				ret = D_INQ_FOUND;
				if (ign_firmw)
					ret |= D_FIRMW_FOUND;
			}
		}
	}
	if (past_df_sig())
		dp->flags = D_DB_BAD;
	if (dp->fmt_time > 0)
		dp->flags |= D_FTIME_FOUND;
	if (dp->veri_time > 0)
		dp->flags |= D_VTIME_FOUND;

	if (ret & D_FIRMW_FOUND) {
		if (xdebug)
			printf("defpart: '%s' mpages: '%s'\n", defpart, mpages);
		if (defpart[0])
			dp->default_part = permstring(defpart);
		if (mpages[0])
			dp->mode_pages   = permstring(mpages);
	}
	return (ret);
}

LOCAL
void set_diskitem(dp, inqname, defpart, mpages)
	struct disk	*dp;
	char		*inqname;
	char		*defpart;
	char		*mpages;
{
	char	*word;

	for (word = curword(); *word; word = nextword()) {
		if (streql(word, ":"))
			continue;
		if (streql(word, "inquiry")) {
			if (!set_stringvar("Inquiry Name", inqname, 28))
				break;
		} else if (streql(word, "default_partition")) {
			if (!set_stringvar("Partition Name", defpart, 79))
				break;
		} else if (streql(word, "mode_pages")) {
			if (!set_stringvar("Modepage Name", mpages, 79))
				break;
		} else if (!set_diskvar(word, dp))
			break;
	}
	(void)nextword();
}

LOCAL
BOOL set_diskvar(word, dp)
	char		*word;
	struct disk	*dp;
{
	register struct keyw *kp = keyw;

	long	*valp = (long *)0;
	long	l;

	if (xdebug) printf("diskvar: '%s' : ", word);

	for (; kp < keywNKEYW; kp++) {
		if ((kp->name != NULL) &&
				((kp->flags & (K_LABEL|K_NDB)) == 0) &&
						streql(word, kp->name)) {
			valp = lfld(dp, kp->off);
			break;
		}
	}

	if (kp >= keywNKEYW) {
		skip_illvar("disk", word);
		return (FALSE);
	}

	if (!checkequal())
		return (FALSE);

	if (!isval(word = nextword()))
		return (FALSE);
	if (kp->flags & K_BOOL) {
		if (streql(word, "TRUE")) {
			l = TRUE;
		} else if (streql(word, "FALSE")) {
			l = FALSE;
		} else {
			datfileerr("%s: not a bool '%s'", kp->name, word);
			return (FALSE);
		}
	} else if (*astol(word, &l) != '\0') {
		datfileerr("%s: not a number '%s'", kp->name, word);
		return (FALSE);
	}
	*valp = l;

	if (xdebug) printf("%ld\n", *valp);
	return (TRUE);
}

LOCAL
void copy_disk(from, to)
	register struct disk *from;
	register struct disk *to;
{
	register struct keyw *kp = keyw;

	for (; kp < keywNKEYW; kp++) {
		if (kp->flags & K_COPY)
			*lfld(to, kp->off) = *lfld(from, kp->off);
		else if (kp->flags & K_INIT) {
			if (*lfld(from, kp->off) >= 0)
				*lfld(to, kp->off) = *lfld(from, kp->off);
		}
	}

	to->flags |= from->flags;

	if (from->disk_type) {
		to->disk_type = from->disk_type;
	}
	if (from->default_part) {
		if (to->default_part)
			free(to->default_part);
		to->default_part = from->default_part;
	}
	if (from->mode_pages) {
		if (to->mode_pages)
			free(to->mode_pages);
		to->mode_pages = from->mode_pages;
	}
	if (from->parts) {
		/*XXX*/
		to->parts = from->parts;
	}
	if (from->bridge_controller > 0) {
		to->bridge_controller = TRUE;
	}
}

EXPORT
int cmp_disk(dp1, dp2)
	register struct disk *dp1;
	register struct disk *dp2;
{
	register struct keyw *kp = keyw;
	register int	n = 0;

	for (; kp < keywNKEYW; kp++) {
		if ((kp->flags & (K_NONE|K_IGN)) == 0 &&
				*lfld(dp1, kp->off) >= 0 &&
				*lfld(dp1, kp->off) == *lfld(dp2, kp->off)) {
			n++;
		} else {
			if (xdebug == 0)
				continue;

			if (*lfld(dp1, kp->off) == -1)
				continue;
			printf("name:%-16s off:%3d flags:%02X 1:%9ld 2:%9ld\n",
				kp->name, kp->off, kp->flags,
				*lfld(dp1, kp->off), *lfld(dp2, kp->off));
		}
	}
	return (n);
}

LOCAL
BOOL disk_eql(dp1, dp2)
	register struct disk *dp1;
	register struct disk *dp2;
{
	register struct keyw *kp = keyw;
	register int	diffs = 0;

	/*
	 * Zwei Platten sind gleich, wenn alle in beiden Strukturen definierten
	 * d.h. != -1 Felder gleich sind.
	 */
	for (; kp < keywNKEYW; kp++) {
		if ((kp->flags & (K_NONE|K_LABEL|K_IGN)) == 0 &&
				*lfld(dp1, kp->off) >= 0 &&
				*lfld(dp2, kp->off) >= 0 &&
				*lfld(dp1, kp->off) != *lfld(dp2, kp->off)) {
			if (xdebug)
				printf("not equal: %-10s %ld != %ld\n",
				kp->name,
				*lfld(dp1, kp->off), *lfld(dp2, kp->off));
			diffs++;
		}
	}
	if (xdebug)
		printf("total of %d diff%s.\n", diffs, diffs > 1?"s":"");
	return (diffs == 0);
}

EXPORT
BOOL has_error_rec_params(dp)
	register struct disk	*dp;
{
	if (dp->rd_retry_count >= 0 ||
			dp->wr_retry_count >= 0 ||
			dp->recov_timelim >= 0) {
		return (TRUE);
	}
	return (FALSE);
}

EXPORT
BOOL has_disre_params(dp)
	register struct disk	*dp;
{
	if (dp->buf_full_ratio >= 0 ||
			dp->buf_empt_ratio >= 0 ||
			dp->bus_inact_limit >= 0 ||
			dp->disc_time_limit >= 0 ||
			dp->conn_time_limit >= 0 ||
			dp->max_burst_size >= 0 ||
			dp->data_tr_dis_ctl >= 0) {
		return (TRUE);
	}
	return (FALSE);
}


LOCAL
void copy_vendor_info(s, ip)
	char			*s;
	struct scsi_inquiry	*ip;
{
	sprintf(s, "CURRENT %.28s", ip->vendor_info);
}

EXPORT
void prdisk(f, dp, ip)
	register FILE *f;
	register struct disk		*dp;
	register struct scsi_inquiry	*ip;
{
	int	neednl = 0;

	fprintf(f, "disk_type = \"%s\"\n", dp->disk_type);
	fprintf(f, "\tinquiry = \"%.28s\" :\n", ip->vendor_info);
	if (dp->bridge_controller > 0)
		fprintf(f, "\tbridge_controller = TRUE :\n");
#ifdef	nono
	if (dp->fmt_time <= 0 || dp->veri_time <= 0)
		estimate_times(dp);
#endif
	if (dp->fmt_time > 0) {
		fprintf(f, "\tfmt_time = %ld :", dp->fmt_time);
		neednl++;
	}

	if (dp->veri_time > 0) {
		fprintf(f, "%sveri_time = %ld :",
					neednl?" ":"\t", dp->veri_time);
		neednl++;
	}
	if (neednl)
		fprintf(f, "\n");
	neednl = 0;

	fprintf(f, "\tnhead = %ld : ", dp->nhead);
	fprintf(f, "pcyl = %ld : ", dp->pcyl);
	fprintf(f, "spt = %ld : ", dp->spt);
	fprintf(f, "secsize = %ld :\n", dp->secsize);

	if (dp->reduced_curr >= 0 ||
			dp->write_precomp >= 0 || dp->step_rate >= 0) {
		fprintf(f, "\treduced_curr = %ld : ", dp->reduced_curr);
		fprintf(f, "write_precomp = %ld : ", dp->write_precomp);
		fprintf(f, "step_rate = %ld :\n", dp->step_rate);
	}
	if (dp->atrk > 0 || dp->tpz != 1 || dp->aspz > 0) {
		fprintf(f, "\tatrk = %ld : ", dp->atrk);
		fprintf(f, "tpz = %ld : ", dp->tpz);
		fprintf(f, "aspz = %ld : ", dp->aspz);
		neednl++;
	}
	if (dp->phys_secsize > 0 && dp->phys_secsize != dp->secsize) {
		fprintf(f, "phys_secsize = %ld :", dp->phys_secsize);
		neednl++;
		
	}
	if (neednl)
		fprintf(f, "\n");
	if (dp->cur_capacity > 0) {
		fprintf(f, "\tcapacity = %ld :\n", dp->cur_capacity);
	}
	if (dp->track_skew > 0 || dp->cyl_skew > 0) {
		fprintf(f, "\ttrack_skew = %ld : ", dp->track_skew);
		fprintf(f, "cyl_skew = %ld :\n", dp->cyl_skew);
	}
	if (dp->fmt_mode >= 0 || dp->spare_band_size >= 0) {
		fprintf(f, "\tfmt_mode = %ld : ", dp->fmt_mode);
		fprintf(f, "spare_band_size = %ld :\n", dp->spare_band_size);
	}
	if (dp->def_lst_format >= 0 && dp->def_lst_format != SC_DEF_BLOCK) {
		fprintf(f, "\tdef_lst_format = %ld :\n", dp->def_lst_format);
	}
	if (dp->split_wv_cmd > 0) {
		fprintf(f, "\tsplit_wv_cmd = %s :\n",
					dp->split_wv_cmd?"TRUE":"FALSE");
	}
	neednl = 0;
	if (dp->queue_alg_mod >= 0) {
		fprintf(f, "\tqueue_alg_mod = %ld :", dp->queue_alg_mod);
		neednl++;
	}
	if (dp->dis_queuing > 0) {
		fprintf(f, "%sdis_queuing = TRUE :", neednl?" ":"\t");
		neednl++;
	}
	if (neednl)
		fprintf(f, "\n");

	fprintf(f, "\tinterleave = %ld : ", dp->interleave);
	fprintf(f, "rpm = %ld :", dp->rpm);
	if (dp->fmt_pattern > 0)
		fprintf(f, " fmt_pattern = %ld :", dp->fmt_pattern);
	fprintf(f, "\n");

	if (has_error_rec_params(dp)) {
		int	n = 0;

		fprintf(f, "\t");
		if (dp->rd_retry_count >= 0) {
			fprintf(f, "rd_retry_count = %ld :",
						dp->rd_retry_count);
			n++;
		}
		if (dp->wr_retry_count >= 0) {
			fprintf(f, "%swr_retry_count = %ld :", n ? " " : "",
						dp->wr_retry_count);
			n++;
		}
		if (dp->recov_timelim >= 0) {
			fprintf(f, "%srecov_timelim = %ld :", n ? " " : "",
						dp->recov_timelim);
			n++;
		}
		fprintf(f, "\n");
	}
	if (has_disre_params(dp)) {
		int	n = -1;

		fprintf(f, "\t");
		if (dp->buf_full_ratio >= 0) {
			n++;
			fprintf(f, "buf_full_ratio = %ld :",
						dp->buf_full_ratio);
		}
		if (dp->buf_empt_ratio >= 0) {
			n++;
			fprintf(f, "%sbuf_empt_ratio = %ld :", n ? " " : "",
						dp->buf_empt_ratio);
		}
		if (dp->bus_inact_limit >= 0) {
			if (++n >= 3) { fprintf(f, "\n\t"); n = 0;}

			fprintf(f, "%sbus_inact_limit = %ld :", n ? " " : "",
						dp->bus_inact_limit);
		}
		if (dp->disc_time_limit >= 0) {
			if (++n >= 3) { fprintf(f, "\n\t"); n = 0;}

			fprintf(f, "%sdisc_time_limit = %ld :", n ? " " : "",
						dp->disc_time_limit);
		}
		if (dp->conn_time_limit >= 0) {
			if (++n >= 3) { fprintf(f, "\n\t"); n = 0;}

			fprintf(f, "%sconn_time_limit = %ld :", n ? " " : "",
						dp->conn_time_limit);
		}
		if (dp->max_burst_size >= 0) {
			if (++n >= 3) { fprintf(f, "\n\t"); n = 0;}

			fprintf(f, "%smax_burst_size = %ld :", n ? " " : "",
						dp->max_burst_size);
		}
		if (dp->data_tr_dis_ctl >= 0) {
			if (++n >= 3) { fprintf(f, "\n\t"); n = 0;}

			fprintf(f, "%sdata_tr_dis_ctl = %ld :", n ? " " : "",
						dp->data_tr_dis_ctl);
		}
		fprintf(f, "\n");
	}
	
	fprintf(f, "\tdefault_partition = \"%s\" :\n\n", dp->default_part);
}

EXPORT	int
need_params(dp, type)
	register struct disk	*dp;
	register int		type;
{
	register struct keyw *kp = keyw;
	register int	n = 0;

	for (; kp < keywNKEYW; kp++) {
		if ((kp->flags & K_N) != 0)
			continue;
		if ((kp->flags & type) == 0)
			continue;

		if (*lfld(dp, kp->off) != -1)
			continue;
		n++;
/*		if (xdebug == 0)*/
/*			continue;*/

		printf("name:%-16s off:%3d flags:%02X == -1\n",
				kp->name, kp->off, kp->flags);
	}
	return (n);
}

EXPORT	int
need_label_params(dp)
	struct disk	*dp;
{
	return (need_params(dp, K_LABEL));
}

EXPORT	int
need_geom_params(dp)
	struct disk	*dp;
{
	return (need_params(dp, K_GEOM));
}

EXPORT	int
need_scsi_params(dp)
	struct disk	*dp;
{
	return (need_params(dp, K_SCSI));
}

/* NOT NEEDED */
EXPORT	int
need_error_rec_params(dp)
	struct disk	*dp;
{
	return (need_params(dp, K_ERREC));
}

/* NOT NEEDED */
EXPORT	int
need_disre_params(dp)
	struct disk	*dp;
{
	return (need_params(dp, K_DISRE));
}
