1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * Neil Brown <neilb@cse.unsw.edu.au>
   4 * J. Bruce Fields <bfields@umich.edu>
   5 * Andy Adamson <andros@umich.edu>
   6 * Dug Song <dugsong@monkey.org>
   7 *
   8 * RPCSEC_GSS server authentication.
   9 * This implements RPCSEC_GSS as defined in rfc2203 (rpcsec_gss) and rfc2078
  10 * (gssapi)
  11 *
  12 * The RPCSEC_GSS involves three stages:
  13 *  1/ context creation
  14 *  2/ data exchange
  15 *  3/ context destruction
  16 *
  17 * Context creation is handled largely by upcalls to user-space.
  18 *  In particular, GSS_Accept_sec_context is handled by an upcall
  19 * Data exchange is handled entirely within the kernel
  20 *  In particular, GSS_GetMIC, GSS_VerifyMIC, GSS_Seal, GSS_Unseal are in-kernel.
  21 * Context destruction is handled in-kernel
  22 *  GSS_Delete_sec_context is in-kernel
  23 *
  24 * Context creation is initiated by a RPCSEC_GSS_INIT request arriving.
  25 * The context handle and gss_token are used as a key into the rpcsec_init cache.
  26 * The content of this cache includes some of the outputs of GSS_Accept_sec_context,
  27 * being major_status, minor_status, context_handle, reply_token.
  28 * These are sent back to the client.
  29 * Sequence window management is handled by the kernel.  The window size if currently
  30 * a compile time constant.
  31 *
  32 * When user-space is happy that a context is established, it places an entry
  33 * in the rpcsec_context cache. The key for this cache is the context_handle.
  34 * The content includes:
  35 *   uid/gidlist - for determining access rights
  36 *   mechanism type
  37 *   mechanism specific information, such as a key
  38 *
  39 */
  40
  41#include <linux/slab.h>
  42#include <linux/types.h>
  43#include <linux/module.h>
  44#include <linux/pagemap.h>
  45#include <linux/user_namespace.h>
  46
  47#include <linux/sunrpc/auth_gss.h>
  48#include <linux/sunrpc/gss_err.h>
  49#include <linux/sunrpc/svcauth.h>
  50#include <linux/sunrpc/svcauth_gss.h>
  51#include <linux/sunrpc/cache.h>
 
  52
  53#include <trace/events/rpcgss.h>
  54
  55#include "gss_rpc_upcall.h"
  56
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  57
  58/* The rpcsec_init cache is used for mapping RPCSEC_GSS_{,CONT_}INIT requests
  59 * into replies.
  60 *
  61 * Key is context handle (\x if empty) and gss_token.
  62 * Content is major_status minor_status (integers) context_handle, reply_token.
  63 *
  64 */
  65
  66static int netobj_equal(struct xdr_netobj *a, struct xdr_netobj *b)
  67{
  68	return a->len == b->len && 0 == memcmp(a->data, b->data, a->len);
  69}
  70
  71#define	RSI_HASHBITS	6
  72#define	RSI_HASHMAX	(1<<RSI_HASHBITS)
  73
  74struct rsi {
  75	struct cache_head	h;
  76	struct xdr_netobj	in_handle, in_token;
  77	struct xdr_netobj	out_handle, out_token;
  78	int			major_status, minor_status;
  79	struct rcu_head		rcu_head;
  80};
  81
  82static struct rsi *rsi_update(struct cache_detail *cd, struct rsi *new, struct rsi *old);
  83static struct rsi *rsi_lookup(struct cache_detail *cd, struct rsi *item);
  84
  85static void rsi_free(struct rsi *rsii)
  86{
  87	kfree(rsii->in_handle.data);
  88	kfree(rsii->in_token.data);
  89	kfree(rsii->out_handle.data);
  90	kfree(rsii->out_token.data);
  91}
  92
  93static void rsi_free_rcu(struct rcu_head *head)
  94{
  95	struct rsi *rsii = container_of(head, struct rsi, rcu_head);
  96
  97	rsi_free(rsii);
  98	kfree(rsii);
  99}
 100
 101static void rsi_put(struct kref *ref)
 102{
 103	struct rsi *rsii = container_of(ref, struct rsi, h.ref);
 104
 105	call_rcu(&rsii->rcu_head, rsi_free_rcu);
 106}
 107
 108static inline int rsi_hash(struct rsi *item)
 109{
 110	return hash_mem(item->in_handle.data, item->in_handle.len, RSI_HASHBITS)
 111	     ^ hash_mem(item->in_token.data, item->in_token.len, RSI_HASHBITS);
 112}
 113
 114static int rsi_match(struct cache_head *a, struct cache_head *b)
 115{
 116	struct rsi *item = container_of(a, struct rsi, h);
 117	struct rsi *tmp = container_of(b, struct rsi, h);
 118	return netobj_equal(&item->in_handle, &tmp->in_handle) &&
 119	       netobj_equal(&item->in_token, &tmp->in_token);
 120}
 121
 122static int dup_to_netobj(struct xdr_netobj *dst, char *src, int len)
 123{
 124	dst->len = len;
 125	dst->data = (len ? kmemdup(src, len, GFP_KERNEL) : NULL);
 126	if (len && !dst->data)
 127		return -ENOMEM;
 128	return 0;
 129}
 130
 131static inline int dup_netobj(struct xdr_netobj *dst, struct xdr_netobj *src)
 132{
 133	return dup_to_netobj(dst, src->data, src->len);
 134}
 135
 136static void rsi_init(struct cache_head *cnew, struct cache_head *citem)
 137{
 138	struct rsi *new = container_of(cnew, struct rsi, h);
 139	struct rsi *item = container_of(citem, struct rsi, h);
 140
 141	new->out_handle.data = NULL;
 142	new->out_handle.len = 0;
 143	new->out_token.data = NULL;
 144	new->out_token.len = 0;
 145	new->in_handle.len = item->in_handle.len;
 146	item->in_handle.len = 0;
 147	new->in_token.len = item->in_token.len;
 148	item->in_token.len = 0;
 149	new->in_handle.data = item->in_handle.data;
 150	item->in_handle.data = NULL;
 151	new->in_token.data = item->in_token.data;
 152	item->in_token.data = NULL;
 153}
 154
 155static void update_rsi(struct cache_head *cnew, struct cache_head *citem)
 156{
 157	struct rsi *new = container_of(cnew, struct rsi, h);
 158	struct rsi *item = container_of(citem, struct rsi, h);
 159
 160	BUG_ON(new->out_handle.data || new->out_token.data);
 161	new->out_handle.len = item->out_handle.len;
 162	item->out_handle.len = 0;
 163	new->out_token.len = item->out_token.len;
 164	item->out_token.len = 0;
 165	new->out_handle.data = item->out_handle.data;
 166	item->out_handle.data = NULL;
 167	new->out_token.data = item->out_token.data;
 168	item->out_token.data = NULL;
 169
 170	new->major_status = item->major_status;
 171	new->minor_status = item->minor_status;
 172}
 173
 174static struct cache_head *rsi_alloc(void)
 175{
 176	struct rsi *rsii = kmalloc(sizeof(*rsii), GFP_KERNEL);
 177	if (rsii)
 178		return &rsii->h;
 179	else
 180		return NULL;
 181}
 182
 183static int rsi_upcall(struct cache_detail *cd, struct cache_head *h)
 184{
 185	return sunrpc_cache_pipe_upcall_timeout(cd, h);
 186}
 187
 188static void rsi_request(struct cache_detail *cd,
 189		       struct cache_head *h,
 190		       char **bpp, int *blen)
 191{
 192	struct rsi *rsii = container_of(h, struct rsi, h);
 193
 194	qword_addhex(bpp, blen, rsii->in_handle.data, rsii->in_handle.len);
 195	qword_addhex(bpp, blen, rsii->in_token.data, rsii->in_token.len);
 196	(*bpp)[-1] = '\n';
 
 
 197}
 198
 199static int rsi_parse(struct cache_detail *cd,
 200		    char *mesg, int mlen)
 201{
 202	/* context token expiry major minor context token */
 203	char *buf = mesg;
 204	char *ep;
 205	int len;
 206	struct rsi rsii, *rsip = NULL;
 207	time64_t expiry;
 208	int status = -EINVAL;
 209
 210	memset(&rsii, 0, sizeof(rsii));
 211	/* handle */
 212	len = qword_get(&mesg, buf, mlen);
 213	if (len < 0)
 214		goto out;
 215	status = -ENOMEM;
 216	if (dup_to_netobj(&rsii.in_handle, buf, len))
 217		goto out;
 218
 219	/* token */
 220	len = qword_get(&mesg, buf, mlen);
 221	status = -EINVAL;
 222	if (len < 0)
 223		goto out;
 224	status = -ENOMEM;
 225	if (dup_to_netobj(&rsii.in_token, buf, len))
 226		goto out;
 227
 228	rsip = rsi_lookup(cd, &rsii);
 229	if (!rsip)
 230		goto out;
 231
 232	rsii.h.flags = 0;
 233	/* expiry */
 234	expiry = get_expiry(&mesg);
 235	status = -EINVAL;
 236	if (expiry == 0)
 237		goto out;
 238
 
 239	/* major/minor */
 240	len = qword_get(&mesg, buf, mlen);
 241	if (len <= 0)
 242		goto out;
 243	rsii.major_status = simple_strtoul(buf, &ep, 10);
 244	if (*ep)
 245		goto out;
 246	len = qword_get(&mesg, buf, mlen);
 247	if (len <= 0)
 248		goto out;
 249	rsii.minor_status = simple_strtoul(buf, &ep, 10);
 250	if (*ep)
 251		goto out;
 252
 253	/* out_handle */
 254	len = qword_get(&mesg, buf, mlen);
 255	if (len < 0)
 256		goto out;
 257	status = -ENOMEM;
 258	if (dup_to_netobj(&rsii.out_handle, buf, len))
 259		goto out;
 260
 261	/* out_token */
 262	len = qword_get(&mesg, buf, mlen);
 263	status = -EINVAL;
 264	if (len < 0)
 265		goto out;
 266	status = -ENOMEM;
 267	if (dup_to_netobj(&rsii.out_token, buf, len))
 268		goto out;
 269	rsii.h.expiry_time = expiry;
 270	rsip = rsi_update(cd, &rsii, rsip);
 271	status = 0;
 272out:
 273	rsi_free(&rsii);
 274	if (rsip)
 275		cache_put(&rsip->h, cd);
 276	else
 277		status = -ENOMEM;
 278	return status;
 279}
 280
 281static const struct cache_detail rsi_cache_template = {
 282	.owner		= THIS_MODULE,
 283	.hash_size	= RSI_HASHMAX,
 284	.name           = "auth.rpcsec.init",
 285	.cache_put      = rsi_put,
 286	.cache_upcall	= rsi_upcall,
 287	.cache_request  = rsi_request,
 288	.cache_parse    = rsi_parse,
 289	.match		= rsi_match,
 290	.init		= rsi_init,
 291	.update		= update_rsi,
 292	.alloc		= rsi_alloc,
 293};
 294
 295static struct rsi *rsi_lookup(struct cache_detail *cd, struct rsi *item)
 296{
 297	struct cache_head *ch;
 298	int hash = rsi_hash(item);
 299
 300	ch = sunrpc_cache_lookup_rcu(cd, &item->h, hash);
 301	if (ch)
 302		return container_of(ch, struct rsi, h);
 303	else
 304		return NULL;
 305}
 306
 307static struct rsi *rsi_update(struct cache_detail *cd, struct rsi *new, struct rsi *old)
 308{
 309	struct cache_head *ch;
 310	int hash = rsi_hash(new);
 311
 312	ch = sunrpc_cache_update(cd, &new->h,
 313				 &old->h, hash);
 314	if (ch)
 315		return container_of(ch, struct rsi, h);
 316	else
 317		return NULL;
 318}
 319
 320
 321/*
 322 * The rpcsec_context cache is used to store a context that is
 323 * used in data exchange.
 324 * The key is a context handle. The content is:
 325 *  uid, gidlist, mechanism, service-set, mech-specific-data
 326 */
 327
 328#define	RSC_HASHBITS	10
 329#define	RSC_HASHMAX	(1<<RSC_HASHBITS)
 330
 331#define GSS_SEQ_WIN	128
 332
 333struct gss_svc_seq_data {
 334	/* highest seq number seen so far: */
 335	u32			sd_max;
 336	/* for i such that sd_max-GSS_SEQ_WIN < i <= sd_max, the i-th bit of
 337	 * sd_win is nonzero iff sequence number i has been seen already: */
 338	unsigned long		sd_win[GSS_SEQ_WIN/BITS_PER_LONG];
 339	spinlock_t		sd_lock;
 340};
 341
 342struct rsc {
 343	struct cache_head	h;
 344	struct xdr_netobj	handle;
 345	struct svc_cred		cred;
 346	struct gss_svc_seq_data	seqdata;
 347	struct gss_ctx		*mechctx;
 348	struct rcu_head		rcu_head;
 349};
 350
 351static struct rsc *rsc_update(struct cache_detail *cd, struct rsc *new, struct rsc *old);
 352static struct rsc *rsc_lookup(struct cache_detail *cd, struct rsc *item);
 353
 354static void rsc_free(struct rsc *rsci)
 355{
 356	kfree(rsci->handle.data);
 357	if (rsci->mechctx)
 358		gss_delete_sec_context(&rsci->mechctx);
 359	free_svc_cred(&rsci->cred);
 360}
 361
 362static void rsc_free_rcu(struct rcu_head *head)
 363{
 364	struct rsc *rsci = container_of(head, struct rsc, rcu_head);
 365
 366	kfree(rsci->handle.data);
 367	kfree(rsci);
 368}
 369
 370static void rsc_put(struct kref *ref)
 371{
 372	struct rsc *rsci = container_of(ref, struct rsc, h.ref);
 373
 374	if (rsci->mechctx)
 375		gss_delete_sec_context(&rsci->mechctx);
 376	free_svc_cred(&rsci->cred);
 377	call_rcu(&rsci->rcu_head, rsc_free_rcu);
 378}
 379
 380static inline int
 381rsc_hash(struct rsc *rsci)
 382{
 383	return hash_mem(rsci->handle.data, rsci->handle.len, RSC_HASHBITS);
 384}
 385
 386static int
 387rsc_match(struct cache_head *a, struct cache_head *b)
 388{
 389	struct rsc *new = container_of(a, struct rsc, h);
 390	struct rsc *tmp = container_of(b, struct rsc, h);
 391
 392	return netobj_equal(&new->handle, &tmp->handle);
 393}
 394
 395static void
 396rsc_init(struct cache_head *cnew, struct cache_head *ctmp)
 397{
 398	struct rsc *new = container_of(cnew, struct rsc, h);
 399	struct rsc *tmp = container_of(ctmp, struct rsc, h);
 400
 401	new->handle.len = tmp->handle.len;
 402	tmp->handle.len = 0;
 403	new->handle.data = tmp->handle.data;
 404	tmp->handle.data = NULL;
 405	new->mechctx = NULL;
 406	init_svc_cred(&new->cred);
 407}
 408
 409static void
 410update_rsc(struct cache_head *cnew, struct cache_head *ctmp)
 411{
 412	struct rsc *new = container_of(cnew, struct rsc, h);
 413	struct rsc *tmp = container_of(ctmp, struct rsc, h);
 414
 415	new->mechctx = tmp->mechctx;
 416	tmp->mechctx = NULL;
 417	memset(&new->seqdata, 0, sizeof(new->seqdata));
 418	spin_lock_init(&new->seqdata.sd_lock);
 419	new->cred = tmp->cred;
 420	init_svc_cred(&tmp->cred);
 421}
 422
 423static struct cache_head *
 424rsc_alloc(void)
 425{
 426	struct rsc *rsci = kmalloc(sizeof(*rsci), GFP_KERNEL);
 427	if (rsci)
 428		return &rsci->h;
 429	else
 430		return NULL;
 431}
 432
 433static int rsc_upcall(struct cache_detail *cd, struct cache_head *h)
 434{
 435	return -EINVAL;
 436}
 437
 438static int rsc_parse(struct cache_detail *cd,
 439		     char *mesg, int mlen)
 440{
 441	/* contexthandle expiry [ uid gid N <n gids> mechname ...mechdata... ] */
 442	char *buf = mesg;
 443	int id;
 444	int len, rv;
 445	struct rsc rsci, *rscp = NULL;
 446	time64_t expiry;
 447	int status = -EINVAL;
 448	struct gss_api_mech *gm = NULL;
 449
 450	memset(&rsci, 0, sizeof(rsci));
 451	/* context handle */
 452	len = qword_get(&mesg, buf, mlen);
 453	if (len < 0) goto out;
 454	status = -ENOMEM;
 455	if (dup_to_netobj(&rsci.handle, buf, len))
 456		goto out;
 457
 458	rsci.h.flags = 0;
 459	/* expiry */
 460	expiry = get_expiry(&mesg);
 461	status = -EINVAL;
 462	if (expiry == 0)
 463		goto out;
 464
 
 465	rscp = rsc_lookup(cd, &rsci);
 466	if (!rscp)
 467		goto out;
 468
 469	/* uid, or NEGATIVE */
 470	rv = get_int(&mesg, &id);
 471	if (rv == -EINVAL)
 472		goto out;
 473	if (rv == -ENOENT)
 474		set_bit(CACHE_NEGATIVE, &rsci.h.flags);
 475	else {
 476		int N, i;
 477
 478		/*
 479		 * NOTE: we skip uid_valid()/gid_valid() checks here:
 480		 * instead, * -1 id's are later mapped to the
 481		 * (export-specific) anonymous id by nfsd_setuser.
 482		 *
 483		 * (But supplementary gid's get no such special
 484		 * treatment so are checked for validity here.)
 485		 */
 486		/* uid */
 487		rsci.cred.cr_uid = make_kuid(current_user_ns(), id);
 488
 489		/* gid */
 490		if (get_int(&mesg, &id))
 491			goto out;
 492		rsci.cred.cr_gid = make_kgid(current_user_ns(), id);
 493
 494		/* number of additional gid's */
 495		if (get_int(&mesg, &N))
 496			goto out;
 497		if (N < 0 || N > NGROUPS_MAX)
 498			goto out;
 499		status = -ENOMEM;
 500		rsci.cred.cr_group_info = groups_alloc(N);
 501		if (rsci.cred.cr_group_info == NULL)
 502			goto out;
 503
 504		/* gid's */
 505		status = -EINVAL;
 506		for (i=0; i<N; i++) {
 507			kgid_t kgid;
 508			if (get_int(&mesg, &id))
 509				goto out;
 510			kgid = make_kgid(current_user_ns(), id);
 511			if (!gid_valid(kgid))
 512				goto out;
 513			rsci.cred.cr_group_info->gid[i] = kgid;
 514		}
 515		groups_sort(rsci.cred.cr_group_info);
 516
 517		/* mech name */
 518		len = qword_get(&mesg, buf, mlen);
 519		if (len < 0)
 520			goto out;
 521		gm = rsci.cred.cr_gss_mech = gss_mech_get_by_name(buf);
 522		status = -EOPNOTSUPP;
 523		if (!gm)
 524			goto out;
 525
 526		status = -EINVAL;
 527		/* mech-specific data: */
 528		len = qword_get(&mesg, buf, mlen);
 529		if (len < 0)
 530			goto out;
 531		status = gss_import_sec_context(buf, len, gm, &rsci.mechctx,
 532						NULL, GFP_KERNEL);
 533		if (status)
 534			goto out;
 535
 536		/* get client name */
 537		len = qword_get(&mesg, buf, mlen);
 538		if (len > 0) {
 539			rsci.cred.cr_principal = kstrdup(buf, GFP_KERNEL);
 540			if (!rsci.cred.cr_principal) {
 541				status = -ENOMEM;
 542				goto out;
 543			}
 544		}
 545
 546	}
 547	rsci.h.expiry_time = expiry;
 548	rscp = rsc_update(cd, &rsci, rscp);
 549	status = 0;
 550out:
 551	rsc_free(&rsci);
 552	if (rscp)
 553		cache_put(&rscp->h, cd);
 554	else
 555		status = -ENOMEM;
 556	return status;
 557}
 558
 559static const struct cache_detail rsc_cache_template = {
 560	.owner		= THIS_MODULE,
 561	.hash_size	= RSC_HASHMAX,
 562	.name		= "auth.rpcsec.context",
 563	.cache_put	= rsc_put,
 564	.cache_upcall	= rsc_upcall,
 565	.cache_parse	= rsc_parse,
 566	.match		= rsc_match,
 567	.init		= rsc_init,
 568	.update		= update_rsc,
 569	.alloc		= rsc_alloc,
 570};
 571
 572static struct rsc *rsc_lookup(struct cache_detail *cd, struct rsc *item)
 573{
 574	struct cache_head *ch;
 575	int hash = rsc_hash(item);
 576
 577	ch = sunrpc_cache_lookup_rcu(cd, &item->h, hash);
 578	if (ch)
 579		return container_of(ch, struct rsc, h);
 580	else
 581		return NULL;
 582}
 583
 584static struct rsc *rsc_update(struct cache_detail *cd, struct rsc *new, struct rsc *old)
 585{
 586	struct cache_head *ch;
 587	int hash = rsc_hash(new);
 588
 589	ch = sunrpc_cache_update(cd, &new->h,
 590				 &old->h, hash);
 591	if (ch)
 592		return container_of(ch, struct rsc, h);
 593	else
 594		return NULL;
 595}
 596
 597
 598static struct rsc *
 599gss_svc_searchbyctx(struct cache_detail *cd, struct xdr_netobj *handle)
 600{
 601	struct rsc rsci;
 602	struct rsc *found;
 603
 604	memset(&rsci, 0, sizeof(rsci));
 605	if (dup_to_netobj(&rsci.handle, handle->data, handle->len))
 606		return NULL;
 607	found = rsc_lookup(cd, &rsci);
 608	rsc_free(&rsci);
 609	if (!found)
 610		return NULL;
 611	if (cache_check(cd, &found->h, NULL))
 612		return NULL;
 613	return found;
 614}
 615
 616/**
 617 * gss_check_seq_num - GSS sequence number window check
 618 * @rqstp: RPC Call to use when reporting errors
 619 * @rsci: cached GSS context state (updated on return)
 620 * @seq_num: sequence number to check
 621 *
 622 * Implements sequence number algorithm as specified in
 623 * RFC 2203, Section 5.3.3.1. "Context Management".
 624 *
 625 * Return values:
 626 *   %true: @rqstp's GSS sequence number is inside the window
 627 *   %false: @rqstp's GSS sequence number is outside the window
 628 */
 629static bool gss_check_seq_num(const struct svc_rqst *rqstp, struct rsc *rsci,
 630			      u32 seq_num)
 631{
 632	struct gss_svc_seq_data *sd = &rsci->seqdata;
 633	bool result = false;
 634
 635	spin_lock(&sd->sd_lock);
 636	if (seq_num > sd->sd_max) {
 637		if (seq_num >= sd->sd_max + GSS_SEQ_WIN) {
 638			memset(sd->sd_win, 0, sizeof(sd->sd_win));
 639			sd->sd_max = seq_num;
 640		} else while (sd->sd_max < seq_num) {
 641			sd->sd_max++;
 642			__clear_bit(sd->sd_max % GSS_SEQ_WIN, sd->sd_win);
 643		}
 644		__set_bit(seq_num % GSS_SEQ_WIN, sd->sd_win);
 645		goto ok;
 646	} else if (seq_num <= sd->sd_max - GSS_SEQ_WIN) {
 647		goto toolow;
 648	}
 649	if (__test_and_set_bit(seq_num % GSS_SEQ_WIN, sd->sd_win))
 650		goto alreadyseen;
 651
 652ok:
 653	result = true;
 654out:
 655	spin_unlock(&sd->sd_lock);
 656	return result;
 657
 658toolow:
 659	trace_rpcgss_svc_seqno_low(rqstp, seq_num,
 660				   sd->sd_max - GSS_SEQ_WIN,
 661				   sd->sd_max);
 662	goto out;
 663alreadyseen:
 664	trace_rpcgss_svc_seqno_seen(rqstp, seq_num);
 665	goto out;
 666}
 667
 668static inline u32 round_up_to_quad(u32 i)
 669{
 670	return (i + 3 ) & ~3;
 671}
 672
 673static inline int
 674svc_safe_getnetobj(struct kvec *argv, struct xdr_netobj *o)
 675{
 676	int l;
 677
 678	if (argv->iov_len < 4)
 679		return -1;
 680	o->len = svc_getnl(argv);
 681	l = round_up_to_quad(o->len);
 682	if (argv->iov_len < l)
 683		return -1;
 684	o->data = argv->iov_base;
 685	argv->iov_base += l;
 686	argv->iov_len -= l;
 687	return 0;
 688}
 689
 690static inline int
 691svc_safe_putnetobj(struct kvec *resv, struct xdr_netobj *o)
 692{
 693	u8 *p;
 694
 695	if (resv->iov_len + 4 > PAGE_SIZE)
 696		return -1;
 697	svc_putnl(resv, o->len);
 698	p = resv->iov_base + resv->iov_len;
 699	resv->iov_len += round_up_to_quad(o->len);
 700	if (resv->iov_len > PAGE_SIZE)
 701		return -1;
 702	memcpy(p, o->data, o->len);
 703	memset(p + o->len, 0, round_up_to_quad(o->len) - o->len);
 704	return 0;
 705}
 706
 707/*
 708 * Verify the checksum on the header and return SVC_OK on success.
 709 * Otherwise, return SVC_DROP (in the case of a bad sequence number)
 710 * or return SVC_DENIED and indicate error in authp.
 
 
 711 */
 712static int
 713gss_verify_header(struct svc_rqst *rqstp, struct rsc *rsci,
 714		  __be32 *rpcstart, struct rpc_gss_wire_cred *gc, __be32 *authp)
 715{
 
 716	struct gss_ctx		*ctx_id = rsci->mechctx;
 
 717	struct xdr_buf		rpchdr;
 718	struct xdr_netobj	checksum;
 719	u32			flavor = 0;
 720	struct kvec		*argv = &rqstp->rq_arg.head[0];
 721	struct kvec		iov;
 722
 723	/* data to compute the checksum over: */
 
 
 
 724	iov.iov_base = rpcstart;
 725	iov.iov_len = (u8 *)argv->iov_base - (u8 *)rpcstart;
 726	xdr_buf_from_iov(&iov, &rpchdr);
 727
 728	*authp = rpc_autherr_badverf;
 729	if (argv->iov_len < 4)
 
 
 
 730		return SVC_DENIED;
 731	flavor = svc_getnl(argv);
 732	if (flavor != RPC_AUTH_GSS)
 733		return SVC_DENIED;
 734	if (svc_safe_getnetobj(argv, &checksum))
 735		return SVC_DENIED;
 
 736
 737	if (rqstp->rq_deferred) /* skip verification of revisited request */
 738		return SVC_OK;
 739	if (gss_verify_mic(ctx_id, &rpchdr, &checksum) != GSS_S_COMPLETE) {
 740		*authp = rpcsec_gsserr_credproblem;
 
 
 741		return SVC_DENIED;
 742	}
 743
 744	if (gc->gc_seq > MAXSEQ) {
 745		trace_rpcgss_svc_seqno_large(rqstp, gc->gc_seq);
 746		*authp = rpcsec_gsserr_ctxproblem;
 747		return SVC_DENIED;
 748	}
 749	if (!gss_check_seq_num(rqstp, rsci, gc->gc_seq))
 750		return SVC_DROP;
 751	return SVC_OK;
 752}
 753
 754static int
 755gss_write_null_verf(struct svc_rqst *rqstp)
 756{
 757	__be32     *p;
 758
 759	svc_putnl(rqstp->rq_res.head, RPC_AUTH_NULL);
 760	p = rqstp->rq_res.head->iov_base + rqstp->rq_res.head->iov_len;
 761	/* don't really need to check if head->iov_len > PAGE_SIZE ... */
 762	*p++ = 0;
 763	if (!xdr_ressize_check(rqstp, p))
 764		return -1;
 765	return 0;
 766}
 767
 768static int
 769gss_write_verf(struct svc_rqst *rqstp, struct gss_ctx *ctx_id, u32 seq)
 770{
 771	__be32			*xdr_seq;
 772	u32			maj_stat;
 773	struct xdr_buf		verf_data;
 774	struct xdr_netobj	mic;
 775	__be32			*p;
 776	struct kvec		iov;
 777	int err = -1;
 778
 779	svc_putnl(rqstp->rq_res.head, RPC_AUTH_GSS);
 780	xdr_seq = kmalloc(4, GFP_KERNEL);
 781	if (!xdr_seq)
 782		return -1;
 783	*xdr_seq = htonl(seq);
 784
 785	iov.iov_base = xdr_seq;
 786	iov.iov_len = 4;
 787	xdr_buf_from_iov(&iov, &verf_data);
 788	p = rqstp->rq_res.head->iov_base + rqstp->rq_res.head->iov_len;
 789	mic.data = (u8 *)(p + 1);
 790	maj_stat = gss_get_mic(ctx_id, &verf_data, &mic);
 791	if (maj_stat != GSS_S_COMPLETE)
 792		goto out;
 793	*p++ = htonl(mic.len);
 794	memset((u8 *)p + mic.len, 0, round_up_to_quad(mic.len) - mic.len);
 795	p += XDR_QUADLEN(mic.len);
 796	if (!xdr_ressize_check(rqstp, p))
 797		goto out;
 798	err = 0;
 799out:
 800	kfree(xdr_seq);
 801	return err;
 802}
 803
 804struct gss_domain {
 805	struct auth_domain	h;
 806	u32			pseudoflavor;
 807};
 808
 809static struct auth_domain *
 810find_gss_auth_domain(struct gss_ctx *ctx, u32 svc)
 811{
 812	char *name;
 813
 814	name = gss_service_to_auth_domain_name(ctx->mech_type, svc);
 815	if (!name)
 816		return NULL;
 817	return auth_domain_find(name);
 818}
 819
 820static struct auth_ops svcauthops_gss;
 821
 822u32 svcauth_gss_flavor(struct auth_domain *dom)
 823{
 824	struct gss_domain *gd = container_of(dom, struct gss_domain, h);
 825
 826	return gd->pseudoflavor;
 827}
 828
 829EXPORT_SYMBOL_GPL(svcauth_gss_flavor);
 830
 831struct auth_domain *
 832svcauth_gss_register_pseudoflavor(u32 pseudoflavor, char * name)
 833{
 834	struct gss_domain	*new;
 835	struct auth_domain	*test;
 836	int			stat = -ENOMEM;
 837
 838	new = kmalloc(sizeof(*new), GFP_KERNEL);
 839	if (!new)
 840		goto out;
 841	kref_init(&new->h.ref);
 842	new->h.name = kstrdup(name, GFP_KERNEL);
 843	if (!new->h.name)
 844		goto out_free_dom;
 845	new->h.flavour = &svcauthops_gss;
 846	new->pseudoflavor = pseudoflavor;
 847
 848	test = auth_domain_lookup(name, &new->h);
 849	if (test != &new->h) {
 850		pr_warn("svc: duplicate registration of gss pseudo flavour %s.\n",
 851			name);
 852		stat = -EADDRINUSE;
 853		auth_domain_put(test);
 854		goto out_free_name;
 855	}
 856	return test;
 857
 858out_free_name:
 859	kfree(new->h.name);
 860out_free_dom:
 861	kfree(new);
 862out:
 863	return ERR_PTR(stat);
 864}
 865EXPORT_SYMBOL_GPL(svcauth_gss_register_pseudoflavor);
 866
 867static inline int
 868read_u32_from_xdr_buf(struct xdr_buf *buf, int base, u32 *obj)
 869{
 870	__be32  raw;
 871	int     status;
 872
 873	status = read_bytes_from_xdr_buf(buf, base, &raw, sizeof(*obj));
 874	if (status)
 875		return status;
 876	*obj = ntohl(raw);
 877	return 0;
 878}
 879
 880/* It would be nice if this bit of code could be shared with the client.
 881 * Obstacles:
 882 *	The client shouldn't malloc(), would have to pass in own memory.
 883 *	The server uses base of head iovec as read pointer, while the
 884 *	client uses separate pointer. */
 885static int
 886unwrap_integ_data(struct svc_rqst *rqstp, struct xdr_buf *buf, u32 seq, struct gss_ctx *ctx)
 887{
 888	u32 integ_len, rseqno, maj_stat;
 889	int stat = -EINVAL;
 890	struct xdr_netobj mic;
 891	struct xdr_buf integ_buf;
 892
 893	mic.data = NULL;
 894
 895	/* NFS READ normally uses splice to send data in-place. However
 896	 * the data in cache can change after the reply's MIC is computed
 897	 * but before the RPC reply is sent. To prevent the client from
 898	 * rejecting the server-computed MIC in this somewhat rare case,
 899	 * do not use splice with the GSS integrity service.
 900	 */
 901	clear_bit(RQ_SPLICE_OK, &rqstp->rq_flags);
 902
 903	/* Did we already verify the signature on the original pass through? */
 904	if (rqstp->rq_deferred)
 905		return 0;
 906
 907	integ_len = svc_getnl(&buf->head[0]);
 908	if (integ_len & 3)
 909		goto unwrap_failed;
 910	if (integ_len > buf->len)
 911		goto unwrap_failed;
 912	if (xdr_buf_subsegment(buf, &integ_buf, 0, integ_len))
 
 913		goto unwrap_failed;
 914
 915	/* copy out mic... */
 916	if (read_u32_from_xdr_buf(buf, integ_len, &mic.len))
 917		goto unwrap_failed;
 918	if (mic.len > RPC_MAX_AUTH_SIZE)
 
 
 
 
 
 
 919		goto unwrap_failed;
 920	mic.data = kmalloc(mic.len, GFP_KERNEL);
 921	if (!mic.data)
 922		goto unwrap_failed;
 923	if (read_bytes_from_xdr_buf(buf, integ_len + 4, mic.data, mic.len))
 
 
 924		goto unwrap_failed;
 925	maj_stat = gss_verify_mic(ctx, &integ_buf, &mic);
 
 926	if (maj_stat != GSS_S_COMPLETE)
 927		goto bad_mic;
 928	rseqno = svc_getnl(&buf->head[0]);
 929	if (rseqno != seq)
 
 
 
 930		goto bad_seqno;
 931	/* trim off the mic and padding at the end before returning */
 932	xdr_buf_trim(buf, round_up_to_quad(mic.len) + 4);
 933	stat = 0;
 934out:
 935	kfree(mic.data);
 936	return stat;
 937
 938unwrap_failed:
 939	trace_rpcgss_svc_unwrap_failed(rqstp);
 940	goto out;
 941bad_seqno:
 942	trace_rpcgss_svc_seqno_bad(rqstp, seq, rseqno);
 943	goto out;
 944bad_mic:
 945	trace_rpcgss_svc_mic(rqstp, maj_stat);
 946	goto out;
 947}
 948
 949static inline int
 950total_buf_len(struct xdr_buf *buf)
 951{
 952	return buf->head[0].iov_len + buf->page_len + buf->tail[0].iov_len;
 953}
 954
 955static void
 956fix_priv_head(struct xdr_buf *buf, int pad)
 957{
 958	if (buf->page_len == 0) {
 959		/* We need to adjust head and buf->len in tandem in this
 960		 * case to make svc_defer() work--it finds the original
 961		 * buffer start using buf->len - buf->head[0].iov_len. */
 962		buf->head[0].iov_len -= pad;
 963	}
 964}
 965
 966static int
 967unwrap_priv_data(struct svc_rqst *rqstp, struct xdr_buf *buf, u32 seq, struct gss_ctx *ctx)
 
 
 
 
 
 
 
 
 
 
 
 
 968{
 969	u32 priv_len, maj_stat;
 970	int pad, remaining_len, offset;
 971	u32 rseqno;
 972
 973	clear_bit(RQ_SPLICE_OK, &rqstp->rq_flags);
 974
 975	priv_len = svc_getnl(&buf->head[0]);
 
 976	if (rqstp->rq_deferred) {
 977		/* Already decrypted last time through! The sequence number
 978		 * check at out_seq is unnecessary but harmless: */
 979		goto out_seq;
 980	}
 981	/* buf->len is the number of bytes from the original start of the
 982	 * request to the end, where head[0].iov_len is just the bytes
 983	 * not yet read from the head, so these two values are different: */
 984	remaining_len = total_buf_len(buf);
 985	if (priv_len > remaining_len)
 986		goto unwrap_failed;
 987	pad = remaining_len - priv_len;
 988	buf->len -= pad;
 989	fix_priv_head(buf, pad);
 990
 991	maj_stat = gss_unwrap(ctx, 0, priv_len, buf);
 992	pad = priv_len - buf->len;
 993	/* The upper layers assume the buffer is aligned on 4-byte boundaries.
 994	 * In the krb5p case, at least, the data ends up offset, so we need to
 995	 * move it around. */
 996	/* XXX: This is very inefficient.  It would be better to either do
 997	 * this while we encrypt, or maybe in the receive code, if we can peak
 998	 * ahead and work out the service and mechanism there. */
 999	offset = xdr_pad_size(buf->head[0].iov_len);
1000	if (offset) {
1001		buf->buflen = RPCSVC_MAXPAYLOAD;
1002		xdr_shift_buf(buf, offset);
1003		fix_priv_head(buf, pad);
1004	}
1005	if (maj_stat != GSS_S_COMPLETE)
1006		goto bad_unwrap;
 
 
1007out_seq:
1008	rseqno = svc_getnl(&buf->head[0]);
1009	if (rseqno != seq)
 
 
1010		goto bad_seqno;
1011	return 0;
1012
1013unwrap_failed:
1014	trace_rpcgss_svc_unwrap_failed(rqstp);
1015	return -EINVAL;
1016bad_seqno:
1017	trace_rpcgss_svc_seqno_bad(rqstp, seq, rseqno);
1018	return -EINVAL;
1019bad_unwrap:
1020	trace_rpcgss_svc_unwrap(rqstp, maj_stat);
1021	return -EINVAL;
1022}
1023
1024struct gss_svc_data {
1025	/* decoded gss client cred: */
1026	struct rpc_gss_wire_cred	clcred;
1027	/* save a pointer to the beginning of the encoded verifier,
1028	 * for use in encryption/checksumming in svcauth_gss_release: */
1029	__be32				*verf_start;
1030	struct rsc			*rsci;
1031};
1032
1033static int
1034svcauth_gss_set_client(struct svc_rqst *rqstp)
1035{
1036	struct gss_svc_data *svcdata = rqstp->rq_auth_data;
1037	struct rsc *rsci = svcdata->rsci;
1038	struct rpc_gss_wire_cred *gc = &svcdata->clcred;
1039	int stat;
1040
 
 
1041	/*
1042	 * A gss export can be specified either by:
1043	 * 	export	*(sec=krb5,rw)
1044	 * or by
1045	 * 	export gss/krb5(rw)
1046	 * The latter is deprecated; but for backwards compatibility reasons
1047	 * the nfsd code will still fall back on trying it if the former
1048	 * doesn't work; so we try to make both available to nfsd, below.
1049	 */
1050	rqstp->rq_gssclient = find_gss_auth_domain(rsci->mechctx, gc->gc_svc);
1051	if (rqstp->rq_gssclient == NULL)
1052		return SVC_DENIED;
1053	stat = svcauth_unix_set_client(rqstp);
1054	if (stat == SVC_DROP || stat == SVC_CLOSE)
1055		return stat;
 
 
1056	return SVC_OK;
1057}
1058
1059static inline int
1060gss_write_init_verf(struct cache_detail *cd, struct svc_rqst *rqstp,
1061		struct xdr_netobj *out_handle, int *major_status)
 
