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