/*
 * 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 (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
 * Copyright 2021 Tintri by DDN, Inc. All rights reserved.
 */

#include <assert.h>
#include <strings.h>
#include <sys/param.h>
#include <sys/debug.h>

#include <libmlrpc.h>

#ifdef _BIG_ENDIAN
static const int ndr_native_byte_order = NDR_REPLAB_INTG_BIG_ENDIAN;
#else
static const int ndr_native_byte_order = NDR_REPLAB_INTG_LITTLE_ENDIAN;
#endif

static int ndr_decode_hdr_common(ndr_stream_t *, ndr_common_header_t *);
static int ndr_decode_pac_hdr(ndr_stream_t *, ndr_pac_hdr_t *);

/*
 * This is the layout of an RPC PDU, as shown in
 * [MS-RPCE] 2.2.2.13 "Verification Trailer".
 *
 *      +-------------------------------+
 *      |       PDU Header              |
 *      +-------------------------------+ ====
 *      |       Stub Data               |
 *      +-------------------------------+ PDU
 *      |       Stub Padding Octets     |
 *      +-------------------------------+ Body
 *      |       Verification Trailer    |
 *      +-------------------------------+ Here
 *      |       Authentication Padding  |
 *      +-------------------------------+ ====
 *      |       sec_trailer             |
 *      +-------------------------------+
 *      |       Authentication Token    |
 *      +-------------------------------+
 *
 * We don't use the "Verification Trailer" for anything yet.
 * sec_trailer and Authentication Token are for Secure RPC,
 * and are collectively the 'auth_verifier_co' in DCERPC.
 *
 * Each fragment of a multi-fragment response has a unique
 * header and, if authentication was requested, a unique
 * sec_trailer.
 */

static int
ndr_convert_nds_error(ndr_stream_t *nds)
{
        int rc;

        switch (nds->error) {
        case NDR_ERR_MALLOC_FAILED:
                rc = NDR_DRC_FAULT_OUT_OF_MEMORY;
                break;

        case NDR_ERR_SWITCH_VALUE_INVALID:
                rc = NDR_DRC_FAULT_PARAM_0_INVALID;
                break;

        case NDR_ERR_UNDERFLOW:
                rc = NDR_DRC_FAULT_RECEIVED_RUNT;
                break;

        case NDR_ERR_GROW_FAILED:
                rc = NDR_DRC_FAULT_ENCODE_TOO_BIG;
                break;

        default:
                if (nds->m_op == NDR_M_OP_MARSHALL)
                        rc = NDR_DRC_FAULT_ENCODE_FAILED;
                else
                        rc = NDR_DRC_FAULT_DECODE_FAILED;
                break;
        }

        return (rc);
}

static int
ndr_encode_decode_common(ndr_stream_t *nds, unsigned opnum,
    ndr_typeinfo_t *ti, void *datum)
{
        /*
         * Perform the (un)marshalling
         */
        if (ndo_operation(nds, ti, opnum, datum))
                return (NDR_DRC_OK);

        return (ndr_convert_nds_error(nds));
}

static int
ndr_encode_decode_type(ndr_stream_t *nds, ndr_typeinfo_t *ti, void *datum)
{
        /*
         * Perform the (un)marshalling
         */
        if (ndo_process(nds, ti, datum))
                return (NDR_DRC_OK);

        return (ndr_convert_nds_error(nds));
}

ndr_buf_t *
ndr_buf_init(ndr_typeinfo_t *ti)
{
        ndr_buf_t               *nbuf;

        if ((nbuf = calloc(1, sizeof (ndr_buf_t))) == NULL)
                return (NULL);

        if ((nbuf->nb_heap = ndr_heap_create()) == NULL) {
                free(nbuf);
                return (NULL);
        }

        nbuf->nb_ti = ti;
        nbuf->nb_magic = NDR_BUF_MAGIC;
        return (nbuf);
}

void
ndr_buf_fini(ndr_buf_t *nbuf)
{
        assert(nbuf->nb_magic == NDR_BUF_MAGIC);

        nds_destruct(&nbuf->nb_nds);
        ndr_heap_destroy(nbuf->nb_heap);
        nbuf->nb_magic = 0;
        free(nbuf);
}

