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