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