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

+#include <boost/asio/placeholders.hpp>

+#include <boost/asio/write.hpp>

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

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

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

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

+#include <boost/asio/io_service.hpp>

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

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

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

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

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

+#include <boost/asio/io_service.hpp>

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

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

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

+#include <boost/asio/placeholders.hpp>

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

+#include <boost/asio/io_service.hpp>

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

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

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

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

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

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

+#include <boost/asio/io_service.hpp>

+#include <boost/thread/thread.hpp>

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

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

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

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

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

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

+#include <boost/bind.hpp>

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

+#include <boost/asio/io_service.hpp>

+#include <boost/asio/deadline_timer.hpp>

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

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

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

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

+#include <boost/asio/io_service.hpp>

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

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

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

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

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

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

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

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

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

+#include <boost/thread/thread.hpp>

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

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

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

+

+#include <boost/bind.hpp>

+#include <typeinfo>

+

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

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

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

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

+

+using namespace Swift;

+

+ChainedConnector::ChainedConnector(

+ const std::string& hostname,

+ DomainNameResolver* resolver,

+ const std::vector<ConnectionFactory*>& connectionFactories,

+ TimerFactory* timerFactory) :

+ hostname(hostname),

+ resolver(resolver),

+ connectionFactories(connectionFactories),

+ timerFactory(timerFactory),

+ timeoutMilliseconds(0) {

+}

+

+void ChainedConnector::setTimeoutMilliseconds(int milliseconds) {

+ timeoutMilliseconds = milliseconds;

+}

+

+void ChainedConnector::start() {

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

+

+ connectionFactoryQueue = std::deque<ConnectionFactory*>(connectionFactories.begin(), connectionFactories.end());

+ tryNextConnectionFactory();

+}

+

+void ChainedConnector::stop() {

+ if (currentConnector) {

+ currentConnector->onConnectFinished.disconnect(boost::bind(&ChainedConnector::handleConnectorFinished, this, _1));

+ currentConnector->stop();

+ currentConnector.reset();

+ }

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

+}

+

+void ChainedConnector::tryNextConnectionFactory() {

+ assert(!currentConnector);

+ if (connectionFactoryQueue.empty()) {

+ SWIFT_LOG(debug) << "No more connection factories" << std::endl;

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

+ }

+ else {

+ ConnectionFactory* connectionFactory = connectionFactoryQueue.front();

+ SWIFT_LOG(debug) << "Trying next connection factory: " << typeid(*connectionFactory).name() << std::endl;

+ connectionFactoryQueue.pop_front();

+ currentConnector = Connector::create(hostname, resolver, connectionFactory, timerFactory);

+ currentConnector->setTimeoutMilliseconds(timeoutMilliseconds);

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

+ currentConnector->start();

+ }

+}

+

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

+ SWIFT_LOG(debug) << "Connector finished" << std::endl;

+ currentConnector->onConnectFinished.disconnect(boost::bind(&ChainedConnector::handleConnectorFinished, this, _1));

+ currentConnector.reset();

+ if (connection) {

+ finish(connection);

+ }

+ else {

+ tryNextConnectionFactory();

+ }

+}

+

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

+ onConnectFinished(connection);

+}

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

+#include <string>

+#include <vector>

+#include <deque>

+#include <boost/shared_ptr.hpp>

+

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

+

+namespace Swift {

+ class Connection;

+ class Connector;

+ class ConnectionFactory;

+ class TimerFactory;

+ class DomainNameResolver;

+

+ class ChainedConnector {

+ public:

+ ChainedConnector(const std::string& hostname, DomainNameResolver*, const std::vector<ConnectionFactory*>&, TimerFactory*);

+

+ void setTimeoutMilliseconds(int milliseconds);

+ void start();

+ void stop();

+

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

+

+ private:

+ void finish(boost::shared_ptr<Connection> connection);

+ void tryNextConnectionFactory();

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

+

+ private:

+ std::string hostname;

+ DomainNameResolver* resolver;

+ std::vector<ConnectionFactory*> connectionFactories;

+ TimerFactory* timerFactory;

+ int timeoutMilliseconds;

+ std::deque<ConnectionFactory*> connectionFactoryQueue;

+ boost::shared_ptr<Connector> currentConnector;

+ };

+};

+/*

+ * 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/Connection.h>

+

+using namespace Swift;

+

+Connection::Connection() {

+}

+

+Connection::~Connection() {

+}

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

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

+ class HostAddressPort;

+

+ Connection();

+ virtual ~Connection();

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+/*

+ * 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/DummyConnection.h>

+

+#include <boost/bind.hpp>

+#include <cassert>

+

+namespace Swift {

+

+DummyConnection::DummyConnection(EventLoop* eventLoop) : eventLoop(eventLoop) {

+}

+

+void DummyConnection::receive(const ByteArray& data) {

+ eventLoop->postEvent(boost::bind(boost::ref(onDataRead), ByteArray(data)), shared_from_this());

+}

+

+void DummyConnection::listen() {

+ assert(false);

+}

+

+void DummyConnection::connect(const HostAddressPort&) {

+ assert(false);

+}

+

+

+}

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

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

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

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

+ DummyConnection(EventLoop* eventLoop);

+ void listen();

+ void connect(const HostAddressPort&);

+ void receive(const ByteArray& data);

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

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

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

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

+/*

+ * Copyright (c) 2010-2011 Thilo Cestonaro

+ * Licensed under the simplified BSD license.

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

+ */

+

+#include <stdio.h>

+#include <stdlib.h>

+#include <iostream>

+

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

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

+

+namespace Swift {

+

+EnvironmentProxyProvider::EnvironmentProxyProvider() {

+ socksProxy = getFromEnv("all_proxy", "socks");

+ httpProxy = getFromEnv("http_proxy", "http");

+ SWIFT_LOG(debug) << "Environment: SOCKS5 => " << socksProxy.toString() << "; HTTP Connect => " << httpProxy.toString() << std::endl;

+}

+

+HostAddressPort EnvironmentProxyProvider::getHTTPConnectProxy() const {

+ return httpProxy;

+}

+

+HostAddressPort EnvironmentProxyProvider::getSOCKS5Proxy() const {

+ return socksProxy;

+}

+

+HostAddressPort EnvironmentProxyProvider::getFromEnv(const char* envVarName, std::string proxyProtocol) {

+ char* envVar = NULL;

+ std::string address;

+ int port = 0;

+

+ envVar = getenv(envVarName);

+

+ proxyProtocol += "://";

+ address = envVar != NULL ? envVar : "0.0.0.0";

+ if(envVar != NULL && address.compare(0, proxyProtocol.length(), proxyProtocol) == 0) {

+ address = address.substr(proxyProtocol.length(), address.length());

+ port = atoi(address.substr(address.find(':') + 1, address.length()).c_str());

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

+ }

+

+ return HostAddressPort(HostAddress(address), port);

+}

+

+}

