svr4pkg/pkgmk/mkpkgmap.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 2006 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 <string.h>
#include <errno.h>
#include <ctype.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <limits.h>
#include <pkgstrct.h>
#include <pkginfo.h>
#include <locale.h>
#include <libintl.h>
#include <unistd.h>
#include <stdlib.h>
#include <pkglib.h>
#include <install.h>
#include <libadm.h>
#include <libinst.h>

extern char *basedir, *root, *rootlist[], **environ;

/*
 * IMPORTANT NOTE: PLEASE SEE THE DEFINITION OF temp[] BELOW BEFORE
 * CHANGING THE DEFINITION OF PATH_LGTH!!!!
 */

#define PATH_LGTH 4096

#define MAXPARAMS 256
#define NRECURS 20

#define MSG_BPARAMC "parametric class specification for <%s> not allowed"
#define MSG_SRCHLOC "no object for <%s> found in local path"
#define MSG_SRCHSRCH    "no object for <%s> found in search path"
#define MSG_SRCHROOT    "no object for <%s> found in root directory"
#define MSG_CONTENTS    "unable to process contents of object <%s>"
#define MSG_WRITE   "write of entry failed, errno=%d"
#define MSG_GARBDEFLT   "garbled default settings: %s"
#define MSG_BANG    "unknown directive: %s"
#define MSG_CHDIR   "unable to change directory to <%s>"
#define MSG_INCOMPLETE  "processing of <%s> may be incomplete"
#define MSG_NRECURS "too many levels of include (limit is %d)"
#define MSG_RDINCLUDE   "unable to process include file <%s>, errno=%d"
#define MSG_IGNINCLUDE  "ignoring include file <%s>"
#define MSG_NODEVICE    "device numbers cannot be determined for <%s>"

#define WRN_BADATTR "WARNING: attributes set to %04o %s %s for <%s>"
#define WRN_BADATTRM    "WARNING: attributes set to %s %s %s for <%s>"
#define WRN_FAKEBD  "WARNING: parametric paths may ignore BASEDIR"

#define ERR_TEMP    "unable to obtain temporary file resources, errno=%d"
#define ERR_ENVBUILD    "unable to build parameter environment, errno=%d"
#define ERR_MAXPARAMS   "too many parameter definitions (limit is %d)"
#define ERR_GETCWD  "unable to get current directory, errno=%d"
#define ERR_PATHVAR "cannot resolve all build parameters associated with " \
                "path <%s>."

static struct cfent entry;
static FILE *fp,
        *sfp[20];
static char *dname[NRECURS],
        *params[256],
        *proto[NRECURS],
        *rootp[NRECURS][16],
        *srchp[NRECURS][16],
        *d_own[NRECURS],
        *d_grp[NRECURS],
        *rdonly[256];
static mode_t   d_mod[NRECURS];
static int  nfp = (-1);
static int  nrdonly = 0;
static int  errflg = 0;
static char *separ = " \t\n, ";

/* libpkg/gpkgmap.c */
extern void attrpreset(int mode, char *owner, char *group);
extern void attrdefault();
static char *findfile(char *path, char *local);
static char *srchroot(char *path, char *copy);

static int  popenv(void);

static int  doattrib(void);
static void doinclude(void);
static void dorsearch(void);
static void dosearch(void);
static void error(int flag);
static void lputenv(char *s);
static void pushenv(char *file);
static void translate(register char *pt, register char *copy);

