import os, shutil, datetime

Import("env")

myenv = env.Clone()

myenv["CXXFLAGS"] = filter(lambda x : x != "-Wfloat-equal", myenv["CXXFLAGS"])

myenv.UseFlags(env["SLIMBER_FLAGS"])

myenv.UseFlags(env["LIMBER_FLAGS"])

myenv.UseFlags(env["SWIFTOOLS_FLAGS"])

myenv.UseFlags(env["SWIFTEN_FLAGS"])

myenv.UseFlags(env["BOOST_FLAGS"])

myenv.UseFlags(env.get("LIBXML_FLAGS", ""))

myenv.UseFlags(env.get("EXPAT_FLAGS", ""))

myenv.UseFlags(env.get("AVAHI_FLAGS", ""))

myenv.UseFlags(myenv["PLATFORM_FLAGS"])

myenv.Tool("qt4", toolpath = ["#/BuildTools/SCons/Tools"])

myenv.Tool("nsis", toolpath = ["#/BuildTools/SCons/Tools"])

myenv.EnableQt4Modules(['QtCore', 'QtGui'], debug = False)

myenv.Append(CPPPATH = ["."])

if env["PLATFORM"] == "win32" :

myenv.Append(LINKFLAGS = ["/SUBSYSTEM:WINDOWS"])

myenv.Append(LIBS = "qtmain")

myenv.BuildVersion("BuildVersion.h", project = "slimber")

sources = [

"main.cpp",

"QtMenulet.cpp",

"QtAboutDialog.cpp",

myenv.Qrc("Slimber.qrc"),

]

#if env["PLATFORM"] == "win32" :

# myenv.RES("../resources/Windows/Slimber.rc")

# sources += ["../resources/Windows/Slimber.res"]

if env["PLATFORM"] == "win32" :

slimberProgram = myenv.Program("Slimber", sources)

else :

slimberProgram = myenv.Program("slimber", sources)

if env["PLATFORM"] == "win32" :

if "dist" in COMMAND_LINE_TARGETS or env.GetOption("clean") :

myenv.WindowsBundle("Slimber", resources = {}, qtlibs = ["QtCore4", "QtGui4"])

myenv.Append(NSIS_OPTIONS = [

"/DmsvccRedistributableDir=\"" + env["vcredist"] + "\"",

"/DbuildDate=" + datetime.date.today().strftime("%Y%m%d")

])

SLUIFT_LUA_FUNCTION(JID, escape_node) {

lua_pushstring(L, JID::getEscapedNode(Lua::checkString(L, 1)).c_str());

return 1;

}

/*******************************************************************************

* Base64 Functions

******************************************************************************/

SLUIFT_LUA_FUNCTION(Base64, encode) {

if (!lua_isstring(L, 1)) {

throw Lua::Exception("Expected string");

}

size_t len;

const char* data = lua_tolstring(L, 1, &len);

lua_pushstring(L, Base64::encode(createByteArray(data, len)).c_str());

return 1;

}

SLUIFT_LUA_FUNCTION(Base64, decode) {

if (!lua_isstring(L, 1)) {

throw Lua::Exception("Expected string");

}

ByteArray result = Base64::decode(lua_tostring(L, 1));

lua_pushlstring(L, reinterpret_cast<char*>(vecptr(result)), result.size());

return 1;

}

/*******************************************************************************

* IDN Functions

******************************************************************************/

SLUIFT_LUA_FUNCTION(IDN, encode) {

IDNConverter* converter = Sluift::globals.networkFactories.getIDNConverter();

return 1;

}

SLUIFT_LUA_FUNCTION(IDN, stringprep) {

IDNConverter* converter = Sluift::globals.networkFactories.getIDNConverter();

IDNConverter::StringPrepProfile profile;

std::string profileString = Lua::checkString(L, 2);

if (profileString == "nameprep") {

profile = IDNConverter::NamePrep;

}

else if (profileString == "xmpp_nodeprep") {

profile = IDNConverter::XMPPNodePrep;

}

else if (profileString == "xmpp_resourceprep") {

profile = IDNConverter::XMPPResourcePrep;

}

else if (profileString == "saslprep") {

profile = IDNConverter::SASLPrep;

}

else {

throw Lua::Exception("Invalid profile");

}

try {

lua_pushstring(L, converter->getStringPrepared(Lua::checkString(L, 1), profile).c_str());

}

catch (const std::exception&) {

throw Lua::Exception("Error");

}

return 1;

}