+/*

+ * Copyright (c) 2010-2011 Thilo Cestonaro

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

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

+

+namespace Swift {

+ class EnvironmentProxyProvider : public ProxyProvider {

+ public:

+ EnvironmentProxyProvider();

+ virtual HostAddressPort getHTTPConnectProxy() const;

+ virtual HostAddressPort getSOCKS5Proxy() const;

+ private:

+ HostAddressPort getFromEnv(const char* envVarName, std::string proxyProtocol);

+ HostAddressPort socksProxy;

+ HostAddressPort httpProxy;

+ };

+}

+

+

+/*

+ * 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/FakeConnection.h>

+

+#include <boost/bind.hpp>

+

+namespace Swift {

+

+FakeConnection::FakeConnection(EventLoop* eventLoop) : eventLoop(eventLoop), state(Initial), delayConnect(false) {

+}

+

+FakeConnection::~FakeConnection() {

+}

+

+void FakeConnection::listen() {

+ assert(false);

+}

+

+void FakeConnection::setError(const Error& e) {

+ error = boost::optional<Error>(e);

+ state = DisconnectedWithError;

+ if (connectedTo) {

+ eventLoop->postEvent(

+ boost::bind(boost::ref(onDisconnected), error),

+ shared_from_this());

+ }

+}

+

+void FakeConnection::connect(const HostAddressPort& address) {

+ if (delayConnect) {

+ state = Connecting;

+ }

+ else {

+ if (!error) {

+ connectedTo = address;

+ state = Connected;

+ }

+ else {

+ state = DisconnectedWithError;

+ }

+ eventLoop->postEvent(

+ boost::bind(boost::ref(onConnectFinished), error),

+ shared_from_this());

+ }

+}

+

+void FakeConnection::disconnect() {

+ if (!error) {

+ state = Disconnected;

+ }

+ else {

+ state = DisconnectedWithError;

+ }

+ connectedTo.reset();

+ eventLoop->postEvent(

+ boost::bind(boost::ref(onDisconnected), error),

+ shared_from_this());

+}

+

+}

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

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

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

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

+ FakeConnection(EventLoop* eventLoop);

+ ~FakeConnection();

+ virtual void listen();

+ void setError(const Error& e);

+ virtual void connect(const HostAddressPort& address);

+ virtual void disconnect();

+/*

+ * Copyright (c) 2010-2011 Thilo Cestonaro

+ * Licensed under the simplified BSD license.

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

+ */

+

+#include <stdio.h>

+#include <stdlib.h>

+#include <iostream>

+

+#include <gconf/gconf-client.h>

+

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

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

+

+namespace Swift {

+

+GConfProxyProvider::GConfProxyProvider() {

+ socksProxy = getFromGConf("/system/proxy/socks_host", "/system/proxy/socks_port");

+ httpProxy = getFromGConf("/system/http_proxy/host", "/system/http_proxy/port");

+ SWIFT_LOG(debug) << "GConf: SOCKS5 => " << socksProxy.toString() << "; HTTP Connect => " << httpProxy.toString() << std::endl;

+}

+

+HostAddressPort GConfProxyProvider::getHTTPConnectProxy() const {

+ return httpProxy;

+}

+

+HostAddressPort GConfProxyProvider::getSOCKS5Proxy() const {

+ return socksProxy;

+}

+

+HostAddressPort GConfProxyProvider::getFromGConf(const char* gcHost, const char* gcPort) {

+ std::string address;

+ int port = 0;

+ gchar* str;

+

+ GConfClient* client = gconf_client_get_default();

+

+ str = gconf_client_get_string(client, gcHost, NULL);

+ port = static_cast<int> (gconf_client_get_int(client, gcPort, NULL));

+

+ if(str) {

+ address = static_cast<char*> (str);

+ g_free(str);

+ }

+

+ g_object_unref(client);

+ return HostAddressPort(HostAddress(address), port);

+}

+

+}

+/*

+ * Copyright (c) 2010-2011 Thilo Cestonaro

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

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

+

+namespace Swift {

+ class GConfProxyProvider : public ProxyProvider {

+ public:

+ GConfProxyProvider();

+ virtual HostAddressPort getHTTPConnectProxy() const;

+ virtual HostAddressPort getSOCKS5Proxy() const;

+ private:

+ HostAddressPort getFromGConf(const char* gcHost, const char* gcPort);

+ HostAddressPort socksProxy;

+ HostAddressPort httpProxy;

+ };

+}

+

+

+/*

+ * Copyright (c) 2010-2011 Thilo Cestonaro

+ * Licensed under the simplified BSD license.

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

+ */

+

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

+

+#include <iostream>

+#include <boost/bind.hpp>

+#include <boost/thread.hpp>

+#include <boost/lexical_cast.hpp>

+

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

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

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

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

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

+

+using namespace Swift;

+

+HTTPConnectProxiedConnection::HTTPConnectProxiedConnection(ConnectionFactory* connectionFactory, HostAddressPort proxy) : connectionFactory_(connectionFactory), proxy_(proxy), server_(HostAddressPort(HostAddress("0.0.0.0"), 0)) {

+ connected_ = false;

+}

+

+HTTPConnectProxiedConnection::~HTTPConnectProxiedConnection() {

+ if (connection_) {

+ connection_->onDataRead.disconnect(boost::bind(&HTTPConnectProxiedConnection::handleDataRead, shared_from_this(), _1));

+ connection_->onDisconnected.disconnect(boost::bind(&HTTPConnectProxiedConnection::handleDisconnected, shared_from_this(), _1));

+ }

+

+ if (connected_) {

+ std::cerr << "Warning: Connection was still established." << std::endl;

+ }

+}

+

+void HTTPConnectProxiedConnection::connect(const HostAddressPort& server) {

+ server_ = server;

+ connection_ = connectionFactory_->createConnection();

+ connection_->onConnectFinished.connect(boost::bind(&HTTPConnectProxiedConnection::handleConnectionConnectFinished, shared_from_this(), _1));

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

+ connection_->onDisconnected.connect(boost::bind(&HTTPConnectProxiedConnection::handleDisconnected, shared_from_this(), _1));

+ connection_->connect(proxy_);

+}

+

+void HTTPConnectProxiedConnection::listen() {

+ assert(false);

+ connection_->listen();

+}

+

+void HTTPConnectProxiedConnection::disconnect() {

+ connected_ = false;

+ connection_->disconnect();

+}

+

+void HTTPConnectProxiedConnection::handleDisconnected(const boost::optional<Error>& error) {

+ onDisconnected(error);

+}

+

+void HTTPConnectProxiedConnection::write(const ByteArray& data) {

+ connection_->write(data);

+}

+

+void HTTPConnectProxiedConnection::handleConnectionConnectFinished(bool error) {

+ connection_->onConnectFinished.disconnect(boost::bind(&HTTPConnectProxiedConnection::handleConnectionConnectFinished, shared_from_this(), _1));

+ if (!error) {

+ std::stringstream connect;

+ connect << "CONNECT " << server_.getAddress().toString() << ":" << server_.getPort() << " HTTP/1.1\r\n\r\n";

+ connection_->write(ByteArray(connect.str()));

+ }

+ else {

+ onConnectFinished(true);

+ }

+}

