namespace SocketLib
{
    class Socket
    {
    public:
        inline sock GetSock() const
        {
            return m_sock;
        }
        inline port GetLocalPort() const
        {
            return ntohs( m_localinfo.sin_port );
        }
        inline ipaddress GetLocalAddress() const
        {
            return m_localinfo.sin_addr.s_addr;
        }
        void Close();
        void SetBlocking( bool p_blockmode );
    protected:
        Socket( sock p_socket = -1 );
        sock m_sock;                    // this is the underlying representation of the actual socket.
        struct sockaddr_in m_localinfo; // structure containing information about the local connection
        bool m_isblocking;              // this tells whether the socket is blocking or not.
    };
}   // end namespace SocketLib

    void Socket::SetBlocking( bool p_blockmode )
    {
        int err;
        #ifdef WIN32
            unsigned long mode = !p_blockmode;
            err = ioctlsocket( m_sock, FIONBIO, &mode );
        #else
            // get the flags
            int flags = fcntl( m_sock, F_GETFL, 0 );
            // set or clear the non-blocking flag
            if( p_blockmode == false )
            {
                flags |= O_NONBLOCK;
            }
            else
            {
                flags &= ~O_NONBLOCK;
            }
            err = fcntl( m_sock, F_SETFL, flags );
        #endif
        if( err == -1 )
        {
            throw( Exception( GetError() ) );
        }
        m_isblocking = p_blockmode;
    }

class ListeningSocket : public Socket
    {
    public:
        ListeningSocket();
        void Listen( port p_port );
        DataSocket Accept();
        inline bool IsListening() const
        {
            return m_listening;
        }
        void Close();
    protected:
        bool m_listening;               // is the socket listening?
    };

   class DataSocket : public Socket
    {
    public:
        DataSocket( sock p_socket = -1 );
        inline ipaddress GetRemoteAddress() const
        {
            return m_remoteinfo.sin_addr.s_addr;
        }
        inline port GetRemotePort() const
        {
            return ntohs( m_remoteinfo.sin_port );
        }
        inline bool IsConnected() const
        {
            return m_connected;
        }
        void Connect( ipaddress p_addr, port p_port );
        int Send( const char* p_buffer, int p_size );
        int Receive( char* p_buffer, int p_size );
        void Close();
    protected:
        bool m_connected;               // is the socket connected?
        struct sockaddr_in m_remoteinfo;// structure containing information about the remote connection
    };    

using namespace SocketLib;
ListeningSocket lsock;
DataSocket dsock;
lsock.Listen(5000);
dsock = lsock.Accept();

char buffer[128] = "Hello There!";
dsock.Send( buffer, strlen( buffer ));
dsock.Receive(buffer, 128);

namespace SocketLib
{    
    const int MAX = FD_SETSIZE;
    class SocketSet
    {
    public:
        SocketSet();
        void AddSocket( const Socket& p_sock );
        void RemoveSocket( const Socket& p_sock );        
        inline int Poll( long p_time = 0 )
        {
            // this is the time value structure. It will determine how long
            // the select function will wait.
            struct timeval t = { 0, p_time * 1000 };
            // copy the set over into the activity set.
            m_activityset = m_set;
            // now run select() on the sockets.
            #ifdef WIN32
                return select( 0, &m_activityset, 0, 0, &t );
            #else
                if( m_socketdescs.size() == 0 ) return 0;
                return select( *(m_socketdescs.rbegin()), &m_activityset, 0, 0, &t );
            #endif
        }
        inline bool HasActivity( const Socket& p_sock )
        {
            return FD_ISSET( p_sock.GetSock(), &m_activityset ) != 0;
        }
    protected:
        // a set representing the socket descriptors.
        fd_set m_set;
        // this set will represent all the sockets that have activity on them.
        fd_set m_activityset;
        // this is only used for linux, since select() requires the largest
        // descriptor +1 passed into it. BLAH!
        #ifndef WIN32
            std::set<sock> m_socketdescs;
        #endif
    };
}   // end namespace SocketLib

