[deliverable/linux.git] / net / sunrpc / auth_gss / gss_rpc_xdr.c

/*
 * GSS Proxy upcall module
 *
 *  Copyright (C) 2012 Simo Sorce <simo@redhat.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include <linux/sunrpc/svcauth.h>
#include "gss_rpc_xdr.h"

static int gssx_enc_bool(struct xdr_stream *xdr, int v)
{
	__be32 *p;

	p = xdr_reserve_space(xdr, 4);
	if (unlikely(p == NULL))
		return -ENOSPC;
	*p = v ? xdr_one : xdr_zero;
	return 0;
}

static int gssx_dec_bool(struct xdr_stream *xdr, u32 *v)
{
	__be32 *p;

	p = xdr_inline_decode(xdr, 4);
	if (unlikely(p == NULL))
		return -ENOSPC;
	*v = be32_to_cpu(*p);
	return 0;
}

static int gssx_enc_buffer(struct xdr_stream *xdr,
			   gssx_buffer *buf)
{
	__be32 *p;

	p = xdr_reserve_space(xdr, sizeof(u32) + buf->len);
	if (!p)
		return -ENOSPC;
	xdr_encode_opaque(p, buf->data, buf->len);
	return 0;
}

static int gssx_enc_in_token(struct xdr_stream *xdr,
			     struct gssp_in_token *in)
{
	__be32 *p;

	p = xdr_reserve_space(xdr, 4);
	if (!p)
		return -ENOSPC;
	*p = cpu_to_be32(in->page_len);

	/* all we need to do is to write pages */
	xdr_write_pages(xdr, in->pages, in->page_base, in->page_len);

	return 0;
}


static int gssx_dec_buffer(struct xdr_stream *xdr,
			   gssx_buffer *buf)
{
	u32 length;
	__be32 *p;

	p = xdr_inline_decode(xdr, 4);
	if (unlikely(p == NULL))
		return -ENOSPC;

	length = be32_to_cpup(p);
	p = xdr_inline_decode(xdr, length);
	if (unlikely(p == NULL))
		return -ENOSPC;

	if (buf->len == 0) {
		/* we intentionally are not interested in this buffer */
		return 0;
	}
	if (length > buf->len)
		return -ENOSPC;

	if (!buf->data) {
		buf->data = kmemdup(p, length, GFP_KERNEL);
		if (!buf->data)
			return -ENOMEM;
	} else {
		memcpy(buf->data, p, length);
	}
	buf->len = length;
	return 0;
}

static int gssx_enc_option(struct xdr_stream *xdr,
			   struct gssx_option *opt)
{
	int err;

	err = gssx_enc_buffer(xdr, &opt->option);
	if (err)
		return err;
	err = gssx_enc_buffer(xdr, &opt->value);
	return err;
}

static int gssx_dec_option(struct xdr_stream *xdr,
			   struct gssx_option *opt)
{
	int err;

	err = gssx_dec_buffer(xdr, &opt->option);
	if (err)
		return err;
	err = gssx_dec_buffer(xdr, &opt->value);
	return err;
}

static int dummy_enc_opt_array(struct xdr_stream *xdr,
				struct gssx_option_array *oa)
{
	__be32 *p;

	if (oa->count != 0)
		return -EINVAL;

	p = xdr_reserve_space(xdr, 4);
	if (!p)
		return -ENOSPC;
	*p = 0;

	return 0;
}

static int dummy_dec_opt_array(struct xdr_stream *xdr,
				struct gssx_option_array *oa)
{
	struct gssx_option dummy;
	u32 count, i;
	__be32 *p;

	p = xdr_inline_decode(xdr, 4);
	if (unlikely(p == NULL))
		return -ENOSPC;
	count = be32_to_cpup(p++);
	memset(&dummy, 0, sizeof(dummy));
	for (i = 0; i < count; i++) {
		gssx_dec_option(xdr, &dummy);
	}

	oa->count = 0;
	oa->data = NULL;
	return 0;
}

static int get_host_u32(struct xdr_stream *xdr, u32 *res)
{
	__be32 *p;

	p = xdr_inline_decode(xdr, 4);
	if (!p)
		return -EINVAL;
	/* Contents of linux creds are all host-endian: */
	memcpy(res, p, sizeof(u32));
	return 0;
}

static int gssx_dec_linux_creds(struct xdr_stream *xdr,
				struct svc_cred *creds)
{
	u32 length;
	__be32 *p;
	u32 tmp;
	u32 N;
	int i, err;

	p = xdr_inline_decode(xdr, 4);
	if (unlikely(p == NULL))
		return -ENOSPC;

	length = be32_to_cpup(p);

	if (length > (3 + NGROUPS_MAX) * sizeof(u32))
		return -ENOSPC;

	/* uid */
	err = get_host_u32(xdr, &tmp);
	if (err)
		return err;
	creds->cr_uid = make_kuid(&init_user_ns, tmp);

	/* gid */
	err = get_host_u32(xdr, &tmp);
	if (err)
		return err;
	creds->cr_gid = make_kgid(&init_user_ns, tmp);

	/* number of additional gid's */
	err = get_host_u32(xdr, &tmp);
	if (err)
		return err;
	N = tmp;
	if ((3 + N) * sizeof(u32) != length)
		return -EINVAL;
	creds->cr_group_info = groups_alloc(N);
	if (creds->cr_group_info == NULL)
		return -ENOMEM;

	/* gid's */
	for (i = 0; i < N; i++) {
		kgid_t kgid;
		err = get_host_u32(xdr, &tmp);
		if (err)
			goto out_free_groups;
		err = -EINVAL;
		kgid = make_kgid(&init_user_ns, tmp);
		if (!gid_valid(kgid))
			goto out_free_groups;
		GROUP_AT(creds->cr_group_info, i) = kgid;
	}

	return 0;
out_free_groups:
	groups_free(creds->cr_group_info);
	return err;
}

static int gssx_dec_option_array(struct xdr_stream *xdr,
				 struct gssx_option_array *oa)
{
	struct svc_cred *creds;
	u32 count, i;
	__be32 *p;
	int err;

	p = xdr_inline_decode(xdr, 4);
	if (unlikely(p == NULL))
		return -ENOSPC;
	count = be32_to_cpup(p++);
	if (!count)
		return 0;

