// SPDX-License-Identifier: GPL-2.0-or-later
/* RxRPC key management
 *
 * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
 * Written by David Howells (dhowells@redhat.com)
 *
 * RxRPC keys should have a description of describing their purpose:
 * "afs@example.com"
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <crypto/skcipher.h>
#include <linux/module.h>
#include <linux/net.h>
#include <linux/skbuff.h>
#include <linux/key-type.h>
#include <linux/ctype.h>
#include <linux/slab.h>
#include <net/sock.h>
#include <net/af_rxrpc.h>
#include <keys/rxrpc-type.h>
#include <keys/user-type.h>
#include "ar-internal.h"

static int rxrpc_preparse(struct key_preparsed_payload *);
static void rxrpc_free_preparse(struct key_preparsed_payload *);
static void rxrpc_destroy(struct key *);
static void rxrpc_describe(const struct key *, struct seq_file *);
static long rxrpc_read(const struct key *, char *, size_t);

/*
 * rxrpc defined keys take an arbitrary string as the description and an
 * arbitrary blob of data as the payload
 */
struct key_type key_type_rxrpc = {
 .name  = "rxrpc",
 .flags  = KEY_TYPE_NET_DOMAIN,
 .preparse = rxrpc_preparse,
 .free_preparse = rxrpc_free_preparse,
 .instantiate = generic_key_instantiate,
 .destroy = rxrpc_destroy,
 .describe = rxrpc_describe,
 .read  = rxrpc_read,
};
EXPORT_SYMBOL(key_type_rxrpc);

/*
 * parse an RxKAD type XDR format token
 * - the caller guarantees we have at least 4 words
 */
static int rxrpc_preparse_xdr_rxkad(struct key_preparsed_payload *prep,
        size_t datalen,
        const __be32 *xdr, unsigned int toklen)
{
 struct rxrpc_key_token *token, **pptoken;
 time64_t expiry;
 size_t plen;
 u32 tktlen;

 _enter(",{%x,%x,%x,%x},%u",
        ntohl(xdr[0]), ntohl(xdr[1]), ntohl(xdr[2]), ntohl(xdr[3]),
        toklen);

 if (toklen <= 8 * 4)
  return -EKEYREJECTED;
 tktlen = ntohl(xdr[7]);
 _debug("tktlen: %x", tktlen);
 if (tktlen > AFSTOKEN_RK_TIX_MAX)
  return -EKEYREJECTED;
 if (toklen < 8 * 4 + tktlen)
  return -EKEYREJECTED;

 plen = sizeof(*token) + sizeof(*token->kad) + tktlen;
 prep->quotalen = datalen + plen;

 plen -= sizeof(*token);
 token = kzalloc(sizeof(*token), GFP_KERNEL);
 if (!token)
  return -ENOMEM;

 token->kad = kzalloc(plen, GFP_KERNEL);
 if (!token->kad) {
  kfree(token);
  return -ENOMEM;
 }

 token->security_index = RXRPC_SECURITY_RXKAD;
 token->kad->ticket_len = tktlen;
 token->kad->vice_id = ntohl(xdr[0]);
 token->kad->kvno = ntohl(xdr[1]);
 token->kad->start = ntohl(xdr[4]);
 token->kad->expiry = ntohl(xdr[5]);
 token->kad->primary_flag = ntohl(xdr[6]);
 memcpy(&token->kad->session_key, &xdr[2], 8);
 memcpy(&token->kad->ticket, &xdr[8], tktlen);

 _debug("SCIX: %u", token->security_index);
 _debug("TLEN: %u", token->kad->ticket_len);
 _debug("EXPY: %x", token->kad->expiry);
 _debug("KVNO: %u", token->kad->kvno);
 _debug("PRIM: %u", token->kad->primary_flag);
 _debug("SKEY: %02x%02x%02x%02x%02x%02x%02x%02x",
        token->kad->session_key[0], token->kad->session_key[1],
        token->kad->session_key[2], token->kad->session_key[3],
        token->kad->session_key[4], token->kad->session_key[5],
        token->kad->session_key[6], token->kad->session_key[7]);
 if (token->kad->ticket_len >= 8)
  _debug("TCKT: %02x%02x%02x%02x%02x%02x%02x%02x",
         token->kad->ticket[0], token->kad->ticket[1],
         token->kad->ticket[2], token->kad->ticket[3],
         token->kad->ticket[4], token->kad->ticket[5],
         token->kad->ticket[6], token->kad->ticket[7]);

 /* count the number of tokens attached */
 prep->payload.data[1] = (void *)((unsigned long)prep->payload.data[1] + 1);

 /* attach the data */
 for (pptoken = (struct rxrpc_key_token **)&prep->payload.data[0];
      *pptoken;
      pptoken = &(*pptoken)->next)
  continue;
 *pptoken = token;
 expiry = rxrpc_u32_to_time64(token->kad->expiry);
 if (expiry < prep->expiry)
  prep->expiry = expiry;

 _leave(" = 0");
 return 0;
}