namespace SocketLib
{
SocketSet::SocketSet()
{
    FD_ZERO( &m_set );
    FD_ZERO( &m_activityset );
}
void SocketSet::AddSocket( const Socket& p_sock )
{
    // add the socket desc to the set
    FD_SET( p_sock.GetSock(), &m_set );
    // if linux, then record the descriptor into the vector, 
    // and check if it's the largest descriptor.
    #ifndef WIN32
        m_socketdescs.insert( p_sock.GetSock() );
    #endif
}
void SocketSet::RemoveSocket( const Socket& p_sock )
{
    FD_CLR( p_sock.GetSock(), &m_set );
    #ifndef WIN32
        // remove the descriptor from the vector
        m_socketdescs.erase( p_sock.GetSock() );
    #endif
}
}   // end namespace SocketSet

using namespace SocketLib;
DataSocket socks[3];
SocketSet sset;
sset.AddSocket( socks[0] );
sset.AddSocket( socks[1] );
sset.AddSocket( socks[2] );
int active = sset.Poll( 1000 );
if( sset.HasActivity( socks[0] ){}
sset.RemoveSocket( socks[0] );

namespace SocketLib
{
    #ifdef WIN32                // windows 95 and above
        class System
        {
        public:
            System()
            {
                // attempt to start up the winsock lib
                WSAStartup( MAKEWORD( 2, 2 ), &m_WSAData );
            }
            ~System()
            {
                // attempt to close down the winsock lib
                WSACleanup();
            }
        protected:
            // holds information about winsock
            WSADATA m_WSAData;
        };
        System g_system;
    #endif
    ipaddress GetIPAddress( const std::string p_address )
    {
        if( IsIPAddress( p_address ) )
        {
            // if the address is just a regular IP address, there's no need
            // to do a DNS lookup, so just convert the string directly into
            // its binary format.
            ipaddress addr = inet_addr( p_address.c_str() );
            // if the address is invalid, throw a HOST_NOT_FOUND exception.
            if( addr == INADDR_NONE )
            {
                throw Exception( EDNSNotFound );
            }
            // by this point, the address is valid, so return it.
            return addr;
        }
        else
        {
            // the address isn't an IP address, so we need to look it up using
            // DNS. 
            struct hostent* host = gethostbyname( p_address.c_str() );
            // if there was an error, throw an exception.
            if( host == 0 )
            {
                // get the error from h_errno.
                throw Exception( GetError( false ) );
            }
            // now perform some really wierd casting tricks to get the value.
            // h_addr is a char*, so cast it into an ipaddress*, and 
            // dereference it to get the value.
            return *((ipaddress*)host->h_addr);
        }
    }
    std::string GetIPString( ipaddress p_address )
    {
        // return a new string containing the address.
        // (god that is some ugly casting going on... stupid language)
        char* str = inet_ntoa( *((in_addr*)&p_address) );
        if( str == 0 )
        {
            return std::string( "Invalid IP Address" );
        }
        return std::string( str );
    }
    std::string GetHostNameString( ipaddress p_address )
    {
        // get the host info.
        struct hostent* host = gethostbyaddr( (char*)&p_address, 4, AF_INET );
        // if there was an error, throw an exception.
        if( host == 0 )
        {
            // get the error from h_errno.
            throw Exception( GetError( false ) );
        }
        return std::string( host->h_name );
    }
    bool IsIPAddress( const std::string p_address )
    {
        // scan through the string to see if it's a pure IP address or not.
        // basically, we assume that any string with characters other than
        // numerics and periods needs to be DNS'ed.
        for( size_t i = 0; i < p_address.length(); i++ )
        {
            if( ( p_address[i] < '0' || p_address[i] > '9' ) && 
                p_address[i] != '.' )
                return false;
        }
        return true;
    }
}

System g_system;

namespace SocketLib
{
    ipaddress GetIPAddress( const std::string p_address );
    std::string GetIPString( ipaddress p_address );
    std::string GetHostNameString( ipaddress p_address );
    bool IsIPAddress( const std::string p_address );
}