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

/*
 * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
/*	  All Rights Reserved  	*/


/*
 * data base routines for the network listener process
 */

/* system include files	*/

#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <sys/param.h>
#include <sys/types.h>
#include <sys/tiuser.h>
#include <sys/stropts.h>

/* listener include files */

#include "lsparam.h"		/* listener parameters		*/
#include "listen.h"		/* listener includes 		*/
#include "lsfiles.h"		/* listener files info		*/
#include "lserror.h"		/* listener error codes		*/
#include "lsdbf.h"		/* data base file stuff		*/
/* #include "nsaddr.h"		nls includes			*/

#define SUPPRESS	1	/* suppress messages during scan*/
#define NOSUPPRESS	0	/* don't suppress messages 	*/

/* static data		*/

static char *dbfopenmsg = "Trouble opening data base file";
static char *dbfrderror = "Error reading data base file: line %d";
static char *dbfbadlmsg = "Data base file: Error on line %d";
static char *dbfdupcmsg = "Data base file: Duplicate service code: <%s>";
static char *dbfunknown = "Unknown error reading data base file: line %d";
static char *dbfsvccmsg = "Data base file: Illegal service code: <%s>";
static char *dbfcorrupt = "Data base file has been corrupted";

static int   Dbflineno;		/* current line number in dbf		*/
static unsigned Dbfentries;	/* number of non-comment lines		*/
extern char  *Server_cmd_lines; /* contains svc_code, cmd_line, mod_list */
extern char  *New_cmd_lines; /* svc_code, cmd_line, mod_list (on reread)*/

/* public variables */


/*
 * read_dbf:
 *
 * read the data base file into internal structures
 *
 * all data base routines under read_dbf log there own errors and return -1
 * in case of an error.
 *
 * if 're_read' is non-zero, this stuff is being called to read a new
 * data base file after the listener's initialization.
 */

int
read_dbf(re_read)
int	re_read;	/* zero means first time	*/
{
	register unsigned size;
	int exit_flag = EXIT | NOCORE;
	register dbf_t *dbf_p;
	register char  *cmd_p;
	unsigned scan_dbf();
	extern dbf_t *Dbfhead;		/* Dbfentries (when allocated)	*/
	extern dbf_t *Newdbf;		/* Dbfentries (on re-read)	*/
	extern char *calloc();

	DEBUG((9,"in read_dbf"));

	if (check_version())
		error(E_BADVER, EXIT | NOCORE);

	if (re_read)	{			/* not first time */
		exit_flag = CONTINUE;
	}

	/*
	 * note: data base routines log their own error messages
	 */

	Dbfentries = 0;
	DEBUG((9,"read_dbf: open file here:  %s", DBFNAME));
	if ( (size = scan_dbf(DBFNAME)) == (unsigned)(-1) )
		error( E_SCAN_DBF, exit_flag | NO_MSG );

	DEBUG((5,"read_dbf: scan complete: non-commented lines: %u, size: %u",
		Dbfentries, size));

	if (!size)  {
		logmessage("No database?  0 entries?");
		return(0);
	}

	/*
	 * allocate enough space for Dbfentries of 'size' bytes (total)
	 * The +1 is to insure a NULL last entry!
	 */

	if (!(dbf_p = (dbf_t *)calloc(Dbfentries+1,sizeof(dbf_t)))
	   || !(cmd_p = calloc(size, 1)))  {
		DEBUG((1,"cannot calloc %u + %u bytes", size,
			(Dbfentries+1)*(unsigned)sizeof(dbf_t)));
		error( E_DBF_ALLOC, exit_flag);	/* if init, exit */

		/* if still here, this is a re-read	*/

		if (dbf_p)
			free(dbf_p);
		if (cmd_p)
			free(cmd_p);
		return(-1);
	}

	if (get_dbf(dbf_p, cmd_p))  {
		DEBUG((9, "get_dbf FAILED"));
		error(E_DBF_IO, exit_flag | NO_MSG);

		/* if still here, this is a re_read */
		free(dbf_p);
		free(cmd_p);
		return(-1);
	}

	if (re_read)  {
		Newdbf = dbf_p;
		New_cmd_lines = cmd_p;
#ifdef	DEBUGMODE
		DEBUG((7,"read_dbf: NEW data base dump..."));
		if (Newdbf)
			for (dbf_p = Newdbf; dbf_p->dbf_svc_code; ++dbf_p)
				DEBUG((7, "svc code <%s>; id: %s; private address: %s; modules: %s; cmd line: %s; sflags: %x, prognum: %d version: %d",
				dbf_p->dbf_svc_code, dbf_p->dbf_id, dbf_p->dbf_prv_adr, dbf_p->dbf_modules, dbf_p->dbf_cmd_line, dbf_p->dbf_sflags, dbf_p->dbf_prognum, dbf_p->dbf_version));
#endif	/* DEBUGMODE */
	}
	else {
		Dbfhead = dbf_p;
		Server_cmd_lines = cmd_p;
#ifdef	DEBUGMODE
		DEBUG((7,"read_dbf: data base dump..."));
		if (Dbfhead)
			for (dbf_p = Dbfhead; dbf_p->dbf_svc_code; ++dbf_p)
				DEBUG((7, "svc code <%s>; id: %s; r1: %s; r2: %s; r3: %s; private address: %s; modules: %s; cmd line: %s; sflags: %x, prognum: %d version: %d",
				dbf_p->dbf_svc_code, dbf_p->dbf_id, dbf_p->dbf_res1, dbf_p->dbf_res2, dbf_p->dbf_res3, dbf_p->dbf_prv_adr, dbf_p->dbf_modules, dbf_p->dbf_cmd_line, dbf_p->dbf_sflags, dbf_p->dbf_prognum, dbf_p->dbf_version));
#endif	/* DEBUGMODE */
	}

	return(0);
}


