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

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. #ifndef _WIN_NET
  36. #define _WIN_NET
  37. #include "hlxclib/sys/types.h"
  38. #include <stdio.h>
  39. #include <winsock.h>
  40. #include "conn.h"
  41. #include "hxmap.h"
  42. // Predeclare this guy
  43. #ifndef WIN32_PLATFORM_PSPC
  44. class CAsyncSockN;
  45. class HXAsyncNetCallback;
  46. #endif
  47. class win_net : public conn 
  48. {
  49. public:
  50. /*  call new_socket() to automatically create the correct platform specific network object.
  51.     The type parameter may be either HX_TCP_SOCKET or HX_UDP_SOCKET. If new_socket() returns 
  52.     NULL, an error occurred and the conn object was not created. Call last_error() to get the error */
  53.     
  54.     static win_net *new_socket  (UINT16 type);
  55. ~win_net (void);
  56. /* call init_drivers() to do any platform specific initialization of the network drivers
  57.     before calling any other functions in this class */
  58.     
  59.     static HX_RESULT init_drivers  (void *params);
  60. /*  close_drivers() should close any network drivers used by the program
  61.     NOTE: The program MUST not make any other calls to the network drivers
  62.     until init_drivers() has been called */
  63.     static HX_RESULT close_drivers  (void *params);
  64. /*  host_to_ip_str() converts the host name to an ASCII ip address of
  65.     the form "XXX.XXX.XXX.XXX" */
  66.     static  HX_RESULT  host_to_ip_str (char *host, char *ip, UINT32 ulIPBufLen);
  67. /*  call done() when you are finsihed with the socket. Done() will close the socket.
  68.     You may reuse the socket by calling init() or connect() */
  69.     static HX_RESULT get_host_name(char *name, int namelen);
  70.     static HX_RESULT get_host_by_name(char *name, REF(struct hostent*) pHostent);
  71.     
  72.     virtual void        done            (void);
  73.     virtual ULONG32     AddRef     (void);
  74.     virtual ULONG32     Release     (void);
  75.     
  76.     // just for DNS for hostname...
  77.     // is introduced for RTSP...
  78.     virtual HX_RESULT dns_find_ip_addr (const char * host, UINT16 blocking=0);
  79.     virtual BOOL dns_ip_addr_found(BOOL * valid, ULONG32 *addr);
  80.     virtual HX_RESULT init (UINT32 local_addr,
  81.  UINT16  port, 
  82.  UINT16  blocking=0)=0;
  83.      
  84.     virtual HX_RESULT init_win (UINT16 type, 
  85.  UINT32 local_addr,
  86.  UINT16  port, 
  87.  UINT16  blocking=0);
  88.      
  89.     virtual HX_RESULT listen (ULONG32 ulAddr,
  90.  UINT16 port,
  91.  UINT16 backlog,
  92.  UINT16 blocking = 0,
  93.  ULONG32 ulPlatform = 0);
  94.     
  95.     virtual HX_RESULT connect (const char *host, 
  96.  UINT16  port,
  97.  UINT16  blocking=0,
  98.  ULONG32 ulPlatform=0);
  99.     
  100.     virtual HX_RESULT connect (sockaddr_in *addr);
  101.     virtual HX_RESULT blocking (void);
  102.     
  103.     virtual HX_RESULT nonblocking (void);
  104.     
  105.     virtual HX_RESULT read (void  *buf, 
  106.  UINT16  *size);
  107.     virtual HX_RESULT readfrom (REF(IHXBuffer*)   pBuffer,
  108.  REF(UINT32)     ulAddress,
  109.  REF(UINT16)     ulPort);
  110.     
  111.     virtual HX_RESULT write (void  *buf,
  112.  UINT16  *size);
  113.     virtual HX_RESULT writeto (void  *buf,
  114.  UINT16  *len, 
  115.  ULONG32  addr,
  116.  UINT16  port);
  117.     virtual BOOL        set_receive_buf_size (int DesiredSize);
  118.     virtual UINT16 connection_really_open (void) {return m_SocketState == CONN_OPEN;};
  119.     /* don't make sense for TCP */
  120.     virtual HX_RESULT join_multicast_group(ULONG32 addr, ULONG32 if_addr)
  121.     {
  122.      return HXR_INVALID_OPERATION;
  123.     }
  124.     virtual HX_RESULT leave_multicast_group(ULONG32 addr, ULONG32 if_addr)
  125.     {
  126.      return HXR_INVALID_OPERATION;
  127.     }
  128.     virtual HX_RESULT set_broadcast(BOOL enable)
  129.     {
  130.      return HXR_INVALID_OPERATION;
  131.     }  
  132.     virtual HX_RESULT set_multicast_if(ULONG32 ulInterface)
  133.     {
  134.      return HXR_INVALID_OPERATION;
  135.     }
  136.     virtual HX_RESULT set_send_size(ULONG32 send_size)
  137.     {
  138. return HXR_INVALID_OPERATION;
  139.     }
  140.     virtual HX_RESULT set_multicast()
  141.     {
  142. return HXR_INVALID_OPERATION;
  143.     }
  144.     virtual HX_RESULT set_multicast_ttl(unsigned char ttl)
  145.     {
  146. return HXR_INVALID_OPERATION;
  147.     }
  148.     virtual HX_RESULT reuse_addr(BOOL enable);
  149.     virtual HX_RESULT reuse_port(BOOL enable);    
  150.     virtual ULONG32 get_addr (void) ;
  151.     virtual UINT16 get_local_port (void) ;
  152.     
  153.     // we need it for dns_find_ip_addr since async stuff needs a window handle...
  154.     virtual HX_RESULT  SetWindowHandle(ULONG32 handle);
  155.     virtual void IgnoreWSAECONNRESET(BOOL b) {m_bIgnoreWSAECONNRESET = b;}
  156. #if defined(HELIX_FEATURE_NETWORK_USE_SELECT)
  157.     virtual HX_RESULT WaitforSelect(void *,void *);
  158.     virtual HX_RESULT CheckForConnection();
  159. #endif HELIX_FEATURE_NETWORK_USE_SELECT
  160.     
  161. private:
  162.     virtual HX_RESULT connect_accept (ULONG32 ulPlatform, sockaddr_in Addr);
  163.     char* m_pInBuffer;
  164.     static int zm_LibRefCount;
  165.     static CHXMapPtrToPtr zm_MapObjectsToWinsockTasks;
  166.     static CHXMapPtrToPtr zm_WinsockTasksRefCounts;
  167. public:
  168.     static  int         IsWinsockAvailable(void* pObject);
  169.     static  int         ReleaseWinsockUsage(void* pObject);
  170.     
  171.     HX_RESULT           WriteComplete   (char * Buffer, int length);
  172.     int ReadyToWrite    ();
  173. #ifndef WIN32_PLATFORM_PSPC
  174.     // Callbacks from our Async Net notifier object
  175.     void CB_DNSComplete( int iSuccess );
  176.     void CB_ConnectionComplete( int iSuccess );
  177.     void CB_ReadWriteNotification( int iType );
  178.     void CB_CloseNotification();
  179.     void CB_AcceptNotification();
  180.     HX_RESULT ConnectAsync( LPCSTR host, UINT16 port );
  181.     void ContinueAsyncConnect();
  182.     // Handle to any active Async DNS type operations. Usually NULL meaning
  183.     // no such operations are active.
  184.     HANDLE  m_hAsyncHandle;
  185. #endif
  186. protected:
  187. win_net (void); 
  188. #ifndef WIN32_PLATFORM_PSPC
  189.     HX_RESULT  DoStartAsyncConn();
  190. #endif
  191.     
  192.     int                 callRaConnect;
  193.     int InBlockingMode; 
  194.     int                 bReadyToWrite;
  195.     struct sockaddr  from;
  196.     // NEW ASYNC DNS STUFF
  197.     typedef enum tagCONN_STATE
  198.     {
  199. CONN_CLOSED = 0, // Socket not readable or writeable
  200. CONN_NO_CONN, // Socket needs to be connected (TCP)
  201. CONN_DNS_INPROG, // DNS is in progress reads/writes will return HX_WOULDBLOCK
  202. CONN_DNS_FAILED, // Error doing DNS (return HXR_INVALID_HOST error next read or write)
  203. CONN_CONNECT_INPROG, // DNS is complete, but the connection not complete
  204. CONN_CONNECT_FAILED, // Error doing Connect (return error next read or write)
  205. CONN_OPEN, // Socket readable/writeable
  206. CONN_CLOSING, // Socket is shutdown, reading might work, writing will fail
  207. CONN_LISTENNING, // Socket is listenning for connections
  208. CONN_BOGUS_STATE // NOT A VALID SOCKET STATE - USED FOR RANGE CHECKING AT MOST
  209.     } CONN_STATE;
  210.     HINSTANCE m_hInst;
  211.     UINT16 m_AsyncPort;
  212.     char* m_pAsyncHost;
  213.     char* m_AsyncAddress;
  214. #ifndef WIN32_PLATFORM_PSPC
  215.     CAsyncSockN* m_AsyncNotifier;
  216. #endif
  217.     CONN_STATE m_SocketState;
  218.     
  219.     // stores addr about where we are connected to currently
  220.     ULONG32 CurrentAddr;  
  221.     // just for DNS for hostname...
  222.     // is introduced for RTSP...
  223.     BOOL m_DNSOnly;
  224.     LONG32 m_lRefCount;
  225.     // 
  226.     BOOL m_bReuseAddr;
  227.     BOOL m_bReusePort;
  228.     BOOL m_bIgnoreWSAECONNRESET;
  229. };
  230. class win_UDP: public win_net {
  231. public :
  232.     HX_RESULT init(UINT32 local_addr, UINT16 port, 
  233.              UINT16 blocking=0)
  234.     {        
  235.  callRaConnect = 0;
  236.  return win_net::init_win(SOCK_DGRAM, local_addr, port, 
  237.                       blocking);
  238.     };
  239.     HX_RESULT connect(const char* host, UINT16 port, UINT16  blocking=0, ULONG32 ulPlatform = 0 );
  240.     HX_RESULT connect(sockaddr_in *addr, UINT16 blocking=0);
  241.     HX_RESULT  SetWindowHandle(ULONG32 handle);
  242.     HX_RESULT join_multicast_group(ULONG32 addr, ULONG32 if_addr);
  243.     HX_RESULT leave_multicast_group(ULONG32 addr, ULONG32 if_addr);
  244.     HX_RESULT set_multicast_if(ULONG32 ulInterface);    
  245.     HX_RESULT set_broadcast(BOOL enable);
  246.     HX_RESULT   set_send_size(UINT32 send_size);
  247.     HX_RESULT set_multicast();
  248.     HX_RESULT set_multicast_ttl(unsigned char ttl);
  249.     HX_RESULT listen (ULONG32 ulLocalAddr, UINT16 port, UINT16 backlog, UINT16 blocking=0, ULONG32 ulPlatform = 0);
  250.     HX_RESULT GetFromInfo(ULONG32& ulAddr, UINT16& nPort);
  251. };
  252. class win_TCP: public win_net {
  253. public :
  254.     HX_RESULT init(UINT32 local_addr, UINT16 port, 
  255.                  UINT16 blocking=0)
  256.     {
  257.      return win_net::init_win(SOCK_STREAM, local_addr, port, 
  258.                       blocking);
  259. };
  260.     HX_RESULT connect(const char* host, UINT16 port, UINT16 blocking=0, ULONG32 ulPlatform = 0 );
  261.     HX_RESULT connect(sockaddr_in *addr, UINT16 blocking=0);
  262.     HX_RESULT listen (ULONG32 ulLocalAddr, UINT16 port, UINT16 backlog, UINT16 blocking=0, ULONG32 ulPlatform = 0);
  263. };
  264. class WinsockManager{
  265. public :
  266.     WinsockManager();
  267.     ~WinsockManager();
  268.     void    Initialize();
  269.     BOOL    IsInitialized();
  270. private :
  271.     BOOL bInitialized;
  272. };
  273. #endif // _WIN_NET