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