	/* we recognize only 1 currently: CREDS_VALUE */
	oa->count = 1;

	oa->data = kmalloc(sizeof(struct gssx_option), GFP_KERNEL);
	if (!oa->data)
		return -ENOMEM;

	creds = kmalloc(sizeof(struct svc_cred), GFP_KERNEL);
	if (!creds) {
		kfree(oa->data);
		return -ENOMEM;
	}

	oa->data[0].option.data = CREDS_VALUE;
	oa->data[0].option.len = sizeof(CREDS_VALUE);
	oa->data[0].value.data = (void *)creds;
	oa->data[0].value.len = 0;

	for (i = 0; i < count; i++) {
		gssx_buffer dummy = { 0, NULL };
		u32 length;

		/* option buffer */
		p = xdr_inline_decode(xdr, 4);
		if (unlikely(p == NULL))
			return -ENOSPC;

		length = be32_to_cpup(p);
		p = xdr_inline_decode(xdr, length);
		if (unlikely(p == NULL))
			return -ENOSPC;

		if (length == sizeof(CREDS_VALUE) &&
		    memcmp(p, CREDS_VALUE, sizeof(CREDS_VALUE)) == 0) {
			/* We have creds here. parse them */
			err = gssx_dec_linux_creds(xdr, creds);
			if (err)
				return err;
			oa->data[0].value.len = 1; /* presence */
		} else {
			/* consume uninteresting buffer */
			err = gssx_dec_buffer(xdr, &dummy);
			if (err)
				return err;
		}
	}
	return 0;
}

static int gssx_dec_status(struct xdr_stream *xdr,
			   struct gssx_status *status)
{
	__be32 *p;
	int err;

	/* status->major_status */
	p = xdr_inline_decode(xdr, 8);
	if (unlikely(p == NULL))
		return -ENOSPC;
	p = xdr_decode_hyper(p, &status->major_status);

	/* status->mech */
	err = gssx_dec_buffer(xdr, &status->mech);
	if (err)
		return err;

	/* status->minor_status */
	p = xdr_inline_decode(xdr, 8);
	if (unlikely(p == NULL))
		return -ENOSPC;
	p = xdr_decode_hyper(p, &status->minor_status);

	/* status->major_status_string */
	err = gssx_dec_buffer(xdr, &status->major_status_string);
	if (err)
		return err;

	/* status->minor_status_string */
	err = gssx_dec_buffer(xdr, &status->minor_status_string);
	if (err)
		return err;

	/* status->server_ctx */
	err = gssx_dec_buffer(xdr, &status->server_ctx);
	if (err)
		return err;

	/* we assume we have no options for now, so simply consume them */
	/* status->options */
	err = dummy_dec_opt_array(xdr, &status->options);

	return err;
}

static int gssx_enc_call_ctx(struct xdr_stream *xdr,
			     struct gssx_call_ctx *ctx)
{
	struct gssx_option opt;
	__be32 *p;
	int err;

	/* ctx->locale */
	err = gssx_enc_buffer(xdr, &ctx->locale);
	if (err)
		return err;

	/* ctx->server_ctx */
	err = gssx_enc_buffer(xdr, &ctx->server_ctx);
	if (err)
		return err;

	/* we always want to ask for lucid contexts */
	/* ctx->options */
	p = xdr_reserve_space(xdr, 4);
	*p = cpu_to_be32(2);

	/* we want a lucid_v1 context */
	opt.option.data = LUCID_OPTION;
	opt.option.len = sizeof(LUCID_OPTION);
	opt.value.data = LUCID_VALUE;
	opt.value.len = sizeof(LUCID_VALUE);
	err = gssx_enc_option(xdr, &opt);

	/* ..and user creds */
	opt.option.data = CREDS_OPTION;
	opt.option.len = sizeof(CREDS_OPTION);
	opt.value.data = CREDS_VALUE;
	opt.value.len = sizeof(CREDS_VALUE);
	err = gssx_enc_option(xdr, &opt);

	return err;
}

static int gssx_dec_name_attr(struct xdr_stream *xdr,
			     struct gssx_name_attr *attr)
{
	int err;

	/* attr->attr */
	err = gssx_dec_buffer(xdr, &attr->attr);
	if (err)
		return err;

	/* attr->value */
	err = gssx_dec_buffer(xdr, &attr->value);
	if (err)
		return err;

	/* attr->extensions */
	err = dummy_dec_opt_array(xdr, &attr->extensions);

	return err;
}

static int dummy_enc_nameattr_array(struct xdr_stream *xdr,
				    struct gssx_name_attr_array *naa)
{
	__be32 *p;

	if (naa->count != 0)
		return -EINVAL;

	p = xdr_reserve_space(xdr, 4);
	if (!p)
		return -ENOSPC;
	*p = 0;

	return 0;
}

static int dummy_dec_nameattr_array(struct xdr_stream *xdr,
				    struct gssx_name_attr_array *naa)
{
	struct gssx_name_attr dummy = { .attr = {.len = 0} };
	u32 count, i;
	__be32 *p;

	p = xdr_inline_decode(xdr, 4);
	if (unlikely(p == NULL))
		return -ENOSPC;
	count = be32_to_cpup(p++);
	for (i = 0; i < count; i++) {
		gssx_dec_name_attr(xdr, &dummy);
	}

	naa->count = 0;
	naa->data = NULL;
	return 0;
}

static struct xdr_netobj zero_netobj = {};

static struct gssx_name_attr_array zero_name_attr_array = {};

static struct gssx_option_array zero_option_array = {};

static int gssx_enc_name(struct xdr_stream *xdr,
			 struct gssx_name *name)
{
	int err;

	/* name->display_name */
	err = gssx_enc_buffer(xdr, &name->display_name);
	if (err)
		return err;

	/* name->name_type */
	err = gssx_enc_buffer(xdr, &zero_netobj);
	if (err)
		return err;

	/* name->exported_name */
	err = gssx_enc_buffer(xdr, &zero_netobj);
	if (err)
		return err;

	/* name->exported_composite_name */
	err = gssx_enc_buffer(xdr, &zero_netobj);
	if (err)
		return err;