int
mkpkgmap(char *outfile, char *protofile, char **envparam)
{
    FILE    *tmpfp;
    char    *pt, *path, mybuff[PATH_LGTH];
    char    **envsave;
    int c, fakebasedir;
    int i, n;

    /*
     * NOTE: THE SIZE OF temp IS HARD CODED INTO CALLS TO fscanf.
     * YOU *MUST* MAKE SURE TO CHANGE THOSE CALLS IF THE SIZE OF temp
     * IS EVER CHANGED!!!!!!
     */
    char    temp[PATH_LGTH];

    if ((tmpfp = fopen(outfile, "w")) == NULL) {
        progerr(gettext(ERR_TEMP), errno);
        quit(99);
    }
    envsave = environ;
    environ = params; /* use only local environ */
    attrdefault();  /* assume no default attributes */

    /*
     * Environment parameters are optional, so variable
     * (envparam[i]) could be NULL.
     */
    for (i = 0; (envparam[i] != NULL) &&
        (pt = strchr(envparam[i], '=')); i++) {
        *pt = '\0';
        rdonly[nrdonly++] = qstrdup(envparam[i]);
        *pt = '=';
        if (putenv(qstrdup(envparam[i]))) { /* bugid 1090920 */
            progerr(gettext(ERR_ENVBUILD), errno);
            quit(99);
        }
        if (nrdonly >= MAXPARAMS) {
            progerr(gettext(ERR_MAXPARAMS), MAXPARAMS);
            quit(1);
        }
    }

    pushenv(protofile);
    errflg = 0;
again:
    fakebasedir = 0;
    while (!feof(fp)) {
        c = getc(fp);
        while (isspace(c))
            c = getc(fp);

        if (c == '#') {
            do c = getc(fp); while ((c != EOF) && (c != '\n'));
            continue;
        }
        if (c == EOF)
            break;

        if (c == '!') {
            /*
             * IMPORTANT NOTE: THE SIZE OF temp IS HARD CODED INTO
             * the FOLLOWING CALL TO fscanf -- YOU MUST CHANGE THIS
             * LINE IF THE SIZE OF fscanf IS EVER CHANGED!!!
             */
            (void) fscanf(fp, "%4096s", temp);

            if (strcmp(temp, "include") == 0)
                doinclude();
            else if (strcmp(temp, "rsearch") == 0)
                dorsearch();
            else if (strcmp(temp, "search") == 0)
                dosearch();
            else if (strcmp(temp, "default") == 0) {
                if (doattrib())
                    break;
            } else if (strchr(temp, '=')) {
                translate(temp, mybuff);
                /* put this into the local environment */
                lputenv(mybuff);
                (void) fscanf(fp, "%*[^\n]"); /* rest of line */
                (void) fscanf(fp, "\n"); /* rest of line */
            } else {
                error(1);
                logerr(gettext(MSG_BANG), temp);
                (void) fscanf(fp, "%*[^\n]"); /* read of line */
                (void) fscanf(fp, "\n"); /* read of line */
            }
            continue;
        }
        (void) ungetc(c, fp);

        if ((n = gpkgmap(&entry, fp)) < 0) {
            char    *errstr;

            error(1);
            errstr = getErrstr();
            logerr(gettext("garbled entry"));
            logerr(gettext("- pathname: %s"),
                (entry.path && *entry.path) ? entry.path :
                "Unknown");
            logerr(gettext("- problem: %s"),
                (errstr && *errstr) ? errstr : "Unknown");
            break;
        }
        if (n == 0)
            break; /* done with file */

        /* don't allow classname to be parametric */
        if (entry.ftype != 'i') {
            if (entry.pkg_class[0] == '$') {
                error(1);
                logerr(gettext(MSG_BPARAMC), entry.path);
            }
        }

        if (strchr("dxlscbp", entry.ftype)) {
            /*
             * We don't need to search for things without any
             * contents in them.
             */
            if (strchr("cb", entry.ftype)) {
                if (entry.ainfo.major == BADMAJOR ||
                    entry.ainfo.minor == BADMINOR) {
                    error(1);
                    logerr(gettext(MSG_NODEVICE),
                        entry.path);
                }
            }
            path = NULL;
        } else {
            path = findfile(entry.path, entry.ainfo.local);
            if (!path)
                continue;

            entry.ainfo.local = path;
            if (strchr("fevin?", entry.ftype)) {
                if (cverify(0, &entry.ftype, path,
                    &entry.cinfo, 1)) {
                    error(1);
                    logerr(gettext(MSG_CONTENTS), path);
                }
            }
        }

        /* Warn if attributes are not set correctly. */
        if (!strchr("isl", entry.ftype)) {
            int dowarning = 0;
            int hasbadmode = 0;

            if (entry.ainfo.mode == NOMODE) {
                entry.ainfo.mode = CURMODE;
                dowarning = 1;
                hasbadmode = 1;
            }

            if (strcmp(entry.ainfo.owner, NOOWNER) == 0) {
                (void) strlcpy(entry.ainfo.owner, CUROWNER,
                        sizeof (entry.ainfo.owner));
                dowarning = 1;
            }

            if (strcmp(entry.ainfo.group, NOGROUP) == 0) {
                (void) strlcpy(entry.ainfo.group, CURGROUP,
                        sizeof (entry.ainfo.group));
                dowarning = 1;
            }


            if (dowarning) {
                if (hasbadmode)
                    logerr(gettext(WRN_BADATTRM),
                        "?",
                        entry.ainfo.owner,
                        entry.ainfo.group,
                        entry.path);
                else
                    logerr(gettext(WRN_BADATTR),
                        (int)entry.ainfo.mode,
                        entry.ainfo.owner,
                        entry.ainfo.group,
                        entry.path);
            }
        }

        /*
         * Resolve build parameters (initial lower case) in
         * the link and target paths.
         */
        if (strchr("ls", entry.ftype)) {
            if (!RELATIVE(entry.ainfo.local) ||
                    PARAMETRIC(entry.ainfo.local)) {
                if (mappath(1, entry.ainfo.local)) {
                    error(1);
                    logerr(gettext(ERR_PATHVAR),
                        entry.ainfo.local);
                    break;
                }

                canonize(entry.ainfo.local);
            }
        }

        /*
         * Warn if top level file or directory is an install
         * parameter
         */
        if (entry.ftype != 'i') {
            if (entry.path[0] == '$' && isupper(entry.path[1]))
                fakebasedir = 1;
        }

        if (mappath(1, entry.path)) {
            error(1);
            logerr(gettext(ERR_PATHVAR), entry.path);
            break;
        }

        canonize(entry.path);
        if (ppkgmap(&entry, tmpfp)) {
            error(1);
            logerr(gettext(MSG_WRITE), errno);
            break;
        }
    }

    if (fakebasedir) {
        logerr(gettext(WRN_FAKEBD));
        fakebasedir = 0;
    }

    if (popenv())
        goto again;

    (void) fclose(tmpfp);
    environ = envsave; /* restore environment */

    return (errflg ? 1 : 0);
}

