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