/*
 * Decode an NDR encoded buffer.  The buffer is expected to contain
 * a single fragment packet with a valid PDU header followed by NDR
 * encoded data.  The structure to which result points should be
 * of the appropriate type to hold the decoded output.  For example:
 *
 *      pac_info_t info;
 *
 *      if ((nbuf = ndr_buf_init(&TYPEINFO(ndr_pac)) != NULL) {
 *              rc = ndr_decode_buf(nbuf, opnum, data, datalen, &info);
 *              ...
 *              ndr_buf_fini(nbuf);
 *      }
 */
int
ndr_buf_decode(ndr_buf_t *nbuf, unsigned hdr_type, unsigned opnum,
    const char *data, size_t datalen, void *result)
{
        ndr_common_header_t     hdr;
        ndr_pac_hdr_t           pac_hdr;
        unsigned                pdu_size_hint;
        int                     rc;

        assert(nbuf->nb_magic == NDR_BUF_MAGIC);
        assert(nbuf->nb_heap != NULL);
        assert(nbuf->nb_ti != NULL);

        if (datalen < NDR_PDU_SIZE_HINT_DEFAULT)
                pdu_size_hint = NDR_PDU_SIZE_HINT_DEFAULT;
        else
                pdu_size_hint = datalen;

        rc = nds_initialize(&nbuf->nb_nds, pdu_size_hint, NDR_MODE_BUF_DECODE,
            nbuf->nb_heap);
        if (NDR_DRC_IS_FAULT(rc))
                return (rc);

        bcopy(data, nbuf->nb_nds.pdu_base_addr, datalen);
        nbuf->nb_nds.pdu_size = datalen;

        switch (hdr_type) {
        case NDR_PTYPE_COMMON:
                rc = ndr_decode_hdr_common(&nbuf->nb_nds, &hdr);
                if (NDR_DRC_IS_FAULT(rc))
                        return (rc);

                if (!NDR_IS_SINGLE_FRAG(hdr.pfc_flags))
                        return (NDR_DRC_FAULT_DECODE_FAILED);
                break;

        case NDR_PTYPE_PAC:
                rc = ndr_decode_pac_hdr(&nbuf->nb_nds, &pac_hdr);
                if (NDR_DRC_IS_FAULT(rc))
                        return (rc);

                if (pac_hdr.common_hdr.hdrlen != sizeof (ndr_serialtype1_hdr_t))
                        return (NDR_DRC_FAULT_DECODE_FAILED);
                break;

        default:
                return (NDR_ERR_UNIMPLEMENTED);
        }

        rc = ndr_encode_decode_common(&nbuf->nb_nds, opnum, nbuf->nb_ti,
            result);
        return (rc);
}

/*
 * Use the receive stream to unmarshall data (NDR_MODE_CALL_RECV).
 */
int
ndr_decode_call(ndr_xa_t *mxa, void *params)
{
        ndr_stream_t    *nds = &mxa->recv_nds;
        int             rc;

        if (!NDR_MODE_MATCH(nds, NDR_MODE_CALL_RECV))
                return (NDR_DRC_FAULT_MODE_MISMATCH);

        rc = ndr_encode_decode_common(nds, mxa->opnum,
            mxa->binding->service->interface_ti, params);

        return (rc + NDR_PTYPE_REQUEST);
}

/*
 * Use the send stream to marshall data (NDR_MODE_RETURN_SEND).
 */
int
ndr_encode_return(ndr_xa_t *mxa, void *params)
{
        ndr_stream_t    *nds = &mxa->send_nds;
        int             rc;

        if (!NDR_MODE_MATCH(nds, NDR_MODE_RETURN_SEND))
                return (NDR_DRC_FAULT_MODE_MISMATCH);

        rc = ndr_encode_decode_common(nds, mxa->opnum,
            mxa->binding->service->interface_ti, params);

        return (rc + NDR_PTYPE_RESPONSE);
}

/*
 * Use the send stream to marshall data (NDR_MODE_CALL_SEND).
 */
