src/network/nSocket.h

Go to the documentation of this file.

/*

*************************************************************************

ArmageTron -- Just another Tron Lightcycle Game in 3D.
Copyright (C) 2000  Manuel Moos (manuel@moosnet.de)

**************************************************************************

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

***************************************************************************

*/

// nSocket.h

// extremely losely based on the GNU Quake 1 base network code, so technicaly:
// Copyright (C) 1996-1997 Id Software, Inc.
// Modified for Armagetron by Manuel Moos (manuel@moosnet.de)

#ifndef NET_SOCKET_H
#define NET_SOCKET_H

#include <iostream>
#include "tConsole.h"
#include "tException.h"
#include <vector>

class nScoket;
struct nHostInfo;
// struct addrinfo;
struct hostentry;
struct sockaddr;

#ifdef WIN32
#include  <winsock.h>
#else
#include <sys/socket.h>
#include <netinet/in.h>
#endif

typedef  char int8;

union nAddressBase
{
    struct sockaddr     addr;       
    struct sockaddr_in  addr_in;    
    // struct sockaddr_in6 addr_in6;   //!< IPV6 address ( not supported yet )
};

class nAddress
{
public:
    nAddress();         
    ~nAddress();        

    // these functions handle address representation in the form hostname:port
    nAddress const &    ToString    ( tString & string ) const   ; 
    tString                     ToString    ()                   const   ; 
    int                                 FromString  ( const char * string )      ; 

    //  void                FromAddrInfo( const addrinfo & info )    ; //!< copy address from addrinfo

    void                FromHostent ( int l, const char * addr ) ; 

    nAddress &                  SetHostname     ( const char * hostname )    ; 
    tString                     GetHostname     ( void ) const               ; 
    nAddress const &    GetHostname     ( tString & hostname ) const ; 

    nAddress &                  SetAddress      ( const char * address )     ; 
    tString                     GetAddress      ( void ) const               ; 
    nAddress const &    GetAddress      ( tString & address ) const  ; 

    nAddress &                  SetPort         ( int port )                 ; 
    int                                 GetPort         ( void ) const               ; 
    nAddress const &    GetPort         ( int & port ) const         ; 

    bool                IsSet       () const                     ; 

    static int  Compare ( const nAddress & a1, const nAddress & a2 );   

    operator struct sockaddr *      ()       { return &addr_.addr; }   
    operator struct sockaddr const *() const { return &addr_.addr; }   

    bool operator == ( nAddress const & other ) const
    {
        return Compare( *this, other ) == 0;
    }

    bool operator != ( nAddress const & other ) const
    {
        return Compare( *this, other ) != 0;
    }

    enum{ size = sizeof( nAddressBase ) };

    unsigned int GetAddressLength( void ) const;        
private:
    nAddressBase addr_;     
    unsigned int addrLen_;  
};

class nSocket
{
public:
    nSocket();          
    ~nSocket();         

class PermanentError: public tException
    {
    public:
        PermanentError();                                       
        PermanentError( const tString & details );              
        ~PermanentError();                                      
    private:
        virtual tString DoGetName()         const;              
        virtual tString DoGetDescription()  const;              

        tString description_;
    };

    int Open ();                            
    int Open ( nAddress const & address );  
    int Open ( int port );                  
    //  int Open ( const addrinfo & addr );     //!< open socket for listening on the specified address info
    int Open ( const nHostInfo & addr );    
    int Close ();                           
    bool IsOpen () const;                   
    void Reset () const;                    

    int Connect ( const nAddress & addr );          
    const nSocket * CheckNewConnection() const;     

    int Read        ( int8 *buf, int len, nAddress & addr )             const; 
    int Write       ( const int8 *buf, int len, const nAddress & addr ) const; 
    int Broadcast   ( const char *buf, int len, unsigned int port )     const; 

    nAddress const &   GetAddress( void )                  const   ;    
    nSocket const &    GetAddress( nAddress & address )    const   ;    

    inline int             GetSocket( void )         const; 
    inline nSocket const & GetSocket( int & socket ) const;     

    // moving copy semantics
    void MoveFrom( const nSocket & other );       
    nSocket( const nSocket & other );             
    nSocket & operator=( const nSocket & other ); 
private:
    int Create ();                            
    int Bind ( nAddress const & address );    

