static char *GetProcessOptions()
{
# ifdef HAVE_GETZONEID
zoneid_t zid;
char zone[ZONENAME_MAX];
static char psopts[CF_BUFSIZE];
zid = getzoneid();
getzonenamebyid(zid, zone, ZONENAME_MAX);
if (strcmp(zone, "global") == 0)
{
snprintf(psopts, CF_BUFSIZE, "%s,zone", VPSOPTS[VSYSTEMHARDCLASS]);
return psopts;
}
# endif
# ifdef LINUX
if (strncmp(VSYSNAME.release, "2.4", 3) == 0)
{
// No threads on 2.4 kernels
return "-eo user,pid,ppid,pgid,pcpu,pmem,vsz,pri,rss,stime,time,args";
}
# endif
return VPSOPTS[VSYSTEMHARDCLASS];
}
/*
* -t prints "shared" vs. "exclusive"
*/
int
main(int argc, char *argv[])
{
zoneid_t zoneid;
char zonename[ZONENAME_MAX];
FILE *fp;
int arg;
boolean_t stacktype = B_FALSE;
(void) setlocale(LC_ALL, "");
(void) textdomain(TEXT_DOMAIN);
opterr = 0;
while ((arg = getopt(argc, argv, "t")) != EOF) {
switch (arg) {
case 't':
stacktype = B_TRUE;
break;
}
}
zoneid = getzoneid();
if (stacktype) {
ushort_t flags;
if (zone_getattr(zoneid, ZONE_ATTR_FLAGS, &flags,
sizeof (flags)) < 0) {
perror("could not determine zone IP type");
exit(1);
}
if (flags & ZF_NET_EXCL)
(void) puts("exclusive");
else
(void) puts("shared");
return (0);
}
if (getzonenamebyid(zoneid, zonename, sizeof (zonename)) < 0) {
(void) fputs(gettext("could not determine zone name\n"),
stderr);
return (1);
}
/*
* The use of dlopen here is a bit ugly, but it allows zonename to
* function properly before /usr is mounted. On such a system, scratch
* zones don't exist, so no translation is necessary.
*/
if (dlopen("libzonecfg.so.1", RTLD_NOW | RTLD_GLOBAL) != NULL &&
zonecfg_is_scratch(zonename) &&
(fp = zonecfg_open_scratch("", B_FALSE)) != NULL) {
(void) zonecfg_reverse_scratch(fp, zonename, zonename,
sizeof (zonename), NULL, 0);
zonecfg_close_scratch(fp);
}
(void) puts(zonename);
return (0);
}
int
zone_get_id(const char *str, zoneid_t *zip)
{
zoneid_t zoneid;
char *cp;
/*
* The first time we are called, attempt to dlopen() libzonecfg.so.1
* and get a pointer to the real zone_get_id().
* If we fail, set our pointer to -1 so we won't try again.
*/
if (real_zone_get_id == NULL) {
/*
* There's no harm in doing this more than once, even
* concurrently. We will get the same result each time,
* and the dynamic linker will single-thread the dlopen()
* with its own internal lock. The worst that can happen
* is that the handle gets a reference count greater than
* one, which doesn't matter since we never dlclose()
* the handle if we successfully find the symbol; the
* library just stays in the address space until exit().
*/
void *dlhandle = dlopen("libzonecfg.so.1", RTLD_LAZY);
void *sym = (void *)(-1);
if (dlhandle != NULL &&
(sym = dlsym(dlhandle, "zone_get_id")) == NULL) {
sym = (void *)(-1);
(void) dlclose(dlhandle);
}
real_zone_get_id = (zone_get_id_t)sym;
}
/*
* If we've successfully loaded it, call the real zone_get_id().
* Otherwise, perform our stripped-down version of the code.
*/
if (real_zone_get_id != (zone_get_id_t)(-1))
return (real_zone_get_id(str, zip));
/* first try looking for active zone by id */
errno = 0;
zoneid = (zoneid_t)strtol(str, &cp, 0);
if (errno == 0 && cp != str && *cp == '\0' &&
getzonenamebyid(zoneid, NULL, 0) != -1) {
*zip = zoneid;
return (0);
}
/* then look for active zone by name */
if ((zoneid = getzoneidbyname(str)) != -1) {
*zip = zoneid;
return (0);
}
/* not an active zone, return error */
return (-1);
}
void
lookup_zonename(char *zonename, size_t zonesize)
{
zoneid_t zoneid = getzoneid();
if (getzonenamebyid(zoneid, zonename, zonesize) >= 0)
return;
syslog(LOG_ERR, "could not determine zone name");
(void) strlcpy(zonename, GLOBAL_ZONENAME, zonesize);
}
/*ARGSUSED*/
static int
ipdadm_list(int argc, char *argv[])
{
int fd, rval;
unsigned int ii;
ipd_ioc_list_t ipil;
char zonename[ZONENAME_MAX];
if (argc != 0)
return (usage(stderr));
fd = ipdadm_open();
(void) memset(&ipil, '\0', sizeof (ipd_ioc_list_t));
rval = ioctl(fd, IPDIOC_LIST, &ipil);
if (rval != 0) {
(void) fprintf(stderr, "%s: failed to get list info: %s\n",
g_pname, strerror(errno));
return (E_ERROR);
}
ipil.ipil_list = malloc(sizeof (zoneid_t) * ipil.ipil_nzones);
if (ipil.ipil_list == NULL) {
(void) fprintf(stderr, "%s: failed to allocate memory: %s\n",
g_pname, strerror(errno));
return (E_ERROR);
}
rval = ioctl(fd, IPDIOC_LIST, &ipil);
if (rval != 0) {
free(ipil.ipil_list);
(void) fprintf(stderr, "%s: failed to get list info: %s\n",
g_pname, strerror(errno));
return (E_ERROR);
}
for (ii = 0; ii < ipil.ipil_nzones; ii++) {
if (getzonenamebyid(ipil.ipil_list[ii], zonename,
sizeof (zonename)) < 0) {
(void) fprintf(stderr, "%s: failed to get zonename: "
"%s\n", g_pname, strerror(errno));
return (E_ERROR);
}
(void) printf("%s\n", zonename);
}
return (E_SUCCESS);
}
char *
get_labeled_zonename(char *slabel)
{
m_label_t *bsl = NULL;
int err = 0;
ssize_t zonename_size = -1;
zoneid_t zid = -1;
char *zname = NULL;
syslog(LOG_DEBUG, "lpsched: get_labeled_zonename %s", slabel);
/*
* convert the label to binary.
*/
if (str_to_label(slabel, &bsl, USER_CLEAR,
L_NO_CORRECTION, &err) == -1) {
/* label could not be converted, error */
syslog(LOG_WARNING,
"lpsched: %s: label not recognized (error==%d)",
slabel, err);
return ((char *)-1);
}
if ((zid = getzoneidbylabel(bsl)) < 0) {
/* no zone with that label, cannot send mail */
syslog(LOG_WARNING,
"lpsched: cannot send mail, no zone with %s label",
slabel);
m_label_free(bsl);
return ((char *)-1);
}
zname = Malloc(ZONENAME_MAX + 1);
if ((zonename_size = getzonenamebyid(zid, zname, ZONENAME_MAX + 1))
== -1) {
/* cannot get zone name, cannot send mail */
syslog(LOG_WARNING,
"lpsched: cannot send mail, no zone name for %s",
slabel);
m_label_free(bsl);
Free(zname);
return ((char *)-1);
} else {
m_label_free(bsl);
if (strcmp(zname, GLOBAL_ZONENAME) == 0) {
Free(zname);
zname = NULL;
}
}
return (zname);
}
static void zone_submit_values(c_avl_tree_t *tree) {
char zonename[ZONENAME_MAX];
zoneid_t *zoneid = NULL;
zone_stats_t *stats = NULL;
while (c_avl_pick(tree, (void **)&zoneid, (void **)&stats) == 0) {
if (getzonenamebyid(*zoneid, zonename, sizeof(zonename)) == -1) {
WARNING("zone plugin: error retrieving zonename");
} else {
zone_submit_value(zonename, (gauge_t)FRC2PCT(stats->pctcpu));
}
free(stats);
free(zoneid);
}
c_avl_destroy(tree);
}
static boolean_t
libbrand_initialize()
{
static mutex_t initialize_lock = DEFAULTMUTEX;
(void) mutex_lock(&initialize_lock);
if (libbrand_initialized) {
(void) mutex_unlock(&initialize_lock);
return (B_TRUE);
}
if (sysinfo(SI_ARCHITECTURE, i_curr_arch, sizeof (i_curr_arch)) < 0) {
(void) mutex_unlock(&initialize_lock);
return (B_FALSE);
}
if (getzonenamebyid(getzoneid(), i_curr_zone,
sizeof (i_curr_zone)) < 0) {
(void) mutex_unlock(&initialize_lock);
return (B_FALSE);
}
/*
* Note that here we're initializing per-process libxml2
* state. By doing so we're implicitly assuming that
* no other code in this process is also trying to
* use libxml2. But in most case we know this not to
* be true since we're almost always used in conjunction
* with libzonecfg, which also uses libxml2. Lucky for
* us, libzonecfg initializes libxml2 to essentially
* the same defaults as we're using below.
*/
(void) xmlLineNumbersDefault(1);
xmlLoadExtDtdDefaultValue |= XML_DETECT_IDS;
xmlDoValidityCheckingDefaultValue = 1;
(void) xmlKeepBlanksDefault(0);
xmlGetWarningsDefaultValue = 0;
xmlSetGenericErrorFunc(NULL, brand_error_func);
libbrand_initialized = B_TRUE;
(void) mutex_unlock(&initialize_lock);
return (B_TRUE);
}
static void
ipdadm_list_one(zoneid_t z, const ipd_config_t *icp, void *arg)
{
char zonename[ZONENAME_MAX];
int opt_v = (int)(intptr_t)arg;
if (getzonenamebyid(z, zonename, sizeof (zonename)) < 0)
(void) printf("%ld", z);
else
(void) printf("%s", zonename);
if (!opt_v) {
(void) printf("\n");
return;
}
(void) printf("\t%u\t%u\t%u\n", icp->ic_corrupt, icp->ic_drop,
icp->ic_delay);
}
static int ForeignZone(char *s)
{
// We want to keep the banner
if (strstr(s, "%CPU"))
{
return false;
}
# ifdef HAVE_GETZONEID
zoneid_t zid;
char *sp, zone[ZONENAME_MAX];
static psopts[CF_BUFSIZE];
zid = getzoneid();
getzonenamebyid(zid, zone, ZONENAME_MAX);
if (strcmp(zone, "global") == 0)
{
if (strcmp(s + strlen(s) - 6, "global") == 0)
{
*(s + strlen(s) - 6) = '\0';
for (sp = s + strlen(s) - 1; isspace(*sp); sp--)
{
*sp = '\0';
}
return false;
}
else
{
return true;
}
}
# endif
return false;
}
static void
sendmes_tozone(zoneid_t zid, int aflag) {
int i = 0;
char zonename[ZONENAME_MAX], root[MAXPATHLEN];
struct utmpx *p;
if (zid != getzoneid()) {
root[0] = '\0';
(void) getzonenamebyid(zid, zonename, ZONENAME_MAX);
(void) zone_get_rootpath(zonename, root, sizeof (root));
(void) strlcat(root, UTMPX_FILE, sizeof (root));
if (!utmpxname(root)) {
(void) fprintf(stderr, "Cannot open %s\n", root);
return;
}
} else {
(void) utmpxname(UTMPX_FILE);
}
setutxent();
while ((p = getutxent()) != NULL) {
if (p->ut_type != USER_PROCESS)
continue;
/*
* if (-a option OR NOT pty window login), send the message
*/
if (aflag || !nonuserx(*p))
sendmes(p, zid);
}
endutxent();
(void) alarm(60);
do {
i = (int)wait((int *)0);
} while (i != -1 || errno != ECHILD);
}
int
main(int argc, char *argv[])
{
int ii;
ipdadm_cmd_t *cmd;
g_pname = basename(argv[0]);
if (argc < 2)
return (usage(stderr));
argc--;
argv++;
g_zid = getzoneid();
if (strcmp("-z", argv[0]) == 0) {
argc--;
argv++;
if (argc < 1) {
(void) fprintf(stderr, "%s: -z requires an argument\n",
g_pname);
return (usage(stderr));
}
if (g_zid != GLOBAL_ZONEID) {
(void) fprintf(stderr, "%s: -z option only permitted "
"in global zone\n", g_pname);
return (usage(stderr));
}
g_zid = getzoneidbyname(argv[0]);
if (g_zid == -1) {
(void) fprintf(stderr, "%s: %s: invalid zone\n",
g_pname, argv[0]);
return (E_ERROR);
}
argc--;
argv++;
}
if (getzonenamebyid(g_zid, g_zonename, sizeof (g_zonename)) < 0) {
(void) fprintf(stderr, "%s: failed to get zonename: %s\n",
g_pname, strerror(errno));
return (E_ERROR);
}
if (argc < 1)
return (usage(stderr));
for (ii = 0; ii < IPDADM_NCMDS; ii++) {
cmd = &ipdadm_cmds[ii];
if (strcmp(argv[0], cmd->idc_name) == 0) {
argv++;
argc--;
assert(cmd->idc_func != NULL);
return (cmd->idc_func(argc, argv));
}
}
(void) fprintf(stderr, "%s: %s: unknown command\n", g_pname, argv[0]);
return (usage(stderr));
}
/*
* Note to future maintainers: with the change of wall to use the
* getutxent() API, the forked children (created by this function)
* must call _exit as opposed to exit. This is necessary to avoid
* unwanted fflushing of getutxent's stdio stream (caused by atexit
* processing).
*/
static void
sendmes(struct utmpx *p, zoneid_t zid)
{
int i;
char *s;
static char device[LMAX + 6];
char *bp;
int ibp;
FILE *f;
int fd, tmpl_fd;
boolean_t zoneenter = B_FALSE;
if (zid != getzoneid()) {
zoneenter = B_TRUE;
tmpl_fd = init_template();
if (tmpl_fd == -1) {
(void) fprintf(stderr, "Could not initialize "
"process contract");
return;
}
}
while ((i = (int)fork()) == -1) {
(void) alarm(60);
(void) wait((int *)0);
(void) alarm(0);
}
if (i)
return;
if (zoneenter && zone_enter(zid) == -1) {
char zonename[ZONENAME_MAX];
(void) getzonenamebyid(zid, zonename, ZONENAME_MAX);
(void) fprintf(stderr, "Could not enter zone "
"%s\n", zonename);
}
if (zoneenter)
(void) ct_tmpl_clear(tmpl_fd);
if (gflag)
if (!chkgrp(p->ut_user))
_exit(0);
(void) signal(SIGHUP, SIG_IGN);
(void) alarm(60);
s = &device[0];
(void) snprintf(s, sizeof (device), "/dev/%.*s", LMAX, p->ut_line);
/* check if the device is really a tty */
if ((fd = open(s, O_WRONLY|O_NOCTTY|O_NONBLOCK)) == -1) {
(void) fprintf(stderr, "Cannot send to %.*s on %s\n",
NMAX, p->ut_user, s);
perror("open");
(void) fflush(stderr);
_exit(1);
} else {
if (!isatty(fd)) {
(void) fprintf(stderr,
"Cannot send to device %.*s %s\n",
LMAX, p->ut_line,
"because it's not a tty");
openlog("wall", 0, LOG_AUTH);
syslog(LOG_CRIT, "%.*s in utmpx is not a tty\n",
LMAX, p->ut_line);
closelog();
(void) fflush(stderr);
_exit(1);
}
}
#ifdef DEBUG
(void) close(fd);
f = fopen("wall.debug", "a");
#else
f = fdopen(fd, "w");
#endif
if (f == NULL) {
(void) fprintf(stderr, "Cannot send to %-.*s on %s\n",
NMAX, &p->ut_user[0], s);
perror("open");
(void) fflush(stderr);
_exit(1);
}
(void) fprintf(f,
"\07\07\07Broadcast Message from %s (%s) on %s %19.19s",
who, line, systm, time_buf);
if (gflag)
(void) fprintf(f, " to group %s", grpname);
(void) fprintf(f, "...\n");
#ifdef DEBUG
(void) fprintf(f, "DEBUG: To %.*s on %s\n", NMAX, p->ut_user, s);
#endif
i = strlen(mesg);
for (bp = mesg; --i >= 0; bp++) {
ibp = (unsigned int)((unsigned char) *bp);
if (*bp == '\n')
(void) putc('\r', f);
if (isprint(ibp) || *bp == '\r' || *bp == '\013' ||
*bp == ' ' || *bp == '\t' || *bp == '\n' || *bp == '\007') {
(void) putc(*bp, f);
} else {
if (!isascii(*bp)) {
(void) fputs("M-", f);
*bp = toascii(*bp);
}
if (iscntrl(*bp)) {
(void) putc('^', f);
(void) putc(*bp + 0100, f);
}
else
(void) putc(*bp, f);
}
if (*bp == '\n')
(void) fflush(f);
if (ferror(f) || feof(f)) {
(void) printf("\n\007Write failed\n");
(void) fflush(stdout);
_exit(1);
}
}
(void) fclose(f);
(void) close(fd);
_exit(0);
}
/*
* If the system is labeled then we need to
* have a uniquely-named auto_home map for each zone.
* The maps are made unique by appending the zonename.
* The home directory is made unique by prepending /zone/<zonename>
* for each zone that is dominated by the current zone.
* The current zone's home directory mount point is not changed.
*
* For each auto_home_<zonename> a default template map is created
* only if it doesn't exist yet. The default entry is used to declare
* local home directories created within each zone. For example:
*
* +auto_home_public
* * -fstype=lofs :/zone/public/export/home/&
*/
static void
loadzone_maps(char *mntpnt, char *map, char *opts, char **stack, char ***stkptr)
{
zoneid_t *zids = NULL;
zoneid_t my_zoneid;
uint_t nzents_saved;
uint_t nzents;
int i;
if (!priv_ineffect(PRIV_SYS_MOUNT))
return;
if (zone_list(NULL, &nzents) != 0) {
return;
}
my_zoneid = getzoneid();
again:
if (nzents == 0)
return;
zids = malloc(nzents * sizeof (zoneid_t));
nzents_saved = nzents;
if (zone_list(zids, &nzents) != 0) {
free(zids);
return;
}
if (nzents != nzents_saved) {
/* list changed, try again */
free(zids);
goto again;
}
for (i = 0; i < nzents; i++) {
char zonename[ZONENAME_MAX];
char zoneroot[MAXPATHLEN];
if (getzonenamebyid(zids[i], zonename, ZONENAME_MAX) != -1) {
char appended_map[MAXPATHLEN];
char prepended_mntpnt[MAXPATHLEN];
char map_path[MAXPATHLEN];
int fd;
(void) snprintf(appended_map, sizeof (appended_map),
"%s_%s", map, zonename);
/* for current zone, leave mntpnt alone */
if (zids[i] != my_zoneid) {
(void) snprintf(prepended_mntpnt,
sizeof (prepended_mntpnt),
"/zone/%s%s", zonename, mntpnt);
if (zone_getattr(zids[i], ZONE_ATTR_ROOT,
zoneroot, sizeof (zoneroot)) == -1)
continue;
} else {
(void) strcpy(prepended_mntpnt, mntpnt);
zoneroot[0] = '\0';
}
dirinit(prepended_mntpnt, appended_map, opts, 0, stack,
stkptr);
/*
* Next create auto_home_<zone> maps for each zone
*/
(void) snprintf(map_path, sizeof (map_path),
"/etc/%s", appended_map);
/*
* If the map file doesn't exist create a template
*/
if ((fd = open(map_path, O_RDWR | O_CREAT | O_EXCL,
S_IRUSR | S_IWUSR | S_IRGRP| S_IROTH)) != -1) {
int len;
char map_rec[MAXPATHLEN];
len = snprintf(map_rec, sizeof (map_rec),
"+%s\n*\t-fstype=lofs\t:%s/export/home/&\n",
appended_map, zoneroot);
if (len <= sizeof (map_rec))
(void) write(fd, map_rec, len);
(void) close(fd);
}
}
}
free(zids);
}
void
process_ids(char *pool_name, uint_t flags, idtype_t idtype, char *idstr,
int argc, char *argv[])
{
int i;
id_t id;
for (i = 0; i < argc; i++) {
char *endp;
char *poolname;
errno = 0;
id = (id_t)strtol(argv[i], &endp, 10);
if (errno != 0 ||
(endp && endp != argv[i] + strlen(argv[i])) ||
(idtype == P_ZONEID &&
getzonenamebyid(id, NULL, 0) == -1)) {
/*
* The string does not completely parse to
* an integer, or it represents an invalid
* zone id.
*/
/*
* It must be a project or zone name.
*/
if (idtype == P_ZONEID) {
if (zone_get_id(argv[i], &id) != 0) {
warn(gettext("invalid zone '%s'\n"),
argv[i]);
error = E_ERROR;
continue;
}
/* make sure the zone is booted */
if (id == -1) {
warn(gettext("zone '%s' is not "
"active\n"), argv[i]);
error = E_ERROR;
continue;
}
} else if (idtype == P_PROJID) {
if ((id = getprojidbyname(argv[i])) < 0) {
warn(gettext("failed to get project "
"id for project: '%s'"), argv[i]);
error = E_ERROR;
continue;
}
} else {
warn(gettext("invalid %s '%s'\n"),
idstr, argv[i]);
error = E_ERROR;
continue;
}
}
if (flags & pFLAG) {
if (pool_set_binding(pool_name, idtype, id) !=
PO_SUCCESS) {
warn(gettext("binding %s %ld to pool '%s': "
"%s\n"), idstr, id, pool_name,
get_errstr());
error = E_ERROR;
}
continue;
}
if (flags & qFLAG) {
if ((poolname = pool_get_binding(id)) == NULL) {
warn(gettext("couldn't determine binding for "
"pid %ld: %s\n"), id, get_errstr());
error = E_ERROR;
} else {
(void) printf("%ld\t%s\n", id, poolname);
free(poolname);
}
}
if (flags & QFLAG) {
uint_t j, count;
const char **resource_types;
(void) pool_resource_type_list(NULL, &count);
if ((resource_types = malloc(count *
sizeof (const char *))) == NULL) {
warn(gettext("couldn't allocate query memory "
"for pid %ld: %s\n"), id, get_errstr());
error = E_ERROR;
}
(void) pool_resource_type_list(resource_types, &count);
for (j = 0; j < count; j++)
(void) print_resource_binding(resource_types[j],
(pid_t)id);
free(resource_types);
}
}
}
static void
convert_path(const char *path, char *fname, size_t size,
struct ps_prochandle *P)
{
char *p, *s;
ssize_t len;
const psinfo_t *pip = Ppsinfo(P);
int got_uts = 0;
struct utsname uts;
char exec[PATH_MAX];
fname[size - 1] = '\0';
size--;
while ((p = strchr(path, '%')) != NULL && size != 0) {
len = MIN(size, p - path);
bcopy(path, fname, len);
fname += len;
if ((size -= len) == 0)
break;
p++;
switch (*p) {
case 'p':
len = snprintf(fname, size, "%d", (int)pip->pr_pid);
break;
case 'u':
len = snprintf(fname, size, "%d", (int)pip->pr_uid);
break;
case 'g':
len = snprintf(fname, size, "%d", (int)pip->pr_gid);
break;
case 'f':
len = snprintf(fname, size, "%s", pip->pr_fname);
break;
case 'd':
len = 0;
if (Pexecname(P, exec, sizeof (exec)) == NULL ||
exec[0] != '/' || (s = strrchr(exec, '/')) == NULL)
break;
*s = '\0';
len = snprintf(fname, size, "%s", &exec[1]);
break;
case 'n':
if (got_uts++ == 0)
(void) uname(&uts);
len = snprintf(fname, size, "%s", uts.nodename);
break;
case 'm':
if (got_uts++ == 0)
(void) uname(&uts);
len = snprintf(fname, size, "%s", uts.machine);
break;
case 't':
len = snprintf(fname, size, "%ld", (long)time(NULL));
break;
case 'z':
/*
* getzonenamebyid() returns the size including the
* terminating null byte so we need to adjust len.
*/
if ((len = getzonenamebyid(pip->pr_zoneid, fname,
size)) < 0)
len = snprintf(fname, size, "%d",
(int)pip->pr_zoneid);
else
len--;
break;
case '%':
*fname = '%';
len = 1;
break;
default:
len = snprintf(fname, size, "%%%c", *p);
}
if (len >= size)
return;
fname += len;
size -= len;
path = p + 1;
}
(void) strncpy(fname, path, size);
}
/*
* kw_init -- initialize keywords based on given filename
*/
void
kw_init(struct fn *fnp, struct fn *nfnp)
{
static char *fullpath;
static char *nfullpath;
static char *splitpath;
static char secs[MAXDIGITS];
static struct utsname un;
static char platform[SYS_NMLN];
static char isa[SYS_NMLN];
static char domain[256];
static char *home;
static char *user;
static char *logname;
static char zonename[ZONENAME_MAX];
static zoneid_t zoneid;
static int initialized;
char *ptr;
/* make a copy of the string for $file */
if (fullpath)
FREE(fullpath);
fullpath = STRDUP(fn_s(fnp));
Keywords = lut_add(Keywords, "file", fullpath);
/* make a copy of the string for $nfile */
if (nfullpath)
FREE(nfullpath);
if (nfnp == NULL) {
nfullpath = NULL;
Keywords = lut_add(Keywords, "nfile", "");
} else {
nfullpath = STRDUP(fn_s(nfnp));
Keywords = lut_add(Keywords, "nfile", nfullpath);
}
/* make a copy of the string for $dirname/$basename */
if (splitpath)
FREE(splitpath);
splitpath = STRDUP(fn_s(fnp));
if ((ptr = strrchr(splitpath, '/')) == NULL) {
Keywords = lut_add(Keywords, "basename", splitpath);
Keywords = lut_add(Keywords, "dirname", ".");
} else {
*ptr++ = '\0';
Keywords = lut_add(Keywords, "basename", ptr);
Keywords = lut_add(Keywords, "dirname", splitpath);
}
if (initialized)
return; /* rest of the keywords don't change */
(void) snprintf(secs, MAXDIGITS, "%d", (int)Now);
Keywords = lut_add(Keywords, "secs", secs);
if (uname(&un) < 0)
err(EF_SYS, "uname");
Keywords = lut_add(Keywords, "nodename", un.nodename);
Keywords = lut_add(Keywords, "release", un.release);
Keywords = lut_add(Keywords, "machine", un.machine);
if (sysinfo(SI_ARCHITECTURE, isa, sizeof (isa)) == -1)
err(EF_WARN|EF_SYS, "sysinfo(SI_ARCHITECTURE) failed.");
else
Keywords = lut_add(Keywords, "isa", isa);
if (sysinfo(SI_PLATFORM, platform, sizeof (platform)) == -1)
err(EF_WARN|EF_SYS, "sysinfo(SI_PLATFORM) failed.");
else
Keywords = lut_add(Keywords, "platform", platform);
if (sysinfo(SI_SRPC_DOMAIN, domain, sizeof (domain)) == -1)
err(EF_WARN|EF_SYS, "sysinfo(SI_SRPC_DOMAIN) failed.");
else
Keywords = lut_add(Keywords, "domain", domain);
if ((home = getenv("HOME")) != NULL)
Keywords = lut_add(Keywords, "home", STRDUP(home));
if ((user = getenv("USER")) != NULL)
Keywords = lut_add(Keywords, "user", STRDUP(user));
if ((logname = getenv("LOGNAME")) != NULL)
Keywords = lut_add(Keywords, "logname", STRDUP(logname));
zoneid = getzoneid();
if ((getzonenamebyid(zoneid, zonename, sizeof (zonename))) == -1)
err(EF_WARN|EF_SYS, "getzonenamebyid() failed.");
else
Keywords = lut_add(Keywords, "zonename", STRDUP(zonename));
initialized = 1;
}
static void
showquotas(uid_t uid, char *name)
{
struct mnttab mnt;
FILE *mtab;
struct dqblk dqblk;
uid_t myuid;
struct failed_srv {
char *serv_name;
struct failed_srv *next;
};
struct failed_srv *failed_srv_list = NULL;
int rc;
char my_zonename[ZONENAME_MAX];
zoneid_t my_zoneid = getzoneid();
myuid = getuid();
if (uid != myuid && myuid != 0) {
printf("quota: %s (uid %d): permission denied\n", name, uid);
zexit(32);
}
memset(my_zonename, '\0', ZONENAME_MAX);
getzonenamebyid(my_zoneid, my_zonename, ZONENAME_MAX);
if (vflag)
heading(uid, name);
mtab = fopen(MNTTAB, "r");
while (getmntent(mtab, &mnt) == NULL) {
if (strcmp(mnt.mnt_fstype, MNTTYPE_ZFS) == 0) {
bzero(&dqblk, sizeof (dqblk));
if (getzfsquota(name, mnt.mnt_special, &dqblk))
continue;
} else if (strcmp(mnt.mnt_fstype, MNTTYPE_UFS) == 0) {
if (nolocalquota ||
(quotactl(Q_GETQUOTA,
mnt.mnt_mountp, uid, &dqblk) != 0 &&
!(vflag && getdiskquota(&mnt, uid, &dqblk))))
continue;
} else if (strcmp(mnt.mnt_fstype, MNTTYPE_NFS) == 0) {
struct replica *rl;
int count;
char *mntopt = NULL;
/*
* Skip checking quotas for file systems mounted
* in other zones. Zone names will be passed in
* following format from hasmntopt():
* "zone=<zone-name>,<mnt options...>"
*/
if ((mntopt = hasmntopt(&mnt, MNTOPT_ZONE)) &&
(my_zonename[0] != '\0')) {
mntopt += strcspn(mntopt, "=") + 1;
if (strncmp(mntopt, my_zonename,
strcspn(mntopt, ",")) != 0)
continue;
}
if (hasopt(MNTOPT_NOQUOTA, mnt.mnt_mntopts))
continue;
/*
* Skip quota processing if mounted with public
* option. We are not likely to be able to pierce
* a fire wall to contact the quota server.
*/
if (hasopt(MNTOPT_PUBLIC, mnt.mnt_mntopts))
continue;
rl = parse_replica(mnt.mnt_special, &count);
if (rl == NULL) {
if (count < 0)
fprintf(stderr, "cannot find hostname "
"and/or pathname for %s\n",
mnt.mnt_mountp);
else
fprintf(stderr, "no memory to parse "
"mnttab entry for %s\n",
mnt.mnt_mountp);
continue;
}
/*
* We skip quota reporting on mounts with replicas
* for the following reasons:
*
* (1) Very little point in reporting quotas on
* a set of read-only replicas ... how will the
* user correct the problem?
*
* (2) Which replica would we report the quota
* for? If we pick the current replica, what
* happens when a fail over event occurs? The
* next time quota is run, the quota will look
* all different, or there won't even be one.
* This has the potential to break scripts.
*
* If we prnt quouta for all replicas, how do
* we present the output without breaking scripts?
*/
if (count > 1) {
free_replica(rl, count);
continue;
}
/*
* Skip file systems mounted using public fh.
* We are not likely to be able to pierce
* a fire wall to contact the quota server.
*/
if (strcmp(rl[0].host, "nfs") == 0 &&
strncmp(rl[0].path, "//", 2) == 0) {
free_replica(rl, count);
continue;
}
/*
* Skip getting quotas from failing servers
*/
if (failed_srv_list != NULL) {
struct failed_srv *tmp_list;
int found_failed = 0;
size_t len = strlen(rl[0].host);
tmp_list = failed_srv_list;
do {
if (strncasecmp(rl[0].host,
tmp_list->serv_name, len) == 0) {
found_failed = 1;
break;
}
} while ((tmp_list = tmp_list->next) != NULL);
if (found_failed) {
free_replica(rl, count);
continue;
}
}
rc = getnfsquota(rl[0].host, rl[0].path, uid, &dqblk);
if (rc != RPC_SUCCESS) {
size_t len;
struct failed_srv *tmp_srv;
/*
* Failed to get quota from this server. Add
* this server to failed_srv_list and skip
* getting quotas for other mounted filesystems
* from this server.
*/
if (rc == RPC_TIMEDOUT || rc == RPC_CANTSEND) {
len = strlen(rl[0].host);
tmp_srv = (struct failed_srv *)malloc(
sizeof (struct failed_srv));
tmp_srv->serv_name = (char *)malloc(
len * sizeof (char) + 1);
strncpy(tmp_srv->serv_name, rl[0].host,
len);
tmp_srv->serv_name[len] = '\0';
tmp_srv->next = failed_srv_list;
failed_srv_list = tmp_srv;
}
free_replica(rl, count);
continue;
}
free_replica(rl, count);
} else {
continue;
}
if (dqblk.dqb_bsoftlimit == 0 && dqblk.dqb_bhardlimit == 0 &&
dqblk.dqb_fsoftlimit == 0 && dqblk.dqb_fhardlimit == 0)
continue;
if (vflag)
prquota(&mnt, &dqblk);
else
warn(&mnt, &dqblk);
}
/*
* Free list of failed servers
*/
while (failed_srv_list != NULL) {
struct failed_srv *tmp_srv = failed_srv_list;
failed_srv_list = failed_srv_list->next;
free(tmp_srv->serv_name);
free(tmp_srv);
}
fclose(mtab);
}
/*
* init_env()
* A clone of the work init.c does to provide as much compatibility
* for startup scripts as possible.
*/
void
init_env()
{
int i;
char line[MAXCMDL];
FILE *fp;
int inquotes, length, wslength;
char *tokp, *cp1, *cp2;
char **newp;
glob_env_n = 16;
glob_envp = startd_alloc(sizeof (*glob_envp) * glob_env_n);
glob_envp[0] = startd_alloc((unsigned)(strlen(DEF_PATH)+2));
(void) strcpy(glob_envp[0], DEF_PATH);
if ((fp = fopen(ENVFILE, "r")) == NULL) {
uu_warn("Cannot open %s. Environment not initialized.\n",
ENVFILE);
glob_envp[1] = NULL;
return;
}
i = 1;
while (fgets(line, MAXCMDL - 1, fp) != NULL) {
/*
* Toss newline
*/
length = strlen(line);
if (line[length - 1] == '\n')
line[length - 1] = '\0';
/*
* Ignore blank or comment lines.
*/
if (line[0] == '#' || line[0] == '\0' ||
(wslength = strspn(line, " \t\n")) == strlen(line) ||
strchr(line, '#') == line + wslength)
continue;
/*
* First make a pass through the line and change
* any non-quoted semi-colons to blanks so they
* will be treated as token separators below.
*/
inquotes = 0;
for (cp1 = line; *cp1 != '\0'; cp1++) {
if (*cp1 == '"') {
if (inquotes == 0)
inquotes = 1;
else
inquotes = 0;
} else if (*cp1 == ';') {
if (inquotes == 0)
*cp1 = ' ';
}
}
/*
* Tokens within the line are separated by blanks
* and tabs. For each token in the line which
* contains a '=' we strip out any quotes and then
* stick the token in the environment array.
*/
if ((tokp = strtok(line, " \t")) == NULL)
continue;
do {
cp1 = strchr(tokp, '=');
if (cp1 == NULL || cp1 == tokp)
continue;
length = strlen(tokp);
while ((cp1 = strpbrk(tokp, "\"\'")) != NULL) {
for (cp2 = cp1; cp2 < &tokp[length]; cp2++)
*cp2 = *(cp2 + 1);
length--;
}
/*
* init already started us with this umask, and we
* handled it in startd.c, so just skip it.
*/
if (strncmp(tokp, "CMASK=", 6) == 0 ||
strncmp(tokp, "SMF_", 4) == 0)
continue;
glob_envp[i] = startd_alloc((unsigned)(length + 1));
(void) strcpy(glob_envp[i], tokp);
/*
* Double the environment size whenever it is
* full.
*/
if (++i == glob_env_n) {
glob_env_n *= 2;
newp = startd_alloc(sizeof (*glob_envp) *
glob_env_n);
(void) memcpy(newp, glob_envp,
sizeof (*glob_envp) * glob_env_n / 2);
startd_free(glob_envp,
sizeof (*glob_envp) * glob_env_n / 2);
glob_envp = newp;
}
} while ((tokp = strtok(NULL, " \t")) != NULL);
}
startd_fclose(fp);
/* Append a null pointer to the environment array to mark its end. */
glob_envp[i] = NULL;
/*
* Get the zonename once; it is used to set SMF_ZONENAME for methods.
*/
(void) getzonenamebyid(getzoneid(), zonename, sizeof (zonename));
}
