net/sunrpc/rpcb_clnt.c

   1 /*
   2  * In-kernel rpcbind client supporting versions 2, 3, and 4 of the rpcbind
   3  * protocol
   4  *
   5  * Based on RFC 1833: "Binding Protocols for ONC RPC Version 2" and
   6  * RFC 3530: "Network File System (NFS) version 4 Protocol"
   7  *
   8  * Original: Gilles Quillard, Bull Open Source, 2005 <gilles.quillard@bull.net>
   9  * Updated: Chuck Lever, Oracle Corporation, 2007 <chuck.lever@oracle.com>
  10  *
  11  * Descended from net/sunrpc/pmap_clnt.c,
  12  *  Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
  13  */
  14
  15 #include <linux/module.h>
  16
  17 #include <linux/types.h>
  18 #include <linux/socket.h>
  19 #include <linux/in.h>
  20 #include <linux/in6.h>
  21 #include <linux/kernel.h>
  22 #include <linux/errno.h>
  23 #include <linux/mutex.h>
  24 #include <linux/slab.h>
  25 #include <net/ipv6.h>
  26
  27 #include <linux/sunrpc/clnt.h>
  28 #include <linux/sunrpc/sched.h>
  29 #include <linux/sunrpc/xprtsock.h>
  30
  31 #ifdef RPC_DEBUG
  32 # define RPCDBG_FACILITY        RPCDBG_BIND
  33 #endif
  34
  35 #define RPCBIND_PROGRAM         (100000u)
  36 #define RPCBIND_PORT            (111u)
  37
  38 #define RPCBVERS_2              (2u)
  39 #define RPCBVERS_3              (3u)
  40 #define RPCBVERS_4              (4u)
  41
  42 enum {
  43         RPCBPROC_NULL,
  44         RPCBPROC_SET,
  45         RPCBPROC_UNSET,
  46         RPCBPROC_GETPORT,
  47         RPCBPROC_GETADDR = 3,           /* alias for GETPORT */
  48         RPCBPROC_DUMP,
  49         RPCBPROC_CALLIT,
  50         RPCBPROC_BCAST = 5,             /* alias for CALLIT */
  51         RPCBPROC_GETTIME,
  52         RPCBPROC_UADDR2TADDR,
  53         RPCBPROC_TADDR2UADDR,
  54         RPCBPROC_GETVERSADDR,
  55         RPCBPROC_INDIRECT,
  56         RPCBPROC_GETADDRLIST,
  57         RPCBPROC_GETSTAT,
  58 };
  59
  60 #define RPCB_HIGHPROC_2         RPCBPROC_CALLIT
  61 #define RPCB_HIGHPROC_3         RPCBPROC_TADDR2UADDR
  62 #define RPCB_HIGHPROC_4         RPCBPROC_GETSTAT
  63
  64 /*
  65  * r_owner
  66  *
  67  * The "owner" is allowed to unset a service in the rpcbind database.
  68  *
  69  * For AF_LOCAL SET/UNSET requests, rpcbind treats this string as a
  70  * UID which it maps to a local user name via a password lookup.
  71  * In all other cases it is ignored.
  72  *
  73  * For SET/UNSET requests, user space provides a value, even for
  74  * network requests, and GETADDR uses an empty string.  We follow
  75  * those precedents here.
  76  */
  77 #define RPCB_OWNER_STRING       "0"
  78 #define RPCB_MAXOWNERLEN        sizeof(RPCB_OWNER_STRING)
  79
  80 /*
  81  * XDR data type sizes
  82  */
  83 #define RPCB_program_sz         (1)
  84 #define RPCB_version_sz         (1)
  85 #define RPCB_protocol_sz        (1)
  86 #define RPCB_port_sz            (1)
  87 #define RPCB_boolean_sz         (1)
  88
  89 #define RPCB_netid_sz           (1 + XDR_QUADLEN(RPCBIND_MAXNETIDLEN))
  90 #define RPCB_addr_sz            (1 + XDR_QUADLEN(RPCBIND_MAXUADDRLEN))
  91 #define RPCB_ownerstring_sz     (1 + XDR_QUADLEN(RPCB_MAXOWNERLEN))
  92
  93 /*
  94  * XDR argument and result sizes
  95  */
  96 #define RPCB_mappingargs_sz     (RPCB_program_sz + RPCB_version_sz + \
  97                                 RPCB_protocol_sz + RPCB_port_sz)
  98 #define RPCB_getaddrargs_sz     (RPCB_program_sz + RPCB_version_sz + \
  99                                 RPCB_netid_sz + RPCB_addr_sz + \
 100                                 RPCB_ownerstring_sz)
 101
 102 #define RPCB_getportres_sz      RPCB_port_sz
 103 #define RPCB_setres_sz          RPCB_boolean_sz
 104
 105 /*
 106  * Note that RFC 1833 does not put any size restrictions on the
 107  * address string returned by the remote rpcbind database.
 108  */
 109 #define RPCB_getaddrres_sz      RPCB_addr_sz
 110
 111 static void                     rpcb_getport_done(struct rpc_task *, void *);
 112 static void                     rpcb_map_release(void *data);
 113 static struct rpc_program       rpcb_program;
 114
 115 static struct rpc_clnt *        rpcb_local_clnt;
 116 static struct rpc_clnt *        rpcb_local_clnt4;
 117
 118 struct rpcbind_args {
 119         struct rpc_xprt *       r_xprt;
 120
 121         u32                     r_prog;
 122         u32                     r_vers;
 123         u32                     r_prot;
 124         unsigned short          r_port;
 125         const char *            r_netid;
 126         const char *            r_addr;
 127         const char *            r_owner;
 128
 129         int                     r_status;
 130 };
 131
 132 static struct rpc_procinfo rpcb_procedures2[];
 133 static struct rpc_procinfo rpcb_procedures3[];
 134 static struct rpc_procinfo rpcb_procedures4[];
 135
 136 struct rpcb_info {
 137         u32                     rpc_vers;
 138         struct rpc_procinfo *   rpc_proc;
 139 };
 140
 141 static struct rpcb_info rpcb_next_version[];
 142 static struct rpcb_info rpcb_next_version6[];
 143
 144 static const struct rpc_call_ops rpcb_getport_ops = {
 145         .rpc_call_done          = rpcb_getport_done,
 146         .rpc_release            = rpcb_map_release,
 147 };
 148
 149 static void rpcb_wake_rpcbind_waiters(struct rpc_xprt *xprt, int status)
 150 {
 151         xprt_clear_binding(xprt);
 152         rpc_wake_up_status(&xprt->binding, status);
 153 }
 154
 155 static void rpcb_map_release(void *data)
 156 {
 157         struct rpcbind_args *map = data;
 158
 159         rpcb_wake_rpcbind_waiters(map->r_xprt, map->r_status);
 160         xprt_put(map->r_xprt);
 161         kfree(map->r_addr);
 162         kfree(map);
 163 }
 164
 165 static const struct sockaddr_in rpcb_inaddr_loopback = {
 166         .sin_family             = AF_INET,
 167         .sin_addr.s_addr        = htonl(INADDR_LOOPBACK),
 168         .sin_port               = htons(RPCBIND_PORT),
 169 };
 170
 171 static DEFINE_MUTEX(rpcb_create_local_mutex);
 172
 173 /*
 174  * Returns zero on success, otherwise a negative errno value
 175  * is returned.
 176  */
 177 static int rpcb_create_local(void)
 178 {
 179         struct rpc_create_args args = {
 180                 .net            = &init_net,
 181                 .protocol       = XPRT_TRANSPORT_TCP,
 182                 .address        = (struct sockaddr *)&rpcb_inaddr_loopback,
 183                 .addrsize       = sizeof(rpcb_inaddr_loopback),
 184                 .servername     = "localhost",
 185                 .program        = &rpcb_program,
 186                 .version        = RPCBVERS_2,
 187                 .authflavor     = RPC_AUTH_UNIX,
 188                 .flags          = RPC_CLNT_CREATE_NOPING,
 189         };
 190         struct rpc_clnt *clnt, *clnt4;
 191         int result = 0;
 192
 193         if (rpcb_local_clnt)
 194                 return result;
 195
 196         mutex_lock(&rpcb_create_local_mutex);
 197         if (rpcb_local_clnt)
 198                 goto out;
 199
 200         clnt = rpc_create(&args);
 201         if (IS_ERR(clnt)) {
 202                 dprintk("RPC:       failed to create local rpcbind "
 203                                 "client (errno %ld).\n", PTR_ERR(clnt));
 204                 result = -PTR_ERR(clnt);
 205                 goto out;
 206         }
 207
 208         /*
 209          * This results in an RPC ping.  On systems running portmapper,
 210          * the v4 ping will fail.  Proceed anyway, but disallow rpcb
 211          * v4 upcalls.
 212          */
 213         clnt4 = rpc_bind_new_program(clnt, &rpcb_program, RPCBVERS_4);
 214         if (IS_ERR(clnt4)) {
 215                 dprintk("RPC:       failed to bind second program to "
 216                                 "rpcbind v4 client (errno %ld).\n",
 217                                 PTR_ERR(clnt4));
 218                 clnt4 = NULL;
 219         }
 220
 221         rpcb_local_clnt = clnt;
 222         rpcb_local_clnt4 = clnt4;
 223
 224 out:
 225         mutex_unlock(&rpcb_create_local_mutex);
 226         return result;
 227 }
 228
 229 static struct rpc_clnt *rpcb_create(char *hostname, struct sockaddr *srvaddr,
 230                                     size_t salen, int proto, u32 version)
 231 {
 232         struct rpc_create_args args = {
 233                 .net            = &init_net,
 234                 .protocol       = proto,
 235                 .address        = srvaddr,
 236                 .addrsize       = salen,
 237                 .servername     = hostname,
 238                 .program        = &rpcb_program,
 239                 .version        = version,
 240                 .authflavor     = RPC_AUTH_UNIX,
 241                 .flags          = (RPC_CLNT_CREATE_NOPING |
 242                                         RPC_CLNT_CREATE_NONPRIVPORT),
 243         };
 244
 245         switch (srvaddr->sa_family) {
 246         case AF_INET:
 247                 ((struct sockaddr_in *)srvaddr)->sin_port = htons(RPCBIND_PORT);
 248                 break;
 249         case AF_INET6:
 250                 ((struct sockaddr_in6 *)srvaddr)->sin6_port = htons(RPCBIND_PORT);
 251                 break;
 252         default:
 253                 return ERR_PTR(-EAFNOSUPPORT);
 254         }
 255
 256         return rpc_create(&args);
 257 }
 258
 259 static int rpcb_register_call(struct rpc_clnt *clnt, struct rpc_message *msg)
 260 {
 261         int result, error = 0;
 262
 263         msg->rpc_resp = &result;
 264
 265         error = rpc_call_sync(clnt, msg, RPC_TASK_SOFTCONN);
 266         if (error < 0) {
 267                 dprintk("RPC:       failed to contact local rpcbind "
 268                                 "server (errno %d).\n", -error);
 269                 return error;
 270         }
 271
 272         if (!result)
 273                 return -EACCES;
 274         return 0;
 275 }
 276
 277 /**
 278  * rpcb_register - set or unset a port registration with the local rpcbind svc
 279  * @prog: RPC program number to bind
 280  * @vers: RPC version number to bind
 281  * @prot: transport protocol to register
 282  * @port: port value to register
 283  *
 284  * Returns zero if the registration request was dispatched successfully
 285  * and the rpcbind daemon returned success.  Otherwise, returns an errno
 286  * value that reflects the nature of the error (request could not be
 287  * dispatched, timed out, or rpcbind returned an error).
 288  *
 289  * RPC services invoke this function to advertise their contact
 290  * information via the system's rpcbind daemon.  RPC services
 291  * invoke this function once for each [program, version, transport]
 292  * tuple they wish to advertise.
 293  *
 294  * Callers may also unregister RPC services that are no longer
 295  * available by setting the passed-in port to zero.  This removes
 296  * all registered transports for [program, version] from the local
 297  * rpcbind database.
 298  *
 299  * This function uses rpcbind protocol version 2 to contact the
 300  * local rpcbind daemon.
 301  *
 302  * Registration works over both AF_INET and AF_INET6, and services
 303  * registered via this function are advertised as available for any
 304  * address.  If the local rpcbind daemon is listening on AF_INET6,
 305  * services registered via this function will be advertised on
 306  * IN6ADDR_ANY (ie available for all AF_INET and AF_INET6
 307  * addresses).
 308  */
 309 int rpcb_register(u32 prog, u32 vers, int prot, unsigned short port)
 310 {
 311         struct rpcbind_args map = {
 312                 .r_prog         = prog,
 313                 .r_vers         = vers,
 314                 .r_prot         = prot,
 315                 .r_port         = port,
 316         };
 317         struct rpc_message msg = {
 318                 .rpc_argp       = &map,
 319         };
 320         int error;
 321
 322         error = rpcb_create_local();
 323         if (error)
 324                 return error;
 325
 326         dprintk("RPC:       %sregistering (%u, %u, %d, %u) with local "
 327                         "rpcbind\n", (port ? "" : "un"),
 328                         prog, vers, prot, port);
 329
 330         msg.rpc_proc = &rpcb_procedures2[RPCBPROC_UNSET];
 331         if (port)
 332                 msg.rpc_proc = &rpcb_procedures2[RPCBPROC_SET];
 333
 334         return rpcb_register_call(rpcb_local_clnt, &msg);
 335 }
 336
 337 /*
 338  * Fill in AF_INET family-specific arguments to register
 339  */
 340 static int rpcb_register_inet4(const struct sockaddr *sap,
 341                                struct rpc_message *msg)
 342 {
 343         const struct sockaddr_in *sin = (const struct sockaddr_in *)sap;
 344         struct rpcbind_args *map = msg->rpc_argp;
 345         unsigned short port = ntohs(sin->sin_port);
 346         int result;
 347
 348         map->r_addr = rpc_sockaddr2uaddr(sap);
 349
 350         dprintk("RPC:       %sregistering [%u, %u, %s, '%s'] with "
 351                 "local rpcbind\n", (port ? "" : "un"),
 352                         map->r_prog, map->r_vers,
 353                         map->r_addr, map->r_netid);
 354
 355         msg->rpc_proc = &rpcb_procedures4[RPCBPROC_UNSET];
 356         if (port)
 357                 msg->rpc_proc = &rpcb_procedures4[RPCBPROC_SET];
 358
 359         result = rpcb_register_call(rpcb_local_clnt4, msg);
 360         kfree(map->r_addr);
 361         return result;
 362 }
 363
 364 /*
 365  * Fill in AF_INET6 family-specific arguments to register
 366  */
 367 static int rpcb_register_inet6(const struct sockaddr *sap,
 368                                struct rpc_message *msg)
 369 {
 370         const struct sockaddr_in6 *sin6 = (const struct sockaddr_in6 *)sap;
 371         struct rpcbind_args *map = msg->rpc_argp;
 372         unsigned short port = ntohs(sin6->sin6_port);
 373         int result;
 374
 375         map->r_addr = rpc_sockaddr2uaddr(sap);
 376
 377         dprintk("RPC:       %sregistering [%u, %u, %s, '%s'] with "
 378                 "local rpcbind\n", (port ? "" : "un"),
 379                         map->r_prog, map->r_vers,
 380                         map->r_addr, map->r_netid);
 381
 382         msg->rpc_proc = &rpcb_procedures4[RPCBPROC_UNSET];
 383         if (port)
 384                 msg->rpc_proc = &rpcb_procedures4[RPCBPROC_SET];
 385
 386         result = rpcb_register_call(rpcb_local_clnt4, msg);
 387         kfree(map->r_addr);
 388         return result;
 389 }
 390
 391 static int rpcb_unregister_all_protofamilies(struct rpc_message *msg)
 392 {
 393         struct rpcbind_args *map = msg->rpc_argp;
 394
 395         dprintk("RPC:       unregistering [%u, %u, '%s'] with "
 396                 "local rpcbind\n",
 397                         map->r_prog, map->r_vers, map->r_netid);
 398
 399         map->r_addr = "";
 400         msg->rpc_proc = &rpcb_procedures4[RPCBPROC_UNSET];
 401
 402         return rpcb_register_call(rpcb_local_clnt4, msg);
 403 }
 404
 405 /**
 406  * rpcb_v4_register - set or unset a port registration with the local rpcbind
 407  * @program: RPC program number of service to (un)register
 408  * @version: RPC version number of service to (un)register
 409  * @address: address family, IP address, and port to (un)register
 410  * @netid: netid of transport protocol to (un)register
 411  *
 412  * Returns zero if the registration request was dispatched successfully
 413  * and the rpcbind daemon returned success.  Otherwise, returns an errno
 414  * value that reflects the nature of the error (request could not be
 415  * dispatched, timed out, or rpcbind returned an error).
 416  *
 417  * RPC services invoke this function to advertise their contact
 418  * information via the system's rpcbind daemon.  RPC services
 419  * invoke this function once for each [program, version, address,
 420  * netid] tuple they wish to advertise.
 421  *
 422  * Callers may also unregister RPC services that are registered at a
 423  * specific address by setting the port number in @address to zero.
 424  * They may unregister all registered protocol families at once for
 425  * a service by passing a NULL @address argument.  If @netid is ""
 426  * then all netids for [program, version, address] are unregistered.
 427  *
 428  * This function uses rpcbind protocol version 4 to contact the
 429  * local rpcbind daemon.  The local rpcbind daemon must support
 430  * version 4 of the rpcbind protocol in order for these functions
 431  * to register a service successfully.
 432  *
 433  * Supported netids include "udp" and "tcp" for UDP and TCP over
 434  * IPv4, and "udp6" and "tcp6" for UDP and TCP over IPv6,
 435  * respectively.
 436  *
 437  * The contents of @address determine the address family and the
 438  * port to be registered.  The usual practice is to pass INADDR_ANY
 439  * as the raw address, but specifying a non-zero address is also
 440  * supported by this API if the caller wishes to advertise an RPC
 441  * service on a specific network interface.
 442  *
 443  * Note that passing in INADDR_ANY does not create the same service
 444  * registration as IN6ADDR_ANY.  The former advertises an RPC
 445  * service on any IPv4 address, but not on IPv6.  The latter
 446  * advertises the service on all IPv4 and IPv6 addresses.
 447  */
 448 int rpcb_v4_register(const u32 program, const u32 version,
 449                      const struct sockaddr *address, const char *netid)
 450 {
 451         struct rpcbind_args map = {
 452                 .r_prog         = program,
 453                 .r_vers         = version,
 454                 .r_netid        = netid,
 455                 .r_owner        = RPCB_OWNER_STRING,
 456         };
 457         struct rpc_message msg = {
 458                 .rpc_argp       = &map,
 459         };
 460         int error;
 461
 462         error = rpcb_create_local();
 463         if (error)
 464                 return error;
 465         if (rpcb_local_clnt4 == NULL)
 466                 return -EPROTONOSUPPORT;
 467
 468         if (address == NULL)
 469                 return rpcb_unregister_all_protofamilies(&msg);
 470
 471         switch (address->sa_family) {
 472         case AF_INET:
 473                 return rpcb_register_inet4(address, &msg);
 474         case AF_INET6:
 475                 return rpcb_register_inet6(address, &msg);
 476         }
 477
 478         return -EAFNOSUPPORT;
 479 }
 480
 481 static struct rpc_task *rpcb_call_async(struct rpc_clnt *rpcb_clnt, struct rpcbind_args *map, struct rpc_procinfo *proc)
 482 {
 483         struct rpc_message msg = {
 484                 .rpc_proc = proc,
 485                 .rpc_argp = map,
 486                 .rpc_resp = map,
 487         };
 488         struct rpc_task_setup task_setup_data = {
 489                 .rpc_client = rpcb_clnt,
 490                 .rpc_message = &msg,
 491                 .callback_ops = &rpcb_getport_ops,
 492                 .callback_data = map,
 493                 .flags = RPC_TASK_ASYNC | RPC_TASK_SOFTCONN,
 494         };
 495
 496         return rpc_run_task(&task_setup_data);
 497 }
 498
 499 /*
 500  * In the case where rpc clients have been cloned, we want to make
 501  * sure that we use the program number/version etc of the actual
 502  * owner of the xprt. To do so, we walk back up the tree of parents
 503  * to find whoever created the transport and/or whoever has the
 504  * autobind flag set.
 505  */
 506 static struct rpc_clnt *rpcb_find_transport_owner(struct rpc_clnt *clnt)
 507 {
 508         struct rpc_clnt *parent = clnt->cl_parent;
 509
 510         while (parent != clnt) {
 511                 if (parent->cl_xprt != clnt->cl_xprt)
 512                         break;
 513                 if (clnt->cl_autobind)
 514                         break;
 515                 clnt = parent;
 516                 parent = parent->cl_parent;
 517         }
 518         return clnt;
 519 }
 520
 521 /**
 522  * rpcb_getport_async - obtain the port for a given RPC service on a given host
 523  * @task: task that is waiting for portmapper request
 524  *
 525  * This one can be called for an ongoing RPC request, and can be used in
 526  * an async (rpciod) context.
 527  */
 528 void rpcb_getport_async(struct rpc_task *task)
 529 {
 530         struct rpc_clnt *clnt;
 531         struct rpc_procinfo *proc;
 532         u32 bind_version;
 533         struct rpc_xprt *xprt;
 534         struct rpc_clnt *rpcb_clnt;
 535         static struct rpcbind_args *map;
 536         struct rpc_task *child;
 537         struct sockaddr_storage addr;
 538         struct sockaddr *sap = (struct sockaddr *)&addr;
 539         size_t salen;
 540         int status;
 541
 542         clnt = rpcb_find_transport_owner(task->tk_client);
 543         xprt = clnt->cl_xprt;
 544
 545         dprintk("RPC: %5u %s(%s, %u, %u, %d)\n",
 546                 task->tk_pid, __func__,
 547                 clnt->cl_server, clnt->cl_prog, clnt->cl_vers, xprt->prot);
 548
 549         /* Put self on the wait queue to ensure we get notified if
 550          * some other task is already attempting to bind the port */
 551         rpc_sleep_on(&xprt->binding, task, NULL);
 552
 553         if (xprt_test_and_set_binding(xprt)) {
 554                 dprintk("RPC: %5u %s: waiting for another binder\n",
 555                         task->tk_pid, __func__);
 556                 return;
 557         }
 558
 559         /* Someone else may have bound if we slept */
 560         if (xprt_bound(xprt)) {
 561                 status = 0;
 562                 dprintk("RPC: %5u %s: already bound\n",
 563                         task->tk_pid, __func__);
 564                 goto bailout_nofree;
 565         }
 566
 567         /* Parent transport's destination address */
 568         salen = rpc_peeraddr(clnt, sap, sizeof(addr));
 569
 570         /* Don't ever use rpcbind v2 for AF_INET6 requests */
 571         switch (sap->sa_family) {
 572         case AF_INET:
 573                 proc = rpcb_next_version[xprt->bind_index].rpc_proc;
 574                 bind_version = rpcb_next_version[xprt->bind_index].rpc_vers;
 575                 break;
 576         case AF_INET6:
 577                 proc = rpcb_next_version6[xprt->bind_index].rpc_proc;
 578                 bind_version = rpcb_next_version6[xprt->bind_index].rpc_vers;
 579                 break;
 580         default:
 581                 status = -EAFNOSUPPORT;
 582                 dprintk("RPC: %5u %s: bad address family\n",
 583                                 task->tk_pid, __func__);
 584                 goto bailout_nofree;
 585         }
 586         if (proc == NULL) {
 587                 xprt->bind_index = 0;
 588                 status = -EPFNOSUPPORT;
 589                 dprintk("RPC: %5u %s: no more getport versions available\n",
 590                         task->tk_pid, __func__);
 591                 goto bailout_nofree;
 592         }
 593
 594         dprintk("RPC: %5u %s: trying rpcbind version %u\n",
 595                 task->tk_pid, __func__, bind_version);
 596
 597         rpcb_clnt = rpcb_create(clnt->cl_server, sap, salen, xprt->prot,
 598                                 bind_version);
 599         if (IS_ERR(rpcb_clnt)) {
 600                 status = PTR_ERR(rpcb_clnt);
 601                 dprintk("RPC: %5u %s: rpcb_create failed, error %ld\n",
 602                         task->tk_pid, __func__, PTR_ERR(rpcb_clnt));
 603                 goto bailout_nofree;
 604         }
 605
 606         map = kzalloc(sizeof(struct rpcbind_args), GFP_ATOMIC);
 607         if (!map) {
 608                 status = -ENOMEM;
 609                 dprintk("RPC: %5u %s: no memory available\n",
 610                         task->tk_pid, __func__);
 611                 goto bailout_release_client;
 612         }
 613         map->r_prog = clnt->cl_prog;
 614         map->r_vers = clnt->cl_vers;
 615         map->r_prot = xprt->prot;
 616         map->r_port = 0;
 617         map->r_xprt = xprt_get(xprt);
 618         map->r_status = -EIO;
 619
 620         switch (bind_version) {
 621         case RPCBVERS_4:
 622         case RPCBVERS_3:
 623                 map->r_netid = rpc_peeraddr2str(clnt, RPC_DISPLAY_NETID);
 624                 map->r_addr = rpc_sockaddr2uaddr(sap);
 625                 map->r_owner = "";
 626                 break;
 627         case RPCBVERS_2:
 628                 map->r_addr = NULL;
 629                 break;
 630         default:
 631                 BUG();
 632         }
 633
 634         child = rpcb_call_async(rpcb_clnt, map, proc);
 635         rpc_release_client(rpcb_clnt);
 636         if (IS_ERR(child)) {
 637                 /* rpcb_map_release() has freed the arguments */
 638                 dprintk("RPC: %5u %s: rpc_run_task failed\n",
 639                         task->tk_pid, __func__);
 640                 return;
 641         }
 642
 643         xprt->stat.bind_count++;
 644         rpc_put_task(child);
 645         return;
 646
 647 bailout_release_client:
 648         rpc_release_client(rpcb_clnt);
 649 bailout_nofree:
 650         rpcb_wake_rpcbind_waiters(xprt, status);
 651         task->tk_status = status;
 652 }
 653 EXPORT_SYMBOL_GPL(rpcb_getport_async);
 654
 655 /*
 656  * Rpcbind child task calls this callback via tk_exit.
 657  */
 658 static void rpcb_getport_done(struct rpc_task *child, void *data)
 659 {
 660         struct rpcbind_args *map = data;
 661         struct rpc_xprt *xprt = map->r_xprt;
 662         int status = child->tk_status;
 663
 664         /* Garbage reply: retry with a lesser rpcbind version */
 665         if (status == -EIO)
 666                 status = -EPROTONOSUPPORT;
 667
 668         /* rpcbind server doesn't support this rpcbind protocol version */
 669         if (status == -EPROTONOSUPPORT)
 670                 xprt->bind_index++;
 671
 672         if (status < 0) {
 673                 /* rpcbind server not available on remote host? */
 674                 xprt->ops->set_port(xprt, 0);
 675         } else if (map->r_port == 0) {
 676                 /* Requested RPC service wasn't registered on remote host */
 677                 xprt->ops->set_port(xprt, 0);
 678                 status = -EACCES;
 679         } else {
 680                 /* Succeeded */
 681                 xprt->ops->set_port(xprt, map->r_port);
 682                 xprt_set_bound(xprt);
 683                 status = 0;
 684         }
 685
 686         dprintk("RPC: %5u rpcb_getport_done(status %d, port %u)\n",
 687                         child->tk_pid, status, map->r_port);
 688
 689         map->r_status = status;
 690 }
 691
 692 /*
 693  * XDR functions for rpcbind
 694  */
 695
 696 static int rpcb_enc_mapping(struct rpc_rqst *req, __be32 *p,
 697                             const struct rpcbind_args *rpcb)
 698 {
 699         struct rpc_task *task = req->rq_task;
 700         struct xdr_stream xdr;
 701
 702         dprintk("RPC: %5u encoding PMAP_%s call (%u, %u, %d, %u)\n",
 703                         task->tk_pid, task->tk_msg.rpc_proc->p_name,
 704                         rpcb->r_prog, rpcb->r_vers, rpcb->r_prot, rpcb->r_port);
 705
 706         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
 707
 708         p = xdr_reserve_space(&xdr, sizeof(__be32) * RPCB_mappingargs_sz);
 709         if (unlikely(p == NULL))
 710                 return -EIO;
 711
 712         *p++ = htonl(rpcb->r_prog);
 713         *p++ = htonl(rpcb->r_vers);
 714         *p++ = htonl(rpcb->r_prot);
 715         *p   = htonl(rpcb->r_port);
 716
 717         return 0;
 718 }
 719
 720 static int rpcb_dec_getport(struct rpc_rqst *req, __be32 *p,
 721                             struct rpcbind_args *rpcb)
 722 {
 723         struct rpc_task *task = req->rq_task;
 724         struct xdr_stream xdr;
 725         unsigned long port;
 726
 727         xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
 728
 729         rpcb->r_port = 0;
 730
 731         p = xdr_inline_decode(&xdr, sizeof(__be32));
 732         if (unlikely(p == NULL))
 733                 return -EIO;
 734
 735         port = ntohl(*p);
 736         dprintk("RPC: %5u PMAP_%s result: %lu\n", task->tk_pid,
 737                         task->tk_msg.rpc_proc->p_name, port);
 738         if (unlikely(port > USHRT_MAX))
 739                 return -EIO;
 740
 741         rpcb->r_port = port;
 742         return 0;
 743 }
 744
 745 static int rpcb_dec_set(struct rpc_rqst *req, __be32 *p,
 746                         unsigned int *boolp)
 747 {
 748         struct rpc_task *task = req->rq_task;
 749         struct xdr_stream xdr;
 750
 751         xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
 752
 753         p = xdr_inline_decode(&xdr, sizeof(__be32));
 754         if (unlikely(p == NULL))
 755                 return -EIO;
 756
 757         *boolp = 0;
 758         if (*p)
 759                 *boolp = 1;
 760
 761         dprintk("RPC: %5u RPCB_%s call %s\n",
 762                         task->tk_pid, task->tk_msg.rpc_proc->p_name,
 763                         (*boolp ? "succeeded" : "failed"));
 764         return 0;
 765 }
 766
 767 static int encode_rpcb_string(struct xdr_stream *xdr, const char *string,
 768                                 const u32 maxstrlen)
 769 {
 770         u32 len;
 771         __be32 *p;
 772
 773         if (unlikely(string == NULL))
 774                 return -EIO;
 775         len = strlen(string);
 776         if (unlikely(len > maxstrlen))
 777                 return -EIO;
 778
 779         p = xdr_reserve_space(xdr, sizeof(__be32) + len);
 780         if (unlikely(p == NULL))
 781                 return -EIO;
 782         xdr_encode_opaque(p, string, len);
 783
 784         return 0;
 785 }
 786
 787 static int rpcb_enc_getaddr(struct rpc_rqst *req, __be32 *p,
 788                             const struct rpcbind_args *rpcb)
 789 {
 790         struct rpc_task *task = req->rq_task;
 791         struct xdr_stream xdr;
 792
 793         dprintk("RPC: %5u encoding RPCB_%s call (%u, %u, '%s', '%s')\n",
 794                         task->tk_pid, task->tk_msg.rpc_proc->p_name,
 795                         rpcb->r_prog, rpcb->r_vers,
 796                         rpcb->r_netid, rpcb->r_addr);
 797
 798         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
 799
 800         p = xdr_reserve_space(&xdr,
 801                         sizeof(__be32) * (RPCB_program_sz + RPCB_version_sz));
 802         if (unlikely(p == NULL))
 803                 return -EIO;
 804         *p++ = htonl(rpcb->r_prog);
 805         *p = htonl(rpcb->r_vers);
 806
 807         if (encode_rpcb_string(&xdr, rpcb->r_netid, RPCBIND_MAXNETIDLEN))
 808                 return -EIO;
 809         if (encode_rpcb_string(&xdr, rpcb->r_addr, RPCBIND_MAXUADDRLEN))
 810                 return -EIO;
 811         if (encode_rpcb_string(&xdr, rpcb->r_owner, RPCB_MAXOWNERLEN))
 812                 return -EIO;
 813
 814         return 0;
 815 }
 816
 817 static int rpcb_dec_getaddr(struct rpc_rqst *req, __be32 *p,
 818                             struct rpcbind_args *rpcb)
 819 {
 820         struct sockaddr_storage address;
 821         struct sockaddr *sap = (struct sockaddr *)&address;
 822         struct rpc_task *task = req->rq_task;
 823         struct xdr_stream xdr;
 824         u32 len;
 825
 826         rpcb->r_port = 0;
 827
 828         xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
 829
 830         p = xdr_inline_decode(&xdr, sizeof(__be32));
 831         if (unlikely(p == NULL))
 832                 goto out_fail;
 833         len = ntohl(*p);
 834
 835         /*
 836          * If the returned universal address is a null string,
 837          * the requested RPC service was not registered.
 838          */
 839         if (len == 0) {
 840                 dprintk("RPC: %5u RPCB reply: program not registered\n",
 841                                 task->tk_pid);
 842                 return 0;
 843         }
 844
 845         if (unlikely(len > RPCBIND_MAXUADDRLEN))
 846                 goto out_fail;
 847
 848         p = xdr_inline_decode(&xdr, len);
 849         if (unlikely(p == NULL))
 850                 goto out_fail;
 851         dprintk("RPC: %5u RPCB_%s reply: %s\n", task->tk_pid,
 852                         task->tk_msg.rpc_proc->p_name, (char *)p);
 853
 854         if (rpc_uaddr2sockaddr((char *)p, len, sap, sizeof(address)) == 0)
 855                 goto out_fail;
 856         rpcb->r_port = rpc_get_port(sap);
 857
 858         return 0;
 859
 860 out_fail:
 861         dprintk("RPC: %5u malformed RPCB_%s reply\n",
 862                         task->tk_pid, task->tk_msg.rpc_proc->p_name);
 863         return -EIO;
 864 }
 865
 866 /*
 867  * Not all rpcbind procedures described in RFC 1833 are implemented
 868  * since the Linux kernel RPC code requires only these.
 869  */
 870
 871 static struct rpc_procinfo rpcb_procedures2[] = {
 872         [RPCBPROC_SET] = {
 873                 .p_proc         = RPCBPROC_SET,
 874                 .p_encode       = (kxdrproc_t)rpcb_enc_mapping,
 875                 .p_decode       = (kxdrproc_t)rpcb_dec_set,
 876                 .p_arglen       = RPCB_mappingargs_sz,
 877                 .p_replen       = RPCB_setres_sz,
 878                 .p_statidx      = RPCBPROC_SET,
 879                 .p_timer        = 0,
 880                 .p_name         = "SET",
 881         },
 882         [RPCBPROC_UNSET] = {
 883                 .p_proc         = RPCBPROC_UNSET,
 884                 .p_encode       = (kxdrproc_t)rpcb_enc_mapping,
 885                 .p_decode       = (kxdrproc_t)rpcb_dec_set,
 886                 .p_arglen       = RPCB_mappingargs_sz,
 887                 .p_replen       = RPCB_setres_sz,
 888                 .p_statidx      = RPCBPROC_UNSET,
 889                 .p_timer        = 0,
 890                 .p_name         = "UNSET",
 891         },
 892         [RPCBPROC_GETPORT] = {
 893                 .p_proc         = RPCBPROC_GETPORT,
 894                 .p_encode       = (kxdrproc_t)rpcb_enc_mapping,
 895                 .p_decode       = (kxdrproc_t)rpcb_dec_getport,
 896                 .p_arglen       = RPCB_mappingargs_sz,
 897                 .p_replen       = RPCB_getportres_sz,
 898                 .p_statidx      = RPCBPROC_GETPORT,
 899                 .p_timer        = 0,
 900                 .p_name         = "GETPORT",
 901         },
 902 };
 903
 904 static struct rpc_procinfo rpcb_procedures3[] = {
 905         [RPCBPROC_SET] = {
 906                 .p_proc         = RPCBPROC_SET,
 907                 .p_encode       = (kxdrproc_t)rpcb_enc_getaddr,
 908                 .p_decode       = (kxdrproc_t)rpcb_dec_set,
 909                 .p_arglen       = RPCB_getaddrargs_sz,
 910                 .p_replen       = RPCB_setres_sz,
 911                 .p_statidx      = RPCBPROC_SET,
 912                 .p_timer        = 0,
 913                 .p_name         = "SET",
 914         },
 915         [RPCBPROC_UNSET] = {
 916                 .p_proc         = RPCBPROC_UNSET,
 917                 .p_encode       = (kxdrproc_t)rpcb_enc_getaddr,
 918                 .p_decode       = (kxdrproc_t)rpcb_dec_set,
 919                 .p_arglen       = RPCB_getaddrargs_sz,
 920                 .p_replen       = RPCB_setres_sz,
 921                 .p_statidx      = RPCBPROC_UNSET,
 922                 .p_timer        = 0,
 923                 .p_name         = "UNSET",
 924         },
 925         [RPCBPROC_GETADDR] = {
 926                 .p_proc         = RPCBPROC_GETADDR,
 927                 .p_encode       = (kxdrproc_t)rpcb_enc_getaddr,
 928                 .p_decode       = (kxdrproc_t)rpcb_dec_getaddr,
 929                 .p_arglen       = RPCB_getaddrargs_sz,
 930                 .p_replen       = RPCB_getaddrres_sz,
 931                 .p_statidx      = RPCBPROC_GETADDR,
 932                 .p_timer        = 0,
 933                 .p_name         = "GETADDR",
 934         },
 935 };
 936
 937 static struct rpc_procinfo rpcb_procedures4[] = {
 938         [RPCBPROC_SET] = {
 939                 .p_proc         = RPCBPROC_SET,
 940                 .p_encode       = (kxdrproc_t)rpcb_enc_getaddr,
 941                 .p_decode       = (kxdrproc_t)rpcb_dec_set,
 942                 .p_arglen       = RPCB_getaddrargs_sz,
 943                 .p_replen       = RPCB_setres_sz,
 944                 .p_statidx      = RPCBPROC_SET,
 945                 .p_timer        = 0,
 946                 .p_name         = "SET",
 947         },
 948         [RPCBPROC_UNSET] = {
 949                 .p_proc         = RPCBPROC_UNSET,
 950                 .p_encode       = (kxdrproc_t)rpcb_enc_getaddr,
 951                 .p_decode       = (kxdrproc_t)rpcb_dec_set,
 952                 .p_arglen       = RPCB_getaddrargs_sz,
 953                 .p_replen       = RPCB_setres_sz,
 954                 .p_statidx      = RPCBPROC_UNSET,
 955                 .p_timer        = 0,
 956                 .p_name         = "UNSET",
 957         },
 958         [RPCBPROC_GETADDR] = {
 959                 .p_proc         = RPCBPROC_GETADDR,
 960                 .p_encode       = (kxdrproc_t)rpcb_enc_getaddr,
 961                 .p_decode       = (kxdrproc_t)rpcb_dec_getaddr,
 962                 .p_arglen       = RPCB_getaddrargs_sz,
 963                 .p_replen       = RPCB_getaddrres_sz,
 964                 .p_statidx      = RPCBPROC_GETADDR,
 965                 .p_timer        = 0,
 966                 .p_name         = "GETADDR",
 967         },
 968 };
 969
 970 static struct rpcb_info rpcb_next_version[] = {
 971         {
 972                 .rpc_vers       = RPCBVERS_2,
 973                 .rpc_proc       = &rpcb_procedures2[RPCBPROC_GETPORT],
 974         },
 975         {
 976                 .rpc_proc       = NULL,
 977         },
 978 };
 979
 980 static struct rpcb_info rpcb_next_version6[] = {
 981         {
 982                 .rpc_vers       = RPCBVERS_4,
 983                 .rpc_proc       = &rpcb_procedures4[RPCBPROC_GETADDR],
 984         },
 985         {
 986                 .rpc_vers       = RPCBVERS_3,
 987                 .rpc_proc       = &rpcb_procedures3[RPCBPROC_GETADDR],
 988         },
 989         {
 990                 .rpc_proc       = NULL,
 991         },
 992 };
 993
 994 static struct rpc_version rpcb_version2 = {
 995         .number         = RPCBVERS_2,
 996         .nrprocs        = RPCB_HIGHPROC_2,
 997         .procs          = rpcb_procedures2
 998 };
 999
