rpcpdu.cpp

VXWORKS源代码

        return 0;

    switch (m_pduState)
        {
    case HAVE_NONE:
        return appendCommonHdr (buf, len);
    case HAVE_HDR:
        return appendExtendedHdr (buf, len);
    case HAVE_XHDR:
        return appendStubData (buf, len);
    default:
        return 0;
        }

    return 0;
    }

const rpc_cn_common_hdr_t*
RpcPdu::commonHdr () const
    {
    return &m_header.request.hdr;
    }

size_t
RpcPdu::commonHdrLen () const
    {
    return sizeof (m_header.request.hdr);
    }
    
const rpc_cn_bind_ack_hdr_t&
RpcPdu::bind_ack () const
    {
    return m_header.bind_ack;
    }

const rpc_cn_bind_nak_hdr_t&
RpcPdu::bind_nak () const
    {
    return m_header.bind_nak;
    }

const rpc_cn_bind_hdr_t&
RpcPdu::bind () const
    {
    return m_header.bind;
    }

const rpc_cn_request_hdr_t&
RpcPdu::request () const
    {
    return m_header.request;
    }
    
const rpc_cn_response_hdr_t&
RpcPdu::response () const
    {
    return m_header.response;
    }

const rpc_cn_auth3_hdr_t&
RpcPdu::auth3 () const
    {
    return m_header.auth3;
    }

const rpc_cn_fault_hdr_t&
RpcPdu::fault () const
    {
    return m_header.fault;
    }

const rpc_cn_alter_context_resp_hdr_t&
RpcPdu::alter_context_resp () const
    {
    return m_header.alter_context_resp;
    }

rpc_cn_common_hdr_t*
RpcPdu::commonHdr () 
    {
    return &m_header.request.hdr;
    }
    
rpc_cn_bind_ack_hdr_t&
RpcPdu::bind_ack () 
    {
    return m_header.bind_ack;
    }
    
rpc_cn_bind_nak_hdr_t&
RpcPdu::bind_nak ()
    {
    return m_header.bind_nak;
    }

rpc_cn_bind_hdr_t&
RpcPdu::bind ()
    {
    return m_header.bind;
    }

rpc_cn_request_hdr_t&
RpcPdu::request ()
    {
    return m_header.request;
    }
    
rpc_cn_response_hdr_t&
RpcPdu::response ()
    {
    return m_header.response;
    }

rpc_cn_auth3_hdr_t&
RpcPdu::auth3 ()
    {
    return m_header.auth3;
    }

rpc_cn_fault_hdr_t&
RpcPdu::fault ()
    {
    return m_header.fault;
    }

rpc_cn_alter_context_resp_hdr_t&
RpcPdu::alter_context_resp ()
    {
    return m_header.alter_context_resp;
    }

ULONG
RpcPdu::drep () const
    {
    return * (reinterpret_cast<const ULONG*> (m_header.request.hdr.drep));
    }

ULONG 
RpcPdu::opnum () const
    {
    return m_header.request.methodNum;
    }

ULONG
RpcPdu::callId () const
    {
    return m_header.request.hdr.callId;
    }

int
RpcPdu::packetType () const
    {
    return m_header.request.hdr.packetType;
    }

USHORT
RpcPdu::fragLen () const
    {
    return m_header.request.hdr.fragLen;
    }

ULONG
RpcPdu::authLen () const
    {
    return m_header.request.hdr.authLen;
    }

const void*
RpcPdu::stubData () const
    {
#ifdef __DCC__
    return &(*(m_stubData.begin ()));
#else
    return m_stubData.begin ();
#endif
    }

void*
RpcPdu::stubData ()
    {
#ifdef __DCC__
    return &(*(m_stubData.begin ()));
#else
    return m_stubData.begin ();
#endif
    }

bool
RpcPdu::isRequest () const
    {
    return (packetType () == RPC_CN_PKT_REQUEST);
    }

bool
RpcPdu::isBind () const
    {
    return ((packetType () == RPC_CN_PKT_BIND) ||
            (packetType () == RPC_CN_PKT_ALTER_CONTEXT));
    }

bool
RpcPdu::isBindAck () const
    {
    return (packetType () == RPC_CN_PKT_BIND_ACK);
    }

bool
RpcPdu::isBindNak () const
    {
    return (packetType () == RPC_CN_PKT_BIND_NAK);
    }

bool
RpcPdu::isAuth3 () const
    {
    return (packetType () == RPC_CN_PKT_AUTH3);
    }

bool
RpcPdu::isResponse () const
    {
    return (packetType () == RPC_CN_PKT_RESPONSE);
    }

bool
RpcPdu::isFault () const
    {
    return (packetType () == RPC_CN_PKT_FAULT);
    }

bool
RpcPdu::isAlterContextResp () const
    {
    return (packetType () == RPC_CN_PKT_ALTER_CONTEXT_RESP);
    }

int
RpcPdu::makeReplyBuffer (char*& buf, size_t& buflen)
    {
    int hdrLength = hdrLen ();
    int payloadLength = payloadLen ();

    buflen = hdrLength + payloadLength;

    buf = new char[buflen];

    if (buf)
        {
        // Set the fragment-length field, and the DREP...
        fragLenSet ();
        drepSet ();

        // Format the packet into the correct NDR mode...
        commonHdrReformat (drep ());
        extHdrReformat (drep ());

        char* header = reinterpret_cast<char*> (&m_header);

        ::memcpy (buf, header, hdrLength);

        if (payloadLength > 0)
            ::memcpy (buf + hdrLength, stubData (), payloadLength);
        }

    return buf ? 0 : -1;
    }

