1
2
3
4
5
6
7
8
9
10
11
12
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
24#include <linux/sunrpc/clnt.h>
25#include <linux/sunrpc/sched.h>
26#include <linux/sunrpc/xprtsock.h>
27
28#ifdef RPC_DEBUG
29# define RPCDBG_FACILITY RPCDBG_BIND
30#endif
31
32#define RPCBIND_PROGRAM (100000u)
33#define RPCBIND_PORT (111u)
34
35enum {
36 RPCBPROC_NULL,
37 RPCBPROC_SET,
38 RPCBPROC_UNSET,
39 RPCBPROC_GETPORT,
40 RPCBPROC_GETADDR = 3,
41 RPCBPROC_DUMP,
42 RPCBPROC_CALLIT,
43 RPCBPROC_BCAST = 5,
44 RPCBPROC_GETTIME,
45 RPCBPROC_UADDR2TADDR,
46 RPCBPROC_TADDR2UADDR,
47 RPCBPROC_GETVERSADDR,
48 RPCBPROC_INDIRECT,
49 RPCBPROC_GETADDRLIST,
50 RPCBPROC_GETSTAT,
51};
52
53#define RPCB_HIGHPROC_2 RPCBPROC_CALLIT
54#define RPCB_HIGHPROC_3 RPCBPROC_TADDR2UADDR
55#define RPCB_HIGHPROC_4 RPCBPROC_GETSTAT
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94#define RPCB_MAXADDRLEN (128u)
95
96
97
98
99
100
101
102#define RPCB_OWNER_STRING "rpcb"
103#define RPCB_MAXOWNERLEN sizeof(RPCB_OWNER_STRING)
104
105static void rpcb_getport_done(struct rpc_task *, void *);
106static struct rpc_program rpcb_program;
107
108struct rpcbind_args {
109 struct rpc_xprt * r_xprt;
110
111 u32 r_prog;
112 u32 r_vers;
113 u32 r_prot;
114 unsigned short r_port;
115 char * r_netid;
116 char r_addr[RPCB_MAXADDRLEN];
117 char * r_owner;
118};
119
120static struct rpc_procinfo rpcb_procedures2[];
121static struct rpc_procinfo rpcb_procedures3[];
122
123struct rpcb_info {
124 int rpc_vers;
125 struct rpc_procinfo * rpc_proc;
126};
127
128static struct rpcb_info rpcb_next_version[];
129static struct rpcb_info rpcb_next_version6[];
130
131static void rpcb_getport_prepare(struct rpc_task *task, void *calldata)
132{
133 struct rpcbind_args *map = calldata;
134 struct rpc_xprt *xprt = map->r_xprt;
135 struct rpc_message msg = {
136 .rpc_proc = rpcb_next_version[xprt->bind_index].rpc_proc,
137 .rpc_argp = map,
138 .rpc_resp = &map->r_port,
139 };
140
141 rpc_call_setup(task, &msg, 0);
142}
143
144static void rpcb_map_release(void *data)
145{
146 struct rpcbind_args *map = data;
147
148 xprt_put(map->r_xprt);
149 kfree(map);
150}
151
152static const struct rpc_call_ops rpcb_getport_ops = {
153 .rpc_call_prepare = rpcb_getport_prepare,
154 .rpc_call_done = rpcb_getport_done,
155 .rpc_release = rpcb_map_release,
156};
157
158static void rpcb_wake_rpcbind_waiters(struct rpc_xprt *xprt, int status)
159{
160 xprt_clear_binding(xprt);
161 rpc_wake_up_status(&xprt->binding, status);
162}
163
164static struct rpc_clnt *rpcb_create(char *hostname, struct sockaddr *srvaddr,
165 int proto, int version, int privileged)
166{
167 struct rpc_create_args args = {
168 .protocol = proto,
169 .address = srvaddr,
170 .addrsize = sizeof(struct sockaddr_in),
171 .servername = hostname,
172 .program = &rpcb_program,
173 .version = version,
174 .authflavor = RPC_AUTH_UNIX,
175 .flags = (RPC_CLNT_CREATE_NOPING |
176 RPC_CLNT_CREATE_INTR),
177 };
178
179 switch (srvaddr->sa_family) {
180 case AF_INET:
181 ((struct sockaddr_in *)srvaddr)->sin_port = htons(RPCBIND_PORT);
182 break;
183 case AF_INET6:
184 ((struct sockaddr_in6 *)srvaddr)->sin6_port = htons(RPCBIND_PORT);
185 break;
186 default:
187 return NULL;
188 }
189
190 if (!privileged)
191 args.flags |= RPC_CLNT_CREATE_NONPRIVPORT;
192 return rpc_create(&args);
193}
194
195
196
197
198
199
200
201
202
203
204
205
206
207int rpcb_register(u32 prog, u32 vers, int prot, unsigned short port, int *okay)
208{
209 struct sockaddr_in sin = {
210 .sin_family = AF_INET,
211 .sin_addr.s_addr = htonl(INADDR_LOOPBACK),
212 };
213 struct rpcbind_args map = {
214 .r_prog = prog,
215 .r_vers = vers,
216 .r_prot = prot,
217 .r_port = port,
218 };
219 struct rpc_message msg = {
220 .rpc_proc = &rpcb_procedures2[port ?
221 RPCBPROC_SET : RPCBPROC_UNSET],
222 .rpc_argp = &map,
223 .rpc_resp = okay,
224 };
225 struct rpc_clnt *rpcb_clnt;
226 int error = 0;
227
228 dprintk("RPC: %sregistering (%u, %u, %d, %u) with local "
229 "rpcbind\n", (port ? "" : "un"),
230 prog, vers, prot, port);
231
232 rpcb_clnt = rpcb_create("localhost", (struct sockaddr *) &sin,
233 XPRT_TRANSPORT_UDP, 2, 1);
234 if (IS_ERR(rpcb_clnt))
235 return PTR_ERR(rpcb_clnt);
236
237 error = rpc_call_sync(rpcb_clnt, &msg, 0);
238
239 rpc_shutdown_client(rpcb_clnt);
240 if (error < 0)
241 printk(KERN_WARNING "RPC: failed to contact local rpcbind "
242 "server (errno %d).\n", -error);
243 dprintk("RPC: registration status %d/%d\n", error, *okay);
244
245 return error;
246}
247
248
249
250
251
252
253
254
255
256
257
258
259
260int rpcb_getport_sync(struct sockaddr_in *sin, __u32 prog,
261 __u32 vers, int prot)
262{
263 struct rpcbind_args map = {
264 .r_prog = prog,
265 .r_vers = vers,
266 .r_prot = prot,
267 .r_port = 0,
268 };
269 struct rpc_message msg = {
270 .rpc_proc = &rpcb_procedures2[RPCBPROC_GETPORT],
271 .rpc_argp = &map,
272 .rpc_resp = &map.r_port,
273 };
274 struct rpc_clnt *rpcb_clnt;
275 char hostname[40];
276 int status;
277
278 dprintk("RPC: %s(" NIPQUAD_FMT ", %u, %u, %d)\n",
279 __FUNCTION__, NIPQUAD(sin->sin_addr.s_addr), prog, vers, prot);
280
281 sprintf(hostname, NIPQUAD_FMT, NIPQUAD(sin->sin_addr.s_addr));
282 rpcb_clnt = rpcb_create(hostname, (struct sockaddr *)sin, prot, 2, 0);
283 if (IS_ERR(rpcb_clnt))
284 return PTR_ERR(rpcb_clnt);
285
286 status = rpc_call_sync(rpcb_clnt, &msg, 0);
287 rpc_shutdown_client(rpcb_clnt);
288
289 if (status >= 0) {
290 if (map.r_port != 0)
291 return map.r_port;
292 status = -EACCES;
293 }
294 return status;
295}
296EXPORT_SYMBOL_GPL(rpcb_getport_sync);
297
298
299
300
301
302
303
304
305void rpcb_getport_async(struct rpc_task *task)
306{
307 struct rpc_clnt *clnt = task->tk_client;
308 int bind_version;
309 struct rpc_xprt *xprt = task->tk_xprt;
310 struct rpc_clnt *rpcb_clnt;
311 static struct rpcbind_args *map;
312 struct rpc_task *child;
313 struct sockaddr addr;
314 int status;
315 struct rpcb_info *info;
316
317 dprintk("RPC: %5u %s(%s, %u, %u, %d)\n",
318 task->tk_pid, __FUNCTION__,
319 clnt->cl_server, clnt->cl_prog, clnt->cl_vers, xprt->prot);
320
321
322 BUG_ON(clnt->cl_parent != clnt);
323
324 if (xprt_test_and_set_binding(xprt)) {
325 status = -EAGAIN;
326 dprintk("RPC: %5u %s: waiting for another binder\n",
327 task->tk_pid, __FUNCTION__);
328 goto bailout_nowake;
329 }
330
331
332
333 rpc_sleep_on(&xprt->binding, task, NULL, NULL);
334
335
336 if (xprt_bound(xprt)) {
337 status = 0;
338 dprintk("RPC: %5u %s: already bound\n",
339 task->tk_pid, __FUNCTION__);
340 goto bailout_nofree;
341 }
342
343 rpc_peeraddr(clnt, (void *)&addr, sizeof(addr));
344
345
346 switch (addr.sa_family) {
347 case AF_INET:
348 info = rpcb_next_version;
349 break;
350 case AF_INET6:
351 info = rpcb_next_version6;
352 break;
353 default:
354 status = -EAFNOSUPPORT;
355 dprintk("RPC: %5u %s: bad address family\n",
356 task->tk_pid, __FUNCTION__);
357 goto bailout_nofree;
358 }
359 if (info[xprt->bind_index].rpc_proc == NULL) {
360 xprt->bind_index = 0;
361 status = -EPFNOSUPPORT;
362 dprintk("RPC: %5u %s: no more getport versions available\n",
363 task->tk_pid, __FUNCTION__);
364 goto bailout_nofree;
365 }
366 bind_version = info[xprt->bind_index].rpc_vers;
367
368 dprintk("RPC: %5u %s: trying rpcbind version %u\n",
369 task->tk_pid, __FUNCTION__, bind_version);
370
371 rpcb_clnt = rpcb_create(clnt->cl_server, &addr, xprt->prot,
372 bind_version, 0);
373 if (IS_ERR(rpcb_clnt)) {
374 status = PTR_ERR(rpcb_clnt);
375 dprintk("RPC: %5u %s: rpcb_create failed, error %ld\n",
376 task->tk_pid, __FUNCTION__, PTR_ERR(rpcb_clnt));
377 goto bailout_nofree;
378 }
379
380 map = kzalloc(sizeof(struct rpcbind_args), GFP_ATOMIC);
381 if (!map) {
382 status = -ENOMEM;
383 dprintk("RPC: %5u %s: no memory available\n",
384 task->tk_pid, __FUNCTION__);
385 goto bailout_nofree;
386 }
387 map->r_prog = clnt->cl_prog;
388 map->r_vers = clnt->cl_vers;
389 map->r_prot = xprt->prot;
390 map->r_port = 0;
391 map->r_xprt = xprt_get(xprt);
392 map->r_netid = rpc_peeraddr2str(clnt, RPC_DISPLAY_NETID);
393 memcpy(map->r_addr,
394 rpc_peeraddr2str(rpcb_clnt, RPC_DISPLAY_UNIVERSAL_ADDR),
395 sizeof(map->r_addr));
396 map->r_owner = RPCB_OWNER_STRING;
397
398 child = rpc_run_task(rpcb_clnt, RPC_TASK_ASYNC, &rpcb_getport_ops, map);
399 rpc_release_client(rpcb_clnt);
400 if (IS_ERR(child)) {
401 status = -EIO;
402 dprintk("RPC: %5u %s: rpc_run_task failed\n",
403 task->tk_pid, __FUNCTION__);
404 goto bailout;
405 }
406 rpc_put_task(child);
407
408 task->tk_xprt->stat.bind_count++;
409 return;
410
411bailout:
412 kfree(map);
413 xprt_put(xprt);
414bailout_nofree:
415 rpcb_wake_rpcbind_waiters(xprt, status);
416bailout_nowake:
417 task->tk_status = status;
418}
419EXPORT_SYMBOL_GPL(rpcb_getport_async);
420
421
422
423
424static void rpcb_getport_done(struct rpc_task *child, void *data)
425{
426 struct rpcbind_args *map = data;
427 struct rpc_xprt *xprt = map->r_xprt;
428 int status = child->tk_status;
429
430
431 if (status == -EIO)
432 status = -EPROTONOSUPPORT;
433
434
435 if (status == -EPROTONOSUPPORT)
436 xprt->bind_index++;
437
438 if (status < 0) {
439
440 xprt->ops->set_port(xprt, 0);
441 } else if (map->r_port == 0) {
442
443 xprt->ops->set_port(xprt, 0);
444 status = -EACCES;
445 } else {
446
447 xprt->ops->set_port(xprt, map->r_port);
448 xprt_set_bound(xprt);
449 status = 0;
450 }
451
452 dprintk("RPC: %5u rpcb_getport_done(status %d, port %u)\n",
453 child->tk_pid, status, map->r_port);
454
455 rpcb_wake_rpcbind_waiters(xprt, status);
456}
457
458static int rpcb_encode_mapping(struct rpc_rqst *req, __be32 *p,
459 struct rpcbind_args *rpcb)
460{
461 dprintk("RPC: rpcb_encode_mapping(%u, %u, %d, %u)\n",
462 rpcb->r_prog, rpcb->r_vers, rpcb->r_prot, rpcb->r_port);
463 *p++ = htonl(rpcb->r_prog);
464 *p++ = htonl(rpcb->r_vers);
465 *p++ = htonl(rpcb->r_prot);
466 *p++ = htonl(rpcb->r_port);
467
468 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
469 return 0;
470}
471
472static int rpcb_decode_getport(struct rpc_rqst *req, __be32 *p,
473 unsigned short *portp)
474{
475 *portp = (unsigned short) ntohl(*p++);
476 dprintk("RPC: rpcb_decode_getport result %u\n",
477 *portp);
478 return 0;
479}
480
481static int rpcb_decode_set(struct rpc_rqst *req, __be32 *p,
482 unsigned int *boolp)
483{
484 *boolp = (unsigned int) ntohl(*p++);
485 dprintk("RPC: rpcb_decode_set result %u\n",
486 *boolp);
487 return 0;
488}
489
490static int rpcb_encode_getaddr(struct rpc_rqst *req, __be32 *p,
491 struct rpcbind_args *rpcb)
492{
493 dprintk("RPC: rpcb_encode_getaddr(%u, %u, %s)\n",
494 rpcb->r_prog, rpcb->r_vers, rpcb->r_addr);
495 *p++ = htonl(rpcb->r_prog);
496 *p++ = htonl(rpcb->r_vers);
497
498 p = xdr_encode_string(p, rpcb->r_netid);
499 p = xdr_encode_string(p, rpcb->r_addr);
500 p = xdr_encode_string(p, rpcb->r_owner);
501
502 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
503
504 return 0;
505}
506
507static int rpcb_decode_getaddr(struct rpc_rqst *req, __be32 *p,
508 unsigned short *portp)
509{
510 char *addr;
511 u32 addr_len;
512 int c, i, f, first, val;
513
514 *portp = 0;
515 addr_len = ntohl(*p++);
516
517
518
519
520
521 if (addr_len < 11 || addr_len > RPCB_MAXADDRLEN)
522 goto out_err;
523
524
525
526
527
528
529 addr = (char *)p;
530 val = 0;
531 first = 1;
532 f = 1;
533 for (i = addr_len - 1; i > 0; i--) {
534 c = addr[i];
535 if (c >= '0' && c <= '9') {
536 val += (c - '0') * f;
537 f *= 10;
538 } else if (c == '.') {
539 if (first) {
540 *portp = val;
541 val = first = 0;
542 f = 1;
543 } else {
544 *portp |= (val << 8);
545 break;
546 }
547 }
548 }
549
550
551
552
553
554 if (first)
555 goto out_err;
556
557 dprintk("RPC: rpcb_decode_getaddr port=%u\n", *portp);
558 return 0;
559
560out_err:
561 dprintk("RPC: rpcbind server returned malformed reply\n");
562 return -EIO;
563}
564
565#define RPCB_program_sz (1u)
566#define RPCB_version_sz (1u)
567#define RPCB_protocol_sz (1u)
568#define RPCB_port_sz (1u)
569#define RPCB_boolean_sz (1u)
570
571#define RPCB_netid_sz (1+XDR_QUADLEN(RPCBIND_MAXNETIDLEN))
572#define RPCB_addr_sz (1+XDR_QUADLEN(RPCB_MAXADDRLEN))
573#define RPCB_ownerstring_sz (1+XDR_QUADLEN(RPCB_MAXOWNERLEN))
574
575#define RPCB_mappingargs_sz RPCB_program_sz+RPCB_version_sz+ \
576 RPCB_protocol_sz+RPCB_port_sz
577#define RPCB_getaddrargs_sz RPCB_program_sz+RPCB_version_sz+ \
578 RPCB_netid_sz+RPCB_addr_sz+ \
579 RPCB_ownerstring_sz
580
581#define RPCB_setres_sz RPCB_boolean_sz
582#define RPCB_getportres_sz RPCB_port_sz
583
584
585
586
587
588#define RPCB_getaddrres_sz RPCB_addr_sz
589
590#define PROC(proc, argtype, restype) \
591 [RPCBPROC_##proc] = { \
592 .p_proc = RPCBPROC_##proc, \
593 .p_encode = (kxdrproc_t) rpcb_encode_##argtype, \
594 .p_decode = (kxdrproc_t) rpcb_decode_##restype, \
595 .p_arglen = RPCB_##argtype##args_sz, \
596 .p_replen = RPCB_##restype##res_sz, \
597 .p_statidx = RPCBPROC_##proc, \
598 .p_timer = 0, \
599 .p_name = #proc, \
600 }
601
602
603
604
605
606static struct rpc_procinfo rpcb_procedures2[] = {
607 PROC(SET, mapping, set),
608 PROC(UNSET, mapping, set),
609 PROC(GETADDR, mapping, getport),
610};
611
612static struct rpc_procinfo rpcb_procedures3[] = {
613 PROC(SET, mapping, set),
614 PROC(UNSET, mapping, set),
615 PROC(GETADDR, getaddr, getaddr),
616};
617
618static struct rpc_procinfo rpcb_procedures4[] = {
619 PROC(SET, mapping, set),
620 PROC(UNSET, mapping, set),
621 PROC(GETVERSADDR, getaddr, getaddr),
622};
623
624static struct rpcb_info rpcb_next_version[] = {
625#ifdef CONFIG_SUNRPC_BIND34
626 { 4, &rpcb_procedures4[RPCBPROC_GETVERSADDR] },
627 { 3, &rpcb_procedures3[RPCBPROC_GETADDR] },
628#endif
629 { 2, &rpcb_procedures2[RPCBPROC_GETPORT] },
630 { 0, NULL },
631};
632
633static struct rpcb_info rpcb_next_version6[] = {
634#ifdef CONFIG_SUNRPC_BIND34
635 { 4, &rpcb_procedures4[RPCBPROC_GETVERSADDR] },
636 { 3, &rpcb_procedures3[RPCBPROC_GETADDR] },
637#endif
638 { 0, NULL },
639};
640
641static struct rpc_version rpcb_version2 = {
642 .number = 2,
643 .nrprocs = RPCB_HIGHPROC_2,
644 .procs = rpcb_procedures2
645};
646
647static struct rpc_version rpcb_version3 = {
648 .number = 3,
649 .nrprocs = RPCB_HIGHPROC_3,
650 .procs = rpcb_procedures3
651};
652
653static struct rpc_version rpcb_version4 = {
654 .number = 4,
655 .nrprocs = RPCB_HIGHPROC_4,
656 .procs = rpcb_procedures4
657};
658
659static struct rpc_version *rpcb_version[] = {
660 NULL,
661 NULL,
662 &rpcb_version2,
663 &rpcb_version3,
664 &rpcb_version4
665};
666
667static struct rpc_stat rpcb_stats;
668
669static struct rpc_program rpcb_program = {
670 .name = "rpcbind",
671 .number = RPCBIND_PROGRAM,
672 .nrvers = ARRAY_SIZE(rpcb_version),
673 .version = rpcb_version,
674 .stats = &rpcb_stats,
675};
676