ot_net.h
上传用户:zhongxx05
上传日期:2007-06-06
资源大小:33641k
文件大小:10k
源码类别:

Symbian

开发平台:

C/C++

  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 ***** */ 
  35. #pragma once
  36. #ifndef _OT_NET
  37. #define _OT_NET
  38. #include "conn.h"
  39. #ifndef _MAC_MACHO
  40. #include <OpenTransport.h>
  41. #include <OpenTptInternet.h>
  42. #endif
  43. #define kBufSize 256
  44. typedef struct OTSvcInfo  // Open Transport Internet services provider info 
  45. {
  46. InetSvcRef ref; // provider reference 
  47. Boolean complete; // true when asynch operation has completed 
  48. OTResult result; // result code 
  49. void *cookie; // cookie 
  50. } OTSvcInfo;
  51. #if 0
  52. enum
  53. {
  54. netOpenDriverErr = 100,
  55. netOpenStreamErr,
  56. netLostConnectionErr,
  57. netDNRErr,
  58. netTruncatedErr
  59. };
  60. #endif
  61. // CB Added
  62. typedef struct MyOTInfo
  63. {
  64. const char*  hostName;
  65. InetHostInfo hostInfo;
  66. InetSvcRef   inetSvcRef;
  67. Boolean      complete;
  68. } MyOTInfo;
  69. struct OTCallbackInfo
  70. {
  71.     OTCallbackInfo(OTEventCode code, OTResult result, void* cookie)
  72.     {
  73.         m_Code   = code;
  74.         m_Result = result; 
  75.         m_Cookie = cookie;
  76.     }
  77.     
  78.     OTEventCode m_Code;
  79.     OTResult    m_Result; 
  80.     void*       m_Cookie;
  81. };
  82. class CHXSimpleList;
  83. class OT_net : public conn {
  84. public:
  85. /*  call new_socket() to automatically create the correct platform specific network object.
  86. The type parameter may be either HX_TCP_SOCKET or HX_UDP_SOCKET. If new_socket() returns 
  87. NULL, an error occurred and the conn object was not created. Call last_error() to get the error */
  88. static OT_net *new_socket  (UINT16 type);
  89.     ~OT_net (void);
  90. /*  call init_drivers() to do any platform specific initialization of the network drivers
  91. before calling any other functions in this class */
  92. static HX_RESULT init_drivers  (void *params);
  93. /*  close_drivers() should close any network drivers used by the program
  94.   NOTE: The program MUST not make any other calls to the network drivers
  95.   until init_drivers() has been called */
  96. static HX_RESULT close_drivers  (void *params);
  97. /*  host_to_ip_str() converts the host name to an ASCII ip address of
  98. the form "XXX.XXX.XXX.XXX" */
  99. static  HX_RESULT  host_to_ip_str (char *host, char *ip, UINT32 ulIPBufLen);
  100. /*  call done() when you are finished with the socket. Done() will close the socket.
  101. You may reuse the socket by calling init() or connect() */
  102. /* join_multicast_group() has this socket join a multicast group */
  103. // Note: Only the UDP subclass object supports multicast
  104. virtual HX_RESULT join_multicast_group 
  105.     (ULONG32 addr, ULONG32 if_addr = HX_INADDR_ANY) {return HXR_INVALID_OPERATION;};
  106. virtual HX_RESULT leave_multicast_group
  107.     (ULONG32 addr, ULONG32 if_addr = HX_INADDR_ANY) {return HXR_INVALID_OPERATION;};
  108. virtual HX_RESULT set_broadcast(BOOL enable) {return HXR_INVALID_OPERATION;};
  109. virtual HX_RESULT set_multicast_if(UINT32 ulInterface){return HXR_INVALID_OPERATION;};
  110. virtual void done (void);
  111. virtual ULONG32     AddRef     (void);
  112. virtual ULONG32     Release     (void);
  113. virtual HX_RESULT init (UINT32 local_addr,
  114.  UINT16  port, 
  115.  UINT16  blocking=0) = 0;
  116.  
  117. virtual HX_RESULT listen (ULONG32 ulLocalAddr,
  118.  UINT16 port,
  119.  UINT16  backlog,
  120.  UINT16 blocking,
  121.  ULONG32 ulPlatform) = 0;
  122. virtual HX_RESULT connect (const char *host, 
  123.  UINT16  port,
  124.  UINT16  blocking=0,
  125.  ULONG32 ulPlatform=0 ) = 0;
  126. virtual HX_RESULT blocking (void);
  127. virtual HX_RESULT nonblocking (void);
  128. virtual HX_RESULT read (void  *buf, 
  129.  UINT16  *size) = 0;
  130. virtual HX_RESULT readfrom (REF(IHXBuffer*)   pBuffer,
  131.  REF(UINT32)     ulAddress,
  132.  REF(UINT16)     ulPort) = 0;
  133. virtual HX_RESULT write (void  *buf,
  134.  UINT16  *size) = 0;
  135. virtual HX_RESULT writeto (void  *buf,
  136.  UINT16  *size, 
  137.  ULONG32  addr,
  138.  UINT16  port) {return HXR_INVALID_OPERATION;};
  139. virtual ULONG32 get_addr (void) {return mRemoteHost;};
  140. virtual UINT16 get_local_port (void) {return mLocalPort;};
  141.  
  142. // Open Tranport Stuff
  143. /* NetHaveOT() returns true if Open Transport TCP is installed and available */
  144. static Boolean NetHaveOT  (void);
  145. /* NetInit  initializes the Open Transport drivers */
  146. static  HX_RESULT  NetInit  (void);
  147. /*  NetInit  looks up the IP address of host, and returns the IP address in addr
  148. if the host string contains :port, then the port is returned in port 
  149. else the default port specified by defaultPort is returned in port */
  150. static HX_RESULT lookup_host  (char *name, 
  151.  ULONG32 *addr, 
  152.  UINT16 *port,
  153.  UINT16 defaultPort = 0);
  154. virtual HX_RESULT dns_find_ip_addr (const char * host, UINT16 blocking=0);
  155. virtual BOOL dns_ip_addr_found(BOOL * valid, ULONG32 *addr);
  156. static HX_RESULT  NetGetMyAddr  (unsigned long *addr);
  157. static  HX_RESULT           NetGetIfaceInfo(InetInterfaceInfo* ifaceInfo);
  158. protected:
  159. OT_net (void);
  160. static Boolean  sCheckedOT; // have we checked already for OT
  161. static Boolean  sHaveOT; // TRUE: OT and OT TCP are present
  162. static  Boolean  sMacAddressValid;
  163. static  Boolean  sMacAddressStrValid;
  164. static  ULONG32  sMacAddress;
  165. static  char  sMacAddrStr[16]; /* Flawfinder: ignore */
  166. // Open Tranport Stuff
  167. HX_RESULT OTWait  (void);
  168. static HX_RESULT OTSvcWait  (OTSvcInfo *svcInfo);
  169. static pascal void  NotifyProc      (OT_net *s, 
  170.       OTEventCode code,
  171.       OTResult result, 
  172.       void *cookie);
  173. static pascal void  SvcNotifyProc  (void *stream, 
  174.  OTEventCode code,
  175.  OTResult result, 
  176.  void *cookie );
  177. static pascal void MyOTNotifyProc
  178. (
  179. void*  contextPtr, 
  180. OTEventCode  code,
  181. OTResult  result, 
  182. void*  cookie
  183. );
  184. static pascal void UDPTCPNotifyProc
  185. (
  186. void*  contextPtr, 
  187. OTEventCode  code,
  188. OTResult  result, 
  189. void*  cookie
  190. );
  191. static  HX_RESULT  OpenInetServices (OTSvcInfo *svcInfo);
  192. static HX_RESULT  NetGetMyAddrStr (char *addrStr);
  193.    HX_RESULT  NetNameToAddr  (char *name, 
  194.  unsigned short defaultPort, 
  195.  unsigned long *addr, 
  196.  unsigned short *port);
  197. static HX_RESULT NetAddrToName  (unsigned long addr, 
  198.  InetDomainName name);
  199. char *mActiveName;
  200. ULONG32 mRemoteHost; // IP address of server
  201. UINT16 mRemotePort; // port number on server
  202. UINT16  mLocalPort; // local port number */
  203. LONG32  mResponseCode; // last response code received on stream 
  204. Boolean  mClosing; // true when closing stream 
  205. Boolean  mOtherSideHasClosed; // true when other side has closed its end of the stream 
  206. Boolean  mWeHaveClosed; // true when we have closed our end of the stream 
  207. Boolean  mRelease; // true when stream should be released 
  208. Boolean mStartedReceivingData;  // used by Release to determine if ok to OTSndOrderlyDisconnect 
  209. Boolean mDataArrived; // flag to indicate data is waiting to be read
  210. Boolean mDataFlowOn; // flag to indicate data flow control is currently on
  211. EndpointRef mRef; // endpoint reference 
  212. Boolean  mComplete; // true when asynch operation has completed 
  213. OTEventCode mCode; // event code 
  214. OTResult  mResult; // result 
  215. void  *mCookie; // cookie 
  216. char  mBuf[kBufSize]; // data buffer /* Flawfinder: ignore */
  217. HX_RESULT mAsyncError;
  218. LONG32 m_lRefCount;
  219. CHXSimpleList* m_pPendingCallbackListOne;
  220. CHXSimpleList* m_pPendingCallbackListTwo;
  221. BOOL m_bUsingListOne;
  222. BOOL m_bUsingListTwo;
  223. BOOL m_bIsQuitting;
  224. BOOL   m_bDeferredTaskPending;
  225. //#define _USE_OT_DEFER 1
  226. #ifdef _USE_OT_DEFER
  227. long    m_OTDeferredCookie;
  228.      static pascal void DeferredTaskProc(void* param);
  229. #else
  230. DeferredTask m_DeferredTaskStruct;
  231.      static pascal void DeferredTaskProc(long param);
  232. #endif
  233.     
  234.     void AddToThePendingList(void* pNode);
  235.     void CleanupPendingLists();
  236.     void ProcessPendingCallbacks();
  237. virtual void ProcessCmd(OTEventCode code, OTResult result, void* cookie) {};
  238. static OTResult GetFourByteOption(EndpointRef ep,
  239.                            OTXTILevel level,
  240.                            OTXTIName  name,
  241.                            UInt32   *value);
  242.                            
  243. static OTResult SetFourByteOption(EndpointRef ep,
  244.                            OTXTILevel level,
  245.                            OTXTIName  name,
  246.                            UInt32    value);
  247. #ifdef _CARBON
  248. static OTClientContextPtr sOToutClientContext;
  249. #endif
  250. };
  251. #endif // _OT_NET