Subversion Repositories or1k_soc_on_altera_embedded_dev_kit

/*

 * linux/net/sunrpc/auth_gss/auth_gss.c

 *

 * RPCSEC_GSS client authentication.

 *

 *  Copyright (c) 2000 The Regents of the University of Michigan.

 *  All rights reserved.

 *

 *  Dug Song       <dugsong@monkey.org>

 *  Andy Adamson   <andros@umich.edu>

 *

 *  Redistribution and use in source and binary forms, with or without

 *  modification, are permitted provided that the following conditions

 *  are met:

 *

 *  1. Redistributions of source code must retain the above copyright

 *     notice, this list of conditions and the following disclaimer.

 *  2. Redistributions in binary form must reproduce the above copyright

 *     notice, this list of conditions and the following disclaimer in the

 *     documentation and/or other materials provided with the distribution.

 *  3. Neither the name of the University nor the names of its

 *     contributors may be used to endorse or promote products derived

 *     from this software without specific prior written permission.

 *

 *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED

 *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF

 *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

 *  DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE

 *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

 *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

 *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR

 *  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

 *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

 *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

 *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 *

 * $Id$

 */

#include <linux/module.h>

#include <linux/init.h>

#include <linux/types.h>

#include <linux/slab.h>

#include <linux/sched.h>

#include <linux/pagemap.h>

#include <linux/sunrpc/clnt.h>

#include <linux/sunrpc/auth.h>

#include <linux/sunrpc/auth_gss.h>

#include <linux/sunrpc/svcauth_gss.h>

#include <linux/sunrpc/gss_err.h>

#include <linux/workqueue.h>

#include <linux/sunrpc/rpc_pipe_fs.h>

#include <linux/sunrpc/gss_api.h>

#include <asm/uaccess.h>

static const struct rpc_authops authgss_ops;

static const struct rpc_credops gss_credops;

static const struct rpc_credops gss_nullops;

#ifdef RPC_DEBUG

# define RPCDBG_FACILITY        RPCDBG_AUTH

#endif

#define NFS_NGROUPS     16

#define GSS_CRED_SLACK          1024            /* XXX: unused */

/* length of a krb5 verifier (48), plus data added before arguments when

 * using integrity (two 4-byte integers): */

#define GSS_VERF_SLACK          100

/* XXX this define must match the gssd define

* as it is passed to gssd to signal the use of

* machine creds should be part of the shared rpc interface */

#define CA_RUN_AS_MACHINE  0x00000200

/* dump the buffer in `emacs-hexl' style */

#define isprint(c)      ((c > 0x1f) && (c < 0x7f))

struct gss_auth {

        struct kref kref;

        struct rpc_auth rpc_auth;

        struct gss_api_mech *mech;

        enum rpc_gss_svc service;

        struct rpc_clnt *client;

        struct dentry *dentry;

};

static void gss_free_ctx(struct gss_cl_ctx *);

static struct rpc_pipe_ops gss_upcall_ops;

static inline struct gss_cl_ctx *

gss_get_ctx(struct gss_cl_ctx *ctx)

{

        atomic_inc(&ctx->count);

        return ctx;

}

static inline void

gss_put_ctx(struct gss_cl_ctx *ctx)

{

        if (atomic_dec_and_test(&ctx->count))

                gss_free_ctx(ctx);

}

/* gss_cred_set_ctx:

 * called by gss_upcall_callback and gss_create_upcall in order

 * to set the gss context. The actual exchange of an old context

 * and a new one is protected by the inode->i_lock.

 */

static void

gss_cred_set_ctx(struct rpc_cred *cred, struct gss_cl_ctx *ctx)

{

        struct gss_cred *gss_cred = container_of(cred, struct gss_cred, gc_base);

        struct gss_cl_ctx *old;

        old = gss_cred->gc_ctx;

        rcu_assign_pointer(gss_cred->gc_ctx, ctx);

        set_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags);

        clear_bit(RPCAUTH_CRED_NEW, &cred->cr_flags);

        if (old)

                gss_put_ctx(old);

}

static int

gss_cred_is_uptodate_ctx(struct rpc_cred *cred)

{

        struct gss_cred *gss_cred = container_of(cred, struct gss_cred, gc_base);

        int res = 0;

        rcu_read_lock();

        if (test_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags) && gss_cred->gc_ctx)

                res = 1;

        rcu_read_unlock();

        return res;

}

static const void *

simple_get_bytes(const void *p, const void *end, void *res, size_t len)

{

        const void *q = (const void *)((const char *)p + len);

        if (unlikely(q > end || q < p))

                return ERR_PTR(-EFAULT);

        memcpy(res, p, len);

        return q;

}