/*
 * get_dbf: read the file and fill the structures
 *	    checking for duplicate entries as we go
 */

int
get_dbf(dbf_p, cmd_p)
register dbf_t *dbf_p;
register char *cmd_p;
{
	dbf_t *dbfhead = dbf_p;
	register int n, i;
	char buf[DBFLINESZ];
	register char *p = buf;
	char scratch[128];
	FILE *dbfilep;
	char *cmd_line_p;
	int flags;
	char *svc_code_p;
	char *id_p;
	char *res1_p;
	char *res2_p;
	char *res3_p;
	char *private_p;
	int sflags;
	int prognum;
	int vernum;
	char *module_p;
	register dbf_t *tdbf_p;
	extern int atoi();
	extern int Dbf_entries;
	extern int NLPS_proc;
	extern int errno;

	Dbflineno = 0;
	Dbf_entries = 0;  /* number of private addresses in dbf file */

	DEBUG((9,"in get_dbf: "));
	if (!(dbfilep = fopen(DBFNAME,"r")))  {
		logmessage(dbfopenmsg);
		error(E_DBF_IO, EXIT | NOCORE | NO_MSG);
	}

	while (n = rd_dbf_line(dbfilep,p,&svc_code_p,&flags,&id_p,&res1_p,&res2_p,&res3_p,&private_p,&prognum,&vernum,&module_p,&sflags,&cmd_line_p,NOSUPPRESS))  {

		if (n == -1)  {			/* read error	*/
			fclose(dbfilep);
			return(-1);
		}

		/* make sure service code is legal 			*/

		i = strlen(svc_code_p);
		if ( (i == 0) || (i >= SVC_CODE_SZ) )
			goto reject;

		/* check for duplicate service code			*/
		tdbf_p = dbfhead;
		while (tdbf_p->dbf_svc_code)  {	/* duplicate svc code?	*/
			if (!strcmp(svc_code_p, tdbf_p->dbf_svc_code))  {
				sprintf(scratch, dbfdupcmsg, svc_code_p);
				logmessage(scratch);
				return(-1);
			}
			++tdbf_p;
		}

		/* NLPS_proc is set by the nlps_server, which also uses these
		 * routines.  The actual listener child shouldn't ever need
		 * to read a database, so it will never be here
		 */
		if (!NLPS_proc && (strlen(private_p) == 0) && !(sflags & DFLAG))
			continue;	/* ignore entries with no address */

		/*
		 * child doesn't care about private addresses
		 */

		if (!NLPS_proc) {
			i = strlen(private_p);
			if (i >= PRV_ADR_SZ) {
				goto p_reject;
			}
			Dbf_entries++;
		}

		/*
		 * legal, non-duplicate entry: copy it into internal data base
		 */

		dbf_p->dbf_fd = -1;	/* set to actual fd in add_prvaddr */
		dbf_p->dbf_flags = flags;
		dbf_p->dbf_sflags = sflags;
		dbf_p->dbf_prognum = prognum;
		dbf_p->dbf_version = vernum;
		strcpy(cmd_p, svc_code_p);
		dbf_p->dbf_svc_code = cmd_p;
		cmd_p += strlen(svc_code_p) + 1;	/* +1 for null */
		strcpy(cmd_p, cmd_line_p);
		dbf_p->dbf_cmd_line = cmd_p;
		cmd_p += strlen(cmd_line_p) + 1;
		strcpy(cmd_p, id_p);
		dbf_p->dbf_id = cmd_p;
		cmd_p += strlen(id_p) + 1;
		strcpy(cmd_p, res1_p);
		dbf_p->dbf_res1 = cmd_p;
		cmd_p += strlen(res1_p) + 1;
		strcpy(cmd_p, res2_p);
		dbf_p->dbf_res2 = cmd_p;
		cmd_p += strlen(res2_p) + 1;
		strcpy(cmd_p, res3_p);
		dbf_p->dbf_res3 = cmd_p;
		cmd_p += strlen(res3_p) + 1;
		if (strlen(private_p) != 0) {
			strcpy(cmd_p, private_p);
			dbf_p->dbf_prv_adr = cmd_p;
			cmd_p += strlen(private_p) + 1;
		}
		else
			dbf_p->dbf_prv_adr = NULL;
		strcpy(cmd_p, module_p);
		dbf_p->dbf_modules = cmd_p;
		cmd_p += strlen(module_p) + 1;	/* cmd line + null char */
		++dbf_p;
	}

	fclose(dbfilep);
	return(0);

reject:
	DEBUG((9, "svc_code <%s> failed validation test", svc_code_p));
	sprintf(scratch, dbfsvccmsg, svc_code_p);
	logmessage(scratch);
	return(-1);
p_reject:
	DEBUG((9,"private address <%s> failed validation test", private_p));
	sprintf(scratch, "Invalid private address ignored: \\x%x", private_p);
	logmessage(scratch);
	return(-1);
}


