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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
hxengin.h
资源名称：142_61_thumb_advanced.rar　[点击查看]
上传用户：dangjiwu
上传日期：2013-07-19
资源大小：42019k
文件大小：64k
源码类别：

Symbian

开发平台：

Visual C++

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