Command execution. More...

#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
#include <unistd.h>
#include <getopt.h>
#include <errno.h>
#include <assert.h>
#include <ipxe/tables.h>
#include <ipxe/command.h>
#include <ipxe/parseopt.h>
#include <ipxe/settings.h>
#include <ipxe/shell.h>

Data Structures
struct	echo_options
	"echo" options More...

struct	exit_options
	"exit" options More...

struct	isset_options
	"isset" options More...

struct	iseq_options
	"iseq" options More...

struct	sleep_options
	"sleep" options More...

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)

	FILE_SECBOOT (PERMITTED)

int	execv (const char command, char const argv[])
	Execute command. More...

static int	split_command (char command, char *tokens)
	Split command line into tokens. More...

static int	process_on_success (int rc)
	Process next command only if previous command succeeded. More...

static int	process_on_failure (int rc)
	Process next command only if previous command failed. More...

static int	process_always (int rc __unused)
	Process next command regardless of status from previous command. More...

static int	command_terminator (char tokens, int(process_next)(int rc))
	Find command terminator. More...

void	shell_stop (int stop)
	Set shell stop state. More...

int	shell_stopped (int stop)
	Test and consume shell stop state. More...

static int	expand_tokens (int argc, char tokens, char argv)
	Expand settings within a token list. More...

static void	free_tokens (char **argv)
	Free an expanded token list. More...

int	system (const char *command)
	Execute command line. More...

char *	concat_args (char **args)
	Concatenate arguments. More...

static int	echo_exec (int argc, char **argv)
	"echo" command More...

	COMMAND (echo, echo_exec)
	"echo" command More...

static int	exit_exec (int argc, char **argv)
	"exit" command More...

	COMMAND (exit, exit_exec)
	"exit" command More...

static int	isset_exec (int argc, char **argv)
	"isset" command More...

	COMMAND (isset, isset_exec)
	"isset" command More...

static int	iseq_exec (int argc, char **argv)
	"iseq" command More...

	COMMAND (iseq, iseq_exec)
	"iseq" command More...

static int	sleep_exec (int argc, char **argv)
	"sleep" command More...

	COMMAND (sleep, sleep_exec)
	"sleep" command More...

Variables
static int	stop_state
	Shell stop state. More...

static struct option_descriptor	echo_opts []
	"echo" option list More...

static struct command_descriptor	echo_cmd
	"echo" command descriptor More...

static struct option_descriptor	exit_opts [] = {}
	"exit" option list More...

static struct command_descriptor	exit_cmd
	"exit" command descriptor More...

static struct option_descriptor	isset_opts [] = {}
	"isset" option list More...

static struct command_descriptor	isset_cmd
	"isset" command descriptor More...

static struct option_descriptor	iseq_opts [] = {}
	"iseq" option list More...

static struct command_descriptor	iseq_cmd
	"iseq" command descriptor More...

static struct option_descriptor	sleep_opts [] = {}
	"sleep" option list More...

static struct command_descriptor	sleep_cmd
	"sleep" command descriptor More...

Detailed Description

Command execution.

Definition in file exec.c.

Function Documentation

◆ FILE_LICENCE()

FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL )

◆ FILE_SECBOOT()

FILE_SECBOOT ( PERMITTED )

◆ execv()

int execv	(	const char *	command,
		char *const	argv[]
	)

Execute command.

Parameters

command	Command name
argv	Argument list

Return values

rc	Return status code

Execute the named command. Unlike a traditional POSIX execv(), this function returns the exit status of the command.

Definition at line 61 of file exec.c.

                                                        {
         struct command *cmd;
         int argc;
         int rc;
 
         /* Count number of arguments */
         for ( argc = 0 ; argv[argc] ; argc++ ) {}
 
         /* An empty command is deemed to do nothing, successfully */
         if ( command == NULL ) {
                 rc = 0;
                 goto done;
         }
 
         /* Sanity checks */
         if ( argc == 0 ) {
                 DBG ( "%s: empty argument list\n", command );
                 rc = -EINVAL;
                 goto done;
         }
 
         /* 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 */
         for_each_table_entry ( cmd, COMMANDS ) {
                 if ( strcmp ( command, cmd->name ) == 0 ) {
                         rc = cmd->exec ( argc, ( char ** ) argv );
                         goto done;
                 }
         }
 
         printf ( "%s: command not found\n", command );
         rc = -ENOEXEC;
 
  done:
         /* Store error number, if an error occurred */
         if ( rc ) {
                 errno = rc;
                 if ( errno < 0 )
                         errno = -errno;
         }
 
         return rc;
 }