/*
 * scan_dbf:	Take a quick pass through the data base file to figure out
 *		approx. how many items in the file we'll need to
 *		allocate storage for.  Essentially, returns the number
 *		of non-null, non-comment lines in the data base file.
 *
 *		return: -1 == error.
 *			other == number of non-comment characters.
 *			Dbfentries set.
 */

unsigned
scan_dbf(path)
register char *path;
{
	register unsigned int size = 0;
	register int n;
	register FILE *dbfilep;
	char buf[DBFLINESZ];
	register char *p = buf;
	char *svc_code_p;
	int flags;
	char *cmd_line_p;
	char *module_p;
	char *id_p;
	char *res1_p;
	char *res2_p;
	char *res3_p;
	int sflags;
	int prognum;
	int vernum;
	char *private_p;
	extern int errno;

	DEBUG((9, "In scan_dbf.  Scanning data base file %s.", path));

	if (!(dbfilep = fopen(path,"r")))  {
		DEBUG((9,"errorno = %d", errno));
		logmessage(dbfopenmsg);
		return(-1);
	}

	do {
		n = rd_dbf_line(dbfilep,p,&svc_code_p,&flags,&id_p,&res1_p,&res2_p,&res3_p,&private_p,&prognum,&vernum,&module_p,&sflags,&cmd_line_p,SUPPRESS);
		if (n == -1)  {
			fclose(dbfilep);
			return(-1);
		}
		size += (unsigned)n;
		if (n)
			++Dbfentries;
	} while (n);

	fclose(dbfilep);
	return(size);
}