static char *
findfile(char *path, char *local)
{
    struct stat statbuf;
    static char host[PATH_MAX];
    register char *pt;
    char    temp[PATH_MAX], *basename;
    int i;

    /*
     * map any parameters specified in path to their corresponding values
     * and make sure the path is in its canonical form; any parmeters for
     * which a value is not defined will be left unexpanded. Since this
     * is an actual search for a real file (which will not end up in the
     * package) - we map ALL variables (both build and Install).
     */
    (void) strlcpy(temp, (local && local[0] ? local : path), sizeof (temp));
    mappath(0, temp);
    canonize(temp);

    *host = '\0';
    if (rootlist[0] || (basedir && (*temp != '/'))) {
        /*
         * search for path in the pseudo-root/basedir directory; note
         * that package information files should NOT be included in
         * this list
         */
        if (entry.ftype != 'i')
            return (srchroot(temp, host));
    }

    /* looking for local object file  */
    if (local && *local) {
        basepath(temp, dname[nfp], NULL);
        /*
         * If it equals "/dev/null", that just means it's an empty
         * file. Otherwise, we'll really be writing stuff, so we need
         * to verify the source.
         */
        if (strcmp(temp, "/dev/null") != 0) {
            if (stat(temp, &statbuf) ||
                !(statbuf.st_mode & S_IFREG)) {
                error(1);
                logerr(gettext(MSG_SRCHLOC), path);
                return (NULL);
            }
        }
        (void) strlcpy(host, temp, sizeof (host));
        return (host);
    }

    for (i = 0; rootp[nfp][i]; i++) {
        (void) snprintf(host, sizeof (host), "%s/%s", rootp[nfp][i],
            temp + (*temp == '/' ? 1 : 0));
        if ((stat(host, &statbuf) == 0) &&
            (statbuf.st_mode & S_IFREG)) {
            return (host);
        }
    }

    pt = strrchr(temp, '/');
    if (!pt++)
        pt = temp;

    basename = pt;

    for (i = 0; srchp[nfp][i]; i++) {
        (void) snprintf(host, sizeof (host), "%s/%s",
            srchp[nfp][i], basename);
        if ((stat(host, &statbuf) == 0) &&
            (statbuf.st_mode & S_IFREG)) {
            return (host);
        }
    }

    /* check current directory as a last resort */
    (void) snprintf(host, sizeof (host), "%s/%s", dname[nfp], basename);
    if ((stat(host, &statbuf) == 0) && (statbuf.st_mode & S_IFREG))
        return (host);

    error(1);
    logerr(gettext(MSG_SRCHSRCH), path);
    return (NULL);
}

