Listener.h

Go to the documentation of this file.

/*  Listener.h - IOCP socket listener helper functions
    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_Listener_h
#define OW32_Listener_h

#include <OW32/Socket.h>
#include <OW32/AsyncSocket.h>
#include <OW32/XSOCKET.h>
#include <OW32/IoCompletion.h>
#include <OW32/SyncObjects.h>

namespace OW32 
{

class OW32_LIB_EXPORT CListener;

class OW32_LIB_EXPORT CListenerCallback
{
public:
    virtual BOOL onAcceptCompletion(CListener* /*listener*/, BOOL bRet, DWORD /*cbTransferred*/) { return bRet; }
};

class OW32_LIB_EXPORT CListener
{
public:
    CListener(CListenerCallback* pCallback) :
        m_pCallback(pCallback),
        m_port(0)
    {
    }

    virtual ~CListener() = 0 {}
    
    virtual void Cancel()
    {
        m_sListen.close();
    }

    virtual bool Cancelled()
    {
        return m_sListen == INVALID_SOCKET;
    }

    CListenerCallback *GetCallback() const
    {
        return m_pCallback;
    }

    int GetPort() const { return m_port; }

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

        // Fill out the local socket's address information.
        CSockAddrIn local_sin(htons (static_cast<u_short>(port)));
        if (m_sListen.bind(local_sin)==SOCKET_ERROR)
            return FALSE;

        // Establish a socket to listen for incoming connections.
        if (m_sListen.listen (SOMAXCONN) == SOCKET_ERROR)
            return FALSE;

        m_port = port;
        return TRUE;
    }

    virtual int Accept()=0;

    virtual int ListenAndAccept(int port)
    {
        return (Listen(port) != SOCKET_ERROR && Accept() != SOCKET_ERROR) ? 0 : SOCKET_ERROR;
    }

    virtual int GetAddresses(sockaddr_in** local_address, sockaddr_in** remote_address)=0;

    virtual int GetRemoteAddress(sockaddr_in** remote_address)
    {
        return GetAddresses(NULL,remote_address);
    }

    virtual int GetLocalAddress(sockaddr_in** local_address)
    {
        GetAddresses(local_address,NULL);
        return 0;
    }

    virtual SOCKET DetachAcceptedSocket() {
        return m_sAccepted.Detach();
    }

protected:
    int m_port;
    CSocket m_sListen;
    XSOCKET m_sAccepted;
    CListenerCallback* m_pCallback;
};

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

    
    CIoCompletionListener(CListenerCallback* pCallback) :
        CListener(pCallback)
    {
        ZeroMemory(&m_os, sizeof(m_os));
        m_os.lpCompletion = onAcceptCompletion;
    }

    virtual void Cancel()
    {
        CSingleLock lock(m_socketLock);
        m_sListen.close();
    }

    virtual bool Cancelled()
    {
        CSingleLock lock(m_socketLock);
        return m_sListen == INVALID_SOCKET;
    }

    void onAcceptCompletion(BOOL bRet, DWORD cbTransferred, LPOVERLAPPED /*lpOS*/)
    {
        if (m_pCallback->onAcceptCompletion(this, bRet, cbTransferred))
        {
            while (Accept() == SOCKET_ERROR && m_pCallback->onAcceptCompletion(this, FALSE, 0))
                ;
        }
    }

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

        // Fill out the local socket's address information.
        CSockAddrIn local_sin(htons (static_cast<u_short>(port)));
        if (m_sListen.bind(local_sin)==SOCKET_ERROR)
            return SOCKET_ERROR;

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

        m_port = port;
        return 0;
    }

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

        DWORD dwDummy=0;
        CSingleLock lock(m_socketLock);
        if (!AcceptEx(m_sListen, m_sAccepted, m_buffer, 0, 
             sizeof(sockaddr_in) + 16, sizeof(sockaddr_in) + 16,
             &dwDummy, &m_os)) 
        {
            DWORD error = ::GetLastError();
            lock.Unlock();
            if (error != ERROR_IO_PENDING)
                return SOCKET_ERROR;
        }
        return 0;
    }

    int ListenAndAcceptWithPort(int Port, HANDLE hCompletionPort)
    {
        return (Listen(Port) != SOCKET_ERROR && 
               associateWithIoCompletionPort(hCompletionPort) && 
               Accept() != SOCKET_ERROR) ? 0 : SOCKET_ERROR;
    }

    virtual int 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);
        return 0;
    }

    BOOL associateWithIoCompletionPort(HANDLE hCompletionPort)
    {
        return CreateIoCompletionPort(
            (HANDLE)(SOCKET)m_sListen, hCompletionPort, 
            reinterpret_cast<ULONG_PTR>(static_cast<CIoCompletion*>(this)), 0) != NULL;
    }

    operator SOCKET() { return m_sListen; }

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

    char m_buffer[(sizeof(sockaddr_in)+16)*2];
    OVERLAPPEDPLUS m_os;
    CCriticalSection m_socketLock;
};

class OW32_LIB_EXPORT CMessageListener : 
    public CListener, 
    public CAsyncSocketCallback
{
public:
    CMessageListener(CListenerCallback* pCallback) :
        CListener(pCallback)
    {
    }

    void onAcceptCompletion(BOOL bRet)
    {
        bRet;
        int sock_addr_len = sizeof(m_remote_addr);
        m_sAccepted = m_sListen.accept(&m_remote_addr, &sock_addr_len);
        if (m_pCallback->onAcceptCompletion(this, m_sAccepted!=SOCKET_ERROR, 0))
        {
            while (!Accept() && m_pCallback->onAcceptCompletion(this, FALSE, 0))
                ;
        }
    }

    int Accept();

    virtual int GetAddresses(sockaddr_in** local_addr, sockaddr_in** remote_addr)
    {
        if (remote_addr)
            *remote_addr = (sockaddr_in*)&m_remote_addr;
        if (local_addr)
        {
            *local_addr = 0; // just in case
            int local_addr_len = sizeof(m_local_addr);
            if (getsockname(m_sAccepted, &m_local_addr, &local_addr_len)==SOCKET_ERROR)
                return SOCKET_ERROR;
            *local_addr = (sockaddr_in*)&m_local_addr;
        }
        return 0;
    }

    operator SOCKET() { return m_sListen; }

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

    sockaddr m_remote_addr,m_local_addr;
};

} // namespace OW32

#endif // OW32_Listener_h

---