qemu/roms/ipxe/src/core/exec.c

   1 /*
   2  * Copyright (C) 2006 Michael Brown <mbrown@fensystems.co.uk>.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License as
   6  * published by the Free Software Foundation; either version 2 of the
   7  * License, or any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * 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, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  17  * 02110-1301, USA.
  18  *
  19  * You can also choose to distribute this program under the terms of
  20  * the Unmodified Binary Distribution Licence (as given in the file
  21  * COPYING.UBDL), provided that you have satisfied its requirements.
  22  */
  23
  24 FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
  25
  26 #include <stdint.h>
  27 #include <string.h>
  28 #include <stdlib.h>
  29 #include <stdio.h>
  30 #include <ctype.h>
  31 #include <unistd.h>
  32 #include <getopt.h>
  33 #include <errno.h>
  34 #include <assert.h>
  35 #include <ipxe/tables.h>
  36 #include <ipxe/command.h>
  37 #include <ipxe/parseopt.h>
  38 #include <ipxe/settings.h>
  39 #include <ipxe/console.h>
  40 #include <ipxe/keys.h>
  41 #include <ipxe/process.h>
  42 #include <ipxe/nap.h>
  43 #include <ipxe/shell.h>
  44
  45 /** @file
  46  *
  47  * Command execution
  48  *
  49  */
  50
  51 /** Shell stop state */
  52 static int stop_state;
  53
  54 /**
  55  * Execute command
  56  *
  57  * @v command           Command name
  58  * @v argv              Argument list
  59  * @ret rc              Return status code
  60  *
  61  * Execute the named command.  Unlike a traditional POSIX execv(),
  62  * this function returns the exit status of the command.
  63  */
  64 int execv ( const char *command, char * const argv[] ) {
  65         struct command *cmd;
  66         int argc;
  67         int rc;
  68
  69         /* Count number of arguments */
  70         for ( argc = 0 ; argv[argc] ; argc++ ) {}
  71
  72         /* An empty command is deemed to do nothing, successfully */
  73         if ( command == NULL ) {
  74                 rc = 0;
  75                 goto done;
  76         }
  77
  78         /* Sanity checks */
  79         if ( argc == 0 ) {
  80                 DBG ( "%s: empty argument list\n", command );
  81                 rc = -EINVAL;
  82                 goto done;
  83         }
  84
  85         /* Reset getopt() library ready for use by the command.  This
  86          * is an artefact of the POSIX getopt() API within the context
  87          * of Etherboot; see the documentation for reset_getopt() for
  88          * details.
  89          */
  90         reset_getopt();
  91
  92         /* Hand off to command implementation */
  93         for_each_table_entry ( cmd, COMMANDS ) {
  94                 if ( strcmp ( command, cmd->name ) == 0 ) {
  95                         rc = cmd->exec ( argc, ( char ** ) argv );
  96                         goto done;
  97                 }
  98         }
  99
 100         printf ( "%s: command not found\n", command );
 101         rc = -ENOEXEC;
 102
 103  done:
 104         /* Store error number, if an error occurred */
 105         if ( rc ) {
 106                 errno = rc;
 107                 if ( errno < 0 )
 108                         errno = -errno;
 109         }
 110
 111         return rc;
 112 }
 113
 114 /**
 115  * Split command line into tokens
 116  *
 117  * @v command           Command line
 118  * @v tokens            Token list to populate, or NULL
 119  * @ret count           Number of tokens
 120  *
 121  * Splits the command line into whitespace-delimited tokens.  If @c
 122  * tokens is non-NULL, any whitespace in the command line will be
 123  * replaced with NULs.
 124  */
 125 static int split_command ( char *command, char **tokens ) {
 126         int count = 0;
 127
 128         while ( 1 ) {
 129                 /* Skip over any whitespace / convert to NUL */
 130                 while ( isspace ( *command ) ) {
 131                         if ( tokens )
 132                                 *command = '\0';
 133                         command++;
 134                 }
 135                 /* Check for end of line */
 136                 if ( ! *command )
 137                         break;
 138                 /* We have found the start of the next argument */
 139                 if ( tokens )
 140                         tokens[count] = command;
 141                 count++;
 142                 /* Skip to start of next whitespace, if any */
 143                 while ( *command && ! isspace ( *command ) ) {
 144                         command++;
 145                 }
 146         }
 147         return count;
 148 }
 149
 150 /**
 151  * Process next command only if previous command succeeded
 152  *
 153  * @v rc                Status of previous command
 154  * @ret process         Process next command
 155  */
 156 static int process_on_success ( int rc ) {
 157         return ( rc == 0 );
 158 }
 159
 160 /**
 161  * Process next command only if previous command failed
 162  *
 163  * @v rc                Status of previous command
 164  * @ret process         Process next command
 165  */
 166 static int process_on_failure ( int rc ) {
 167         return ( rc != 0 );
 168 }
 169
 170 /**
 171  * Process next command regardless of status from previous command
 172  *
 173  * @v rc                Status of previous command
 174  * @ret process         Process next command
 175  */
 176 static int process_always ( int rc __unused ) {
 177         return 1;
 178 }
 179
 180 /**
 181  * Find command terminator
 182  *
 183  * @v tokens            Token list
 184  * @ret process_next    "Should next command be processed?" function
 185  * @ret argc            Argument count
 186  */
 187 static int command_terminator ( char **tokens,
 188                                 int ( **process_next ) ( int rc ) ) {
 189         unsigned int i;
 190
 191         /* Find first terminating token */
 192         for ( i = 0 ; tokens[i] ; i++ ) {
 193                 if ( tokens[i][0] == '#' ) {
 194                         /* Start of a comment */
 195                         break;
 196                 } else if ( strcmp ( tokens[i], "||" ) == 0 ) {
 197                         /* Short-circuit logical OR */
 198                         *process_next = process_on_failure;
 199                         return i;
 200                 } else if ( strcmp ( tokens[i], "&&" ) == 0 ) {
 201                         /* Short-circuit logical AND */
 202                         *process_next = process_on_success;
 203                         return i;
 204                 } else if ( strcmp ( tokens[i], ";" ) == 0 ) {
 205                         /* Process next command unconditionally */
 206                         *process_next = process_always;
 207                         return i;
 208                 }
 209         }
 210
 211         /* End of token list */
 212         *process_next = NULL;
 213         return i;
 214 }
 215
 216 /**
 217  * Set shell stop state
 218  *
 219  * @v stop              Shell stop state
 220  */
 221 void shell_stop ( int stop ) {
 222         stop_state = stop;
 223 }
 224
 225 /**
 226  * Test and consume shell stop state
 227  *
 228  * @v stop              Shell stop state to consume
 229  * @v stopped           Shell had been stopped
 230  */
 231 int shell_stopped ( int stop ) {
 232         int stopped;
 233
 234         /* Test to see if we need to stop */
 235         stopped = ( stop_state >= stop );
 236
 237         /* Consume stop state */
 238         if ( stop_state <= stop )
 239                 stop_state = 0;
 240
 241         return stopped;
 242 }
 243
 244 /**
 245  * Expand settings within a token list
 246  *
 247  * @v argc              Argument count
 248  * @v tokens            Token list
 249  * @v argv              Argument list to fill in
 250  * @ret rc              Return status code
 251  */
 252 static int expand_tokens ( int argc, char **tokens, char **argv ) {
 253         int i;
 254
 255         /* Expand each token in turn */
 256         for ( i = 0 ; i < argc ; i++ ) {
 257                 argv[i] = expand_settings ( tokens[i] );
 258                 if ( ! argv[i] )
 259                         goto err_expand_settings;
 260         }
 261
 262         return 0;
 263
 264  err_expand_settings:
 265         assert ( argv[i] == NULL );
 266         for ( ; i >= 0 ; i-- )
 267                 free ( argv[i] );
 268         return -ENOMEM;
 269 }
 270
 271 /**
 272  * Free an expanded token list
 273  *
 274  * @v argv              Argument list
 275  */
 276 static void free_tokens ( char **argv ) {
 277
 278         /* Free each expanded argument */
 279         while ( *argv )
 280                 free ( *(argv++) );
 281 }
 282
 283 /**
 284  * Execute command line
 285  *
 286  * @v command           Command line
 287  * @ret rc              Return status code
 288  *
 289  * Execute the named command and arguments.
 290  */
 291 int system ( const char *command ) {
 292         int count = split_command ( ( char * ) command, NULL );
 293         char *all_tokens[ count + 1 ];
 294         int ( * process_next ) ( int rc );
 295         char *command_copy;
 296         char **tokens;
 297         int argc;
 298         int process;
 299         int rc = 0;
 300
 301         /* Create modifiable copy of command */
 302         command_copy = strdup ( command );
 303         if ( ! command_copy )
 304                 return -ENOMEM;
 305
 306         /* Split command into tokens */
 307         split_command ( command_copy, all_tokens );
 308         all_tokens[count] = NULL;
 309
 310         /* Process individual commands */
 311         process = 1;
 312         for ( tokens = all_tokens ; ; tokens += ( argc + 1 ) ) {
 313
 314                 /* Find command terminator */
 315                 argc = command_terminator ( tokens, &process_next );
 316
 317                 /* Expand tokens and execute command */
 318                 if ( process ) {
 319                         char *argv[ argc + 1 ];
 320
 321                         /* Expand tokens */
 322                         if ( ( rc = expand_tokens ( argc, tokens, argv ) ) != 0)
 323                                 break;
 324                         argv[argc] = NULL;
 325
 326                         /* Execute command */
 327                         rc = execv ( argv[0], argv );
 328
 329                         /* Free tokens */
 330                         free_tokens ( argv );
 331                 }
 332
 333                 /* Stop processing, if applicable */
 334                 if ( shell_stopped ( SHELL_STOP_COMMAND ) )
 335                         break;
 336
 337                 /* Stop processing if we have reached the end of the
 338                  * command.
 339                  */
 340                 if ( ! process_next )
 341                         break;
 342
 343                 /* Determine whether or not to process next command */
 344                 process = process_next ( rc );
 345         }
 346
 347         /* Free modified copy of command */
 348         free ( command_copy );
 349
 350         return rc;
 351 }
 352
 353 /**
 354  * Concatenate arguments
 355  *
 356  * @v args              Argument list (NULL-terminated)
 357  * @ret string          Concatenated arguments
 358  *
 359  * The returned string is allocated with malloc().  The caller is
 360  * responsible for eventually free()ing this string.
 361  */
 362 char * concat_args ( char **args ) {
 363         char **arg;
 364         size_t len;
 365         char *string;
 366         char *ptr;
 367
 368         /* Calculate total string length */
 369         len = 1 /* NUL */;
 370         for ( arg = args ; *arg ; arg++ )
 371                 len += ( 1 /* possible space */ + strlen ( *arg ) );
 372
 373         /* Allocate string */
 374         string = zalloc ( len );
 375         if ( ! string )
 376                 return NULL;
 377
 378         /* Populate string */
 379         ptr = string;
 380         for ( arg = args ; *arg ; arg++ ) {
 381                 ptr += sprintf ( ptr, "%s%s",
 382                                  ( ( arg == args ) ? "" : " " ), *arg );
 383         }
 384         assert ( ptr < ( string + len ) );
 385
 386         return string;
 387 }
 388
 389 /** "echo" options */
 390 struct echo_options {
 391         /** Do not print trailing newline */
 392         int no_newline;
 393 };
 394
 395 /** "echo" option list */
 396 static struct option_descriptor echo_opts[] = {
 397         OPTION_DESC ( "n", 'n', no_argument,
 398                       struct echo_options, no_newline, parse_flag ),
 399 };
 400
 401 /** "echo" command descriptor */
 402 static struct command_descriptor echo_cmd =
 403         COMMAND_DESC ( struct echo_options, echo_opts, 0, MAX_ARGUMENTS,
 404                        "[...]" );
 405
 406 /**
 407  * "echo" command
 408  *
 409  * @v argc              Argument count
 410  * @v argv              Argument list
 411  * @ret rc              Return status code
 412  */
 413 static int echo_exec ( int argc, char **argv ) {
 414         struct echo_options opts;
 415         char *text;
 416         int rc;
 417
 418         /* Parse options */
 419         if ( ( rc = parse_options ( argc, argv, &echo_cmd, &opts ) ) != 0 )
 420                 return rc;
 421
 422         /* Parse text */
 423         text = concat_args ( &argv[optind] );
 424         if ( ! text )
 425                 return -ENOMEM;
 426
 427         /* Print text */
 428         printf ( "%s%s", text, ( opts.no_newline ? "" : "\n" ) );
 429
 430         free ( text );
 431         return 0;
 432 }
 433
 434 /** "echo" command */
 435 struct command echo_command __command = {
 436         .name = "echo",
 437         .exec = echo_exec,
 438 };
 439
 440 /** "exit" options */
 441 struct exit_options {};
 442
 443 /** "exit" option list */
 444 static struct option_descriptor exit_opts[] = {};
 445
 446 /** "exit" command descriptor */
 447 static struct command_descriptor exit_cmd =
 448         COMMAND_DESC ( struct exit_options, exit_opts, 0, 1, "[<status>]" );
 449
 450 /**
 451  * "exit" command
 452  *
 453  * @v argc              Argument count
 454  * @v argv              Argument list
 455  * @ret rc              Return status code
 456  */
 457 static int exit_exec ( int argc, char **argv ) {
 458         struct exit_options opts;
 459         unsigned int exit_code = 0;
 460         int rc;
 461
 462         /* Parse options */
 463         if ( ( rc = parse_options ( argc, argv, &exit_cmd, &opts ) ) != 0 )
 464                 return rc;
 465
 466         /* Parse exit status, if present */
 467         if ( optind != argc ) {
 468                 if ( ( rc = parse_integer ( argv[optind], &exit_code ) ) != 0 )
 469                         return rc;
 470         }
 471
 472         /* Stop shell processing */
 473         shell_stop ( SHELL_STOP_COMMAND_SEQUENCE );
 474
 475         return exit_code;
 476 }
 477
 478 /** "exit" command */
 479 struct command exit_command __command = {
 480         .name = "exit",
 481         .exec = exit_exec,
 482 };
 483
 484 /** "isset" options */
 485 struct isset_options {};
 486
 487 /** "isset" option list */
 488 static struct option_descriptor isset_opts[] = {};
 489
 490 /** "isset" command descriptor */
 491 static struct command_descriptor isset_cmd =
 492         COMMAND_DESC ( struct isset_options, isset_opts, 1, 1, "<value>" );
 493
 494 /**
 495  * "isset" command
 496  *
 497  * @v argc              Argument count
 498  * @v argv              Argument list
 499  * @ret rc              Return status code
 500  */
 501 static int isset_exec ( int argc, char **argv ) {
 502         struct isset_options opts;
 503         int rc;
 504
 505         /* Parse options */
 506         if ( ( rc = parse_options ( argc, argv, &isset_cmd, &opts ) ) != 0 )
 507                 return rc;
 508
 509         /* Return success iff argument is non-empty */
 510         return ( argv[optind][0] ? 0 : -ENOENT );
 511 }
 512
 513 /** "isset" command */
 514 struct command isset_command __command = {
 515         .name = "isset",
 516         .exec = isset_exec,
 517 };
 518
 519 /** "iseq" options */
 520 struct iseq_options {};
 521
 522 /** "iseq" option list */
 523 static struct option_descriptor iseq_opts[] = {};
 524
 525 /** "iseq" command descriptor */
 526 static struct command_descriptor iseq_cmd =
 527         COMMAND_DESC ( struct iseq_options, iseq_opts, 2, 2,
 528                        "<value1> <value2>" );
 529
 530 /**
 531  * "iseq" command
 532  *
 533  * @v argc              Argument count
 534  * @v argv              Argument list
 535  * @ret rc              Return status code
 536  */
 537 static int iseq_exec ( int argc, char **argv ) {
 538         struct iseq_options opts;
 539         int rc;
 540
 541         /* Parse options */
 542         if ( ( rc = parse_options ( argc, argv, &iseq_cmd, &opts ) ) != 0 )
 543                 return rc;
 544
 545         /* Return success iff arguments are equal */
 546         return ( ( strcmp ( argv[optind], argv[ optind + 1 ] ) == 0 ) ?
 547                  0 : -ERANGE );
 548 }
 549
 550 /** "iseq" command */
 551 struct command iseq_command __command = {
 552         .name = "iseq",
 553         .exec = iseq_exec,
 554 };
 555
 556 /** "sleep" options */
 557 struct sleep_options {};
 558
 559 /** "sleep" option list */
 560 static struct option_descriptor sleep_opts[] = {};
 561
 562 /** "sleep" command descriptor */
 563 static struct command_descriptor sleep_cmd =
 564         COMMAND_DESC ( struct sleep_options, sleep_opts, 1, 1, "<seconds>" );
 565
 566 /**
 567  * "sleep" command
 568  *
 569  * @v argc              Argument count
 570  * @v argv              Argument list
 571  * @ret rc              Return status code
 572  */
 573 static int sleep_exec ( int argc, char **argv ) {
 574         struct sleep_options opts;
 575         unsigned int seconds;
 576         unsigned long start;
 577         unsigned long delay;
 578         int rc;
 579
 580         /* Parse options */
 581         if ( ( rc = parse_options ( argc, argv, &sleep_cmd, &opts ) ) != 0 )
 582                 return rc;
 583
 584         /* Parse number of seconds */
 585         if ( ( rc = parse_integer ( argv[optind], &seconds ) ) != 0 )
 586                 return rc;
 587
 588         /* Delay for specified number of seconds */
 589         start = currticks();
 590         delay = ( seconds * TICKS_PER_SEC );
 591         while ( ( currticks() - start ) <= delay ) {
 592                 step();
 593                 if ( iskey() && ( getchar() == CTRL_C ) )
 594                         return -ECANCELED;
 595                 cpu_nap();
 596         }
 597
 598         return 0;
 599 }
 600
 601 /** "sleep" command */
 602 struct command sleep_command __command = {
 603         .name = "sleep",
 604         .exec = sleep_exec,
 605 };