[qemu.git] / cmd.c

/*
 * Copyright (c) 2003-2005 Silicon Graphics, Inc.
 * All Rights Reserved.
 *
 * This program 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.
 *
 * This program is distributed in the hope that it would 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 this program; if not, see <http://www.gnu.org/licenses/>.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
#include <sys/time.h>
#include <getopt.h>

#include "cmd.h"
#include "block/aio.h"
#include "qemu/main-loop.h"

#define _(x)	x	/* not gettext support yet */

/* from libxcmd/command.c */

cmdinfo_t	*cmdtab;
int		ncmds;

static argsfunc_t	args_func;
static checkfunc_t	check_func;
static int		ncmdline;
static char		**cmdline;

static int
compare(const void *a, const void *b)
{
	return strcmp(((const cmdinfo_t *)a)->name,
		      ((const cmdinfo_t *)b)->name);
}

void add_command(const cmdinfo_t *ci)
{
    cmdtab = g_realloc((void *)cmdtab, ++ncmds * sizeof(*cmdtab));
    cmdtab[ncmds - 1] = *ci;
    qsort(cmdtab, ncmds, sizeof(*cmdtab), compare);
}

static int
check_command(
	const cmdinfo_t	*ci)
{
	if (check_func)
		return check_func(ci);
	return 1;
}

void
add_check_command(
	checkfunc_t	cf)
{
	check_func = cf;
}

int
command_usage(
	const cmdinfo_t *ci)
{
	printf("%s %s -- %s\n", ci->name, ci->args, ci->oneline);
	return 0;
}

int
command(
	const cmdinfo_t	*ct,
	int		argc,
	char		**argv)
{
	char		*cmd = argv[0];

	if (!check_command(ct))
		return 0;

	if (argc-1 < ct->argmin || (ct->argmax != -1 && argc-1 > ct->argmax)) {
		if (ct->argmax == -1)
			fprintf(stderr,
	_("bad argument count %d to %s, expected at least %d arguments\n"),
				argc-1, cmd, ct->argmin);
		else if (ct->argmin == ct->argmax)
			fprintf(stderr,
	_("bad argument count %d to %s, expected %d arguments\n"),
				argc-1, cmd, ct->argmin);
		else
			fprintf(stderr,
	_("bad argument count %d to %s, expected between %d and %d arguments\n"),
			argc-1, cmd, ct->argmin, ct->argmax);
		return 0;
	}
	optind = 0;
	return ct->cfunc(argc, argv);
}

const cmdinfo_t *
find_command(
	const char	*cmd)
{
	cmdinfo_t	*ct;

	for (ct = cmdtab; ct < &cmdtab[ncmds]; ct++) {
		if (strcmp(ct->name, cmd) == 0 ||
		    (ct->altname && strcmp(ct->altname, cmd) == 0))
			return (const cmdinfo_t *)ct;
	}
	return NULL;
}

void add_user_command(char *optarg)
{
    cmdline = g_realloc(cmdline, ++ncmdline * sizeof(char *));
    cmdline[ncmdline-1] = optarg;
}

static int
args_command(
	int	index)
{
	if (args_func)
		return args_func(index);
	return 0;
}

void
add_args_command(
	argsfunc_t	af)
{
	args_func = af;
}

static void prep_fetchline(void *opaque)
{
    int *fetchable = opaque;

    qemu_set_fd_handler(STDIN_FILENO, NULL, NULL, NULL);
    *fetchable= 1;
}

static char *get_prompt(void);

void command_loop(void)
{
    int c, i, j = 0, done = 0, fetchable = 0, prompted = 0;
    char *input;
    char **v;
    const cmdinfo_t *ct;

    for (i = 0; !done && i < ncmdline; i++) {
        input = strdup(cmdline[i]);
        if (!input) {
            fprintf(stderr, _("cannot strdup command '%s': %s\n"),
                    cmdline[i], strerror(errno));
            exit(1);
        }
        v = breakline(input, &c);
        if (c) {
            ct = find_command(v[0]);
            if (ct) {
                if (ct->flags & CMD_FLAG_GLOBAL) {
                    done = command(ct, c, v);
                } else {
                    j = 0;
                    while (!done && (j = args_command(j))) {
                        done = command(ct, c, v);
                    }
                }
            } else {
                fprintf(stderr, _("command \"%s\" not found\n"), v[0]);
            }
	}
        doneline(input, v);
    }
    if (cmdline) {
        g_free(cmdline);
        return;
    }

    while (!done) {
        if (!prompted) {
            printf("%s", get_prompt());
            fflush(stdout);
            qemu_set_fd_handler(STDIN_FILENO, prep_fetchline, NULL, &fetchable);
            prompted = 1;
        }

        main_loop_wait(false);

        if (!fetchable) {
            continue;
        }
        input = fetchline();
        if (input == NULL) {
            break;
        }
        v = breakline(input, &c);
        if (c) {
            ct = find_command(v[0]);
            if (ct) {
                done = command(ct, c, v);
            } else {
                fprintf(stderr, _("command \"%s\" not found\n"), v[0]);
            }
        }
        doneline(input, v);

        prompted = 0;
        fetchable = 0;
    }
    qemu_set_fd_handler(STDIN_FILENO, NULL, NULL, NULL);
}

