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