int
ndr_encode_call(ndr_xa_t *mxa, void *params)
{
        ndr_stream_t    *nds = &mxa->send_nds;
        int             rc;

        if (!NDR_MODE_MATCH(nds, NDR_MODE_CALL_SEND))
                return (NDR_DRC_FAULT_MODE_MISMATCH);

        rc = ndr_encode_decode_common(nds, mxa->opnum,
            mxa->binding->service->interface_ti, params);

        return (rc + NDR_PTYPE_REQUEST);
}

/*
 * Use the receive stream to unmarshall data (NDR_MODE_RETURN_RECV).
 */
int
ndr_decode_return(ndr_xa_t *mxa, void *params)
{
        ndr_stream_t    *nds = &mxa->recv_nds;
        int             rc;

        if (!NDR_MODE_MATCH(nds, NDR_MODE_RETURN_RECV))
                return (NDR_DRC_FAULT_MODE_MISMATCH);

        rc = ndr_encode_decode_common(nds, mxa->opnum,
            mxa->binding->service->interface_ti, params);

        return (rc + NDR_PTYPE_RESPONSE);
}

int
ndr_decode_pdu_hdr(ndr_xa_t *mxa)
{
        ndr_common_header_t     *hdr = &mxa->recv_hdr.common_hdr;
        ndr_stream_t            *nds = &mxa->recv_nds;
        int                     rc;
        ulong_t                 saved_offset;

        saved_offset = nds->pdu_scan_offset;
        rc = ndr_decode_hdr_common(nds, hdr);
        if (NDR_DRC_IS_FAULT(rc))
                return (rc);

        /*
         * Verify the protocol version.
         */
        if ((hdr->rpc_vers != 5) || (hdr->rpc_vers_minor != 0))
                return (NDR_DRC_FAULT_RPCHDR_DECODE_FAILED);

        mxa->ptype = hdr->ptype;
        /* pdu_scan_offset now points to (this fragment's) stub data */
        nds->pdu_body_offset = nds->pdu_scan_offset;
        nds->pdu_hdr_size = nds->pdu_scan_offset - saved_offset;
        nds->pdu_body_size = hdr->frag_length - hdr->auth_length -
            nds->pdu_hdr_size -
            ((hdr->auth_length != 0) ? SEC_TRAILER_SIZE : 0);

        if (hdr->auth_length != 0 && hdr->auth_length >
            (hdr->frag_length - nds->pdu_hdr_size - SEC_TRAILER_SIZE))
                return (NDR_DRC_FAULT_RECEIVED_MALFORMED);
        return (NDR_DRC_OK);
}

static int
ndr_decode_hdr_common(ndr_stream_t *nds, ndr_common_header_t *hdr)
{
        int                     ptype;
        int                     rc;
        int                     charset;
        int                     byte_order;
        ulong_t                 saved_offset;

        if (nds->m_op != NDR_M_OP_UNMARSHALL)
                return (NDR_DRC_FAULT_RPCHDR_MODE_MISMATCH);

        /*
         * All PDU headers are at least this big
         */
        saved_offset = nds->pdu_scan_offset;
        if ((nds->pdu_size - saved_offset) < sizeof (ndr_common_header_t))
                return (NDR_DRC_FAULT_RPCHDR_RECEIVED_RUNT);

        /*
         * Peek at the first eight bytes to figure out what we're doing.
         */
        rc = NDS_GET_PDU(nds, 0, 8, (char *)hdr, 0, 0);
        if (!rc)
                return (NDR_DRC_FAULT_RPCHDR_DECODE_FAILED);

        /*
         * Check for ASCII as the character set.  This is an ASCII
         * versus EBCDIC option and has nothing to do with Unicode.
         */
        charset = hdr->packed_drep.intg_char_rep & NDR_REPLAB_CHAR_MASK;
        if (charset != NDR_REPLAB_CHAR_ASCII)
                return (NDR_DRC_FAULT_RPCHDR_DECODE_FAILED);

        /*
         * Set the byte swap flag if the PDU byte-order
         * is different from the local byte-order.
         */
        byte_order = hdr->packed_drep.intg_char_rep & NDR_REPLAB_INTG_MASK;
        nds->swap = (byte_order != ndr_native_byte_order) ? 1 : 0;

        ptype = hdr->ptype;
        if (ptype == NDR_PTYPE_REQUEST &&
            (hdr->pfc_flags & NDR_PFC_OBJECT_UUID) != 0) {
                ptype = NDR_PTYPE_REQUEST_WITH; /* fake for sizing */
        }

        rc = ndr_encode_decode_common(nds, ptype, &TYPEINFO(ndr_hdr), hdr);

        if (hdr->frag_length > (nds->pdu_size - saved_offset))
                rc = NDR_DRC_FAULT_RECEIVED_MALFORMED;
        return (NDR_DRC_PTYPE_RPCHDR(rc));
}

