+ * Copyright (c) 2010-2016 Isode Limited.

+#include <boost/bind.hpp>

+

+ std::cout << "Start browsing" << std::endl;

+ assert(!browser);

+ avahi_threaded_poll_lock(querier->getThreadedPoll());

+ browser = avahi_service_browser_new(querier->getClient(), AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, "_presence._tcp", NULL, static_cast<AvahiLookupFlags>(0), &handleServiceDiscoveredStatic, this);

+ if (!browser) {

+ std::cout << "Error" << std::endl;

+ eventLoop->postEvent(boost::bind(boost::ref(onError)), shared_from_this());

+ }

+ avahi_threaded_poll_unlock(querier->getThreadedPoll());

+ std::cout << "Stop browsing" << std::endl;

+ avahi_threaded_poll_lock(querier->getThreadedPoll());

+ avahi_service_browser_free(browser);

+ browser = NULL;

+ avahi_threaded_poll_unlock(querier->getThreadedPoll());

+ switch (event) {

+ case AVAHI_BROWSER_FAILURE:

+ std::cout << "Service browse error" << std::endl;

+ eventLoop->postEvent(boost::bind(boost::ref(onError)), shared_from_this());

+ break;

+ case AVAHI_BROWSER_NEW: {

+ DNSSDServiceID service(name, domain, type, interfaceIndex);

+ std::cout << "Service discovered " << name << " " << domain << " " << type << " " << interfaceIndex << std::endl;

+ eventLoop->postEvent(boost::bind(boost::ref(onServiceAdded), service), shared_from_this());

+ break;

+ }

+ case AVAHI_BROWSER_REMOVE: {

+ std::cout << "Service went away " << name << " " << domain << " " << type << " " << interfaceIndex << std::endl;

+ DNSSDServiceID service(name, domain, type, interfaceIndex);

+ eventLoop->postEvent(boost::bind(boost::ref(onServiceRemoved), service), shared_from_this());

+ break;

+ }

+ case AVAHI_BROWSER_ALL_FOR_NOW:

+ case AVAHI_BROWSER_CACHE_EXHAUSTED:

+ break;

+ }

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <Swiften/EventLoop/EventLoop.h>

+ class AvahiQuerier;

+

