-#pragma once

-

-#include "Swiften/LinkLocal/DNSSD/Bonjour/BonjourQuery.h"

-#include "Swiften/LinkLocal/DNSSD/DNSSDBrowseQuery.h"

-#include "Swiften/EventLoop/MainEventLoop.h"

-

-namespace Swift {

- class BonjourQuerier;

-

- class BonjourBrowseQuery : public DNSSDBrowseQuery, public BonjourQuery {

- public:

- BonjourBrowseQuery(boost::shared_ptr<BonjourQuerier> q) : BonjourQuery(q) {

- DNSServiceErrorType result = DNSServiceBrowse(

- &sdRef, 0, 0, "_presence._tcp", 0,

- &BonjourBrowseQuery::handleServiceDiscoveredStatic, this);

- if (result != kDNSServiceErr_NoError) {

- sdRef = NULL;

- }

- }

-

- void startBrowsing() {

- if (!sdRef) {

- MainEventLoop::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) {

- MainEventLoop::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, interfaceIndex);

- if (flags & kDNSServiceFlagsAdd) {

- MainEventLoop::postEvent(boost::bind(boost::ref(onServiceAdded), service), shared_from_this());

- }

- else {

- MainEventLoop::postEvent(boost::bind(boost::ref(onServiceRemoved), service), shared_from_this());

- }

- }

- }

- };

-}

-#include "Swiften/LinkLocal/DNSSD/Bonjour/BonjourQuerier.h"

-

-#include <unistd.h>

-#include <sys/socket.h>

-#include <fcntl.h>

-

-#include "Swiften/LinkLocal/DNSSD/Bonjour/BonjourBrowseQuery.h"

-#include "Swiften/LinkLocal/DNSSD/Bonjour/BonjourRegisterQuery.h"

-#include "Swiften/LinkLocal/DNSSD/Bonjour/BonjourResolveServiceQuery.h"

-#include "Swiften/LinkLocal/DNSSD/Bonjour/BonjourResolveHostnameQuery.h"

-#include "Swiften/Base/foreach.h"

-

-namespace Swift {

-

-BonjourQuerier::BonjourQuerier() : stopRequested(false), thread(0) {

- int fds[2];

- int result = pipe(fds);

- assert(result == 0);

- interruptSelectReadSocket = fds[0];

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

- interruptSelectWriteSocket = fds[1];

-}

-

-BonjourQuerier::~BonjourQuerier() {

- assert(!thread);

-}

-

-boost::shared_ptr<DNSSDBrowseQuery> BonjourQuerier::createBrowseQuery() {

- return boost::shared_ptr<DNSSDBrowseQuery>(new BonjourBrowseQuery(shared_from_this()));

-}

-

-boost::shared_ptr<DNSSDRegisterQuery> BonjourQuerier::createRegisterQuery(const String& name, int port, const ByteArray& info) {

- return boost::shared_ptr<DNSSDRegisterQuery>(new BonjourRegisterQuery(name, port, info, shared_from_this()));

-}

-

-boost::shared_ptr<DNSSDResolveServiceQuery> BonjourQuerier::createResolveServiceQuery(const DNSSDServiceID& service) {

- return boost::shared_ptr<DNSSDResolveServiceQuery>(new BonjourResolveServiceQuery(service, shared_from_this()));

-}

-

-boost::shared_ptr<DNSSDResolveHostnameQuery> BonjourQuerier::createResolveHostnameQuery(const String& hostname, int interfaceIndex) {

- return boost::shared_ptr<DNSSDResolveHostnameQuery>(new BonjourResolveHostnameQuery(hostname, interfaceIndex, shared_from_this()));

-}

-

-void BonjourQuerier::addRunningQuery(boost::shared_ptr<BonjourQuery> query) {

- {

- boost::lock_guard<boost::mutex> lock(runningQueriesMutex);

- runningQueries.push_back(query);

- }

- runningQueriesAvailableEvent.notify_one();

- interruptSelect();

-}

-

-void BonjourQuerier::removeRunningQuery(boost::shared_ptr<BonjourQuery> query) {

- {

- boost::lock_guard<boost::mutex> lock(runningQueriesMutex);

- runningQueries.erase(std::remove(

- runningQueries.begin(), runningQueries.end(), query), runningQueries.end());

- }

-}

-

-void BonjourQuerier::interruptSelect() {

- char c = 0;

- write(interruptSelectWriteSocket, &c, 1);

-}

-

-void BonjourQuerier::start() {

- assert(!thread);

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

-}

-

-void BonjourQuerier::stop() {

- if (thread) {

- stopRequested = true;

- assert(runningQueries.empty());

- runningQueriesAvailableEvent.notify_one();

- interruptSelect();

- thread->join();

- delete thread;

- thread = NULL;

- stopRequested = false;

- }

-}

-

-void BonjourQuerier::run() {

- while (!stopRequested) {

- fd_set fdSet;

- int maxSocket;

- {

- boost::unique_lock<boost::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);

-

- foreach(const boost::shared_ptr<BonjourQuery>& query, runningQueries) {

- int socketID = query->getSocketID();

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

- FD_SET(socketID, &fdSet);

- }

- }

-

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

- continue;

- }

-

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

- char dummy;

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

- }