static int
ndr_decode_pac_hdr(ndr_stream_t *nds, ndr_pac_hdr_t *hdr)
{
        int     rc;

        if (nds->m_op != NDR_M_OP_UNMARSHALL)
                return (NDR_DRC_FAULT_RPCHDR_MODE_MISMATCH);

        /*
         * All PDU headers are at least this big
         */
        if ((nds->pdu_size - nds->pdu_scan_offset) < sizeof (ndr_pac_hdr_t))
                return (NDR_DRC_FAULT_RPCHDR_RECEIVED_RUNT);

        /*
         * Peek at the first eight bytes to figure out what we're doing.
         */
        rc = NDS_GET_PDU(nds, 0, 8, (char *)hdr, 0, 0);
        if (!rc)
                return (NDR_DRC_FAULT_RPCHDR_DECODE_FAILED);

        /* Must be set to 1 to indicate type serialization version 1. */
        if (hdr->common_hdr.version != 1)
                return (NDR_DRC_FAULT_RPCHDR_DECODE_FAILED);

        /*
         * Set the byte swap flag if the PDU byte-order
         * is different from the local byte-order.
         */
        nds->swap =
            (hdr->common_hdr.endianness != ndr_native_byte_order) ? 1 : 0;

        rc = ndr_encode_decode_common(nds, NDR_PTYPE_PAC,
            &TYPEINFO(ndr_hdr), hdr);

        return (NDR_DRC_PTYPE_RPCHDR(rc));
}

CTASSERT(sizeof (ndr_common_header_t) >= NDR_CMN_HDR_SIZE);

/*
 * Decode an RPC fragment header.  Use ndr_decode_pdu_hdr() to process
 * the first fragment header then this function to process additional
 * fragment headers.
 */
void
ndr_decode_frag_hdr(ndr_stream_t *nds, ndr_common_header_t *hdr)
{
        ndr_common_header_t *tmp;
        uint8_t *pdu;
        int byte_order;

        pdu = (uint8_t *)nds->pdu_base_offset + nds->pdu_scan_offset;
        bcopy(pdu, hdr, NDR_CMN_HDR_SIZE);

        /*
         * Swap non-byte fields if the PDU byte-order
         * is different from the local byte-order.
         */
        byte_order = hdr->packed_drep.intg_char_rep & NDR_REPLAB_INTG_MASK;

        if (byte_order != ndr_native_byte_order) {
                /*LINTED E_BAD_PTR_CAST_ALIGN*/
                tmp = (ndr_common_header_t *)pdu;

                nds_bswap(&tmp->frag_length, &hdr->frag_length,
                    sizeof (WORD));
                nds_bswap(&tmp->auth_length, &hdr->auth_length,
                    sizeof (WORD));
                nds_bswap(&tmp->call_id, &hdr->call_id, sizeof (DWORD));
        }

        /* pdu_scan_offset points to byte 0 of this fragment */
        nds->pdu_hdr_size = NDR_RSP_HDR_SIZE;
        nds->pdu_body_offset = nds->pdu_scan_offset + nds->pdu_hdr_size;
        nds->pdu_body_size = hdr->frag_length - hdr->auth_length -
            nds->pdu_hdr_size -
            ((hdr->auth_length != 0) ? SEC_TRAILER_SIZE : 0);
}

/*
 * Remove an RPC fragment header from the received data stream.
 *
 * NDR stream on entry:
 *
 *                |<--- frag --->|
 * +-----+--------+-----+--------+-----+---------+-----+
 * | hdr |  data  | hdr |  data  | hdr |  data   | ... |
 * +-----+--------+-----+--------+-----+---------+-----+
 *                 <----
 *
 * NDR stream on return:
 *
 * +-----+----------------+-----+---------+-----+
 * | hdr |       data     | hdr |  data   | ... |
 * +-----+----------------+-----+---------+-----+
 */