/*******************************************************************************

* iTunes Functions

******************************************************************************/

icuResult.resize(numeric_cast<size_t>(icuResultLength));

}

if (U_FAILURE(status)) {

return std::vector<char, SafeAllocator<char> >();

}

icuResult.resize(numeric_cast<size_t>(icuResultLength));

return convertToArray(icuResult);

}

}

namespace Swift {

std::string ICUConverter::getStringPrepared(const std::string& s, StringPrepProfile profile) {

if (s.empty()) {

return "";

}

std::vector<char, SafeAllocator<char> > preparedData = getStringPreparedDetail(s, profile);

if (preparedData.empty()) {

throw std::exception();

}

return std::string(vecptr(preparedData));

}

SafeByteArray ICUConverter::getStringPrepared(const SafeByteArray& s, StringPrepProfile profile) {

if (s.empty()) {

return SafeByteArray();

}

std::vector<char, SafeAllocator<char> > preparedData = getStringPreparedDetail(s, profile);

if (preparedData.empty()) {

throw std::exception();

}

return createSafeByteArray(reinterpret_cast<const char*>(vecptr(preparedData)));

}

UErrorCode status = U_ZERO_ERROR;

ICUString icuInput = convertToICUString(domain);

ICUString icuResult;

icuResult.resize(icuInput.size());

UParseError parseError;

if (status == U_BUFFER_OVERFLOW_ERROR) {

status = U_ZERO_ERROR;

icuResult.resize(numeric_cast<size_t>(icuResultLength));

}

if (U_FAILURE(status)) {

}

icuResult.resize(numeric_cast<size_t>(icuResultLength));

return convertToString(icuResult);

}

}

/*

* Copyright (c) 2012-2013 Remko Tronçon

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <string>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/IDN/IDNConverter.h>

namespace Swift {

class SWIFTEN_API ICUConverter : public IDNConverter {

public:

virtual std::string getStringPrepared(const std::string& s, StringPrepProfile profile) SWIFTEN_OVERRIDE;

virtual SafeByteArray getStringPrepared(const SafeByteArray& s, StringPrepProfile profile) SWIFTEN_OVERRIDE;

};

}

/*

* Copyright (c) 2013 Remko Tronçon

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <string>

#include <Swiften/Base/API.h>

#include <Swiften/Base/SafeByteArray.h>

namespace Swift {

class SWIFTEN_API IDNConverter {

public:

virtual ~IDNConverter();

enum StringPrepProfile {

NamePrep,

XMPPNodePrep,

XMPPResourcePrep,

SASLPrep

};

virtual std::string getStringPrepared(const std::string& s, StringPrepProfile profile) = 0;

virtual SafeByteArray getStringPrepared(const SafeByteArray& s, StringPrepProfile profile) = 0;

// Thread-safe

};

}

assert(false);

return 0;

}

template<typename StringType, typename ContainerType>

ContainerType getStringPreparedInternal(const StringType& s, IDNConverter::StringPrepProfile profile) {

ContainerType input(s.begin(), s.end());

input.resize(MAX_STRINGPREP_SIZE);

if (stringprep(&input[0], MAX_STRINGPREP_SIZE, static_cast<Stringprep_profile_flags>(0), getLibIDNProfile(profile)) == 0) {

return input;

}

else {

return ContainerType();

}

}

}

namespace Swift {

std::string LibIDNConverter::getStringPrepared(const std::string& s, StringPrepProfile profile) {

std::vector<char> preparedData = getStringPreparedInternal< std::string, std::vector<char> >(s, profile);

if (preparedData.empty()) {

throw std::exception();

}

return std::string(vecptr(preparedData));

}

SafeByteArray LibIDNConverter::getStringPrepared(const SafeByteArray& s, StringPrepProfile profile) {

std::vector<char, SafeAllocator<char> > preparedData = getStringPreparedInternal<SafeByteArray, std::vector<char, SafeAllocator<char> > >(s, profile);

if (preparedData.empty()) {

throw std::exception();

}

return createSafeByteArray(reinterpret_cast<const char*>(vecptr(preparedData)));

}

char* output;

std::string result(output);

free(output);

return result;

}

else {

}

}

}

/*

* Copyright (c) 2012-2013 Remko Tronçon

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <string>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/IDN/IDNConverter.h>

namespace Swift {

class SWIFTEN_API LibIDNConverter : public IDNConverter {

public:

virtual std::string getStringPrepared(const std::string& s, StringPrepProfile profile) SWIFTEN_OVERRIDE;

virtual SafeByteArray getStringPrepared(const SafeByteArray& s, StringPrepProfile profile) SWIFTEN_OVERRIDE;

};

}

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

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

*/

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include <boost/shared_ptr.hpp>

