AsyncSocket.h

Go to the documentation of this file.

/*  AsyncSocket.h - SSL communication through the Schannel API
    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_AsyncSocket_h
#define OW32_AsyncSocket_h

#include <OW32/windows.h>
#include <OW32/OW32Libs.h>
#include <OW32/IoCompletion.h>
#include <OW32/Thread.h>
#include <OW32/IoTimeoutManager.h>
#include <OW32/SyncObjects.h>
#include <OW32/RefCounted.h>
#include <OW32/SockAddrIn.h>
#include <tchar.h>
#include <cstddef>

// Open Win32 namespace
namespace OW32
{

enum AsyncIoType
{
    AsyncIo_IoCompletion,
    AsyncIo_Blocking,
    AsyncIo_Message,
    AsyncIo_APC
};

class OW32_LIB_EXPORT CAsyncSocketCallback
{
public:
    virtual void onReadCompletion(BOOL /*bRet*/, DWORD /*cbReceived*/) {}

    virtual void onSendCompletion(BOOL /*bRet*/, DWORD /*cbSent*/) {}

    virtual void onTransmitFileCompletion(BOOL /*bRet*/, DWORD /*cbSent*/) {}

    virtual void onConnectCompletion(BOOL /*bRet*/) {}

    virtual void onCloseCompletion(BOOL /*bRet*/) {}

    virtual void onAcceptCompletion(BOOL /*bRet*/) {}

    virtual void onTimeout() {}

    virtual void onAllNotificationsProcessed() {}
};

class OW32_LIB_EXPORT CAsyncSocketLib
{
public:
    static bool initialise(
        AsyncIoType     model,
        HINSTANCE       hInstance = NULL,
        WORD            wSocketsVersion = MAKEWORD(0,0),
        HANDLE          hCompletionPort = NULL);

    static bool terminate();
    
    static bool initialiseThread();
    
    static bool terminateThread();

    static CIoTimeoutManager *getTimeoutManager();
};

class OW32_LIB_EXPORT CAsyncConnectionThread : public CThread
{
public:
    CAsyncConnectionThread() : 
        CThread(false),
        m_fOK(false)
    {
    }

    virtual BOOL postTerminate() {
        return PostThreadMessage(GetId(), WM_QUIT, 0, 0);
    }

    virtual BOOL terminate() {
        if (GetHandle() != NULL)
        {
            if (!postTerminate())
                return FALSE;
            return WaitForSingleObject(GetHandle(), INFINITE) == WAIT_OBJECT_0;
        }
        return TRUE;
    }

    virtual BOOL initialise() {
        if (!Create())
            return FALSE;
        if (WaitForSingleObject(m_threadReady, INFINITE) != WAIT_OBJECT_0)
            return FALSE;
        
        if (!m_fOK) {
            if (WaitForSingleObject(GetHandle(), INFINITE) != WAIT_OBJECT_0)
                return FALSE;
        }
        return (BOOL)m_fOK;
    }

    virtual unsigned int Run() {
        m_fOK = CAsyncSocketLib::initialiseThread();
        m_threadReady.Set();
        if (!m_fOK)
            return 0;

        MSG msg;
        while (GetMessage(&msg, NULL, 0, 0) > 0) {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
        (void)CAsyncSocketLib::terminateThread();
        return 0;
    }

private:
    // No copy or assignment
    CAsyncConnectionThread(const CAsyncConnectionThread& other);
    CAsyncConnectionThread& operator=(const CAsyncConnectionThread& other);

    bool    m_fOK;
    CEvent  m_threadReady;
};

class OW32_LIB_EXPORT CAsyncSocketBase
{
public:
    CAsyncSocketBase(CAsyncSocketCallback* pCallback) :
        m_pCallback(pCallback),
        m_socket(INVALID_SOCKET),
        m_timeout(static_cast<DWORD>(-1))
    {
    }

    CAsyncSocketBase(CAsyncSocketCallback* pCallback, SOCKET s) :
        m_pCallback(pCallback),
        m_socket(s),
        m_timeout(static_cast<DWORD>(-1))
    {
    }
    
    virtual ~CAsyncSocketBase()
    {
        if (m_socket != INVALID_SOCKET)
            ::closesocket(m_socket);
    }

    void setCallback(CAsyncSocketCallback* pCallback)
    {
        m_pCallback = pCallback; 
    }

    CAsyncSocketCallback* getCallback() const 
    {
        return m_pCallback; 
    }

    operator SOCKET() { return m_socket; }

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

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

    void attach(SOCKET s)
    {
        if (m_socket != INVALID_SOCKET)
            ::closesocket(m_socket);
        m_socket = s;
    }

    virtual void setTimeout(DWORD timeout)
    {
        m_timeout = timeout;
    }

    virtual DWORD getTimeout()
    {
        return m_timeout;
    }