static u64 xdr_dec64(const __be32 *xdr)
{
 return (u64)ntohl(xdr[0]) << 32 | (u64)ntohl(xdr[1]);
}

static time64_t rxrpc_s64_to_time64(s64 time_in_100ns)
{
 bool neg = false;
 u64 tmp = time_in_100ns;

 if (time_in_100ns < 0) {
  tmp = -time_in_100ns;
  neg = true;
 }
 do_div(tmp, 10000000);
 return neg ? -tmp : tmp;
}

/*
 * Parse a YFS-RxGK type XDR format token
 * - the caller guarantees we have at least 4 words
 *
 * struct token_rxgk {
 * opr_time begintime;
 * opr_time endtime;
 * afs_int64 level;
 * afs_int64 lifetime;
 * afs_int64 bytelife;
 * afs_int64 enctype;
 * opaque key<>;
 * opaque ticket<>;
 * };
 */
static int rxrpc_preparse_xdr_yfs_rxgk(struct key_preparsed_payload *prep,
           size_t datalen,
           const __be32 *xdr, unsigned int toklen)
{
 struct rxrpc_key_token *token, **pptoken;
 time64_t expiry;
 size_t plen;
 const __be32 *ticket, *key;
 s64 tmp;
 u32 tktlen, keylen;

 _enter(",{%x,%x,%x,%x},%x",
        ntohl(xdr[0]), ntohl(xdr[1]), ntohl(xdr[2]), ntohl(xdr[3]),
        toklen);

 if (6 * 2 + 2 > toklen / 4)
  goto reject;

 key = xdr + (6 * 2 + 1);
 keylen = ntohl(key[-1]);
 _debug("keylen: %x", keylen);
 keylen = round_up(keylen, 4);
 if ((6 * 2 + 2) * 4 + keylen > toklen)
  goto reject;

 ticket = xdr + (6 * 2 + 1 + (keylen / 4) + 1);
 tktlen = ntohl(ticket[-1]);
 _debug("tktlen: %x", tktlen);
 tktlen = round_up(tktlen, 4);
 if ((6 * 2 + 2) * 4 + keylen + tktlen != toklen) {
  kleave(" = -EKEYREJECTED [%x!=%x, %x,%x]",
         (6 * 2 + 2) * 4 + keylen + tktlen, toklen,
         keylen, tktlen);
  goto reject;
 }

 plen = sizeof(*token) + sizeof(*token->rxgk) + tktlen + keylen;
 prep->quotalen = datalen + plen;

 plen -= sizeof(*token);
 token = kzalloc(sizeof(*token), GFP_KERNEL);
 if (!token)
  goto nomem;

 token->rxgk = kzalloc(sizeof(*token->rxgk) + keylen, GFP_KERNEL);
 if (!token->rxgk)
  goto nomem_token;

 token->security_index = RXRPC_SECURITY_YFS_RXGK;
 token->rxgk->begintime = xdr_dec64(xdr + 0 * 2);
 token->rxgk->endtime = xdr_dec64(xdr + 1 * 2);
 token->rxgk->level = tmp = xdr_dec64(xdr + 2 * 2);
 if (tmp < -1LL || tmp > RXRPC_SECURITY_ENCRYPT)
  goto reject_token;
 token->rxgk->lifetime = xdr_dec64(xdr + 3 * 2);
 token->rxgk->bytelife = xdr_dec64(xdr + 4 * 2);
 token->rxgk->enctype = tmp = xdr_dec64(xdr + 5 * 2);
 if (tmp < 0 || tmp > UINT_MAX)
  goto reject_token;
 token->rxgk->key.len = ntohl(key[-1]);
 token->rxgk->key.data = token->rxgk->_key;
 token->rxgk->ticket.len = ntohl(ticket[-1]);

 if (token->rxgk->endtime != 0) {
  expiry = rxrpc_s64_to_time64(token->rxgk->endtime);
  if (expiry < 0)
   goto expired;
  if (expiry < prep->expiry)
   prep->expiry = expiry;
 }

 memcpy(token->rxgk->key.data, key, token->rxgk->key.len);

 /* Pad the ticket so that we can use it directly in XDR */
 token->rxgk->ticket.data = kzalloc(round_up(token->rxgk->ticket.len, 4),
        GFP_KERNEL);
 if (!token->rxgk->ticket.data)
  goto nomem_yrxgk;
 memcpy(token->rxgk->ticket.data, ticket, token->rxgk->ticket.len);

 _debug("SCIX: %u", token->security_index);
 _debug("EXPY: %llx", token->rxgk->endtime);
 _debug("LIFE: %llx", token->rxgk->lifetime);
 _debug("BYTE: %llx", token->rxgk->bytelife);
 _debug("ENC : %u", token->rxgk->enctype);
 _debug("LEVL: %u", token->rxgk->level);
 _debug("KLEN: %u", token->rxgk->key.len);
 _debug("TLEN: %u", token->rxgk->ticket.len);
 _debug("KEY0: %*phN", token->rxgk->key.len, token->rxgk->key.data);
 _debug("TICK: %*phN",
        min_t(u32, token->rxgk->ticket.len, 32), token->rxgk->ticket.data);

 /* count the number of tokens attached */
 prep->payload.data[1] = (void *)((unsigned long)prep->payload.data[1] + 1);

 /* attach the data */
 for (pptoken = (struct rxrpc_key_token **)&prep->payload.data[0];
      *pptoken;
      pptoken = &(*pptoken)->next)
  continue;
 *pptoken = token;

 _leave(" = 0");
 return 0;

nomem_yrxgk:
 kfree(token->rxgk);
nomem_token:
 kfree(token);
nomem:
 return -ENOMEM;
reject_token:
 kfree(token);
reject:
 return -EKEYREJECTED;
expired:
 kfree(token->rxgk);
 kfree(token);
 return -EKEYEXPIRED;
}

