#include <stdio.h>

#include <ctype.h>

#include <string.h>

#include <errno.h>

#include <fcntl.h>

#include <pwd.h>

#include <grp.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <sys/mkdev.h>

#include <unistd.h>

#include <stdlib.h>

#include <limits.h>

#include <dirent.h>

#include <sys/signal.h>

#include <sys/fault.h>

#include <sys/syscall.h>

#include <sys/time.h>

#include <procfs.h>

#include <locale.h>

#include <wctype.h>

#include <wchar.h>

#include <libw.h>

#include <stdarg.h>

#include <sys/proc.h>

#include <sys/pset.h>

#include <project.h>

#include <zone.h>

#define min(a, b) ((a) > (b) ? (b) : (a))

#define max(a, b) ((a) < (b) ? (b) : (a))

#define NTTYS 20 /* initial size of table for -t option */

#define SIZ 30 /* initial size of tables for -p, -s, -g, -h and -z */

#define ARGSIZ ZONENAME_MAX

#define MAXUGNAME 10 /* max chars in a user/group name or printed u/g id */

struct ugdata {

id_t id; /* numeric user-id or group-id */

char name[MAXUGNAME+1]; /* user/group name, null terminated */

};

struct ughead {

size_t size; /* number of ugdata structs allocated */

size_t nent; /* number of active entries */

struct ugdata *ent; /* pointer to array of actual entries */

};

enum fname { /* enumeration of field names */

F_USER, /* effective user of the process */

F_RUSER, /* real user of the process */

F_GROUP, /* effective group of the process */

F_RGROUP, /* real group of the process */

F_UID, /* numeric effective uid of the process */

F_RUID, /* numeric real uid of the process */

F_GID, /* numeric effective gid of the process */

F_RGID, /* numeric real gid of the process */

F_PID, /* process id */

F_PPID, /* parent process id */

F_PGID, /* process group id */

F_SID, /* session id */

F_PSR, /* bound processor */

F_LWP, /* lwp-id */

F_NLWP, /* number of lwps */

F_OPRI, /* old priority (obsolete) */

F_PRI, /* new priority */

F_F, /* process flags */

F_S, /* letter indicating the state */

F_C, /* processor utilization (obsolete) */

F_PCPU, /* percent of recently used cpu time */

F_PMEM, /* percent of physical memory used (rss) */

F_OSZ, /* virtual size of the process in pages */

F_VSZ, /* virtual size of the process in kilobytes */

F_RSS, /* resident set size of the process in kilobytes */

F_NICE, /* "nice" value of the process */

F_CLASS, /* scheduler class */

F_STIME, /* start time of the process, hh:mm:ss or Month Day */

F_ETIME, /* elapsed time of the process, [[dd-]hh:]mm:ss */

F_TIME, /* cpu time of the process, [[dd-]hh:]mm:ss */

F_TTY, /* name of the controlling terminal */

F_ADDR, /* address of the process (obsolete) */

F_WCHAN, /* wait channel (sleep condition variable) */

F_FNAME, /* file name of command */

F_COMM, /* name of command (argv[0] value) */

F_ARGS, /* name of command plus all its arguments */

F_TASKID, /* task id */

F_PROJID, /* project id */

F_PROJECT, /* project name of the process */

F_PSET, /* bound processor set */

F_ZONE, /* zone name */

F_ZONEID, /* zone id */

F_CTID, /* process contract id */

F_LGRP, /* process home lgroup */

F_DMODEL /* process data model */

};

struct field {

struct field *next; /* linked list */

int fname; /* field index */

const char *header; /* header to use */

int width; /* width of field */

};

static struct field *fields = NULL; /* fields selected via -o */

static struct field *last_field = NULL;

static int do_header = 0;

static struct timeval now;

struct def_field {

const char *fname;

const char *header;

int width;

int minwidth;

};

static struct def_field fname[] = {

/* fname header width minwidth */

{ "user", "USER", 8, 8 },

{ "ruser", "RUSER", 8, 8 },

{ "group", "GROUP", 8, 8 },

{ "rgroup", "RGROUP", 8, 8 },

{ "uid", "UID", 5, 5 },

{ "ruid", "RUID", 5, 5 },

{ "gid", "GID", 5, 5 },

{ "rgid", "RGID", 5, 5 },

{ "pid", "PID", 5, 5 },

{ "ppid", "PPID", 5, 5 },

{ "pgid", "PGID", 5, 5 },

{ "sid", "SID", 5, 5 },

{ "psr", "PSR", 3, 2 },

{ "lwp", "LWP", 6, 2 },

{ "nlwp", "NLWP", 4, 2 },

{ "opri", "PRI", 3, 2 },

{ "pri", "PRI", 3, 2 },

{ "f", "F", 2, 2 },

{ "s", "S", 1, 1 },

{ "c", "C", 2, 2 },

{ "pcpu", "%CPU", 4, 4 },

{ "pmem", "%MEM", 4, 4 },

{ "osz", "SZ", 4, 4 },

{ "vsz", "VSZ", 4, 4 },

{ "rss", "RSS", 4, 4 },

{ "nice", "NI", 2, 2 },

{ "class", "CLS", 4, 2 },

{ "stime", "STIME", 8, 8 },

{ "etime", "ELAPSED", 11, 7 },

{ "time", "TIME", 11, 5 },

{ "tty", "TT", 7, 7 },

#ifdef _LP64

{ "addr", "ADDR", 16, 8 },

{ "wchan", "WCHAN", 16, 8 },

#else

{ "addr", "ADDR", 8, 8 },

{ "wchan", "WCHAN", 8, 8 },

#endif

{ "fname", "COMMAND", 8, 8 },

{ "comm", "COMMAND", 80, 8 },

{ "args", "COMMAND", 80, 80 },

{ "taskid", "TASKID", 5, 5 },

{ "projid", "PROJID", 5, 5 },

{ "project", "PROJECT", 8, 8 },

{ "pset", "PSET", 3, 3 },

{ "zone", "ZONE", 8, 8 },

{ "zoneid", "ZONEID", 5, 5 },

{ "ctid", "CTID", 5, 5 },

{ "lgrp", "LGRP", 4, 2 },

{ "dmodel", "DMODEL", 6, 6 },

};

#define NFIELDS (sizeof (fname) / sizeof (fname[0]))

static int retcode = 1;

static int lflg;

static int Aflg;

static int uflg;

static int Uflg;

static int Gflg;

static int aflg;

static int dflg;

static int Lflg;

static int Pflg;

static int yflg;

static int pflg;

static int fflg;

static int cflg;

static int jflg;

static int gflg;

static int sflg;

static int tflg;

static int zflg;

static int Zflg;

static int hflg;

static int Hflg;

static uid_t tuid = (uid_t)-1;

static int errflg;

static int ndev; /* number of devices */

static int maxdev; /* number of devl structures allocated */

#define DNINCR 100

#define DNSIZE 14

static struct devl { /* device list */

char dname[DNSIZE]; /* device name */

dev_t ddev; /* device number */

} *devl;

static struct tty {

char *tname;

dev_t tdev;

} *tty = NULL; /* for t option */

static size_t ttysz = 0;

static int ntty = 0;

static pid_t *pid = NULL; /* for p option */

static size_t pidsz = 0;

static size_t npid = 0;

static int *lgrps = NULL; /* list of lgroup IDs for for h option */

static size_t lgrps_size = 0; /* size of the lgrps list */

static size_t nlgrps = 0; /* number elements in the list */

#define MAX_LGRP_ID 256

static pid_t *grpid = NULL; /* for g option */

static size_t grpidsz = 0;

static int ngrpid = 0;

static pid_t *sessid = NULL; /* for s option */

