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

+ assert(!browser);

+ avahi_threaded_poll_lock(querier->getThreadedPoll());

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

+ if (!browser) {

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

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

+ }

+ avahi_threaded_poll_unlock(querier->getThreadedPoll());

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

+ avahi_threaded_poll_lock(querier->getThreadedPoll());

+ avahi_service_browser_free(browser);

+ browser = NULL;

+ avahi_threaded_poll_unlock(querier->getThreadedPoll());

+ switch (event) {

+ case AVAHI_BROWSER_FAILURE:

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

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

+ break;

+ case AVAHI_BROWSER_NEW: {

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

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

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

+ break;

+ }

+ case AVAHI_BROWSER_REMOVE: {

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

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

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

+ break;

+ }

+ case AVAHI_BROWSER_ALL_FOR_NOW:

+ case AVAHI_BROWSER_CACHE_EXHAUSTED:

+ break;

+ }

+ class AvahiQuerier;

+ class AvahiBrowseQuery : public DNSSDBrowseQuery, public AvahiQuery {

+ public:

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

+ }

+ void startBrowsing();

+ void stopBrowsing();

+ private:

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

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

+ }

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

+ private:

+ AvahiServiceBrowser* browser;

+

+ };

+ return boost::shared_ptr<DNSSDBrowseQuery>(new AvahiBrowseQuery(shared_from_this(), eventLoop));

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

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

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

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

+ assert(!threadedPoll);

+ threadedPoll = avahi_threaded_poll_new();

+ int error;

+ assert(!client);

+ client = avahi_client_new(

+ avahi_threaded_poll_get(threadedPoll),

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

+ if (!client) {

+ // TODO

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

+ return;

+ }

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

+ avahi_threaded_poll_start(threadedPoll);

+ assert(threadedPoll);

+ avahi_threaded_poll_stop(threadedPoll);

+ assert(client);

+ avahi_client_free(client);

+ avahi_threaded_poll_free(threadedPoll);

+ class EventLoop;

+

+ class AvahiQuerier :

+ public DNSSDQuerier,

+ public boost::enable_shared_from_this<AvahiQuerier> {

+ public:

+ AvahiQuerier(EventLoop* eventLoop);

+ ~AvahiQuerier();

+

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

+ boost::shared_ptr<DNSSDRegisterQuery> createRegisterQuery(

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

+ boost::shared_ptr<DNSSDResolveServiceQuery> createResolveServiceQuery(

+ const DNSSDServiceID&);

+ boost::shared_ptr<DNSSDResolveHostnameQuery> createResolveHostnameQuery(

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

+

+ void start();

+ void stop();

+

+ AvahiThreadedPoll* getThreadedPoll() const {

+ return threadedPoll;

+ }

+

+ AvahiClient* getClient() const {

+ return client;

+ }

+

+ private:

+ EventLoop* eventLoop;

+ AvahiClient* client;

+ AvahiThreadedPoll* threadedPoll;

+ };

+ class AvahiQuerier;

+ class EventLoop;

+ class AvahiQuery :

+ public EventOwner,

+ public boost::enable_shared_from_this<AvahiQuery> {

+ public:

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

+ virtual ~AvahiQuery();

+

+ protected:

+ boost::shared_ptr<AvahiQuerier> querier;

+ EventLoop* eventLoop;

+ };

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

+ avahi_threaded_poll_lock(querier->getThreadedPoll());

+ if (!group) {

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

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

+ if (!group) {

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

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

+ }

+ }

+

+ doRegisterService();

+ avahi_threaded_poll_unlock(querier->getThreadedPoll());

+ if (group) {

+ avahi_entry_group_free(group);

+ group = NULL;

+ }

+ this->txtRecord = txtRecord;

+ avahi_threaded_poll_lock(querier->getThreadedPoll());

+ assert(group);

+ avahi_entry_group_reset(group);

+ doRegisterService();

+ avahi_threaded_poll_unlock(querier->getThreadedPoll());

+ AvahiStringList* txtList;

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

+

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

+ if (result < 0) {

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

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

+ }

+ result = avahi_entry_group_commit(group);

+ if (result < 0) {

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

+ }

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

+ switch (state) {

+ case AVAHI_ENTRY_GROUP_ESTABLISHED :

+ // Domain is a hack!

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

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

+ break;

+ case AVAHI_ENTRY_GROUP_COLLISION : {

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

+ /*char *n;

+ n = avahi_alternative_service_name(name);

+ avahi_free(name);

+ name = n;*/

+ break;

+ }

+

+ case AVAHI_ENTRY_GROUP_FAILURE :

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

+ break;

+

+ case AVAHI_ENTRY_GROUP_UNCOMMITED:

+ case AVAHI_ENTRY_GROUP_REGISTERING:

+ ;

+

+ /*

+ DNSServiceErrorType result = DNSServiceRegister(

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

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

+ &AvahiRegisterQuery::handleServiceRegisteredStatic, this);

+ if (result != kDNSServiceErr_NoError) {

+ sdRef = NULL;

+ }*/

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

+ }

+ class AvahiQuerier;

+ class AvahiRegisterQuery : public DNSSDRegisterQuery, public AvahiQuery {

+ public:

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

+ }

+ void registerService();

+ void unregisterService();

+ void updateServiceInfo(const ByteArray& txtRecord);

+ private:

+ void doRegisterService();

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

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

+ }

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

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

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

+ }

+

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

+ if (errorCode != kDNSServiceErr_NoError) {

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

+ }

+ else {

+ }

+ }

+ */

+

+ private:

+ std::string name;

+ int port;

+ ByteArray txtRecord;

+ AvahiEntryGroup* group;

+ };

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

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

+ class AvahiQuerier;

+ class AvahiResolveHostnameQuery : public DNSSDResolveHostnameQuery, public AvahiQuery {

+ public:

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

+ void run();

+ void finish() {

+ }

+ private:

+ HostAddress hostAddress;

+ std::string hostname;

+ };

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

+ avahi_threaded_poll_lock(querier->getThreadedPoll());

+ assert(!resolver);

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

+ if (!resolver) {

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

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

+ }

+ avahi_threaded_poll_unlock(querier->getThreadedPoll());

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

+ avahi_threaded_poll_lock(querier->getThreadedPoll());

+ avahi_service_resolver_free(resolver);

+ resolver = NULL;

+ avahi_threaded_poll_unlock(querier->getThreadedPoll());

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

+ switch(event) {

+ case AVAHI_RESOLVER_FAILURE:

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

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

+ break;

+ case AVAHI_RESOLVER_FOUND: {

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

+ char a[AVAHI_ADDRESS_STR_MAX];

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

+ ByteArray txtRecord;

+ txtRecord.resize(1024);

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

+ // FIXME: Probably not accurate

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

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

+ eventLoop->postEvent(

+ boost::bind(

+ boost::ref(onServiceResolved),

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

+ shared_from_this());

+ break;

+ }

+ }

+ class AvahiQuerier;

+ class AvahiResolveServiceQuery : public DNSSDResolveServiceQuery, public AvahiQuery {

+ public:

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

+ }

+ void start();

+ void stop();

+ private:

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

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

+ }

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

+ private:

+ DNSSDServiceID service;

+ AvahiServiceResolver* resolver;

+ };