1062{
 
1063	struct rsc *rsci;
1064	int        rc;
1065
1066	if (*major_status != GSS_S_COMPLETE)
1067		return gss_write_null_verf(rqstp);
1068	rsci = gss_svc_searchbyctx(cd, out_handle);
1069	if (rsci == NULL) {
1070		*major_status = GSS_S_NO_CONTEXT;
1071		return gss_write_null_verf(rqstp);
1072	}
1073	rc = gss_write_verf(rqstp, rsci->mechctx, GSS_SEQ_WIN);
 
1074	cache_put(&rsci->h, cd);
1075	return rc;
1076}
1077
1078static inline int
1079gss_read_common_verf(struct rpc_gss_wire_cred *gc,
1080		     struct kvec *argv, __be32 *authp,
1081		     struct xdr_netobj *in_handle)
1082{
1083	/* Read the verifier; should be NULL: */
1084	*authp = rpc_autherr_badverf;
1085	if (argv->iov_len < 2 * 4)
1086		return SVC_DENIED;
1087	if (svc_getnl(argv) != RPC_AUTH_NULL)
1088		return SVC_DENIED;
1089	if (svc_getnl(argv) != 0)
1090		return SVC_DENIED;
1091	/* Martial context handle and token for upcall: */
1092	*authp = rpc_autherr_badcred;
1093	if (gc->gc_proc == RPC_GSS_PROC_INIT && gc->gc_ctx.len != 0)
1094		return SVC_DENIED;
1095	if (dup_netobj(in_handle, &gc->gc_ctx))
1096		return SVC_CLOSE;
1097	*authp = rpc_autherr_badverf;
1098
1099	return 0;
1100}
1101
1102static inline int
1103gss_read_verf(struct rpc_gss_wire_cred *gc,
1104	      struct kvec *argv, __be32 *authp,
1105	      struct xdr_netobj *in_handle,
1106	      struct xdr_netobj *in_token)
1107{
1108	struct xdr_netobj tmpobj;
1109	int res;
1110
1111	res = gss_read_common_verf(gc, argv, authp, in_handle);
1112	if (res)
1113		return res;
1114
1115	if (svc_safe_getnetobj(argv, &tmpobj)) {
1116		kfree(in_handle->data);
1117		return SVC_DENIED;
1118	}
1119	if (dup_netobj(in_token, &tmpobj)) {
1120		kfree(in_handle->data);
1121		return SVC_CLOSE;
1122	}
1123
1124	return 0;
1125}
1126
1127static void gss_free_in_token_pages(struct gssp_in_token *in_token)
1128{
1129	u32 inlen;
1130	int i;
1131
1132	i = 0;
1133	inlen = in_token->page_len;
1134	while (inlen) {
1135		if (in_token->pages[i])
1136			put_page(in_token->pages[i]);
1137		inlen -= inlen > PAGE_SIZE ? PAGE_SIZE : inlen;
1138	}
1139
1140	kfree(in_token->pages);
1141	in_token->pages = NULL;
1142}
1143
1144static int gss_read_proxy_verf(struct svc_rqst *rqstp,
1145			       struct rpc_gss_wire_cred *gc, __be32 *authp,
1146			       struct xdr_netobj *in_handle,
1147			       struct gssp_in_token *in_token)
1148{
1149	struct kvec *argv = &rqstp->rq_arg.head[0];
1150	unsigned int page_base, length;
1151	int pages, i, res;
1152	size_t inlen;
 
1153
1154	res = gss_read_common_verf(gc, argv, authp, in_handle);
1155	if (res)
1156		return res;
1157
1158	inlen = svc_getnl(argv);
1159	if (inlen > (argv->iov_len + rqstp->rq_arg.page_len))
1160		return SVC_DENIED;
 
 
 
 
 
 
 
 
1161
1162	pages = DIV_ROUND_UP(inlen, PAGE_SIZE);
1163	in_token->pages = kcalloc(pages, sizeof(struct page *), GFP_KERNEL);
1164	if (!in_token->pages)
1165		return SVC_DENIED;
1166	in_token->page_base = 0;
1167	in_token->page_len = inlen;
1168	for (i = 0; i < pages; i++) {
1169		in_token->pages[i] = alloc_page(GFP_KERNEL);
1170		if (!in_token->pages[i]) {
1171			gss_free_in_token_pages(in_token);
1172			return SVC_DENIED;
1173		}
1174	}
1175
1176	length = min_t(unsigned int, inlen, argv->iov_len);
1177	memcpy(page_address(in_token->pages[0]), argv->iov_base, length);
1178	inlen -= length;
1179
1180	i = 1;
1181	page_base = rqstp->rq_arg.page_base;
1182	while (inlen) {
1183		length = min_t(unsigned int, inlen, PAGE_SIZE);
1184		memcpy(page_address(in_token->pages[i]),
1185		       page_address(rqstp->rq_arg.pages[i]) + page_base,
 
 
 
 
 
 
 
1186		       length);
1187
 
 
1188		inlen -= length;
1189		page_base = 0;
1190		i++;
1191	}
1192	return 0;
 
 
 
 
1193}
1194
1195static inline int
1196gss_write_resv(struct kvec *resv, size_t size_limit,
1197	       struct xdr_netobj *out_handle, struct xdr_netobj *out_token,
1198	       int major_status, int minor_status)
1199{
1200	if (resv->iov_len + 4 > size_limit)
1201		return -1;
1202	svc_putnl(resv, RPC_SUCCESS);
1203	if (svc_safe_putnetobj(resv, out_handle))
1204		return -1;
1205	if (resv->iov_len + 3 * 4 > size_limit)
1206		return -1;
1207	svc_putnl(resv, major_status);
1208	svc_putnl(resv, minor_status);
1209	svc_putnl(resv, GSS_SEQ_WIN);
1210	if (svc_safe_putnetobj(resv, out_token))
1211		return -1;
1212	return 0;
 
 
 
 
 
 
 
 
 
 
 
1213}
1214
1215/*
1216 * Having read the cred already and found we're in the context
1217 * initiation case, read the verifier and initiate (or check the results
1218 * of) upcalls to userspace for help with context initiation.  If
1219 * the upcall results are available, write the verifier and result.
1220 * Otherwise, drop the request pending an answer to the upcall.
1221 */
1222static int svcauth_gss_legacy_init(struct svc_rqst *rqstp,
1223			struct rpc_gss_wire_cred *gc, __be32 *authp)
 
