OpenSolaris_b135/lib/brand/native/zone/sw_support.c
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
* sw_support does install, detach and attach processing for svr4 pkgs.
*/
#include <stdio.h>
#include <errno.h>
#include <unistd.h>
#include <signal.h>
#include <stdarg.h>
#include <ctype.h>
#include <stdlib.h>
#include <string.h>
#include <wait.h>
#include <zone.h>
#include <locale.h>
#include <libintl.h>
#include <libzonecfg.h>
#include <sys/param.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <assert.h>
#include <limits.h>
#include <stddef.h>
#include <dirent.h>
#include <libxml/xmlmemory.h>
#include <libxml/parser.h>
#include <fcntl.h>
#include <door.h>
#include <macros.h>
#include <libgen.h>
#include <fnmatch.h>
#include <strings.h>
#include <libzonecfg.h>
#define ZONE_SUBPROC_OK 0
#define ZONE_SUBPROC_USAGE 253
#define ZONE_SUBPROC_NOTCOMPLETE 254
#define ZONE_SUBPROC_FATAL 255
#define Z_ERR 1
#define Z_USAGE 2
#define Z_FATAL 3
#define SW_CMP_NONE 0x0
#define SW_CMP_SRC 0x01
#define SW_CMP_SILENT 0x02
#define TMP_MANIFEST "SUNWupdate.xml"
#define PKG_PATH "/var/sadm/pkg"
#define CONTENTS_FILE "/var/sadm/install/contents"
#define SUNW_PKG_ALL_ZONES "SUNW_PKG_ALLZONES=true\n"
#define SUNW_PKG_THIS_ZONE "SUNW_PKG_THISZONE=true\n"
#define VERSION "VERSION="
#define PATCHLIST "PATCHLIST="
#define PATCHINFO "PATCH_INFO_"
#define PKGINFO_RD_LEN 128
#define MY_BRAND_NAME "native"
#define EXEC_PREFIX "exec "
#define EXEC_LEN (strlen(EXEC_PREFIX))
#define RMCOMMAND "/usr/bin/rm -rf"
/* 0755 is the default directory mode. */
#define DEFAULT_DIR_MODE (S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)
/* These are the file status indicators for the contents file */
#define INST_RDY '+' /* entry is ready to installf -f */
#define RM_RDY '-' /* entry is ready for removef -f */
#define NOT_FND '!' /* entry (or part of entry) was not found */
#define SERVED_FILE '%' /* using the file server's RO partition */
#define STAT_NEXT '@' /* this is awaiting eptstat */
#define DUP_ENTRY '#' /* there's a duplicate of this */
#define CONFIRM_CONT '*' /* need to confirm contents */
#define CONFIRM_ATTR '~' /* need to confirm attributes */
#define ENTRY_OK '\0' /* entry is a confirmed file */
enum zn_ipd_fs {ZONE_IPD, ZONE_FS};
struct zone_pkginfo {
boolean_t zpi_all_zones;
boolean_t zpi_this_zone;
int zpi_patch_cnt;
char *zpi_version;
char *zpi_patchlist;
char **zpi_patchinfo;
};
typedef struct {
uu_avl_node_t patch_node;
char *patch_num;
char *patch_vers;
uu_list_t *obs_patches;
} patch_node_t;
typedef struct {
uu_list_node_t link;
char *patch_num;
} obs_patch_node_t;
typedef struct {
uu_avl_t *obs_patches_avl;
zone_dochandle_t handle;
int res;
} patch_parms_t;
typedef struct {
uu_avl_node_t link;
char *patch_num;
boolean_t can_backout;
boolean_t installed;
} bo_patch_node_t;
static char *locale;
static char *zonename;
static char *zonepath;
/* List of pkgs that should be only on GZ */
static char **gz_only_pkgs_list = NULL;
/* used in attach_func() and signal handler */
static volatile boolean_t attach_interupted;
void
zperror(const char *str, boolean_t zonecfg_error)
{
(void) fprintf(stderr, "%s: %s\n", str,
zonecfg_error ? zonecfg_strerror(errno) : strerror(errno));
}
static int sw_cmp(zone_dochandle_t, zone_dochandle_t, uint_t);
/* PRINTFLIKE1 */
void
zerror(const char *fmt, ...)
{
va_list alist;
va_start(alist, fmt);
(void) fprintf(stderr, "zone '%s': ", zonename);
(void) vfprintf(stderr, fmt, alist);
(void) fprintf(stderr, "\n");
va_end(alist);
}
static int
do_subproc(char *cmdbuf)
{
void (*saveint)(int);
void (*saveterm)(int);
void (*savequit)(int);
void (*savehup)(int);
int pid, child, status;
/*
* do_subproc() links stdin to /dev/null, which would break any
* interactive subprocess we try to launch here.
*/
if ((child = vfork()) == 0) {
(void) execl("/bin/sh", "sh", "-c", cmdbuf, (char *)NULL);
}
if (child == -1)
return (-1);
saveint = sigset(SIGINT, SIG_IGN);
saveterm = sigset(SIGTERM, SIG_IGN);
savequit = sigset(SIGQUIT, SIG_IGN);
savehup = sigset(SIGHUP, SIG_IGN);
while ((pid = waitpid(child, &status, 0)) != child && pid != -1)
;
(void) sigset(SIGINT, saveint);
(void) sigset(SIGTERM, saveterm);
(void) sigset(SIGQUIT, savequit);
(void) sigset(SIGHUP, savehup);
return (pid == -1 ? -1 : status);
}
static int
subproc_status(const char *cmd, int status, boolean_t verbose_failure)
{
if (WIFEXITED(status)) {
int exit_code = WEXITSTATUS(status);
if ((verbose_failure) && (exit_code != ZONE_SUBPROC_OK))
zerror(gettext("'%s' failed with exit code %d."), cmd,
exit_code);
return (exit_code);
} else if (WIFSIGNALED(status)) {
int signal = WTERMSIG(status);
char sigstr[SIG2STR_MAX];
if (sig2str(signal, sigstr) == 0) {
zerror(gettext("'%s' terminated by signal SIG%s."), cmd,
sigstr);
} else {
zerror(gettext("'%s' terminated by an unknown signal."),
cmd);
}
} else {
zerror(gettext("'%s' failed for unknown reasons."), cmd);
}
/*
* Assume a subprocess that died due to a signal or an unknown error
* should be considered an exit code of ZONE_SUBPROC_FATAL, as the
* user will likely need to do some manual cleanup.
*/
return (ZONE_SUBPROC_FATAL);
}
/*
* Maintain a space separated list of unique pkg names. PATH_MAX is used in
* the pkg code as the maximum size for a pkg name.
*/
static int
add_pkg_to_str(char **str, char *pkg)
{
int len, newlen;
char tstr[PATH_MAX + 3];
char *tmp;
len = strlen(pkg);
if (*str == NULL) {
/* space for str + 2 spaces + NULL */
if ((*str = (char *)malloc(len + 3)) == NULL)
return (Z_NOMEM);
(void) snprintf(*str, len + 3, " %s ", pkg);
return (Z_OK);
}
(void) snprintf(tstr, sizeof (tstr), " %s ", pkg);
if (strstr(*str, tstr) != NULL)
return (Z_OK);
/* space for str + 1 space + NULL */
newlen = strlen(*str) + len + 2;
if ((tmp = (char *)realloc(*str, newlen)) == NULL)
return (Z_NOMEM);
*str = tmp;
(void) strlcat(*str, pkg, newlen);
(void) strlcat(*str, " ", newlen);
return (Z_OK);
}
/*
* Process a list of pkgs from an entry in the contents file, adding each pkg
* name to the list of pkgs.
*
* It is possible for the pkg name to be preceeded by a special character
* which indicates some bookkeeping information for pkging. Check if the
* first char is not an Alpha char. If so, skip over it.
*/
static int
add_pkg_list(char *lastp, char ***plist, int *pcnt, char **pkg_warn)
{
char *p;
int pkg_cnt = *pcnt;
char **pkgs = *plist;
int res = Z_OK;
while ((p = strtok_r(NULL, " ", &lastp)) != NULL) {
char **tmpp;
int i;
/* skip over any special pkg bookkeeping char */
if (!isalpha(*p)) {
if ((*p == NOT_FND || *p == DUP_ENTRY) &&
(res = add_pkg_to_str(pkg_warn, p + 1)) != Z_OK)
break;
p++;
}
/* Check if the pkg is already in the list */
for (i = 0; i < pkg_cnt; i++) {
if (strcmp(p, pkgs[i]) == 0)
break;
}
if (i < pkg_cnt)
continue;
/* The pkg is not in the list; add it. */
if ((tmpp = (char **)realloc(pkgs,
sizeof (char *) * (pkg_cnt + 1))) == NULL) {
res = Z_NOMEM;
break;
}
pkgs = tmpp;
if ((pkgs[pkg_cnt] = strdup(p)) == NULL) {
res = Z_NOMEM;
break;
}
pkg_cnt++;
}
*plist = pkgs;
*pcnt = pkg_cnt;
return (res);
}
/*
* Process an entry from the contents file (type "directory"). If the
* directory path is in the list of ipds and is not under a lofs mount within
* the ipd then add the associated list of pkgs to the pkg list. The input
* parameter "entry" will be broken up by the parser within this function so
* its value will be modified when this function exits.
*
* The entries we are looking for will look something like:
* /usr d none 0755 root sys SUNWctpls SUNWidnl SUNWlibCf ....
*/
static int
get_path_pkgs(char *entry, char **ipds, char **fss, char ***pkgs, int *pkg_cnt,
char **pkg_warn)
{
char *f1;
char *f2;
char *lastp;
int i;
char *nlp;
if ((f1 = strtok_r(entry, " ", &lastp)) == NULL ||
(f2 = strtok_r(NULL, " ", &lastp)) == NULL || strcmp(f2, "d") != 0)
return (Z_OK);
/* Check if this directory entry is in the list of ipds. */
for (i = 0; ipds[i] != NULL; i++) {
char wildcard[MAXPATHLEN];
/*
* We want to match on the path and any other directory
* entries under this path. When we use FNM_PATHNAME then
* that means '/' will not be matched by a wildcard (*) so
* we omit FNM_PATHNAME on the call with the wildcard matching.
*/
(void) snprintf(wildcard, sizeof (wildcard), "%s/*", ipds[i]);
if (fnmatch(ipds[i], f1, FNM_PATHNAME) == 0 ||
fnmatch(wildcard, f1, 0) == 0) {
/* It looks like we do want the pkgs for this path. */
break;
}
}
/* This entry did not match any of the ipds. */
if (ipds[i] == NULL)
return (Z_OK);
/*
* Check if there is a fs mounted under the ipd. If so, ignore this
* entry.
*/
for (i = 0; fss[i] != NULL; i++) {
char wildcard[MAXPATHLEN];
(void) snprintf(wildcard, sizeof (wildcard), "%s/*", fss[i]);
if (fnmatch(fss[i], f1, FNM_PATHNAME) == 0 ||
fnmatch(wildcard, f1, 0) == 0) {
/* We should ignore this path. */
break;
}
}
/* If not null, then we matched an fs mount point so ignore entry. */
if (fss[i] != NULL)
return (Z_OK);
/*
* We do want the pkgs for this entry. First, skip over the next 4
* fields in the entry so that we call add_pkg_list starting with the
* pkg names.
*/
for (i = 0; i < 4 && strtok_r(NULL, " ", &lastp) != NULL; i++)
;
/* If there are < 4 fields this entry is corrupt, just skip it. */
if (i < 4)
return (Z_OK);
/* strip newline from the line */
nlp = (lastp + strlen(lastp) - 1);
if (*nlp == '\n')
*nlp = '\0';
return (add_pkg_list(lastp, pkgs, pkg_cnt, pkg_warn));
}
/*
* Read an entry from a pkginfo or contents file. Some of these lines can
* either be arbitrarily long or be continued by a backslash at the end of
* the line. This function coalesces lines that are longer than the read
* buffer, and lines that are continued, into one buffer which is returned.
* The caller must free this memory. NULL is returned when we hit EOF or
* if we run out of memory (errno is set to ENOMEM).
*/
static char *
read_pkg_data(FILE *fp)
{
char *start;
char *inp;
char *p;
int char_cnt = 0;
errno = 0;
if ((start = (char *)malloc(PKGINFO_RD_LEN)) == NULL) {
errno = ENOMEM;
return (NULL);
}
inp = start;
while ((p = fgets(inp, PKGINFO_RD_LEN, fp)) != NULL) {
int len;
len = strlen(inp);
if (inp[len - 1] == '\n' &&
(len == 1 || inp[len - 2] != '\\')) {
char_cnt = len;
break;
}
if (inp[len - 2] == '\\')
char_cnt += len - 2;
else
char_cnt += PKGINFO_RD_LEN - 1;
if ((p = realloc(start, char_cnt + PKGINFO_RD_LEN)) == NULL) {
errno = ENOMEM;
break;
}
start = p;
inp = start + char_cnt;
}
if (errno == ENOMEM || (p == NULL && char_cnt == 0)) {
free(start);
start = NULL;
}
return (start);
}
static void
free_ipd_pkgs(char **pkgs, int cnt)
{
int i;
for (i = 0; i < cnt; i++)
free(pkgs[i]);
free(pkgs);
}
/*
* Get a list of the inherited pkg dirs or fs entries configured for the
* zone. The type parameter will be either ZONE_IPD or ZONE_FS.
*/
static int
get_ipd_fs_list(zone_dochandle_t handle, enum zn_ipd_fs type, char ***list)
{
int res;
struct zone_fstab fstab;
int cnt = 0;
char **entries = NULL;
int i;
int (*fp)(zone_dochandle_t, struct zone_fstab *);
if (type == ZONE_IPD) {
fp = zonecfg_getipdent;
res = zonecfg_setipdent(handle);
} else {
fp = zonecfg_getfsent;
res = zonecfg_setfsent(handle);
}
if (res != Z_OK)
return (res);
while (fp(handle, &fstab) == Z_OK) {
char **p;
if ((p = (char **)realloc(entries,
sizeof (char *) * (cnt + 1))) == NULL) {
res = Z_NOMEM;
break;
}
entries = p;
if ((entries[cnt] = strdup(fstab.zone_fs_dir)) == NULL) {
res = Z_NOMEM;
break;
}
cnt++;
}
if (type == ZONE_IPD)
(void) zonecfg_endipdent(handle);
else
(void) zonecfg_endfsent(handle);
/* Add a NULL terminating element. */
if (res == Z_OK) {
char **p;
if ((p = (char **)realloc(entries,
sizeof (char *) * (cnt + 1))) == NULL) {
res = Z_NOMEM;
} else {
entries = p;
entries[cnt] = NULL;
}
}
if (res != Z_OK) {
if (entries != NULL) {
for (i = 0; i < cnt; i++)
free(entries[i]);
free(entries);
}
return (res);
}
*list = entries;
return (Z_OK);
}
/*
* Get the list of inherited-pkg-dirs (ipd) for the zone and then get the
* list of pkgs that deliver into those dirs.
*/
static int
get_ipd_pkgs(zone_dochandle_t handle, char ***pkg_list, int *cnt)
{
int res;
char **ipds;
char **fss;
int pkg_cnt = 0;
char **pkgs = NULL;
int i;
if ((res = get_ipd_fs_list(handle, ZONE_IPD, &ipds)) != Z_OK)
return (res);
if ((res = get_ipd_fs_list(handle, ZONE_FS, &fss)) != Z_OK) {
for (i = 0; ipds[i] != NULL; i++)
free(ipds[i]);
free(ipds);
return (res);
}
/* We only have to process the contents file if we have ipds. */
if (ipds != NULL) {
FILE *fp;
if ((fp = fopen(CONTENTS_FILE, "r")) != NULL) {
char *buf;
char *pkg_warn = NULL;
while ((buf = read_pkg_data(fp)) != NULL) {
res = get_path_pkgs(buf, ipds, fss, &pkgs,
&pkg_cnt, &pkg_warn);
free(buf);
if (res != Z_OK)
break;
}
(void) fclose(fp);
if (pkg_warn != NULL) {
(void) fprintf(stderr, dgettext(TEXT_DOMAIN,
"WARNING: package metadata problems "
"with the following packages:\n %s\n"),
pkg_warn);
free(pkg_warn);
}
}
}
for (i = 0; ipds[i] != NULL; i++)
free(ipds[i]);
free(ipds);
for (i = 0; fss[i] != NULL; i++)
free(fss[i]);
free(fss);
if (res != Z_OK) {
free_ipd_pkgs(pkgs, pkg_cnt);
} else {
*pkg_list = pkgs;
*cnt = pkg_cnt;
}
return (res);
}
/*
* Return true if pkg_name is in the list of pkgs that deliver into an
* inherited pkg directory for the zone.
*/
static boolean_t
dir_pkg(char *pkg_name, char **pkg_list, int cnt)
{
int i;
for (i = 0; i < cnt; i++) {
if (strcmp(pkg_name, pkg_list[i]) == 0)
return (B_TRUE);
}
return (B_FALSE);
}
/*
* Keep track of obsoleted patches for this specific patch. We don't need to
* keep track of the patch version since once a patch is obsoleted, all prior
* versions are also obsolete and there won't be any new versions.
*/
static int
add_obs_patch(patch_node_t *patch, char *num, uu_list_pool_t *patches_pool)
{
obs_patch_node_t *obs;
if (patch->obs_patches == NULL) {
if ((patch->obs_patches = uu_list_create(patches_pool, NULL,
0)) == NULL)
return (Z_NOMEM);
}
if ((obs = (obs_patch_node_t *)malloc(sizeof (obs_patch_node_t)))
== NULL)
return (Z_NOMEM);
if ((obs->patch_num = strdup(num)) == NULL) {
free(obs);
return (Z_NOMEM);
}
uu_list_node_init(obs, &obs->link, patches_pool);
(void) uu_list_insert_before(patch->obs_patches, NULL, obs);
return (Z_OK);
}
/*
* Keep track of obsoleted patches. We don't need to keep track of the patch
* version since once a patch is obsoleted, all prior versions are also
* obsolete and there won't be any new versions.
*/
static int
save_obs_patch(char *num, uu_avl_pool_t *patches_pool, uu_avl_t *obs_patches)
{
patch_node_t *patch;
uu_avl_index_t where;
if ((patch = (patch_node_t *)malloc(sizeof (patch_node_t))) == NULL)
return (Z_NOMEM);
if ((patch->patch_num = strdup(num)) == NULL) {
free(patch);
return (Z_NOMEM);
}
patch->patch_vers = NULL;
patch->obs_patches = NULL;
uu_avl_node_init(patch, &patch->patch_node, patches_pool);
if (uu_avl_find(obs_patches, patch, NULL, &where) != NULL) {
free(patch->patch_num);
free(patch);
return (Z_OK);
}
uu_avl_insert(obs_patches, patch, where);
return (Z_OK);
}
/*
* Keep a list of patches for a pkg. If we see a newer version of a patch,
* we only keep track of the newer version.
*/
static boolean_t
save_patch(patch_node_t *patch, uu_avl_t *patches_avl)
{
patch_node_t *existing;
uu_avl_index_t where;
/*
* Check if this is a newer version of a patch we already have.
* If it is an older version of a patch we already have, ignore it.
*/
if ((existing = (patch_node_t *)uu_avl_find(patches_avl, patch, NULL,
&where)) != NULL) {
char *endptr;
ulong_t pvers, evers;
pvers = strtoul(patch->patch_vers, &endptr, 10);
evers = strtoul(existing->patch_vers, &endptr, 10);
if (pvers <= evers)
return (B_FALSE);
/*
* Remove the lower version patch from the tree so we can
* insert the new higher version one. We also discard the
* obsolete patch list from the old version since the new
* version will have its own, likely different, list.
*/
uu_avl_remove(patches_avl, existing);
free(existing->patch_num);
free(existing->patch_vers);
if (existing->obs_patches != NULL) {
obs_patch_node_t *op;
void *cookie2 = NULL;
while ((op = uu_list_teardown(existing->obs_patches,
&cookie2)) != NULL) {
free(op->patch_num);
free(op);
}
uu_list_destroy(existing->obs_patches);
}
free(existing);
/*
* Now that the old one is gone, find the new location
* in the tree.
*/
(void) uu_avl_find(patches_avl, patch, NULL, &where);
}
uu_avl_insert(patches_avl, patch, where);
return (B_TRUE);
}
/*
* Check if a patch is on the list of obsoleted patches. We don't need to
* check the patch version since once a patch is obsoleted, all prior versions
* are also obsolete and there won't be any new versions.
*/
static boolean_t
obsolete_patch(patch_node_t *patch, uu_avl_t *obs_patches)
{
uu_avl_index_t where;
if (uu_avl_find(obs_patches, patch, NULL, &where) != NULL)
return (B_TRUE);
return (B_FALSE);
}
/* ARGSUSED */
static int
patch_node_compare(const void *l_arg, const void *r_arg, void *private)
{
patch_node_t *l = (patch_node_t *)l_arg;
patch_node_t *r = (patch_node_t *)r_arg;
char *endptr;
ulong_t lnum, rnum;
lnum = strtoul(l->patch_num, &endptr, 10);
rnum = strtoul(r->patch_num, &endptr, 10);
if (lnum > rnum)
return (1);
if (lnum < rnum)
return (-1);
return (0);
}
/*
* Parse the patchinfo string for the patch.
*
* We are parsing entries of the form:
* PATCH_INFO_121454-02=Installed: Wed Dec 7 07:13:51 PST 2005 From: mum \
* Obsoletes: 120777-03 121087-02 119108-07 Requires: 119575-02 \
* 119255-06 Incompatibles:
*
* A backed out patch will have "backed out\n" as the status. We should
* skip these patches. We also ignore any entries that seem to be
* corrupted. Obsolete patches are saved in the obs_patches parameter
* AVL list.
*/
static int
parse_info(char *patchinfo, uu_avl_pool_t *patches_pool, uu_avl_t *patches_avl,
uu_avl_t *obs_patches, uu_list_pool_t *list_pool)
{
char *p;
char *lastp;
char *ep;
char *pvers;
boolean_t add_info = B_FALSE;
patch_node_t *patch;
if (strlen(patchinfo) < (sizeof (PATCHINFO) - 1))
return (Z_OK);
/* Skip over "PATCH_INFO_" to get the patch id. */
p = patchinfo + sizeof (PATCHINFO) - 1;
if ((ep = strchr(p, '=')) == NULL)
return (Z_OK);
*ep++ = '\0';
/* Ignore all but installed patches. */
if (strncmp(ep, "Installed:", 10) != 0)
return (Z_OK);
/* remove newline */
lastp = (ep + strlen(ep) - 1);
if (*lastp == '\n')
*lastp = '\0';
if ((patch = (patch_node_t *)malloc(sizeof (patch_node_t))) == NULL)
return (Z_NOMEM);
if ((pvers = strchr(p, '-')) != NULL)
*pvers++ = '\0';
else
pvers = "";
if ((patch->patch_num = strdup(p)) == NULL) {
free(patch);
return (Z_NOMEM);
}
if ((patch->patch_vers = strdup(pvers)) == NULL) {
free(patch->patch_num);
free(patch);
return (Z_NOMEM);
}
patch->obs_patches = NULL;
uu_avl_node_init(patch, &patch->patch_node, patches_pool);
if (!save_patch(patch, patches_avl)) {
free(patch->patch_num);
free(patch->patch_vers);
assert(patch->obs_patches == NULL);
free(patch);
return (Z_OK);
}
/*
* Start with the first token. This will probably be "Installed:".
* If we can't tokenize this entry, just return.
*/
if ((p = strtok_r(ep, " ", &lastp)) == NULL)
return (Z_OK);
do {
if (strcmp(p, "Installed:") == 0 ||
strcmp(p, "Requires:") == 0 ||
strcmp(p, "From:") == 0 ||
strcmp(p, "Incompatibles:") == 0) {
add_info = B_FALSE;
continue;
} else if (strcmp(p, "Obsoletes:") == 0) {
add_info = B_TRUE;
continue;
}
if (!add_info)
continue;
if ((pvers = strchr(p, '-')) != NULL)
*pvers = '\0';
/*
* We save all of the obsolete patches in one big list in the
* obs_patches AVL tree so that we know not to output those as
* part of the sw dependencies. However, we also need to save
* the obsolete patch information for this sepcific patch so
* so that we can do the cross manifest patch checking
* correctly.
*/
if (save_obs_patch(p, patches_pool, obs_patches) != Z_OK)
return (Z_NOMEM);
if (add_obs_patch(patch, p, list_pool) != Z_OK)
return (Z_NOMEM);
} while ((p = strtok_r(NULL, " ", &lastp)) != NULL);
return (Z_OK);
}
/*
* AVL walker callback used to add patch to XML manifest.
*
* PATH_MAX is used in the pkg/patch code as the maximum size for the patch
* number/version string.
*/
static int
avl_add_patch(void *e, void *p)
{
xmlNodePtr node;
char id[PATH_MAX];
patch_node_t *patch;
patch_parms_t *args;
patch = e;
args = p;
/* skip this patch if it has been obsoleted */
if (obsolete_patch(patch, args->obs_patches_avl))
return (UU_WALK_NEXT);
if (patch->patch_vers[0] == '\0')
(void) snprintf(id, sizeof (id), "%s", patch->patch_num);
else
(void) snprintf(id, sizeof (id), "%s-%s", patch->patch_num,
patch->patch_vers);
if ((args->res = zonecfg_add_patch(args->handle, id, (void **)&node))
!= Z_OK)
return (UU_WALK_DONE);
if (patch->obs_patches != NULL) {
obs_patch_node_t *op;
for (op = uu_list_first(patch->obs_patches); op != NULL;
op = uu_list_next(patch->obs_patches, op)) {
(void) snprintf(id, sizeof (id), "%s", op->patch_num);
if ((args->res = zonecfg_add_patch_obs(id, node))
!= Z_OK)
return (UU_WALK_DONE);
}
}
return (UU_WALK_NEXT);
}
static void
patch_avl_delete(uu_avl_t *patches_avl)
{
if (patches_avl != NULL) {
patch_node_t *p;
void *cookie = NULL;
while ((p = (patch_node_t *)uu_avl_teardown(patches_avl,
&cookie)) != NULL) {
free(p->patch_num);
free(p->patch_vers);
if (p->obs_patches != NULL) {
obs_patch_node_t *op;
void *cookie2 = NULL;
while ((op = uu_list_teardown(p->obs_patches,
&cookie2)) != NULL) {
free(op->patch_num);
free(op);
}
uu_list_destroy(p->obs_patches);
}
free(p);
}
uu_avl_destroy(patches_avl);
}
}
/*
* Add the unique, highest version patches that are associated with this pkg
* to the sw inventory on the handle.
*/
static int
add_patches(zone_dochandle_t handle, struct zone_pkginfo *infop,
uu_avl_pool_t *patches_pool, uu_avl_t *obs_patches,
uu_list_pool_t *list_pool)
{
int i;
int res;
uu_avl_t *patches_avl;
patch_parms_t args;
if ((patches_avl = uu_avl_create(patches_pool, NULL, UU_DEFAULT))
== NULL)
return (Z_NOMEM);
for (i = 0; i < infop->zpi_patch_cnt; i++) {
if ((res = parse_info(infop->zpi_patchinfo[i], patches_pool,
patches_avl, obs_patches, list_pool)) != Z_OK) {
patch_avl_delete(patches_avl);
return (res);
}
}
args.obs_patches_avl = obs_patches;
args.handle = handle;
args.res = Z_OK;
(void) uu_avl_walk(patches_avl, avl_add_patch, &args, 0);
patch_avl_delete(patches_avl);
return (args.res);
}
/*
* Keep track of the pkgs we have already processed so that we can quickly
* skip those pkgs while recursively doing dependents.
*/
static boolean_t
pkg_in_manifest(uu_avl_t *saw_pkgs, char *pname, uu_avl_pool_t *pkgs_pool)
{
uu_avl_index_t where;
if (uu_avl_find(saw_pkgs, pname, NULL, &where) == NULL) {
zone_pkg_entry_t *pkg;
/*
* We need to add it. If we don't have memory we just skip
* this pkg since this routine improves performance but the
* algorithm is still correct without it.
*/
if ((pkg = (zone_pkg_entry_t *)
malloc(sizeof (zone_pkg_entry_t))) == NULL)
return (B_FALSE);
if ((pkg->zpe_name = strdup(pname)) == NULL) {
free(pkg);
return (B_FALSE);
}
pkg->zpe_vers = NULL;
pkg->zpe_patches_avl = NULL;
/* Insert pkg into the AVL tree. */
uu_avl_node_init(pkg, &pkg->zpe_entry, pkgs_pool);
uu_avl_insert(saw_pkgs, pkg, where);
return (B_FALSE);
}
return (B_TRUE);
}
static void
free_pkginfo(struct zone_pkginfo *infop)
{
free(infop->zpi_version);
free(infop->zpi_patchlist);
if (infop->zpi_patch_cnt > 0) {
int i;
for (i = 0; i < infop->zpi_patch_cnt; i++)
free(infop->zpi_patchinfo[i]);
free(infop->zpi_patchinfo);
}
}
/*
* Read the pkginfo file and populate the structure with the data we need
* from this pkg for a sw inventory.
*/
static int
get_pkginfo(char *pkginfo, struct zone_pkginfo *infop)
{
FILE *fp;
char *buf;
int err = 0;
infop->zpi_all_zones = B_FALSE;
infop->zpi_this_zone = B_FALSE;
infop->zpi_version = NULL;
infop->zpi_patchlist = NULL;
infop->zpi_patch_cnt = 0;
infop->zpi_patchinfo = NULL;
if ((fp = fopen(pkginfo, "r")) == NULL)
return (errno);
while ((buf = read_pkg_data(fp)) != NULL) {
if (strncmp(buf, VERSION, sizeof (VERSION) - 1) == 0) {
int len;
if ((infop->zpi_version =
strdup(buf + sizeof (VERSION) - 1)) == NULL) {
err = ENOMEM;
break;
}
/* remove trailing newline */
len = strlen(infop->zpi_version);
infop->zpi_version[len - 1] = '\0';
} else if (strcmp(buf, SUNW_PKG_ALL_ZONES) == 0) {
infop->zpi_all_zones = B_TRUE;
} else if (strcmp(buf, SUNW_PKG_THIS_ZONE) == 0) {
infop->zpi_this_zone = B_TRUE;
} else if (strncmp(buf, PATCHLIST, sizeof (PATCHLIST) - 1)
== 0) {
int len;
if ((infop->zpi_patchlist =
strdup(buf + sizeof (PATCHLIST) - 1)) == NULL) {
err = ENOMEM;
break;
}
/* remove trailing newline */
len = strlen(infop->zpi_patchlist);
infop->zpi_patchlist[len - 1] = '\0';
} else if (strncmp(buf, PATCHINFO, sizeof (PATCHINFO) - 1)
== 0) {
char **p;
if ((p = (char **)realloc(infop->zpi_patchinfo,
sizeof (char *) * (infop->zpi_patch_cnt + 1)))
== NULL) {
err = ENOMEM;
break;
}
infop->zpi_patchinfo = p;
if ((infop->zpi_patchinfo[infop->zpi_patch_cnt] =
strdup(buf)) == NULL) {
err = ENOMEM;
break;
}
infop->zpi_patch_cnt++;
}
free(buf);
}
free(buf);
if (errno == ENOMEM) {
err = ENOMEM;
/* Clean up anything we did manage to allocate. */
free_pkginfo(infop);
}
(void) fclose(fp);
return (err);
}
/*
* Add any dependent pkgs to the list. The pkg depend file lists pkg
* dependencies, one per line with an entry that looks like:
* P SUNWcar Core Architecture, (Root)
* See the depend(4) man page.
*/
static int
add_dependents(zone_dochandle_t handle, char *pname,
uu_avl_pool_t *patches_pool, uu_avl_t *obs_patches,
uu_list_pool_t *list_pool, uu_avl_t *saw_pkgs, uu_avl_pool_t *pkgs_pool)
{
int res = Z_OK;
FILE *fp;
char depend[MAXPATHLEN];
char *buf;
struct stat sbuf;
(void) snprintf(depend, sizeof (depend), "%s/%s/install/depend",
PKG_PATH, pname);
if (stat(depend, &sbuf) == -1 || !S_ISREG(sbuf.st_mode))
return (Z_OK);
if ((fp = fopen(depend, "r")) == NULL)
return (Z_OK);
while ((buf = read_pkg_data(fp)) != NULL) {
char *deppkg;
char *delims = " \t";
char pkginfo[MAXPATHLEN];
struct zone_pkginfo info;
if (*buf != 'P') {
free(buf);
continue;
}
/* Skip past the leading 'P '. */
if ((deppkg = strtok(buf + 2, delims)) == NULL) {
free(buf);
continue;
}
/* If the pkg is already in the manifest don't add it again. */
if (pkg_in_manifest(saw_pkgs, deppkg, pkgs_pool)) {
free(buf);
continue;
}
(void) snprintf(pkginfo, sizeof (pkginfo), "%s/%s/pkginfo",
PKG_PATH, deppkg);
if (stat(pkginfo, &sbuf) == -1 || !S_ISREG(sbuf.st_mode)) {
free(buf);
continue;
}
if (get_pkginfo(pkginfo, &info) != 0) {
res = Z_NOMEM;
free(buf);
break;
}
if ((res = add_dependents(handle, deppkg, patches_pool,
obs_patches, list_pool, saw_pkgs, pkgs_pool)) == Z_OK &&
(res = zonecfg_add_pkg(handle, deppkg, info.zpi_version))
== Z_OK) {
if (info.zpi_patch_cnt > 0)
res = add_patches(handle, &info, patches_pool,
obs_patches, list_pool);
}
free(buf);
free_pkginfo(&info);
if (res != Z_OK)
break;
}
(void) fclose(fp);
return (res);
}
/* ARGSUSED */
static int
pkg_entry_nm_compare(const void *l_arg, const void *r_arg, void *private)
{
zone_pkg_entry_t *pkg = (zone_pkg_entry_t *)l_arg;
char *name = (char *)r_arg;
return (strcmp(pkg->zpe_name, name));
}
/* ARGSUSED */
static int
pkg_entry_compare(const void *l_arg, const void *r_arg, void *private)
{
zone_pkg_entry_t *l = (zone_pkg_entry_t *)l_arg;
zone_pkg_entry_t *r = (zone_pkg_entry_t *)r_arg;
return (strcmp(l->zpe_name, r->zpe_name));
}
static void
pkg_avl_delete(uu_avl_t *pavl)
{
if (pavl != NULL) {
zone_pkg_entry_t *p;
void *cookie = NULL;
while ((p = uu_avl_teardown(pavl, &cookie)) != NULL) {
free(p->zpe_name);
free(p);
}
uu_avl_destroy(pavl);
}
}
/* Memory allocation failure, free up allocated memory */
static void
destroy_gz_only_list()
{
int i;
if (gz_only_pkgs_list != NULL) {
for (i = 0; gz_only_pkgs_list[i] != NULL; i++)
free(gz_only_pkgs_list[i]);
free(gz_only_pkgs_list);
gz_only_pkgs_list = NULL;
}
}
/*
* If a package is GZ only, it should not be installed in NGZ. This routine
* builds the list of GZ only packages
*/
static int
load_gz_only_pkg_list()
{
FILE *fp = NULL;
char buf[80];
int cnt = 0;
/* If file exists, do the open */
if ((fp = fopen("/var/sadm/install/gz-only-packages", "r")) == NULL)
return (ENOENT);
if ((gz_only_pkgs_list =
(char **)malloc(sizeof (char *))) == NULL) {
(void) fclose(fp);
return (Z_NOMEM);
}
while (fgets(buf, 80, fp) != NULL) {
char **p = NULL;
/* Take care to skip comments lines */
if (buf[0] == '#' || buf[0] == '\n')
continue;
buf[strlen(buf) - 1] = '\0';
/*
* Allocate memory for each entry in gz_only_pkgs_list.
* If unable to get memory, return Z_NOMEM to indicate
* allocation failure
*/
if ((gz_only_pkgs_list[cnt] = strdup(buf)) == NULL) {
destroy_gz_only_list();
(void) fclose(fp);
return (Z_NOMEM);
}
cnt++;
/* Allocate memory for the next pkg to be excluded */
if ((p = (char **)realloc(gz_only_pkgs_list,
((cnt + 1) * sizeof (char *)))) == NULL) {
free(gz_only_pkgs_list[cnt-1]);
gz_only_pkgs_list[cnt-1] = NULL;
destroy_gz_only_list();
(void) fclose(fp);
return (Z_NOMEM);
}
gz_only_pkgs_list = p;
}
gz_only_pkgs_list[cnt] = NULL;
(void) fclose(fp);
return (Z_OK);
}
/*
* Check if the package we are trying to install into a NGZ is a GZ only pkg.
* If so, skip it's installation in the NGZ
*/
static boolean_t
is_gz_only_pkg(char *pkg)
{
int i;
for (i = 0; gz_only_pkgs_list[i] != NULL; i++) {
if (strcmp(pkg, gz_only_pkgs_list[i]) == 0)
return (B_TRUE);
}
return (B_FALSE);
}
/*
* Take a software inventory of the global zone. We need to get the set of
* packages and patches that are on the global zone that the specified
* non-global zone depends on. The packages we need in the inventory are:
*
* - skip the package if SUNW_PKG_THISZONE is 'true'
* otherwise,
* - add the package if
* a) SUNW_PKG_ALLZONES is 'true',
* or
* b) any file delivered by the package is in a file system that is inherited
* from the global zone.
* If the zone does not inherit any file systems (whole root)
* then (b) will be skipped.
*
* For each of the packages that is being added to the inventory, we will also
* add its dependent packages to the inventory.
*
* For each of the packages that is being added to the inventory, we will also
* add all of the associated, unique patches to the inventory.
*
* See the comment for zonecfg_getpkgdata() for compatability restrictions on
* how we must save the XML representation of the software inventory.
*/
static int
sw_inventory(zone_dochandle_t handle)
{
char pkginfo[MAXPATHLEN];
int res;
int gz_pkgs_loaded;
struct dirent *dp;
DIR *dirp;
struct stat buf;
struct zone_pkginfo info;
int pkg_cnt = 0;
char **pkgs = NULL;
uu_avl_pool_t *pkgs_pool = NULL;
uu_avl_pool_t *patches_pool = NULL;
uu_list_pool_t *list_pool = NULL;
uu_avl_t *saw_pkgs = NULL;
uu_avl_t *obs_patches = NULL;
/*
* Get the list of GZ only packages from file gz-only-packages
* into memory
*/
if ((gz_pkgs_loaded = load_gz_only_pkg_list())
== Z_NOMEM) {
res = Z_NOMEM;
goto done;
}
if ((pkgs_pool = uu_avl_pool_create("pkgs_pool",
sizeof (zone_pkg_entry_t), offsetof(zone_pkg_entry_t, zpe_entry),
pkg_entry_nm_compare, UU_DEFAULT)) == NULL) {
res = Z_NOMEM;
goto done;
}
if ((saw_pkgs = uu_avl_create(pkgs_pool, NULL, UU_DEFAULT)) == NULL) {
res = Z_NOMEM;
goto done;
}
if ((patches_pool = uu_avl_pool_create("patches_pool",
sizeof (patch_node_t), offsetof(patch_node_t, patch_node),
patch_node_compare, UU_DEFAULT)) == NULL) {
res = Z_NOMEM;
goto done;
}
if ((list_pool = uu_list_pool_create("list_pool",
sizeof (obs_patch_node_t), offsetof(obs_patch_node_t, link), NULL,
UU_DEFAULT)) == NULL) {
res = Z_NOMEM;
goto done;
}
/*
* The obs_patches AVL tree saves all of the obsolete patches so
* that we know not to output those as part of the sw dependencies.
*/
if ((obs_patches = uu_avl_create(patches_pool, NULL, UU_DEFAULT))
== NULL) {
res = Z_NOMEM;
goto done;
}
if ((res = get_ipd_pkgs(handle, &pkgs, &pkg_cnt)) != Z_OK) {
res = Z_NOMEM;
goto done;
}
if ((dirp = opendir(PKG_PATH)) == NULL) {
res = Z_NOMEM;
goto done;
}
while ((dp = readdir(dirp)) != (struct dirent *)0) {
if (strcmp(dp->d_name, ".") == 0 ||
strcmp(dp->d_name, "..") == 0)
continue;
/*
* If only gz-only-packages file exists and read
* into memory, check for a possible match
* If there is a match, skip over. Such a package is
* meant for GZ only installation.
*/
if ((gz_pkgs_loaded == Z_OK) &&
(is_gz_only_pkg(dp->d_name) == B_TRUE))
continue;
(void) snprintf(pkginfo, sizeof (pkginfo), "%s/%s/pkginfo",
PKG_PATH, dp->d_name);
if (stat(pkginfo, &buf) == -1 || !S_ISREG(buf.st_mode))
continue;
if (get_pkginfo(pkginfo, &info) != 0) {
res = Z_NOMEM;
break;
}
if (!info.zpi_this_zone &&
(info.zpi_all_zones ||
dir_pkg(dp->d_name, pkgs, pkg_cnt)) &&
!pkg_in_manifest(saw_pkgs, dp->d_name, pkgs_pool)) {
/*
* Add dependents first so any patches will get
* associated with the right pkg in the xml file.
*/
if ((res = add_dependents(handle, dp->d_name,
patches_pool, obs_patches, list_pool, saw_pkgs,
pkgs_pool)) == Z_OK &&
(res = zonecfg_add_pkg(handle, dp->d_name,
info.zpi_version)) == Z_OK) {
if (info.zpi_patch_cnt > 0)
res = add_patches(handle, &info,
patches_pool, obs_patches,
list_pool);
}
}
free_pkginfo(&info);
if (res != Z_OK)
break;
}
(void) closedir(dirp);
done:
/*
* Free up the heap memory that has been allocated for
* gz-only-packages
*/
destroy_gz_only_list();
pkg_avl_delete(saw_pkgs);
patch_avl_delete(obs_patches);
if (pkgs_pool != NULL)
uu_avl_pool_destroy(pkgs_pool);
if (patches_pool != NULL)
uu_avl_pool_destroy(patches_pool);
if (list_pool != NULL)
uu_list_pool_destroy(list_pool);
free_ipd_pkgs(pkgs, pkg_cnt);
if (res == Z_OK)
zonecfg_set_swinv(handle);
return (res);
}
/*
* Get the information required to support detaching a zone. This is
* called on the source system when detaching (the detaching parameter should
* be set to true) and on the destination system before attaching (the
* detaching parameter should be false).
*
* For native Solaris zones, the detach/attach process involves validating
* that the software on the global zone can support the zone when we attach.
* To do this we take a software inventory of the global zone. We also
* have to keep track of the device configuration so that we can properly
* recreate it on the destination.
*/
static int
get_detach_info(zone_dochandle_t handle, boolean_t detaching)
{
int res;
if ((res = sw_inventory(handle)) != Z_OK)
return (res);
if (detaching)
res = zonecfg_dev_manifest(handle);
return (res);
}
/* ARGSUSED */
static int
zfm_print(const struct mnttab *p, void *r) {
(void) fprintf(stderr, " %s\n", p->mnt_mountp);
return (0);
}
static void
detach_usage()
{
(void) fprintf(stderr, gettext("usage:\t%s brand options: none\n"),
MY_BRAND_NAME);
}
static int
detach_func(int argc, char *argv[])
{
int err, arg;
zone_dochandle_t handle;
boolean_t execute = B_TRUE;
opterr = 0;
optind = 0;
if ((arg = getopt(argc, argv, "?n")) != EOF) {
switch (arg) {
case '?':
if (optopt != '?') {
(void) fprintf(stderr, gettext("%s brand: "
"invalid option: %c\n"), MY_BRAND_NAME,
optopt);
}
detach_usage();
return (optopt == '?' ? Z_OK : ZONE_SUBPROC_USAGE);
case 'n':
execute = B_FALSE;
break;
default:
(void) fprintf(stderr, gettext("%s brand: invalid "
"option: %c\n"), MY_BRAND_NAME, arg);
return (ZONE_SUBPROC_USAGE);
}
}
if (argc > optind) {
detach_usage();
return (ZONE_SUBPROC_USAGE);
}
/* Don't detach the zone if anything is still mounted there */
if (execute && zonecfg_find_mounts(zonepath, NULL, NULL)) {
(void) fprintf(stderr, gettext("These file systems are "
"mounted on subdirectories of %s.\n"), zonepath);
(void) zonecfg_find_mounts(zonepath, zfm_print, NULL);
return (ZONE_SUBPROC_NOTCOMPLETE);
}
if ((handle = zonecfg_init_handle()) == NULL) {
(void) fprintf(stderr, gettext("brand detach program error: "
"%s\n"), strerror(errno));
return (ZONE_SUBPROC_NOTCOMPLETE);
}
if ((err = zonecfg_get_handle(zonename, handle)) != Z_OK) {
(void) fprintf(stderr, gettext("brand detach program error: "
"%s\n"), zonecfg_strerror(err));
zonecfg_fini_handle(handle);
return (ZONE_SUBPROC_NOTCOMPLETE);
}
if ((err = get_detach_info(handle, B_TRUE)) != Z_OK) {
(void) fprintf(stderr, gettext("brand detach program error: "
"%s\n"), zonecfg_strerror(err));
goto done;
}
if ((err = zonecfg_detach_save(handle, (execute ? 0 : ZONE_DRY_RUN)))
!= Z_OK) {
(void) fprintf(stderr, gettext("saving the detach manifest "
"failed: %s\n"), zonecfg_strerror(err));
goto done;
}
done:
zonecfg_fini_handle(handle);
return ((err == Z_OK) ? ZONE_SUBPROC_OK : ZONE_SUBPROC_FATAL);
}
/*
* Validate attaching a zone but don't actually do the work. The zone
* does not have to exist, so there is some complexity getting a new zone
* configuration set up so that we can perform the validation. This is
* handled within zonecfg_attach_manifest() which returns two handles; one
* for the the full configuration to validate (rem_handle) and the other
* (local_handle) containing only the zone configuration derived from the
* manifest.
*/
static int
dryrun_attach(char *manifest_path)
{
int fd;
int err;
int res;
char atbrand[MAXNAMELEN];
zone_dochandle_t local_handle;
zone_dochandle_t rem_handle = NULL;
if ((fd = open(manifest_path, O_RDONLY)) < 0) {
(void) fprintf(stderr, gettext("could not open manifest path: "
"%s\n"), strerror(errno));
return (ZONE_SUBPROC_NOTCOMPLETE);
}
if ((local_handle = zonecfg_init_handle()) == NULL) {
(void) fprintf(stderr, gettext("brand attach program error: "
"%s\n"), strerror(errno));
res = ZONE_SUBPROC_NOTCOMPLETE;
goto done;
}
if ((rem_handle = zonecfg_init_handle()) == NULL) {
(void) fprintf(stderr, gettext("brand attach program error: "
"%s\n"), strerror(errno));
res = ZONE_SUBPROC_NOTCOMPLETE;
goto done;
}
if ((err = zonecfg_attach_manifest(fd, local_handle, rem_handle))
!= Z_OK) {
res = ZONE_SUBPROC_NOTCOMPLETE;
if (err == Z_INVALID_DOCUMENT) {
char buf[6];
bzero(buf, sizeof (buf));
(void) lseek(fd, 0L, SEEK_SET);
if (read(fd, buf, sizeof (buf) - 1) < 0 ||
strncmp(buf, "<?xml", 5) != 0)
(void) fprintf(stderr, gettext("%s is not an "
"XML file\n"), manifest_path);
else
(void) fprintf(stderr, gettext("Cannot attach "
"to an earlier release of the operating "
"system\n"));
} else {
(void) fprintf(stderr, gettext("brand attach program "
"error: %s\n"), zonecfg_strerror(err));
}
goto done;
}
/*
* Retrieve remote handle brand type and determine whether it is
* native or not.
*/
if (zonecfg_get_brand(rem_handle, atbrand, sizeof (atbrand)) != Z_OK) {
(void) fprintf(stderr, gettext("missing or invalid brand\n"));
exit(ZONE_SUBPROC_FATAL);
}
if (strcmp(atbrand, MY_BRAND_NAME) != 0) {
err = Z_ERR;
(void) fprintf(stderr, gettext("Trying to attach a '%s' zone "
"to a '%s' configuration.\n"), atbrand, MY_BRAND_NAME);
exit(ZONE_SUBPROC_FATAL);
}
/* Get the detach information for the locally defined zone. */
res = Z_OK;
if ((err = get_detach_info(local_handle, B_FALSE)) != Z_OK) {
(void) fprintf(stderr, gettext("getting the attach information "
"failed: %s\n"), zonecfg_strerror(err));
res = ZONE_SUBPROC_FATAL;
} else {
/* sw_cmp prints error msgs as necessary */
if (sw_cmp(local_handle, rem_handle, SW_CMP_NONE) != Z_OK)
res = ZONE_SUBPROC_FATAL;
}
done:
(void) close(fd);
zonecfg_fini_handle(local_handle);
zonecfg_fini_handle(rem_handle);
return ((res == Z_OK) ? Z_OK : ZONE_SUBPROC_FATAL);
}
static int
mount_func(boolean_t force)
{
zone_cmd_arg_t zarg;
zarg.cmd = force ? Z_FORCEMOUNT : Z_MOUNT;
zarg.bootbuf[0] = '\0';
if (zonecfg_call_zoneadmd(zonename, &zarg, locale, B_FALSE) != 0) {
zerror(gettext("call to %s failed"), "zoneadmd");
return (Z_ERR);
}
return (Z_OK);
}
static int
unmount_func()
{
zone_cmd_arg_t zarg;
zarg.cmd = Z_UNMOUNT;
if (zonecfg_call_zoneadmd(zonename, &zarg, locale, B_FALSE) != 0) {
zerror(gettext("call to %s failed"), "zoneadmd");
return (Z_ERR);
}
return (Z_OK);
}
/*
* Setup a configured zone so we can mount it and zlogin to perform various
* tasks. Also put a copy of the zone configuration into the zone so we can
* get a handle on it.
*
* The sequence of actions we are doing is this:
* [set zone state to installed]
* [mount zone]
* zlogin {zone} </etc/zones/{zone}.xml 'cat >/etc/zones/{zone}.xml'
*
* The unmount_configured_zone() function should be used to clean up from
* this function.
*/
static boolean_t
mount_configured_zone(boolean_t *mounted)
{
int status;
char cmdbuf[2 * MAXPATHLEN];
/*
* The zone has to be installed to mount and zlogin. Temporarily set
* the state to 'installed'.
*/
if (zone_set_state(zonename, ZONE_STATE_INSTALLED) != Z_OK)
return (B_FALSE);
/* Mount the zone so we can zlogin. */
if (mount_func(B_FALSE) != Z_OK)
return (B_FALSE);
*mounted = B_TRUE;
/*
* We need to copy the zones xml configuration file into the
* zone so we can get a handle for the zone while running inside
* the zone.
*/
if (snprintf(cmdbuf, sizeof (cmdbuf), "/usr/sbin/zlogin -S %s "
"</etc/zones/%s.xml '/usr/bin/cat >/etc/zones/%s.xml'",
zonename, zonename, zonename) >= sizeof (cmdbuf))
return (B_FALSE);
status = do_subproc(cmdbuf);
if (subproc_status("copy", status, B_TRUE) != ZONE_SUBPROC_OK)
return (B_FALSE);
return (B_TRUE);
}
/*
* Cleanup a configured zone mounted using mount_configured_zone().
* tasks.
*
* The sequence of actions we are doing is this:
* zlogin {zone} 'rm -f /etc/zones/{zone}.xml'
* [unmount zone]
* [set zone state to configured]
*/
static boolean_t
unmount_configured_zone(boolean_t mounted)
{
boolean_t res = B_TRUE;
/* Cleanup from the previous actions. */
if (mounted) {
int status;
char cmdbuf[2 * MAXPATHLEN];
if (snprintf(cmdbuf, sizeof (cmdbuf),
"/usr/sbin/zlogin -S %s '/usr/bin/rm -f /etc/zones/%s.xml'",
zonename, zonename) >= sizeof (cmdbuf)) {
res = B_FALSE;
} else {
status = do_subproc(cmdbuf);
if (subproc_status("rm", status, B_TRUE)
!= ZONE_SUBPROC_OK)
res = B_FALSE;
}
if (unmount_func() != Z_OK)
res = B_FALSE;
}
if (zone_set_state(zonename, ZONE_STATE_CONFIGURED) != Z_OK)
res = B_FALSE;
return (res);
}
/*
* Attempt to generate the information we need to make the zone look like
* it was properly detached by using the pkg information contained within
* the zone itself.
* We will perform a dry-run detach within the zone to generate the xml file.
* The successful result of this function is that we will have the "manifest"
* xml file in the zonepath and we can use that to attach the zone.
*/
static boolean_t
gen_detach_info(char *manifest)
{
int status;
boolean_t mounted = B_FALSE;
boolean_t res = B_FALSE;
char cmdbuf[2 * MAXPATHLEN];
if (!mount_configured_zone(&mounted))
goto cleanup;
/* Now run the detach command within the mounted zone. */
if (snprintf(cmdbuf, sizeof (cmdbuf), "/usr/sbin/zlogin -S %s "
"'/usr/sbin/zoneadm -z %s detach -n' >%s/%s",
zonename, zonename, zonepath, manifest) >= sizeof (cmdbuf))
goto cleanup;
status = do_subproc(cmdbuf);
if (subproc_status("detach", status, B_TRUE) != ZONE_SUBPROC_OK)
goto cleanup;
res = B_TRUE;
cleanup:
if (!unmount_configured_zone(mounted))
res = B_FALSE;
return (res);
}
/*
* The zone needs to be updated so set it up for the update and initiate the
* update within the scratch zone. First set the state to incomplete so we can
* force-mount the zone for the update operation. We pass the -U option to the
* mount so that the scratch zone is mounted without the zone's /etc and /var
* being lofs mounted back into the scratch zone root. This is done by
* overloading the bootbuf string in the zone_cmd_arg_t to pass -U as an option
* to the mount cmd.
*/
static int
attach_update(zone_dochandle_t handle)
{
int err;
int update_res;
int status;
zone_cmd_arg_t zarg;
FILE *fp;
struct zone_fstab fstab;
char cmdbuf[(4 * MAXPATHLEN) + 20];
if ((err = zone_set_state(zonename, ZONE_STATE_INCOMPLETE))
!= Z_OK) {
(void) fprintf(stderr, gettext("could not set state: %s\n"),
zonecfg_strerror(err));
return (Z_FATAL);
}
zarg.cmd = Z_FORCEMOUNT;
(void) strlcpy(zarg.bootbuf, "-U", sizeof (zarg.bootbuf));
if (zonecfg_call_zoneadmd(zonename, &zarg, locale, B_FALSE) != 0) {
(void) fprintf(stderr, gettext("could not mount zone\n"));
/* We reset the state since the zone wasn't modified yet. */
if ((err = zone_set_state(zonename, ZONE_STATE_CONFIGURED))
!= Z_OK) {
(void) fprintf(stderr, gettext("could not reset state: "
"%s\n"), zonecfg_strerror(err));
}
return (Z_FATAL);
}
/*
* Move data files generated by sw_up_to_date() into the scratch
* zone's /tmp.
*/
(void) snprintf(cmdbuf, sizeof (cmdbuf), "exec /usr/bin/mv "
"%s/pkg_add %s/pkg_rm %s/lu/tmp",
zonepath, zonepath, zonepath);
status = do_subproc(cmdbuf);
if (subproc_status("mv", status, B_TRUE) != ZONE_SUBPROC_OK) {
(void) fprintf(stderr, gettext("could not mv data files: %s\n"),
strerror(errno));
goto fail;
}
/*
* Save list of inherit-pkg-dirs into zone. Since the file is in
* /tmp we don't have to worry about deleting it.
*/
(void) snprintf(cmdbuf, sizeof (cmdbuf), "%s/lu/tmp/inherited",
zonepath);
if ((fp = fopen(cmdbuf, "w")) == NULL) {
(void) fprintf(stderr, gettext("could not save "
"inherit-pkg-dirs: %s\n"), strerror(errno));
goto fail;
}
if (zonecfg_setipdent(handle) != Z_OK) {
(void) fprintf(stderr, gettext("could not enumerate "
"inherit-pkg-dirs: %s\n"), zonecfg_strerror(err));
goto fail;
}
while (zonecfg_getipdent(handle, &fstab) == Z_OK) {
if (fprintf(fp, "%s\n", fstab.zone_fs_dir) < 0) {
(void) fprintf(stderr, gettext("could not save "
"inherit-pkg-dirs: %s\n"), strerror(errno));
(void) fclose(fp);
goto fail;
}
}
(void) zonecfg_endipdent(handle);
if (fclose(fp) != 0) {
(void) fprintf(stderr, gettext("could not save "
"inherit-pkg-dirs: %s\n"), strerror(errno));
goto fail;
}
/* run the updater inside the scratch zone */
(void) snprintf(cmdbuf, sizeof (cmdbuf),
"exec /usr/sbin/zlogin -S %s "
"/usr/lib/brand/native/attach_update %s", zonename, zonename);
update_res = Z_OK;
status = do_subproc(cmdbuf);
if (subproc_status("attach_update", status, B_TRUE)
!= ZONE_SUBPROC_OK) {
(void) fprintf(stderr, gettext("could not update zone\n"));
update_res = Z_ERR;
}
if (update_res == Z_OK) {
/* Install the new /etc/release file. */
(void) snprintf(cmdbuf, sizeof (cmdbuf),
"exec /usr/sbin/zlogin -S %s "
"'/usr/bin/cat >/a/etc/release' </etc/release", zonename);
status = do_subproc(cmdbuf);
if (subproc_status("/etc/release", status, B_TRUE)
!= ZONE_SUBPROC_OK) {
(void) fprintf(stderr, gettext("could not update "
"zone\n"));
update_res = Z_ERR;
}
}
zarg.cmd = Z_UNMOUNT;
if (zonecfg_call_zoneadmd(zonename, &zarg, locale, B_FALSE) != 0) {
(void) fprintf(stderr, gettext("could not unmount zone\n"));
return (Z_ERR);
}
/*
* If the update script within the scratch zone failed for some reason
* we will now leave the zone in the incomplete state since we no
* longer know the state of the files within the zonepath.
*/
if (update_res == Z_ERR)
return (Z_ERR);
zonecfg_rm_detached(handle, B_FALSE);
return (Z_OK);
fail:
zarg.cmd = Z_UNMOUNT;
if (zonecfg_call_zoneadmd(zonename, &zarg, locale, B_FALSE) != 0)
(void) fprintf(stderr, gettext("could not unmount zone\n"));
/* We reset the state since the zone wasn't modified yet. */
if ((err = zone_set_state(zonename, ZONE_STATE_CONFIGURED))
!= Z_OK) {
errno = err;
(void) fprintf(stderr, gettext("could not reset state: %s\n"),
zonecfg_strerror(err));
}
return (Z_ERR);
}
/* ARGSUSED */
static void
sigcleanup(int sig)
{
attach_interupted = B_TRUE;
}
static boolean_t
valid_num(char *n)
{
for (; isdigit(*n); n++)
;
if (*n != NULL)
return (B_FALSE);
return (B_TRUE);
}
/*
* Take an input field, which must look like a positive int, and return the
* numeric value of the field. Return -1 if the input field does not look
* like something we can convert.
*/
static int
fld2num(char *fld, char **nfld)
{
char *ppoint;
long n;
if ((ppoint = strchr(fld, '.')) != NULL) {
*ppoint = '\0';
*nfld = ppoint + 1;
} else {
*nfld = NULL;
}
if (!valid_num(fld))
return (-1);
errno = 0;
n = strtol(fld, (char **)NULL, 10);
if (errno != 0)
return (-1);
return ((int)n);
}
/*
* Step through two version strings that look like postive ints delimited by
* decimals and compare them. Example input can look like 2, 010.3, 75.02.09,
* etc. If the input does not look like this then we do a simple lexical
* comparison of the two strings. The string can be modified on exit of
* this function.
*/
static int
fld_cmp(char *v1, char *v2)
{
char *nxtfld1, *nxtfld2;
int n1, n2;
for (;;) {
n1 = fld2num(v1, &nxtfld1);
n2 = fld2num(v2, &nxtfld2);
/*
* If either field is not a postive int, just compare them
* lexically.
*/
if (n1 < 0 || n2 < 0)
return (strcmp(v1, v2));
if (n1 > n2)
return (1);
if (n1 < n2)
return (-1);
/* They're equal */
/* No more fields */
if (nxtfld1 == NULL && nxtfld2 == NULL)
return (0);
/* Field 2 still has data so it is greater than field 1 */
if (nxtfld1 == NULL)
return (-1);
/* Field 1 still has data so it is greater than field 2 */
if (nxtfld2 == NULL)
return (1);
/* Both fields still have data, keep going. */
v1 = nxtfld1;
v2 = nxtfld2;
}
}
/*
* The result of the comparison is returned in the cmp parameter:
* 0 if both versions are equal.
* <0 if version1 is less than version 2.
* >0 if version1 is greater than version 2.
* The function returns B_TRUE if there was an ENOMEM error, B_FALSE otherwise.
*
* This function handles the various version strings we can get from the
* dependent pkg versions. They usually look like:
* "1.21,REV=2005.01.17.23.31"
* "2.6.0,REV=10.0.3.2004.12.16.18.02"
*
* We can't do a simple lexical comparison since:
* 2.6.0 would be greater than 2.20.0
* 12 would be greater than 110
*
* If the input strings do not look like decimal delimted version strings
* then we fall back to doing a simple lexical comparison.
*/
static boolean_t
pkg_vers_cmp(char *vers1, char *vers2, int *cmp)
{
char *v1, *v2;
char *rev1, *rev2;
int res;
/* We need to modify the input strings so we dup them. */
if ((v1 = strdup(vers1)) == NULL)
return (B_TRUE);
if ((v2 = strdup(vers2)) == NULL) {
free(v1);
return (B_TRUE);
}
/* Strip off a revision delimited by a comma. */
if ((rev1 = strchr(v1, ',')) != NULL)
*rev1++ = '\0';
if ((rev2 = strchr(v2, ',')) != NULL)
*rev2++ = '\0';
res = fld_cmp(v1, v2);
/* If the primary versions are not equal, return the result */
if (res != 0) {
*cmp = res;
goto done;
}
/*
* All of the fields in the primary version strings are equal, check
* the rev, if it exists.
*/
/* No revs */
if (rev1 == NULL && rev2 == NULL) {
*cmp = 0;
goto done;
}
/* Field 2 has a rev so it is greater than field 1 */
if (rev1 == NULL) {
*cmp = -1;
goto done;
}
/* Field 1 has a rev so it is greater than field 2 */
if (rev2 == NULL) {
*cmp = 1;
goto done;
}
/* If no recognized REV data then just lexically compare them */
if (strncmp(rev1, "REV=", 4) != 0 || strncmp(rev2, "REV=", 4) != 0) {
*cmp = strcmp(rev1, rev2);
goto done;
}
/* Both fields have revs, check them. */
*cmp = fld_cmp(rev1 + 4, rev2 + 4);
done:
free(v1);
free(v2);
return (B_FALSE);
}
/*
* Walk all of the patches on the pkg, looking to see if the specified patch
* has been obsoleted by one of those patches.
*/
static boolean_t
is_obsolete(zone_pkg_entry_t *pkg, zone_pkg_entry_t *patchid)
{
uu_avl_walk_t *patch_walk;
zone_pkg_entry_t *patch;
boolean_t res;
if (pkg->zpe_patches_avl == NULL)
return (B_FALSE);
patch_walk = uu_avl_walk_start(pkg->zpe_patches_avl, UU_WALK_ROBUST);
if (patch_walk == NULL)
return (B_FALSE);
res = B_FALSE;
while ((patch = uu_avl_walk_next(patch_walk)) != NULL) {
uu_avl_index_t where;
if (patch->zpe_patches_avl == NULL)
continue;
/* Check the obsolete list on the patch. */
if (uu_avl_find(patch->zpe_patches_avl, patchid, NULL, &where)
!= NULL) {
res = B_TRUE;
break;
}
}
uu_avl_walk_end(patch_walk);
return (res);
}
/*
* Build a list of unique patches from the input pkg_patches list.
* If the pkg parameter is not null then we will check the patches on that
* pkg to see if any of the pkg_patches have been obsoleted. We don't
* add those obsoleted patches to the unique list.
* Returns B_FALSE if an error occurs.
*/
static boolean_t
add_patch(uu_avl_t *pkg_patches, uu_avl_t *unique, zone_pkg_entry_t *pkg,
uu_avl_pool_t *pkg_pool)
{
uu_avl_walk_t *walk;
zone_pkg_entry_t *pkg_patch;
if (pkg_patches == NULL)
return (B_TRUE);
walk = uu_avl_walk_start(pkg_patches, UU_WALK_ROBUST);
if (walk == NULL)
return (B_FALSE);
while ((pkg_patch = uu_avl_walk_next(walk)) != NULL) {
uu_avl_index_t where;
zone_pkg_entry_t *patch;
/* Skip adding it if we already have it. */
if (uu_avl_find(unique, pkg_patch, NULL, &where) != NULL)
continue;
/* Likewise, skip adding it if it has been obsoleted. */
if (pkg != NULL && is_obsolete(pkg, pkg_patch))
continue;
/* We need to add it so make a duplicate. */
if ((patch = (zone_pkg_entry_t *)
malloc(sizeof (zone_pkg_entry_t))) == NULL) {
uu_avl_walk_end(walk);
return (B_FALSE);
}
if ((patch->zpe_name = strdup(pkg_patch->zpe_name)) == NULL) {
free(patch);
uu_avl_walk_end(walk);
return (B_FALSE);
}
if ((patch->zpe_vers = strdup(pkg_patch->zpe_vers)) == NULL) {
free(patch->zpe_name);
free(patch);
uu_avl_walk_end(walk);
return (B_FALSE);
}
patch->zpe_patches_avl = NULL;
/* Insert patch into the unique patch AVL tree. */
uu_avl_node_init(patch, &patch->zpe_entry, pkg_pool);
uu_avl_insert(unique, patch, where);
}
uu_avl_walk_end(walk);
return (B_TRUE);
}
/*
* Common code for sw_cmp which will check flags, update res and print the
* section header. Return true if we should be silent.
*/
static boolean_t
prt_header(int *res, uint_t flag, boolean_t *do_header, char *hdr)
{
*res = Z_ERR;
if (flag & SW_CMP_SILENT)
return (B_TRUE);
if (*do_header) {
/* LINTED E_SEC_PRINTF_VAR_FMT */
(void) fprintf(stderr, hdr);
*do_header = B_FALSE;
}
return (B_FALSE);
}
/*
* Compare the software on the local global zone and source system global
* zone. Used when we are trying to attach a zone during migration or
* when checking if a ZFS snapshot is still usable for a ZFS clone.
* l_handle is for the local system and s_handle is for the source system.
* These have a snapshot of the appropriate packages and patches in the global
* zone for the two machines.
* The functions called here can print any messages that are needed to
* inform the user about package or patch problems.
* The flag parameter controls how the messages are printed. If the
* SW_CMP_SILENT bit is set in the flag then no messages will be printed
* but we still compare the sw and return an error if there is a mismatch.
*/
static int
sw_cmp(zone_dochandle_t l_handle, zone_dochandle_t s_handle, uint_t flag)
{
char *hdr;
int res;
int err;
boolean_t do_header;
uu_avl_pool_t *pkg_pool = NULL;
uu_avl_t *src_pkgs = NULL;
uu_avl_t *dst_pkgs = NULL;
uu_avl_t *src_patches = NULL;
uu_avl_t *dst_patches = NULL;
zone_pkg_entry_t *src_pkg;
zone_pkg_entry_t *dst_pkg;
zone_pkg_entry_t *src_patch;
zone_pkg_entry_t *dst_patch;
uu_avl_walk_t *walk;
/* Set res to cover any of these memory allocation errors. */
res = Z_NOMEM;
if ((pkg_pool = uu_avl_pool_create("pkgs_pool",
sizeof (zone_pkg_entry_t), offsetof(zone_pkg_entry_t, zpe_entry),
pkg_entry_compare, UU_DEFAULT)) == NULL)
goto done;
if ((src_pkgs = uu_avl_create(pkg_pool, NULL, UU_DEFAULT)) == NULL)
goto done;
if ((dst_pkgs = uu_avl_create(pkg_pool, NULL, UU_DEFAULT)) == NULL)
goto done;
if ((src_patches = uu_avl_create(pkg_pool, NULL, UU_DEFAULT)) == NULL)
goto done;
if ((dst_patches = uu_avl_create(pkg_pool, NULL, UU_DEFAULT)) == NULL)
goto done;
res = Z_OK;
if ((err = zonecfg_getpkgdata(s_handle, pkg_pool, src_pkgs)) != Z_OK) {
res = errno = err;
zperror(gettext("could not get package data for detached zone"),
B_TRUE);
goto done;
}
if ((err = zonecfg_getpkgdata(l_handle, pkg_pool, dst_pkgs)) != Z_OK) {
res = errno = err;
zperror(gettext("could not get package data for global zone"),
B_TRUE);
goto done;
}
/*
* Check the source host for pkgs (and versions) that are not on the
* local host.
*/
hdr = gettext("These packages installed on the source system "
"are inconsistent with this system:\n");
do_header = B_TRUE;
if ((walk = uu_avl_walk_start(src_pkgs, UU_WALK_ROBUST)) == NULL) {
res = Z_NOMEM;
goto done;
}
while ((src_pkg = uu_avl_walk_next(walk)) != NULL) {
int cmp;
uu_avl_index_t where;
dst_pkg = uu_avl_find(dst_pkgs, src_pkg, NULL, &where);
/*
* Build up a list of unique patches for the src system but
* don't track patches that are obsoleted on the dst system
* since they don't matter.
*/
if (!add_patch(src_pkg->zpe_patches_avl, src_patches, dst_pkg,
pkg_pool)) {
res = Z_NOMEM;
goto done;
}
if (dst_pkg == NULL) {
/* src pkg is not installed on dst */
if (prt_header(&res, flag, &do_header, hdr))
break;
(void) fprintf(stderr,
gettext("\t%s: not installed\n\t\t(%s)\n"),
src_pkg->zpe_name, src_pkg->zpe_vers);
continue;
}
/* Check pkg version */
if (pkg_vers_cmp(src_pkg->zpe_vers, dst_pkg->zpe_vers, &cmp)) {
res = Z_NOMEM;
goto done;
}
if (cmp != 0) {
if (prt_header(&res, flag, &do_header, hdr))
break;
(void) fprintf(stderr, gettext(
"\t%s: version mismatch\n\t\t(%s)\n\t\t(%s)\n"),
src_pkg->zpe_name, src_pkg->zpe_vers,
dst_pkg->zpe_vers);
}
}
uu_avl_walk_end(walk);
/*
* Now check the local host for pkgs that were not on the source host.
* We already handled version mismatches in the loop above.
*/
hdr = gettext("These packages installed on this system were "
"not installed on the source system:\n");
do_header = B_TRUE;
if ((walk = uu_avl_walk_start(dst_pkgs, UU_WALK_ROBUST)) == NULL) {
res = Z_NOMEM;
goto done;
}
while ((dst_pkg = uu_avl_walk_next(walk)) != NULL) {
uu_avl_index_t where;
/*
* Build up a list of unique patches for the dst system. We
* don't worry about tracking obsolete patches that were on the
* src since we only want to report the results of moving to
* the dst system.
*/
if (!add_patch(dst_pkg->zpe_patches_avl, dst_patches, NULL,
pkg_pool)) {
res = Z_NOMEM;
goto done;
}
src_pkg = uu_avl_find(src_pkgs, dst_pkg, NULL, &where);
if (src_pkg == NULL) {
/* dst pkg is not installed on src */
if (prt_header(&res, flag, &do_header, hdr))
break;
(void) fprintf(stderr, gettext("\t%s (%s)\n"),
dst_pkg->zpe_name, dst_pkg->zpe_vers);
}
}
uu_avl_walk_end(walk);
/*
* Check the source host for patches that are not on the local host.
*/
hdr = gettext("These patches installed on the source system "
"are inconsistent with this system:\n");
do_header = B_TRUE;
if ((walk = uu_avl_walk_start(src_patches, UU_WALK_ROBUST)) == NULL) {
res = Z_NOMEM;
goto done;
}
while ((src_patch = uu_avl_walk_next(walk)) != NULL) {
uu_avl_index_t where;
dst_patch = uu_avl_find(dst_patches, src_patch, NULL, &where);
if (dst_patch == NULL) {
/* src patch is not installed on dst */
if (prt_header(&res, flag, &do_header, hdr))
break;
(void) fprintf(stderr,
gettext("\t%s-%s: not installed\n"),
src_patch->zpe_name, src_patch->zpe_vers);
continue;
}
/*
* Check patch version. We assume the patch versions are
* properly structured with a leading 0 if necessary (e.g. 01).
*/
assert(strlen(src_patch->zpe_vers) ==
strlen(dst_patch->zpe_vers));
if (strcmp(src_patch->zpe_vers, dst_patch->zpe_vers) != 0) {
if (prt_header(&res, flag, &do_header, hdr))
break;
(void) fprintf(stderr,
gettext("\t%s: version mismatch\n\t\t(%s) (%s)\n"),
src_patch->zpe_name, src_patch->zpe_vers,
dst_patch->zpe_vers);
}
}
uu_avl_walk_end(walk);
/*
* Check the local host for patches that were not on the source host.
* We already handled version mismatches in the loop above.
*/
hdr = gettext("These patches installed on this system were "
"not installed on the source system:\n");
do_header = B_TRUE;
if ((walk = uu_avl_walk_start(dst_patches, UU_WALK_ROBUST)) == NULL) {
res = Z_NOMEM;
goto done;
}
while ((dst_patch = uu_avl_walk_next(walk)) != NULL) {
uu_avl_index_t where;
src_patch = uu_avl_find(src_patches, dst_patch, NULL, &where);
if (src_patch == NULL) {
/* dst patch is not installed on src */
if (prt_header(&res, flag, &do_header, hdr))
break;
(void) fprintf(stderr, gettext("\t%s-%s\n"),
dst_patch->zpe_name, dst_patch->zpe_vers);
}
}
uu_avl_walk_end(walk);
done:
if (res == Z_NOMEM)
zerror(gettext("Out of memory"));
/* free avl structs */
pkg_avl_delete(src_pkgs);
pkg_avl_delete(dst_pkgs);
pkg_avl_delete(src_patches);
pkg_avl_delete(dst_patches);
if (pkg_pool != NULL)
uu_avl_pool_destroy(pkg_pool);
return (res);
}
/*
* Compare the software on the local global zone and source system global
* zone. Used to determine if/how we have to update the zone during attach.
* We generate the data files needed by the update process in this case.
* l_handle is for the local system and s_handle is for the source system.
* These have a snapshot of the appropriate packages and patches in the global
* zone for the two machines.
*
* The algorithm we use to compare the pkgs is as follows:
* 1) pkg on src but not on dst
* remove src pkg (allowed in order to handle obsolete pkgs - note that
* this only applies to dependent pkgs, not generic pkgs installed into
* the zone by the zone admin)
* 2) pkg on dst but not on src
* add pkg
* 3) pkg on src with higher rev than on dst
* fail (downgrade)
* 4) pkg on dst with higher rev than on src
* remove src pkg & add new
* 5) pkg version is the same
* a) patch on src but not on dst
* fail (downgrade, unless obsoleted)
* b) patch on dst but not on src
* remove src pkg & add new
* c) patch on src with higher rev than on dst
* fail (downgrade, unless obsoleted)
* d) patch on dst with higher rev than on src
* remove src pkg & add new
*
* We run this algorithm in 2 passes, first looking at the pkgs from the src
* system and then looking at the pkgs from the dst system.
*
* As with the sw_cmp function, we return Z_OK if there is no work to be
* done (the attach can just happen) or Z_ERR if we have to update the pkgs
* within the zone. We can also return Z_FATAL if we had a real error during
* this process.
*/
static int
sw_up_to_date(zone_dochandle_t l_handle, zone_dochandle_t s_handle)
{
int res = Z_OK;
int err;
int cmp;
FILE *fp_add = NULL, *fp_rm = NULL;
uu_avl_pool_t *pkg_pool = NULL;
uu_avl_t *src_pkgs = NULL;
uu_avl_t *dst_pkgs = NULL;
uu_avl_walk_t *walk;
zone_pkg_entry_t *src_pkg;
zone_pkg_entry_t *dst_pkg;
char fname[MAXPATHLEN];
boolean_t failed = B_FALSE;
(void) snprintf(fname, sizeof (fname), "%s/pkg_add", zonepath);
if ((fp_add = fopen(fname, "w")) == NULL) {
zperror(gettext("could not save list of packages to add"),
B_FALSE);
goto fatal;
}
(void) snprintf(fname, sizeof (fname), "%s/pkg_rm", zonepath);
if ((fp_rm = fopen(fname, "w")) == NULL) {
zperror(gettext("could not save list of packages to remove"),
B_FALSE);
goto fatal;
}
if ((pkg_pool = uu_avl_pool_create("pkgs_pool",
sizeof (zone_pkg_entry_t), offsetof(zone_pkg_entry_t, zpe_entry),
pkg_entry_compare, UU_DEFAULT)) == NULL)
goto fatal;
if ((src_pkgs = uu_avl_create(pkg_pool, NULL, UU_DEFAULT)) == NULL)
goto fatal;
if ((dst_pkgs = uu_avl_create(pkg_pool, NULL, UU_DEFAULT)) == NULL)
goto fatal;
if ((err = zonecfg_getpkgdata(s_handle, pkg_pool, src_pkgs)) != Z_OK) {
errno = err;
zperror(gettext("could not get package data for detached zone"),
B_TRUE);
goto fatal;
}
if ((err = zonecfg_getpkgdata(l_handle, pkg_pool, dst_pkgs)) != Z_OK) {
errno = err;
zperror(gettext("could not get package data for global zone"),
B_TRUE);
goto fatal;
}
/*
* First Pass
*
* Start by checking each pkg from the src system. We need to handle
* the following:
* 1) pkg on src but not on dst
* rm old pkg (allowed in order to handle obsolete pkgs)
* 3) pkg on src with higher rev than on dst
* fail (downgrade)
* 5) pkg ver same
* a) patch on src but not on dst
* fail (downgrade)
* c) patch on src with higher rev than on dst
* fail (downgrade)
*/
if ((walk = uu_avl_walk_start(src_pkgs, UU_WALK_ROBUST)) == NULL) {
zerror(gettext("Out of memory"));
goto fatal;
}
while ((src_pkg = uu_avl_walk_next(walk)) != NULL) {
uu_avl_index_t where;
uu_avl_walk_t *patch_walk;
zone_pkg_entry_t *src_patch;
dst_pkg = uu_avl_find(dst_pkgs, src_pkg, NULL, &where);
if (dst_pkg == NULL) {
/* src pkg is not installed on dst */
if (fprintf(fp_rm, "%s\n", src_pkg->zpe_name) < 0) {
zperror(gettext("could not save list of "
"packages to remove"), B_FALSE);
goto fatal;
}
res = Z_ERR;
continue;
}
/* Check pkg version to determine how to proceed. */
if (pkg_vers_cmp(src_pkg->zpe_vers, dst_pkg->zpe_vers, &cmp)) {
zerror(gettext("Out of memory"));
goto fatal;
}
if (cmp > 0) {
/* src pkg has higher vers than dst pkg */
zerror(gettext("ERROR: attempt to downgrade package "
"%s %s to version %s"), src_pkg->zpe_name,
src_pkg->zpe_vers, dst_pkg->zpe_vers);
failed = B_TRUE;
continue;
}
/*
* src pkg has lower vers than dst pkg, we'll handle
* this in the loop where we process the dst pkgs.
*/
if (cmp < 0)
continue;
/* src and dst pkgs have the same version. */
/*
* If src pkg has no patches, then we're done with this pkg.
* Any patches on the dst pkg are handled in the 2nd pass.
*/
if (src_pkg->zpe_patches_avl == NULL)
continue;
if (dst_pkg->zpe_patches_avl == NULL) {
/*
* We have the same pkg on the src and dst but the src
* pkg has patches and the dst pkg does not, so this
* would be a downgrade! Disallow this.
*/
zerror(gettext("ERROR: attempt to downgrade package "
"%s, the source had patches but this system does "
"not. Patches:"), src_pkg->zpe_name);
failed = B_TRUE;
patch_walk = uu_avl_walk_start(src_pkg->zpe_patches_avl,
UU_WALK_ROBUST);
if (patch_walk == NULL) {
zerror(gettext("Out of memory"));
goto fatal;
}
while ((src_patch = uu_avl_walk_next(patch_walk))
!= NULL) {
(void) fprintf(stderr, "\t%s-%s\n",
src_patch->zpe_name, src_patch->zpe_vers);
}
uu_avl_walk_end(patch_walk);
continue;
}
patch_walk = uu_avl_walk_start(src_pkg->zpe_patches_avl,
UU_WALK_ROBUST);
if (patch_walk == NULL) {
zerror(gettext("Out of memory"));
goto fatal;
}
while ((src_patch = uu_avl_walk_next(patch_walk)) != NULL) {
zone_pkg_entry_t *dst_patch;
dst_patch = uu_avl_find(dst_pkg->zpe_patches_avl,
src_patch, NULL, &where);
if (dst_patch == NULL) {
/*
* We have the same pkg on the src and dst but
* the src pkg has a patch that the dst pkg
* does not, so this would be a downgrade! We
* need to disallow this but first double check
* that this patch has not been obsoleted by
* some other patch that is installed on the
* dst. If the patch is obsolete, the pkg will
* be handled in the 2nd pass.
*/
if (is_obsolete(dst_pkg, src_patch))
continue;
zerror(gettext("ERROR: attempt to downgrade "
"package %s, the source had patch %s-%s "
"which is not installed on this system\n"),
src_pkg->zpe_name, src_patch->zpe_name,
src_patch->zpe_vers);
failed = B_TRUE;
continue;
}
/* Check if the src patch is newer than the dst patch */
if (strcmp(src_patch->zpe_vers, dst_patch->zpe_vers)
> 0) {
/*
* We have a patch on the src with higher rev
* than the patch on the dst so this would be a
* downgrade! We need to disallow this but
* first double check that this patch has not
* been obsoleted by some other patch that is
* installed on the dst. If the patch is
* obsolete, the pkg will be handled in the 2nd
* pass.
*/
if (is_obsolete(dst_pkg, src_patch))
continue;
zerror(gettext("ERROR: attempt to downgrade "
"package %s, the source had patch %s-%s "
"but this system only has %s-%s\n"),
src_pkg->zpe_name, src_patch->zpe_name,
src_patch->zpe_vers, dst_patch->zpe_name,
dst_patch->zpe_vers);
failed = B_TRUE;
continue;
}
/*
* If the src patch is the same rev or older than the
* dst patch we'll handle that in the second pass.
*/
}
uu_avl_walk_end(patch_walk);
}
uu_avl_walk_end(walk);
if (failed)
goto fatal;
/*
* Second Pass
*
* Now check each pkg from the dst system. We need to handle
* the following:
* 2) pkg on dst but not on src
* add pkg
* 4) pkg on dst with higher rev than on src
* remove old pkg & add current
* 5) pkg ver same
* b) patch on dst but not on src
* remove old pkg & add
* d) patch on dst with higher rev than on src
* remove old pkg & add
*/
if ((walk = uu_avl_walk_start(dst_pkgs, UU_WALK_ROBUST)) == NULL) {
zerror(gettext("Out of memory"));
goto fatal;
}
while ((dst_pkg = uu_avl_walk_next(walk)) != NULL) {
uu_avl_index_t where;
uu_avl_walk_t *patch_walk;
zone_pkg_entry_t *dst_patch;
src_pkg = uu_avl_find(src_pkgs, dst_pkg, NULL, &where);
if (src_pkg == NULL) {
/* dst pkg was not installed on src */
if (fprintf(fp_add, "%s\n", dst_pkg->zpe_name) < 0) {
zperror(gettext("could not save list of "
"packages to add"), B_FALSE);
goto fatal;
}
res = Z_ERR;
continue;
}
/* Check pkg version to determine how to proceed. */
if (pkg_vers_cmp(dst_pkg->zpe_vers, src_pkg->zpe_vers, &cmp)) {
zerror(gettext("Out of memory"));
goto fatal;
}
if (cmp > 0) {
/* dst pkg has higher vers than src pkg */
if (fprintf(fp_rm, "%s\n", dst_pkg->zpe_name) < 0) {
zperror(gettext("could not save list of "
"packages to remove"), B_FALSE);
goto fatal;
}
if (fprintf(fp_add, "%s\n", dst_pkg->zpe_name) < 0) {
zperror(gettext("could not save list of "
"packages to add"), B_FALSE);
goto fatal;
}
res = Z_ERR;
continue;
}
/*
* cmp < 0 was handled in the first loop. This would
* be a downgrade so we should have already failed.
*/
assert(cmp >= 0);
/* src and dst pkgs have the same version. */
/* If dst pkg has no patches, then we're done with this pkg. */
if (dst_pkg->zpe_patches_avl == NULL)
continue;
if (src_pkg->zpe_patches_avl == NULL) {
/*
* We have the same pkg on the src and dst
* but the dst pkg has patches and the src
* pkg does not. Just replace the pkg.
*
* We don't want to actually add the original pkg
* to the list of pkgs to remove here since the
* pkginstall command relies on the presence of the
* installed pkg with the same version number to set
* the UPDATE environment variable for the Class Action
* Scripts. Instead, we just re-install the pkg so the
* right thing happens.
*/
if (fprintf(fp_add, "%s\n", dst_pkg->zpe_name) < 0) {
zperror(gettext("could not save list of "
"packages to add"), B_FALSE);
goto fatal;
}
res = Z_ERR;
continue;
}
patch_walk = uu_avl_walk_start(dst_pkg->zpe_patches_avl,
UU_WALK_ROBUST);
if (patch_walk == NULL) {
zerror(gettext("Out of memory"));
goto fatal;
}
while ((dst_patch = uu_avl_walk_next(patch_walk)) != NULL) {
zone_pkg_entry_t *src_patch;
src_patch = uu_avl_find(src_pkg->zpe_patches_avl,
dst_patch, NULL, &where);
if (src_patch == NULL) {
/*
* We have the same pkg on the src and dst but
* the dst pkg has a patch that the src pkg
* does not. Just replace the pkg.
*
* See the comment above for why we don't want
* to actually remove the pkg.
*/
if (fprintf(fp_add, "%s\n", dst_pkg->zpe_name)
< 0) {
zperror(gettext("could not save list "
"of packages to add"), B_FALSE);
goto fatal;
}
res = Z_ERR;
continue;
}
/* Check if the dst patch is newer than the src patch */
if (strcmp(dst_patch->zpe_vers, src_patch->zpe_vers)
> 0) {
/*
* We have a patch on the dst with higher rev
* than the patch on the src. Just replace the
* pkg.
*
* See the comment above for why we don't want
* to actually remove the pkg.
*/
if (fprintf(fp_add, "%s\n", dst_pkg->zpe_name)
< 0) {
zperror(gettext("could not save list "
"of packages to add"), B_FALSE);
goto fatal;
}
res = Z_ERR;
continue;
}
/*
* If the dst patch is the same rev then we can ignore
* this pkg. If it is older than the src patch we
* handled that in the first pass and we should have
* already failed.
*/
assert(strcmp(dst_patch->zpe_vers, src_patch->zpe_vers)
>= 0);
}
uu_avl_walk_end(patch_walk);
}
uu_avl_walk_end(walk);
if (fclose(fp_add) != 0) {
zperror(gettext("could not save list of packages to add"),
B_FALSE);
goto fatal;
}
fp_add = NULL;
if (fclose(fp_rm) != 0) {
zperror(gettext("could not save list of packages to remove"),
B_FALSE);
goto fatal;
}
/* free avl structs */
pkg_avl_delete(src_pkgs);
pkg_avl_delete(dst_pkgs);
uu_avl_pool_destroy(pkg_pool);
return (res);
fatal:
/* free avl structs */
pkg_avl_delete(src_pkgs);
pkg_avl_delete(dst_pkgs);
if (pkg_pool != NULL)
uu_avl_pool_destroy(pkg_pool);
if (fp_add != NULL)
(void) fclose(fp_add);
if (fp_rm != NULL)
(void) fclose(fp_rm);
/* clean up data files left behind */
(void) snprintf(fname, sizeof (fname), "%s/pkg_add", zonepath);
(void) unlink(fname);
(void) snprintf(fname, sizeof (fname), "%s/pkg_rm", zonepath);
(void) unlink(fname);
return (Z_FATAL);
}
/*
* During attach we go through and fix up the /dev entries for the zone
* we are attaching. In order to regenerate /dev with the correct devices,
* the old /dev will be removed, the zone readied (which generates a new
* /dev) then halted, then we use the info from the manifest to update
* the modes, owners, etc. on the new /dev.
*/
static int
dev_fix(char *zonename, zone_dochandle_t handle)
{
int err;
int status;
struct zone_devpermtab devtab;
zone_cmd_arg_t zarg;
char devpath[MAXPATHLEN];
/* 6: "exec " and " " */
char cmdbuf[sizeof (RMCOMMAND) + MAXPATHLEN + 6];
if (snprintf(devpath, sizeof (devpath), "%s/dev", zonepath)
>= sizeof (devpath))
return (Z_TOO_BIG);
/*
* "exec" the command so that the returned status is that of
* RMCOMMAND and not the shell.
*/
(void) snprintf(cmdbuf, sizeof (cmdbuf), EXEC_PREFIX RMCOMMAND " %s",
devpath);
status = do_subproc(cmdbuf);
if ((err = subproc_status(RMCOMMAND, status, B_TRUE)) !=
ZONE_SUBPROC_OK) {
(void) fprintf(stderr,
gettext("could not remove existing /dev\n"));
return (Z_ERR);
}
/* In order to ready the zone, it must be in the installed state */
if ((err = zone_set_state(zonename, ZONE_STATE_INSTALLED)) != Z_OK) {
errno = err;
zperror(gettext("could not reset state"), B_TRUE);
return (Z_ERR);
}
/* We have to ready the zone to regen the dev tree */
zarg.cmd = Z_READY;
if (zonecfg_call_zoneadmd(zonename, &zarg, locale, B_FALSE) != 0) {
zerror(gettext("call to %s failed"), "zoneadmd");
/* attempt to restore zone to configured state */
(void) zone_set_state(zonename, ZONE_STATE_CONFIGURED);
return (Z_ERR);
}
zarg.cmd = Z_HALT;
if (zonecfg_call_zoneadmd(zonename, &zarg, locale, B_FALSE) != 0) {
zerror(gettext("call to %s failed"), "zoneadmd");
/* attempt to restore zone to configured state */
(void) zone_set_state(zonename, ZONE_STATE_CONFIGURED);
return (Z_ERR);
}
/* attempt to restore zone to configured state */
(void) zone_set_state(zonename, ZONE_STATE_CONFIGURED);
if (zonecfg_setdevperment(handle) != Z_OK) {
(void) fprintf(stderr,
gettext("unable to enumerate device entries\n"));
return (Z_ERR);
}
while (zonecfg_getdevperment(handle, &devtab) == Z_OK) {
int err;
if ((err = zonecfg_devperms_apply(handle,
devtab.zone_devperm_name, devtab.zone_devperm_uid,
devtab.zone_devperm_gid, devtab.zone_devperm_mode,
devtab.zone_devperm_acl)) != Z_OK && err != Z_INVAL)
(void) fprintf(stderr, gettext("error updating device "
"%s: %s\n"), devtab.zone_devperm_name,
zonecfg_strerror(err));
free(devtab.zone_devperm_acl);
}
(void) zonecfg_enddevperment(handle);
return (Z_OK);
}
/*
* Check the pkg to see if the patch backout data exists for the specified
* patch in the "bo" parameter. Mark the patch if we cannot back it out.
* Only return false if we hit a fatal error.
*/
static boolean_t
collect_patch_backout(char *pkg_path, bo_patch_node_t *bo)
{
struct stat buf;
char backout_path[MAXPATHLEN];
char backout_data[MAXPATHLEN];
if (snprintf(backout_path, sizeof (backout_path), "%s/save/%s",
pkg_path, bo->patch_num) >= sizeof (backout_path)) {
zerror(gettext("Package path is too long"));
return (B_FALSE);
}
if (snprintf(backout_data, sizeof (backout_data), "%s/undo.Z",
backout_path) >= sizeof (backout_data)) {
zerror(gettext("Package path is too long"));
return (B_FALSE);
}
if (stat(backout_data, &buf) == 0)
return (B_TRUE);
if (snprintf(backout_data, sizeof (backout_data), "%s/undo",
backout_path) >= sizeof (backout_data)) {
zerror(gettext("Package path is too long"));
return (B_FALSE);
}
if (stat(backout_data, &buf) == 0)
return (B_TRUE);
if (snprintf(backout_data, sizeof (backout_data), "%s/obsolete.Z",
backout_path) >= sizeof (backout_data)) {
zerror(gettext("Package path is too long"));
return (B_FALSE);
}
if (stat(backout_data, &buf) == 0)
return (B_TRUE);
if (snprintf(backout_data, sizeof (backout_data), "%s/obsolete",
backout_path) >= sizeof (backout_data)) {
zerror(gettext("Package path is too long"));
return (B_FALSE);
}
if (stat(backout_data, &buf) == 0)
return (B_TRUE);
/* There is no backout data for the patch. */
bo->can_backout = B_FALSE;
return (B_TRUE);
}
/*
* Parse pkg patch_list and check if any of the backout patches are in the pkg.
* For each backout, collect the data about backing it out. Only return false
* if we hit a fatal error.
*/
static boolean_t
collect_pkg_backout(char *pkg_path, char *patch_list, uu_avl_t *backout_list,
uu_avl_pool_t *backout_pool)
{
char *tmp;
char *patch;
char *lastp;
if (patch_list == NULL)
return (B_TRUE);
for (tmp = patch_list; (patch = strtok_r(tmp, " ", &lastp)) != NULL;
tmp = NULL) {
uu_list_index_t where;
bo_patch_node_t *found;
bo_patch_node_t backout;
backout.patch_num = patch;
uu_avl_node_init(&backout, &backout.link, backout_pool);
if ((found = uu_avl_find(backout_list, &backout, NULL, &where))
!= NULL) {
found->installed = B_TRUE;
if (!collect_patch_backout(pkg_path, found))
return (B_FALSE);
}
}
return (B_TRUE);
}
/*
* Walk all of the pkgs installed to determine if one of the patches to backout
* is installed on that pkg. To figure out what patches are installed we have
* to look at each pkg, since patch data is stored in individual pkginfo files.
*
* Once that is done, the patches to backout will each be flagged so we
* can verify that the backout list is valid.
*
* We're doing this from the global zone, but this is just a sanity check and
* nothing is being modified. The actual backout happens in the scratch zone.
*/
static boolean_t
backout_ok(uu_avl_t *backout_list, uu_avl_pool_t *backout_pool)
{
boolean_t res = B_TRUE;
struct dirent *dp;
DIR *dirp;
uu_avl_walk_t *walk;
bo_patch_node_t *backout;
boolean_t do_header = B_TRUE;
char pkg_dir[MAXPATHLEN];
if (backout_list == NULL)
return (B_TRUE);
if (snprintf(pkg_dir, sizeof (pkg_dir), "%s/root/%s", zonepath,
PKG_PATH) >= sizeof (pkg_dir))
return (B_FALSE);
if ((dirp = opendir(pkg_dir)) == NULL)
return (B_FALSE);
while ((dp = readdir(dirp)) != NULL) {
char pkgpath[MAXPATHLEN];
char pkginfo[MAXPATHLEN];
struct stat buf;
struct zone_pkginfo info;
if (strcmp(dp->d_name, ".") == 0 ||
strcmp(dp->d_name, "..") == 0)
continue;
if (snprintf(pkgpath, sizeof (pkgpath), "%s/%s", pkg_dir,
dp->d_name) >= sizeof (pkgpath))
continue;
if (snprintf(pkginfo, sizeof (pkginfo), "%s/pkginfo", pkgpath)
>= sizeof (pkginfo))
continue;
if (stat(pkginfo, &buf) == -1 || !S_ISREG(buf.st_mode))
continue;
if (get_pkginfo(pkginfo, &info) != 0) {
res = B_FALSE;
break;
}
res = collect_pkg_backout(pkgpath, info.zpi_patchlist,
backout_list, backout_pool);
free_pkginfo(&info);
if (!res)
break;
}
(void) closedir(dirp);
/* If we had a fatal error in the loop above, we're done. */
if (!res)
return (B_FALSE);
/*
* Walk the list of patches to see if any are not installed or cannot
* be backed out.
*/
if ((walk = uu_avl_walk_start(backout_list, UU_WALK_ROBUST)) == NULL) {
zerror(gettext("Out of memory"));
return (B_FALSE);
}
while ((backout = uu_avl_walk_next(walk)) != NULL) {
if (!backout->installed || !backout->can_backout) {
if (do_header) {
(void) fprintf(stderr, gettext("The following "
"patches cannot be removed:\n"));
do_header = B_FALSE;
}
if (!backout->installed)
(void) fprintf(stderr,
gettext("\t%s is not installed\n"),
backout->patch_num);
else
(void) fprintf(stderr, gettext("\t%s was "
"installed without creating its backout "
"data\n"), backout->patch_num);
res = B_FALSE;
}
}
uu_avl_walk_end(walk);
return (res);
}
/*
* Run patchrm in the scratch zone to backout the specified patches.
* Return B_TRUE if the backout suceeded, otherwise, return B_FALSE.
*/
static boolean_t
backout_patches(uu_avl_t *backout_list)
{
boolean_t res = B_FALSE;
uu_avl_walk_t *walk;
bo_patch_node_t *backout;
boolean_t mounted = B_FALSE;
int status;
int len;
char *patchrm = "/usr/sbin/zlogin -S %s "
"'/usr/bin/date >>/a/var/sadm/system/logs/backout_log; "
"/usr/sbin/patchrm -R /a ";
char *patchlog = " 2>&1 | "
"tee -a /a/var/sadm/system/logs/backout_log'\n";
char *cmdbuf = NULL;
char *tmp;
if (backout_list == NULL)
return (B_TRUE);
if (!mount_configured_zone(&mounted))
goto cleanup;
len = strlen(patchrm) + strlen(zonename) + strlen(patchlog) + 1;
if ((cmdbuf = (char *)malloc(len)) == NULL) {
zerror(gettext("Out of memory"));
goto cleanup;
}
/* Walk the list of patches to build the backout command. */
if ((walk = uu_avl_walk_start(backout_list, UU_WALK_ROBUST)) == NULL) {
zerror(gettext("Out of memory"));
goto cleanup;
}
(void) printf(gettext("Backing out patches: "));
/* LINTED E_SEC_PRINTF_VAR_FMT */
(void) snprintf(cmdbuf, len, patchrm, zonename);
while ((backout = uu_avl_walk_next(walk)) != NULL) {
(void) printf("%s ", backout->patch_num);
len += strlen(backout->patch_num) + 1;
if ((tmp = (char *)realloc(cmdbuf, len)) == NULL) {
uu_avl_walk_end(walk);
zerror(gettext("Out of memory"));
goto cleanup;
}
cmdbuf = tmp;
(void) strlcat(cmdbuf, backout->patch_num, len);
(void) strlcat(cmdbuf, " ", len);
}
(void) printf("\n");
uu_avl_walk_end(walk);
(void) strlcat(cmdbuf, patchlog, len);
/* Now run the patchrm command within the mounted zone. */
status = do_subproc(cmdbuf);
if (subproc_status("patchrm", status, B_TRUE) != ZONE_SUBPROC_OK) {
zerror(gettext("Backing out the patches failed.\n"
"See the /var/sadm/system/logs/backout_log file in the "
"zone for details.\n"));
goto cleanup;
}
res = B_TRUE;
cleanup:
if (cmdbuf != NULL)
free(cmdbuf);
if (!unmount_configured_zone(mounted))
res = B_FALSE;
return (res);
}
/* ARGSUSED */
static int
backout_patch_node_compare(const void *l_arg, const void *r_arg, void *private)
{
bo_patch_node_t *l = (bo_patch_node_t *)l_arg;
bo_patch_node_t *r = (bo_patch_node_t *)r_arg;
return (strcmp(l->patch_num, r->patch_num));
}
static boolean_t
init_backout_data(uu_avl_pool_t **backout_pool, uu_avl_t **backout_list)
{
if ((*backout_pool = uu_avl_pool_create("backout_pool",
sizeof (bo_patch_node_t), offsetof(bo_patch_node_t, link),
backout_patch_node_compare, UU_DEFAULT)) == NULL)
return (B_FALSE);
if ((*backout_list = uu_avl_create(*backout_pool, NULL, UU_DEFAULT))
== NULL)
return (B_FALSE);
return (B_TRUE);
}
static void
cleanup_backout_data(uu_avl_pool_t *backout_pool, uu_avl_t *backout_list)
{
if (backout_list != NULL) {
bo_patch_node_t *p;
void *cookie = NULL;
while ((p = uu_avl_teardown(backout_list, &cookie)) != NULL)
free(p);
uu_avl_destroy(backout_list);
}
if (backout_pool != NULL)
uu_avl_pool_destroy(backout_pool);
}
static void
attach_usage()
{
(void) fprintf(stderr, gettext("usage:\t%s brand options: "
"[-b patchid]* [-u]\n"), MY_BRAND_NAME);
(void) fprintf(stderr, gettext("\tSpecify one or more -b patchid "
"options to backout the patch from the\n\tzone.\n"));
(void) fprintf(stderr, gettext("\tSpecify -u to update the zone to "
"the current system software.\n"));
}
static int
attach_func(int argc, char *argv[])
{
int err, arg;
int res = ZONE_SUBPROC_NOTCOMPLETE;
zone_dochandle_t handle = NULL;
zone_dochandle_t athandle = NULL;
char brand[MAXNAMELEN], atbrand[MAXNAMELEN];
boolean_t execute = B_TRUE;
boolean_t update = B_FALSE;
char *manifest_path;
char tmp_path[MAXPATHLEN];
uu_avl_pool_t *backout_pool = NULL;
uu_avl_t *backout_list = NULL;
bo_patch_node_t *backout;
uu_avl_index_t where;
opterr = 0;
optind = 0;
while ((arg = getopt(argc, argv, "?b:Fn:u")) != EOF) {
switch (arg) {
case '?':
if (optopt != '?') {
(void) fprintf(stderr, gettext("%s brand: "
"invalid option: %c\n"), MY_BRAND_NAME,
optopt);
}
attach_usage();
res = (optopt == '?' ? ZONE_SUBPROC_OK :
ZONE_SUBPROC_USAGE);
goto done;
case 'b':
if (backout_pool == NULL &&
!init_backout_data(&backout_pool, &backout_list))
goto done;
if ((backout = (bo_patch_node_t *)malloc(
sizeof (bo_patch_node_t))) == NULL)
goto done;
backout->patch_num = optarg;
backout->can_backout = B_TRUE;
backout->installed = B_FALSE;
uu_avl_node_init(backout, &backout->link, backout_pool);
if (uu_avl_find(backout_list, backout, NULL, &where)
== NULL) {
(void) uu_avl_insert(backout_list, backout,
where);
} else {
free(backout);
}
break;
case 'n':
execute = B_FALSE;
manifest_path = optarg;
break;
case 'u':
update = B_TRUE;
break;
default:
(void) fprintf(stderr, gettext("%s brand: invalid "
"option: %c\n"), MY_BRAND_NAME, optopt);
res = ZONE_SUBPROC_USAGE;
goto done;
}
}
if (argc > optind) {
attach_usage();
res = ZONE_SUBPROC_USAGE;
goto done;
}
/* dry-run and update flags are mutually exclusive */
if (!execute && update) {
(void) fprintf(stderr, gettext("-n and -u flags are mutually "
"exclusive\n"));
res = ZONE_SUBPROC_USAGE;
goto done;
}
/*
* If there are any patches to backout, check if each patch was
* installed with its backout data.
*/
if (!backout_ok(backout_list, backout_pool))
goto done;
/*
* If the no-execute option was specified, we need to branch down
* a completely different path since there is no zone required to be
* configured for this option.
*/
if (!execute) {
res = dryrun_attach(manifest_path);
goto done;
}
if ((handle = zonecfg_init_handle()) == NULL) {
(void) fprintf(stderr, gettext("brand attach program error: "
"%s\n"), strerror(errno));
goto done;
}
if ((err = zonecfg_get_handle(zonename, handle)) != Z_OK) {
(void) fprintf(stderr, gettext("brand attach program error: "
"%s\n"), zonecfg_strerror(err));
zonecfg_fini_handle(handle);
goto done;
}
if ((athandle = zonecfg_init_handle()) == NULL) {
(void) fprintf(stderr, gettext("brand attach program error: "
"%s\n"), strerror(errno));
goto done;
}
/* Get the detach information for the locally defined zone. */
if ((err = get_detach_info(handle, B_FALSE)) != Z_OK) {
(void) fprintf(stderr, gettext("getting the attach information "
"failed: %s\n"), zonecfg_strerror(err));
goto done;
}
/*
* If the zone was previously detached, then we can read its manifest
* to check that the detached and locally defined zones are both of
* the same brand.
*/
if (zonecfg_get_attach_handle(zonepath, ZONE_DETACHED, zonename,
B_TRUE, athandle) == Z_OK) {
if ((zonecfg_get_brand(handle, brand, sizeof (brand)) != 0) ||
(zonecfg_get_brand(athandle, atbrand, sizeof (atbrand))
!= 0)) {
(void) fprintf(stderr, gettext("missing or invalid "
"brand\n"));
goto done;
}
if (strcmp(atbrand, brand) != 0) {
(void) fprintf(stderr, gettext("Trying to attach a "
"'%s' zone to a '%s' configuration.\n"), atbrand,
brand);
goto done;
}
zonecfg_fini_handle(athandle);
if ((athandle = zonecfg_init_handle()) == NULL) {
(void) fprintf(stderr, gettext("brand attach program "
"error: %s\n"), strerror(errno));
goto done;
}
}
/* Now backout the specified patches. */
if (!backout_patches(backout_list)) {
res = ZONE_SUBPROC_FATAL;
goto done;
}
/*
* Now that any patches have been backed out, regenerate the zone
* detach data.
*
* Even if no patches were backed out, we want to regenerate the
* detach data using the latest software on this target system so
* that we take advantage of any bug fixes on this release.
*/
if (snprintf(tmp_path, sizeof (tmp_path), "%s/%s", zonepath,
TMP_MANIFEST) >= sizeof (tmp_path) ||
!gen_detach_info(TMP_MANIFEST)) {
(void) fprintf(stderr, gettext("Cannot generate the "
"information needed to attach this zone.\n"));
goto done;
}
if ((err = zonecfg_get_attach_handle(zonepath, TMP_MANIFEST, zonename,
B_TRUE, athandle)) != Z_OK) {
(void) fprintf(stderr, gettext("brand attach program "
"error: %s\n"), zonecfg_strerror(err));
(void) unlink(tmp_path);
goto done;
}
(void) unlink(tmp_path);
/*
* We set the result to be fatal here. If we make it through the sw
* check and possible update cleanly, then we set the result to OK.
* Otherwise, we goto done and the result remains fatal.
*/
res = ZONE_SUBPROC_FATAL;
/*
* If we're doing an update on attach, and the zone does need to be
* updated, then run the update.
*/
if (update) {
char fname[MAXPATHLEN];
(void) sigset(SIGINT, sigcleanup);
if ((err = sw_up_to_date(handle, athandle)) != Z_OK) {
if (err != Z_FATAL && !attach_interupted)
err = attach_update(handle);
}
(void) sigset(SIGINT, SIG_DFL);
/*
* Clean up data files left behind by sw_up_to_date().
* Don't worry if the files don't exist; they might have been
* cleaned up by the attach_update() function.
*/
(void) snprintf(fname, sizeof (fname), "%s/pkg_add", zonepath);
(void) unlink(fname);
(void) snprintf(fname, sizeof (fname), "%s/pkg_rm", zonepath);
(void) unlink(fname);
if (attach_interupted || err != Z_OK)
goto done;
} else {
/* sw_cmp prints error msgs as necessary */
if (sw_cmp(handle, athandle, SW_CMP_NONE) != Z_OK)
goto done;
if (dev_fix(zonename, athandle) != Z_OK)
goto done;
}
if ((err = zone_set_state(zonename, ZONE_STATE_INSTALLED)) != Z_OK) {
(void) fprintf(stderr, gettext("could not reset state: %s\n"),
zonecfg_strerror(err));
goto done;
}
res = ZONE_SUBPROC_OK;
done:
if (handle != NULL)
zonecfg_fini_handle(handle);
if (athandle != NULL)
zonecfg_fini_handle(athandle);
cleanup_backout_data(backout_pool, backout_list);
return (res);
}
static boolean_t
add_opts(char *buf, int bsize, char opt, char *arg)
{
char argbuf[MAXPATHLEN];
if (snprintf(argbuf, sizeof (argbuf), " -%c '%s'", opt, arg)
> sizeof (argbuf) || strlcat(buf, argbuf, bsize) >= bsize) {
(void) fprintf(stderr, gettext("Command line too long"));
return (B_TRUE);
}
return (B_FALSE);
}
static boolean_t
add_opt(char *buf, int bsize, char opt)
{
char argbuf[4];
(void) snprintf(argbuf, sizeof (argbuf), " -%c", opt);
if (strlcat(buf, argbuf, bsize) >= bsize) {
(void) fprintf(stderr, gettext("Command line too long"));
return (B_TRUE);
}
return (B_FALSE);
}
static void
install_usage()
{
(void) fprintf(stderr, gettext("usage:\t%s brand options:\n"
"\tWith no options the zone is freshly installed:\n"
"\t\tinstall\n"
"\tAlternatively, the zone may be installed using an existing\n"
"\tsystem image from an archive or a directory:\n"
"\t\tinstall -a archive (-u | -p) [-v | -s] [-b patchid]*\n"
"\t\tinstall -d directory (-u | -p) [-v | -s] [-b patchid]*\n"),
MY_BRAND_NAME);
}
static int
install_func(int argc, char *argv[])
{
char cmdbuf[NCARGS];
char argbuf[NCARGS];
int arg;
int status;
boolean_t image_install = B_FALSE;
char image_install_arg = '\0';
argbuf[0] = '\0';
opterr = 0;
optind = 0;
while ((arg = getopt(argc, argv, "?a:b:d:psuvx:")) != EOF) {
switch (arg) {
case '?':
if (optopt != '?') {
(void) fprintf(stderr, gettext("%s brand: "
"invalid option: %c\n"), MY_BRAND_NAME,
optopt);
}
install_usage();
return (optopt == '?' ? Z_OK : ZONE_SUBPROC_USAGE);
case 'a':
if (image_install) {
install_usage();
return (ZONE_SUBPROC_USAGE);
}
image_install = B_TRUE;
if (add_opts(argbuf, sizeof (argbuf), arg, optarg))
return (Z_ERR);
break;
case 'b':
image_install_arg = optopt;
if (add_opts(argbuf, sizeof (argbuf), arg, optarg))
return (Z_ERR);
break;
case 'd':
if (image_install) {
install_usage();
return (ZONE_SUBPROC_USAGE);
}
image_install = B_TRUE;
if (add_opts(argbuf, sizeof (argbuf), arg, optarg))
return (Z_ERR);
break;
case 'p':
image_install_arg = optopt;
if (add_opt(argbuf, sizeof (argbuf), arg))
return (Z_ERR);
break;
case 's':
image_install_arg = optopt;
if (add_opt(argbuf, sizeof (argbuf), arg))
return (Z_ERR);
break;
case 'u':
image_install_arg = optopt;
if (add_opt(argbuf, sizeof (argbuf), arg))
return (Z_ERR);
break;
case 'v':
image_install_arg = optopt;
if (add_opt(argbuf, sizeof (argbuf), arg))
return (Z_ERR);
break;
case 'x':
if (strcmp(optarg, "nodataset") != 0) {
(void) fprintf(stderr, gettext("%s brand: "
"invalid option: %c\n"), MY_BRAND_NAME,
arg);
return (ZONE_SUBPROC_USAGE);
}
/* Ignore option, handled in zoneadm. */
break;
default:
(void) fprintf(stderr, gettext("%s brand: invalid "
"option: %c\n"), MY_BRAND_NAME, optopt);
return (ZONE_SUBPROC_USAGE);
}
}
if (argc > optind) {
install_usage();
return (ZONE_SUBPROC_USAGE);
}
/*
* Either install the zone using a system image or using the
* traditional lu support.
*/
if (image_install) {
if (snprintf(cmdbuf, sizeof (cmdbuf),
"/usr/lib/brand/native/image_install %s %s %s", zonename,
zonepath, argbuf) >= sizeof (cmdbuf))
return (Z_ERR);
} else {
struct stat stbuf;
char rootpath[MAXPATHLEN]; /* zone root path */
if (snprintf(rootpath, sizeof (rootpath), "%s/root", zonepath)
>= sizeof (rootpath)) {
(void) fprintf(stderr,
gettext("Zonepath %s is too long.\n"), zonepath);
return (Z_ERR);
}
if (stat(rootpath, &stbuf) == 0) {
struct dirent *dp;
DIR *dirp;
boolean_t empty = B_TRUE;
if ((dirp = opendir(rootpath)) == NULL) {
(void) fprintf(stderr, gettext("Could not "
"open rootpath %s\n"), rootpath);
return (Z_ERR);
}
/* Verify that the dir is empty. */
while ((dp = readdir(dirp)) != NULL) {
if (strcmp(dp->d_name, ".") == 0 ||
strcmp(dp->d_name, "..") == 0)
continue;
empty = B_FALSE;
break;
}
(void) closedir(dirp);
if (!empty) {
(void) fprintf(stderr, gettext("Zonepath root "
"%s exists and contains data; remove or "
"move aside prior to install.\n"),
rootpath);
return (Z_ERR);
}
}
if (image_install_arg != '\0') {
(void) fprintf(stderr, gettext("%s brand: option: %c "
"is only valid with -a or -d\n"), MY_BRAND_NAME,
image_install_arg);
return (ZONE_SUBPROC_USAGE);
}
if (snprintf(cmdbuf, sizeof (cmdbuf),
"/usr/lib/lu/lucreatezone -z %s", zonename) >=
sizeof (cmdbuf))
return (Z_ERR);
}
/*
* According to the Application Packaging Developer's Guide, a
* "checkinstall" script when included in a package is executed as
* the user "install", if such a user exists, or by the user
* "nobody". In order to support this dubious behavior, the path
* to the zone being constructed is opened up during the life of
* the command laying down the zone's root file system. Once this
* has completed, regardless of whether it was successful, the
* path to the zone is again restricted.
*/
if (chmod(zonepath, DEFAULT_DIR_MODE) != 0) {
zperror(zonepath, B_FALSE);
return (Z_ERR);
}
status = do_subproc(cmdbuf);
if (chmod(zonepath, S_IRWXU) != 0) {
zperror(zonepath, B_FALSE);
return (Z_ERR);
}
if (subproc_status("install", status, B_FALSE) != ZONE_SUBPROC_OK)
return (Z_ERR);
return (Z_OK);
}
/* ARGSUSED */
static int
postclone_func(int argc, char *argv[])
{
int status;
boolean_t res = B_TRUE;
struct stat sbuf;
char cmdbuf[2 * MAXPATHLEN];
/* Ignore any arguments. */
/*
* Trusted Extensions requires that cloned zones use the same sysid
* configuration, so it is not appropriate to perform any
* post-clone reconfiguration.
*/
if (is_system_labeled())
return (ZONE_SUBPROC_OK);
/* If the zone is already sys-unconfiged, then we're done. */
if (snprintf(cmdbuf, sizeof (cmdbuf), "%s/root/etc/.UNCONFIGURED",
zonepath) >= sizeof (cmdbuf))
return (ZONE_SUBPROC_FATAL);
if (stat(cmdbuf, &sbuf) == 0 && S_ISREG(sbuf.st_mode))
return (ZONE_SUBPROC_OK);
/*
* Mount the zone. The zone is still in the INCOMPLETE state, so we
* have to force mount it.
*/
if (mount_func(B_TRUE) != Z_OK)
return (ZONE_SUBPROC_FATAL);
/* sys-unconfig the zone */
if (snprintf(cmdbuf, sizeof (cmdbuf), "/usr/sbin/zlogin -S %s "
"'/usr/sbin/sys-unconfig -R /a'", zonename) >= sizeof (cmdbuf)) {
res = B_FALSE;
} else {
status = do_subproc(cmdbuf);
if (subproc_status("sys-unconfig failed", status, B_TRUE)
!= ZONE_SUBPROC_OK)
res = B_FALSE;
}
if (unmount_func() != Z_OK)
res = B_FALSE;
return (res ? ZONE_SUBPROC_OK : ZONE_SUBPROC_FATAL);
}
/*
* Perform any necessary housekeeping tasks we need to do before we take
* a ZFS snapshot of the zone. What this really entails is that we are
* taking a sw inventory of the source zone, like we do when we detach,
* so that there is the XML manifest in the snapshot. We use that to
* validate the snapshot if it is the source of a clone at some later time.
*/
static int
presnap_func(int argc, char *argv[])
{
int err;
zone_dochandle_t handle;
opterr = 0;
optind = 0;
if (getopt(argc, argv, "") != EOF)
return (ZONE_SUBPROC_USAGE);
if ((handle = zonecfg_init_handle()) == NULL) {
(void) fprintf(stderr, gettext("brand pre-snapshot program "
"error: %s\n"), strerror(errno));
return (Z_ERR);
}
if ((err = zonecfg_get_handle(zonename, handle)) != Z_OK) {
(void) fprintf(stderr, gettext("brand pre-snapshot program "
"error: %s\n"), zonecfg_strerror(err));
zonecfg_fini_handle(handle);
return (Z_ERR);
}
if ((err = get_detach_info(handle, B_TRUE)) != Z_OK) {
(void) fprintf(stderr, gettext("brand pre-snapshot program "
"error: %s\n"), zonecfg_strerror(err));
zonecfg_fini_handle(handle);
return (Z_ERR);
}
if ((err = zonecfg_detach_save(handle, 0)) != Z_OK) {
(void) fprintf(stderr, gettext("saving the detach manifest "
"failed: %s\n"), zonecfg_strerror(err));
zonecfg_fini_handle(handle);
return (Z_ERR);
}
zonecfg_fini_handle(handle);
return (Z_OK);
}
/*
* Perform any necessary housekeeping tasks we need to do after we take
* a ZFS snapshot of the zone. What this really entails is removing the
* sw inventory XML file from the zone. It is still in the snapshot where
* we want it, but we don't want it in the source zone itself.
*/
static int
postsnap_func(int argc, char *argv[])
{
int err;
zone_dochandle_t handle;
opterr = 0;
optind = 0;
if (getopt(argc, argv, "") != EOF)
return (ZONE_SUBPROC_USAGE);
if ((handle = zonecfg_init_handle()) == NULL) {
(void) fprintf(stderr, gettext("brand post-snapshot program "
"error: %s\n"), strerror(errno));
return (Z_ERR);
}
if ((err = zonecfg_get_handle(zonename, handle)) != Z_OK) {
(void) fprintf(stderr, gettext("brand post-snapshot program "
"error: %s\n"), zonecfg_strerror(err));
zonecfg_fini_handle(handle);
return (Z_ERR);
}
zonecfg_rm_detached(handle, B_FALSE);
zonecfg_fini_handle(handle);
return (Z_OK);
}
/*
* We are using an explicit snapshot from some earlier point in time so
* we need to validate it. This involves checking the sw inventory that
* we took when we made the snapshot to verify that the current sw config
* on the host is still valid to run a zone made from this snapshot.
*/
static int
validatesnap_func(int argc, char *argv[])
{
int err;
zone_dochandle_t handle;
zone_dochandle_t athandle = NULL;
char *snapshot_name;
char *snap_path;
opterr = 0;
optind = 0;
if (getopt(argc, argv, "") != EOF)
return (ZONE_SUBPROC_USAGE);
if (argc < 2)
return (ZONE_SUBPROC_USAGE);
snapshot_name = argv[0];
snap_path = argv[1];
if ((handle = zonecfg_init_handle()) == NULL) {
(void) fprintf(stderr, gettext("brand validate-snapshot "
"program error: %s\n"), strerror(errno));
return (Z_ERR);
}
if ((err = zonecfg_get_handle(zonename, handle)) != Z_OK) {
(void) fprintf(stderr, gettext("brand validate-snapshot "
"program error: %s\n"), zonecfg_strerror(err));
zonecfg_fini_handle(handle);
return (Z_ERR);
}
if ((athandle = zonecfg_init_handle()) == NULL) {
(void) fprintf(stderr, gettext("brand validate-snapshot "
"program error: %s\n"), strerror(errno));
goto done;
}
if ((err = zonecfg_get_attach_handle(snap_path, ZONE_DETACHED, zonename,
B_TRUE, athandle)) != Z_OK) {
if (err == Z_NO_ZONE)
(void) fprintf(stderr, gettext("snapshot %s was not "
"taken\n\tby a 'zoneadm clone' command. It can "
"not be used to clone zones.\n"), snapshot_name);
else
(void) fprintf(stderr, gettext("snapshot %s is "
"out-dated\n\tIt can no longer be used to clone "
"zones on this system.\n"), snapshot_name);
goto done;
}
/* Get the detach information for the locally defined zone. */
if ((err = get_detach_info(handle, B_FALSE)) != Z_OK) {
errno = err;
zperror(gettext("getting the attach information failed"),
B_TRUE);
goto done;
}
if ((err = sw_cmp(handle, athandle, SW_CMP_SILENT)) != Z_OK)
(void) fprintf(stderr, gettext("snapshot %s is out-dated\n\t"
"It can no longer be used to clone zones on this "
"system.\n"), snapshot_name);
done:
zonecfg_fini_handle(handle);
if (athandle != NULL)
zonecfg_fini_handle(athandle);
return ((err == Z_OK) ? Z_OK : ZONE_SUBPROC_FATAL);
}
static void
usage()
{
(void) fprintf(stderr, gettext("sw_support invalid arguments\n"));
exit(253);
}
int
main(int argc, char **argv)
{
int err = ZONE_SUBPROC_FATAL;
char *cmd = NULL;
if ((locale = setlocale(LC_ALL, "")) == NULL)
locale = "C";
(void) textdomain(TEXT_DOMAIN);
if (argc < 4)
usage();
cmd = argv[1];
zonename = argv[2];
zonepath = argv[3];
argc -= 4;
argv = &argv[4];
if (strcmp(cmd, "attach") == 0)
err = attach_func(argc, argv);
else if (strcmp(cmd, "detach") == 0)
err = detach_func(argc, argv);
else if (strcmp(cmd, "install") == 0)
err = install_func(argc, argv);
else if (strcmp(cmd, "postclone") == 0)
err = postclone_func(argc, argv);
else if (strcmp(cmd, "presnap") == 0)
err = presnap_func(argc, argv);
else if (strcmp(cmd, "postsnap") == 0)
err = postsnap_func(argc, argv);
else if (strcmp(cmd, "validatesnap") == 0)
err = validatesnap_func(argc, argv);
return (err);
}