/* from libxcmd/input.c */

#if defined(ENABLE_READLINE)
# include <readline/history.h>
# include <readline/readline.h>
#elif defined(ENABLE_EDITLINE)
# include <histedit.h>
#endif

static char *
get_prompt(void)
{
	static char	prompt[FILENAME_MAX + 2 /*"> "*/ + 1 /*"\0"*/ ];

	if (!prompt[0])
		snprintf(prompt, sizeof(prompt), "%s> ", progname);
	return prompt;
}

#if defined(ENABLE_READLINE)
char *
fetchline(void)
{
	char	*line;

	line = readline(get_prompt());
	if (line && *line)
		add_history(line);
	return line;
}
#elif defined(ENABLE_EDITLINE)
static char *el_get_prompt(EditLine *e) { return get_prompt(); }
char *
fetchline(void)
{
	static EditLine	*el;
	static History	*hist;
	HistEvent	hevent;
	char		*line;
	int		count;

	if (!el) {
		hist = history_init();
		history(hist, &hevent, H_SETSIZE, 100);
		el = el_init(progname, stdin, stdout, stderr);
		el_source(el, NULL);
		el_set(el, EL_SIGNAL, 1);
		el_set(el, EL_PROMPT, el_get_prompt);
		el_set(el, EL_HIST, history, (const char *)hist);
	}
	line = strdup(el_gets(el, &count));
	if (line) {
		if (count > 0)
			line[count-1] = '\0';
		if (*line)
			history(hist, &hevent, H_ENTER, line);
	}
	return line;
}
#else
# define MAXREADLINESZ	1024
char *
fetchline(void)
{
	char	*p, *line = malloc(MAXREADLINESZ);

	if (!line)
		return NULL;
	if (!fgets(line, MAXREADLINESZ, stdin)) {
		free(line);
		return NULL;
	}
	p = line + strlen(line);
	if (p != line && p[-1] == '\n')
		p[-1] = '\0';
	return line;
}
#endif

static char *qemu_strsep(char **input, const char *delim)
{
    char *result = *input;
    if (result != NULL) {
        char *p;

        for (p = result; *p != '\0'; p++) {
            if (strchr(delim, *p)) {
                break;
            }
        }
        if (*p == '\0') {
            *input = NULL;
        } else {
            *p = '\0';
            *input = p + 1;
        }
    }
    return result;
}

char **breakline(char *input, int *count)
{
    int c = 0;
    char *p;
    char **rval = calloc(sizeof(char *), 1);
    char **tmp;

    while (rval && (p = qemu_strsep(&input, " ")) != NULL) {
        if (!*p) {
            continue;
        }
        c++;
        tmp = realloc(rval, sizeof(*rval) * (c + 1));
        if (!tmp) {
            free(rval);
            rval = NULL;
            c = 0;
            break;
        } else {
            rval = tmp;
        }
        rval[c - 1] = p;
        rval[c] = NULL;
    }
    *count = c;
    return rval;
}

void
doneline(
	char	*input,
	char	**vec)
{
	free(input);
	free(vec);
}

#define EXABYTES(x)	((long long)(x) << 60)
#define PETABYTES(x)	((long long)(x) << 50)
#define TERABYTES(x)	((long long)(x) << 40)
#define GIGABYTES(x)	((long long)(x) << 30)
#define MEGABYTES(x)	((long long)(x) << 20)
#define KILOBYTES(x)	((long long)(x) << 10)

long long
cvtnum(
	char		*s)
{
	long long	i;
	char		*sp;
	int		c;

	i = strtoll(s, &sp, 0);
	if (i == 0 && sp == s)
		return -1LL;
	if (*sp == '\0')
		return i;

	if (sp[1] != '\0')
		return -1LL;

	c = qemu_tolower(*sp);
	switch (c) {
	default:
		return i;
	case 'k':
		return KILOBYTES(i);
	case 'm':
		return MEGABYTES(i);
	case 'g':
		return GIGABYTES(i);
	case 't':
		return TERABYTES(i);
	case 'p':
		return PETABYTES(i);
	case 'e':
		return  EXABYTES(i);
	}
	return -1LL;
}

