git.oblomov.eu Git - linux-2.6/blob - net/sunrpc/auth_gss/auth_gss.c

   1 /*
   2  * linux/net/sunrpc/auth_gss/auth_gss.c
   3  *
   4  * RPCSEC_GSS client authentication.
   5  *
   6  *  Copyright (c) 2000 The Regents of the University of Michigan.
   7  *  All rights reserved.
   8  *
   9  *  Dug Song       <dugsong@monkey.org>
  10  *  Andy Adamson   <andros@umich.edu>
  11  *
  12  *  Redistribution and use in source and binary forms, with or without
  13  *  modification, are permitted provided that the following conditions
  14  *  are met:
  15  *
  16  *  1. Redistributions of source code must retain the above copyright
  17  *     notice, this list of conditions and the following disclaimer.
  18  *  2. Redistributions in binary form must reproduce the above copyright
  19  *     notice, this list of conditions and the following disclaimer in the
  20  *     documentation and/or other materials provided with the distribution.
  21  *  3. Neither the name of the University nor the names of its
  22  *     contributors may be used to endorse or promote products derived
  23  *     from this software without specific prior written permission.
  24  *
  25  *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
  26  *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  27  *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  28  *  DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  29  *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  30  *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  31  *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  32  *  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  33  *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  34  *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  35  *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  36  */
  37
  38
  39 #include <linux/module.h>
  40 #include <linux/init.h>
  41 #include <linux/types.h>
  42 #include <linux/slab.h>
  43 #include <linux/sched.h>
  44 #include <linux/pagemap.h>
  45 #include <linux/sunrpc/clnt.h>
  46 #include <linux/sunrpc/auth.h>
  47 #include <linux/sunrpc/auth_gss.h>
  48 #include <linux/sunrpc/svcauth_gss.h>
  49 #include <linux/sunrpc/gss_err.h>
  50 #include <linux/workqueue.h>
  51 #include <linux/sunrpc/rpc_pipe_fs.h>
  52 #include <linux/sunrpc/gss_api.h>
  53 #include <asm/uaccess.h>
  54
  55 static const struct rpc_authops authgss_ops;
  56
  57 static const struct rpc_credops gss_credops;
  58 static const struct rpc_credops gss_nullops;
  59
  60 #ifdef RPC_DEBUG
  61 # define RPCDBG_FACILITY        RPCDBG_AUTH
  62 #endif
  63
  64 #define GSS_CRED_SLACK          1024
  65 /* length of a krb5 verifier (48), plus data added before arguments when
  66  * using integrity (two 4-byte integers): */
  67 #define GSS_VERF_SLACK          100
  68
  69 struct gss_auth {
  70         struct kref kref;
  71         struct rpc_auth rpc_auth;
  72         struct gss_api_mech *mech;
  73         enum rpc_gss_svc service;
  74         struct rpc_clnt *client;
  75         struct dentry *dentry;
  76 };
  77
  78 /* pipe_version >= 0 if and only if someone has a pipe open. */
  79 static int pipe_version = -1;
  80 static atomic_t pipe_users = ATOMIC_INIT(0);
  81 static DEFINE_SPINLOCK(pipe_version_lock);
  82 static struct rpc_wait_queue pipe_version_rpc_waitqueue;
  83 static DECLARE_WAIT_QUEUE_HEAD(pipe_version_waitqueue);
  84
  85 static void gss_free_ctx(struct gss_cl_ctx *);
  86 static struct rpc_pipe_ops gss_upcall_ops;
  87
  88 static inline struct gss_cl_ctx *
  89 gss_get_ctx(struct gss_cl_ctx *ctx)
  90 {
  91         atomic_inc(&ctx->count);
  92         return ctx;
  93 }
  94
  95 static inline void
  96 gss_put_ctx(struct gss_cl_ctx *ctx)
  97 {
  98         if (atomic_dec_and_test(&ctx->count))
  99                 gss_free_ctx(ctx);
 100 }
 101
 102 /* gss_cred_set_ctx:
 103  * called by gss_upcall_callback and gss_create_upcall in order
 104  * to set the gss context. The actual exchange of an old context
 105  * and a new one is protected by the inode->i_lock.
 106  */
 107 static void
 108 gss_cred_set_ctx(struct rpc_cred *cred, struct gss_cl_ctx *ctx)
 109 {
 110         struct gss_cred *gss_cred = container_of(cred, struct gss_cred, gc_base);
 111
 112         if (!test_bit(RPCAUTH_CRED_NEW, &cred->cr_flags))
 113                 return;
 114         gss_get_ctx(ctx);
 115         rcu_assign_pointer(gss_cred->gc_ctx, ctx);
 116         set_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags);
 117         smp_mb__before_clear_bit();
 118         clear_bit(RPCAUTH_CRED_NEW, &cred->cr_flags);
 119 }
 120
 121 static const void *
 122 simple_get_bytes(const void *p, const void *end, void *res, size_t len)
 123 {
 124         const void *q = (const void *)((const char *)p + len);
 125         if (unlikely(q > end || q < p))
 126                 return ERR_PTR(-EFAULT);
 127         memcpy(res, p, len);
 128         return q;
 129 }
 130
 131 static inline const void *
 132 simple_get_netobj(const void *p, const void *end, struct xdr_netobj *dest)
 133 {
 134         const void *q;
 135         unsigned int len;
 136
 137         p = simple_get_bytes(p, end, &len, sizeof(len));
 138         if (IS_ERR(p))
 139                 return p;
 140         q = (const void *)((const char *)p + len);
 141         if (unlikely(q > end || q < p))
 142                 return ERR_PTR(-EFAULT);
 143         dest->data = kmemdup(p, len, GFP_NOFS);
 144         if (unlikely(dest->data == NULL))
 145                 return ERR_PTR(-ENOMEM);
 146         dest->len = len;
 147         return q;
 148 }
 149
 150 static struct gss_cl_ctx *
 151 gss_cred_get_ctx(struct rpc_cred *cred)
 152 {
 153         struct gss_cred *gss_cred = container_of(cred, struct gss_cred, gc_base);
 154         struct gss_cl_ctx *ctx = NULL;
 155
 156         rcu_read_lock();
 157         if (gss_cred->gc_ctx)
 158                 ctx = gss_get_ctx(gss_cred->gc_ctx);
 159         rcu_read_unlock();
 160         return ctx;
 161 }
 162
 163 static struct gss_cl_ctx *
 164 gss_alloc_context(void)
 165 {
 166         struct gss_cl_ctx *ctx;
 167
 168         ctx = kzalloc(sizeof(*ctx), GFP_NOFS);
 169         if (ctx != NULL) {
 170                 ctx->gc_proc = RPC_GSS_PROC_DATA;
 171                 ctx->gc_seq = 1;        /* NetApp 6.4R1 doesn't accept seq. no. 0 */
 172                 spin_lock_init(&ctx->gc_seq_lock);
 173                 atomic_set(&ctx->count,1);
 174         }
 175         return ctx;
 176 }
 177
 178 #define GSSD_MIN_TIMEOUT (60 * 60)
 179 static const void *
 180 gss_fill_context(const void *p, const void *end, struct gss_cl_ctx *ctx, struct gss_api_mech *gm)
 181 {
 182         const void *q;
 183         unsigned int seclen;
 184         unsigned int timeout;
 185         u32 window_size;
 186         int ret;
 187
 188         /* First unsigned int gives the lifetime (in seconds) of the cred */
 189         p = simple_get_bytes(p, end, &timeout, sizeof(timeout));
 190         if (IS_ERR(p))
 191                 goto err;
 192         if (timeout == 0)
 193                 timeout = GSSD_MIN_TIMEOUT;
 194         ctx->gc_expiry = jiffies + (unsigned long)timeout * HZ * 3 / 4;
 195         /* Sequence number window. Determines the maximum number of simultaneous requests */
 196         p = simple_get_bytes(p, end, &window_size, sizeof(window_size));
 197         if (IS_ERR(p))
 198                 goto err;
 199         ctx->gc_win = window_size;
 200         /* gssd signals an error by passing ctx->gc_win = 0: */
 201         if (ctx->gc_win == 0) {
 202                 /* in which case, p points to  an error code which we ignore */
 203                 p = ERR_PTR(-EACCES);
 204                 goto err;
 205         }
 206         /* copy the opaque wire context */
 207         p = simple_get_netobj(p, end, &ctx->gc_wire_ctx);
 208         if (IS_ERR(p))
 209                 goto err;
 210         /* import the opaque security context */
 211         p  = simple_get_bytes(p, end, &seclen, sizeof(seclen));
 212         if (IS_ERR(p))
 213                 goto err;
 214         q = (const void *)((const char *)p + seclen);
 215         if (unlikely(q > end || q < p)) {
 216                 p = ERR_PTR(-EFAULT);
 217                 goto err;
 218         }
 219         ret = gss_import_sec_context(p, seclen, gm, &ctx->gc_gss_ctx);
 220         if (ret < 0) {
 221                 p = ERR_PTR(ret);
 222                 goto err;
 223         }
 224         return q;
 225 err:
 226         dprintk("RPC:       gss_fill_context returning %ld\n", -PTR_ERR(p));
 227         return p;
 228 }
 229
 230
 231 struct gss_upcall_msg {
 232         atomic_t count;
 233         uid_t   uid;
 234         struct rpc_pipe_msg msg;
 235         struct list_head list;
 236         struct gss_auth *auth;
 237         struct rpc_wait_queue rpc_waitqueue;
 238         wait_queue_head_t waitqueue;
 239         struct gss_cl_ctx *ctx;
 240 };
 241
 242 static int get_pipe_version(void)
 243 {
 244         int ret;
 245
 246         spin_lock(&pipe_version_lock);
 247         if (pipe_version >= 0) {
 248                 atomic_inc(&pipe_users);
 249                 ret = 0;
 250         } else
 251                 ret = -EAGAIN;
 252         spin_unlock(&pipe_version_lock);
 253         return ret;
 254 }
 255
 256 static void put_pipe_version(void)
 257 {
 258         if (atomic_dec_and_lock(&pipe_users, &pipe_version_lock)) {
 259                 pipe_version = -1;
 260                 spin_unlock(&pipe_version_lock);
 261         }
 262 }
 263
 264 static void
 265 gss_release_msg(struct gss_upcall_msg *gss_msg)
 266 {
 267         if (!atomic_dec_and_test(&gss_msg->count))
 268                 return;
 269         put_pipe_version();
 270         BUG_ON(!list_empty(&gss_msg->list));
 271         if (gss_msg->ctx != NULL)
 272                 gss_put_ctx(gss_msg->ctx);
 273         rpc_destroy_wait_queue(&gss_msg->rpc_waitqueue);
 274         kfree(gss_msg);
 275 }
 276
 277 static struct gss_upcall_msg *
 278 __gss_find_upcall(struct rpc_inode *rpci, uid_t uid)
 279 {
 280         struct gss_upcall_msg *pos;
 281         list_for_each_entry(pos, &rpci->in_downcall, list) {
 282                 if (pos->uid != uid)
 283                         continue;
 284                 atomic_inc(&pos->count);
 285                 dprintk("RPC:       gss_find_upcall found msg %p\n", pos);
 286                 return pos;
 287         }
 288         dprintk("RPC:       gss_find_upcall found nothing\n");
 289         return NULL;
 290 }
 291
 292 /* Try to add an upcall to the pipefs queue.
 293  * If an upcall owned by our uid already exists, then we return a reference
 294  * to that upcall instead of adding the new upcall.
 295  */
 296 static inline struct gss_upcall_msg *
 297 gss_add_msg(struct gss_auth *gss_auth, struct gss_upcall_msg *gss_msg)
 298 {
 299         struct inode *inode = gss_auth->dentry->d_inode;
 300         struct rpc_inode *rpci = RPC_I(inode);
 301         struct gss_upcall_msg *old;
 302
 303         spin_lock(&inode->i_lock);
 304         old = __gss_find_upcall(rpci, gss_msg->uid);
 305         if (old == NULL) {
 306                 atomic_inc(&gss_msg->count);
 307                 list_add(&gss_msg->list, &rpci->in_downcall);
 308         } else
 309                 gss_msg = old;
 310         spin_unlock(&inode->i_lock);
 311         return gss_msg;
 312 }
 313
 314 static void
 315 __gss_unhash_msg(struct gss_upcall_msg *gss_msg)
 316 {
 317         list_del_init(&gss_msg->list);
 318         rpc_wake_up_status(&gss_msg->rpc_waitqueue, gss_msg->msg.errno);
 319         wake_up_all(&gss_msg->waitqueue);
 320         atomic_dec(&gss_msg->count);
 321 }
 322
 323 static void
 324 gss_unhash_msg(struct gss_upcall_msg *gss_msg)
 325 {
 326         struct gss_auth *gss_auth = gss_msg->auth;
 327         struct inode *inode = gss_auth->dentry->d_inode;
 328
 329         if (list_empty(&gss_msg->list))
 330                 return;
 331         spin_lock(&inode->i_lock);
 332         if (!list_empty(&gss_msg->list))
 333                 __gss_unhash_msg(gss_msg);
 334         spin_unlock(&inode->i_lock);
 335 }
 336
 337 static void
 338 gss_upcall_callback(struct rpc_task *task)
 339 {
 340         struct gss_cred *gss_cred = container_of(task->tk_msg.rpc_cred,
 341                         struct gss_cred, gc_base);
 342         struct gss_upcall_msg *gss_msg = gss_cred->gc_upcall;
 343         struct inode *inode = gss_msg->auth->dentry->d_inode;
 344
 345         spin_lock(&inode->i_lock);
 346         if (gss_msg->ctx)
 347                 gss_cred_set_ctx(task->tk_msg.rpc_cred, gss_msg->ctx);
 348         else
 349                 task->tk_status = gss_msg->msg.errno;
 350         gss_cred->gc_upcall = NULL;
 351         rpc_wake_up_status(&gss_msg->rpc_waitqueue, gss_msg->msg.errno);
 352         spin_unlock(&inode->i_lock);
 353         gss_release_msg(gss_msg);
 354 }
 355
 356 static inline struct gss_upcall_msg *
 357 gss_alloc_msg(struct gss_auth *gss_auth, uid_t uid)
 358 {
 359         struct gss_upcall_msg *gss_msg;
 360         int vers;
 361
 362         gss_msg = kzalloc(sizeof(*gss_msg), GFP_NOFS);
 363         if (gss_msg == NULL)
 364                 return ERR_PTR(-ENOMEM);
 365         vers = get_pipe_version();
 366         if (vers < 0) {
 367                 kfree(gss_msg);
 368                 return ERR_PTR(vers);
 369         }
 370         INIT_LIST_HEAD(&gss_msg->list);
 371         rpc_init_wait_queue(&gss_msg->rpc_waitqueue, "RPCSEC_GSS upcall waitq");
 372         init_waitqueue_head(&gss_msg->waitqueue);
 373         atomic_set(&gss_msg->count, 1);
 374         gss_msg->msg.data = &gss_msg->uid;
 375         gss_msg->msg.len = sizeof(gss_msg->uid);
 376         gss_msg->uid = uid;
 377         gss_msg->auth = gss_auth;
 378         return gss_msg;
 379 }
 380
 381 static struct gss_upcall_msg *
 382 gss_setup_upcall(struct rpc_clnt *clnt, struct gss_auth *gss_auth, struct rpc_cred *cred)
 383 {
 384         struct gss_cred *gss_cred = container_of(cred,
 385                         struct gss_cred, gc_base);
 386         struct gss_upcall_msg *gss_new, *gss_msg;
 387         uid_t uid = cred->cr_uid;
 388
 389         /* Special case: rpc.gssd assumes that uid == 0 implies machine creds */
 390         if (gss_cred->gc_machine_cred != 0)
 391                 uid = 0;
 392
 393         gss_new = gss_alloc_msg(gss_auth, uid);
 394         if (IS_ERR(gss_new))
 395                 return gss_new;
 396         gss_msg = gss_add_msg(gss_auth, gss_new);
 397         if (gss_msg == gss_new) {
 398                 int res = rpc_queue_upcall(gss_auth->dentry->d_inode, &gss_new->msg);
 399                 if (res) {
 400                         gss_unhash_msg(gss_new);
 401                         gss_msg = ERR_PTR(res);
 402                 }
 403         } else
 404                 gss_release_msg(gss_new);
 405         return gss_msg;
 406 }
 407
 408 static void warn_gssd(void)
 409 {
 410         static unsigned long ratelimit;
 411         unsigned long now = jiffies;
 412
 413         if (time_after(now, ratelimit)) {
 414                 printk(KERN_WARNING "RPC: AUTH_GSS upcall timed out.\n"
 415                                 "Please check user daemon is running.\n");
 416                 ratelimit = now + 15*HZ;
 417         }
 418 }
 419
 420 static inline int
 421 gss_refresh_upcall(struct rpc_task *task)
 422 {
 423         struct rpc_cred *cred = task->tk_msg.rpc_cred;
 424         struct gss_auth *gss_auth = container_of(cred->cr_auth,
 425                         struct gss_auth, rpc_auth);
 426         struct gss_cred *gss_cred = container_of(cred,
 427                         struct gss_cred, gc_base);
 428         struct gss_upcall_msg *gss_msg;
 429         struct inode *inode = gss_auth->dentry->d_inode;
 430         int err = 0;
 431
 432         dprintk("RPC: %5u gss_refresh_upcall for uid %u\n", task->tk_pid,
 433                                                                 cred->cr_uid);
 434         gss_msg = gss_setup_upcall(task->tk_client, gss_auth, cred);
 435         if (IS_ERR(gss_msg) == -EAGAIN) {
 436                 /* XXX: warning on the first, under the assumption we
 437                  * shouldn't normally hit this case on a refresh. */
 438                 warn_gssd();
 439                 task->tk_timeout = 15*HZ;
 440                 rpc_sleep_on(&pipe_version_rpc_waitqueue, task, NULL);
 441                 return 0;
 442         }
 443         if (IS_ERR(gss_msg)) {
 444                 err = PTR_ERR(gss_msg);
 445                 goto out;
 446         }
 447         spin_lock(&inode->i_lock);
 448         if (gss_cred->gc_upcall != NULL)
 449                 rpc_sleep_on(&gss_cred->gc_upcall->rpc_waitqueue, task, NULL);
 450         else if (gss_msg->ctx != NULL) {
 451                 gss_cred_set_ctx(task->tk_msg.rpc_cred, gss_msg->ctx);
 452                 gss_cred->gc_upcall = NULL;
 453                 rpc_wake_up_status(&gss_msg->rpc_waitqueue, gss_msg->msg.errno);
 454         } else if (gss_msg->msg.errno >= 0) {
 455                 task->tk_timeout = 0;
 456                 gss_cred->gc_upcall = gss_msg;
 457                 /* gss_upcall_callback will release the reference to gss_upcall_msg */
 458                 atomic_inc(&gss_msg->count);
 459                 rpc_sleep_on(&gss_msg->rpc_waitqueue, task, gss_upcall_callback);
 460         } else
 461                 err = gss_msg->msg.errno;
 462         spin_unlock(&inode->i_lock);
 463         gss_release_msg(gss_msg);
 464 out:
 465         dprintk("RPC: %5u gss_refresh_upcall for uid %u result %d\n",
 466                         task->tk_pid, cred->cr_uid, err);
 467         return err;
 468 }
 469
 470 static inline int
 471 gss_create_upcall(struct gss_auth *gss_auth, struct gss_cred *gss_cred)
 472 {
 473         struct inode *inode = gss_auth->dentry->d_inode;
 474         struct rpc_cred *cred = &gss_cred->gc_base;
 475         struct gss_upcall_msg *gss_msg;
 476         DEFINE_WAIT(wait);
 477         int err = 0;
 478
 479         dprintk("RPC:       gss_upcall for uid %u\n", cred->cr_uid);
 480 retry:
 481         gss_msg = gss_setup_upcall(gss_auth->client, gss_auth, cred);
 482         if (PTR_ERR(gss_msg) == -EAGAIN) {
 483                 err = wait_event_interruptible_timeout(pipe_version_waitqueue,
 484                                 pipe_version >= 0, 15*HZ);
 485                 if (err)
 486                         goto out;
 487                 if (pipe_version < 0)
 488                         warn_gssd();
 489                 goto retry;
 490         }
 491         if (IS_ERR(gss_msg)) {
 492                 err = PTR_ERR(gss_msg);
 493                 goto out;
 494         }
 495         for (;;) {
 496                 prepare_to_wait(&gss_msg->waitqueue, &wait, TASK_INTERRUPTIBLE);
 497                 spin_lock(&inode->i_lock);
 498                 if (gss_msg->ctx != NULL || gss_msg->msg.errno < 0) {
 499                         break;
 500                 }
 501                 spin_unlock(&inode->i_lock);
 502                 if (signalled()) {
 503                         err = -ERESTARTSYS;
 504                         goto out_intr;
 505                 }
 506                 schedule();
 507         }
 508         if (gss_msg->ctx)
 509                 gss_cred_set_ctx(cred, gss_msg->ctx);
 510         else
 511                 err = gss_msg->msg.errno;
 512         spin_unlock(&inode->i_lock);
 513 out_intr:
 514         finish_wait(&gss_msg->waitqueue, &wait);
 515         gss_release_msg(gss_msg);
 516 out:
 517         dprintk("RPC:       gss_create_upcall for uid %u result %d\n",
 518                         cred->cr_uid, err);
 519         return err;
 520 }
 521
 522 static ssize_t
 523 gss_pipe_upcall(struct file *filp, struct rpc_pipe_msg *msg,
 524                 char __user *dst, size_t buflen)
 525 {
 526         char *data = (char *)msg->data + msg->copied;
 527         size_t mlen = min(msg->len, buflen);
 528         unsigned long left;
 529
 530         left = copy_to_user(dst, data, mlen);
 531         if (left == mlen) {
 532                 msg->errno = -EFAULT;
 533                 return -EFAULT;
 534         }
 535
 536         mlen -= left;
 537         msg->copied += mlen;
 538         msg->errno = 0;
 539         return mlen;
 540 }
 541
 542 #define MSG_BUF_MAXSIZE 1024
 543
 544 static ssize_t
 545 gss_pipe_downcall(struct file *filp, const char __user *src, size_t mlen)
 546 {
 547         const void *p, *end;
 548         void *buf;
 549         struct gss_upcall_msg *gss_msg;
 550         struct inode *inode = filp->f_path.dentry->d_inode;
 551         struct gss_cl_ctx *ctx;
 552         uid_t uid;
 553         ssize_t err = -EFBIG;
 554
 555         if (mlen > MSG_BUF_MAXSIZE)
 556                 goto out;
 557         err = -ENOMEM;
 558         buf = kmalloc(mlen, GFP_NOFS);
 559         if (!buf)
 560                 goto out;
 561
 562         err = -EFAULT;
 563         if (copy_from_user(buf, src, mlen))
 564                 goto err;
 565
 566         end = (const void *)((char *)buf + mlen);
 567         p = simple_get_bytes(buf, end, &uid, sizeof(uid));
 568         if (IS_ERR(p)) {
 569                 err = PTR_ERR(p);
 570                 goto err;
 571         }
 572
 573         err = -ENOMEM;
 574         ctx = gss_alloc_context();
 575         if (ctx == NULL)
 576                 goto err;
 577
 578         err = -ENOENT;
 579         /* Find a matching upcall */
 580         spin_lock(&inode->i_lock);
 581         gss_msg = __gss_find_upcall(RPC_I(inode), uid);
 582         if (gss_msg == NULL) {
 583                 spin_unlock(&inode->i_lock);
 584                 goto err_put_ctx;
 585         }
 586         list_del_init(&gss_msg->list);
 587         spin_unlock(&inode->i_lock);
 588
 589         p = gss_fill_context(p, end, ctx, gss_msg->auth->mech);
 590         if (IS_ERR(p)) {
 591                 err = PTR_ERR(p);
 592                 gss_msg->msg.errno = (err == -EAGAIN) ? -EAGAIN : -EACCES;
 593                 goto err_release_msg;
 594         }
 595         gss_msg->ctx = gss_get_ctx(ctx);
 596         err = mlen;
 597
 598 err_release_msg:
 599         spin_lock(&inode->i_lock);
 600         __gss_unhash_msg(gss_msg);
 601         spin_unlock(&inode->i_lock);
 602         gss_release_msg(gss_msg);
 603 err_put_ctx:
 604         gss_put_ctx(ctx);
 605 err:
 606         kfree(buf);
 607 out:
 608         dprintk("RPC:       gss_pipe_downcall returning %Zd\n", err);
 609         return err;
 610 }
 611
 612 static int
 613 gss_pipe_open(struct inode *inode)
 614 {
 615         spin_lock(&pipe_version_lock);
 616         if (pipe_version < 0) {
 617                 pipe_version = 0;
 618                 rpc_wake_up(&pipe_version_rpc_waitqueue);
 619                 wake_up(&pipe_version_waitqueue);
 620         }
 621         atomic_inc(&pipe_users);
 622         spin_unlock(&pipe_version_lock);
 623         return 0;
 624 }
 625
 626 static void
 627 gss_pipe_release(struct inode *inode)
 628 {
 629         struct rpc_inode *rpci = RPC_I(inode);
 630         struct gss_upcall_msg *gss_msg;
 631
 632         spin_lock(&inode->i_lock);
 633         while (!list_empty(&rpci->in_downcall)) {
 634
 635                 gss_msg = list_entry(rpci->in_downcall.next,
 636                                 struct gss_upcall_msg, list);
 637                 gss_msg->msg.errno = -EPIPE;
 638                 atomic_inc(&gss_msg->count);
 639                 __gss_unhash_msg(gss_msg);
 640                 spin_unlock(&inode->i_lock);
 641                 gss_release_msg(gss_msg);
 642                 spin_lock(&inode->i_lock);
 643         }
 644         spin_unlock(&inode->i_lock);
 645
 646         put_pipe_version();
 647 }
 648
 649 static void
 650 gss_pipe_destroy_msg(struct rpc_pipe_msg *msg)
 651 {
 652         struct gss_upcall_msg *gss_msg = container_of(msg, struct gss_upcall_msg, msg);
 653
 654         if (msg->errno < 0) {
 655                 dprintk("RPC:       gss_pipe_destroy_msg releasing msg %p\n",
 656                                 gss_msg);
 657                 atomic_inc(&gss_msg->count);
 658                 gss_unhash_msg(gss_msg);
 659                 if (msg->errno == -ETIMEDOUT)
 660                         warn_gssd();
 661                 gss_release_msg(gss_msg);
 662         }
 663 }
 664
 665 /*
 666  * NOTE: we have the opportunity to use different
 667  * parameters based on the input flavor (which must be a pseudoflavor)
 668  */
 669 static struct rpc_auth *
 670 gss_create(struct rpc_clnt *clnt, rpc_authflavor_t flavor)
 671 {
 672         struct gss_auth *gss_auth;
 673         struct rpc_auth * auth;
 674         int err = -ENOMEM; /* XXX? */
 675
 676         dprintk("RPC:       creating GSS authenticator for client %p\n", clnt);
 677
 678         if (!try_module_get(THIS_MODULE))
 679                 return ERR_PTR(err);
 680         if (!(gss_auth = kmalloc(sizeof(*gss_auth), GFP_KERNEL)))
 681                 goto out_dec;
 682         gss_auth->client = clnt;
 683         err = -EINVAL;
 684         gss_auth->mech = gss_mech_get_by_pseudoflavor(flavor);
 685         if (!gss_auth->mech) {
 686                 printk(KERN_WARNING "%s: Pseudoflavor %d not found!\n",
 687                                 __func__, flavor);
 688                 goto err_free;
 689         }
 690         gss_auth->service = gss_pseudoflavor_to_service(gss_auth->mech, flavor);
 691         if (gss_auth->service == 0)
 692                 goto err_put_mech;
 693         auth = &gss_auth->rpc_auth;
 694         auth->au_cslack = GSS_CRED_SLACK >> 2;
 695         auth->au_rslack = GSS_VERF_SLACK >> 2;
 696         auth->au_ops = &authgss_ops;
 697         auth->au_flavor = flavor;
 698         atomic_set(&auth->au_count, 1);
 699         kref_init(&gss_auth->kref);
 700
 701         gss_auth->dentry = rpc_mkpipe(clnt->cl_dentry, gss_auth->mech->gm_name,
 702                         clnt, &gss_upcall_ops, RPC_PIPE_WAIT_FOR_OPEN);
 703         if (IS_ERR(gss_auth->dentry)) {
 704                 err = PTR_ERR(gss_auth->dentry);
 705                 goto err_put_mech;
 706         }
 707
 708         err = rpcauth_init_credcache(auth);
 709         if (err)
 710                 goto err_unlink_pipe;
 711
 712         return auth;
 713 err_unlink_pipe:
 714         rpc_unlink(gss_auth->dentry);
 715 err_put_mech:
 716         gss_mech_put(gss_auth->mech);
 717 err_free:
 718         kfree(gss_auth);
 719 out_dec:
 720         module_put(THIS_MODULE);
 721         return ERR_PTR(err);
 722 }
 723
 724 static void
 725 gss_free(struct gss_auth *gss_auth)
 726 {
 727         rpc_unlink(gss_auth->dentry);
 728         gss_mech_put(gss_auth->mech);
 729
 730         kfree(gss_auth);
 731         module_put(THIS_MODULE);
 732 }
 733
 734 static void
 735 gss_free_callback(struct kref *kref)
 736 {
 737         struct gss_auth *gss_auth = container_of(kref, struct gss_auth, kref);
 738
 739         gss_free(gss_auth);
 740 }
 741
 742 static void
 743 gss_destroy(struct rpc_auth *auth)
 744 {
 745         struct gss_auth *gss_auth;
 746
 747         dprintk("RPC:       destroying GSS authenticator %p flavor %d\n",
 748                         auth, auth->au_flavor);
 749
 750         rpcauth_destroy_credcache(auth);
 751
 752         gss_auth = container_of(auth, struct gss_auth, rpc_auth);
 753         kref_put(&gss_auth->kref, gss_free_callback);
 754 }
 755
 756 /*
 757  * gss_destroying_context will cause the RPCSEC_GSS to send a NULL RPC call
 758  * to the server with the GSS control procedure field set to
 759  * RPC_GSS_PROC_DESTROY. This should normally cause the server to release
 760  * all RPCSEC_GSS state associated with that context.
 761  */
 762 static int
 763 gss_destroying_context(struct rpc_cred *cred)
 764 {
 765         struct gss_cred *gss_cred = container_of(cred, struct gss_cred, gc_base);
 766         struct gss_auth *gss_auth = container_of(cred->cr_auth, struct gss_auth, rpc_auth);
 767         struct rpc_task *task;
 768
 769         if (gss_cred->gc_ctx == NULL ||
 770             test_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags) == 0)
 771                 return 0;
 772
 773         gss_cred->gc_ctx->gc_proc = RPC_GSS_PROC_DESTROY;
 774         cred->cr_ops = &gss_nullops;
 775
 776         /* Take a reference to ensure the cred will be destroyed either
 777          * by the RPC call or by the put_rpccred() below */
 778         get_rpccred(cred);
 779
 780         task = rpc_call_null(gss_auth->client, cred, RPC_TASK_ASYNC|RPC_TASK_SOFT);
 781         if (!IS_ERR(task))
 782                 rpc_put_task(task);
 783
 784         put_rpccred(cred);
 785         return 1;
 786 }
 787
 788 /* gss_destroy_cred (and gss_free_ctx) are used to clean up after failure
 789  * to create a new cred or context, so they check that things have been
 790  * allocated before freeing them. */
 791 static void
 792 gss_do_free_ctx(struct gss_cl_ctx *ctx)
 793 {
 794         dprintk("RPC:       gss_free_ctx\n");
 795
 796         kfree(ctx->gc_wire_ctx.data);
 797         kfree(ctx);
 798 }
 799
 800 static void
 801 gss_free_ctx_callback(struct rcu_head *head)
 802 {
 803         struct gss_cl_ctx *ctx = container_of(head, struct gss_cl_ctx, gc_rcu);
 804         gss_do_free_ctx(ctx);
 805 }
 806
 807 static void
 808 gss_free_ctx(struct gss_cl_ctx *ctx)
 809 {
 810         struct gss_ctx *gc_gss_ctx;
 811
 812         gc_gss_ctx = rcu_dereference(ctx->gc_gss_ctx);
 813         rcu_assign_pointer(ctx->gc_gss_ctx, NULL);
 814         call_rcu(&ctx->gc_rcu, gss_free_ctx_callback);
 815         if (gc_gss_ctx)
 816                 gss_delete_sec_context(&gc_gss_ctx);
 817 }
 818
 819 static void
 820 gss_free_cred(struct gss_cred *gss_cred)
 821 {
 822         dprintk("RPC:       gss_free_cred %p\n", gss_cred);
 823         kfree(gss_cred);
 824 }
 825
 826 static void
 827 gss_free_cred_callback(struct rcu_head *head)
 828 {
 829         struct gss_cred *gss_cred = container_of(head, struct gss_cred, gc_base.cr_rcu);
 830         gss_free_cred(gss_cred);
 831 }
 832
 833 static void
 834 gss_destroy_nullcred(struct rpc_cred *cred)
 835 {
 836         struct gss_cred *gss_cred = container_of(cred, struct gss_cred, gc_base);
 837         struct gss_auth *gss_auth = container_of(cred->cr_auth, struct gss_auth, rpc_auth);
 838         struct gss_cl_ctx *ctx = gss_cred->gc_ctx;
 839
 840         rcu_assign_pointer(gss_cred->gc_ctx, NULL);
 841         call_rcu(&cred->cr_rcu, gss_free_cred_callback);
 842         if (ctx)
 843                 gss_put_ctx(ctx);
 844         kref_put(&gss_auth->kref, gss_free_callback);
 845 }
 846
 847 static void
 848 gss_destroy_cred(struct rpc_cred *cred)
 849 {
 850
 851         if (gss_destroying_context(cred))
 852                 return;
 853         gss_destroy_nullcred(cred);
 854 }
 855
 856 /*
 857  * Lookup RPCSEC_GSS cred for the current process
 858  */
 859 static struct rpc_cred *
 860 gss_lookup_cred(struct rpc_auth *auth, struct auth_cred *acred, int flags)
 861 {
 862         return rpcauth_lookup_credcache(auth, acred, flags);
 863 }
 864
 865 static struct rpc_cred *
 866 gss_create_cred(struct rpc_auth *auth, struct auth_cred *acred, int flags)
 867 {
 868         struct gss_auth *gss_auth = container_of(auth, struct gss_auth, rpc_auth);
 869         struct gss_cred *cred = NULL;
 870         int err = -ENOMEM;
 871
 872         dprintk("RPC:       gss_create_cred for uid %d, flavor %d\n",
 873                 acred->uid, auth->au_flavor);
 874
 875         if (!(cred = kzalloc(sizeof(*cred), GFP_NOFS)))
 876                 goto out_err;
 877
 878         rpcauth_init_cred(&cred->gc_base, acred, auth, &gss_credops);
 879         /*
 880          * Note: in order to force a call to call_refresh(), we deliberately
 881          * fail to flag the credential as RPCAUTH_CRED_UPTODATE.
 882          */
 883         cred->gc_base.cr_flags = 1UL << RPCAUTH_CRED_NEW;
 884         cred->gc_service = gss_auth->service;
 885         cred->gc_machine_cred = acred->machine_cred;
 886         kref_get(&gss_auth->kref);
 887         return &cred->gc_base;
 888
 889 out_err:
 890         dprintk("RPC:       gss_create_cred failed with error %d\n", err);
 891         return ERR_PTR(err);
 892 }
 893
 894 static int
 895 gss_cred_init(struct rpc_auth *auth, struct rpc_cred *cred)
 896 {
 897         struct gss_auth *gss_auth = container_of(auth, struct gss_auth, rpc_auth);
 898         struct gss_cred *gss_cred = container_of(cred,struct gss_cred, gc_base);
 899         int err;
 900
 901         do {
 902                 err = gss_create_upcall(gss_auth, gss_cred);
 903         } while (err == -EAGAIN);
 904         return err;
 905 }
 906
 907 static int
 908 gss_match(struct auth_cred *acred, struct rpc_cred *rc, int flags)
 909 {
 910         struct gss_cred *gss_cred = container_of(rc, struct gss_cred, gc_base);
 911
 912         if (test_bit(RPCAUTH_CRED_NEW, &rc->cr_flags))
 913                 goto out;
 914         /* Don't match with creds that have expired. */
 915         if (time_after(jiffies, gss_cred->gc_ctx->gc_expiry))
 916                 return 0;
 917         if (!test_bit(RPCAUTH_CRED_UPTODATE, &rc->cr_flags))
 918                 return 0;
 919 out:
 920         if (acred->machine_cred != gss_cred->gc_machine_cred)
 921                 return 0;
 922         return (rc->cr_uid == acred->uid);
 923 }
 924
 925 /*
 926 * Marshal credentials.
 927 * Maybe we should keep a cached credential for performance reasons.
 928 */
 929 static __be32 *
 930 gss_marshal(struct rpc_task *task, __be32 *p)
 931 {
 932         struct rpc_cred *cred = task->tk_msg.rpc_cred;
 933         struct gss_cred *gss_cred = container_of(cred, struct gss_cred,
 934                                                  gc_base);
 935         struct gss_cl_ctx       *ctx = gss_cred_get_ctx(cred);
 936         __be32          *cred_len;
 937         struct rpc_rqst *req = task->tk_rqstp;
 938         u32             maj_stat = 0;
 939         struct xdr_netobj mic;
 940         struct kvec     iov;
 941         struct xdr_buf  verf_buf;
 942
 943         dprintk("RPC: %5u gss_marshal\n", task->tk_pid);
 944
 945         *p++ = htonl(RPC_AUTH_GSS);
 946         cred_len = p++;
 947
 948         spin_lock(&ctx->gc_seq_lock);
 949         req->rq_seqno = ctx->gc_seq++;
 950         spin_unlock(&ctx->gc_seq_lock);
 951
 952         *p++ = htonl((u32) RPC_GSS_VERSION);
 953         *p++ = htonl((u32) ctx->gc_proc);
 954         *p++ = htonl((u32) req->rq_seqno);
 955         *p++ = htonl((u32) gss_cred->gc_service);
 956         p = xdr_encode_netobj(p, &ctx->gc_wire_ctx);
 957         *cred_len = htonl((p - (cred_len + 1)) << 2);
 958
 959         /* We compute the checksum for the verifier over the xdr-encoded bytes
 960          * starting with the xid and ending at the end of the credential: */
 961         iov.iov_base = xprt_skip_transport_header(task->tk_xprt,
 962                                         req->rq_snd_buf.head[0].iov_base);
 963         iov.iov_len = (u8 *)p - (u8 *)iov.iov_base;
 964         xdr_buf_from_iov(&iov, &verf_buf);
 965
 966         /* set verifier flavor*/
 967         *p++ = htonl(RPC_AUTH_GSS);
 968
 969         mic.data = (u8 *)(p + 1);
 970         maj_stat = gss_get_mic(ctx->gc_gss_ctx, &verf_buf, &mic);
 971         if (maj_stat == GSS_S_CONTEXT_EXPIRED) {
 972                 clear_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags);
 973         } else if (maj_stat != 0) {
 974                 printk("gss_marshal: gss_get_mic FAILED (%d)\n", maj_stat);
 975                 goto out_put_ctx;
 976         }
 977         p = xdr_encode_opaque(p, NULL, mic.len);
 978         gss_put_ctx(ctx);
 979         return p;
 980 out_put_ctx:
 981         gss_put_ctx(ctx);
 982         return NULL;
 983 }
 984
 985 static int gss_renew_cred(struct rpc_task *task)
 986 {
 987         struct rpc_cred *oldcred = task->tk_msg.rpc_cred;
 988         struct gss_cred *gss_cred = container_of(oldcred,
 989                                                  struct gss_cred,
 990                                                  gc_base);
 991         struct rpc_auth *auth = oldcred->cr_auth;
 992         struct auth_cred acred = {
 993                 .uid = oldcred->cr_uid,
 994                 .machine_cred = gss_cred->gc_machine_cred,
 995         };
 996         struct rpc_cred *new;
 997
 998         new = gss_lookup_cred(auth, &acred, RPCAUTH_LOOKUP_NEW);
 999         if (IS_ERR(new))
1000                 return PTR_ERR(new);
1001         task->tk_msg.rpc_cred = new;
1002         put_rpccred(oldcred);
1003         return 0;
1004 }
1005
1006 /*
1007 * Refresh credentials. XXX - finish
1008 */
1009 static int
1010 gss_refresh(struct rpc_task *task)
1011 {
1012         struct rpc_cred *cred = task->tk_msg.rpc_cred;
1013         int ret = 0;
1014
1015         if (!test_bit(RPCAUTH_CRED_NEW, &cred->cr_flags) &&
1016                         !test_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags)) {
1017                 ret = gss_renew_cred(task);
1018                 if (ret < 0)
1019                         goto out;
1020                 cred = task->tk_msg.rpc_cred;
1021         }
1022
1023         if (test_bit(RPCAUTH_CRED_NEW, &cred->cr_flags))
1024                 ret = gss_refresh_upcall(task);
1025 out:
1026         return ret;
1027 }
1028
1029 /* Dummy refresh routine: used only when destroying the context */
1030 static int
1031 gss_refresh_null(struct rpc_task *task)
1032 {
1033         return -EACCES;
1034 }
1035
1036 static __be32 *
1037 gss_validate(struct rpc_task *task, __be32 *p)
1038 {
1039         struct rpc_cred *cred = task->tk_msg.rpc_cred;
1040         struct gss_cl_ctx *ctx = gss_cred_get_ctx(cred);
1041         __be32          seq;
1042         struct kvec     iov;
1043         struct xdr_buf  verf_buf;
1044         struct xdr_netobj mic;
1045         u32             flav,len;
1046         u32             maj_stat;
1047
1048         dprintk("RPC: %5u gss_validate\n", task->tk_pid);
1049
1050         flav = ntohl(*p++);
1051         if ((len = ntohl(*p++)) > RPC_MAX_AUTH_SIZE)
1052                 goto out_bad;
1053         if (flav != RPC_AUTH_GSS)
1054                 goto out_bad;
1055         seq = htonl(task->tk_rqstp->rq_seqno);
1056         iov.iov_base = &seq;
1057         iov.iov_len = sizeof(seq);
1058         xdr_buf_from_iov(&iov, &verf_buf);
1059         mic.data = (u8 *)p;
1060         mic.len = len;
1061
1062         maj_stat = gss_verify_mic(ctx->gc_gss_ctx, &verf_buf, &mic);
1063         if (maj_stat == GSS_S_CONTEXT_EXPIRED)
1064                 clear_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags);
1065         if (maj_stat) {
1066                 dprintk("RPC: %5u gss_validate: gss_verify_mic returned "
1067                                 "error 0x%08x\n", task->tk_pid, maj_stat);
1068                 goto out_bad;
1069         }
1070         /* We leave it to unwrap to calculate au_rslack. For now we just
1071          * calculate the length of the verifier: */
1072         cred->cr_auth->au_verfsize = XDR_QUADLEN(len) + 2;
1073         gss_put_ctx(ctx);
1074         dprintk("RPC: %5u gss_validate: gss_verify_mic succeeded.\n",
1075                         task->tk_pid);
1076         return p + XDR_QUADLEN(len);
1077 out_bad:
1078         gss_put_ctx(ctx);
1079         dprintk("RPC: %5u gss_validate failed.\n", task->tk_pid);
1080         return NULL;
1081 }
1082
1083 static inline int
1084 gss_wrap_req_integ(struct rpc_cred *cred, struct gss_cl_ctx *ctx,
1085                 kxdrproc_t encode, struct rpc_rqst *rqstp, __be32 *p, void *obj)
1086 {
1087         struct xdr_buf  *snd_buf = &rqstp->rq_snd_buf;
1088         struct xdr_buf  integ_buf;
1089         __be32          *integ_len = NULL;
1090         struct xdr_netobj mic;
1091         u32             offset;
1092         __be32          *q;
1093         struct kvec     *iov;
1094         u32             maj_stat = 0;
1095         int             status = -EIO;
1096
1097         integ_len = p++;
1098         offset = (u8 *)p - (u8 *)snd_buf->head[0].iov_base;
1099         *p++ = htonl(rqstp->rq_seqno);
1100
1101         status = encode(rqstp, p, obj);
1102         if (status)
1103                 return status;
1104
1105         if (xdr_buf_subsegment(snd_buf, &integ_buf,
1106                                 offset, snd_buf->len - offset))
1107                 return status;
1108         *integ_len = htonl(integ_buf.len);
1109
1110         /* guess whether we're in the head or the tail: */
1111         if (snd_buf->page_len || snd_buf->tail[0].iov_len)
1112                 iov = snd_buf->tail;
1113         else
1114                 iov = snd_buf->head;
1115         p = iov->iov_base + iov->iov_len;
1116         mic.data = (u8 *)(p + 1);
1117
1118         maj_stat = gss_get_mic(ctx->gc_gss_ctx, &integ_buf, &mic);
1119         status = -EIO; /* XXX? */
1120         if (maj_stat == GSS_S_CONTEXT_EXPIRED)
1121                 clear_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags);
1122         else if (maj_stat)
1123                 return status;
1124         q = xdr_encode_opaque(p, NULL, mic.len);
1125
1126         offset = (u8 *)q - (u8 *)p;
1127         iov->iov_len += offset;
1128         snd_buf->len += offset;
1129         return 0;
1130 }
1131
1132 static void
1133 priv_release_snd_buf(struct rpc_rqst *rqstp)
1134 {
1135         int i;
1136
1137         for (i=0; i < rqstp->rq_enc_pages_num; i++)
1138                 __free_page(rqstp->rq_enc_pages[i]);
1139         kfree(rqstp->rq_enc_pages);
1140 }
1141
1142 static int
1143 alloc_enc_pages(struct rpc_rqst *rqstp)
1144 {
1145         struct xdr_buf *snd_buf = &rqstp->rq_snd_buf;
1146         int first, last, i;
1147
1148         if (snd_buf->page_len == 0) {
1149                 rqstp->rq_enc_pages_num = 0;
1150                 return 0;
1151         }
1152
1153         first = snd_buf->page_base >> PAGE_CACHE_SHIFT;
1154         last = (snd_buf->page_base + snd_buf->page_len - 1) >> PAGE_CACHE_SHIFT;
1155         rqstp->rq_enc_pages_num = last - first + 1 + 1;
1156         rqstp->rq_enc_pages
1157                 = kmalloc(rqstp->rq_enc_pages_num * sizeof(struct page *),
1158                                 GFP_NOFS);
1159         if (!rqstp->rq_enc_pages)
1160                 goto out;
1161         for (i=0; i < rqstp->rq_enc_pages_num; i++) {
1162                 rqstp->rq_enc_pages[i] = alloc_page(GFP_NOFS);
1163                 if (rqstp->rq_enc_pages[i] == NULL)
1164                         goto out_free;
1165         }
1166         rqstp->rq_release_snd_buf = priv_release_snd_buf;
1167         return 0;
1168 out_free:
1169         for (i--; i >= 0; i--) {
1170                 __free_page(rqstp->rq_enc_pages[i]);
1171         }
1172 out:
1173         return -EAGAIN;
1174 }
1175
1176 static inline int
1177 gss_wrap_req_priv(struct rpc_cred *cred, struct gss_cl_ctx *ctx,
1178                 kxdrproc_t encode, struct rpc_rqst *rqstp, __be32 *p, void *obj)
1179 {
1180         struct xdr_buf  *snd_buf = &rqstp->rq_snd_buf;
1181         u32             offset;
1182         u32             maj_stat;
1183         int             status;
1184         __be32          *opaque_len;
1185         struct page     **inpages;
1186         int             first;
1187         int             pad;
1188         struct kvec     *iov;
1189         char            *tmp;
1190
1191         opaque_len = p++;
1192         offset = (u8 *)p - (u8 *)snd_buf->head[0].iov_base;
1193         *p++ = htonl(rqstp->rq_seqno);
1194
1195         status = encode(rqstp, p, obj);
1196         if (status)
1197                 return status;
1198
1199         status = alloc_enc_pages(rqstp);
1200         if (status)
1201                 return status;
1202         first = snd_buf->page_base >> PAGE_CACHE_SHIFT;
1203         inpages = snd_buf->pages + first;
1204         snd_buf->pages = rqstp->rq_enc_pages;
1205         snd_buf->page_base -= first << PAGE_CACHE_SHIFT;
1206         /* Give the tail its own page, in case we need extra space in the
1207          * head when wrapping: */
1208         if (snd_buf->page_len || snd_buf->tail[0].iov_len) {
1209                 tmp = page_address(rqstp->rq_enc_pages[rqstp->rq_enc_pages_num - 1]);
1210                 memcpy(tmp, snd_buf->tail[0].iov_base, snd_buf->tail[0].iov_len);
1211                 snd_buf->tail[0].iov_base = tmp;
1212         }
1213         maj_stat = gss_wrap(ctx->gc_gss_ctx, offset, snd_buf, inpages);
1214         /* RPC_SLACK_SPACE should prevent this ever happening: */
1215         BUG_ON(snd_buf->len > snd_buf->buflen);
1216         status = -EIO;
1217         /* We're assuming that when GSS_S_CONTEXT_EXPIRED, the encryption was
1218          * done anyway, so it's safe to put the request on the wire: */
1219         if (maj_stat == GSS_S_CONTEXT_EXPIRED)
1220                 clear_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags);
1221         else if (maj_stat)
1222                 return status;
1223
1224         *opaque_len = htonl(snd_buf->len - offset);
1225         /* guess whether we're in the head or the tail: */
1226         if (snd_buf->page_len || snd_buf->tail[0].iov_len)
1227                 iov = snd_buf->tail;
1228         else
1229                 iov = snd_buf->head;
1230         p = iov->iov_base + iov->iov_len;
1231         pad = 3 - ((snd_buf->len - offset - 1) & 3);
1232         memset(p, 0, pad);
1233         iov->iov_len += pad;
1234         snd_buf->len += pad;
1235
1236         return 0;
1237 }
1238
1239 static int
1240 gss_wrap_req(struct rpc_task *task,
1241              kxdrproc_t encode, void *rqstp, __be32 *p, void *obj)
1242 {
1243         struct rpc_cred *cred = task->tk_msg.rpc_cred;
1244         struct gss_cred *gss_cred = container_of(cred, struct gss_cred,
1245                         gc_base);
1246         struct gss_cl_ctx *ctx = gss_cred_get_ctx(cred);
1247         int             status = -EIO;
1248
1249         dprintk("RPC: %5u gss_wrap_req\n", task->tk_pid);
1250         if (ctx->gc_proc != RPC_GSS_PROC_DATA) {
1251                 /* The spec seems a little ambiguous here, but I think that not
1252                  * wrapping context destruction requests makes the most sense.
1253                  */
1254                 status = encode(rqstp, p, obj);
1255                 goto out;
1256         }
1257         switch (gss_cred->gc_service) {
1258                 case RPC_GSS_SVC_NONE:
1259                         status = encode(rqstp, p, obj);
1260                         break;
1261                 case RPC_GSS_SVC_INTEGRITY:
1262                         status = gss_wrap_req_integ(cred, ctx, encode,
1263                                                                 rqstp, p, obj);
1264                         break;
1265                 case RPC_GSS_SVC_PRIVACY:
1266                         status = gss_wrap_req_priv(cred, ctx, encode,
1267                                         rqstp, p, obj);
1268                         break;
1269         }
1270 out:
1271         gss_put_ctx(ctx);
1272         dprintk("RPC: %5u gss_wrap_req returning %d\n", task->tk_pid, status);
1273         return status;
1274 }
1275
1276 static inline int
1277 gss_unwrap_resp_integ(struct rpc_cred *cred, struct gss_cl_ctx *ctx,
1278                 struct rpc_rqst *rqstp, __be32 **p)
1279 {
1280         struct xdr_buf  *rcv_buf = &rqstp->rq_rcv_buf;
1281         struct xdr_buf integ_buf;
1282         struct xdr_netobj mic;
1283         u32 data_offset, mic_offset;
1284         u32 integ_len;
1285         u32 maj_stat;
1286         int status = -EIO;
1287
1288         integ_len = ntohl(*(*p)++);
1289         if (integ_len & 3)
1290                 return status;
1291         data_offset = (u8 *)(*p) - (u8 *)rcv_buf->head[0].iov_base;
1292         mic_offset = integ_len + data_offset;
1293         if (mic_offset > rcv_buf->len)
1294                 return status;
1295         if (ntohl(*(*p)++) != rqstp->rq_seqno)
1296                 return status;
1297
1298         if (xdr_buf_subsegment(rcv_buf, &integ_buf, data_offset,
1299                                 mic_offset - data_offset))
1300                 return status;
1301
1302         if (xdr_buf_read_netobj(rcv_buf, &mic, mic_offset))
1303                 return status;
1304
1305         maj_stat = gss_verify_mic(ctx->gc_gss_ctx, &integ_buf, &mic);
1306         if (maj_stat == GSS_S_CONTEXT_EXPIRED)
1307                 clear_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags);
1308         if (maj_stat != GSS_S_COMPLETE)
1309                 return status;
1310         return 0;
1311 }
1312
1313 static inline int
1314 gss_unwrap_resp_priv(struct rpc_cred *cred, struct gss_cl_ctx *ctx,
1315                 struct rpc_rqst *rqstp, __be32 **p)
1316 {
1317         struct xdr_buf  *rcv_buf = &rqstp->rq_rcv_buf;
1318         u32 offset;
1319         u32 opaque_len;
1320         u32 maj_stat;
1321         int status = -EIO;
1322
1323         opaque_len = ntohl(*(*p)++);
1324         offset = (u8 *)(*p) - (u8 *)rcv_buf->head[0].iov_base;
1325         if (offset + opaque_len > rcv_buf->len)
1326                 return status;
1327         /* remove padding: */
1328         rcv_buf->len = offset + opaque_len;
1329
1330         maj_stat = gss_unwrap(ctx->gc_gss_ctx, offset, rcv_buf);
1331         if (maj_stat == GSS_S_CONTEXT_EXPIRED)
1332                 clear_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags);
1333         if (maj_stat != GSS_S_COMPLETE)
1334                 return status;
1335         if (ntohl(*(*p)++) != rqstp->rq_seqno)
1336                 return status;
1337
1338         return 0;
1339 }
1340
1341
1342 static int
1343 gss_unwrap_resp(struct rpc_task *task,
1344                 kxdrproc_t decode, void *rqstp, __be32 *p, void *obj)
1345 {
1346         struct rpc_cred *cred = task->tk_msg.rpc_cred;
1347         struct gss_cred *gss_cred = container_of(cred, struct gss_cred,
1348                         gc_base);
1349         struct gss_cl_ctx *ctx = gss_cred_get_ctx(cred);
1350         __be32          *savedp = p;
1351         struct kvec     *head = ((struct rpc_rqst *)rqstp)->rq_rcv_buf.head;
1352         int             savedlen = head->iov_len;
1353         int             status = -EIO;
1354
1355         if (ctx->gc_proc != RPC_GSS_PROC_DATA)
1356                 goto out_decode;
1357         switch (gss_cred->gc_service) {
1358                 case RPC_GSS_SVC_NONE:
1359                         break;
1360                 case RPC_GSS_SVC_INTEGRITY:
1361                         status = gss_unwrap_resp_integ(cred, ctx, rqstp, &p);
1362                         if (status)
1363                                 goto out;
1364                         break;
1365                 case RPC_GSS_SVC_PRIVACY:
1366                         status = gss_unwrap_resp_priv(cred, ctx, rqstp, &p);
1367                         if (status)
1368                                 goto out;
1369                         break;
1370         }
1371         /* take into account extra slack for integrity and privacy cases: */
1372         cred->cr_auth->au_rslack = cred->cr_auth->au_verfsize + (p - savedp)
1373                                                 + (savedlen - head->iov_len);
1374 out_decode:
1375         status = decode(rqstp, p, obj);
1376 out:
1377         gss_put_ctx(ctx);
1378         dprintk("RPC: %5u gss_unwrap_resp returning %d\n", task->tk_pid,
1379                         status);
1380         return status;
1381 }
1382
1383 static const struct rpc_authops authgss_ops = {
1384         .owner          = THIS_MODULE,
1385         .au_flavor      = RPC_AUTH_GSS,
1386         .au_name        = "RPCSEC_GSS",
1387         .create         = gss_create,
1388         .destroy        = gss_destroy,
1389         .lookup_cred    = gss_lookup_cred,
1390         .crcreate       = gss_create_cred
1391 };
1392
1393 static const struct rpc_credops gss_credops = {
1394         .cr_name        = "AUTH_GSS",
1395         .crdestroy      = gss_destroy_cred,
1396         .cr_init        = gss_cred_init,
1397         .crbind         = rpcauth_generic_bind_cred,
1398         .crmatch        = gss_match,
1399         .crmarshal      = gss_marshal,
1400         .crrefresh      = gss_refresh,
1401         .crvalidate     = gss_validate,
1402         .crwrap_req     = gss_wrap_req,
1403         .crunwrap_resp  = gss_unwrap_resp,
1404 };
1405
1406 static const struct rpc_credops gss_nullops = {
1407         .cr_name        = "AUTH_GSS",
1408         .crdestroy      = gss_destroy_nullcred,
1409         .crbind         = rpcauth_generic_bind_cred,
1410         .crmatch        = gss_match,
1411         .crmarshal      = gss_marshal,
1412         .crrefresh      = gss_refresh_null,
1413         .crvalidate     = gss_validate,
1414         .crwrap_req     = gss_wrap_req,
1415         .crunwrap_resp  = gss_unwrap_resp,
1416 };
1417
1418 static struct rpc_pipe_ops gss_upcall_ops = {
1419         .upcall         = gss_pipe_upcall,
1420         .downcall       = gss_pipe_downcall,
1421         .destroy_msg    = gss_pipe_destroy_msg,
1422         .open_pipe      = gss_pipe_open,
1423         .release_pipe   = gss_pipe_release,
1424 };
1425
1426 /*
1427  * Initialize RPCSEC_GSS module
1428  */
1429 static int __init init_rpcsec_gss(void)
1430 {
1431         int err = 0;
1432
1433         err = rpcauth_register(&authgss_ops);
1434         if (err)
1435                 goto out;
1436         err = gss_svc_init();
1437         if (err)
1438                 goto out_unregister;
1439         rpc_init_wait_queue(&pipe_version_rpc_waitqueue, "gss pipe version");
1440         return 0;
1441 out_unregister:
1442         rpcauth_unregister(&authgss_ops);
1443 out:
1444         return err;
1445 }
1446
1447 static void __exit exit_rpcsec_gss(void)
1448 {
1449         gss_svc_shutdown();
1450         rpcauth_unregister(&authgss_ops);
1451 }
1452
1453 MODULE_LICENSE("GPL");
1454 module_init(init_rpcsec_gss)
1455 module_exit(exit_rpcsec_gss)