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
== 0) {
187 sn
->rpcb_local_clnt
= NULL
;
188 sn
->rpcb_local_clnt4
= NULL
;
190 shutdown
= !sn
->rpcb_users
;
191 spin_unlock(&sn
->rpcb_clnt_lock
);
195 * cleanup_rpcb_clnt - remove xprtsock's sysctls, unregister
198 rpc_shutdown_client(clnt4
);
200 rpc_shutdown_client(clnt
);
204 static void rpcb_set_local(struct net
*net
, struct rpc_clnt
*clnt
,
205 struct rpc_clnt
*clnt4
)
207 struct sunrpc_net
*sn
= net_generic(net
, sunrpc_net_id
);
209 /* Protected by rpcb_create_local_mutex */
210 sn
->rpcb_local_clnt
= clnt
;
211 sn
->rpcb_local_clnt4
= clnt4
;
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)" : "");
221 * Returns zero on success, otherwise a negative errno value
224 static int rpcb_create_local_unix(struct net
*net
)
226 static const struct sockaddr_un rpcb_localaddr_rpcbind
= {
227 .sun_family
= AF_LOCAL
,
228 .sun_path
= RPCBIND_SOCK_PATHNAME
,
230 struct rpc_create_args args
= {
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
,
240 struct rpc_clnt
*clnt
, *clnt4
;
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.
248 clnt
= rpc_create(&args
);
250 dprintk("RPC: failed to create AF_LOCAL rpcbind "
251 "client (errno %ld).\n", PTR_ERR(clnt
));
252 result
= -PTR_ERR(clnt
);
256 clnt4
= rpc_bind_new_program(clnt
, &rpcb_program
, RPCBVERS_4
);
258 dprintk("RPC: failed to bind second program to "
259 "rpcbind v4 client (errno %ld).\n",
264 rpcb_set_local(net
, clnt
, clnt4
);
271 * Returns zero on success, otherwise a negative errno value
274 static int rpcb_create_local_net(struct net
*net
)
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
),
281 struct rpc_create_args args
= {
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
,
292 struct rpc_clnt
*clnt
, *clnt4
;
295 clnt
= rpc_create(&args
);
297 dprintk("RPC: failed to create local rpcbind "
298 "client (errno %ld).\n", PTR_ERR(clnt
));
299 result
= -PTR_ERR(clnt
);
304 * This results in an RPC ping. On systems running portmapper,
305 * the v4 ping will fail. Proceed anyway, but disallow rpcb
308 clnt4
= rpc_bind_new_program(clnt
, &rpcb_program
, RPCBVERS_4
);
310 dprintk("RPC: failed to bind second program to "
311 "rpcbind v4 client (errno %ld).\n",
316 rpcb_set_local(net
, clnt
, clnt4
);
323 * Returns zero on success, otherwise a negative errno value
326 int rpcb_create_local(struct net
*net
)
328 static DEFINE_MUTEX(rpcb_create_local_mutex
);
331 if (rpcb_get_local(net
))
334 mutex_lock(&rpcb_create_local_mutex
);
335 if (rpcb_get_local(net
))
338 if (rpcb_create_local_unix(net
) != 0)
339 result
= rpcb_create_local_net(net
);
342 mutex_unlock(&rpcb_create_local_mutex
);
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
)
350 struct rpc_create_args args
= {
355 .servername
= hostname
,
356 .program
= &rpcb_program
,
358 .authflavor
= RPC_AUTH_UNIX
,
359 .flags
= (RPC_CLNT_CREATE_NOPING
|
360 RPC_CLNT_CREATE_NONPRIVPORT
),
363 switch (srvaddr
->sa_family
) {
365 ((struct sockaddr_in
*)srvaddr
)->sin_port
= htons(RPCBIND_PORT
);
368 ((struct sockaddr_in6
*)srvaddr
)->sin6_port
= htons(RPCBIND_PORT
);
371 return ERR_PTR(-EAFNOSUPPORT
);
374 return rpc_create(&args
);
377 static int rpcb_register_call(struct rpc_clnt
*clnt
, struct rpc_message
*msg
)
379 int result
, error
= 0;
381 msg
->rpc_resp
= &result
;
383 error
= rpc_call_sync(clnt
, msg
, RPC_TASK_SOFTCONN
);
385 dprintk("RPC: failed to contact local rpcbind "
386 "server (errno %d).\n", -error
);
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
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).
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.
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
417 * This function uses rpcbind protocol version 2 to contact the
418 * local rpcbind daemon.
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
427 int rpcb_register(struct net
*net
, u32 prog
, u32 vers
, int prot
, unsigned short port
)
429 struct rpcbind_args map
= {
435 struct rpc_message msg
= {
438 struct sunrpc_net
*sn
= net_generic(net
, sunrpc_net_id
);
440 dprintk("RPC: %sregistering (%u, %u, %d, %u) with local "
441 "rpcbind\n", (port
? "" : "un"),
442 prog
, vers
, prot
, port
);
444 msg
.rpc_proc
= &rpcb_procedures2
[RPCBPROC_UNSET
];
446 msg
.rpc_proc
= &rpcb_procedures2
[RPCBPROC_SET
];
448 return rpcb_register_call(sn
->rpcb_local_clnt
, &msg
);
452 * Fill in AF_INET family-specific arguments to register
454 static int rpcb_register_inet4(struct sunrpc_net
*sn
,
455 const struct sockaddr
*sap
,
456 struct rpc_message
*msg
)
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
);
463 map
->r_addr
= rpc_sockaddr2uaddr(sap
, GFP_KERNEL
);
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
);
470 msg
->rpc_proc
= &rpcb_procedures4
[RPCBPROC_UNSET
];
472 msg
->rpc_proc
= &rpcb_procedures4
[RPCBPROC_SET
];
474 result
= rpcb_register_call(sn
->rpcb_local_clnt4
, msg
);
480 * Fill in AF_INET6 family-specific arguments to register
482 static int rpcb_register_inet6(struct sunrpc_net
*sn
,
483 const struct sockaddr
*sap
,
484 struct rpc_message
*msg
)
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
);
491 map
->r_addr
= rpc_sockaddr2uaddr(sap
, GFP_KERNEL
);
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
);
498 msg
->rpc_proc
= &rpcb_procedures4
[RPCBPROC_UNSET
];
500 msg
->rpc_proc
= &rpcb_procedures4
[RPCBPROC_SET
];
502 result
= rpcb_register_call(sn
->rpcb_local_clnt4
, msg
);
507 static int rpcb_unregister_all_protofamilies(struct sunrpc_net
*sn
,
508 struct rpc_message
*msg
)
510 struct rpcbind_args
*map
= msg
->rpc_argp
;
512 dprintk("RPC: unregistering [%u, %u, '%s'] with "
514 map
->r_prog
, map
->r_vers
, map
->r_netid
);
517 msg
->rpc_proc
= &rpcb_procedures4
[RPCBPROC_UNSET
];
519 return rpcb_register_call(sn
->rpcb_local_clnt4
, msg
);
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
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).
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.
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.
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.
550 * Supported netids include "udp" and "tcp" for UDP and TCP over
551 * IPv4, and "udp6" and "tcp6" for UDP and TCP over IPv6,
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.
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.
565 int rpcb_v4_register(struct net
*net
, const u32 program
, const u32 version
,
566 const struct sockaddr
*address
, const char *netid
)
568 struct rpcbind_args map
= {
572 .r_owner
= RPCB_OWNER_STRING
,
574 struct rpc_message msg
= {
577 struct sunrpc_net
*sn
= net_generic(net
, sunrpc_net_id
);
579 if (sn
->rpcb_local_clnt4
== NULL
)
580 return -EPROTONOSUPPORT
;
583 return rpcb_unregister_all_protofamilies(sn
, &msg
);
585 switch (address
->sa_family
) {
587 return rpcb_register_inet4(sn
, address
, &msg
);
589 return rpcb_register_inet6(sn
, address
, &msg
);
592 return -EAFNOSUPPORT
;
595 static struct rpc_task
*rpcb_call_async(struct rpc_clnt
*rpcb_clnt
, struct rpcbind_args
*map
, struct rpc_procinfo
*proc
)
597 struct rpc_message msg
= {
602 struct rpc_task_setup task_setup_data
= {
603 .rpc_client
= rpcb_clnt
,
605 .callback_ops
= &rpcb_getport_ops
,
606 .callback_data
= map
,
607 .flags
= RPC_TASK_ASYNC
| RPC_TASK_SOFTCONN
,
610 return rpc_run_task(&task_setup_data
);
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
620 static struct rpc_clnt
*rpcb_find_transport_owner(struct rpc_clnt
*clnt
)
622 struct rpc_clnt
*parent
= clnt
->cl_parent
;
623 struct rpc_xprt
*xprt
= rcu_dereference(clnt
->cl_xprt
);
625 while (parent
!= clnt
) {
626 if (rcu_dereference(parent
->cl_xprt
) != xprt
)
628 if (clnt
->cl_autobind
)
631 parent
= parent
->cl_parent
;
637 * rpcb_getport_async - obtain the port for a given RPC service on a given host
638 * @task: task that is waiting for portmapper request
640 * This one can be called for an ongoing RPC request, and can be used in
641 * an async (rpciod) context.
643 void rpcb_getport_async(struct rpc_task
*task
)
645 struct rpc_clnt
*clnt
;
646 struct rpc_procinfo
*proc
;
648 struct rpc_xprt
*xprt
;
649 struct rpc_clnt
*rpcb_clnt
;
650 struct rpcbind_args
*map
;
651 struct rpc_task
*child
;
652 struct sockaddr_storage addr
;
653 struct sockaddr
*sap
= (struct sockaddr
*)&addr
;
659 clnt
= rpcb_find_transport_owner(task
->tk_client
);
660 xprt
= xprt_get(rcu_dereference(clnt
->cl_xprt
));
661 } while (xprt
== NULL
);
664 dprintk("RPC: %5u %s(%s, %u, %u, %d)\n",
665 task
->tk_pid
, __func__
,
666 xprt
->servername
, clnt
->cl_prog
, clnt
->cl_vers
, xprt
->prot
);
668 /* Put self on the wait queue to ensure we get notified if
669 * some other task is already attempting to bind the port */
670 rpc_sleep_on(&xprt
->binding
, task
, NULL
);
672 if (xprt_test_and_set_binding(xprt
)) {
673 dprintk("RPC: %5u %s: waiting for another binder\n",
674 task
->tk_pid
, __func__
);
679 /* Someone else may have bound if we slept */
680 if (xprt_bound(xprt
)) {
682 dprintk("RPC: %5u %s: already bound\n",
683 task
->tk_pid
, __func__
);
687 /* Parent transport's destination address */
688 salen
= rpc_peeraddr(clnt
, sap
, sizeof(addr
));
690 /* Don't ever use rpcbind v2 for AF_INET6 requests */
691 switch (sap
->sa_family
) {
693 proc
= rpcb_next_version
[xprt
->bind_index
].rpc_proc
;
694 bind_version
= rpcb_next_version
[xprt
->bind_index
].rpc_vers
;
697 proc
= rpcb_next_version6
[xprt
->bind_index
].rpc_proc
;
698 bind_version
= rpcb_next_version6
[xprt
->bind_index
].rpc_vers
;
701 status
= -EAFNOSUPPORT
;
702 dprintk("RPC: %5u %s: bad address family\n",
703 task
->tk_pid
, __func__
);
707 xprt
->bind_index
= 0;
708 status
= -EPFNOSUPPORT
;
709 dprintk("RPC: %5u %s: no more getport versions available\n",
710 task
->tk_pid
, __func__
);
714 dprintk("RPC: %5u %s: trying rpcbind version %u\n",
715 task
->tk_pid
, __func__
, bind_version
);
717 rpcb_clnt
= rpcb_create(xprt
->xprt_net
, xprt
->servername
, sap
, salen
,
718 xprt
->prot
, bind_version
);
719 if (IS_ERR(rpcb_clnt
)) {
720 status
= PTR_ERR(rpcb_clnt
);
721 dprintk("RPC: %5u %s: rpcb_create failed, error %ld\n",
722 task
->tk_pid
, __func__
, PTR_ERR(rpcb_clnt
));
726 map
= kzalloc(sizeof(struct rpcbind_args
), GFP_ATOMIC
);
729 dprintk("RPC: %5u %s: no memory available\n",
730 task
->tk_pid
, __func__
);
731 goto bailout_release_client
;
733 map
->r_prog
= clnt
->cl_prog
;
734 map
->r_vers
= clnt
->cl_vers
;
735 map
->r_prot
= xprt
->prot
;
738 map
->r_status
= -EIO
;
740 switch (bind_version
) {
743 map
->r_netid
= xprt
->address_strings
[RPC_DISPLAY_NETID
];
744 map
->r_addr
= rpc_sockaddr2uaddr(sap
, GFP_ATOMIC
);
754 child
= rpcb_call_async(rpcb_clnt
, map
, proc
);
755 rpc_release_client(rpcb_clnt
);
757 /* rpcb_map_release() has freed the arguments */
758 dprintk("RPC: %5u %s: rpc_run_task failed\n",
759 task
->tk_pid
, __func__
);
763 xprt
->stat
.bind_count
++;
767 bailout_release_client
:
768 rpc_release_client(rpcb_clnt
);
770 rpcb_wake_rpcbind_waiters(xprt
, status
);
771 task
->tk_status
= status
;
774 EXPORT_SYMBOL_GPL(rpcb_getport_async
);
777 * Rpcbind child task calls this callback via tk_exit.
779 static void rpcb_getport_done(struct rpc_task
*child
, void *data
)
781 struct rpcbind_args
*map
= data
;
782 struct rpc_xprt
*xprt
= map
->r_xprt
;
783 int status
= child
->tk_status
;
785 /* Garbage reply: retry with a lesser rpcbind version */
787 status
= -EPROTONOSUPPORT
;
789 /* rpcbind server doesn't support this rpcbind protocol version */
790 if (status
== -EPROTONOSUPPORT
)
794 /* rpcbind server not available on remote host? */
795 xprt
->ops
->set_port(xprt
, 0);
796 } else if (map
->r_port
== 0) {
797 /* Requested RPC service wasn't registered on remote host */
798 xprt
->ops
->set_port(xprt
, 0);
802 xprt
->ops
->set_port(xprt
, map
->r_port
);
803 xprt_set_bound(xprt
);
807 dprintk("RPC: %5u rpcb_getport_done(status %d, port %u)\n",
808 child
->tk_pid
, status
, map
->r_port
);
810 map
->r_status
= status
;
814 * XDR functions for rpcbind
817 static void rpcb_enc_mapping(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
818 const struct rpcbind_args
*rpcb
)
822 dprintk("RPC: %5u encoding PMAP_%s call (%u, %u, %d, %u)\n",
823 req
->rq_task
->tk_pid
,
824 req
->rq_task
->tk_msg
.rpc_proc
->p_name
,
825 rpcb
->r_prog
, rpcb
->r_vers
, rpcb
->r_prot
, rpcb
->r_port
);
827 p
= xdr_reserve_space(xdr
, RPCB_mappingargs_sz
<< 2);
828 *p
++ = cpu_to_be32(rpcb
->r_prog
);
829 *p
++ = cpu_to_be32(rpcb
->r_vers
);
830 *p
++ = cpu_to_be32(rpcb
->r_prot
);
831 *p
= cpu_to_be32(rpcb
->r_port
);
834 static int rpcb_dec_getport(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
835 struct rpcbind_args
*rpcb
)
842 p
= xdr_inline_decode(xdr
, 4);
843 if (unlikely(p
== NULL
))
846 port
= be32_to_cpup(p
);
847 dprintk("RPC: %5u PMAP_%s result: %lu\n", req
->rq_task
->tk_pid
,
848 req
->rq_task
->tk_msg
.rpc_proc
->p_name
, port
);
849 if (unlikely(port
> USHRT_MAX
))
856 static int rpcb_dec_set(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
861 p
= xdr_inline_decode(xdr
, 4);
862 if (unlikely(p
== NULL
))
869 dprintk("RPC: %5u RPCB_%s call %s\n",
870 req
->rq_task
->tk_pid
,
871 req
->rq_task
->tk_msg
.rpc_proc
->p_name
,
872 (*boolp
? "succeeded" : "failed"));
876 static void encode_rpcb_string(struct xdr_stream
*xdr
, const char *string
,
882 len
= strlen(string
);
883 BUG_ON(len
> maxstrlen
);
884 p
= xdr_reserve_space(xdr
, 4 + len
);
885 xdr_encode_opaque(p
, string
, len
);
888 static void rpcb_enc_getaddr(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
889 const struct rpcbind_args
*rpcb
)
893 dprintk("RPC: %5u encoding RPCB_%s call (%u, %u, '%s', '%s')\n",
894 req
->rq_task
->tk_pid
,
895 req
->rq_task
->tk_msg
.rpc_proc
->p_name
,
896 rpcb
->r_prog
, rpcb
->r_vers
,
897 rpcb
->r_netid
, rpcb
->r_addr
);
899 p
= xdr_reserve_space(xdr
, (RPCB_program_sz
+ RPCB_version_sz
) << 2);
900 *p
++ = cpu_to_be32(rpcb
->r_prog
);
901 *p
= cpu_to_be32(rpcb
->r_vers
);
903 encode_rpcb_string(xdr
, rpcb
->r_netid
, RPCBIND_MAXNETIDLEN
);
904 encode_rpcb_string(xdr
, rpcb
->r_addr
, RPCBIND_MAXUADDRLEN
);
905 encode_rpcb_string(xdr
, rpcb
->r_owner
, RPCB_MAXOWNERLEN
);
908 static int rpcb_dec_getaddr(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
909 struct rpcbind_args
*rpcb
)
911 struct sockaddr_storage address
;
912 struct sockaddr
*sap
= (struct sockaddr
*)&address
;
918 p
= xdr_inline_decode(xdr
, 4);
919 if (unlikely(p
== NULL
))
921 len
= be32_to_cpup(p
);
924 * If the returned universal address is a null string,
925 * the requested RPC service was not registered.
928 dprintk("RPC: %5u RPCB reply: program not registered\n",
929 req
->rq_task
->tk_pid
);
933 if (unlikely(len
> RPCBIND_MAXUADDRLEN
))
936 p
= xdr_inline_decode(xdr
, len
);
937 if (unlikely(p
== NULL
))
939 dprintk("RPC: %5u RPCB_%s reply: %s\n", req
->rq_task
->tk_pid
,
940 req
->rq_task
->tk_msg
.rpc_proc
->p_name
, (char *)p
);
942 if (rpc_uaddr2sockaddr(req
->rq_xprt
->xprt_net
, (char *)p
, len
,
943 sap
, sizeof(address
)) == 0)
945 rpcb
->r_port
= rpc_get_port(sap
);
950 dprintk("RPC: %5u malformed RPCB_%s reply\n",
951 req
->rq_task
->tk_pid
,
952 req
->rq_task
->tk_msg
.rpc_proc
->p_name
);
957 * Not all rpcbind procedures described in RFC 1833 are implemented
958 * since the Linux kernel RPC code requires only these.
961 static struct rpc_procinfo rpcb_procedures2
[] = {
963 .p_proc
= RPCBPROC_SET
,
964 .p_encode
= (kxdreproc_t
)rpcb_enc_mapping
,
965 .p_decode
= (kxdrdproc_t
)rpcb_dec_set
,
966 .p_arglen
= RPCB_mappingargs_sz
,
967 .p_replen
= RPCB_setres_sz
,
968 .p_statidx
= RPCBPROC_SET
,
973 .p_proc
= RPCBPROC_UNSET
,
974 .p_encode
= (kxdreproc_t
)rpcb_enc_mapping
,
975 .p_decode
= (kxdrdproc_t
)rpcb_dec_set
,
976 .p_arglen
= RPCB_mappingargs_sz
,
977 .p_replen
= RPCB_setres_sz
,
978 .p_statidx
= RPCBPROC_UNSET
,
982 [RPCBPROC_GETPORT
] = {
983 .p_proc
= RPCBPROC_GETPORT
,
984 .p_encode
= (kxdreproc_t
)rpcb_enc_mapping
,
985 .p_decode
= (kxdrdproc_t
)rpcb_dec_getport
,
986 .p_arglen
= RPCB_mappingargs_sz
,
987 .p_replen
= RPCB_getportres_sz
,
988 .p_statidx
= RPCBPROC_GETPORT
,
994 static struct rpc_procinfo rpcb_procedures3
[] = {
996 .p_proc
= RPCBPROC_SET
,
997 .p_encode
= (kxdreproc_t
)rpcb_enc_getaddr
,
998 .p_decode
= (kxdrdproc_t
)rpcb_dec_set
,
999 .p_arglen
= RPCB_getaddrargs_sz
,
1000 .p_replen
= RPCB_setres_sz
,
1001 .p_statidx
= RPCBPROC_SET
,
1005 [RPCBPROC_UNSET
] = {
1006 .p_proc
= RPCBPROC_UNSET
,
1007 .p_encode
= (kxdreproc_t
)rpcb_enc_getaddr
,
1008 .p_decode
= (kxdrdproc_t
)rpcb_dec_set
,
1009 .p_arglen
= RPCB_getaddrargs_sz
,
1010 .p_replen
= RPCB_setres_sz
,
1011 .p_statidx
= RPCBPROC_UNSET
,
1015 [RPCBPROC_GETADDR
] = {
1016 .p_proc
= RPCBPROC_GETADDR
,
1017 .p_encode
= (kxdreproc_t
)rpcb_enc_getaddr
,
1018 .p_decode
= (kxdrdproc_t
)rpcb_dec_getaddr
,
1019 .p_arglen
= RPCB_getaddrargs_sz
,
1020 .p_replen
= RPCB_getaddrres_sz
,
1021 .p_statidx
= RPCBPROC_GETADDR
,
1023 .p_name
= "GETADDR",
1027 static struct rpc_procinfo rpcb_procedures4
[] = {
1029 .p_proc
= RPCBPROC_SET
,
1030 .p_encode
= (kxdreproc_t
)rpcb_enc_getaddr
,
1031 .p_decode
= (kxdrdproc_t
)rpcb_dec_set
,
1032 .p_arglen
= RPCB_getaddrargs_sz
,
1033 .p_replen
= RPCB_setres_sz
,
1034 .p_statidx
= RPCBPROC_SET
,
1038 [RPCBPROC_UNSET
] = {
1039 .p_proc
= RPCBPROC_UNSET
,
1040 .p_encode
= (kxdreproc_t
)rpcb_enc_getaddr
,
1041 .p_decode
= (kxdrdproc_t
)rpcb_dec_set
,
1042 .p_arglen
= RPCB_getaddrargs_sz
,
1043 .p_replen
= RPCB_setres_sz
,
1044 .p_statidx
= RPCBPROC_UNSET
,
1048 [RPCBPROC_GETADDR
] = {
1049 .p_proc
= RPCBPROC_GETADDR
,
1050 .p_encode
= (kxdreproc_t
)rpcb_enc_getaddr
,
1051 .p_decode
= (kxdrdproc_t
)rpcb_dec_getaddr
,
1052 .p_arglen
= RPCB_getaddrargs_sz
,
1053 .p_replen
= RPCB_getaddrres_sz
,
1054 .p_statidx
= RPCBPROC_GETADDR
,
1056 .p_name
= "GETADDR",
1060 static const struct rpcb_info rpcb_next_version
[] = {
1062 .rpc_vers
= RPCBVERS_2
,
1063 .rpc_proc
= &rpcb_procedures2
[RPCBPROC_GETPORT
],
1070 static const struct rpcb_info rpcb_next_version6
[] = {
1072 .rpc_vers
= RPCBVERS_4
,
1073 .rpc_proc
= &rpcb_procedures4
[RPCBPROC_GETADDR
],
1076 .rpc_vers
= RPCBVERS_3
,
1077 .rpc_proc
= &rpcb_procedures3
[RPCBPROC_GETADDR
],
1084 static const struct rpc_version rpcb_version2
= {
1085 .number
= RPCBVERS_2
,
1086 .nrprocs
= ARRAY_SIZE(rpcb_procedures2
),
1087 .procs
= rpcb_procedures2
1090 static const struct rpc_version rpcb_version3
= {
1091 .number
= RPCBVERS_3
,
1092 .nrprocs
= ARRAY_SIZE(rpcb_procedures3
),
1093 .procs
= rpcb_procedures3
1096 static const struct rpc_version rpcb_version4
= {
1097 .number
= RPCBVERS_4
,
1098 .nrprocs
= ARRAY_SIZE(rpcb_procedures4
),
1099 .procs
= rpcb_procedures4
1102 static const struct rpc_version
*rpcb_version
[] = {
1110 static struct rpc_stat rpcb_stats
;
1112 static const struct rpc_program rpcb_program
= {
1114 .number
= RPCBIND_PROGRAM
,
1115 .nrvers
= ARRAY_SIZE(rpcb_version
),
1116 .version
= rpcb_version
,
1117 .stats
= &rpcb_stats
,