static size_t sessidsz = 0;

static int nsessid = 0;

static zoneid_t *zoneid = NULL; /* for z option */

static size_t zoneidsz = 0;

static int nzoneid = 0;

static int kbytes_per_page;

static int pidwidth;

static char *procdir = "/proc"; /* standard /proc directory */

static struct ughead euid_tbl; /* table to store selected euid's */

static struct ughead ruid_tbl; /* table to store selected real uid's */

static struct ughead egid_tbl; /* table to store selected egid's */

static struct ughead rgid_tbl; /* table to store selected real gid's */

static prheader_t *lpsinfobuf; /* buffer to contain lpsinfo */

static size_t lpbufsize;

#define PTHRESHOLD 40

#define UCB_OPTS "-aceglnrtuvwxSU"

static void usage(void);

static char *getarg(char **);

static char *parse_format(char *);

static char *gettty(psinfo_t *);

static int prfind(int, psinfo_t *, char **);

static void prcom(psinfo_t *, char *);

static void prtpct(ushort_t, int);

static void print_time(time_t, int);

static void print_field(psinfo_t *, struct field *, const char *);

static void print_zombie_field(psinfo_t *, struct field *, const char *);

static void pr_fields(psinfo_t *, const char *,

void (*print_fld)(psinfo_t *, struct field *, const char *));

static int search(pid_t *, int, pid_t);

static void add_ugentry(struct ughead *, char *);

static int uconv(struct ughead *);

static int gconv(struct ughead *);

static int ugfind(id_t, struct ughead *);

static void prtime(timestruc_t, int, int);

static void przom(psinfo_t *);

static int namencnt(char *, int, int);

static char *err_string(int);

static int print_proc(char *pname);

static time_t delta_secs(const timestruc_t *);

static int str2id(const char *, pid_t *, long, long);

static int str2uid(const char *, uid_t *, unsigned long, unsigned long);

static void *Realloc(void *, size_t);

static int pidcmp(const void *p1, const void *p2);

extern int ucbmain(int, char **);

static int stdmain(int, char **);

main(int argc, char **argv)

{

const char *me;

/*

if (argv[1] != NULL) {

if (argv[1][0] != '-')

return (ucbmain(argc, argv));

else if (argv[1][strspn(argv[1], UCB_OPTS)] != '\0')

return (stdmain(argc, argv));

}

me = getexecname();

if (me != NULL && strstr(me, "ucb") != NULL)

return (ucbmain(argc, argv));

else

return (stdmain(argc, argv));

}

static int

stdmain(int argc, char **argv)

{

char *p;

char *p1;

char *parg;

int c;

int i;

int pgerrflg = 0; /* err flg: non-numeric arg w/p & g options */

size_t size, len;

DIR *dirp;

struct dirent *dentp;

pid_t maxpid;

pid_t id;

int ret;

char loc_stime_str[32];

(void) setlocale(LC_ALL, "");

#if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */

#define TEXT_DOMAIN "SYS_TEST" /* Use this only if it weren't */

#endif

(void) textdomain(TEXT_DOMAIN);

(void) memset(&euid_tbl, 0, sizeof (euid_tbl));

(void) memset(&ruid_tbl, 0, sizeof (ruid_tbl));

(void) memset(&egid_tbl, 0, sizeof (egid_tbl));

(void) memset(&rgid_tbl, 0, sizeof (rgid_tbl));

kbytes_per_page = sysconf(_SC_PAGESIZE) / 1024;

(void) gettimeofday(&now, NULL);

/*

id = maxpid = (pid_t)sysconf(_SC_MAXPID);

pidwidth = 1;

while ((id /= 10) > 0)

++pidwidth;

pidwidth = pidwidth < 5 ? 5 : pidwidth;

fname[F_PID].width = fname[F_PPID].width = pidwidth;

fname[F_PGID].width = fname[F_SID].width = pidwidth;

/*

len = snprintf(loc_stime_str, sizeof (loc_stime_str),

dcgettext(NULL, "%8.8s", LC_TIME), "STIME");

if (len >= sizeof (loc_stime_str))

len = sizeof (loc_stime_str) - 1;

fname[F_STIME].width = fname[F_STIME].minwidth = len;

while ((c = getopt(argc, argv, "jlfceAadLPyZHh:t:p:g:u:U:G:n:s:o:z:"))

!= EOF)

switch (c) {

case 'H': /* Show home lgroups */

Hflg++;

break;

case 'h':

/*

hflg++;

p1 = optarg;

do {

int id;

/*

parg = getarg(&p1);

/* Convert string to integer */

ret = str2id(parg, (pid_t *)&id, 0,

MAX_LGRP_ID);

/* Complain if ID didn't parse correctly */

if (ret != 0) {

pgerrflg++;

(void) fprintf(stderr,

gettext("ps: %s "), parg);

if (ret == EINVAL)

(void) fprintf(stderr,

gettext("is an invalid "

"non-numeric argument"));

else

(void) fprintf(stderr,

gettext("exceeds valid "

"range"));

(void) fprintf(stderr,

gettext(" for -h option\n"));

continue;

}

/* Extend lgrps array if needed */

if (nlgrps == lgrps_size) {

/* Double the size of the lgrps array */

if (lgrps_size == 0)

lgrps_size = SIZ;

lgrps_size *= 2;

lgrps = Realloc(lgrps,

lgrps_size * sizeof (int));

}

/* place the id in the lgrps table */

lgrps[nlgrps++] = id;

} while (*p1);

break;

case 'l': /* long listing */

lflg++;

break;

case 'f': /* full listing */

fflg++;

break;

case 'j':

jflg++;

break;

case 'c':

/*

cflg++;

break;

case 'A': /* list every process */

case 'e': /* (obsolete) list every process */

Aflg++;

tflg = Gflg = Uflg = uflg = pflg = gflg = sflg = 0;

zflg = hflg = 0;

break;

case 'a':

/*

aflg++;

break;

case 'd': /* same as e except no session leaders */

dflg++;

break;

case 'L': /* show lwps */

Lflg++;

break;

case 'P': /* show bound processor */

Pflg++;

break;

case 'y': /* omit F & ADDR, report RSS & SZ in Kby */

yflg++;

break;

case 'n': /* no longer needed; retain as no-op */

(void) fprintf(stderr,

gettext("ps: warning: -n option ignored\n"));

break;

case 't': /* terminals */

#define TSZ 30

tflg++;

p1 = optarg;

do {

char nambuf[TSZ+6]; /* for "/dev/" + '\0' */

struct stat64 s;

parg = getarg(&p1);

p = Realloc(NULL, TSZ+1); /* for '\0' */

/* zero the buffer before using it */

p[0] = '\0';

size = TSZ;

if (isdigit(*parg)) {

(void) strcpy(p, "tty");

size -= 3;

}

(void) strncat(p, parg, size);

if (ntty == ttysz) {

if ((ttysz *= 2) == 0)

ttysz = NTTYS;

tty = Realloc(tty,

(ttysz + 1) * sizeof (struct tty));

}

tty[ntty].tdev = PRNODEV;

(void) strcpy(nambuf, "/dev/");

(void) strcat(nambuf, p);

if (stat64(nambuf, &s) == 0)

tty[ntty].tdev = s.st_rdev;

tty[ntty++].tname = p;

} while (*p1);

break;

case 'p': /* proc ids */

pflg++;

p1 = optarg;