static inline const void *

simple_get_netobj(const void *p, const void *end, struct xdr_netobj *dest)

{

        const void *q;

        unsigned int len;

        p = simple_get_bytes(p, end, &len, sizeof(len));

        if (IS_ERR(p))

                return p;

        q = (const void *)((const char *)p + len);

        if (unlikely(q > end || q < p))

                return ERR_PTR(-EFAULT);

        dest->data = kmemdup(p, len, GFP_KERNEL);

        if (unlikely(dest->data == NULL))

                return ERR_PTR(-ENOMEM);

        dest->len = len;

        return q;

}

static struct gss_cl_ctx *

gss_cred_get_ctx(struct rpc_cred *cred)

{

        struct gss_cred *gss_cred = container_of(cred, struct gss_cred, gc_base);

        struct gss_cl_ctx *ctx = NULL;

        rcu_read_lock();

        if (gss_cred->gc_ctx)

                ctx = gss_get_ctx(gss_cred->gc_ctx);

        rcu_read_unlock();

        return ctx;

}

static struct gss_cl_ctx *

gss_alloc_context(void)

{

        struct gss_cl_ctx *ctx;

        ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);

        if (ctx != NULL) {

                ctx->gc_proc = RPC_GSS_PROC_DATA;

                ctx->gc_seq = 1;        /* NetApp 6.4R1 doesn't accept seq. no. 0 */

                spin_lock_init(&ctx->gc_seq_lock);

                atomic_set(&ctx->count,1);

        }

        return ctx;

}

#define GSSD_MIN_TIMEOUT (60 * 60)

static const void *

gss_fill_context(const void *p, const void *end, struct gss_cl_ctx *ctx, struct gss_api_mech *gm)

{

        const void *q;

        unsigned int seclen;

        unsigned int timeout;

        u32 window_size;

        int ret;

        /* First unsigned int gives the lifetime (in seconds) of the cred */

        p = simple_get_bytes(p, end, &timeout, sizeof(timeout));

        if (IS_ERR(p))

                goto err;

        if (timeout == 0)

                timeout = GSSD_MIN_TIMEOUT;

        ctx->gc_expiry = jiffies + (unsigned long)timeout * HZ * 3 / 4;

        /* Sequence number window. Determines the maximum number of simultaneous requests */

        p = simple_get_bytes(p, end, &window_size, sizeof(window_size));

        if (IS_ERR(p))

                goto err;

        ctx->gc_win = window_size;

        /* gssd signals an error by passing ctx->gc_win = 0: */

        if (ctx->gc_win == 0) {

                /* in which case, p points to  an error code which we ignore */

                p = ERR_PTR(-EACCES);

                goto err;

        }

        /* copy the opaque wire context */

        p = simple_get_netobj(p, end, &ctx->gc_wire_ctx);

        if (IS_ERR(p))

                goto err;

        /* import the opaque security context */

        p  = simple_get_bytes(p, end, &seclen, sizeof(seclen));

        if (IS_ERR(p))

                goto err;

        q = (const void *)((const char *)p + seclen);

        if (unlikely(q > end || q < p)) {

                p = ERR_PTR(-EFAULT);

                goto err;

        }

        ret = gss_import_sec_context(p, seclen, gm, &ctx->gc_gss_ctx);

        if (ret < 0) {

                p = ERR_PTR(ret);

                goto err;

        }

        return q;

err:

        dprintk("RPC:       gss_fill_context returning %ld\n", -PTR_ERR(p));

        return p;

}

struct gss_upcall_msg {

        atomic_t count;

        uid_t   uid;

        struct rpc_pipe_msg msg;

        struct list_head list;

        struct gss_auth *auth;

        struct rpc_wait_queue rpc_waitqueue;

        wait_queue_head_t waitqueue;

        struct gss_cl_ctx *ctx;

};

static void

gss_release_msg(struct gss_upcall_msg *gss_msg)

{

        if (!atomic_dec_and_test(&gss_msg->count))

                return;

        BUG_ON(!list_empty(&gss_msg->list));

        if (gss_msg->ctx != NULL)

                gss_put_ctx(gss_msg->ctx);

        kfree(gss_msg);

}

static struct gss_upcall_msg *

__gss_find_upcall(struct rpc_inode *rpci, uid_t uid)

{

        struct gss_upcall_msg *pos;

        list_for_each_entry(pos, &rpci->in_downcall, list) {

                if (pos->uid != uid)

                        continue;

                atomic_inc(&pos->count);

                dprintk("RPC:       gss_find_upcall found msg %p\n", pos);

                return pos;

        }

        dprintk("RPC:       gss_find_upcall found nothing\n");

        return NULL;

}

