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>
28 #include <linux/sunrpc/clnt.h>
29 #include <linux/sunrpc/sched.h>
30 #include <linux/sunrpc/xprtsock.h>
35 # define RPCDBG_FACILITY RPCDBG_BIND
38 #define RPCBIND_SOCK_PATHNAME "/var/run/rpcbind.sock"
40 #define RPCBIND_PROGRAM (100000u)
41 #define RPCBIND_PORT (111u)
43 #define RPCBVERS_2 (2u)
44 #define RPCBVERS_3 (3u)
45 #define RPCBVERS_4 (4u)
52 RPCBPROC_GETADDR
= 3, /* alias for GETPORT */
55 RPCBPROC_BCAST
= 5, /* alias for CALLIT */
68 * The "owner" is allowed to unset a service in the rpcbind database.
70 * For AF_LOCAL SET/UNSET requests, rpcbind treats this string as a
71 * UID which it maps to a local user name via a password lookup.
72 * In all other cases it is ignored.
74 * For SET/UNSET requests, user space provides a value, even for
75 * network requests, and GETADDR uses an empty string. We follow
76 * those precedents here.
78 #define RPCB_OWNER_STRING "0"
79 #define RPCB_MAXOWNERLEN sizeof(RPCB_OWNER_STRING)
84 #define RPCB_program_sz (1)
85 #define RPCB_version_sz (1)
86 #define RPCB_protocol_sz (1)
87 #define RPCB_port_sz (1)
88 #define RPCB_boolean_sz (1)
90 #define RPCB_netid_sz (1 + XDR_QUADLEN(RPCBIND_MAXNETIDLEN))
91 #define RPCB_addr_sz (1 + XDR_QUADLEN(RPCBIND_MAXUADDRLEN))
92 #define RPCB_ownerstring_sz (1 + XDR_QUADLEN(RPCB_MAXOWNERLEN))
95 * XDR argument and result sizes
97 #define RPCB_mappingargs_sz (RPCB_program_sz + RPCB_version_sz + \
98 RPCB_protocol_sz + RPCB_port_sz)
99 #define RPCB_getaddrargs_sz (RPCB_program_sz + RPCB_version_sz + \
100 RPCB_netid_sz + RPCB_addr_sz + \
103 #define RPCB_getportres_sz RPCB_port_sz
104 #define RPCB_setres_sz RPCB_boolean_sz
107 * Note that RFC 1833 does not put any size restrictions on the
108 * address string returned by the remote rpcbind database.
110 #define RPCB_getaddrres_sz RPCB_addr_sz
112 static void rpcb_getport_done(struct rpc_task
*, void *);
113 static void rpcb_map_release(void *data
);
114 static const struct rpc_program rpcb_program
;
116 struct rpcbind_args
{
117 struct rpc_xprt
* r_xprt
;
122 unsigned short r_port
;
123 const char * r_netid
;
125 const char * r_owner
;
130 static struct rpc_procinfo rpcb_procedures2
[];
131 static struct rpc_procinfo rpcb_procedures3
[];
132 static struct rpc_procinfo rpcb_procedures4
[];
136 struct rpc_procinfo
* rpc_proc
;
139 static const struct rpcb_info rpcb_next_version
[];
140 static const struct rpcb_info rpcb_next_version6
[];
142 static const struct rpc_call_ops rpcb_getport_ops
= {
143 .rpc_call_done
= rpcb_getport_done
,
144 .rpc_release
= rpcb_map_release
,
147 static void rpcb_wake_rpcbind_waiters(struct rpc_xprt
*xprt
, int status
)
149 xprt_clear_binding(xprt
);
150 rpc_wake_up_status(&xprt
->binding
, status
);
153 static void rpcb_map_release(void *data
)
155 struct rpcbind_args
*map
= data
;
157 rpcb_wake_rpcbind_waiters(map
->r_xprt
, map
->r_status
);
158 xprt_put(map
->r_xprt
);
163 static int rpcb_get_local(struct net
*net
)
166 struct sunrpc_net
*sn
= net_generic(net
, sunrpc_net_id
);
168 spin_lock(&sn
->rpcb_clnt_lock
);
171 cnt
= sn
->rpcb_users
;
172 spin_unlock(&sn
->rpcb_clnt_lock
);
177 void rpcb_put_local(struct net
*net
)
179 struct sunrpc_net
*sn
= net_generic(net
, sunrpc_net_id
);
180 struct rpc_clnt
*clnt
= sn
->rpcb_local_clnt
;
181 struct rpc_clnt
*clnt4
= sn
->rpcb_local_clnt4
;
184 spin_lock(&sn
->rpcb_clnt_lock
);
185 if (sn
->rpcb_users
) {
186 if (--sn
->rpcb_users
== 0) {
187 sn
->rpcb_local_clnt
= NULL
;
188 sn
->rpcb_local_clnt4
= NULL
;
190 shutdown
= !sn
->rpcb_users
;
192 spin_unlock(&sn
->rpcb_clnt_lock
);
196 * cleanup_rpcb_clnt - remove xprtsock's sysctls, unregister
199 rpc_shutdown_client(clnt4
);
201 rpc_shutdown_client(clnt
);
205 static void rpcb_set_local(struct net
*net
, struct rpc_clnt
*clnt
,
206 struct rpc_clnt
*clnt4
)
208 struct sunrpc_net
*sn
= net_generic(net
, sunrpc_net_id
);
210 /* Protected by rpcb_create_local_mutex */
211 sn
->rpcb_local_clnt
= clnt
;
212 sn
->rpcb_local_clnt4
= clnt4
;
215 dprintk("RPC: created new rpcb local clients (rpcb_local_clnt: "
216 "%p, rpcb_local_clnt4: %p) for net %p%s\n",
217 sn
->rpcb_local_clnt
, sn
->rpcb_local_clnt4
,
218 net
, (net
== &init_net
) ? " (init_net)" : "");
222 * Returns zero on success, otherwise a negative errno value
225 static int rpcb_create_local_unix(struct net
*net
)
227 static const struct sockaddr_un rpcb_localaddr_rpcbind
= {
228 .sun_family
= AF_LOCAL
,
229 .sun_path
= RPCBIND_SOCK_PATHNAME
,
231 struct rpc_create_args args
= {
233 .protocol
= XPRT_TRANSPORT_LOCAL
,
234 .address
= (struct sockaddr
*)&rpcb_localaddr_rpcbind
,
235 .addrsize
= sizeof(rpcb_localaddr_rpcbind
),
236 .servername
= "localhost",
237 .program
= &rpcb_program
,
238 .version
= RPCBVERS_2
,
239 .authflavor
= RPC_AUTH_NULL
,
241 struct rpc_clnt
*clnt
, *clnt4
;
245 * Because we requested an RPC PING at transport creation time,
246 * this works only if the user space portmapper is rpcbind, and
247 * it's listening on AF_LOCAL on the named socket.
249 clnt
= rpc_create(&args
);
251 dprintk("RPC: failed to create AF_LOCAL rpcbind "
252 "client (errno %ld).\n", PTR_ERR(clnt
));
253 result
= PTR_ERR(clnt
);
257 clnt4
= rpc_bind_new_program(clnt
, &rpcb_program
, RPCBVERS_4
);
259 dprintk("RPC: failed to bind second program to "
260 "rpcbind v4 client (errno %ld).\n",
265 rpcb_set_local(net
, clnt
, clnt4
);
272 * Returns zero on success, otherwise a negative errno value
275 static int rpcb_create_local_net(struct net
*net
)
277 static const struct sockaddr_in rpcb_inaddr_loopback
= {
278 .sin_family
= AF_INET
,
279 .sin_addr
.s_addr
= htonl(INADDR_LOOPBACK
),
280 .sin_port
= htons(RPCBIND_PORT
),
282 struct rpc_create_args args
= {
284 .protocol
= XPRT_TRANSPORT_TCP
,
285 .address
= (struct sockaddr
*)&rpcb_inaddr_loopback
,
286 .addrsize
= sizeof(rpcb_inaddr_loopback
),
287 .servername
= "localhost",
288 .program
= &rpcb_program
,
289 .version
= RPCBVERS_2
,
290 .authflavor
= RPC_AUTH_UNIX
,
291 .flags
= RPC_CLNT_CREATE_NOPING
,
293 struct rpc_clnt
*clnt
, *clnt4
;
296 clnt
= rpc_create(&args
);
298 dprintk("RPC: failed to create local rpcbind "
299 "client (errno %ld).\n", PTR_ERR(clnt
));
300 result
= PTR_ERR(clnt
);
305 * This results in an RPC ping. On systems running portmapper,
306 * the v4 ping will fail. Proceed anyway, but disallow rpcb
309 clnt4
= rpc_bind_new_program(clnt
, &rpcb_program
, RPCBVERS_4
);
311 dprintk("RPC: failed to bind second program to "
312 "rpcbind v4 client (errno %ld).\n",
317 rpcb_set_local(net
, clnt
, clnt4
);
324 * Returns zero on success, otherwise a negative errno value
327 int rpcb_create_local(struct net
*net
)
329 static DEFINE_MUTEX(rpcb_create_local_mutex
);
332 if (rpcb_get_local(net
))
335 mutex_lock(&rpcb_create_local_mutex
);
336 if (rpcb_get_local(net
))
339 if (rpcb_create_local_unix(net
) != 0)
340 result
= rpcb_create_local_net(net
);
343 mutex_unlock(&rpcb_create_local_mutex
);
347 static struct rpc_clnt
*rpcb_create(struct net
*net
, const char *hostname
,
348 struct sockaddr
*srvaddr
, size_t salen
,
349 int proto
, u32 version
)
351 struct rpc_create_args args
= {
356 .servername
= hostname
,
357 .program
= &rpcb_program
,
359 .authflavor
= RPC_AUTH_UNIX
,
360 .flags
= (RPC_CLNT_CREATE_NOPING
|
361 RPC_CLNT_CREATE_NONPRIVPORT
),
364 switch (srvaddr
->sa_family
) {
366 ((struct sockaddr_in
*)srvaddr
)->sin_port
= htons(RPCBIND_PORT
);
369 ((struct sockaddr_in6
*)srvaddr
)->sin6_port
= htons(RPCBIND_PORT
);
372 return ERR_PTR(-EAFNOSUPPORT
);
375 return rpc_create(&args
);
378 static int rpcb_register_call(struct rpc_clnt
*clnt
, struct rpc_message
*msg
)
380 int result
, error
= 0;
382 msg
->rpc_resp
= &result
;
384 error
= rpc_call_sync(clnt
, msg
, RPC_TASK_SOFTCONN
);
386 dprintk("RPC: failed to contact local rpcbind "
387 "server (errno %d).\n", -error
);
397 * rpcb_register - set or unset a port registration with the local rpcbind svc
398 * @net: target network namespace
399 * @prog: RPC program number to bind
400 * @vers: RPC version number to bind
401 * @prot: transport protocol to register
402 * @port: port value to register
404 * Returns zero if the registration request was dispatched successfully
405 * and the rpcbind daemon returned success. Otherwise, returns an errno
406 * value that reflects the nature of the error (request could not be
407 * dispatched, timed out, or rpcbind returned an error).
409 * RPC services invoke this function to advertise their contact
410 * information via the system's rpcbind daemon. RPC services
411 * invoke this function once for each [program, version, transport]
412 * tuple they wish to advertise.
414 * Callers may also unregister RPC services that are no longer
415 * available by setting the passed-in port to zero. This removes
416 * all registered transports for [program, version] from the local
419 * This function uses rpcbind protocol version 2 to contact the
420 * local rpcbind daemon.
422 * Registration works over both AF_INET and AF_INET6, and services
423 * registered via this function are advertised as available for any
424 * address. If the local rpcbind daemon is listening on AF_INET6,
425 * services registered via this function will be advertised on
426 * IN6ADDR_ANY (ie available for all AF_INET and AF_INET6
429 int rpcb_register(struct net
*net
, u32 prog
, u32 vers
, int prot
, unsigned short port
)
431 struct rpcbind_args map
= {
437 struct rpc_message msg
= {
440 struct sunrpc_net
*sn
= net_generic(net
, sunrpc_net_id
);
442 dprintk("RPC: %sregistering (%u, %u, %d, %u) with local "
443 "rpcbind\n", (port
? "" : "un"),
444 prog
, vers
, prot
, port
);
446 msg
.rpc_proc
= &rpcb_procedures2
[RPCBPROC_UNSET
];
448 msg
.rpc_proc
= &rpcb_procedures2
[RPCBPROC_SET
];
450 return rpcb_register_call(sn
->rpcb_local_clnt
, &msg
);
454 * Fill in AF_INET family-specific arguments to register
456 static int rpcb_register_inet4(struct sunrpc_net
*sn
,
457 const struct sockaddr
*sap
,
458 struct rpc_message
*msg
)
460 const struct sockaddr_in
*sin
= (const struct sockaddr_in
*)sap
;
461 struct rpcbind_args
*map
= msg
->rpc_argp
;
462 unsigned short port
= ntohs(sin
->sin_port
);
465 map
->r_addr
= rpc_sockaddr2uaddr(sap
, GFP_KERNEL
);
467 dprintk("RPC: %sregistering [%u, %u, %s, '%s'] with "
468 "local rpcbind\n", (port
? "" : "un"),
469 map
->r_prog
, map
->r_vers
,
470 map
->r_addr
, map
->r_netid
);
472 msg
->rpc_proc
= &rpcb_procedures4
[RPCBPROC_UNSET
];
474 msg
->rpc_proc
= &rpcb_procedures4
[RPCBPROC_SET
];
476 result
= rpcb_register_call(sn
->rpcb_local_clnt4
, msg
);
482 * Fill in AF_INET6 family-specific arguments to register
484 static int rpcb_register_inet6(struct sunrpc_net
*sn
,
485 const struct sockaddr
*sap
,
486 struct rpc_message
*msg
)
488 const struct sockaddr_in6
*sin6
= (const struct sockaddr_in6
*)sap
;
489 struct rpcbind_args
*map
= msg
->rpc_argp
;
490 unsigned short port
= ntohs(sin6
->sin6_port
);
493 map
->r_addr
= rpc_sockaddr2uaddr(sap
, GFP_KERNEL
);
495 dprintk("RPC: %sregistering [%u, %u, %s, '%s'] with "
496 "local rpcbind\n", (port
? "" : "un"),
497 map
->r_prog
, map
->r_vers
,
498 map
->r_addr
, map
->r_netid
);
500 msg
->rpc_proc
= &rpcb_procedures4
[RPCBPROC_UNSET
];
502 msg
->rpc_proc
= &rpcb_procedures4
[RPCBPROC_SET
];
504 result
= rpcb_register_call(sn
->rpcb_local_clnt4
, msg
);
509 static int rpcb_unregister_all_protofamilies(struct sunrpc_net
*sn
,
510 struct rpc_message
*msg
)
512 struct rpcbind_args
*map
= msg
->rpc_argp
;
514 dprintk("RPC: unregistering [%u, %u, '%s'] with "
516 map
->r_prog
, map
->r_vers
, map
->r_netid
);
519 msg
->rpc_proc
= &rpcb_procedures4
[RPCBPROC_UNSET
];
521 return rpcb_register_call(sn
->rpcb_local_clnt4
, msg
);
525 * rpcb_v4_register - set or unset a port registration with the local rpcbind
526 * @net: target network namespace
527 * @program: RPC program number of service to (un)register
528 * @version: RPC version number of service to (un)register
529 * @address: address family, IP address, and port to (un)register
530 * @netid: netid of transport protocol to (un)register
532 * Returns zero if the registration request was dispatched successfully
533 * and the rpcbind daemon returned success. Otherwise, returns an errno
534 * value that reflects the nature of the error (request could not be
535 * dispatched, timed out, or rpcbind returned an error).
537 * RPC services invoke this function to advertise their contact
538 * information via the system's rpcbind daemon. RPC services
539 * invoke this function once for each [program, version, address,
540 * netid] tuple they wish to advertise.
542 * Callers may also unregister RPC services that are registered at a
543 * specific address by setting the port number in @address to zero.
544 * They may unregister all registered protocol families at once for
545 * a service by passing a NULL @address argument. If @netid is ""
546 * then all netids for [program, version, address] are unregistered.
548 * This function uses rpcbind protocol version 4 to contact the
549 * local rpcbind daemon. The local rpcbind daemon must support
550 * version 4 of the rpcbind protocol in order for these functions
551 * to register a service successfully.
553 * Supported netids include "udp" and "tcp" for UDP and TCP over
554 * IPv4, and "udp6" and "tcp6" for UDP and TCP over IPv6,
557 * The contents of @address determine the address family and the
558 * port to be registered. The usual practice is to pass INADDR_ANY
559 * as the raw address, but specifying a non-zero address is also
560 * supported by this API if the caller wishes to advertise an RPC
561 * service on a specific network interface.
563 * Note that passing in INADDR_ANY does not create the same service
564 * registration as IN6ADDR_ANY. The former advertises an RPC
565 * service on any IPv4 address, but not on IPv6. The latter
566 * advertises the service on all IPv4 and IPv6 addresses.
568 int rpcb_v4_register(struct net
*net
, const u32 program
, const u32 version
,
569 const struct sockaddr
*address
, const char *netid
)
571 struct rpcbind_args map
= {
575 .r_owner
= RPCB_OWNER_STRING
,
577 struct rpc_message msg
= {
580 struct sunrpc_net
*sn
= net_generic(net
, sunrpc_net_id
);
582 if (sn
->rpcb_local_clnt4
== NULL
)
583 return -EPROTONOSUPPORT
;
586 return rpcb_unregister_all_protofamilies(sn
, &msg
);
588 switch (address
->sa_family
) {
590 return rpcb_register_inet4(sn
, address
, &msg
);
592 return rpcb_register_inet6(sn
, address
, &msg
);
595 return -EAFNOSUPPORT
;
598 static struct rpc_task
*rpcb_call_async(struct rpc_clnt
*rpcb_clnt
, struct rpcbind_args
*map
, struct rpc_procinfo
*proc
)
600 struct rpc_message msg
= {
605 struct rpc_task_setup task_setup_data
= {
606 .rpc_client
= rpcb_clnt
,
608 .callback_ops
= &rpcb_getport_ops
,
609 .callback_data
= map
,
610 .flags
= RPC_TASK_ASYNC
| RPC_TASK_SOFTCONN
,
613 return rpc_run_task(&task_setup_data
);
617 * In the case where rpc clients have been cloned, we want to make
618 * sure that we use the program number/version etc of the actual
619 * owner of the xprt. To do so, we walk back up the tree of parents
620 * to find whoever created the transport and/or whoever has the
623 static struct rpc_clnt
*rpcb_find_transport_owner(struct rpc_clnt
*clnt
)
625 struct rpc_clnt
*parent
= clnt
->cl_parent
;
626 struct rpc_xprt
*xprt
= rcu_dereference(clnt
->cl_xprt
);
628 while (parent
!= clnt
) {
629 if (rcu_dereference(parent
->cl_xprt
) != xprt
)
631 if (clnt
->cl_autobind
)
634 parent
= parent
->cl_parent
;
640 * rpcb_getport_async - obtain the port for a given RPC service on a given host
641 * @task: task that is waiting for portmapper request
643 * This one can be called for an ongoing RPC request, and can be used in
644 * an async (rpciod) context.
646 void rpcb_getport_async(struct rpc_task
*task
)
648 struct rpc_clnt
*clnt
;
649 struct rpc_procinfo
*proc
;
651 struct rpc_xprt
*xprt
;
652 struct rpc_clnt
*rpcb_clnt
;
653 struct rpcbind_args
*map
;
654 struct rpc_task
*child
;
655 struct sockaddr_storage addr
;
656 struct sockaddr
*sap
= (struct sockaddr
*)&addr
;
662 clnt
= rpcb_find_transport_owner(task
->tk_client
);
663 xprt
= xprt_get(rcu_dereference(clnt
->cl_xprt
));
664 } while (xprt
== NULL
);
667 dprintk("RPC: %5u %s(%s, %u, %u, %d)\n",
668 task
->tk_pid
, __func__
,
669 xprt
->servername
, clnt
->cl_prog
, clnt
->cl_vers
, xprt
->prot
);
671 /* Put self on the wait queue to ensure we get notified if
672 * some other task is already attempting to bind the port */
673 rpc_sleep_on(&xprt
->binding
, task
, NULL
);
675 if (xprt_test_and_set_binding(xprt
)) {
676 dprintk("RPC: %5u %s: waiting for another binder\n",
677 task
->tk_pid
, __func__
);
682 /* Someone else may have bound if we slept */
683 if (xprt_bound(xprt
)) {
685 dprintk("RPC: %5u %s: already bound\n",
686 task
->tk_pid
, __func__
);
690 /* Parent transport's destination address */
691 salen
= rpc_peeraddr(clnt
, sap
, sizeof(addr
));
693 /* Don't ever use rpcbind v2 for AF_INET6 requests */
694 switch (sap
->sa_family
) {
696 proc
= rpcb_next_version
[xprt
->bind_index
].rpc_proc
;
697 bind_version
= rpcb_next_version
[xprt
->bind_index
].rpc_vers
;
700 proc
= rpcb_next_version6
[xprt
->bind_index
].rpc_proc
;
701 bind_version
= rpcb_next_version6
[xprt
->bind_index
].rpc_vers
;
704 status
= -EAFNOSUPPORT
;
705 dprintk("RPC: %5u %s: bad address family\n",
706 task
->tk_pid
, __func__
);
710 xprt
->bind_index
= 0;
711 status
= -EPFNOSUPPORT
;
712 dprintk("RPC: %5u %s: no more getport versions available\n",
713 task
->tk_pid
, __func__
);
717 dprintk("RPC: %5u %s: trying rpcbind version %u\n",
718 task
->tk_pid
, __func__
, bind_version
);
720 rpcb_clnt
= rpcb_create(xprt
->xprt_net
, xprt
->servername
, sap
, salen
,
721 xprt
->prot
, bind_version
);
722 if (IS_ERR(rpcb_clnt
)) {
723 status
= PTR_ERR(rpcb_clnt
);
724 dprintk("RPC: %5u %s: rpcb_create failed, error %ld\n",
725 task
->tk_pid
, __func__
, PTR_ERR(rpcb_clnt
));
729 map
= kzalloc(sizeof(struct rpcbind_args
), GFP_ATOMIC
);
732 dprintk("RPC: %5u %s: no memory available\n",
733 task
->tk_pid
, __func__
);
734 goto bailout_release_client
;
736 map
->r_prog
= clnt
->cl_prog
;
737 map
->r_vers
= clnt
->cl_vers
;
738 map
->r_prot
= xprt
->prot
;
741 map
->r_status
= -EIO
;
743 switch (bind_version
) {
746 map
->r_netid
= xprt
->address_strings
[RPC_DISPLAY_NETID
];
747 map
->r_addr
= rpc_sockaddr2uaddr(sap
, GFP_ATOMIC
);
757 child
= rpcb_call_async(rpcb_clnt
, map
, proc
);
758 rpc_release_client(rpcb_clnt
);
760 /* rpcb_map_release() has freed the arguments */
761 dprintk("RPC: %5u %s: rpc_run_task failed\n",
762 task
->tk_pid
, __func__
);
766 xprt
->stat
.bind_count
++;
770 bailout_release_client
:
771 rpc_release_client(rpcb_clnt
);
773 rpcb_wake_rpcbind_waiters(xprt
, status
);
774 task
->tk_status
= status
;
777 EXPORT_SYMBOL_GPL(rpcb_getport_async
);
780 * Rpcbind child task calls this callback via tk_exit.
782 static void rpcb_getport_done(struct rpc_task
*child
, void *data
)
784 struct rpcbind_args
*map
= data
;
785 struct rpc_xprt
*xprt
= map
->r_xprt
;
786 int status
= child
->tk_status
;
788 /* Garbage reply: retry with a lesser rpcbind version */
790 status
= -EPROTONOSUPPORT
;
792 /* rpcbind server doesn't support this rpcbind protocol version */
793 if (status
== -EPROTONOSUPPORT
)
797 /* rpcbind server not available on remote host? */
798 xprt
->ops
->set_port(xprt
, 0);
799 } else if (map
->r_port
== 0) {
800 /* Requested RPC service wasn't registered on remote host */
801 xprt
->ops
->set_port(xprt
, 0);
805 xprt
->ops
->set_port(xprt
, map
->r_port
);
806 xprt_set_bound(xprt
);
810 dprintk("RPC: %5u rpcb_getport_done(status %d, port %u)\n",
811 child
->tk_pid
, status
, map
->r_port
);
813 map
->r_status
= status
;
817 * XDR functions for rpcbind
820 static void rpcb_enc_mapping(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
821 const struct rpcbind_args
*rpcb
)
825 dprintk("RPC: %5u encoding PMAP_%s call (%u, %u, %d, %u)\n",
826 req
->rq_task
->tk_pid
,
827 req
->rq_task
->tk_msg
.rpc_proc
->p_name
,
828 rpcb
->r_prog
, rpcb
->r_vers
, rpcb
->r_prot
, rpcb
->r_port
);
830 p
= xdr_reserve_space(xdr
, RPCB_mappingargs_sz
<< 2);
831 *p
++ = cpu_to_be32(rpcb
->r_prog
);
832 *p
++ = cpu_to_be32(rpcb
->r_vers
);
833 *p
++ = cpu_to_be32(rpcb
->r_prot
);
834 *p
= cpu_to_be32(rpcb
->r_port
);
837 static int rpcb_dec_getport(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
838 struct rpcbind_args
*rpcb
)
845 p
= xdr_inline_decode(xdr
, 4);
846 if (unlikely(p
== NULL
))
849 port
= be32_to_cpup(p
);
850 dprintk("RPC: %5u PMAP_%s result: %lu\n", req
->rq_task
->tk_pid
,
851 req
->rq_task
->tk_msg
.rpc_proc
->p_name
, port
);
852 if (unlikely(port
> USHRT_MAX
))
859 static int rpcb_dec_set(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
864 p
= xdr_inline_decode(xdr
, 4);
865 if (unlikely(p
== NULL
))
872 dprintk("RPC: %5u RPCB_%s call %s\n",
873 req
->rq_task
->tk_pid
,
874 req
->rq_task
->tk_msg
.rpc_proc
->p_name
,
875 (*boolp
? "succeeded" : "failed"));
879 static void encode_rpcb_string(struct xdr_stream
*xdr
, const char *string
,
885 len
= strlen(string
);
886 WARN_ON_ONCE(len
> maxstrlen
);
888 /* truncate and hope for the best */
890 p
= xdr_reserve_space(xdr
, 4 + len
);
891 xdr_encode_opaque(p
, string
, len
);
894 static void rpcb_enc_getaddr(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
895 const struct rpcbind_args
*rpcb
)
899 dprintk("RPC: %5u encoding RPCB_%s call (%u, %u, '%s', '%s')\n",
900 req
->rq_task
->tk_pid
,
901 req
->rq_task
->tk_msg
.rpc_proc
->p_name
,
902 rpcb
->r_prog
, rpcb
->r_vers
,
903 rpcb
->r_netid
, rpcb
->r_addr
);
905 p
= xdr_reserve_space(xdr
, (RPCB_program_sz
+ RPCB_version_sz
) << 2);
906 *p
++ = cpu_to_be32(rpcb
->r_prog
);
907 *p
= cpu_to_be32(rpcb
->r_vers
);
909 encode_rpcb_string(xdr
, rpcb
->r_netid
, RPCBIND_MAXNETIDLEN
);
910 encode_rpcb_string(xdr
, rpcb
->r_addr
, RPCBIND_MAXUADDRLEN
);
911 encode_rpcb_string(xdr
, rpcb
->r_owner
, RPCB_MAXOWNERLEN
);
914 static int rpcb_dec_getaddr(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
915 struct rpcbind_args
*rpcb
)
917 struct sockaddr_storage address
;
918 struct sockaddr
*sap
= (struct sockaddr
*)&address
;
924 p
= xdr_inline_decode(xdr
, 4);
925 if (unlikely(p
== NULL
))
927 len
= be32_to_cpup(p
);
930 * If the returned universal address is a null string,
931 * the requested RPC service was not registered.
934 dprintk("RPC: %5u RPCB reply: program not registered\n",
935 req
->rq_task
->tk_pid
);
939 if (unlikely(len
> RPCBIND_MAXUADDRLEN
))
942 p
= xdr_inline_decode(xdr
, len
);
943 if (unlikely(p
== NULL
))
945 dprintk("RPC: %5u RPCB_%s reply: %s\n", req
->rq_task
->tk_pid
,
946 req
->rq_task
->tk_msg
.rpc_proc
->p_name
, (char *)p
);
948 if (rpc_uaddr2sockaddr(req
->rq_xprt
->xprt_net
, (char *)p
, len
,
949 sap
, sizeof(address
)) == 0)
951 rpcb
->r_port
= rpc_get_port(sap
);
956 dprintk("RPC: %5u malformed RPCB_%s reply\n",
957 req
->rq_task
->tk_pid
,
958 req
->rq_task
->tk_msg
.rpc_proc
->p_name
);
963 * Not all rpcbind procedures described in RFC 1833 are implemented
964 * since the Linux kernel RPC code requires only these.
967 static struct rpc_procinfo rpcb_procedures2
[] = {
969 .p_proc
= RPCBPROC_SET
,
970 .p_encode
= (kxdreproc_t
)rpcb_enc_mapping
,
971 .p_decode
= (kxdrdproc_t
)rpcb_dec_set
,
972 .p_arglen
= RPCB_mappingargs_sz
,
973 .p_replen
= RPCB_setres_sz
,
974 .p_statidx
= RPCBPROC_SET
,
979 .p_proc
= RPCBPROC_UNSET
,
980 .p_encode
= (kxdreproc_t
)rpcb_enc_mapping
,
981 .p_decode
= (kxdrdproc_t
)rpcb_dec_set
,
982 .p_arglen
= RPCB_mappingargs_sz
,
983 .p_replen
= RPCB_setres_sz
,
984 .p_statidx
= RPCBPROC_UNSET
,
988 [RPCBPROC_GETPORT
] = {
989 .p_proc
= RPCBPROC_GETPORT
,
990 .p_encode
= (kxdreproc_t
)rpcb_enc_mapping
,
991 .p_decode
= (kxdrdproc_t
)rpcb_dec_getport
,
992 .p_arglen
= RPCB_mappingargs_sz
,
993 .p_replen
= RPCB_getportres_sz
,
994 .p_statidx
= RPCBPROC_GETPORT
,
1000 static struct rpc_procinfo rpcb_procedures3
[] = {
1002 .p_proc
= RPCBPROC_SET
,
1003 .p_encode
= (kxdreproc_t
)rpcb_enc_getaddr
,
1004 .p_decode
= (kxdrdproc_t
)rpcb_dec_set
,
1005 .p_arglen
= RPCB_getaddrargs_sz
,
1006 .p_replen
= RPCB_setres_sz
,
1007 .p_statidx
= RPCBPROC_SET
,
1011 [RPCBPROC_UNSET
] = {
1012 .p_proc
= RPCBPROC_UNSET
,
1013 .p_encode
= (kxdreproc_t
)rpcb_enc_getaddr
,
1014 .p_decode
= (kxdrdproc_t
)rpcb_dec_set
,
1015 .p_arglen
= RPCB_getaddrargs_sz
,
1016 .p_replen
= RPCB_setres_sz
,
1017 .p_statidx
= RPCBPROC_UNSET
,
1021 [RPCBPROC_GETADDR
] = {
1022 .p_proc
= RPCBPROC_GETADDR
,
1023 .p_encode
= (kxdreproc_t
)rpcb_enc_getaddr
,
1024 .p_decode
= (kxdrdproc_t
)rpcb_dec_getaddr
,
1025 .p_arglen
= RPCB_getaddrargs_sz
,
1026 .p_replen
= RPCB_getaddrres_sz
,
1027 .p_statidx
= RPCBPROC_GETADDR
,
1029 .p_name
= "GETADDR",
1033 static struct rpc_procinfo rpcb_procedures4
[] = {
1035 .p_proc
= RPCBPROC_SET
,
1036 .p_encode
= (kxdreproc_t
)rpcb_enc_getaddr
,
1037 .p_decode
= (kxdrdproc_t
)rpcb_dec_set
,
1038 .p_arglen
= RPCB_getaddrargs_sz
,
1039 .p_replen
= RPCB_setres_sz
,
1040 .p_statidx
= RPCBPROC_SET
,
1044 [RPCBPROC_UNSET
] = {
1045 .p_proc
= RPCBPROC_UNSET
,
1046 .p_encode
= (kxdreproc_t
)rpcb_enc_getaddr
,
1047 .p_decode
= (kxdrdproc_t
)rpcb_dec_set
,
1048 .p_arglen
= RPCB_getaddrargs_sz
,
1049 .p_replen
= RPCB_setres_sz
,
1050 .p_statidx
= RPCBPROC_UNSET
,
1054 [RPCBPROC_GETADDR
] = {
1055 .p_proc
= RPCBPROC_GETADDR
,
1056 .p_encode
= (kxdreproc_t
)rpcb_enc_getaddr
,
1057 .p_decode
= (kxdrdproc_t
)rpcb_dec_getaddr
,
1058 .p_arglen
= RPCB_getaddrargs_sz
,
1059 .p_replen
= RPCB_getaddrres_sz
,
1060 .p_statidx
= RPCBPROC_GETADDR
,
1062 .p_name
= "GETADDR",
1066 static const struct rpcb_info rpcb_next_version
[] = {
1068 .rpc_vers
= RPCBVERS_2
,
1069 .rpc_proc
= &rpcb_procedures2
[RPCBPROC_GETPORT
],
1076 static const struct rpcb_info rpcb_next_version6
[] = {
1078 .rpc_vers
= RPCBVERS_4
,
1079 .rpc_proc
= &rpcb_procedures4
[RPCBPROC_GETADDR
],
1082 .rpc_vers
= RPCBVERS_3
,
1083 .rpc_proc
= &rpcb_procedures3
[RPCBPROC_GETADDR
],
1090 static const struct rpc_version rpcb_version2
= {
1091 .number
= RPCBVERS_2
,
1092 .nrprocs
= ARRAY_SIZE(rpcb_procedures2
),
1093 .procs
= rpcb_procedures2
1096 static const struct rpc_version rpcb_version3
= {
1097 .number
= RPCBVERS_3
,
1098 .nrprocs
= ARRAY_SIZE(rpcb_procedures3
),
1099 .procs
= rpcb_procedures3
1102 static const struct rpc_version rpcb_version4
= {
1103 .number
= RPCBVERS_4
,
1104 .nrprocs
= ARRAY_SIZE(rpcb_procedures4
),
1105 .procs
= rpcb_procedures4
1108 static const struct rpc_version
*rpcb_version
[] = {
1116 static struct rpc_stat rpcb_stats
;
1118 static const struct rpc_program rpcb_program
= {
1120 .number
= RPCBIND_PROGRAM
,
1121 .nrvers
= ARRAY_SIZE(rpcb_version
),
1122 .version
= rpcb_version
,
1123 .stats
= &rpcb_stats
,