Removed trailing \n from error_msg{,_and_die} messages.
[oweals/busybox.git] / util-linux / mount.c
index 76f048b1c86c55dfb717b317f104e3d9f7b439aa..b571e5035c658a3edd2ad20c8a271a02ab77451c 100644 (file)
  *
  * 2000-01-12   Ben Collins <bcollins@debian.org>, Borrowed utils-linux's
  *              mount to add loop support.
+ *
+ * 2000-04-30  Dave Cinege <dcinege@psychosis.com>
+ *             Rewrote fstab while loop and lower mount section. Can now do
+ *             single mounts from fstab. Can override fstab options for single
+ *             mount. Common mount_one call for single mounts and 'all'. Fixed
+ *             mtab updating and stale entries. Removed 'remount' default. 
+ *     
  */
 
-#include "internal.h"
+#include "busybox.h"
 #include <stdlib.h>
 #include <unistd.h>
 #include <errno.h>
 #include <string.h>
 #include <stdio.h>
 #include <mntent.h>
-#include <sys/mount.h>
 #include <ctype.h>
 #if defined BB_FEATURE_USE_DEVPS_PATCH
-#include <linux/devmtab.h>
-#endif
-#ifndef MS_RDONLY
-#include <linux/fs.h>
+#include <linux/devmtab.h> /* For Erik's nifty devmtab device driver */
 #endif
 
+enum {
+       MS_MGC_VAL = 0xc0ed0000, /* Magic number indicatng "new" flags */
+       MS_RDONLY = 1,      /* Mount read-only */
+       MS_NOSUID = 2,      /* Ignore suid and sgid bits */
+       MS_NODEV = 4,      /* Disallow access to device special files */
+       MS_NOEXEC = 8,      /* Disallow program execution */
+       MS_SYNCHRONOUS = 16,      /* Writes are synced at once */
+       MS_REMOUNT = 32,      /* Alter flags of a mounted FS */
+       MS_MANDLOCK = 64,      /* Allow mandatory locks on an FS */
+       S_QUOTA = 128,     /* Quota initialized for file/directory/symlink */
+       S_APPEND = 256,     /* Append-only file */
+       S_IMMUTABLE = 512,     /* Immutable file */
+       MS_NOATIME = 1024,    /* Do not update access times. */
+       MS_NODIRATIME = 2048,    /* Do not update directory access times */
+};
+
 
 #if defined BB_FEATURE_MOUNT_LOOP
 #include <fcntl.h>
 #include <sys/ioctl.h>
-#include <linux/loop.h>
-
-
 static int use_loop = FALSE;
 #endif
 
-extern const char mtab_file[]; /* Defined in utility.c */
+extern int mount (__const char *__special_file, __const char *__dir,
+                       __const char *__fstype, unsigned long int __rwflag,
+                       __const void *__data);
+extern int umount (__const char *__special_file);
+extern int umount2 (__const char *__special_file, int __flags);
 
-static const char mount_usage[] = 
-       "mount [flags] device directory [-o options,more-options]\n"
-#ifndef BB_FEATURE_TRIVIAL_HELP
-       "\nMount a filesystem\n\n"
-       "Flags:\n" 
-       "\t-a:\t\tMount all filesystems in fstab.\n"
-#ifdef BB_MTAB
-       "\t-f:\t\t\"Fake\" mount. Add entry to mount table but don't mount it.\n"
-       "\t-n:\t\tDon't write a mount table entry.\n"
-#endif
-       "\t-o option:\tOne of many filesystem options, listed below.\n"
-       "\t-r:\t\tMount the filesystem read-only.\n"
-       "\t-t fs-type:\tSpecify the filesystem type.\n"
-       "\t-w:\t\tMount for reading and writing (default).\n"
-       "\n"
-       "Options for use with the \"-o\" flag:\n"
-       "\tasync/sync:\tWrites are asynchronous / synchronous.\n"
-       "\tatime/noatime:\tEnable / disable updates to inode access times.\n"
-       "\tdev/nodev:\tAllow use of special device files / disallow them.\n"
-       "\texec/noexec:\tAllow use of executable files / disallow them.\n"
-#if defined BB_FEATURE_MOUNT_LOOP
-       "\tloop:\t\tMounts a file via loop device.\n"
-#endif
-       "\tsuid/nosuid:\tAllow set-user-id-root programs / disallow them.\n"
-       "\tremount:\tRe-mount a currently-mounted filesystem, changing its flags.\n"
-       "\tro/rw:\t\tMount for read-only / read-write.\n"
-       "\nThere are EVEN MORE flags that are specific to each filesystem.\n"
-       "You'll have to see the written documentation for those.\n"
-#endif
-       ;
 
