-#pragma once

-

-#include <boost/bind.hpp>

-

-#include "Swiften/LinkLocal/DNSSD/Avahi/AvahiQuery.h"

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

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

-

-namespace Swift {

- class AvahiQuerier;

-

- class AvahiBrowseQuery : public DNSSDBrowseQuery, public AvahiQuery {

- public:

- AvahiBrowseQuery(boost::shared_ptr<AvahiQuerier> q) : AvahiQuery(q) {

- }

-

- void startBrowsing() {

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

- avahi_threaded_poll_lock(querier->getThreadedPoll());

- std::cout << "Creating browser" << std::endl;

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

- if (!browser) {

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

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

- }

- std::cout << "Unlocking" << std::endl;

- avahi_threaded_poll_unlock(querier->getThreadedPoll());

- std::cout << "Browse started" << std::endl;

- }

-

- void stopBrowsing() {

- // TODO

- }

-

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

- switch (event) {

- case AVAHI_BROWSER_FAILURE:

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

- MainEventLoop::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 << " " << type << " " << domain << std::endl;

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

- break;

- }

- case AVAHI_BROWSER_REMOVE: {

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

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

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

- break;

- }

- case AVAHI_BROWSER_ALL_FOR_NOW:

- case AVAHI_BROWSER_CACHE_EXHAUSTED:

- break;

- }

- }

- };

-}

-#include "Swiften/LinkLocal/DNSSD/Avahi/AvahiQuerier.h"

-

-#include <iostream>

-

-#include "Swiften/LinkLocal/DNSSD/Avahi/AvahiBrowseQuery.h"

-#include "Swiften/LinkLocal/DNSSD/Avahi/AvahiResolveServiceQuery.h"

-#include "Swiften/LinkLocal/DNSSD/Avahi/AvahiResolveHostnameQuery.h"

-#include "Swiften/LinkLocal/DNSSD/Avahi/AvahiRegisterQuery.h"

-

-namespace Swift {

-

-AvahiQuerier::AvahiQuerier() : client(NULL), threadedPoll(NULL) {

-}

-

-AvahiQuerier::~AvahiQuerier() {

-}

-

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

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

-}

-

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

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

-}

-

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

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

-}

-

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

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

-}

-

-void AvahiQuerier::start() {

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

-}

-

-void AvahiQuerier::stop() {

- assert(threadedPoll);

- avahi_threaded_poll_stop(threadedPoll);

- assert(client);

- avahi_client_free(client);

- avahi_threaded_poll_free(threadedPoll);

-}

-

-}

-#pragma once

-

-#include <boost/shared_ptr.hpp>

-#include <boost/enable_shared_from_this.hpp>

-#include <avahi-client/client.h>

-#include <avahi-client/lookup.h>

-#include <avahi-common/thread-watch.h>

-#include <avahi-common/watch.h>

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

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

-

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

-

-namespace Swift {

- class ByteArray;

-

- class AvahiQuerier :

- public DNSSDQuerier,

- public boost::enable_shared_from_this<AvahiQuerier> {

- public:

- AvahiQuerier();

- ~AvahiQuerier();

-

- 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();

-

- AvahiThreadedPoll* getThreadedPoll() const {

- return threadedPoll;

- }

-

- AvahiClient* getClient() const {

- return client;

- }

-

- private:

- AvahiClient* client;

- AvahiThreadedPoll* threadedPoll;

- };

-}

-#include "Swiften/LinkLocal/DNSSD/Avahi/AvahiQuery.h"

-#include "Swiften/LinkLocal/DNSSD/Avahi/AvahiQuerier.h"

-

-namespace Swift {

-

-AvahiQuery::AvahiQuery(boost::shared_ptr<AvahiQuerier> q) : querier(q) {

-}

-

-AvahiQuery::~AvahiQuery() {

-}

-

-}

-

-#pragma once

-

-#include <boost/shared_ptr.hpp>

-#include <boost/enable_shared_from_this.hpp>

-

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

-

-namespace Swift {

- class AvahiQuerier;

-

- class AvahiQuery :

- public EventOwner,

- public boost::enable_shared_from_this<AvahiQuery> {

- public:

- AvahiQuery(boost::shared_ptr<AvahiQuerier>);

- virtual ~AvahiQuery();

-

- protected:

- boost::shared_ptr<AvahiQuerier> querier;

- };

-}

-

-#pragma once

-

-#include <avahi-client/publish.h>

-

-#include "Swiften/LinkLocal/DNSSD/Avahi/AvahiQuery.h"

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

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

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

-

-namespace Swift {

- class AvahiQuerier;

-

- class AvahiRegisterQuery : public DNSSDRegisterQuery, public AvahiQuery {

- public:

- AvahiRegisterQuery(const String& name, int port, const ByteArray& txtRecord, boost::shared_ptr<AvahiQuerier> querier) : AvahiQuery(querier), name(name), port(port), txtRecord(txtRecord), group(0) {

- }

-

- void registerService() {

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

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

- }

- }

-

- doRegisterService();

- avahi_threaded_poll_unlock(querier->getThreadedPoll());

- }

-

- void unregisterService() {

- }

-

- void updateServiceInfo(const ByteArray& txtRecord) {

- this->txtRecord = txtRecord;

- avahi_threaded_poll_lock(querier->getThreadedPoll());

- assert(group);

- avahi_entry_group_reset(group);

- doRegisterService();

- avahi_threaded_poll_unlock(querier->getThreadedPoll());

- }

-

- private:

- void doRegisterService() {

- AvahiStringList* txtList;

- avahi_string_list_parse(txtRecord.getData(), txtRecord.getSize(), &txtList);

-

- int result = avahi_entry_group_add_service_strlst(group, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, (AvahiPublishFlags) 0, name.getUTF8Data(), "_presence._tcp", NULL, NULL, port, txtList);

- if (result < 0) {

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

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

- }

- }

-

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

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

- }

-

- void handleEntryGroupChange(AvahiEntryGroup* g, AvahiEntryGroupState state) {

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

- switch (state) {

- case AVAHI_ENTRY_GROUP_ESTABLISHED :

- // Domain is a hack!

- MainEventLoop::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.getUTF8Data(), "_presence._tcp", NULL, NULL, port,

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

- &AvahiRegisterQuery::handleServiceRegisteredStatic, this);

- if (result != kDNSServiceErr_NoError) {

- sdRef = NULL;

- }*/

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

- }

- }

-

-/*

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

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

- }

- else {

- }

- }

- */

-

- private:

- String name;

- int port;

- ByteArray txtRecord;

- AvahiEntryGroup* group;

- };

-}

-#pragma once

-

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

-#include "Swiften/LinkLocal/DNSSD/Avahi/AvahiQuery.h"

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

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

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

-

-#include <netinet/in.h>

-

-namespace Swift {

- class AvahiQuerier;

-

- class AvahiResolveHostnameQuery : public DNSSDResolveHostnameQuery, public AvahiQuery {

- public:

- AvahiResolveHostnameQuery(const String& hostname, int, boost::shared_ptr<AvahiQuerier> querier) : AvahiQuery(querier), hostname(hostname) {

- std::cout << "Resolving hostname " << hostname << std::endl;

- }

-

- void run() {

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

- }

-

- void finish() {

- }

-

- private:

- HostAddress hostAddress;

- String hostname;

- };

-}

-#pragma once

-

-#include "Swiften/LinkLocal/DNSSD/Avahi/AvahiQuery.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 AvahiQuerier;

-

- class AvahiResolveServiceQuery : public DNSSDResolveServiceQuery, public AvahiQuery {

- public:

- AvahiResolveServiceQuery(const DNSSDServiceID& service, boost::shared_ptr<AvahiQuerier> querier) : AvahiQuery(querier), service(service), resolver(NULL) {

- }

-

- void start() {

- std::cout << "Resolving " << service.getName() << std::endl;

- avahi_threaded_poll_lock(querier->getThreadedPoll());

- assert(!resolver);

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

- if (!resolver) {

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

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

- }

- avahi_threaded_poll_unlock(querier->getThreadedPoll());

- }

-

- void stop() {

- avahi_threaded_poll_lock(querier->getThreadedPoll());

- avahi_service_resolver_free(resolver);

- resolver = NULL;

- avahi_threaded_poll_unlock(querier->getThreadedPoll());

- }

-

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

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

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

- break;

- case AVAHI_RESOLVER_FOUND: {

- char a[AVAHI_ADDRESS_STR_MAX];

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

-

- ByteArray txtRecord;

- txtRecord.resize(1024);

- avahi_string_list_serialize(txt, txtRecord.getData(), txtRecord.getSize());

-

- // FIXME: Probably not accurate

- String fullname = String(name) + "." + String(type) + "." + String(domain) + ".";

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

- MainEventLoop::postEvent(

- boost::bind(

- boost::ref(onServiceResolved),

- Result(fullname, String(a), port, txtRecord)),

- shared_from_this());

- break;

- }

- }

- }

-

- private:

- DNSSDServiceID service;

- AvahiServiceResolver* resolver;

- };

-}

-#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());

- }

- }

- };

-}

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

-

