2006-12-08 02:23:11 +01:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2006 Michael Brown <mbrown@fensystems.co.uk>.
|
|
|
|
*
|
|
|
|
* 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; either version 2 of the
|
|
|
|
* License, or any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will 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, write to the Free Software
|
|
|
|
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
|
*/
|
|
|
|
|
2009-05-01 16:41:06 +02:00
|
|
|
FILE_LICENCE ( GPL2_OR_LATER );
|
|
|
|
|
2006-12-08 02:23:11 +01:00
|
|
|
#include <stdint.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <stdlib.h>
|
2007-01-19 02:13:12 +01:00
|
|
|
#include <stdio.h>
|
2009-06-03 11:13:29 +02:00
|
|
|
#include <ctype.h>
|
2006-12-08 02:23:11 +01:00
|
|
|
#include <unistd.h>
|
|
|
|
#include <getopt.h>
|
|
|
|
#include <errno.h>
|
|
|
|
#include <assert.h>
|
2010-04-19 21:16:01 +02:00
|
|
|
#include <ipxe/tables.h>
|
|
|
|
#include <ipxe/command.h>
|
2010-11-22 21:20:33 +01:00
|
|
|
#include <ipxe/parseopt.h>
|
2010-04-19 21:16:01 +02:00
|
|
|
#include <ipxe/settings.h>
|
2010-11-29 15:19:59 +01:00
|
|
|
#include <ipxe/shell.h>
|
2006-12-08 02:23:11 +01:00
|
|
|
|
|
|
|
/** @file
|
|
|
|
*
|
|
|
|
* Command execution
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2010-11-29 15:19:59 +01:00
|
|
|
/** Shell stop state */
|
|
|
|
static int stop_state;
|
2006-12-19 17:27:15 +01:00
|
|
|
|
2006-12-08 02:23:11 +01:00
|
|
|
/**
|
|
|
|
* Execute command
|
|
|
|
*
|
|
|
|
* @v command Command name
|
|
|
|
* @v argv Argument list
|
2010-11-29 15:19:59 +01:00
|
|
|
* @ret rc Return status code
|
2006-12-08 02:23:11 +01:00
|
|
|
*
|
|
|
|
* Execute the named command. Unlike a traditional POSIX execv(),
|
|
|
|
* this function returns the exit status of the command.
|
|
|
|
*/
|
|
|
|
int execv ( const char *command, char * const argv[] ) {
|
|
|
|
struct command *cmd;
|
2006-12-08 18:07:12 +01:00
|
|
|
int argc;
|
2006-12-08 02:23:11 +01:00
|
|
|
|
|
|
|
/* Count number of arguments */
|
2006-12-08 18:07:12 +01:00
|
|
|
for ( argc = 0 ; argv[argc] ; argc++ ) {}
|
|
|
|
|
2010-11-22 02:47:07 +01:00
|
|
|
/* An empty command is deemed to do nothing, successfully */
|
|
|
|
if ( command == NULL )
|
|
|
|
return 0;
|
|
|
|
|
2006-12-08 18:07:12 +01:00
|
|
|
/* Sanity checks */
|
2010-11-22 02:47:07 +01:00
|
|
|
if ( argc == 0 ) {
|
2006-12-08 18:07:12 +01:00
|
|
|
DBG ( "%s: empty argument list\n", command );
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2006-12-08 02:23:11 +01:00
|
|
|
|
|
|
|
/* Reset getopt() library ready for use by the command. This
|
|
|
|
* is an artefact of the POSIX getopt() API within the context
|
|
|
|
* of Etherboot; see the documentation for reset_getopt() for
|
|
|
|
* details.
|
|
|
|
*/
|
|
|
|
reset_getopt();
|
|
|
|
|
|
|
|
/* Hand off to command implementation */
|
2009-03-12 20:41:40 +01:00
|
|
|
for_each_table_entry ( cmd, COMMANDS ) {
|
2006-12-08 02:23:11 +01:00
|
|
|
if ( strcmp ( command, cmd->name ) == 0 )
|
|
|
|
return cmd->exec ( argc, ( char ** ) argv );
|
|
|
|
}
|
|
|
|
|
|
|
|
printf ( "%s: command not found\n", command );
|
|
|
|
return -ENOEXEC;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2010-11-22 02:47:07 +01:00
|
|
|
* Split command line into tokens
|
2006-12-08 02:23:11 +01:00
|
|
|
*
|
2010-11-22 02:47:07 +01:00
|
|
|
* @v command Command line
|
|
|
|
* @v tokens Token list to populate, or NULL
|
|
|
|
* @ret count Number of tokens
|
2006-12-08 02:23:11 +01:00
|
|
|
*
|
2010-11-22 02:47:07 +01:00
|
|
|
* Splits the command line into whitespace-delimited tokens. If @c
|
|
|
|
* tokens is non-NULL, any whitespace in the command line will be
|
2006-12-08 02:23:11 +01:00
|
|
|
* replaced with NULs.
|
|
|
|
*/
|
2010-11-22 02:47:07 +01:00
|
|
|
static int split_command ( char *command, char **tokens ) {
|
|
|
|
int count = 0;
|
2006-12-08 02:23:11 +01:00
|
|
|
|
|
|
|
while ( 1 ) {
|
|
|
|
/* Skip over any whitespace / convert to NUL */
|
2010-11-22 02:47:07 +01:00
|
|
|
while ( isspace ( *command ) ) {
|
|
|
|
if ( tokens )
|
|
|
|
*command = '\0';
|
|
|
|
command++;
|
2006-12-08 02:23:11 +01:00
|
|
|
}
|
|
|
|
/* Check for end of line */
|
2010-11-22 02:47:07 +01:00
|
|
|
if ( ! *command )
|
2006-12-08 02:23:11 +01:00
|
|
|
break;
|
|
|
|
/* We have found the start of the next argument */
|
2010-11-22 02:47:07 +01:00
|
|
|
if ( tokens )
|
|
|
|
tokens[count] = command;
|
|
|
|
count++;
|
2006-12-08 02:23:11 +01:00
|
|
|
/* Skip to start of next whitespace, if any */
|
2010-11-22 02:47:07 +01:00
|
|
|
while ( *command && ! isspace ( *command ) ) {
|
|
|
|
command++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2010-11-29 15:19:59 +01:00
|
|
|
* Process next command only if previous command succeeded
|
2010-11-22 02:47:07 +01:00
|
|
|
*
|
|
|
|
* @v rc Status of previous command
|
2010-11-29 15:19:59 +01:00
|
|
|
* @ret process Process next command
|
2010-11-22 02:47:07 +01:00
|
|
|
*/
|
2010-11-29 15:19:59 +01:00
|
|
|
static int process_on_success ( int rc ) {
|
2010-11-22 02:47:07 +01:00
|
|
|
return ( rc == 0 );
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2010-11-29 15:19:59 +01:00
|
|
|
* Process next command only if previous command failed
|
2010-11-22 02:47:07 +01:00
|
|
|
*
|
|
|
|
* @v rc Status of previous command
|
2010-11-29 15:19:59 +01:00
|
|
|
* @ret process Process next command
|
2010-11-22 02:47:07 +01:00
|
|
|
*/
|
2010-11-29 15:19:59 +01:00
|
|
|
static int process_on_failure ( int rc ) {
|
2010-11-22 02:47:07 +01:00
|
|
|
return ( rc != 0 );
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Find command terminator
|
|
|
|
*
|
|
|
|
* @v tokens Token list
|
2010-11-29 15:19:59 +01:00
|
|
|
* @ret process_next "Should next command be processed?" function
|
2010-11-22 02:47:07 +01:00
|
|
|
* @ret argc Argument count
|
|
|
|
*/
|
|
|
|
static int command_terminator ( char **tokens,
|
2010-11-29 15:19:59 +01:00
|
|
|
int ( **process_next ) ( int rc ) ) {
|
2010-11-22 02:47:07 +01:00
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
/* Find first terminating token */
|
|
|
|
for ( i = 0 ; tokens[i] ; i++ ) {
|
|
|
|
if ( tokens[i][0] == '#' ) {
|
|
|
|
/* Start of a comment */
|
2010-11-29 15:19:59 +01:00
|
|
|
break;
|
2010-11-22 02:47:07 +01:00
|
|
|
} else if ( strcmp ( tokens[i], "||" ) == 0 ) {
|
|
|
|
/* Short-circuit logical OR */
|
2010-11-29 15:19:59 +01:00
|
|
|
*process_next = process_on_failure;
|
2010-11-22 02:47:07 +01:00
|
|
|
return i;
|
|
|
|
} else if ( strcmp ( tokens[i], "&&" ) == 0 ) {
|
|
|
|
/* Short-circuit logical AND */
|
2010-11-29 15:19:59 +01:00
|
|
|
*process_next = process_on_success;
|
2010-11-22 02:47:07 +01:00
|
|
|
return i;
|
2006-12-08 02:23:11 +01:00
|
|
|
}
|
|
|
|
}
|
2010-11-22 02:47:07 +01:00
|
|
|
|
|
|
|
/* End of token list */
|
2010-11-29 15:19:59 +01:00
|
|
|
*process_next = NULL;
|
2010-11-22 02:47:07 +01:00
|
|
|
return i;
|
2006-12-08 02:23:11 +01:00
|
|
|
}
|
|
|
|
|
2010-11-29 15:19:59 +01:00
|
|
|
/**
|
|
|
|
* Set shell stop state
|
|
|
|
*
|
|
|
|
* @v stop Shell stop state
|
|
|
|
*/
|
|
|
|
void shell_stop ( int stop ) {
|
|
|
|
stop_state = stop;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Test and consume shell stop state
|
|
|
|
*
|
|
|
|
* @v stop Shell stop state to consume
|
|
|
|
* @v stopped Shell had been stopped
|
|
|
|
*/
|
|
|
|
int shell_stopped ( int stop ) {
|
|
|
|
int stopped;
|
|
|
|
|
|
|
|
/* Test to see if we need to stop */
|
|
|
|
stopped = ( stop_state >= stop );
|
|
|
|
|
|
|
|
/* Consume stop state */
|
|
|
|
if ( stop_state <= stop )
|
|
|
|
stop_state = 0;
|
|
|
|
|
|
|
|
return stopped;
|
|
|
|
}
|
|
|
|
|
2006-12-08 02:23:11 +01:00
|
|
|
/**
|
|
|
|
* Execute command line
|
|
|
|
*
|
|
|
|
* @v command Command line
|
2010-11-29 15:19:59 +01:00
|
|
|
* @ret rc Return status code
|
2006-12-08 02:23:11 +01:00
|
|
|
*
|
|
|
|
* Execute the named command and arguments.
|
|
|
|
*/
|
|
|
|
int system ( const char *command ) {
|
2010-11-29 15:19:59 +01:00
|
|
|
int ( * process_next ) ( int rc );
|
2010-11-22 02:47:07 +01:00
|
|
|
char *expcmd;
|
|
|
|
char **argv;
|
2006-12-08 02:23:11 +01:00
|
|
|
int argc;
|
2010-11-22 02:47:07 +01:00
|
|
|
int count;
|
2010-11-29 15:19:59 +01:00
|
|
|
int process;
|
2007-01-12 09:56:48 +01:00
|
|
|
int rc = 0;
|
2006-12-08 04:07:15 +01:00
|
|
|
|
2008-07-27 02:08:20 +02:00
|
|
|
/* Perform variable expansion */
|
2011-01-28 01:16:18 +01:00
|
|
|
expcmd = expand_settings ( command );
|
2010-11-22 02:47:07 +01:00
|
|
|
if ( ! expcmd )
|
2006-12-08 02:23:11 +01:00
|
|
|
return -ENOMEM;
|
|
|
|
|
2010-11-22 02:47:07 +01:00
|
|
|
/* Count tokens */
|
|
|
|
count = split_command ( expcmd, NULL );
|
2006-12-08 02:23:11 +01:00
|
|
|
|
2010-11-22 02:47:07 +01:00
|
|
|
/* Create token array */
|
|
|
|
if ( count ) {
|
|
|
|
char * tokens[count + 1];
|
2006-12-08 02:23:11 +01:00
|
|
|
|
2010-11-22 02:47:07 +01:00
|
|
|
split_command ( expcmd, tokens );
|
|
|
|
tokens[count] = NULL;
|
2010-11-29 15:19:59 +01:00
|
|
|
process = 1;
|
2010-11-22 02:47:07 +01:00
|
|
|
|
|
|
|
for ( argv = tokens ; ; argv += ( argc + 1 ) ) {
|
2007-01-12 09:56:48 +01:00
|
|
|
|
2010-11-22 02:47:07 +01:00
|
|
|
/* Find command terminator */
|
2010-11-29 15:19:59 +01:00
|
|
|
argc = command_terminator ( argv, &process_next );
|
2010-11-22 02:47:07 +01:00
|
|
|
|
|
|
|
/* Execute command */
|
2010-11-29 15:19:59 +01:00
|
|
|
if ( process ) {
|
|
|
|
argv[argc] = NULL;
|
|
|
|
rc = execv ( argv[0], argv );
|
|
|
|
}
|
2010-11-22 02:47:07 +01:00
|
|
|
|
2010-11-29 15:19:59 +01:00
|
|
|
/* Stop processing, if applicable */
|
|
|
|
if ( shell_stopped ( SHELL_STOP_COMMAND ) )
|
2010-11-22 21:20:33 +01:00
|
|
|
break;
|
|
|
|
|
2010-11-29 15:19:59 +01:00
|
|
|
/* Stop processing if we have reached the end
|
|
|
|
* of the command.
|
|
|
|
*/
|
|
|
|
if ( ! process_next )
|
2010-11-22 02:47:07 +01:00
|
|
|
break;
|
2010-11-29 15:19:59 +01:00
|
|
|
|
|
|
|
/* Determine whether or not to process next command */
|
|
|
|
process = process_next ( rc );
|
2010-11-22 02:47:07 +01:00
|
|
|
}
|
2006-12-08 02:23:11 +01:00
|
|
|
}
|
2006-12-08 04:07:15 +01:00
|
|
|
|
2010-11-22 02:47:07 +01:00
|
|
|
/* Free expanded command */
|
|
|
|
free ( expcmd );
|
|
|
|
|
2006-12-08 04:07:15 +01:00
|
|
|
return rc;
|
2006-12-08 02:23:11 +01:00
|
|
|
}
|
2008-07-27 02:08:20 +02:00
|
|
|
|
2011-03-07 19:31:38 +01:00
|
|
|
/**
|
|
|
|
* Concatenate arguments
|
|
|
|
*
|
|
|
|
* @v args Argument list (NULL-terminated)
|
|
|
|
* @ret string Concatenated arguments
|
|
|
|
*
|
|
|
|
* The returned string is allocated with malloc(). The caller is
|
|
|
|
* responsible for eventually free()ing this string.
|
|
|
|
*/
|
|
|
|
char * concat_args ( char **args ) {
|
|
|
|
char **arg;
|
|
|
|
size_t len;
|
|
|
|
char *string;
|
|
|
|
char *ptr;
|
|
|
|
|
|
|
|
/* Calculate total string length */
|
|
|
|
len = 1 /* NUL */;
|
|
|
|
for ( arg = args ; *arg ; arg++ )
|
|
|
|
len += ( 1 /* possible space */ + strlen ( *arg ) );
|
|
|
|
|
|
|
|
/* Allocate string */
|
|
|
|
string = zalloc ( len );
|
|
|
|
if ( ! string )
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
/* Populate string */
|
|
|
|
ptr = string;
|
|
|
|
for ( arg = args ; *arg ; arg++ ) {
|
|
|
|
ptr += sprintf ( ptr, "%s%s",
|
|
|
|
( ( ptr == string ) ? "" : " " ), *arg );
|
|
|
|
}
|
|
|
|
assert ( ptr < ( string + len ) );
|
|
|
|
|
|
|
|
return string;
|
|
|
|
}
|
|
|
|
|
2008-07-27 02:08:20 +02:00
|
|
|
/**
|
2010-11-22 21:20:33 +01:00
|
|
|
* "echo" command
|
2008-07-27 02:08:20 +02:00
|
|
|
*
|
|
|
|
* @v argc Argument count
|
|
|
|
* @v argv Argument list
|
2010-11-29 15:19:59 +01:00
|
|
|
* @ret rc Return status code
|
2008-07-27 02:08:20 +02:00
|
|
|
*/
|
2011-03-07 19:31:38 +01:00
|
|
|
static int echo_exec ( int argc __unused, char **argv ) {
|
|
|
|
char *text;
|
2008-07-27 02:08:20 +02:00
|
|
|
|
2011-03-07 19:31:38 +01:00
|
|
|
text = concat_args ( &argv[1] );
|
|
|
|
if ( ! text )
|
|
|
|
return -ENOMEM;
|
|
|
|
printf ( "%s\n", text );
|
|
|
|
free ( text );
|
2008-07-27 02:08:20 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/** "echo" command */
|
|
|
|
struct command echo_command __command = {
|
|
|
|
.name = "echo",
|
|
|
|
.exec = echo_exec,
|
|
|
|
};
|
2010-11-22 21:20:33 +01:00
|
|
|
|
|
|
|
/** "exit" options */
|
|
|
|
struct exit_options {};
|
|
|
|
|
|
|
|
/** "exit" option list */
|
|
|
|
static struct option_descriptor exit_opts[] = {};
|
|
|
|
|
|
|
|
/** "exit" command descriptor */
|
|
|
|
static struct command_descriptor exit_cmd =
|
2011-03-04 13:14:51 +01:00
|
|
|
COMMAND_DESC ( struct exit_options, exit_opts, 0, 1, "[<status>]" );
|
2010-11-22 21:20:33 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* "exit" command
|
|
|
|
*
|
|
|
|
* @v argc Argument count
|
|
|
|
* @v argv Argument list
|
|
|
|
* @ret rc Return status code
|
|
|
|
*/
|
|
|
|
static int exit_exec ( int argc, char **argv ) {
|
|
|
|
struct exit_options opts;
|
|
|
|
unsigned int exit_code = 0;
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
/* Parse options */
|
|
|
|
if ( ( rc = parse_options ( argc, argv, &exit_cmd, &opts ) ) != 0 )
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
/* Parse exit status, if present */
|
|
|
|
if ( optind != argc ) {
|
|
|
|
if ( ( rc = parse_integer ( argv[optind], &exit_code ) ) != 0 )
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2010-11-29 15:19:59 +01:00
|
|
|
/* Stop shell processing */
|
|
|
|
shell_stop ( SHELL_STOP_COMMAND_SEQUENCE );
|
2010-11-22 21:20:33 +01:00
|
|
|
|
|
|
|
return exit_code;
|
|
|
|
}
|
|
|
|
|
|
|
|
/** "exit" command */
|
|
|
|
struct command exit_command __command = {
|
|
|
|
.name = "exit",
|
|
|
|
.exec = exit_exec,
|
|
|
|
};
|
|
|
|
|
2010-11-22 21:41:17 +01:00
|
|
|
/** "isset" options */
|
|
|
|
struct isset_options {};
|
|
|
|
|
|
|
|
/** "isset" option list */
|
|
|
|
static struct option_descriptor isset_opts[] = {};
|
|
|
|
|
|
|
|
/** "isset" command descriptor */
|
|
|
|
static struct command_descriptor isset_cmd =
|
|
|
|
COMMAND_DESC ( struct isset_options, isset_opts, 0, MAX_ARGUMENTS,
|
2011-03-04 13:14:51 +01:00
|
|
|
"[...]" );
|
2010-11-22 21:41:17 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* "isset" command
|
|
|
|
*
|
|
|
|
* @v argc Argument count
|
|
|
|
* @v argv Argument list
|
|
|
|
* @ret rc Return status code
|
|
|
|
*/
|
|
|
|
static int isset_exec ( int argc, char **argv ) {
|
|
|
|
struct isset_options opts;
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
/* Parse options */
|
|
|
|
if ( ( rc = parse_options ( argc, argv, &isset_cmd, &opts ) ) != 0 )
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
/* Return success iff any arguments exist */
|
|
|
|
return ( ( optind == argc ) ? -ENOENT : 0 );
|
|
|
|
}
|
|
|
|
|
|
|
|
/** "isset" command */
|
|
|
|
struct command isset_command __command = {
|
|
|
|
.name = "isset",
|
|
|
|
.exec = isset_exec,
|
|
|
|
};
|