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, FALSE);
 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_PROGVERSMISMATCH)
 558                         goto out_bad;
 559
 560                 if (!prot) {
 561                         if (*++p_prot)
 562                                 continue;
 563                         p_prot = protos;
 564                 }
 565                 if (rpc_createerr.cf_stat == RPC_TIMEDOUT)
 566                         goto out_bad;
 567
 568                 if (vers || !*++p_vers)
 569                         break;
 570         }
 571
 572 out_bad:
 573         return 0;
 574
 575 out_ok:
 576         if (!vers)
 577                 pmap->pm_vers = *p_vers;
 578         if (!prot)
 579                 pmap->pm_prot = *p_prot;
 580         if (!port)
 581                 pmap->pm_port = p_port;
 582         rpc_createerr.cf_stat = 0;
 583         return 1;
 584 }
 585
 586 static int probe_nfsport(clnt_addr_t *nfs_server)
 587 {
 588         struct pmap *pmap = &nfs_server->pmap;
 589
 590         if (pmap->pm_vers && pmap->pm_prot && pmap->pm_port)
 591                 return 1;
 592
 593         if (nfs_mount_data_version >= 4)
 594                 return probe_port(nfs_server, probe_nfs3_first, probe_tcp_first);
 595         else
 596                 return probe_port(nfs_server, probe_nfs2_only, probe_udp_only);
 597 }
 598
 599 static int probe_mntport(clnt_addr_t *mnt_server)
 600 {
 601         struct pmap *pmap = &mnt_server->pmap;
 602
 603         if (pmap->pm_vers && pmap->pm_prot && pmap->pm_port)
 604                 return 1;
 605
 606         if (nfs_mount_data_version >= 4)
 607                 return probe_port(mnt_server, probe_mnt3_first, probe_udp_first);
 608         else
 609                 return probe_port(mnt_server, probe_mnt1_first, probe_udp_only);
 610 }
 611
 612 /**
 613  * probe_bothports - discover the RPC endpoints of mountd and NFS server
 614  * @mnt_server: pointer to address and pmap argument for mountd results
 615  * @nfs_server: pointer to address and pmap argument for NFS server
 616  *
 617  * Returns 1 if successful, otherwise zero if some error occurred.
 618  * Note that the arguments are both input and output arguments.
 619  *
 620  * A side effect of calling this function is that rpccreateerr is set.
 621  */
 622 int probe_bothports(clnt_addr_t *mnt_server, clnt_addr_t *nfs_server)
 623 {
 624         struct pmap *nfs_pmap = &nfs_server->pmap;
 625         struct pmap *mnt_pmap = &mnt_server->pmap;
 626         struct pmap save_nfs, save_mnt;
 627         int res;
 628         const unsigned long *probe_vers;
 629
 630         if (mnt_pmap->pm_vers && !nfs_pmap->pm_vers)
 631                 nfs_pmap->pm_vers = mntvers_to_nfs(mnt_pmap->pm_vers);
 632         else if (nfs_pmap->pm_vers && !mnt_pmap->pm_vers)
 633                 mnt_pmap->pm_vers = nfsvers_to_mnt(nfs_pmap->pm_vers);
 634         if (nfs_pmap->pm_vers)
 635                 goto version_fixed;
 636
 637         memcpy(&save_nfs, nfs_pmap, sizeof(save_nfs));
 638         memcpy(&save_mnt, mnt_pmap, sizeof(save_mnt));
 639         probe_vers = (nfs_mount_data_version >= 4) ?
 640                         probe_mnt3_first : probe_mnt1_first;
 641
 642         for (; *probe_vers; probe_vers++) {
 643                 nfs_pmap->pm_vers = mntvers_to_nfs(*probe_vers);
 644                 if ((res = probe_nfsport(nfs_server) != 0)) {
 645                         mnt_pmap->pm_vers = *probe_vers;
 646                         if ((res = probe_mntport(mnt_server)) != 0)
 647                                 return 1;
 648                         memcpy(mnt_pmap, &save_mnt, sizeof(*mnt_pmap));
 649                 }
 650                 switch (rpc_createerr.cf_stat) {
 651                 case RPC_PROGVERSMISMATCH:
 652                 case RPC_PROGNOTREGISTERED:
 653                         break;
 654                 default:
 655                         goto out_bad;
 656                 }
 657                 memcpy(nfs_pmap, &save_nfs, sizeof(*nfs_pmap));
 658         }
 659
 660 out_bad:
 661         return 0;
 662
 663 version_fixed:
 664         if (!probe_nfsport(nfs_server))
 665                 goto out_bad;
 666         return probe_mntport(mnt_server);
 667 }
 668
 669 static int probe_statd(void)
 670 {
 671         struct sockaddr_in addr;
 672         unsigned short port;
 673
 674         memset(&addr, 0, sizeof(addr));
 675         addr.sin_family = AF_INET;
 676         addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
 677         port = getport(&addr, 100024, 1, IPPROTO_UDP);
 678
 679         if (port == 0)
 680                 return 0;
 681         addr.sin_port = htons(port);
 682
 683         if (clnt_ping(&addr, 100024, 1, IPPROTO_UDP, NULL) <= 0)
 684                 return 0;
 685
 686         return 1;
 687 }
 688
 689 /**
 690  * start_statd - attempt to start rpc.statd
 691  *
 692  * Returns 1 if statd is running; otherwise zero.
 693  */
 694 int start_statd(void)
 695 {
 696 #ifdef START_STATD
 697         struct stat stb;
 698 #endif
 699
 700         if (probe_statd())
 701                 return 1;
 702
 703 #ifdef START_STATD
 704         if (stat(START_STATD, &stb) == 0) {
 705                 if (S_ISREG(stb.st_mode) && (stb.st_mode & S_IXUSR)) {
 706                         system(START_STATD);
 707                         if (probe_statd())
 708                                 return 1;
 709                 }
 710         }
 711 #endif
 712
 713         return 0;
 714 }
 715
 716 /**
 717  * nfs_call_umount - ask the server to remove a share from it's rmtab
 718  * @mnt_server: address of RPC MNT program server
 719  * @argp: directory path of share to "unmount"
 720  *
 721  * Returns one if the unmount call succeeded; zero if the unmount
 722  * failed for any reason.
 723  *
 724  * Note that a side effect of calling this function is that rpccreateerr
 725  * is set.
 726  */
 727 int nfs_call_umount(clnt_addr_t *mnt_server, dirpath *argp)
 728 {
 729         CLIENT *clnt;
 730         enum clnt_stat res = 0;
 731         int msock;
 732
 733         if (!probe_mntport(mnt_server))
 734                 return 0;
 735         clnt = mnt_openclnt(mnt_server, &msock);
 736         if (!clnt)
 737                 return 0;
 738         res = clnt_call(clnt, MOUNTPROC_UMNT,
 739                         (xdrproc_t)xdr_dirpath, (caddr_t)argp,
 740                         (xdrproc_t)xdr_void, NULL,
 741                         TIMEOUT);
 742         mnt_closeclnt(clnt, msock);
 743
 744         if (res == RPC_SUCCESS)
 745                 return 1;
 746         return 0;
 747 }
 748
 749 /**
 750  * mnt_openclnt - get a handle for a remote mountd service
 751  * @mnt_server: address and pmap arguments of mountd service
 752  * @msock: returns a file descriptor of the underlying transport socket
 753  *
 754  * Returns an active handle for the remote's mountd service
 755  */
 756 CLIENT *mnt_openclnt(clnt_addr_t *mnt_server, int *msock)
 757 {
 758         struct sockaddr_in *mnt_saddr = &mnt_server->saddr;
 759         struct pmap *mnt_pmap = &mnt_server->pmap;
 760         CLIENT *clnt = NULL;
 761
 762         mnt_saddr->sin_port = htons((u_short)mnt_pmap->pm_port);
 763         *msock = get_socket(mnt_saddr, mnt_pmap->pm_prot, MOUNT_TIMEOUT,
 764                                 TRUE, FALSE);
 765         if (*msock == RPC_ANYSOCK) {
 766                 if (rpc_createerr.cf_error.re_errno == EADDRINUSE)
 767                         /*
 768                          * Probably in-use by a TIME_WAIT connection,
 769                          * It is worth waiting a while and trying again.
 770                          */
 771                         rpc_createerr.cf_stat = RPC_TIMEDOUT;
 772                 return NULL;
 773         }
 774
 775         switch (mnt_pmap->pm_prot) {
 776         case IPPROTO_UDP:
 777                 clnt = clntudp_bufcreate(mnt_saddr,
 778                                          mnt_pmap->pm_prog, mnt_pmap->pm_vers,
 779                                          RETRY_TIMEOUT, msock,
 780                                          MNT_SENDBUFSIZE, MNT_RECVBUFSIZE);
 781                 break;
 782         case IPPROTO_TCP:
 783                 clnt = clnttcp_create(mnt_saddr,
 784                                       mnt_pmap->pm_prog, mnt_pmap->pm_vers,
 785                                       msock,
 786                                       MNT_SENDBUFSIZE, MNT_RECVBUFSIZE);
 787                 break;
 788         }
 789         if (clnt) {
 790                 /* try to mount hostname:dirname */
 791                 clnt->cl_auth = authunix_create_default();
 792                 return clnt;
 793         }
 794         return NULL;
 795 }
 796
 797 /**
 798  * mnt_closeclnt - terminate a handle for a remote mountd service
 799  * @clnt: pointer to an active handle for a remote mountd service
 800  * @msock: file descriptor of the underlying transport socket
 801  *
 802  */
 803 void mnt_closeclnt(CLIENT *clnt, int msock)
 804 {
 805         auth_destroy(clnt->cl_auth);
 806         clnt_destroy(clnt);
 807         close(msock);
 808 }
 809
 810 /**
 811  * clnt_ping - send an RPC ping to the remote RPC service endpoint
 812  * @saddr: server's address
 813  * @prog: target RPC program number
 814  * @vers: target RPC version number
 815  * @prot: target RPC protocol
 816  * @caddr: filled in with our network address
 817  *
 818  * Sigh... getport() doesn't actually check the version number.
 819  * In order to make sure that the server actually supports the service
 820  * we're requesting, we open and RPC client, and fire off a NULL
 821  * RPC call.
 822  *
 823  * caddr is the network address that the server will use to call us back.
 824  * On multi-homed clients, this address depends on which NIC we use to
 825  * route requests to the server.
 826  *
 827  * Returns one if successful, otherwise zero.
 828  */
 829 int clnt_ping(struct sockaddr_in *saddr, const unsigned long prog,
 830                 const unsigned long vers, const unsigned int prot,
 831                 struct sockaddr_in *caddr)
 832 {
 833         CLIENT *clnt = NULL;
 834         int sock, stat;
 835         static char clnt_res;
 836         struct sockaddr dissolve;
 837
 838         rpc_createerr.cf_stat = stat = 0;
 839         sock = get_socket(saddr, prot, CONNECT_TIMEOUT, FALSE, TRUE);
 840         if (sock == RPC_ANYSOCK) {
 841                 if (rpc_createerr.cf_error.re_errno == ETIMEDOUT) {
 842                         /*
 843                          * TCP timeout. Bubble up the error to see
 844                          * how it should be handled.
 845                          */
 846                         rpc_createerr.cf_stat = RPC_TIMEDOUT;
 847                 }
 848                 return 0;
 849         }
 850
 851         if (caddr) {
 852                 /* Get the address of our end of this connection */
 853                 socklen_t len = sizeof(*caddr);
 854                 if (getsockname(sock, caddr, &len) != 0)
 855                         caddr->sin_family = 0;
 856         }
 857
 858         switch(prot) {
 859         case IPPROTO_UDP:
 860                 /* The socket is connected (so we could getsockname successfully),
 861                  * but some servers on multi-homed hosts reply from
 862                  * the wrong address, so if we stay connected, we lose the reply.
 863                  */
 864                 dissolve.sa_family = AF_UNSPEC;
 865                 connect(sock, &dissolve, sizeof(dissolve));
 866
 867                 clnt = clntudp_bufcreate(saddr, prog, vers,
 868                                          RETRY_TIMEOUT, &sock,
 869                                          RPCSMALLMSGSIZE, RPCSMALLMSGSIZE);
 870                 break;
 871         case IPPROTO_TCP:
 872                 clnt = clnttcp_create(saddr, prog, vers, &sock,
 873                                       RPCSMALLMSGSIZE, RPCSMALLMSGSIZE);
 874                 break;
 875         }
 876         if (!clnt) {
 877                 close(sock);
 878                 return 0;
 879         }
 880         memset(&clnt_res, 0, sizeof(clnt_res));
 881         stat = clnt_call(clnt, NULLPROC,
 882                          (xdrproc_t)xdr_void, (caddr_t)NULL,
 883                          (xdrproc_t)xdr_void, (caddr_t)&clnt_res,
 884                          TIMEOUT);
 885         if (stat) {
 886                 clnt_geterr(clnt, &rpc_createerr.cf_error);
 887                 rpc_createerr.cf_stat = stat;
 888         }
 889         clnt_destroy(clnt);
 890         close(sock);
 891
 892         if (stat == RPC_SUCCESS)
 893                 return 1;
 894         else
 895                 return 0;
 896 }
 897
 898 /*
 899  * Try a getsockname() on a connected datagram socket.
 900  *
 901  * Returns 1 and fills in @buf if successful; otherwise, zero.
 902  *
 903  * A connected datagram socket prevents leaving a socket in TIME_WAIT.
 904  * This conserves the ephemeral port number space, helping reduce failed
 905  * socket binds during mount storms.
 906  */
 907 static int nfs_ca_sockname(const struct sockaddr *sap, const socklen_t salen,
 908                            struct sockaddr *buf, socklen_t *buflen)
 909 {
 910         struct sockaddr_in sin = {
 911                 .sin_family             = AF_INET,
 912                 .sin_addr.s_addr        = htonl(INADDR_ANY),
 913         };
 914         struct sockaddr_in6 sin6 = {
 915                 .sin6_family            = AF_INET6,
 916                 .sin6_addr              = IN6ADDR_ANY_INIT,
 917         };
 918         int sock;
 919
 920         sock = socket(sap->sa_family, SOCK_DGRAM, IPPROTO_UDP);
 921         if (sock < 0)
 922                 return 0;
 923
 924         switch (sap->sa_family) {
 925         case AF_INET:
 926                 if (bind(sock, (struct sockaddr *)&sin, sizeof(sin)) < 0) {
 927                         close(sock);
 928                         return 0;
 929                 }
 930                 break;
 931         case AF_INET6:
 932                 if (bind(sock, (struct sockaddr *)&sin6, sizeof(sin6)) < 0) {
 933                         close(sock);
 934                         return 0;
 935                 }
 936                 break;
 937         default:
 938                 errno = EAFNOSUPPORT;
 939                 return 0;
 940         }
 941
 942         if (connect(sock, sap, salen) < 0) {
 943                 close(sock);
 944                 return 0;
 945         }
 946
 947         return !getsockname(sock, buf, buflen);
 948 }
 949
 950 /*
 951  * Try to generate an address that prevents the server from calling us.
 952  *
 953  * Returns 1 and fills in @buf if successful; otherwise, zero.
 954  */
 955 static int nfs_ca_gai(const struct sockaddr *sap, const socklen_t salen,
 956                       struct sockaddr *buf, socklen_t *buflen)
 957 {
 958         struct addrinfo *gai_results;
 959         struct addrinfo gai_hint = {
 960                 .ai_family      = sap->sa_family,
 961                 .ai_flags       = AI_PASSIVE,   /* ANYADDR */
 962         };
 963
 964         if (getaddrinfo(NULL, "", &gai_hint, &gai_results))
 965                 return 0;
 966
 967         *buflen = gai_results->ai_addrlen;
 968         memcpy(buf, gai_results->ai_addr, *buflen);
 969
 970         freeaddrinfo(gai_results);
 971
 972         return 1;
 973 }
 974
 975 /**
 976  * nfs_callback_address - acquire our local network address
 977  * @sap: pointer to address of remote
 978  * @sap_len: length of address
 979  * @buf: pointer to buffer to be filled in with local network address
 980  * @buflen: IN: length of buffer to fill in; OUT: length of filled-in address
 981  *
 982  * Discover a network address that an NFSv4 server can use to call us back.
 983  * On multi-homed clients, this address depends on which NIC we use to
 984  * route requests to the server.
 985  *
 986  * Returns 1 and fills in @buf if an unambiguous local address is
 987  * available; returns 1 and fills in an appropriate ANYADDR address
 988  * if a local address isn't available; otherwise, returns zero.
 989  */
 990 int nfs_callback_address(const struct sockaddr *sap, const socklen_t salen,
 991                          struct sockaddr *buf, socklen_t *buflen)
 992 {
 993         struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)buf;
 994
 995         if (nfs_ca_sockname(sap, salen, buf, buflen) == 0)
 996                 if (nfs_ca_gai(sap, salen, buf, buflen) == 0)
 997                         goto out_failed;
 998
 999         /*
1000          * The server can't use an interface ID that was generated
1001          * here on the client, so always clear sin6_scope_id.
1002          */
1003         if (sin6->sin6_family == AF_INET6)
1004                 sin6->sin6_scope_id = 0;
1005
1006         return 1;
1007
1008 out_failed:
1009         *buflen = 0;
1010         if (verbose)
1011                 nfs_error(_("%s: failed to construct callback address"));
1012         return 0;
1013
1014 }