/*
 * rd_dbf_line:	Returns the next non-comment line into the
 *		given buffer (up to DBFLINESZ bytes).
 *		Skips 'ignore' lines.
 *
 *		Returns:	0 = done, -1 = error,
 * 				other = cmd line size incl. terminating null.
 *				*svc_code_p = service code;
 *				*id_p = user id string;
 *				*res1_p = reserved string;
 *				*res2_p = reserved string;
 *				*res3_p = reserved string;
 *				*private_p = contains private address;
 *				*flags_p = decoded flags;
 *				prognum = RPC program #;
 *				vernum = RPC version $;
 *				cnd_line_p points to null terminated cmd line;
 *
 * When logging errors, the extern Dbflineno is used.
 */

int
rd_dbf_line(fp, bp, svc_code_p, flags_p, id_p, res1_p, res2_p, res3_p, private_p, prognum, vernum, module_p, sflags, cmd_line_p, mflag)
register FILE *fp;
register char *bp;
char **svc_code_p;
int *flags_p;
char **id_p;
char **res1_p;
char **res2_p;
char **res3_p;
char **private_p;
int *prognum;
int *vernum;
char **module_p;
int *sflags;
char **cmd_line_p;
int mflag;
{
	register int length;
	register char *p;

	do {
		++Dbflineno;
		length = 0;

		if (!fgets(bp, DBFLINESZ, fp))  {
			if (feof(fp))  {
				return(0);	/* EOF	*/
			}
			if (ferror(fp))  {
				sprintf(bp,dbfrderror,Dbflineno);
				logmessage(bp);
				return(-1);
			}
			sprintf(bp,dbfunknown,Dbflineno);
			logmessage(bp);
			return(-1);		/* Unknown error (?)	*/
		}

		if (*(bp+strlen(bp)-1) != '\n')  {  /* terminating newline? */
			sprintf(bp, dbfbadlmsg, Dbflineno);
			logmessage(bp);
			return(-1);
		}

		*(bp + strlen(bp) -1) = (char)0; /* delete newline	*/

		if (strlen(bp) && (p = strchr(bp, DBFCOMMENT)))
			*p = (char)0;		/* delete comments	*/
		if (!strlen(bp))
			continue;

		p = bp + strlen(bp) - 1;	/* bp->start; p->end	*/
		while ((p != bp) && (isspace(*p)))  {
			*p = (char)0;		/* delete terminating spaces */
			--p;
		}

		while (*bp)			/* del beginning white space*/
			if (isspace(*bp))
				++bp;
			else
				break;

		if (strlen(bp)) {		/* anything left?	*/

		   if (!(length=scan_line(bp,svc_code_p,flags_p,id_p,res1_p,res2_p,res3_p,private_p,prognum,vernum,module_p,sflags,cmd_line_p,mflag))) {

			DEBUG((1, "rd_dbf_line line %d, error while scanning entry",
			  Dbflineno));
			sprintf(bp, dbfbadlmsg, Dbflineno);
			logmessage(bp);
			return(-1);
		    }
		}

	}  while (!length);		/* until we have something */

	DEBUG((5,"rd_dbf_line: line: %d,cmd line len: %d",Dbflineno, length+1));

	return(length+1); /* +1 for the trailing NULL */

}


/*
 * scan a non-white space line
 *		0 = error;
 *		other = length of cmd line;
 *
 *	non-null lines have the following format:
 *
 *	service_code: flags: id: res1: res2: res3: private address: rpcdata: sflags: modules: cmd_line # comments
 *
 * mflag is set to suppress messages (scan_line is called both for parsing
 * and counting, messages should only be output once)
 */

