/*

 * Copyright (c) 1998,1999,2000

 *	Traakan, Inc., Los Altos, CA

 *	All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice unmodified, this list of conditions, and the following

 *    disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND

 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE

 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

 * SUCH DAMAGE.

 */

/*

 * Project:  NDMJOB

 * Ident:    $Id: $

 *

 * Description:

 *

 */

#include "ndmlib.h"

#define CFG_BUF_SIZE	512

#define CFG_MAX_SV	32

/* control block */

struct cfg_cb {

	FILE *			fp;

	ndmp9_config_info *	config_info;

	char			buf[CFG_BUF_SIZE];

	char *			sv[CFG_MAX_SV];

	int			sc;

	int			n_error;

};

static int	cfg_butype (struct cfg_cb *cb);

static int	cfg_fs (struct cfg_cb *cb);

static int	cfg_tape (struct cfg_cb *cb);

static int	cfg_scsi (struct cfg_cb *cb);

static int	cfg_device (struct cfg_cb *cb, u_int *n_device,

			ndmp9_device_info **pp);

static int	cfg_add_env (struct cfg_cb *cb, u_int *n_env,

			ndmp9_pval **pp, char *name, char *value);

int

ndmcfg_load (char *filename, ndmp9_config_info *config_info)

{

	FILE *		fp;

	int		rc;

	fp = fopen (filename, "r");

	if (!fp)

		return -1;

	rc = ndmcfg_loadfp (fp, config_info);

	fclose (fp);

	return rc;

}

int

ndmcfg_loadfp (FILE *fp, ndmp9_config_info *config_info)

{

	struct cfg_cb	_cb, *cb = &_cb;

	int		rc;

	NDMOS_MACRO_ZEROFILL(cb);

	cb->fp = fp;

	cb->config_info = config_info;

	for (;;) {

		rc = ndmstz_getstanza (cb->fp, cb->buf, sizeof cb->buf);

		if (rc == EOF) {

			break;

		}

		cb->sc = ndmstz_parse (cb->buf, cb->sv, CFG_MAX_SV);

		if (cb->sc < 1) {

			continue;

		}

		if (strcmp (cb->sv[0], "butype") == 0 && cb->sc == 2) {

			cfg_butype (cb);

			continue;

		}

		if (strcmp (cb->sv[0], "fs") == 0 && cb->sc == 2) {

			cfg_fs (cb);

			continue;

		}

		if (strcmp (cb->sv[0], "tape") == 0 && cb->sc == 2) {

			cfg_tape (cb);

			continue;

		}

		if (strcmp (cb->sv[0], "scsi") == 0 && cb->sc == 2) {

			cfg_scsi (cb);

			continue;

		}

		/*

		 * Unrecognized stanzas are deemed for other purposes

		 * and tolerated.

		 */

	}

	return cb->n_error;

}

/*

 * [butype BUTYPE]

 *	v2attr	0xATTR

 *	v3attr	0xATTR

 *	v4attr	0xATTR

 *	default_env NAME VALUE

 */

static int

cfg_butype (struct cfg_cb *cb)

{

	ndmp9_config_info *	cfg = cb->config_info;

	ndmp9_butype_info *	ent = cfg->butype_info.butype_info_val;

	int			n_ent = cfg->butype_info.butype_info_len;

	int			i, rc;

	if (!ent)

		n_ent = 0;

	ent = NDMOS_MACRO_NEWN(ndmp9_butype_info, n_ent+1);

	if (!ent) {

		cb->n_error++;

		return -1;

	}

	for (i = 0; i < n_ent; i++) {

		ent[i] = cfg->butype_info.butype_info_val[i];

	}

	if (cfg->butype_info.butype_info_val) {

		NDMOS_API_FREE (cfg->butype_info.butype_info_val);

	}

	cfg->butype_info.butype_info_val = ent;

	cfg->butype_info.butype_info_len = n_ent+1;

	ent += n_ent;

	NDMOS_MACRO_ZEROFILL (ent);

	ent->butype_name = NDMOS_API_STRDUP (cb->sv[1]);

	for (;;) {

		rc = ndmstz_getline (cb->fp, cb->buf, CFG_BUF_SIZE);

		if (rc < 0)

			break;

		cb->sc = ndmstz_parse (cb->buf, cb->sv, CFG_MAX_SV);

		if (cb->sc < 1) {

			continue;

		}

		if (strcmp (cb->sv[0], "v2attr") == 0 && cb->sc == 2) {

			ent->v2attr.valid = NDMP9_VALIDITY_VALID;

			ent->v2attr.value = strtol (cb->sv[1], 0, 0);

			continue;

		}

		if (strcmp (cb->sv[0], "v3attr") == 0 && cb->sc == 2) {

			ent->v3attr.valid = NDMP9_VALIDITY_VALID;

			ent->v3attr.value = strtol (cb->sv[1], 0, 0);

			continue;

		}

		if (strcmp (cb->sv[0], "v4attr") == 0 && cb->sc == 2) {

			ent->v4attr.valid = NDMP9_VALIDITY_VALID;

			ent->v4attr.value = strtol (cb->sv[1], 0, 0);

			continue;

		}

		if (strcmp (cb->sv[0], "default_env") == 0 && cb->sc == 3) {

			cfg_add_env (cb, &ent->default_env.default_env_len,

				&ent->default_env.default_env_val,

				cb->sv[1], cb->sv[2]);

			continue;

		}

		/*

		 * Unrecognized lines are deemed version differences

		 * and tolerated.

		 */

	}

	return 0;

}