#include <Swiften/IDN/IDNConverter.h>

#include <Swiften/IDN/PlatformIDNConverter.h>

using namespace Swift;

class IDNConverterTest : public CppUnit::TestFixture {

CPPUNIT_TEST_SUITE(IDNConverterTest);

CPPUNIT_TEST(testStringPrep);

CPPUNIT_TEST(testStringPrep_Empty);

CPPUNIT_TEST(testGetEncoded);

CPPUNIT_TEST(testGetEncoded_International);

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

testling = boost::shared_ptr<IDNConverter>(PlatformIDNConverter::create());

}

void testStringPrep() {

std::string result = testling->getStringPrepared("tron\xc3\x87on", IDNConverter::NamePrep);

CPPUNIT_ASSERT_EQUAL(std::string("tron\xc3\xa7on"), result);

}

void testStringPrep_Empty() {

CPPUNIT_ASSERT_EQUAL(std::string(""), testling->getStringPrepared("", IDNConverter::NamePrep));

CPPUNIT_ASSERT_EQUAL(std::string(""), testling->getStringPrepared("", IDNConverter::XMPPNodePrep));

CPPUNIT_ASSERT_EQUAL(std::string(""), testling->getStringPrepared("", IDNConverter::XMPPResourcePrep));

}

void testGetEncoded() {

}

void testGetEncoded_International() {

}

private:

boost::shared_ptr<IDNConverter> testling;

};

CPPUNIT_TEST_SUITE_REGISTRATION(IDNConverterTest);

nameprepAndSetComponents(node, domain, "");

}

JID::JID(const std::string& node, const std::string& domain, const std::string& resource) : valid_(true), hasResource_(true) {

nameprepAndSetComponents(node, domain, resource);

}

void JID::initializeFromString(const std::string& jid) {

if (String::beginsWith(jid, '@')) {

valid_ = false;

return;

}

std::string bare, resource;

size_t slashIndex = jid.find('/');

if (slashIndex != jid.npos) {

hasResource_ = true;

bare = jid.substr(0, slashIndex);

resource = jid.substr(slashIndex + 1, jid.npos);

}

else {

hasResource_ = false;

bare = jid;

}

std::pair<std::string,std::string> nodeAndDomain = String::getSplittedAtFirst(bare, '@');

if (nodeAndDomain.second.empty()) {

nameprepAndSetComponents("", nodeAndDomain.first, resource);

}

else {

nameprepAndSetComponents(nodeAndDomain.first, nodeAndDomain.second, resource);

}

}

void JID::nameprepAndSetComponents(const std::string& node, const std::string& domain, const std::string& resource) {

valid_ = false;

return;

}

#ifndef SWIFTEN_CACHE_JID_PREP

node_ = idnConverter->getStringPrepared(node, IDNConverter::XMPPNodePrep);

domain_ = idnConverter->getStringPrepared(domain, IDNConverter::NamePrep);

resource_ = idnConverter->getStringPrepared(resource, IDNConverter::XMPPResourcePrep);

#else

boost::mutex::scoped_lock lock(namePrepCacheMutex);

std::pair<PrepCache::iterator, bool> r;

r = nodePrepCache.insert(std::make_pair(node, std::string()));

if (r.second) {

try {

r.first->second = idnConverter->getStringPrepared(node, IDNConverter::XMPPNodePrep);

}

catch (...) {

nodePrepCache.erase(r.first);

valid_ = false;

return;

}

}

node_ = r.first->second;

r = domainPrepCache.insert(std::make_pair(domain, std::string()));

