Socket.cpp

Go to the documentation of this file.

// Socket.cpp -- implementation for the Socket class

#include <errno.h>
#include <cstring>

#include "Socket.h"
#include "SystemCall.h"


// class Socket


// standard c++ iostream inserter
std::ostream& Socket::operator<<(std::ostream& stream) const
{
        stream << "Socket( ";
        if ( isOpen() )
                stream << getDescriptor();
        else
                stream << "Socket is not open";
        stream << " )";
        return stream;
}

// Return the native operating system socket handle
SOCKET Socket::getDescriptor() const throw()
{
        return socketHandle;
}

// Comparison to another socket object
bool Socket::operator==(const Socket& socket) const throw()
{
        return getDescriptor() == socket.getDescriptor();
}

// Comparison to another socket object
bool Socket::operator<(const Socket& socket) const throw()
{
        return getDescriptor() < socket.getDescriptor();
}

// Whether the socket has been open or not
bool Socket::isOpen() const throw()
{
        return getDescriptor() != static_cast<SOCKET>(-1);
}

// Construct using the native operating system socket handle
Socket::Socket(SOCKET descriptor) : socketHandle(descriptor),autoClosing(true),flags_(0)
{
}

// Specify the native operating system socket handle
void Socket::setDescriptor(SOCKET descriptor) throw()
{
        socketHandle = descriptor;
}

// Return the native operating system socket handle
Socket::operator SOCKET() const throw()
{
        return socketHandle;
}


// Retrieve whether a boolean socket option is set
bool Socket::getBoolOption(int code) const
{
        return getOption(code) ? true : false;
}

// Specify an integral socket option
void Socket::setOption(int code, int value)
{
        setOption(code,&value,sizeof(value));
}

// Specify a boolean socket option
void Socket::setBoolOption(int code, bool flag)
{
        setOption(code,flag);
}

// The type of socket (ie, SOCK_STREAM,SOCK_DGRAM,SOCK_RAW, etc.)
int Socket::getSocketType() const
{
        return getOption(SO_TYPE);
}

// Retrieves error status and clears the status
int Socket::getAndClearErrorStatus()
{
        return getOption(SO_ERROR);
}

// Retrieve whether routing is enabled
// The default option is false for the SO_DONTROUTE
bool Socket::getRouting() const
{
        return !getBoolOption(SO_DONTROUTE);
}

// Specify whether the socket should use routing
void Socket::setRouting( bool flag )
{
        setBoolOption(SO_DONTROUTE,!flag);
}

// Retrieve whether the address to which this socket is bound can be used by others
bool Socket::canLocalAddressesBeReused() const
{
        return getBoolOption(SO_REUSEADDR);
}

// Specify whether the address to which this socket is bound can be used by others
void Socket::setReuseLocalAddresses(bool flag)
{
        setBoolOption(SO_REUSEADDR,flag);
}

// Retrieve whether the Socket will close the native socket on destruction
bool Socket::isAutoClosing() const throw()
{
        return autoClosing;
}

// Specify whether or not the destructor will close the native socket
void Socket::setToAutoClose( bool flag ) throw()
{
        autoClosing = flag;
}

// Associates a local address with a socket
void Socket::bind( const SocketAddress& address )
{
        sockaddr_in in= address.operator sockaddr_in();
        bind(reinterpret_cast<sockaddr*>(&in),sizeof(sockaddr));
}


// Constuct with given parameters
Socket::Socket(int type,int domain,int protocol) : socketHandle( static_cast<SOCKET>(-1) ),
        autoClosing( true ),flags_( 0 )
{
        int result;
        SOCKET_CALL_3( result = (int), ::socket, domain, type, protocol )

        if ( result >= 0 ) {
                setDescriptor(result);
        }
}

// Socket destructor
Socket::~Socket()
{
        try {
                if ( isAutoClosing() )
                        close();
        }
        catch (...)
        {
        }
}

// Return the size of the operating system's socket buffer
int Socket::getReceivingBufferSize() const
{
        return getOption( SO_RCVBUF );
}

