Change the append_addr_option() function to support sending either IPv4
[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 <ctype.h>
29 #include <unistd.h>
30 #include <stdio.h>
31 #include <string.h>
32 #include <stdlib.h>
33 #include <errno.h>
34 #include <netdb.h>
35 #include <time.h>
36
37 #include <sys/socket.h>
38 #include <sys/mount.h>
39 #include <netinet/in.h>
40 #include <arpa/inet.h>
41
42 #include "xcommon.h"
43 #include "mount.h"
44 #include "nls.h"
45 #include "nfs_mount.h"
46 #include "mount_constants.h"
47 #include "stropts.h"
48 #include "error.h"
49 #include "network.h"
50 #include "parse_opt.h"
51 #include "version.h"
52
53 #ifdef HAVE_RPCSVC_NFS_PROT_H
54 #include <rpcsvc/nfs_prot.h>
55 #else
56 #include <linux/nfs.h>
57 #define nfsstat nfs_stat
58 #endif
59
60 #ifndef NFS_PORT
61 #define NFS_PORT 2049
62 #endif
63
64 #ifndef NFS_MAXHOSTNAME
65 #define NFS_MAXHOSTNAME         (255)
66 #endif
67
68 #ifndef NFS_MAXPATHNAME
69 #define NFS_MAXPATHNAME         (1024)
70 #endif
71
72 #ifndef NFS_DEF_FG_TIMEOUT_MINUTES
73 #define NFS_DEF_FG_TIMEOUT_MINUTES      (2u)
74 #endif
75
76 #ifndef NFS_DEF_BG_TIMEOUT_MINUTES
77 #define NFS_DEF_BG_TIMEOUT_MINUTES      (10000u)
78 #endif
79
80 extern int nfs_mount_data_version;
81 extern char *progname;
82 extern int verbose;
83 extern int sloppy;
84
85 struct nfsmount_info {
86         const char              *spec,          /* server:/path */
87                                 *node,          /* mounted-on dir */
88                                 *type;          /* "nfs" or "nfs4" */
89         char                    *hostname;      /* server's hostname */
90
91         struct mount_options    *options;       /* parsed mount options */
92         char                    **extra_opts;   /* string for /etc/mtab */
93
94         int                     flags,          /* MS_ flags */
95                                 fake,           /* actually do the mount? */
96                                 child;          /* forked bg child? */
97 };
98
99 static int nfs_parse_devname(struct nfsmount_info *mi)
100 {
101         int ret = 0;
102         char *dev, *pathname, *s;
103
104         dev = xstrdup(mi->spec);
105
106         if (!(pathname = strchr(dev, ':'))) {
107                 nfs_error(_("%s: remote share not in 'host:dir' format"),
108                                 progname);
109                 goto out;
110         }
111         *pathname = '\0';
112         pathname++;
113
114         /*
115          * We don't need a copy of the pathname, but let's
116          * sanity check it anyway.
117          */
118         if (strlen(pathname) > NFS_MAXPATHNAME) {
119                 nfs_error(_("%s: export pathname is too long"),
120                                 progname);
121                 goto out;
122         }
123
124         /*
125          * Ignore all but first hostname in replicated mounts
126          * until they can be fully supported. (mack@sgi.com)
127          */
128         if ((s = strchr(dev, ','))) {
129                 *s = '\0';
130                 nfs_error(_("%s: warning: multiple hostnames not supported"),
131                                 progname);
132                 nfs_error(_("%s: ignoring hostnames that follow the first one"),
133                                 progname);
134         }
135         mi->hostname = xstrdup(dev);
136         if (strlen(mi->hostname) > NFS_MAXHOSTNAME) {
137                 nfs_error(_("%s: server hostname is too long"),
138                                 progname);
139                 free(mi->hostname);
140                 mi->hostname = NULL;
141                 goto out;
142         }
143
144         ret = 1;
145
146 out:
147         free(dev);
148         return ret;
149 }
150
151 static int fill_ipv4_sockaddr(const char *hostname, struct sockaddr_in *addr)
152 {
153         struct hostent *hp;
154         addr->sin_family = AF_INET;
155
156         if (inet_aton(hostname, &addr->sin_addr))
157                 return 1;
158         if ((hp = gethostbyname(hostname)) == NULL) {
159                 nfs_error(_("%s: can't get address for %s\n"),
160                                 progname, hostname);
161                 return 0;
162         }
163         if (hp->h_length > sizeof(struct in_addr)) {
164                 nfs_error(_("%s: got bad hp->h_length"), progname);
165                 hp->h_length = sizeof(struct in_addr);
166         }
167         memcpy(&addr->sin_addr, hp->h_addr, hp->h_length);
168         return 1;
169 }
170
171 /*
172  * Obtain a retry timeout value based on the value of the "retry=" option.
173  *
174  * Returns a time_t timeout timestamp, in seconds.
175  */
176 static time_t nfs_parse_retry_option(struct mount_options *options,
177                                      unsigned int timeout_minutes)
178 {
179         char *retry_option, *endptr;
180
181         retry_option = po_get(options, "retry");
182         if (retry_option) {
183                 long tmp;
184
185                 errno = 0;
186                 tmp = strtol(retry_option, &endptr, 10);
187                 if (errno == 0 && endptr != retry_option && tmp >= 0)
188                         timeout_minutes = tmp;
189                 else if (verbose)
190                         nfs_error(_("%s: invalid retry timeout was specified; "
191                                         "using default timeout"), progname);
192         }
193
194         return time(NULL) + (time_t)(timeout_minutes * 60);
195 }
196
197 /*
198  * Convert the passed-in sockaddr-style address to presentation
199  * format, then append an option of the form "keyword=address".
200  *
201  * Returns 1 if the option was appended successfully; otherwise zero.
202  */
203 static int nfs_append_generic_address_option(const struct sockaddr *sap,
204                                              const socklen_t salen,
205                                              const char *keyword,
206                                              struct mount_options *options)
207 {
208         char address[NI_MAXHOST];
209         char new_option[512];
210
211         if (!nfs_present_sockaddr(sap, salen, address, sizeof(address)))
212                 goto out_err;
213
214         if (snprintf(new_option, sizeof(new_option), "%s=%s",
215                                         keyword, address) >= sizeof(new_option))
216                 goto out_err;
217
218         if (po_append(options, new_option) != PO_SUCCEEDED)
219                 goto out_err;
220
221         return 1;
222
223 out_err:
224         nfs_error(_("%s: failed to construct %s option"), progname, keyword);
225         return 0;
226 }
227
228 /*
229  * Append the 'addr=' option to the options string to pass a resolved
230  * server address to the kernel.  After a successful mount, this address
231  * is also added to /etc/mtab for use when unmounting.
232  *
233  * If 'addr=' is already present, we strip it out.  This prevents users
234  * from setting a bogus 'addr=' option themselves, and also allows bg
235  * retries to recompute the server's address, in case it has changed.
236  *
237  * Returns 1 if 'addr=' option appended successfully;
238  * otherwise zero.
239  */
240 static int nfs_append_addr_option(const struct sockaddr *sap,
241                                   socklen_t salen,
242                                   struct mount_options *options)
243 {
244         po_remove_all(options, "addr");
245         return nfs_append_generic_address_option(sap, salen, "addr", options);
246 }
247
248 /*
249  * Called to discover our address and append an appropriate 'clientaddr='
250  * option to the options string.
251  *
252  * Returns 1 if 'clientaddr=' option created successfully or if
253  * 'clientaddr=' option is already present; otherwise zero.
254  */
255 static int append_clientaddr_option(struct sockaddr_in *saddr,
256                                     struct mount_options *options)
257 {
258         struct sockaddr_in my_addr;
259         char new_option[32];
260
261         if (po_contains(options, "clientaddr") == PO_SUCCEEDED)
262                 return 1;
263
264         if (!get_client_address(saddr, &my_addr))
265                 return 0;
266
267         snprintf(new_option, sizeof(new_option) - 1,
268                         "clientaddr=%s", inet_ntoa(my_addr.sin_addr));
269
270         if (po_append(options, new_option) == PO_SUCCEEDED)
271                 return 1;
272         return 0;
273 }
274
275 /*
276  * Resolve the 'mounthost=' hostname and append a new option using
277  * the resulting IPv4 address.
278  */
279 static int fix_mounthost_option(struct mount_options *options)
280 {
281         struct sockaddr_in maddr;
282         char *mounthost, new_option[32];
283
284         mounthost = po_get(options, "mounthost");
285         if (!mounthost)
286                 return 1;
287
288         if (!fill_ipv4_sockaddr(mounthost, &maddr))
289                 return 0;
290
291         snprintf(new_option, sizeof(new_option) - 1,
292                         "mountaddr=%s", inet_ntoa(maddr.sin_addr));
293
294         if (po_append(options, new_option) == PO_SUCCEEDED)
295                 return 1;
296         return 0;
297 }
298
299 /*
300  * Returns zero if the "lock" option is in effect, but statd
301  * can't be started.  Otherwise, returns 1.
302  */
303 static int verify_lock_option(struct mount_options *options)
304 {
305         if (po_rightmost(options, "nolock", "lock") == PO_KEY1_RIGHTMOST)
306                 return 1;
307
308         if (!start_statd()) {
309                 nfs_error(_("%s: rpc.statd is not running but is "
310                             "required for remote locking."), progname);
311                 nfs_error(_("%s: Either use '-o nolock' to keep "
312                             "locks local, or start statd."), progname);
313                 return 0;
314         }
315
316         return 1;
317 }
318
319 static int nfs_append_sloppy_option(struct mount_options *options)
320 {
321         if (!sloppy || linux_version_code() < MAKE_VERSION(2, 6, 27))
322                 return 1;
323
324         if (po_append(options, "sloppy") == PO_FAILED)
325                 return 0;
326         return 1;
327 }
328
329 /*
330  * Set up mandatory NFS mount options.
331  *
332  * Returns 1 if successful; otherwise zero.
333  */
334 static int nfs_validate_options(struct nfsmount_info *mi)
335 {
336         struct sockaddr_in saddr;
337
338         if (!fill_ipv4_sockaddr(mi->hostname, &saddr))
339                 return 0;
340
341         if (strncmp(mi->type, "nfs4", 4) == 0) {
342                 if (!append_clientaddr_option(&saddr, mi->options))
343                         return 0;
344         } else {
345                 if (!fix_mounthost_option(mi->options))
346                         return 0;
347                 if (!mi->fake && !verify_lock_option(mi->options))
348                         return 0;
349         }
350
351         if (!nfs_append_sloppy_option(mi->options))
352                 return 0;
353
354         return nfs_append_addr_option((struct sockaddr *)&saddr,
355                                         sizeof(saddr), mi->options);
356 }
357
358 /*
359  * Distinguish between permanent and temporary errors.
360  *
361  * Returns 0 if the passed-in error is temporary, thus the
362  * mount system call should be retried; returns one if the
363  * passed-in error is permanent, thus the mount system call
364  * should not be retried.
365  */
366 static int is_permanent_error(int error)
367 {
368         switch (error) {
369         case ESTALE:
370         case ETIMEDOUT:
371         case ECONNREFUSED:
372                 return 0;       /* temporary */
373         default:
374                 return 1;       /* permanent */
375         }
376 }
377
378 /*
379  * Reconstruct the mount option string based on a portmapper probe
380  * of the server.  Returns one if the server's portmapper returned
381  * something we can use, otherwise zero.
382  *
383  * To handle version and transport protocol fallback properly, we
384  * need to parse some of the mount options in order to set up a
385  * portmap probe.  Mount options that rewrite_mount_options()
386  * doesn't recognize are left alone.
387  *
388  * Returns a new group of mount options if successful; otherwise
389  * NULL is returned if some failure occurred.
390  */
391 static struct mount_options *rewrite_mount_options(char *str)
392 {
393         struct mount_options *options;
394         char *option, new_option[64];
395         clnt_addr_t mnt_server = { };
396         clnt_addr_t nfs_server = { };
397         int p;
398
399         options = po_split(str);
400         if (!options) {
401                 errno = EFAULT;
402                 return NULL;
403         }
404
405         errno = EINVAL;
406         option = po_get(options, "addr");
407         if (option) {
408                 nfs_server.saddr.sin_family = AF_INET;
409                 if (!inet_aton((const char *)option, &nfs_server.saddr.sin_addr))
410                         goto err;
411         } else
412                 goto err;
413
414         option = po_get(options, "mountaddr");
415         if (option) {
416                 mnt_server.saddr.sin_family = AF_INET;
417                 if (!inet_aton((const char *)option, &mnt_server.saddr.sin_addr))
418                         goto err;
419         } else
420                 memcpy(&mnt_server.saddr, &nfs_server.saddr,
421                                 sizeof(mnt_server.saddr));
422
423         option = po_get(options, "mountport");
424         if (option)
425                 mnt_server.pmap.pm_port = atoi(option);
426         mnt_server.pmap.pm_prog = MOUNTPROG;
427         option = po_get(options, "mountvers");
428         if (option)
429                 mnt_server.pmap.pm_vers = atoi(option);
430
431         option = po_get(options, "port");
432         if (option) {
433                 nfs_server.pmap.pm_port = atoi(option);
434                 po_remove_all(options, "port");
435         }
436         nfs_server.pmap.pm_prog = NFS_PROGRAM;
437
438         option = po_get(options, "nfsvers");
439         if (option) {
440                 nfs_server.pmap.pm_vers = atoi(option);
441                 po_remove_all(options, "nfsvers");
442         }
443         option = po_get(options, "vers");
444         if (option) {
445                 nfs_server.pmap.pm_vers = atoi(option);
446                 po_remove_all(options, "vers");
447         }
448         option = po_get(options, "proto");
449         if (option) {
450                 if (strcmp(option, "tcp") == 0) {
451                         nfs_server.pmap.pm_prot = IPPROTO_TCP;
452                         po_remove_all(options, "proto");
453                 }
454                 if (strcmp(option, "udp") == 0) {
455                         nfs_server.pmap.pm_prot = IPPROTO_UDP;
456                         po_remove_all(options, "proto");
457                 }
458         }
459         p = po_rightmost(options, "tcp", "udp");
460         switch (p) {
461         case PO_KEY2_RIGHTMOST:
462                 nfs_server.pmap.pm_prot = IPPROTO_UDP;
463                 break;
464         case PO_KEY1_RIGHTMOST:
465                 nfs_server.pmap.pm_prot = IPPROTO_TCP;
466                 break;
467         }
468         po_remove_all(options, "tcp");
469         po_remove_all(options, "udp");
470
471         if (!probe_bothports(&mnt_server, &nfs_server)) {
472                 errno = ESPIPE;
473                 goto err;
474         }
475
476         snprintf(new_option, sizeof(new_option) - 1,
477                  "nfsvers=%lu", nfs_server.pmap.pm_vers);
478         if (po_append(options, new_option) == PO_FAILED)
479                 goto err;
480
481         if (nfs_server.pmap.pm_prot == IPPROTO_TCP)
482                 snprintf(new_option, sizeof(new_option) - 1,
483                          "proto=tcp");
484         else
485                 snprintf(new_option, sizeof(new_option) - 1,
486                          "proto=udp");
487         if (po_append(options, new_option) == PO_FAILED)
488                 goto err;
489
490         if (nfs_server.pmap.pm_port != NFS_PORT) {
491                 snprintf(new_option, sizeof(new_option) - 1,
492                          "port=%lu", nfs_server.pmap.pm_port);
493                 if (po_append(options, new_option) == PO_FAILED)
494                         goto err;
495
496         }
497
498         errno = 0;
499         return options;
500
501 err:
502         po_destroy(options);
503         return NULL;
504 }
505
506 /*
507  * Do the mount(2) system call.
508  *
509  * Returns 1 if successful, otherwise zero.
510  * "errno" is set to reflect the individual error.
511  */
512 static int nfs_sys_mount(const struct nfsmount_info *mi, const char *type,
513                          const char *options)
514 {
515         int result;
516
517         result = mount(mi->spec, mi->node, type,
518                                 mi->flags & ~(MS_USER|MS_USERS), options);
519         if (verbose && result) {
520                 int save = errno;
521                 nfs_error(_("%s: mount(2): %s"), progname, strerror(save));
522                 errno = save;
523         }
524         return !result;
525 }
526
527 /*
528  * Retry an NFS mount that failed because the requested service isn't
529  * available on the server.
530  *
531  * Returns 1 if successful.  Otherwise, returns zero.
532  * "errno" is set to reflect the individual error.
533  *
534  * Side effect: If the retry is successful, both 'options' and
535  * 'extra_opts' are updated to reflect the mount options that worked.
536  * If the retry fails, 'options' and 'extra_opts' are left unchanged.
537  */
538 static int nfs_retry_nfs23mount(struct nfsmount_info *mi)
539 {
540         struct mount_options *retry_options;
541         char *retry_str = NULL;
542         char **extra_opts = mi->extra_opts;
543
544         retry_options = rewrite_mount_options(*extra_opts);
545         if (!retry_options)
546                 return 0;
547
548         if (po_join(retry_options, &retry_str) == PO_FAILED) {
549                 po_destroy(retry_options);
550                 errno = EIO;
551                 return 0;
552         }
553
554         if (verbose)
555                 printf(_("%s: text-based options (retry): '%s'\n"),
556                         progname, retry_str);
557
558         if (!nfs_sys_mount(mi, "nfs", retry_str)) {
559                 po_destroy(retry_options);
560                 free(retry_str);
561                 return 0;
562         }
563
564         free(*extra_opts);
565         *extra_opts = retry_str;
566         po_replace(mi->options, retry_options);
567         return 1;
568 }
569
570 /*
571  * Attempt an NFSv2/3 mount via a mount(2) system call.  If the kernel
572  * claims the requested service isn't supported on the server, probe
573  * the server to see what's supported, rewrite the mount options,
574  * and retry the request.
575  *
576  * Returns 1 if successful.  Otherwise, returns zero.
577  * "errno" is set to reflect the individual error.
578  *
579  * Side effect: If the retry is successful, both 'options' and
580  * 'extra_opts' are updated to reflect the mount options that worked.
581  * If the retry fails, 'options' and 'extra_opts' are left unchanged.
582  */
583 static int nfs_try_nfs23mount(struct nfsmount_info *mi)
584 {
585         char **extra_opts = mi->extra_opts;
586
587         if (po_join(mi->options, extra_opts) == PO_FAILED) {
588                 errno = EIO;
589                 return 0;
590         }
591
592         if (verbose)
593                 printf(_("%s: text-based options: '%s'\n"),
594                         progname, *extra_opts);
595
596         if (mi->fake)
597                 return 1;
598
599         if (nfs_sys_mount(mi, "nfs", *extra_opts))
600                 return 1;
601
602         /*
603          * The kernel returns EOPNOTSUPP if the RPC bind failed,
604          * and EPROTONOSUPPORT if the version isn't supported.
605          */
606         if (errno != EOPNOTSUPP && errno != EPROTONOSUPPORT)
607                 return 0;
608
609         return nfs_retry_nfs23mount(mi);
610 }
611
612 /*
613  * Attempt an NFS v4 mount via a mount(2) system call.
614  *
615  * Returns 1 if successful.  Otherwise, returns zero.
616  * "errno" is set to reflect the individual error.
617  */
618 static int nfs_try_nfs4mount(struct nfsmount_info *mi)
619 {
620         char **extra_opts = mi->extra_opts;
621
622         if (po_join(mi->options, extra_opts) == PO_FAILED) {
623                 errno = EIO;
624                 return 0;
625         }
626
627         if (verbose)
628                 printf(_("%s: text-based options: '%s'\n"),
629                         progname, *extra_opts);
630
631         if (mi->fake)
632                 return 1;
633
634         return nfs_sys_mount(mi, "nfs4", *extra_opts);
635 }
636
637 /*
638  * Perform either an NFSv2/3 mount, or an NFSv4 mount system call.
639  *
640  * Returns 1 if successful.  Otherwise, returns zero.
641  * "errno" is set to reflect the individual error.
642  */
643 static int nfs_try_mount(struct nfsmount_info *mi)
644 {
645         if (strncmp(mi->type, "nfs4", 4) == 0)
646                 return nfs_try_nfs4mount(mi);
647         else
648                 return nfs_try_nfs23mount(mi);
649 }
650
651 /*
652  * Handle "foreground" NFS mounts.
653  *
654  * Retry the mount request for as long as the 'retry=' option says.
655  *
656  * Returns a valid mount command exit code.
657  */
658 static int nfsmount_fg(struct nfsmount_info *mi)
659 {
660         unsigned int secs = 1;
661         time_t timeout;
662
663         timeout = nfs_parse_retry_option(mi->options,
664                                          NFS_DEF_FG_TIMEOUT_MINUTES);
665         if (verbose)
666                 printf(_("%s: timeout set for %s"),
667                         progname, ctime(&timeout));
668
669         for (;;) {
670                 if (nfs_try_mount(mi))
671                         return EX_SUCCESS;
672
673                 if (is_permanent_error(errno))
674                         break;
675
676                 if (time(NULL) > timeout) {
677                         errno = ETIMEDOUT;
678                         break;
679                 }
680
681                 if (errno != ETIMEDOUT) {
682                         if (sleep(secs))
683                                 break;
684                         secs <<= 1;
685                         if (secs > 10)
686                                 secs = 10;
687                 }
688         };
689
690         mount_error(mi->spec, mi->node, errno);
691         return EX_FAIL;
692 }
693
694 /*
695  * Handle "background" NFS mount [first try]
696  *
697  * Returns a valid mount command exit code.
698  *
699  * EX_BG should cause the caller to fork and invoke nfsmount_child.
700  */
701 static int nfsmount_parent(struct nfsmount_info *mi)
702 {
703         if (nfs_try_mount(mi))
704                 return EX_SUCCESS;
705
706         if (is_permanent_error(errno)) {
707                 mount_error(mi->spec, mi->node, errno);
708                 return EX_FAIL;
709         }
710
711         sys_mount_errors(mi->hostname, errno, 1, 1);
712         return EX_BG;
713 }
714
715 /*
716  * Handle "background" NFS mount [retry daemon]
717  *
718  * Returns a valid mount command exit code: EX_SUCCESS if successful,
719  * EX_FAIL if a failure occurred.  There's nothing to catch the
720  * error return, though, so we use sys_mount_errors to log the
721  * failure.
722  */
723 static int nfsmount_child(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_BG_TIMEOUT_MINUTES);
730
731         for (;;) {
732                 if (sleep(secs))
733                         break;
734                 secs <<= 1;
735                 if (secs > 120)
736                         secs = 120;
737
738                 if (nfs_try_mount(mi))
739                         return EX_SUCCESS;
740
741                 if (is_permanent_error(errno))
742                         break;
743
744                 if (time(NULL) > timeout)
745                         break;
746
747                 sys_mount_errors(mi->hostname, errno, 1, 1);
748         };
749
750         sys_mount_errors(mi->hostname, errno, 1, 0);
751         return EX_FAIL;
752 }
753
754 /*
755  * Handle "background" NFS mount
756  *
757  * Returns a valid mount command exit code.
758  */
759 static int nfsmount_bg(struct nfsmount_info *mi)
760 {
761         if (!mi->child)
762                 return nfsmount_parent(mi);
763         else
764                 return nfsmount_child(mi);
765 }
766
767 /*
768  * Process mount options and try a mount system call.
769  *
770  * Returns a valid mount command exit code.
771  */
772 static int nfsmount_start(struct nfsmount_info *mi)
773 {
774         if (!nfs_validate_options(mi))
775                 return EX_FAIL;
776
777         if (po_rightmost(mi->options, "bg", "fg") == PO_KEY1_RIGHTMOST)
778                 return nfsmount_bg(mi);
779         else
780                 return nfsmount_fg(mi);
781 }
782
783 /**
784  * nfsmount_string - Mount an NFS file system using C string options
785  * @spec: C string specifying remote share to mount ("hostname:path")
786  * @node: C string pathname of local mounted-on directory
787  * @type: C string that represents file system type ("nfs" or "nfs4")
788  * @flags: MS_ style mount flags
789  * @extra_opts: pointer to C string containing fs-specific mount options
790  *              (input and output argument)
791  * @fake: flag indicating whether to carry out the whole operation
792  * @child: one if this is a mount daemon (bg)
793  */
794 int nfsmount_string(const char *spec, const char *node, const char *type,
795                     int flags, char **extra_opts, int fake, int child)
796 {
797         struct nfsmount_info mi = {
798                 .spec           = spec,
799                 .node           = node,
800                 .type           = type,
801                 .extra_opts     = extra_opts,
802                 .flags          = flags,
803                 .fake           = fake,
804                 .child          = child,
805         };
806         int retval = EX_FAIL;
807
808         if (!nfs_parse_devname(&mi))
809                 return retval;
810
811         mi.options = po_split(*extra_opts);
812         if (mi.options) {
813                 retval = nfsmount_start(&mi);
814                 po_destroy(mi.options);
815         } else
816                 nfs_error(_("%s: internal option parsing error"), progname);
817
818         free(mi.hostname);
819         return retval;
820 }