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

+ assert(!connector_);

+ connector_ = boost::shared_ptr<Connector>(new Connector(jid_.getDomain(), &resolver_, connectionFactory_));

+ connector_->onConnectFinished.connect(boost::bind(&Client::handleConnectorFinished, this, _1));

+ connector_->start();

+void Client::handleConnectorFinished(boost::shared_ptr<Connection> connection) {

+ // TODO: Add domain name resolver error

+ connector_.reset();

+ if (!connection) {

+ assert(!connection_);

+ connection_ = connection;

+

+ if (sessionStream_) {

+ sessionStream_.reset();

+ }

+ onDataRead(data);

+ onDataWritten(data);

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

+ class Connector;

+ void handleConnectorFinished(boost::shared_ptr<Connection>);

+ PlatformDomainNameResolver resolver_;

+ boost::shared_ptr<Connector> connector_;

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

+

+#include <boost/bind.hpp>

+

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

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

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

+

+namespace Swift {

+

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

+}

+

+void Connector::start() {

+ assert(!currentConnection);

+ try {

+ std::vector<HostAddressPort> resolveResult = resolver->resolve(hostname.getUTF8String());

+ resolvedHosts = std::deque<HostAddressPort>(resolveResult.begin(), resolveResult.end());

+ tryNextHostname();

+ }

+ catch (const DomainNameResolveException&) {

+ onConnectFinished(boost::shared_ptr<Connection>());

+ }

+}

+

+void Connector::tryNextHostname() {

+ if (resolvedHosts.empty()) {

+ onConnectFinished(boost::shared_ptr<Connection>());

+ }

+ else {

+ HostAddressPort remote = resolvedHosts.front();

+ resolvedHosts.pop_front();

+ currentConnection = connectionFactory->createConnection();

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

+ currentConnection->connect(remote);

+ }

+}

+

+void Connector::handleConnectionConnectFinished(bool error) {

+ if (error) {

+ tryNextHostname();

+ }

+ else {

+ onConnectFinished(currentConnection);

+ }

+}

+

+};

+#pragma once

+

+#include <deque>

+#include <boost/signal.hpp>

+#include <boost/shared_ptr.hpp>

+

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

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

+

+namespace Swift {

+ class DomainNameResolver;

+ class ConnectionFactory;

+

+ class Connector : public boost::bsignals::trackable {

+ public:

+ Connector(const String& hostname, DomainNameResolver*, ConnectionFactory*);

+

+ void start();

+

+ boost::signal<void (boost::shared_ptr<Connection>)> onConnectFinished;

+

+ private:

+ void tryNextHostname();

+ void handleConnectionConnectFinished(bool error);

+

+ private:

+ String hostname;

+ DomainNameResolver* resolver;

+ ConnectionFactory* connectionFactory;

+ std::deque<HostAddressPort> resolvedHosts;

+ boost::shared_ptr<Connection> currentConnection;

+ };

+

+};

+#pragma once

+#include <vector>

+ virtual std::vector<HostAddressPort> resolve(const String& domain) = 0;

+#pragma once

+

+#include <cassert>

+#include <boost/bind.hpp>

+#include <boost/enable_shared_from_this.hpp>

+

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

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

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

+

+namespace Swift {

+ class DummyConnection :

+ public Connection,

+ public EventOwner,

+ public boost::enable_shared_from_this<DummyConnection> {

+

+ void listen() {

+ assert(false);

+ }

+

+ void connect(const HostAddressPort&) {

+ assert(false);

+ }

+

+ void disconnect() {

+ assert(false);

+ }

+

+ void write(const ByteArray& data) {

+ onDataWritten(data);

+ }

+

+ void receive(const ByteArray& data) {

+ MainEventLoop::postEvent(boost::bind(

+ boost::ref(onDataRead), ByteArray(data)), shared_from_this());

+ }

+

+ boost::signal<void (const ByteArray&)> onDataWritten;

+ };

+}

+ bool operator==(const HostAddress& o) const {

+ return address_ == o.address_;

+ }

+

+ bool operator==(const HostAddressPort& o) const {

+ return address_ == o.address_ && port_ == o.port_;

+ }

+

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

+

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

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

+

+#include <stdlib.h>

+#include <boost/asio.hpp>

+#include <idna.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 <algorithm>

+

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

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

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

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

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

+

+namespace Swift {

+

+PlatformDomainNameResolver::PlatformDomainNameResolver() {

+}

+

+std::vector<HostAddressPort> PlatformDomainNameResolver::resolve(const String& domain) {

+ char* output;

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

+ std::string outputString(output);

+ free(output);

+ return resolveDomain(outputString);

+ }

+ else {

+ return resolveDomain(domain.getUTF8String());

+ }

+}

+

+std::vector<HostAddressPort> PlatformDomainNameResolver::resolveDomain(const std::string& domain) {

+ try {

+ return resolveXMPPService(domain);

+ }

+ catch (const DomainNameResolveException&) {

+ }

+ std::vector<HostAddressPort> result;

+ result.push_back(HostAddressPort(resolveHostName(domain), 5222));

+ return result;

+}

+

+std::vector<HostAddressPort> PlatformDomainNameResolver::resolveXMPPService(const std::string& domain) {

+ std::vector<SRVRecord> records;

+

+ std::string srvQuery = "_xmpp-client._tcp." + domain;

+

+#if defined(SWIFTEN_PLATFORM_WINDOWS)

+ DNS_RECORD* responses;

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

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

+ throw DomainNameResolveException();

+ }

+

+ 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*>(srvQuery.c_str()), ns_c_in, ns_t_srv, reinterpret_cast<u_char*>(response.getData()), response.getSize());