/*
 * attempt to parse the data as the XDR format
 * - the caller guarantees we have more than 7 words
 */
static int rxrpc_preparse_xdr(struct key_preparsed_payload *prep)
{
 const __be32 *xdr = prep->data, *token, *p;
 const char *cp;
 unsigned int len, paddedlen, loop, ntoken, toklen, sec_ix;
 size_t datalen = prep->datalen;
 int ret, ret2;

 _enter(",{%x,%x,%x,%x},%zu",
        ntohl(xdr[0]), ntohl(xdr[1]), ntohl(xdr[2]), ntohl(xdr[3]),
        prep->datalen);

 if (datalen > AFSTOKEN_LENGTH_MAX)
  goto not_xdr;

 /* XDR is an array of __be32's */
 if (datalen & 3)
  goto not_xdr;

 /* the flags should be 0 (the setpag bit must be handled by
 * userspace) */
 if (ntohl(*xdr++) != 0)
  goto not_xdr;
 datalen -= 4;

 /* check the cell name */
 len = ntohl(*xdr++);
 if (len < 1 || len > AFSTOKEN_CELL_MAX)
  goto not_xdr;
 datalen -= 4;
 paddedlen = (len + 3) & ~3;
 if (paddedlen > datalen)
  goto not_xdr;

 cp = (const char *) xdr;
 for (loop = 0; loop < len; loop++)
  if (!isprint(cp[loop]))
   goto not_xdr;
 for (; loop < paddedlen; loop++)
  if (cp[loop])
   goto not_xdr;
 _debug("cellname: [%u/%u] '%*.*s'",
        len, paddedlen, len, len, (const char *) xdr);
 datalen -= paddedlen;
 xdr += paddedlen >> 2;

 /* get the token count */
 if (datalen < 12)
  goto not_xdr;
 ntoken = ntohl(*xdr++);
 datalen -= 4;
 _debug("ntoken: %x", ntoken);
 if (ntoken < 1 || ntoken > AFSTOKEN_MAX)
  goto not_xdr;

 /* check each token wrapper */
 p = xdr;
 loop = ntoken;
 do {
  if (datalen < 8)
   goto not_xdr;
  toklen = ntohl(*p++);
  sec_ix = ntohl(*p);
  datalen -= 4;
  _debug("token: [%x/%zx] %x", toklen, datalen, sec_ix);
  paddedlen = (toklen + 3) & ~3;
  if (toklen < 20 || toklen > datalen || paddedlen > datalen)
   goto not_xdr;
  datalen -= paddedlen;
  p += paddedlen >> 2;

 } while (--loop > 0);

 _debug("remainder: %zu", datalen);
 if (datalen != 0)
  goto not_xdr;

 /* okay: we're going to assume it's valid XDR format
  * - we ignore the cellname, relying on the key to be correctly named
 */
 ret = -EPROTONOSUPPORT;
 do {
  toklen = ntohl(*xdr++);
  token = xdr;
  xdr += (toklen + 3) / 4;

  sec_ix = ntohl(*token++);
  toklen -= 4;

  _debug("TOKEN type=%x len=%x", sec_ix, toklen);

  switch (sec_ix) {
  case RXRPC_SECURITY_RXKAD:
   ret2 = rxrpc_preparse_xdr_rxkad(prep, datalen, token, toklen);
   break;
  case RXRPC_SECURITY_YFS_RXGK:
   ret2 = rxrpc_preparse_xdr_yfs_rxgk(prep, datalen, token, toklen);
   break;
  default:
   ret2 = -EPROTONOSUPPORT;
   break;
  }

  switch (ret2) {
  case 0:
   ret = 0;
   break;
  case -EPROTONOSUPPORT:
   break;
  case -ENOPKG:
   if (ret != 0)
    ret = -ENOPKG;
   break;
  default:
   ret = ret2;
   goto error;
  }

 } while (--ntoken > 0);

error:
 _leave(" = %d", ret);
 return ret;

not_xdr:
 _leave(" = -EPROTO");
 return -EPROTO;
}

