mdnsbrowser.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_MDNS
#include <promeki/namespace.h>
#include <promeki/atomic.h>
#include <promeki/buffer.h>
#include <promeki/duration.h>
#include <promeki/error.h>
#include <promeki/list.h>
#include <promeki/map.h>
#include <promeki/mdnsrecord.h>
#include <promeki/mdnsserviceinstance.h>
#include <promeki/mdnsservicetype.h>
#include <promeki/mutex.h>
#include <promeki/networkinterface.h>
#include <promeki/objectbase.h>
#include <promeki/socketaddress.h>
#include <promeki/string.h>
#include <promeki/timestamp.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class DnsRecord;
class MdnsManager;
using MdnsParsedRecord = DnsRecord;
 
class MdnsBrowser : public ObjectBase {
                PROMEKI_OBJECT(MdnsBrowser, ObjectBase)
        public:
                explicit MdnsBrowser(const MdnsServiceType &type, ObjectBase *parent = nullptr);
 
                ~MdnsBrowser() override;
 
                void setManager(MdnsManager *manager);
 
                MdnsManager *manager() const { return _manager; }
 
                MdnsManager *effectiveManager() const;
 
                const MdnsServiceType &serviceType() const { return _type; }
 
                bool isActive() const { return _active.value(); }
 
                Error start();
 
                void stop();
 
                Error sendQuery();
 
                void onManagerTick(const TimeStamp &now);
 
                static constexpr int64_t InitialQueryIntervalMs = 1000;
 
                static constexpr int64_t MaxQueryIntervalMs = 3600 * 1000;
 
                static constexpr int64_t CacheFlushGraceMs = 1000;
 
                static constexpr int64_t DirectedQueryDebounceMs = 2000;
 
                Duration currentBackoffInterval() const;
 
                uint64_t queryFireCount() const { return _queryFireCount.value(); }
 
                int evictExpired();
 
                int evictExpiredAt(const TimeStamp &now);
 
                List<MdnsServiceInstance> instances() const;
 
                void handlePacket(const Buffer &data, const SocketAddress &sender,
                                  const NetworkInterface &iface);
 
                void clearCache();
 
                PROMEKI_SIGNAL(serviceFound,   MdnsServiceInstance);
                PROMEKI_SIGNAL(serviceUpdated, MdnsServiceInstance);
                PROMEKI_SIGNAL(serviceLost,    MdnsServiceInstance);
 
        private:
                // Internal per-instance bookkeeping.  Stored in a Map
                // keyed by the lower-cased instance FQDN so DNS's
                // case-insensitive match is honoured cheaply.
                struct Entry {
                        MdnsServiceInstance instance;
                        TimeStamp           lastSeen;        
                        Duration            ttl;             
                        // Per-family cache-flush timestamps used to
                        // implement the RFC 6762 §10.2 "1-second
                        // grace" — a cache-flush A/AAAA arriving
                        // within @ref CacheFlushGraceMs of the prior
                        // one is treated as a continuation of the
                        // same multi-record announce and appended
                        // rather than wiping the list.
                        TimeStamp           lastV4FlushAt;
                        TimeStamp           lastV6FlushAt;
                        // Per-record-type "last directed query sent"
                        // timestamps for the follow-up query
                        // debounce (see @ref DirectedQueryDebounceMs).
                        // Index by @ref MdnsParsedRecord::Type cast
                        // to size_t via @ref directedQuerySlot.
                        TimeStamp           lastDirectedQuerySrvAt;
                        TimeStamp           lastDirectedQueryTxtAt;
                        TimeStamp           lastDirectedQueryAAt;
                        TimeStamp           lastDirectedQueryAaaaAt;
                        bool                foundEmitted = false;
                        bool                hasPtr       = false;
                };
 
                struct DirectedQuery {
                        String   name;
                        uint16_t recordType = 0;
                };
 
                // Helper: extract the instance label from a full
                // <Instance>._<app>._<proto>.<domain>. FQDN given the
                // browser's service-type FQDN.  Returns an empty
                // String when @p targetFqdn does not end with the
                // expected suffix.
                String extractInstanceLabel(const String &targetFqdn) const;
 
                // Returns a case-folded FQDN suitable for map keying.
                static String foldName(const String &s);
 
                // Applies one record to the cache.  May emit
                // serviceFound / serviceUpdated / serviceLost — the
                // signals are emitted with the mutex released.
                // Any directed follow-up queries needed to fill in
                // gaps (e.g. PTR → SRV/TXT, SRV → A/AAAA) are
                // appended to @p directedQueries; the caller is
                // responsible for issuing them after the mutex is
                // released.
                void processRecord(const MdnsParsedRecord &record,
                                   const NetworkInterface &iface,
                                   List<DirectedQuery>    &directedQueries);
 
                // Helper used by @ref processRecord.  Examines the
                // given @p entry against the "what we still need"
                // gap list and stages directed queries onto
                // @p directedQueries when the @ref DirectedQueryDebounceMs
                // gate allows.  Updates the entry's debounce
                // timestamps in place when a query is staged.
                void planDirectedFollowups(Entry &entry, const TimeStamp &now,
                                           List<DirectedQuery> &directedQueries);
 
                // Issues every staged directed query off-lock.  No-op
                // when @ref _manager is null or not active.
                void issueDirectedQueries(const List<DirectedQuery> &queries);
 
                // Builds the Known-Answer Suppression list for an
                // outbound continuous-query — one PTR record per
                // currently-cached, still-fresh entry.  Walks under
                // @ref _entriesMtx; safe to call from any thread.
                List<MdnsRecord> composeKnownAnswers() const;
 
                // Returns @c true when the instance has the minimal
                // identity needed to be exposed via @ref serviceFound
                // (port + hostname).  Address records may arrive
                // later; tests can decide separately how strict to be.
                static bool isAddressable(const MdnsServiceInstance &inst);
 
                MdnsServiceType   _type;
                MdnsManager      *_manager = nullptr;
                mutable Mutex     _entriesMtx;
                Map<String, Entry> _entries;
                Atomic<bool>      _active;
                Atomic<uint64_t>  _queryFireCount;
 
                // Backoff schedule — protected by the same mutex as
                // the entries map.  Reset to the initial interval on
                // every @ref start; doubled by @ref onManagerTick.
                TimeStamp         _nextQueryAt;
                Duration          _currentInterval;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_MDNS