#define TO_EXABYTES(x)	((x) / EXABYTES(1))
#define TO_PETABYTES(x)	((x) / PETABYTES(1))
#define TO_TERABYTES(x)	((x) / TERABYTES(1))
#define TO_GIGABYTES(x)	((x) / GIGABYTES(1))
#define TO_MEGABYTES(x)	((x) / MEGABYTES(1))
#define TO_KILOBYTES(x)	((x) / KILOBYTES(1))

void
cvtstr(
	double		value,
	char		*str,
	size_t		size)
{
	char		*trim;
	const char	*suffix;

	if (value >= EXABYTES(1)) {
		suffix = " EiB";
		snprintf(str, size - 4, "%.3f", TO_EXABYTES(value));
	} else if (value >= PETABYTES(1)) {
		suffix = " PiB";
		snprintf(str, size - 4, "%.3f", TO_PETABYTES(value));
	} else if (value >= TERABYTES(1)) {
		suffix = " TiB";
		snprintf(str, size - 4, "%.3f", TO_TERABYTES(value));
	} else if (value >= GIGABYTES(1)) {
		suffix = " GiB";
		snprintf(str, size - 4, "%.3f", TO_GIGABYTES(value));
	} else if (value >= MEGABYTES(1)) {
		suffix = " MiB";
		snprintf(str, size - 4, "%.3f", TO_MEGABYTES(value));
	} else if (value >= KILOBYTES(1)) {
		suffix = " KiB";
		snprintf(str, size - 4, "%.3f", TO_KILOBYTES(value));
	} else {
		suffix = " bytes";
		snprintf(str, size - 6, "%f", value);
	}

	trim = strstr(str, ".000");
	if (trim) {
		strcpy(trim, suffix);
	} else {
		strcat(str, suffix);
	}
}

struct timeval
tsub(struct timeval t1, struct timeval t2)
{
	t1.tv_usec -= t2.tv_usec;
	if (t1.tv_usec < 0) {
		t1.tv_usec += 1000000;
		t1.tv_sec--;
	}
	t1.tv_sec -= t2.tv_sec;
	return t1;
}

double
tdiv(double value, struct timeval tv)
{
	return value / ((double)tv.tv_sec + ((double)tv.tv_usec / 1000000.0));
}

#define HOURS(sec)	((sec) / (60 * 60))
#define MINUTES(sec)	(((sec) % (60 * 60)) / 60)
#define SECONDS(sec)	((sec) % 60)

void
timestr(
	struct timeval	*tv,
	char		*ts,
	size_t		size,
	int		format)
{
	double		usec = (double)tv->tv_usec / 1000000.0;

	if (format & TERSE_FIXED_TIME) {
		if (!HOURS(tv->tv_sec)) {
			snprintf(ts, size, "%u:%02u.%02u",
				(unsigned int) MINUTES(tv->tv_sec),
				(unsigned int) SECONDS(tv->tv_sec),
				(unsigned int) (usec * 100));
			return;
		}
		format |= VERBOSE_FIXED_TIME;	/* fallback if hours needed */
	}

	if ((format & VERBOSE_FIXED_TIME) || tv->tv_sec) {
		snprintf(ts, size, "%u:%02u:%02u.%02u",
			(unsigned int) HOURS(tv->tv_sec),
			(unsigned int) MINUTES(tv->tv_sec),
			(unsigned int) SECONDS(tv->tv_sec),
			(unsigned int) (usec * 100));
	} else {
		snprintf(ts, size, "0.%04u sec", (unsigned int) (usec * 10000));
	}
}


/* from libxcmd/quit.c */

static cmdinfo_t quit_cmd;

/* ARGSUSED */
static int
quit_f(
	int	argc,
	char	**argv)
{
	return 1;
}

void
quit_init(void)
{
	quit_cmd.name = _("quit");
	quit_cmd.altname = _("q");
	quit_cmd.cfunc = quit_f;
	quit_cmd.argmin = -1;
	quit_cmd.argmax = -1;
	quit_cmd.flags = CMD_FLAG_GLOBAL;
	quit_cmd.oneline = _("exit the program");

	add_command(&quit_cmd);
}

/* from libxcmd/help.c */

