/*

 *

 * U.S. Government Rights - Commercial software. Government users are subject

 * to the Sun Microsystems, Inc. standard license agreement and applicable

 * provisions of the FAR and its supplements.

 *

 *

 * This distribution may include materials developed by third parties. Sun,

 * Sun Microsystems, the Sun logo and Solaris are trademarks or registered

 * trademarks of Sun Microsystems, Inc. in the U.S. and other countries.

 *

 */

/*

 * Note: this file originally auto-generated by mib2c using

 *         : mib2c.iterate.conf,v 5.5 2002/12/16 22:50:18 hardaker Exp $

 */

#include <net-snmp/net-snmp-config.h>

#include <net-snmp/net-snmp-includes.h>

#include <net-snmp/agent/net-snmp-agent-includes.h>

#include "sunProcesses.h"

#include <stdio.h>

#include <errno.h>

#include <sys/types.h>

#include <sys/fcntl.h>

#include <sys/stat.h>

#include <sys/time.h>

#include <sys/mntent.h>

#include <sys/mnttab.h>

#include <ftw.h>

#include <stdlib.h>

#include <dirent.h>

#include <string.h>

#include <memory.h>

#include <pwd.h>

#include <syslog.h>

#include "snmpvars.h"

#include "agent.h"

#include "asn1.h"

/* The following code is borrowed from ps.c */

#define        NUID        64

#define TRUE 1

#define FALSE 0

#define NTTYS 20      /* max ttys that can be specified with the -t option  */

#define SIZ 30        /* max processes that can be specified with -p and -g */

#define ARGSIZ 30     /* size of buffer holding args for -t, -p, -u options */

#define FSTYPE_MAX 8

#ifndef MAXLOGIN

#define MAXLOGIN 8    /* max number of chars in login that will be printed */

#endif

#define UDQ 50

char *ttyname();

static char *psfile = "/tmp/mibiisa_ps_data";

static int ndev;             /* number of devices */

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

#define DNSIZE 14

static struct devl {         /* device list */

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

    dev_t  dev;           /* device number */

} *devl = NULL;

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

static int  rd_only = 0;         /* flag for remote filesystem read-only */

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

static time_t ps_cache_time = 0;

time_t cache_now = 0;

int cache_lifetime = 45;

static void call_ftw_for_dev(void);

static void wrdata();

static void write_tmp_file();

static int isprocdir();

static void get_ps_data(void);

static void clean_ps(ps_ldata_t *);

static char *get_usr_name(uid_t);

static ps_data_t *find_ps_data(pid_t pid);

static void pr_ps(void);

ps_data_t *pstable = PS_NULL;

int pstable_lines = 0;   /* # of items in memory block pointed    */

                                /* to by pstable.                        */

static void

clean_ps(ps_ldata_t *head)

{

    if (head != PS_LNULL) {

        ps_ldata_t *pdp;

        ps_ldata_t *nxt;

        for (pdp = head; pdp != PS_LNULL; pdp = nxt) {

            nxt = pdp->link;

            free(pdp);

        }

    }

}

static int

pscomp(ps_data_t *i, ps_data_t *j)

{

    return (i->pid - j->pid);

}

static struct ncache {

    uid_t uid;

    char  name[USRNM_SZ+1];

} nc[NUID];

/*

 * This function assumes that the password file is hashed

 * (or some such) to allow fast access based on a uid key.

 */

static char *

get_usr_name(uid_t uid)

{

    struct passwd *pw;

    int cp;

#if        (((NUID) & ((NUID) - 1)) != 0)

cp = uid % (NUID);

#else

cp = uid & ((NUID) - 1);

#endif

    if (uid >= 0 && nc[cp].uid == uid && nc[cp].name[0])

        return (nc[cp].name);

    pw = getpwuid(uid);

    if (!pw)

        return ((char *)0);

    nc[cp].uid = uid;

    strncpy(nc[cp].name, pw->pw_name, USRNM_SZ);

    return (nc[cp].name);

}

void

pr_ps(void)

{

    ps_data_t *psp;

    int lines;

    printf("%d entries\n", pstable_lines);

    printf("UID   PID   PPID   SZ   USR   WCHAN  TTY  CPU  CMD \n\n");

    for (psp = pstable, lines = 0; lines < pstable_lines; psp++, lines++) {

        printf("%d     %u     %u        %d    %s     %s    %s    %d   %s\n",

            psp->uid,

            psp->pid,

            psp->ppid,

            psp->sz,

            psp->usrname,

            psp->wchan,

            psp->tty,

            psp->cpu,

            psp->cmd);

    }

}

/*

 *  Locate a particular PID.

 *  Return a pointer to the entry or NULL if not found.

 */

static ps_data_t * find_ps_data(pid_t pid)

