| /* Copyright 2013 The ChromiumOS Authors | |
| * Use of this source code is governed by a BSD-style license that can be | |
| * found in the LICENSE file. | |
| */ | |
| #include <errno.h> | |
| #include <fcntl.h> | |
| #include <getopt.h> | |
| #include <limits.h> | |
| #include <stdint.h> | |
| #include <stdio.h> | |
| #include <stdlib.h> | |
| #include <string.h> | |
| #include <sys/stat.h> | |
| #include <unistd.h> | |
| #include "futility.h" | |
| const char *ft_print_header = NULL; | |
| const char *ft_print_header2 = NULL; | |
| /******************************************************************************/ | |
| static const char *const usage = "\n" | |
| "Usage: " MYNAME " [options] COMMAND [args...]\n" | |
| "\n" | |
| "This is the unified firmware utility, which contains various of distinct\n" | |
| "verified boot tools as subcommands.\n" | |
| "\n" | |
| "See the README file for more information about the available commands\n"; | |
| static const char *const options = | |
| "Global options:\n" | |
| "\n" | |
| " --vb1 Use only vboot v1.0 binary formats\n" | |
| " --vb21 Use only vboot v2.1 binary formats\n" | |
| " --debug Be noisy about what's going on\n" | |
| "\n"; | |
| static const struct futil_cmd_t *find_command(const char *name) | |
| { | |
| const struct futil_cmd_t *const *cmd; | |
| for (cmd = futil_cmds; *cmd; cmd++) | |
| if (((*cmd)->version & vboot_version) && | |
| !strcmp((*cmd)->name, name)) | |
| return *cmd; | |
| return NULL; | |
| } | |
| static void list_commands(void) | |
| { | |
| const struct futil_cmd_t *const *cmd; | |
| for (cmd = futil_cmds; *cmd; cmd++) | |
| if (vboot_version & (*cmd)->version) | |
| printf(" %-20s %s\n", | |
| (*cmd)->name, (*cmd)->shorthelp); | |
| } | |
| static int run_command(const struct futil_cmd_t *cmd, int argc, char *argv[]) | |
| { | |
| int i; | |
| VB2_DEBUG("\"%s\" ...\n", cmd->name); | |
| for (i = 0; i < argc; i++) | |
| VB2_DEBUG(" argv[%d] = \"%s\"\n", i, argv[i]); | |
| return cmd->handler(argc, argv); | |
| } | |
| static int do_help(int argc, char *argv[]) | |
| { | |
| const struct futil_cmd_t *cmd; | |
| const char *vstr = ""; | |
| /* Help about a known command? */ | |
| if (argc > 1) { | |
| cmd = find_command(argv[1]); | |
| if (cmd) { | |
| /* Let the command provide its own help */ | |
| argv[0] = argv[1]; | |
| argv[1] = (char *)"--help"; | |
| return run_command(cmd, argc, argv); | |
| } | |
| } | |
| fputs(usage, stdout); | |
| if (vboot_version == VBOOT_VERSION_ALL) | |
| fputs(options, stdout); | |
| switch (vboot_version) { | |
| case VBOOT_VERSION_1_0: | |
| vstr = "version 1.0 "; | |
| break; | |
| case VBOOT_VERSION_2_1: | |
| vstr = "version 2.1 "; | |
| break; | |
| case VBOOT_VERSION_ALL: | |
| vstr = ""; | |
| break; | |
| } | |
| printf("The following %scommands are built-in:\n\n", vstr); | |
| list_commands(); | |
| printf("\nUse \"" MYNAME " help COMMAND\" for more information.\n\n"); | |
| return 0; | |
| } | |
| DECLARE_FUTIL_COMMAND(help, do_help, VBOOT_VERSION_ALL, | |
| "Show a bit of help (you're looking at it)"); | |
| static const char ver_help[] = | |
| "Show the futility source revision and build date"; | |
| static int do_version(int argc, char *argv[]) | |
| { | |
| if (argc > 1) | |
| printf("%s - %s\n", argv[0], ver_help); | |
| else | |
| printf("%s\n", futility_version); | |
| return 0; | |
| } | |
| DECLARE_FUTIL_COMMAND(version, do_version, VBOOT_VERSION_ALL, | |
| ver_help); | |
| static char *simple_basename(char *str) | |
| { | |
| char *s = strrchr(str, '/'); | |
| if (s) | |
| s++; | |
| else | |
| s = str; | |
| return s; | |
| } | |
| /* Here we go */ | |
| #define OPT_HELP 1000 | |
| test_mockable | |
| int main(int argc, char *argv[], char *envp[]) | |
| { | |
| char *progname; | |
| const struct futil_cmd_t *cmd; | |
| int i, errorcnt = 0; | |
| int vb_ver = VBOOT_VERSION_ALL; | |
| int helpind = 0; | |
| struct option long_opts[] = { | |
| {"debug", 0, &debugging_enabled, 1}, | |
| {"vb1" , 0, &vb_ver, VBOOT_VERSION_1_0}, | |
| {"vb21", 0, &vb_ver, VBOOT_VERSION_2_1}, | |
| {"help", 0, 0, OPT_HELP}, | |
| { 0, 0, 0, 0}, | |
| }; | |
| /* How were we invoked? */ | |
| progname = simple_basename(argv[0]); | |
| /* See if the program name is a command we recognize */ | |
| cmd = find_command(progname); | |
| if (cmd) { | |
| /* Yep, just do that */ | |
| return !!run_command(cmd, argc, argv); | |
| } | |
| /* Parse the global options, stopping at the first non-option. */ | |
| opterr = 0; /* quiet, you. */ | |
| while ((i = getopt_long(argc, argv, "+:", long_opts, NULL)) != -1) { | |
| switch (i) { | |
| case OPT_HELP: | |
| /* Remember where we found this option */ | |
| /* Note: this might be GNU-specific */ | |
| helpind = optind - 1; | |
| break; | |
| case '?': | |
| if (optopt) | |
| fprintf(stderr, "Unrecognized option: -%c\n", | |
| optopt); | |
| else | |
| fprintf(stderr, "Unrecognized option: %s\n", | |
| argv[optind - 1]); | |
| errorcnt++; | |
| break; | |
| case ':': | |
| fprintf(stderr, "Missing argument to -%c\n", optopt); | |
| errorcnt++; | |
| break; | |
| case 0: /* handled option */ | |
| break; | |
| default: | |
| FATAL("Unrecognized getopt output: %d\n", i); | |
| } | |
| } | |
| vboot_version = vb_ver; | |
| /* | |
| * Translate "--help" in the args to "help" as the first parameter, | |
| * by rearranging argv[]. | |
| */ | |
| if (helpind) { | |
| int j; | |
| optind--; | |
| for (j = helpind; j < optind; j++) | |
| argv[j] = argv[j + 1]; | |
| argv[j] = (char *)"help"; | |
| } | |
| /* We require a command name. */ | |
| if (errorcnt || argc == optind) { | |
| do_help(1, argv); | |
| return 1; | |
| } | |
| /* For reasons I've forgotten, treat /blah/blah/CMD the same as CMD */ | |
| argv[optind] = simple_basename(argv[optind]); | |
| /* Do we recognize the command? */ | |
| cmd = find_command(argv[optind]); | |
| if (cmd) { | |
| /* Reset so commands can parse their own options */ | |
| argc -= optind; | |
| argv += optind; | |
| optind = 0; | |
| return !!run_command(cmd, argc, argv); | |
| } | |
| /* Nope. We've no clue what we're being asked to do. */ | |
| do_help(1, argv); | |
| return 1; | |
| } |