mdnsmanager.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/function.h>
#include <promeki/ipv4address.h>
#include <promeki/ipv6address.h>
#include <promeki/list.h>
#include <promeki/map.h>
#include <promeki/mdnsrecord.h>
#include <promeki/multicastmanager.h>
#include <promeki/mutex.h>
#include <promeki/networkinterface.h>
#include <promeki/socketaddress.h>
#include <promeki/string.h>
#include <promeki/thread.h>
#include <promeki/timestamp.h>
#include <promeki/udpsocket.h>
#include <promeki/uniqueptr.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class MdnsBrowser;
class MdnsPublisher;
class MdnsTypeBrowser;
class NetworkInterfaceMonitor;
 
class MdnsManager : public Thread {
                PROMEKI_OBJECT(MdnsManager, Thread)
        public:
                static constexpr uint16_t DefaultPort = 5353;
 
                static constexpr size_t DefaultMaxPacketSize = 9000;
 
                static constexpr unsigned int DefaultTickIntervalMs = 1000;
 
                static Ipv4Address ipv4Group() { return Ipv4Address(224, 0, 0, 251); }
 
                static Ipv6Address ipv6Group();
 
                enum class IpFamily : uint8_t {
                        IPv4Only = 1,
                        IPv6Only = 2,
                        Both     = 3,
                };
 
                void setIpFamily(IpFamily family);
 
                IpFamily ipFamily() const { return _ipFamily; }
 
                using PacketHook = Function<void(NetworkInterface iface,
                                                 SocketAddress sender,
                                                 Buffer data)>;
 
                explicit MdnsManager(ObjectBase *parent = nullptr);
 
                ~MdnsManager() override;
 
                void setPort(uint16_t port);
 
                uint16_t port() const { return _port; }
 
                void setAutoTrackInterfaces(bool enable);
 
                bool autoTrackInterfaces() const { return _autoTrackInterfaces; }
 
                void setIncludeLoopback(bool include);
 
                bool includeLoopback() const { return _includeLoopback; }
 
                void setMaxPacketSize(size_t bytes);
 
                size_t maxPacketSize() const { return _maxPacketSize; }
 
                void setTickInterval(unsigned int ms);
 
                unsigned int tickInterval() const { return _tickIntervalMs; }
 
                Error sendQuery(const String &name, uint16_t recordType,
                                uint16_t transactionId = 0,
                                bool unicastResponse = false);
 
                Error sendMetaQuery();
 
                static String metaBrowseFqdn() {
                        return String("_services._dns-sd._udp.local.");
                }
 
                Error sendQueryWithKnownAnswers(const String &name, uint16_t recordType,
                                                const List<MdnsRecord> &knownAnswers,
                                                uint16_t transactionId = 0);
 
                static Buffer buildQuery(const String &name, uint16_t recordType,
                                         uint16_t transactionId = 0,
                                         bool unicastResponse = false);
 
                static Buffer buildQueryWithKnownAnswers(const String &name, uint16_t recordType,
                                                         const List<MdnsRecord> &knownAnswers,
                                                         uint16_t transactionId = 0,
                                                         bool unicastResponse = false);
 
                void registerBrowser(MdnsBrowser *browser);
 
                void registerPublisher(MdnsPublisher *publisher);
 
                void unregisterPublisher(MdnsPublisher *publisher);
 
                void registerTypeBrowser(MdnsTypeBrowser *typeBrowser);
 
                void unregisterTypeBrowser(MdnsTypeBrowser *typeBrowser);
 
                Error writeMulticast(const Buffer &packet, bool ipv6);
 
                void unregisterBrowser(MdnsBrowser *browser);
 
                void setPacketHook(PacketHook hook);
 
                int registerPacketObserver(PacketHook observer);
 
                void unregisterPacketObserver(int handle);
 
                Error start();
 
                Error start(const NetworkInterface::List &ifaces);
 
                void stop();
 
                bool isActive() const { return _active.value(); }
 
                NetworkInterface::List joinedInterfaces() const;
 
                uint64_t datagramCount() const { return _datagramCount.value(); }
 
                uint64_t byteCount() const { return _byteCount.value(); }
 
                UdpSocket *socket() const { return _socket.get(); }
 
                UdpSocket *socketV6() const { return _socketV6.get(); }
 
