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