    virtual int close()
    {
        if (m_socket != INVALID_SOCKET)
        {
            int ret = ::closesocket(m_socket);
            m_socket = INVALID_SOCKET;
            return ret;
        }
        return 0;
    }

    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));
    }

    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);
    }

    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 shutdown(int how)
    {
        return ::shutdown(m_socket, how);
    }

    virtual int recv(char* buf, int len) = 0;

    virtual int send(const char* buf, int len) = 0;

    virtual int sendv(WSABUF *bufs, DWORD nbufs)
    {
        bufs;
        nbufs;
        SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
        return SOCKET_ERROR;
    }

    virtual int transmitFile(HANDLE hFile, DWORD nNumberOfBytesToWrite, DWORD nNumberOfBytesPerSend, 
                             LPTRANSMIT_FILE_BUFFERS lpTransmitBuffers, DWORD dwFlags)
    {
        hFile;
        nNumberOfBytesToWrite;
        nNumberOfBytesPerSend;
        lpTransmitBuffers;
        dwFlags;
        SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
        return SOCKET_ERROR;
    }

protected:
    CAsyncSocketCallback    *m_pCallback;

    SOCKET                  m_socket;

    DWORD                   m_timeout;

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

class OW32_LIB_EXPORT CAsyncBlockingSocket : public CAsyncSocketBase
{
public:
    CAsyncBlockingSocket(CAsyncSocketCallback* pCallback, SOCKET s) :
        CAsyncSocketBase(pCallback, s)
    {
    }

    CAsyncBlockingSocket(CAsyncSocketCallback* pCallback) :
        CAsyncSocketBase(pCallback)
    {
    }

