gsocket.h

Go to the documentation of this file.

//
// Copyright (C) 2001-2013 Graeme Walker <graeme_walker@users.sourceforge.net>
// 
// 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 3 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, see <http://www.gnu.org/licenses/>.
// ===

#ifndef G_SOCKET_H 
#define G_SOCKET_H

#include "gdef.h"
#include "gnet.h"
#include "gaddress.h"
#include "gevent.h"
#include "gdescriptor.h"
#include <string>

namespace GNet
{
        class Socket ;
        class SocketProtocol ;
        class StreamSocket ;
        class DatagramSocket ;
        class AcceptPair ;
}

class GNet::Socket  
{
public:
        typedef size_t size_type ;
        typedef ssize_t ssize_type ;
        class Credentials 
        { 
                friend class SocketProtocol ;
                friend class SocketProtocolTest ;
                Credentials( const char * ) {}
        } ;

        virtual ~Socket() ;

        bool valid() const ;

        std::pair<bool,Address> getLocalAddress() const ;

        std::pair<bool,Address> getPeerAddress() const ;

        bool hasPeer() const ;

        bool bind( const Address & address ) ;

        bool canBindHint( const Address & address ) ;

        bool connect( const Address & addr , bool *done = NULL ) ;

        bool listen( int backlog = 1 ) ;

        virtual ssize_type write( const char * buf , size_type len ) ;

        bool eWouldBlock() ;

        bool eInProgress() ;

        bool eMsgSize() ;

        void addReadHandler( EventHandler & handler ) ;

        void dropReadHandler();

        void addWriteHandler( EventHandler & handler ) ;

        void dropWriteHandler() ;

        void addExceptionHandler( EventHandler & handler );

        void dropExceptionHandler() ;

        std::string asString() const ;

        std::string reasonString() const ;

        void shutdown( bool for_writing = true ) ;

        int fd( Credentials ) const ;

protected:
        Socket( int domain , int type , int protocol ) ;

        explicit Socket( Descriptor s ) ;

protected:
        static bool valid( Descriptor s ) ;
        static int reason() ;
        static bool error( int rc ) ;
        static bool sizeError( ssize_type size ) ;
        void prepare() ;
        void setFault() ;
        void setNoLinger() ;
        void setReuse() ;
        void setKeepAlive() ;
        std::pair<bool,Address> getAddress( bool ) const ;

private:
        void doClose() ;
        bool setNonBlock() ;

protected:
        int m_reason ;
        Descriptor m_socket ;

private:
        Socket( const Socket & ) ;
        void operator=( const Socket & ) ;
        void drop() ;
} ;


class GNet::AcceptPair 
{
public:
        typedef std::auto_ptr<StreamSocket> first_type ;
        typedef Address second_type ;

        first_type first ;
        second_type second ;

        AcceptPair( StreamSocket * new_p , Address a ) ;

        AcceptPair( const AcceptPair & other ) ;

        AcceptPair & operator=( const AcceptPair & rhs ) ;
} ;


class GNet::StreamSocket : public GNet::Socket 
{
public:
        typedef Socket::size_type size_type ;
        typedef Socket::ssize_type ssize_type ;

        StreamSocket() ;

        explicit StreamSocket( const Address & address_hint ) ;

        virtual ~StreamSocket() ;

        ssize_type read( char * buffer , size_type buffer_length ) ;

        AcceptPair accept() ;

private:
        StreamSocket( const StreamSocket & ) ; // not implemented
        void operator=( const StreamSocket & ) ; // not implemented
        StreamSocket( Descriptor s ) ; // A private constructor used in accept().
} ;


class GNet::DatagramSocket : public GNet::Socket 
{
public:
        DatagramSocket() ;

        explicit DatagramSocket( const Address & address_hint ) ;

        virtual ~DatagramSocket() ;

        ssize_type read( void * buffer , size_type len , Address & src ) ; 

        ssize_type write( const char * buffer , size_type len , const Address & dst ) ; 

        ssize_type write( const char * buffer , size_type len ) ;

        void disconnect() ;

private:
        DatagramSocket( const DatagramSocket & ) ; // not implemented
        void operator=( const DatagramSocket & ) ; // not implemented
} ;


inline
GNet::Socket::ssize_type GNet::DatagramSocket::write( const char *buf, size_type len ) 
{ 
        return Socket::write(buf,len) ; 
}


inline 
GNet::AcceptPair::AcceptPair( StreamSocket * p , Address a ) : 
        first(p) , 
        second(a) 
{
}

inline 
GNet::AcceptPair::AcceptPair( const AcceptPair & other ) : 
        first(const_cast<first_type&>(other.first)) , 
        second(other.second) 
{
}

inline 
GNet::AcceptPair & GNet::AcceptPair::operator=( const AcceptPair & rhs ) 
{ 
        first = const_cast<first_type&>(rhs.first) ; 
        second = rhs.second ; 
        return *this ; 
}

#endif