+

+void HTTPConnectProxiedConnection::handleDataRead(const ByteArray& data) {

+ if (!connected_) {

+ SWIFT_LOG(debug) << data.toString() << std::endl;

+ std::vector<std::string> tmp = String::split(data.toString(), ' ');

+ if(tmp.size() > 1) {

+ int status = boost::lexical_cast<int> (tmp[1].c_str());

+ SWIFT_LOG(debug) << "Proxy Status: " << status << std::endl;

+ if (status / 100 == 2) { // all 2XX states are OK

+ connected_ = true;

+ onConnectFinished(false);

+ return;

+ }

+ SWIFT_LOG(debug) << "HTTP Proxy returned an error: " << data.toString() << std::endl;

+ }

+ disconnect();

+ onConnectFinished(true);

+ }

+ else {

+ onDataRead(data);

+ }

+}

+

+HostAddressPort HTTPConnectProxiedConnection::getLocalAddress() const {

+ return connection_->getLocalAddress();

+}

+/*

+ * Copyright (c) 2010-2011 Thilo Cestonaro

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <boost/enable_shared_from_this.hpp>

+

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

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

+

+namespace boost {

+ class thread;

+ namespace system {

+ class error_code;

+ }

+}

+

+namespace Swift {

+ class ConnectionFactory;

+

+ class HTTPConnectProxiedConnection : public Connection, public boost::enable_shared_from_this<HTTPConnectProxiedConnection> {

+ public:

+ typedef boost::shared_ptr<HTTPConnectProxiedConnection> ref;

+

+ ~HTTPConnectProxiedConnection();

+

+ static ref create(ConnectionFactory* connectionFactory, HostAddressPort proxy) {

+ return ref(new HTTPConnectProxiedConnection(connectionFactory, proxy));

+ }

+

+ virtual void listen();

+ virtual void connect(const HostAddressPort& address);

+ virtual void disconnect();

+ virtual void write(const ByteArray& data);

+

+ virtual HostAddressPort getLocalAddress() const;

+ private:

+ HTTPConnectProxiedConnection(ConnectionFactory* connectionFactory, HostAddressPort proxy);

+

+ void handleConnectionConnectFinished(bool error);

+ void handleDataRead(const ByteArray& data);

+ void handleDisconnected(const boost::optional<Error>& error);

+

+ private:

+ bool connected_;

+ ConnectionFactory* connectionFactory_;

+ HostAddressPort proxy_;

+ HostAddressPort server_;

+ boost::shared_ptr<Connection> connection_;

+ };

+}

+/*

+ * Copyright (c) 2010-2011 Thilo Cestonaro

+ * Licensed under the simplified BSD license.

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

+ */

+

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

+

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

+

+namespace Swift {

+

+HTTPConnectProxiedConnectionFactory::HTTPConnectProxiedConnectionFactory(ConnectionFactory* connectionFactory, const HostAddressPort& proxy) : connectionFactory_(connectionFactory), proxy_(proxy) {

+}

+

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

+ return HTTPConnectProxiedConnection::create(connectionFactory_, proxy_);

+}

+

+}

+/*

+ * Copyright (c) 2010-2011 Thilo Cestonaro

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

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

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

+

+namespace Swift {

+ class HTTPConnectProxiedConnectionFactory : public ConnectionFactory {

+ public:

+ HTTPConnectProxiedConnectionFactory(ConnectionFactory* connectionFactory, const HostAddressPort& proxy);

+

+ virtual boost::shared_ptr<Connection> createConnection();

+

+ private:

+ ConnectionFactory* connectionFactory_;

+ HostAddressPort proxy_;

+ };

+}

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

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

+ catch (const std::exception&) {

+boost::asio::ip::address HostAddress::getRawAddress() const {

+ return address_;

+}

+

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

+ boost::asio::ip::address getRawAddress() const;

+/*

+ * 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/HostAddressPort.h>

+

+#include <boost/lexical_cast.hpp>

+

+using namespace Swift;

+

+HostAddressPort::HostAddressPort(const HostAddress& address, int port) : address_(address), port_(port) {

+}

+

+HostAddressPort::HostAddressPort(const boost::asio::ip::tcp::endpoint& endpoint) {

+ address_ = HostAddress(endpoint.address());

+ port_ = endpoint.port();

+}

+

+std::string HostAddressPort::toString() const {

+ return getAddress().toString() + ":" + boost::lexical_cast<std::string>(getPort());

+}

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

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

+ HostAddressPort(const HostAddress& address = HostAddress(), int port = -1);

+ HostAddressPort(const boost::asio::ip::tcp::endpoint& endpoint);

+

+ std::string toString() const;

+/*

+ * Copyright (c) 2010-2011 Thilo Cestonaro

+ * Licensed under the simplified BSD license.

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

+ */

+

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

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

+

+#include <stdio.h>

+#include <stdlib.h>

+#include <iostream>

+#include <utility>

+

+#ifndef SWIFTEN_PLATFORM_IPHONE

+#include <SystemConfiguration/SystemConfiguration.h>

+#endif

+

+using namespace Swift;

+

+#ifndef SWIFTEN_PLATFORM_IPHONE

+static HostAddressPort getFromDictionary(CFDictionaryRef dict, CFStringRef enabledKey, CFStringRef hostKey, CFStringRef portKey) {

+ CFNumberRef numberValue = NULL;

+ HostAddressPort ret = HostAddressPort(HostAddress(), 0);

+

+ if(CFDictionaryGetValueIfPresent(dict, reinterpret_cast<const void*> (enabledKey), reinterpret_cast<const void**> (&numberValue)) == true) {

+ const int i = 0;

+ CFNumberRef zero = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &i);

+ CFComparisonResult result = CFNumberCompare(numberValue, zero, NULL);

+ CFRelease(numberValue);

+

+ if(result != kCFCompareEqualTo) {

+ int port = 0;

+ std::string host = "";

+

+ try {

+ CFNumberRef numberValue = reinterpret_cast<CFNumberRef> (CFDictionaryGetValue(dict, portKey));

+ if(numberValue != NULL) {

+ CFNumberGetValue(numberValue, kCFNumberIntType, &port);

+ CFRelease(numberValue);

+ }

+

+ CFStringRef stringValue = reinterpret_cast<CFStringRef> (CFDictionaryGetValue(dict, hostKey));

+ if(stringValue != NULL) {

+ std::vector<char> buffer;

+ // length must be +1 for the ending zero; and the Docu of CFStringGetCString tells it like

+ // if the string is toby the length must be at least 5.

+ CFIndex length = CFStringGetLength(stringValue) + 1;

+ buffer.resize(length);

+ if(CFStringGetCString(stringValue, &buffer[0], length, kCFStringEncodingMacRoman)) {

+ for(std::vector<char>::iterator iter = buffer.begin(); iter != buffer.end(); iter++) {

+ host += *iter;

+ }

+ }

+ CFRelease(stringValue);

+ }

+ }

+ catch(...) {

+ std::cerr << "Exception caught ... " << std::endl;

+ }

+

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

+ ret = HostAddressPort(HostAddress(host), port);

+ }

+ }