/*
 * Preparse an rxrpc defined key.
 *
 * Data should be of the form:
 * OFFSET LEN CONTENT
 * 0 4 key interface version number
 * 4 2 security index (type)
 * 6 2 ticket length
 * 8 4 key expiry time (time_t)
 * 12 4 kvno
 * 16 8 session key
 * 24 [len] ticket
 *
 * if no data is provided, then a no-security key is made
 */
static int rxrpc_preparse(struct key_preparsed_payload *prep)
{
 const struct rxrpc_key_data_v1 *v1;
 struct rxrpc_key_token *token, **pp;
 time64_t expiry;
 size_t plen;
 u32 kver;
 int ret;

 _enter("%zu", prep->datalen);

 /* handle a no-security key */
 if (!prep->data && prep->datalen == 0)
  return 0;

 /* determine if the XDR payload format is being used */
 if (prep->datalen > 7 * 4) {
  ret = rxrpc_preparse_xdr(prep);
  if (ret != -EPROTO)
   return ret;
 }

 /* get the key interface version number */
 ret = -EINVAL;
 if (prep->datalen <= 4 || !prep->data)
  goto error;
 memcpy(&kver, prep->data, sizeof(kver));
 prep->data += sizeof(kver);
 prep->datalen -= sizeof(kver);

 _debug("KEY I/F VERSION: %u", kver);

 ret = -EKEYREJECTED;
 if (kver != 1)
  goto error;

 /* deal with a version 1 key */
 ret = -EINVAL;
 if (prep->datalen < sizeof(*v1))
  goto error;

 v1 = prep->data;
 if (prep->datalen != sizeof(*v1) + v1->ticket_length)
  goto error;

 _debug("SCIX: %u", v1->security_index);
 _debug("TLEN: %u", v1->ticket_length);
 _debug("EXPY: %x", v1->expiry);
 _debug("KVNO: %u", v1->kvno);
 _debug("SKEY: %02x%02x%02x%02x%02x%02x%02x%02x",
        v1->session_key[0], v1->session_key[1],
        v1->session_key[2], v1->session_key[3],
        v1->session_key[4], v1->session_key[5],
        v1->session_key[6], v1->session_key[7]);
 if (v1->ticket_length >= 8)
  _debug("TCKT: %02x%02x%02x%02x%02x%02x%02x%02x",
         v1->ticket[0], v1->ticket[1],
         v1->ticket[2], v1->ticket[3],
         v1->ticket[4], v1->ticket[5],
         v1->ticket[6], v1->ticket[7]);

 ret = -EPROTONOSUPPORT;
 if (v1->security_index != RXRPC_SECURITY_RXKAD)
  goto error;

 plen = sizeof(*token->kad) + v1->ticket_length;
 prep->quotalen = plen + sizeof(*token);

 ret = -ENOMEM;
 token = kzalloc(sizeof(*token), GFP_KERNEL);
 if (!token)
  goto error;
 token->kad = kzalloc(plen, GFP_KERNEL);
 if (!token->kad)
  goto error_free;

 token->security_index  = RXRPC_SECURITY_RXKAD;
 token->kad->ticket_len  = v1->ticket_length;
 token->kad->expiry  = v1->expiry;
 token->kad->kvno  = v1->kvno;
 memcpy(&token->kad->session_key, &v1->session_key, 8);
 memcpy(&token->kad->ticket, v1->ticket, v1->ticket_length);

 /* count the number of tokens attached */
 prep->payload.data[1] = (void *)((unsigned long)prep->payload.data[1] + 1);

 /* attach the data */
 pp = (struct rxrpc_key_token **)&prep->payload.data[0];
 while (*pp)
  pp = &(*pp)->next;
 *pp = token;
 expiry = rxrpc_u32_to_time64(token->kad->expiry);
 if (expiry < prep->expiry)
  prep->expiry = expiry;
 token = NULL;
 ret = 0;

error_free:
 kfree(token);
error:
 return ret;
}

