+ * Copyright (c) 2010-2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+#include <algorithm>

+#include <string>

+

+#include <boost/bind.hpp>

+

+#include <Swiften/Base/Platform.h>

+#include <Swiften/Base/sleep.h>

+#include <Swiften/EventLoop/DummyEventLoop.h>

+#include <Swiften/IDN/IDNConverter.h>

+#include <Swiften/IDN/PlatformIDNConverter.h>

+#include <Swiften/Network/BoostIOServiceThread.h>

+#include <Swiften/Network/BoostTimerFactory.h>

+#include <Swiften/Network/DomainNameAddressQuery.h>

+#include <Swiften/Network/DomainNameServiceQuery.h>

+#include <Swiften/Network/NetworkFactories.h>

+ bool operator()(const HostAddress& h1, const HostAddress& h2) {

+ return h1.toString() < h2.toString();

+ }

+ CPPUNIT_TEST_SUITE(DomainNameResolverTest);

+ CPPUNIT_TEST(testResolveAddress);

+ CPPUNIT_TEST(testResolveAddress_Error);

+ /**

+ * The native DNS resolver of Windows behaves oddly if the system has no global IPv6

+ * routed address and no IPv6 reachability. It will not return IPv6 records from DNS

+ * requests for an unspecified protocol (IPv6 or IPv4).

+ * The following tests are only enabled on Windows if scons is run with the 'test_ipv6=1'

+ * argument, indicating working IPv6 on the test machine.

+ */

+#if !defined(SWIFTEN_PLATFORM_WINDOWS) || defined(TEST_IPV6)

+ CPPUNIT_TEST(testResolveAddress_IPv6);

+ CPPUNIT_TEST(testResolveAddress_IPv4and6);

+#endif

+ CPPUNIT_TEST(testResolveAddress_International);

+ CPPUNIT_TEST(testResolveAddress_Localhost);

+ CPPUNIT_TEST(testResolveAddress_Parallel);

+ CPPUNIT_TEST(testResolveService);

+ CPPUNIT_TEST(testResolveService_Error);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ void setUp() {

+ ioServiceThread = new BoostIOServiceThread();

+ eventLoop = new DummyEventLoop();

+ idnConverter = std::shared_ptr<IDNConverter>(PlatformIDNConverter::create());

+ resolver = new UnboundDomainNameResolver(idnConverter.get(), ioServiceThread->getIOService(), eventLoop);

+ resolver = new PlatformDomainNameResolver(idnConverter.get(), eventLoop);

+ resultsAvailable = false;

+ }

+

+ void tearDown() {

+ delete ioServiceThread;

+ delete resolver;

+ delete eventLoop;

+ }

+

+ void testResolveAddress() {

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

+

+ query->run();

+ waitForResults();

+

+ CPPUNIT_ASSERT(!addressQueryError);

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

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

+ }

+

+ void testResolveAddress_Error() {

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

+

+ query->run();

+ waitForResults();

+

+ CPPUNIT_ASSERT(addressQueryError);

+ }

+

+ void testResolveAddress_IPv6() {

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

+

+ query->run();

+ waitForResults();

+

+ CPPUNIT_ASSERT(!addressQueryError);

+ CPPUNIT_ASSERT_EQUAL(std::string("2001:470:1f0e:852::2"), addressQueryResult[0].toString());

+ }

+

+ void testResolveAddress_IPv4and6() {

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

+

+ query->run();

+ waitForResults();

+

+ CPPUNIT_ASSERT(!addressQueryError);

+ CPPUNIT_ASSERT_EQUAL(2, static_cast<int>(addressQueryResult.size()));

+ CPPUNIT_ASSERT_EQUAL(std::string("10.0.0.7"), addressQueryResult[0].toString());

+ CPPUNIT_ASSERT_EQUAL(std::string("1234:5678:9abc:def0:fed:cba9:8765:4321"), addressQueryResult[1].toString());

+ }

+

+ void testResolveAddress_International() {

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

+

+ query->run();

+ waitForResults();

+

+ CPPUNIT_ASSERT(!addressQueryError);

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

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

+ }

+

+ void testResolveAddress_Localhost() {

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

+

+ query->run();

+ waitForResults();

+

+ CPPUNIT_ASSERT(!addressQueryError);

+ CPPUNIT_ASSERT(std::find(addressQueryResult.begin(), addressQueryResult.end(), HostAddress::fromString("127.0.0.1").get()) != addressQueryResult.end());

+ }

+

+ void testResolveAddress_Parallel() {

+ std::vector<DomainNameAddressQuery::ref> queries;

+ static const size_t numQueries = 100;

+ for (size_t i = 0; i < numQueries; ++i) {

+ DomainNameAddressQuery::ref query(createAddressQuery("xmpp.test.swift.im"));

+ queries.push_back(query);

+ query->run();

+ }

+

+ eventLoop->processEvents();

+ int ticks = 0;

+ while (allAddressQueryResults.size() < numQueries) {

+ ticks++;

+ if (ticks > 1000) {

+ CPPUNIT_ASSERT(false);

+ }

+ Swift::sleep(10);

+ eventLoop->processEvents();

+ }

+

+ CPPUNIT_ASSERT_EQUAL(numQueries, allAddressQueryResults.size());

+ for (size_t i = 0; i < numQueries; ++i) {

+ CPPUNIT_ASSERT_EQUAL(std::string("10.0.0.0"), allAddressQueryResults[i].toString());

+ }

+ }

+

+ void testResolveService() {

+ std::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(std::string("xmpp1.test.swift.im"), serviceQueryResult[0].hostname);

+ CPPUNIT_ASSERT_EQUAL(static_cast<unsigned short>(5000), serviceQueryResult[0].port);

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

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

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

+ CPPUNIT_ASSERT_EQUAL(static_cast<unsigned short>(5000), serviceQueryResult[1].port);

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

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

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

+ CPPUNIT_ASSERT_EQUAL(static_cast<unsigned short>(5000), serviceQueryResult[2].port);

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

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

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

+ CPPUNIT_ASSERT_EQUAL(static_cast<unsigned short>(5000), serviceQueryResult[3].port);

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

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

+ }

+

+ void testResolveService_Error() {

+ }

+

+ private:

+ std::shared_ptr<DomainNameAddressQuery> createAddressQuery(const std::string& domain) {

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

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

+ return result;

+ }

+

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

+ addressQueryResult = addresses;

+ std::sort(addressQueryResult.begin(), addressQueryResult.end(), CompareHostAddresses());

+ allAddressQueryResults.insert(allAddressQueryResults.begin(), addresses.begin(), addresses.end());

+ addressQueryError = error;

+ resultsAvailable = true;

+ }

+

+ std::shared_ptr<DomainNameServiceQuery> createServiceQuery(const std::string& serviceLookupPrefix, const std::string& domain) {

+ std::shared_ptr<DomainNameServiceQuery> result = resolver->createServiceQuery(serviceLookupPrefix, 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();

+ }

+ }

+

+ private:

+ BoostIOServiceThread* ioServiceThread;

+ DummyEventLoop* eventLoop;

+ std::shared_ptr<IDNConverter> idnConverter;

+ std::shared_ptr<TimerFactory> timerFactory;

+ bool resultsAvailable;

+ std::vector<HostAddress> addressQueryResult;

+ std::vector<HostAddress> allAddressQueryResults;

+ boost::optional<DomainNameResolveError> addressQueryError;

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

+ DomainNameResolver* resolver;