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