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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 查看源码
RPCSVC_C.C
资源名称：MSDN_VC98.zip　[点击查看]
上传用户：bangxh
上传日期：2007-01-31
资源大小：42235k
文件大小：60k
源码类别：

Windows编程

开发平台：

Visual C++

RPCSVC_C.C：源码内容
  1. /* this ALWAYS GENERATED file contains the RPC client stubs */
  4. /* File created by MIDL compiler version 3.03.0110 */
  5. /* at Mon Mar 30 03:08:52 1998
  6.  */
  7. /* Compiler settings for rpcsvc.idl:
  8.     Os (OptLev=s), W1, Zp8, env=Win32, ms_ext, c_ext
  9.     error checks: none
  10. */
  11. //@@MIDL_FILE_HEADING(  )
  13. #include <string.h>
  14. #if defined( _ALPHA_ )
  15. #include <stdarg.h>
  16. #endif
  18. #include "rpcsvc.h"
  20. #define TYPE_FORMAT_STRING_SIZE   395                               
  21. #define PROC_FORMAT_STRING_SIZE   141                               
  23. typedef struct _MIDL_TYPE_FORMAT_STRING
  24.     {
  25.     short          Pad;
  26.     unsigned char  Format[ TYPE_FORMAT_STRING_SIZE ];
  27.     } MIDL_TYPE_FORMAT_STRING;
  29. typedef struct _MIDL_PROC_FORMAT_STRING
  30.     {
  31.     short          Pad;
  32.     unsigned char  Format[ PROC_FORMAT_STRING_SIZE ];
  33.     } MIDL_PROC_FORMAT_STRING;
  36. extern const MIDL_TYPE_FORMAT_STRING __MIDL_TypeFormatString;
  37. extern const MIDL_PROC_FORMAT_STRING __MIDL_ProcFormatString;
  39. /* Standard interface: RpcServiceSample, ver. 1.0,
  40.    GUID={0x15cd3850,0x28ca,0x11ce,{0xa4,0xe8,0x00,0xaa,0x00,0x61,0x16,0xcb}} */
  44. static const RPC_CLIENT_INTERFACE RpcServiceSample___RpcClientInterface =
  45.     {
  46.     sizeof(RPC_CLIENT_INTERFACE),
  47.     {{0x15cd3850,0x28ca,0x11ce,{0xa4,0xe8,0x00,0xaa,0x00,0x61,0x16,0xcb}},{1,0}},
  48.     {{0x8A885D04,0x1CEB,0x11C9,{0x9F,0xE8,0x08,0x00,0x2B,0x10,0x48,0x60}},{2,0}},
  49.     0,
  50.     0,
  51.     0,
  52.     0,
  53.     0,
  54.     0
  55.     };
  56. RPC_IF_HANDLE RpcServiceSample_v1_0_c_ifspec = (RPC_IF_HANDLE)& RpcServiceSample___RpcClientInterface;
  58. extern const MIDL_STUB_DESC RpcServiceSample_StubDesc;
  60. static RPC_BINDING_HANDLE RpcServiceSample__MIDL_AutoBindHandle;
  63. /* [fault_status][comm_status] */ error_status_t Ping( 
  64.     /* [in] */ handle_t Binding)
  65. {
  67.     RPC_BINDING_HANDLE _Handle = 0;
  68.     
  69.     error_status_t _RetVal;
  70.     
  71.     RPC_MESSAGE _RpcMessage;
  72.     
  73.     RPC_STATUS _Status;
  74.     
  75.     MIDL_STUB_MESSAGE _StubMsg;
  76.     
  77.     RpcTryExcept
  78.         {
  79.         RpcTryFinally
  80.             {
  81.             NdrClientInitializeNew(
  82.                           ( PRPC_MESSAGE  )&_RpcMessage,
  83.                           ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  84.                           ( PMIDL_STUB_DESC  )&RpcServiceSample_StubDesc,
  85.                           0);
  86.             
  87.             
  88.             _Handle = Binding;
  89.             
  90.             
  91.             _StubMsg.BufferLength = 0U;
  92.             NdrGetBuffer( (PMIDL_STUB_MESSAGE) &_StubMsg, _StubMsg.BufferLength, _Handle );
  93.             
  94.             NdrSendReceive( (PMIDL_STUB_MESSAGE) &_StubMsg, (unsigned char __RPC_FAR *) _StubMsg.Buffer );
  95.             
  96.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  97.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[0] );
  98.             
  99.             _RetVal = *(( error_status_t __RPC_FAR * )_StubMsg.Buffer)++;
  100.             
  101.             }
  102.         RpcFinally
  103.             {
  104.             NdrFreeBuffer( (PMIDL_STUB_MESSAGE) &_StubMsg );
  105.             
  106.             }
  107.         RpcEndFinally
  108.         
  109.         }
  110.     RpcExcept( 1 )
  111.         {
  112.         if(_Status = NdrMapCommAndFaultStatus(( PMIDL_STUB_MESSAGE  )&_StubMsg,( unsigned long __RPC_FAR * )&_RetVal,( unsigned long __RPC_FAR * )&_RetVal,RpcExceptionCode()))
  113.             {
  114.             RpcRaiseException(_Status);
  115.             }
  116.         }
  117.     RpcEndExcept
  118.     return _RetVal;
  119. }
  122. /* [fault_status][comm_status] */ error_status_t CheckSecurity( 
  123.     /* [in] */ handle_t Binding)
  124. {
  126.     RPC_BINDING_HANDLE _Handle = 0;
  127.     
  128.     error_status_t _RetVal;
  129.     
  130.     RPC_MESSAGE _RpcMessage;
  131.     
  132.     RPC_STATUS _Status;
  133.     
  134.     MIDL_STUB_MESSAGE _StubMsg;
  135.     
  136.     RpcTryExcept
  137.         {
  138.         RpcTryFinally
  139.             {
  140.             NdrClientInitializeNew(
  141.                           ( PRPC_MESSAGE  )&_RpcMessage,
  142.                           ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  143.                           ( PMIDL_STUB_DESC  )&RpcServiceSample_StubDesc,
  144.                           1);
  145.             
  146.             
  147.             _Handle = Binding;
  148.             
  149.             
  150.             _StubMsg.BufferLength = 0U;
  151.             NdrGetBuffer( (PMIDL_STUB_MESSAGE) &_StubMsg, _StubMsg.BufferLength, _Handle );
  152.             
  153.             NdrSendReceive( (PMIDL_STUB_MESSAGE) &_StubMsg, (unsigned char __RPC_FAR *) _StubMsg.Buffer );
  154.             
  155.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  156.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[0] );
  157.             
  158.             _RetVal = *(( error_status_t __RPC_FAR * )_StubMsg.Buffer)++;
  159.             
  160.             }
  161.         RpcFinally
  162.             {
  163.             NdrFreeBuffer( (PMIDL_STUB_MESSAGE) &_StubMsg );
  164.             
  165.             }
  166.         RpcEndFinally
  167.         
  168.         }
  169.     RpcExcept( 1 )
  170.         {
  171.         if(_Status = NdrMapCommAndFaultStatus(( PMIDL_STUB_MESSAGE  )&_StubMsg,( unsigned long __RPC_FAR * )&_RetVal,( unsigned long __RPC_FAR * )&_RetVal,RpcExceptionCode()))
  172.             {
  173.             RpcRaiseException(_Status);
  174.             }
  175.         }
  176.     RpcEndExcept
  177.     return _RetVal;
  178. }
  181. /* [fault_status][comm_status] */ error_status_t BufferIn1( 
  182.     /* [in] */ handle_t Binding,
  183.     /* [in][size_is][length_is] */ byte __RPC_FAR Buffer[  ],
  184.     /* [in] */ unsigned long BufferLength,
  185.     /* [in] */ unsigned long BufferSize)
  186. {
  188.     RPC_BINDING_HANDLE _Handle = 0;
  189.     
  190.     error_status_t _RetVal;
  191.     
  192.     RPC_MESSAGE _RpcMessage;
  193.     
  194.     RPC_STATUS _Status;
  195.     
  196.     MIDL_STUB_MESSAGE _StubMsg;
  197.     
  198.     RpcTryExcept
  199.         {
  200.         RpcTryFinally
  201.             {
  202.             NdrClientInitializeNew(
  203.                           ( PRPC_MESSAGE  )&_RpcMessage,
  204.                           ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  205.                           ( PMIDL_STUB_DESC  )&RpcServiceSample_StubDesc,
  206.                           2);
  207.             
  208.             
  209.             _Handle = Binding;
  210.             
  211.             
  212.             _StubMsg.BufferLength = 0U + 12U + 11U + 7U;
  213.             _StubMsg.MaxCount = BufferSize;
  214.             _StubMsg.Offset = 0;
  215.             _StubMsg.ActualCount = BufferLength;
  216.             
  217.             NdrConformantVaryingArrayBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
  218.                                                  (unsigned char __RPC_FAR *)Buffer,
  219.                                                  (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[0] );
  220.             
  221.             NdrGetBuffer( (PMIDL_STUB_MESSAGE) &_StubMsg, _StubMsg.BufferLength, _Handle );
  222.             
  223.             _StubMsg.MaxCount = BufferSize;
  224.             _StubMsg.Offset = 0;
  225.             _StubMsg.ActualCount = BufferLength;
  226.             
  227.             NdrConformantVaryingArrayMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
  228.                                                (unsigned char __RPC_FAR *)Buffer,
  229.                                                (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[0] );
  230.             
  231.             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
  232.             *(( unsigned long __RPC_FAR * )_StubMsg.Buffer)++ = BufferLength;
  233.             
  234.             *(( unsigned long __RPC_FAR * )_StubMsg.Buffer)++ = BufferSize;
  235.             
  236.             NdrSendReceive( (PMIDL_STUB_MESSAGE) &_StubMsg, (unsigned char __RPC_FAR *) _StubMsg.Buffer );
  237.             
  238.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  239.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[4] );
  240.             
  241.             _RetVal = *(( error_status_t __RPC_FAR * )_StubMsg.Buffer)++;
  242.             
  243.             }
  244.         RpcFinally
  245.             {
  246.             NdrFreeBuffer( (PMIDL_STUB_MESSAGE) &_StubMsg );
  247.             
  248.             }
  249.         RpcEndFinally
  250.         
  251.         }
  252.     RpcExcept( 1 )
  253.         {
  254.         if(_Status = NdrMapCommAndFaultStatus(( PMIDL_STUB_MESSAGE  )&_StubMsg,( unsigned long __RPC_FAR * )&_RetVal,( unsigned long __RPC_FAR * )&_RetVal,RpcExceptionCode()))
  255.             {
  256.             RpcRaiseException(_Status);
  257.             }
  258.         }
  259.     RpcEndExcept
  260.     return _RetVal;
  261. }
  264. /* [fault_status][comm_status] */ error_status_t BufferIn2( 
  265.     /* [in] */ handle_t Binding,
  266.     /* [in][length_is] */ byte __RPC_FAR Buffer[ 16384 ],
  267.     /* [in] */ unsigned long BufferLength)
  268. {
  270.     RPC_BINDING_HANDLE _Handle = 0;
  271.     
  272.     error_status_t _RetVal;
  273.     
  274.     RPC_MESSAGE _RpcMessage;
  275.     
  276.     RPC_STATUS _Status;
  277.     
  278.     MIDL_STUB_MESSAGE _StubMsg;
  279.     
  280.     RpcTryExcept
  281.         {
  282.         RpcTryFinally
  283.             {
  284.             NdrClientInitializeNew(
  285.                           ( PRPC_MESSAGE  )&_RpcMessage,
  286.                           ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  287.                           ( PMIDL_STUB_DESC  )&RpcServiceSample_StubDesc,
  288.                           3);
  289.             
  290.             
  291.             _Handle = Binding;
  292.             
  293.             
  294.             _StubMsg.BufferLength = 0U + 0U + 11U;
  295.             _StubMsg.Offset = 0;
  296.             _StubMsg.ActualCount = BufferLength;
  297.             
  298.             NdrVaryingArrayBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
  299.                                        (unsigned char __RPC_FAR *)Buffer,
  300.                                        (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[14] );
  301.             
  302.             NdrGetBuffer( (PMIDL_STUB_MESSAGE) &_StubMsg, _StubMsg.BufferLength, _Handle );
  303.             
  304.             _StubMsg.Offset = 0;
  305.             _StubMsg.ActualCount = BufferLength;
  306.             
  307.             NdrVaryingArrayMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
  308.                                      (unsigned char __RPC_FAR *)Buffer,
  309.                                      (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[14] );
  310.             
  311.             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
  312.             *(( unsigned long __RPC_FAR * )_StubMsg.Buffer)++ = BufferLength;
  313.             
  314.             NdrSendReceive( (PMIDL_STUB_MESSAGE) &_StubMsg, (unsigned char __RPC_FAR *) _StubMsg.Buffer );
  315.             
  316.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  317.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[16] );
  318.             
  319.             _RetVal = *(( error_status_t __RPC_FAR * )_StubMsg.Buffer)++;
  320.             
  321.             }
  322.         RpcFinally
  323.             {
  324.             NdrFreeBuffer( (PMIDL_STUB_MESSAGE) &_StubMsg );
  325.             
  326.             }
  327.         RpcEndFinally
  328.         
  329.         }
  330.     RpcExcept( 1 )
  331.         {
  332.         if(_Status = NdrMapCommAndFaultStatus(( PMIDL_STUB_MESSAGE  )&_StubMsg,( unsigned long __RPC_FAR * )&_RetVal,( unsigned long __RPC_FAR * )&_RetVal,RpcExceptionCode()))
  333.             {
  334.             RpcRaiseException(_Status);
  335.             }
  336.         }
  337.     RpcEndExcept
  338.     return _RetVal;
  339. }
  342. /* [fault_status][comm_status] */ error_status_t BufferIn3( 
  343.     /* [in] */ handle_t Binding,
  344.     /* [in][size_is] */ byte __RPC_FAR Buffer[  ],
  345.     /* [in] */ unsigned long BufferLength)
  346. {
  348.     RPC_BINDING_HANDLE _Handle = 0;
  349.     
  350.     error_status_t _RetVal;
  351.     
  352.     RPC_MESSAGE _RpcMessage;
  353.     
  354.     RPC_STATUS _Status;
  355.     
  356.     MIDL_STUB_MESSAGE _StubMsg;
  357.     
  358.     RpcTryExcept
  359.         {
  360.         RpcTryFinally
  361.             {
  362.             NdrClientInitializeNew(
  363.                           ( PRPC_MESSAGE  )&_RpcMessage,
  364.                           ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  365.                           ( PMIDL_STUB_DESC  )&RpcServiceSample_StubDesc,
  366.                           4);
  367.             
  368.             
  369.             _Handle = Binding;
  370.             
  371.             
  372.             _StubMsg.BufferLength = 0U + 4U + 11U;
  373.             _StubMsg.MaxCount = BufferLength;
  374.             
  375.             NdrConformantArrayBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
  376.                                           (unsigned char __RPC_FAR *)Buffer,
  377.                                           (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[28] );
  378.             
  379.             NdrGetBuffer( (PMIDL_STUB_MESSAGE) &_StubMsg, _StubMsg.BufferLength, _Handle );
  380.             
  381.             _StubMsg.MaxCount = BufferLength;
  382.             
  383.             NdrConformantArrayMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
  384.                                         (unsigned char __RPC_FAR *)Buffer,
  385.                                         (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[28] );
  386.             
  387.             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
  388.             *(( unsigned long __RPC_FAR * )_StubMsg.Buffer)++ = BufferLength;
  389.             
  390.             NdrSendReceive( (PMIDL_STUB_MESSAGE) &_StubMsg, (unsigned char __RPC_FAR *) _StubMsg.Buffer );
  391.             
  392.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  393.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[26] );
  394.             
  395.             _RetVal = *(( error_status_t __RPC_FAR * )_StubMsg.Buffer)++;
  396.             
  397.             }
  398.         RpcFinally
  399.             {
  400.             NdrFreeBuffer( (PMIDL_STUB_MESSAGE) &_StubMsg );
  401.             
  402.             }
  403.         RpcEndFinally
  404.         
  405.         }
  406.     RpcExcept( 1 )
  407.         {
  408.         if(_Status = NdrMapCommAndFaultStatus(( PMIDL_STUB_MESSAGE  )&_StubMsg,( unsigned long __RPC_FAR * )&_RetVal,( unsigned long __RPC_FAR * )&_RetVal,RpcExceptionCode()))
  409.             {
  410.             RpcRaiseException(_Status);
  411.             }
  412.         }
  413.     RpcEndExcept
  414.     return _RetVal;
  415. }
  418. /* [fault_status][comm_status] */ error_status_t BufferOut1( 
  419.     /* [in] */ handle_t Binding,
  420.     /* [length_is] */ byte __RPC_FAR Buffer[ 16384 ],
  421.     /* [out] */ unsigned long __RPC_FAR *pBufferLength)
  422. {
  424.     RPC_BINDING_HANDLE _Handle = 0;
  425.     
  426.     error_status_t _RetVal;
  427.     
  428.     RPC_MESSAGE _RpcMessage;
  429.     
  430.     RPC_STATUS _Status;
  431.     
  432.     MIDL_STUB_MESSAGE _StubMsg;
  433.     
  434.     RpcTryExcept
  435.         {
  436.         RpcTryFinally
  437.             {
  438.             NdrClientInitializeNew(
  439.                           ( PRPC_MESSAGE  )&_RpcMessage,
  440.                           ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  441.                           ( PMIDL_STUB_DESC  )&RpcServiceSample_StubDesc,
  442.                           5);
  443.             
  444.             
  445.             _Handle = Binding;
  446.             
  447.             
  448.             _StubMsg.BufferLength = 0U + 0U;
  449.             _StubMsg.Offset = 0;
  450.             _StubMsg.ActualCount = pBufferLength ? *pBufferLength : 0;
  451.             
  452.             NdrVaryingArrayBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
  453.                                        (unsigned char __RPC_FAR *)Buffer,
  454.                                        (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[38] );
  455.             
  456.             NdrGetBuffer( (PMIDL_STUB_MESSAGE) &_StubMsg, _StubMsg.BufferLength, _Handle );
  457.             
  458.             _StubMsg.Offset = 0;
  459.             _StubMsg.ActualCount = pBufferLength ? *pBufferLength : 0;
  460.             
  461.             NdrVaryingArrayMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
  462.                                      (unsigned char __RPC_FAR *)Buffer,
  463.                                      (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[38] );
  464.             
  465.             NdrSendReceive( (PMIDL_STUB_MESSAGE) &_StubMsg, (unsigned char __RPC_FAR *) _StubMsg.Buffer );
  466.             
  467.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  468.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[36] );
  469.             
  470.             *pBufferLength = *(( unsigned long __RPC_FAR * )_StubMsg.Buffer)++;
  471.             
  472.             _RetVal = *(( error_status_t __RPC_FAR * )_StubMsg.Buffer)++;
  473.             
  474.             }
  475.         RpcFinally
  476.             {
  477.             NdrFreeBuffer( (PMIDL_STUB_MESSAGE) &_StubMsg );
  478.             
  479.             }
  480.         RpcEndFinally
  481.         
  482.         }
  483.     RpcExcept( 1 )
  484.         {
  485.         if(_Status = NdrMapCommAndFaultStatus(( PMIDL_STUB_MESSAGE  )&_StubMsg,( unsigned long __RPC_FAR * )&_RetVal,( unsigned long __RPC_FAR * )&_RetVal,RpcExceptionCode()))
  486.             {
  487.             RpcRaiseException(_Status);
  488.             }
  489.         }
  490.     RpcEndExcept
  491.     return _RetVal;
  492. }
  495. /* [fault_status][comm_status] */ error_status_t BufferOut2( 
  496.     /* [in] */ handle_t Binding,
  497.     /* [out][length_is][size_is] */ byte __RPC_FAR Buffer[  ],
  498.     /* [in] */ unsigned long BufferSize,
  499.     /* [out] */ unsigned long __RPC_FAR *pBufferLength)
  500. {
  502.     RPC_BINDING_HANDLE _Handle = 0;
  503.     
  504.     error_status_t _RetVal;
  505.     
  506.     RPC_MESSAGE _RpcMessage;
  507.     
  508.     RPC_STATUS _Status;
  509.     
  510.     MIDL_STUB_MESSAGE _StubMsg;
  511.     
  512.     RpcTryExcept
  513.         {
  514.         RpcTryFinally
  515.             {
  516.             NdrClientInitializeNew(
  517.                           ( PRPC_MESSAGE  )&_RpcMessage,
  518.                           ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  519.                           ( PMIDL_STUB_DESC  )&RpcServiceSample_StubDesc,
  520.                           6);
  521.             
  522.             
  523.             _Handle = Binding;
  524.             
  525.             
  526.             _StubMsg.BufferLength = 0U + 4U;
  527.             NdrGetBuffer( (PMIDL_STUB_MESSAGE) &_StubMsg, _StubMsg.BufferLength, _Handle );
  528.             
  529.             *(( unsigned long __RPC_FAR * )_StubMsg.Buffer)++ = BufferSize;
  530.             
  531.             NdrSendReceive( (PMIDL_STUB_MESSAGE) &_StubMsg, (unsigned char __RPC_FAR *) _StubMsg.Buffer );
  532.             
  533.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  534.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[48] );
  535.             
  536.             NdrConformantVaryingArrayUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
  537.                                                  (unsigned char __RPC_FAR * __RPC_FAR *)&Buffer,
  538.                                                  (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[56],
  539.                                                  (unsigned char)0 );
  540.             
  541.             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
  542.             *pBufferLength = *(( unsigned long __RPC_FAR * )_StubMsg.Buffer)++;
  543.             
  544.             _RetVal = *(( error_status_t __RPC_FAR * )_StubMsg.Buffer)++;
  545.             
  546.             }
  547.         RpcFinally
  548.             {
  549.             NdrFreeBuffer( (PMIDL_STUB_MESSAGE) &_StubMsg );
  550.             
  551.             }
  552.         RpcEndFinally
  553.         
  554.         }
  555.     RpcExcept( 1 )
  556.         {
  557.         if(_Status = NdrMapCommAndFaultStatus(( PMIDL_STUB_MESSAGE  )&_StubMsg,( unsigned long __RPC_FAR * )&_RetVal,( unsigned long __RPC_FAR * )&_RetVal,RpcExceptionCode()))
  558.             {
  559.             RpcRaiseException(_Status);
  560.             }
  561.         }
  562.     RpcEndExcept
  563.     return _RetVal;
  564. }
  567. /* [fault_status][comm_status] */ error_status_t BufferOut3( 
  568.     /* [in] */ handle_t Binding,
  569.     /* [out] */ BUFFER __RPC_FAR *pBuffer)
  570. {
  572.     RPC_BINDING_HANDLE _Handle = 0;
  573.     
  574.     error_status_t _RetVal;
  575.     
  576.     RPC_MESSAGE _RpcMessage;
  577.     
  578.     RPC_STATUS _Status;
  579.     
  580.     MIDL_STUB_MESSAGE _StubMsg;
  581.     
  582.     RpcTryExcept
  583.         {
  584.         RpcTryFinally
  585.             {
  586.             NdrClientInitializeNew(
  587.                           ( PRPC_MESSAGE  )&_RpcMessage,
  588.                           ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  589.                           ( PMIDL_STUB_DESC  )&RpcServiceSample_StubDesc,
  590.                           7);
  591.             
  592.             
  593.             _Handle = Binding;
  594.             
  595.             
  596.             _StubMsg.BufferLength = 0U;
  597.             NdrGetBuffer( (PMIDL_STUB_MESSAGE) &_StubMsg, _StubMsg.BufferLength, _Handle );
  598.             
  599.             NdrSendReceive( (PMIDL_STUB_MESSAGE) &_StubMsg, (unsigned char __RPC_FAR *) _StubMsg.Buffer );
  600.             
  601.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  602.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[62] );
  603.             
  604.             NdrSimpleStructUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
  605.                                        (unsigned char __RPC_FAR * __RPC_FAR *)&pBuffer,
  606.                                        (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[84],
  607.                                        (unsigned char)0 );
  608.             
  609.             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
  610.             _RetVal = *(( error_status_t __RPC_FAR * )_StubMsg.Buffer)++;
  611.             
  612.             }
  613.         RpcFinally
  614.             {
  615.             NdrFreeBuffer( (PMIDL_STUB_MESSAGE) &_StubMsg );
  616.             
  617.             }
  618.         RpcEndFinally
  619.         
  620.         }
  621.     RpcExcept( 1 )
  622.         {
  623.         if(_Status = NdrMapCommAndFaultStatus(( PMIDL_STUB_MESSAGE  )&_StubMsg,( unsigned long __RPC_FAR * )&_RetVal,( unsigned long __RPC_FAR * )&_RetVal,RpcExceptionCode()))
  624.             {
  625.             RpcRaiseException(_Status);
  626.             }
  627.         }
  628.     RpcEndExcept
  629.     return _RetVal;
  630. }
  633. /* [fault_status][comm_status] */ error_status_t BufferOut4( 
  634.     /* [in] */ handle_t Binding,
  635.     /* [size_is][out] */ byte __RPC_FAR Buffer[  ],
  636.     /* [out][in] */ unsigned long __RPC_FAR *pBufferLength)
  637. {
  639.     RPC_BINDING_HANDLE _Handle = 0;
  640.     
  641.     error_status_t _RetVal;
  642.     
  643.     RPC_MESSAGE _RpcMessage;
  644.     
  645.     RPC_STATUS _Status;
  646.     
  647.     MIDL_STUB_MESSAGE _StubMsg;
  648.     
  649.     RpcTryExcept
  650.         {
  651.         RpcTryFinally
  652.             {
  653.             NdrClientInitializeNew(
  654.                           ( PRPC_MESSAGE  )&_RpcMessage,
  655.                           ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  656.                           ( PMIDL_STUB_DESC  )&RpcServiceSample_StubDesc,
  657.                           8);
  658.             
  659.             
  660.             _Handle = Binding;
  661.             
  662.             
  663.             _StubMsg.BufferLength = 0U + 4U;
  664.             NdrGetBuffer( (PMIDL_STUB_MESSAGE) &_StubMsg, _StubMsg.BufferLength, _Handle );
  665.             
  666.             *(( unsigned long __RPC_FAR * )_StubMsg.Buffer)++ = *pBufferLength;
  667.             
  668.             NdrSendReceive( (PMIDL_STUB_MESSAGE) &_StubMsg, (unsigned char __RPC_FAR *) _StubMsg.Buffer );
  669.             
  670.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  671.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[70] );
  672.             
  673.             NdrConformantArrayUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
  674.                                           (unsigned char __RPC_FAR * __RPC_FAR *)&Buffer,
  675.                                           (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[104],
  676.                                           (unsigned char)0 );
  677.             
  678.             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
  679.             *pBufferLength = *(( unsigned long __RPC_FAR * )_StubMsg.Buffer)++;
  680.             
  681.             _RetVal = *(( error_status_t __RPC_FAR * )_StubMsg.Buffer)++;
  682.             
  683.             }
  684.         RpcFinally
  685.             {
  686.             NdrFreeBuffer( (PMIDL_STUB_MESSAGE) &_StubMsg );
  687.             
  688.             }
  689.         RpcEndFinally
  690.         
  691.         }
  692.     RpcExcept( 1 )
  693.         {
  694.         if(_Status = NdrMapCommAndFaultStatus(( PMIDL_STUB_MESSAGE  )&_StubMsg,( unsigned long __RPC_FAR * )&_RetVal,( unsigned long __RPC_FAR * )&_RetVal,RpcExceptionCode()))
  695.             {
  696.             RpcRaiseException(_Status);
  697.             }
  698.         }
  699.     RpcEndExcept
  700.     return _RetVal;
  701. }
  704. /* [fault_status][comm_status] */ error_status_t StructsIn1( 
  705.     /* [in] */ handle_t Binding,
  706.     /* [in] */ struct BAD1 __RPC_FAR array[ 50 ])
  707. {
  709.     RPC_BINDING_HANDLE _Handle = 0;
  710.     
  711.     error_status_t _RetVal;
  712.     
  713.     RPC_MESSAGE _RpcMessage;
  714.     
  715.     RPC_STATUS _Status;
  716.     
  717.     MIDL_STUB_MESSAGE _StubMsg;
  718.     
  719.     RpcTryExcept
  720.         {
  721.         RpcTryFinally
  722.             {
  723.             NdrClientInitializeNew(
  724.                           ( PRPC_MESSAGE  )&_RpcMessage,
  725.                           ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  726.                           ( PMIDL_STUB_DESC  )&RpcServiceSample_StubDesc,
  727.                           9);
  728.             
  729.             
  730.             _Handle = Binding;
  731.             
  732.             
  733.             _StubMsg.BufferLength = 0U + 0U;
  734.             NdrComplexArrayBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
  735.                                        (unsigned char __RPC_FAR *)array,
  736.                                        (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[130] );
  737.             
  738.             NdrGetBuffer( (PMIDL_STUB_MESSAGE) &_StubMsg, _StubMsg.BufferLength, _Handle );
  739.             
  740.             NdrComplexArrayMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
  741.                                      (unsigned char __RPC_FAR *)array,
  742.                                      (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[130] );
  743.             
  744.             NdrSendReceive( (PMIDL_STUB_MESSAGE) &_StubMsg, (unsigned char __RPC_FAR *) _StubMsg.Buffer );
  745.             
  746.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  747.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[82] );
  748.             
  749.             _RetVal = *(( error_status_t __RPC_FAR * )_StubMsg.Buffer)++;
  750.             
  751.             }
  752.         RpcFinally
  753.             {
  754.             NdrFreeBuffer( (PMIDL_STUB_MESSAGE) &_StubMsg );
  755.             
  756.             }
  757.         RpcEndFinally
  758.         
  759.         }
  760.     RpcExcept( 1 )
  761.         {
  762.         if(_Status = NdrMapCommAndFaultStatus(( PMIDL_STUB_MESSAGE  )&_StubMsg,( unsigned long __RPC_FAR * )&_RetVal,( unsigned long __RPC_FAR * )&_RetVal,RpcExceptionCode()))
  763.             {
  764.             RpcRaiseException(_Status);
  765.             }
  766.         }
  767.     RpcEndExcept
  768.     return _RetVal;
  769. }
  772. /* [fault_status][comm_status] */ error_status_t StructsIn2( 
  773.     /* [in] */ handle_t Binding,
  774.     /* [in] */ struct BAD2 __RPC_FAR array[ 50 ])
  775. {
  777.     RPC_BINDING_HANDLE _Handle = 0;
  778.     
  779.     error_status_t _RetVal;
  780.     
  781.     RPC_MESSAGE _RpcMessage;
  782.     
  783.     RPC_STATUS _Status;
  784.     
  785.     MIDL_STUB_MESSAGE _StubMsg;
  786.     
  787.     RpcTryExcept
  788.         {
  789.         RpcTryFinally
  790.             {
  791.             NdrClientInitializeNew(
  792.                           ( PRPC_MESSAGE  )&_RpcMessage,
  793.                           ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  794.                           ( PMIDL_STUB_DESC  )&RpcServiceSample_StubDesc,
  795.                           10);
  796.             
  797.             
  798.             _Handle = Binding;
  799.             
  800.             
  801.             _StubMsg.BufferLength = 0U + 0U;
  802.             NdrComplexArrayBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
  803.                                        (unsigned char __RPC_FAR *)array,
  804.                                        (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[160] );
  805.             
  806.             NdrGetBuffer( (PMIDL_STUB_MESSAGE) &_StubMsg, _StubMsg.BufferLength, _Handle );
  807.             
  808.             NdrComplexArrayMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
  809.                                      (unsigned char __RPC_FAR *)array,
  810.                                      (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[160] );
  811.             
  812.             NdrSendReceive( (PMIDL_STUB_MESSAGE) &_StubMsg, (unsigned char __RPC_FAR *) _StubMsg.Buffer );
  813.             
  814.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  815.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[90] );
  816.             
  817.             _RetVal = *(( error_status_t __RPC_FAR * )_StubMsg.Buffer)++;
  818.             
  819.             }
  820.         RpcFinally
  821.             {
  822.             NdrFreeBuffer( (PMIDL_STUB_MESSAGE) &_StubMsg );
  823.             
  824.             }
  825.         RpcEndFinally
  826.         
  827.         }
  828.     RpcExcept( 1 )
  829.         {
  830.         if(_Status = NdrMapCommAndFaultStatus(( PMIDL_STUB_MESSAGE  )&_StubMsg,( unsigned long __RPC_FAR * )&_RetVal,( unsigned long __RPC_FAR * )&_RetVal,RpcExceptionCode()))
  831.             {
  832.             RpcRaiseException(_Status);
  833.             }
  834.         }
  835.     RpcEndExcept
  836.     return _RetVal;
  837. }
  840. /* [fault_status][comm_status] */ error_status_t StructsIn3( 
  841.     /* [in] */ handle_t Binding,
  842.     /* [in] */ struct GOOD __RPC_FAR array[ 50 ])
  843. {
  845.     RPC_BINDING_HANDLE _Handle = 0;
  846.     
  847.     error_status_t _RetVal;
  848.     
  849.     RPC_MESSAGE _RpcMessage;
  850.     
  851.     RPC_STATUS _Status;
  852.     
  853.     MIDL_STUB_MESSAGE _StubMsg;
  854.     
  855.     RpcTryExcept
  856.         {
  857.         RpcTryFinally
  858.             {
  859.             NdrClientInitializeNew(
  860.                           ( PRPC_MESSAGE  )&_RpcMessage,
  861.                           ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  862.                           ( PMIDL_STUB_DESC  )&RpcServiceSample_StubDesc,
  863.                           11);
  864.             
  865.             
  866.             _Handle = Binding;
  867.             
  868.             
  869.             _StubMsg.BufferLength = 0U + 0U;
  870.             NdrFixedArrayBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
  871.                                      (unsigned char __RPC_FAR *)array,
  872.                                      (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[186] );
  873.             
  874.             NdrGetBuffer( (PMIDL_STUB_MESSAGE) &_StubMsg, _StubMsg.BufferLength, _Handle );
  875.             
  876.             NdrFixedArrayMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
  877.                                    (unsigned char __RPC_FAR *)array,
  878.                                    (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[186] );
  879.             
  880.             NdrSendReceive( (PMIDL_STUB_MESSAGE) &_StubMsg, (unsigned char __RPC_FAR *) _StubMsg.Buffer );
  881.             
  882.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  883.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[98] );
  884.             
  885.             _RetVal = *(( error_status_t __RPC_FAR * )_StubMsg.Buffer)++;
  886.             
  887.             }
  888.         RpcFinally
  889.             {
  890.             NdrFreeBuffer( (PMIDL_STUB_MESSAGE) &_StubMsg );
  891.             
  892.             }
  893.         RpcEndFinally
  894.         
  895.         }
  896.     RpcExcept( 1 )
  897.         {
  898.         if(_Status = NdrMapCommAndFaultStatus(( PMIDL_STUB_MESSAGE  )&_StubMsg,( unsigned long __RPC_FAR * )&_RetVal,( unsigned long __RPC_FAR * )&_RetVal,RpcExceptionCode()))
  899.             {
  900.             RpcRaiseException(_Status);
  901.             }
  902.         }
  903.     RpcEndExcept
  904.     return _RetVal;
  905. }
  908. /* [fault_status][comm_status] */ error_status_t ListIn( 
  909.     /* [in] */ handle_t Binding,
  910.     /* [in] */ PLIST pList)
  911. {
  913.     RPC_BINDING_HANDLE _Handle = 0;
  914.     
  915.     error_status_t _RetVal;
  916.     
  917.     RPC_MESSAGE _RpcMessage;
  918.     
  919.     RPC_STATUS _Status;
  920.     
  921.     MIDL_STUB_MESSAGE _StubMsg;
  922.     
  923.     RpcTryExcept
  924.         {
  925.         RpcTryFinally
  926.             {
  927.             NdrClientInitializeNew(
  928.                           ( PRPC_MESSAGE  )&_RpcMessage,
  929.                           ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  930.                           ( PMIDL_STUB_DESC  )&RpcServiceSample_StubDesc,
  931.                           12);
  932.             
  933.             
  934.             _Handle = Binding;
  935.             
  936.             
  937.             _StubMsg.BufferLength = 0U + 4U;
  938.             NdrPointerBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
  939.                                   (unsigned char __RPC_FAR *)pList,
  940.                                   (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[196] );
  941.             
  942.             NdrGetBuffer( (PMIDL_STUB_MESSAGE) &_StubMsg, _StubMsg.BufferLength, _Handle );
  943.             
  944.             NdrPointerMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
  945.                                 (unsigned char __RPC_FAR *)pList,
  946.                                 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[196] );
  947.             
  948.             NdrSendReceive( (PMIDL_STUB_MESSAGE) &_StubMsg, (unsigned char __RPC_FAR *) _StubMsg.Buffer );
  949.             
  950.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  951.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[106] );
  952.             
  953.             _RetVal = *(( error_status_t __RPC_FAR * )_StubMsg.Buffer)++;
  954.             
  955.             }
  956.         RpcFinally
  957.             {
  958.             NdrFreeBuffer( (PMIDL_STUB_MESSAGE) &_StubMsg );
  959.             
  960.             }
  961.         RpcEndFinally
  962.         
  963.         }
  964.     RpcExcept( 1 )
  965.         {
  966.         if(_Status = NdrMapCommAndFaultStatus(( PMIDL_STUB_MESSAGE  )&_StubMsg,( unsigned long __RPC_FAR * )&_RetVal,( unsigned long __RPC_FAR * )&_RetVal,RpcExceptionCode()))
  967.             {
  968.             RpcRaiseException(_Status);
  969.             }
  970.         }
  971.     RpcEndExcept
  972.     return _RetVal;
  973. }
  976. /* [fault_status][comm_status] */ error_status_t ListOut1( 
  977.     /* [in] */ handle_t Binding,
  978.     /* [out] */ LIST __RPC_FAR *pListHead)
  979. {
  981.     RPC_BINDING_HANDLE _Handle = 0;
  982.     
  983.     error_status_t _RetVal;
  984.     
  985.     RPC_MESSAGE _RpcMessage;
  986.     
  987.     RPC_STATUS _Status;
  988.     
  989.     MIDL_STUB_MESSAGE _StubMsg;
  990.     
  991.     RpcTryExcept
  992.         {
  993.         RpcTryFinally
  994.             {
  995.             NdrClientInitializeNew(
  996.                           ( PRPC_MESSAGE  )&_RpcMessage,
  997.                           ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  998.                           ( PMIDL_STUB_DESC  )&RpcServiceSample_StubDesc,
  999.                           13);
  1000.             
  1001.             
  1002.             _Handle = Binding;
  1003.             
  1004.             
  1005.             _StubMsg.BufferLength = 0U;
  1006.             NdrGetBuffer( (PMIDL_STUB_MESSAGE) &_StubMsg, _StubMsg.BufferLength, _Handle );
  1007.             
  1008.             NdrSendReceive( (PMIDL_STUB_MESSAGE) &_StubMsg, (unsigned char __RPC_FAR *) _StubMsg.Buffer );
  1009.             
  1010.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  1011.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[114] );
  1012.             
  1013.             NdrSimpleStructUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
  1014.                                        (unsigned char __RPC_FAR * __RPC_FAR *)&pListHead,
  1015.                                        (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[200],
  1016.                                        (unsigned char)0 );
  1017.             
  1018.             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
  1019.             _RetVal = *(( error_status_t __RPC_FAR * )_StubMsg.Buffer)++;
  1020.             
  1021.             }
  1022.         RpcFinally
  1023.             {
  1024.             NdrFreeBuffer( (PMIDL_STUB_MESSAGE) &_StubMsg );
  1025.             
  1026.             }
  1027.         RpcEndFinally
  1028.         
  1029.         }
  1030.     RpcExcept( 1 )
  1031.         {
  1032.         if(_Status = NdrMapCommAndFaultStatus(( PMIDL_STUB_MESSAGE  )&_StubMsg,( unsigned long __RPC_FAR * )&_RetVal,( unsigned long __RPC_FAR * )&_RetVal,RpcExceptionCode()))
  1033.             {
  1034.             RpcRaiseException(_Status);
  1035.             }
  1036.         }
  1037.     RpcEndExcept
  1038.     return _RetVal;
  1039. }
  1042. /* [fault_status][comm_status] */ error_status_t ListOut2( 
  1043.     /* [in] */ handle_t Binding,
  1044.     /* [out] */ LIST __RPC_FAR *pListHead)
  1045. {
  1047.     RPC_BINDING_HANDLE _Handle = 0;
  1048.     
  1049.     error_status_t _RetVal;
  1050.     
  1051.     RPC_MESSAGE _RpcMessage;
  1052.     
  1053.     RPC_STATUS _Status;
  1054.     
  1055.     MIDL_STUB_MESSAGE _StubMsg;
  1056.     
  1057.     RpcTryExcept
  1058.         {
  1059.         RpcTryFinally
  1060.             {
  1061.             NdrClientInitializeNew(
  1062.                           ( PRPC_MESSAGE  )&_RpcMessage,
  1063.                           ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  1064.                           ( PMIDL_STUB_DESC  )&RpcServiceSample_StubDesc,
  1065.                           14);
  1066.             
  1067.             
  1068.             _Handle = Binding;
  1069.             
  1070.             
  1071.             _StubMsg.BufferLength = 0U;
  1072.             NdrGetBuffer( (PMIDL_STUB_MESSAGE) &_StubMsg, _StubMsg.BufferLength, _Handle );
  1073.             
  1074.             NdrSendReceive( (PMIDL_STUB_MESSAGE) &_StubMsg, (unsigned char __RPC_FAR *) _StubMsg.Buffer );
  1075.             
  1076.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  1077.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[114] );
  1078.             
  1079.             NdrSimpleStructUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
  1080.                                        (unsigned char __RPC_FAR * __RPC_FAR *)&pListHead,
  1081.                                        (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[200],
  1082.                                        (unsigned char)0 );
  1083.             
  1084.             _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
  1085.             _RetVal = *(( error_status_t __RPC_FAR * )_StubMsg.Buffer)++;
  1086.             
  1087.             }
  1088.         RpcFinally
  1089.             {
  1090.             NdrFreeBuffer( (PMIDL_STUB_MESSAGE) &_StubMsg );
  1091.             
  1092.             }
  1093.         RpcEndFinally
  1094.         
  1095.         }
  1096.     RpcExcept( 1 )
  1097.         {
  1098.         if(_Status = NdrMapCommAndFaultStatus(( PMIDL_STUB_MESSAGE  )&_StubMsg,( unsigned long __RPC_FAR * )&_RetVal,( unsigned long __RPC_FAR * )&_RetVal,RpcExceptionCode()))
  1099.             {
  1100.             RpcRaiseException(_Status);
  1101.             }
  1102.         }
  1103.     RpcEndExcept
  1104.     return _RetVal;
  1105. }
  1108. /* [fault_status][comm_status] */ error_status_t UnionCall1( 
  1109.     /* [in] */ handle_t Binding,
  1110.     /* [in] */ unsigned long Length,
  1111.     /* [size_is][in] */ BAD_UNION __RPC_FAR ArrayOfUnions[  ])
  1112. {
  1114.     RPC_BINDING_HANDLE _Handle = 0;
  1115.     
  1116.     error_status_t _RetVal;
  1117.     
  1118.     RPC_MESSAGE _RpcMessage;
  1119.     
  1120.     RPC_STATUS _Status;
  1121.     
  1122.     MIDL_STUB_MESSAGE _StubMsg;
  1123.     
  1124.     RpcTryExcept
  1125.         {
  1126.         RpcTryFinally
  1127.             {
  1128.             NdrClientInitializeNew(
  1129.                           ( PRPC_MESSAGE  )&_RpcMessage,
  1130.                           ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  1131.                           ( PMIDL_STUB_DESC  )&RpcServiceSample_StubDesc,
  1132.                           15);
  1133.             
  1134.             
  1135.             _Handle = Binding;
  1136.             
  1137.             
  1138.             _StubMsg.BufferLength = 0U + 4U + 4U;
  1139.             _StubMsg.MaxCount = Length;
  1140.             
  1141.             NdrComplexArrayBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
  1142.                                        (unsigned char __RPC_FAR *)ArrayOfUnions,
  1143.                                        (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[264] );
  1144.             
  1145.             NdrGetBuffer( (PMIDL_STUB_MESSAGE) &_StubMsg, _StubMsg.BufferLength, _Handle );
  1146.             
  1147.             *(( unsigned long __RPC_FAR * )_StubMsg.Buffer)++ = Length;
  1148.             
  1149.             _StubMsg.MaxCount = Length;
  1150.             
  1151.             NdrComplexArrayMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
  1152.                                      (unsigned char __RPC_FAR *)ArrayOfUnions,
  1153.                                      (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[264] );
  1154.             
  1155.             NdrSendReceive( (PMIDL_STUB_MESSAGE) &_StubMsg, (unsigned char __RPC_FAR *) _StubMsg.Buffer );
  1156.             
  1157.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  1158.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[122] );
  1159.             
  1160.             _RetVal = *(( error_status_t __RPC_FAR * )_StubMsg.Buffer)++;
  1161.             
  1162.             }
  1163.         RpcFinally
  1164.             {
  1165.             NdrFreeBuffer( (PMIDL_STUB_MESSAGE) &_StubMsg );
  1166.             
  1167.             }
  1168.         RpcEndFinally
  1169.         
  1170.         }
  1171.     RpcExcept( 1 )
  1172.         {
  1173.         if(_Status = NdrMapCommAndFaultStatus(( PMIDL_STUB_MESSAGE  )&_StubMsg,( unsigned long __RPC_FAR * )&_RetVal,( unsigned long __RPC_FAR * )&_RetVal,RpcExceptionCode()))
  1174.             {
  1175.             RpcRaiseException(_Status);
  1176.             }
  1177.         }
  1178.     RpcEndExcept
  1179.     return _RetVal;
  1180. }
  1183. /* [fault_status][comm_status] */ error_status_t UnionCall2( 
  1184.     /* [in] */ handle_t Binding,
  1185.     /* [in] */ GOOD_UNION __RPC_FAR *pUnionContainingArrays)
  1186. {
  1188.     RPC_BINDING_HANDLE _Handle = 0;
  1189.     
  1190.     error_status_t _RetVal;
  1191.     
  1192.     RPC_MESSAGE _RpcMessage;
  1193.     
  1194.     RPC_STATUS _Status;
  1195.     
  1196.     MIDL_STUB_MESSAGE _StubMsg;
  1197.     
  1198.     RpcTryExcept
  1199.         {
  1200.         RpcTryFinally
  1201.             {
  1202.             NdrClientInitializeNew(
  1203.                           ( PRPC_MESSAGE  )&_RpcMessage,
  1204.                           ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  1205.                           ( PMIDL_STUB_DESC  )&RpcServiceSample_StubDesc,
  1206.                           16);
  1207.             
  1208.             
  1209.             _Handle = Binding;
  1210.             
  1211.             
  1212.             _StubMsg.BufferLength = 0U + 0U;
  1213.             NdrComplexStructBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
  1214.                                         (unsigned char __RPC_FAR *)pUnionContainingArrays,
  1215.                                         (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[380] );
  1216.             
  1217.             NdrGetBuffer( (PMIDL_STUB_MESSAGE) &_StubMsg, _StubMsg.BufferLength, _Handle );
  1218.             
  1219.             NdrComplexStructMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
  1220.                                       (unsigned char __RPC_FAR *)pUnionContainingArrays,
  1221.                                       (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[380] );
  1222.             
  1223.             NdrSendReceive( (PMIDL_STUB_MESSAGE) &_StubMsg, (unsigned char __RPC_FAR *) _StubMsg.Buffer );
  1224.             
  1225.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  1226.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[132] );
  1227.             
  1228.             _RetVal = *(( error_status_t __RPC_FAR * )_StubMsg.Buffer)++;
  1229.             
  1230.             }
  1231.         RpcFinally
  1232.             {
  1233.             NdrFreeBuffer( (PMIDL_STUB_MESSAGE) &_StubMsg );
  1234.             
  1235.             }
  1236.         RpcEndFinally
  1237.         
  1238.         }
  1239.     RpcExcept( 1 )
  1240.         {
  1241.         if(_Status = NdrMapCommAndFaultStatus(( PMIDL_STUB_MESSAGE  )&_StubMsg,( unsigned long __RPC_FAR * )&_RetVal,( unsigned long __RPC_FAR * )&_RetVal,RpcExceptionCode()))
  1242.             {
  1243.             RpcRaiseException(_Status);
  1244.             }
  1245.         }
  1246.     RpcEndExcept
  1247.     return _RetVal;
  1248. }
  1251. static const MIDL_STUB_DESC RpcServiceSample_StubDesc = 
  1252.     {
  1253.     (void __RPC_FAR *)& RpcServiceSample___RpcClientInterface,
  1254.     MIDL_user_allocate,
  1255.     MIDL_user_free,
  1256.     &RpcServiceSample__MIDL_AutoBindHandle,
  1257.     0,
  1258.     0,
  1259.     0,
  1260.     0,
  1261.     __MIDL_TypeFormatString.Format,
  1262.     0, /* -error bounds_check flag */
  1263.     0x10001, /* Ndr library version */
  1264.     0,
  1265.     0x303006e, /* MIDL Version 3.3.110 */
  1266.     0,
  1267.     0,
  1268.     0,  /* Reserved1 */
  1269.     0,  /* Reserved2 */
  1270.     0,  /* Reserved3 */
  1271.     0,  /* Reserved4 */
  1272.     0   /* Reserved5 */
  1273.     };
  1275. #if !defined(__RPC_WIN32__)
  1276. #error  Invalid build platform for this stub.
  1277. #endif
  1279. static const MIDL_PROC_FORMAT_STRING __MIDL_ProcFormatString =
  1280.     {
  1281.         0,
  1282.         {
  1283. 0x4e, /* FC_IN_PARAM_BASETYPE */
  1284. 0xf, /* FC_IGNORE */
  1285. /*  2 */ 0x53, /* FC_RETURN_PARAM_BASETYPE */
  1286. 0x10, /* FC_ERROR_STATUS_T */
  1287. /*  4 */ 0x4e, /* FC_IN_PARAM_BASETYPE */
  1288. 0xf, /* FC_IGNORE */
  1289. /*  6 */
  1290. 0x4d, /* FC_IN_PARAM */
  1291. #ifndef _ALPHA_
  1292. 0x1, /* x86, MIPS & PPC Stack size = 1 */
  1293. #else
  1294. 0x2, /* Alpha Stack size = 2 */
  1295. #endif
  1296. /*  8 */ NdrFcShort( 0x0 ), /* Type Offset=0 */
  1297. /* 10 */ 0x4e, /* FC_IN_PARAM_BASETYPE */
  1298. 0x8, /* FC_LONG */
  1299. /* 12 */ 0x4e, /* FC_IN_PARAM_BASETYPE */
  1300. 0x8, /* FC_LONG */
  1301. /* 14 */ 0x53, /* FC_RETURN_PARAM_BASETYPE */
  1302. 0x10, /* FC_ERROR_STATUS_T */
  1303. /* 16 */ 0x4e, /* FC_IN_PARAM_BASETYPE */
  1304. 0xf, /* FC_IGNORE */
  1305. /* 18 */
  1306. 0x4d, /* FC_IN_PARAM */
  1307. #ifndef _ALPHA_
  1308. 0x1, /* x86, MIPS & PPC Stack size = 1 */
  1309. #else
  1310. 0x2, /* Alpha Stack size = 2 */
  1311. #endif
  1312. /* 20 */ NdrFcShort( 0xe ), /* Type Offset=14 */
  1313. /* 22 */ 0x4e, /* FC_IN_PARAM_BASETYPE */
  1314. 0x8, /* FC_LONG */
  1315. /* 24 */ 0x53, /* FC_RETURN_PARAM_BASETYPE */
  1316. 0x10, /* FC_ERROR_STATUS_T */
  1317. /* 26 */ 0x4e, /* FC_IN_PARAM_BASETYPE */
  1318. 0xf, /* FC_IGNORE */
  1319. /* 28 */
  1320. 0x4d, /* FC_IN_PARAM */
  1321. #ifndef _ALPHA_
  1322. 0x1, /* x86, MIPS & PPC Stack size = 1 */
  1323. #else
  1324. 0x2, /* Alpha Stack size = 2 */
  1325. #endif
  1326. /* 30 */ NdrFcShort( 0x1c ), /* Type Offset=28 */
  1327. /* 32 */ 0x4e, /* FC_IN_PARAM_BASETYPE */
  1328. 0x8, /* FC_LONG */
  1329. /* 34 */ 0x53, /* FC_RETURN_PARAM_BASETYPE */
  1330. 0x10, /* FC_ERROR_STATUS_T */
  1331. /* 36 */ 0x4e, /* FC_IN_PARAM_BASETYPE */
  1332. 0xf, /* FC_IGNORE */
  1333. /* 38 */
  1334. 0x4d, /* FC_IN_PARAM */
  1335. #ifndef _ALPHA_
  1336. 0x1, /* x86, MIPS & PPC Stack size = 1 */
  1337. #else
  1338. 0x2, /* Alpha Stack size = 2 */
  1339. #endif
  1340. /* 40 */ NdrFcShort( 0x26 ), /* Type Offset=38 */
  1341. /* 42 */
  1342. 0x51, /* FC_OUT_PARAM */
  1343. #ifndef _ALPHA_
  1344. 0x1, /* x86, MIPS & PPC Stack size = 1 */
  1345. #else
  1346. 0x2, /* Alpha Stack size = 2 */
  1347. #endif
  1348. /* 44 */ NdrFcShort( 0x34 ), /* Type Offset=52 */
  1349. /* 46 */ 0x53, /* FC_RETURN_PARAM_BASETYPE */
  1350. 0x10, /* FC_ERROR_STATUS_T */
  1351. /* 48 */ 0x4e, /* FC_IN_PARAM_BASETYPE */
  1352. 0xf, /* FC_IGNORE */
  1353. /* 50 */
  1354. 0x51, /* FC_OUT_PARAM */
  1355. #ifndef _ALPHA_
  1356. 0x1, /* x86, MIPS & PPC Stack size = 1 */
  1357. #else
  1358. 0x2, /* Alpha Stack size = 2 */
  1359. #endif
  1360. /* 52 */ NdrFcShort( 0x38 ), /* Type Offset=56 */
  1361. /* 54 */ 0x4e, /* FC_IN_PARAM_BASETYPE */
  1362. 0x8, /* FC_LONG */
  1363. /* 56 */
  1364. 0x51, /* FC_OUT_PARAM */
  1365. #ifndef _ALPHA_
  1366. 0x1, /* x86, MIPS & PPC Stack size = 1 */
  1367. #else
  1368. 0x2, /* Alpha Stack size = 2 */
  1369. #endif
  1370. /* 58 */ NdrFcShort( 0x34 ), /* Type Offset=52 */
  1371. /* 60 */ 0x53, /* FC_RETURN_PARAM_BASETYPE */
  1372. 0x10, /* FC_ERROR_STATUS_T */
  1373. /* 62 */ 0x4e, /* FC_IN_PARAM_BASETYPE */
  1374. 0xf, /* FC_IGNORE */
  1375. /* 64 */
  1376. 0x51, /* FC_OUT_PARAM */
  1377. #ifndef _ALPHA_
  1378. 0x1, /* x86, MIPS & PPC Stack size = 1 */
  1379. #else
  1380. 0x2, /* Alpha Stack size = 2 */
  1381. #endif
  1382. /* 66 */ NdrFcShort( 0x46 ), /* Type Offset=70 */
  1383. /* 68 */ 0x53, /* FC_RETURN_PARAM_BASETYPE */
  1384. 0x10, /* FC_ERROR_STATUS_T */
  1385. /* 70 */ 0x4e, /* FC_IN_PARAM_BASETYPE */
  1386. 0xf, /* FC_IGNORE */
  1387. /* 72 */
  1388. 0x51, /* FC_OUT_PARAM */
  1389. #ifndef _ALPHA_
  1390. 0x1, /* x86, MIPS & PPC Stack size = 1 */
  1391. #else
  1392. 0x2, /* Alpha Stack size = 2 */
  1393. #endif
  1394. /* 74 */ NdrFcShort( 0x68 ), /* Type Offset=104 */
  1395. /* 76 */
  1396. 0x50, /* FC_IN_OUT_PARAM */
  1397. #ifndef _ALPHA_
  1398. 0x1, /* x86, MIPS & PPC Stack size = 1 */
  1399. #else
  1400. 0x2, /* Alpha Stack size = 2 */
  1401. #endif
  1402. /* 78 */ NdrFcShort( 0x72 ), /* Type Offset=114 */
  1403. /* 80 */ 0x53, /* FC_RETURN_PARAM_BASETYPE */
  1404. 0x10, /* FC_ERROR_STATUS_T */
  1405. /* 82 */ 0x4e, /* FC_IN_PARAM_BASETYPE */
  1406. 0xf, /* FC_IGNORE */
  1407. /* 84 */
  1408. 0x4d, /* FC_IN_PARAM */
  1409. #ifndef _ALPHA_
  1410. 0x1, /* x86, MIPS & PPC Stack size = 1 */
  1411. #else
  1412. 0x2, /* Alpha Stack size = 2 */
  1413. #endif
  1414. /* 86 */ NdrFcShort( 0x82 ), /* Type Offset=130 */
  1415. /* 88 */ 0x53, /* FC_RETURN_PARAM_BASETYPE */
  1416. 0x10, /* FC_ERROR_STATUS_T */
  1417. /* 90 */ 0x4e, /* FC_IN_PARAM_BASETYPE */
  1418. 0xf, /* FC_IGNORE */
  1419. /* 92 */
  1420. 0x4d, /* FC_IN_PARAM */
  1421. #ifndef _ALPHA_
  1422. 0x1, /* x86, MIPS & PPC Stack size = 1 */
  1423. #else
  1424. 0x2, /* Alpha Stack size = 2 */
  1425. #endif
  1426. /* 94 */ NdrFcShort( 0xa0 ), /* Type Offset=160 */
  1427. /* 96 */ 0x53, /* FC_RETURN_PARAM_BASETYPE */
  1428. 0x10, /* FC_ERROR_STATUS_T */
  1429. /* 98 */ 0x4e, /* FC_IN_PARAM_BASETYPE */
  1430. 0xf, /* FC_IGNORE */
  1431. /* 100 */
  1432. 0x4d, /* FC_IN_PARAM */
  1433. #ifndef _ALPHA_
  1434. 0x1, /* x86, MIPS & PPC Stack size = 1 */
  1435. #else
  1436. 0x2, /* Alpha Stack size = 2 */
  1437. #endif
  1438. /* 102 */ NdrFcShort( 0xba ), /* Type Offset=186 */
  1439. /* 104 */ 0x53, /* FC_RETURN_PARAM_BASETYPE */
  1440. 0x10, /* FC_ERROR_STATUS_T */
  1441. /* 106 */ 0x4e, /* FC_IN_PARAM_BASETYPE */
  1442. 0xf, /* FC_IGNORE */
  1443. /* 108 */
  1444. 0x4d, /* FC_IN_PARAM */
  1445. #ifndef _ALPHA_
  1446. 0x1, /* x86, MIPS & PPC Stack size = 1 */
  1447. #else
  1448. 0x2, /* Alpha Stack size = 2 */
  1449. #endif
  1450. /* 110 */ NdrFcShort( 0xc4 ), /* Type Offset=196 */
  1451. /* 112 */ 0x53, /* FC_RETURN_PARAM_BASETYPE */
  1452. 0x10, /* FC_ERROR_STATUS_T */
  1453. /* 114 */ 0x4e, /* FC_IN_PARAM_BASETYPE */
  1454. 0xf, /* FC_IGNORE */
  1455. /* 116 */
  1456. 0x51, /* FC_OUT_PARAM */
  1457. #ifndef _ALPHA_
  1458. 0x1, /* x86, MIPS & PPC Stack size = 1 */
  1459. #else
  1460. 0x2, /* Alpha Stack size = 2 */
  1461. #endif
  1462. /* 118 */ NdrFcShort( 0xdc ), /* Type Offset=220 */
  1463. /* 120 */ 0x53, /* FC_RETURN_PARAM_BASETYPE */
  1464. 0x10, /* FC_ERROR_STATUS_T */
  1465. /* 122 */ 0x4e, /* FC_IN_PARAM_BASETYPE */
  1466. 0xf, /* FC_IGNORE */
  1467. /* 124 */ 0x4e, /* FC_IN_PARAM_BASETYPE */
  1468. 0x8, /* FC_LONG */
  1469. /* 126 */
  1470. 0x4d, /* FC_IN_PARAM */
  1471. #ifndef _ALPHA_
  1472. 0x1, /* x86, MIPS & PPC Stack size = 1 */
  1473. #else
  1474. 0x2, /* Alpha Stack size = 2 */
  1475. #endif
  1476. /* 128 */ NdrFcShort( 0x108 ), /* Type Offset=264 */
  1477. /* 130 */ 0x53, /* FC_RETURN_PARAM_BASETYPE */
  1478. 0x10, /* FC_ERROR_STATUS_T */
  1479. /* 132 */ 0x4e, /* FC_IN_PARAM_BASETYPE */
  1480. 0xf, /* FC_IGNORE */
  1481. /* 134 */
  1482. 0x4d, /* FC_IN_PARAM */
  1483. #ifndef _ALPHA_
  1484. 0x1, /* x86, MIPS & PPC Stack size = 1 */
  1485. #else
  1486. 0x2, /* Alpha Stack size = 2 */
  1487. #endif
  1488. /* 136 */ NdrFcShort( 0x11a ), /* Type Offset=282 */
  1489. /* 138 */ 0x53, /* FC_RETURN_PARAM_BASETYPE */
  1490. 0x10, /* FC_ERROR_STATUS_T */
  1492. 0x0
  1493.         }
  1494.     };
  1496. static const MIDL_TYPE_FORMAT_STRING __MIDL_TypeFormatString =
  1497.     {
  1498.         0,
  1499.         {
  1501. 0x1c, /* FC_CVARRAY */
  1502. 0x0, /* 0 */
  1503. /*  2 */ NdrFcShort( 0x1 ), /* 1 */
  1504. /*  4 */ 0x29, /* 41 */
  1505. 0x0, /*  */
  1506. #ifndef _ALPHA_
  1507. /*  6 */ NdrFcShort( 0xc ), /* x86, MIPS, PPC Stack size/offset = 12 */
  1508. #else
  1509. NdrFcShort( 0x18 ), /* Alpha Stack size/offset = 24 */
  1510. #endif
  1511. /*  8 */ 0x29, /* 41 */
  1512. 0x0, /*  */
  1513. #ifndef _ALPHA_
  1514. /* 10 */ NdrFcShort( 0x8 ), /* x86, MIPS, PPC Stack size/offset = 8 */
  1515. #else
  1516. NdrFcShort( 0x10 ), /* Alpha Stack size/offset = 16 */
  1517. #endif
  1518. /* 12 */ 0x1, /* FC_BYTE */
  1519. 0x5b, /* FC_END */
  1520. /* 14 */
  1521. 0x1f, /* FC_SMVARRAY */
  1522. 0x0, /* 0 */
  1523. /* 16 */ NdrFcShort( 0x4000 ), /* 16384 */
  1524. /* 18 */ NdrFcShort( 0x4000 ), /* 16384 */
  1525. /* 20 */ NdrFcShort( 0x1 ), /* 1 */
  1526. /* 22 */ 0x29, /* 41 */
  1527. 0x0, /*  */
  1528. #ifndef _ALPHA_
  1529. /* 24 */ NdrFcShort( 0x8 ), /* x86, MIPS, PPC Stack size/offset = 8 */
  1530. #else
  1531. NdrFcShort( 0x10 ), /* Alpha Stack size/offset = 16 */
  1532. #endif
  1533. /* 26 */ 0x1, /* FC_BYTE */
  1534. 0x5b, /* FC_END */
  1535. /* 28 */
  1536. 0x1b, /* FC_CARRAY */
  1537. 0x0, /* 0 */
  1538. /* 30 */ NdrFcShort( 0x1 ), /* 1 */
  1539. /* 32 */ 0x29, /* 41 */
  1540. 0x0, /*  */
  1541. #ifndef _ALPHA_
  1542. /* 34 */ NdrFcShort( 0x8 ), /* x86, MIPS, PPC Stack size/offset = 8 */
  1543. #else
  1544. NdrFcShort( 0x10 ), /* Alpha Stack size/offset = 16 */
  1545. #endif
  1546. /* 36 */ 0x1, /* FC_BYTE */
  1547. 0x5b, /* FC_END */
  1548. /* 38 */
  1549. 0x1f, /* FC_SMVARRAY */
  1550. 0x0, /* 0 */
  1551. /* 40 */ NdrFcShort( 0x4000 ), /* 16384 */
  1552. /* 42 */ NdrFcShort( 0x4000 ), /* 16384 */
  1553. /* 44 */ NdrFcShort( 0x1 ), /* 1 */
  1554. /* 46 */ 0x29, /* 41 */
  1555. 0x54, /* FC_DEREFERENCE */
  1556. #ifndef _ALPHA_
  1557. /* 48 */ NdrFcShort( 0x8 ), /* x86, MIPS, PPC Stack size/offset = 8 */
  1558. #else
  1559. NdrFcShort( 0x10 ), /* Alpha Stack size/offset = 16 */
  1560. #endif
  1561. /* 50 */ 0x1, /* FC_BYTE */
  1562. 0x5b, /* FC_END */
  1563. /* 52 */
  1564. 0x11, 0xc, /* FC_RP [alloced_on_stack] [simple_pointer] */
  1565. /* 54 */ 0x8, /* FC_LONG */
  1566. 0x5c, /* FC_PAD */
  1567. /* 56 */
  1568. 0x1c, /* FC_CVARRAY */
  1569. 0x0, /* 0 */
  1570. /* 58 */ NdrFcShort( 0x1 ), /* 1 */
  1571. /* 60 */ 0x29, /* 41 */
  1572. 0x0, /*  */
  1573. #ifndef _ALPHA_
  1574. /* 62 */ NdrFcShort( 0x8 ), /* x86, MIPS, PPC Stack size/offset = 8 */
  1575. #else
  1576. NdrFcShort( 0x10 ), /* Alpha Stack size/offset = 16 */
  1577. #endif
  1578. /* 64 */ 0x29, /* 41 */
  1579. 0x54, /* FC_DEREFERENCE */
  1580. #ifndef _ALPHA_
  1581. /* 66 */ NdrFcShort( 0xc ), /* x86, MIPS, PPC Stack size/offset = 12 */
  1582. #else
  1583. NdrFcShort( 0x18 ), /* Alpha Stack size/offset = 24 */
  1584. #endif
  1585. /* 68 */ 0x1, /* FC_BYTE */
  1586. 0x5b, /* FC_END */
  1587. /* 70 */
  1588. 0x11, 0x4, /* FC_RP [alloced_on_stack] */
  1589. /* 72 */ NdrFcShort( 0xc ), /* Offset= 12 (84) */
  1590. /* 74 */
  1591. 0x1b, /* FC_CARRAY */
  1592. 0x0, /* 0 */
  1593. /* 76 */ NdrFcShort( 0x1 ), /* 1 */
  1594. /* 78 */ 0x19, /* 25 */
  1595. 0x0, /*  */
  1596. /* 80 */ NdrFcShort( 0x0 ), /* 0 */
  1597. /* 82 */ 0x1, /* FC_BYTE */
  1598. 0x5b, /* FC_END */
  1599. /* 84 */
  1600. 0x16, /* FC_PSTRUCT */
  1601. 0x3, /* 3 */
  1602. /* 86 */ NdrFcShort( 0x8 ), /* 8 */
  1603. /* 88 */
  1604. 0x4b, /* FC_PP */
  1605. 0x5c, /* FC_PAD */
  1606. /* 90 */
  1607. 0x46, /* FC_NO_REPEAT */
  1608. 0x5c, /* FC_PAD */
  1609. /* 92 */ NdrFcShort( 0x4 ), /* 4 */
  1610. /* 94 */ NdrFcShort( 0x4 ), /* 4 */
  1611. /* 96 */ 0x12, 0x0, /* FC_UP */
  1612. /* 98 */ NdrFcShort( 0xffffffe8 ), /* Offset= -24 (74) */
  1613. /* 100 */
  1614. 0x5b, /* FC_END */
  1616. 0x8, /* FC_LONG */
  1617. /* 102 */ 0x8, /* FC_LONG */
  1618. 0x5b, /* FC_END */
  1619. /* 104 */
  1620. 0x1b, /* FC_CARRAY */
  1621. 0x0, /* 0 */
  1622. /* 106 */ NdrFcShort( 0x1 ), /* 1 */
  1623. /* 108 */ 0x29, /* 41 */
  1624. 0x54, /* FC_DEREFERENCE */
  1625. #ifndef _ALPHA_
  1626. /* 110 */ NdrFcShort( 0x8 ), /* x86, MIPS, PPC Stack size/offset = 8 */
  1627. #else
  1628. NdrFcShort( 0x10 ), /* Alpha Stack size/offset = 16 */
  1629. #endif
  1630. /* 112 */ 0x1, /* FC_BYTE */
  1631. 0x5b, /* FC_END */
  1632. /* 114 */
  1633. 0x11, 0x8, /* FC_RP [simple_pointer] */
  1634. /* 116 */ 0x8, /* FC_LONG */
  1635. 0x5c, /* FC_PAD */
  1636. /* 118 */
  1637. 0x1a, /* FC_BOGUS_STRUCT */
  1638. 0x3, /* 3 */
  1639. /* 120 */ NdrFcShort( 0x8 ), /* 8 */
  1640. /* 122 */ NdrFcShort( 0x0 ), /* 0 */
  1641. /* 124 */ NdrFcShort( 0x0 ), /* Offset= 0 (124) */
  1642. /* 126 */ 0x8, /* FC_LONG */
  1643. 0x6, /* FC_SHORT */
  1644. /* 128 */ 0x3e, /* FC_STRUCTPAD2 */
  1645. 0x5b, /* FC_END */
  1646. /* 130 */
  1647. 0x21, /* FC_BOGUS_ARRAY */
  1648. 0x3, /* 3 */
  1649. /* 132 */ NdrFcShort( 0x32 ), /* 50 */
  1650. /* 134 */ NdrFcLong( 0xffffffff ), /* -1 */
  1651. /* 138 */ NdrFcLong( 0xffffffff ), /* -1 */
  1652. /* 142 */ 0x4c, /* FC_EMBEDDED_COMPLEX */
  1653. 0x0, /* 0 */
  1654. /* 144 */ NdrFcShort( 0xffffffe6 ), /* Offset= -26 (118) */
  1655. /* 146 */ 0x5c, /* FC_PAD */
  1656. 0x5b, /* FC_END */
  1657. /* 148 */
  1658. 0x1a, /* FC_BOGUS_STRUCT */
  1659. 0x3, /* 3 */
  1660. /* 150 */ NdrFcShort( 0x8 ), /* 8 */
  1661. /* 152 */ NdrFcShort( 0x0 ), /* 0 */
  1662. /* 154 */ NdrFcShort( 0x0 ), /* Offset= 0 (154) */
  1663. /* 156 */ 0xd, /* FC_ENUM16 */
  1664. 0x8, /* FC_LONG */
  1665. /* 158 */ 0x5c, /* FC_PAD */
  1666. 0x5b, /* FC_END */
  1667. /* 160 */
  1668. 0x21, /* FC_BOGUS_ARRAY */
  1669. 0x3, /* 3 */
  1670. /* 162 */ NdrFcShort( 0x32 ), /* 50 */
  1671. /* 164 */ NdrFcLong( 0xffffffff ), /* -1 */
  1672. /* 168 */ NdrFcLong( 0xffffffff ), /* -1 */
  1673. /* 172 */ 0x4c, /* FC_EMBEDDED_COMPLEX */
  1674. 0x0, /* 0 */
  1675. /* 174 */ NdrFcShort( 0xffffffe6 ), /* Offset= -26 (148) */
  1676. /* 176 */ 0x5c, /* FC_PAD */
  1677. 0x5b, /* FC_END */
  1678. /* 178 */
  1679. 0x15, /* FC_STRUCT */
  1680. 0x3, /* 3 */
  1681. /* 180 */ NdrFcShort( 0xc ), /* 12 */
  1682. /* 182 */ 0xe, /* FC_ENUM32 */
  1683. 0x8, /* FC_LONG */
  1684. /* 184 */ 0x8, /* FC_LONG */
  1685. 0x5b, /* FC_END */
  1686. /* 186 */
  1687. 0x1d, /* FC_SMFARRAY */
  1688. 0x3, /* 3 */
  1689. /* 188 */ NdrFcShort( 0x258 ), /* 600 */
  1690. /* 190 */ 0x4c, /* FC_EMBEDDED_COMPLEX */
  1691. 0x0, /* 0 */
  1692. /* 192 */ NdrFcShort( 0xfffffff2 ), /* Offset= -14 (178) */
  1693. /* 194 */ 0x5c, /* FC_PAD */
  1694. 0x5b, /* FC_END */
  1695. /* 196 */
  1696. 0x12, 0x0, /* FC_UP */
  1697. /* 198 */ NdrFcShort( 0x2 ), /* Offset= 2 (200) */
  1698. /* 200 */
  1699. 0x16, /* FC_PSTRUCT */
  1700. 0x3, /* 3 */
  1701. /* 202 */ NdrFcShort( 0x8 ), /* 8 */
  1702. /* 204 */
  1703. 0x4b, /* FC_PP */
  1704. 0x5c, /* FC_PAD */
  1705. /* 206 */
  1706. 0x46, /* FC_NO_REPEAT */
  1707. 0x5c, /* FC_PAD */
  1708. /* 208 */ NdrFcShort( 0x0 ), /* 0 */
  1709. /* 210 */ NdrFcShort( 0x0 ), /* 0 */
  1710. /* 212 */ 0x12, 0x0, /* FC_UP */
  1711. /* 214 */ NdrFcShort( 0xfffffff2 ), /* Offset= -14 (200) */
  1712. /* 216 */
  1713. 0x5b, /* FC_END */
  1715. 0x8, /* FC_LONG */
  1716. /* 218 */ 0x8, /* FC_LONG */
  1717. 0x5b, /* FC_END */
  1718. /* 220 */
  1719. 0x11, 0x4, /* FC_RP [alloced_on_stack] */
  1720. /* 222 */ NdrFcShort( 0xffffffea ), /* Offset= -22 (200) */
  1721. /* 224 */
  1722. 0x2b, /* FC_NON_ENCAPSULATED_UNION */
  1723. 0x9, /* FC_ULONG */
  1724. /* 226 */ 0x9, /* 9 */
  1725. 0x0, /*  */
  1726. /* 228 */ NdrFcShort( 0xfffffff8 ), /* -8 */
  1727. /* 230 */ NdrFcShort( 0x2 ), /* Offset= 2 (232) */
  1728. /* 232 */ NdrFcShort( 0x8 ), /* 8 */
  1729. /* 234 */ NdrFcShort( 0x2 ), /* 2 */
  1730. /* 236 */ NdrFcLong( 0x1 ), /* 1 */
  1731. /* 240 */ NdrFcShort( 0xffff8008 ), /* Offset= -32760 (-32520) */
  1732. /* 242 */ NdrFcLong( 0x2 ), /* 2 */
  1733. /* 246 */ NdrFcShort( 0xffff800b ), /* Offset= -32757 (-32511) */
  1734. /* 248 */ NdrFcShort( 0x0 ), /* Offset= 0 (248) */
  1735. /* 250 */
  1736. 0x1a, /* FC_BOGUS_STRUCT */
  1737. 0x7, /* 7 */
  1738. /* 252 */ NdrFcShort( 0x10 ), /* 16 */
  1739. /* 254 */ NdrFcShort( 0x0 ), /* 0 */
  1740. /* 256 */ NdrFcShort( 0x0 ), /* Offset= 0 (256) */
  1741. /* 258 */ 0x8, /* FC_LONG */
  1742. 0x4c, /* FC_EMBEDDED_COMPLEX */
  1743. /* 260 */ 0x4, /* 4 */
  1744. NdrFcShort( 0xffffffdb ), /* Offset= -37 (224) */
  1745. 0x5b, /* FC_END */
  1746. /* 264 */
  1747. 0x21, /* FC_BOGUS_ARRAY */
  1748. 0x7, /* 7 */
  1749. /* 266 */ NdrFcShort( 0x0 ), /* 0 */
  1750. /* 268 */ 0x29, /* 41 */
  1751. 0x0, /*  */
  1752. #ifndef _ALPHA_
  1753. /* 270 */ NdrFcShort( 0x4 ), /* x86, MIPS, PPC Stack size/offset = 4 */
  1754. #else
  1755. NdrFcShort( 0x8 ), /* Alpha Stack size/offset = 8 */
  1756. #endif
  1757. /* 272 */ NdrFcLong( 0xffffffff ), /* -1 */
  1758. /* 276 */ 0x4c, /* FC_EMBEDDED_COMPLEX */
  1759. 0x0, /* 0 */
  1760. /* 278 */ NdrFcShort( 0xffffffe4 ), /* Offset= -28 (250) */
  1761. /* 280 */ 0x5c, /* FC_PAD */
  1762. 0x5b, /* FC_END */
  1763. /* 282 */
  1764. 0x11, 0x0, /* FC_RP */
  1765. /* 284 */ NdrFcShort( 0x60 ), /* Offset= 96 (380) */
  1766. /* 286 */
  1767. 0x2b, /* FC_NON_ENCAPSULATED_UNION */
  1768. 0x9, /* FC_ULONG */
  1769. /* 288 */ 0x9, /* 9 */
  1770. 0x0, /*  */
  1771. /* 290 */ NdrFcShort( 0xfffffffc ), /* -4 */
  1772. /* 292 */ NdrFcShort( 0x2 ), /* Offset= 2 (294) */
  1773. /* 294 */ NdrFcShort( 0x4 ), /* 4 */
  1774. /* 296 */ NdrFcShort( 0x2 ), /* 2 */
  1775. /* 298 */ NdrFcLong( 0x1 ), /* 1 */
  1776. /* 302 */ NdrFcShort( 0xa ), /* Offset= 10 (312) */
  1777. /* 304 */ NdrFcLong( 0x2 ), /* 2 */
  1778. /* 308 */ NdrFcShort( 0x26 ), /* Offset= 38 (346) */
  1779. /* 310 */ NdrFcShort( 0xffffffff ), /* Offset= -1 (309) */
  1780. /* 312 */
  1781. 0x12, 0x0, /* FC_UP */
  1782. /* 314 */ NdrFcShort( 0xc ), /* Offset= 12 (326) */
  1783. /* 316 */
  1784. 0x1b, /* FC_CARRAY */
  1785. 0x3, /* 3 */
  1786. /* 318 */ NdrFcShort( 0x4 ), /* 4 */
  1787. /* 320 */ 0x19, /* 25 */
  1788. 0x0, /*  */
  1789. /* 322 */ NdrFcShort( 0x0 ), /* 0 */
  1790. /* 324 */ 0x8, /* FC_LONG */
  1791. 0x5b, /* FC_END */
  1792. /* 326 */
  1793. 0x16, /* FC_PSTRUCT */
  1794. 0x3, /* 3 */
  1795. /* 328 */ NdrFcShort( 0x8 ), /* 8 */
  1796. /* 330 */
  1797. 0x4b, /* FC_PP */
  1798. 0x5c, /* FC_PAD */
  1799. /* 332 */
  1800. 0x46, /* FC_NO_REPEAT */
  1801. 0x5c, /* FC_PAD */
  1802. /* 334 */ NdrFcShort( 0x4 ), /* 4 */
  1803. /* 336 */ NdrFcShort( 0x4 ), /* 4 */
  1804. /* 338 */ 0x12, 0x0, /* FC_UP */
  1805. /* 340 */ NdrFcShort( 0xffffffe8 ), /* Offset= -24 (316) */
  1806. /* 342 */
  1807. 0x5b, /* FC_END */
  1809. 0x8, /* FC_LONG */
  1810. /* 344 */ 0x8, /* FC_LONG */
  1811. 0x5b, /* FC_END */
  1812. /* 346 */
  1813. 0x12, 0x0, /* FC_UP */
  1814. /* 348 */ NdrFcShort( 0xc ), /* Offset= 12 (360) */
  1815. /* 350 */
  1816. 0x1b, /* FC_CARRAY */
  1817. 0x7, /* 7 */
  1818. /* 352 */ NdrFcShort( 0x8 ), /* 8 */
  1819. /* 354 */ 0x19, /* 25 */
  1820. 0x0, /*  */
  1821. /* 356 */ NdrFcShort( 0x0 ), /* 0 */
  1822. /* 358 */ 0xb, /* FC_HYPER */
  1823. 0x5b, /* FC_END */
  1824. /* 360 */
  1825. 0x16, /* FC_PSTRUCT */
  1826. 0x3, /* 3 */
  1827. /* 362 */ NdrFcShort( 0x8 ), /* 8 */
  1828. /* 364 */
  1829. 0x4b, /* FC_PP */
  1830. 0x5c, /* FC_PAD */
  1831. /* 366 */
  1832. 0x46, /* FC_NO_REPEAT */
  1833. 0x5c, /* FC_PAD */
  1834. /* 368 */ NdrFcShort( 0x4 ), /* 4 */
  1835. /* 370 */ NdrFcShort( 0x4 ), /* 4 */
  1836. /* 372 */ 0x12, 0x0, /* FC_UP */
  1837. /* 374 */ NdrFcShort( 0xffffffe8 ), /* Offset= -24 (350) */
  1838. /* 376 */
  1839. 0x5b, /* FC_END */
  1841. 0x8, /* FC_LONG */
  1842. /* 378 */ 0x8, /* FC_LONG */
  1843. 0x5b, /* FC_END */
  1844. /* 380 */
  1845. 0x1a, /* FC_BOGUS_STRUCT */
  1846. 0x3, /* 3 */
  1847. /* 382 */ NdrFcShort( 0x8 ), /* 8 */
  1848. /* 384 */ NdrFcShort( 0x0 ), /* 0 */
  1849. /* 386 */ NdrFcShort( 0x0 ), /* Offset= 0 (386) */
  1850. /* 388 */ 0x8, /* FC_LONG */
  1851. 0x4c, /* FC_EMBEDDED_COMPLEX */
  1852. /* 390 */ 0x0, /* 0 */
  1853. NdrFcShort( 0xffffff97 ), /* Offset= -105 (286) */
  1854. 0x5b, /* FC_END */
  1856. 0x0
  1857.         }
  1858.     };