/*
 * 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.
 */

#include <stdio.h>
#include <sys/param.h>
#include <fcntl.h>
#include <stdlib.h>
#include <strings.h>
#include <errno.h>
#include <dirent.h>
#include <sys/stat.h>

#include "list.h"
#include "protodir.h"
#include "arch.h"
#include "exception_list.h"

#define FS      " \t\n"

static char *
resolve_relative(const char *source, const char *link)
{
        char    *p;
        char    *l_next;
        char    *l_pos;
        static char     curpath[MAXPATHLEN];

        /* if absolute path - no relocation required */
        if (link[0] == '/')
                return (strcpy(curpath, link));

        (void) strcpy(curpath, source);
        p = rindex(curpath, '/');
        *p = '\0';
        l_pos = (char *)link;
        do {
                l_next = index(l_pos, '/');
                if (strncmp(l_pos, "../", 3) == 0) {
                        if ((p = rindex(curpath, '/')) != NULL)
                                *p = '\0';
                        else
                                curpath[0] = '\0';
                } else if (strncmp(l_pos, "./", 2)) {
                        /* if not . then we process */
                        if (curpath[0])
                                (void) strcat(curpath, "/");
                        if (l_next) {
                                (void) strncat(curpath, l_pos,
                                    (l_next - l_pos));
                        } else
                                (void) strcat(curpath, l_pos);
                }
                l_pos = l_next + 1;
        } while (l_next);

        return (curpath);
}


static int
parse_proto_line(const char *basedir, char *line, elem_list *list, short arch,
    const char *pkgname)
{
        char    *type, *class, *file, *src, *maj, *min, *perm, *owner, *group;
        char    p_line[BUFSIZ];
        elem    *dup;
        static elem *e = NULL;

        (void) strcpy(p_line, line);
        if (!e)
                e = (elem *)calloc(1, sizeof (elem));

        e->flag = 0;

        if (!(type  = strtok(p_line, FS))) {
                (void) fprintf(stderr, "error: bad line(type) : %s\n", line);
                return (-1);
        }

        e->file_type = type[0];

        if ((class = strtok(NULL, FS)) == NULL) {
                (void) fprintf(stderr, "error: bad line(class) : %s\n", line);
                return (-1);
        }

        /*
         * Just ignore 'legacy' entries.  These are not present in the proto
         * area at all.  They're phantoms.
         */
        if (strcmp(class, "legacy") == 0)
                return (0);

        if (!(file  = strtok(NULL, FS))) {
                (void) fprintf(stderr, "error: bad line(file_name) : %s\n",
                    line);
                return (-1);
        }

        e->symsrc = NULL;
        if ((src = index(file, '=')) != NULL) {
                /*
                 * The '=' operator is subtly different for link and non-link
                 * entries.  For the hard or soft link case, the left hand side
                 * exists in the proto area and is created by the package.
                 *
                 * When the file is an editable file, it's very likely that the
                 * right hand side is only a fragment of that file, which is
                 * delivered by multiple packages in the consolidation.  Thus it
                 * can't exist in the proto area, and because we can't really
                 * know where the file's root directory is, we should skip the
                 * file.
                 *
                 * For all other filetypes, assume the right hand side is in the
                 * proto area.
                 */
                if (e->file_type == SYM_LINK_T || e->file_type == LINK_T) {
                        *src++ = '\0';
                        e->symsrc = strdup(src);
                } else if (e->file_type == EDIT_T) {
                        return (0);
                } else {
                        file = src + 1;
                }
        }

        /*
         * if a basedir has a value, prepend it to the filename
         */
        if (basedir[0])
                (void) strcat(strcat(strcpy(e->name, basedir), "/"), file);
        else
                (void) strcpy(e->name, file);

        if (e->file_type != SYM_LINK_T) {
                if ((e->file_type == CHAR_DEV_T) ||
                    (e->file_type == BLOCK_DEV_T)) {
                        if (!(maj = strtok(NULL, FS))) {
                                (void) fprintf(stderr,
                                    "error: bad line(major number) : %s\n",
                                    line);
                                return (-1);
                        }
                        e->major = atoi(maj);

                        if (!(min = strtok(NULL, FS))) {
                                (void) fprintf(stderr,
                                    "error: bad line(minor number) : %s\n",
                                    line);
                                return (-1);
                        }
                        e->minor = atoi(min);
                } else {
                        e->major = -1;
                        e->minor = -1;
                }

                if (!(perm = strtok(NULL, FS))) {
                        (void) fprintf(stderr,
                            "error: bad line(permission) : %s\n", line);
                        return (-1);
                }
                e->perm = strtol(perm, NULL, 8);

                if (!(owner = strtok(NULL, FS))) {
                        (void) fprintf(stderr,
                            "error: bad line(owner) : %s\n", line);
                        return (-1);
                }
                (void) strcpy(e->owner, owner);

                if (!(group = strtok(NULL, FS))) {
                        (void) fprintf(stderr,
                            "error: bad line(group) : %s\n", line);
                        return (-1);
                }
                (void) strcpy(e->group, group);
        }

        e->inode = 0;
        e->ref_cnt = 1;
        e->arch = arch;
        e->link_parent = NULL;

        if (!(dup = find_elem(list, e, FOLLOW_LINK))) {
                e->pkgs = add_pkg(NULL, pkgname); /* init pkgs list */
                add_elem(list, e);
                e = NULL;
                return (1);
        } else if (dup->file_type == DIR_T) {
                if (!(dup->pkgs = add_pkg(dup->pkgs, pkgname))) {
                        /* add entry to pkgs */
                        (void) fprintf(stderr,
                            "warning: %s: Duplicate entry for %s\n",
                            pkgname, dup->name);
                        return (-1);
                }
                if (e->perm != dup->perm) {
                        (void) fprintf(stderr,
                            "warning: %s: permissions %#o of %s do not match "
                            "previous permissions %#o\n",
                            pkgname, e->perm, dup->name, dup->perm);
                }
                if (strcmp(e->owner, dup->owner) != 0) {
                        (void) fprintf(stderr,
                            "warning: %s: owner \"%s\" of %s does not match "
                            "previous owner \"%s\"\n",
                            pkgname, e->owner, dup->name, dup->owner);
                }
                if (strcmp(e->group, dup->group) != 0) {
                        (void) fprintf(stderr,
                            "warning: %s: group \"%s\" of %s does not match "
                            "previous group \"%s\"\n",
                            pkgname, e->group, dup->name, dup->group);
                }
        } else {
                /*
                 * Signal an error only if this is something that's not on the
                 * exception list.
                 */
                (void) strcpy(e->name, file);
                if (find_elem(&exception_list, e, FOLLOW_LINK) == NULL) {
                        (void) fprintf(stderr,
                            "warning: %s: duplicate entry for %s - ignored\n",
                            pkgname, e->name);
                        return (-1);
                }
        }

        return (0);
}