	/* leave name_attributes empty for now, will add once we have any
	 * to pass up at all */
	/* name->name_attributes */
	err = dummy_enc_nameattr_array(xdr, &zero_name_attr_array);
	if (err)
		return err;

	/* leave options empty for now, will add once we have any options
	 * to pass up at all */
	/* name->extensions */
	err = dummy_enc_opt_array(xdr, &zero_option_array);

	return err;
}


static int gssx_dec_name(struct xdr_stream *xdr,
			 struct gssx_name *name)
{
	struct xdr_netobj dummy_netobj = { .len = 0 };
	struct gssx_name_attr_array dummy_name_attr_array = { .count = 0 };
	struct gssx_option_array dummy_option_array = { .count = 0 };
	int err;

	/* name->display_name */
	err = gssx_dec_buffer(xdr, &name->display_name);
	if (err)
		return err;

	/* name->name_type */
	err = gssx_dec_buffer(xdr, &dummy_netobj);
	if (err)
		return err;

	/* name->exported_name */
	err = gssx_dec_buffer(xdr, &dummy_netobj);
	if (err)
		return err;

	/* name->exported_composite_name */
	err = gssx_dec_buffer(xdr, &dummy_netobj);
	if (err)
		return err;

	/* we assume we have no attributes for now, so simply consume them */
	/* name->name_attributes */
	err = dummy_dec_nameattr_array(xdr, &dummy_name_attr_array);
	if (err)
		return err;

	/* we assume we have no options for now, so simply consume them */
	/* name->extensions */
	err = dummy_dec_opt_array(xdr, &dummy_option_array);

	return err;
}

static int dummy_enc_credel_array(struct xdr_stream *xdr,
				  struct gssx_cred_element_array *cea)
{
	__be32 *p;

	if (cea->count != 0)
		return -EINVAL;

	p = xdr_reserve_space(xdr, 4);
	if (!p)
		return -ENOSPC;
	*p = 0;

	return 0;
}

static int gssx_enc_cred(struct xdr_stream *xdr,
			 struct gssx_cred *cred)
{
	int err;

	/* cred->desired_name */
	err = gssx_enc_name(xdr, &cred->desired_name);
	if (err)
		return err;

	/* cred->elements */
	err = dummy_enc_credel_array(xdr, &cred->elements);
	if (err)
		return err;

	/* cred->cred_handle_reference */
	err = gssx_enc_buffer(xdr, &cred->cred_handle_reference);
	if (err)
		return err;

	/* cred->needs_release */
	err = gssx_enc_bool(xdr, cred->needs_release);

	return err;
}

static int gssx_enc_ctx(struct xdr_stream *xdr,
			struct gssx_ctx *ctx)
{
	__be32 *p;
	int err;

	/* ctx->exported_context_token */
	err = gssx_enc_buffer(xdr, &ctx->exported_context_token);
	if (err)
		return err;

	/* ctx->state */
	err = gssx_enc_buffer(xdr, &ctx->state);
	if (err)
		return err;

	/* ctx->need_release */
	err = gssx_enc_bool(xdr, ctx->need_release);
	if (err)
		return err;

	/* ctx->mech */
	err = gssx_enc_buffer(xdr, &ctx->mech);
	if (err)
		return err;

	/* ctx->src_name */
	err = gssx_enc_name(xdr, &ctx->src_name);
	if (err)
		return err;

	/* ctx->targ_name */
	err = gssx_enc_name(xdr, &ctx->targ_name);
	if (err)
		return err;

	/* ctx->lifetime */
	p = xdr_reserve_space(xdr, 8+8);
	if (!p)
		return -ENOSPC;
	p = xdr_encode_hyper(p, ctx->lifetime);

	/* ctx->ctx_flags */
	p = xdr_encode_hyper(p, ctx->ctx_flags);

	/* ctx->locally_initiated */
	err = gssx_enc_bool(xdr, ctx->locally_initiated);
	if (err)
		return err;

	/* ctx->open */
	err = gssx_enc_bool(xdr, ctx->open);
	if (err)
		return err;

	/* leave options empty for now, will add once we have any options
	 * to pass up at all */
	/* ctx->options */
	err = dummy_enc_opt_array(xdr, &ctx->options);

	return err;
}

static int gssx_dec_ctx(struct xdr_stream *xdr,
			struct gssx_ctx *ctx)
{
	__be32 *p;
	int err;

	/* ctx->exported_context_token */
	err = gssx_dec_buffer(xdr, &ctx->exported_context_token);
	if (err)
		return err;

	/* ctx->state */
	err = gssx_dec_buffer(xdr, &ctx->state);
	if (err)
		return err;

	/* ctx->need_release */
	err = gssx_dec_bool(xdr, &ctx->need_release);
	if (err)
		return err;

	/* ctx->mech */
	err = gssx_dec_buffer(xdr, &ctx->mech);
	if (err)
		return err;

	/* ctx->src_name */
	err = gssx_dec_name(xdr, &ctx->src_name);
	if (err)
		return err;

	/* ctx->targ_name */
	err = gssx_dec_name(xdr, &ctx->targ_name);
	if (err)
		return err;

	/* ctx->lifetime */
	p = xdr_inline_decode(xdr, 8+8);
	if (unlikely(p == NULL))
		return -ENOSPC;
	p = xdr_decode_hyper(p, &ctx->lifetime);

	/* ctx->ctx_flags */
	p = xdr_decode_hyper(p, &ctx->ctx_flags);

	/* ctx->locally_initiated */
	err = gssx_dec_bool(xdr, &ctx->locally_initiated);
	if (err)
		return err;

	/* ctx->open */
	err = gssx_dec_bool(xdr, &ctx->open);
	if (err)
		return err;

	/* we assume we have no options for now, so simply consume them */
	/* ctx->options */
	err = dummy_dec_opt_array(xdr, &ctx->options);

	return err;
}

