mount.nfs: Assume v2/v3 if mount-related options are present
[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 static int nfs_set_version(struct nfsmount_info *mi)
282 {
283         if (!nfs_nfs_version(mi->options, &mi->version))
284                 return 0;
285
286         if (strncmp(mi->type, "nfs4", 4) == 0)
287                 mi->version = 4;
288         else {
289                 char *option = po_get(mi->options, "proto");
290                 if (option && strcmp(option, "rdma") == 0)
291                         mi->version = 3;
292         }
293
294         /*
295          * If we still don't know, check for version-specific
296          * mount options.
297          */
298         if (mi->version == 0) {
299                 if (po_contains(mi->options, "mounthost") ||
300                     po_contains(mi->options, "mountaddr") ||
301                     po_contains(mi->options, "mountvers") ||
302                     po_contains(mi->options, "mountproto"))
303                         mi->version = 3;
304         }
305
306         /*
307          * If enabled, see if the default version was
308          * set in the config file
309          */
310         nfs_default_version(mi);
311         
312         return 1;
313 }
314
315 /*
316  * Set up mandatory non-version specific NFS mount options.
317  *
318  * Returns 1 if successful; otherwise zero.
319  */
320 static int nfs_validate_options(struct nfsmount_info *mi)
321 {
322         struct sockaddr *sap = (struct sockaddr *)&mi->address;
323
324         if (!nfs_parse_devname(mi->spec, &mi->hostname, NULL))
325                 return 0;
326
327         mi->salen = sizeof(mi->address);
328         if (!nfs_name_to_address(mi->hostname, sap, &mi->salen))
329                 return 0;
330
331         if (!nfs_set_version(mi))
332                 return 0;
333
334         if (!nfs_append_sloppy_option(mi->options))
335                 return 0;
336
337         if (!nfs_append_addr_option(sap, mi->salen, mi->options))
338                 return 0;
339
340         return 1;
341 }
342
343 /*
344  * Get NFS/mnt server addresses from mount options
345  *
346  * Returns 1 and fills in @nfs_saddr, @nfs_salen, @mnt_saddr, and @mnt_salen
347  * if all goes well; otherwise zero.
348  */
349 static int nfs_extract_server_addresses(struct mount_options *options,
350                                         struct sockaddr *nfs_saddr,
351                                         socklen_t *nfs_salen,
352                                         struct sockaddr *mnt_saddr,
353                                         socklen_t *mnt_salen)
354 {
355         char *option;
356
357         option = po_get(options, "addr");
358         if (option == NULL)
359                 return 0;
360         if (!nfs_string_to_sockaddr(option, nfs_saddr, nfs_salen))
361                 return 0;
362
363         option = po_get(options, "mountaddr");
364         if (option == NULL) {
365                 memcpy(mnt_saddr, nfs_saddr, *nfs_salen);
366                 *mnt_salen = *nfs_salen;
367         } else if (!nfs_string_to_sockaddr(option, mnt_saddr, mnt_salen))
368                 return 0;
369
370         return 1;
371 }
372
373 static int nfs_construct_new_options(struct mount_options *options,
374                                      struct pmap *nfs_pmap,
375                                      struct pmap *mnt_pmap)
376 {
377         char new_option[64];
378
379         po_remove_all(options, "nfsprog");
380         po_remove_all(options, "mountprog");
381
382         po_remove_all(options, "v2");
383         po_remove_all(options, "v3");
384         po_remove_all(options, "vers");
385         po_remove_all(options, "nfsvers");
386         snprintf(new_option, sizeof(new_option) - 1,
387                  "vers=%lu", nfs_pmap->pm_vers);
388         if (po_append(options, new_option) == PO_FAILED)
389                 return 0;
390
391         po_remove_all(options, "proto");
392         po_remove_all(options, "udp");
393         po_remove_all(options, "tcp");
394         switch (nfs_pmap->pm_prot) {
395         case IPPROTO_TCP:
396                 snprintf(new_option, sizeof(new_option) - 1,
397                          "proto=tcp");
398                 if (po_append(options, new_option) == PO_FAILED)
399                         return 0;
400                 break;
401         case IPPROTO_UDP:
402                 snprintf(new_option, sizeof(new_option) - 1,
403                          "proto=udp");
404                 if (po_append(options, new_option) == PO_FAILED)
405                         return 0;
406                 break;
407         }
408
409         po_remove_all(options, "port");
410         if (nfs_pmap->pm_port != NFS_PORT) {
411                 snprintf(new_option, sizeof(new_option) - 1,
412                          "port=%lu", nfs_pmap->pm_port);
413                 if (po_append(options, new_option) == PO_FAILED)
414                         return 0;
415         }
416
417         po_remove_all(options, "mountvers");
418         snprintf(new_option, sizeof(new_option) - 1,
419                  "mountvers=%lu", mnt_pmap->pm_vers);
420         if (po_append(options, new_option) == PO_FAILED)
421                 return 0;
422
423         po_remove_all(options, "mountproto");
424         switch (mnt_pmap->pm_prot) {
425         case IPPROTO_TCP:
426                 snprintf(new_option, sizeof(new_option) - 1,
427                          "mountproto=tcp");
428                 if (po_append(options, new_option) == PO_FAILED)
429                         return 0;
430                 break;
431         case IPPROTO_UDP:
432                 snprintf(new_option, sizeof(new_option) - 1,
433                          "mountproto=udp");
434                 if (po_append(options, new_option) == PO_FAILED)
435                         return 0;
436                 break;
437         }
438
439         po_remove_all(options, "mountport");
440         snprintf(new_option, sizeof(new_option) - 1,
441                  "mountport=%lu", mnt_pmap->pm_port);
442         if (po_append(options, new_option) == PO_FAILED)
443                 return 0;
444
445         return 1;
446 }
447
448 /*
449  * Reconstruct the mount option string based on a portmapper probe
450  * of the server.  Returns one if the server's portmapper returned
451  * something we can use, otherwise zero.
452  *
453  * To handle version and transport protocol fallback properly, we
454  * need to parse some of the mount options in order to set up a
455  * portmap probe.  Mount options that nfs_rewrite_pmap_mount_options()
456  * doesn't recognize are left alone.
457  *
458  * Returns TRUE if rewriting was successful; otherwise
459  * FALSE is returned if some failure occurred.
460  */
461 static int
462 nfs_rewrite_pmap_mount_options(struct mount_options *options)
463 {
464         struct sockaddr_storage nfs_address;
465         struct sockaddr *nfs_saddr = (struct sockaddr *)&nfs_address;
466         socklen_t nfs_salen = sizeof(nfs_address);
467         struct pmap nfs_pmap;
468         struct sockaddr_storage mnt_address;
469         struct sockaddr *mnt_saddr = (struct sockaddr *)&mnt_address;
470         socklen_t mnt_salen = sizeof(mnt_address);
471         struct pmap mnt_pmap;
472         char *option;
473
474         /*
475          * Skip option negotiation for proto=rdma mounts.
476          */
477         option = po_get(options, "proto");
478         if (option && strcmp(option, "rdma") == 0)
479                 goto out;
480
481         /*
482          * Extract just the options needed to contact server.
483          * Bail now if any of these have bad values.
484          */
485         if (!nfs_extract_server_addresses(options, nfs_saddr, &nfs_salen,
486                                                 mnt_saddr, &mnt_salen)) {
487                 errno = EINVAL;
488                 return 0;
489         }
490         if (!nfs_options2pmap(options, &nfs_pmap, &mnt_pmap)) {
491                 errno = EINVAL;
492                 return 0;
493         }
494
495         /*
496          * The kernel NFS client doesn't support changing the RPC
497          * program number for these services, so force the value of
498          * these fields before probing the server's ports.
499          */
500         nfs_pmap.pm_prog = NFS_PROGRAM;
501         mnt_pmap.pm_prog = MOUNTPROG;
502
503         /*
504          * If the server's rpcbind service isn't available, we can't
505          * negotiate.  Bail now if we can't contact it.
506          */
507         if (!nfs_probe_bothports(mnt_saddr, mnt_salen, &mnt_pmap,
508                                  nfs_saddr, nfs_salen, &nfs_pmap)) {
509                 errno = ESPIPE;
510                 return 0;
511         }
512
513         if (!nfs_construct_new_options(options, &nfs_pmap, &mnt_pmap)) {
514                 errno = EINVAL;
515                 return 0;
516         }
517
518 out:
519         errno = 0;
520         return 1;
521 }
522
523 /*
524  * Do the mount(2) system call.
525  *
526  * Returns TRUE if successful, otherwise FALSE.
527  * "errno" is set to reflect the individual error.
528  */
529 static int nfs_sys_mount(struct nfsmount_info *mi, struct mount_options *opts)
530 {
531         char *options = NULL;
532         int result;
533
534         if (po_join(opts, &options) == PO_FAILED) {
535                 errno = EIO;
536                 return 0;
537         }
538
539         if (verbose)
540                 printf(_("%s: trying text-based options '%s'\n"),
541                         progname, options);
542
543         if (mi->fake)
544                 return 1;
545
546         result = mount(mi->spec, mi->node, mi->type,
547                         mi->flags & ~(MS_USER|MS_USERS), options);
548         if (verbose && result) {
549                 int save = errno;
550                 nfs_error(_("%s: mount(2): %s"), progname, strerror(save));
551                 errno = save;
552         }
553         return !result;
554 }
555
556 /*
557  * For "-t nfs vers=2" or "-t nfs vers=3" mounts.
558  */
559 static int nfs_try_mount_v3v2(struct nfsmount_info *mi)
560 {
561         struct mount_options *options = po_dup(mi->options);
562         int result = 0;
563
564         if (!options) {
565                 errno = ENOMEM;
566                 return result;
567         }
568
569         if (!nfs_fix_mounthost_option(options)) {
570                 errno = EINVAL;
571                 goto out_fail;
572         }
573         if (!mi->fake && !nfs_verify_lock_option(options)) {
574                 errno = EINVAL;
575                 goto out_fail;
576         }
577
578         /*
579          * Options we negotiate below may be stale by the time this
580          * file system is unmounted.  In order to force umount.nfs
581          * to renegotiate with the server, only write the user-
582          * specified options, and not negotiated options, to /etc/mtab.
583          */
584         if (po_join(options, mi->extra_opts) == PO_FAILED) {
585                 errno = ENOMEM;
586                 goto out_fail;
587         }
588
589         if (!nfs_rewrite_pmap_mount_options(options))
590                 goto out_fail;
591
592         result = nfs_sys_mount(mi, options);
593
594 out_fail:
595         po_destroy(options);
596         return result;
597 }
598
599 /*
600  * For "-t nfs -o vers=4" or "-t nfs4" mounts.
601  */
602 static int nfs_try_mount_v4(struct nfsmount_info *mi)
603 {
604         struct sockaddr *sap = (struct sockaddr *)&mi->address;
605         struct mount_options *options = po_dup(mi->options);
606         int result = 0;
607
608         if (!options) {
609                 errno = ENOMEM;
610                 return result;
611         }
612
613         if (mi->version == 0) {
614                 if (po_contains(options, "mounthost") ||
615                         po_contains(options, "mountaddr") ||
616                         po_contains(options, "mountvers") ||
617                         po_contains(options, "mountproto")) {
618                 /*
619                  * Since these mountd options are set assume version 3
620                  * is wanted so error out with EPROTONOSUPPORT so the
621                  * protocol negation starts with v3.
622                  */
623                         errno = EPROTONOSUPPORT;
624                         goto out_fail;
625                 }
626                 if (po_append(options, "vers=4") == PO_FAILED) {
627                         errno = EINVAL;
628                         goto out_fail;
629                 }
630         }
631
632         if (!nfs_append_clientaddr_option(sap, mi->salen, options)) {
633                 errno = EINVAL;
634                 goto out_fail;
635         }
636
637         /*
638          * Update option string to be recorded in /etc/mtab.
639          */
640         if (po_join(options, mi->extra_opts) == PO_FAILED) {
641                 errno = ENOMEM;
642                 goto out_fail;
643         }
644
645         result = nfs_sys_mount(mi, options);
646
647 out_fail:
648         po_destroy(options);
649         return result;
650 }
651
652 /*
653  * This is a single pass through the fg/bg loop.
654  *
655  * Returns TRUE if successful, otherwise FALSE.
656  * "errno" is set to reflect the individual error.
657  */
658 static int nfs_try_mount(struct nfsmount_info *mi)
659 {
660         int result = 0;
661
662         switch (mi->version) {
663         case 0:
664                 if (linux_version_code() > MAKE_VERSION(2, 6, 31)) {
665                         errno = 0;
666                         result = nfs_try_mount_v4(mi);
667                         if (errno != EPROTONOSUPPORT) {
668                                 /* 
669                                  * To deal with legacy Linux servers that don't
670                                  * automatically export a pseudo root, retry
671                                  * ENOENT errors using version 3
672                                  */
673                                 if (errno != ENOENT)
674                                         break;
675                         }
676                 }
677         case 2:
678         case 3:
679                 result = nfs_try_mount_v3v2(mi);
680                 break;
681         case 4:
682                 result = nfs_try_mount_v4(mi);
683                 break;
684         default:
685                 errno = EIO;
686         }
687
688         return result;
689 }
690
691 /*
692  * Distinguish between permanent and temporary errors.
693  *
694  * Basically, we retry if communication with the server has
695  * failed so far, but fail immediately if there is a local
696  * error (like a bad mount option).
697  *
698  * ESTALE is also a temporary error because some servers
699  * return ESTALE when a share is temporarily offline.
700  *
701  * Returns 1 if we should fail immediately, or 0 if we
702  * should retry.
703  */
704 static int nfs_is_permanent_error(int error)
705 {
706         switch (error) {
707         case ESTALE:
708         case ETIMEDOUT:
709         case ECONNREFUSED:
710                 return 0;       /* temporary */
711         default:
712                 return 1;       /* permanent */
713         }
714 }
715
716 /*
717  * Handle "foreground" NFS mounts.
718  *
719  * Retry the mount request for as long as the 'retry=' option says.
720  *
721  * Returns a valid mount command exit code.
722  */
723 static int nfsmount_fg(struct nfsmount_info *mi)
724 {
725         unsigned int secs = 1;
726         time_t timeout;
727
728         timeout = nfs_parse_retry_option(mi->options,
729                                          NFS_DEF_FG_TIMEOUT_MINUTES);
730         if (verbose)
731                 printf(_("%s: timeout set for %s"),
732                         progname, ctime(&timeout));
733
734         for (;;) {
735                 if (nfs_try_mount(mi))
736                         return EX_SUCCESS;
737
738                 if (nfs_is_permanent_error(errno))
739                         break;
740
741                 if (time(NULL) > timeout) {
742                         errno = ETIMEDOUT;
743                         break;
744                 }
745
746                 if (errno != ETIMEDOUT) {
747                         if (sleep(secs))
748                                 break;
749                         secs <<= 1;
750                         if (secs > 10)
751                                 secs = 10;
752                 }
753         };
754
755         mount_error(mi->spec, mi->node, errno);
756         return EX_FAIL;
757 }
758
759 /*
760  * Handle "background" NFS mount [first try]
761  *
762  * Returns a valid mount command exit code.
763  *
764  * EX_BG should cause the caller to fork and invoke nfsmount_child.
765  */
766 static int nfsmount_parent(struct nfsmount_info *mi)
767 {
768         if (nfs_try_mount(mi))
769                 return EX_SUCCESS;
770
771         if (nfs_is_permanent_error(errno)) {
772                 mount_error(mi->spec, mi->node, errno);
773                 return EX_FAIL;
774         }
775
776         sys_mount_errors(mi->hostname, errno, 1, 1);
777         return EX_BG;
778 }
779
780 /*
781  * Handle "background" NFS mount [retry daemon]
782  *
783  * Returns a valid mount command exit code: EX_SUCCESS if successful,
784  * EX_FAIL if a failure occurred.  There's nothing to catch the
785  * error return, though, so we use sys_mount_errors to log the
786  * failure.
787  */
788 static int nfsmount_child(struct nfsmount_info *mi)
789 {
790         unsigned int secs = 1;
791         time_t timeout;
792
793         timeout = nfs_parse_retry_option(mi->options,
794                                          NFS_DEF_BG_TIMEOUT_MINUTES);
795
796         for (;;) {
797                 if (sleep(secs))
798                         break;
799                 secs <<= 1;
800                 if (secs > 120)
801                         secs = 120;
802
803                 if (nfs_try_mount(mi))
804                         return EX_SUCCESS;
805
806                 if (nfs_is_permanent_error(errno))
807                         break;
808
809                 if (time(NULL) > timeout)
810                         break;
811
812                 sys_mount_errors(mi->hostname, errno, 1, 1);
813         };
814
815         sys_mount_errors(mi->hostname, errno, 1, 0);
816         return EX_FAIL;
817 }
818
819 /*
820  * Handle "background" NFS mount
821  *
822  * Returns a valid mount command exit code.
823  */
824 static int nfsmount_bg(struct nfsmount_info *mi)
825 {
826         if (!mi->child)
827                 return nfsmount_parent(mi);
828         else
829                 return nfsmount_child(mi);
830 }
831
832 /*
833  * Process mount options and try a mount system call.
834  *
835  * Returns a valid mount command exit code.
836  */
837 static const char *nfs_background_opttbl[] = {
838         "bg",
839         "fg",
840         NULL,
841 };
842
843 static int nfsmount_start(struct nfsmount_info *mi)
844 {
845         if (!nfs_validate_options(mi))
846                 return EX_FAIL;
847
848         if (po_rightmost(mi->options, nfs_background_opttbl) == 0)
849                 return nfsmount_bg(mi);
850         else
851                 return nfsmount_fg(mi);
852 }
853
854 /**
855  * nfsmount_string - Mount an NFS file system using C string options
856  * @spec: C string specifying remote share to mount ("hostname:path")
857  * @node: C string pathname of local mounted-on directory
858  * @type: C string that represents file system type ("nfs" or "nfs4")
859  * @flags: MS_ style mount flags
860  * @extra_opts: pointer to C string containing fs-specific mount options
861  *              (input and output argument)
862  * @fake: flag indicating whether to carry out the whole operation
863  * @child: one if this is a mount daemon (bg)
864  */
865 int nfsmount_string(const char *spec, const char *node, const char *type,
866                     int flags, char **extra_opts, int fake, int child)
867 {
868         struct nfsmount_info mi = {
869                 .spec           = spec,
870                 .node           = node,
871                 .type           = type,
872                 .extra_opts     = extra_opts,
873                 .flags          = flags,
874                 .fake           = fake,
875                 .child          = child,
876         };
877         int retval = EX_FAIL;
878
879         mi.options = po_split(*extra_opts);
880         if (mi.options) {
881                 retval = nfsmount_start(&mi);
882                 po_destroy(mi.options);
883         } else
884                 nfs_error(_("%s: internal option parsing error"), progname);
885
886         free(mi.hostname);
887         return retval;
888 }