usr/src/cmd/svr4pkg/pkgmk/mkpkgmap.c

   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
 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 *
 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
 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
 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
 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
 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 == NULL)
 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
 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
 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
 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
 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
 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 *
 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 }