/*
 * Free token list.
 */
static void rxrpc_free_token_list(struct rxrpc_key_token *token)
{
 struct rxrpc_key_token *next;

 for (; token; token = next) {
  next = token->next;
  switch (token->security_index) {
  case RXRPC_SECURITY_RXKAD:
   kfree(token->kad);
   break;
  case RXRPC_SECURITY_YFS_RXGK:
   kfree(token->rxgk->ticket.data);
   kfree(token->rxgk);
   break;
  default:
   pr_err("Unknown token type %x on rxrpc key\n",
          token->security_index);
   BUG();
  }

  kfree(token);
 }
}

/*
 * Clean up preparse data.
 */
static void rxrpc_free_preparse(struct key_preparsed_payload *prep)
{
 rxrpc_free_token_list(prep->payload.data[0]);
}

/*
 * dispose of the data dangling from the corpse of a rxrpc key
 */
static void rxrpc_destroy(struct key *key)
{
 rxrpc_free_token_list(key->payload.data[0]);
}

/*
 * describe the rxrpc key
 */
static void rxrpc_describe(const struct key *key, struct seq_file *m)
{
 const struct rxrpc_key_token *token;
 const char *sep = ": ";

 seq_puts(m, key->description);

 for (token = key->payload.data[0]; token; token = token->next) {
  seq_puts(m, sep);

  switch (token->security_index) {
  case RXRPC_SECURITY_RXKAD:
   seq_puts(m, "ka");
   break;
  case RXRPC_SECURITY_YFS_RXGK:
   seq_puts(m, "ygk");
   break;
  default: /* we have a ticket we can't encode */
   seq_printf(m, "%u", token->security_index);
   break;
  }

  sep = " ";
 }
}

/*
 * grab the security key for a socket
 */
