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