static void
dosearch(void)
{
    char temp[PATH_MAX], lookpath[PATH_MAX], *pt;
    int n;

    (void) fgets(temp, PATH_MAX, fp);
    translate(temp, lookpath);

    for (n = 0; srchp[nfp][n]; n++)
        free(srchp[nfp][n]);

    n = 0;
    pt = strtok(lookpath, separ);
    if (pt && *pt) {
        do {
            if (*pt != '/') {
                /* make relative path an absolute directory */
                (void) snprintf(temp, sizeof (temp),
                        "%s/%s", dname[nfp], pt);
                pt = temp;
            }
            canonize(pt);
            srchp[nfp][n++] = qstrdup(pt);
        } while (pt = strtok(NULL, separ));
        srchp[nfp][n] = NULL;
    }
}

static void
dorsearch(void)
{
    char temp[PATH_MAX], lookpath[PATH_MAX], *pt;
    int n;

    (void) fgets(temp, PATH_MAX, fp);
    translate(temp, lookpath);

    for (n = 0; rootp[nfp][n]; n++)
        free(rootp[nfp][n]);

    n = 0;
    pt = strtok(lookpath, separ);
    do {
        if (*pt != '/') {
            /* make relative path an absolute directory */
            (void) snprintf(temp, sizeof (temp),
                    "%s/%s", dname[nfp], pt);
            pt = temp;
        }
        canonize(pt);
        rootp[nfp][n++] = qstrdup(pt);
    } while (pt = strtok(NULL, separ));
    rootp[nfp][n] = NULL;
}

/*
 * This function reads the default mode, owner and group from the prototype
 * file and makes that available.
 */