GUID
RpcPdu::iid () const
    {
    // assumes its a bind packet
    return bind ().presCtxList.presCtxElem [0].abstractSyntax.id;
    }

ostream&
operator<< (ostream& os, const RpcPdu& pdu)
    {
    char hex_string [64];
    char chr_string [32];
    char details [8192];        // XXX
    char* s = "UNKNOWN!";
    int nBytes = pdu.payloadLen ();

    // Print packet type
    details [0] = 0;

    switch (pdu.packetType ())
        {
        case RPC_CN_PKT_REQUEST:
            s="REQUEST";
            sprintf (details, "allocHint=%lu pres-ctx=%u opnum=%u objUuid=%s",
                     pdu.request ().allocHint,
                     pdu.request ().presCtxId,
                     pdu.request ().methodNum,
                     (pdu.request ().hdr.flags & RPC_CN_FLAGS_OBJECT_UUID) ? 
                     vxcomGUID2String (pdu.request ().objectId) : "not-present");
            break;

        case RPC_CN_PKT_RESPONSE:
            s="RESPONSE";
            sprintf (details, "allocHint=%lu pres-ctx=%u alertCount=%u",
                     pdu.response ().allocHint,
                     pdu.response ().presCtxId,
                     pdu.response ().alertCount);
            break;

        case RPC_CN_PKT_FAULT: s="FAULT";
            sprintf (details, "faultCode=0x%lx", pdu.fault().status);
            break;

        case RPC_CN_PKT_ALTER_CONTEXT:
        case RPC_CN_PKT_BIND:
            if (pdu.packetType () == RPC_CN_PKT_BIND)
                s="BIND";
            else
                s="ALTER CONTEXT";
            sprintf (details,
                     "max-txFragSize=%u max-rxFragSize=%u assoc-grp-ID=0x%8.8lX pres-ctx=%d, IID=%s",
                     pdu.bind ().maxTxFrag,
                     pdu.bind ().maxRxFrag,
                     pdu.bind ().assocGroupId,
                     pdu.bind().presCtxList.presCtxElem[0].presCtxId,
                     vxcomGUID2String (pdu.bind ().presCtxList.presCtxElem [0].abstractSyntax.id));
            break;

        case RPC_CN_PKT_ALTER_CONTEXT_RESP:
        case RPC_CN_PKT_BIND_ACK:
            if (pdu.packetType () == RPC_CN_PKT_BIND_ACK)
                s="BIND ACK";
            else
                s="ALTER CONTEXT RESP";
            sprintf (details,
                     "max-txFragSize=%u max-rxFragSize=%u assoc-grp-ID=0x%8.8lX result=%u",
                     pdu.bind_ack ().maxTxFrag,
                     pdu.bind_ack ().maxRxFrag,
                     pdu.bind_ack ().assocGroupId,
                     pdu.bind_ack ().resultList.presResult [0].result);
            break;

        case RPC_CN_PKT_BIND_NAK:
            s="BIND NAK";
            break;

        case RPC_CN_PKT_AUTH3: s="AUTH3"; break;
        case RPC_CN_PKT_SHUTDOWN: s="SHUTDOWN"; break;
        case RPC_CN_PKT_REMOTE_ALERT: s="ALERT"; break;
        case RPC_CN_PKT_ORPHANED: s="ORPHANED"; break;
        }
    
    os << s << " " << details;

    // Print common-header info...
    sprintf (details,
             "ver=%d.%d flags=0x%2.2X fragmentLength=0x%X authLen=%u callID=%lu intDataRep=%s",
             pdu.request ().hdr.rpcVersion,
             pdu.request ().hdr.rpcMinorVersion,
             pdu.request ().hdr.flags,
             pdu.request ().hdr.fragLen,
             pdu.request ().hdr.authLen,
             pdu.request ().hdr.callId,
             pdu.request ().hdr.drep [0] ? "littleEndian" :
             "bigEndian");

    os << " " << details << endl;

    if (nBytes > 0)
        {
        os << " payloadLen: " << nBytes << endl;

        // Binary/hex dump...
        char* pbase = (char*) pdu.stubData ();
        char* p = pbase;
        while (nBytes > 0)
            {
            char*   phex = hex_string;
            char*   pchr = chr_string;
            
            for (int j=0; j < 16; ++j)
                {
                if (nBytes > 0)
                    {
                    int val = p [j] & 0xFF;
                    sprintf (phex, "%02X ", val);
                    sprintf (pchr, "%c", isprint (val) ? val : '.');
                    }
                else
                    sprintf (phex, "   ");

                phex += 3;
                ++pchr;
                --nBytes;
                }

              void* a = reinterpret_cast<void*> (p - pbase);
              os << a << ": " << hex_string << " " << chr_string << endl;

            *phex = 0;
            *pchr = 0;

            p += 16;
            }
        }

    return os;
    }

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

void
RpcPdu::stubDataAlign (size_t n)
    {
    while ((m_stubData.size () % n) != 0)
        m_stubData.push_back (0);
    }

//////////////////////////////////////////////////////////////////////////
//
// authTrailerAppend -- appends the trailer in 'tlr' to the current
// packet, its auth-data is of length 'authlen'...
//

HRESULT RpcPdu::authTrailerAppend
    (
    const rpc_cn_auth_tlr_t&        tlr,
    size_t                        authlen
    )
    {
    stubDataAlign (4);
    stubDataAppend (&tlr, authlen + SIZEOF_AUTH_TLR_PREAMBLE);
    authLenSet (authlen);
    return S_OK;
    }