static cmdinfo_t help_cmd;
static void help_onecmd(const char *cmd, const cmdinfo_t *ct);
static void help_oneline(const char *cmd, const cmdinfo_t *ct);

static void
help_all(void)
{
	const cmdinfo_t	*ct;

	for (ct = cmdtab; ct < &cmdtab[ncmds]; ct++)
		help_oneline(ct->name, ct);
	printf(_("\nUse 'help commandname' for extended help.\n"));
}

static int
help_f(
	int		argc,
	char		**argv)
{
	const cmdinfo_t	*ct;

	if (argc == 1) {
		help_all();
		return 0;
	}
	ct = find_command(argv[1]);
	if (ct == NULL) {
		printf(_("command %s not found\n"), argv[1]);
		return 0;
	}
	help_onecmd(argv[1], ct);
	return 0;
}

static void
help_onecmd(
	const char	*cmd,
	const cmdinfo_t	*ct)
{
	help_oneline(cmd, ct);
	if (ct->help)
		ct->help();
}

static void
help_oneline(
	const char	*cmd,
	const cmdinfo_t	*ct)
{
	if (cmd)
		printf("%s ", cmd);
	else {
		printf("%s ", ct->name);
		if (ct->altname)
			printf("(or %s) ", ct->altname);
	}
	if (ct->args)
		printf("%s ", ct->args);
	printf("-- %s\n", ct->oneline);
}

void
help_init(void)
{
	help_cmd.name = _("help");
	help_cmd.altname = _("?");
	help_cmd.cfunc = help_f;
	help_cmd.argmin = 0;
	help_cmd.argmax = 1;
	help_cmd.flags = CMD_FLAG_GLOBAL;
	help_cmd.args = _("[command]");
	help_cmd.oneline = _("help for one or all commands");

	add_command(&help_cmd);
}
Commit	Line	Data
e3aff4f6 AL	1	/*
	2	* Copyright (c) 2003-2005 Silicon Graphics, Inc.
	3	* All Rights Reserved.
	4	*
	5	* This program is free software; you can redistribute it and/or
	6	* modify it under the terms of the GNU General Public License as
	7	* published by the Free Software Foundation.
	8	*
	9	* This program is distributed in the hope that it would be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	* GNU General Public License for more details.
	13	*
	14	* You should have received a copy of the GNU General Public License
8167ee88	15	* along with this program; if not, see <http://www.gnu.org/licenses/>.
e3aff4f6 AL	16	*/
	17
	18	#include <stdio.h>
	19	#include <stdlib.h>
	20	#include <string.h>
	21	#include <ctype.h>
	22	#include <errno.h>
c32d766a	23	#include <sys/time.h>
22a2bdcb	24	#include <getopt.h>
e3aff4f6 AL	25
e3aff4f6 AL	26	#include "cmd.h"
737e150e	27	#include "block/aio.h"
1de7afc9	28	#include "qemu/main-loop.h"
e3aff4f6 AL	29
	30	#define _(x) x /* not gettext support yet */
	31
e3aff4f6 AL	32	/* from libxcmd/command.c */
	33
	34	cmdinfo_t *cmdtab;
	35	int ncmds;
	36
	37	static argsfunc_t args_func;
	38	static checkfunc_t check_func;
	39	static int ncmdline;
	40	static char **cmdline;
	41
	42	static int
	43	compare(const void a, const void b)
	44	{
	45	return strcmp(((const cmdinfo_t *)a)->name,
	46	((const cmdinfo_t *)b)->name);
	47	}
	48