+ if (responseLength == -1) {

+ throw DomainNameResolveException();

+ }

+

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

+ throw DomainNameResolveException();

+ }

+ currentEntry += entryLength + NS_QFIXEDSZ;

+ queriesCount--;

+ }

+

+ // Process the SRV answers

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

+ while (answersCount > 0) {

+ SRVRecord record;

+

+ int entryLength = dn_skipname(currentEntry, messageEnd);

+ currentEntry += entryLength;

+ currentEntry += NS_RRFIXEDSZ;

+

+ // Priority

+ if (currentEntry + 2 >= messageEnd) {

+ throw DomainNameResolveException();

+ }

+ record.priority = ns_get16(currentEntry);

+ currentEntry += 2;

+

+ // Weight

+ if (currentEntry + 2 >= messageEnd) {

+ throw DomainNameResolveException();

+ }

+ record.weight = ns_get16(currentEntry);

+ currentEntry += 2;

+

+ // Port

+ if (currentEntry + 2 >= messageEnd) {

+ throw DomainNameResolveException();

+ }

+ record.port = ns_get16(currentEntry);

+ currentEntry += 2;

+

+ // Hostname

+ if (currentEntry >= messageEnd) {

+ throw DomainNameResolveException();

+ }

+ ByteArray entry;

+ entry.resize(NS_MAXDNAME);

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

+ if (entryLength < 0) {

+ throw DomainNameResolveException();

+ }

+ record.hostname = std::string(entry.getData(), entryLength);

+ records.push_back(record);

+ currentEntry += entryLength;

+ answersCount--;

+ }

+#endif

+

+ // Resolve the hostnames in the records, and build the result list

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

+ std::vector<HostAddressPort> result;

+ foreach(const SRVRecord& record, records) {

+ try {

+ HostAddress address = resolveHostName(record.hostname);

+ result.push_back(HostAddressPort(address, record.port));

+ }

+ catch (const DomainNameResolveException&) {

+ }

+ }

+ if (result.empty()) {

+ throw DomainNameResolveException();

+ }

+ return result;

+}

+

+HostAddress PlatformDomainNameResolver::resolveHostName(const std::string& hostname) {

+ boost::asio::io_service ioService;

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

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

+ try {

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

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

+ throw DomainNameResolveException();

+ }

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

+ if (address.is_v4()) {

+ return HostAddress(&address.to_v4().to_bytes()[0], 4);

+ }

+ else {

+ return HostAddress(&address.to_v6().to_bytes()[0], 16);

+ }

+ }

+ catch (...) {

+ throw DomainNameResolveException();

+ }

+}

+

+}

+#pragma once

+

+#include <string>

+#include <vector>

+

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

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

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

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

+

+namespace Swift {

+ class String;

+

+ class PlatformDomainNameResolver : public DomainNameResolver {

+ public:

+ PlatformDomainNameResolver();

+

+ std::vector<HostAddressPort> resolve(const String& domain);

+

+ private:

+ std::vector<HostAddressPort> resolveDomain(const std::string& domain);

+ std::vector<HostAddressPort> resolveXMPPService(const std::string& domain);

+ HostAddress resolveHostName(const std::string& hostName);

+ };

+}

+ "Connector.cpp",

+ "PlatformDomainNameResolver.cpp",

+ "StaticDomainNameResolver.cpp",

+#pragma once

+

+namespace Swift {

+ struct SRVRecord {

+ std::string hostname;

+ int port;

+ int priority;

+ int weight;

+ };

+}

+#pragma once

