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