static int
doattrib(void)
{
    char *pt, attrib[PATH_MAX], *mode_ptr, *owner_ptr, *group_ptr, *eol;
    int mode;
    char owner[ATRSIZ+1], group[ATRSIZ+1], attrib_save[(4*ATRSIZ)];

    (void) fgets(attrib, PATH_MAX, fp);

    (void) strlcpy(attrib_save, attrib, sizeof (attrib_save));

    /*
     * Now resolve any variables that may be present. Start on group and
     * move backward since that keeps the resolved string from
     * overwriting any of the other entries. This is required since
     * mapvar() writes the resolved string over the string provided.
     */
    mode_ptr = strtok(attrib, " \t");
    owner_ptr = strtok(NULL, " \t");
    group_ptr = strtok(NULL, " \t\n");
    eol = strtok(NULL, " \t\n");
    if (strtok(NULL, " \t\n")) {
        /* extra tokens on the line */
        error(1);
        logerr(gettext(MSG_GARBDEFLT), (eol) ? eol :
            gettext("unreadable at end of line"));
        return (1);
    }

    if (group_ptr && mapvar(1, group_ptr) == 0)
        (void) strncpy(group, group_ptr, ATRSIZ);
    else {
        error(1);
        logerr(gettext(MSG_GARBDEFLT), (attrib_save) ?
            ((attrib_save[0]) ? attrib_save : gettext("none")) :
            gettext("unreadable at group"));
        return (1);
    }

    if (owner_ptr && mapvar(1, owner_ptr) == 0)
        (void) strncpy(owner, owner_ptr, ATRSIZ);
    else {
        error(1);
        logerr(gettext(MSG_GARBDEFLT), (attrib_save) ?
            ((attrib_save[0]) ? attrib_save : gettext("none")) :
            gettext("unreadable at owner"));
        return (1);
    }

    /*
     * For mode, don't use scanf, since we want to force an octal
     * interpretation and need to limit the length of the owner and group
     * specifications.
     */
    if (mode_ptr && mapvar(1, mode_ptr) == 0)
        mode = strtol(mode_ptr, &pt, 8);
    else {
        error(1);
        logerr(gettext(MSG_GARBDEFLT), (attrib_save) ?
            ((attrib_save[0]) ? attrib_save : gettext("none")) :
            gettext("unreadable at mode"));
        return (1);
    }

    /* free any previous memory from qstrdup */
    if (d_own[nfp])
        free(d_own[nfp]);
    if (d_grp[nfp])
        free(d_grp[nfp]);

    d_mod[nfp] = mode;
    d_own[nfp] = qstrdup(owner);
    d_grp[nfp] = qstrdup(group);

    attrpreset(d_mod[nfp], d_own[nfp], d_grp[nfp]);

    return (0);
}

static void
doinclude(void)
{
    char    file[PATH_MAX];
    char    temp[PATH_MAX];

    (void) fgets(temp, PATH_MAX, fp);

    /*
     * IMPORTANT NOTE: THE SIZE OF temp IS HARD CODED INTO THE
     * FOLLOWING CALL TO fscanf -- YOU MUST CHANGE THIS LINE IF
     * THE SIZE OF fscanf IS EVER CHANGED!!!
     */
    (void) sscanf(temp, "%1024s", file);

    translate(file, temp);
    canonize(temp);

    if (*temp == NULL)
        return;
    else if (*temp != '/')
        (void) snprintf(file, sizeof (file), "%s/%s", dname[nfp], temp);
    else
        (void) strlcpy(file, temp, sizeof (file));

    canonize(file);
    pushenv(file);
}

/*
 * This does what mappath() does except that it does it for ALL variables
 * using whitespace as a token separator. This is used to resolve search
 * paths and assignment statements. It doesn't effect the build versus
 * install decision made for pkgmap variables.
 */
static void
translate(register char *pt, register char *copy)
{
    char *pt2, varname[MAX_PKG_PARAM_LENGTH];

token:
    /* eat white space */
    while (isspace(*pt))
        pt++;
    while (*pt && !isspace(*pt)) {
        if (*pt == '$') {
            pt2 = varname;
            while (*++pt && !strchr("/= \t\n\r", *pt))
                *pt2++ = *pt;
            *pt2 = '\0';
            if (pt2 = getenv(varname)) {
                while (*pt2)
                    *copy++ = *pt2++;
            }
        } else
            *copy++ = *pt++;
    }
    if (*pt) {
        *copy++ = ' ';
        goto token;
    }
    *copy = '\0';
}

static void
error(int flag)
{
    static char *lasterr = NULL;

    if (lasterr != proto[nfp]) {
        lasterr = proto[nfp];
        (void) fprintf(stderr, gettext("ERROR in %s:\n"), lasterr);
    }
    if (flag)
        errflg++;
}

