d262e940091e195449d9d0aea05473a556c2b9fe
[nfs-utils.git] / utils / mount / network.c
1 /*
2  * network.c -- Provide common network functions for NFS mount/umount
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/types.h>
38 #include <sys/socket.h>
39 #include <sys/wait.h>
40 #include <netinet/in.h>
41 #include <rpc/rpc.h>
42 #include <rpc/pmap_prot.h>
43 #include <rpc/pmap_clnt.h>
44
45 #include "xcommon.h"
46 #include "mount.h"
47 #include "nls.h"
48 #include "nfs_mount.h"
49 #include "mount_constants.h"
50 #include "nfsrpc.h"
51 #include "network.h"
52
53 #define PMAP_TIMEOUT    (10)
54 #define CONNECT_TIMEOUT (20)
55 #define MOUNT_TIMEOUT   (30)
56
57 #if SIZEOF_SOCKLEN_T - 0 == 0
58 #define socklen_t unsigned int
59 #endif
60
61 extern int nfs_mount_data_version;
62 extern char *progname;
63 extern int verbose;
64
65 static const char *nfs_ns_pgmtbl[] = {
66         "status",
67         NULL,
68 };
69
70 static const unsigned long nfs_to_mnt[] = {
71         0,
72         0,
73         1,
74         3,
75 };
76
77 static const unsigned long mnt_to_nfs[] = {
78         0,
79         2,
80         2,
81         3,
82 };
83
84 /*
85  * Map an NFS version into the corresponding Mountd version
86  */
87 unsigned long nfsvers_to_mnt(const unsigned long vers)
88 {
89         if (vers <= 3)
90                 return nfs_to_mnt[vers];
91         return 0;
92 }
93
94 /*
95  * Map a Mountd version into the corresponding NFS version
96  */
97 static unsigned long mntvers_to_nfs(const unsigned long vers)
98 {
99         if (vers <= 3)
100                 return mnt_to_nfs[vers];
101         return 0;
102 }
103
104 static const unsigned int probe_udp_only[] = {
105         IPPROTO_UDP,
106         0,
107 };
108
109 static const unsigned int probe_udp_first[] = {
110         IPPROTO_UDP,
111         IPPROTO_TCP,
112         0,
113 };
114
115 static const unsigned int probe_tcp_first[] = {
116         IPPROTO_TCP,
117         IPPROTO_UDP,
118         0,
119 };
120
121 static const unsigned long probe_nfs2_only[] = {
122         2,
123         0,
124 };
125
126 static const unsigned long probe_nfs3_first[] = {
127         3,
128         2,
129         0,
130 };
131
132 static const unsigned long probe_mnt1_first[] = {
133         1,
134         2,
135         0,
136 };
137
138 static const unsigned long probe_mnt3_first[] = {
139         3,
140         1,
141         2,
142         0,
143 };
144
145 static void nfs_set_port(struct sockaddr *sap, const unsigned short port)
146 {
147         switch (sap->sa_family) {
148         case AF_INET:
149                 ((struct sockaddr_in *)sap)->sin_port = htons(port);
150                 break;
151         case AF_INET6:
152                 ((struct sockaddr_in6 *)sap)->sin6_port = htons(port);
153                 break;
154         default:
155                 nfs_error(_("%s: unrecognized address family in %s"),
156                         progname, __func__);
157         }
158 }
159
160 #ifdef HAVE_DECL_AI_ADDRCONFIG
161 /**
162  * nfs_name_to_address - resolve hostname to an IPv4 or IPv6 socket address
163  * @hostname: pointer to C string containing DNS hostname to resolve
164  * @af_hint: hint to restrict resolution to one address family
165  * @sap: pointer to buffer to fill with socket address
166  * @len: IN: size of buffer to fill; OUT: size of socket address
167  *
168  * Returns 1 and places a socket address at @sap if successful;
169  * otherwise zero.
170  */
171 int nfs_name_to_address(const char *hostname,
172                         const sa_family_t af_hint,
173                         struct sockaddr *sap, socklen_t *salen)
174 {
175         struct addrinfo *gai_results;
176         struct addrinfo gai_hint = {
177                 .ai_family      = af_hint,
178                 .ai_flags       = AI_ADDRCONFIG,
179         };
180         socklen_t len = *salen;
181         int error, ret = 0;
182
183         if (af_hint == AF_INET6)
184                 gai_hint.ai_flags |= AI_V4MAPPED|AI_ALL;
185
186         *salen = 0;
187
188         error = getaddrinfo(hostname, NULL, &gai_hint, &gai_results);
189         if (error) {
190                 nfs_error(_("%s: DNS resolution failed for %s: %s"),
191                         progname, hostname, (error == EAI_SYSTEM ?
192                                 strerror(errno) : gai_strerror(error)));
193                 return ret;
194         }
195
196         switch (gai_results->ai_addr->sa_family) {
197         case AF_INET:
198         case AF_INET6:
199                 if (len >= gai_results->ai_addrlen) {
200                         *salen = gai_results->ai_addrlen;
201                         memcpy(sap, gai_results->ai_addr, *salen);
202                         ret = 1;
203                 }
204                 break;
205         default:
206                 /* things are really broken if we get here, so warn */
207                 nfs_error(_("%s: unrecognized DNS resolution results for %s"),
208                                 progname, hostname);
209                 break;
210         }
211
212         freeaddrinfo(gai_results);
213         return ret;
214 }
215 #else   /* HAVE_DECL_AI_ADDRCONFIG */
216 /**
217  * nfs_name_to_address - resolve hostname to an IPv4 socket address
218  * @hostname: pointer to C string containing DNS hostname to resolve
219  * @af_hint: hint to restrict resolution to one address family
220  * @sap: pointer to buffer to fill with socket address
221  * @len: IN: size of buffer to fill; OUT: size of socket address
222  *
223  * Returns 1 and places a socket address at @sap if successful;
224  * otherwise zero.
225  *
226  * Some older getaddrinfo(3) implementations don't support
227  * AI_ADDRCONFIG or AI_V4MAPPED properly.  For those cases, a DNS
228  * resolver based on the traditional gethostbyname(3) is provided.
229  */
230 int nfs_name_to_address(const char *hostname,
231                         const sa_family_t af_hint,
232                         struct sockaddr *sap, socklen_t *salen)
233 {
234         struct sockaddr_in *sin = (struct sockaddr_in *)sap;
235         socklen_t len = *salen;
236         struct hostent *hp;
237
238         *salen = 0;
239
240         if (af_hint != AF_INET) {
241                 nfs_error(_("%s: address family not supported by DNS resolver\n"),
242                                 progname, hostname);
243                 return 0;
244         }
245
246         sin->sin_family = AF_INET;
247         if (inet_aton(hostname, &sin->sin_addr)) {
248                 *salen = sizeof(*sin);
249                 return 1;
250         }
251
252         hp = gethostbyname(hostname);
253         if (hp == NULL) {
254                 nfs_error(_("%s: DNS resolution failed for %s: %s"),
255                                 progname, hostname, hstrerror(h_errno));
256                 return 0;
257         }
258
259         if (hp->h_length > len) {
260                 nfs_error(_("%s: DNS resolution results too long for buffer\n"),
261                                 progname);
262                 return 0;
263         }
264
265         memcpy(&sin->sin_addr, hp->h_addr, hp->h_length);
266         *salen = hp->h_length;
267         return 1;
268 }
269 #endif  /* HAVE_DECL_AI_ADDRCONFIG */
270
271 /**
272  * nfs_gethostbyname - resolve a hostname to an IPv4 address
273  * @hostname: pointer to a C string containing a DNS hostname
274  * @sin: returns an IPv4 address 
275  *
276  * Returns 1 if successful, otherwise zero.
277  */
278 int nfs_gethostbyname(const char *hostname, struct sockaddr_in *sin)
279 {
280         socklen_t len = sizeof(*sin);
281
282         return nfs_name_to_address(hostname, AF_INET,
283                                         (struct sockaddr *)sin, &len);
284 }
285
286 /**
287  * nfs_string_to_sockaddr - convert string address to sockaddr
288  * @address:    pointer to presentation format address to convert
289  * @addrlen:    length of presentation address
290  * @sap:        pointer to socket address buffer to fill in
291  * @salen:      IN: length of address buffer
292  *              OUT: length of converted socket address
293  *
294  * Convert a presentation format address string to a socket address.
295  * Similar to nfs_name_to_address(), but the DNS query is squelched,
296  * and won't make any noise if the getaddrinfo() call fails.
297  *
298  * Returns 1 and fills in @sap and @salen if successful; otherwise zero.
299  *
300  * See RFC 4038 section 5.1 or RFC 3513 section 2.2 for more details
301  * on presenting IPv6 addresses as text strings.
302  */
303 int nfs_string_to_sockaddr(const char *address, const size_t addrlen,
304                            struct sockaddr *sap, socklen_t *salen)
305 {
306         struct addrinfo *gai_results;
307         struct addrinfo gai_hint = {
308                 .ai_flags       = AI_NUMERICHOST,
309         };
310         socklen_t len = *salen;
311         int ret = 0;
312
313         *salen = 0;
314
315         if (getaddrinfo(address, NULL, &gai_hint, &gai_results) == 0) {
316                 switch (gai_results->ai_addr->sa_family) {
317                 case AF_INET:
318                 case AF_INET6:
319                         if (len >= gai_results->ai_addrlen) {
320                                 *salen = gai_results->ai_addrlen;
321                                 memcpy(sap, gai_results->ai_addr, *salen);
322                                 ret = 1;
323                         }
324                         break;
325                 }
326                 freeaddrinfo(gai_results);
327         }
328
329         return ret;
330 }
331
332 /**
333  * nfs_present_sockaddr - convert sockaddr to string
334  * @sap: pointer to socket address to convert
335  * @salen: length of socket address
336  * @buf: pointer to buffer to fill in
337  * @buflen: length of buffer
338  *
339  * Convert the passed-in sockaddr-style address to presentation format.
340  * The presentation format address is placed in @buf and is
341  * '\0'-terminated.
342  *
343  * Returns 1 if successful; otherwise zero.
344  *
345  * See RFC 4038 section 5.1 or RFC 3513 section 2.2 for more details
346  * on presenting IPv6 addresses as text strings.
347  */
348 int nfs_present_sockaddr(const struct sockaddr *sap, const socklen_t salen,
349                          char *buf, const size_t buflen)
350 {
351 #ifdef HAVE_GETNAMEINFO
352         int result;
353
354         result = getnameinfo(sap, salen, buf, buflen,
355                                         NULL, 0, NI_NUMERICHOST);
356         if (!result)
357                 return 1;
358
359         nfs_error(_("%s: invalid server address: %s"), progname,
360                         gai_strerror(result));
361         return 0;
362 #else   /* HAVE_GETNAMEINFO */
363         char *addr;
364
365         if (sap->sa_family == AF_INET) {
366                 addr = inet_ntoa(((struct sockaddr_in *)sap)->sin_addr);
367                 if (addr && strlen(addr) < buflen) {
368                         strcpy(buf, addr);
369                         return 1;
370                 }
371         }
372
373         nfs_error(_("%s: invalid server address"), progname);
374         return 0;
375 #endif  /* HAVE_GETNAMEINFO */
376 }
377
378 /*
379  * Attempt to connect a socket, but time out after "timeout" seconds.
380  *
381  * On error return, caller closes the socket.
382  */
383 static int connect_to(int fd, struct sockaddr *addr,
384                         socklen_t addrlen, int timeout)
385 {
386         int ret, saved;
387         fd_set rset, wset;
388         struct timeval tv = {
389                 .tv_sec = timeout,
390         };
391
392         saved = fcntl(fd, F_GETFL, 0);
393         fcntl(fd, F_SETFL, saved | O_NONBLOCK);
394
395         ret = connect(fd, addr, addrlen);
396         if (ret < 0 && errno != EINPROGRESS)
397                 return -1;
398         if (ret == 0)
399                 goto out;
400
401         FD_ZERO(&rset);
402         FD_SET(fd, &rset);
403         wset = rset;
404         ret = select(fd + 1, &rset, &wset, NULL, &tv);
405         if (ret == 0) {
406                 errno = ETIMEDOUT;
407                 return -1;
408         }
409         if (FD_ISSET(fd, &rset) || FD_ISSET(fd, &wset)) {
410                 int error;
411                 socklen_t len = sizeof(error);
412                 if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &error, &len) < 0)
413                         return -1;
414                 if (error) {
415                         errno = error;
416                         return -1;
417                 }
418         } else
419                 return -1;
420
421 out:
422         fcntl(fd, F_SETFL, saved);
423         return 0;
424 }
425
426 /*
427  * Create a socket that is locally bound to a reserved or non-reserved port.
428  *
429  * The caller should check rpc_createerr to determine the cause of any error.
430  */
431 static int get_socket(struct sockaddr_in *saddr, unsigned int p_prot,
432                         unsigned int timeout, int resvp, int conn)
433 {
434         int so, cc, type;
435         struct sockaddr_in laddr;
436         socklen_t namelen = sizeof(laddr);
437
438         type = (p_prot == IPPROTO_UDP ? SOCK_DGRAM : SOCK_STREAM);
439         if ((so = socket (AF_INET, type, p_prot)) < 0)
440                 goto err_socket;
441
442         laddr.sin_family = AF_INET;
443         laddr.sin_port = 0;
444         laddr.sin_addr.s_addr = htonl(INADDR_ANY);
445         if (resvp) {
446                 if (bindresvport(so, &laddr) < 0)
447                         goto err_bindresvport;
448         } else {
449                 cc = bind(so, (struct sockaddr *)&laddr, namelen);
450                 if (cc < 0)
451                         goto err_bind;
452         }
453         if (type == SOCK_STREAM || (conn && type == SOCK_DGRAM)) {
454                 cc = connect_to(so, (struct sockaddr *)saddr, namelen,
455                                 timeout);
456                 if (cc < 0)
457                         goto err_connect;
458         }
459         return so;
460
461 err_socket:
462         rpc_createerr.cf_stat = RPC_SYSTEMERROR;
463         rpc_createerr.cf_error.re_errno = errno;
464         if (verbose) {
465                 nfs_error(_("%s: Unable to create %s socket: errno %d (%s)\n"),
466                         progname, p_prot == IPPROTO_UDP ? _("UDP") : _("TCP"),
467                         errno, strerror(errno));
468         }
469         return RPC_ANYSOCK;
470
471 err_bindresvport:
472         rpc_createerr.cf_stat = RPC_SYSTEMERROR;
473         rpc_createerr.cf_error.re_errno = errno;
474         if (verbose) {
475                 nfs_error(_("%s: Unable to bindresvport %s socket: errno %d"
476                                 " (%s)\n"),
477                         progname, p_prot == IPPROTO_UDP ? _("UDP") : _("TCP"),
478                         errno, strerror(errno));
479         }
480         close(so);
481         return RPC_ANYSOCK;
482
483 err_bind:
484         rpc_createerr.cf_stat = RPC_SYSTEMERROR;
485         rpc_createerr.cf_error.re_errno = errno;
486         if (verbose) {
487                 nfs_error(_("%s: Unable to bind to %s socket: errno %d (%s)\n"),
488                         progname, p_prot == IPPROTO_UDP ? _("UDP") : _("TCP"),
489                         errno, strerror(errno));
490         }
491         close(so);
492         return RPC_ANYSOCK;
493
494 err_connect:
495         rpc_createerr.cf_stat = RPC_SYSTEMERROR;
496         rpc_createerr.cf_error.re_errno = errno;
497         if (verbose) {
498                 nfs_error(_("%s: Unable to connect to %s:%d, errno %d (%s)\n"),
499                         progname, inet_ntoa(saddr->sin_addr),
500                         ntohs(saddr->sin_port), errno, strerror(errno));
501         }
502         close(so);
503         return RPC_ANYSOCK;
504 }
505
506 static void nfs_pp_debug(const struct sockaddr *sap, const socklen_t salen,
507                          const rpcprog_t program, const rpcvers_t version,
508                          const unsigned short protocol,
509                          const unsigned short port)
510 {
511         char buf[NI_MAXHOST];
512
513         if (!verbose)
514                 return;
515
516         if (nfs_present_sockaddr(sap, salen, buf, sizeof(buf)) == 0) {
517                 buf[0] = '\0';
518                 strcat(buf, "unknown host");
519         }
520
521         fprintf(stderr, _("%s: trying %s prog %ld vers %ld prot %s port %d\n"),
522                         progname, buf, program, version,
523                         (protocol == IPPROTO_UDP ? _("UDP") : _("TCP")),
524                         port);
525 }
526
527 /*
528  * Use the portmapper to discover whether or not the service we want is
529  * available. The lists 'versions' and 'protos' define ordered sequences
530  * of service versions and udp/tcp protocols to probe for.
531  *
532  * Returns 1 if the requested service port is unambiguous and pingable;
533  * @pmap is filled in with the version, port, and transport protocol used
534  * during the successful ping.  Note that if a port is already specified
535  * in @pmap and it matches the rpcbind query result, nfs_probe_port() does
536  * not perform an RPC ping.
537  * 
538  * If an error occurs or the requested service isn't available, zero is
539  * returned; rpccreateerr.cf_stat is set to reflect the nature of the error.
540  */
541 static int nfs_probe_port(const struct sockaddr *sap, const socklen_t salen,
542                           struct pmap *pmap, const unsigned long *versions,
543                           const unsigned int *protos)
544 {
545         struct sockaddr_storage address;
546         struct sockaddr *saddr = (struct sockaddr *)&address;
547         const unsigned long prog = pmap->pm_prog, *p_vers;
548         const unsigned int prot = (u_int)pmap->pm_prot, *p_prot;
549         const u_short port = (u_short) pmap->pm_port;
550         unsigned long vers = pmap->pm_vers;
551         unsigned short p_port;
552
553         memcpy(saddr, sap, salen);
554         p_prot = prot ? &prot : protos;
555         p_vers = vers ? &vers : versions;
556         rpc_createerr.cf_stat = 0;
557
558         for (;;) {
559                 p_port = nfs_getport(saddr, salen, prog, *p_vers, *p_prot);
560                 if (p_port) {
561                         if (!port || port == p_port) {
562                                 nfs_set_port(saddr, p_port);
563                                 nfs_pp_debug(saddr, salen, prog, *p_vers,
564                                                 *p_prot, p_port);
565                                 if (nfs_rpc_ping(saddr, salen, prog,
566                                                         *p_vers, *p_prot, NULL))
567                                         goto out_ok;
568                         }
569                 }
570                 if (rpc_createerr.cf_stat != RPC_PROGNOTREGISTERED &&
571                     rpc_createerr.cf_stat != RPC_TIMEDOUT &&
572                     rpc_createerr.cf_stat != RPC_CANTRECV &&
573                     rpc_createerr.cf_stat != RPC_PROGVERSMISMATCH)
574                         goto out_bad;
575
576                 if (!prot) {
577                         if (*++p_prot)
578                                 continue;
579                         p_prot = protos;
580                 }
581                 if (rpc_createerr.cf_stat == RPC_TIMEDOUT ||
582                     rpc_createerr.cf_stat == RPC_CANTRECV)
583                         goto out_bad;
584
585                 if (vers || !*++p_vers)
586                         break;
587         }
588
589 out_bad:
590         return 0;
591
592 out_ok:
593         if (!vers)
594                 pmap->pm_vers = *p_vers;
595         if (!prot)
596                 pmap->pm_prot = *p_prot;
597         if (!port)
598                 pmap->pm_port = p_port;
599         rpc_createerr.cf_stat = 0;
600         return 1;
601 }
602
603 /*
604  * Probe a server's NFS service to determine which versions and
605  * transport protocols are supported.
606  *
607  * Returns 1 if the requested service port is unambiguous and pingable;
608  * @pmap is filled in with the version, port, and transport protocol used
609  * during the successful ping.  If all three are already specified, simply
610  * return success without an rpcbind query or RPC ping (we may be trying
611  * to mount an NFS service that is not advertised via rpcbind).
612  *
613  * If an error occurs or the requested service isn't available, zero is
614  * returned; rpccreateerr.cf_stat is set to reflect the nature of the error.
615  */
616 static int nfs_probe_nfsport(const struct sockaddr *sap, const socklen_t salen,
617                                 struct pmap *pmap)
618 {
619         if (pmap->pm_vers && pmap->pm_prot && pmap->pm_port)
620                 return 1;
621
622         if (nfs_mount_data_version >= 4)
623                 return nfs_probe_port(sap, salen, pmap,
624                                         probe_nfs3_first, probe_tcp_first);
625         else
626                 return nfs_probe_port(sap, salen, pmap,
627                                         probe_nfs2_only, probe_udp_only);
628 }
629
630 /*
631  * Probe a server's mountd service to determine which versions and
632  * transport protocols are supported.
633  *
634  * Returns 1 if the requested service port is unambiguous and pingable;
635  * @pmap is filled in with the version, port, and transport protocol used
636  * during the successful ping.  If all three are already specified, simply
637  * return success without an rpcbind query or RPC ping (we may be trying
638  * to mount an NFS service that is not advertised via rpcbind).
639  * 
640  * If an error occurs or the requested service isn't available, zero is
641  * returned; rpccreateerr.cf_stat is set to reflect the nature of the error.
642  */
643 static int nfs_probe_mntport(const struct sockaddr *sap, const socklen_t salen,
644                                 struct pmap *pmap)
645 {
646         if (pmap->pm_vers && pmap->pm_prot && pmap->pm_port)
647                 return 1;
648
649         if (nfs_mount_data_version >= 4)
650                 return nfs_probe_port(sap, salen, pmap,
651                                         probe_mnt3_first, probe_udp_first);
652         else
653                 return nfs_probe_port(sap, salen, pmap,
654                                         probe_mnt1_first, probe_udp_only);
655 }
656
657 /*
658  * Probe a server's mountd service to determine which versions and
659  * transport protocols are supported.  Invoked when the protocol
660  * version is already known for both the NFS and mountd service.
661  *
662  * Returns 1 and fills in both @pmap structs if the requested service
663  * ports are unambiguous and pingable.  Otherwise zero is returned;
664  * rpccreateerr.cf_stat is set to reflect the nature of the error.
665  */
666 static int nfs_probe_version_fixed(const struct sockaddr *mnt_saddr,
667                         const socklen_t mnt_salen,
668                         struct pmap *mnt_pmap,
669                         const struct sockaddr *nfs_saddr,
670                         const socklen_t nfs_salen,
671                         struct pmap *nfs_pmap)
672 {
673         if (!nfs_probe_nfsport(nfs_saddr, nfs_salen, nfs_pmap))
674                 return 0;
675         return nfs_probe_mntport(mnt_saddr, mnt_salen, mnt_pmap);
676 }
677
678 /**
679  * nfs_probe_bothports - discover the RPC endpoints of mountd and NFS server
680  * @mnt_saddr:  pointer to socket address of mountd server
681  * @mnt_salen:  length of mountd server's address
682  * @mnt_pmap:   IN: partially filled-in mountd RPC service tuple;
683  *              OUT: fully filled-in mountd RPC service tuple
684  * @nfs_saddr:  pointer to socket address of NFS server
685  * @nfs_salen:  length of NFS server's address
686  * @nfs_pmap:   IN: partially filled-in NFS RPC service tuple;
687  *              OUT: fully filled-in NFS RPC service tuple
688  *
689  * Returns 1 and fills in both @pmap structs if the requested service
690  * ports are unambiguous and pingable.  Otherwise zero is returned;
691  * rpccreateerr.cf_stat is set to reflect the nature of the error.
692  */
693 int nfs_probe_bothports(const struct sockaddr *mnt_saddr,
694                         const socklen_t mnt_salen,
695                         struct pmap *mnt_pmap,
696                         const struct sockaddr *nfs_saddr,
697                         const socklen_t nfs_salen,
698                         struct pmap *nfs_pmap)
699 {
700         struct pmap save_nfs, save_mnt;
701         const unsigned long *probe_vers;
702
703         if (mnt_pmap->pm_vers && !nfs_pmap->pm_vers)
704                 nfs_pmap->pm_vers = mntvers_to_nfs(mnt_pmap->pm_vers);
705         else if (nfs_pmap->pm_vers && !mnt_pmap->pm_vers)
706                 mnt_pmap->pm_vers = nfsvers_to_mnt(nfs_pmap->pm_vers);
707
708         if (nfs_pmap->pm_vers)
709                 return nfs_probe_version_fixed(mnt_saddr, mnt_salen, mnt_pmap,
710                                                nfs_saddr, nfs_salen, nfs_pmap);
711
712         memcpy(&save_nfs, nfs_pmap, sizeof(save_nfs));
713         memcpy(&save_mnt, mnt_pmap, sizeof(save_mnt));
714         probe_vers = (nfs_mount_data_version >= 4) ?
715                         probe_mnt3_first : probe_mnt1_first;
716
717         for (; *probe_vers; probe_vers++) {
718                 nfs_pmap->pm_vers = mntvers_to_nfs(*probe_vers);
719                 if (nfs_probe_nfsport(nfs_saddr, nfs_salen, nfs_pmap) != 0) {
720                         mnt_pmap->pm_vers = *probe_vers;
721                         if (nfs_probe_mntport(mnt_saddr, mnt_salen, mnt_pmap) != 0)
722                                 return 1;
723                         memcpy(mnt_pmap, &save_mnt, sizeof(*mnt_pmap));
724                 }
725                 switch (rpc_createerr.cf_stat) {
726                 case RPC_PROGVERSMISMATCH:
727                 case RPC_PROGNOTREGISTERED:
728                         break;
729                 default:
730                         return 0;
731                 }
732                 memcpy(nfs_pmap, &save_nfs, sizeof(*nfs_pmap));
733         }
734
735         return 0;
736 }
737
738 /**
739  * probe_bothports - discover the RPC endpoints of mountd and NFS server
740  * @mnt_server: pointer to address and pmap argument for mountd results
741  * @nfs_server: pointer to address and pmap argument for NFS server
742  *
743  * This is the legacy API that takes "clnt_addr_t" for both servers,
744  * but supports only AF_INET addresses.
745  *
746  * Returns 1 and fills in the pmap field in both clnt_addr_t structs
747  * if the requested service ports are unambiguous and pingable.
748  * Otherwise zero is returned; rpccreateerr.cf_stat is set to reflect
749  * the nature of the error.
750  */
751 int probe_bothports(clnt_addr_t *mnt_server, clnt_addr_t *nfs_server)
752 {
753         return nfs_probe_bothports((struct sockaddr *)&mnt_server->saddr,
754                                         sizeof(mnt_server->saddr),
755                                         &mnt_server->pmap,
756                                         (struct sockaddr *)&nfs_server->saddr,
757                                         sizeof(nfs_server->saddr),
758                                         &nfs_server->pmap);
759 }
760
761 static int nfs_probe_statd(void)
762 {
763         struct sockaddr_in addr = {
764                 .sin_family             = AF_INET,
765                 .sin_addr.s_addr        = htonl(INADDR_LOOPBACK),
766         };
767         rpcprog_t program = nfs_getrpcbyname(NSMPROG, nfs_ns_pgmtbl);
768
769         return nfs_getport_ping((struct sockaddr *)&addr, sizeof(addr),
770                                 program, (rpcvers_t)1, IPPROTO_UDP);
771 }
772
773 /**
774  * start_statd - attempt to start rpc.statd
775  *
776  * Returns 1 if statd is running; otherwise zero.
777  */
778 int start_statd(void)
779 {
780 #ifdef START_STATD
781         struct stat stb;
782 #endif
783
784         if (nfs_probe_statd())
785                 return 1;
786
787 #ifdef START_STATD
788         if (stat(START_STATD, &stb) == 0) {
789                 if (S_ISREG(stb.st_mode) && (stb.st_mode & S_IXUSR)) {
790                         pid_t pid = fork();
791                         switch (pid) {
792                         case 0: /* child */
793                                 execl(START_STATD, START_STATD, NULL);
794                                 exit(1);
795                         case -1: /* error */
796                                 nfs_error(_("fork failed: %s"),
797                                                         strerror(errno));
798                                 break;
799                         default: /* parent */
800                                 waitpid(pid, NULL,0);
801                                 break;
802                         }
803                         if (nfs_probe_statd())
804                                 return 1;
805                 }
806         }
807 #endif
808
809         return 0;
810 }
811
812 /**
813  * nfs_call_umount - ask the server to remove a share from it's rmtab
814  * @mnt_server: address of RPC MNT program server
815  * @argp: directory path of share to "unmount"
816  *
817  * Returns one if the unmount call succeeded; zero if the unmount
818  * failed for any reason.
819  *
820  * Note that a side effect of calling this function is that rpccreateerr
821  * is set.
822  */
823 int nfs_call_umount(clnt_addr_t *mnt_server, dirpath *argp)
824 {
825         struct sockaddr *sap = (struct sockaddr *)&mnt_server->saddr;
826         socklen_t salen = sizeof(mnt_server->saddr);
827         struct pmap *pmap = &mnt_server->pmap;
828         CLIENT *clnt;
829         enum clnt_stat res = 0;
830         int msock;
831
832         if (!nfs_probe_mntport(sap, salen, pmap))
833                 return 0;
834         clnt = mnt_openclnt(mnt_server, &msock);
835         if (!clnt)
836                 return 0;
837         res = clnt_call(clnt, MOUNTPROC_UMNT,
838                         (xdrproc_t)xdr_dirpath, (caddr_t)argp,
839                         (xdrproc_t)xdr_void, NULL,
840                         TIMEOUT);
841         mnt_closeclnt(clnt, msock);
842
843         if (res == RPC_SUCCESS)
844                 return 1;
845         return 0;
846 }
847
848 /**
849  * mnt_openclnt - get a handle for a remote mountd service
850  * @mnt_server: address and pmap arguments of mountd service
851  * @msock: returns a file descriptor of the underlying transport socket
852  *
853  * Returns an active handle for the remote's mountd service
854  */
855 CLIENT *mnt_openclnt(clnt_addr_t *mnt_server, int *msock)
856 {
857         struct sockaddr_in *mnt_saddr = &mnt_server->saddr;
858         struct pmap *mnt_pmap = &mnt_server->pmap;
859         CLIENT *clnt = NULL;
860
861         mnt_saddr->sin_port = htons((u_short)mnt_pmap->pm_port);
862         *msock = get_socket(mnt_saddr, mnt_pmap->pm_prot, MOUNT_TIMEOUT,
863                                 TRUE, FALSE);
864         if (*msock == RPC_ANYSOCK) {
865                 if (rpc_createerr.cf_error.re_errno == EADDRINUSE)
866                         /*
867                          * Probably in-use by a TIME_WAIT connection,
868                          * It is worth waiting a while and trying again.
869                          */
870                         rpc_createerr.cf_stat = RPC_TIMEDOUT;
871                 return NULL;
872         }
873
874         switch (mnt_pmap->pm_prot) {
875         case IPPROTO_UDP:
876                 clnt = clntudp_bufcreate(mnt_saddr,
877                                          mnt_pmap->pm_prog, mnt_pmap->pm_vers,
878                                          RETRY_TIMEOUT, msock,
879                                          MNT_SENDBUFSIZE, MNT_RECVBUFSIZE);
880                 break;
881         case IPPROTO_TCP:
882                 clnt = clnttcp_create(mnt_saddr,
883                                       mnt_pmap->pm_prog, mnt_pmap->pm_vers,
884                                       msock,
885                                       MNT_SENDBUFSIZE, MNT_RECVBUFSIZE);
886                 break;
887         }
888         if (clnt) {
889                 /* try to mount hostname:dirname */
890                 clnt->cl_auth = authunix_create_default();
891                 return clnt;
892         }
893         return NULL;
894 }
895
896 /**
897  * mnt_closeclnt - terminate a handle for a remote mountd service
898  * @clnt: pointer to an active handle for a remote mountd service
899  * @msock: file descriptor of the underlying transport socket
900  *
901  */
902 void mnt_closeclnt(CLIENT *clnt, int msock)
903 {
904         auth_destroy(clnt->cl_auth);
905         clnt_destroy(clnt);
906         close(msock);
907 }
908
909 /**
910  * clnt_ping - send an RPC ping to the remote RPC service endpoint
911  * @saddr: server's address
912  * @prog: target RPC program number
913  * @vers: target RPC version number
914  * @prot: target RPC protocol
915  * @caddr: filled in with our network address
916  *
917  * Sigh... GETPORT queries don't actually check the version number.
918  * In order to make sure that the server actually supports the service
919  * we're requesting, we open an RPC client, and fire off a NULL
920  * RPC call.
921  *
922  * caddr is the network address that the server will use to call us back.
923  * On multi-homed clients, this address depends on which NIC we use to
924  * route requests to the server.
925  *
926  * Returns one if successful, otherwise zero.
927  */
928 int clnt_ping(struct sockaddr_in *saddr, const unsigned long prog,
929                 const unsigned long vers, const unsigned int prot,
930                 struct sockaddr_in *caddr)
931 {
932         CLIENT *clnt = NULL;
933         int sock, stat;
934         static char clnt_res;
935         struct sockaddr dissolve;
936
937         rpc_createerr.cf_stat = stat = 0;
938         sock = get_socket(saddr, prot, CONNECT_TIMEOUT, FALSE, TRUE);
939         if (sock == RPC_ANYSOCK) {
940                 if (rpc_createerr.cf_error.re_errno == ETIMEDOUT) {
941                         /*
942                          * TCP timeout. Bubble up the error to see 
943                          * how it should be handled.
944                          */
945                         rpc_createerr.cf_stat = RPC_TIMEDOUT;
946                 }
947                 return 0;
948         }
949
950         if (caddr) {
951                 /* Get the address of our end of this connection */
952                 socklen_t len = sizeof(*caddr);
953                 if (getsockname(sock, caddr, &len) != 0)
954                         caddr->sin_family = 0;
955         }
956
957         switch(prot) {
958         case IPPROTO_UDP:
959                 /* The socket is connected (so we could getsockname successfully),
960                  * but some servers on multi-homed hosts reply from
961                  * the wrong address, so if we stay connected, we lose the reply.
962                  */
963                 dissolve.sa_family = AF_UNSPEC;
964                 connect(sock, &dissolve, sizeof(dissolve));
965
966                 clnt = clntudp_bufcreate(saddr, prog, vers,
967                                          RETRY_TIMEOUT, &sock,
968                                          RPCSMALLMSGSIZE, RPCSMALLMSGSIZE);
969                 break;
970         case IPPROTO_TCP:
971                 clnt = clnttcp_create(saddr, prog, vers, &sock,
972                                       RPCSMALLMSGSIZE, RPCSMALLMSGSIZE);
973                 break;
974         }
975         if (!clnt) {
976                 close(sock);
977                 return 0;
978         }
979         memset(&clnt_res, 0, sizeof(clnt_res));
980         stat = clnt_call(clnt, NULLPROC,
981                          (xdrproc_t)xdr_void, (caddr_t)NULL,
982                          (xdrproc_t)xdr_void, (caddr_t)&clnt_res,
983                          TIMEOUT);
984         if (stat) {
985                 clnt_geterr(clnt, &rpc_createerr.cf_error);
986                 rpc_createerr.cf_stat = stat;
987         }
988         clnt_destroy(clnt);
989         close(sock);
990
991         if (stat == RPC_SUCCESS)
992                 return 1;
993         else
994                 return 0;
995 }
996
997 /*
998  * Try a getsockname() on a connected datagram socket.
999  *
1000  * Returns 1 and fills in @buf if successful; otherwise, zero.
1001  *
1002  * A connected datagram socket prevents leaving a socket in TIME_WAIT.
1003  * This conserves the ephemeral port number space, helping reduce failed
1004  * socket binds during mount storms.
1005  */
1006 static int nfs_ca_sockname(const struct sockaddr *sap, const socklen_t salen,
1007                            struct sockaddr *buf, socklen_t *buflen)
1008 {
1009         struct sockaddr_in sin = {
1010                 .sin_family             = AF_INET,
1011                 .sin_addr.s_addr        = htonl(INADDR_ANY),
1012         };
1013         struct sockaddr_in6 sin6 = {
1014                 .sin6_family            = AF_INET6,
1015                 .sin6_addr              = IN6ADDR_ANY_INIT,
1016         };
1017         int sock;
1018
1019         sock = socket(sap->sa_family, SOCK_DGRAM, IPPROTO_UDP);
1020         if (sock < 0)
1021                 return 0;
1022
1023         switch (sap->sa_family) {
1024         case AF_INET:
1025                 if (bind(sock, (struct sockaddr *)&sin, sizeof(sin)) < 0) {
1026                         close(sock);
1027                         return 0;
1028                 }
1029                 break;
1030         case AF_INET6:
1031                 if (bind(sock, (struct sockaddr *)&sin6, sizeof(sin6)) < 0) {
1032                         close(sock);
1033                         return 0;
1034                 }
1035                 break;
1036         default:
1037                 errno = EAFNOSUPPORT;
1038                 return 0;
1039         }
1040
1041         if (connect(sock, sap, salen) < 0) {
1042                 close(sock);
1043                 return 0;
1044         }
1045
1046         return !getsockname(sock, buf, buflen);
1047 }
1048
1049 /*
1050  * Try to generate an address that prevents the server from calling us.
1051  *
1052  * Returns 1 and fills in @buf if successful; otherwise, zero.
1053  */
1054 static int nfs_ca_gai(const struct sockaddr *sap, const socklen_t salen,
1055                       struct sockaddr *buf, socklen_t *buflen)
1056 {
1057         struct addrinfo *gai_results;
1058         struct addrinfo gai_hint = {
1059                 .ai_family      = sap->sa_family,
1060                 .ai_flags       = AI_PASSIVE,   /* ANYADDR */
1061         };
1062
1063         if (getaddrinfo(NULL, "", &gai_hint, &gai_results))
1064                 return 0;
1065
1066         *buflen = gai_results->ai_addrlen;
1067         memcpy(buf, gai_results->ai_addr, *buflen);
1068
1069         freeaddrinfo(gai_results);
1070
1071         return 1;
1072 }
1073
1074 /**
1075  * nfs_callback_address - acquire our local network address
1076  * @sap: pointer to address of remote
1077  * @sap_len: length of address
1078  * @buf: pointer to buffer to be filled in with local network address
1079  * @buflen: IN: length of buffer to fill in; OUT: length of filled-in address
1080  *
1081  * Discover a network address that an NFSv4 server can use to call us back.
1082  * On multi-homed clients, this address depends on which NIC we use to
1083  * route requests to the server.
1084  *
1085  * Returns 1 and fills in @buf if an unambiguous local address is
1086  * available; returns 1 and fills in an appropriate ANYADDR address
1087  * if a local address isn't available; otherwise, returns zero.
1088  */
1089 int nfs_callback_address(const struct sockaddr *sap, const socklen_t salen,
1090                          struct sockaddr *buf, socklen_t *buflen)
1091 {
1092         struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)buf;
1093
1094         if (nfs_ca_sockname(sap, salen, buf, buflen) == 0)
1095                 if (nfs_ca_gai(sap, salen, buf, buflen) == 0)
1096                         goto out_failed;
1097
1098         /*
1099          * The server can't use an interface ID that was generated
1100          * here on the client, so always clear sin6_scope_id.
1101          */
1102         if (sin6->sin6_family == AF_INET6)
1103                 sin6->sin6_scope_id = 0;
1104
1105         return 1;
1106
1107 out_failed:
1108         *buflen = 0;
1109         if (verbose)
1110                 nfs_error(_("%s: failed to construct callback address"));
1111         return 0;
1112
1113 }