do {

pid_t id;

parg = getarg(&p1);

if ((ret = str2id(parg, &id, 0, maxpid)) != 0) {

pgerrflg++;

(void) fprintf(stderr,

gettext("ps: %s "), parg);

if (ret == EINVAL)

(void) fprintf(stderr,

gettext("is an invalid "

"non-numeric argument"));

else

(void) fprintf(stderr,

gettext("exceeds valid "

"range"));

(void) fprintf(stderr,

gettext(" for -p option\n"));

continue;

}

if (npid == pidsz) {

if ((pidsz *= 2) == 0)

pidsz = SIZ;

pid = Realloc(pid,

pidsz * sizeof (pid_t));

}

pid[npid++] = id;

} while (*p1);

break;

case 's': /* session */

sflg++;

p1 = optarg;

do {

pid_t id;

parg = getarg(&p1);

if ((ret = str2id(parg, &id, 0, maxpid)) != 0) {

pgerrflg++;

(void) fprintf(stderr,

gettext("ps: %s "), parg);

if (ret == EINVAL)

(void) fprintf(stderr,

gettext("is an invalid "

"non-numeric argument"));

else

(void) fprintf(stderr,

gettext("exceeds valid "

"range"));

(void) fprintf(stderr,

gettext(" for -s option\n"));

continue;

}

if (nsessid == sessidsz) {

if ((sessidsz *= 2) == 0)

sessidsz = SIZ;

sessid = Realloc(sessid,

sessidsz * sizeof (pid_t));

}

sessid[nsessid++] = id;

} while (*p1);

break;

case 'g': /* proc group */

gflg++;

p1 = optarg;

do {

pid_t id;

parg = getarg(&p1);

if ((ret = str2id(parg, &id, 0, maxpid)) != 0) {

pgerrflg++;

(void) fprintf(stderr,

gettext("ps: %s "), parg);

if (ret == EINVAL)

(void) fprintf(stderr,

gettext("is an invalid "

"non-numeric argument"));

else

(void) fprintf(stderr,

gettext("exceeds valid "

"range"));

(void) fprintf(stderr,

gettext(" for -g option\n"));

continue;

}

if (ngrpid == grpidsz) {

if ((grpidsz *= 2) == 0)

grpidsz = SIZ;

grpid = Realloc(grpid,

grpidsz * sizeof (pid_t));

}

grpid[ngrpid++] = id;

} while (*p1);

break;

case 'u': /* effective user name or number */

uflg++;

p1 = optarg;

do {

parg = getarg(&p1);

add_ugentry(&euid_tbl, parg);

} while (*p1);

break;

case 'U': /* real user name or number */

Uflg++;

p1 = optarg;

do {

parg = getarg(&p1);

add_ugentry(&ruid_tbl, parg);

} while (*p1);

break;

case 'G': /* real group name or number */

Gflg++;

p1 = optarg;

do {

parg = getarg(&p1);

add_ugentry(&rgid_tbl, parg);

} while (*p1);

break;

case 'o': /* output format */

p = optarg;

while ((p = parse_format(p)) != NULL)

;

break;

case 'z': /* zone name or number */

zflg++;

p1 = optarg;

do {

zoneid_t id;

parg = getarg(&p1);

if (zone_get_id(parg, &id) != 0) {

pgerrflg++;

(void) fprintf(stderr,

gettext("ps: unknown zone %s\n"),

parg);

continue;

}

if (nzoneid == zoneidsz) {

if ((zoneidsz *= 2) == 0)

zoneidsz = SIZ;

zoneid = Realloc(zoneid,

zoneidsz * sizeof (zoneid_t));

}

zoneid[nzoneid++] = id;

} while (*p1);

break;

case 'Z': /* show zone name */

Zflg++;

break;

default: /* error on ? */

errflg++;

break;

}

if (errflg || optind < argc || pgerrflg)

usage();

if (tflg)

tty[ntty].tname = NULL;

/*

if (!(aflg|Aflg|dflg|Gflg|hflg|Uflg|uflg|tflg|pflg|gflg|sflg|zflg)) {

psinfo_t info;

int procfd;

char *name;

char pname[100];

/* get our own controlling tty name using /proc */

(void) snprintf(pname, sizeof (pname),

"%s/self/psinfo", procdir);

if ((procfd = open(pname, O_RDONLY)) < 0 ||

read(procfd, (char *)&info, sizeof (info)) < 0 ||

info.pr_ttydev == PRNODEV) {

(void) fprintf(stderr,

gettext("ps: no controlling terminal\n"));

exit(1);

}

(void) close(procfd);

i = 0;

name = gettty(&info);

if (*name == '?') {

(void) fprintf(stderr,

gettext("ps: can't find controlling terminal\n"));

exit(1);

}

if (ntty == ttysz) {

if ((ttysz *= 2) == 0)

ttysz = NTTYS;

tty = Realloc(tty, (ttysz + 1) * sizeof (struct tty));

}

tty[ntty].tdev = info.pr_ttydev;

tty[ntty++].tname = name;

tty[ntty].tname = NULL;

tflg++;

tuid = getuid();

}

if (Aflg) {

Gflg = Uflg = uflg = pflg = sflg = gflg = aflg = dflg = 0;

zflg = hflg = 0;

}

if (Aflg | aflg | dflg)

tflg = 0;

i = 0; /* prepare to exit on name lookup errors */

i += uconv(&euid_tbl);

i += uconv(&ruid_tbl);

i += gconv(&egid_tbl);

i += gconv(&rgid_tbl);

if (i)

exit(1);

/* allocate a buffer for lwpsinfo structures */

lpbufsize = 4096;

if (Lflg && (lpsinfobuf = malloc(lpbufsize)) == NULL) {

(void) fprintf(stderr,

gettext("ps: no memory\n"));

exit(1);

}

