2 * In-kernel rpcbind client supporting versions 2, 3, and 4 of the rpcbind
5 * Based on RFC 1833: "Binding Protocols for ONC RPC Version 2" and
6 * RFC 3530: "Network File System (NFS) version 4 Protocol"
8 * Original: Gilles Quillard, Bull Open Source, 2005 <gilles.quillard@bull.net>
9 * Updated: Chuck Lever, Oracle Corporation, 2007 <chuck.lever@oracle.com>
11 * Descended from net/sunrpc/pmap_clnt.c,
12 * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
15 #include <linux/module.h>
17 #include <linux/types.h>
18 #include <linux/socket.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>
29 #include <linux/sunrpc/clnt.h>
30 #include <linux/sunrpc/sched.h>
31 #include <linux/sunrpc/xprtsock.h>
36 # define RPCDBG_FACILITY RPCDBG_BIND
39 #define RPCBIND_SOCK_PATHNAME "/var/run/rpcbind.sock"
41 #define RPCBIND_PROGRAM (100000u)
42 #define RPCBIND_PORT (111u)
44 #define RPCBVERS_2 (2u)
45 #define RPCBVERS_3 (3u)
46 #define RPCBVERS_4 (4u)
53 RPCBPROC_GETADDR
= 3, /* alias for GETPORT */
56 RPCBPROC_BCAST
= 5, /* alias for CALLIT */
69 * The "owner" is allowed to unset a service in the rpcbind database.
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.
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.
79 #define RPCB_OWNER_STRING "0"
80 #define RPCB_MAXOWNERLEN sizeof(RPCB_OWNER_STRING)
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)
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))
96 * XDR argument and result sizes
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 + \
104 #define RPCB_getportres_sz RPCB_port_sz
105 #define RPCB_setres_sz RPCB_boolean_sz
108 * Note that RFC 1833 does not put any size restrictions on the
109 * address string returned by the remote rpcbind database.
111 #define RPCB_getaddrres_sz RPCB_addr_sz
113 static void rpcb_getport_done(struct rpc_task
*, void *);
114 static void rpcb_map_release(void *data
);
115 static const struct rpc_program rpcb_program
;
117 struct rpcbind_args
{
118 struct rpc_xprt
* r_xprt
;
123 unsigned short r_port
;
124 const char * r_netid
;
126 const char * r_owner
;
131 static struct rpc_procinfo rpcb_procedures2
[];
132 static struct rpc_procinfo rpcb_procedures3
[];
133 static struct rpc_procinfo rpcb_procedures4
[];
137 struct rpc_procinfo
* rpc_proc
;
140 static const struct rpcb_info rpcb_next_version
[];
141 static const struct rpcb_info rpcb_next_version6
[];
143 static const struct rpc_call_ops rpcb_getport_ops
= {
144 .rpc_call_done
= rpcb_getport_done
,
145 .rpc_release
= rpcb_map_release
,
148 static void rpcb_wake_rpcbind_waiters(struct rpc_xprt
*xprt
, int status
)
150 xprt_clear_binding(xprt
);
151 rpc_wake_up_status(&xprt
->binding
, status
);
154 static void rpcb_map_release(void *data
)
156 struct rpcbind_args
*map
= data
;
158 rpcb_wake_rpcbind_waiters(map
->r_xprt
, map
->r_status
);
159 xprt_put(map
->r_xprt
);
164 static int rpcb_get_local(struct net
*net
)
167 struct sunrpc_net
*sn
= net_generic(net
, sunrpc_net_id
);
169 spin_lock(&sn
->rpcb_clnt_lock
);
172 cnt
= sn
->rpcb_users
;
173 spin_unlock(&sn
->rpcb_clnt_lock
);
178 void rpcb_put_local(struct net
*net
)
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
;
185 spin_lock(&sn
->rpcb_clnt_lock
);
186 if (sn
->rpcb_users
) {
187 if (--sn
->rpcb_users
== 0) {
188 sn
->rpcb_local_clnt
= NULL
;
189 sn
->rpcb_local_clnt4
= NULL
;
191 shutdown
= !sn
->rpcb_users
;
193 spin_unlock(&sn
->rpcb_clnt_lock
);
197 * cleanup_rpcb_clnt - remove xprtsock's sysctls, unregister
200 rpc_shutdown_client(clnt4
);
202 rpc_shutdown_client(clnt
);
206 static void rpcb_set_local(struct net
*net
, struct rpc_clnt
*clnt
,
207 struct rpc_clnt
*clnt4
)
209 struct sunrpc_net
*sn
= net_generic(net
, sunrpc_net_id
);
211 /* Protected by rpcb_create_local_mutex */
212 sn
->rpcb_local_clnt
= clnt
;
213 sn
->rpcb_local_clnt4
= clnt4
;
216 dprintk("RPC: created new rpcb local clients (rpcb_local_clnt: "
217 "%p, rpcb_local_clnt4: %p) for net %p%s\n",
218 sn
->rpcb_local_clnt
, sn
->rpcb_local_clnt4
,
219 net
, (net
== &init_net
) ? " (init_net)" : "");
223 * Returns zero on success, otherwise a negative errno value
226 static int rpcb_create_local_unix(struct net
*net
)
228 static const struct sockaddr_un rpcb_localaddr_rpcbind
= {
229 .sun_family
= AF_LOCAL
,
230 .sun_path
= RPCBIND_SOCK_PATHNAME
,
232 struct rpc_create_args args
= {
234 .protocol
= XPRT_TRANSPORT_LOCAL
,
235 .address
= (struct sockaddr
*)&rpcb_localaddr_rpcbind
,
236 .addrsize
= sizeof(rpcb_localaddr_rpcbind
),
237 .servername
= "localhost",
238 .program
= &rpcb_program
,
239 .version
= RPCBVERS_2
,
240 .authflavor
= RPC_AUTH_NULL
,
242 struct rpc_clnt
*clnt
, *clnt4
;
246 * Because we requested an RPC PING at transport creation time,
247 * this works only if the user space portmapper is rpcbind, and
248 * it's listening on AF_LOCAL on the named socket.
250 clnt
= rpc_create(&args
);
252 dprintk("RPC: failed to create AF_LOCAL rpcbind "
253 "client (errno %ld).\n", PTR_ERR(clnt
));
254 result
= PTR_ERR(clnt
);
258 clnt4
= rpc_bind_new_program(clnt
, &rpcb_program
, RPCBVERS_4
);
260 dprintk("RPC: failed to bind second program to "
261 "rpcbind v4 client (errno %ld).\n",
266 rpcb_set_local(net
, clnt
, clnt4
);
273 * Returns zero on success, otherwise a negative errno value
276 static int rpcb_create_local_net(struct net
*net
)
278 static const struct sockaddr_in rpcb_inaddr_loopback
= {
279 .sin_family
= AF_INET
,
280 .sin_addr
.s_addr
= htonl(INADDR_LOOPBACK
),
281 .sin_port
= htons(RPCBIND_PORT
),
283 struct rpc_create_args args
= {
285 .protocol
= XPRT_TRANSPORT_TCP
,
286 .address
= (struct sockaddr
*)&rpcb_inaddr_loopback
,
287 .addrsize
= sizeof(rpcb_inaddr_loopback
),
288 .servername
= "localhost",
289 .program
= &rpcb_program
,
290 .version
= RPCBVERS_2
,
291 .authflavor
= RPC_AUTH_UNIX
,
292 .flags
= RPC_CLNT_CREATE_NOPING
,
294 struct rpc_clnt
*clnt
, *clnt4
;
297 clnt
= rpc_create(&args
);
299 dprintk("RPC: failed to create local rpcbind "
300 "client (errno %ld).\n", PTR_ERR(clnt
));
301 result
= PTR_ERR(clnt
);
306 * This results in an RPC ping. On systems running portmapper,
307 * the v4 ping will fail. Proceed anyway, but disallow rpcb
310 clnt4
= rpc_bind_new_program(clnt
, &rpcb_program
, RPCBVERS_4
);
312 dprintk("RPC: failed to bind second program to "
313 "rpcbind v4 client (errno %ld).\n",
318 rpcb_set_local(net
, clnt
, clnt4
);
325 * Returns zero on success, otherwise a negative errno value
328 int rpcb_create_local(struct net
*net
)
330 static DEFINE_MUTEX(rpcb_create_local_mutex
);
333 if (rpcb_get_local(net
))
336 mutex_lock(&rpcb_create_local_mutex
);
337 if (rpcb_get_local(net
))
340 if (rpcb_create_local_unix(net
) != 0)
341 result
= rpcb_create_local_net(net
);
344 mutex_unlock(&rpcb_create_local_mutex
);
348 static struct rpc_clnt
*rpcb_create(struct net
*net
, const char *hostname
,
349 struct sockaddr
*srvaddr
, size_t salen
,
350 int proto
, u32 version
)
352 struct rpc_create_args args
= {
357 .servername
= hostname
,
358 .program
= &rpcb_program
,
360 .authflavor
= RPC_AUTH_UNIX
,
361 .flags
= (RPC_CLNT_CREATE_NOPING
|
362 RPC_CLNT_CREATE_NONPRIVPORT
),
365 switch (srvaddr
->sa_family
) {
367 ((struct sockaddr_in
*)srvaddr
)->sin_port
= htons(RPCBIND_PORT
);
370 ((struct sockaddr_in6
*)srvaddr
)->sin6_port
= htons(RPCBIND_PORT
);
373 return ERR_PTR(-EAFNOSUPPORT
);
376 return rpc_create(&args
);
379 static int rpcb_register_call(struct rpc_clnt
*clnt
, struct rpc_message
*msg
)
381 int result
, error
= 0;
383 msg
->rpc_resp
= &result
;
385 error
= rpc_call_sync(clnt
, msg
, RPC_TASK_SOFTCONN
);
387 dprintk("RPC: failed to contact local rpcbind "
388 "server (errno %d).\n", -error
);
398 * rpcb_register - set or unset a port registration with the local rpcbind svc
399 * @net: target network namespace
400 * @prog: RPC program number to bind
401 * @vers: RPC version number to bind
402 * @prot: transport protocol to register
403 * @port: port value to register
405 * Returns zero if the registration request was dispatched successfully
406 * and the rpcbind daemon returned success. Otherwise, returns an errno
407 * value that reflects the nature of the error (request could not be
408 * dispatched, timed out, or rpcbind returned an error).
410 * RPC services invoke this function to advertise their contact
411 * information via the system's rpcbind daemon. RPC services
412 * invoke this function once for each [program, version, transport]
413 * tuple they wish to advertise.
415 * Callers may also unregister RPC services that are no longer
416 * available by setting the passed-in port to zero. This removes
417 * all registered transports for [program, version] from the local
420 * This function uses rpcbind protocol version 2 to contact the
421 * local rpcbind daemon.
423 * Registration works over both AF_INET and AF_INET6, and services
424 * registered via this function are advertised as available for any
425 * address. If the local rpcbind daemon is listening on AF_INET6,
426 * services registered via this function will be advertised on
427 * IN6ADDR_ANY (ie available for all AF_INET and AF_INET6
430 int rpcb_register(struct net
*net
, u32 prog
, u32 vers
, int prot
, unsigned short port
)
432 struct rpcbind_args map
= {
438 struct rpc_message msg
= {
441 struct sunrpc_net
*sn
= net_generic(net
, sunrpc_net_id
);
443 dprintk("RPC: %sregistering (%u, %u, %d, %u) with local "
444 "rpcbind\n", (port
? "" : "un"),
445 prog
, vers
, prot
, port
);
447 msg
.rpc_proc
= &rpcb_procedures2
[RPCBPROC_UNSET
];
449 msg
.rpc_proc
= &rpcb_procedures2
[RPCBPROC_SET
];
451 return rpcb_register_call(sn
->rpcb_local_clnt
, &msg
);
455 * Fill in AF_INET family-specific arguments to register
457 static int rpcb_register_inet4(struct sunrpc_net
*sn
,
458 const struct sockaddr
*sap
,
459 struct rpc_message
*msg
)
461 const struct sockaddr_in
*sin
= (const struct sockaddr_in
*)sap
;
462 struct rpcbind_args
*map
= msg
->rpc_argp
;
463 unsigned short port
= ntohs(sin
->sin_port
);
466 map
->r_addr
= rpc_sockaddr2uaddr(sap
, GFP_KERNEL
);
468 dprintk("RPC: %sregistering [%u, %u, %s, '%s'] with "
469 "local rpcbind\n", (port
? "" : "un"),
470 map
->r_prog
, map
->r_vers
,
471 map
->r_addr
, map
->r_netid
);
473 msg
->rpc_proc
= &rpcb_procedures4
[RPCBPROC_UNSET
];
475 msg
->rpc_proc
= &rpcb_procedures4
[RPCBPROC_SET
];
477 result
= rpcb_register_call(sn
->rpcb_local_clnt4
, msg
);
483 * Fill in AF_INET6 family-specific arguments to register
485 static int rpcb_register_inet6(struct sunrpc_net
*sn
,
486 const struct sockaddr
*sap
,
487 struct rpc_message
*msg
)
489 const struct sockaddr_in6
*sin6
= (const struct sockaddr_in6
*)sap
;
490 struct rpcbind_args
*map
= msg
->rpc_argp
;
491 unsigned short port
= ntohs(sin6
->sin6_port
);
494 map
->r_addr
= rpc_sockaddr2uaddr(sap
, GFP_KERNEL
);
496 dprintk("RPC: %sregistering [%u, %u, %s, '%s'] with "
497 "local rpcbind\n", (port
? "" : "un"),
498 map
->r_prog
, map
->r_vers
,
499 map
->r_addr
, map
->r_netid
);
501 msg
->rpc_proc
= &rpcb_procedures4
[RPCBPROC_UNSET
];
503 msg
->rpc_proc
= &rpcb_procedures4
[RPCBPROC_SET
];
505 result
= rpcb_register_call(sn
->rpcb_local_clnt4
, msg
);
510 static int rpcb_unregister_all_protofamilies(struct sunrpc_net
*sn
,
511 struct rpc_message
*msg
)
513 struct rpcbind_args
*map
= msg
->rpc_argp
;
515 dprintk("RPC: unregistering [%u, %u, '%s'] with "
517 map
->r_prog
, map
->r_vers
, map
->r_netid
);
520 msg
->rpc_proc
= &rpcb_procedures4
[RPCBPROC_UNSET
];
522 return rpcb_register_call(sn
->rpcb_local_clnt4
, msg
);
526 * rpcb_v4_register - set or unset a port registration with the local rpcbind
527 * @net: target network namespace
528 * @program: RPC program number of service to (un)register
529 * @version: RPC version number of service to (un)register
530 * @address: address family, IP address, and port to (un)register
531 * @netid: netid of transport protocol to (un)register
533 * Returns zero if the registration request was dispatched successfully
534 * and the rpcbind daemon returned success. Otherwise, returns an errno
535 * value that reflects the nature of the error (request could not be
536 * dispatched, timed out, or rpcbind returned an error).
538 * RPC services invoke this function to advertise their contact
539 * information via the system's rpcbind daemon. RPC services
540 * invoke this function once for each [program, version, address,
541 * netid] tuple they wish to advertise.
543 * Callers may also unregister RPC services that are registered at a
544 * specific address by setting the port number in @address to zero.
545 * They may unregister all registered protocol families at once for
546 * a service by passing a NULL @address argument. If @netid is ""
547 * then all netids for [program, version, address] are unregistered.
549 * This function uses rpcbind protocol version 4 to contact the
550 * local rpcbind daemon. The local rpcbind daemon must support
551 * version 4 of the rpcbind protocol in order for these functions
552 * to register a service successfully.
554 * Supported netids include "udp" and "tcp" for UDP and TCP over
555 * IPv4, and "udp6" and "tcp6" for UDP and TCP over IPv6,
558 * The contents of @address determine the address family and the
559 * port to be registered. The usual practice is to pass INADDR_ANY
560 * as the raw address, but specifying a non-zero address is also
561 * supported by this API if the caller wishes to advertise an RPC
562 * service on a specific network interface.
564 * Note that passing in INADDR_ANY does not create the same service
565 * registration as IN6ADDR_ANY. The former advertises an RPC
566 * service on any IPv4 address, but not on IPv6. The latter
567 * advertises the service on all IPv4 and IPv6 addresses.
569 int rpcb_v4_register(struct net
*net
, const u32 program
, const u32 version
,
570 const struct sockaddr
*address
, const char *netid
)
572 struct rpcbind_args map
= {
576 .r_owner
= RPCB_OWNER_STRING
,
578 struct rpc_message msg
= {
581 struct sunrpc_net
*sn
= net_generic(net
, sunrpc_net_id
);
583 if (sn
->rpcb_local_clnt4
== NULL
)
584 return -EPROTONOSUPPORT
;
587 return rpcb_unregister_all_protofamilies(sn
, &msg
);
589 switch (address
->sa_family
) {
591 return rpcb_register_inet4(sn
, address
, &msg
);
593 return rpcb_register_inet6(sn
, address
, &msg
);
596 return -EAFNOSUPPORT
;
599 static struct rpc_task
*rpcb_call_async(struct rpc_clnt
*rpcb_clnt
, struct rpcbind_args
*map
, struct rpc_procinfo
*proc
)
601 struct rpc_message msg
= {
606 struct rpc_task_setup task_setup_data
= {
607 .rpc_client
= rpcb_clnt
,
609 .callback_ops
= &rpcb_getport_ops
,
610 .callback_data
= map
,
611 .flags
= RPC_TASK_ASYNC
| RPC_TASK_SOFTCONN
,
614 return rpc_run_task(&task_setup_data
);
618 * In the case where rpc clients have been cloned, we want to make
619 * sure that we use the program number/version etc of the actual
620 * owner of the xprt. To do so, we walk back up the tree of parents
621 * to find whoever created the transport and/or whoever has the
624 static struct rpc_clnt
*rpcb_find_transport_owner(struct rpc_clnt
*clnt
)
626 struct rpc_clnt
*parent
= clnt
->cl_parent
;
627 struct rpc_xprt
*xprt
= rcu_dereference(clnt
->cl_xprt
);
629 while (parent
!= clnt
) {
630 if (rcu_dereference(parent
->cl_xprt
) != xprt
)
632 if (clnt
->cl_autobind
)
635 parent
= parent
->cl_parent
;
641 * rpcb_getport_async - obtain the port for a given RPC service on a given host
642 * @task: task that is waiting for portmapper request
644 * This one can be called for an ongoing RPC request, and can be used in
645 * an async (rpciod) context.
647 void rpcb_getport_async(struct rpc_task
*task
)
649 struct rpc_clnt
*clnt
;
650 struct rpc_procinfo
*proc
;
652 struct rpc_xprt
*xprt
;
653 struct rpc_clnt
*rpcb_clnt
;
654 struct rpcbind_args
*map
;
655 struct rpc_task
*child
;
656 struct sockaddr_storage addr
;
657 struct sockaddr
*sap
= (struct sockaddr
*)&addr
;
663 clnt
= rpcb_find_transport_owner(task
->tk_client
);
664 xprt
= xprt_get(rcu_dereference(clnt
->cl_xprt
));
665 } while (xprt
== NULL
);
668 dprintk("RPC: %5u %s(%s, %u, %u, %d)\n",
669 task
->tk_pid
, __func__
,
670 xprt
->servername
, clnt
->cl_prog
, clnt
->cl_vers
, xprt
->prot
);
672 /* Put self on the wait queue to ensure we get notified if
673 * some other task is already attempting to bind the port */
674 rpc_sleep_on(&xprt
->binding
, task
, NULL
);
676 if (xprt_test_and_set_binding(xprt
)) {
677 dprintk("RPC: %5u %s: waiting for another binder\n",
678 task
->tk_pid
, __func__
);
683 /* Someone else may have bound if we slept */
684 if (xprt_bound(xprt
)) {
686 dprintk("RPC: %5u %s: already bound\n",
687 task
->tk_pid
, __func__
);
691 /* Parent transport's destination address */
692 salen
= rpc_peeraddr(clnt
, sap
, sizeof(addr
));
694 /* Don't ever use rpcbind v2 for AF_INET6 requests */
695 switch (sap
->sa_family
) {
697 proc
= rpcb_next_version
[xprt
->bind_index
].rpc_proc
;
698 bind_version
= rpcb_next_version
[xprt
->bind_index
].rpc_vers
;
701 proc
= rpcb_next_version6
[xprt
->bind_index
].rpc_proc
;
702 bind_version
= rpcb_next_version6
[xprt
->bind_index
].rpc_vers
;
705 status
= -EAFNOSUPPORT
;
706 dprintk("RPC: %5u %s: bad address family\n",
707 task
->tk_pid
, __func__
);
711 xprt
->bind_index
= 0;
712 status
= -EPFNOSUPPORT
;
713 dprintk("RPC: %5u %s: no more getport versions available\n",
714 task
->tk_pid
, __func__
);
718 dprintk("RPC: %5u %s: trying rpcbind version %u\n",
719 task
->tk_pid
, __func__
, bind_version
);
721 rpcb_clnt
= rpcb_create(xprt
->xprt_net
, xprt
->servername
, sap
, salen
,
722 xprt
->prot
, bind_version
);
723 if (IS_ERR(rpcb_clnt
)) {
724 status
= PTR_ERR(rpcb_clnt
);
725 dprintk("RPC: %5u %s: rpcb_create failed, error %ld\n",
726 task
->tk_pid
, __func__
, PTR_ERR(rpcb_clnt
));
730 map
= kzalloc(sizeof(struct rpcbind_args
), GFP_ATOMIC
);
733 dprintk("RPC: %5u %s: no memory available\n",
734 task
->tk_pid
, __func__
);
735 goto bailout_release_client
;
737 map
->r_prog
= clnt
->cl_prog
;
738 map
->r_vers
= clnt
->cl_vers
;
739 map
->r_prot
= xprt
->prot
;
742 map
->r_status
= -EIO
;
744 switch (bind_version
) {
747 map
->r_netid
= xprt
->address_strings
[RPC_DISPLAY_NETID
];
748 map
->r_addr
= rpc_sockaddr2uaddr(sap
, GFP_ATOMIC
);
758 child
= rpcb_call_async(rpcb_clnt
, map
, proc
);
759 rpc_release_client(rpcb_clnt
);
761 /* rpcb_map_release() has freed the arguments */
762 dprintk("RPC: %5u %s: rpc_run_task failed\n",
763 task
->tk_pid
, __func__
);
767 xprt
->stat
.bind_count
++;
771 bailout_release_client
:
772 rpc_release_client(rpcb_clnt
);
774 rpcb_wake_rpcbind_waiters(xprt
, status
);
775 task
->tk_status
= status
;
778 EXPORT_SYMBOL_GPL(rpcb_getport_async
);
781 * Rpcbind child task calls this callback via tk_exit.
783 static void rpcb_getport_done(struct rpc_task
*child
, void *data
)
785 struct rpcbind_args
*map
= data
;
786 struct rpc_xprt
*xprt
= map
->r_xprt
;
787 int status
= child
->tk_status
;
789 /* Garbage reply: retry with a lesser rpcbind version */
791 status
= -EPROTONOSUPPORT
;
793 /* rpcbind server doesn't support this rpcbind protocol version */
794 if (status
== -EPROTONOSUPPORT
)
798 /* rpcbind server not available on remote host? */
799 xprt
->ops
->set_port(xprt
, 0);
800 } else if (map
->r_port
== 0) {
801 /* Requested RPC service wasn't registered on remote host */
802 xprt
->ops
->set_port(xprt
, 0);
806 xprt
->ops
->set_port(xprt
, map
->r_port
);
807 xprt_set_bound(xprt
);
811 dprintk("RPC: %5u rpcb_getport_done(status %d, port %u)\n",
812 child
->tk_pid
, status
, map
->r_port
);
814 map
->r_status
= status
;
818 * XDR functions for rpcbind
821 static void rpcb_enc_mapping(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
822 const struct rpcbind_args
*rpcb
)
826 dprintk("RPC: %5u encoding PMAP_%s call (%u, %u, %d, %u)\n",
827 req
->rq_task
->tk_pid
,
828 req
->rq_task
->tk_msg
.rpc_proc
->p_name
,
829 rpcb
->r_prog
, rpcb
->r_vers
, rpcb
->r_prot
, rpcb
->r_port
);
831 p
= xdr_reserve_space(xdr
, RPCB_mappingargs_sz
<< 2);
832 *p
++ = cpu_to_be32(rpcb
->r_prog
);
833 *p
++ = cpu_to_be32(rpcb
->r_vers
);
834 *p
++ = cpu_to_be32(rpcb
->r_prot
);
835 *p
= cpu_to_be32(rpcb
->r_port
);
838 static int rpcb_dec_getport(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
839 struct rpcbind_args
*rpcb
)
846 p
= xdr_inline_decode(xdr
, 4);
847 if (unlikely(p
== NULL
))
850 port
= be32_to_cpup(p
);
851 dprintk("RPC: %5u PMAP_%s result: %lu\n", req
->rq_task
->tk_pid
,
852 req
->rq_task
->tk_msg
.rpc_proc
->p_name
, port
);
853 if (unlikely(port
> USHRT_MAX
))
860 static int rpcb_dec_set(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
865 p
= xdr_inline_decode(xdr
, 4);
866 if (unlikely(p
== NULL
))
873 dprintk("RPC: %5u RPCB_%s call %s\n",
874 req
->rq_task
->tk_pid
,
875 req
->rq_task
->tk_msg
.rpc_proc
->p_name
,
876 (*boolp
? "succeeded" : "failed"));
880 static void encode_rpcb_string(struct xdr_stream
*xdr
, const char *string
,
886 len
= strlen(string
);
887 BUG_ON(len
> maxstrlen
);
888 p
= xdr_reserve_space(xdr
, 4 + len
);
889 xdr_encode_opaque(p
, string
, len
);
892 static void rpcb_enc_getaddr(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
893 const struct rpcbind_args
*rpcb
)
897 dprintk("RPC: %5u encoding RPCB_%s call (%u, %u, '%s', '%s')\n",
898 req
->rq_task
->tk_pid
,
899 req
->rq_task
->tk_msg
.rpc_proc
->p_name
,
900 rpcb
->r_prog
, rpcb
->r_vers
,
901 rpcb
->r_netid
, rpcb
->r_addr
);
903 p
= xdr_reserve_space(xdr
, (RPCB_program_sz
+ RPCB_version_sz
) << 2);
904 *p
++ = cpu_to_be32(rpcb
->r_prog
);
905 *p
= cpu_to_be32(rpcb
->r_vers
);
907 encode_rpcb_string(xdr
, rpcb
->r_netid
, RPCBIND_MAXNETIDLEN
);
908 encode_rpcb_string(xdr
, rpcb
->r_addr
, RPCBIND_MAXUADDRLEN
);
909 encode_rpcb_string(xdr
, rpcb
->r_owner
, RPCB_MAXOWNERLEN
);
912 static int rpcb_dec_getaddr(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
913 struct rpcbind_args
*rpcb
)
915 struct sockaddr_storage address
;
916 struct sockaddr
*sap
= (struct sockaddr
*)&address
;
922 p
= xdr_inline_decode(xdr
, 4);
923 if (unlikely(p
== NULL
))
925 len
= be32_to_cpup(p
);
928 * If the returned universal address is a null string,
929 * the requested RPC service was not registered.
932 dprintk("RPC: %5u RPCB reply: program not registered\n",
933 req
->rq_task
->tk_pid
);
937 if (unlikely(len
> RPCBIND_MAXUADDRLEN
))
940 p
= xdr_inline_decode(xdr
, len
);
941 if (unlikely(p
== NULL
))
943 dprintk("RPC: %5u RPCB_%s reply: %s\n", req
->rq_task
->tk_pid
,
944 req
->rq_task
->tk_msg
.rpc_proc
->p_name
, (char *)p
);
946 if (rpc_uaddr2sockaddr(req
->rq_xprt
->xprt_net
, (char *)p
, len
,
947 sap
, sizeof(address
)) == 0)
949 rpcb
->r_port
= rpc_get_port(sap
);
954 dprintk("RPC: %5u malformed RPCB_%s reply\n",
955 req
->rq_task
->tk_pid
,
956 req
->rq_task
->tk_msg
.rpc_proc
->p_name
);
961 * Not all rpcbind procedures described in RFC 1833 are implemented
962 * since the Linux kernel RPC code requires only these.
965 static struct rpc_procinfo rpcb_procedures2
[] = {
967 .p_proc
= RPCBPROC_SET
,
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_SET
,
977 .p_proc
= RPCBPROC_UNSET
,
978 .p_encode
= (kxdreproc_t
)rpcb_enc_mapping
,
979 .p_decode
= (kxdrdproc_t
)rpcb_dec_set
,
980 .p_arglen
= RPCB_mappingargs_sz
,
981 .p_replen
= RPCB_setres_sz
,
982 .p_statidx
= RPCBPROC_UNSET
,
986 [RPCBPROC_GETPORT
] = {
987 .p_proc
= RPCBPROC_GETPORT
,
988 .p_encode
= (kxdreproc_t
)rpcb_enc_mapping
,
989 .p_decode
= (kxdrdproc_t
)rpcb_dec_getport
,
990 .p_arglen
= RPCB_mappingargs_sz
,
991 .p_replen
= RPCB_getportres_sz
,
992 .p_statidx
= RPCBPROC_GETPORT
,
998 static struct rpc_procinfo rpcb_procedures3
[] = {
1000 .p_proc
= RPCBPROC_SET
,
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_SET
,
1009 [RPCBPROC_UNSET
] = {
1010 .p_proc
= RPCBPROC_UNSET
,
1011 .p_encode
= (kxdreproc_t
)rpcb_enc_getaddr
,
1012 .p_decode
= (kxdrdproc_t
)rpcb_dec_set
,
1013 .p_arglen
= RPCB_getaddrargs_sz
,
1014 .p_replen
= RPCB_setres_sz
,
1015 .p_statidx
= RPCBPROC_UNSET
,
1019 [RPCBPROC_GETADDR
] = {
1020 .p_proc
= RPCBPROC_GETADDR
,
1021 .p_encode
= (kxdreproc_t
)rpcb_enc_getaddr
,
1022 .p_decode
= (kxdrdproc_t
)rpcb_dec_getaddr
,
1023 .p_arglen
= RPCB_getaddrargs_sz
,
1024 .p_replen
= RPCB_getaddrres_sz
,
1025 .p_statidx
= RPCBPROC_GETADDR
,
1027 .p_name
= "GETADDR",
1031 static struct rpc_procinfo rpcb_procedures4
[] = {
1033 .p_proc
= RPCBPROC_SET
,
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_SET
,
1042 [RPCBPROC_UNSET
] = {
1043 .p_proc
= RPCBPROC_UNSET
,
1044 .p_encode
= (kxdreproc_t
)rpcb_enc_getaddr
,
1045 .p_decode
= (kxdrdproc_t
)rpcb_dec_set
,
1046 .p_arglen
= RPCB_getaddrargs_sz
,
1047 .p_replen
= RPCB_setres_sz
,
1048 .p_statidx
= RPCBPROC_UNSET
,
1052 [RPCBPROC_GETADDR
] = {
1053 .p_proc
= RPCBPROC_GETADDR
,
1054 .p_encode
= (kxdreproc_t
)rpcb_enc_getaddr
,
1055 .p_decode
= (kxdrdproc_t
)rpcb_dec_getaddr
,
1056 .p_arglen
= RPCB_getaddrargs_sz
,
1057 .p_replen
= RPCB_getaddrres_sz
,
1058 .p_statidx
= RPCBPROC_GETADDR
,
1060 .p_name
= "GETADDR",
1064 static const struct rpcb_info rpcb_next_version
[] = {
1066 .rpc_vers
= RPCBVERS_2
,
1067 .rpc_proc
= &rpcb_procedures2
[RPCBPROC_GETPORT
],
1074 static const struct rpcb_info rpcb_next_version6
[] = {
1076 .rpc_vers
= RPCBVERS_4
,
1077 .rpc_proc
= &rpcb_procedures4
[RPCBPROC_GETADDR
],
1080 .rpc_vers
= RPCBVERS_3
,
1081 .rpc_proc
= &rpcb_procedures3
[RPCBPROC_GETADDR
],
1088 static const struct rpc_version rpcb_version2
= {
1089 .number
= RPCBVERS_2
,
1090 .nrprocs
= ARRAY_SIZE(rpcb_procedures2
),
1091 .procs
= rpcb_procedures2
1094 static const struct rpc_version rpcb_version3
= {
1095 .number
= RPCBVERS_3
,
1096 .nrprocs
= ARRAY_SIZE(rpcb_procedures3
),
1097 .procs
= rpcb_procedures3
1100 static const struct rpc_version rpcb_version4
= {
1101 .number
= RPCBVERS_4
,
1102 .nrprocs
= ARRAY_SIZE(rpcb_procedures4
),
1103 .procs
= rpcb_procedures4
1106 static const struct rpc_version
*rpcb_version
[] = {
1114 static struct rpc_stat rpcb_stats
;
1116 static const struct rpc_program rpcb_program
= {
1118 .number
= RPCBIND_PROGRAM
,
1119 .nrvers
= ARRAY_SIZE(rpcb_version
),
1120 .version
= rpcb_version
,
1121 .stats
= &rpcb_stats
,