81beeec4	49	void add_command(const cmdinfo_t *ci)
e3aff4f6	50	{
ba7806ad	51	cmdtab = g_realloc((void )cmdtab, ++ncmds sizeof(*cmdtab));
81beeec4 PB	52	cmdtab[ncmds - 1] = *ci;
81beeec4 PB	53	qsort(cmdtab, ncmds, sizeof(*cmdtab), compare);
e3aff4f6 AL	54	}
	55
	56	static int
	57	check_command(
	58	const cmdinfo_t *ci)
	59	{
	60	if (check_func)
	61	return check_func(ci);
	62	return 1;
	63	}
	64
	65	void
	66	add_check_command(
	67	checkfunc_t cf)
	68	{
	69	check_func = cf;
	70	}
	71
	72	int
	73	command_usage(
	74	const cmdinfo_t *ci)
	75	{
	76	printf("%s %s -- %s\n", ci->name, ci->args, ci->oneline);
	77	return 0;
	78	}
	79
	80	int
	81	command(
	82	const cmdinfo_t *ct,
	83	int argc,
	84	char **argv)
	85	{
	86	char *cmd = argv[0];
	87
	88	if (!check_command(ct))
	89	return 0;
	90
	91	if (argc-1 < ct->argmin \|\| (ct->argmax != -1 && argc-1 > ct->argmax)) {
	92	if (ct->argmax == -1)
	93	fprintf(stderr,
	94	_("bad argument count %d to %s, expected at least %d arguments\n"),
	95	argc-1, cmd, ct->argmin);
	96	else if (ct->argmin == ct->argmax)
	97	fprintf(stderr,
	98	_("bad argument count %d to %s, expected %d arguments\n"),
	99	argc-1, cmd, ct->argmin);
	100	else
	101	fprintf(stderr,
	102	_("bad argument count %d to %s, expected between %d and %d arguments\n"),
	103	argc-1, cmd, ct->argmin, ct->argmax);
	104	return 0;
	105	}
	106	optind = 0;
	107	return ct->cfunc(argc, argv);
	108	}
	109
	110	const cmdinfo_t *
	111	find_command(
	112	const char *cmd)
	113	{
	114	cmdinfo_t *ct;
	115
	116	for (ct = cmdtab; ct < &cmdtab[ncmds]; ct++) {
	117	if (strcmp(ct->name, cmd) == 0 \|\|
118	(ct->altname && strcmp(ct->altname, cmd) == 0))
119	return (const cmdinfo_t *)ct;
120	}
121	return NULL;
122	}
123
81beeec4	124	void add_user_command(char *optarg)
e3aff4f6	125	{
ba7806ad	126	cmdline = g_realloc(cmdline, ++ncmdline * sizeof(char *));
81beeec4	127	cmdline[ncmdline-1] = optarg;
e3aff4f6 AL	128	}
	129
	130	static int
	131	args_command(
	132	int index)
	133	{
	134	if (args_func)
	135	return args_func(index);
	136	return 0;
	137	}
	138
	139	void
	140	add_args_command(
	141	argsfunc_t af)
	142	{
	143	args_func = af;
	144	}
	145
7d7d975c MK	146	static void prep_fetchline(void *opaque)
	147	{
	148	int *fetchable = opaque;
	149
a5a5238e	150	qemu_set_fd_handler(STDIN_FILENO, NULL, NULL, NULL);
7d7d975c MK	151	*fetchable= 1;
	152	}
	153
	154	static char *get_prompt(void);
	155
81beeec4	156	void command_loop(void)
e3aff4f6	157	{
81beeec4 PB	158	int c, i, j = 0, done = 0, fetchable = 0, prompted = 0;
	159	char *input;
	160	char **v;
	161	const cmdinfo_t *ct;
	162
	163	for (i = 0; !done && i < ncmdline; i++) {
	164	input = strdup(cmdline[i]);
	165	if (!input) {
	166	fprintf(stderr, _("cannot strdup command '%s': %s\n"),
	167	cmdline[i], strerror(errno));
	168	exit(1);
	169	}
	170	v = breakline(input, &c);
	171	if (c) {
	172	ct = find_command(v[0]);
	173	if (ct) {
	174	if (ct->flags & CMD_FLAG_GLOBAL) {
	175	done = command(ct, c, v);
	176	} else {
	177	j = 0;
	178	while (!done && (j = args_command(j))) {
	179	done = command(ct, c, v);
	180	}
	181	}
	182	} else {
	183	fprintf(stderr, _("command \"%s\" not found\n"), v[0]);
	184	}
e3aff4f6	185	}
81beeec4 PB	186	doneline(input, v);
	187	}
	188	if (cmdline) {
ba7806ad	189	g_free(cmdline);
81beeec4 PB	190	return;
81beeec4 PB	191	}
7d7d975c	192
81beeec4	193	while (!done) {
7d7d975c MK	194	if (!prompted) {
	195	printf("%s", get_prompt());
	196	fflush(stdout);
a5a5238e	197	qemu_set_fd_handler(STDIN_FILENO, prep_fetchline, NULL, &fetchable);
7d7d975c MK	198	prompted = 1;
	199	}
	200
a5a5238e	201	main_loop_wait(false);
7d7d975c MK	202
	203	if (!fetchable) {
	204	continue;
	205	}
81beeec4 PB	206	input = fetchline();
	207	if (input == NULL) {
	208	break;
	209	}
	210	v = breakline(input, &c);
	211	if (c) {
	212	ct = find_command(v[0]);
	213	if (ct) {
	214	done = command(ct, c, v);
	215	} else {
	216	fprintf(stderr, _("command \"%s\" not found\n"), v[0]);
	217	}
	218	}
	219	doneline(input, v);
7d7d975c MK	220
	221	prompted = 0;
	222	fetchable = 0;
81beeec4	223	}
a5a5238e	224	qemu_set_fd_handler(STDIN_FILENO, NULL, NULL, NULL);
e3aff4f6 AL	225	}
	226
	227	/* from libxcmd/input.c */
	228
	229	#if defined(ENABLE_READLINE)
	230	# include <readline/history.h>
	231	# include <readline/readline.h>
	232	#elif defined(ENABLE_EDITLINE)
	233	# include <histedit.h>
	234	#endif
	235