+ }

+ return ret;

+}

+#endif

+namespace Swift {

+

+MacOSXProxyProvider::MacOSXProxyProvider() {

+}

+

+HostAddressPort MacOSXProxyProvider::getHTTPConnectProxy() const {

+ HostAddressPort result;

+#ifndef SWIFTEN_PLATFORM_IPHONE

+ CFDictionaryRef proxies = SCDynamicStoreCopyProxies(NULL);

+ if(proxies != NULL) {

+ result = getFromDictionary(proxies, kSCPropNetProxiesHTTPEnable, kSCPropNetProxiesHTTPProxy, kSCPropNetProxiesHTTPPort);

+ }

+#endif

+ return result;

+}

+

+HostAddressPort MacOSXProxyProvider::getSOCKS5Proxy() const {

+ HostAddressPort result;

+#ifndef SWIFTEN_PLATFORM_IPHONE

+ CFDictionaryRef proxies = SCDynamicStoreCopyProxies(NULL);

+ if(proxies != NULL) {

+ result = getFromDictionary(proxies, kSCPropNetProxiesSOCKSEnable, kSCPropNetProxiesSOCKSProxy, kSCPropNetProxiesSOCKSPort);

+ }

+#endif

+ return result;

+}

+

+}

+/*

+ * Copyright (c) 2010-2011 Thilo Cestonaro

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

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

+#include <CoreFoundation/CoreFoundation.h>

+

+namespace Swift {

+ class MacOSXProxyProvider : public ProxyProvider {

+ public:

+ MacOSXProxyProvider();

+ virtual HostAddressPort getHTTPConnectProxy() const;

+ virtual HostAddressPort getSOCKS5Proxy() const;

+ };

+}

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

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the simplified BSD license.

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

+ */

+

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

+

+using namespace Swift;

+

+NullProxyProvider::NullProxyProvider() {

+}

+

+HostAddressPort NullProxyProvider::getHTTPConnectProxy() const {

+ return HostAddressPort();

+}

+

+HostAddressPort NullProxyProvider::getSOCKS5Proxy() const {

+ return HostAddressPort();

+}

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

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

+

+namespace Swift {

+ class NullProxyProvider : public ProxyProvider {

+ public:

+ NullProxyProvider();

+

+ virtual HostAddressPort getHTTPConnectProxy() const;

+ virtual HostAddressPort getSOCKS5Proxy() const;

+ };

+}

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

+

+#include <boost/asio/io_service.hpp>

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

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

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

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

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

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

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

+#include <boost/thread/thread.hpp>

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

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

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

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

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

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

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

+/*

+ * Copyright (c) 2010-2011 Thilo Cestonaro

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

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

+

+#if defined(SWIFTEN_PLATFORM_MACOSX)

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

+namespace Swift {

+ typedef MacOSXProxyProvider PlatformProxyProvider;

+}

+#elif defined(SWIFTEN_PLATFORM_WIN32)

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

+namespace Swift {

+ typedef WindowsProxyProvider PlatformProxyProvider;

+}

+#else

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

+namespace Swift {

+ typedef UnixProxyProvider PlatformProxyProvider;

+}

+#endif

+/*

+ * Copyright (c) 2010-2011 Thilo Cestonaro

+ * Licensed under the simplified BSD license.

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

+ */

+

+#include "ProxyProvider.h"

+

+namespace Swift {

+

+ProxyProvider::ProxyProvider()

+{

+}

+

+ProxyProvider::~ProxyProvider()

+{

+}

+

+}

+/*

+ * Copyright (c) 2010-2011 Thilo Cestonaro

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+#include <map>

+

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

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

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

+

+namespace Swift {

+ class ProxyProvider {

+ public:

+ ProxyProvider();

+ virtual ~ProxyProvider();

+ virtual HostAddressPort getHTTPConnectProxy() const = 0;

+ virtual HostAddressPort getSOCKS5Proxy() const = 0;

+ };

+}

+

+ "HTTPConnectProxiedConnection.cpp",

+ "HTTPConnectProxiedConnectionFactory.cpp",

+ "SOCKS5ProxiedConnection.cpp",

+ "SOCKS5ProxiedConnectionFactory.cpp",

+ "DummyConnection.cpp",

+ "FakeConnection.cpp",

+ "ChainedConnector.cpp",

+ "Connection.cpp",

+ "HostAddressPort.cpp",

+ "BoostTimer.cpp",

+ "ProxyProvider.cpp",

+ "NullProxyProvider.cpp"

+ ]

+

+if myenv["PLATFORM"] == "darwin" :

+ myenv.Append(FRAMEWORKS = ["CoreServices", "SystemConfiguration"])

+ sourceList += [ "MacOSXProxyProvider.cpp" ]

+elif myenv["PLATFORM"] == "win32" :

+ sourceList += [ "WindowsProxyProvider.cpp" ]

+else :

+ sourceList += [ "UnixProxyProvider.cpp" ]

+ sourceList += [ "EnvironmentProxyProvider.cpp" ]

+ if myenv.get("HAVE_GCONF", 0) :

+ myenv.Append(CPPDEFINES = "HAVE_GCONF")

+ myenv.MergeFlags(myenv["GCONF_FLAGS"])

+ sourceList += [ "GConfProxyProvider.cpp" ]

+/*

+ * Copyright (c) 2010-2011 Thilo Cestonaro

+ * Licensed under the simplified BSD license.

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

+ */

+

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

+

+#include <iostream>

+#include <boost/bind.hpp>

+#include <boost/thread.hpp>

+

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

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

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

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

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

+

+using namespace Swift;

+

+SOCKS5ProxiedConnection::SOCKS5ProxiedConnection(ConnectionFactory* connectionFactory, const HostAddressPort& proxy) : connectionFactory_(connectionFactory), proxy_(proxy), server_(HostAddressPort(HostAddress("0.0.0.0"), 0)) {

+ connected_ = false;

+}

+

+SOCKS5ProxiedConnection::~SOCKS5ProxiedConnection() {

+ if (connection_) {

+ connection_->onDataRead.disconnect(boost::bind(&SOCKS5ProxiedConnection::handleDataRead, shared_from_this(), _1));

+ connection_->onDisconnected.disconnect(boost::bind(&SOCKS5ProxiedConnection::handleDisconnected, shared_from_this(), _1));

+ }

+

+ if (connected_) {

+ std::cerr << "Warning: Connection was still established." << std::endl;

+ }

+}

+