+

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

+

+namespace Swift {

+ struct SRVRecordPriorityComparator {

+ bool operator()(const SRVRecord& a, const SRVRecord& b) const {

+ return a.priority < b.priority;

+ }

+ };

+}

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

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

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

+

+namespace Swift {

+

+StaticDomainNameResolver::StaticDomainNameResolver() {

+}

+

+std::vector<HostAddressPort> StaticDomainNameResolver::resolve(const String& queriedDomain) {

+ std::vector<HostAddressPort> result;

+

+ for(DomainCollection::const_iterator i = domains.begin(); i != domains.end(); ++i) {

+ if (i->first == queriedDomain) {

+ result.push_back(i->second);

+ }

+ }

+ if (result.empty()) {

+ throw DomainNameResolveException();

+ }

+ return result;

+}

+

+void StaticDomainNameResolver::addDomain(const String& domain, const HostAddressPort& addressPort) {

+ domains.push_back(std::make_pair(domain, addressPort));

+}

+

+}

+#pragma once

+

+#include <vector>

+#include <map>

+

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

+

+namespace Swift {

+ class String;

+

+ class StaticDomainNameResolver : public DomainNameResolver {

+ public:

+ StaticDomainNameResolver();

+

+ virtual std::vector<HostAddressPort> resolve(const String& domain);

+

+ void addDomain(const String& domain, const HostAddressPort& addressPort);

+

+ private:

+ typedef std::vector< std::pair<String, HostAddressPort> > DomainCollection;

+ DomainCollection domains;

+ };

+}

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

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

+

+#include <boost/optional.hpp>

+#include <boost/bind.hpp>

+

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

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

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

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

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

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

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

+

+using namespace Swift;

+

+class ConnectorTest : public CppUnit::TestFixture {

+ CPPUNIT_TEST_SUITE(ConnectorTest);

+ CPPUNIT_TEST(testConnect);

+ CPPUNIT_TEST(testConnect_NoHosts);

+ CPPUNIT_TEST(testConnect_FirstHostFails);

+ CPPUNIT_TEST(testConnect_AllHostsFail);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ ConnectorTest() : host1(HostAddress("1.1.1.1"), 1234), host2(HostAddress("2.2.2.2"), 2345) {

+ }

+

+ void setUp() {

+ eventLoop = new DummyEventLoop();

+ resolver = new StaticDomainNameResolver();

+ connectionFactory = new MockConnectionFactory();

+ }

+

+ void tearDown() {

+ delete connectionFactory;

+ delete resolver;

+ delete eventLoop;

+ }

+

+ void testConnect() {

+ std::auto_ptr<Connector> testling(createConnector());

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

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

+

+ testling->start();

+ eventLoop->processEvents();

+

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(connections.size()));

+ CPPUNIT_ASSERT(connections[0]);

+ CPPUNIT_ASSERT(host1 == *(connections[0]->hostAddressPort));

+ }

+

+ void testConnect_NoHosts() {

+ std::auto_ptr<Connector> testling(createConnector());

+

+ testling->start();

+ eventLoop->processEvents();

+

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(connections.size()));

+ CPPUNIT_ASSERT(!connections[0]);

+ }

+

+ void testConnect_FirstHostFails() {

+ std::auto_ptr<Connector> testling(createConnector());

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

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

+ connectionFactory->failingPorts.push_back(host1);

+

+ testling->start();

+ eventLoop->processEvents();

+

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(connections.size()));

+ CPPUNIT_ASSERT(host2 == *(connections[0]->hostAddressPort));

+ }

+

+ void testConnect_AllHostsFail() {

+ std::auto_ptr<Connector> testling(createConnector());

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

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

+ connectionFactory->failingPorts.push_back(host1);

+ connectionFactory->failingPorts.push_back(host2);

+

+ testling->start();

+ eventLoop->processEvents();

+

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(connections.size()));

+ CPPUNIT_ASSERT(!connections[0]);

+ }

+

+ private:

+ Connector* createConnector() {

+ Connector* connector = new Connector("foo.com", resolver, connectionFactory);

+ connector->onConnectFinished.connect(boost::bind(&ConnectorTest::handleConnectorFinished, this, _1));

+ return connector;

+ }

+

+ void handleConnectorFinished(boost::shared_ptr<Connection> connection) {

+ boost::shared_ptr<MockConnection> c(boost::dynamic_pointer_cast<MockConnection>(connection));

+ if (connection) {

+ assert(c);

+ }

+ connections.push_back(c);

+ }

+

