?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
9765 pkgadd has no Z option
[unleashed.git] / usr / src / cmd / svr4pkg / pkgadd / main.c
blob4f05b2831846710a57c62f926809280da8868418
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 (c) 2018 Peter Tribble.
24 */
25
26 /*
27 * Copyright (c) 1989, 2010, Oracle and/or its affiliates. All rights reserved.
28 */
29
30 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
31 /* All Rights Reserved */
32
33
34 /*
35 * Program: pkgadd / pkgask
36 *
37 * Function: public command and private utility functions that
38 * implement the package add and package ask operations.
39 *
40 */
41
42 /*
43 * System includes
44 */
45
46 #include <stdio.h>
47 #include <limits.h>
48 #include <stdlib.h>
49 #include <unistd.h>
50 #include <string.h>
51 #include <fcntl.h>
52 #include <sys/types.h>
53 #include <sys/stat.h>
54 #include <signal.h>
55 #include <errno.h>
56 #include <pkgdev.h>
57 #include <pkginfo.h>
58 #include <pkglocs.h>
59 #include <locale.h>
60 #include <libintl.h>
61 #include <pkgtrans.h>
62 #include <assert.h>
63
64 /*
65 * consolidation pkg command library includes
66 */
67 #include <pkglib.h>
68
69 #include <instzones_api.h>
70
71 /*
72 * local pkg command library includes
73 */
74 #include <install.h>
75 #include <libinst.h>
76 #include <libadm.h>
77 #include <messages.h>
78
79
80 /*
81 * pkgadd local includes
82 */
83
84 #include "quit.h"
85
86 /*
87 * imported global variables/functions
88 */
89
90 /* check.c */
91 extern int preinstall_verify(char **a_pkgList, zoneList_t a_zlst,
92 char *a_zoneTempDir);
93
94 /*
95 * ckquit is a global that controls 'ckyorn' (defined in libadm)
96 * If ckquit is non-zero, then "quit" is allowed as an answer when
97 * ckyorn is called. If is it zero, then "quit" is not an allowed answer.
98 */
99 extern int ckquit;
100
101 /*
102 * exported global variables
103 */
104
105 /* these globals are set by ckreturn and used by quit.c */
106
107 int admnflag = 0; /* != 0 if any pkg op admin setting failure (4) */
108 int doreboot = 0; /* != 0 if reboot required after installation */
109 int failflag = 0; /* != 0 if fatal error has occurred (1) */
110 int intrflag = 0; /* != 0 if user selected quit (3) */
111 int ireboot = 0; /* != 0 if immediate reboot required */
112 int nullflag = 0; /* != 0 if admin interaction required (5) */
113 int warnflag = 0; /* != 0 if non-fatal error has occurred (2) */
114
115 /* imported by quit.c */
116 int npkgs = 0; /* the number of packages yet to be installed */
117
118 /* imported by various (many) */
119 char *respfile = NULL; /* response pathname (or NULL) */
120 char *tmpdir = NULL; /* location to place temporary files */
121
122 struct admin adm; /* holds info about installation admin */
123 struct pkgdev pkgdev; /* holds info about the installation device */
124
125 /*
126 * internal global variables
127 */
128
129 static char *admnfile = NULL; /* file to use for installation admin */
130 static char *ids_name = NULL; /* name of data stream device */
131 static char *pkgcontsrc = NULL; /* continuation file (-c option) */
132 static char *pkgdrtarg = NULL; /* dry run file (-D option) */
133 static char *pkginst = NULL; /* current pkg/src instance 2 process */
134 static char *respdir = NULL; /* respfile is a directory spec */
135 static char *rw_block_size = NULL;
136 static char *vfstab_file = NULL;
137 static int askflag = 0; /* non-zero if invoked as "pkgask" */
138 static int disableAttributes = 0; /* Disabling attribute checking */
139 static int disableChecksum = 0; /* Disable checksumming */
140 static int disableSaveSpool = 0; /* Disable partial spool dir create */
141 static int init_install = 0; /* inform scripts initial install */
142 static int no_map_client = 0; /* do not map from vfstab file */
143 static int nointeract = 0; /* non-zero - no user interaction */
144 static int pkgverbose = 0; /* non-zero if verbose mode selected */
145 static int saveSpoolInstall = 0; /* installing from save spool dir */
146 static int suppressCopyright = 0; /* suppress copyright notices */
147
148 /* set by ckreturn() */
149
150 static int interrupted = 0; /* last pkg op was quit (1,2,3,4,5) */
151 static int needconsult = 0; /* essential ask admin now (1,2,3,5) */
152
153 /* Set by -O nozones: do not process any zones */
154
155 static boolean_t noZones = B_FALSE;
156
157 /* Set by -O zonelist=<names...>: process only named zones */
158
159 static boolean_t usedZoneList = B_FALSE;
160
161 /* Set by -O debug: debug output is enabled? */
162
163 static boolean_t debugFlag = B_FALSE;
164
165 /* Set by the -G option: install packages in global zone only */
166
167 static boolean_t globalZoneOnly = B_FALSE;
168
169 /*
170 * Assume the package is ABI and POSIX compliant as regards user
171 * interactiion during procedure scripts.
172 */
173
174 static int old_pkg = 0;
175
176 /* Assume pkg should be installed according to the ABI */
177
178 static int old_symlinks = 0;
179
180 /*
181 * Default name length will be 32 chars - if this is set,
182 * disable the 32 char name limit extension
183 */
184
185 static int ABI_namelength = 0;
186
187 #if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */
188 #define TEXT_DOMAIN "SYS_TEST"
189 #endif
190
191 /* printable string - if string is null results in ??? */
192
193 #define PSTR(STR) (((STR) == (char *)NULL) ? "???" : (STR))
194
195 #define MAX_FDS 20
196
197 /*
198 * forward declarations
199 */
200
201 static int boot_and_pkginstall_check_in_zones(zoneList_t a_zlst,
202 char *a_idsName, char *a_altBinDir,
203 char *a_zoneAdminFile, char *a_zoneTempDir);
204 static int boot_and_install_in_zones(zoneList_t a_zlst,
205 char *a_idsName, char *a_altBinDir,
206 char *a_zoneAdminFile, char *a_zoneTempDir);
207 static void pkginstall_check_in_one_zone(char *a_zoneName,
208 char *a_idsName, char *a_zoneAdminFile,
209 char *a_zoneTempDir, char *a_altBinDir,
210 char *a_scratchName, zone_state_t a_zoneState,
211 boolean_t a_tmpzn);
212 static void ckreturn(int retcode);
213 static void create_zone_adminfile(char **r_zoneAdminFile,
214 char *a_zoneTempDir, char *a_admnfile);
215 static void create_zone_tempdir(char **r_zoneTempDir,
216 char *a_tmpdir);
217 static void install_in_one_zone(char *a_zoneName, char *a_idsName,
218 char *a_zoneAdminFile, char *a_zoneTempDir,
219 char *a_altBinDir, zone_state_t a_zoneState,
220 boolean_t a_tmpzn);
221 static int pkginstall_check_in_zones(zoneList_t a_zlst,
222 char *a_idsName, char *a_altBinDir,
223 char *a_zoneAdminFile, char *a_zoneTempDir);
224 static int install_in_zones(zoneList_t a_zlst, char *a_idsName,
225 char *a_altBinDir, char *a_zoneAdminFile,
226 char *a_zoneTempDir);
227 static int pkgInstall(char *ir, char *a_idsName, char *a_pkgDir,
228 char *a_altBinDir);
229 static int pkgZoneCheckInstall(char *a_zoneName,
230 zone_state_t a_zoneState,
231 char *a_idsName, char *a_altBinDir,
232 char *a_adminFile, char *a_stdoutPath,
233 boolean_t a_tmpzn);
234 static int pkgZoneInstall(char *a_zoneName,
235 zone_state_t a_zoneState,
236 char *a_idsName, char *a_altBinDir,
237 char *a_adminFile, boolean_t a_tmpzn);
238 static void resetreturn();
239 static void usage(void);
240 static boolean_t add_packages(char **a_pkgList,
241 char *a_idsName, int a_repeat,
242 char *a_altBinDir, char *a_device,
243 boolean_t a_noZones);
244 static boolean_t add_packages_in_global_no_zones(char **a_pkgList,
245 char *a_idsName, int a_repeat,
246 char *a_altBinDir, char *a_device);
247 static boolean_t add_packages_in_global_with_zones(char **a_pkgList,
248 char *a_idsName, int a_repeat,
249 char *a_altBinDir, char *a_device,
250 zoneList_t a_zlst);
251 static boolean_t add_packages_in_nonglobal_zone(char **a_pkgList,
252 char *a_idsName, int a_repeat,
253 char *a_altBinDir, char *a_device);
254 static boolean_t check_applicability(char *a_packageDir,
255 char *a_pkgInst, char *a_rootPath,
256 CAF_T a_flags);
257 static boolean_t get_package_list(char ***r_pkgList, char **a_argv,
258 char *a_categories, char **a_categoryList,
259 char *a_idsName, int *r_repeat);
260 static boolean_t continue_installation(void);
261 static boolean_t unpack_and_check_packages(char **a_pkgList,
262 char *a_idsName, char *a_packageDir);
263 /*
264 * *****************************************************************************
265 * global external (public) functions
266 * *****************************************************************************
267 */
268
269 /*
270 * Name: main
271 * Description: main entry point for pkgadd/pkgask
272 * Returns: int
273 * 0 Successful completion
274 * 1 Fatal error.
275 * 2 Warning.
276 * 3 Interruption.
277 * 4 Administration.
278 * 5 Administration. Interaction is required. Do not use pkgadd -n.
279 * In addition, one of the following values may be added to the previous value
280 * as appropriate:
281 * 10 Reboot after installation of all packages.
282 * 20 Reboot after installation of this package.
283 * For example, "14" would indicate both "administration" and "reboot after
284 * installation of all packages".
285 */
286
287 int
288 main(int argc, char **argv)
289 {
290 char **category = NULL;
291 char *abiPtr;
292 char *altBinDir = (char *)NULL;
293 char *catg_arg = NULL;
294 char *device = NULL; /* dev pkg stored on */
295 char *p;
296 char *q;
297 char *prog;
298 char *prog_full_name = NULL;
299 char *spoolDir = NULL; /* specified with -s */
300 char Rpath[PATH_MAX+1] = {'\0'};
301 int c;
302 int n;
303 int repeat;
304 struct sigaction nact;
305 struct sigaction oact;
306
307 /* initialize locale environment */
308
309 (void) setlocale(LC_ALL, "");
310 (void) textdomain(TEXT_DOMAIN);
311
312 /* initialize program name */
313
314 prog_full_name = argv[0];
315 prog = set_prog_name(argv[0]);
316
317 /* tell spmi zones interface how to access package output functions */
318
319 z_set_output_functions(echo, echoDebug, progerr);
320
321 askflag = (strcmp(prog, "pkgask") == 0);
322
323 /* set sane umask */
324
325 (void) umask(0022);
326
327 /* tell quit which ckreturn function to call */
328
329 quitSetCkreturnFunc(&ckreturn);
330
331 /* initially no source "device" */
332
333 device = NULL;
334
335 /* reset npkgs (used as pkg remaining count in quit.c) */
336
337 npkgs = 0;
338
339 if (z_running_in_global_zone() && !enable_local_fs()) {
340 progerr(ERR_CANNOT_ENABLE_LOCAL_FS);
341 }
342
343 pkgserversetmode(DEFAULTMODE);
344
345 /*
346 * ********************************************************************
347 * parse command line options
348 * ********************************************************************
349 */
350
351 while ((c = getopt(argc, argv,
352 "?Aa:b:B:Cc:D:d:GhIMnO:R:r:Ss:tV:vY:z")) != EOF) {
353 switch (c) {
354
355 /*
356 * Not a public interface: This disables attribute checking.
357 * It speeds up installation a little bit.
358 */
359 case 'A':
360 disableAttributes++;
361 break;
362
363 /*
364 * Public interface: Define an installation administration
365 * file, admin, to be used in place of the default
366 * administration file. The token none overrides the use
367 * of any admin file, and thus forces interaction with the
368 * user. Unless a full path name is given, pkgadd first
369 * looks in the current working directory for the
370 * administration file. If the specified administration
371 * file is not in the current working directory, pkgadd
372 * looks in the /var/sadm/install/admin directory for the
373 * administration file.
374 */
375 case 'a':
376 admnfile = flex_device(optarg, 0);
377 break;
378
379 /*
380 * Not a public interface: control block size given to
381 * pkginstall - block size used in read()/write() loop;
382 * default is st_blksize from stat() of source file.
383 */
384 case 'B':
385 if (optarg[0] == '-') {
386 usage();
387 quit(1);
388 }
389 rw_block_size = optarg;
390 break;
391
392 /*
393 * Not a public interface: location where package executables
394 * can be found - default is /usr/sadm/install/bin.
395 */
396 case 'b':
397 if (optarg[0] == '-') {
398 usage();
399 quit(1);
400 }
401 if (!path_valid(optarg)) {
402 progerr(ERR_PATH, optarg);
403 quit(1);
404 }
405 if (isdir(optarg) != 0) {
406 p = strerror(errno);
407 progerr(ERR_CANNOT_USE_DIR, optarg, p);
408 quit(1);
409 }
410 altBinDir = optarg;
411 break;
412
413 /*
414 * Not a public interface: This disables checksum tests on
415 * the source files. It speeds up installation a little bit.
416 */
417 case 'C':
418 disableChecksum++;
419 break;
420
421 /*
422 * Not a public interface: This allows designation of a
423 * continuation file. It is the same format as a dryrun file
424 * but it is used to take up where the dryrun left off.
425 */
426 case 'c':
427 pkgcontsrc = flex_device(optarg, 0);
428 break;
429
430 /*
431 * Not a public interface: This allows designation of a
432 * dryrun file. This pkgadd will create dryrun files
433 * in the directory provided.
434 */
435 case 'D':
436 if (optarg[0] == '-') {
437 usage();
438 quit(1);
439 }
440 pkgdrtarg = flex_device(optarg, 0);
441 break;
442
443 /*
444 * Public interface: Install or copy a package from
445 * device. device can be a full path name to a directory
446 * or the identifiers for tape, floppy disk, or removable
447 * disk - for example, /var/tmp or /floppy/floppy_name.
448 * It can also be a device alias - for example,
449 * /floppy/floppy0, or a datastream created by pkgtrans.
450 */
451 case 'd':
452 if (optarg[0] == '-') {
453 usage();
454 quit(1);
455 }
456 if (!path_valid(optarg)) {
457 progerr(ERR_PATH, optarg);
458 quit(1);
459 /* NOTREACHED */
460 }
461
462 device = flex_device(optarg, 1);
463 break;
464
465 /*
466 * Public interface: install package in global zone only.
467 */
468 case 'G':
469 globalZoneOnly = B_TRUE;
470 break;
471
472 /*
473 * Not a public interface: Enable hollow package support. When
474 * specified, for any package that has SUNW_PKG_HOLLOW=true:
475 * Do not calculate and verify package size against target.
476 * Do not run any package procedure or class action scripts.
477 * Do not create any target directories.
478 * Do not perform any script locking.
479 * Do not install any components of any package.
480 * Do not output any status or database update messages.
481 */
482 case 'h':
483 set_depend_pkginfo_DB(B_TRUE);
484 break;
485
486 /*
487 * Not a public interface: Informs scripts that this is
488 * an initial install by setting the environment parameter
489 * PKG_INIT_INSTALL=TRUE for all scripts. They may use it as
490 * they see fit, safe in the knowledge that the target
491 * filesystem is tabula rasa.
492 */
493 case 'I':
494 init_install++;
495 break;
496
497 /*
498 * Public interface: Instruct pkgadd not to use the
499 * $root_path/etc/vfstab file for determining the client's
500 * mount points. This option assumes the mount points are
501 * correct on the server and it behaves consistently with
502 * Solaris 2.5 and earlier releases.
503 */
504 case 'M':
505 no_map_client = 1;
506 break;
507
508 /*
509 * Not a public interface: the -O option allows the behavior
510 * of the package tools to be modified. Recognized options:
511 * -> debug
512 * ---> enable debugging output
513 * -> addzonename
514 * ---> add zone name to appropriate messages
515 * -> nozones
516 * ---> act as though in global zone with no non-global zones
517 * -> enable-hollow-package-support
518 * ---> Enable hollow package support. When specified, for any
519 * ---> package that has SUNW_PKG_HOLLOW=true:
520 * ---> Do not calculate and verify package size against target
521 * ---> Do not run any package procedure or class action scripts
522 * ---> Do not create any target directories
523 * ---> Do not perform any script locking
524 * ---> Do not install any components of any package
525 * ---> Do not output any status or database update messages
526 * -> zonelist="<names...>"
527 * ---> add package to space/colon separated list of zones only
528 */
529
530 case 'O':
531 for (p = strtok(optarg, ","); p != (char *)NULL;
532 p = strtok(NULL, ",")) {
533
534 if (strcmp(p, "debug") == 0) {
535 /* set debug flag/enable debug output */
536 debugFlag = B_TRUE;
537 (void) echoDebugSetFlag(debugFlag);
538
539 /* debug info on arguments to pkgadd */
540 for (n = 0; n < argc && argv[n]; n++) {
541 echoDebug(DBG_ARG, n, argv[n]);
542 }
543
544 continue;
545 }
546
547 if (strcmp(p,
548 "enable-hollow-package-support") == 0) {
549 set_depend_pkginfo_DB(B_TRUE);
550 continue;
551 }
552
553 if (strcmp(p, "addzonename") == 0) {
554 quitSetZoneName(z_get_zonename());
555 continue;
556 }
557
558 if (strcmp(p, "nozones") == 0) {
559 noZones = B_TRUE;
560 continue;
561 }
562
563 if (strncmp(p, "zonelist=", 9) == 0) {
564 /*
565 * If colons used as separators,
566 * convert to spaces.
567 */
568 q = p + 9;
569 while (*q != '\0') {
570 if (*q == ':') {
571 *q = ' ';
572 }
573 q++;
574 }
575
576 if (z_set_zone_spec(p + 9) == -1)
577 quit(1);
578 usedZoneList = B_TRUE;
579 continue;
580 }
581
582 progerr(ERR_INVALID_O_OPTION, p);
583 continue;
584 }
585 break;
586
587 /*
588 * Public interface: installation occurs in
589 * non-interactive mode. Suppress output of the list of
590 * installed files. The default mode is interactive.
591 */
592 case 'n':
593 nointeract++;
594 (void) echoSetFlag(B_FALSE);
595 break;
596
597 /*
598 * Public interface: Define the full path name of a
599 * directory to use as the root_path. All files,
600 * including package system information files, are
601 * relocated to a directory tree starting in the specified
602 * root_path. The root_path may be specified when
603 * installing to a client from a server (for example,
604 * /export/root/client1).
605 */
606 case 'R':
607 if (optarg[0] == '-') {
608 usage();
609 quit(1);
610 }
611 /* determine the real path specified */
612
613 n = resolvepath(optarg, Rpath, sizeof (Rpath)-1);
614
615 /* use supplied path if not resolvable */
616
617 if (n == -1) {
618 (void) strlcpy(Rpath, optarg, sizeof (Rpath));
619 } else {
620 /* null terminate string */
621 Rpath[n] = '\0';
622 }
623
624 /* set the alternative root path */
625
626 if (!set_inst_root(Rpath)) {
627 progerr(ERR_ROOT_CMD);
628 exit(1);
629 }
630 break;
631
632 /*
633 * Public interface: Identify a file or directory which
634 * contains output from a previous pkgask(1M)
635 * session. This file supplies the interaction responses
636 * that would be requested by the package in interactive
637 * mode. response must be a full pathname.
638 */
639 case 'r':
640 if (optarg[0] == '-') {
641 usage();
642 quit(1);
643 }
644 respfile = flex_device(optarg, 2);
645 if (isdir(respfile) == 0)
646 respdir = respfile;
647 break;
648
649 /*
650 * Not a public interface: suppress copyright notice being
651 * output during installation.
652 */
653 case 'S':
654 suppressCopyright++;
655 break;
656
657 /*
658 * Public interface: Write the package into the directory
659 * spool instead of installing it. The default directory
660 * for spooled packages is /var/sadm/pkg.
661 */
662 case 's':
663 spoolDir = flex_device(optarg, 1);
664 break;
665
666 /*
667 * Not a public interface: disable save spool area creation;
668 * suppress the creation and population of the package save
669 * spool area (var/sadm/pkg/PKG/save/pspool/PKG).
670 */
671 case 't':
672 disableSaveSpool++;
673 break;
674
675 /*
676 * Public interface: Specify an alternative fs_file to map
677 * the client's file systems. For example, used in
678 * situations where the $root_path/etc/vfstab file is
679 * non-existent or unreliable. Informs the pkginstall
680 * portion to mount up a client filesystem based upon the
681 * supplied vfstab-like file of stable format.
682 */
683 case 'V':
684 vfstab_file = flex_device(optarg, 2);
685 no_map_client = 0;
686 break;
687
688 /*
689 * Public interface: Trace all of the scripts that get
690 * executed by pkgadd, located in the pkginst/install
691 * directory. This option is used for debugging the
692 * procedural and non-procedural scripts
693 */
694 case 'v':
695 pkgverbose++;
696 break;
697
698 /*
699 * Public interface: Install packages based on the value
700 * of the CATEGORY parameter stored in the package's
701 * pkginfo(4) file. All packages on the source medium
702 * whose CATEGORY matches one of the specified categories
703 * will be selected for installation or spooling. Install
704 * packages that contain the same CATEGORY as the one
705 * provided on the command line.
706 */
707 case 'Y':
708 if (optarg[0] == '-') {
709 usage();
710 quit(1);
711 }
712 catg_arg = strdup(optarg);
713
714 if ((category = get_categories(catg_arg)) == NULL) {
715 progerr(ERR_CAT_INV, catg_arg);
716 exit(1);
717 } else if (is_not_valid_length(category)) {
718 progerr(ERR_CAT_LNGTH);
719 exit(1);
720 }
721 break;
722
723 /*
724 * Not a public interface: perform fresh install from
725 * package save spool area. When set, the package contents
726 * are installed from the package spool save area instead
727 * of from the package root area, so that the original
728 * source packages are not required to install the
729 * package. If the -h option is also specified and the
730 * package is hollow, then this option is ignored. When -z
731 * is specified:
732 * - Editable files are installed from the package instance
733 * save area.
734 * - Volatile files are installed from the package instance
735 * save area.
736 * - Executable and data files are installed from the final
737 * installed location as specified in the pkgmap file.
738 * - Installation scripts are run from the package spool
739 * save area.
740 */
741 case 'z':
742 saveSpoolInstall++;
743 break;
744
745 /*
746 * unrecognized option
747 */
748
749 default:
750 usage();
751 return (1);
752 }
753 }
754
755 /*
756 * ********************************************************************
757 * validate command line options
758 * ********************************************************************
759 */
760
761 /* set "debug echo" flag according to setting of "-O debug" option */
762
763 (void) echoDebugSetFlag(debugFlag);
764
765 /* output entry debugging information */
766
767 if (z_running_in_global_zone()) {
768 echoDebug(DBG_ENTRY_IN_GZ, prog_full_name);
769 } else {
770 echoDebug(DBG_ENTRY_IN_LZ, prog_full_name, getzoneid(),
771 z_get_zonename());
772 }
773
774 /*
775 * Later, it may be decided to pursue this ability to continue to an
776 * actual installation based only on the dryrun data. At this time,
777 * it is too risky.
778 */
779
780 if (pkgcontsrc && !pkgdrtarg) {
781 progerr(ERR_NO_LIVE_MODE);
782 usage();
783 return (1);
784 }
785
786 /* ignore -G option if not used in the global zone */
787
788 if (!z_running_in_global_zone()) {
789 globalZoneOnly = B_FALSE;
790 }
791
792 /* if zonelist used, must be in global zone */
793
794 if (usedZoneList && !z_running_in_global_zone()) {
795 progerr(ERR_Z_USED_IN_NONGLOBAL_ZONE);
796 return (1);
797 }
798
799 /* -G and zonelist cannot be used together */
800
801 if (globalZoneOnly && usedZoneList) {
802 progerr(ERR_GZ_USED_TOGETHER);
803 usage();
804 return (1);
805 }
806
807 /* -s cannot be used with either -G or zonelist */
808
809 if (spoolDir != NULL) {
810 if (globalZoneOnly) {
811 progerr(ERR_SPOOLDIR_USED_WITH_G);
812 usage();
813 return (1);
814 }
815 if (usedZoneList) {
816 progerr(ERR_SPOOLDIR_USED_WITH_Z);
817 usage();
818 return (1);
819 }
820 if (strcmp(spoolDir, "/var/sadm/pkg") == 0) {
821 progerr(ERR_SPOOLDIR_CANNOT_BE_SYS, "/var/sadm/pkg");
822 usage();
823 return (1);
824 }
825 }
826
827 /* pkgask does not support the same options as pkgadd */
828
829 if (askflag && spoolDir) {
830 progerr(ERR_PKGASK_AND_SPOOLDIR);
831 usage();
832 return (1);
833 }
834
835 if (askflag && nointeract) {
836 progerr(ERR_PKGASK_AND_NOINTERACT);
837 usage();
838 return (1);
839 }
840
841 /* cannot use response file/not-interactive and spool-to directory */
842
843 if (spoolDir && nointeract) {
844 progerr(ERR_SPOOLDIR_AND_NOINTERACT);
845 usage();
846 return (1);
847 }
848
849 if (spoolDir && respfile) {
850 progerr(ERR_SPOOLDIR_AND_RESPFILE);
851 usage();
852 return (1);
853 }
854
855 if (usedZoneList) {
856 /* Verify supplied zone list valid for the target */
857 if (z_verify_zone_spec() == -1)
858 return (1);
859
860 /* -z zonelist=global is logically the same as -G */
861 if (z_global_only() && z_running_in_global_zone())
862 globalZoneOnly = B_TRUE;
863 }
864
865 /*
866 * hook SIGINT and SIGHUP interrupts into quit.c's trap handler
867 */
868
869 /* hold SIGINT/SIGHUP interrupts */
870
871 (void) sighold(SIGHUP);
872 (void) sighold(SIGINT);
873
874 /* connect quit.c:trap() to SIGINT */
875
876 nact.sa_handler = quitGetTrapHandler();
877 nact.sa_flags = SA_RESTART;
878 (void) sigemptyset(&nact.sa_mask);
879
880 (void) sigaction(SIGINT, &nact, &oact);
881
882 /* connect quit.c:trap() to SIGHUP */
883
884 nact.sa_handler = quitGetTrapHandler();
885 nact.sa_flags = SA_RESTART;
886 (void) sigemptyset(&nact.sa_mask);
887
888 (void) sigaction(SIGHUP, &nact, &oact);
889
890 /* release hold on signals */
891
892 (void) sigrelse(SIGHUP);
893 (void) sigrelse(SIGINT);
894
895 /*
896 * This function is in the libadm library; it sets:
897 * -> get_PKGLOC() = <install_root>/var/sadm/pkg
898 * -> get_PKGADM() = <install_root>/var/sadm/install
899 * -> pkgdir = <install_root>/var/sadm/pkg
900 * -> pkg_install_root = <install_root>
901 * This controls operations of libadm functions such as:
902 * -> pkginfofind, pkginfopen, fpkgparam, pkgparam, get_PKGLOC,
903 * -> get_PKGADM, get_install_root
904 */
905
906 set_PKGpaths(get_inst_root());
907 echoDebug(DBG_PKGADD_PKGPATHS,
908 get_PKGLOC() ? get_PKGLOC() : "",
909 get_PKGADM() ? get_PKGADM() : "");
910
911 /*
912 * This function is in the libinst library; it reads the specified
913 * admin(4) file and, using fpkgparam(), sets the global "adm" structure
914 * values to match what is in the specified admin file.
915 */
916
917 echoDebug(DBG_PKGADD_ADMINFILE, admnfile ? admnfile : "");
918 setadminFile(admnfile);
919
920 /*
921 * if running in the global zone, and non-global zones exist, then
922 * enable hollow package support so that any packages that are marked
923 * SUNW_PKG_HOLLOW=true will be correctly installed in non-global zones
924 * when added directly in the global zone by the global zone admin.
925 */
926
927 if (is_depend_pkginfo_DB()) {
928 echoDebug(DBG_PKGADD_HOLLOW_ENABLED);
929 } else if ((z_running_in_global_zone() == B_TRUE) &&
930 (z_non_global_zones_exist() == B_TRUE)) {
931 echoDebug(DBG_PKGADD_ENABLING_HOLLOW);
932 set_depend_pkginfo_DB(B_TRUE);
933 }
934
935 /* if no device, get and validate default device */
936
937 if (device == NULL) {
938 device = devattr("spool", "pathname");
939 if (device == NULL) {
940 progerr(ERR_NODEVICE);
941 quit(1);
942 /* NOTREACHED */
943 }
944 }
945
946 /* must be root if not directing results to spool directory */
947
948 if ((getuid() != 0) && (spoolDir == NULL)) {
949 progerr(ERR_NOT_ROOT, prog);
950 exit(1);
951 }
952
953 /*
954 * process response file argument
955 */
956
957 if (respfile) {
958 echoDebug(DBG_PKGADD_RESPFILE,
959 respfile, respdir ? respdir : "");
960
961 if (respfile[0] != '/') {
962 progerr(ERR_RSP_FILE_NOTFULLPATH, respfile);
963 quit(1);
964 /* NOTREACHED */
965 }
966 if (respdir == NULL) {
967 if (askflag) {
968 if (access(respfile, F_OK) == 0) {
969 progerr(ERR_NORESP, respfile);
970 quit(1);
971 /* NOTREACHED */
972 }
973 } else if (access(respfile, F_OK) != 0) {
974 progerr(ERR_ACCRESP, respfile);
975 quit(1);
976 /* NOTREACHED */
977 }
978 }
979 } else if (askflag) {
980 progerr(ERR_RSP_FILE_NOT_GIVEN);
981 usage();
982 quit(1);
983 /* NOTREACHED */
984 }
985
986 /* establish temporary directory to use */
987
988 if ((tmpdir = getenv("TMPDIR")) == NULL) {
989 /* use default - no override specified */
990 tmpdir = P_tmpdir;
991 }
992
993 echoDebug(DBG_PKGADD_TMPDIR, tmpdir);
994
995 /*
996 * See if user wants this to be handled as an old style pkg.
997 * NOTE : the ``exception_pkg()'' stuff is to be used only
998 * through on495. This function comes out for on1095. See
999 * PSARC 1993-546. -- JST
1000 */
1001
1002 if (getenv("NONABI_SCRIPTS") != NULL) {
1003 old_pkg = 1;
1004 }
1005
1006 /*
1007 * See if the user wants to process symlinks consistent with
1008 * the old behavior.
1009 */
1010
1011 if (getenv("PKG_NONABI_SYMLINKS") != NULL) {
1012 old_symlinks = 1;
1013 }
1014
1015 /*
1016 * See if the user wants the package name length restricted.
1017 */
1018
1019 abiPtr = getenv("PKG_ABI_NAMELENGTH");
1020 if (abiPtr && strncasecmp(abiPtr, "TRUE", 4) == 0) {
1021 ABI_namelength = 1;
1022 }
1023
1024 /*
1025 * validate the package source device - return pkgdev info that
1026 * describes the package source device.
1027 */
1028
1029 if (devtype(device, &pkgdev)) {
1030 progerr(ERR_BAD_DEVICE, device);
1031 quit(1);
1032 /* NOTREACHED */
1033 }
1034
1035 /*
1036 * If writing the packages into a spool directory instead of
1037 * installing the packages, open the package datastream and
1038 * invoke pkgtrans to perform the conversion and exit.
1039 */
1040
1041 if (spoolDir != (char *)NULL) {
1042 boolean_t b;
1043 int n;
1044
1045 echoDebug(DBG_INSTALLING_TO_SPOOL, spoolDir);
1046
1047 b = open_package_datastream(argc, argv, spoolDir, device,
1048 &repeat, &ids_name, tmpdir,
1049 &pkgdev, optind);
1050
1051 quitSetIdsName(ids_name);
1052
1053 if (b != B_TRUE) {
1054 progerr(ERR_CANNOT_OPEN_PKG_STREAM, PSTR(device));
1055 quit(1);
1056 }
1057
1058 n = pkgtrans(device, spoolDir, &argv[optind], 0);
1059 quit(n);
1060 /* NOTREACHED */
1061 }
1062
1063 /*
1064 * error if there are packages on the command line and a category
1065 * was specified
1066 */
1067
1068 if ((optind < argc) && (catg_arg != NULL)) {
1069 progerr(ERR_PKGS_AND_CAT_PKGADD);
1070 usage();
1071 quit(1);
1072 /* NOTREACHED */
1073 }
1074
1075 /*
1076 * ********************************************************************
1077 * main package processing "loop"
1078 * ********************************************************************
1079 */
1080
1081 ids_name = NULL;
1082 quitSetIdsName(ids_name);
1083
1084 for (;;) {
1085 boolean_t b;
1086 char **pkglist; /* points to array of pkgs */
1087
1088 /*
1089 * open next package data stream
1090 */
1091
1092 b = open_package_datastream(argc, argv, spoolDir, device,
1093 &repeat, &ids_name, tmpdir,
1094 &pkgdev, optind);
1095
1096 quitSetIdsName(ids_name);
1097
1098 if (b == B_FALSE) {
1099 echoDebug(ERR_CANNOT_OPEN_PKG_STREAM, PSTR(device));
1100 continue;
1101 }
1102
1103 /*
1104 * package source data stream open - get the package list
1105 */
1106
1107 b = get_package_list(&pkglist, argv, catg_arg, category,
1108 ids_name, &repeat);
1109
1110 if (b == B_FALSE) {
1111 echoDebug(DBG_CANNOT_GET_PKGLIST);
1112
1113 progerr(ERR_NOPKGS, pkgdev.dirname);
1114 quit(1);
1115 /* NOTREACHED */
1116 }
1117
1118 /*
1119 * count the number of packages to install
1120 * NOTE: npkgs is a global variable that is referenced by quit.c
1121 * when error messages are generated - it is referenced directly
1122 * by the other functions called below...
1123 */
1124
1125 for (npkgs = 0; pkglist[npkgs] != (char *)NULL; /* void */) {
1126 echoDebug(DBG_PKG_SELECTED, npkgs, pkglist[npkgs]);
1127 npkgs++;
1128 }
1129
1130 /* output number of packages to be added */
1131
1132 echoDebug(DBG_NUM_PKGS_TO_ADD, npkgs);
1133
1134 /*
1135 * if pkgask and response container is a file (not a directory),
1136 * and there is more than one package to install, then it is an
1137 * error - too many packages to install when response container
1138 * is a file.
1139 */
1140
1141 if ((askflag != 0) && (respdir == (char *)NULL) &&
1142 (npkgs > 1)) {
1143 progerr(ERR_TOO_MANY_PKGS);
1144 quit(1);
1145 /* NOTREACHED */
1146 }
1147
1148 /*
1149 * package list generated - add packages
1150 */
1151
1152 b = add_packages(pkglist, ids_name, repeat,
1153 altBinDir, device, noZones);
1154
1155 /*
1156 * close open input data stream (source package) if left open.
1157 */
1158
1159 if (ids_name) {
1160 echoDebug(DBG_CLOSING_STREAM, ids_name,
1161 PSTR(pkgdev.dirname));
1162 (void) ds_close(1);
1163 rrmdir(pkgdev.dirname);
1164 ids_name = NULL;
1165 quitSetIdsName(ids_name);
1166 }
1167
1168 /*
1169 * continue with next sequence of packages if continue set
1170 */
1171
1172 if (b == B_TRUE) {
1173 continue;
1174 }
1175
1176 /*
1177 * not continuing - quit with 0 exit code
1178 */
1179
1180 quit(0);
1181 /* NOTREACHED */
1182 }
1183
1184 /* NOTREACHED */
1185 }
1186
1187 /*
1188 * *****************************************************************************
1189 * static internal (private) functions
1190 * *****************************************************************************
1191 */
1192
1193 /*
1194 * Name: pkgZoneCheckInstall
1195 * Description: Invoke pkginstall in a specified zone to perform a preinstall
1196 * check of the a single package in the specified zone
1197 * Arguments: a_zoneName - pointer to string representing the name of the
1198 * zone to check install the package in.
1199 * a_zoneState - current state of the zone; must be mounted or
1200 * running.
1201 * a_idsName - pointer to string representing the data stream
1202 * device (input data stream) containing the package to
1203 * be check installed.
1204 * a_altBinDir - pointer to string representing an alternative
1205 * binary location directory to pass to pkginstall.
1206 * If this is == NULL no alternative binary location is
1207 * passed to pkginstall.
1208 * a_adminFile - pointer to string representing the admin
1209 * file to pass to pkginstall when installing the package.
1210 * If this is == NULL no admin file is given to pkginstall.
1211 * a_stdoutPath - pointer to string representing the local path
1212 * into which all output written by pkginstall to stdout
1213 * is stored.
1214 * If this is == NULL stdout is redirected to /dev/null
1215 * a_tmpzn - B_TRUE when this zone is booted by the package
1216 * command or B_FALSE if it was running before.
1217 * Returns: int (see ckreturn() function for details)
1218 * 0 - success
1219 * 1 - package operation failed (fatal error)
1220 * 2 - non-fatal error (warning)
1221 * 3 - user selected quit (operation interrupted)
1222 * 4 - admin settings prevented operation
1223 * 5 - interaction required and -n (non-interactive) specified
1224 * "10" will be added to indicate "immediate reboot required"
1225 * "20" will be added to indicate "reboot after install required"
1226 */
1227
1228 static int
1229 pkgZoneCheckInstall(char *a_zoneName, zone_state_t a_zoneState,
1230 char *a_idsName, char *a_altBinDir, char *a_adminFile,
1231 char *a_stdoutPath, boolean_t a_tmpzn)
1232 {
1233 char *arg[MAXARGS];
1234 char *p;
1235 char adminfd_path[PATH_MAX];
1236 char path[PATH_MAX];
1237 char pkgstreamfd_path[PATH_MAX];
1238 int fds[MAX_FDS];
1239 int maxfds;
1240 int n;
1241 int nargs;
1242
1243 /* entry assertions */
1244
1245 assert(a_zoneName != (char *)NULL);
1246 assert(*a_zoneName != '\0');
1247
1248 /* entry debugging info */
1249
1250 echoDebug(DBG_PKGZONECHECKINSTALL_ENTRY);
1251 echoDebug(DBG_PKGZONECHECKINSTALL_ARGS, a_zoneName, PSTR(pkginst),
1252 PSTR(pkgdev.dirname), PSTR(pkgdev.mount), PSTR(pkgdev.bdevice),
1253 a_zoneState == ZONE_STATE_MOUNTED ? "/a" : "/",
1254 PSTR(a_idsName), PSTR(a_adminFile), PSTR(a_stdoutPath));
1255
1256 /* generate full path to 'phatinstall' to run in zone */
1257
1258 (void) snprintf(path, sizeof (path), "%s/pkginstall",
1259 "/usr/sadm/install/bin");
1260
1261 /* start at first file descriptor */
1262
1263 maxfds = 0;
1264
1265 /*
1266 * generate argument list for call to pkginstall
1267 */
1268
1269 /* start at argument 0 */
1270
1271 nargs = 0;
1272
1273 /* first argument is always: full path to executable */
1274
1275 arg[nargs++] = path;
1276
1277 /*
1278 * second argument is always: pass -O debug to pkginstall: debug mode
1279 */
1280 if (debugFlag == B_TRUE) {
1281 arg[nargs++] = "-O";
1282 arg[nargs++] = "debug";
1283 }
1284
1285 /* pkgadd -G: pass -G to pkginstall */
1286
1287 if (globalZoneOnly == B_TRUE) {
1288 arg[nargs++] = "-G";
1289 }
1290
1291 /* pkgadd -b dir: pass -b to pkginstall */
1292
1293 if (a_altBinDir != (char *)NULL) {
1294 arg[nargs++] = "-b";
1295 arg[nargs++] = a_altBinDir;
1296 }
1297
1298 /* pkgadd -C: pass -C to pkginstall: disable checksum */
1299
1300 if (disableChecksum) {
1301 arg[nargs++] = "-C";
1302 }
1303
1304 /* pkgadd -A: pass -A to pkginstall: disable attribute checking */
1305
1306 if (disableAttributes) {
1307 arg[nargs++] = "-A";
1308 }
1309
1310 /*
1311 * NONABI_SCRIPTS defined: pass -o to pkginstall; refers to a
1312 * pkg requiring operator interaction during a procedure script
1313 * (common before on1093)
1314 */
1315
1316 if (old_pkg) {
1317 arg[nargs++] = "-o";
1318 }
1319
1320 /*
1321 * PKG_NONABI_SYMLINKS defined: pass -y to pkginstall; process
1322 * symlinks consistent with old behavior
1323 */
1324
1325 if (old_symlinks) {
1326 arg[nargs++] = "-y";
1327 }
1328
1329 /*
1330 * PKG_ABI_NAMELENGTH defined: pass -e to pkginstall; causes
1331 * package name length to be restricted
1332 */
1333
1334 if (ABI_namelength) {
1335 arg[nargs++] = "-e";
1336 }
1337
1338 /* pkgadd -S: pass -S to pkginstall: suppress copyright notices */
1339
1340 arg[nargs++] = "-S";
1341
1342 /* pkgadd -M: pass -M to pkginstall: dont mount client file systems */
1343
1344 arg[nargs++] = "-M";
1345
1346 /* pkgadd -v: pass -v to pkginstall: never trace scripts */
1347
1348 /* if running pkgask, pass -i to pkginstall: running pkgask */
1349
1350 if (askflag) {
1351 return (0);
1352 }
1353
1354 /* pass "-O enable-hollow-package-support" */
1355
1356 if (is_depend_pkginfo_DB()) {
1357 arg[nargs++] = "-O";
1358 arg[nargs++] = "enable-hollow-package-support";
1359 }
1360
1361 /* check is always in non-interactive mode */
1362
1363 arg[nargs++] = "-n";
1364
1365 /* pkgadd -a admin: pass -a admin to pkginstall in zone: admin file */
1366
1367 if (a_adminFile) {
1368 int fd;
1369 fd = openLocal(a_adminFile, O_RDONLY, tmpdir);
1370 if (fd < 0) {
1371 progerr(ERR_CANNOT_COPY_LOCAL, a_adminFile,
1372 errno, strerror(errno));
1373 return (1);
1374 }
1375 (void) snprintf(adminfd_path, sizeof (adminfd_path),
1376 "/proc/self/fd/%d", fd);
1377 fds[maxfds++] = fd;
1378 arg[nargs++] = "-a";
1379 arg[nargs++] = adminfd_path;
1380 }
1381
1382 /* pkgadd -R root: pass -R /a to pkginstall when zone is mounted */
1383
1384 if (a_zoneState == ZONE_STATE_MOUNTED) {
1385 arg[nargs++] = "-R";
1386 arg[nargs++] = "/a";
1387 }
1388
1389 /* pass -N to pkginstall: program name to report */
1390
1391 arg[nargs++] = "-N";
1392 arg[nargs++] = get_prog_name();
1393
1394 /* pass "-O preinstallcheck" */
1395
1396 arg[nargs++] = "-O";
1397 arg[nargs++] = "preinstallcheck";
1398
1399 /* add "-O addzonename" */
1400
1401 arg[nargs++] = "-O";
1402 arg[nargs++] = "addzonename";
1403
1404 /*
1405 * add parent zone info/type
1406 */
1407
1408 p = z_get_zonename();
1409 if ((p != NULL) && (*p != '\0')) {
1410 char zn[MAXPATHLEN];
1411 (void) snprintf(zn, sizeof (zn),
1412 "parent-zone-name=%s", p);
1413 arg[nargs++] = "-O";
1414 arg[nargs++] = strdup(zn);
1415 }
1416
1417 /* current zone type */
1418
1419 arg[nargs++] = "-O";
1420 if (z_running_in_global_zone() == B_TRUE) {
1421 char zn[MAXPATHLEN];
1422 (void) snprintf(zn, sizeof (zn),
1423 "parent-zone-type=%s",
1424 TAG_VALUE_GLOBAL_ZONE);
1425 arg[nargs++] = strdup(zn);
1426 } else {
1427 char zn[MAXPATHLEN];
1428 (void) snprintf(zn, sizeof (zn),
1429 "parent-zone-type=%s",
1430 TAG_VALUE_NONGLOBAL_ZONE);
1431 arg[nargs++] = strdup(zn);
1432 }
1433
1434 /* Add the pkgserv options */
1435 arg[nargs++] = "-O";
1436 arg[nargs++] = pkgmodeargument(a_tmpzn ? RUN_ONCE : pkgservergetmode());
1437
1438 /* add in the package stream file */
1439
1440 if (a_idsName != NULL) {
1441 int fd;
1442 fd = openLocal(a_idsName, O_RDONLY, tmpdir);
1443 if (fd < 0) {
1444 progerr(ERR_STREAM_UNAVAILABLE, a_idsName,
1445 pkginst, strerror(errno));
1446 quit(1);
1447 }
1448 (void) snprintf(pkgstreamfd_path, sizeof (pkgstreamfd_path),
1449 "/proc/self/fd/%d", fd);
1450 fds[maxfds++] = fd;
1451 arg[nargs++] = pkgstreamfd_path;
1452 } else {
1453 progerr(ERR_PKGZONEINSTALL_NO_STREAM);
1454 quit(1);
1455 }
1456
1457 /* add package instance name */
1458
1459 arg[nargs++] = pkginst;
1460
1461 /* terminate the argument list */
1462
1463 arg[nargs++] = NULL;
1464
1465 /*
1466 * run the appropriate pkginstall command in the specified zone
1467 */
1468
1469 if (debugFlag == B_TRUE) {
1470 echoDebug(DBG_ZONE_EXEC_ENTER, a_zoneName, arg[0]);
1471 for (n = 0; arg[n]; n++) {
1472 echoDebug(DBG_ARG, n, arg[n]);
1473 }
1474 }
1475
1476 /* terminate file descriptor list */
1477
1478 fds[maxfds] = -1;
1479
1480 /* exec command in zone */
1481
1482 n = z_zone_exec(a_zoneName, path, arg, a_stdoutPath, (char *)NULL, fds);
1483
1484 echoDebug(DBG_ZONE_EXEC_EXIT, a_zoneName, arg[0], n,
1485 PSTR(a_stdoutPath));
1486
1487 /*
1488 * close any files that were opened for use by the
1489 * /proc/self/fd interface so they could be passed to programs
1490 * via the z_zone_exec() interface
1491 */
1492
1493 for (; maxfds > 0; maxfds--) {
1494 (void) close(fds[maxfds-1]);
1495 }
1496
1497 /* return results of pkginstall in zone execution */
1498
1499 return (n);
1500 }
1501
1502 /*
1503 * Name: pkgZoneInstall
1504 * Description: Invoke pkginstall in a specified zone to perform an install
1505 * of a single package in the specified zone
1506 * Arguments: a_zoneName - pointer to string representing the name of the
1507 * zone to install the package in.
1508 * a_zoneState - current state of the zone; must be mounted or
1509 * running.
1510 * a_idsName - pointer to string representing the data stream
1511 * device (input data stream) containing the package to
1512 * be installed.
1513 * a_altBinDir - pointer to string representing an alternative
1514 * binary location directory to pass to pkginstall.
1515 * If this is == NULL no alternative binary location is
1516 * passed to pkginstall.
1517 * a_adminFile - pointer to string representing the admin
1518 * file to pass to pkginstall when installing the package.
1519 * If this is == NULL no admin file is given to pkginstall.
1520 * a_stdoutPath - pointer to string representing the local path
1521 * into which all output written by pkginstall to stdout
1522 * is stored.
1523 * If this is == NULL stdout is redirected to /dev/null
1524 * a_tmpzn - B_TRUE when this zone is booted by the package
1525 * command or B_FALSE if it was running before.
1526 * Returns: int (see ckreturn() function for details)
1527 * 0 - success
1528 * 1 - package operation failed (fatal error)
1529 * 2 - non-fatal error (warning)
1530 * 3 - user selected quit (operation interrupted)
1531 * 4 - admin settings prevented operation
1532 * 5 - interaction required and -n (non-interactive) specified
1533 * "10" will be added to indicate "immediate reboot required"
1534 * "20" will be added to indicate "reboot after install required"
1535 */
1536
1537 static int
1538 pkgZoneInstall(char *a_zoneName, zone_state_t a_zoneState, char *a_idsName,
1539 char *a_altBinDir, char *a_adminFile, boolean_t a_tmpzn)
1540 {
1541 char *arg[MAXARGS];
1542 char *p;
1543 char adminfd_path[PATH_MAX];
1544 char path[PATH_MAX];
1545 char pkgstreamfd_path[PATH_MAX];
1546 char respfilefd_path[PATH_MAX];
1547 int fds[MAX_FDS];
1548 int maxfds;
1549 int n;
1550 int nargs;
1551
1552 /* entry assertions */
1553
1554 assert(a_zoneName != (char *)NULL);
1555 assert(*a_zoneName != '\0');
1556
1557 /* entry debugging info */
1558
1559 echoDebug(DBG_PKGZONEINSTALL_ENTRY);
1560 echoDebug(DBG_PKGZONEINSTALL_ARGS, a_zoneName, PSTR(pkginst),
1561 PSTR(pkgdev.dirname), PSTR(pkgdev.mount), PSTR(pkgdev.bdevice),
1562 a_zoneState == ZONE_STATE_MOUNTED ? "/a" : "", PSTR(a_idsName),
1563 a_adminFile);
1564
1565 /* generate path to pkginstall */
1566
1567 (void) snprintf(path, sizeof (path), "%s/pkginstall", PKGBIN);
1568
1569 /* start at first file descriptor */
1570
1571 maxfds = 0;
1572
1573 /*
1574 * generate argument list for call to pkginstall
1575 */
1576
1577 /* start at argument 0 */
1578
1579 nargs = 0;
1580
1581 /* first argument is path to executable */
1582
1583 arg[nargs++] = path;
1584
1585 /*
1586 * second argument is always: pass -O debug to pkginstall: debug mode
1587 */
1588 if (debugFlag == B_TRUE) {
1589 arg[nargs++] = "-O";
1590 arg[nargs++] = "debug";
1591 }
1592
1593 /* pkgadd -G: pass -G to pkginstall */
1594
1595 if (globalZoneOnly == B_TRUE) {
1596 arg[nargs++] = "-G";
1597 }
1598
1599 /* pkgadd -b dir: pass -b to pkginstall in zone */
1600
1601 if (a_altBinDir != (char *)NULL) {
1602 arg[nargs++] = "-b";
1603 arg[nargs++] = a_altBinDir;
1604 }
1605
1606 /* pkgadd -B blocksize: pass -B to pkginstall in zone */
1607
1608 if (rw_block_size != NULL) {
1609 arg[nargs++] = "-B";
1610 arg[nargs++] = rw_block_size;
1611 }
1612
1613 /* pkgadd -C: pass -C to pkgadd in zone: disable checksum */
1614
1615 if (disableChecksum) {
1616 arg[nargs++] = "-C";
1617 }
1618
1619 /* pkgadd -A: pass -A to pkgadd in zone: disable attribute checking */
1620
1621 if (disableAttributes) {
1622 arg[nargs++] = "-A";
1623 }
1624
1625 /* pkgadd -S: pass -S to pkgadd in zone: suppress copyright notices */
1626
1627 arg[nargs++] = "-S";
1628
1629 /* pkgadd -I: pass -I to pkgadd in zone: initial install */
1630
1631 if (init_install) {
1632 arg[nargs++] = "-I";
1633 }
1634
1635 /* pkgadd -M: pass -M to pkgadd in zone: dont mount client file sys */
1636
1637 arg[nargs++] = "-M";
1638
1639 /* pkgadd -v: pass -v to pkgadd in zone: trace scripts */
1640
1641 if (pkgverbose) {
1642 arg[nargs++] = "-v";
1643 }
1644
1645 /* pkgadd -z: pass -z to pkgadd in zone fresh inst from pkg save area */
1646
1647 if (saveSpoolInstall) {
1648 arg[nargs++] = "-z";
1649 }
1650
1651 /* pass "-O enable-hollow-package-support" */
1652
1653 if (is_depend_pkginfo_DB()) {
1654 arg[nargs++] = "-O";
1655 arg[nargs++] = "enable-hollow-package-support";
1656 }
1657
1658 /* pkgadd -t pass -t to pkgadd in zone disable save spool area create */
1659
1660 if (disableSaveSpool) {
1661 arg[nargs++] = "-t";
1662 }
1663
1664 /* if running pkgask, pass -i to pkgadd in zone: running pkgask */
1665
1666 if (askflag) {
1667 echo(MSG_BYPASSING_ZONE, a_zoneName);
1668 return (0);
1669 }
1670
1671 /*
1672 * pkgadd -n (not pkgask): pass -n to pkginstall: noninteractive mode
1673 */
1674 if (nointeract && !askflag) {
1675 arg[nargs++] = "-n";
1676 }
1677
1678 /* pkgadd -a admin: pass -a admin to pkginstall in zone: admin file */
1679
1680 if (a_adminFile) {
1681 int fd;
1682 fd = openLocal(a_adminFile, O_RDONLY, tmpdir);
1683 if (fd < 0) {
1684 progerr(ERR_CANNOT_COPY_LOCAL, a_adminFile,
1685 errno, strerror(errno));
1686 return (1);
1687 }
1688 (void) snprintf(adminfd_path, sizeof (adminfd_path),
1689 "/proc/self/fd/%d", fd);
1690 fds[maxfds++] = fd;
1691 arg[nargs++] = "-a";
1692 arg[nargs++] = adminfd_path;
1693 }
1694
1695 /* pkgadd -R root: pass -R /a to pkginstall when zone is mounted */
1696 if (a_zoneState == ZONE_STATE_MOUNTED) {
1697 arg[nargs++] = "-R";
1698 arg[nargs++] = "/a";
1699 }
1700
1701 /*
1702 * pkgadd -D arg: pass -D dryrun to pkginstall in zone: dryrun
1703 * mode/file
1704 */
1705 if (pkgdrtarg) {
1706 arg[nargs++] = "-D";
1707 arg[nargs++] = pkgdrtarg;
1708 }
1709
1710 /*
1711 * pkgadd -c cont: pass -c cont to pkginstall in zone: continuation
1712 * file
1713 */
1714 if (pkgcontsrc) {
1715 arg[nargs++] = "-c";
1716 arg[nargs++] = pkgcontsrc;
1717 }
1718
1719 /* pkgadd -r resp: pass -r resp to pkginstall in zone: response file */
1720
1721 if (respfile) {
1722 int fd;
1723 fd = openLocal(respfile, O_RDONLY, tmpdir);
1724 if (fd < 0) {
1725 progerr(ERR_CANNOT_COPY_LOCAL, a_adminFile,
1726 errno, strerror(errno));
1727 return (1);
1728 }
1729 (void) snprintf(respfilefd_path,
1730 sizeof (respfilefd_path),
1731 "/proc/self/fd/%d", fd);
1732 fds[maxfds++] = fd;
1733 arg[nargs++] = "-r";
1734 arg[nargs++] = respfilefd_path;
1735 }
1736
1737 /* add "-O addzonename" */
1738
1739 arg[nargs++] = "-O";
1740 arg[nargs++] = "addzonename";
1741
1742 /*
1743 * add parent zone info/type
1744 */
1745
1746 p = z_get_zonename();
1747 if ((p != NULL) && (*p != '\0')) {
1748 char zn[MAXPATHLEN];
1749 (void) snprintf(zn, sizeof (zn),
1750 "parent-zone-name=%s", p);
1751 arg[nargs++] = "-O";
1752 arg[nargs++] = strdup(zn);
1753 }
1754
1755 /* current zone type */
1756
1757 arg[nargs++] = "-O";
1758 if (z_running_in_global_zone() == B_TRUE) {
1759 char zn[MAXPATHLEN];
1760 (void) snprintf(zn, sizeof (zn),
1761 "parent-zone-type=%s",
1762 TAG_VALUE_GLOBAL_ZONE);
1763 arg[nargs++] = strdup(zn);
1764 } else {
1765 char zn[MAXPATHLEN];
1766 (void) snprintf(zn, sizeof (zn),
1767 "parent-zone-type=%s",
1768 TAG_VALUE_NONGLOBAL_ZONE);
1769 arg[nargs++] = strdup(zn);
1770 }
1771
1772 /* Add the pkgserv options */
1773 arg[nargs++] = "-O";
1774 arg[nargs++] = pkgmodeargument(a_tmpzn ? RUN_ONCE : pkgservergetmode());
1775
1776 /* add in the package stream file */
1777
1778 if (a_idsName != NULL) {
1779 int fd;
1780 fd = openLocal(a_idsName, O_RDONLY, tmpdir);
1781 if (fd < 0) {
1782 progerr(ERR_STREAM_UNAVAILABLE, a_idsName,
1783 pkginst, strerror(errno));
1784 quit(1);
1785 }
1786 (void) snprintf(pkgstreamfd_path, sizeof (pkgstreamfd_path),
1787 "/proc/self/fd/%d", fd);
1788 fds[maxfds++] = fd;
1789 arg[nargs++] = pkgstreamfd_path;
1790 } else {
1791 progerr(ERR_PKGZONEINSTALL_NO_STREAM);
1792 quit(1);
1793 }
1794
1795 /* add package instance name */
1796
1797 arg[nargs++] = pkginst;
1798
1799 /* terminate the argument list */
1800
1801 arg[nargs++] = NULL;
1802
1803 /*
1804 * run the appropriate pkginstall command in the specified zone
1805 */
1806
1807 if (debugFlag == B_TRUE) {
1808 echoDebug(DBG_ZONE_EXEC_ENTER, a_zoneName, arg[0]);
1809 for (n = 0; arg[n]; n++) {
1810 echoDebug(DBG_ARG, n, arg[n]);
1811 }
1812 }
1813
1814 /* terminate file descriptor list */
1815
1816 fds[maxfds] = -1;
1817
1818 /* exec command in zone */
1819
1820 n = z_zone_exec(a_zoneName, path, arg, (char *)NULL, (char *)NULL, fds);
1821
1822 echoDebug(DBG_ZONE_EXEC_EXIT, a_zoneName, arg[0], n, "");
1823
1824 /*
1825 * close any files that were opened for use by the
1826 * /proc/self/fd interface so they could be passed to programs
1827 * via the z_zone_exec() interface
1828 */
1829
1830 for (; maxfds > 0; maxfds--) {
1831 (void) close(fds[maxfds-1]);
1832 }
1833
1834 /* return results of pkginstall in zone execution */
1835
1836 return (n);
1837 }
1838
1839 /*
1840 * Name: pkgInstall
1841 * Description: Invoke pkginstall in the current zone to perform an install
1842 * of a single package to the current zone or standalone system
1843 * Arguments: a_altRoot - pointer to string representing the alternative
1844 * root to use for the install
1845 * a_idsName - pointer to string representing the data stream
1846 * device (input data stream) containing the package to
1847 * be installed.
1848 * a_pkgDir - pointer to string representing the path to the
1849 * directory containing the package
1850 * a_altBinDir - pointer to string representing location of the
1851 * pkginstall executable to run. If not NULL, then pass
1852 * the path specified to the -b option to pkginstall.
1853 * Returns: int (see ckreturn() function for details)
1854 * 0 - success
1855 * 1 - package operation failed (fatal error)
1856 * 2 - non-fatal error (warning)
1857 * 3 - user selected quit (operation interrupted)
1858 * 4 - admin settings prevented operation
1859 * 5 - interaction required and -n (non-interactive) specified
1860 * "10" will be added to indicate "immediate reboot required"
1861 * "20" will be added to indicate "reboot after install required"
1862 * NOTE: Both a_idsName and a_pkgDir are used to determine where the
1863 * package to be installed is located. If a_idsName is != NULL
1864 * then it must be the path to a device containing a package
1865 * stream that contains the package to be installed. If a_idsName
1866 * is == NULL then a_pkgDir must contain a full path to a directory
1867 * that contains the package to be installed.
1868 */
1869
1870 static int
1871 pkgInstall(char *a_altRoot, char *a_idsName, char *a_pkgDir, char *a_altBinDir)
1872 {
1873 char *arg[MAXARGS];
1874 char *p;
1875 char path[PATH_MAX];
1876 char buffer[256];
1877 int n, nargs;
1878
1879 /* entry debugging info */
1880
1881 echoDebug(DBG_PKGINSTALL_ENTRY);
1882 echoDebug(DBG_PKGINSTALL_ARGS, PSTR(pkginst), PSTR(pkgdev.dirname),
1883 PSTR(pkgdev.mount), PSTR(pkgdev.bdevice), PSTR(a_altRoot),
1884 PSTR(a_idsName), PSTR(a_pkgDir));
1885
1886 /* generate full path to 'pkginstall' to run in zone */
1887
1888 (void) snprintf(path, sizeof (path), "%s/pkginstall",
1889 a_altBinDir == (char *)NULL ? PKGBIN : a_altBinDir);
1890 /*
1891 * generate argument list for call to pkginstall
1892 */
1893
1894 /* start at argument 0 */
1895
1896 nargs = 0;
1897
1898 /* first argument is path to executable */
1899
1900 arg[nargs++] = path;
1901
1902 /*
1903 * second argument is always: pass -O debug to pkginstall: debug mode
1904 */
1905 if (debugFlag == B_TRUE) {
1906 arg[nargs++] = "-O";
1907 arg[nargs++] = "debug";
1908 }
1909
1910 arg[nargs++] = "-O";
1911 arg[nargs++] = pkgmodeargument(pkgservergetmode());
1912
1913 /*
1914 * pkgadd -G: pass -G to pkginstall if:
1915 * - the -G option is specified on the pkgadd command line
1916 * - this package is marked 'this zone only':
1917 * -- package has SUNW_PKG_THISZONE=true, or
1918 * -- package has a request script
1919 * Setting -G for pkginstall causes pkginstall to install the package
1920 * in the target zone. If running in the global zone, will install the
1921 * package and mark the package as installed "in the global zone only".
1922 * If running in a non-global zone, will just install the package.
1923 */
1924
1925 if (globalZoneOnly == B_TRUE) {
1926 arg[nargs++] = "-G";
1927 } else if (pkgPackageIsThisZone(pkginst) == B_TRUE) {
1928 arg[nargs++] = "-G";
1929 }
1930
1931 /* pkgadd -b dir: pass -b to pkginstall */
1932
1933 if (a_altBinDir != (char *)NULL) {
1934 arg[nargs++] = "-b";
1935 arg[nargs++] = a_altBinDir;
1936 }
1937
1938 /* pkgadd -B blocksize: pass -B to pkginstall */
1939
1940 if (rw_block_size != NULL) {
1941 arg[nargs++] = "-B";
1942 arg[nargs++] = rw_block_size;
1943 }
1944
1945 /* pkgadd -C: pass -C to pkginstall: disable checksum */
1946
1947 if (disableChecksum) {
1948 arg[nargs++] = "-C";
1949 }
1950
1951 /* pkgadd -A: pass -A to pkginstall: disable attribute checking */
1952
1953 if (disableAttributes) {
1954 arg[nargs++] = "-A";
1955 }
1956
1957 /*
1958 * NONABI_SCRIPTS defined: pass -o to pkginstall; refers to a
1959 * pkg requiring operator interaction during a procedure script
1960 * (common before on1093)
1961 */
1962
1963 if (old_pkg) {
1964 arg[nargs++] = "-o";
1965 }
1966
1967 /*
1968 * PKG_NONABI_SYMLINKS defined: pass -y to pkginstall; process
1969 * symlinks consistent with old behavior
1970 */
1971
1972 if (old_symlinks) {
1973 arg[nargs++] = "-y";
1974 }
1975
1976 /*
1977 * PKG_ABI_NAMELENGTH defined: pass -e to pkginstall; causes
1978 * package name length to be restricted
1979 */
1980
1981 if (ABI_namelength) {
1982 arg[nargs++] = "-e";
1983 }
1984
1985 /* pkgadd -S: pass -S to pkginstall: suppress copyright notices */
1986
1987 if (suppressCopyright) {
1988 arg[nargs++] = "-S";
1989 }
1990
1991 /* pkgadd -I: pass -I to pkginstall: initial install being performed */
1992
1993 if (init_install) {
1994 arg[nargs++] = "-I";
1995 }
1996
1997 /* pkgadd -M: pass -M to pkginstall: dont mount client file systems */
1998
1999 if (no_map_client) {
2000 arg[nargs++] = "-M";
2001 }
2002
2003 /* pkgadd -v: pass -v to pkginstall: trace scripts */
2004
2005 if (pkgverbose) {
2006 arg[nargs++] = "-v";
2007 }
2008
2009 /* pkgadd -z: pass -z to pkginstall: fresh install from pkg save area */
2010
2011 if (saveSpoolInstall) {
2012 arg[nargs++] = "-z";
2013 }
2014
2015 /*
2016 * if running in a non-global zone and the 'hollow' attribute is
2017 * passed in, then pass -h to pkginstall so that it knows how to
2018 * handle hollow packages for this local zone.
2019 */
2020
2021 if (!z_running_in_global_zone() && is_depend_pkginfo_DB()) {
2022 arg[nargs++] = "-h";
2023 }
2024
2025 /* pkgadd -t: pass -t to pkginstall: disable save spool area creation */
2026
2027 if (disableSaveSpool) {
2028 arg[nargs++] = "-t";
2029 }
2030
2031 /* if running pkgask, pass -i to pkginstall: running pkgask */
2032
2033 if (askflag) {
2034 arg[nargs++] = "-i";
2035 }
2036
2037 /* pkgadd -n (not pkgask): pass -n to pkginstall: noninteractive mode */
2038
2039 if (nointeract && !askflag) {
2040 arg[nargs++] = "-n";
2041 }
2042
2043 /* pkgadd -a admin: pass -a admin to pkginstall: admin file */
2044
2045 if (admnfile) {
2046 arg[nargs++] = "-a";
2047 arg[nargs++] = admnfile;
2048 }
2049
2050 /* pkgadd -D dryrun: pass -D dryrun to pkginstall: dryrun mode/file */
2051
2052 if (pkgdrtarg) {
2053 arg[nargs++] = "-D";
2054 arg[nargs++] = pkgdrtarg;
2055 }
2056
2057 /* pkgadd -c cont: pass -c cont to pkginstall: continuation file */
2058
2059 if (pkgcontsrc) {
2060 arg[nargs++] = "-c";
2061 arg[nargs++] = pkgcontsrc;
2062 }
2063
2064 /* pkgadd -V vfstab: pass -V vfstab to pkginstall: alternate vfstab */
2065
2066 if (vfstab_file) {
2067 arg[nargs++] = "-V";
2068 arg[nargs++] = vfstab_file;
2069 }
2070
2071 /* pkgadd -r resp: pass -r resp to pkginstall: response file */
2072
2073 if (respfile) {
2074 arg[nargs++] = "-r";
2075 arg[nargs++] = respfile;
2076 }
2077
2078 /* pkgadd -R root: pass -R root to pkginstall: alternative root */
2079
2080 if (a_altRoot && *a_altRoot) {
2081 arg[nargs++] = "-R";
2082 arg[nargs++] = a_altRoot;
2083 }
2084
2085 /*
2086 * If input data stream is available,
2087 * - add: -d ids_name -p number_of_parts
2088 * else,
2089 * - add: -d device -m mount [-f type]
2090 */
2091
2092 if (a_idsName != NULL) {
2093 arg[nargs++] = "-d";
2094 arg[nargs++] = a_idsName;
2095 arg[nargs++] = "-p";
2096 ds_close(1);
2097 ds_putinfo(buffer, sizeof (buffer));
2098 arg[nargs++] = buffer;
2099 } else if (pkgdev.mount != NULL) {
2100 arg[nargs++] = "-d";
2101 arg[nargs++] = pkgdev.bdevice;
2102 arg[nargs++] = "-m";
2103 arg[nargs++] = pkgdev.mount;
2104 if (pkgdev.fstyp != NULL) {
2105 arg[nargs++] = "-f";
2106 arg[nargs++] = pkgdev.fstyp;
2107 }
2108 }
2109
2110 /*
2111 * add parent zone info/type
2112 */
2113
2114 p = z_get_zonename();
2115 if ((p != NULL) && (*p != '\0')) {
2116 char zn[MAXPATHLEN];
2117 (void) snprintf(zn, sizeof (zn),
2118 "parent-zone-name=%s", p);
2119 arg[nargs++] = "-O";
2120 arg[nargs++] = strdup(zn);
2121 }
2122
2123 /* current zone type */
2124
2125 arg[nargs++] = "-O";
2126 if (z_running_in_global_zone() == B_TRUE) {
2127 char zn[MAXPATHLEN];
2128 (void) snprintf(zn, sizeof (zn),
2129 "parent-zone-type=%s",
2130 TAG_VALUE_GLOBAL_ZONE);
2131 arg[nargs++] = strdup(zn);
2132 } else {
2133 char zn[MAXPATHLEN];
2134 (void) snprintf(zn, sizeof (zn),
2135 "parent-zone-type=%s",
2136 TAG_VALUE_NONGLOBAL_ZONE);
2137 arg[nargs++] = strdup(zn);
2138 }
2139
2140 /* pass -N to pkginstall: program name to report */
2141
2142 arg[nargs++] = "-N";
2143 arg[nargs++] = get_prog_name();
2144
2145 /* add package directory name */
2146
2147 arg[nargs++] = a_pkgDir;
2148
2149 /* add package instance name */
2150
2151 arg[nargs++] = pkginst;
2152
2153 /* terminate the argument list */
2154
2155 arg[nargs++] = NULL;
2156
2157 /*
2158 * run the appropriate pkginstall command in the specified zone
2159 */
2160
2161 if (debugFlag == B_TRUE) {
2162 echoDebug(DBG_ZONE_EXEC_ENTER, "global", arg[0]);
2163 for (n = 0; arg[n]; n++) {
2164 echoDebug(DBG_ARG, n, arg[n]);
2165 }
2166 }
2167
2168 /* execute pkginstall command */
2169
2170 n = pkgexecv(NULL, NULL, NULL, NULL, arg);
2171
2172 /* return results of pkginstall execution */
2173
2174 return (n);
2175 }
2176
2177 /*
2178 * function to clear out any exisiting error return conditions that may have
2179 * been set by previous calls to ckreturn()
2180 */
2181 static void
2182 resetreturn()
2183 {
2184 admnflag = 0; /* != 0 if any pkg op admin setting failure (4) */
2185 doreboot = 0; /* != 0 if reboot required after installation (>= 10) */
2186 failflag = 0; /* != 0 if fatal error has occurred (1) */
2187 intrflag = 0; /* != 0 if user selected quit (3) */
2188 ireboot = 0; /* != 0 if immediate reboot required (>= 20) */
2189 nullflag = 0; /* != 0 if admin interaction required (5) */
2190 warnflag = 0; /* != 0 if non-fatal error has occurred (2) */
2191 interrupted = 0; /* last pkg op was quit (1,2,3,4,5) */
2192 needconsult = 0; /* essential ask admin now (1,2,3,5) */
2193 }
2194
2195 /*
2196 * function which checks the indicated return value
2197 * and indicates disposition of installation
2198 */
2199 static void
2200 ckreturn(int retcode)
2201 {
2202 /*
2203 * entry debugging info
2204 */
2205
2206 echoDebug(DBG_PKGADD_CKRETURN, retcode, PSTR(pkginst));
2207
2208 /* reset needconsult so it only reflects this call to ckreturn */
2209 needconsult = 0;
2210
2211 switch (retcode) {
2212 case 0: /* successful */
2213 case 10:
2214 case 20:
2215 break; /* empty case */
2216
2217 case 1: /* package operation failed (fatal error) */
2218 case 11:
2219 case 21:
2220 failflag++;
2221 interrupted++;
2222 needconsult++;
2223 break;
2224
2225 case 2: /* non-fatal error (warning) */
2226 case 12:
2227 case 22:
2228 warnflag++;
2229 interrupted++;
2230 needconsult++;
2231 break;
2232
2233 case 3: /* user selected quit; operation interrupted */
2234 case 13:
2235 case 23:
2236 intrflag++;
2237 interrupted++;
2238 needconsult++;
2239 break;
2240
2241 case 4: /* admin settings prevented operation */
2242 case 14:
2243 case 24:
2244 admnflag++;
2245 interrupted++;
2246 break;
2247
2248 case 5: /* administration: interaction req (no -n) */
2249 case 15:
2250 case 25:
2251 nullflag++;
2252 interrupted++;
2253 needconsult++;
2254 break;
2255
2256 default:
2257 failflag++;
2258 interrupted++;
2259 needconsult++;
2260 return;
2261 }
2262
2263 if (retcode >= 20) {
2264 ireboot++;
2265 } else if (retcode >= 10) {
2266 doreboot++;
2267 }
2268 }
2269
2270 static void
2271 usage(void)
2272 {
2273 char *prog = get_prog_name();
2274
2275 if (askflag) {
2276 (void) fprintf(stderr, ERR_USAGE_PKGASK, prog);
2277 } else if (z_running_in_global_zone() == B_FALSE) {
2278 (void) fprintf(stderr, ERR_USAGE_PKGADD_NONGLOBALZONE,
2279 prog, prog);
2280 } else {
2281 (void) fprintf(stderr, ERR_USAGE_PKGADD_GLOBALZONE,
2282 prog, prog);
2283 }
2284 }
2285
2286 /*
2287 * Name: check_applicability
2288 * Description: determine if a package is installable in this zone; that is,
2289 * does the scope of install conflict with existing installation
2290 * or can the package be installed
2291 * Arguments: a_packageDir - [RO, *RO] - (char *)
2292 * Pointer to string representing the directory where the
2293 * package is located
2294 * a_pkgInst - [RO, *RO] - (char *)
2295 * Pointer to string representing the name of the package
2296 * to check
2297 * a_rootPath - [RO, *RO] - (char *)
2298 * Pointer to string representing path to the root of the
2299 * file system where the package is to be installed - this
2300 * is usually the same as the "-R" argument to pkgadd
2301 * a_flags - [RO, *RO] - (CAF_T)
2302 * Flags set by the caller to indicate the conditions
2303 * under which the package is to be installed:
2304 * CAF_IN_GLOBAL_ZONE - in global zone
2305 * CAF_SCOPE_GLOBAL - -G specified
2306 * Returns: boolean_t
2307 * B_TRUE - the package can be installed
2308 * B_FALSE - the package can not be installed
2309 */
2310
2311 static boolean_t
2312 check_applicability(char *a_packageDir, char *a_pkgInst, char *a_rootPath,
2313 CAF_T a_flags)
2314 {
2315 FILE *pkginfoFP;
2316 FILE *pkgmapFP;
2317 boolean_t all_zones; /* pkg is "all zones" only */
2318 boolean_t in_gz_only; /* pkg installed in global zone only */
2319 boolean_t is_hollow; /* pkg is "hollow" */
2320 boolean_t pkg_installed; /* pkg is installed */
2321 boolean_t this_zone; /* pkg is "this zone" only */
2322 boolean_t reqfile_found = B_FALSE;
2323 char instPkg[PKGSIZ+1]; /* installed pkg instance nam */
2324 char instPkgPath[PATH_MAX]; /* installed pkg toplevel dir */
2325 char pkginfoPath[PATH_MAX]; /* pkg 2 install pkginfo file */
2326 char pkgmapPath[PATH_MAX]; /* pkg 2 install pkgmap file */
2327 char pkgpath[PATH_MAX]; /* pkg 2 install toplevel dir */
2328 int len;
2329 char line[LINE_MAX];
2330
2331 /* entry assertions */
2332
2333 assert(a_packageDir != (char *)NULL);
2334 assert(*a_packageDir != '\0');
2335 assert(a_pkgInst != (char *)NULL);
2336 assert(*a_pkgInst != '\0');
2337
2338 /* normalize root path */
2339
2340 if (a_rootPath == (char *)NULL) {
2341 a_rootPath = "";
2342 }
2343
2344 /* entry debugging info */
2345
2346 echoDebug(DBG_CHECKAPP_ENTRY);
2347 echoDebug(DBG_CHECKAPP_ARGS, a_pkgInst, a_packageDir, a_rootPath);
2348
2349 /*
2350 * calculate paths to various objects
2351 */
2352
2353 /* path to package to be installed top level (main) directory */
2354
2355 len = snprintf(pkgpath, sizeof (pkgpath), "%s/%s", a_packageDir,
2356 a_pkgInst);
2357 if (len > sizeof (pkgpath)) {
2358 progerr(ERR_CREATE_PATH_2, a_packageDir, a_pkgInst);
2359 return (B_FALSE);
2360 }
2361
2362 /* error if package top level directory does not exist */
2363
2364 if (isdir(pkgpath) != 0) {
2365 progerr(ERR_NO_PKGDIR, pkgpath, a_pkgInst, strerror(errno));
2366 return (B_FALSE);
2367 }
2368
2369 /* path to pkginfo file within the package to be installed */
2370
2371 len = snprintf(pkginfoPath, sizeof (pkginfoPath), "%s/pkginfo",
2372 pkgpath);
2373 if (len > sizeof (pkginfoPath)) {
2374 progerr(ERR_CREATE_PATH_2, pkgpath, "pkginfo");
2375 return (B_FALSE);
2376 }
2377
2378 /* path to highest instance of package currently installed */
2379
2380 pkgLocateHighestInst(instPkgPath, sizeof (instPkgPath),
2381 instPkg, sizeof (instPkg), a_rootPath, a_pkgInst);
2382
2383 /*
2384 * gather information from this package's pkginfo file
2385 */
2386
2387 pkginfoFP = fopen(pkginfoPath, "r");
2388
2389 if (pkginfoFP == (FILE *)NULL) {
2390 progerr(ERR_NO_PKG_INFOFILE, a_pkgInst, pkginfoPath,
2391 strerror(errno));
2392 return (B_FALSE);
2393 }
2394
2395 /* determine "HOLLOW" setting for this package */
2396
2397 is_hollow = pkginfoParamTruth(pkginfoFP, PKG_HOLLOW_VARIABLE,
2398 "true", B_FALSE);
2399
2400 /* determine "ALLZONES" setting for this package */
2401
2402 all_zones = pkginfoParamTruth(pkginfoFP, PKG_ALLZONES_VARIABLE,
2403 "true", B_FALSE);
2404
2405 /* determine "THISZONE" setting for this package */
2406
2407 this_zone = pkginfoParamTruth(pkginfoFP, PKG_THISZONE_VARIABLE,
2408 "true", B_FALSE);
2409
2410 /* close pkginfo file */
2411
2412 (void) fclose(pkginfoFP);
2413
2414 /*
2415 * If request file is not found, it may be in the datastream which
2416 * is not yet unpacked. Check in the pkgmap file.
2417 */
2418 if (isfile(pkgpath, REQUEST_FILE) != 0) {
2419
2420 /* path to pkgmap file within the package to be installed */
2421 (void) snprintf(pkgmapPath, sizeof (pkgmapPath), "%s/pkgmap",
2422 pkgpath);
2423
2424 pkgmapFP = fopen(pkgmapPath, "r");
2425
2426 if (pkgmapFP == NULL) {
2427 progerr(ERR_NO_PKG_MAPFILE, a_pkgInst,
2428 pkgmapPath, strerror(errno));
2429 return (B_FALSE);
2430 }
2431
2432 while (fgets(line, LINE_MAX, pkgmapFP) != NULL) {
2433 if (strstr(line, " i request") != NULL) {
2434 reqfile_found = B_TRUE;
2435 break;
2436 }
2437 }
2438 (void) fclose(pkgmapFP);
2439 } else {
2440 reqfile_found = B_TRUE;
2441 }
2442
2443 /*
2444 * If this package is not marked for installation in this zone only,
2445 * check to see if this package has a request script. If this package
2446 * does have a request script, then mark the package for installation
2447 * in this zone only. Any package with a request script cannot be
2448 * installed outside of the zone the pkgadd command is being run in,
2449 * nor can such a package be installed as part of a new zone install.
2450 * A new zone install must be non-interactive, which is required
2451 * by all packages integrated into the Solaris WOS.
2452 */
2453
2454 if ((!this_zone) && (reqfile_found)) {
2455 if (a_flags & CAF_IN_GLOBAL_ZONE) {
2456 echoDebug(DBG_CHECKAPP_THISZONE_REQUEST, a_pkgInst);
2457 }
2458 this_zone = B_TRUE;
2459 }
2460
2461 /*
2462 * If this package is already installed, see if the current installation
2463 * of the package has a request file - if it does, then act as though
2464 * the current package to be added has a request file - install the
2465 * package in the current zone only.
2466 */
2467
2468 if ((!this_zone) && (instPkgPath[0] != '\0') &&
2469 (isfile(instPkgPath, REQUEST_FILE) == 0)) {
2470 if (a_flags & CAF_IN_GLOBAL_ZONE) {
2471 echoDebug(DBG_CHECKAPP_THISZONE_INSTREQ,
2472 a_pkgInst, instPkg);
2473 }
2474 this_zone = B_TRUE;
2475 }
2476
2477 /* gather information from the global zone only file */
2478
2479 in_gz_only = B_FALSE;
2480 if (a_flags & CAF_IN_GLOBAL_ZONE) {
2481 in_gz_only = pkgIsPkgInGzOnly(a_rootPath, a_pkgInst);
2482 }
2483
2484 /* determine if this package is currently installed */
2485
2486 pkg_installed = pkginfoIsPkgInstalled((struct pkginfo **)NULL,
2487 a_pkgInst);
2488
2489 /*
2490 * verify package applicability based on information gathered,
2491 * and validate the three SUNW_PKG_ options:
2492 *
2493 * -----------|--------------|-------------|-------------|-----------
2494 * - - - - - -| GLOBAL ZONE -| GLOBAL ZONE | LOCAL ZONE | LOCAL ZONE
2495 * - - - - - -| - - pkgadd - | pkgadd -G | pkgadd | pkgadd -G
2496 * ----1------|--------------|-------------|-------------|------------
2497 * ALLZONES f | add to gz | add to gz | add to ls | add to ls
2498 * HOLLOW f | current lz | not to curr | only - - - -| only - - -
2499 * THISZONE f | futr lz - - -| or futr lz | - - - - - - | - - - - - -
2500 * ----2------|--------------|-------------|-------------|------------
2501 * ALLZONES T | add to gz | operation | operation | operation
2502 * HOLLOW f | current lz | not allowed | not allowed | not allowed
2503 * THISZONE f | future lz | - - - - - - | - - - - - - | - - - - - -
2504 * ----3------|--------------|-------------|-------------|------------
2505 * ALLZONES T | add to gz | operation | operation | operation
2506 * HOLLOW T | pkg db only | not allowed | not allowed | not allowed
2507 * THISZONE f | curr/futr lz | - - - - - - | - - - - - - | - - - - - -
2508 * ----4------|--------------|-------------|-------------|------------
2509 * ALLZONES T | bad option | bad option | bad option | bad option
2510 * HOLLOW * | combo - - - -| combo - - - | combo - - - | combo - -
2511 * THISZONE T | - - - - - - -|- - - - - - -|- - - - - - -|- - - - - -
2512 * ----5------|--------------|-------------|-------------|------------
2513 * ALLZONES f | bad option | bad option | bad option | bad option
2514 * HOLLOW T | combo - - - -| combo - - - | combo - - - | combo - - -
2515 * THISZONE * | - - - - - - -| - - - - - - | - - - - - - | - - - - - -
2516 * ----6------|--------------|-------------|-------------|------------
2517 * ALLZONES f | add to gz | add to gz | add to lz | add to lz
2518 * HOLLOW f | not current | not current | only - - - | only - - -
2519 * THISZONE T | or future lz | or futr lz | - - - - - - | - - - - - -
2520 * -----------|--------------|-------------|-------------|-----------
2521 */
2522
2523 /* pkg "all zones" && "this zone" (#4) */
2524
2525 if (all_zones && this_zone) {
2526 progerr(ERR_ALLZONES_AND_THISZONE, a_pkgInst,
2527 PKG_ALLZONES_VARIABLE, PKG_THISZONE_VARIABLE);
2528 return (B_FALSE);
2529 }
2530
2531 /* pkg "!all zones" && "hollow" (#5) */
2532
2533 if ((!all_zones) && is_hollow) {
2534 progerr(ERR_NOW_ALLZONES_AND_HOLLOW, a_pkgInst,
2535 PKG_ALLZONES_VARIABLE, PKG_HOLLOW_VARIABLE);
2536 return (B_FALSE);
2537 }
2538
2539 /* pkg ALLZONES=true & not running in global zone (#2/#3) */
2540
2541 if (all_zones && (!(a_flags & CAF_IN_GLOBAL_ZONE))) {
2542 progerr(ERR_ALLZONES_AND_IN_LZ, a_pkgInst);
2543 return (B_FALSE);
2544 }
2545
2546 /* pkg "in gz only" & pkg "NOT installed" */
2547
2548 if (in_gz_only && (!pkg_installed)) {
2549 /* MAKE A WARNING */
2550 echo(ERR_IN_GZ_AND_NOT_INSTALLED, a_pkgInst,
2551 pkgGetGzOnlyPath());
2552 }
2553
2554 /* pkg ALLZONES=true & pkg "in gz only" & pkg "is installed" */
2555
2556 if (all_zones && in_gz_only && pkg_installed) {
2557 progerr(ERR_IN_GZ_AND_ALLZONES_AND_INSTALLED, a_pkgInst);
2558 return (B_FALSE);
2559 }
2560
2561 /* pkg ALLZONES=true && -G specified (#2/#3) */
2562
2563 if (all_zones && (a_flags & CAF_SCOPE_GLOBAL)) {
2564 progerr(ERR_ALLZONES_AND_G_USED, a_pkgInst);
2565 return (B_FALSE);
2566 }
2567
2568 /* pkg "!this zone" && "in gz only" & -G not specified */
2569
2570 if ((!this_zone) && in_gz_only && (!(a_flags & CAF_SCOPE_GLOBAL))) {
2571 progerr(ERR_IN_GZ_AND_NO_G_USED, a_pkgInst);
2572 return (B_FALSE);
2573 }
2574
2575 /*
2576 * If this package is marked 'this zone only', then mark the package
2577 * as "add to this zone only". This is referenced by the various
2578 * add_package_... functions to determine if the package should be
2579 * added to the current zone, or to all zones, depending on the
2580 * zone in which the command is being run.
2581 */
2582
2583 if (this_zone) {
2584 pkgAddThisZonePackage(a_pkgInst);
2585 }
2586
2587 return (B_TRUE);
2588 }
2589
2590 /*
2591 * Name: create_zone_adminfile
2592 * Description: Given a zone temporary directory and optionally an existing
2593 * administration file, generate an administration file that
2594 * can be used to perform "non-interactive" operations in a
2595 * non-global zone.
2596 * Arguments: r_zoneAdminFile - pointer to handle that will contain a
2597 * string representing the path to the temporary
2598 * administration file created - this must be NULL
2599 * before the first call to this function - on
2600 * subsequent calls if the pointer is NOT null then
2601 * the existing string will NOT be overwritten.
2602 * a_zoneTempDir - pointer to string representing the path
2603 * to the zone temporary directory to create the
2604 * temporary administration file in
2605 * a_admnfile - pointer to string representing the path to
2606 * an existing "user" administration file - the
2607 * administration file created will contain the
2608 * settings contained in this file, modified as
2609 * appropriate to supress any interaction;
2610 * If this is == NULL then the administration file
2611 * created will not contain any extra settings
2612 * Returns: void
2613 * NOTE: Any string returned is placed in new storage for the
2614 * calling method. The caller must use 'free' to dispose
2615 * of the storage once the string is no longer needed.
2616 * NOTE: On any error this function will call 'quit(1)'
2617 */
2618
2619 static void
2620 create_zone_adminfile(char **r_zoneAdminFile, char *a_zoneTempDir,
2621 char *a_admnfile)
2622 {
2623 boolean_t b;
2624
2625 /* entry assertions */
2626
2627 assert(r_zoneAdminFile != (char **)NULL);
2628 assert(a_zoneTempDir != (char *)NULL);
2629 assert(*a_zoneTempDir != '\0');
2630
2631 /* entry debugging info */
2632
2633 echoDebug(DBG_CREATE_ZONE_ADMINFILE, a_zoneTempDir, PSTR(a_admnfile));
2634
2635 /* if temporary name already exists, do not overwrite */
2636
2637 if (*r_zoneAdminFile != (char *)NULL) {
2638 return;
2639 }
2640
2641 /* create temporary name */
2642
2643 *r_zoneAdminFile = tempnam(a_zoneTempDir, "zadmn");
2644 b = z_create_zone_admin_file(*r_zoneAdminFile, a_admnfile);
2645 if (b == B_FALSE) {
2646 progerr(ERR_CREATE_TMPADMIN, *r_zoneAdminFile,
2647 strerror(errno));
2648 quit(1);
2649 /* NOTREACHED */
2650 }
2651
2652 echoDebug(DBG_CREATED_ZONE_ADMINFILE, *r_zoneAdminFile);
2653 }
2654
2655 /*
2656 * Name: create_zone_tempdir
2657 * Description: Given a system temporary directory, create a "zone" specific
2658 * temporary directory and return the path to the directory
2659 * created.
2660 * Arguments: r_zoneTempDir - pointer to handle that will contain a
2661 * string representing the path to the temporary
2662 * directory created - this must be NULL before the
2663 * first call to this function - on subsequent calls
2664 * if the pointer is NOT null then the existing string
2665 * will NOT be overwritten.
2666 * a_zoneTempDir - pointer to string representing the path
2667 * to the system temporary directory to create the
2668 * temporary zone directory in
2669 * Returns: void
2670 * NOTE: Any string returned is placed in new storage for the
2671 * calling method. The caller must use 'free' to dispose
2672 * of the storage once the string is no longer needed.
2673 * NOTE: On any error this function will call 'quit(1)'
2674 * NOTE: This function calls "quitSetZoneTmpdir" on success to
2675 * register the directory created with quit() so that the
2676 * directory will be automatically deleted on exit.
2677 */
2678
2679 static void
2680 create_zone_tempdir(char **r_zoneTempDir, char *a_tmpdir)
2681 {
2682 boolean_t b;
2683
2684 /* entry assertions */
2685
2686 assert(r_zoneTempDir != (char **)NULL);
2687 assert(a_tmpdir != (char *)NULL);
2688 assert(*a_tmpdir != '\0');
2689
2690 /* entry debugging info */
2691
2692 echoDebug(DBG_CREATE_ZONE_TEMPDIR, a_tmpdir);
2693
2694 /* if temporary directory already exists, do not overwrite */
2695
2696 if (*r_zoneTempDir != (char *)NULL) {
2697 return;
2698 }
2699
2700 /* create temporary directory */
2701
2702 b = setup_temporary_directory(r_zoneTempDir, a_tmpdir, "ztemp");
2703 if (b == B_FALSE) {
2704 progerr(ERR_ZONETEMPDIR, a_tmpdir, strerror(errno));
2705 quit(1);
2706 /* NOTREACHED */
2707 }
2708
2709 /* register with quit() so directory is removed on exit */
2710
2711 quitSetZoneTmpdir(*r_zoneTempDir);
2712
2713 /* exit debugging info */
2714
2715 echoDebug(DBG_CREATED_ZONE_TEMPDIR, *r_zoneTempDir);
2716 }
2717
2718 /*
2719 * Name: continue_installation
2720 * Description: Called from within a loop that is installing packages,
2721 * this function examines various global variables and decides
2722 * whether or not to ask an appropriate question, and wait for
2723 * and appropriate reply.
2724 * Arguments: <<global variables>>
2725 * Returns: B_TRUE - continue processing with next package
2726 * B_FALSE - do not continue processing with next package
2727 */
2728
2729 static boolean_t
2730 continue_installation(void)
2731 {
2732 char ans[MAX_INPUT];
2733 int n;
2734
2735 /* return TRUE if not interrupted */
2736
2737 if (!interrupted) {
2738 return (B_TRUE);
2739 }
2740
2741 /*
2742 * process interrupted - determine whether or not to continue
2743 */
2744
2745 /* output appropriate interrupted message */
2746
2747 if (askflag) {
2748 echo(npkgs == 1 ? MSG_1MORE_PROC : MSG_MORE_PROC, npkgs);
2749 } else {
2750 echo(npkgs == 1 ? MSG_1MORE_INST : MSG_MORE_INST, npkgs);
2751 }
2752
2753 /* if running with no interaction (-n) do not ask question */
2754
2755 if (nointeract) {
2756 /* if admin required return 'dont continue' */
2757 if (needconsult) {
2758 return (B_FALSE);
2759 }
2760 ckquit = 1;
2761 return (B_TRUE);
2762 }
2763
2764 /* interaction possible: ask question */
2765
2766 ckquit = 0;
2767 n = ckyorn(ans, NULL, NULL, NULL, ASK_CONTINUE_ADD);
2768 if (n != 0) {
2769 quit(n);
2770 /* NOTREACHED */
2771 }
2772 ckquit = 1;
2773 if (strchr("yY", *ans) == NULL) {
2774 return (B_FALSE);
2775 }
2776 return (B_TRUE);
2777 }
2778
2779 /*
2780 * package can be in a number of formats:
2781 * - file containing package stream (pkgadd -d file [pkgs])
2782 * - directory containing packages (pkgadd -d /dir [pkgs])
2783 * - device containing packages (pkgadd -d diskette1 [pkgs])
2784 * non-global zones can be passed open files and strings as arguments
2785 * - for file containing package stream
2786 * -- the stream can be passed directly to the non-global zone
2787 * - for directory
2788 * -- convert packages to datastream to pass to the non-global zone
2789 * - for device
2790 * -- ?
2791 */
2792
2793 static boolean_t
2794 unpack_and_check_packages(char **a_pkgList, char *a_idsName, char *a_packageDir)
2795 {
2796 int savenpkgs = npkgs;
2797 int i;
2798 CAF_T flags = 0;
2799
2800 /* entry assertions */
2801
2802 assert(a_pkgList != (char **)NULL);
2803
2804 /* entry debugging info */
2805
2806 echoDebug(DBG_UNPACKCHECK_ENTRY);
2807 echoDebug(DBG_UNPACKCHECK_ARGS, PSTR(a_idsName), PSTR(a_packageDir));
2808
2809 /*
2810 * set flags for applicability check
2811 */
2812
2813 /* determine if running in the global zone */
2814
2815 if (z_running_in_global_zone() == B_TRUE) {
2816 flags |= CAF_IN_GLOBAL_ZONE;
2817 }
2818
2819 /* set -G flag */
2820
2821 if (globalZoneOnly == B_TRUE) {
2822 flags |= CAF_SCOPE_GLOBAL;
2823 }
2824
2825 /*
2826 * for each package to install:
2827 * - if packages from datastream, unpack package into package dir
2828 * - check applicability of installing package on this system/zone
2829 */
2830
2831 for (i = 0; (pkginst = a_pkgList[i]) != NULL; i++) {
2832 if (a_idsName != (char *)NULL) {
2833 /* create stream out of package if not already one */
2834 if (unpack_package_from_stream(a_idsName, pkginst,
2835 a_packageDir) == B_FALSE) {
2836 progerr(ERR_CANNOT_UNPACK_PKGSTRM,
2837 PSTR(pkginst), PSTR(a_idsName),
2838 PSTR(a_packageDir));
2839
2840 npkgs = savenpkgs;
2841 return (B_FALSE);
2842 }
2843 } else {
2844 echoDebug(DBG_PKG_IN_DIR, pkginst, a_packageDir);
2845 }
2846
2847 /* check package applicability */
2848 if (check_applicability(a_packageDir,
2849 pkginst, get_inst_root(), flags) == B_FALSE) {
2850 progerr(ERR_PKG_NOT_INSTALLABLE, pkginst);
2851 npkgs = savenpkgs;
2852 return (B_FALSE);
2853 }
2854 npkgs--;
2855 }
2856
2857 npkgs = savenpkgs;
2858 return (B_TRUE);
2859 }
2860
2861 /*
2862 * returns:
2863 * B_TRUE - package list generated
2864 * B_FALSE - failed to generate package list
2865 * Will call quit(n) on fatal error.
2866 */
2867
2868 static boolean_t
2869 get_package_list(char ***r_pkgList, char **a_argv, char *a_categories,
2870 char **a_categoryList, char *a_idsName, int *r_repeat)
2871 {
2872 int n;
2873
2874 /* entry assertions */
2875
2876 assert(r_repeat != (int *)NULL);
2877
2878 /* entry debugging info */
2879
2880 echoDebug(DBG_GETPKGLIST_ENTRY);
2881 echoDebug(DBG_GETPKGLIST_ARGS, PSTR(a_idsName), PSTR(pkgdev.dirname),
2882 *r_repeat);
2883
2884 /*
2885 * get the list of the packages to add
2886 */
2887
2888 n = pkgGetPackageList(r_pkgList, a_argv, optind, a_categories,
2889 a_categoryList, &pkgdev);
2890
2891 switch (n) {
2892 case -1: /* no packages found */
2893 echoDebug(DBG_PKGLIST_NONFOUND, PSTR(a_idsName),
2894 pkgdev.dirname);
2895 return (B_FALSE);
2896
2897 case 0: /* packages found */
2898 break;
2899
2900 default: /* "quit" error */
2901 echoDebug(DBG_PKGLIST_ERROR, PSTR(a_idsName),
2902 pkgdev.dirname, n);
2903 quit(n);
2904 /* NOTREACHED */
2905 }
2906
2907 /* order package list if input data stream specified */
2908
2909 if (a_idsName) {
2910 ds_order(*r_pkgList);
2911 }
2912
2913 return (B_TRUE);
2914 }
2915
2916 /*
2917 * Name: install_in_one_zone
2918 * Description: Install a single package in a single zone
2919 * Arguments: a_zoneName - pointer to string representing the name of the
2920 * zone to install the package into.
2921 * a_idsName - pointer to string representing the data stream
2922 * device (input data stream) containing the package to
2923 * be installed.
2924 * If this is == NULL the package is assumed to be
2925 * spooled in the zone temporary directory.
2926 * a_zoneAdminFile - pointer to string representing the admin
2927 * file to pass to pkginstall when installing the package.
2928 * If this is == NULL no admin file is given to pkginstall.
2929 * a_zoneTempDir - pointer to string representing the temporary
2930 * directory in which spooled packages can be found if
2931 * a_idsName is == NULL.
2932 * a_altBinDir - pointer to string representing an alternative
2933 * binary location directory to pass to pkginstall.
2934 * If this is == NULL no alternative binary location is
2935 * passed to pkginstall.
2936 * a_scratchName - pointer to string representing the name of the
2937 * scratch zone to use for installation.
2938 * a_zoneState - state of the zone; must be mounted or running.
2939 * a_tmpzn - B_TRUE when this zone is booted by the package
2940 * command or B_FALSE if it was running before.
2941 * Returns: void
2942 * NOTE: As a side effect, "ckreturn" is called on the result returned
2943 * from running 'pkginstall' in the zone; this sets several global
2944 * variables which allows the caller to determine the result of
2945 * the installation operation.
2946 */
2947
2948 static void
2949 install_in_one_zone(char *a_zoneName, char *a_idsName,
2950 char *a_zoneAdminFile, char *a_zoneTempDir,
2951 char *a_altBinDir, zone_state_t a_zoneState, boolean_t a_tmpzn)
2952 {
2953 char zoneStreamName[PATH_MAX] = {'\0'};
2954 int n;
2955
2956 /* entry assertions */
2957
2958 assert(a_zoneName != (char *)NULL);
2959 assert(*a_zoneName != '\0');
2960
2961 /* entry debugging info */
2962
2963 echoDebug(DBG_INSTINONEZONE_ENTRY);
2964 echoDebug(DBG_INSTINONEZONE_ARGS, a_zoneName, PSTR(a_idsName),
2965 PSTR(a_zoneAdminFile), PSTR(a_zoneTempDir),
2966 PSTR(a_altBinDir));
2967
2968 /* echo operation to perform to stdout */
2969
2970 echo(MSG_INSTALL_PKG_IN_ZONE, pkginst, a_zoneName);
2971
2972 /* determine path to the package stream */
2973
2974 if (a_idsName == (char *)NULL) {
2975 /* locate temp stream created earlier */
2976 (void) snprintf(zoneStreamName, sizeof (zoneStreamName),
2977 "%s/%s.dstream", a_zoneTempDir, pkginst);
2978 } else {
2979 /* use stream passed in on command line */
2980 (void) snprintf(zoneStreamName, sizeof (zoneStreamName),
2981 "%s", a_idsName);
2982 }
2983
2984 echoDebug(DBG_INSTALL_IN_ZONE, pkginst, a_zoneName, zoneStreamName);
2985
2986 n = pkgZoneInstall(a_zoneName, a_zoneState, zoneStreamName,
2987 a_altBinDir, a_zoneAdminFile, a_tmpzn);
2988
2989 /* set success/fail condition variables */
2990
2991 ckreturn(n);
2992
2993 /* exit debugging info */
2994
2995 echoDebug(DBG_INSTALL_FLAG_VALUES, "after install", admnflag, doreboot,
2996 failflag, interrupted, intrflag, ireboot, needconsult,
2997 nullflag, warnflag);
2998 }
2999
3000 /*
3001 * Name: install_in_zones
3002 * Description: Install a single package in the zones that are running from
3003 * a list of zones
3004 * Arguments: a_zlst - list of zones to install the package into
3005 * a_idsName - pointer to string representing the data stream
3006 * device (input data stream) containing the package to
3007 * be installed.
3008 * If this is == NULL the package is assumed to be
3009 * spooled in the zone temporary directory.
3010 * a_altBinDir - pointer to string representing an alternative
3011 * binary location directory to pass to pkginstall.
3012 * If this is == NULL no alternative binary location is
3013 * passed to pkginstall.
3014 * a_zoneAdminFile - pointer to string representing the admin
3015 * file to pass to pkginstall when installing the package.
3016 * If this is == NULL no admin file is given to pkginstall.
3017 * a_zoneTempDir - pointer to string representing the temporary
3018 * directory in which spooled packages can be found if
3019 * a_idsName is == NULL.
3020 */
3021
3022 static int
3023 install_in_zones(zoneList_t a_zlst, char *a_idsName, char *a_altBinDir,
3024 char *a_zoneAdminFile, char *a_zoneTempDir)
3025 {
3026 char *zoneName;
3027 int zoneIndex;
3028 int zonesSkipped = 0;
3029 zone_state_t zst;
3030
3031 /* entry assertions */
3032
3033 assert(a_zlst != (zoneList_t)NULL);
3034
3035 /* entry debugging info */
3036
3037 echoDebug(DBG_INSTALLINZONES_ENTRY);
3038 echoDebug(DBG_INSTALLINZONES_ARGS, PSTR(a_idsName),
3039 PSTR(a_zoneAdminFile), PSTR(a_zoneTempDir));
3040
3041 /* process each zone in the list */
3042
3043 for (zoneIndex = 0;
3044 (zoneName = z_zlist_get_zonename(a_zlst, zoneIndex)) != NULL;
3045 zoneIndex++) {
3046
3047 /* skip the zone if it is NOT running */
3048
3049 zst = z_zlist_get_current_state(a_zlst, zoneIndex);
3050 if (zst != ZONE_STATE_RUNNING && zst != ZONE_STATE_MOUNTED) {
3051 zonesSkipped++;
3052 echoDebug(DBG_SKIPPING_ZONE, zoneName);
3053 continue;
3054 }
3055
3056 /* install the package in this zone */
3057
3058 install_in_one_zone(z_zlist_get_scratch(a_zlst, zoneIndex),
3059 a_idsName, a_zoneAdminFile, a_zoneTempDir, a_altBinDir,
3060 zst, B_FALSE);
3061 }
3062
3063 return (zonesSkipped);
3064 }
3065
3066 /*
3067 * Name: boot_and_install_in_zones
3068 * Description: Install a single package in the zones that are NOT running from
3069 * a list of zones - each zone is booted, the package installed,
3070 * and the zone is halted
3071 * Arguments: a_zlst - list of zones to install the package into
3072 * a_idsName - pointer to string representing the data stream
3073 * device (input data stream) containing the package to
3074 * be installed.
3075 * If this is == NULL the package is assumed to be
3076 * spooled in the zone temporary directory.
3077 * a_altBinDir - pointer to string representing an alternative
3078 * binary location directory to pass to pkginstall.
3079 * If this is == NULL no alternative binary location is
3080 * passed to pkginstall.
3081 * a_zoneAdminFile - pointer to string representing the admin
3082 * file to pass to pkginstall when installing the package.
3083 * If this is == NULL no admin file is given to pkginstall.
3084 * a_zoneTempDir - pointer to string representing the temporary
3085 * directory in which spooled packages can be found if
3086 * a_idsName is == NULL.
3087 */
3088
3089 static int
3090 boot_and_install_in_zones(zoneList_t a_zlst, char *a_idsName, char *a_altBinDir,
3091 char *a_zoneAdminFile, char *a_zoneTempDir)
3092 {
3093 boolean_t b;
3094 char *zoneName;
3095 int zoneIndex;
3096 int zonesSkipped = 0;
3097 zone_state_t zst;
3098
3099 /* entry assertions */
3100
3101 assert(a_zlst != (zoneList_t)NULL);
3102
3103 /* entry debugging info */
3104
3105 echoDebug(DBG_BOOTINSTALLINZONES_ENTRY);
3106 echoDebug(DBG_BOOTINSTALLINZONES_ARGS, PSTR(a_idsName),
3107 PSTR(a_zoneAdminFile), PSTR(a_zoneTempDir));
3108
3109 /* process each zone in the list */
3110
3111 for (zoneIndex = 0;
3112 (zoneName = z_zlist_get_zonename(a_zlst, zoneIndex)) != NULL;
3113 zoneIndex++) {
3114
3115 /* skip the zone if it IS running */
3116
3117 zst = z_zlist_get_current_state(a_zlst, zoneIndex);
3118 if (zst == ZONE_STATE_RUNNING || zst == ZONE_STATE_MOUNTED) {
3119 echoDebug(DBG_SKIPPING_ZONE_BOOT, zoneName);
3120 continue;
3121 }
3122
3123 /* skip the zone if it is NOT bootable */
3124
3125 if (z_zlist_is_zone_runnable(a_zlst, zoneIndex) == B_FALSE) {
3126 echo(MSG_SKIPPING_ZONE_NOT_RUNNABLE, zoneName);
3127 echoDebug(DBG_SKIPPING_ZONE_NOT_RUNNABLE, zoneName);
3128 continue;
3129 }
3130
3131 /* mount up the zone */
3132
3133 echo(MSG_BOOTING_ZONE, zoneName);
3134 echoDebug(DBG_BOOTING_ZONE, zoneName);
3135
3136 b = z_zlist_change_zone_state(a_zlst, zoneIndex,
3137 ZONE_STATE_MOUNTED);
3138 if (b == B_FALSE) {
3139 progerr(ERR_CANNOT_BOOT_ZONE, zoneName);
3140 /* set fatal error return condition */
3141 ckreturn(1);
3142 zonesSkipped++;
3143 continue;
3144 }
3145
3146 /* install the package in this zone */
3147
3148 install_in_one_zone(z_zlist_get_scratch(a_zlst, zoneIndex),
3149 a_idsName, a_zoneAdminFile, a_zoneTempDir, a_altBinDir,
3150 ZONE_STATE_MOUNTED, B_TRUE);
3151
3152 /* restore original state of zone */
3153
3154 echo(MSG_RESTORE_ZONE_STATE, zoneName);
3155 echoDebug(DBG_RESTORE_ZONE_STATE, zoneName);
3156
3157 b = z_zlist_restore_zone_state(a_zlst, zoneIndex);
3158 }
3159
3160 return (zonesSkipped);
3161 }
3162
3163 /*
3164 * Name: pkginstall_check_in_one_zone
3165 * Description: Do a pre install check of a single package in a single zone
3166 * Arguments: a_zoneName - pointer to string representing the name of the
3167 * zone to check install the package in.
3168 * a_idsName - pointer to string representing the data stream
3169 * device (input data stream) containing the package to
3170 * be check installed.
3171 * If this is == NULL the package is assumed to be
3172 * spooled in the zone temporary directory.
3173 * a_zoneAdminFile - pointer to string representing the admin
3174 * file to pass to pkginstall when installing the package.
3175 * If this is == NULL no admin file is given to pkginstall.
3176 * a_zoneTempDir - pointer to string representing the temporary
3177 * directory in which spooled packages can be found if
3178 * a_idsName is == NULL.
3179 * a_altBinDir - pointer to string representing an alternative
3180 * binary location directory to pass to pkginstall.
3181 * If this is == NULL no alternative binary location is
3182 * passed to pkginstall.
3183 * a_scratchName - pointer to string representing the name of the
3184 * scratch zone to use for installation.
3185 * a_zoneState - state of the zone; must be mounted or running.
3186 * a_tmpzn - B_TRUE when this zone is booted by the package
3187 * command or B_FALSE if it was running before.
3188 * Returns: void
3189 * NOTE: As a side effect, "ckreturn" is called on the result returned
3190 * from running 'pkginstall' in the zone; this sets several global
3191 * variables which allows the caller to determine the result of
3192 * the pre installation check operation.
3193 */
3194
3195 static void
3196 pkginstall_check_in_one_zone(char *a_zoneName,
3197 char *a_idsName, char *a_zoneAdminFile, char *a_zoneTempDir,
3198 char *a_altBinDir, char *a_scratchName, zone_state_t a_zoneState,
3199 boolean_t a_tmpzn)
3200 {
3201 char preinstallcheckPath[PATH_MAX+1];
3202 char zoneStreamName[PATH_MAX] = {'\0'};
3203 int n;
3204
3205 echo(MSG_CHECKINSTALL_PKG_IN_ZONE, pkginst, a_zoneName);
3206 echoDebug(MSG_CHECKINSTALL_PKG_IN_ZONE, pkginst, a_zoneName);
3207
3208 (void) snprintf(preinstallcheckPath, sizeof (preinstallcheckPath),
3209 "%s/%s.%s.preinstallcheck.txt", a_zoneTempDir, pkginst,
3210 a_zoneName);
3211
3212 if (a_idsName == (char *)NULL) {
3213 /* locate temporary stream created earlier */
3214 (void) snprintf(zoneStreamName, sizeof (zoneStreamName),
3215 "%s/%s.dstream", a_zoneTempDir, pkginst);
3216 } else {
3217 (void) snprintf(zoneStreamName, sizeof (zoneStreamName),
3218 "%s", a_idsName);
3219 }
3220
3221 echoDebug(DBG_CHECKINSTALL_IN_ZONE, pkginst, a_zoneName,
3222 zoneStreamName);
3223
3224 n = pkgZoneCheckInstall(a_scratchName, a_zoneState, zoneStreamName,
3225 a_altBinDir, a_zoneAdminFile, preinstallcheckPath, a_tmpzn);
3226
3227 /* set success/fail condition variables */
3228
3229 ckreturn(n);
3230
3231 echoDebug(DBG_INSTALL_FLAG_VALUES, "after preinstall check",
3232 admnflag, doreboot, failflag, interrupted, intrflag,
3233 ireboot, needconsult, nullflag, warnflag);
3234 }
3235
3236 /*
3237 * Name: pkginstall_check_in_zones
3238 * Description: Check installation of a single package in the zones that
3239 * are running from a list of zones
3240 * Arguments: a_zlst - list of zones to check install the package
3241 * a_idsName - pointer to string representing the data stream
3242 * device (input data stream) containing the package to
3243 * be check installed.
3244 * If this is == NULL the package is assumed to be
3245 * spooled in the zone temporary directory.
3246 * a_altBinDir - pointer to string representing an alternative
3247 * binary location directory to pass to pkginstall.
3248 * If this is == NULL no alternative binary location is
3249 * passed to pkginstall.
3250 * a_zoneAdminFile - pointer to string representing the admin
3251 * file to pass to pkginstall when checking the installing
3252 * of the package.
3253 * If this is == NULL no admin file is given to pkginstall.
3254 * a_zoneTempDir - pointer to string representing the temporary
3255 * directory in which spooled packages can be found if
3256 * a_idsName is == NULL.
3257 */
3258
3259 static int
3260 pkginstall_check_in_zones(zoneList_t a_zlst, char *a_idsName, char *a_altBinDir,
3261 char *a_zoneAdminFile, char *a_zoneTempDir)
3262 {
3263 char *zoneName;
3264 int zoneIndex;
3265 int zonesSkipped = 0;
3266 zone_state_t zst;
3267
3268 for (zoneIndex = 0;
3269 (zoneName = z_zlist_get_zonename(a_zlst, zoneIndex)) != NULL;
3270 zoneIndex++) {
3271
3272 zst = z_zlist_get_current_state(a_zlst, zoneIndex);
3273 if (zst != ZONE_STATE_RUNNING && zst != ZONE_STATE_MOUNTED) {
3274 zonesSkipped++;
3275 echoDebug(DBG_SKIPPING_ZONE, zoneName);
3276 continue;
3277 }
3278
3279 pkginstall_check_in_one_zone(zoneName, a_idsName,
3280 a_zoneAdminFile, a_zoneTempDir, a_altBinDir,
3281 z_zlist_get_scratch(a_zlst, zoneIndex), zst, B_FALSE);
3282 }
3283
3284 return (zonesSkipped);
3285 }
3286
3287 /*
3288 * Name: boot_and_pkginstall_check_in_zones
3289 * Description: Check installation of a single package in the zones that
3290 * are NOT running from a list of zones - each zone is booted,
3291 * the package installation is checked, and the zone is halted.
3292 * Arguments: a_zlst - list of zones to install the package into
3293 * a_idsName - pointer to string representing the data stream
3294 * device (input data stream) containing the package to
3295 * be check installed.
3296 * If this is == NULL the package is assumed to be
3297 * spooled in the zone temporary directory.
3298 * a_altBinDir - pointer to string representing an alternative
3299 * binary location directory to pass to pkginstall.
3300 * If this is == NULL no alternative binary location is
3301 * passed to pkginstall.
3302 * a_zoneAdminFile - pointer to string representing the admin
3303 * file to pass to pkginstall when check installing the
3304 * package.
3305 * If this is == NULL no admin file is given to pkginstall.
3306 * a_zoneTempDir - pointer to string representing the temporary
3307 * directory in which spooled packages can be found if
3308 * a_idsName is == NULL.
3309 */
3310
3311 static int
3312 boot_and_pkginstall_check_in_zones(zoneList_t a_zlst, char *a_idsName,
3313 char *a_altBinDir, char *a_zoneAdminFile, char *a_zoneTempDir)
3314 {
3315 int zoneIndex;
3316 int zonesSkipped = 0;
3317 char *zoneName;
3318 boolean_t b;
3319 zone_state_t zst;
3320
3321 /* entry assertions */
3322
3323 assert(a_zlst != (zoneList_t)NULL);
3324
3325 /* entry debugging info */
3326
3327 echoDebug(DBG_BOOTCHECKINSTALLINZONES_ENTRY);
3328 echoDebug(DBG_BOOTCHECKINSTALLINZONES_ARGS, PSTR(a_idsName),
3329 PSTR(a_zoneAdminFile), PSTR(a_zoneTempDir));
3330
3331 /* process each zone in the list */
3332
3333 for (zoneIndex = 0;
3334 (zoneName = z_zlist_get_zonename(a_zlst, zoneIndex)) != NULL;
3335 zoneIndex++) {
3336
3337 /* skip the zone if it IS running */
3338
3339 zst = z_zlist_get_current_state(a_zlst, zoneIndex);
3340 if (zst == ZONE_STATE_RUNNING || zst == ZONE_STATE_MOUNTED) {
3341 echoDebug(DBG_SKIPPING_ZONE_BOOT, zoneName);
3342 continue;
3343 }
3344
3345 /* skip the zone if it is NOT bootable */
3346
3347 if (z_zlist_is_zone_runnable(a_zlst, zoneIndex) == B_FALSE) {
3348 echo(MSG_SKIPPING_ZONE_NOT_RUNNABLE, zoneName);
3349 echoDebug(DBG_SKIPPING_ZONE_NOT_RUNNABLE, zoneName);
3350 continue;
3351 }
3352
3353 /* mount up the zone */
3354
3355 echo(MSG_BOOTING_ZONE, zoneName);
3356 echoDebug(DBG_BOOTING_ZONE, zoneName);
3357
3358 b = z_zlist_change_zone_state(a_zlst, zoneIndex,
3359 ZONE_STATE_MOUNTED);
3360 if (b == B_FALSE) {
3361 progerr(ERR_CANNOT_BOOT_ZONE, zoneName);
3362 /* set fatal error return condition */
3363 ckreturn(1);
3364 zonesSkipped++;
3365 continue;
3366 }
3367
3368 /* pre-installation check of the package in this zone */
3369
3370 pkginstall_check_in_one_zone(zoneName, a_idsName,
3371 a_zoneAdminFile, a_zoneTempDir, a_altBinDir,
3372 z_zlist_get_scratch(a_zlst, zoneIndex),
3373 ZONE_STATE_MOUNTED, B_TRUE);
3374
3375 /* restore original state of zone */
3376
3377 echo(MSG_RESTORE_ZONE_STATE, zoneName);
3378 echoDebug(DBG_RESTORE_ZONE_STATE, zoneName);
3379
3380 b = z_zlist_restore_zone_state(a_zlst, zoneIndex);
3381 }
3382
3383 return (zonesSkipped);
3384 }
3385
3386 /*
3387 * Function: add_packages_in_global_with_zones
3388 * Description: call this function to add a list of packages in the global zone
3389 * when one or more non-global zones exist
3390 * returns:
3391 * B_TRUE to process next data stream
3392 * B_FALSE to exit
3393 */
3394
3395 static boolean_t
3396 add_packages_in_global_with_zones(char **a_pkgList,
3397 char *a_idsName, int a_repeat, char *a_altBinDir,
3398 char *a_device, zoneList_t a_zlst)
3399 {
3400 static char *zoneTempDir = (char *)NULL;
3401 static char *zoneAdminFile = (char *)NULL;
3402
3403 boolean_t b;
3404 char *packageDir;
3405 char instdir[PATH_MAX];
3406 char respfile_path[PATH_MAX];
3407 char zoneStreamName[PATH_MAX] = {'\0'};
3408 int i;
3409 int n;
3410 int savenpkgs = npkgs;
3411 int zonesSkipped;
3412 boolean_t globalPresent;
3413
3414 /* entry assertions */
3415
3416 assert(a_pkgList != (char **)NULL);
3417 assert(a_zlst != (zoneList_t)NULL);
3418
3419 echoDebug(DBG_ADDPACKAGES_GZ_W_LZ_ENTRY);
3420 echoDebug(DBG_ADDPACKAGES_GZ_W_LZ_ARGS, npkgs,
3421 PSTR(a_idsName), a_repeat, PSTR(a_device));
3422
3423 /* create temporary directory for use by zone operations */
3424
3425 create_zone_tempdir(&zoneTempDir, tmpdir);
3426
3427 /* create hands off settings admin file for use in a non-global zone */
3428
3429 create_zone_adminfile(&zoneAdminFile, zoneTempDir, admnfile);
3430
3431 /* determine directory where packages can be found */
3432
3433 if (a_idsName == (char *)NULL) {
3434 /* no stream - directory containing packages provided */
3435 packageDir = pkgdev.dirname;
3436 } else {
3437 packageDir = zoneTempDir;
3438 }
3439
3440 /* unpack and check all packages */
3441
3442 b = unpack_and_check_packages(a_pkgList, a_idsName, packageDir);
3443 if (b != B_TRUE) {
3444 quit(1);
3445 }
3446
3447 /*
3448 * if the packages are contained in a directory, convert the
3449 * packages into individual streams because pkgZoneInstall is only able
3450 * to pass a stream to the non-global zone's pkginstall command.
3451 * After this code is executed:
3452 * if the original input was a datastream:
3453 * -> that datastream has been unpacked into "instdir"
3454 * if the original input was a directory with packages in it:
3455 * -> those packages have been placed into a single datastream
3456 */
3457
3458 if (a_idsName == (char *)NULL) {
3459 for (i = 0; (pkginst = a_pkgList[i]) != NULL; i++) {
3460 char *pkgs[2];
3461
3462 /* package is not a stream - create one */
3463
3464 (void) snprintf(zoneStreamName, sizeof (zoneStreamName),
3465 "%s/%s.dstream", zoneTempDir, pkginst);
3466
3467 echoDebug(DBG_CONVERTING_PKG, packageDir, pkginst,
3468 zoneStreamName);
3469
3470 /* set up list of packages to be this package only */
3471
3472 pkgs[0] = pkginst;
3473 pkgs[1] = (char *)NULL;
3474
3475 n = pkgtrans(packageDir, zoneStreamName, pkgs,
3476 PT_SILENT|PT_ODTSTREAM);
3477 if (n != 0) {
3478 progerr(ERR_CANNOT_CONVERT_PKGSTRM,
3479 pkginst, packageDir, zoneStreamName);
3480 quit(1);
3481 }
3482 npkgs--;
3483 }
3484 npkgs = savenpkgs;
3485 }
3486
3487 /*
3488 * Phase I - run collect dependency information for all packages for all
3489 * zones - this involves running pkginstall with the "preinstallcheck"
3490 * option which causes all dependency checks to be performed without
3491 * actually doing the installation of the packages. This information is
3492 * gathered in the zone temporary directory and is used later to present
3493 * the dependency check results to the system administrator depending
3494 * on the administration settings.
3495 */
3496
3497 for (i = 0; (pkginst = a_pkgList[i]) != NULL; i++) {
3498
3499 /* reset interrupted flag before calling pkginstall */
3500
3501 interrupted = 0; /* last action was NOT quit */
3502
3503 /*
3504 * if this package is marked "install in this zone only", then
3505 * do not check dependencies in any other zone
3506 */
3507
3508 if (pkgPackageIsThisZone(pkginst) == B_TRUE) {
3509 echoDebug(DBG_VERIFY_SKIP_THISZONE, pkginst);
3510 npkgs--;
3511 continue;
3512 }
3513
3514 /*
3515 * if operation failed in global zone do not propagate
3516 * to any non-global zones
3517 */
3518
3519 if (interrupted != 0) {
3520 echo(MSG_CHECKINSTALL_INTERRUPT_B4_Z, pkginst);
3521 echoDebug(MSG_CHECKINSTALL_INTERRUPT_B4_Z, pkginst);
3522 break;
3523 }
3524
3525 echoDebug(DBG_INSTALL_FLAG_VALUES, "after pkginstall",
3526 admnflag, doreboot, failflag, interrupted, intrflag,
3527 ireboot, needconsult, nullflag, warnflag);
3528
3529 /*
3530 * call pkginstall to verify this package for all non-global
3531 * zones that are currently booted
3532 */
3533
3534 zonesSkipped = pkginstall_check_in_zones(a_zlst, a_idsName,
3535 a_altBinDir, admnfile, zoneTempDir);
3536
3537 /*
3538 * if any zones were skipped (becuase they are not currently
3539 * booted), boot each zone one at a time and call pkginstall
3540 * to verify this package for each such non-global zone
3541 */
3542
3543 if (zonesSkipped > 0) {
3544 echoDebug(DBG_ZONES_SKIPPED, zonesSkipped);
3545
3546 zonesSkipped =
3547 boot_and_pkginstall_check_in_zones(a_zlst,
3548 a_idsName, a_altBinDir, admnfile,
3549 zoneTempDir);
3550
3551 if (zonesSkipped > 0) {
3552 progerr(ERR_INSTALL_ZONES_SKIPPED,
3553 zonesSkipped);
3554 }
3555 }
3556
3557 npkgs--;
3558 }
3559
3560 /*
3561 * At this point, all of the dependency information has been gathered
3562 * and is ready to be analyzed. This function processes all of that
3563 * dependency information and presents the results to the system
3564 * administrator, depending on the current administration settings.
3565 */
3566
3567 i = preinstall_verify(a_pkgList, a_zlst, zoneTempDir);
3568 if (i != 0) {
3569 /* dependency checks failed - exit */
3570 quit(i);
3571 }
3572
3573 npkgs = savenpkgs;
3574
3575 /*
3576 * reset all error return condition variables that may have been
3577 * set during package installation dependency checking so that they
3578 * do not reflect on the success/failure of the actual package
3579 * installation operations
3580 */
3581
3582 resetreturn();
3583
3584 /*
3585 * At this point, all of the dependency checking is completed, and
3586 * the installation of the packages can proceed. Install each package
3587 * one at a time, starting with the global zone, and the for each
3588 * non-global zone that is booted, and then for each non-global zone
3589 * that is not currently booted.
3590 */
3591
3592 globalPresent = z_on_zone_spec(GLOBAL_ZONENAME);
3593
3594 for (i = 0; (pkginst = a_pkgList[i]) != NULL; i++) {
3595 /*
3596 * if immediate reboot required from last package and this is
3597 * not 'pkgask' then suspend installation of remaining packages
3598 */
3599
3600 if ((ireboot != 0) && (askflag == 0)) {
3601 ptext(stderr, MSG_SUSPEND_ADD, pkginst);
3602 continue;
3603 }
3604
3605 /*
3606 * handle interrupt if the previous pkginstall was interrupted
3607 */
3608
3609 if (continue_installation() == B_FALSE) {
3610 return (B_FALSE);
3611 }
3612
3613 /*
3614 * if pkgask, handle response file creation:
3615 * - if the response file is a directory, then create a path to
3616 * -- a package instance within the response file directory.
3617 * - If the response file is NOT a directory, if more than one
3618 * -- package is to be installed.
3619 */
3620
3621 if ((askflag != 0) && (respdir != (char *)NULL)) {
3622 (void) snprintf(respfile_path, sizeof (respfile_path),
3623 "%s/%s", respdir, pkginst);
3624 respfile = respfile_path;
3625 }
3626
3627 echo(MSG_PROC_INST, pkginst, a_device);
3628
3629 /*
3630 * If we're installing another package in the same
3631 * session, the second through nth pkginstall, must
3632 * continue from where the prior one left off. For this
3633 * reason, the continuation feature (implied by the
3634 * nature of the command) is used for the remaining
3635 * packages.
3636 */
3637
3638 if ((i == 1) && (pkgdrtarg != (char *)NULL)) {
3639 pkgcontsrc = pkgdrtarg;
3640 }
3641
3642 if (globalPresent) {
3643 /*
3644 * call pkginstall for this package for the global zone
3645 */
3646
3647 echo(MSG_INSTALLING_PKG_IN_GZ, pkginst);
3648
3649 /* reset interrupted flag before calling pkginstall */
3650
3651 interrupted = 0; /* last action was NOT quit */
3652
3653 n = pkgInstall(get_inst_root(), NULL, packageDir,
3654 a_altBinDir);
3655
3656 /* set success/fail condition variables */
3657
3658 ckreturn(n);
3659
3660 /*
3661 * if operation failed in global zone do not propagate
3662 * to any non-global zones
3663 */
3664
3665 if (interrupted != 0) {
3666 echo(MSG_INSTALL_INTERRUPT_B4_ZONES, pkginst);
3667 echoDebug(MSG_INSTALL_INTERRUPT_B4_ZONES,
3668 pkginst);
3669 break;
3670 }
3671 }
3672
3673 /*
3674 * if this package is marked "install in this zone only",
3675 * then only need to install the package in the global zone;
3676 * skip installation in any non-global zones.
3677 */
3678
3679 if (pkgPackageIsThisZone(pkginst) == B_TRUE) {
3680 echoDebug(DBG_INSTALL_SKIP_THISZONE, pkginst);
3681 npkgs--;
3682 continue;
3683 }
3684
3685 echoDebug(DBG_INSTALL_FLAG_VALUES, "install in running zones",
3686 admnflag, doreboot, failflag, interrupted, intrflag,
3687 ireboot, needconsult, nullflag, warnflag);
3688
3689 /* install package in currently booted zones */
3690
3691 zonesSkipped = install_in_zones(a_zlst, a_idsName, a_altBinDir,
3692 zoneAdminFile, zoneTempDir);
3693
3694 /* install package in zones that are not currently booted */
3695
3696 if (zonesSkipped > 0) {
3697 echoDebug(DBG_ZONES_SKIPPED, zonesSkipped);
3698
3699 zonesSkipped = boot_and_install_in_zones(a_zlst,
3700 a_idsName, a_altBinDir, zoneAdminFile,
3701 zoneTempDir);
3702
3703 if (zonesSkipped > 0) {
3704 progerr(ERR_INSTALL_ZONES_SKIPPED,
3705 zonesSkipped);
3706 }
3707 }
3708
3709 /*
3710 * package completely installed - remove any temporary stream
3711 * of the package that might have been created
3712 */
3713
3714 if (a_idsName == (char *)NULL) {
3715 /* locate temporary stream created earlier */
3716 (void) snprintf(zoneStreamName, sizeof (zoneStreamName),
3717 "%s/%s.dstream", zoneTempDir, pkginst);
3718 /* remove stream - no longer needed */
3719 echoDebug(DBG_REMOVING_DSTREAM_PKGDIR, zoneStreamName,
3720 pkginst);
3721 (void) remove(zoneStreamName);
3722 } else {
3723 /* remove package - no longer needed */
3724 if (snprintf(instdir, sizeof (instdir), "%s/%s",
3725 zoneTempDir, pkginst) >= PATH_MAX) {
3726 progerr(ERR_CANNOT_CREATE_PKGPATH, tmpdir);
3727 quit(1);
3728 }
3729 echoDebug(DBG_REMOVING_PKG_TMPDIR, instdir, pkginst);
3730 (void) remove(instdir);
3731 }
3732
3733 /* decrement number of packages left to install */
3734
3735 npkgs--;
3736
3737 /*
3738 * if no packages left to install, unmount package source
3739 * device if appropriate
3740 */
3741
3742 if ((npkgs <= 0) && (pkgdev.mount || a_idsName)) {
3743 (void) chdir("/");
3744 if (!a_idsName) {
3745 echoDebug(DBG_UNMOUNTING_DEV,
3746 PSTR(pkgdev.mount));
3747 (void) pkgumount(&pkgdev);
3748 }
3749 }
3750 }
3751
3752 /*
3753 * all packages in the package list have been installed.
3754 * Continue with installation if:
3755 * -- immediate reboot is NOT required
3756 * -- there are more packages to install
3757 * -- the package source is a path to a file
3758 * else return do NOT continue.
3759 */
3760
3761 if ((ireboot == 0) && (a_repeat != 0) &&
3762 (pkgdev.pathname == (char *)NULL)) {
3763 return (B_TRUE);
3764 }
3765
3766 /* return 'dont continue' */
3767
3768 return (B_FALSE);
3769 }
3770
3771 /*
3772 * Function: add_packages_in_nonglobal_zone
3773 * Description: call this function to add a list of packages in a non-global
3774 * zone
3775 * returns:
3776 * B_TRUE to process next data stream
3777 * B_FALSE to exit
3778 */
3779
3780 static boolean_t
3781 add_packages_in_nonglobal_zone(char **a_pkgList,
3782 char *a_idsName, int a_repeat, char *a_altBinDir, char *a_device)
3783 {
3784 static char *zoneTempDir = (char *)NULL;
3785
3786 char *packageDir;
3787 char respfile_path[PATH_MAX];
3788 int i;
3789 int n;
3790 boolean_t b;
3791 int savenpkgs = npkgs;
3792
3793 /* entry assertions */
3794
3795 assert(a_pkgList != (char **)NULL);
3796
3797 /* entry debugging info */
3798
3799 echoDebug(DBG_ADDPACKAGES_LZ_ENTRY);
3800 echoDebug(DBG_ADDPACKAGES_LZ_ARGS, npkgs, PSTR(a_idsName),
3801 a_repeat, PSTR(a_device));
3802
3803 /* create temporary directory for use by zone operations */
3804
3805 create_zone_tempdir(&zoneTempDir, tmpdir);
3806
3807 /*
3808 * package can be in a number of formats:
3809 * - file containing package stream (pkgadd -d file [pkgs])
3810 * - directory containing packages (pkgadd -d /dir [pkgs])
3811 * - device containing packages (pkgadd -d diskette1 [pkgs])
3812 * non-global zones can be passed open file drescriptors and
3813 * strings as arguments
3814 * - for file containing package stream
3815 * -- the stream can be passed directly to the non-global zone
3816 * - for directory
3817 * -- convert packages to datastream to pass to the non-global zone
3818 * - for device
3819 */
3820
3821 /* determine directory where packages can be found */
3822
3823 if (a_idsName == (char *)NULL) {
3824 /* no stream - directory containing packages provided */
3825 packageDir = pkgdev.dirname;
3826 } else {
3827 packageDir = zoneTempDir;
3828 }
3829
3830 b = unpack_and_check_packages(a_pkgList, a_idsName, packageDir);
3831 if (b != B_TRUE) {
3832 quit(1);
3833 }
3834
3835 /*
3836 * this is the main loop where all of the packages (as listed in the
3837 * package list) are added one at a time.
3838 */
3839
3840 for (i = 0; (pkginst = a_pkgList[i]) != NULL; i++) {
3841 npkgs--;
3842 }
3843
3844 npkgs = savenpkgs;
3845
3846 /*
3847 * this is the main loop where all of the packages (as listed in the
3848 * package list) are added one at a time.
3849 */
3850
3851 for (i = 0; (pkginst = a_pkgList[i]) != NULL; i++) {
3852 /*
3853 * if immediate reboot required from last package and this is
3854 * not 'pkgask' then suspend installation of remaining packages
3855 */
3856
3857 if ((ireboot != 0) && (askflag == 0)) {
3858 ptext(stderr, MSG_SUSPEND_ADD, pkginst);
3859 continue;
3860 }
3861
3862 /*
3863 * handle interrupt if the previous pkginstall was interrupted
3864 */
3865
3866 if (continue_installation() == B_FALSE) {
3867 return (B_FALSE);
3868 }
3869
3870 /*
3871 * if pkgask, handle response file creation:
3872 * - if the response file is a directory, then create a path to
3873 * -- a package instance within the response file directory.
3874 * - If the response file is NOT a directory, if more than one
3875 * -- package is to be installed.
3876 */
3877
3878 if ((askflag != 0) && (respdir != (char *)NULL)) {
3879 (void) snprintf(respfile_path, sizeof (respfile_path),
3880 "%s/%s", respdir, pkginst);
3881 respfile = respfile_path;
3882 }
3883
3884 echo(MSG_PROC_INST, pkginst, a_device);
3885
3886 /*
3887 * If we're installing another package in the same
3888 * session, the second through nth pkginstall, must
3889 * continue from where the prior one left off. For this
3890 * reason, the continuation feature (implied by the
3891 * nature of the command) is used for the remaining
3892 * packages.
3893 */
3894
3895 if ((i == 1) && (pkgdrtarg != (char *)NULL)) {
3896 pkgcontsrc = pkgdrtarg;
3897 }
3898
3899 /* reset interrupted flag before calling pkginstall */
3900
3901 interrupted = 0; /* last action was NOT quit */
3902
3903 /* call pkginstall for this package */
3904
3905 n = pkgInstall(get_inst_root(), NULL,
3906 packageDir, a_altBinDir);
3907
3908 /* set success/fail condition variables */
3909
3910 ckreturn(n);
3911
3912 /* decrement number of packages left to install */
3913
3914 npkgs--;
3915
3916 /*
3917 * if no packages left to install, unmount package source
3918 * device if appropriate
3919 */
3920
3921 if ((npkgs <= 0) && (pkgdev.mount || a_idsName)) {
3922 (void) chdir("/");
3923 if (!a_idsName) {
3924 (void) pkgumount(&pkgdev);
3925 }
3926 }
3927 }
3928
3929 /*
3930 * all packages in the package list have been installed.
3931 * Continue with installation if:
3932 * -- immediate reboot is NOT required
3933 * -- there are more packages to install
3934 * -- the package source is a path to a file
3935 * else return do NOT continue.
3936 */
3937
3938 if ((ireboot == 0) && (a_repeat != 0) &&
3939 (pkgdev.pathname == (char *)NULL)) {
3940 return (B_TRUE);
3941 }
3942
3943 /* return 'dont continue' */
3944
3945 return (B_FALSE);
3946 }
3947
3948 /*
3949 * Function: add_packages_in_global_no_zones
3950 * Description: call this function to add a list of packages in the global zone
3951 * when no non-global zones exist
3952 * returns:
3953 * B_TRUE to process next data stream
3954 * B_FALSE to exit
3955 */
3956
3957 static boolean_t
3958 add_packages_in_global_no_zones(char **a_pkgList,
3959 char *a_idsName, int a_repeat, char *a_altBinDir, char *a_device)
3960 {
3961 int n;
3962 int i;
3963 char respfile_path[PATH_MAX];
3964 CAF_T flags = 0;
3965
3966 /* entry assertions */
3967
3968 assert(a_pkgList != (char **)NULL);
3969
3970 echoDebug(DBG_ADDPACKAGES_GZ_NO_LZ_ENTRY);
3971 echoDebug(DBG_ADDPACKAGES_GZ_NO_LZ_ARGS, npkgs,
3972 PSTR(a_idsName), a_repeat, PSTR(a_device));
3973
3974 /*
3975 * set flags for applicability check
3976 */
3977
3978 /* in the global zone */
3979
3980 flags |= CAF_IN_GLOBAL_ZONE;
3981
3982 /* set -G flag */
3983
3984 if (globalZoneOnly == B_TRUE) {
3985 flags |= CAF_SCOPE_GLOBAL;
3986 }
3987
3988 /*
3989 * this is the main loop where all of the packages (as listed in the
3990 * package list) are added one at a time.
3991 */
3992
3993 for (i = 0; (pkginst = a_pkgList[i]) != NULL; i++) {
3994 /*
3995 * if immediate reboot required from last package and this is
3996 * not 'pkgask' then suspend installation of remaining packages
3997 */
3998
3999 if ((ireboot != 0) && (askflag == 0)) {
4000 ptext(stderr, MSG_SUSPEND_ADD, pkginst);
4001 continue;
4002 }
4003
4004 /*
4005 * handle interrupt if the previous pkginstall was interrupted
4006 */
4007
4008 if (continue_installation() == B_FALSE) {
4009 return (B_FALSE);
4010 }
4011
4012 /*
4013 * check package applicability to install in this context
4014 */
4015
4016 if (check_applicability(pkgdev.dirname,
4017 pkginst, get_inst_root(), flags) == B_FALSE) {
4018 progerr(ERR_PKG_NOT_APPLICABLE, pkginst);
4019 quit(1);
4020 }
4021
4022 /*
4023 * if pkgask, handle response file creation:
4024 * - if the response file is a directory, then create a path to
4025 * -- a package instance within the response file directory.
4026 * - If the response file is NOT a directory, if more than one
4027 * -- package is to be installed.
4028 */
4029
4030 if ((askflag != 0) && (respdir != (char *)NULL)) {
4031 (void) snprintf(respfile_path, sizeof (respfile_path),
4032 "%s/%s", respdir, pkginst);
4033 respfile = respfile_path;
4034 }
4035
4036 echo(MSG_PROC_INST, pkginst, a_device);
4037
4038 /*
4039 * If we're installing another package in the same
4040 * session, the second through nth pkginstall, must
4041 * continue from where the prior one left off. For this
4042 * reason, the continuation feature (implied by the
4043 * nature of the command) is used for the remaining
4044 * packages.
4045 */
4046
4047 if ((i == 1) && (pkgdrtarg != (char *)NULL)) {
4048 pkgcontsrc = pkgdrtarg;
4049 }
4050
4051 /* reset interrupted flag before calling pkginstall */
4052
4053 interrupted = 0; /* last action was NOT quit */
4054
4055 /* call pkginstall for this package */
4056
4057 n = pkgInstall(get_inst_root(), a_idsName,
4058 pkgdev.dirname, a_altBinDir);
4059
4060 /* set success/fail condition variables */
4061
4062 ckreturn(n);
4063
4064 /* decrement number of packages left to install */
4065
4066 npkgs--;
4067
4068 /*
4069 * if no packages left to install, unmount package source
4070 * device if appropriate
4071 */
4072
4073 if ((npkgs <= 0) && (pkgdev.mount || a_idsName)) {
4074 (void) chdir("/");
4075 if (!a_idsName) {
4076 (void) pkgumount(&pkgdev);
4077 }
4078 }
4079 }
4080
4081 /*
4082 * all packages in the package list have been installed.
4083 * Continue with installation if:
4084 * -- immediate reboot is NOT required
4085 * -- there are more packages to install
4086 * -- the package source is a path to a file
4087 * else return do NOT continue.
4088 */
4089
4090 if ((ireboot == 0) && (a_repeat != 0) &&
4091 (pkgdev.pathname == (char *)NULL)) {
4092 return (B_TRUE);
4093 }
4094
4095 /* return 'dont continue' */
4096
4097 return (B_FALSE);
4098 }
4099
4100 /*
4101 * returns:
4102 * B_TRUE to process next data stream
4103 * B_FALSE to exit
4104 */
4105
4106 static boolean_t
4107 add_packages(char **a_pkgList,
4108 char *a_idsName, int a_repeat, char *a_altBinDir, char *a_device,
4109 boolean_t a_noZones)
4110 {
4111 zoneList_t zlst;
4112 boolean_t b;
4113
4114 /* entry assertions */
4115
4116 assert(a_pkgList != (char **)NULL);
4117
4118 echoDebug(DBG_ADDPACKAGES_ENTRY);
4119 echoDebug(DBG_ADDPACKAGES_ARGS, npkgs, PSTR(a_idsName),
4120 a_repeat, PSTR(a_altBinDir), PSTR(a_device));
4121
4122 /*
4123 * if running in the global zone AND one or more non-global
4124 * zones exist, add packages in a 'zones aware' manner, else
4125 * add packages in the standard 'non-zones aware' manner.
4126 */
4127
4128 if ((a_noZones == B_FALSE) && (z_running_in_global_zone() == B_FALSE)) {
4129 /* in non-global zone */
4130
4131 echoDebug(DBG_IN_LZ);
4132
4133 b = z_lock_this_zone(ZLOCKS_PKG_ADMIN);
4134 if (b != B_TRUE) {
4135 progerr(ERR_CANNOT_LOCK_THIS_ZONE);
4136 /* set fatal error return condition */
4137 ckreturn(1);
4138 return (B_FALSE);
4139 }
4140
4141 b = add_packages_in_nonglobal_zone(a_pkgList, a_idsName,
4142 a_repeat, a_altBinDir, a_device);
4143
4144 (void) z_unlock_this_zone(ZLOCKS_ALL);
4145
4146 return (B_FALSE);
4147 }
4148
4149 /* running in the global zone */
4150
4151 b = z_non_global_zones_exist();
4152 if ((a_noZones == B_FALSE) && (b == B_TRUE) &&
4153 (globalZoneOnly == B_FALSE)) {
4154
4155 echoDebug(DBG_IN_GZ_WITH_LZ);
4156
4157 /* error if -V specified - what to use in non-global zone? */
4158
4159 if (vfstab_file) {
4160 progerr(ERR_V_USED_WITH_GZS);
4161 quit(1);
4162 }
4163
4164 /* get a list of all non-global zones */
4165 zlst = z_get_nonglobal_zone_list();
4166 if (zlst == (zoneList_t)NULL) {
4167 progerr(ERR_CANNOT_GET_ZONE_LIST);
4168 quit(1);
4169 }
4170
4171 /* need to lock all of the zones */
4172
4173 quitSetZonelist(zlst);
4174 b = z_lock_zones(zlst, ZLOCKS_PKG_ADMIN);
4175 if (b == B_FALSE) {
4176 z_free_zone_list(zlst);
4177 progerr(ERR_CANNOT_LOCK_ZONES);
4178 /* set fatal error return condition */
4179 ckreturn(1);
4180 return (B_FALSE);
4181 }
4182
4183 /* add packages to all zones */
4184
4185 b = add_packages_in_global_with_zones(a_pkgList,
4186 a_idsName, a_repeat, a_altBinDir, a_device, zlst);
4187
4188 /* unlock all zones */
4189
4190 (void) z_unlock_zones(zlst, ZLOCKS_ALL);
4191 quitSetZonelist((zoneList_t)NULL);
4192
4193 /* free list of all non-global zones */
4194
4195 z_free_zone_list(zlst);
4196
4197 return (B_FALSE);
4198 }
4199
4200 /* in global zone no non-global zones */
4201
4202 echoDebug(DBG_IN_GZ_NO_LZ);
4203
4204 b = z_lock_this_zone(ZLOCKS_PKG_ADMIN);
4205 if (b != B_TRUE) {
4206 progerr(ERR_CANNOT_LOCK_THIS_ZONE);
4207 /* set fatal error return condition */
4208 ckreturn(1);
4209 return (B_FALSE);
4210 }
4211
4212 b = add_packages_in_global_no_zones(a_pkgList, a_idsName,
4213 a_repeat, a_altBinDir, a_device);
4214
4215 (void) z_unlock_this_zone(ZLOCKS_ALL);
4216
4217 return (B_FALSE);
4218 }
Unleashed OS