e3aff4f6 AL	236	static char *
	237	get_prompt(void)
	238	{
	239	static char prompt[FILENAME_MAX + 2 /"> "/ + 1 /"\0"/ ];
	240
	241	if (!prompt[0])
	242	snprintf(prompt, sizeof(prompt), "%s> ", progname);
	243	return prompt;
	244	}
	245
	246	#if defined(ENABLE_READLINE)
	247	char *
	248	fetchline(void)
	249	{
	250	char *line;
	251
	252	line = readline(get_prompt());
	253	if (line && *line)
	254	add_history(line);
	255	return line;
	256	}
	257	#elif defined(ENABLE_EDITLINE)
	258	static char el_get_prompt(EditLine e) { return get_prompt(); }
	259	char *
	260	fetchline(void)
	261	{
	262	static EditLine *el;
	263	static History *hist;
	264	HistEvent hevent;
	265	char *line;
	266	int count;
	267
	268	if (!el) {
	269	hist = history_init();
	270	history(hist, &hevent, H_SETSIZE, 100);
	271	el = el_init(progname, stdin, stdout, stderr);
	272	el_source(el, NULL);
	273	el_set(el, EL_SIGNAL, 1);
	274	el_set(el, EL_PROMPT, el_get_prompt);
	275	el_set(el, EL_HIST, history, (const char *)hist);
	276	}
	277	line = strdup(el_gets(el, &count));
	278	if (line) {
	279	if (count > 0)
	280	line[count-1] = '\0';
	281	if (*line)
	282	history(hist, &hevent, H_ENTER, line);
	283	}
	284	return line;
	285	}
	286	#else
	287	# define MAXREADLINESZ 1024
	288	char *
	289	fetchline(void)
	290	{
	291	char p, line = malloc(MAXREADLINESZ);
	292
	293	if (!line)
	294	return NULL;
e3aff4f6 AL	295	if (!fgets(line, MAXREADLINESZ, stdin)) {
	296	free(line);
	297	return NULL;
	298	}
	299	p = line + strlen(line);
	300	if (p != line && p[-1] == '\n')
	301	p[-1] = '\0';
	302	return line;
	303	}
	304	#endif
	305
c32d766a SW	306	static char qemu_strsep(char input, const char delim)
	307	{
	308	char result = input;
	309	if (result != NULL) {
88bf7950 BS	310	char *p;
88bf7950 BS	311
50da01ed SW	312	for (p = result; *p != '\0'; p++) {
50da01ed SW	313	if (strchr(delim, *p)) {
c32d766a SW	314	break;
	315	}
	316	}
	317	if (*p == '\0') {
	318	*input = NULL;
	319	} else {
	320	*p = '\0';
	321	*input = p + 1;
	322	}
	323	}
	324	return result;
	325	}
	326
