Pull model-name into release branch
[linux-2.6] / net / sunrpc / pmap_clnt.c
1 /*
2  * linux/net/sunrpc/pmap.c
3  *
4  * Portmapper client.
5  *
6  * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
7  */
8
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>
14 #include <linux/in.h>
15 #include <linux/sunrpc/clnt.h>
16 #include <linux/sunrpc/xprt.h>
17 #include <linux/sunrpc/sched.h>
18
19 #ifdef RPC_DEBUG
20 # define RPCDBG_FACILITY        RPCDBG_PMAP
21 #endif
22
23 #define PMAP_SET                1
24 #define PMAP_UNSET              2
25 #define PMAP_GETPORT            3
26
27 static struct rpc_procinfo      pmap_procedures[];
28 static struct rpc_clnt *        pmap_create(char *, struct sockaddr_in *, int, int);
29 static void                     pmap_getport_done(struct rpc_task *);
30 static struct rpc_program       pmap_program;
31 static DEFINE_SPINLOCK(pmap_lock);
32
33 /*
34  * Obtain the port for a given RPC service on a given host. This one can
35  * be called for an ongoing RPC request.
36  */
37 void
38 rpc_getport(struct rpc_task *task, struct rpc_clnt *clnt)
39 {
40         struct rpc_portmap *map = clnt->cl_pmap;
41         struct sockaddr_in *sap = &clnt->cl_xprt->addr;
42         struct rpc_message msg = {
43                 .rpc_proc       = &pmap_procedures[PMAP_GETPORT],
44                 .rpc_argp       = map,
45                 .rpc_resp       = &clnt->cl_port,
46                 .rpc_cred       = NULL
47         };
48         struct rpc_clnt *pmap_clnt;
49         struct rpc_task *child;
50
51         dprintk("RPC: %4d rpc_getport(%s, %d, %d, %d)\n",
52                         task->tk_pid, clnt->cl_server,
53                         map->pm_prog, map->pm_vers, map->pm_prot);
54
55         /* Autobind on cloned rpc clients is discouraged */
56         BUG_ON(clnt->cl_parent != clnt);
57
58         spin_lock(&pmap_lock);
59         if (map->pm_binding) {
60                 rpc_sleep_on(&map->pm_bindwait, task, NULL, NULL);
61                 spin_unlock(&pmap_lock);
62                 return;
63         }
64         map->pm_binding = 1;
65         spin_unlock(&pmap_lock);
66
67         pmap_clnt = pmap_create(clnt->cl_server, sap, map->pm_prot, 0);
68         if (IS_ERR(pmap_clnt)) {
69                 task->tk_status = PTR_ERR(pmap_clnt);
70                 goto bailout;
71         }
72         task->tk_status = 0;
73
74         /*
75          * Note: rpc_new_child will release client after a failure.
76          */
77         if (!(child = rpc_new_child(pmap_clnt, task)))
78                 goto bailout;
79
80         /* Setup the call info struct */
81         rpc_call_setup(child, &msg, 0);
82
83         /* ... and run the child task */
84         task->tk_xprt->stat.bind_count++;
85         rpc_run_child(task, child, pmap_getport_done);
86         return;
87
88 bailout:
89         spin_lock(&pmap_lock);
90         map->pm_binding = 0;
91         rpc_wake_up(&map->pm_bindwait);
92         spin_unlock(&pmap_lock);
93         rpc_exit(task, -EIO);
94 }
95
96 #ifdef CONFIG_ROOT_NFS
97 int
98 rpc_getport_external(struct sockaddr_in *sin, __u32 prog, __u32 vers, int prot)
99 {
100         struct rpc_portmap map = {
101                 .pm_prog        = prog,
102                 .pm_vers        = vers,
103                 .pm_prot        = prot,
104                 .pm_port        = 0
105         };
106         struct rpc_message msg = {
107                 .rpc_proc       = &pmap_procedures[PMAP_GETPORT],
108                 .rpc_argp       = &map,
109                 .rpc_resp       = &map.pm_port,
110         };
111         struct rpc_clnt *pmap_clnt;
112         char            hostname[32];
113         int             status;
114
115         dprintk("RPC:      rpc_getport_external(%u.%u.%u.%u, %d, %d, %d)\n",
116                         NIPQUAD(sin->sin_addr.s_addr), prog, vers, prot);
117
118         sprintf(hostname, "%u.%u.%u.%u", NIPQUAD(sin->sin_addr.s_addr));
119         pmap_clnt = pmap_create(hostname, sin, prot, 0);
120         if (IS_ERR(pmap_clnt))
121                 return PTR_ERR(pmap_clnt);
122
123         /* Setup the call info struct */
124         status = rpc_call_sync(pmap_clnt, &msg, 0);
125
126         if (status >= 0) {
127                 if (map.pm_port != 0)
128                         return map.pm_port;
129                 status = -EACCES;
130         }
131         return status;
132 }
133 #endif
134
135 static void
136 pmap_getport_done(struct rpc_task *task)
137 {
138         struct rpc_clnt *clnt = task->tk_client;
139         struct rpc_xprt *xprt = task->tk_xprt;
140         struct rpc_portmap *map = clnt->cl_pmap;
141
142         dprintk("RPC: %4d pmap_getport_done(status %d, port %d)\n",
143                         task->tk_pid, task->tk_status, clnt->cl_port);
144
145         xprt->ops->set_port(xprt, 0);
146         if (task->tk_status < 0) {
147                 /* Make the calling task exit with an error */
148                 task->tk_action = rpc_exit_task;
149         } else if (clnt->cl_port == 0) {
150                 /* Program not registered */
151                 rpc_exit(task, -EACCES);
152         } else {
153                 xprt->ops->set_port(xprt, clnt->cl_port);
154                 clnt->cl_port = htons(clnt->cl_port);
155         }
156         spin_lock(&pmap_lock);
157         map->pm_binding = 0;
158         rpc_wake_up(&map->pm_bindwait);
159         spin_unlock(&pmap_lock);
160 }
161
162 /*
163  * Set or unset a port registration with the local portmapper.
164  * port == 0 means unregister, port != 0 means register.
165  */
166 int
167 rpc_register(u32 prog, u32 vers, int prot, unsigned short port, int *okay)
168 {
169         struct sockaddr_in      sin = {
170                 .sin_family     = AF_INET,
171                 .sin_addr.s_addr = htonl(INADDR_LOOPBACK),
172         };
173         struct rpc_portmap      map = {
174                 .pm_prog        = prog,
175                 .pm_vers        = vers,
176                 .pm_prot        = prot,
177                 .pm_port        = port,
178         };
179         struct rpc_message msg = {
180                 .rpc_proc       = &pmap_procedures[port ? PMAP_SET : PMAP_UNSET],
181                 .rpc_argp       = &map,
182                 .rpc_resp       = okay,
183         };
184         struct rpc_clnt         *pmap_clnt;
185         int error = 0;
186
187         dprintk("RPC: registering (%d, %d, %d, %d) with portmapper.\n",
188                         prog, vers, prot, port);
189
190         pmap_clnt = pmap_create("localhost", &sin, IPPROTO_UDP, 1);
191         if (IS_ERR(pmap_clnt)) {
192                 error = PTR_ERR(pmap_clnt);
193                 dprintk("RPC: couldn't create pmap client. Error = %d\n", error);
194                 return error;
195         }
196
197         error = rpc_call_sync(pmap_clnt, &msg, 0);
198
199         if (error < 0) {
200                 printk(KERN_WARNING
201                         "RPC: failed to contact portmap (errno %d).\n",
202                         error);
203         }
204         dprintk("RPC: registration status %d/%d\n", error, *okay);
205
206         /* Client deleted automatically because cl_oneshot == 1 */
207         return error;
208 }
209
210 static struct rpc_clnt *
211 pmap_create(char *hostname, struct sockaddr_in *srvaddr, int proto, int privileged)
212 {
213         struct rpc_xprt *xprt;
214         struct rpc_clnt *clnt;
215
216         /* printk("pmap: create xprt\n"); */
217         xprt = xprt_create_proto(proto, srvaddr, NULL);
218         if (IS_ERR(xprt))
219                 return (struct rpc_clnt *)xprt;
220         xprt->ops->set_port(xprt, RPC_PMAP_PORT);
221         if (!privileged)
222                 xprt->resvport = 0;
223
224         /* printk("pmap: create clnt\n"); */
225         clnt = rpc_new_client(xprt, hostname,
226                                 &pmap_program, RPC_PMAP_VERSION,
227                                 RPC_AUTH_UNIX);
228         if (!IS_ERR(clnt)) {
229                 clnt->cl_softrtry = 1;
230                 clnt->cl_oneshot  = 1;
231         }
232         return clnt;
233 }
234
235 /*
236  * XDR encode/decode functions for PMAP
237  */
238 static int
239 xdr_encode_mapping(struct rpc_rqst *req, u32 *p, struct rpc_portmap *map)
240 {
241         dprintk("RPC: xdr_encode_mapping(%d, %d, %d, %d)\n",
242                 map->pm_prog, map->pm_vers, map->pm_prot, map->pm_port);
243         *p++ = htonl(map->pm_prog);
244         *p++ = htonl(map->pm_vers);
245         *p++ = htonl(map->pm_prot);
246         *p++ = htonl(map->pm_port);
247
248         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
249         return 0;
250 }
251
252 static int
253 xdr_decode_port(struct rpc_rqst *req, u32 *p, unsigned short *portp)
254 {
255         *portp = (unsigned short) ntohl(*p++);
256         return 0;
257 }
258
259 static int
260 xdr_decode_bool(struct rpc_rqst *req, u32 *p, unsigned int *boolp)
261 {
262         *boolp = (unsigned int) ntohl(*p++);
263         return 0;
264 }
265
266 static struct rpc_procinfo      pmap_procedures[] = {
267 [PMAP_SET] = {
268           .p_proc               = PMAP_SET,
269           .p_encode             = (kxdrproc_t) xdr_encode_mapping,      
270           .p_decode             = (kxdrproc_t) xdr_decode_bool,
271           .p_bufsiz             = 4,
272           .p_count              = 1,
273           .p_statidx            = PMAP_SET,
274           .p_name               = "SET",
275         },
276 [PMAP_UNSET] = {
277           .p_proc               = PMAP_UNSET,
278           .p_encode             = (kxdrproc_t) xdr_encode_mapping,      
279           .p_decode             = (kxdrproc_t) xdr_decode_bool,
280           .p_bufsiz             = 4,
281           .p_count              = 1,
282           .p_statidx            = PMAP_UNSET,
283           .p_name               = "UNSET",
284         },
285 [PMAP_GETPORT] = {
286           .p_proc               = PMAP_GETPORT,
287           .p_encode             = (kxdrproc_t) xdr_encode_mapping,
288           .p_decode             = (kxdrproc_t) xdr_decode_port,
289           .p_bufsiz             = 4,
290           .p_count              = 1,
291           .p_statidx            = PMAP_GETPORT,
292           .p_name               = "GETPORT",
293         },
294 };
295
296 static struct rpc_version       pmap_version2 = {
297         .number         = 2,
298         .nrprocs        = 4,
299         .procs          = pmap_procedures
300 };
301
302 static struct rpc_version *     pmap_version[] = {
303         NULL,
304         NULL,
305         &pmap_version2
306 };
307
308 static struct rpc_stat          pmap_stats;
309
310 static struct rpc_program       pmap_program = {
311         .name           = "portmap",
312         .number         = RPC_PMAP_PROGRAM,
313         .nrvers         = ARRAY_SIZE(pmap_version),
314         .version        = pmap_version,
315         .stats          = &pmap_stats,
316 };