/*
 * 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 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

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

#include <stdio.h>
#include <limits.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <ctype.h>
#include <sys/types.h>
#include <libintl.h>
#include "pkglib.h"
#include "pkgstrct.h"
#include "pkglocale.h"
#include "pkglibmsgs.h"

/*
 * Forward declarations
 */

static int	getend(char **cp);
static int	getstr(char **cp, int n, char *str, int separator[]);

/* from gpkgmap.c */
int	getnumvfp(char **cp, int base, long *d, long bad);
int	getlnumvfp(char **cp, int base, fsblkcnt_t *d, long bad);

/*
 * Module globals
 */

static char	lpath[PATH_MAX];	/* for ept->path */
static char	mylocal[PATH_MAX];	/* for ept->ainfo.local */
static int	decisionTableInit = 0;

/*
 * These arrays must be indexable by an unsigned char.
 */

static int	ISWORDSEP[UCHAR_MAX+1];
static int	ISPKGNAMESEP[UCHAR_MAX+1];

/*
 * Name:	COPYPATH
 * Description:	copy path limiting size to destination capacity
 * Arguments:	DEST - (char []) - [RW]
 *		SRC - (char *) - [RO, *RO]
 *			Pointer to first byte of path to copy
 *		LEN - (int) - [RO]
 *			Number of bytes to copy
 */

#define	COPYPATH(DEST, SRC, LEN)					\
	{								\
		/* assure return path does not overflow */		\
		if ((LEN) > sizeof ((DEST))) {				\
			(LEN) = sizeof ((DEST))-1;			\
		}							\
		/* copy return path to local storage */			\
		(void) memcpy((DEST), (SRC), (LEN));			\
		(DEST)[(LEN)] = '\0';					\
	}

/*
 * Name:	srchcfile
 * Description:	search contents file looking for closest match to entry,
 *		creating a new contents file if output contents file specified
 * Arguments:	ept - (struct cfent *) - [RO, *RW]
 *			- contents file entry, describing last item found
 *		path - (char *) - [RO, *RO]
 *			- path to search for in contents file
 *			- If path is "*", then the next entry is returned;
 *				the next entry always matches this path
 *		PKGserver
 *			- our door to the database server.
 *
 * Returns:	int
 *		< 0 - error occurred
 *			- Use getErrstr to retrieve character-string describing
 *			  the reason for failure
 *		== 0 - no match found
 *			- specified path not in the contents file
 *		== 1 - exact match found
 *			- specified path found in contents file
 *			- this value is always returned if path is "*" and the
 *			  next entry is returned - 0 is returned when no more
 *			  entries are left to process
 * Side Effects:
 *		- The ept structure supplied is filled in with a description of
 *		  the item that caused the search to terminate, except in the
 *		  case of '0' in which case the contents of 'ept' is undefined.
 *		- NOTE: the ept->path item points to a path that is statically
 *		  allocated and will be overwritten on the next call.
 *		- NOTE: the ept->ainfo.local item points to a path that is
 *		  statically allocated and will be overwritten on the next call.
 */

