linklocalmanager.h

/*
  Copyright (c) 2012-2023 by Jakob Schröter <js@camaya.net>
  This file is part of the gloox library. http://camaya.net/gloox
 
  This software is distributed under a license. The full license
  agreement can be found in the file LICENSE in this distribution.
  This software may not be copied, modified, sold or distributed
  other than expressed in the named license agreement.
 
  This software is distributed without any warranty.
*/
 
#ifndef LINKLOCALMANAGER_H___
#define LINKLOCALMANAGER_H___
 
#include "config.h"
 
#ifdef HAVE_MDNS
 
#include "linklocal.h"
#include "macros.h"
#include "gloox.h"
#include "util.h"
#include "logsink.h"
#include "connectiontcpserver.h"
#include "mutex.h"
#include "jid.h"
 
#include <string>
 
#include <dns_sd.h>
 
namespace gloox
{
 
  class ConnectionHandler;
  class ConnectionTCPClient;
 
  namespace LinkLocal
  {
 
    class Handler;
 
    class GLOOX_API Manager
    {
 
      public:
 
        Manager( const std::string& user, ConnectionHandler* connHandler, const LogSink &logInstance );
 
        virtual ~Manager();
 
        void addTXTData( const std::string& key, const std::string& value );
 
        void removeTXTData( const std::string& key );
 
        void registerService();
 
        void deregisterService();
 
        void setUser( const std::string& user ) { m_user = user; }
 
        void setHost( const std::string& host ) { m_host = host; }
 
        void setDomain( const std::string& domain ) { m_domain = domain; }
 
        void setPort( const int port ) { m_port = port; addTXTData( "port.p2pj", util::int2string( m_port ) ); }
 
        void setInterface( unsigned iface ) { m_interface = iface; }
 
        bool startBrowsing();
 
        void stopBrowsing();
 
        int socket() const { return m_browseFd; }
 
        void recv( int timeout );
 
        void registerLinkLocalHandler( Handler* handler ) { m_linkLocalHandler = handler; }
 
//         /**
//          *
//          */
//         static const StringMap decodeTXT( const std::string& txt );
 
      private:
        static void handleBrowseReply( DNSServiceRef sdRef, DNSServiceFlags flags, unsigned interfaceIndex,
                                       DNSServiceErrorType errorCode, const char* serviceName, const char* regtype,
                                       const char* replyDomain, void* context );
 
        void handleBrowse( Flag flag, const std::string& service, const std::string& regtype, const std::string& domain, int iface, bool moreComing );
 
        typedef std::list<ConnectionTCPClient*> ConnectionList;
        typedef std::map<ConnectionTCPClient*, const JID> ConnectionMap;
 
        DNSServiceRef m_publishRef;
        DNSServiceRef m_browseRef;
 
        ServiceList m_tmpServices;
//         ServiceList m_services;
 
        std::string m_user;
        std::string m_host;
        std::string m_domain;
        unsigned m_interface;
        int m_port;
 
        const LogSink& m_logInstance;
 
        int m_browseFd;
 
        StringMap m_txtData;
 
        ConnectionTCPServer m_server;
 
        Handler* m_linkLocalHandler;
        ConnectionHandler* m_connectionHandler;
 
    };
 
  }
 
}
 
#endif // HAVE_MDNS
 
#endif // LINKLOCALMANAGER_H___