/*	$OpenBSD: top.c,v 1.88 2015/11/05 17:17:13 espie Exp $	*/

/*

 *  Top users/processes display for Unix

 *  Version 3

 *

 * Copyright (c) 1984, 1989, William LeFebvre, Rice University

 * Copyright (c) 1989, 1990, 1992, William LeFebvre, Northwestern University

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR

 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.

 * IN NO EVENT SHALL THE AUTHOR OR HIS EMPLOYER BE LIABLE FOR ANY DIRECT, INDIRECT,

 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT

 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

#include <sys/types.h>

#include <curses.h>

#include <err.h>

#include <errno.h>

#include <stdio.h>

#include <signal.h>

#include <string.h>

#include <poll.h>

#include <stdlib.h>

#include <limits.h>

#include <unistd.h>

/* includes specific to top */

#include "display.h"		/* interface to display package */

#include "screen.h"		/* interface to screen package */

#include "top.h"

#include "top.local.h"

#include "boolean.h"

#include "machine.h"

#include "utils.h"

/* Size of the stdio buffer given to stdout */

#define BUFFERSIZE	2048

/* The buffer that stdio will use */

char		stdoutbuf[BUFFERSIZE];

/* signal handling routines */

static void	leave(int);

static void	onalrm(int);

static void	tstop(int);

static void	sigwinch(int);

volatile sig_atomic_t leaveflag, tstopflag, winchflag;

static void	reset_display(void);

int		rundisplay(void);

static int	max_topn;	/* maximum displayable processes */

extern int	(*proc_compares[])(const void *, const void *);

int order_index;

int displays = 0;	/* indicates unspecified */

char do_unames = Yes;

struct process_select ps;

char interactive = Maybe;

double delay = Default_DELAY;

char *order_name = NULL;

int topn = Default_TOPN;

int no_command = Yes;

int old_system = No;

int old_threads = No;

int show_args = No;

pid_t hlpid = -1;

int combine_cpus = 0;

#if Default_TOPN == Infinity

char topn_specified = No;

#endif

/*

 * these defines enumerate the "strchr"s of the commands in

 * command_chars

 */

#define CMD_redraw	0

#define CMD_update	1

#define CMD_quit	2

#define CMD_help1	3

#define CMD_help2	4

#define CMD_OSLIMIT	4	/* terminals with OS can only handle commands */

#define CMD_errors	5	/* less than or equal to CMD_OSLIMIT	   */

#define CMD_number1	6

#define CMD_number2	7

#define CMD_delay	8

#define CMD_displays	9

#define CMD_kill	10

#define CMD_renice	11

#define CMD_idletog	12

#define CMD_idletog2	13

#define CMD_user	14

#define CMD_system	15

#define CMD_order	16

#define CMD_pid		17

#define CMD_command	18

#define CMD_threads	19

#define CMD_grep	20

#define CMD_add		21

#define CMD_hl		22

#define CMD_cpus	23

static void

usage(void)

{

	extern char *__progname;

	    "usage: %s [-1bCHIinqSu] [-d count] [-g string] [-o field] "

	    "[-p pid] [-s time]\n\t[-U [-]user] [number]\n",

	    __progname);

}

static void

parseargs(int ac, char **av)

	char *endp;

	int i;

		case '1':

		case 'C':

		case 'u':	/* toggle uid/username display */

		case 'U':	/* display only username's processes */

					    optarg);

				else

				    optarg);

			else

			break;

		case 'p': {	/* display only process id */

			const char *errstr;

				    optarg);

			else {

			}

			break;

		}

		case 'S':	/* show system processes */

		case 'H':	/* show threads */

		case 'I':	/* show idle processes */

		case 'i':	/* go interactive regardless */

		case 'n':	/* batch, or non-interactive */

		case 'b':

		case 'd':	/* number of displays to show */

				break;

			}

			    "warning: display count should be positive "

			    "-- option ignored");

		case 's':

			    "warning: delay should be a non-negative number"

			    " -- using default");

		case 'q':	/* be quick about it */

			/* only allow this if user is really root */

				/* be very un-nice! */

			}

			    "warning: `-q' option can only be used by root");

		case 'o':	/* select sort order */

		case 'g':	/* grep command name */

			break;

		default:

		}

	}

	/* get count of top processes to display (if any) */

			    "warning: process count should "

			    "be a non-negative number -- using default");

		}

