AsyncResolverOptions.h

Go to the documentation of this file.

/*  AsyncResolverOptions.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_AsyncResolverOptions_h
#define OW32_AsyncResolverOptions_h

#include <OW32/AsyncResolverError.h>
#include <OW32/tstl.h>
#include <vector>
#include <string>

namespace OW32
{

struct apattern 
{
    struct in_addr addr;
    struct in_addr mask;
};

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

class OW32_LIB_EXPORT CAsyncResolverOptions
{
public:
    CAsyncResolverOptions();

    AsyncResolverError init(const TCHAR *confPath = NULL);

    AsyncResolverError setSearch(const char *domain_list);

    AsyncResolverError setDomain(const char *domain);

    const std::vector<std::string> &getSearch() const { return m_domains; }

    AsyncResolverError setLookup(const char *lookups);

    const std::string &getLookup() const { return m_lookups; }

    AsyncResolverError setNameServer(const char *ns);

    void clearNameServers() { m_servers.clear(); }

    const std::vector<in_addr> &getServers() const { return m_servers; }

    AsyncResolverError setSortList(const char *sl);

    const std::vector<apattern> getSortList() const { return m_sortlist; }

    void setHostsPath(const TCHAR *path);

    const std::_tstring &getHostsPath() const { return m_hosts_path; }

    void setDots(int ndots) { m_ndots = ndots; }

    int getDots() const { return m_ndots; }

    void setTries(int tries) { m_tries = tries; }

    const int getTries() const { return m_tries; }

    void setTimeout(int timeout) { m_timeout = timeout; }

    const int getTimeout() const { return m_timeout; }

    void setUDPPort(unsigned short udp_port) { m_udp_port = udp_port; }

    const unsigned short getUDPPort() const { return m_udp_port; }

    /*
     * Set the nameserver TCP port, defaults to 53.
     */
    void setTCPPort(unsigned short tcp_port) { m_tcp_port = tcp_port; }

    const unsigned short getTCPPort() const { return m_tcp_port; }

    enum OptionFlagValues
    {
        ARES_FLAG_USEVC         = (1 << 0),
        ARES_FLAG_PRIMARY       = (1 << 1),
        ARES_FLAG_IGNTC         = (1 << 2),
        ARES_FLAG_NORECURSE     = (1 << 3),
        ARES_FLAG_STAYOPEN      = (1 << 4),
        ARES_FLAG_NOSEARCH      = (1 << 5),
        ARES_FLAG_NOALIASES     = (1 << 6),
        ARES_FLAG_NOCHECKRESP   = (1 << 7)
    };

    void setFlags(int flags) { m_flags = flags; }

    const int getFlags() const { return m_flags; }

private:
    AsyncResolverError initByEnvironment();

    AsyncResolverError initByConf(const TCHAR *confPath = NULL);

    AsyncResolverError initByIPHelper();

    AsyncResolverError initByRegistry();

    AsyncResolverError initByDefaults();

    AsyncResolverError setOptions(const char *opt);

    int                         m_flags;
    int                         m_timeout;
    int                         m_tries;
    int                         m_ndots;
    unsigned short              m_udp_port;
    unsigned short              m_tcp_port;
    std::vector<in_addr>        m_servers;
    std::vector<std::string>    m_domains;
    std::vector<apattern>       m_sortlist;
    std::string                 m_lookups;
    std::_tstring               m_hosts_path;
    bool                        m_fSetServers;
    bool                        m_fSetSearch;
    bool                        m_fSetSort;
};

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

} // namespace OW32

#endif // OW32_AsyncResolverOptions_h

---