1 /*
2 * linux/net/sunrpc/svc.c
3 *
4 * High-level RPC service routines
5 *
6 * Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de>
7 */
8
9 #define __KERNEL_SYSCALLS__
10 #include <linux/linkage.h>
11 #include <linux/sched.h>
12 #include <linux/errno.h>
13 #include <linux/net.h>
14 #include <linux/in.h>
15 #include <linux/unistd.h>
16
17 #include <linux/sunrpc/types.h>
18 #include <linux/sunrpc/xdr.h>
19 #include <linux/sunrpc/stats.h>
20 #include <linux/sunrpc/svcsock.h>
21 #include <linux/sunrpc/clnt.h>
22
23 #define RPCDBG_FACILITY RPCDBG_SVCDSP
24 #define RPC_PARANOIA 1
25
26 /*
27 * Create an RPC service
28 */
29 struct svc_serv *
30 svc_create(struct svc_program *prog, unsigned int bufsize, unsigned int xdrsize)
31 {
32 struct svc_serv *serv;
33
34 xdr_init();
35 #ifdef RPC_DEBUG
36 rpc_register_sysctl();
37 #endif
38
39 if (!(serv = (struct svc_serv *) kmalloc(sizeof(*serv), GFP_KERNEL)))
40 return NULL;
41
42 memset(serv, 0, sizeof(*serv));
43 serv->sv_program = prog;
44 serv->sv_nrthreads = 1;
45 serv->sv_stats = prog->pg_stats;
46 serv->sv_bufsz = bufsize? bufsize : 4096;
47 serv->sv_xdrsize = xdrsize;
48 spin_lock_init(&serv->sv_lock);
49
50 serv->sv_name = prog->pg_name;
51
52 /* Remove any stale portmap registrations */
53 svc_register(serv, 0, 0);
54
55 return serv;
56 }
57
58 /*
59 * Destroy an RPC service
60 */
61 void
62 svc_destroy(struct svc_serv *serv)
63 {
64 struct svc_sock *svsk;
65
66 dprintk("RPC: svc_destroy(%s, %d)\n",
67 serv->sv_program->pg_name,
68 serv->sv_nrthreads);
69
70 if (serv->sv_nrthreads) {
71 if (--(serv->sv_nrthreads) != 0)
72 return;
73 } else
74 printk("svc_destroy: no threads for serv=%p!\n", serv);
75
76 while ((svsk = serv->sv_allsocks) != NULL)
77 svc_delete_socket(svsk);
78
79 /* Unregister service with the portmapper */
80 svc_register(serv, 0, 0);
81 kfree(serv);
82 }
83
84 /*
85 * Allocate an RPC server buffer
86 * Later versions may do nifty things by allocating multiple pages
87 * of memory directly and putting them into the bufp->iov.
88 */
89 int
90 svc_init_buffer(struct svc_buf *bufp, unsigned int size)
91 {
92 if (!(bufp->area = (u32 *) kmalloc(size, GFP_KERNEL)))
93 return 0;
94 bufp->base = bufp->area;
95 bufp->buf = bufp->area;
96 bufp->len = 0;
97 bufp->buflen = size >> 2;
98
99 bufp->iov[0].iov_base = bufp->area;
100 bufp->iov[0].iov_len = size;
101 bufp->nriov = 1;
102
103 return 1;
104 }
105
106 /*
107 * Release an RPC server buffer
108 */
109 void
110 svc_release_buffer(struct svc_buf *bufp)
111 {
112 kfree(bufp->area);
113 bufp->area = 0;
114 }
115
116 /*
117 * Create a server thread
118 */
119 int
120 svc_create_thread(svc_thread_fn func, struct svc_serv *serv)
121 {
122 struct svc_rqst *rqstp;
123 int error = -ENOMEM;
124
125 rqstp = kmalloc(sizeof(*rqstp), GFP_KERNEL);
126 if (!rqstp)
127 goto out;
128
129 memset(rqstp, 0, sizeof(*rqstp));
130 init_waitqueue_head(&rqstp->rq_wait);
131
132 if (!(rqstp->rq_argp = (u32 *) kmalloc(serv->sv_xdrsize, GFP_KERNEL))
133 || !(rqstp->rq_resp = (u32 *) kmalloc(serv->sv_xdrsize, GFP_KERNEL))
134 || !svc_init_buffer(&rqstp->rq_defbuf, serv->sv_bufsz))
135 goto out_thread;
136
137 serv->sv_nrthreads++;
138 rqstp->rq_server = serv;
139 error = kernel_thread((int (*)(void *)) func, rqstp, 0);
140 if (error < 0)
141 goto out_thread;
142 error = 0;
143 out:
144 return error;
145
146 out_thread:
147 svc_exit_thread(rqstp);
148 goto out;
149 }
150
151 /*
152 * Destroy an RPC server thread
153 */
154 void
155 svc_exit_thread(struct svc_rqst *rqstp)
156 {
157 struct svc_serv *serv = rqstp->rq_server;
158
159 svc_release_buffer(&rqstp->rq_defbuf);
160 if (rqstp->rq_resp)
161 kfree(rqstp->rq_resp);
162 if (rqstp->rq_argp)
163 kfree(rqstp->rq_argp);
164 kfree(rqstp);
165
166 /* Release the server */
167 if (serv)
168 svc_destroy(serv);
169 }
170
171 /*
172 * Register an RPC service with the local portmapper.
173 * To unregister a service, call this routine with
174 * proto and port == 0.
175 */
176 int
177 svc_register(struct svc_serv *serv, int proto, unsigned short port)
178 {
179 struct svc_program *progp;
180 unsigned long flags;
181 int i, error = 0, dummy;
182
183 progp = serv->sv_program;
184
185 dprintk("RPC: svc_register(%s, %s, %d)\n",
186 progp->pg_name, proto == IPPROTO_UDP? "udp" : "tcp", port);
187
188 if (!port)
189 current->sigpending = 0;
190
191 for (i = 0; i < progp->pg_nvers; i++) {
192 if (progp->pg_vers[i] == NULL)
193 continue;
194 error = rpc_register(progp->pg_prog, i, proto, port, &dummy);
195 if (error < 0)
196 break;
197 if (port && !dummy) {
198 error = -EACCES;
199 break;
200 }
201 }
202
203 if (!port) {
204 spin_lock_irqsave(¤t->sigmask_lock, flags);
205 recalc_sigpending(current);
206 spin_unlock_irqrestore(¤t->sigmask_lock, flags);
207 }
208
209 return error;
210 }
211
212 /*
213 * Process the RPC request.
214 */
215 int
216 svc_process(struct svc_serv *serv, struct svc_rqst *rqstp)
217 {
218 struct svc_program *progp;
219 struct svc_version *versp = NULL; /* compiler food */
220 struct svc_procedure *procp = NULL;
221 struct svc_buf * argp = &rqstp->rq_argbuf;
222 struct svc_buf * resp = &rqstp->rq_resbuf;
223 kxdrproc_t xdr;
224 u32 *bufp, *statp;
225 u32 dir, prog, vers, proc,
226 auth_stat, rpc_stat;
227
228 rpc_stat = rpc_success;
229 bufp = argp->buf;
230
231 if (argp->len < 5)
232 goto err_short_len;
233
234 dir = ntohl(*bufp++);
235 vers = ntohl(*bufp++);
236
237 /* First words of reply: */
238 svc_putlong(resp, xdr_one); /* REPLY */
239 svc_putlong(resp, xdr_zero); /* ACCEPT */
240
241 if (dir != 0) /* direction != CALL */
242 goto err_bad_dir;
243 if (vers != 2) /* RPC version number */
244 goto err_bad_rpc;
245
246 rqstp->rq_prog = prog = ntohl(*bufp++); /* program number */
247 rqstp->rq_vers = vers = ntohl(*bufp++); /* version number */
248 rqstp->rq_proc = proc = ntohl(*bufp++); /* procedure number */
249
250 argp->buf += 5;
251 argp->len -= 5;
252
253 /* Used by nfsd to only allow the NULL procedure for amd. */
254 if (rqstp->rq_auth && !rqstp->rq_client && proc) {
255 auth_stat = rpc_autherr_badcred;
256 goto err_bad_auth;
257 }
258
259 /*
260 * Decode auth data, and add verifier to reply buffer.
261 * We do this before anything else in order to get a decent
262 * auth verifier.
263 */
264 svc_authenticate(rqstp, &rpc_stat, &auth_stat);
265
266 if (rpc_stat != rpc_success)
267 goto err_garbage;
268
269 if (auth_stat != rpc_auth_ok)
270 goto err_bad_auth;
271
272 progp = serv->sv_program;
273 if (prog != progp->pg_prog)
274 goto err_bad_prog;
275
276 if (vers >= progp->pg_nvers ||
277 !(versp = progp->pg_vers[vers]))
278 goto err_bad_vers;
279
280 procp = versp->vs_proc + proc;
281 if (proc >= versp->vs_nproc || !procp->pc_func)
282 goto err_bad_proc;
283 rqstp->rq_server = serv;
284 rqstp->rq_procinfo = procp;
285
286 /* Syntactic check complete */
287 serv->sv_stats->rpccnt++;
288
289 /* Build the reply header. */
290 statp = resp->buf;
291 svc_putlong(resp, rpc_success); /* RPC_SUCCESS */
292
293 /* Bump per-procedure stats counter */
294 procp->pc_count++;
295
296 /* Initialize storage for argp and resp */
297 memset(rqstp->rq_argp, 0, procp->pc_argsize);
298 memset(rqstp->rq_resp, 0, procp->pc_ressize);
299
300 /* Call the function that processes the request. */
301 if (!versp->vs_dispatch) {
302 /* Decode arguments */
303 xdr = procp->pc_decode;
304 if (xdr && !xdr(rqstp, rqstp->rq_argbuf.buf, rqstp->rq_argp))
305 goto err_garbage;
306
307 *statp = procp->pc_func(rqstp, rqstp->rq_argp, rqstp->rq_resp);
308
309 /* Encode reply */
310 if (*statp == rpc_success && (xdr = procp->pc_encode)
311 && !xdr(rqstp, rqstp->rq_resbuf.buf, rqstp->rq_resp)) {
312 dprintk("svc: failed to encode reply\n");
313 /* serv->sv_stats->rpcsystemerr++; */
314 *statp = rpc_system_err;
315 }
316 } else {
317 dprintk("svc: calling dispatcher\n");
318 if (!versp->vs_dispatch(rqstp, statp))
319 goto dropit;
320 }
321
322 /* Check RPC status result */
323 if (*statp != rpc_success)
324 resp->len = statp + 1 - resp->base;
325
326 /* Release reply info */
327 if (procp->pc_release)
328 procp->pc_release(rqstp, NULL, rqstp->rq_resp);
329
330 if (procp->pc_encode == NULL)
331 goto dropit;
332 sendit:
333 return svc_send(rqstp);
334
335 dropit:
336 dprintk("svc: svc_process dropit\n");
337 svc_drop(rqstp);
338 return 0;
339
340 err_short_len:
341 #ifdef RPC_PARANOIA
342 printk("svc: short len %d, dropping request\n", argp->len);
343 #endif
344 goto dropit; /* drop request */
345
346 err_bad_dir:
347 #ifdef RPC_PARANOIA
348 printk("svc: bad direction %d, dropping request\n", dir);
349 #endif
350 serv->sv_stats->rpcbadfmt++;
351 goto dropit; /* drop request */
352
353 err_bad_rpc:
354 serv->sv_stats->rpcbadfmt++;
355 resp->buf[-1] = xdr_one; /* REJECT */
356 svc_putlong(resp, xdr_zero); /* RPC_MISMATCH */
357 svc_putlong(resp, xdr_two); /* Only RPCv2 supported */
358 svc_putlong(resp, xdr_two);
359 goto sendit;
360
361 err_bad_auth:
362 dprintk("svc: authentication failed (%d)\n", ntohl(auth_stat));
363 serv->sv_stats->rpcbadauth++;
364 resp->buf[-1] = xdr_one; /* REJECT */
365 svc_putlong(resp, xdr_one); /* AUTH_ERROR */
366 svc_putlong(resp, auth_stat); /* status */
367 goto sendit;
368
369 err_bad_prog:
370 #ifdef RPC_PARANOIA
371 printk("svc: unknown program %d (me %d)\n", prog, progp->pg_prog);
372 #endif
373 serv->sv_stats->rpcbadfmt++;
374 svc_putlong(resp, rpc_prog_unavail);
375 goto sendit;
376
377 err_bad_vers:
378 #ifdef RPC_PARANOIA
379 printk("svc: unknown version (%d)\n", vers);
380 #endif
381 serv->sv_stats->rpcbadfmt++;
382 svc_putlong(resp, rpc_prog_mismatch);
383 svc_putlong(resp, htonl(progp->pg_lovers));
384 svc_putlong(resp, htonl(progp->pg_hivers));
385 goto sendit;
386
387 err_bad_proc:
388 #ifdef RPC_PARANOIA
389 printk("svc: unknown procedure (%d)\n", proc);
390 #endif
391 serv->sv_stats->rpcbadfmt++;
392 svc_putlong(resp, rpc_proc_unavail);
393 goto sendit;
394
395 err_garbage:
396 #ifdef RPC_PARANOIA
397 printk("svc: failed to decode args\n");
398 #endif
399 serv->sv_stats->rpcbadfmt++;
400 svc_putlong(resp, rpc_garbage_args);
401 goto sendit;
402 }
403
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.