+void SOCKS5ProxiedConnection::connect(const HostAddressPort& server) {

+ server_ = server;

+ connection_ = connectionFactory_->createConnection();

+ connection_->onConnectFinished.connect(boost::bind(&SOCKS5ProxiedConnection::handleConnectionConnectFinished, shared_from_this(), _1));

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

+ connection_->onDisconnected.connect(boost::bind(&SOCKS5ProxiedConnection::handleDisconnected, shared_from_this(), _1));

+ SWIFT_LOG(debug) << "Trying to connect via proxy " << proxy_.getAddress().toString() << ":" << proxy_.getPort() << std::endl;

+ SWIFT_LOG(debug) << "to server " << server.getAddress().toString() << ":" << server.getPort() << std::endl;

+ connection_->connect(proxy_);

+}

+

+void SOCKS5ProxiedConnection::listen() {

+ assert(false);

+ connection_->listen();

+}

+

+void SOCKS5ProxiedConnection::disconnect() {

+ connected_ = false;

+ if (connection_) {

+ connection_->disconnect();

+ }

+}

+

+void SOCKS5ProxiedConnection::handleDisconnected(const boost::optional<Error>& error) {

+ onDisconnected(error);

+}

+

+void SOCKS5ProxiedConnection::write(const ByteArray& data) {

+ if (connection_) {

+ connection_->write(data);

+ }

+}

+

+void SOCKS5ProxiedConnection::handleConnectionConnectFinished(bool error) {

+ connection_->onConnectFinished.disconnect(boost::bind(&SOCKS5ProxiedConnection::handleConnectionConnectFinished, shared_from_this(), _1));

+ if (!error) {

+ SWIFT_LOG(debug) << "Connection to proxy established, now connect to the server via it." << std::endl;

+

+ proxyState_ = ProxyAuthenticating;

+ ByteArray socksConnect;

+ socksConnect += 0x05; // VER = SOCKS5 = 0x05

+ socksConnect += 0x01; // Number of authentication methods after this byte.

+ socksConnect += 0x00; // 0x00 == no authentication

+ // buffer.push_back(0x01); // 0x01 == GSSAPI

+ // buffer.push_back(0x02); // 0x02 == Username/Password

+ // rest see RFC 1928 (http://tools.ietf.org/html/rfc1928)

+ connection_->write(socksConnect);

+ }

+ else {

+ onConnectFinished(true);

+ }

+}

+

+void SOCKS5ProxiedConnection::handleDataRead(const ByteArray& data) {

+ ByteArray socksConnect;

+ boost::asio::ip::address rawAddress = server_.getAddress().getRawAddress();

+ assert(rawAddress.is_v4() || rawAddress.is_v6());

+ if (!connected_) {

+ if (proxyState_ == ProxyAuthenticating) {

+ SWIFT_LOG(debug) << "ProxyAuthenticating response received, reply with the connect BYTEs" << std::endl;

+ unsigned char choosenMethod = static_cast<unsigned char> (data[1]);

+ if (data[0] == 0x05 && choosenMethod != 0xFF) {

+ switch(choosenMethod) { // use the correct Method

+ case 0x00:

+ try {

+ proxyState_ = ProxyConnecting;

+ socksConnect += 0x05; // VER = SOCKS5 = 0x05

+ socksConnect += 0x01; // Construct a TCP connection. (CMD)

+ socksConnect += 0x00; // reserved.

+ socksConnect += rawAddress.is_v4() ? 0x01 : 0x04; // IPv4 == 0x01, Hostname == 0x02, IPv6 == 0x04. (ATYP)

+ size_t size = rawAddress.is_v4() ? rawAddress.to_v4().to_bytes().size() : rawAddress.to_v6().to_bytes().size();

+ for (size_t s = 0; s < size; s++) {

+ unsigned char uc;

+ if(rawAddress.is_v4()) {

+ uc = rawAddress.to_v4().to_bytes()[s]; // the address.

+ }

+ else {

+ uc = rawAddress.to_v6().to_bytes()[s]; // the address.

+ }

+ socksConnect += static_cast<char> (uc);

+

+ }

+ socksConnect += static_cast<unsigned char> ((server_.getPort() >> 8) & 0xFF); // highbyte of the port.

+ socksConnect += static_cast<unsigned char> (server_.getPort() & 0xFF); // lowbyte of the port.

+ connection_->write(socksConnect);

+ return;

+ }

+ catch(...) {

+ std::cerr << "exception caught" << std::endl;

+ }

+ connection_->write(socksConnect);

+ break;

+ default:

+ onConnectFinished(true);

+ break;

+ }

+ return;

+ }

+ }

+ else if (proxyState_ == ProxyConnecting) {

+ SWIFT_LOG(debug) << "Connect response received, check if successfully." << std::endl;

+ SWIFT_LOG(debug) << "Errorbyte: 0x" << std::hex << static_cast<int> (data[1]) << std::dec << std::endl;

+ /*

+

+ data.at(1) can be one of the following:

+ 0x00 succeeded

+ 0x01 general SOCKS server failure

+ 0x02 connection not allowed by ruleset

+ 0x03 Network unreachable

+ 0x04 Host unreachable

+ 0x05 Connection refused

+ 0x06 TTL expired

+ 0x07 Command not supported (CMD)

+ 0x08 Address type not supported (ATYP)

+ 0x09 bis 0xFF unassigned

+ */

+ if (data[0] == 0x05 && data[1] == 0x0) {

+ SWIFT_LOG(debug) << "Successfully connected the server via the proxy." << std::endl;

+ connected_ = true;

+ onConnectFinished(false);

+ return;

+ }

+ else {

+ std::cerr << "SOCKS Proxy returned an error: " << std::hex << data[1] << std::endl;

+ }

+ return;

+ }

+ }

+ else {

+ onDataRead(data);

+ return;

+ }

+ disconnect();

+ onConnectFinished(true);

+}

+

+HostAddressPort SOCKS5ProxiedConnection::getLocalAddress() const {

+ return connection_->getLocalAddress();

+}

+/*

+ * Copyright (c) 2010-2011 Thilo Cestonaro

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <boost/enable_shared_from_this.hpp>

+

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

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

+

+namespace boost {

+ class thread;

+ namespace system {

+ class error_code;

+ }

+}

+

+namespace Swift {

+ class ConnectionFactory;

+

+ class SOCKS5ProxiedConnection : public Connection, public boost::enable_shared_from_this<SOCKS5ProxiedConnection> {

+ public:

+ typedef boost::shared_ptr<SOCKS5ProxiedConnection> ref;

+

+ ~SOCKS5ProxiedConnection();

+

+ static ref create(ConnectionFactory* connectionFactory, const HostAddressPort& proxy) {

+ return ref(new SOCKS5ProxiedConnection(connectionFactory, proxy));

+ }

+

+ virtual void listen();

+ virtual void connect(const HostAddressPort& address);

+ virtual void disconnect();

+ virtual void write(const ByteArray& data);

+

+ virtual HostAddressPort getLocalAddress() const;

+

+ private:

+ SOCKS5ProxiedConnection(ConnectionFactory* connectionFactory, const HostAddressPort& proxy);

+

+ void handleConnectionConnectFinished(bool error);

+ void handleDataRead(const ByteArray& data);

+ void handleDisconnected(const boost::optional<Error>& error);

+

+ private:

+ enum {

+ ProxyAuthenticating = 0,

+ ProxyConnecting,

+ } proxyState_;

+ bool connected_;

+ ConnectionFactory* connectionFactory_;

+ HostAddressPort proxy_;

+ HostAddressPort server_;

+ boost::shared_ptr<Connection> connection_;

+ };

+}

+/*

+ * Copyright (c) 2010-2011 Thilo Cestonaro

+ * Licensed under the simplified BSD license.

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

+ */