-

- {

- boost::lock_guard<boost::mutex> lock(runningQueriesMutex);

- foreach(boost::shared_ptr<BonjourQuery> query, runningQueries) {

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

- query->processResult();

- }

- }

- }

- }

-}

-

-}

-#pragma once

-

-#include <boost/shared_ptr.hpp>

-#include <boost/enable_shared_from_this.hpp>

-#include <list>

-#include <boost/thread.hpp>

-#include <boost/thread/mutex.hpp>

-

-#include "Swiften/LinkLocal/DNSSD/DNSSDQuerier.h"

-#include "Swiften/LinkLocal/DNSSD/Bonjour/BonjourQuery.h"

-

-namespace Swift {

- class ByteArray;

-

- class BonjourQuerier :

- public DNSSDQuerier,

- public boost::enable_shared_from_this<BonjourQuerier> {

- public:

- BonjourQuerier();

- ~BonjourQuerier();

-

- boost::shared_ptr<DNSSDBrowseQuery> createBrowseQuery();

- boost::shared_ptr<DNSSDRegisterQuery> createRegisterQuery(

- const String& name, int port, const ByteArray& info);

- boost::shared_ptr<DNSSDResolveServiceQuery> createResolveServiceQuery(

- const DNSSDServiceID&);

- boost::shared_ptr<DNSSDResolveHostnameQuery> createResolveHostnameQuery(

- const String& hostname, int interfaceIndex);

-

- void start();

- void stop();

-

- private:

- friend class BonjourQuery;

-

- void addRunningQuery(boost::shared_ptr<BonjourQuery>);

- void removeRunningQuery(boost::shared_ptr<BonjourQuery>);

- void interruptSelect();

- void run();

-

- private:

- bool stopRequested;

- boost::thread* thread;

- boost::mutex runningQueriesMutex;

- std::list< boost::shared_ptr<BonjourQuery> > runningQueries;

- int interruptSelectReadSocket;

- int interruptSelectWriteSocket;

- boost::condition_variable runningQueriesAvailableEvent;

- };

-}

-#include "Swiften/LinkLocal/DNSSD/Bonjour/BonjourQuery.h"

-#include "Swiften/LinkLocal/DNSSD/Bonjour/BonjourQuerier.h"

-

-namespace Swift {

-

-BonjourQuery::BonjourQuery(boost::shared_ptr<BonjourQuerier> q) : querier(q), sdRef(0) {

-}

-

-BonjourQuery::~BonjourQuery() {

- DNSServiceRefDeallocate(sdRef);

-}

-

-void BonjourQuery::processResult() {

- boost::lock_guard<boost::mutex> lock(sdRefMutex);

- DNSServiceProcessResult(sdRef);

-}

-

-int BonjourQuery::getSocketID() const {

- boost::lock_guard<boost::mutex> lock(sdRefMutex);

- return DNSServiceRefSockFD(sdRef);

-}

-

-void BonjourQuery::run() {

- querier->addRunningQuery(shared_from_this());

-}

-

-void BonjourQuery::finish() {

- querier->removeRunningQuery(shared_from_this());

-}

-

-}

-#pragma once

-

-#include <dns_sd.h>

-#include <boost/shared_ptr.hpp>

-#include <boost/enable_shared_from_this.hpp>

-#include <boost/thread/mutex.hpp>

-

-#include "Swiften/EventLoop/EventOwner.h"

-

-namespace Swift {

- class BonjourQuerier;

-

- class BonjourQuery :

- public EventOwner,

- public boost::enable_shared_from_this<BonjourQuery> {

- public:

- BonjourQuery(boost::shared_ptr<BonjourQuerier>);

- virtual ~BonjourQuery();

-

- void processResult();

- int getSocketID() const;

-

- protected:

- void run();

- void finish();

-

- protected:

- boost::shared_ptr<BonjourQuerier> querier;

- mutable boost::mutex sdRefMutex;

- DNSServiceRef sdRef;

- };

-}

-#pragma once

-

