xref: /titanic_51/usr/src/lib/libdscfg/common/cfg.c (revision fcf3ce441efd61da9bb2884968af01cb7c1452cc)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (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 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <stdio.h>

#include <sys/types.h>
#include <sys/wait.h>
#include <stdio.h>
#include <sys/mnttab.h>
#include <sys/vtoc.h>
#include <errno.h>
#include <limits.h>
#include <fcntl.h>
#include <string.h>
#include <stdarg.h>
#include <strings.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/mman.h>
#include <sys/stat.h>

#include <locale.h>
#include <langinfo.h>
#include <libintl.h>
#include <stdarg.h>
#include <netdb.h>
#include <ctype.h>
#include <sys/stat.h>
#include <sys/utsname.h>

#include "cfg_impl.h"
#include "cfg.h"
#include "cfg_lockd.h"

#if 0
#define	DEBUG_CFGLIST
#define	DEBUG_EXTRA
#define	DEBUG_LIB
#define	DEBUG_NOISY
#define	DEBUG_OUT
#endif

#define	MAX_CFG		16	/* Max. number of lines in /etc/dscfg_format */
#define	MAX_SET		12	/* number of chars in a set name */


/* parser tree for config section */
static struct parser chead[MAX_CFG] = { NULL };
static int chead_loaded = 0;
static char	config_file[CFG_MAX_BUF];
static char	dectohex[] = { '0', '1', '2', '3', '4', '5', '6', '7',
				'8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
#define	CHARS_TO_ENCODE "=;\t "
#define	min(a, b) ((a) > (b) ? (b) : (a))

/* field to be sorted on in sorting routines */
static struct sortby_s {
	char section[CFG_MAX_KEY];
	char field[CFG_MAX_KEY];
	int offset;
	int comperror;
} sortby;

int	cfg_severity = 0;
char	*cfg_perror_str;
static int	cfg_read(cfp_t *);
static void	cfg_read_parser_config(cfp_t *);
static int	cfg_rdlock(CFGFILE *);
static int	cfg_wrlock(CFGFILE *);
static int	cfg_lockd;
void 		cfg_replace_lists(cfp_t *);
void		cfg_free_parser_tree();
void		cfg_invalidate_hsizes(int, const char *);
int		cfg_map_cfglists(cfp_t *);
int		cfg_hdrcmp(cfp_t *);
void		cfg_free_cfglist(cfp_t *);

extern cfg_io_t *cfg_block_io_provider(void);
extern cfg_io_t *cfg_raw_io_provider(void);
extern int cl_initialized;

#ifdef DEBUG_LIB
static void
dump_status(cfp_t *cfp, char *str)
{
	printf("called from %s\n", str);
	printf(gettext("Header info:\n"
		"\tmagic: %x\tstate: %x\n"),
		cfp->cf_head->h_magic, cfp->cf_head->h_state);
	printf(gettext("Parser section:\n"
		"Start: %x\tsize: %d\toffset: %d\n"),
		cfp->cf_mapped, cfp->cf_head->h_parsesize,
		cfp->cf_head->h_parseoff);
	printf(gettext("Config section:\n"
		"Start: %x\tsize:%d\tacsize: %d\n"),
		cfp->cf_head->h_cparse, cfp->cf_head->h_csize,
		cfp->cf_head->h_acsize);
	printf("\n\tccopy1: %x\tccopy2: %x\n",
		cfp->cf_head->h_ccopy1, cfp->cf_head->h_ccopy2);
	printf(gettext("Sequence:\n"
		"\tseq1: %d\t\tseq2: %d\n"),
		cfp->cf_head->h_seq1, cfp->cf_head->h_seq2);
}
#endif /* DEBUG */

/*
 * cfg_get_item
 * return position from parser config given tag and field
 */
static int
cfg_get_item(struct parser *tbl, const char *tag, const char *field)
{
	int i;
	struct lookup *p;

	for (i = 0; i < MAX_CFG; i++) {
		/* only as many lists as defined */
		if (tbl[i].tag.l_word[0] == '\0') {
			i = MAX_CFG;
			break;
		}
		if (strcmp(tbl[i].tag.l_word, tag) == 0)
			break;
	}

	/* Handle table size */
	if (i < MAX_CFG) {
		p = tbl[i].fld;
		while (p) {
			if (strcmp(p->l_word, field) == 0)
				return (p->l_value);
			p = p->l_next;
		}
	}

	/* Handle failure */
	return (-1);
}

/*
 * cfg_get_num_flds
 * return number of fields for given parser tag
 */
static int
cfg_get_num_flds(struct parser *tbl, const char *tag, int *table_index)
{
	int i;
	int pos = 0;
	struct lookup *p;

	for (i = 0; i < MAX_CFG; i++) {
		/* only as many lists as defined */
		if (tbl[i].tag.l_word[0] == '\0') {
			i = MAX_CFG;
			break;
		}
		if (strcmp(tbl[i].tag.l_word, tag) == 0) {
			*table_index = i;
			break;
		}
	}

	/* Handle table size */
	if (i < MAX_CFG) {
		p = tbl[i].fld;
		while (p) {
			pos++;
			p = p->l_next;
		}
		return (pos);
	}

	return (0);
}

/*
 * count white space fields
 */
static int
cfg_cnt_flds(char *value)
{
	char *ptr;
	char buf[CFG_MAX_BUF];
	int flds = 0;

	if ((value == NULL) || (strlen(value) >= CFG_MAX_BUF))
		return (0);

	bzero(buf, CFG_MAX_BUF);
	strcpy(buf, value);
	ptr = strtok(buf, " ");
	while (ptr) {
		flds++;
		ptr = strtok(NULL, " ");
	}
	return (flds);
}

/*
 * cfg_get_parser_offset
 * returns the index for each
 * section of the parser..
 * ie. parser info for sndr is chead[3].tag.l_word
 * this will help us find sndr quicker, as the
 * the memory picture of the sets mimic this ordering
 */
static int
cfg_get_parser_offset(const char *section)
{
	int i;

	for (i = 0; i < MAX_CFG; i++) {
		/* only as many lists as defined */
		if (chead[i].tag.l_word[0] == '\0') {
			i = MAX_CFG;
			break;
		}
		if (strcmp(chead[i].tag.l_word, section) == 0)
			break;
	}

	/* Handle table size */
	if (i < MAX_CFG)
		return (i);

	/* Handle failure */
	cfg_perror_str = dgettext("cfg",
		"cfg_get_parser_offset: section not found");
	cfg_severity = CFG_EFATAL;
	errno = ESRCH;
	return (-1);
}

/*
 * cfg_fld_mov
 * move fields from old buffer to new
 * moving only specified fields
 * concates newbuf
 * returns fields moved
 */
static int
cfg_fld_mov(char *newbuf, char *oldbuf, int start, int end)
{
	char buf[CFG_MAX_BUF];
	char *ptr;
	int flds = 0;

	bzero(buf, CFG_MAX_BUF);
	if (oldbuf == NULL)
		return (0);

	if ((start > end) || (strlen(oldbuf) >= CFG_MAX_BUF)) {
		return (0);
	}
	if (!start || !end)
		return (-1);
	strcpy(buf, oldbuf);
	ptr = strtok(buf, " ");
	while (ptr) {
		flds++;
		if (flds >= start && flds <= end) {
			strcat(newbuf, ptr);
			strcat(newbuf, " ");
		}
		ptr = strtok(NULL, " ");
	}

	return (flds);
}

/*
 * cfg_filter_node
 * return indication if this raw buf should be returned
 * checks cfg->cf_node for filtering
 * We already know that this buf meets most of our criteria
 * find the cnode field in the buf and see if it matches
 * returns
 * 	TRUE	Good entry
 * 	FALSE	Don't use it
 */
static int
cfg_filter_node(CFGFILE *cfg, struct parser *tbl, char *buf, char *tag)
{
	char tmpbuf[CFG_MAX_BUF];
	int i = 1;
	int fld;
	char *ptr;

	if (!cfg->cf_node)		/* no filter always good */
		return (TRUE);
	bzero(tmpbuf, CFG_MAX_BUF);
	fld = cfg_get_item(tbl, tag, "cnode");
	if (fld < 0)	/* no cnode field always good */
		return (TRUE);
	strncpy(tmpbuf, buf, CFG_MAX_BUF);
	if (tmpbuf[CFG_MAX_BUF - 1] != '\0')
		return (FALSE);
	ptr = strtok(tmpbuf, " ");
	while (ptr && (i < fld)) {
		ptr = strtok(NULL, " ");
		i++;
	}
	if (!ptr)
		return (FALSE);
#ifdef DEBUG_EXTRA
	(void) fprintf(stderr, "cfg_filter_node: node=%s:%d cnode=%s:%d\n",
	    cfg->cf_node, strlen(cfg->cf_node), ptr, strlen(ptr));
#endif
	if (strcmp(ptr, cfg->cf_node) == 0)
		return (TRUE);
	return (FALSE);
}
/*
 * cfg_insert_node
 * insert resource in bufs which contain cnode parser field
 */
static void
cfg_insert_node(CFGFILE *cfg, struct parser *tbl, char *buf, char *tag)
{
	char tmpbuf[CFG_MAX_BUF];
	int fld;
	int nflds;
	int table_index;

	bzero(tmpbuf, CFG_MAX_BUF);
	strcpy(tmpbuf, " ");
	fld = cfg_get_item(tbl, tag, "cnode");
	nflds = cfg_get_num_flds(tbl, tag, &table_index);
	if ((fld < 0) && !(cfg->cf_node))	/* no cnode field always good */
		return;

	cfg_fld_mov(tmpbuf, buf, 1, (fld - 1));
	if (cfg->cf_node)
		strcat(tmpbuf, cfg->cf_node);
	else
		strcat(tmpbuf, "-");
	strcat(tmpbuf, " ");
	cfg_fld_mov(tmpbuf, buf, (fld + 1), nflds);
	bcopy(tmpbuf, buf, strlen(tmpbuf) + 1);
}

/*
 * cfg_is_cnode
 * Parser current buffer to see if a non-empty " - " cnode exists
 */
/*ARGSUSED*/
static int
cfg_is_cnode(CFGFILE *cfg, struct parser *tbl, char *buf, char *tag)
{
	char tmpbuf[CFG_MAX_BUF];
	int fld = cfg_get_item(tbl, tag, "cnode");

	if (fld >= 0) {
		tmpbuf[0] = '\0';
		cfg_fld_mov(tmpbuf, buf, fld, fld);
		return (strcmp(tmpbuf, "- ") ? TRUE : FALSE);
	}
	return (FALSE);
}
/*
 * cfg_get_cstring
 * key determines section and value
 * special considerations:
 * AA.BB.CC...
 * AA = data service tag
 * BB = set number relative to first set (1..n)
 * CC = field of set or if absent, all
 */
int
cfg_get_cstring(CFGFILE *cfg, const char *key, void *value, int value_len)
{
	cfp_t *cfp;
	char buf[CFG_MAX_BUF];
	char tmpkey[CFG_MAX_KEY];
	char *section;
	char set[MAX_SET];
	char *setp;
	char *itemp;
	char *p;
	int pos = 1;
	int setnum;
	int relnum;
	int secnum;
	int numfound;
	int needed;
	int table_offset;

	if (cfg == NULL) {
		cfg_perror_str = dgettext("cfg", CFG_EINVAL);
		cfg_severity = CFG_EFATAL;
		return (-1);
	}

	if (!cfg_rdlock(cfg)) {
		cfg_perror_str = dgettext("cfg", CFG_NOTLOCKED);
		cfg_severity = CFG_EFATAL;
		return (-1);
	}

	bzero(buf, sizeof (buf));
	bzero(set, sizeof (set));
	bzero(tmpkey, sizeof (tmpkey));
	strcpy(tmpkey, key);
	section = strtok(tmpkey, ".");
	setp = strtok(NULL, ".");
	itemp = strtok(NULL, ".");

#ifdef DEBUG_EXTRA
	if (!itemp)
		(void) fprintf(stderr, "cfg_get_cstring:section:%s setp=%s\n",
		    section, setp);
	else
		(void) fprintf(stderr,
		    "cfg_get_cstring:section:%s setp=%s fld=%s\n",
		    section, setp, itemp);
#endif

	table_offset = cfg_get_parser_offset(section);
	setnum = atoi(setp + 3);
	if ((setnum < 1) || (setnum > 0x7ffd)) {
		errno = EINVAL;
		cfg_perror_str = dgettext("cfg", CFG_EINVAL);
		cfg_severity = CFG_ENONFATAL;
		return (-1);
	}

	/*
	 * we have to figure out where this set is
	 * in relation to other sets
	 */
	relnum = 1;
	secnum = 0;
	numfound = 0;
	for (cfp = &cfg->cf[0]; cfp <= &cfg->cf[1]; cfp++) {
		if (!cfp->cf_fd) continue;
		if (cfp->cf_head->h_state & CFG_HDR_INVALID) {
			if (!cfg_read(cfp)) {
				cfg_perror_str = dgettext("cfg", CFG_RDFAILED);
				cfg_severity = CFG_EFATAL;
				return (-1);
			}
		}
		while (numfound < setnum) {
			if ((*cfp->cf_pp->readcf)
			    (cfp, buf, table_offset, relnum - secnum) == NULL) {
				secnum = relnum - 1;
				break;
			}
			if (cfg_filter_node(cfg, &chead[0], buf, section))
				numfound++;

			if (numfound == setnum)
				break;

			relnum++;
		}
		if (numfound == setnum)
			break;
	}

	/* Fail to find anything? */
	if (cfp >= &cfg->cf[2]) {
		errno = ESRCH;
		cfg_perror_str = dgettext("cfg", strerror(errno));
		cfg_severity = CFG_ENONFATAL;
		return (-1);
	}

	if (buf) {
		if (!itemp) {
			strncpy(value, buf, value_len);
			return (0);
		}

		if (itemp) {
			needed = cfg_get_item(&chead[0], section, itemp);
			p = strtok(buf, " ");
			while (p) {
				if (needed == pos) {
					errno = 0;
					if (*p == '-') {
						strcpy(value, "");
						return (0);
					}
					else
						if (strlen(p) > value_len) {
							errno = E2BIG;
							cfg_perror_str =
							dgettext("cfg",
							strerror(errno));
							cfg_severity =
							CFG_ENONFATAL;
							return (-1);
						}

						strncpy(value, p, value_len);

					return (pos);
				}
				p = strtok(NULL, " ");
				if (!p)
					break;
				pos++;
			}
		}
	}
	errno = ESRCH;
	cfg_perror_str = dgettext("cfg", strerror(errno));
	cfg_severity = CFG_ENONFATAL;
	return (-1);
}

/*
 * cfg_find_cstring()
 * search for a string in the specified section
 * in the specified field(s)
 * if nfld is 0, then the string is searched for in
 * every field of the entry
 * the set number of the first occurence of target is returned
 * ie. if /dev/vx/rdsk/vol10 is found in sndr.set9, 9 will be returned
 * that is, of course, if the correct field was searched on.
 * -1 on error
 *
 */
int
cfg_find_cstring(CFGFILE *cfg, const char *target,
    const char *section, int numflds, ...) {

	char **list = NULL;
	va_list ap;
	char buf[CFG_MAX_BUF];
	char *field, *p;
	char **fldbuf = NULL;
	int i, j, rc;
	int pos = 1;
	int fieldnum;
	int nflds;
	int tbl_off;

	if (cfg == NULL) {
		cfg_perror_str = dgettext("cfg", CFG_EINVAL);
		cfg_severity = CFG_EFATAL;
		return (-1);
	}

	if (numflds == 0) {
		nflds = cfg_get_num_flds(&chead[0], section, &tbl_off);

	} else {
		nflds = numflds;
	}
	if ((fldbuf = calloc(nflds, CFG_MAX_KEY)) == NULL) {
		cfg_perror_str = dgettext("cfg", strerror(errno));
		cfg_severity = CFG_EFATAL;
		return (-1);
	}

	if (numflds == 0) { /* search the whole string */
		if ((rc = cfg_get_section(cfg, &list, section)) <= 0) {
			for (i = 0; i < nflds; i++)
				free(fldbuf[i]);
			free(fldbuf);
			return (rc);
		}
		for (i = 0; i < rc; i++) {
			bzero(buf, sizeof (buf));
			strcpy(buf, list[i]);
			p = strtok(buf, " ");
			while (p) {
				if (strcmp(p, target) == 0) { /* we found it! */
					for (j = 0; j < rc; j++)
						free(list[j]);
					free(list);
					for (j = 0; j < nflds; j++)
						free(fldbuf[j]);
					free(fldbuf);
					return (i + 1);
				}
			p = strtok(NULL, " ");
			}
		}
		for (i = 0; i < nflds; i++)
			free(fldbuf[j]);
		for (i = 0; i < rc; i++)
			free(list[i]);
		free(fldbuf);
		free(list);
		return (0);
	}

	if ((rc = cfg_get_section(cfg, &list, section)) <= 0) {
		for (i = 0; i < nflds; i++)
			free(fldbuf[i]);
		free(fldbuf);
		return (rc);
	}

	va_start(ap, numflds);
	for (i = 0; i < numflds; i++) {
		fldbuf[i] = strdup(va_arg(ap, char *));
	}

	fldbuf[i] = NULL;

	for (j = 0; j < numflds; j++) {
		fieldnum = cfg_get_item(&chead[0], section, fldbuf[j]);
		for (i = 0; i < rc; i++) {
			bzero(buf, sizeof (buf));
			strcpy(buf, list[i]);

			field = strtok(buf, " ");
			pos = 1;
			while (pos < fieldnum) {
				field = strtok(NULL, " ");
				pos++;
			}
			if (field == NULL) {
				for (j = 0; j < numflds; j++)
					free(fldbuf[j]);
				for (j = 0; j < rc; j++)
					free(list[j]);
				free(fldbuf);
				free(list);
				return (-1);
			}

			if (strcmp(field, target) == 0) {
				for (j = 0; j < numflds; j++)
					free(fldbuf[j]);
				for (j = 0; j < rc; j++)
					free(list[j]);
				free(fldbuf);
				free(list);

				return (i + 1);
			}

		}

	}
	for (i = 0; i < nflds; i++)
		free(fldbuf[i]);
	for (i = 0; i < rc; i++)
		free(list[i]);
	free(fldbuf);
	free(list);
	return (0);
}

/*
 * cfg_put_cstring
 * modify entry or add an entry to configuration section
 * Key syntax supported
 *	tag		Add entry (in entirely) to config
 * 	tag.setn	Add entry to setn If it exists overwrite old entry
 * 	tag.setn.field	Change field in setn
 * value
 *	string to change
 *	NULL	delete specified key
 *
 */

int
cfg_put_cstring(CFGFILE *cfg, const char *key,  void *value, int val_len)
{
	cfp_t *cfp;
	char buf[CFG_MAX_BUF];
	char newbuf[CFG_MAX_BUF];
	char *bufp;
	char tmpkey[CFG_MAX_KEY];
	char *section;
	char *setp;
	char *itemp;
	int nofield = 0;
	int noset = 0;
	int fldnum;
	int setnum = 0;
	int relnum;
	int secnum;
	int numfound;
	int addcnode = 1;
	int table_index;
	int table_offset;

	if (cfg == NULL) {
		cfg_perror_str = dgettext("cfg", CFG_EINVAL);
		cfg_severity = CFG_EFATAL;
		return (-1);
	}

	bzero(buf, sizeof (buf));
	strcpy(tmpkey, key);
	section = strtok(tmpkey, ".");
	setp = strtok(NULL, ".");
	itemp = strtok(NULL, ".");

	if (!cfg_wrlock(cfg)) {
		cfg_perror_str = dgettext("cfg", CFG_RDFAILED);
		cfg_severity = CFG_EFATAL;
		return (-1);
	}

	if (!key) {
		cfg_perror_str = dgettext("cfg", CFG_EINVAL);
		cfg_severity = CFG_ENONFATAL;
		return (-1);
	}
	if (value && val_len == 0) {
		cfg_perror_str = dgettext("cfg", CFG_EINVAL);
		cfg_severity = CFG_ENONFATAL;
		return (-1);
	}
	if (!itemp)
		nofield++;
	if (!setp)
		noset++;
	else if (setp) {
		setnum = atoi(setp + 3);
		if (setnum < 1 || setnum > 0x7ffd) {
			errno = EINVAL;
			cfg_perror_str = dgettext("cfg", CFG_EINVAL);
			cfg_severity = CFG_ENONFATAL;
			return (-1);
		}
	}

	table_offset = cfg_get_parser_offset(section);

	/*
	 * we have to figure out where this set is
	 * in relation to other sets
	 */
	relnum = 1;
	secnum = 0;
	numfound = 0;

	if (setp && nofield) {
		char tmpbuf[CFG_MAX_BUF];
		int rc;
		int nflds;
		int got;

		/*
		 * Set specified but no field
		 */
		for (cfp = &cfg->cf[0]; cfp <= &cfg->cf[1]; cfp++) {
			if (!cfp->cf_fd) continue;
			if (cfp->cf_head->h_state & CFG_HDR_INVALID) {
				if (!cfg_read(cfp)) {
					cfg_perror_str =
						dgettext("cfg", CFG_RDFAILED);
					cfg_severity = CFG_EFATAL;
					return (-1);
				}
			}
			while (numfound < setnum) {
				if ((*cfp->cf_pp->readcf)
				    (cfp, tmpbuf, table_offset, relnum - secnum)
				    == NULL) {
					secnum = relnum - 1;
					break;
				}
				if (cfg_filter_node(cfg, &chead[0], tmpbuf,
					section))
					numfound++;

				if (numfound == setnum)
					break;

				relnum++;
			}
			if (numfound == setnum)
				break;
		}

		/* Fail to find anything? */
		if (cfp >= &cfg->cf[2]) {
			errno = ESRCH;
			cfg_perror_str = dgettext("cfg", strerror(errno));
			cfg_severity = CFG_ENONFATAL;
			return (-1);
		}

		nflds = cfg_get_num_flds(&chead[0], section, &table_index);

		if (value == NULL) {
			/* Remove entry completely */

			if ((rc = ((*cfp->cf_pp->remcf)
				    (cfp, table_index, relnum - secnum))) < 0)
				return (rc);
			return (0);
		}

		got = cfg_cnt_flds(value);
		bzero(buf, sizeof (buf));

		strncpy(buf, " ", 1);
		if (strlen(value) > sizeof (buf) - 2) {
			errno = E2BIG;
			cfg_perror_str = dgettext("cfg", strerror(errno));
			cfg_severity = CFG_ENONFATAL;
			return (-1);
		}
		strncat(buf, value, val_len);
		if (got < nflds) {
			for (/* CSTYLED */; got < nflds; got++)
				strncat(buf, " - ", 3);
		} else if (got > nflds) {
			return (-1);
		} else {
			/* got == nflds, so cnode was included */
			addcnode = 0;
		}

		bufp = buf;
		if (addcnode) {
			cfg_insert_node(cfg, &chead[0], buf, section);
		}

		(*cfp->cf_pp->replacecf)
			(cfp, bufp, table_index, relnum - secnum);

		return (TRUE);
	}

	/*
	 * Both Set and field are specified
	 * needs to get current whole entry and old requested field
	 * copy good fields to buf, replace new field in buf
	 * move everything depending of new size
	 * replace entry so set# does not change
	 */
	if (setp && itemp) {
		int rc;
		int nflds;
		int cnodepos;

		for (cfp = &cfg->cf[0]; cfp <= &cfg->cf[1]; cfp++) {
			if (!cfp->cf_fd) continue;
			if (cfp->cf_head->h_state & CFG_HDR_INVALID) {
				if (!cfg_read(cfp)) {
					cfg_perror_str =
						dgettext("cfg", CFG_RDFAILED);
					cfg_severity = CFG_EFATAL;
					return (-1);
				}
			}
			while (numfound < setnum) {
				if ((*cfp->cf_pp->readcf)
				    (cfp, buf, table_offset, relnum - secnum)
				    == NULL) {
					secnum = relnum - 1;
					break;
				}
				if (cfg_filter_node(cfg, &chead[0], buf,
					section))
					numfound++;

				if (numfound == setnum)
					break;

				relnum++;
			}
			if (numfound == setnum)
				break;
		}

		/* Fail to find anything? */
		if (cfp >= &cfg->cf[2]) {
			errno = ESRCH;
			cfg_perror_str = dgettext("cfg", strerror(errno));
			cfg_severity = CFG_ENONFATAL;
			return (-1);
		}

		nflds = cfg_get_num_flds(&chead[0], section, &table_index);
		fldnum = cfg_get_item(&chead[0], section, itemp);
		bzero(newbuf, sizeof (newbuf));
		strncpy(newbuf, " ", 1);

		/* move good flds in */
		rc = cfg_fld_mov(newbuf, buf, 1, fldnum - 1);
		if (rc < 0)
			return (rc);

		/* move new fld in */
		strncat(newbuf, value, strlen(value));
		strcat(newbuf, " ");

		/* move remaining flds in */
		rc = cfg_fld_mov(newbuf, buf, fldnum + 1, nflds);
		if (rc < 0)
			return (rc);

		cnodepos = cfg_get_item(&chead[0], section, "cnode");
		if ((cnodepos >= 0) && strcmp(itemp, "cnode") != 0) {
			/* add cnode if user didn't specify it */
			cfg_insert_node(cfg, &chead[0],
			    newbuf, section);
		}

		(*cfp->cf_pp->replacecf)
			(cfp, newbuf, table_index, relnum - secnum);

		return (TRUE);
	}

	if (noset) {	/* blast entire thing in */
		int nflds;
		int got;
		int cnodepos;

		bufp = buf;
		if (!value) { /* we shouldn't be here */
			errno = EINVAL;
			return (-1);
		}
		strncat(buf, " ", 1);
		if (strlen(value) > sizeof (buf) - 2) {
			errno = E2BIG;
			return (-1);
		}

		strncat(buf, value, val_len);
		nflds = cfg_get_num_flds(&chead[0], section, &table_index);
		got = cfg_cnt_flds(value);

		cnodepos = cfg_get_item(&chead[0], section, "cnode");
		if (cnodepos < 0 || got >= cnodepos) {
			/* no cnode, or cnode was specified by caller */
			addcnode = 0;
		}

		if (got < nflds) {
			for (/* CSTYLED */; got < nflds; got++)
				strncat(buf, " - ", 3);
		} else if (got > nflds) {
			errno = EINVAL; /* specified too many fields */
			return (-1);
		} else {
			/* got == nflds, so cnode was included */
			addcnode = 0;
		}

		if (addcnode) {
			cfg_insert_node(cfg, &chead[0], buf, section);
		}

		/* Make sure we put this entry in the right database */
		if (cfg_is_cnode(cfg, &chead[0], buf, section) &&
		    cfg->cf[1].cf_fd)
			cfp = &cfg->cf[1];
		else
			cfp = &cfg->cf[0];

		if (cfp->cf_head->h_state & CFG_HDR_INVALID) {
			if (!cfg_read(cfp)) {
				cfg_perror_str = dgettext("cfg", CFG_RDFAILED);
				cfg_severity = CFG_EFATAL;
				return (-1);
			}
		}
		if (cfp->cf_head->h_csize + strlen(buf) > CFG_DEFAULT_SSIZE) {
			errno = ENOSPC;
			return (-1);
		}

		(*cfp->cf_pp->addcf)(cfp, bufp, table_index);

		return (TRUE);
	}

	errno = EINVAL;
	cfg_perror_str = strerror(errno);
	cfg_severity = CFG_ENONFATAL;
	return (-1);
}

/*
 * cfg_encode_char
 *
 *	Encode a single character into % + hex ascii value
 */
static void
cfg_encode_char(char *result, char ch)
{
	*result++ = '%';
	*result++ = dectohex[ (ch >> 4) & 0xf ];
	*result++ = dectohex[ ch & 0xf ];
}

/*
 * cfg_decode_char
 *
 *	Reverses cfg_encode_char
 */
static char
cfg_decode_char(char *code)
{
	char retval;
	if (*code != '%') {
		return ('\0');
	}
	++code;
	if (!isxdigit(*code))
		return ('\0');
	retval = (isdigit(*code)? *code - '0' : *code - 'a' + 10);
	retval <<= 4;
	++code;
	if (!isxdigit(*code))
		return ('\0');
	retval |= (isdigit(*code)? *code - '0' : *code - 'a' + 10);

	return (retval);
}

/*
 * cfg_encode_option
 *
 *	Transforms the key and value strings so that special characters
 *	can be used within the options field.
 *
 * Returns:
 *	Length of encoded string; -1 on failure
 */
static int
cfg_encode_string(char *str, char *output, int outlen)
{
	char *mem, *p, *q;
	int curlen;


	/* first, scan through the tag string converting %-signs */
	p = str;
	q = output;
	curlen = 0;
	while (*p && curlen < outlen) {
		if (*p == '%') {
			if (curlen + 3 >= outlen) {
				return (-1);
			}
			cfg_encode_char(q, *p);
			curlen += 3;
			q += 3;
		} else {
			*q++ = *p;
			++curlen;
		}
		++p;
	}
	if (curlen < outlen)
		*q = '\0';

	/* now encode special characters */
	p = mem = strdup(output);
	q = output;
	curlen = 0;
	while (*p && curlen < outlen) {
		if (strchr(CHARS_TO_ENCODE, *p) != 0) {
			if (curlen + 3 >= outlen) {
				free(mem);
				return (-1);
			}
			cfg_encode_char(q, *p);
			curlen += 3;
			q += 3;
		} else {
			*q++ = *p;
			++curlen;
		}
		++p;
	}
	free(mem);

	if (curlen < outlen)
		*q = '\0';
	/* LINTED possible ptrdiff_t overflow */
	return (q - output);
}

/*
 * cfg_decode_option
 *
 *	Given a string, decodes any %-encodes on it.
 */
static void
cfg_decode_string(char *str, char *output, int outlen)
{
	char *p, *q;
	int curlen;

	p = str;
	q = output;
	curlen = 0;
	while (*p && curlen < outlen) {
		if (*p == '%') {
			char ch = cfg_decode_char(p);
			if (!ch) {
				*q++ = *p++;
				++curlen;
			} else {
				*q++ = ch;
				p += 3;
				++curlen;
			}
		} else {
			*q++ = *p++;
			++curlen;
		}
	}
	if (curlen < outlen)
		*q = '\0';
}

/*
 * cfg_get_options
 * return first options set from basekey
 * Subsequent calls with basekey = NULL return next option if any
 * into tag and val
 * returns
 *	true 	success and more options data
 *	-1 	no options data
 */

int
cfg_get_options(CFGFILE *cfg, int section, const char *basekey, char *tag,
    int tag_len, char *val, int val_len)
{
	static char buf[CFG_MAX_BUF];
	char decode_buf[CFG_MAX_BUF];
	int rc;
	char *ttag, *tval;

	if (cfg == NULL) {
		cfg_perror_str = dgettext("cfg", CFG_EINVAL);
		cfg_severity = CFG_EFATAL;
		return (-1);
	}

	errno = ENOSYS;
	if (basekey == 0) {
		ttag = strtok(NULL, "=");
	} else {
		bzero(buf, CFG_MAX_BUF);
		if (section == CFG_SEC_CONF) {
			rc = cfg_get_cstring(cfg, basekey, buf, CFG_MAX_BUF);
		} else
			return (-1);
		if (rc < 0)
			return (rc);
		/* buf now contains raw options data */
		ttag = strtok(buf, "=");
	}
	tval = strtok(NULL, ";");
	if (!(tval) || !(ttag))
		return (-1);
	if ((strlen(tval) > val_len) || (strlen(ttag) > tag_len)) {
		errno = E2BIG;
		return (-1);
	}
	cfg_decode_string(tval, decode_buf, CFG_MAX_BUF);
	strncpy(val, decode_buf, val_len);
	cfg_decode_string(ttag, decode_buf, CFG_MAX_BUF);
	strncpy(tag, decode_buf, tag_len);
	errno = 0;
	return (TRUE);
}

/*
 * cfg_put_options
 *
 *	Replaces existing tag with new val.  If tag doesn't exist,
 *	then it adds a new tag with the specified val.
 *
 * Return:
 *	true	success
 *	-1	incorrect section, or read error from cfg DB
 */
int
cfg_put_options(CFGFILE *cfg, int section, const char *basekey, char *tag,
    char *val)
{
	char buf[CFG_MAX_BUF];
	char encode_buf[CFG_MAX_BUF];
	char *p;
	int enclen;

	if (cfg == NULL) {
		cfg_perror_str = dgettext("cfg", CFG_EINVAL);
		cfg_severity = CFG_EFATAL;
		return (-1);
	}

	errno = ENOSYS;
	bzero(buf, CFG_MAX_BUF);
	if (section != CFG_SEC_CONF) {
		cfg_severity = CFG_ENONFATAL;
		cfg_perror_str = dgettext("cfg", CFG_EINVAL);
		return (-1);
	}
	if (!tag || !*tag || !val || !*val)
		return (-1);
	if (cfg_get_cstring(cfg, basekey, buf, CFG_MAX_BUF) < 0) {
		/* cfg severity & perror_str set up cfg_get_cstring() */
		return (-1);
	}
	*encode_buf = ';';
	enclen = cfg_encode_string(tag, &encode_buf[1], CFG_MAX_BUF - 1) + 1;
	if (enclen < 1 || (enclen + 1) >= CFG_MAX_BUF) {
		cfg_severity = CFG_ENONFATAL;
		cfg_perror_str = dgettext("cfg", "Buffer too small");
		return (-1);
	}
	encode_buf[enclen] = '=';
	encode_buf[enclen + 1] = '\0';

	/* check the start of the string */
	if (strncmp(buf, &encode_buf[1], enclen) == 0) {
		/* locate the end of this option */
		p = strchr(buf, ';');
		if (p && *(p + 1) != '\0') {
			/* add the new tag to the end */
			++p;
			strcat(p, &encode_buf[1]);
		} else {
			/* completely overwrite the existing tag */
			p = buf;
			strcpy(p, &encode_buf[1]);
		}
		if (cfg_encode_string(val, encode_buf, CFG_MAX_BUF) < 0) {
			cfg_severity = CFG_ENONFATAL;
			cfg_perror_str = dgettext("cfg", "Buffer too small");
			return (-1);
		}
		strcat(p, encode_buf);
		strcat(p, ";");
		if (cfg_put_cstring(cfg, basekey, p, strlen(p)) < 0) {
			/* severity & perror_str set by cfg_put_cstring */
			return (-1);
		}
		errno = 0;
		return (TRUE);
	}

	/* it's hiding somewhere inside... */
	p = strstr(buf, encode_buf);
	if (p) {
		/* delete the old value */
		char *q = strchr(p + 1, ';');
		if (q) {
			strcpy(p + 1, q + 1);
		} else {
			*p = '\0';
		}
		strcat(buf, &encode_buf[1]);
	} else if (*buf) {
		strcat(buf, &encode_buf[1]);
	} else {
		strcpy(buf, &encode_buf[1]);
	}
	enclen = cfg_encode_string(val, encode_buf, CFG_MAX_BUF);
	if (enclen < 0 || (strlen(buf) + enclen) >= CFG_MAX_BUF) {
		cfg_severity = CFG_ENONFATAL;
		cfg_perror_str = dgettext("cfg", "Buffer too small");
		return (-1);
	}
	strcat(buf, encode_buf);
	strcat(buf, ";");
	if (cfg_put_cstring(cfg, basekey, buf, CFG_MAX_BUF) < 0) {
		/* severity & perror_str set by cfg_put_cstring */
		return (-1);
	}
	errno = 0;
	return (TRUE);
}

/*
 * cfg_get_single_option
 *
 *	Scans the options string for the specified option and returns
 *	the decoded value
 *
 * Return:
 *	true	success
 *	-1	incorrect section, or read error from cfg DB
 */
int
cfg_get_single_option(CFGFILE *cfg, int section, const char *basekey, char *tag,
    char *val, int val_len)
{
	char buf[CFG_MAX_BUF];
	char encode_buf[CFG_MAX_BUF];
	char *p, *q;
	int enclen;

	if (cfg == NULL) {
		cfg_perror_str = dgettext("cfg", CFG_EINVAL);
		cfg_severity = CFG_EFATAL;
		return (-1);
	}

	errno = ENOSYS;
	bzero(buf, CFG_MAX_BUF);
	if (section != CFG_SEC_CONF) {
		cfg_severity = CFG_ENONFATAL;
		cfg_perror_str = dgettext("cfg", CFG_EINVAL);
		return (-1);
	}
	if (cfg_get_cstring(cfg, basekey, buf, CFG_MAX_BUF) < 0) {
		/* severity & perror_str set by cfg_get_cstring */
		return (-1);
	}

	*encode_buf = ';';
	enclen = cfg_encode_string(tag, &encode_buf[1], CFG_MAX_BUF - 1) + 1;
	if (enclen < 1 || (enclen + 1) >= CFG_MAX_BUF) {
		cfg_severity = CFG_ENONFATAL;
		cfg_perror_str = dgettext("cfg", "Buffer too small");
		return (-1);
	}
	encode_buf[enclen] = '=';
	encode_buf[enclen + 1] = '\0';

	/* check the start of the string */
	if (strncmp(buf, &encode_buf[1], enclen) == 0) {
		p = strchr(buf, '=');
		if (!p) {
			cfg_severity = CFG_ENONFATAL;
			cfg_perror_str = dgettext("cfg", "Option not found");
			return (-1);
		}
		++p;
		q = strchr(p, ';');
		if (q) {
			*q = '\0';
		}
		cfg_decode_string(p, val, val_len);
		errno = 0;
		return (TRUE);
	}

	/* it's hiding somewhere inside... */
	p = strstr(buf, encode_buf);
	if (p) {
		p += enclen + 1;
		q = strchr(p, ';');
		if (q) {
			*q = '\0';
		}
		cfg_decode_string(p, val, val_len);
		errno = 0;
		return (TRUE);
	}

	/* key not found */
	return (-1);

}

/*
 * cfg_del_option
 *
 *	Removes a single key=val pair from the specified option field
 *
 * Return:
 *	true	success
 *	-1	unable to update config
 */
int
cfg_del_option(CFGFILE *cfg, int section, const char *basekey, char *tag)
{
	char buf[CFG_MAX_BUF];
	char encode_buf[CFG_MAX_BUF];
	char *p, *q;
	int enclen, rc;

	if (cfg == NULL) {
		cfg_perror_str = dgettext("cfg", CFG_EINVAL);
		cfg_severity = CFG_EFATAL;
		return (-1);
	}

	bzero(buf, CFG_MAX_BUF);
	if (section != CFG_SEC_CONF) {
		cfg_severity = CFG_ENONFATAL;
		cfg_perror_str = dgettext("cfg", CFG_EINVAL);
		return (-1);
	}
	if (cfg_get_cstring(cfg, basekey, buf, CFG_MAX_BUF) < 0) {
		/* severity & perror_str are set by cfg_get_cstring */
		return (-1);
	}

	*encode_buf = ';';
	enclen = cfg_encode_string(tag, &encode_buf[1], CFG_MAX_BUF - 1) + 1;
	if (enclen < 1 || (enclen + 1) >= CFG_MAX_BUF) {
		cfg_severity = CFG_ENONFATAL;
		cfg_perror_str = dgettext("cfg", "Buffer too small");
		return (-1);
	}
	encode_buf[enclen] = '=';
	encode_buf[enclen + 1] = '\0';

	/* check the start of the string */
	if (strncmp(buf, &encode_buf[1], enclen) == 0) {
		p = strchr(buf, ';');
		if (p && (*(p + 1) != '\0')) {
		    rc = cfg_put_cstring(cfg, basekey, p + 1, strlen(p + 1));
		} else {
		    rc = cfg_put_cstring(cfg, basekey, "-", 1);
		}
		/* severity & perror_str are set by cfg_put_cstring */
		return (rc);
	}

	/* sigh */
	p = strstr(buf, encode_buf);
	if (!p) {
		/* already removed */
		return (TRUE);
	}
	q = strchr(p + 1, ';');

	/*
	 * Now the string looks like:
	 *	| first few options | *p | option to remove | *q | rest | '\0'
	 */

	if (!q) {
		/* hum... */
		*p = '\0';
	} else {
		strcpy(p, q);
	}

	return (cfg_put_cstring(cfg, basekey, buf, strlen(buf)));
}

static void
cfg_set_memorymap(cfp_t *cfp)
{
	cfgheader_t *hd = cfp->cf_head;

#ifdef DEBUG_CFGLIST
	(void) fprintf(stderr, "callocing %d for initial reads\n", hd->h_csize);
#endif

	hd->h_ccopy1 = (char *)calloc(hd->h_csize, sizeof (char));
	hd->h_ccopy2 = (char *)calloc(hd->h_csize, sizeof (char));
	hd->h_sizes1 = (int *)calloc(CFG_DEFAULT_PSIZE, sizeof (int));
	hd->h_sizes2 = (int *)calloc(CFG_DEFAULT_PSIZE, sizeof (int));
}

/*
 * cfg_init_header
 * fill in default header info
 */
static void
cfg_init_header(cfp_t *cfp)
{
	time_t tloc;
	cfgheader_t *hd = cfp->cf_head;

	hd->h_magic = (int32_t)CFG_NEW_MAGIC;
	hd->h_stamp = time(&tloc);
	hd->h_lock = 0;
	/* parser config */
	hd->h_parsesize = 0;
	hd->h_parseoff = 0;
	hd->h_csize = 0;
	hd->h_psize = 0;
	hd->h_cfgs = NULL;
	hd->h_ncfgs = 0;
	hd->h_seq1 = hd->h_seq2 = 1;
	bzero(hd->h_cfgsizes, MAX_CFG * sizeof (int));
}
/*
 * cfg_read
 * read header and all sections of configuration file
 * gets new data for incore copy
 * removes invalid header state
 * works even if config and persistent sections are empty
 *
 */
static int
cfg_read(cfp_t *cfp)
{
	int rc;
	cfgheader_t *hd;
	int readsize = 0;
#ifdef DEBUG_CFGLIST
	(void) fprintf(stderr, "cfg_read\n");
#endif

	if (!cfp->cf_head) {
		if ((hd = calloc(1, sizeof (*hd))) == NULL)
			return (FALSE);
#ifdef DEBUG_HDR
			(void) fprintf(stderr, "initial cfg header read\n");
#endif
		cfp->cf_head = hd;
	}

	if ((*cfp->cf_pp->seek)(cfp, 0, SEEK_SET) < 0) {
#ifdef DEBUG_LIB
		(void) fprintf(stderr, "cfg: seek header failed\n");
#endif
		return (FALSE);
	}

	rc = (*cfp->cf_pp->read)(cfp, (char *)cfp->cf_head, 4);
	if (rc < 4) {
#ifdef DEBUG_LIB
		(void) fprintf(stderr, "cfg: read magic number failed\n");
#endif
		return (FALSE);
	}

	if ((*cfp->cf_pp->seek)(cfp, 0, SEEK_SET) < 0) {
#ifdef DEBUG_LIB
		(void) fprintf(stderr, "cfg: seek header failed\n");
#endif
		return (FALSE);
	}

	rc = (*cfp->cf_pp->read)(cfp, (char *)cfp->cf_head, sizeof (*hd));
	if (rc < sizeof (*hd)) {
#ifdef DEBUG_LIB
		(void) fprintf(stderr, "cfg: read header failed\n");
#endif
		return (FALSE);
	}

	cfp->cf_head->h_cfgs = NULL;
	cfg_set_memorymap(cfp);
	if (cfp->cf_head->h_magic != CFG_NEW_MAGIC) {
#ifdef DEBUG_LIB
		(void) fprintf(stderr, "cfg_read: wrong MAGIC number %x\n",
			cfp->cf_head->h_magic);
#endif
		return (FALSE);
	}

	cfp->cf_head->h_state &= ~(CFG_HDR_INVALID);

#ifdef DEBUG_CFGLIST
	(void) fprintf(stderr, "reading parser\n");
#endif
	rc = (*cfp->cf_pp->read)
		(cfp, (char *)cfp->cf_mapped, CFG_DEFAULT_PARSE_SIZE);
	if (rc < sizeof (*hd)) {
#ifdef DEBUG
		(void) fprintf(stderr, "cfg: read parse config failed\n");
#endif
		return (FALSE);
	}

	readsize = cfp->cf_head->h_csize;

#ifdef DEBUG_CFGLIST
	(void) fprintf(stderr, "reading copy1 readsize = %d\n", readsize);
#endif
	rc = (*cfp->cf_pp->read)
		(cfp, (char *)cfp->cf_head->h_ccopy1, readsize);
	if (rc < 0) {
		/* don't fail just return */
#ifdef DEBUG
		(void) fprintf(stderr, "cfg: read ccopy1 section failed\n");
#endif
		return (FALSE);
	}

	if ((*cfp->cf_pp->seek)
		(cfp, CFG_DEFAULT_SSIZE - rc, SEEK_CUR) < 0) {
#ifdef DEBUG
		(void) fprintf(stderr, "cfg: seek (SEEK_CUR) failed\n");
#endif
		return (FALSE);
	}

#ifdef DEBUG_CFGLIST
	(void) fprintf(stderr, "reading copy2 readsize = %d\n", readsize);
#endif

	rc = (*cfp->cf_pp->read)
		(cfp, (char *)cfp->cf_head->h_ccopy2, readsize);
	if (rc < 0) {
		/* don't fail just return */
#ifdef DEBUG
		(void) fprintf(stderr, "cfg: read ccopy2 section failed\n");
#endif
		return (FALSE);
	}

	/* read the sizes of the lists from disk  */
	if ((*cfp->cf_pp->seek)
		(cfp, CFG_DEFAULT_SSIZE - rc, SEEK_CUR) < 0) {
#ifdef DEBUG
		(void) fprintf(stderr, "cfg: seek (SEEK_CUR) failed\n");
#endif
		return (FALSE);
	}

#ifdef DEBUG_CFGLIST
	(void) fprintf(stderr, "reading sizes\n");
#endif
	rc = (*cfp->cf_pp->read)
		(cfp, (int *)cfp->cf_head->h_sizes1, CFG_DEFAULT_PSIZE);
	if (rc < 0) {
#ifdef DEBUG
		(void) fprintf(stderr, "cfg: read h_sizes1 failed\n");
#endif
		return (FALSE);
	}

	rc = (*cfp->cf_pp->read)
		(cfp, (int *)cfp->cf_head->h_sizes2, CFG_DEFAULT_PSIZE);
	if (rc < 0) {
#ifdef DEBUG
		(void) fprintf(stderr, "cfg: read h_sizes2 failed\n");
#endif
		return (FALSE);
	}

	/*
	 * If initial or invalid sequence, use first section
	 */
	if ((cfp->cf_head->h_seq1 <= 0) && (cfp->cf_head->h_seq2 <= 0)) {
		cfp->cf_head->h_cparse = cfp->cf_head->h_ccopy1;
		cfp->cf_head->h_sizes = cfp->cf_head->h_sizes1;
	}

	if (cfp->cf_head->h_seq1 >= cfp->cf_head->h_seq2) {
		cfp->cf_head->h_cparse = cfp->cf_head->h_ccopy1;
		cfp->cf_head->h_sizes = cfp->cf_head->h_sizes1;
	} else {
		cfp->cf_head->h_cparse = cfp->cf_head->h_ccopy2;
		cfp->cf_head->h_sizes = cfp->cf_head->h_sizes2;
	}

#ifdef DEBUG_LIB
	dump_status(cfp, "cfg_read");
#endif

	return (TRUE);
}

/*
 * cfg_lock
 * Read-write locking of the configuration
 * reads into core all sections
 * builds parser trees for each section
 * Returns: TRUE if the lock was acquired, FALSE otherwise.
 */
int
cfg_lock(CFGFILE *cfg, CFGLOCK mode)
{
	cfp_t *cfp;
	int is_locked = 0;
	int rc;

	if (cfg == NULL) {
		cfg_perror_str = dgettext("cfg", CFG_EINVAL);
		cfg_severity = CFG_EFATAL;
		return (FALSE);
	}

	if (mode == CFG_UPGRADE) {
		mode = CFG_WRLOCK;
	}

	if (mode == CFG_WRLOCK && (cfg->cf[0].cf_flag & CFG_RDONLY)) {
		goto fail;
	}

	/*
	 * if you don't even give me the right lock request,
	 * why should I give you one?
	 */
	if (mode != CFG_RDLOCK && mode != CFG_WRLOCK)
		goto fail;

	if (cfg_lockd) {
		if (mode == CFG_WRLOCK)
			cfg_lockd_wrlock();
		else
			cfg_lockd_rdlock();
		is_locked = 1;
	} else {

#ifdef DEBUG_CFGLIST
		(void) fprintf(stderr, "cfg_lock\n");
#endif
		/* Lock is always based on local file pointer */
		cfg->cf[1].cf_lock = cfg->cf[0].cf_lock = cfg->cf[0].cf_fd;

		if (!((cfg->cf[0].cf_flag & CFG_RDONLY) &&
			(mode == CFG_RDLOCK))) {

			struct flock lk = {0};
			lk.l_type = (mode == CFG_RDLOCK ? F_RDLCK : F_WRLCK);
			lk.l_whence = SEEK_SET;
			lk.l_start = (off_t)0;
			lk.l_len = (off_t)0;

			if (fcntl(cfg->cf[0].cf_lock, F_SETLKW, &lk) < 0)
				goto fail;
		}
	}

	/* Determine number of files open */
	for (cfp = &cfg->cf[0]; cfp <= &cfg->cf[1]; cfp++) {
		if (!cfp->cf_fd) continue;
		if ((cfp->cf_head) &&
		    (cfp->cf_head->h_state & CFG_HDR_INVALID)) {
			if ((rc = cfg_hdrcmp(cfp)) == 0) {
#ifdef DEBUG_HDR
		(void) fprintf(stderr,
			"cfg header match, skipping re-read\n");
#endif
				cfp->cf_head->h_state |= CFG_HDR_RDLOCK;
				if (mode == CFG_WRLOCK)
					cfp->cf_head->h_state |= CFG_HDR_WRLOCK;

				cfp->cf_head->h_state &= ~(CFG_HDR_INVALID);
				continue;
			}
#ifdef DEBUG_HDR
		(void) fprintf(stderr, "re-reading cfg, header mismatch\n");
#endif
			/*
			 * dump what we have, info is stale
			 */
			cfg_free_cfglist(cfp);
			cfg_free_parser_tree();

			if (cfp->cf_head->h_ccopy1) {
				free(cfp->cf_head->h_ccopy1);
				cfp->cf_head->h_ccopy1 = NULL;
			}
			if (cfp->cf_head->h_ccopy2) {
				free(cfp->cf_head->h_ccopy2);
				cfp->cf_head->h_ccopy2 = NULL;
			}
			if (cfp->cf_head->h_sizes1) {
				free(cfp->cf_head->h_sizes1);
				cfp->cf_head->h_sizes1 = NULL;
			}
			if (cfp->cf_head->h_sizes2) {
				free(cfp->cf_head->h_sizes2);
				cfp->cf_head->h_sizes2 = NULL;
			}

			if (cfp->cf_head)
				free(cfp->cf_head);
			cfp->cf_head = NULL;
		}

		if (cfp->cf_head == NULL) {
			if (!cfg_read(cfp)) {
				if (cfp->cf_head != NULL)
					cfg_init_header(cfp);
				else
					goto fail;
			} else {
#ifdef DEBUG_CFGLIST
				(void) fprintf(stderr,
				"reading parser config\n");
#endif
				/* build parser trees */
				cfg_read_parser_config(cfp);
			}

		}
		cfp->cf_head->h_state |= CFG_HDR_RDLOCK;
		if (mode == CFG_WRLOCK) {
			if (cfp->cf_head->h_seq1 >= cfp->cf_head->h_seq2) {
#ifdef DEBUG_LIB
				(void) fprintf(stderr,
					"cfg_lock: WRLOCK copying 1 to 2\n");
#endif
				memcpy(cfp->cf_head->h_ccopy2,
					cfp->cf_head->h_ccopy1,
					cfp->cf_head->h_csize);
				memcpy(cfp->cf_head->h_sizes2,
					cfp->cf_head->h_sizes1,
					CFG_DEFAULT_PSIZE);

				cfp->cf_head->h_cparse = cfp->cf_head->h_ccopy2;
				cfp->cf_head->h_sizes = cfp->cf_head->h_sizes2;
			} else {
#ifdef DEBUG_LIB
				(void) fprintf(stderr,
					"cfg_lock: WRLOCK copying 2 to 1\n");
#endif
				memcpy(cfp->cf_head->h_ccopy1,
					cfp->cf_head->h_ccopy2,
					cfp->cf_head->h_csize);
				memcpy(cfp->cf_head->h_sizes1,
					cfp->cf_head->h_sizes2,
					CFG_DEFAULT_PSIZE);

				cfp->cf_head->h_cparse = cfp->cf_head->h_ccopy1;
				cfp->cf_head->h_sizes = cfp->cf_head->h_sizes1;
			}

			cfp->cf_head->h_state |= CFG_HDR_WRLOCK;
		}

		if (cfg_map_cfglists(cfp) < 0) {
#ifdef DEBUG_LIB
			(void) fprintf(stderr, "cfg: map_cfglists failed\n");
#endif
			goto fail;
		}

#ifdef DEBUG_LIB
		dump_status(cfp, "cfg_lock");
#endif
	}

	return (TRUE);

fail:
	if (is_locked) {
		cfg_lockd_unlock();
	}
	cfg_perror_str = dgettext("cfg", CFG_EGENERIC);
	cfg_severity = CFG_ENONFATAL;
	return (FALSE);
}

/*
 * Unlock the database
 */
void
cfp_unlock(cfp_t *cfp)
{

#ifdef DEBUG_CFGLIST
	(void) fprintf(stderr, "cfg_unlock\n");
#endif
	if (cfg_lockd) {
		cfg_lockd_unlock();
	} else {
		struct flock lk = {0};
		lk.l_type = F_UNLCK;
		lk.l_whence = SEEK_SET;
		lk.l_start = (off_t)0;
		lk.l_len = (off_t)0;
		(void) fcntl(cfp->cf_lock, F_SETLKW, &lk);
	}

	if (cfp->cf_head != NULL) {
		cfp->cf_head->h_state &= ~(CFG_HDR_RDLOCK|CFG_HDR_WRLOCK);
		cfp->cf_head->h_state |= CFG_HDR_INVALID;
	}
}
void
cfg_unlock(CFGFILE *cfg)
{
	if (cfg == NULL) {
		cfg_perror_str = dgettext("cfg", CFG_EINVAL);
		cfg_severity = CFG_EFATAL;
		return;
	}

	cfp_unlock(&cfg->cf[0]);
	cfp_unlock(&cfg->cf[1]);
}

/*
 * Test for a read lock, set errno if failed.
 */
static int
cfg_rdlock(CFGFILE *cfg)
{
	int rc;
	cfp_t *cfp;

	if (cfg == NULL) {
		cfg_perror_str = dgettext("cfg", CFG_EINVAL);
		cfg_severity = CFG_EFATAL;
		return (FALSE);
	}

	/* Determine number of files open */
	for (cfp = &cfg->cf[0]; cfp <= &cfg->cf[1]; cfp++) {
		if (!cfp->cf_fd) continue;
		if (cfp->cf_head == NULL) {
#ifdef DEBUG_LIB
		    (void) fprintf(stderr, "cfg_rdlock: cf_head == NULL\n");
#endif
		/*
		 * 6335583, if header == NULL,
		 * we can't call cfg_read to fill the header again
		 * since it will change the lock state to
		 * CFG_HDR_WRLOCK and dscfg will be the processer
		 * that hold the lock,
		 * just returning a FALSE if the case,
		 * then retrieve the lock state from flock structure.
		 */
		    rc = FALSE;
		    break;
		} else {
#ifdef DEBUG_LIB
		    (void) fprintf(stderr, "cfg_rdlock: cf_head != NULL\n");
#endif
		    if ((cfp->cf_head->h_state & CFG_HDR_RDLOCK)
			== CFG_HDR_RDLOCK)
			rc = TRUE;
		    else {
			rc = FALSE;
			break;
		    }
		}
	}

	if (!rc)
		errno = EPERM;

	return (rc);
}

/*
 * Test for a write lock, set errno if failed.
 */
static int
cfg_wrlock(CFGFILE *cfg)
{
	int rc;
	cfp_t *cfp;

	if (cfg == NULL) {
		cfg_perror_str = dgettext("cfg", CFG_EINVAL);
		cfg_severity = CFG_EFATAL;
		return (FALSE);
	}

	/* Determine number of files open */
	for (cfp = &cfg->cf[0]; cfp <= &cfg->cf[1]; cfp++) {
		if (!cfp->cf_fd) continue;
		if (cfp->cf_head == NULL) {
#ifdef DEBUG_LIB
		    (void) fprintf(stderr, "cfg wrlock: cf_head == NULL\n");
#endif
		/*
		 * 6335583, see comments on cfg_rdlock
		 */
		    rc = FALSE;
		    break;
		} else {
#ifdef DEBUG_LIB
		    (void) fprintf(stderr, "cfg wrlock: cf_head != NULL\n");
#endif
		    if ((cfp->cf_head->h_state & CFG_HDR_WRLOCK)
			== CFG_HDR_WRLOCK)
			rc = TRUE;
		    else {
			rc = FALSE;
			break;
		    }
		}
	}

	if (!rc)
		errno = EPERM;

	return (rc);
}

/*
 * cfg_get_lock
 * Find lock status of CFG database.
 * Returns: TRUE and sets lock and pid if the lock is held, FALSE otherwise.
 */
int
cfg_get_lock(CFGFILE *cfg, CFGLOCK *lock, pid_t *pid)
{
	struct flock lk;
	int rc;

	if (cfg == NULL) {
		cfg_perror_str = dgettext("cfg", CFG_EINVAL);
		cfg_severity = CFG_EFATAL;
		return (FALSE);
	}

	if (cfg_lockd) {
		switch (cfg_lockedby(pid)) {
		case LOCK_READ:
			*lock = CFG_RDLOCK;
			return (TRUE);
		case LOCK_WRITE:
			*lock = CFG_WRLOCK;
			return (TRUE);
		case LOCK_NOTLOCKED:
		default:
			return (FALSE);
		}
	} else {
		if (cfg_wrlock(cfg)) {
		    *lock = CFG_WRLOCK;
		    *pid = getpid();
		    return (TRUE);
		}

		if (cfg_rdlock(cfg)) {
		    *lock = CFG_RDLOCK;
		    *pid = getpid();
		    return (TRUE);
		}
	}
	/* Lock is always based on local file pointer */
	cfg->cf[1].cf_lock = cfg->cf[0].cf_lock = cfg->cf[0].cf_fd;

	bzero(&lk, sizeof (lk));
	lk.l_type = F_WRLCK;
	lk.l_whence = SEEK_SET;
	lk.l_start = (off_t)0;
	lk.l_len = (off_t)0;

	if (fcntl(cfg->cf[0].cf_lock, F_GETLK, &lk) < 0)
		rc = FALSE;
	else {
		if (lk.l_type == F_UNLCK)
			rc = FALSE;
		else {
			rc = TRUE;
			*pid = lk.l_pid;
			*lock = lk.l_type == F_WRLCK ? CFG_WRLOCK : CFG_RDLOCK;
		}
	}

	return (rc);
}

/*
 * cfg_commit
 * Write modified version of header, configuration and persistent
 * data using 2 stage commit.
 * If no valid data is found in header, it is assumed to be an initial
 * write and we will create the default header (could be dangerous)
 * another tricky part, if we are doing an upgrade we may be dealing
 * with an old database. we need to take care seeking and writing
 * until such time that it is upgraded.
 *
 * Mutual exclusion is checked using cfg_lock
 */

int
cfg_commit(CFGFILE *cfg)
{
	cfp_t *cfp;
	int rc;
	time_t tloc;
	int section;
	int wrsize, *ip;

	if (cfg == NULL) {
		cfg_perror_str = dgettext("cfg", CFG_EINVAL);
		cfg_severity = CFG_EFATAL;
		return (FALSE);
	}

	if (!cfg_wrlock(cfg))
		return (FALSE);

	/* Determine number of files open */
	for (cfp = &cfg->cf[0]; cfp <= &cfg->cf[1]; cfp++) {
		if (!cfp->cf_fd) continue;

		/*
		 * lets put everything back into one char *
		 */
		cfg_replace_lists(cfp);

		if ((*cfp->cf_pp->seek)(cfp, 0, SEEK_SET) < 0) {
#ifdef DEBUG_LIB
		(void) fprintf(stderr, "cfg: seek header failed\n");
#endif
			return (FALSE);
		}

		cfp->cf_head->h_size = cfp->cf_head->h_parsesize
			+ cfp->cf_head->h_csize + cfp->cf_head->h_psize;
		cfp->cf_head->h_stamp = time(&tloc);

		/* seeking into database */
		if ((*cfp->cf_pp->seek)
			(cfp, sizeof (cfgheader_t), SEEK_CUR) < 0)
			return (FALSE);

		if (cfp->cf_head->h_ccopy1 == cfp->cf_head->h_cparse) {
			if (cfp->cf_head->h_seq1 < 0)
				cfp->cf_head->h_seq1 = 1;
			else
				cfp->cf_head->h_seq1 = cfp->cf_head->h_seq2 + 1;
			section = 1;
		} else {
			if (cfp->cf_head->h_seq2 < 0)
				cfp->cf_head->h_seq2 = 1;
			else
				cfp->cf_head->h_seq2 = cfp->cf_head->h_seq1 + 1;
			section = 2;
		}
#ifdef DEBUG_LIB
		dump_status(cfp, "cfg_commit");
#endif
		rc = (*cfp->cf_pp->write)
			(cfp, cfp->cf_mapped, CFG_DEFAULT_PARSE_SIZE);
#ifdef DEBUG
		if (rc < 0) {
			(void) fprintf(stderr,
				"parse commit: rc %d h_parsesize %d\n",
				rc, cfp->cf_head->h_parsesize);
		}
#endif
		if (section == 1) {
			rc = (*cfp->cf_pp->write)
				(cfp, cfp->cf_head->h_ccopy1,
				cfp->cf_head->h_csize);
#ifdef DEBUG
			if (rc < 0) {
				(void) fprintf(stderr,
					"csection commit 1: rc %d h_csize %d\n",
					rc, cfp->cf_head->h_csize);
			}
#endif
			if ((*cfp->cf_pp->seek)
			    (cfp, (2 * CFG_DEFAULT_SSIZE) - rc, SEEK_CUR) < 0)
				return (FALSE);

			/*
			 * limit the write to only what we need
			 */
			ip = cfp->cf_head->h_sizes1;
			for (wrsize = 0; *ip; ip += *ip + 1)
				wrsize += *ip + 1;

			rc = (*cfp->cf_pp->write)(cfp,
				cfp->cf_head->h_sizes1, wrsize * sizeof (int));
#ifdef DEBUG
			if (rc < 0) {
				(void) fprintf(stderr,
					"cfg: write list sizes1 failed rc\n");
			}
#endif
		} else {
			if ((*cfp->cf_pp->seek)(cfp,
				CFG_DEFAULT_SSIZE, SEEK_CUR) < 0)
				return (FALSE);

			rc = (*cfp->cf_pp->write)(cfp,
				cfp->cf_head->h_ccopy2, cfp->cf_head->h_csize);
#ifdef DEBUG
			if (rc < 0) {
				(void) fprintf(stderr,
					"csection commit 2: rc %d h_csize %d\n",
					rc, cfp->cf_head->h_csize);
			}
#endif
			if ((*cfp->cf_pp->seek)
			    (cfp, (CFG_DEFAULT_SSIZE + CFG_DEFAULT_PSIZE) - rc,
			    SEEK_CUR) < 0)
				return (FALSE);

			/*
			 * limit the write to only what we need
			 */
			ip = cfp->cf_head->h_sizes2;
			for (wrsize = 0; *ip; ip += *ip + 1)
				wrsize += *ip + 1;

			rc = (*cfp->cf_pp->write)(cfp, cfp->cf_head->h_sizes2,
				wrsize * sizeof (int));
#ifdef DEBUG
			if (rc < 0) {
				(void) fprintf(stderr,
					"cfg: write list sizes2 failed\n");
			}
#endif

		}


#ifdef DEBUG_CFGLIST
		(void) fprintf(stderr,
		    "writing h_csize %d\n", cfp->cf_head->h_csize);
#endif
		if ((*cfp->cf_pp->seek)(cfp, 0, SEEK_SET) < 0)
			return (FALSE);

		cfp->cf_head->h_size = cfp->cf_head->h_parsesize +
			cfp->cf_head->h_csize +	cfp->cf_head->h_psize;

		rc = (*cfp->cf_pp->write)
			(cfp, cfp->cf_head, sizeof (cfgheader_t));
		if (rc < 0) {
			cfg_perror_str = dgettext("cfg",
				"cfg_commit: header write failed");
			cfg_severity = CFG_EFATAL;
			return (FALSE);
		}
	}

	return (TRUE);
}

/*
 * cfg_rewind
 * rewind internal file pointer for specified section
 * empty now, rewind not necessary. But don't break
 * old code.
 */
/*ARGSUSED*/
void
cfg_rewind(CFGFILE *cfg, int section)
{
	switch (section) {
		case CFG_SEC_CONF:
			break;
		case CFG_SEC_ALL:
			break;
	};
}

/*
 * cfg_location
 * set or return the default location file to
 * determine the partition name of the configuration partition
 * location is stored in well known file location
 */
char *
cfg_location(char *location, int mode, char *altroot)
{
	int fd;
	int fmode;
	int rc;
	char wellknown[NSC_MAXPATH];
	char loc[NSC_MAXPATH];

	if (mode == CFG_LOC_GET_LOCAL) {
		return (CFG_LOCAL_LOCATION);
	} else if (mode == CFG_LOC_GET_CLUSTER) {
		fmode = O_RDONLY;
	} else {
		fmode = O_RDWR | O_CREAT;
	}

	if (altroot) {
		strcpy(wellknown, altroot);
		strcat(wellknown, CFG_CLUSTER_LOCATION);
	} else
		strcpy(wellknown, CFG_CLUSTER_LOCATION);

	fd = open(wellknown, fmode, 0644);
	if (fd < 0) {
		cfg_perror_str = dgettext("cfg", strerror(errno));
		cfg_severity = CFG_ENONFATAL;
		return (NULL);
	}

	if (mode == CFG_LOC_SET_CLUSTER) {
		if (location == NULL || (strlen(location) > NSC_MAXPATH)) {
			cfg_perror_str = dgettext("cfg",
			    "cfg_location: filename too big or missing");
			cfg_severity = CFG_EFATAL;
			return (NULL);
		}

		/*
		 * 5082142
		 * If we're in a cluster, make sure that the config location
		 * is a raw device.  Using non-raw did devices in a cluster
		 * can result in data corruption, since inconsistent data
		 * may reside in the block cache on one node, but has not
		 * been flushed to disk.
		 */
		if (cfg_iscluster() > 0) {
			struct stat dscfg_stat;
			if (stat(location, &dscfg_stat) != 0) {
				cfg_perror_str = dgettext("cfg",
				    "Unable to access dscfg location");
				cfg_severity = CFG_EFATAL;
				return (NULL);
			}
			if (!S_ISCHR(dscfg_stat.st_mode)) {
				cfg_perror_str = dgettext("cfg",
				    "dscfg location must be a raw device");
				cfg_severity = CFG_EFATAL;
				return (NULL);
			}
		}

		if (ftruncate(fd, 0) < 0)
			return (NULL);

		rc = write(fd, location, strlen(location));
		if (rc < 0) {
			cfg_perror_str = dgettext("cfg",
			    "cfg_location: write to well known failed");
			cfg_severity = CFG_EFATAL;
			return (NULL);
		}
		bzero(config_file, sizeof (config_file));
	}
	if (lseek(fd, 0, SEEK_SET) < 0)
		return (NULL);

	bzero(config_file, sizeof (config_file));
	rc = read(fd, config_file, sizeof (config_file));
	if (rc < 0) {
		cfg_perror_str = dgettext("cfg",
		    "cfg_location: read from well known failed");
		cfg_severity = CFG_EFATAL;
		return (NULL);
	}
	close(fd);
	if (altroot) {
		strcpy(loc, altroot);
		strcat(loc, config_file);
		bzero(config_file, sizeof (config_file));
		strcpy(config_file, loc);
	}

	/*
	 * scan string out of config_file, to strip whitespace
	 */
	sscanf(config_file, "%s", loc);
	strcpy(config_file, loc);

	return (config_file);
}

/*
 * cfg_update_parser_config
 * If tag and key exist return -1
 *
 * XXX Currently does not append new field to existing parser rule
 */

int
cfg_update_parser_config(CFGFILE *cfg, const char *key, int section)
{
	cfp_t *cfp;
	int size;
	char buf[CFG_MAX_BUF];
	struct parser *tbl;
	char tmpkey[CFG_MAX_KEY];
	char *ky, *fld;
	errno = 0;

	if (cfg == NULL) {
		cfg_perror_str = dgettext("cfg", CFG_EINVAL);
		cfg_severity = CFG_EFATAL;
		return (-1);
	}

	cfp = FP_SUN_CLUSTER(cfg);
	if (!cfg_wrlock(cfg))
		return (-1);

	bzero(buf, CFG_MAX_BUF);
	bzero(tmpkey, sizeof (tmpkey));
	strcpy(tmpkey, key);
	if (section == CFG_PARSE_CONF) {
		strcat(buf, "C:");
		tbl =  chead;
	} else {
		errno = EINVAL;
		return (-1);
	}
	ky = strtok(tmpkey, ".");
	fld = strtok(NULL, ".");
	while (fld) {
		size = cfg_get_item(tbl, ky, fld);

		/*
		 * Assure we are loading a clean table, with do duplicates
		 * based on our File Descriptor
		 */
		if (chead_loaded && (chead_loaded != cfp->cf_fd)) {
			if (size <= 0)
				return (-1);
		} else {
			if (size > 0)
				return (-1);
		}
		fld = strtok(NULL, ".");
	}
	size = strlen(key) + 2;
	strncat(buf, key, size);
#ifdef DEBUG_LIB
	(void) fprintf(stderr, "update parser config %s size %d\n", buf, size);
#endif
	if ((size + cfp->cf_head->h_parseoff) > CFG_DEFAULT_PARSE_SIZE) {
		cfg_perror_str = dgettext("cfg",
		    "cfg_update_parser_config: header overrun");
		cfg_severity = CFG_EFATAL;
#ifdef DEBUG_LIB
		(void) fprintf(stderr, "update parser config: "
		    "overrun siz %d poff %d parsesize %d\n",
		    size, cfp->cf_head->h_parseoff, cfp->cf_head->h_parsesize);
#endif
		errno = E2BIG;
		return (-1);
	}
	bcopy(buf, (cfp->cf_mapped + cfp->cf_head->h_parseoff), size);
	cfp->cf_head->h_parseoff += size;
	cfp->cf_head->h_state |= CFG_HDR_INVALID;
	if (cfp->cf_mapped[cfp->cf_head->h_parseoff - 1] != '\n') {
		cfp->cf_mapped[cfp->cf_head->h_parseoff] = '\n';
		cfp->cf_head->h_parseoff++;
	}
	cfp->cf_head->h_parsesize = cfp->cf_head->h_parseoff;
	cfg_read_parser_config(cfp);
	return (TRUE);
}
/*
 * cfg_read_parser_config
 * reads parser config from file
 * converts it to internal tree for parsing
 * chead for configuration parser entries
 *
 */
static
void
cfg_read_parser_config(cfp_t *cfp)
{
	struct lookup *p, *q;
	struct parser *thead;
	int off, foff;
	char *part;
	char *key;
	char *fld;
	int fldnum;
	char c;
	char buf[CFG_MAX_BUF];
	int i = 0;
	int n = 0;

	off = foff = 0;
	/*CONSTCOND*/
	while (TRUE) {
		off = 0;
		bzero(buf, CFG_MAX_BUF);
		/* LINTED it assigns value to c */
		while (c = cfp->cf_mapped[foff++]) {
			if (c == '\n')
				break;
			buf[off++] = c;
		}
		part = strtok(buf, ":");
		if (!part)
			break;
		if (*part == 'C') {
			thead = chead;
			n = i;
		}
		key = strtok(NULL, ".");
		if (!key)
			break;
		strcpy(thead[n].tag.l_word, key);
		thead[n].tag.l_value = 0;
		thead[n].fld = NULL;
		fldnum = 1;
		while ((fld = strtok(NULL, ".")) != NULL) {
			p = thead[n].fld;
			if (p == NULL) {
				q = thead[n].fld = calloc(1,
						sizeof (struct lookup));
			} else {
				for (q = thead[n].fld; q; q = q->l_next)
					p = q;
				q = calloc(1, sizeof (struct lookup));
				p->l_next = q;
			}
			strcpy(q->l_word, fld);
			q->l_value = fldnum;
			q->l_next = NULL;
#ifdef DEBUG_EXTRA
			(void) fprintf(stderr,
			    "read parser: q: word %s value %d\n",
			    q->l_word, q->l_value);
#endif
			fldnum++;
		}
		if (*part == 'C')
			i++;
	}

	/* All done, indicate parser table is loaded */
	if (i && (chead_loaded == 0))
		chead_loaded = cfp->cf_fd;

	/*
	 * before I go and alloc, why am I here?
	 * do I need a bunch of cfglists, or do I just
	 * need to accommodate a just added parser entry
	 * if the latter, we already have a base, just set
	 * i to the index of the cfg which members need allocing
	 */
	if ((cfp->cf_head->h_cfgs == NULL) ||
	    (cfp->cf_head->h_cfgs[n-1].l_entry == NULL)) {
		cfp->cf_head->h_cfgs = (cfglist_t *)calloc(MAX_CFG,
		    sizeof (cfglist_t));
		i = 0;
	}
	else
		i = n;

	if (cfp->cf_head->h_cfgs) {

#ifdef DEBUG_CFGLIST
	(void) fprintf(stderr, "alloced %d cfg lists \n", n + 1);
#endif
		for (cfp->cf_head->h_ncfgs = n + 1;
			i < min(cfp->cf_head->h_ncfgs, MAX_CFG); i++) {
			cfp->cf_head->h_cfgs[i].l_name = '\0';
			cfp->cf_head->h_cfgs[i].l_name =
			    strdup(chead[i].tag.l_word);
			cfp->cf_head->h_cfgs[i].l_index = i;
			cfp->cf_head->h_cfgs[i].l_entry =
			    calloc(DEFAULT_ENTRY_SIZE, sizeof (char));
			cfp->cf_head->h_cfgs[i].l_nentry = 0;
			cfp->cf_head->h_cfgs[i].l_esiz =
			    calloc(DEFAULT_NENTRIES, sizeof (int));
			cfp->cf_head->h_cfgs[i].l_size = 0;
			cfp->cf_head->h_cfgs[i].l_free = DEFAULT_ENTRY_SIZE;
			if ((cfp->cf_head->h_cfgs[i].l_entry == NULL) ||
			    (cfp->cf_head->h_cfgs[i].l_esiz == NULL)) {
				cfg_perror_str = dgettext("cfg", "unable to"
				    " allocate cfglist members");
				cfg_severity = CFG_EFATAL;
			}
		}
	} else {
		cfg_perror_str = dgettext("cfg", "unable to alloc cfglist");
		cfg_severity = CFG_EFATAL;
	}
}

/*
 * cfg_map_cfglists()
 * go through list of list sizes in header
 * and create separate lists
 */
int
cfg_map_cfglists(cfp_t *cfp)
{
	int i;
	int offset = 0;
	int *ip;
	int list_size = 0;
	int slot_inc;
	char *p;
	cfgheader_t *ch;

	ch = cfp->cf_head;
	p = ch->h_cparse;

	/* get the first list size */
	ip = ch->h_sizes;

	for (i = 0; i < min(ch->h_ncfgs, MAX_CFG); i++) {
		if (ch->h_cfgsizes[i] > 0) {
			if (ch->h_cfgsizes[i] > DEFAULT_ENTRY_SIZE) {

				ch->h_cfgs[i].l_entry = (char *)
				    realloc(ch->h_cfgs[i].l_entry,
				    ch->h_cfgsizes[i] * sizeof (char));
				/* set free to 0, we'll get more when we add */
				ch->h_cfgs[i].l_free = 0;

			} else
				ch->h_cfgs[i].l_free -= ch->h_cfgsizes[i];

			/* get lists and marry up to each cfgs structure */


			list_size = *ip;
			ip++;

			if (list_size > DEFAULT_NENTRIES) {
				/*
				 *  we're gonna need more slots
				 * we want to alloc on DEFAULT_NENTRIES
				 * boundry. ie. always a multiple of it
				 * later on, when we add to the list
				 * we can see if we need to add by mod'ding
				 * l_nentry and DEFAULT_NENTRIES and check for 0
				 */
				slot_inc = DEFAULT_NENTRIES -
				    (list_size % DEFAULT_NENTRIES);
				if (slot_inc == DEFAULT_NENTRIES)
					slot_inc = 0; /* addcfline reallocs */

				ch->h_cfgs[i].l_esiz = (int *)realloc(
				    ch->h_cfgs[i].l_esiz,
				    (list_size + slot_inc) * sizeof (int));
			}
			memcpy(ch->h_cfgs[i].l_esiz, ip,
			    list_size * sizeof (int));

			ch->h_cfgs[i].l_nentry = list_size;

			ip += list_size;

		} else

			continue;

		if (ch->h_cfgs[i].l_entry != NULL) {
			p = ch->h_cparse + offset;
#ifdef DEBUG_CFGLIST
	(void) fprintf(stderr, "mapping list %d size %d offset %d, addr 0x%x\n",
	    i, ch->h_cfgsizes[i], offset, p);
#endif
			memcpy(ch->h_cfgs[i].l_entry,
			    p, ch->h_cfgsizes[i]);
			ch->h_cfgs[i].l_size = ch->h_cfgsizes[i];
			offset += ch->h_cfgsizes[i];
		} else {
#ifdef DEBUG_CFGLIST
			(void) fprintf(stderr, "NULL l_entry\n");
#endif
			return (-1);
		}
	}


	return (1);

}

void
cfg_replace_lists(cfp_t *cfp)
{
	int i;
	int offset = 0;
	int size_offset = 0;

	int section = 0;
	cfgheader_t *cf;
	cfglist_t	*cfl;

	cf = cfp->cf_head;

	if ((cfl = cfp->cf_head->h_cfgs) == NULL)
		return;

#ifdef DEBUG_CFGLIST
	(void) fprintf(stderr, "cfg_replace_lists\n");
#endif

	if (cf->h_cparse == cf->h_ccopy1)
		section = 1;

	/*
	 * check to see if we are using copy1 or 2,
	 * grow or shrink the size, fix h_cparse reference
	 * in case realloc gave us a funky new address.
	 * put stuff in it.
	 */
	cf->h_ccopy1 = (char *)
	    realloc(cf->h_ccopy1, cf->h_csize * sizeof (char));
	cf->h_ccopy2 = (char *)
	    realloc(cf->h_ccopy2, cf->h_csize * sizeof (char));
	if (section == 1) {
		/* we used copy1 */
		cf->h_cparse = cf->h_ccopy1;
	} else
		cf->h_cparse = cf->h_ccopy2;

	/*
	 * just because, we'll zero out h_csize and recalc
	 * after all, this is the number the next guy gets
	 */
	cf->h_csize = cf->h_sizes[0] = 0;
	for (i = 0; i < MAX_CFG; i++) {
		/* only as many lists as chead has */
		if (chead[i].tag.l_word[0] == '\0') {
			break;
		}
		if (cfl[i].l_entry && cfl[i].l_entry[0] != '\0') {
#ifdef DEBUG_CFGLIST
			(void) fprintf(stderr,
			    "copying list %d at %x size %d\n",
			    i, cf->h_cparse + offset,
			    cfl[i].l_size);
#endif
			memcpy((cf->h_cparse + offset),
			    cfl[i].l_entry, cfl[i].l_size);
			offset += cfl[i].l_size;
#ifdef DEBUG_CFGLIST
			(void) fprintf(stderr,
			    "cfl[%d].l_nentry %d cfl[%d].l_esiz[%d] %d"
			    " size offset %d\n",
			    i, cfl[i].l_nentry, i, cfl[i].l_nentry - 1,
			    cfl[i].l_esiz[cfl[i].l_nentry - 1], size_offset);
#endif
			/*
			 * first write the number of entries
			 * then copy over the array ie.
			 * a list with 5 elements would be copied
			 * as a 6 element array slot 0 being the
			 * number of elements
			 */
			cf->h_sizes[size_offset++] = cfl[i].l_nentry;
			memcpy((cf->h_sizes + size_offset), cfl[i].l_esiz,
			    cfl[i].l_nentry * sizeof (int));
			size_offset += cfl[i].l_nentry;
			cf->h_sizes[size_offset] = 0;
		}
		cf->h_csize += cfl[i].l_size;
	}
}

void
cfg_free_cfglist(cfp_t *cfp)
{
	int i;

	if (!cfp->cf_head || !cfp->cf_head->h_cfgs)
		return;

	for (i = 0; cfp->cf_head && i < MAX_CFG; i++) {
		if (cfp->cf_head->h_cfgs[i].l_entry) {
			free(cfp->cf_head->h_cfgs[i].l_entry);
			cfp->cf_head->h_cfgs[i].l_entry = NULL;
		}

		if (cfp->cf_head->h_cfgs[i].l_name) {
			free(cfp->cf_head->h_cfgs[i].l_name);
			cfp->cf_head->h_cfgs[i].l_entry = NULL;
		}

		if (cfp->cf_head->h_cfgs[i].l_esiz) {
			free(cfp->cf_head->h_cfgs[i].l_esiz);
			cfp->cf_head->h_cfgs[i].l_esiz = NULL;
		}
	}

	if (cfp->cf_head) {
		free(cfp->cf_head->h_cfgs);
		cfp->cf_head->h_cfgs = NULL;
	}
}

void
cfg_free_parser_tree()
{
	struct lookup *p = NULL;
	struct lookup *q = NULL;
	int i;

	for (i = 0; i < MAX_CFG; i++) {
		if (chead)
			p = chead[i].fld;
		while (p) {
			q = p->l_next;
			if (p) {
				free(p);
				p = NULL;
			}
			p = q;
		}
	}
	bzero(chead, MAX_CFG * sizeof (struct parser));
}

void
cfg_close(CFGFILE *cfg)
{
	cfp_t *cfp;

	if (cfg == NULL) {
		cfg_perror_str = dgettext("cfg", CFG_EINVAL);
		cfg_severity = CFG_EFATAL;
		return;
	}

	/* Determine number of files open */
	for (cfp = &cfg->cf[0]; cfp <= &cfg->cf[1]; cfp++) {
		if (!cfp->cf_fd) continue;

		(*cfp->cf_pp->close)(cfp);
#ifdef DEBUG_CFGLIST
		(void) fprintf(stderr, "freeing cfglists\n");
#endif
		cfg_free_cfglist(cfp);

#ifdef DEBUG_CFGLIST
		(void) fprintf(stderr, "freeing cfp->cf_mapped\n");
#endif
		free(cfp->cf_mapped);
		cfp->cf_mapped = NULL;

#ifdef DEBUG_CFGLIST
		(void) fprintf(stderr,
		    "freeing copy1, copy2, h_sizes and cf\n");
#endif
		if (cfp->cf_head) {
			if (cfp->cf_head->h_ccopy1) {
				free(cfp->cf_head->h_ccopy1);
				cfp->cf_head->h_ccopy1 = NULL;
			}
			if (cfp->cf_head->h_ccopy2) {
				free(cfp->cf_head->h_ccopy2);
				cfp->cf_head->h_ccopy2 = NULL;
			}
			if (cfp->cf_head->h_sizes1) {
				free(cfp->cf_head->h_sizes1);
				cfp->cf_head->h_sizes1 = NULL;
			}
			if (cfp->cf_head->h_sizes2) {
				free(cfp->cf_head->h_sizes2);
				cfp->cf_head->h_sizes2 = NULL;
			}

		}
		if (cfp->cf_head)
			free(cfp->cf_head);
	}

	free(cfg);
	cfg = NULL;
	cfg_free_parser_tree();

#ifdef DEBUG_CFGLIST
	(void) fprintf(stderr, "cfg_close\n");
#endif
}


char *
cfg_get_resource(CFGFILE *cfg)
{
	if (cfg == NULL) {
		cfg_perror_str = dgettext("cfg", CFG_EINVAL);
		cfg_severity = CFG_EFATAL;
		return (NULL);
	}

	return (cfg->cf_node);
}

/*
 * cfg_resource
 * set or clear the cluster node filter for get/put
 */

void
cfg_resource(CFGFILE *cfg, const char *node)
{
	if (cfg == NULL) {
		cfg_perror_str = dgettext("cfg", CFG_EINVAL);
		cfg_severity = CFG_EFATAL;
		return;
	}

	if (cfg->cf_node) {
#ifdef DEBUG_CFGLIST
		(void) fprintf(stderr,
		    "cfg_resource: changing node from %s to %s\n",
		    cfg->cf_node, (node?node:"NULL"));
#endif
		free(cfg->cf_node);
		cfg->cf_node = NULL;
	}

	/*
	 * just in case someone passes in a non-NULL
	 * node, but has no valid value
	 */
	if ((node) && (node[0] != '\0')) {
		cfg->cf_node = strdup(node);
	}
}

/*
 * cfg_open
 * Open the current configuration file
 */
CFGFILE *
cfg_open(char *name)
{
	CFGFILE *cfg;
	cfp_t *cfp;
	int32_t magic;
	long needed;
	int rc;

#ifdef DEBUG_CFGLIST
	(void) fprintf(stderr, "cfg_open\n");
#endif

	cfg_severity = 0;
	if ((cfg = (CFGFILE *)calloc(1, sizeof (*cfg))) == NULL) {
		cfg_perror_str = dgettext("cfg",
			"cfg_open: malloc failed");
		cfg_severity = CFG_EFATAL;
		return (NULL);
	}

	cfp = &cfg->cf[0];
	if ((name) && strlen(name)) {
#ifdef DEBUG
		(void) fprintf(stderr, "cfg_open: Using non-standard name\n");
#endif
		cfp->cf_name = name;
		cfp->cf_pp = (strstr(cfp->cf_name, "/rdsk/") == NULL)
			? cfg_block_io_provider()
			: cfg_raw_io_provider();
	} else {
		cfp->cf_name = cfg_location(NULL, CFG_LOC_GET_LOCAL, NULL);
		cfp->cf_pp = cfg_block_io_provider();

		/* Handle cfg_open(""), which is an open from boot tools */
		if (name)
			cl_initialized = 1;
		if (cfg_iscluster() > 0) {
			cfp = &cfg->cf[1];
			cfp->cf_name =
				cfg_location(NULL, CFG_LOC_GET_CLUSTER, NULL);
			if (cfp->cf_name) {
				cfp->cf_pp = cfg_raw_io_provider();
			}
		}
	}

	/*
	 * Open one or two configuration files
	 */
	for (cfp = &cfg->cf[0]; cfp->cf_name && (cfp <= &cfg->cf[1]); cfp++) {
		if ((*cfp->cf_pp->open)(cfp, cfp->cf_name) == NULL) {
			cfg_perror_str = dgettext("cfg",
			    "cfg_open: unable to open configuration location");
			cfg_severity = CFG_EFATAL;
			break;
		}

		/* block device smaller than repository? */
		rc = (*cfp->cf_pp->read)(cfp, &magic, sizeof (magic));
		if (rc < sizeof (magic)) {
			cfg_perror_str = dgettext("cfg",
			    "cfg_open: unable to read configuration header");
			cfg_severity = CFG_EFATAL;
			break;
		}

		if ((*cfp->cf_pp->seek)(cfp, 0, SEEK_SET) < 0) {
			cfg_perror_str = dgettext("cfg",
			    "cfg_open: unable to seek configuration header");
			cfg_severity = CFG_EFATAL;
			break;
		}

		/*
		 * we can't enforce size rules on an old database
		 * so check the magic number before we test for size
		 */
		if (magic == CFG_NEW_MAGIC) {
			needed = FBA_NUM(FBA_SIZE(1) - 1 +
			(sizeof (struct cfgheader) + CFG_CONFIG_SIZE));
		} else {
			needed = 0;
		}

		if (cfp->cf_size < needed) {
			cfg_perror_str = dgettext("cfg",
			    "cfg_open: configuration file too small");
			cfg_severity = CFG_EFATAL;
			errno = ENOMEM;
			break;
		}

		cfp->cf_mapped = (char *)malloc(CFG_DEFAULT_PARSE_SIZE);
		if (cfp->cf_mapped == NULL) {
			cfg_perror_str = dgettext("cfg",
				"cfg_open: malloc failed");
			cfg_severity = CFG_EFATAL;
			break;
		}

		bzero(cfp->cf_mapped, CFG_DEFAULT_PARSE_SIZE);
		cfp->cf_lock = -1;
	}

	/* Processing errors, take care of one or more cfp pointers */
	if (cfg_severity && (cfp <= &cfg->cf[1])) {
		cfp = &cfg->cf[0];
		if (cfp->cf_fd)
			(*cfp->cf_pp->close)(cfp);
		cfp = &cfg->cf[1];
		if (cfp->cf_fd)
			(*cfp->cf_pp->close)(cfp);
		free(cfg);
		return (NULL);
	}

	cfg_lockd = cfg_lockd_init();


#ifdef DEBUG_CFGLIST
	(void) fprintf(stderr, "cfg_open ok\n");
#endif
	return (cfg);
}

void
cfg_invalidate_hsizes(int fd, const char *loc) {
	int offset;
	int rc = -1;
	int hdrsz;

	char buf[2 * CFG_DEFAULT_PSIZE];

	hdrsz = sizeof (cfgheader_t) + 512 -
	    (sizeof (cfgheader_t) % 512);

	offset = hdrsz + CFG_DEFAULT_PARSE_SIZE +
	    (CFG_DEFAULT_SSIZE * 2);

	if (cfg_shldskip_vtoc(fd, loc) > 0)
		offset += CFG_VTOC_SKIP;

	bzero(buf, sizeof (buf));

	if (lseek(fd, offset, SEEK_SET) > 0)
		rc = write(fd, buf, sizeof (buf));
	if (rc < 0)
		(void) fprintf(stderr, "cfg: invalidate hsizes failed\n");

}

char *
cfg_error(int *severity)
{
	if (severity != NULL)
		*severity = cfg_severity;
	return (cfg_perror_str ? cfg_perror_str : CFG_EGENERIC);
}
/*
 * cfg_cfg_isempty
 */
int
cfg_cfg_isempty(CFGFILE *cfg)
{
	cfp_t *cfp;

	if (cfg == NULL) {
		cfg_perror_str = dgettext("cfg", CFG_EINVAL);
		cfg_severity = CFG_EFATAL;
		return (FALSE);
	}

	cfp = FP_SUN_CLUSTER(cfg);
	if (cfp->cf_head->h_csize == 0)
		return (TRUE);
	else
		return (FALSE);
}

/*
 * cfg_get_num_entries
 * return the number of entries in a given section of database
 * sndr, ii, ndr_ii...
 */
int
cfg_get_num_entries(CFGFILE *cfg, char *section)
{
	int count = 0;
	int table_offset;
	cfp_t *cfp;

	if (cfg == NULL) {
		cfg_perror_str = dgettext("cfg", CFG_EINVAL);
		cfg_severity = CFG_EFATAL;
		return (-1);
	}

	if ((table_offset = cfg_get_parser_offset(section)) < 0) {
		errno = ESRCH;
		return (-1);
	}

	/* Determine number of files open */
	for (cfp = &cfg->cf[0]; cfp->cf_fd && (cfp <= &cfg->cf[1]); cfp++)
		count += cfp->cf_head->h_cfgs[table_offset].l_nentry;

	return (count);
}

/*
 * cfg_get_section
 * all etries in a config file section is placed in
 * buf, allocation is done inside
 * freeing buf is responisbility of the caller
 * number of entries in section is returned
 * -1 on failure, errno is set
 */
int
cfg_get_section(CFGFILE *cfg, char ***list, const char *section)
{
	int table_offset;
	int i, count;
	cfglist_t *cfl;
	char *p = NULL;
	char **buf;
	cfp_t *cfp;

	if (cfg == NULL) {
		cfg_perror_str = dgettext("cfg", CFG_EINVAL);
		cfg_severity = CFG_EFATAL;
		return (FALSE);
	}

	if ((table_offset = cfg_get_parser_offset(section)) < 0) {
		errno = ESRCH;
		return (-1);
	}

	/* Determine number of files open */
	count = 0;
	for (cfp = &cfg->cf[0]; cfp <= &cfg->cf[1]; cfp++) {
		if (!cfp->cf_fd) continue;
		if (cfp->cf_head->h_state & CFG_HDR_INVALID) {
			if (!cfg_read(cfp)) {
				cfg_perror_str = dgettext("cfg", CFG_RDFAILED);
				cfg_severity = CFG_EFATAL;
				return (-1);
			}
		}

		cfl = &cfp->cf_head->h_cfgs[table_offset];
		if (cfl->l_nentry == 0) /* empty list */
			continue;

		if (count == 0)
			buf = (char **)malloc(cfl->l_nentry * sizeof (char *));
		else
			buf = (char **)realloc(buf, (cfl->l_nentry + count) *
						sizeof (char *));
		if (buf == NULL) {
			errno = ENOMEM;
			return (-1);
		} else {
			bzero(&buf[count], cfl->l_nentry * sizeof (char *));
		}

		p = cfl->l_entry;
		for (i = 0; i < cfl->l_nentry; i++) {
			if ((buf[i + count] = strdup(p)) == NULL) {
				errno = ENOMEM;
				return (-1);
			}
			p += cfl->l_esiz[i];
		}
		count +=  cfl->l_nentry;
	}

	*list = buf;
	return (count);
}

/*
 * cluster upgrade helper functions. These support old database operations
 * while upgrading nodes on a cluster.
 */

/*
 * returns the list of configured tags
 * return -1 on error, else the number
 * of tags returned in taglist
 * caller frees
 */
int
cfg_get_tags(CFGFILE *cfg, char ***taglist)
{
	char **list;
	int i = 0;

	if (cfg == NULL) {
		cfg_perror_str = dgettext("cfg", CFG_EINVAL);
		cfg_severity = CFG_EFATAL;
		return (-1);
	}

	if (!cfg_rdlock(cfg)) {
		return (-1);
	}
	list = calloc(1, MAX_CFG * sizeof (char *));
	if (list == NULL) {
		errno = ENOMEM;
		return (-1);
	}

	while ((i < MAX_CFG) && (chead[i].tag.l_word[0] != '\0')) {
		list[i] = strdup(chead[i].tag.l_word);
		if (list[i] == NULL) {
			for (/* CSTYLE */; i >= 0; i--) {
				if (list[i])
					free(list[i]);
			}
			free(list);
			errno = ENOMEM;
			return (-1);
		}
		i++;
	}
	*taglist = list;
	return (i);

}

/*
 * is this a database?
 * check the header for the magic number
 * 0 no match 1 match, -1 on error
 */
int
cfg_is_cfg(CFGFILE *cfg)
{
	int32_t magic;
	int rc;
	cfp_t *cfp = FP_SUN_CLUSTER(cfg);

	rc = (cfp->cf_pp->read)(cfp, &magic, sizeof (magic));
	if (rc < sizeof (magic)) {
		cfg_perror_str = dgettext("cfg", "Fail to read configuration");
		cfg_severity = CFG_EFATAL;
		return (-1);
	}

	if (magic == CFG_NEW_MAGIC)
		return (1);

	cfg_perror_str = dgettext("cfg",
		"configuration not initialized, bad magic");
	cfg_severity = CFG_EFATAL;

	return (0);
}

int
compare(const void* a, const void *b)
{
	char *p;
	char *pbuf;
	char *q;
	char *qbuf;
	int needed;
	int cmp;
	int pos;

	pbuf = strdup(a);
	qbuf = strdup(b);

	if (!qbuf || !pbuf)
		return (0);

	pos = 1;
	needed = sortby.offset;

	p = strtok(pbuf, " ");
	while (p) {
		if (needed == pos) {
			break;
		}
		p = strtok(NULL, " ");
		if (!p)
			break;
		pos++;
	}

	pos = 1;
	q = strtok(qbuf, " ");
	while (q) {
		if (needed == pos) {
			break;
		}
		q = strtok(NULL, " ");
		if (!q)
			break;
		pos++;
	}
	if (!p || !q) {
		sortby.comperror++;
		free(pbuf);
		free(qbuf);
		return (0);
	}
	cmp = strcmp(p, q);
	free(pbuf);
	free(qbuf);
	return (cmp);


}
/*
 * cfg_get_srtdsec
 * returns the section, sorted by supplied field
 * caller frees mem
 */
int
cfg_get_srtdsec(CFGFILE *cfg, char ***list, const char *section,
	const char *field)
{
	cfglist_t *cfl;
	cfp_t *cfp;
	char **buf;
	char *tmplst;
	char *p, *q;
	int table_offset;
	int count, i;

	if (cfg == NULL) {
		cfg_perror_str = dgettext("cfg", CFG_EINVAL);
		cfg_severity = CFG_EFATAL;
		return (FALSE);
	}

	if ((table_offset = cfg_get_parser_offset(section)) < 0) {
		cfg_perror_str = dgettext("cfg", CFG_RDFAILED);
		errno = ESRCH;
		return (-1);
	}

	/*
	 * do essentially what get_section does,
	 * except stick entries in a static size
	 * buf to make things easier to qsort
	 */
	count = 0;
	for (cfp = &cfg->cf[0]; cfp <= &cfg->cf[1]; cfp++) {
		if (!cfp->cf_fd) continue;
		if (cfp->cf_head->h_state & CFG_HDR_INVALID) {
			if (!cfg_read(cfp)) {
				cfg_perror_str = dgettext("cfg", CFG_RDFAILED);
				cfg_severity = CFG_EFATAL;
				return (-1);
			}
		}

		cfl = &cfp->cf_head->h_cfgs[table_offset];
		if (cfl->l_nentry == 0) /* empty list */
			continue;

		if (count == 0)
			buf = (char **)malloc(cfl->l_nentry * sizeof (char *));
		else
			buf = (char **)realloc(buf, (cfl->l_nentry + count) *
						sizeof (char *));
		if (buf == NULL) {
			errno = ENOMEM;
			cfg_perror_str = dgettext("cfg", "cfg_get_srtdsec: "
			    "malloc failed");
			cfg_severity = CFG_EFATAL;
			return (-1);
		} else {
			bzero(&buf[count], cfl->l_nentry * sizeof (char *));
		}

		/*
		 * allocate each line
		 */
		for (i = count; i < cfl->l_nentry + count; i++) {
			buf[i] = calloc(1, CFG_MAX_BUF);
			if (buf[i] == NULL) {
				free(buf);
				errno = ENOMEM;
				return (-1);
			}
		}

		if (count == 0)
			tmplst = (char *)malloc(cfl->l_nentry * CFG_MAX_BUF);
		else
			tmplst = (char *)realloc(tmplst,
					(cfl->l_nentry + count) * CFG_MAX_BUF);
		if (tmplst == NULL) {
			cfg_perror_str = dgettext("cfg", "cfg_get_srtdsec: "
			    "malloc failed");
			cfg_severity = CFG_EFATAL;
			free(buf);
			return (-1);
		} else {
			bzero(&tmplst[count], cfl->l_nentry * CFG_MAX_BUF);
		}

		/*
		 * put the section in tmplst and sort
		 */
		p = &tmplst[count];
		q = cfl->l_entry;
		for (i = 0; i < cfl->l_nentry; i++) {
			bcopy(q, p, cfl->l_esiz[i]);
			p += CFG_MAX_BUF;
			q += cfl->l_esiz[i];
		}
		count += cfl->l_nentry;
	}

	bzero(sortby.section, CFG_MAX_KEY);
	bzero(sortby.field, CFG_MAX_KEY);

	strcpy(sortby.section, section);
	strcpy(sortby.field, field);
	sortby.comperror = 0;
	sortby.offset = cfg_get_item(&chead[0], section, field);

	qsort(tmplst, count, CFG_MAX_BUF, compare);

	if (sortby.comperror) {
		sortby.comperror = 0;
		cfg_perror_str = dgettext("cfg", "cfg_get_srtdsec: "
		    "comparison error");
		cfg_severity = CFG_ENONFATAL;
		cfg_free_section(&buf, cfl->l_nentry);
		free(tmplst);
		*list = NULL;
		return (-1);
	}

	p = tmplst;
	for (i = 0; i < count; i++) {
		bcopy(p, buf[i], CFG_MAX_BUF);
		p +=  CFG_MAX_BUF;
	}

	free(tmplst);
	*list = buf;
	return (count);
}

/*
 * free an array alloc'd by get_*section
 * or some other array of size size
 */

void
cfg_free_section(char ***section, int size)
{
	int i;
	char **secpp = *section;

	for (i = 0; i < size; i++) {
		if (secpp[i]) {
			free(secpp[i]);
			secpp[i] = NULL;
		}
	}
	if (secpp) {
		free(secpp);
		secpp = NULL;
	}
	section = NULL;
}


int
cfg_shldskip_vtoc(int fd, const char *loc)
{
	struct vtoc vtoc;
	struct stat sb;
	int slice;
	int rfd;
	char char_name[PATH_MAX];
	char *p;

	if (fstat(fd, &sb) == -1) {
		cfg_perror_str = dgettext("cfg", "unable to stat config");
		cfg_severity = CFG_EFATAL;
		return (-1);
	}
	if (S_ISREG(sb.st_mode))
		return (0);

	if (S_ISCHR(sb.st_mode)) {
		if ((slice = read_vtoc(fd, &vtoc)) < 0)
			return (-1);

		if (vtoc.v_part[slice].p_start < CFG_VTOC_SIZE)
			return (1);
		else
			return (0);
	}

	if (S_ISBLK(sb.st_mode)) {
		p = strstr(loc, "/dsk/");
		if (p == NULL)
			return (-1);
		strcpy(char_name, loc);
		char_name[strlen(loc) - strlen(p)] = 0;
		strcat(char_name, "/rdsk/");
		strcat(char_name, p + 5);

		if ((rfd = open(char_name, O_RDONLY)) < 0) {
			return (-1);
		}
		if ((slice = read_vtoc(rfd, &vtoc)) < 0) {
			close(rfd);
			return (-1);
		}
		close(rfd);
		if (vtoc.v_part[slice].p_start < CFG_VTOC_SIZE)
			return (1);
		else
			return (0);
	}

	return (-1);
}

/*
 * comapares incore header with one on disk
 * returns 0 if equal, 1 if not,  -1 error
 */
int
cfg_hdrcmp(cfp_t *cfp)
{
	cfgheader_t *dskhdr, *memhdr;
	int rc;

	if ((dskhdr = calloc(1, sizeof (*dskhdr))) == NULL) {
		cfg_perror_str = dgettext("cfg", "cfg_hdrcmp: No memory");
		cfg_severity = CFG_ENONFATAL;
	}

	if ((*cfp->cf_pp->seek)(cfp, 0, SEEK_SET) < 0) {
		cfg_perror_str = dgettext("cfg", "cfg_hdrcmp: seek failed");
		cfg_severity = CFG_ENONFATAL;
		free(dskhdr);
		return (-1);
	}

	rc = (*cfp->cf_pp->read)(cfp, (char *)dskhdr, sizeof (*dskhdr));
	if (rc < 0) {
		cfg_perror_str = dgettext("cfg", "cfg_hdrcmp: read failed");
		cfg_severity = CFG_ENONFATAL;
		free(dskhdr);
		return (-1);
	}

	memhdr = cfp->cf_head;

	if ((memhdr->h_seq1 == dskhdr->h_seq1) &&
	    (memhdr->h_seq2 == dskhdr->h_seq2))
		rc = 0;
	else
		rc = 1;


	free(dskhdr);
	return (rc);
}