linux/syslinux.c

   1 /* ----------------------------------------------------------------------- *
   2  *
   3  *   Copyright 1998-2008 H. Peter Anvin - All Rights Reserved
   4  *   Copyright 2009-2010 Intel Corporation; author: H. Peter Anvin
   5  *
   6  *   This program is free software; you can redistribute it and/or modify
   7  *   it under the terms of the GNU General Public License as published by
   8  *   the Free Software Foundation, Inc., 53 Temple Place Ste 330,
   9  *   Boston MA 02111-1307, USA; either version 2 of the License, or
  10  *   (at your option) any later version; incorporated herein by reference.
  11  *
  12  * ----------------------------------------------------------------------- */
  13
  14 /*
  15  * syslinux.c - Linux installer program for SYSLINUX
  16  *
  17  * This is Linux-specific by now.
  18  *
  19  * This is an alternate version of the installer which doesn't require
  20  * mtools, but requires root privilege.
  21  */
  22
  23 /*
  24  * If DO_DIRECT_MOUNT is 0, call mount(8)
  25  * If DO_DIRECT_MOUNT is 1, call mount(2)
  26  */
  27 #ifdef __KLIBC__
  28 # define DO_DIRECT_MOUNT 1
  29 #else
  30 # define DO_DIRECT_MOUNT 0      /* glibc has broken losetup ioctls */
  31 #endif
  32
  33 #define _GNU_SOURCE
  34 #define _XOPEN_SOURCE 500       /* For pread() pwrite() */
  35 #define _FILE_OFFSET_BITS 64
  36 #include <alloca.h>
  37 #include <errno.h>
  38 #include <fcntl.h>
  39 #include <paths.h>
  40 #include <stdio.h>
  41 #include <string.h>
  42 #include <stdlib.h>
  43 #include <unistd.h>
  44 #include <inttypes.h>
  45 #include <sys/stat.h>
  46 #include <sys/types.h>
  47 #include <sys/wait.h>
  48 #include <sys/mount.h>
  49
  50 #include "linuxioctl.h"
  51
  52 #include <paths.h>
  53 #ifndef _PATH_MOUNT
  54 # define _PATH_MOUNT "/bin/mount"
  55 #endif
  56 #ifndef _PATH_UMOUNT
  57 # define _PATH_UMOUNT "/bin/umount"
  58 #endif
  59 #ifndef _PATH_TMP
  60 # define _PATH_TMP "/tmp/"
  61 #endif
  62
  63 #include "syslinux.h"
  64
  65 #if DO_DIRECT_MOUNT
  66 # include <linux/loop.h>
  67 #endif
  68
  69 #include <getopt.h>
  70 #include <sysexits.h>
  71 #include "syslxcom.h"
  72 #include "syslxfs.h"
  73 #include "setadv.h"
  74 #include "syslxopt.h" /* unified options */
  75
  76 extern const char *program;     /* Name of program */
  77
  78 pid_t mypid;
  79 char *mntpath = NULL;           /* Path on which to mount */
  80
  81 #if DO_DIRECT_MOUNT
  82 int loop_fd = -1;               /* Loop device */
  83 #endif
  84
  85 void __attribute__ ((noreturn)) die(const char *msg)
  86 {
  87     fprintf(stderr, "%s: %s\n", program, msg);
  88
  89 #if DO_DIRECT_MOUNT
  90     if (loop_fd != -1) {
  91         ioctl(loop_fd, LOOP_CLR_FD, 0); /* Free loop device */
  92         close(loop_fd);
  93         loop_fd = -1;
  94     }
  95 #endif
  96
  97     if (mntpath)
  98         unlink(mntpath);
  99
 100     exit(1);
 101 }
 102
 103 /*
 104  * Mount routine
 105  */
 106 int do_mount(int dev_fd, int *cookie, const char *mntpath, const char *fstype)
 107 {
 108     struct stat st;
 109
 110     (void)cookie;
 111
 112     if (fstat(dev_fd, &st) < 0)
 113         return errno;
 114
 115 #if DO_DIRECT_MOUNT
 116     {
 117         if (!S_ISBLK(st.st_mode)) {
 118             /* It's file, need to mount it loopback */
 119             unsigned int n = 0;
 120             struct loop_info64 loopinfo;
 121             int loop_fd;
 122
 123             for (n = 0; loop_fd < 0; n++) {
 124                 snprintf(devfdname, sizeof devfdname, "/dev/loop%u", n);
 125                 loop_fd = open(devfdname, O_RDWR);
 126                 if (loop_fd < 0 && errno == ENOENT) {
 127                     die("no available loopback device!");
 128                 }
 129                 if (ioctl(loop_fd, LOOP_SET_FD, (void *)dev_fd)) {
 130                     close(loop_fd);
 131                     loop_fd = -1;
 132                     if (errno != EBUSY)
 133                         die("cannot set up loopback device");
 134                     else
 135                         continue;
 136                 }
 137
 138                 if (ioctl(loop_fd, LOOP_GET_STATUS64, &loopinfo) ||
 139                     (loopinfo.lo_offset = opt.offset,
 140                      ioctl(loop_fd, LOOP_SET_STATUS64, &loopinfo)))
 141                     die("cannot set up loopback device");
 142             }
 143
 144             *cookie = loop_fd;
 145         } else {
 146             snprintf(devfdname, sizeof devfdname, "/proc/%lu/fd/%d",
 147                      (unsigned long)mypid, dev_fd);
 148             *cookie = -1;
 149         }
 150
 151         return mount(devfdname, mntpath, fstype,
 152                      MS_NOEXEC | MS_NOSUID, "umask=077,quiet");
 153     }
 154 #else
 155     {
 156         char devfdname[128], mnt_opts[128];
 157         pid_t f, w;
 158         int status;
 159
 160         snprintf(devfdname, sizeof devfdname, "/proc/%lu/fd/%d",
 161                  (unsigned long)mypid, dev_fd);
 162
 163         f = fork();
 164         if (f < 0) {
 165             return -1;
 166         } else if (f == 0) {
 167             if (!S_ISBLK(st.st_mode)) {
 168                 snprintf(mnt_opts, sizeof mnt_opts,
 169                          "rw,nodev,noexec,loop,offset=%llu,umask=077,quiet",
 170                          (unsigned long long)opt.offset);
 171             } else {
 172                 snprintf(mnt_opts, sizeof mnt_opts,
 173                          "rw,nodev,noexec,umask=077,quiet");
 174             }
 175             execl(_PATH_MOUNT, _PATH_MOUNT, "-t", fstype, "-o", mnt_opts,
 176                   devfdname, mntpath, NULL);
 177             _exit(255);         /* execl failed */
 178         }
 179
 180         w = waitpid(f, &status, 0);
 181         return (w != f || status) ? -1 : 0;
 182     }
 183 #endif
 184 }
 185
 186 /*
 187  * umount routine
 188  */
 189 void do_umount(const char *mntpath, int cookie)
 190 {
 191 #if DO_DIRECT_MOUNT
 192     int loop_fd = cookie;
 193
 194     if (umount2(mntpath, 0))
 195         die("could not umount path");
 196
 197     if (loop_fd != -1) {
 198         ioctl(loop_fd, LOOP_CLR_FD, 0); /* Free loop device */
 199         close(loop_fd);
 200         loop_fd = -1;
 201     }
 202 #else
 203     pid_t f = fork();
 204     pid_t w;
 205     int status;
 206     (void)cookie;
 207
 208     if (f < 0) {
 209         perror("fork");
 210         exit(1);
 211     } else if (f == 0) {
 212         execl(_PATH_UMOUNT, _PATH_UMOUNT, mntpath, NULL);
 213     }
 214
 215     w = waitpid(f, &status, 0);
 216     if (w != f || status) {
 217         exit(1);
 218     }
 219 #endif
 220 }
 221
 222 /*
 223  * Modify the ADV of an existing installation
 224  */
 225 int modify_existing_adv(const char *path)
 226 {
 227     if (opt.reset_adv)
 228         syslinux_reset_adv(syslinux_adv);
 229     else if (read_adv(path, "ldlinux.sys") < 0)
 230         return 1;
 231
 232     if (modify_adv() < 0)
 233         return 1;
 234
 235     if (write_adv(path, "ldlinux.sys") < 0)
 236         return 1;
 237
 238     return 0;
 239 }
 240
 241 int do_open_file(char *name)
 242 {
 243     int fd;
 244
 245     if ((fd = open(name, O_RDONLY)) >= 0) {
 246         uint32_t zero_attr = 0;
 247         ioctl(fd, FAT_IOCTL_SET_ATTRIBUTES, &zero_attr);
 248         close(fd);
 249     }
 250
 251     unlink(name);
 252     fd = open(name, O_WRONLY | O_CREAT | O_TRUNC, 0444);
 253     if (fd < 0)
 254         perror(opt.device);
 255
 256     return fd;
 257 }
 258
 259 int main(int argc, char *argv[])
 260 {
 261     static unsigned char sectbuf[SECTOR_SIZE];
 262     int dev_fd, fd;
 263     struct stat st;
 264     int err = 0;
 265     char mntname[128];
 266     char *ldlinux_name;
 267     char *ldlinux_path;
 268     char *subdir;
 269     sector_t *sectors = NULL;
 270     int ldlinux_sectors = (boot_image_len + SECTOR_SIZE - 1) >> SECTOR_SHIFT;
 271     const char *errmsg;
 272     int mnt_cookie;
 273     int patch_sectors;
 274     int i, rv;
 275
 276     mypid = getpid();
 277     umask(077);
 278     parse_options(argc, argv, MODE_SYSLINUX);
 279
 280     /* Note: subdir is guaranteed to start and end in / */
 281     if (opt.directory && opt.directory[0]) {
 282         int len = strlen(opt.directory);
 283         int rv = asprintf(&subdir, "%s%s%s",
 284                           opt.directory[0] == '/' ? "" : "/",
 285                           opt.directory,
 286                           opt.directory[len-1] == '/' ? "" : "/");
 287         if (rv < 0 || !subdir) {
 288             perror(program);
 289             exit(1);
 290         }
 291     } else {
 292         subdir = "/";
 293     }
 294
 295     if (!opt.device || opt.install_mbr || opt.activate_partition)
 296         usage(EX_USAGE, MODE_SYSLINUX);
 297
 298     /*
 299      * First make sure we can open the device at all, and that we have
 300      * read/write permission.
 301      */
 302     dev_fd = open(opt.device, O_RDWR);
 303     if (dev_fd < 0 || fstat(dev_fd, &st) < 0) {
 304         perror(opt.device);
 305         exit(1);
 306     }
 307
 308     if (!S_ISBLK(st.st_mode) && !S_ISREG(st.st_mode) && !S_ISCHR(st.st_mode)) {
 309         die("not a device or regular file");
 310     }
 311
 312     if (opt.offset && S_ISBLK(st.st_mode)) {
 313         die("can't combine an offset with a block device");
 314     }
 315
 316     xpread(dev_fd, sectbuf, SECTOR_SIZE, opt.offset);
 317     fsync(dev_fd);
 318
 319     /*
 320      * Check to see that what we got was indeed an FAT/NTFS
 321      * boot sector/superblock
 322      */
 323     if ((errmsg = syslinux_check_bootsect(sectbuf, &fs_type))) {
 324         fprintf(stderr, "%s: %s\n", opt.device, errmsg);
 325         exit(1);
 326     }
 327
 328     /*
 329      * Now mount the device.
 330      */
 331     if (geteuid()) {
 332         die("This program needs root privilege");
 333     } else {
 334         int i = 0;
 335         struct stat dst;
 336         int rv;
 337
 338         /* We're root or at least setuid.
 339            Make a temp dir and pass all the gunky options to mount. */
 340
 341         if (chdir(_PATH_TMP)) {
 342             fprintf(stderr, "%s: Cannot access the %s directory.\n",
 343                     program, _PATH_TMP);
 344             exit(1);
 345         }
 346 #define TMP_MODE (S_IXUSR|S_IWUSR|S_IXGRP|S_IWGRP|S_IWOTH|S_IXOTH|S_ISVTX)
 347
 348         if (stat(".", &dst) || !S_ISDIR(dst.st_mode) ||
 349             (dst.st_mode & TMP_MODE) != TMP_MODE) {
 350             die("possibly unsafe " _PATH_TMP " permissions");
 351         }
 352
 353         for (i = 0;; i++) {
 354             snprintf(mntname, sizeof mntname, "syslinux.mnt.%lu.%d",
 355                      (unsigned long)mypid, i);
 356
 357             if (lstat(mntname, &dst) != -1 || errno != ENOENT)
 358                 continue;
 359
 360             rv = mkdir(mntname, 0000);
 361
 362             if (rv == -1) {
 363                 if (errno == EEXIST || errno == EINTR)
 364                     continue;
 365                 perror(program);
 366                 exit(1);
 367             }
 368
 369             if (lstat(mntname, &dst) || dst.st_mode != (S_IFDIR | 0000) ||
 370                 dst.st_uid != 0) {
 371                 die("someone is trying to symlink race us!");
 372             }
 373             break;              /* OK, got something... */
 374         }
 375
 376         mntpath = mntname;
 377     }
 378
 379     if (fs_type == VFAT) {
 380         if (do_mount(dev_fd, &mnt_cookie, mntpath, "vfat") &&
 381             do_mount(dev_fd, &mnt_cookie, mntpath, "msdos")) {
 382             rmdir(mntpath);
 383             die("failed on mounting fat volume");
 384         }
 385     } else if (fs_type == NTFS) {
 386         if (do_mount(dev_fd, &mnt_cookie, mntpath, "ntfs-3g")) {
 387             rmdir(mntpath);
 388             die("failed on mounting ntfs volume");
 389         }
 390     }
 391
 392     ldlinux_path = alloca(strlen(mntpath) + strlen(subdir) + 1);
 393     sprintf(ldlinux_path, "%s%s", mntpath, subdir);
 394
 395     ldlinux_name = alloca(strlen(ldlinux_path) + 14);
 396     if (!ldlinux_name) {
 397         perror(program);
 398         err = 1;
 399         goto umount;
 400     }
 401     sprintf(ldlinux_name, "%sldlinux.sys", ldlinux_path);
 402
 403     /* update ADV only ? */
 404     if (opt.update_only == -1) {
 405         if (opt.reset_adv || opt.set_once) {
 406             modify_existing_adv(ldlinux_path);
 407             do_umount(mntpath, mnt_cookie);
 408             sync();
 409             rmdir(mntpath);
 410             exit(0);
 411     } else if (opt.update_only && !syslinux_already_installed(dev_fd)) {
 412         fprintf(stderr, "%s: no previous syslinux boot sector found\n",
 413                 argv[0]);
 414         exit(1);
 415         } else {
 416             fprintf(stderr, "%s: please specify --install or --update for the future\n", argv[0]);
 417             opt.update_only = 0;
 418         }
 419     }
 420
 421     /* Read a pre-existing ADV, if already installed */
 422     if (opt.reset_adv)
 423         syslinux_reset_adv(syslinux_adv);
 424     else if (read_adv(ldlinux_path, "ldlinux.sys") < 0)
 425         syslinux_reset_adv(syslinux_adv);
 426     if (modify_adv() < 0)
 427         exit(1);
 428
 429     fd = do_open_file(ldlinux_name);
 430     if (fd < 0) {
 431         err = 1;
 432         goto umount;
 433     }
 434
 435     /* Write it the first time */
 436     if (xpwrite(fd, boot_image, boot_image_len, 0) != (int)boot_image_len ||
 437         xpwrite(fd, syslinux_adv, 2 * ADV_SIZE,
 438                 boot_image_len) != 2 * ADV_SIZE) {
 439         fprintf(stderr, "%s: write failure on %s\n", program, ldlinux_name);
 440         exit(1);
 441     }
 442
 443     fsync(fd);
 444     /*
 445      * Set the attributes
 446      */
 447     {
 448         uint32_t attr = 0x07;   /* Hidden+System+Readonly */
 449         ioctl(fd, FAT_IOCTL_SET_ATTRIBUTES, &attr);
 450     }
 451
 452     /*
 453      * Create a block map.
 454      */
 455     ldlinux_sectors += 2; /* 2 ADV sectors */
 456     sectors = calloc(ldlinux_sectors, sizeof *sectors);
 457     if (sectmap(fd, sectors, ldlinux_sectors)) {
 458         perror("bmap");
 459         exit(1);
 460     }
 461     close(fd);
 462     sync();
 463
 464     sprintf(ldlinux_name, "%sldlinux.c32", ldlinux_path);
 465     fd = do_open_file(ldlinux_name);
 466     if (fd < 0) {
 467         err = 1;
 468         goto umount;
 469     }
 470
 471     rv = xpwrite(fd, syslinux_ldlinuxc32, syslinux_ldlinuxc32_len, 0);
 472     if (rv != (int)syslinux_ldlinuxc32_len) {
 473         fprintf(stderr, "%s: write failure on %s\n", program, ldlinux_name);
 474         exit(1);
 475     }
 476
 477     fsync(fd);
 478     /*
 479      * Set the attributes
 480      */
 481     {
 482         uint32_t attr = 0x07;   /* Hidden+System+Readonly */
 483         ioctl(fd, FAT_IOCTL_SET_ATTRIBUTES, &attr);
 484     }
 485
 486     close(fd);
 487     sync();
 488
 489 umount:
 490     do_umount(mntpath, mnt_cookie);
 491     sync();
 492     rmdir(mntpath);
 493
 494     if (err)
 495         exit(err);
 496
 497     /*
 498      * Patch ldlinux.sys and the boot sector
 499      */
 500     i = syslinux_patch(sectors, ldlinux_sectors, opt.stupid_mode,
 501                        opt.raid_mode, subdir, NULL);
 502     patch_sectors = (i + SECTOR_SIZE - 1) >> SECTOR_SHIFT;
 503
 504     /*
 505      * Write the now-patched first sectors of ldlinux.sys
 506      */
 507     for (i = 0; i < patch_sectors; i++) {
 508         xpwrite(dev_fd, boot_image + i * SECTOR_SIZE, SECTOR_SIZE,
 509                 opt.offset + ((off_t) sectors[i] << SECTOR_SHIFT));
 510     }
 511
 512     /*
 513      * To finish up, write the boot sector
 514      */
 515
 516     /* Read the superblock again since it might have changed while mounted */
 517     xpread(dev_fd, sectbuf, SECTOR_SIZE, opt.offset);
 518
 519     /* Copy the syslinux code into the boot sector */
 520     syslinux_make_bootsect(sectbuf, fs_type);
 521
 522     /* Write new boot sector */
 523     xpwrite(dev_fd, sectbuf, SECTOR_SIZE, opt.offset);
 524
 525     close(dev_fd);
 526     sync();
 527
 528     /* Done! */
 529
 530     return 0;
 531 }