1224{
1225	struct kvec *argv = &rqstp->rq_arg.head[0];
1226	struct kvec *resv = &rqstp->rq_res.head[0];
1227	struct rsi *rsip, rsikey;
 
 
1228	int ret;
1229	struct sunrpc_net *sn = net_generic(SVC_NET(rqstp), sunrpc_net_id);
1230
1231	memset(&rsikey, 0, sizeof(rsikey));
1232	ret = gss_read_verf(gc, argv, authp,
1233			    &rsikey.in_handle, &rsikey.in_token);
1234	if (ret)
1235		return ret;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1236
1237	/* Perform upcall, or find upcall result: */
1238	rsip = rsi_lookup(sn->rsi_cache, &rsikey);
1239	rsi_free(&rsikey);
1240	if (!rsip)
1241		return SVC_CLOSE;
1242	if (cache_check(sn->rsi_cache, &rsip->h, &rqstp->rq_chandle) < 0)
1243		/* No upcall result: */
1244		return SVC_CLOSE;
1245
1246	ret = SVC_CLOSE;
1247	/* Got an answer to the upcall; use it: */
1248	if (gss_write_init_verf(sn->rsc_cache, rqstp,
1249				&rsip->out_handle, &rsip->major_status))
1250		goto out;
1251	if (gss_write_resv(resv, PAGE_SIZE,
1252			   &rsip->out_handle, &rsip->out_token,
1253			   rsip->major_status, rsip->minor_status))
 
1254		goto out;
1255
1256	ret = SVC_COMPLETE;
1257out:
1258	cache_put(&rsip->h, sn->rsi_cache);
1259	return ret;
1260}
1261
1262static int gss_proxy_save_rsc(struct cache_detail *cd,
1263				struct gssp_upcall_data *ud,
1264				uint64_t *handle)
1265{
1266	struct rsc rsci, *rscp = NULL;
1267	static atomic64_t ctxhctr;
1268	long long ctxh;
1269	struct gss_api_mech *gm = NULL;
1270	time64_t expiry;
1271	int status = -EINVAL;
1272
1273	memset(&rsci, 0, sizeof(rsci));
1274	/* context handle */
1275	status = -ENOMEM;
1276	/* the handle needs to be just a unique id,
1277	 * use a static counter */
1278	ctxh = atomic64_inc_return(&ctxhctr);
1279
1280	/* make a copy for the caller */
1281	*handle = ctxh;
1282
1283	/* make a copy for the rsc cache */
1284	if (dup_to_netobj(&rsci.handle, (char *)handle, sizeof(uint64_t)))
1285		goto out;
1286	rscp = rsc_lookup(cd, &rsci);
1287	if (!rscp)
1288		goto out;
1289
1290	/* creds */
1291	if (!ud->found_creds) {
1292		/* userspace seem buggy, we should always get at least a
1293		 * mapping to nobody */
1294		goto out;
1295	} else {
1296		struct timespec64 boot;
1297
1298		/* steal creds */
1299		rsci.cred = ud->creds;
1300		memset(&ud->creds, 0, sizeof(struct svc_cred));
1301
1302		status = -EOPNOTSUPP;
1303		/* get mech handle from OID */
1304		gm = gss_mech_get_by_OID(&ud->mech_oid);
1305		if (!gm)
1306			goto out;
1307		rsci.cred.cr_gss_mech = gm;
1308
1309		status = -EINVAL;
1310		/* mech-specific data: */
1311		status = gss_import_sec_context(ud->out_handle.data,
1312						ud->out_handle.len,
1313						gm, &rsci.mechctx,
1314						&expiry, GFP_KERNEL);
1315		if (status)
1316			goto out;
1317
1318		getboottime64(&boot);
1319		expiry -= boot.tv_sec;
1320	}
1321
1322	rsci.h.expiry_time = expiry;
1323	rscp = rsc_update(cd, &rsci, rscp);
1324	status = 0;
1325out:
1326	rsc_free(&rsci);
1327	if (rscp)
1328		cache_put(&rscp->h, cd);
1329	else
1330		status = -ENOMEM;
1331	return status;
1332}
1333
1334static int svcauth_gss_proxy_init(struct svc_rqst *rqstp,
1335			struct rpc_gss_wire_cred *gc, __be32 *authp)
1336{
1337	struct kvec *resv = &rqstp->rq_res.head[0];
1338	struct xdr_netobj cli_handle;
1339	struct gssp_upcall_data ud;
1340	uint64_t handle;
1341	int status;
1342	int ret;
1343	struct net *net = SVC_NET(rqstp);
1344	struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
1345
1346	memset(&ud, 0, sizeof(ud));
1347	ret = gss_read_proxy_verf(rqstp, gc, authp,
1348				  &ud.in_handle, &ud.in_token);
1349	if (ret)
1350		return ret;
1351
1352	ret = SVC_CLOSE;
1353
1354	/* Perform synchronous upcall to gss-proxy */
1355	status = gssp_accept_sec_context_upcall(net, &ud);
1356	if (status)
1357		goto out;
1358
1359	trace_rpcgss_svc_accept_upcall(rqstp, ud.major_status, ud.minor_status);
1360
1361	switch (ud.major_status) {
1362	case GSS_S_CONTINUE_NEEDED:
1363		cli_handle = ud.out_handle;
1364		break;
1365	case GSS_S_COMPLETE:
1366		status = gss_proxy_save_rsc(sn->rsc_cache, &ud, &handle);
1367		if (status)
1368			goto out;
1369		cli_handle.data = (u8 *)&handle;
1370		cli_handle.len = sizeof(handle);
1371		break;
1372	default:
1373		goto out;
1374	}
1375
1376	/* Got an answer to the upcall; use it: */
1377	if (gss_write_init_verf(sn->rsc_cache, rqstp,
1378				&cli_handle, &ud.major_status))
1379		goto out;
1380	if (gss_write_resv(resv, PAGE_SIZE,
1381			   &cli_handle, &ud.out_token,
1382			   ud.major_status, ud.minor_status))
 
1383		goto out;
1384
1385	ret = SVC_COMPLETE;
1386out:
1387	gss_free_in_token_pages(&ud.in_token);
1388	gssp_free_upcall_data(&ud);
1389	return ret;
1390}
1391
1392/*
1393 * Try to set the sn->use_gss_proxy variable to a new value. We only allow
1394 * it to be changed if it's currently undefined (-1). If it's any other value
1395 * then return -EBUSY unless the type wouldn't have changed anyway.
1396 */
1397static int set_gss_proxy(struct net *net, int type)
1398{
1399	struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
1400	int ret;
1401
1402	WARN_ON_ONCE(type != 0 && type != 1);
1403	ret = cmpxchg(&sn->use_gss_proxy, -1, type);
1404	if (ret != -1 && ret != type)
1405		return -EBUSY;
1406	return 0;
1407}
1408
1409static bool use_gss_proxy(struct net *net)
1410{
1411	struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
1412
1413	/* If use_gss_proxy is still undefined, then try to disable it */
1414	if (sn->use_gss_proxy == -1)
1415		set_gss_proxy(net, 0);
1416	return sn->use_gss_proxy;
1417}
1418
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1419#ifdef CONFIG_PROC_FS
1420
1421static ssize_t write_gssp(struct file *file, const char __user *buf,
1422			 size_t count, loff_t *ppos)
1423{
1424	struct net *net = PDE_DATA(file_inode(file));
1425	char tbuf[20];
1426	unsigned long i;
1427	int res;
1428
1429	if (*ppos || count > sizeof(tbuf)-1)
1430		return -EINVAL;
1431	if (copy_from_user(tbuf, buf, count))
1432		return -EFAULT;
1433
1434	tbuf[count] = 0;
1435	res = kstrtoul(tbuf, 0, &i);
1436	if (res)
1437		return res;
1438	if (i != 1)
1439		return -EINVAL;
1440	res = set_gssp_clnt(net);
1441	if (res)
1442		return res;
1443	res = set_gss_proxy(net, 1);
1444	if (res)
1445		return res;
1446	return count;
1447}
1448
1449static ssize_t read_gssp(struct file *file, char __user *buf,
1450			 size_t count, loff_t *ppos)
1451{
1452	struct net *net = PDE_DATA(file_inode(file));
1453	struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
1454	unsigned long p = *ppos;
1455	char tbuf[10];
1456	size_t len;
1457
1458	snprintf(tbuf, sizeof(tbuf), "%d\n", sn->use_gss_proxy);
1459	len = strlen(tbuf);
1460	if (p >= len)
1461		return 0;
1462	len -= p;
1463	if (len > count)
1464		len = count;
1465	if (copy_to_user(buf, (void *)(tbuf+p), len))
1466		return -EFAULT;
1467	*ppos += len;
1468	return len;
1469}
1470
1471static const struct proc_ops use_gss_proxy_proc_ops = {
1472	.proc_open	= nonseekable_open,
1473	.proc_write	= write_gssp,
1474	.proc_read	= read_gssp,
1475};
1476
1477static int create_use_gss_proxy_proc_entry(struct net *net)
1478{
1479	struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
1480	struct proc_dir_entry **p = &sn->use_gssp_proc;
1481
1482	sn->use_gss_proxy = -1;
1483	*p = proc_create_data("use-gss-proxy", S_IFREG | 0600,
1484			      sn->proc_net_rpc,
1485			      &use_gss_proxy_proc_ops, net);
1486	if (!*p)
1487		return -ENOMEM;
1488	init_gssp_clnt(sn);
1489	return 0;
1490}
1491
1492static void destroy_use_gss_proxy_proc_entry(struct net *net)
1493{
1494	struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
1495
1496	if (sn->use_gssp_proc) {
1497		remove_proc_entry("use-gss-proxy", sn->proc_net_rpc);
1498		clear_gssp_clnt(sn);
1499	}
1500}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1501#else /* CONFIG_PROC_FS */
1502
1503static int create_use_gss_proxy_proc_entry(struct net *net)
1504{
1505	return 0;
1506}
1507
1508static void destroy_use_gss_proxy_proc_entry(struct net *net) {}
1509
 
 
 
 
 
 
 