int
scan_line(bp, svc_code_p, flags_p, id_p, res1_p, res2_p, res3_p, private_p, prognum, vernum, module_p, sflags, cmd_line_p, mflag)
register char *bp;
char **svc_code_p;
register int *flags_p;
char **id_p;
char **res1_p;
char **res2_p;
char **res3_p;
char **private_p;
int *prognum;
int *vernum;
char **module_p;
int *sflags;
register char **cmd_line_p;
int mflag;
{
	register char *p;
	register char *nexttok;
	register char *ptr;
	int sawsep = 0;
	char scratch[BUFSIZ];

	*flags_p = 0;

	if (!(p = strchr(bp, DBFTOKSEP ))) {	/* look for service code string */
		DEBUG((9,"scan_line failed svc_code strchr"));
		return(0);
	}
	*p = '\0';
	*svc_code_p = bp;
	nexttok = ++p;

	if (!(p = strchr(nexttok, DBFTOKSEP )))  {
		DEBUG((9,"scan_line failed flags strchr"));
		return(0);
	}
	*p = '\0';

	while (*nexttok)  {
		switch (*nexttok)  {
		case 'x':		/* service is turned off	*/
		case 'X':
			*flags_p |= DBF_OFF;
			break;
		case 'u':		/* create utmp entry		*/
			*flags_p |= DBF_UTMP;
			break;
		default:
			DEBUG((1,"scan_line: unknown flag char: 0x%x",*nexttok));
			*flags_p = DBF_UNKNOWN;
			break;
		}
		++nexttok;
	}
	nexttok = ++p;

	if (!(p = strchr(nexttok, DBFTOKSEP ))) {
		DEBUG((9,"scan_line failed id strchr"));
		return(0);
	}
	*p = '\0';
	*id_p = nexttok;
	nexttok = ++p;

	if (!(p = strchr(nexttok, DBFTOKSEP ))) {
		DEBUG((9,"scan_line failed res1 strchr"));
		return(0);
	}
	*p = '\0';
	*res1_p = nexttok;
	nexttok = ++p;

	if (!(p = strchr(nexttok, DBFTOKSEP ))) {
		DEBUG((9,"scan_line failed res2 strchr"));
		return(0);
	}
	*p = '\0';
	*res2_p = nexttok;
	nexttok = ++p;

	if (!(p = strchr(nexttok, DBFTOKSEP ))) {
		DEBUG((9,"scan_line failed res3 strchr"));
		return(0);
	}
	*p = '\0';
	*res3_p = nexttok;
	nexttok = ++p;

	if (!(p = strchr(nexttok, DBFTOKSEP ))) {
		DEBUG((9,"scan_line failed private strchr"));
		return(0);
	}
	*p = '\0';
	*private_p = nexttok;
	nexttok = ++p;

	if (!(p = strchr(nexttok, DBFTOKSEP ))) {
		DEBUG((9,"scan_line failed rpc strchr"));
		return(0);
	}
	*p = '\0';

	*prognum = -1;
	*vernum = -1;
	if (*nexttok) {
		/* there is rpc info */
		for (ptr = nexttok; *ptr; ++ptr) {
			if ((*ptr == ',') && !sawsep) {
				/*
				 * skip separator - note that if
				 * separator has been seen, it's not
				 * a digit so it will fail below
				 */
				sawsep++;
				continue;
			}
			if (!isdigit(*ptr)) {
				sprintf(scratch, "service code <%s> specifies non-integer rpc info", *svc_code_p);
				logmessage(scratch);
				return(0);
			}
		}
		ptr = strchr(nexttok, ',');
		if (ptr) {
			if ((*prognum = atoi(nexttok)) < 0) {
				if (!mflag) {
					/* messages aren't suppressed */
					sprintf(scratch, "service code <%s> specifies negative program number", *svc_code_p);
					logmessage(scratch);
				}
				return(0);
			}
			if ((*vernum = atoi(ptr + 1)) < 0) {
				if (!mflag) {
					sprintf(scratch, "service code <%s> specifies negative version number", *svc_code_p);
					logmessage(scratch);
				}
				return(0);
			}
		}
		else {
			if (!mflag) {
				sprintf(scratch, "service code <%s> - invalid rpcinfo", *svc_code_p);
				logmessage(scratch);
			}
			return(0);
		}
	}
	nexttok = ++p;

	if (!(p = strchr(nexttok, DBFTOKSEP ))) {
		DEBUG((9,"scan_line failed sflags strchr"));
		return(0);
	}
	*p = '\0';

	*sflags = 0;
	while (*nexttok)  {
		switch (*nexttok)  {
		case 'c':	/* dbf_cmd_line is a command */
			*sflags |= CFLAG;
			break;
		case 'd':	/* dynamic address */
			if ((int) strlen(*private_p) > 0) {
				if (!mflag) {
					sprintf(scratch, "service code <%s> specifies static and dynamic address", *svc_code_p);
					logmessage(scratch);
					logmessage("  address info ignored");
				}
				/* don't set DFLAG and wipe out private addr */
				**private_p = '\0';
			}
			else {
				*sflags |= DFLAG;
			}
			break;
		case 'p':	/* dbf_cmd_line is a pipe */
			*sflags |= PFLAG;
			break;
		default:
			if (!mflag) {
				sprintf(scratch, "service code <%s> unknown flag <%c> ignored", *svc_code_p, *nexttok);
				logmessage(scratch);
			}
			break;
		}
		++nexttok;
	}
	nexttok = ++p;

	if (!(p = strchr(nexttok, DBFTOKSEP ))) {
		DEBUG((9,"scan_line failed module strchr"));
		return(0);
	}
	*p = '\0';
	*module_p = nexttok;
	nexttok = ++p;

	*cmd_line_p = nexttok;

	DEBUG((9,"scan_line: modules: %s; line: %s; len: %d", *module_p, *cmd_line_p, strlen(*svc_code_p)+strlen(*id_p)+strlen(*res1_p)+strlen(*res2_p)+strlen(*res3_p)+strlen(*private_p)+strlen(*module_p)+strlen(*cmd_line_p)+9));
	/*
	 * return the length of the buffer.  Add 9 for the NULLs after each
	 * string
	 */
	return(strlen(*svc_code_p)+strlen(*id_p)+strlen(*res1_p)+strlen(*res2_p)+strlen(*res3_p)+strlen(*private_p)+strlen(*module_p)+strlen(*cmd_line_p)+9);
}