-namespace Swift {

-

-DNSSDBrowseQuery::~DNSSDBrowseQuery() {

-}

-

-}

-#pragma once

-

-#include <boost/signal.hpp>

-

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

-

-namespace Swift {

- class DNSSDBrowseQuery {

- public:

- virtual ~DNSSDBrowseQuery();

-

- virtual void startBrowsing() = 0;

- virtual void stopBrowsing() = 0;

-

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

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

- boost::signal<void ()> onError;

- };

-}

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

-

-namespace Swift {

-

-DNSSDQuerier::~DNSSDQuerier() {

-}

-

-}

-#pragma once

-

-#include <boost/shared_ptr.hpp>

-

-namespace Swift {

- class String;

- class ByteArray;

- class DNSSDServiceID;

- class DNSSDBrowseQuery;

- class DNSSDRegisterQuery;

- class DNSSDResolveServiceQuery;

- class DNSSDResolveHostnameQuery;

-

- class DNSSDQuerier {

- public:

- virtual ~DNSSDQuerier();

-

- virtual void start() = 0;

- virtual void stop() = 0;

-

- virtual boost::shared_ptr<DNSSDBrowseQuery> createBrowseQuery() = 0;

- virtual boost::shared_ptr<DNSSDRegisterQuery> createRegisterQuery(

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

- virtual boost::shared_ptr<DNSSDResolveServiceQuery> createResolveServiceQuery(

- const DNSSDServiceID&) = 0;

- virtual boost::shared_ptr<DNSSDResolveHostnameQuery> createResolveHostnameQuery(

- const String& hostname, int interfaceIndex) = 0;

- };

-}

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

-

-namespace Swift {

-

-DNSSDRegisterQuery::~DNSSDRegisterQuery() {

-}

-

-}

-#pragma once

-

-#include <boost/signal.hpp>

-#include <boost/optional.hpp>

-

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

-

-namespace Swift {

- class ByteArray;

-

- class DNSSDRegisterQuery {

- public:

- virtual ~DNSSDRegisterQuery();

-

- virtual void registerService() = 0;

- virtual void unregisterService() = 0;

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

-

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

- };

-}

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

-

-namespace Swift {

-

-DNSSDResolveHostnameQuery::~DNSSDResolveHostnameQuery() {

-}

-

-}

-#pragma once

-

-#include <boost/signal.hpp>

-#include <boost/optional.hpp>

-

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

-

-namespace Swift {

- class DNSSDResolveHostnameQuery {

- public:

- virtual ~DNSSDResolveHostnameQuery();

-

- virtual void run() = 0;

- virtual void finish() = 0;

-

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

- };

-}

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

-

-namespace Swift {

-

-DNSSDResolveServiceQuery::~DNSSDResolveServiceQuery() {

-}

-

-}

-#pragma once

-

-#include <boost/signal.hpp>

-#include <boost/optional.hpp>

-

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

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

-

-namespace Swift {

- class DNSSDResolveServiceQuery {

- public:

- struct Result {

- Result(const String& fullName, const String& host, int port, const ByteArray& info) :

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

- String fullName;

- String host;

- int port;

- ByteArray info;

- };

-

- virtual ~DNSSDResolveServiceQuery();

-

- virtual void start() = 0;

- virtual void stop() = 0;

-

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

- };

-}

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

-

-namespace Swift {

-

-const char* DNSSDServiceID::PresenceServiceType = "_presence._tcp";

-

-}

-#pragma once

-

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

-

-namespace Swift {

- class DNSSDServiceID {

- public:

- static const char* PresenceServiceType;

-

- DNSSDServiceID(

- const String& name,

- const String& domain,

- const String& type = PresenceServiceType,

- int networkInterface = 0) :

- 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 String& getName() const {

- return name;

- }

-

- const String& getDomain() const {

- return domain;

- }

-

- const String& getType() const {

- return type;

- }

-

- int getNetworkInterfaceID() const {

- return networkInterface;

- }

-

- private:

- String name;

- String domain;

- String type;

- int networkInterface;

- };

-}

-#pragma once

-

-#include "Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuery.h"

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

-

-namespace Swift {

- class FakeDNSSDQuerier;

-

- class FakeDNSSDBrowseQuery : public DNSSDBrowseQuery, public FakeDNSSDQuery {

- public:

- FakeDNSSDBrowseQuery(boost::shared_ptr<FakeDNSSDQuerier> querier) : FakeDNSSDQuery(querier) {

- }

-

- void startBrowsing() {

- run();

- }

-

- void stopBrowsing() {

- finish();

- }

- };

-}

-#include "Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuerier.h"

-

-#include <boost/bind.hpp>

-

-#include "Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDBrowseQuery.h"

-#include "Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDRegisterQuery.h"

-#include "Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDResolveServiceQuery.h"

-#include "Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDResolveHostnameQuery.h"

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

-

-namespace Swift {

-

-FakeDNSSDQuerier::FakeDNSSDQuerier(const String& domain) : domain(domain) {

-}

-

-FakeDNSSDQuerier::~FakeDNSSDQuerier() {

- if (!runningQueries.empty()) {

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

- }

-}

-

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

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

-}

-

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

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

-}

-

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

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

-}

-

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

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

-}

-

-void FakeDNSSDQuerier::addRunningQuery(boost::shared_ptr<FakeDNSSDQuery> query) {

- runningQueries.push_back(query);

- if (boost::shared_ptr<FakeDNSSDBrowseQuery> browseQuery = boost::dynamic_pointer_cast<FakeDNSSDBrowseQuery>(query)) {

- foreach(const DNSSDServiceID& service, services) {

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

- }

- }

- else if (boost::shared_ptr<FakeDNSSDResolveServiceQuery> resolveQuery = boost::dynamic_pointer_cast<FakeDNSSDResolveServiceQuery>(query)) {

- for(ServiceInfoMap::const_iterator i = serviceInfo.begin(); i != serviceInfo.end(); ++i) {

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

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

- }

- }

- }

- else if (boost::shared_ptr<FakeDNSSDRegisterQuery> registerQuery = boost::dynamic_pointer_cast<FakeDNSSDRegisterQuery>(query)) {

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

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

- }

- else if (boost::shared_ptr<FakeDNSSDResolveHostnameQuery> resolveHostnameQuery = boost::dynamic_pointer_cast<FakeDNSSDResolveHostnameQuery>(query)) {

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

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

- MainEventLoop::postEvent(

- boost::bind(

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

- shared_from_this());

- }

- }

-}

-

-void FakeDNSSDQuerier::removeRunningQuery(boost::shared_ptr<FakeDNSSDQuery> query) {

- runningQueries.erase(std::remove(

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

-}

-

-void FakeDNSSDQuerier::addService(const DNSSDServiceID& id) {

- services.insert(id);

- foreach(const boost::shared_ptr<FakeDNSSDBrowseQuery>& query, getQueries<FakeDNSSDBrowseQuery>()) {

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

- }

-}

-

-void FakeDNSSDQuerier::removeService(const DNSSDServiceID& id) {

- services.erase(id);

- serviceInfo.erase(id);

- foreach(const boost::shared_ptr<FakeDNSSDBrowseQuery>& query, getQueries<FakeDNSSDBrowseQuery>()) {

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

- }

-}

-

-void FakeDNSSDQuerier::setServiceInfo(const DNSSDServiceID& id, const DNSSDResolveServiceQuery::Result& info) {

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

- if (!r.second) {

- r.first->second = info;

- }

- foreach(const boost::shared_ptr<FakeDNSSDResolveServiceQuery>& query, getQueries<FakeDNSSDResolveServiceQuery>()) {

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

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

- }

- }

-}

-

-bool FakeDNSSDQuerier::isServiceRegistered(const String& name, int port, const ByteArray& info) {

- foreach(const boost::shared_ptr<FakeDNSSDRegisterQuery>& query, getQueries<FakeDNSSDRegisterQuery>()) {

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

- return true;

- }

- }

- return false;

-}

-

-void FakeDNSSDQuerier::setBrowseError() {

- foreach(const boost::shared_ptr<FakeDNSSDBrowseQuery>& query, getQueries<FakeDNSSDBrowseQuery>()) {

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

- }

-}

-

-void FakeDNSSDQuerier::setRegisterError() {

- foreach(const boost::shared_ptr<FakeDNSSDRegisterQuery>& query, getQueries<FakeDNSSDRegisterQuery>()) {

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

- }

-}

-

-void FakeDNSSDQuerier::setAddress(const String& hostname, boost::optional<HostAddress> address) {

- addresses[hostname] = address;

- foreach(const boost::shared_ptr<FakeDNSSDResolveHostnameQuery>& query, getQueries<FakeDNSSDResolveHostnameQuery>()) {

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

- MainEventLoop::postEvent(boost::bind(

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

- }

- }

-}

-

-}

-#pragma once

-

-#include <boost/shared_ptr.hpp>

-#include <boost/enable_shared_from_this.hpp>

-#include <list>

-#include <set>

-

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

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

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

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

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

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

-