static int
parse_proto_link(const char *basedir, char *line, elem_list *list, short arch,
    const char *pkgname)
{
        char    *type, *file, *src;
        char    p_line[BUFSIZ];
        elem    *p, *dup;
        elem    key;
        static elem     *e = NULL;


        (void) strcpy(p_line, line);
        if (!e)
                e = (elem *)calloc(1, sizeof (elem));

        e->flag = 0;
        type = strtok(p_line, FS);
        e->arch = arch;

        e->file_type = type[0];
        (void) strtok(NULL, FS);   /* burn class */

        file = strtok(NULL, FS);
        if ((src = index(file, '=')) != NULL) {
                *src++ = '\0';
                e->symsrc = strdup(src);
        } else {
                (void) fprintf(stderr,
                    "error: %s: hard link does not have destination (%s)\n",
                    pkgname, file);
                return (0);
        }

        /*
         * if a basedir has a value, prepend it to the filename
         */
        if (basedir[0])
                (void) strcat(strcat(strcpy(e->name, basedir), "/"), file);
        else
                (void) strcpy(e->name, file);

        /*
         * now we need to find the file that we link to - to do this
         * we build a key.
         */

        src = resolve_relative(e->name, e->symsrc);
        (void) strcpy(key.name, src);
        key.arch = e->arch;
        if ((p = find_elem(list, &key, NO_FOLLOW_LINK)) == NULL) {
                (void) fprintf(stderr,
                    "error: %s: hardlink to non-existent file: %s=%s\n",
                    pkgname, e->name, e->symsrc);
                return (0);
        }
        if ((p->file_type == SYM_LINK_T) || (p->file_type == LINK_T)) {
                (void) fprintf(stderr,
                    "error: %s: hardlink must link to a file or directory "
                    "(not other links): %s=%s\n", pkgname, e->name, p->name);
                return (0);
        }
        e->link_parent = p;
        e->link_sib = p->link_sib;
        p->link_sib = e;
        p->ref_cnt++;
        e->inode = p->inode;
        e->perm = p->perm;
        e->ref_cnt = p->ref_cnt;
        e->major = p->major;
        e->minor = p->minor;
        (void) strcpy(e->owner, p->owner);
        (void) strcpy(e->group, p->owner);

        if (!(dup = find_elem(list, e, NO_FOLLOW_LINK))) {
                e->pkgs = add_pkg(NULL, pkgname); /* init pkgs list */
                e->link_sib = NULL;
                add_elem(list, e);
                e = NULL;
                return (1);
        } else {
                /*
                 * Signal an error only if this is something that's not on the
                 * exception list.
                 */
                (void) strcpy(e->name, file);
                if (find_elem(&exception_list, e, FOLLOW_LINK) == NULL) {
                        (void) fprintf(stderr,
                            "warning: %s: duplicate entry for %s - ignored\n",
                            pkgname, e->name);
                        return (-1);
                }
        }

        return (0);
}


