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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 防火墙与安全工具 > 查看源码
srvsvc_s.c
资源名称：2008-MS08-067.rar　[点击查看]
上传用户：fsojjn
上传日期：2015-10-05
资源大小：12k
文件大小：46k
源码类别：

防火墙与安全工具

开发平台：

Visual C++

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