void
ndr_remove_frag_hdr(ndr_stream_t *nds)
{
        char    *hdr;
        char    *data;
        int     nbytes;

        hdr = (char *)nds->pdu_base_offset + nds->pdu_scan_offset;
        data = hdr + NDR_RSP_HDR_SIZE;
        nbytes = nds->pdu_size - nds->pdu_scan_offset - NDR_RSP_HDR_SIZE;

        /*
         * Move all of the data after the header back to where the header began.
         */
        memmove(hdr, data, nbytes);
        nds->pdu_size -= NDR_RSP_HDR_SIZE;
}

void
ndr_show_hdr(ndr_common_header_t *hdr)
{
        char    *fragtype;

        if (hdr == NULL) {
                ndo_printf(NULL, NULL, "ndr hdr: <null>");
                return;
        }

        if (NDR_IS_SINGLE_FRAG(hdr->pfc_flags))
                fragtype = "single";
        else if (NDR_IS_FIRST_FRAG(hdr->pfc_flags))
                fragtype = "first";
        else if (NDR_IS_LAST_FRAG(hdr->pfc_flags))
                fragtype = "last";
        else
                fragtype = "intermediate";

        ndo_printf(NULL, NULL,
            "ndr hdr: %d.%d ptype=%d, %s frag (flags=0x%08x) len=%d "
            "auth_len=%d",
            hdr->rpc_vers, hdr->rpc_vers_minor, hdr->ptype,
            fragtype, hdr->pfc_flags, hdr->frag_length, hdr->auth_length);
}

void
ndr_show_auth(ndr_sec_t *auth)
{
        if (auth == NULL) {
                ndo_printf(NULL, NULL, "ndr auth: <null>");
                return;
        }

        ndo_printf(NULL, NULL,
            "ndr auth: type=0x%x, level=0x%x, pad_len=%d, ctx_id=%d",
            auth->auth_type, auth->auth_level, auth->auth_pad_len,
            auth->auth_context_id);
}

int
ndr_encode_pdu_hdr(ndr_xa_t *mxa)
{
        ndr_common_header_t     *hdr = &mxa->send_hdr.common_hdr;
        ndr_stream_t            *nds = &mxa->send_nds;
        int                     ptype;
        int                     rc;

        if (nds->m_op != NDR_M_OP_MARSHALL)
                return (NDR_DRC_FAULT_RPCHDR_MODE_MISMATCH);

        ptype = hdr->ptype;
        if (ptype == NDR_PTYPE_REQUEST &&
            (hdr->pfc_flags & NDR_PFC_OBJECT_UUID) != 0) {
                ptype = NDR_PTYPE_REQUEST_WITH; /* fake for sizing */
        }

        rc = ndr_encode_decode_common(nds, ptype, &TYPEINFO(ndr_hdr), hdr);

        return (NDR_DRC_PTYPE_RPCHDR(rc));
}

/*
 * This is a hand-coded derivative of the automatically generated
 * (un)marshalling routine for bind_ack headers. bind_ack headers
 * have an interior conformant array, which is inconsistent with
 * IDL/NDR rules.
 */
extern struct ndr_typeinfo ndt__uchar;
extern struct ndr_typeinfo ndt__ushort;
extern struct ndr_typeinfo ndt__ulong;

int ndr__ndr_bind_ack_hdr(ndr_ref_t *encl_ref);
ndr_typeinfo_t ndt__ndr_bind_ack_hdr = {
    1,          /* NDR version */
    3,          /* alignment */
    NDR_F_STRUCT,       /* flags */
    ndr__ndr_bind_ack_hdr,      /* ndr_func */
    68,         /* pdu_size_fixed_part */
    0,          /* pdu_size_variable_part */
    68,         /* c_size_fixed_part */
    0,          /* c_size_variable_part */
};

/*
 * [_no_reorder]
 */
