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 "qemu-aio.h"
  28
  29 #define _(x)    x       /* not gettext support yet */
  30
  31 /* from libxcmd/command.c */
  32
  33 cmdinfo_t       *cmdtab;
  34 int             ncmds;
  35
  36 static argsfunc_t       args_func;
  37 static checkfunc_t      check_func;
  38 static int              ncmdline;
  39 static char             **cmdline;
  40
  41 static int
  42 compare(const void *a, const void *b)
  43 {
  44         return strcmp(((const cmdinfo_t *)a)->name,
  45                       ((const cmdinfo_t *)b)->name);
  46 }
  47
  48 void add_command(const cmdinfo_t *ci)
  49 {
  50     cmdtab = realloc((void *)cmdtab, ++ncmds * sizeof(*cmdtab));
  51     cmdtab[ncmds - 1] = *ci;
  52     qsort(cmdtab, ncmds, sizeof(*cmdtab), compare);
  53 }
  54
  55 static int
  56 check_command(
  57         const cmdinfo_t *ci)
  58 {
  59         if (check_func)
  60                 return check_func(ci);
  61         return 1;
  62 }
  63
  64 void
  65 add_check_command(
  66         checkfunc_t     cf)
  67 {
  68         check_func = cf;
  69 }
  70
  71 int
  72 command_usage(
  73         const cmdinfo_t *ci)
  74 {
  75         printf("%s %s -- %s\n", ci->name, ci->args, ci->oneline);
  76         return 0;
  77 }
  78
  79 int
  80 command(
  81         const cmdinfo_t *ct,
  82         int             argc,
  83         char            **argv)
  84 {
  85         char            *cmd = argv[0];
  86
  87         if (!check_command(ct))
  88                 return 0;
  89
  90         if (argc-1 < ct->argmin || (ct->argmax != -1 && argc-1 > ct->argmax)) {
  91                 if (ct->argmax == -1)
  92                         fprintf(stderr,
  93         _("bad argument count %d to %s, expected at least %d arguments\n"),
  94                                 argc-1, cmd, ct->argmin);
  95                 else if (ct->argmin == ct->argmax)
  96                         fprintf(stderr,
  97         _("bad argument count %d to %s, expected %d arguments\n"),
  98                                 argc-1, cmd, ct->argmin);
  99                 else
 100                         fprintf(stderr,
 101         _("bad argument count %d to %s, expected between %d and %d arguments\n"),
 102                         argc-1, cmd, ct->argmin, ct->argmax);
 103                 return 0;
 104         }
 105         optind = 0;
 106         return ct->cfunc(argc, argv);
 107 }
 108
 109 const cmdinfo_t *
 110 find_command(
 111         const char      *cmd)
 112 {
 113         cmdinfo_t       *ct;
 114
 115         for (ct = cmdtab; ct < &cmdtab[ncmds]; ct++) {
 116                 if (strcmp(ct->name, cmd) == 0 ||
 117                     (ct->altname && strcmp(ct->altname, cmd) == 0))
 118                         return (const cmdinfo_t *)ct;
 119         }
 120         return NULL;
 121 }
 122
 123 void add_user_command(char *optarg)
 124 {
 125     ncmdline++;
 126     cmdline = realloc(cmdline, ncmdline * sizeof(char *));
 127     if (!cmdline) {
 128         perror("realloc");
 129         exit(1);
 130     }
 131     cmdline[ncmdline-1] = optarg;
 132 }
 133
 134 static int
 135 args_command(
 136         int     index)
 137 {
 138         if (args_func)
 139                 return args_func(index);
 140         return 0;
 141 }
 142
 143 void
 144 add_args_command(
 145         argsfunc_t      af)
 146 {
 147         args_func = af;
 148 }
 149
 150 static void prep_fetchline(void *opaque)
 151 {
 152     int *fetchable = opaque;
 153
 154     qemu_aio_set_fd_handler(STDIN_FILENO, NULL, NULL, NULL, NULL, NULL);
 155     *fetchable= 1;
 156 }
 157
 158 static char *get_prompt(void);
 159
 160 void command_loop(void)
 161 {
 162     int c, i, j = 0, done = 0, fetchable = 0, prompted = 0;
 163     char *input;
 164     char **v;
 165     const cmdinfo_t *ct;
 166
 167     for (i = 0; !done && i < ncmdline; i++) {
 168         input = strdup(cmdline[i]);
 169         if (!input) {
 170             fprintf(stderr, _("cannot strdup command '%s': %s\n"),
 171                     cmdline[i], strerror(errno));
 172             exit(1);
 173         }
 174         v = breakline(input, &c);
 175         if (c) {
 176             ct = find_command(v[0]);
 177             if (ct) {
 178                 if (ct->flags & CMD_FLAG_GLOBAL) {
 179                     done = command(ct, c, v);
 180                 } else {
 181                     j = 0;
 182                     while (!done && (j = args_command(j))) {
 183                         done = command(ct, c, v);
 184                     }
 185                 }
 186             } else {
 187                 fprintf(stderr, _("command \"%s\" not found\n"), v[0]);
 188             }
 189         }
 190         doneline(input, v);
 191     }
 192     if (cmdline) {
 193         free(cmdline);
 194         return;
 195     }
 196
 197     while (!done) {
 198         if (!prompted) {
 199             printf("%s", get_prompt());
 200             fflush(stdout);
 201             qemu_aio_set_fd_handler(STDIN_FILENO, prep_fetchline, NULL, NULL,
 202                                     NULL, &fetchable);
 203             prompted = 1;
 204         }
 205
 206         qemu_aio_wait();
 207
 208         if (!fetchable) {
 209             continue;
 210         }
 211         input = fetchline();
 212         if (input == NULL) {
 213             break;
 214         }
 215         v = breakline(input, &c);
 216         if (c) {
 217             ct = find_command(v[0]);
 218             if (ct) {
 219                 done = command(ct, c, v);
 220             } else {
 221                 fprintf(stderr, _("command \"%s\" not found\n"), v[0]);
 222             }
 223         }
 224         doneline(input, v);
 225
 226         prompted = 0;
 227         fetchable = 0;
 228     }
 229     qemu_aio_set_fd_handler(STDIN_FILENO, NULL, NULL, NULL, NULL, NULL);
 230 }
 231
 232 /* from libxcmd/input.c */
 233
 234 #if defined(ENABLE_READLINE)
 235 # include <readline/history.h>
 236 # include <readline/readline.h>
 237 #elif defined(ENABLE_EDITLINE)
 238 # include <histedit.h>
 239 #endif
 240
 241 static char *
 242 get_prompt(void)
 243 {
 244         static char     prompt[FILENAME_MAX + 2 /*"> "*/ + 1 /*"\0"*/ ];
 245
 246         if (!prompt[0])
 247                 snprintf(prompt, sizeof(prompt), "%s> ", progname);
 248         return prompt;
 249 }
 250
 251 #if defined(ENABLE_READLINE)
 252 char *
 253 fetchline(void)
 254 {
 255         char    *line;
 256
 257         line = readline(get_prompt());
 258         if (line && *line)
 259                 add_history(line);
 260         return line;
 261 }
 262 #elif defined(ENABLE_EDITLINE)
 263 static char *el_get_prompt(EditLine *e) { return get_prompt(); }
 264 char *
 265 fetchline(void)
 266 {
 267         static EditLine *el;
 268         static History  *hist;
 269         HistEvent       hevent;
 270         char            *line;
 271         int             count;
 272
 273         if (!el) {
 274                 hist = history_init();
 275                 history(hist, &hevent, H_SETSIZE, 100);
 276                 el = el_init(progname, stdin, stdout, stderr);
 277                 el_source(el, NULL);
 278                 el_set(el, EL_SIGNAL, 1);
 279                 el_set(el, EL_PROMPT, el_get_prompt);
 280                 el_set(el, EL_HIST, history, (const char *)hist);
 281         }
 282         line = strdup(el_gets(el, &count));
 283         if (line) {
 284                 if (count > 0)
 285                         line[count-1] = '\0';
 286                 if (*line)
 287                         history(hist, &hevent, H_ENTER, line);
 288         }
 289         return line;
 290 }
 291 #else
 292 # define MAXREADLINESZ  1024
 293 char *
 294 fetchline(void)
 295 {
 296         char    *p, *line = malloc(MAXREADLINESZ);
 297
 298         if (!line)
 299                 return NULL;
 300         if (!fgets(line, MAXREADLINESZ, stdin)) {
 301                 free(line);
 302                 return NULL;
 303         }
 304         p = line + strlen(line);
 305         if (p != line && p[-1] == '\n')
 306                 p[-1] = '\0';
 307         return line;
 308 }
 309 #endif
 310
 311 static char *qemu_strsep(char **input, const char *delim)
 312 {
 313     char *result = *input;
 314     if (result != NULL) {
 315         char *p;
 316
 317         for (p = result; *p != '\0'; p++) {
 318             if (strchr(delim, *p)) {
 319                 break;
 320             }
 321         }
 322         if (*p == '\0') {
 323             *input = NULL;
 324         } else {
 325             *p = '\0';
 326             *input = p + 1;
 327         }
 328     }
 329     return result;
 330 }
 331
 332 char **breakline(char *input, int *count)
 333 {
 334     int c = 0;
 335     char *p;
 336     char **rval = calloc(sizeof(char *), 1);
 337
 338     while (rval && (p = qemu_strsep(&input, " ")) != NULL) {
 339         if (!*p) {
 340             continue;
 341         }
 342         c++;
 343         rval = realloc(rval, sizeof(*rval) * (c + 1));
 344         if (!rval) {
 345             c = 0;
 346             break;
 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         const char      *fmt;
 422         int             precise;
 423
 424         precise = ((double)value * 1000 == (double)(int)value * 1000);
 425
 426         if (value >= EXABYTES(1)) {
 427                 fmt = precise ? "%.f EiB" : "%.3f EiB";
 428                 snprintf(str, size, fmt, TO_EXABYTES(value));
 429         } else if (value >= PETABYTES(1)) {
 430                 fmt = precise ? "%.f PiB" : "%.3f PiB";
 431                 snprintf(str, size, fmt, TO_PETABYTES(value));
 432         } else if (value >= TERABYTES(1)) {
 433                 fmt = precise ? "%.f TiB" : "%.3f TiB";
 434                 snprintf(str, size, fmt, TO_TERABYTES(value));
 435         } else if (value >= GIGABYTES(1)) {
 436                 fmt = precise ? "%.f GiB" : "%.3f GiB";
 437                 snprintf(str, size, fmt, TO_GIGABYTES(value));
 438         } else if (value >= MEGABYTES(1)) {
 439                 fmt = precise ? "%.f MiB" : "%.3f MiB";
 440                 snprintf(str, size, fmt, TO_MEGABYTES(value));
 441         } else if (value >= KILOBYTES(1)) {
 442                 fmt = precise ? "%.f KiB" : "%.3f KiB";
 443                 snprintf(str, size, fmt, TO_KILOBYTES(value));
 444         } else {
 445                 snprintf(str, size, "%f bytes", value);
 446         }
 447 }
 448
 449 struct timeval
 450 tsub(struct timeval t1, struct timeval t2)
 451 {
 452         t1.tv_usec -= t2.tv_usec;
 453         if (t1.tv_usec < 0) {
 454                 t1.tv_usec += 1000000;
 455                 t1.tv_sec--;
 456         }
 457         t1.tv_sec -= t2.tv_sec;
 458         return t1;
 459 }
 460
 461 double
 462 tdiv(double value, struct timeval tv)
 463 {
 464         return value / ((double)tv.tv_sec + ((double)tv.tv_usec / 1000000.0));
 465 }
 466
 467 #define HOURS(sec)      ((sec) / (60 * 60))
 468 #define MINUTES(sec)    (((sec) % (60 * 60)) / 60)
 469 #define SECONDS(sec)    ((sec) % 60)
 470
 471 void
 472 timestr(
 473         struct timeval  *tv,
 474         char            *ts,
 475         size_t          size,
 476         int             format)
 477 {
 478         double          usec = (double)tv->tv_usec / 1000000.0;
 479
 480         if (format & TERSE_FIXED_TIME) {
 481                 if (!HOURS(tv->tv_sec)) {
 482                         snprintf(ts, size, "%u:%02u.%02u",
 483                                 (unsigned int) MINUTES(tv->tv_sec),
 484                                 (unsigned int) SECONDS(tv->tv_sec),
 485                                 (unsigned int) (usec * 100));
 486                         return;
 487                 }
 488                 format |= VERBOSE_FIXED_TIME;   /* fallback if hours needed */
 489         }
 490
 491         if ((format & VERBOSE_FIXED_TIME) || tv->tv_sec) {
 492                 snprintf(ts, size, "%u:%02u:%02u.%02u",
 493                         (unsigned int) HOURS(tv->tv_sec),
 494                         (unsigned int) MINUTES(tv->tv_sec),
 495                         (unsigned int) SECONDS(tv->tv_sec),
 496                         (unsigned int) (usec * 100));
 497         } else {
 498                 snprintf(ts, size, "0.%04u sec", (unsigned int) (usec * 10000));
 499         }
 500 }
 501
 502
 503 /* from libxcmd/quit.c */
 504
 505 static cmdinfo_t quit_cmd;
 506
 507 /* ARGSUSED */
 508 static int
 509 quit_f(
 510         int     argc,
 511         char    **argv)
 512 {
 513         return 1;
 514 }
 515
 516 void
 517 quit_init(void)
 518 {
 519         quit_cmd.name = _("quit");
 520         quit_cmd.altname = _("q");
 521         quit_cmd.cfunc = quit_f;
 522         quit_cmd.argmin = -1;
 523         quit_cmd.argmax = -1;
 524         quit_cmd.flags = CMD_FLAG_GLOBAL;
 525         quit_cmd.oneline = _("exit the program");
 526
 527         add_command(&quit_cmd);
 528 }
 529
 530 /* from libxcmd/help.c */
 531
 532 static cmdinfo_t help_cmd;
 533 static void help_onecmd(const char *cmd, const cmdinfo_t *ct);
 534 static void help_oneline(const char *cmd, const cmdinfo_t *ct);
 535
 536 static void
 537 help_all(void)
 538 {
 539         const cmdinfo_t *ct;
 540
 541         for (ct = cmdtab; ct < &cmdtab[ncmds]; ct++)
 542                 help_oneline(ct->name, ct);
 543         printf(_("\nUse 'help commandname' for extended help.\n"));
 544 }
 545
 546 static int
 547 help_f(
 548         int             argc,
 549         char            **argv)
 550 {
 551         const cmdinfo_t *ct;
 552
 553         if (argc == 1) {
 554                 help_all();
 555                 return 0;
 556         }
 557         ct = find_command(argv[1]);
 558         if (ct == NULL) {
 559                 printf(_("command %s not found\n"), argv[1]);
 560                 return 0;
 561         }
 562         help_onecmd(argv[1], ct);
 563         return 0;
 564 }
 565
 566 static void
 567 help_onecmd(
 568         const char      *cmd,
 569         const cmdinfo_t *ct)
 570 {
 571         help_oneline(cmd, ct);
 572         if (ct->help)
 573                 ct->help();
 574 }
 575
 576 static void
 577 help_oneline(
 578         const char      *cmd,
 579         const cmdinfo_t *ct)
 580 {
 581         if (cmd)
 582                 printf("%s ", cmd);
 583         else {
 584                 printf("%s ", ct->name);
 585                 if (ct->altname)
 586                         printf("(or %s) ", ct->altname);
 587         }
 588         if (ct->args)
 589                 printf("%s ", ct->args);
 590         printf("-- %s\n", ct->oneline);
 591 }
 592
 593 void
 594 help_init(void)
 595 {
 596         help_cmd.name = _("help");
 597         help_cmd.altname = _("?");
 598         help_cmd.cfunc = help_f;
 599         help_cmd.argmin = 0;
 600         help_cmd.argmax = 1;
 601         help_cmd.flags = CMD_FLAG_GLOBAL;
 602         help_cmd.args = _("[command]");
 603         help_cmd.oneline = _("help for one or all commands");
 604
 605         add_command(&help_cmd);
 606 }