libadm/common/pkgparam.c

/*
 * 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 (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/*    All Rights Reserved   */

/*
 * Copyright (c) 1989, 2011, Oracle and/or its affiliates. All rights reserved.
 */

/*   5-20-92   newroot support added  */

#include <stdio.h>
#include <limits.h>
#include <ctype.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <pkgstrct.h>
#include <pkginfo.h>
#include <pkglocs.h>
#include <stdlib.h>
#include <unistd.h>
#include "libadm.h"

#define VALSIZ  128
#define NEWLINE '\n'
#define ESCAPE  '\\'

static char sepset[] =  ":=\n";
static char qset[] =    "'\"";
static char *pkg_inst_root = NULL;

char *pkgdir = NULL;
char *pkgfile = NULL;

static char Adm_pkgold[PATH_MAX] = { 0 }; /* added for newroot */
static char Adm_pkgloc[PATH_MAX] = { 0 }; /* added for newroot */
static char Adm_pkgadm[PATH_MAX] = { 0 }; /* added for newroot */

/*
 * This looks in a directory that might be the top level directory of a
 * package. It tests a temporary install directory first and then for a
 * standard directory. This looks a little confusing, so here's what's
 * happening. If this pkginfo is being openned in a script during a pkgadd
 * which is updating an existing package, the original pkginfo file is in a
 * directory that has been renamed from <pkginst> to .save.<pkginst>. If the
 * pkgadd fails it will be renamed back to <pkginst>. We are always interested
 * in the OLD pkginfo data because the new pkginfo data is already in our
 * environment. For that reason, we try to open the backup first - that has
 * the old data. This returns the first accessible path in "path" and a "1"
 * if an appropriate pkginfo file was found. It returns a 0 if no type of
 * pkginfo was located.
 */
int
pkginfofind(char *path, char *pkg_dir, char *pkginst)
{
    int len = 0;

    /* Construct the temporary pkginfo file name. */
    len =  snprintf(path, PATH_MAX, "%s/.save.%s/pkginfo", pkg_dir,
        pkginst);
    if (len > PATH_MAX)
        return (0);
    if (access(path, 0)) {
        /*
         * This isn't a temporary directory, so we look for a
         * regular one.
         */
        len =  snprintf(path, PATH_MAX, "%s/%s/pkginfo", pkg_dir,
            pkginst);
        if (len > PATH_MAX)
            return (0);
        if (access(path, 0))
            return (0); /* doesn't appear to be a package */
    }

    return (1);
}

/*
 * This opens the appropriate pkginfo file for a particular package.
 */
FILE *
pkginfopen(char *pkg_dir, char *pkginst)
{
    FILE *fp = NULL;
    char temp[PATH_MAX];

    if (pkginfofind(temp, pkg_dir, pkginst))
        fp = fopen(temp, "r");

    return (fp);
}


