Imported Upstream version 1.2.3
[nfs-utils.git] / support / nfs / getport.c
1 /*
2  * Provide a variety of APIs that query an rpcbind daemon to
3  * discover RPC service ports and allowed protocol version
4  * numbers.
5  *
6  * Copyright (C) 2008 Oracle Corporation.  All rights reserved.
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public
10  * License as published by the Free Software Foundation; either
11  * version 2 of the License, or (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public
19  * License along with this program; if not, write to the
20  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
21  * Boston, MA 021110-1307, USA.
22  *
23  */
24
25 #ifdef HAVE_CONFIG_H
26 #include <config.h>
27 #endif
28
29 #include <sys/types.h>
30 #include <sys/time.h>
31 #include <unistd.h>
32 #include <fcntl.h>
33 #include <errno.h>
34
35 #include <sys/socket.h>
36 #include <netinet/in.h>
37 #include <netdb.h>
38 #include <arpa/inet.h>
39
40 #include <rpc/rpc.h>
41 #include <rpc/pmap_prot.h>
42
43 #ifdef HAVE_LIBTIRPC
44 #include <netconfig.h>
45 #include <rpc/rpcb_prot.h>
46 #endif
47
48 #include "sockaddr.h"
49 #include "nfsrpc.h"
50
51 /*
52  * Try a local socket first to access the local rpcbind daemon
53  *
54  * Rpcbind's local socket service does not seem to be working.
55  * Disable this logic for now.
56  */
57 #ifdef HAVE_LIBTIRPC
58 #undef NFS_GP_LOCAL
59 #else   /* !HAVE_LIBTIRPC */
60 #undef NFS_GP_LOCAL
61 #endif  /* !HAVE_LIBTIRPC */
62
63 #ifdef HAVE_LIBTIRPC
64 static const rpcvers_t default_rpcb_version = RPCBVERS_4;
65 #else   /* !HAVE_LIBTIRPC */
66 static const rpcvers_t default_rpcb_version = PMAPVERS;
67 #endif  /* !HAVE_LIBTIRPC */
68
69 /*
70  * Historical: Map TCP connect timeouts to timeout
71  * error code used by UDP.
72  */
73 static void
74 nfs_gp_map_tcp_errorcodes(const unsigned short protocol)
75 {
76         if (protocol != IPPROTO_TCP)
77                 return;
78
79         switch (rpc_createerr.cf_error.re_errno) {
80         case ETIMEDOUT:
81                 rpc_createerr.cf_stat = RPC_TIMEDOUT;
82                 break;
83         case ECONNREFUSED:
84                 rpc_createerr.cf_stat = RPC_CANTRECV;
85                 break;
86         }
87 }
88
89 /*
90  * There's no easy way to tell how the local system's networking
91  * and rpcbind is configured (ie. whether we want to use IPv6 or
92  * IPv4 loopback to contact RPC services on the local host).  We
93  * punt and simply try to look up "localhost".
94  *
95  * Returns TRUE on success.
96  */
97 static int nfs_gp_loopback_address(struct sockaddr *sap, socklen_t *salen)
98 {
99         struct addrinfo *gai_results;
100         int ret = 0;
101
102         if (getaddrinfo("localhost", NULL, NULL, &gai_results))
103                 return 0;
104
105         if (*salen >= gai_results->ai_addrlen) {
106                 memcpy(sap, gai_results->ai_addr,
107                                 gai_results->ai_addrlen);
108                 *salen = gai_results->ai_addrlen;
109                 ret = 1;
110         }
111
112         freeaddrinfo(gai_results);
113         return ret;
114 }
115
116 /*
117  * Look up a network service in /etc/services and return the
118  * network-order port number of that service.
119  */
120 static in_port_t nfs_gp_getservbyname(const char *service,
121                                       const unsigned short protocol)
122 {
123         const struct addrinfo gai_hint = {
124                 .ai_family      = AF_INET,
125                 .ai_protocol    = protocol,
126                 .ai_flags       = AI_PASSIVE,
127         };
128         struct addrinfo *gai_results;
129         const struct sockaddr_in *sin;
130         in_port_t port;
131
132         if (getaddrinfo(NULL, service, &gai_hint, &gai_results) != 0)
133                 return 0;
134
135         sin = (const struct sockaddr_in *)gai_results->ai_addr;
136         port = sin->sin_port;
137         
138         freeaddrinfo(gai_results);
139         return port;
140 }
141
142 /*
143  * Discover the port number that should be used to contact an
144  * rpcbind service.  This will detect if the port has a local
145  * value that may have been set in /etc/services.
146  *
147  * Returns network byte-order port number of rpcbind service
148  * on this system.
149  */
150 static in_port_t nfs_gp_get_rpcb_port(const unsigned short protocol)
151 {
152         static const char *rpcb_netnametbl[] = {
153                 "rpcbind",
154                 "portmapper",
155                 "sunrpc",
156                 NULL,
157         };
158         unsigned int i;
159
160         for (i = 0; rpcb_netnametbl[i] != NULL; i++) {
161                 in_port_t port;
162
163                 port = nfs_gp_getservbyname(rpcb_netnametbl[i], protocol);
164                 if (port != 0)
165                         return port;
166         }
167
168         return (in_port_t)htons((uint16_t)PMAPPORT);
169 }
170
171 /*
172  * Set up an RPC client for communicating with an rpcbind daemon at
173  * @sap over @transport with protocol version @version.
174  *
175  * Returns a pointer to a prepared RPC client if successful, and
176  * @timeout is initialized; caller must destroy a non-NULL returned RPC
177  * client.  Otherwise returns NULL, and rpc_createerr.cf_stat is set to
178  * reflect the error.
179  */
180 static CLIENT *nfs_gp_get_rpcbclient(struct sockaddr *sap,
181                                      const socklen_t salen,
182                                      const unsigned short transport,
183                                      const rpcvers_t version,
184                                      struct timeval *timeout)
185 {
186         static const char *rpcb_pgmtbl[] = {
187                 "rpcbind",
188                 "portmap",
189                 "portmapper",
190                 "sunrpc",
191                 NULL,
192         };
193         rpcprog_t rpcb_prog = nfs_getrpcbyname(RPCBPROG, rpcb_pgmtbl);
194         CLIENT *clnt;
195
196         nfs_set_port(sap, ntohs(nfs_gp_get_rpcb_port(transport)));
197         clnt = nfs_get_rpcclient(sap, salen, transport, rpcb_prog,
198                                                         version, timeout);
199         nfs_gp_map_tcp_errorcodes(transport);
200         return clnt;
201 }
202
203 /**
204  * nfs_get_proto - Convert a netid to an address family and protocol number
205  * @netid: C string containing a netid
206  * @family: OUT: address family
207  * @protocol: OUT: protocol number
208  *
209  * Returns 1 and fills in @protocol if the netid was recognized;
210  * otherwise zero is returned.
211  */
212 #ifdef HAVE_LIBTIRPC
213 int
214 nfs_get_proto(const char *netid, sa_family_t *family, unsigned long *protocol)
215 {
216         struct netconfig *nconf;
217         struct protoent *proto;
218
219         /*
220          * IANA does not define a protocol number for rdma netids,
221          * since "rdma" is not an IP protocol.
222          */
223         if (strcmp(netid, "rdma") == 0) {
224                 *family = AF_INET;
225                 *protocol = NFSPROTO_RDMA;
226                 return 1;
227         }
228         if (strcmp(netid, "rdma6") == 0) {
229                 *family = AF_INET6;
230                 *protocol = NFSPROTO_RDMA;
231                 return 1;
232         }
233
234         nconf = getnetconfigent(netid);
235         if (nconf == NULL)
236                 return 0;
237
238         proto = getprotobyname(nconf->nc_proto);
239         if (proto == NULL) {
240                 freenetconfigent(nconf);
241                 return 0;
242         }
243
244         *family = AF_UNSPEC;
245         if (strcmp(nconf->nc_protofmly, NC_INET) == 0)
246                 *family = AF_INET;
247         if (strcmp(nconf->nc_protofmly, NC_INET6) == 0)
248                 *family = AF_INET6;
249         freenetconfigent(nconf);
250
251         *protocol = (unsigned long)proto->p_proto;
252         return 1;
253 }
254 #else   /* !HAVE_LIBTIRPC */
255 int
256 nfs_get_proto(const char *netid, sa_family_t *family, unsigned long *protocol)
257 {
258         struct protoent *proto;
259
260         /*
261          * IANA does not define a protocol number for rdma netids,
262          * since "rdma" is not an IP protocol.
263          */
264         if (strcmp(netid, "rdma") == 0) {
265                 *family = AF_INET;
266                 *protocol = NFSPROTO_RDMA;
267                 return 1;
268         }
269
270         proto = getprotobyname(netid);
271         if (proto == NULL)
272                 return 0;
273
274         *family = AF_INET;
275         *protocol = (unsigned long)proto->p_proto;
276         return 1;
277 }
278 #endif /* !HAVE_LIBTIRPC */
279
280 /**
281  * nfs_get_netid - Convert a protocol family and protocol name to a netid
282  * @family: protocol family
283  * @protocol: protocol number
284  *
285  * One of the arguments passed when querying remote rpcbind services
286  * via rpcbind v3 or v4 is a netid string.  This replaces the pm_prot
287  * field used in legacy PMAP_GETPORT calls.
288  *
289  * RFC 1833 says netids are not standard but rather defined on the local
290  * host.  There are, however, standard definitions for nc_protofmly and
291  * nc_proto that can be used to derive a netid string on the local host,
292  * based on the contents of /etc/netconfig.
293  *
294  * Walk through the local netconfig database and grab the netid of the
295  * first entry that matches @family and @protocol and whose netid string
296  * fits in the provided buffer.
297  *
298  * Returns a '\0'-terminated string if successful.  Caller must
299  * free the returned string.  Otherwise NULL is returned, and
300  * rpc_createerr.cf_stat is set to reflect the error.
301  */
302 #ifdef HAVE_LIBTIRPC
303 char *nfs_get_netid(const sa_family_t family, const unsigned long protocol)
304 {
305         char *nc_protofmly, *nc_proto, *nc_netid;
306         struct netconfig *nconf;
307         struct protoent *proto;
308         void *handle;
309
310         switch (family) {
311         case AF_LOCAL:
312         case AF_INET:
313                 nc_protofmly = NC_INET;
314                 break;
315         case AF_INET6:
316                 nc_protofmly = NC_INET6;
317                 break;
318         default:
319                 goto out;
320         }
321
322         proto = getprotobynumber(protocol);
323         if (proto == NULL)
324                 goto out;
325         nc_proto = proto->p_name;
326
327         handle = setnetconfig();
328         while ((nconf = getnetconfig(handle)) != NULL) {
329
330                 if (nconf->nc_protofmly != NULL &&
331                     strcmp(nconf->nc_protofmly, nc_protofmly) != 0)
332                         continue;
333                 if (nconf->nc_proto != NULL &&
334                     strcmp(nconf->nc_proto, nc_proto) != 0)
335                         continue;
336
337                 nc_netid = strdup(nconf->nc_netid);
338                 endnetconfig(handle);
339
340                 if (nc_netid == NULL)
341                         rpc_createerr.cf_stat = RPC_SYSTEMERROR;
342                 return nc_netid;
343         }
344         endnetconfig(handle);
345
346 out:
347         rpc_createerr.cf_stat = RPC_UNKNOWNPROTO;
348         return NULL;
349 }
350 #else   /* !HAVE_LIBTIRPC */
351 char *nfs_get_netid(const sa_family_t family, const unsigned long protocol)
352 {
353         struct protoent *proto;
354         char *netid;
355
356         if (family != AF_INET)
357                 goto out;
358         proto = getprotobynumber((int)protocol);
359         if (proto == NULL)
360                 goto out;
361
362         netid = strdup(proto->p_name);
363         if (netid == NULL)
364                 rpc_createerr.cf_stat = RPC_SYSTEMERROR;
365         return netid;
366
367 out:
368         rpc_createerr.cf_stat = RPC_UNKNOWNPROTO;
369         return NULL;
370 }
371 #endif  /* !HAVE_LIBTIRPC */
372
373 /*
374  * Extract a port number from a universal address, and terminate the
375  * string in @addrstr just after the address part.
376  *
377  * Returns -1 if unsuccesful; otherwise a decoded port number (possibly 0)
378  * is returned.
379  */
380 static int nfs_gp_universal_porthelper(char *addrstr)
381 {
382         char *p, *endptr;
383         unsigned long portlo, porthi;
384         int port = -1;
385
386         p = strrchr(addrstr, '.');
387         if (p == NULL)
388                 goto out;
389         portlo = strtoul(p + 1, &endptr, 10);
390         if (*endptr != '\0' || portlo > 255)
391                 goto out;
392         *p = '\0';
393
394         p = strrchr(addrstr, '.');
395         if (p == NULL)
396                 goto out;
397         porthi = strtoul(p + 1, &endptr, 10);
398         if (*endptr != '\0' || porthi > 255)
399                 goto out;
400         *p = '\0';
401         port = (porthi << 8) | portlo;
402
403 out:
404         return port;
405 }
406
407 /**
408  * nfs_universal2port - extract port number from a "universal address"
409  * @uaddr: '\0'-terminated C string containing a universal address
410  *
411  * Universal addresses (defined in RFC 1833) are used when calling an
412  * rpcbind daemon via protocol versions 3 or 4..
413  *
414  * Returns -1 if unsuccesful; otherwise a decoded port number (possibly 0)
415  * is returned.
416  */
417 int nfs_universal2port(const char *uaddr)
418 {
419         char *addrstr;
420         int port = -1;
421
422         addrstr = strdup(uaddr);
423         if (addrstr != NULL) {
424                 port = nfs_gp_universal_porthelper(addrstr);
425                 free(addrstr);
426         }
427         return port;
428 }
429
430 /**
431  * nfs_sockaddr2universal - convert a sockaddr to a "universal address"
432  * @sap: pointer to a socket address
433  *
434  * Universal addresses (defined in RFC 1833) are used when calling an
435  * rpcbind daemon via protocol versions 3 or 4..
436  *
437  * Returns a '\0'-terminated string if successful; caller must free
438  * the returned string.  Otherwise NULL is returned and
439  * rpc_createerr.cf_stat is set to reflect the error.
440  *
441  * inet_ntop(3) is used here, since getnameinfo(3) is not available
442  * in some earlier glibc releases, and we don't require support for
443  * scope IDs for universal addresses.
444  */
445 char *nfs_sockaddr2universal(const struct sockaddr *sap)
446 {
447         const struct sockaddr_in6 *sin6 = (const struct sockaddr_in6 *)sap;
448         const struct sockaddr_un *sun = (const struct sockaddr_un *)sap;
449         const struct sockaddr_in *sin = (const struct sockaddr_in *)sap;
450         char buf[INET6_ADDRSTRLEN + 8 /* for port information */];
451         uint16_t port;
452         size_t count;
453         char *result;
454         int len;
455
456         switch (sap->sa_family) {
457         case AF_LOCAL:
458                 return strndup(sun->sun_path, sizeof(sun->sun_path));
459         case AF_INET:
460                 if (inet_ntop(AF_INET, (const void *)&sin->sin_addr.s_addr,
461                                         buf, (socklen_t)sizeof(buf)) == NULL)
462                         goto out_err;
463                 port = ntohs(sin->sin_port);
464                 break;
465         case AF_INET6:
466                 if (inet_ntop(AF_INET6, (const void *)&sin6->sin6_addr,
467                                         buf, (socklen_t)sizeof(buf)) == NULL)
468                         goto out_err;
469                 port = ntohs(sin6->sin6_port);
470                 break;
471         default:
472                 goto out_err;
473         }
474
475         count = sizeof(buf) - strlen(buf);
476         len = snprintf(buf + strlen(buf), count, ".%u.%u",
477                         (unsigned)(port >> 8), (unsigned)(port & 0xff));
478         /* before glibc 2.0.6, snprintf(3) could return -1 */
479         if (len < 0 || (size_t)len > count)
480                 goto out_err;
481
482         result = strdup(buf);
483         if (result != NULL)
484                 return result;
485
486 out_err:
487         rpc_createerr.cf_stat = RPC_N2AXLATEFAILURE;
488         return NULL;
489 }
490
491 /*
492  * Send a NULL request to the indicated RPC service.
493  *
494  * Returns 1 if the service responded; otherwise 0;
495  */
496 static int nfs_gp_ping(CLIENT *client, struct timeval timeout)
497 {
498         enum clnt_stat status;
499
500         status = CLNT_CALL(client, NULLPROC,
501                            (xdrproc_t)xdr_void, NULL,
502                            (xdrproc_t)xdr_void, NULL,
503                            timeout);
504
505         if (status != RPC_SUCCESS) {
506                 rpc_createerr.cf_stat = status;
507                 CLNT_GETERR(client, &rpc_createerr.cf_error);
508         }
509         return (int)(status == RPC_SUCCESS);
510 }
511
512 #ifdef HAVE_LIBTIRPC
513
514 /*
515  * Initialize the rpcb argument for a GETADDR request.
516  *
517  * Returns 1 if successful, and caller must free strings pointed
518  * to by r_netid and r_addr; otherwise 0.
519  */
520 static int nfs_gp_init_rpcb_parms(const struct sockaddr *sap,
521                                   const rpcprog_t program,
522                                   const rpcvers_t version,
523                                   const unsigned short protocol,
524                                   struct rpcb *parms)
525 {
526         char *netid, *addr;
527
528         netid = nfs_get_netid(sap->sa_family, protocol);
529         if (netid == NULL)
530                 return 0;
531
532         addr = nfs_sockaddr2universal(sap);
533         if (addr == NULL) {
534                 free(netid);
535                 return 0;
536         }
537
538         memset(parms, 0, sizeof(*parms));
539         parms->r_prog   = program;
540         parms->r_vers   = version;
541         parms->r_netid  = netid;
542         parms->r_addr   = addr;
543         parms->r_owner  = "";
544
545         return 1;
546 }
547
548 static void nfs_gp_free_rpcb_parms(struct rpcb *parms)
549 {
550         free(parms->r_netid);
551         free(parms->r_addr);
552 }
553
554 /*
555  * Try rpcbind GETADDR via version 4.  If that fails, try same
556  * request via version 3.
557  *
558  * Returns non-zero port number on success; otherwise returns
559  * zero.  rpccreateerr is set to reflect the nature of the error.
560  */
561 static unsigned short nfs_gp_rpcb_getaddr(CLIENT *client,
562                                           struct rpcb *parms,
563                                           struct timeval timeout)
564 {
565         rpcvers_t rpcb_version;
566         struct rpc_err rpcerr;
567         int port = 0;
568
569         for (rpcb_version = RPCBVERS_4;
570              rpcb_version >= RPCBVERS_3;
571              rpcb_version--) {
572                 enum clnt_stat status;
573                 char *uaddr = NULL;
574
575                 CLNT_CONTROL(client, CLSET_VERS, (void *)&rpcb_version);
576                 status = CLNT_CALL(client, (rpcproc_t)RPCBPROC_GETADDR,
577                                    (xdrproc_t)xdr_rpcb, (void *)parms,
578                                    (xdrproc_t)xdr_wrapstring, (void *)&uaddr,
579                                    timeout);
580
581                 switch (status) {
582                 case RPC_SUCCESS:
583                         if ((uaddr == NULL) || (uaddr[0] == '\0')) {
584                                 rpc_createerr.cf_stat = RPC_PROGNOTREGISTERED;
585                                 return 0;
586                         }
587
588                         port = nfs_universal2port(uaddr);
589                         xdr_free((xdrproc_t)xdr_wrapstring, (char *)&uaddr);
590                         if (port == -1) {
591                                 rpc_createerr.cf_stat = RPC_N2AXLATEFAILURE;
592                                 return 0;
593                         }
594                         return (unsigned short)port;
595                 case RPC_PROGVERSMISMATCH:
596                         clnt_geterr(client, &rpcerr);
597                         if (rpcerr.re_vers.low > RPCBVERS4)
598                                 return 0;
599                         continue;
600                 case RPC_PROCUNAVAIL:
601                 case RPC_PROGUNAVAIL:
602                         continue;
603                 default:
604                         /* Most likely RPC_TIMEDOUT or RPC_CANTRECV */
605                         rpc_createerr.cf_stat = status;
606                         clnt_geterr(client, &rpc_createerr.cf_error);
607                         return 0;
608                 }
609
610         }
611
612         if (port == 0) {
613                 rpc_createerr.cf_stat = RPC_PROGNOTREGISTERED;
614                 clnt_geterr(client, &rpc_createerr.cf_error);
615         }
616         return port;
617 }
618
619 #endif  /* HAVE_LIBTIRPC */
620
621 /*
622  * Try GETPORT request via rpcbind version 2.
623  *
624  * Returns non-zero port number on success; otherwise returns
625  * zero.  rpccreateerr is set to reflect the nature of the error.
626  */
627 static unsigned long nfs_gp_pmap_getport(CLIENT *client,
628                                          struct pmap *parms,
629                                          struct timeval timeout)
630 {
631         enum clnt_stat status;
632         unsigned long port;
633
634         status = CLNT_CALL(client, (rpcproc_t)PMAPPROC_GETPORT,
635                            (xdrproc_t)xdr_pmap, (void *)parms,
636                            (xdrproc_t)xdr_u_long, (void *)&port,
637                            timeout);
638
639         if (status != RPC_SUCCESS) {
640                 rpc_createerr.cf_stat = status;
641                 CLNT_GETERR(client, &rpc_createerr.cf_error);
642                 port = 0;
643         } else if (port == 0)
644                 rpc_createerr.cf_stat = RPC_PROGNOTREGISTERED;
645
646         return port;
647 }
648
649 #ifdef HAVE_LIBTIRPC
650
651 static unsigned short nfs_gp_getport_rpcb(CLIENT *client,
652                                           const struct sockaddr *sap,
653                                           const rpcprog_t program,
654                                           const rpcvers_t version,
655                                           const unsigned short protocol,
656                                           struct timeval timeout)
657 {
658         unsigned short port = 0;
659         struct rpcb parms;
660
661         if (nfs_gp_init_rpcb_parms(sap, program, version,
662                                         protocol, &parms) != 0) {
663                 port = nfs_gp_rpcb_getaddr(client, &parms, timeout);
664                 nfs_gp_free_rpcb_parms(&parms);
665         }
666
667         return port;
668 }
669
670 #endif  /* HAVE_LIBTIRPC */
671
672 static unsigned long nfs_gp_getport_pmap(CLIENT *client,
673                                          const rpcprog_t program,
674                                          const rpcvers_t version,
675                                          const unsigned short protocol,
676                                          struct timeval timeout)
677 {
678         struct pmap parms = {
679                 .pm_prog        = program,
680                 .pm_vers        = version,
681                 .pm_prot        = protocol,
682         };
683         rpcvers_t pmap_version = PMAPVERS;
684
685         CLNT_CONTROL(client, CLSET_VERS, (void *)&pmap_version);
686         return nfs_gp_pmap_getport(client, &parms, timeout);
687 }
688
689 /*
690  * Try an AF_INET6 request via rpcbind v4/v3; try an AF_INET
691  * request via rpcbind v2.
692  *
693  * Returns non-zero port number on success; otherwise returns
694  * zero.  rpccreateerr is set to reflect the nature of the error.
695  */
696 static unsigned short nfs_gp_getport(CLIENT *client,
697                                      const struct sockaddr *sap,
698                                      const rpcprog_t program,
699                                      const rpcvers_t version,
700                                      const unsigned short protocol,
701                                      struct timeval timeout)
702 {
703         switch (sap->sa_family) {
704 #ifdef HAVE_LIBTIRPC
705         case AF_INET6:
706                 return nfs_gp_getport_rpcb(client, sap, program,
707                                                 version, protocol, timeout);
708 #endif  /* HAVE_LIBTIRPC */
709         case AF_INET:
710                 return nfs_gp_getport_pmap(client, program, version,
711                                                         protocol, timeout);
712         }
713
714         rpc_createerr.cf_stat = RPC_UNKNOWNADDR;
715         return 0;
716 }
717
718 /**
719  * nfs_rpc_ping - Determine if RPC service is responding to requests
720  * @sap: pointer to address of server to query (port is already filled in)
721  * @salen: length of server address
722  * @program: requested RPC program number
723  * @version: requested RPC version number
724  * @protocol: requested IPPROTO_ value of transport protocol
725  * @timeout: pointer to request timeout (NULL means use default timeout)
726  *
727  * Returns 1 if the remote service responded without an error; otherwise
728  * zero.
729  */
730 int nfs_rpc_ping(const struct sockaddr *sap, const socklen_t salen,
731                  const rpcprog_t program, const rpcvers_t version,
732                  const unsigned short protocol, const struct timeval *timeout)
733 {
734         union nfs_sockaddr address;
735         struct sockaddr *saddr = &address.sa;
736         CLIENT *client;
737         struct timeval tout = { -1, 0 };
738         int result = 0;
739
740         if (timeout != NULL)
741                 tout = *timeout;
742
743         nfs_clear_rpc_createerr();
744
745         memcpy(saddr, sap, (size_t)salen);
746         client = nfs_get_rpcclient(saddr, salen, protocol,
747                                                 program, version, &tout);
748         if (client != NULL) {
749                 result = nfs_gp_ping(client, tout);
750                 nfs_gp_map_tcp_errorcodes(protocol);
751                 CLNT_DESTROY(client);
752         }
753
754         return result;
755 }
756
757 /**
758  * nfs_getport - query server's rpcbind to get port number for an RPC service
759  * @sap: pointer to address of server to query
760  * @salen: length of server's address
761  * @program: requested RPC program number
762  * @version: requested RPC version number
763  * @protocol: IPPROTO_ value of requested transport protocol
764  *
765  * Uses any acceptable rpcbind version to discover the port number for the
766  * RPC service described by the given [program, version, transport] tuple.
767  * Uses a quick timeout and an ephemeral source port.  Supports AF_INET and
768  * AF_INET6 server addresses.
769  *
770  * Returns a positive integer representing the port number of the RPC
771  * service advertised by the server (in host byte order), or zero if the
772  * service is not advertised or there was some problem querying the server's
773  * rpcbind daemon.  rpccreateerr is set to reflect the underlying cause of
774  * the error.
775  *
776  * There are a variety of ways to choose which transport and rpcbind versions
777  * to use.  We chose to conserve local resources and try to avoid incurring
778  * timeouts.
779  *
780  * Transport
781  * To provide rudimentary support for traversing firewalls, query the remote
782  * using the same transport as the requested service.  This provides some
783  * guarantee that the requested transport is available between this client
784  * and the server, and if the caller specifically requests TCP, for example,
785  * this may be becuase a firewall is in place that blocks UDP traffic.  We
786  * could try both, but that could involve a lengthy timeout in several cases,
787  * and would often consume an extra ephemeral port.
788  *
789  * Rpcbind version
790  * To avoid using up too many ephemeral ports, AF_INET queries use tried-and-
791  * true rpcbindv2, and don't try the newer versions; and AF_INET6 queries use
792  * rpcbindv4, then rpcbindv3 on the same socket.  The newer rpcbind protocol
793  * versions can adequately detect if a remote RPC service does not support
794  * AF_INET6 at all.  The rpcbind socket is re-used in an attempt to keep the
795  * overall number of consumed ephemeral ports low.
796  */
797 unsigned short nfs_getport(const struct sockaddr *sap,
798                            const socklen_t salen,
799                            const rpcprog_t program,
800                            const rpcvers_t version,
801                            const unsigned short protocol)
802 {
803         union nfs_sockaddr address;
804         struct sockaddr *saddr = &address.sa;
805         struct timeval timeout = { -1, 0 };
806         unsigned short port = 0;
807         CLIENT *client;
808
809         nfs_clear_rpc_createerr();
810
811         memcpy(saddr, sap, (size_t)salen);
812         client = nfs_gp_get_rpcbclient(saddr, salen, protocol,
813                                                 default_rpcb_version, &timeout);
814         if (client != NULL) {
815                 port = nfs_gp_getport(client, saddr, program,
816                                         version, protocol, timeout);
817                 CLNT_DESTROY(client);
818         }
819
820         return port;
821 }
822
823 /**
824  * nfs_getport_ping - query server's rpcbind and do RPC ping to verify result
825  * @sap: IN: pointer to address of server to query;
826  *       OUT: pointer to updated address
827  * @salen: length of server's address
828  * @program: requested RPC program number
829  * @version: requested RPC version number
830  * @protocol: IPPROTO_ value of requested transport protocol
831  *
832  * Uses any acceptable rpcbind version to discover the port number for the
833  * RPC service described by the given [program, version, transport] tuple.
834  * Uses a quick timeout and an ephemeral source port.  Supports AF_INET and
835  * AF_INET6 server addresses.
836  *
837  * Returns a 1 and sets the port number in the passed-in server address
838  * if both the query and the ping were successful; otherwise zero.
839  * rpccreateerr is set to reflect the underlying cause of the error.
840  */
841 int nfs_getport_ping(struct sockaddr *sap, const socklen_t salen,
842                      const rpcprog_t program, const rpcvers_t version,
843                      const unsigned short protocol)
844 {
845         struct timeval timeout = { -1, 0 };
846         unsigned short port = 0;
847         CLIENT *client;
848         int result = 0;
849         
850         nfs_clear_rpc_createerr();
851
852         client = nfs_gp_get_rpcbclient(sap, salen, protocol,
853                                                 default_rpcb_version, &timeout);
854         if (client != NULL) {
855                 port = nfs_gp_getport(client, sap, program,
856                                         version, protocol, timeout);
857                 CLNT_DESTROY(client);
858                 client = NULL;
859         }
860
861         if (port != 0) {
862                 union nfs_sockaddr address;
863                 struct sockaddr *saddr = &address.sa;
864
865                 memcpy(saddr, sap, (size_t)salen);
866                 nfs_set_port(saddr, port);
867
868                 nfs_clear_rpc_createerr();
869
870                 client = nfs_get_rpcclient(saddr, salen, protocol,
871                                                 program, version, &timeout);
872                 if (client != NULL) {
873                         result = nfs_gp_ping(client, timeout);
874                         nfs_gp_map_tcp_errorcodes(protocol);
875                         CLNT_DESTROY(client);
876                 }
877         }
878
879         if (result)
880                 nfs_set_port(sap, port);
881
882         return result;
883 }
884
885 /**
886  * nfs_getlocalport - query local rpcbind to get port number for an RPC service
887  * @program: requested RPC program number
888  * @version: requested RPC version number
889  * @protocol: IPPROTO_ value of requested transport protocol
890  *
891  * Uses any acceptable rpcbind version to discover the port number for the
892  * RPC service described by the given [program, version, transport] tuple.
893  * Uses a quick timeout and an ephemeral source port.  Supports AF_INET and
894  * AF_INET6 local addresses.
895  *
896  * Returns a positive integer representing the port number of the RPC
897  * service advertised by the server (in host byte order), or zero if the
898  * service is not advertised or there was some problem querying the server's
899  * rpcbind daemon.  rpccreateerr is set to reflect the underlying cause of
900  * the error.
901  *
902  * Try an AF_LOCAL connection first.  The rpcbind daemon implementation should
903  * listen on AF_LOCAL.
904  *
905  * If that doesn't work (for example, if portmapper is running, or rpcbind
906  * isn't listening on /var/run/rpcbind.sock), send a query via UDP to localhost
907  * (UDP doesn't leave a socket in TIME_WAIT, and the timeout is a relatively
908  * short 3 seconds).
909  */
910 unsigned short nfs_getlocalport(const rpcprot_t program,
911                                 const rpcvers_t version,
912                                 const unsigned short protocol)
913 {
914         union nfs_sockaddr address;
915         struct sockaddr *lb_addr = &address.sa;
916         socklen_t lb_len = sizeof(*lb_addr);
917         unsigned short port = 0;
918
919 #ifdef NFS_GP_LOCAL
920         const struct sockaddr_un sun = {
921                 .sun_family     = AF_LOCAL,
922                 .sun_path       = _PATH_RPCBINDSOCK,
923         };
924         const struct sockaddr *sap = (struct sockaddr *)&sun;
925         const socklen_t salen = SUN_LEN(&sun);
926         CLIENT *client;
927         struct timeval timeout = { -1, 0 };
928
929         nfs_clear_rpc_createerr();
930
931         client = nfs_gp_get_rpcbclient(sap, salen, 0, RPCBVERS_4, &timeout);
932         if (client != NULL) {
933                 struct rpcb parms;
934
935                 if (nfs_gp_init_rpcb_parms(sap, program, version,
936                                                 protocol, &parms) != 0) {
937                         port = nfs_gp_rpcb_getaddr(client, &parms, timeout);
938                         nfs_gp_free_rpcb_parms(&parms);
939                 }
940                 CLNT_DESTROY(client);
941         }
942 #endif  /* NFS_GP_LOCAL */
943
944         if (port == 0) {
945                 nfs_clear_rpc_createerr();
946
947                 if (nfs_gp_loopback_address(lb_addr, &lb_len)) {
948                         port = nfs_getport(lb_addr, lb_len,
949                                                 program, version, protocol);
950                 } else
951                         rpc_createerr.cf_stat = RPC_UNKNOWNADDR;
952         }
953
954         return port;
955 }
956
957 /**
958  * nfs_rpcb_getaddr - query rpcbind via rpcbind versions 4 and 3
959  * @sap: pointer to address of server to query
960  * @salen: length of server address
961  * @transport: transport protocol to use for the query
962  * @addr: pointer to r_addr address
963  * @program: requested RPC program number
964  * @version: requested RPC version number
965  * @protocol: requested IPPROTO_ value of transport protocol
966  * @timeout: pointer to request timeout (NULL means use default timeout)
967  *
968  * Returns a positive integer representing the port number of the RPC
969  * service advertised by the server (in host byte order), or zero if the
970  * service is not advertised or there was some problem querying the
971  * server's rpcbind daemon.  rpccreateerr is set to reflect the
972  * underlying cause of the error.
973  *
974  * This function provides similar functionality to nfs_pmap_getport(),
975  * but performs the rpcbind lookup via rpcbind version 4.  If the server
976  * doesn't support rpcbind version 4, it will retry with version 3.
977  * The GETADDR procedure is exactly the same in these two versions of
978  * the rpcbind protocol, so the socket, RPC client, and arguments are
979  * re-used when retrying, saving ephemeral port space.
980  *
981  * These RPC procedures take a universal address as an argument, so the
982  * query will fail if the remote rpcbind daemon doesn't find an entry
983  * with a matching address.  A matching address includes an ANYADDR
984  * address of the same address family.  In this way an RPC server can
985  * advertise via rpcbind that it does not support AF_INET6.
986  */
987 #ifdef HAVE_LIBTIRPC
988
989 unsigned short nfs_rpcb_getaddr(const struct sockaddr *sap,
990                                 const socklen_t salen,
991                                 const unsigned short transport,
992                                 const struct sockaddr *addr,
993                                 const rpcprog_t program,
994                                 const rpcvers_t version,
995                                 const unsigned short protocol,
996                                 const struct timeval *timeout)
997 {
998         union nfs_sockaddr address;
999         struct sockaddr *saddr = &address.sa;
1000         CLIENT *client;
1001         struct rpcb parms;
1002         struct timeval tout = { -1, 0 };
1003         unsigned short port = 0;
1004
1005         if (timeout != NULL)
1006                 tout = *timeout;
1007
1008         nfs_clear_rpc_createerr();
1009
1010         memcpy(saddr, sap, (size_t)salen);
1011         client = nfs_gp_get_rpcbclient(saddr, salen, transport,
1012                                                         RPCBVERS_4, &tout);
1013         if (client != NULL) {
1014                 if (nfs_gp_init_rpcb_parms(addr, program, version,
1015                                                 protocol, &parms) != 0) {
1016                         port = nfs_gp_rpcb_getaddr(client, &parms, tout);
1017                         nfs_gp_free_rpcb_parms(&parms);
1018                 }
1019                 CLNT_DESTROY(client);
1020         }
1021
1022         return port;
1023 }
1024
1025 #else   /* !HAVE_LIBTIRPC */
1026
1027 unsigned short nfs_rpcb_getaddr(__attribute__((unused)) const struct sockaddr *sap,
1028                                 __attribute__((unused)) const socklen_t salen,
1029                                 __attribute__((unused)) const unsigned short transport,
1030                                 __attribute__((unused)) const struct sockaddr *addr,
1031                                 __attribute__((unused)) const rpcprog_t program,
1032                                 __attribute__((unused)) const rpcvers_t version,
1033                                 __attribute__((unused)) const unsigned short protocol,
1034                                 __attribute__((unused)) const struct timeval *timeout)
1035 {
1036         nfs_clear_rpc_createerr();
1037
1038         rpc_createerr.cf_stat = RPC_UNKNOWNADDR;
1039         return 0;
1040 }
1041
1042 #endif  /* !HAVE_LIBTIRPC */
1043
1044 /**
1045  * nfs_pmap_getport - query rpcbind via the portmap protocol (rpcbindv2)
1046  * @sin: pointer to AF_INET address of server to query
1047  * @transport: transport protocol to use for the query
1048  * @program: requested RPC program number
1049  * @version: requested RPC version number
1050  * @protocol: requested IPPROTO_ value of transport protocol
1051  * @timeout: pointer to request timeout (NULL means use default timeout)
1052  *
1053  * Returns a positive integer representing the port number of the RPC service
1054  * advertised by the server (in host byte order), or zero if the service is
1055  * not advertised or there was some problem querying the server's rpcbind
1056  * daemon.  rpccreateerr is set to reflect the underlying cause of the error.
1057  *
1058  * nfs_pmap_getport() is very similar to pmap_getport(), except that:
1059  *
1060  *  1.  This version always tries to use an ephemeral port, since reserved
1061  *      ports are not needed for GETPORT queries.  This conserves the very
1062  *      limited reserved port space, helping reduce failed socket binds
1063  *      during mount storms.
1064  *
1065  *  2.  This version times out quickly by default.  It time-limits the
1066  *      connect process as well as the actual RPC call, and even allows the
1067  *      caller to specify the timeout.
1068  *
1069  *  3.  This version shares code with the rpcbindv3 and rpcbindv4 query
1070  *      functions.  It can use a TI-RPC generated CLIENT.
1071  */
1072 unsigned long nfs_pmap_getport(const struct sockaddr_in *sin,
1073                                const unsigned short transport,
1074                                const unsigned long program,
1075                                const unsigned long version,
1076                                const unsigned long protocol,
1077                                const struct timeval *timeout)
1078 {
1079         struct sockaddr_in address;
1080         struct sockaddr *saddr = (struct sockaddr *)&address;
1081         CLIENT *client;
1082         struct pmap parms = {
1083                 .pm_prog        = program,
1084                 .pm_vers        = version,
1085                 .pm_prot        = protocol,
1086         };
1087         struct timeval tout = { -1, 0 };
1088         unsigned long port = 0;
1089
1090         if (timeout != NULL)
1091                 tout = *timeout;
1092
1093         nfs_clear_rpc_createerr();
1094
1095         memcpy(saddr, sin, sizeof(address));
1096         client = nfs_gp_get_rpcbclient(saddr, (socklen_t)sizeof(*sin),
1097                                         transport, PMAPVERS, &tout);
1098         if (client != NULL) {
1099                 port = nfs_gp_pmap_getport(client, &parms, tout);
1100                 CLNT_DESTROY(client);
1101         }
1102
1103         return port;
1104 }