mount.c - busybox - Git at Google

 /*
    3/21/1999	Charles P. Wright <cpwright@cpwright.com>
 		searches through fstab when -a is passed
 		will try mounting stuff with all fses when passed -t auto

 	1999-04-17	Dave Cinege...Rewrote -t auto. Fixed ro mtab.
 */

 #include "internal.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>

 const char	mount_usage[] = "mount\n"
 "\t\tmount [flags] special-device directory\n"
 "\n"
 "Flags:\n"
 "\t-a:\tMount all file systems in fstab.\n"
 "\t-f:\t\"Fake\" mount. Add entry to mount table but don't mount it.\n"
 "\t-n:\tDon't write a mount table entry.\n"
 "\t-o option:\tOne of many filesystem options, listed below.\n"
 "\t-r:\tMount the filesystem read-only.\n"
 "\t-t filesystem-type:\tSpecify the filesystem type.\n"
 "\t-w:\tMount for reading and writing (default).\n"
 "\n"
 "Options for use with the \"-o\" flag:\n"
 "\tasync / sync:\tWrites are asynchronous / synchronous.\n"
 "\tdev / nodev:\tAllow use of special device files / disallow them.\n"
 "\texec / noexec:\tAllow use of executable files / disallow them.\n"
 "\tsuid / nosuid:\tAllow set-user-id-root programs / disallow them.\n"
 "\tremount: Re-mount a currently-mounted filesystem, changing its flags.\n"
 "\tro / rw: Mount for read-only / read-write.\n"
 "\t"
 "There are EVEN MORE flags that are specific to each filesystem.\n"
 "You'll have to see the written documentation for those.\n";

 struct mount_options {
 	const char *	name;
 	unsigned long	and;
 	unsigned long	or;
 };

 static const struct mount_options	mount_options[] = {
 	{	"async",	~MS_SYNCHRONOUS,0		},
 	{	"defaults",	~0,		0		},
 	{	"dev",		~MS_NODEV,	0		},
 	{	"exec",		~MS_NOEXEC,	0		},
 	{	"nodev",	~0,		MS_NODEV	},
 	{	"noexec",	~0,		MS_NOEXEC	},
 	{	"nosuid",	~0,		MS_NOSUID	},
 	{	"remount",	~0,		MS_REMOUNT	},
 	{	"ro",		~0,		MS_RDONLY	},
 	{	"rw",		~MS_RDONLY,	0		},
 	{	"suid",		~MS_NOSUID,	0		},
 	{	"sync",		~0,		MS_SYNCHRONOUS	},
 	{	0,		0,		0		}
 };

 static void
 show_flags(unsigned long flags, char * buffer)
 {
 	const struct mount_options *	f = mount_options;
 	while ( f->name ) {
 		if ( flags & f->and ) {
 			int	length = strlen(f->name);
 			memcpy(buffer, f->name, length);
 			buffer += length;
 			*buffer++ = ',';
 			*buffer = '\0';
 		}
 		f++;
 	}
 }

 static void
 one_option(
  char *			option
 ,unsigned long *	flags
 ,char *			data)
 {
 	const struct mount_options *	f = mount_options;

 	while ( f->name != 0 ) {
 		if ( strcasecmp(f->name, option) == 0 ) {
 			*flags &= f->and;
 			*flags |= f->or;
 			return;
 		}
 		f++;
 	}
 	if ( *data ) {
 		data += strlen(data);
 		*data++ = ',';
 	}
 	strcpy(data, option);
 }

 static void
 parse_mount_options(
  char *			options
 ,unsigned long *	flags
 ,char *			data)
 {
 	while ( *options ) {
 		char * comma = strchr(options, ',');
 		if ( comma )
 			*comma = '\0';
 		one_option(options, flags, data);
 		if ( comma ) {
 			*comma = ',';
 			options = ++comma;
 		}
 		else
 			break;
 	}
 }

 int
 mount_one(
  char *		blockDevice
 ,char *		directory
 ,char *		filesystemType
 ,unsigned long	flags
 ,char *		string_flags
 ,int		noMtab
 ,int		fake)
 {
 	int	error = 0;
 	int 	status = 0;

 	char	buf[255];

 	if (!fake) {
 		if (*filesystemType == 'a') { 			//Will fail on real FS starting with 'a'

 			FILE	*f = fopen("/proc/filesystems", "r");

 			if (f == NULL)	return 1;

 			while (fgets(buf, sizeof(buf), f) != NULL) {
 				filesystemType = buf;
 				if (*filesystemType == '\t') {  // Not a nodev filesystem

 					while (*filesystemType && *filesystemType != '\n')	filesystemType++;
 					*filesystemType = '\0';

 					filesystemType = buf;
 					filesystemType++;	//hop past tab

 					status = mount(blockDevice, directory, filesystemType,
 							flags|MS_MGC_VAL ,string_flags);
 					error = errno;

 					if (status == 0) break;
 				}
 			}
 			fclose(f);
 		} else {

 			status = mount( blockDevice, directory, filesystemType,
 					flags|MS_MGC_VAL ,string_flags);
 			error = errno;
 		}
 	}

 	if ( status == 0 ) {
 		char *	s = &string_flags[strlen(string_flags)];
 		FILE *	mountTable;
 		if ( s != string_flags ) {
 			*s++ = ',';
 			show_flags(flags, s);
 		}
 		if ( !noMtab && (mountTable = setmntent("/etc/mtab", "a+")) ) {
 			int	length = strlen(directory);
 			struct mntent	m;

 			if ( length > 1 && directory[length - 1] == '/' )
 				directory[length - 1] = '\0';

 			if ( filesystemType == 0 ) {
 				struct mntent *	p
 				 = findMountPoint(blockDevice, "/proc/mounts");

 				if ( p && p->mnt_type )
 					filesystemType = p->mnt_type;
 			}
 			m.mnt_fsname = blockDevice;
 			m.mnt_dir = directory;
 			m.mnt_type = filesystemType ? filesystemType : "default";

 			if (*string_flags) {
 				m.mnt_opts = string_flags;
 			} else {
 				if ( (flags | MS_RDONLY) == flags )
 					m.mnt_opts = "ro";
 				else
 					m.mnt_opts = "rw";
 			}

 			m.mnt_freq = 0;
 			m.mnt_passno = 0;
 			addmntent(mountTable, &m);
 			endmntent(mountTable);
 		}
 		return 0;
 	} else {
 		fprintf(stderr, "Mount %s", blockDevice);
 		if ( filesystemType && *filesystemType )
 			fprintf(stderr, " (type %s)", filesystemType);

 		fprintf(
 		 stderr
 		," on %s: "
 		,directory);

 		switch ( error ) {
 		case EPERM:
 			if (geteuid() == 0)
 				fprintf(
 				 stderr
 				,"mount point %s is not a directory"
 				,blockDevice);
 			else
 				fprintf(
 				 stderr
 				,"must be superuser to use mount");
 			break;
 		case EBUSY:
 			fprintf(
 			 stderr
 			,"%s already mounted or %s busy"
 			,blockDevice
 			,directory);
 			break;
 		case ENOENT:
 		{
 			struct stat statbuf;
 			if ( stat(directory, &statbuf) != 0 )
 				fprintf(
 				 stderr
 				,"directory %s does not exist"
 				,directory);
 			else if ( stat(blockDevice, &statbuf) != 0 )
 				fprintf(
 				 stderr
 				,"block device %s does not exist"
 				,blockDevice);
 			else
 				fprintf(
 				 stderr
 				,"%s is not mounted on %s, but the mount table says it is."
 				,blockDevice
 				,directory);
 			break;
 		}
 		case ENOTDIR:
 			fprintf(
 			 stderr
 			,"%s is not a directory"
 			,directory);
 			break;
 		case EINVAL:
 			fprintf(
 			 stderr
 			,"wrong filesystem type, or bad superblock on %s"
 			,blockDevice);
 			break;
 		case EMFILE:
 			fprintf(stderr, "mount table full");
 			break;
 		case EIO:
 			fprintf(
 			 stderr
 			,"I/O error reading %s"
 			,blockDevice);
 			break;
 		case ENODEV:
 		{
 			FILE *	f = fopen("/proc/filesystems", "r");

 			fprintf(
 			 stderr
 			,"filesystem type %s not in kernel.\n"
 			,filesystemType);
 			fprintf(stderr, "Do you need to load a module?\n");
 			if ( f ) {
 				char	buf[100];

 				fprintf(
 				 stderr
 				,"Here are the filesystem types the kernel"
 				 " can mount:\n");
 				while ( fgets(buf, sizeof(buf), f) != 0 )
 					fprintf(stderr, "\t%s", buf);
 				fclose(f);
 			}
 			break;
 		}
 		case ENOTBLK:
 			fprintf(
 			 stderr
 			,"%s is not a block device"
 			,blockDevice);
 			break;
 		case ENXIO:
 			fprintf(
 			 stderr
 			,"%s is not a valid block device"
 			,blockDevice);
 			break;
 		default:
 			fputs(strerror(errno), stderr);
 		}
 		putc('\n', stderr);
 		return -1;
 	}
 }

 extern int
 mount_main(struct FileInfo * i, int argc, char * * argv)
 {
 	char	string_flags[1024];
 	unsigned long	flags = 0;
 	char *	filesystemType = "auto";
 	int		fake = 0;
 	int		noMtab = 0;
 	int 		all = 0;

 	*string_flags = '\0';

 	if ( argc == 1 ) {
 		FILE *	mountTable;
 		if ( (mountTable = setmntent("/etc/mtab", "r")) ) {
 			struct mntent * m;
 			while ( (m = getmntent(mountTable)) != 0 ) {
 				printf(
 				 "%s on %s type %s (%s)\n"
 				,m->mnt_fsname
 				,m->mnt_dir
 				,m->mnt_type
 				,m->mnt_opts);
 			}
 			endmntent(mountTable);
 		}
 		return 0;
 	}

 	while ( argc >= 2 && argv[1][0] == '-' ) {
 		switch ( argv[1][1] ) {
 		case 'f':
 			fake = 1;
 			break;
 		case 'n':
 			noMtab = 1;
 			break;
 		case 'o':
 			if ( argc < 3 ) {
 				usage(mount_usage);
 				return 1;
 			}
 			parse_mount_options(argv[2], &flags, string_flags);
 			argc--;
 			argv++;
 			break;
 		case 'r':
 			flags |= MS_RDONLY;
 			break;
 		case 't':
 			if ( argc < 3 ) {
 				usage(mount_usage);
 				return 1;
 			}
 			filesystemType = argv[2];
 			argc--;
 			argv++;
 			break;
 		case 'v':
 			break;
 		case 'w':
 			flags &= ~MS_RDONLY;
 			break;
 		case 'a':
 			all = 1;
 			break;
 		default:
 			usage(mount_usage);
 			return 1;
 		}
 		argc--;
 		argv++;
 	}

 	if (all == 1) {
 		struct 	mntent *m;
 		FILE	*f = setmntent("/etc/fstab", "r");

 		if (f == NULL)	{
 			return 1;
 		}

 		// FIXME: Combine read routine (make new function) with unmount_all to save space.

 		while ((m = getmntent(f)) != NULL) {
 			// If the file system isn't noauto, and isn't mounted on /, mount it
 			if ((!strstr(m->mnt_opts, "noauto")) && (m->mnt_dir[1] != '\0')
 				&& !((m->mnt_type[0] == 's') && (m->mnt_type[1] == 'w'))
 				&& !((m->mnt_type[0] == 'n') && (m->mnt_type[1] == 'f'))) {
 				mount_one(m->mnt_fsname, m->mnt_dir, m->mnt_type, flags, m->mnt_opts, noMtab, fake);
 			}
 		}

 		endmntent(f);
 	} else {
 		if ( argc >= 3 ) {
 			if ( mount_one( argv[1], argv[2], filesystemType, flags, string_flags, noMtab, fake) == 0 )
 				return 0;
 			else
 				return 1;
 		} else {
 			usage(mount_usage);
 			return 1;
 		}
 	}
 	return 0;
 }
	/*
	3/21/1999 Charles P. Wright <cpwright@cpwright.com>
	searches through fstab when -a is passed
	will try mounting stuff with all fses when passed -t auto

	1999-04-17 Dave Cinege...Rewrote -t auto. Fixed ro mtab.
	*/

	#include "internal.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>

	const char mount_usage[] = "mount\n"
	"\t\tmount [flags] special-device directory\n"
	"\n"
	"Flags:\n"
	"\t-a:\tMount all file systems in fstab.\n"
	"\t-f:\t\"Fake\" mount. Add entry to mount table but don't mount it.\n"
	"\t-n:\tDon't write a mount table entry.\n"
	"\t-o option:\tOne of many filesystem options, listed below.\n"
	"\t-r:\tMount the filesystem read-only.\n"
	"\t-t filesystem-type:\tSpecify the filesystem type.\n"
	"\t-w:\tMount for reading and writing (default).\n"
	"\n"
	"Options for use with the \"-o\" flag:\n"
	"\tasync / sync:\tWrites are asynchronous / synchronous.\n"
	"\tdev / nodev:\tAllow use of special device files / disallow them.\n"
	"\texec / noexec:\tAllow use of executable files / disallow them.\n"
	"\tsuid / nosuid:\tAllow set-user-id-root programs / disallow them.\n"
	"\tremount: Re-mount a currently-mounted filesystem, changing its flags.\n"
	"\tro / rw: Mount for read-only / read-write.\n"
	"\t"
	"There are EVEN MORE flags that are specific to each filesystem.\n"
	"You'll have to see the written documentation for those.\n";

	struct mount_options {
	const char * name;
	unsigned long and;
	unsigned long or;
	};

	static const struct mount_options mount_options[] = {
	{ "async", ~MS_SYNCHRONOUS,0 },
	{ "defaults", ~0, 0 },
	{ "dev", ~MS_NODEV, 0 },
	{ "exec", ~MS_NOEXEC, 0 },
	{ "nodev", ~0, MS_NODEV },
	{ "noexec", ~0, MS_NOEXEC },
	{ "nosuid", ~0, MS_NOSUID },
	{ "remount", ~0, MS_REMOUNT },
	{ "ro", ~0, MS_RDONLY },
	{ "rw", ~MS_RDONLY, 0 },
	{ "suid", ~MS_NOSUID, 0 },
	{ "sync", ~0, MS_SYNCHRONOUS },
	{ 0, 0, 0 }
	};

	static void
	show_flags(unsigned long flags, char * buffer)
	{
	const struct mount_options * f = mount_options;
	while ( f->name ) {
	if ( flags & f->and ) {
	int length = strlen(f->name);
	memcpy(buffer, f->name, length);
	buffer += length;
	*buffer++ = ',';
	*buffer = '\0';
	}
	f++;
	}
	}

	static void
	one_option(
	char * option
	,unsigned long * flags
	,char * data)
	{
	const struct mount_options * f = mount_options;

	while ( f->name != 0 ) {
	if ( strcasecmp(f->name, option) == 0 ) {
	*flags &= f->and;
	*flags \|= f->or;
	return;
	}
	f++;
	}
	if ( *data ) {
	data += strlen(data);
	*data++ = ',';
	}
	strcpy(data, option);
	}

	static void
	parse_mount_options(
	char * options
	,unsigned long * flags
	,char * data)
	{
	while ( *options ) {
	char * comma = strchr(options, ',');
	if ( comma )
	*comma = '\0';
	one_option(options, flags, data);
	if ( comma ) {
	*comma = ',';
	options = ++comma;
	}
	else
	break;
	}
	}

	int
	mount_one(
	char * blockDevice
	,char * directory
	,char * filesystemType
	,unsigned long flags
	,char * string_flags
	,int noMtab
	,int fake)
	{
	int error = 0;
	int status = 0;

	char buf[255];

	if (!fake) {
	if (*filesystemType == 'a') { //Will fail on real FS starting with 'a'

	FILE *f = fopen("/proc/filesystems", "r");

	if (f == NULL) return 1;

	while (fgets(buf, sizeof(buf), f) != NULL) {
	filesystemType = buf;
	if (*filesystemType == '\t') { // Not a nodev filesystem

	while (filesystemType && filesystemType != '\n') filesystemType++;
	*filesystemType = '\0';

	filesystemType = buf;
	filesystemType++; //hop past tab

	status = mount(blockDevice, directory, filesystemType,
	flags\|MS_MGC_VAL ,string_flags);
	error = errno;

	if (status == 0) break;
	}
	}
	fclose(f);
	} else {

	status = mount( blockDevice, directory, filesystemType,
	flags\|MS_MGC_VAL ,string_flags);
	error = errno;
	}
	}

	if ( status == 0 ) {
	char * s = &string_flags[strlen(string_flags)];
	FILE * mountTable;
	if ( s != string_flags ) {
	*s++ = ',';
	show_flags(flags, s);
	}
	if ( !noMtab && (mountTable = setmntent("/etc/mtab", "a+")) ) {
	int length = strlen(directory);
	struct mntent m;

	if ( length > 1 && directory[length - 1] == '/' )
	directory[length - 1] = '\0';

	if ( filesystemType == 0 ) {
	struct mntent * p
	= findMountPoint(blockDevice, "/proc/mounts");

	if ( p && p->mnt_type )
	filesystemType = p->mnt_type;
	}
	m.mnt_fsname = blockDevice;
	m.mnt_dir = directory;
	m.mnt_type = filesystemType ? filesystemType : "default";

	if (*string_flags) {
	m.mnt_opts = string_flags;
	} else {
	if ( (flags \| MS_RDONLY) == flags )
	m.mnt_opts = "ro";
	else
	m.mnt_opts = "rw";
	}

	m.mnt_freq = 0;
	m.mnt_passno = 0;
	addmntent(mountTable, &m);
	endmntent(mountTable);
	}
	return 0;
	} else {
	fprintf(stderr, "Mount %s", blockDevice);
	if ( filesystemType && *filesystemType )
	fprintf(stderr, " (type %s)", filesystemType);

	fprintf(
	stderr
	," on %s: "
	,directory);

	switch ( error ) {
	case EPERM:
	if (geteuid() == 0)
	fprintf(
	stderr
	,"mount point %s is not a directory"
	,blockDevice);
	else
	fprintf(
	stderr
	,"must be superuser to use mount");
	break;
	case EBUSY:
	fprintf(
	stderr
	,"%s already mounted or %s busy"
	,blockDevice
	,directory);
	break;
	case ENOENT:
	{
	struct stat statbuf;
	if ( stat(directory, &statbuf) != 0 )
	fprintf(
	stderr
	,"directory %s does not exist"
	,directory);
	else if ( stat(blockDevice, &statbuf) != 0 )
	fprintf(
	stderr
	,"block device %s does not exist"
	,blockDevice);
	else
	fprintf(
	stderr
	,"%s is not mounted on %s, but the mount table says it is."
	,blockDevice
	,directory);
	break;
	}
	case ENOTDIR:
	fprintf(
	stderr
	,"%s is not a directory"
	,directory);
	break;
	case EINVAL:
	fprintf(
	stderr
	,"wrong filesystem type, or bad superblock on %s"
	,blockDevice);
	break;
	case EMFILE:
	fprintf(stderr, "mount table full");
	break;
	case EIO:
	fprintf(
	stderr
	,"I/O error reading %s"
	,blockDevice);
	break;
	case ENODEV:
	{
	FILE * f = fopen("/proc/filesystems", "r");

	fprintf(
	stderr
	,"filesystem type %s not in kernel.\n"
	,filesystemType);
	fprintf(stderr, "Do you need to load a module?\n");
	if ( f ) {
	char buf[100];

	fprintf(
	stderr
	,"Here are the filesystem types the kernel"
	" can mount:\n");
	while ( fgets(buf, sizeof(buf), f) != 0 )
	fprintf(stderr, "\t%s", buf);
	fclose(f);
	}
	break;
	}
	case ENOTBLK:
	fprintf(
	stderr
	,"%s is not a block device"
	,blockDevice);
	break;
	case ENXIO:
	fprintf(
	stderr
	,"%s is not a valid block device"
	,blockDevice);
	break;
	default:
	fputs(strerror(errno), stderr);
	}
	putc('\n', stderr);
	return -1;
	}
	}

	extern int
	mount_main(struct FileInfo * i, int argc, char * * argv)
	{
	char string_flags[1024];
	unsigned long flags = 0;
	char * filesystemType = "auto";
	int fake = 0;
	int noMtab = 0;
	int all = 0;

	*string_flags = '\0';

	if ( argc == 1 ) {
	FILE * mountTable;
	if ( (mountTable = setmntent("/etc/mtab", "r")) ) {
	struct mntent * m;
	while ( (m = getmntent(mountTable)) != 0 ) {
	printf(
	"%s on %s type %s (%s)\n"
	,m->mnt_fsname
	,m->mnt_dir
	,m->mnt_type
	,m->mnt_opts);
	}
	endmntent(mountTable);
	}
	return 0;
	}

	while ( argc >= 2 && argv[1][0] == '-' ) {
	switch ( argv[1][1] ) {
	case 'f':
	fake = 1;
	break;
	case 'n':
	noMtab = 1;
	break;
	case 'o':
	if ( argc < 3 ) {
	usage(mount_usage);
	return 1;
	}
	parse_mount_options(argv[2], &flags, string_flags);
	argc--;
	argv++;
	break;
	case 'r':
	flags \|= MS_RDONLY;
	break;
	case 't':
	if ( argc < 3 ) {
	usage(mount_usage);
	return 1;
	}
	filesystemType = argv[2];
	argc--;
	argv++;
	break;
	case 'v':
	break;
	case 'w':
	flags &= ~MS_RDONLY;
	break;
	case 'a':
	all = 1;
	break;
	default:
	usage(mount_usage);
	return 1;
	}
	argc--;
	argv++;
	}

	if (all == 1) {
	struct mntent *m;
	FILE *f = setmntent("/etc/fstab", "r");

	if (f == NULL) {
	return 1;
	}

	// FIXME: Combine read routine (make new function) with unmount_all to save space.

	while ((m = getmntent(f)) != NULL) {
	// If the file system isn't noauto, and isn't mounted on /, mount it
	if ((!strstr(m->mnt_opts, "noauto")) && (m->mnt_dir[1] != '\0')
	&& !((m->mnt_type[0] == 's') && (m->mnt_type[1] == 'w'))
	&& !((m->mnt_type[0] == 'n') && (m->mnt_type[1] == 'f'))) {
	mount_one(m->mnt_fsname, m->mnt_dir, m->mnt_type, flags, m->mnt_opts, noMtab, fake);
	}
	}

	endmntent(f);
	} else {
	if ( argc >= 3 ) {
	if ( mount_one( argv[1], argv[2], filesystemType, flags, string_flags, noMtab, fake) == 0 )
	return 0;
	else
	return 1;
	} else {
	usage(mount_usage);
	return 1;
	}
	}
	return 0;
	}