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., 675 Mass Ave, Cambridge, MA 02139, USA.
  17  */
  18
  19 FILE_LICENCE ( GPL2_OR_LATER );
  20
  21 #include <stdint.h>
  22 #include <string.h>
  23 #include <stdlib.h>
  24 #include <stdio.h>
  25 #include <ctype.h>
  26 #include <unistd.h>
  27 #include <getopt.h>
  28 #include <errno.h>
  29 #include <assert.h>
  30 #include <gpxe/tables.h>
  31 #include <gpxe/command.h>
  32 #include <gpxe/settings.h>
  33
  34 /** @file
  35  *
  36  * Command execution
  37  *
  38  */
  39
  40 /* Avoid dragging in getopt.o unless a command really uses it */
  41 int optind;
  42 int nextchar;
  43
  44 /**
  45  * Execute command
  46  *
  47  * @v command           Command name
  48  * @v argv              Argument list
  49  * @ret rc              Command exit status
  50  *
  51  * Execute the named command.  Unlike a traditional POSIX execv(),
  52  * this function returns the exit status of the command.
  53  */
  54 int execv ( const char *command, char * const argv[] ) {
  55         struct command *cmd;
  56         int argc;
  57
  58         /* Count number of arguments */
  59         for ( argc = 0 ; argv[argc] ; argc++ ) {}
  60
  61         /* Sanity checks */
  62         if ( ! command ) {
  63                 DBG ( "No command\n" );
  64                 return -EINVAL;
  65         }
  66         if ( ! argc ) {
  67                 DBG ( "%s: empty argument list\n", command );
  68                 return -EINVAL;
  69         }
  70
  71         /* Reset getopt() library ready for use by the command.  This
  72          * is an artefact of the POSIX getopt() API within the context
  73          * of Etherboot; see the documentation for reset_getopt() for
  74          * details.
  75          */
  76         reset_getopt();
  77
  78         /* Hand off to command implementation */
  79         for_each_table_entry ( cmd, COMMANDS ) {
  80                 if ( strcmp ( command, cmd->name ) == 0 )
  81                         return cmd->exec ( argc, ( char ** ) argv );
  82         }
  83
  84         printf ( "%s: command not found\n", command );
  85         return -ENOEXEC;
  86 }
  87
  88 /**
  89  * Expand variables within command line
  90  *
  91  * @v command           Command line
  92  * @ret expcmd          Expanded command line
  93  *
  94  * The expanded command line is allocated with malloc() and the caller
  95  * must eventually free() it.
  96  */
  97 static char * expand_command ( const char *command ) {
  98         char *expcmd;
  99         char *start;
 100         char *end;
 101         char *head;
 102         char *name;
 103         char *tail;
 104         int setting_len;
 105         int new_len;
 106         char *tmp;
 107
 108         /* Obtain temporary modifiable copy of command line */
 109         expcmd = strdup ( command );
 110         if ( ! expcmd )
 111                 return NULL;
 112
 113         /* Expand while expansions remain */
 114         while ( 1 ) {
 115
 116                 head = expcmd;
 117
 118                 /* Locate opener */
 119                 start = strstr ( expcmd, "${" );
 120                 if ( ! start )
 121                         break;
 122                 *start = '\0';
 123                 name = ( start + 2 );
 124
 125                 /* Locate closer */
 126                 end = strstr ( name, "}" );
 127                 if ( ! end )
 128                         break;
 129                 *end = '\0';
 130                 tail = ( end + 1 );
 131
 132                 /* Determine setting length */
 133                 setting_len = fetchf_named_setting ( name, NULL, 0 );
 134                 if ( setting_len < 0 )
 135                         setting_len = 0; /* Treat error as empty setting */
 136
 137                 /* Read setting into temporary buffer */
 138                 {
 139                         char setting_buf[ setting_len + 1 ];
 140
 141                         setting_buf[0] = '\0';
 142                         fetchf_named_setting ( name, setting_buf,
 143                                                sizeof ( setting_buf ) );
 144
 145                         /* Construct expanded string and discard old string */
 146                         tmp = expcmd;
 147                         new_len = asprintf ( &expcmd, "%s%s%s",
 148                                              head, setting_buf, tail );
 149                         free ( tmp );
 150                         if ( new_len < 0 )
 151                                 return NULL;
 152                 }
 153         }
 154
 155         return expcmd;
 156 }
 157
 158 /**
 159  * Split command line into argv array
 160  *
 161  * @v args              Command line
 162  * @v argv              Argument array to populate, or NULL
 163  * @ret argc            Argument count
 164  *
 165  * Splits the command line into whitespace-delimited arguments.  If @c
 166  * argv is non-NULL, any whitespace in the command line will be
 167  * replaced with NULs.
 168  */
 169 static int split_args ( char *args, char * argv[] ) {
 170         int argc = 0;
 171
 172         while ( 1 ) {
 173                 /* Skip over any whitespace / convert to NUL */
 174                 while ( isspace ( *args ) ) {
 175                         if ( argv )
 176                                 *args = '\0';
 177                         args++;
 178                 }
 179                 /* Check for end of line */
 180                 if ( ! *args )
 181                         break;
 182                 /* We have found the start of the next argument */
 183                 if ( argv )
 184                         argv[argc] = args;
 185                 argc++;
 186                 /* Skip to start of next whitespace, if any */
 187                 while ( *args && ! isspace ( *args ) ) {
 188                         args++;
 189                 }
 190         }
 191         return argc;
 192 }
 193
 194 /**
 195  * Execute command line
 196  *
 197  * @v command           Command line
 198  * @ret rc              Command exit status
 199  *
 200  * Execute the named command and arguments.
 201  */
 202 int system ( const char *command ) {
 203         char *args;
 204         int argc;
 205         int rc = 0;
 206
 207         /* Perform variable expansion */
 208         args = expand_command ( command );
 209         if ( ! args )
 210                 return -ENOMEM;
 211
 212         /* Count arguments */
 213         argc = split_args ( args, NULL );
 214
 215         /* Create argv array and execute command */
 216         if ( argc ) {
 217                 char * argv[argc + 1];
 218
 219                 split_args ( args, argv );
 220                 argv[argc] = NULL;
 221
 222                 if ( argv[0][0] != '#' )
 223                         rc = execv ( argv[0], argv );
 224         }
 225
 226         free ( args );
 227         return rc;
 228 }
 229
 230 /**
 231  * The "echo" command
 232  *
 233  * @v argc              Argument count
 234  * @v argv              Argument list
 235  * @ret rc              Exit code
 236  */
 237 static int echo_exec ( int argc, char **argv ) {
 238         int i;
 239
 240         for ( i = 1 ; i < argc ; i++ ) {
 241                 printf ( "%s%s", ( ( i == 1 ) ? "" : " " ), argv[i] );
 242         }
 243         printf ( "\n" );
 244         return 0;
 245 }
 246
 247 /** "echo" command */
 248 struct command echo_command __command = {
 249         .name = "echo",
 250         .exec = echo_exec,
 251 };