/*

 * [fs MOUNTPOINT]

 *	fs_type TYPE

 *	fs_physical_device DEVICEPATH

 *	fs_status "COMMENT"

 *	fs_env NAME VALUE

 */

static int

cfg_fs (struct cfg_cb *cb)

{

	ndmp9_config_info *	cfg = cb->config_info;

	ndmp9_fs_info *		ent = cfg->fs_info.fs_info_val;

	int			n_ent = cfg->fs_info.fs_info_len;

	int			i, rc;

	if (!ent)

		n_ent = 0;

	ent = NDMOS_MACRO_NEWN(ndmp9_fs_info, n_ent+1);

	if (!ent) {

		cb->n_error++;

		return -1;

	}

	for (i = 0; i < n_ent; i++) {

		ent[i] = cfg->fs_info.fs_info_val[i];

	}

	if (cfg->fs_info.fs_info_val) {

		NDMOS_API_FREE (cfg->fs_info.fs_info_val);

	}

	cfg->fs_info.fs_info_val = ent;

	cfg->fs_info.fs_info_len = n_ent+1;

	ent += n_ent;

	NDMOS_MACRO_ZEROFILL (ent);

	ent->fs_logical_device = NDMOS_API_STRDUP (cb->sv[1]);

	for (;;) {

		rc = ndmstz_getline (cb->fp, cb->buf, CFG_BUF_SIZE);

		if (rc < 0)

			break;

		cb->sc = ndmstz_parse (cb->buf, cb->sv, CFG_MAX_SV);

		if (cb->sc < 1) {

			continue;

		}

		if (strcmp (cb->sv[0], "fs_type") == 0 && cb->sc == 2) {

			ent->fs_type = NDMOS_API_STRDUP (cb->sv[1]);

			continue;

		}

		if (strcmp (cb->sv[0], "fs_physical_device") == 0

		 && cb->sc == 2) {

			ent->fs_physical_device = NDMOS_API_STRDUP (cb->sv[1]);

			continue;

		}

		if (strcmp (cb->sv[0], "fs_status") == 0 && cb->sc == 2) {

			ent->fs_status = NDMOS_API_STRDUP (cb->sv[1]);

			continue;

		}

		if (strcmp (cb->sv[0], "fs_env") == 0 && cb->sc == 3) {

			cfg_add_env (cb, &ent->fs_env.fs_env_len,

				&ent->fs_env.fs_env_val,

				cb->sv[1], cb->sv[2]);

			continue;

		}

		/*

		 * Unrecognized lines are deemed version differences

		 * and tolerated.

		 */

	}

	return 0;

}

static int

cfg_tape (struct cfg_cb *cb)

{

	ndmp9_config_info *	cfg = cb->config_info;

	return cfg_device (cb, &cfg->tape_info.tape_info_len,

				&cfg->tape_info.tape_info_val);

}

static int

cfg_scsi (struct cfg_cb *cb)

{

	ndmp9_config_info *	cfg = cb->config_info;

	return cfg_device (cb, &cfg->scsi_info.scsi_info_len,

				&cfg->scsi_info.scsi_info_val);

}

/*

 * [tape IDENT]  or  [scsi IDENT]

 *	device DEVICEPATH

 *	v3attr 0xATTR

 *	v4attr 0xATTR

 *	capability NAME VALUE

 */

static int

cfg_device (struct cfg_cb *cb, u_int *n_device, ndmp9_device_info **pp)