/*
 * open up the pkginfo file and find the ARCH= and the BASEDIR= macros.
 * I will set the arch and basedir variables based on these fields.
 */
static void
read_pkginfo(const char *protodir, short *arch, char *basedir)
{
        char    pkginfofile[MAXPATHLEN];
        char    architecture[MAXPATHLEN];
        char    buf[BUFSIZ];
        FILE    *pkginfo_fp;
        int     hits = 0;
        int     i;
        int     index;


        architecture[0] = '\0';
        basedir[0] = '\0';
        *arch = P_ISA;

        /*
         * determine whether the pkginfo file is a pkginfo.tmpl or
         * a pkginfo file
         */
        (void) strcat(strcat(strcpy(pkginfofile, protodir), "/"),
            "pkginfo.tmpl");

        if ((pkginfo_fp = fopen(pkginfofile, "r")) == NULL) {
                (void) strcat(strcat(strcpy(pkginfofile, protodir), "/"),
                    "pkginfo");
                if ((pkginfo_fp = fopen(pkginfofile, "r")) == NULL) {
                        perror(pkginfofile);
                        return;
                }
        }


        while (fgets(buf, BUFSIZ, pkginfo_fp) && (hits != 3)) {
                if (strncmp(buf, "ARCH=", 5) == 0) {
                        index = 0;
                        /*
                         * remove any '"' in the ARCH field.
                         */
                        for (i = 5; buf[i]; i++) {
                                if (buf[i] != '"')
                                        architecture[index++] = buf[i];
                        }
                        /* -1 because above copy included '\n' */
                        architecture[index-1] = '\0';
                        hits += 1;
                } else if (strncmp(buf, "BASEDIR=", 8) == 0) {
                        index = 0;
                        /*
                         * remove any '"' in the BASEDIR field, and
                         * strip off a leading '/' if present.
                         */
                        for (i = 8; buf[i]; i++) {
                                if (buf[i] != '"' &&
                                    (buf[i] != '/' || index != 0)) {
                                        buf[index++] = buf[i];
                                }
                        }
                        /* -1 because above copy included '\n' */
                        buf[index-1] = '\0';
                        (void) strcpy(basedir, &buf[0]);
                        hits += 2;
                }
        }
        (void) fclose(pkginfo_fp);

        if (architecture[0])
                if ((*arch = assign_arch(architecture)) == 0) {
                        (void) fprintf(stderr,
                            "warning: Unknown architecture %s found in %s\n",
                            architecture, pkginfofile);
                }
}

/*
 * The first pass through the prototype file goes through and reads
 * in all the entries except 'hard links'.  Those must be processed
 * in a second pass.
 *
 * If any !includes are found in the prototype file this routine
 * will be called recursively.
 *
 * Args:
 *   protofile - full pathname to prototype file to be processed.
 *   protodir  - directory in which prototype file resides.
 *   list      - list to which elements will be added
 *   arch      - architecture of current prototype
 *   basedir   - basedir for package
 *   pkgname   - name of package
 *
 * Returns:
 *   returns number of items added to list.
 *
 */
