X-Git-Url: https://git.decadent.org.uk/gitweb/?p=nfs-utils.git;a=blobdiff_plain;f=utils%2Fmount%2Fmount.c;h=eea00afe2679f28e3e4f10ea11c0553f5f51f712;hp=ca87e3d1b7fb60bc04d7e3504a7bcb4985e79b38;hb=9a5293a10551c03b4fb976503dd24da569fcadb3;hpb=ceeffc1f76485b4084b2c61f4ff3c40e4f51c3b8

diff --git a/utils/mount/mount.c b/utils/mount/mount.c
index ca87e3d..eea00af 100644
--- a/utils/mount/mount.c
+++ b/utils/mount/mount.c
@@ -18,9 +18,13 @@
  *
  */
 
-#include "config.h"
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
 #include <unistd.h>
 #include <sys/types.h>
+#include <sys/stat.h>
 #include <stdio.h>
 #include <string.h>
 #include <errno.h>
@@ -28,21 +32,32 @@
 #include <sys/mount.h>
 #include <getopt.h>
 #include <mntent.h>
+#include <pwd.h>
 
 #include "fstab.h"
 #include "xcommon.h"
+#include "nls.h"
 #include "mount_constants.h"
+#include "mount_config.h"
 #include "nfs_paths.h"
+#include "nfs_mntent.h"
 
 #include "nfs_mount.h"
 #include "nfs4_mount.h"
-#include "nfsumount.h"
 #include "mount.h"
+#include "error.h"
+#include "stropts.h"
+#include "utils.h"
 
 char *progname;
+int nfs_mount_data_version;
 int nomtab;
 int verbose;
