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


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

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

static pkg_list *packages[HASH_SIZE];

#define HASH(name) (hash(name) % HASH_SIZE)

int
processed_package(const char *pkgname)
{
        int     bucket;
        pkg_list *tmp;

        bucket = HASH(pkgname);
        for (tmp = packages[bucket]; tmp != NULL; tmp = tmp->next) {
                if (strcmp(tmp->pkg_name, pkgname) == 0)
                        return (1);
        }
        return (0);
}

void
mark_processed(const char *pkgname)
{
        int     bucket;
        pkg_list *tmp;

        bucket = HASH(pkgname);
        tmp = malloc(sizeof (pkg_list));
        bzero(tmp, sizeof (pkg_list));
        (void) strcpy(tmp->pkg_name, pkgname);
        tmp->next = packages[bucket];
        packages[bucket] = tmp;
}

static pkg_list *
add_dependency(pkg_list *dependlist, const char *pkgname)
{
        pkg_list *tmp;
        pkg_list *pkg;

        pkg = malloc(sizeof (pkg_list));
        bzero(pkg, sizeof (pkg_list));
        (void) strcpy(pkg->pkg_name, pkgname);

        /* easy case */
        if (dependlist == NULL)
                return (pkg);
        /* insert at end, since the order matters */
        for (tmp = dependlist; tmp->next != NULL; tmp = tmp->next) {
                /* NULL */
        }
        tmp->next = pkg;
        return (dependlist);
}

static void
free_dependency_list(pkg_list *dependlist)
{
        pkg_list *tmp;

        while (dependlist) {
                tmp = dependlist;
                dependlist = dependlist->next;
                tmp->next = NULL;
                free(tmp);
        }
}

#ifdef DEBUG
void
print_dependencies(const char *pkgname, pkg_list *dependlist)
{
        pkg_list *tmp;

        fprintf(stderr, "%s:", pkgname);
        for (tmp = dependlist; tmp != NULL; tmp = tmp->next)
                fprintf(stderr, " %s", tmp->pkg_name);
        fprintf(stderr, "\n");
}
#endif

static char *suffix_list[] = {
#if defined(__i386)
        ".i",
#elif defined(__sparc)
        ".c",
        ".d",
        ".m",
        ".u",
        ".v",
#else
#error "Unknown architecture."
#endif
        NULL,
};

static pkg_list *
find_dependencies(const char *pkgname, const char *parentdir)
{
        char    dependfile[MAXPATHLEN + 1];
        char    pkgdir[MAXPATHLEN + 1];
        char    buf[BUFSIZ];
        char    deppkg[MAXNAME];
        char    archpkg[MAXNAME];
        struct stat sbuf;
        FILE    *fp;
        pkg_list *dependlist = NULL;
        char    **suffixes;

        (void) sprintf(dependfile, "%s/%s/depend", parentdir, pkgname);
        fp = fopen(dependfile, "r");
        if (fp == NULL) {
                /*
                 * depend won't exist in ON packages until a build
                 * has been done, but it would be nice if you didn't have
                 * to do that. So try the generic depend file that those
                 * packages would copy in during the build.
                 */
                (void) sprintf(dependfile, "%s/common_files/depend", parentdir);
                fp = fopen(dependfile, "r");
                if (fp == NULL)
                        return (NULL);
        }
        while (fgets(buf, BUFSIZ, fp) != NULL) {
                if ((buf[0] == '\0') || (buf[0] == '#') || isspace(buf[0]))
                        continue;
                /* we only care about prerequisites */
                if (buf[0] != 'P')
                        continue;
                (void) sscanf(buf, "P %s", deppkg);
                /*
                 * We have to be careful with some of the packages that are
                 * listed as dependencies but exist under a different name -
                 * SUNWcar is good, because it's actually SUNWcar.{c,d,i,m,u}.
                 * What do we do there? We can't just go for all the '.'
                 * packages, since on x86 we only want the .i one, and on sparc
                 * we want everything _but_ .i. Maybe
                 *
                 * I think perhaps what we do is, if we don't find a package
                 * dependency, on intel we append '.i' and try for that, and on
                 * sparc we try the other extensions. Any we find get added.
                 *
                 * Note also we're quiet on failures. This is because you might
                 * be dependant on some outside package.
                 */
                (void) sprintf(pkgdir, "%s/%s", parentdir, deppkg);
                if (stat(pkgdir, &sbuf) == -1) {
                        if (errno != ENOENT) {
                                continue;
                        }
                        for (suffixes = &suffix_list[0]; *suffixes != NULL;
                            suffixes++) {
                                (void) sprintf(archpkg, "%s%s", deppkg,
                                    *suffixes);
                                (void) sprintf(pkgdir, "%s/%s", parentdir,
                                    archpkg);
                                if (stat(pkgdir, &sbuf) == -1) {
                                        continue;
                                }
                                if (!S_ISDIR(sbuf.st_mode)) {
                                        continue;
                                }
                                /* found one */
                                dependlist = add_dependency(dependlist,
                                    archpkg);
                        }
                }
                if (!S_ISDIR(sbuf.st_mode)) {
                        continue;
                }
                dependlist = add_dependency(dependlist, deppkg);
        }
        (void) fclose(fp);
        return (dependlist);
}

int
process_dependencies(const char *pkgname, const char *parentdir,
    elem_list *list, int verbose)
{
        int     count = 0;
        char    pkgdir[MAXPATHLEN + 1];
        pkg_list *dependlist;
        pkg_list *tmp;

        dependlist = find_dependencies(pkgname, parentdir);
/*
 *      print_dependencies(pkgname, dependlist);
 */
        if (dependlist == NULL)
                return (0);

        for (tmp = dependlist; tmp != NULL; tmp = tmp->next) {
                (void) sprintf(pkgdir, "%s/%s", parentdir, tmp->pkg_name);
                count += process_package_dir(tmp->pkg_name, pkgdir, list,
                    verbose);
        }

        free_dependency_list(dependlist);
        return (count);
}