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

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

Windows编程

开发平台：

Visual C++

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