{

    ps_data_t *psp;

    ps_data_t key;

    key.pid = pid;

    /* Should add a cache here */

    psp = (ps_data_t *)bsearch((char *)&key, (char *)pstable,

                            pstable_lines, sizeof (ps_data_t),

                            (int (*)())pscomp);

    return (psp);

}

void

get_ps_data(void)

{

    ps_ldata_t *ps_last = PS_LNULL;

    ps_ldata_t *ps_head = PS_LNULL;

    ps_ldata_t *psp;

    ps_data_t  *pstp;

    static char *usrname;

    int i = 0;

    DIR *dirp;

    struct dirent *dentp;

    char pname[MAXNAMELEN];

    int pdlen;

    char *gettty();

    if (pstable != PS_NULL) {  /* Don't run ps unless we need to */

        if ((cache_now - ps_cache_time) <= cache_lifetime)

            return;

        free(pstable);

    }

    pstable_lines = 0;

    ps_cache_time = cache_now;

    /*

     * Determine root path for remote machine.

     */

    if (!readata()) {        /* get data from psfile */

        call_ftw_for_dev();

        wrdata();

    }

    /*

     * Determine which processes to print info about by searching

     * the /proc directory and looking at each process.

     */

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

        (void) SYSLOG0("Cannot open PROC directory\n");

        return;

    }

    (void) strcpy(pname, procdir);

    pdlen = strlen(pname);

    pname[pdlen++] = '/';

    /* for each active process --- */

    while (dentp = readdir(dirp)) {

        int procfd;

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

                continue;

        (void) strcpy(pname + pdlen, dentp->d_name);

retry:

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

                continue;

        /*

         * Get the info structure for the process and close quickly.

         */

            int saverr = errno;

            (void) close(procfd);

            if (saverr == EAGAIN)

                goto retry;

            if (saverr != ENOENT)

                               pname, strerror(saverr));

            continue;

        }

        (void) close(procfd);

        if ((psp = (ps_ldata_t *)malloc(sizeof (ps_ldata_t))) == PS_LNULL)

            break;

        memset((char *)psp, 0, sizeof (ps_ldata_t));

        psp->pdata.uid = info.pr_uid;

        psp->pdata.pid = info.pr_pid;

        psp->pdata.ppid = info.pr_ppid;

        psp->pdata.sz = info.pr_size;

        else

            strcpy(psp->pdata.wchan, "         ");

        memset(&psp->pdata.stat[0], 0, STAT_SZ+1);

        i = 0;

        strcpy(psp->pdata.tty, (char *)gettty(&i));

        psp->pdata.cpu = info.pr_time.tv_sec;

        strcpy(psp->pdata.cmd, info.pr_fname);

        if ((usrname = (get_usr_name(psp->pdata.uid))) != NULL)

            strncpy(psp->pdata.usrname, usrname, USRNM_SZ);

        else {

            free(psp);

            continue;

        }

        psp->pdata.usrname[USRNM_SZ] = '\0';

        pstable_lines++;

        if (ps_last == PS_LNULL)

            ps_head = psp;

        else

            ps_last->link = psp;

        ps_last = psp;

    }

    (void) closedir(dirp);

    if ((pstable = (ps_data_t *)malloc(pstable_lines

                    * sizeof (ps_data_t))) == PS_NULL) {

        clean_ps(ps_head);

        return;

    }

    for (pstp = pstable, psp = ps_head; psp != PS_LNULL;

                                    pstp++, psp = psp->link) {

        memcpy((char *)pstp, (char *)&(psp->pdata), sizeof (ps_data_t));

    }

    clean_ps(ps_head);

    qsort(pstable, pstable_lines, sizeof (ps_data_t), (int (*)())pscomp);

}

int

readata()

{

    struct stat sbuf1, sbuf2;

    int fd;

    if ((fd = open(psfile, O_RDONLY)) == -1)

        return (0);

    if (fstat(fd, &sbuf1) < 0 || sbuf1.st_size == 0 ||

        stat("/dev", &sbuf2) == -1 || sbuf1.st_mtime <= sbuf2.st_mtime ||

        sbuf1.st_mtime <= sbuf2.st_ctime) {

        if (!rd_only) {                /* if read-only, believe old data */

            (void) close(fd);

            return (0);

        }

    }

    /* Read /dev data from psfile. */

    if (read_tmp_file(fd, (char *) &ndev, sizeof (ndev)) == 0)  {

        (void) close(fd);

        return (0);

    }

    if (devl)

        free(devl);

    if ((devl = (struct devl *)malloc(ndev * sizeof (*devl))) == NULL) {

        SYSLOG1("malloc() for device table failed, %s\n", strerror(errno));

        exit(1);

    }

    if (read_tmp_file(fd, (char *)devl, ndev * sizeof (*devl)) == 0)  {

        (void) close(fd);

        return (0);

    }

    (void) close(fd);

    return (1);

}

/*

 * call_ftw_for_dev() uses ftw() to pass pathnames under /dev to gdev()

 * along with a status buffer.

 */