                PROMEKI_SIGNAL(interfaceAdded,   NetworkInterface);
                PROMEKI_SIGNAL(interfaceRemoved, NetworkInterface);
                PROMEKI_SIGNAL(receiveError,     Error);
 
        protected:
                void run() override;
 
        private:
                Error openAndJoin(const NetworkInterface::List &ifaces);
                Error openSocket(bool ipv6);
                Error joinGroups(const NetworkInterface::List &ifaces, int *joined);
                Error joinGroupsOnInterface(const NetworkInterface &iface, int *joined);
                void  closeAndLeave();
                NetworkInterface::List selectAllMulticastInterfaces() const;
                bool                   acceptInterface(const NetworkInterface &iface) const;
                NetworkInterface       interfaceFromIfIndex(unsigned int ifindex) const;
 
                // Sends @p pkt out @p dest on every joined interface
                // via @p sock with @c IP_MULTICAST_IF / @c IPV6_MULTICAST_IF
                // steering.  Returns the number of successful sends.
                int sendOnSocketPerInterface(UdpSocket *sock, const Buffer &pkt,
                                             const SocketAddress &dest);
 
                // EventLoop IO-source callback: drains @p sock until
                // EAGAIN, then fans every received datagram out to
                // browsers / publishers / type browsers under the
                // standard mutex discipline.  On @c IoError emits
                // @ref receiveErrorSignal before attempting the drain
                // (POLLERR / POLLHUP can co-occur with queued data).
                void handleSocketEvents(UdpSocket *sock, uint32_t events);
 
                // EventLoop timer callback: drives onManagerTick on
                // every registered browser / publisher / type browser.
                // Fires unconditionally — no wall-clock comparison
                // because the EventLoop timer cadence already
                // matches @ref tickInterval.
                void runTick();
 
                // Monitor wiring.  @ref attachInterfaceMonitor is
                // called from @ref start; @ref detachInterfaceMonitor
                // from @ref stop.  Slots are dispatched on the
                // manager's affinity thread (the @ref ObjectBase
                // construction thread); their bodies mutate the
                // joined set under @ref _interfacesMtx and call into
                // the @ref MulticastManager to issue per-interface
                // joins / leaves on the wildcard socket.
                void attachInterfaceMonitor();
                void detachInterfaceMonitor();
                void onInterfaceAppeared(const NetworkInterface &iface);
                void onInterfaceDisappeared(const NetworkInterface &iface);
 
                UdpSocket::UPtr                    _socket;       
                UdpSocket::UPtr                    _socketV6;     
                MulticastManager                   _multicastManager;
                NetworkInterface::List             _joinedInterfaces;
                // Cached ifindex → NetworkInterface for fast receive-
                // side attribution.  Rebuilt on each interface join /
                // leave so the receive thread can look up by the
                // @c IP_PKTINFO / @c IPV6_PKTINFO cmsg without
                // walking @ref _joinedInterfaces.  Guarded by
                // @ref _interfacesMtx.
                Map<unsigned int, NetworkInterface> _byIfIndex;
                mutable Mutex                      _interfacesMtx;
                PacketHook                         _packetHook;
                struct PacketObserver {
                                int        handle = -1;
                                PacketHook hook;
                };
                List<PacketObserver>               _packetObservers;
                mutable Mutex                      _packetObserversMtx;
                Atomic<int>                        _nextObserverHandle;
                List<MdnsBrowser *>                _browsers;
                mutable Mutex                      _browsersMtx;
                List<MdnsPublisher *>              _publishers;
                mutable Mutex                      _publishersMtx;
                List<MdnsTypeBrowser *>            _typeBrowsers;
                mutable Mutex                      _typeBrowsersMtx;
                UniquePtr<NetworkInterfaceMonitor> _ifMonitor;
 
                uint16_t                           _port               = DefaultPort;
                bool                               _includeLoopback    = true;
                bool                               _autoTrackInterfaces = true;
                IpFamily                           _ipFamily           = IpFamily::Both;
                size_t                             _maxPacketSize      = DefaultMaxPacketSize;
                unsigned int                       _tickIntervalMs     = DefaultTickIntervalMs;
 
                Atomic<bool>                       _active;
                Atomic<uint64_t>                   _datagramCount;
                Atomic<uint64_t>                   _byteCount;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_MDNS