2 * linux/net/sunrpc/pmap.c
6 * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
9 #include <linux/types.h>
10 #include <linux/socket.h>
11 #include <linux/kernel.h>
12 #include <linux/errno.h>
13 #include <linux/uio.h>
15 #include <linux/sunrpc/clnt.h>
16 #include <linux/sunrpc/xprt.h>
17 #include <linux/sunrpc/sched.h>
20 # define RPCDBG_FACILITY RPCDBG_PMAP
25 #define PMAP_GETPORT 3
31 unsigned short pm_port;
32 struct rpc_task * pm_task;
35 static struct rpc_procinfo pmap_procedures[];
36 static struct rpc_clnt * pmap_create(char *, struct sockaddr_in *, int, int);
37 static void pmap_getport_done(struct rpc_task *, void *);
38 static struct rpc_program pmap_program;
40 static void pmap_getport_prepare(struct rpc_task *task, void *calldata)
42 struct portmap_args *map = calldata;
43 struct rpc_message msg = {
44 .rpc_proc = &pmap_procedures[PMAP_GETPORT],
46 .rpc_resp = &map->pm_port,
49 rpc_call_setup(task, &msg, 0);
52 static inline struct portmap_args *pmap_map_alloc(void)
54 return kmalloc(sizeof(struct portmap_args), GFP_NOFS);
57 static inline void pmap_map_free(struct portmap_args *map)
62 static void pmap_map_release(void *data)
67 static const struct rpc_call_ops pmap_getport_ops = {
68 .rpc_call_prepare = pmap_getport_prepare,
69 .rpc_call_done = pmap_getport_done,
70 .rpc_release = pmap_map_release,
73 static inline void pmap_wake_portmap_waiters(struct rpc_xprt *xprt)
75 xprt_clear_binding(xprt);
76 rpc_wake_up(&xprt->binding);
80 * Obtain the port for a given RPC service on a given host. This one can
81 * be called for an ongoing RPC request.
84 rpc_getport(struct rpc_task *task, struct rpc_clnt *clnt)
86 struct rpc_xprt *xprt = task->tk_xprt;
87 struct sockaddr_in *sap = &xprt->addr;
88 struct portmap_args *map;
89 struct rpc_clnt *pmap_clnt;
90 struct rpc_task *child;
92 dprintk("RPC: %4d rpc_getport(%s, %u, %u, %d)\n",
93 task->tk_pid, clnt->cl_server,
94 clnt->cl_prog, clnt->cl_vers, xprt->prot);
96 /* Autobind on cloned rpc clients is discouraged */
97 BUG_ON(clnt->cl_parent != clnt);
99 if (xprt_test_and_set_binding(xprt)) {
100 task->tk_status = -EACCES; /* tell caller to check again */
101 rpc_sleep_on(&xprt->binding, task, NULL, NULL);
105 /* Someone else may have bound if we slept */
106 if (xprt_bound(xprt)) {
111 map = pmap_map_alloc();
113 task->tk_status = -ENOMEM;
116 map->pm_prog = clnt->cl_prog;
117 map->pm_vers = clnt->cl_vers;
118 map->pm_prot = xprt->prot;
122 pmap_clnt = pmap_create(clnt->cl_server, sap, map->pm_prot, 0);
123 if (IS_ERR(pmap_clnt)) {
124 task->tk_status = PTR_ERR(pmap_clnt);
128 child = rpc_run_task(pmap_clnt, RPC_TASK_ASYNC, &pmap_getport_ops, map);
130 task->tk_status = -EIO;
133 rpc_release_task(child);
135 rpc_sleep_on(&xprt->binding, task, NULL, NULL);
137 task->tk_xprt->stat.bind_count++;
143 pmap_wake_portmap_waiters(xprt);
146 #ifdef CONFIG_ROOT_NFS
148 rpc_getport_external(struct sockaddr_in *sin, __u32 prog, __u32 vers, int prot)
150 struct portmap_args map = {
156 struct rpc_message msg = {
157 .rpc_proc = &pmap_procedures[PMAP_GETPORT],
159 .rpc_resp = &map.pm_port,
161 struct rpc_clnt *pmap_clnt;
165 dprintk("RPC: rpc_getport_external(%u.%u.%u.%u, %d, %d, %d)\n",
166 NIPQUAD(sin->sin_addr.s_addr), prog, vers, prot);
168 sprintf(hostname, "%u.%u.%u.%u", NIPQUAD(sin->sin_addr.s_addr));
169 pmap_clnt = pmap_create(hostname, sin, prot, 0);
170 if (IS_ERR(pmap_clnt))
171 return PTR_ERR(pmap_clnt);
173 /* Setup the call info struct */
174 status = rpc_call_sync(pmap_clnt, &msg, 0);
177 if (map.pm_port != 0)
186 pmap_getport_done(struct rpc_task *child, void *data)
188 struct portmap_args *map = data;
189 struct rpc_task *task = map->pm_task;
190 struct rpc_xprt *xprt = task->tk_xprt;
191 int status = child->tk_status;
194 /* Portmapper not available */
195 xprt->ops->set_port(xprt, 0);
196 task->tk_status = status;
197 } else if (map->pm_port == 0) {
198 /* Requested RPC service wasn't registered */
199 xprt->ops->set_port(xprt, 0);
200 task->tk_status = -EACCES;
203 xprt->ops->set_port(xprt, map->pm_port);
204 xprt_set_bound(xprt);
208 dprintk("RPC: %4d pmap_getport_done(status %d, port %u)\n",
209 child->tk_pid, child->tk_status, map->pm_port);
211 pmap_wake_portmap_waiters(xprt);
215 * Set or unset a port registration with the local portmapper.
216 * port == 0 means unregister, port != 0 means register.
219 rpc_register(u32 prog, u32 vers, int prot, unsigned short port, int *okay)
221 struct sockaddr_in sin = {
222 .sin_family = AF_INET,
223 .sin_addr.s_addr = htonl(INADDR_LOOPBACK),
225 struct portmap_args map = {
231 struct rpc_message msg = {
232 .rpc_proc = &pmap_procedures[port ? PMAP_SET : PMAP_UNSET],
236 struct rpc_clnt *pmap_clnt;
239 dprintk("RPC: registering (%d, %d, %d, %d) with portmapper.\n",
240 prog, vers, prot, port);
242 pmap_clnt = pmap_create("localhost", &sin, IPPROTO_UDP, 1);
243 if (IS_ERR(pmap_clnt)) {
244 error = PTR_ERR(pmap_clnt);
245 dprintk("RPC: couldn't create pmap client. Error = %d\n", error);
249 error = rpc_call_sync(pmap_clnt, &msg, 0);
253 "RPC: failed to contact portmap (errno %d).\n",
256 dprintk("RPC: registration status %d/%d\n", error, *okay);
258 /* Client deleted automatically because cl_oneshot == 1 */
262 static struct rpc_clnt *
263 pmap_create(char *hostname, struct sockaddr_in *srvaddr, int proto, int privileged)
265 struct rpc_xprt *xprt;
266 struct rpc_clnt *clnt;
268 /* printk("pmap: create xprt\n"); */
269 xprt = xprt_create_proto(proto, srvaddr, NULL);
271 return (struct rpc_clnt *)xprt;
272 xprt->ops->set_port(xprt, RPC_PMAP_PORT);
273 xprt_set_bound(xprt);
277 /* printk("pmap: create clnt\n"); */
278 clnt = rpc_new_client(xprt, hostname,
279 &pmap_program, RPC_PMAP_VERSION,
282 clnt->cl_softrtry = 1;
283 clnt->cl_oneshot = 1;
289 * XDR encode/decode functions for PMAP
292 xdr_encode_mapping(struct rpc_rqst *req, u32 *p, struct portmap_args *map)
294 dprintk("RPC: xdr_encode_mapping(%d, %d, %d, %d)\n",
295 map->pm_prog, map->pm_vers, map->pm_prot, map->pm_port);
296 *p++ = htonl(map->pm_prog);
297 *p++ = htonl(map->pm_vers);
298 *p++ = htonl(map->pm_prot);
299 *p++ = htonl(map->pm_port);
301 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
306 xdr_decode_port(struct rpc_rqst *req, u32 *p, unsigned short *portp)
308 *portp = (unsigned short) ntohl(*p++);
313 xdr_decode_bool(struct rpc_rqst *req, u32 *p, unsigned int *boolp)
315 *boolp = (unsigned int) ntohl(*p++);
319 static struct rpc_procinfo pmap_procedures[] = {
322 .p_encode = (kxdrproc_t) xdr_encode_mapping,
323 .p_decode = (kxdrproc_t) xdr_decode_bool,
326 .p_statidx = PMAP_SET,
330 .p_proc = PMAP_UNSET,
331 .p_encode = (kxdrproc_t) xdr_encode_mapping,
332 .p_decode = (kxdrproc_t) xdr_decode_bool,
335 .p_statidx = PMAP_UNSET,
339 .p_proc = PMAP_GETPORT,
340 .p_encode = (kxdrproc_t) xdr_encode_mapping,
341 .p_decode = (kxdrproc_t) xdr_decode_port,
344 .p_statidx = PMAP_GETPORT,
349 static struct rpc_version pmap_version2 = {
352 .procs = pmap_procedures
355 static struct rpc_version * pmap_version[] = {
361 static struct rpc_stat pmap_stats;
363 static struct rpc_program pmap_program = {
365 .number = RPC_PMAP_PROGRAM,
366 .nrvers = ARRAY_SIZE(pmap_version),
367 .version = pmap_version,
368 .stats = &pmap_stats,