/* $OpenBSD: utils.c,v 1.14 2004/10/07 06:26:12 otto 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 various handy utilities used by top.
 */

#include <sys/param.h>
#include <sys/sysctl.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>

#include "top.h"
#include "machine.h"
#include "utils.h"

int
atoiwi(char *str)
{
	size_t len;

	len = strlen(str);
	if (len != 0) {
		if (strncmp(str, "infinity", len) == 0 ||
		    strncmp(str, "all", len) == 0 ||
		    strncmp(str, "maximum", len) == 0) {
			return (Infinity);
		} else if (str[0] == '-')
			return (Invalid);
		else
			return (atoi(str));
	}
	return (0);
}

/*
 * itoa - convert integer (decimal) to ascii string.
 */
char *
itoa(int val)
{
	static char buffer[16];	/* result is built here */

	/*
	 * 16 is sufficient since the largest number we will ever convert
	 * will be 2^32-1, which is 10 digits.
	 */
	(void)snprintf(buffer, sizeof(buffer), "%d", val);
	return (buffer);
}

/*
 * format_uid(uid) - like itoa, except for uid_t and the number is right
 * justified in a 6 character field to match uname_field in top.c.
 */
char *
format_uid(uid_t uid)
{
	static char buffer[16];	/* result is built here */

	/*
	 * 16 is sufficient since the largest uid we will ever convert
	 * will be 2^32-1, which is 10 digits.
	 */
	(void)snprintf(buffer, sizeof(buffer), "%6u", uid);
	return (buffer);
}

/*
 * digits(val) - return number of decimal digits in val.  Only works for
 * positive numbers.  If val <= 0 then digits(val) == 0.
 */
int
digits(int val)
{
	int cnt = 0;

	while (val > 0) {
		cnt++;
		val /= 10;
	}
	return (cnt);
}

/*
 * string_index(string, array) - find string in array and return index
 */
int
string_index(char *string, char **array)
{
	int i = 0;

	while (*array != NULL) {
		if (strcmp(string, *array) == 0)
			return (i);
		array++;
		i++;
	}
	return (-1);
}

/*
 * argparse(line, cntp) - parse arguments in string "line", separating them
 * out into an argv-like array, and setting *cntp to the number of
 * arguments encountered.  This is a simple parser that doesn't understand
 * squat about quotes.
 */
char **
argparse(char *line, int *cntp)
{
	char **argv, **argarray, *args, *from, *to;
	int cnt, ch, length, lastch;

	/*
	 * unfortunately, the only real way to do this is to go thru the
	 * input string twice.
	 */

	/* step thru the string counting the white space sections */
	from = line;
	lastch = cnt = length = 0;
	while ((ch = *from++) != '\0') {
		length++;
		if (ch == ' ' && lastch != ' ')
			cnt++;
		lastch = ch;
	}

	/*
	 * add three to the count:  one for the initial "dummy" argument, one
	 * for the last argument and one for NULL
	 */
	cnt += 3;

	/* allocate a char * array to hold the pointers */
	argarray = (char **) malloc(cnt * sizeof(char *));

	/* allocate another array to hold the strings themselves */
	args = (char *) malloc(length + 2);

	/* initialization for main loop */
	from = line;
	to = args;
	argv = argarray;
	lastch = '\0';

	/* create a dummy argument to keep getopt happy */
	*argv++ = to;
	*to++ = '\0';
	cnt = 2;

	/* now build argv while copying characters */
	*argv++ = to;
	while ((ch = *from++) != '\0') {
		if (ch != ' ') {
			if (lastch == ' ') {
				*to++ = '\0';
				*argv++ = to;
				cnt++;
			}
			*to++ = ch;
		}
		lastch = ch;
	}
	*to++ = '\0';

	/* set cntp and return the allocated array */
	*cntp = cnt;
	return (argarray);
}

/*
 * percentages(cnt, out, new, old, diffs) - calculate percentage change
 * between array "old" and "new", putting the percentages i "out".
 * "cnt" is size of each array and "diffs" is used for scratch space.
 * The array "old" is updated on each call.
 * The routine assumes modulo arithmetic.  This function is especially
 * useful on BSD mchines for calculating cpu state percentages.
 */