-namespace Swift {

- class ByteArray;

- class FakeDNSSDQuery;

- class FakeDNSSDBrowseQuery;

-

- class FakeDNSSDQuerier :

- public DNSSDQuerier,

- public EventOwner,

- public boost::enable_shared_from_this<FakeDNSSDQuerier> {

- public:

- FakeDNSSDQuerier(const String& domain);

- ~FakeDNSSDQuerier();

-

- void start() {}

- void stop() {}

-

- 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 addRunningQuery(boost::shared_ptr<FakeDNSSDQuery>);

- void removeRunningQuery(boost::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 String& name, int port, const ByteArray& info);

- void setAddress(const String& hostname, boost::optional<HostAddress> address);

-

- void setBrowseError();

- void setRegisterError();

-

- private:

- template<typename T>

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

- std::vector< boost::shared_ptr<T> > result;

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

- if (boost::shared_ptr<T> resultQuery = boost::dynamic_pointer_cast<T>(query)) {

- result.push_back(resultQuery);

- }

- }

- return result;

- }

-

- private:

- String domain;

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

- std::set<DNSSDServiceID> services;

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

- ServiceInfoMap serviceInfo;

- std::map<String, boost::optional<HostAddress> > addresses;

- };

-}

-#include "Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuery.h"

-#include "Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuerier.h"

-

-namespace Swift {

-

-FakeDNSSDQuery::FakeDNSSDQuery(boost::shared_ptr<FakeDNSSDQuerier> querier) : querier(querier) {

-}

-

-FakeDNSSDQuery::~FakeDNSSDQuery() {

-}

-

-void FakeDNSSDQuery::run() {

- querier->addRunningQuery(shared_from_this());

-}

-

-void FakeDNSSDQuery::finish() {

- querier->removeRunningQuery(shared_from_this());

-}

-

-}

-#pragma once

-

-#include <boost/shared_ptr.hpp>

-#include <boost/enable_shared_from_this.hpp>

-

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

-

-namespace Swift {

- class FakeDNSSDQuerier;

-

- class FakeDNSSDQuery :

- public EventOwner,

- public boost::enable_shared_from_this<FakeDNSSDQuery> {

- public:

- FakeDNSSDQuery(boost::shared_ptr<FakeDNSSDQuerier>);

- virtual ~FakeDNSSDQuery();

-

- protected:

- void run();

- void finish();

-

- protected:

- boost::shared_ptr<FakeDNSSDQuerier> querier;

- };

-}

-#pragma once

-

-#include "Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuery.h"

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

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

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

-

-namespace Swift {

- class FakeDNSSDQuerier;

-

- class FakeDNSSDRegisterQuery : public DNSSDRegisterQuery, public FakeDNSSDQuery {

- public:

- FakeDNSSDRegisterQuery(const String& name, int port, const ByteArray& info, boost::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();

- }

-

- String name;

- int port;

- ByteArray info;

- };

-}

-#pragma once

-

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

-#include "Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuery.h"

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

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

-

-namespace Swift {

- class FakeDNSSDQuerier;

-

- class FakeDNSSDResolveHostnameQuery : public DNSSDResolveHostnameQuery, public FakeDNSSDQuery {

- public:

- FakeDNSSDResolveHostnameQuery(const String& hostname, int interfaceIndex, boost::shared_ptr<FakeDNSSDQuerier> querier) : FakeDNSSDQuery(querier), hostname(hostname), interfaceIndex(interfaceIndex) {

- }

-

- void run() {

- FakeDNSSDQuery::run();

- }

-

- void finish() {

- FakeDNSSDQuery::finish();

- }

-

- String hostname;

- int interfaceIndex;

- };

-}

-#pragma once

-

-#include "Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuery.h"

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

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

-

-namespace Swift {

- class FakeDNSSDQuerier;

-

- class FakeDNSSDResolveServiceQuery : public DNSSDResolveServiceQuery, public FakeDNSSDQuery {

- public:

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

- }

-

- void start() {

- run();

- }

-

- void stop() {

- finish();

- }

-

- DNSSDServiceID service;

- };

-}

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

-

-#if defined(HAVE_BONJOUR)

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

-#elif defined(HAVE_AVAHI)

-#include "Swiften/LinkLocal/DNSSD/Avahi/AvahiQuerier.h"

-#endif

-

-

-namespace Swift {

-

-boost::shared_ptr<DNSSDQuerier> PlatformDNSSDQuerierFactory::createQuerier() {

-#if defined(HAVE_BONJOUR)

- return boost::shared_ptr<DNSSDQuerier>(new BonjourQuerier());

-#elif defined(HAVE_AVAHI)

- return boost::shared_ptr<DNSSDQuerier>(new AvahiQuerier());

-#else

- return boost::shared_ptr<DNSSDQuerier>();

-#endif

-}

-

-}

-#pragma once

-

-#include <boost/shared_ptr.hpp>

-

-namespace Swift {

- class DNSSDQuerier;

-

- class PlatformDNSSDQuerierFactory {

- public:

- boost::shared_ptr<DNSSDQuerier> createQuerier();

- };

-}

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

-

-#include <boost/bind.hpp>

-

-#include "Swiften/Elements/ProtocolHeader.h"

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

-#include "Swiften/StreamStack/StreamStack.h"

-#include "Swiften/StreamStack/ConnectionLayer.h"

-#include "Swiften/StreamStack/XMPPLayer.h"

-#include "Swiften/Elements/StreamFeatures.h"

-#include "Swiften/Elements/IQ.h"

-

-namespace Swift {

-

-IncomingLinkLocalSession::IncomingLinkLocalSession(

- const JID& localJID,

- boost::shared_ptr<Connection> connection,

- PayloadParserFactoryCollection* payloadParserFactories,

- PayloadSerializerCollection* payloadSerializers) :

- Session(connection, payloadParserFactories, payloadSerializers),

- initialized(false) {

- setLocalJID(localJID);

-}

-

-void IncomingLinkLocalSession::handleStreamStart(const ProtocolHeader& incomingHeader) {

- setRemoteJID(JID(incomingHeader.getFrom()));

- if (!getRemoteJID().isValid()) {

- finishSession();

- return;

- }

-

- ProtocolHeader header;

- header.setFrom(getLocalJID());

- getXMPPLayer()->writeHeader(header);

-

- if (incomingHeader.getVersion() == "1.0") {

- getXMPPLayer()->writeElement(boost::shared_ptr<StreamFeatures>(new StreamFeatures()));

- }

- else {

- setInitialized();

- }

-}

-

-void IncomingLinkLocalSession::handleElement(boost::shared_ptr<Element> element) {

- boost::shared_ptr<Stanza> stanza = boost::dynamic_pointer_cast<Stanza>(element);

- // If we get our first stanza before streamfeatures, our session is implicitly

- // initialized

- if (stanza && !isInitialized()) {

- setInitialized();

- }

-

- onElementReceived(element);

-}

-

-void IncomingLinkLocalSession::setInitialized() {

- initialized = true;

- onSessionStarted();

-}

-

-

-

-}

-#pragma once

-

-#include <boost/shared_ptr.hpp>

-#include <boost/signal.hpp>

-

-#include "Swiften/Session/Session.h"

-#include "Swiften/JID/JID.h"

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

-

-namespace Swift {

- class ProtocolHeader;

- class String;

- class Element;

- class PayloadParserFactoryCollection;

- class PayloadSerializerCollection;

-

- class IncomingLinkLocalSession : public Session {

- public:

- IncomingLinkLocalSession(

- const JID& localJID,

- boost::shared_ptr<Connection> connection,

- PayloadParserFactoryCollection* payloadParserFactories,

- PayloadSerializerCollection* payloadSerializers);

-

- boost::signal<void ()> onSessionStarted;

-

- private:

- void handleElement(boost::shared_ptr<Element>);

- void handleStreamStart(const ProtocolHeader&);

- void setInitialized();

- bool isInitialized() const {

- return initialized;

- }

-

- bool initialized;

- };

-}

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

-

-#include <boost/bind.hpp>

-

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

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

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

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

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

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

-

-namespace Swift {

-

-LinkLocalConnector::LinkLocalConnector(

- const LinkLocalService& service,

- boost::shared_ptr<DNSSDQuerier> querier,

- boost::shared_ptr<Connection> connection) :

- service(service),

- querier(querier),

- connection(connection) {

-}

-

-LinkLocalConnector::~LinkLocalConnector() {

- assert(!resolveQuery);

-}

-

-void LinkLocalConnector::connect() {

- resolveQuery = querier->createResolveHostnameQuery(

- service.getHostname(),

- service.getID().getNetworkInterfaceID());

- resolveQuery->onHostnameResolved.connect(boost::bind(

- &LinkLocalConnector::handleHostnameResolved,

- boost::dynamic_pointer_cast<LinkLocalConnector>(shared_from_this()),

- _1));

- resolveQuery->run();

-}

-

-void LinkLocalConnector::cancel() {

- if (resolveQuery) {

- resolveQuery->finish();

- }

- resolveQuery.reset();

- connection->disconnect();

-}

-

-void LinkLocalConnector::handleHostnameResolved(const boost::optional<HostAddress>& address) {

- resolveQuery->finish();

- resolveQuery.reset();

- if (address) {

- connection->onConnectFinished.connect(

- boost::bind(boost::ref(onConnectFinished), _1));

- connection->connect(HostAddressPort(*address, service.getPort()));

- }

- else {

- onConnectFinished(true);

- }

-}

-

-void LinkLocalConnector::handleConnected(bool error) {

- onConnectFinished(error);

-}

-

-void LinkLocalConnector::queueElement(boost::shared_ptr<Element> element) {

- queuedElements.push_back(element);

-}

-

-

-}