/* Try to add a upcall to the pipefs queue.

 * If an upcall owned by our uid already exists, then we return a reference

 * to that upcall instead of adding the new upcall.

 */

static inline struct gss_upcall_msg *

gss_add_msg(struct gss_auth *gss_auth, struct gss_upcall_msg *gss_msg)

{

        struct inode *inode = gss_auth->dentry->d_inode;

        struct rpc_inode *rpci = RPC_I(inode);

        struct gss_upcall_msg *old;

        spin_lock(&inode->i_lock);

        old = __gss_find_upcall(rpci, gss_msg->uid);

        if (old == NULL) {

                atomic_inc(&gss_msg->count);

                list_add(&gss_msg->list, &rpci->in_downcall);

        } else

                gss_msg = old;

        spin_unlock(&inode->i_lock);

        return gss_msg;

}

static void

__gss_unhash_msg(struct gss_upcall_msg *gss_msg)

{

        list_del_init(&gss_msg->list);

        rpc_wake_up_status(&gss_msg->rpc_waitqueue, gss_msg->msg.errno);

        wake_up_all(&gss_msg->waitqueue);

        atomic_dec(&gss_msg->count);

}

static void

gss_unhash_msg(struct gss_upcall_msg *gss_msg)

{

        struct gss_auth *gss_auth = gss_msg->auth;

        struct inode *inode = gss_auth->dentry->d_inode;

        if (list_empty(&gss_msg->list))

                return;

        spin_lock(&inode->i_lock);

        if (!list_empty(&gss_msg->list))

                __gss_unhash_msg(gss_msg);

        spin_unlock(&inode->i_lock);

}

static void

gss_upcall_callback(struct rpc_task *task)

{

        struct gss_cred *gss_cred = container_of(task->tk_msg.rpc_cred,

                        struct gss_cred, gc_base);

        struct gss_upcall_msg *gss_msg = gss_cred->gc_upcall;

        struct inode *inode = gss_msg->auth->dentry->d_inode;

        spin_lock(&inode->i_lock);

        if (gss_msg->ctx)

                gss_cred_set_ctx(task->tk_msg.rpc_cred, gss_get_ctx(gss_msg->ctx));

        else

                task->tk_status = gss_msg->msg.errno;

        gss_cred->gc_upcall = NULL;

        rpc_wake_up_status(&gss_msg->rpc_waitqueue, gss_msg->msg.errno);

        spin_unlock(&inode->i_lock);

        gss_release_msg(gss_msg);

}

static inline struct gss_upcall_msg *

gss_alloc_msg(struct gss_auth *gss_auth, uid_t uid)

{

        struct gss_upcall_msg *gss_msg;

        gss_msg = kzalloc(sizeof(*gss_msg), GFP_KERNEL);

        if (gss_msg != NULL) {

                INIT_LIST_HEAD(&gss_msg->list);

                rpc_init_wait_queue(&gss_msg->rpc_waitqueue, "RPCSEC_GSS upcall waitq");

                init_waitqueue_head(&gss_msg->waitqueue);

                atomic_set(&gss_msg->count, 1);

                gss_msg->msg.data = &gss_msg->uid;

                gss_msg->msg.len = sizeof(gss_msg->uid);

                gss_msg->uid = uid;

                gss_msg->auth = gss_auth;

        }

        return gss_msg;

}

static struct gss_upcall_msg *

gss_setup_upcall(struct rpc_clnt *clnt, struct gss_auth *gss_auth, struct rpc_cred *cred)

{

        struct gss_upcall_msg *gss_new, *gss_msg;

        gss_new = gss_alloc_msg(gss_auth, cred->cr_uid);

        if (gss_new == NULL)

                return ERR_PTR(-ENOMEM);

        gss_msg = gss_add_msg(gss_auth, gss_new);

        if (gss_msg == gss_new) {

                int res = rpc_queue_upcall(gss_auth->dentry->d_inode, &gss_new->msg);

                if (res) {

                        gss_unhash_msg(gss_new);

                        gss_msg = ERR_PTR(res);

                }

        } else

                gss_release_msg(gss_new);

        return gss_msg;

}

static inline int

gss_refresh_upcall(struct rpc_task *task)