81beeec4	327	char *breakline(char input, int *count)
e3aff4f6	328	{
81beeec4 PB	329	int c = 0;
	330	char *p;
	331	char *rval = calloc(sizeof(char ), 1);
47e8dd8f	332	char **tmp;
81beeec4 PB	333
	334	while (rval && (p = qemu_strsep(&input, " ")) != NULL) {
	335	if (!*p) {
	336	continue;
	337	}
	338	c++;
47e8dd8f PB	339	tmp = realloc(rval, sizeof(rval) (c + 1));
	340	if (!tmp) {
	341	free(rval);
	342	rval = NULL;
81beeec4 PB	343	c = 0;
81beeec4 PB	344	break;
47e8dd8f PB	345	} else {
47e8dd8f PB	346	rval = tmp;
81beeec4 PB	347	}
	348	rval[c - 1] = p;
	349	rval[c] = NULL;
	350	}
	351	*count = c;
	352	return rval;
e3aff4f6 AL	353	}
	354
	355	void
	356	doneline(
	357	char *input,
	358	char **vec)
	359	{
	360	free(input);
	361	free(vec);
	362	}
	363
	364	#define EXABYTES(x) ((long long)(x) << 60)
	365	#define PETABYTES(x) ((long long)(x) << 50)
	366	#define TERABYTES(x) ((long long)(x) << 40)
	367	#define GIGABYTES(x) ((long long)(x) << 30)
	368	#define MEGABYTES(x) ((long long)(x) << 20)
	369	#define KILOBYTES(x) ((long long)(x) << 10)
	370
	371	long long
	372	cvtnum(
	373	char *s)
	374	{
	375	long long i;
	376	char *sp;
	377	int c;
	378
	379	i = strtoll(s, &sp, 0);
	380	if (i == 0 && sp == s)
	381	return -1LL;
	382	if (*sp == '\0')
	383	return i;
	384
	385	if (sp[1] != '\0')
	386	return -1LL;
	387
7b0a03a1	388	c = qemu_tolower(*sp);
e3aff4f6 AL	389	switch (c) {
	390	default:
	391	return i;
	392	case 'k':
	393	return KILOBYTES(i);
	394	case 'm':
	395	return MEGABYTES(i);
	396	case 'g':
	397	return GIGABYTES(i);
	398	case 't':
	399	return TERABYTES(i);
	400	case 'p':
	401	return PETABYTES(i);
	402	case 'e':
	403	return EXABYTES(i);
	404	}
	405	return -1LL;
	406	}
	407
	408	#define TO_EXABYTES(x) ((x) / EXABYTES(1))
	409	#define TO_PETABYTES(x) ((x) / PETABYTES(1))
	410	#define TO_TERABYTES(x) ((x) / TERABYTES(1))
	411	#define TO_GIGABYTES(x) ((x) / GIGABYTES(1))
	412	#define TO_MEGABYTES(x) ((x) / MEGABYTES(1))
	413	#define TO_KILOBYTES(x) ((x) / KILOBYTES(1))
	414
	415	void
	416	cvtstr(
	417	double value,
	418	char *str,
	419	size_t size)
	420	{
8655d2de PB	421	char *trim;
8655d2de PB	422	const char *suffix;
e3aff4f6 AL	423
e3aff4f6 AL	424	if (value >= EXABYTES(1)) {
8655d2de PB	425	suffix = " EiB";
8655d2de PB	426	snprintf(str, size - 4, "%.3f", TO_EXABYTES(value));
e3aff4f6	427	} else if (value >= PETABYTES(1)) {
8655d2de PB	428	suffix = " PiB";
8655d2de PB	429	snprintf(str, size - 4, "%.3f", TO_PETABYTES(value));
e3aff4f6	430	} else if (value >= TERABYTES(1)) {
8655d2de PB	431	suffix = " TiB";
8655d2de PB	432	snprintf(str, size - 4, "%.3f", TO_TERABYTES(value));
e3aff4f6	433	} else if (value >= GIGABYTES(1)) {
8655d2de PB	434	suffix = " GiB";
8655d2de PB	435	snprintf(str, size - 4, "%.3f", TO_GIGABYTES(value));
e3aff4f6	436	} else if (value >= MEGABYTES(1)) {
8655d2de PB	437	suffix = " MiB";
8655d2de PB	438	snprintf(str, size - 4, "%.3f", TO_MEGABYTES(value));
e3aff4f6	439	} else if (value >= KILOBYTES(1)) {
8655d2de PB	440	suffix = " KiB";
	441	snprintf(str, size - 4, "%.3f", TO_KILOBYTES(value));
	442	} else {
	443	suffix = " bytes";
	444	snprintf(str, size - 6, "%f", value);
	445	}
	446
	447	trim = strstr(str, ".000");
	448	if (trim) {
	449	strcpy(trim, suffix);
e3aff4f6	450	} else {
8655d2de	451	strcat(str, suffix);
e3aff4f6 AL	452	}
	453	}
	454
	455	struct timeval
	456	tsub(struct timeval t1, struct timeval t2)
	457	{
	458	t1.tv_usec -= t2.tv_usec;
	459	if (t1.tv_usec < 0) {
	460	t1.tv_usec += 1000000;
	461	t1.tv_sec--;
	462	}
	463	t1.tv_sec -= t2.tv_sec;
	464	return t1;
	465	}
	466
	467	double
	468	tdiv(double value, struct timeval tv)
	469	{
	470	return value / ((double)tv.tv_sec + ((double)tv.tv_usec / 1000000.0));
	471	}
	472
	473	#define HOURS(sec) ((sec) / (60 * 60))
	474	#define MINUTES(sec) (((sec) % (60 * 60)) / 60)
	475	#define SECONDS(sec) ((sec) % 60)
	476
	477	void
	478	timestr(
	479	struct timeval *tv,
	480	char *ts,
	481	size_t size,
	482	int format)
	483	{
	484	double usec = (double)tv->tv_usec / 1000000.0;
	485
	486	if (format & TERSE_FIXED_TIME) {
	487	if (!HOURS(tv->tv_sec)) {
	488	snprintf(ts, size, "%u:%02u.%02u",
	489	(unsigned int) MINUTES(tv->tv_sec),
	490	(unsigned int) SECONDS(tv->tv_sec),
bcd2491a	491	(unsigned int) (usec * 100));
e3aff4f6 AL	492	return;
	493	}
	494	format \|= VERBOSE_FIXED_TIME; /* fallback if hours needed */
	495	}
	496
	497	if ((format & VERBOSE_FIXED_TIME) \|\| tv->tv_sec) {
	498	snprintf(ts, size, "%u:%02u:%02u.%02u",
	499	(unsigned int) HOURS(tv->tv_sec),
	500	(unsigned int) MINUTES(tv->tv_sec),
	501	(unsigned int) SECONDS(tv->tv_sec),
bcd2491a	502	(unsigned int) (usec * 100));
e3aff4f6	503	} else {
bcd2491a	504	snprintf(ts, size, "0.%04u sec", (unsigned int) (usec * 10000));
e3aff4f6 AL	505	}
	506	}
	507
	508
	509	/* from libxcmd/quit.c */
	510
	511	static cmdinfo_t quit_cmd;
	512
	513	/* ARGSUSED */
	514	static int
	515	quit_f(
	516	int argc,
	517	char **argv)
	518	{
	519	return 1;
	520	}
	521
	522	void
	523	quit_init(void)
	524	{
	525	quit_cmd.name = _("quit");
	526	quit_cmd.altname = _("q");
	527	quit_cmd.cfunc = quit_f;
	528	quit_cmd.argmin = -1;
	529	quit_cmd.argmax = -1;
	530	quit_cmd.flags = CMD_FLAG_GLOBAL;
	531	quit_cmd.oneline = _("exit the program");
	532
	533	add_command(&quit_cmd);
	534	}
	535
	536	/* from libxcmd/help.c */
	537
	538	static cmdinfo_t help_cmd;
	539	static void help_onecmd(const char cmd, const cmdinfo_t ct);
	540	static void help_oneline(const char cmd, const cmdinfo_t ct);
	541
	542	static void
	543	help_all(void)
	544	{
	545	const cmdinfo_t *ct;
	546
	547	for (ct = cmdtab; ct < &cmdtab[ncmds]; ct++)
	548	help_oneline(ct->name, ct);
	549	printf(_("\nUse 'help commandname' for extended help.\n"));
	550	}
	551
	552	static int
	553	help_f(
	554	int argc,
	555	char **argv)
	556	{
	557	const cmdinfo_t *ct;
	558
	559	if (argc == 1) {
	560	help_all();
	561	return 0;
	562	}
	563	ct = find_command(argv[1]);
	564	if (ct == NULL) {
	565	printf(_("command %s not found\n"), argv[1]);
	566	return 0;
	567	}
	568	help_onecmd(argv[1], ct);
569	return 0;
570	}
571
572	static void
573	help_onecmd(
574	const char *cmd,
575	const cmdinfo_t *ct)
576	{
577	help_oneline(cmd, ct);
578	if (ct->help)
579	ct->help();
580	}
581
582	static void
583	help_oneline(
584	const char *cmd,
585	const cmdinfo_t *ct)
586	{
587	if (cmd)
588	printf("%s ", cmd);
589	else {
590	printf("%s ", ct->name);
591	if (ct->altname)
592	printf("(or %s) ", ct->altname);
593	}
594	if (ct->args)
595	printf("%s ", ct->args);
596	printf("-- %s\n", ct->oneline);
597	}
598
599	void
600	help_init(void)
601	{
602	help_cmd.name = _("help");
603	help_cmd.altname = _("?");
604	help_cmd.cfunc = help_f;
605	help_cmd.argmin = 0;
606	help_cmd.argmax = 1;
607	help_cmd.flags = CMD_FLAG_GLOBAL;
608	help_cmd.args = _("[command]");
609	help_cmd.oneline = _("help for one or all commands");
610
611	add_command(&help_cmd);
612	}