svr4pkg/pkgproto/main.c

	main.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
 * 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 <ctype.h>
#include <dirent.h>
#include <limits.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <pkgstrct.h>
#include <errno.h>
#include <locale.h>
#include <libintl.h>
#include <pkglib.h>
#include "libadm.h"
#include "libinst.h"

extern int  holdcinfo;

#define WRN_SCARYLINK   "WARNING: <%s>, target of symlink <%s>, does not exist."

#define ERR_PATHLONG    "path argument too long"
#define ERR_CLASSLONG   "classname argument too long"
#define ERR_CLASSCHAR   "bad character in classname"
#define ERR_STAT    "unable to stat <%s>"
#define ERR_WRITE   "write of entry failed"
#define ERR_POPEN   "unable to create pipe to <%s>"
#define ERR_PCLOSE  "unable to close pipe to <%s>"
#define ERR_RDLINK  "unable to read link for <%s>"
#define ERR_MEMORY  "memory allocation failure, errno=%d"

#define LINK    1

struct link {
    char    *path;
    ino_t   ino;
    dev_t   dev;
    struct link *next;
};

static struct link *firstlink = (struct link *)0;
static struct link *lastlink = (struct link *)0;
static char *scan_raw_ln(char *targ_name, char *link_name);

static char *def_class = "none";

static int  errflg = 0;
static int  iflag = 0;  /* follow symlinks */
static int  xflag = 0;  /* confirm contents of files */
static int  nflag = 0;
static char construction[PATH_MAX], mylocal[PATH_MAX];

static void findlink(struct cfent *ept, char *path, char *svpath);
static void follow(char *path);
static void output(char *path, int n, char *local);
static void usage(void);

int
main(int argc, char *argv[])
{
    int c;
    char *pt, path[PATH_MAX];
    char    *abi_sym_ptr;
    extern char *optarg;
    extern int  optind;

    (void) setlocale(LC_ALL, "");

#if !defined(TEXT_DOMAIN)   /* Should be defined by cc -D */
#define TEXT_DOMAIN "SYS_TEST"
#endif
    (void) textdomain(TEXT_DOMAIN);

    (void) set_prog_name(argv[0]);

    while ((c = getopt(argc, argv, "xnic:?")) != EOF) {
        switch (c) {
            case 'x':   /* include content info */
            xflag++;
            break;

            case 'n':
            nflag++;
            break;

            case 'c':   /* assign class */
            def_class = optarg;
            /* validate that classname is acceptable */
            if (strlen(def_class) > (size_t)CLSSIZ) {
                progerr(gettext(ERR_CLASSLONG));
                exit(1);
            }
            for (pt = def_class; *pt; pt++) {
                if (!isalpha(*pt) && !isdigit(*pt)) {
                    progerr(gettext(ERR_CLASSCHAR));
                    exit(1);
                }
            }
            break;

            case 'i':   /* follow symlinks */
            iflag++;
            break;

            default:
            usage();
        }
    }

    if (iflag) {
        /* follow symlinks */
        set_nonABI_symlinks();
    } else {
        /* bug id 4244631, not ABI compliant */
        abi_sym_ptr = getenv("PKG_NONABI_SYMLINKS");
        if (abi_sym_ptr && strncasecmp(abi_sym_ptr, "TRUE", 4) == 0) {
            set_nonABI_symlinks();
        }
    }
    holdcinfo = !xflag;
    if (optind == argc) {
        /* take path list from stdin */
        while (fgets(path, sizeof (path), stdin) != (char *)NULL) {
            output(path, 0, NULL);
        }
    } else {
        while (optind < argc) {
            follow(argv[optind++]);
        }
    }

    return (errflg ? 1 : 0);
}