-#pragma once

-

-#include <boost/shared_ptr.hpp>

-#include <boost/signal.hpp>

-#include <boost/enable_shared_from_this.hpp>

-#include <vector>

-

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

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

-

-namespace Swift {

- class ConnectionFactory;

- class HostAddress;

- class Element;

- class PayloadParserFactoryCollection;

- class PayloadSerializerCollection;

- class DNSSDQuerier;

- class DNSSDResolveHostnameQuery;

-

- class LinkLocalConnector : public boost::enable_shared_from_this<LinkLocalConnector> {

- public:

- LinkLocalConnector(

- const LinkLocalService& service,

- boost::shared_ptr<DNSSDQuerier> querier,

- boost::shared_ptr<Connection> connection);

- ~LinkLocalConnector();

-

- const LinkLocalService& getService() const {

- return service;

- }

-

- void connect();

- void cancel();

- void queueElement(boost::shared_ptr<Element> element);

-

- const std::vector<boost::shared_ptr<Element> >& getQueuedElements() const {

- return queuedElements;

- }

-

- boost::shared_ptr<Connection> getConnection() const {

- return connection;

- }

-

- boost::signal<void (bool)> onConnectFinished;

-

- private:

- void handleHostnameResolved(const boost::optional<HostAddress>& address);

- void handleConnected(bool error);

-

- private:

- LinkLocalService service;

- boost::shared_ptr<DNSSDQuerier> querier;

- boost::shared_ptr<DNSSDResolveHostnameQuery> resolveQuery;

- boost::shared_ptr<Connection> connection;

- std::vector<boost::shared_ptr<Element> > queuedElements;

- };

-}

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

-

-namespace Swift {

-

-String LinkLocalService::getDescription() const {

- LinkLocalServiceInfo info = getInfo();

- if (!info.getNick().isEmpty()) {

- return info.getNick();

- }

- else if (!info.getFirstName().isEmpty()) {

- String result = info.getFirstName();

- if (!info.getLastName().isEmpty()) {

- result += " " + info.getLastName();

- }

- return result;

- }

- else if (!info.getLastName().isEmpty()) {

- return info.getLastName();

- }

- return getName();

-}

-

-JID LinkLocalService::getJID() const {

- return JID(getName());

-}

-

-}

-#pragma once

-

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

-#include "Swiften/JID/JID.h"

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

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

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

-

-namespace Swift {

- class LinkLocalService {

- public:

- LinkLocalService(

- const DNSSDServiceID& id,

- const DNSSDResolveServiceQuery::Result& info) :

- id(id),

- info(info) {}

-

- const DNSSDServiceID& getID() const {

- return id;

- }

-

- const String& getName() const {

- return id.getName();

- }

-

- int getPort() const {

- return info.port;

- }

-

- const String& getHostname() const {

- return info.host;

- }

-

- LinkLocalServiceInfo getInfo() const {

- return LinkLocalServiceInfo::createFromTXTRecord(info.info);

- }

-

- String getDescription() const;

-

- JID getJID() const;

-

- private:

- DNSSDServiceID id;

- DNSSDResolveServiceQuery::Result info;

- };

-}

-#include <boost/bind.hpp>

-#include <iostream>

-

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

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

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

-

-namespace Swift {

-

-LinkLocalServiceBrowser::LinkLocalServiceBrowser(boost::shared_ptr<DNSSDQuerier> querier) : querier(querier), haveError(false) {

-}

-

-LinkLocalServiceBrowser::~LinkLocalServiceBrowser() {

- if (isRunning()) {

- std::cerr << "WARNING: LinkLocalServiceBrowser still running on destruction" << std::endl;

- }

-}

-

-

-void LinkLocalServiceBrowser::start() {

- assert(!isRunning());

- haveError = false;

- browseQuery = querier->createBrowseQuery();

- browseQuery->onServiceAdded.connect(

- boost::bind(&LinkLocalServiceBrowser::handleServiceAdded, this, _1));

- browseQuery->onServiceRemoved.connect(

- boost::bind(&LinkLocalServiceBrowser::handleServiceRemoved, this, _1));

- browseQuery->onError.connect(

- boost::bind(&LinkLocalServiceBrowser::handleBrowseError, this));

- browseQuery->startBrowsing();

-}

-

-void LinkLocalServiceBrowser::stop() {

- assert(isRunning());

- if (isRegistered()) {

- unregisterService();

- }

- for (ResolveQueryMap::const_iterator i = resolveQueries.begin(); i != resolveQueries.end(); ++i) {

- i->second->stop();

- }

- resolveQueries.clear();

- services.clear();

- browseQuery->stopBrowsing();

- browseQuery.reset();

- onStopped(haveError);

-}

-

-bool LinkLocalServiceBrowser::isRunning() const {

- return browseQuery;

-}

-

-bool LinkLocalServiceBrowser::hasError() const {

- return haveError;

-}

-

-bool LinkLocalServiceBrowser::isRegistered() const {

- return registerQuery;

-}

-

-void LinkLocalServiceBrowser::registerService(const String& name, int port, const LinkLocalServiceInfo& info) {

- assert(!registerQuery);

- registerQuery = querier->createRegisterQuery(name, port, info.toTXTRecord());

- registerQuery->onRegisterFinished.connect(

- boost::bind(&LinkLocalServiceBrowser::handleRegisterFinished, this, _1));

- registerQuery->registerService();

-}

-

-void LinkLocalServiceBrowser::updateService(const LinkLocalServiceInfo& info) {

- assert(registerQuery);

- registerQuery->updateServiceInfo(info.toTXTRecord());

-}

-

-void LinkLocalServiceBrowser::unregisterService() {

- assert(registerQuery);

- registerQuery->unregisterService();

- registerQuery.reset();

- selfService.reset();

-}

-

-std::vector<LinkLocalService> LinkLocalServiceBrowser::getServices() const {

- std::vector<LinkLocalService> result;

- for (ServiceMap::const_iterator i = services.begin(); i != services.end(); ++i) {

- result.push_back(LinkLocalService(i->first, i->second));

- }

- return result;

-}

-

-void LinkLocalServiceBrowser::handleServiceAdded(const DNSSDServiceID& service) {

- if (selfService && service == *selfService) {

- return;

- }

- boost::shared_ptr<DNSSDResolveServiceQuery> resolveQuery = querier->createResolveServiceQuery(service);

- resolveQuery->onServiceResolved.connect(

- boost::bind(&LinkLocalServiceBrowser::handleServiceResolved, this, service, _1));

- std::pair<ResolveQueryMap::iterator, bool> r = resolveQueries.insert(std::make_pair(service, resolveQuery));

- if (!r.second) {

- r.first->second = resolveQuery;

- }

- resolveQuery->start();

-}

-

-void LinkLocalServiceBrowser::handleServiceRemoved(const DNSSDServiceID& service) {

- ResolveQueryMap::iterator i = resolveQueries.find(service);

- if (i == resolveQueries.end()) {

- // Can happen after an unregister(), when getting the old 'self'

- // service remove notification.

- return;

- }

- i->second->stop();

- resolveQueries.erase(i);

- ServiceMap::iterator j = services.find(service);

- assert(j != services.end());

- LinkLocalService linkLocalService(j->first, j->second);

- services.erase(j);

- onServiceRemoved(linkLocalService);

-}

-

-void LinkLocalServiceBrowser::handleServiceResolved(const DNSSDServiceID& service, const boost::optional<DNSSDResolveServiceQuery::Result>& result) {

- if (result) {

- std::pair<ServiceMap::iterator, bool> r = services.insert(std::make_pair(service, *result));

- if (r.second) {

- onServiceAdded(LinkLocalService(r.first->first, r.first->second));

- }

- else {

- r.first->second = *result;

- onServiceChanged(LinkLocalService(r.first->first, r.first->second));

- }

- }

-}

-

-void LinkLocalServiceBrowser::handleRegisterFinished(const boost::optional<DNSSDServiceID>& result) {

- if (result) {

- selfService = result;

- onServiceRegistered(*result);

- }

- else {

- haveError = true;

- stop();

- }

-}

-

-void LinkLocalServiceBrowser::handleBrowseError() {

- haveError = true;

- stop();

-}

-

-}

-#pragma once

-

-#include <boost/signal.hpp>

-#include <boost/shared_ptr.hpp>

-#include <boost/optional.hpp>

-#include <map>

-#include <vector>

-

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

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

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

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

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

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

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

-

