mount.nfs: clean up a couple of printfs in fstab.c
[nfs-utils.git] / utils / mount / fstab.c
1 /* 1999-02-22 Arkadiusz Mi¬∂kiewicz <misiek@pld.ORG.PL>
2  * - added Native Language Support
3  * Sun Mar 21 1999 - Arnaldo Carvalho de Melo <acme@conectiva.com.br>
4  * - fixed strerr(errno) in gettext calls
5  *
6  * 2006-06-08 Amit Gud <agud@redhat.com>
7  * - Moved code to nfs-utils/support/nfs from util-linux/mount.
8  */
9
10 #include <errno.h>
11 #include <stdio.h>
12 #include <fcntl.h>
13 #include <unistd.h>
14 #include <string.h>
15 #include <sys/stat.h>
16 #include <mntent.h>
17
18 #include "fstab.h"
19 #include "xcommon.h"
20 #include "nfs_mntent.h"
21 #include "nfs_paths.h"
22 #include "nls.h"
23
24 #define LOCK_TIMEOUT    10
25 #define streq(s, t)     (strcmp ((s), (t)) == 0)
26 #define PROC_MOUNTS             "/proc/mounts"
27
28 extern char *progname;
29 extern int verbose;
30
31 /* Information about mtab. ------------------------------------*/
32 static int have_mtab_info = 0;
33 static int var_mtab_does_not_exist = 0;
34 static int var_mtab_is_a_symlink = 0;
35
36 static void
37 get_mtab_info(void) {
38         struct stat mtab_stat;
39
40         if (!have_mtab_info) {
41                 if (lstat(MOUNTED, &mtab_stat))
42                         var_mtab_does_not_exist = 1;
43                 else if (S_ISLNK(mtab_stat.st_mode))
44                         var_mtab_is_a_symlink = 1;
45                 have_mtab_info = 1;
46         }
47 }
48
49 int
50 mtab_does_not_exist(void) {
51         get_mtab_info();
52         return var_mtab_does_not_exist;
53 }
54
55 static int
56 mtab_is_a_symlink(void) {
57         get_mtab_info();
58         return var_mtab_is_a_symlink;
59 }
60
61 int
62 mtab_is_writable() {
63         int fd;
64
65         /* Should we write to /etc/mtab upon an update?
66            Probably not if it is a symlink to /proc/mounts, since that
67            would create a file /proc/mounts in case the proc filesystem
68            is not mounted. */
69         if (mtab_is_a_symlink())
70                 return 0;
71
72         fd = open(MOUNTED, O_RDWR | O_CREAT, 0644);
73         if (fd >= 0) {
74                 close(fd);
75                 return 1;
76         } else
77                 return 0;
78 }
79
80 /* Contents of mtab and fstab ---------------------------------*/
81
82 struct mntentchn mounttable;
83 static int got_mtab = 0;
84 struct mntentchn fstab;
85 static int got_fstab = 0;
86
87 static void read_mounttable(void);
88 static void read_fstab(void);
89
90 static struct mntentchn *
91 mtab_head(void)
92 {
93         if (!got_mtab)
94                 read_mounttable();
95         return &mounttable;
96 }
97
98 static struct mntentchn *
99 fstab_head(void)
100 {
101         if (!got_fstab)
102                 read_fstab();
103         return &fstab;
104 }
105
106 #if 0
107 static void
108 my_free(const void *s) {
109         if (s)
110                 free((void *) s);
111 }
112
113 static void
114 discard_mntentchn(struct mntentchn *mc0) {
115         struct mntentchn *mc, *mc1;
116
117         for (mc = mc0->nxt; mc && mc != mc0; mc = mc1) {
118                 mc1 = mc->nxt;
119                 my_free(mc->m.mnt_fsname);
120                 my_free(mc->m.mnt_dir);
121                 my_free(mc->m.mnt_type);
122                 my_free(mc->m.mnt_opts);
123                 free(mc);
124         }
125 }
126 #endif
127
128 static void
129 read_mntentchn(mntFILE *mfp, const char *fnam, struct mntentchn *mc0) {
130         struct mntentchn *mc = mc0;
131         struct mntent *mnt;
132
133         while ((mnt = nfs_getmntent(mfp)) != NULL) {
134                 if (!streq(mnt->mnt_type, MNTTYPE_IGNORE)) {
135                         mc->nxt = (struct mntentchn *) xmalloc(sizeof(*mc));
136                         mc->nxt->prev = mc;
137                         mc = mc->nxt;
138                         mc->m = *mnt;
139                         mc->nxt = mc0;
140                 }
141         }
142         mc0->prev = mc;
143         if (ferror(mfp->mntent_fp)) {
144                 int errsv = errno;
145                 nfs_error(_("warning: error reading %s: %s"),
146                       fnam, strerror (errsv));
147                 mc0->nxt = mc0->prev = NULL;
148         }
149         nfs_endmntent(mfp);
150 }
151
152 /*
153  * Read /etc/mtab.  If that fails, try /proc/mounts.
154  * This produces a linked list. The list head mounttable is a dummy.
155  * Return 0 on success.
156  */
157 static void
158 read_mounttable() {
159         mntFILE *mfp;
160         const char *fnam;
161         struct mntentchn *mc = &mounttable;
162
163         got_mtab = 1;
164         mc->nxt = mc->prev = NULL;
165
166         fnam = MOUNTED;
167         mfp = nfs_setmntent (fnam, "r");
168         if (mfp == NULL || mfp->mntent_fp == NULL) {
169                 int errsv = errno;
170                 fnam = PROC_MOUNTS;
171                 mfp = nfs_setmntent (fnam, "r");
172                 if (mfp == NULL || mfp->mntent_fp == NULL) {
173                         nfs_error(_("warning: can't open %s: %s"),
174                               MOUNTED, strerror (errsv));
175                         return;
176                 }
177                 if (verbose)
178                         printf(_("%s: could not open %s; using %s instead\n"),
179                                 progname, MOUNTED, PROC_MOUNTS);
180         }
181         read_mntentchn(mfp, fnam, mc);
182 }
183
184 static void
185 read_fstab()
186 {
187         mntFILE *mfp = NULL;
188         const char *fnam;
189         struct mntentchn *mc = &fstab;
190
191         got_fstab = 1;
192         mc->nxt = mc->prev = NULL;
193
194         fnam = _PATH_FSTAB;
195         mfp = nfs_setmntent (fnam, "r");
196         if (mfp == NULL || mfp->mntent_fp == NULL) {
197                 int errsv = errno;
198                 nfs_error(_("warning: can't open %s: %s"),
199                           _PATH_FSTAB, strerror (errsv));
200                 return;
201         }
202         read_mntentchn(mfp, fnam, mc);
203 }
204
205 /*
206  * Given the directory name NAME, and the place MCPREV we found it last time,
207  * try to find more occurrences.
208  */ 
209 struct mntentchn *
210 getmntdirbackward (const char *name, struct mntentchn *mcprev) {
211         struct mntentchn *mc, *mc0;
212
213         mc0 = mtab_head();
214         if (!mcprev)
215                 mcprev = mc0;
216         for (mc = mcprev->prev; mc && mc != mc0; mc = mc->prev)
217                 if (streq(mc->m.mnt_dir, name))
218                         return mc;
219         return NULL;
220 }
221
222 /*
223  * Given the device name NAME, and the place MCPREV we found it last time,
224  * try to find more occurrences.
225  */ 
226 struct mntentchn *
227 getmntdevbackward (const char *name, struct mntentchn *mcprev) {
228         struct mntentchn *mc, *mc0;
229
230         mc0 = mtab_head();
231         if (!mcprev)
232                 mcprev = mc0;
233         for (mc = mcprev->prev; mc && mc != mc0; mc = mc->prev)
234                 if (streq(mc->m.mnt_fsname, name))
235                         return mc;
236         return NULL;
237 }
238
239 /* Find the dir FILE in fstab.  */
240 struct mntentchn *
241 getfsfile (const char *file)
242 {
243         struct mntentchn *mc, *mc0;
244
245         mc0 = fstab_head();
246         for (mc = mc0->nxt; mc && mc != mc0; mc = mc->nxt)
247                 if (streq(mc->m.mnt_dir, file))
248                         return mc;
249         return NULL;
250 }
251
252 /* Find the device SPEC in fstab.  */
253 struct mntentchn *
254 getfsspec (const char *spec)
255 {
256         struct mntentchn *mc, *mc0;
257
258         mc0 = fstab_head();
259         for (mc = mc0->nxt; mc && mc != mc0; mc = mc->nxt)
260                 if (streq(mc->m.mnt_fsname, spec))
261                         return mc;
262         return NULL;
263 }
264
265 /* Updating mtab ----------------------------------------------*/
266
267 /* Flag for already existing lock file. */
268 static int we_created_lockfile = 0;
269 static int lockfile_fd = -1;
270
271 /* Flag to indicate that signals have been set up. */
272 static int signals_have_been_setup = 0;
273
274 /* Ensure that the lock is released if we are interrupted.  */
275 extern char *strsignal(int sig);        /* not always in <string.h> */
276
277 static void
278 handler (int sig) {
279      die(EX_USER, "%s", strsignal(sig));
280 }
281
282 static void
283 setlkw_timeout (int sig) {
284      /* nothing, fcntl will fail anyway */
285 }
286
287 /* Remove lock file.  */
288 void
289 unlock_mtab (void) {
290         if (we_created_lockfile) {
291                 close(lockfile_fd);
292                 lockfile_fd = -1;
293                 unlink (MOUNTED_LOCK);
294                 we_created_lockfile = 0;
295         }
296 }
297
298 /* Create the lock file.
299    The lock file will be removed if we catch a signal or when we exit. */
300 /* The old code here used flock on a lock file /etc/mtab~ and deleted
301    this lock file afterwards. However, as rgooch remarks, that has a
302    race: a second mount may be waiting on the lock and proceed as
303    soon as the lock file is deleted by the first mount, and immediately
304    afterwards a third mount comes, creates a new /etc/mtab~, applies
305    flock to that, and also proceeds, so that the second and third mount
306    now both are scribbling in /etc/mtab.
307    The new code uses a link() instead of a creat(), where we proceed
308    only if it was us that created the lock, and hence we always have
309    to delete the lock afterwards. Now the use of flock() is in principle
310    superfluous, but avoids an arbitrary sleep(). */
311
312 /* Where does the link point to? Obvious choices are mtab and mtab~~.
313    HJLu points out that the latter leads to races. Right now we use
314    mtab~.<pid> instead. Use 20 as upper bound for the length of %d. */
315 #define MOUNTLOCK_LINKTARGET            MOUNTED_LOCK "%d"
316 #define MOUNTLOCK_LINKTARGET_LTH        (sizeof(MOUNTED_LOCK)+20)
317
318 void
319 lock_mtab (void) {
320         int tries = 100000, i;
321         char linktargetfile[MOUNTLOCK_LINKTARGET_LTH];
322
323         at_die = unlock_mtab;
324
325         if (!signals_have_been_setup) {
326                 int sig = 0;
327                 struct sigaction sa;
328
329                 sa.sa_handler = handler;
330                 sa.sa_flags = 0;
331                 sigfillset (&sa.sa_mask);
332   
333                 while (sigismember (&sa.sa_mask, ++sig) != -1
334                        && sig != SIGCHLD) {
335                         if (sig == SIGALRM)
336                                 sa.sa_handler = setlkw_timeout;
337                         else
338                                 sa.sa_handler = handler;
339                         sigaction (sig, &sa, (struct sigaction *) 0);
340                 }
341                 signals_have_been_setup = 1;
342         }
343
344         sprintf(linktargetfile, MOUNTLOCK_LINKTARGET, getpid ());
345
346         i = open (linktargetfile, O_WRONLY|O_CREAT, 0);
347         if (i < 0) {
348                 int errsv = errno;
349                 /* linktargetfile does not exist (as a file)
350                    and we cannot create it. Read-only filesystem?
351                    Too many files open in the system?
352                    Filesystem full? */
353                 die (EX_FILEIO, _("can't create lock file %s: %s "
354                                                   "(use -n flag to override)"),
355                          linktargetfile, strerror (errsv));
356         }
357         close(i);
358         
359         /* Repeat until it was us who made the link */
360         while (!we_created_lockfile) {
361                 struct flock flock;
362                 int errsv, j;
363
364                 j = link(linktargetfile, MOUNTED_LOCK);
365                 errsv = errno;
366
367                 if (j == 0)
368                         we_created_lockfile = 1;
369
370                 if (j < 0 && errsv != EEXIST) {
371                         (void) unlink(linktargetfile);
372                         die (EX_FILEIO, _("can't link lock file %s: %s "
373                              "(use -n flag to override)"),
374                              MOUNTED_LOCK, strerror (errsv));
375                 }
376
377                 lockfile_fd = open (MOUNTED_LOCK, O_WRONLY);
378
379                 if (lockfile_fd < 0) {
380                         int errsv = errno;
381                         /* Strange... Maybe the file was just deleted? */
382                         if (errno == ENOENT && tries-- > 0) {
383                                 if (tries % 200 == 0)
384                                         usleep(30);
385                                 continue;
386                         }
387                         (void) unlink(linktargetfile);
388                         die (EX_FILEIO, _("can't open lock file %s: %s "
389                              "(use -n flag to override)"),
390                              MOUNTED_LOCK, strerror (errsv));
391                 }
392
393                 flock.l_type = F_WRLCK;
394                 flock.l_whence = SEEK_SET;
395                 flock.l_start = 0;
396                 flock.l_len = 0;
397
398                 if (j == 0) {
399                         /* We made the link. Now claim the lock. */
400                         if (fcntl (lockfile_fd, F_SETLK, &flock) == -1) {
401                                 if (verbose) {
402                                     int errsv = errno;
403                                     nfs_error(_("%s: Can't lock lock file "
404                                                 "%s: %s"), progname,
405                                                 MOUNTED_LOCK,
406                                                 strerror (errsv));
407                                 }
408                                 /* proceed anyway */
409                         }
410                         (void) unlink(linktargetfile);
411                 } else {
412                         static int tries = 0;
413
414                         /* Someone else made the link. Wait. */
415                         alarm(LOCK_TIMEOUT);
416                         if (fcntl (lockfile_fd, F_SETLKW, &flock) == -1) {
417                                 int errsv = errno;
418                                 (void) unlink(linktargetfile);
419                                 die (EX_FILEIO, _("can't lock lock file %s: %s"),
420                                      MOUNTED_LOCK, (errno == EINTR) ?
421                                      _("timed out") : strerror (errsv));
422                         }
423                         alarm(0);
424                         /* Limit the number of iterations - maybe there
425                            still is some old /etc/mtab~ */
426                         ++tries;
427                         if (tries % 200 == 0)
428                            usleep(30);
429                         if (tries > 100000) {
430                                 (void) unlink(linktargetfile);
431                                 close(lockfile_fd);
432                                 die (EX_FILEIO, _("Cannot create link %s\n"
433                                                   "Perhaps there is a stale lock file?\n"),
434                                          MOUNTED_LOCK);
435                         }
436                         close(lockfile_fd);
437                 }
438         }
439 }
440
441 /*
442  * Update the mtab.
443  *  Used by umount with null INSTEAD: remove the last DIR entry.
444  *  Used by mount upon a remount: update option part,
445  *   and complain if a wrong device or type was given.
446  *   [Note that often a remount will be a rw remount of /
447  *    where there was no entry before, and we'll have to believe
448  *    the values given in INSTEAD.]
449  */
450
451 void
452 update_mtab (const char *dir, struct mntent *instead)
453 {
454         mntFILE *mfp, *mftmp;
455         const char *fnam = MOUNTED;
456         struct mntentchn mtabhead;      /* dummy */
457         struct mntentchn *mc, *mc0, *absent = NULL;
458
459         if (mtab_does_not_exist() || !mtab_is_writable())
460                 return;
461
462         lock_mtab();
463
464         /* having locked mtab, read it again */
465         mc0 = mc = &mtabhead;
466         mc->nxt = mc->prev = NULL;
467
468         mfp = nfs_setmntent(fnam, "r");
469         if (mfp == NULL || mfp->mntent_fp == NULL) {
470                 int errsv = errno;
471                 nfs_error (_("cannot open %s (%s) - mtab not updated"),
472                        fnam, strerror (errsv));
473                 goto leave;
474         }
475
476         read_mntentchn(mfp, fnam, mc);
477
478         /* find last occurrence of dir */
479         for (mc = mc0->prev; mc && mc != mc0; mc = mc->prev)
480                 if (streq(mc->m.mnt_dir, dir))
481                         break;
482         if (mc && mc != mc0) {
483                 if (instead == NULL) {
484                         /* An umount - remove entry */
485                         if (mc && mc != mc0) {
486                                 mc->prev->nxt = mc->nxt;
487                                 mc->nxt->prev = mc->prev;
488                                 free(mc);
489                         }
490                 } else {
491                         /* A remount */
492                         mc->m.mnt_opts = instead->mnt_opts;
493                 }
494         } else if (instead) {
495                 /* not found, add a new entry */
496                 absent = xmalloc(sizeof(*absent));
497                 absent->m = *instead;
498                 absent->nxt = mc0;
499                 absent->prev = mc0->prev;
500                 mc0->prev = absent;
501                 if (mc0->nxt == NULL)
502                         mc0->nxt = absent;
503         }
504
505         /* write chain to mtemp */
506         mftmp = nfs_setmntent (MOUNTED_TEMP, "w");
507         if (mftmp == NULL || mftmp->mntent_fp == NULL) {
508                 int errsv = errno;
509                 nfs_error (_("cannot open %s (%s) - mtab not updated"),
510                        MOUNTED_TEMP, strerror (errsv));
511                 goto leave;
512         }
513
514         for (mc = mc0->nxt; mc && mc != mc0; mc = mc->nxt) {
515                 if (nfs_addmntent(mftmp, &(mc->m)) == 1) {
516                         int errsv = errno;
517                         die (EX_FILEIO, _("error writing %s: %s"),
518                              MOUNTED_TEMP, strerror (errsv));
519                 }
520         }
521
522 #if 0
523         /* the chain might have strings copied from 'instead',
524          * so we cannot safely free it.
525          * And there is no need anyway because we are going to exit
526          * shortly.  So just don't call discard_mntentchn....
527          */
528         discard_mntentchn(mc0);
529 #endif
530         if (fchmod (fileno (mftmp->mntent_fp),
531                     S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH) < 0) {
532                 int errsv = errno;
533                 nfs_error(_("%s: error changing mode of %s: %s"),
534                                 progname, MOUNTED_TEMP, strerror (errsv));
535         }
536         nfs_endmntent (mftmp);
537
538         { /*
539            * If mount is setuid and some non-root user mounts sth,
540            * then mtab.tmp might get the group of this user. Copy uid/gid
541            * from the present mtab before renaming.
542            */
543             struct stat sbuf;
544             if (stat (MOUNTED, &sbuf) == 0)
545                 chown (MOUNTED_TEMP, sbuf.st_uid, sbuf.st_gid);
546         }
547
548         /* rename mtemp to mtab */
549         if (rename (MOUNTED_TEMP, MOUNTED) < 0) {
550                 int errsv = errno;
551                 nfs_error(_("%s: can't rename %s to %s: %s\n"),
552                                 progname, MOUNTED_TEMP, MOUNTED,
553                                 strerror(errsv));
554         }
555
556  leave:
557         unlock_mtab();
558 }