if (fields) { /* print user-specified header */

if (do_header) {

struct field *f;

for (f = fields; f != NULL; f = f->next) {

if (f != fields)

(void) printf(" ");

switch (f->fname) {

case F_TTY:

(void) printf("%-*s",

f->width, f->header);

break;

case F_FNAME:

case F_COMM:

case F_ARGS:

/*

if (f->next != NULL) {

(void) printf("%-*s",

f->width, f->header);

} else {

(void) printf("%s",

f->header);

}

break;

default:

(void) printf("%*s",

f->width, f->header);

break;

}

}

(void) printf("\n");

}

} else { /* print standard header */

/*

if (lflg) {

if (yflg)

(void) printf("S ");

else

(void) printf(" F S ");

}

if (Zflg)

(void) printf(" ZONE ");

if (fflg) {

(void) printf(" UID ");

} else if (lflg)

(void) printf(" UID ");

(void) printf("%*s", pidwidth, "PID");

if (lflg || fflg)

(void) printf(" %*s", pidwidth, "PPID");

if (jflg)

(void) printf(" %*s %*s", pidwidth, "PGID",

pidwidth, "SID");

if (Lflg)

(void) printf(" LWP");

if (Pflg)

(void) printf(" PSR");

if (Lflg && fflg)

(void) printf(" NLWP");

if (cflg)

(void) printf(" CLS PRI");

else if (lflg || fflg) {

(void) printf(" C");

if (lflg)

(void) printf(" PRI NI");

}

if (lflg) {

if (yflg)

(void) printf(" RSS SZ WCHAN");

else

(void) printf(" ADDR SZ WCHAN");

}

if (fflg)

(void) printf(" %s", loc_stime_str);

if (Hflg)

(void) printf(" LGRP");

if (Lflg)

(void) printf(" TTY LTIME CMD\n");

else

(void) printf(" TTY TIME CMD\n");

}

if (pflg && !(aflg|Aflg|dflg|Gflg|Uflg|uflg|hflg|tflg|gflg|sflg|zflg) &&

npid <= PTHRESHOLD) {

/*

int i;

(void) qsort(pid, npid, sizeof (pid_t), pidcmp);

for (i = 0; i < npid; i++) {

char pname[12];

if (i >= 1 && pid[i] == pid[i - 1])

continue;

(void) sprintf(pname, "%d", (int)pid[i]);

if (print_proc(pname) == 0)

retcode = 0;

}

} else {

/*

if ((dirp = opendir(procdir)) == NULL) {

(void) fprintf(stderr,

gettext("ps: cannot open PROC directory %s\n"),

procdir);

exit(1);

}

/* for each active process --- */

while (dentp = readdir(dirp)) {

if (dentp->d_name[0] == '.') /* skip . and .. */

continue;

if (print_proc(dentp->d_name) == 0)

retcode = 0;

}

(void) closedir(dirp);

}

return (retcode);

}

print_proc(char *pid_name)

{

char pname[PATH_MAX];

int pdlen;

int found;

int procfd; /* filedescriptor for /proc/nnnnn/psinfo */

char *tp; /* ptr to ttyname, if any */

psinfo_t info; /* process information from /proc */

lwpsinfo_t *lwpsinfo; /* array of lwpsinfo structs */

pdlen = snprintf(pname, sizeof (pname), "%s/%s/", procdir, pid_name);

if (pdlen >= sizeof (pname) - 10)

return (1);

retry:

(void) strcpy(&pname[pdlen], "psinfo");

if ((procfd = open(pname, O_RDONLY)) == -1) {

/* Process may have exited meanwhile. */

return (1);

}

/*

if (read(procfd, (char *)&info, sizeof (info)) < 0) {

int saverr = errno;

(void) close(procfd);

if (saverr == EAGAIN)

goto retry;

if (saverr != ENOENT)

(void) fprintf(stderr,

gettext("ps: read() on %s: %s\n"),

pname, err_string(saverr));

return (1);

}

(void) close(procfd);

found = 0;

if (info.pr_lwp.pr_state == 0) /* can't happen? */

return (1);

/*

if ((info.pr_pid == info.pr_sid) && (dflg || aflg))

return (1);

if (Aflg || dflg)

found++;

else if (pflg && search(pid, npid, info.pr_pid))

found++; /* ppid in p option arg list */

else if (uflg && ugfind((id_t)info.pr_euid, &euid_tbl))

found++; /* puid in u option arg list */

else if (Uflg && ugfind((id_t)info.pr_uid, &ruid_tbl))

found++; /* puid in U option arg list */

#ifdef NOT_YET

else if (gflg && ugfind((id_t)info.pr_egid, &egid_tbl))

found++; /* pgid in g option arg list */

#endif /* NOT_YET */

else if (Gflg && ugfind((id_t)info.pr_gid, &rgid_tbl))

found++; /* pgid in G option arg list */

else if (gflg && search(grpid, ngrpid, info.pr_pgid))

found++; /* grpid in g option arg list */

else if (sflg && search(sessid, nsessid, info.pr_sid))

found++; /* sessid in s option arg list */

else if (zflg && search(zoneid, nzoneid, info.pr_zoneid))

found++; /* zoneid in z option arg list */

else if (hflg && search((pid_t *)lgrps, nlgrps, info.pr_lwp.pr_lgrp))

found++; /* home lgroup in h option arg list */

if (!found && !tflg && !aflg)

return (1);

if (!prfind(found, &info, &tp))

return (1);

if (Lflg && (info.pr_nlwp + info.pr_nzomb) > 1) {

ssize_t prsz;

(void) strcpy(&pname[pdlen], "lpsinfo");

if ((procfd = open(pname, O_RDONLY)) == -1)

return (1);

/*

prsz = read(procfd, lpsinfobuf, lpbufsize);

if (prsz == -1) {

int saverr = errno;

(void) close(procfd);

if (saverr == EAGAIN)

goto retry;

if (saverr != ENOENT)

(void) fprintf(stderr,

gettext("ps: read() on %s: %s\n"),

pname, err_string(saverr));

return (1);

}

(void) close(procfd);

if (prsz == lpbufsize) {

/*

lpbufsize *= 2;

lpsinfobuf = Realloc(lpsinfobuf, lpbufsize);

goto retry;

}

if (lpsinfobuf->pr_nent != (info.pr_nlwp + info.pr_nzomb))

goto retry;

lwpsinfo = (lwpsinfo_t *)(lpsinfobuf + 1);

}

if (!Lflg || (info.pr_nlwp + info.pr_nzomb) <= 1) {

prcom(&info, tp);

} else {

int nlwp = 0;

do {

info.pr_lwp = *lwpsinfo;

prcom(&info, tp);

/* LINTED improper alignment */

lwpsinfo = (lwpsinfo_t *)((char *)lwpsinfo +

lpsinfobuf->pr_entsize);

} while (++nlwp < lpsinfobuf->pr_nent);

}

return (0);

}

static int

field_cmp(const void *l, const void *r)

{

struct def_field *lhs = *((struct def_field **)l);

struct def_field *rhs = *((struct def_field **)r);

return (strcmp(lhs->fname, rhs->fname));

}

static void

usage(void) /* print usage message and quit */

{

struct def_field *df, *sorted[NFIELDS];

int pos = 80, i = 0;

static char usage1[] =

"ps [ -aAdefHlcjLPyZ ] [ -o format ] [ -t termlist ]";

static char usage2[] =

"\t[ -u userlist ] [ -U userlist ] [ -G grouplist ]";

static char usage3[] =

"\t[ -p proclist ] [ -g pgrplist ] [ -s sidlist ]";

static char usage4[] =

"\t[ -z zonelist ] [-h lgrplist]";

static char usage5[] =

" 'format' is one or more of:";

(void) fprintf(stderr,

gettext("usage: %s\n%s\n%s\n%s\n%s"),

gettext(usage1), gettext(usage2), gettext(usage3),

gettext(usage4), gettext(usage5));

/*

for (df = &fname[0]; df < &fname[NFIELDS]; df++)

sorted[i++] = df;

(void) qsort(sorted, NFIELDS, sizeof (void *), field_cmp);

for (i = 0; i < NFIELDS; i++) {

if (pos + strlen((df = sorted[i])->fname) + 1 >= 80) {

(void) fprintf(stderr, "\n\t");

pos = 8;

}

(void) fprintf(stderr, "%s%s", pos > 8 ? " " : "", df->fname);

pos += strlen(df->fname) + 1;

}

(void) fprintf(stderr, "\n");

exit(1);

}

static char *

getarg(char **pp1)

{

static char argbuf[ARGSIZ];

char *p1 = *pp1;

char *parga = argbuf;

int c;

while ((c = *p1) != '\0' && (c == ',' || isspace(c)))

p1++;

while ((c = *p1) != '\0' && c != ',' && !isspace(c)) {

if (parga < argbuf + ARGSIZ - 1)

*parga++ = c;

p1++;

}

*parga = '\0';

while ((c = *p1) != '\0' && (c == ',' || isspace(c)))

p1++;

*pp1 = p1;

return (argbuf);

}

static char *

parse_format(char *arg)

{

int c;

char *name;

char *header = NULL;

int width = 0;

struct def_field *df;

struct field *f;

while ((c = *arg) != '\0' && (c == ',' || isspace(c)))

arg++;

if (c == '\0')

return (NULL);

name = arg;

arg = strpbrk(arg, " \t\r\v\f\n,=");

if (arg != NULL) {

c = *arg;

*arg++ = '\0';

if (c == '=') {

char *s;

header = arg;

arg = NULL;

width = strlen(header);

s = header + width;

while (s > header && isspace(*--s))

*s = '\0';

while (isspace(*header))

header++;

}

}

for (df = &fname[0]; df < &fname[NFIELDS]; df++)

if (strcmp(name, df->fname) == 0) {

if (strcmp(name, "lwp") == 0)

Lflg++;

break;

}

if (df >= &fname[NFIELDS]) {

(void) fprintf(stderr,

gettext("ps: unknown output format: -o %s\n"),

name);

errflg++;

return (arg);

}

if ((f = malloc(sizeof (*f))) == NULL) {

(void) fprintf(stderr,

gettext("ps: malloc() for output format failed, %s\n"),

err_string(errno));

exit(1);

}

f->next = NULL;

f->fname = df - &fname[0];

f->header = header? header : df->header;

if (width == 0)

width = df->width;

if (*f->header != '\0')

do_header = 1;

f->width = max(width, df->minwidth);

if (fields == NULL)

fields = last_field = f;

else {

last_field->next = f;

last_field = f;

}

return (arg);

}

static char *

devlookup(dev_t ddev)

{

struct devl *dp;

int i;

for (dp = devl, i = 0; i < ndev; dp++, i++) {

if (dp->ddev == ddev)

return (dp->dname);

}

return (NULL);

}

static char *

devadd(char *name, dev_t ddev)

{

struct devl *dp;

int leng, start, i;

if (ndev == maxdev) {

maxdev += DNINCR;

devl = Realloc(devl, maxdev * sizeof (struct devl));

}

dp = &devl[ndev++];

dp->ddev = ddev;

if (name == NULL) {

(void) strcpy(dp->dname, "??");

return (dp->dname);

}

leng = strlen(name);

/* Strip off /dev/ */

if (leng < DNSIZE + 4)

(void) strcpy(dp->dname, &name[5]);

else {

start = leng - DNSIZE - 1;

for (i = start; i < leng && name[i] != '/'; i++)

;

if (i == leng)

(void) strncpy(dp->dname, &name[start], DNSIZE);

else

(void) strncpy(dp->dname, &name[i+1], DNSIZE);

}

return (dp->dname);

}

static char *

gettty(psinfo_t *psinfo)

{

extern char *_ttyname_dev(dev_t, char *, size_t);

static zoneid_t zid = -1;

char devname[TTYNAME_MAX];

char *retval;

if (zid == -1)

zid = getzoneid();

if (psinfo->pr_ttydev == PRNODEV || psinfo->pr_zoneid != zid)

return ("?");

if ((retval = devlookup(psinfo->pr_ttydev)) != NULL)

return (retval);

retval = _ttyname_dev(psinfo->pr_ttydev, devname, sizeof (devname));

return (devadd(retval, psinfo->pr_ttydev));

}

static int

prfind(int found, psinfo_t *psinfo, char **tpp)

{

char *tp;

struct tty *ttyp;

if (psinfo->pr_nlwp == 0) {

/* process is a zombie */

*tpp = "?";

if (tflg && !found)

return (0);

return (1);

}

/*

tp = gettty(psinfo);

if (aflg && *tp == '?') {

*tpp = tp;

return (0);

}

if (tflg && !found) {

int match = 0;

char *other = NULL;

for (ttyp = tty; ttyp->tname != NULL; ttyp++) {

/*

if (strcmp(tp, ttyp->tname) == 0) {

match = 1;

break;

}

/*

if ((other == NULL) &&

(ttyp->tdev != PRNODEV) &&

(psinfo->pr_ttydev == ttyp->tdev))

other = ttyp->tname;

}

if (!match && (other != NULL)) {

/*

match = 1;

tp = other;

}

if (!match || (tuid != (uid_t)-1 && tuid != psinfo->pr_euid)) {

/*

*tpp = tp;

return (0);

}

}

*tpp = tp;

return (1);

}

static void

prcom(psinfo_t *psinfo, char *ttyp)

{

char *cp;

long tm;

int bytesleft;

int wcnt, length;

wchar_t wchar;

struct passwd *pwd;

int zombie_lwp;

char zonename[ZONENAME_MAX];

/*

if (psinfo->pr_nlwp == 0) {

if (fields != NULL)

pr_fields(psinfo, ttyp, print_zombie_field);

else

przom(psinfo);

return;

}

zombie_lwp = (Lflg && psinfo->pr_lwp.pr_sname == 'Z');

/*

if (fields != NULL) {

pr_fields(psinfo, ttyp, print_field);

return;

}

/*

if (lflg) {

if (!yflg)

(void) printf("%2x ", psinfo->pr_flag & 0377); /* F */

(void) printf("%c ", psinfo->pr_lwp.pr_sname); /* S */

}

if (Zflg) { /* ZONE */

if (getzonenamebyid(psinfo->pr_zoneid, zonename,

sizeof (zonename)) < 0) {

(void) printf(" %7.7d ", ((int)psinfo->pr_zoneid));

} else {

(void) printf("%8.8s ", zonename);

}

}

if (fflg) { /* UID */

if ((pwd = getpwuid(psinfo->pr_euid)) != NULL)

(void) printf("%8.8s ", pwd->pw_name);

else

(void) printf(" %7.7u ", psinfo->pr_euid);

} else if (lflg) {

(void) printf("%6u ", psinfo->pr_euid);

}

(void) printf("%*d", pidwidth, (int)psinfo->pr_pid); /* PID */

if (lflg || fflg)

(void) printf(" %*d", pidwidth,

(int)psinfo->pr_ppid); /* PPID */

if (jflg) {

(void) printf(" %*d", pidwidth,

(int)psinfo->pr_pgid); /* PGID */

(void) printf(" %*d", pidwidth,

(int)psinfo->pr_sid); /* SID */

}

if (Lflg)

(void) printf(" %5d", (int)psinfo->pr_lwp.pr_lwpid); /* LWP */

if (Pflg) {

if (psinfo->pr_lwp.pr_bindpro == PBIND_NONE) /* PSR */

(void) printf(" -");

else

(void) printf(" %3d", psinfo->pr_lwp.pr_bindpro);

}

if (Lflg && fflg) /* NLWP */

(void) printf(" %5d", psinfo->pr_nlwp + psinfo->pr_nzomb);

if (cflg) {

if (zombie_lwp) /* CLS */

(void) printf(" ");

else

(void) printf(" %4s", psinfo->pr_lwp.pr_clname);

(void) printf(" %3d", psinfo->pr_lwp.pr_pri); /* PRI */

} else if (lflg || fflg) {

(void) printf(" %3d", psinfo->pr_lwp.pr_cpu & 0377); /* C */

if (lflg) { /* PRI NI */

/*

(void) printf(" %3d", psinfo->pr_lwp.pr_oldpri);

if (psinfo->pr_lwp.pr_oldpri != 0)

(void) printf(" %2d", psinfo->pr_lwp.pr_nice);

else

(void) printf(" %2.2s",

psinfo->pr_lwp.pr_clname);

}

}

if (lflg) {

if (yflg) {

if (psinfo->pr_flag & SSYS) /* RSS */

(void) printf(" 0");

else if (psinfo->pr_rssize)

(void) printf(" %5lu",

(ulong_t)psinfo->pr_rssize);

else

(void) printf(" ?");

if (psinfo->pr_flag & SSYS) /* SZ */

(void) printf(" 0");

else if (psinfo->pr_size)

(void) printf(" %6lu",

(ulong_t)psinfo->pr_size);

else

(void) printf(" ?");

} else {

#ifndef _LP64

if (psinfo->pr_addr) /* ADDR */

(void) printf(" %8lx",

(ulong_t)psinfo->pr_addr);

else

#endif

(void) printf(" ?");

if (psinfo->pr_flag & SSYS) /* SZ */

(void) printf(" 0");

else if (psinfo->pr_size)

(void) printf(" %6lu",

(ulong_t)psinfo->pr_size / kbytes_per_page);

else

(void) printf(" ?");

}

if (psinfo->pr_lwp.pr_sname != 'S') /* WCHAN */

(void) printf(" ");

#ifndef _LP64

else if (psinfo->pr_lwp.pr_wchan)

(void) printf(" %8lx",

(ulong_t)psinfo->pr_lwp.pr_wchan);

#endif

else

(void) printf(" ?");

}

if (fflg) { /* STIME */

int width = fname[F_STIME].width;

if (Lflg)

prtime(psinfo->pr_lwp.pr_start, width + 1, 1);

else

prtime(psinfo->pr_start, width + 1, 1);

}

if (Hflg) {

/* Display home lgroup */

(void) printf(" %4d", (int)psinfo->pr_lwp.pr_lgrp);

}

(void) printf(" %-8.14s", ttyp); /* TTY */

if (Lflg) {

tm = psinfo->pr_lwp.pr_time.tv_sec;

if (psinfo->pr_lwp.pr_time.tv_nsec > 500000000)

tm++;

} else {

tm = psinfo->pr_time.tv_sec;

if (psinfo->pr_time.tv_nsec > 500000000)

tm++;

}

(void) printf(" %4ld:%.2ld", tm / 60, tm % 60); /* [L]TIME */

if (zombie_lwp) {

(void) printf(" <defunct>\n");

return;

}

if (!fflg) { /* CMD */

wcnt = namencnt(psinfo->pr_fname, 16, 8);

(void) printf(" %.*s\n", wcnt, psinfo->pr_fname);

return;

}

/*

psinfo->pr_psargs[PRARGSZ-1] = '\0';

bytesleft = PRARGSZ;

for (cp = psinfo->pr_psargs; *cp != '\0'; cp += length) {

length = mbtowc(&wchar, cp, MB_LEN_MAX);

if (length == 0)

break;

if (length < 0 || !iswprint(wchar)) {

if (length < 0)

length = 1;

if (bytesleft <= length) {

*cp = '\0';

break;

}

/* omit the unprintable character */

(void) memmove(cp, cp+length, bytesleft-length);

length = 0;

}