+extern const char mtab_file[]; /* Defined in utility.c */
 
 struct mount_options {
        const char *name;
@@ -128,11 +119,11 @@ do_mount(char *specialfile, char *dir, char *filesystemtype,
                 char *mtab_opts)
 {
        int status = 0;
+#if defined BB_FEATURE_MOUNT_LOOP
        char *lofile = NULL;
+#endif
 
-#if defined BB_MTAB
        if (fakeIt == FALSE)
-#endif
        {
 #if defined BB_FEATURE_MOUNT_LOOP
                if (use_loop==TRUE) {
@@ -141,28 +132,31 @@ do_mount(char *specialfile, char *dir, char *filesystemtype,
 
                        specialfile = find_unused_loop_device();
                        if (specialfile == NULL) {
-                               fprintf(stderr, "Could not find a spare loop device\n");
-                               return (FALSE);
+                               error_msg_and_die("Could not find a spare loop device");
                        }
                        if (set_loop(specialfile, lofile, 0, &loro)) {
-                               fprintf(stderr, "Could not setup loop device\n");
-                               return (FALSE);
+                               error_msg_and_die("Could not setup loop device");
                        }
                        if (!(flags & MS_RDONLY) && loro) {     /* loop is ro, but wanted rw */
-                               fprintf(stderr, "WARNING: loop device is read-only\n");
+                               error_msg("WARNING: loop device is read-only");
                                flags &= ~MS_RDONLY;
                        }
                }
 #endif
                status = mount(specialfile, dir, filesystemtype, flags, string_flags);
+               if (errno == EROFS) {
+                       error_msg("%s is write-protected, mounting read-only", specialfile);
+                       status = mount(specialfile, dir, filesystemtype, flags |= MS_RDONLY, string_flags);
+               }
        }
 
 
        /* If the mount was sucessful, do anything needed, then return TRUE */
-       if (status == 0) {
+       if (status == 0 || fakeIt==TRUE) {
 
 #if defined BB_MTAB
                if (useMtab == TRUE) {
+                       erase_mtab(specialfile);        // Clean any stale entries
                        write_mtab(specialfile, dir, filesystemtype, flags, mtab_opts);
                }
 #endif
@@ -177,7 +171,7 @@ do_mount(char *specialfile, char *dir, char *filesystemtype,
 #endif
 
        if (errno == EPERM) {
-               fatalError("mount: permission denied. Are you root?\n");
+               error_msg_and_die("permission denied. Are you root?");
        }
 
        return (FALSE);
@@ -187,7 +181,7 @@ do_mount(char *specialfile, char *dir, char *filesystemtype,
 
 /* Seperate standard mount options from the nonstandard string options */
 static void
-parse_mount_options(char *options, unsigned long *flags, char *strflags)
+parse_mount_options(char *options, int *flags, char *strflags)
 {
        while (options) {
                int gotone = FALSE;
@@ -277,18 +271,18 @@ mount_one(char *blockDevice, char *directory, char *filesystemType,
                /* open device */ 
                fd = open(device, O_RDONLY);
                if (fd < 0)
-                       fatalError("open failed for `%s': %s\n", device, strerror (errno));
+                       perror_msg_and_die("open failed for `%s'", device);
 
                /* How many filesystems?  We need to know to allocate enough space */
                numfilesystems = ioctl (fd, DEVMTAB_COUNT_FILESYSTEMS);
                if (numfilesystems<0)
-                       fatalError("\nDEVMTAB_COUNT_FILESYSTEMS: %s\n", strerror (errno));
-               fslist = (struct k_fstype *) calloc ( numfilesystems, sizeof(struct k_fstype));
+                       perror_msg_and_die("\nDEVMTAB_COUNT_FILESYSTEMS");
+               fslist = (struct k_fstype *) xcalloc ( numfilesystems, sizeof(struct k_fstype));
 
                /* Grab the list of available filesystems */
                status = ioctl (fd, DEVMTAB_GET_FILESYSTEMS, fslist);
                if (status<0)
-                       fatalError("\nDEVMTAB_GET_FILESYSTEMS: %s\n", strerror (errno));
+                       perror_msg_and_die("\nDEVMTAB_GET_FILESYSTEMS");
 
                /* Walk the list trying to mount filesystems 
                 * that do not claim to be nodev filesystems */
@@ -313,8 +307,7 @@ mount_one(char *blockDevice, char *directory, char *filesystemType,
 
        if (status == FALSE) {
                if (whineOnErrors == TRUE) {
-                       fprintf(stderr, "Mounting %s on %s failed: %s\n",
-                                       blockDevice, directory, strerror(errno));
+                       perror_msg("Mounting %s on %s failed", blockDevice, directory);
                }
                return (FALSE);
        }
@@ -326,7 +319,7 @@ extern int mount_main(int argc, char **argv)
        char string_flags_buf[1024] = "";
        char *string_flags = string_flags_buf;
        char *extra_opts = string_flags_buf;
-       unsigned long flags = 0;
+       int flags = 0;
        char *filesystemType = "auto";
        char *device = NULL;
        char *directory = NULL;
@@ -334,6 +327,8 @@ extern int mount_main(int argc, char **argv)
        int fakeIt = FALSE;
        int useMtab = TRUE;
        int i;
+       int rc = EXIT_FAILURE;
+       int fstabmount = FALSE; 
 
 #if defined BB_FEATURE_USE_DEVPS_PATCH
        if (argc == 1) {
@@ -344,32 +339,32 @@ extern int mount_main(int argc, char **argv)
                /* open device */ 
                fd = open(device, O_RDONLY);
                if (fd < 0)
-                       fatalError("open failed for `%s': %s\n", device, strerror (errno));
+                       perror_msg_and_die("open failed for `%s'", device);
 
                /* How many mounted filesystems?  We need to know to 
                 * allocate enough space for later... */
                numfilesystems = ioctl (fd, DEVMTAB_COUNT_MOUNTS);
                if (numfilesystems<0)
-                       fatalError( "\nDEVMTAB_COUNT_MOUNTS: %s\n", strerror (errno));
-               mntentlist = (struct k_mntent *) calloc ( numfilesystems, sizeof(struct k_mntent));
+                       perror_msg_and_die( "\nDEVMTAB_COUNT_MOUNTS");
+               mntentlist = (struct k_mntent *) xcalloc ( numfilesystems, sizeof(struct k_mntent));
                
                /* Grab the list of mounted filesystems */
                if (ioctl (fd, DEVMTAB_GET_MOUNTS, mntentlist)<0)
-                       fatalError( "\nDEVMTAB_GET_MOUNTS: %s\n", strerror (errno));
+                       perror_msg_and_die( "\nDEVMTAB_GET_MOUNTS");
 
                for( i = 0 ; i < numfilesystems ; i++) {
-                       fprintf( stdout, "%s %s %s %s %d %d\n", mntentlist[i].mnt_fsname,
+                       printf( "%s %s %s %s %d %d\n", mntentlist[i].mnt_fsname,
                                        mntentlist[i].mnt_dir, mntentlist[i].mnt_type, 
                                        mntentlist[i].mnt_opts, mntentlist[i].mnt_freq, 
                                        mntentlist[i].mnt_passno);
                }
+#ifdef BB_FEATURE_CLEAN_UP
                /* Don't bother to close files or free memory.  Exit 
                 * does that automagically, so we can save a few bytes */
-#if 0
                free( mntentlist);
                close(fd);
 #endif
-               exit(TRUE);
+               return EXIT_SUCCESS;
        }
 #else
        if (argc == 1) {
@@ -388,9 +383,9 @@ extern int mount_main(int argc, char **argv)
                        }
                        endmntent(mountTable);
                } else {
-                       perror(mtab_file);
+                       perror_msg_and_die("%s", mtab_file);
                }
-               exit(TRUE);
+               return EXIT_SUCCESS;
        }
 #endif
 
@@ -451,56 +446,69 @@ extern int mount_main(int argc, char **argv)
                argv++;
        }
 
-       if (all == TRUE) {
+       if (all == TRUE || directory == NULL) {
                struct mntent *m;
                FILE *f = setmntent("/etc/fstab", "r");
+               fstabmount = TRUE;
 
                if (f == NULL)
-                       fatalError( "\nCannot read /etc/fstab: %s\n", strerror (errno));
+                       perror_msg_and_die( "\nCannot read /etc/fstab");
 
                while ((m = getmntent(f)) != NULL) {
-                       // If the filesystem isn't noauto, 
-                       // and isn't swap or nfs, then mount it
-                       if ((!strstr(m->mnt_opts, "noauto")) &&
-                                       (!strstr(m->mnt_type, "swap")) &&
-                                       (!strstr(m->mnt_type, "nfs"))) {
+                       if (all == FALSE && directory == NULL && (
+                               (strcmp(device, m->mnt_fsname) != 0) &&
+                               (strcmp(device, m->mnt_dir) != 0) ) ) {
+                               continue;
+                       }
+                       
+                       if (all == TRUE && (                            // If we're mounting 'all'
+                               (strstr(m->mnt_opts, "noauto")) ||      // and the file system isn't noauto,
+                               (strstr(m->mnt_type, "swap")) ||        // and isn't swap or nfs, then mount it
+                               (strstr(m->mnt_type, "nfs")) ) ) {
+                               continue;
+                       }
+                       
+                       if (all == TRUE || flags == 0) {        // Allow single mount to override fstab flags
                                flags = 0;
                                *string_flags = '\0';
                                parse_mount_options(m->mnt_opts, &flags, string_flags);
-                               if (mount_one(m->mnt_fsname, m->mnt_dir, m->mnt_type,
-                                                       flags, string_flags, useMtab, fakeIt,
-                                                       extra_opts, FALSE)==FALSE) 
-                               {
-                                       /* Try again, but this time try a remount */
-                                       mount_one(m->mnt_fsname, m->mnt_dir, m->mnt_type,
-                                                       flags|MS_REMOUNT, string_flags, useMtab, fakeIt,
-                                                       extra_opts, TRUE);
-                               }
                        }
-               }
-               endmntent(f);
-       } else {
-               if (device && directory) {
+                       
+                       device = strdup(m->mnt_fsname);
+                       directory = strdup(m->mnt_dir);
+                       filesystemType = strdup(m->mnt_type);
+singlemount:                   
+                       rc = EXIT_SUCCESS;
 #ifdef BB_NFSMOUNT
                        if (strchr(device, ':') != NULL)
                                filesystemType = "nfs";
                        if (strcmp(filesystemType, "nfs") == 0) {
-                               int ret;
-                               ret = nfsmount (device, directory, &flags,
-                                               &extra_opts, &string_flags, 1);
-                               if (ret != 0)
-                                       fatalError("nfsmount failed: %s\n", strerror(errno));
+                               rc = nfsmount (device, directory, &flags,
+                                       &extra_opts, &string_flags, 1);
+                               if ( rc != 0) {
+                                       perror_msg_and_die("nfsmount failed");  
+                                       rc = EXIT_FAILURE;
+                               }
                        }
 #endif
-                       exit(mount_one(device, directory, filesystemType,
-                                                  flags, string_flags, useMtab, fakeIt,
-                                                  extra_opts, TRUE));
-               } else {
-                       goto goodbye;
+                       if (!mount_one(device, directory, filesystemType, flags,
+                                       string_flags, useMtab, fakeIt, extra_opts, TRUE))
+                               rc = EXIT_FAILURE;
+                               
+                       if (all == FALSE)
+                               break;
                }
+               if (fstabmount == TRUE)
+                       endmntent(f);
+                       
+               if (all == FALSE && fstabmount == TRUE && directory == NULL)
+                       fprintf(stderr, "Can't find %s in /etc/fstab\n", device);
+       
+               exit(rc);
        }
-       exit(TRUE);
-
-  goodbye:
+       
+       goto singlemount;
+       
+goodbye:
        usage(mount_usage);
 }