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

#define LSIZE   1024
#define MALSIZ  164

#define ERR_MAJOR       "invalid major number <%s> specified for <%s>"
#define ERR_MINOR       "invalid minor number <%s> specified for <%s>"
#define ERR_MODE        "invalid mode <%s> specified for <%s>"
#define ERR_RELPATH     "relative pathname <%s> not permitted"
#define ERR_NULLPATH    "NULL or garbled pathname"
#define ERR_LINK        "invalid link specification <%s>"
#define ERR_LINKFTYPE   "ftype <%c> does not match link specification <%s>"
#define ERR_LINKARGS    "extra arguments in link specification <%s>"
#define ERR_LINKREL     "relative pathname in link specification <%s>"
#define ERR_FTYPE       "invalid ftype <%c> for <%s>"
#define ERR_ARGC        "invalid number of arguments for <%s>"
#define ERR_SPECALL     "ftype <%c> requires all fields to be specified"

static int validate(struct cfextra *ext, int argc, char *argv[]);
static void checkPaths(char *argv[]);

int
installf(int argc, char *argv[])
{
        struct cfextra *new;
        char    line[LSIZE];
        char    *largv[8];
        int     myerror;

        if (strcmp(argv[0], "-") != 0) {
                if (argc < 1)
                        usage(); /* at least pathname is required */
                extlist = calloc(2, sizeof (struct cfextra *));
                extlist[0] = new = calloc(1, sizeof (struct cfextra));
                eptnum = 1;

                /* There is only one filename on the command line. */
                checkPaths(argv);
                if (validate(new, argc, argv))
                        quit(1);
                return (0);
        }

        /* Read stdin to obtain entries, which need to be sorted. */
        eptnum = 0;
        myerror = 0;
        extlist = calloc(MALSIZ, sizeof (struct cfextra *));
        while (fgets(line, LSIZE, stdin) != NULL) {
                argc = 0;
                argv = largv;
                argv[argc++] = strtok(line, " \t\n");
                while (argv[argc] = strtok(NULL, " \t\n"))
                        argc++;

                if (argc < 1)
                        usage(); /* at least pathname is required */

                new = calloc(1, sizeof (struct cfextra));
                if (new == NULL) {
                        progerr(strerror(errno));
                        quit(99);
                }

                checkPaths(argv);

                if (validate(new, argc, argv))
                        myerror++;

                extlist[eptnum] = new;
                if ((++eptnum % MALSIZ) == 0) {
                        extlist = realloc(extlist,
                            (sizeof (struct cfextra *) * (eptnum+MALSIZ)));
                        if (!extlist) {
                                progerr(strerror(errno));
                                quit(99);
                        }
                }
        }
        extlist[eptnum] = (struct cfextra *)NULL;
        qsort((char *)extlist, (unsigned)eptnum, sizeof (struct cfextra *),
            cfentcmp);
        return (myerror);
}

