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

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. #if !defined _HPUX && !defined _AIX43 && (!defined _MAC_UNIX || ( defined(_MAC_UNIX) && ( !defined(MAC_OS_X_VERSION_10_3) || (MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_3) ) ) )
  36. typedef unsigned int socklen_t;
  37. #endif
  38. #ifndef _UNIX_NET
  39. #define _UNIX_NET
  40. #include <stdio.h>
  41. #include <stdarg.h>
  42. #include <unistd.h>
  43. #ifndef _VXWORKS
  44. #include <sys/time.h>
  45. #include <sys/types.h>
  46. #include <sys/socket.h>
  47. #include <sys/ioctl.h>
  48. #include <netdb.h>
  49. #else
  50. #include <time.h>
  51. #include "sockLib.h"
  52. #include <ioLib.h>
  53. #ifndef fcntl
  54. #define fcntl ioctl
  55. #endif
  56. #include <fcntl.h>
  57. #endif
  58. #include <netinet/in.h>
  59. #ifndef _BEOS
  60. #include <arpa/inet.h>
  61. #endif
  62. #include <errno.h>
  63. #if defined ( _SOLARIS ) || defined ( _SUN )
  64. #include <sys/filio.h>                  // for FIONBIO
  65. #endif
  66. #include "sockio.h"
  67. #include "conn.h"
  68. #include "debug.h"
  69. #define INVALID_SOCKET -1
  70. const int nInvalidPipe = -1;
  71. struct IHXCallback;
  72. class CHXSimpleList;
  73. class unix_net : public conn 
  74. {
  75. public:  
  76.   ~unix_net (void);
  77.   
  78.   //  call new_socket() to automatically create the correct platform
  79.   // specific network object.  The type parameter may be either
  80.   // HX_TCP_SOCKET or HX_UDP_SOCKET. If new_socket() returns NULL,
  81.   // an error occurred and the conn object was not created. Call
  82.   // last_error() to get the error
  83.   static unix_net *new_socket (UINT16 type);
  84.   
  85.   // just for DNS for hostname...
  86.   // is introduced for RTSP...
  87.   virtual HX_RESULT dns_find_ip_addr (const char* host, UINT16 blocking=0);
  88.   virtual BOOL      dns_ip_addr_found(BOOL* valid, ULONG32* addr);     
  89.   
  90.   // call init_drivers() to do any platform specific initialization of
  91.   // the network drivers before calling any other functions in this
  92.   // class
  93.   static HX_RESULT init_drivers (void *params);
  94.   
  95.   // close_drivers() should close any network drivers used by the
  96.   // program NOTE: The program MUST not make any other calls to the
  97.   // network drivers until init_drivers() has been called 
  98.   static HX_RESULT close_drivers (void *params);
  99.  
  100.   // host_to_ip_str() converts the host name to an ASCII ip address of
  101.   // the form "XXX.XXX.XXX.XXX"
  102.   static HX_RESULT host_to_ip_str (char *host, char *ip, UINT32 ulIPBufLen);
  103.   // call done() when you are finished with the socket. Done() will
  104.   // close the socket.  You may reuse the socket by calling init()
  105.   // or connect() 
  106.   virtual void done (void);
  107.                 
  108.   static HX_RESULT get_host_name(char *name, int namelen);
  109.   static HX_RESULT get_host_by_name(char *name, REF(struct hostent*) pHostent);
  110.   virtual ULONG32 AddRef (void);
  111.   virtual ULONG32 Release (void);
  112.   virtual HX_RESULT init (UINT32 local_addr,
  113.   UINT16 port,
  114.   UINT16 blocking=0) =0;
  115.   
  116.   
  117.   virtual HX_RESULT init_unix (UINT16 type, 
  118.        UINT32 local_addr,
  119.        UINT16 port,
  120.        UINT16 blocking=0);
  121.                                                                                  
  122.   virtual HX_RESULT listen (UINT16 backlog);
  123.   virtual HX_RESULT listen (ULONG32 ulLocalAddr,
  124.     UINT16 port,
  125.     UINT16 backlog,
  126.     UINT16 blocking,
  127.     ULONG32 ulPlatform) =0;
  128.  
  129.                 
  130.   virtual HX_RESULT connect (const char *host, 
  131.      UINT16 port,
  132.      UINT16 blocking=0,
  133.      ULONG32 ulPlatform=0);
  134.         
  135.   virtual HX_RESULT connect (sockaddr_in *addr);
  136.   virtual HX_RESULT blocking (void);
  137.   virtual HX_RESULT CheckOnDNS(void);
  138.   
  139.   virtual HX_RESULT CheckForConnection(void);
  140.               
  141.   virtual HX_RESULT nonblocking (void);
  142.                 
  143.   virtual HX_RESULT read (void *buf, 
  144.   UINT16 *size);
  145.   virtual HX_RESULT readfrom (REF(IHXBuffer*)   pBuffer,
  146.       REF(UINT32)        ulAddress,
  147.       REF(UINT16)        ulPort);
  148.   virtual HX_RESULT write (void *buf,
  149.    UINT16 *size);
  150.   virtual HX_RESULT writeto (void *buf,
  151.      UINT16 *len,
  152.      ULONG32 addr,
  153.      UINT16 port);
  154.   /* some operation doesn't make sense for TCP */
  155.   virtual HX_RESULT join_multicast_group(ULONG32 addr, ULONG32 if_addr)
  156.   {
  157.     return HXR_INVALID_OPERATION;
  158.   }
  159.   virtual HX_RESULT leave_multicast_group(ULONG32 addr, ULONG32 if_addr)
  160.   {
  161.     return HXR_INVALID_OPERATION;
  162.   }
  163.   virtual HX_RESULT set_broadcast(BOOL enable)
  164.   {
  165.     return HXR_INVALID_OPERATION;
  166.   }  
  167.   virtual HX_RESULT set_multicast_if(ULONG32 ulInterface)
  168.   {
  169.     return HXR_INVALID_OPERATION;
  170.   }
  171.   virtual HX_RESULT set_send_size(ULONG32 send_size)
  172.   {
  173.     return HXR_INVALID_OPERATION;
  174.   }
  175.   virtual HX_RESULT set_multicast()
  176.   {
  177.       return HXR_INVALID_OPERATION;
  178.   }
  179.   virtual HX_RESULT set_multicast_ttl(unsigned char ttl)
  180.   {
  181.       return HXR_INVALID_OPERATION;
  182.   }
  183.   virtual HX_RESULT reuse_addr(BOOL enable);
  184.   virtual HX_RESULT reuse_port(BOOL enable);
  185.   
  186.   virtual ULONG32 get_addr (void);
  187.   virtual UINT16  get_local_port (void);
  188.   virtual HX_RESULT accept (sockaddr_in *addr, UINT16 *addrlen);
  189.   virtual HX_RESULT connect_accept(sockaddr_in *addr);
  190.   virtual HX_RESULT bind (sockaddr_in *addr);
  191.   void set_callback     (IHXCallback* pCallback);
  192.         
  193.   HX_RESULT WriteComplete (char * Buffer, int length);
  194.   int ReadyToWrite ();
  195.   // Callbacks from our Async Net notifier object
  196.   void CB_DNSComplete( int iSuccess );
  197.   void CB_ConnectionComplete( int iSuccess );
  198.   void CB_ReadWriteNotification( int iType );
  199.   void CB_CloseNotification();
  200.   void CB_NewConnectionReady(int iSuccess, unix_net* pConn);
  201.   void add_read_request();
  202.   static void process_idle();
  203.   void add_select(int *, fd_set*, fd_set*, fd_set*);
  204.   void process_select(int, fd_set*, fd_set*, fd_set*);
  205.   BOOL read_pending;
  206.   HX_RESULT ConnectAsync( const char* host, UINT16 port );
  207.   void ContinueAsyncConnect();
  208.   
  209.   // Handle to any active Async DNS type operations. Usually NULL meaning
  210.   // no such operations are active.
  211.   // HANDLE m_hAsyncHandle;
  212.   
  213.   //Helper method for async debugging.
  214.   const int GetSocketState() const
  215.   {
  216.     return m_SocketState;
  217.   }
  218.   
  219. protected:
  220.   unix_net (void); 
  221.   HX_RESULT DoStartAsyncConn();
  222.   void      CleanUpChildProc();
  223.   
  224.   char*       m_pInBuffer;
  225.   int         callRaConnect;                                    
  226.   static int  InBlockingMode; 
  227.   int         bReadyToWrite;
  228.   static CHXSimpleList* readers;
  229.   typedef enum tagCONN_STATE
  230.   {
  231.     CONN_CLOSED = 0, // Socket not readable or writeable
  232.     CONN_NO_CONN,    // Socket needs to be connected (TCP)
  233.     CONN_DNS_INPROG, // DNS is in progress reads/writes will return
  234.                      // HX_WOULDBLOCK
  235.     CONN_DNS_FAILED, // Error doing DNS (return HXR_INVALID_HOST error
  236.                      // next read or write)
  237.     CONN_CONNECT_INPROG, // DNS is complete, but the connection not
  238.                          // complete
  239.     CONN_CONNECT_FAILED, // Error doing Connect (return error next
  240.                          // read or write)
  241.     CONN_OPEN,    // Socket readable/writeable
  242.     CONN_CLOSING, // Socket is shutdown, reading might work, writing
  243.                   // will fail
  244.     CONN_LISTENNING, // Socket is listenning for connectionsa
  245.     CONN_BOGUS_STATE // NOT A VALID SOCKET STATE - USED FOR RANGE
  246.                      // CHECKING AT MOST
  247.   } CONN_STATE;
  248.   //Vars for Async DNS.
  249.   UINT16       m_AsyncPort;
  250.   char*         m_pAsyncHost;
  251.   int         m_anDNSPipe[2];
  252.   int          m_nChildProcID;
  253.   struct sockaddr_in m_sSockAddrIn;
  254.   BOOL               m_DNSOnly; //Used for DNS only objects.
  255.   char               m_szPipeIP[20]; /* Flawfinder: ignore */ //big enough to hold "255.255.255.255"
  256.   
  257. #ifdef _UNIX_THREADS_SUPPORTED
  258.   //On threaded network IO builds we are going to use a thread
  259.   //instead of a fork to do async DNS.
  260.   int                m_nResolved;
  261.   HXThread*         m_pResolver;
  262.   static void *_ResolveIt( void* pArg );
  263. #endif  
  264.   CONN_STATE m_SocketState;
  265.   // stores addr about where we are connected to currently
  266.   ULONG32 CurrentAddr;  
  267.   LONG32  m_lRefCount;
  268.     BOOL m_bReuseAddr;
  269.     BOOL m_bReusePort;
  270. };
  271. class unix_UDP: public unix_net 
  272. {
  273.   public :
  274.   HX_RESULT init(UINT32 local_addr, UINT16 port, 
  275.  UINT16 blocking=0)
  276.   {        
  277.     callRaConnect = 0;
  278.     return unix_net::init_unix( SOCK_DGRAM, local_addr, port, blocking);
  279.   };
  280.   HX_RESULT connect( const char* host,
  281.      UINT16 port,
  282.      UINT16  blocking=0,
  283.      ULONG32 ulPlatform = 0
  284.      );
  285.   HX_RESULT connect( sockaddr_in *addr, UINT16 blocking=0);
  286.   HX_RESULT join_multicast_group(ULONG32 addr, ULONG32 if_addr);
  287.   HX_RESULT leave_multicast_group(ULONG32 addr, ULONG32 if_addr);
  288.   HX_RESULT set_broadcast(BOOL enable);
  289.   HX_RESULT set_multicast_if(ULONG32 ulInterface);
  290.   HX_RESULT set_send_size(UINT32 send_size);
  291.   HX_RESULT set_multicast();
  292.   HX_RESULT set_multicast_ttl(unsigned char ttl);
  293.   HX_RESULT listen( ULONG32 ulLocalAddr,
  294.     UINT16 port,
  295.     UINT16 backlog,
  296.     UINT16 blocking=1,
  297.     ULONG32 ulPlatform=0
  298.     )
  299.   {
  300.     // listening on a UDP port is not supported...
  301.     return HXR_NOTIMPL;
  302.   }
  303. };
  304. class unix_TCP: public unix_net {
  305.   public :
  306.   HX_RESULT init(UINT32 local_addr, UINT16 port, 
  307.  UINT16 blocking=1)
  308.   {
  309.     return unix_net::init_unix(SOCK_STREAM, local_addr, port,  
  310.                                blocking);
  311.   };
  312.   HX_RESULT connect(const char* host, UINT16 port, UINT16 blocking=0, ULONG32 ulPlatform = 0 );
  313.   HX_RESULT connect(sockaddr_in *addr, UINT16 blocking=1);
  314.   HX_RESULT listen (ULONG32 ulLocalAddr, UINT16 port, UINT16 backlog, UINT16 blocking=0, ULONG32 ulPlatform=0);
  315. };
  316. inline HX_RESULT unix_net::blocking (void)
  317. {
  318.   int rtn;
  319. #ifdef FIONBIO
  320.   unsigned long nonblocking = 0;
  321.   rtn = ::ioctl(get_sock(), FIONBIO, (char*)&nonblocking); 
  322. #elif SO_NONBLOCK
  323.     char nonblocking = 0;
  324.     rtn = ::setsockopt(get_sock(),SOL_SOCKET,SO_NONBLOCK,&nonblocking,1);
  325. #else
  326.     rtn = ::fcntl(get_sock(), F_SETFL, ::fcntl(get_sock(), F_GETFL, 0) & ~O_NONBLOCK);
  327. #endif
  328.   if (rtn == 0)
  329.     return HXR_OK;
  330.   else if (errno == EBADF)
  331.     return HXR_NET_SOCKET_INVALID;
  332.   else if (errno == EINVAL)
  333.     return HXR_INVALID_OPERATION;
  334.   return HXR_INVALID_OPERATION;
  335. }
  336.     
  337. inline HX_RESULT unix_net::nonblocking (void) 
  338. {
  339.   int rtn;
  340. #ifdef FIONBIO
  341.   unsigned long nonblocking = 1;
  342.   rtn = ::ioctl(get_sock(), FIONBIO, (char*)&nonblocking); 
  343. #elif SO_NONBLOCK
  344.     char nonblocking = 1;
  345.     rtn = ::setsockopt(get_sock(),SOL_SOCKET,SO_NONBLOCK,&nonblocking,1);
  346. #else
  347.     rtn = ::fcntl(get_sock(), F_SETFL, ::fcntl(get_sock(), F_GETFL, 0) | O_NONBLOCK);
  348. #endif
  349.   if (rtn == 0)
  350.     return HXR_OK;
  351.   else if (errno == EBADF)
  352.     return HXR_NET_SOCKET_INVALID;
  353.   else if (errno == EINVAL)
  354.     return HXR_INVALID_OPERATION;
  355.   return HXR_INVALID_OPERATION;
  356. }
  357. inline HX_RESULT unix_net::accept (sockaddr_in *addr, UINT16 *addrlen)
  358. {
  359.   return ::accept(get_sock(), (sockaddr*)addr, (HX_SOCKLEN_T*)addrlen);
  360. }
  361.                                          
  362. inline HX_RESULT unix_net::bind (sockaddr_in *addr)
  363. {
  364.   return ::bind(get_sock(), (sockaddr*)addr, sizeof(addr));
  365. }
  366. #endif // _UNIX_NET