mdnspublisher.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_MDNS
#include <cstdint>
#include <promeki/namespace.h>
#include <promeki/atomic.h>
#include <promeki/buffer.h>
#include <promeki/error.h>
#include <promeki/list.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 MdnsManager;
 
class MdnsPublisher : public ObjectBase {
                PROMEKI_OBJECT(MdnsPublisher, ObjectBase)
        public:
                enum class State : uint8_t {
                        Idle         = 0,
                        Probing      = 1,
                        Announcing   = 2,
                        Published    = 3,
                        Conflicted   = 4,
                        Withdrawing  = 5,
                };
 
                static constexpr int64_t ProbeIntervalMs = 250;
 
                static constexpr int ProbeCount = 3;
 
                static constexpr int64_t AnnounceIntervalMs = 1000;
 
                static constexpr int AnnounceCount = 2;
 
                static constexpr int MaxRenameAttempts = 8;
 
                explicit MdnsPublisher(ObjectBase *parent = nullptr);
 
                ~MdnsPublisher() override;
 
                void setInstance(const MdnsServiceInstance &instance);
 
                const MdnsServiceInstance &instance() const { return _instance; }
 
                void setAutoRename(bool enable) { _autoRename = enable; }
 
                bool autoRename() const { return _autoRename; }
 
                void setManager(MdnsManager *manager);
 
                MdnsManager *manager() const { return _manager; }
 
                MdnsManager *effectiveManager() const;
 
                State state() const { return _state.value(); }
 
                bool isActive() const { return state() != State::Idle && state() != State::Conflicted; }
 
                Error publish();
 
                void withdraw();
 
                List<MdnsRecord> records() const;
 
                void handlePacket(const Buffer &data, const SocketAddress &sender,
                                  const NetworkInterface &iface);
 
                void onManagerTick(const TimeStamp &now);
 
                PROMEKI_SIGNAL(announced, MdnsServiceInstance);
                PROMEKI_SIGNAL(conflict,  MdnsServiceInstance);
                PROMEKI_SIGNAL(renamed,   MdnsServiceInstance, MdnsServiceInstance);
                PROMEKI_SIGNAL(withdrawn, MdnsServiceInstance);
 
                static List<MdnsRecord> filterByKnownAnswers(const List<MdnsRecord> &answers,
                                                             const Buffer &inboundQuery);
 
        private:
                // Builds the full record set from @ref _instance.
                static List<MdnsRecord> composeRecords(const MdnsServiceInstance &i);
 
                // Transitions the state machine and fires any associated
                // signals.  Called from publish / onManagerTick /
                // withdraw.
                void enterState(State s);
                void advance(const TimeStamp &now);
 
                // Examines inbound records for conflicts with our
                // tentative record set; returns @c true if a conflict
                // was found.
                bool detectConflict(const Buffer &data);
 
                // Examines inbound questions for matches against our
                // record set and dispatches a response packet via the
                // manager.
                void respondToQueries(const Buffer &data);
 
                // RFC 6762 §9 instance-name mutation: parse any
                // trailing " (N)" suffix and bump it; otherwise
                // append " (2)".  Returns the new instance with the
                // mutated label and recomposed FQDN.
                static MdnsServiceInstance bumpInstanceName(const MdnsServiceInstance &in);
 
                MdnsServiceInstance      _instance;
                MdnsManager             *_manager = nullptr;
                mutable Mutex            _stateMtx;
                List<MdnsRecord>         _records;
 
                Atomic<State>            _state;
                Atomic<int>              _probeIdx;       
                Atomic<int>              _announceIdx;    
                Atomic<int>              _renameAttempts; 
                bool                     _autoRename = true;
 
                // Wall-clock for the next probe / announce / withdraw
                // step.  Owned by @ref _stateMtx.
                TimeStamp                _nextActionAt;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_MDNS