#pragma once

namespace Swift {

class AvahiQuerier;

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

}

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

}

private:

AvahiServiceBrowser* browser;

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <iostream>

namespace Swift {

#include <avahi-common/malloc.h>

#include <avahi-common/error.h>

namespace Swift {

class EventLoop;

class AvahiQuerier :

* See Documentation/Licenses/GPLv3.txt for more information.

*/

namespace Swift {

#include <boost/shared_ptr.hpp>

#include <boost/enable_shared_from_this.hpp>

namespace Swift {

class AvahiQuerier;

#include <avahi-client/publish.h>

namespace Swift {

class AvahiQuerier;

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

}

private:

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

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

}

/*

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

#pragma once

#include <string>

#include <netinet/in.h>

class AvahiResolveHostnameQuery : public DNSSDResolveHostnameQuery, public AvahiQuery {

public:

void finish() {

}

#pragma once

namespace Swift {

class AvahiQuerier;

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

}

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

}

private:

DNSSDServiceID service;

#pragma once

namespace Swift {

class BonjourQuerier;

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <unistd.h>

#include <sys/socket.h>

#include <fcntl.h>

namespace Swift {

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

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

{

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

}

}

#include <boost/shared_ptr.hpp>

#include <boost/enable_shared_from_this.hpp>

#include <list>

#include <boost/thread/mutex.hpp>

namespace Swift {

class BonjourQuerier :

public DNSSDQuerier,

public boost::enable_shared_from_this<BonjourQuerier> {

* See Documentation/Licenses/GPLv3.txt for more information.

*/

namespace Swift {

#include <boost/enable_shared_from_this.hpp>

#include <boost/thread/mutex.hpp>

namespace Swift {

class BonjourQuerier;

#pragma once

namespace Swift {

class BonjourQuerier;

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

DNSServiceErrorType result = DNSServiceRegister(

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

&BonjourRegisterQuery::handleServiceRegisteredStatic, this);

if (result != kDNSServiceErr_NoError) {

sdRef = NULL;

void updateServiceInfo(const ByteArray& txtRecord) {

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

}

private:

#pragma GCC diagnostic ignored "-Wold-style-cast"

#include <string>

#include <netinet/in.h>

#pragma once

namespace Swift {

class BonjourQuerier;

boost::bind(

boost::ref(onServiceResolved),

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

shared_from_this());

}

}

* See Documentation/Licenses/GPLv3.txt for more information.

*/

namespace Swift {

#pragma once

namespace Swift {

class DNSSDBrowseQuery {

* See Documentation/Licenses/GPLv3.txt for more information.

*/

namespace Swift {

#include <boost/shared_ptr.hpp>

namespace Swift {

class DNSSDServiceID;

class DNSSDBrowseQuery;

class DNSSDRegisterQuery;

* See Documentation/Licenses/GPLv3.txt for more information.

*/

namespace Swift {

#pragma once

#include <boost/optional.hpp>

namespace Swift {

class DNSSDRegisterQuery {

public:

virtual ~DNSSDRegisterQuery();

* See Documentation/Licenses/GPLv3.txt for more information.

*/

namespace Swift {

#pragma once

#include <boost/optional.hpp>

namespace Swift {

class DNSSDResolveHostnameQuery {

* See Documentation/Licenses/GPLv3.txt for more information.

*/

namespace Swift {

#pragma once

#include <boost/optional.hpp>

namespace Swift {

class DNSSDResolveServiceQuery {

* See Documentation/Licenses/GPLv3.txt for more information.

*/

namespace Swift {

#pragma once

namespace Swift {

class FakeDNSSDQuerier;

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <boost/bind.hpp>

namespace Swift {

}

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

}

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

#include <list>

#include <set>

#include <string>

namespace Swift {

class FakeDNSSDQuery;

class FakeDNSSDBrowseQuery;

class EventLoop;

template<typename T>

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

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

result.push_back(resultQuery);

}

}

template<typename T>

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

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

result.push_back(resultQuery);

}

}

private:

std::string domain;

EventLoop* eventLoop;

std::set<DNSSDServiceID> services;

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

ServiceInfoMap serviceInfo;

* See Documentation/Licenses/GPLv3.txt for more information.

*/

namespace Swift {

#include <boost/shared_ptr.hpp>

#include <boost/enable_shared_from_this.hpp>

namespace Swift {

class FakeDNSSDQuerier;

#pragma once

#include <string>

namespace Swift {

#pragma once

#include <string>

namespace Swift {

class FakeDNSSDQuerier;

#pragma once

namespace Swift {

class FakeDNSSDQuerier;

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#if defined(HAVE_BONJOUR)

#elif defined(HAVE_AVAHI)

#endif