char *
fpkgparam(FILE *fp, char *param)
{
    char    ch, buffer[VALSIZ];
    char    *mempt, *copy;
    int c, n;
    boolean_t check_end_quote = B_FALSE;
    boolean_t begline, quoted, escape;
    int idx = 0;

    if (param == NULL) {
        errno = ENOENT;
        return (NULL);
    }

    mempt = NULL;

    for (;;) {      /* For each entry in the file fp */
        copy = buffer;
        n = 0;

        /* Get the next token. */
        while ((c = getc(fp)) != EOF) {
            ch = (char)c;
            if (strchr(sepset, ch))
                break;
            if (++n < VALSIZ)
                *copy++ = ch;
        }

        /* If it's the end of the file, exit the for() loop */
        if (c == EOF) {
            errno = EINVAL;
            return (NULL); /* No more entries left */

        /* If it's end of line, look for the next parameter. */
        } else if (c == NEWLINE)
            continue;

        /* At this point copy points to the end of a valid parameter. */
        *copy = '\0';       /* Terminate the string. */
        if (buffer[0] == '#')   /* If it's a comment, drop thru. */
            copy = NULL;    /* Comments don't get buffered. */
        else {
            /* If parameter is NULL, we return whatever we got. */
            if (param[0] == '\0') {
                (void) strcpy(param, buffer);
                copy = buffer;

            /* If this doesn't match the parameter, drop thru. */
            } else if (strcmp(param, buffer))
                copy = NULL;

            /* Otherwise, this is our boy. */
            else
                copy = buffer;
        }

        n = 0;
        quoted = escape = B_FALSE;
        begline = B_TRUE; /* Value's line begins */

        /* Now read the parameter value. */
        while ((c = getc(fp)) != EOF) {
            ch = (char)c;

            if (begline && ((ch == ' ') || (ch == '\t')))
                continue; /* Ignore leading white space */

            /*
             * Take last end quote 'verbatim' if anything
             * other than space, newline and escape.
             * Example:
             * PARAM1="zonename="test-zone""
             *  Here in this example the letter 't' inside
             *  the value is followed by '"', this makes
             *  the previous end quote candidate '"',
             *  a part of value and the end quote
             *  disqualfies. Reset check_end_quote.
             * PARAM2="value"<== newline here
             * PARAM3="value"\
             * "continued"<== newline here.
             *  Check for end quote continues.
             */
            if (ch != NEWLINE && ch != ' ' && ch != ESCAPE &&
                ch != '\t' && check_end_quote)
                check_end_quote = B_FALSE;

            if (ch == NEWLINE) {
                if (!escape) {
                    /*
                     * The end quote candidate qualifies.
                     * Eat any trailing spaces.
                     */
                    if (check_end_quote) {
                        copy -= n - idx;
                        n = idx;
                        check_end_quote = B_FALSE;
                        quoted = B_FALSE;
                    }
                    break; /* End of entry */
                }
                /*
                 * The end quote if exists, doesn't qualify.
                 * Eat end quote and trailing spaces if any.
                 * Value spans to next line.
                 */
                if (check_end_quote) {
                    copy -= n - idx;
                    n = idx;
                    check_end_quote = B_FALSE;
                } else if (copy) {
                    copy--; /* Eat previous esc */
                    n--;
                }
                escape = B_FALSE;
                begline = B_TRUE; /* New input line */
                continue;
            } else {
                if (!escape && strchr(qset, ch)) {
                    /* Handle quotes */
                    if (begline) {
                        /* Starting quote */
                        quoted = B_TRUE;
                        begline = B_FALSE;
                        continue;
                    } else if (quoted) {
                        /*
                         * This is the candidate
                         * for end quote. Check
                         * to see it qualifies.
                         */
                        check_end_quote = B_TRUE;
                        idx = n;
                    }
                }
                if (ch == ESCAPE)
                    escape = B_TRUE;
                else if (escape)
                    escape = B_FALSE;
                if (copy) *copy++ = ch;
                begline = B_FALSE;
            }

            if (copy && ((++n % VALSIZ) == 0)) {
                if (mempt) {
                    mempt = realloc(mempt,
                        (n+VALSIZ)*sizeof (char));
                    if (!mempt)
                        return (NULL);
                } else {
                    mempt = calloc((size_t)(2*VALSIZ),
                        sizeof (char));
                    if (!mempt)
                        return (NULL);
                    (void) strncpy(mempt, buffer, n);
                }
                copy = &mempt[n];
            }
        }

        /*
         * Don't allow trailing white space.
         * NOTE : White space in the middle is OK, since this may
         * be a list. At some point it would be a good idea to let
         * this function know how to validate such a list. -- JST
         *
         * Now while there's a parametric value and it ends in a
         * space and the actual remaining string length is still
         * greater than 0, back over the space.
         */
        while (copy && isspace((unsigned char)*(copy - 1)) && n-- > 0)
            copy--;

        if (quoted) {
            if (mempt)
                (void) free(mempt);
            errno = EFAULT; /* missing closing quote */
            return (NULL);
        }
        if (copy) {
            *copy = '\0';
            break;
        }
        if (c == EOF) {
            errno = EINVAL; /* parameter not found */
            return (NULL);
        }
    }

    if (!mempt)
        mempt = strdup(buffer);
    else
        mempt = realloc(mempt, (strlen(mempt)+1)*sizeof (char));
    return (mempt);
}

