dnscache.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/dnsrecord.h>
#include <promeki/duration.h>
#include <promeki/enums_dns.h>
#include <promeki/list.h>
#include <promeki/map.h>
#include <promeki/mutex.h>
#include <promeki/string.h>
#include <promeki/timestamp.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class DnsCache {
        public:
                static constexpr int64_t DefaultMaxTtlSeconds = 3600;
 
                static constexpr int64_t DefaultMaxNegativeTtlSeconds = 300;
 
                static constexpr size_t DefaultCapacity = 4096;
 
                DnsCache();
 
                void setMaxTtl(const Duration &d);
                Duration maxTtl() const;
 
                void setMaxNegativeTtl(const Duration &d);
                Duration maxNegativeTtl() const;
 
                void setCapacity(size_t cap);
 
                size_t capacity() const;
 
                size_t size() const;
 
                void clear();
 
                struct Hit {
                        bool          found    = false;
                        bool          negative = false;
                        DnsRcode      rcode;
                        List<DnsRecord> records;
                };
 
                Hit get(const String &name, uint16_t type, uint16_t klass) const;
 
                void put(const String &name, uint16_t type, uint16_t klass,
                         const List<DnsRecord> &records,
                         const Duration &ttlCap = Duration::zero());
 
                void putNegative(const String &name, uint16_t type, uint16_t klass,
                                 const DnsRcode &rcode,
                                 const Duration &ttlCap = Duration::zero());
 
        private:
                struct Entry {
                        TimeStamp       expiresAt;
                        bool            negative = false;
                        DnsRcode        rcode    = DnsRcode::NoError;
                        List<DnsRecord> records;
                };
 
                struct Key {
                        String   name;
                        uint16_t type  = 0;
                        uint16_t klass = 0;
                        bool operator<(const Key &o) const {
                                if (name  < o.name)  return true;
                                if (o.name  < name)  return false;
                                if (type  < o.type)  return true;
                                if (type  > o.type)  return false;
                                return klass < o.klass;
                        }
                };
 
                void evictIfOversized();
 
                mutable Mutex     _mtx;
                Map<Key, Entry>   _entries;
                Duration          _maxTtl;
                Duration          _maxNegTtl;
                size_t            _cap = DefaultCapacity;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_NETWORK