2 * linux/net/sunrpc/pmap_clnt.c
4 * In-kernel RPC portmapper client.
6 * Portmapper supports version 2 of the rpcbind protocol (RFC 1833).
8 * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
11 #include <linux/types.h>
12 #include <linux/socket.h>
13 #include <linux/kernel.h>
14 #include <linux/errno.h>
15 #include <linux/uio.h>
17 #include <linux/sunrpc/clnt.h>
18 #include <linux/sunrpc/xprt.h>
19 #include <linux/sunrpc/sched.h>
22 # define RPCDBG_FACILITY RPCDBG_PMAP
27 #define PMAP_GETPORT 3
33 unsigned short pm_port;
34 struct rpc_task * pm_task;
37 static struct rpc_procinfo pmap_procedures[];
38 static struct rpc_clnt * pmap_create(char *, struct sockaddr_in *, int, int);
39 static void pmap_getport_done(struct rpc_task *, void *);
40 static struct rpc_program pmap_program;
42 static void pmap_getport_prepare(struct rpc_task *task, void *calldata)
44 struct portmap_args *map = calldata;
45 struct rpc_message msg = {
46 .rpc_proc = &pmap_procedures[PMAP_GETPORT],
48 .rpc_resp = &map->pm_port,
51 rpc_call_setup(task, &msg, 0);
54 static inline struct portmap_args *pmap_map_alloc(void)
56 return kmalloc(sizeof(struct portmap_args), GFP_NOFS);
59 static inline void pmap_map_free(struct portmap_args *map)
64 static void pmap_map_release(void *data)
69 static const struct rpc_call_ops pmap_getport_ops = {
70 .rpc_call_prepare = pmap_getport_prepare,
71 .rpc_call_done = pmap_getport_done,
72 .rpc_release = pmap_map_release,
75 static inline void pmap_wake_portmap_waiters(struct rpc_xprt *xprt)
77 xprt_clear_binding(xprt);
78 rpc_wake_up(&xprt->binding);
82 * rpc_getport - obtain the port for a given RPC service on a given host
83 * @task: task that is waiting for portmapper request
85 * This one can be called for an ongoing RPC request, and can be used in
86 * an async (rpciod) context.
88 void rpc_getport(struct rpc_task *task)
90 struct rpc_clnt *clnt = task->tk_client;
91 struct rpc_xprt *xprt = task->tk_xprt;
92 struct sockaddr_in *sap = &xprt->addr;
93 struct portmap_args *map;
94 struct rpc_clnt *pmap_clnt;
95 struct rpc_task *child;
97 dprintk("RPC: %4d rpc_getport(%s, %u, %u, %d)\n",
98 task->tk_pid, clnt->cl_server,
99 clnt->cl_prog, clnt->cl_vers, xprt->prot);
101 /* Autobind on cloned rpc clients is discouraged */
102 BUG_ON(clnt->cl_parent != clnt);
104 if (xprt_test_and_set_binding(xprt)) {
105 task->tk_status = -EACCES; /* tell caller to check again */
106 rpc_sleep_on(&xprt->binding, task, NULL, NULL);
110 /* Someone else may have bound if we slept */
111 if (xprt_bound(xprt)) {
116 map = pmap_map_alloc();
118 task->tk_status = -ENOMEM;
121 map->pm_prog = clnt->cl_prog;
122 map->pm_vers = clnt->cl_vers;
123 map->pm_prot = xprt->prot;
127 pmap_clnt = pmap_create(clnt->cl_server, sap, map->pm_prot, 0);
128 if (IS_ERR(pmap_clnt)) {
129 task->tk_status = PTR_ERR(pmap_clnt);
133 child = rpc_run_task(pmap_clnt, RPC_TASK_ASYNC, &pmap_getport_ops, map);
135 task->tk_status = -EIO;
138 rpc_release_task(child);
140 rpc_sleep_on(&xprt->binding, task, NULL, NULL);
142 task->tk_xprt->stat.bind_count++;
148 pmap_wake_portmap_waiters(xprt);
151 #ifdef CONFIG_ROOT_NFS
153 * rpc_getport_external - obtain the port for a given RPC service on a given host
154 * @sin: address of remote peer
155 * @prog: RPC program number to bind
156 * @vers: RPC version number to bind
157 * @prot: transport protocol to use to make this request
159 * This one is called from outside the RPC client in a synchronous task context.
161 int rpc_getport_external(struct sockaddr_in *sin, __u32 prog, __u32 vers, int prot)
163 struct portmap_args map = {
169 struct rpc_message msg = {
170 .rpc_proc = &pmap_procedures[PMAP_GETPORT],
172 .rpc_resp = &map.pm_port,
174 struct rpc_clnt *pmap_clnt;
178 dprintk("RPC: rpc_getport_external(%u.%u.%u.%u, %u, %u, %d)\n",
179 NIPQUAD(sin->sin_addr.s_addr), prog, vers, prot);
181 sprintf(hostname, "%u.%u.%u.%u", NIPQUAD(sin->sin_addr.s_addr));
182 pmap_clnt = pmap_create(hostname, sin, prot, 0);
183 if (IS_ERR(pmap_clnt))
184 return PTR_ERR(pmap_clnt);
186 /* Setup the call info struct */
187 status = rpc_call_sync(pmap_clnt, &msg, 0);
190 if (map.pm_port != 0)
199 * Portmapper child task invokes this callback via tk_exit.
201 static void pmap_getport_done(struct rpc_task *child, void *data)
203 struct portmap_args *map = data;
204 struct rpc_task *task = map->pm_task;
205 struct rpc_xprt *xprt = task->tk_xprt;
206 int status = child->tk_status;
209 /* Portmapper not available */
210 xprt->ops->set_port(xprt, 0);
211 task->tk_status = status;
212 } else if (map->pm_port == 0) {
213 /* Requested RPC service wasn't registered */
214 xprt->ops->set_port(xprt, 0);
215 task->tk_status = -EACCES;
218 xprt->ops->set_port(xprt, map->pm_port);
219 xprt_set_bound(xprt);
223 dprintk("RPC: %4d pmap_getport_done(status %d, port %u)\n",
224 child->tk_pid, child->tk_status, map->pm_port);
226 pmap_wake_portmap_waiters(xprt);
230 * rpc_register - set or unset a port registration with the local portmapper
231 * @prog: RPC program number to bind
232 * @vers: RPC version number to bind
233 * @prot: transport protocol to use to make this request
234 * @port: port value to register
237 * port == 0 means unregister, port != 0 means register.
239 int rpc_register(u32 prog, u32 vers, int prot, unsigned short port, int *okay)
241 struct sockaddr_in sin = {
242 .sin_family = AF_INET,
243 .sin_addr.s_addr = htonl(INADDR_LOOPBACK),
245 struct portmap_args map = {
251 struct rpc_message msg = {
252 .rpc_proc = &pmap_procedures[port ? PMAP_SET : PMAP_UNSET],
256 struct rpc_clnt *pmap_clnt;
259 dprintk("RPC: registering (%u, %u, %d, %u) with portmapper.\n",
260 prog, vers, prot, port);
262 pmap_clnt = pmap_create("localhost", &sin, IPPROTO_UDP, 1);
263 if (IS_ERR(pmap_clnt)) {
264 error = PTR_ERR(pmap_clnt);
265 dprintk("RPC: couldn't create pmap client. Error = %d\n", error);
269 error = rpc_call_sync(pmap_clnt, &msg, 0);
273 "RPC: failed to contact portmap (errno %d).\n",
276 dprintk("RPC: registration status %d/%d\n", error, *okay);
278 /* Client deleted automatically because cl_oneshot == 1 */
282 static struct rpc_clnt *pmap_create(char *hostname, struct sockaddr_in *srvaddr, int proto, int privileged)
284 struct rpc_xprt *xprt;
285 struct rpc_clnt *clnt;
287 xprt = xprt_create_proto(proto, srvaddr, NULL);
289 return (struct rpc_clnt *)xprt;
290 xprt->ops->set_port(xprt, RPC_PMAP_PORT);
291 xprt_set_bound(xprt);
295 clnt = rpc_new_client(xprt, hostname,
296 &pmap_program, RPC_PMAP_VERSION,
299 clnt->cl_softrtry = 1;
300 clnt->cl_oneshot = 1;
306 * XDR encode/decode functions for PMAP
308 static int xdr_encode_mapping(struct rpc_rqst *req, u32 *p, struct portmap_args *map)
310 dprintk("RPC: xdr_encode_mapping(%u, %u, %u, %u)\n",
311 map->pm_prog, map->pm_vers, map->pm_prot, map->pm_port);
312 *p++ = htonl(map->pm_prog);
313 *p++ = htonl(map->pm_vers);
314 *p++ = htonl(map->pm_prot);
315 *p++ = htonl(map->pm_port);
317 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
321 static int xdr_decode_port(struct rpc_rqst *req, u32 *p, unsigned short *portp)
323 *portp = (unsigned short) ntohl(*p++);
327 static int xdr_decode_bool(struct rpc_rqst *req, u32 *p, unsigned int *boolp)
329 *boolp = (unsigned int) ntohl(*p++);
333 static struct rpc_procinfo pmap_procedures[] = {
336 .p_encode = (kxdrproc_t) xdr_encode_mapping,
337 .p_decode = (kxdrproc_t) xdr_decode_bool,
340 .p_statidx = PMAP_SET,
344 .p_proc = PMAP_UNSET,
345 .p_encode = (kxdrproc_t) xdr_encode_mapping,
346 .p_decode = (kxdrproc_t) xdr_decode_bool,
349 .p_statidx = PMAP_UNSET,
353 .p_proc = PMAP_GETPORT,
354 .p_encode = (kxdrproc_t) xdr_encode_mapping,
355 .p_decode = (kxdrproc_t) xdr_decode_port,
358 .p_statidx = PMAP_GETPORT,
363 static struct rpc_version pmap_version2 = {
366 .procs = pmap_procedures
369 static struct rpc_version * pmap_version[] = {
375 static struct rpc_stat pmap_stats;
377 static struct rpc_program pmap_program = {
379 .number = RPC_PMAP_PROGRAM,
380 .nrvers = ARRAY_SIZE(pmap_version),
381 .version = pmap_version,
382 .stats = &pmap_stats,