CuSocket - create an endpoint for communication

// create an endpoint for communication

CuSocket ClientSocket;
ClientSocket.Socket();
ClientSocket.Connect(lpszHostAddress, nHostPort);


// CuSocket.h


class CuSocket
{
private:
    SOCKET m_hSocket;
public:
    CuSocket(void);
public:
    ~CuSocket(void);

    SOCKET Socket(int nSocketType = SOCK_STREAM);
    int Close(void);

    //enum { SD_SEND = 0, SD_RECEIVE = 1,  SD_BOTH = 2};
    int ShutDown(int nHow = SD_BOTH);

    int Bind(UINT nSocketPort);
    int Listen( int nConnectionBacklog = 5 );
    SOCKET Accept( SOCKADDR *lpSockAddr, int *lpAddrLen );

    int Connect( LPCSTR lpszHostAddress, UINT nHostPort);

    int Receive(void *lpBuf, int nBufLen, int nFlags);
    int Send(const void *lpBuf, int nBufLen, int nFlags);

    BOOL Attach(SOCKET hSocket);
    operator SOCKET() const;
    CuSocket &operator =(CuSocket &socket);

};




// CuSocket.cpp


CuSocket::CuSocket(void)
:m_hSocket(NULL)
{
}

CuSocket::~CuSocket(void)
{
    if( m_hSocket != NULL )
    {
        Close();
    }
}

SOCKET CuSocket::Socket(int nSocketType /* = SOCK_STREAM */ )
{
    this->Close();
    m_hSocket = socket(AF_INET, nSocketType, IPPROTO_TCP);
    return m_hSocket;
}

BOOL CuSocket::Attach(SOCKET hSocket)
{
    this->Close();
    m_hSocket = hSocket;
    return (m_hSocket != NULL);
}

int CuSocket::Close(void)
{
    int error = 0;
    if( m_hSocket != NULL )
    {
        this->ShutDown();
        error = closesocket(m_hSocket);
        m_hSocket = NULL;
    }
    return error;
}

int CuSocket::Bind(UINT nSocketPort)
{
    SOCKADDR_IN SockAddr;
    SockAddr.sin_family = AF_INET;
    SockAddr.sin_addr.s_addr = htonl(INADDR_ANY);
    SockAddr.sin_port = htons(nSocketPort);

    int error = bind( m_hSocket, (PSOCKADDR)&SockAddr, sizeof(SockAddr) );
    return error;
}

int CuSocket::ShutDown(int nHow /* = SD_BOTH */ )
{
    int error = shutdown( m_hSocket, nHow );
    return error;
}

int CuSocket::Listen( int nConnectionBacklog /* = 5 */ )
{
    int error = listen(m_hSocket, nConnectionBacklog);
    return error;
}

SOCKET CuSocket::Accept( SOCKADDR *lpSockAddr, int *lpAddrLen )
{
    SOCKET hSocket = NULL;
    hSocket = accept( m_hSocket, lpSockAddr, lpAddrLen );
    return hSocket;
}

int CuSocket::Connect( LPCSTR lpszHostAddress, UINT nHostPort)
{
    SOCKADDR_IN ServerAddr;
    ServerAddr.sin_family = AF_INET;
    ServerAddr.sin_port = htons(nHostPort);
    ServerAddr.sin_addr.s_addr = inet_addr( lpszHostAddress );

    int error = connect(m_hSocket, (PSOCKADDR)&ServerAddr, sizeof(ServerAddr));
    return error;
}

CuSocket::operator SOCKET() const
{
    return m_hSocket;
}

CuSocket& CuSocket::operator =(CuSocket &socket)
{
    m_hSocket = socket.m_hSocket;
    return *this;
}

int CuSocket::Receive(void *lpBuf, int nBufLen, int nFlags)
{
    return recv( m_hSocket, static_cast<char *>(lpBuf), nBufLen, nFlags );
}

int CuSocket::Send(const void *lpBuf, int nBufLen, int nFlags)
{
    return send( m_hSocket, static_cast<const char*>(lpBuf), nBufLen, nFlags );
}