-namespace Swift {

- class LinkLocalServiceBrowser {

- public:

- LinkLocalServiceBrowser(boost::shared_ptr<DNSSDQuerier> querier);

- ~LinkLocalServiceBrowser();

-

- void start();

- void stop();

- bool isRunning() const;

- bool hasError() const;

-

- void registerService(

- const String& name,

- int port,

- const LinkLocalServiceInfo& info = LinkLocalServiceInfo());

- void updateService(

- const LinkLocalServiceInfo& info = LinkLocalServiceInfo());

- void unregisterService();

- bool isRegistered() const;

-

- std::vector<LinkLocalService> getServices() const;

-

- // FIXME: Ugly that we need this

- boost::shared_ptr<DNSSDQuerier> getQuerier() const {

- return querier;

- }

-

- boost::signal<void (const LinkLocalService&)> onServiceAdded;

- boost::signal<void (const LinkLocalService&)> onServiceChanged;

- boost::signal<void (const LinkLocalService&)> onServiceRemoved;

- boost::signal<void (const DNSSDServiceID&)> onServiceRegistered;

- boost::signal<void (bool)> onStopped;

-

- private:

- void handleServiceAdded(const DNSSDServiceID&);

- void handleServiceRemoved(const DNSSDServiceID&);

- void handleServiceResolved(const DNSSDServiceID& service, const boost::optional<DNSSDResolveServiceQuery::Result>& result);

- void handleRegisterFinished(const boost::optional<DNSSDServiceID>&);

- void handleBrowseError();

-

- private:

- boost::shared_ptr<DNSSDQuerier> querier;

- boost::optional<DNSSDServiceID> selfService;

- boost::shared_ptr<DNSSDBrowseQuery> browseQuery;

- boost::shared_ptr<DNSSDRegisterQuery> registerQuery;

- typedef std::map<DNSSDServiceID, boost::shared_ptr<DNSSDResolveServiceQuery> > ResolveQueryMap;

- ResolveQueryMap resolveQueries;

- typedef std::map<DNSSDServiceID, DNSSDResolveServiceQuery::Result> ServiceMap;

- ServiceMap services;

- bool haveError;

- };

-}

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

-

-#include <boost/lexical_cast.hpp>

-

-namespace Swift {

-

-ByteArray LinkLocalServiceInfo::toTXTRecord() const {

- ByteArray result(getEncoded("txtvers=1"));

- if (!firstName.isEmpty()) {

- result += getEncoded("1st=" + firstName);

- }

- if (!lastName.isEmpty()) {

- result += getEncoded("last=" + lastName);

- }

- if (!email.isEmpty()) {

- result += getEncoded("email=" + email);

- }

- if (jid.isValid()) {

- result += getEncoded("jid=" + jid.toString());

- }

- if (!message.isEmpty()) {

- result += getEncoded("msg=" + message);

- }

- if (!nick.isEmpty()) {

- result += getEncoded("nick=" + nick);

- }

- if (port) {

- result += getEncoded("port.p2pj=" + String(boost::lexical_cast<std::string>(*port)));

- }

-

- switch (status) {

- case Available: result += getEncoded("status=avail"); break;

- case Away: result += getEncoded("status=away"); break;

- case DND: result += getEncoded("status=dnd"); break;

- }

-

- return result;

-}

-

-ByteArray LinkLocalServiceInfo::getEncoded(const String& s) {

- ByteArray sizeByte;

- sizeByte.resize(1);

- assert(s.getLength() < 256);

- sizeByte[0] = s.getUTF8Size();

- return sizeByte + ByteArray(s);

-}

-

-LinkLocalServiceInfo LinkLocalServiceInfo::createFromTXTRecord(const ByteArray& record) {

- LinkLocalServiceInfo info;

- size_t i = 0;

- while (i < record.getSize()) {

- std::pair<String,String> entry = readEntry(record, &i);

- if (entry.first.isEmpty()) {

- break;

- }

- else if (entry.first == "1st") {

- info.setFirstName(entry.second);

- }

- else if (entry.first == "last") {

- info.setLastName(entry.second);

- }

- else if (entry.first == "email") {

- info.setEMail(entry.second);

- }

- else if (entry.first == "jid") {

- info.setJID(JID(entry.second));

- }

- else if (entry.first == "msg") {

- info.setMessage(entry.second);

- }

- else if (entry.first == "nick") {

- info.setNick(entry.second);

- }

- else if (entry.first == "port.p2pj") {

- info.setPort(boost::lexical_cast<int>(entry.second));

- }

- else if (entry.first == "status") {

- if (entry.second == "away") {

- info.setStatus(Away);

- }

- else if (entry.second == "dnd") {

- info.setStatus(DND);

- }

- }

- }

- return info;

-}

-

-std::pair<String,String> LinkLocalServiceInfo::readEntry(const ByteArray& record, size_t* index) {

- size_t& i = *index;

- String key;

- String value;

-

- size_t entryEnd = i + 1 + record[i];

- ++i;

- bool inKey = true;

- while (i < entryEnd && i < record.getSize()) {

- if (inKey) {

- if (record[i] == '=') {

- inKey = false;

- }

- else {

- key += record[i];

- }

- }

- else {

- value += record[i];

- }

- ++i;

- }

- return std::make_pair(key, value);

-}

-

-}

-#pragma once

-

-#include <boost/optional.hpp>

-

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

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

-#include "Swiften/JID/JID.h"

-

-namespace Swift {

-

- class LinkLocalServiceInfo {

- public:

- enum Status { Available, Away, DND };

-

- LinkLocalServiceInfo() : status(Available) {}

-

- const String& getFirstName() const { return firstName; }

- void setFirstName(const String& f) { firstName = f; }

-

- const String& getLastName() const { return lastName; }

- void setLastName(const String& l) { lastName = l; }

-

- const String& getEMail() const { return email; }

- void setEMail(const String& e) { email = e; }

-

- const JID& getJID() const { return jid; }

- void setJID(const JID& j) { jid = j; }

-

- const String& getMessage() const { return message; }

- void setMessage(const String& m) { message = m; }

-

- const String& getNick() const { return nick; }

- void setNick(const String& n) { nick = n; }

-

- Status getStatus() const { return status; }

- void setStatus(Status s) { status = s; }

-

- boost::optional<int> getPort() const { return port; }

- void setPort(int p) { port = p; }

-

- ByteArray toTXTRecord() const;

-

- static LinkLocalServiceInfo createFromTXTRecord(const ByteArray& record);

-

- private:

- static ByteArray getEncoded(const String&);

- static std::pair<String,String> readEntry(const ByteArray&, size_t*);

-

- private:

- String firstName;

- String lastName;

- String email;

- JID jid;

- String message;

- String nick;

- Status status;

- boost::optional<int> port;

- };

-}

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

-

-#include <boost/bind.hpp>

-

-#include "Swiften/StreamStack/XMPPLayer.h"

-#include "Swiften/Elements/ProtocolHeader.h"

-#include "Swiften/Elements/StreamFeatures.h"

-#include "Swiften/Elements/IQ.h"

-

-namespace Swift {

-

-OutgoingLinkLocalSession::OutgoingLinkLocalSession(

- const JID& localJID,

- const JID& remoteJID,

- boost::shared_ptr<Connection> connection,

- PayloadParserFactoryCollection* payloadParserFactories,

- PayloadSerializerCollection* payloadSerializers) :

- Session(connection, payloadParserFactories, payloadSerializers) {

- setLocalJID(localJID);

- setRemoteJID(remoteJID);

-}

-

-void OutgoingLinkLocalSession::handleSessionStarted() {

- ProtocolHeader header;

- header.setFrom(getLocalJID());

- getXMPPLayer()->writeHeader(header);

-}

-

-void OutgoingLinkLocalSession::handleStreamStart(const ProtocolHeader&) {

- foreach(const boost::shared_ptr<Element>& stanza, queuedElements_) {

- sendElement(stanza);

- }

- queuedElements_.clear();

-}

-

-void OutgoingLinkLocalSession::handleElement(boost::shared_ptr<Element> element) {

- onElementReceived(element);

-}

-

-void OutgoingLinkLocalSession::queueElement(boost::shared_ptr<Element> element) {

- queuedElements_.push_back(element);

-}

-

-

-}

-#pragma once

-

-#include <boost/shared_ptr.hpp>

-#include <boost/signal.hpp>

-#include <boost/enable_shared_from_this.hpp>

-#include <vector>

-

-#include "Swiften/Session/Session.h"

-#include "Swiften/JID/JID.h"

-

-namespace Swift {

- class ConnectionFactory;

- class String;

- class Element;

- class PayloadParserFactoryCollection;

- class PayloadSerializerCollection;

-

- class OutgoingLinkLocalSession : public Session {

- public:

- OutgoingLinkLocalSession(

- const JID& localJID,

- const JID& remoteJID,

- boost::shared_ptr<Connection> connection,

- PayloadParserFactoryCollection* payloadParserFactories,

- PayloadSerializerCollection* payloadSerializers);

-

- void queueElement(boost::shared_ptr<Element> element);

-

- private:

- void handleSessionStarted();

- void handleElement(boost::shared_ptr<Element>);

- void handleStreamStart(const ProtocolHeader&);

-

- private:

- std::vector<boost::shared_ptr<Element> > queuedElements_;

- };

-}

