blob: 753a9e315518312f7d2a35df8b0364ea29f6b507 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/fs/nfs/callback.c
3 *
4 * Copyright (C) 2004 Trond Myklebust
5 *
6 * NFSv4 callback handling
7 */
8
Linus Torvalds1da177e2005-04-16 15:20:36 -07009#include <linux/completion.h>
10#include <linux/ip.h>
11#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070012#include <linux/sunrpc/svc.h>
13#include <linux/sunrpc/svcsock.h>
14#include <linux/nfs_fs.h>
Ingo Molnar353ab6e2006-03-26 01:37:12 -080015#include <linux/mutex.h>
Rafael J. Wysocki83144182007-07-17 04:03:35 -070016#include <linux/freezer.h>
Jeff Laytona277e332008-02-20 08:55:30 -050017#include <linux/kthread.h>
Olga Kornievskaia945b34a2008-12-23 16:18:34 -050018#include <linux/sunrpc/svcauth_gss.h>
Ricardo Labiagaa43cde92009-04-01 09:23:08 -040019#include <linux/sunrpc/bc_xprt.h>
Arnaldo Carvalho de Melo14c85022005-12-27 02:43:12 -020020
21#include <net/inet_sock.h>
22
Trond Myklebust4ce79712005-06-22 17:16:21 +000023#include "nfs4_fs.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#include "callback.h"
David Howells24c8dbb2006-08-22 20:06:10 -040025#include "internal.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070026
27#define NFSDBG_FACILITY NFSDBG_CALLBACK
28
29struct nfs_callback_data {
30 unsigned int users;
Ricardo Labiagaa43cde92009-04-01 09:23:08 -040031 struct svc_serv *serv;
Jeff Layton5afc5972008-06-11 10:03:11 -040032 struct svc_rqst *rqst;
Jeff Laytona277e332008-02-20 08:55:30 -050033 struct task_struct *task;
Linus Torvalds1da177e2005-04-16 15:20:36 -070034};
35
Andy Adamsone82dc222009-04-01 09:23:14 -040036static struct nfs_callback_data nfs_callback_info[NFS4_MAX_MINOR_VERSION + 1];
Ingo Molnar353ab6e2006-03-26 01:37:12 -080037static DEFINE_MUTEX(nfs_callback_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070038static struct svc_program nfs4_callback_program;
39
Trond Myklebusta72b4422006-01-03 09:55:41 +010040unsigned int nfs_callback_set_tcpport;
Linus Torvalds1da177e2005-04-16 15:20:36 -070041unsigned short nfs_callback_tcpport;
Chuck Leverf738f512009-03-18 20:48:06 -040042unsigned short nfs_callback_tcpport6;
Trond Myklebustc140aa92009-08-09 15:06:19 -040043#define NFS_CALLBACK_MAXPORTNR (65535U)
David Howells7d4e2742006-08-22 20:06:07 -040044
Rusty Russell9bbb9e52010-08-11 23:04:12 -060045static int param_set_portnr(const char *val, const struct kernel_param *kp)
David Howells7d4e2742006-08-22 20:06:07 -040046{
Trond Myklebustc140aa92009-08-09 15:06:19 -040047 unsigned long num;
48 int ret;
49
50 if (!val)
David Howells7d4e2742006-08-22 20:06:07 -040051 return -EINVAL;
Trond Myklebustc140aa92009-08-09 15:06:19 -040052 ret = strict_strtoul(val, 0, &num);
53 if (ret == -EINVAL || num > NFS_CALLBACK_MAXPORTNR)
54 return -EINVAL;
55 *((unsigned int *)kp->arg) = num;
David Howells7d4e2742006-08-22 20:06:07 -040056 return 0;
57}
Rusty Russell9bbb9e52010-08-11 23:04:12 -060058static struct kernel_param_ops param_ops_portnr = {
59 .set = param_set_portnr,
60 .get = param_get_uint,
61};
Trond Myklebustc140aa92009-08-09 15:06:19 -040062#define param_check_portnr(name, p) __param_check(name, p, unsigned int);
63
64module_param_named(callback_tcpport, nfs_callback_set_tcpport, portnr, 0644);
Linus Torvalds1da177e2005-04-16 15:20:36 -070065
66/*
Andy Adamsone82dc222009-04-01 09:23:14 -040067 * This is the NFSv4 callback kernel thread.
Linus Torvalds1da177e2005-04-16 15:20:36 -070068 */
Jeff Laytona277e332008-02-20 08:55:30 -050069static int
Benny Halevy71468512009-04-01 09:22:56 -040070nfs4_callback_svc(void *vrqstp)
Linus Torvalds1da177e2005-04-16 15:20:36 -070071{
Jeff Layton06e02d62008-04-08 15:40:07 -040072 int err, preverr = 0;
Jeff Laytona277e332008-02-20 08:55:30 -050073 struct svc_rqst *rqstp = vrqstp;
Linus Torvalds1da177e2005-04-16 15:20:36 -070074
Rafael J. Wysocki83144182007-07-17 04:03:35 -070075 set_freezable();
Linus Torvalds1da177e2005-04-16 15:20:36 -070076
Jeff Laytona277e332008-02-20 08:55:30 -050077 while (!kthread_should_stop()) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070078 /*
79 * Listen for a request on the socket
80 */
NeilBrown6fb2b472006-10-02 02:17:50 -070081 err = svc_recv(rqstp, MAX_SCHEDULE_TIMEOUT);
Jeff Layton06e02d62008-04-08 15:40:07 -040082 if (err == -EAGAIN || err == -EINTR) {
83 preverr = err;
Linus Torvalds1da177e2005-04-16 15:20:36 -070084 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -070085 }
Jeff Layton06e02d62008-04-08 15:40:07 -040086 if (err < 0) {
87 if (err != preverr) {
88 printk(KERN_WARNING "%s: unexpected error "
89 "from svc_recv (%d)\n", __func__, err);
90 preverr = err;
91 }
92 schedule_timeout_uninterruptible(HZ);
93 continue;
94 }
95 preverr = err;
NeilBrown6fb2b472006-10-02 02:17:50 -070096 svc_process(rqstp);
Linus Torvalds1da177e2005-04-16 15:20:36 -070097 }
Jeff Laytona277e332008-02-20 08:55:30 -050098 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070099}
100
101/*
Benny Halevy71468512009-04-01 09:22:56 -0400102 * Prepare to bring up the NFSv4 callback service
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103 */
Benny Halevy71468512009-04-01 09:22:56 -0400104struct svc_rqst *
105nfs4_callback_up(struct svc_serv *serv)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106{
Benny Halevy71468512009-04-01 09:22:56 -0400107 int ret;
Chuck Lever482fb942007-02-12 00:53:29 -0800108
Pavel Emelyanovfc5d00b2010-09-29 16:03:50 +0400109 ret = svc_create_xprt(serv, "tcp", &init_net, PF_INET,
Chuck Lever9652ada2009-03-18 20:46:21 -0400110 nfs_callback_set_tcpport, SVC_SOCK_ANONYMOUS);
Chuck Lever482fb942007-02-12 00:53:29 -0800111 if (ret <= 0)
Jeff Layton8e600292008-02-11 10:00:20 -0500112 goto out_err;
Chuck Lever482fb942007-02-12 00:53:29 -0800113 nfs_callback_tcpport = ret;
Chuck Lever18de9732008-10-16 17:41:11 -0400114 dprintk("NFS: Callback listener port = %u (af %u)\n",
Chuck Lever26298ca2009-03-18 20:46:36 -0400115 nfs_callback_tcpport, PF_INET);
Chuck Lever482fb942007-02-12 00:53:29 -0800116
Pavel Emelyanovfc5d00b2010-09-29 16:03:50 +0400117 ret = svc_create_xprt(serv, "tcp", &init_net, PF_INET6,
Chuck Leverf738f512009-03-18 20:48:06 -0400118 nfs_callback_set_tcpport, SVC_SOCK_ANONYMOUS);
119 if (ret > 0) {
120 nfs_callback_tcpport6 = ret;
121 dprintk("NFS: Callback listener port = %u (af %u)\n",
122 nfs_callback_tcpport6, PF_INET6);
Chuck Lever18fc3162009-06-17 18:02:10 -0700123 } else if (ret == -EAFNOSUPPORT)
124 ret = 0;
125 else
Chuck Leverf738f512009-03-18 20:48:06 -0400126 goto out_err;
Chuck Leverf738f512009-03-18 20:48:06 -0400127
Benny Halevy71468512009-04-01 09:22:56 -0400128 return svc_prepare_thread(serv, &serv->sv_pools[0]);
129
130out_err:
131 if (ret == 0)
132 ret = -ENOMEM;
133 return ERR_PTR(ret);
134}
135
Ricardo Labiagaa43cde92009-04-01 09:23:08 -0400136#if defined(CONFIG_NFS_V4_1)
137/*
Andy Adamson2c2618c2011-01-06 02:04:31 +0000138 * * CB_SEQUENCE operations will fail until the callback sessionid is set.
139 * */
140int nfs4_set_callback_sessionid(struct nfs_client *clp)
141{
142 struct svc_serv *serv = clp->cl_rpcclient->cl_xprt->bc_serv;
143 struct nfs4_sessionid *bc_sid;
144
145 if (!serv->bc_xprt)
146 return -EINVAL;
147
148 /* on success freed in xprt_free */
149 bc_sid = kmalloc(sizeof(struct nfs4_sessionid), GFP_KERNEL);
150 if (!bc_sid)
151 return -ENOMEM;
152 memcpy(bc_sid->data, &clp->cl_session->sess_id.data,
153 NFS4_MAX_SESSIONID_LEN);
154 spin_lock_bh(&serv->sv_cb_lock);
155 serv->bc_xprt->xpt_bc_sid = bc_sid;
156 spin_unlock_bh(&serv->sv_cb_lock);
157 dprintk("%s set xpt_bc_sid=%u:%u:%u:%u for bc_xprt %p\n", __func__,
158 ((u32 *)bc_sid->data)[0], ((u32 *)bc_sid->data)[1],
159 ((u32 *)bc_sid->data)[2], ((u32 *)bc_sid->data)[3],
160 serv->bc_xprt);
161 return 0;
162}
163
164/*
Ricardo Labiagaa43cde92009-04-01 09:23:08 -0400165 * The callback service for NFSv4.1 callbacks
166 */
167static int
168nfs41_callback_svc(void *vrqstp)
169{
170 struct svc_rqst *rqstp = vrqstp;
171 struct svc_serv *serv = rqstp->rq_server;
172 struct rpc_rqst *req;
173 int error;
174 DEFINE_WAIT(wq);
175
176 set_freezable();
177
Ricardo Labiagaa43cde92009-04-01 09:23:08 -0400178 while (!kthread_should_stop()) {
179 prepare_to_wait(&serv->sv_cb_waitq, &wq, TASK_INTERRUPTIBLE);
180 spin_lock_bh(&serv->sv_cb_lock);
181 if (!list_empty(&serv->sv_cb_list)) {
182 req = list_first_entry(&serv->sv_cb_list,
183 struct rpc_rqst, rq_bc_list);
184 list_del(&req->rq_bc_list);
185 spin_unlock_bh(&serv->sv_cb_lock);
186 dprintk("Invoking bc_svc_process()\n");
187 error = bc_svc_process(serv, req, rqstp);
188 dprintk("bc_svc_process() returned w/ error code= %d\n",
189 error);
190 } else {
191 spin_unlock_bh(&serv->sv_cb_lock);
192 schedule();
193 }
194 finish_wait(&serv->sv_cb_waitq, &wq);
195 }
Ricardo Labiagaa43cde92009-04-01 09:23:08 -0400196 return 0;
197}
198
199/*
200 * Bring up the NFSv4.1 callback service
201 */
202struct svc_rqst *
203nfs41_callback_up(struct svc_serv *serv, struct rpc_xprt *xprt)
204{
Andy Adamson01c9a0b2011-01-06 02:04:28 +0000205 struct svc_rqst *rqstp;
206 int ret;
Benny Halevy8f975242009-04-01 09:23:11 -0400207
Andy Adamson01c9a0b2011-01-06 02:04:28 +0000208 /*
209 * Create an svc_sock for the back channel service that shares the
210 * fore channel connection.
211 * Returns the input port (0) and sets the svc_serv bc_xprt on success
212 */
213 ret = svc_create_xprt(serv, "tcp-bc", &init_net, PF_INET, 0,
214 SVC_SOCK_ANONYMOUS);
215 if (ret < 0) {
216 rqstp = ERR_PTR(ret);
Benny Halevy8f975242009-04-01 09:23:11 -0400217 goto out;
Andy Adamson01c9a0b2011-01-06 02:04:28 +0000218 }
Benny Halevy8f975242009-04-01 09:23:11 -0400219
Ricardo Labiagaa43cde92009-04-01 09:23:08 -0400220 /*
221 * Save the svc_serv in the transport so that it can
222 * be referenced when the session backchannel is initialized
223 */
224 xprt->bc_serv = serv;
225
226 INIT_LIST_HEAD(&serv->sv_cb_list);
227 spin_lock_init(&serv->sv_cb_lock);
228 init_waitqueue_head(&serv->sv_cb_waitq);
Benny Halevy8f975242009-04-01 09:23:11 -0400229 rqstp = svc_prepare_thread(serv, &serv->sv_pools[0]);
Andy Adamson01c9a0b2011-01-06 02:04:28 +0000230 if (IS_ERR(rqstp)) {
231 svc_xprt_put(serv->bc_xprt);
232 serv->bc_xprt = NULL;
233 }
Benny Halevy8f975242009-04-01 09:23:11 -0400234out:
Andy Adamson01c9a0b2011-01-06 02:04:28 +0000235 dprintk("--> %s return %ld\n", __func__,
236 IS_ERR(rqstp) ? PTR_ERR(rqstp) : 0);
Benny Halevy8f975242009-04-01 09:23:11 -0400237 return rqstp;
Ricardo Labiagaa43cde92009-04-01 09:23:08 -0400238}
239
240static inline int nfs_minorversion_callback_svc_setup(u32 minorversion,
241 struct svc_serv *serv, struct rpc_xprt *xprt,
242 struct svc_rqst **rqstpp, int (**callback_svc)(void *vrqstp))
243{
244 if (minorversion) {
245 *rqstpp = nfs41_callback_up(serv, xprt);
246 *callback_svc = nfs41_callback_svc;
247 }
248 return minorversion;
249}
250
251static inline void nfs_callback_bc_serv(u32 minorversion, struct rpc_xprt *xprt,
252 struct nfs_callback_data *cb_info)
253{
254 if (minorversion)
255 xprt->bc_serv = cb_info->serv;
256}
257#else
258static inline int nfs_minorversion_callback_svc_setup(u32 minorversion,
259 struct svc_serv *serv, struct rpc_xprt *xprt,
260 struct svc_rqst **rqstpp, int (**callback_svc)(void *vrqstp))
261{
262 return 0;
263}
264
265static inline void nfs_callback_bc_serv(u32 minorversion, struct rpc_xprt *xprt,
266 struct nfs_callback_data *cb_info)
267{
268}
Andy Adamson2c2618c2011-01-06 02:04:31 +0000269int nfs4_set_callback_sessionid(struct nfs_client *clp)
270{
271 return 0;
272}
Ricardo Labiagaa43cde92009-04-01 09:23:08 -0400273#endif /* CONFIG_NFS_V4_1 */
274
Benny Halevy71468512009-04-01 09:22:56 -0400275/*
276 * Bring up the callback thread if it is not already up.
277 */
278int nfs_callback_up(u32 minorversion, struct rpc_xprt *xprt)
279{
280 struct svc_serv *serv = NULL;
281 struct svc_rqst *rqstp;
282 int (*callback_svc)(void *vrqstp);
Andy Adamsone82dc222009-04-01 09:23:14 -0400283 struct nfs_callback_data *cb_info = &nfs_callback_info[minorversion];
Benny Halevy71468512009-04-01 09:22:56 -0400284 char svc_name[12];
285 int ret = 0;
Ricardo Labiagaa43cde92009-04-01 09:23:08 -0400286 int minorversion_setup;
Benny Halevy71468512009-04-01 09:22:56 -0400287
288 mutex_lock(&nfs_callback_mutex);
Andy Adamsone82dc222009-04-01 09:23:14 -0400289 if (cb_info->users++ || cb_info->task != NULL) {
290 nfs_callback_bc_serv(minorversion, xprt, cb_info);
Benny Halevy71468512009-04-01 09:22:56 -0400291 goto out;
Ricardo Labiagaa43cde92009-04-01 09:23:08 -0400292 }
Benny Halevy71468512009-04-01 09:22:56 -0400293 serv = svc_create(&nfs4_callback_program, NFS4_CALLBACK_BUFSIZE, NULL);
294 if (!serv) {
295 ret = -ENOMEM;
296 goto out_err;
297 }
298
Ricardo Labiagaa43cde92009-04-01 09:23:08 -0400299 minorversion_setup = nfs_minorversion_callback_svc_setup(minorversion,
300 serv, xprt, &rqstp, &callback_svc);
301 if (!minorversion_setup) {
302 /* v4.0 callback setup */
Benny Halevy71468512009-04-01 09:22:56 -0400303 rqstp = nfs4_callback_up(serv);
304 callback_svc = nfs4_callback_svc;
Benny Halevy71468512009-04-01 09:22:56 -0400305 }
306
307 if (IS_ERR(rqstp)) {
308 ret = PTR_ERR(rqstp);
Jeff Layton8e600292008-02-11 10:00:20 -0500309 goto out_err;
Jeff Laytona277e332008-02-20 08:55:30 -0500310 }
311
312 svc_sock_update_bufs(serv);
Jeff Laytona277e332008-02-20 08:55:30 -0500313
Benny Halevy71468512009-04-01 09:22:56 -0400314 sprintf(svc_name, "nfsv4.%u-svc", minorversion);
Andy Adamsone82dc222009-04-01 09:23:14 -0400315 cb_info->serv = serv;
316 cb_info->rqst = rqstp;
317 cb_info->task = kthread_run(callback_svc, cb_info->rqst, svc_name);
318 if (IS_ERR(cb_info->task)) {
319 ret = PTR_ERR(cb_info->task);
320 svc_exit_thread(cb_info->rqst);
321 cb_info->rqst = NULL;
322 cb_info->task = NULL;
Jeff Laytona277e332008-02-20 08:55:30 -0500323 goto out_err;
324 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325out:
Jeff Layton8e600292008-02-11 10:00:20 -0500326 /*
327 * svc_create creates the svc_serv with sv_nrthreads == 1, and then
Jeff Laytona277e332008-02-20 08:55:30 -0500328 * svc_prepare_thread increments that. So we need to call svc_destroy
Jeff Layton8e600292008-02-11 10:00:20 -0500329 * on both success and failure so that the refcount is 1 when the
330 * thread exits.
331 */
332 if (serv)
333 svc_destroy(serv);
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800334 mutex_unlock(&nfs_callback_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335 return ret;
Jeff Layton8e600292008-02-11 10:00:20 -0500336out_err:
Chuck Lever18de9732008-10-16 17:41:11 -0400337 dprintk("NFS: Couldn't create callback socket or server thread; "
338 "err = %d\n", ret);
Andy Adamsone82dc222009-04-01 09:23:14 -0400339 cb_info->users--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 goto out;
341}
342
343/*
Jeff Layton5afc5972008-06-11 10:03:11 -0400344 * Kill the callback thread if it's no longer being used.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345 */
Andy Adamsone82dc222009-04-01 09:23:14 -0400346void nfs_callback_down(int minorversion)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347{
Andy Adamsone82dc222009-04-01 09:23:14 -0400348 struct nfs_callback_data *cb_info = &nfs_callback_info[minorversion];
349
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800350 mutex_lock(&nfs_callback_mutex);
Andy Adamsone82dc222009-04-01 09:23:14 -0400351 cb_info->users--;
352 if (cb_info->users == 0 && cb_info->task != NULL) {
353 kthread_stop(cb_info->task);
354 svc_exit_thread(cb_info->rqst);
355 cb_info->serv = NULL;
356 cb_info->rqst = NULL;
357 cb_info->task = NULL;
Jeff Layton5afc5972008-06-11 10:03:11 -0400358 }
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800359 mutex_unlock(&nfs_callback_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360}
361
Olga Kornievskaia945b34a2008-12-23 16:18:34 -0500362static int check_gss_callback_principal(struct nfs_client *clp,
363 struct svc_rqst *rqstp)
364{
365 struct rpc_clnt *r = clp->cl_rpcclient;
366 char *p = svc_gss_principal(rqstp);
367
Andy Adamsonece0de62011-01-06 02:04:33 +0000368 /* No RPC_AUTH_GSS on NFSv4.1 back channel yet */
369 if (clp->cl_minorversion != 0)
370 return SVC_DROP;
Olga Kornievskaia945b34a2008-12-23 16:18:34 -0500371 /*
372 * It might just be a normal user principal, in which case
373 * userspace won't bother to tell us the name at all.
374 */
375 if (p == NULL)
376 return SVC_DENIED;
377
378 /* Expect a GSS_C_NT_HOSTBASED_NAME like "nfs@serverhostname" */
379
380 if (memcmp(p, "nfs@", 4) != 0)
381 return SVC_DENIED;
382 p += 4;
383 if (strcmp(p, r->cl_server) != 0)
384 return SVC_DENIED;
385 return SVC_OK;
386}
387
Andy Adamsonc36fca52011-01-06 02:04:32 +0000388/* pg_authenticate method helper */
389static struct nfs_client *nfs_cb_find_client(struct svc_rqst *rqstp)
390{
391 struct nfs4_sessionid *sessionid = bc_xprt_sid(rqstp);
392 int is_cb_compound = rqstp->rq_proc == CB_COMPOUND ? 1 : 0;
393
394 dprintk("--> %s rq_proc %d\n", __func__, rqstp->rq_proc);
395 if (svc_is_backchannel(rqstp))
396 /* Sessionid (usually) set after CB_NULL ping */
397 return nfs4_find_client_sessionid(svc_addr(rqstp), sessionid,
398 is_cb_compound);
399 else
400 /* No callback identifier in pg_authenticate */
401 return nfs4_find_client_no_ident(svc_addr(rqstp));
402}
403
404/* pg_authenticate method for nfsv4 callback threads. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405static int nfs_callback_authenticate(struct svc_rqst *rqstp)
406{
David Howellsadfa6f92006-08-22 20:06:08 -0400407 struct nfs_client *clp;
Pavel Emelyanov5216a8e2008-02-21 10:57:45 +0300408 RPC_IFDEBUG(char buf[RPC_MAX_ADDRBUFLEN]);
Olga Kornievskaia945b34a2008-12-23 16:18:34 -0500409 int ret = SVC_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410
411 /* Don't talk to strangers */
Andy Adamsonc36fca52011-01-06 02:04:32 +0000412 clp = nfs_cb_find_client(rqstp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413 if (clp == NULL)
414 return SVC_DROP;
Chuck Leverad06e4b2007-02-12 00:53:32 -0800415
Harvey Harrison3110ff82008-05-02 13:42:44 -0700416 dprintk("%s: %s NFSv4 callback!\n", __func__,
Chuck Leverad06e4b2007-02-12 00:53:32 -0800417 svc_print_addr(rqstp, buf, sizeof(buf)));
Chuck Leverad06e4b2007-02-12 00:53:32 -0800418
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419 switch (rqstp->rq_authop->flavour) {
420 case RPC_AUTH_NULL:
421 if (rqstp->rq_proc != CB_NULL)
Olga Kornievskaia945b34a2008-12-23 16:18:34 -0500422 ret = SVC_DENIED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423 break;
424 case RPC_AUTH_UNIX:
425 break;
426 case RPC_AUTH_GSS:
Olga Kornievskaia945b34a2008-12-23 16:18:34 -0500427 ret = check_gss_callback_principal(clp, rqstp);
428 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429 default:
Olga Kornievskaia945b34a2008-12-23 16:18:34 -0500430 ret = SVC_DENIED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431 }
Olga Kornievskaia945b34a2008-12-23 16:18:34 -0500432 nfs_put_client(clp);
433 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434}
435
436/*
437 * Define NFS4 callback program
438 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439static struct svc_version *nfs4_callback_version[] = {
440 [1] = &nfs4_callback_version1,
Alexandros Batsakis07bccc22009-12-05 13:19:01 -0500441 [4] = &nfs4_callback_version4,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442};
443
444static struct svc_stat nfs4_callback_stats;
445
446static struct svc_program nfs4_callback_program = {
447 .pg_prog = NFS4_CALLBACK, /* RPC service number */
448 .pg_nvers = ARRAY_SIZE(nfs4_callback_version), /* Number of entries */
449 .pg_vers = nfs4_callback_version, /* version table */
450 .pg_name = "NFSv4 callback", /* service name */
451 .pg_class = "nfs", /* authentication class */
452 .pg_stats = &nfs4_callback_stats,
453 .pg_authenticate = nfs_callback_authenticate,
454};