util-linux/mount.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * Mini mount implementation for busybox
   4  *
   5  * Copyright (C) 1995, 1996 by Bruce Perens <bruce@pixar.com>.
   6  * Copyright (C) 1999-2002 by Erik Andersen <andersee@debian.org>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16  * General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  21  *
  22  * 3/21/1999    Charles P. Wright <cpwright@cpwright.com>
  23  *              searches through fstab when -a is passed
  24  *              will try mounting stuff with all fses when passed -t auto
  25  *
  26  * 1999-04-17   Dave Cinege...Rewrote -t auto. Fixed ro mtab.
  27  *
  28  * 1999-10-07   Erik Andersen <andersee@debian.org>.
  29  *              Rewrite of a lot of code. Removed mtab usage (I plan on
  30  *              putting it back as a compile-time option some time),
  31  *              major adjustments to option parsing, and some serious
  32  *              dieting all around.
  33  *
  34  * 1999-11-06   mtab suppport is back - andersee
  35  *
  36  * 2000-01-12   Ben Collins <bcollins@debian.org>, Borrowed utils-linux's
  37  *              mount to add loop support.
  38  *
  39  * 2000-04-30   Dave Cinege <dcinege@psychosis.com>
  40  *              Rewrote fstab while loop and lower mount section. Can now do
  41  *              single mounts from fstab. Can override fstab options for single
  42  *              mount. Common mount_one call for single mounts and 'all'. Fixed
  43  *              mtab updating and stale entries. Removed 'remount' default.
  44  *
  45  */
  46
  47 #include <limits.h>
  48 #include <stdlib.h>
  49 #include <unistd.h>
  50 #include <errno.h>
  51 #include <string.h>
  52 #include <stdio.h>
  53 #include <mntent.h>
  54 #include <ctype.h>
  55 #include "busybox.h"
  56
  57 enum {
  58         MS_MGC_VAL = 0xc0ed0000,        /* Magic number indicatng "new" flags */
  59         MS_RDONLY = 1,          /* Mount read-only */
  60         MS_NOSUID = 2,          /* Ignore suid and sgid bits */
  61         MS_NODEV = 4,           /* Disallow access to device special files */
  62         MS_NOEXEC = 8,          /* Disallow program execution */
  63         MS_SYNCHRONOUS = 16,    /* Writes are synced at once */
  64         MS_REMOUNT = 32,        /* Alter flags of a mounted FS */
  65         MS_MANDLOCK = 64,       /* Allow mandatory locks on an FS */
  66         S_QUOTA = 128,          /* Quota initialized for file/directory/symlink */
  67         S_APPEND = 256,         /* Append-only file */
  68         S_IMMUTABLE = 512,      /* Immutable file */
  69         MS_NOATIME = 1024,      /* Do not update access times. */
  70         MS_NODIRATIME = 2048,   /* Do not update directory access times */
  71         MS_BIND = 4096,         /* Use the new linux 2.4.x "mount --bind" feature */
  72 };
  73
  74
  75 #if defined CONFIG_FEATURE_MOUNT_LOOP
  76 #include <fcntl.h>
  77 #include <sys/ioctl.h>
  78 static int use_loop = FALSE;
  79 #endif
  80
  81 extern int mount(__const char *__special_file, __const char *__dir,
  82                                  __const char *__fstype, unsigned long int __rwflag,
  83                                  __const void *__data);
  84 extern int umount(__const char *__special_file);
  85 extern int umount2(__const char *__special_file, int __flags);
  86
  87 extern int sysfs(int option, unsigned int fs_index, char *buf);
  88
  89 extern const char mtab_file[];  /* Defined in utility.c */
  90
  91 struct mount_options {
  92         const char *name;
  93         unsigned long and;
  94         unsigned long or;
  95 };
  96
  97 static const struct mount_options mount_options[] = {
  98         {"async", ~MS_SYNCHRONOUS, 0},
  99         {"atime", ~0, ~MS_NOATIME},
 100         {"defaults", ~0, 0},
 101         {"noauto", ~0, 0},
 102         {"dev", ~MS_NODEV, 0},
 103         {"diratime", ~0, ~MS_NODIRATIME},
 104         {"exec", ~MS_NOEXEC, 0},
 105         {"noatime", ~0, MS_NOATIME},
 106         {"nodev", ~0, MS_NODEV},
 107         {"nodiratime", ~0, MS_NODIRATIME},
 108         {"noexec", ~0, MS_NOEXEC},
 109         {"nosuid", ~0, MS_NOSUID},
 110         {"remount", ~0, MS_REMOUNT},
 111         {"ro", ~0, MS_RDONLY},
 112         {"rw", ~MS_RDONLY, 0},
 113         {"suid", ~MS_NOSUID, 0},
 114         {"sync", ~0, MS_SYNCHRONOUS},
 115         {"bind", ~0, MS_BIND},
 116         {0, 0, 0}
 117 };
 118
 119 static int
 120 do_mount(char *specialfile, char *dir, char *filesystemtype, long flags,
 121                  void *string_flags, int useMtab, int fakeIt, char *mtab_opts,
 122                  int mount_all)
 123 {
 124         int status = 0;
 125
 126 #if defined CONFIG_FEATURE_MOUNT_LOOP
 127         char *lofile = NULL;
 128 #endif
 129
 130         if (!fakeIt) {
 131 #if defined CONFIG_FEATURE_MOUNT_LOOP
 132                 if (use_loop == TRUE) {
 133                         int loro = flags & MS_RDONLY;
 134
 135                         lofile = specialfile;
 136
 137                         specialfile = find_unused_loop_device();
 138                         if (specialfile == NULL) {
 139                                 error_msg_and_die("Could not find a spare loop device");
 140                         }
 141                         if (set_loop(specialfile, lofile, 0, &loro)) {
 142                                 error_msg_and_die("Could not setup loop device");
 143                         }
 144                         if (!(flags & MS_RDONLY) && loro) {     /* loop is ro, but wanted rw */
 145                                 error_msg("WARNING: loop device is read-only");
 146                                 flags |= MS_RDONLY;
 147                         }
 148                 }
 149 #endif
 150                 status = mount(specialfile, dir, filesystemtype, flags, string_flags);
 151                 if (status < 0 && errno == EROFS) {
 152                         error_msg("%s is write-protected, mounting read-only",
 153                                           specialfile);
 154                         status = mount(specialfile, dir, filesystemtype, flags |=
 155                                                    MS_RDONLY, string_flags);
 156                 }
 157                 /* Don't whine about already mounted filesystems when mounting all. */
 158                 if (status < 0 && errno == EBUSY && mount_all) {
 159                         return TRUE;
 160                 }
 161         }
 162
 163
 164         /* If the mount was sucessful, do anything needed, then return TRUE */
 165         if (status == 0 || fakeIt == TRUE) {
 166
 167 #if defined CONFIG_FEATURE_MTAB_SUPPORT
 168                 if (useMtab) {
 169                         erase_mtab(specialfile);        /* Clean any stale entries */
 170                         write_mtab(specialfile, dir, filesystemtype, flags, mtab_opts);
 171                 }
 172 #endif
 173                 return (TRUE);
 174         }
 175
 176         /* Bummer.  mount failed.  Clean up */
 177 #if defined CONFIG_FEATURE_MOUNT_LOOP
 178         if (lofile != NULL) {
 179                 del_loop(specialfile);
 180         }
 181 #endif
 182
 183         if (errno == EPERM) {
 184                 error_msg_and_die("permission denied. Are you root?");
 185         }
 186
 187         return (FALSE);
 188 }
 189
 190
 191 static void paste_str(char **s1, const char *s2)
 192 {
 193         *s1 = xrealloc(*s1, strlen(*s1) + strlen(s2) + 1);
 194         strcat(*s1, s2);
 195 }
 196
 197 /* Seperate standard mount options from the nonstandard string options */
 198 static void parse_mount_options(char *options, int *flags, char **strflags)
 199 {
 200         while (options) {
 201                 int gotone = FALSE;
 202                 char *comma = strchr(options, ',');
 203                 const struct mount_options *f = mount_options;
 204
 205                 if (comma) {
 206                         *comma = '\0';
 207                 }
 208
 209                 while (f->name != 0) {
 210                         if (strcasecmp(f->name, options) == 0) {
 211
 212                                 *flags &= f->and;
 213                                 *flags |= f->or;
 214                                 gotone = TRUE;
 215                                 break;
 216                         }
 217                         f++;
 218                 }
 219 #if defined CONFIG_FEATURE_MOUNT_LOOP
 220                 if (!strcasecmp("loop", options)) {     /* loop device support */
 221                         use_loop = TRUE;
 222                         gotone = TRUE;
 223                 }
 224 #endif
 225                 if (!gotone) {
 226                         if (**strflags) {
 227                                 /* have previous parsed options */
 228                                 paste_str(strflags, ",");
 229                         }
 230                         paste_str(strflags, options);
 231                 }
 232                 if (comma) {
 233                         *comma = ',';
 234                         options = ++comma;
 235                 } else {
 236                         break;
 237                 }
 238         }
 239 }
 240
 241 static int mount_one(char *blockDevice, char *directory, char *filesystemType,
 242                                          unsigned long flags, char *string_flags, int useMtab,
 243                                          int fakeIt, char *mtab_opts, int whineOnErrors,
 244                                          int mount_all)
 245 {
 246         int status = 0;
 247         if (strcmp(filesystemType, "auto") == 0) {
 248                 char buf[255];
 249                 FILE *f;
 250                 int read_proc = 0;
 251
 252                 f = fopen("/etc/filesystems", "r");
 253
 254                 if (f) {
 255                         while (fgets(buf, sizeof(buf), f)) {
 256                                 if (*buf == '*') {
 257                                         read_proc = 1;
 258                                 } else if (*buf == '#') {
 259                                         continue;
 260                                 } else {
 261                                         filesystemType = buf;
 262
 263                                         /* Add NULL termination to each line */
 264                                         while (*filesystemType && !isspace(*filesystemType)) {
 265                                                 filesystemType++;
 266                                         }
 267                                         *filesystemType = '\0';
 268
 269                                         filesystemType = buf;
 270
 271                                         if (xstrlen(filesystemType)) {
 272                                                 status =
 273                                                         do_mount(blockDevice, directory, filesystemType,
 274                                                                          flags | MS_MGC_VAL, string_flags,
 275                                                                          useMtab, fakeIt, mtab_opts, mount_all);
 276                                                 if (status) {
 277                                                         break;
 278                                                 }
 279                                         }
 280
 281                                 }
 282                         }
 283                         fclose(f);
 284                 }
 285
 286                 if ((!f || read_proc) && !status) {
 287                         f = xfopen("/proc/filesystems", "r");
 288
 289                         while (fgets(buf, sizeof(buf), f) != NULL) {
 290                                 filesystemType = buf;
 291                                 if (*filesystemType == '\t') {  /* Not a nodev filesystem */
 292
 293                                         /* Add NULL termination to each line */
 294                                         while (*filesystemType && *filesystemType != '\n') {
 295                                                 filesystemType++;
 296                                         }
 297                                         *filesystemType = '\0';
 298
 299                                         filesystemType = buf;
 300                                         filesystemType++;       /* hop past tab */
 301
 302                                         status =
 303                                                 do_mount(blockDevice, directory, filesystemType,
 304                                                                  flags | MS_MGC_VAL, string_flags, useMtab,
 305                                                                  fakeIt, mtab_opts, mount_all);
 306                                         if (status) {
 307                                                 break;
 308                                         }
 309                                 }
 310                         }
 311                 }
 312                 fclose(f);
 313         } else {
 314                 status =
 315                         do_mount(blockDevice, directory, filesystemType,
 316                                          flags | MS_MGC_VAL, string_flags, useMtab, fakeIt,
 317                                          mtab_opts, mount_all);
 318         }
 319
 320         if (!status) {
 321                 if (whineOnErrors) {
 322                         perror_msg("Mounting %s on %s failed", blockDevice, directory);
 323                 }
 324                 return (FALSE);
 325         }
 326         return (TRUE);
 327 }
 328
 329 static void show_mounts(char *onlytype)
 330 {
 331         FILE *mountTable = setmntent(mtab_file, "r");
 332
 333         if (mountTable) {
 334                 struct mntent *m;
 335
 336                 while ((m = getmntent(mountTable)) != 0) {
 337                         char *blockDevice = m->mnt_fsname;
 338
 339                         if (strcmp(blockDevice, "/dev/root") == 0) {
 340                                 blockDevice = find_real_root_device_name(blockDevice);
 341                         }
 342                         if (!onlytype || (strcmp(m->mnt_type, onlytype) == 0)) {
 343                                 printf("%s on %s type %s (%s)\n", blockDevice, m->mnt_dir,
 344                                            m->mnt_type, m->mnt_opts);
 345                         }
 346 #ifdef CONFIG_FEATURE_CLEAN_UP
 347                         if (blockDevice != m->mnt_fsname) {
 348                                 free(blockDevice);
 349                         }
 350 #endif
 351                 }
 352                 endmntent(mountTable);
 353         } else {
 354                 perror_msg_and_die("%s", mtab_file);
 355         }
 356         exit(EXIT_SUCCESS);
 357 }
 358
 359 extern int mount_main(int argc, char **argv)
 360 {
 361         struct stat statbuf;
 362         char *string_flags = xstrdup("");
 363         char *extra_opts;
 364         int flags = 0;
 365         char *filesystemType = "auto";
 366         int got_filesystemType = 0;
 367         char *device = xmalloc(PATH_MAX);
 368         char *directory = xmalloc(PATH_MAX);
 369         struct mntent *m = NULL;
 370         int all = FALSE;
 371         int fakeIt = FALSE;
 372         int useMtab = TRUE;
 373         int rc = EXIT_FAILURE;
 374         FILE *f = 0;
 375         int opt;
 376
 377         /* Parse options */
 378         while ((opt = getopt(argc, argv, "o:rt:wafnv")) > 0) {
 379                 switch (opt) {
 380                 case 'o':
 381                         parse_mount_options(optarg, &flags, &string_flags);
 382                         break;
 383                 case 'r':
 384                         flags |= MS_RDONLY;
 385                         break;
 386                 case 't':
 387                         filesystemType = optarg;
 388                         got_filesystemType = 1;
 389                         break;
 390                 case 'w':
 391                         flags &= ~MS_RDONLY;
 392                         break;
 393                 case 'a':
 394                         all = TRUE;
 395                         break;
 396                 case 'f':
 397                         fakeIt = TRUE;
 398                         break;
 399 #ifdef CONFIG_FEATURE_MTAB_SUPPORT
 400                 case 'n':
 401                         useMtab = FALSE;
 402                         break;
 403 #endif
 404                 case 'v':
 405                         break;          /* ignore -v */
 406                 }
 407         }
 408
 409         if (!all && (optind == argc)) {
 410                 show_mounts(got_filesystemType ? filesystemType : NULL);
 411         }
 412
 413         if (optind < argc) {
 414                 /* if device is a filename get its real path */
 415                 if (stat(argv[optind], &statbuf) == 0) {
 416                         char *tmp = simplify_path(argv[optind]);
 417
 418                         safe_strncpy(device, tmp, PATH_MAX);
 419                 } else {
 420                         safe_strncpy(device, argv[optind], PATH_MAX);
 421                 }
 422         }
 423
 424         if (optind + 1 < argc)
 425                 directory = simplify_path(argv[optind + 1]);
 426
 427         if (all || optind + 1 == argc) {
 428                 f = setmntent("/etc/fstab", "r");
 429
 430                 if (f == NULL)
 431                         perror_msg_and_die("\nCannot read /etc/fstab");
 432
 433                 while ((m = getmntent(f)) != NULL) {
 434                         if (!all && (optind + 1 == argc)
 435                                 && ((strcmp(device, m->mnt_fsname) != 0)
 436                                         && (strcmp(device, m->mnt_dir) != 0))) {
 437                                 continue;
 438                         }
 439
 440                         if (all && (    /* If we're mounting 'all' */
 441                                                    (strstr(m->mnt_opts, "noauto")) ||   /* and the file system isn't noauto, */
 442                                                    (strstr(m->mnt_type, "swap")) ||     /* and isn't swap or nfs, then mount it */
 443                                                    (strstr(m->mnt_type, "nfs")))) {
 444                                 continue;
 445                         }
 446
 447                         if (all || flags == 0) {        /* Allow single mount to override fstab flags */
 448                                 flags = 0;
 449                                 string_flags[0] = 0;
 450                                 parse_mount_options(m->mnt_opts, &flags, &string_flags);
 451                         }
 452
 453                         strcpy(device, m->mnt_fsname);
 454                         strcpy(directory, m->mnt_dir);
 455                         filesystemType = xstrdup(m->mnt_type);
 456                   singlemount:
 457                         extra_opts = string_flags;
 458                         rc = EXIT_SUCCESS;
 459 #ifdef CONFIG_NFSMOUNT
 460                         if (strchr(device, ':') != NULL) {
 461                                 filesystemType = "nfs";
 462                                 if (nfsmount
 463                                         (device, directory, &flags, &extra_opts, &string_flags,
 464                                          1)) {
 465                                         perror_msg("nfsmount failed");
 466                                         rc = EXIT_FAILURE;
 467                                 }
 468                         }
 469 #endif
 470                         if (!mount_one
 471                                 (device, directory, filesystemType, flags, string_flags,
 472                                  useMtab, fakeIt, extra_opts, TRUE, all)) {
 473                                 rc = EXIT_FAILURE;
 474                         }
 475                         if (!all) {
 476                                 break;
 477                         }
 478                 }
 479                 if (f) {
 480                         endmntent(f);
 481                 }
 482                 if (!all && f && m == NULL) {
 483                         fprintf(stderr, "Can't find %s in /etc/fstab\n", device);
 484                 }
 485                 return rc;
 486         }
 487
 488         goto singlemount;
 489 }