-Import("swiften_env")

-

-myenv = swiften_env.Clone()

-myenv.MergeFlags(swiften_env.get("BONJOUR_FLAGS", ""))

-

-sources = [

- "DNSSD/DNSSDBrowseQuery.cpp",

- "DNSSD/DNSSDQuerier.cpp",

- "DNSSD/DNSSDRegisterQuery.cpp",

- "DNSSD/DNSSDResolveHostnameQuery.cpp",

- "DNSSD/DNSSDResolveServiceQuery.cpp",

- "DNSSD/DNSSDServiceID.cpp",

- "DNSSD/Fake/FakeDNSSDQuerier.cpp",

- "DNSSD/Fake/FakeDNSSDQuery.cpp",

- "DNSSD/PlatformDNSSDQuerierFactory.cpp",

- "IncomingLinkLocalSession.cpp",

- "LinkLocalConnector.cpp",

- "LinkLocalService.cpp",

- "LinkLocalServiceBrowser.cpp",

- "LinkLocalServiceInfo.cpp",

- "OutgoingLinkLocalSession.cpp",

- ]

-

-if myenv.get("HAVE_BONJOUR", 0) :

- myenv.Append(CPPDEFINES = "HAVE_BONJOUR")

- sources += [

- "DNSSD/Bonjour/BonjourQuerier.cpp",

- "DNSSD/Bonjour/BonjourQuery.cpp",

- ]

-elif myenv.get("HAVE_AVAHI", 0) :

- sources += [

- "DNSSD/Avahi/AvahiQuerier.cpp",

- "DNSSD/Avahi/AvahiQuery.cpp"

- ]

-

-objects = myenv.StaticObject(sources)

-swiften_env.Append(SWIFTEN_OBJECTS = [objects])

-#include <cppunit/extensions/HelperMacros.h>

-#include <cppunit/extensions/TestFactoryRegistry.h>

-

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

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

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

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

-#include "Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuerier.h"

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

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

-

-using namespace Swift;

-

-class LinkLocalConnectorTest : public CppUnit::TestFixture {

- CPPUNIT_TEST_SUITE(LinkLocalConnectorTest);

- CPPUNIT_TEST(testConnect);

- CPPUNIT_TEST(testConnect_UnableToResolve);

- CPPUNIT_TEST(testConnect_UnableToConnect);

- CPPUNIT_TEST(testCancel_DuringResolve);

- CPPUNIT_TEST(testCancel_DuringConnect);

- CPPUNIT_TEST_SUITE_END();

-

- public:

- void setUp() {

- eventLoop = new DummyEventLoop();

- querier = boost::shared_ptr<FakeDNSSDQuerier>(

- new FakeDNSSDQuerier("rabbithole.local"));

- connection = boost::shared_ptr<FakeConnection>(new FakeConnection());

- connectFinished = false;

- }

-

- void tearDown() {

- delete eventLoop;

- }

-

- void testConnect() {

- boost::shared_ptr<LinkLocalConnector>

- testling(createConnector("rabbithole.local", 1234));

- querier->setAddress("rabbithole.local", HostAddress("192.168.1.1"));

-

- testling->connect();

- eventLoop->processEvents();

-

- CPPUNIT_ASSERT(connectFinished);

- CPPUNIT_ASSERT(!connectError);

- CPPUNIT_ASSERT(connection->connectedTo);

- CPPUNIT_ASSERT_EQUAL(String(connection->connectedTo->getAddress().toString()), String("192.168.1.1"));

- CPPUNIT_ASSERT_EQUAL(connection->connectedTo->getPort(), 1234);

- }

-

- void testConnect_UnableToResolve() {

- boost::shared_ptr<LinkLocalConnector>

- testling(createConnector("rabbithole.local", 1234));

- querier->setAddress("rabbithole.local", boost::optional<HostAddress>());

-

- testling->connect();

- eventLoop->processEvents();

-

- CPPUNIT_ASSERT(connectFinished);

- CPPUNIT_ASSERT(connectError);

- CPPUNIT_ASSERT(!connection->connectedTo);

- }

-

- void testConnect_UnableToConnect() {

- boost::shared_ptr<LinkLocalConnector>

- testling(createConnector("rabbithole.local", 1234));

- querier->setAddress("rabbithole.local", HostAddress("192.168.1.1"));

- connection->setError(Connection::ReadError);

-

- testling->connect();

- eventLoop->processEvents();

-

- CPPUNIT_ASSERT(connectFinished);

- CPPUNIT_ASSERT(connectError);

- CPPUNIT_ASSERT(!connection->connectedTo);

- }

-

- void testCancel_DuringResolve() {

- boost::shared_ptr<LinkLocalConnector>

- testling(createConnector("rabbithole.local", 1234));

- testling->connect();

- eventLoop->processEvents();

- CPPUNIT_ASSERT(!connectFinished);

-

- testling->cancel();

- eventLoop->processEvents();

- querier->setAddress("rabbithole.local", HostAddress("192.168.1.1"));

- eventLoop->processEvents();

-

- CPPUNIT_ASSERT(FakeConnection::Disconnected == connection->state);

- }

-

- void testCancel_DuringConnect() {

- boost::shared_ptr<LinkLocalConnector>

- testling(createConnector("rabbithole.local", 1234));

- querier->setAddress("rabbithole.local", HostAddress("192.168.1.1"));

- connection->setDelayConnect();

- testling->connect();

- eventLoop->processEvents();

- CPPUNIT_ASSERT(FakeConnection::Connecting == connection->state);

-

- testling->cancel();

- eventLoop->processEvents();

-

- CPPUNIT_ASSERT(FakeConnection::Disconnected == connection->state);

- }

-

- private:

- boost::shared_ptr<LinkLocalConnector> createConnector(const String& hostname, int port) {

- LinkLocalService service(

- DNSSDServiceID("myname", "local."),

- DNSSDResolveServiceQuery::Result(

- "myname._presence._tcp.local", hostname, port,

- LinkLocalServiceInfo().toTXTRecord()));

- boost::shared_ptr<LinkLocalConnector> result(

- new LinkLocalConnector(service, querier, connection));

- result->onConnectFinished.connect(

- boost::bind(&LinkLocalConnectorTest::handleConnected, this, _1));

- return result;

- }

-

- void handleConnected(bool e) {

- connectFinished = true;

- connectError = e;

- }

-

- private:

- DummyEventLoop* eventLoop;

- boost::shared_ptr<FakeDNSSDQuerier> querier;

- boost::shared_ptr<FakeConnection> connection;

- bool connectFinished;

- bool connectError;

-};

-

-CPPUNIT_TEST_SUITE_REGISTRATION(LinkLocalConnectorTest);

-#include <cppunit/extensions/HelperMacros.h>

-#include <cppunit/extensions/TestFactoryRegistry.h>

-#include <boost/bind.hpp>

-#include <map>

-

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

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

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

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

-#include "Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuerier.h"

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

-

-using namespace Swift;

-

-class LinkLocalServiceBrowserTest : public CppUnit::TestFixture {

- CPPUNIT_TEST_SUITE(LinkLocalServiceBrowserTest);

- CPPUNIT_TEST(testConstructor);

- CPPUNIT_TEST(testStart);

- CPPUNIT_TEST(testServiceAdded);

- CPPUNIT_TEST(testServiceAdded_NoServiceInfo);

- CPPUNIT_TEST(testServiceAdded_RegisteredService);

- CPPUNIT_TEST(testServiceAdded_UnregisteredService);

- CPPUNIT_TEST(testServiceChanged);

- CPPUNIT_TEST(testServiceRemoved);

- CPPUNIT_TEST(testServiceRemoved_UnregisteredService);

- CPPUNIT_TEST(testError_BrowseErrorAfterStart);

- CPPUNIT_TEST(testError_BrowseErrorAfterResolve);

- CPPUNIT_TEST(testRegisterService);

- CPPUNIT_TEST(testRegisterService_Error);

- CPPUNIT_TEST(testRegisterService_Reregister);

- CPPUNIT_TEST(testUpdateService);

- CPPUNIT_TEST_SUITE_END();

-

- public:

- LinkLocalServiceBrowserTest() {}

-

- void setUp() {

- eventLoop = new DummyEventLoop();

- querier = boost::shared_ptr<FakeDNSSDQuerier>(new FakeDNSSDQuerier("wonderland.lit"));

- aliceServiceID = new DNSSDServiceID("alice", "wonderland.lit");

- aliceServiceInfo = new DNSSDResolveServiceQuery::Result("_presence._tcp.wonderland.lit", "xmpp.wonderland.lit", 1234, LinkLocalServiceInfo().toTXTRecord());

- testServiceID = new DNSSDServiceID("foo", "bar.local");

- testServiceInfo = new DNSSDResolveServiceQuery::Result("_presence._tcp.bar.local", "xmpp.bar.local", 1234, LinkLocalServiceInfo().toTXTRecord());

- testServiceInfo2 = new DNSSDResolveServiceQuery::Result("_presence.tcp.bar.local", "xmpp.foo.local", 2345, LinkLocalServiceInfo().toTXTRecord());

- errorStopReceived = false;

- normalStopReceived = false;

- }

-

- void tearDown() {

- addedServices.clear();

- removedServices.clear();

- changedServices.clear();

-

- delete aliceServiceID;

- delete aliceServiceInfo;

- delete testServiceInfo2;

- delete testServiceInfo;

- delete testServiceID;

- delete eventLoop;

- }

-

- void testConstructor() {

- boost::shared_ptr<LinkLocalServiceBrowser> testling = createTestling();

-

- CPPUNIT_ASSERT(!testling->isRunning());

- CPPUNIT_ASSERT(!testling->hasError());

- }

-

- void testStart() {

- boost::shared_ptr<LinkLocalServiceBrowser> testling = createTestling();

- testling->start();

-

- CPPUNIT_ASSERT(testling->isRunning());

- CPPUNIT_ASSERT(!testling->hasError());

-

- testling->stop();

- }

-

- void testServiceAdded() {

- boost::shared_ptr<LinkLocalServiceBrowser> testling = createTestling();

- testling->start();

- eventLoop->processEvents();

-

- querier->setServiceInfo(*testServiceID,*testServiceInfo);

- querier->addService(*testServiceID);

- eventLoop->processEvents();

-

- CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(addedServices.size()));

- CPPUNIT_ASSERT(addedServices[0].getID() == *testServiceID);

- CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(changedServices.size()));

- CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(removedServices.size()));

- std::vector<LinkLocalService> services = testling->getServices();

- CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(services.size()));

- CPPUNIT_ASSERT(*testServiceID == services[0].getID());

- CPPUNIT_ASSERT(testServiceInfo->port == services[0].getPort());

- CPPUNIT_ASSERT(testServiceInfo->host == services[0].getHostname());

-

- testling->stop();

- }

-

- void testServiceAdded_NoServiceInfo() {

- boost::shared_ptr<LinkLocalServiceBrowser> testling = createTestling();

- testling->start();

- eventLoop->processEvents();

-

- querier->addService(*testServiceID);

- eventLoop->processEvents();

-

- CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(addedServices.size()));

- CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(testling->getServices().size()));

-

- testling->stop();

- }

-

- void testServiceAdded_RegisteredService() {

- boost::shared_ptr<LinkLocalServiceBrowser> testling = createTestling();

- testling->start();

- eventLoop->processEvents();

-

- testling->registerService("alice", 1234, LinkLocalServiceInfo());

- eventLoop->processEvents();

- querier->setServiceInfo(*aliceServiceID, *aliceServiceInfo);

- querier->addService(*aliceServiceID);

- eventLoop->processEvents();

-

- CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(addedServices.size()));

- CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(testling->getServices().size()));

-

- testling->stop();

- }

-

- void testServiceAdded_UnregisteredService() {

- boost::shared_ptr<LinkLocalServiceBrowser> testling = createTestling();

- testling->start();

- eventLoop->processEvents();

- testling->registerService("alice", 1234, LinkLocalServiceInfo());

- eventLoop->processEvents();

- testling->unregisterService();

- eventLoop->processEvents();

-

- querier->setServiceInfo(*aliceServiceID, *aliceServiceInfo);

- querier->addService(*aliceServiceID);

- eventLoop->processEvents();

-

- CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(addedServices.size()));

- CPPUNIT_ASSERT(addedServices[0].getID() == *aliceServiceID);

- CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(changedServices.size()));

- CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(removedServices.size()));

- std::vector<LinkLocalService> services = testling->getServices();

- CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(services.size()));

- CPPUNIT_ASSERT(*aliceServiceID == services[0].getID());

- CPPUNIT_ASSERT(aliceServiceInfo->port == services[0].getPort());

- CPPUNIT_ASSERT(aliceServiceInfo->host == services[0].getHostname());

-

- testling->stop();

- }

-

- void testServiceRemoved_UnregisteredService() {

- boost::shared_ptr<LinkLocalServiceBrowser> testling = createTestling();

- testling->start();

- eventLoop->processEvents();

- testling->registerService("alice", 1234, LinkLocalServiceInfo());

- eventLoop->processEvents();

- testling->unregisterService();

- eventLoop->processEvents();

-

- querier->removeService(*aliceServiceID);

- eventLoop->processEvents();

-

- CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(removedServices.size()));

-

- testling->stop();

- }

-

- void testServiceChanged() {

- boost::shared_ptr<LinkLocalServiceBrowser> testling = createTestling();

- testling->start();

- querier->setServiceInfo(*testServiceID,*testServiceInfo);

- querier->addService(*testServiceID);

- eventLoop->processEvents();

-

- querier->setServiceInfo(*testServiceID,*testServiceInfo2);

- eventLoop->processEvents();

-

- CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(addedServices.size()));

- CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(changedServices.size()));

- CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(removedServices.size()));

- CPPUNIT_ASSERT(changedServices[0].getID() == *testServiceID);

- std::vector<LinkLocalService> services = testling->getServices();

- CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(services.size()));

- CPPUNIT_ASSERT(*testServiceID == services[0].getID());

- CPPUNIT_ASSERT(testServiceInfo2->port == services[0].getPort());

- CPPUNIT_ASSERT(testServiceInfo2->host == services[0].getHostname());

-

- testling->stop();

- }

-

- void testServiceRemoved() {

- boost::shared_ptr<LinkLocalServiceBrowser> testling = createTestling();

- testling->start();

- querier->setServiceInfo(*testServiceID,*testServiceInfo);

- querier->addService(*testServiceID);

- eventLoop->processEvents();

-

- querier->removeService(*testServiceID);

- eventLoop->processEvents();

- querier->setServiceInfo(*testServiceID,*testServiceInfo2);

- eventLoop->processEvents();

-

- CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(addedServices.size()));

- CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(changedServices.size()));

- CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(removedServices.size()));

- CPPUNIT_ASSERT(removedServices[0].getID() == *testServiceID);

- CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(testling->getServices().size()));

-

- testling->stop();

- }

-

- void testError_BrowseErrorAfterStart() {

- boost::shared_ptr<LinkLocalServiceBrowser> testling = createTestling();

- testling->start();

-

- querier->setBrowseError();

- eventLoop->processEvents();

-

- CPPUNIT_ASSERT(!testling->isRunning());

- CPPUNIT_ASSERT(testling->hasError());

- CPPUNIT_ASSERT(errorStopReceived);

- }

-

- void testError_BrowseErrorAfterResolve() {

- boost::shared_ptr<LinkLocalServiceBrowser> testling = createTestling();

- testling->start();

- querier->setServiceInfo(*testServiceID,*testServiceInfo);

- querier->addService(*testServiceID);

- eventLoop->processEvents();

-

- querier->setBrowseError();

- eventLoop->processEvents();

- querier->setServiceInfo(*testServiceID,*testServiceInfo2);

- eventLoop->processEvents();

-

- CPPUNIT_ASSERT(!testling->isRunning());

- CPPUNIT_ASSERT(testling->hasError());

- CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(testling->getServices().size()));

- CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(changedServices.size()));

- CPPUNIT_ASSERT(errorStopReceived);

- }

-

- void testRegisterService() {

- boost::shared_ptr<LinkLocalServiceBrowser> testling = createTestling();

- testling->start();

- eventLoop->processEvents();

-

- LinkLocalServiceInfo info;

- info.setFirstName("Foo");

- testling->registerService("foo@bar", 1234, info);

- eventLoop->processEvents();

-

- CPPUNIT_ASSERT(querier->isServiceRegistered("foo@bar", 1234, info.toTXTRecord()));

- CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(registeredServices.size()));

- CPPUNIT_ASSERT(registeredServices[0] == DNSSDServiceID("foo@bar", "wonderland.lit"));

- testling->stop();

- }

-

- void testRegisterService_Error() {

- boost::shared_ptr<LinkLocalServiceBrowser> testling = createTestling();

- testling->start();

- LinkLocalServiceInfo info;

- testling->registerService("foo@bar", 1234, info);

- eventLoop->processEvents();

-

- querier->setRegisterError();

- eventLoop->processEvents();

-

- CPPUNIT_ASSERT(!testling->isRunning());

- CPPUNIT_ASSERT(testling->hasError());

- CPPUNIT_ASSERT(errorStopReceived);

- CPPUNIT_ASSERT(!querier->isServiceRegistered("foo@bar", 1234, info.toTXTRecord()));

- }

-

- void testRegisterService_Reregister() {

- boost::shared_ptr<LinkLocalServiceBrowser> testling = createTestling();

- testling->start();

- eventLoop->processEvents();

- LinkLocalServiceInfo info;

- info.setFirstName("Foo");

- testling->registerService("foo@bar", 1234, info);

- eventLoop->processEvents();

- testling->unregisterService();

- eventLoop->processEvents();

-

- info.setFirstName("Bar");

- testling->registerService("bar@baz", 3456, info);

- eventLoop->processEvents();

-

- CPPUNIT_ASSERT(querier->isServiceRegistered("bar@baz", 3456, info.toTXTRecord()));

-

- testling->stop();

- }