static int gssx_enc_cb(struct xdr_stream *xdr, struct gssx_cb *cb)
{
	__be32 *p;
	int err;

	/* cb->initiator_addrtype */
	p = xdr_reserve_space(xdr, 8);
	if (!p)
		return -ENOSPC;
	p = xdr_encode_hyper(p, cb->initiator_addrtype);

	/* cb->initiator_address */
	err = gssx_enc_buffer(xdr, &cb->initiator_address);
	if (err)
		return err;

	/* cb->acceptor_addrtype */
	p = xdr_reserve_space(xdr, 8);
	if (!p)
		return -ENOSPC;
	p = xdr_encode_hyper(p, cb->acceptor_addrtype);

	/* cb->acceptor_address */
	err = gssx_enc_buffer(xdr, &cb->acceptor_address);
	if (err)
		return err;

	/* cb->application_data */
	err = gssx_enc_buffer(xdr, &cb->application_data);

	return err;
}

void gssx_enc_accept_sec_context(struct rpc_rqst *req,
				 struct xdr_stream *xdr,
				 struct gssx_arg_accept_sec_context *arg)
{
	int err;

	err = gssx_enc_call_ctx(xdr, &arg->call_ctx);
	if (err)
		goto done;

	/* arg->context_handle */
	if (arg->context_handle)
		err = gssx_enc_ctx(xdr, arg->context_handle);
	else
		err = gssx_enc_bool(xdr, 0);
	if (err)
		goto done;

	/* arg->cred_handle */
	if (arg->cred_handle)
		err = gssx_enc_cred(xdr, arg->cred_handle);
	else
		err = gssx_enc_bool(xdr, 0);
	if (err)
		goto done;

	/* arg->input_token */
	err = gssx_enc_in_token(xdr, &arg->input_token);
	if (err)
		goto done;

	/* arg->input_cb */
	if (arg->input_cb)
		err = gssx_enc_cb(xdr, arg->input_cb);
	else
		err = gssx_enc_bool(xdr, 0);
	if (err)
		goto done;

	err = gssx_enc_bool(xdr, arg->ret_deleg_cred);
	if (err)
		goto done;

	/* leave options empty for now, will add once we have any options
	 * to pass up at all */
	/* arg->options */
	err = dummy_enc_opt_array(xdr, &arg->options);

	xdr_inline_pages(&req->rq_rcv_buf,
		PAGE_SIZE/2 /* pretty arbitrary */,
		arg->pages, 0 /* page base */, arg->npages * PAGE_SIZE);
done:
	if (err)
		dprintk("RPC:       gssx_enc_accept_sec_context: %d\n", err);
}

int gssx_dec_accept_sec_context(struct rpc_rqst *rqstp,
				struct xdr_stream *xdr,
				struct gssx_res_accept_sec_context *res)
{
	u32 value_follows;
	int err;

	/* res->status */
	err = gssx_dec_status(xdr, &res->status);
	if (err)
		return err;

	/* res->context_handle */
	err = gssx_dec_bool(xdr, &value_follows);
	if (err)
		return err;
	if (value_follows) {
		err = gssx_dec_ctx(xdr, res->context_handle);
		if (err)
			return err;
	} else {
		res->context_handle = NULL;
	}

	/* res->output_token */
	err = gssx_dec_bool(xdr, &value_follows);
	if (err)
		return err;
	if (value_follows) {
		err = gssx_dec_buffer(xdr, res->output_token);
		if (err)
			return err;
	} else {
		res->output_token = NULL;
	}

	/* res->delegated_cred_handle */
	err = gssx_dec_bool(xdr, &value_follows);
	if (err)
		return err;
	if (value_follows) {
		/* we do not support upcall servers sending this data. */
		return -EINVAL;
	}

	/* res->options */
	err = gssx_dec_option_array(xdr, &res->options);

	return err;
}
Commit	Line	Data
1d658336 SS	1	/*
	2	* GSS Proxy upcall module
	3	*
	4	* Copyright (C) 2012 Simo Sorce <simo@redhat.com>
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; either version 2 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program; if not, write to the Free Software
	18	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	19	*/
	20
	21	#include <linux/sunrpc/svcauth.h>
	22	#include "gss_rpc_xdr.h"
	23
