srchcfile.c revision 5c51f1241dbbdf2656d0e10011981411ed0c9673
/*
* 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
* 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 <libintl.h>
#include "pkglib.h"
#include "pkgstrct.h"
#include "pkglocale.h"
#include "pkglibmsgs.h"
/*
* Forward declarations
*/
/* from gpkgmap.c */
/*
* Module globals
*/
static int decisionTableInit = 0;
/*
* These arrays must be indexable by an unsigned char.
*/
/*
* Name: WRITEDATA
* Description: write out data to VFP_T given start and end pointers
* Arguments: VFP - (VFP_T *) - [RO, *RW]
* Contents file VFP to narrow search on
* FIRSTPOS - (char *) - [RO, *RO]
* Pointer to first byte to write out
* LASTPOS - (char *) - [RO, *RO]
* Pointer to last byte to write out
*/
{ \
/* compute number of bytes skipped */ \
/* write the bytes out */ \
}
/*
* 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
*/
{ \
/* assure return path does not overflow */ \
} \
/* copy return path to local storage */ \
}
/*
* Name: narrowSearch
* Description: narrow the search location for a specified path
* The contents and package map files are always sorted by path.
* This function is given a target path to search for given the
* current location in a contents file. It is assured that the
* target path has not been searched for yet in the contents file
* so the current location in the contents file is guaranteed to
* be less than the location of the target path (if present).
* Given this employ a binary search to speed up the search for
* the path nearest to a specified target path.
* Arguments: a_vfp - (VFP_T *) - [RO, *RW]
* Contents file VFP to narrow search on
* a_path - (char *) - [RO, *RO]
* Pointer to path to search for
* a_pathLen - (size_t) - [RO]
* Length of string (a_path)
* Returns: char * - pointer to first byte of entry in contents file that
* is guaranteed to be the closest match to the specified
* a_path without being "greater than" the path.
* == (char *)NULL if no entry found
*/
static char *
{
char *phigh;
char *plow;
char *pmid;
int n;
/* if no path to compare, start at beginning */
return ((char *)NULL);
}
/* if the contents file is empty, resort to sequential search */
return ((char *)NULL);
}
/*
* test against first path - if the path specified is less than the
* first path in the contents file, then the path can be inserted
* before the first entry in the contents file.
*/
/* locate start of first line */
/* if first path not absolute, resort to sequential search */
if (*pmid != '/') {
return ((char *)NULL);
}
/* find end of path */
while (ISPKGPATHSEP[(int)*pmid] == 0) {
pmid++;
}
/* determine length of path */
/* compare target path with current path */
if (n == 0) {
/* if lengths same exact match return position found */
return (plow);
}
/* not exact match - a_path > pm */
n = a_pathLen;
}
/* return if target is less than or equal to first entry */
if (n <= 0) {
return (plow);
}
/*
* test against last path - if the path specified is greater than the
* last path in the contents file, then the path can be appended after
* the last entry in the contents file.
*/
/* locate start of last line */
pmid--;
}
/* if absolute path, do comparison */
/* find end of path */
while (ISPKGPATHSEP[(int)*pmid] == 0) {
pmid++;
}
/* determine length of path */
/* compare target path with current path */
if (n == 0) {
/* if lengths same exact match return position found */
return (plow);
}
/* not exact match - a_path > pm */
n = a_pathLen;
}
/* return if target is greater than or equal to entry */
if (n >= 0) {
return (plow);
}
}
/*
* firstPath < targetpath < lastPath:
* binary search looking for closest "less than" match
*/
for (;;) {
char *pm;
/* determine number of bytes left in search area */
/* calculate mid point between current low and high points */
/* backup and find first "\n/" -or- start of buffer */
pmid--;
}
/* return lowest line found if current line not past that */
return (plow);
}
/* remember start of this line */
/* find end of path */
while (ISPKGPATHSEP[(int)*pmid] == 0) {
pmid++;
}
/* determine length of path */
/* compare target path with current path */
if (n == 0) {
/* if lengths same exact match return position found */
return (pm);
}
/* not exact match - a_path > pm */
n = a_pathLen;
}
/* not exact match - determine which watermark to split */
if (n > 0) { /* a_path > pm */
} else { /* a_path < pm */
}
}
/*NOTREACHED*/
}
/*
* 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
* - If the path is (char *)NULL or "", then all remaining
* entries are processed and copied out to the
* file specified by cfTmpVFp
* cfVfp - (VFP_T *) - [RO, *RW]
* - VFP_T open on contents file to search
* cfTmpVfp - (VFP_T *) - [RO, *RW]
* - VFP_T open on temporary contents file to populate
* 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
* - all contents of cfVfp copied to cfTmpVfp
* - current character of cfVfp is at end of file
* == 1 - exact match found
* - specified path found in contents file
* - contents of cfVfp up to entry found copied to cfTmpVfp
* - current character of cfVfp is first character of
* entry found
* - this value is always returned if path is "*" and the
* next entry is returned - -1 is returned when no more
* entries are left to process
* == 2 - entry found which is GREATER than path specified
* - specified path would fit BEFORE entry found
* - contents of cfVfp up to entry found copied to cfTmpVfp
* - current character of cfVfp is first character of
* entry found
* 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
{
char *cpath_start = (char *)NULL;
char *pos;
int anypath = 0;
int c;
int dataSkipped = 0;
int n;
int rdpath;
/*
* this code does not use nested subroutines because execution time
* of this routine is especially critical to installation and upgrade
*/
/* initialize local variables */
lpath[0] = '\0';
/* initialize ept structure values */
/*
* 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 path names, normal space and =
* for linked filenames
*/
/*
* Separators for normal words
*/
/*
* Separators for list of packages, includes \\ for
* alternate ftype and : for classname
*/
decisionTableInit = 1;
}
/* if no bytes in contents file, return 0 */
return (0);
}
/* if the path to scan for is empty, act like no path was specified */
}
/*
* if path to search for is "*", then we will return the first path
* we encounter as a match, otherwise we return an error
*/
return (-1);
}
anypath = 1;
}
/* attempt to narrow down the search for the specified path */
if (anypath == 0) {
char *np;
dataSkipped = 1;
}
}
/*
* If the path to search for in the source contents file is NULL, then
* this is a request to scan to the end of the source contents file. If
* there is a temporary contents file to copy entries to, all that needs
* to be done is to copy the data remaining from the current location in
* the source contents file to the end of the temporary contents file.
* if there is no temporary contents file to copy to, then all that
* needs to be done is to seek to the end of the source contents file.
*/
if (vfpGetBytesRemaining(cfVfp) > 0) {
}
}
return (0);
}
/*
* *********************************************************************
* main loop processing entries from the contents file looking for
* the specified path
* *********************************************************************
*/
for (;;) {
char *p;
/* not reading old style entry */
rdpath = 0;
/* determine first character of the next entry */
if (vfpGetBytesRemaining(cfVfp) <= 0) {
/* no bytes in contents file current char is NULL */
c = '\0';
} else {
/* grab path from first entry */
c = vfpGetcNoInc(cfVfp);
}
/* save current position in file */
/*
* =============================================================
* at the first character of the next entry in the contents file
* if not absolute path check for exceptions and old style entry
* --> if end of contents file write out skipped data and return
* --> if comment character skip to end of line and restart loop
* --> else process "old style entry: ftype class path"
* =============================================================
*/
if (c != '/') {
/* if NULL character then end of contents file found */
if (c == '\0') {
/* write out skipped data before returning */
if (dataSkipped &&
}
return (0); /* no more entries */
}
/* ignore lines that begin with #, : or a "space" */
/* line is a comment */
continue;
}
/*
* old style entry - format is:
* ftype class path
* set ept->ftype to the type
* set ept->class to the class
* set ept->path to point to lpath
* set cpath_start/cpath_len to point to the file name
* set rdpath to '1' to indicate old style entry parsed
*/
;
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 */
/* save class */
return (-1);
}
/*
* locate file name up to "=", set cpath_start
* and cpath_len to point to the file name
*/
p = vfpGetCurrCharPtr(cfVfp);
/*
* skip past all bytes until first '= \t\n\0':
*/
while (ISPKGPATHSEP[(int)*p] == 0) {
p++;
}
/*
* if the path is zero bytes, line is corrupted
*/
if (cpath_len < 1) {
return (-1);
}
/* set path to point to local path cache */
/* set flag indicating path already parsed */
rdpath = 1;
break;
case '\0':
/* end of line before new-line seen */
return (-1);
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
/* volume number seen */
return (-1);
case 'i':
/* type i files are not cataloged */
return (-1);
default:
/* unknown ftype */
return (-1);
}
} else {
/*
* 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 */
p = cpath_start;
/*
* skip past all bytes until first from '= \t\n\0':
*/
while (ISPKGPATHSEP[(int)*p] == 0) {
p++;
}
return (-1);
}
}
/*
* =============================================================
* if absolute path then the path is collected and we are at the
* first byte following the absolute path name;
* if not an absolute path then an old style entry, ept has been
* filled with the type and class and path name.
* determine if we have read the pathname which identifies
* the entry we are searching for
* =============================================================
*/
if (anypath != 0) {
n = 0; /* next entry is "equal to" */
n = 1; /* next entry is "greater than" */
} else {
if ((n == 0) && (cpath_len != pathLength)) {
n = cpath_len;
}
}
/* get first character following the end of the path */
/*
* if an exact match, always parse out the local path
*/
if (n == 0) {
/*
* 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 */
/* copy path found to 'lpath' */
return (-1);
}
}
}
/*
* if an exact match and processing a new style entry, read the
* remaining information from the new style entry - if this is
* an old style entry (rdpath != 0) then the existing info has
* already been processed as it exists before the pathname and
* not after like a new style entry
*/
if (n == 0 && rdpath == 0) {
;
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 */
/* save class */
/* copy path found to 'lpath' */
return (-1);
}
break; /* we already read the pathname */
case '\0':
/* end of line before new-line seen */
/* copy path found to 'lpath' */
return (-1);
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
/* copy path found to 'lpath' */
return (-1);
case 'i':
/* copy path found to 'lpath' */
return (-1);
default:
/* unknown ftype */
/* copy path found to 'lpath' */
return (-1);
}
}
/*
* if an exact match all processing is completed; break out of
* the main processing loop and finish processing this entry
* prior to returning to the caller.
*/
if (n == 0) {
break;
}
/*
* this entry is not an exact match for the path being searched
* for - if this entry is GREATER THAN the path being searched
* for then finish processing and return GREATER THAN result
* to the caller so the entry for the path being searched for
* can be added to the contents file.
*/
if (n < 0) {
/*
* the entry we want would fit BEFORE the one we just
* read, so we need to unread what we've read by
* seeking back to the start of this entry
*/
/* copy path found to 'lpath' */
/* write out any skipped data before returning */
}
return (2); /* path would insert here */
}
/*
* This entry is "LESS THAN" the specified path to search for
* need to process the next entry from the contents file. First,
* if writing to new contents file, update new contents file if
* processing old style entry; otherwise, update skipped data
* information to remember current last byte of skipped data.
*/
char *px;
if (rdpath != 0) {
/* modify record: write out any skipped data */
if (dataSkipped) {
}
/*
* copy what we've read and the rest of this
* line onto the specified output stream
*/
} else {
}
/* reset skiped bytes if any data skipped */
if (dataSkipped) {
dataSkipped = 0;
}
} else {
/* skip data */
dataSkipped = 1;
} else {
}
}
} else {
/*
* since this isn't the entry we want, just read the
* stream until we find the end of this entry and
* then start this search loop again
*/
char *px;
/* copy path found to 'lpath' */
return (-1);
} else {
}
}
}
/*
* *********************************************************************
* end of main loop processing entries from contents file
* the loop is broken out of when an exact match for the
* path being searched for has been found and the type is one of:
* - ?fvelspcbdx
* at this point parsing is at the first character past the full path
* name on an exact match for the path being looked for - parse the
* remainder of the entries information into the ept structure.
* *********************************************************************
*/
/* copy path found to 'lpath' */
return (-1);
}
/* copy path found to 'lpath' */
return (-1);
}
}
/* most types have mode, owner, group identification components */
/* mode, owner, group should be here */
/* copy path found to 'lpath' */
return (-1);
}
}
/* i/f/v/e have size, checksum, modification time components */
/* look for content description */
/* copy path found to 'lpath' */
return (-1);
}
}
/* i files processing is completed - return 'exact match found' */
/* copy path found to 'lpath' */
/* copy path found to 'lpath' */
return (-1);
}
/* write out any skipped data before returning */
}
return (1);
}
/*
* determine list of packages which reference this entry
*/
pkgname, ISPKGNAMESEP)) <= 0) {
/* if c < 0 the string was too long to fix in the buffer */
if (c < 0) {
/* copy path found to 'lpath' */
return (-1);
}
/* a package is present - create and populate pinfo structure */
if (!pinfo) {
/* copy path found to 'lpath' */
return (-1);
}
if (!lastpinfo) {
} else {
}
} else {
}
/* pkg/[:[ftype][:class] */
if (c == '\\') {
/* get alternate ftype */
}
if (c == ':') {
/* get special classname */
}
/* 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)) {
/* copy path found to 'lpath' */
return (-1);
}
}
/*
* parsing of the entry is complete
*/
/* copy path found to 'lpath' */
/* write out any skipped data before returning */
}
/* if not at the end of the entry, make it so */
if ((c != '\n') && (c != '\0')) {
return (-1);
}
}
return (1);
}
static int
{
int c;
char *p = *cp;
char *p1;
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;
p1++;
}
/* if string will fit in result buffer copy string and return success */
if (len < n) {
p += len;
*cp = p;
return (0);
}
/* result buffer too small; copy partial string, return error */
p += n;
*cp = p;
return (-1);
}
static int
{
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);
}
static void
{
char *p1;
char *p = *cp;
/* if at end of buffer return no more characters left */
if (*p == '\0') {
return;
}
/* find the end of the line */
return;
}
}