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