1d658336 SS	24	static int gssx_enc_bool(struct xdr_stream *xdr, int v)
	25	{
	26	__be32 *p;
	27
	28	p = xdr_reserve_space(xdr, 4);
	29	if (unlikely(p == NULL))
	30	return -ENOSPC;
	31	*p = v ? xdr_one : xdr_zero;
	32	return 0;
	33	}
	34
	35	static int gssx_dec_bool(struct xdr_stream xdr, u32 v)
	36	{
	37	__be32 *p;
	38
	39	p = xdr_inline_decode(xdr, 4);
	40	if (unlikely(p == NULL))
	41	return -ENOSPC;
	42	v = be32_to_cpu(p);
	43	return 0;
	44	}
	45
	46	static int gssx_enc_buffer(struct xdr_stream *xdr,
	47	gssx_buffer *buf)
	48	{
	49	__be32 *p;
	50
	51	p = xdr_reserve_space(xdr, sizeof(u32) + buf->len);
	52	if (!p)
	53	return -ENOSPC;
	54	xdr_encode_opaque(p, buf->data, buf->len);
	55	return 0;
	56	}
	57
	58	static int gssx_enc_in_token(struct xdr_stream *xdr,
	59	struct gssp_in_token *in)
	60	{
	61	__be32 *p;
	62
	63	p = xdr_reserve_space(xdr, 4);
	64	if (!p)
	65	return -ENOSPC;
	66	*p = cpu_to_be32(in->page_len);
	67
	68	/* all we need to do is to write pages */
	69	xdr_write_pages(xdr, in->pages, in->page_base, in->page_len);
	70
	71	return 0;
	72	}
	73
	74
	75	static int gssx_dec_buffer(struct xdr_stream *xdr,
	76	gssx_buffer *buf)
	77	{
	78	u32 length;
	79	__be32 *p;
	80
	81	p = xdr_inline_decode(xdr, 4);
	82	if (unlikely(p == NULL))
	83	return -ENOSPC;
	84
	85	length = be32_to_cpup(p);
	86	p = xdr_inline_decode(xdr, length);
	87	if (unlikely(p == NULL))
88	return -ENOSPC;
89
90	if (buf->len == 0) {
91	/* we intentionally are not interested in this buffer */
92	return 0;
93	}
94	if (length > buf->len)
95	return -ENOSPC;
96
97	if (!buf->data) {
98	buf->data = kmemdup(p, length, GFP_KERNEL);
99	if (!buf->data)
100	return -ENOMEM;
101	} else {
102	memcpy(buf->data, p, length);
103	}
104	buf->len = length;
105	return 0;
106	}
107
108	static int gssx_enc_option(struct xdr_stream *xdr,
109	struct gssx_option *opt)
110	{
111	int err;
112
113	err = gssx_enc_buffer(xdr, &opt->option);
114	if (err)
115	return err;
116	err = gssx_enc_buffer(xdr, &opt->value);
117	return err;
118	}
119
120	static int gssx_dec_option(struct xdr_stream *xdr,
121	struct gssx_option *opt)
122	{
123	int err;
124
125	err = gssx_dec_buffer(xdr, &opt->option);
126	if (err)
127	return err;
128	err = gssx_dec_buffer(xdr, &opt->value);
129	return err;
130	}
131
132	static int dummy_enc_opt_array(struct xdr_stream *xdr,
133	struct gssx_option_array *oa)
134	{
135	__be32 *p;
136
137	if (oa->count != 0)
138	return -EINVAL;
139
140	p = xdr_reserve_space(xdr, 4);
141	if (!p)
142	return -ENOSPC;
143	*p = 0;
144
145	return 0;
146	}
147
148	static int dummy_dec_opt_array(struct xdr_stream *xdr,
149	struct gssx_option_array *oa)
150	{
151	struct gssx_option dummy;
152	u32 count, i;
153	__be32 *p;
154
155	p = xdr_inline_decode(xdr, 4);
156	if (unlikely(p == NULL))
157	return -ENOSPC;
158	count = be32_to_cpup(p++);
159	memset(&dummy, 0, sizeof(dummy));
160	for (i = 0; i < count; i++) {
161	gssx_dec_option(xdr, &dummy);
162	}
163
164	oa->count = 0;
165	oa->data = NULL;
166	return 0;
167	}
168
6a36978e	169	static int get_host_u32(struct xdr_stream xdr, u32 res)
1d658336	170	{
778e512b BF	171	__be32 *p;
	172
	173	p = xdr_inline_decode(xdr, 4);
	174	if (!p)
1d658336	175	return -EINVAL;
6a36978e BF	176	/* Contents of linux creds are all host-endian: */
6a36978e BF	177	memcpy(res, p, sizeof(u32));
1d658336 SS	178	return 0;
	179	}
	180
	181	static int gssx_dec_linux_creds(struct xdr_stream *xdr,
	182	struct svc_cred *creds)
	183	{
	184	u32 length;
	185	__be32 *p;
6a36978e BF	186	u32 tmp;
	187	u32 N;
	188	int i, err;
1d658336 SS	189
	190	p = xdr_inline_decode(xdr, 4);
	191	if (unlikely(p == NULL))
	192	return -ENOSPC;
	193
	194	length = be32_to_cpup(p);
	195
778e512b	196	if (length > (3 + NGROUPS_MAX) * sizeof(u32))
1d658336 SS	197	return -ENOSPC;
1d658336 SS	198
1d658336	199	/* uid */
6a36978e	200	err = get_host_u32(xdr, &tmp);
1d658336 SS	201	if (err)
1d658336 SS	202	return err;
d28fcc83	203	creds->cr_uid = make_kuid(&init_user_ns, tmp);
1d658336 SS	204
1d658336 SS	205	/* gid */
6a36978e	206	err = get_host_u32(xdr, &tmp);
1d658336 SS	207	if (err)
1d658336 SS	208	return err;
d28fcc83	209	creds->cr_gid = make_kgid(&init_user_ns, tmp);
1d658336 SS	210
1d658336 SS	211	/* number of additional gid's */
6a36978e	212	err = get_host_u32(xdr, &tmp);
1d658336 SS	213	if (err)
	214	return err;
	215	N = tmp;
778e512b BF	216	if ((3 + N) * sizeof(u32) != length)
778e512b BF	217	return -EINVAL;
1d658336 SS	218	creds->cr_group_info = groups_alloc(N);
	219	if (creds->cr_group_info == NULL)
	220	return -ENOMEM;
	221
	222	/* gid's */
	223	for (i = 0; i < N; i++) {
d28fcc83	224	kgid_t kgid;
6a36978e	225	err = get_host_u32(xdr, &tmp);
d28fcc83 BF	226	if (err)
	227	goto out_free_groups;
	228	err = -EINVAL;
	229	kgid = make_kgid(&init_user_ns, tmp);
	230	if (!gid_valid(kgid))
	231	goto out_free_groups;
	232	GROUP_AT(creds->cr_group_info, i) = kgid;
1d658336 SS	233	}
	234
	235	return 0;
d28fcc83 BF	236	out_free_groups:
	237	groups_free(creds->cr_group_info);
	238	return err;
1d658336 SS	239	}
	240
	241	static int gssx_dec_option_array(struct xdr_stream *xdr,
	242	struct gssx_option_array *oa)
	243	{
	244	struct svc_cred *creds;
	245	u32 count, i;
	246	__be32 *p;
	247	int err;
	248
	249	p = xdr_inline_decode(xdr, 4);
	250	if (unlikely(p == NULL))
	251	return -ENOSPC;
	252	count = be32_to_cpup(p++);
9fd40c5a GU	253	if (!count)
9fd40c5a GU	254	return 0;
1d658336	255
9fd40c5a GU	256	/* we recognize only 1 currently: CREDS_VALUE */
9fd40c5a GU	257	oa->count = 1;
1d658336	258
9fd40c5a GU	259	oa->data = kmalloc(sizeof(struct gssx_option), GFP_KERNEL);
	260	if (!oa->data)
	261	return -ENOMEM;
1d658336	262
9fd40c5a GU	263	creds = kmalloc(sizeof(struct svc_cred), GFP_KERNEL);
	264	if (!creds) {
	265	kfree(oa->data);
	266	return -ENOMEM;
1d658336	267	}
9fd40c5a GU	268
	269	oa->data[0].option.data = CREDS_VALUE;
	270	oa->data[0].option.len = sizeof(CREDS_VALUE);
	271	oa->data[0].value.data = (void *)creds;
	272	oa->data[0].value.len = 0;
	273
1d658336 SS	274	for (i = 0; i < count; i++) {
	275	gssx_buffer dummy = { 0, NULL };
	276	u32 length;
	277
	278	/* option buffer */
	279	p = xdr_inline_decode(xdr, 4);
	280	if (unlikely(p == NULL))
	281	return -ENOSPC;
	282
	283	length = be32_to_cpup(p);
	284	p = xdr_inline_decode(xdr, length);
	285	if (unlikely(p == NULL))
	286	return -ENOSPC;
	287
	288	if (length == sizeof(CREDS_VALUE) &&
	289	memcmp(p, CREDS_VALUE, sizeof(CREDS_VALUE)) == 0) {
	290	/* We have creds here. parse them */
	291	err = gssx_dec_linux_creds(xdr, creds);
	292	if (err)
	293	return err;
	294	oa->data[0].value.len = 1; /* presence */
	295	} else {
	296	/* consume uninteresting buffer */
	297	err = gssx_dec_buffer(xdr, &dummy);
	298	if (err)
	299	return err;
	300	}
	301	}
	302	return 0;
	303	}
	304
	305	static int gssx_dec_status(struct xdr_stream *xdr,
	306	struct gssx_status *status)
	307	{
	308	__be32 *p;
	309	int err;
	310
	311	/* status->major_status */
	312	p = xdr_inline_decode(xdr, 8);
	313	if (unlikely(p == NULL))
	314	return -ENOSPC;
	315	p = xdr_decode_hyper(p, &status->major_status);
	316
	317	/* status->mech */
	318	err = gssx_dec_buffer(xdr, &status->mech);
	319	if (err)
	320	return err;
	321
	322	/* status->minor_status */
	323	p = xdr_inline_decode(xdr, 8);
	324	if (unlikely(p == NULL))
	325	return -ENOSPC;
	326	p = xdr_decode_hyper(p, &status->minor_status);
	327
	328	/* status->major_status_string */
	329	err = gssx_dec_buffer(xdr, &status->major_status_string);
	330	if (err)
	331	return err;
	332
	333	/* status->minor_status_string */
	334	err = gssx_dec_buffer(xdr, &status->minor_status_string);
	335	if (err)
	336	return err;
	337
338	/* status->server_ctx */
339	err = gssx_dec_buffer(xdr, &status->server_ctx);
340	if (err)
341	return err;
342
343	/* we assume we have no options for now, so simply consume them */
344	/* status->options */
345	err = dummy_dec_opt_array(xdr, &status->options);
346
347	return err;
348	}
349
350	static int gssx_enc_call_ctx(struct xdr_stream *xdr,
351	struct gssx_call_ctx *ctx)
352	{
353	struct gssx_option opt;
354	__be32 *p;
355	int err;
356
357	/* ctx->locale */
358	err = gssx_enc_buffer(xdr, &ctx->locale);
359	if (err)
360	return err;
361
362	/* ctx->server_ctx */
363	err = gssx_enc_buffer(xdr, &ctx->server_ctx);
364	if (err)
365	return err;
366
367	/* we always want to ask for lucid contexts */
368	/* ctx->options */
369	p = xdr_reserve_space(xdr, 4);
370	*p = cpu_to_be32(2);
371
372	/* we want a lucid_v1 context */
373	opt.option.data = LUCID_OPTION;
374	opt.option.len = sizeof(LUCID_OPTION);
375	opt.value.data = LUCID_VALUE;
376	opt.value.len = sizeof(LUCID_VALUE);
377	err = gssx_enc_option(xdr, &opt);
378
379	/* ..and user creds */
380	opt.option.data = CREDS_OPTION;
381	opt.option.len = sizeof(CREDS_OPTION);
382	opt.value.data = CREDS_VALUE;
383	opt.value.len = sizeof(CREDS_VALUE);
384	err = gssx_enc_option(xdr, &opt);
385
386	return err;
387	}
388
389	static int gssx_dec_name_attr(struct xdr_stream *xdr,
390	struct gssx_name_attr *attr)
391	{
392	int err;
393
394	/* attr->attr */
395	err = gssx_dec_buffer(xdr, &attr->attr);
396	if (err)
397	return err;
398
399	/* attr->value */
400	err = gssx_dec_buffer(xdr, &attr->value);
401	if (err)
402	return err;
403
404	/* attr->extensions */
405	err = dummy_dec_opt_array(xdr, &attr->extensions);
406
407	return err;
408	}
409
410	static int dummy_enc_nameattr_array(struct xdr_stream *xdr,
411	struct gssx_name_attr_array *naa)
412	{
413	__be32 *p;
414
415	if (naa->count != 0)
416	return -EINVAL;
417
418	p = xdr_reserve_space(xdr, 4);
419	if (!p)
420	return -ENOSPC;
421	*p = 0;
422
423	return 0;
424	}
425
426	static int dummy_dec_nameattr_array(struct xdr_stream *xdr,
427	struct gssx_name_attr_array *naa)
428	{
dc43376c	429	struct gssx_name_attr dummy = { .attr = {.len = 0} };
1d658336 SS	430	u32 count, i;
	431	__be32 *p;
	432
	433	p = xdr_inline_decode(xdr, 4);
	434	if (unlikely(p == NULL))
	435	return -ENOSPC;
	436	count = be32_to_cpup(p++);
	437	for (i = 0; i < count; i++) {
	438	gssx_dec_name_attr(xdr, &dummy);
	439	}
	440
	441	naa->count = 0;
	442	naa->data = NULL;
	443	return 0;
	444	}
	445
	446	static struct xdr_netobj zero_netobj = {};
	447
	448	static struct gssx_name_attr_array zero_name_attr_array = {};
	449
	450	static struct gssx_option_array zero_option_array = {};
	451
	452	static int gssx_enc_name(struct xdr_stream *xdr,
	453	struct gssx_name *name)
	454	{
	455	int err;
	456
	457	/* name->display_name */
	458	err = gssx_enc_buffer(xdr, &name->display_name);
	459	if (err)
	460	return err;
	461
	462	/* name->name_type */
	463	err = gssx_enc_buffer(xdr, &zero_netobj);
	464	if (err)
	465	return err;
	466
	467	/* name->exported_name */
	468	err = gssx_enc_buffer(xdr, &zero_netobj);
	469	if (err)
	470	return err;
	471
	472	/* name->exported_composite_name */
	473	err = gssx_enc_buffer(xdr, &zero_netobj);
	474	if (err)
	475	return err;
	476
	477	/* leave name_attributes empty for now, will add once we have any
	478	* to pass up at all */
	479	/* name->name_attributes */
	480	err = dummy_enc_nameattr_array(xdr, &zero_name_attr_array);
	481	if (err)
	482	return err;
	483
	484	/* leave options empty for now, will add once we have any options
	485	* to pass up at all */
	486	/* name->extensions */
	487	err = dummy_enc_opt_array(xdr, &zero_option_array);
	488
	489	return err;
	490	}
	491
