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

+#include <iostream>

+#include "Swiften/Network/DomainNameAddressQuery.h"

+Connector::Connector(const String& hostname, DomainNameResolver* resolver, ConnectionFactory* connectionFactory) : hostname(hostname), resolver(resolver), connectionFactory(connectionFactory), queriedAllHosts(true) {

+ assert(!serviceQuery);

+ queriedAllHosts = false;

+ serviceQuery = resolver->createServiceQuery("_xmpp-client._tcp." + hostname);

+ serviceQuery->onResult.connect(boost::bind(&Connector::handleServiceQueryResult, this, _1));

+ serviceQuery->run();

+}

+

+void Connector::queryAddress(const String& hostname) {

+ assert(!addressQuery);

+ addressQuery = resolver->createAddressQuery(hostname);

+ addressQuery->onResult.connect(boost::bind(&Connector::handleAddressQueryResult, this, _1, _2));

+ addressQuery->run();

+}

+

+void Connector::handleServiceQueryResult(const std::vector<DomainNameServiceQuery::Result>& result) {

+ serviceQueryResults = std::deque<DomainNameServiceQuery::Result>(result.begin(), result.end());

+ serviceQuery.reset();

+ tryNextHostname();

+}

+

+void Connector::tryNextHostname() {

+ if (queriedAllHosts) {

+ else if (serviceQueryResults.empty()) {

+ // Fall back on simple address resolving

+ queriedAllHosts = true;

+ queryAddress(hostname);

+ }

+ else {

+ queryAddress(serviceQueryResults.front().hostname);

+ }

+void Connector::handleAddressQueryResult(const HostAddress& address, boost::optional<DomainNameResolveError> error) {

+ addressQuery.reset();

+ if (!serviceQueryResults.empty()) {

+ DomainNameServiceQuery::Result serviceQueryResult = serviceQueryResults.front();

+ serviceQueryResults.pop_front();

+ if (error) {

+ tryNextHostname();

+ }

+ else {

+ tryConnect(HostAddressPort(address, serviceQueryResult.port));

+ }

+ }

+ else if (error) {

+ // The fallback address query failed

+ assert(queriedAllHosts);

+ // The fallback query succeeded

+ tryConnect(HostAddressPort(address, 5222));

+void Connector::tryConnect(const HostAddressPort& target) {

+ assert(!currentConnection);

+ currentConnection = connectionFactory->createConnection();

+ currentConnection->onConnectFinished.connect(boost::bind(&Connector::handleConnectionConnectFinished, this, _1));

+ currentConnection->connect(target);

+}

+

+ currentConnection.reset();

+#include "Swiften/Network/DomainNameServiceQuery.h"

+#include "Swiften/Network/DomainNameResolveError.h"

+ class DomainNameAddressQuery;

+ void handleServiceQueryResult(const std::vector<DomainNameServiceQuery::Result>& result);

+ void handleAddressQueryResult(const HostAddress& address, boost::optional<DomainNameResolveError> error);

+ void queryAddress(const String& hostname);

+

+ void tryConnect(const HostAddressPort& target);

+

+ boost::shared_ptr<DomainNameServiceQuery> serviceQuery;

+ std::deque<DomainNameServiceQuery::Result> serviceQueryResults;

+ boost::shared_ptr<DomainNameAddressQuery> addressQuery;

+ bool queriedAllHosts;

+#include "Swiften/Network/DomainNameAddressQuery.h"

+

+namespace Swift {

+

+DomainNameAddressQuery::~DomainNameAddressQuery() {

+}

+

+}

+#pragma once

+

+#include <boost/signals.hpp>

+#include <boost/optional.hpp>

+#include <boost/shared_ptr.hpp>

+

+#include "Swiften/Network/DomainNameResolveError.h"

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

+

+namespace Swift {

+ class DomainNameAddressQuery {

+ public:

+ virtual ~DomainNameAddressQuery();

+

+ virtual void run() = 0;

+

+ boost::signal<void (const HostAddress&, boost::optional<DomainNameResolveError>)> onResult;

+ };

+}

+#pragma once

+

+#include "Swiften/Base/Error.h"

+

+namespace Swift {

+ class DomainNameResolveError : public Error {

+ public:

+ DomainNameResolveError() {}

+ };

+}

+#include <boost/shared_ptr.hpp>

+ class DomainNameServiceQuery;

+ class DomainNameAddressQuery;

+ virtual boost::shared_ptr<DomainNameServiceQuery> createServiceQuery(const String& name) = 0;

+ virtual boost::shared_ptr<DomainNameAddressQuery> createAddressQuery(const String& name) = 0;

+#include "Swiften/Network/DomainNameServiceQuery.h"

+

+namespace Swift {

+

+DomainNameServiceQuery::~DomainNameServiceQuery() {

+}

+

+}

+#pragma once

+

+#include <boost/signals.hpp>

+#include <boost/optional.hpp>

+#include <vector>

+

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

+#include "Swiften/Network/DomainNameResolveError.h"

+

+namespace Swift {

+ class DomainNameServiceQuery {

+ public:

+ struct Result {

+ Result(const String& hostname = "", int port = -1, int priority = -1, int weight = -1) : hostname(hostname), port(port), priority(priority), weight(weight) {}

+ String hostname;

+ int port;

+ int priority;

+ int weight;

+ };

+

+ virtual ~DomainNameServiceQuery();

+

+ virtual void run() = 0;

+

+ boost::signal<void (const std::vector<Result>&)> onResult;

+ };

+}

+// Putting this early on, because some system types conflict with thread

+#include "Swiften/Network/PlatformDomainNameServiceQuery.h"

+#include <string>

+#include <vector>

+#include <boost/bind.hpp>

+#include <boost/enable_shared_from_this.hpp>

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

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

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

+#include "Swiften/Network/DomainNameAddressQuery.h"

+

+using namespace Swift;

+

+namespace {

+ struct AddressQuery : public DomainNameAddressQuery, public boost::enable_shared_from_this<AddressQuery>, public EventOwner {

+ AddressQuery(const String& host) : hostname(host) {}

+

+ virtual void run() {

+ boost::asio::ip::tcp::resolver resolver(ioService);

+ boost::asio::ip::tcp::resolver::query query(hostname.getUTF8String(), "5222");

+ try {

+ boost::asio::ip::tcp::resolver::iterator endpointIterator = resolver.resolve(query);

+ if (endpointIterator == boost::asio::ip::tcp::resolver::iterator()) {

+ emitError();

+ }

+ else {

+ boost::asio::ip::address address = (*endpointIterator).endpoint().address();

+ HostAddress result = (address.is_v4() ? HostAddress(&address.to_v4().to_bytes()[0], 4) : HostAddress(&address.to_v6().to_bytes()[0], 16));

+ MainEventLoop::postEvent(

+ boost::bind(boost::ref(onResult), result, boost::optional<DomainNameResolveError>()),

+ shared_from_this());

+ }

+ }

+ catch (...) {

+ emitError();

+ }

+ void emitError() {

+ MainEventLoop::postEvent(boost::bind(boost::ref(onResult), HostAddress(), boost::optional<DomainNameResolveError>(DomainNameResolveError())), shared_from_this());

+ boost::asio::io_service ioService;

+ String hostname;

+ };

+ String getNormalized(const String& domain) {

+ char* output;

+ if (idna_to_ascii_8z(domain.getUTF8Data(), &output, 0) == IDNA_SUCCESS) {

+ String result(output);

+ free(output);

+ return result;

+ else {

+ return domain;

+ }

+}

+namespace Swift {

+PlatformDomainNameResolver::PlatformDomainNameResolver() {

+}

+boost::shared_ptr<DomainNameServiceQuery> PlatformDomainNameResolver::createServiceQuery(const String& name) {

+ return boost::shared_ptr<DomainNameServiceQuery>(new PlatformDomainNameServiceQuery(getNormalized(name)));

+boost::shared_ptr<DomainNameAddressQuery> PlatformDomainNameResolver::createAddressQuery(const String& name) {

+ return boost::shared_ptr<DomainNameAddressQuery>(new AddressQuery(getNormalized(name)));

+ virtual boost::shared_ptr<DomainNameServiceQuery> createServiceQuery(const String& name);

+ virtual boost::shared_ptr<DomainNameAddressQuery> createAddressQuery(const String& name);

+#include "Swiften/Network/PlatformDomainNameServiceQuery.h"

+

+#include "Swiften/Base/Platform.h"

+#include <stdlib.h>

+#ifdef SWIFTEN_PLATFORM_WINDOWS

+#undef UNICODE

+#include <windows.h>

+#include <windns.h>

+#ifndef DNS_TYPE_SRV

+#define DNS_TYPE_SRV 33

+#endif

+#else

+#include <arpa/nameser.h>

+#include <arpa/nameser_compat.h>

+#include <resolv.h>

+#endif

+#include <boost/bind.hpp>

+

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

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

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

+

+using namespace Swift;

+

+namespace {

+ struct SRVRecordPriorityComparator {

+ bool operator()(const DomainNameServiceQuery::Result& a, const DomainNameServiceQuery::Result& b) const {

+ return a.priority < b.priority;

+ }

+ };

+}

+

+namespace Swift {

+

+PlatformDomainNameServiceQuery::PlatformDomainNameServiceQuery(const String& service) : service(service) {

+}

+

+void PlatformDomainNameServiceQuery::run() {

+ std::vector<DomainNameServiceQuery::Result> records;

+

+#if defined(SWIFTEN_PLATFORM_WINDOWS)

+ DNS_RECORD* responses;

+ // FIXME: This conversion doesn't work if unicode is deffed above

+ if (DnsQuery(service.getUTF8Data(), DNS_TYPE_SRV, DNS_QUERY_STANDARD, NULL, &responses, NULL) != ERROR_SUCCESS) {

+ emitError();

+ return;

+ }

+

+ DNS_RECORD* currentEntry = responses;

+ while (currentEntry) {

+ if (currentEntry->wType == DNS_TYPE_SRV) {

+ SRVRecord record;

+ record.priority = currentEntry->Data.SRV.wPriority;

+ record.weight = currentEntry->Data.SRV.wWeight;

+ record.port = currentEntry->Data.SRV.wPort;

+

+ // The pNameTarget is actually a PCWSTR, so I would have expected this

+ // conversion to not work at all, but it does.

+ // Actually, it doesn't. Fix this and remove explicit cast

+ // Remove unicode undef above as well

+ record.hostname = std::string((const char*) currentEntry->Data.SRV.pNameTarget);

+ records.push_back(record);

+ }

+ currentEntry = currentEntry->pNext;

+ }

+ DnsRecordListFree(responses, DnsFreeRecordList);

+

+#else

+

+ ByteArray response;

+ response.resize(NS_PACKETSZ);

+ int responseLength = res_query(const_cast<char*>(service.getUTF8Data()), ns_c_in, ns_t_srv, reinterpret_cast<u_char*>(response.getData()), response.getSize());

+ if (responseLength == -1) {

+ emitError();

+ return;

+ }

+

+ // Parse header

+ HEADER* header = reinterpret_cast<HEADER*>(response.getData());

+ unsigned char* messageStart = reinterpret_cast<unsigned char*>(response.getData());

+ unsigned char* messageEnd = messageStart + responseLength;

+ unsigned char* currentEntry = messageStart + NS_HFIXEDSZ;

+

+ // Skip over the queries

+ int queriesCount = ntohs(header->qdcount);

+ while (queriesCount > 0) {

+ int entryLength = dn_skipname(currentEntry, messageEnd);

+ if (entryLength < 0) {

+ emitError();

+ return;

+ }

+ currentEntry += entryLength + NS_QFIXEDSZ;

+ queriesCount--;

+ }

+

+ // Process the SRV answers

+ int answersCount = ntohs(header->ancount);

+ while (answersCount > 0) {

+ DomainNameServiceQuery::Result record;

+

+ int entryLength = dn_skipname(currentEntry, messageEnd);

+ currentEntry += entryLength;

+ currentEntry += NS_RRFIXEDSZ;

+

+ // Priority

+ if (currentEntry + 2 >= messageEnd) {

+ emitError();

+ return;

+ }

+ record.priority = ns_get16(currentEntry);

+ currentEntry += 2;

+

+ // Weight

+ if (currentEntry + 2 >= messageEnd) {

+ emitError();

+ return;

+ }

+ record.weight = ns_get16(currentEntry);

+ currentEntry += 2;

+

+ // Port

+ if (currentEntry + 2 >= messageEnd) {

+ emitError();

+ return;

+ }

+ record.port = ns_get16(currentEntry);

+ currentEntry += 2;

+

+ // Hostname

+ if (currentEntry >= messageEnd) {

+ emitError();

+ return;

+ }

+ ByteArray entry;

+ entry.resize(NS_MAXDNAME);

+ entryLength = dn_expand(messageStart, messageEnd, currentEntry, entry.getData(), entry.getSize());

+ if (entryLength < 0) {

+ emitError();

+ return;

+ }

+ record.hostname = String(entry.getData());

+ records.push_back(record);

+ currentEntry += entryLength;

+ answersCount--;

+ }

+#endif

+

+ std::sort(records.begin(), records.end(), SRVRecordPriorityComparator());

+ MainEventLoop::postEvent(boost::bind(boost::ref(onResult), records));

+}

+

+void PlatformDomainNameServiceQuery::emitError() {

+ MainEventLoop::postEvent(boost::bind(boost::ref(onResult), std::vector<DomainNameServiceQuery::Result>()), shared_from_this());

+}

+

+}

+#pragma once

+

+#include <boost/enable_shared_from_this.hpp>

+

+#include "Swiften/Network/DomainNameServiceQuery.h"

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

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

+

+namespace Swift {

+ class PlatformDomainNameServiceQuery : public DomainNameServiceQuery, public boost::enable_shared_from_this<PlatformDomainNameServiceQuery>, public EventOwner {

+ public:

+ PlatformDomainNameServiceQuery(const String& service);

+

+ virtual void run();

+

+ private:

+ void emitError();

+

+ private:

+ String service;

+ };

+}

+ "DomainNameAddressQuery.cpp",

+ "DomainNameServiceQuery.cpp",

+ "PlatformDomainNameServiceQuery.cpp",

+#include "Swiften/Network/DomainNameResolveError.h"

+using namespace Swift;

+

+namespace {

+ struct ServiceQuery : public DomainNameServiceQuery {

+ ServiceQuery(const String& service, Swift::StaticDomainNameResolver* resolver) : service(service), resolver(resolver) {}

+

+ virtual void run() {

+ }

+

+ String service;

+ StaticDomainNameResolver* resolver;

+ };

+

+ struct AddressQuery : public DomainNameAddressQuery {

+ AddressQuery(const String& host, StaticDomainNameResolver* resolver) : host(host), resolver(resolver) {}

+

+ virtual void run() {

+ }

+

+ String host;

+ StaticDomainNameResolver* resolver;

+ };

+}

+

+void StaticDomainNameResolver::addAddress(const String& domain, const HostAddress& address) {

+ addresses[domain] = address;

+void StaticDomainNameResolver::addService(const String& service, const DomainNameServiceQuery::Result& result) {

+ services.push_back(std::make_pair(service, result));

+}

+void StaticDomainNameResolver::addXMPPClientService(const String& domain, const HostAddressPort& address) {

+ addService("_xmpp-client._tcp." + domain, ServiceQuery::Result(domain, 5222, 0, 0));

+ addAddress(domain, address.getAddress());

+}

+

+boost::shared_ptr<DomainNameServiceQuery> StaticDomainNameResolver::createServiceQuery(const String& name) {

+ return boost::shared_ptr<DomainNameServiceQuery>(new ServiceQuery(name, this));

+boost::shared_ptr<DomainNameAddressQuery> StaticDomainNameResolver::createAddressQuery(const String& name) {

+ return boost::shared_ptr<DomainNameAddressQuery>(new AddressQuery(name, this));

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

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

+#include "Swiften/Network/DomainNameServiceQuery.h"

+#include "Swiften/Network/DomainNameAddressQuery.h"

+ typedef std::map<String, HostAddress> AddressesMap;

+ typedef std::vector< std::pair<String, DomainNameServiceQuery::Result> > ServicesCollection;

+ public:

+ void addAddress(const String& domain, const HostAddress& address);

+ void addService(const String& service, const DomainNameServiceQuery::Result& result);

+ void addXMPPClientService(const String& domain, const HostAddressPort&);

+

+ const AddressesMap& getAddresses() const {

+ return addresses;

+ }

+

+ const ServicesCollection& getServices() const {

+ return services;

+ }

+ virtual boost::shared_ptr<DomainNameServiceQuery> createServiceQuery(const String& name);

+ virtual boost::shared_ptr<DomainNameAddressQuery> createAddressQuery(const String& name);

+ AddressesMap addresses;

+ ServicesCollection services;

+ resolver->addXMPPClientService("foo.com", host1);

+ resolver->addXMPPClientService("foo.com", host2);

+ resolver->addXMPPClientService("foo.com", host1);

+ resolver->addXMPPClientService("foo.com", host2);

+ resolver->addXMPPClientService("foo.com", host1);

+ resolver->addXMPPClientService("foo.com", host2);

+#include <boost/bind.hpp>

+#include "Swiften/Base/sleep.h"

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

+#include "Swiften/Network/DomainNameAddressQuery.h"

+#include "Swiften/Network/DomainNameServiceQuery.h"

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

+ CPPUNIT_TEST(testResolveAddress);

+ CPPUNIT_TEST(testResolveAddress_Error);

+ //CPPUNIT_TEST(testResolveAddress_IPv6);

+ CPPUNIT_TEST(testResolveAddress_International);

+ CPPUNIT_TEST(testResolveAddress_Localhost);

+ CPPUNIT_TEST(testResolveService);

+ CPPUNIT_TEST(testResolveService_Error);

+ eventLoop = new DummyEventLoop();

+ resolver = new PlatformDomainNameResolver();

+ resultsAvailable = false;

+ delete resolver;

+ delete eventLoop;

+ void testResolveAddress() {

+ boost::shared_ptr<DomainNameAddressQuery> query(createAddressQuery("xmpp.test.swift.im"));

+ query->run();

+ waitForResults();

+

+ CPPUNIT_ASSERT(!addressQueryError);

+ CPPUNIT_ASSERT_EQUAL(std::string("10.0.0.0"), addressQueryResult.toString());

+ void testResolveAddress_Error() {

+ boost::shared_ptr<DomainNameAddressQuery> query(createAddressQuery("invalid.test.swift.im"));

+

+ query->run();

+ waitForResults();

+ CPPUNIT_ASSERT(addressQueryError);

+ void testResolveAddress_IPv6() {

+ boost::shared_ptr<DomainNameAddressQuery> query(createAddressQuery("xmpp-ipv6.test.swift.im"));

+

+ query->run();

+ waitForResults();

+

+ CPPUNIT_ASSERT(!addressQueryError);

+ CPPUNIT_ASSERT_EQUAL(std::string("0000:0000:0000:0000:0000:ffff:0a00:0104"), addressQueryResult.toString());

+ void testResolveAddress_International() {

+ boost::shared_ptr<DomainNameAddressQuery> query(createAddressQuery("tron\xc3\xa7on.test.swift.im"));

+

+ query->run();

+ waitForResults();

+

+ CPPUNIT_ASSERT(!addressQueryError);

+ CPPUNIT_ASSERT_EQUAL(std::string("10.0.0.3"), addressQueryResult.toString());

+ void testResolveAddress_Localhost() {

+ boost::shared_ptr<DomainNameAddressQuery> query(createAddressQuery("localhost"));

+

+ query->run();

+ waitForResults();

+

+ CPPUNIT_ASSERT(!addressQueryError);

+ CPPUNIT_ASSERT_EQUAL(std::string("127.0.0.1"), addressQueryResult.toString());

+

+ void testResolveService() {

+ boost::shared_ptr<DomainNameServiceQuery> query(createServiceQuery("_xmpp-client._tcp.xmpp-srv.test.swift.im"));

+

+ query->run();

+ waitForResults();

+

+ CPPUNIT_ASSERT_EQUAL(4, static_cast<int>(serviceQueryResult.size()));

+ CPPUNIT_ASSERT_EQUAL(String("xmpp1.test.swift.im"), serviceQueryResult[0].hostname);

+ CPPUNIT_ASSERT_EQUAL(5000, serviceQueryResult[0].port);

+ CPPUNIT_ASSERT_EQUAL(0, serviceQueryResult[0].priority);

+ CPPUNIT_ASSERT_EQUAL(1, serviceQueryResult[0].weight);

+ CPPUNIT_ASSERT_EQUAL(String("xmpp-invalid.test.swift.im"), serviceQueryResult[1].hostname);

+ CPPUNIT_ASSERT_EQUAL(5000, serviceQueryResult[1].port);

+ CPPUNIT_ASSERT_EQUAL(1, serviceQueryResult[1].priority);

+ CPPUNIT_ASSERT_EQUAL(100, serviceQueryResult[1].weight);

+ CPPUNIT_ASSERT_EQUAL(String("xmpp3.test.swift.im"), serviceQueryResult[2].hostname);

+ CPPUNIT_ASSERT_EQUAL(5000, serviceQueryResult[2].port);

+ CPPUNIT_ASSERT_EQUAL(3, serviceQueryResult[2].priority);

+ CPPUNIT_ASSERT_EQUAL(100, serviceQueryResult[2].weight);

+ CPPUNIT_ASSERT_EQUAL(String("xmpp2.test.swift.im"), serviceQueryResult[3].hostname);

+ CPPUNIT_ASSERT_EQUAL(5000, serviceQueryResult[3].port);

+ CPPUNIT_ASSERT_EQUAL(5, serviceQueryResult[3].priority);

+ CPPUNIT_ASSERT_EQUAL(100, serviceQueryResult[3].weight);

+ }

+

+ void testResolveService_Error() {

+/*

+ }

+ */

+

+ private:

+ boost::shared_ptr<DomainNameAddressQuery> createAddressQuery(const String& domain) {

+ boost::shared_ptr<DomainNameAddressQuery> result = resolver->createAddressQuery(domain);

+ result->onResult.connect(boost::bind(&DomainNameResolverTest::handleAddressQueryResult, this, _1, _2));

+ return result;

+ }

+

+ void handleAddressQueryResult(const HostAddress& address, boost::optional<DomainNameResolveError> error) {

+ addressQueryResult = address;

+ addressQueryError = error;

+ resultsAvailable = true;

+ }

+

+ boost::shared_ptr<DomainNameServiceQuery> createServiceQuery(const String& domain) {

+ boost::shared_ptr<DomainNameServiceQuery> result = resolver->createServiceQuery(domain);

+ result->onResult.connect(boost::bind(&DomainNameResolverTest::handleServiceQueryResult, this, _1));

+ return result;

+ }

+

+ void handleServiceQueryResult(const std::vector<DomainNameServiceQuery::Result>& result) {

+ serviceQueryResult = result;

+ resultsAvailable = true;

+ }

+

+ void waitForResults() {

+ eventLoop->processEvents();

+ int ticks = 0;

+ while (!resultsAvailable) {

+ ticks++;

+ if (ticks > 1000) {

+ CPPUNIT_ASSERT(false);

+ }

+ Swift::sleep(10);

+ eventLoop->processEvents();

+ }

+ }

+

+ DummyEventLoop* eventLoop;

+ bool resultsAvailable;

+ HostAddress addressQueryResult;

+ boost::optional<DomainNameResolveError> addressQueryError;

+ std::vector<DomainNameServiceQuery::Result> serviceQueryResult;

+ PlatformDomainNameResolver* resolver;