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