rpcpdu.cpp

VXWORKS源代码

/* RpcPdu.cpp - COM/DCOM RpcPdu class implementation */

/*
modification history
--------------------
01z,17dec01,nel  Add include symbol for diab build.
01y,10dec01,dbs  diab build
01x,08oct01,nel  SPR#70120. reformat ALTER_CONTEXT_RESP separately from
                 BIND_ACK.
01w,13jul01,dbs  fix up includes
01v,15aug00,nel  Win2K Fix.
01u,27jun00,dbs  NDR-format presCtxId
01t,22jun00,dbs  add accessors for alter_context_resp
01s,19aug99,aim  change assert to VXDCOM_ASSERT
01r,20jul99,aim  grow vector when building incoming pdu
01q,09jul99,dbs  copied from NRpcPdu into RpcPdu files
01p,07jul99,aim  removed debug from makeReplyBuffer
01o,06jul99,aim  added isBindNak
01n,02jul99,aim  added isBindAck
01m,25jun99,dbs  add authn properties
01l,24jun99,dbs  move authn into new class
01k,18jun99,aim  set data rep on outgoing packets
01j,17jun99,aim  changed assert to assert
01i,01jun99,dbs  add NDR formatting to FAULT packet header
01h,19may99,dbs  send packet in fragments so no copying required
01g,11may99,dbs  rename VXCOM to VXDCOM
01f,07may99,dbs  add method to return object ID
01e,29apr99,dbs  fix -Wall warnings
01d,28apr99,dbs  add mem-pool
01c,26apr99,aim  added TRACE_CALL
01b,21apr99,dbs  change RPCMSG to RpcPdu
01a,20apr99,dbs  created during Grand Renaming

*/

/*
  DESCRIPTION:

  RpcPdu -- RPC Protocol Data Unit class.

*/

#include <stdio.h>
#include <ctype.h>
#include "RpcPdu.h"
#include "orpcLib.h"
#include "dcomProxy.h"
#include "Syslog.h"
#include "TraceCall.h"

/* Include symbol for diab */
extern "C" int include_vxdcom_RpcPdu (void)
    {
    return 0;
    }

//////////////////////////////////////////////////////////////////////////
//

RpcPdu::RpcPdu ()
  : m_headerOffset (0),
    m_stubData (),
    m_requiredOctets (sizeof (rpc_cn_common_hdr_t)),
    m_pduState (HAVE_NONE)
    {
    TRACE_CALL;
    m_headerOffset = reinterpret_cast<char*> (&m_header);
    (void) ::memset (&m_header, 0, sizeof (m_header));
    }

RpcPdu::~RpcPdu ()
    {
    TRACE_CALL;
    }

//////////////////////////////////////////////////////////////////////////
//

void RpcPdu::guidReformat
    (
    GUID&                guid,
    ULONG                drep
    )
    {
    TRACE_CALL;
    ndr_make_right (guid.Data1, drep);
    ndr_make_right (guid.Data2, drep);
    ndr_make_right (guid.Data3, drep);
    }

//////////////////////////////////////////////////////////////////////////
//

void RpcPdu::commonHdrReformat
    (
    ULONG                drep
    )
    {
    TRACE_CALL;
    rpc_cn_packet_t* pHdr = &m_header;
    
    ndr_make_right (pHdr->request.hdr.fragLen, drep);
    ndr_make_right (pHdr->request.hdr.authLen, drep);
    ndr_make_right (pHdr->request.hdr.callId, drep);
    }

//////////////////////////////////////////////////////////////////////////
//