static int
validate(struct cfextra *ext, int argc, char *argv[])
{
        char    *ret, *pt;
        int     n, allspec, is_a_link;
        struct  cfent *ept;

        ept = &(ext->cf_ent);

        /* initialize cfent structure */
        ept->pinfo = NULL;
        (void) gpkgmapvfp(ept, (VFP_T *)NULL);  /* This just clears stuff. */

        n = allspec = 0;
        if (classname)
                (void) strncpy(ept->pkg_class, classname, CLSSIZ);

        if (argv[n] == NULL || *(argv[n]) == '\000') {
                progerr(gettext(ERR_NULLPATH));
                return (1);
        }

        /*
         * It would be a good idea to figure out how to get much of
         * this done using facilities in procmap.c - JST
         */
        if (pt = strchr(argv[n], '=')) {
                *pt = '\0';     /* cut off pathname at the = sign */
                is_a_link = 1;
        } else
                is_a_link = 0;

        if (RELATIVE(argv[n])) {
                progerr(gettext(ERR_RELPATH),
                    (argv[n] == NULL) ? "unknown" : argv[n]);
                return (1);
        }

        /* get the pathnames */
        if (eval_path(&(ext->server_path), &(ext->client_path),
            &(ext->map_path), argv[n++]) == 0)
                return (1);

        ept->path = ext->client_path;

        /* This isn't likely to happen; but, better safe than sorry. */
        if (RELATIVE(ept->path)) {
                progerr(gettext(ERR_RELPATH), ept->path);
                return (1);
        }

        if (is_a_link) {
                /* links specifications should be handled right here */
                ept->ftype = ((n >= argc) ? 'l' : argv[n++][0]);

                /* If nothing follows the '=', it's invalid */
                if (!pt[1]) {
                        progerr(gettext(ERR_LINK), ept->path);
                        return (1);
                }

                /* Test for an argument after the link. */
                if (argc != n) {
                        progerr(gettext(ERR_LINKARGS), ept->path);
                        return (1);
                }

                /*
                 * If it's a link but it's neither hard nor symbolic then
                 * it's bad.
                 */
                if (!strchr("sl", ept->ftype)) {
                        progerr(gettext(ERR_LINKFTYPE), ept->ftype, ept->path);
                        return (1);
                }

                ext->server_local = pathdup(pt+1);
                ext->client_local = ext->server_local;

                ept->ainfo.local = ext->client_local;

                return (0);
        } else if (n >= argc) {
                /* we are expecting to change object's contents */
                return (0);
        }

        ept->ftype = argv[n++][0];
        if (strchr("sl", ept->ftype)) {
                progerr(gettext(ERR_LINK), ept->path);
                return (1);
        } else if (!strchr("?fvedxcbp", ept->ftype)) {
                progerr(gettext(ERR_FTYPE), ept->ftype, ept->path);
                return (1);
        }

        if (ept->ftype == 'b' || ept->ftype == 'c') {
                if (n < argc) {
                        ept->ainfo.major = strtol(argv[n++], &ret, 0);
                        if (ret && *ret) {
                                progerr(gettext(ERR_MAJOR), argv[n-1],
                                    ept->path);
                                return (1);
                        }
                }
                if (n < argc) {
                        ept->ainfo.minor = strtol(argv[n++], &ret, 0);
                        if (ret && *ret) {
                                progerr(gettext(ERR_MINOR), argv[n-1],
                                    ept->path);
                                return (1);
                        }
                        allspec++;
                }
        }

        allspec = 0;
        if (n < argc) {
                ept->ainfo.mode = strtol(argv[n++], &ret, 8);
                if (ret && *ret) {
                        progerr(gettext(ERR_MODE), argv[n-1], ept->path);
                        return (1);
                }
        }
        if (n < argc)
                (void) strncpy(ept->ainfo.owner, argv[n++], ATRSIZ);
        if (n < argc) {
                (void) strncpy(ept->ainfo.group, argv[n++], ATRSIZ);
                allspec++;
        }
        if (strchr("dxbcp", ept->ftype) && !allspec) {
                progerr(gettext(ERR_ARGC), ept->path);
                progerr(gettext(ERR_SPECALL), ept->ftype);
                return (1);
        }
        if (n < argc) {
                progerr(gettext(ERR_ARGC), ept->path);
                return (1);
        }
        return (0);
}

int
cfentcmp(const void *p1, const void *p2)
{
        struct cfextra *ext1 = *((struct cfextra **)p1);
        struct cfextra *ext2 = *((struct cfextra **)p2);

        return (strcmp(ext1->cf_ent.path, ext2->cf_ent.path));
}

/*
 * If the path at argv[0] has the value of
 * PKG_INSTALL_ROOT prepended, remove it
 */
static void
checkPaths(char *argv[])
{
        char *root;
        int rootLen;

        /*
         * Note- No local copy of argv is needed since this
         * function is guaranteed to replace argv with a subset of
         * the original argv.
         */

        /* We only want to canonize the path if it contains multiple '/'s */

        canonize_slashes(argv[0]);

        if ((root = get_inst_root()) == NULL)
                return;
        if (strcmp(root, "/") != 0) {
                rootLen = strlen(root);
                if (strncmp(argv[0], root, rootLen) == 0) {
                        argv[0] += rootLen;
                }
        }
}