{

        struct rpc_cred *cred = task->tk_msg.rpc_cred;

        struct gss_auth *gss_auth = container_of(cred->cr_auth,

                        struct gss_auth, rpc_auth);

        struct gss_cred *gss_cred = container_of(cred,

                        struct gss_cred, gc_base);

        struct gss_upcall_msg *gss_msg;

        struct inode *inode = gss_auth->dentry->d_inode;

        int err = 0;

        dprintk("RPC: %5u gss_refresh_upcall for uid %u\n", task->tk_pid,

                                                                cred->cr_uid);

        gss_msg = gss_setup_upcall(task->tk_client, gss_auth, cred);

        if (IS_ERR(gss_msg)) {

                err = PTR_ERR(gss_msg);

                goto out;

        }

        spin_lock(&inode->i_lock);

        if (gss_cred->gc_upcall != NULL)

                rpc_sleep_on(&gss_cred->gc_upcall->rpc_waitqueue, task, NULL, NULL);

        else if (gss_msg->ctx == NULL && gss_msg->msg.errno >= 0) {

                task->tk_timeout = 0;

                gss_cred->gc_upcall = gss_msg;

                /* gss_upcall_callback will release the reference to gss_upcall_msg */

                atomic_inc(&gss_msg->count);

                rpc_sleep_on(&gss_msg->rpc_waitqueue, task, gss_upcall_callback, NULL);

        } else

                err = gss_msg->msg.errno;

        spin_unlock(&inode->i_lock);

        gss_release_msg(gss_msg);

out:

        dprintk("RPC: %5u gss_refresh_upcall for uid %u result %d\n",

                        task->tk_pid, cred->cr_uid, err);

        return err;

}

static inline int

gss_create_upcall(struct gss_auth *gss_auth, struct gss_cred *gss_cred)

{

        struct inode *inode = gss_auth->dentry->d_inode;

        struct rpc_cred *cred = &gss_cred->gc_base;

        struct gss_upcall_msg *gss_msg;

        DEFINE_WAIT(wait);

        int err = 0;

        dprintk("RPC:       gss_upcall for uid %u\n", cred->cr_uid);

        gss_msg = gss_setup_upcall(gss_auth->client, gss_auth, cred);

        if (IS_ERR(gss_msg)) {

                err = PTR_ERR(gss_msg);

                goto out;

        }

        for (;;) {

                prepare_to_wait(&gss_msg->waitqueue, &wait, TASK_INTERRUPTIBLE);

                spin_lock(&inode->i_lock);

                if (gss_msg->ctx != NULL || gss_msg->msg.errno < 0) {

                        break;

                }

                spin_unlock(&inode->i_lock);

                if (signalled()) {

                        err = -ERESTARTSYS;

                        goto out_intr;

                }

                schedule();

        }

        if (gss_msg->ctx)

                gss_cred_set_ctx(cred, gss_get_ctx(gss_msg->ctx));

        else

                err = gss_msg->msg.errno;

        spin_unlock(&inode->i_lock);

out_intr:

        finish_wait(&gss_msg->waitqueue, &wait);

        gss_release_msg(gss_msg);

out:

        dprintk("RPC:       gss_create_upcall for uid %u result %d\n",

                        cred->cr_uid, err);

        return err;

}

static ssize_t

gss_pipe_upcall(struct file *filp, struct rpc_pipe_msg *msg,

                char __user *dst, size_t buflen)

{

        char *data = (char *)msg->data + msg->copied;

        ssize_t mlen = msg->len;

        ssize_t left;

        if (mlen > buflen)

                mlen = buflen;

        left = copy_to_user(dst, data, mlen);

        if (left < 0) {

                msg->errno = left;

                return left;

        }

        mlen -= left;

        msg->copied += mlen;

        msg->errno = 0;

        return mlen;

}

#define MSG_BUF_MAXSIZE 1024

static ssize_t

gss_pipe_downcall(struct file *filp, const char __user *src, size_t mlen)