static int
first_pass_prototype(const char *protofile, const char *protodir,
    elem_list *list, short arch, const char *basedir, const char *pkgname)
{
        int     elem_count = 0;
        FILE    *proto_fp;
        char    include_file[MAXPATHLEN];
        char    buf[BUFSIZ];

        if ((proto_fp = fopen(protofile, "r")) == NULL) {
                perror(protofile);
                return (0);
        }

        /*
         * first pass through file - process everything but
         * hard links.
         */
        while (fgets(buf, BUFSIZ, proto_fp)) {
                int     rc;

                switch (buf[0]) {
                case FILE_T:
                case EDIT_T:
                case VOLATILE_T:
                case DIR_T:
                case SYM_LINK_T:
                case CHAR_DEV_T:
                case BLOCK_DEV_T:
                        if ((rc = parse_proto_line(basedir, buf, list, arch,
                            pkgname)) >= 0) {
                                elem_count += rc;
                        } else {
                                (void) fprintf(stderr,
                                    "error: Errors found in %s\n", protofile);
                        }
                        break;
                case LINK_T:
                case 'i':
                case '#':
                case '\n':
                        break;
                case '!':
                        /* Is this an include statement - if so process */
                        if (strncmp(buf, "!include", 8) == 0) {
                                char *inc_file = (char *)(buf + 9);

                                /* burn white space */
                                while ((*inc_file == ' ') ||
                                    (*inc_file == '\t'))
                                        inc_file++;
                                if (*inc_file) {
                                        /* remove trailing \n */
                                        inc_file[strlen(inc_file) - 1] = '\0';
                                        (void) strcat(strcat(strcpy(
                                            include_file, protodir), "/"),
                                            inc_file);
                                        elem_count +=
                                            first_pass_prototype(include_file,
                                            protodir, list, arch, basedir,
                                            pkgname);
                                } else {
                                        (void) fprintf(stderr,
                                            "warning: bad !include statement "
                                            "in prototype %s : %s\n",
                                            protofile, buf);
                                }
                        } else {
                                (void) fprintf(stderr,
                                    "warning: unexpected ! notation in "
                                    "prototype %s : %s\n", protofile, buf);

                        }
                        break;
                default:
                        (void) fprintf(stderr,
                            "warning: unexpected line in prototype %s : %s\n",
                            protofile, buf);
                        break;
                }
        }

        (void) fclose(proto_fp);

        return (elem_count);
}

/*
 * The second pass through the prototype file goes through and reads
 * and processes only the 'hard links' in the prototype file.  These
 * are resolved and added accordingly to the elements list(list).
 *
 * If any !includes are found in the prototype file this routine
 * will be called recursively.
 *
 * Args:
 *   protofile - full pathname to prototype file to be processed.
 *   protodir  - directory in which prototype file resides.
 *   list      - list to which elements will be added
 *   arch      - architecture of current prototype
 *   basedir   - basedir for package
 *   pkgname   - package name
 *
 * Returns:
 *   returns number of items added to list.
 *
 */
static int
second_pass_prototype(const char *protofile, const char *protodir,
    elem_list *list, short arch, const char *basedir, const char *pkgname)
{
        FILE    *proto_fp;
        int     elem_count = 0;
        char    include_file[MAXPATHLEN];
        char    buf[BUFSIZ];

        if ((proto_fp = fopen(protofile, "r")) == NULL) {
                perror(protofile);
                return (0);
        }

        /*
         * second pass through prototype file - process the hard links
         * now.
         */
        while (fgets(buf, BUFSIZ, proto_fp)) {
                if (buf[0] == LINK_T) {
                        int     rc;

                        if ((rc = parse_proto_link(basedir, buf, list, arch,
                            pkgname)) >= 0) {
                                elem_count += rc;
                        } else {
                                (void) fprintf(stderr,
                                    "error: Errors found in %s\n", protofile);
                        }
                } else if (strncmp(buf, "!include", 8) == 0) {
                        /*
                         * This is a file to include
                         */
                        char *inc_file = (char *)(buf + 9);

                        /* burn white space */
                        while ((*inc_file == ' ') || (*inc_file == '\t'))
                                inc_file++;

                        if (*inc_file) {
                                /* remove trailing \n */
                                inc_file[strlen(inc_file) - 1] = '\0';
                                /* build up include file name to be opened. */
                                (void) strcat(strcat(strcpy(include_file,
                                    protodir), "/"), inc_file);
                                /*
                                 * recursively call this routine to process the
                                 * !include file.
                                 */
                                elem_count +=
                                    second_pass_prototype(include_file,
                                    protodir, list, arch, basedir, pkgname);
                        } else {
                                (void) fprintf(stderr,
                                    "warning: Bad !include statement in "
                                    "prototype %s : %s\n", protofile, buf);
                        }
                }
        }
        (void) fclose(proto_fp);

        return (elem_count);
}

