LCOV - code coverage report
Current view: top level - net/sunrpc/auth_gss - svcauth_gss.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 38 1003 3.8 %
Date: 2022-04-01 14:35:51 Functions: 5 57 8.8 %
Branches: 8 456 1.8 %

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

Generated by: LCOV version 1.14