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