+

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

+

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

+

+namespace Swift {

+

+SOCKS5ProxiedConnectionFactory::SOCKS5ProxiedConnectionFactory(ConnectionFactory* connectionFactory, const HostAddressPort& proxy) : connectionFactory_(connectionFactory), proxy_(proxy) {

+}

+

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

+ return SOCKS5ProxiedConnection::create(connectionFactory_, proxy_);

+}

+

+}

+/*

+ * Copyright (c) 2010-2011 Thilo Cestonaro

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

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

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

+

+namespace Swift {

+ class SOCKS5ProxiedConnectionFactory : public ConnectionFactory {

+ public:

+ SOCKS5ProxiedConnectionFactory(ConnectionFactory* connectionFactory, const HostAddressPort& proxy);

+

+ virtual boost::shared_ptr<Connection> createConnection();

+

+ private:

+ ConnectionFactory* connectionFactory_;

+ HostAddressPort proxy_;

+ };

+}

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

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

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

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

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

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

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

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

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

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

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

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

+/*

+ * 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/bind.hpp>

+#include <boost/smart_ptr/make_shared.hpp>

+

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

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

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

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

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

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

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

+

+using namespace Swift;

+

+class ChainedConnectorTest : public CppUnit::TestFixture {

+ CPPUNIT_TEST_SUITE(ChainedConnectorTest);

+ CPPUNIT_TEST(testConnect_FirstConnectorSucceeds);

+ CPPUNIT_TEST(testConnect_SecondConnectorSucceeds);

+ CPPUNIT_TEST(testConnect_NoConnectorSucceeds);

+ CPPUNIT_TEST(testStop);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ void setUp() {

+ host = HostAddressPort(HostAddress("1.1.1.1"), 1234);

+ eventLoop = new DummyEventLoop();

+ resolver = new StaticDomainNameResolver(eventLoop);

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

+ connectionFactory1 = new MockConnectionFactory(eventLoop, 1);

+ connectionFactory2 = new MockConnectionFactory(eventLoop, 2);

+ timerFactory = new DummyTimerFactory();

+ }

+

+ void tearDown() {

+ delete timerFactory;

+ delete connectionFactory2;

+ delete connectionFactory1;

+ delete resolver;

+ delete eventLoop;

+ }

+

+ void testConnect_FirstConnectorSucceeds() {

+ boost::shared_ptr<ChainedConnector> testling(createConnector());

+ connectionFactory1->connects = true;

+ connectionFactory2->connects = false;

+

+ testling->start();

+ eventLoop->processEvents();

+

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

+ CPPUNIT_ASSERT(connections[0]);

+ CPPUNIT_ASSERT_EQUAL(1, boost::dynamic_pointer_cast<MockConnection>(connections[0])->id);

+ }

+

+ void testConnect_SecondConnectorSucceeds() {

+ boost::shared_ptr<ChainedConnector> testling(createConnector());

+ connectionFactory1->connects = false;

+ connectionFactory2->connects = true;

+

+ testling->start();

+ eventLoop->processEvents();

+

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

+ CPPUNIT_ASSERT(connections[0]);

+ CPPUNIT_ASSERT_EQUAL(2, boost::dynamic_pointer_cast<MockConnection>(connections[0])->id);

+ }

+

+ void testConnect_NoConnectorSucceeds() {

+ boost::shared_ptr<ChainedConnector> testling(createConnector());

+ connectionFactory1->connects = false;

+ connectionFactory2->connects = false;

+

+ testling->start();

+ eventLoop->processEvents();

+

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

+ CPPUNIT_ASSERT(!connections[0]);

+ }

+

+ void testStop() {

+ boost::shared_ptr<ChainedConnector> testling(createConnector());

+ connectionFactory1->connects = true;

+ connectionFactory2->connects = false;

+

+ testling->start();

+ testling->stop();

+ eventLoop->processEvents();

+

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

+ CPPUNIT_ASSERT(!connections[0]);

+ }

+

+ private:

+ boost::shared_ptr<ChainedConnector> createConnector() {

+ std::vector<ConnectionFactory*> factories;

+ factories.push_back(connectionFactory1);

+ factories.push_back(connectionFactory2);

+ boost::shared_ptr<ChainedConnector> connector = boost::make_shared<ChainedConnector>("foo.com", resolver, factories, timerFactory);

+ connector->onConnectFinished.connect(boost::bind(&ChainedConnectorTest::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(bool connects, int id, EventLoop* eventLoop) : connects(connects), id(id), eventLoop(eventLoop) {

+ }

+

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

+ void connect(const HostAddressPort&) {

+ eventLoop->postEvent(boost::bind(boost::ref(onConnectFinished), !connects));

+ }

+

+ HostAddressPort getLocalAddress() const { return HostAddressPort(); }

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

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

+

+ bool connects;

+ int id;

+ EventLoop* eventLoop;

+ };

+

+ struct MockConnectionFactory : public ConnectionFactory {

+ MockConnectionFactory(EventLoop* eventLoop, int id) : eventLoop(eventLoop), connects(true), id(id) {

+ }

+

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

+ return boost::make_shared<MockConnection>(connects, id, eventLoop);

+ }

+

+ EventLoop* eventLoop;

+ bool connects;

+ int id;

+ };

+

+ private:

+ HostAddressPort host;

+ DummyEventLoop* eventLoop;

+ StaticDomainNameResolver* resolver;

+ MockConnectionFactory* connectionFactory1;

+ MockConnectionFactory* connectionFactory2;

+ DummyTimerFactory* timerFactory;

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

+};

+

+CPPUNIT_TEST_SUITE_REGISTRATION(ChainedConnectorTest);

+#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/Network/DummyTimerFactory.h>

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

+/*

+ * 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/optional.hpp>

+#include <boost/bind.hpp>

+#include <boost/smart_ptr/make_shared.hpp>

+#include <boost/shared_ptr.hpp>

+

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

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

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

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

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

+

+using namespace Swift;

+

+class HTTPConnectProxiedConnectionTest : public CppUnit::TestFixture {

+ CPPUNIT_TEST_SUITE(HTTPConnectProxiedConnectionTest);

+ CPPUNIT_TEST(testConnect_CreatesConnectionToProxy);

+ CPPUNIT_TEST(testConnect_SendsConnectRequest);

+ CPPUNIT_TEST(testConnect_ReceiveConnectResponse);

+ CPPUNIT_TEST(testConnect_ReceiveMalformedConnectResponse);

+ CPPUNIT_TEST(testConnect_ReceiveErrorConnectResponse);

+ CPPUNIT_TEST(testConnect_ReceiveDataAfterConnect);

+ CPPUNIT_TEST(testWrite_AfterConnect);

+ CPPUNIT_TEST(testDisconnect_AfterConnectRequest);

+ CPPUNIT_TEST(testDisconnect_AfterConnect);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ void setUp() {

+ proxyHost = HostAddressPort(HostAddress("1.1.1.1"), 1234);

+ host = HostAddressPort(HostAddress("2.2.2.2"), 2345);

+ eventLoop = new DummyEventLoop();

+ connectionFactory = new MockConnectionFactory(eventLoop);

+ connectFinished = false;

+ disconnected = false;

+ }

+

+ void tearDown() {

+ delete connectionFactory;

+ delete eventLoop;

+ }

+

+ void testConnect_CreatesConnectionToProxy() {

+ HTTPConnectProxiedConnection::ref testling(createTestling());

+

+ testling->connect(host);

+ eventLoop->processEvents();

+

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

+ CPPUNIT_ASSERT(connectionFactory->connections[0]->hostAddressPort);

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

+ CPPUNIT_ASSERT(!connectFinished);

+ }

+

+ void testConnect_SendsConnectRequest() {

+ HTTPConnectProxiedConnection::ref testling(createTestling());

+

+ testling->connect(HostAddressPort(HostAddress("2.2.2.2"), 2345));

+ eventLoop->processEvents();

+

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

+ }

+

+ void testConnect_ReceiveConnectResponse() {

+ HTTPConnectProxiedConnection::ref testling(createTestling());

+ testling->connect(HostAddressPort(HostAddress("2.2.2.2"), 2345));

+ eventLoop->processEvents();

+

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

+ eventLoop->processEvents();

+

+ CPPUNIT_ASSERT(connectFinished);

+ CPPUNIT_ASSERT(!connectFinishedWithError);

+ CPPUNIT_ASSERT(dataRead.isEmpty());

+ }

+

+ void testConnect_ReceiveMalformedConnectResponse() {

+ HTTPConnectProxiedConnection::ref testling(createTestling());

+ testling->connect(HostAddressPort(HostAddress("2.2.2.2"), 2345));

+ eventLoop->processEvents();

+

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

+ eventLoop->processEvents();

+

+ CPPUNIT_ASSERT(connectFinished);

+ CPPUNIT_ASSERT(connectFinishedWithError);

+ CPPUNIT_ASSERT(connectionFactory->connections[0]->disconnected);

+ }

+

+ void testConnect_ReceiveErrorConnectResponse() {

+ HTTPConnectProxiedConnection::ref testling(createTestling());

+ testling->connect(HostAddressPort(HostAddress("2.2.2.2"), 2345));

+ eventLoop->processEvents();

+

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

+ eventLoop->processEvents();

+

+ CPPUNIT_ASSERT(connectFinished);

+ CPPUNIT_ASSERT(connectFinishedWithError);

+ CPPUNIT_ASSERT(connectionFactory->connections[0]->disconnected);

+ }

+

+ void testConnect_ReceiveDataAfterConnect() {

+ HTTPConnectProxiedConnection::ref testling(createTestling());

+ testling->connect(HostAddressPort(HostAddress("2.2.2.2"), 2345));

+ eventLoop->processEvents();

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

+ eventLoop->processEvents();

+

+ connectionFactory->connections[0]->onDataRead(ByteArray("abcdef"));

+

+ CPPUNIT_ASSERT_EQUAL(ByteArray("abcdef"), dataRead);

+ }

+

+ void testWrite_AfterConnect() {

+ HTTPConnectProxiedConnection::ref testling(createTestling());

+ testling->connect(HostAddressPort(HostAddress("2.2.2.2"), 2345));

+ eventLoop->processEvents();

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

+ eventLoop->processEvents();

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

+

+ testling->write(ByteArray("abcdef"));

+

+ CPPUNIT_ASSERT_EQUAL(ByteArray("abcdef"), connectionFactory->connections[0]->dataWritten);

+ }

+

+ void testDisconnect_AfterConnectRequest() {

+ HTTPConnectProxiedConnection::ref testling(createTestling());

+ testling->connect(HostAddressPort(HostAddress("2.2.2.2"), 2345));

+ eventLoop->processEvents();

+

+ testling->disconnect();

+

+ CPPUNIT_ASSERT(connectionFactory->connections[0]->disconnected);

+ CPPUNIT_ASSERT(disconnected);

+ CPPUNIT_ASSERT(!disconnectedError);

+ }

+

+ void testDisconnect_AfterConnect() {

+ HTTPConnectProxiedConnection::ref testling(createTestling());

+ testling->connect(HostAddressPort(HostAddress("2.2.2.2"), 2345));

+ eventLoop->processEvents();

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

+ eventLoop->processEvents();

+

+ testling->disconnect();

+

+ CPPUNIT_ASSERT(connectionFactory->connections[0]->disconnected);

+ CPPUNIT_ASSERT(disconnected);

+ CPPUNIT_ASSERT(!disconnectedError);

+ }

+

+ private:

+ HTTPConnectProxiedConnection::ref createTestling() {

+ boost::shared_ptr<HTTPConnectProxiedConnection> c = HTTPConnectProxiedConnection::create(connectionFactory, proxyHost);

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

+ c->onDisconnected.connect(boost::bind(&HTTPConnectProxiedConnectionTest::handleDisconnected, this, _1));

+ c->onDataRead.connect(boost::bind(&HTTPConnectProxiedConnectionTest::handleDataRead, this, _1));

+ return c;

+ }

+

+ void handleConnectFinished(bool error) {

+ connectFinished = true;

+ connectFinishedWithError = error;

+ }

+

+ void handleDisconnected(const boost::optional<Connection::Error>& e) {

+ disconnected = true;

+ disconnectedError = e;

+ }

+

+ void handleDataRead(const ByteArray& d) {

+ dataRead += d;

+ }

+

+ struct MockConnection : public Connection {

+ public:

+ MockConnection(const std::vector<HostAddressPort>& failingPorts, EventLoop* eventLoop) : eventLoop(eventLoop), failingPorts(failingPorts), disconnected(false) {

+ }

+

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

+

+ void connect(const HostAddressPort& address) {

+ hostAddressPort = address;

+ bool fail = std::find(failingPorts.begin(), failingPorts.end(), address) != failingPorts.end();

+ eventLoop->postEvent(boost::bind(boost::ref(onConnectFinished), fail));

+ }

+

+ HostAddressPort getLocalAddress() const { return HostAddressPort(); }

+

+ void disconnect() {

+ disconnected = true;

+ onDisconnected(boost::optional<Connection::Error>());

+ }

+

+ void write(const ByteArray& d) {

+ dataWritten += d;

+ }

+

+ EventLoop* eventLoop;

+ boost::optional<HostAddressPort> hostAddressPort;

+ std::vector<HostAddressPort> failingPorts;

+ ByteArray dataWritten;

+ bool disconnected;

+ };

+

+ struct MockConnectionFactory : public ConnectionFactory {

+ MockConnectionFactory(EventLoop* eventLoop) : eventLoop(eventLoop) {

+ }

+

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

+ boost::shared_ptr<MockConnection> connection = boost::make_shared<MockConnection>(failingPorts, eventLoop);

+ connections.push_back(connection);

+ return connection;

+ }

+

+ EventLoop* eventLoop;

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

+ std::vector<HostAddressPort> failingPorts;

+ };

+

+ private:

+ HostAddressPort proxyHost;

+ HostAddressPort host;

+ DummyEventLoop* eventLoop;

+ MockConnectionFactory* connectionFactory;

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

+ bool connectFinished;

+ bool connectFinishedWithError;

+ bool disconnected;

+ boost::optional<Connection::Error> disconnectedError;

+ ByteArray dataRead;

+};

+

+CPPUNIT_TEST_SUITE_REGISTRATION(HTTPConnectProxiedConnectionTest);

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

+/*

+ * Copyright (c) 2010-2011 Thilo Cestonaro

+ * Licensed under the simplified BSD license.

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

+ */

