开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
RpcPdu.cpp
资源名称：vxwork_src.rar　[点击查看]
上传用户：nvosite88
上传日期：2007-01-17
资源大小：4983k
文件大小：20k
源码类别：

VxWorks

开发平台：

C/C++

RpcPdu.cpp：源码内容
  1. /* RpcPdu.cpp - COM/DCOM RpcPdu class implementation */
  3. /*
  4. modification history
  5. --------------------
  6. 01z,17dec01,nel  Add include symbol for diab build.
  7. 01y,10dec01,dbs  diab build
  8. 01x,08oct01,nel  SPR#70120. reformat ALTER_CONTEXT_RESP separately from
  9.                  BIND_ACK.
  10. 01w,13jul01,dbs  fix up includes
  11. 01v,15aug00,nel  Win2K Fix.
  12. 01u,27jun00,dbs  NDR-format presCtxId
  13. 01t,22jun00,dbs  add accessors for alter_context_resp
  14. 01s,19aug99,aim  change assert to VXDCOM_ASSERT
  15. 01r,20jul99,aim  grow vector when building incoming pdu
  16. 01q,09jul99,dbs  copied from NRpcPdu into RpcPdu files
  17. 01p,07jul99,aim  removed debug from makeReplyBuffer
  18. 01o,06jul99,aim  added isBindNak
  19. 01n,02jul99,aim  added isBindAck
  20. 01m,25jun99,dbs  add authn properties
  21. 01l,24jun99,dbs  move authn into new class
  22. 01k,18jun99,aim  set data rep on outgoing packets
  23. 01j,17jun99,aim  changed assert to assert
  24. 01i,01jun99,dbs  add NDR formatting to FAULT packet header
  25. 01h,19may99,dbs  send packet in fragments so no copying required
  26. 01g,11may99,dbs  rename VXCOM to VXDCOM
  27. 01f,07may99,dbs  add method to return object ID
  28. 01e,29apr99,dbs  fix -Wall warnings
  29. 01d,28apr99,dbs  add mem-pool
  30. 01c,26apr99,aim  added TRACE_CALL
  31. 01b,21apr99,dbs  change RPCMSG to RpcPdu
  32. 01a,20apr99,dbs  created during Grand Renaming
  34. */
  36. /*
  37.   DESCRIPTION:
  39.   RpcPdu -- RPC Protocol Data Unit class.
  41. */
  43. #include <stdio.h>
  44. #include <ctype.h>
  45. #include "RpcPdu.h"
  46. #include "orpcLib.h"
  47. #include "dcomProxy.h"
  48. #include "Syslog.h"
  49. #include "TraceCall.h"
  51. /* Include symbol for diab */
  52. extern "C" int include_vxdcom_RpcPdu (void)
  53.     {
  54.     return 0;
  55.     }
  57. //////////////////////////////////////////////////////////////////////////
  58. //
  60. RpcPdu::RpcPdu ()
  61.   : m_headerOffset (0),
  62.     m_stubData (),
  63.     m_requiredOctets (sizeof (rpc_cn_common_hdr_t)),
  64.     m_pduState (HAVE_NONE)
  65.     {
  66.     TRACE_CALL;
  67.     m_headerOffset = reinterpret_cast<char*> (&m_header);
  68.     (void) ::memset (&m_header, 0, sizeof (m_header));
  69.     }
  71. RpcPdu::~RpcPdu ()
  72.     {
  73.     TRACE_CALL;
  74.     }
  76. //////////////////////////////////////////////////////////////////////////
  77. //
  79. void RpcPdu::guidReformat
  80.     (
  81.     GUID&                guid,
  82.     ULONG                drep
  83.     )
  84.     {
  85.     TRACE_CALL;
  86.     ndr_make_right (guid.Data1, drep);
  87.     ndr_make_right (guid.Data2, drep);
  88.     ndr_make_right (guid.Data3, drep);
  89.     }
  91. //////////////////////////////////////////////////////////////////////////
  92. //
  94. void RpcPdu::commonHdrReformat
  95.     (
  96.     ULONG                drep
  97.     )
  98.     {
  99.     TRACE_CALL;
  100.     rpc_cn_packet_t* pHdr = &m_header;
  101.     
  102.     ndr_make_right (pHdr->request.hdr.fragLen, drep);
  103.     ndr_make_right (pHdr->request.hdr.authLen, drep);
  104.     ndr_make_right (pHdr->request.hdr.callId, drep);
  105.     }
  107. //////////////////////////////////////////////////////////////////////////
  108. //
  110. void RpcPdu::extHdrReformat
  111.     (
  112.     ULONG                drep
  113.     )
  114.     {
  115.     TRACE_CALL;
  116.     rpc_cn_packet_t* pHdr = &m_header;
  117.     
  118.     switch (pHdr->request.hdr.packetType)
  119.         {
  120.         case RPC_CN_PKT_REQUEST:
  121.             ndr_make_right (pHdr->request.allocHint, drep);
  122.             ndr_make_right (pHdr->request.presCtxId, drep);
  123.             ndr_make_right (pHdr->request.methodNum, drep);
  124.             if (pHdr->request.hdr.flags & RPC_CN_FLAGS_OBJECT_UUID)
  125.                 guidReformat (pHdr->request.objectId, drep);
  126.             break;
  128.         case RPC_CN_PKT_RESPONSE:
  129.             ndr_make_right (pHdr->request.allocHint, drep);
  130.             ndr_make_right (pHdr->request.presCtxId, drep);
  131.             break;
  133.         case RPC_CN_PKT_BIND:
  134.         case RPC_CN_PKT_ALTER_CONTEXT:
  135.             ndr_make_right (pHdr->bind.maxTxFrag, drep);
  136.             ndr_make_right (pHdr->bind.maxRxFrag, drep);
  137.             ndr_make_right (pHdr->bind.assocGroupId, drep);
  138.             guidReformat (pHdr->bind.presCtxList.presCtxElem
  139.                           [0].abstractSyntax.id,
  140.                           drep);
  141.             ndr_make_right (pHdr->bind.presCtxList.presCtxElem
  142.                  [0].abstractSyntax.version, drep);
  143.             ndr_make_right (pHdr->bind.presCtxList.presCtxElem[0].presCtxId, 
  144.                             drep);
  145.             guidReformat (pHdr->bind.presCtxList.presCtxElem
  146.                           [0].transferSyntax [0].id,
  147.                           drep);
  148.             ndr_make_right (pHdr->bind.presCtxList.presCtxElem
  149.                  [0].transferSyntax [0].version, drep);
  150.             break;
  152.         case RPC_CN_PKT_BIND_ACK:
  153.     ndr_make_right (pHdr->bind_ack.maxTxFrag, drep);
  154.     ndr_make_right (pHdr->bind_ack.maxRxFrag, drep);
  155.     ndr_make_right (pHdr->bind_ack.assocGroupId, drep);
  156.     ndr_make_right (pHdr->bind_ack.secAddr.len, drep);
  157.             ndr_make_right (pHdr->bind_ack.resultList.presResult [0].result, drep);
  158.             ndr_make_right (pHdr->bind_ack.resultList.presResult [0].reason, drep);
  159.     ndr_make_right (pHdr->bind_ack.resultList.presResult
  160.     [0].transferSyntax.version, drep);
  161.     guidReformat (pHdr->bind_ack.resultList.presResult
  162.   [0].transferSyntax.id, drep);
  163.             break;
  168.         case RPC_CN_PKT_ALTER_CONTEXT_RESP:
  169.     ndr_make_right (pHdr->alter_context_resp.maxTxFrag, drep);
  170.     ndr_make_right (pHdr->alter_context_resp.maxRxFrag, drep);
  171.     ndr_make_right (pHdr->alter_context_resp.assocGroupId, drep);
  172.     ndr_make_right (pHdr->alter_context_resp.secAddr, drep);
  173.             ndr_make_right (pHdr->alter_context_resp.resultList.presResult [0].result, drep);
  174.             ndr_make_right (pHdr->alter_context_resp.resultList.presResult [0].reason, drep);
  175.     ndr_make_right (pHdr->alter_context_resp.resultList.presResult
  176.     [0].transferSyntax.version, drep);
  177.     guidReformat (pHdr->alter_context_resp.resultList.presResult
  178.   [0].transferSyntax.id, drep);
  179.             break;
  182.         case RPC_CN_PKT_FAULT:
  183.             ndr_make_right (pHdr->fault.status, drep);
  184.             break;
  185.         }
  186.     }
  188. //////////////////////////////////////////////////////////////////////////
  189. //
  191. const rpc_cn_auth_tlr_t*
  192. RpcPdu::authTrailer () const
  193.     {
  194.     TRACE_CALL;
  196.     ULONG alen = authLen ();
  198.     if (alen == 0)
  199.         return 0;
  201. #ifdef __DCC__
  202.     const char* stubDataOffset = &(*(m_stubData.begin ()));
  203. #else
  204.     const char* stubDataOffset = reinterpret_cast<const char*>
  205.                                  (m_stubData.begin ());
  206. #endif
  207.     
  208.     if (stubDataOffset == 0)
  209.         return 0;
  211.     return reinterpret_cast<rpc_cn_auth_tlr_t*>
  212.         (const_cast<char *>
  213.         (stubDataOffset + (payloadLen () -
  214.                            (alen + SIZEOF_AUTH_TLR_PREAMBLE))));
  215.     }
  217. // this always includes the auth-trailer if present
  218. size_t
  219. RpcPdu::payloadLen () const
  220.     {
  221.     TRACE_CALL;
  222.     return m_stubData.size ();
  223.     }
  225. // this *only* the stub data length
  226. size_t RpcPdu::stubDataLen () const
  227.     {
  228.     return (payloadLen () - authLen ());
  229.     }
  232. ULONG
  233. RpcPdu::hdrLen () const
  234.     {
  235.     TRACE_CALL;
  236.     ULONG n = 0;
  238.     switch (m_header.request.hdr.packetType)
  239.         {
  240.         case RPC_CN_PKT_REQUEST:
  241.             n = sizeof (rpc_cn_request_hdr_t);
  242.             if (! (m_header.request.hdr.flags & RPC_CN_FLAGS_OBJECT_UUID))
  243.                 n -= sizeof (GUID);
  244.             break;
  246.         case RPC_CN_PKT_RESPONSE:
  247.             n = sizeof (rpc_cn_response_hdr_t);
  248.             break;
  250.         case RPC_CN_PKT_BIND:
  251.         case RPC_CN_PKT_ALTER_CONTEXT:
  252.             n = sizeof (rpc_cn_bind_hdr_t);
  253.             break;
  255.         case RPC_CN_PKT_BIND_ACK:
  256.             n = sizeof (rpc_cn_bind_ack_hdr_t);
  257.             break;
  259.         case RPC_CN_PKT_ALTER_CONTEXT_RESP:
  260.             n = sizeof (rpc_cn_alter_context_resp_hdr_t);
  261.             break;
  263.         case RPC_CN_PKT_BIND_NAK:
  264.             n = sizeof (rpc_cn_bind_nak_hdr_t);
  265.             break;
  267.         case RPC_CN_PKT_AUTH3:
  268.             n = sizeof (rpc_cn_auth3_hdr_t);
  269.             break;
  270.             
  271.         case RPC_CN_PKT_SHUTDOWN:
  272.         case RPC_CN_PKT_REMOTE_ALERT:
  273.         case RPC_CN_PKT_ORPHANED:
  274.             n = sizeof (rpc_cn_common_hdr_t);
  275.             break;
  277.         case RPC_CN_PKT_FAULT:
  278.             n = sizeof (rpc_cn_fault_hdr_t);
  279.             break;
  281.         default:
  282.             // log warning
  283.             n = 4096;
  284.             break;
  285.         }
  287.     return n;
  288.     }
  289.     
  290. void
  291. RpcPdu::opnumSet (USHORT op)
  292.     {
  293.     TRACE_CALL;
  294.     m_header.request.methodNum = op;
  295.     }
  297. void
  298. RpcPdu::fragLenSet ()
  299.     {
  300.     TRACE_CALL;
  301.     int len = hdrLen () + payloadLen ();
  302.     m_header.request.hdr.fragLen = len;
  303.     if (packetType () == RPC_CN_PKT_REQUEST)
  304.         m_header.request.allocHint = len;
  305.     else if (packetType () == RPC_CN_PKT_RESPONSE)
  306.         m_header.response.allocHint = len;
  307.     }
  309. void
  310. RpcPdu::authLenSet (size_t n)
  311.     {
  312.     TRACE_CALL;
  313.     m_header.request.hdr.authLen = n;
  314.     }
  316. void
  317. RpcPdu::drepSet ()
  318.     {
  319.     TRACE_CALL;
  320.     * (ULONG*) m_header.request.hdr.drep = ORPC_WIRE_DREP;
  321.     }
  323. void
  324. RpcPdu::drepSet (ULONG dr)
  325.     {
  326.     TRACE_CALL;
  327.     * (ULONG*) m_header.request.hdr.drep = dr;
  328.     }
  330. size_t
  331. RpcPdu::stubDataAppend (const void* pv, size_t n)
  332.     {
  333.     TRACE_CALL;
  334.     const char* p = reinterpret_cast<const char*> (pv);
  335.     m_stubData.insert (m_stubData.end (), p, p +n);
  336.     return n;
  337.     }
  339. const GUID& RpcPdu::objectId () const
  340.     {
  341.     TRACE_CALL;
  343.     if (m_header.request.hdr.flags & RPC_CN_FLAGS_OBJECT_UUID)
  344.         return m_header.request.objectId;
  346.     return GUID_NULL;
  347.     }
  349. ///////////////////////////////////////////////////////////////////////////////
  350. //
  352. bool
  353. RpcPdu::complete () const
  354.     {
  355.     return m_pduState & HAVE_STUB;
  356.     }
  358. size_t
  359. RpcPdu::appendCommonHdr (const char* buf, size_t len)
  360.     {
  361.     COM_ASSERT (m_pduState & HAVE_NONE);
  363.     size_t n = min(len, m_requiredOctets); // octets to copy
  365.     ::memcpy (m_headerOffset, buf, n);
  367.     m_headerOffset += n;
  368.     m_requiredOctets -= n;
  370.     if (m_requiredOctets == 0)
  371.         {
  372.         // Un-NDR the packet header...
  373.         commonHdrReformat (drep ());
  375.         // mark the next state's requirements
  376.         m_pduState = HAVE_HDR;
  377.         m_requiredOctets = hdrLen () - sizeof (rpc_cn_common_hdr_t);
  379.         if (len - n > 0)
  380.             n += appendExtendedHdr (buf + n, len - n);
  381.         }
  383.     return n;
  384.     }
  386. size_t
  387. RpcPdu::appendExtendedHdr (const char* buf, size_t len)
  388.     {
  389.     COM_ASSERT (m_pduState & HAVE_HDR);
  391.     size_t n = min(len, m_requiredOctets); // octets to copy
  393.     ::memcpy (m_headerOffset, buf, n);
  395.     m_headerOffset += n;
  396.     m_requiredOctets -= n;
  398.     if (m_requiredOctets == 0)
  399.         {
  400.         // Un-NDR the remainder of the header...
  401.         extHdrReformat (drep ());
  403.         // mark the next state's requirements
  404.         m_pduState = HAVE_XHDR;
  405.         m_requiredOctets = fragLen () - hdrLen ();
  407.         if (m_requiredOctets > 0)
  408.             m_stubData.reserve (m_requiredOctets);
  410.         if (m_requiredOctets > 0 && (len - n) > 0)
  411.             n += appendStubData (buf + n, len - n);
  412.         else if (m_requiredOctets == 0)
  413.             m_pduState = HAVE_STUB;
  414.         }
  416.     return n;
  417.     }
  419. size_t
  420. RpcPdu::appendStubData (const char* buf, size_t len)
  421.     {
  422.     size_t n = min(len, m_requiredOctets); // octets to copy
  424.     m_stubData.insert (m_stubData.end (), buf, buf + n);
  426.     if ((m_requiredOctets -= n) == 0)
  427.         m_pduState = HAVE_STUB;
  429.     return n;
  430.     }
  432. size_t
  433. RpcPdu::append (const char* buf, size_t len)
  434.     {
  435.     if (len < 0)
  436.         return 0;
  438.     switch (m_pduState)
  439.         {
  440.     case HAVE_NONE:
  441.         return appendCommonHdr (buf, len);
  442.     case HAVE_HDR:
  443.         return appendExtendedHdr (buf, len);
  444.     case HAVE_XHDR:
  445.         return appendStubData (buf, len);
  446.     default:
  447.         return 0;
  448.         }
  450.     return 0;
  451.     }
  453. const rpc_cn_common_hdr_t*
  454. RpcPdu::commonHdr () const
  455.     {
  456.     return &m_header.request.hdr;
  457.     }
  459. size_t
  460. RpcPdu::commonHdrLen () const
  461.     {
  462.     return sizeof (m_header.request.hdr);
  463.     }
  464.     
  465. const rpc_cn_bind_ack_hdr_t&
  466. RpcPdu::bind_ack () const
  467.     {
  468.     return m_header.bind_ack;
  469.     }
  471. const rpc_cn_bind_nak_hdr_t&
  472. RpcPdu::bind_nak () const
  473.     {
  474.     return m_header.bind_nak;
  475.     }
  477. const rpc_cn_bind_hdr_t&
  478. RpcPdu::bind () const
  479.     {
  480.     return m_header.bind;
  481.     }
  483. const rpc_cn_request_hdr_t&
  484. RpcPdu::request () const
  485.     {
  486.     return m_header.request;
  487.     }
  488.     
  489. const rpc_cn_response_hdr_t&
  490. RpcPdu::response () const
  491.     {
  492.     return m_header.response;
  493.     }
  495. const rpc_cn_auth3_hdr_t&
  496. RpcPdu::auth3 () const
  497.     {
  498.     return m_header.auth3;
  499.     }
  501. const rpc_cn_fault_hdr_t&
  502. RpcPdu::fault () const
  503.     {
  504.     return m_header.fault;
  505.     }
  507. const rpc_cn_alter_context_resp_hdr_t&
  508. RpcPdu::alter_context_resp () const
  509.     {
  510.     return m_header.alter_context_resp;
  511.     }
  513. rpc_cn_common_hdr_t*
  514. RpcPdu::commonHdr () 
  515.     {
  516.     return &m_header.request.hdr;
  517.     }
  518.     
  519. rpc_cn_bind_ack_hdr_t&
  520. RpcPdu::bind_ack () 
  521.     {
  522.     return m_header.bind_ack;
  523.     }
  524.     
  525. rpc_cn_bind_nak_hdr_t&
  526. RpcPdu::bind_nak ()
  527.     {
  528.     return m_header.bind_nak;
  529.     }
  531. rpc_cn_bind_hdr_t&
  532. RpcPdu::bind ()
  533.     {
  534.     return m_header.bind;
  535.     }
  537. rpc_cn_request_hdr_t&
  538. RpcPdu::request ()
  539.     {
  540.     return m_header.request;
  541.     }
  542.     
  543. rpc_cn_response_hdr_t&
  544. RpcPdu::response ()
  545.     {
  546.     return m_header.response;
  547.     }
  549. rpc_cn_auth3_hdr_t&
  550. RpcPdu::auth3 ()
  551.     {
  552.     return m_header.auth3;
  553.     }
  555. rpc_cn_fault_hdr_t&
  556. RpcPdu::fault ()
  557.     {
  558.     return m_header.fault;
  559.     }
  561. rpc_cn_alter_context_resp_hdr_t&
  562. RpcPdu::alter_context_resp ()
  563.     {
  564.     return m_header.alter_context_resp;
  565.     }
  567. ULONG
  568. RpcPdu::drep () const
  569.     {
  570.     return * (reinterpret_cast<const ULONG*> (m_header.request.hdr.drep));
  571.     }
  573. ULONG 
  574. RpcPdu::opnum () const
  575.     {
  576.     return m_header.request.methodNum;
  577.     }
  579. ULONG
  580. RpcPdu::callId () const
  581.     {
  582.     return m_header.request.hdr.callId;
  583.     }
  585. int
  586. RpcPdu::packetType () const
  587.     {
  588.     return m_header.request.hdr.packetType;
  589.     }
  591. USHORT
  592. RpcPdu::fragLen () const
  593.     {
  594.     return m_header.request.hdr.fragLen;
  595.     }
  597. ULONG
  598. RpcPdu::authLen () const
  599.     {
  600.     return m_header.request.hdr.authLen;
  601.     }
  603. const void*
  604. RpcPdu::stubData () const
  605.     {
  606. #ifdef __DCC__
  607.     return &(*(m_stubData.begin ()));
  608. #else
  609.     return m_stubData.begin ();
  610. #endif
  611.     }
  613. void*
  614. RpcPdu::stubData ()
  615.     {
  616. #ifdef __DCC__
  617.     return &(*(m_stubData.begin ()));
  618. #else
  619.     return m_stubData.begin ();
  620. #endif
  621.     }
  623. bool
  624. RpcPdu::isRequest () const
  625.     {
  626.     return (packetType () == RPC_CN_PKT_REQUEST);
  627.     }
  629. bool
  630. RpcPdu::isBind () const
  631.     {
  632.     return ((packetType () == RPC_CN_PKT_BIND) ||
  633.             (packetType () == RPC_CN_PKT_ALTER_CONTEXT));
  634.     }
  636. bool
  637. RpcPdu::isBindAck () const
  638.     {
  639.     return (packetType () == RPC_CN_PKT_BIND_ACK);
  640.     }
  642. bool
  643. RpcPdu::isBindNak () const
  644.     {
  645.     return (packetType () == RPC_CN_PKT_BIND_NAK);
  646.     }
  648. bool
  649. RpcPdu::isAuth3 () const
  650.     {
  651.     return (packetType () == RPC_CN_PKT_AUTH3);
  652.     }
  654. bool
  655. RpcPdu::isResponse () const
  656.     {
  657.     return (packetType () == RPC_CN_PKT_RESPONSE);
  658.     }
  660. bool
  661. RpcPdu::isFault () const
  662.     {
  663.     return (packetType () == RPC_CN_PKT_FAULT);
  664.     }
  666. bool
  667. RpcPdu::isAlterContextResp () const
  668.     {
  669.     return (packetType () == RPC_CN_PKT_ALTER_CONTEXT_RESP);
  670.     }
  672. int
  673. RpcPdu::makeReplyBuffer (char*& buf, size_t& buflen)
  674.     {
  675.     int hdrLength = hdrLen ();
  676.     int payloadLength = payloadLen ();
  678.     buflen = hdrLength + payloadLength;
  680.     buf = new char[buflen];
  682.     if (buf)
  683.         {
  684.         // Set the fragment-length field, and the DREP...
  685.         fragLenSet ();
  686.         drepSet ();
  688.         // Format the packet into the correct NDR mode...
  689.         commonHdrReformat (drep ());
  690.         extHdrReformat (drep ());
  692.         char* header = reinterpret_cast<char*> (&m_header);
  694.         ::memcpy (buf, header, hdrLength);
  696.         if (payloadLength > 0)
  697.             ::memcpy (buf + hdrLength, stubData (), payloadLength);
  698.         }
  700.     return buf ? 0 : -1;
  701.     }
  703. GUID
  704. RpcPdu::iid () const
  705.     {
  706.     // assumes its a bind packet
  707.     return bind ().presCtxList.presCtxElem [0].abstractSyntax.id;
  708.     }
  710. ostream&
  711. operator<< (ostream& os, const RpcPdu& pdu)
  712.     {
  713.     char hex_string [64];
  714.     char chr_string [32];
  715.     char details [8192];        // XXX
  716.     char* s = "UNKNOWN!";
  717.     int nBytes = pdu.payloadLen ();
  719.     // Print packet type
  720.     details [0] = 0;
  722.     switch (pdu.packetType ())
  723.         {
  724.         case RPC_CN_PKT_REQUEST:
  725.             s="REQUEST";
  726.             sprintf (details, "allocHint=%lu pres-ctx=%u opnum=%u objUuid=%s",
  727.                      pdu.request ().allocHint,
  728.                      pdu.request ().presCtxId,
  729.                      pdu.request ().methodNum,
  730.                      (pdu.request ().hdr.flags & RPC_CN_FLAGS_OBJECT_UUID) ? 
  731.                      vxcomGUID2String (pdu.request ().objectId) : "not-present");
  732.             break;
  734.         case RPC_CN_PKT_RESPONSE:
  735.             s="RESPONSE";
  736.             sprintf (details, "allocHint=%lu pres-ctx=%u alertCount=%u",
  737.                      pdu.response ().allocHint,
  738.                      pdu.response ().presCtxId,
  739.                      pdu.response ().alertCount);
  740.             break;
  742.         case RPC_CN_PKT_FAULT: s="FAULT";
  743.             sprintf (details, "faultCode=0x%lx", pdu.fault().status);
  744.             break;
  746.         case RPC_CN_PKT_ALTER_CONTEXT:
  747.         case RPC_CN_PKT_BIND:
  748.             if (pdu.packetType () == RPC_CN_PKT_BIND)
  749.                 s="BIND";
  750.             else
  751.                 s="ALTER CONTEXT";
  752.             sprintf (details,
  753.                      "max-txFragSize=%u max-rxFragSize=%u assoc-grp-ID=0x%8.8lX pres-ctx=%d, IID=%s",
  754.                      pdu.bind ().maxTxFrag,
  755.                      pdu.bind ().maxRxFrag,
  756.                      pdu.bind ().assocGroupId,
  757.                      pdu.bind().presCtxList.presCtxElem[0].presCtxId,
  758.                      vxcomGUID2String (pdu.bind ().presCtxList.presCtxElem [0].abstractSyntax.id));
  759.             break;
  761.         case RPC_CN_PKT_ALTER_CONTEXT_RESP:
  762.         case RPC_CN_PKT_BIND_ACK:
  763.             if (pdu.packetType () == RPC_CN_PKT_BIND_ACK)
  764.                 s="BIND ACK";
  765.             else
  766.                 s="ALTER CONTEXT RESP";
  767.             sprintf (details,
  768.                      "max-txFragSize=%u max-rxFragSize=%u assoc-grp-ID=0x%8.8lX result=%u",
  769.                      pdu.bind_ack ().maxTxFrag,
  770.                      pdu.bind_ack ().maxRxFrag,
  771.                      pdu.bind_ack ().assocGroupId,
  772.                      pdu.bind_ack ().resultList.presResult [0].result);
  773.             break;
  775.         case RPC_CN_PKT_BIND_NAK:
  776.             s="BIND NAK";
  777.             break;
  779.         case RPC_CN_PKT_AUTH3: s="AUTH3"; break;
  780.         case RPC_CN_PKT_SHUTDOWN: s="SHUTDOWN"; break;
  781.         case RPC_CN_PKT_REMOTE_ALERT: s="ALERT"; break;
  782.         case RPC_CN_PKT_ORPHANED: s="ORPHANED"; break;
  783.         }
  784.     
  785.     os << s << " " << details;
  787.     // Print common-header info...
  788.     sprintf (details,
  789.              "ver=%d.%d flags=0x%2.2X fragmentLength=0x%X authLen=%u callID=%lu intDataRep=%s",
  790.              pdu.request ().hdr.rpcVersion,
  791.              pdu.request ().hdr.rpcMinorVersion,
  792.              pdu.request ().hdr.flags,
  793.              pdu.request ().hdr.fragLen,
  794.              pdu.request ().hdr.authLen,
  795.              pdu.request ().hdr.callId,
  796.              pdu.request ().hdr.drep [0] ? "littleEndian" :
  797.              "bigEndian");
  799.     os << " " << details << endl;
  801.     if (nBytes > 0)
  802.         {
  803.         os << " payloadLen: " << nBytes << endl;
  805.         // Binary/hex dump...
  806.         char* pbase = (char*) pdu.stubData ();
  807.         char* p = pbase;
  808.         while (nBytes > 0)
  809.             {
  810.             char*   phex = hex_string;
  811.             char*   pchr = chr_string;
  812.             
  813.             for (int j=0; j < 16; ++j)
  814.                 {
  815.                 if (nBytes > 0)
  816.                     {
  817.                     int val = p [j] & 0xFF;
  818.                     sprintf (phex, "%02X ", val);
  819.                     sprintf (pchr, "%c", isprint (val) ? val : '.');
  820.                     }
  821.                 else
  822.                     sprintf (phex, "   ");
  824.                 phex += 3;
  825.                 ++pchr;
  826.                 --nBytes;
  827.                 }
  829.               void* a = reinterpret_cast<void*> (p - pbase);
  830.               os << a << ": " << hex_string << " " << chr_string << endl;
  832.             *phex = 0;
  833.             *pchr = 0;
  835.             p += 16;
  836.             }
  837.         }
  839.     return os;
  840.     }
  842. ///////////////////////////////////////////////////////////////////////////////
  843. //
  845. void
  846. RpcPdu::stubDataAlign (size_t n)
  847.     {
  848.     while ((m_stubData.size () % n) != 0)
  849.         m_stubData.push_back (0);
  850.     }
  852. //////////////////////////////////////////////////////////////////////////
  853. //
  854. // authTrailerAppend -- appends the trailer in 'tlr' to the current
  855. // packet, its auth-data is of length 'authlen'...
  856. //
  858. HRESULT RpcPdu::authTrailerAppend
  859.     (
  860.     const rpc_cn_auth_tlr_t&        tlr,
  861.     size_t                        authlen
  862.     )
  863.     {
  864.     stubDataAlign (4);
  865.     stubDataAppend (&tlr, authlen + SIZEOF_AUTH_TLR_PREAMBLE);
  866.     authLenSet (authlen);
  867.     return S_OK;
  868.     }