    virtual int recv(char* buf, int len);
    virtual int send(const char* buf, int len);
    virtual int connect(const struct sockaddr* name, int namelen);
    virtual int connect(CSockAddrIn& sockaddr_in) { return connect((const struct sockaddr *)&sockaddr_in, sizeof(sockaddr_in)); }

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

class OW32_LIB_EXPORT CAsyncIoCompletionSocket : 
    private CIoCompletion,
    public CAsyncSocketBase,
    public CIoTimeoutCallback
{
public:
    DLL_IMPLEMENT_IO_COMPLETION(CAsyncIoCompletionSocket, OW32_LIB_EXPORT)

    
    CAsyncIoCompletionSocket(CAsyncSocketCallback* pCallback, SOCKET s) :
        CAsyncSocketBase(pCallback,s),
        m_notificationCount(0),
        m_timeoutRefs(0)
    {
        Init();
    }

    CAsyncIoCompletionSocket(CAsyncSocketCallback* pCallback) :
        CAsyncSocketBase(pCallback),
        m_notificationCount(0),
        m_timeoutRefs(0)
    {
        Init();
    }

    virtual ~CAsyncIoCompletionSocket();

    bool associateWithIoCompletionPort(HANDLE hCompletionPort)
    {
        return !!CreateIoCompletionPort((HANDLE)(SOCKET)m_socket, hCompletionPort, (ULONG_PTR)this, 0) != NULL;
    }

    virtual int close();

    virtual int connect(const struct sockaddr* name, int namelen);

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

    virtual int shutdown(int how);

    virtual void setTimeout(DWORD timeout);

    virtual int recv(char* buf, int len);

    virtual int send(const char* buf, int len);

    virtual int sendv(WSABUF *bufs, DWORD nbufs);

    virtual int transmitFile(HANDLE hFile, DWORD nNumberOfBytesToWrite, DWORD nNumberOfBytesPerSend, 
                             LPTRANSMIT_FILE_BUFFERS lpTransmitBuffers, DWORD dwFlags);


    void expectNotification()
    {
        InterlockedIncrement(&m_notificationCount);
    }

    void receivedNotification();

private:
    // No copy or assignment
    CAsyncIoCompletionSocket(const CAsyncIoCompletionSocket& other);
    CAsyncIoCompletionSocket& operator=(const CAsyncIoCompletionSocket& other);

// CIoTimeoutCallback
    virtual void onTimeout(LPVOID Context);

// IOCP notification functions
    friend static LRESULT CALLBACK SocketNotifyWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
    void onConnectCompletion(BOOL bRet, DWORD cbBytesReceived, LPOVERLAPPED lpOS);
    void onSendCompletion(BOOL bRet, DWORD cbBytesSent, LPOVERLAPPED lpOS);
    void onReadCompletion(BOOL bRet, DWORD cbBytesReceived, LPOVERLAPPED lpOS);
    void onTransmitFileCompletion(BOOL bRet, DWORD cbBytesReceived, LPOVERLAPPED lpOS);

    inline bool AddTimeout();

    inline void ReleaseTimeout();

    void Init()
    {
        ZeroMemory(&m_osRead, sizeof(m_osRead));
        m_osRead.lpCompletion = onReadCompletion;

        ZeroMemory(&m_osSend, sizeof(m_osSend));

        m_SocketMap = 0;
    }

    CCriticalSection    m_socketLock;

    LONG                m_notificationCount;

    LONG                m_timeoutRefs;

    LPVOID              m_SocketMap;
    unsigned __int64    m_mapKey;

    OVERLAPPEDPLUS      m_osSend;
    OVERLAPPEDPLUS      m_osRead;
};

class OW32_LIB_EXPORT CAsyncAPCSocket : 
    public CAsyncSocketBase
{
public:
    CAsyncAPCSocket(CAsyncSocketCallback* pCallback, SOCKET s) :
        CAsyncSocketBase(pCallback,s)
    {
        ZeroMemory(&m_osRead, sizeof(m_osRead));
        m_osRead.pParent = this;
        ZeroMemory(&m_osSend, sizeof(m_osSend));
        m_osSend.pParent = this;
    }

    CAsyncAPCSocket(CAsyncSocketCallback* pCallback) :
        CAsyncSocketBase(pCallback)
    {
        ZeroMemory(&m_osRead, sizeof(m_osRead));
        m_osRead.pParent = this;
        ZeroMemory(&m_osSend, sizeof(m_osSend));
        m_osSend.pParent = this;
    }

    virtual ~CAsyncAPCSocket();

    virtual int recv(char* buf, int len);
    virtual int send(const char* buf, int len);
    virtual int connect(const struct sockaddr* name, int namelen);
    virtual int connect(CSockAddrIn& sockaddr_in) { return connect((const struct sockaddr *)&sockaddr_in, sizeof(sockaddr_in)); }

private:
    // No copy or assignment
    CAsyncAPCSocket(const CAsyncAPCSocket& other);
    CAsyncAPCSocket& operator=(const CAsyncAPCSocket& other);

    static void CALLBACK onSendCompletion(DWORD nErrorCode, DWORD cbTransferred, LPOVERLAPPED lpOverlapped);
    static void CALLBACK onReadCompletion(DWORD nErrorCode, DWORD cbTransferred, LPOVERLAPPED lpOverlapped);

    struct OW32_LIB_EXPORT OVERLAPPEDPLUS : public OVERLAPPED
    {
        CAsyncAPCSocket* pParent;
    };

    OVERLAPPEDPLUS m_osSend;
    OVERLAPPEDPLUS m_osRead;
};

class OW32_LIB_EXPORT CAsyncMessageSocket : 
    public CAsyncSocketBase
{
public:
    CAsyncMessageSocket(CAsyncSocketCallback* pCallback, SOCKET s) :
        CAsyncSocketBase(&m_callback,s),
        m_pCallback(pCallback),
        m_readBuf(0),
        m_sendBuf(0)
    {
        (void)setAsync();
    }

    CAsyncMessageSocket(CAsyncSocketCallback* pCallback) :
        CAsyncSocketBase(&m_callback),
        m_pCallback(pCallback),
        m_readBuf(0),
        m_sendBuf(0)
    {
    }

    ~CAsyncMessageSocket();

    virtual int recv(char* buf, int len);
    virtual int send(const char* buf, int len);
    virtual int connect(const struct sockaddr* name, int namelen);
    virtual int connect(CSockAddrIn& sockaddr_in) { return connect((const struct sockaddr *)&sockaddr_in, sizeof(sockaddr_in)); }

private:
    // No copy or assignment
    CAsyncMessageSocket(const CAsyncMessageSocket& other);
    CAsyncMessageSocket& operator=(const CAsyncMessageSocket& other);

    // Two slightly bent functions that make this fit into the IOCP model
    void onSendCompletion() { m_pCallback->onSendCompletion(TRUE, m_sendLen); }
    void onReadCompletion() { m_pCallback->onReadCompletion(TRUE, m_readLen); }
    friend static LRESULT CALLBACK SocketNotifyWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);

    // interception layer
    class OW32_LIB_EXPORT CAsyncMessageSocketCallback : public CAsyncSocketCallback
    {
    public:
        virtual void onReadCompletion(BOOL bRet, DWORD cbReceived);
        virtual void onSendCompletion(BOOL bRet, DWORD cbSent);
        virtual void onConnectCompletion(BOOL bRet) { 
            CAsyncMessageSocket* pParent = (CAsyncMessageSocket*)((char*)this - offsetof(CAsyncMessageSocket,m_callback));
            pParent->m_pCallback->onConnectCompletion(bRet); 
        }
        virtual void onCloseCompletion(BOOL bRet) {
            CAsyncMessageSocket* pParent = (CAsyncMessageSocket*)((char*)this - offsetof(CAsyncMessageSocket,m_callback));
            pParent->m_pCallback->onCloseCompletion(bRet); 
        }
    };
    friend CAsyncMessageSocketCallback;
    CAsyncMessageSocketCallback m_callback;

    int setAsync();

    // We need to keep this for sending ourselves messages
    HWND m_hWnd;

    CAsyncSocketCallback* m_pCallback;

    char* m_readBuf;
    int m_readLen;

    const char* m_sendBuf;
    int m_sendLen;
};

}; // namespace OW32

#endif // OW32_AsyncSocket_h

---