if (r.second) {

try {

r.first->second = idnConverter->getStringPrepared(domain, IDNConverter::NamePrep);

}

catch (...) {

domainPrepCache.erase(r.first);

valid_ = false;

return;

}

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

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

*/

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include <Swiften/JID/JID.h>

using namespace Swift;

class JIDTest : public CppUnit::TestFixture

{

CPPUNIT_TEST_SUITE(JIDTest);

CPPUNIT_TEST(testConstructorWithString);

CPPUNIT_TEST(testConstructorWithString_NoResource);

CPPUNIT_TEST(testConstructorWithString_NoNode);

CPPUNIT_TEST(testConstructorWithString_EmptyResource);

CPPUNIT_TEST(testConstructorWithString_OnlyDomain);

CPPUNIT_TEST(testConstructorWithString_UpperCaseNode);

CPPUNIT_TEST(testConstructorWithString_UpperCaseDomain);

CPPUNIT_TEST(testConstructorWithString_UpperCaseResource);

CPPUNIT_TEST(testConstructorWithString_EmptyNode);

CPPUNIT_TEST(testConstructorWithString_IllegalResource);

CPPUNIT_TEST(testConstructorWithString_SpacesInNode);

CPPUNIT_TEST(testConstructorWithStrings);

CPPUNIT_TEST(testConstructorWithStrings_EmptyDomain);

CPPUNIT_TEST(testIsBare);

CPPUNIT_TEST(testIsBare_NotBare);

CPPUNIT_TEST(testToBare);

CPPUNIT_TEST(testToBare_EmptyNode);

CPPUNIT_TEST(testToBare_EmptyResource);

CPPUNIT_TEST(testToString);

CPPUNIT_TEST(testToString_EmptyNode);

CPPUNIT_TEST(testToString_EmptyResource);

CPPUNIT_TEST(testToString_NoResource);

CPPUNIT_TEST(testCompare_SmallerNode);

CPPUNIT_TEST(testCompare_LargerNode);

CPPUNIT_TEST(testCompare_SmallerDomain);

CPPUNIT_TEST(testCompare_LargerDomain);

CPPUNIT_TEST(testCompare_SmallerResource);

CPPUNIT_TEST(testCompare_LargerResource);

CPPUNIT_TEST(testCompare_Equal);

CPPUNIT_TEST(testCompare_EqualWithoutResource);

CPPUNIT_TEST(testCompare_NoResourceAndEmptyResource);

CPPUNIT_TEST(testCompare_EmptyResourceAndNoResource);

CPPUNIT_TEST(testEquals);

CPPUNIT_TEST(testEquals_NotEqual);

CPPUNIT_TEST(testEquals_WithoutResource);

CPPUNIT_TEST(testSmallerThan);

CPPUNIT_TEST(testSmallerThan_Equal);

CPPUNIT_TEST(testSmallerThan_Larger);

CPPUNIT_TEST(testHasResource);

CPPUNIT_TEST(testHasResource_NoResource);

void testConstructorWithString_NoResource() {

JID testling("foo@bar");

CPPUNIT_ASSERT_EQUAL(std::string("foo"), testling.getNode());

CPPUNIT_ASSERT_EQUAL(std::string("bar"), testling.getDomain());

CPPUNIT_ASSERT_EQUAL(std::string(""), testling.getResource());

CPPUNIT_ASSERT(testling.isBare());

}

void testConstructorWithString_EmptyResource() {

JID testling("bar/");

CPPUNIT_ASSERT(testling.isValid());

CPPUNIT_ASSERT(!testling.isBare());

}

void testConstructorWithString_NoNode() {

JID testling("bar/baz");

CPPUNIT_ASSERT_EQUAL(std::string(""), testling.getNode());

CPPUNIT_ASSERT_EQUAL(std::string("bar"), testling.getDomain());

CPPUNIT_ASSERT_EQUAL(std::string("baz"), testling.getResource());

CPPUNIT_ASSERT(!testling.isBare());

}

void testConstructorWithString_OnlyDomain() {

JID testling("bar");

CPPUNIT_ASSERT_EQUAL(std::string(""), testling.getNode());

CPPUNIT_ASSERT_EQUAL(std::string("bar"), testling.getDomain());

CPPUNIT_ASSERT_EQUAL(std::string(""), testling.getResource());

CPPUNIT_ASSERT(testling.isBare());

}

void testConstructorWithString_UpperCaseNode() {

JID testling("Fo\xCE\xA9@bar");

CPPUNIT_ASSERT_EQUAL(std::string("fo\xCF\x89"), testling.getNode());

CPPUNIT_ASSERT_EQUAL(std::string("bar"), testling.getDomain());

}

void testConstructorWithString_UpperCaseDomain() {

JID testling("Fo\xCE\xA9");

CPPUNIT_ASSERT_EQUAL(std::string("fo\xCF\x89"), testling.getDomain());

}

void testConstructorWithString_UpperCaseResource() {

JID testling("bar/Fo\xCE\xA9");

CPPUNIT_ASSERT_EQUAL(testling.getResource(), std::string("Fo\xCE\xA9"));

}

void testConstructorWithString_EmptyNode() {

JID testling("@bar");

CPPUNIT_ASSERT(!testling.isValid());

}

void testConstructorWithString_IllegalResource() {

JID testling("foo@bar.com/\xd8\xb1\xd9\x85\xd9\x82\xd9\x87\x20\xd8\xaa\xd8\xb1\xd9\x86\xd8\xb3\x20");

CPPUNIT_ASSERT(!testling.isValid());

}

void testConstructorWithString_SpacesInNode() {

CPPUNIT_ASSERT(!JID(" alice@wonderland.lit").isValid());

CPPUNIT_ASSERT(!JID("alice @wonderland.lit").isValid());

}

/*

* Copyright (c) 2012 Kevin Smith

* Licensed under the GNU General Public License v3.

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

*/

#include <Swiften/Network/CachingDomainNameResolver.h>

#include <boost/smart_ptr/make_shared.hpp>

namespace Swift {

CachingDomainNameResolver::CachingDomainNameResolver(DomainNameResolver* realResolver, EventLoop*) : realResolver(realResolver) {

}

CachingDomainNameResolver::~CachingDomainNameResolver() {

}

//TODO: Cache

}

DomainNameAddressQuery::ref CachingDomainNameResolver::createAddressQuery(const std::string& name) {

//TODO: Cache

return realResolver->createAddressQuery(name);

}

}

/*

* Copyright (c) 2012 Kevin Smith

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <Swiften/Network/DomainNameResolver.h>

#include <Swiften/Network/StaticDomainNameResolver.h>

/*

* FIXME: Does not do any caching yet.

*/

namespace Swift {

class EventLoop;

class CachingDomainNameResolver : public DomainNameResolver {

public:

CachingDomainNameResolver(DomainNameResolver* realResolver, EventLoop* eventLoop);

~CachingDomainNameResolver();

virtual DomainNameAddressQuery::ref createAddressQuery(const std::string& name);

private:

DomainNameResolver* realResolver;

};

}

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

*/

#include <Swiften/Network/Connector.h>

#include <boost/bind.hpp>

#include <iostream>

#include <Swiften/Network/ConnectionFactory.h>

#include <Swiften/Network/DomainNameResolver.h>

#include <Swiften/Network/DomainNameAddressQuery.h>

#include <Swiften/Network/TimerFactory.h>

#include <Swiften/Base/Log.h>

namespace Swift {

Connector::Connector(const std::string& hostname, int port, const boost::optional<std::string>& serviceLookupPrefix, DomainNameResolver* resolver, ConnectionFactory* connectionFactory, TimerFactory* timerFactory) : hostname(hostname), port(port), serviceLookupPrefix(serviceLookupPrefix), resolver(resolver), connectionFactory(connectionFactory), timerFactory(timerFactory), timeoutMilliseconds(0), queriedAllServices(true), foundSomeDNS(false) {

}

void Connector::setTimeoutMilliseconds(int milliseconds) {

timeoutMilliseconds = milliseconds;

}

void Connector::start() {

SWIFT_LOG(debug) << "Starting connector for " << hostname << std::endl;

//std::cout << "Connector::start()" << std::endl;

assert(!currentConnection);

assert(!serviceQuery);

assert(!timer);

queriedAllServices = false;

if (timeoutMilliseconds > 0) {

timer = timerFactory->createTimer(timeoutMilliseconds);

timer->onTick.connect(boost::bind(&Connector::handleTimeout, shared_from_this()));

}

if (serviceLookupPrefix) {

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

serviceQuery->run();

}

else {

queryAddress(hostname);

}

}

void Connector::stop() {

finish(boost::shared_ptr<Connection>());

}

void Connector::queryAddress(const std::string& hostname) {

assert(!addressQuery);

addressQuery = resolver->createAddressQuery(hostname);

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

addressQuery->run();

}

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

SWIFT_LOG(debug) << result.size() << " SRV result(s)" << std::endl;

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

serviceQuery.reset();

if (!serviceQueryResults.empty()) {

foundSomeDNS = true;

}

tryNextServiceOrFallback();

}

void Connector::tryNextServiceOrFallback() {

if (queriedAllServices) {

SWIFT_LOG(debug) << "Queried all services" << std::endl;

finish(boost::shared_ptr<Connection>());

}

else if (serviceQueryResults.empty()) {

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <string>

#include <Swiften/Base/API.h>

namespace Swift {

class DomainNameServiceQuery;

class DomainNameAddressQuery;

class SWIFTEN_API DomainNameResolver {

public:

virtual ~DomainNameResolver();

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

};

}

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

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

*/

#include <Swiften/Network/PlatformDomainNameAddressQuery.h>

#include <boost/asio/ip/tcp.hpp>

#include <Swiften/Network/PlatformDomainNameResolver.h>

#include <Swiften/EventLoop/EventLoop.h>

namespace Swift {

}

void PlatformDomainNameAddressQuery::run() {

getResolver()->addQueryToQueue(shared_from_this());

}

void PlatformDomainNameAddressQuery::runBlocking() {

//std::cout << "PlatformDomainNameResolver::doRun()" << std::endl;

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

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

try {

//std::cout << "PlatformDomainNameResolver::doRun(): Resolving" << std::endl;

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

//std::cout << "PlatformDomainNameResolver::doRun(): Resolved" << std::endl;

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

//std::cout << "PlatformDomainNameResolver::doRun(): Error 1" << std::endl;

emitError();

}

else {

std::vector<HostAddress> results;

for ( ; endpointIterator != boost::asio::ip::tcp::resolver::iterator(); ++endpointIterator) {

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

results.push_back(address.is_v4() ? HostAddress(&address.to_v4().to_bytes()[0], 4) : HostAddress(&address.to_v6().to_bytes()[0], 16));

}

//std::cout << "PlatformDomainNameResolver::doRun(): Success" << std::endl;

eventLoop->postEvent(

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

shared_from_this());

}

}

catch (...) {

//std::cout << "PlatformDomainNameResolver::doRun(): Error 2" << std::endl;

emitError();

}

}

void PlatformDomainNameAddressQuery::emitError() {

eventLoop->postEvent(boost::bind(boost::ref(onResult), std::vector<HostAddress>(), boost::optional<DomainNameResolveError>(DomainNameResolveError())), shared_from_this());

}

}

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <boost/asio/io_service.hpp>

#include <boost/enable_shared_from_this.hpp>

#include <Swiften/Network/DomainNameAddressQuery.h>

#include <Swiften/Network/PlatformDomainNameQuery.h>

#include <Swiften/EventLoop/EventOwner.h>

#include <string>

namespace Swift {

class PlatformDomainNameResolver;

class EventLoop;

class PlatformDomainNameAddressQuery : public DomainNameAddressQuery, public PlatformDomainNameQuery, public boost::enable_shared_from_this<PlatformDomainNameAddressQuery>, public EventOwner {

public:

void run();

private:

void runBlocking();

void emitError();

private:

boost::asio::io_service ioService;

std::string hostname;

EventLoop* eventLoop;

};

}

#include <Swiften/Network/PlatformDomainNameResolver.h>

// 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/thread.hpp>

#include <algorithm>

#include <string>

#include <Swiften/IDN/IDNConverter.h>

#include <Swiften/Network/HostAddress.h>

#include <Swiften/EventLoop/EventLoop.h>

#include <Swiften/Network/HostAddressPort.h>

#include <Swiften/Network/DomainNameAddressQuery.h>

#include <Swiften/Network/PlatformDomainNameAddressQuery.h>

using namespace Swift;

namespace Swift {

PlatformDomainNameResolver::PlatformDomainNameResolver(IDNConverter* idnConverter, EventLoop* eventLoop) : idnConverter(idnConverter), eventLoop(eventLoop), stopRequested(false) {

thread = new boost::thread(boost::bind(&PlatformDomainNameResolver::run, this));

}

PlatformDomainNameResolver::~PlatformDomainNameResolver() {

stopRequested = true;

addQueryToQueue(boost::shared_ptr<PlatformDomainNameQuery>());

thread->join();

delete thread;

}

}

boost::shared_ptr<DomainNameAddressQuery> PlatformDomainNameResolver::createAddressQuery(const std::string& name) {

return boost::shared_ptr<DomainNameAddressQuery>(new PlatformDomainNameAddressQuery(idnConverter->getIDNAEncoded(name), eventLoop, this));

}

void PlatformDomainNameResolver::run() {

while (!stopRequested) {

PlatformDomainNameQuery::ref query;

{

boost::unique_lock<boost::mutex> lock(queueMutex);

while (queue.empty()) {

queueNonEmpty.wait(lock);

}

query = queue.front();

queue.pop_front();

}

// Check whether we don't have a non-null query (used to stop the

// resolver)

if (query) {

query->runBlocking();

}

}

}

void PlatformDomainNameResolver::addQueryToQueue(PlatformDomainNameQuery::ref query) {

{

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

queue.push_back(query);

}

queueNonEmpty.notify_one();

}

}

