/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * auth_none.c implements routines used to pass "null" credentials
 * and "null" verifiers in kernel RPC.
 */

#include <rpc/auth.h>

/*
 * Null authenticator operations vector
 */
static void     authnone_nextverf(AUTH *);
static bool_t   authnone_marshal(AUTH *, XDR *, struct cred *);
static bool_t   authnone_validate(AUTH *, struct opaque_auth *);
static bool_t   authnone_refresh(AUTH *, struct rpc_msg *, cred_t *);
static void     authnone_destroy(AUTH *);

static struct auth_ops auth_none_ops = {
        authnone_nextverf,
        authnone_marshal,
        authnone_validate,
        authnone_refresh,
        authnone_destroy,
        authany_wrap,
        authany_unwrap
};

/*
 * Create a kernel null style authenticator.
 * Returns an auth handle.
 */
AUTH *
authnone_create(void)
{
        /*
         * Allocate and set up auth handle
         */
        return (kmem_cache_alloc(authnone_cache, KM_SLEEP));
}

/*
 *  The constructor of the authnone_cache.
 */
/* ARGSUSED */
int
authnone_init(void *buf, void *cdrarg, int kmflags)
{
        AUTH *auth = (AUTH *)buf;

        auth->ah_ops = &auth_none_ops;

        /*
         * Flavor of RPC message's credential and verifier should be set to
         * AUTH_NONE. Opaque data associated with AUTH_NONE is undefined.
         * The length of the opaque data should be zero.
         *      oa_flavor = AUTH_NONE
         *      oa_base = NULL
         *      oa_length = 0
         */
        auth->ah_cred = auth->ah_verf = _null_auth;

        return (0);
}

/*
 * authnone operations
 */
/* ARGSUSED */
static void
authnone_nextverf(AUTH *auth)
{
        /* no action necessary */
}

/* ARGSUSED */
static bool_t
authnone_marshal(AUTH *auth, XDR *xdrs, struct cred *cr)
{
        int32_t *ptr;

        /*
         * auth_none has no opaque data. Encode auth_none
         * value with 0 len data for both cred and verf.
         * We first try a fast path to complete this operation.
         */
        ptr = XDR_INLINE(xdrs, 4 + 4 + 4 + 4);
        if (ptr) {
                IXDR_PUT_INT32(ptr, AUTH_NONE);
                IXDR_PUT_INT32(ptr, 0);
                IXDR_PUT_INT32(ptr, AUTH_NONE);
                IXDR_PUT_INT32(ptr, 0);
                return (TRUE);
        }

        /*
         * serialize AUTH_NONE credential and AUTH_NONE verifier
         */
        if ((xdr_opaque_auth(xdrs, &(auth->ah_cred))) &&
            (xdr_opaque_auth(xdrs, &(auth->ah_verf))))
                return (TRUE);
        else
                return (FALSE);
}

/* ARGSUSED */
static bool_t
authnone_validate(AUTH *auth, struct opaque_auth *verf)
{
        return (TRUE);
}

/* ARGSUSED */
static bool_t
authnone_refresh(AUTH *auth, struct rpc_msg *msg, cred_t *cr)
{
        return (FALSE);
}

static void
authnone_destroy(AUTH *auth)
{
        kmem_cache_free(authnone_cache, auth);
}