-#include "Swiften/LinkLocal/DNSSD/Bonjour/BonjourQuery.h"

-#include "Swiften/LinkLocal/DNSSD/DNSSDRegisterQuery.h"

-#include "Swiften/Base/ByteArray.h"

-#include "Swiften/EventLoop/MainEventLoop.h"

-

-namespace Swift {

- class BonjourQuerier;

-

- class BonjourRegisterQuery : public DNSSDRegisterQuery, public BonjourQuery {

- public:

- BonjourRegisterQuery(const String& name, int port, const ByteArray& txtRecord, boost::shared_ptr<BonjourQuerier> querier) : BonjourQuery(querier) {

- DNSServiceErrorType result = DNSServiceRegister(

- &sdRef, 0, 0, name.getUTF8Data(), "_presence._tcp", NULL, NULL, port,

- txtRecord.getSize(), txtRecord.getData(),

- &BonjourRegisterQuery::handleServiceRegisteredStatic, this);

- if (result != kDNSServiceErr_NoError) {

- sdRef = NULL;

- }

- }

-

- void registerService() {

- if (sdRef) {

- run();

- }

- else {

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

- }

- }

-

- void unregisterService() {

- finish();

- }

-

- void updateServiceInfo(const ByteArray& txtRecord) {

- boost::lock_guard<boost::mutex> lock(sdRefMutex);

- DNSServiceUpdateRecord(sdRef, NULL, NULL, txtRecord.getSize(), txtRecord.getData(), 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) {

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

- }

- else {

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

- }

- }

- };

-}

-#pragma once

-

-#include "Swiften/Base/String.h"

-#include "Swiften/LinkLocal/DNSSD/Bonjour/BonjourQuery.h"

-#include "Swiften/LinkLocal/DNSSD/DNSSDResolveHostnameQuery.h"

-#include "Swiften/EventLoop/MainEventLoop.h"

-#include "Swiften/Network/HostAddress.h"

-

-#include <netinet/in.h>

-

-namespace Swift {

- class BonjourQuerier;

-

- class BonjourResolveHostnameQuery : public DNSSDResolveHostnameQuery, public BonjourQuery {

- public:

- BonjourResolveHostnameQuery(const String& hostname, int interfaceIndex, boost::shared_ptr<BonjourQuerier> querier) : BonjourQuery(querier) {

- DNSServiceErrorType result = DNSServiceGetAddrInfo(

- &sdRef, 0, interfaceIndex, kDNSServiceProtocol_IPv4,

- hostname.getUTF8Data(),

- &BonjourResolveHostnameQuery::handleHostnameResolvedStatic, this);

- if (result != kDNSServiceErr_NoError) {

- sdRef = NULL;

- }

- }

-

- //void DNSSDResolveHostnameQuery::run() {

- void run() {

- if (sdRef) {

- BonjourQuery::run();

- }

- else {

- MainEventLoop::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) {

- MainEventLoop::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);

- MainEventLoop::postEvent(boost::bind(

- boost::ref(onHostnameResolved),

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

- shared_from_this());

- }

- }

- };

-}

-#pragma once

-

-#include "Swiften/LinkLocal/DNSSD/Bonjour/BonjourQuery.h"

-#include "Swiften/LinkLocal/DNSSD/DNSSDResolveServiceQuery.h"

-#include "Swiften/LinkLocal/LinkLocalServiceInfo.h"

-#include "Swiften/Base/ByteArray.h"

-#include "Swiften/EventLoop/MainEventLoop.h"

-

-namespace Swift {

- class BonjourQuerier;

-

- class BonjourResolveServiceQuery : public DNSSDResolveServiceQuery, public BonjourQuery {

- public:

- BonjourResolveServiceQuery(const DNSSDServiceID& service, boost::shared_ptr<BonjourQuerier> querier) : BonjourQuery(querier) {

- DNSServiceErrorType result = DNSServiceResolve(

- &sdRef, 0, service.getNetworkInterfaceID(),

- service.getName().getUTF8Data(), service.getType().getUTF8Data(),

- service.getDomain().getUTF8Data(),

- &BonjourResolveServiceQuery::handleServiceResolvedStatic, this);

- if (result != kDNSServiceErr_NoError) {

- sdRef = NULL;

- }

- }

-

- void start() {

- if (sdRef) {

- run();

- }

- else {

- MainEventLoop::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) {

- MainEventLoop::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;

- MainEventLoop::postEvent(

- boost::bind(

- boost::ref(onServiceResolved),

- Result(String(fullName), String(host), port,

- ByteArray(reinterpret_cast<const char*>(txtRecord), txtLen))),

- shared_from_this());

- }

- }

- };

-}