/*

* Copyright (c) 2010-2013 Remko Tronçon

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <deque>

#include <boost/thread/thread.hpp>

#include <boost/thread/mutex.hpp>

#include <boost/thread/condition_variable.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Network/DomainNameResolver.h>

#include <Swiften/Network/PlatformDomainNameQuery.h>

#include <Swiften/Network/DomainNameServiceQuery.h>

#include <Swiften/Network/DomainNameAddressQuery.h>

namespace Swift {

class IDNConverter;

class EventLoop;

class SWIFTEN_API PlatformDomainNameResolver : public DomainNameResolver {

public:

PlatformDomainNameResolver(IDNConverter* idnConverter, EventLoop* eventLoop);

~PlatformDomainNameResolver();

virtual DomainNameAddressQuery::ref createAddressQuery(const std::string& name);

private:

void run();

void addQueryToQueue(PlatformDomainNameQuery::ref);

private:

friend class PlatformDomainNameServiceQuery;

friend class PlatformDomainNameAddressQuery;

IDNConverter* idnConverter;

EventLoop* eventLoop;

bool stopRequested;

boost::thread* thread;

std::deque<PlatformDomainNameQuery::ref> queue;

boost::mutex queueMutex;

boost::condition_variable queueNonEmpty;

};

}

#include <boost/asio.hpp>

#include <Swiften/Network/PlatformDomainNameServiceQuery.h>

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

#include <Swiften/Base/Platform.h>

#include <stdlib.h>

#include <boost/numeric/conversion/cast.hpp>

#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/EventLoop.h>

#include <Swiften/Base/foreach.h>

#include <Swiften/Base/BoostRandomGenerator.h>

#include <Swiften/Base/Log.h>

#include <Swiften/Network/PlatformDomainNameResolver.h>

using namespace Swift;

namespace Swift {

}

void PlatformDomainNameServiceQuery::run() {

getResolver()->addQueryToQueue(shared_from_this());

}

void PlatformDomainNameServiceQuery::runBlocking() {

SWIFT_LOG(debug) << "Querying " << service << std::endl;

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.c_str(), 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) {

DomainNameServiceQuery::Result 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

// Make sure we reinitialize the domain list every time

res_init();

/*

* Copyright (c) 2010-2013 Remko Tronçon

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <boost/enable_shared_from_this.hpp>

#include <Swiften/Network/DomainNameServiceQuery.h>

#include <Swiften/EventLoop/EventOwner.h>

#include <string>

#include <Swiften/Network/PlatformDomainNameQuery.h>

namespace Swift {

class EventLoop;

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

public:

virtual void run();

private:

void runBlocking();

void emitError();

private:

EventLoop* eventLoop;

std::string service;

};

}

}

};

namespace Swift {

StaticDomainNameResolver::StaticDomainNameResolver(EventLoop* eventLoop) : eventLoop(eventLoop), isResponsive(true), owner(new StaticDomainNameResolverEventOwner()) {

}

StaticDomainNameResolver::~StaticDomainNameResolver() {

eventLoop->removeEventsFromOwner(owner);

}

void StaticDomainNameResolver::addAddress(const std::string& domain, const HostAddress& address) {

addresses[domain].push_back(address);

}

void StaticDomainNameResolver::addService(const std::string& service, const DomainNameServiceQuery::Result& result) {

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

}

void StaticDomainNameResolver::addXMPPClientService(const std::string& domain, const HostAddressPort& address) {

static int hostid = 0;

std::string hostname(std::string("host-") + boost::lexical_cast<std::string>(hostid));

hostid++;

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

addAddress(hostname, address.getAddress());

}

void StaticDomainNameResolver::addXMPPClientService(const std::string& domain, const std::string& hostname, int port) {

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

}

}

boost::shared_ptr<DomainNameAddressQuery> StaticDomainNameResolver::createAddressQuery(const std::string& name) {

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

}

}

#include <Swiften/Network/DomainNameServiceQuery.h>

#include <Swiften/Network/DomainNameAddressQuery.h>

#include <Swiften/EventLoop/EventLoop.h>

namespace Swift {

class SWIFTEN_API StaticDomainNameResolver : public DomainNameResolver {

public:

typedef std::map<std::string, std::vector<HostAddress> > AddressesMap;

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

public:

StaticDomainNameResolver(EventLoop* eventLoop);

~StaticDomainNameResolver();

void addAddress(const std::string& domain, const HostAddress& address);

void addService(const std::string& service, const DomainNameServiceQuery::Result& result);

void addXMPPClientService(const std::string& domain, const HostAddressPort&);

void addXMPPClientService(const std::string& domain, const std::string& host, int port);

const AddressesMap& getAddresses() const {

return addresses;

}

const ServicesCollection& getServices() const {

return services;

}

bool getIsResponsive() const {

return isResponsive;

}

void setIsResponsive(bool b) {

isResponsive = b;

}

virtual boost::shared_ptr<DomainNameAddressQuery> createAddressQuery(const std::string& name);

private:

EventLoop* eventLoop;

bool isResponsive;

AddressesMap addresses;

ServicesCollection services;

boost::shared_ptr<EventOwner> owner;

};

}

query->run();

waitForResults();

CPPUNIT_ASSERT(!addressQueryError);

CPPUNIT_ASSERT(std::find(addressQueryResult.begin(), addressQueryResult.end(), HostAddress("127.0.0.1")) != 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() {

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(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(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(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(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 std::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 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;

}

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;

boost::shared_ptr<IDNConverter> idnConverter;

boost::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;

};

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

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

*/