bytesleft -= length;

}

wcnt = namencnt(psinfo->pr_psargs, PRARGSZ, lflg ? 35 : PRARGSZ);

(void) printf(" %.*s\n", wcnt, psinfo->pr_psargs);

}

static void

prtpct(ushort_t pct, int width)

{

uint_t value = pct; /* need 32 bits to compute with */

value = ((value * 1000) + 0x7000) >> 15; /* [0 .. 1000] */

if (value >= 1000)

value = 999;

if ((width -= 2) < 2)

width = 2;

(void) printf("%*u.%u", width, value / 10, value % 10);

}

static void

print_time(time_t tim, int width)

{

char buf[30];

time_t seconds;

time_t minutes;

time_t hours;

time_t days;

if (tim < 0) {

(void) printf("%*s", width, "-");

return;

}

seconds = tim % 60;

tim /= 60;

minutes = tim % 60;

tim /= 60;

hours = tim % 24;

days = tim / 24;

if (days > 0) {

(void) snprintf(buf, sizeof (buf), "%ld-%2.2ld:%2.2ld:%2.2ld",

days, hours, minutes, seconds);

} else if (hours > 0) {

(void) snprintf(buf, sizeof (buf), "%2.2ld:%2.2ld:%2.2ld",

hours, minutes, seconds);

} else {

(void) snprintf(buf, sizeof (buf), "%2.2ld:%2.2ld",

minutes, seconds);

}

(void) printf("%*s", width, buf);

}

