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 2010 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 <signal.h> 34 #include <errno.h> 35 #include <malloc.h> 36 #include <stdlib.h> 37 #include <unistd.h> 38 #include <time.h> 39 #include <fcntl.h> 40 #include <sys/types.h> 41 #include <sys/stat.h> 42 #include <sys/param.h> 43 #include <ctype.h> 44 #include <sys/mman.h> 45 #include <sys/sysmacros.h> 46 #include <strings.h> 47 #include <pkgstrct.h> 48 #include <pkgdev.h> 49 #include <pkginfo.h> 50 #include <pkglocs.h> 51 #include <locale.h> 52 #include <libintl.h> 53 #include <sys/statvfs.h> 54 #include <sys/utsname.h> 55 #include <instzones_api.h> 56 #include <pkglib.h> 57 #include <libadm.h> 58 #include <libinst.h> 59 60 extern char **environ, *pkgdir; 61 62 /* mkpkgmap.c */ 63 extern int mkpkgmap(char *outfile, char *protofile, char **cmdparam); 64 /* splpkgmap.c */ 65 extern int splpkgmap(struct cfent **eptlist, unsigned int eptnum, 66 char *order[], ulong_t bsize, ulong_t frsize, fsblkcnt_t *plimit, 67 fsfilcnt_t *pilimit, fsblkcnt_t *pllimit); 68 /* scriptvfy.c */ 69 extern int checkscripts(char *inst_dir, int silent); 70 71 /* libpkg/gpkgmap.c */ 72 extern void setmapmode(int mode_no); 73 74 static boolean_t valid_zone_attr(struct cfent **eptlist); 75 76 #define MALSIZ 16 77 #define NROOT 8 78 #define SPOOLDEV "spool" 79 80 #define MSG_PROTOTYPE "## Building pkgmap from package prototype file.\n" 81 #define MSG_PKGINFO "## Processing pkginfo file.\n" 82 #define MSG_VOLUMIZE "## Attempting to volumize %d entries in pkgmap.\n" 83 #define MSG_PACKAGE1 "## Packaging one part.\n" 84 #define MSG_PACKAGEM "## Packaging %d parts.\n" 85 #define MSG_VALSCRIPTS "## Validating control scripts.\n" 86 87 /* Other problems */ 88 #define ERR_MEMORY "memory allocation failure, errno=%d" 89 #define ERR_NROOT "too many paths listed with -r option, limit is %d" 90 #define ERR_PKGINST "invalid package instance identifier <%s>" 91 #define ERR_PKGABRV "invalid package abbreviation <%s>" 92 #define ERR_BADDEV "unknown or invalid device specified <%s>" 93 #define ERR_TEMP "unable to obtain temporary file resources, errno=%d" 94 #define ERR_DSTREAM "invalid device specified (datastream) <%s>" 95 #define ERR_SPLIT "unable to volumize package" 96 #define ERR_MKDIR "unable to make directory <%s>" 97 #define ERR_SYMLINK "unable to create symbolic link for <%s>" 98 #define ERR_OVERWRITE "must use -o option to overwrite <%s>" 99 #define ERR_UMOUNT "unable to unmount device <%s>" 100 #define ERR_NOPKGINFO "required pkginfo file is not specified in prototype " \ 101 "file" 102 #define ERR_RDPKGINFO "unable to process pkginfo file <%s>" 103 #define ERR_PROTOTYPE "unable to locate prototype file" 104 #define ERR_STATVFS "unable to stat filesystem <%s>" 105 #define ERR_WHATVFS "unable to determine or access output filesystem for " \ 106 "device <%s>" 107 #define ERR_DEVICE "unable to find info for device <%s>" 108 #define ERR_BUILD "unable to build pkgmap from prototype file" 109 #define ERR_ONEVOL "other packages found - package must fit on a single " \ 110 "volume" 111 #define ERR_NOPARAM "parameter <%s> is not defined in <%s>" 112 #define ERR_PKGMTCH "PKG parameter <%s> does not match instance <%s>" 113 #define ERR_NO_PKG_INFOFILE "unable to open pkginfo file <%s>: %s" 114 #define ERR_ALLZONES_AND_THISZONE "The package <%s> has <%s> = true " \ 115 "and <%s> = true: the package may " \ 116 "set either parameter to true, but " \ 117 "may not set both parameters to " \ 118 "true. NOTE: if the package " \ 119 "contains a request script, it is " \ 120 "treated as though it has " \ 121 "<SUNW_PKG_THISZONE> = true" 122 #define ERR_NO_ALLZONES_AND_HOLLOW "The package <%s> has <%s> = false " \ 123 "and <%s> = true: a hollow package " \ 124 "must also be set to install in all " \ 125 "zones" 126 #define ERR_PKGINFO_INVALID_OPTION_COMB "Invalid combinations of zone " \ 127 "parameters in pkginfo file" 128 129 #define ERR_USAGE "usage: %s [options] [VAR=value [VAR=value]] " \ 130 "[pkginst]\n" \ 131 " where options may include:\n" \ 132 "\t-o\n" \ 133 "\t-a arch\n" \ 134 "\t-v version\n" \ 135 "\t-p pstamp\n" \ 136 "\t-l limit\n" \ 137 "\t-r rootpath\n" \ 138 "\t-b basedir\n" \ 139 "\t-d device\n" \ 140 "\t-f protofile\n" 141 #define WRN_MISSINGDIR "WARNING: missing directory entry for <%s>" 142 #define WRN_SETPARAM "WARNING: parameter <%s> set to \"%s\"" 143 #define WRN_CLASSES "WARNING: unreferenced class <%s> in prototype file" 144 145 #define LINK 1 146 147 struct pkgdev pkgdev; /* holds info about the installation device */ 148 int started; 149 char pkgloc[PATH_MAX]; 150 char *basedir; 151 char *root; 152 char *rootlist[NROOT]; 153 char *t_pkgmap; 154 char *t_pkginfo; 155 156 static struct cfent *svept; 157 static char *protofile, 158 *device; 159 static fsblkcnt_t limit = 0; 160 static fsblkcnt_t llimit = 0; 161 static fsfilcnt_t ilimit = 0; 162 static int overwrite, 163 nflag, 164 sflag; 165 static void ckmissing(char *path, char type); 166 static void outvol(struct cfent **eptlist, unsigned int eptnum, int part, 167 int nparts); 168 static void trap(int n); 169 static void usage(void); 170 171 static int slinkf(char *from, char *to); 172 173 int 174 main(int argc, char *argv[]) 175 { 176 struct utsname utsbuf; 177 struct statvfs64 svfsb; 178 struct cfent **eptlist; 179 FILE *fp; 180 VFP_T *vfp; 181 int c, n, found; 182 int part, nparts, npkgs, objects; 183 char buf[MAX_PKG_PARAM_LENGTH]; 184 char temp[MAX_PKG_PARAM_LENGTH]; 185 char param[MAX_PKG_PARAM_LENGTH]; 186 char *pt, *value, *pkginst, *tmpdir, *abi_sym_ptr, 187 **cmdparam; 188 char *pkgname; 189 char *pkgvers; 190 char *pkgarch; 191 char *pkgcat; 192 void (*func)(); 193 time_t clock; 194 ulong_t bsize = 0; 195 ulong_t frsize = 0; 196 struct cl_attr **allclass = NULL; 197 struct cl_attr **order; 198 unsigned int eptnum, i; 199 200 /* initialize locale environment */ 201 202 (void) setlocale(LC_ALL, ""); 203 204 #if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */ 205 #define TEXT_DOMAIN "SYS_TEST" 206 #endif 207 (void) textdomain(TEXT_DOMAIN); 208 209 /* initialize program name */ 210 211 (void) set_prog_name(argv[0]); 212 213 /* tell spmi zones interface how to access package output functions */ 214 215 z_set_output_functions(echo, echoDebug, progerr); 216 217 func = sigset(SIGINT, trap); 218 if (func != SIG_DFL) 219 func = sigset(SIGINT, func); 220 func = sigset(SIGHUP, trap); 221 setmapmode(MAPBUILD); /* variable binding */ 222 if (func != SIG_DFL) 223 func = sigset(SIGHUP, func); 224 225 environ = NULL; 226 while ((c = getopt(argc, argv, "osnp:l:r:b:d:f:a:v:?")) != EOF) { 227 switch (c) { 228 case 'n': 229 nflag++; 230 break; 231 232 case 's': 233 sflag++; 234 break; 235 236 case 'o': 237 overwrite++; 238 break; 239 240 case 'p': 241 putparam("PSTAMP", optarg); 242 break; 243 244 case 'l': 245 llimit = strtoull(optarg, NULL, 10); 246 break; 247 248 case 'r': 249 pt = strtok(optarg, " \t\n, "); 250 n = 0; 251 do { 252 rootlist[n++] = flex_device(pt, 0); 253 if (n >= NROOT) { 254 progerr(gettext(ERR_NROOT), NROOT); 255 quit(1); 256 } 257 } while (pt = strtok(NULL, " \t\n, ")); 258 rootlist[n] = NULL; 259 break; 260 261 case 'b': 262 basedir = optarg; 263 break; 264 265 case 'f': 266 protofile = optarg; 267 break; 268 269 case 'd': 270 device = flex_device(optarg, 1); 271 break; 272 273 case 'a': 274 putparam("ARCH", optarg); 275 break; 276 277 case 'v': 278 putparam("VERSION", optarg); 279 break; 280 281 default: 282 usage(); 283 /*NOTREACHED*/ 284 /* 285 * Although usage() calls a noreturn function, 286 * needed to add return (1); so that main() would 287 * pass compilation checks. The statement below 288 * should never be executed. 289 */ 290 return (1); 291 } 292 } 293 294 /* 295 * Store command line variable assignments for later 296 * incorporation into the environment. 297 */ 298 cmdparam = &argv[optind]; 299 300 /* Skip past equates. */ 301 while (argv[optind] && strchr(argv[optind], '=')) 302 optind++; 303 304 /* Confirm that the instance name is valid */ 305 if ((pkginst = argv[optind]) != NULL) { 306 if (pkgnmchk(pkginst, "all", 0)) { 307 progerr(gettext(ERR_PKGINST), pkginst); 308 quit(1); 309 } 310 argv[optind++] = NULL; 311 } 312 if (optind != argc) 313 usage(); 314 315 tmpdir = getenv("TMPDIR"); 316 if (tmpdir == NULL) 317 tmpdir = P_tmpdir; 318 319 /* bug id 4244631, not ABI compliant */ 320 abi_sym_ptr = getenv("PKG_NONABI_SYMLINKS"); 321 if (abi_sym_ptr && (strncasecmp(abi_sym_ptr, "TRUE", 4) == 0)) { 322 set_nonABI_symlinks(); 323 } 324 325 if (device == NULL) { 326 device = devattr(SPOOLDEV, "pathname"); 327 if (device == NULL) { 328 progerr(gettext(ERR_DEVICE), SPOOLDEV); 329 exit(99); 330 } 331 } 332 333 if (protofile == NULL) { 334 if (access("prototype", 0) == 0) 335 protofile = "prototype"; 336 else if (access("Prototype", 0) == 0) 337 protofile = "Prototype"; 338 else { 339 progerr(gettext(ERR_PROTOTYPE)); 340 quit(1); 341 } 342 } 343 344 if (devtype(device, &pkgdev)) { 345 progerr(gettext(ERR_BADDEV), device); 346 quit(1); 347 } 348 if (pkgdev.norewind) { 349 /* initialize datastream */ 350 progerr(gettext(ERR_DSTREAM), device); 351 quit(1); 352 } 353 if (pkgdev.mount) { 354 if (n = pkgmount(&pkgdev, NULL, 0, 0, 1)) 355 quit(n); 356 } 357 358 /* 359 * convert prototype file to a pkgmap, while locating 360 * package objects in the current environment 361 */ 362 t_pkgmap = tempnam(tmpdir, "tmpmap"); 363 if (t_pkgmap == NULL) { 364 progerr(gettext(ERR_TEMP), errno); 365 exit(99); 366 } 367 368 (void) fprintf(stderr, gettext(MSG_PROTOTYPE)); 369 if (n = mkpkgmap(t_pkgmap, protofile, cmdparam)) { 370 progerr(gettext(ERR_BUILD)); 371 quit(1); 372 } 373 374 setmapmode(MAPNONE); /* All appropriate variables are now bound */ 375 376 if (vfpOpen(&vfp, t_pkgmap, "r", VFP_NEEDNOW) != 0) { 377 progerr(gettext(ERR_TEMP), errno); 378 quit(99); 379 } 380 381 eptlist = procmap(vfp, 0, NULL); 382 383 if (eptlist == NULL) { 384 quit(1); 385 } 386 387 (void) vfpClose(&vfp); 388 389 /* Validate the zone attributes in pkginfo, before creation */ 390 if (!valid_zone_attr(eptlist)) { 391 progerr(ERR_PKGINFO_INVALID_OPTION_COMB); 392 quit(1); 393 } 394 395 (void) fprintf(stderr, gettext(MSG_PKGINFO)); 396 pt = NULL; 397 for (i = 0; eptlist[i]; i++) { 398 ckmissing(eptlist[i]->path, eptlist[i]->ftype); 399 if (eptlist[i]->ftype != 'i') 400 continue; 401 if (strcmp(eptlist[i]->path, "pkginfo") == 0) 402 svept = eptlist[i]; 403 } 404 if (svept == NULL) { 405 progerr(gettext(ERR_NOPKGINFO)); 406 quit(99); 407 } 408 eptnum = i; 409 410 /* 411 * process all parameters from the pkginfo file 412 * and place them in the execution environment 413 */ 414 415 if ((fp = fopen(svept->ainfo.local, "r")) == NULL) { 416 progerr(gettext(ERR_RDPKGINFO), svept->ainfo.local); 417 quit(99); 418 } 419 param[0] = '\0'; 420 while (value = fpkgparam(fp, param)) { 421 if (getenv(param) == NULL) 422 putparam(param, value); 423 free((void *)value); 424 param[0] = '\0'; 425 } 426 (void) fclose(fp); 427 428 /* add command line variables */ 429 while (*cmdparam && (value = strchr(*cmdparam, '=')) != NULL) { 430 *value = '\0'; /* terminate the parameter */ 431 value++; /* value is now the value (not '=') */ 432 putparam(*cmdparam++, value); /* store it in environ */ 433 } 434 435 /* make sure parameters are valid */ 436 (void) time(&clock); 437 if (pt = getenv("PKG")) { 438 if (pkgnmchk(pt, NULL, 0) || strchr(pt, '.')) { 439 progerr(gettext(ERR_PKGABRV), pt); 440 quit(1); 441 } 442 if (pkginst == NULL) 443 pkginst = pt; 444 } else { 445 progerr(gettext(ERR_NOPARAM), "PKG", svept->path); 446 quit(1); 447 } 448 /* 449 * verify consistency between PKG parameter and pkginst 450 */ 451 (void) snprintf(param, sizeof (param), "%s.*", pt); 452 if (pkgnmchk(pkginst, param, 0)) { 453 progerr(gettext(ERR_PKGMTCH), pt, pkginst); 454 quit(1); 455 } 456 457 if ((pkgname = getenv("NAME")) == NULL) { 458 progerr(gettext(ERR_NOPARAM), "NAME", svept->path); 459 quit(1); 460 } 461 if (ckparam("NAME", pkgname)) 462 quit(1); 463 if ((pkgvers = getenv("VERSION")) == NULL) { 464 /* XXX - I18n */ 465 /* LINTED do not use cftime(); use strftime instead */ 466 (void) cftime(buf, "\045m/\045d/\045Y", &clock); 467 (void) snprintf(temp, sizeof (temp), 468 gettext("Dev Release %s"), buf); 469 putparam("VERSION", temp); 470 pkgvers = getenv("VERSION"); 471 logerr(gettext(WRN_SETPARAM), "VERSION", temp); 472 } 473 if (ckparam("VERSION", pkgvers)) 474 quit(1); 475 if ((pkgarch = getenv("ARCH")) == NULL) { 476 (void) uname(&utsbuf); 477 putparam("ARCH", utsbuf.machine); 478 pkgarch = getenv("ARCH"); 479 logerr(gettext(WRN_SETPARAM), "ARCH", utsbuf.machine); 480 } 481 if (ckparam("ARCH", pkgarch)) 482 quit(1); 483 if (getenv("PSTAMP") == NULL) { 484 /* use octal value of '%' to fight sccs expansion */ 485 /* XXX - I18n */ 486 /* LINTED do not use cftime(); use strftime instead */ 487 (void) cftime(buf, "\045Y\045m\045d\045H\045M\045S", &clock); 488 (void) uname(&utsbuf); 489 (void) snprintf(temp, sizeof (temp), "%s%s", 490 utsbuf.nodename, buf); 491 putparam("PSTAMP", temp); 492 logerr(gettext(WRN_SETPARAM), "PSTAMP", temp); 493 } 494 if ((pkgcat = getenv("CATEGORY")) == NULL) { 495 progerr(gettext(ERR_NOPARAM), "CATEGORY", svept->path); 496 quit(1); 497 } 498 if (ckparam("CATEGORY", pkgcat)) 499 quit(1); 500 501 /* 502 * warn user of classes listed in package which do 503 * not appear in CLASSES variable in pkginfo file 504 */ 505 objects = 0; 506 for (i = 0; eptlist[i]; i++) { 507 if (eptlist[i]->ftype != 'i') { 508 objects++; 509 addlist(&allclass, eptlist[i]->pkg_class); 510 } 511 } 512 513 if ((pt = getenv("CLASSES")) == NULL) { 514 if (allclass && *allclass) { 515 cl_setl(allclass); 516 cl_putl("CLASSES", allclass); 517 logerr(gettext(WRN_SETPARAM), "CLASSES", 518 getenv("CLASSES")); 519 } 520 } else { 521 cl_sets(qstrdup(pt)); 522 if (allclass && *allclass) { 523 for (i = 0; allclass[i]; i++) { 524 found = 0; 525 if (cl_idx(allclass[i]->name) != -1) { 526 found++; 527 break; 528 } 529 if (!found) { 530 logerr(gettext(WRN_CLASSES), 531 (char *)allclass[i]); 532 } 533 } 534 } 535 } 536 537 (void) fprintf(stderr, gettext(MSG_VOLUMIZE), objects); 538 order = (struct cl_attr **)0; 539 if (pt = getenv("ORDER")) { 540 pt = qstrdup(pt); 541 (void) setlist(&order, pt); 542 cl_putl("ORDER", order); 543 } 544 545 /* stat the intended output filesystem to get blocking information */ 546 if (pkgdev.dirname == NULL) { 547 progerr(gettext(ERR_WHATVFS), device); 548 quit(99); 549 } 550 if (statvfs64(pkgdev.dirname, &svfsb)) { 551 progerr(gettext(ERR_STATVFS), pkgdev.dirname); 552 quit(99); 553 } 554 555 if (bsize == 0) { 556 bsize = svfsb.f_bsize; 557 } 558 if (frsize == 0) { 559 frsize = svfsb.f_frsize; 560 } 561 562 if (limit == 0) 563 /* 564 * bavail is in terms of fragment size blocks - change 565 * to 512 byte blocks 566 */ 567 limit = (fsblkcnt_t)(((fsblkcnt_t)frsize > 0) ? 568 howmany(frsize, DEV_BSIZE) : 569 howmany(bsize, DEV_BSIZE)) * svfsb.f_bavail; 570 571 if (ilimit == 0) { 572 ilimit = (svfsb.f_favail > 0) ? 573 svfsb.f_favail : svfsb.f_ffree; 574 } 575 576 nparts = splpkgmap(eptlist, eptnum, (char **)order, bsize, frsize, 577 &limit, &ilimit, &llimit); 578 579 if (nparts <= 0) { 580 progerr(gettext(ERR_SPLIT)); 581 quit(1); 582 } 583 584 if (nflag) { 585 for (i = 0; eptlist[i]; i++) 586 (void) ppkgmap(eptlist[i], stdout); 587 exit(0); 588 /*NOTREACHED*/ 589 } 590 591 (void) snprintf(pkgloc, sizeof (pkgloc), "%s/%s", 592 pkgdev.dirname, pkginst); 593 if (!isdir(pkgloc) && !overwrite) { 594 progerr(gettext(ERR_OVERWRITE), pkgloc); 595 quit(1); 596 } 597 598 /* output all environment install parameters */ 599 t_pkginfo = tempnam(tmpdir, "pkginfo"); 600 if ((fp = fopen(t_pkginfo, "w")) == NULL) { 601 progerr(gettext(ERR_TEMP), errno); 602 exit(99); 603 } 604 for (i = 0; environ[i]; i++) { 605 if (isupper(*environ[i])) { 606 (void) fputs(environ[i], fp); 607 (void) fputc('\n', fp); 608 } 609 } 610 (void) fclose(fp); 611 612 started++; 613 (void) rrmdir(pkgloc); 614 if (mkdir(pkgloc, 0755)) { 615 progerr(gettext(ERR_MKDIR), pkgloc); 616 quit(1); 617 } 618 619 /* determine how many packages already reside on the medium */ 620 pkgdir = pkgdev.dirname; 621 npkgs = 0; 622 while (pt = fpkginst("all", NULL, NULL)) 623 npkgs++; 624 (void) fpkginst(NULL); /* free resource usage */ 625 626 if (nparts > 1) { 627 if (pkgdev.mount && npkgs) { 628 progerr(gettext(ERR_ONEVOL)); 629 quit(1); 630 } 631 } 632 633 /* 634 * update pkgmap entry for pkginfo file, since it may 635 * have changed due to command line or failure to 636 * specify all neccessary parameters 637 */ 638 for (i = 0; eptlist[i]; i++) { 639 if (eptlist[i]->ftype != 'i') 640 continue; 641 if (strcmp(eptlist[i]->path, "pkginfo") == 0) { 642 svept = eptlist[i]; 643 svept->ftype = '?'; 644 svept->ainfo.local = t_pkginfo; 645 (void) cverify(0, &svept->ftype, t_pkginfo, 646 &svept->cinfo, 1); 647 svept->ftype = 'i'; 648 break; 649 } 650 } 651 652 if (nparts > 1) 653 (void) fprintf(stderr, gettext(MSG_PACKAGEM), nparts); 654 else 655 (void) fprintf(stderr, gettext(MSG_PACKAGE1)); 656 657 for (part = 1; part <= nparts; part++) { 658 if ((part > 1) && pkgdev.mount) { 659 if (pkgumount(&pkgdev)) { 660 progerr(gettext(ERR_UMOUNT), pkgdev.mount); 661 quit(99); 662 } 663 if (n = pkgmount(&pkgdev, NULL, part, nparts, 1)) 664 quit(n); 665 (void) rrmdir(pkgloc); 666 if (mkdir(pkgloc, 0555)) { 667 progerr(gettext(ERR_MKDIR), pkgloc); 668 quit(99); 669 } 670 } 671 outvol(eptlist, eptnum, part, nparts); 672 673 /* Validate (as much as possible) the control scripts. */ 674 if (part == 1) { 675 char inst_path[PATH_MAX]; 676 677 (void) fprintf(stderr, gettext(MSG_VALSCRIPTS)); 678 (void) snprintf(inst_path, sizeof (inst_path), 679 "%s/install", pkgloc); 680 checkscripts(inst_path, 0); 681 } 682 } 683 684 quit(0); 685 /* LINTED: no return */ 686 } 687 688 static void 689 trap(int n) 690 { 691 (void) signal(SIGINT, SIG_IGN); 692 (void) signal(SIGHUP, SIG_IGN); 693 694 if (n == SIGINT) 695 quit(3); 696 else { 697 (void) fprintf(stderr, gettext("%s terminated (signal %d).\n"), 698 get_prog_name(), n); 699 quit(99); 700 } 701 } 702 703 static void 704 outvol(struct cfent **eptlist, unsigned int eptnum, int part, int nparts) 705 { 706 FILE *fp; 707 char *svpt, *path, temp[PATH_MAX]; 708 unsigned int i; 709 710 711 if (nparts > 1) 712 (void) fprintf(stderr, gettext(" -- part %2d:\n"), part); 713 if (part == 1) { 714 /* re-write pkgmap, but exclude local pathnames */ 715 (void) snprintf(temp, sizeof (temp), "%s/pkgmap", pkgloc); 716 if ((fp = fopen(temp, "w")) == NULL) { 717 progerr(gettext(ERR_TEMP), errno); 718 quit(99); 719 } 720 (void) fprintf(fp, ": %d %llu\n", nparts, limit); 721 for (i = 0; eptlist[i]; i++) { 722 svpt = eptlist[i]->ainfo.local; 723 if (!strchr("sl", eptlist[i]->ftype)) 724 eptlist[i]->ainfo.local = NULL; 725 if (ppkgmap(eptlist[i], fp)) { 726 progerr(gettext(ERR_TEMP), errno); 727 quit(99); 728 } 729 eptlist[i]->ainfo.local = svpt; 730 } 731 (void) fclose(fp); 732 (void) fprintf(stderr, "%s\n", temp); 733 } 734 735 (void) snprintf(temp, sizeof (temp), "%s/pkginfo", pkgloc); 736 if (copyf(svept->ainfo.local, temp, svept->cinfo.modtime)) 737 quit(1); 738 (void) fprintf(stderr, "%s\n", temp); 739 740 for (i = 0; i < eptnum; i++) { 741 if (eptlist[i]->volno != part) 742 continue; 743 if (strchr("dxslcbp", eptlist[i]->ftype)) 744 continue; 745 if (eptlist[i]->ftype == 'i') { 746 if (eptlist[i] == svept) 747 continue; /* don't copy pkginfo file */ 748 (void) snprintf(temp, sizeof (temp), 749 "%s/install/%s", pkgloc, 750 eptlist[i]->path); 751 path = temp; 752 } else 753 path = srcpath(pkgloc, eptlist[i]->path, part, nparts); 754 if (sflag) { 755 if (slinkf(eptlist[i]->ainfo.local, path)) 756 quit(1); 757 } else if (copyf(eptlist[i]->ainfo.local, path, 758 eptlist[i]->cinfo.modtime)) { 759 quit(1); 760 } 761 762 /* 763 * If the package file attributes can be sync'd up with 764 * the pkgmap, we fix the attributes here. 765 */ 766 if (*(eptlist[i]->ainfo.owner) != '$' && 767 *(eptlist[i]->ainfo.group) != '$') { 768 /* Clear dangerous bits. */ 769 eptlist[i]->ainfo.mode= 770 (eptlist[i]->ainfo.mode & S_IAMB); 771 /* 772 * Make sure it can be read by the world and written 773 * by the owner. 774 */ 775 eptlist[i]->ainfo.mode |= 0644; 776 if (!strchr("in", eptlist[i]->ftype)) { 777 /* Set the safe attributes. */ 778 averify(1, &(eptlist[i]->ftype), 779 path, &(eptlist[i]->ainfo)); 780 } 781 } 782 783 (void) fprintf(stderr, "%s\n", path); 784 } 785 } 786 787 static void 788 ckmissing(char *path, char type) 789 { 790 static char **dir; 791 static int ndir; 792 char *pt; 793 int i, found; 794 795 if (dir == NULL) { 796 dir = (char **)calloc(MALSIZ, sizeof (char *)); 797 if (dir == NULL) { 798 progerr(gettext(ERR_MEMORY), errno); 799 quit(99); 800 } 801 } 802 803 if (strchr("dx", type)) { 804 dir[ndir] = path; 805 if ((++ndir % MALSIZ) == 0) { 806 dir = (char **)realloc((void *)dir, 807 (ndir+MALSIZ)*sizeof (char *)); 808 if (dir == NULL) { 809 progerr(gettext(ERR_MEMORY), errno); 810 quit(99); 811 } 812 } 813 dir[ndir] = (char *)NULL; 814 } 815 816 pt = path; 817 if (*pt == '/') 818 pt++; 819 while (pt = strchr(pt, '/')) { 820 *pt = '\0'; 821 found = 0; 822 for (i = 0; i < ndir; i++) { 823 if (strcmp(path, dir[i]) == 0) { 824 found++; 825 break; 826 } 827 } 828 if (!found) { 829 logerr(gettext(WRN_MISSINGDIR), path); 830 ckmissing(qstrdup(path), 'd'); 831 } 832 *pt++ = '/'; 833 } 834 } 835 836 static int 837 slinkf(char *from, char *to) 838 { 839 char *pt; 840 841 pt = to; 842 while (pt = strchr(pt+1, '/')) { 843 *pt = '\0'; 844 if (isdir(to) && mkdir(to, 0755)) { 845 progerr(gettext(ERR_MKDIR), to); 846 *pt = '/'; 847 return (-1); 848 } 849 *pt = '/'; 850 } 851 if (symlink(from, to)) { 852 progerr(gettext(ERR_SYMLINK), to); 853 return (-1); 854 } 855 return (0); 856 } 857 858 static void 859 usage(void) 860 { 861 (void) fprintf(stderr, gettext(ERR_USAGE), get_prog_name()); 862 exit(1); 863 /*NOTREACHED*/ 864 } 865 866 /* 867 * valid_zone_attr: Validates the zone attributes specified in 868 * pkginfo file for this package. The package 869 * can not be created with certain combinations 870 * of the attributes. 871 */ 872 static boolean_t 873 valid_zone_attr(struct cfent **eptlist) 874 { 875 FILE *pkginfoFP; 876 boolean_t all_zones; /* pkg is "all zones" only */ 877 boolean_t is_hollow; /* pkg is "hollow" */ 878 boolean_t this_zone; /* pkg is "this zone" only */ 879 char pkginfoPath[PATH_MAX]; /* pkginfo file path */ 880 char *pkgInst; 881 int i; 882 883 /* Path to pkginfo file within the package to be installed */ 884 885 this_zone = B_FALSE; 886 for (i = 0; eptlist[i]; i++) { 887 if (eptlist[i]->ftype != 'i') 888 continue; 889 if (strcmp(eptlist[i]->path, "pkginfo") == 0) 890 (void) strcpy(pkginfoPath, eptlist[i]->ainfo.local); 891 892 /* 893 * Check to see if this package has a request script. If this 894 * package does have a request script, then mark the package 895 * for installation in this zone only. Any package with a 896 * request script cannot be installed outside of the zone the 897 * pkgadd command is being run in, nor can such a package be 898 * installed as part of a new zone install. A new zone install 899 * must be non-interactive, which is required by all packages 900 * integrated into the Solaris WOS. 901 * If request file is set in prototype, then this_zone is TRUE. 902 */ 903 if (strcmp(eptlist[i]->path, "request") == 0) 904 this_zone = B_TRUE; 905 } 906 907 /* Gather information from the pkginfo file */ 908 909 pkginfoFP = fopen(pkginfoPath, "r"); 910 911 if (pkginfoFP == NULL) { 912 progerr(ERR_NO_PKG_INFOFILE, pkginfoPath, strerror(errno)); 913 return (B_FALSE); 914 } 915 916 if ((pkgInst = fpkgparam(pkginfoFP, "PKG")) == NULL) { 917 progerr(gettext(ERR_NOPARAM), "PKG", pkginfoPath); 918 return (B_FALSE); 919 } 920 921 922 /* Determine "HOLLOW" setting for this package */ 923 is_hollow = pkginfoParamTruth(pkginfoFP, PKG_HOLLOW_VARIABLE, 924 "true", B_FALSE); 925 926 /* Determine "ALLZONES" setting for this package */ 927 all_zones = pkginfoParamTruth(pkginfoFP, PKG_ALLZONES_VARIABLE, 928 "true", B_FALSE); 929 930 /* Determine "THISZONE" setting for this package, if no request file */ 931 if (!this_zone) 932 this_zone = pkginfoParamTruth(pkginfoFP, PKG_THISZONE_VARIABLE, 933 "true", B_FALSE); 934 935 /* Close pkginfo file */ 936 (void) fclose(pkginfoFP); 937 938 /* 939 * Validate zone attributes based on information gathered, 940 * and validate the three SUNW_PKG_ options: 941 * 942 * -----------------------------|---------------| 943 * <ALLZONES><HOLLOW><THISZONE> | If Allowed | 944 * ----1------------------------|---------------| 945 * F F F | OK | 946 * F F T | OK | 947 * F T * | NO | 948 * ----2------------------------|---------------| 949 * T F F | OK | 950 * T T F | OK | 951 * T * T | NO | 952 * -----------------------------|---------------| 953 */ 954 955 /* pkg "all zones" && "this zone" (#2) */ 956 957 if (all_zones && this_zone) { 958 progerr(ERR_ALLZONES_AND_THISZONE, pkgInst, 959 PKG_ALLZONES_VARIABLE, PKG_THISZONE_VARIABLE); 960 return (B_FALSE); 961 } 962 963 /* pkg "!all zones" && "hollow" (#1) */ 964 965 if ((!all_zones) && is_hollow) { 966 progerr(ERR_NO_ALLZONES_AND_HOLLOW, pkgInst, 967 PKG_ALLZONES_VARIABLE, PKG_HOLLOW_VARIABLE); 968 return (B_FALSE); 969 } 970 971 return (B_TRUE); 972 } 973