#include <Swiften/TLS/ServerIdentityVerifier.h>

#include <boost/algorithm/string.hpp>

#include <Swiften/Base/foreach.h>

#include <Swiften/IDN/IDNConverter.h>

namespace Swift {

domain = jid.getDomain();

}

bool ServerIdentityVerifier::certificateVerifies(Certificate::ref certificate) {

bool hasSAN = false;

if (certificate == NULL) {

return false;

}

// DNS names

std::vector<std::string> dnsNames = certificate->getDNSNames();

foreach (const std::string& dnsName, dnsNames) {

if (matchesDomain(dnsName)) {

return true;

}

}

hasSAN |= !dnsNames.empty();

// SRV names

std::vector<std::string> srvNames = certificate->getSRVNames();

foreach (const std::string& srvName, srvNames) {

// Only match SRV names that begin with the service; this isn't required per

// spec, but we're being purist about this.

if (boost::starts_with(srvName, "_xmpp-client.") && matchesDomain(srvName.substr(std::string("_xmpp-client.").size(), srvName.npos))) {

return true;

}

}

hasSAN |= !srvNames.empty();

// XmppAddr

std::vector<std::string> xmppAddresses = certificate->getXMPPAddresses();

foreach (const std::string& xmppAddress, xmppAddresses) {

if (matchesAddress(xmppAddress)) {

return true;

}

}

hasSAN |= !xmppAddresses.empty();

// CommonNames. Only check this if there was no SAN (according to spec).

if (!hasSAN) {

std::vector<std::string> commonNames = certificate->getCommonNames();

foreach (const std::string& commonName, commonNames) {

if (matchesDomain(commonName)) {

return true;

}

}

}

return false;

}

bool ServerIdentityVerifier::matchesDomain(const std::string& s) const {

if (boost::starts_with(s, "*.")) {

std::string matchString(s.substr(2, s.npos));

std::string matchDomain = encodedDomain;

size_t dotIndex = matchDomain.find('.');

if (dotIndex != matchDomain.npos) {

matchDomain = matchDomain.substr(dotIndex + 1, matchDomain.npos);

}

return matchString == matchDomain;

}

else {

return s == encodedDomain;

}

}

bool ServerIdentityVerifier::matchesAddress(const std::string& s) const {

return s == domain;

}

}

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <string>

#include <Swiften/Base/API.h>

#include <Swiften/JID/JID.h>

#include <Swiften/TLS/Certificate.h>

namespace Swift {

class IDNConverter;

class SWIFTEN_API ServerIdentityVerifier {

public:

ServerIdentityVerifier(const JID& jid, IDNConverter* idnConverter);

bool certificateVerifies(Certificate::ref);

private:

bool matchesDomain(const std::string&) const ;

bool matchesAddress(const std::string&) const;

private:

std::string domain;

std::string encodedDomain;

};

}