dc43376c	492
1d658336 SS	493	static int gssx_dec_name(struct xdr_stream *xdr,
	494	struct gssx_name *name)
	495	{
dc43376c BF	496	struct xdr_netobj dummy_netobj = { .len = 0 };
	497	struct gssx_name_attr_array dummy_name_attr_array = { .count = 0 };
	498	struct gssx_option_array dummy_option_array = { .count = 0 };
1d658336 SS	499	int err;
	500
	501	/* name->display_name */
	502	err = gssx_dec_buffer(xdr, &name->display_name);
	503	if (err)
	504	return err;
	505
	506	/* name->name_type */
	507	err = gssx_dec_buffer(xdr, &dummy_netobj);
	508	if (err)
	509	return err;
	510
	511	/* name->exported_name */
	512	err = gssx_dec_buffer(xdr, &dummy_netobj);
	513	if (err)
	514	return err;
	515
	516	/* name->exported_composite_name */
	517	err = gssx_dec_buffer(xdr, &dummy_netobj);
	518	if (err)
	519	return err;
	520
	521	/* we assume we have no attributes for now, so simply consume them */
	522	/* name->name_attributes */
	523	err = dummy_dec_nameattr_array(xdr, &dummy_name_attr_array);
	524	if (err)
	525	return err;
	526
	527	/* we assume we have no options for now, so simply consume them */
	528	/* name->extensions */
	529	err = dummy_dec_opt_array(xdr, &dummy_option_array);
	530
	531	return err;
	532	}
	533
	534	static int dummy_enc_credel_array(struct xdr_stream *xdr,
	535	struct gssx_cred_element_array *cea)
	536	{
	537	__be32 *p;
	538
	539	if (cea->count != 0)
	540	return -EINVAL;
	541
	542	p = xdr_reserve_space(xdr, 4);
	543	if (!p)
	544	return -ENOSPC;
	545	*p = 0;
	546
	547	return 0;
	548	}
	549
	550	static int gssx_enc_cred(struct xdr_stream *xdr,
	551	struct gssx_cred *cred)
	552	{
	553	int err;
	554
	555	/* cred->desired_name */
	556	err = gssx_enc_name(xdr, &cred->desired_name);
	557	if (err)
	558	return err;
	559
	560	/* cred->elements */
	561	err = dummy_enc_credel_array(xdr, &cred->elements);
b26ec9b1 BF	562	if (err)
b26ec9b1 BF	563	return err;
1d658336 SS	564
	565	/* cred->cred_handle_reference */
	566	err = gssx_enc_buffer(xdr, &cred->cred_handle_reference);
	567	if (err)
	568	return err;
	569
	570	/* cred->needs_release */
	571	err = gssx_enc_bool(xdr, cred->needs_release);
	572
	573	return err;
	574	}
	575
	576	static int gssx_enc_ctx(struct xdr_stream *xdr,
	577	struct gssx_ctx *ctx)
	578	{
	579	__be32 *p;
	580	int err;
	581
	582	/* ctx->exported_context_token */
	583	err = gssx_enc_buffer(xdr, &ctx->exported_context_token);
	584	if (err)
	585	return err;
	586
	587	/* ctx->state */
	588	err = gssx_enc_buffer(xdr, &ctx->state);
	589	if (err)
	590	return err;
	591
	592	/* ctx->need_release */
	593	err = gssx_enc_bool(xdr, ctx->need_release);
	594	if (err)
	595	return err;
	596
	597	/* ctx->mech */
	598	err = gssx_enc_buffer(xdr, &ctx->mech);
	599	if (err)
	600	return err;
	601
	602	/* ctx->src_name */
	603	err = gssx_enc_name(xdr, &ctx->src_name);
	604	if (err)
	605	return err;
	606
	607	/* ctx->targ_name */
	608	err = gssx_enc_name(xdr, &ctx->targ_name);
	609	if (err)
	610	return err;
	611
	612	/* ctx->lifetime */
	613	p = xdr_reserve_space(xdr, 8+8);
	614	if (!p)
	615	return -ENOSPC;
	616	p = xdr_encode_hyper(p, ctx->lifetime);
	617
	618	/* ctx->ctx_flags */
	619	p = xdr_encode_hyper(p, ctx->ctx_flags);
	620
	621	/* ctx->locally_initiated */
	622	err = gssx_enc_bool(xdr, ctx->locally_initiated);
	623	if (err)
	624	return err;
	625
	626	/* ctx->open */
	627	err = gssx_enc_bool(xdr, ctx->open);
628	if (err)
629	return err;
630
631	/* leave options empty for now, will add once we have any options
632	* to pass up at all */
633	/* ctx->options */
634	err = dummy_enc_opt_array(xdr, &ctx->options);
635
636	return err;
637	}
638
639	static int gssx_dec_ctx(struct xdr_stream *xdr,
640	struct gssx_ctx *ctx)
641	{
642	__be32 *p;
643	int err;
644
645	/* ctx->exported_context_token */
646	err = gssx_dec_buffer(xdr, &ctx->exported_context_token);
647	if (err)
648	return err;
649
650	/* ctx->state */
651	err = gssx_dec_buffer(xdr, &ctx->state);
652	if (err)
653	return err;
654
655	/* ctx->need_release */
656	err = gssx_dec_bool(xdr, &ctx->need_release);
657	if (err)
658	return err;
659
660	/* ctx->mech */
661	err = gssx_dec_buffer(xdr, &ctx->mech);
662	if (err)
663	return err;
664
665	/* ctx->src_name */
666	err = gssx_dec_name(xdr, &ctx->src_name);
667	if (err)
668	return err;
669
670	/* ctx->targ_name */
671	err = gssx_dec_name(xdr, &ctx->targ_name);
672	if (err)
673	return err;
674
675	/* ctx->lifetime */
676	p = xdr_inline_decode(xdr, 8+8);
677	if (unlikely(p == NULL))
678	return -ENOSPC;
679	p = xdr_decode_hyper(p, &ctx->lifetime);
680
681	/* ctx->ctx_flags */
682	p = xdr_decode_hyper(p, &ctx->ctx_flags);
683
684	/* ctx->locally_initiated */
685	err = gssx_dec_bool(xdr, &ctx->locally_initiated);
686	if (err)
687	return err;
688
689	/* ctx->open */
690	err = gssx_dec_bool(xdr, &ctx->open);
691	if (err)
692	return err;
693
694	/* we assume we have no options for now, so simply consume them */
695	/* ctx->options */
696	err = dummy_dec_opt_array(xdr, &ctx->options);
697
698	return err;
699	}
700
701	static int gssx_enc_cb(struct xdr_stream xdr, struct gssx_cb cb)
702	{
703	__be32 *p;
704	int err;
705
706	/* cb->initiator_addrtype */
707	p = xdr_reserve_space(xdr, 8);
708	if (!p)
709	return -ENOSPC;
710	p = xdr_encode_hyper(p, cb->initiator_addrtype);
711
712	/* cb->initiator_address */
713	err = gssx_enc_buffer(xdr, &cb->initiator_address);
714	if (err)
715	return err;
716
717	/* cb->acceptor_addrtype */
718	p = xdr_reserve_space(xdr, 8);
719	if (!p)
720	return -ENOSPC;
721	p = xdr_encode_hyper(p, cb->acceptor_addrtype);
722
723	/* cb->acceptor_address */
724	err = gssx_enc_buffer(xdr, &cb->acceptor_address);
725	if (err)
726	return err;
727
728	/* cb->application_data */
729	err = gssx_enc_buffer(xdr, &cb->application_data);
730
731	return err;
732	}
733
734	void gssx_enc_accept_sec_context(struct rpc_rqst *req,
735	struct xdr_stream *xdr,
736	struct gssx_arg_accept_sec_context *arg)
737	{
738	int err;
739
740	err = gssx_enc_call_ctx(xdr, &arg->call_ctx);
741	if (err)
742	goto done;
743
744	/* arg->context_handle */
b26ec9b1	745	if (arg->context_handle)
1d658336	746	err = gssx_enc_ctx(xdr, arg->context_handle);
b26ec9b1	747	else
1d658336	748	err = gssx_enc_bool(xdr, 0);
b26ec9b1 BF	749	if (err)
b26ec9b1 BF	750	goto done;
1d658336 SS	751
1d658336 SS	752	/* arg->cred_handle */
b26ec9b1	753	if (arg->cred_handle)
1d658336	754	err = gssx_enc_cred(xdr, arg->cred_handle);
b26ec9b1	755	else
1d658336	756	err = gssx_enc_bool(xdr, 0);
b26ec9b1 BF	757	if (err)
b26ec9b1 BF	758	goto done;
1d658336 SS	759
	760	/* arg->input_token */
	761	err = gssx_enc_in_token(xdr, &arg->input_token);
	762	if (err)
	763	goto done;
	764
	765	/* arg->input_cb */
b26ec9b1	766	if (arg->input_cb)
1d658336	767	err = gssx_enc_cb(xdr, arg->input_cb);
b26ec9b1	768	else
1d658336	769	err = gssx_enc_bool(xdr, 0);
b26ec9b1 BF	770	if (err)
b26ec9b1 BF	771	goto done;
1d658336 SS	772
	773	err = gssx_enc_bool(xdr, arg->ret_deleg_cred);
	774	if (err)
	775	goto done;
	776
	777	/* leave options empty for now, will add once we have any options
	778	* to pass up at all */
	779	/* arg->options */
	780	err = dummy_enc_opt_array(xdr, &arg->options);
	781
9dfd87da BF	782	xdr_inline_pages(&req->rq_rcv_buf,
	783	PAGE_SIZE/2 /* pretty arbitrary */,
	784	arg->pages, 0 /* page base /, arg->npages PAGE_SIZE);
1d658336 SS	785	done:
	786	if (err)
	787	dprintk("RPC: gssx_enc_accept_sec_context: %d\n", err);
	788	}
	789
	790	int gssx_dec_accept_sec_context(struct rpc_rqst *rqstp,
	791	struct xdr_stream *xdr,
	792	struct gssx_res_accept_sec_context *res)
	793	{
fb43f11c	794	u32 value_follows;
1d658336 SS	795	int err;
	796
	797	/* res->status */
	798	err = gssx_dec_status(xdr, &res->status);
	799	if (err)
	800	return err;
	801
	802	/* res->context_handle */
fb43f11c BF	803	err = gssx_dec_bool(xdr, &value_follows);
	804	if (err)
	805	return err;
	806	if (value_follows) {
1d658336 SS	807	err = gssx_dec_ctx(xdr, res->context_handle);
	808	if (err)
	809	return err;
	810	} else {
	811	res->context_handle = NULL;
	812	}
	813
	814	/* res->output_token */
fb43f11c BF	815	err = gssx_dec_bool(xdr, &value_follows);
	816	if (err)
	817	return err;
	818	if (value_follows) {
1d658336 SS	819	err = gssx_dec_buffer(xdr, res->output_token);
	820	if (err)
	821	return err;
	822	} else {
	823	res->output_token = NULL;
	824	}
	825
	826	/* res->delegated_cred_handle */
fb43f11c BF	827	err = gssx_dec_bool(xdr, &value_follows);
	828	if (err)
	829	return err;
	830	if (value_follows) {
1d658336 SS	831	/* we do not support upcall servers sending this data. */
	832	return -EINVAL;
	833	}
	834
	835	/* res->options */
	836	err = gssx_dec_option_array(xdr, &res->options);
	837
	838	return err;
	839	}