/* * This function verifies that the contents file is in place. * returns 1 - if it exists * returns 0 - if it does not exist */ int iscfile(void) { char contents[PATH_MAX]; (void) snprintf(contents, PATH_MAX, "%s/contents", get_PKGADM()); return (access(contents, F_OK) == 0 ? 1 : 0); }
void setadminFile(char *file) { FILE *fp; int i; char param[MAX_PKG_PARAM_LENGTH]; char *value; char path[PATH_MAX]; int mail = 0; if (file == NULL) file = "default"; else if (strcmp(file, "none") == 0) { adm.basedir = "ask"; return; } if (file[0] == '/') (void) strcpy(path, file); else { (void) snprintf(path, sizeof (path), "%s/admin/%s", get_PKGADM(), file); if (access(path, R_OK)) { (void) snprintf(path, sizeof (path), "%s/admin/%s", PKGADM, file); } } if ((fp = fopen(path, "r")) == NULL) { progerr(ERR_OPEN_ADMIN_FILE, file, strerror(errno)); quit(99); } param[0] = '\0'; while (value = fpkgparam(fp, param)) { if (strcmp(param, "mail") == 0) { mail = 1; } if (value[0] == '\0') { param[0] = '\0'; continue; /* same as not being set at all */ } for (i = 0; admlist[i].memloc; i++) { if (strcmp(param, admlist[i].tag) == 0) { *admlist[i].memloc = value; break; } } if (admlist[i].memloc == NULL) { logerr(WRN_UNKNOWN_ADM_PARAM, param); free(value); } param[0] = '\0'; } (void) fclose(fp); if (!mail) { adm.mail = DEFMAIL; /* if we don't assign anything to it */ } }
int vcfile(void) { int lerrno; int fd; char contents[PATH_MAX]; /* * create full path to contents file */ (void) snprintf(contents, sizeof (contents), "%s/contents", get_PKGADM()); /* * Attempt to create the file - will only be successful * if the file does not currently exist. */ fd = open(contents, O_WRONLY | O_CREAT | O_EXCL, 0644); if (fd >= 0) { /* * Contents file wasn't there, but is now. */ echo(gettext("## Software contents file initialized")); (void) close(fd); return (1); /* success */ } /* * Could not create the file - it may exist or there may be * permissions issues - find out and act accordingly. */ lerrno = errno; /* success if error is 'file exists' */ if (lerrno == EEXIST) { return (1); /* success */ } /* success if error is 'permission denied' but file exists */ if (lerrno == EACCES) { /* * Because O_CREAT and O_EXCL are specified in open(), * if the contents file already exists, the open will * fail with EACCES - determine if this is the case - * if so return success. */ if (access(contents, F_OK) == 0) { return (1); /* success */ } /* * access() failed - if because of permissions failure this * means the contents file exists but it cannot be accessed * or the path to the contents file cannot be accessed - in * either case the contents file cannot be accessed. */ if (errno == EACCES) { progerr(gettext(ERR_ACCESS_CONT), contents, strerror(lerrno)); logerr(gettext(ERR_ERRNO), lerrno, strerror(lerrno)); return (0); /* failure */ } } /* * the contents file does not exist and it cannot be created. */ progerr(gettext(ERR_CREAT_CONT), contents, strerror(lerrno)); logerr(gettext(ERR_ERRNO), lerrno, strerror(lerrno)); return (0); /* failure */ }
/* * Point packaging to the appropriate contents file. This is primarily used * to establish a dryrun contents file. If the malloc() doesn't work, this * returns 99 (internal error), else 0. */ int set_cfdir(char *cfdir) { char realcf[PATH_MAX]; char tmpcf[PATH_MAX]; int status; if (cfdir == NULL) { pkgadm_dir = get_PKGADM(); return (0); } if ((pkgadm_dir = strdup(cfdir)) == NULL) { return (99); } (void) snprintf(tmpcf, sizeof (tmpcf), "%s/contents", pkgadm_dir); /* * return if a temporary contents file already exists - * assume it is from a prior package in this series. */ if (access(tmpcf, F_OK) == 0) { return (0); } /* * no temporary contents file exists - create one. */ (void) snprintf(realcf, sizeof (realcf), "%s/contents", get_PKGADM()); /* * If there's a contents file there already, copy it * over, otherwise initialize one. Make sure that the * server, if running, flushes the contents file. */ (void) pkgsync(NULL, get_PKGADM(), B_FALSE); /* create new contents file if one does not already exist */ if (access(realcf, F_OK) != 0) { int n; n = open(tmpcf, O_WRONLY|O_CREAT|O_TRUNC|O_EXCL, 0644); if (n < 0) { progerr(gettext(ERR_CREAT_CONT), tmpcf, strerror(errno)); return (99); } (void) close(n); } else { /* contents file exists, save in pkgadm-dir */ status = copyf(realcf, tmpcf, (time_t)0); if (status != 0) { progerr(gettext(ERR_DRCONTCP), tmpcf); return (99); } } return (0); }
int main(int argc, char **argv) { int c; pkgdir = NULL; setErrstr(NULL); /* initialize locale mechanism */ #if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */ #define TEXT_DOMAIN "SYS_TEST" #endif (void) textdomain(TEXT_DOMAIN); /* determine program name */ (void) set_prog_name(argv[0]); /* tell spmi zones interface how to access package output functions */ z_set_output_functions(echo, echoDebug, progerr); /* establish installation root directory */ if (!set_inst_root(getenv("PKG_INSTALL_ROOT"))) { progerr(gettext(ERR_ROOT_SET)); exit(1); } while ((c = getopt(argc, argv, "LNR:xv:a:d:qrpilc:?")) != EOF) { switch (c) { case 'v': ckvers = optarg; break; case 'a': ckarch = optarg; break; case 'd': /* -d could specify stream or mountable device */ device = flex_device(optarg, 1); break; case 'q': qflag++; break; case 'i': iflag = 1; if (pflag > 0) usage(); pflag = 0; break; case 'p': pflag = 1; if (iflag > 0) usage(); iflag = 0; break; case 'N': Nflag++; break; case 'L': if (xflag || lflag || rflag) { progerr(gettext(ERR_INCOMP0)); usage(); } Lflag++; break; case 'l': if (xflag || rflag) { progerr(gettext(ERR_INCOMP1)); usage(); } lflag++; break; case 'x': /* bug # 1081606 */ if (lflag || rflag) { progerr(gettext(ERR_INCOMP2)); usage(); } xflag++; break; case 'r': if (lflag || xflag || Lflag) { progerr(gettext(ERR_INCOMP0)); usage(); } rflag++; break; case 'c': ckcatg[ncatg++] = strtok(optarg, " \t\n, "); while (ckcatg[ncatg] = strtok(NULL, " \t\n, ")) ncatg++; break; /* added for newroot functions */ case 'R': if (!set_inst_root(optarg)) { progerr(gettext(ERR_ROOT_CMD)); exit(1); } break; default: usage(); } } /* * implement the newroot option */ set_PKGpaths(get_inst_root()); /* set up /var... directories */ /* * Open the install DB, if one exists. */ pkg = &argv[optind]; pkgcnt = (argc - optind); if (pkg[0] && strcmp(pkg[0], "all") == 0) { pkgcnt = 0; pkg[0] = NULL; } if (pkgdir == NULL) pkgdir = get_PKGLOC(); /* we need this later */ /* convert device appropriately */ if (pkghead(device)) exit(1); /* * If we are to inspect a spooled package we are only interested in * the pkginfo file in the spooled pkg so we skip any Reg 4 DB * lookups and use the old algorithm. We have a spooled pkg if * device is not NULL. */ look_for_installed(); if (lflag && strcmp(pkgdir, get_PKGLOC()) == 0) { /* look at contents file */ (void) snprintf(contents, sizeof (contents), "%s/contents", get_PKGADM()); rdcontents(); } /* * If we are to inspect a spooled package we are only interested in * the pkginfo file in the spooled pkg so we skip any Reg 4 DB * lookups and use the old algorithm. We have a spooled pkg if * device is not NULL. */ report(); (void) pkghead(NULL); exit(errflg ? 1 : 0); /*NOTREACHED*/ #ifdef lint return (0); #endif /* lint */ }
boolean_t unpack_package_from_stream(char *a_idsName, char *a_pkginst, char *a_tempDir) { int dparts; char instdir[PATH_MAX]; /* entry assertions */ assert(a_idsName != (char *)NULL); assert(a_pkginst != (char *)NULL); assert(a_tempDir != (char *)NULL); /* entry debug information */ echoDebug(DBG_UNPACKSTRM_ENTRY); echoDebug(DBG_UNPACKSTRM_ARGS, a_pkginst, a_idsName, a_tempDir); /* find the specified package in the datastream */ dparts = ds_findpkg(a_idsName, a_pkginst); if (dparts < 1) { progerr(gettext(ERR_DSARCH), a_pkginst); return (B_FALSE); /*NOTREACHED*/ } /* * read in next part from stream, even if we decide * later that we don't need it */ /* create directory to hold this package instance */ if (snprintf(instdir, sizeof (instdir), "%s/%s", a_tempDir, a_pkginst) >= PATH_MAX) { progerr(ERR_CREATE_PATH_2, a_tempDir, a_pkginst); return (B_FALSE); } switch (fmkdir(instdir, 0755)) { case 0: /* directory created */ break; case 1: /* could not remove existing non-directory node */ progerr(ERR_REMOVE, instdir, strerror(errno)); return (B_FALSE); case 2: /* could not create specified new directory */ default: progerr(ERR_UNPACK_FMKDIR, instdir, strerror(errno)); return (B_FALSE); } /* unpack package instance from stream to dir created */ echoDebug(DBG_UNPACKSTRM_UNPACKING, a_pkginst, a_idsName, instdir); if (chdir(instdir)) { progerr(ERR_CHDIR, instdir); return (B_FALSE); } dparts--; if (ds_next(a_idsName, instdir)) { progerr(ERR_UNPACK_DSREAD, dparts+1, a_idsName, instdir, a_pkginst); return (B_FALSE); } if (chdir(get_PKGADM())) { progerr(gettext(ERR_CHDIR), get_PKGADM()); return (B_FALSE); } return (B_TRUE); }
int cppath(int a_ctrl, char *a_srcPath, char *a_dstPath, mode_t a_mode) { char *linknam = (char *)NULL; int dstFd; int len; int srcFd; long status; struct stat srcStatbuf; struct utimbuf times; /* entry debugging info */ echoDebug(DBG_CPPATH_ENTRY, a_ctrl, a_mode, a_srcPath, a_dstPath); /* open source file for reading */ srcFd = open(a_srcPath, O_RDONLY); if (srcFd < 0) { progerr(ERR_OPEN_READ, a_srcPath, errno, strerror(errno)); return (1); } /* obtain file status of source file */ if (fstat(srcFd, &srcStatbuf) != 0) { progerr(ERR_FSTAT, srcFd, a_srcPath, errno, strerror(errno)); (void) close(srcFd); return (1); } /* * Determine the permissions mode for the destination: * - if MODE_SET is specified: * --> use a_mode (do not mask off any portion) * --> If a_mode is unknown (? in the pkgmap), then the file gets * --> installed with the default 0644 mode * - if MODE_SRC is specified: * --> use the mode of the source (srcStatbuf.st_mode) but mask off all * --> non-access mode bits (remove SET?UID bits) * - otherwise: * --> use 0666 */ if (a_ctrl & MODE_SET) { mode_t usemode; usemode = (a_mode ^ BADMODE) ? a_mode : 0644; if (a_mode != usemode && usemode == 0644) { logerr(WRN_DEF_MODE, a_dstPath); a_mode = usemode; } } else if (a_ctrl & MODE_SRC) { a_mode = (srcStatbuf.st_mode & S_IAMB); } else { a_mode = 0666; } /* * Get fd of newly created destination file or, if this * is an overwrite, a temporary file (linknam). */ dstFd = write_file(&linknam, a_ctrl, a_mode, a_dstPath); if (dstFd < 0) { (void) close(srcFd); return (1); } /* * source and target files are open: copy data */ status = copyFile(srcFd, dstFd, a_srcPath, a_dstPath, &srcStatbuf, 0); (void) close(srcFd); (void) close(dstFd); if (status != 0) { progerr(ERR_INPUT, a_srcPath, errno, strerror(errno)); if (linknam) { (void) remove(linknam); } return (1); } /* * If this is an overwrite, rename temp over original */ if ((linknam != (char *)NULL) && (rename(linknam, a_dstPath) != 0)) { FILE *logfp = (FILE *)NULL; char busylog[PATH_MAX]; /* output log message if busy else program error */ if (errno == ETXTBSY) { logerr(MSG_PROCMV, linknam); } else { progerr(ERR_OUTPUT_WRITING, a_dstPath, errno, strerror(errno)); } (void) remove(linknam); /* open the log file and append log entry */ len = snprintf(busylog, sizeof (busylog), "%s/textbusy", get_PKGADM()); if (len > sizeof (busylog)) { progerr(ERR_CREATE_PATH_2, get_PKGADM(), "textbusy"); } else { logfp = fopen(busylog, "a"); if (logfp == NULL) { progerr(ERR_LOG, busylog, errno, strerror(errno)); } else { (void) fprintf(logfp, "%s\n", linknam); (void) fclose(logfp); } } } /* set access/modification times for target */ times.actime = srcStatbuf.st_atime; times.modtime = srcStatbuf.st_mtime; if (utime(a_dstPath, ×) != 0) { progerr(ERR_MODTIM, a_dstPath, errno, strerror(errno)); return (1); } /* success! */ return (0); }
int main(int argc, char *argv[]) { FILE *fp; char *abi_comp_ptr; char *abi_sym_ptr; char *p; char *prog_full_name = NULL; char *pt; char *value; char *vfstab_file = NULL; char *zoneName = (char *)NULL; char cmdbin[PATH_MAX]; char param[MAX_PKG_PARAM_LENGTH]; char path[PATH_MAX]; char script[PATH_MAX]; int c; int err; int fd; int i; int map_client = 1; int n; int nodelete = 0; /* do not delete file or run scripts */ int pkgrmremote = 0; /* dont remove remote objects */ struct sigaction nact; struct sigaction oact; PKGserver pkgserver = NULL; VFP_T *tmpfp; /* reset contents of all default paths */ (void) memset(cmdbin, '\0', sizeof (cmdbin)); /* initialize locale environment */ (void) setlocale(LC_ALL, ""); (void) textdomain(TEXT_DOMAIN); /* initialize program name */ prog_full_name = argv[0]; (void) set_prog_name(argv[0]); /* tell spmi zones interface how to access package output functions */ z_set_output_functions(echo, echoDebug, progerr); /* exit if not root */ if (getuid()) { progerr(ERR_NOT_ROOT, get_prog_name()); exit(1); /* NOTREACHED */ } /* Read PKG_INSTALL_ROOT from the environment, if it's there. */ if (!set_inst_root(getenv("PKG_INSTALL_ROOT"))) { progerr(ERR_ROOT_SET); exit(1); } pkgserversetmode(DEFAULTMODE); /* parse command line options */ while ((c = getopt(argc, argv, "?Aa:b:FMN:nO:oR:V:vy")) != EOF) { switch (c) { /* * Same as pkgrm: Allow admin to remove package objects from * a shared area from a reference client. */ case 'A': pkgrmremote++; break; /* * Same as pkgrm: Use the installation * administration file, admin, in place of the * default admin file. pkgrm first looks in the * current working directory for the administration * file. If the specified administration file is not * in the current working directory, pkgrm looks in * the /var/sadm/install/admin directory for the * administration file. */ case 'a': admnfile = flex_device(optarg, 0); break; /* * Same as pkgrm: location where package executables * can be found - default is /usr/sadm/install/bin. */ case 'b': if (!path_valid(optarg)) { progerr(ERR_PATH, optarg); exit(1); } if (isdir(optarg) != 0) { char *p = strerror(errno); progerr(ERR_CANNOT_USE_DIR, optarg, p); exit(1); } (void) strlcpy(cmdbin, optarg, sizeof (cmdbin)); break; /* * Same as pkgrm: suppresses the removal of any * files and any class action scripts, and suppresses * the running of any class action scripts. The * package files remain but the package looks like it * is not installed. This is mainly for use by the * upgrade process. */ case 'F': nodelete++; break; /* * Same as pkgrm: Instruct pkgrm not to use the * $root_path/etc/vfstab file for determining the * client's mount points. This option assumes the * mount points are correct on the server and it * behaves consistently with Solaris 2.5 and earlier * releases. */ case 'M': map_client = 0; break; /* * Different from pkgrm: specify program name to use * for messages. */ case 'N': (void) set_prog_name(optarg); break; /* * Same as pkgrm: package removal occurs in * non-interactive mode. Suppress output of the list of * removed files. The default mode is interactive. */ case 'n': nointeract++; (void) echoSetFlag(B_FALSE); break; /* * Almost same as pkgrm: the -O option allows the behavior * of the package tools to be modified. Recognized options: * -> debug * ---> enable debugging output * -> preremovecheck * ---> perform a "pre removal" check of the specified * ---> package - suppress all regular output and cause a * ---> series of one or more "name=value" pair format lines * ---> to be output that describes the "removability" of * ---> the specified package * -> enable-hollow-package-support * --> Enable hollow package support. When specified, for any * --> package that has SUNW_PKG_HOLLOW=true: * --> Do not calculate and verify package size against target * --> Do not run any package procedure or class action scripts * --> Do not create or remove any target directories * --> Do not perform any script locking * --> Do not install or uninstall any components of any package * --> Do not output any status or database update messages */ case 'O': for (p = strtok(optarg, ","); p != (char *)NULL; p = strtok(NULL, ",")) { /* process debug option */ if (strcmp(p, "debug") == 0) { /* set debug flag/enable debug output */ debugFlag = B_TRUE; (void) echoDebugSetFlag(debugFlag); /* debug info on arguments to pkgadd */ for (n = 0; n < argc && argv[n]; n++) { echoDebug(DBG_ARG, n, argv[n]); } continue; } /* process enable-hollow-package-support opt */ if (strcmp(p, "enable-hollow-package-support") == 0) { set_depend_pkginfo_DB(B_TRUE); continue; } /* process preremovecheck option */ if (strcmp(p, "preremovecheck") == 0) { preremoveCheck = B_TRUE; nointeract++; /* -n */ nodelete++; /* -F */ quitSetSilentExit(B_TRUE); continue; } /* process addzonename option */ if (strcmp(p, "addzonename") == 0) { zoneName = z_get_zonename(); quitSetZoneName(zoneName); continue; } /* process parent-zone-name option */ if (strncmp(p, PARENTZONENAME, PARENTZONENAME_LEN) == 0) { parentZoneName = p+PARENTZONENAME_LEN; continue; } /* process parent-zone-type option */ if (strncmp(p, PARENTZONETYPE, PARENTZONETYPE_LEN) == 0) { parentZoneType = p+PARENTZONETYPE_LEN; continue; } if (strncmp(p, PKGSERV_MODE, PKGSERV_MODE_LEN) == 0) { pkgserversetmode(pkgparsemode(p + PKGSERV_MODE_LEN)); continue; } /* option not recognized - issue warning */ progerr(ERR_INVALID_O_OPTION, p); continue; } break; /* * Different from pkgrm: This is an old non-ABI package */ case 'o': script_in = PROC_XSTDIN; break; /* * Same as pkgrm: defines the full path name of a * directory to use as the root_path. All files, * including package system information files, are * relocated to a directory tree starting in the * specified root_path. */ case 'R': if (!set_inst_root(optarg)) { progerr(ERR_ROOT_CMD); exit(1); } break; /* * Same as pkgrm: allow admin to establish the client * filesystem using a vfstab-like file of stable format. */ case 'V': vfstab_file = flex_device(optarg, 2); map_client = 1; break; /* * Same as pkgrm: trace all of the scripts that * get executed by pkgrm, located in the * pkginst/install directory. This option is used for * debugging the procedural and non-procedural * scripts. */ case 'v': pkgverbose++; break; /* * Different from pkgrm: process this package using * old non-ABI symlinks */ case 'y': set_nonABI_symlinks(); break; default: usage(); /*NOTREACHED*/ /* * Although usage() calls a noreturn function, * needed to add return (1); so that main() would * pass compilation checks. The statement below * should never be executed. */ return (1); } } /* * ******************************************************************** * validate command line options * ******************************************************************** */ (void) echoDebugSetFlag(debugFlag); (void) log_set_verbose(debugFlag); if (z_running_in_global_zone()) { echoDebug(DBG_ENTRY_IN_GZ, prog_full_name); } else { echoDebug(DBG_ENTRY_IN_LZ, prog_full_name, getzoneid(), z_get_zonename()); } /* establish cmdbin path */ if (cmdbin[0] == '\0') { (void) strlcpy(cmdbin, PKGBIN, sizeof (cmdbin)); } /* Read the mount table */ if (get_mntinfo(map_client, vfstab_file)) { quit(99); } /* * This function defines the standard /var/... directories used later * to construct the paths to the various databases. */ set_PKGpaths(get_inst_root()); /* * If this is being removed from a client whose /var filesystem is * mounted in some odd way, remap the administrative paths to the * real filesystem. This could be avoided by simply mounting up the * client now; but we aren't yet to the point in the process where * modification of the filesystem is permitted. */ if (is_an_inst_root()) { int fsys_value; fsys_value = fsys(get_PKGLOC()); if (use_srvr_map_n(fsys_value)) set_PKGLOC(server_map(get_PKGLOC(), fsys_value)); fsys_value = fsys(get_PKGADM()); if (use_srvr_map_n(fsys_value)) set_PKGADM(server_map(get_PKGADM(), fsys_value)); } else { pkgrmremote = 0; /* Makes no sense on local host. */ } /* * hook SIGINT and SIGHUP interrupts into quit.c's trap handler */ /* hold SIGINT/SIGHUP interrupts */ (void) sighold(SIGHUP); (void) sighold(SIGINT); /* connect quit.c:trap() to SIGINT */ nact.sa_handler = quitGetTrapHandler(); nact.sa_flags = SA_RESTART; (void) sigemptyset(&nact.sa_mask); (void) sigaction(SIGINT, &nact, &oact); /* connect quit.c:trap() to SIGHUP */ nact.sa_handler = quitGetTrapHandler(); nact.sa_flags = SA_RESTART; (void) sigemptyset(&nact.sa_mask); (void) sigaction(SIGHUP, &nact, &oact); /* release hold on signals */ (void) sigrelse(SIGHUP); (void) sigrelse(SIGINT); pkginst = argv[optind++]; if (optind != argc) { usage(); } /* validate package software database (contents) file */ if (vcfile() == 0) { quit(99); } /* * Acquire the package lock - currently at "remove initialization" */ if (!lockinst(get_prog_name(), pkginst, "remove-initial")) { quit(99); } /* establish temporary directory to use */ tmpdir = getenv("TMPDIR"); if (tmpdir == NULL) { tmpdir = P_tmpdir; } echoDebug(DBG_PKGREMOVE_TMPDIR, tmpdir); /* * Initialize installation admin parameters by reading * the adminfile. */ echoDebug(DBG_PKGREMOVE_ADMINFILE, admnfile ? admnfile : ""); setadminFile(admnfile); /* * about to perform first operation that could be modified by the * preremove check option - if preremove check is selected (that is, * only gathering dependencies), then output a debug message to * indicate that the check is beginning. Also turn echo() output * off and set various other flags. */ if (preremoveCheck == B_TRUE) { (void) echoSetFlag(B_FALSE); echoDebug(DBG_PKGREMOVE_PRERMCHK, pkginst ? pkginst : "", zoneName ? zoneName : "global"); rcksetPreremoveCheck(B_TRUE); rcksetZoneName(zoneName); } (void) snprintf(pkgloc, sizeof (pkgloc), "%s/%s", get_PKGLOC(), pkginst); (void) snprintf(pkgbin, sizeof (pkgbin), "%s/install", pkgloc); (void) snprintf(rlockfile, sizeof (rlockfile), "%s/!R-Lock!", pkgloc); if (chdir(pkgbin)) { progerr(ERR_CHDIR, pkgbin); quit(99); } echo(MSG_PREREMOVE_REMINST, pkginst); /* * if a lock file is present, then a previous attempt to remove this * package may have been unsuccessful. */ if (access(rlockfile, F_OK) == 0) { echo(ERR_UNSUCC); echoDebug(DBG_PKGINSTALL_HAS_LOCKFILE, pkginst, rlockfile, zoneName ? zoneName : "global"); } /* * Process all parameters from the pkginfo file * and place them in the execution environment */ /* Add DB retreival of the pkginfo parameters here */ (void) snprintf(path, sizeof (path), "%s/pkginfo", pkgloc); if ((fp = fopen(path, "r")) == NULL) { progerr(ERR_PKGINFO, path); quit(99); } /* Mount up the client if necessary. */ if (map_client && !mount_client()) { logerr(MSG_MANMOUNT); } /* Get mount point of client */ client_mntdir = getenv("CLIENT_MNTDIR"); getuserlocale(); /* * current environment has been read; clear environment out * so putparam() can be used to populate the new environment * to be passed to any executables/scripts. */ environ = NULL; if (nonABI_symlinks()) { putparam("PKG_NONABI_SYMLINKS", "TRUE"); } /* * read the pkginfo file and fix any PKGSAV path - the correct * install_root will be prepended to the existing path. */ param[0] = '\0'; while (value = fpkgparam(fp, param)) { int validx = 0; char *newvalue; /* strip out any setting of PATH */ if (strcmp(param, "PATH") == 0) { free(value); param[0] = '\0'; continue; } /* if not PKGSAV then write out unchanged */ if (strcmp(param, "PKGSAV") != 0) { putparam(param, value); free(value); param[0] = '\0'; continue; } /* * PKGSAV parameter found - interpret the directory: * If in host:path format or marked with the leading "//", * then there is no client-relative translation - take it * literally later rather than use fixpath(). */ if (strstr(value, ":/")) { /* no modification needed */ validx = 0; } else if (strstr(value, "//") == value) { validx = 1; } else if (is_an_inst_root()) { /* This PKGSAV needs to be made client-relative. */ newvalue = fixpath(value); free(value); value = newvalue; } putparam(param, value+validx); free(value); param[0] = '\0'; } (void) fclose(fp); /* write parent condition information to environment */ putConditionInfo(parentZoneName, parentZoneType); putuserlocale(); /* * Now do all the various setups based on ABI compliance */ /* Read the environment provided by the pkginfo file */ abi_comp_ptr = getenv("NONABI_SCRIPTS"); /* if not ABI compliant set global flag */ abi_sym_ptr = getenv("PKG_NONABI_SYMLINKS"); if (abi_sym_ptr && strncasecmp(abi_sym_ptr, "TRUE", 4) == 0) { set_nonABI_symlinks(); } /* * If pkginfo says it's not compliant then set non_abi_scripts. */ if (abi_comp_ptr && strncmp(abi_comp_ptr, "TRUE", 4) == 0) { script_in = PROC_XSTDIN; } /* * Since this is a removal, we can tell whether it's absolute or * not from the resident pkginfo file read above. */ if ((err = set_basedirs((getenv("BASEDIR") != NULL), adm.basedir, pkginst, nointeract)) != 0) { quit(err); } /* * See if were are removing a package that only wants to update * the database or only remove files associated with CAS's. We * only check the PKG_HOLLOW_VARIABLE variable if told to do so by * the caller. */ if (is_depend_pkginfo_DB()) { pt = getenv(PKG_HOLLOW_VARIABLE); if ((pt != NULL) && (strncasecmp(pt, "true", 4) == 0)) { echoDebug(DBG_PKGREMOVE_HOLLOW_ENABLED); /* * this is a hollow package and hollow package support * is enabled -- override admin settings to suppress * checks that do not make sense since no scripts will * be executed and no files will be removed. */ setadminSetting("conflict", "nocheck"); setadminSetting("setuid", "nocheck"); setadminSetting("action", "nocheck"); setadminSetting("partial", "nocheck"); setadminSetting("space", "nocheck"); setadminSetting("authentication", "nocheck"); } else { echoDebug(DBG_PKGREMOVE_HOLLOW_DISABLED); set_depend_pkginfo_DB(B_FALSE); } } put_path_params(); /* If client mount point, add it to pkgremove environment */ if (client_mntdir != NULL) { putparam("CLIENT_MNTDIR", client_mntdir); } /* Establish the class list and the class attributes. */ if ((value = getenv("CLASSES")) != NULL) { cl_sets(qstrdup(value)); } else { progerr(ERR_CLASSES, path); quit(99); } /* establish path and tmpdir */ if (cmdbin[0] == '\0') { (void) strlcpy(cmdbin, PKGBIN, sizeof (cmdbin)); } (void) snprintf(path, sizeof (path), "%s:%s", DEFPATH, cmdbin); putparam("PATH", path); putparam("TMPDIR", tmpdir); /* * Check ulimit requirement (provided in pkginfo). The purpose of * this limit is to terminate pathological file growth resulting from * file edits in scripts. It does not apply to files in the pkgmap * and it does not apply to any database files manipulated by the * installation service. */ if (value = getenv("ULIMIT")) { if (assign_ulimit(value) == -1) { progerr(ERR_BADULIMIT, value); warnflag++; } putparam("PKG_ULIMIT", "TRUE"); } /* * If only gathering dependencies, check and output status of all * remaining dependencies and exit. */ if (preremoveCheck == B_TRUE) { /* * make sure current runlevel is appropriate */ (void) fprintf(stdout, "rckrunlevel=%d\n", rckrunlevel()); /* * determine if any packaging scripts provided with * this package will execute as a priviledged user */ (void) fprintf(stdout, "rckpriv=%d\n", rckpriv()); /* * verify package dependencies */ (void) fprintf(stdout, "rckdepend=%d\n", rckdepend()); /* * ****** preremove check done - exit ****** */ echoDebug(DBG_PKGREMOVE_PRERMCHK_OK); quit(0); /*NOTREACHED*/ } /* * Not gathering dependencies only, proceed to check dependencies * and continue with the package removal operation. */ /* * make sure current runlevel is appropriate */ n = rckrunlevel(); if (n != 0) { quit(n); /* NOTREACHED */ } /* * determine if any packaging scripts provided with * this package will execute as a priviledged user */ n = rckpriv(); if (n != 0) { quit(n); /* NOTREACHED */ } /* * verify package dependencies */ n = rckdepend(); if (n != 0) { quit(n); /* NOTREACHED */ } /* * ********************************************************************* * the actual removal of the package begins here * ********************************************************************* */ /* * create lockfile to indicate start of removal */ started++; if ((fd = open(rlockfile, O_WRONLY|O_CREAT|O_TRUNC, 0644)) < 0) { progerr(ERR_LOCKFILE, rlockfile); quit(99); } else { (void) close(fd); } if (zoneName == (char *)NULL) { echo(MSG_PKGREMOVE_PROCPKG_GZ); echoDebug(DBG_PKGREMOVE_PROCPKG_GZ, pkginst, rlockfile); } else { echo(MSG_PKGREMOVE_PROCPKG_LZ, zoneName); echoDebug(DBG_PKGREMOVE_PROCPKG_LZ, pkginst, rlockfile, zoneName); } if (delmap(0, pkginst, &pkgserver, &tmpfp) != 0) { progerr(ERR_DB_QUERY, pkginst); quit(99); } /* * Run a preremove script if one is provided by the package. * Don't execute preremove script if only updating the DB. * Don't execute preremove script if files are not being deleted. */ /* update the lock - at the preremove script */ lockupd("preremove"); /* execute preremove script if one is provided */ (void) snprintf(script, sizeof (script), "%s/preremove", pkgbin); if (access(script, F_OK) != 0) { /* no script present */ echoDebug(DBG_PKGREMOVE_POC_NONE, pkginst, zoneName ? zoneName : "global"); } else if (nodelete) { /* not deleting files: skip preremove script */ echoDebug(DBG_PKGREMOVE_POC_NODEL, pkginst, script, zoneName ? zoneName : "global"); } else if (is_depend_pkginfo_DB()) { /* updating db only: skip preremove script */ echoDebug(DBG_PKGREMOVE_POC_DBUPD, pkginst, script, zoneName ? zoneName : "global"); } else { /* script present and ok to run: run the script */ set_ulimit("preremove", ERR_PREREMOVE); if (zoneName == (char *)NULL) { echo(MSG_PKGREMOVE_EXEPOC_GZ); echoDebug(DBG_PKGREMOVE_EXEPOC_GZ, pkginst, script); } else { echo(MSG_PKGREMOVE_EXEPOC_LZ, zoneName); echoDebug(DBG_PKGREMOVE_EXEPOC_LZ, pkginst, script, zoneName); } putparam("PKG_PROC_SCRIPT", "preremove"); if (pkgverbose) { ckreturn(pkgexecl(script_in, PROC_STDOUT, PROC_USER, PROC_GRP, SHELL, "-x", script, NULL), ERR_PREREMOVE); } else { ckreturn(pkgexecl(script_in, PROC_STDOUT, PROC_USER, PROC_GRP, SHELL, script, NULL), ERR_PREREMOVE); } clr_ulimit(); } /* update the lock - doing removal */ lockupd("remove"); /* * Remove all components belonging to this package. * Don't remove components if only updating the DB. * Don't remove components if files are not being deleted. */ if (nodelete) { echoDebug(DBG_PKGREMOVE_REM_NODEL, pkginst, zoneName ? zoneName : "global"); } else if (is_depend_pkginfo_DB()) { echoDebug(DBG_PKGREMOVE_REM_DBUPD, pkginst, zoneName ? zoneName : "global"); } else { echoDebug(DBG_PKGREMOVE_REM, pkginst, zoneName ? zoneName : "global"); /* * remove package one class at a time */ /* reverse order of classes */ for (i = cl_getn() - 1; i >= 0; i--) { rmclass(cl_nam(i), pkgrmremote, zoneName); } rmclass(NULL, pkgrmremote, zoneName); } z_destroyMountTable(); /* * Execute postremove script, if any * Don't execute postremove script if only updating the DB. * Don't execute postremove script if files are not being deleted. */ /* update the lock - at the postremove script */ lockupd("postremove"); /* execute postremove script if one is provided */ (void) snprintf(script, sizeof (script), "%s/postremove", pkgbin); if (access(script, F_OK) != 0) { /* no script present */ echoDebug(DBG_PKGREMOVE_PIC_NONE, pkginst, zoneName ? zoneName : "global"); } else if (nodelete) { /* not deleting files: skip postremove script */ echoDebug(DBG_PKGREMOVE_PIC_NODEL, pkginst, script, zoneName ? zoneName : "global"); } else if (is_depend_pkginfo_DB()) { /* updating db only: skip postremove script */ echoDebug(DBG_PKGREMOVE_PIC_DBUPD, pkginst, script, zoneName ? zoneName : "global"); } else { /* script present and ok to run: run the script */ set_ulimit("postremove", ERR_POSTREMOVE); if (zoneName == (char *)NULL) { echo(MSG_PKGREMOVE_EXEPIC_GZ); echoDebug(DBG_PKGREMOVE_EXEPIC_GZ, pkginst, script); } else { echo(MSG_PKGREMOVE_EXEPIC_LZ, zoneName); echoDebug(DBG_PKGREMOVE_EXEPIC_LZ, pkginst, script, zoneName); } putparam("PKG_PROC_SCRIPT", "postremove"); putparam("TMPDIR", tmpdir); if (pkgverbose) { ckreturn(pkgexecl(script_in, PROC_STDOUT, PROC_USER, PROC_GRP, SHELL, "-x", script, NULL), ERR_POSTREMOVE); } else { ckreturn(pkgexecl(script_in, PROC_STDOUT, PROC_USER, PROC_GRP, SHELL, script, NULL), ERR_POSTREMOVE); } clr_ulimit(); } if (zoneName == (char *)NULL) { echo(MSG_PKGREMOVE_UPDINF_GZ); } else { echo(MSG_PKGREMOVE_UPDINF_LZ, zoneName); } if (delmap(1, pkginst, &pkgserver, &tmpfp) != 0) { progerr(ERR_DB_QUERY, pkginst); quit(99); } if (!warnflag && !failflag) { (void) chdir("/"); if (rrmdir(pkgloc)) warnflag++; } if ((z_running_in_global_zone() == B_TRUE) && (pkgIsPkgInGzOnly(get_inst_root(), pkginst) == B_TRUE)) { boolean_t b; b = pkgRemovePackageFromGzonlyList(get_inst_root(), pkginst); if (b == B_FALSE) { progerr(ERR_PKGREMOVE_GZONLY_REMOVE, pkginst); ckreturn(1, NULL); } } /* release the generic package lock */ (void) unlockinst(); pkgcloseserver(pkgserver); quit(0); /* LINTED: no return */ }