static void
output(char *path, int n, char *local)
{
    char        mypath[PATH_MAX];
    int     len;
    int     s;
    struct cfent    entry;

    /*
     * remove any trailing newline characters from the end of path
     */

    len = strlen(path);
    while ((len > 0) && (path[len-1] == '\n')) {
        path[--len] = '\0';
    }

    entry.volno = 0;
    entry.ftype = '?';
    entry.path = mypath;
    (void) strlcpy(entry.pkg_class, def_class, sizeof (entry.pkg_class));
    (void) strlcpy(entry.path, path, PATH_MAX);
    entry.ainfo.local = NULL;
    entry.ainfo.mode = BADMODE;
    (void) strlcpy(entry.ainfo.owner, BADOWNER, sizeof (entry.ainfo.owner));
    (void) strlcpy(entry.ainfo.group, BADGROUP, sizeof (entry.ainfo.group));
    errflg = 0;

    if (xflag) {
        entry.ftype = '?';
        if (cverify(0, &entry.ftype, path, &entry.cinfo, 1)) {
            errflg++;
            logerr(gettext("ERROR: %s"), path);
            logerr(getErrbufAddr());
            return;
        }
    }

    /*
     * Use averify to figure out the attributes. This has trouble
     * divining the identity of a symlink which points to a
     * non-existant target. For that reason, if it comes back as
     * an existence problem, we fake in a symlink and see if averify
     * likes that. If it does, all we have is a risky symlink.
     */
    if ((s = averify(0, &entry.ftype, path, &entry.ainfo)) == VE_EXIST &&
        !iflag) {
        entry.ftype = 's';  /* try again assuming symlink */
        /* try to read what it points to */
        if ((s = readlink(path, mylocal, PATH_MAX)) > 0) {
            mylocal[s] = '\000';    /* terminate it */
            entry.ainfo.local = mylocal;
            if (averify(0, &entry.ftype, path, &entry.ainfo)) {
                errflg++;
            } else
                /* It's a link to a file not in this package. */
                ptext(stderr, gettext(WRN_SCARYLINK),
                    mylocal, path);
        } else {
            errflg++;
        }
    } else if (s != 0 && s != VE_CONT)
        errflg++;

    if (errflg) {
        logerr(gettext("ERROR: %s"), path);
        logerr(getErrbufAddr());
        return;
    }

    if (n) {
        /* replace first n characters with 'local' */
        if (strchr("fev", entry.ftype)) {
            entry.ainfo.local = mylocal;
            (void) strlcpy(entry.ainfo.local, entry.path,
                PATH_MAX);
            canonize(entry.ainfo.local);
        }
        if (local[0]) {
            entry.ainfo.local = mylocal;
            (void) strlcpy(entry.path, local, PATH_MAX);
            (void) strcat(entry.path, path+n);
        } else
            (void) strlcpy(entry.path,
                (path[n] == '/') ? path+n+1 : path+n,
                PATH_MAX);
    }

    canonize(entry.path);
    if (entry.path[0]) {
        findlink(&entry, path, entry.path);
        if (strchr("dcbp", entry.ftype) ||
        (nflag && !strchr("sl", entry.ftype)))
            entry.ainfo.local = NULL;
        if (ppkgmap(&entry, stdout)) {
            progerr(gettext(ERR_WRITE));
            exit(99);
        }
    }
}

static void
follow(char *path)
{
    struct stat stbuf;
    FILE    *pp;
    char    *pt,
        local[PATH_MAX],
        newpath[PATH_MAX],
        cmd[PATH_MAX+32];
    int n;

    errflg = 0;

    if (pt = strchr(path, '=')) {
        *pt++ = '\0';
        n = ((unsigned int)pt - (unsigned int)path - 1);
        if (n >= PATH_MAX) {
            progerr(gettext(ERR_PATHLONG));
            errflg++;
            return;
        }

        n = strlen(pt);

        if (n < PATH_MAX) {
            (void) strlcpy(local, pt, sizeof (local));
            n = strlen(path);
        } else {
            progerr(gettext(ERR_PATHLONG));
            errflg++;
            return;
        }
    } else {
        n = 0;
        local[0] = '\0';
    }

    if (stat(path, &stbuf)) {
        progerr(gettext(ERR_STAT), path);
        errflg++;
        return;
    }

    if (stbuf.st_mode & S_IFDIR) {
        (void) snprintf(cmd, sizeof (cmd), "find %s -print", path);
        if ((pp = popen(cmd, "r")) == NULL) {
            progerr(gettext(ERR_POPEN), cmd);
            exit(1);
        }
        while (fscanf(pp, "%[^\n]\n", newpath) == 1)
            output(newpath, n, local);
        if (pclose(pp)) {
            progerr(gettext(ERR_PCLOSE), cmd);
            errflg++;
        }
    } else
        output(path, n, local);
}

/*
 * Scan a raw link for origination errors. Given
 *  targ_name = hlink/path/file1
 *      and
 *  link_name = hlink/path/file2
 * we don't want the link to be verbatim since link_name must be relative
 * to it's source. This functions checks for identical directory paths
 * and if it's clearly a misplaced relative path, the duplicate
 * directories are stripped. This is necessary because pkgadd is actually
 * in the source directory (hlink/path) when it creates the link.
 *
 * NOTE : The buffer we get with targ_name is going to be used later
 * and cannot be modified. That's why we have yet another PATH_MAX
 * size buffer in this function.
 */