int
ndr__ndr_bind_ack_hdr(ndr_ref_t *encl_ref)
{
        ndr_stream_t            *nds = encl_ref->stream;
        struct ndr_bind_ack_hdr *val = /*LINTED E_BAD_PTR_CAST_ALIGN*/
            (struct ndr_bind_ack_hdr *)encl_ref->datum;
        ndr_ref_t               myref;
        unsigned long           offset;

        bzero(&myref, sizeof (myref));
        myref.enclosing = encl_ref;
        myref.stream = encl_ref->stream;
        myref.packed_alignment = 0;

        /* do all members in order */
        NDR_MEMBER(_ndr_common_header, common_hdr, 0UL);
        NDR_MEMBER(_ushort, max_xmit_frag, 16UL);
        NDR_MEMBER(_ushort, max_recv_frag, 18UL);
        NDR_MEMBER(_ulong, assoc_group_id, 20UL);

        /* port any is the conformant culprit */
        offset = 24UL;

        switch (nds->m_op) {
        case NDR_M_OP_MARSHALL:
                val->sec_addr.length =
                    strlen((char *)val->sec_addr.port_spec) + 1;
                break;

        case NDR_M_OP_UNMARSHALL:
                break;

        default:
                NDR_SET_ERROR(encl_ref, NDR_ERR_M_OP_INVALID);
                return (0);
        }

        NDR_MEMBER(_ushort, sec_addr.length, offset);
        NDR_MEMBER_ARR_WITH_DIMENSION(_uchar, sec_addr.port_spec,
            offset+2UL, val->sec_addr.length);

        offset += 2;
        offset += val->sec_addr.length;
        offset += NDR_ALIGN4(offset);

        NDR_MEMBER(_ndr_p_result_list, p_result_list, offset);
        return (1);
}

/*
 * Assume a single presentation context element in the result list.
 */
unsigned
ndr_bind_ack_hdr_size(ndr_xa_t *mxa)
{
        ndr_bind_ack_hdr_t *bahdr = &mxa->send_hdr.bind_ack_hdr;
        unsigned        offset;
        unsigned        length;

        /* port any is the conformant culprit */
        offset = 24UL;

        length = strlen((char *)bahdr->sec_addr.port_spec) + 1;

        offset += 2;
        offset += length;
        offset += NDR_ALIGN4(offset);
        offset += sizeof (ndr_p_result_list_t);
        return (offset);
}

/*
 * This is a hand-coded derivative of the automatically generated
 * (un)marshalling routine for alter_context_rsp headers.
 * Alter context response headers have an interior conformant array,
 * which is inconsistent with IDL/NDR rules.
 */
int ndr__ndr_alter_context_rsp_hdr(ndr_ref_t *encl_ref);
ndr_typeinfo_t ndt__ndr_alter_context_rsp_hdr = {
    1,                  /* NDR version */
    3,                  /* alignment */
    NDR_F_STRUCT,       /* flags */
    ndr__ndr_alter_context_rsp_hdr,     /* ndr_func */
    56,                 /* pdu_size_fixed_part */
    0,                  /* pdu_size_variable_part */
    56,                 /* c_size_fixed_part */
    0,                  /* c_size_variable_part */
};

/*
 * [_no_reorder]
 */
int
ndr__ndr_alter_context_rsp_hdr(ndr_ref_t *encl_ref)
{
        ndr_stream_t            *nds = encl_ref->stream;
        ndr_alter_context_rsp_hdr_t *val = /*LINTED E_BAD_PTR_CAST_ALIGN*/
            (ndr_alter_context_rsp_hdr_t *)encl_ref->datum;
        ndr_ref_t               myref;
        unsigned long           offset;

        bzero(&myref, sizeof (myref));
        myref.enclosing = encl_ref;
        myref.stream = encl_ref->stream;
        myref.packed_alignment = 0;

        /* do all members in order */
        NDR_MEMBER(_ndr_common_header, common_hdr, 0UL);
        NDR_MEMBER(_ushort, max_xmit_frag, 16UL);
        NDR_MEMBER(_ushort, max_recv_frag, 18UL);
        NDR_MEMBER(_ulong, assoc_group_id, 20UL);

        offset = 24UL;  /* offset of sec_addr */

        switch (nds->m_op) {
        case NDR_M_OP_MARSHALL:
                val->sec_addr.length = 0;
                break;

        case NDR_M_OP_UNMARSHALL:
                break;

        default:
                NDR_SET_ERROR(encl_ref, NDR_ERR_M_OP_INVALID);
                return (0);
        }

        NDR_MEMBER(_ushort, sec_addr.length, offset);
        NDR_MEMBER_ARR_WITH_DIMENSION(_uchar, sec_addr.port_spec,
            offset+2UL, val->sec_addr.length);

        offset += 2;    /* sizeof (sec_addr.length) */
        offset += NDR_ALIGN4(offset);

        NDR_MEMBER(_ndr_p_result_list, p_result_list, offset);
        return (1);
}

