/* * * This software is released under the provisions of the GPL version 2. * see file "COPYING". If that file is not available, the full statement * of the license can be found at * * http://www.fsf.org/licensing/licenses/gpl.txt * * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved. * */ #ifndef _HXENGIN_H_ #define _HXENGIN_H_ #include "hxcom.h" #include "ihxpckts.h" /* * Forward declarations of some interfaces used here-in. */ typedef _INTERFACE IHXValues IHXValues; typedef _INTERFACE IHXBuffer IHXBuffer; typedef _INTERFACE IHXCallback IHXCallback; typedef _INTERFACE IHXScheduler IHXScheduler; typedef _INTERFACE IHXTCPResponse IHXTCPResponse; typedef _INTERFACE IHXLBoundTCPSocket IHXLBoundTCPSocket; typedef _INTERFACE IHXTCPSocket IHXTCPSocket; typedef _INTERFACE IHXListenResponse IHXListenResponse; typedef _INTERFACE IHXListenSocket IHXListenSocket; typedef _INTERFACE IHXNetworkServices IHXNetworkServices; typedef _INTERFACE IHXNetworkServices2 IHXNetworkServices2; typedef _INTERFACE IHXUDPResponse IHXUDPResponse; typedef _INTERFACE IHXUDPSocket IHXUDPSocket; typedef _INTERFACE IHXResolver IHXResolver; typedef _INTERFACE IHXResolverResponse IHXResolverResponse; typedef _INTERFACE IHXInterruptSafe IHXInterruptSafe; typedef _INTERFACE IHXAsyncIOSelection IHXAsyncIOSelection; typedef _INTERFACE IHXUDPMulticastInit IHXUDPMulticastInit; typedef _INTERFACE IHXInterruptState IHXInterruptState; typedef _INTERFACE IHXOptimizedScheduler IHXOptimizedScheduler; // $Private: typedef _INTERFACE IHXThreadSafeScheduler IHXThreadSafeScheduler; typedef _INTERFACE IHXBufferedSocket IHXBufferedSocket; typedef _INTERFACE IHXNetInterfaces IHXNetInterfaces; typedef _INTERFACE IHXNetInterfacesAdviseSink IHXNetInterfacesAdviseSink; // $EndPrivate. typedef _INTERFACE IHXNetworkInterfaceEnumerator IHXNetworkInterfaceEnumerator; typedef _INTERFACE IHXUDPConnectedSocket IHXUDPConnectedSocket; typedef _INTERFACE IHXAutoBWDetection IHXAutoBWDetection; typedef _INTERFACE IHXAutoBWDetectionAdviseSink IHXAutoBWDetectionAdviseSink; typedef _INTERFACE IHXAutoBWCalibration IHXAutoBWCalibration; typedef _INTERFACE IHXAutoBWCalibrationAdviseSink IHXAutoBWCalibrationAdviseSink; typedef _INTERFACE IHXPreferredTransport IHXPreferredTransport; /* * Address flags starting with PNR are deprecated. */ #define HXR_INADDR_ANY (UINT32)0x00000000 //THIS FLAG IS DEPRECATED #define HX_INADDR_ANY (UINT32)0x00000000 /* * 255.255.255.254 * * Bind to all ports in IPBindings list from * server config. */ #define HXR_INADDR_IPBINDINGS (UINT32)0xfffffffe //THIS FLAG IS DEPRECATED #define HX_INADDR_IPBINDINGS (UINT32)0xfffffffe /* Async IO Selection Type (Unix Only) */ #define PNAIO_READ 1 #define PNAIO_WRITE 2 #define PNAIO_EXCEPTION 4 /**************************************************************************** * * Interface: * * IHXCallback * * Purpose: * * This interface defines a simple callback which will be used in * various interfaces such as IHXScheduler. * * IID_IHXCallback: * * {00000100-0901-11d1-8B06-00A024406D59} * */ DEFINE_GUID(IID_IHXCallback, 0x00000100, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59); #undef INTERFACE #define INTERFACE IHXCallback DECLARE_INTERFACE_(IHXCallback, IUnknown) { /* * IUnknown methods */ STDTQT_METHOD(QueryInterface) (THIS_ REFIID riid, void** ppvObj) PURE; STDMETHOD_(ULONG32,AddRef) (THIS) PURE; STDMETHOD_(ULONG32,Release) (THIS) PURE; /* * IHXCallback methods */ /************************************************************************ * Method: * IHXCallback::Func * Purpose: * This is the function that will be called when a callback is * to be executed. */ STDTQT_METHOD(Func) (THIS) PURE; }; /**************************************************************************** * * Interface: * * IHXScheduler * * Purpose: * * This interface provides the user with a way of scheduling callbacks * that will be executed at some time in the future. * * IID_IHXScheduler: * * {00000101-0901-11d1-8B06-00A024406D59} * */ DEFINE_GUID(IID_IHXScheduler, 0x00000101, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59); #undef INTERFACE #define INTERFACE IHXScheduler typedef ULONG32 CallbackHandle; typedef struct _HXTimeval { UINT32 tv_sec; UINT32 tv_usec; } HXTimeval; DECLARE_INTERFACE_(IHXScheduler, IUnknown) { /* * IUnknown methods */ STDTQT_METHOD(QueryInterface) (THIS_ REFIID riid, void** ppvObj) PURE; STDMETHOD_(ULONG32,AddRef) (THIS) PURE; STDMETHOD_(ULONG32,Release) (THIS) PURE; /* * IHXScheduler methods */ /************************************************************************ * Method: * IHXScheduler::RelativeEnter * Purpose: * Schedule a callback to be executed "ms" milliseconds from now * This function is less percise then AbsoluteEnter and should only * be used when accurate timing is not critical. */ STDMETHOD_(CallbackHandle,RelativeEnter) (THIS_ IHXCallback* pCallback, UINT32 ms) PURE; /************************************************************************ * Method: * IHXScheduler::AbsoluteEnter * Purpose: * Schedule a callback to be executed at time "tVal". */ STDMETHOD_(CallbackHandle,AbsoluteEnter) (THIS_ IHXCallback* pCallback, HXTimeval tVal) PURE; /************************************************************************ * Method: * IHXScheduler::Remove * Purpose: * Remove a callback from the scheduler. */ STDTQT_METHOD(Remove) (THIS_ CallbackHandle Handle) PURE; /************************************************************************ * Method: * IHXScheduler::GetCurrentSchedulerTime * Purpose: * Gives the current time (in the timeline of the scheduler). */ STDMETHOD_(HXTimeval,GetCurrentSchedulerTime) (THIS) PURE; }; /**************************************************************************** * * Interface: * * IHXTCPResponse * * Purpose: * * This is the response interface for the asynchronous TCP networking * interface. * * IID_IHXTCPResponse: * * {00000102-0901-11d1-8B06-00A024406D59} * */ DEFINE_GUID(IID_IHXTCPResponse, 0x00000102, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59); #undef INTERFACE #define INTERFACE IHXTCPResponse DECLARE_INTERFACE_(IHXTCPResponse, IUnknown) { /* * IUnknown methods */ STDTQT_METHOD(QueryInterface) (THIS_ REFIID riid, void** ppvObj) PURE; STDMETHOD_(ULONG32,AddRef) (THIS) PURE; STDMETHOD_(ULONG32,Release) (THIS) PURE; /* * IHXTCPResponse methods */ /************************************************************************ * Method: * IHXTCPResponse::ConnectDone * Purpose: * A Connect operation has been completed or an error has occurred. */ STDTQT_METHOD(ConnectDone) (THIS_ HX_RESULT status) PURE; /************************************************************************ * Method: * IHXTCPResponse::ReadDone * Purpose: * A Read operation has been completed or an error has occurred. * The data is returned in the IHXBuffer. */ STDTQT_METHOD(ReadDone) (THIS_ HX_RESULT status, IHXBuffer* pBuffer) PURE; /************************************************************************ * Method: * IHXTCPResponse::WriteReady * Purpose: * This is the response method for WantWrite. * If HX_RESULT is ok, then the TCP channel is ok to Write to. */ STDTQT_METHOD(WriteReady) (THIS_ HX_RESULT status) PURE; /************************************************************************ * Method: * IHXTCPResponse::Closed * Purpose: * This method is called to inform you that the TCP channel has * been closed by the peer or closed due to error. */ STDTQT_METHOD(Closed) (THIS_ HX_RESULT status) PURE; }; /**************************************************************************** * * Interface: * * IHXTCPSocket * * Purpose: * * Provides the user with an asynchronous TCP networking interface. * * IID_IHXTCPSocket: * * {00000103-0901-11d1-8B06-00A024406D59} * */ DEFINE_GUID(IID_IHXTCPSocket, 0x00000103, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59); #undef INTERFACE #define INTERFACE IHXTCPSocket DECLARE_INTERFACE_(IHXTCPSocket, IUnknown) { /* * IUnknown methods */ STDTQT_METHOD(QueryInterface) (THIS_ REFIID riid, void** ppvObj) PURE; STDMETHOD_(ULONG32,AddRef) (THIS) PURE; STDMETHOD_(ULONG32,Release) (THIS) PURE; /* * IHXTCPSocket methods * * Network addresses and ports are in native byte order * */ STDTQT_METHOD(Init) (THIS_ IHXTCPResponse* /*IN*/ pTCPResponse) PURE; STDTQT_METHOD(SetResponse) (THIS_ IHXTCPResponse* pTCPResponse) PURE; STDTQT_METHOD(Bind) (THIS_ UINT32 ulLocalAddr, UINT16 nPort) PURE; /* * pDestination is a string containing host name or dotted-ip notation */ STDTQT_METHOD(Connect) (THIS_ const char* pDestination, UINT16 nPort) PURE; STDTQT_METHOD(Read) (THIS_ UINT16 Size) PURE; STDTQT_METHOD(Write) (THIS_ IHXBuffer* pBuffer) PURE; /************************************************************************ * Method: * IHXTCPSocket::WantWrite * Purpose: * This method is called when you wish to write a large amount of * data. If you are only writing small amounts of data, you can * just call Write (all data not ready to be transmitted will be * buffered on your behalf). When the TCP channel is ready to be * written to, the response interfaces WriteReady method will be * called. */ STDTQT_METHOD(WantWrite) (THIS) PURE; /************************************************************************ * Method: * IHXTCPSocket::GetForeignAddress * Purpose: * Returns the address of the other end of the TCP socket as a * ULONG32 in local host order */ STDTQT_METHOD(GetForeignAddress) (THIS_ REF(ULONG32) lAddress) PURE; STDTQT_METHOD(GetLocalAddress) (THIS_ REF(ULONG32) lAddress) PURE; /************************************************************************ * Method: * IHXTCPSocket::GetForeignPort * Purpose: * Returns the port of the other end of the TCP socket in local * host order. */ STDTQT_METHOD(GetForeignPort) (THIS_ REF(UINT16) port) PURE; STDTQT_METHOD(GetLocalPort) (THIS_ REF(UINT16) port) PURE; }; // $Private: /**************************************************************************** * * Interface: * * IHXTCPSecureSocket * * Purpose: * * When an IHXTCPSocket also supports this interface, * it allows you to say it's secure so it tries to use * SSL. * */ DEFINE_GUID(IID_IHXTCPSecureSocket, 0x00000203, 0x911, 0x21d1, 0x8c, 0x4, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x54); #undef INTERFACE #define INTERFACE IHXTCPSecureSocket DECLARE_INTERFACE_(IHXTCPSecureSocket, IUnknown) { /* * IUnknown methods */ STDTQT_METHOD(QueryInterface) (THIS_ REFIID riid, void** ppvObj) PURE; STDMETHOD_(ULONG32,AddRef) (THIS) PURE; STDMETHOD_(ULONG32,Release) (THIS) PURE; /* * IHXTCPSecureSocket method */ STDTQT_METHOD(SetSecure) (THIS_ HXBOOL bSecure) PURE; }; // $EndPrivate. // $Private: /**************************************************************************** * * Interface: * * IHXSSL * * Purpose: * * This is the interface to an SSL library. * */ DEFINE_GUID(IID_IHXSSL, 0x34e171d4, 0xa8f0, 0x4832, 0xbc, 0x7d, 0x06, 0xdf, 0xe3, 0xae, 0x58, 0xfd); DECLARE_INTERFACE_(IHXSSL, IUnknown) { /* * IUnknown methods */ STDTQT_METHOD(QueryInterface) (THIS_ REFIID riid, void** ppvObj) PURE; STDMETHOD_(ULONG32, AddRef) (THIS) PURE; STDMETHOD_(ULONG32, Release) (THIS) PURE; /* * */ STDTQT_METHOD(Initialize) (THIS) PURE; STDTQT_METHOD(Shutdown) (THIS) PURE; STDTQT_METHOD(PostConnect) (THIS_ LONG32 nSocketNumber) PURE; STDMETHOD_(LONG32, Read) (THIS_ LONG32 nSocketNumber, void* buff, LONG32 buffLen) PURE; STDMETHOD_(LONG32, Write) (THIS_ LONG32 nSocketNumber, void* buff, LONG32 buffLen) PURE; STDTQT_METHOD(Close) (THIS_ LONG32 nSocketNumber) PURE; STDTQT_METHOD(SetCallbacks) (THIS_ void* readCallback, void* writeCallback, void* closeCallback) PURE; }; // $EndPrivate. // $Private: /**************************************************************************** * * Interface: * * IHXBufferedSocket * * Purpose: * * This provdies a method for doing for doing more optimal * TCP delivery using desired packet size and writev. * * IID_IHXTCPSocket: * * {00001402-0901-11d1-8B06-00A024406D59} * */ DEFINE_GUID(IID_IHXBufferedSocket, 0x00001402, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59); #undef INTERFACE #define INTERFACE IHXBufferedSocket DECLARE_INTERFACE_(IHXBufferedSocket, IUnknown) { /* * IUnknown methods */ STDTQT_METHOD(QueryInterface) (THIS_ REFIID riid, void** ppvObj) PURE; STDMETHOD_(ULONG32,AddRef) (THIS) PURE; STDMETHOD_(ULONG32,Release) (THIS) PURE; /* * IHXTCPSocket methods */ STDTQT_METHOD(BufferedWrite) (THIS_ IHXBuffer* pBuffer) PURE; STDTQT_METHOD(FlushWrite) (THIS) PURE; STDTQT_METHOD(SetDesiredPacketSize) (THIS_ UINT32 ulPacketSize) PURE; }; // $EndPrivate. /**************************************************************************** * * Interface: * * IHXListenResponse * * Purpose: * * This is the response interface for the asynchronous TCP listening * socket interface. * * IID_IHXListenResponse: * * {00000104-0901-11d1-8B06-00A024406D59} * */ DEFINE_GUID(IID_IHXListenResponse, 0x00000104, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59); #undef INTERFACE #define INTERFACE IHXListenResponse DECLARE_INTERFACE_(IHXListenResponse, IUnknown) { /* * IUnknown methods */ STDTQT_METHOD(QueryInterface) (THIS_ REFIID riid, void** ppvObj) PURE; STDMETHOD_(ULONG32,AddRef) (THIS) PURE; STDMETHOD_(ULONG32,Release) (THIS) PURE; /* * IHXListenResponse methods */ STDTQT_METHOD(NewConnection) (THIS_ HX_RESULT status, IHXTCPSocket* pTCPSocket) PURE; }; /**************************************************************************** * * Interface: * * IHXListenSocket * * Purpose: * * This interfaces allows you to asynchronously listen on a port for * TCP connections. * * IID_IHXListenSocket: * * {00000105-0901-11d1-8B06-00A024406D59} * */ DEFINE_GUID(IID_IHXListenSocket, 0x00000105, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59); #undef INTERFACE #define INTERFACE IHXListenSocket DECLARE_INTERFACE_(IHXListenSocket, IUnknown) { /* * IUnknown methods */ STDTQT_METHOD(QueryInterface) (THIS_ REFIID riid, void** ppvObj) PURE; STDMETHOD_(ULONG32,AddRef) (THIS) PURE; STDMETHOD_(ULONG32,Release) (THIS) PURE; /* * IHXListenSocket methods */ STDTQT_METHOD(Init) (THIS_ UINT32 ulLocalAddr, UINT16 port, IHXListenResponse* /*IN*/ pListenResponse ) PURE; }; /**************************************************************************** * * Interface: * * IHXNetworkServices * * Purpose: * * This is a factory interface for the various types of networking * interfaces described above. * * IID_IHXNetworkServices: * * {00000106-0901-11d1-8B06-00A024406D59} * */ DEFINE_GUID(IID_IHXNetworkServices, 0x00000106, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59); #undef INTERFACE #define INTERFACE IHXNetworkServices DECLARE_INTERFACE_(IHXNetworkServices, IUnknown) { /* * IUnknown methods */ STDTQT_METHOD(QueryInterface) (THIS_ REFIID riid, void** ppvObj) PURE; STDMETHOD_(ULONG32,AddRef) (THIS) PURE; STDMETHOD_(ULONG32,Release) (THIS) PURE; /* * IHXNetworkServices methods */ /************************************************************************ * Method: * IHXNetworkServices::CreateTCPSocket * Purpose: * Create a new TCP socket. */ STDTQT_METHOD(CreateTCPSocket) (THIS_ IHXTCPSocket** /*OUT*/ ppTCPSocket) PURE; /************************************************************************ * Method: * IHXNetworkServices::CreateUDPSocket * Purpose: * Create a new UDP socket. */ STDTQT_METHOD(CreateUDPSocket) (THIS_ IHXUDPSocket** /*OUT*/ ppUDPSocket) PURE; /************************************************************************ * Method: * IHXNetworkServices::CreateListenSocket * Purpose: * Create a new TCP socket that will listen for connections on a * particular port. */ STDTQT_METHOD(CreateListenSocket) (THIS_ IHXListenSocket** /*OUT*/ ppListenSocket ) PURE; /************************************************************************ * Method: * IHXNetworkServices::CreateResolver * Purpose: * Create a new resolver that can lookup host names */ STDTQT_METHOD(CreateResolver) (THIS_ IHXResolver** /*OUT*/ ppResolver) PURE; }; /**************************************************************************** * * Interface: * * IHXNetworkServices2 * * Purpose: * * This is a factory interface for the various types of networking * interfaces described above. * * IID_IHXNetworkServices: * * {17951551-5683-11d3-B6BA-00C0F031C237} * */ // {17951551-5683-11d3-B6BA-00C0F031C237} DEFINE_GUID(IID_IHXNetworkServices2, 0x17951551, 0x5683, 0x11d3, 0xb6, 0xba, 0x0, 0xc0, 0xf0, 0x31, 0xc2, 0x37); #undef INTERFACE #define INTERFACE IHXNetworkServices2 DECLARE_INTERFACE_(IHXNetworkServices2, IHXNetworkServices) { /************************************************************************ * Method: * IHXNetworkServices2::CreateLBoundTCPSocket * Purpose: * Create a new local bound TCP socket. */ STDTQT_METHOD(CreateLBoundTCPSocket) (THIS_ IHXTCPSocket** /*OUT*/ ppTCPSocket) PURE; }; /**************************************************************************** * * Interface: * * IHXUDPResponse * * Purpose: * * This is the response interface for the asynchronous UDP networking * interface. * * IID_IHXUDPResponse: * * {00000107-0901-11d1-8B06-00A024406D59} * */ DEFINE_GUID(IID_IHXUDPResponse, 0x00000107, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59); #undef INTERFACE #define INTERFACE IHXUDPResponse DECLARE_INTERFACE_(IHXUDPResponse, IUnknown) { /* * IUnknown methods */ STDTQT_METHOD(QueryInterface) (THIS_ REFIID riid, void** ppvObj) PURE; STDMETHOD_(ULONG32,AddRef) (THIS) PURE; STDMETHOD_(ULONG32,Release) (THIS) PURE; /* * IHXUDPResponse methods */ STDTQT_METHOD(ReadDone) (THIS_ HX_RESULT status, IHXBuffer* pBuffer, ULONG32 ulAddr, UINT16 nPort) PURE; }; /**************************************************************************** * * Interface: * * IHXUDPSocket * * Purpose: * * Provides the user with an asynchronous UDP networking interface. * * IID_IHXUDPSocket: * * {00000108-0901-11d1-8B06-00A024406D59} * */ DEFINE_GUID(IID_IHXUDPSocket, 0x00000108, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59); #undef INTERFACE #define INTERFACE IHXUDPSocket DECLARE_INTERFACE_(IHXUDPSocket, IUnknown) { /* * IUnknown methods */ STDTQT_METHOD(QueryInterface) (THIS_ REFIID riid, void** ppvObj) PURE; STDMETHOD_(ULONG32,AddRef) (THIS) PURE; STDMETHOD_(ULONG32,Release) (THIS) PURE; /* * IHXUDPSocket methods * * Network addresses and ports are in native byte order */ STDTQT_METHOD(Init) (THIS_ ULONG32 ulAddr, UINT16 nPort, IHXUDPResponse* pUDPResponse) PURE; STDTQT_METHOD(Bind) (THIS_ UINT32 ulLocalAddr, UINT16 nPort) PURE; STDTQT_METHOD(Read) (THIS_ UINT16 Size) PURE; STDTQT_METHOD(Write) (THIS_ IHXBuffer* pBuffer) PURE; STDTQT_METHOD(WriteTo) (THIS_ ULONG32 ulAddr, UINT16 nPort, IHXBuffer* pBuffer) PURE; STDTQT_METHOD(GetLocalPort) (THIS_ REF(UINT16) port) PURE; STDTQT_METHOD(JoinMulticastGroup) (THIS_ ULONG32 ulMulticastAddr, ULONG32 ulInterfaceAddr) PURE; STDTQT_METHOD(LeaveMulticastGroup) (THIS_ ULONG32 ulMulticastAddr, ULONG32 ulInterfaceAddr) PURE; }; /**************************************************************************** * * Interface: * * IHXResolver * * Purpose: * * This interface allows you to asynchronously resolve hostnames. * * IID_IHXResolver: * * {00000109-0901-11d1-8B06-00A024406D59} * */ DEFINE_GUID(IID_IHXResolver, 0x00000109, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59); #undef INTERFACE #define INTERFACE IHXResolver DECLARE_INTERFACE_(IHXResolver, IUnknown) { /* * IUnknown methods */ STDTQT_METHOD(QueryInterface) (THIS_ REFIID riid, void** ppvObj) PURE; STDMETHOD_(ULONG32,AddRef) (THIS) PURE; STDMETHOD_(ULONG32,Release) (THIS) PURE; /* * IHXResolver methods */ STDTQT_METHOD(Init) (THIS_ IHXResolverResponse* pResponse) PURE; STDTQT_METHOD(GetHostByName) (THIS_ const char* pHostName) PURE; }; /**************************************************************************** * * Interface: * * IHXResolverResponse * * Purpose: * * This is the response interface for the asynchronous DNS hostname * resolver. * * IID_IHXResolverResponse: * * {0000010A-0901-11d1-8B06-00A024406D59} * */ DEFINE_GUID(IID_IHXResolverResponse, 0x0000010A, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59); #undef INTERFACE #define INTERFACE IHXResolverResponse DECLARE_INTERFACE_(IHXResolverResponse, IUnknown) { /* * IUnknown methods */ STDTQT_METHOD(QueryInterface) (THIS_ REFIID riid, void** ppvObj) PURE; STDMETHOD_(ULONG32,AddRef) (THIS) PURE; STDMETHOD_(ULONG32,Release) (THIS) PURE; /* * IHXResolverResponse methods */ STDTQT_METHOD(GetHostByNameDone) (THIS_ HX_RESULT status, ULONG32 ulAddr) PURE; }; /**************************************************************************** * * Interface: * * IHXInterruptSafe * * Purpose: * * This interface is used in Macintosh implementations of callback * functions, renderers, etc... to determine if interrupt time execution * is supported. If this interface is not implemented then it is assumed * that interrupt time execution is NOT supported. There are restrictions * on what may be executed at interrupt time; please consult the Macintosh * Deferred Task Manager tech notes from Apple. * * IID_IHXInterruptSafe: * * {0000010B-0901-11d1-8B06-00A024406D59} * */ DEFINE_GUID(IID_IHXInterruptSafe, 0x0000010B, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59); #undef INTERFACE #define INTERFACE IHXInterruptSafe DECLARE_INTERFACE_(IHXInterruptSafe, IUnknown) { /* * IUnknown methods */ STDTQT_METHOD(QueryInterface) (THIS_ REFIID riid, void** ppvObj) PURE; STDMETHOD_(ULONG32,AddRef) (THIS) PURE; STDMETHOD_(ULONG32,Release) (THIS) PURE; /* * IHXInterruptSafe methods */ /************************************************************************ * Method: * IHXInterruptSafe::IsInterruptSafe * Purpose: * This is the function that will be called to determine if * interrupt time execution is supported. */ STDMETHOD_(HXBOOL,IsInterruptSafe) (THIS) PURE; }; /**************************************************************************** * * Interface: * * IHXAsyncIOSelection * * Purpose: * * This interface is implemented by the server/player context on Unix * platforms. This interface allows your plugin to get callbacks based * I/O events that are normally handled by select(). This interface * allows you to setup callbacks which will be executed when a file * descriptor is ready for reading, writing, or has an exception. * * IID_IHXAsyncIOSelection: * * {0000010C-0901-11d1-8B06-00A024406D59} * */ DEFINE_GUID(IID_IHXAsyncIOSelection, 0x0000010C, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59); #undef INTERFACE #define INTERFACE IHXAsyncIOSelection DECLARE_INTERFACE_(IHXAsyncIOSelection, IUnknown) { /* * IUnknown methods */ STDTQT_METHOD(QueryInterface) (THIS_ REFIID riid, void** ppvObj) PURE; STDMETHOD_(ULONG32,AddRef) (THIS) PURE; STDMETHOD_(ULONG32,Release) (THIS) PURE; /* * IHXAsyncIOSelection methods */ /************************************************************************ * Method: * IHXAsyncIOSelection::Add * Purpose: * This function will allow you to receive a callback when the * given descriptor is ready for read, write, or has an * exception. This function is only available on Unix, and is * intended to replace the functionality of select(). */ STDTQT_METHOD(Add) (THIS_ IHXCallback* pCallback, INT32 lFileDescriptor, UINT32 ulType) PURE; /************************************************************************ * Method: * IHXAsyncIOSelection::Remove * Purpose: * This function will allow you remove the callback associated * with the given descriptor from the event handler. * This function is only available on Unix, and is intended to * replace the functionality of select(). */ STDTQT_METHOD(Remove) (THIS_ INT32 lFileDescriptor, UINT32 ulType) PURE; }; /**************************************************************************** * * Interface: * * IHXUDPMulticastInit * * Purpose: * * Provides the user with a way to set the TTL for outgoing multicast * UDP packets. Usually shared with IHXUDPSocket. * * IID_IHXUDPMulticastInit: * * {0000010D-0901-11d1-8B06-00A024406D59} * */ DEFINE_GUID(IID_IHXUDPMulticastInit, 0x0000010D, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59); #undef INTERFACE #define INTERFACE IHXUDPMulticastInit DECLARE_INTERFACE_(IHXUDPMulticastInit, IUnknown) { /* * IUnknown methods */ STDTQT_METHOD(QueryInterface) (THIS_ REFIID riid, void** ppvObj) PURE; STDMETHOD_(ULONG32,AddRef) (THIS) PURE; STDMETHOD_(ULONG32,Release) (THIS) PURE; /* * IHXUDPMulticastInit methods * */ /************************************************************************ * Method: * IHXUDPMulticastInit::InitMulticast * Purpose: * This function will set the TTL (time to live) for the UDP socket * so it can be used as a multicast socket, sending packets across * the number of routers specified in the ulTTL parameter. */ STDTQT_METHOD(InitMulticast) (THIS_ UINT8 chTTL) PURE; }; /**************************************************************************** * * Interface: * * IHXInterruptState * * Purpose: * * This interface is used in Macintosh implementations to inform the * the client engine when entering & leaving an interupt task. It is * also used to determine if it is currently at interrupt time. * Please consult the Macintosh Deferred Task Manager tech notes from Apple * for information on interrupt tasks. * * IID_IHXInterruptState: * * {0000010E-0901-11d1-8B06-00A024406D59} * */ DEFINE_GUID(IID_IHXInterruptState, 0x0000010E, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59); #undef INTERFACE #define INTERFACE IHXInterruptState DECLARE_INTERFACE_(IHXInterruptState, IUnknown) { /* * IUnknown methods */ STDTQT_METHOD(QueryInterface) (THIS_ REFIID riid, void** ppvObj) PURE; STDMETHOD_(ULONG32,AddRef) (THIS) PURE; STDMETHOD_(ULONG32,Release) (THIS) PURE; /* * IHXInterruptState methods */ /************************************************************************ * Method: * IHXInterruptState::AtInterruptTime * Purpose: * This function is called to determine if we are currently at * interrupt task time. */ STDMETHOD_(HXBOOL,AtInterruptTime) (THIS) PURE; /************************************************************************ * Method: * IHXInterruptState::EnterInterruptState * Purpose: * This function is called when starting a deferred/interrupt task */ STDTQT_METHOD(EnterInterruptState) (THIS) PURE; /************************************************************************ * Method: * IHXInterruptState::LeaveInterruptState * Purpose: * This function is called when leaving a deferred/interrupt task */ STDTQT_METHOD(LeaveInterruptState) (THIS) PURE; /************************************************************************ * Method: * IHXInterruptState::EnableInterrupt * Purpose: * This function can be called to enable/disable interrupt time * processsing */ STDTQT_METHOD(EnableInterrupt) (THIS_ HXBOOL bEnable) PURE; /************************************************************************ * Method: * IHXInterruptState::IsInterruptEnabled * Purpose: * This function can be called to find if the core is currently * interrupt enabled. */ STDMETHOD_(HXBOOL, IsInterruptEnabled) (THIS) PURE; }; /**************************************************************************** * * Interface: * * IHXOptimizedScheduler * * Purpose: * * This interface provides the user with a way of scheduling callbacks * that will be executed at some time in the future. * * This interface should ONLY be used if you need accurately timed * callbacks. These callbacks should be efficient and should not consume * much time/CPU. This is not a thread safe interface. The user has to * take care of synchronization in their callbacks. * * IID_IHXOptimizedScheduler: * * {0000010F-0901-11d1-8B06-00A024406D59} * */ DEFINE_GUID(IID_IHXOptimizedScheduler, 0x0000010F, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59); #undef INTERFACE #define INTERFACE IHXOptimizedScheduler DECLARE_INTERFACE_(IHXOptimizedScheduler, IUnknown) { /* * IUnknown methods */ STDTQT_METHOD(QueryInterface) (THIS_ REFIID riid, void** ppvObj) PURE; STDMETHOD_(ULONG32,AddRef) (THIS) PURE; STDMETHOD_(ULONG32,Release) (THIS) PURE; /* * IHXOptimizedScheduler methods */ /************************************************************************ * Method: * IHXOptimizedScheduler::RelativeEnter * Purpose: * Schedule a callback to be executed "ms" milliseconds from now * This function is less percise then AbsoluteEnter and should only * be used when accurate timing is not critical. */ STDMETHOD_(CallbackHandle,RelativeEnter) (THIS_ IHXCallback* pCallback, UINT32 ms) PURE; /************************************************************************ * Method: * IHXOptimizedScheduler::AbsoluteEnter * Purpose: * Schedule a callback to be executed at time "tVal". */ STDMETHOD_(CallbackHandle,AbsoluteEnter) (THIS_ IHXCallback* pCallback, HXTimeval tVal) PURE; /************************************************************************ * Method: * IHXOptimizedScheduler::Remove * Purpose: * Remove a callback from the scheduler. */ STDTQT_METHOD(Remove) (THIS_ CallbackHandle Handle) PURE; /************************************************************************ * Method: * IHXOptimizedScheduler::GetCurrentSchedulerTime * Purpose: * Gives the current time (in the timeline of the scheduler). */ STDMETHOD_(HXTimeval,GetCurrentSchedulerTime) (THIS) PURE; }; /**************************************************************************** * * Interface: * * IHXThreadSafeScheduler * * Purpose: * * This interface provides the user with a way of scheduling callbacks * that will be executed at some time in the future. This is identical * to IHXScheduler except the scheduler events are considered thread-safe. * * IID_IHXThreadSafeScheduler: * * {00000120-0901-11d1-8B06-00A024406D59} * */ DEFINE_GUID(IID_IHXThreadSafeScheduler, 0x00000120, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59); #undef INTERFACE #define INTERFACE IHXThreadSafeScheduler DECLARE_INTERFACE_(IHXThreadSafeScheduler, IUnknown) { /* * IUnknown methods */ STDTQT_METHOD(QueryInterface) (THIS_ REFIID riid, void** ppvObj) PURE; STDMETHOD_(ULONG32,AddRef) (THIS) PURE; STDMETHOD_(ULONG32,Release) (THIS) PURE; /* * IHXThreadSafeScheduler methods */ /************************************************************************ * Method: * IHXThreadSafeScheduler::RelativeEnter * Purpose: * Schedule a callback to be executed "ms" milliseconds from now * This function is less percise then AbsoluteEnter and should only * be used when accurate timing is not critical. */ STDMETHOD_(CallbackHandle,RelativeEnter) (THIS_ IHXCallback* pCallback, UINT32 ms) PURE; /************************************************************************ * Method: * IHXThreadSafeScheduler::AbsoluteEnter * Purpose: * Schedule a callback to be executed at time "tVal". */ STDMETHOD_(CallbackHandle,AbsoluteEnter) (THIS_ IHXCallback* pCallback, HXTimeval tVal) PURE; /************************************************************************ * Method: * IHXThreadSafeScheduler::Remove * Purpose: * Remove a callback from the scheduler. */ STDTQT_METHOD(Remove) (THIS_ CallbackHandle Handle) PURE; }; /**************************************************************************** * * Interface: * * IHXProcessEntryPoint * * Purpose: * * This interface is the entry point for an IHXProcess * * IID_IHXProcessEntryPoint * * {00000123-0901-11d1-8B06-00A024406D59} * */ DEFINE_GUID(IID_IHXProcessEntryPoint, 0x00000123, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59); #undef INTERFACE #define INTERFACE IHXProcessEntryPoint DECLARE_INTERFACE_(IHXProcessEntryPoint, IUnknown) { /* * IUnknown methods */ STDTQT_METHOD(QueryInterface) (THIS_ REFIID riid, void** ppvObj) PURE; STDMETHOD_(ULONG32,AddRef) (THIS) PURE; STDMETHOD_(ULONG32,Release) (THIS) PURE; STDTQT_METHOD(Func) (THIS_ IUnknown* pContext) PURE; }; /**************************************************************************** * * Interface: * * IHXProcess * * Purpose: * * This interface allows you to create new server processes and specify * an entry point. It is queried off the context. * * IID_IHXProcess * * {00000122-0901-11d1-8B06-00A024406D59} * */ DEFINE_GUID(IID_IHXProcess, 0x00000122, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59); #undef INTERFACE #define INTERFACE IHXProcess DECLARE_INTERFACE_(IHXProcess, IUnknown) { /* * IUnknown methods */ STDTQT_METHOD(QueryInterface) (THIS_ REFIID riid, void** ppvObj) PURE; STDMETHOD_(ULONG32,AddRef) (THIS) PURE; STDMETHOD_(ULONG32,Release) (THIS) PURE; STDTQT_METHOD(Start) (THIS_ const char* pProcessName, IHXProcessEntryPoint* pEntryPoint) PURE; }; /**************************************************************************** * * Interface: * * IHXLoadBalancedListen * * Purpose: * * This interface is queried off of IHXListenSocket. It allows * a plugin to specify that it wants the server to load balance * multiple instances of itself. The server will instantiate multiple * instances of the plugin as needed based on socket / descriptor limits. * Each plugin instance should attempt to listen on the same port as * other instances (they will share the port). * * IID_IHXLoadBalancedListen: * * {00000110-0901-11d1-8B06-00A024406D59} * */ DEFINE_GUID(IID_IHXLoadBalancedListen, 0x00000110, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59); #undef INTERFACE #define INTERFACE IHXLoadBalancedListen DECLARE_INTERFACE_(IHXLoadBalancedListen, IUnknown) { /* * IUnknown methods */ STDTQT_METHOD(QueryInterface) (THIS_ REFIID riid, void** ppvObj) PURE; STDMETHOD_(ULONG32,AddRef) (THIS) PURE; STDMETHOD_(ULONG32,Release) (THIS) PURE; /* * IHXLoadBalancedListen methods */ /************************************************************************ * Method: * IHXLoadBalancedListen::SetID * Purpose: * This function set's the unique ID for this listen socket. This * ID is used to determine whether or not different instances of * a plugin trying to listen on a single port are actually the * same plugin. Without this function, it would be possible for * two completely different plugins to listen on the same port using * the load balanced listener. */ STDTQT_METHOD(SetID) (THIS_ REFIID ID) PURE; /************************************************************************ * Method: * IHXLoadBalancedListen::SetReserveLimit * Purpose: * Sets the reserve limit for descriptors / sockets. If less * than reserve limit descriptors / sockets are left then a new * instance of the plugin will be created. */ STDTQT_METHOD(SetReserveLimit) (THIS_ UINT32 ulDescriptors, UINT32 ulSockets) PURE; }; /**************************************************************************** * * Interface: * * IHXOverrideDefaultServices * * Purpose: * * This interface is queried off of the context. It allows * a plugin to override any default services provided by the G2 system. * Currently, it is supported only on the client side. * You may currently override IHXNetworkServices using this interface * You can use the same interface to later restore back the overridden services. * This is done by calling the same OverrideServices() function with the * original service TQIed before the initial override. * * IID_IHXOverrideDefaultServices: * * {00000111-0901-11d1-8B06-00A024406D59} * */ DEFINE_GUID(IID_IHXOverrideDefaultServices, 0x00000111, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59); #undef INTERFACE #define INTERFACE IHXOverrideDefaultServices DECLARE_INTERFACE_(IHXOverrideDefaultServices, IUnknown) { /* * IUnknown methods */ STDTQT_METHOD(QueryInterface) (THIS_ REFIID riid, void** ppvObj) PURE; STDMETHOD_(ULONG32,AddRef) (THIS) PURE; STDMETHOD_(ULONG32,Release) (THIS) PURE; /* * IHXOverrideDefaultServices methods */ /************************************************************************ * Method: * IHXOverrideDefaultServices::OverrideServices * Purpose: * Override default services provided by the G2 system. * */ STDTQT_METHOD(OverrideServices) (THIS_ IUnknown* pContext) PURE; }; typedef enum _HX_SOCKET_OPTION { HX_SOCKOPT_REUSE_ADDR, HX_SOCKOPT_REUSE_PORT, HX_SOCKOPT_BROADCAST, HX_SOCKOPT_SET_RECVBUF_SIZE, HX_SOCKOPT_SET_SENDBUF_SIZE, HX_SOCKOPT_MULTICAST_IF, HX_SOCKOPT_IP_TOS } HX_SOCKET_OPTION; /**************************************************************************** * * Interface: * * IHXSetSocketOption * * Purpose: * * Set sockt option * * IID_IHXSetSocketOption: * * IID_IHXSetSocketOption: {00000114-0901-11d1-8B06-00A024406D59} * */ DEFINE_GUID(IID_IHXSetSocketOption, 0x00000114, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59); #undef INTERFACE #define INTERFACE IHXSetSocketOption DECLARE_INTERFACE_(IHXSetSocketOption, IUnknown) { /* * IUnknown methods */ STDTQT_METHOD(QueryInterface) (THIS_ REFIID riid, void** ppvObj) PURE; STDMETHOD_(ULONG32,AddRef) (THIS) PURE; STDMETHOD_(ULONG32,Release) (THIS) PURE; /* * IHXListenSocket methods */ STDTQT_METHOD(SetOption) (THIS_ HX_SOCKET_OPTION option, UINT32 ulValue) PURE; }; #define HX_THREADSAFE_METHOD_FF_GETPACKET 0x00000001 /* * FileFormat::GetPacket() only calls: * CCF->CI(Buffer), CCF->CI(Packet), CCF->CI(Values), *Alloc, *Free, * FS->Read(), FS->Close(), FS->Seek(), * FFR->PacketReady(), FFR->StreamDone() * Context->Scheduler->*, * CCF->CI(Mutex), Mutex->* * Context->ErrorMessages * * XXXSMPNOW */ #define HX_THREADSAFE_METHOD_FS_READ 0x00000002 /* * FileSystem::Read()/Seek()/Close() only calls: * CCF->CI(Buffer), CCF->CI(Packet), CCF->CI(Values), *Alloc, *Free, * FS->Read(), FS->Close(), FS->Seek(), * Context->Scheduler->*, * CCF->CI(Mutex), Mutex->* * Context->ErrorMessages * * XXXSMPNOW */ #define HX_THREADSAFE_METHOD_FSR_READDONE 0x00000004 /* * FileFormat::ReadDone()/SeekDone()/CloseDone() only calls: * CCF->CI(Buffer), CCF->CI(Packet), CCF->CI(Values), *Alloc, *Free, * FS->Read(), FS->Close(), FS->Seek(), * FFR->PacketReady(), FFR->StreamDone() * Context->Scheduler->*, * CCF->CI(Mutex), Mutex->* * Context->ErrorMessages * * XXXSMPNOW */ #define HX_THREADSAFE_METHOD_CACHE_FILE 0x00000008 /* * FileSystem::Read()/Seek()/Close() only calls: * CCF->CI(Buffer), CCF->CI(Packet), CCF->CI(Values), *Alloc, *Free, * FS->Read(), FS->Close(), FS->Seek(), * IHXCacheFile->*, IHXCacheFileResponse->*, * Context->Scheduler->*, * CCF->CI(Mutex), Mutex->* * Context->ErrorMessages * * XXXSMPNOW */ #define HX_THREADSAFE_METHOD_CACHE_FILE_RESPONSE 0x00000010 /* * FileSystem::Read()/Seek()/Close() only calls: * CCF->CI(Buffer), CCF->CI(Packet), CCF->CI(Values), *Alloc, *Free, * FS->Read(), FS->Close(), FS->Seek(), * IHXCacheFile->*, IHXCacheFileResponse->*, * Context->Scheduler->*, * CCF->CI(Mutex), Mutex->* * Context->ErrorMessages * * XXXSMPNOW */ /* * Thread Safe flags for IHXDataConvert */ #define HX_THREADSAFE_METHOD_CONVERT_HEADERS 0x00000020 /* * IHXDataConvert::ConvertXXX()/CtrlBufferReady() only calls: * CCF->CI(Buffer), CCF->CI(Packet), CCF->CI(Values), *Alloc, *Free, * IHXDataConvertResponse->* * Context->Scheduler->*, * CCF->CI(Mutex), Mutex->* * Context->ErrorMessages * * XXXSMPNOW */ #define HX_THREADSAFE_METHOD_CONVERT_DATA 0x00000040 /* * IHXDataConvert::ConvertXXX()/CtrlBufferReady() only calls: * CCF->CI(Buffer), CCF->CI(Packet), CCF->CI(Values), *Alloc, *Free, * IHXDataConvertResponse->* * Context->Scheduler->*, * CCF->CI(Mutex), Mutex->* * Context->ErrorMessages * * XXXSMPNOW */ #define HX_THREADSAFE_METHOD_CONVERT_CTRL_BUFFER_READY 0x00000080 /* * IHXDataConvert::ConvertXXX()/CtrlBufferReady() only calls: * CCF->CI(Buffer), CCF->CI(Packet), CCF->CI(Values), *Alloc, *Free, * IHXDataConvertResponse->* * Context->Scheduler->*, * CCF->CI(Mutex), Mutex->* * Context->ErrorMessages * * XXXSMPNOW */ #define HX_THREADSAFE_METHOD_SOCKET_READDONE 0x00000100 #define HX_THREADSAFE_METHOD_ALL (~0) /**************************************************************************** * * Interface: * * IHXThreadSafeMethods * * Purpose: * * XXXSMPNOW * * IID_IHXThreadSafeMethods: * * {00000115-0901-11d1-8B06-00A024406D59} * */ DEFINE_GUID(IID_IHXThreadSafeMethods, 0x00000115, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59); #undef INTERFACE #define INTERFACE IHXThreadSafeMethods DECLARE_INTERFACE_(IHXThreadSafeMethods, IUnknown) { /* * IUnknown methods */ STDTQT_METHOD(QueryInterface) (THIS_ REFIID riid, void** ppvObj) PURE; STDMETHOD_(ULONG32,AddRef) (THIS) PURE; STDMETHOD_(ULONG32,Release) (THIS) PURE; /* * IHXThreadSafeMethods methods */ /************************************************************************ * Method: * IHXThreadSafeMethods::IsThreadSafe * Purpose: * XXXSMPNOW */ STDMETHOD_(UINT32,IsThreadSafe) (THIS) PURE; }; /**************************************************************************** * * Interface: * * IHXMutex * * Purpose: * * XXXSMPNOW * * IID_IHXMutex: * * {00000116-0901-11d1-8B06-00A024406D59} * */ DEFINE_GUID(IID_IHXMutex, 0x00000116, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59); #undef INTERFACE #define INTERFACE IHXMutex /* * The IHXCommonClassFactory supports creating an instance * of this object. */ #define CLSID_IHXMutex IID_IHXMutex DECLARE_INTERFACE_(IHXMutex, IUnknown) { /* * IUnknown methods */ STDTQT_METHOD(QueryInterface) (THIS_ REFIID riid, void** ppvObj) PURE; STDMETHOD_(ULONG32,AddRef) (THIS) PURE; STDMETHOD_(ULONG32,Release) (THIS) PURE; /* * IHXMutex methods */ /* XXXSMPNOW Comments */ STDTQT_METHOD(Lock) (THIS) PURE; STDTQT_METHOD(TryLock) (THIS) PURE; STDTQT_METHOD(Unlock) (THIS) PURE; }; // $Private: /**************************************************************************** * * Interface: * * IHXFastPathNetWrite * * Purpose: * * Private interface for high speed UDP output. * * IID_IHXFastPathNetWrite: * * {00000117-0901-11d1-8B06-00A024406D59} * */ DEFINE_GUID(IID_IHXFastPathNetWrite, 0x00000117, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59); #undef INTERFACE #define INTERFACE IHXFastPathNetWrite DECLARE_INTERFACE_(IHXFastPathNetWrite, IUnknown) { /* * IUnknown methods */ STDTQT_METHOD(QueryInterface) (THIS_ REFIID riid, void** ppvObj) PURE; STDMETHOD_(ULONG32,AddRef) (THIS) PURE; STDMETHOD_(ULONG32,Release) (THIS) PURE; /* * IHXFastPathNetWrite methods * */ STDTQT_METHOD(FastWrite) (THIS_ const UINT8* pBuffer, UINT32 ulLen) PURE; }; /**************************************************************************** * * Interface: * * IHXWouldBlockResponse * * Purpose: * * Get notifications of EWOULDBLOCK conditions. * * IID_IHXWouldBlockResponse: * * {00000118-0901-11d1-8B06-00A024406D59} * */ DEFINE_GUID(IID_IHXWouldBlockResponse, 0x00000118, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59); #undef INTERFACE #define INTERFACE IHXWouldBlockResponse DECLARE_INTERFACE_(IHXWouldBlockResponse, IUnknown) { /* * IUnknown methods */ STDTQT_METHOD(QueryInterface) (THIS_ REFIID riid, void** ppvObj) PURE; STDMETHOD_(ULONG32,AddRef) (THIS) PURE; STDMETHOD_(ULONG32,Release) (THIS) PURE; /* * IHXWouldBlockResponse methods * */ /* * WouldBlock * * Return HXR_OK to go into blocked mode, causing a future * WouldBlockCleared call. HXR_anythingelse to ignore. */ STDTQT_METHOD(WouldBlock) (THIS_ UINT32 id) PURE; STDTQT_METHOD(WouldBlockCleared)(THIS_ UINT32 id) PURE; }; /**************************************************************************** * * Interface: * * IHXWouldBlock * * Purpose: * * Notifier for EWOULDBLOCK conditions. * * IID_IHXWouldBlock: * * {00000119-0901-11d1-8B06-00A024406D59} * */ DEFINE_GUID(IID_IHXWouldBlock, 0x00000119, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59); #undef INTERFACE #define INTERFACE IHXWouldBlock DECLARE_INTERFACE_(IHXWouldBlock, IUnknown) { /* * IUnknown methods */ STDTQT_METHOD(QueryInterface) (THIS_ REFIID riid, void** ppvObj) PURE; STDMETHOD_(ULONG32,AddRef) (THIS) PURE; STDMETHOD_(ULONG32,Release) (THIS) PURE; /* * IHXWouldBlock methods * */ STDTQT_METHOD(WantWouldBlock) (THIS_ IHXWouldBlockResponse*, UINT32 id) PURE; }; /**************************************************************************** * * Interface: * * IHXSharedUDPServices * * Purpose: * * Private interface for tying a UDP socket (via IHXUDPSocketContext) to * a shared UDP resend port. Used to send UDP packet resend requests to one * shared UDP port per streamer. * * IID_IHXSharedUDPServices * * {00000123-0901-11d1-8B06-00A024406D59} * */ DEFINE_GUID(IID_IHXSharedUDPServices, 0x00000124, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59); #undef INTERFACE #define INTERFACE IHXSharedUDPServices DECLARE_INTERFACE_(IHXSharedUDPServices, IUnknown) { /* * IUnknown methods */ STDTQT_METHOD(QueryInterface) (THIS_ REFIID riid, void** ppvObj) PURE; STDMETHOD_(ULONG32,AddRef) (THIS) PURE; STDMETHOD_(ULONG32,Release) (THIS) PURE; /* * IHXSharedUDPServices methods */ STDTQT_METHOD(RegisterSharedResponse) (THIS_ IHXUDPResponse* response, UINT16 sPortEnum) PURE; STDTQT_METHOD(UnregisterSharedResponse) (THIS) PURE; STDMETHOD_(UINT16, GetSharedPort) (THIS) PURE; }; /**************************************************************************** * * Interface: * * IHXThreadLocal * * Purpose: * * Thread-local information, namely the procnum. * * IID_IHXThreadLocal * * {00000125-0901-11d1-8B06-00A024406D59} * */ DEFINE_GUID(IID_IHXThreadLocal, 0x00000125, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59); #undef INTERFACE #define INTERFACE IHXThreadLocal #define CLSID_IHXThreadLocal IID_IHXThreadLocal DECLARE_INTERFACE_(IHXThreadLocal, IUnknown) { /* * IUnknown methods */ STDTQT_METHOD(QueryInterface) (THIS_ REFIID riid, void** ppvObj) PURE; STDMETHOD_(ULONG32,AddRef) (THIS) PURE; STDMETHOD_(ULONG32,Release) (THIS) PURE; /* * IHXThreadLocal methods */ /* * IHXThreadLocal::GetMaxThreads() * * Maximum number of threads on the system (MAX_THREADS on server) */ STDMETHOD_(int, GetMaxThreads) (THIS) PURE; /* * IHXThreadLocal::GetThreadNumber() * * This thread's number (< MAX_THREADS) */ STDMETHOD_(int, GetThreadNumber) (THIS) PURE; }; /**************************************************************************** * * Interface: * * IHXMemoryServices * * Purpose: * * Exposes server memory functions * * IID_IHXMemoryServices * * {00000126-0901-11d1-8B06-00A024406D59} * */ DEFINE_GUID(IID_IHXMemoryServices, 0x00000126, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59); #undef INTERFACE #define INTERFACE IHXMemoryServices #define CLSID_IHXMemoryServices IID_IHXMemoryServices DECLARE_INTERFACE_(IHXMemoryServices, IUnknown) { /* * IUnknown methods */ STDTQT_METHOD(QueryInterface) (THIS_ REFIID riid, void** ppvObj) PURE; STDMETHOD_(ULONG32,AddRef) (THIS) PURE; STDMETHOD_(ULONG32,Release) (THIS) PURE; /* * IHXMemoryServices methods */ /* * IHXMemoryServices::ValidateMemory() * * Make consistency checks on the server shared memory space. * * lStartPage, lPages * * Specifies a page range to allow smaller searches, if you have a * repro case and want to fail as soon as possible after the scribble. * Use lPages == 0 to check to the last page. (Pages in the shared * space are numbered starting from zero. You can decide on a range * based on the printout of previous errors.) * * ulFlags * * 0x00000001 fail -- abort() -- on finding an error. * 0x00000002 do rudimentary checks on internal SharedMemory data arrays. * */ STDTQT_METHOD(ValidateMemory) (THIS_ INT32 lStartPage, INT32 lPages, UINT32 ulFlags) PURE; }; typedef enum _HX_PRIVATE_SOCKET_OPTION { HX_PRIVATE_SOCKOPT_IGNORE_WSAECONNRESET } HX_PRIVATE_SOCKET_OPTION; /**************************************************************************** * * Interface: * * IHXSetPrivateSocketOption * * Purpose: * * Set private sockt option * * IID_IHXSetPrivateSocketOption: * * {00000127-0901-11d1-8B06-00A024406D59} * */ DEFINE_GUID(IID_IHXSetPrivateSocketOption, 0x00000127, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59); #undef INTERFACE #define INTERFACE IHXSetPrivateSocketOption DECLARE_INTERFACE_(IHXSetPrivateSocketOption, IUnknown) { /* * IUnknown methods */ STDTQT_METHOD(QueryInterface) (THIS_ REFIID riid, void** ppvObj) PURE; STDMETHOD_(ULONG32,AddRef) (THIS) PURE; STDMETHOD_(ULONG32,Release) (THIS) PURE; /* * IHXSetPrivateSocketOption methods */ STDTQT_METHOD(SetOption) (THIS_ HX_PRIVATE_SOCKET_OPTION option, UINT32 ulValue) PURE; }; /**************************************************************************** * * Interface: * * IHXNetInterfaces * * Purpose: * * Network Interfaces * * IID_IHXNetInterfaces: * * {00000128-0901-11d1-8B06-00A024406D59} * */ typedef enum { NI_UNKNOWN, NI_ETHERNET, NI_TOKENRING, NI_FDDI, NI_PPP, NI_LOOPBACK, NI_SLIP, NI_TUNNEL } NIType; // Operational status of the interface using the // values defined in RFC 2863. typedef enum { NI_OPER_STATUS_NON_OPERATIONAL= 0, NI_OPER_STATUS_UNREACHABLE, NI_OPER_STATUS_DISCONNECTED, NI_OPER_STATUS_CONNECTING, NI_OPER_STATUS_CONNECTED, NI_OPER_STATUS_OPERATIONAL } NIStatus; typedef enum { NI_ADDR_UNKNOWN, NI_ADDR_IPv4, NI_ADDR_IPv6 } NIAddressType; struct NIAddressInfo { NIAddressType type; IHXBuffer* pAddress; IHXBuffer* pSubnet; UINT32 ulSubnetPrefix; NIAddressInfo* next; NIAddressInfo() { type = NI_ADDR_UNKNOWN; pAddress = NULL; pSubnet = NULL; ulSubnetPrefix = 0; next = NULL; }; ~NIAddressInfo() { HX_RELEASE(pAddress); HX_RELEASE(pSubnet); next = NULL; }; }; struct NIInfo { NIType type; IHXBuffer* pDescription; NIStatus status; UINT32 ulIPv4Index; UINT32 ulIPv6Index; UINT32 ulMTU; NIAddressInfo* pAddressInfo; NIInfo() { type = NI_UNKNOWN; pDescription = NULL; status = NI_OPER_STATUS_NON_OPERATIONAL; ulIPv4Index = 0; ulIPv6Index = 0; ulMTU = 0; pAddressInfo = NULL; }; ~NIInfo() { HX_RELEASE(pDescription); NIAddressInfo* pTemp = pAddressInfo; while (pTemp) { pAddressInfo = pAddressInfo->next; HX_DELETE(pTemp); pTemp = pAddressInfo; } }; }; DEFINE_GUID(IID_IHXNetInterfaces, 0x00000128, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59); #undef INTERFACE #define INTERFACE IHXNetInterfaces DECLARE_INTERFACE_(IHXNetInterfaces, IUnknown) { /* * IUnknown methods */ STDTQT_METHOD(QueryInterface) (THIS_ REFIID riid, void** ppvObj) PURE; STDMETHOD_(ULONG32,AddRef) (THIS) PURE; STDMETHOD_(ULONG32,Release) (THIS) PURE; /* * IHXNetworkInterfaces methods */ STDTQT_METHOD(UpdateNetInterfaces) (THIS) PURE; STDMETHOD_(UINT32, GetNumOfNetInterfaces) (THIS) PURE; STDTQT_METHOD(GetNetInterfaces) (THIS_ UINT16 lIndex, REF(NIInfo*) pNIInfo) PURE; STDTQT_METHOD(AddAdviseSink) (THIS_ IHXNetInterfacesAdviseSink* pSink) PURE; STDTQT_METHOD(RemoveAdviseSink) (THIS_ IHXNetInterfacesAdviseSink* pSink) PURE; }; /**************************************************************************** * * Interface: * * IHXNetInterfacesAdviseSink * * Purpose: * * Network Interfaces Advise Sink * * IID_IHXNetInterfaces: * * {00000129-0901-11d1-8B06-00A024406D59} * */ DEFINE_GUID(IID_IHXNetInterfacesAdviseSink, 0x00000129, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59); #undef INTERFACE #define INTERFACE IHXNetInterfacesAdviseSink DECLARE_INTERFACE_(IHXNetInterfacesAdviseSink, IUnknown) { /* * IUnknown methods */ STDTQT_METHOD(QueryInterface) (THIS_ REFIID riid, void** ppvObj) PURE; STDMETHOD_(ULONG32,AddRef) (THIS) PURE; STDMETHOD_(ULONG32,Release) (THIS) PURE; /* * IHXNetInterfacesAdviseSink methods */ STDTQT_METHOD(NetInterfacesUpdated) (THIS) PURE; }; // $EndPrivate. /**************************************************************************** * * Interface: * * IHXNetworkInterfaceEnumerator * * Purpose: * * Enumerate interfaces on a box. * * IID_IHXNetworkInterfaceEnumerator; * * {00000121-0901-11d1-8B06-00A024406D59} * */ DEFINE_GUID(IID_IHXNetworkInterfaceEnumerator, 0x00000121, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59); #undef INTERFACE #define INTERFACE IHXNetworkInterfaceEnumerator DECLARE_INTERFACE_(IHXNetworkInterfaceEnumerator, IUnknown) { /* * IUnknown methods */ STDTQT_METHOD(QueryInterface) (THIS_ REFIID riid, void** ppvObj) PURE; STDMETHOD_(ULONG32,AddRef) (THIS) PURE; STDMETHOD_(ULONG32,Release) (THIS) PURE; /************************************************************************ * Method: * IHXNetworkInterfaceEnumerator::EnumerateInterfaces * Purpose: * returns a list of local interfaces * Usage: * If a buffer passed in is too small, it will return * HXR_BUFFERTOOSMALL with ulNumInterfaces updated. */ STDTQT_METHOD(EnumerateInterfaces) (THIS_ REF(UINT32*) pulInterfaces, REF(UINT32) ulNumInterfaces) PURE; }; /**************************************************************************** * * Interface: * * IHXUDPConnectedSocket * * Purpose: * * Connect and disconnect a UDP socket * * IID_IHXUDPConnectedSocket; * * {0000012A-0901-11d1-8B06-00A024406D59} * */ DEFINE_GUID(IID_IHXUDPConnectedSocket, 0x0000012a, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59); #undef INTERFACE #define INTERFACE IHXUDPConnectedSocket DECLARE_INTERFACE_(IHXUDPConnectedSocket, IUnknown) { /* * IUnknown methods */ STDTQT_METHOD(QueryInterface) (THIS_ REFIID riid, void** ppvObj) PURE; STDMETHOD_(ULONG32,AddRef) (THIS) PURE; STDMETHOD_(ULONG32,Release) (THIS) PURE; /************************************************************************ * Method: * IHXUDPConnectedSocket::UDPConnect * Purpose: * Connect the udp socket * Usage: * Connect to the foreign addr and port the socket already knows * about; this is implementation-dependent. */ STDTQT_METHOD(UDPConnect) (THIS) PURE; /************************************************************************ * Method: * IHXUDPConnectedSocket::UDPConnect(ULONG32 ulAddr, UINT16 nPort); * Purpose: * Connect the udp socket * Usage: * Specify the host-ordered foreign addr and port to connect to. */ STDTQT_METHOD(UDPConnect) (THIS_ ULONG32 ulAddr, UINT16 nPort) PURE; /************************************************************************ * Method: * IHXUDPConnectedSocket::UDPDisconnect * Purpose: * Disconnect the udp socket */ STDTQT_METHOD(UDPDisconnect) (THIS) PURE; /************************************************************************ * Method: * IHXUDPConnectedSocket::IsUDPConnected * Purpose: * Return whether the socket is connected. */ STDMETHOD_(HXBOOL, IsUDPConnected) (THIS) PURE; /************************************************************************ * Method: * IHXUDPConnectedSocket::IsUDPConnected(REF(ULONG32) ulAddr, * REF(UINT16) nPort) * Purpose: * Return whether the socket is connected, and the connected addr/port. * Usage: * Return the foreign addr/port the socket knows about, regardless of * whether it's connected. This is the foreign addr that is connected * to (if TRUE) or that will be used if Connect(void) called (if FALSE). */ STDMETHOD_(HXBOOL, IsUDPConnected) (THIS_ REF(ULONG32) ulAddr, REF(UINT16) nPort) PURE; }; /**************************************************************************** * * Interface: * * IHXAutoBWDetection * * Purpose: * * Auto Bandwidth Detection interface * * IID_IHXAutoBWDetection; * * {0000012b-0901-11d1-8B06-00A024406D59} * */ DEFINE_GUID(IID_IHXAutoBWDetection, 0x0000012b, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59); #undef INTERFACE #define INTERFACE IHXAutoBWDetection DECLARE_INTERFACE_(IHXAutoBWDetection, IUnknown) { /* * IUnknown methods */ STDTQT_METHOD(QueryInterface) (THIS_ REFIID riid, void** ppvObj) PURE; STDMETHOD_(ULONG32,AddRef) (THIS) PURE; STDMETHOD_(ULONG32,Release) (THIS) PURE; /* * IHXAutoBWDetection methods */ STDTQT_METHOD(InitAutoBWDetection) (THIS_ HXBOOL bEnabled) PURE; STDTQT_METHOD(AddAutoBWDetectionSink) (THIS_ IHXAutoBWDetectionAdviseSink* pSink) PURE; STDTQT_METHOD(RemoveAutoBWDetectionSink) (THIS_ IHXAutoBWDetectionAdviseSink* pSink) PURE; }; /**************************************************************************** * * Interface: * * IHXAutoBWDetectionAdviseSink * * Purpose: * * Auto Bandwidth Detection callback interface * * IID_IHXAutoBWDetectionAdviseSink: * * {0000012c-0901-11d1-8B06-00A024406D59} * */ DEFINE_GUID(IID_IHXAutoBWDetectionAdviseSink, 0x0000012c, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59); #undef INTERFACE #define INTERFACE IHXAutoBWDetectionAdviseSink DECLARE_INTERFACE_(IHXAutoBWDetectionAdviseSink, IUnknown) { /* * IUnknown methods */ STDTQT_METHOD(QueryInterface) (THIS_ REFIID riid, void** ppvObj) PURE; STDMETHOD_(ULONG32,AddRef) (THIS) PURE; STDMETHOD_(ULONG32,Release) (THIS) PURE; /* * IHXAutoBWDetectionAdviseSink methods */ STDTQT_METHOD(AutoBWDetectionDone) (THIS_ HX_RESULT status, UINT32 ulBW) PURE; }; /**************************************************************************** * * Interface: * * IHXAutoBWCalibration * * Purpose: * * Auto Bandwidth Calibration interface * * IID_IHXAutoBWDetection; * * {0000012d-0901-11d1-8B06-00A024406D59} * */ DEFINE_GUID(IID_IHXAutoBWCalibration, 0x0000012d, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59); #undef INTERFACE #define INTERFACE IHXAutoBWCalibration DECLARE_INTERFACE_(IHXAutoBWCalibration, IUnknown) { /* * IUnknown methods */ STDTQT_METHOD(QueryInterface) (THIS_ REFIID riid, void** ppvObj) PURE; STDMETHOD_(ULONG32,AddRef) (THIS) PURE; STDMETHOD_(ULONG32,Release) (THIS) PURE; /* * IHXAutoBWCalibration methods */ STDTQT_METHOD(InitAutoBWCalibration) (THIS_ IHXValues* pValues) PURE; STDTQT_METHOD(StartAutoBWCalibration) (THIS) PURE; STDTQT_METHOD(StopAutoBWCalibration) (THIS) PURE; STDTQT_METHOD(AddAutoBWCalibrationSink) (THIS_ IHXAutoBWCalibrationAdviseSink* pSink) PURE; STDTQT_METHOD(RemoveAutoBWCalibrationSink) (THIS_ IHXAutoBWCalibrationAdviseSink* pSink) PURE; }; /**************************************************************************** * * Interface: * * IHXAutoBWCalibrationAdviseSink * * Purpose: * * Auto Bandwidth Calibration callback interface * * IID_IHXAutoBWCalibrationAdviseSink: * * {0000012e-0901-11d1-8B06-00A024406D59} * */ DEFINE_GUID(IID_IHXAutoBWCalibrationAdviseSink, 0x0000012e, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59); #undef INTERFACE #define INTERFACE IHXAutoBWCalibrationAdviseSink DECLARE_INTERFACE_(IHXAutoBWCalibrationAdviseSink, IUnknown) { /* * IUnknown methods */ STDTQT_METHOD(QueryInterface) (THIS_ REFIID riid, void** ppvObj) PURE; STDMETHOD_(ULONG32,AddRef) (THIS) PURE; STDMETHOD_(ULONG32,Release) (THIS) PURE; /* * IHXAutoBWCalibrationAdviseSink methods */ STDTQT_METHOD(AutoBWCalibrationStarted) (THIS_ const char* pszServer) PURE; STDTQT_METHOD(AutoBWCalibrationDone) (THIS_ HX_RESULT status, UINT32 ulBW) PURE; }; /**************************************************************************** * * Interface: * * IHXConnectionBWAdviseSink * * Purpose: * * Manages * * IID_IHXConnectionBWAdviseSink * * {7568B47F-0C1A-4099-B84B-D425C9746737} * */ DEFINE_GUID(IID_IHXConnectionBWAdviseSink, 0x7568b47f, 0xc1a, 0x4099, 0xb8, 0x4b, 0xd4, 0x25, 0xc9, 0x74, 0x67, 0x37); #undef INTERFACE #define INTERFACE IHXConnectionBWAdviseSink DECLARE_INTERFACE_(IHXConnectionBWAdviseSink, IUnknown) { /* * IUnknown methods */ STDTQT_METHOD(QueryInterface) (THIS_ REFIID riid, void** ppvObj) PURE; STDMETHOD_(ULONG32,AddRef) (THIS) PURE; STDMETHOD_(ULONG32,Release) (THIS) PURE; /* * IHXConnectionBWAdviseSink methods */ STDTQT_METHOD(NewConnectionBW)(THIS_ UINT32 uConnectionBW) PURE; }; /**************************************************************************** * * Interface: * * IHXConnectionBWInfo * * Purpose: * * Manages * * IID_IHXConnectionBWInfo * * {9D1EDFB0-7A10-43f1-B008-8D0E00CA279F} * */ DEFINE_GUID(IID_IHXConnectionBWInfo, 0x9d1edfb0, 0x7a10, 0x43f1, 0xb0, 0x8, 0x8d, 0xe, 0x0, 0xca, 0x27, 0x9f); #undef INTERFACE #define INTERFACE IHXConnectionBWInfo DECLARE_INTERFACE_(IHXConnectionBWInfo, IUnknown) { /* * IUnknown methods */ STDTQT_METHOD(QueryInterface) (THIS_ REFIID riid, void** ppvObj) PURE; STDMETHOD_(ULONG32,AddRef) (THIS) PURE; STDMETHOD_(ULONG32,Release) (THIS) PURE; /* * IHXConnectionBWInfo methods */ STDTQT_METHOD(AddABDInfo)(THIS_ IHXAutoBWDetection* pABD, IHXPreferredTransport* pPrefTransport) PURE; STDTQT_METHOD(RemoveABDInfo)(THIS_ IHXAutoBWDetection* pABD) PURE; /* * IHXConnectionBWInfo::GetConnectionBW() * * Gets the current connection bandwidth estimate. * * Parameters: * uBW : The connection BW is stored in this parameter on return * bDetectedBWOnly : Specifies that only values derived from BW * detection are considered OK. * * Returns: * HXR_OK : uBW is set to the connection BW * HXR_INCOMPLETE : This is returned if bDetectedBWOnly is set * and there isn't any BW detection data available. * uBW will contain a connection BW based on user * preferences * HXR_FAILED : No connection BW is available at this time * */ STDTQT_METHOD(GetConnectionBW)(THIS_ REF(UINT32) uBw, HXBOOL bDetectedBWOnly) PURE; STDTQT_METHOD(AddSink)(THIS_ IHXConnectionBWAdviseSink* pSink) PURE; STDTQT_METHOD(RemoveSink)(THIS_ IHXConnectionBWAdviseSink* pSink) PURE; }; #endif /* _HXENGIN_H_ */