1000 static struct rpc_version rpcb_version3 = {
1001         .number         = RPCBVERS_3,
1002         .nrprocs        = RPCB_HIGHPROC_3,
1003         .procs          = rpcb_procedures3
1004 };
1005
1006 static struct rpc_version rpcb_version4 = {
1007         .number         = RPCBVERS_4,
1008         .nrprocs        = RPCB_HIGHPROC_4,
1009         .procs          = rpcb_procedures4
1010 };
1011
1012 static struct rpc_version *rpcb_version[] = {
1013         NULL,
1014         NULL,
1015         &rpcb_version2,
1016         &rpcb_version3,
1017         &rpcb_version4
1018 };
1019
1020 static struct rpc_stat rpcb_stats;
1021
1022 static struct rpc_program rpcb_program = {
1023         .name           = "rpcbind",
1024         .number         = RPCBIND_PROGRAM,
1025         .nrvers         = ARRAY_SIZE(rpcb_version),
1026         .version        = rpcb_version,
1027         .stats          = &rpcb_stats,
1028 };
1029
1030 /**
1031  * cleanup_rpcb_clnt - remove xprtsock's sysctls, unregister
1032  *
1033  */
1034 void cleanup_rpcb_clnt(void)
1035 {
1036         if (rpcb_local_clnt4)
1037                 rpc_shutdown_client(rpcb_local_clnt4);
1038         if (rpcb_local_clnt)
1039                 rpc_shutdown_client(rpcb_local_clnt);
1040 }