static void

call_ftw_for_dev(void)

{

    int gdev();

    int rcode;

    ndev = 0;

    rcode = ftw("/dev", gdev, 17);

    switch (rcode) {

    case 0:

        return;                /* successful return, devl populated */

    case 1:

        SYSLOG0(" ftw() encountered problem\n");

        break;

    case -1:

        SYSLOG1(" ftw() failed, %s\n", strerror(errno));

        break;

    default:

        SYSLOG1(" ftw() unexpected return, rcode=%d\n", rcode);

        break;

    }

    exit(1);

}

/*

 * gdev() puts device names and ID into the devl structure for character

 * special files in /dev.  The "/dev/" string is stripped from the name

 * and if the resulting pathname exceeds DNSIZE in length then the highest

 * level directory names are stripped until the pathname is DNSIZE or less.

 */

int

gdev(objptr, statp, numb)

    char        *objptr;

    struct stat *statp;

    int        numb;

{

    int i;

    int leng, start;

    static struct devl ldevl[2];

    static int lndev, consflg;

    switch (numb) {

    case FTW_F:

        if ((statp->st_mode & S_IFMT) == S_IFCHR) {

            /* Get more and be ready for syscon & systty. */

            while (ndev + lndev >= maxdev) {

                maxdev += UDQ;

                devl = (struct devl *) ((devl == NULL) ?

                            malloc(sizeof (struct devl) * maxdev) :

                            realloc(devl, sizeof (struct devl) * maxdev));

                if (devl == NULL) {

                    SYSLOG1(" not enough memory for %d devices\n", maxdev);

                    exit(1);

                }

            }

            /*

             * Save systty & syscon entries if the console

             * entry hasn't been seen.

             */

            if (!consflg && (strcmp("/dev/systty", objptr) == 0 ||

                strcmp("/dev/syscon", objptr) == 0)) {

                (void) strncpy(ldevl[lndev].dname, &objptr[5], DNSIZE);

                ldevl[lndev].dev = statp->st_rdev;

                lndev++;

                return (0);

            }

            leng = strlen(objptr);

            /* Strip off /dev/ */

            if (leng < DNSIZE + 4)

                (void) strcpy(devl[ndev].dname, &objptr[5]);

            else {

                start = leng - DNSIZE - 1;

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

                            ;

                if (i == leng)

                    (void) strncpy(devl[ndev].dname,

                                    &objptr[start], DNSIZE);

                else

                    (void) strncpy(devl[ndev].dname,

                                    &objptr[i+1], DNSIZE);

            }

            devl[ndev].dev = statp->st_rdev;

            ndev++;

            /*

             * Put systty & syscon entries in devl when console

             * is found.

             */

            if (strcmp("/dev/console", objptr) == 0) {

                consflg++;

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

                    (void) strncpy(devl[ndev].dname,

                                    ldevl[i].dname, DNSIZE);

                    devl[ndev].dev = ldevl[i].dev;

                    ndev++;

                }

                lndev = 0;

            }

        }

        return (0);

    case FTW_D:

    case FTW_DNR:

    case FTW_NS:

        return (0);

    default:

        SYSLOG1(" gdev() error, %d, encountered\n", numb);

        return (1);

    }

}

void

wrdata()

{

    char tmpname[MAXNAMELEN];

    char *tfname;

    int        fd;

    (void) umask(02);

    (void) strcpy(tmpname, "/tmp/mibiisa_ps.XXXXXX");

    if ((tfname = mktemp(tmpname)) == NULL || *tfname == '\0') {

        SYSLOG1(" mktemp(\"/tmp/mibiisa_ps.XXXXXX\") failed, %s\n",

                strerror(errno));

        return;

    }

    if ((fd = open(tfname, O_WRONLY|O_CREAT|O_EXCL, 0664)) < 0) {

        SYSLOG2(" open(\"%s\") for write failed, %s\n",

                tfname, strerror(errno));

        return;

    }

    /*

     * Make owner root, group sys.

     */

    (void) chown(tfname, (uid_t)0, (gid_t)3);

    /* write /dev data */

    write_tmp_file(fd, (char *) &ndev, sizeof (ndev));

    write_tmp_file(fd, (char *)devl, ndev * sizeof (*devl));

    (void) close(fd);

    if (rename(tfname, psfile) != 0) {

        SYSLOG2(" rename(\"%s\",\"%s\") failed\n", tfname, psfile);

        return;

    }

}

/*

 * gettty returns the user's tty number or ? if none.

 */

char *

gettty(ip)

int        *ip;        /* where the search left off last time */

{

    int        i;

    if (info.pr_ttydev != PRNODEV && *ip >= 0) {

        for (i = *ip; i < ndev; i++) {

            if (devl[i].dev == info.pr_ttydev) {

                *ip = i + 1;

                return (devl[i].dname);

            }

        }