#if Default_TOPN == Infinity

		else

#endif

	}

struct system_info system_info;

struct statics  statics;

int

main(int argc, char *argv[])

	sigset_t mask, oldmask;

	time_t curr_time;

	caddr_t processes;

	/* set the buffer for stdout */

#ifdef DEBUG

	setvbuf(stdout, NULL, _IONBUF, 0);

#else

#endif

	/* initialize some selection options */

	/* get preset options from the environment */

		/*

		 * set the dummy argument to an explanatory message, in case

		 * getopt encounters a bad argument

		 */

	}

	/* process options */

	do {

		/*

		 * if we're done doing the presets, then process the real

		 * arguments

		 */

		}

	/* set constants for username/uid display correctly */

	}

	/* initialize the kernel memory interface */

	/* determine sorting order index, if necessary */

		    statics.order_names)) == -1) {

			char **pp, msg[512];

			    "'%s' is not a recognized sorting order",

			    order_name);

			}

		}

	}

	/* initialize termcap */

	/* initialize display interface */

	/* print warning if user requested more processes than we can display */

		    "warning: this terminal can only display %d processes",

		    max_topn);

	/* adjust for topn == Infinity */

		/*

		 *  For smart terminals, infinity really means everything that can

		 *  be displayed, or Largest.

		 *  On dumb terminals, infinity means every process in the system!

		 *  We only really want to do that if it was explicitly specified.

		 *  This is always the case when "Default_TOPN != Infinity".  But if

		 *  topn wasn't explicitly specified and we are on a dumb terminal

		 *  and the default is Infinity, then (and only then) we use

		 *  "Nominal_TOPN" instead.

		 */

#if Default_TOPN == Infinity

		    (topn_specified ? Largest : Nominal_TOPN);

#else

		topn = Largest;

#endif

	}

	/* set header display accordingly */

	/* determine interactive state */

	/* if # of displays not specified, fill it in */

	/*

	 * block interrupt signals while setting up the screen and the

	 * handlers

	 */

restart:

	/*

	 *  main loop -- repeat while display count is positive or while it

	 *		indicates infinity (by being -1)

	 */

			/*

			 * reascertain the screen

			 * dimensions

			 */

			/* tell display to resize */

			/* reset the signal handler */

		}

		/* get the current stats */

		/* get the current set of processes */

		    proc_compares[order_index]);

		/* display the load averages */

		/* display the current time */

		/* this method of getting the time SHOULD be fairly portable */

		/* display process/threads state breakdown */

		    ps.threads);

		/* display the cpu state percentage breakdown */

		/* display memory stats */

		/* handle message area */

		/* get the string to use for the process area header */

		/* update the header area */

#if Default_TOPN == Infinity

			    (topn_specified ? Largest : Nominal_TOPN);

#else

			topn = Largest;

#endif

		}

			/* determine number of processes to actually display */

			/*

			 * this number will be the smallest of:  active

			 * processes, number user requested, number current

			 * screen accommodates

			 */

			/* now show the top "n" processes. */

				pid_t pid;

				char * s;

				    &pid, ps.threads);

			}

		}

		/* do end-screen processing */

		/* now, flush the output buffer */

		/* only do the rest if we have more displays to show */

			/* switch out for new display on smart terminals */

				/* set up alarm */

				/* wait for the rest of it .... */

					/* reset the signal handler */

				}

			} else {

			}

		}

	}

	/* NOTREACHED */

}

int

