xref: /illumos-gate/usr/src/cmd/svr4pkg/pkgmk/main.c (revision c57b775050136774ef88b195e5833b3f9b86561b)
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
main(int argc,char * argv[])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
trap(int n)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
outvol(struct cfent ** eptlist,unsigned int eptnum,int part,int nparts)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
ckmissing(char * path,char type)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
slinkf(char * from,char * to)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
usage(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
valid_zone_attr(struct cfent ** eptlist)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