/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright 2017 RackTop Systems.
 */

#include <sys/systm.h>
#include <sys/sdt.h>
#include <rpc/types.h>
#include <rpc/auth.h>
#include <rpc/auth_unix.h>
#include <rpc/auth_des.h>
#include <rpc/svc.h>
#include <rpc/xdr.h>
#include <nfs/nfs4.h>
#include <nfs/nfs_dispatch.h>
#include <sys/cmn_err.h>
#include <sys/modctl.h>

static void
rfs4_err_resp(COMPOUND4args *args, COMPOUND4res *resp, nfsstat4 err)
{
        size_t  sz;

        resp->array_len = 1;
        sz = resp->array_len * sizeof (nfs_resop4);
        resp->array = kmem_zalloc(sz, KM_SLEEP);

        resp->array[0].resop = args->array[0].argop;
        resp->status = resp->array[0].nfs_resop4_u.opillegal.status = err;
}

/*
 * The function checks if given compound operation is allowed
 * to be the very fist operation in compound array.
 */
static bool_t
valid_first_compound_op(nfs_opnum4 op)
{
        if (op == OP_BIND_CONN_TO_SESSION       ||
            op == OP_SEQUENCE                   ||
            op == OP_EXCHANGE_ID                ||
            op == OP_CREATE_SESSION             ||
            op == OP_DESTROY_SESSION            ||
            op == OP_DESTROY_CLIENTID           ||
            op == OP_ILLEGAL)
                return (TRUE);

        return (FALSE);
}

/*
 * The function verifies arguments passed to mds_op_compound.
 * If agrguments are valid, NFS4_OK is returned, otherwise
 * function returns correspoinding NFS4 error code.
 */
static nfsstat4
verify_compound_args(COMPOUND4args *args)
{
        if (args->array_len == 0)
                return (NFS4_OK);

        if (!valid_first_compound_op(args->array[0].argop))
                return (NFS4ERR_OP_NOT_IN_SESSION);

        if (args->array_len > 1 && args->array[0].argop != OP_SEQUENCE) {
                /*
                 * Compound is outside the session. There must be
                 * only one operation in request.
                 */
                return (NFS4ERR_NOT_ONLY_OP);
        }

        return (NFS4_OK);
}

static void
rfs4x_dispatch_done(compound_state_t *cs)
{
        if (cs->slot)
                rfs4x_sequence_done(cs->cmpresp, cs);
        else {
                rfs4_compound_free(cs->cmpresp);
        }
        cs->cs_flags |= RFS4_DISPATCH_DONE;
}

static bool_t
xdr_compound_wrapper(XDR *xdrs, compound_state_t *cs)
{
        COMPOUND4res *resp = cs->cmpresp;
        bool_t res = FALSE;
        bool_t isreal = (xdrs->x_handy != 0);    /* real data encoding ? */

        if (!(cs->cs_flags & RFS4_DISPATCH_DONE)) {
                res = xdr_COMPOUND4res_srv(xdrs, resp);
                if (isreal)
                        rfs4x_dispatch_done(cs);
        }

        return (res);
}

int
rfs4x_dispatch(struct svc_req *req, SVCXPRT *xprt, char *ap)
{
        struct compound_state cs;
        COMPOUND4res res_buf;
        COMPOUND4res *rbp;
        COMPOUND4args   *cap;
        int rpcerr = 0;
        nfsstat4 error;

        bzero(&res_buf, sizeof (COMPOUND4res));
        rbp = &res_buf;
        cap = (COMPOUND4args *)ap;
        rfs4_init_compound_state(&cs);

        cs.statusp = &error;
        cs.cmpresp = rbp;

        error = verify_compound_args(cap);
        if (error != NFS4_OK) {
                rfs4_err_resp(cap, rbp, error);
                goto out_send;
        }

        error = rfs4x_sequence_prep(cap, rbp, &cs, xprt);
        if (error != NFS4_OK) {
                if (error != nfserr_replay_cache)
                        rfs4_err_resp(cap, rbp, error);
                goto out_send;
        }

        /* Regular processing */
        curthread->t_flag |= T_DONTPEND;
        rfs4_compound(cap, rbp, &cs, req, &rpcerr);
        curthread->t_flag &= ~T_DONTPEND;

        /*
         * On RPC error, short sendreply
         */
        if (rpcerr) {
                goto out_free;
        }

        if (curthread->t_flag & T_WOULDBLOCK) {
                curthread->t_flag &= ~T_WOULDBLOCK;
                error = 1;
                goto out_free;
        }

out_send:
        if (!svc_sendreply(xprt, xdr_compound_wrapper, (char *)&cs)) {
                DTRACE_PROBE2(sendfail, SVCXPRT *, xprt,
                    compound_state_t *, &cs);
                svcerr_systemerr(xprt);
                rpcerr = 1;
        }

out_free:
        if (!(cs.cs_flags & RFS4_DISPATCH_DONE)) {
                rfs4x_dispatch_done(&cs);
        }

        rfs4_fini_compound_state(&cs);
        return ((error != NFS4_OK || rpcerr) ? 1 : 0);
}