Change the append_clientaddr_option() function to support sending either
[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 nfs_append_clientaddr_option(const struct sockaddr *sap,
256                                         socklen_t salen,
257                                         struct mount_options *options)
258 {
259         struct sockaddr_storage dummy;
260         struct sockaddr *my_addr = (struct sockaddr *)&dummy;
261         socklen_t my_len = sizeof(dummy);
262
263         if (po_contains(options, "clientaddr") == PO_FOUND)
264                 return 1;
265
266         nfs_callback_address(sap, salen, my_addr, &my_len);
267
268         return nfs_append_generic_address_option(my_addr, my_len,
269                                                         "clientaddr", options);
270 }
271
272 /*
273  * Resolve the 'mounthost=' hostname and append a new option using
274  * the resulting IPv4 address.
275  */
276 static int fix_mounthost_option(struct mount_options *options)
277 {
278         struct sockaddr_in maddr;
279         char *mounthost, new_option[32];
280
281         mounthost = po_get(options, "mounthost");
282         if (!mounthost)
283                 return 1;
284
285         if (!fill_ipv4_sockaddr(mounthost, &maddr))
286                 return 0;
287
288         snprintf(new_option, sizeof(new_option) - 1,
289                         "mountaddr=%s", inet_ntoa(maddr.sin_addr));
290
291         if (po_append(options, new_option) == PO_SUCCEEDED)
292                 return 1;
293         return 0;
294 }
295
296 /*
297  * Returns zero if the "lock" option is in effect, but statd
298  * can't be started.  Otherwise, returns 1.
299  */
300 static int verify_lock_option(struct mount_options *options)
301 {
302         if (po_rightmost(options, "nolock", "lock") == PO_KEY1_RIGHTMOST)
303                 return 1;
304
305         if (!start_statd()) {
306                 nfs_error(_("%s: rpc.statd is not running but is "
307                             "required for remote locking."), progname);
308                 nfs_error(_("%s: Either use '-o nolock' to keep "
309                             "locks local, or start statd."), progname);
310                 return 0;
311         }
312
313         return 1;
314 }
315
316 static int nfs_append_sloppy_option(struct mount_options *options)
317 {
318         if (!sloppy || linux_version_code() < MAKE_VERSION(2, 6, 27))
319                 return 1;
320
321         if (po_append(options, "sloppy") == PO_FAILED)
322                 return 0;
323         return 1;
324 }
325
326 /*
327  * Set up mandatory NFS mount options.
328  *
329  * Returns 1 if successful; otherwise zero.
330  */
331 static int nfs_validate_options(struct nfsmount_info *mi)
332 {
333         struct sockaddr_in saddr;
334
335         if (!fill_ipv4_sockaddr(mi->hostname, &saddr))
336                 return 0;
337
338         if (strncmp(mi->type, "nfs4", 4) == 0) {
339                 if (!nfs_append_clientaddr_option((struct sockaddr *)&saddr,
340                                                   sizeof(saddr), mi->options))
341                         return 0;
342         } else {
343                 if (!fix_mounthost_option(mi->options))
344                         return 0;
345                 if (!mi->fake && !verify_lock_option(mi->options))
346                         return 0;
347         }
348
349         if (!nfs_append_sloppy_option(mi->options))
350                 return 0;
351
352         return nfs_append_addr_option((struct sockaddr *)&saddr,
353                                         sizeof(saddr), mi->options);
354 }
355
356 /*
357  * Distinguish between permanent and temporary errors.
358  *
359  * Returns 0 if the passed-in error is temporary, thus the
360  * mount system call should be retried; returns one if the
361  * passed-in error is permanent, thus the mount system call
362  * should not be retried.
363  */
364 static int is_permanent_error(int error)
365 {
366         switch (error) {
367         case ESTALE:
368         case ETIMEDOUT:
369         case ECONNREFUSED:
370                 return 0;       /* temporary */
371         default:
372                 return 1;       /* permanent */
373         }
374 }
375
376 /*
377  * Reconstruct the mount option string based on a portmapper probe
378  * of the server.  Returns one if the server's portmapper returned
379  * something we can use, otherwise zero.
380  *
381  * To handle version and transport protocol fallback properly, we
382  * need to parse some of the mount options in order to set up a
383  * portmap probe.  Mount options that rewrite_mount_options()
384  * doesn't recognize are left alone.
385  *
386  * Returns a new group of mount options if successful; otherwise
387  * NULL is returned if some failure occurred.
388  */
389 static struct mount_options *rewrite_mount_options(char *str)
390 {
391         struct mount_options *options;
392         char *option, new_option[64];
393         clnt_addr_t mnt_server = { };
394         clnt_addr_t nfs_server = { };
395         int p;
396
397         options = po_split(str);
398         if (!options) {
399                 errno = EFAULT;
400                 return NULL;
401         }
402
403         errno = EINVAL;
404         option = po_get(options, "addr");
405         if (option) {
406                 nfs_server.saddr.sin_family = AF_INET;
407                 if (!inet_aton((const char *)option, &nfs_server.saddr.sin_addr))
408                         goto err;
409         } else
410                 goto err;
411
412         option = po_get(options, "mountaddr");
413         if (option) {
414                 mnt_server.saddr.sin_family = AF_INET;
415                 if (!inet_aton((const char *)option, &mnt_server.saddr.sin_addr))
416                         goto err;
417         } else
418                 memcpy(&mnt_server.saddr, &nfs_server.saddr,
419                                 sizeof(mnt_server.saddr));
420
421         option = po_get(options, "mountport");
422         if (option)
423                 mnt_server.pmap.pm_port = atoi(option);
424         mnt_server.pmap.pm_prog = MOUNTPROG;
425         option = po_get(options, "mountvers");
426         if (option)
427                 mnt_server.pmap.pm_vers = atoi(option);
428
429         option = po_get(options, "port");
430         if (option) {
431                 nfs_server.pmap.pm_port = atoi(option);
432                 po_remove_all(options, "port");
433         }
434         nfs_server.pmap.pm_prog = NFS_PROGRAM;
435
436         option = po_get(options, "nfsvers");
437         if (option) {
438                 nfs_server.pmap.pm_vers = atoi(option);
439                 po_remove_all(options, "nfsvers");
440         }
441         option = po_get(options, "vers");
442         if (option) {
443                 nfs_server.pmap.pm_vers = atoi(option);
444                 po_remove_all(options, "vers");
445         }
446         option = po_get(options, "proto");
447         if (option) {
448                 if (strcmp(option, "tcp") == 0) {
449                         nfs_server.pmap.pm_prot = IPPROTO_TCP;
450                         po_remove_all(options, "proto");
451                 }
452                 if (strcmp(option, "udp") == 0) {
453                         nfs_server.pmap.pm_prot = IPPROTO_UDP;
454                         po_remove_all(options, "proto");
455                 }
456         }
457         p = po_rightmost(options, "tcp", "udp");
458         switch (p) {
459         case PO_KEY2_RIGHTMOST:
460                 nfs_server.pmap.pm_prot = IPPROTO_UDP;
461                 break;
462         case PO_KEY1_RIGHTMOST:
463                 nfs_server.pmap.pm_prot = IPPROTO_TCP;
464                 break;
465         }
466         po_remove_all(options, "tcp");
467         po_remove_all(options, "udp");
468
469         if (!probe_bothports(&mnt_server, &nfs_server)) {
470                 errno = ESPIPE;
471                 goto err;
472         }
473
474         snprintf(new_option, sizeof(new_option) - 1,
475                  "nfsvers=%lu", nfs_server.pmap.pm_vers);
476         if (po_append(options, new_option) == PO_FAILED)
477                 goto err;
478
479         if (nfs_server.pmap.pm_prot == IPPROTO_TCP)
480                 snprintf(new_option, sizeof(new_option) - 1,
481                          "proto=tcp");
482         else
483                 snprintf(new_option, sizeof(new_option) - 1,
484                          "proto=udp");
485         if (po_append(options, new_option) == PO_FAILED)
486                 goto err;
487
488         if (nfs_server.pmap.pm_port != NFS_PORT) {
489                 snprintf(new_option, sizeof(new_option) - 1,
490                          "port=%lu", nfs_server.pmap.pm_port);
491                 if (po_append(options, new_option) == PO_FAILED)
492                         goto err;
493
494         }
495
496         errno = 0;
497         return options;
498
499 err:
500         po_destroy(options);
501         return NULL;
502 }
503
504 /*
505  * Do the mount(2) system call.
506  *
507  * Returns 1 if successful, otherwise zero.
508  * "errno" is set to reflect the individual error.
509  */
510 static int nfs_sys_mount(const struct nfsmount_info *mi, const char *type,
511                          const char *options)
512 {
513         int result;
514
515         result = mount(mi->spec, mi->node, type,
516                                 mi->flags & ~(MS_USER|MS_USERS), options);
517         if (verbose && result) {
518                 int save = errno;
519                 nfs_error(_("%s: mount(2): %s"), progname, strerror(save));
520                 errno = save;
521         }
522         return !result;
523 }
524
525 /*
526  * Retry an NFS mount that failed because the requested service isn't
527  * available on the server.
528  *
529  * Returns 1 if successful.  Otherwise, returns zero.
530  * "errno" is set to reflect the individual error.
531  *
532  * Side effect: If the retry is successful, both 'options' and
533  * 'extra_opts' are updated to reflect the mount options that worked.
534  * If the retry fails, 'options' and 'extra_opts' are left unchanged.
535  */
536 static int nfs_retry_nfs23mount(struct nfsmount_info *mi)
537 {
538         struct mount_options *retry_options;
539         char *retry_str = NULL;
540         char **extra_opts = mi->extra_opts;
541
542         retry_options = rewrite_mount_options(*extra_opts);
543         if (!retry_options)
544                 return 0;
545
546         if (po_join(retry_options, &retry_str) == PO_FAILED) {
547                 po_destroy(retry_options);
548                 errno = EIO;
549                 return 0;
550         }
551
552         if (verbose)
553                 printf(_("%s: text-based options (retry): '%s'\n"),
554                         progname, retry_str);
555
556         if (!nfs_sys_mount(mi, "nfs", retry_str)) {
557                 po_destroy(retry_options);
558                 free(retry_str);
559                 return 0;
560         }
561
562         free(*extra_opts);
563         *extra_opts = retry_str;
564         po_replace(mi->options, retry_options);
565         return 1;
566 }
567
568 /*
569  * Attempt an NFSv2/3 mount via a mount(2) system call.  If the kernel
570  * claims the requested service isn't supported on the server, probe
571  * the server to see what's supported, rewrite the mount options,
572  * and retry the request.
573  *
574  * Returns 1 if successful.  Otherwise, returns zero.
575  * "errno" is set to reflect the individual error.
576  *
577  * Side effect: If the retry is successful, both 'options' and
578  * 'extra_opts' are updated to reflect the mount options that worked.
579  * If the retry fails, 'options' and 'extra_opts' are left unchanged.
580  */
581 static int nfs_try_nfs23mount(struct nfsmount_info *mi)
582 {
583         char **extra_opts = mi->extra_opts;
584
585         if (po_join(mi->options, extra_opts) == PO_FAILED) {
586                 errno = EIO;
587                 return 0;
588         }
589
590         if (verbose)
591                 printf(_("%s: text-based options: '%s'\n"),
592                         progname, *extra_opts);
593
594         if (mi->fake)
595                 return 1;
596
597         if (nfs_sys_mount(mi, "nfs", *extra_opts))
598                 return 1;
599
600         /*
601          * The kernel returns EOPNOTSUPP if the RPC bind failed,
602          * and EPROTONOSUPPORT if the version isn't supported.
603          */
604         if (errno != EOPNOTSUPP && errno != EPROTONOSUPPORT)
605                 return 0;
606
607         return nfs_retry_nfs23mount(mi);
608 }
609
610 /*
611  * Attempt an NFS v4 mount via a mount(2) system call.
612  *
613  * Returns 1 if successful.  Otherwise, returns zero.
614  * "errno" is set to reflect the individual error.
615  */
616 static int nfs_try_nfs4mount(struct nfsmount_info *mi)
617 {
618         char **extra_opts = mi->extra_opts;
619
620         if (po_join(mi->options, extra_opts) == PO_FAILED) {
621                 errno = EIO;
622                 return 0;
623         }
624
625         if (verbose)
626                 printf(_("%s: text-based options: '%s'\n"),
627                         progname, *extra_opts);
628
629         if (mi->fake)
630                 return 1;
631
632         return nfs_sys_mount(mi, "nfs4", *extra_opts);
633 }
634
635 /*
636  * Perform either an NFSv2/3 mount, or an NFSv4 mount system call.
637  *
638  * Returns 1 if successful.  Otherwise, returns zero.
639  * "errno" is set to reflect the individual error.
640  */
641 static int nfs_try_mount(struct nfsmount_info *mi)
642 {
643         if (strncmp(mi->type, "nfs4", 4) == 0)
644                 return nfs_try_nfs4mount(mi);
645         else
646                 return nfs_try_nfs23mount(mi);
647 }
648
649 /*
650  * Handle "foreground" NFS mounts.
651  *
652  * Retry the mount request for as long as the 'retry=' option says.
653  *
654  * Returns a valid mount command exit code.
655  */
656 static int nfsmount_fg(struct nfsmount_info *mi)
657 {
658         unsigned int secs = 1;
659         time_t timeout;
660
661         timeout = nfs_parse_retry_option(mi->options,
662                                          NFS_DEF_FG_TIMEOUT_MINUTES);
663         if (verbose)
664                 printf(_("%s: timeout set for %s"),
665                         progname, ctime(&timeout));
666
667         for (;;) {
668                 if (nfs_try_mount(mi))
669                         return EX_SUCCESS;
670
671                 if (is_permanent_error(errno))
672                         break;
673
674                 if (time(NULL) > timeout) {
675                         errno = ETIMEDOUT;
676                         break;
677                 }
678
679                 if (errno != ETIMEDOUT) {
680                         if (sleep(secs))
681                                 break;
682                         secs <<= 1;
683                         if (secs > 10)
684                                 secs = 10;
685                 }
686         };
687
688         mount_error(mi->spec, mi->node, errno);
689         return EX_FAIL;
690 }
691
692 /*
693  * Handle "background" NFS mount [first try]
694  *
695  * Returns a valid mount command exit code.
696  *
697  * EX_BG should cause the caller to fork and invoke nfsmount_child.
698  */
699 static int nfsmount_parent(struct nfsmount_info *mi)
700 {
701         if (nfs_try_mount(mi))
702                 return EX_SUCCESS;
703
704         if (is_permanent_error(errno)) {
705                 mount_error(mi->spec, mi->node, errno);
706                 return EX_FAIL;
707         }
708
709         sys_mount_errors(mi->hostname, errno, 1, 1);
710         return EX_BG;
711 }
712
713 /*
714  * Handle "background" NFS mount [retry daemon]
715  *
716  * Returns a valid mount command exit code: EX_SUCCESS if successful,
717  * EX_FAIL if a failure occurred.  There's nothing to catch the
718  * error return, though, so we use sys_mount_errors to log the
719  * failure.
720  */
721 static int nfsmount_child(struct nfsmount_info *mi)
722 {
723         unsigned int secs = 1;
724         time_t timeout;
725
726         timeout = nfs_parse_retry_option(mi->options,
727                                          NFS_DEF_BG_TIMEOUT_MINUTES);
728
729         for (;;) {
730                 if (sleep(secs))
731                         break;
732                 secs <<= 1;
733                 if (secs > 120)
734                         secs = 120;
735
736                 if (nfs_try_mount(mi))
737                         return EX_SUCCESS;
738
739                 if (is_permanent_error(errno))
740                         break;
741
742                 if (time(NULL) > timeout)
743                         break;
744
745                 sys_mount_errors(mi->hostname, errno, 1, 1);
746         };
747
748         sys_mount_errors(mi->hostname, errno, 1, 0);
749         return EX_FAIL;
750 }
751
752 /*
753  * Handle "background" NFS mount
754  *
755  * Returns a valid mount command exit code.
756  */
757 static int nfsmount_bg(struct nfsmount_info *mi)
758 {
759         if (!mi->child)
760                 return nfsmount_parent(mi);
761         else
762                 return nfsmount_child(mi);
763 }
764
765 /*
766  * Process mount options and try a mount system call.
767  *
768  * Returns a valid mount command exit code.
769  */
770 static int nfsmount_start(struct nfsmount_info *mi)
771 {
772         if (!nfs_validate_options(mi))
773                 return EX_FAIL;
774
775         if (po_rightmost(mi->options, "bg", "fg") == PO_KEY1_RIGHTMOST)
776                 return nfsmount_bg(mi);
777         else
778                 return nfsmount_fg(mi);
779 }
780
781 /**
782  * nfsmount_string - Mount an NFS file system using C string options
783  * @spec: C string specifying remote share to mount ("hostname:path")
784  * @node: C string pathname of local mounted-on directory
785  * @type: C string that represents file system type ("nfs" or "nfs4")
786  * @flags: MS_ style mount flags
787  * @extra_opts: pointer to C string containing fs-specific mount options
788  *              (input and output argument)
789  * @fake: flag indicating whether to carry out the whole operation
790  * @child: one if this is a mount daemon (bg)
791  */
792 int nfsmount_string(const char *spec, const char *node, const char *type,
793                     int flags, char **extra_opts, int fake, int child)
794 {
795         struct nfsmount_info mi = {
796                 .spec           = spec,
797                 .node           = node,
798                 .type           = type,
799                 .extra_opts     = extra_opts,
800                 .flags          = flags,
801                 .fake           = fake,
802                 .child          = child,
803         };
804         int retval = EX_FAIL;
805
806         if (!nfs_parse_devname(&mi))
807                 return retval;
808
809         mi.options = po_split(*extra_opts);
810         if (mi.options) {
811                 retval = nfsmount_start(&mi);
812                 po_destroy(mi.options);
813         } else
814                 nfs_error(_("%s: internal option parsing error"), progname);
815
816         free(mi.hostname);
817         return retval;
818 }