+ class AvahiBrowseQuery : public DNSSDBrowseQuery, public AvahiQuery {

+ public:

+ AvahiBrowseQuery(std::shared_ptr<AvahiQuerier> q, EventLoop* eventLoop) : AvahiQuery(q, eventLoop), browser(NULL) {

+ }

+ void startBrowsing();

+ void stopBrowsing();

+ private:

+ static void handleServiceDiscoveredStatic(AvahiServiceBrowser *b, AvahiIfIndex interfaceIndex, AvahiProtocol protocol, AvahiBrowserEvent event, const char *name, const char *type, const char *domain, AvahiLookupResultFlags flags, void* context) {

+ static_cast<AvahiBrowseQuery*>(context)->handleServiceDiscovered(b, interfaceIndex, protocol, event, name, type, domain, flags);

+ }

+ void handleServiceDiscovered(AvahiServiceBrowser *, AvahiIfIndex interfaceIndex, AvahiProtocol, AvahiBrowserEvent event, const char *name, const char *type, const char *domain, AvahiLookupResultFlags);

+ private:

+ AvahiServiceBrowser* browser;

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <Swiften/LinkLocal/DNSSD/Avahi/AvahiResolveHostnameQuery.h>

+#include <Swiften/LinkLocal/DNSSD/Avahi/AvahiResolveServiceQuery.h>

+std::shared_ptr<DNSSDBrowseQuery> AvahiQuerier::createBrowseQuery() {

+ return std::make_shared<AvahiBrowseQuery>(shared_from_this(), eventLoop);

+std::shared_ptr<DNSSDRegisterQuery> AvahiQuerier::createRegisterQuery(const std::string& name, int port, const ByteArray& info) {

+ return std::make_shared<AvahiRegisterQuery>(name, port, info, shared_from_this(), eventLoop);

+std::shared_ptr<DNSSDResolveServiceQuery> AvahiQuerier::createResolveServiceQuery(const DNSSDServiceID& service) {

+ return std::make_shared<AvahiResolveServiceQuery>(service, shared_from_this(), eventLoop);

+std::shared_ptr<DNSSDResolveHostnameQuery> AvahiQuerier::createResolveHostnameQuery(const std::string& hostname, int interfaceIndex) {

+ return std::make_shared<AvahiResolveHostnameQuery>(hostname, interfaceIndex, shared_from_this(), eventLoop);

+ std::cout << "Starrting querier" << std::endl;

+ assert(!threadedPoll);

+ threadedPoll = avahi_threaded_poll_new();

+ int error;

+ assert(!client);

+ client = avahi_client_new(

+ avahi_threaded_poll_get(threadedPoll),

+ static_cast<AvahiClientFlags>(0), NULL, this, &error); // TODO

+ if (!client) {

+ // TODO

+ std::cerr << "Avahi Error: " << avahi_strerror(error) << std::endl;

+ return;

+ }

+ std::cout << "Starrting event loop" << std::endl;

+ avahi_threaded_poll_start(threadedPoll);

+ assert(threadedPoll);

+ avahi_threaded_poll_stop(threadedPoll);

+ assert(client);

+ avahi_client_free(client);

+ avahi_threaded_poll_free(threadedPoll);

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <memory>

+

+#include <avahi-common/error.h>

+#include <avahi-common/malloc.h>

+#include <Swiften/LinkLocal/DNSSD/DNSSDQuerier.h>

+ class EventLoop;

+

+ class AvahiQuerier :

+ public DNSSDQuerier,

+ public std::enable_shared_from_this<AvahiQuerier> {

+ public:

+ AvahiQuerier(EventLoop* eventLoop);

+ ~AvahiQuerier();

+

+ std::shared_ptr<DNSSDBrowseQuery> createBrowseQuery();

+ std::shared_ptr<DNSSDRegisterQuery> createRegisterQuery(

+ const std::string& name, int port, const ByteArray& info);

+ std::shared_ptr<DNSSDResolveServiceQuery> createResolveServiceQuery(

+ const DNSSDServiceID&);

+ std::shared_ptr<DNSSDResolveHostnameQuery> createResolveHostnameQuery(

+ const std::string& hostname, int interfaceIndex);

+

+ void start();

+ void stop();

+

+ AvahiThreadedPoll* getThreadedPoll() const {

+ return threadedPoll;

+ }

+

+ AvahiClient* getClient() const {

+ return client;

+ }

+

+ private:

+ EventLoop* eventLoop;

+ AvahiClient* client;

+ AvahiThreadedPoll* threadedPoll;

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+

+AvahiQuery::AvahiQuery(std::shared_ptr<AvahiQuerier> q, EventLoop* eventLoop) : querier(q), eventLoop(eventLoop) {

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <memory>

+ class AvahiQuerier;

+ class EventLoop;

+ class AvahiQuery :

+ public EventOwner,

+ public std::enable_shared_from_this<AvahiQuery> {

+ public:

+ AvahiQuery(std::shared_ptr<AvahiQuerier>, EventLoop* eventLoop);

+ virtual ~AvahiQuery();

+

+ protected:

+ std::shared_ptr<AvahiQuerier> querier;

+ EventLoop* eventLoop;

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+

+ std::cout << "Registering service " << name << ":" << port << std::endl;

+ avahi_threaded_poll_lock(querier->getThreadedPoll());

+ if (!group) {

+ std::cout << "Creating entry group" << std::endl;

+ group = avahi_entry_group_new(querier->getClient(), handleEntryGroupChange, this);

+ if (!group) {

+ std::cout << "Error ceating entry group" << std::endl;

+ eventLoop->postEvent(boost::bind(boost::ref(onRegisterFinished), boost::optional<DNSSDServiceID>()), shared_from_this());

+ }

+ }

+

+ doRegisterService();

+ avahi_threaded_poll_unlock(querier->getThreadedPoll());

+ if (group) {

+ avahi_entry_group_free(group);

+ group = NULL;

+ }

+ this->txtRecord = txtRecord;

+ avahi_threaded_poll_lock(querier->getThreadedPoll());

+ assert(group);

+ avahi_entry_group_reset(group);

+ doRegisterService();

+ avahi_threaded_poll_unlock(querier->getThreadedPoll());

+ AvahiStringList* txtList;

+ avahi_string_list_parse(vecptr(txtRecord), txtRecord.size(), &txtList);

+

+ int result = avahi_entry_group_add_service_strlst(group, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, static_cast<AvahiPublishFlags>(0), name.c_str(), "_presence._tcp", NULL, NULL, port, txtList);

+ if (result < 0) {

+ std::cout << "Error registering service: " << avahi_strerror(result) << std::endl;

+ eventLoop->postEvent(boost::bind(boost::ref(onRegisterFinished), boost::optional<DNSSDServiceID>()), shared_from_this());

+ }

+ result = avahi_entry_group_commit(group);

+ if (result < 0) {

+ std::cout << "Error registering service: " << avahi_strerror(result) << std::endl;

+ }

+ std::cout << "ENtry group callback: " << state << std::endl;

+ switch (state) {

+ case AVAHI_ENTRY_GROUP_ESTABLISHED :

+ // Domain is a hack!

+ eventLoop->postEvent(boost::bind(boost::ref(onRegisterFinished), boost::optional<DNSSDServiceID>(DNSSDServiceID(name, "local", "_presence._tcp", 0))), shared_from_this());

+ std::cout << "Entry group established" << std::endl;

+ break;

+ case AVAHI_ENTRY_GROUP_COLLISION : {

+ std::cout << "Entry group collision" << std::endl;

+ /*char *n;

+ n = avahi_alternative_service_name(name);

+ avahi_free(name);

+ name = n;*/

+ break;

+ }

+

+ case AVAHI_ENTRY_GROUP_FAILURE :

+ std::cout << "Entry group failure " << avahi_strerror(avahi_client_errno(avahi_entry_group_get_client(g))) << std::endl;

+ break;

+

+ case AVAHI_ENTRY_GROUP_UNCOMMITED:

+ case AVAHI_ENTRY_GROUP_REGISTERING:

+ ;

+

+ /*

+ DNSServiceErrorType result = DNSServiceRegister(

+ &sdRef, 0, 0, name.c_str(), "_presence._tcp", NULL, NULL, port,

+ txtRecord.getSize(), txtRecord.getData(),

+ &AvahiRegisterQuery::handleServiceRegisteredStatic, this);

+ if (result != kDNSServiceErr_NoError) {

+ sdRef = NULL;

+ }*/

+ //eventLoop->postEvent(boost::bind(boost::ref(onRegisterFinished), boost::optional<DNSSDServiceID>()), shared_from_this());

+ }

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <Swiften/LinkLocal/DNSSD/Avahi/AvahiQuery.h>

+#include <Swiften/LinkLocal/DNSSD/DNSSDRegisterQuery.h>

+ class AvahiQuerier;

+ class AvahiRegisterQuery : public DNSSDRegisterQuery, public AvahiQuery {

+ public:

+ AvahiRegisterQuery(const std::string& name, int port, const ByteArray& txtRecord, std::shared_ptr<AvahiQuerier> querier, EventLoop* eventLoop) : AvahiQuery(querier, eventLoop), name(name), port(port), txtRecord(txtRecord), group(0) {

+ }

+ void registerService();

+ void unregisterService();

+ void updateServiceInfo(const ByteArray& txtRecord);

+ private:

+ void doRegisterService();

+ static void handleEntryGroupChange(AvahiEntryGroup *g, AvahiEntryGroupState state, void *userdata) {

+ static_cast<AvahiRegisterQuery*>(userdata)->handleEntryGroupChange(g, state);

+ }

+ void handleEntryGroupChange(AvahiEntryGroup* g, AvahiEntryGroupState state);

+ static void handleServiceRegisteredStatic(DNSServiceRef, DNSServiceFlags, DNSServiceErrorType errorCode, const char *name, const char *regtype, const char *domain, void *context) {

+ static_cast<AvahiRegisterQuery*>(context)->handleServiceRegistered(errorCode, name, regtype, domain);

+ }

+

+ void handleServiceRegistered(DNSServiceErrorType errorCode, const char *name, const char *regtype, const char *domain) {

+ if (errorCode != kDNSServiceErr_NoError) {

+ eventLoop->postEvent(boost::bind(boost::ref(onRegisterFinished), boost::optional<DNSSDServiceID>()), shared_from_this());

+ }

+ else {

+ }

+ }

+ */

+

+ private:

+ std::string name;

+ int port;

+ ByteArray txtRecord;

+ AvahiEntryGroup* group;

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <netinet/in.h>

+

+#include <Swiften/Base/Log.h>

+

+AvahiResolveHostnameQuery::AvahiResolveHostnameQuery(const std::string& hostname, int, std::shared_ptr<AvahiQuerier> querier, EventLoop* eventLoop) : AvahiQuery(querier, eventLoop), hostname(hostname) {

+ SWIFT_LOG(debug) << "Resolving hostname " << hostname << std::endl;

+ eventLoop->postEvent(boost::bind(boost::ref(onHostnameResolved), HostAddress::fromString(hostname)), shared_from_this());

+ * Copyright (c) 2010-2016 Isode Limited.

+

+#include <Swiften/EventLoop/EventLoop.h>

+ class AvahiQuerier;

+ class AvahiResolveHostnameQuery : public DNSSDResolveHostnameQuery, public AvahiQuery {

+ public:

+ AvahiResolveHostnameQuery(const std::string& hostname, int, std::shared_ptr<AvahiQuerier> querier, EventLoop* eventLoop);

+ void run();

+ void finish() {

+ }

+ private:

+ HostAddress hostAddress;

+ std::string hostname;

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <boost/bind.hpp>

+

+ std::cout << "Start resolving " << service.getName() << " " << service.getType() << " " << service.getDomain() << std::endl;

+ avahi_threaded_poll_lock(querier->getThreadedPoll());

+ assert(!resolver);

+ resolver = avahi_service_resolver_new(querier->getClient(), service.getNetworkInterfaceID(), AVAHI_PROTO_UNSPEC, service.getName().c_str(), service.getType().c_str(), service.getDomain().c_str(), AVAHI_PROTO_UNSPEC, static_cast<AvahiLookupFlags>(0), handleServiceResolvedStatic, this);

+ if (!resolver) {

+ std::cout << "Error starting resolver" << std::endl;

+ eventLoop->postEvent(boost::bind(boost::ref(onServiceResolved), boost::optional<Result>()), shared_from_this());

+ }

+ avahi_threaded_poll_unlock(querier->getThreadedPoll());

+ std::cout << "Stop resolving" << std::endl;

+ avahi_threaded_poll_lock(querier->getThreadedPoll());

+ avahi_service_resolver_free(resolver);

+ resolver = NULL;

+ avahi_threaded_poll_unlock(querier->getThreadedPoll());

+ std::cout << "Resolve finished" << std::endl;

+ switch(event) {

+ case AVAHI_RESOLVER_FAILURE:

+ std::cout << "Resolve error " << avahi_strerror(avahi_client_errno(avahi_service_resolver_get_client(resolver))) << std::endl;

+ eventLoop->postEvent(boost::bind(boost::ref(onServiceResolved), boost::optional<Result>()), shared_from_this());

+ break;

+ case AVAHI_RESOLVER_FOUND: {

+ std::cout << "Success" << std::endl;

+ char a[AVAHI_ADDRESS_STR_MAX];

+ avahi_address_snprint(a, sizeof(a), address);

+ ByteArray txtRecord;

+ txtRecord.resize(1024);

+ avahi_string_list_serialize(txt, vecptr(txtRecord), txtRecord.size());

+ // FIXME: Probably not accurate

+ std::string fullname = std::string(name) + "." + std::string(type) + "." + std::string(domain) + ".";

+ std::cout << "Result: " << fullname << "->" << std::string(a) << ":" << port << std::endl;

+ eventLoop->postEvent(

+ boost::bind(

+ boost::ref(onServiceResolved),

+ Result(fullname, std::string(a), port, txtRecord)),

+ shared_from_this());

+ break;

+ }

+ }

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <Swiften/Base/ByteArray.h>

+#include <Swiften/EventLoop/EventLoop.h>

+ class AvahiQuerier;

+ class AvahiResolveServiceQuery : public DNSSDResolveServiceQuery, public AvahiQuery {

+ public:

+ AvahiResolveServiceQuery(const DNSSDServiceID& service, std::shared_ptr<AvahiQuerier> querier, EventLoop* eventLoop) : AvahiQuery(querier, eventLoop), service(service), resolver(NULL) {

+ }

+ void start();

+ void stop();

+ private:

+ static void handleServiceResolvedStatic(AvahiServiceResolver* resolver, AvahiIfIndex interfaceIndex, AvahiProtocol protocol, AvahiResolverEvent event, const char *name, const char *type, const char *domain, const char *host_name, const AvahiAddress *address, uint16_t port, AvahiStringList *txt, AvahiLookupResultFlags flags, void* context) {

+ static_cast<AvahiResolveServiceQuery*>(context)->handleServiceResolved(resolver, interfaceIndex, protocol, event, name, type, domain, host_name, address, port, txt, flags);

+ }

+ void handleServiceResolved(AvahiServiceResolver* resolver, AvahiIfIndex, AvahiProtocol, AvahiResolverEvent event, const char *name, const char * type, const char* domain, const char * /*host_name*/, const AvahiAddress *address, uint16_t port, AvahiStringList *txt, AvahiLookupResultFlags);

+ private:

+ DNSSDServiceID service;

+ AvahiServiceResolver* resolver;

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <boost/numeric/conversion/cast.hpp>

+

+#include <Swiften/EventLoop/EventLoop.h>

+ class BonjourQuerier;

+

+ class BonjourBrowseQuery : public DNSSDBrowseQuery, public BonjourQuery {

+ public:

+ BonjourBrowseQuery(std::shared_ptr<BonjourQuerier> q, EventLoop* eventLoop) : BonjourQuery(q, eventLoop) {

+ DNSServiceErrorType result = DNSServiceBrowse(

+ &sdRef, 0, 0, "_presence._tcp", nullptr,

+ &BonjourBrowseQuery::handleServiceDiscoveredStatic, this);

+ if (result != kDNSServiceErr_NoError) {

+ sdRef = nullptr;

+ }

+ }

+

+ void startBrowsing() {

+ if (!sdRef) {

+ eventLoop->postEvent(boost::bind(boost::ref(onError)), shared_from_this());

+ }

+ else {

+ run();

+ }

+ }

+

+ void stopBrowsing() {

+ finish();

+ }

+

+ private:

+ static void handleServiceDiscoveredStatic(DNSServiceRef, DNSServiceFlags flags, uint32_t interfaceIndex, DNSServiceErrorType errorCode, const char *name, const char *type, const char *domain, void *context) {

+ static_cast<BonjourBrowseQuery*>(context)->handleServiceDiscovered(flags, interfaceIndex, errorCode, name, type, domain);

+ }

+

+ void handleServiceDiscovered(DNSServiceFlags flags, uint32_t interfaceIndex, DNSServiceErrorType errorCode, const char *name, const char *type, const char *domain) {

+ if (errorCode != kDNSServiceErr_NoError) {

+ eventLoop->postEvent(boost::bind(boost::ref(onError)), shared_from_this());

+ }

+ else {

+ //std::cout << "Discovered service: name:" << name << " domain:" << domain << " type: " << type << std::endl;

+ DNSSDServiceID service(name, domain, type, boost::numeric_cast<int>(interfaceIndex));

+ if (flags & kDNSServiceFlagsAdd) {

+ eventLoop->postEvent(boost::bind(boost::ref(onServiceAdded), service), shared_from_this());

+ }

+ else {

+ eventLoop->postEvent(boost::bind(boost::ref(onServiceRemoved), service), shared_from_this());

+ }

+ }

+ }

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <sys/socket.h>

+#include <unistd.h>

+#include <Swiften/Base/Algorithm.h>

+#include <Swiften/LinkLocal/DNSSD/Bonjour/BonjourResolveServiceQuery.h>

+BonjourQuerier::BonjourQuerier(EventLoop* eventLoop) : eventLoop(eventLoop), stopRequested(false), thread(nullptr) {

+ int fds[2];

+ int result = pipe(fds);

+ assert(result == 0);

+ (void) result;

+ interruptSelectReadSocket = fds[0];

+ fcntl(interruptSelectReadSocket, F_SETFL, fcntl(interruptSelectReadSocket, F_GETFL)|O_NONBLOCK);

+ interruptSelectWriteSocket = fds[1];

+ assert(!thread);

+std::shared_ptr<DNSSDBrowseQuery> BonjourQuerier::createBrowseQuery() {

+ return std::make_shared<BonjourBrowseQuery>(shared_from_this(), eventLoop);

+std::shared_ptr<DNSSDRegisterQuery> BonjourQuerier::createRegisterQuery(const std::string& name, int port, const ByteArray& info) {

+ return std::make_shared<BonjourRegisterQuery>(name, port, info, shared_from_this(), eventLoop);

+std::shared_ptr<DNSSDResolveServiceQuery> BonjourQuerier::createResolveServiceQuery(const DNSSDServiceID& service) {

+ return std::make_shared<BonjourResolveServiceQuery>(service, shared_from_this(), eventLoop);

+std::shared_ptr<DNSSDResolveHostnameQuery> BonjourQuerier::createResolveHostnameQuery(const std::string& hostname, int interfaceIndex) {

+ return std::make_shared<BonjourResolveHostnameQuery>(hostname, interfaceIndex, shared_from_this(), eventLoop);

+void BonjourQuerier::addRunningQuery(std::shared_ptr<BonjourQuery> query) {

+ {

+ std::lock_guard<std::mutex> lock(runningQueriesMutex);

+ runningQueries.push_back(query);

+ }

+ runningQueriesAvailableEvent.notify_one();

+ interruptSelect();

+void BonjourQuerier::removeRunningQuery(std::shared_ptr<BonjourQuery> query) {

+ {

+ std::lock_guard<std::mutex> lock(runningQueriesMutex);

+ erase(runningQueries, query);

+ }

+ char c = 0;

+ write(interruptSelectWriteSocket, &c, 1);

+ assert(!thread);

+ thread = new std::thread(boost::bind(&BonjourQuerier::run, shared_from_this()));

+ if (thread) {

+ stopRequested = true;

+ assert(runningQueries.empty());

+ runningQueriesAvailableEvent.notify_one();

+ interruptSelect();

+ thread->join();

+ delete thread;

+ thread = nullptr;

+ stopRequested = false;

+ }

+ while (!stopRequested) {

+ fd_set fdSet;

+ int maxSocket;

+ {

+ std::unique_lock<std::mutex> lock(runningQueriesMutex);

+ if (runningQueries.empty()) {

+ runningQueriesAvailableEvent.wait(lock);

+ if (runningQueries.empty()) {

+ continue;

+ }

+ }

+

+ // Run all running queries

+ FD_ZERO(&fdSet);

+ maxSocket = interruptSelectReadSocket;

+ FD_SET(interruptSelectReadSocket, &fdSet);

+

+ for (const auto& query : runningQueries) {

+ int socketID = query->getSocketID();

+ maxSocket = std::max(maxSocket, socketID);

+ FD_SET(socketID, &fdSet);

+ }

+ }

+

+ if (select(maxSocket+1, &fdSet, nullptr, nullptr, nullptr) <= 0) {

+ continue;

+ }

+

+ if (FD_ISSET(interruptSelectReadSocket, &fdSet)) {

+ char dummy;

+ while (read(interruptSelectReadSocket, &dummy, 1) > 0) {}

+ }

+

+ {

+ std::lock_guard<std::mutex> lock(runningQueriesMutex);

+ for (auto&& query : runningQueries) {

+ if (FD_ISSET(query->getSocketID(), &fdSet)) {

+ query->processResult();

+ }

+ }

+ }

+ }

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <memory>

+#include <mutex>

+#include <thread>

+#include <Swiften/LinkLocal/DNSSD/Bonjour/BonjourQuery.h>

+#include <Swiften/LinkLocal/DNSSD/DNSSDQuerier.h>

+ class BonjourQuerier :

+ public DNSSDQuerier,

+ public std::enable_shared_from_this<BonjourQuerier> {

+ public:

+ BonjourQuerier(EventLoop* eventLoop);

+ ~BonjourQuerier();

+

+ std::shared_ptr<DNSSDBrowseQuery> createBrowseQuery();

+ std::shared_ptr<DNSSDRegisterQuery> createRegisterQuery(

+ const std::string& name, int port, const ByteArray& info);

+ std::shared_ptr<DNSSDResolveServiceQuery> createResolveServiceQuery(

+ const DNSSDServiceID&);

+ std::shared_ptr<DNSSDResolveHostnameQuery> createResolveHostnameQuery(

+ const std::string& hostname, int interfaceIndex);

+

+ void start();

+ void stop();

+

+ private:

+ friend class BonjourQuery;

+

+ void addRunningQuery(std::shared_ptr<BonjourQuery>);

+ void removeRunningQuery(std::shared_ptr<BonjourQuery>);

+ void interruptSelect();

+ void run();

+

+ private:

+ EventLoop* eventLoop;

+ bool stopRequested;

+ std::thread* thread;

+ std::mutex runningQueriesMutex;

+ std::list< std::shared_ptr<BonjourQuery> > runningQueries;

+ int interruptSelectReadSocket;

+ int interruptSelectWriteSocket;

+ std::condition_variable runningQueriesAvailableEvent;

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+

+BonjourQuery::BonjourQuery(std::shared_ptr<BonjourQuerier> q, EventLoop* eventLoop) : eventLoop(eventLoop), querier(q), sdRef(nullptr) {

+ DNSServiceRefDeallocate(sdRef);

+ std::lock_guard<std::mutex> lock(sdRefMutex);

+ DNSServiceProcessResult(sdRef);

+ std::lock_guard<std::mutex> lock(sdRefMutex);

+ return DNSServiceRefSockFD(sdRef);

+ querier->addRunningQuery(shared_from_this());

+ querier->removeRunningQuery(shared_from_this());

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <memory>

+#include <mutex>

+

+ class BonjourQuerier;

+ class EventLoop;

+

+ class BonjourQuery :

+ public EventOwner,

+ public std::enable_shared_from_this<BonjourQuery> {

+ public:

+ BonjourQuery(std::shared_ptr<BonjourQuerier>, EventLoop* eventLoop);

+ virtual ~BonjourQuery();

+

+ void processResult();

+ int getSocketID() const;

+

+ protected:

+ void run();

+ void finish();

+

+ protected:

+ EventLoop* eventLoop;

+ std::shared_ptr<BonjourQuerier> querier;

+ mutable std::mutex sdRefMutex;

+ DNSServiceRef sdRef;

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <mutex>

+

+ class BonjourQuerier;

+ class BonjourRegisterQuery : public DNSSDRegisterQuery, public BonjourQuery {

+ public:

+ BonjourRegisterQuery(const std::string& name, int port, const ByteArray& txtRecord, std::shared_ptr<BonjourQuerier> querier, EventLoop* eventLoop) : BonjourQuery(querier, eventLoop) {

+ DNSServiceErrorType result = DNSServiceRegister(

+ &sdRef, 0, 0, name.c_str(), "_presence._tcp", nullptr, nullptr, boost::numeric_cast<unsigned short>(port),

+ boost::numeric_cast<unsigned short>(txtRecord.size()), vecptr(txtRecord),

+ &BonjourRegisterQuery::handleServiceRegisteredStatic, this);

+ if (result != kDNSServiceErr_NoError) {

+ sdRef = nullptr;

+ }

+ }

+ void registerService() {

+ if (sdRef) {

+ run();

+ }

+ else {

+ eventLoop->postEvent(boost::bind(boost::ref(onRegisterFinished), boost::optional<DNSSDServiceID>()), shared_from_this());

+ }

+ }

+ void unregisterService() {

+ finish();

+ }

+ void updateServiceInfo(const ByteArray& txtRecord) {

+ std::lock_guard<std::mutex> lock(sdRefMutex);

+ DNSServiceUpdateRecord(sdRef, nullptr, 0, boost::numeric_cast<unsigned short>(txtRecord.size()), vecptr(txtRecord), 0);

+ }

+ private:

+ static void handleServiceRegisteredStatic(DNSServiceRef, DNSServiceFlags, DNSServiceErrorType errorCode, const char *name, const char *regtype, const char *domain, void *context) {

+ static_cast<BonjourRegisterQuery*>(context)->handleServiceRegistered(errorCode, name, regtype, domain);

+ }

+ void handleServiceRegistered(DNSServiceErrorType errorCode, const char *name, const char *regtype, const char *domain) {

+ if (errorCode != kDNSServiceErr_NoError) {

+ eventLoop->postEvent(boost::bind(boost::ref(onRegisterFinished), boost::optional<DNSSDServiceID>()), shared_from_this());

+ }

+ else {

+ eventLoop->postEvent(boost::bind(boost::ref(onRegisterFinished), boost::optional<DNSSDServiceID>(DNSSDServiceID(name, domain, regtype, 0))), shared_from_this());

+ }

+ }

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+ class BonjourQuerier;

+ class BonjourResolveHostnameQuery : public DNSSDResolveHostnameQuery, public BonjourQuery {

+ public:

+ BonjourResolveHostnameQuery(const std::string& hostname, int interfaceIndex, std::shared_ptr<BonjourQuerier> querier, EventLoop* eventLoop) : BonjourQuery(querier, eventLoop) {

+ DNSServiceErrorType result = DNSServiceGetAddrInfo(

+ &sdRef, 0, boost::numeric_cast<unsigned int>(interfaceIndex), kDNSServiceProtocol_IPv4,

+ hostname.c_str(),

+ &BonjourResolveHostnameQuery::handleHostnameResolvedStatic, this);

+ if (result != kDNSServiceErr_NoError) {

+ sdRef = nullptr;

+ }

+ }

+ //void DNSSDResolveHostnameQuery::run() {

+ void run() {

+ if (sdRef) {

+ BonjourQuery::run();

+ }

+ else {

+ eventLoop->postEvent(boost::bind(boost::ref(onHostnameResolved), boost::optional<HostAddress>()), shared_from_this());

+ }

+ }

+ void finish() {

+ BonjourQuery::finish();

+ }

+ private:

+ static void handleHostnameResolvedStatic(DNSServiceRef, DNSServiceFlags, uint32_t, DNSServiceErrorType errorCode, const char*, const struct sockaddr *address, uint32_t, void *context) {

+ static_cast<BonjourResolveHostnameQuery*>(context)->handleHostnameResolved(errorCode, address);

+ }

+ void handleHostnameResolved(DNSServiceErrorType errorCode, const struct sockaddr *rawAddress) {

+ if (errorCode) {

+ eventLoop->postEvent(

+ boost::bind(boost::ref(onHostnameResolved),

+ boost::optional<HostAddress>()),

+ shared_from_this());

+ }

+ else {

+ assert(rawAddress->sa_family == AF_INET);

+ const sockaddr_in* sa = reinterpret_cast<const sockaddr_in*>(rawAddress);

+ uint32_t address = ntohl(sa->sin_addr.s_addr);

+ eventLoop->postEvent(boost::bind(

+ boost::ref(onHostnameResolved),

+ HostAddress(reinterpret_cast<unsigned char*>(&address), 4)),

+ shared_from_this());

+ }

+ }

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <boost/numeric/conversion/cast.hpp>

+

+#include <Swiften/Base/ByteArray.h>

+#include <Swiften/EventLoop/EventLoop.h>

+ class BonjourQuerier;

+ class BonjourResolveServiceQuery : public DNSSDResolveServiceQuery, public BonjourQuery {

+ public:

+ BonjourResolveServiceQuery(const DNSSDServiceID& service, std::shared_ptr<BonjourQuerier> querier, EventLoop* eventLoop) : BonjourQuery(querier, eventLoop) {

+ DNSServiceErrorType result = DNSServiceResolve(

+ &sdRef, 0, boost::numeric_cast<unsigned int>(service.getNetworkInterfaceID()),

+ service.getName().c_str(), service.getType().c_str(),

+ service.getDomain().c_str(),

+ &BonjourResolveServiceQuery::handleServiceResolvedStatic, this);

+ if (result != kDNSServiceErr_NoError) {

+ sdRef = nullptr;

+ }

+ }

+ void start() {

+ if (sdRef) {

+ run();

+ }

+ else {

+ eventLoop->postEvent(boost::bind(boost::ref(onServiceResolved), boost::optional<Result>()), shared_from_this());

+ }

+ }

+ void stop() {

+ finish();

+ }

+ private:

+ static void handleServiceResolvedStatic(DNSServiceRef, DNSServiceFlags, uint32_t, DNSServiceErrorType errorCode, const char *fullname, const char *hosttarget, uint16_t port, uint16_t txtLen, const unsigned char *txtRecord, void *context) {

+ static_cast<BonjourResolveServiceQuery*>(context)->handleServiceResolved(errorCode, fullname, hosttarget, port, txtLen, txtRecord);

+ }

+ void handleServiceResolved(DNSServiceErrorType errorCode, const char* fullName, const char* host, uint16_t port, uint16_t txtLen, const unsigned char *txtRecord) {

+ if (errorCode != kDNSServiceErr_NoError) {

+ eventLoop->postEvent(boost::bind(boost::ref(onServiceResolved), boost::optional<Result>()), shared_from_this());

+ }

+ else {

+ //std::cout << "Service resolved: name:" << fullName << " host:" << host << " port:" << port << std::endl;

+ eventLoop->postEvent(

+ boost::bind(

+ boost::ref(onServiceResolved),

+ Result(std::string(fullName), std::string(host), port,

+ createByteArray(reinterpret_cast<const char*>(txtRecord), txtLen))),

+ shared_from_this());

+ }

+ }

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <boost/signals2.hpp>

+ class DNSSDBrowseQuery {

+ public:

+ virtual ~DNSSDBrowseQuery();

+ virtual void startBrowsing() = 0;

+ virtual void stopBrowsing() = 0;

+ boost::signals2::signal<void (const DNSSDServiceID&)> onServiceAdded;

+ boost::signals2::signal<void (const DNSSDServiceID&)> onServiceRemoved;

+ boost::signals2::signal<void ()> onError;

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <memory>

+ class DNSSDServiceID;

+ class DNSSDBrowseQuery;

+ class DNSSDRegisterQuery;

+ class DNSSDResolveServiceQuery;

+ class DNSSDResolveHostnameQuery;

+ class DNSSDQuerier {

+ public:

+ virtual ~DNSSDQuerier();

+ virtual void start() = 0;

+ virtual void stop() = 0;

+ virtual std::shared_ptr<DNSSDBrowseQuery> createBrowseQuery() = 0;

+ virtual std::shared_ptr<DNSSDRegisterQuery> createRegisterQuery(

+ const std::string& name, int port, const ByteArray& info) = 0;

+ virtual std::shared_ptr<DNSSDResolveServiceQuery> createResolveServiceQuery(

+ const DNSSDServiceID&) = 0;

+ virtual std::shared_ptr<DNSSDResolveHostnameQuery> createResolveHostnameQuery(

+ const std::string& hostname, int interfaceIndex) = 0;

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <boost/signals2.hpp>

+#include <Swiften/LinkLocal/DNSSD/DNSSDServiceID.h>

+ class DNSSDRegisterQuery {

+ public:

+ virtual ~DNSSDRegisterQuery();

+ virtual void registerService() = 0;

+ virtual void unregisterService() = 0;

+ virtual void updateServiceInfo(const ByteArray& info) = 0;

+ boost::signals2::signal<void (boost::optional<DNSSDServiceID>)> onRegisterFinished;

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <boost/signals2.hpp>

+ class DNSSDResolveHostnameQuery {

+ public:

+ virtual ~DNSSDResolveHostnameQuery();

+ virtual void run() = 0;

+ virtual void finish() = 0;

+ boost::signals2::signal<void (const boost::optional<HostAddress>&)> onHostnameResolved;

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <boost/signals2.hpp>

+#include <Swiften/LinkLocal/DNSSD/DNSSDServiceID.h>

+ class DNSSDResolveServiceQuery {

+ public:

+ struct Result {

+ Result(const std::string& fullName, const std::string& host, int port, const ByteArray& info) :

+ fullName(fullName), host(host), port(port), info(info) {}

+ std::string fullName;

+ std::string host;

+ int port;

+ ByteArray info;

+ };

+ virtual ~DNSSDResolveServiceQuery();

+ virtual void start() = 0;

+ virtual void stop() = 0;

+ boost::signals2::signal<void (const boost::optional<Result>&)> onServiceResolved;

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <Swiften/Base/API.h>

+

+ class SWIFTEN_API DNSSDServiceID {

+ public:

+ static const char* PresenceServiceType;

+ DNSSDServiceID(

+ const std::string& name,

+ const std::string& domain,

+ const std::string& type = PresenceServiceType,

+ int networkInterface = -1) :

+ name(name),

+ domain(domain),

+ type(type),

+ networkInterface(networkInterface) {

+ }

+ bool operator==(const DNSSDServiceID& o) const {

+ return name == o.name && domain == o.domain && type == o.type && (networkInterface != 0 && o.networkInterface != 0 ? networkInterface == o.networkInterface : true);

+ }

+ bool operator<(const DNSSDServiceID& o) const {

+ if (o.name == name) {

+ if (o.domain == domain) {

+ if (o.type == type) {

+ return networkInterface < o.networkInterface;

+ }

+ else {

+ return type < o.type;

+ }

+ }

+ else {

+ return domain < o.domain;

+ }

+ }

+ else {

+ return o.name < name;

+ }

+ }

+ const std::string& getName() const {

+ return name;

+ }

+ const std::string& getDomain() const {

+ return domain;

+ }

+ const std::string& getType() const {

+ return type;

+ }

+ int getNetworkInterfaceID() const {

+ return networkInterface;

+ }

+ private:

+ std::string name;

+ std::string domain;

+ std::string type;

+ int networkInterface;

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuery.h>

+ class FakeDNSSDQuerier;

+ class FakeDNSSDBrowseQuery : public DNSSDBrowseQuery, public FakeDNSSDQuery {

+ public:

+ FakeDNSSDBrowseQuery(std::shared_ptr<FakeDNSSDQuerier> querier) : FakeDNSSDQuery(querier) {

+ }

+ void startBrowsing() {

+ run();

+ }

+ void stopBrowsing() {

+ finish();

+ }

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <boost/bind.hpp>

+

+#include <Swiften/EventLoop/EventLoop.h>

+#include <Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDResolveServiceQuery.h>

+ if (!runningQueries.empty()) {

+ std::cerr << "FakeDNSSDQuerier: Running queries not empty at destruction time" << std::endl;

+ }

+std::shared_ptr<DNSSDBrowseQuery> FakeDNSSDQuerier::createBrowseQuery() {

+ return std::make_shared<FakeDNSSDBrowseQuery>(shared_from_this());

+std::shared_ptr<DNSSDRegisterQuery> FakeDNSSDQuerier::createRegisterQuery(const std::string& name, int port, const ByteArray& info) {

+ return std::make_shared<FakeDNSSDRegisterQuery>(name, port, info, shared_from_this());

+std::shared_ptr<DNSSDResolveServiceQuery> FakeDNSSDQuerier::createResolveServiceQuery(const DNSSDServiceID& service) {

+ return std::make_shared<FakeDNSSDResolveServiceQuery>(service, shared_from_this());

+std::shared_ptr<DNSSDResolveHostnameQuery> FakeDNSSDQuerier::createResolveHostnameQuery(const std::string& hostname, int interfaceIndex) {

+ return std::make_shared<FakeDNSSDResolveHostnameQuery>(hostname, interfaceIndex, shared_from_this());

+void FakeDNSSDQuerier::addRunningQuery(std::shared_ptr<FakeDNSSDQuery> query) {

+ runningQueries.push_back(query);

+ allQueriesEverRun.push_back(query);

+ if (std::shared_ptr<FakeDNSSDBrowseQuery> browseQuery = std::dynamic_pointer_cast<FakeDNSSDBrowseQuery>(query)) {

+ for (const auto& service : services) {

+ eventLoop->postEvent(boost::bind(boost::ref(browseQuery->onServiceAdded), service), shared_from_this());

+ }

+ }

+ else if (std::shared_ptr<FakeDNSSDResolveServiceQuery> resolveQuery = std::dynamic_pointer_cast<FakeDNSSDResolveServiceQuery>(query)) {

+ for (const auto& i : serviceInfo) {

+ if (i.first == resolveQuery->service) {

+ eventLoop->postEvent(boost::bind(boost::ref(resolveQuery->onServiceResolved), i.second), shared_from_this());

+ }

+ }

+ }

+ else if (std::shared_ptr<FakeDNSSDRegisterQuery> registerQuery = std::dynamic_pointer_cast<FakeDNSSDRegisterQuery>(query)) {

+ DNSSDServiceID service(registerQuery->name, domain);

+ eventLoop->postEvent(boost::bind(boost::ref(registerQuery->onRegisterFinished), service), shared_from_this());

+ }

+ else if (std::shared_ptr<FakeDNSSDResolveHostnameQuery> resolveHostnameQuery = std::dynamic_pointer_cast<FakeDNSSDResolveHostnameQuery>(query)) {

+ std::map<std::string,boost::optional<HostAddress> >::const_iterator i = addresses.find(resolveHostnameQuery->hostname);

+ if (i != addresses.end()) {

+ eventLoop->postEvent(

+ boost::bind(

+ boost::ref(resolveHostnameQuery->onHostnameResolved), i->second),

+ shared_from_this());

+ }

+ }

+void FakeDNSSDQuerier::removeRunningQuery(std::shared_ptr<FakeDNSSDQuery> query) {

+ erase(runningQueries, query);

+ services.insert(id);

+ for (const auto& query : getQueries<FakeDNSSDBrowseQuery>()) {

+ eventLoop->postEvent(boost::bind(boost::ref(query->onServiceAdded), id), shared_from_this());

+ }

+ services.erase(id);

+ serviceInfo.erase(id);

+ for (const auto& query : getQueries<FakeDNSSDBrowseQuery>()) {

+ eventLoop->postEvent(boost::bind(boost::ref(query->onServiceRemoved), id), shared_from_this());

+ }

+ std::pair<ServiceInfoMap::iterator, bool> r = serviceInfo.insert(std::make_pair(id, info));

+ if (!r.second) {

+ r.first->second = info;

+ }

+ for (const auto& query : getQueries<FakeDNSSDResolveServiceQuery>()) {

+ if (query->service == id) {

+ eventLoop->postEvent(boost::bind(boost::ref(query->onServiceResolved), info), shared_from_this());

+ }

+ }

+ for (const auto& query : getQueries<FakeDNSSDRegisterQuery>()) {

+ if (query->name == name && query->port == port && query->info == info) {

+ return true;

+ }

+ }

+ return false;

+ for (const auto& query : getQueries<FakeDNSSDBrowseQuery>()) {

+ eventLoop->postEvent(boost::ref(query->onError), shared_from_this());

+ }

+ for (const auto& query : getQueries<FakeDNSSDRegisterQuery>()) {

+ eventLoop->postEvent(boost::bind(boost::ref(query->onRegisterFinished), boost::optional<DNSSDServiceID>()), shared_from_this());

+ }

+ addresses[hostname] = address;

+ for (const auto& query : getQueries<FakeDNSSDResolveHostnameQuery>()) {

+ if (query->hostname == hostname) {

+ eventLoop->postEvent(boost::bind(

+ boost::ref(query->onHostnameResolved), address), shared_from_this());

+ }

+ }

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <memory>

+

+ class FakeDNSSDQuery;

+ class FakeDNSSDBrowseQuery;

+ class EventLoop;

+ class SWIFTEN_API FakeDNSSDQuerier :

+ public DNSSDQuerier,

+ public EventOwner,

+ public std::enable_shared_from_this<FakeDNSSDQuerier> {

+ public:

+ FakeDNSSDQuerier(const std::string& domain, EventLoop* eventLoop);

+ ~FakeDNSSDQuerier();

+ void start() {}

+ void stop() {}

+ void clearAllQueriesEverRun() {

+ allQueriesEverRun.clear();

+ }

+ std::shared_ptr<DNSSDBrowseQuery> createBrowseQuery();

+ std::shared_ptr<DNSSDRegisterQuery> createRegisterQuery(

+ const std::string& name, int port, const ByteArray& info);

+ std::shared_ptr<DNSSDResolveServiceQuery> createResolveServiceQuery(

+ const DNSSDServiceID&);

+ std::shared_ptr<DNSSDResolveHostnameQuery> createResolveHostnameQuery(

+ const std::string& hostname, int interfaceIndex);

+ void addRunningQuery(std::shared_ptr<FakeDNSSDQuery>);

+ void removeRunningQuery(std::shared_ptr<FakeDNSSDQuery>);

+ void addService(const DNSSDServiceID& id);

+ void removeService(const DNSSDServiceID& id);

+ void setServiceInfo(const DNSSDServiceID& id, const DNSSDResolveServiceQuery::Result& info);

+ bool isServiceRegistered(const std::string& name, int port, const ByteArray& info);

+ void setAddress(const std::string& hostname, boost::optional<HostAddress> address);

+ void setBrowseError();

+ void setRegisterError();

+ public:

+ template<typename T>

+ std::vector< std::shared_ptr<T> > getAllQueriesEverRun() const {

+ std::vector< std::shared_ptr<T> > result;

+ for (const auto& i : allQueriesEverRun) {

+ if (std::shared_ptr<T> resultQuery = std::dynamic_pointer_cast<T>(i)) {

+ result.push_back(resultQuery);

+ }

+ }

+ return result;

+ }

+ private:

+ template<typename T>

+ std::vector< std::shared_ptr<T> > getQueries() const {

+ std::vector< std::shared_ptr<T> > result;

+ for (const auto& runningQuerie : runningQueries) {

+ if (std::shared_ptr<T> resultQuery = std::dynamic_pointer_cast<T>(runningQuerie)) {

+ result.push_back(resultQuery);

+ }

+ }

+ return result;

+ }

+ private:

+ std::string domain;

+ EventLoop* eventLoop;

+ typedef std::list< std::shared_ptr<FakeDNSSDQuery> > QueryList;

+ QueryList runningQueries;

+ QueryList allQueriesEverRun;

+ std::set<DNSSDServiceID> services;

+ typedef std::map<DNSSDServiceID,DNSSDResolveServiceQuery::Result> ServiceInfoMap;

+ ServiceInfoMap serviceInfo;

+ std::map<std::string, boost::optional<HostAddress> > addresses;

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+

+FakeDNSSDQuery::FakeDNSSDQuery(std::shared_ptr<FakeDNSSDQuerier> querier) : querier(querier) {

+ querier->addRunningQuery(shared_from_this());

+ querier->removeRunningQuery(shared_from_this());

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <memory>

+ class FakeDNSSDQuerier;

+ class FakeDNSSDQuery :

+ public EventOwner,

+ public std::enable_shared_from_this<FakeDNSSDQuery> {

+ public:

+ FakeDNSSDQuery(std::shared_ptr<FakeDNSSDQuerier>);

+ virtual ~FakeDNSSDQuery();

+

+ protected:

+ void run();

+ void finish();

+

+ protected:

+ std::shared_ptr<FakeDNSSDQuerier> querier;

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <Swiften/Base/ByteArray.h>

+#include <Swiften/LinkLocal/DNSSD/DNSSDRegisterQuery.h>

+#include <Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuery.h>

+

+ class FakeDNSSDQuerier;

+ class FakeDNSSDRegisterQuery : public DNSSDRegisterQuery, public FakeDNSSDQuery {

+ public:

+ FakeDNSSDRegisterQuery(const std::string& name, int port, const ByteArray& info, std::shared_ptr<FakeDNSSDQuerier> querier) : FakeDNSSDQuery(querier), name(name), port(port), info(info) {

+ }

+ void registerService() {

+ run();

+ }

+ void updateServiceInfo(const ByteArray& i) {

+ info = i;

+ }

+ void unregisterService() {

+ finish();

+ }

+ std::string name;

+ int port;

+ ByteArray info;

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+

+#include <Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuery.h>

+ class FakeDNSSDQuerier;

+ class FakeDNSSDResolveHostnameQuery : public DNSSDResolveHostnameQuery, public FakeDNSSDQuery {

+ public:

+ FakeDNSSDResolveHostnameQuery(const std::string& hostname, int interfaceIndex, std::shared_ptr<FakeDNSSDQuerier> querier) : FakeDNSSDQuery(querier), hostname(hostname), interfaceIndex(interfaceIndex) {

+ }

+ void run() {

+ FakeDNSSDQuery::run();

+ }

+ void finish() {

+ FakeDNSSDQuery::finish();

+ }

+ std::string hostname;

+ int interfaceIndex;

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuery.h>

+ class FakeDNSSDQuerier;

+ class FakeDNSSDResolveServiceQuery : public DNSSDResolveServiceQuery, public FakeDNSSDQuery {

+ public:

+ FakeDNSSDResolveServiceQuery(const DNSSDServiceID& service, std::shared_ptr<FakeDNSSDQuerier> querier) : FakeDNSSDQuery(querier), service(service) {

+ }

+ void start() {

+ run();

+ }

+ void stop() {

+ finish();

+ }

+ DNSSDServiceID service;

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+std::shared_ptr<DNSSDQuerier> PlatformDNSSDQuerierFactory::createQuerier() {

+ return std::make_shared<BonjourQuerier>(eventLoop);

+ return std::make_shared<AvahiQuerier>(eventLoop);

+ (void)eventLoop;

+ return std::shared_ptr<DNSSDQuerier>();

+ return true;

+ return false;

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <memory>

+ class DNSSDQuerier;

+ class EventLoop;

+ class SWIFTEN_API PlatformDNSSDQuerierFactory {

+ public:

+ PlatformDNSSDQuerierFactory(EventLoop* eventLoop);

+ std::shared_ptr<DNSSDQuerier> createQuerier();

+ bool canCreate();

+ private:

+ EventLoop* eventLoop;

+ };