3a2a237931835eeea19ca311138079442221235b
[nfs-utils.git] / utils / mount / stropts.c
1 /*
2  * stropts.c -- NFS mount using C string to pass options to kernel
3  *
4  * Copyright (C) 2007 Oracle.  All rights reserved.
5  * Copyright (C) 2007 Chuck Lever <chuck.lever@oracle.com>
6  *
7  * This program is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU General Public
9  * License as published by the Free Software Foundation; either
10  * version 2 of the License, or (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
18  * License along with this program; if not, write to the
19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20  * Boston, MA 021110-1307, USA.
21  *
22  */
23
24 #ifdef HAVE_CONFIG_H
25 #include <config.h>
26 #endif
27
28 #include <unistd.h>
29 #include <errno.h>
30 #include <netdb.h>
31 #include <time.h>
32
33 #include <sys/socket.h>
34 #include <sys/mount.h>
35 #include <netinet/in.h>
36 #include <arpa/inet.h>
37
38 #include "xcommon.h"
39 #include "mount.h"
40 #include "nls.h"
41 #include "mount_constants.h"
42 #include "stropts.h"
43 #include "error.h"
44 #include "network.h"
45 #include "parse_opt.h"
46 #include "version.h"
47 #include "parse_dev.h"
48 #include "conffile.h"
49
50 #ifndef NFS_PROGRAM
51 #define NFS_PROGRAM     (100003)
52 #endif
53
54 #ifndef NFS_PORT
55 #define NFS_PORT        (2049)
56 #endif
57
58 #ifndef NFS_MAXHOSTNAME
59 #define NFS_MAXHOSTNAME         (255)
60 #endif
61
62 #ifndef NFS_MAXPATHNAME
63 #define NFS_MAXPATHNAME         (1024)
64 #endif
65
66 #ifndef NFS_DEF_FG_TIMEOUT_MINUTES
67 #define NFS_DEF_FG_TIMEOUT_MINUTES      (2u)
68 #endif
69
70 #ifndef NFS_DEF_BG_TIMEOUT_MINUTES
71 #define NFS_DEF_BG_TIMEOUT_MINUTES      (10000u)
72 #endif
73
74 extern int nfs_mount_data_version;
75 extern char *progname;
76 extern int verbose;
77 extern int sloppy;
78
79 struct nfsmount_info {
80         const char              *spec,          /* server:/path */
81                                 *node,          /* mounted-on dir */
82                                 *type;          /* "nfs" or "nfs4" */
83         char                    *hostname;      /* server's hostname */
84         struct sockaddr_storage address;        /* server's address */
85         socklen_t               salen;          /* size of server's address */
86
87         struct mount_options    *options;       /* parsed mount options */
88         char                    **extra_opts;   /* string for /etc/mtab */
89
90         unsigned long           version;        /* NFS version */
91         int                     flags,          /* MS_ flags */
92                                 fake,           /* actually do the mount? */
93                                 child;          /* forked bg child? */
94 };
95
96 #ifdef MOUNT_CONFIG
97 static void nfs_default_version(struct nfsmount_info *mi);
98
99 static void nfs_default_version(struct nfsmount_info *mi)
100 {
101         extern unsigned long config_default_vers;
102         /*
103          * Use the default value set in the config file when
104          * the version has not been explicitly set.
105          */
106         if (mi->version == 0 && config_default_vers) {
107                 if (config_default_vers < 4)
108                         mi->version = config_default_vers;
109         }
110 }
111 #else
112 inline void nfs_default_version(struct nfsmount_info *mi) {}
113 #endif /* MOUNT_CONFIG */
114
115 /*
116  * Obtain a retry timeout value based on the value of the "retry=" option.
117  *
118  * Returns a time_t timeout timestamp, in seconds.
119  */
120 static time_t nfs_parse_retry_option(struct mount_options *options,
121                                      unsigned int timeout_minutes)
122 {
123         long tmp;
124
125         switch (po_get_numeric(options, "retry", &tmp)) {
126         case PO_NOT_FOUND:
127                 break;
128         case PO_FOUND:
129                 if (tmp >= 0) {
130                         timeout_minutes = tmp;
131                         break;
132                 }
133         case PO_BAD_VALUE:
134                 if (verbose)
135                         nfs_error(_("%s: invalid retry timeout was specified; "
136                                         "using default timeout"), progname);
137                 break;
138         }
139
140         return time(NULL) + (time_t)(timeout_minutes * 60);
141 }
142
143 /*
144  * Convert the passed-in sockaddr-style address to presentation
145  * format, then append an option of the form "keyword=address".
146  *
147  * Returns 1 if the option was appended successfully; otherwise zero.
148  */
149 static int nfs_append_generic_address_option(const struct sockaddr *sap,
150                                              const socklen_t salen,
151                                              const char *keyword,
152                                              struct mount_options *options)
153 {
154         char address[NI_MAXHOST];
155         char new_option[512];
156         int len;
157
158         if (!nfs_present_sockaddr(sap, salen, address, sizeof(address)))
159                 goto out_err;
160
161         len = snprintf(new_option, sizeof(new_option), "%s=%s",
162                                                 keyword, address);
163         if (len < 0 || (size_t)len >= sizeof(new_option))
164                 goto out_err;
165
166         if (po_append(options, new_option) != PO_SUCCEEDED)
167                 goto out_err;
168
169         return 1;
170
171 out_err:
172         nfs_error(_("%s: failed to construct %s option"), progname, keyword);
173         return 0;
174 }
175
176 /*
177  * Append the 'addr=' option to the options string to pass a resolved
178  * server address to the kernel.  After a successful mount, this address
179  * is also added to /etc/mtab for use when unmounting.
180  *
181  * If 'addr=' is already present, we strip it out.  This prevents users
182  * from setting a bogus 'addr=' option themselves, and also allows bg
183  * retries to recompute the server's address, in case it has changed.
184  *
185  * Returns 1 if 'addr=' option appended successfully;
186  * otherwise zero.
187  */
188 static int nfs_append_addr_option(const struct sockaddr *sap,
189                                   socklen_t salen,
190                                   struct mount_options *options)
191 {
192         po_remove_all(options, "addr");
193         return nfs_append_generic_address_option(sap, salen, "addr", options);
194 }
195
196 /*
197  * Called to discover our address and append an appropriate 'clientaddr='
198  * option to the options string.
199  *
200  * Returns 1 if 'clientaddr=' option created successfully or if
201  * 'clientaddr=' option is already present; otherwise zero.
202  */
203 static int nfs_append_clientaddr_option(const struct sockaddr *sap,
204                                         socklen_t salen,
205                                         struct mount_options *options)
206 {
207         struct sockaddr_storage dummy;
208         struct sockaddr *my_addr = (struct sockaddr *)&dummy;
209         socklen_t my_len = sizeof(dummy);
210
211         if (po_contains(options, "clientaddr") == PO_FOUND)
212                 return 1;
213
214         nfs_callback_address(sap, salen, my_addr, &my_len);
215
216         return nfs_append_generic_address_option(my_addr, my_len,
217                                                         "clientaddr", options);
218 }
219
220 /*
221  * Resolve the 'mounthost=' hostname and append a new option using
222  * the resulting address.
223  */
224 static int nfs_fix_mounthost_option(struct mount_options *options)
225 {
226         struct sockaddr_storage dummy;
227         struct sockaddr *sap = (struct sockaddr *)&dummy;
228         socklen_t salen = sizeof(dummy);
229         char *mounthost;
230
231         mounthost = po_get(options, "mounthost");
232         if (!mounthost)
233                 return 1;
234
235         if (!nfs_name_to_address(mounthost, sap, &salen)) {
236                 nfs_error(_("%s: unable to determine mount server's address"),
237                                 progname);
238                 return 0;
239         }
240
241         return nfs_append_generic_address_option(sap, salen,
242                                                         "mountaddr", options);
243 }
244
245 /*
246  * Returns zero if the "lock" option is in effect, but statd
247  * can't be started.  Otherwise, returns 1.
248  */
249 static const char *nfs_lock_opttbl[] = {
250         "nolock",
251         "lock",
252         NULL,
253 };
254
255 static int nfs_verify_lock_option(struct mount_options *options)
256 {
257         if (po_rightmost(options, nfs_lock_opttbl) == 0)
258                 return 1;
259
260         if (!start_statd()) {
261                 nfs_error(_("%s: rpc.statd is not running but is "
262                             "required for remote locking."), progname);
263                 nfs_error(_("%s: Either use '-o nolock' to keep "
264                             "locks local, or start statd."), progname);
265                 return 0;
266         }
267
268         return 1;
269 }
270
271 static int nfs_append_sloppy_option(struct mount_options *options)
272 {
273         if (!sloppy || linux_version_code() < MAKE_VERSION(2, 6, 27))
274                 return 1;
275
276         if (po_append(options, "sloppy") == PO_FAILED)
277                 return 0;
278         return 1;
279 }
280
281 /*
282  * Set up mandatory non-version specific NFS mount options.
283  *
284  * Returns 1 if successful; otherwise zero.
285  */
286 static int nfs_validate_options(struct nfsmount_info *mi)
287 {
288         struct sockaddr *sap = (struct sockaddr *)&mi->address;
289
290         if (!nfs_parse_devname(mi->spec, &mi->hostname, NULL))
291                 return 0;
292
293         mi->salen = sizeof(mi->address);
294         if (!nfs_name_to_address(mi->hostname, sap, &mi->salen))
295                 return 0;
296
297         if (!nfs_nfs_version(mi->options, &mi->version))
298                 return 0;
299         if (strncmp(mi->type, "nfs4", 4) == 0)
300                 mi->version = 4;
301         else {
302                 char *option = po_get(mi->options, "proto");
303                 if (option && strcmp(option, "rdma") == 0)
304                         mi->version = 3;
305         }
306
307         /*
308          * If enabled, see if the default version was
309          * set in the config file
310          */
311         nfs_default_version(mi);
312
313         if (!nfs_append_sloppy_option(mi->options))
314                 return 0;
315
316         if (!nfs_append_addr_option(sap, mi->salen, mi->options))
317                 return 0;
318
319         return 1;
320 }
321
322 /*
323  * Get NFS/mnt server addresses from mount options
324  *
325  * Returns 1 and fills in @nfs_saddr, @nfs_salen, @mnt_saddr, and @mnt_salen
326  * if all goes well; otherwise zero.
327  */
328 static int nfs_extract_server_addresses(struct mount_options *options,
329                                         struct sockaddr *nfs_saddr,
330                                         socklen_t *nfs_salen,
331                                         struct sockaddr *mnt_saddr,
332                                         socklen_t *mnt_salen)
333 {
334         char *option;
335
336         option = po_get(options, "addr");
337         if (option == NULL)
338                 return 0;
339         if (!nfs_string_to_sockaddr(option, nfs_saddr, nfs_salen))
340                 return 0;
341
342         option = po_get(options, "mountaddr");
343         if (option == NULL) {
344                 memcpy(mnt_saddr, nfs_saddr, *nfs_salen);
345                 *mnt_salen = *nfs_salen;
346         } else if (!nfs_string_to_sockaddr(option, mnt_saddr, mnt_salen))
347                 return 0;
348
349         return 1;
350 }
351
352 static int nfs_construct_new_options(struct mount_options *options,
353                                      struct pmap *nfs_pmap,
354                                      struct pmap *mnt_pmap)
355 {
356         char new_option[64];
357
358         po_remove_all(options, "nfsprog");
359         po_remove_all(options, "mountprog");
360
361         po_remove_all(options, "v2");
362         po_remove_all(options, "v3");
363         po_remove_all(options, "vers");
364         po_remove_all(options, "nfsvers");
365         snprintf(new_option, sizeof(new_option) - 1,
366                  "vers=%lu", nfs_pmap->pm_vers);
367         if (po_append(options, new_option) == PO_FAILED)
368                 return 0;
369
370         po_remove_all(options, "proto");
371         po_remove_all(options, "udp");
372         po_remove_all(options, "tcp");
373         switch (nfs_pmap->pm_prot) {
374         case IPPROTO_TCP:
375                 snprintf(new_option, sizeof(new_option) - 1,
376                          "proto=tcp");
377                 if (po_append(options, new_option) == PO_FAILED)
378                         return 0;
379                 break;
380         case IPPROTO_UDP:
381                 snprintf(new_option, sizeof(new_option) - 1,
382                          "proto=udp");
383                 if (po_append(options, new_option) == PO_FAILED)
384                         return 0;
385                 break;
386         }
387
388         po_remove_all(options, "port");
389         if (nfs_pmap->pm_port != NFS_PORT) {
390                 snprintf(new_option, sizeof(new_option) - 1,
391                          "port=%lu", nfs_pmap->pm_port);
392                 if (po_append(options, new_option) == PO_FAILED)
393                         return 0;
394         }
395
396         po_remove_all(options, "mountvers");
397         snprintf(new_option, sizeof(new_option) - 1,
398                  "mountvers=%lu", mnt_pmap->pm_vers);
399         if (po_append(options, new_option) == PO_FAILED)
400                 return 0;
401
402         po_remove_all(options, "mountproto");
403         switch (mnt_pmap->pm_prot) {
404         case IPPROTO_TCP:
405                 snprintf(new_option, sizeof(new_option) - 1,
406                          "mountproto=tcp");
407                 if (po_append(options, new_option) == PO_FAILED)
408                         return 0;
409                 break;
410         case IPPROTO_UDP:
411                 snprintf(new_option, sizeof(new_option) - 1,
412                          "mountproto=udp");
413                 if (po_append(options, new_option) == PO_FAILED)
414                         return 0;
415                 break;
416         }
417
418         po_remove_all(options, "mountport");
419         snprintf(new_option, sizeof(new_option) - 1,
420                  "mountport=%lu", mnt_pmap->pm_port);
421         if (po_append(options, new_option) == PO_FAILED)
422                 return 0;
423
424         return 1;
425 }
426
427 /*
428  * Reconstruct the mount option string based on a portmapper probe
429  * of the server.  Returns one if the server's portmapper returned
430  * something we can use, otherwise zero.
431  *
432  * To handle version and transport protocol fallback properly, we
433  * need to parse some of the mount options in order to set up a
434  * portmap probe.  Mount options that nfs_rewrite_pmap_mount_options()
435  * doesn't recognize are left alone.
436  *
437  * Returns TRUE if rewriting was successful; otherwise
438  * FALSE is returned if some failure occurred.
439  */
440 static int
441 nfs_rewrite_pmap_mount_options(struct mount_options *options)
442 {
443         struct sockaddr_storage nfs_address;
444         struct sockaddr *nfs_saddr = (struct sockaddr *)&nfs_address;
445         socklen_t nfs_salen = sizeof(nfs_address);
446         struct pmap nfs_pmap;
447         struct sockaddr_storage mnt_address;
448         struct sockaddr *mnt_saddr = (struct sockaddr *)&mnt_address;
449         socklen_t mnt_salen = sizeof(mnt_address);
450         struct pmap mnt_pmap;
451         char *option;
452
453         /*
454          * Skip option negotiation for proto=rdma mounts.
455          */
456         option = po_get(options, "proto");
457         if (option && strcmp(option, "rdma") == 0)
458                 goto out;
459
460         /*
461          * Extract just the options needed to contact server.
462          * Bail now if any of these have bad values.
463          */
464         if (!nfs_extract_server_addresses(options, nfs_saddr, &nfs_salen,
465                                                 mnt_saddr, &mnt_salen)) {
466                 errno = EINVAL;
467                 return 0;
468         }
469         if (!nfs_options2pmap(options, &nfs_pmap, &mnt_pmap)) {
470                 errno = EINVAL;
471                 return 0;
472         }
473
474         /*
475          * The kernel NFS client doesn't support changing the RPC
476          * program number for these services, so force the value of
477          * these fields before probing the server's ports.
478          */
479         nfs_pmap.pm_prog = NFS_PROGRAM;
480         mnt_pmap.pm_prog = MOUNTPROG;
481
482         /*
483          * If the server's rpcbind service isn't available, we can't
484          * negotiate.  Bail now if we can't contact it.
485          */
486         if (!nfs_probe_bothports(mnt_saddr, mnt_salen, &mnt_pmap,
487                                  nfs_saddr, nfs_salen, &nfs_pmap)) {
488                 errno = ESPIPE;
489                 return 0;
490         }
491
492         if (!nfs_construct_new_options(options, &nfs_pmap, &mnt_pmap)) {
493                 errno = EINVAL;
494                 return 0;
495         }
496
497 out:
498         errno = 0;
499         return 1;
500 }
501
502 /*
503  * Do the mount(2) system call.
504  *
505  * Returns TRUE if successful, otherwise FALSE.
506  * "errno" is set to reflect the individual error.
507  */
508 static int nfs_sys_mount(struct nfsmount_info *mi, struct mount_options *opts)
509 {
510         char *options = NULL;
511         int result;
512
513         if (po_join(opts, &options) == PO_FAILED) {
514                 errno = EIO;
515                 return 0;
516         }
517
518         if (verbose)
519                 printf(_("%s: trying text-based options '%s'\n"),
520                         progname, options);
521
522         if (mi->fake)
523                 return 1;
524
525         result = mount(mi->spec, mi->node, mi->type,
526                         mi->flags & ~(MS_USER|MS_USERS), options);
527         if (verbose && result) {
528                 int save = errno;
529                 nfs_error(_("%s: mount(2): %s"), progname, strerror(save));
530                 errno = save;
531         }
532         return !result;
533 }
534
535 /*
536  * For "-t nfs vers=2" or "-t nfs vers=3" mounts.
537  */
538 static int nfs_try_mount_v3v2(struct nfsmount_info *mi)
539 {
540         struct mount_options *options = po_dup(mi->options);
541         int result = 0;
542
543         if (!options) {
544                 errno = ENOMEM;
545                 return result;
546         }
547
548         if (!nfs_fix_mounthost_option(options)) {
549                 errno = EINVAL;
550                 goto out_fail;
551         }
552         if (!mi->fake && !nfs_verify_lock_option(options)) {
553                 errno = EINVAL;
554                 goto out_fail;
555         }
556
557         /*
558          * Options we negotiate below may be stale by the time this
559          * file system is unmounted.  In order to force umount.nfs
560          * to renegotiate with the server, only write the user-
561          * specified options, and not negotiated options, to /etc/mtab.
562          */
563         if (po_join(options, mi->extra_opts) == PO_FAILED) {
564                 errno = ENOMEM;
565                 goto out_fail;
566         }
567
568         if (!nfs_rewrite_pmap_mount_options(options))
569                 goto out_fail;
570
571         result = nfs_sys_mount(mi, options);
572
573 out_fail:
574         po_destroy(options);
575         return result;
576 }
577
578 /*
579  * For "-t nfs -o vers=4" or "-t nfs4" mounts.
580  */
581 static int nfs_try_mount_v4(struct nfsmount_info *mi)
582 {
583         struct sockaddr *sap = (struct sockaddr *)&mi->address;
584         struct mount_options *options = po_dup(mi->options);
585         int result = 0;
586
587         if (!options) {
588                 errno = ENOMEM;
589                 return result;
590         }
591
592         if (mi->version == 0) {
593                 if (po_append(options, "vers=4") == PO_FAILED) {
594                         errno = EINVAL;
595                         goto out_fail;
596                 }
597         }
598
599         if (!nfs_append_clientaddr_option(sap, mi->salen, options)) {
600                 errno = EINVAL;
601                 goto out_fail;
602         }
603         /*
604          * Update option string to be recorded in /etc/mtab.
605          */
606         if (po_join(options, mi->extra_opts) == PO_FAILED) {
607                 errno = ENOMEM;
608                 return 0;
609         }
610
611         result = nfs_sys_mount(mi, options);
612
613 out_fail:
614         po_destroy(options);
615         return result;
616 }
617
618 /*
619  * This is a single pass through the fg/bg loop.
620  *
621  * Returns TRUE if successful, otherwise FALSE.
622  * "errno" is set to reflect the individual error.
623  */
624 static int nfs_try_mount(struct nfsmount_info *mi)
625 {
626         int result = 0;
627
628         switch (mi->version) {
629         case 0:
630                 if (linux_version_code() > MAKE_VERSION(2, 6, 31)) {
631                         errno = 0;
632                         result = nfs_try_mount_v4(mi);
633                         if (errno != EPROTONOSUPPORT) {
634                                 /* 
635                                  * To deal with legacy Linux servers that don't
636                                  * automatically export a pseudo root, retry
637                                  * ENOENT errors using version 3
638                                  */
639                                 if (errno != ENOENT)
640                                         break;
641                         }
642                 }
643         case 2:
644         case 3:
645                 result = nfs_try_mount_v3v2(mi);
646                 break;
647         case 4:
648                 result = nfs_try_mount_v4(mi);
649                 break;
650         default:
651                 errno = EIO;
652         }
653
654         return result;
655 }
656
657 /*
658  * Distinguish between permanent and temporary errors.
659  *
660  * Basically, we retry if communication with the server has
661  * failed so far, but fail immediately if there is a local
662  * error (like a bad mount option).
663  *
664  * ESTALE is also a temporary error because some servers
665  * return ESTALE when a share is temporarily offline.
666  *
667  * Returns 1 if we should fail immediately, or 0 if we
668  * should retry.
669  */
670 static int nfs_is_permanent_error(int error)
671 {
672         switch (error) {
673         case ESTALE:
674         case ETIMEDOUT:
675         case ECONNREFUSED:
676                 return 0;       /* temporary */
677         default:
678                 return 1;       /* permanent */
679         }
680 }
681
682 /*
683  * Handle "foreground" NFS mounts.
684  *
685  * Retry the mount request for as long as the 'retry=' option says.
686  *
687  * Returns a valid mount command exit code.
688  */
689 static int nfsmount_fg(struct nfsmount_info *mi)
690 {
691         unsigned int secs = 1;
692         time_t timeout;
693
694         timeout = nfs_parse_retry_option(mi->options,
695                                          NFS_DEF_FG_TIMEOUT_MINUTES);
696         if (verbose)
697                 printf(_("%s: timeout set for %s"),
698                         progname, ctime(&timeout));
699
700         for (;;) {
701                 if (nfs_try_mount(mi))
702                         return EX_SUCCESS;
703
704                 if (nfs_is_permanent_error(errno))
705                         break;
706
707                 if (time(NULL) > timeout) {
708                         errno = ETIMEDOUT;
709                         break;
710                 }
711
712                 if (errno != ETIMEDOUT) {
713                         if (sleep(secs))
714                                 break;
715                         secs <<= 1;
716                         if (secs > 10)
717                                 secs = 10;
718                 }
719         };
720
721         mount_error(mi->spec, mi->node, errno);
722         return EX_FAIL;
723 }
724
725 /*
726  * Handle "background" NFS mount [first try]
727  *
728  * Returns a valid mount command exit code.
729  *
730  * EX_BG should cause the caller to fork and invoke nfsmount_child.
731  */
732 static int nfsmount_parent(struct nfsmount_info *mi)
733 {
734         if (nfs_try_mount(mi))
735                 return EX_SUCCESS;
736
737         if (nfs_is_permanent_error(errno)) {
738                 mount_error(mi->spec, mi->node, errno);
739                 return EX_FAIL;
740         }
741
742         sys_mount_errors(mi->hostname, errno, 1, 1);
743         return EX_BG;
744 }
745
746 /*
747  * Handle "background" NFS mount [retry daemon]
748  *
749  * Returns a valid mount command exit code: EX_SUCCESS if successful,
750  * EX_FAIL if a failure occurred.  There's nothing to catch the
751  * error return, though, so we use sys_mount_errors to log the
752  * failure.
753  */
754 static int nfsmount_child(struct nfsmount_info *mi)
755 {
756         unsigned int secs = 1;
757         time_t timeout;
758
759         timeout = nfs_parse_retry_option(mi->options,
760                                          NFS_DEF_BG_TIMEOUT_MINUTES);
761
762         for (;;) {
763                 if (sleep(secs))
764                         break;
765                 secs <<= 1;
766                 if (secs > 120)
767                         secs = 120;
768
769                 if (nfs_try_mount(mi))
770                         return EX_SUCCESS;
771
772                 if (nfs_is_permanent_error(errno))
773                         break;
774
775                 if (time(NULL) > timeout)
776                         break;
777
778                 sys_mount_errors(mi->hostname, errno, 1, 1);
779         };
780
781         sys_mount_errors(mi->hostname, errno, 1, 0);
782         return EX_FAIL;
783 }
784
785 /*
786  * Handle "background" NFS mount
787  *
788  * Returns a valid mount command exit code.
789  */
790 static int nfsmount_bg(struct nfsmount_info *mi)
791 {
792         if (!mi->child)
793                 return nfsmount_parent(mi);
794         else
795                 return nfsmount_child(mi);
796 }
797
798 /*
799  * Process mount options and try a mount system call.
800  *
801  * Returns a valid mount command exit code.
802  */
803 static const char *nfs_background_opttbl[] = {
804         "bg",
805         "fg",
806         NULL,
807 };
808
809 static int nfsmount_start(struct nfsmount_info *mi)
810 {
811         if (!nfs_validate_options(mi))
812                 return EX_FAIL;
813
814         if (po_rightmost(mi->options, nfs_background_opttbl) == 0)
815                 return nfsmount_bg(mi);
816         else
817                 return nfsmount_fg(mi);
818 }
819
820 /**
821  * nfsmount_string - Mount an NFS file system using C string options
822  * @spec: C string specifying remote share to mount ("hostname:path")
823  * @node: C string pathname of local mounted-on directory
824  * @type: C string that represents file system type ("nfs" or "nfs4")
825  * @flags: MS_ style mount flags
826  * @extra_opts: pointer to C string containing fs-specific mount options
827  *              (input and output argument)
828  * @fake: flag indicating whether to carry out the whole operation
829  * @child: one if this is a mount daemon (bg)
830  */
831 int nfsmount_string(const char *spec, const char *node, const char *type,
832                     int flags, char **extra_opts, int fake, int child)
833 {
834         struct nfsmount_info mi = {
835                 .spec           = spec,
836                 .node           = node,
837                 .type           = type,
838                 .extra_opts     = extra_opts,
839                 .flags          = flags,
840                 .fake           = fake,
841                 .child          = child,
842         };
843         int retval = EX_FAIL;
844
845         mi.options = po_split(*extra_opts);
846         if (mi.options) {
847                 retval = nfsmount_start(&mi);
848                 po_destroy(mi.options);
849         } else
850                 nfs_error(_("%s: internal option parsing error"), progname);
851
852         free(mi.hostname);
853         return retval;
854 }