dnsresolver.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_NETWORK
#include <cstdint>
#include <promeki/namespace.h>
#include <promeki/atomic.h>
#include <promeki/dnscache.h>
#include <promeki/dnsconfig.h>
#include <promeki/dnsrecord.h>
#include <promeki/duration.h>
#include <promeki/enums_dns.h>
#include <promeki/error.h>
#include <promeki/list.h>
#include <promeki/map.h>
#include <promeki/networkaddress.h>
#include <promeki/objectbase.h>
#include <promeki/result.h>
#include <promeki/socketaddress.h>
#include <promeki/string.h>
#include <promeki/uniqueptr.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class DnsResolver;
class MdnsManager;
class TcpSocket;
class UdpSocket;
class TimerEvent;
 
class DnsLookup : public ObjectBase {
                PROMEKI_OBJECT(DnsLookup, ObjectBase)
        public:
                DnsLookup(DnsResolver *resolver, const String &name,
                          const DnsRecordType &type,
                          const DnsRecordClass &klass = DnsRecordClass::In);
 
                ~DnsLookup() override;
 
                const String &name() const { return _name; }
 
                const DnsRecordType &type() const { return _type; }
 
                const DnsRecordClass &klass() const { return _klass; }
 
                const DnsRcode &rcode() const { return _rcode; }
 
                void cancel();
 
                bool isActive() const { return _active.value(); }
 
                PROMEKI_SIGNAL(answered, List<DnsRecord>);
 
                PROMEKI_SIGNAL(failed,   Error);
 
        protected:
                void timerEvent(TimerEvent *e) override;
 
        private:
                friend class DnsResolver;
 
                DnsResolver           *_resolver = nullptr;
                String                 _name;
                DnsRecordType          _type     = DnsRecordType::A;
                DnsRecordClass         _klass    = DnsRecordClass::In;
                DnsRcode               _rcode    = DnsRcode::NoError;
                Atomic<bool>           _active;
                Atomic<bool>           _emitted;
};
 
class DnsResolver : public ObjectBase {
                PROMEKI_OBJECT(DnsResolver, ObjectBase)
        public:
                static constexpr int MaxCnameDepth = 16;
 
                static constexpr uint16_t Edns0UdpSize = 1232;
 
                static constexpr int64_t DefaultAttemptTimeoutMs = 3000;
 
                static DnsResolver *defaultInstance();
 
                explicit DnsResolver(ObjectBase *parent = nullptr);
 
                ~DnsResolver() override;
 
                void setNameservers(const List<SocketAddress> &servers);
 
                List<SocketAddress> nameservers() const;
 
                void setSearchDomains(const StringList &domains);
 
                StringList searchDomains() const;
 
                void setConfig(const DnsConfig &cfg);
 
                DnsConfig config() const;
 
                Error reloadSystemConfig();
 
                DnsCache &cache() { return _cache; }
                const DnsCache &cache() const { return _cache; }
 
                void setMdnsManager(MdnsManager *manager);
 
                MdnsManager *mdnsManager() const;
 
                void setMdnsRoutingEnabled(bool enable);
 
                bool mdnsRoutingEnabled() const;
 
                DnsLookup *lookup(const String &name,
                                  const DnsRecordType &type = DnsRecordType::A,
                                  const DnsRecordClass &klass = DnsRecordClass::In);
 
                static Result<List<DnsRecord>> lookupSync(
                        const String &name,
                        const DnsRecordType &type = DnsRecordType::A,
                        const Duration &timeout = Duration::fromSeconds(5));
 
                static Result<NetworkAddress> resolveSync(
                        const String &host,
                        NetworkAddress::FamilyPreference prefer = NetworkAddress::PreferIPv4,
                        const Duration &timeout = Duration::fromSeconds(5));
 
                static Result<List<DnsRecord>> lookupReverseSync(
                        const NetworkAddress &addr,
                        const Duration &timeout = Duration::fromSeconds(5));
 
        private:
                friend class DnsLookup;
 
                struct Inflight;
 
                Error openSocketsIfNeeded();
                void  closeSockets();
                void  beginLookup(DnsLookup *lookup);
                void  beginAttempt(Inflight *flight);
                bool  isMdnsName(const String &name) const;
                Error beginMdnsLookup(Inflight *flight);
                void  handleMdnsPacket(Inflight *flight, const Buffer &data);
                MdnsManager *effectiveMdnsManager();
                void  onLookupTimeout(DnsLookup *lookup);
                void  failLookup(DnsLookup *lookup, Error err);
                void  succeedLookup(DnsLookup *lookup, const List<DnsRecord> &records);
                void  handleSocketReadable(UdpSocket *sock);
                void  processResponseBytes(const uint8_t *data, size_t len);
                void  followCname(Inflight *flight, const String &target);
                void  beginTcpFallback(Inflight *flight);
                void  removeInflight(DnsLookup *lookup);
                uint16_t allocateTransactionId();
                List<String> expandSearch(const String &name) const;
                Error  sendQueryUdp(Inflight *flight);
                static List<DnsRecord> filterAnswerRecords(
                        const class DnsPacket &pkt,
                        const String &name, uint16_t type, uint16_t klass);
                static Duration soaMinimumFromAuthority(const class DnsPacket &pkt);
 
                mutable Mutex                _cfgMtx;
                DnsConfig                    _config;
                DnsCache                     _cache;
                UniquePtr<UdpSocket>         _socketV4;
                UniquePtr<UdpSocket>         _socketV6;
                int                          _ioHandleV4 = -1;
                int                          _ioHandleV6 = -1;
 
                // mDNS routing — populated lazily via
                // @ref effectiveMdnsManager.  @c _mdnsManager is the
                // explicit override; when null we fall back to
                // @ref Application::mdnsManager.  The observer handle
                // is registered with the manager on first .local.
                // lookup and unregistered when the resolver dies.
                MdnsManager                 *_mdnsManager        = nullptr;
                int                          _mdnsObserverHandle = -1;
                bool                         _mdnsRoutingEnabled = true;
 
                // In-flight bookkeeping: keyed by transaction id.
                // The Inflight owns the timer; lookup ownership stays
                // with the parent (this resolver).  An Inflight is
                // created when @ref beginLookup posts to our loop and
                // destroyed when the lookup completes or is
                // cancelled.
                Map<uint16_t, Inflight *>    _inflight;
                Map<DnsLookup *, Inflight *> _byLookup;
                uint16_t                     _nextTxId = 0;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_NETWORK