-int mounttype;
+int sloppy;
+int string;
+
+#define FOREGROUND	(0)
+#define BACKGROUND	(1)
 
 static struct option longopts[] = {
   { "fake", 0, 0, 'f' },
@@ -55,23 +70,17 @@ static struct option longopts[] = {
   { "read-write", 0, 0, 'w' },
   { "rw", 0, 0, 'w' },
   { "options", 1, 0, 'o' },
-  { "nfsvers", 1, 0, 't' },
-  { "bind", 0, 0, 128 },
-  { "replace", 0, 0, 129 },
-  { "after", 0, 0, 130 },
-  { "before", 0, 0, 131 },
-  { "over", 0, 0, 132 },
-  { "move", 0, 0, 133 },
-  { "rbind", 0, 0, 135 },
   { NULL, 0, 0, 0 }
 };
 
-/* Map from -o and fstab option strings to the flag argument to mount(2).  */
+/*
+ * Map from -o and fstab option strings to the flag argument to mount(2).
+ */
 struct opt_map {
-  const char *opt;              /* option name */
-  int  skip;                    /* skip in mtab option string */
-  int  inv;                     /* true if flag value should be inverted */
-  int  mask;                    /* flag mask value */
+	const char *opt;	/* option name */
+	int skip;		/* skip in mtab option string */
+	int inv;		/* true if flag value should be inverted */
+	int mask;		/* flag mask value */
 };
 
 static const struct opt_map opt_map[] = {
@@ -90,6 +99,18 @@ static const struct opt_map opt_map[] = {
   { "remount",  0, 0, MS_REMOUNT},      /* Alter flags of mounted FS */
   { "bind",     0, 0, MS_BIND   },      /* Remount part of tree elsewhere */
   { "rbind",    0, 0, MS_BIND|MS_REC }, /* Idem, plus mounted subtrees */
+  { "auto",     0, 0, MS_DUMMY },       /* Can be mounted using -a */
+  { "noauto",   0, 0, MS_DUMMY },       /* Can  only be mounted explicitly */
+  { "users",    1, 0, MS_USERS },	/* Allow ordinary user to mount */
+  { "nousers",  0, 1, MS_DUMMY  },      /* Forbid ordinary user to mount */
+  { "user",     1, 0, MS_USER  },	/* Allow ordinary user to mount */
+  { "nouser",   0, 1, MS_DUMMY   },     /* Forbid ordinary user to mount */
+  { "owner",    0, 0, MS_DUMMY  },      /* Let the owner of the device mount */
+  { "noowner",  0, 0, MS_DUMMY  },      /* Device owner has no special privs */
+  { "group",    0, 0, MS_DUMMY  },      /* Let the group of the device mount */
+  { "nogroup",  0, 0, MS_DUMMY  },      /* Device group has no special privs */
+  { "_netdev",  0, 0, MS_DUMMY},        /* Device requires network */
+  { "comment",  0, 0, MS_DUMMY},        /* fstab comment only (kudzu,_netdev)*/
 
   /* add new options here */
 #ifdef MS_NOSUB
@@ -104,6 +125,7 @@ static const struct opt_map opt_map[] = {
   { "mand",     0, 0, MS_MANDLOCK },    /* Allow mandatory locks on this FS */
   { "nomand",   0, 1, MS_MANDLOCK },    /* Forbid mandatory locks on this FS */
 #endif
+  { "loop",     1, 0, MS_DUMMY   },      /* use a loop device */
 #ifdef MS_NOATIME
   { "atime",    0, 1, MS_NOATIME },     /* Update access time */
   { "noatime",  0, 0, MS_NOATIME },     /* Do not update access time */
@@ -112,15 +134,39 @@ static const struct opt_map opt_map[] = {
   { "diratime", 0, 1, MS_NODIRATIME },  /* Update dir access times */
   { "nodiratime", 0, 0, MS_NODIRATIME },/* Do not update dir access times */
 #endif
+#ifdef MS_RELATIME
+  { "relatime", 0, 0, MS_RELATIME },   /* Update access times relative to
+                      mtime/ctime */
+  { "norelatime", 0, 1, MS_RELATIME }, /* Update access time without regard
+                      to mtime/ctime */
+#endif
+  { "noquota", 0, 0, MS_DUMMY },        /* Don't enforce quota */
+  { "quota", 0, 0, MS_DUMMY },          /* Enforce user quota */
+  { "usrquota", 0, 0, MS_DUMMY },       /* Enforce user quota */
+  { "grpquota", 0, 0, MS_DUMMY },       /* Enforce group quota */
   { NULL,	0, 0, 0		}
 };
 
-/* Try to build a canonical options string.  */
-static char * fix_opts_string (int flags, const char *extra_opts) {
+static void parse_opts(const char *options, int *flags, char **extra_opts);
+
+/*
+ * Build a canonical mount option string for /etc/mtab.
+ */
+static char *fix_opts_string(int flags, const char *extra_opts)
+{
 	const struct opt_map *om;
 	char *new_opts;
 
 	new_opts = xstrdup((flags & MS_RDONLY) ? "ro" : "rw");
+	if (flags & MS_USER) {
+		/* record who mounted this so they can unmount */
+		struct passwd *pw = getpwuid(getuid());
+		if(pw)
+			new_opts = xstrconcat3(new_opts, ",user=", pw->pw_name);
+	}
+	if (flags & MS_USERS)
+		new_opts = xstrconcat3(new_opts, ",users", "");
+
 	for (om = opt_map; om->opt != NULL; om++) {
 		if (om->skip)
 			continue;
@@ -135,72 +181,111 @@ static char * fix_opts_string (int flags, const char *extra_opts) {
 	return new_opts;
 }
 
-
-int add_mtab(char *fsname, char *mount_point, char *fstype, int flags, char *opts, int freq, int passno)
+static void
+init_mntent(struct mntent *mnt, char *fsname, char *dir, char *type,
+		int flags, char *opts)
 {
-	struct mntent ment;
-	int fd;
-	FILE *mtab;
-
-	ment.mnt_fsname = fsname;
-	ment.mnt_dir = mount_point;
-	ment.mnt_type = fstype;
-	ment.mnt_opts = fix_opts_string(flags, opts);
-	ment.mnt_freq = 0;
-	ment.mnt_passno= 0;
-
-	if ((fd = open(MOUNTED"~", O_RDWR|O_CREAT|O_EXCL, 0600)) == -1)	{
-		fprintf(stderr, "Can't get "MOUNTED"~ lock file");
-		return 1;
-	}
-        close(fd);
+	mnt->mnt_fsname	= fsname;
+	mnt->mnt_dir	= dir;
+	mnt->mnt_type	= type;
+	mnt->mnt_opts	= fix_opts_string(flags & ~MS_NOMTAB, opts);
+
+	/* these are always zero for NFS */
+	mnt->mnt_freq	= 0;
+	mnt->mnt_passno	= 0;
+}
 
-        if ((mtab = setmntent(MOUNTED, "a+")) == NULL) {
-		fprintf(stderr, "Can't open " MOUNTED);
-		return 1;
+/* Create mtab with a root entry.  */
+static void
+create_mtab (void) {
+	struct mntentchn *fstab;
+	struct mntent mnt;
+	int flags;
+	mntFILE *mfp;
+
+	lock_mtab();
+
+	mfp = nfs_setmntent (MOUNTED, "a+");
+	if (mfp == NULL || mfp->mntent_fp == NULL) {
+		int errsv = errno;
+		die (EX_FILEIO, _("mount: can't open %s for writing: %s"),
+		     MOUNTED, strerror (errsv));
 	}
 
-        if (addmntent(mtab, &ment) == 1) {
-		fprintf(stderr, "Can't write mount entry");
-		return 1;
+	/* Find the root entry by looking it up in fstab */
+	if ((fstab = getfsfile ("/")) || (fstab = getfsfile ("root"))) {
+		char *extra_opts;
+		parse_opts (fstab->m.mnt_opts, &flags, &extra_opts);
+		init_mntent(&mnt, xstrdup(fstab->m.mnt_fsname), "/",
+				fstab->m.mnt_type, flags, extra_opts);
+		free(extra_opts);
+
+		if (nfs_addmntent (mfp, &mnt) == 1) {
+			int errsv = errno;
+			die (EX_FILEIO, _("mount: error writing %s: %s"),
+			     _PATH_MOUNTED, strerror (errsv));
+		}
 	}
+	if (fchmod (fileno (mfp->mntent_fp), 0644) < 0)
+		if (errno != EROFS) {
+			int errsv = errno;
+			die (EX_FILEIO,
+			     _("mount: error changing mode of %s: %s"),
+			     _PATH_MOUNTED, strerror (errsv));
+		}
+	nfs_endmntent (mfp);
 
-        if (fchmod(fileno(mtab), 0644) == -1) {
-		fprintf(stderr, "Can't set perms on " MOUNTED);
-		return 1;
-	}
+	unlock_mtab();
+
+	reset_mtab_info();
+}
 
-	endmntent(mtab);
+static int add_mtab(char *spec, char *mount_point, char *fstype,
+			int flags, char *opts)
+{
+	struct mntent ment;
+	int result = EX_SUCCESS;
 
-	if (unlink(MOUNTED"~") == -1) {
-		fprintf(stderr, "Can't remove "MOUNTED"~");
-		return 1;
+	init_mntent(&ment, spec, mount_point, fstype, flags, opts);
+
+	if (!nomtab && mtab_does_not_exist()) {
+		if (verbose > 1)
+			printf(_("mount: no %s found - creating it..\n"),
+			       MOUNTED);
+		create_mtab ();
 	}
 
-	return 0;
-}
+	if (!nomtab && mtab_is_writable()) {
+		if (flags & MS_REMOUNT)
+			update_mtab(ment.mnt_dir, &ment);
+		else {
+			mntFILE *mtab;
+			
+			lock_mtab();
+			mtab = nfs_setmntent(MOUNTED, "a+");
+			if (mtab == NULL || mtab->mntent_fp == NULL) {
+				nfs_error(_("Can't open mtab: %s"),
+						strerror(errno));
+				result = EX_FILEIO;
+			} else {
+				if (nfs_addmntent(mtab, &ment) == 1) {
+					nfs_error(_("Can't write mount entry to mtab: %s"),
+							strerror(errno));
+					result = EX_FILEIO;
+				}
+			}
+			nfs_endmntent(mtab);
+			unlock_mtab();
+		}
+	}
 
-int do_mount_syscall(char *spec, char *node, char *type, int flags, void *data)
-{
-	return mount(spec, node, type, flags, data);
-}
+	free(ment.mnt_opts);
 
-void mount_usage()
-{
-	printf("usage: %s remotetarget dir [-rvVwfnh] [-t version] [-o nfsoptions]\n", progname);
-	printf("options:\n\t-r\t\tMount file system readonly\n");
-	printf("\t-v\t\tVerbose\n");
-	printf("\t-V\t\tPrint version\n");
-	printf("\t-w\t\tMount file system read-write\n");
-	printf("\t-f\t\tFake mount, don't actually mount\n");
-	printf("\t-n\t\tDo not update /etc/mtab\n");
-	printf("\t-h\t\tPrint this help\n");
-	printf("\tversion\t\tnfs4 - NFS version 4, nfs - older NFS version supported\n");
-	printf("\tnfsoptions\tRefer mount.nfs(8) or nfs(5)\n\n");
+	return result;
 }
 
-static inline void
-parse_opt(const char *opt, int *mask, char *extra_opts, int len) {
+static void parse_opt(const char *opt, int *mask, char *extra_opts, size_t len)
+{
 	const struct opt_map *om;
 
 	for (om = opt_map; om->opt != NULL; om++) {
@@ -222,94 +307,103 @@ parse_opt(const char *opt, int *mask, char *extra_opts, int len) {
 		strcat(extra_opts, opt);
 }
 
-/* Take -o options list and compute 4th and 5th args to mount(2).  flags
-   gets the standard options (indicated by bits) and extra_opts all the rest */
-static void parse_opts (const char *options, int *flags, char **extra_opts)
+/*
+ * Convert the provided mount command-line options into the 4th &
+ * 5th arguments to mount(2).  Output parameter "@flags" gets the
+ * standard options (indicated by MS_ bits), and output parameter
+ * "@extra_opts" gets all the filesystem-specific options.
+ */
+static void parse_opts(const char *options, int *flags, char **extra_opts)
 {
 	if (options != NULL) {
 		char *opts = xstrdup(options);
-		char *opt;
-		int len = strlen(opts) + 20;
+		char *opt, *p;
+		size_t len = strlen(opts) + 1;	/* include room for a null */
+		int open_quote = 0;
 
 		*extra_opts = xmalloc(len);
 		**extra_opts = '\0';
 
-		for (opt = strtok(opts, ","); opt; opt = strtok(NULL, ","))
-			parse_opt(opt, flags, *extra_opts, len);
-
+		for (p = opts, opt = NULL; p && *p; p++) {
+			if (!opt)
+				opt = p;	/* begin of the option item */
+			if (*p == '"')
+				open_quote ^= 1; /* reverse the status */
+			if (open_quote)
+				continue;	/* still in a quoted block */
+			if (*p == ',')
+				*p = '\0';	/* terminate the option item */
+
+			/* end of option item or last item */
+			if (*p == '\0' || *(p + 1) == '\0') {
+				parse_opt(opt, flags, *extra_opts, len);
+				opt = NULL;
+			}
+		}
 		free(opts);
 	}
-
 }
 
-static void mount_error(char *node)
+static int try_mount(char *spec, char *mount_point, int flags,
+			char *fs_type, char **extra_opts, char *mount_opts,
+			int fake, int bg)
 {
-	switch(errno) {
-		case ENOTDIR:
-			printf("%s: mount point %s is not a directory\n", progname, node);
-			break;
-		case EBUSY:
-			printf("%s: %s is already mounted or busy\n", progname, node);
-			break;
-		case ENOENT:
-			printf("%s: mount point %s does not exist\n", progname, node);
-			break;
-		default:
-			printf("%s: %s\n", progname, strerror(errno));
+	int ret;
+
+	if (string)
+		ret = nfsmount_string(spec, mount_point, fs_type, flags,
+					extra_opts, fake, bg);
+	else {
+		if (strcmp(fs_type, "nfs4") == 0)
+			ret = nfs4mount(spec, mount_point, flags,
+					extra_opts, fake, bg);
+		else
+			ret = nfsmount(spec, mount_point, flags,
+					extra_opts, fake, bg);
 	}
+
+	if (ret)
+		return ret;
+
+	if (!fake)
+		print_one(spec, mount_point, fs_type, mount_opts);
+
+	return add_mtab(spec, mount_point, fs_type, flags, *extra_opts);
 }
 
 int main(int argc, char *argv[])
 {
-	int c, flags = 0, nfs_mount_vers = 0, mnt_err = 1, fake = 0;
-	char *spec, *mount_point, *extra_opts = NULL;
-	char *mount_opts = NULL, *p;
+	int c, flags = 0, mnt_err = 1, fake = 0;
+	char *spec = NULL, *mount_point = NULL, *fs_type = "nfs";
+	char *extra_opts = NULL, *mount_opts = NULL;
+	uid_t uid = getuid();
 
-	progname = argv[0];
-	if ((p = strrchr(progname, '/')) != NULL)
-		progname = p+1;
+	progname = basename(argv[0]);
 
-	if (getuid() != 0) {
-		printf("%s: only root can do that.\n", progname);
-		exit(1);
-	}
+	nfs_mount_data_version = discover_nfs_mount_data_version(&string);
 
-	if(!strncmp(progname, "umount", strlen("umount"))) {
-		if(argc < 2) {
-			umount_usage();
-			exit(1);
-		}
-		return(nfsumount(argc, argv));
-	}
+	if(!strncmp(progname, "umount", strlen("umount")))
+		exit(nfsumount(argc, argv));
 
-	if ((argc < 2)) {
+	if ((argc < 3)) {
 		mount_usage();
-		exit(1);
+		exit(EX_USAGE);
 	}
 
-	if(argv[1][0] == '-') {
-		if(argv[1][1] == 'V')
-			printf("%s ("PACKAGE_STRING")\n", progname);
-		else
-			mount_usage();
-		return 0;
-	}
+	mount_config_init(progname);
 
-	while ((c = getopt_long (argc - 2, argv + 2, "rt:vVwfno:h",
+	while ((c = getopt_long(argc, argv, "rvVwfno:hs",
 				longopts, NULL)) != -1) {
 		switch (c) {
 		case 'r':
 			flags |= MS_RDONLY;
 			break;
-		case 't':
-			nfs_mount_vers = (strncmp(optarg, "nfs4", 4)) ? 0 : 4;
-			break;
 		case 'v':
 			++verbose;
 			break;
 		case 'V':
 			printf("%s: ("PACKAGE_STRING")\n", progname);
-			return 0;
+			exit(EX_SUCCESS);
 		case 'w':
 			flags &= ~MS_RDONLY;
 			break;
@@ -325,63 +419,132 @@ int main(int argc, char *argv[])
 			else
 				mount_opts = xstrdup(optarg);
 			break;
-		case 128: /* bind */
-			mounttype = MS_BIND;
-			break;
-		case 129: /* replace */
-			mounttype = MS_REPLACE;
-			break;
-		case 130: /* after */
-			mounttype = MS_AFTER;
-			break;
-		case 131: /* before */
-			mounttype = MS_BEFORE;
-			break;
-		case 132: /* over */
-			mounttype = MS_OVER;
-			break;
-		case 133: /* move */
-			mounttype = MS_MOVE;
-			break;
-		case 135: /* rbind */
-			mounttype = MS_BIND | MS_REC;
+		case 's':
+			++sloppy;
 			break;
 		case 'h':
 		default:
 			mount_usage();
-			exit(1);
+			goto out_usage;
 		}
 	}
 
-	spec = argv[1];
-	mount_point = canonicalize(argv[2]);
-	
-	parse_opts(mount_opts, &flags, &extra_opts);
+	/*
+	 * Extra non-option words at the end are bogus...
+	 */
+	if (optind != argc - 2) {
+		mount_usage();
+		goto out_usage;
+	} else {
+		while (optind < argc) {
+			if (!spec)
+				spec = argv[optind];
+			else
+				mount_point = argv[optind];
+			optind++;
+		}
+	}
+
+	if (strcmp(progname, "mount.nfs4") == 0)
+		fs_type = "nfs4";
+
+	/*
+	 * If a non-root user is attempting to mount, make sure the
+	 * user's requested options match the options specified in
+	 * /etc/fstab; otherwise, don't allow the mount.
+	 */
+	if (uid != 0) {
+		struct mntentchn *mc;
+
+		if ((mc = getfsfile(mount_point)) == NULL ||
+		    strcmp(mc->m.mnt_fsname, spec) != 0 ||
+		    strcmp(mc->m.mnt_type, fs_type) != 0) {
+			nfs_error(_("%s: permission denied: no match for %s "
+				"found in /etc/fstab"), progname, mount_point);
+			goto out_usage;
+		}
 
-	if (!strcmp(progname, "mount.nfs4") || nfs_mount_vers == 4) {
-		nfs_mount_vers = 4;
-		mnt_err = nfs4mount(spec, mount_point, &flags, &extra_opts, &mount_opts, 0);
+		/*
+		 * 'mount' munges the options from fstab before passing them
+		 * to us, so it is non-trivial to test that we have the correct
+		 * set of options and we don't want to trust what the user
+		 * gave us, so just take whatever is in /etc/fstab.
+		 */
+		mount_opts = strdup(mc->m.mnt_opts);
 	}
-	else {
-		if (!strcmp(progname, "mount.nfs")) {
-			mnt_err = nfsmount(spec, mount_point, &flags,
-					&extra_opts, &mount_opts, &nfs_mount_vers, 0);
+
+	mount_point = canonicalize(mount_point);
+	if (!mount_point) {
+		nfs_error(_("%s: no mount point provided"), progname);
+		goto out_usage;
+	}
+	if (mount_point[0] != '/') {
+		nfs_error(_("%s: unrecognized mount point %s"),
+			progname, mount_point);
+		mnt_err = EX_USAGE;
+		goto out;
+	}
+	/*
+	 * Concatenate mount options from the configuration file
+	 */
+	mount_opts = mount_config_opts(spec, mount_point, mount_opts);
+
+	parse_opts(mount_opts, &flags, &extra_opts);
+
+	if (uid != 0) {
+		if (!(flags & (MS_USERS|MS_USER))) {
+			nfs_error(_("%s: permission denied"), progname);
+			mnt_err = EX_USAGE;
+			goto out;
+		}
+
+		if (geteuid() != 0) {
+			nfs_error(_("%s: not installed setuid - "
+				    "\"user\" NFS mounts not supported."), progname);
+			exit(EX_FAIL);
 		}
 	}
 
-	if (!mnt_err && !fake) {
-		mnt_err = do_mount_syscall(spec, mount_point, nfs_mount_vers == 4 ? "nfs4" : "nfs", flags, mount_opts);
-		
-		if(mnt_err) {
-			mount_error(mount_point);
-			exit(-1);
+	if (chk_mountpoint(mount_point)) {
+		mnt_err = EX_USAGE;
+		goto out;
+	}
+
+	mnt_err = try_mount(spec, mount_point, flags, fs_type, &extra_opts,
+				mount_opts, fake, FOREGROUND);
+	if (mnt_err == EX_BG) {
+		printf(_("%s: backgrounding \"%s\"\n"),
+			progname, spec);
+		printf(_("%s: mount options: \"%s\"\n"),
+			progname, extra_opts);
+
+		fflush(stdout);
+
+		/*
+		 * Parent exits immediately with success.
+		 */
+		if (daemon(0, 0)) {
+			nfs_error(_("%s: failed to start "
+					"background process: %s\n"),
+						progname, strerror(errno));
+			exit(EX_FAIL);
 		}
 
-		if(!nomtab)
-			add_mtab(spec, mount_point, nfs_mount_vers == 4 ? "nfs4" : "nfs",
-				 flags, extra_opts, 0, 0);
+		mnt_err = try_mount(spec, mount_point, flags, fs_type,
+					&extra_opts, mount_opts, fake,
+					BACKGROUND);
+		if (verbose && mnt_err)
+			printf(_("%s: giving up \"%s\"\n"),
+				progname, spec);
 	}
 
-	return 0;
-}
+out:
+	free(mount_opts);
+	free(extra_opts);
+	free(mount_point);
+	exit(mnt_err);
 
+out_usage:
+	free(mount_opts);
+	exit(EX_USAGE);
+}