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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
hxengin.h
资源名称：helix.src.0812.rar　[点击查看]
上传用户：zhongxx05
上传日期：2007-06-06
资源大小：33641k
文件大小：64k
源码类别：

Symbian

开发平台：

C/C++

hxengin.h：源码内容
  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  36. #ifndef _HXENGIN_H_
  37. #define _HXENGIN_H_
  39. #include "hxcom.h"
  41. /*
  42.  * Forward declarations of some interfaces used here-in.
  43.  */
  45. typedef _INTERFACE IHXBuffer IHXBuffer;
  46. typedef _INTERFACE IHXCallback IHXCallback;
  47. typedef _INTERFACE IHXScheduler IHXScheduler;
  48. typedef _INTERFACE IHXTCPResponse IHXTCPResponse;
  49. typedef _INTERFACE IHXLBoundTCPSocket IHXLBoundTCPSocket;
  50. typedef _INTERFACE IHXTCPSocket IHXTCPSocket;
  51. typedef _INTERFACE IHXListenResponse IHXListenResponse;
  52. typedef _INTERFACE IHXListenSocket IHXListenSocket;
  53. typedef _INTERFACE IHXNetworkServices IHXNetworkServices;
  54. typedef _INTERFACE IHXNetworkServices2 IHXNetworkServices2;
  55. typedef _INTERFACE IHXUDPResponse      IHXUDPResponse;
  56. typedef _INTERFACE IHXUDPSocket IHXUDPSocket;
  57. typedef _INTERFACE IHXResolver IHXResolver;
  58. typedef _INTERFACE IHXResolverResponse IHXResolverResponse;
  59. typedef _INTERFACE IHXInterruptSafe IHXInterruptSafe;
  60. typedef _INTERFACE IHXAsyncIOSelection IHXAsyncIOSelection;
  61. typedef _INTERFACE IHXUDPMulticastInit IHXUDPMulticastInit;
  62. typedef _INTERFACE IHXInterruptState IHXInterruptState;
  63. typedef _INTERFACE IHXOptimizedScheduler IHXOptimizedScheduler;
  64. // $Private:
  65. typedef _INTERFACE IHXThreadSafeScheduler IHXThreadSafeScheduler;
  66. typedef _INTERFACE IHXBufferedSocket IHXBufferedSocket;
  67. typedef _INTERFACE IHXNetInterfaces IHXNetInterfaces;
  68. typedef _INTERFACE IHXNetInterfacesAdviseSink IHXNetInterfacesAdviseSink;
  69. // $EndPrivate.
  70. typedef _INTERFACE IHXNetworkInterfaceEnumerator IHXNetworkInterfaceEnumerator;
  71. typedef _INTERFACE IHXUDPConnectedSocket           IHXUDPConnectedSocket;
  74. /*
  75.  * Address flags starting with PNR are depricated.
  76.  */
  77. #define HXR_INADDR_ANY (UINT32)0x00000000  //THIS FLAG IS DEPRICATED
  78. #define HX_INADDR_ANY (UINT32)0x00000000
  80. /*
  81.  * 255.255.255.254
  82.  *
  83.  * Bind to all ports in IPBindings list from
  84.  * server config.
  85.  */
  86. #define HXR_INADDR_IPBINDINGS (UINT32)0xfffffffe    //THIS FLAG IS DEPRICATED
  87. #define HX_INADDR_IPBINDINGS (UINT32)0xfffffffe
  90. /* Async IO Selection Type (Unix Only) */
  92. #define PNAIO_READ 1
  93. #define PNAIO_WRITE 2
  94. #define PNAIO_EXCEPTION 4
  96. /****************************************************************************
  97.  * 
  98.  *  Interface:
  99.  * 
  100.  * IHXCallback
  101.  * 
  102.  *  Purpose:
  103.  * 
  104.  * This interface defines a simple callback which will be used in
  105.  * various interfaces such as IHXScheduler.
  106.  * 
  107.  *  IID_IHXCallback:
  108.  * 
  109.  * {00000100-0901-11d1-8B06-00A024406D59}
  110.  * 
  111.  */
  112. DEFINE_GUID(IID_IHXCallback, 0x00000100, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 
  113. 0xa0, 0x24, 0x40, 0x6d, 0x59);
  115. #undef  INTERFACE
  116. #define INTERFACE   IHXCallback
  118. DECLARE_INTERFACE_(IHXCallback, IUnknown)
  119. {
  120.     /*
  121.      *  IUnknown methods
  122.      */
  123.     STDMETHOD(QueryInterface) (THIS_
  124. REFIID riid,
  125. void** ppvObj) PURE;
  127.     STDMETHOD_(ULONG32,AddRef) (THIS) PURE;
  129.     STDMETHOD_(ULONG32,Release) (THIS) PURE;
  131.     /*
  132.      *  IHXCallback methods
  133.      */
  135.     /************************************************************************
  136.      * Method:
  137.      *     IHXCallback::Func
  138.      * Purpose:
  139.      *     This is the function that will be called when a callback is
  140.      *     to be executed.
  141.      */
  142.     STDMETHOD(Func) (THIS) PURE;
  143. };
  146. /****************************************************************************
  147.  * 
  148.  *  Interface:
  149.  * 
  150.  * IHXScheduler
  151.  * 
  152.  *  Purpose:
  153.  * 
  154.  * This interface provides the user with a way of scheduling callbacks
  155.  * that will be executed at some time in the future.
  156.  * 
  157.  *  IID_IHXScheduler:
  158.  * 
  159.  * {00000101-0901-11d1-8B06-00A024406D59}
  160.  * 
  161.  */
  162. DEFINE_GUID(IID_IHXScheduler, 0x00000101, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 
  163. 0xa0, 0x24, 0x40, 0x6d, 0x59);
  165. #undef  INTERFACE
  166. #define INTERFACE   IHXScheduler
  168. typedef ULONG32 CallbackHandle;
  170. typedef struct _HXTimeval
  171. {
  172.     UINT32 tv_sec;
  173.     UINT32 tv_usec;
  174. } HXTimeval;
  176. DECLARE_INTERFACE_(IHXScheduler, IUnknown)
  177. {
  178.     /*
  179.      *  IUnknown methods
  180.      */
  181.     STDMETHOD(QueryInterface) (THIS_
  182. REFIID riid,
  183. void** ppvObj) PURE;
  185.     STDMETHOD_(ULONG32,AddRef) (THIS) PURE;
  187.     STDMETHOD_(ULONG32,Release) (THIS) PURE;
  189.     /*
  190.      * IHXScheduler methods
  191.      */
  193.     /************************************************************************
  194.      * Method:
  195.      *     IHXScheduler::RelativeEnter
  196.      * Purpose:
  197.      *     Schedule a callback to be executed "ms" milliseconds from now
  198.      *     This function is less percise then AbsoluteEnter and should only
  199.      *     be used when accurate timing is not critical.
  200.      */
  201.     STDMETHOD_(CallbackHandle,RelativeEnter) (THIS_
  202. IHXCallback* pCallback,
  203. UINT32 ms) PURE;
  205.     /************************************************************************
  206.      * Method:
  207.      *     IHXScheduler::AbsoluteEnter
  208.      * Purpose:
  209.      *     Schedule a callback to be executed at time "tVal".
  210.      */
  211.     STDMETHOD_(CallbackHandle,AbsoluteEnter) (THIS_
  212. IHXCallback* pCallback,
  213. HXTimeval tVal) PURE;
  215.     /************************************************************************
  216.      * Method:
  217.      *     IHXScheduler::Remove
  218.      * Purpose:
  219.      *     Remove a callback from the scheduler.
  220.      */
  221.     STDMETHOD(Remove) (THIS_
  222.      CallbackHandle Handle) PURE;
  224.     /************************************************************************
  225.      * Method:
  226.      *     IHXScheduler::GetCurrentSchedulerTime
  227.      * Purpose:
  228.      *     Gives the current time (in the timeline of the scheduler).
  229.      */
  230.     STDMETHOD_(HXTimeval,GetCurrentSchedulerTime) (THIS) PURE;
  231. };
  234. /****************************************************************************
  235.  * 
  236.  *  Interface:
  237.  * 
  238.  * IHXTCPResponse
  239.  * 
  240.  *  Purpose:
  241.  * 
  242.  * This is the response interface for the asynchronous TCP networking 
  243.  * interface.
  244.  * 
  245.  *  IID_IHXTCPResponse:
  246.  * 
  247.  * {00000102-0901-11d1-8B06-00A024406D59}
  248.  * 
  249.  */
  250. DEFINE_GUID(IID_IHXTCPResponse, 0x00000102, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 
  251. 0xa0, 0x24, 0x40, 0x6d, 0x59);
  253. #undef  INTERFACE
  254. #define INTERFACE   IHXTCPResponse
  256. DECLARE_INTERFACE_(IHXTCPResponse, IUnknown)
  257. {
  258.     /*
  259.      *  IUnknown methods
  260.      */
  261.     STDMETHOD(QueryInterface) (THIS_
  262. REFIID riid,
  263. void** ppvObj) PURE;
  265.     STDMETHOD_(ULONG32,AddRef) (THIS) PURE;
  267.     STDMETHOD_(ULONG32,Release) (THIS) PURE;
  269.     /*
  270.      * IHXTCPResponse methods
  271.      */
  273.     /************************************************************************
  274.      * Method:
  275.      *     IHXTCPResponse::ConnectDone
  276.      * Purpose:
  277.      *     A Connect operation has been completed or an error has occurred.
  278.      */
  279.     STDMETHOD(ConnectDone) (THIS_
  280. HX_RESULT status) PURE;
  282.     /************************************************************************
  283.      * Method:
  284.      *     IHXTCPResponse::ReadDone
  285.      * Purpose:
  286.      *     A Read operation has been completed or an error has occurred.
  287.      *     The data is returned in the IHXBuffer.
  288.      */
  289.     STDMETHOD(ReadDone) (THIS_
  290. HX_RESULT status,
  291. IHXBuffer* pBuffer) PURE;
  293.     /************************************************************************
  294.      * Method:
  295.      *     IHXTCPResponse::WriteReady
  296.      * Purpose:
  297.      *     This is the response method for WantWrite.
  298.      *     If HX_RESULT is ok, then the TCP channel is ok to Write to.
  299.      */
  300.     STDMETHOD(WriteReady) (THIS_
  301.      HX_RESULT status) PURE;
  303.     /************************************************************************
  304.      * Method:
  305.      *     IHXTCPResponse::Closed
  306.      * Purpose:
  307.      *     This method is called to inform you that the TCP channel has
  308.      *     been closed by the peer or closed due to error.
  309.      */
  310.     STDMETHOD(Closed) (THIS_
  311. HX_RESULT status) PURE;
  312. };
  315. /****************************************************************************
  316.  * 
  317.  *  Interface:
  318.  * 
  319.  * IHXTCPSocket
  320.  * 
  321.  *  Purpose:
  322.  * 
  323.  * Provides the user with an asynchronous TCP networking interface.
  324.  * 
  325.  *  IID_IHXTCPSocket:
  326.  * 
  327.  * {00000103-0901-11d1-8B06-00A024406D59}
  328.  * 
  329.  */
  330. DEFINE_GUID(IID_IHXTCPSocket, 0x00000103, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 
  331. 0xa0, 0x24, 0x40, 0x6d, 0x59);
  333. #undef  INTERFACE
  334. #define INTERFACE   IHXTCPSocket
  336. DECLARE_INTERFACE_(IHXTCPSocket, IUnknown)
  337. {
  338.     /*
  339.      *  IUnknown methods
  340.      */
  341.     STDMETHOD(QueryInterface) (THIS_
  342. REFIID riid,
  343. void** ppvObj) PURE;
  345.     STDMETHOD_(ULONG32,AddRef) (THIS) PURE;
  347.     STDMETHOD_(ULONG32,Release) (THIS) PURE;
  349.     /*
  350.      * IHXTCPSocket methods
  351.      *
  352.      *  Network addresses and ports are in native byte order
  353.      *  
  354.      */
  356.     STDMETHOD(Init) (THIS_
  357. IHXTCPResponse*    /*IN*/  pTCPResponse) PURE;
  359.     STDMETHOD(SetResponse) (THIS_
  360.      IHXTCPResponse*     pTCPResponse) PURE;
  362.     STDMETHOD(Bind) (THIS_
  363. UINT32     ulLocalAddr,
  364. UINT16      nPort) PURE;
  366.     /*
  367.      * pDestination is a string containing host name or dotted-ip notation
  368.      */
  369.     STDMETHOD(Connect) (THIS_
  370. const char*     pDestination,
  371. UINT16      nPort) PURE;
  373.     STDMETHOD(Read) (THIS_
  374. UINT16     Size) PURE;
  376.     STDMETHOD(Write) (THIS_
  377. IHXBuffer*     pBuffer) PURE;
  379.     /************************************************************************
  380.      * Method:
  381.      *     IHXTCPSocket::WantWrite
  382.      * Purpose:
  383.      *     This method is called when you wish to write a large amount of
  384.      *     data.  If you are only writing small amounts of data, you can
  385.      *     just call Write (all data not ready to be transmitted will be
  386.      *     buffered on your behalf).  When the TCP channel is ready to be
  387.      *     written to, the response interfaces WriteReady method will be 
  388.      *     called.
  389.      */
  390.     STDMETHOD(WantWrite) (THIS) PURE;
  392.     /************************************************************************
  393.      * Method:
  394.      *     IHXTCPSocket::GetForeignAddress
  395.      * Purpose:
  396.      *     Returns the address of the other end of the TCP socket as a
  397.      *     ULONG32 in local host order
  398.      */
  399.     STDMETHOD(GetForeignAddress) (THIS_
  400.      REF(ULONG32) lAddress) PURE;
  402.     STDMETHOD(GetLocalAddress) (THIS_
  403.      REF(ULONG32) lAddress) PURE;
  405.     /************************************************************************
  406.      * Method:
  407.      *     IHXTCPSocket::GetForeignPort
  408.      * Purpose:
  409.      *     Returns the port of the other end of the TCP socket in local
  410.      *      host order.
  411.      */
  412.     STDMETHOD(GetForeignPort) (THIS_
  413.      REF(UINT16) port) PURE;
  415.     STDMETHOD(GetLocalPort) (THIS_
  416.      REF(UINT16) port) PURE;
  417. };
  419. // $Private:
  420. /****************************************************************************
  421.  * 
  422.  *  Interface:
  423.  * 
  424.  * IHXTCPSecureSocket
  425.  * 
  426.  *  Purpose:
  427.  * 
  428.  * When an IHXTCPSocket also supports this interface,
  429.  * it allows you to say it's secure so it tries to use
  430.  * SSL.
  431.  * 
  432.  */
  433. DEFINE_GUID(IID_IHXTCPSecureSocket, 0x00000203, 0x911, 0x21d1, 0x8c, 0x4, 0x0, 
  434. 0xa0, 0x24, 0x40, 0x6d, 0x54);
  436. #undef  INTERFACE
  437. #define INTERFACE   IHXTCPSecureSocket
  439. DECLARE_INTERFACE_(IHXTCPSecureSocket, IUnknown)
  440. {
  441.     /*
  442.      *  IUnknown methods
  443.      */
  444.     STDMETHOD(QueryInterface) (THIS_
  445. REFIID riid,
  446. void** ppvObj) PURE;
  448.     STDMETHOD_(ULONG32,AddRef) (THIS) PURE;
  450.     STDMETHOD_(ULONG32,Release) (THIS) PURE;
  452.     /*
  453.      *  IHXTCPSecureSocket method
  454.      */
  455.     STDMETHOD(SetSecure) (THIS_
  456.      BOOL bSecure) PURE;
  457. };
  458. // $EndPrivate.
  462. // $Private:
  463. /****************************************************************************
  464.  * 
  465.  *  Interface:
  466.  * 
  467.  * IHXSSL
  468.  * 
  469.  *  Purpose:
  470.  * 
  471.  * This is the interface to an SSL library.
  472.  * 
  473.  */
  474. DEFINE_GUID(IID_IHXSSL, 0x34e171d4, 0xa8f0,
  475.            0x4832, 0xbc, 0x7d, 0x06, 0xdf, 0xe3, 0xae, 0x58, 0xfd);
  477. DECLARE_INTERFACE_(IHXSSL, IUnknown)
  478. {
  479. /*
  480.  * IUnknown methods
  481.  */
  483. STDMETHOD(QueryInterface) (THIS_
  484. REFIID riid,
  485. void** ppvObj) PURE;
  487. STDMETHOD_(ULONG32, AddRef) (THIS) PURE;
  489. STDMETHOD_(ULONG32, Release) (THIS) PURE;
  491. /*
  492.  *
  493.  */
  495. STDMETHOD(Initialize) (THIS) PURE;
  497. STDMETHOD(Shutdown) (THIS) PURE;
  499. STDMETHOD(PostConnect) (THIS_
  500. LONG32 nSocketNumber) PURE;
  502. STDMETHOD_(LONG32, Read) (THIS_
  503. LONG32 nSocketNumber,
  504. void* buff,
  505. LONG32 buffLen) PURE;
  507. STDMETHOD_(LONG32, Write) (THIS_
  508. LONG32 nSocketNumber,
  509. void* buff,
  510. LONG32 buffLen) PURE;
  512. STDMETHOD(Close) (THIS_
  513. LONG32 nSocketNumber) PURE;
  515. STDMETHOD(SetCallbacks) (THIS_
  516. void* readCallback,
  517. void* writeCallback,
  518. void* closeCallback) PURE;
  521. };
  522. // $EndPrivate.
  528. // $Private:
  529. /****************************************************************************
  530.  * 
  531.  *  Interface:
  532.  * 
  533.  * IHXBufferedSocket
  534.  * 
  535.  *  Purpose:
  536.  * 
  537.  * This provdies a method for doing for doing more optimal
  538.  *      TCP delivery using desired packet size and writev.  
  539.  * 
  540.  *  IID_IHXTCPSocket:
  541.  * 
  542.  * {00001402-0901-11d1-8B06-00A024406D59}
  543.  * 
  544.  */
  545. DEFINE_GUID(IID_IHXBufferedSocket, 
  546.     0x00001402, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59);
  548. #undef  INTERFACE
  549. #define INTERFACE   IHXBufferedSocket
  551. DECLARE_INTERFACE_(IHXBufferedSocket, IUnknown)
  552. {
  553.     /*
  554.      *  IUnknown methods
  555.      */
  556.     STDMETHOD(QueryInterface) (THIS_
  557. REFIID riid,
  558. void** ppvObj) PURE;
  560.     STDMETHOD_(ULONG32,AddRef) (THIS) PURE;
  562.     STDMETHOD_(ULONG32,Release) (THIS) PURE;
  564.     /*
  565.      * IHXTCPSocket methods
  566.      */
  568.     STDMETHOD(BufferedWrite) (THIS_
  569. IHXBuffer* pBuffer) PURE;
  571.     STDMETHOD(FlushWrite) (THIS) PURE;
  573.     STDMETHOD(SetDesiredPacketSize)     (THIS_
  574. UINT32 ulPacketSize) PURE;
  576. };
  577. // $EndPrivate.
  580. /****************************************************************************
  581.  * 
  582.  *  Interface:
  583.  * 
  584.  * IHXListenResponse
  585.  * 
  586.  *  Purpose:
  587.  * 
  588.  * This is the response interface for the asynchronous TCP listening
  589.  * socket interface.
  590.  * 
  591.  *  IID_IHXListenResponse:
  592.  * 
  593.  * {00000104-0901-11d1-8B06-00A024406D59}
  594.  * 
  595.  */
  596. DEFINE_GUID(IID_IHXListenResponse, 0x00000104, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 
  597. 0xa0, 0x24, 0x40, 0x6d, 0x59);
  599. #undef  INTERFACE
  600. #define INTERFACE   IHXListenResponse
  602. DECLARE_INTERFACE_(IHXListenResponse, IUnknown)
  603. {
  604.     /*
  605.      *  IUnknown methods
  606.      */
  607.     STDMETHOD(QueryInterface) (THIS_
  608. REFIID riid,
  609. void** ppvObj) PURE;
  611.     STDMETHOD_(ULONG32,AddRef) (THIS) PURE;
  613.     STDMETHOD_(ULONG32,Release) (THIS) PURE;
  615.     /*
  616.      * IHXListenResponse methods
  617.      */
  619.     STDMETHOD(NewConnection) (THIS_
  620. HX_RESULT status,
  621. IHXTCPSocket* pTCPSocket) PURE;
  622. };
  624. /****************************************************************************
  625.  * 
  626.  *  Interface:
  627.  * 
  628.  * IHXListenSocket
  629.  * 
  630.  *  Purpose:
  631.  * 
  632.  * This interfaces allows you to asynchronously listen on a port for
  633.  * TCP connections.
  634.  * 
  635.  *  IID_IHXListenSocket:
  636.  * 
  637.  * {00000105-0901-11d1-8B06-00A024406D59}
  638.  * 
  639.  */
  640. DEFINE_GUID(IID_IHXListenSocket, 0x00000105, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 
  641. 0xa0, 0x24, 0x40, 0x6d, 0x59);
  643. #undef  INTERFACE
  644. #define INTERFACE   IHXListenSocket
  646. DECLARE_INTERFACE_(IHXListenSocket, IUnknown)
  647. {
  648.     /*
  649.      *  IUnknown methods
  650.      */
  651.     STDMETHOD(QueryInterface) (THIS_
  652. REFIID riid,
  653. void** ppvObj) PURE;
  655.     STDMETHOD_(ULONG32,AddRef) (THIS) PURE;
  657.     STDMETHOD_(ULONG32,Release) (THIS) PURE;
  659.     /*
  660.      * IHXListenSocket methods
  661.      */
  663.     STDMETHOD(Init) (THIS_
  664. UINT32 ulLocalAddr,
  665. UINT16 port,
  666. IHXListenResponse*    /*IN*/ pListenResponse
  667. ) PURE;
  668. };
  671. /****************************************************************************
  672.  * 
  673.  *  Interface:
  674.  * 
  675.  * IHXNetworkServices
  676.  * 
  677.  *  Purpose:
  678.  * 
  679.  * This is a factory interface for the various types of networking
  680.  * interfaces described above.
  681.  * 
  682.  *  IID_IHXNetworkServices:
  683.  * 
  684.  * {00000106-0901-11d1-8B06-00A024406D59}
  685.  * 
  686.  */
  687. DEFINE_GUID(IID_IHXNetworkServices, 0x00000106, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 
  688. 0xa0, 0x24, 0x40, 0x6d, 0x59);
  690. #undef  INTERFACE
  691. #define INTERFACE   IHXNetworkServices
  693. DECLARE_INTERFACE_(IHXNetworkServices, IUnknown)
  694. {
  695.     /*
  696.      *  IUnknown methods
  697.      */
  698.     STDMETHOD(QueryInterface) (THIS_
  699. REFIID riid,
  700. void** ppvObj) PURE;
  702.     STDMETHOD_(ULONG32,AddRef) (THIS) PURE;
  704.     STDMETHOD_(ULONG32,Release) (THIS) PURE;
  706.     /*
  707.      * IHXNetworkServices methods
  708.      */
  710.     /************************************************************************
  711.      * Method:
  712.      *     IHXNetworkServices::CreateTCPSocket
  713.      * Purpose:
  714.      *     Create a new TCP socket.
  715.      */
  716.     STDMETHOD(CreateTCPSocket) (THIS_
  717. IHXTCPSocket**    /*OUT*/  ppTCPSocket) PURE;
  719.     /************************************************************************
  720.      * Method:
  721.      *     IHXNetworkServices::CreateUDPSocket
  722.      * Purpose:
  723.      *     Create a new UDP socket.
  724.      */
  725.     STDMETHOD(CreateUDPSocket) (THIS_
  726. IHXUDPSocket**    /*OUT*/  ppUDPSocket) PURE;
  728.     /************************************************************************
  729.      * Method:
  730.      *     IHXNetworkServices::CreateListenSocket
  731.      * Purpose:
  732.      *     Create a new TCP socket that will listen for connections on a
  733.      *     particular port.
  734.      */
  735.     STDMETHOD(CreateListenSocket)   (THIS_
  736.     IHXListenSocket** /*OUT*/ ppListenSocket
  737.     ) PURE;
  739.     /************************************************************************
  740.      * Method:
  741.      *     IHXNetworkServices::CreateResolver
  742.      * Purpose:
  743.      *     Create a new resolver that can lookup host names
  744.      */
  745.     STDMETHOD(CreateResolver)   (THIS_
  746.      IHXResolver**    /*OUT*/     ppResolver) PURE;
  747. };
  750. /****************************************************************************
  751.  * 
  752.  *  Interface:
  753.  * 
  754.  * IHXNetworkServices2
  755.  * 
  756.  *  Purpose:
  757.  * 
  758.  * This is a factory interface for the various types of networking
  759.  * interfaces described above.
  760.  * 
  761.  *  IID_IHXNetworkServices:
  762.  * 
  763.  * {17951551-5683-11d3-B6BA-00C0F031C237}
  764.  * 
  765.  */
  767. // {17951551-5683-11d3-B6BA-00C0F031C237}
  768. DEFINE_GUID(IID_IHXNetworkServices2, 0x17951551, 0x5683, 0x11d3, 0xb6, 0xba, 0x0, 0xc0, 0xf0, 0x31, 0xc2, 0x37);
  770. #undef  INTERFACE
  771. #define INTERFACE   IHXNetworkServices2
  773. DECLARE_INTERFACE_(IHXNetworkServices2, IHXNetworkServices)
  774. {
  775.     /************************************************************************
  776.      * Method:
  777.      *     IHXNetworkServices2::CreateLBoundTCPSocket
  778.      * Purpose:
  779.      *     Create a new local bound TCP socket.
  780.      */
  781.     STDMETHOD(CreateLBoundTCPSocket) (THIS_
  782. IHXTCPSocket**    /*OUT*/  ppTCPSocket) PURE;
  783. };
  787. /****************************************************************************
  788.  * 
  789.  *  Interface:
  790.  * 
  791.  * IHXUDPResponse
  792.  * 
  793.  *  Purpose:
  794.  * 
  795.  * This is the response interface for the asynchronous UDP networking 
  796.  * interface.
  797.  * 
  798.  *  IID_IHXUDPResponse:
  799.  * 
  800.  * {00000107-0901-11d1-8B06-00A024406D59}
  801.  * 
  802.  */
  803. DEFINE_GUID(IID_IHXUDPResponse, 0x00000107, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 
  804. 0xa0, 0x24, 0x40, 0x6d, 0x59);
  806. #undef  INTERFACE
  807. #define INTERFACE   IHXUDPResponse
  809. DECLARE_INTERFACE_(IHXUDPResponse, IUnknown)
  810. {
  811.     /*
  812.      *  IUnknown methods
  813.      */
  814.     STDMETHOD(QueryInterface) (THIS_
  815. REFIID riid,
  816. void** ppvObj) PURE;
  818.     STDMETHOD_(ULONG32,AddRef) (THIS) PURE;
  820.     STDMETHOD_(ULONG32,Release) (THIS) PURE;
  822.     /*
  823.      * IHXUDPResponse methods
  824.      */
  826.     STDMETHOD(ReadDone) (THIS_
  827. HX_RESULT status,
  828. IHXBuffer* pBuffer,
  829. ULONG32 ulAddr,
  830. UINT16 nPort) PURE;
  831. };
  834. /****************************************************************************
  835.  * 
  836.  *  Interface:
  837.  * 
  838.  * IHXUDPSocket
  839.  * 
  840.  *  Purpose:
  841.  * 
  842.  * Provides the user with an asynchronous UDP networking interface.
  843.  * 
  844.  *  IID_IHXUDPSocket:
  845.  * 
  846.  * {00000108-0901-11d1-8B06-00A024406D59}
  847.  * 
  848.  */
  849. DEFINE_GUID(IID_IHXUDPSocket, 0x00000108, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 
  850. 0xa0, 0x24, 0x40, 0x6d, 0x59);
  852. #undef  INTERFACE
  853. #define INTERFACE   IHXUDPSocket
  855. DECLARE_INTERFACE_(IHXUDPSocket, IUnknown)
  856. {
  857.     /*
  858.      *  IUnknown methods
  859.      */
  860.     STDMETHOD(QueryInterface) (THIS_
  861. REFIID riid,
  862. void** ppvObj) PURE;
  864.     STDMETHOD_(ULONG32,AddRef) (THIS) PURE;
  866.     STDMETHOD_(ULONG32,Release) (THIS) PURE;
  868.     /*
  869.      * IHXUDPSocket methods
  870.      *
  871.      *  Network addresses and ports are in native byte order
  872.      */
  874.     STDMETHOD(Init) (THIS_
  875. ULONG32 ulAddr,
  876. UINT16 nPort,
  877. IHXUDPResponse* pUDPResponse) PURE;
  879.     STDMETHOD(Bind) (THIS_
  880. UINT32     ulLocalAddr,
  881. UINT16      nPort) PURE;
  883.     STDMETHOD(Read) (THIS_
  884. UINT16 Size) PURE;
  886.     STDMETHOD(Write) (THIS_
  887. IHXBuffer* pBuffer) PURE;
  889.     STDMETHOD(WriteTo) (THIS_
  890.      ULONG32 ulAddr,
  891. UINT16 nPort,
  892. IHXBuffer* pBuffer) PURE;
  894.     STDMETHOD(GetLocalPort) (THIS_
  895.      REF(UINT16) port) PURE;
  897.     STDMETHOD(JoinMulticastGroup) (THIS_
  898.      ULONG32     ulMulticastAddr,
  899.      ULONG32     ulInterfaceAddr) PURE;
  900.     
  901.     STDMETHOD(LeaveMulticastGroup) (THIS_
  902.      ULONG32     ulMulticastAddr,
  903.      ULONG32     ulInterfaceAddr) PURE;
  904. };
  907. /****************************************************************************
  908.  * 
  909.  *  Interface:
  910.  * 
  911.  * IHXResolver
  912.  * 
  913.  *  Purpose:
  914.  * 
  915.  * This interface allows you to asynchronously resolve hostnames.
  916.  * 
  917.  *  IID_IHXResolver:
  918.  * 
  919.  * {00000109-0901-11d1-8B06-00A024406D59}
  920.  * 
  921.  */
  922. DEFINE_GUID(IID_IHXResolver, 0x00000109, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 
  923. 0xa0, 0x24, 0x40, 0x6d, 0x59);
  925. #undef  INTERFACE
  926. #define INTERFACE   IHXResolver
  928. DECLARE_INTERFACE_(IHXResolver, IUnknown)
  929. {
  930.     /*
  931.      *  IUnknown methods
  932.      */
  933.     STDMETHOD(QueryInterface) (THIS_
  934. REFIID riid,
  935. void** ppvObj) PURE;
  937.     STDMETHOD_(ULONG32,AddRef) (THIS) PURE;
  939.     STDMETHOD_(ULONG32,Release) (THIS) PURE;
  941.     /*
  942.      * IHXResolver methods
  943.      */
  945.     STDMETHOD(Init) (THIS_
  946. IHXResolverResponse*  pResponse) PURE;
  948.     STDMETHOD(GetHostByName) (THIS_
  949. const char* pHostName) PURE;
  950. };
  953. /****************************************************************************
  954.  * 
  955.  *  Interface:
  956.  * 
  957.  * IHXResolverResponse
  958.  * 
  959.  *  Purpose:
  960.  * 
  961.  * This is the response interface for the asynchronous DNS hostname
  962.  * resolver.
  963.  * 
  964.  *  IID_IHXResolverResponse:
  965.  * 
  966.  * {0000010A-0901-11d1-8B06-00A024406D59}
  967.  * 
  968.  */
  969. DEFINE_GUID(IID_IHXResolverResponse, 0x0000010A, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 
  970. 0xa0, 0x24, 0x40, 0x6d, 0x59);
  972. #undef  INTERFACE
  973. #define INTERFACE   IHXResolverResponse
  975. DECLARE_INTERFACE_(IHXResolverResponse, IUnknown)
  976. {
  977.     /*
  978.      *  IUnknown methods
  979.      */
  980.     STDMETHOD(QueryInterface) (THIS_
  981. REFIID riid,
  982. void** ppvObj) PURE;
  984.     STDMETHOD_(ULONG32,AddRef) (THIS) PURE;
  986.     STDMETHOD_(ULONG32,Release) (THIS) PURE;
  988.     /*
  989.      * IHXResolverResponse methods
  990.      */
  992.     STDMETHOD(GetHostByNameDone) (THIS_
  993. HX_RESULT status,
  994. ULONG32 ulAddr) PURE;
  995. };
  998. /****************************************************************************
  999.  * 
  1000.  *  Interface:
  1001.  * 
  1002.  * IHXInterruptSafe
  1003.  * 
  1004.  *  Purpose:
  1005.  * 
  1006.  * This interface is used in Macintosh implementations of callback 
  1007.  * functions, renderers, etc... to determine if interrupt time execution  
  1008.  * is supported. If this interface is not implemented then it is assumed
  1009.  * that interrupt time execution is NOT supported. There are restrictions 
  1010.  * on what may be executed at interrupt time; please consult the Macintosh
  1011.  * Deferred Task Manager tech notes from Apple.
  1012.  * 
  1013.  *  IID_IHXInterruptSafe:
  1014.  * 
  1015.  * {0000010B-0901-11d1-8B06-00A024406D59}
  1016.  * 
  1017.  */
  1018. DEFINE_GUID(IID_IHXInterruptSafe, 0x0000010B, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 
  1019. 0xa0, 0x24, 0x40, 0x6d, 0x59);
  1021. #undef  INTERFACE
  1022. #define INTERFACE   IHXInterruptSafe
  1024. DECLARE_INTERFACE_(IHXInterruptSafe, IUnknown)
  1025. {
  1026.     /*
  1027.      *  IUnknown methods
  1028.      */
  1029.     STDMETHOD(QueryInterface) (THIS_
  1030. REFIID riid,
  1031. void** ppvObj) PURE;
  1033.     STDMETHOD_(ULONG32,AddRef) (THIS) PURE;
  1035.     STDMETHOD_(ULONG32,Release) (THIS) PURE;
  1037.     /*
  1038.      *  IHXInterruptSafe methods
  1039.      */
  1041.     /************************************************************************
  1042.      * Method:
  1043.      *     IHXInterruptSafe::IsInterruptSafe
  1044.      * Purpose:
  1045.      *     This is the function that will be called to determine if
  1046.      *     interrupt time execution is supported.
  1047.      */
  1048.     STDMETHOD_(BOOL,IsInterruptSafe) (THIS) PURE;
  1049. };
  1052. /****************************************************************************
  1053.  * 
  1054.  *  Interface:
  1055.  * 
  1056.  * IHXAsyncIOSelection
  1057.  * 
  1058.  *  Purpose:
  1059.  * 
  1060.  *      This interface is implemented by the server/player context on Unix
  1061.  *      platforms.  This interface allows your plugin to get callbacks based
  1062.  *      I/O events that are normally handled by select().  This interface
  1063.  * allows you to setup callbacks which will be executed when a file
  1064.  * descriptor is ready for reading, writing, or has an exception.
  1065.  * 
  1066.  *  IID_IHXAsyncIOSelection:
  1067.  * 
  1068.  * {0000010C-0901-11d1-8B06-00A024406D59}
  1069.  * 
  1070.  */
  1071. DEFINE_GUID(IID_IHXAsyncIOSelection, 0x0000010C, 0x901, 0x11d1, 0x8b, 0x6, 0x0,
  1072. 0xa0, 0x24, 0x40, 0x6d, 0x59);
  1074. #undef  INTERFACE
  1075. #define INTERFACE   IHXAsyncIOSelection
  1077. DECLARE_INTERFACE_(IHXAsyncIOSelection, IUnknown)
  1078. {
  1079.     /*
  1080.      *  IUnknown methods
  1081.      */
  1082.     STDMETHOD(QueryInterface) (THIS_
  1083. REFIID riid,
  1084. void** ppvObj) PURE;
  1086.     STDMETHOD_(ULONG32,AddRef) (THIS) PURE;
  1088.     STDMETHOD_(ULONG32,Release) (THIS) PURE;
  1090.     /*
  1091.      * IHXAsyncIOSelection methods
  1092.      */
  1094.     /************************************************************************
  1095.      * Method:
  1096.      *     IHXAsyncIOSelection::Add
  1097.      * Purpose:
  1098.      *     This function will allow you to receive a callback when the
  1099.      *     given descriptor is ready for read, write, or has an
  1100.      *     exception.  This function is only available on Unix, and is
  1101.      *     intended to replace the functionality of select().
  1102.      */
  1103.     STDMETHOD(Add) (THIS_
  1104. IHXCallback* pCallback,
  1105. INT32 lFileDescriptor,
  1106. UINT32 ulType) PURE;
  1108.     /************************************************************************
  1109.      * Method:
  1110.      *     IHXAsyncIOSelection::Remove
  1111.      * Purpose:
  1112.      *     This function will allow you remove the callback associated
  1113.      *     with the given descriptor from the event handler.
  1114.      *     This function is only available on Unix, and is intended to
  1115.      *     replace the functionality of select().
  1116.      */
  1117.     STDMETHOD(Remove)                   (THIS_
  1118.                                         INT32           lFileDescriptor,
  1119. UINT32 ulType) PURE;
  1120. };
  1123. /****************************************************************************
  1124.  * 
  1125.  *  Interface:
  1126.  * 
  1127.  * IHXUDPMulticastInit
  1128.  * 
  1129.  *  Purpose:
  1130.  * 
  1131.  * Provides the user with a way to set the TTL for outgoing multicast
  1132.  * UDP packets.  Usually shared with IHXUDPSocket.
  1133.  * 
  1134.  *  IID_IHXUDPMulticastInit:
  1135.  * 
  1136.  * {0000010D-0901-11d1-8B06-00A024406D59}
  1137.  * 
  1138.  */
  1139. DEFINE_GUID(IID_IHXUDPMulticastInit, 0x0000010D, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 
  1140. 0xa0, 0x24, 0x40, 0x6d, 0x59);
  1142. #undef  INTERFACE
  1143. #define INTERFACE   IHXUDPMulticastInit
  1145. DECLARE_INTERFACE_(IHXUDPMulticastInit, IUnknown)
  1146. {
  1147.     /*
  1148.      *  IUnknown methods
  1149.      */
  1150.     STDMETHOD(QueryInterface) (THIS_
  1151. REFIID riid,
  1152. void** ppvObj) PURE;
  1154.     STDMETHOD_(ULONG32,AddRef) (THIS) PURE;
  1156.     STDMETHOD_(ULONG32,Release) (THIS) PURE;
  1158.     /*
  1159.      * IHXUDPMulticastInit methods
  1160.      *
  1161.      */
  1163.      /************************************************************************
  1164.      * Method:
  1165.      *     IHXUDPMulticastInit::InitMulticast
  1166.      * Purpose:
  1167.      *     This function will set the TTL (time to live) for the UDP socket
  1168.      *      so it can be used as a multicast socket, sending packets across
  1169.      *      the number of routers specified in the ulTTL parameter.  
  1170.      */
  1172.     STDMETHOD(InitMulticast) (THIS_
  1173.      UINT8     chTTL) PURE;
  1174. };
  1176. /****************************************************************************
  1177.  * 
  1178.  *  Interface:
  1179.  * 
  1180.  * IHXInterruptState
  1181.  * 
  1182.  *  Purpose:
  1183.  * 
  1184.  * This interface is used in Macintosh implementations to inform the
  1185.  * the client engine when entering & leaving an interupt task. It is
  1186.  * also used to determine if it is currently at interrupt time.
  1187.  * Please consult the Macintosh Deferred Task Manager tech notes from Apple
  1188.  * for information on interrupt tasks.
  1189.  * 
  1190.  *  IID_IHXInterruptState:
  1191.  * 
  1192.  * {0000010E-0901-11d1-8B06-00A024406D59}
  1193.  * 
  1194.  */
  1195. DEFINE_GUID(IID_IHXInterruptState, 0x0000010E, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 
  1196. 0xa0, 0x24, 0x40, 0x6d, 0x59);
  1198. #undef  INTERFACE
  1199. #define INTERFACE   IHXInterruptState
  1201. DECLARE_INTERFACE_(IHXInterruptState, IUnknown)
  1202. {
  1203.     /*
  1204.      *  IUnknown methods
  1205.      */
  1206.     STDMETHOD(QueryInterface) (THIS_
  1207. REFIID riid,
  1208. void** ppvObj) PURE;
  1210.     STDMETHOD_(ULONG32,AddRef) (THIS) PURE;
  1212.     STDMETHOD_(ULONG32,Release) (THIS) PURE;
  1214.     /*
  1215.      *  IHXInterruptState methods
  1216.      */
  1218.     /************************************************************************
  1219.      * Method:
  1220.      *     IHXInterruptState::AtInterruptTime
  1221.      * Purpose:
  1222.      *     This function is called to determine if we are currently at
  1223.      *     interrupt task time.
  1224.      */
  1225.         STDMETHOD_(BOOL,AtInterruptTime) (THIS) PURE;
  1227.     /************************************************************************
  1228.      * Method:
  1229.      *     IHXInterruptState::EnterInterruptState
  1230.      * Purpose:
  1231.      *     This function is called when starting a deferred/interrupt task
  1232.      */
  1233.     STDMETHOD(EnterInterruptState) (THIS) PURE;
  1235.     /************************************************************************
  1236.      * Method:
  1237.      *     IHXInterruptState::LeaveInterruptState
  1238.      * Purpose:
  1239.      *     This function is called when leaving a deferred/interrupt task
  1240.      */
  1241.     STDMETHOD(LeaveInterruptState) (THIS) PURE;
  1243.     /************************************************************************
  1244.      * Method:
  1245.      *     IHXInterruptState::EnableInterrupt
  1246.      * Purpose:
  1247.      *     This function can be called to enable/disable interrupt time 
  1248.      *     processsing
  1249.      */
  1250.     STDMETHOD(EnableInterrupt) (THIS_
  1251. BOOL bEnable) PURE;
  1252.     
  1253.     /************************************************************************
  1254.      * Method:
  1255.      *     IHXInterruptState::IsInterruptEnabled
  1256.      * Purpose:
  1257.      *     This function can be called to find if the core is currently
  1258.      *     interrupt enabled.
  1259.      */
  1260.     STDMETHOD_(BOOL, IsInterruptEnabled)   (THIS) PURE;
  1261. };
  1264. /****************************************************************************
  1265.  * 
  1266.  *  Interface:
  1267.  * 
  1268.  * IHXOptimizedScheduler
  1269.  * 
  1270.  *  Purpose:
  1271.  * 
  1272.  * This interface provides the user with a way of scheduling callbacks
  1273.  * that will be executed at some time in the future.
  1274.  *
  1275.  * This interface should ONLY be used if you need accurately timed 
  1276.  * callbacks. These callbacks should be efficient and should not consume 
  1277.  * much time/CPU. This is not a thread safe interface. The user has to 
  1278.  * take care of synchronization in their callbacks.
  1279.  * 
  1280.  *  IID_IHXOptimizedScheduler:
  1281.  * 
  1282.  * {0000010F-0901-11d1-8B06-00A024406D59}
  1283.  * 
  1284.  */
  1285. DEFINE_GUID(IID_IHXOptimizedScheduler, 0x0000010F, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 
  1286. 0xa0, 0x24, 0x40, 0x6d, 0x59);
  1288. #undef  INTERFACE
  1289. #define INTERFACE   IHXOptimizedScheduler
  1291. DECLARE_INTERFACE_(IHXOptimizedScheduler, IUnknown)
  1292. {
  1293.     /*
  1294.      *  IUnknown methods
  1295.      */
  1296.     STDMETHOD(QueryInterface) (THIS_
  1297. REFIID riid,
  1298. void** ppvObj) PURE;
  1300.     STDMETHOD_(ULONG32,AddRef) (THIS) PURE;
  1302.     STDMETHOD_(ULONG32,Release) (THIS) PURE;
  1304.     /*
  1305.      * IHXOptimizedScheduler methods
  1306.      */
  1308.     /************************************************************************
  1309.      * Method:
  1310.      *     IHXOptimizedScheduler::RelativeEnter
  1311.      * Purpose:
  1312.      *     Schedule a callback to be executed "ms" milliseconds from now
  1313.      *     This function is less percise then AbsoluteEnter and should only
  1314.      *     be used when accurate timing is not critical.
  1315.      */
  1316.     STDMETHOD_(CallbackHandle,RelativeEnter) (THIS_
  1317. IHXCallback* pCallback,
  1318. UINT32 ms) PURE;
  1320.     /************************************************************************
  1321.      * Method:
  1322.      *     IHXOptimizedScheduler::AbsoluteEnter
  1323.      * Purpose:
  1324.      *     Schedule a callback to be executed at time "tVal".
  1325.      */
  1326.     STDMETHOD_(CallbackHandle,AbsoluteEnter) (THIS_
  1327. IHXCallback* pCallback,
  1328. HXTimeval tVal) PURE;
  1330.     /************************************************************************
  1331.      * Method:
  1332.      *     IHXOptimizedScheduler::Remove
  1333.      * Purpose:
  1334.      *     Remove a callback from the scheduler.
  1335.      */
  1336.     STDMETHOD(Remove) (THIS_
  1337.      CallbackHandle Handle) PURE;
  1339.     /************************************************************************
  1340.      * Method:
  1341.      *     IHXOptimizedScheduler::GetCurrentSchedulerTime
  1342.      * Purpose:
  1343.      *     Gives the current time (in the timeline of the scheduler).
  1344.      */
  1345.     STDMETHOD_(HXTimeval,GetCurrentSchedulerTime) (THIS) PURE;
  1346. };
  1348. /****************************************************************************
  1349.  *
  1350.  *  Interface:
  1351.  *
  1352.  *     IHXThreadSafeScheduler
  1353.  *
  1354.  *  Purpose:
  1355.  *
  1356.  *     This interface provides the user with a way of scheduling callbacks
  1357.  *     that will be executed at some time in the future.  This is identical
  1358.  *      to IHXScheduler except the scheduler events are considered thread-safe.
  1359.  *
  1360.  *  IID_IHXThreadSafeScheduler:
  1361.  *
  1362.  *     {00000120-0901-11d1-8B06-00A024406D59}
  1363.  *
  1364.  */
  1365. DEFINE_GUID(IID_IHXThreadSafeScheduler, 0x00000120, 0x901, 0x11d1, 0x8b, 0x6, 0x0,
  1366.                        0xa0, 0x24, 0x40, 0x6d, 0x59);
  1368. #undef  INTERFACE
  1369. #define INTERFACE   IHXThreadSafeScheduler
  1371. DECLARE_INTERFACE_(IHXThreadSafeScheduler, IUnknown)
  1372. {
  1373.     /*
  1374.      *  IUnknown methods
  1375.      */
  1376.     STDMETHOD(QueryInterface)          (THIS_
  1377.                                        REFIID riid,
  1378.                                        void** ppvObj) PURE;
  1380.     STDMETHOD_(ULONG32,AddRef)         (THIS) PURE;
  1382.     STDMETHOD_(ULONG32,Release)                (THIS) PURE;
  1384.     /*
  1385.      * IHXThreadSafeScheduler methods
  1386.      */
  1388.     /************************************************************************
  1389.      * Method:
  1390.      *     IHXThreadSafeScheduler::RelativeEnter
  1391.      * Purpose:
  1393.      *     Schedule a callback to be executed "ms" milliseconds from now
  1394.      *     This function is less percise then AbsoluteEnter and should only
  1395.      *     be used when accurate timing is not critical.
  1396.      */
  1397.     STDMETHOD_(CallbackHandle,RelativeEnter)   (THIS_
  1398.                                                IHXCallback* pCallback,
  1399.                                                UINT32 ms) PURE;
  1401.     /************************************************************************
  1402.      * Method:
  1403.      *     IHXThreadSafeScheduler::AbsoluteEnter
  1404.      * Purpose:
  1405.      *     Schedule a callback to be executed at time "tVal".
  1406.      */
  1407.     STDMETHOD_(CallbackHandle,AbsoluteEnter)   (THIS_
  1408.                                                IHXCallback* pCallback,
  1409.                                                HXTimeval tVal) PURE;
  1411.     /************************************************************************
  1412.      * Method:
  1413.      *     IHXThreadSafeScheduler::Remove
  1414.      * Purpose:
  1415.      *     Remove a callback from the scheduler.
  1416.      */
  1417.     STDMETHOD(Remove)          (THIS_
  1418.                                CallbackHandle Handle) PURE;
  1419. };
  1421. /****************************************************************************
  1422.  *
  1423.  *  Interface:
  1424.  *
  1425.  *     IHXProcessEntryPoint
  1426.  *
  1427.  *  Purpose:
  1428.  *
  1429.  *     This interface is the entry point for an IHXProcess
  1430.  *
  1431.  *  IID_IHXProcessEntryPoint
  1432.  *
  1433.  *     {00000123-0901-11d1-8B06-00A024406D59}
  1434.  *
  1435.  */
  1436. DEFINE_GUID(IID_IHXProcessEntryPoint, 0x00000123, 0x901, 0x11d1, 0x8b, 0x6,
  1437.             0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59);
  1439. #undef  INTERFACE
  1440. #define INTERFACE   IHXProcessEntryPoint
  1442. DECLARE_INTERFACE_(IHXProcessEntryPoint, IUnknown)
  1443. {
  1444.     /*
  1445.      *  IUnknown methods
  1446.      */
  1447.     STDMETHOD(QueryInterface)          (THIS_
  1448.                                        REFIID riid,
  1449.                                        void** ppvObj) PURE;
  1451.     STDMETHOD_(ULONG32,AddRef)         (THIS) PURE;
  1453.     STDMETHOD_(ULONG32,Release)        (THIS) PURE;
  1455.     STDMETHOD(Func)                   (THIS_
  1456.                                        IUnknown* pContext) PURE;
  1457. };
  1459. /****************************************************************************
  1460.  *
  1461.  *  Interface:
  1462.  *
  1463.  *     IHXProcess
  1464.  *
  1465.  *  Purpose:
  1466.  *
  1467.  *     This interface allows you to create new server processes and specify
  1468.  *  an entry point.  It is queried off the context.
  1469.  *
  1470.  *  IID_IHXProcess
  1471.  *
  1472.  *     {00000122-0901-11d1-8B06-00A024406D59}
  1473.  *
  1474.  */
  1475. DEFINE_GUID(IID_IHXProcess, 0x00000122, 0x901, 0x11d1, 0x8b, 0x6, 0x0,
  1476.                        0xa0, 0x24, 0x40, 0x6d, 0x59);
  1478. #undef  INTERFACE
  1479. #define INTERFACE   IHXProcess
  1481. DECLARE_INTERFACE_(IHXProcess, IUnknown)
  1482. {
  1483.     /*
  1484.      *  IUnknown methods
  1485.      */
  1486.     STDMETHOD(QueryInterface)          (THIS_
  1487.                                        REFIID riid,
  1488.                                        void** ppvObj) PURE;
  1490.     STDMETHOD_(ULONG32,AddRef)         (THIS) PURE;
  1492.     STDMETHOD_(ULONG32,Release)        (THIS) PURE;
  1494.     STDMETHOD(Start)                   (THIS_
  1495.                                        const char* pProcessName,
  1496.                                        IHXProcessEntryPoint* pEntryPoint) PURE;
  1497. };
  1499. /****************************************************************************
  1500.  * 
  1501.  *  Interface:
  1502.  * 
  1503.  * IHXLoadBalancedListen
  1504.  * 
  1505.  *  Purpose:
  1506.  * 
  1507.  * This interface is queried off of IHXListenSocket.  It allows
  1508.  * a plugin to specify that it wants the server to load balance
  1509.  * multiple instances of itself.  The server will instantiate multiple
  1510.  * instances of the plugin as needed based on socket / descriptor limits.
  1511.  * Each plugin instance should attempt to listen on the same port as
  1512.  * other instances (they will share the port).
  1513.  * 
  1514.  *  IID_IHXLoadBalancedListen:
  1515.  * 
  1516.  * {00000110-0901-11d1-8B06-00A024406D59}
  1517.  * 
  1518.  */
  1519. DEFINE_GUID(IID_IHXLoadBalancedListen, 0x00000110, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 
  1520. 0xa0, 0x24, 0x40, 0x6d, 0x59);
  1522. #undef  INTERFACE
  1523. #define INTERFACE   IHXLoadBalancedListen
  1525. DECLARE_INTERFACE_(IHXLoadBalancedListen, IUnknown)
  1526. {
  1527.     /*
  1528.      *  IUnknown methods
  1529.      */
  1530.     STDMETHOD(QueryInterface) (THIS_
  1531. REFIID riid,
  1532. void** ppvObj) PURE;
  1534.     STDMETHOD_(ULONG32,AddRef) (THIS) PURE;
  1536.     STDMETHOD_(ULONG32,Release) (THIS) PURE;
  1538.     /*
  1539.      * IHXLoadBalancedListen methods
  1540.      */
  1542.     /************************************************************************
  1543.      * Method:
  1544.      *     IHXLoadBalancedListen::SetID
  1545.      * Purpose:
  1546.      *     This function set's the unique ID for this listen socket.  This
  1547.      *     ID is used to determine whether or not different instances of
  1548.      *     a plugin trying to listen on a single port are actually the
  1549.      *     same plugin.  Without this function, it would be possible for
  1550.      *     two completely different plugins to listen on the same port using
  1551.      *     the load balanced listener.
  1552.      */
  1553.     STDMETHOD(SetID) (THIS_
  1554.      REFIID ID) PURE;
  1556.     /************************************************************************
  1557.      * Method:
  1558.      *     IHXLoadBalancedListen::SetReserveLimit
  1559.      * Purpose:
  1560.      *     Sets the reserve limit for descriptors / sockets.  If less
  1561.      *     than reserve limit descriptors / sockets are left then a new
  1562.      *     instance of the plugin will be created.
  1563.      */
  1564.     STDMETHOD(SetReserveLimit) (THIS_
  1565.      UINT32 ulDescriptors,
  1566. UINT32 ulSockets) PURE;
  1567. };
  1570. /****************************************************************************
  1571.  * 
  1572.  *  Interface:
  1573.  * 
  1574.  * IHXOverrideDefaultServices
  1575.  * 
  1576.  *  Purpose:
  1577.  * 
  1578.  * This interface is queried off of the context.  It allows
  1579.  * a plugin to override any default services provided by the G2 system.
  1580.  * Currently, it is supported only on the client side. 
  1581.  * You may currently override IHXNetworkServices using this interface
  1582.  * You can use the same interface to later restore back the overriden services.
  1583.  * This is done by calling the same OverrideServices() function with the 
  1584.  * original service QIed before the initial override.
  1585.  * 
  1586.  *  IID_IHXOverrideDefaultServices:
  1587.  * 
  1588.  * {00000111-0901-11d1-8B06-00A024406D59}
  1589.  * 
  1590.  */
  1591. DEFINE_GUID(IID_IHXOverrideDefaultServices, 0x00000111, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 
  1592. 0xa0, 0x24, 0x40, 0x6d, 0x59);
  1594. #undef  INTERFACE
  1595. #define INTERFACE   IHXOverrideDefaultServices
  1597. DECLARE_INTERFACE_(IHXOverrideDefaultServices, IUnknown)
  1598. {
  1599.     /*
  1600.      * IUnknown methods
  1601.      */
  1602.     STDMETHOD(QueryInterface)   (THIS_
  1603.                                 REFIID riid,
  1604. void** ppvObj) PURE;
  1606.     STDMETHOD_(ULONG32,AddRef)  (THIS) PURE;
  1608.     STDMETHOD_(ULONG32,Release) (THIS) PURE;
  1610.    /*
  1611.     * IHXOverrideDefaultServices methods
  1612.     */
  1614.    /************************************************************************
  1615.     *  Method:
  1616.     *      IHXOverrideDefaultServices::OverrideServices
  1617.     *  Purpose:
  1618.     *      Override default services provided by the G2 system.
  1619.     *
  1620.     */
  1621.     STDMETHOD(OverrideServices)         (THIS_
  1622. IUnknown* pContext) PURE;
  1623. };
  1625. typedef enum _HX_SOCKET_OPTION
  1626. {
  1627.     HX_SOCKOPT_REUSE_ADDR,
  1628.     HX_SOCKOPT_REUSE_PORT,
  1629.     HX_SOCKOPT_BROADCAST,
  1630.     HX_SOCKOPT_SET_RECVBUF_SIZE,
  1631.     HX_SOCKOPT_SET_SENDBUF_SIZE,
  1632.     HX_SOCKOPT_MULTICAST_IF,
  1633.     HX_SOCKOPT_IP_TOS
  1634. } HX_SOCKET_OPTION;
  1636. /****************************************************************************
  1637.  * 
  1638.  *  Interface:
  1639.  * 
  1640.  * IHXSetSocketOption
  1641.  * 
  1642.  *  Purpose:
  1643.  * 
  1644.  * Set sockt option
  1645.  * 
  1646.  *  IID_IHXSetSocketOption:
  1647.  * 
  1648.  * IID_IHXSetSocketOption:    {00000114-0901-11d1-8B06-00A024406D59}
  1649.  * 
  1650.  */
  1651. DEFINE_GUID(IID_IHXSetSocketOption,
  1652.     0x00000114, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59);
  1654. #undef  INTERFACE
  1655. #define INTERFACE   IHXSetSocketOption
  1656. DECLARE_INTERFACE_(IHXSetSocketOption, IUnknown)
  1657. {
  1658.     /*
  1659.      *  IUnknown methods
  1660.      */
  1661.     STDMETHOD(QueryInterface) (THIS_
  1662. REFIID riid,
  1663. void** ppvObj) PURE;
  1665.     STDMETHOD_(ULONG32,AddRef) (THIS) PURE;
  1667.     STDMETHOD_(ULONG32,Release) (THIS) PURE;
  1669.     /*
  1670.      * IHXListenSocket methods
  1671.      */
  1673.     STDMETHOD(SetOption) (THIS_ 
  1674.  HX_SOCKET_OPTION option,
  1675.  UINT32 ulValue) PURE;  
  1676. };
  1678. #define HX_THREADSAFE_METHOD_FF_GETPACKET 0x00000001
  1679. /*
  1680.  * FileFormat::GetPacket() only calls:
  1681.  *     CCF->CI(Buffer), CCF->CI(Packet), CCF->CI(Values), *Alloc, *Free, 
  1682.  *     FS->Read(), FS->Close(), FS->Seek(),
  1683.  *     FFR->PacketReady(), FFR->StreamDone()
  1684.  *     Context->Scheduler->*,
  1685.  *     CCF->CI(Mutex), Mutex->*
  1686.  *     Context->ErrorMessages
  1687.  *
  1688.  * XXXSMPNOW
  1689.  */
  1691. #define HX_THREADSAFE_METHOD_FS_READ 0x00000002
  1692. /*
  1693.  * FileSystem::Read()/Seek()/Close() only calls:
  1694.  *     CCF->CI(Buffer), CCF->CI(Packet), CCF->CI(Values), *Alloc, *Free, 
  1695.  *     FS->Read(), FS->Close(), FS->Seek(),
  1696.  *     Context->Scheduler->*,
  1697.  *     CCF->CI(Mutex), Mutex->*
  1698.  *     Context->ErrorMessages
  1699.  *
  1700.  * XXXSMPNOW
  1701.  */
  1702. #define HX_THREADSAFE_METHOD_FSR_READDONE 0x00000004
  1703. /*
  1704.  * FileFormat::ReadDone()/SeekDone()/CloseDone() only calls:
  1705.  *     CCF->CI(Buffer), CCF->CI(Packet), CCF->CI(Values), *Alloc, *Free, 
  1706.  *     FS->Read(), FS->Close(), FS->Seek(),
  1707.  *     FFR->PacketReady(), FFR->StreamDone()
  1708.  *     Context->Scheduler->*,
  1709.  *     CCF->CI(Mutex), Mutex->*
  1710.  *     Context->ErrorMessages
  1711.  *
  1712.  * XXXSMPNOW
  1713.  */
  1714. #define HX_THREADSAFE_METHOD_CACHE_FILE 0x00000008
  1715. /*
  1716.  * FileSystem::Read()/Seek()/Close() only calls:
  1717.  *     CCF->CI(Buffer), CCF->CI(Packet), CCF->CI(Values), *Alloc, *Free, 
  1718.  *     FS->Read(), FS->Close(), FS->Seek(),
  1719.  *     IHXCacheFile->*, IHXCacheFileResponse->*,
  1720.  *     Context->Scheduler->*,
  1721.  *     CCF->CI(Mutex), Mutex->*
  1722.  *     Context->ErrorMessages
  1723.  *
  1724.  * XXXSMPNOW
  1725.  */
  1726. #define HX_THREADSAFE_METHOD_CACHE_FILE_RESPONSE 0x00000010
  1727. /*
  1728.  * FileSystem::Read()/Seek()/Close() only calls:
  1729.  *     CCF->CI(Buffer), CCF->CI(Packet), CCF->CI(Values), *Alloc, *Free, 
  1730.  *     FS->Read(), FS->Close(), FS->Seek(),
  1731.  *     IHXCacheFile->*, IHXCacheFileResponse->*,
  1732.  *     Context->Scheduler->*,
  1733.  *     CCF->CI(Mutex), Mutex->*
  1734.  *     Context->ErrorMessages
  1735.  *
  1736.  * XXXSMPNOW
  1737.  */
  1739. /*
  1740.  * Thread Safe flags for IHXDataConvert
  1741.  */
  1742. #define HX_THREADSAFE_METHOD_CONVERT_HEADERS 0x00000020
  1743. /*
  1744.  * IHXDataConvert::ConvertXXX()/CtrlBufferReady() only calls:
  1745.  *     CCF->CI(Buffer), CCF->CI(Packet), CCF->CI(Values), *Alloc, *Free, 
  1746.  *     IHXDataConvertResponse->*
  1747.  *     Context->Scheduler->*,
  1748.  *     CCF->CI(Mutex), Mutex->*
  1749.  *     Context->ErrorMessages
  1750.  *
  1751.  * XXXSMPNOW
  1752.  */
  1753. #define HX_THREADSAFE_METHOD_CONVERT_DATA 0x00000040
  1754. /*
  1755.  * IHXDataConvert::ConvertXXX()/CtrlBufferReady() only calls:
  1756.  *     CCF->CI(Buffer), CCF->CI(Packet), CCF->CI(Values), *Alloc, *Free, 
  1757.  *     IHXDataConvertResponse->*
  1758.  *     Context->Scheduler->*,
  1759.  *     CCF->CI(Mutex), Mutex->*
  1760.  *     Context->ErrorMessages
  1761.  *
  1762.  * XXXSMPNOW
  1763.  */
  1764. #define HX_THREADSAFE_METHOD_CONVERT_CTRL_BUFFER_READY 0x00000080
  1765. /*
  1766.  * IHXDataConvert::ConvertXXX()/CtrlBufferReady() only calls:
  1767.  *     CCF->CI(Buffer), CCF->CI(Packet), CCF->CI(Values), *Alloc, *Free, 
  1768.  *     IHXDataConvertResponse->*
  1769.  *     Context->Scheduler->*,
  1770.  *     CCF->CI(Mutex), Mutex->*
  1771.  *     Context->ErrorMessages
  1772.  *
  1773.  * XXXSMPNOW
  1774.  */
  1775. #define HX_THREADSAFE_METHOD_SOCKET_READDONE  0x00000100
  1777. #define HX_THREADSAFE_METHOD_ALL  (~0)
  1779. /****************************************************************************
  1780.  * 
  1781.  *  Interface:
  1782.  * 
  1783.  * IHXThreadSafeMethods
  1784.  * 
  1785.  *  Purpose:
  1786.  * 
  1787.  * XXXSMPNOW
  1788.  * 
  1789.  *  IID_IHXThreadSafeMethods:
  1790.  * 
  1791.  * {00000115-0901-11d1-8B06-00A024406D59}
  1792.  * 
  1793.  */
  1794. DEFINE_GUID(IID_IHXThreadSafeMethods, 0x00000115, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 
  1795. 0xa0, 0x24, 0x40, 0x6d, 0x59);
  1797. #undef  INTERFACE
  1798. #define INTERFACE   IHXThreadSafeMethods
  1800. DECLARE_INTERFACE_(IHXThreadSafeMethods, IUnknown)
  1801. {
  1802.     /*
  1803.      * IUnknown methods
  1804.      */
  1805.     STDMETHOD(QueryInterface) (THIS_
  1806. REFIID riid,
  1807. void** ppvObj) PURE;
  1809.     STDMETHOD_(ULONG32,AddRef) (THIS) PURE;
  1811.     STDMETHOD_(ULONG32,Release) (THIS) PURE;
  1813.     /*
  1814.      * IHXThreadSafeMethods methods
  1815.      */
  1817.     /************************************************************************
  1818.      * Method:
  1819.      *     IHXThreadSafeMethods::IsThreadSafe
  1820.      * Purpose:
  1821.      *     XXXSMPNOW
  1822.      */
  1823.     STDMETHOD_(UINT32,IsThreadSafe)     (THIS) PURE;
  1824. };
  1827. /****************************************************************************
  1828.  * 
  1829.  *  Interface:
  1830.  * 
  1831.  * IHXMutex
  1832.  * 
  1833.  *  Purpose:
  1834.  * 
  1835.  * XXXSMPNOW
  1836.  * 
  1837.  *  IID_IHXMutex:
  1838.  * 
  1839.  * {00000116-0901-11d1-8B06-00A024406D59}
  1840.  * 
  1841.  */
  1842. DEFINE_GUID(IID_IHXMutex, 0x00000116, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 
  1843. 0xa0, 0x24, 0x40, 0x6d, 0x59);
  1845. #undef  INTERFACE
  1846. #define INTERFACE   IHXMutex
  1848. /*
  1849.  *  The IHXCommonClassFactory supports creating an instance
  1850.  *  of this object.
  1851.  */
  1852. #define CLSID_IHXMutex IID_IHXMutex
  1854. DECLARE_INTERFACE_(IHXMutex, IUnknown)
  1855. {
  1856.     /*
  1857.      * IUnknown methods
  1858.      */
  1859.     STDMETHOD(QueryInterface) (THIS_
  1860. REFIID riid,
  1861. void** ppvObj) PURE;
  1863.     STDMETHOD_(ULONG32,AddRef) (THIS) PURE;
  1865.     STDMETHOD_(ULONG32,Release) (THIS) PURE;
  1867.     /*
  1868.      * IHXMutex methods
  1869.      */
  1871.      /* XXXSMPNOW Comments */
  1872.     STDMETHOD(Lock)     (THIS) PURE;
  1874.     STDMETHOD(TryLock)     (THIS) PURE;
  1876.     STDMETHOD(Unlock)     (THIS) PURE;
  1877. };
  1879. // $Private:
  1880. /****************************************************************************
  1881.  * 
  1882.  *  Interface:
  1883.  * 
  1884.  * IHXFastPathNetWrite
  1885.  * 
  1886.  *  Purpose:
  1887.  * 
  1888.  * Private interface for high speed UDP output.
  1889.  * 
  1890.  *  IID_IHXFastPathNetWrite:
  1891.  * 
  1892.  * {00000117-0901-11d1-8B06-00A024406D59}
  1893.  * 
  1894.  */
  1895. DEFINE_GUID(IID_IHXFastPathNetWrite, 0x00000117, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 
  1896. 0xa0, 0x24, 0x40, 0x6d, 0x59);
  1898. #undef  INTERFACE
  1899. #define INTERFACE   IHXFastPathNetWrite
  1901. DECLARE_INTERFACE_(IHXFastPathNetWrite, IUnknown)
  1902. {
  1903.     /*
  1904.      *  IUnknown methods
  1905.      */
  1906.     STDMETHOD(QueryInterface) (THIS_
  1907. REFIID riid,
  1908. void** ppvObj) PURE;
  1910.     STDMETHOD_(ULONG32,AddRef) (THIS) PURE;
  1912.     STDMETHOD_(ULONG32,Release) (THIS) PURE;
  1914.     /*
  1915.      * IHXFastPathNetWrite methods
  1916.      *
  1917.      */
  1919.     STDMETHOD(FastWrite) (THIS_
  1920. const UINT8* pBuffer, UINT32 ulLen) PURE;
  1921. };
  1923. /****************************************************************************
  1924.  * 
  1925.  *  Interface:
  1926.  * 
  1927.  * IHXWouldBlockResponse
  1928.  * 
  1929.  *  Purpose:
  1930.  * 
  1931.  * Get notifications of EWOULDBLOCK conditions.
  1932.  * 
  1933.  *  IID_IHXWouldBlockResponse:
  1934.  * 
  1935.  * {00000118-0901-11d1-8B06-00A024406D59}
  1936.  * 
  1937.  */
  1938. DEFINE_GUID(IID_IHXWouldBlockResponse, 0x00000118, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59);
  1940. #undef  INTERFACE
  1941. #define INTERFACE   IHXWouldBlockResponse
  1943. DECLARE_INTERFACE_(IHXWouldBlockResponse, IUnknown)
  1944. {
  1945.     /*
  1946.      *  IUnknown methods
  1947.      */
  1948.     STDMETHOD(QueryInterface) (THIS_
  1949. REFIID riid,
  1950. void** ppvObj) PURE;
  1952.     STDMETHOD_(ULONG32,AddRef) (THIS) PURE;
  1954.     STDMETHOD_(ULONG32,Release) (THIS) PURE;
  1956.     /*
  1957.      * IHXWouldBlockResponse methods
  1958.      *
  1959.      */
  1960.     
  1961.     
  1962.     /*
  1963.      * WouldBlock
  1964.      *
  1965.      * Return HXR_OK to go into blocked mode, causing a future
  1966.      * WouldBlockCleared call.  HXR_anythingelse to ignore.
  1967.      */
  1968.     
  1969.     STDMETHOD(WouldBlock) (THIS_ UINT32 id) PURE;
  1970.     STDMETHOD(WouldBlockCleared)(THIS_ UINT32 id) PURE;
  1972. };
  1974. /****************************************************************************
  1975.  * 
  1976.  *  Interface:
  1977.  * 
  1978.  * IHXWouldBlock
  1979.  * 
  1980.  *  Purpose:
  1981.  * 
  1982.  * Notifier for EWOULDBLOCK conditions.
  1983.  * 
  1984.  *  IID_IHXWouldBlock:
  1985.  * 
  1986.  * {00000119-0901-11d1-8B06-00A024406D59}
  1987.  * 
  1988.  */
  1989. DEFINE_GUID(IID_IHXWouldBlock, 0x00000119, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 
  1990. 0xa0, 0x24, 0x40, 0x6d, 0x59);
  1992. #undef  INTERFACE
  1993. #define INTERFACE   IHXWouldBlock
  1995. DECLARE_INTERFACE_(IHXWouldBlock, IUnknown)
  1996. {
  1997.     /*
  1998.      *  IUnknown methods
  1999.      */
  2000.     STDMETHOD(QueryInterface) (THIS_
  2001. REFIID riid,
  2002. void** ppvObj) PURE;
  2004.     STDMETHOD_(ULONG32,AddRef) (THIS) PURE;
  2006.     STDMETHOD_(ULONG32,Release) (THIS) PURE;
  2008.     /*
  2009.      * IHXWouldBlock methods
  2010.      *
  2011.      */
  2012.     
  2013.     STDMETHOD(WantWouldBlock) (THIS_
  2014.      IHXWouldBlockResponse*, UINT32 id) PURE;
  2015. };
  2017. /****************************************************************************
  2018.  *
  2019.  *  Interface:
  2020.  *
  2021.  *     IHXSharedUDPServices
  2022.  *
  2023.  *  Purpose:
  2024.  *
  2025.  *     Private interface for tying a UDP socket (via IHXUDPSocketContext) to
  2026.  *  a shared UDP resend port.  Used to send UDP packet resend requests to one
  2027.  *  shared UDP port per streamer.
  2028.  *
  2029.  *  IID_IHXSharedUDPServices
  2030.  *
  2031.  *     {00000123-0901-11d1-8B06-00A024406D59}
  2032.  *
  2033.  */
  2034. DEFINE_GUID(IID_IHXSharedUDPServices, 0x00000124, 0x901, 0x11d1, 0x8b, 0x6, 0x0,
  2035.                        0xa0, 0x24, 0x40, 0x6d, 0x59);
  2037. #undef  INTERFACE
  2038. #define INTERFACE   IHXSharedUDPServices
  2040. DECLARE_INTERFACE_(IHXSharedUDPServices, IUnknown)
  2041. {
  2042.     /*
  2043.      *  IUnknown methods
  2044.      */
  2045.     STDMETHOD(QueryInterface)          (THIS_
  2046.                                        REFIID riid,
  2047.                                        void** ppvObj) PURE;
  2049.     STDMETHOD_(ULONG32,AddRef)         (THIS) PURE;
  2051.     STDMETHOD_(ULONG32,Release)        (THIS) PURE;
  2053.     /*
  2054.      * IHXSharedUDPServices methods
  2055.      */
  2056.     STDMETHOD(RegisterSharedResponse) (THIS_
  2057.  IHXUDPResponse* response,
  2058.  UINT16 sPortEnum) PURE;
  2060.     STDMETHOD(UnregisterSharedResponse) (THIS) PURE;
  2062.     STDMETHOD_(UINT16, GetSharedPort) (THIS) PURE;
  2064. };
  2066. /****************************************************************************
  2067.  *
  2068.  *  Interface:
  2069.  *
  2070.  *     IHXThreadLocal
  2071.  *
  2072.  *  Purpose:
  2073.  *
  2074.  *     Thread-local information, namely the procnum.
  2075.  *
  2076.  *  IID_IHXThreadLocal
  2077.  *
  2078.  *     {00000125-0901-11d1-8B06-00A024406D59}
  2079.  *
  2080.  */
  2081. DEFINE_GUID(IID_IHXThreadLocal, 0x00000125, 0x901, 0x11d1, 0x8b, 0x6, 0x0,
  2082.                        0xa0, 0x24, 0x40, 0x6d, 0x59);
  2084. #undef  INTERFACE
  2085. #define INTERFACE   IHXThreadLocal
  2087. #define CLSID_IHXThreadLocal IID_IHXThreadLocal
  2089. DECLARE_INTERFACE_(IHXThreadLocal, IUnknown)
  2090. {
  2091.     /*
  2092.      *  IUnknown methods
  2093.      */
  2094.     STDMETHOD(QueryInterface)          (THIS_
  2095.                                        REFIID riid,
  2096.                                        void** ppvObj) PURE;
  2098.     STDMETHOD_(ULONG32,AddRef)         (THIS) PURE;
  2100.     STDMETHOD_(ULONG32,Release)        (THIS) PURE;
  2102.     /*
  2103.      * IHXThreadLocal methods
  2104.      */
  2106.     /*
  2107.      *  IHXThreadLocal::GetMaxThreads()
  2108.      *
  2109.      *  Maximum number of threads on the system (MAX_THREADS on server)
  2110.      */
  2111.     STDMETHOD_(int, GetMaxThreads) (THIS) PURE;
  2113.     /*
  2114.      *  IHXThreadLocal::GetThreadNumber()
  2115.      *
  2116.      *  This thread's number (< MAX_THREADS)
  2117.      */
  2118.     STDMETHOD_(int, GetThreadNumber) (THIS) PURE;
  2119. };
  2121. /****************************************************************************
  2122.  *
  2123.  *  Interface:
  2124.  *
  2125.  *     IHXMemoryServices
  2126.  *
  2127.  *  Purpose:
  2128.  *
  2129.  *     Exposes server memory functions
  2130.  *
  2131.  *  IID_IHXMemoryServices
  2132.  *
  2133.  *     {00000126-0901-11d1-8B06-00A024406D59}
  2134.  *
  2135.  */
  2136. DEFINE_GUID(IID_IHXMemoryServices, 0x00000126, 0x901, 0x11d1, 0x8b, 0x6, 0x0,
  2137.                        0xa0, 0x24, 0x40, 0x6d, 0x59);
  2139. #undef  INTERFACE
  2140. #define INTERFACE   IHXMemoryServices
  2142. #define CLSID_IHXMemoryServices IID_IHXMemoryServices
  2144. DECLARE_INTERFACE_(IHXMemoryServices, IUnknown)
  2145. {
  2146.     /*
  2147.      *  IUnknown methods
  2148.      */
  2149.     STDMETHOD(QueryInterface)          (THIS_
  2150.                                        REFIID riid,
  2151.                                        void** ppvObj) PURE;
  2153.     STDMETHOD_(ULONG32,AddRef)         (THIS) PURE;
  2155.     STDMETHOD_(ULONG32,Release)        (THIS) PURE;
  2157.     /*
  2158.      * IHXMemoryServices methods
  2159.      */
  2161.     /*
  2162.      *  IHXMemoryServices::ValidateMemory()
  2163.      *
  2164.      *  Make consistency checks on the server shared memory space.
  2165.      *
  2166.      * lStartPage, lPages
  2167.      *
  2168.      * Specifies a page range to allow smaller searches, if you have a 
  2169.      * repro case and want to fail as soon as possible after the scribble.
  2170.      * Use lPages == 0 to check to the last page.  (Pages in the shared
  2171.      * space are numbered starting from zero.  You can decide on a range
  2172.      * based on the printout of previous errors.)
  2173.      *
  2174.      * ulFlags
  2175.      *
  2176.      * 0x00000001 fail -- abort() -- on finding an error.
  2177.      * 0x00000002 do rudimentary checks on internal SharedMemory data arrays.
  2178.      *
  2179.      */
  2180.     STDMETHOD(ValidateMemory) (THIS_
  2181.  INT32 lStartPage, 
  2182.  INT32 lPages, 
  2183.  UINT32 ulFlags) PURE;
  2184. };
  2187. typedef enum _HX_PRIVATE_SOCKET_OPTION
  2188. {
  2189.     HX_PRIVATE_SOCKOPT_IGNORE_WSAECONNRESET
  2190. } HX_PRIVATE_SOCKET_OPTION;
  2192. /****************************************************************************
  2193.  * 
  2194.  *  Interface:
  2195.  * 
  2196.  * IHXSetPrivateSocketOption
  2197.  * 
  2198.  *  Purpose:
  2199.  * 
  2200.  * Set private sockt option
  2201.  * 
  2202.  *  IID_IHXSetPrivateSocketOption:
  2203.  *
  2204.  *     {00000127-0901-11d1-8B06-00A024406D59}
  2205.  * 
  2206.  */
  2207. DEFINE_GUID(IID_IHXSetPrivateSocketOption, 
  2208.     0x00000127, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59);
  2209.  
  2210. #undef  INTERFACE
  2211. #define INTERFACE   IHXSetPrivateSocketOption
  2212. DECLARE_INTERFACE_(IHXSetPrivateSocketOption, IUnknown)
  2213. {
  2214.     /*
  2215.      *  IUnknown methods
  2216.      */
  2217.     STDMETHOD(QueryInterface) (THIS_
  2218. REFIID riid,
  2219. void** ppvObj) PURE;
  2221.     STDMETHOD_(ULONG32,AddRef) (THIS) PURE;
  2223.     STDMETHOD_(ULONG32,Release) (THIS) PURE;
  2225.     /*
  2226.      * IHXSetPrivateSocketOption methods
  2227.      */
  2229.     STDMETHOD(SetOption) (THIS_ 
  2230.  HX_PRIVATE_SOCKET_OPTION option,
  2231.  UINT32 ulValue) PURE;  
  2232. };
  2234. /****************************************************************************
  2235.  * 
  2236.  *  Interface:
  2237.  * 
  2238.  * IHXNetInterfaces
  2239.  * 
  2240.  *  Purpose:
  2241.  * 
  2242.  * Network Interfaces
  2243.  * 
  2244.  *  IID_IHXNetInterfaces:
  2245.  *
  2246.  *     {00000128-0901-11d1-8B06-00A024406D59}
  2247.  * 
  2248.  */
  2249. typedef enum
  2250. {
  2251.     UNKNOWN,
  2252.     LOOPBACK,
  2253.     POINTTOPOINT,
  2254.     BROADCAST
  2255. } NIType;
  2257. typedef struct _NIInfo
  2258. {
  2259.     NIType type;
  2260.     BOOL bActive;
  2261.     UINT32 ulNetAddress;
  2262.     UINT32 ulNetMask;
  2263. } NIInfo;
  2265. DEFINE_GUID(IID_IHXNetInterfaces, 
  2266.     0x00000128, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59);
  2267.  
  2268. #undef  INTERFACE
  2269. #define INTERFACE   IHXNetInterfaces
  2270. DECLARE_INTERFACE_(IHXNetInterfaces, IUnknown)
  2271. {
  2272.     /*
  2273.      *  IUnknown methods
  2274.      */
  2275.     STDMETHOD(QueryInterface) (THIS_
  2276. REFIID riid,
  2277. void** ppvObj) PURE;
  2279.     STDMETHOD_(ULONG32,AddRef) (THIS) PURE;
  2281.     STDMETHOD_(ULONG32,Release) (THIS) PURE;
  2283.     /*
  2284.      * IHXNetworkInterfaces methods
  2285.      */
  2286.     STDMETHOD(UpdateNetInterfaces) (THIS) PURE;
  2288.     STDMETHOD_(UINT32, GetNumOfNetInterfaces) (THIS) PURE;
  2290.     STDMETHOD(GetNetInterfaces) (THIS_
  2291. UINT16 lIndex,
  2292. REF(NIInfo*) pNIInfo) PURE;
  2294.     STDMETHOD(AddAdviseSink) (THIS_
  2295. IHXNetInterfacesAdviseSink* pSink) PURE;
  2297.     STDMETHOD(RemoveAdviseSink) (THIS_
  2298. IHXNetInterfacesAdviseSink* pSink) PURE;
  2299. };
  2301. /****************************************************************************
  2302.  * 
  2303.  *  Interface:
  2304.  * 
  2305.  * IHXNetInterfacesAdviseSink
  2306.  * 
  2307.  *  Purpose:
  2308.  * 
  2309.  * Network Interfaces Advise Sink
  2310.  * 
  2311.  *  IID_IHXNetInterfaces:
  2312.  *
  2313.  *     {00000129-0901-11d1-8B06-00A024406D59}
  2314.  * 
  2315.  */
  2316. DEFINE_GUID(IID_IHXNetInterfacesAdviseSink, 
  2317.     0x00000129, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59);
  2318.  
  2319. #undef  INTERFACE
  2320. #define INTERFACE   IHXNetInterfacesAdviseSink
  2321. DECLARE_INTERFACE_(IHXNetInterfacesAdviseSink, IUnknown)
  2322. {
  2323.     /*
  2324.      *  IUnknown methods
  2325.      */
  2326.     STDMETHOD(QueryInterface) (THIS_
  2327. REFIID riid,
  2328. void** ppvObj) PURE;
  2330.     STDMETHOD_(ULONG32,AddRef) (THIS) PURE;
  2332.     STDMETHOD_(ULONG32,Release) (THIS) PURE;
  2334.     /*
  2335.      * IHXNetInterfacesAdviseSink methods
  2336.      */
  2337.     STDMETHOD(NetInterfacesUpdated) (THIS) PURE;
  2338. };
  2339. // $EndPrivate.
  2341. /****************************************************************************
  2342.  * 
  2343.  *  Interface:
  2344.  * 
  2345.  * IHXNetworkInterfaceEnumerator
  2346.  * 
  2347.  *  Purpose:
  2348.  * 
  2349.  * Enumerate interfaces on a box.
  2350.  * 
  2351.  *  IID_IHXNetworkInterfaceEnumerator;
  2352.  * 
  2353.  * {00000121-0901-11d1-8B06-00A024406D59}
  2354.  * 
  2355.  */
  2356. DEFINE_GUID(IID_IHXNetworkInterfaceEnumerator, 0x00000121, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 
  2357. 0xa0, 0x24, 0x40, 0x6d, 0x59);
  2359. #undef  INTERFACE
  2360. #define INTERFACE   IHXNetworkInterfaceEnumerator
  2362. DECLARE_INTERFACE_(IHXNetworkInterfaceEnumerator, IUnknown)
  2363. {
  2364.     /*
  2365.      *  IUnknown methods
  2366.      */
  2367.     STDMETHOD(QueryInterface) (THIS_
  2368. REFIID riid,
  2369. void** ppvObj) PURE;
  2370.     STDMETHOD_(ULONG32,AddRef) (THIS) PURE;
  2371.     STDMETHOD_(ULONG32,Release) (THIS) PURE;
  2374.     /************************************************************************
  2375.      * Method:
  2376.      *     IHXNetworkInterfaceEnumerator::EnumerateInterfaces
  2377.      * Purpose:
  2378.      *     returns a list of local interfaces
  2379.      * Usage:
  2380.      *     If a buffer passed in is too small, it will return 
  2381.      *     HXR_BUFFERTOOSMALL with ulNumInterfaces updated.
  2382.      */
  2383.     STDMETHOD(EnumerateInterfaces) (THIS_
  2384. REF(UINT32*) pulInterfaces, REF(UINT32) ulNumInterfaces) PURE;
  2385. };
  2387. /****************************************************************************
  2388.  * 
  2389.  *  Interface:
  2390.  * 
  2391.  * IHXUDPConnectedSocket
  2392.  * 
  2393.  *  Purpose:
  2394.  * 
  2395.  * Connect and disconnect a UDP socket
  2396.  * 
  2397.  *  IID_IHXUDPConnectedSocket;
  2398.  * 
  2399.  * {0000012A-0901-11d1-8B06-00A024406D59}
  2400.  * 
  2401.  */
  2402. DEFINE_GUID(IID_IHXUDPConnectedSocket, 0x0000012a, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 
  2403. 0xa0, 0x24, 0x40, 0x6d, 0x59);
  2405. #undef  INTERFACE
  2406. #define INTERFACE   IHXUDPConnectedSocket
  2408. DECLARE_INTERFACE_(IHXUDPConnectedSocket, IUnknown)
  2409. {
  2410.     /*
  2411.      *  IUnknown methods
  2412.      */
  2413.     STDMETHOD(QueryInterface) (THIS_
  2414. REFIID riid,
  2415. void** ppvObj) PURE;
  2416.     STDMETHOD_(ULONG32,AddRef) (THIS) PURE;
  2417.     STDMETHOD_(ULONG32,Release) (THIS) PURE;
  2420.     /************************************************************************
  2421.      * Method:
  2422.      *     IHXUDPConnectedSocket::UDPConnect
  2423.      * Purpose:
  2424.      *     Connect the udp socket
  2425.      * Usage:
  2426.      *     Connect to the foreign addr and port the socket already knows
  2427.      *      about; this is implementation-dependent.
  2428.      */
  2429.     STDMETHOD(UDPConnect) (THIS) PURE;
  2431.     /************************************************************************
  2432.      * Method:
  2433.      *     IHXUDPConnectedSocket::UDPConnect(ULONG32 ulAddr, UINT16 nPort);
  2434.      * Purpose:
  2435.      *     Connect the udp socket
  2436.      * Usage:
  2437.      *     Specify the host-ordered foreign addr and port to connect to.
  2438.      */
  2439.     STDMETHOD(UDPConnect) (THIS_ ULONG32 ulAddr, UINT16 nPort) PURE;
  2441.     /************************************************************************
  2442.      * Method:
  2443.      *     IHXUDPConnectedSocket::UDPDisconnect
  2444.      * Purpose:
  2445.      *     Disconnect the udp socket
  2446.      */
  2447.     STDMETHOD(UDPDisconnect) (THIS) PURE;
  2449.     /************************************************************************
  2450.      * Method:
  2451.      *     IHXUDPConnectedSocket::IsUDPConnected
  2452.      * Purpose:
  2453.      *     Return whether the socket is connected.
  2454.      */
  2455.     STDMETHOD_(BOOL, IsUDPConnected) (THIS) PURE;
  2457.     /************************************************************************
  2458.      * Method:
  2459.      *     IHXUDPConnectedSocket::IsUDPConnected(REF(ULONG32) ulAddr, 
  2460.      *                                            REF(UINT16) nPort)
  2461.      * Purpose:
  2462.      *     Return whether the socket is connected, and the connected addr/port.
  2463.      * Usage:
  2464.      *      Return the foreign addr/port the socket knows about, regardless of
  2465.      *      whether it's connected.  This is the foreign addr that is connected
  2466.      *      to (if TRUE) or that will be used if Connect(void) called (if FALSE).
  2467.      */
  2468.     STDMETHOD_(BOOL, IsUDPConnected) (THIS_ REF(ULONG32) ulAddr, 
  2469.                                             REF(UINT16) nPort) PURE;
  2470. };
  2472. #endif /* _HXENGIN_H_ */