// Sets the size of the operating system's socket buffer
// On Windows the default buffer size is 8K
void Socket::setReceivingBufferSize( int size )
{
        setOption( SO_RCVBUF, size );
}

// Return the size of the operating system's socket buffer
int Socket::getSendingBufferSize() const
{
        return getOption( SO_SNDBUF );
}

// Sets the size of the operating system's socket buffer
// On Windows the default buffer size is 8K
void Socket::setSendingBufferSize( int size )
{
        setOption( SO_SNDBUF, size );
}

// Associates a local address with a socket
void Socket::bind( sockaddr* address, int size )
{
        int dummy;
        SOCKET_CALL_3( dummy =, ::bind, getDescriptor(), (sockaddr*) address, size )
}

// Retrieve the interger socket option
int Socket::getOption( int code ) const
{
        int result = 0;
        int size = sizeof( result );
        getOption( code, &result, size );
        return result;
}

// Retrieve the length of time the socket will wait for unsent data
// before the socket is closed and whether it is set
bool Socket::getLingerInformation( int& seconds ) const
{
        linger lingerStruct;
        int size = sizeof(lingerStruct);
        getOption( SO_LINGER, &lingerStruct, size );
        seconds = lingerStruct.l_linger;
        return lingerStruct.l_onoff != 0;
}

// Specify the length of time to wait for unsent data before a socket is closed
void Socket::setLingerInformation( bool flag, int seconds )
{
        linger lingerStruct;
        lingerStruct.l_onoff = static_cast<unsigned short>(flag);
        lingerStruct.l_linger = static_cast<unsigned short>(seconds);
        setOption(SO_LINGER,&lingerStruct,sizeof( lingerStruct ) );
}


// IP Socket Address accessor
SocketAddress Socket::getSocketAddress() const
{
        SocketAddress address;
        sockaddr_in in = address.operator sockaddr_in();
        int size = static_cast<int>(sizeof(sockaddr));
        name( reinterpret_cast<sockaddr*>(&in), size);
        return address;
}

// Shutdown the socket receiving channel
void Socket::shutdownSocketReceives()
{
        shutdown(ShutdownReceive);
}

// Shutdown the socket send channel
void Socket::shutdownSocketSends()
{
        shutdown(ShutdownSend);
}

// Shutdown all socket channels
void Socket::shutdown()
{
        shutdown(ShutdownBoth);
}

// Shutdown socket
void Socket::shutdown(SocketShutdownMode code)
{
        int dummy;
        SOCKET_CALL_2(dummy =,::shutdown,getDescriptor(),code)
}


// Sets the given socket option
void Socket::setOption( int code, void* storage, int size )
{
        int dummy;
        SOCKET_CALL_5(dummy =,::setsockopt,getDescriptor(),SOL_SOCKET,code,
                reinterpret_cast<char*>(storage),size)
}

// Close the socket
void Socket::close()
{
    ::closesocket(socketHandle);
        socketHandle = static_cast<SOCKET>(-1);
}

// Close my socket descriptor, then allocate a new socket.  
void Socket::reset( int type, int domain, int protocol )
{
        try {
                close();
        }
        catch (std::exception&) {
                // do nothing because we might not have been opened
    }
  
        int result = 0;
        SOCKET_CALL_3(result=(int),::socket,domain,type,protocol)
        if (result >= 0)
                setDescriptor(result);
}

// Retrieve the given socket option
void Socket::getOption( int code, void* storage, int& size ) const
{
#ifdef _MSC_VER
    int length = size;
#else
        socklen_t length = size;
#endif

        int dummy;
        SOCKET_CALL_5(dummy =,::getsockopt,getDescriptor(),SOL_SOCKET,code,
                reinterpret_cast<char*>(storage),&length)
}

// Retrieve the socket's name
void Socket::name( sockaddr* address, int& size ) const
{
        int dummy;
#ifdef _MSC_VER
    int length = size;
#else
        socklen_t length = size;
#endif

        SOCKET_CALL_3(dummy =,::getsockname,getDescriptor(),address,&length)
        size = length;
}

---