IoCompletionListener.h

Go to the documentation of this file.

/*  IoCompletionListener.h - IOCP socket listener
    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_IoCompletionListener_h
#define OW32_IoCompletionListener_h

#include <OW32/XSOCKET.h>
#include <OW32/SyncObjects.h>

namespace OW32 
{

class CIoCompletionListenerAcceptEx;
class CIoCompletionListener;

class OW32_LIB_EXPORT CIoCompletionListenerCallback
{
public:
    virtual void onAcceptCompletion(CIoCompletionListenerAcceptEx *accepted, bool bRet, DWORD /*cbTransferred*/) = 0;
};

class CIoCompletionListenerAcceptEx :
    public CIoCompletion
{
public:
    CIoCompletionListenerAcceptEx(CIoCompletionListener *listener, CIoCompletionListenerCallback *callback) :
        m_listener(listener),
        m_callback(callback)
    {
        ZeroMemory(&m_os, sizeof(OVERLAPPED));
    }

    virtual void OnIoCompletion(BOOL bRet, DWORD dwBytes, LPOVERLAPPED lpOS)
    {
        lpOS;
        m_callback->onAcceptCompletion(this, !!bRet, dwBytes);
    }

    void getAddresses(sockaddr_in **local_address, sockaddr_in **remote_address)
    {
        INT local_address_len = sizeof(sockaddr_in);
        INT remote_address_len = sizeof(sockaddr_in);
        sockaddr *temp_local, *temp_remote;
        GetAcceptExSockaddrs(m_buffer, 0, sizeof(sockaddr_in)+16, sizeof(sockaddr_in)+16, 
            local_address ? (sockaddr**)local_address : &temp_local, &local_address_len,
            remote_address ? (sockaddr**)remote_address : &temp_remote, &remote_address_len);
    }

    CIoCompletionListener *getListener() const
    {
        return m_listener;
    }

    SOCKET detachAcceptedSocket()
    {
        return m_accepted.Detach();
    }

    int post(SOCKET sListen)
    {
        // Create an explicitly non-blocking socket: for apps that are naughty (like
        // perl) and turn off the overlapped flag by default
        m_accepted = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, NULL, WSA_FLAG_OVERLAPPED);
        if (m_accepted == SOCKET_ERROR)
        {
            delete this;
            return SOCKET_ERROR;
        }

        DWORD dwDummy = 0;
        if (!AcceptEx(sListen, m_accepted, m_buffer, 0, 
                      sizeof(sockaddr_in) + 16, sizeof(sockaddr_in) + 16,
                      &dwDummy, &m_os)) 
        {
            DWORD error = ::GetLastError();
            if (error != ERROR_IO_PENDING)
            {
                delete this;
                ::SetLastError(error);
                return SOCKET_ERROR;
            }
        }
        return 0;
    }

private:
    CIoCompletionListener           *m_listener;
    CIoCompletionListenerCallback   *m_callback;
    XSOCKET                         m_accepted;
    char                            m_buffer[(sizeof(sockaddr_in)+16)*2];
    /* The overlapped structure in use */
    OVERLAPPED                      m_os;
};

class OW32_LIB_EXPORT CIoCompletionListener
{
public:
    DLL_IMPLEMENT_IO_COMPLETION(CIoCompletionListener, OW32_LIB_EXPORT)

    
    CIoCompletionListener(CIoCompletionListenerCallback* callback) :
        m_callback(callback)
    {
    }

    void cancel()
    {
        CSingleLock lock(m_socketLock);
        m_listen.Close();
    }

    bool cancelled()
    {
        CSingleLock lock(m_socketLock);
        return m_listen == INVALID_SOCKET;
    }

    int listen(int port, HANDLE hCompletionPort)
    {
        // Create an explicitly non-blocking socket: for apps that are naughty (like
        // perl) and turn off the overlapped flag by default
        m_listen = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, NULL, WSA_FLAG_OVERLAPPED);
        if (m_listen == INVALID_SOCKET)
            return FALSE;

        // Fill out the local socket's address information.
        sockaddr_in local_sin;
        local_sin.sin_port              = htons(static_cast<u_short>(port));
        local_sin.sin_addr.S_un.S_addr  = INADDR_ANY;
        local_sin.sin_family            = AF_INET;

        // Bind the socket
        if (::bind(m_listen, reinterpret_cast<const sockaddr *>(&local_sin), sizeof(local_sin)) == SOCKET_ERROR)
            return SOCKET_ERROR;

        // Establish a socket to listen for incoming connections.
        if (::listen(m_listen, SOMAXCONN) == SOCKET_ERROR)
            return SOCKET_ERROR;

        // Associated with the IOCP
        if (!CreateIoCompletionPort(
                reinterpret_cast<HANDLE>(static_cast<SOCKET>(m_listen)), hCompletionPort, 
                reinterpret_cast<ULONG_PTR>(static_cast<CIoCompletion*>(this)), 0))
            return SOCKET_ERROR;

        // Store the port
        m_port = port;
        return 0;
    }

    int postAccept()
    {
        CIoCompletionListenerAcceptEx *acceptEx = new (std::nothrow) CIoCompletionListenerAcceptEx(this, m_callback);
        if (!acceptEx)
        {
            ::SetLastError(ERROR_INSUFFICIENT_MEMORY);
            return SOCKET_ERROR;
        }
        CSingleLock lock(m_socketLock);
        return acceptEx->post(m_listen);
    }

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

    CIoCompletionListenerCallback   *m_callback;
    CCriticalSection                m_socketLock;
    XSOCKET                         m_listen;
};

} // namespace OW32

#endif // OW32_IoCompletionListener_h

---