Socket.h

Go to the documentation of this file.

/*  Socket.h - Winsock wrapper
    Copyright (C) 2001-2004 Mark Weaver
    Written by Mark Weaver <mark@npsl.co.uk>

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

    This library 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
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the
    Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    Boston, MA  02111-1307, USA.
*/

#ifndef OW32_Socket_h
#define OW32_Socket_h

#include <OW32/OW32Libs.h>
#include <OW32/SockAddrIn.h>

// Open Win32 namespace
namespace OW32
{

class OW32_LIB_EXPORT CSocket
{
public:
    CSocket() :
        m_socket(INVALID_SOCKET),
        m_timeout(-1)
    {
    }

    CSocket(int af, int type, int protocol) :
        m_socket(WSASocket(af, type, protocol, NULL, NULL, WSA_FLAG_OVERLAPPED)),
        m_timeout(-1)
    {
    }

    CSocket(SOCKET s) :
        m_socket(s),
        m_timeout(-1)
    {
    }

    virtual ~CSocket() 
    {
        if (m_socket != INVALID_SOCKET)
            ::closesocket(m_socket);
    }

    virtual int shutdown(int how) { return ::shutdown(m_socket, how); }

#ifdef _MSC_VER
#pragma warning(disable: 4127)
#endif

    int wait_writeable() {
        fd_set  writefds;
        TIMEVAL timeout;
        timeout.tv_sec = (int)(m_timeout/10000000);
        timeout.tv_usec = (int)((m_timeout%10000000)/10);

        FD_ZERO(&writefds);
        FD_SET(m_socket, &writefds);
        int ret = select(1, NULL, &writefds, NULL, &timeout);
        if (ret == 0) { SetLastError(ERROR_TIMEOUT); return SOCKET_ERROR; }
        if (ret < 0) return SOCKET_ERROR;
        if (!FD_ISSET(m_socket, &writefds)) return SOCKET_ERROR;
        return 1;
    }

    int wait_readable() {
        fd_set readfds;
        TIMEVAL timeout;
        timeout.tv_sec = (int)(m_timeout/10000000);
        timeout.tv_usec = (int)((m_timeout%10000000)/10);

        FD_ZERO(&readfds);
        FD_SET(m_socket, &readfds);
        int ret = select(1,&readfds,NULL,NULL,&timeout);
        if (ret == 0) { SetLastError(ERROR_TIMEOUT); return SOCKET_ERROR; }
        if (ret < 0) return SOCKET_ERROR;
        if (!FD_ISSET(m_socket, &readfds)) return SOCKET_ERROR;
        return 1;
    }

#ifdef _MSC_VER
#pragma warning(default: 4127)
#endif

    virtual int send(const char* buf, int len) {
        if (m_timeout!=-1) {
            int ret = wait_writeable();
            if (ret <= 0) return ret;
        }
        return ::send(m_socket, buf, len, 0);
    }

    virtual int recv(char* buf, int len) {
        if (m_timeout != -1) {
            int ret = wait_readable();
            if (ret <= 0) return ret;
        }
        return ::recv(m_socket, buf, len, 0);
    }

    void settimeout(__int64 timeout) {
        m_timeout = timeout;
    }

    __int64 gettimeout() {
        return m_timeout;
    }

    int bind(const struct sockaddr* name, int namelen) { return ::bind(m_socket, name, namelen); }
    int bind(CSockAddrIn& sockaddr_in) { return bind((const struct sockaddr *)&sockaddr_in, sizeof(sockaddr_in)); }

    virtual int close() { 
        SOCKET s = Detach();
        if (s == NULL || s == INVALID_SOCKET) {
            ::SetLastError(WSAENOTSOCK);
            return SOCKET_ERROR;
        }
        return ::closesocket(s);
    }

    virtual int connect(const struct sockaddr* name, int namelen) { return ::connect(m_socket, name, namelen); }
    virtual int connect(CSockAddrIn& sockaddr_in) { return connect((const struct sockaddr *)&sockaddr_in, sizeof(sockaddr_in)); }

    virtual int listen(int backlog=SOMAXCONN) { return ::listen(m_socket, backlog); }
    virtual SOCKET accept(sockaddr* addr, int* addrlen) { return ::accept(m_socket, addr, addrlen); }
    virtual SOCKET accept(CSockAddrIn& sockaddr_in) { int len=sizeof(sockaddr_in); return accept((struct sockaddr *)&sockaddr_in, &len); }

    // setsockopt for common option types
    int setopt(int optname, int value, int level=SOL_SOCKET)        { return ::setsockopt(m_socket, level, optname, (char*)&value, sizeof(value)); }
    int setopt(int optname, bool value, int level=SOL_SOCKET)       { return ::setsockopt(m_socket, level, optname, (char*)(BOOL*)&value, sizeof(value)); }
    int setopt(int optname, LINGER value, int level=SOL_SOCKET)     { return ::setsockopt(m_socket, level, optname, (char*)&value, sizeof(value)); }
    // generic setsockopt
    int setopt(int optname, char* pValue, int size, int level=SOL_SOCKET)       { return ::setsockopt(m_socket, level, optname, pValue, size); }

    // getsockopt for common option types
    int getopt(int optname, int* pValue, int level=SOL_SOCKET)      { int size=sizeof(int); return ::getsockopt(m_socket, level, optname, (char*)pValue, &size); }
    int getopt(int optname, bool* pValue, int level=SOL_SOCKET)     { int size=sizeof(int); return ::getsockopt(m_socket, level, optname, (char*)(BOOL*)pValue, &size); }
    int getopt(int optname, LINGER* pValue, int level=SOL_SOCKET)   { int size=sizeof(int); return ::getsockopt(m_socket, level, optname, (char*)pValue, &size); }
    // generic getsockopt
    int getopt(int optname, char* pValue, int* pSize, int level=SOL_SOCKET) { return ::getsockopt(m_socket, level, optname, pValue, pSize); }

    operator SOCKET() { return m_socket; }
    operator HANDLE() { return (HANDLE)(SOCKET)m_socket; }

    SOCKET Detach() { 
        SOCKET s = m_socket;
        m_socket = INVALID_SOCKET;
        return s;
    }

    void Attach(SOCKET s) { 
        if (m_socket != NULL && m_socket != INVALID_SOCKET)
            ::closesocket(m_socket);
        m_socket = s;
    }

protected:
    SOCKET  m_socket;
    __int64 m_timeout;

private:
    // No copy or assignment
    CSocket(const CSocket& );
    CSocket& operator= (const CSocket& );
};

} // namespace OW32

#endif // OW32_Socket_h

---