References cmd, COMMANDS, DBG, done, EINVAL, ENOEXEC, errno, for_each_table_entry, NULL, printf(), rc, reset_getopt(), and strcmp().

Referenced by system(), and time_exec().

◆ split_command()

static int split_command	(	char *	command,
		char **	tokens
	)

static

Split command line into tokens.

Parameters

command	Command line
tokens	Token list to populate, or NULL

Return values

count Number of tokens

Splits the command line into whitespace-delimited tokens. If tokens is non-NULL, any whitespace in the command line will be replaced with NULs.

Definition at line 122 of file exec.c.

                                                           {
         int count = 0;
 
         while ( 1 ) {
                 /* Skip over any whitespace / convert to NUL */
                 while ( isspace ( *command ) ) {
                         if ( tokens )
                                 *command = '\0';
                         command++;
                 }
                 /* Check for end of line */
                 if ( ! *command )
                         break;
                 /* We have found the start of the next argument */
                 if ( tokens )
                         tokens[count] = command;
                 count++;
                 /* Skip to start of next whitespace, if any */
                 while ( *command && ! isspace ( *command ) ) {
                         command++;
                 }
         }
         return count;
 }

References command, count, and isspace().

Referenced by system().

◆ process_on_success()

static int process_on_success ( int rc )

static

Process next command only if previous command succeeded.

Parameters

rc	Status of previous command

Return values

process Process next command

Definition at line 153 of file exec.c.

                                          {
         return ( rc == 0 );
 }

References rc.

Referenced by command_terminator().

◆ process_on_failure()

static int process_on_failure ( int rc )

static

Process next command only if previous command failed.

Parameters

rc	Status of previous command

Return values

process Process next command

Definition at line 163 of file exec.c.

                                          {
         return ( rc != 0 );
 }

References rc.

Referenced by command_terminator().

◆ process_always()

static int process_always ( int rc __unused )

static

Process next command regardless of status from previous command.

Parameters

rc	Status of previous command

Return values

process Process next command

Definition at line 173 of file exec.c.

                                               {
         return 1;
 }

Referenced by command_terminator().

◆ command_terminator()

static int command_terminator	(	char **	tokens,
		int(**)(int rc)	process_next
	)

static

Find command terminator.

Parameters

tokens Token list

Return values

process_next	"Should next command be processed?" function
argc	Argument count

Definition at line 184 of file exec.c.

                                                                     {
         unsigned int i;
 
         /* Find first terminating token */
         for ( i = 0 ; tokens[i] ; i++ ) {
                 if ( tokens[i][0] == '#' ) {
                         /* Start of a comment */
                         break;
                 } else if ( strcmp ( tokens[i], "||" ) == 0 ) {
                         /* Short-circuit logical OR */
                         *process_next = process_on_failure;
                         return i;
                 } else if ( strcmp ( tokens[i], "&&" ) == 0 ) {
                         /* Short-circuit logical AND */
                         *process_next = process_on_success;
                         return i;
                 } else if ( strcmp ( tokens[i], ";" ) == 0 ) {
                         /* Process next command unconditionally */
                         *process_next = process_always;
                         return i;
                 }
         }
 
         /* End of token list */
         *process_next = NULL;
         return i;
 }

References NULL, process_always(), process_on_failure(), process_on_success(), and strcmp().

Referenced by system().

◆ shell_stop()

void shell_stop ( int stop )

Set shell stop state.

Parameters

stop	Shell stop state

Definition at line 218 of file exec.c.

                              {
         stop_state = stop;
 }

References stop_state.

Referenced by exit_exec(), goto_exec(), and imgexec().

◆ shell_stopped()

int shell_stopped ( int stop )

Test and consume shell stop state.

Parameters

stop	Shell stop state to consume
stopped	Shell had been stopped

Definition at line 228 of file exec.c.

                                {
         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;
 }

References stop_state.

