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