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-2015 Kay Sievers
   7   Copyright 2013 Lennart Poettering
   8
   9   systemd is free software; you can redistribute it and/or modify it
  10   under the terms of the GNU Lesser General Public License as published by
  11   the Free Software Foundation; either version 2.1 of the License, or
  12   (at your option) any later version.
  13
  14   systemd is distributed in the hope that it will be useful, but
  15   WITHOUT ANY WARRANTY; without even the implied warranty of
  16   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  17   Lesser General Public License for more details.
  18
  19   You should have received a copy of the GNU Lesser General Public License
  20   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  21 ***/
  22
  23 #include <stdio.h>
  24 #include <getopt.h>
  25 #include <errno.h>
  26 #include <stdlib.h>
  27 #include <assert.h>
  28 #include <sys/statfs.h>
  29 #include <sys/stat.h>
  30 #include <errno.h>
  31 #include <string.h>
  32 #include <unistd.h>
  33 #include <sys/mman.h>
  34 #include <dirent.h>
  35 #include <ctype.h>
  36 #include <limits.h>
  37 #include <ftw.h>
  38 #include <stdbool.h>
  39 #include <blkid/blkid.h>
  40
  41 #include "efivars.h"
  42 #include "build.h"
  43 #include "util.h"
  44
  45 static int verify_esp(const char *p, uint32_t *part, uint64_t *pstart, uint64_t *psize, sd_id128_t *uuid) {
  46         struct statfs sfs;
  47         struct stat st, st2;
  48         char *t;
  49         blkid_probe b = NULL;
  50         int r;
  51         const char *v;
  52
  53         if (statfs(p, &sfs) < 0) {
  54                 fprintf(stderr, "Failed to check file system type of %s: %m\n", p);
  55                 return -errno;
  56         }
  57
  58         if (sfs.f_type != 0x4d44) {
  59                 fprintf(stderr, "File system %s is not a FAT EFI System Partition (ESP) file system.\n", p);
  60                 return -ENODEV;
  61         }
  62
  63         if (stat(p, &st) < 0) {
  64                 fprintf(stderr, "Failed to determine block device node of %s: %m\n", p);
  65                 return -errno;
  66         }
  67
  68         if (major(st.st_dev) == 0) {
  69                 fprintf(stderr, "Block device node of %p is invalid.\n", p);
  70                 return -ENODEV;
  71         }
  72
  73         r = asprintf(&t, "%s/..", p);
  74         if (r < 0) {
  75                 fprintf(stderr, "Out of memory.\n");
  76                 return -ENOMEM;
  77         }
  78
  79         r = stat(t, &st2);
  80         free(t);
  81         if (r < 0) {
  82                 fprintf(stderr, "Failed to determine block device node of parent of %s: %m\n", p);
  83                 return -errno;
  84         }
  85
  86         if (st.st_dev == st2.st_dev) {
  87                 fprintf(stderr, "Directory %s is not the root of the EFI System Partition (ESP) file system.\n", p);
  88                 return -ENODEV;
  89         }
  90
  91         r = asprintf(&t, "/dev/block/%u:%u", major(st.st_dev), minor(st.st_dev));
  92         if (r < 0) {
  93                 fprintf(stderr, "Out of memory.\n");
  94                 return -ENOMEM;
  95         }
  96
  97         errno = 0;
  98         b = blkid_new_probe_from_filename(t);
  99         free(t);
 100         if (!b) {
 101                 if (errno != 0) {
 102                         fprintf(stderr, "Failed to open file system %s: %m\n", p);
 103                         return -errno;
 104                 }
 105
 106                 fprintf(stderr, "Out of memory.\n");
 107                 return -ENOMEM;
 108         }
 109
 110         blkid_probe_enable_superblocks(b, 1);
 111         blkid_probe_set_superblocks_flags(b, BLKID_SUBLKS_TYPE);
 112         blkid_probe_enable_partitions(b, 1);
 113         blkid_probe_set_partitions_flags(b, BLKID_PARTS_ENTRY_DETAILS);
 114
 115         errno = 0;
 116         r = blkid_do_safeprobe(b);
 117         if (r == -2) {
 118                 fprintf(stderr, "File system %s is ambigious.\n", p);
 119                 r = -ENODEV;
 120                 goto fail;
 121         } else if (r == 1) {
 122                 fprintf(stderr, "File system %s does not contain a label.\n", p);
 123                 r = -ENODEV;
 124                 goto fail;
 125         } else if (r != 0) {
 126                 r = errno ? -errno : -EIO;
 127                 fprintf(stderr, "Failed to probe file system %s: %s\n", p, strerror(-r));
 128                 goto fail;
 129         }
 130
 131         errno = 0;
 132         r = blkid_probe_lookup_value(b, "TYPE", &v, NULL);
 133         if (r != 0) {
 134                 r = errno ? -errno : -EIO;
 135                 fprintf(stderr, "Failed to probe file system type %s: %s\n", p, strerror(-r));
 136                 goto fail;
 137         }
 138
 139         if (strcmp(v, "vfat") != 0) {
 140                 fprintf(stderr, "File system %s is not a FAT EFI System Partition (ESP) file system after all.\n", p);
 141                 r = -ENODEV;
 142                 goto fail;
 143         }
 144
 145         errno = 0;
 146         r = blkid_probe_lookup_value(b, "PART_ENTRY_SCHEME", &v, NULL);
 147         if (r != 0) {
 148                 r = errno ? -errno : -EIO;
 149                 fprintf(stderr, "Failed to probe partition scheme %s: %s\n", p, strerror(-r));
 150                 goto fail;
 151         }
 152
 153         if (strcmp(v, "gpt") != 0) {
 154                 fprintf(stderr, "File system %s is not on a GPT partition table.\n", p);
 155                 r = -ENODEV;
 156                 goto fail;
 157         }
 158
 159         errno = 0;
 160         r = blkid_probe_lookup_value(b, "PART_ENTRY_TYPE", &v, NULL);
 161         if (r != 0) {
 162                 r = errno ? -errno : -EIO;
 163                 fprintf(stderr, "Failed to probe partition type UUID %s: %s\n", p, strerror(-r));
 164                 goto fail;
 165         }
 166
 167         if (strcmp(v, "c12a7328-f81f-11d2-ba4b-00a0c93ec93b") != 0) {
 168                 r = -ENODEV;
 169                 fprintf(stderr, "File system %s is not an EFI System Partition (ESP).\n", p);
 170                 goto fail;
 171         }
 172
 173         errno = 0;
 174         r = blkid_probe_lookup_value(b, "PART_ENTRY_UUID", &v, NULL);
 175         if (r != 0) {
 176                 r = errno ? -errno : -EIO;
 177                 fprintf(stderr, "Failed to probe partition entry UUID %s: %s\n", p, strerror(-r));
 178                 goto fail;
 179         }
 180
 181         r = sd_id128_from_string(v, uuid);
 182         if (r < 0) {
 183                 fprintf(stderr, "Partition %s has invalid UUID: %s\n", p, v);
 184                 r = -EIO;
 185                 goto fail;
 186         }
 187
 188         errno = 0;
 189         r = blkid_probe_lookup_value(b, "PART_ENTRY_NUMBER", &v, NULL);
 190         if (r != 0) {
 191                 r = errno ? -errno : -EIO;
 192                 fprintf(stderr, "Failed to probe partition number %s: %s\n", p, strerror(-r));
 193                 goto fail;
 194         }
 195         *part = strtoul(v, NULL, 10);
 196
 197         errno = 0;
 198         r = blkid_probe_lookup_value(b, "PART_ENTRY_OFFSET", &v, NULL);
 199         if (r != 0) {
 200                 r = errno ? -errno : -EIO;
 201                 fprintf(stderr, "Failed to probe partition offset %s: %s\n", p, strerror(-r));
 202                 goto fail;
 203         }
 204         *pstart = strtoul(v, NULL, 10);
 205
 206         errno = 0;
 207         r = blkid_probe_lookup_value(b, "PART_ENTRY_SIZE", &v, NULL);
 208         if (r != 0) {
 209                 r = errno ? -errno : -EIO;
 210                 fprintf(stderr, "Failed to probe partition size %s: %s\n", p, strerror(-r));
 211                 goto fail;
 212         }
 213         *psize = strtoul(v, NULL, 10);
 214
 215         blkid_free_probe(b);
 216         return 0;
 217 fail:
 218         if (b)
 219                 blkid_free_probe(b);
 220         return r;
 221 }
 222
 223 /* search for "#### LoaderInfo: systemd-boot 218 ####" string inside the binary */
 224 static int get_file_version(FILE *f, char **v) {
 225         struct stat st;
 226         char *buf;
 227         const char *s, *e;
 228         char *x = NULL;
 229         int r = 0;
 230
 231         assert(f);
 232         assert(v);
 233
 234         if (fstat(fileno(f), &st) < 0)
 235                 return -errno;
 236
 237         if (st.st_size < 27)
 238                 return 0;
 239
 240         buf = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fileno(f), 0);
 241         if (buf == MAP_FAILED)
 242                 return -errno;
 243
 244         s = memmem(buf, st.st_size - 8, "#### LoaderInfo: ", 17);
 245         if (!s)
 246                 goto finish;
 247         s += 17;
 248
 249         e = memmem(s, st.st_size - (s - buf), " ####", 5);
 250         if (!e || e - s < 3) {
 251                 fprintf(stderr, "Malformed version string.\n");
 252                 r = -EINVAL;
 253                 goto finish;
 254         }
 255
 256         x = strndup(s, e - s);
 257         if (!x) {
 258                 fprintf(stderr, "Out of memory.\n");
 259                 r = -ENOMEM;
 260                 goto finish;
 261         }
 262         r = 1;
 263
 264 finish:
 265         munmap(buf, st.st_size);
 266         *v = x;
 267         return r;
 268 }
 269
 270 static int enumerate_binaries(const char *esp_path, const char *path, const char *prefix) {
 271         struct dirent *de;
 272         char *p = NULL, *q = NULL;
 273         DIR *d = NULL;
 274         int r = 0, c = 0;
 275
 276         if (asprintf(&p, "%s/%s", esp_path, path) < 0) {
 277                 fprintf(stderr, "Out of memory.\n");
 278                 r = -ENOMEM;
 279                 goto finish;
 280         }
 281
 282         d = opendir(p);
 283         if (!d) {
 284                 if (errno == ENOENT) {
 285                         r = 0;
 286                         goto finish;
 287                 }
 288
 289                 fprintf(stderr, "Failed to read %s: %m\n", p);
 290                 r = -errno;
 291                 goto finish;
 292         }
 293
 294         while ((de = readdir(d))) {
 295                 char *v;
 296                 size_t n;
 297                 FILE *f;
 298
 299                 if (de->d_name[0] == '.')
 300                         continue;
 301
 302                 n = strlen(de->d_name);
 303                 if (n < 4 || strcasecmp(de->d_name + n - 4, ".efi") != 0)
 304                         continue;
 305
 306                 if (prefix && strncasecmp(de->d_name, prefix, strlen(prefix)) != 0)
 307                         continue;
 308
 309                 free(q);
 310                 q = NULL;
 311                 if (asprintf(&q, "%s/%s/%s", esp_path, path, de->d_name) < 0) {
 312                         fprintf(stderr, "Out of memory.\n");
 313                         r = -ENOMEM;
 314                         goto finish;
 315                 }
 316
 317                 f = fopen(q, "re");
 318                 if (!f) {
 319                         fprintf(stderr, "Failed to open %s for reading: %m\n", q);
 320                         r = -errno;
 321                         goto finish;
 322                 }
 323
 324                 r = get_file_version(f, &v);
 325                 fclose(f);
 326
 327                 if (r < 0)
 328                         goto finish;
 329
 330                 if (r > 0)
 331                         printf("         File: └─/%s/%s (%s)\n", path, de->d_name, v);
 332                 else
 333                         printf("         File: └─/%s/%s\n", path, de->d_name);
 334
 335                 c++;
 336                 free(v);
 337         }
 338
 339         r = c;
 340
 341 finish:
 342         if (d)
 343                 closedir(d);
 344
 345         free(p);
 346         free(q);
 347         return r;
 348 }
 349
 350 static int status_binaries(const char *esp_path, sd_id128_t partition) {
 351         int r;
 352
 353         printf("Boot Loader Binaries:\n");
 354
 355         printf("          ESP: /dev/disk/by-partuuid/%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\n", SD_ID128_FORMAT_VAL(partition));
 356
 357         r = enumerate_binaries(esp_path, "EFI/systemd", NULL);
 358         if (r == 0)
 359                 fprintf(stderr, "systemd-boot not installed in ESP.\n");
 360         else if (r < 0)
 361                 return r;
 362
 363         r = enumerate_binaries(esp_path, "EFI/Boot", "boot");
 364         if (r == 0)
 365                 fprintf(stderr, "No default/fallback boot loader installed in ESP.\n");
 366         else if (r < 0)
 367                 return r;
 368
 369         printf("\n");
 370         return 0;
 371 }
 372
 373 static int print_efi_option(uint16_t id, bool in_order) {
 374         _cleanup_free_ char *title = NULL;
 375         _cleanup_free_ char *path = NULL;
 376         sd_id128_t partition;
 377         bool active;
 378         int r = 0;
 379
 380         r = efi_get_boot_option(id, &title, &partition, &path, &active);
 381         if (r < 0)
 382                 return r;
 383
 384         /* print only configured entries with partition information */
 385         if (!path || sd_id128_equal(partition, SD_ID128_NULL))
 386                 return 0;
 387
 388         efi_tilt_backslashes(path);
 389
 390         printf("        Title: %s\n", strna(title));
 391         printf("           ID: 0x%04X\n", id);
 392         printf("       Status: %sactive%s\n", active ? "" : "in", in_order ? ", boot-order" : "");
 393         printf("    Partition: /dev/disk/by-partuuid/%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\n", SD_ID128_FORMAT_VAL(partition));
 394         printf("         File: └─%s\n", path);
 395         printf("\n");
 396
 397         return 0;
 398 }
 399
 400 static int status_variables(void) {
 401         int n_options, n_order;
 402         uint16_t *options = NULL, *order = NULL;
 403         int r, i;
 404
 405         if (!is_efi_boot()) {
 406                 fprintf(stderr, "Not booted with EFI, not showing EFI variables.\n");
 407                 return 0;
 408         }
 409
 410         n_options = efi_get_boot_options(&options);
 411         if (n_options < 0) {
 412                 if (n_options == -ENOENT)
 413                         fprintf(stderr, "Failed to access EFI variables, "
 414                                 "efivarfs needs to be available at /sys/firmware/efi/efivars/.\n");
 415                 else
 416                         fprintf(stderr, "Failed to read EFI boot entries: %s\n", strerror(-n_options));
 417                 r = n_options;
 418                 goto finish;
 419         }
 420
 421         printf("Boot Loader Entries in EFI Variables:\n");
 422         n_order = efi_get_boot_order(&order);
 423         if (n_order == -ENOENT) {
 424                 n_order = 0;
 425         } else if (n_order < 0) {
 426                 fprintf(stderr, "Failed to read EFI boot order.\n");
 427                 r = n_order;
 428                 goto finish;
 429         }
 430
 431         /* print entries in BootOrder first */
 432         for (i = 0; i < n_order; i++)
 433                 print_efi_option(order[i], true);
 434
 435         /* print remaining entries */
 436         for (i = 0; i < n_options; i++) {
 437                 int j;
 438                 bool found = false;
 439
 440                 for (j = 0; j < n_order; j++)
 441                         if (options[i] == order[j]) {
 442                                 found = true;
 443                                 break;
 444                         }
 445
 446                 if (found)
 447                         continue;
 448
 449                 print_efi_option(options[i], false);
 450         }
 451
 452         r = 0;
 453 finish:
 454         free(options);
 455         free(order);
 456
 457         return r;
 458 }
 459
 460 static int compare_product(const char *a, const char *b) {
 461         size_t x, y;
 462
 463         assert(a);
 464         assert(b);
 465
 466         x = strcspn(a, " ");
 467         y = strcspn(b, " ");
 468         if (x != y)
 469                 return x < y ? -1 : x > y ? 1 : 0;
 470
 471         return strncmp(a, b, x);
 472 }
 473
 474 static int compare_version(const char *a, const char *b) {
 475         assert(a);
 476         assert(b);
 477
 478         a += strcspn(a, " ");
 479         a += strspn(a, " ");
 480         b += strcspn(b, " ");
 481         b += strspn(b, " ");
 482
 483         return strverscmp(a, b);
 484 }
 485
 486 static int version_check(FILE *f, const char *from, const char *to) {
 487         FILE *g = NULL;
 488         char *a = NULL, *b = NULL;
 489         int r;
 490
 491         assert(f);
 492         assert(from);
 493         assert(to);
 494
 495         r = get_file_version(f, &a);
 496         if (r < 0)
 497                 goto finish;
 498         if (r == 0) {
 499                 r = -EINVAL;
 500                 fprintf(stderr, "Source file %s does not carry version information!\n", from);
 501                 goto finish;
 502         }
 503
 504         g = fopen(to, "re");
 505         if (!g) {
 506                 if (errno == ENOENT) {
 507                         r = 0;
 508                         goto finish;
 509                 }
 510
 511                 r = -errno;
 512                 fprintf(stderr, "Failed to open %s for reading: %m\n", to);
 513                 goto finish;
 514         }
 515
 516         r = get_file_version(g, &b);
 517         if (r < 0)
 518                 goto finish;
 519         if (r == 0 || compare_product(a, b) != 0) {
 520                 r = -EEXIST;
 521                 fprintf(stderr, "Skipping %s, since it's owned by another boot loader.\n", to);
 522                 goto finish;
 523         }
 524
 525         if (compare_version(a, b) < 0) {
 526                 r = -EEXIST;
 527                 fprintf(stderr, "Skipping %s, since it's a newer boot loader version already.\n", to);
 528                 goto finish;
 529         }
 530
 531         r = 0;
 532
 533 finish:
 534         free(a);
 535         free(b);
 536         if (g)
 537                 fclose(g);
 538         return r;
 539 }
 540
 541 static int copy_file(const char *from, const char *to, bool force) {
 542         FILE *f = NULL, *g = NULL;
 543         char *p = NULL;
 544         int r;
 545         struct timespec t[2];
 546         struct stat st;
 547
 548         assert(from);
 549         assert(to);
 550
 551         f = fopen(from, "re");
 552         if (!f) {
 553                 fprintf(stderr, "Failed to open %s for reading: %m\n", from);
 554                 return -errno;
 555         }
 556
 557         if (!force) {
 558                 /* If this is an update, then let's compare versions first */
 559                 r = version_check(f, from, to);
 560                 if (r < 0)
 561                         goto finish;
 562         }
 563
 564         if (asprintf(&p, "%s~", to) < 0) {
 565                 fprintf(stderr, "Out of memory.\n");
 566                 r = -ENOMEM;
 567                 goto finish;
 568         }
 569
 570         g = fopen(p, "wxe");
 571         if (!g) {
 572                 /* Directory doesn't exist yet? Then let's skip this... */
 573                 if (!force && errno == ENOENT) {
 574                         r = 0;
 575                         goto finish;
 576                 }
 577
 578                 fprintf(stderr, "Failed to open %s for writing: %m\n", to);
 579                 r = -errno;
 580                 goto finish;
 581         }
 582
 583         rewind(f);
 584         do {
 585                 size_t k;
 586                 uint8_t buf[32*1024];
 587
 588                 k = fread(buf, 1, sizeof(buf), f);
 589                 if (ferror(f)) {
 590                         fprintf(stderr, "Failed to read %s: %m\n", from);
 591                         r = -errno;
 592                         goto finish;
 593                 }
 594                 if (k == 0)
 595                         break;
 596
 597                 fwrite(buf, 1, k, g);
 598                 if (ferror(g)) {
 599                         fprintf(stderr, "Failed to write %s: %m\n", to);
 600                         r = -errno;
 601                         goto finish;
 602                 }
 603         } while (!feof(f));
 604
 605         fflush(g);
 606         if (ferror(g)) {
 607                 fprintf(stderr, "Failed to write %s: %m\n", to);
 608                 r = -errno;
 609                 goto finish;
 610         }
 611
 612         r = fstat(fileno(f), &st);
 613         if (r < 0) {
 614                 fprintf(stderr, "Failed to get file timestamps of %s: %m", from);
 615                 r = -errno;
 616                 goto finish;
 617         }
 618
 619         t[0] = st.st_atim;
 620         t[1] = st.st_mtim;
 621
 622         r = futimens(fileno(g), t);
 623         if (r < 0) {
 624                 fprintf(stderr, "Failed to change file timestamps for %s: %m", p);
 625                 r = -errno;
 626                 goto finish;
 627         }
 628
 629         if (rename(p, to) < 0) {
 630                 fprintf(stderr, "Failed to rename %s to %s: %m\n", p, to);
 631                 r = -errno;
 632                 goto finish;
 633         }
 634
 635         fprintf(stderr, "Copied %s to %s.\n", from, to);
 636
 637         free(p);
 638         p = NULL;
 639         r = 0;
 640
 641 finish:
 642         if (f)
 643                 fclose(f);
 644         if (g)
 645                 fclose(g);
 646         if (p) {
 647                 unlink(p);
 648                 free(p);
 649         }
 650         return r;
 651 }
 652
 653 static char* strupper(char *s) {
 654         char *p;
 655
 656         for (p = s; *p; p++)
 657                 *p = toupper(*p);
 658
 659         return s;
 660 }
 661
 662 static int mkdir_one(const char *prefix, const char *suffix) {
 663         char *p;
 664
 665         if (asprintf(&p, "%s/%s", prefix, suffix) < 0) {
 666                 fprintf(stderr, "Out of memory.\n");
 667                 return -ENOMEM;
 668         }
 669
 670         if (mkdir(p, 0700) < 0) {
 671                 if (errno != EEXIST) {
 672                         fprintf(stderr, "Failed to create %s: %m\n", p);
 673                         free(p);
 674                         return -errno;
 675                 }
 676         } else
 677                 fprintf(stderr, "Created %s.\n", p);
 678
 679         free(p);
 680         return 0;
 681 }
 682
 683 static int create_dirs(const char *esp_path) {
 684         int r;
 685
 686         r = mkdir_one(esp_path, "EFI");
 687         if (r < 0)
 688                 return r;
 689
 690         r = mkdir_one(esp_path, "EFI/systemd");
 691         if (r < 0)
 692                 return r;
 693
 694         r = mkdir_one(esp_path, "EFI/Boot");
 695         if (r < 0)
 696                 return r;
 697
 698         r = mkdir_one(esp_path, "loader");
 699         if (r < 0)
 700                 return r;
 701
 702         r = mkdir_one(esp_path, "loader/entries");
 703         if (r < 0)
 704                 return r;
 705
 706         return 0;
 707 }
 708
 709 static int copy_one_file(const char *esp_path, const char *name, bool force) {
 710         _cleanup_free_ char *p = NULL;
 711         _cleanup_free_ char *q = NULL;
 712         _cleanup_free_ char *v = NULL;
 713         int r;
 714
 715         if (asprintf(&p, BOOTLIBDIR "/%s", name) < 0) {
 716                 fprintf(stderr, "Out of memory.\n");
 717                 return -ENOMEM;
 718         }
 719
 720         if (asprintf(&q, "%s/EFI/systemd/%s", esp_path, name) < 0) {
 721                 fprintf(stderr, "Out of memory.\n");
 722                 return -ENOMEM;
 723         }
 724
 725         r = copy_file(p, q, force);
 726
 727         if (startswith(name, "systemd-boot")) {
 728                 int k;
 729
 730                 /* Create the EFI default boot loader name (specified for removable devices) */
 731                 if (asprintf(&v, "%s/EFI/Boot/BOOT%s", esp_path, name + strlen("systemd-boot")) < 0) {
 732                         fprintf(stderr, "Out of memory.\n");
 733                         return -ENOMEM;
 734                 }
 735                 strupper(strrchr(v, '/') + 1);
 736
 737                 k = copy_file(p, v, force);
 738                 if (k < 0 && r == 0)
 739                         return k;
 740         }
 741
 742         return r;
 743 }
 744
 745 static int install_binaries(const char *esp_path, bool force) {
 746         struct dirent *de;
 747         DIR *d;
 748         int r = 0;
 749
 750         if (force) {
 751                 /* Don't create any of these directories when we are
 752                  * just updating. When we update we'll drop-in our
 753                  * files (unless there are newer ones already), but we
 754                  * won't create the directories for them in the first
 755                  * place. */
 756                 r = create_dirs(esp_path);
 757                 if (r < 0)
 758                         return r;
 759         }
 760
 761         d = opendir(BOOTLIBDIR);
 762         if (!d) {
 763                 fprintf(stderr, "Failed to open "BOOTLIBDIR": %m\n");
 764                 return -errno;
 765         }
 766
 767         while ((de = readdir(d))) {
 768                 size_t n;
 769                 int k;
 770
 771                 if (de->d_name[0] == '.')
 772                         continue;
 773
 774                 n = strlen(de->d_name);
 775                 if (n < 4 || strcmp(de->d_name + n - 4, ".efi") != 0)
 776                         continue;
 777
 778                 k = copy_one_file(esp_path, de->d_name, force);
 779                 if (k < 0 && r == 0)
 780                         r = k;
 781         }
 782
 783         closedir(d);
 784         return r;
 785 }
 786
 787 static bool same_entry(uint16_t id, const sd_id128_t uuid, const char *path) {
 788         char *opath = NULL;
 789         sd_id128_t ouuid;
 790         int err;
 791         bool same = false;
 792
 793         err = efi_get_boot_option(id, NULL, &ouuid, &opath, NULL);
 794         if (err < 0)
 795                 return false;
 796         if (!sd_id128_equal(uuid, ouuid))
 797                 goto finish;
 798
 799         if (!streq_ptr(path, opath))
 800                 goto finish;
 801
 802         same = true;
 803
 804 finish:
 805         return same;
 806 }
 807
 808 static int find_slot(sd_id128_t uuid, const char *path, uint16_t *id) {
 809         uint16_t *options = NULL;
 810         int n_options;
 811         int i;
 812         uint16_t new_id = 0;
 813         bool existing = false;
 814
 815         n_options = efi_get_boot_options(&options);
 816         if (n_options < 0)
 817                 return n_options;
 818
 819         /* find already existing systemd-boot entry */
 820         for (i = 0; i < n_options; i++)
 821                 if (same_entry(options[i], uuid, path)) {
 822                         new_id = options[i];
 823                         existing = true;
 824                         goto finish;
 825                 }
 826
 827         /* find free slot in the sorted BootXXXX variable list */
 828         for (i = 0; i < n_options; i++)
 829                 if (i != options[i]) {
 830                         new_id = i;
 831                         goto finish;
 832                 }
 833
 834         /* use the next one */
 835         if (i == 0xffff)
 836                 return -ENOSPC;
 837         new_id = i;
 838
 839 finish:
 840         *id = new_id;
 841         free(options);
 842         return existing;
 843 }
 844
 845 static int insert_into_order(uint16_t slot, bool first) {
 846         uint16_t *order = NULL;
 847         uint16_t *new_order;
 848         int n_order;
 849         int i;
 850         int err = 0;
 851
 852         n_order = efi_get_boot_order(&order);
 853         if (n_order <= 0) {
 854                 /* no entry, add us */
 855                 err = efi_set_boot_order(&slot, 1);
 856                 goto finish;
 857         }
 858
 859         /* are we the first and only one? */
 860         if (n_order == 1 && order[0] == slot)
 861                 goto finish;
 862
 863         /* are we already in the boot order? */
 864         for (i = 0; i < n_order; i++) {
 865                 if (order[i] != slot)
 866                         continue;
 867
 868                 /* we do not require to be the first one, all is fine */
 869                 if (!first)
 870                         goto finish;
 871
 872                 /* move us to the first slot */
 873                 memmove(&order[1], order, i * sizeof(uint16_t));
 874                 order[0] = slot;
 875                 efi_set_boot_order(order, n_order);
 876                 goto finish;
 877         }
 878
 879         /* extend array */
 880         new_order = realloc(order, (n_order+1) * sizeof(uint16_t));
 881         if (!new_order) {
 882                 err = -ENOMEM;
 883                 goto finish;
 884         }
 885         order = new_order;
 886
 887         /* add us to the top or end of the list */
 888         if (first) {
 889                 memmove(&order[1], order, n_order * sizeof(uint16_t));
 890                 order[0] = slot;
 891         } else
 892                 order[n_order] = slot;
 893
 894         efi_set_boot_order(order, n_order+1);
 895
 896 finish:
 897         free(order);
 898         return err;
 899 }
 900
 901 static int remove_from_order(uint16_t slot) {
 902         _cleanup_free_ uint16_t *order = NULL;
 903         int n_order;
 904         int i;
 905         int err = 0;
 906
 907         n_order = efi_get_boot_order(&order);
 908         if (n_order < 0)
 909                 return n_order;
 910         if (n_order == 0)
 911                 return 0;
 912
 913         for (i = 0; i < n_order; i++) {
 914                 if (order[i] != slot)
 915                         continue;
 916
 917                 if (i+1 < n_order)
 918                         memmove(&order[i], &order[i+1], (n_order - i) * sizeof(uint16_t));
 919                 efi_set_boot_order(order, n_order-1);
 920                 break;
 921         }
 922
 923         return err;
 924 }
 925
 926 static int install_variables(const char *esp_path,
 927                              uint32_t part, uint64_t pstart, uint64_t psize,
 928                              sd_id128_t uuid, const char *path,
 929                              bool first) {
 930         char *p = NULL;
 931         uint16_t *options = NULL;
 932         uint16_t slot;
 933         int r;
 934
 935         if (!is_efi_boot()) {
 936                 fprintf(stderr, "Not booted with EFI, skipping EFI variable setup.\n");
 937                 return 0;
 938         }
 939
 940         if (asprintf(&p, "%s%s", esp_path, path) < 0) {
 941                 fprintf(stderr, "Out of memory.\n");
 942                 return -ENOMEM;
 943         }
 944
 945         if (access(p, F_OK) < 0) {
 946                 if (errno == ENOENT)
 947                         r = 0;
 948                 else
 949                         r = -errno;
 950                 goto finish;
 951         }
 952
 953         r = find_slot(uuid, path, &slot);
 954         if (r < 0) {
 955                 if (r == -ENOENT)
 956                         fprintf(stderr, "Failed to access EFI variables. Is the \"efivarfs\" filesystem mounted?\n");
 957                 else
 958                         fprintf(stderr, "Failed to determine current boot order: %s\n", strerror(-r));
 959                 goto finish;
 960         }
 961
 962         if (first || r == false) {
 963                 r = efi_add_boot_option(slot, "Linux Boot Manager",
 964                                         part, pstart, psize,
 965                                         uuid, path);
 966                 if (r < 0) {
 967                         fprintf(stderr, "Failed to create EFI Boot variable entry: %s\n", strerror(-r));
 968                         goto finish;
 969                 }
 970                 fprintf(stderr, "Created EFI boot entry \"Linux Boot Manager\".\n");
 971         }
 972
 973         insert_into_order(slot, first);
 974
 975 finish:
 976         free(p);
 977         free(options);
 978         return r;
 979 }
 980
 981 static int remove_boot_efi(const char *esp_path) {
 982         struct dirent *de;
 983         char *p = NULL, *q = NULL;
 984         DIR *d = NULL;
 985         int r = 0, c = 0;
 986
 987         if (asprintf(&p, "%s/EFI/Boot", esp_path) < 0) {
 988                 fprintf(stderr, "Out of memory.\n");
 989                 return -ENOMEM;
 990         }
 991
 992         d = opendir(p);
 993         if (!d) {
 994                 if (errno == ENOENT) {
 995                         r = 0;
 996                         goto finish;
 997                 }
 998
 999                 fprintf(stderr, "Failed to read %s: %m\n", p);
1000                 r = -errno;
1001                 goto finish;
1002         }
1003
1004         while ((de = readdir(d))) {
1005                 char *v;
1006                 size_t n;
1007                 FILE *f;
1008
1009                 if (de->d_name[0] == '.')
1010                         continue;
1011
1012                 n = strlen(de->d_name);
1013                 if (n < 4 || strcasecmp(de->d_name + n - 4, ".EFI") != 0)
1014                         continue;
1015
1016                 if (strncasecmp(de->d_name, "Boot", 4) != 0)
1017                         continue;
1018
1019                 free(q);
1020                 q = NULL;
1021                 if (asprintf(&q, "%s/%s", p, de->d_name) < 0) {
1022                         fprintf(stderr, "Out of memory.\n");
1023                         r = -ENOMEM;
1024                         goto finish;
1025                 }
1026
1027                 f = fopen(q, "re");
1028                 if (!f) {
1029                         fprintf(stderr, "Failed to open %s for reading: %m\n", q);
1030                         r = -errno;
1031                         goto finish;
1032                 }
1033
1034                 r = get_file_version(f, &v);
1035                 fclose(f);
1036
1037                 if (r < 0)
1038                         goto finish;
1039
1040                 if (r > 0 && strncmp(v, "systemd-boot ", 10) == 0) {
1041
1042                         r = unlink(q);
1043                         if (r < 0) {
1044                                 fprintf(stderr, "Failed to remove %s: %m\n", q);
1045                                 r = -errno;
1046                                 free(v);
1047                                 goto finish;
1048                         } else
1049                                 fprintf(stderr, "Removed %s.\n", q);
1050                 }
1051
1052                 c++;
1053                 free(v);
1054         }
1055
1056         r = c;
1057
1058 finish:
1059         if (d)
1060                 closedir(d);
1061         free(p);
1062         free(q);
1063
1064         return r;
1065 }
1066
1067 static int rmdir_one(const char *prefix, const char *suffix) {
1068         char *p;
1069
1070         if (asprintf(&p, "%s/%s", prefix, suffix) < 0) {
1071                 fprintf(stderr, "Out of memory.\n");
1072                 return -ENOMEM;
1073         }
1074
1075         if (rmdir(p) < 0) {
1076                 if (errno != ENOENT && errno != ENOTEMPTY) {
1077                         fprintf(stderr, "Failed to remove %s: %m\n", p);
1078                         free(p);
1079                         return -errno;
1080                 }
1081         } else
1082                 fprintf(stderr, "Removed %s.\n", p);
1083
1084         free(p);
1085         return 0;
1086 }
1087
1088
1089 static int remove_binaries(const char *esp_path) {
1090         char *p;
1091         int r, q;
1092
1093         if (asprintf(&p, "%s/EFI/systemd-boot", esp_path) < 0) {
1094                 fprintf(stderr, "Out of memory.\n");
1095                 return -ENOMEM;
1096         }
1097
1098         r = rm_rf(p, false, false, false);
1099         free(p);
1100
1101         q = remove_boot_efi(esp_path);
1102         if (q < 0 && r == 0)
1103                 r = q;
1104
1105         q = rmdir_one(esp_path, "loader/entries");
1106         if (q < 0 && r == 0)
1107                 r = q;
1108
1109         q = rmdir_one(esp_path, "loader");
1110         if (q < 0 && r == 0)
1111                 r = q;
1112
1113         q = rmdir_one(esp_path, "EFI/Boot");
1114         if (q < 0 && r == 0)
1115                 r = q;
1116
1117         q = rmdir_one(esp_path, "EFI/systemd-boot");
1118         if (q < 0 && r == 0)
1119                 r = q;
1120
1121         q = rmdir_one(esp_path, "EFI");
1122         if (q < 0 && r == 0)
1123                 r = q;
1124
1125         return r;
1126 }
1127
1128 static int remove_variables(sd_id128_t uuid, const char *path, bool in_order) {
1129         uint16_t slot;
1130         int r;
1131
1132         if (!is_efi_boot())
1133                 return 0;
1134
1135         r = find_slot(uuid, path, &slot);
1136         if (r != 1)
1137                 return 0;
1138
1139         r = efi_remove_boot_option(slot);
1140         if (r < 0)
1141                 return r;
1142
1143         if (in_order)
1144                 remove_from_order(slot);
1145
1146         return 0;
1147 }
1148
1149 static int install_loader_config(const char *esp_path) {
1150         char *p = NULL;
1151         char line[64];
1152         char *machine = NULL;
1153         FILE *f;
1154
1155         f = fopen("/etc/machine-id", "re");
1156         if (!f)
1157                 return -errno;
1158
1159         if (fgets(line, sizeof(line), f) != NULL) {
1160                 char *s;
1161
1162                 s = strchr(line, '\n');
1163                 if (s)
1164                         s[0] = '\0';
1165                 if (strlen(line) == 32)
1166                         machine = line;
1167         }
1168
1169         fclose(f);
1170
1171         if (!machine)
1172                 return -ESRCH;
1173
1174         if (asprintf(&p, "%s/%s", esp_path, "loader/loader.conf") < 0) {
1175                 fprintf(stderr, "Out of memory.\n");
1176                 return -ENOMEM;
1177         }
1178
1179         f = fopen(p, "wxe");
1180         if (f) {
1181                 fprintf(f, "#timeout 3\n");
1182                 fprintf(f, "default %s-*\n", machine);
1183                 fclose(f);
1184         }
1185
1186         free(p);
1187         return 0;
1188 }
1189
1190 static int help(void) {
1191         printf("%s [COMMAND] [OPTIONS...]\n"
1192                "\n"
1193                "Install, update or remove the sdboot EFI boot manager.\n\n"
1194                "  -h --help          Show this help\n"
1195                "     --version       Print version\n"
1196                "     --path=PATH     Path to the EFI System Partition (ESP)\n"
1197                "     --no-variables  Don't touch EFI variables\n"
1198                "\n"
1199                "Comands:\n"
1200                "     status          Show status of installed systemd-boot and EFI variables\n"
1201                "     install         Install systemd-boot to the ESP and EFI variables\n"
1202                "     update          Update systemd-boot in the ESP and EFI variables\n"
1203                "     remove          Remove systemd-boot from the ESP and EFI variables\n",
1204                program_invocation_short_name);
1205
1206         return 0;
1207 }
1208
1209 static const char *arg_path = NULL;
1210 static bool arg_touch_variables = true;
1211
1212 static int parse_argv(int argc, char *argv[]) {
1213         enum {
1214                 ARG_PATH = 0x100,
1215                 ARG_VERSION,
1216                 ARG_NO_VARIABLES,
1217         };
1218
1219         static const struct option options[] = {
1220                 { "help",         no_argument,       NULL, 'h'              },
1221                 { "version",      no_argument,       NULL, ARG_VERSION      },
1222                 { "path",         required_argument, NULL, ARG_PATH         },
1223                 { "no-variables", no_argument,       NULL, ARG_NO_VARIABLES },
1224                 { NULL,           0,                 NULL, 0                }
1225         };
1226
1227         int c;
1228
1229         assert(argc >= 0);
1230         assert(argv);
1231
1232         while ((c = getopt_long(argc, argv, "h", options, NULL)) >= 0) {
1233                 switch (c) {
1234
1235                 case 'h':
1236                         help();
1237                         return 0;
1238
1239                 case ARG_VERSION:
1240                         printf(VERSION "\n");
1241                         return 0;
1242
1243                 case ARG_PATH:
1244                         arg_path = optarg;
1245                         break;
1246
1247                 case ARG_NO_VARIABLES:
1248                         arg_touch_variables = false;
1249                         break;
1250
1251                 case '?':
1252                         return -EINVAL;
1253
1254                 default:
1255                         fprintf(stderr, "Unknown option code '%c'.\n", c);
1256                         return -EINVAL;
1257                 }
1258         }
1259
1260         return 1;
1261 }
1262
1263 static int bootctl_main(int argc, char*argv[]) {
1264         enum action {
1265                 ACTION_STATUS,
1266                 ACTION_INSTALL,
1267                 ACTION_UPDATE,
1268                 ACTION_REMOVE
1269         } arg_action = ACTION_STATUS;
1270         static const struct {
1271                 const char* verb;
1272                 enum action action;
1273         } verbs[] = {
1274                 { "status",  ACTION_STATUS },
1275                 { "install", ACTION_INSTALL },
1276                 { "update",  ACTION_UPDATE },
1277                 { "remove",  ACTION_REMOVE },
1278         };
1279
1280         sd_id128_t uuid = {};
1281         uint32_t part = 0;
1282         uint64_t pstart = 0;
1283         uint64_t psize = 0;
1284         unsigned int i;
1285         int q;
1286         int r;
1287
1288         if (argv[optind]) {
1289                 for (i = 0; i < ELEMENTSOF(verbs); i++) {
1290                         if (!streq(argv[optind], verbs[i].verb))
1291                                 continue;
1292                         arg_action = verbs[i].action;
1293                         break;
1294                 }
1295                 if (i >= ELEMENTSOF(verbs)) {
1296                         fprintf(stderr, "Unknown operation %s\n", argv[optind]);
1297                         r = -EINVAL;
1298                         goto finish;
1299                 }
1300         }
1301
1302         if (!arg_path)
1303                 arg_path = "/boot";
1304
1305         if (geteuid() != 0) {
1306                 fprintf(stderr, "Need to be root.\n");
1307                 r = -EPERM;
1308                 goto finish;
1309         }
1310
1311         r = verify_esp(arg_path, &part, &pstart, &psize, &uuid);
1312         if (r == -ENODEV && !arg_path)
1313                 fprintf(stderr, "You might want to use --path= to indicate the path to your ESP, in case it is not mounted to /boot.\n");
1314         if (r < 0)
1315                 goto finish;
1316
1317         switch (arg_action) {
1318         case ACTION_STATUS: {
1319                 _cleanup_free_ char *fw_type = NULL;
1320                 _cleanup_free_ char *fw_info = NULL;
1321                 _cleanup_free_ char *loader = NULL;
1322                 _cleanup_free_ char *loader_path = NULL;
1323                 sd_id128_t loader_part_uuid = {};
1324
1325                 efi_get_variable_string(EFI_VENDOR_LOADER, "LoaderFirmwareType", &fw_type);
1326                 efi_get_variable_string(EFI_VENDOR_LOADER, "LoaderFirmwareInfo", &fw_info);
1327                 efi_get_variable_string(EFI_VENDOR_LOADER, "LoaderInfo", &loader);
1328                 if (efi_get_variable_string(EFI_VENDOR_LOADER, "LoaderImageIdentifier", &loader_path) > 0)
1329                         efi_tilt_backslashes(loader_path);
1330                 efi_loader_get_device_part_uuid(&loader_part_uuid);
1331
1332                 printf("System:\n");
1333                 printf("     Firmware: %s (%s)\n", fw_type, strna(fw_info));
1334                 printf("  Secure Boot: %s\n", is_efi_secure_boot() ? "enabled" : "disabled");
1335                 printf("   Setup Mode: %s\n", is_efi_secure_boot_setup_mode() ? "setup" : "user");
1336                 printf("\n");
1337
1338                 printf("Loader:\n");
1339                 printf("      Product: %s\n", strna(loader));
1340                 if (!sd_id128_equal(loader_part_uuid, SD_ID128_NULL))
1341                         printf("    Partition: /dev/disk/by-partuuid/%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\n",
1342                                SD_ID128_FORMAT_VAL(loader_part_uuid));
1343                 else
1344                         printf("    Partition: n/a\n");
1345                 printf("         File: %s%s\n", draw_special_char(DRAW_TREE_RIGHT), strna(loader_path));
1346                 printf("\n");
1347
1348                 r = status_binaries(arg_path, uuid);
1349                 if (r < 0)
1350                         goto finish;
1351
1352                 if (arg_touch_variables)
1353                         r = status_variables();
1354                 break;
1355         }
1356
1357         case ACTION_INSTALL:
1358         case ACTION_UPDATE:
1359                 umask(0002);
1360
1361                 r = install_binaries(arg_path, arg_action == ACTION_INSTALL);
1362                 if (r < 0)
1363                         goto finish;
1364
1365                 if (arg_action == ACTION_INSTALL)
1366                         install_loader_config(arg_path);
1367
1368                 if (arg_touch_variables)
1369                         r = install_variables(arg_path,
1370                                               part, pstart, psize, uuid,
1371                                               "/EFI/systemd/systemd-boot" EFI_MACHINE_TYPE_NAME ".efi",
1372                                               arg_action == ACTION_INSTALL);
1373                 break;
1374
1375         case ACTION_REMOVE:
1376                 r = remove_binaries(arg_path);
1377
1378                 if (arg_touch_variables) {
1379                         q = remove_variables(uuid, "/EFI/systemd/systemd-boot" EFI_MACHINE_TYPE_NAME ".efi", true);
1380                         if (q < 0 && r == 0)
1381                                 r = q;
1382                 }
1383                 break;
1384         }
1385
1386 finish:
1387         return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
1388 }
1389
1390 int main(int argc, char *argv[]) {
1391         int r;
1392
1393         log_parse_environment();
1394         log_open();
1395
1396         r = parse_argv(argc, argv);
1397         if (r <= 0)
1398                 goto finish;
1399
1400         r = bootctl_main(argc, argv);
1401
1402  finish:
1403         return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
1404 }