{

	ndmp9_device_info *	ent = *pp;

	ndmp9_device_capability *dcap;

	int			rc;

	unsigned int		i, n_ent = *n_device;

	if (!ent)

		n_ent = 0;

	for (i = 0; i < n_ent; i++) {

		if (strcmp(ent[i].model, (*pp)[i].model) == 0) {

			ent += i;

			goto got_model;

		}

	}

	ent = NDMOS_MACRO_NEWN(ndmp9_device_info, n_ent+1);

	if (!ent) {

		cb->n_error++;

		return -1;

	}

	for (i = 0; i < n_ent; i++) {

		ent[i] = (*pp)[i];

	}

	if (*pp) {

		NDMOS_API_FREE (*pp);

	}

	*pp = ent;

	*n_device = n_ent+1;

	ent += n_ent;

	NDMOS_MACRO_ZEROFILL (ent);

	ent->model = NDMOS_API_STRDUP (cb->sv[1]);

  got_model:

	dcap = NDMOS_MACRO_NEWN (ndmp9_device_capability,

			ent->caplist.caplist_len+1);

	if (!dcap) {

		cb->n_error++;

		return -1;

	}

	for (i = 0; i < ent->caplist.caplist_len; i++) {

		dcap[i] = ent->caplist.caplist_val[i];

	}

	if (ent->caplist.caplist_val) {

		NDMOS_API_FREE (ent->caplist.caplist_val);

	}

	ent->caplist.caplist_val = dcap;

	dcap += ent->caplist.caplist_len++;

	NDMOS_MACRO_ZEROFILL(dcap);

	for (;;) {

		rc = ndmstz_getline (cb->fp, cb->buf, CFG_BUF_SIZE);

		if (rc < 0)

			break;

		cb->sc = ndmstz_parse (cb->buf, cb->sv, CFG_MAX_SV);

		if (cb->sc < 1) {

			continue;

		}

		if (strcmp (cb->sv[0], "device") == 0 && cb->sc == 2) {

			dcap->device = NDMOS_API_STRDUP (cb->sv[1]);

			continue;

		}

		if (strcmp (cb->sv[0], "v3attr") == 0 && cb->sc == 2) {

			dcap->v3attr.valid = NDMP9_VALIDITY_VALID;

			dcap->v3attr.value = strtol (cb->sv[1], 0, 0);

			continue;

		}

		if (strcmp (cb->sv[0], "v4attr") == 0 && cb->sc == 2) {

			dcap->v4attr.valid = NDMP9_VALIDITY_VALID;

			dcap->v4attr.value = strtol (cb->sv[1], 0, 0);

			continue;

		}

		if (strcmp (cb->sv[0], "capability") == 0 && cb->sc == 3) {

			cfg_add_env (cb, &dcap->capability.capability_len,

				&dcap->capability.capability_val,

				cb->sv[1], cb->sv[2]);

			continue;

		}

		/*

		 * Unrecognized lines are deemed version differences

		 * and tolerated.

		 */

	}

	return 0;

}

static int

cfg_add_env (struct cfg_cb *cb, u_int *n_env,

  ndmp9_pval **pp, char *name, char *value)

{

	ndmp9_pval *		ent = *pp;

	int			n_ent = *n_env;

	int			i;

	if (!ent)

		n_ent = 0;

	ent = NDMOS_MACRO_NEWN(ndmp9_pval, n_ent+1);

	if (!ent) {

		cb->n_error++;

		return -1;

	}

	for (i = 0; i < n_ent; i++) {

		ent[i] = (*pp)[i];

	}

	if (*pp) {

		NDMOS_API_FREE (*pp);

	}

	*pp = ent;

	*n_env = n_ent+1;

	ent += n_ent;

	NDMOS_MACRO_ZEROFILL (ent);

	ent->name = NDMOS_API_STRDUP (name);

	ent->value = NDMOS_API_STRDUP (value);

	return 0;

}

#ifdef SELF_TEST

int

main (int argc, char *argv[])