/*
 * Args:
 *    pkgname  - name of package being processed
 *    protodir - pathname to package defs directory
 *    list     - List of elements read in, elements are added to this
 *               as they are read in.
 *    verbose  - verbose output
 *
 * Returns:
 *    number of elements added to list
 */
int
process_package_dir(const char *pkgname, const char *protodir,
    elem_list *list, int verbose)
{
        struct stat     st_buf;
        char            protofile[MAXPATHLEN];
        char            basedir[MAXPATHLEN];
        short           arch;
        int             count = 0;


        /*
         * skip any packages we've already handled (because of
         * dependencies)
         */
        if (processed_package(pkgname)) {
                return (0);
        }

        /*
         * find the prototype file.  Legal forms of the name are:
         *              prototype
         *              prototype_<mach> (where mach == (sparc || i386 || ppc)
         */
        (void) strcat(strcat(strcpy(protofile, protodir), "/"), "prototype");
        if (stat(protofile, &st_buf) < 0) {
                if (errno == ENOENT) {
                        (void) strcat(strcat(strcat(strcpy(protofile,
                            protodir), "/"), "prototype"), PROTO_EXT);
                        if (stat(protofile, &st_buf) < 0) {
                                if (errno == ENOENT) {
                                        if (verbose) {
                                                (void) fprintf(stderr,
                                                    "warning: no prototype "
                                                    "file found in %s, "
                                                    "skipping...\n",
                                                    protodir);
                                        }
                                } else
                                        perror(protofile);
                                return (0);
                        }
                } else {
                        perror(protofile);
                        return (0);
                }
        }

        mark_processed(pkgname);

        read_pkginfo(protodir, &arch, basedir);

        count += first_pass_prototype(protofile, protodir, list, arch,
            basedir, pkgname);
        count += second_pass_prototype(protofile, protodir, list, arch,
            basedir, pkgname);

        /* print_list(list); */
        return (count);
}

int
read_in_protodir(const char *dir_name, elem_list *list, int verbose)
{
        DIR             *p_dir;
        struct dirent   *dp;
        char            protodir[MAXPATHLEN];
        struct stat     st_buf;
        int             count = 0;

        if ((p_dir = opendir(dir_name)) == NULL) {
                perror(dir_name);
                exit(1);
        }

        list->type = PROTODIR_LIST;

        while ((dp = readdir(p_dir)) != NULL) {
                /*
                 * let's not check "." and ".." - I don't really like this
                 * but I wasn't really sure you could be sure that they
                 * are always the first two entries in the directory
                 * structure  - so I put it in the loop.
                 *
                 * Also - we skip all directories that are names .del-*.
                 * and any SCCS directories too.
                 */
                if ((strcmp(dp->d_name, ".") == 0) ||
                    (strcmp(dp->d_name, "..") == 0) ||
                    (strncmp(dp->d_name, ".del-", 5) == 0) ||
                    (strcmp(dp->d_name, "SCCS") == 0))
                        continue;

                (void) strcat(strcat(strcpy(protodir, dir_name), "/"),
                    dp->d_name);
                if (stat(protodir, &st_buf) < 0) {
                        perror(protodir);
                        continue;
                }
                if (!S_ISDIR(st_buf.st_mode)) {
                        if (verbose) {
                                (void) fprintf(stderr,
                                    "warning: %s not a directory\n", protodir);
                        }
                        continue;
                }

                count += process_dependencies(dp->d_name, dir_name, list,
                    verbose);

                count += process_package_dir(dp->d_name, protodir, list,
                    verbose);
        }

        if (verbose)
                (void) printf("read in %d lines\n", count);

        (void) closedir(p_dir);

        return (count);
}