/*
 * Assume a single presentation context element in the result list.
 */
unsigned
ndr_alter_context_rsp_hdr_size(void)
{
        unsigned        offset;

        offset = 24UL;  /* offset of sec_addr */
        offset += 2;    /* sizeof (sec_addr.length) */
        offset += NDR_ALIGN4(offset);
        offset += sizeof (ndr_p_result_list_t);
        return (offset);
}

/*
 * This is a hand-coded (un)marshalling routine for auth_verifier_co
 * (aka ndr_sec_t).
 *
 * We need to pretend this structure isn't variably sized, until ndrgen
 * has been modified to support variable-sized arrays.
 * Here, we only account for the fixed-size members (8 bytes), plus
 * a pointer for the C structure.
 *
 * We then convert between a pointer to the auth token (auth_value,
 * allocated here during unmarshall) and a flat, 'fixed'-sized array.
 */

int ndr__auth_verifier_co(ndr_ref_t *encl_ref);
ndr_typeinfo_t ndt__auth_verifier_co = {
    1,          /* NDR version */
    3,          /* alignment */
    NDR_F_STRUCT,       /* flags */
    ndr__auth_verifier_co,      /* ndr_func */
    8,          /* pdu_size_fixed_part */
    0,          /* pdu_size_variable_part */
    8 + sizeof (void *),        /* c_size_fixed_part */
    0,          /* c_size_variable_part */
};

/*
 * [_no_reorder]
 */
int
ndr__auth_verifier_co(ndr_ref_t *encl_ref)
{
        ndr_stream_t            *nds = encl_ref->stream;
        ndr_xa_t                *mxa = /*LINTED E_BAD_PTR_CAST_ALIGN*/
            (ndr_xa_t *)encl_ref->datum;
        ndr_common_header_t     *hdr;
        ndr_ref_t               myref;
        ndr_sec_t               *val;

        /*
         * Assumes scan_offset points to the end of PDU body.
         * (That's base + frag_len - auth_len - SEC_TRAILER_SIZE)
         *
         * At some point, NDRGEN could use struct initializers instead of
         * bzero() + initialization.
         */
        bzero(&myref, sizeof (myref));
        myref.enclosing = encl_ref;
        myref.stream = encl_ref->stream;

        switch (nds->m_op) {
        case NDR_M_OP_MARSHALL:
                val = &mxa->send_auth;
                hdr = &mxa->send_hdr.common_hdr;
                break;

        case NDR_M_OP_UNMARSHALL:
                val = &mxa->recv_auth;
                hdr = &mxa->recv_hdr.common_hdr;
                val->auth_value = (uchar_t *)NDS_MALLOC(nds, hdr->auth_length,
                    encl_ref);
                break;

        default:
                NDR_SET_ERROR(encl_ref, NDR_ERR_M_OP_INVALID);
                return (0);
        }

        /*
         * ndr_topmost() can't account for auth_length (pdu_scan/end_offset).
         * This would only matter if any of this struct's members
         * are treated as 'outer' constructs, but they aren't.
         */
        encl_ref->pdu_end_offset += hdr->auth_length;
        nds->pdu_scan_offset += hdr->auth_length;

        NDR_MEMBER(_uchar, auth_type, 0UL);
        NDR_MEMBER(_uchar, auth_level, 1UL);
        NDR_MEMBER(_uchar, auth_pad_len, 2UL);
        NDR_MEMBER(_uchar, auth_rsvd, 3UL);
        NDR_MEMBER(_ulong, auth_context_id, 4UL);

        NDR_MEMBER_PTR_WITH_DIMENSION(_uchar, auth_value, 8UL,
            hdr->auth_length);

        return (1);
}