void RpcPdu::extHdrReformat
    (
    ULONG                drep
    )
    {
    TRACE_CALL;
    rpc_cn_packet_t* pHdr = &m_header;
    
    switch (pHdr->request.hdr.packetType)
        {
        case RPC_CN_PKT_REQUEST:
            ndr_make_right (pHdr->request.allocHint, drep);
            ndr_make_right (pHdr->request.presCtxId, drep);
            ndr_make_right (pHdr->request.methodNum, drep);
            if (pHdr->request.hdr.flags & RPC_CN_FLAGS_OBJECT_UUID)
                guidReformat (pHdr->request.objectId, drep);
            break;

        case RPC_CN_PKT_RESPONSE:
            ndr_make_right (pHdr->request.allocHint, drep);
            ndr_make_right (pHdr->request.presCtxId, drep);
            break;

        case RPC_CN_PKT_BIND:
        case RPC_CN_PKT_ALTER_CONTEXT:
            ndr_make_right (pHdr->bind.maxTxFrag, drep);
            ndr_make_right (pHdr->bind.maxRxFrag, drep);
            ndr_make_right (pHdr->bind.assocGroupId, drep);
            guidReformat (pHdr->bind.presCtxList.presCtxElem
                          [0].abstractSyntax.id,
                          drep);
            ndr_make_right (pHdr->bind.presCtxList.presCtxElem
                 [0].abstractSyntax.version, drep);
            ndr_make_right (pHdr->bind.presCtxList.presCtxElem[0].presCtxId, 
                            drep);
            guidReformat (pHdr->bind.presCtxList.presCtxElem
                          [0].transferSyntax [0].id,
                          drep);
            ndr_make_right (pHdr->bind.presCtxList.presCtxElem
                 [0].transferSyntax [0].version, drep);
            break;

        case RPC_CN_PKT_BIND_ACK:
	    ndr_make_right (pHdr->bind_ack.maxTxFrag, drep);
	    ndr_make_right (pHdr->bind_ack.maxRxFrag, drep);
	    ndr_make_right (pHdr->bind_ack.assocGroupId, drep);
	    ndr_make_right (pHdr->bind_ack.secAddr.len, drep);
            ndr_make_right (pHdr->bind_ack.resultList.presResult [0].result, drep);
            ndr_make_right (pHdr->bind_ack.resultList.presResult [0].reason, drep);
	    ndr_make_right (pHdr->bind_ack.resultList.presResult
			    [0].transferSyntax.version, drep);
	    guidReformat (pHdr->bind_ack.resultList.presResult
			  [0].transferSyntax.id, drep);
            break;




        case RPC_CN_PKT_ALTER_CONTEXT_RESP:
	    ndr_make_right (pHdr->alter_context_resp.maxTxFrag, drep);
	    ndr_make_right (pHdr->alter_context_resp.maxRxFrag, drep);
	    ndr_make_right (pHdr->alter_context_resp.assocGroupId, drep);
	    ndr_make_right (pHdr->alter_context_resp.secAddr, drep);
            ndr_make_right (pHdr->alter_context_resp.resultList.presResult [0].result, drep);
            ndr_make_right (pHdr->alter_context_resp.resultList.presResult [0].reason, drep);
	    ndr_make_right (pHdr->alter_context_resp.resultList.presResult
			    [0].transferSyntax.version, drep);
	    guidReformat (pHdr->alter_context_resp.resultList.presResult
			  [0].transferSyntax.id, drep);
            break;


        case RPC_CN_PKT_FAULT:
            ndr_make_right (pHdr->fault.status, drep);
            break;
        }
    }

//////////////////////////////////////////////////////////////////////////
//

const rpc_cn_auth_tlr_t*
RpcPdu::authTrailer () const
    {
    TRACE_CALL;

    ULONG alen = authLen ();

    if (alen == 0)
        return 0;

#ifdef __DCC__
    const char* stubDataOffset = &(*(m_stubData.begin ()));
#else
    const char* stubDataOffset = reinterpret_cast<const char*>
                                 (m_stubData.begin ());
#endif
    
    if (stubDataOffset == 0)
        return 0;

    return reinterpret_cast<rpc_cn_auth_tlr_t*>
        (const_cast<char *>
        (stubDataOffset + (payloadLen () -
                           (alen + SIZEOF_AUTH_TLR_PREAMBLE))));
    }

// this always includes the auth-trailer if present
size_t
RpcPdu::payloadLen () const
    {
    TRACE_CALL;
    return m_stubData.size ();
    }

// this *only* the stub data length
size_t RpcPdu::stubDataLen () const
    {
    return (payloadLen () - authLen ());
    }


ULONG
RpcPdu::hdrLen () const
    {
    TRACE_CALL;
    ULONG n = 0;

    switch (m_header.request.hdr.packetType)
        {
        case RPC_CN_PKT_REQUEST:
            n = sizeof (rpc_cn_request_hdr_t);
            if (! (m_header.request.hdr.flags & RPC_CN_FLAGS_OBJECT_UUID))
                n -= sizeof (GUID);
            break;

        case RPC_CN_PKT_RESPONSE:
            n = sizeof (rpc_cn_response_hdr_t);
            break;

        case RPC_CN_PKT_BIND:
        case RPC_CN_PKT_ALTER_CONTEXT:
            n = sizeof (rpc_cn_bind_hdr_t);
            break;

        case RPC_CN_PKT_BIND_ACK:
            n = sizeof (rpc_cn_bind_ack_hdr_t);
            break;

        case RPC_CN_PKT_ALTER_CONTEXT_RESP:
            n = sizeof (rpc_cn_alter_context_resp_hdr_t);
            break;

        case RPC_CN_PKT_BIND_NAK:
            n = sizeof (rpc_cn_bind_nak_hdr_t);
            break;

        case RPC_CN_PKT_AUTH3:
            n = sizeof (rpc_cn_auth3_hdr_t);
            break;
            
        case RPC_CN_PKT_SHUTDOWN:
        case RPC_CN_PKT_REMOTE_ALERT:
        case RPC_CN_PKT_ORPHANED:
            n = sizeof (rpc_cn_common_hdr_t);
            break;

        case RPC_CN_PKT_FAULT:
            n = sizeof (rpc_cn_fault_hdr_t);
            break;

        default:
            // log warning
            n = 4096;
            break;
        }

    return n;
    }
    