static void

print_field(psinfo_t *psinfo, struct field *f, const char *ttyp)

{

int width = f->width;

struct passwd *pwd;

struct group *grp;

time_t cputime;

int bytesleft;

int wcnt;

wchar_t wchar;

char *cp;

int length;

ulong_t mask;

char c, *csave;

int zombie_lwp;

zombie_lwp = (Lflg && psinfo->pr_lwp.pr_sname == 'Z');

switch (f->fname) {

case F_RUSER:

if ((pwd = getpwuid(psinfo->pr_uid)) != NULL)

(void) printf("%*s", width, pwd->pw_name);

else

(void) printf("%*u", width, psinfo->pr_uid);

break;

case F_USER:

if ((pwd = getpwuid(psinfo->pr_euid)) != NULL)

(void) printf("%*s", width, pwd->pw_name);

else

(void) printf("%*u", width, psinfo->pr_euid);

break;

case F_RGROUP:

if ((grp = getgrgid(psinfo->pr_gid)) != NULL)

(void) printf("%*s", width, grp->gr_name);

else

(void) printf("%*u", width, psinfo->pr_gid);

break;

case F_GROUP:

if ((grp = getgrgid(psinfo->pr_egid)) != NULL)

(void) printf("%*s", width, grp->gr_name);

else

(void) printf("%*u", width, psinfo->pr_egid);

break;

case F_RUID:

(void) printf("%*u", width, psinfo->pr_uid);

break;

case F_UID:

(void) printf("%*u", width, psinfo->pr_euid);

break;

case F_RGID:

(void) printf("%*u", width, psinfo->pr_gid);

break;

case F_GID:

(void) printf("%*u", width, psinfo->pr_egid);

break;

case F_PID:

(void) printf("%*d", width, (int)psinfo->pr_pid);

break;

case F_PPID:

(void) printf("%*d", width, (int)psinfo->pr_ppid);

break;

case F_PGID:

(void) printf("%*d", width, (int)psinfo->pr_pgid);

break;

case F_SID:

(void) printf("%*d", width, (int)psinfo->pr_sid);

break;

case F_PSR:

if (zombie_lwp || psinfo->pr_lwp.pr_bindpro == PBIND_NONE)

(void) printf("%*s", width, "-");

else

(void) printf("%*d", width, psinfo->pr_lwp.pr_bindpro);

break;

case F_LWP:

(void) printf("%*d", width, (int)psinfo->pr_lwp.pr_lwpid);

break;

case F_NLWP:

(void) printf("%*d", width, psinfo->pr_nlwp + psinfo->pr_nzomb);

break;

case F_OPRI:

if (zombie_lwp)

(void) printf("%*s", width, "-");

else

(void) printf("%*d", width, psinfo->pr_lwp.pr_oldpri);

break;

case F_PRI:

if (zombie_lwp)

(void) printf("%*s", width, "-");

else

(void) printf("%*d", width, psinfo->pr_lwp.pr_pri);

break;

case F_F:

mask = 0xffffffffUL;

if (width < 8)

mask >>= (8 - width) * 4;

(void) printf("%*lx", width, psinfo->pr_flag & mask);

break;

case F_S:

(void) printf("%*c", width, psinfo->pr_lwp.pr_sname);

break;

case F_C:

if (zombie_lwp)

(void) printf("%*s", width, "-");

else

(void) printf("%*d", width, psinfo->pr_lwp.pr_cpu);

break;

case F_PCPU:

if (zombie_lwp)

(void) printf("%*s", width, "-");

else if (Lflg)

prtpct(psinfo->pr_lwp.pr_pctcpu, width);

else

prtpct(psinfo->pr_pctcpu, width);

break;

case F_PMEM:

prtpct(psinfo->pr_pctmem, width);

break;

case F_OSZ:

(void) printf("%*lu", width,

(ulong_t)psinfo->pr_size / kbytes_per_page);

break;

case F_VSZ:

(void) printf("%*lu", width, (ulong_t)psinfo->pr_size);

break;

case F_RSS:

(void) printf("%*lu", width, (ulong_t)psinfo->pr_rssize);

break;

case F_NICE:

/* if pr_oldpri is zero, then this class has no nice */

if (zombie_lwp)

(void) printf("%*s", width, "-");

else if (psinfo->pr_lwp.pr_oldpri != 0)

(void) printf("%*d", width, psinfo->pr_lwp.pr_nice);

else

(void) printf("%*.*s", width, width,

psinfo->pr_lwp.pr_clname);

break;

case F_CLASS:

if (zombie_lwp)

(void) printf("%*s", width, "-");

else

(void) printf("%*.*s", width, width,

psinfo->pr_lwp.pr_clname);

break;

case F_STIME:

if (Lflg)

prtime(psinfo->pr_lwp.pr_start, width, 0);

else

prtime(psinfo->pr_start, width, 0);

break;

case F_ETIME:

if (Lflg)

print_time(delta_secs(&psinfo->pr_lwp.pr_start),

width);

else

print_time(delta_secs(&psinfo->pr_start), width);

break;

case F_TIME:

if (Lflg) {

cputime = psinfo->pr_lwp.pr_time.tv_sec;

if (psinfo->pr_lwp.pr_time.tv_nsec > 500000000)

cputime++;

} else {

cputime = psinfo->pr_time.tv_sec;

if (psinfo->pr_time.tv_nsec > 500000000)

cputime++;

}

print_time(cputime, width);

break;

case F_TTY:

(void) printf("%-*s", width, ttyp);

break;

case F_ADDR:

if (zombie_lwp)

(void) printf("%*s", width, "-");

else if (Lflg)

(void) printf("%*lx", width,

(long)psinfo->pr_lwp.pr_addr);

else

(void) printf("%*lx", width, (long)psinfo->pr_addr);

break;

case F_WCHAN:

if (!zombie_lwp && psinfo->pr_lwp.pr_wchan)

(void) printf("%*lx", width,

(long)psinfo->pr_lwp.pr_wchan);

else

(void) printf("%*.*s", width, width, "-");

break;

case F_FNAME:

/*

if (zombie_lwp) {

if (f->next != NULL)

(void) printf("%-*s", width, "<defunct>");

else

(void) printf("%s", "<defunct>");

break;

}

wcnt = namencnt(psinfo->pr_fname, 16, width);

if (f->next != NULL)

(void) printf("%-*.*s", width, wcnt, psinfo->pr_fname);

else

(void) printf("%-.*s", wcnt, psinfo->pr_fname);

break;

case F_COMM:

if (zombie_lwp) {

if (f->next != NULL)

(void) printf("%-*s", width, "<defunct>");

else

(void) printf("%s", "<defunct>");

break;

}

csave = strpbrk(psinfo->pr_psargs, " \t\r\v\f\n");

if (csave) {

c = *csave;

*csave = '\0';

}

/* FALLTHROUGH */

case F_ARGS:

/*

if (zombie_lwp) {

(void) printf("%-*s", width, "<defunct>");

break;

}

psinfo->pr_psargs[PRARGSZ-1] = '\0';

bytesleft = PRARGSZ;

for (cp = psinfo->pr_psargs; *cp != '\0'; cp += length) {

length = mbtowc(&wchar, cp, MB_LEN_MAX);

if (length == 0)

break;

if (length < 0 || !iswprint(wchar)) {

if (length < 0)

length = 1;

if (bytesleft <= length) {

*cp = '\0';

break;

}

/* omit the unprintable character */

(void) memmove(cp, cp+length, bytesleft-length);

length = 0;

}

bytesleft -= length;

}