static char *
scan_raw_ln(char *targ_name, char *link_name)
{
    char *const_ptr;    /* what we return */
    char *file_name;    /* name of the file in link_name */
    char *this_dir;     /* current directory in targ_name */
    char *next_dir;     /* next directory in targ_name  */
    char *targ_ptr;     /* current character in targ_name */

    const_ptr = targ_name;  /* Point to here 'til we know it's different. */

    /*
     * If the link is absolute or it is in the current directory, no
     * further testing necessary.
     */
    if (RELATIVE(targ_name) &&
        (file_name = strrchr(link_name, '/')) != NULL) {

        /*
         * This will be walked down to the highest directory
         * not common to both the link and the target.
         */
        targ_ptr = targ_name;

        /*
         * At this point targ_name is a relative path through at
         * least one directory.
         */
        this_dir = targ_ptr;    /* first directory in targ_name */
        file_name++;        /* point to the name not the '/' */

        /*
         * Scan across the pathname until we reach a different
         * directory or the final file name.
         */
        do {
            size_t str_size;

            next_dir = strchr(targ_ptr, '/');
            if (next_dir)
                next_dir++; /* point to name not '/' */
            else    /* point to the end of the string */
                next_dir = targ_ptr+strlen(targ_ptr);

            /* length to compare */
            str_size = ((ptrdiff_t)next_dir - (ptrdiff_t)this_dir);

            /*
             * If both paths begin with the same directory, then
             * skip that common directory in both the link and
             * the target.
             */
            if (strncmp(this_dir, link_name, str_size) == 0) {
                /* point to the target so far */
                const_ptr = this_dir = next_dir;
                /* Skip past it in the target */
                targ_ptr = (char *)(targ_ptr+str_size);
                /* Skip past it in the link */
                link_name = (char *)(link_name+str_size);
            /*
             * If these directories don't match then the
             * directory above is the lowest common directory. We
             * need to construct a relative path from the lowest
             * child up to that directory.
             */
            } else {
                int d = 0;
                char *dptr = link_name;

                /* Count the intermediate directories. */
                while ((dptr = strchr(dptr, '/')) != NULL) {
                    dptr++;
                    d++;
                }
                /*
                 * Now targ_ptr is pointing to the fork in
                 * the path and dptr is pointing to the lowest
                 * child in the link. We now insert the
                 * appropriate number of "../'s" to get to
                 * the first common directory. We'll
                 * construct this in the construction
                 * buffer.
                 */
                if (d) {
                    char *tptr;

                    const_ptr = tptr = construction;
                    while (d--) {
                        (void) strlcpy(tptr,
                            "../", PATH_MAX);
                        tptr += 3;
                    }
                    (void) strlcpy(tptr, targ_ptr,
                        PATH_MAX);
                }
                break;      /* done */
            }
        } while (link_name != file_name);   /* at file name */
    }

    return (const_ptr);
}

static void
findlink(struct cfent *ept, char *path, char *svpath)
{
    struct stat statbuf;
    struct link *link, *new;
    char        buf[PATH_MAX];
    int     n;

    if (lstat(path, &statbuf)) {
        progerr(gettext(ERR_STAT), path);
        errflg++;
    }
    if ((statbuf.st_mode & S_IFMT) == S_IFLNK) {
        if (!iflag) {
            ept->ainfo.local = mylocal;
            ept->ftype = 's';
            n = readlink(path, buf, PATH_MAX);
            if (n <= 0) {
                progerr(gettext(ERR_RDLINK), path);
                errflg++;
                (void) strlcpy(ept->ainfo.local,
                    "unknown", PATH_MAX);
            } else {
                (void) strncpy(ept->ainfo.local, buf, n);
                ept->ainfo.local[n] = '\0';
            }
        }
        return;
    }

    if (stat(path, &statbuf))
        return;
    if (statbuf.st_nlink <= 1)
        return;

    for (link = firstlink; link; link = link->next) {
        if ((statbuf.st_ino == link->ino) &&
        (statbuf.st_dev == link->dev)) {
            ept->ftype = 'l';
            ept->ainfo.local = mylocal;
            (void) strlcpy(ept->ainfo.local,
                    scan_raw_ln(link->path, ept->path),
                    PATH_MAX);
            return;
        }
    }
    if ((new = (struct link *)calloc(1, sizeof (struct link))) == NULL) {
        progerr(gettext(ERR_MEMORY), errno);
        exit(1);
    }

    if (firstlink) {
        lastlink->next = new;
        lastlink = new;
    } else
        firstlink = lastlink = new;

    new->path = strdup(svpath);
    new->ino = statbuf.st_ino;
    new->dev = statbuf.st_dev;
}

static void
usage(void)
{
    (void) fprintf(stderr,
        gettext("usage: %s [-i] [-c class] [path ...]\n"), get_prog_name());
    exit(1);
    /*NOTREACHED*/
}