blob: 6cea6814426cb39592cb8ad8e553b98d9bd1afe8 [file] [log] [blame]
/*
* Copyright 2013 The Chromium OS Authors. All rights reserved.
* 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"
/******************************************************************************/
/* Logging stuff */
/* File to use for logging, if present */
#define LOGFILE "/tmp/futility.log"
/* Normally logging will only happen if the logfile already exists. Uncomment
* this to force log file creation (and thus logging) always. */
/* #define FORCE_LOGGING_ON */
static int log_fd = -1;
/* Write the string and a newline. Silently give up on errors */
static void log_str(char *prefix, char *str)
{
int len, done, n;
if (log_fd < 0)
return;
if (!str)
str = "(NULL)";
if (prefix && *prefix) {
len = strlen(prefix);
for (done = 0; done < len; done += n) {
n = write(log_fd, prefix + done, len - done);
if (n < 0)
return;
}
}
len = strlen(str);
if (len == 0) {
str = "(EMPTY)";
len = strlen(str);
}
for (done = 0; done < len; done += n) {
n = write(log_fd, str + done, len - done);
if (n < 0)
return;
}
if (write(log_fd, "\n", 1) < 0)
return;
}
static void log_close(void)
{
struct flock lock;
if (log_fd >= 0) {
memset(&lock, 0, sizeof(lock));
lock.l_type = F_UNLCK;
lock.l_whence = SEEK_SET;
if (fcntl(log_fd, F_SETLKW, &lock))
perror("Unable to unlock log file");
close(log_fd);
log_fd = -1;
}
}
static void log_open(void)
{
struct flock lock;
int ret;
#ifdef FORCE_LOGGING_ON
log_fd = open(LOGFILE, O_WRONLY | O_APPEND | O_CREAT, 0666);
#else
log_fd = open(LOGFILE, O_WRONLY | O_APPEND);
#endif
if (log_fd < 0) {
if (errno != EACCES)
return;
/* Permission problems should improve shortly ... */
sleep(1);
log_fd = open(LOGFILE, O_WRONLY | O_APPEND | O_CREAT, 0666);
if (log_fd < 0) /* Nope, they didn't */
return;
}
/* Let anyone have a turn */
fchmod(log_fd, 0666);
/* But only one at a time */
memset(&lock, 0, sizeof(lock));
lock.l_type = F_WRLCK;
lock.l_whence = SEEK_END;
ret = fcntl(log_fd, F_SETLKW, &lock); /* this blocks */
if (ret < 0)
log_close();
}
static void log_args(int argc, char *argv[])
{
int i;
ssize_t r;
pid_t parent;
char buf[80];
FILE *fp;
char caller_buf[PATH_MAX];
log_open();
/* delimiter */
log_str(NULL, "##### LOG #####");
/* Can we tell who called us? */
parent = getppid();
snprintf(buf, sizeof(buf), "/proc/%d/exe", parent);
r = readlink(buf, caller_buf, sizeof(caller_buf) - 1);
if (r >= 0) {
caller_buf[r] = '\0';
log_str("CALLER:", caller_buf);
}
/* From where? */
snprintf(buf, sizeof(buf), "/proc/%d/cwd", parent);
r = readlink(buf, caller_buf, sizeof(caller_buf) - 1);
if (r >= 0) {
caller_buf[r] = '\0';
log_str("DIR:", caller_buf);
}
/* And maybe the args? */
snprintf(buf, sizeof(buf), "/proc/%d/cmdline", parent);
fp = fopen(buf, "r");
if (fp) {
memset(caller_buf, 0, sizeof(caller_buf));
r = fread(caller_buf, 1, sizeof(caller_buf) - 1, fp);
if (r > 0) {
char *s = caller_buf;
for (i = 0; i < r && *s; ) {
log_str("CMDLINE:", s);
while (i < r && *s)
i++, s++;
i++, s++;
}
}
fclose(fp);
}
/* Now log the stuff about ourselves */
for (i = 0; i < argc; i++)
log_str(NULL, argv[i]);
log_close();
}
/******************************************************************************/
static const char *const usage = "\n"
"Usage: " MYNAME " [options] COMMAND [args...]\n"
"\n"
"This is the unified firmware utility, which will eventually replace\n"
"most of the distinct verified boot tools formerly produced by the\n"
"vboot_reference package.\n"
"\n"
"When symlinked under the name of one of those previous tools, it should\n"
"fully implement the original behavior. It can also be invoked directly\n"
"as " MYNAME ", followed by the original name as the first argument.\n"
"\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;
Debug("%s(\"%s\") ...\n", __func__, cmd->name);
for (i = 0; i < argc; i++)
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] = "--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
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},
};
log_args(argc, argv);
/* 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:
Debug("i=%d\n", i);
DIE;
}
}
vboot_version = vb_ver;
/*
* Translate "--help" in the args to "help" as the first parameter,
* by rearranging argv[].
*/
if (helpind) {
int i;
optind--;
for (i = helpind; i < optind; i++)
argv[i] = argv[i + 1];
argv[i] = "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;
}