public:

void setUp() {

eventLoop = new DummyEventLoop();

resolver = new StaticDomainNameResolver(eventLoop);

connectionFactory = new MockConnectionFactory(eventLoop);

#include <boost/bind.hpp>

#include <Swiften/Base/Log.h>

#include <Swiften/Elements/JingleS5BTransportPayload.h>

#include <Swiften/FileTransfer/SOCKS5BytestreamProxiesManager.h>

#include <Swiften/FileTransfer/SOCKS5BytestreamServerManager.h>

if (options_.isDirectAllowed()) {

// get direct candidates

std::vector<HostAddressPort> directCandidates = s5bServerManager->getHostAddressPorts();

if (addressPort.getAddress().getRawAddress().is_v6() &&

addressPort.getAddress().getRawAddress().to_v6().is_link_local()) {

continue;

if (options_.isAssistedAllowed()) {

// get assissted candidates

std::vector<HostAddressPort> assisstedCandidates = s5bServerManager->getAssistedHostAddressPorts();

JingleS5BTransportPayload::Candidate candidate;

candidate.type = JingleS5BTransportPayload::Candidate::AssistedType;

candidate.jid = ownJID;

}

if (options_.isProxiedAllowed() && s5bProxy->getOrDiscoverS5BProxies().is_initialized()) {

if (proxy->getStreamHost()) { // FIXME: Added this test, because there were cases where this wasn't initialized. Investigate this. (Remko)

JingleS5BTransportPayload::Candidate candidate;

candidate.type = JingleS5BTransportPayload::Candidate::ProxyType;

candidate.jid = (*proxy->getStreamHost()).jid;

}

}

}

#include <boost/bind.hpp>

#include <Swiften/Base/Log.h>

#include <Swiften/FileTransfer/SOCKS5BytestreamClientSession.h>

#include <Swiften/Network/ConnectionFactory.h>

#include <Swiften/Network/DomainNameAddressQuery.h>

proxyFinder_->stop();

}

session.second->onSessionReady.disconnect(boost::bind(&SOCKS5BytestreamProxiesManager::handleProxySessionReady, this,sessionsForID.first, session.first, session.second, _1));

session.second->onFinished.disconnect(boost::bind(&SOCKS5BytestreamProxiesManager::handleProxySessionFinished, this, sessionsForID.first, session.first, session.second, _1));

}

void SOCKS5BytestreamProxiesManager::addS5BProxy(S5BProxyRequest::ref proxy) {

if (proxy) {

if (!localS5BProxies_) {

localS5BProxies_ = std::vector<S5BProxyRequest::ref>();

}

ProxyJIDClientSessionVector clientSessions;

if (localS5BProxies_) {

}

}

void SOCKS5BytestreamProxiesManager::handleProxiesFound(std::vector<S5BProxyRequest::ref> proxyHosts) {

proxyFinder_->onProxiesFound.disconnect(boost::bind(&SOCKS5BytestreamProxiesManager::handleProxiesFound, this, _1));

if (proxy) {

addS5BProxy(proxy);

onDiscoveredProxiesChanged();

}

}

else {

// generate proxy per returned address

S5BProxyRequest::StreamHost streamHost = proxy->getStreamHost().get();

S5BProxyRequest::ref proxyForAddress = std::make_shared<S5BProxyRequest>(*proxy);

streamHost.host = address.toString();

#include <boost/bind.hpp>

#include <Swiften/Base/Log.h>

#include <Swiften/FileTransfer/SOCKS5BytestreamServer.h>

#include <Swiften/FileTransfer/SOCKS5BytestreamServerPortForwardingUser.h>

#include <Swiften/FileTransfer/SOCKS5BytestreamServerResourceUser.h>

std::vector<HostAddressPort> result;

if (connectionServer) {

std::vector<NetworkInterface> networkInterfaces = networkEnvironment->getNetworkInterfaces();

result.push_back(HostAddressPort(address, connectionServerPort));

}

}

int port;

for (port = LISTEN_PORTS_BEGIN; port < LISTEN_PORTS_END; ++port) {

SWIFT_LOG(debug) << "Trying to start server on port " << port << std::endl;

boost::optional<ConnectionServer::Error> error = connectionServer->tryStart();

if (!error) {

break;

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

crypto = std::shared_ptr<CryptoProvider>(PlatformCryptoProvider::create());

void testConnect() {

std::shared_ptr<LinkLocalConnector>

testling(createConnector("rabbithole.local", 1234));

testling->connect();

eventLoop->processEvents();

void testConnect_UnableToConnect() {

std::shared_ptr<LinkLocalConnector>

testling(createConnector("rabbithole.local", 1234));

connection->setError(Connection::ReadError);

testling->connect();

testling->cancel();

eventLoop->processEvents();

eventLoop->processEvents();

CPPUNIT_ASSERT(FakeConnection::Disconnected == connection->state);

void testCancel_DuringConnect() {

std::shared_ptr<LinkLocalConnector>

testling(createConnector("rabbithole.local", 1234));

connection->setDelayConnect();

testling->connect();

eventLoop->processEvents();

assert(!serviceQuery);

assert(!timer);

queriedAllServices = false;

if (timeoutMilliseconds > 0) {

timer = timerFactory->createTimer(timeoutMilliseconds);

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

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

serviceQuery->run();

}

// hostname is already a valid address; skip name lookup.

foundSomeDNS = true;

tryNextAddress();

} else {

queryAddress(hostname);

address = address.substr(0, address.find(':'));

}

}

}

HostAddress::HostAddress() {

}

HostAddress::HostAddress(const unsigned char* address, size_t length) {

assert(length == 4 || length == 16);

if (length == 4) {

return address_ == localhost4 || address_ == localhost6;

}

}

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <string>

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

#include <Swiften/Base/API.h>

class SWIFTEN_API HostAddress {

public:

HostAddress();

HostAddress(const unsigned char* address, size_t length);

HostAddress(const boost::asio::ip::address& address);

bool isValid() const;

bool isLocalhost() const;

private:

boost::asio::ip::address address_;

};

#include <stdio.h>

#include <stdlib.h>

#include <iostream>

#include <utility>

#ifndef SWIFTEN_PLATFORM_IPHONE

#include <SystemConfiguration/SystemConfiguration.h>

#endif

}

if(host != "" && port != 0) {

}

}

}