1510#endif /* CONFIG_PROC_FS */
1511
1512/*
1513 * Accept an rpcsec packet.
1514 * If context establishment, punt to user space
1515 * If data exchange, verify/decrypt
1516 * If context destruction, handle here
1517 * In the context establishment and destruction case we encode
1518 * response here and return SVC_COMPLETE.
 
 
 
 
 
 
 
 
 
1519 */
1520static int
1521svcauth_gss_accept(struct svc_rqst *rqstp, __be32 *authp)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1522{
1523	struct kvec	*argv = &rqstp->rq_arg.head[0];
1524	struct kvec	*resv = &rqstp->rq_res.head[0];
1525	u32		crlen;
1526	struct gss_svc_data *svcdata = rqstp->rq_auth_data;
 
1527	struct rpc_gss_wire_cred *gc;
1528	struct rsc	*rsci = NULL;
1529	__be32		*rpcstart;
1530	__be32		*reject_stat = resv->iov_base + resv->iov_len;
1531	int		ret;
1532	struct sunrpc_net *sn = net_generic(SVC_NET(rqstp), sunrpc_net_id);
1533
1534	*authp = rpc_autherr_badcred;
1535	if (!svcdata)
1536		svcdata = kmalloc(sizeof(*svcdata), GFP_KERNEL);
1537	if (!svcdata)
1538		goto auth_err;
1539	rqstp->rq_auth_data = svcdata;
1540	svcdata->verf_start = NULL;
1541	svcdata->rsci = NULL;
1542	gc = &svcdata->clcred;
1543
1544	/* start of rpc packet is 7 u32's back from here:
1545	 * xid direction rpcversion prog vers proc flavour
1546	 */
1547	rpcstart = argv->iov_base;
1548	rpcstart -= 7;
1549
1550	/* credential is:
1551	 *   version(==1), proc(0,1,2,3), seq, service (1,2,3), handle
1552	 * at least 5 u32s, and is preceded by length, so that makes 6.
1553	 */
1554
1555	if (argv->iov_len < 5 * 4)
1556		goto auth_err;
1557	crlen = svc_getnl(argv);
1558	if (svc_getnl(argv) != RPC_GSS_VERSION)
1559		goto auth_err;
1560	gc->gc_proc = svc_getnl(argv);
1561	gc->gc_seq = svc_getnl(argv);
1562	gc->gc_svc = svc_getnl(argv);
1563	if (svc_safe_getnetobj(argv, &gc->gc_ctx))
1564		goto auth_err;
1565	if (crlen != round_up_to_quad(gc->gc_ctx.len) + 5 * 4)
1566		goto auth_err;
1567
1568	if ((gc->gc_proc != RPC_GSS_PROC_DATA) && (rqstp->rq_proc != 0))
1569		goto auth_err;
1570
1571	*authp = rpc_autherr_badverf;
1572	switch (gc->gc_proc) {
1573	case RPC_GSS_PROC_INIT:
1574	case RPC_GSS_PROC_CONTINUE_INIT:
1575		if (use_gss_proxy(SVC_NET(rqstp)))
1576			return svcauth_gss_proxy_init(rqstp, gc, authp);
1577		else
1578			return svcauth_gss_legacy_init(rqstp, gc, authp);
1579	case RPC_GSS_PROC_DATA:
1580	case RPC_GSS_PROC_DESTROY:
1581		/* Look up the context, and check the verifier: */
1582		*authp = rpcsec_gsserr_credproblem;
 
 
 
1583		rsci = gss_svc_searchbyctx(sn->rsc_cache, &gc->gc_ctx);
1584		if (!rsci)
1585			goto auth_err;
1586		switch (gss_verify_header(rqstp, rsci, rpcstart, gc, authp)) {
1587		case SVC_OK:
1588			break;
1589		case SVC_DENIED:
1590			goto auth_err;
1591		case SVC_DROP:
1592			goto drop;
1593		}
1594		break;
1595	default:
1596		*authp = rpc_autherr_rejectedcred;
 
 
1597		goto auth_err;
1598	}
1599
1600	/* now act upon the command: */
1601	switch (gc->gc_proc) {
1602	case RPC_GSS_PROC_DESTROY:
1603		if (gss_write_verf(rqstp, rsci->mechctx, gc->gc_seq))
 
 
1604			goto auth_err;
1605		/* Delete the entry from the cache_list and call cache_put */
1606		sunrpc_cache_unhash(sn->rsc_cache, &rsci->h);
1607		if (resv->iov_len + 4 > PAGE_SIZE)
1608			goto drop;
1609		svc_putnl(resv, RPC_SUCCESS);
1610		goto complete;
1611	case RPC_GSS_PROC_DATA:
1612		*authp = rpcsec_gsserr_ctxproblem;
1613		svcdata->verf_start = resv->iov_base + resv->iov_len;
1614		if (gss_write_verf(rqstp, rsci->mechctx, gc->gc_seq))
1615			goto auth_err;
 
 
 
1616		rqstp->rq_cred = rsci->cred;
1617		get_group_info(rsci->cred.cr_group_info);
1618		*authp = rpc_autherr_badcred;
1619		switch (gc->gc_svc) {
1620		case RPC_GSS_SVC_NONE:
1621			break;
1622		case RPC_GSS_SVC_INTEGRITY:
1623			/* placeholders for length and seq. number: */
1624			svc_putnl(resv, 0);
1625			svc_putnl(resv, 0);
1626			if (unwrap_integ_data(rqstp, &rqstp->rq_arg,
1627					gc->gc_seq, rsci->mechctx))
1628				goto garbage_args;
1629			rqstp->rq_auth_slack = RPC_MAX_AUTH_SIZE;
1630			break;
1631		case RPC_GSS_SVC_PRIVACY:
1632			/* placeholders for length and seq. number: */
1633			svc_putnl(resv, 0);
1634			svc_putnl(resv, 0);
1635			if (unwrap_priv_data(rqstp, &rqstp->rq_arg,
1636					gc->gc_seq, rsci->mechctx))
1637				goto garbage_args;
1638			rqstp->rq_auth_slack = RPC_MAX_AUTH_SIZE * 2;
1639			break;
1640		default:
1641			goto auth_err;
1642		}
1643		svcdata->rsci = rsci;
1644		cache_get(&rsci->h);
1645		rqstp->rq_cred.cr_flavor = gss_svc_to_pseudoflavor(
1646					rsci->mechctx->mech_type,
1647					GSS_C_QOP_DEFAULT,
1648					gc->gc_svc);
1649		ret = SVC_OK;
1650		trace_rpcgss_svc_authenticate(rqstp, gc);
1651		goto out;
1652	}
1653garbage_args:
1654	ret = SVC_GARBAGE;
1655	goto out;
1656auth_err:
1657	/* Restore write pointer to its original value: */
1658	xdr_ressize_check(rqstp, reject_stat);
1659	ret = SVC_DENIED;
1660	goto out;
1661complete:
1662	ret = SVC_COMPLETE;
1663	goto out;
1664drop:
1665	ret = SVC_CLOSE;
1666out:
1667	if (rsci)
1668		cache_put(&rsci->h, sn->rsc_cache);
1669	return ret;
1670}
1671
1672static __be32 *
1673svcauth_gss_prepare_to_wrap(struct xdr_buf *resbuf, struct gss_svc_data *gsd)
1674{
1675	__be32 *p;
1676	u32 verf_len;
1677
1678	p = gsd->verf_start;
1679	gsd->verf_start = NULL;
 
1680
1681	/* If the reply stat is nonzero, don't wrap: */
1682	if (*(p-1) != rpc_success)
1683		return NULL;
1684	/* Skip the verifier: */
1685	p += 1;
1686	verf_len = ntohl(*p++);
1687	p += XDR_QUADLEN(verf_len);
1688	/* move accept_stat to right place: */
1689	memcpy(p, p + 2, 4);
1690	/* Also don't wrap if the accept stat is nonzero: */
1691	if (*p != rpc_success) {
1692		resbuf->head[0].iov_len -= 2 * 4;
1693		return NULL;
1694	}
1695	p++;
1696	return p;
1697}
1698
1699static inline int
1700svcauth_gss_wrap_resp_integ(struct svc_rqst *rqstp)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1701{
1702	struct gss_svc_data *gsd = (struct gss_svc_data *)rqstp->rq_auth_data;
 
1703	struct rpc_gss_wire_cred *gc = &gsd->clcred;
1704	struct xdr_buf *resbuf = &rqstp->rq_res;
1705	struct xdr_buf integ_buf;
1706	struct xdr_netobj mic;
1707	struct kvec *resv;
1708	__be32 *p;
1709	int integ_offset, integ_len;
1710	int stat = -EINVAL;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1711
1712	p = svcauth_gss_prepare_to_wrap(resbuf, gsd);
1713	if (p == NULL)
1714		goto out;
1715	integ_offset = (u8 *)(p + 1) - (u8 *)resbuf->head[0].iov_base;
1716	integ_len = resbuf->len - integ_offset;
1717	if (integ_len & 3)
1718		goto out;
1719	*p++ = htonl(integ_len);
1720	*p++ = htonl(gc->gc_seq);
1721	if (xdr_buf_subsegment(resbuf, &integ_buf, integ_offset, integ_len)) {
1722		WARN_ON_ONCE(1);
1723		goto out_err;
1724	}
1725	if (resbuf->tail[0].iov_base == NULL) {
1726		if (resbuf->head[0].iov_len + RPC_MAX_AUTH_SIZE > PAGE_SIZE)
1727			goto out_err;
1728		resbuf->tail[0].iov_base = resbuf->head[0].iov_base
1729						+ resbuf->head[0].iov_len;
1730		resbuf->tail[0].iov_len = 0;
1731	}
1732	resv = &resbuf->tail[0];
1733	mic.data = (u8 *)resv->iov_base + resv->iov_len + 4;
1734	if (gss_get_mic(gsd->rsci->mechctx, &integ_buf, &mic))
1735		goto out_err;
1736	svc_putnl(resv, mic.len);
1737	memset(mic.data + mic.len, 0,
1738			round_up_to_quad(mic.len) - mic.len);
1739	resv->iov_len += XDR_QUADLEN(mic.len) << 2;
1740	/* not strictly required: */
1741	resbuf->len += XDR_QUADLEN(mic.len) << 2;
1742	if (resv->iov_len > PAGE_SIZE)
1743		goto out_err;
1744out:
1745	stat = 0;
1746out_err:
1747	return stat;
 
 
 
 
 
1748}
1749
1750static inline int
1751svcauth_gss_wrap_resp_priv(struct svc_rqst *rqstp)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1752{
1753	struct gss_svc_data *gsd = (struct gss_svc_data *)rqstp->rq_auth_data;
1754	struct rpc_gss_wire_cred *gc = &gsd->clcred;
1755	struct xdr_buf *resbuf = &rqstp->rq_res;
1756	struct page **inpages = NULL;
1757	__be32 *p, *len;
1758	int offset;
1759	int pad;
1760
1761	p = svcauth_gss_prepare_to_wrap(resbuf, gsd);
1762	if (p == NULL)
1763		return 0;
1764	len = p++;
1765	offset = (u8 *)p - (u8 *)resbuf->head[0].iov_base;
1766	*p++ = htonl(gc->gc_seq);
1767	inpages = resbuf->pages;
1768	/* XXX: Would be better to write some xdr helper functions for
1769	 * nfs{2,3,4}xdr.c that place the data right, instead of copying: */
 
 
1770
1771	/*
1772	 * If there is currently tail data, make sure there is
1773	 * room for the head, tail, and 2 * RPC_MAX_AUTH_SIZE in
1774	 * the page, and move the current tail data such that
1775	 * there is RPC_MAX_AUTH_SIZE slack space available in
1776	 * both the head and tail.
1777	 */
1778	if (resbuf->tail[0].iov_base) {
1779		if (resbuf->tail[0].iov_base >=
1780			resbuf->head[0].iov_base + PAGE_SIZE)
1781			return -EINVAL;
1782		if (resbuf->tail[0].iov_base < resbuf->head[0].iov_base)
1783			return -EINVAL;
1784		if (resbuf->tail[0].iov_len + resbuf->head[0].iov_len
1785				+ 2 * RPC_MAX_AUTH_SIZE > PAGE_SIZE)
1786			return -ENOMEM;
1787		memmove(resbuf->tail[0].iov_base + RPC_MAX_AUTH_SIZE,
1788			resbuf->tail[0].iov_base,
1789			resbuf->tail[0].iov_len);
1790		resbuf->tail[0].iov_base += RPC_MAX_AUTH_SIZE;
1791	}
1792	/*
1793	 * If there is no current tail data, make sure there is
1794	 * room for the head data, and 2 * RPC_MAX_AUTH_SIZE in the
1795	 * allotted page, and set up tail information such that there
1796	 * is RPC_MAX_AUTH_SIZE slack space available in both the
1797	 * head and tail.
1798	 */
1799	if (resbuf->tail[0].iov_base == NULL) {
1800		if (resbuf->head[0].iov_len + 2*RPC_MAX_AUTH_SIZE > PAGE_SIZE)
1801			return -ENOMEM;
1802		resbuf->tail[0].iov_base = resbuf->head[0].iov_base
1803			+ resbuf->head[0].iov_len + RPC_MAX_AUTH_SIZE;
1804		resbuf->tail[0].iov_len = 0;
1805	}
1806	if (gss_wrap(gsd->rsci->mechctx, offset, resbuf, inpages))
1807		return -ENOMEM;
1808	*len = htonl(resbuf->len - offset);
1809	pad = 3 - ((resbuf->len - offset - 1)&3);
1810	p = (__be32 *)(resbuf->tail[0].iov_base + resbuf->tail[0].iov_len);
 
 
 
 
 
 
1811	memset(p, 0, pad);
1812	resbuf->tail[0].iov_len += pad;
1813	resbuf->len += pad;
 
1814	return 0;
 
 
 
 
 
 
1815}
1816
 
 
 
 
 
 
 
 
 