Referenced by shell(), system(), and terminate_on_exit_or_failure().

◆ expand_tokens()

static int expand_tokens	(	int	argc,
		char **	tokens,
		char **	argv
	)

static

Expand settings within a token list.

Parameters

argc	Argument count
tokens	Token list
argv	Argument list to fill in

Return values

rc	Return status code

Definition at line 249 of file exec.c.

                                                                   {
         int i;
 
         /* Expand each token in turn */
         for ( i = 0 ; i < argc ; i++ ) {
                 argv[i] = expand_settings ( tokens[i] );
                 if ( ! argv[i] )
                         goto err_expand_settings;
         }
 
         return 0;
 
  err_expand_settings:
         assert ( argv[i] == NULL );
         for ( ; i >= 0 ; i-- )
                 free ( argv[i] );
         return -ENOMEM;
 }

References assert(), ENOMEM, expand_settings(), free, and NULL.

Referenced by system().

◆ free_tokens()

static void free_tokens ( char ** argv )

static

Free an expanded token list.

Parameters

argv	Argument list

Definition at line 273 of file exec.c.

                                         {
 
         /* Free each expanded argument */
         while ( *argv )
                 free ( *(argv++) );
 }

References free.

Referenced by system().

◆ system()

int system ( const char * command )

Execute command line.

Parameters

command Command line

Return values

rc	Return status code

Execute the named command and arguments.

Definition at line 288 of file exec.c.

                                    {
         int count = split_command ( ( char * ) command, NULL );
         char *all_tokens[ count + 1 ];
         int ( * process_next ) ( int rc );
         char *command_copy;
         char **tokens;
         int argc;
         int process;
         int rc = 0;
 
         /* Create modifiable copy of command */
         command_copy = strdup ( command );
         if ( ! command_copy )
                 return -ENOMEM;
 
         /* Split command into tokens */
         split_command ( command_copy, all_tokens );
         all_tokens[count] = NULL;
 
         /* Process individual commands */
         process = 1;
         for ( tokens = all_tokens ; ; tokens += ( argc + 1 ) ) {
 
                 /* Find command terminator */
                 argc = command_terminator ( tokens, &process_next );
 
                 /* Expand tokens and execute command */
                 if ( process ) {
                         char *argv[ argc + 1 ];
 
                         /* Expand tokens */
                         if ( ( rc = expand_tokens ( argc, tokens, argv ) ) != 0)
                                 break;
                         argv[argc] = NULL;
 
                         /* Execute command */
                         rc = execv ( argv[0], argv );
 
                         /* Free tokens */
                         free_tokens ( argv );
                 }
 
                 /* Stop processing, if applicable */
                 if ( shell_stopped ( SHELL_STOP_COMMAND ) )
                         break;
 
                 /* Stop processing if we have reached the end of the
                  * command.
                  */
                 if ( ! process_next )
                         break;
 
                 /* Determine whether or not to process next command */
                 process = process_next ( rc );
         }
 
         /* Free modified copy of command */
         free ( command_copy );
 
         return rc;
 }

References command_terminator(), count, ENOMEM, execv(), expand_tokens(), free, free_tokens(), NULL, rc, SHELL_STOP_COMMAND, shell_stopped(), split_command(), and strdup().

◆ concat_args()

char* concat_args ( char ** args )

Concatenate arguments.

Parameters

args	Argument list (NULL-terminated)

Return values

string Concatenated arguments

The returned string is allocated with malloc(). The caller is responsible for eventually free()ing this string.

Definition at line 359 of file exec.c.

                                    {
         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",
                                  ( ( arg == args ) ? "" : " " ), *arg );
         }
         assert ( ptr < ( string + len ) );
 
         return string;
 }

References assert(), len, NULL, sprintf, string, strlen(), and zalloc().

Referenced by dynui_exec(), echo_exec(), imgsingle_exec(), item_exec(), param_exec(), prompt_exec(), and set_value().

◆ echo_exec()

static int echo_exec	(	int	argc,
		char **	argv
	)

static

"echo" command

Parameters

argc	Argument count
argv	Argument list

Return values

rc	Return status code