int
percentages(int cnt, int *out, long *new, long *old, long *diffs)
{
	long change, total_change, *dp, half_total;
	int i;

	/* initialization */
	total_change = 0;
	dp = diffs;

	/* calculate changes for each state and the overall change */
	for (i = 0; i < cnt; i++) {
		if ((change = *new - *old) < 0) {
			/* this only happens when the counter wraps */
			change = ((unsigned int)*new - (unsigned int)*old);
		}
		total_change += (*dp++ = change);
		*old++ = *new++;
	}

	/* avoid divide by zero potential */
	if (total_change == 0)
		total_change = 1;

	/* calculate percentages based on overall change, rounding up */
	half_total = total_change / 2l;
	for (i = 0; i < cnt; i++)
		*out++ = ((*diffs++ * 1000 + half_total) / total_change);

	/* return the total in case the caller wants to use it */
	return (total_change);
}

/*
 * format_time(seconds) - format number of seconds into a suitable display
 * that will fit within 6 characters.  Note that this routine builds its
 * string in a static area.  If it needs to be called more than once without
 * overwriting previous data, then we will need to adopt a technique similar
 * to the one used for format_k.
 */

/*
 * Explanation: We want to keep the output within 6 characters.  For low
 * values we use the format mm:ss.  For values that exceed 999:59, we switch
 * to a format that displays hours and fractions:  hhh.tH.  For values that
 * exceed 999.9, we use hhhh.t and drop the "H" designator.  For values that
 * exceed 9999.9, we use "???".
 */

char *
format_time(time_t seconds)
{
	static char result[10];

	/* sanity protection */
	if (seconds < 0 || seconds > (99999l * 360l)) {
		strlcpy(result, "   ???", sizeof result);
	} else if (seconds >= (1000l * 60l)) {
		/* alternate (slow) method displaying hours and tenths */
		snprintf(result, sizeof(result), "%5.1fH",
		    (double) seconds / (double) (60l * 60l));

		/*
		 * It is possible that the snprintf took more than 6
		 * characters. If so, then the "H" appears as result[6].  If
		 * not, then there is a \0 in result[6].  Either way, it is
		 * safe to step on.
		 */
		result[6] = '\0';
	} else {
		/* standard method produces MMM:SS */
		/* we avoid printf as must as possible to make this quick */
		snprintf(result, sizeof(result), "%3d:%02d", seconds / 60,
		    seconds % 60);
	}
	return (result);
}

/*
 * format_k(amt) - format a kilobyte memory value, returning a string
 * suitable for display.  Returns a pointer to a static
 * area that changes each call.  "amt" is converted to a
 * string with a trailing "K".  If "amt" is 10000 or greater,
 * then it is formatted as megabytes (rounded) with a
 * trailing "M".
 */

/*
 * Compromise time.  We need to return a string, but we don't want the
 * caller to have to worry about freeing a dynamically allocated string.
 * Unfortunately, we can't just return a pointer to a static area as one
 * of the common uses of this function is in a large call to snprintf where
 * it might get invoked several times.  Our compromise is to maintain an
 * array of strings and cycle thru them with each invocation.  We make the
 * array large enough to handle the above mentioned case.  The constant
 * NUM_STRINGS defines the number of strings in this array:  we can tolerate
 * up to NUM_STRINGS calls before we start overwriting old information.
 * Keeping NUM_STRINGS a power of two will allow an intelligent optimizer
 * to convert the modulo operation into something quicker.  What a hack!
 */

#define NUM_STRINGS 8

char *
format_k(int amt)
{
	static char retarray[NUM_STRINGS][16];
	static int  idx = 0;
	char *ret, tag = 'K';

	ret = retarray[idx];
	idx = (idx + 1) % NUM_STRINGS;

	if (amt >= 10000) {
		amt = (amt + 512) / 1024;
		tag = 'M';
		if (amt >= 10000) {
			amt = (amt + 512) / 1024;
			tag = 'G';
		}
	}
	snprintf(ret, sizeof(retarray[0]), "%d%c", amt, tag);
	return (ret);
}

int
find_pid(pid_t pid)
{
	struct kinfo_proc2 *pbase, *cur;
	int i, nproc;

	if ((pbase = getprocs(KERN_PROC_KTHREAD, 0, &nproc)) == NULL)
		quit(23);

	for (i = 0, cur = pbase; i < nproc; i++, cur++)
		if (cur->p_pid == pid)
			return 1;
	return 0;
}