int fileSysTest() { Vdisk disk1("filesys1", 100, 500); FileSys fsys("filesys1"); fsys.makeFile("file1"); fsys.makeFile("file2"); std::string bfile; for (int i = 1; i <= 1500; ++i) { bfile += "1"; } std::vector<std::string> blocks = block(bfile, 500); int blocknumber = 0; for (unsigned int i = 0; i < blocks.size(); ++i) { blocknumber = fsys.addBlock("file1", blocks[i]); } fsys.deleteBlock("file1", fsys.getFirstBlock("file1")); for (unsigned int i = 1; i <= 2000; ++i) { bfile += "2"; } for (unsigned int i = 0; i < blocks.size(); ++i) { blocknumber = fsys.addBlock("file2", blocks[i]); } fsys.deleteBlock("file2", blocknumber); return 1; }
/* * This function returns the served status of the filesystem. Served means a * client is getting this file from a server and it is not writeable by the * client. It has nothing to do with whether or not this particular operation * (eg: pkgadd or pkgrm) will be writing to it. */ int is_served(char *path, uint32_t *fsys_value) { if (*fsys_value == BADFSYS) *fsys_value = fsys(path); return (is_served_n(*fsys_value)); }
/* * is_remote_fs - given a cfent entry, return 1 * if it's a remote filesystem, 0 if local. * * Also Note: Upon exit, a valid fsys() is guaranteed. This is * an interface requirement. */ int is_remote_fs(char *path, uint32_t *fsys_value) { if (*fsys_value == BADFSYS) *fsys_value = fsys(path); return (is_remote_fs_n(*fsys_value)); }
/* * is_fs_writeable - given a cfent entry, return 1 * if it's writeable, 0 if read-only. * * Note: Upon exit, a valid fsys() is guaranteed. This is * an interface requirement. */ int is_fs_writeable(char *path, uint32_t *fsys_value) { if (*fsys_value == BADFSYS) *fsys_value = fsys(path); return (is_fs_writeable_n(*fsys_value)); }
/* * This function returns the srvr_map status based upon the path. */ int use_srvr_map(char *path, uint32_t *fsys_value) { if (*fsys_value == BADFSYS) *fsys_value = fsys(path); return (use_srvr_map_n(*fsys_value)); }
/* * This function returns the entry in the fs_tab[] corresponding to the * actual filesystem of record. It won't return a loopback filesystem entry, * it will return the filesystem that the loopback filesystem is mounted * over. */ uint32_t resolved_fsys(char *path) { int i = -1; char path2use[PATH_MAX]; (void) strcpy(path2use, path); /* If this isn't a "real" filesystem, resolve the map. */ do { (void) strcpy(path2use, server_map(path2use, i)); i = fsys(path2use); } while (fs_tab[i]->srvr_map); return (i); }
// struct jsdl_data_staging // { // struct jsdl_data_staging * next; // char * name; // char * FileName; // char * FileSystemName; // enum jsdl_creation_flags CreationFlag; // int DeleteOnTermination; // char * Source; // char * Target; // struct hpcp_credential * Credential; // }; void job_description::set_file_transfers (std::vector <std::string> specs) { // " http://host.one/data/one >> ftp://host.two/stage/two" // "UserPass @ http://host.one/data/one > ftp://host.two/stage/two" std::string spec_pattern = "^(([^ ]+) +@ +)?([^ ><]+) *(>|>>|<|<<) *([^ ><]+)$"; regex_t regex; if ( 0 != regcomp (®ex, spec_pattern.c_str (), REG_EXTENDED) ) { throw "regcomp() failed"; // FIXME errno } for ( unsigned int i = 0; i < specs.size (); i++ ) { std::string spec = specs[i]; size_t nmatch = 6; regmatch_t pmatch[6]; std::cout << "parsing '" << spec << "' against '" << spec_pattern << "'" << std::endl; if ( 0 != regexec (®ex, spec.c_str (), nmatch, pmatch, 0) ) { throw "regexec() failed"; // FIXME errno } std::vector <std::string> matches; matches.resize (6, ""); for ( unsigned int j = 0; j < nmatch; j++ ) { if ( pmatch[j].rm_so != -1 ) { for ( int k = pmatch[j].rm_so; k < pmatch[j].rm_eo; k++ ) { matches[j] += spec[k]; } } std::cout << " spec match " << j << " : " << matches[j] << std::endl; } std::string fname (""); std::string fsys (""); std::string src (""); std::string tgt (""); std::string ctx (""); staging_flag flag; bool cleanup = false; std::cout << "matches: " << matches.size () << std::endl; // 0 1 2 3 4 5 // "^( ([^\\s]+)\\s+@\\s+)?([^\\><s]+)\\s*(>|>>|<|<<)\\s*([^\\><s]+)$"; ctx = matches[2]; if ( matches[4] == ">" || matches[4] == ">>" ) { // stage in src = matches[3]; fname = matches[5]; if ( matches[4] == ">" ) { flag = Overwrite; } else { flag = Append; } } else if ( matches[4] == "<" || matches[4] == "<<" ) { // stage out tgt = matches[3]; fname = matches[5]; if ( matches[4] == "<" ) { flag = Overwrite; } else { flag = Append; } } else { throw "invalid file transfer operation"; // FIXME: details } struct jsdl_data_staging * file = new struct jsdl_data_staging; file->next = NULL; file->name = NULL; file->FileName = NULL; file->FileSystemName = NULL; file->CreationFlag = jsdl_nocreationflag; file->DeleteOnTermination = 0; file->Source = NULL; file->Target = NULL; file->Credential = NULL; if ( ! fname.empty () ) { file->FileName = ::strdup (fname.c_str ()); if ( file->FileName == NULL ) { throw "strdup error"; } } if ( ! fsys.empty () ) { file->FileSystemName = ::strdup (fsys.c_str ()); if ( file->FileSystemName == NULL ) { throw "strdup error"; } } if ( flag & Overwrite ) { file->CreationFlag = jsdl_overwrite; } else if ( flag & Append ) { file->CreationFlag = jsdl_append; } else if ( flag & DontOverwrite ) { file->CreationFlag = jsdl_dontOverwrite; } if ( cleanup ) { file->DeleteOnTermination = 1; } if ( ! src.empty () ) { file->Source = ::strdup (src.c_str ()); if ( file->Source == NULL ) { throw "strdup error"; } } if ( ! tgt.empty () ) { file->Target = ::strdup (tgt.c_str ()); if ( file->Target == NULL ) { throw "strdup error"; } } if ( ! ctx.empty () ) { std::cout << "no credential support for file staging, yet: " << ctx << std::endl; // throw "no credential support for file staging, yet"; // struct hpcp_credential * cred = NULL; // if ( (rc = jsdl_processCredential(cur, &cred)) != BESE_OK ) // { // jsdl_freeDataStaging(file); // return rc; // } // file->Credential = cred; } struct jsdl_data_staging * cur_file = jsdl_->DataStaging; if ( cur_file ) { while ( cur_file->next ) { cur_file = cur_file->next; } cur_file->next = file; } else { jsdl_->DataStaging = file; } } regfree (®ex); // FIXME: we should re-use the compiled regex }
/* * This function constructs a new fs_tab[] entry based on * an /etc/vfstab entry. When it returns, the new entry has been inserted * into fstab[]. */ static int construct_vfs(struct vfstab *vfsent, char *client_path, char *link_name, int is_remote, int mnt_stat) { int use_link; struct fstable *nfte; if ((nfte = fs_tab_init(client_path, vfsent->vfs_fstype)) == NULL) return (1); nfte->remote = (is_remote == REAL_REMOTE); /* * The file system mounted on the client may or may not be writeable. * So we hand it over to fsys() to evaluate. This will have the same * read/write attributes as the corresponding mounted filesystem. */ use_link = 0; if (nfte->remote) { /* * Deal here with mount points actually on a system remote * from the server. */ if (mnt_stat == MNT_NOT) { /* * This filesystem isn't in the current mount table * meaning it isn't mounted, the current host can't * write to it and there's no point to mapping it for * the server. */ link_name = NULL; nfte->mounted = 0; nfte->srvr_map = 0; nfte->writeable = 0; } else { /* It's MNT_AVAIL. */ /* * This filesystem is associated with a current * mountpoint. Since it's mounted, it needs to be * remapped and it is writable if the real mounted * filesystem is writeable. */ use_link = 1; link_name = strdup(fs_tab[match_mount]->name); nfte->mounted = 1; nfte->srvr_map = 1; nfte->writeable = fs_tab[match_mount]->writeable; nfte->write_tested = fs_tab[match_mount]->write_tested; } } else { /* local filesystem */ use_link = 1; nfte->mounted = 1; nfte->srvr_map = 1; nfte->writeable = fs_tab[fsys(link_name)]->writeable; nfte->write_tested = 1; } /* * Now we establish whether the client will see this as served. */ if (is_remote && hasopt(vfsent->vfs_mntopts, MNTOPT_RO)) nfte->served = 1; if (use_link) { nfte->remote_name = link_name; } else { nfte->remote_name = strdup(vfsent->vfs_special); } return (0); }
/* * This function reads all of the package objects, maps them to their target * filesystems and adds up the amount of space used on each. Wherever you see * "fsys_value", that's the apparent filesystem which could be a temporary * loopback mount for the purpose of constructing the client filesystem. It * isn't necessarily the real target filesystem. Where you see "fsys_base" * that's the real filesystem to which fsys_value may just refer. If this is * installing to a standalone or a server, fsys_value will almost always be * the same as fsys_base. */ static int readmap(int *error) { struct fstable *fs_tab; struct cfextra *ext; struct cfent *ept; struct stat statbuf; char tpath[PATH_MAX]; fsblkcnt_t blk; int i, n; /* * Handle the installation files (ftype i) that are in the * pkgmap/eptlist. */ for (i = 0; (ext = extlist[i]) != NULL; i++) { ept = &(ext->cf_ent); if (ept->ftype != 'i') continue; /* * These paths are treated differently from the others * since their full pathnames are not included in the * pkgmap. */ if (strcmp(ept->path, "pkginfo") == 0) (void) sprintf(tpath, "%s/%s", pkgloc, ept->path); else (void) sprintf(tpath, "%s/install/%s", pkgloc, ept->path); /* If we haven't done an fsys() series, do one */ if (ext->fsys_value == BADFSYS) ext->fsys_value = fsys(tpath); /* * Now check if this is a base or apparent filesystem. If * it's just apparent, get the resolved filesystem entry, * otherwise, base and value are the same. */ if (use_srvr_map_n(ext->fsys_value)) ext->fsys_base = resolved_fsys(tpath); else ext->fsys_base = ext->fsys_value; if (fsys_stat(ext->fsys_base)) { (*error)++; continue; } /* * Don't accumulate space requirements on read-only * remote filesystems. */ if (is_remote_fs_n(ext->fsys_value) && !is_fs_writeable_n(ext->fsys_value)) continue; fs_tab = get_fs_entry(ext->fsys_base); fs_tab->fused++; if (ept->cinfo.size != BADCONT) blk = nblk(ept->cinfo.size, fs_tab->bsize, fs_tab->frsize); else blk = 0; fs_tab->bused += blk; } /* * Handle the other files in the eptlist. */ for (i = 0; (ext = extlist[i]) != NULL; i++) { ept = &(extlist[i]->cf_ent); if (ept->ftype == 'i') continue; /* * Don't recalculate package objects that are already in the * table. */ if (ext->mstat.preloaded) continue; /* * Don't accumulate space requirements on read-only * remote filesystems. */ if (is_remote_fs(ept->path, &(ext->fsys_value)) && !is_fs_writeable(ept->path, &(ext->fsys_value))) continue; /* * Now check if this is a base or apparent filesystem. If * it's just apparent, get the resolved filesystem entry, * otherwise, base and value are the same. */ if (use_srvr_map_n(ext->fsys_value)) ext->fsys_base = resolved_fsys(tpath); else ext->fsys_base = ext->fsys_value; /* At this point we know we have a good fsys_base. */ if (fsys_stat(ext->fsys_base)) { (*error)++; continue; } /* * We have to stat this path based upon it's real location. * If this is a server-remap, ept->path isn't the real * location. */ if (use_srvr_map_n(ext->fsys_value)) strcpy(tpath, server_map(ept->path, ext->fsys_value)); else strcpy(tpath, ept->path); fs_tab = get_fs_entry(ext->fsys_base); if (stat(tpath, &statbuf)) { /* path cannot be accessed */ fs_tab->fused++; if (strchr("dxs", ept->ftype)) blk = nblk(fs_tab->bsize, fs_tab->bsize, fs_tab->frsize); else if (ept->cinfo.size != BADCONT) blk = nblk(ept->cinfo.size, fs_tab->bsize, fs_tab->frsize); else blk = 0; } else { /* path already exists */ if (strchr("dxs", ept->ftype)) blk = 0; else if (ept->cinfo.size != BADCONT) { fsblkcnt_t new_size, old_size; new_size = nblk(ept->cinfo.size, fs_tab->bsize, fs_tab->frsize); old_size = nblk(statbuf.st_size, fs_tab->bsize, fs_tab->frsize); /* * negative blocks show room freed, but since * order of installation is uncertain show * 0 blocks usage */ if (new_size < old_size) blk = 0; else blk = new_size - old_size; } else blk = 0; } fs_tab->bused += blk; } 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 */ }
static char * check_db_entry(VFP_T *vfpo, struct cfextra *entry, int rmflag, char *myclass, int *dbchg) { struct pinfo *pinfo; int fs_entry; char *save_path = NULL; char *tp; /* write this entry to the contents file */ if (myclass && strcmp(myclass, entry->cf_ent.pkg_class)) { if (putcvfpfile(&entry->cf_ent, vfpo)) { progerr(gettext(ERR_WRITE)); quit(99); } return (NULL); } /* * Now scan each package instance holding this file or * directory and see if it matches the package we are * updating here. */ pinfo = entry->cf_ent.pinfo; while (pinfo) { if (strcmp(pkginst, pinfo->pkg) == 0) break; pinfo = pinfo->next; } /* * If pinfo == NULL at this point, then this file or * directory isn't part of the package of interest. * So the loop below executes only on files in the package * of interest. */ save_path = NULL; if (pinfo) { if (rmflag && (pinfo->status == RM_RDY)) { *dbchg = 1; (void) eptstat(&(entry->cf_ent), pkginst, '@'); if (entry->cf_ent.npkgs) { if (putcvfpfile(&(entry->cf_ent), vfpo)) { progerr(gettext(ERR_WRITE)); quit(99); } } return (NULL); } else if (!rmflag && (pinfo->status == INST_RDY)) { *dbchg = 1; /* tp is the server-relative path */ tp = fixpath(entry->cf_ent.path); /* save_path is the cmd line path */ save_path = entry->cf_ent.path; /* entry has the server-relative path */ entry->cf_ent.path = tp; /* * The next if statement figures out how * the contents file entry should be * annotated. * * Don't install or verify objects for * remote, read-only filesystems. We * need only verify their presence and * flag them appropriately from some * server. Otherwise, ok to do final * check. */ fs_entry = fsys(entry->cf_ent.path); if (is_remote_fs_n(fs_entry) && !is_fs_writeable_n(fs_entry)) { /* * Mark it shared whether it's present * or not. life's too funny for me * to explain. */ pinfo->status = SERVED_FILE; /* * restore for now. This may * chg soon. */ entry->cf_ent.path = save_path; } else { /* * If the object is accessible, check * the new entry for existence and * attributes. If there's a problem, * mark it NOT_FND; otherwise, * ENTRY_OK. */ if (is_mounted_n(fs_entry)) { int n; n = finalck((&entry->cf_ent), 1, 1, B_FALSE); pinfo->status = ENTRY_OK; if (n != 0) { pinfo->status = NOT_FND; } } /* * It's not remote, read-only but it * may look that way to the client. * If it does, overwrite the above * result - mark it shared. */ if (is_served_n(fs_entry)) pinfo->status = SERVED_FILE; /* restore original path */ entry->cf_ent.path = save_path; /* and clear save_path */ save_path = NULL; } } } /* Output entry to contents file. */ if (putcvfpfile(&(entry->cf_ent), vfpo)) { progerr(gettext(ERR_WRITE)); quit(99); } return (save_path); }