Definition at line 410 of file exec.c.

                                                {
         struct echo_options opts;
         char *text;
         int rc;
 
         /* Parse options */
         if ( ( rc = parse_options ( argc, argv, &echo_cmd, &opts ) ) != 0 )
                 return rc;
 
         /* Parse text */
         text = concat_args ( &argv[optind] );
         if ( ! text )
                 return -ENOMEM;
 
         /* Print text */
         printf ( "%s%s", text, ( opts.no_newline ? "" : "\n" ) );
 
         free ( text );
         return 0;
 }

References concat_args(), echo_cmd, ENOMEM, free, optind, opts, parse_options(), printf(), and rc.

◆ COMMAND() [1/5]

COMMAND	(	echo	,
		echo_exec
	)

"echo" command

◆ exit_exec()

static int exit_exec	(	int	argc,
		char **	argv
	)

static

"exit" command

Parameters

argc	Argument count
argv	Argument list

Return values

rc	Return status code

Definition at line 451 of file exec.c.

                                                {
         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;
         }
 
         /* Stop shell processing */
         shell_stop ( SHELL_STOP_COMMAND_SEQUENCE );
 
         return exit_code;
 }

References exit_cmd, optind, opts, parse_integer(), parse_options(), rc, shell_stop(), and SHELL_STOP_COMMAND_SEQUENCE.

◆ COMMAND() [2/5]

COMMAND	(	exit	,
		exit_exec
	)

"exit" command

◆ isset_exec()

static int isset_exec	(	int	argc,
		char **	argv
	)

static

"isset" command

Parameters

argc	Argument count
argv	Argument list

Return values

rc	Return status code

Definition at line 492 of file exec.c.

                                                 {
         struct isset_options opts;
         int rc;
 
         /* Parse options */
         if ( ( rc = parse_options ( argc, argv, &isset_cmd, &opts ) ) != 0 )
                 return rc;
 
         /* Return success iff argument is non-empty */
         return ( argv[optind][0] ? 0 : -ENOENT );
 }

References ENOENT, isset_cmd, optind, opts, parse_options(), and rc.

◆ COMMAND() [3/5]

COMMAND	(	isset	,
		isset_exec
	)

"isset" command

◆ iseq_exec()

static int iseq_exec	(	int	argc,
		char **	argv
	)

static

"iseq" command

Parameters

argc	Argument count
argv	Argument list

Return values

rc	Return status code

Definition at line 525 of file exec.c.

                                                {
         struct iseq_options opts;
         int rc;
 
         /* Parse options */
         if ( ( rc = parse_options ( argc, argv, &iseq_cmd, &opts ) ) != 0 )
                 return rc;
 
         /* Return success iff arguments are equal */
         return ( ( strcmp ( argv[optind], argv[ optind + 1 ] ) == 0 ) ?
                  0 : -ERANGE );
 }

References ERANGE, iseq_cmd, optind, opts, parse_options(), rc, and strcmp().

◆ COMMAND() [4/5]

COMMAND	(	iseq	,
		iseq_exec
	)

"iseq" command

◆ sleep_exec()

static int sleep_exec	(	int	argc,
		char **	argv
	)

static

"sleep" command

Parameters

argc	Argument count
argv	Argument list

Return values

rc	Return status code

Definition at line 558 of file exec.c.

                                                 {
         struct sleep_options opts;
         unsigned int seconds;
         int rc;
 
         /* Parse options */
         if ( ( rc = parse_options ( argc, argv, &sleep_cmd, &opts ) ) != 0 )
                 return rc;
 
         /* Parse number of seconds */
         if ( ( rc = parse_integer ( argv[optind], &seconds ) ) != 0 )
                 return rc;
 
         /* Delay for specified number of seconds */
         if ( sleep ( seconds ) != 0 )
                 return -ECANCELED;
 
         return 0;
 }

References ECANCELED, optind, opts, parse_integer(), parse_options(), rc, seconds, sleep(), and sleep_cmd.

◆ COMMAND() [5/5]

COMMAND	(	sleep	,
		sleep_exec
	)

"sleep" command

Variable Documentation

◆ stop_state

int stop_state

static

Shell stop state.

Definition at line 49 of file exec.c.

Referenced by shell_stop(), and shell_stopped().

◆ echo_opts

struct option_descriptor echo_opts[]

static

Initial value:

