/* $OpenBSD: display.c,v 1.50 2015/10/26 12:44:22 tedu 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.

 */

/*

 *  This file contains the routines that display information on the screen.

 *  Each section of the screen has two routines:  one for initially writing

 *  all constant and dynamic text, and one for only updating the text that

 *  changes.  The prefix "i_" is used on all the "initial" routines and the

 *  prefix "u_" is used for all the "updating" routines.

 *

 *  ASSUMPTIONS:

 *        None of the "i_" routines use any of the termcap capabilities.

 *        In this way, those routines can be safely used on terminals that

 *        have minimal (or nonexistent) terminal capabilities.

 *

 *        The routines are called in this order:  *_loadave, i_timeofday,

 *        *_procstates, *_cpustates, *_memory, *_message, *_header,

 *        *_process, u_endscreen.

 */

#include <sys/types.h>

#include <sys/sched.h>

#include <curses.h>

#include <errno.h>

#include <stdio.h>

#include <ctype.h>

#include <err.h>

#include <signal.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <sys/sysctl.h>

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

#include "layout.h"		/* defines for screen position layout */

#include "display.h"

#include "top.h"

#include "boolean.h"

#include "machine.h"		/* we should eliminate this!!! */

#include "utils.h"

#ifdef DEBUG

FILE           *debug;

#endif

static int      display_width = MAX_COLS;

static char    *cpustates_tag(int);

static int      string_count(char **);

static void     summary_format(char *, size_t, int *, char **);

static int	readlinedumb(char *, int);

#define lineindex(l) ((l)*display_width)

/* things initialized by display_init and used throughout */

/* buffer of proc information lines for display updating */

char           *screenbuf = NULL;

static char   **procstate_names;

static char   **cpustate_names;

static char   **memory_names;

static int      num_cpustates;

static int     *cpustate_columns;

static int      cpustate_total_length;

/* display ips */

int y_mem;

int y_message;

int y_header;

int y_idlecursor;

int y_procs;

extern int ncpu;

extern int combine_cpus;

extern struct process_select ps;

int header_status = Yes;

static int

empty(void)

{

}

static int

myfputs(const char *s)

{

}

static int (*addstrp)(const char *);

static int (*printwp)(const char *, ...);

static int (*standoutp)(void);

static int (*standendp)(void);

int

display_resize(void)

	int display_lines;

	/* calculate the current dimensions */

	/* if operating in "dumb" mode, we only need one line */

	/*

	 * we don't want more than MAX_COLS columns, since the

	 * machine-dependent modules make static allocations based on

	 * MAX_COLS and we don't want to run off the end of their buffers

	 */

	/* return number of lines available */

	/* for dumb terminals, pretend like we can show any amount */

}

int

display_init(struct statics * statics)

	int display_lines, *ip, i;

	char **pp;

	} else {

	}

	/* call resize to do the dirty work */

	/* only do the rest if we need to */

	/* save pointers and allocate space for names */

	/* calculate starting columns where needed */

		}

	}

	/* return number of lines available */

}

static void

format_uptime(char *buf, size_t buflen)

	time_t now, uptime;

	int days, hrs, mins;

	int mib[2];

	size_t size;

	struct timeval boottime;

	/*

	 * Print how long system has been up.

	 * (Found by getting "boottime" from the kernel)

	 */

			    days, days > 1 ? "s" : "", hrs, mins);

		else

			    hrs, mins);

	}

void

i_loadave(pid_t mpid, double *avenrun)

		int i;

		/* mpid == -1 implies this system doesn't have an _mpid */

	}

/*

 *  Display the current time.

 *  "ctime" always returns a string that looks like this:

 *

 *	Sun Sep 16 01:03:52 1973

 *      012345678901234567890123

 *	          1         2

 *

 *  We want indices 11 thru 18 (length 8).

 */

void

i_timeofday(time_t * tod)

	static char buf[30];

		} else {

		}

#ifdef DEBUG

		{

			char *foo;

			foo = ctime(tod);

			addstrp(foo);

		}

#endif

	}

/*

 *  *_procstates(total, states, threads) - print the process/thread summary line

 *

 *  Assumptions:  cursor is at the beginning of the line on entry

 */

void

i_procstates(int total, int *states, int threads)

		char procstates_buffer[MAX_COLS];

		char uptime[40];

		/* write current number of procs and remember the value */

		else

		/* format and print the process state summary */

		    states, procstate_names);

		else

	}

/*

 *  *_cpustates(states) - print the cpu state percentages

 *

 *  Assumptions:  cursor is on the PREVIOUS line

 */

/* cpustates_tag() calculates the correct tag to use to label the line */

static char *

cpustates_tag(int cpu)

		static char *tag;

		static int cpulen, old_width;

		int i;

			/* compute length of the cpu string */

				continue;

		}

				/* just store the cpu number in the tag */

			}

		} else {

			/*

			 * use a long tag if it will fit, otherwise use short one.

			 */

			else

			else

		}

	} else

}

void

