15c51f124SMoriah Waterland /*
25c51f124SMoriah Waterland * CDDL HEADER START
35c51f124SMoriah Waterland *
45c51f124SMoriah Waterland * The contents of this file are subject to the terms of the
55c51f124SMoriah Waterland * Common Development and Distribution License (the "License").
65c51f124SMoriah Waterland * You may not use this file except in compliance with the License.
75c51f124SMoriah Waterland *
85c51f124SMoriah Waterland * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
95c51f124SMoriah Waterland * or http://www.opensolaris.org/os/licensing.
105c51f124SMoriah Waterland * See the License for the specific language governing permissions
115c51f124SMoriah Waterland * and limitations under the License.
125c51f124SMoriah Waterland *
135c51f124SMoriah Waterland * When distributing Covered Code, include this CDDL HEADER in each
145c51f124SMoriah Waterland * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
155c51f124SMoriah Waterland * If applicable, add the following below this CDDL HEADER, with the
165c51f124SMoriah Waterland * fields enclosed by brackets "[]" replaced with your own identifying
175c51f124SMoriah Waterland * information: Portions Copyright [yyyy] [name of copyright owner]
185c51f124SMoriah Waterland *
195c51f124SMoriah Waterland * CDDL HEADER END
205c51f124SMoriah Waterland */
215c51f124SMoriah Waterland
225c51f124SMoriah Waterland /*
235c51f124SMoriah Waterland * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
245c51f124SMoriah Waterland * Use is subject to license terms.
255c51f124SMoriah Waterland */
265c51f124SMoriah Waterland
275c51f124SMoriah Waterland /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
285c51f124SMoriah Waterland /* All Rights Reserved */
295c51f124SMoriah Waterland
305c51f124SMoriah Waterland
315c51f124SMoriah Waterland #include <stdio.h>
325c51f124SMoriah Waterland #include <string.h>
335c51f124SMoriah Waterland #include <errno.h>
345c51f124SMoriah Waterland #include <ctype.h>
355c51f124SMoriah Waterland #include <sys/types.h>
365c51f124SMoriah Waterland #include <sys/stat.h>
375c51f124SMoriah Waterland #include <limits.h>
385c51f124SMoriah Waterland #include <pkgstrct.h>
395c51f124SMoriah Waterland #include <pkginfo.h>
405c51f124SMoriah Waterland #include <locale.h>
415c51f124SMoriah Waterland #include <libintl.h>
425c51f124SMoriah Waterland #include <unistd.h>
435c51f124SMoriah Waterland #include <stdlib.h>
445c51f124SMoriah Waterland #include <pkglib.h>
455c51f124SMoriah Waterland #include <install.h>
465c51f124SMoriah Waterland #include <libadm.h>
475c51f124SMoriah Waterland #include <libinst.h>
485c51f124SMoriah Waterland
495c51f124SMoriah Waterland extern char *basedir, *root, *rootlist[], **environ;
505c51f124SMoriah Waterland
515c51f124SMoriah Waterland /*
525c51f124SMoriah Waterland * IMPORTANT NOTE: PLEASE SEE THE DEFINITION OF temp[] BELOW BEFORE
535c51f124SMoriah Waterland * CHANGING THE DEFINITION OF PATH_LGTH!!!!
545c51f124SMoriah Waterland */
555c51f124SMoriah Waterland
565c51f124SMoriah Waterland #define PATH_LGTH 4096
575c51f124SMoriah Waterland
585c51f124SMoriah Waterland #define MAXPARAMS 256
595c51f124SMoriah Waterland #define NRECURS 20
605c51f124SMoriah Waterland
615c51f124SMoriah Waterland #define MSG_BPARAMC "parametric class specification for <%s> not allowed"
625c51f124SMoriah Waterland #define MSG_SRCHLOC "no object for <%s> found in local path"
635c51f124SMoriah Waterland #define MSG_SRCHSRCH "no object for <%s> found in search path"
645c51f124SMoriah Waterland #define MSG_SRCHROOT "no object for <%s> found in root directory"
655c51f124SMoriah Waterland #define MSG_CONTENTS "unable to process contents of object <%s>"
665c51f124SMoriah Waterland #define MSG_WRITE "write of entry failed, errno=%d"
675c51f124SMoriah Waterland #define MSG_GARBDEFLT "garbled default settings: %s"
685c51f124SMoriah Waterland #define MSG_BANG "unknown directive: %s"
695c51f124SMoriah Waterland #define MSG_CHDIR "unable to change directory to <%s>"
705c51f124SMoriah Waterland #define MSG_INCOMPLETE "processing of <%s> may be incomplete"
715c51f124SMoriah Waterland #define MSG_NRECURS "too many levels of include (limit is %d)"
725c51f124SMoriah Waterland #define MSG_RDINCLUDE "unable to process include file <%s>, errno=%d"
735c51f124SMoriah Waterland #define MSG_IGNINCLUDE "ignoring include file <%s>"
745c51f124SMoriah Waterland #define MSG_NODEVICE "device numbers cannot be determined for <%s>"
755c51f124SMoriah Waterland
765c51f124SMoriah Waterland #define WRN_BADATTR "WARNING: attributes set to %04o %s %s for <%s>"
775c51f124SMoriah Waterland #define WRN_BADATTRM "WARNING: attributes set to %s %s %s for <%s>"
785c51f124SMoriah Waterland #define WRN_FAKEBD "WARNING: parametric paths may ignore BASEDIR"
795c51f124SMoriah Waterland
805c51f124SMoriah Waterland #define ERR_TEMP "unable to obtain temporary file resources, errno=%d"
815c51f124SMoriah Waterland #define ERR_ENVBUILD "unable to build parameter environment, errno=%d"
825c51f124SMoriah Waterland #define ERR_MAXPARAMS "too many parameter definitions (limit is %d)"
835c51f124SMoriah Waterland #define ERR_GETCWD "unable to get current directory, errno=%d"
845c51f124SMoriah Waterland #define ERR_PATHVAR "cannot resolve all build parameters associated with " \
855c51f124SMoriah Waterland "path <%s>."
865c51f124SMoriah Waterland
875c51f124SMoriah Waterland static struct cfent entry;
885c51f124SMoriah Waterland static FILE *fp,
895c51f124SMoriah Waterland *sfp[20];
905c51f124SMoriah Waterland static char *dname[NRECURS],
915c51f124SMoriah Waterland *params[256],
925c51f124SMoriah Waterland *proto[NRECURS],
935c51f124SMoriah Waterland *rootp[NRECURS][16],
945c51f124SMoriah Waterland *srchp[NRECURS][16],
955c51f124SMoriah Waterland *d_own[NRECURS],
965c51f124SMoriah Waterland *d_grp[NRECURS],
975c51f124SMoriah Waterland *rdonly[256];
985c51f124SMoriah Waterland static mode_t d_mod[NRECURS];
995c51f124SMoriah Waterland static int nfp = (-1);
1005c51f124SMoriah Waterland static int nrdonly = 0;
1015c51f124SMoriah Waterland static int errflg = 0;
1025c51f124SMoriah Waterland static char *separ = " \t\n, ";
1035c51f124SMoriah Waterland
1045c51f124SMoriah Waterland /* libpkg/gpkgmap.c */
1055c51f124SMoriah Waterland extern void attrpreset(int mode, char *owner, char *group);
1065c51f124SMoriah Waterland extern void attrdefault();
1075c51f124SMoriah Waterland static char *findfile(char *path, char *local);
1085c51f124SMoriah Waterland static char *srchroot(char *path, char *copy);
1095c51f124SMoriah Waterland
1105c51f124SMoriah Waterland static int popenv(void);
1115c51f124SMoriah Waterland
1125c51f124SMoriah Waterland static int doattrib(void);
1135c51f124SMoriah Waterland static void doinclude(void);
1145c51f124SMoriah Waterland static void dorsearch(void);
1155c51f124SMoriah Waterland static void dosearch(void);
1165c51f124SMoriah Waterland static void error(int flag);
1175c51f124SMoriah Waterland static void lputenv(char *s);
1185c51f124SMoriah Waterland static void pushenv(char *file);
1195c51f124SMoriah Waterland static void translate(register char *pt, register char *copy);
1205c51f124SMoriah Waterland
1215c51f124SMoriah Waterland int
mkpkgmap(char * outfile,char * protofile,char ** envparam)1225c51f124SMoriah Waterland mkpkgmap(char *outfile, char *protofile, char **envparam)
1235c51f124SMoriah Waterland {
1245c51f124SMoriah Waterland FILE *tmpfp;
1255c51f124SMoriah Waterland char *pt, *path, mybuff[PATH_LGTH];
1265c51f124SMoriah Waterland char **envsave;
1275c51f124SMoriah Waterland int c, fakebasedir;
1285c51f124SMoriah Waterland int i, n;
1295c51f124SMoriah Waterland
1305c51f124SMoriah Waterland /*
1315c51f124SMoriah Waterland * NOTE: THE SIZE OF temp IS HARD CODED INTO CALLS TO fscanf.
1325c51f124SMoriah Waterland * YOU *MUST* MAKE SURE TO CHANGE THOSE CALLS IF THE SIZE OF temp
1335c51f124SMoriah Waterland * IS EVER CHANGED!!!!!!
1345c51f124SMoriah Waterland */
1355c51f124SMoriah Waterland char temp[PATH_LGTH];
1365c51f124SMoriah Waterland
1375c51f124SMoriah Waterland if ((tmpfp = fopen(outfile, "w")) == NULL) {
1385c51f124SMoriah Waterland progerr(gettext(ERR_TEMP), errno);
1395c51f124SMoriah Waterland quit(99);
1405c51f124SMoriah Waterland }
1415c51f124SMoriah Waterland envsave = environ;
1425c51f124SMoriah Waterland environ = params; /* use only local environ */
1435c51f124SMoriah Waterland attrdefault(); /* assume no default attributes */
1445c51f124SMoriah Waterland
1455c51f124SMoriah Waterland /*
1465c51f124SMoriah Waterland * Environment parameters are optional, so variable
1475c51f124SMoriah Waterland * (envparam[i]) could be NULL.
1485c51f124SMoriah Waterland */
1495c51f124SMoriah Waterland for (i = 0; (envparam[i] != NULL) &&
1505c51f124SMoriah Waterland (pt = strchr(envparam[i], '=')); i++) {
1515c51f124SMoriah Waterland *pt = '\0';
1525c51f124SMoriah Waterland rdonly[nrdonly++] = qstrdup(envparam[i]);
1535c51f124SMoriah Waterland *pt = '=';
1545c51f124SMoriah Waterland if (putenv(qstrdup(envparam[i]))) { /* bugid 1090920 */
1555c51f124SMoriah Waterland progerr(gettext(ERR_ENVBUILD), errno);
1565c51f124SMoriah Waterland quit(99);
1575c51f124SMoriah Waterland }
1585c51f124SMoriah Waterland if (nrdonly >= MAXPARAMS) {
1595c51f124SMoriah Waterland progerr(gettext(ERR_MAXPARAMS), MAXPARAMS);
1605c51f124SMoriah Waterland quit(1);
1615c51f124SMoriah Waterland }
1625c51f124SMoriah Waterland }
1635c51f124SMoriah Waterland
1645c51f124SMoriah Waterland pushenv(protofile);
1655c51f124SMoriah Waterland errflg = 0;
1665c51f124SMoriah Waterland again:
1675c51f124SMoriah Waterland fakebasedir = 0;
1685c51f124SMoriah Waterland while (!feof(fp)) {
1695c51f124SMoriah Waterland c = getc(fp);
1705c51f124SMoriah Waterland while (isspace(c))
1715c51f124SMoriah Waterland c = getc(fp);
1725c51f124SMoriah Waterland
1735c51f124SMoriah Waterland if (c == '#') {
1745c51f124SMoriah Waterland do c = getc(fp); while ((c != EOF) && (c != '\n'));
1755c51f124SMoriah Waterland continue;
1765c51f124SMoriah Waterland }
1775c51f124SMoriah Waterland if (c == EOF)
1785c51f124SMoriah Waterland break;
1795c51f124SMoriah Waterland
1805c51f124SMoriah Waterland if (c == '!') {
1815c51f124SMoriah Waterland /*
1825c51f124SMoriah Waterland * IMPORTANT NOTE: THE SIZE OF temp IS HARD CODED INTO
1835c51f124SMoriah Waterland * the FOLLOWING CALL TO fscanf -- YOU MUST CHANGE THIS
1845c51f124SMoriah Waterland * LINE IF THE SIZE OF fscanf IS EVER CHANGED!!!
1855c51f124SMoriah Waterland */
1865c51f124SMoriah Waterland (void) fscanf(fp, "%4096s", temp);
1875c51f124SMoriah Waterland
1885c51f124SMoriah Waterland if (strcmp(temp, "include") == 0)
1895c51f124SMoriah Waterland doinclude();
1905c51f124SMoriah Waterland else if (strcmp(temp, "rsearch") == 0)
1915c51f124SMoriah Waterland dorsearch();
1925c51f124SMoriah Waterland else if (strcmp(temp, "search") == 0)
1935c51f124SMoriah Waterland dosearch();
1945c51f124SMoriah Waterland else if (strcmp(temp, "default") == 0) {
1955c51f124SMoriah Waterland if (doattrib())
1965c51f124SMoriah Waterland break;
1975c51f124SMoriah Waterland } else if (strchr(temp, '=')) {
1985c51f124SMoriah Waterland translate(temp, mybuff);
1995c51f124SMoriah Waterland /* put this into the local environment */
2005c51f124SMoriah Waterland lputenv(mybuff);
2015c51f124SMoriah Waterland (void) fscanf(fp, "%*[^\n]"); /* rest of line */
2025c51f124SMoriah Waterland (void) fscanf(fp, "\n"); /* rest of line */
2035c51f124SMoriah Waterland } else {
2045c51f124SMoriah Waterland error(1);
2055c51f124SMoriah Waterland logerr(gettext(MSG_BANG), temp);
2065c51f124SMoriah Waterland (void) fscanf(fp, "%*[^\n]"); /* read of line */
2075c51f124SMoriah Waterland (void) fscanf(fp, "\n"); /* read of line */
2085c51f124SMoriah Waterland }
2095c51f124SMoriah Waterland continue;
2105c51f124SMoriah Waterland }
2115c51f124SMoriah Waterland (void) ungetc(c, fp);
2125c51f124SMoriah Waterland
2135c51f124SMoriah Waterland if ((n = gpkgmap(&entry, fp)) < 0) {
2145c51f124SMoriah Waterland char *errstr;
2155c51f124SMoriah Waterland
2165c51f124SMoriah Waterland error(1);
2175c51f124SMoriah Waterland errstr = getErrstr();
2185c51f124SMoriah Waterland logerr(gettext("garbled entry"));
2195c51f124SMoriah Waterland logerr(gettext("- pathname: %s"),
2205c51f124SMoriah Waterland (entry.path && *entry.path) ? entry.path :
2215c51f124SMoriah Waterland "Unknown");
2225c51f124SMoriah Waterland logerr(gettext("- problem: %s"),
2235c51f124SMoriah Waterland (errstr && *errstr) ? errstr : "Unknown");
2245c51f124SMoriah Waterland break;
2255c51f124SMoriah Waterland }
2265c51f124SMoriah Waterland if (n == 0)
2275c51f124SMoriah Waterland break; /* done with file */
2285c51f124SMoriah Waterland
2295c51f124SMoriah Waterland /* don't allow classname to be parametric */
2305c51f124SMoriah Waterland if (entry.ftype != 'i') {
2315c51f124SMoriah Waterland if (entry.pkg_class[0] == '$') {
2325c51f124SMoriah Waterland error(1);
2335c51f124SMoriah Waterland logerr(gettext(MSG_BPARAMC), entry.path);
2345c51f124SMoriah Waterland }
2355c51f124SMoriah Waterland }
2365c51f124SMoriah Waterland
2375c51f124SMoriah Waterland if (strchr("dxlscbp", entry.ftype)) {
2385c51f124SMoriah Waterland /*
2395c51f124SMoriah Waterland * We don't need to search for things without any
2405c51f124SMoriah Waterland * contents in them.
2415c51f124SMoriah Waterland */
2425c51f124SMoriah Waterland if (strchr("cb", entry.ftype)) {
2435c51f124SMoriah Waterland if (entry.ainfo.major == BADMAJOR ||
2445c51f124SMoriah Waterland entry.ainfo.minor == BADMINOR) {
2455c51f124SMoriah Waterland error(1);
2465c51f124SMoriah Waterland logerr(gettext(MSG_NODEVICE),
2475c51f124SMoriah Waterland entry.path);
2485c51f124SMoriah Waterland }
2495c51f124SMoriah Waterland }
2505c51f124SMoriah Waterland path = NULL;
2515c51f124SMoriah Waterland } else {
2525c51f124SMoriah Waterland path = findfile(entry.path, entry.ainfo.local);
2535c51f124SMoriah Waterland if (!path)
2545c51f124SMoriah Waterland continue;
2555c51f124SMoriah Waterland
2565c51f124SMoriah Waterland entry.ainfo.local = path;
2575c51f124SMoriah Waterland if (strchr("fevin?", entry.ftype)) {
2585c51f124SMoriah Waterland if (cverify(0, &entry.ftype, path,
2595c51f124SMoriah Waterland &entry.cinfo, 1)) {
2605c51f124SMoriah Waterland error(1);
2615c51f124SMoriah Waterland logerr(gettext(MSG_CONTENTS), path);
2625c51f124SMoriah Waterland }
2635c51f124SMoriah Waterland }
2645c51f124SMoriah Waterland }
2655c51f124SMoriah Waterland
2665c51f124SMoriah Waterland /* Warn if attributes are not set correctly. */
2675c51f124SMoriah Waterland if (!strchr("isl", entry.ftype)) {
2685c51f124SMoriah Waterland int dowarning = 0;
2695c51f124SMoriah Waterland int hasbadmode = 0;
2705c51f124SMoriah Waterland
2715c51f124SMoriah Waterland if (entry.ainfo.mode == NOMODE) {
2725c51f124SMoriah Waterland entry.ainfo.mode = CURMODE;
2735c51f124SMoriah Waterland dowarning = 1;
2745c51f124SMoriah Waterland hasbadmode = 1;
2755c51f124SMoriah Waterland }
2765c51f124SMoriah Waterland
2775c51f124SMoriah Waterland if (strcmp(entry.ainfo.owner, NOOWNER) == 0) {
2785c51f124SMoriah Waterland (void) strlcpy(entry.ainfo.owner, CUROWNER,
2795c51f124SMoriah Waterland sizeof (entry.ainfo.owner));
2805c51f124SMoriah Waterland dowarning = 1;
2815c51f124SMoriah Waterland }
2825c51f124SMoriah Waterland
2835c51f124SMoriah Waterland if (strcmp(entry.ainfo.group, NOGROUP) == 0) {
2845c51f124SMoriah Waterland (void) strlcpy(entry.ainfo.group, CURGROUP,
2855c51f124SMoriah Waterland sizeof (entry.ainfo.group));
2865c51f124SMoriah Waterland dowarning = 1;
2875c51f124SMoriah Waterland }
2885c51f124SMoriah Waterland
2895c51f124SMoriah Waterland
2905c51f124SMoriah Waterland if (dowarning) {
2915c51f124SMoriah Waterland if (hasbadmode)
2925c51f124SMoriah Waterland logerr(gettext(WRN_BADATTRM),
2935c51f124SMoriah Waterland "?",
2945c51f124SMoriah Waterland entry.ainfo.owner,
2955c51f124SMoriah Waterland entry.ainfo.group,
2965c51f124SMoriah Waterland entry.path);
2975c51f124SMoriah Waterland else
2985c51f124SMoriah Waterland logerr(gettext(WRN_BADATTR),
2995c51f124SMoriah Waterland (int)entry.ainfo.mode,
3005c51f124SMoriah Waterland entry.ainfo.owner,
3015c51f124SMoriah Waterland entry.ainfo.group,
3025c51f124SMoriah Waterland entry.path);
3035c51f124SMoriah Waterland }
3045c51f124SMoriah Waterland }
3055c51f124SMoriah Waterland
3065c51f124SMoriah Waterland /*
3075c51f124SMoriah Waterland * Resolve build parameters (initial lower case) in
3085c51f124SMoriah Waterland * the link and target paths.
3095c51f124SMoriah Waterland */
3105c51f124SMoriah Waterland if (strchr("ls", entry.ftype)) {
3115c51f124SMoriah Waterland if (!RELATIVE(entry.ainfo.local) ||
3125c51f124SMoriah Waterland PARAMETRIC(entry.ainfo.local)) {
3135c51f124SMoriah Waterland if (mappath(1, entry.ainfo.local)) {
3145c51f124SMoriah Waterland error(1);
3155c51f124SMoriah Waterland logerr(gettext(ERR_PATHVAR),
3165c51f124SMoriah Waterland entry.ainfo.local);
3175c51f124SMoriah Waterland break;
3185c51f124SMoriah Waterland }
3195c51f124SMoriah Waterland
3205c51f124SMoriah Waterland canonize(entry.ainfo.local);
3215c51f124SMoriah Waterland }
3225c51f124SMoriah Waterland }
3235c51f124SMoriah Waterland
3245c51f124SMoriah Waterland /*
3255c51f124SMoriah Waterland * Warn if top level file or directory is an install
3265c51f124SMoriah Waterland * parameter
3275c51f124SMoriah Waterland */
3285c51f124SMoriah Waterland if (entry.ftype != 'i') {
3295c51f124SMoriah Waterland if (entry.path[0] == '$' && isupper(entry.path[1]))
3305c51f124SMoriah Waterland fakebasedir = 1;
3315c51f124SMoriah Waterland }
3325c51f124SMoriah Waterland
3335c51f124SMoriah Waterland if (mappath(1, entry.path)) {
3345c51f124SMoriah Waterland error(1);
3355c51f124SMoriah Waterland logerr(gettext(ERR_PATHVAR), entry.path);
3365c51f124SMoriah Waterland break;
3375c51f124SMoriah Waterland }
3385c51f124SMoriah Waterland
3395c51f124SMoriah Waterland canonize(entry.path);
3405c51f124SMoriah Waterland if (ppkgmap(&entry, tmpfp)) {
3415c51f124SMoriah Waterland error(1);
3425c51f124SMoriah Waterland logerr(gettext(MSG_WRITE), errno);
3435c51f124SMoriah Waterland break;
3445c51f124SMoriah Waterland }
3455c51f124SMoriah Waterland }
3465c51f124SMoriah Waterland
3475c51f124SMoriah Waterland if (fakebasedir) {
3485c51f124SMoriah Waterland logerr(gettext(WRN_FAKEBD));
3495c51f124SMoriah Waterland fakebasedir = 0;
3505c51f124SMoriah Waterland }
3515c51f124SMoriah Waterland
3525c51f124SMoriah Waterland if (popenv())
3535c51f124SMoriah Waterland goto again;
3545c51f124SMoriah Waterland
3555c51f124SMoriah Waterland (void) fclose(tmpfp);
3565c51f124SMoriah Waterland environ = envsave; /* restore environment */
3575c51f124SMoriah Waterland
3585c51f124SMoriah Waterland return (errflg ? 1 : 0);
3595c51f124SMoriah Waterland }
3605c51f124SMoriah Waterland
3615c51f124SMoriah Waterland static char *
findfile(char * path,char * local)3625c51f124SMoriah Waterland findfile(char *path, char *local)
3635c51f124SMoriah Waterland {
3645c51f124SMoriah Waterland struct stat statbuf;
3655c51f124SMoriah Waterland static char host[PATH_MAX];
3665c51f124SMoriah Waterland register char *pt;
3675c51f124SMoriah Waterland char temp[PATH_MAX], *basename;
3685c51f124SMoriah Waterland int i;
3695c51f124SMoriah Waterland
3705c51f124SMoriah Waterland /*
3715c51f124SMoriah Waterland * map any parameters specified in path to their corresponding values
3725c51f124SMoriah Waterland * and make sure the path is in its canonical form; any parmeters for
3735c51f124SMoriah Waterland * which a value is not defined will be left unexpanded. Since this
3745c51f124SMoriah Waterland * is an actual search for a real file (which will not end up in the
3755c51f124SMoriah Waterland * package) - we map ALL variables (both build and Install).
3765c51f124SMoriah Waterland */
3775c51f124SMoriah Waterland (void) strlcpy(temp, (local && local[0] ? local : path), sizeof (temp));
3785c51f124SMoriah Waterland mappath(0, temp);
3795c51f124SMoriah Waterland canonize(temp);
3805c51f124SMoriah Waterland
3815c51f124SMoriah Waterland *host = '\0';
3825c51f124SMoriah Waterland if (rootlist[0] || (basedir && (*temp != '/'))) {
3835c51f124SMoriah Waterland /*
3845c51f124SMoriah Waterland * search for path in the pseudo-root/basedir directory; note
3855c51f124SMoriah Waterland * that package information files should NOT be included in
3865c51f124SMoriah Waterland * this list
3875c51f124SMoriah Waterland */
3885c51f124SMoriah Waterland if (entry.ftype != 'i')
3895c51f124SMoriah Waterland return (srchroot(temp, host));
3905c51f124SMoriah Waterland }
3915c51f124SMoriah Waterland
3925c51f124SMoriah Waterland /* looking for local object file */
3935c51f124SMoriah Waterland if (local && *local) {
3945c51f124SMoriah Waterland basepath(temp, dname[nfp], NULL);
3955c51f124SMoriah Waterland /*
3965c51f124SMoriah Waterland * If it equals "/dev/null", that just means it's an empty
3975c51f124SMoriah Waterland * file. Otherwise, we'll really be writing stuff, so we need
3985c51f124SMoriah Waterland * to verify the source.
3995c51f124SMoriah Waterland */
4005c51f124SMoriah Waterland if (strcmp(temp, "/dev/null") != 0) {
4015c51f124SMoriah Waterland if (stat(temp, &statbuf) ||
4025c51f124SMoriah Waterland !(statbuf.st_mode & S_IFREG)) {
4035c51f124SMoriah Waterland error(1);
4045c51f124SMoriah Waterland logerr(gettext(MSG_SRCHLOC), path);
4055c51f124SMoriah Waterland return (NULL);
4065c51f124SMoriah Waterland }
4075c51f124SMoriah Waterland }
4085c51f124SMoriah Waterland (void) strlcpy(host, temp, sizeof (host));
4095c51f124SMoriah Waterland return (host);
4105c51f124SMoriah Waterland }
4115c51f124SMoriah Waterland
4125c51f124SMoriah Waterland for (i = 0; rootp[nfp][i]; i++) {
4135c51f124SMoriah Waterland (void) snprintf(host, sizeof (host), "%s/%s", rootp[nfp][i],
4145c51f124SMoriah Waterland temp + (*temp == '/' ? 1 : 0));
4155c51f124SMoriah Waterland if ((stat(host, &statbuf) == 0) &&
4165c51f124SMoriah Waterland (statbuf.st_mode & S_IFREG)) {
4175c51f124SMoriah Waterland return (host);
4185c51f124SMoriah Waterland }
4195c51f124SMoriah Waterland }
4205c51f124SMoriah Waterland
4215c51f124SMoriah Waterland pt = strrchr(temp, '/');
4225c51f124SMoriah Waterland if (!pt++)
4235c51f124SMoriah Waterland pt = temp;
4245c51f124SMoriah Waterland
4255c51f124SMoriah Waterland basename = pt;
4265c51f124SMoriah Waterland
4275c51f124SMoriah Waterland for (i = 0; srchp[nfp][i]; i++) {
4285c51f124SMoriah Waterland (void) snprintf(host, sizeof (host), "%s/%s",
4295c51f124SMoriah Waterland srchp[nfp][i], basename);
4305c51f124SMoriah Waterland if ((stat(host, &statbuf) == 0) &&
4315c51f124SMoriah Waterland (statbuf.st_mode & S_IFREG)) {
4325c51f124SMoriah Waterland return (host);
4335c51f124SMoriah Waterland }
4345c51f124SMoriah Waterland }
4355c51f124SMoriah Waterland
4365c51f124SMoriah Waterland /* check current directory as a last resort */
4375c51f124SMoriah Waterland (void) snprintf(host, sizeof (host), "%s/%s", dname[nfp], basename);
4385c51f124SMoriah Waterland if ((stat(host, &statbuf) == 0) && (statbuf.st_mode & S_IFREG))
4395c51f124SMoriah Waterland return (host);
4405c51f124SMoriah Waterland
4415c51f124SMoriah Waterland error(1);
4425c51f124SMoriah Waterland logerr(gettext(MSG_SRCHSRCH), path);
4435c51f124SMoriah Waterland return (NULL);
4445c51f124SMoriah Waterland }
4455c51f124SMoriah Waterland
4465c51f124SMoriah Waterland static void
dosearch(void)4475c51f124SMoriah Waterland dosearch(void)
4485c51f124SMoriah Waterland {
4495c51f124SMoriah Waterland char temp[PATH_MAX], lookpath[PATH_MAX], *pt;
4505c51f124SMoriah Waterland int n;
4515c51f124SMoriah Waterland
4525c51f124SMoriah Waterland (void) fgets(temp, PATH_MAX, fp);
4535c51f124SMoriah Waterland translate(temp, lookpath);
4545c51f124SMoriah Waterland
4555c51f124SMoriah Waterland for (n = 0; srchp[nfp][n]; n++)
4565c51f124SMoriah Waterland free(srchp[nfp][n]);
4575c51f124SMoriah Waterland
4585c51f124SMoriah Waterland n = 0;
4595c51f124SMoriah Waterland pt = strtok(lookpath, separ);
4605c51f124SMoriah Waterland if (pt && *pt) {
4615c51f124SMoriah Waterland do {
4625c51f124SMoriah Waterland if (*pt != '/') {
4635c51f124SMoriah Waterland /* make relative path an absolute directory */
4645c51f124SMoriah Waterland (void) snprintf(temp, sizeof (temp),
4655c51f124SMoriah Waterland "%s/%s", dname[nfp], pt);
4665c51f124SMoriah Waterland pt = temp;
4675c51f124SMoriah Waterland }
4685c51f124SMoriah Waterland canonize(pt);
4695c51f124SMoriah Waterland srchp[nfp][n++] = qstrdup(pt);
4705c51f124SMoriah Waterland } while (pt = strtok(NULL, separ));
4715c51f124SMoriah Waterland srchp[nfp][n] = NULL;
4725c51f124SMoriah Waterland }
4735c51f124SMoriah Waterland }
4745c51f124SMoriah Waterland
4755c51f124SMoriah Waterland static void
dorsearch(void)4765c51f124SMoriah Waterland dorsearch(void)
4775c51f124SMoriah Waterland {
4785c51f124SMoriah Waterland char temp[PATH_MAX], lookpath[PATH_MAX], *pt;
4795c51f124SMoriah Waterland int n;
4805c51f124SMoriah Waterland
4815c51f124SMoriah Waterland (void) fgets(temp, PATH_MAX, fp);
4825c51f124SMoriah Waterland translate(temp, lookpath);
4835c51f124SMoriah Waterland
4845c51f124SMoriah Waterland for (n = 0; rootp[nfp][n]; n++)
4855c51f124SMoriah Waterland free(rootp[nfp][n]);
4865c51f124SMoriah Waterland
4875c51f124SMoriah Waterland n = 0;
4885c51f124SMoriah Waterland pt = strtok(lookpath, separ);
4895c51f124SMoriah Waterland do {
4905c51f124SMoriah Waterland if (*pt != '/') {
4915c51f124SMoriah Waterland /* make relative path an absolute directory */
4925c51f124SMoriah Waterland (void) snprintf(temp, sizeof (temp),
4935c51f124SMoriah Waterland "%s/%s", dname[nfp], pt);
4945c51f124SMoriah Waterland pt = temp;
4955c51f124SMoriah Waterland }
4965c51f124SMoriah Waterland canonize(pt);
4975c51f124SMoriah Waterland rootp[nfp][n++] = qstrdup(pt);
4985c51f124SMoriah Waterland } while (pt = strtok(NULL, separ));
4995c51f124SMoriah Waterland rootp[nfp][n] = NULL;
5005c51f124SMoriah Waterland }
5015c51f124SMoriah Waterland
5025c51f124SMoriah Waterland /*
5035c51f124SMoriah Waterland * This function reads the default mode, owner and group from the prototype
5045c51f124SMoriah Waterland * file and makes that available.
5055c51f124SMoriah Waterland */
5065c51f124SMoriah Waterland static int
doattrib(void)5075c51f124SMoriah Waterland doattrib(void)
5085c51f124SMoriah Waterland {
5095c51f124SMoriah Waterland char *pt, attrib[PATH_MAX], *mode_ptr, *owner_ptr, *group_ptr, *eol;
5105c51f124SMoriah Waterland int mode;
5115c51f124SMoriah Waterland char owner[ATRSIZ+1], group[ATRSIZ+1], attrib_save[(4*ATRSIZ)];
5125c51f124SMoriah Waterland
5135c51f124SMoriah Waterland (void) fgets(attrib, PATH_MAX, fp);
5145c51f124SMoriah Waterland
5155c51f124SMoriah Waterland (void) strlcpy(attrib_save, attrib, sizeof (attrib_save));
5165c51f124SMoriah Waterland
5175c51f124SMoriah Waterland /*
5185c51f124SMoriah Waterland * Now resolve any variables that may be present. Start on group and
5195c51f124SMoriah Waterland * move backward since that keeps the resolved string from
5205c51f124SMoriah Waterland * overwriting any of the other entries. This is required since
5215c51f124SMoriah Waterland * mapvar() writes the resolved string over the string provided.
5225c51f124SMoriah Waterland */
5235c51f124SMoriah Waterland mode_ptr = strtok(attrib, " \t");
5245c51f124SMoriah Waterland owner_ptr = strtok(NULL, " \t");
5255c51f124SMoriah Waterland group_ptr = strtok(NULL, " \t\n");
5265c51f124SMoriah Waterland eol = strtok(NULL, " \t\n");
5275c51f124SMoriah Waterland if (strtok(NULL, " \t\n")) {
5285c51f124SMoriah Waterland /* extra tokens on the line */
5295c51f124SMoriah Waterland error(1);
5305c51f124SMoriah Waterland logerr(gettext(MSG_GARBDEFLT), (eol) ? eol :
5315c51f124SMoriah Waterland gettext("unreadable at end of line"));
5325c51f124SMoriah Waterland return (1);
5335c51f124SMoriah Waterland }
5345c51f124SMoriah Waterland
5355c51f124SMoriah Waterland if (group_ptr && mapvar(1, group_ptr) == 0)
5365c51f124SMoriah Waterland (void) strncpy(group, group_ptr, ATRSIZ);
5375c51f124SMoriah Waterland else {
5385c51f124SMoriah Waterland error(1);
5395c51f124SMoriah Waterland logerr(gettext(MSG_GARBDEFLT), (attrib_save) ?
5405c51f124SMoriah Waterland ((attrib_save[0]) ? attrib_save : gettext("none")) :
5415c51f124SMoriah Waterland gettext("unreadable at group"));
5425c51f124SMoriah Waterland return (1);
5435c51f124SMoriah Waterland }
5445c51f124SMoriah Waterland
5455c51f124SMoriah Waterland if (owner_ptr && mapvar(1, owner_ptr) == 0)
5465c51f124SMoriah Waterland (void) strncpy(owner, owner_ptr, ATRSIZ);
5475c51f124SMoriah Waterland else {
5485c51f124SMoriah Waterland error(1);
5495c51f124SMoriah Waterland logerr(gettext(MSG_GARBDEFLT), (attrib_save) ?
5505c51f124SMoriah Waterland ((attrib_save[0]) ? attrib_save : gettext("none")) :
5515c51f124SMoriah Waterland gettext("unreadable at owner"));
5525c51f124SMoriah Waterland return (1);
5535c51f124SMoriah Waterland }
5545c51f124SMoriah Waterland
5555c51f124SMoriah Waterland /*
5565c51f124SMoriah Waterland * For mode, don't use scanf, since we want to force an octal
5575c51f124SMoriah Waterland * interpretation and need to limit the length of the owner and group
5585c51f124SMoriah Waterland * specifications.
5595c51f124SMoriah Waterland */
5605c51f124SMoriah Waterland if (mode_ptr && mapvar(1, mode_ptr) == 0)
5615c51f124SMoriah Waterland mode = strtol(mode_ptr, &pt, 8);
5625c51f124SMoriah Waterland else {
5635c51f124SMoriah Waterland error(1);
5645c51f124SMoriah Waterland logerr(gettext(MSG_GARBDEFLT), (attrib_save) ?
5655c51f124SMoriah Waterland ((attrib_save[0]) ? attrib_save : gettext("none")) :
5665c51f124SMoriah Waterland gettext("unreadable at mode"));
5675c51f124SMoriah Waterland return (1);
5685c51f124SMoriah Waterland }
5695c51f124SMoriah Waterland
5705c51f124SMoriah Waterland /* free any previous memory from qstrdup */
5715c51f124SMoriah Waterland if (d_own[nfp])
5725c51f124SMoriah Waterland free(d_own[nfp]);
5735c51f124SMoriah Waterland if (d_grp[nfp])
5745c51f124SMoriah Waterland free(d_grp[nfp]);
5755c51f124SMoriah Waterland
5765c51f124SMoriah Waterland d_mod[nfp] = mode;
5775c51f124SMoriah Waterland d_own[nfp] = qstrdup(owner);
5785c51f124SMoriah Waterland d_grp[nfp] = qstrdup(group);
5795c51f124SMoriah Waterland
5805c51f124SMoriah Waterland attrpreset(d_mod[nfp], d_own[nfp], d_grp[nfp]);
5815c51f124SMoriah Waterland
5825c51f124SMoriah Waterland return (0);
5835c51f124SMoriah Waterland }
5845c51f124SMoriah Waterland
5855c51f124SMoriah Waterland static void
doinclude(void)5865c51f124SMoriah Waterland doinclude(void)
5875c51f124SMoriah Waterland {
5885c51f124SMoriah Waterland char file[PATH_MAX];
5895c51f124SMoriah Waterland char temp[PATH_MAX];
5905c51f124SMoriah Waterland
5915c51f124SMoriah Waterland (void) fgets(temp, PATH_MAX, fp);
5925c51f124SMoriah Waterland
5935c51f124SMoriah Waterland /*
5945c51f124SMoriah Waterland * IMPORTANT NOTE: THE SIZE OF temp IS HARD CODED INTO THE
5955c51f124SMoriah Waterland * FOLLOWING CALL TO fscanf -- YOU MUST CHANGE THIS LINE IF
5965c51f124SMoriah Waterland * THE SIZE OF fscanf IS EVER CHANGED!!!
5975c51f124SMoriah Waterland */
5985c51f124SMoriah Waterland (void) sscanf(temp, "%1024s", file);
5995c51f124SMoriah Waterland
6005c51f124SMoriah Waterland translate(file, temp);
6015c51f124SMoriah Waterland canonize(temp);
6025c51f124SMoriah Waterland
603*c57b7750SToomas Soome if (*temp == '\0')
6045c51f124SMoriah Waterland return;
6055c51f124SMoriah Waterland else if (*temp != '/')
6065c51f124SMoriah Waterland (void) snprintf(file, sizeof (file), "%s/%s", dname[nfp], temp);
6075c51f124SMoriah Waterland else
6085c51f124SMoriah Waterland (void) strlcpy(file, temp, sizeof (file));
6095c51f124SMoriah Waterland
6105c51f124SMoriah Waterland canonize(file);
6115c51f124SMoriah Waterland pushenv(file);
6125c51f124SMoriah Waterland }
6135c51f124SMoriah Waterland
6145c51f124SMoriah Waterland /*
6155c51f124SMoriah Waterland * This does what mappath() does except that it does it for ALL variables
6165c51f124SMoriah Waterland * using whitespace as a token separator. This is used to resolve search
6175c51f124SMoriah Waterland * paths and assignment statements. It doesn't effect the build versus
6185c51f124SMoriah Waterland * install decision made for pkgmap variables.
6195c51f124SMoriah Waterland */
6205c51f124SMoriah Waterland static void
translate(register char * pt,register char * copy)6215c51f124SMoriah Waterland translate(register char *pt, register char *copy)
6225c51f124SMoriah Waterland {
6235c51f124SMoriah Waterland char *pt2, varname[MAX_PKG_PARAM_LENGTH];
6245c51f124SMoriah Waterland
6255c51f124SMoriah Waterland token:
6265c51f124SMoriah Waterland /* eat white space */
6275c51f124SMoriah Waterland while (isspace(*pt))
6285c51f124SMoriah Waterland pt++;
6295c51f124SMoriah Waterland while (*pt && !isspace(*pt)) {
6305c51f124SMoriah Waterland if (*pt == '$') {
6315c51f124SMoriah Waterland pt2 = varname;
6325c51f124SMoriah Waterland while (*++pt && !strchr("/= \t\n\r", *pt))
6335c51f124SMoriah Waterland *pt2++ = *pt;
6345c51f124SMoriah Waterland *pt2 = '\0';
6355c51f124SMoriah Waterland if (pt2 = getenv(varname)) {
6365c51f124SMoriah Waterland while (*pt2)
6375c51f124SMoriah Waterland *copy++ = *pt2++;
6385c51f124SMoriah Waterland }
6395c51f124SMoriah Waterland } else
6405c51f124SMoriah Waterland *copy++ = *pt++;
6415c51f124SMoriah Waterland }
6425c51f124SMoriah Waterland if (*pt) {
6435c51f124SMoriah Waterland *copy++ = ' ';
6445c51f124SMoriah Waterland goto token;
6455c51f124SMoriah Waterland }
6465c51f124SMoriah Waterland *copy = '\0';
6475c51f124SMoriah Waterland }
6485c51f124SMoriah Waterland
6495c51f124SMoriah Waterland static void
error(int flag)6505c51f124SMoriah Waterland error(int flag)
6515c51f124SMoriah Waterland {
6525c51f124SMoriah Waterland static char *lasterr = NULL;
6535c51f124SMoriah Waterland
6545c51f124SMoriah Waterland if (lasterr != proto[nfp]) {
6555c51f124SMoriah Waterland lasterr = proto[nfp];
6565c51f124SMoriah Waterland (void) fprintf(stderr, gettext("ERROR in %s:\n"), lasterr);
6575c51f124SMoriah Waterland }
6585c51f124SMoriah Waterland if (flag)
6595c51f124SMoriah Waterland errflg++;
6605c51f124SMoriah Waterland }
6615c51f124SMoriah Waterland
6625c51f124SMoriah Waterland /* Set up defaults and change to the build directory. */
6635c51f124SMoriah Waterland static void
pushenv(char * file)6645c51f124SMoriah Waterland pushenv(char *file)
6655c51f124SMoriah Waterland {
6665c51f124SMoriah Waterland register char *pt;
6675c51f124SMoriah Waterland static char topdir[PATH_MAX];
6685c51f124SMoriah Waterland
6695c51f124SMoriah Waterland if ((nfp+1) >= NRECURS) {
6705c51f124SMoriah Waterland error(1);
6715c51f124SMoriah Waterland logerr(gettext(MSG_NRECURS), NRECURS);
6725c51f124SMoriah Waterland logerr(gettext(MSG_IGNINCLUDE), file);
6735c51f124SMoriah Waterland return;
6745c51f124SMoriah Waterland }
6755c51f124SMoriah Waterland
6765c51f124SMoriah Waterland if (strcmp(file, "-") == 0) {
6775c51f124SMoriah Waterland fp = stdin;
6785c51f124SMoriah Waterland } else if ((fp = fopen(file, "r")) == NULL) {
6795c51f124SMoriah Waterland error(1);
6805c51f124SMoriah Waterland logerr(gettext(MSG_RDINCLUDE), file, errno);
6815c51f124SMoriah Waterland if (nfp >= 0) {
6825c51f124SMoriah Waterland logerr(gettext(MSG_IGNINCLUDE), file);
6835c51f124SMoriah Waterland fp = sfp[nfp];
6845c51f124SMoriah Waterland return;
6855c51f124SMoriah Waterland } else
6865c51f124SMoriah Waterland quit(1);
6875c51f124SMoriah Waterland }
6885c51f124SMoriah Waterland sfp[++nfp] = fp;
6895c51f124SMoriah Waterland srchp[nfp][0] = NULL;
6905c51f124SMoriah Waterland rootp[nfp][0] = NULL;
6915c51f124SMoriah Waterland d_mod[nfp] = (mode_t)(-1);
6925c51f124SMoriah Waterland d_own[nfp] = NULL;
6935c51f124SMoriah Waterland d_grp[nfp] = NULL;
6945c51f124SMoriah Waterland
6955c51f124SMoriah Waterland if (!nfp) {
6965c51f124SMoriah Waterland /* upper level proto file */
6975c51f124SMoriah Waterland proto[nfp] = file;
6985c51f124SMoriah Waterland if (file[0] == '/')
6995c51f124SMoriah Waterland pt = strcpy(topdir, file);
7005c51f124SMoriah Waterland else {
7015c51f124SMoriah Waterland /* path is relative to the prototype file specified */
7025c51f124SMoriah Waterland pt = getcwd(NULL, PATH_MAX);
7035c51f124SMoriah Waterland if (pt == NULL) {
7045c51f124SMoriah Waterland progerr(gettext(ERR_GETCWD), errno);
7055c51f124SMoriah Waterland quit(99);
7065c51f124SMoriah Waterland }
7075c51f124SMoriah Waterland (void) snprintf(topdir, sizeof (topdir),
7085c51f124SMoriah Waterland "%s/%s", pt, file);
7095c51f124SMoriah Waterland }
7105c51f124SMoriah Waterland if (pt = strrchr(topdir, '/'))
7115c51f124SMoriah Waterland *pt = '\0'; /* should always happen */
7125c51f124SMoriah Waterland if (topdir[0] == '\0')
7135c51f124SMoriah Waterland (void) strlcpy(topdir, "/", sizeof (topdir));
7145c51f124SMoriah Waterland dname[nfp] = topdir;
7155c51f124SMoriah Waterland } else {
7165c51f124SMoriah Waterland proto[nfp] = qstrdup(file);
7175c51f124SMoriah Waterland dname[nfp] = qstrdup(file);
7185c51f124SMoriah Waterland if (pt = strrchr(dname[nfp], '/'))
7195c51f124SMoriah Waterland *pt = '\0';
7205c51f124SMoriah Waterland else {
7215c51f124SMoriah Waterland /* same directory as the last prototype */
7225c51f124SMoriah Waterland free(dname[nfp]);
7235c51f124SMoriah Waterland dname[nfp] = qstrdup(dname[nfp-1]);
7245c51f124SMoriah Waterland return; /* no need to canonize() or chdir() */
7255c51f124SMoriah Waterland }
7265c51f124SMoriah Waterland }
7275c51f124SMoriah Waterland
7285c51f124SMoriah Waterland canonize(dname[nfp]);
7295c51f124SMoriah Waterland
7305c51f124SMoriah Waterland if (chdir(dname[nfp])) {
7315c51f124SMoriah Waterland error(1);
7325c51f124SMoriah Waterland logerr(gettext(MSG_CHDIR), dname[nfp]);
7335c51f124SMoriah Waterland if (!nfp)
7345c51f124SMoriah Waterland quit(1); /* must be able to cd to upper level */
7355c51f124SMoriah Waterland logerr(gettext(MSG_IGNINCLUDE), proto[nfp]);
7365c51f124SMoriah Waterland (void) popenv();
7375c51f124SMoriah Waterland }
7385c51f124SMoriah Waterland }
7395c51f124SMoriah Waterland
7405c51f124SMoriah Waterland /* Restore defaults and return to the prior directory. */
7415c51f124SMoriah Waterland static int
popenv(void)7425c51f124SMoriah Waterland popenv(void)
7435c51f124SMoriah Waterland {
7445c51f124SMoriah Waterland int i;
7455c51f124SMoriah Waterland
7465c51f124SMoriah Waterland (void) fclose(fp);
7475c51f124SMoriah Waterland if (nfp) {
7485c51f124SMoriah Waterland if (proto[nfp])
7495c51f124SMoriah Waterland free(proto[nfp]);
7505c51f124SMoriah Waterland if (dname[nfp])
7515c51f124SMoriah Waterland free(dname[nfp]);
7525c51f124SMoriah Waterland for (i = 0; srchp[nfp][i]; i++)
7535c51f124SMoriah Waterland free(srchp[nfp][i]);
7545c51f124SMoriah Waterland for (i = 0; rootp[nfp][i]; i++)
7555c51f124SMoriah Waterland free(rootp[nfp][i]);
7565c51f124SMoriah Waterland if (d_own[nfp])
7575c51f124SMoriah Waterland free(d_own[nfp]);
7585c51f124SMoriah Waterland if (d_grp[nfp])
7595c51f124SMoriah Waterland free(d_grp[nfp]);
7605c51f124SMoriah Waterland
7615c51f124SMoriah Waterland fp = sfp[--nfp];
7625c51f124SMoriah Waterland
7635c51f124SMoriah Waterland if (chdir(dname[nfp])) {
7645c51f124SMoriah Waterland error(1);
7655c51f124SMoriah Waterland logerr(gettext(MSG_CHDIR), dname[nfp]);
7665c51f124SMoriah Waterland logerr(gettext(MSG_INCOMPLETE), proto[nfp]);
7675c51f124SMoriah Waterland return (popenv());
7685c51f124SMoriah Waterland }
7695c51f124SMoriah Waterland return (1);
7705c51f124SMoriah Waterland }
7715c51f124SMoriah Waterland return (0);
7725c51f124SMoriah Waterland }
7735c51f124SMoriah Waterland
7745c51f124SMoriah Waterland /*
7755c51f124SMoriah Waterland * If this parameter isn't already in place, put it into the local
7765c51f124SMoriah Waterland * environment. This means that command line directives override prototype
7775c51f124SMoriah Waterland * file directives.
7785c51f124SMoriah Waterland */
7795c51f124SMoriah Waterland static void
lputenv(char * s)7805c51f124SMoriah Waterland lputenv(char *s)
7815c51f124SMoriah Waterland {
7825c51f124SMoriah Waterland char *pt;
7835c51f124SMoriah Waterland int i;
7845c51f124SMoriah Waterland
7855c51f124SMoriah Waterland pt = strchr(s, '=');
7865c51f124SMoriah Waterland if (!pt)
7875c51f124SMoriah Waterland return;
7885c51f124SMoriah Waterland
7895c51f124SMoriah Waterland *pt = '\0';
7905c51f124SMoriah Waterland for (i = 0; i < nrdonly; i++) {
7915c51f124SMoriah Waterland if (strcmp(rdonly[i], s) == 0) {
7925c51f124SMoriah Waterland *pt = '=';
7935c51f124SMoriah Waterland return;
7945c51f124SMoriah Waterland }
7955c51f124SMoriah Waterland }
7965c51f124SMoriah Waterland *pt = '=';
7975c51f124SMoriah Waterland
7985c51f124SMoriah Waterland if (putenv(qstrdup(s))) {
7995c51f124SMoriah Waterland progerr(gettext(ERR_ENVBUILD), errno);
8005c51f124SMoriah Waterland quit(99);
8015c51f124SMoriah Waterland }
8025c51f124SMoriah Waterland }
8035c51f124SMoriah Waterland
8045c51f124SMoriah Waterland static char *
srchroot(char * path,char * copy)8055c51f124SMoriah Waterland srchroot(char *path, char *copy)
8065c51f124SMoriah Waterland {
8075c51f124SMoriah Waterland struct stat statbuf;
8085c51f124SMoriah Waterland int i;
8095c51f124SMoriah Waterland
8105c51f124SMoriah Waterland i = 0;
8115c51f124SMoriah Waterland root = rootlist[i++];
8125c51f124SMoriah Waterland do {
8135c51f124SMoriah Waterland /* convert with root & basedir info */
8145c51f124SMoriah Waterland cvtpath(path, copy);
8155c51f124SMoriah Waterland /* make it pretty again */
8165c51f124SMoriah Waterland canonize(copy);
8175c51f124SMoriah Waterland
8185c51f124SMoriah Waterland if (stat(copy, &statbuf) || !(statbuf.st_mode & S_IFREG)) {
8195c51f124SMoriah Waterland root = rootlist[i++];
8205c51f124SMoriah Waterland continue; /* host source must be a regular file */
8215c51f124SMoriah Waterland }
8225c51f124SMoriah Waterland return (copy);
8235c51f124SMoriah Waterland } while (root != NULL);
8245c51f124SMoriah Waterland error(1);
8255c51f124SMoriah Waterland logerr(gettext(MSG_SRCHROOT), path);
8265c51f124SMoriah Waterland return (NULL);
8275c51f124SMoriah Waterland }
828