rundisplay(void)

	static char tempbuf[TEMPBUFSIZE];

	sigset_t mask;

	char ch, *iptr;

	int change, i;

	struct pollfd pfd[1];

	uid_t uid, huid;

	static char command_chars[] = "\f qh?en#sdkriIuSopCHg+P1";

	/*

	 * assume valid command unless told

	 * otherwise

	 */

	/*

	 * set up arguments for select with

	 * timeout

	 */

		/* move to the lower left */

		/*

		 * default the signal handler

		 * action

		 */

		/*

		 * unblock the signal and

		 * send ourselves one

		 */

		sigemptyset(&mask);

		sigaddset(&mask, SIGTSTP);

		/* reset the signal handler */

		/* reinit screen */

	}

	/*

	 * wait for either input or the end

	 * of the delay period

	 */

		char *errmsg;

		ssize_t len;

		/*

		 * now read it and convert to

		 * command strchr

		 */

		while (1) {

			break;

		}

			/* illegal command */

		}

		case CMD_redraw:	/* redraw screen */

		case CMD_update:	/* merely update display */

			/*

			 * is the load average high?

			 */

				/* yes, go home for visual feedback */

			}

			break;

		case CMD_quit:	/* quit */

		case CMD_help1:	/* help */

		case CMD_help2:

		case CMD_errors:	/* show errors */

				    " Currently no errors to report.");

			} else {

			}

			break;

		case CMD_number1:	/* new number */

		case CMD_number2:

			    "Number of processes to show: ");

						    MT_delayed,

						    " This terminal can only "

						    "display %d processes.",

						    max_topn);

					}

					    && topn == 0) {

						/* redraw the header */

				} else {

					    "Processes should be a "

					    "non-negative number");

				}

			} else

			break;

		case CMD_delay:	/* new seconds delay */

				char *endp;

				    *endp == '\0') {

				} else {

					    "Delay should be a non-negative number");

				}

			} else

			break;

		case CMD_displays:	/* change display count */

			    "Displays to show (currently %s): ",

			    displays == -1 ? "infinite" :

			    itoa(displays));

				} else {

					    "Displays should be a non-negative number");

				}

			} else

			break;

		case CMD_kill:	/* kill program */

				}

			} else

			break;

		case CMD_renice:	/* renice program */

				}

			} else

			break;

		case CMD_idletog:

		case CMD_idletog2:

			    " %sisplaying idle processes.",

			    ps.idle ? "D" : "Not d");

			break;

		case CMD_user:

			    "Username to show: ");

				    tempbuf[1] == '\0') {

						    " %s: unknown user", tempbuf+1);

					} else {

					}

					    	    " %s: unknown user", tempbuf);

				} else {

				}

			} else

			break;

		case CMD_system:

			    " %sisplaying system processes.",

			    ps.system ? "D" : "Not d");

		case CMD_order:

			    "Order to sort: ");

				    statics.order_names)) == -1) {

					    " %s: unrecognized sorting order",

					    tempbuf);

				} else

			} else

			break;

		case CMD_pid:

				    tempbuf[1] == '\0') {

				} else {

					unsigned long long num;

					const char *errstr;

					    &errstr);

						    " %s: unknown pid",

						    tempbuf);

					} else {

					}

				}

			} else

			break;

		case CMD_command:

		case CMD_threads:

			    " %sisplaying threads.",

			    ps.threads ? "D" : "Not d");

		case CMD_grep:

			    "Grep command name: ");

				    tempbuf[1] == '\0')

				else

					    NULL)

			} else

			break;

		case CMD_hl:

				    tempbuf[1] == '\0') {

				} else {

					unsigned long long num;

					const char *errstr;

					    &errstr);

						    " %s: unknown pid",

						    tempbuf);

					} else

				}

			} else

			break;

		case CMD_add:

		case CMD_cpus:

		default:

		}

	}

	/* flush out stuff that may have been written */

}

/*

 *  reset_display() - reset all the display routine pointers so that entire

 *	screen will get redrawn.

 */

static void

reset_display(void)

{

	}

}

/* ARGSUSED */

void

leave(int signo)

{

}

/* ARGSUSED */