[fdt] Add ability to parse a MAC address from a flattened device tree
[ipxe.git] / src / image / script.c
1 /*
2 * Copyright (C) 2007 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., 51 Franklin Street, Fifth Floor, Boston, MA
17 * 02110-1301, USA.
18 *
19 * You can also choose to distribute this program under the terms of
20 * the Unmodified Binary Distribution Licence (as given in the file
21 * COPYING.UBDL), provided that you have satisfied its requirements.
22 */
23
24 FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
25
26 /**
27 * @file
28 *
29 * iPXE scripts
30 *
31 */
32
33 #include <string.h>
34 #include <stdlib.h>
35 #include <stdio.h>
36 #include <ctype.h>
37 #include <errno.h>
38 #include <getopt.h>
39 #include <ipxe/command.h>
40 #include <ipxe/parseopt.h>
41 #include <ipxe/image.h>
42 #include <ipxe/shell.h>
43 #include <usr/prompt.h>
44 #include <ipxe/script.h>
45
46 /** Offset within current script
47 *
48 * This is a global in order to allow goto_exec() to update the
49 * offset.
50 */
51 static size_t script_offset;
52
53 /**
54 * Process script lines
55 *
56 * @v image Script
57 * @v process_line Line processor
58 * @v terminate Termination check
59 * @ret rc Return status code
60 */
61 static int process_script ( struct image *image,
62 int ( * process_line ) ( struct image *image,
63 size_t offset,
64 const char *label,
65 const char *command ),
66 int ( * terminate ) ( int rc ) ) {
67 size_t len = 0;
68 char *line = NULL;
69 size_t line_offset;
70 char *label;
71 char *command;
72 off_t eol;
73 size_t frag_len;
74 char *tmp;
75 int rc;
76
77 /* Initialise script and line offsets */
78 script_offset = 0;
79 line_offset = 0;
80
81 do {
82
83 /* Find length of next line, excluding any terminating '\n' */
84 eol = memchr_user ( image->data, script_offset, '\n',
85 ( image->len - script_offset ) );
86 if ( eol < 0 )
87 eol = image->len;
88 frag_len = ( eol - script_offset );
89
90 /* Allocate buffer for line */
91 tmp = realloc ( line, ( len + frag_len + 1 /* NUL */ ) );
92 if ( ! tmp ) {
93 rc = -ENOMEM;
94 goto err_alloc;
95 }
96 line = tmp;
97
98 /* Copy line */
99 copy_from_user ( ( line + len ), image->data, script_offset,
100 frag_len );
101 len += frag_len;
102
103 /* Move to next line in script */
104 script_offset += ( frag_len + 1 );
105
106 /* Strip trailing CR, if present */
107 if ( len && ( line[ len - 1 ] == '\r' ) )
108 len--;
109
110 /* Handle backslash continuations */
111 if ( len && ( line[ len - 1 ] == '\\' ) ) {
112 len--;
113 rc = -EINVAL;
114 continue;
115 }
116
117 /* Terminate line */
118 line[len] = '\0';
119
120 /* Split line into (optional) label and command */
121 command = line;
122 while ( isspace ( *command ) )
123 command++;
124 if ( *command == ':' ) {
125 label = ++command;
126 while ( *command && ! isspace ( *command ) )
127 command++;
128 if ( *command )
129 *(command++) = '\0';
130 } else {
131 label = NULL;
132 }
133
134 /* Process line */
135 rc = process_line ( image, line_offset, label, command );
136 if ( terminate ( rc ) )
137 goto err_process;
138
139 /* Free line */
140 free ( line );
141 line = NULL;
142 len = 0;
143
144 /* Update line offset */
145 line_offset = script_offset;
146
147 } while ( script_offset < image->len );
148
149 err_process:
150 err_alloc:
151 free ( line );
152 return rc;
153 }
154
155 /**
156 * Terminate script processing on shell exit or command failure
157 *
158 * @v rc Line processing status
159 * @ret terminate Terminate script processing
160 */
161 static int terminate_on_exit_or_failure ( int rc ) {
162
163 return ( shell_stopped ( SHELL_STOP_COMMAND_SEQUENCE ) ||
164 ( rc != 0 ) );
165 }
166
167 /**
168 * Execute script line
169 *
170 * @v image Script
171 * @v offset Offset within script
172 * @v label Label, or NULL
173 * @v command Command
174 * @ret rc Return status code
175 */
176 static int script_exec_line ( struct image *image, size_t offset,
177 const char *label __unused,
178 const char *command ) {
179 int rc;
180
181 DBGC ( image, "[%04zx] $ %s\n", offset, command );
182
183 /* Execute command */
184 if ( ( rc = system ( command ) ) != 0 )
185 return rc;
186
187 return 0;
188 }
189
190 /**
191 * Execute script
192 *
193 * @v image Script
194 * @ret rc Return status code
195 */
196 static int script_exec ( struct image *image ) {
197 size_t saved_offset;
198 int rc;
199
200 /* Temporarily de-register image, so that a "boot" command
201 * doesn't throw us into an execution loop.
202 */
203 unregister_image ( image );
204
205 /* Preserve state of any currently-running script */
206 saved_offset = script_offset;
207
208 /* Process script */
209 rc = process_script ( image, script_exec_line,
210 terminate_on_exit_or_failure );
211
212 /* Restore saved state */
213 script_offset = saved_offset;
214
215 /* Re-register image (unless we have been replaced) */
216 if ( ! image->replacement )
217 register_image ( image );
218
219 return rc;
220 }
221
222 /**
223 * Probe script image
224 *
225 * @v image Script
226 * @ret rc Return status code
227 */
228 static int script_probe ( struct image *image ) {
229 static const char ipxe_magic[] = "#!ipxe";
230 static const char gpxe_magic[] = "#!gpxe";
231 linker_assert ( sizeof ( ipxe_magic ) == sizeof ( gpxe_magic ),
232 magic_size_mismatch );
233 char test[ sizeof ( ipxe_magic ) - 1 /* NUL */
234 + 1 /* terminating space */];
235
236 /* Sanity check */
237 if ( image->len < sizeof ( test ) ) {
238 DBGC ( image, "Too short to be a script\n" );
239 return -ENOEXEC;
240 }
241
242 /* Check for magic signature */
243 copy_from_user ( test, image->data, 0, sizeof ( test ) );
244 if ( ! ( ( ( memcmp ( test, ipxe_magic, sizeof ( test ) - 1 ) == 0 ) ||
245 ( memcmp ( test, gpxe_magic, sizeof ( test ) - 1 ) == 0 )) &&
246 isspace ( test[ sizeof ( test ) - 1 ] ) ) ) {
247 DBGC ( image, "Invalid magic signature\n" );
248 return -ENOEXEC;
249 }
250
251 return 0;
252 }
253
254 /** Script image type */
255 struct image_type script_image_type __image_type ( PROBE_NORMAL ) = {
256 .name = "script",
257 .probe = script_probe,
258 .exec = script_exec,
259 };
260
261 /** "goto" options */
262 struct goto_options {};
263
264 /** "goto" option list */
265 static struct option_descriptor goto_opts[] = {};
266
267 /** "goto" command descriptor */
268 static struct command_descriptor goto_cmd =
269 COMMAND_DESC ( struct goto_options, goto_opts, 1, 1, "<label>" );
270
271 /**
272 * Current "goto" label
273 *
274 * Valid only during goto_exec(). Consider this part of a closure.
275 */
276 static const char *goto_label;
277
278 /**
279 * Check for presence of label
280 *
281 * @v image Script
282 * @v offset Offset within script
283 * @v label Label
284 * @v command Command
285 * @ret rc Return status code
286 */
287 static int goto_find_label ( struct image *image, size_t offset,
288 const char *label, const char *command __unused ) {
289
290 /* Check label exists */
291 if ( ! label )
292 return -ENOENT;
293
294 /* Check label matches */
295 if ( strcmp ( goto_label, label ) != 0 )
296 return -ENOENT;
297
298 /* Update script offset */
299 script_offset = offset;
300 DBGC ( image, "[%04zx] Gone to :%s\n", offset, label );
301
302 return 0;
303 }
304
305 /**
306 * Terminate script processing when label is found
307 *
308 * @v rc Line processing status
309 * @ret terminate Terminate script processing
310 */
311 static int terminate_on_label_found ( int rc ) {
312 return ( rc == 0 );
313 }
314
315 /**
316 * "goto" command
317 *
318 * @v argc Argument count
319 * @v argv Argument list
320 * @ret rc Return status code
321 */
322 static int goto_exec ( int argc, char **argv ) {
323 struct goto_options opts;
324 size_t saved_offset;
325 int rc;
326
327 /* Parse options */
328 if ( ( rc = parse_options ( argc, argv, &goto_cmd, &opts ) ) != 0 )
329 return rc;
330
331 /* Sanity check */
332 if ( ! current_image ) {
333 rc = -ENOTTY;
334 printf ( "Not in a script: %s\n", strerror ( rc ) );
335 return rc;
336 }
337
338 /* Parse label */
339 goto_label = argv[optind];
340
341 /* Find label */
342 saved_offset = script_offset;
343 if ( ( rc = process_script ( current_image, goto_find_label,
344 terminate_on_label_found ) ) != 0 ) {
345 script_offset = saved_offset;
346 DBGC ( current_image, "[%04zx] No such label :%s\n",
347 script_offset, goto_label );
348 return rc;
349 }
350
351 /* Terminate processing of current command */
352 shell_stop ( SHELL_STOP_COMMAND );
353
354 return 0;
355 }
356
357 /** "goto" command */
358 struct command goto_command __command = {
359 .name = "goto",
360 .exec = goto_exec,
361 };
362
363 /** "prompt" options */
364 struct prompt_options {
365 /** Key to wait for */
366 unsigned int key;
367 /** Timeout */
368 unsigned long timeout;
369 };
370
371 /** "prompt" option list */
372 static struct option_descriptor prompt_opts[] = {
373 OPTION_DESC ( "key", 'k', required_argument,
374 struct prompt_options, key, parse_key ),
375 OPTION_DESC ( "timeout", 't', required_argument,
376 struct prompt_options, timeout, parse_timeout ),
377 };
378
379 /** "prompt" command descriptor */
380 static struct command_descriptor prompt_cmd =
381 COMMAND_DESC ( struct prompt_options, prompt_opts, 0, MAX_ARGUMENTS,
382 "[<text>]" );
383
384 /**
385 * "prompt" command
386 *
387 * @v argc Argument count
388 * @v argv Argument list
389 * @ret rc Return status code
390 */
391 static int prompt_exec ( int argc, char **argv ) {
392 struct prompt_options opts;
393 char *text;
394 int rc;
395
396 /* Parse options */
397 if ( ( rc = parse_options ( argc, argv, &prompt_cmd, &opts ) ) != 0 )
398 goto err_parse;
399
400 /* Parse prompt text */
401 text = concat_args ( &argv[optind] );
402 if ( ! text ) {
403 rc = -ENOMEM;
404 goto err_concat;
405 }
406
407 /* Display prompt and wait for key */
408 if ( ( rc = prompt ( text, opts.timeout, opts.key ) ) != 0 )
409 goto err_prompt;
410
411 /* Free prompt text */
412 free ( text );
413
414 return 0;
415
416 err_prompt:
417 free ( text );
418 err_concat:
419 err_parse:
420 return rc;
421 }
422
423 /** "prompt" command */
424 struct command prompt_command __command = {
425 .name = "prompt",
426 .exec = prompt_exec,
427 };