]> git.proxmox.com Git - qemu.git/blob - cmd.c
fw_cfg: Splash image loader can overrun a stack variable, fix
[qemu.git] / cmd.c
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
15 * along with this program; if not, see <http://www.gnu.org/licenses/>.
16 */
17
18 #include <stdio.h>
19 #include <stdlib.h>
20 #include <string.h>
21 #include <ctype.h>
22 #include <errno.h>
23 #include <sys/time.h>
24 #include <getopt.h>
25
26 #include "cmd.h"
27 #include "block/aio.h"
28 #include "qemu/main-loop.h"
29
30 #define _(x) x /* not gettext support yet */
31
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
49 void add_command(const cmdinfo_t *ci)
50 {
51 cmdtab = g_realloc((void *)cmdtab, ++ncmds * sizeof(*cmdtab));
52 cmdtab[ncmds - 1] = *ci;
53 qsort(cmdtab, ncmds, sizeof(*cmdtab), compare);
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
124 void add_user_command(char *optarg)
125 {
126 cmdline = g_realloc(cmdline, ++ncmdline * sizeof(char *));
127 cmdline[ncmdline-1] = optarg;
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
146 static void prep_fetchline(void *opaque)
147 {
148 int *fetchable = opaque;
149
150 qemu_set_fd_handler(STDIN_FILENO, NULL, NULL, NULL);
151 *fetchable= 1;
152 }
153
154 static char *get_prompt(void);
155
156 void command_loop(void)
157 {
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 }
185 }
186 doneline(input, v);
187 }
188 if (cmdline) {
189 g_free(cmdline);
190 return;
191 }
192
193 while (!done) {
194 if (!prompted) {
195 printf("%s", get_prompt());
196 fflush(stdout);
197 qemu_set_fd_handler(STDIN_FILENO, prep_fetchline, NULL, &fetchable);
198 prompted = 1;
199 }
200
201 main_loop_wait(false);
202
203 if (!fetchable) {
204 continue;
205 }
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);
220
221 prompted = 0;
222 fetchable = 0;
223 }
224 qemu_set_fd_handler(STDIN_FILENO, NULL, NULL, NULL);
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
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;
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
306 static char *qemu_strsep(char **input, const char *delim)
307 {
308 char *result = *input;
309 if (result != NULL) {
310 char *p;
311
312 for (p = result; *p != '\0'; p++) {
313 if (strchr(delim, *p)) {
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
327 char **breakline(char *input, int *count)
328 {
329 int c = 0;
330 char *p;
331 char **rval = calloc(sizeof(char *), 1);
332 char **tmp;
333
334 while (rval && (p = qemu_strsep(&input, " ")) != NULL) {
335 if (!*p) {
336 continue;
337 }
338 c++;
339 tmp = realloc(rval, sizeof(*rval) * (c + 1));
340 if (!tmp) {
341 free(rval);
342 rval = NULL;
343 c = 0;
344 break;
345 } else {
346 rval = tmp;
347 }
348 rval[c - 1] = p;
349 rval[c] = NULL;
350 }
351 *count = c;
352 return rval;
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
388 c = qemu_tolower(*sp);
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 {
421 char *trim;
422 const char *suffix;
423
424 if (value >= EXABYTES(1)) {
425 suffix = " EiB";
426 snprintf(str, size - 4, "%.3f", TO_EXABYTES(value));
427 } else if (value >= PETABYTES(1)) {
428 suffix = " PiB";
429 snprintf(str, size - 4, "%.3f", TO_PETABYTES(value));
430 } else if (value >= TERABYTES(1)) {
431 suffix = " TiB";
432 snprintf(str, size - 4, "%.3f", TO_TERABYTES(value));
433 } else if (value >= GIGABYTES(1)) {
434 suffix = " GiB";
435 snprintf(str, size - 4, "%.3f", TO_GIGABYTES(value));
436 } else if (value >= MEGABYTES(1)) {
437 suffix = " MiB";
438 snprintf(str, size - 4, "%.3f", TO_MEGABYTES(value));
439 } else if (value >= KILOBYTES(1)) {
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);
450 } else {
451 strcat(str, suffix);
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),
491 (unsigned int) (usec * 100));
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),
502 (unsigned int) (usec * 100));
503 } else {
504 snprintf(ts, size, "0.%04u sec", (unsigned int) (usec * 10000));
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 }