int fpkginfo(struct pkginfo *info, char *pkginst) { if (info == NULL) { errno = EINVAL; return (-1); } initpkg(info); if (pkginst == NULL) return (0); else if (pkgnmchk(pkginst, "all", 1)) { errno = EINVAL; /* not an instance identifier */ return (-1); } if (pkgdir == NULL) pkgdir = get_PKGLOC(); if (rdconfig(info, pkginst, NULL)) { initpkg(info); return (-1); } return (0); }
/*VARARGS*/ char * fpkginst(char *pkg, ...) { static char pkginst[PKGSIZ+1]; static DIR *pdirfp; struct dirent *dp; char *ckarch, *ckvers; va_list ap; va_start(ap, pkg); if (pkg == NULL) { /* request to close or rewind the file */ if (pdirfp) { (void) closedir(pdirfp); pdirfp = NULL; } return (NULL); } ckarch = va_arg(ap, char *); ckvers = va_arg(ap, char *); va_end(ap); if (!pkgdir) pkgdir = get_PKGLOC(); if (!pdirfp && ((pdirfp = opendir(pkgdir)) == NULL)) { errno = EACCES; return (NULL); } while ((dp = readdir64(pdirfp)) != NULL) { if (dp->d_name[0] == '.') continue; if (pkgnmchk(dp->d_name, pkg, 0)) continue; /* ignore invalid SVR4 package names */ if (ckinfo(dp->d_name, ckarch, ckvers)) continue; /* * Leave directory open in case user requests another * instance. */ (void) strcpy(pkginst, dp->d_name); return (pkginst); } errno = ESRCH; /* close any file we might have open */ (void) closedir(pdirfp); pdirfp = NULL; return (NULL); }
static int compver(char *pkginst, char *version) { FILE *fp; char temp[256]; (void) sprintf(temp, "%s/%s/install/compver", get_PKGLOC(), pkginst); if ((fp = fopen(temp, "r")) == NULL) return (-1); while (fgets(temp, 256, fp)) { if (*temp == '#') continue; if (verscmp(temp, version) == 0) { (void) fclose(fp); return (0); } } (void) fclose(fp); return (-1); }
/*VARARGS*/ char * fpkginst(char *pkg, ...) { static char pkginst[PKGSIZ+1]; static DIR *pdirfp; struct dirent64 *dp; char *pt, *ckarch, *ckvers; va_list ap; va_start(ap, pkg); if (pkg == NULL) { /* request to close or rewind the file */ if (pdirfp) { (void) closedir(pdirfp); pdirfp = NULL; } (void) svr4inst(NULL); /* close any files used here */ return (NULL); } ckarch = va_arg(ap, char *); ckvers = va_arg(ap, char *); va_end(ap); if (!pkgdir) pkgdir = get_PKGLOC(); if (!pdirfp && ((pdirfp = opendir(pkgdir)) == NULL)) { errno = EACCES; return (NULL); } while ((dp = readdir64(pdirfp)) != NULL) { if (dp->d_name[0] == '.') continue; if (pkgnmchk(dp->d_name, pkg, 0)) continue; /* ignore invalid SVR4 package names */ if (ckinfo(dp->d_name, ckarch, ckvers)) continue; /* * Leave directory open in case user requests another * instance. */ (void) strcpy(pkginst, dp->d_name); return (pkginst); } /* * If we are searching the directory which contains info about * installed packages, check the pre-svr4 directory for an instance * and be sure it matches any version specification provided to us */ if (strcmp(pkgdir, get_PKGLOC()) == 0 && (ckarch == NULL)) { /* search for pre-SVR4 instance */ if (pt = svr4inst(pkg)) return (pt); } errno = ESRCH; /* close any file we might have open */ (void) closedir(pdirfp); pdirfp = NULL; return (NULL); }
static int rdconfig(struct pkginfo *info, char *pkginst, char *ckvers) { FILE *fp; char temp[256]; char *value, *pt, *copy, **memloc; int count; if ((fp = pkginfopen(pkgdir, pkginst)) == NULL) { if ((errno == ENOENT) && strcmp(pkgdir, get_PKGLOC()) == 0) return (svr4info(info, pkginst, ckvers)); errno = EACCES; return (-1); } *temp = '\0'; count = 0; while (value = fpkgparam(fp, temp)) { if (strcmp(temp, "ARCH") == 0 || strcmp(temp, "CATEGORY") == 0) { /* remove all whitespace from value */ pt = copy = value; while (*pt) { if (!isspace((unsigned char)*pt)) *copy++ = *pt; pt++; } *copy = '\0'; } count++; memloc = NULL; if (strcmp(temp, "NAME") == 0) memloc = &info->name; else if (strcmp(temp, "VERSION") == 0) memloc = &info->version; else if (strcmp(temp, "ARCH") == 0) memloc = &info->arch; else if (strcmp(temp, "VENDOR") == 0) memloc = &info->vendor; else if (strcmp(temp, "BASEDIR") == 0) memloc = &info->basedir; else if (strcmp(temp, "CATEGORY") == 0) memloc = &info->catg; temp[0] = '\0'; if (memloc == NULL) continue; /* not a parameter we're looking for */ *memloc = strdup(value); if (!*memloc) { (void) fclose(fp); errno = ENOMEM; return (-1); /* malloc from strdup failed */ } } (void) fclose(fp); if (!count) { errno = ESRCH; return (-1); } info->status = (strcmp(pkgdir, get_PKGLOC()) ? PI_SPOOLED : PI_INSTALLED); if (info->status == PI_INSTALLED) { (void) sprintf(temp, "%s/%s/!I-Lock!", pkgdir, pkginst); if (access(temp, 0) == 0) info->status = PI_PARTIAL; else { (void) sprintf(temp, "%s/%s/!R-Lock!", pkgdir, pkginst); if (access(temp, 0) == 0) info->status = PI_PARTIAL; } } info->pkginst = strdup(pkginst); return (0); }
static void dumpinfo(struct cfstat *dp, int pkgLngth) { register int i; char *pt; char category[128]; if (qflag) { return; /* print nothing */ } if (rflag) { (void) puts((info.basedir) ? info.basedir : "none"); return; } if (Lflag) { (void) puts(info.pkginst); return; } else if (xflag) { (void) printf(XFMT, pkgLngth, pkgLngth, info.pkginst, info.name); if (info.arch || info.version) { (void) printf(CFMT, pkgLngth, pkgLngth, ""); if (info.arch) (void) printf("(%s) ", info.arch); if (info.version) (void) printf("%s", info.version); (void) printf("\n"); } return; } else if (!lflag) { if (info.catg) { (void) sscanf(info.catg, "%[^, \t\n]", category); } else { (void) strcpy(category, "(unknown)"); } (void) printf(SFMT, category, pkgLngth, pkgLngth, info.pkginst, info.name); return; } if (info.pkginst) (void) printf(FMT, "PKGINST", info.pkginst); if (info.name) (void) printf(FMT, "NAME", info.name); if (lflag && info.catg) (void) printf(FMT, "CATEGORY", info.catg); if (lflag && info.arch) (void) printf(FMT, "ARCH", info.arch); if (info.version) (void) printf(FMT, "VERSION", info.version); if (info.basedir) (void) printf(FMT, "BASEDIR", info.basedir); if (info.vendor) (void) printf(FMT, "VENDOR", info.vendor); for (i = 0; parmlst[i]; ++i) { if ((pt = pkgparam(info.pkginst, parmlst[i])) != NULL && *pt) (void) printf(FMT, parmlst[i], pt); } if (info.status == PI_SPOOLED) (void) printf(FMT, "STATUS", gettext("spooled")); else if (info.status == PI_PARTIAL) (void) printf(FMT, "STATUS", gettext("partially installed")); else if (info.status == PI_INSTALLED) (void) printf(FMT, "STATUS", gettext("completely installed")); else (void) printf(FMT, "STATUS", gettext("(unknown)")); (void) pkgparam(NULL, NULL); if (!lflag) { (void) putchar('\n'); return; } if (strcmp(pkgdir, get_PKGLOC())) getinfo(dp); if (dp->spooled) (void) printf( gettext("%10s: %7ld spooled pathnames\n"), "FILES", dp->spooled); if (dp->installed) (void) printf( gettext("%10s: %7ld installed pathnames\n"), "FILES", dp->installed); if (dp->partial) (void) printf( gettext("%20d partially installed pathnames\n"), dp->partial); if (dp->shared) (void) printf(gettext("%20d shared pathnames\n"), dp->shared); if (dp->link) (void) printf(gettext("%20d linked files\n"), dp->link); if (dp->dirs) (void) printf(gettext("%20d directories\n"), dp->dirs); if (dp->exec) (void) printf(gettext("%20d executables\n"), dp->exec); if (dp->setuid) (void) printf( gettext("%20d setuid/setgid executables\n"), dp->setuid); if (dp->info) (void) printf( gettext("%20d package information files\n"), dp->info+1); /* pkgmap counts! */ if (dp->tblks) (void) printf(gettext("%20ld blocks used (approx)\n"), dp->tblks); (void) putchar('\n'); }
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 */ }
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 */ }