static void
usage(void)
{
(void) fprintf(stderr,
gettext("usage: %s [-ions] srcdev dstdev [pkg [pkg...]]\n"),
get_prog_name());
}
static void
usage(void)
{
(void) fprintf(stderr, gettext("usage: %s cmd keyword src dest\n"),
get_prog_name());
exit(2);
}
/*PRINTFLIKE1*/
void
echoDebug(char *a_fmt, ...)
{
va_list ap;
/* output debugging message if debugging is enabled */
if (debugFlag == B_TRUE) {
char *p = get_prog_name();
(void) fprintf(stderr, "# [%6d %3d", getpid(), getzoneid());
if ((p != (char *)NULL) && (*p != '\0')) {
fprintf(stderr, " %-11s", p);
}
(void) fprintf(stderr, "] ");
va_start(ap, a_fmt);
(void) vfprintf(stderr, a_fmt, ap);
va_end(ap);
(void) putc('\n', stderr);
}
}
int main(int argc, char *argv[])
{
char progname[64];
char serial[8];
char stimeout_min[9];
int ret;
memset(progname, 0, sizeof(progname));
get_prog_name(argv[0], progname);
init_log("./", progname);
memset(serial, 0, sizeof(serial));
memset(stimeout_min, 0, sizeof(stimeout_min));
if( (ret=get_current_serial(CONF_FILE, serial, stimeout_min)) != 0) {
log("get conf error[%d]\n", ret);
return 0;
}
if(argc == 1) {
gen_result(serial, stimeout_min);
}
else {
gen_this_result(serial);
}
return 0;
}
static void
usage(void)
{
(void) fprintf(stderr, gettext(ERR_USAGE), get_prog_name());
exit(1);
/*NOTREACHED*/
}
static void
usage(void)
{
(void) fprintf(stderr,
gettext("usage: %s [-ionsg] [-k keystore] " \
"[-a alias] [-P password] srcdev dstdev [pkg [pkg...]]\n"),
get_prog_name());
}
static void
usage(void)
{
char *prog = get_prog_name();
/* bug # 1081606 */
(void) fprintf(stderr, gettext(ERR_USAGE), prog, prog);
exit(1);
}
static void
trap(int n)
{
(void) signal(SIGINT, SIG_IGN);
(void) signal(SIGHUP, SIG_IGN);
if (n == SIGINT)
quit(3);
else {
(void) fprintf(stderr, gettext("%s terminated (signal %d).\n"),
get_prog_name(), n);
quit(99);
}
}
void prog_init(Getopt& getopt, int argc, char* argv[])
{
getopt.addOption("help", Option::NO_ARG);
getopt.addOption("verbose", Option::NO_ARG);
getopt.addOption("configfile", Option::REQ_ARG);
getopt.addOption("logfile", Option::REQ_ARG);
if (getopt.processOpts(argc, argv)) {
getopt.showHelp(std::cout);
exit(1);
}
if (getopt.getOption('h').is_set()) {
getopt.showHelp(std::cout);
exit(0);
}
const bool verbose = getopt.getOption('v').is_set();
std::string default_cfg = "configfiles/config.";
std::string default_log = "logfiles/";
std::string prog_name = get_prog_name(argv[0]);
default_cfg += prog_name;
default_log += prog_name + ".log";
// std::cout << default_cfg << ' ' << default_log << std::endl;
const std::string cfgFile(getopt.getOption('c').is_set() ?
getopt.getOption('c').arg() :
default_cfg);
ConfigFile::get_mutable_instance().init(cfgFile);
if (verbose) {
std::cout << "using config file " << cfgFile << std::endl;
}
const std::string logFile(getopt.getOption('l').is_set() ?
getopt.getOption('l').arg() :
default_log);
Logger::init(logFile);
if (verbose) {
std::cout << "writing to log file " << logFile << std::endl;
}
}
int handle_live(t_vm *vm, t_program *prog, int index)
{
int id;
id = get_prog_number(prog, vm);
if (id < 0)
return (0);
if (++vm->nb_live == NBR_LIVE)
{
vm->nb_live = 0;
vm->cycle_to_die -= CYCLE_DELTA;
my_printf("[VM] - cycle to die : %d\n", vm->cycle_to_die);
}
if (vm->progs_live[id] == -1)
{
prog->active = 0;
return (0);
}
vm->progs_live[id] = vm->cycle;
my_printf("le joueur %d (%s) est en vie\n", id,
get_prog_name(vm, id));
(void)index;
return (5);
}
/*PRINTFLIKE2*/
void
log_msg(LogMsgType a_type, const char *a_format, ...)
{
FILE *out;
char *rstr = (char *)NULL;
char bfr[1];
char *prefix;
size_t vres = 0;
va_list ap;
char *p = get_prog_name();
/* process message based on type */
switch (a_type) {
case LOG_MSG_ERR:
default: /* treat unknown type as LOG_MSG_ERR */
out = stderr;
prefix = MSG_LOG_ERROR;
break;
case LOG_MSG_WRN: /* warning message */
out = stderr;
prefix = MSG_LOG_WARNING;
break;
case LOG_MSG_INFO: /* information message */
out = stdout;
prefix = NULL;
break;
case LOG_MSG_DEBUG: /* debugging message */
if (!log_get_verbose()) {
/* no debug messages if not verbose mode */
return;
}
out = stderr;
prefix = NULL;
/* output debug prefix to match echoDebug() format */
(void) fprintf(stderr, "# [%6d %3d", getpid(),
#ifdef __sun
getzoneid()
#else
0
#endif
);
if ((p != (char *)NULL) && (*p != '\0')) {
fprintf(stderr, " %-11s", p);
}
(void) fprintf(stderr, "] ");
break;
}
/* output prefix if specified */
if (prefix != NULL) {
(void) fprintf(out, "%s: ", prefix);
}
/* determine size of the message in bytes */
va_start(ap, a_format);
vres = vsnprintf(bfr, 1, a_format, ap);
va_end(ap);
/* allocate storage to hold the message */
rstr = (char *)malloc(vres+2);
/* generate the results of the printf conversion */
va_start(ap, a_format);
vres = vsnprintf(rstr, vres+1, a_format, ap);
va_end(ap);
/* output formatted message to appropriate destination */
if (fprintf(out, "%s\n", rstr) < 0) {
if (out != stderr) {
/*
* nothing output, try stderr as a
* last resort
*/
(void) fprintf(stderr, ERR_LOG_FAIL, a_format);
}
}
/* free temporary message storage */
free(rstr);
}
int
swapcfile(PKGserver server, VFP_T **a_cfTmpVfp, char *pkginst, int dbchg)
{
char *pe;
char *pl;
char *ps;
char line[256];
char timeb[BUFSIZ];
int retval = RESULT_OK;
struct tm *timep;
time_t clock;
/* normalize pkginst so its never null */
if (pkginst == (char *)NULL) {
dbchg = 0;
pkginst = "<unknown>";
}
/*
* If no changes were made to the database, checkpoint the temporary
* contents file - if this fails, then just close the file which causes
* the contents file to be reopened and reread if it is needed again
*/
if ((dbchg == 0) && (vfpGetModified(*a_cfTmpVfp) == 0)) {
(void) pkgWunlock(); /* Free the database lock. */
return (retval);
}
/*
* changes made to the current temporary contents file -
* remove any trailing comment lines in the temp contents file, then
* append updated modification info records to temp contents file
*/
pe = vfpGetCurrCharPtr(*a_cfTmpVfp); /* last char in contents file */
ps = vfpGetFirstCharPtr(*a_cfTmpVfp); /* 1st char in contents file */
pl = pe; /* last match is last char in contents file */
/* skip past all trailing newlines and null bytes */
while ((pe > ps) && ((*pe == '\n') || (*pe == '\0'))) {
pe--;
}
/* remove trailing comments as long as there are lines in the file */
while (pe > ps) {
if (*pe != '\n') {
/* curr char is not newline: backup one byte */
pl = pe--;
} else if (*pl != '#') {
/* curr char is newline next char not comment break */
break;
} else {
/* curr char is newline next char is comment - remove */
*pl = '\0';
vfpSetLastCharPtr(*a_cfTmpVfp, pl);
pe--;
}
}
/* create two update comment lines */
(void) time(&clock);
timep = localtime(&clock);
(void) strftime(timeb, sizeof (timeb), "%c\n", timep);
(void) snprintf(line, sizeof (line),
gettext("# Last modified by %s for %s package\n# %s"),
get_prog_name(), pkginst, timeb);
vfpPuts(*a_cfTmpVfp, line);
/* commit temporary contents file bytes to storage */
if (pkgservercommitfile(*a_cfTmpVfp, server) != 0) {
int lerrno = errno;
logerr(gettext(ERR_COMMIT));
vfpClose(a_cfTmpVfp);
pkgcloseserver(server);
(void) pkgWunlock(); /* Free the database lock. */
return (RESULT_ERR);
}
return (relslock() == 0 ? RESULT_ERR : retval);
}
int
main(int argc, char *argv[])
{
int c;
void (*func)();
extern char *optarg;
extern int optind;
char *keystore_alias = NULL;
char *keystore_file = NULL;
boolean_t create_sig = B_FALSE;
char *homedir = NULL;
PKG_ERR *err;
int ret, len;
(void) setlocale(LC_ALL, "");
#if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */
#define TEXT_DOMAIN "SYS_TEST"
#endif
(void) textdomain(TEXT_DOMAIN);
(void) set_prog_name(argv[0]);
while ((c = getopt(argc, argv, "ga:P:k:snio?")) != EOF) {
switch (c) {
case 'n':
options |= PT_RENAME;
break;
case 'i':
options |= PT_INFO_ONLY;
break;
case 'o':
options |= PT_OVERWRITE;
break;
case 's':
options |= PT_ODTSTREAM;
break;
case 'g':
/* this should eventually be a PT_ option */
create_sig = B_TRUE;
break;
case 'k':
keystore_file = optarg;
break;
case 'a':
keystore_alias = optarg;
break;
case 'P':
set_passphrase_passarg(optarg);
if (ci_strneq(optarg, "pass:"******"pass:<pass>");
}
break;
default:
usage();
return (1);
}
}
func = signal(SIGINT, trap);
if (func != SIG_DFL)
(void) signal(SIGINT, func);
(void) signal(SIGHUP, trap);
(void) signal(SIGQUIT, trap);
(void) signal(SIGTERM, trap);
(void) signal(SIGPIPE, trap);
(void) signal(SIGPWR, trap);
if ((argc-optind) < 2) {
usage();
return (1);
}
if (create_sig) {
sec_init();
err = pkgerr_new();
/* figure out which keystore to use */
if (keystore_file == NULL) {
if (geteuid() == 0) {
/* we are superuser, so use their keystore */
keystore_file = PKGSEC;
} else if ((homedir = getenv("HOME")) == NULL) {
/*
* not superuser, but no home dir, so
* use superuser's keystore
*/
keystore_file = PKGSEC;
} else if (asprintf(&keystore_file, "%s/.pkg/security",
homedir) < 0) {
logerr(ERR_MEM);
quit(1);
}
}
logerr(gettext(KEYSTORE_OPEN), keystore_file);
set_passphrase_prompt(MSG_PASSPROMPT);
/* open keystore for reading */
if (open_keystore(err, keystore_file, get_prog_name(),
pkg_passphrase_cb, KEYSTORE_DFLT_FLAGS, &keystore) != 0) {
pkgerr(err);
pkgerr_free(err);
quit(1);
}
} else {
/* no signature, so don't use a keystore */
keystore = NULL;
}
ret = pkgtrans(flex_device(argv[optind], 1),
flex_device(argv[optind+1], 1), &argv[optind+2], options,
keystore, keystore_alias);
if (create_sig) {
/* close keystore */
if (close_keystore(err, keystore, NULL) != 0) {
pkgerr(err);
pkgerr_free(err);
quit(1);
}
keystore = NULL;
}
quit(ret);
/*NOTREACHED*/
}
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 */
}
void main (int argc, char *argv [])
{
FILE *in, *out;
int toprg = TRUE, mult = FALSE, lower = TRUE, stomp = FALSE;
int filegiven = FALSE, i, k, casemode = TRUE, colmode = FALSE;
char fin [MAXPATH], fout [MAXPATH], inmode [3], outmode [3];
char in_ext [MAXEXT], out_ext [MAXEXT], fext [MAXEXT];
kw_list [0] = keywords;
kw_list [1] = KW_NULL;
get_prog_name (argv [0]);
if (argc == 1) usage ();
else
{
for (i = 1; i < argc; i++)
{
for (k = 0; k < (int)strlen (argv [i]); k++)
argv [i][k] = tolower (argv [i][k]);
if (argv [i][0] == '/' || argv [i][0] == '-')
{
if (! strcmp (argv [i], cmds [TOTXT].command))
toprg = FALSE;
else if (! strcmp (argv [i], cmds [TOPRG].command))
toprg = TRUE;
else if (! strcmp (argv [i], cmds [MULT].command))
mult = TRUE;
else if (! strcmp (argv [i], cmds [NOMULT].command))
mult = FALSE;
else if (! (strcmp (argv [i], cmds [HELP].command)
&& strcmp (argv [i], "/h")
&& strcmp (argv [i], "/?")
&& strcmp (argv [i], "-h")))
help ();
else if (! strcmp (argv [i], cmds [LIST].command))
list_cmds ();
else if (! strcmp (argv [i], cmds [KEYWORDS].command))
list_keywords ();
else if (! strcmp (argv [i], cmds [SPECIAL].command))
list_special ();
else if (! strcmp (argv [i], cmds [EXTENSIONS].command))
list_extensions ();
else if (! strcmp (argv [i], cmds [LOWER].command))
lower = TRUE;
else if (! strcmp (argv [i], cmds [UPPER].command))
lower = FALSE;
else if (! strcmp (argv [i], cmds [LOWCASE].command))
casemode = FALSE;
else if (! strcmp (argv [i], cmds [CASE].command))
casemode = TRUE;
else if (! strcmp (argv [i], cmds [COL].command))
colmode = TRUE;
else if (! strcmp (argv [i], cmds [NOCOL].command))
colmode = FALSE;
else if (! strcmp (argv [i], cmds [STOMP].command))
stomp = TRUE;
else if (! strcmp (argv [i], cmds [NOSTOMP].command))
stomp = FALSE;
else if (! strcmp (argv [i], cmds [FINCART3].command))
{
kw_list [0] = final_cart_3;
kw_list [1] = keywords;
kw_list [2] = KW_NULL;
}
else if (! strcmp (argv [i], cmds [GRAPH52].command))
{
kw_list [0] = graphics_52;
kw_list [1] = keywords;
kw_list [2] = KW_NULL;
}
else if (! strcmp (argv [i], cmds [ASM6510PLUS].command))
{
kw_list [0] = asm6510plus;
kw_list [1] = keywords;
kw_list [2] = KW_NULL;
}
else if (! strcmp (argv [i], cmds [C64].command))
{
kw_list [0] = keywords;
kw_list [1] = KW_NULL;
}
else
{
fprintf (stderr, "%s: invalid command \"%s\".\n",
program, argv [i]);
exit (EXITBAD);
}
}
else
{
filegiven = TRUE;
if (toprg)
{
strcpy (in_ext, TXT_EXT);
strcpy (out_ext, PRG_EXT);
strcpy (inmode, "rt");
strcpy (outmode, "wb");
}
else
{
strcpy (in_ext, PRG_EXT);
strcpy (out_ext, TXT_EXT);
strcpy (inmode, "rb");
strcpy (outmode, "wt");
}
/* get base name and check if there's an extension */
if (! basename (argv [i], fout, MAXPATH - 1))
{
/* nope, no extension specified */
strcpy (fin, fout);
strncat (fin, in_ext, MAXPATH - 1);
}
else
{
strncpy (fin, argv [i], MAXPATH - 1);
extension (fin, fext, MAXEXT - 1);
if (! strcmp (fext, out_ext))
{
fprintf (stderr, "%s: not expecting \"%s\" as input.\n",
program, argv [i]);
exit (EXITBAD);
}
}
strncat (fout, out_ext, MAXPATH - 1);
if ((in = fopen (fin, inmode)) == NULL)
{
fprintf (stderr, "%s: Can't open %s for input.\n",
program, fin);
exit (EXITBAD);
}
else if (mult)
{
fprintf (stderr, "processing %s ...\n", fin);
process_mult (in, stomp, casemode, colmode);
fprintf (stderr, "processing of %s complete.\n", fin);
}
else
{
if (! exit_exists (stomp, in, fout))
{
if ((out = fopen (fout, outmode)) == NULL)
{
fprintf (stderr, "%s: Can't open %s for output\n",
program, fout);
exit (EXITBAD);
}
else
{
fprintf (stderr, "%s ==> %s ...", fin, fout);
if (toprg) txt2prg (in, out, casemode, colmode);
else prg2txt (in, out, fin, lower);
fclose (out);
fprintf (stderr, " done.\n");
}
}
fclose (in);
} /* end can open input file */
} /* end command line arg check */
} /* end for loop thru args */
} /* end if check for args */
if (! filegiven) usage ();
exit (EXITOK);
} /* end main */