return boost::optional<HostAddress>();

}

else {

}

}

timerFactory_(timerFactory),

proxyHost_(proxyHost),

proxyPort_(proxyPort),

connected_ = false;

}

boshDataRead.clear();

boshDataWritten.clear();

resolver = new StaticDomainNameResolver(eventLoop);

timerFactory = new DummyTimerFactory();

}

void testSession() {

to = "prosody.doomsong.co.uk";

path = "/http-bind/";

boshURL = URL("http", to, 5280, path);

private:

BOSHConnection::ref createTestling() {

Connector::ref connector = Connector::create("wonderland.lit", 5280, boost::optional<std::string>(), resolver, connectionFactory, timerFactory);

BOSHConnection::ref c = BOSHConnection::create(URL("http", "wonderland.lit", 5280, "/http-bind"), connector, &parserFactory, tlsContextFactory, TLSOptions());

c->onConnectFinished.connect(boost::bind(&BOSHConnectionTest::handleConnectFinished, this, _1));

public:

void setUp() {

error.reset();

eventLoop = new DummyEventLoop();

resolver = new StaticDomainNameResolver(eventLoop);

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

public:

void setUp() {

eventLoop = new DummyEventLoop();

resolver = new StaticDomainNameResolver(eventLoop);

connectionFactory = new MockConnectionFactory(eventLoop);

void testConnect_FirstAddressHostFails() {

Connector::ref testling(createConnector());

resolver->addXMPPClientService("foo.com", "host-foo.com", 1234);

resolver->addAddress("host-foo.com", address1);

resolver->addAddress("host-foo.com", address2);

Connector::ref testling(createConnector());

testling->setTimeoutMilliseconds(10);

resolver->addXMPPClientService("foo.com", "host-foo.com", 1234);

resolver->addAddress("host-foo.com", address2);

connectionFactory->isResponsive = false;

#include <Swiften/Base/Algorithm.h>

#include <Swiften/Base/Log.h>

#include <Swiften/EventLoop/DummyEventLoop.h>

#include <Swiften/Network/Connection.h>

#include <Swiften/Network/ConnectionFactory.h>

int statusCode = boost::lexical_cast<int>(statusLineFields[1]);

if (statusCode == 407) {

if (to_lower(field.first) == to_lower("Proxy-Authenticate")) {

if (field.second.size() >= 6 && field.second.substr(0, 6) == " NTLM ") {

filterResponseReturn.push_back(std::pair<std::string, std::string>("Proxy-Authorization", "NTLM TlRMTVNTUAADAAAAGAAYAHIAAAAYABgAigAAABIAEgBIAAAABgAGAFoAAAASABIVNTUAADAAYAAAABAAEACiAAAANYKI4gUBKAoAAAAPTABBAEIAUwBNAE8ASwBFADMAXwBxAGEATABBAEIAUwBNAE8ASwBFADMA0NKq8HYYhj8AAAAAAAAAAAAAAAAAAAAAOIiih3mR+AkyM4r99sy1mdFonCu2ILODro1WTTrJ4b4JcXEzUBA2Ig=="));

void setUp() {

proxyHost = "doo.bah";

proxyPort = 1234;

eventLoop = new DummyEventLoop();

resolver = new StaticDomainNameResolver(eventLoop);

resolver->addAddress(proxyHost, proxyHostAddress.getAddress());

void testConnect_SendsConnectRequest() {

HTTPConnectProxiedConnection::ref testling(createTestling());

CPPUNIT_ASSERT_EQUAL(createByteArray("CONNECT 2.2.2.2:2345 HTTP/1.1\r\n\r\n"), connectionFactory->connections[0]->dataWritten);

}

void testConnect_ReceiveConnectResponse() {

HTTPConnectProxiedConnection::ref testling(createTestling());

connectionFactory->connections[0]->onDataRead(createSafeByteArrayRef("HTTP/1.0 200 Connection established\r\n\r\n"));

eventLoop->processEvents();

void testConnect_ReceiveConnectChunkedResponse() {

HTTPConnectProxiedConnection::ref testling(createTestling());

connectionFactory->connections[0]->onDataRead(createSafeByteArrayRef("HTTP/1.0 "));

eventLoop->processEvents();

void testConnect_ReceiveMalformedConnectResponse() {

HTTPConnectProxiedConnection::ref testling(createTestling());

connectionFactory->connections[0]->onDataRead(createSafeByteArrayRef("FLOOP"));

eventLoop->processEvents();

void testConnect_ReceiveErrorConnectResponse() {

HTTPConnectProxiedConnection::ref testling(createTestling());

connectionFactory->connections[0]->onDataRead(createSafeByteArrayRef("HTTP/1.0 401 Unauthorized\r\n\r\n"));

eventLoop->processEvents();

void testConnect_ReceiveDataAfterConnect() {

HTTPConnectProxiedConnection::ref testling(createTestling());

connectionFactory->connections[0]->onDataRead(createSafeByteArrayRef("HTTP/1.0 200 Connection established\r\n\r\n"));

eventLoop->processEvents();

void testWrite_AfterConnect() {

HTTPConnectProxiedConnection::ref testling(createTestling());

connectionFactory->connections[0]->onDataRead(createSafeByteArrayRef("HTTP/1.0 200 Connection established\r\n\r\n"));

eventLoop->processEvents();

connectionFactory->connections[0]->dataWritten.clear();

void testDisconnect_AfterConnectRequest() {

HTTPConnectProxiedConnection::ref testling(createTestling());

testling->disconnect();

void testDisconnect_AfterConnect() {

HTTPConnectProxiedConnection::ref testling(createTestling());

connectionFactory->connections[0]->onDataRead(createSafeByteArrayRef("HTTP/1.0 200 Connection established\r\n\r\n"));

eventLoop->processEvents();

std::shared_ptr<ExampleHTTPTrafficFilter> httpTrafficFilter = std::make_shared<ExampleHTTPTrafficFilter>();

testling->setHTTPTrafficFilter(httpTrafficFilter);

// set a default response so the server response is answered by the traffic filter

httpTrafficFilter->filterResponseReturn.clear();

std::shared_ptr<ProxyAuthenticationHTTPTrafficFilter> httpTrafficFilter = std::make_shared<ProxyAuthenticationHTTPTrafficFilter>();

testling->setHTTPTrafficFilter(httpTrafficFilter);

// First HTTP CONNECT request assumes the proxy will work.

CPPUNIT_ASSERT_EQUAL(createByteArray("CONNECT 2.2.2.2:2345 HTTP/1.1\r\n"

public:

void testConstructor() {

}

void testConstructor_Invalid() {

}

void testConstructor_InvalidString() {

}

void testToString() {

#include <Swiften/Base/ByteArray.h>

#include <Swiften/Base/Log.h>

namespace Swift {

if(result == ERROR_SUCCESS) {

std::vector<std::string> proxies = String::split(byteArrayToString(dataBuffer), ';');

std::pair<std::string, std::string> protocolAndProxy;

if(proxy.find('=') != std::string::npos) {

protocolAndProxy = String::getSplittedAtFirst(proxy, '=');

SWIFT_LOG(debug) << "Found proxy: " << protocolAndProxy.first << " => " << protocolAndProxy.second << std::endl;

// .c_str() is needed as tmp.second can include a \0 char which will end in an exception of the lexical cast.

// with .c_str() the \0 will not be part of the string which is to be casted

port = boost::lexical_cast<int> (tmp.second.c_str());

}

catch(...) {

}

return ret;

DWORD data = 0;

ByteArray dataBuffer;

return ret;

result = RegQueryValueEx(hKey, "ProxyEnable", NULL, &dataType, NULL, &dataSize);

return ret;

dataBuffer.resize(dataSize);

result = RegQueryValueEx(hKey, "ProxyEnable", NULL, &dataType, reinterpret_cast<BYTE*>(vecptr(dataBuffer)), &dataSize);

return ret;

for(size_t t = 0; t < dataBuffer.size(); t++) {

data += static_cast<int> (dataBuffer[t]) * pow(256, static_cast<double>(t));

* See Documentation/Licenses/BSD-simplified.txt for more information.

*/

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Network/ProxyProvider.h>

namespace Swift {

try {

port = boost::lexical_cast<int>(attributes.getAttributeValue("port").get_value_or("-1"));

} catch(boost::bad_lexical_cast &) { }

candidate.jid = JID(attributes.getAttributeValue("jid").get_value_or(""));

int priority = -1;

try {

void JingleS5BTransportMethodPayloadParser::handleEndElement(const std::string&, const std::string&) {

--level;

}

void JingleS5BTransportMethodPayloadParser::handleCharacterData(const std::string&) {

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

candidate = s5bPayload->getCandidates()[0];

CPPUNIT_ASSERT_EQUAL(std::string("hft54dqy"), candidate.cid);

CPPUNIT_ASSERT_EQUAL(JID("romeo@montague.lit/orchard"), candidate.jid);

CPPUNIT_ASSERT_EQUAL(8257636, candidate.priority);

CPPUNIT_ASSERT_EQUAL(JingleS5BTransportPayload::Candidate::DirectType, candidate.type);

candidate = s5bPayload->getCandidates()[1];

CPPUNIT_ASSERT_EQUAL(std::string("hutr46fe"), candidate.cid);

CPPUNIT_ASSERT_EQUAL(JID("romeo@montague.lit/orchard"), candidate.jid);

CPPUNIT_ASSERT_EQUAL(8258636, candidate.priority);

CPPUNIT_ASSERT_EQUAL(JingleS5BTransportPayload::Candidate::DirectType, candidate.type);

}

candidate = s5bPayload->getCandidates()[0];

CPPUNIT_ASSERT_EQUAL(std::string("ht567dq"), candidate.cid);

CPPUNIT_ASSERT_EQUAL(JID("juliet@capulet.lit/balcony"), candidate.jid);

CPPUNIT_ASSERT_EQUAL(8257636, candidate.priority);

CPPUNIT_ASSERT_EQUAL(JingleS5BTransportPayload::Candidate::DirectType, candidate.type);

candidate = s5bPayload->getCandidates()[1];

CPPUNIT_ASSERT_EQUAL(std::string("hr65dqyd"), candidate.cid);

CPPUNIT_ASSERT_EQUAL(JID("juliet@capulet.lit/balcony"), candidate.jid);

CPPUNIT_ASSERT_EQUAL(7929856, candidate.priority);

CPPUNIT_ASSERT_EQUAL(JingleS5BTransportPayload::Candidate::AssistedType, candidate.type);

candidate = s5bPayload->getCandidates()[2];

CPPUNIT_ASSERT_EQUAL(std::string("grt654q2"), candidate.cid);

CPPUNIT_ASSERT_EQUAL(JID("juliet@capulet.lit/balcony"), candidate.jid);

CPPUNIT_ASSERT_EQUAL(8257606, candidate.priority);

CPPUNIT_ASSERT_EQUAL(JingleS5BTransportPayload::Candidate::DirectType, candidate.type);

}

}

void testIPv4Server() {

testling->onNewConnection.connect(boost::bind(&BoostConnectionServerTest::handleNewConnection, this, _1));

testling->start();

BoostConnection::ref clientTestling = BoostConnection::create(boostIOServiceThread_->getIOService(), eventLoop_);

clientTestling->onConnectFinished.connect(boost::bind(&BoostConnectionServerTest::handleConnectFinished, this, _1));

while (!connectFinished_) {

Swift::sleep(10);

}

void testIPv6Server() {

testling->onNewConnection.connect(boost::bind(&BoostConnectionServerTest::handleNewConnection, this, _1));

testling->start();

BoostConnection::ref clientTestling = BoostConnection::create(boostIOServiceThread_->getIOService(), eventLoop_);

clientTestling->onConnectFinished.connect(boost::bind(&BoostConnectionServerTest::handleConnectFinished, this, _1));

while (!connectFinished_) {

Swift::sleep(10);

}

void testIPv4IPv6DualStackServer() {

testling->onNewConnection.connect(boost::bind(&BoostConnectionServerTest::handleNewConnection, this, _1));

testling->start();

// Test IPv4.

BoostConnection::ref clientTestling = BoostConnection::create(boostIOServiceThread_->getIOService(), eventLoop_);

clientTestling->onConnectFinished.connect(boost::bind(&BoostConnectionServerTest::handleConnectFinished, this, _1));

while (!connectFinished_) {

Swift::sleep(10);

// Test IPv6.

clientTestling = BoostConnection::create(boostIOServiceThread_->getIOService(), eventLoop_);

clientTestling->onConnectFinished.connect(boost::bind(&BoostConnectionServerTest::handleConnectFinished, this, _1));

while (!connectFinished_) {

Swift::sleep(10);

}

void testIPv6DualStackServerPeerAddress() {

testling->onNewConnection.connect(boost::bind(&BoostConnectionServerTest::handleNewConnection, this, _1));

testling->start();

// Test IPv4.

BoostConnection::ref clientTestling = BoostConnection::create(boostIOServiceThread_->getIOService(), eventLoop_);

clientTestling->onConnectFinished.connect(boost::bind(&BoostConnectionServerTest::handleConnectFinished, this, _1));

while (!connectFinished_) {

Swift::sleep(10);

CPPUNIT_ASSERT_EQUAL(true, receivedNewConnection_);

// The IPv4 localhost mapped to a IPv6 address is expected here.

receivedNewConnection_ = false;

connectFinished_ = false;

// Test IPv6.

clientTestling = BoostConnection::create(boostIOServiceThread_->getIOService(), eventLoop_);

clientTestling->onConnectFinished.connect(boost::bind(&BoostConnectionServerTest::handleConnectFinished, this, _1));

while (!connectFinished_) {

Swift::sleep(10);

CPPUNIT_ASSERT_EQUAL(true, receivedNewConnection_);

// The IPv6 local host is expected here.

testling->stop();

}

void testDestructor() {

{

BoostConnection::ref testling(BoostConnection::create(boostIOServiceThread_->getIOService(), eventLoop_));

}

}

void testDestructor_PendingEvents() {

{

BoostConnection::ref testling(BoostConnection::create(boostIOServiceThread_->getIOService(), eventLoop_));

while (!eventLoop_->hasEvents()) {

Swift::sleep(10);

}

testling->onConnectFinished.connect(boost::bind(&BoostConnectionTest::doWrite, this, testling.get()));

testling->onDataRead.connect(boost::bind(&BoostConnectionTest::handleDataRead, this, _1));

testling->onDisconnected.connect(boost::bind(&BoostConnectionTest::handleDisconnected, this));

boost::posix_time::ptime start = second_clock::local_time();

while (receivedData_.empty() && ((second_clock::local_time() - start) < seconds(60))) {

testling->onConnectFinished.connect(boost::bind(&BoostConnectionTest::doWrite, this, testling.get()));

testling->onDataRead.connect(boost::bind(&BoostConnectionTest::handleDataRead, this, _1));

testling->onDisconnected.connect(boost::bind(&BoostConnectionTest::handleDisconnected, this));

boost::posix_time::ptime start = second_clock::local_time();

while (receivedData_.empty() && ((second_clock::local_time() - start) < seconds(60))) {

testling->onConnectFinished.connect(boost::bind(&BoostConnectionTest::handleConnectFinished, this));

testling->onDataRead.connect(boost::bind(&BoostConnectionTest::handleDataRead, this, _1));

testling->onDisconnected.connect(boost::bind(&BoostConnectionTest::handleDisconnected, this));

while (!connectFinished_) {

boostIOService_->run_one();

eventLoop_->processEvents();

waitForResults();

CPPUNIT_ASSERT(!addressQueryError);

}

void testResolveAddress_Parallel() {

JingleS5BTransportPayload::Candidate candidate1;

candidate1.cid = "hft54dqy";

candidate1.jid = JID("romeo@montague.lit/orchard");

candidate1.priority = 8257636;

candidate1.type = JingleS5BTransportPayload::Candidate::DirectType;

JingleS5BTransportPayload::Candidate candidate2;

candidate2.cid = "hutr46fe";

candidate2.jid = JID("romeo@montague.lit/orchard");

candidate2.priority = 8258636;

candidate2.type = JingleS5BTransportPayload::Candidate::DirectType;