wcnt = namencnt(psinfo->pr_psargs, PRARGSZ, width);

/*

if (f->next != NULL)

(void) printf("%-*.*s", width, wcnt,

psinfo->pr_psargs);

else

(void) printf("%-.*s", wcnt,

psinfo->pr_psargs);

if (f->fname == F_COMM && csave)

*csave = c;

break;

case F_TASKID:

(void) printf("%*d", width, (int)psinfo->pr_taskid);

break;

case F_PROJID:

(void) printf("%*d", width, (int)psinfo->pr_projid);

break;

case F_PROJECT:

{

struct project cproj;

char proj_buf[PROJECT_BUFSZ];

if ((getprojbyid(psinfo->pr_projid, &cproj,

(void *)&proj_buf, PROJECT_BUFSZ)) == NULL)

(void) printf("%*d", width,

(int)psinfo->pr_projid);

else

(void) printf("%*s", width,

(cproj.pj_name != NULL) ?

cproj.pj_name : "---");

}

break;

case F_PSET:

if (zombie_lwp || psinfo->pr_lwp.pr_bindpset == PS_NONE)

(void) printf("%*s", width, "-");

else

(void) printf("%*d", width, psinfo->pr_lwp.pr_bindpset);

break;

case F_ZONEID:

(void) printf("%*d", width, (int)psinfo->pr_zoneid);

break;

case F_ZONE:

{

char zonename[ZONENAME_MAX];

if (getzonenamebyid(psinfo->pr_zoneid, zonename,

sizeof (zonename)) < 0) {

(void) printf("%*d", width,

((int)psinfo->pr_zoneid));

} else {

(void) printf("%*s", width, zonename);

}

}

break;

case F_CTID:

if (psinfo->pr_contract == -1)

(void) printf("%*s", width, "-");

else

(void) printf("%*ld", width, (long)psinfo->pr_contract);

break;

case F_LGRP:

/* Display home lgroup */

(void) printf("%*d", width, (int)psinfo->pr_lwp.pr_lgrp);

break;

case F_DMODEL:

(void) printf("%*s", width,

psinfo->pr_dmodel == PR_MODEL_LP64 ? "_LP64" : "_ILP32");

break;

}

}

static void

print_zombie_field(psinfo_t *psinfo, struct field *f, const char *ttyp)

{

int wcnt;

int width = f->width;

switch (f->fname) {

case F_FNAME:

case F_COMM:

case F_ARGS:

/*

wcnt = min(width, sizeof ("<defunct>"));

if (f->next != NULL)

(void) printf("%-*.*s", width, wcnt, "<defunct>");

else

(void) printf("%-.*s", wcnt, "<defunct>");

break;

case F_PSR:

case F_PCPU:

case F_PMEM:

case F_NICE:

case F_CLASS:

case F_STIME:

case F_ETIME:

case F_WCHAN:

case F_PSET:

(void) printf("%*s", width, "-");

break;

case F_OPRI:

case F_PRI:

case F_OSZ:

case F_VSZ:

case F_RSS:

(void) printf("%*d", width, 0);

break;

default:

print_field(psinfo, f, ttyp);

break;

}

}

static void

pr_fields(psinfo_t *psinfo, const char *ttyp,

void (*print_fld)(psinfo_t *, struct field *, const char *))

{

struct field *f;

for (f = fields; f != NULL; f = f->next) {

print_fld(psinfo, f, ttyp);

if (f->next != NULL)

(void) printf(" ");

}

(void) printf("\n");

}

static int

search(pid_t *arr, int number, pid_t arg)

{

int i;

for (i = 0; i < number; i++)

if (arg == arr[i])

return (1);

return (0);

}

static void

add_ugentry(struct ughead *tbl, char *name)

{

struct ugdata *entp;

if (tbl->size == tbl->nent) { /* reallocate the table entries */

if ((tbl->size *= 2) == 0)

tbl->size = 32; /* first time */

tbl->ent = Realloc(tbl->ent, tbl->size*sizeof (struct ugdata));

}

entp = &tbl->ent[tbl->nent++];

entp->id = 0;

(void) strncpy(entp->name, name, MAXUGNAME);

entp->name[MAXUGNAME] = '\0';

}

static int

uconv(struct ughead *uhead)

