depend.c revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (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 2004 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
#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",
#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);
}