#define VERSIONSTR	"# VERSION="

int
check_version(void)
{
	FILE *fp;
	char *line, *p, *tmp;
	int version;

	if ((fp = fopen(DBFNAME, "r")) == NULL) {
		logmessage(dbfopenmsg);
		error(E_DBF_IO, EXIT | NOCORE | NO_MSG);
	}
	if ((line = (char *) malloc(DBFLINESZ)) == NULL)
		error(E_DBF_ALLOC, EXIT | NOCORE);
	p = line;
	while (fgets(p, DBFLINESZ, fp)) {
		if (!strncmp(p, VERSIONSTR, strlen(VERSIONSTR))) {
			/* pitch the newline */
			tmp = strchr(p, '\n');
			if (tmp)
				*tmp = '\0';
			else {
				logmessage(dbfcorrupt);
				error(E_DBF_CORRUPT, EXIT | NOCORE);
			}
			p += strlen(VERSIONSTR);
			if (*p)
				version = atoi(p);
			else {
				logmessage(dbfcorrupt);
				error(E_DBF_CORRUPT, EXIT | NOCORE);
			}
			free(line);
			fclose(fp);
			if (version != VERSION)
				return(1);	/* wrong version */
			else
				return(0);	/* version ok */
		}
		p = line;
	}
	logmessage(dbfcorrupt);
	error(E_DBF_CORRUPT, EXIT | NOCORE);
	return(1);
}


/*
 * mkdbfargv:	Given a pointer to a dbf_t, construct argv
 *		for an exec system call.
 *		Warning: returns a pointer to static data which are
 *			 overritten by each call.
 *
 *		There is a practical limit of 50 arguments (including argv[0])
 *
 *		Warning: calling mkdbfargv destroys the data (by writing null
 *		characters via strtok) pointed to by dbp->dbf_cmd_line.
 */

static char *dbfargv[50];
static char *delim = " \t'\"";		/* delimiters */