{

struct ugdata *utbl = uhead->ent;

int n = uhead->nent;

struct passwd *pwd;

int i;

int fnd = 0;

uid_t uid;

/*

for (i = 0; i < n; i++) {

/*

if (str2uid(utbl[i].name, &uid, 0, MAXEPHUID) == 0)

pwd = getpwuid(uid);

else

pwd = getpwnam(utbl[i].name);

/*

if (pwd == NULL) {

(void) fprintf(stderr,

gettext("ps: unknown user %s\n"), utbl[i].name);

continue;

}

utbl[fnd].id = pwd->pw_uid;

(void) strncpy(utbl[fnd].name, pwd->pw_name, MAXUGNAME);

fnd++;

}

uhead->nent = fnd; /* in case it changed */

return (n - fnd);

}

static int

gconv(struct ughead *ghead)

{

struct ugdata *gtbl = ghead->ent;

int n = ghead->nent;

struct group *grp;

gid_t gid;

int i;

int fnd = 0;

/*

for (i = 0; i < n; i++) {

/*

if (str2uid(gtbl[i].name, (uid_t *)&gid, 0, MAXEPHUID) == 0)

grp = getgrgid(gid);

else

grp = getgrnam(gtbl[i].name);

/*

if (grp == NULL) {

(void) fprintf(stderr,

gettext("ps: unknown group %s\n"), gtbl[i].name);

continue;

}

gtbl[fnd].id = grp->gr_gid;

(void) strncpy(gtbl[fnd].name, grp->gr_name, MAXUGNAME);

fnd++;

}

ghead->nent = fnd; /* in case it changed */

return (n - fnd);

}

static int

ugfind(id_t id, struct ughead *ughead)

{

struct ugdata *utbl = ughead->ent;

int n = ughead->nent;

int i;

for (i = 0; i < n; i++)

if (utbl[i].id == id)

return (1);

return (0);

}

static void

prtime(timestruc_t st, int width, int old)

{

char sttim[26];

time_t starttime;

starttime = st.tv_sec;

if (st.tv_nsec > 500000000)

starttime++;

if ((now.tv_sec - starttime) >= 24*60*60) {

(void) strftime(sttim, sizeof (sttim), old?

/*

dcgettext(NULL, "%b %d", LC_TIME) :

/*

dcgettext(NULL, "%b_%d", LC_TIME), localtime(&starttime));

} else {

/*

(void) strftime(sttim, sizeof (sttim),

dcgettext(NULL, "%H:%M:%S", LC_TIME),

localtime(&starttime));

}

(void) printf("%*.*s", width, width, sttim);

}

static void

przom(psinfo_t *psinfo)

{

long tm;

struct passwd *pwd;

char zonename[ZONENAME_MAX];

/*

if (lflg) { /* F S */

if (!yflg)

(void) printf("%2x ", psinfo->pr_flag & 0377); /* F */

(void) printf("%c ", psinfo->pr_lwp.pr_sname); /* S */

}

if (Zflg) {

if (getzonenamebyid(psinfo->pr_zoneid, zonename,

sizeof (zonename)) < 0) {

(void) printf(" %7.7d ", ((int)psinfo->pr_zoneid));

} else {

(void) printf("%8.8s ", zonename);

}

}

if (Hflg) {

/* Display home lgroup */

(void) printf(" %6d", (int)psinfo->pr_lwp.pr_lgrp); /* LGRP */

}

if (fflg) {

if ((pwd = getpwuid(psinfo->pr_euid)) != NULL)

(void) printf("%8.8s ", pwd->pw_name);

else

(void) printf(" %7.7u ", psinfo->pr_euid);

} else if (lflg)

(void) printf("%6u ", psinfo->pr_euid);

(void) printf("%*d", pidwidth, (int)psinfo->pr_pid); /* PID */

if (lflg || fflg)

(void) printf(" %*d", pidwidth,

(int)psinfo->pr_ppid); /* PPID */

if (jflg) {

(void) printf(" %*d", pidwidth,

(int)psinfo->pr_pgid); /* PGID */

(void) printf(" %*d", pidwidth,

(int)psinfo->pr_sid); /* SID */

}

if (Lflg)

(void) printf(" %5d", 0); /* LWP */

if (Pflg)

(void) printf(" -"); /* PSR */

if (Lflg && fflg)

(void) printf(" %5d", 0); /* NLWP */

if (cflg) {

(void) printf(" %4s", "-"); /* zombies have no class */

(void) printf(" %3d", psinfo->pr_lwp.pr_pri); /* PRI */

} else if (lflg || fflg) {

(void) printf(" %3d", psinfo->pr_lwp.pr_cpu & 0377); /* C */

if (lflg)

(void) printf(" %3d %2s",

psinfo->pr_lwp.pr_oldpri, "-"); /* PRI NI */

}

if (lflg) {

if (yflg) /* RSS SZ WCHAN */

(void) printf(" %5d %6d %8s", 0, 0, "-");

else /* ADDR SZ WCHAN */

(void) printf(" %8s %6d %8s", "-", 0, "-");

}

if (fflg) {

int width = fname[F_STIME].width;

(void) printf(" %*.*s", width, width, "-"); /* STIME */

}

(void) printf(" %-8.14s", "?"); /* TTY */

tm = psinfo->pr_time.tv_sec;

if (psinfo->pr_time.tv_nsec > 500000000)

tm++;

(void) printf(" %4ld:%.2ld", tm / 60, tm % 60); /* TIME */

(void) printf(" <defunct>\n");

}

static int

namencnt(char *cmd, int csisize, int scrsize)

{

int csiwcnt = 0, scrwcnt = 0;

int ncsisz, nscrsz;

wchar_t wchar;

int len;

while (*cmd != '\0') {

if ((len = csisize - csiwcnt) > (int)MB_CUR_MAX)

len = MB_CUR_MAX;

if ((ncsisz = mbtowc(&wchar, cmd, len)) < 0)

return (8); /* default to use for illegal chars */

if ((nscrsz = wcwidth(wchar)) <= 0)

return (8);

if (csiwcnt + ncsisz > csisize || scrwcnt + nscrsz > scrsize)

break;

csiwcnt += ncsisz;

scrwcnt += nscrsz;

cmd += ncsisz;

}

return (csiwcnt);

}

static char *

err_string(int err)

{

static char buf[32];

char *str = strerror(err);

if (str == NULL)

(void) snprintf(str = buf, sizeof (buf), "Errno #%d", err);

return (str);

}

static void *

Realloc(void *ptr, size_t size)

{

ptr = realloc(ptr, size);

if (ptr == NULL) {

(void) fprintf(stderr, gettext("ps: no memory\n"));

exit(1);

}

return (ptr);

}

static time_t

delta_secs(const timestruc_t *start)

{

time_t seconds = now.tv_sec - start->tv_sec;

long nanosecs = now.tv_usec * 1000 - start->tv_nsec;

if (nanosecs >= (NANOSEC / 2))

seconds++;

else if (nanosecs < -(NANOSEC / 2))

seconds--;

return (seconds);

}

static int

str2id(const char *p, pid_t *val, long min, long max)

{

char *q;

long number;

int error;

errno = 0;

number = strtol(p, &q, 10);

if (errno != 0 || q == p || *q != '\0') {

if ((error = errno) == 0) {

/*

error = EINVAL;

}

} else if (number < min || number > max) {

error = ERANGE;

} else {

error = 0;

}

*val = number;

return (error);

}

static int

str2uid(const char *p, uid_t *val, unsigned long min, unsigned long max)

{

char *q;

unsigned long number;

int error;

errno = 0;

number = strtoul(p, &q, 10);

if (errno != 0 || q == p || *q != '\0') {

if ((error = errno) == 0) {

/*