1817static int
1818svcauth_gss_release(struct svc_rqst *rqstp)
1819{
1820	struct gss_svc_data *gsd = (struct gss_svc_data *)rqstp->rq_auth_data;
1821	struct rpc_gss_wire_cred *gc = &gsd->clcred;
1822	struct xdr_buf *resbuf = &rqstp->rq_res;
1823	int stat = -EINVAL;
1824	struct sunrpc_net *sn = net_generic(SVC_NET(rqstp), sunrpc_net_id);
 
 
 
1825
1826	if (gc->gc_proc != RPC_GSS_PROC_DATA)
1827		goto out;
1828	/* Release can be called twice, but we only wrap once. */
1829	if (gsd->verf_start == NULL)
1830		goto out;
1831	/* normally not set till svc_send, but we need it here: */
1832	/* XXX: what for?  Do we mess it up the moment we call svc_putu32
1833	 * or whatever? */
1834	resbuf->len = total_buf_len(resbuf);
1835	switch (gc->gc_svc) {
1836	case RPC_GSS_SVC_NONE:
1837		break;
1838	case RPC_GSS_SVC_INTEGRITY:
1839		stat = svcauth_gss_wrap_resp_integ(rqstp);
1840		if (stat)
1841			goto out_err;
1842		break;
1843	case RPC_GSS_SVC_PRIVACY:
1844		stat = svcauth_gss_wrap_resp_priv(rqstp);
1845		if (stat)
1846			goto out_err;
1847		break;
1848	/*
1849	 * For any other gc_svc value, svcauth_gss_accept() already set
1850	 * the auth_error appropriately; just fall through:
1851	 */
1852	}
1853
1854out:
1855	stat = 0;
1856out_err:
1857	if (rqstp->rq_client)
1858		auth_domain_put(rqstp->rq_client);
1859	rqstp->rq_client = NULL;
1860	if (rqstp->rq_gssclient)
1861		auth_domain_put(rqstp->rq_gssclient);
1862	rqstp->rq_gssclient = NULL;
1863	if (rqstp->rq_cred.cr_group_info)
1864		put_group_info(rqstp->rq_cred.cr_group_info);
1865	rqstp->rq_cred.cr_group_info = NULL;
1866	if (gsd->rsci)
1867		cache_put(&gsd->rsci->h, sn->rsc_cache);
1868	gsd->rsci = NULL;
1869
1870	return stat;
1871}
1872
1873static void
1874svcauth_gss_domain_release_rcu(struct rcu_head *head)
1875{
1876	struct auth_domain *dom = container_of(head, struct auth_domain, rcu_head);
1877	struct gss_domain *gd = container_of(dom, struct gss_domain, h);
1878
1879	kfree(dom->name);
1880	kfree(gd);
1881}
1882
1883static void
1884svcauth_gss_domain_release(struct auth_domain *dom)
1885{
1886	call_rcu(&dom->rcu_head, svcauth_gss_domain_release_rcu);
1887}
1888
 
 
 
 
 