int rxrpc_request_key(struct rxrpc_sock *rx, sockptr_t optval, int optlen)
{
 struct key *key;
 char *description;

 _enter("");

 if (optlen <= 0 || optlen > PAGE_SIZE - 1 || rx->securities)
  return -EINVAL;

 description = memdup_sockptr_nul(optval, optlen);
 if (IS_ERR(description))
  return PTR_ERR(description);

 key = request_key_net(&key_type_rxrpc, description, sock_net(&rx->sk), NULL);
 if (IS_ERR(key)) {
  kfree(description);
  _leave(" = %ld", PTR_ERR(key));
  return PTR_ERR(key);
 }

 rx->key = key;
 kfree(description);
 _leave(" = 0 [key %x]", key->serial);
 return 0;
}

/*
 * generate a server data key
 */
int rxrpc_get_server_data_key(struct rxrpc_connection *conn,
         const void *session_key,
         time64_t expiry,
         u32 kvno)
{
 const struct cred *cred = current_cred();
 struct key *key;
 int ret;

 struct {
  u32 kver;
  struct rxrpc_key_data_v1 v1;
 } data;

 _enter("");

 key = key_alloc(&key_type_rxrpc, "x",
   GLOBAL_ROOT_UID, GLOBAL_ROOT_GID, cred, 0,
   KEY_ALLOC_NOT_IN_QUOTA, NULL);
 if (IS_ERR(key)) {
  _leave(" = -ENOMEM [alloc %ld]", PTR_ERR(key));
  return -ENOMEM;
 }

 _debug("key %d", key_serial(key));

 data.kver = 1;
 data.v1.security_index = RXRPC_SECURITY_RXKAD;
 data.v1.ticket_length = 0;
 data.v1.expiry = rxrpc_time64_to_u32(expiry);
 data.v1.kvno = 0;

 memcpy(&data.v1.session_key, session_key, sizeof(data.v1.session_key));

 ret = key_instantiate_and_link(key, &data, sizeof(data), NULL, NULL);
 if (ret < 0)
  goto error;

 conn->key = key;
 _leave(" = 0 [%d]", key_serial(key));
 return 0;

error:
 key_revoke(key);
 key_put(key);
 _leave(" = -ENOMEM [ins %d]", ret);
 return -ENOMEM;
}
EXPORT_SYMBOL(rxrpc_get_server_data_key);

/**
 * rxrpc_get_null_key - Generate a null RxRPC key
 * @keyname: The name to give the key.
 *
 * Generate a null RxRPC key that can be used to indicate anonymous security is
 * required for a particular domain.
 *
 * Return: The new key or a negative error code.
 */
struct key *rxrpc_get_null_key(const char *keyname)
{
 const struct cred *cred = current_cred();
 struct key *key;
 int ret;

 key = key_alloc(&key_type_rxrpc, keyname,
   GLOBAL_ROOT_UID, GLOBAL_ROOT_GID, cred,
   KEY_POS_SEARCH, KEY_ALLOC_NOT_IN_QUOTA, NULL);
 if (IS_ERR(key))
  return key;

 ret = key_instantiate_and_link(key, NULL, 0, NULL, NULL);
 if (ret < 0) {
  key_revoke(key);
  key_put(key);
  return ERR_PTR(ret);
 }

 return key;
}
EXPORT_SYMBOL(rxrpc_get_null_key);

/*
 * read the contents of an rxrpc key
 * - this returns the result in XDR form
 */
