home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / msdn_vcb / samples / vc98 / sdk / netds / rpc / rpcsvc / rpcsvc_s.c < prev    next >
C/C++ Source or Header  |  1998-03-30  |  56KB  |  1,753 lines
  1. /* this ALWAYS GENERATED file contains the RPC server stubs */
  2.  
  3.  
  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(  )
  12.  
  13. #include <string.h>
  14. #include "rpcsvc.h"
  15.  
  16. #define TYPE_FORMAT_STRING_SIZE   395                               
  17. #define PROC_FORMAT_STRING_SIZE   141                               
  18.  
  19. typedef struct _MIDL_TYPE_FORMAT_STRING
  20.     {
  21.     short          Pad;
  22.     unsigned char  Format[ TYPE_FORMAT_STRING_SIZE ];
  23.     } MIDL_TYPE_FORMAT_STRING;
  24.  
  25. typedef struct _MIDL_PROC_FORMAT_STRING
  26.     {
  27.     short          Pad;
  28.     unsigned char  Format[ PROC_FORMAT_STRING_SIZE ];
  29.     } MIDL_PROC_FORMAT_STRING;
  30.  
  31. extern const MIDL_TYPE_FORMAT_STRING __MIDL_TypeFormatString;
  32. extern const MIDL_PROC_FORMAT_STRING __MIDL_ProcFormatString;
  33.  
  34. /* Standard interface: RpcServiceSample, ver. 1.0,
  35.    GUID={0x15cd3850,0x28ca,0x11ce,{0xa4,0xe8,0x00,0xaa,0x00,0x61,0x16,0xcb}} */
  36.  
  37.  
  38. extern RPC_DISPATCH_TABLE RpcServiceSample_v1_0_DispatchTable;
  39.  
  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;
  53.  
  54. extern const MIDL_STUB_DESC RpcServiceSample_StubDesc;
  55.  
  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. }
  100.  
  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. }
  145.  
  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. }
  211.  
  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. }
  273.  
  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. }
  332.  
  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. }
  396.  
  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. }
  479.  
  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. }
  544.  
  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. }
  620.  
  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. }
  679.  
  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. }
  738.  
  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. }
  790.  
  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. }
  846.  
  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. }
  911.  
  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. }
  974.  
  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. }
  1041.  
  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. }
  1097.  
  1098. extern MALLOC_FREE_STRUCT _MallocFreeStruct;
  1099.  
  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.     };
  1123.  
  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.     };
  1150.  
  1151. static void __RPC_FAR * __RPC_USER
  1152. RpcServiceSample_malloc_wrapper( size_t _Size )
  1153. {
  1154.     return( malloc( _Size ) );
  1155. }
  1156.  
  1157. static void  __RPC_USER
  1158. RpcServiceSample_free_wrapper( void __RPC_FAR * _p )
  1159. {
  1160.     free( _p );
  1161. }
  1162.  
  1163. static MALLOC_FREE_STRUCT _MallocFreeStruct = 
  1164. {
  1165.     RpcServiceSample_malloc_wrapper,
  1166.     RpcServiceSample_free_wrapper
  1167. };
  1168.  
  1169. #if !defined(__RPC_WIN32__)
  1170. #error  Invalid build platform for this stub.
  1171. #endif
  1172.  
  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 */
  1385.  
  1386.             0x0
  1387.         }
  1388.     };
  1389.  
  1390. static const MIDL_TYPE_FORMAT_STRING __MIDL_TypeFormatString =
  1391.     {
  1392.         0,
  1393.         {
  1394.             
  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 */
  1509.  
  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 */
  1608.  
  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 */
  1702.  
  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 */
  1734.  
  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 */
  1749.  
  1750.             0x0
  1751.         }
  1752.     };
  1753.