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

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

namespace Swift {

class AvahiQuerier;

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

if (!browser) {

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

}

avahi_threaded_poll_unlock(querier->getThreadedPoll());

}

switch (event) {

case AVAHI_BROWSER_FAILURE:

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

break;

case AVAHI_BROWSER_NEW: {

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

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

break;

}

case AVAHI_BROWSER_REMOVE: {

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

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

break;

}

case AVAHI_BROWSER_ALL_FOR_NOW:

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

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

#include "Swiften/Base/ByteArray.h"

namespace Swift {

class AvahiQuerier;

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

if (!group) {

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

}

}

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

if (result < 0) {

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

}

result = avahi_entry_group_commit(group);

if (result < 0) {

switch (state) {

case AVAHI_ENTRY_GROUP_ESTABLISHED :

// Domain is a hack!

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

break;

case AVAHI_ENTRY_GROUP_COLLISION : {

if (result != kDNSServiceErr_NoError) {

sdRef = NULL;

}*/

}

}

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

if (errorCode != kDNSServiceErr_NoError) {

}

else {

}

#include "Swiften/Base/String.h"

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

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

#include "Swiften/Network/HostAddress.h"

#include <netinet/in.h>

}

void run() {

}

void finish() {

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

#include "Swiften/LinkLocal/LinkLocalServiceInfo.h"

#include "Swiften/Base/ByteArray.h"

namespace Swift {

class AvahiQuerier;

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

if (!resolver) {

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

}

avahi_threaded_poll_unlock(querier->getThreadedPoll());

}

switch(event) {

case AVAHI_RESOLVER_FAILURE:

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

break;

case AVAHI_RESOLVER_FOUND: {

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

// FIXME: Probably not accurate

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

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

boost::bind(

boost::ref(onServiceResolved),

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

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

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

namespace Swift {

class BonjourQuerier;

class BonjourBrowseQuery : public DNSSDBrowseQuery, public BonjourQuery {

public:

DNSServiceErrorType result = DNSServiceBrowse(

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

&BonjourBrowseQuery::handleServiceDiscoveredStatic, this);

void startBrowsing() {

if (!sdRef) {

}

else {

run();

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

if (errorCode != kDNSServiceErr_NoError) {

}

else {

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

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

if (flags & kDNSServiceFlagsAdd) {

}

else {

}

}

}

namespace Swift {

int fds[2];

int result = pipe(fds);

assert(result == 0);

}

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

}

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

}

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

}

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

}

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

public DNSSDQuerier,

public boost::enable_shared_from_this<BonjourQuerier> {

public:

~BonjourQuerier();

boost::shared_ptr<DNSSDBrowseQuery> createBrowseQuery();

void run();

private:

bool stopRequested;

boost::thread* thread;

boost::mutex runningQueriesMutex;

namespace Swift {

}

BonjourQuery::~BonjourQuery() {

namespace Swift {

class BonjourQuerier;

class BonjourQuery :

public EventOwner,

public boost::enable_shared_from_this<BonjourQuery> {

public:

virtual ~BonjourQuery();

void processResult();

void finish();

protected:

boost::shared_ptr<BonjourQuerier> querier;

mutable boost::mutex sdRefMutex;

DNSServiceRef sdRef;

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

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

#include "Swiften/Base/ByteArray.h"

namespace Swift {

class BonjourQuerier;

class BonjourRegisterQuery : public DNSSDRegisterQuery, public BonjourQuery {

public:

DNSServiceErrorType result = DNSServiceRegister(

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

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

run();

}

else {

}

}

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

if (errorCode != kDNSServiceErr_NoError) {

}

else {

}

}

};

#include "Swiften/Base/String.h"

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

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

#include "Swiften/Network/HostAddress.h"

#include <netinet/in.h>

class BonjourResolveHostnameQuery : public DNSSDResolveHostnameQuery, public BonjourQuery {

public:

DNSServiceErrorType result = DNSServiceGetAddrInfo(

&sdRef, 0, interfaceIndex, kDNSServiceProtocol_IPv4,

hostname.getUTF8Data(),

BonjourQuery::run();

}

else {

}

}

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

if (errorCode) {

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

boost::optional<HostAddress>()),

shared_from_this());

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

boost::ref(onHostnameResolved),

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

shared_from_this());

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

#include "Swiften/LinkLocal/LinkLocalServiceInfo.h"

#include "Swiften/Base/ByteArray.h"

namespace Swift {

class BonjourQuerier;

class BonjourResolveServiceQuery : public DNSSDResolveServiceQuery, public BonjourQuery {

public:

DNSServiceErrorType result = DNSServiceResolve(

&sdRef, 0, service.getNetworkInterfaceID(),

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

run();

}

else {

}

}

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

if (errorCode != kDNSServiceErr_NoError) {

}

else {

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

boost::bind(

boost::ref(onServiceResolved),

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

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

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

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

namespace Swift {

}

FakeDNSSDQuerier::~FakeDNSSDQuerier() {

allQueriesEverRun.push_back(query);

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

foreach(const DNSSDServiceID& service, services) {

}

}

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

}

}

}

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

DNSSDServiceID service(registerQuery->name, domain);

}

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

boost::bind(

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

shared_from_this());

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

services.insert(id);

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

}

}

services.erase(id);

serviceInfo.erase(id);

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

}

}

}

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

if (query->service == id) {

}

}

}

void FakeDNSSDQuerier::setBrowseError() {

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

}

}

void FakeDNSSDQuerier::setRegisterError() {

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

}

}

addresses[hostname] = address;

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

if (query->hostname == hostname) {

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

}

}

class ByteArray;

class FakeDNSSDQuery;

class FakeDNSSDBrowseQuery;

class FakeDNSSDQuerier :

public DNSSDQuerier,

public EventOwner,

public boost::enable_shared_from_this<FakeDNSSDQuerier> {

public:

~FakeDNSSDQuerier();

void start() {}

private:

String domain;

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

std::list< boost::shared_ptr<FakeDNSSDQuery> > allQueriesEverRun;

std::set<DNSSDServiceID> services;

namespace Swift {

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

#if defined(HAVE_BONJOUR)

#elif defined(HAVE_AVAHI)

#else

return boost::shared_ptr<DNSSDQuerier>();

#endif

namespace Swift {

class DNSSDQuerier;

class PlatformDNSSDQuerierFactory {

public:

};

}

void setUp() {

eventLoop = new DummyEventLoop();

querier = boost::shared_ptr<FakeDNSSDQuerier>(

connectFinished = false;

}

void setUp() {

eventLoop = new DummyEventLoop();

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