= {
        OPTION_DESC ( "n", 'n', no_argument,
                      struct echo_options, no_newline, parse_flag ),
}

"echo" option list

Definition at line 393 of file exec.c.

◆ echo_cmd

struct command_descriptor echo_cmd

static

Initial value:

=
        COMMAND_DESC ( struct echo_options, echo_opts, 0, MAX_ARGUMENTS,
                       "[...]" )

"echo" command descriptor

Definition at line 399 of file exec.c.

Referenced by echo_exec().

◆ exit_opts

struct option_descriptor exit_opts[] = {}

static

"exit" option list

Definition at line 438 of file exec.c.

◆ exit_cmd

struct command_descriptor exit_cmd

static

Initial value:

=

COMMAND_DESC ( struct exit_options, exit_opts, 0, 1, "[<status>]" )

exit_opts

static struct option_descriptor exit_opts[]

"exit" option list

Definition: exec.c:438

COMMAND_DESC

#define COMMAND_DESC(_struct, _options, _min_args, _max_args, _usage)

Construct command descriptor.

Definition: parseopt.h:109

exit_options

"exit" options

Definition: exec.c:435

"exit" command descriptor

Definition at line 441 of file exec.c.

Referenced by exit_exec().

◆ isset_opts

struct option_descriptor isset_opts[] = {}

static

"isset" option list

Definition at line 479 of file exec.c.

◆ isset_cmd

struct command_descriptor isset_cmd

static

Initial value:

=

COMMAND_DESC ( struct isset_options, isset_opts, 1, 1, "<value>" )

isset_options

"isset" options

Definition: exec.c:476

isset_opts

static struct option_descriptor isset_opts[]

"isset" option list

Definition: exec.c:479

COMMAND_DESC

#define COMMAND_DESC(_struct, _options, _min_args, _max_args, _usage)

Construct command descriptor.

Definition: parseopt.h:109

"isset" command descriptor

Definition at line 482 of file exec.c.

Referenced by isset_exec().

◆ iseq_opts

struct option_descriptor iseq_opts[] = {}

static

"iseq" option list

Definition at line 511 of file exec.c.

◆ iseq_cmd

struct command_descriptor iseq_cmd

static

Initial value:

=
        COMMAND_DESC ( struct iseq_options, iseq_opts, 2, 2,
                       "<value1> <value2>" )

"iseq" command descriptor

Definition at line 514 of file exec.c.

Referenced by iseq_exec().

◆ sleep_opts

struct option_descriptor sleep_opts[] = {}

static

"sleep" option list

Definition at line 545 of file exec.c.

◆ sleep_cmd

struct command_descriptor sleep_cmd

static

Initial value:

=

COMMAND_DESC ( struct sleep_options, sleep_opts, 1, 1, "<seconds>" )

sleep_opts

static struct option_descriptor sleep_opts[]

"sleep" option list

Definition: exec.c:545

sleep_options

"sleep" options

Definition: exec.c:542

COMMAND_DESC

#define COMMAND_DESC(_struct, _options, _min_args, _max_args, _usage)

Construct command descriptor.

Definition: parseopt.h:109

"sleep" command descriptor

Definition at line 548 of file exec.c.

Referenced by sleep_exec().

Data Structures

Functions

Variables

Detailed Description

Function Documentation

◆ FILE_LICENCE()

◆ FILE_SECBOOT()

◆ execv()

◆ split_command()

◆ process_on_success()

◆ process_on_failure()

◆ process_always()

◆ command_terminator()

◆ shell_stop()

◆ shell_stopped()

◆ expand_tokens()

◆ free_tokens()

◆ system()

◆ concat_args()

◆ echo_exec()

◆ COMMAND() [1/5]

◆ exit_exec()

◆ COMMAND() [2/5]

◆ isset_exec()

◆ COMMAND() [3/5]

◆ iseq_exec()

◆ COMMAND() [4/5]

◆ sleep_exec()

◆ COMMAND() [5/5]

Variable Documentation

◆ stop_state

◆ echo_opts

◆ echo_cmd

◆ exit_opts

◆ exit_cmd

◆ isset_opts

◆ isset_cmd

◆ iseq_opts

◆ iseq_cmd

◆ sleep_opts

◆ sleep_cmd