/* Copyright (C) 1998 Joshua Sled
   This file is part of LibGTop 1.0.

   Contributed by Joshua Sled <jsled@xcf.berkeley.edu>, July 1998.

   LibGTop is free software; you can redistribute it and/or modify it
   under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License,
   or (at your option) any later version.

   LibGTop is distributed in the hope that it will be useful, but WITHOUT
   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   for more details.

   You should have received a copy of the GNU General Public License
   along with LibGTop; see the file COPYING. If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
*/

#include <config.h>
#include <glibtop.h>
#include <glibtop/error.h>
#include <glibtop/proclist.h>
#include <glibtop/procstate.h>

#include <glibtop_suid.h>

#include <sys/types.h>
#include <sys/sysctl.h>
#include <sys/user.h>

static const unsigned long _glibtop_sysdeps_proclist =
(1L << GLIBTOP_PROCLIST_TOTAL) + (1L << GLIBTOP_PROCLIST_NUMBER) +
(1L << GLIBTOP_PROCLIST_SIZE);

/* Fetch list of currently running processes.
 * The interface of this function is a little bit different from the others:
 * buf->flags is only set if the call succeeded, in this case pids_chain,
 * a list of the pids of all currently running processes is returned,
 * buf->number is the number of elements of this list and buf->size is
 * the size of one single element (sizeof (pid_t)). The total size is
 * stored in buf->total.
 *
 * The calling function has to free the memory to which a pointer is returned.
 *
 * IMPORTANT NOTE:
 *   On error, this function MUST return NULL and set buf->flags to zero !
 *   On success, it returnes a pointer to a list of buf->number elements
 *   each buf->size big. The total size is stored in buf->total.
 * The calling function has to free the memory to which a pointer is returned.
 *
 * On error, NULL is returned and buf->flags is zero. */

/* Init function. */

void
_glibtop_init_proclist_p (glibtop *server)
{
	server->sysdeps.proclist = _glibtop_sysdeps_proclist;
}

pid_t *
glibtop_get_proclist_p (glibtop *server, glibtop_proclist *buf,
			gint64 which, gint64 arg)
{
	struct kinfo_proc *pinfo;
	GArray *pids;
	glibtop_proc_state procstate;
	size_t len;
	unsigned int i;
	pid_t prev;

	memset (buf, 0, sizeof (glibtop_proclist));

	if (sysctlbyname ("kern.proc.all", NULL, &len, NULL, 0)) {
		glibtop_warn_io_r (server, "sysctl (kern.proc.all)");
		return NULL;
	}

	pinfo = (struct kinfo_proc *) g_malloc0 (len);

	if (sysctlbyname ("kern.proc.all", pinfo, &len, NULL, 0)) {
		glibtop_warn_io_r (server, "sysctl (kern.proc.all)");
		g_free (pinfo);
		return NULL;
	}

	len /= sizeof (struct kinfo_proc);

	pids = g_array_sized_new (FALSE, FALSE, sizeof (pid_t), len);

	for (i = 0; i < len; i++) {
		pid_t pid;

		pid = (pid_t) pinfo[i].ki_pid;

		/* If a process has many threads, kern.proc.all reports multiple
		   times the same pid. So don't look twice at the same pid.
		   FIXME?: not sure that kern.proc.all reports a partially sorted
		   list (all pid/threads grouped).
		*/
		if (i > 0 && pid == prev) {
			continue;
		}

		prev = pid;

		switch (which & GLIBTOP_KERN_PROC_MASK) {
			case GLIBTOP_KERN_PROC_ALL:
				break;
			case GLIBTOP_KERN_PROC_PID:
				if ((pid_t) arg != pid)
					continue;
				break;
			case GLIBTOP_KERN_PROC_UID:
				if ((uid_t) arg != pinfo[i].ki_ruid)
					continue;
				break;
			case GLIBTOP_KERN_PROC_PGRP:
				if ((pid_t) arg != pinfo[i].ki_pgid)
					continue;
				break;
			case GLIBTOP_KERN_PROC_SESSION:
				if ((pid_t) arg != pinfo[i].ki_sid)
					continue;
				break;
			case GLIBTOP_KERN_PROC_TTY:
				if ((dev_t) arg != pinfo[i].ki_tdev)
					continue;
				break;
			case GLIBTOP_KERN_PROC_RUID:
				if ((uid_t) arg != pinfo[i].ki_ruid)
					continue;
				break;
			}

		if (which & GLIBTOP_EXCLUDE_NOTTY)
			if (pinfo[i].ki_tdev == (dev_t) -1) continue;

		if (which & GLIBTOP_EXCLUDE_IDLE) {
			glibtop_get_proc_state_p (server, &procstate, pid);
			if (procstate.flags & (1L << GLIBTOP_PROC_STATE_STATE))
				if (procstate.state != GLIBTOP_PROCESS_RUNNING) continue;

			if (pinfo[i].ki_ppid == 0 && !strcmp(pinfo[i].ki_comm, "idle"))
				continue;
		}

		if (which & GLIBTOP_EXCLUDE_SYSTEM)
			if (pinfo[i].ki_ruid == (uid_t) 0) continue;

		g_array_append_val (pids, pid);
	}

	g_free (pinfo);

	buf->flags = _glibtop_sysdeps_proclist;
	buf->size = sizeof (pid_t);
	buf->number = pids->len;
	buf->total = buf->number * buf->size;

	return (pid_t *) g_array_free (pids, FALSE);
}