blob: 89eb099c52edbd146626452e235e9a35a55b3825 [file] [log] [blame]
Erik Andersene49d5ec2000-02-08 19:58:47 +00001/* vi: set sw=4 ts=4: */
Eric Andersencc8ed391999-10-05 16:24:54 +00002/*
Eric Andersen596e5461999-10-07 08:30:23 +00003 * Mini mount implementation for busybox
4 *
Eric Andersenc4996011999-10-20 22:08:37 +00005 * Copyright (C) 1995, 1996 by Bruce Perens <bruce@pixar.com>.
Eric Andersen596e5461999-10-07 08:30:23 +00006 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 *
21 * 3/21/1999 Charles P. Wright <cpwright@cpwright.com>
22 * searches through fstab when -a is passed
23 * will try mounting stuff with all fses when passed -t auto
24 *
25 * 1999-04-17 Dave Cinege...Rewrote -t auto. Fixed ro mtab.
Eric Andersenc4996011999-10-20 22:08:37 +000026 *
27 * 1999-10-07 Erik Andersen <andersen@lineo.com>, <andersee@debian.org>.
Erik Andersen31638212000-01-15 22:28:50 +000028 * Rewrite of a lot of code. Removed mtab usage (I plan on
Eric Andersenc4996011999-10-20 22:08:37 +000029 * putting it back as a compile-time option some time),
30 * major adjustments to option parsing, and some serious
31 * dieting all around.
Erik Andersenb7cc49d2000-01-13 06:38:14 +000032 *
Erik Andersen31638212000-01-15 22:28:50 +000033 * 1999-11-06 mtab suppport is back - andersee
34 *
Erik Andersenb7cc49d2000-01-13 06:38:14 +000035 * 2000-01-12 Ben Collins <bcollins@debian.org>, Borrowed utils-linux's
36 * mount to add loop support.
Eric Andersenfdd51032000-08-02 18:48:26 +000037 *
38 * 2000-04-30 Dave Cinege <dcinege@psychosis.com>
39 * Rewrote fstab while loop and lower mount section. Can now do
40 * single mounts from fstab. Can override fstab options for single
41 * mount. Common mount_one call for single mounts and 'all'. Fixed
42 * mtab updating and stale entries. Removed 'remount' default.
43 *
Erik Andersenb7cc49d2000-01-13 06:38:14 +000044 */
Eric Andersencc8ed391999-10-05 16:24:54 +000045
Matt Kraai34251112001-05-02 21:17:38 +000046#include <limits.h>
Eric Andersencc8ed391999-10-05 16:24:54 +000047#include <stdlib.h>
48#include <unistd.h>
49#include <errno.h>
50#include <string.h>
51#include <stdio.h>
52#include <mntent.h>
Eric Andersencc8ed391999-10-05 16:24:54 +000053#include <ctype.h>
Eric Andersencbe31da2001-02-20 06:14:08 +000054#include "busybox.h"
Mark Whitley4b541a82001-04-25 17:10:30 +000055#if defined BB_FEATURE_USE_DEVPS_PATCH
56# include <linux/devmtab.h> /* For Erik's nifty devmtab device driver */
57#endif
Eric Andersenbd22ed82000-07-08 18:55:24 +000058
Mark Whitley59ab0252001-01-23 22:30:04 +000059enum {
60 MS_MGC_VAL = 0xc0ed0000, /* Magic number indicatng "new" flags */
61 MS_RDONLY = 1, /* Mount read-only */
62 MS_NOSUID = 2, /* Ignore suid and sgid bits */
63 MS_NODEV = 4, /* Disallow access to device special files */
64 MS_NOEXEC = 8, /* Disallow program execution */
65 MS_SYNCHRONOUS = 16, /* Writes are synced at once */
66 MS_REMOUNT = 32, /* Alter flags of a mounted FS */
67 MS_MANDLOCK = 64, /* Allow mandatory locks on an FS */
68 S_QUOTA = 128, /* Quota initialized for file/directory/symlink */
69 S_APPEND = 256, /* Append-only file */
70 S_IMMUTABLE = 512, /* Immutable file */
71 MS_NOATIME = 1024, /* Do not update access times. */
72 MS_NODIRATIME = 2048, /* Do not update directory access times */
73};
Eric Andersencc8ed391999-10-05 16:24:54 +000074
Eric Andersenbd22ed82000-07-08 18:55:24 +000075
Erik Andersenb7cc49d2000-01-13 06:38:14 +000076#if defined BB_FEATURE_MOUNT_LOOP
77#include <fcntl.h>
78#include <sys/ioctl.h>
Erik Andersene132f4b2000-02-09 04:16:43 +000079static int use_loop = FALSE;
Erik Andersenb7cc49d2000-01-13 06:38:14 +000080#endif
81
Eric Andersena57ba4d2000-07-08 19:20:49 +000082extern int mount (__const char *__special_file, __const char *__dir,
83 __const char *__fstype, unsigned long int __rwflag,
84 __const void *__data);
85extern int umount (__const char *__special_file);
86extern int umount2 (__const char *__special_file, int __flags);
Eric Andersende440672001-03-01 07:55:49 +000087
Eric Andersene76c3b02001-04-05 03:14:39 +000088extern int sysfs( int option, unsigned int fs_index, char * buf);
Eric Andersena57ba4d2000-07-08 19:20:49 +000089
Erik Andersene49d5ec2000-02-08 19:58:47 +000090extern const char mtab_file[]; /* Defined in utility.c */
Eric Andersend0246fb1999-11-04 21:18:07 +000091
Eric Andersencc8ed391999-10-05 16:24:54 +000092struct mount_options {
Erik Andersene49d5ec2000-02-08 19:58:47 +000093 const char *name;
94 unsigned long and;
95 unsigned long or;
Eric Andersencc8ed391999-10-05 16:24:54 +000096};
97
Eric Andersen596e5461999-10-07 08:30:23 +000098static const struct mount_options mount_options[] = {
Erik Andersene49d5ec2000-02-08 19:58:47 +000099 {"async", ~MS_SYNCHRONOUS, 0},
Erik Andersen6c5f2c62000-05-05 19:49:33 +0000100 {"atime", ~0, ~MS_NOATIME},
Erik Andersene49d5ec2000-02-08 19:58:47 +0000101 {"defaults", ~0, 0},
102 {"dev", ~MS_NODEV, 0},
Erik Andersen6c5f2c62000-05-05 19:49:33 +0000103 {"diratime", ~0, ~MS_NODIRATIME},
Erik Andersene49d5ec2000-02-08 19:58:47 +0000104 {"exec", ~MS_NOEXEC, 0},
Erik Andersen6c5f2c62000-05-05 19:49:33 +0000105 {"noatime", ~0, MS_NOATIME},
Erik Andersene49d5ec2000-02-08 19:58:47 +0000106 {"nodev", ~0, MS_NODEV},
Erik Andersen6c5f2c62000-05-05 19:49:33 +0000107 {"nodiratime", ~0, MS_NODIRATIME},
Erik Andersene49d5ec2000-02-08 19:58:47 +0000108 {"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 {0, 0, 0}
Eric Andersencc8ed391999-10-05 16:24:54 +0000116};
117
Eric Andersend0246fb1999-11-04 21:18:07 +0000118static int
Erik Andersene49d5ec2000-02-08 19:58:47 +0000119do_mount(char *specialfile, char *dir, char *filesystemtype,
120 long flags, void *string_flags, int useMtab, int fakeIt,
121 char *mtab_opts)
Eric Andersend0246fb1999-11-04 21:18:07 +0000122{
Erik Andersene49d5ec2000-02-08 19:58:47 +0000123 int status = 0;
Eric Andersen8847b9a2000-09-21 01:33:05 +0000124#if defined BB_FEATURE_MOUNT_LOOP
Erik Andersene132f4b2000-02-09 04:16:43 +0000125 char *lofile = NULL;
Eric Andersen8847b9a2000-09-21 01:33:05 +0000126#endif
Eric Andersend0246fb1999-11-04 21:18:07 +0000127
Erik Andersene49d5ec2000-02-08 19:58:47 +0000128 if (fakeIt == FALSE)
Erik Andersene49d5ec2000-02-08 19:58:47 +0000129 {
Erik Andersenb7cc49d2000-01-13 06:38:14 +0000130#if defined BB_FEATURE_MOUNT_LOOP
Erik Andersene132f4b2000-02-09 04:16:43 +0000131 if (use_loop==TRUE) {
Erik Andersene49d5ec2000-02-08 19:58:47 +0000132 int loro = flags & MS_RDONLY;
Mark Whitleye677dfe2001-02-26 17:45:58 +0000133
134 lofile = specialfile;
Erik Andersene49d5ec2000-02-08 19:58:47 +0000135
136 specialfile = find_unused_loop_device();
137 if (specialfile == NULL) {
Matt Kraaidd19c692001-01-31 19:00:21 +0000138 error_msg_and_die("Could not find a spare loop device");
Erik Andersene49d5ec2000-02-08 19:58:47 +0000139 }
140 if (set_loop(specialfile, lofile, 0, &loro)) {
Matt Kraaidd19c692001-01-31 19:00:21 +0000141 error_msg_and_die("Could not setup loop device");
Erik Andersene49d5ec2000-02-08 19:58:47 +0000142 }
143 if (!(flags & MS_RDONLY) && loro) { /* loop is ro, but wanted rw */
Matt Kraaidd19c692001-01-31 19:00:21 +0000144 error_msg("WARNING: loop device is read-only");
Erik Andersene49d5ec2000-02-08 19:58:47 +0000145 flags &= ~MS_RDONLY;
146 }
147 }
Erik Andersenb7cc49d2000-01-13 06:38:14 +0000148#endif
Eric Andersena42982e2000-06-07 17:28:53 +0000149 status = mount(specialfile, dir, filesystemtype, flags, string_flags);
Eric Andersen0cccdfa2000-09-20 06:23:36 +0000150 if (errno == EROFS) {
Matt Kraaidd19c692001-01-31 19:00:21 +0000151 error_msg("%s is write-protected, mounting read-only", specialfile);
Eric Andersen0cccdfa2000-09-20 06:23:36 +0000152 status = mount(specialfile, dir, filesystemtype, flags |= MS_RDONLY, string_flags);
153 }
Erik Andersene49d5ec2000-02-08 19:58:47 +0000154 }
Erik Andersen5cbdd712000-01-26 20:06:48 +0000155
156
Erik Andersene49d5ec2000-02-08 19:58:47 +0000157 /* If the mount was sucessful, do anything needed, then return TRUE */
Eric Andersen0c8e2a62000-08-02 18:56:25 +0000158 if (status == 0 || fakeIt==TRUE) {
Erik Andersen5cbdd712000-01-26 20:06:48 +0000159
Eric Andersenc4cef5a2001-04-01 16:01:11 +0000160#if defined BB_FEATURE_MTAB_SUPPORT
Erik Andersene49d5ec2000-02-08 19:58:47 +0000161 if (useMtab == TRUE) {
Eric Andersenfdd51032000-08-02 18:48:26 +0000162 erase_mtab(specialfile); // Clean any stale entries
Erik Andersene49d5ec2000-02-08 19:58:47 +0000163 write_mtab(specialfile, dir, filesystemtype, flags, mtab_opts);
164 }
165#endif
166 return (TRUE);
167 }
168
169 /* Bummer. mount failed. Clean up */
170#if defined BB_FEATURE_MOUNT_LOOP
Erik Andersene132f4b2000-02-09 04:16:43 +0000171 if (lofile != NULL) {
Erik Andersene49d5ec2000-02-08 19:58:47 +0000172 del_loop(specialfile);
Erik Andersen5cbdd712000-01-26 20:06:48 +0000173 }
Eric Andersend0246fb1999-11-04 21:18:07 +0000174#endif
Eric Andersena42982e2000-06-07 17:28:53 +0000175
176 if (errno == EPERM) {
Matt Kraaidd19c692001-01-31 19:00:21 +0000177 error_msg_and_die("permission denied. Are you root?");
Eric Andersena42982e2000-06-07 17:28:53 +0000178 }
179
Erik Andersene49d5ec2000-02-08 19:58:47 +0000180 return (FALSE);
Erik Andersenb7cc49d2000-01-13 06:38:14 +0000181}
182
Eric Andersend0246fb1999-11-04 21:18:07 +0000183
Eric Andersencc8ed391999-10-05 16:24:54 +0000184
Eric Andersen8341a151999-10-08 17:14:14 +0000185/* Seperate standard mount options from the nonstandard string options */
Eric Andersencc8ed391999-10-05 16:24:54 +0000186static void
Eric Andersene7413a92000-07-14 06:19:41 +0000187parse_mount_options(char *options, int *flags, char *strflags)
Eric Andersencc8ed391999-10-05 16:24:54 +0000188{
Erik Andersene49d5ec2000-02-08 19:58:47 +0000189 while (options) {
190 int gotone = FALSE;
191 char *comma = strchr(options, ',');
192 const struct mount_options *f = mount_options;
Eric Andersencc8ed391999-10-05 16:24:54 +0000193
Erik Andersene49d5ec2000-02-08 19:58:47 +0000194 if (comma)
195 *comma = '\0';
Eric Andersen3ae0c781999-11-04 01:13:21 +0000196
Erik Andersene49d5ec2000-02-08 19:58:47 +0000197 while (f->name != 0) {
198 if (strcasecmp(f->name, options) == 0) {
199
200 *flags &= f->and;
201 *flags |= f->or;
202 gotone = TRUE;
203 break;
204 }
205 f++;
206 }
Erik Andersenb7cc49d2000-01-13 06:38:14 +0000207#if defined BB_FEATURE_MOUNT_LOOP
Erik Andersene49d5ec2000-02-08 19:58:47 +0000208 if (gotone == FALSE && !strcasecmp("loop", options)) { /* loop device support */
Erik Andersene132f4b2000-02-09 04:16:43 +0000209 use_loop = TRUE;
Erik Andersene49d5ec2000-02-08 19:58:47 +0000210 gotone = TRUE;
211 }
Erik Andersenb7cc49d2000-01-13 06:38:14 +0000212#endif
Erik Andersene49d5ec2000-02-08 19:58:47 +0000213 if (*strflags && strflags != '\0' && gotone == FALSE) {
214 char *temp = strflags;
215
216 temp += strlen(strflags);
217 *temp++ = ',';
218 *temp++ = '\0';
219 }
220 if (gotone == FALSE)
221 strcat(strflags, options);
222 if (comma) {
223 *comma = ',';
224 options = ++comma;
225 } else {
226 break;
227 }
Eric Andersencc8ed391999-10-05 16:24:54 +0000228 }
Eric Andersencc8ed391999-10-05 16:24:54 +0000229}
230
Glenn L McGrath1e117b42001-03-30 01:28:13 +0000231extern int
Eric Andersend0246fb1999-11-04 21:18:07 +0000232mount_one(char *blockDevice, char *directory, char *filesystemType,
Erik Andersene49d5ec2000-02-08 19:58:47 +0000233 unsigned long flags, char *string_flags, int useMtab, int fakeIt,
Erik Andersene132f4b2000-02-09 04:16:43 +0000234 char *mtab_opts, int whineOnErrors)
Eric Andersencc8ed391999-10-05 16:24:54 +0000235{
Erik Andersene49d5ec2000-02-08 19:58:47 +0000236 int status = 0;
Eric Andersencc8ed391999-10-05 16:24:54 +0000237
Erik Andersene49d5ec2000-02-08 19:58:47 +0000238 if (strcmp(filesystemType, "auto") == 0) {
Glenn L McGrath1e117b42001-03-30 01:28:13 +0000239 static const char *noauto_array[] = { "tmpfs", "shm", "proc", "ramfs", "devpts", "devfs", 0 };
240 const char **noauto_fstype;
Eric Andersen7b91f022001-03-01 07:50:04 +0000241 const int num_of_filesystems = sysfs(3, 0, 0);
242 char buf[255];
Glenn L McGrath323434b2001-03-02 22:21:34 +0000243 int i=0;
244
Eric Andersen7b91f022001-03-01 07:50:04 +0000245 filesystemType=buf;
Eric Andersencc8ed391999-10-05 16:24:54 +0000246
Eric Andersen7b91f022001-03-01 07:50:04 +0000247 while(i < num_of_filesystems) {
248 sysfs(2, i++, filesystemType);
Glenn L McGrath1e117b42001-03-30 01:28:13 +0000249 for (noauto_fstype = noauto_array; *noauto_fstype; noauto_fstype++) {
250 if (!strcmp(filesystemType, *noauto_fstype)) {
Glenn L McGrath323434b2001-03-02 22:21:34 +0000251 break;
252 }
253 }
Glenn L McGrath1e117b42001-03-30 01:28:13 +0000254 if (!*noauto_fstype) {
Glenn L McGrath323434b2001-03-02 22:21:34 +0000255 status = do_mount(blockDevice, directory, filesystemType,
Eric Andersen7b91f022001-03-01 07:50:04 +0000256 flags | MS_MGC_VAL, string_flags,
257 useMtab, fakeIt, mtab_opts);
Glenn L McGrath323434b2001-03-02 22:21:34 +0000258 if (status == TRUE)
259 break;
260 }
Erik Andersen246cc6d2000-03-07 07:41:42 +0000261 }
Eric Andersen7b91f022001-03-01 07:50:04 +0000262 } else {
Erik Andersene49d5ec2000-02-08 19:58:47 +0000263 status = do_mount(blockDevice, directory, filesystemType,
Eric Andersen7b91f022001-03-01 07:50:04 +0000264 flags | MS_MGC_VAL, string_flags, useMtab,
265 fakeIt, mtab_opts);
Erik Andersene49d5ec2000-02-08 19:58:47 +0000266 }
Eric Andersencc8ed391999-10-05 16:24:54 +0000267
Eric Andersena42982e2000-06-07 17:28:53 +0000268 if (status == FALSE) {
Erik Andersene132f4b2000-02-09 04:16:43 +0000269 if (whineOnErrors == TRUE) {
Matt Kraai1fa1ade2000-12-18 03:57:16 +0000270 perror_msg("Mounting %s on %s failed", blockDevice, directory);
Erik Andersene132f4b2000-02-09 04:16:43 +0000271 }
Erik Andersene49d5ec2000-02-08 19:58:47 +0000272 return (FALSE);
273 }
274 return (TRUE);
Eric Andersencc8ed391999-10-05 16:24:54 +0000275}
276
Matt Kraai12400822001-04-17 04:32:50 +0000277void show_mounts()
278{
279#if defined BB_FEATURE_USE_DEVPS_PATCH
280 int fd, i, numfilesystems;
281 char device[] = "/dev/mtab";
282 struct k_mntent *mntentlist;
283
284 /* open device */
285 fd = open(device, O_RDONLY);
286 if (fd < 0)
287 perror_msg_and_die("open failed for `%s'", device);
288
289 /* How many mounted filesystems? We need to know to
290 * allocate enough space for later... */
291 numfilesystems = ioctl (fd, DEVMTAB_COUNT_MOUNTS);
292 if (numfilesystems<0)
293 perror_msg_and_die( "\nDEVMTAB_COUNT_MOUNTS");
294 mntentlist = (struct k_mntent *) xcalloc ( numfilesystems, sizeof(struct k_mntent));
295
296 /* Grab the list of mounted filesystems */
297 if (ioctl (fd, DEVMTAB_GET_MOUNTS, mntentlist)<0)
298 perror_msg_and_die( "\nDEVMTAB_GET_MOUNTS");
299
300 for( i = 0 ; i < numfilesystems ; i++) {
301 printf( "%s %s %s %s %d %d\n", mntentlist[i].mnt_fsname,
302 mntentlist[i].mnt_dir, mntentlist[i].mnt_type,
303 mntentlist[i].mnt_opts, mntentlist[i].mnt_freq,
304 mntentlist[i].mnt_passno);
305 }
306#ifdef BB_FEATURE_CLEAN_UP
307 /* Don't bother to close files or free memory. Exit
308 * does that automagically, so we can save a few bytes */
309 free( mntentlist);
310 close(fd);
311#endif
312 exit(EXIT_SUCCESS);
313#else
314 FILE *mountTable = setmntent(mtab_file, "r");
315
316 if (mountTable) {
317 struct mntent *m;
318
319 while ((m = getmntent(mountTable)) != 0) {
320 char *blockDevice = m->mnt_fsname;
321 if (strcmp(blockDevice, "/dev/root") == 0) {
322 find_real_root_device_name( blockDevice);
323 }
324 printf("%s on %s type %s (%s)\n", blockDevice, m->mnt_dir,
325 m->mnt_type, m->mnt_opts);
326 }
327 endmntent(mountTable);
328 } else {
329 perror_msg_and_die("%s", mtab_file);
330 }
331 exit(EXIT_SUCCESS);
332#endif
333}
334
Erik Andersene49d5ec2000-02-08 19:58:47 +0000335extern int mount_main(int argc, char **argv)
Eric Andersencc8ed391999-10-05 16:24:54 +0000336{
Erik Andersene49d5ec2000-02-08 19:58:47 +0000337 char string_flags_buf[1024] = "";
338 char *string_flags = string_flags_buf;
339 char *extra_opts = string_flags_buf;
Eric Andersene7413a92000-07-14 06:19:41 +0000340 int flags = 0;
Erik Andersene49d5ec2000-02-08 19:58:47 +0000341 char *filesystemType = "auto";
Matt Kraai34251112001-05-02 21:17:38 +0000342 char device[PATH_MAX], directory[PATH_MAX];
Erik Andersene49d5ec2000-02-08 19:58:47 +0000343 int all = FALSE;
344 int fakeIt = FALSE;
345 int useMtab = TRUE;
Matt Kraai3e856ce2000-12-01 02:55:13 +0000346 int rc = EXIT_FAILURE;
Eric Andersenfdd51032000-08-02 18:48:26 +0000347 int fstabmount = FALSE;
Matt Kraaia3045df2001-04-17 04:48:51 +0000348 int opt;
Eric Andersencc8ed391999-10-05 16:24:54 +0000349
Erik Andersene49d5ec2000-02-08 19:58:47 +0000350 /* Parse options */
Matt Kraaia3045df2001-04-17 04:48:51 +0000351 while ((opt = getopt(argc, argv, "o:rt:wafnv")) > 0) {
352 switch (opt) {
353 case 'o':
354 parse_mount_options(optarg, &flags, string_flags);
355 break;
356 case 'r':
357 flags |= MS_RDONLY;
358 break;
359 case 't':
360 filesystemType = optarg;
361 break;
362 case 'w':
363 flags &= ~MS_RDONLY;
364 break;
365 case 'a':
366 all = TRUE;
367 break;
368 case 'f':
369 fakeIt = TRUE;
370 break;
Eric Andersenc4cef5a2001-04-01 16:01:11 +0000371#ifdef BB_FEATURE_MTAB_SUPPORT
Matt Kraaia3045df2001-04-17 04:48:51 +0000372 case 'n':
373 useMtab = FALSE;
374 break;
Eric Andersena9c95ea1999-11-15 17:33:30 +0000375#endif
Matt Kraaia3045df2001-04-17 04:48:51 +0000376 case 'v':
377 break; /* ignore -v */
Erik Andersene49d5ec2000-02-08 19:58:47 +0000378 }
Matt Kraaia3045df2001-04-17 04:48:51 +0000379 }
380
Matt Kraai34251112001-05-02 21:17:38 +0000381 if (!all && optind == argc)
Matt Kraai12400822001-04-17 04:32:50 +0000382 show_mounts();
383
Matt Kraai34251112001-05-02 21:17:38 +0000384 if (optind < argc)
385 if (realpath(argv[optind], device) == NULL)
386 perror_msg_and_die("%s", device);
387
388 if (optind + 1 < argc)
389 if (realpath(argv[optind + 1], directory) == NULL)
390 perror_msg_and_die("%s", directory);
391
392 if (all == TRUE || optind + 1 == argc) {
Erik Andersene49d5ec2000-02-08 19:58:47 +0000393 struct mntent *m;
394 FILE *f = setmntent("/etc/fstab", "r");
Eric Andersenfdd51032000-08-02 18:48:26 +0000395 fstabmount = TRUE;
Erik Andersene49d5ec2000-02-08 19:58:47 +0000396
Erik Andersen246cc6d2000-03-07 07:41:42 +0000397 if (f == NULL)
Matt Kraai1fa1ade2000-12-18 03:57:16 +0000398 perror_msg_and_die( "\nCannot read /etc/fstab");
Erik Andersen246cc6d2000-03-07 07:41:42 +0000399
Erik Andersene49d5ec2000-02-08 19:58:47 +0000400 while ((m = getmntent(f)) != NULL) {
Matt Kraai34251112001-05-02 21:17:38 +0000401 if (all == FALSE && optind + 1 == argc && (
Eric Andersenfdd51032000-08-02 18:48:26 +0000402 (strcmp(device, m->mnt_fsname) != 0) &&
403 (strcmp(device, m->mnt_dir) != 0) ) ) {
404 continue;
405 }
406
407 if (all == TRUE && ( // If we're mounting 'all'
408 (strstr(m->mnt_opts, "noauto")) || // and the file system isn't noauto,
409 (strstr(m->mnt_type, "swap")) || // and isn't swap or nfs, then mount it
410 (strstr(m->mnt_type, "nfs")) ) ) {
411 continue;
412 }
413
414 if (all == TRUE || flags == 0) { // Allow single mount to override fstab flags
Erik Andersene49d5ec2000-02-08 19:58:47 +0000415 flags = 0;
416 *string_flags = '\0';
417 parse_mount_options(m->mnt_opts, &flags, string_flags);
Erik Andersene49d5ec2000-02-08 19:58:47 +0000418 }
Eric Andersenfdd51032000-08-02 18:48:26 +0000419
Matt Kraai34251112001-05-02 21:17:38 +0000420 strcpy(device, m->mnt_fsname);
421 strcpy(directory, m->mnt_dir);
Eric Andersenfdd51032000-08-02 18:48:26 +0000422 filesystemType = strdup(m->mnt_type);
423singlemount:
Mark Whitley20f61d32001-03-14 17:30:44 +0000424 string_flags = strdup(string_flags);
Eric Andersend9d03b82000-12-12 23:20:37 +0000425 rc = EXIT_SUCCESS;
Erik Andersene49d5ec2000-02-08 19:58:47 +0000426#ifdef BB_NFSMOUNT
Pavel Roskin680d65a2000-06-06 17:03:55 +0000427 if (strchr(device, ':') != NULL)
428 filesystemType = "nfs";
Erik Andersene49d5ec2000-02-08 19:58:47 +0000429 if (strcmp(filesystemType, "nfs") == 0) {
Matt Kraai93ba60f2001-02-28 15:33:12 +0000430 if (nfsmount (device, directory, &flags, &extra_opts,
431 &string_flags, 1)) {
432 perror_msg("nfsmount failed");
Matt Kraai3e856ce2000-12-01 02:55:13 +0000433 rc = EXIT_FAILURE;
Eric Andersenfdd51032000-08-02 18:48:26 +0000434 }
Eric Andersen252bacc2000-09-19 01:21:13 +0000435 }
Erik Andersene49d5ec2000-02-08 19:58:47 +0000436#endif
Matt Kraai92ed8a32000-12-06 15:55:23 +0000437 if (!mount_one(device, directory, filesystemType, flags,
438 string_flags, useMtab, fakeIt, extra_opts, TRUE))
439 rc = EXIT_FAILURE;
Eric Andersenfdd51032000-08-02 18:48:26 +0000440
441 if (all == FALSE)
442 break;
Eric Andersenfdd51032000-08-02 18:48:26 +0000443 }
444 if (fstabmount == TRUE)
445 endmntent(f);
446
Matt Kraai34251112001-05-02 21:17:38 +0000447 if (all == FALSE && fstabmount == TRUE && optind + 1 == argc)
Eric Andersenfdd51032000-08-02 18:48:26 +0000448 fprintf(stderr, "Can't find %s in /etc/fstab\n", device);
449
Matt Kraai93ba60f2001-02-28 15:33:12 +0000450 return rc;
Eric Andersenfdd51032000-08-02 18:48:26 +0000451 }
452
453 goto singlemount;
Eric Andersencc8ed391999-10-05 16:24:54 +0000454}