/*	pst3.c
 *
 *  Third version to get process arg info; this time by using
 *  a combination of reading the /proc/<pid>/psinfo structures
 *  and reading the complete arg vector from kernel memory structures.
 *
 *  Developed and tested under Solaris 5.8 (both 32 and 64 bit modes).
 *
 *  NOTE:  This program must be setuid-root (or run by root) to work!
 *
 *	Written: 2005-04-28	R.W.Ingraham
 */


#define _KMEMUSER	1

#include <kvm.h>
#include <sys/param.h>
#include <sys/user.h>
#include <sys/time.h>
#include <sys/proc.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <procfs.h>
#include <fcntl.h>
#include <dirent.h>
#include <errno.h>


/*
 *	Constants
 */

#define PROC_DIR	"/proc"
#define MAX_PATH	1024


/*
 *	Structures
 */


/*
 *	Globals
 */

static char *        szProg;
static kvm_t *       kd;
static struct proc * pProc;
static struct user * pUser;
static char **       myArgv;


/*
 *	Prototypes
 */

static int HandleFile (struct dirent *pDent);
static int HandlePsInfo (char *szPath, psinfo_t *pPsInfo);
static int GetArgVectors (pid_t pid);
static void ShowArgVectors (void);
static void ReleaseArgVectors();


/*----------------------------------------------------------------------------*/

int main (int argc, char **argv)
{
	DIR *pDir;
	struct dirent *pDent;
	int retcode = 0;


	/* Set our program name global */
	if ((szProg = strrchr(argv[0], '/')) != NULL)
		szProg++;
	else
		szProg = argv[0];

	/* Make sure that our euid is root */
	if (geteuid() != 0)
	{
		fprintf(stderr, "%s: This program can only be run by the root user!\n", szProg);
		exit(1);
	}

	/* Get a handle to the running kernel image */
	if ((kd = kvm_open(NULL, NULL, NULL, O_RDONLY, argv[0])) == NULL)
	{
		fprintf(stderr, "%s: Failed to open kernel memory: %s\n", szProg, strerror(errno));
		exit(2);
	}

	/* Open the /proc directory */
	if ((pDir = opendir(PROC_DIR)) != NULL)
	{
		/* Display column headings */
		printf("S   UID  PPID    VSZ    RSS %%CPU COMMAND ARGS\n");

		/* Zip through all of the process entries */
		while ((pDent = readdir(pDir)) != NULL)
		{
			/* Handle each pid sub-directory */
			HandleFile(pDent);
		}

		/* Close the directory */
		closedir(pDir);
	}
	else	/* ERROR: Failure to open PROC_DIR */
	{
		fprintf(stderr, "%s: Failed to open \"%s\": %s\n", szProg, PROC_DIR, strerror(errno));
		retcode = 3;
	}

	/* Close the handle to the running kernel image */
	kvm_close(kd);

	return retcode;
}

/*----------------------------------------------------------------------------*/

static int HandleFile (struct dirent *pDent)
{
	char szPath[MAX_PATH];
	psinfo_t sPsInfo;
	int fd, len;
	int rc = 0;

	/* Skip files beginning with a "." */
	if (pDent->d_name[0] == '.')
		return 0;

	/* Cosntruct the path to the psinfo file */
	len = sprintf(szPath, "%s/%s/psinfo", PROC_DIR, pDent->d_name);

	/* Open the psinfo file for this pid and print out its arg vectors */
	if ((fd = open(szPath, O_RDONLY)) >= 0)
	{
		/* Read the psinfo struct */
		if ((len = read(fd, &sPsInfo, sizeof(sPsInfo))) != sizeof(sPsInfo))
		{
			rc = errno;
			fprintf(stderr, "%s: Read error of psinfo structure (%d)\n", szPath, len);
			return rc;
		}

		/* Close the psinfo file */
		close(fd);

		/* Pass psinfo struct to reporting function */
		HandlePsInfo(szPath, &sPsInfo);
	}
	else if (errno != ENOENT)
	{
		rc = errno;
		fprintf(stderr, "%s: %s\n", szPath, strerror(errno));
	}

	return 0;
}

/*----------------------------------------------------------------------------*/

static int HandlePsInfo (char *szPath, psinfo_t *pPsInfo)
{
	int retcode;
	char *thisProg;

	/* Make sure that the process is still there */
	if ((retcode = GetArgVectors(pPsInfo->pr_pid)) == 0)
	{
		/* We use the program name from the kvm argv[0] instead
		 * of pr_fname from the psinfo struct because pr_fname
		 * may be truncated.
		 *
		 * Also, strip-off leading path information.
		 */
		if ((thisProg = strrchr(myArgv[0], '/')) != NULL)
			thisProg++;
		else
			thisProg = myArgv[0];
 
		/* Display the ps columns (except for argv) */
		printf("%c %5d %5d %6lu %6lu %4.1f %s ",
			pPsInfo->pr_lwp.pr_sname,
			(int)(pPsInfo->pr_euid),
			(int)(pPsInfo->pr_ppid),
			(unsigned long)(pPsInfo->pr_size),
			(unsigned long)(pPsInfo->pr_rssize),
			((float)(pPsInfo->pr_pctcpu) / 0x8000 * 100.0),
			thisProg);

		/* Display the arg vectors associated with this pid */
		ShowArgVectors();

		/* Release the arg vector buffer memory */
		ReleaseArgVectors();
	}

	return retcode;
}

/*----------------------------------------------------------------------------*/

static int GetArgVectors (pid_t pid)
{
	int retcode = 1;

	/* Get the proc structure for the specified PID */
	if ((pProc = kvm_getproc(kd, pid)) != NULL)
	{
		/* Save a copy of the process' u-area */
		if ((pUser = kvm_getu(kd, pProc)) != NULL)
		{
			/* Reconstruct the process' argv vector array */
			if (kvm_getcmd(kd, pProc, pUser, &myArgv, NULL) == 0)
			{
				retcode = 0;
			}
		}
	}

	return retcode;
}

/*----------------------------------------------------------------------------*/

static void ShowArgVectors (void)
{
	int i;

	for (i=0; myArgv[i]; i++)
	{
		printf(" %s", myArgv[i]);
	}
	printf("\n");
}

/*----------------------------------------------------------------------------*/

static void ReleaseArgVectors()
{
	/* NOOP */
}

/*----------------------------------------------------------------------------*/