void
RpcPdu::opnumSet (USHORT op)
    {
    TRACE_CALL;
    m_header.request.methodNum = op;
    }

void
RpcPdu::fragLenSet ()
    {
    TRACE_CALL;
    int len = hdrLen () + payloadLen ();
    m_header.request.hdr.fragLen = len;
    if (packetType () == RPC_CN_PKT_REQUEST)
        m_header.request.allocHint = len;
    else if (packetType () == RPC_CN_PKT_RESPONSE)
        m_header.response.allocHint = len;
    }

void
RpcPdu::authLenSet (size_t n)
    {
    TRACE_CALL;
    m_header.request.hdr.authLen = n;
    }

void
RpcPdu::drepSet ()
    {
    TRACE_CALL;
    * (ULONG*) m_header.request.hdr.drep = ORPC_WIRE_DREP;
    }

void
RpcPdu::drepSet (ULONG dr)
    {
    TRACE_CALL;
    * (ULONG*) m_header.request.hdr.drep = dr;
    }

size_t
RpcPdu::stubDataAppend (const void* pv, size_t n)
    {
    TRACE_CALL;
    const char* p = reinterpret_cast<const char*> (pv);
    m_stubData.insert (m_stubData.end (), p, p +n);
    return n;
    }

const GUID& RpcPdu::objectId () const
    {
    TRACE_CALL;

    if (m_header.request.hdr.flags & RPC_CN_FLAGS_OBJECT_UUID)
        return m_header.request.objectId;

    return GUID_NULL;
    }

///////////////////////////////////////////////////////////////////////////////
//

bool
RpcPdu::complete () const
    {
    return m_pduState & HAVE_STUB;
    }

size_t
RpcPdu::appendCommonHdr (const char* buf, size_t len)
    {
    COM_ASSERT (m_pduState & HAVE_NONE);

    size_t n = min(len, m_requiredOctets); // octets to copy

    ::memcpy (m_headerOffset, buf, n);

    m_headerOffset += n;
    m_requiredOctets -= n;

    if (m_requiredOctets == 0)
        {
        // Un-NDR the packet header...
        commonHdrReformat (drep ());

        // mark the next state's requirements
        m_pduState = HAVE_HDR;
        m_requiredOctets = hdrLen () - sizeof (rpc_cn_common_hdr_t);

        if (len - n > 0)
            n += appendExtendedHdr (buf + n, len - n);
        }

    return n;
    }

size_t
RpcPdu::appendExtendedHdr (const char* buf, size_t len)
    {
    COM_ASSERT (m_pduState & HAVE_HDR);

    size_t n = min(len, m_requiredOctets); // octets to copy

    ::memcpy (m_headerOffset, buf, n);

    m_headerOffset += n;
    m_requiredOctets -= n;

    if (m_requiredOctets == 0)
        {
        // Un-NDR the remainder of the header...
        extHdrReformat (drep ());

        // mark the next state's requirements
        m_pduState = HAVE_XHDR;
        m_requiredOctets = fragLen () - hdrLen ();

        if (m_requiredOctets > 0)
            m_stubData.reserve (m_requiredOctets);

        if (m_requiredOctets > 0 && (len - n) > 0)
            n += appendStubData (buf + n, len - n);
        else if (m_requiredOctets == 0)
            m_pduState = HAVE_STUB;
        }

    return n;
    }

size_t
RpcPdu::appendStubData (const char* buf, size_t len)
    {
    size_t n = min(len, m_requiredOctets); // octets to copy

    m_stubData.insert (m_stubData.end (), buf, buf + n);

    if ((m_requiredOctets -= n) == 0)
        m_pduState = HAVE_STUB;

    return n;
    }

size_t
RpcPdu::append (const char* buf, size_t len)
    {
    if (len < 0)