{

        const void *p, *end;

        void *buf;

        struct rpc_clnt *clnt;

        struct gss_upcall_msg *gss_msg;

        struct inode *inode = filp->f_path.dentry->d_inode;

        struct gss_cl_ctx *ctx;

        uid_t uid;

        ssize_t err = -EFBIG;

        if (mlen > MSG_BUF_MAXSIZE)

                goto out;

        err = -ENOMEM;

        buf = kmalloc(mlen, GFP_KERNEL);

        if (!buf)

                goto out;

        clnt = RPC_I(inode)->private;

        err = -EFAULT;

        if (copy_from_user(buf, src, mlen))

                goto err;

        end = (const void *)((char *)buf + mlen);

        p = simple_get_bytes(buf, end, &uid, sizeof(uid));

        if (IS_ERR(p)) {

                err = PTR_ERR(p);

                goto err;

        }

        err = -ENOMEM;

        ctx = gss_alloc_context();

        if (ctx == NULL)

                goto err;

        err = -ENOENT;

        /* Find a matching upcall */

        spin_lock(&inode->i_lock);

        gss_msg = __gss_find_upcall(RPC_I(inode), uid);

        if (gss_msg == NULL) {

                spin_unlock(&inode->i_lock);

                goto err_put_ctx;

        }

        list_del_init(&gss_msg->list);

        spin_unlock(&inode->i_lock);

        p = gss_fill_context(p, end, ctx, gss_msg->auth->mech);

        if (IS_ERR(p)) {

                err = PTR_ERR(p);

                gss_msg->msg.errno = (err == -EAGAIN) ? -EAGAIN : -EACCES;

                goto err_release_msg;

        }

        gss_msg->ctx = gss_get_ctx(ctx);

        err = mlen;

err_release_msg:

        spin_lock(&inode->i_lock);

        __gss_unhash_msg(gss_msg);

        spin_unlock(&inode->i_lock);

        gss_release_msg(gss_msg);

err_put_ctx:

        gss_put_ctx(ctx);

err:

        kfree(buf);

out:

        dprintk("RPC:       gss_pipe_downcall returning %Zd\n", err);

        return err;

}

static void

gss_pipe_release(struct inode *inode)

{

        struct rpc_inode *rpci = RPC_I(inode);

        struct gss_upcall_msg *gss_msg;

        spin_lock(&inode->i_lock);

        while (!list_empty(&rpci->in_downcall)) {

                gss_msg = list_entry(rpci->in_downcall.next,

                                struct gss_upcall_msg, list);

                gss_msg->msg.errno = -EPIPE;

                atomic_inc(&gss_msg->count);

                __gss_unhash_msg(gss_msg);

                spin_unlock(&inode->i_lock);

                gss_release_msg(gss_msg);

                spin_lock(&inode->i_lock);

        }

        spin_unlock(&inode->i_lock);

}

static void

gss_pipe_destroy_msg(struct rpc_pipe_msg *msg)

{

        struct gss_upcall_msg *gss_msg = container_of(msg, struct gss_upcall_msg, msg);

        static unsigned long ratelimit;

        if (msg->errno < 0) {

                dprintk("RPC:       gss_pipe_destroy_msg releasing msg %p\n",

                                gss_msg);

                atomic_inc(&gss_msg->count);

                gss_unhash_msg(gss_msg);

                if (msg->errno == -ETIMEDOUT) {

                        unsigned long now = jiffies;

                        if (time_after(now, ratelimit)) {

                                printk(KERN_WARNING "RPC: AUTH_GSS upcall timed out.\n"

                                                    "Please check user daemon is running!\n");

                                ratelimit = now + 15*HZ;

                        }

                }

                gss_release_msg(gss_msg);

        }

}

/*

 * NOTE: we have the opportunity to use different

 * parameters based on the input flavor (which must be a pseudoflavor)

 */

static struct rpc_auth *

gss_create(struct rpc_clnt *clnt, rpc_authflavor_t flavor)

{

        struct gss_auth *gss_auth;

        struct rpc_auth * auth;

        int err = -ENOMEM; /* XXX? */

        dprintk("RPC:       creating GSS authenticator for client %p\n", clnt);

        if (!try_module_get(THIS_MODULE))

                return ERR_PTR(err);

        if (!(gss_auth = kmalloc(sizeof(*gss_auth), GFP_KERNEL)))

                goto out_dec;

        gss_auth->client = clnt;

        err = -EINVAL;

        gss_auth->mech = gss_mech_get_by_pseudoflavor(flavor);

        if (!gss_auth->mech) {

                printk(KERN_WARNING "%s: Pseudoflavor %d not found!\n",

                                __FUNCTION__, flavor);

                goto err_free;

        }

        gss_auth->service = gss_pseudoflavor_to_service(gss_auth->mech, flavor);

        if (gss_auth->service == 0)

                goto err_put_mech;

        auth = &gss_auth->rpc_auth;

        auth->au_cslack = GSS_CRED_SLACK >> 2;

        auth->au_rslack = GSS_VERF_SLACK >> 2;

        auth->au_ops = &authgss_ops;

        auth->au_flavor = flavor;

        atomic_set(&auth->au_count, 1);

        kref_init(&gss_auth->kref);

        gss_auth->dentry = rpc_mkpipe(clnt->cl_dentry, gss_auth->mech->gm_name,

                        clnt, &gss_upcall_ops, RPC_PIPE_WAIT_FOR_OPEN);

        if (IS_ERR(gss_auth->dentry)) {