+ struct MockConnection : public Connection {

+ public:

+ MockConnection(const std::vector<HostAddressPort>& failingPorts) : failingPorts(failingPorts) {}

+

+ void listen() { assert(false); }

+ void connect(const HostAddressPort& address) {

+ hostAddressPort = address;

+ MainEventLoop::postEvent(boost::bind(boost::ref(onConnectFinished), std::find(failingPorts.begin(), failingPorts.end(), address) != failingPorts.end()));

+ }

+

+ void disconnect() { assert(false); }

+ void write(const ByteArray&) { assert(false); }

+

+ boost::optional<HostAddressPort> hostAddressPort;

+ std::vector<HostAddressPort> failingPorts;

+ };

+

+ struct MockConnectionFactory : public ConnectionFactory {

+ boost::shared_ptr<Connection> createConnection() {

+ return boost::shared_ptr<Connection>(new MockConnection(failingPorts));

+ }

+

+ std::vector<HostAddressPort> failingPorts;

+ };

+

+ private:

+ HostAddressPort host1;

+ HostAddressPort host2;

+ DummyEventLoop* eventLoop;

+ StaticDomainNameResolver* resolver;

+ MockConnectionFactory* connectionFactory;

+ std::vector< boost::shared_ptr<MockConnection> > connections;

+};

+

+CPPUNIT_TEST_SUITE_REGISTRATION(ConnectorTest);

+bool reconnected = false;

+ if (reconnected) {

+ rosterReceived = true;

+ client->disconnect();

+ eventLoop.stop();

+ }

+ else {

+ reconnected = true;

+ client->disconnect();

+ client->connect();

+ }

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

+ CPPUNIT_TEST(testResolve_Localhost);

+ resolver_ = new PlatformDomainNameResolver();

+ HostAddressPort result = resolver_->resolve("xmpp.test.swift.im")[0];

+ std::vector<HostAddressPort> result = resolver_->resolve("xmpp-srv.test.swift.im");

+ CPPUNIT_ASSERT_EQUAL(3, static_cast<int>(result.size()));

+ CPPUNIT_ASSERT_EQUAL(std::string("10.0.0.1"), result[0].getAddress().toString());

+ CPPUNIT_ASSERT_EQUAL(5000, result[0].getPort());

+ CPPUNIT_ASSERT_EQUAL(std::string("10.0.0.3"), result[1].getAddress().toString());

+ CPPUNIT_ASSERT_EQUAL(5000, result[1].getPort());

+ CPPUNIT_ASSERT_EQUAL(std::string("10.0.0.2"), result[2].getAddress().toString());

+ CPPUNIT_ASSERT_EQUAL(5000, result[2].getPort());

+ HostAddressPort result = resolver_->resolve("xmpp-ipv6.test.swift.im")[0];

+ HostAddressPort result = resolver_->resolve("tron\xc3\xa7on.test.swift.im")[0];

+ void testResolve_Localhost() {

+ HostAddressPort result = resolver_->resolve("localhost")[0];

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

+ CPPUNIT_ASSERT_EQUAL(5222, result.getPort());

+ }

+

+ PlatformDomainNameResolver* resolver_;

+ File("Network/UnitTest/ConnectorTest.cpp"),

+ &BasicSessionStream::handleXMPPError, shared_from_this()));

+ xmppLayer->onDataRead.connect(boost::bind(&BasicSessionStream::handleDataRead, shared_from_this(), _1));

+ xmppLayer->onWriteData.connect(boost::bind(&BasicSessionStream::handleDataWritten, shared_from_this(), _1));

+ new ConnectionLayer(connection));

+ delete streamStack;

+ return tlsLayerFactory && tlsLayerFactory->canCreate();

+ xmppLayer->resetParser();

+ class TLSLayerFactory;

+ class TLSLayer;

+ class WhitespacePingLayer;

+ class StreamStack;

+ class ConnectionLayer;

+ class BasicSessionStream :

+ public SessionStream,

+ public boost::enable_shared_from_this<BasicSessionStream> {

+ public:

+ BasicSessionStream(

+ boost::shared_ptr<Connection> connection,

+ PayloadParserFactoryCollection* payloadParserFactories,

+ PayloadSerializerCollection* payloadSerializers,

+ TLSLayerFactory* tlsLayerFactory

+ );

+ ~BasicSessionStream();

+ private:

+ void handleXMPPError();

+ void handleTLSError();

+ void handleDataRead(const ByteArray& data);

+ void handleDataWritten(const ByteArray& data);

+ private:

+ boost::shared_ptr<TLSLayer> tlsLayer;

+ boost::shared_ptr<WhitespacePingLayer> whitespacePingLayer;

+ };