    int Write       ( const int8 *buf, int len, const sockaddr * addr, int addrlen ) const; 

    nSocket & SetAddress( nAddress const & address );  
    inline nSocket & SetSocket( int socket );          

    int socket_;            
    nAddress address_;      
    nAddress trueAddress_;  
    int family_, socktype_, protocol_;    
    mutable bool broadcast_;              
};

class nSocketListener
{
public:
    nSocketListener();      
    ~nSocketListener();     

    bool Listen ( bool state );                                 

    typedef std::vector< nSocket > SocketArray;                 
    typedef SocketArray::const_iterator const_iterator;         
    typedef SocketArray::const_iterator iterator;               

    // almost std:: compliant iterator functions
    iterator begin() const;                                    
    iterator end() const;                                      

    nSocketListener &       SetPort     ( unsigned int port );          
    unsigned int            GetPort     ( void ) const;                 
    nSocketListener const & GetPort     ( unsigned int & port ) const;  
    nSocketListener &       SetIpList   ( tString const & ipList );         
    tString const &         GetIpList   ( void ) const;                 
    nSocketListener const & GetIpList   ( tString & ipList ) const;         
    inline SocketArray const     & GetSockets ( void ) const;                   
    inline nSocketListener const & GetSockets ( SocketArray & sockets ) const;  
private:
    SocketArray  sockets_;   
    unsigned int port_;      
    tString      ipList_;    

    // forbid copying
    nSocketListener( const nSocketListener & );
    nSocketListener & operator=( const nSocketListener & );

    inline nSocketListener & SetSockets( SocketArray const & sockets ); 
};

class nBasicNetworkSystem
{
public:
    nBasicNetworkSystem();              
    ~nBasicNetworkSystem();             

    nSocket*  Init (void);              
    void      Shutdown (void);          

    bool      Select (REAL dt);         

    nSocketListener &             AccessListener      ( void )                                ; 
    nBasicNetworkSystem &         SetListener         ( nSocketListener const & listener )    ; 
    nSocketListener const &       GetListener         ( void ) const                          ; 
    // nBasicNetworkSystem const &   GetListener         ( nSocketListener & listener ) const    ;      //!< Gets listening sockets

    // nBasicNetworkSystem &         SetControlSocket    ( nSocket const & controlSocket )       ;      //!< Sets network control socket
    nSocket const &               GetControlSocket    ( void ) const                          ; 
    // nBasicNetworkSystem const &   GetControlSocket    ( nSocket & controlSocket ) const       ;      //!< Gets network control socket
private:

    nSocketListener listener_;          
    nSocket         controlSocket_;     

    // forbid copying
    nBasicNetworkSystem( const nBasicNetworkSystem & );
    nBasicNetworkSystem & operator=( const nBasicNetworkSystem & );

    nSocket &                     AccessControlSocket ( void )                                ; 
};

// *******************************************************************************
// *
// *    GetSockets
// *
// *******************************************************************************
// *******************************************************************************

nSocketListener::SocketArray const & nSocketListener::GetSockets( void ) const
{
    return this->sockets_;
}

// *******************************************************************************
// *
// *    GetSockets
// *
// *******************************************************************************
// *******************************************************************************

nSocketListener const & nSocketListener::GetSockets( SocketArray & sockets ) const
{
    sockets = this->sockets_;
    return *this;
}

// *******************************************************************************
// *
// *    SetSockets
// *
// *******************************************************************************
// *******************************************************************************

nSocketListener & nSocketListener::SetSockets( SocketArray const & sockets )
{
    this->sockets_ = sockets;
    return *this;
}

// *******************************************************************************
// *
// *    GetSocket
// *
// *******************************************************************************
// *******************************************************************************

int nSocket::GetSocket( void ) const
{
    return this->socket_;
}

// *******************************************************************************
// *
// *    GetSocket
// *
// *******************************************************************************
// *******************************************************************************

nSocket const & nSocket::GetSocket( int & socket ) const
{
    socket = this->socket_;
    return *this;
}

// *******************************************************************************
// *
// *    SetSocket
// *
// *******************************************************************************
// *******************************************************************************

nSocket & nSocket::SetSocket( int socket )
{
    this->socket_ = socket;
    return *this;
}

#endif

---