1889static struct auth_ops svcauthops_gss = {
1890	.name		= "rpcsec_gss",
1891	.owner		= THIS_MODULE,
1892	.flavour	= RPC_AUTH_GSS,
1893	.accept		= svcauth_gss_accept,
1894	.release	= svcauth_gss_release,
1895	.domain_release = svcauth_gss_domain_release,
1896	.set_client	= svcauth_gss_set_client,
 
1897};
1898
1899static int rsi_cache_create_net(struct net *net)
1900{
1901	struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
1902	struct cache_detail *cd;
1903	int err;
1904
1905	cd = cache_create_net(&rsi_cache_template, net);
1906	if (IS_ERR(cd))
1907		return PTR_ERR(cd);
1908	err = cache_register_net(cd, net);
1909	if (err) {
1910		cache_destroy_net(cd, net);
1911		return err;
1912	}
1913	sn->rsi_cache = cd;
1914	return 0;
1915}
1916
1917static void rsi_cache_destroy_net(struct net *net)
1918{
1919	struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
1920	struct cache_detail *cd = sn->rsi_cache;
1921
1922	sn->rsi_cache = NULL;
1923	cache_purge(cd);
1924	cache_unregister_net(cd, net);
1925	cache_destroy_net(cd, net);
1926}
1927
1928static int rsc_cache_create_net(struct net *net)
1929{
1930	struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
1931	struct cache_detail *cd;
1932	int err;
1933
1934	cd = cache_create_net(&rsc_cache_template, net);
1935	if (IS_ERR(cd))
1936		return PTR_ERR(cd);
1937	err = cache_register_net(cd, net);
1938	if (err) {
1939		cache_destroy_net(cd, net);
1940		return err;
1941	}
1942	sn->rsc_cache = cd;
1943	return 0;
1944}
1945
1946static void rsc_cache_destroy_net(struct net *net)
1947{
1948	struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
1949	struct cache_detail *cd = sn->rsc_cache;
1950
1951	sn->rsc_cache = NULL;
1952	cache_purge(cd);
1953	cache_unregister_net(cd, net);
1954	cache_destroy_net(cd, net);
1955}
1956
1957int
1958gss_svc_init_net(struct net *net)
1959{
1960	int rv;
1961
1962	rv = rsc_cache_create_net(net);
1963	if (rv)
1964		return rv;
1965	rv = rsi_cache_create_net(net);
1966	if (rv)
1967		goto out1;
1968	rv = create_use_gss_proxy_proc_entry(net);
1969	if (rv)
1970		goto out2;
 
 
 
 
 
1971	return 0;
1972out2:
 
1973	destroy_use_gss_proxy_proc_entry(net);
 
 
1974out1:
1975	rsc_cache_destroy_net(net);
1976	return rv;
1977}
1978
1979void
1980gss_svc_shutdown_net(struct net *net)
1981{
 
1982	destroy_use_gss_proxy_proc_entry(net);
1983	rsi_cache_destroy_net(net);
1984	rsc_cache_destroy_net(net);
1985}
1986
1987int
1988gss_svc_init(void)
1989{
1990	return svc_auth_register(RPC_AUTH_GSS, &svcauthops_gss);
1991}
1992
1993void
1994gss_svc_shutdown(void)
1995{
1996	svc_auth_unregister(RPC_AUTH_GSS);
1997}