src/boot/bootctl.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2013 Kay Sievers
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <stdlib.h>
  23 #include <stdbool.h>
  24 #include <unistd.h>
  25 #include <getopt.h>
  26 #include <locale.h>
  27 #include <string.h>
  28 #include <sys/timex.h>
  29
  30 #include "boot.h"
  31 #include "build.h"
  32 #include "util.h"
  33 #include "utf8.h"
  34
  35 static int help(void) {
  36         printf("%s [OPTIONS...] COMMAND ...\n\n"
  37                "Query or change firmware and boot manager settings.\n\n"
  38                "  -h --help              Show this help\n"
  39                "     --version           Show package version\n"
  40                "Commands:\n"
  41                "  status                 Show current boot settings\n",
  42                program_invocation_short_name);
  43
  44         return 0;
  45 }
  46
  47 static int parse_argv(int argc, char *argv[]) {
  48         enum {
  49                 ARG_VERSION = 0x100,
  50         };
  51
  52         static const struct option options[] = {
  53                 { "help",                no_argument,       NULL, 'h'                     },
  54                 { "version",             no_argument,       NULL, ARG_VERSION             },
  55                 { NULL,                  0,                 NULL, 0                       }
  56         };
  57
  58         int c;
  59
  60         assert(argc >= 0);
  61         assert(argv);
  62         while ((c = getopt_long(argc, argv, "+hH:P", options, NULL)) >= 0) {
  63
  64                 switch (c) {
  65
  66                 case 'h':
  67                         help();
  68                         return 0;
  69
  70                 case ARG_VERSION:
  71                         puts(PACKAGE_STRING);
  72                         puts(SYSTEMD_FEATURES);
  73                         return 0;
  74
  75                 case '?':
  76                         return -EINVAL;
  77
  78                 default:
  79                         log_error("Unknown option code %c", c);
  80                         return -EINVAL;
  81                 }
  82         }
  83
  84         return 1;
  85 }
  86
  87 static int boot_info_new(struct boot_info **info) {
  88         struct boot_info *in;
  89         int err;
  90
  91         in = new0(struct boot_info, 1);
  92         if (!in)
  93                 return -ENOMEM;
  94
  95         err = sd_id128_get_machine(&in->machine_id);
  96         if (err < 0)
  97                 goto err;
  98
  99         err = sd_id128_get_boot(&in->boot_id);
 100         if (err < 0)
 101                 goto err;
 102
 103         in->fw_entry_active = -1;
 104         in->loader_entry_active = -1;
 105
 106         *info = in;
 107         return 0;
 108 err:
 109         free(in);
 110         return err;
 111 }
 112
 113 static void boot_info_entries_free(struct boot_info_entry *entries, size_t n) {
 114         size_t i;
 115
 116         for (i = 0; i < n; i++) {
 117                 free(entries[i].title);
 118                 free(entries[i].path);
 119         }
 120         free(entries);
 121 }
 122
 123 static void boot_info_free(struct boot_info *info) {
 124         free(info->fw_type);
 125         free(info->fw_info);
 126         boot_info_entries_free(info->fw_entries, info->fw_entries_count);
 127         free(info->fw_entries_order);
 128         free(info->loader);
 129         free(info->loader_image_path);
 130         free(info->loader_options_added);
 131         boot_info_entries_free(info->loader_entries, info->loader_entries_count);
 132         free(info);
 133 }
 134
 135 static int show_status(char **args, unsigned n) {
 136         char buf[64];
 137         struct boot_info *info;
 138         int err;
 139
 140         err = boot_info_new(&info);
 141         if (err < 0)
 142                 return -ENOMEM;
 143
 144         err = boot_info_query(info);
 145
 146         printf("System:\n");
 147         printf("   Machine ID: %s\n", sd_id128_to_string(info->machine_id, buf));
 148         printf("      Boot ID: %s\n", sd_id128_to_string(info->boot_id, buf));
 149         if (info->fw_type)
 150                 printf("     Firmware: %s (%s)\n", info->fw_type, strna(info->fw_info));
 151         if (info->fw_secure_boot >= 0)
 152                 printf("  Secure Boot: %s\n", info->fw_secure_boot ? "enabled" : "disabled");
 153         if (info->fw_secure_boot_setup_mode >= 0)
 154                 printf("   Setup Mode: %s\n", info->fw_secure_boot_setup_mode ? "setup" : "user");
 155         printf("\n");
 156
 157         if (info->fw_entry_active >= 0) {
 158                 printf("Selected Firmware Entry:\n");
 159                 printf("        Title: %s\n", strna(info->fw_entries[info->fw_entry_active].title));
 160                 if (!sd_id128_equal(info->fw_entries[info->fw_entry_active].part_uuid, SD_ID128_NULL))
 161                         printf("    Partition: /dev/disk/by-partuuid/%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\n",
 162                                SD_ID128_FORMAT_VAL(info->fw_entries[info->fw_entry_active].part_uuid));
 163                 else
 164                         printf("    Partition: n/a\n");
 165                 if (info->fw_entries[info->fw_entry_active].path)
 166                         printf("         File: %s%s\n", draw_special_char(DRAW_TREE_RIGHT), info->fw_entries[info->fw_entry_active].path);
 167         }
 168         printf("\n");
 169
 170         if (info->loader) {
 171                 printf("Boot Loader:\n");
 172                 printf("      Product: %s\n", info->loader);
 173                 if (!sd_id128_equal(info->loader_part_uuid, SD_ID128_NULL))
 174                         printf("    Partition: /dev/disk/by-partuuid/%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\n",
 175                                SD_ID128_FORMAT_VAL(info->loader_part_uuid));
 176                         else
 177                                 printf("    Partition: n/a\n");
 178                 printf("         File: %s%s\n", draw_special_char(DRAW_TREE_RIGHT), strna(info->loader_image_path));
 179                 printf("\n");
 180
 181                 if (info->loader_entry_active >= 0) {
 182                         printf("Selected Boot Loader Entry:\n");
 183                         printf("        Title: %s\n", strna(info->loader_entries[info->loader_entry_active].title));
 184                         printf("         File: %s\n", info->loader_entries[info->loader_entry_active].path);
 185                         if (info->loader_options_added)
 186                                 printf("      Options: %s\n", info->loader_options_added);
 187                 }
 188         } else
 189                 printf("No suitable data is provided by the boot manager. See:\n"
 190                        "  http://www.freedesktop.org/wiki/Software/systemd/BootLoaderInterface\n"
 191                        "  http://www.freedesktop.org/wiki/Specifications/BootLoaderSpec\n"
 192                        "for details.\n");
 193         printf("\n");
 194
 195         boot_info_free(info);
 196         return err;
 197 }
 198
 199 static int bootctl_main(int argc, char *argv[]) {
 200         static const struct {
 201                 const char* verb;
 202                 const enum {
 203                         MORE,
 204                         LESS,
 205                         EQUAL
 206                 } argc_cmp;
 207                 const int argc;
 208                 int (* const dispatch)(char **args, unsigned n);
 209         } verbs[] = {
 210                 { "status",                LESS,   1, show_status      },
 211         };
 212
 213         int left;
 214         unsigned i;
 215
 216         assert(argc >= 0);
 217         assert(argv);
 218
 219         left = argc - optind;
 220
 221         if (left <= 0)
 222                 /* Special rule: no arguments means "status" */
 223                 i = 0;
 224         else {
 225                 if (streq(argv[optind], "help")) {
 226                         help();
 227                         return 0;
 228                 }
 229
 230                 for (i = 0; i < ELEMENTSOF(verbs); i++)
 231                         if (streq(argv[optind], verbs[i].verb))
 232                                 break;
 233
 234                 if (i >= ELEMENTSOF(verbs)) {
 235                         log_error("Unknown operation %s", argv[optind]);
 236                         return -EINVAL;
 237                 }
 238         }
 239
 240         switch (verbs[i].argc_cmp) {
 241
 242         case EQUAL:
 243                 if (left != verbs[i].argc) {
 244                         log_error("Invalid number of arguments.");
 245                         return -EINVAL;
 246                 }
 247                 break;
 248
 249         case MORE:
 250                 if (left < verbs[i].argc) {
 251                         log_error("Too few arguments.");
 252                         return -EINVAL;
 253                 }
 254                 break;
 255
 256         case LESS:
 257                 if (left > verbs[i].argc) {
 258                         log_error("Too many arguments.");
 259                         return -EINVAL;
 260                 }
 261                 break;
 262
 263         default:
 264                 assert_not_reached("Unknown comparison operator.");
 265         }
 266
 267         return verbs[i].dispatch(argv + optind, left);
 268 }
 269
 270 int main(int argc, char *argv[]) {
 271         int r, retval = EXIT_FAILURE;
 272
 273         log_parse_environment();
 274         log_open();
 275
 276         r = parse_argv(argc, argv);
 277         if (r < 0)
 278                 goto finish;
 279         else if (r == 0) {
 280                 retval = EXIT_SUCCESS;
 281                 goto finish;
 282         }
 283
 284         r = bootctl_main(argc, argv);
 285         retval = r < 0 ? EXIT_FAILURE : r;
 286 finish:
 287         return retval;
 288 }