linux/syslinux.c

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