char **
mkdbfargv(dbp)
register dbf_t	*dbp;
{
	register char **argvp = dbfargv;
	register char *p = dbp->dbf_cmd_line;
	char delch;
	register char *savep;
	register char *tp;
	char scratch[BUFSIZ];
	char *strpbrk();
#ifdef	DEBUGMODE
	register int i = 0;
#endif

	*argvp = 0;
	savep = p;
	while (p && *p) {
		if (p = strpbrk(p, delim)) {
			switch (*p) {
			case ' ':
			case '\t':
				/* "normal" cases */
				*p++ = '\0';
				*argvp++ = savep;
				DEBUG((9, "argv[%d] = %s", i++, savep));
				/* zap trailing white space */
				while (isspace(*p))
					p++;
				savep = p;
				break;
			case '"':
			case '\'':
				/* found a string */
				delch = *p; /* remember the delimiter */
				savep = ++p;

/*
 * We work the string in place, embedded instances of the string delimiter,
 * i.e. \" must have the '\' removed.  Since we'd have to do a compare to
 * decide if a copy were needed, it's less work to just do the copy, even
 * though it is most likely unnecessary.
 */

				tp = p;
				for (;;) {
					if (*p == '\0') {
						sprintf(scratch, "invalid command line, non-terminated string for service code %s", dbp->dbf_svc_code);
						logmessage(scratch);
						exit(2); /* server, don't log */
					}
					if (*p == delch) {
						if (*(tp - 1) == '\\') { /* \delim */
							*(tp - 1) = *p;
							p++;
						}
						else { /* end of string */
							*tp = 0;
							*argvp++ = savep;
							DEBUG((9, "argv[%d] = %s", i++, savep));
							p++;
							/* zap trailing white space */
							while (isspace(*p))
								p++;
							savep = p;
							break;
						}
					}
					else {
						*tp++ = *p++;
					}
				}
				break;
			default:
				logmessage("Internal error in parse routine");
				exit(2); /* server, don't log */
			}
		}
		else {
			*argvp++ = savep;
			DEBUG((9, "argv[%d] = %s", i++, savep));
		}
	}
	*argvp = 0;
	return(dbfargv);
}



/*
 *
 * getentry: Given a fd, this routine will return a
 *		    dbf entry.  If the entry doesn't exist it will
 *		    return NULL.
 */

dbf_t *
getentry(fd)
int	fd;
{
	extern dbf_t *Dbfhead;		/* Dbfentries (when allocated)	*/
	register dbf_t 	*dbp = Dbfhead;

	if (!Dbfhead) {		/* no private address in database file */
		DEBUG((9, "getdbfentry - nothing in Dbfhead = %s ",Dbfhead));
		return((dbf_t *)0);
	}
	else
		for (dbp = Dbfhead;  dbp->dbf_prv_adr;   ++dbp)
			if (fd == dbp->dbf_fd) {
				return(dbp);
			}

	return((dbf_t *)0);	/* requested private address not in list */

}


/*
 * pushmod:	push modules if defined in the data base entry.
 *
 *		WARNING: This routine writes into the in-memory copy
 *		of the database file.  Therefore, after it is called,
 *		the incore copy of the database file will no longer be valid.
 */

int
pushmod(fd, mp)
int fd;
register char *mp;
{
	register char *cp;
	register char *bufp = mp;
	char name[32];
	extern int errno;

	DEBUG((9,"in pushmod:"));
	if (!mp || *mp == '\0') {
		DEBUG((9,"NULL list: exiting pushmod"));
		return(0);
	}
	/* pop timod if it is on the stack */
	if (ioctl(fd, I_LOOK, name) >= 0) {
		if (strcmp(name, "timod") == 0) {
			if (ioctl(fd, I_POP, 0) < 0)
				DEBUG((9,"pushmod: I_POP failed"));
		}
	}
	while ((cp = strtok(bufp, ",")) != NULL) {
		bufp = NULL;
		DEBUG((9,"pushmod: about to push %s", cp));
		if (ioctl(fd, I_PUSH, cp) < 0) {
			DEBUG((9,"pushmod: ioctl failed, errno = %d",errno));
			return(1);
		}
	}
	DEBUG((9,"exiting pushmod:"));
	return(0);
}