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