int
srchcfile(struct cfent *ept, char *path, PKGserver server)
{
	char		*cpath_start = NULL;
	char		classname[CLSSIZ+1];
	char		pkgname[PKGSIZ+1];
	int		anypath = 0;
	int		c;
	int		cpath_len = 0;
	struct pinfo	*lastpinfo;
	struct pinfo	*pinfo;
	char		*p;
	char		*curbuf;
	int		linelen;	/* includes NUL */

	/*
	 * this code does not use nested subroutines because execution time
	 * of this routine is especially critical to installation and upgrade
	 */

	/* initialize local variables */

	setErrstr(NULL);	/* no error message currently cached */
	lpath[0] = '\0';
	lpath[sizeof (lpath)-1] = '\0';

	/* initialize ept structure values */

	(void) strlcpy(ept->ainfo.group, BADGROUP, sizeof (ept->ainfo.group));
	(void) strlcpy(ept->ainfo.owner, BADOWNER, sizeof (ept->ainfo.owner));
	(void) strlcpy(ept->pkg_class, BADCLASS,  sizeof (ept->pkg_class));
	ept->ainfo.local = (char *)NULL;
	ept->ainfo.mode = BADMODE;
	ept->cinfo.cksum = BADCONT;
	ept->cinfo.modtime = BADCONT;
	ept->cinfo.size = (fsblkcnt_t)BADCONT;
	ept->ftype = BADFTYPE;
	ept->npkgs = 0;
	ept->path = (char *)NULL;
	ept->pinfo = (struct pinfo *)NULL;
	ept->pkg_class_idx = -1;
	ept->volno = 0;

	/*
	 * populate decision tables that implement fast character checking;
	 * this is much faster than the equivalent strpbrk() call or a
	 * while() loop checking for the characters. It is only faster if
	 * there are at least 3 characters to scan for - when checking for
	 * one or two characters (such as '\n' or '\0') its faster to do
	 * a simple while() loop.
	 */

	if (decisionTableInit == 0) {
		/*
		 * any chars listed stop scan;
		 * scan stops on first byte found that is set to '1' below
		 */

		/*
		 * Separators for normal words
		 */
		bzero(ISWORDSEP, sizeof (ISWORDSEP));
		ISWORDSEP[' '] = 1;
		ISWORDSEP['\t'] = 1;
		ISWORDSEP['\n'] = 1;
		ISWORDSEP['\0'] = 1;

		/*
		 * Separators for list of packages, includes \\ for
		 * alternate ftype and : for classname
		 */
		bzero(ISPKGNAMESEP, sizeof (ISPKGNAMESEP));
		ISPKGNAMESEP[' '] = 1;
		ISPKGNAMESEP['\t'] = 1;
		ISPKGNAMESEP['\n'] = 1;
		ISPKGNAMESEP[':'] = 1;
		ISPKGNAMESEP['\\'] = 1;
		ISPKGNAMESEP['\0'] = 1;

		decisionTableInit = 1;
	}

	/* if the path to scan for is empty, act like no path was specified */

	if ((path != NULL) && (*path == '\0')) {
		path = NULL;
	}

	/*
	 * if path to search for is "*", then we will return the first path
	 * we encounter as a match, otherwise we return an error
	 */

	if ((path != NULL) && (path[0] != '/')) {
		if (strcmp(path, "*") != 0) {
			setErrstr(pkg_gt(ERR_ILLEGAL_SEARCH_PATH));
			return (-1);
		}
		anypath = 1;
	}

	/* attempt to narrow down the search for the specified path */

	if (anypath == 0 && path == NULL)
		return (0);

	/* determine first character of the next entry */
	if (anypath == 0)
		curbuf = pkggetentry_named(server, path, &linelen, &cpath_len);
	else
		curbuf = pkggetentry(server, &linelen, &cpath_len);

	if (curbuf == NULL)
		return (0);

	/*
	 * current entry DOES start with absolute path
	 * set ept->path to point to lpath
	 * set cpath_start/cpath_len to point to the file name
	 */

	/* copy first token into path element of passed structure */

	cpath_start = curbuf;

	p = cpath_start + cpath_len;

	ept->path = lpath;

	/* copy path found to 'lpath' */
	COPYPATH(lpath, cpath_start, cpath_len);

	/* get first character following the end of the path */

	c = *p++;

	/*
	 * we want to return information about this path in
	 * the structure provided, so parse any local path
	 * and jump to code which parses rest of the input line
	 */
	if (c == '=') {
		/* parse local path specification */
		if (getstr(&p, PATH_MAX, mylocal, ISWORDSEP)) {
			setErrstr(ERR_CANNOT_READ_LL_PATH);
			return (-1);
		}
		ept->ainfo.local = mylocal;
	}

	/*
	 * if an exact match and processing a new style entry, read the
	 * remaining information from the new style entry.
	 */

	while (isspace((c = *p++)))
		;

	switch (c) {
	case '?': case 'f': case 'v': case 'e': case 'l':
	case 's': case 'p': case 'c': case 'b': case 'd':
	case 'x':
		/* save ftype */
		ept->ftype = (char)c;

		/* save class */
		if (getstr(&p, CLSSIZ, ept->pkg_class, ISWORDSEP)) {
			setErrstr(ERR_CANNOT_READ_CLASS_TOKEN);
			return (-1);
		}
		break; /* we already read the pathname */

	case '\0':
		/* end of line before new-line seen */
		setErrstr(ERR_INCOMPLETE_ENTRY);
		return (-1);

	case '0': case '1': case '2': case '3': case '4':
	case '5': case '6': case '7': case '8': case '9':
		setErrstr(ERR_VOLUMENO_UNEXPECTED);
		return (-1);

	case 'i':
		setErrstr(ERR_FTYPE_I_UNEXPECTED);
		return (-1);

	default:
		/* unknown ftype */
		setErrstr(ERR_UNKNOWN_FTYPE);
		return (-1);
	}

	/* link/symbolic link must have link destination */

	if (((ept->ftype == 's') || (ept->ftype == 'l')) &&
	    (ept->ainfo.local == NULL)) {
		setErrstr(ERR_NO_LINK_SOURCE_SPECIFIED);
		return (-1);
	}

	/* character/block devices have major/minor device numbers */

	if (((ept->ftype == 'c') || (ept->ftype == 'b'))) {
		ept->ainfo.major = BADMAJOR;
		ept->ainfo.minor = BADMINOR;
		if (getnumvfp(&p, 10, (long *)&ept->ainfo.major, BADMAJOR) ||
		    getnumvfp(&p, 10, (long *)&ept->ainfo.minor, BADMINOR)) {
			setErrstr(pkg_gt(ERR_CANNOT_READ_MM_NUMS));
			return (-1);
		}
	}

	/* most types have mode, owner, group identification components */

	if ((ept->ftype == 'd') || (ept->ftype == 'x') || (ept->ftype == 'c') ||
	    (ept->ftype == 'b') || (ept->ftype == 'p') ||
	    (ept->ftype == 'f') || (ept->ftype == 'v') ||
	    (ept->ftype == 'e')) {
		/* mode, owner, group should be here */
		if (getnumvfp(&p, 8, (long *)&ept->ainfo.mode, BADMODE) ||
		    getstr(&p, sizeof (ept->ainfo.owner), ept->ainfo.owner,
		    ISWORDSEP) ||
		    getstr(&p, sizeof (ept->ainfo.group), ept->ainfo.group,
		    ISWORDSEP)) {
			setErrstr(ERR_CANNOT_READ_MOG);
			return (-1);
		}
	}

	/* i/f/v/e have size, checksum, modification time components */

	if ((ept->ftype == 'i') || (ept->ftype == 'f') ||
	    (ept->ftype == 'v') || (ept->ftype == 'e')) {
		/* look for content description */
		if (getlnumvfp(&p, 10, (fsblkcnt_t *)&ept->cinfo.size,
		    BADCONT) ||
		    getnumvfp(&p, 10, (long *)&ept->cinfo.cksum, BADCONT) ||
		    getnumvfp(&p, 10, (long *)&ept->cinfo.modtime, BADCONT)) {
			setErrstr(ERR_CANNOT_READ_CONTENT_INFO);
			return (-1);
		}
	}

	/* i files processing is completed - return 'exact match found' */

	if (ept->ftype == 'i') {
		return (1);
	}

	/*
	 * determine list of packages which reference this entry
	 */

	lastpinfo = (struct pinfo *)NULL;
	while ((c = getstr(&p, sizeof (pkgname), pkgname, ISPKGNAMESEP)) <= 0) {
		/* if c < 0 the string was too long to fix in the buffer */

		if (c < 0) {
			setErrstr(ERR_PACKAGE_NAME_TOO_LONG);
			return (-1);
		}

		/* a package is present - create and populate pinfo structure */

		pinfo = (struct pinfo *)calloc(1, sizeof (struct pinfo));
		if (!pinfo) {
			setErrstr(ERR_NO_MEMORY);
			return (-1);
		}
		if (!lastpinfo) {
			ept->pinfo = pinfo; /* first one */
		} else {
			lastpinfo->next = pinfo; /* link list */
		}
		lastpinfo = pinfo;

		if ((pkgname[0] == '-') || (pkgname[0] == '+') ||
		    (pkgname[0] == '*') || (pkgname[0] == '~') ||
		    (pkgname[0] == '!') || (pkgname[0] == '%')) {
			pinfo->status = pkgname[0];
			(void) strlcpy(pinfo->pkg, pkgname+1,
			    sizeof (pinfo->pkg));
		} else {
			(void) strlcpy(pinfo->pkg, pkgname,
			    sizeof (pinfo->pkg));
		}

		/* pkg/[:[ftype][:class] */
		c = *p++;
		if (c == '\\') {
			/* get alternate ftype */
			pinfo->editflag++;
			c = *p++;
		}

		if (c == ':') {
			/* get special classname */
			(void) getstr(&p, sizeof (classname), classname,
			    ISWORDSEP);
			(void) strlcpy(pinfo->aclass, classname,
			    sizeof (pinfo->aclass));
			c = *p++;
		}
		ept->npkgs++;

		/* break out of while if at end of entry */

		if ((c == '\n') || (c == '\0')) {
			break;
		}

		/* if package not separated by a space return an error */

		if (!isspace(c)) {
			setErrstr(ERR_BAD_ENTRY_END);
			return (-1);
		}
	}

	/*
	 * parsing of the entry is complete
	 */

	/* if not at the end of the entry, make it so */

	if ((c != '\n') && (c != '\0')) {
		if (getend(&p) && ept->pinfo) {
			setErrstr(ERR_EXTRA_TOKENS);
			return (-1);
		}
	}

	return (1);
}

