[cmdline] Add setting expansion using ${...} syntax
[people/dverkamp/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 static struct command commands[0]
38         __table_start ( struct command, commands );
39 static struct command commands_end[0]
40         __table_end ( struct command, commands );
41
42 /* Avoid dragging in getopt.o unless a command really uses it */
43 int optind;
44 int nextchar;
45
46 /**
47  * Execute command
48  *
49  * @v command           Command name
50  * @v argv              Argument list
51  * @ret rc              Command exit status
52  *
53  * Execute the named command.  Unlike a traditional POSIX execv(),
54  * this function returns the exit status of the command.
55  */
56 int execv ( const char *command, char * const argv[] ) {
57         struct command *cmd;
58         int argc;
59
60         /* Count number of arguments */
61         for ( argc = 0 ; argv[argc] ; argc++ ) {}
62
63         /* Sanity checks */
64         if ( ! command ) {
65                 DBG ( "No command\n" );
66                 return -EINVAL;
67         }
68         if ( ! argc ) {
69                 DBG ( "%s: empty argument list\n", command );
70                 return -EINVAL;
71         }
72
73         /* Reset getopt() library ready for use by the command.  This
74          * is an artefact of the POSIX getopt() API within the context
75          * of Etherboot; see the documentation for reset_getopt() for
76          * details.
77          */
78         reset_getopt();
79
80         /* Hand off to command implementation */
81         for ( cmd = commands ; cmd < commands_end ; cmd++ ) {
82                 if ( strcmp ( command, cmd->name ) == 0 )
83                         return cmd->exec ( argc, ( char ** ) argv );
84         }
85
86         printf ( "%s: command not found\n", command );
87         return -ENOEXEC;
88 }
89
90 /**
91  * Expand variables within command line
92  *
93  * @v command           Command line
94  * @ret expcmd          Expanded command line
95  *
96  * The expanded command line is allocated with malloc() and the caller
97  * must eventually free() it.
98  */
99 static char * expand_command ( const char *command ) {
100         char *expcmd;
101         char *start;
102         char *end;
103         char *head;
104         char *name;
105         char *tail;
106         int setting_len;
107         int new_len;
108         char *tmp;
109
110         /* Obtain temporary modifiable copy of command line */
111         expcmd = strdup ( command );
112         if ( ! expcmd )
113                 return NULL;
114
115         /* Expand while expansions remain */
116         while ( 1 ) {
117
118                 head = expcmd;
119
120                 /* Locate opener */
121                 start = strstr ( expcmd, "${" );
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         return expcmd;
158 }
159
160 /**
161  * Split command line into argv array
162  *
163  * @v args              Command line
164  * @v argv              Argument array to populate, or NULL
165  * @ret argc            Argument count
166  *
167  * Splits the command line into whitespace-delimited arguments.  If @c
168  * argv is non-NULL, any whitespace in the command line will be
169  * replaced with NULs.
170  */
171 static int split_args ( char *args, char * argv[] ) {
172         int argc = 0;
173
174         while ( 1 ) {
175                 /* Skip over any whitespace / convert to NUL */
176                 while ( *args == ' ' ) {
177                         if ( argv )
178                                 *args = '\0';
179                         args++;
180                 }
181                 /* Check for end of line */
182                 if ( ! *args )
183                         break;
184                 /* We have found the start of the next argument */
185                 if ( argv )
186                         argv[argc] = args;
187                 argc++;
188                 /* Skip to start of next whitespace, if any */
189                 while ( *args && ( *args != ' ' ) ) {
190                         args++;
191                 }
192         }
193         return argc;
194 }
195
196 /**
197  * Execute command line
198  *
199  * @v command           Command line
200  * @ret rc              Command exit status
201  *
202  * Execute the named command and arguments.
203  */
204 int system ( const char *command ) {
205         char *args;
206         int argc;
207         int rc = 0;
208
209         /* Perform variable expansion */
210         args = expand_command ( command );
211         if ( ! args )
212                 return -ENOMEM;
213
214         /* Count arguments */
215         argc = split_args ( args, NULL );
216
217         /* Create argv array and execute command */
218         if ( argc ) {
219                 char * argv[argc + 1];
220                 
221                 split_args ( args, argv );
222                 argv[argc] = NULL;
223
224                 if ( argv[0][0] != '#' )
225                         rc = execv ( argv[0], argv );
226         }
227
228         free ( args );
229         return rc;
230 }
231
232 /**
233  * The "echo" command
234  *
235  * @v argc              Argument count
236  * @v argv              Argument list
237  * @ret rc              Exit code
238  */
239 static int echo_exec ( int argc, char **argv ) {
240         int i;
241
242         for ( i = 1 ; i < argc ; i++ ) {
243                 printf ( "%s%s", ( ( i == 1 ) ? "" : " " ), argv[i] );
244         }
245         printf ( "\n" );
246         return 0;
247 }
248
249 /** "echo" command */
250 struct command echo_command __command = {
251         .name = "echo",
252         .exec = echo_exec,
253 };