-

- void testUpdateService() {

- boost::shared_ptr<LinkLocalServiceBrowser> testling = createTestling();

- testling->start();

- eventLoop->processEvents();

-

- LinkLocalServiceInfo info;

- info.setFirstName("Foo");

- testling->registerService("foo@bar", 1234, info);

- eventLoop->processEvents();

- info.setFirstName("Bar");

- testling->updateService(info);

-

- CPPUNIT_ASSERT(querier->isServiceRegistered("foo@bar", 1234, info.toTXTRecord()));

-

- testling->stop();

- }

-

- private:

- boost::shared_ptr<LinkLocalServiceBrowser> createTestling() {

- boost::shared_ptr<LinkLocalServiceBrowser> testling(

- new LinkLocalServiceBrowser(querier));

- testling->onServiceAdded.connect(boost::bind(

- &LinkLocalServiceBrowserTest::handleServiceAdded, this, _1));

- testling->onServiceChanged.connect(boost::bind(

- &LinkLocalServiceBrowserTest::handleServiceChanged, this, _1));

- testling->onServiceRemoved.connect(boost::bind(

- &LinkLocalServiceBrowserTest::handleServiceRemoved, this, _1));

- testling->onServiceRegistered.connect(boost::bind(

- &LinkLocalServiceBrowserTest::handleServiceRegistered, this, _1));

- testling->onStopped.connect(boost::bind(

- &LinkLocalServiceBrowserTest::handleStopped, this, _1));

- return testling;

- }

-

- void handleServiceAdded(const LinkLocalService& service) {

- addedServices.push_back(service);

- }

-

- void handleServiceRemoved(const LinkLocalService& service) {

- removedServices.push_back(service);

- }

-

- void handleServiceChanged(const LinkLocalService& service) {

- changedServices.push_back(service);

- }

-

- void handleServiceRegistered(const DNSSDServiceID& service) {

- registeredServices.push_back(service);

- }

-

- void handleStopped(bool error) {

- CPPUNIT_ASSERT(!errorStopReceived);

- CPPUNIT_ASSERT(!normalStopReceived);

- if (error) {

- errorStopReceived = true;

- }

- else {

- normalStopReceived = true;

- }

- }

-

- private:

- DummyEventLoop* eventLoop;

- boost::shared_ptr<FakeDNSSDQuerier> querier;

- std::vector<LinkLocalService> addedServices;

- std::vector<LinkLocalService> changedServices;

- std::vector<LinkLocalService> removedServices;

- std::vector<DNSSDServiceID> registeredServices;

- DNSSDServiceID* aliceServiceID;

- DNSSDResolveServiceQuery::Result* aliceServiceInfo;

- DNSSDServiceID* testServiceID;

- DNSSDResolveServiceQuery::Result* testServiceInfo;

- DNSSDResolveServiceQuery::Result* testServiceInfo2;

- bool errorStopReceived;

- bool normalStopReceived;

-};

-

-CPPUNIT_TEST_SUITE_REGISTRATION(LinkLocalServiceBrowserTest);

-#include <cppunit/extensions/HelperMacros.h>

-#include <cppunit/extensions/TestFactoryRegistry.h>

-

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

-

-using namespace Swift;

-

-class LinkLocalServiceInfoTest : public CppUnit::TestFixture {

- CPPUNIT_TEST_SUITE(LinkLocalServiceInfoTest);

- CPPUNIT_TEST(testGetTXTRecord);

- CPPUNIT_TEST(testCreateFromTXTRecord);

- CPPUNIT_TEST(testCreateFromTXTRecord_InvalidSize);

- CPPUNIT_TEST(testGetTXTRecordCreateFromTXTRecord_RoundTrip);

- CPPUNIT_TEST_SUITE_END();

-

- public:

- void testGetTXTRecord() {

- LinkLocalServiceInfo info;

- info.setFirstName("Remko");

- info.setLastName("Tron\xc3\xe7on");

- info.setStatus(LinkLocalServiceInfo::Away);

-

- CPPUNIT_ASSERT_EQUAL(ByteArray("\x09txtvers=1\x09" + String("1st=Remko\x0dlast=Tron\xc3\xe7on\x0bstatus=away")), info.toTXTRecord());

- }

-

- void testCreateFromTXTRecord() {

- LinkLocalServiceInfo info = LinkLocalServiceInfo::createFromTXTRecord(ByteArray("\x09txtvers=1\x09" + String("1st=Remko\x0dlast=Tron\xc3\xe7on\x0bstatus=away")));

-

- CPPUNIT_ASSERT_EQUAL(String("Remko"), info.getFirstName());

- CPPUNIT_ASSERT_EQUAL(String("Tron\xc3\xe7on"), info.getLastName());

- CPPUNIT_ASSERT_EQUAL(LinkLocalServiceInfo::Away, info.getStatus());

- }

-

- void testCreateFromTXTRecord_InvalidSize() {

- LinkLocalServiceInfo info = LinkLocalServiceInfo::createFromTXTRecord(ByteArray("\x10last=a"));

-

- CPPUNIT_ASSERT_EQUAL(String("a"), info.getLastName());

- }

-

- void testGetTXTRecordCreateFromTXTRecord_RoundTrip() {

- LinkLocalServiceInfo info;

- info.setFirstName("Remko");

- info.setLastName("Tron\xc3\xe7on");

- info.setEMail("remko-email@swift.im");

- info.setJID(JID("remko-jid@swift.im"));

- info.setMessage("I'm busy");

- info.setNick("el-tramo");

- info.setStatus(LinkLocalServiceInfo::DND);

- info.setPort(1234);

-

- LinkLocalServiceInfo info2 = LinkLocalServiceInfo::createFromTXTRecord(info.toTXTRecord());

- CPPUNIT_ASSERT_EQUAL(info.getFirstName(), info2.getFirstName());

- CPPUNIT_ASSERT_EQUAL(info.getLastName(), info2.getLastName());

- CPPUNIT_ASSERT_EQUAL(info.getEMail(), info2.getEMail());

- CPPUNIT_ASSERT_EQUAL(info.getJID(), info2.getJID());

- CPPUNIT_ASSERT_EQUAL(info.getMessage(), info2.getMessage());

- CPPUNIT_ASSERT_EQUAL(info.getNick(), info2.getNick());

- CPPUNIT_ASSERT(info.getStatus() == info2.getStatus());

- CPPUNIT_ASSERT(info.getPort() == info2.getPort());

- }

-};

-

-CPPUNIT_TEST_SUITE_REGISTRATION(LinkLocalServiceInfoTest);

-#include <cppunit/extensions/HelperMacros.h>

-#include <cppunit/extensions/TestFactoryRegistry.h>

-

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

-

-using namespace Swift;

-

-class LinkLocalServiceTest : public CppUnit::TestFixture {

- CPPUNIT_TEST_SUITE(LinkLocalServiceTest);

- CPPUNIT_TEST(testGetDescription_WithNick);

- CPPUNIT_TEST(testGetDescription_WithFirstName);

- CPPUNIT_TEST(testGetDescription_WithLastName);

- CPPUNIT_TEST(testGetDescription_WithFirstAndLastName);

- CPPUNIT_TEST(testGetDescription_NoInfo);

- CPPUNIT_TEST_SUITE_END();

-

- public:

- void testGetDescription_WithNick() {

- LinkLocalService testling = createService("alice@wonderland", "Alice", "Alice In", "Wonderland");

-

- CPPUNIT_ASSERT_EQUAL(String("Alice"), testling.getDescription());

- }

-

- void testGetDescription_WithFirstName() {

- LinkLocalService testling = createService("alice@wonderland", "", "Alice In");

-

- CPPUNIT_ASSERT_EQUAL(String("Alice In"), testling.getDescription());

- }

-

- void testGetDescription_WithLastName() {

- LinkLocalService testling = createService("alice@wonderland", "", "", "Wonderland");

-

- CPPUNIT_ASSERT_EQUAL(String("Wonderland"), testling.getDescription());

- }

-

- void testGetDescription_WithFirstAndLastName() {

- LinkLocalService testling = createService("alice@wonderland", "", "Alice In", "Wonderland");

-

- CPPUNIT_ASSERT_EQUAL(String("Alice In Wonderland"), testling.getDescription());

- }

-

- void testGetDescription_NoInfo() {

- LinkLocalService testling = createService("alice@wonderland");

-

- CPPUNIT_ASSERT_EQUAL(String("alice@wonderland"), testling.getDescription());

- }

-

- private:

- LinkLocalService createService(const String& name, const String& nickName = String(), const String& firstName = String(), const String& lastName = String()) {

- DNSSDServiceID service(name, "local.");

- LinkLocalServiceInfo info;

- info.setFirstName(firstName);

- info.setLastName(lastName);

- info.setNick(nickName);

- return LinkLocalService(service,

- DNSSDResolveServiceQuery::Result(

- name + "._presence._tcp.local", "rabbithole.local", 1234,

- info.toTXTRecord()));

- }

-};

-

-CPPUNIT_TEST_SUITE_REGISTRATION(LinkLocalServiceTest);