{

	ndmp9_config_info	config_info;

	int			rc, i, j, k;

	if (argc != 2) {

		printf ("usage: %s FILE\n", argv[0]);

		return 1;

	}

	NDMOS_MACRO_ZEROFILL (&config_info);

	rc = ndmcfg_load (argv[1], &config_info);

	printf ("%d errors\n", rc);

	for (i = 0; i < config_info.butype_info.butype_info_len; i++) {

		ndmp9_butype_info *	bu;

		bu = &config_info.butype_info.butype_info_val[i];

		printf ("butype[%d] name='%s'\n", i, bu->butype_name);

		if (bu->v2attr.valid) {

			printf ("  v2attr 0x%x\n", bu->v2attr.value);

		} else {

			printf ("  v2attr -invalid-\n");

		}

		if (bu->v3attr.valid) {

			printf ("  v3attr 0x%x\n", bu->v3attr.value);

		} else {

			printf ("  v3attr -invalid-\n");

		}

		if (bu->v4attr.valid) {

			printf ("  v4attr 0x%x\n", bu->v4attr.value);

		} else {

			printf ("  v4attr -invalid-\n");

		}

		for (j = 0; j < bu->default_env.default_env_len; j++) {

			ndmp9_pval *	env;

			env = &bu->default_env.default_env_val[j];

			printf ("  default_env[%d] '%s'='%s'\n",

				j, env->name, env->value);

		}

	}

	for (i = 0; i < config_info.fs_info.fs_info_len; i++) {

		ndmp9_fs_info *	fs;

		fs = &config_info.fs_info.fs_info_val[i];

		printf ("fs[%d] fs_logical_device='%s'\n",

			 i, fs->fs_logical_device);

		if (fs->fs_physical_device) {

			printf ("  fs_physical_device '%s'\n",

				fs->fs_physical_device);

		} else {

			printf ("  fs_physical_device -null-\n");

		}

		if (fs->fs_type) {

			printf ("  fs_type '%s'\n", fs->fs_type);

		} else {

			printf ("  fs_type -null-\n");

		}

		if (fs->fs_status) {

			printf ("  fs_status '%s'\n", fs->fs_status);

		} else {

			printf ("  fs_status -null-\n");

		}

		if (fs->total_size.valid) {

			printf ("  total_size %llu\n", fs->total_size.value);

		} else {

			printf ("  total_size -invalid-\n");

		}

		if (fs->used_size.valid) {

			printf ("  used_size %llu\n", fs->used_size.value);

		} else {

			printf ("  used_size -invalid-\n");

		}

		if (fs->avail_size.valid) {

			printf ("  avail_size %llu\n", fs->avail_size.value);

		} else {

			printf ("  avail_size -invalid-\n");

		}

		if (fs->total_inodes.valid) {

			printf ("  total_inodes %llu\n",

				fs->total_inodes.value);

		} else {

			printf ("  total_inodes -invalid-\n");

		}

		if (fs->used_inodes.valid) {

			printf ("  used_inodes %llu\n", fs->used_inodes.value);

		} else {

			printf ("  used_inodes -invalid-\n");

		}

		for (j = 0; j < fs->fs_env.fs_env_len; j++) {

			ndmp9_pval *	env;

			env = &fs->fs_env.fs_env_val[j];

			printf ("  fs_env[%d] '%s'='%s'\n",

				j, env->name, env->value);

		}

	}

	for (i = 0; i < config_info.tape_info.tape_info_len; i++) {

		ndmp9_device_info *	dev;

		dev = &config_info.tape_info.tape_info_val[i];

		printf ("tape[%d] model='%s'\n", i, dev->model);

		for (j = 0; j < dev->caplist.caplist_len; j++) {

			struct ndmp9_device_capability *dcap;

			dcap = &dev->caplist.caplist_val[j];

			printf (" capability %d\n", j);

			if (dcap->device) {

				printf ("  device '%s'\n", dcap->device);

			} else {

				printf ("  device -null-\n");

			}

			if (dcap->v3attr.valid) {

				printf ("  v3attr 0x%x\n", dcap->v3attr.value);

			} else {

				printf ("  v3attr -invalid-\n");

			}

			if (dcap->v4attr.valid) {

				printf ("  v4attr 0x%x\n", dcap->v4attr.value);

			} else {

				printf ("  v4attr -invalid-\n");

			}

			k = 0;

			for (; k < dcap->capability.capability_len; k++) {

				ndmp9_pval *env;

				env = &dcap->capability.capability_val[k];

				printf ("  capability[%d] '%s'='%s'\n",

					k, env->name, env->value);

			}

		}

	}

	for (i = 0; i < config_info.scsi_info.scsi_info_len; i++) {

		ndmp9_device_info *	dev;

		dev = &config_info.scsi_info.scsi_info_val[i];

		printf ("scsi[%d] model='%s'\n", i, dev->model);

		for (j = 0; j < dev->caplist.caplist_len; j++) {

			struct ndmp9_device_capability *dcap;

			dcap = &dev->caplist.caplist_val[j];

			printf (" capability %d\n", j);

			if (dcap->device) {

				printf ("  device '%s'\n", dcap->device);

			} else {

				printf ("  device -null-\n");

			}

			if (dcap->v3attr.valid) {

				printf ("  v3attr 0x%x\n", dcap->v3attr.value);

			} else {

				printf ("  v3attr -invalid-\n");

			}

			if (dcap->v4attr.valid) {

				printf ("  v4attr 0x%x\n", dcap->v4attr.value);

			} else {

				printf ("  v4attr -invalid-\n");

			}

			k = 0;

			for (; k < dcap->capability.capability_len; k++) {

				ndmp9_pval *env;

				env = &dcap->capability.capability_val[k];

				printf ("  capability[%d] '%s'='%s'\n",

					k, env->name, env->value);

			}

		}

	}

	return 0;

}

#endif /* SELF_TEST */