AsyncResolver.h

Go to the documentation of this file.

/*  AsyncResolver.h - simple asynchronous DNS resolver stub
    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.
*/

/* Copyright 1998 by the Massachusetts Institute of Technology.
 *
 * Permission to use, copy, modify, and distribute this
 * software and its documentation for any purpose and without
 * fee is hereby granted, provided that the above copyright
 * notice appear in all copies and that both that copyright
 * notice and this permission notice appear in supporting
 * documentation, and that the name of M.I.T. not be used in
 * advertising or publicity pertaining to distribution of the
 * software without specific, written prior permission.
 * M.I.T. makes no representations about the suitability of
 * this software for any purpose.  It is provided "as is"
 * without express or implied warranty.
 */

#ifndef OW32_AsyncResolver_h
#define OW32_AsyncResolver_h

#if defined(_MSC_VER) && !defined(_DEBUG)
#pragma warning(disable: 4702)
#endif
#include <map>
#include <vector>
#if defined(_MSC_VER) && !defined(_DEBUG)
#pragma warning(default: 4702)
#endif

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

#include <OW32/AsyncResolverSearch.h>
#include <OW32/AsyncResolverOptions.h>
#include <OW32/AsyncResolverRandom.h>
#include <OW32/AsyncResolverHostCallback.h>
#include <OW32/AsyncResolverHostsDB.h>

#include <OW32/FileWatch.h>
#include <OW32/FileWatchCallback.h>

namespace OW32
{

class OW32_LIB_EXPORT CAsyncResolver;
class OW32_LIB_EXPORT CAsyncResolverServer;
class OW32_LIB_EXPORT CFileWatcher;

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

class OW32_LIB_EXPORT CAsyncResolver :
    public CIoTimeoutCallback,
    public CIoTimeoutDrainCallback,
    private CFileWatchCallback
{
    // options and stuff
public:
    CAsyncResolver() {}

    AsyncResolverError initialise(
        const CAsyncResolverOptions *pOptions, 
        HANDLE                      hIoPort,
        CFileWatcher                *pFileWatcher = NULL,
        const char                  *random_data = NULL);

    ~CAsyncResolver();

    AsyncResolverError terminate();

    HANDLE getIoCompletionPort() { return m_hIoCompletionPort; }

    void gethostbyname(CAsyncResolverHostCallback *pCallback, void *context, const char *name, int family);

    void gethostbyaddr(CAsyncResolverHostCallback *pCallback, void *context, const void *addr, int addrlen, int family);

    void search(CAsyncResolverCallback *pCallback, void *context, const char *name, int dnsclass, int type);

    void sendQuery(CAsyncResolverQuery *query);

    static AsyncResolverError expandName(
            const unsigned char *encoded, 
            const unsigned char *abuf, size_t alen, 
            char **s, size_t *enclen);

    AsyncResolverError getHostsDB(CAsyncResolverHostsDBPtr &hostsDB);

    static AsyncResolverError getHostEnt(FILE *fp, struct hostent **host);

    static void freeHostEnt(struct hostent *host);

    static const TCHAR *describeError(AsyncResolverError code);

    static AsyncResolverError readLine(FILE *fp, char **buf, size_t *bufsize);

    unsigned int random(unsigned int n);

    const CAsyncResolverOptions *getOptions() const { return m_pOptions; }

    void OnAnswer(size_t serverIndex, bool fTCP, BYTE *abuf, size_t alen);

    void OnError(size_t serverIndex, bool fTCP, AsyncResolverError status, CAsyncResolverQuery *query);

// CIoTimeoutCallback:
    virtual void onTimeout(LPVOID key);

// CIoTimeoutDrainCallback
    virtual bool drainTimeout(CIoTimeoutCallback *pCallback, LPVOID key);

private:
// CFileWatchCallback
    virtual void onChanged(CFileWatch *watch, const FILE_NOTIFY_INFORMATION *notifyInfo);

    virtual void onFailure(CFileWatch *watch, DWORD error);

private:
    bool removeQuery(CAsyncResolverQuery *query);

    // prohibit copy and assignment
    CAsyncResolver(const CAsyncResolver &);
    CAsyncResolver& operator=(const CAsyncResolver &);

    void nextServer(CAsyncResolverQuery *query);

    typedef std::multimap<int, CAsyncResolverQueryPtr> querymap_t;
    querymap_t                          m_queryMap;
    CCriticalSection                    m_queryMapLock;

    CAsyncResolverRandom                m_random;
    CCriticalSection                    m_randomLock;

    const CAsyncResolverOptions         *m_pOptions;
    std::vector<CAsyncResolverServer *> m_servers;
    bool                                m_fInDestruction;

    CCriticalSection                    m_hostsDBLock;
    CAsyncResolverHostsDBPtr            m_hostsDB;
    CFileWatchPtr                       m_fileWatch;

    CFileWatcher                        *m_pFileWatcher;

    HANDLE                              m_hIoCompletionPort;
};

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

}; // namespace OW32

#endif // OW32_AsyncResolver_h

---