1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
28 /* All Rights Reserved */
29
30
31 #include <stdio.h>
32 #include <string.h>
33 #include <errno.h>
34 #include <ctype.h>
35 #include <sys/types.h>
36 #include <sys/stat.h>
37 #include <limits.h>
38 #include <pkgstrct.h>
39 #include <pkginfo.h>
40 #include <locale.h>
41 #include <libintl.h>
42 #include <unistd.h>
43 #include <stdlib.h>
44 #include <pkglib.h>
45 #include <install.h>
46 #include <libadm.h>
47 #include <libinst.h>
48
49 extern char *basedir, *root, *rootlist[], **environ;
50
51 /*
52 * IMPORTANT NOTE: PLEASE SEE THE DEFINITION OF temp[] BELOW BEFORE
53 * CHANGING THE DEFINITION OF PATH_LGTH!!!!
54 */
55
56 #define PATH_LGTH 4096
57
58 #define MAXPARAMS 256
59 #define NRECURS 20
60
61 #define MSG_BPARAMC "parametric class specification for <%s> not allowed"
62 #define MSG_SRCHLOC "no object for <%s> found in local path"
63 #define MSG_SRCHSRCH "no object for <%s> found in search path"
64 #define MSG_SRCHROOT "no object for <%s> found in root directory"
65 #define MSG_CONTENTS "unable to process contents of object <%s>"
66 #define MSG_WRITE "write of entry failed, errno=%d"
67 #define MSG_GARBDEFLT "garbled default settings: %s"
68 #define MSG_BANG "unknown directive: %s"
69 #define MSG_CHDIR "unable to change directory to <%s>"
70 #define MSG_INCOMPLETE "processing of <%s> may be incomplete"
71 #define MSG_NRECURS "too many levels of include (limit is %d)"
72 #define MSG_RDINCLUDE "unable to process include file <%s>, errno=%d"
73 #define MSG_IGNINCLUDE "ignoring include file <%s>"
74 #define MSG_NODEVICE "device numbers cannot be determined for <%s>"
75
76 #define WRN_BADATTR "WARNING: attributes set to %04o %s %s for <%s>"
77 #define WRN_BADATTRM "WARNING: attributes set to %s %s %s for <%s>"
78 #define WRN_FAKEBD "WARNING: parametric paths may ignore BASEDIR"
79
80 #define ERR_TEMP "unable to obtain temporary file resources, errno=%d"
81 #define ERR_ENVBUILD "unable to build parameter environment, errno=%d"
82 #define ERR_MAXPARAMS "too many parameter definitions (limit is %d)"
83 #define ERR_GETCWD "unable to get current directory, errno=%d"
84 #define ERR_PATHVAR "cannot resolve all build parameters associated with " \
85 "path <%s>."
86
87 static struct cfent entry;
88 static FILE *fp,
89 *sfp[20];
90 static char *dname[NRECURS],
91 *params[256],
92 *proto[NRECURS],
93 *rootp[NRECURS][16],
94 *srchp[NRECURS][16],
95 *d_own[NRECURS],
96 *d_grp[NRECURS],
97 *rdonly[256];
98 static mode_t d_mod[NRECURS];
99 static int nfp = (-1);
100 static int nrdonly = 0;
101 static int errflg = 0;
102 static char *separ = " \t\n, ";
103
104 /* libpkg/gpkgmap.c */
105 extern void attrpreset(int mode, char *owner, char *group);
106 extern void attrdefault();
107 static char *findfile(char *path, char *local);
108 static char *srchroot(char *path, char *copy);
109
110 static int popenv(void);
111
112 static int doattrib(void);
113 static void doinclude(void);
114 static void dorsearch(void);
115 static void dosearch(void);
116 static void error(int flag);
117 static void lputenv(char *s);
118 static void pushenv(char *file);
119 static void translate(register char *pt, register char *copy);
120
121 int
mkpkgmap(char * outfile,char * protofile,char ** envparam)122 mkpkgmap(char *outfile, char *protofile, char **envparam)
123 {
124 FILE *tmpfp;
125 char *pt, *path, mybuff[PATH_LGTH];
126 char **envsave;
127 int c, fakebasedir;
128 int i, n;
129
130 /*
131 * NOTE: THE SIZE OF temp IS HARD CODED INTO CALLS TO fscanf.
132 * YOU *MUST* MAKE SURE TO CHANGE THOSE CALLS IF THE SIZE OF temp
133 * IS EVER CHANGED!!!!!!
134 */
135 char temp[PATH_LGTH];
136
137 if ((tmpfp = fopen(outfile, "w")) == NULL) {
138 progerr(gettext(ERR_TEMP), errno);
139 quit(99);
140 }
141 envsave = environ;
142 environ = params; /* use only local environ */
143 attrdefault(); /* assume no default attributes */
144
145 /*
146 * Environment parameters are optional, so variable
147 * (envparam[i]) could be NULL.
148 */
149 for (i = 0; (envparam[i] != NULL) &&
150 (pt = strchr(envparam[i], '=')); i++) {
151 *pt = '\0';
152 rdonly[nrdonly++] = qstrdup(envparam[i]);
153 *pt = '=';
154 if (putenv(qstrdup(envparam[i]))) { /* bugid 1090920 */
155 progerr(gettext(ERR_ENVBUILD), errno);
156 quit(99);
157 }
158 if (nrdonly >= MAXPARAMS) {
159 progerr(gettext(ERR_MAXPARAMS), MAXPARAMS);
160 quit(1);
161 }
162 }
163
164 pushenv(protofile);
165 errflg = 0;
166 again:
167 fakebasedir = 0;
168 while (!feof(fp)) {
169 c = getc(fp);
170 while (isspace(c))
171 c = getc(fp);
172
173 if (c == '#') {
174 do c = getc(fp); while ((c != EOF) && (c != '\n'));
175 continue;
176 }
177 if (c == EOF)
178 break;
179
180 if (c == '!') {
181 /*
182 * IMPORTANT NOTE: THE SIZE OF temp IS HARD CODED INTO
183 * the FOLLOWING CALL TO fscanf -- YOU MUST CHANGE THIS
184 * LINE IF THE SIZE OF fscanf IS EVER CHANGED!!!
185 */
186 (void) fscanf(fp, "%4096s", temp);
187
188 if (strcmp(temp, "include") == 0)
189 doinclude();
190 else if (strcmp(temp, "rsearch") == 0)
191 dorsearch();
192 else if (strcmp(temp, "search") == 0)
193 dosearch();
194 else if (strcmp(temp, "default") == 0) {
195 if (doattrib())
196 break;
197 } else if (strchr(temp, '=')) {
198 translate(temp, mybuff);
199 /* put this into the local environment */
200 lputenv(mybuff);
201 (void) fscanf(fp, "%*[^\n]"); /* rest of line */
202 (void) fscanf(fp, "\n"); /* rest of line */
203 } else {
204 error(1);
205 logerr(gettext(MSG_BANG), temp);
206 (void) fscanf(fp, "%*[^\n]"); /* read of line */
207 (void) fscanf(fp, "\n"); /* read of line */
208 }
209 continue;
210 }
211 (void) ungetc(c, fp);
212
213 if ((n = gpkgmap(&entry, fp)) < 0) {
214 char *errstr;
215
216 error(1);
217 errstr = getErrstr();
218 logerr(gettext("garbled entry"));
219 logerr(gettext("- pathname: %s"),
220 (entry.path && *entry.path) ? entry.path :
221 "Unknown");
222 logerr(gettext("- problem: %s"),
223 (errstr && *errstr) ? errstr : "Unknown");
224 break;
225 }
226 if (n == 0)
227 break; /* done with file */
228
229 /* don't allow classname to be parametric */
230 if (entry.ftype != 'i') {
231 if (entry.pkg_class[0] == '$') {
232 error(1);
233 logerr(gettext(MSG_BPARAMC), entry.path);
234 }
235 }
236
237 if (strchr("dxlscbp", entry.ftype)) {
238 /*
239 * We don't need to search for things without any
240 * contents in them.
241 */
242 if (strchr("cb", entry.ftype)) {
243 if (entry.ainfo.major == BADMAJOR ||
244 entry.ainfo.minor == BADMINOR) {
245 error(1);
246 logerr(gettext(MSG_NODEVICE),
247 entry.path);
248 }
249 }
250 path = NULL;
251 } else {
252 path = findfile(entry.path, entry.ainfo.local);
253 if (!path)
254 continue;
255
256 entry.ainfo.local = path;
257 if (strchr("fevin?", entry.ftype)) {
258 if (cverify(0, &entry.ftype, path,
259 &entry.cinfo, 1)) {
260 error(1);
261 logerr(gettext(MSG_CONTENTS), path);
262 }
263 }
264 }
265
266 /* Warn if attributes are not set correctly. */
267 if (!strchr("isl", entry.ftype)) {
268 int dowarning = 0;
269 int hasbadmode = 0;
270
271 if (entry.ainfo.mode == NOMODE) {
272 entry.ainfo.mode = CURMODE;
273 dowarning = 1;
274 hasbadmode = 1;
275 }
276
277 if (strcmp(entry.ainfo.owner, NOOWNER) == 0) {
278 (void) strlcpy(entry.ainfo.owner, CUROWNER,
279 sizeof (entry.ainfo.owner));
280 dowarning = 1;
281 }
282
283 if (strcmp(entry.ainfo.group, NOGROUP) == 0) {
284 (void) strlcpy(entry.ainfo.group, CURGROUP,
285 sizeof (entry.ainfo.group));
286 dowarning = 1;
287 }
288
289
290 if (dowarning) {
291 if (hasbadmode)
292 logerr(gettext(WRN_BADATTRM),
293 "?",
294 entry.ainfo.owner,
295 entry.ainfo.group,
296 entry.path);
297 else
298 logerr(gettext(WRN_BADATTR),
299 (int)entry.ainfo.mode,
300 entry.ainfo.owner,
301 entry.ainfo.group,
302 entry.path);
303 }
304 }
305
306 /*
307 * Resolve build parameters (initial lower case) in
308 * the link and target paths.
309 */
310 if (strchr("ls", entry.ftype)) {
311 if (!RELATIVE(entry.ainfo.local) ||
312 PARAMETRIC(entry.ainfo.local)) {
313 if (mappath(1, entry.ainfo.local)) {
314 error(1);
315 logerr(gettext(ERR_PATHVAR),
316 entry.ainfo.local);
317 break;
318 }
319
320 canonize(entry.ainfo.local);
321 }
322 }
323
324 /*
325 * Warn if top level file or directory is an install
326 * parameter
327 */
328 if (entry.ftype != 'i') {
329 if (entry.path[0] == '$' && isupper(entry.path[1]))
330 fakebasedir = 1;
331 }
332
333 if (mappath(1, entry.path)) {
334 error(1);
335 logerr(gettext(ERR_PATHVAR), entry.path);
336 break;
337 }
338
339 canonize(entry.path);
340 if (ppkgmap(&entry, tmpfp)) {
341 error(1);
342 logerr(gettext(MSG_WRITE), errno);
343 break;
344 }
345 }
346
347 if (fakebasedir) {
348 logerr(gettext(WRN_FAKEBD));
349 fakebasedir = 0;
350 }
351
352 if (popenv())
353 goto again;
354
355 (void) fclose(tmpfp);
356 environ = envsave; /* restore environment */
357
358 return (errflg ? 1 : 0);
359 }
360
361 static char *
findfile(char * path,char * local)362 findfile(char *path, char *local)
363 {
364 struct stat statbuf;
365 static char host[PATH_MAX];
366 register char *pt;
367 char temp[PATH_MAX], *basename;
368 int i;
369
370 /*
371 * map any parameters specified in path to their corresponding values
372 * and make sure the path is in its canonical form; any parmeters for
373 * which a value is not defined will be left unexpanded. Since this
374 * is an actual search for a real file (which will not end up in the
375 * package) - we map ALL variables (both build and Install).
376 */
377 (void) strlcpy(temp, (local && local[0] ? local : path), sizeof (temp));
378 mappath(0, temp);
379 canonize(temp);
380
381 *host = '\0';
382 if (rootlist[0] || (basedir && (*temp != '/'))) {
383 /*
384 * search for path in the pseudo-root/basedir directory; note
385 * that package information files should NOT be included in
386 * this list
387 */
388 if (entry.ftype != 'i')
389 return (srchroot(temp, host));
390 }
391
392 /* looking for local object file */
393 if (local && *local) {
394 basepath(temp, dname[nfp], NULL);
395 /*
396 * If it equals "/dev/null", that just means it's an empty
397 * file. Otherwise, we'll really be writing stuff, so we need
398 * to verify the source.
399 */
400 if (strcmp(temp, "/dev/null") != 0) {
401 if (stat(temp, &statbuf) ||
402 !(statbuf.st_mode & S_IFREG)) {
403 error(1);
404 logerr(gettext(MSG_SRCHLOC), path);
405 return (NULL);
406 }
407 }
408 (void) strlcpy(host, temp, sizeof (host));
409 return (host);
410 }
411
412 for (i = 0; rootp[nfp][i]; i++) {
413 (void) snprintf(host, sizeof (host), "%s/%s", rootp[nfp][i],
414 temp + (*temp == '/' ? 1 : 0));
415 if ((stat(host, &statbuf) == 0) &&
416 (statbuf.st_mode & S_IFREG)) {
417 return (host);
418 }
419 }
420
421 pt = strrchr(temp, '/');
422 if (!pt++)
423 pt = temp;
424
425 basename = pt;
426
427 for (i = 0; srchp[nfp][i]; i++) {
428 (void) snprintf(host, sizeof (host), "%s/%s",
429 srchp[nfp][i], basename);
430 if ((stat(host, &statbuf) == 0) &&
431 (statbuf.st_mode & S_IFREG)) {
432 return (host);
433 }
434 }
435
436 /* check current directory as a last resort */
437 (void) snprintf(host, sizeof (host), "%s/%s", dname[nfp], basename);
438 if ((stat(host, &statbuf) == 0) && (statbuf.st_mode & S_IFREG))
439 return (host);
440
441 error(1);
442 logerr(gettext(MSG_SRCHSRCH), path);
443 return (NULL);
444 }
445
446 static void
dosearch(void)447 dosearch(void)
448 {
449 char temp[PATH_MAX], lookpath[PATH_MAX], *pt;
450 int n;
451
452 (void) fgets(temp, PATH_MAX, fp);
453 translate(temp, lookpath);
454
455 for (n = 0; srchp[nfp][n]; n++)
456 free(srchp[nfp][n]);
457
458 n = 0;
459 pt = strtok(lookpath, separ);
460 if (pt && *pt) {
461 do {
462 if (*pt != '/') {
463 /* make relative path an absolute directory */
464 (void) snprintf(temp, sizeof (temp),
465 "%s/%s", dname[nfp], pt);
466 pt = temp;
467 }
468 canonize(pt);
469 srchp[nfp][n++] = qstrdup(pt);
470 } while (pt = strtok(NULL, separ));
471 srchp[nfp][n] = NULL;
472 }
473 }
474
475 static void
dorsearch(void)476 dorsearch(void)
477 {
478 char temp[PATH_MAX], lookpath[PATH_MAX], *pt;
479 int n;
480
481 (void) fgets(temp, PATH_MAX, fp);
482 translate(temp, lookpath);
483
484 for (n = 0; rootp[nfp][n]; n++)
485 free(rootp[nfp][n]);
486
487 n = 0;
488 pt = strtok(lookpath, separ);
489 do {
490 if (*pt != '/') {
491 /* make relative path an absolute directory */
492 (void) snprintf(temp, sizeof (temp),
493 "%s/%s", dname[nfp], pt);
494 pt = temp;
495 }
496 canonize(pt);
497 rootp[nfp][n++] = qstrdup(pt);
498 } while (pt = strtok(NULL, separ));
499 rootp[nfp][n] = NULL;
500 }
501
502 /*
503 * This function reads the default mode, owner and group from the prototype
504 * file and makes that available.
505 */
506 static int
doattrib(void)507 doattrib(void)
508 {
509 char *pt, attrib[PATH_MAX], *mode_ptr, *owner_ptr, *group_ptr, *eol;
510 int mode;
511 char owner[ATRSIZ+1], group[ATRSIZ+1], attrib_save[(4*ATRSIZ)];
512
513 (void) fgets(attrib, PATH_MAX, fp);
514
515 (void) strlcpy(attrib_save, attrib, sizeof (attrib_save));
516
517 /*
518 * Now resolve any variables that may be present. Start on group and
519 * move backward since that keeps the resolved string from
520 * overwriting any of the other entries. This is required since
521 * mapvar() writes the resolved string over the string provided.
522 */
523 mode_ptr = strtok(attrib, " \t");
524 owner_ptr = strtok(NULL, " \t");
525 group_ptr = strtok(NULL, " \t\n");
526 eol = strtok(NULL, " \t\n");
527 if (strtok(NULL, " \t\n")) {
528 /* extra tokens on the line */
529 error(1);
530 logerr(gettext(MSG_GARBDEFLT), (eol) ? eol :
531 gettext("unreadable at end of line"));
532 return (1);
533 }
534
535 if (group_ptr && mapvar(1, group_ptr) == 0)
536 (void) strncpy(group, group_ptr, ATRSIZ);
537 else {
538 error(1);
539 logerr(gettext(MSG_GARBDEFLT), (attrib_save) ?
540 ((attrib_save[0]) ? attrib_save : gettext("none")) :
541 gettext("unreadable at group"));
542 return (1);
543 }
544
545 if (owner_ptr && mapvar(1, owner_ptr) == 0)
546 (void) strncpy(owner, owner_ptr, ATRSIZ);
547 else {
548 error(1);
549 logerr(gettext(MSG_GARBDEFLT), (attrib_save) ?
550 ((attrib_save[0]) ? attrib_save : gettext("none")) :
551 gettext("unreadable at owner"));
552 return (1);
553 }
554
555 /*
556 * For mode, don't use scanf, since we want to force an octal
557 * interpretation and need to limit the length of the owner and group
558 * specifications.
559 */
560 if (mode_ptr && mapvar(1, mode_ptr) == 0)
561 mode = strtol(mode_ptr, &pt, 8);
562 else {
563 error(1);
564 logerr(gettext(MSG_GARBDEFLT), (attrib_save) ?
565 ((attrib_save[0]) ? attrib_save : gettext("none")) :
566 gettext("unreadable at mode"));
567 return (1);
568 }
569
570 /* free any previous memory from qstrdup */
571 if (d_own[nfp])
572 free(d_own[nfp]);
573 if (d_grp[nfp])
574 free(d_grp[nfp]);
575
576 d_mod[nfp] = mode;
577 d_own[nfp] = qstrdup(owner);
578 d_grp[nfp] = qstrdup(group);
579
580 attrpreset(d_mod[nfp], d_own[nfp], d_grp[nfp]);
581
582 return (0);
583 }
584
585 static void
doinclude(void)586 doinclude(void)
587 {
588 char file[PATH_MAX];
589 char temp[PATH_MAX];
590
591 (void) fgets(temp, PATH_MAX, fp);
592
593 /*
594 * IMPORTANT NOTE: THE SIZE OF temp IS HARD CODED INTO THE
595 * FOLLOWING CALL TO fscanf -- YOU MUST CHANGE THIS LINE IF
596 * THE SIZE OF fscanf IS EVER CHANGED!!!
597 */
598 (void) sscanf(temp, "%1024s", file);
599
600 translate(file, temp);
601 canonize(temp);
602
603 if (*temp == '\0')
604 return;
605 else if (*temp != '/')
606 (void) snprintf(file, sizeof (file), "%s/%s", dname[nfp], temp);
607 else
608 (void) strlcpy(file, temp, sizeof (file));
609
610 canonize(file);
611 pushenv(file);
612 }
613
614 /*
615 * This does what mappath() does except that it does it for ALL variables
616 * using whitespace as a token separator. This is used to resolve search
617 * paths and assignment statements. It doesn't effect the build versus
618 * install decision made for pkgmap variables.
619 */
620 static void
translate(register char * pt,register char * copy)621 translate(register char *pt, register char *copy)
622 {
623 char *pt2, varname[MAX_PKG_PARAM_LENGTH];
624
625 token:
626 /* eat white space */
627 while (isspace(*pt))
628 pt++;
629 while (*pt && !isspace(*pt)) {
630 if (*pt == '$') {
631 pt2 = varname;
632 while (*++pt && !strchr("/= \t\n\r", *pt))
633 *pt2++ = *pt;
634 *pt2 = '\0';
635 if (pt2 = getenv(varname)) {
636 while (*pt2)
637 *copy++ = *pt2++;
638 }
639 } else
640 *copy++ = *pt++;
641 }
642 if (*pt) {
643 *copy++ = ' ';
644 goto token;
645 }
646 *copy = '\0';
647 }
648
649 static void
error(int flag)650 error(int flag)
651 {
652 static char *lasterr = NULL;
653
654 if (lasterr != proto[nfp]) {
655 lasterr = proto[nfp];
656 (void) fprintf(stderr, gettext("ERROR in %s:\n"), lasterr);
657 }
658 if (flag)
659 errflg++;
660 }
661
662 /* Set up defaults and change to the build directory. */
663 static void
pushenv(char * file)664 pushenv(char *file)
665 {
666 register char *pt;
667 static char topdir[PATH_MAX];
668
669 if ((nfp+1) >= NRECURS) {
670 error(1);
671 logerr(gettext(MSG_NRECURS), NRECURS);
672 logerr(gettext(MSG_IGNINCLUDE), file);
673 return;
674 }
675
676 if (strcmp(file, "-") == 0) {
677 fp = stdin;
678 } else if ((fp = fopen(file, "r")) == NULL) {
679 error(1);
680 logerr(gettext(MSG_RDINCLUDE), file, errno);
681 if (nfp >= 0) {
682 logerr(gettext(MSG_IGNINCLUDE), file);
683 fp = sfp[nfp];
684 return;
685 } else
686 quit(1);
687 }
688 sfp[++nfp] = fp;
689 srchp[nfp][0] = NULL;
690 rootp[nfp][0] = NULL;
691 d_mod[nfp] = (mode_t)(-1);
692 d_own[nfp] = NULL;
693 d_grp[nfp] = NULL;
694
695 if (!nfp) {
696 /* upper level proto file */
697 proto[nfp] = file;
698 if (file[0] == '/')
699 pt = strcpy(topdir, file);
700 else {
701 /* path is relative to the prototype file specified */
702 pt = getcwd(NULL, PATH_MAX);
703 if (pt == NULL) {
704 progerr(gettext(ERR_GETCWD), errno);
705 quit(99);
706 }
707 (void) snprintf(topdir, sizeof (topdir),
708 "%s/%s", pt, file);
709 }
710 if (pt = strrchr(topdir, '/'))
711 *pt = '\0'; /* should always happen */
712 if (topdir[0] == '\0')
713 (void) strlcpy(topdir, "/", sizeof (topdir));
714 dname[nfp] = topdir;
715 } else {
716 proto[nfp] = qstrdup(file);
717 dname[nfp] = qstrdup(file);
718 if (pt = strrchr(dname[nfp], '/'))
719 *pt = '\0';
720 else {
721 /* same directory as the last prototype */
722 free(dname[nfp]);
723 dname[nfp] = qstrdup(dname[nfp-1]);
724 return; /* no need to canonize() or chdir() */
725 }
726 }
727
728 canonize(dname[nfp]);
729
730 if (chdir(dname[nfp])) {
731 error(1);
732 logerr(gettext(MSG_CHDIR), dname[nfp]);
733 if (!nfp)
734 quit(1); /* must be able to cd to upper level */
735 logerr(gettext(MSG_IGNINCLUDE), proto[nfp]);
736 (void) popenv();
737 }
738 }
739
740 /* Restore defaults and return to the prior directory. */
741 static int
popenv(void)742 popenv(void)
743 {
744 int i;
745
746 (void) fclose(fp);
747 if (nfp) {
748 if (proto[nfp])
749 free(proto[nfp]);
750 if (dname[nfp])
751 free(dname[nfp]);
752 for (i = 0; srchp[nfp][i]; i++)
753 free(srchp[nfp][i]);
754 for (i = 0; rootp[nfp][i]; i++)
755 free(rootp[nfp][i]);
756 if (d_own[nfp])
757 free(d_own[nfp]);
758 if (d_grp[nfp])
759 free(d_grp[nfp]);
760
761 fp = sfp[--nfp];
762
763 if (chdir(dname[nfp])) {
764 error(1);
765 logerr(gettext(MSG_CHDIR), dname[nfp]);
766 logerr(gettext(MSG_INCOMPLETE), proto[nfp]);
767 return (popenv());
768 }
769 return (1);
770 }
771 return (0);
772 }
773
774 /*
775 * If this parameter isn't already in place, put it into the local
776 * environment. This means that command line directives override prototype
777 * file directives.
778 */
779 static void
lputenv(char * s)780 lputenv(char *s)
781 {
782 char *pt;
783 int i;
784
785 pt = strchr(s, '=');
786 if (!pt)
787 return;
788
789 *pt = '\0';
790 for (i = 0; i < nrdonly; i++) {
791 if (strcmp(rdonly[i], s) == 0) {
792 *pt = '=';
793 return;
794 }
795 }
796 *pt = '=';
797
798 if (putenv(qstrdup(s))) {
799 progerr(gettext(ERR_ENVBUILD), errno);
800 quit(99);
801 }
802 }
803
804 static char *
srchroot(char * path,char * copy)805 srchroot(char *path, char *copy)
806 {
807 struct stat statbuf;
808 int i;
809
810 i = 0;
811 root = rootlist[i++];
812 do {
813 /* convert with root & basedir info */
814 cvtpath(path, copy);
815 /* make it pretty again */
816 canonize(copy);
817
818 if (stat(copy, &statbuf) || !(statbuf.st_mode & S_IFREG)) {
819 root = rootlist[i++];
820 continue; /* host source must be a regular file */
821 }
822 return (copy);
823 } while (root != NULL);
824 error(1);
825 logerr(gettext(MSG_SRCHROOT), path);
826 return (NULL);
827 }
828