static int
getstr(char **cp, int n, char *str, int separator[])
{
	int	c;
	char	*p = *cp;
	char	*p1;
	size_t	len;

	if (*p == '\0') {
		return (1);
	}

	/* leading white space ignored */

	while (((c = *p) != '\0') && (isspace(*p++)))
		;
	if ((c == '\0') || (c == '\n')) {
		p--;
		*cp = p;
		return (1); /* nothing there */
	}

	p--;

	/* compute length based on delimiter found or not */

	p1 = p;
	while (separator[(int)(*(unsigned char *)p1)] == 0) {
		p1++;
	}

	len = (ptrdiff_t)p1 - (ptrdiff_t)p;

	/* if string will fit in result buffer copy string and return success */

	if (len < n) {
		(void) memcpy(str, p, len);
		str[len] = '\0';
		p += len;
		*cp = p;
		return (0);
	}

	/* result buffer too small; copy partial string, return error */
	(void) memcpy(str, p, n-1);
	str[n-1] = '\0';
	p += n;
	*cp = p;
	return (-1);
}

static int
getend(char **cp)
{
	int	n;
	char	*p = *cp;

	n = 0;

	/* if at end of buffer return no more characters left */

	if (*p == '\0') {
		return (0);
	}

	while ((*p != '\0') && (*p != '\n')) {
		if (n == 0) {
			if (!isspace(*p)) {
				n++;
			}
		}
		p++;
	}

	*cp = ++p;
	return (n);
}