static long rxrpc_read(const struct key *key,
         char *buffer, size_t buflen)
{
 const struct rxrpc_key_token *token;
 size_t size;
 __be32 *xdr, *oldxdr;
 u32 cnlen, toksize, ntoks, tok, zero;
 u16 toksizes[AFSTOKEN_MAX];

 _enter("");

 /* we don't know what form we should return non-AFS keys in */
 if (memcmp(key->description, "afs@", 4) != 0)
  return -EOPNOTSUPP;
 cnlen = strlen(key->description + 4);

#define RND(X) (((X) + 3) & ~3)

 /* AFS keys we return in XDR form, so we need to work out the size of
 * the XDR */
 size = 2 * 4; /* flags, cellname len */
 size += RND(cnlen); /* cellname */
 size += 1 * 4; /* token count */

 ntoks = 0;
 for (token = key->payload.data[0]; token; token = token->next) {
  toksize = 4; /* sec index */

  switch (token->security_index) {
  case RXRPC_SECURITY_RXKAD:
   toksize += 8 * 4; /* viceid, kvno, key*2, begin,
 * end, primary, tktlen */
   if (!token->no_leak_key)
    toksize += RND(token->kad->ticket_len);
   break;

  case RXRPC_SECURITY_YFS_RXGK:
   toksize += 6 * 8 + 2 * 4;
   if (!token->no_leak_key)
    toksize += RND(token->rxgk->key.len);
   toksize += RND(token->rxgk->ticket.len);
   break;

  default: /* we have a ticket we can't encode */
   pr_err("Unsupported key token type (%u)\n",
          token->security_index);
   return -ENOPKG;
  }

  _debug("token[%u]: toksize=%u", ntoks, toksize);
  if (WARN_ON(toksize > AFSTOKEN_LENGTH_MAX))
   return -EIO;

  toksizes[ntoks++] = toksize;
  size += toksize + 4; /* each token has a length word */
 }

#undef RND

 if (!buffer || buflen < size)
  return size;

 xdr = (__be32 *)buffer;
 zero = 0;
#define ENCODE(x)    \
 do {     \
  *xdr++ = htonl(x);  \
 } while(0)
#define ENCODE_DATA(l, s)      \
 do {        \
  u32 _l = (l);      \
  ENCODE(l);      \
  memcpy(xdr, (s), _l);     \
  if (_l & 3)      \
   memcpy((u8 *)xdr + _l, &zero, 4 - (_l & 3)); \
  xdr += (_l + 3) >> 2;     \
 } while(0)
#define ENCODE_BYTES(l, s)      \
 do {        \
  u32 _l = (l);      \
  memcpy(xdr, (s), _l);     \
  if (_l & 3)      \
   memcpy((u8 *)xdr + _l, &zero, 4 - (_l & 3)); \
  xdr += (_l + 3) >> 2;     \
 } while(0)
#define ENCODE64(x)     \
 do {      \
  __be64 y = cpu_to_be64(x);  \
  memcpy(xdr, &y, 8);   \
  xdr += 8 >> 2;    \
 } while(0)
#define ENCODE_STR(s)    \
 do {     \
  const char *_s = (s);  \
  ENCODE_DATA(strlen(_s), _s); \
 } while(0)

 ENCODE(0);     /* flags */
 ENCODE_DATA(cnlen, key->description + 4); /* cellname */
 ENCODE(ntoks);

 tok = 0;
 for (token = key->payload.data[0]; token; token = token->next) {
  toksize = toksizes[tok++];
  ENCODE(toksize);
  oldxdr = xdr;
  ENCODE(token->security_index);

  switch (token->security_index) {
  case RXRPC_SECURITY_RXKAD:
   ENCODE(token->kad->vice_id);
   ENCODE(token->kad->kvno);
   ENCODE_BYTES(8, token->kad->session_key);
   ENCODE(token->kad->start);
   ENCODE(token->kad->expiry);
   ENCODE(token->kad->primary_flag);
   if (token->no_leak_key)
    ENCODE(0);
   else
    ENCODE_DATA(token->kad->ticket_len, token->kad->ticket);
   break;

  case RXRPC_SECURITY_YFS_RXGK:
   ENCODE64(token->rxgk->begintime);
   ENCODE64(token->rxgk->endtime);
   ENCODE64(token->rxgk->level);
   ENCODE64(token->rxgk->lifetime);
   ENCODE64(token->rxgk->bytelife);
   ENCODE64(token->rxgk->enctype);
   if (token->no_leak_key)
    ENCODE(0);
   else
    ENCODE_DATA(token->rxgk->key.len, token->rxgk->key.data);
   ENCODE_DATA(token->rxgk->ticket.len, token->rxgk->ticket.data);
   break;

  default:
   pr_err("Unsupported key token type (%u)\n",
          token->security_index);
   return -ENOPKG;
  }

  if (WARN_ON((unsigned long)xdr - (unsigned long)oldxdr !=
       toksize))
   return -EIO;
 }

#undef ENCODE_STR
#undef ENCODE_DATA
#undef ENCODE64
#undef ENCODE

 if (WARN_ON(tok != ntoks))
  return -EIO;
 if (WARN_ON((unsigned long)xdr - (unsigned long)buffer != size))
  return -EIO;
 _leave(" = %zu", size);
 return size;
}