AsyncResolverServer.h

Go to the documentation of this file.

/*  AsyncResolverServer.h - asynchronous DNS server encapsulation
    Copyright (C) 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_AsyncResolverServer_h
#define OW32_AsyncResolverServer_h

#include <OW32/windows.h>
#include <OW32/auto_array_ptr.h>
#include <OW32/SyncObjects.h>
#include <OW32/auto_buf.h>
#include <OW32/XSOCKET.h>

#include <list>

namespace OW32
{

class OW32_LIB_EXPORT CAsyncResolver;

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

class OW32_LIB_EXPORT CAsyncResolverServer
{
public:
    CAsyncResolverServer(CAsyncResolver *pParent, size_t serverIndex, in_addr addr);

    AsyncResolverError sendQuery(CAsyncResolverQuery *query);

    AsyncResolverError destroy();

    const size_t getServerIndex() const { return m_serverIndex; }

private:
    CAsyncResolverServer(const CAsyncResolverServer &);
    CAsyncResolverServer& operator=(const CAsyncResolverServer &);

    class OW32_LIB_EXPORT CUDPConnection : public CIoCompletion
    {
    public:
        CUDPConnection();

        typedef void (CUDPConnection::*CompletionFn)(BOOL bRet, DWORD dwBytes, LPOVERLAPPED lpOS);

        struct OW32_LIB_EXPORT OVERLAPPEDPLUS : public OVERLAPPED
        {
            CompletionFn            lpCompletion;
        };

        struct SENDOVERLAPPED : public OVERLAPPEDPLUS
        {
            SENDOVERLAPPED(CAsyncResolverQuery *query_) :
                query(query_)
            {
            }

            CAsyncResolverQueryPtr  query;
        };

        virtual void OnIoCompletion(BOOL bRet, DWORD dwBytes, LPOVERLAPPED lpOS)
        {
            OVERLAPPEDPLUS* lpOSPlus = (OVERLAPPEDPLUS*)lpOS;
            (this->*(lpOSPlus->lpCompletion))(bRet, dwBytes, lpOS);
        }

        void onSendCompletion(BOOL bRet, DWORD cbBytesSent, LPOVERLAPPED lpOS);

        void onReadCompletion(BOOL bRet, DWORD cbBytesReceived, LPOVERLAPPED lpOS);

        void onAllNotificationsProcessed();

        AsyncResolverError sendQuery(CAsyncResolverQuery *query);

        AsyncResolverError destroy();

    private:
        void expectNotification() 
        { 
            InterlockedIncrement(&m_outstandingNotifications); 
        }

        void receivedNotification() 
        {
            if (InterlockedDecrement(&m_outstandingNotifications) == 0)
                onAllNotificationsProcessed();
        }

        OVERLAPPEDPLUS          m_osRead;
        auto_array_ptr<BYTE>    m_answer;
        XSOCKET                 m_socket;
        CCriticalSection        m_lock;
        LONG                    m_outstandingNotifications;
        bool                    m_fInDestruction;
        CEvent                  m_evDestruction;
    };
    CUDPConnection          m_udpConnection;

    class OW32_LIB_EXPORT CTCPConnection : public CAsyncSocketCallback
    {
    public:
        CTCPConnection();

        // CAsyncSocketCallback
        virtual void onConnectCompletion(BOOL bRet);
        virtual void onReadCompletion(BOOL bRet, DWORD dwBytes);
        virtual void onSendCompletion(BOOL bRet, DWORD dwBytes);
        virtual void onAllNotificationsProcessed();

        AsyncResolverError sendQuery(CAsyncResolverQuery *query);

        AsyncResolverError destroy();

    private:
        AsyncResolverError makeConnection();

        bool sendQueuedItem(CSingleLock &lock);

        void handleError(CSingleLock &lock, AsyncResolverError status);

        bool                                m_fOkToSend;
        CCriticalSection                    m_lock;
        std::list<CAsyncResolverQueryPtr>   m_queue;
        size_t                              m_length;
        size_t                              m_sendPos;
        auto_byte_buf                       m_answer;
        std::auto_ptr<CAsyncIoCompletionSocket> m_pSocket;
        bool                                m_fInDestruction;
        CEvent                              m_evDestruction;
    };
    CTCPConnection              m_tcpConnection;

    in_addr                     m_addr;
    CAsyncResolver              *m_pParent;
    size_t                      m_serverIndex;
};

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

} // namespace OW32

#endif // OW32_AsyncResolverServer_h

---