i_cpustates(int64_t *ostates)

	int i, first, cpu;

	double value;

	int64_t *states;

	char **names, *thisname;

		static double *values;

		}

					/* retrieve the value and remember it */

				}

			}

		}

					/* if percentage is >= 1000, print it as 100% */

					    "%s%4.1f%% %s"), first++ == 0 ? "" : ", ",

					    value / 10., thisname);

				}

			}

		}

		return;

	}

		/* now walk thru the names and print the line */

					/* retrieve the value and remember it */

					/* if percentage is >= 1000, print it as 100% */

					    "%s%4.1f%% %s"), first++ == 0 ? "" : ", ",

					    value / 10., thisname);

				}

			}

		}

	}

}

/*

 *  *_memory(stats) - print "Memory: " followed by the memory summary string

 */

void

i_memory(int *stats)

		char memory_buffer[MAX_COLS];

		/* format and print the memory summary */

		    memory_names);

	}

/*

 *  *_message() - print the next pending message line, or erase the one

 *                that is there.

 */

/*

 *  i_message is funny because it gets its message asynchronously (with

 *	respect to screen updates).

 */

static char     next_msg[MAX_COLS + 5];

static int      msgon = 0;

void

i_message(void)

	}

/*

 *  *_header(text) - print the header for the process area

 */

void

i_header(char *text)

              || !smart_terminal)) {

		} else {

		}

	}

/*

 *  *_process(line, thisline) - print one process line

 */

void

i_process(int line, char *thisline, int hl)

	/* make sure we are on the correct line */

	/* truncate the line to conform to our current screen width */

	/* write the line out */

void

u_endscreen(void)

		/* move the cursor to a pleasant place */

	} else {

		/*

		 * separate this display from the next with some vertical

		 * room

		 */

	}

void

display_header(int status)

void

new_message(int type, const char *msgfmt,...)

	va_list ap;

	/* first, format the message */

		/* message there already -- can we clear it? */

		/* yes -- write it and clear to end */

		}

	}

void

clear_message(void)

static int

readlinedumb(char *buffer, int size)

{

	extern volatile sig_atomic_t leaveflag;

	ssize_t len;

	/* allow room for null terminator */

	/* read loop */

		}

		/* newline means we are done */

		/* handle special editing characters */

			/* return null string */

			/* erase previous character */

				/* none to erase! */

			} else {

			}

		}

		/* check for character validity and buffer overflow */

			/* not legal */

		} else {

			/* echo it and store it in the buffer */

		}

	}

	/* all done -- null terminate the string */

	/* return either inputted number or string length */

}

int

readline(char *buffer, int size)

{

	size_t cnt;

	/* allow room for null terminator */

		int y, x;

	} else

}

/* internal support routines */

static int

string_count(char **pp)

	int cnt;

}

#define	COPYLEFT(to, from)				\

	do {						\

		len = strlcpy((to), (from), left);	\

		if (len >= left)			\

			return;				\

		p += len;				\

		left -= len;				\

	} while (0)

static void

summary_format(char *buf, size_t left, int *numbers, char **names)

	char *p, *thisname;

	size_t len;

	int num;

	/* format each number followed by its string */

		/* get the number to format */

			/* is this number in kilobytes? */

				/* yes: format it as a memory value */

				/*

				 * skip over the K, since it was included by

				 * format_k

				 */

			}

		} else {

			/*

			 * Ignore negative numbers, but display corresponding

			 * string.

			 */

		}

	}

	/* if the last two characters in the string are ", ", delete them */

}

/*

 *  printable(str) - make the string pointed to by "str" into one that is

 *	printable (i.e.: all ascii), by converting all non-printable

 *	characters into '?'.  Replacements are done in place and a pointer

 *	to the original buffer is returned.

 */

char *

printable(char *str)

	char *ptr, ch;

	}

}

/*

 *  show_help() - display the help screen; invoked in response to

 *		either 'h' or '?'.

 */

void

show_help(void)

{

	}

	    "\n"

	    "^L           - redraw screen\n"

	    "<space>      - update screen\n"

	    "+            - reset any g, p, or u filters\n"

	    "1            - display CPU statistics on a single line\n"

	    "C            - toggle the display of command line arguments\n"

	    "d count      - show `count' displays, then exit\n"

	    "e            - list errors generated by last \"kill\" or \"renice\" command\n"

	    "g string     - filter on command name (g+ selects all commands)\n"

	    "h | ?        - help; show this text\n"

	    "H            - toggle the display of threads\n"

	    "I | i        - toggle the display of idle processes\n"

	    "k [-sig] pid - send signal `-sig' to process `pid'\n"

	    "n|# count    - show `count' processes\n"

	    "o field      - specify sort order (size, res, cpu, time, pri, pid, command)\n"

	    "P pid        - highlight process `pid' (P+ switches highlighting off)\n"

	    "p pid        - display process by `pid' (p+ selects all processes)\n"

	    "q            - quit\n"

	    "r count pid  - renice process `pid' to nice value `count'\n"

	    "S            - toggle the display of system processes\n"

	    "s time       - change delay between displays to `time' seconds\n"

	    "u [-]user    - show processes for `user' (u+ shows all, u -user hides user)\n"

	    "\n");

	}

}

/*

 *  show_errors() - display on stdout the current log of errors.

 */

void

show_errors(void)

{

	}

		    errp->err == 0 ? "Not a number" : strerror(errp->err));

	}

	}

}

void

anykey(void)

{

	int ch;

	ssize_t len;

	else

	while (1) {

		break;

	}

}