+

+#include <stdio.h>

+#include <stdlib.h>

+#include <iostream>

+

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

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

+

+namespace Swift {

+

+UnixProxyProvider::UnixProxyProvider() :

+#if defined(HAVE_GCONF)

+ gconfProxyProvider(),

+#endif

+ environmentProxyProvider()

+{

+}

+

+HostAddressPort UnixProxyProvider::getSOCKS5Proxy() const {

+ HostAddressPort proxy;

+#if defined(HAVE_GCONF)

+ proxy = gconfProxyProvider.getSOCKS5Proxy();

+ if(proxy.isValid()) {

+ return proxy;

+ }

+#endif

+ proxy = environmentProxyProvider.getSOCKS5Proxy();

+ if(proxy.isValid()) {

+ return proxy;

+ }

+ return HostAddressPort(HostAddress(), 0);

+}

+

+HostAddressPort UnixProxyProvider::getHTTPConnectProxy() const {

+ HostAddressPort proxy;

+#if defined(HAVE_GCONF)

+ proxy = gconfProxyProvider.getHTTPConnectProxy();

+ if(proxy.isValid()) {

+ return proxy;

+ }

+#endif

+ proxy = environmentProxyProvider.getHTTPConnectProxy();

+ if(proxy.isValid()) {

+ return proxy;

+ }

+ return HostAddressPort(HostAddress(), 0);

+}

+

+

+}