/* Set up defaults and change to the build directory. */
static void
pushenv(char *file)
{
    register char *pt;
    static char topdir[PATH_MAX];

    if ((nfp+1) >= NRECURS) {
        error(1);
        logerr(gettext(MSG_NRECURS), NRECURS);
        logerr(gettext(MSG_IGNINCLUDE), file);
        return;
    }

    if (strcmp(file, "-") == 0) {
        fp = stdin;
    } else if ((fp = fopen(file, "r")) == NULL) {
        error(1);
        logerr(gettext(MSG_RDINCLUDE), file, errno);
        if (nfp >= 0) {
            logerr(gettext(MSG_IGNINCLUDE), file);
            fp = sfp[nfp];
            return;
        } else
            quit(1);
    }
    sfp[++nfp] = fp;
    srchp[nfp][0] = NULL;
    rootp[nfp][0] = NULL;
    d_mod[nfp] = (mode_t)(-1);
    d_own[nfp] = NULL;
    d_grp[nfp] = NULL;

    if (!nfp) {
        /* upper level proto file */
        proto[nfp] = file;
        if (file[0] == '/')
            pt = strcpy(topdir, file);
        else {
            /* path is relative to the prototype file specified */
            pt = getcwd(NULL, PATH_MAX);
            if (pt == NULL) {
                progerr(gettext(ERR_GETCWD), errno);
                quit(99);
            }
            (void) snprintf(topdir, sizeof (topdir),
                        "%s/%s", pt, file);
        }
        if (pt = strrchr(topdir, '/'))
            *pt = '\0'; /* should always happen */
        if (topdir[0] == '\0')
            (void) strlcpy(topdir, "/", sizeof (topdir));
        dname[nfp] = topdir;
    } else {
        proto[nfp] = qstrdup(file);
        dname[nfp] = qstrdup(file);
        if (pt = strrchr(dname[nfp], '/'))
            *pt = '\0';
        else {
            /* same directory as the last prototype */
            free(dname[nfp]);
            dname[nfp] = qstrdup(dname[nfp-1]);
            return; /* no need to canonize() or chdir() */
        }
    }

    canonize(dname[nfp]);

    if (chdir(dname[nfp])) {
        error(1);
        logerr(gettext(MSG_CHDIR), dname[nfp]);
        if (!nfp)
            quit(1); /* must be able to cd to upper level */
        logerr(gettext(MSG_IGNINCLUDE), proto[nfp]);
        (void) popenv();
    }
}

/* Restore defaults and return to the prior directory. */
static int
popenv(void)
{
    int i;

    (void) fclose(fp);
    if (nfp) {
        if (proto[nfp])
            free(proto[nfp]);
        if (dname[nfp])
            free(dname[nfp]);
        for (i = 0; srchp[nfp][i]; i++)
            free(srchp[nfp][i]);
        for (i = 0; rootp[nfp][i]; i++)
            free(rootp[nfp][i]);
        if (d_own[nfp])
            free(d_own[nfp]);
        if (d_grp[nfp])
            free(d_grp[nfp]);

        fp = sfp[--nfp];

        if (chdir(dname[nfp])) {
            error(1);
            logerr(gettext(MSG_CHDIR), dname[nfp]);
            logerr(gettext(MSG_INCOMPLETE), proto[nfp]);
            return (popenv());
        }
        return (1);
    }
    return (0);
}

/*
 * If this parameter isn't already in place, put it into the local
 * environment. This means that command line directives override prototype
 * file directives.
 */
static void
lputenv(char *s)
{
    char *pt;
    int i;

    pt = strchr(s, '=');
    if (!pt)
        return;

    *pt = '\0';
    for (i = 0; i < nrdonly; i++) {
        if (strcmp(rdonly[i], s) == 0) {
            *pt = '=';
            return;
        }
    }
    *pt = '=';

    if (putenv(qstrdup(s))) {
        progerr(gettext(ERR_ENVBUILD), errno);
        quit(99);
    }
}

static char *
srchroot(char *path, char *copy)
{
    struct stat statbuf;
    int i;

    i = 0;
    root = rootlist[i++];
    do {
        /* convert with root & basedir info */
        cvtpath(path, copy);
        /* make it pretty again */
        canonize(copy);

        if (stat(copy, &statbuf) || !(statbuf.st_mode & S_IFREG)) {
            root = rootlist[i++];
            continue; /* host source must be a regular file */
        }
        return (copy);
    } while (root != NULL);
    error(1);
    logerr(gettext(MSG_SRCHROOT), path);
    return (NULL);
}