int
ndr_encode_pdu_auth(ndr_xa_t *mxa)
{
        ndr_common_header_t     *hdr = &mxa->send_hdr.common_hdr;
        ndr_stream_t            *nds = &mxa->send_nds;
        int                     rc;
        ulong_t                 want_size;

        if (nds->m_op != NDR_M_OP_MARSHALL)
                return (NDR_DRC_FAULT_MODE_MISMATCH);

        if (hdr->auth_length == 0)
                return (NDR_DRC_OK);

        want_size = nds->pdu_scan_offset + hdr->auth_length + SEC_TRAILER_SIZE;

        /*
         * Make sure we have space for the sec trailer - the marshaller
         * doesn't know how large the auth token is.
         * Note: ndr_add_auth_token() has already added padding.
         *
         * NDS_GROW_PDU will adjust pdu_size for us.
         */
        if (nds->pdu_max_size < want_size) {
                if (NDS_GROW_PDU(nds, want_size, NULL) == 0)
                        return (NDR_DRC_FAULT_ENCODE_TOO_BIG);
        } else {
                nds->pdu_size = want_size;
        }
        rc = ndr_encode_decode_type(nds, &TYPEINFO(auth_verifier_co),
            mxa);

        return (rc);
}

int
ndr_decode_pdu_auth(ndr_xa_t *mxa)
{
        ndr_common_header_t     *hdr = &mxa->recv_hdr.common_hdr;
        ndr_stream_t            *nds = &mxa->recv_nds;
        ndr_sec_t               *auth = &mxa->recv_auth;
        int                     rc;
        ulong_t                 saved_offset;
        size_t                  auth_size;

        if (nds->m_op != NDR_M_OP_UNMARSHALL)
                return (NDR_DRC_FAULT_MODE_MISMATCH);

        mxa->recv_auth.auth_pad_len = 0;
        if (hdr->auth_length == 0)
                return (NDR_DRC_OK);

        /*
         * Save the current offset, and skip to the sec_trailer.
         * That's located after the (fragment of) stub data and the auth
         * pad bytes (collectively the 'PDU Body').
         */
        saved_offset = nds->pdu_scan_offset;
        nds->pdu_scan_offset = nds->pdu_body_offset + nds->pdu_body_size;

        /* auth_length is all of the data after the sec_trailer */
        if (hdr->auth_length >
            (nds->pdu_size - nds->pdu_scan_offset - SEC_TRAILER_SIZE)) {
                nds->pdu_scan_offset = saved_offset;
                return (NDR_DRC_FAULT_RECEIVED_MALFORMED);
        }

        rc = ndr_encode_decode_type(nds, &TYPEINFO(auth_verifier_co),
            mxa);

        /*
         * Reset the scan_offset for call decode processing.
         * If we were successful, remove the sec trailer and padding
         * from size accounting.
         */
        if (auth->auth_pad_len > nds->pdu_body_size)
                rc = NDR_DRC_FAULT_RECEIVED_MALFORMED;
        else if (rc == NDR_DRC_OK) {
                auth_size = hdr->auth_length + SEC_TRAILER_SIZE +
                    auth->auth_pad_len;

                /*
                 * After the authenticator has been decoded,
                 * pdu_scan_offset points to just after the auth token,
                 * which is the end of the fragment.
                 *
                 * If there's no data after the authenticator, then we
                 * just remove the authenticator from size accounting.
                 * Otherwise, need to memmove() all of that data back to after
                 * the stub data. The data we move starts at the beginning of
                 * the next fragment.
                 */
                if (nds->pdu_size > nds->pdu_scan_offset) {
                        uchar_t *next_frag_ptr = nds->pdu_base_addr +
                            nds->pdu_scan_offset;

                        memmove(next_frag_ptr - auth_size, next_frag_ptr,
                            nds->pdu_size - nds->pdu_scan_offset);
                }

                nds->pdu_size -= auth_size;
        }
        nds->pdu_scan_offset = saved_offset;
        return (rc);
}