+/*

+ * Copyright (c) 2010-2011 Thilo Cestonaro

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+#if defined(HAVE_GCONF)

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

+#endif

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

+

+namespace Swift {

+ class UnixProxyProvider : public ProxyProvider {

+ public:

+ UnixProxyProvider();

+ virtual HostAddressPort getHTTPConnectProxy() const;

+ virtual HostAddressPort getSOCKS5Proxy() const;

+ private:

+#if defined(HAVE_GCONF)

+ GConfProxyProvider gconfProxyProvider;

+#endif

+ EnvironmentProxyProvider environmentProxyProvider;

+ };

+}

+/*

+ * Copyright (c) 2010-2011 Thilo Cestonaro

+ * Licensed under the simplified BSD license.

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

+ */

+

+#include <stdio.h>

+#include <stdlib.h>

+#include <math.h>

+#include <iostream>

+#include <boost/lexical_cast.hpp>

+

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

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

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

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

+

+#include <windows.h>

+

+namespace Swift {

+

+WindowsProxyProvider::WindowsProxyProvider()

+: ProxyProvider()

+{

+ HKEY hKey = (HKEY)INVALID_HANDLE_VALUE;

+ long result;

+

+ result = RegOpenKeyEx(HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings", 0, KEY_READ, &hKey);

+ if (result == ERROR_SUCCESS && hKey != INVALID_HANDLE_VALUE && proxyEnabled(hKey)) {

+ DWORD dataType = REG_SZ;

+ DWORD dataSize = 0;

+ ByteArray dataBuffer;

+

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

+ if(result != ERROR_SUCCESS) {

+ return;

+ }

+ dataBuffer.resize(dataSize);

+ result = RegQueryValueEx(hKey, "ProxyServer", NULL, &dataType, reinterpret_cast<BYTE*>(dataBuffer.getData()), &dataSize);

+ if(result == ERROR_SUCCESS) {

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

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

+ foreach(std::string proxy, proxies) {

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

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

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

+ if(protocolAndProxy.first.compare("socks") == 0) {

+ socksProxy = getAsHostAddressPort(protocolAndProxy.second);

+ }

+ else if (protocolAndProxy.first.compare("http") == 0) {

+ httpProxy = getAsHostAddressPort(protocolAndProxy.second);

+ }

+ }

+ }

+ }

+ }

+}

+

+HostAddressPort WindowsProxyProvider::getHTTPConnectProxy() const {

+ return httpProxy;

+}

+

+HostAddressPort WindowsProxyProvider::getSOCKS5Proxy() const {

+ return socksProxy;

+}

+

+HostAddressPort WindowsProxyProvider::getAsHostAddressPort(std::string proxy) {

+ HostAddressPort ret(HostAddress(), 0);

+

+ try {

+ std::pair<std::string, std::string> tmp;

+ int port = 0;

+ tmp = String::getSplittedAtFirst(proxy, ':');

+ // .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());

+ ret = HostAddressPort(HostAddress(tmp.first), port);

+ }

+ catch(...) {

+ std::cerr << "Exception occured while parsing windows proxy \"getHostAddressPort\"." << std::endl;

+ }

+

+ return ret;

+}

+

+

+bool WindowsProxyProvider::proxyEnabled(HKEY hKey) const {

+ bool ret = false;

+ long result;

+ DWORD dataType = REG_DWORD;

+ DWORD dataSize = 0;

+ DWORD data = 0;

+ ByteArray dataBuffer;

+

+ if(hKey == INVALID_HANDLE_VALUE)

+ return ret;

+

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

+ if(result != ERROR_SUCCESS)

+ return ret;

+

+ dataBuffer.resize(dataSize);

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

+ if(result != ERROR_SUCCESS)

+ return ret;

+

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

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

+ }

+ return (data == 1);

+}

+

+}

+/*

+ * Copyright (c) 2010-2011 Thilo Cestonaro

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

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

+

+namespace Swift {

+ class WindowsProxyProvider : public ProxyProvider {

+ public:

+ WindowsProxyProvider();

+ virtual HostAddressPort getHTTPConnectProxy() const;

+ virtual HostAddressPort getSOCKS5Proxy() const;

+ private:

+ HostAddressPort getAsHostAddressPort(std::string proxy);

+ bool proxyEnabled(HKEY hKey) const;

+ HostAddressPort socksProxy;

+ HostAddressPort httpProxy;

+ };

+}