char *
pkgparam(char *pkg, char *param)
{
    static char lastfname[PATH_MAX];
    static FILE *fp = NULL;
    char *pt, *copy, *value, line[PATH_MAX];

    if (!pkgdir)
        pkgdir = get_PKGLOC();

    if (!pkg) {
        /* request to close file */
        if (fp) {
            (void) fclose(fp);
            fp = NULL;
        }
        return (NULL);
    }

    if (!param) {
        errno = ENOENT;
        return (NULL);
    }

    if (pkgfile)
        (void) strcpy(line, pkgfile); /* filename was passed */
    else
        (void) pkginfofind(line, pkgdir, pkg);

    if (fp && strcmp(line, lastfname)) {
        /* different filename implies need for different fp */
        (void) fclose(fp);
        fp = NULL;
    }
    if (!fp) {
        (void) strcpy(lastfname, line);
        if ((fp = fopen(lastfname, "r")) == NULL)
            return (NULL);
    }

    /*
     * if parameter is a null string, then the user is requesting us
     * to find the value of the next available parameter for this
     * package and to copy the parameter name into the provided string;
     * if it is not, then it is a request for a specified parameter, in
     * which case we rewind the file to start search from beginning
     */
    if (param[0]) {
        /* new parameter request, so reset file position */
        if (fseek(fp, 0L, 0))
            return (NULL);
    }

    if (pt = fpkgparam(fp, param)) {
        if (strcmp(param, "ARCH") == NULL ||
            strcmp(param, "CATEGORY") == NULL) {
            /* remove all whitespace from value */
            value = copy = pt;
            while (*value) {
                if (!isspace((unsigned char)*value))
                    *copy++ = *value;
                value++;
            }
            *copy = '\0';
        }
        return (pt);
    }
    return (NULL);
}
/*
 * This routine sets adm_pkgloc and adm_pkgadm which are the
 * replacement location for PKGLOC and PKGADM.
 */

static void canonize_name(char *);

void
set_PKGpaths(char *path)
{
    if (path && *path) {
        (void) snprintf(Adm_pkgloc, sizeof (Adm_pkgloc), "%s%s",
            path, PKGLOC);
        (void) snprintf(Adm_pkgold, sizeof (Adm_pkgold), "%s%s",
            path, PKGOLD);
        (void) snprintf(Adm_pkgadm, sizeof (Adm_pkgadm), "%s%s",
            path, PKGADM);
        set_install_root(path);
    } else {
        (void) snprintf(Adm_pkgloc, sizeof (Adm_pkgloc), "%s", PKGLOC);
        (void) snprintf(Adm_pkgold, sizeof (Adm_pkgold), "%s", PKGOLD);
        (void) snprintf(Adm_pkgadm, sizeof (Adm_pkgadm), "%s", PKGADM);
    }
    canonize_name(Adm_pkgloc);
    canonize_name(Adm_pkgold);
    canonize_name(Adm_pkgadm);
    pkgdir = Adm_pkgloc;
}

char *
get_PKGLOC(void)
{
    if (Adm_pkgloc[0] == NULL)
        return (PKGLOC);
    else
        return (Adm_pkgloc);
}

char *
get_PKGOLD(void)
{
    if (Adm_pkgold[0] == NULL)
        return (PKGOLD);
    else
        return (Adm_pkgold);
}

char *
get_PKGADM(void)
{
    if (Adm_pkgadm[0] == NULL)
        return (PKGADM);
    else
        return (Adm_pkgadm);
}

void
set_PKGADM(char *newpath)
{
    (void) strcpy(Adm_pkgadm, newpath);
}

void
set_PKGLOC(char *newpath)
{
    (void) strcpy(Adm_pkgloc, newpath);
}

#define isdot(x)    ((x[0] == '.')&&(!x[1]||(x[1] == '/')))
#define isdotdot(x) ((x[0] == '.')&&(x[1] == '.')&&(!x[2]||(x[2] == '/')))

static void
canonize_name(char *file)
{
    char *pt, *last;
    int level;

    /* Remove references such as "./" and "../" and "//" */

    for (pt = file; *pt; ) {
        if (isdot(pt))
            (void) strcpy(pt, pt[1] ? pt+2 : pt+1);
        else if (isdotdot(pt)) {
            level = 0;
            last = pt;
            do {
                level++;
                last += 2;
                if (*last)
                    last++;
            } while (isdotdot(last));
            --pt; /* point to previous '/' */
            while (level--) {
                if (pt <= file)
                    return;
                while ((*--pt != '/') && (pt > file))
                    ;
            }
            if (*pt == '/')
                pt++;
            (void) strcpy(pt, last);
        } else {
            while (*pt && (*pt != '/'))
                pt++;
            if (*pt == '/') {
                while (pt[1] == '/')
                    (void) strcpy(pt, pt+1);
                pt++;
            }
        }
    }
    if ((--pt > file) && (*pt == '/'))
        *pt = '\0';
}

void
set_install_root(char *path)
{
    pkg_inst_root = strdup(path);
}

char *
get_install_root()
{
    return (pkg_inst_root);
}