[cmdline] Fix image command-line construction for zero-length argument lists
[people/mdeck/gpxe.git] / src / hci / commands / image_cmd.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., 675 Mass Ave, Cambridge, MA 02139, USA.
17  */
18
19 #include <stdint.h>
20 #include <stdlib.h>
21 #include <stdio.h>
22 #include <errno.h>
23 #include <libgen.h>
24 #include <getopt.h>
25 #include <gpxe/image.h>
26 #include <gpxe/command.h>
27 #include <gpxe/initrd.h>
28 #include <usr/imgmgmt.h>
29
30 /** @file
31  *
32  * Image management commands
33  *
34  */
35
36 enum image_action {
37         IMG_FETCH = 0,
38         IMG_LOAD,
39         IMG_EXEC,
40 };
41
42 /**
43  * Fill in image command line
44  *
45  * @v image             Image
46  * @v nargs             Argument count
47  * @v args              Argument list
48  * @ret rc              Return status code
49  */
50 static int imgfill_cmdline ( struct image *image, unsigned int nargs, 
51                              char **args ) {
52         size_t len;
53         unsigned int i;
54
55         /* Determine total length of command line */
56         len = 1; /* NUL */
57         for ( i = 0 ; i < nargs ; i++ )
58                 len += ( 1 /* possible space */ + strlen ( args[i] ) );
59
60         {
61                 char buf[len];
62                 char *ptr = buf;
63
64                 /* Assemble command line */
65                 buf[0] = '\0';
66                 for ( i = 0 ; i < nargs ; i++ ) {
67                         ptr += sprintf ( ptr, "%s%s", ( i ? " " : "" ),
68                                          args[i] );
69                 }
70                 assert ( ptr < ( buf + len ) );
71
72                 return image_set_cmdline ( image, buf );
73         }
74 }
75
76 /**
77  * "imgfetch"/"module"/"kernel" command syntax message
78  *
79  * @v argv              Argument list
80  */
81 static void imgfetch_core_syntax ( char **argv, enum image_action action ) {
82         static const char *actions[] = {
83                 [IMG_FETCH]     = "Fetch",
84                 [IMG_LOAD]      = "Fetch and load",
85                 [IMG_EXEC]      = "Fetch and execute",
86         };
87
88         printf ( "Usage:\n"
89                  "  %s [-n|--name <name>] filename [arguments...]\n"
90                  "\n"
91                  "%s executable/loadable image\n",
92                  argv[0], actions[action] );
93 }
94
95 /**
96  * The "imgfetch"/"module"/"kernel" command body
97  *
98  * @v image_type        Image type to assign (or NULL)
99  * @v load              Image will be automatically loaded after fetching
100  * @v argc              Argument count
101  * @v argv              Argument list
102  * @ret rc              Return status code
103  */
104 static int imgfetch_core_exec ( struct image_type *image_type,
105                                 enum image_action action,
106                                 int argc, char **argv ) {
107         static struct option longopts[] = {
108                 { "help", 0, NULL, 'h' },
109                 { "name", required_argument, NULL, 'n' },
110                 { NULL, 0, NULL, 0 },
111         };
112         struct image *image;
113         const char *name = NULL;
114         char *filename;
115         int ( * image_register ) ( struct image *image );
116         int c;
117         int rc;
118
119         /* Parse options */
120         while ( ( c = getopt_long ( argc, argv, "hn:",
121                                     longopts, NULL ) ) >= 0 ) {
122                 switch ( c ) {
123                 case 'n':
124                         /* Set image name */
125                         name = optarg;
126                         break;
127                 case 'h':
128                         /* Display help text */
129                 default:
130                         /* Unrecognised/invalid option */
131                         imgfetch_core_syntax ( argv, action );
132                         return -EINVAL;
133                 }
134         }
135
136         /* Need at least a filename remaining after the options */
137         if ( optind == argc ) {
138                 imgfetch_core_syntax ( argv, action );
139                 return -EINVAL;
140         }
141         filename = argv[optind++];
142         if ( ! name )
143                 name = basename ( filename );
144
145         /* Allocate image */
146         image = alloc_image();
147         if ( ! image ) {
148                 printf ( "%s\n", strerror ( -ENOMEM ) );
149                 return -ENOMEM;
150         }
151
152         /* Fill in image name */
153         if ( name ) {
154                 if ( ( rc = image_set_name ( image, name ) ) != 0 )
155                         return rc;
156         }
157
158         /* Set image type (if specified) */
159         image->type = image_type;
160
161         /* Fill in command line */
162         if ( ( rc = imgfill_cmdline ( image, ( argc - optind ),
163                                       &argv[optind] ) ) != 0 )
164                 return rc;
165
166         /* Fetch the image */
167         switch ( action ) {
168         case IMG_FETCH:
169                 image_register = register_image;
170                 break;
171         case IMG_LOAD:
172                 image_register = register_and_autoload_image;
173                 break;
174         case IMG_EXEC:
175                 image_register = register_and_autoexec_image;
176                 break;
177         default:
178                 assert ( 0 );
179                 return -EINVAL;
180         }
181         if ( ( rc = imgfetch ( image, filename, image_register ) ) != 0 ) {
182                 printf ( "Could not fetch %s: %s\n",
183                          filename, strerror ( rc ) );
184                 image_put ( image );
185                 return rc;
186         }
187
188         image_put ( image );
189         return 0;
190 }
191
192 /**
193  * The "imgfetch"/"module" command
194  *
195  * @v argc              Argument count
196  * @v argv              Argument list
197  * @ret rc              Exit code
198  */
199 static int imgfetch_exec ( int argc, char **argv ) {
200         int rc;
201
202         if ( ( rc = imgfetch_core_exec ( NULL, IMG_FETCH,
203                                          argc, argv ) ) != 0 )
204                 return rc;
205
206         return 0;
207 }
208
209 /**
210  * The "kernel" command
211  *
212  * @v argc              Argument count
213  * @v argv              Argument list
214  * @ret rc              Exit code
215  */
216 static int kernel_exec ( int argc, char **argv ) {
217         int rc;
218
219         if ( ( rc = imgfetch_core_exec ( NULL, IMG_LOAD, argc, argv ) ) != 0 )
220                 return rc;
221
222         return 0;
223 }
224
225 /**
226  * The "initrd" command
227  *
228  * @v argc              Argument count
229  * @v argv              Argument list
230  * @ret rc              Exit code
231  */
232 static int initrd_exec ( int argc, char **argv ) {
233         int rc;
234
235         if ( ( rc = imgfetch_core_exec ( &initrd_image_type, IMG_FETCH,
236                                          argc, argv ) ) != 0 )
237                 return rc;
238
239         return 0;
240 }
241
242 /**
243  * "imgload" command syntax message
244  *
245  * @v argv              Argument list
246  */
247 static void imgload_syntax ( char **argv ) {
248         printf ( "Usage:\n"
249                  "  %s <image name>\n"
250                  "\n"
251                  "Load executable/loadable image\n",
252                  argv[0] );
253 }
254
255 /**
256  * The "imgload" command
257  *
258  * @v argc              Argument count
259  * @v argv              Argument list
260  * @ret rc              Exit code
261  */
262 static int imgload_exec ( int argc, char **argv ) {
263         static struct option longopts[] = {
264                 { "help", 0, NULL, 'h' },
265                 { NULL, 0, NULL, 0 },
266         };
267         struct image *image;
268         const char *name;
269         int c;
270         int rc;
271
272         /* Parse options */
273         while ( ( c = getopt_long ( argc, argv, "h", longopts, NULL ) ) >= 0 ){
274                 switch ( c ) {
275                 case 'h':
276                         /* Display help text */
277                 default:
278                         /* Unrecognised/invalid option */
279                         imgload_syntax ( argv );
280                         return 1;
281                 }
282         }
283
284         /* Need exactly one image name remaining after the options */
285         if ( optind != ( argc - 1 ) ) {
286                 imgload_syntax ( argv );
287                 return 1;
288         }
289         name = argv[optind];
290
291         /* Load all specified images */
292         image = find_image ( name );
293         if ( ! image ) {
294                 printf ( "No such image: %s\n", name );
295                 return 1;
296         }
297         if ( ( rc = imgload ( image ) ) != 0 ) {
298                 printf ( "Could not load %s: %s\n", name, strerror ( rc ) );
299                 return rc;
300         }
301
302         return 0;
303 }
304
305 /**
306  * "imgargs" command syntax message
307  *
308  * @v argv              Argument list
309  */
310 static void imgargs_syntax ( char **argv ) {
311         printf ( "Usage:\n"
312                  "  %s <image name> [<arguments>...]\n"
313                  "\n"
314                  "Set arguments for executable/loadable image\n",
315                  argv[0] );
316 }
317
318 /**
319  * The "imgargs" command body
320  *
321  * @v argc              Argument count
322  * @v argv              Argument list
323  * @ret rc              Exit code
324  */
325 static int imgargs_exec ( int argc, char **argv ) {
326         static struct option longopts[] = {
327                 { "help", 0, NULL, 'h' },
328                 { NULL, 0, NULL, 0 },
329         };
330         struct image *image;
331         const char *name;
332         int c;
333         int rc;
334
335         /* Parse options */
336         while ( ( c = getopt_long ( argc, argv, "h", longopts, NULL ) ) >= 0 ){
337                 switch ( c ) {
338                 case 'h':
339                         /* Display help text */
340                 default:
341                         /* Unrecognised/invalid option */
342                         imgargs_syntax ( argv );
343                         return 1;
344                 }
345         }
346
347         /* Need at least an image name remaining after the options */
348         if ( optind == argc ) {
349                 imgargs_syntax ( argv );
350                 return 1;
351         }
352         name = argv[optind++];
353
354         /* Fill in command line */
355         image = find_image ( name );
356         if ( ! image ) {
357                 printf ( "No such image: %s\n", name );
358                 return 1;
359         }
360         if ( ( rc = imgfill_cmdline ( image, ( argc - optind ),
361                                       &argv[optind] ) ) != 0 )
362                 return rc;
363
364
365         return 0;
366 }
367
368 /**
369  * "imgexec" command syntax message
370  *
371  * @v argv              Argument list
372  */
373 static void imgexec_syntax ( char **argv ) {
374         printf ( "Usage:\n"
375                  "  %s <image name>\n"
376                  "\n"
377                  "Execute executable/loadable image\n",
378                  argv[0] );
379 }
380
381 /**
382  * The "imgexec" command
383  *
384  * @v argc              Argument count
385  * @v argv              Argument list
386  * @ret rc              Exit code
387  */
388 static int imgexec_exec ( int argc, char **argv ) {
389         static struct option longopts[] = {
390                 { "help", 0, NULL, 'h' },
391                 { NULL, 0, NULL, 0 },
392         };
393         struct image *image;
394         const char *name = NULL;
395         int c;
396         int rc;
397
398         /* Parse options */
399         while ( ( c = getopt_long ( argc, argv, "h", longopts, NULL ) ) >= 0 ){
400                 switch ( c ) {
401                 case 'h':
402                         /* Display help text */
403                 default:
404                         /* Unrecognised/invalid option */
405                         imgexec_syntax ( argv );
406                         return 1;
407                 }
408         }
409
410         /* Need no more than one image name */
411         if ( optind != argc )
412                 name = argv[optind++];
413         if ( optind != argc ) {
414                 imgexec_syntax ( argv );
415                 return 1;
416         }
417         
418         /* Execute specified image */
419         if ( name ) {
420                 image = find_image ( name );
421                 if ( ! image ) {
422                         printf ( "No such image: %s\n", name );
423                         return 1;
424                 }
425         } else {
426                 image = imgautoselect();
427                 if ( ! image ) {
428                         printf ( "No loaded images\n" );
429                         return 1;
430                 }
431         }
432
433         if ( ( rc = imgexec ( image ) ) != 0 ) {
434                 printf ( "Could not execute %s: %s\n",
435                          image->name, strerror ( rc ) );
436                 return 1;
437         }
438
439         return 0;
440 }
441
442 /**
443  * "imgstat" command syntax message
444  *
445  * @v argv              Argument list
446  */
447 static void imgstat_syntax ( char **argv ) {
448         printf ( "Usage:\n"
449                  "  %s\n"
450                  "\n"
451                  "List executable/loadable images\n",
452                  argv[0] );
453 }
454
455 /**
456  * The "imgstat" command
457  *
458  * @v argc              Argument count
459  * @v argv              Argument list
460  * @ret rc              Exit code
461  */
462 static int imgstat_exec ( int argc, char **argv ) {
463         static struct option longopts[] = {
464                 { "help", 0, NULL, 'h' },
465                 { NULL, 0, NULL, 0 },
466         };
467         struct image *image;
468         int c;
469
470         /* Parse options */
471         while ( ( c = getopt_long ( argc, argv, "h", longopts, NULL ) ) >= 0 ){
472                 switch ( c ) {
473                 case 'h':
474                         /* Display help text */
475                 default:
476                         /* Unrecognised/invalid option */
477                         imgstat_syntax ( argv );
478                         return 1;
479                 }
480         }
481
482         /* No arguments */
483         if ( optind != argc ) {
484                 imgstat_syntax ( argv );
485                 return 1;
486         }
487
488         /* Show status of all images */
489         for_each_image ( image ) {
490                 imgstat ( image );
491         }
492         return 0;
493 }
494
495 /**
496  * "imgstat" command syntax message
497  *
498  * @v argv              Argument list
499  */
500 static void imgfree_syntax ( char **argv ) {
501         printf ( "Usage:\n"
502                  "  %s\n"
503                  "\n"
504                  "Free all executable/loadable images\n",
505                  argv[0] );
506 }
507
508 /**
509  * The "imgfree" command
510  *
511  * @v argc              Argument count
512  * @v argv              Argument list
513  * @ret rc              Exit code
514  */
515 static int imgfree_exec ( int argc, char **argv ) {
516         static struct option longopts[] = {
517                 { "help", 0, NULL, 'h' },
518                 { NULL, 0, NULL, 0 },
519         };
520         struct image *image;
521         struct image *tmp;
522         int c;
523
524         /* Parse options */
525         while ( ( c = getopt_long ( argc, argv, "h", longopts, NULL ) ) >= 0 ){
526                 switch ( c ) {
527                 case 'h':
528                         /* Display help text */
529                 default:
530                         /* Unrecognised/invalid option */
531                         imgfree_syntax ( argv );
532                         return 1;
533                 }
534         }
535
536         /* No arguments */
537         if ( optind != argc ) {
538                 imgfree_syntax ( argv );
539                 return 1;
540         }
541
542         /* Free all images */
543         list_for_each_entry_safe ( image, tmp, &images, list ) {
544                 imgfree ( image );
545         }
546         return 0;
547 }
548
549 /** Image management commands */
550 struct command image_commands[] __command = {
551         {
552                 .name = "imgfetch",
553                 .exec = imgfetch_exec,
554         },
555         {
556                 .name = "module",
557                 .exec = imgfetch_exec, /* synonym for "imgfetch" */
558         },
559         {
560                 .name = "kernel",
561                 .exec = kernel_exec,
562         },
563         {
564                 .name = "initrd",
565                 .exec = initrd_exec,
566         },
567         {
568                 .name = "imgload",
569                 .exec = imgload_exec,
570         },
571         {
572                 .name = "imgargs",
573                 .exec = imgargs_exec,
574         },
575         {
576                 .name = "imgexec",
577                 .exec = imgexec_exec,
578         },
579         {
580                 .name = "boot", /* synonym for "imgexec" */
581                 .exec = imgexec_exec,
582         },
583         {
584                 .name = "imgstat",
585                 .exec = imgstat_exec,
586         },
587         {
588                 .name = "imgfree",
589                 .exec = imgfree_exec,
590         },
591 };