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

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

Symbian

开发平台：

C/C++

hxnetapi.h：源码内容
  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  36. #ifndef _HXNETAPI_H_
  37. #define _HXNETAPI_H_
  39. #if defined(_SYMBIAN)
  40. #include "platform/symbian/hxsymbiannetapi.h"
  41. #elif defined(_OPENWAVE)
  42. #include "platform/openwave/hxopwavenetapi.h"
  43. #else
  45. #include "conn.h"
  46. #include "hxengin.h"
  47. #include "hxslist.h"
  48. #include "hxpnets.h"
  49. #include "preftran.h"
  51. // necessary for authentication 
  52. #include "hxauthn.h"
  53. #include "hxathsp.h"
  54. #include "hxcomsp.h"
  55. #include "hxplnsp.h"
  57. #include "hxcloakedtcp.h"
  58. #include "hxsockcallback.h"
  59. #include "hxnetutil.h"
  61. struct IHXCloakedNetworkServices;
  62. struct IHXNetworkServices;
  63. struct IHXListenSocket;
  64. struct IHXTCPSocket;
  65. struct IHXUDPSocket;
  66. struct IHXInterruptState;
  67. struct IHXInterruptSafe;
  71. // for sockets
  72. #if defined(_WIN32) || defined(_WINDOWS)
  73. #include "platform/win/win_net.h"
  74. #elif defined(_OPENWAVE)
  75. #include "socketdefs.h"
  76. #elif defined(__TCS__)
  77. #include "sockio.h"
  78. #else
  79. #include "hlxclib/sys/socket.h"
  80. #endif
  82. class CByteGrowingQueue;
  84. class HXAsyncNetCallback;
  85. class HXMutex;
  86. class HXEvent;
  88. #ifdef _MACINTOSH
  90. struct IhxQueueElement 
  91. {
  92. IhxQueueElement  *mNextElementInQueue; // link must be first member
  93. IUnknown *mObject;
  94. };
  96. class InterruptSafeMacQueue 
  97. {
  98. protected:
  100. QHdr  mQueueHeader;
  101. Boolean mDestructing;
  103. public:
  105. InterruptSafeMacQueue(void);
  106. ~InterruptSafeMacQueue(void); // decrements the ref on the irma nodes (via release)
  108. IUnknown *  RemoveHead(void);
  109. HX_RESULT  AddTail(IUnknown* pObject); // increments the ref
  110. HX_RESULT TransferToSimpleList(CHXSimpleList &simpleList); // leaves the ref incremented
  111. };
  112. #endif // _MACINTOSH
  115. class HXNetworkServices : public IHXNetworkServices,
  116.    public IHXCloakedNetworkServices,
  117.    public IHXNetworkInterfaceEnumerator
  118. {
  119. public:
  120. HXNetworkServices(IUnknown* pContext);
  121. ~HXNetworkServices();
  122.     /* IUnknown interface */
  123.     STDMETHOD(QueryInterface)     (THIS_ 
  124.     REFIID riid, void** ppvObj);
  126.     STDMETHOD_(ULONG32,AddRef)     (THIS);
  128.     STDMETHOD_(ULONG32,Release)     (THIS);
  130.     /* IHXNetworkServices interface */
  131.     STDMETHOD(CreateTCPSocket)      (THIS_ 
  132.     IHXTCPSocket** ppTCPSocket);
  134.     STDMETHOD(CreateUDPSocket) (THIS_
  135. IHXUDPSocket**    /*OUT*/     ppUDPSocket);
  137.     STDMETHOD(CreateListenSocket)   (THIS_ 
  138.     IHXListenSocket** ppListenSocket);
  139.     STDMETHOD(CreateResolver)     (THIS_
  140.          IHXResolver** ppResolver);
  142.     /* IHXCloakedNetworkServices interface */
  143.     STDMETHOD(CreateClientCloakedSocket) (THIS_
  144. IHXTCPSocket**    /*OUT*/     ppTCPSocket);
  146.     STDMETHOD(CreateServerCloakedSocket) (THIS_
  147. IHXListenSocket**    /*OUT*/     ppListenSocket);
  150.     /* IHXNetworkInterfaceEnumerator methods */
  151.     STDMETHOD(EnumerateInterfaces) (THIS_
  152. REF(UINT32*) pulInterfaces, REF(UINT32) ulNumInterfaces);
  155.     void Close();
  156.     void UseDrivers();
  157. private:
  158.     LONG32                      m_lRefCount;
  159.     IUnknown* m_pContext;
  160.     BOOL m_bNeedToCleanupDrivers;
  161. #if !defined(HELIX_CONFIG_NOSTATICS)
  162.     static UINT16 z_muNumDriverInstance;
  163. #else
  164.     static const UINT16 z_muNumDriverInstance;
  165. #endif
  166. };
  168. class HXResolver: public IHXResolver
  169. {
  170. public:
  171.      HXResolver(HXNetworkServices* pNetworkServices);
  172.      ~HXResolver();
  173.                                 HXResolver(HXNetworkServices* pNetworkServices,
  174.                                             IUnknown*           pContext );
  175.                                 
  176.     STDMETHOD(QueryInterface)   (THIS_ REFIID riid, void** ppvObj);
  177.     STDMETHOD_(ULONG32,AddRef)  (THIS);
  178.     STDMETHOD_(ULONG32,Release) (THIS);
  179.     STDMETHOD(Init)             (THIS_ IHXResolverResponse* pResp);
  180.     STDMETHOD(GetHostByName)    (THIS_ const char* pHostName);
  182. private:
  183.     class HXResolverCallback: public HXAsyncNetCallback
  184.     {
  185.     public:
  186. HX_RESULT Func(NotificationType Type, BOOL bSuccess = TRUE, conn* pConn = NULL);
  187. HXResolver* m_pContext;
  188.     };
  189.     friend class HXResolverCallback;
  191.     void    DNSDone(BOOL bSuccess);
  193.     HXResolverCallback* m_pCallback;
  195.     LONG32                      m_lRefCount;
  196.     IHXResolverResponse*       m_pResp;
  197.     BOOL m_bResolverPending;
  198.     conn* m_pData;
  199.     HXNetworkServices* m_pNetworkServices;
  200.     IUnknown*                   m_pContext;
  201. };
  203. class HXUDPSocket : public IHXUDPSocket,
  204.      public IHXSetSocketOption,
  205.      public SocketCallbackInterface,
  206.      public IHXUDPMulticastInit,
  207.      public IHXSetPrivateSocketOption
  208. {
  209. public:
  210. HXUDPSocket(IUnknown* pContext, HXNetworkServices* pNetworkServices);
  211. ~HXUDPSocket();
  212.     /* IUnknown interface */
  213.     STDMETHOD(QueryInterface) (THIS_ 
  214. REFIID riid, void** ppvObj);
  216.     STDMETHOD_(ULONG32,AddRef) (THIS);
  218.     STDMETHOD_(ULONG32,Release) (THIS);
  220.    /* SocketCallbackInterface interface */
  221.   enum {
  222. UDP_READ_COMMAND,
  223. UDP_WRITE_COMMAND,
  224. UDP_BIND_COMMAND
  225. };
  226. STDMETHODIMP HandleCallback(INT32 theCommand, HX_RESULT theError);
  228.     /* IHXUDPSocket interface */
  229.     STDMETHOD(Init) (THIS_
  230. ULONG32 ulAddr,
  231. UINT16 nPort,
  232. IHXUDPResponse* pUDPResponse);
  234.     STDMETHOD(Bind) (THIS_
  235. UINT32 ulLocalAddr,
  236. UINT16  nPort);
  238.     STDMETHOD(Read) (THIS_
  239. UINT16 Size);
  241.     STDMETHOD(Write) (THIS_
  242. IHXBuffer* pBuffer);
  244.     STDMETHOD(WriteTo) (THIS_
  245.      ULONG32 ulAddr,
  246. UINT16 nPort,
  247. IHXBuffer* pBuffer);
  249.     STDMETHOD(GetLocalPort) (THIS_
  250.      UINT16& nPort);
  252.     STDMETHOD(JoinMulticastGroup) (THIS_
  253.      ULONG32     ulMulticastAddr,
  254.      ULONG32     ulInterfaceAddr);
  256.     STDMETHOD(LeaveMulticastGroup) (THIS_
  257.      ULONG32     ulMulticastAddr,
  258.      ULONG32     ulInterfaceAddr);
  260.     /*
  261.      * IHXUDPMulticastInit methods
  262.      */
  263.  
  264.     STDMETHOD(InitMulticast)            (THIS_
  265.                                          UINT8       ulTTL);
  267.     /*
  268.      * IHXListenSocket methods
  269.      */
  270.     STDMETHOD(SetOption) (THIS_ 
  271.  HX_SOCKET_OPTION option,
  272.  UINT32 ulValue);
  273.     /*
  274.      * IHXSetPrivateSocketOption methods
  275.      */
  276.     STDMETHOD(SetOption) (THIS_ 
  277.  HX_PRIVATE_SOCKET_OPTION option,
  278.  UINT32 ulValue);    
  280.     class UDPSocketCallback: public HXAsyncNetCallback
  281.     {
  282.     public:
  283. HX_RESULT Func(NotificationType Type, BOOL bSuccess = TRUE, conn* pConn = NULL);
  284. HXUDPSocket* m_pContext;
  285.     };
  286.     friend class UDPSocketCallback;
  288.   private:
  289.     IUnknown*                   m_pContext;
  290.     HX_RESULT DoRead();
  291.     HX_RESULT DoWrite();
  292.     BOOL IsSafe();
  293.     LONG32                      m_lRefCount;
  294.     IHXUDPResponse* m_pUDPResponse;
  295.     conn* m_pData;
  296.     struct sockaddr_in m_sockAddr;
  297.     HX_BITFIELD m_bReadPending : 1;
  298.     HX_BITFIELD m_bInRead : 1;
  299.     HX_BITFIELD m_bInDoRead : 1;
  300.     HX_BITFIELD m_bInWrite : 1;
  301.     UINT32 m_nRequired;
  302.     CHXSimpleList m_ReadBuffers;
  303.     CHXSimpleList m_WriteBuffers;
  304.     IHXScheduler* m_pScheduler;
  305.     UDPSocketCallback* m_pCallback;
  306.     ScheduledSocketCallback* m_pSchedulerReadCallback;
  307.     ScheduledSocketCallback* m_pSchedulerWriteCallback;
  308.     ScheduledSocketCallback* m_pNonInterruptReadCallback;
  309.     UINT16 m_nDestPort;
  310.     HX_BITFIELD m_bInitComplete : 1;
  311.     IHXInterruptState* m_pInterruptState;
  312.     IHXInterruptSafe* m_pResponseInterruptSafe;
  313.     HXMutex* m_pMutex;
  314.     HX_BITFIELD m_bInDestructor : 1;
  315.     HXNetworkServices* m_pNetworkServices;
  316. #ifdef _MACINTOSH
  317. InterruptSafeMacQueue* m_pInterruptSafeMacWriteQueue; // only instantiated on the mac
  318. #endif
  320.     BOOL m_bReuseAddr;
  321.     BOOL m_bReusePort;    
  322. };
  324. class HXTCPSocket : public IHXTCPSocket,
  325.      public IHXSetSocketOption,
  326.      public SocketCallbackInterface,
  327.      public IHXTCPSecureSocket
  328. {
  329. public:
  330. HXTCPSocket(IUnknown* pContext, HXNetworkServices* pNetworkServices);
  331. ~HXTCPSocket();
  332.     
  333.     /* IUnknown interface */
  334.     STDMETHOD(QueryInterface)   (THIS_ 
  335. REFIID riid, void** ppvObj);
  337.     STDMETHOD_(ULONG32,AddRef)  (THIS);
  339.     STDMETHOD_(ULONG32,Release) (THIS);
  341.    /* SocketCallbackInterface interface */
  342.   enum {
  343. TCP_READ_COMMAND,
  344. TCP_WRITE_COMMAND,
  345. TCP_BIND_COMMAND,
  346. TCP_READ_DONE_COMMAND,
  347. TCP_CONNECT_DONE_COMMAND
  348. };
  349. STDMETHODIMP HandleCallback(INT32 theCommand, HX_RESULT theError);
  351.     /*
  352.      *  IHXTCPSocket methods
  353.      */
  355.     STDMETHOD(Init) (THIS_
  356. IHXTCPResponse*    /*IN*/  pTCPResponse);
  358.     STDMETHOD(SetResponse) (THIS_
  359. IHXTCPResponse*    /*IN*/  pTCPResponse);
  361.     STDMETHOD(Bind) (THIS_
  362. UINT32     ulLocalAddr,
  363. UINT16      nPort);
  365.     STDMETHOD(Connect) (THIS_
  366. const char*     pDestination,
  367. UINT16     nPort);
  369.     STDMETHOD(Read) (THIS_
  370. UINT16     uSize);
  372.     STDMETHOD(Write) (THIS_
  373. IHXBuffer*     pBuffer);
  375.     STDMETHOD(WantWrite) (THIS);
  377.     STDMETHOD(GetLocalAddress) (THIS_
  378. UINT32&     lAddress);
  379.     STDMETHOD(GetForeignAddress)(THIS_
  380. UINT32&     lAddress);
  381.     STDMETHOD(GetLocalPort) (THIS_
  382.      UINT16&     nPort);
  383.     STDMETHOD(GetForeignPort) (THIS_
  384.      UINT16&     nPort);
  386.     /*
  387.      * IHXTCPSecureSocket
  388.      */
  389.     
  390.     STDMETHOD(SetSecure) (THIS_
  391.      BOOL bSecure);
  392.     
  393.     /*
  394.      * IHXListenSocket methods
  395.      */
  396.     STDMETHOD(SetOption) (THIS_ 
  397.  HX_SOCKET_OPTION option,
  398.  UINT32 ulValue);
  400.     class TCPSocketCallback: public HXAsyncNetCallback
  401.     {
  402.     public:
  403. HX_RESULT Func(NotificationType Type, BOOL bSuccess = TRUE, conn* pConn = NULL);
  404. HXTCPSocket* m_pContext;
  405.     };
  406.    friend class TCPSocketCallback;
  408.     STDMETHOD(AcceptConnection) (THIS_ conn* pNewCon);
  410. private:
  411.     HX_RESULT DoRead();
  412.     HX_RESULT DoWrite();
  413.     void CloseDone();
  414.     void DNSDone(BOOL bSuccess);
  415.     void TransferBuffers();
  416.     void ConnectDone(BOOL bResult);
  417.     BOOL IsSafe();
  419.     LONG32                      m_lRefCount;
  420.     IHXTCPResponse* m_pTCPResponse;
  421.     conn* m_pCtrl;
  422.     UINT32 m_lForeignAddress;
  423.     UINT16 m_nForeignPort : 16;
  424.     UINT16 m_nRequired : 16;
  425.     HX_BITFIELD m_bReadPending : 1;
  426.     HX_BITFIELD m_bConnected : 1;
  427.     HX_BITFIELD m_bWantWritePending : 1;
  428.     HX_BITFIELD m_bInitComplete : 1;
  429.     HX_BITFIELD m_bInDestructor : 1;
  430.     HX_BITFIELD m_bInRead : 1;
  431.     HX_BITFIELD m_bInDoRead : 1;
  432.     HX_BITFIELD m_bInWrite : 1;
  433.     HX_BITFIELD m_bWriteFlushPending : 1;
  434.     CByteGrowingQueue* mSendTCP;
  435.     CByteGrowingQueue* mReceiveTCP;
  436.     CHXSimpleList m_PendingWriteBuffers;
  437.     char* m_pBuffer;
  438.     TCPSocketCallback* m_pCallback;
  439.     UINT16 m_nLocalPort;
  440.     IHXScheduler* m_pScheduler;
  441.     ScheduledSocketCallback* m_pSchedulerReadCallback;
  442.     ScheduledSocketCallback* m_pSchedulerWriteCallback;
  443.     ScheduledSocketCallback* m_pNonInterruptReadCallback;
  444. #ifdef _MACINTOSH
  445. ScheduledSocketCallback*  m_pMacCommandCallback;
  446. InterruptSafeMacQueue* m_pInterruptSafeMacWriteQueue; // only instantiated on the mac
  447. #endif
  449.     IHXInterruptState* m_pInterruptState;
  450.     IHXInterruptSafe* m_pResponseInterruptSafe;
  451.     HXMutex* m_pMutex;
  452.     HXNetworkServices* m_pNetworkServices;
  453.     IHXPreferences* m_pPreferences;
  455.     BOOL m_bReuseAddr;
  456.     BOOL m_bReusePort;
  457.     IUnknown*                   m_pContext;
  458.     BOOL m_bSecureSocket;
  459. };
  461. class HXListenSocket : public IHXListenSocket,
  462. public IHXSetSocketOption
  463. {
  464. public:
  465. HXListenSocket(IUnknown* pContext, HXNetworkServices* pNetworkServices);
  466. ~HXListenSocket();
  468.     /* IUnknown interface */
  469.     STDMETHOD(QueryInterface)   (THIS_ 
  470. REFIID riid, void** ppvObj);
  472.     STDMETHOD_(ULONG32,AddRef)  (THIS);
  474.     STDMETHOD_(ULONG32,Release) (THIS);
  476.     /*
  477.      *  IHXListenSocket methods
  478.      */
  480.     STDMETHOD(Init) (THIS_
  481. UINT32 ulLocalAddr,
  482. UINT16 port,
  483. IHXListenResponse*    /*IN*/ pListenResponse);
  484.     /*
  485.      * IHXSetSocketOption methods
  486.      */
  487.     STDMETHOD(SetOption) (THIS_ 
  488.  HX_SOCKET_OPTION option,
  489.  UINT32 ulValue);
  491.     class ListenSocketCallback: public HXAsyncNetCallback
  492.     {
  493.     public:
  494. HX_RESULT Func(NotificationType Type, BOOL bSuccess = TRUE, conn* pConn = NULL);
  495. HXListenSocket* m_pContext;
  496.     };
  497.     friend class ListenSocketCallback;
  500. private:
  501.     LONG32                      m_lRefCount;
  502.     IHXListenResponse* m_pListenResponse;
  503.     HXNetworkServices* m_pNetworkServices;
  504.     IUnknown* m_pContext;
  506.     conn* m_pListenConn;
  507.     ListenSocketCallback* m_pCallback;
  508.     BOOL m_bReuseAddr;
  509.     BOOL m_bReusePort;
  510. };
  512. #endif /* defined(_SYMBIAN) */
  514. #endif /*_HXNETAPI_H_*/