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

+#include <string>

+#include <algorithm>

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

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

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

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

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

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

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

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

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

+ SharedBuffer(const SafeByteArray& data) :

+ data_(new std::vector<char, SafeAllocator<char> >(data.begin(), data.end())),

+ boost::shared_ptr< std::vector<char, SafeAllocator<char> > > data_;

+ eventLoop(eventLoop), ioService(ioService), socket_(*ioService), writing_(false) {

+void BoostConnection::write(const SafeByteArray& data) {

+ append(writeQueue_, data);

+void BoostConnection::doWrite(const SafeByteArray& data) {

+ readBuffer_ = boost::make_shared<SafeByteArray>(BUFFER_SIZE);

+ boost::asio::buffer(*readBuffer_),

+ readBuffer_->resize(bytesTransferred);

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

+ if (writeQueue_.empty()) {

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

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

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

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

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

+ virtual void write(const SafeByteArray& data);

+ void doWrite(const SafeByteArray& data);

+ boost::shared_ptr<SafeByteArray> readBuffer_;

+ SafeByteArray writeQueue_;

+#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>

+ boost::shared_ptr<boost::asio::io_service> getIOService() const {

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

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

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

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

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

+#ifdef SWIFT_EXPERIMENTAL_FT

+ natTraverser = new PlatformNATTraversalWorker(eventLoop);

+#else

+ natTraverser = new NullNATTraverser(eventLoop);

+#endif

+ delete natTraverser;

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

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

+ class NATTraverser;

+ NATTraverser* getNATTraverser() const {

+ return natTraverser;

+ }

+

+ NATTraverser* natTraverser;

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

+ class HostAddressPort;

+

+ Connection();

+ virtual ~Connection();

+ virtual void write(const SafeByteArray& data) = 0;

+ boost::signal<void (boost::shared_ptr<SafeByteArray>)> onDataRead;

+#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>

+ return ref(new Connector(hostname, resolver, connectionFactory, timerFactory));

+#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 <boost/smart_ptr/make_shared.hpp>

+#include <cassert>

+

+namespace Swift {

+

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

+}

+

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

+ eventLoop->postEvent(boost::bind(boost::ref(onDataRead), boost::make_shared<SafeByteArray>(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 write(const SafeByteArray& data) {

+ void receive(const SafeByteArray& data);

+ boost::signal<void (const SafeByteArray&)> onDataSent;

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

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

+

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

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

+

+namespace Swift {

+

+class EventLoop;

+

+class DummyConnectionFactory : public ConnectionFactory {

+public:

+ DummyConnectionFactory(EventLoop *eventLoop) : eventLoop(eventLoop) {}

+ virtual ~DummyConnectionFactory() {}

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

+ return boost::make_shared<DummyConnection>(eventLoop);

+ }

+private:

+ EventLoop* eventLoop;

+};

+

+}

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

+ virtual void write(const SafeByteArray& data) {

+ std::vector<SafeByteArray> dataWritten;

+/*

+ * 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() {

+ // Ensure static GLib initialization methods are called

+ static bool glibInitialized = false;

+ if (!glibInitialized) {

+ g_type_init();

+ glibInitialized = true;

+ }

+

+ 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 SafeByteArray& 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(createSafeByteArray(connect.str()));

+ }

+ else {

+ onConnectFinished(true);

+ }

+}

+

+void HTTPConnectProxiedConnection::handleDataRead(boost::shared_ptr<SafeByteArray> data) {

+ if (!connected_) {

+ SWIFT_LOG(debug) << byteArrayToString(ByteArray(data->begin(), data->end())) << std::endl;

+ std::vector<std::string> tmp = String::split(byteArrayToString(ByteArray(data->begin(), data->end())), ' ');

+ 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: " << byteArrayToString(ByteArray(data->begin(), data->end())) << 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 SafeByteArray& data);

+

+ virtual HostAddressPort getLocalAddress() const;

+ private:

+ HTTPConnectProxiedConnection(ConnectionFactory* connectionFactory, HostAddressPort proxy);

+

+ void handleConnectionConnectFinished(bool error);

+ void handleDataRead(boost::shared_ptr<SafeByteArray> 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&) {

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

+/*

+ * 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;

+ };

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

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

+

+#include <upnpcommands.h>

+#include <upnperrors.h>

+#include <boost/lexical_cast.hpp>

+

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

+

+namespace Swift {

+

+MiniUPnPInterface::MiniUPnPInterface() : isValid(false) {

+ int error = 0;

+ deviceList = upnpDiscover(1500 /* timeout in ms */, 0, 0, 0, 0 /* do IPv6? */, &error);

+ if (!deviceList) {

+ return;

+ }

+

+ char lanAddress[64];

+ if (!UPNP_GetValidIGD(deviceList, &urls, &data, lanAddress, sizeof(lanAddress))) {

+ return;

+ }

+ localAddress = std::string(lanAddress);

+ isValid = true;

+}

+

+MiniUPnPInterface::~MiniUPnPInterface() {

+ if (isValid) {

+ FreeUPNPUrls(&urls);

+ }

+ freeUPNPDevlist(deviceList);

+}

+

+boost::optional<HostAddress> MiniUPnPInterface::getPublicIP() {

+ if (!isValid) {

+ return boost::optional<HostAddress>();

+ }

+ char externalIPAddress[40];

+ int ret = UPNP_GetExternalIPAddress(urls.controlURL, data.first.servicetype, externalIPAddress);

+ if (ret != UPNPCOMMAND_SUCCESS) {

+ return boost::optional<HostAddress>();

+ }

+ else {

+ return HostAddress(std::string(externalIPAddress));

+ }

+}

+

+boost::optional<NATPortMapping> MiniUPnPInterface::addPortForward(int actualLocalPort, int actualPublicPort) {

+ if (!isValid) {

+ return boost::optional<NATPortMapping>();

+ }

+

+ NATPortMapping mapping(actualLocalPort, actualPublicPort, NATPortMapping::TCP);

+

+ std::string publicPort = boost::lexical_cast<std::string>(mapping.publicPort);

+ std::string localPort = boost::lexical_cast<std::string>(mapping.localPort);

+ std::string leaseSeconds = boost::lexical_cast<std::string>(mapping.leaseInSeconds);

+

+ int ret = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype, publicPort.c_str(), localPort.c_str(), localAddress.c_str(), 0, mapping.protocol == NATPortMapping::TCP ? "TCP" : "UDP", 0, leaseSeconds.c_str());

+ if (ret == UPNPCOMMAND_SUCCESS) {

+ return mapping;

+ }

+ else {

+ return boost::optional<NATPortMapping>();

+ }

+}

+

+bool MiniUPnPInterface::removePortForward(const NATPortMapping& mapping) {

+ if (!isValid) {

+ return false;

+ }

+

+ std::string publicPort = boost::lexical_cast<std::string>(mapping.publicPort);

+ std::string localPort = boost::lexical_cast<std::string>(mapping.localPort);

+ std::string leaseSeconds = boost::lexical_cast<std::string>(mapping.leaseInSeconds);

+

+ int ret = UPNP_DeletePortMapping(urls.controlURL, data.first.servicetype, publicPort.c_str(), mapping.protocol == NATPortMapping::TCP ? "TCP" : "UDP", 0);

+ return ret == UPNPCOMMAND_SUCCESS;

+}

+

+}

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <boost/optional.hpp>

+#include <miniupnpc.h>

+

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

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

+

+namespace Swift {

+ class MiniUPnPInterface : public NATTraversalInterface {

+ public:

+ MiniUPnPInterface();

+ ~MiniUPnPInterface();

+

+ virtual bool isAvailable() {

+ return isValid;

+ }

+

+ boost::optional<HostAddress> getPublicIP();

+ boost::optional<NATPortMapping> addPortForward(int localPort, int publicPort);

+ bool removePortForward(const NATPortMapping&);

+

+ private:

+ bool isValid;

+ std::string localAddress;

+ UPNPDev* deviceList;

+ UPNPUrls urls;

+ IGDdatas data;

+ };

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

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

+

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

+

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

+

+namespace Swift {

+

+NATPMPInterface::NATPMPInterface() {

+ initnatpmp(&natpmp, 0, 0);

+}

+

+NATPMPInterface::~NATPMPInterface() {

+ closenatpmp(&natpmp);

+}

+

+bool NATPMPInterface::isAvailable() {

+ return getPublicIP();

+}

+

+boost::optional<HostAddress> NATPMPInterface::getPublicIP() {

+ if (sendpublicaddressrequest(&natpmp) < 0) {

+ SWIFT_LOG(debug) << "Failed to send NAT-PMP public address request!" << std::endl;

+ return boost::optional<HostAddress>();

+ }

+

+ int r = 0;

+ natpmpresp_t response;

+ do {

+ fd_set fds;

+ struct timeval timeout;

+ FD_ZERO(&fds);

+ FD_SET(natpmp.s, &fds);

+ getnatpmprequesttimeout(&natpmp, &timeout);

+ select(FD_SETSIZE, &fds, NULL, NULL, &timeout);

+ r = readnatpmpresponseorretry(&natpmp, &response);

+ } while (r == NATPMP_TRYAGAIN);

+

+ if (r == 0) {

+ return boost::optional<HostAddress>(HostAddress(reinterpret_cast<const unsigned char*>(&(response.pnu.publicaddress.addr)), 4));

+ }

+ else {

+ SWIFT_LOG(debug) << "Inavlid NAT-PMP response." << std::endl;

+ return boost::optional<HostAddress>();

+ }

+}

+

+boost::optional<NATPortMapping> NATPMPInterface::addPortForward(int localPort, int publicPort) {

+ NATPortMapping mapping(localPort, publicPort, NATPortMapping::TCP);

+ if (sendnewportmappingrequest(&natpmp, mapping.protocol == NATPortMapping::TCP ? NATPMP_PROTOCOL_TCP : NATPMP_PROTOCOL_UDP, mapping.leaseInSeconds, mapping.publicPort, mapping.localPort) < 0) {

+ SWIFT_LOG(debug) << "Failed to send NAT-PMP port forwarding request!" << std::endl;

+ return boost::optional<NATPortMapping>();

+ }

+

+ int r = 0;

+ natpmpresp_t response;

+ do {

+ fd_set fds;

+ struct timeval timeout;

+ FD_ZERO(&fds);

+ FD_SET(natpmp.s, &fds);

+ getnatpmprequesttimeout(&natpmp, &timeout);

+ select(FD_SETSIZE, &fds, NULL, NULL, &timeout);

+ r = readnatpmpresponseorretry(&natpmp, &response);

+ } while(r == NATPMP_TRYAGAIN);

+

+ if (r == 0) {

+ mapping.localPort = response.pnu.newportmapping.privateport;

+ mapping.publicPort = response.pnu.newportmapping.mappedpublicport;

+ mapping.leaseInSeconds = response.pnu.newportmapping.lifetime;

+ return mapping;

+ }

+ else {

+ SWIFT_LOG(debug) << "Invalid NAT-PMP response." << std::endl;

+ return boost::optional<NATPortMapping>();

+ }

+}

+

+bool NATPMPInterface::removePortForward(const NATPortMapping& mapping) {

+ if (sendnewportmappingrequest(&natpmp, mapping.protocol == NATPortMapping::TCP ? NATPMP_PROTOCOL_TCP : NATPMP_PROTOCOL_UDP, 0, 0, mapping.localPort) < 0) {

+ SWIFT_LOG(debug) << "Failed to send NAT-PMP remove forwarding request!" << std::endl;

+ return false;

+ }

+

+ int r = 0;

+ natpmpresp_t response;

+ do {

+ fd_set fds;

+ struct timeval timeout;

+ FD_ZERO(&fds);

+ FD_SET(natpmp.s, &fds);

+ getnatpmprequesttimeout(&natpmp, &timeout);

+ select(FD_SETSIZE, &fds, NULL, NULL, &timeout);

+ r = readnatpmpresponseorretry(&natpmp, &response);

+ } while(r == NATPMP_TRYAGAIN);

+

+ if (r == 0) {

+ return true;

+ }

+ else {

+ SWIFT_LOG(debug) << "Invalid NAT-PMP response." << std::endl;

+ return false;

+ }

+}

+

+

+}

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <boost/optional.hpp>

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

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

+

+// This has to be included after the previous headers, because of WIN32 macro

+// being defined somewhere.

+#include <natpmp.h>

+

+namespace Swift {

+ class NATPMPInterface : public NATTraversalInterface {

+ public:

+ NATPMPInterface();

+ ~NATPMPInterface();

+

+ virtual bool isAvailable();

+

+ virtual boost::optional<HostAddress> getPublicIP();

+ virtual boost::optional<NATPortMapping> addPortForward(int localPort, int publicPort);

+ virtual bool removePortForward(const NATPortMapping&);

+

+ private:

+ natpmp_t natpmp;

+ };

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

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

+

+namespace Swift {

+ struct NATPortMapping {

+ enum Protocol {

+ TCP,

+ UDP,

+ };

+

+ NATPortMapping(int localPort, int publicPort, Protocol protocol = TCP, int leaseInSeconds = 60 * 60 * 24) : publicPort(publicPort), localPort(localPort), protocol(protocol), leaseInSeconds(leaseInSeconds) {

+

+ }

+

+ int publicPort;

+ int localPort;

+ Protocol protocol;

+ int leaseInSeconds;

+ };

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

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

+

+namespace Swift {

+

+NATTraversalForwardPortRequest::~NATTraversalForwardPortRequest() {

+}

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

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

+

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

+

+namespace Swift {

+ class NATTraversalForwardPortRequest {

+ public:

+ virtual ~NATTraversalForwardPortRequest();

+

+ virtual void run() = 0;

+

+ boost::signal<void (boost::optional<NATPortMapping>)> onResult;

+ };

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

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

+

+namespace Swift {

+

+NATTraversalGetPublicIPRequest::~NATTraversalGetPublicIPRequest() {

+}

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

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

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

+

+namespace Swift {

+ class NATTraversalGetPublicIPRequest {

+ public:

+ virtual ~NATTraversalGetPublicIPRequest();

+

+ virtual void run() = 0;

+

+ boost::signal<void (boost::optional<HostAddress>)> onResult;

+ };

+}

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the simplified BSD license.

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

+ */

+

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

+

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

+

+

+namespace Swift {

+

+NATTraversalInterface::~NATTraversalInterface() {

+}

+

+}

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <boost/optional.hpp>

+

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

+

+namespace Swift {

+ class NATTraversalInterface {

+ public:

+ virtual ~NATTraversalInterface();

+

+ virtual bool isAvailable() = 0;

+

+ virtual boost::optional<HostAddress> getPublicIP() = 0;

+ virtual boost::optional<NATPortMapping> addPortForward(int localPort, int publicPort) = 0;

+ virtual bool removePortForward(const NATPortMapping&) = 0;

+ };

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

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

+

+namespace Swift {

+

+NATTraversalRemovePortForwardingRequest::~NATTraversalRemovePortForwardingRequest() {

+}

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

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

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

+

+namespace Swift {

+ class NATTraversalRemovePortForwardingRequest {

+ public:

+ struct PortMapping {

+ enum Protocol {

+ TCP,

+ UDP,

+ };

+

+ unsigned int publicPort;

+ unsigned int localPort;

+ Protocol protocol;

+ unsigned long leaseInSeconds;

+ };

+

+ public:

+ virtual ~NATTraversalRemovePortForwardingRequest();

+

+ virtual void run() = 0;

+

+ boost::signal<void (boost::optional<bool> /* failure */)> onResult;

+ };

+}

+/*

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

+

+namespace Swift {

+

+NATTraverser::~NATTraverser() {

+}

+

+}

+/*

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

+

+namespace Swift {

+ class NATTraversalGetPublicIPRequest;

+ class NATTraversalForwardPortRequest;

+ class NATTraversalRemovePortForwardingRequest;

+

+ class NATTraverser {

+ public:

+ virtual ~NATTraverser();

+

+ virtual boost::shared_ptr<NATTraversalGetPublicIPRequest> createGetPublicIPRequest() = 0;

+ virtual boost::shared_ptr<NATTraversalForwardPortRequest> createForwardPortRequest(int localPort, int publicPort) = 0;

+ virtual boost::shared_ptr<NATTraversalRemovePortForwardingRequest> createRemovePortForwardingRequest(int localPort, int publicPort) = 0;

+ };

+}

+/*

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

+

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

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

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

+

+namespace Swift {

+

+NetworkEnvironment::~NetworkEnvironment() {

+}

+

+HostAddress NetworkEnvironment::getLocalAddress() const {

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

+ foreach (const NetworkInterface& iface, networkInterfaces) {

+ if (!iface.isLoopback()) {

+ foreach (const HostAddress& address, iface.getAddresses()) {

+ if (address.getRawAddress().is_v4()) {

+ return address;

+ }

+ }

+ }

+ }

+ return HostAddress();

+}

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <vector>

+

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

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

+

+namespace Swift {

+ class NetworkEnvironment {

+ public:

+ virtual ~NetworkEnvironment();

+

+ virtual std::vector<NetworkInterface> getNetworkInterfaces() const = 0;

+

+ HostAddress getLocalAddress() const;

+ };

+}

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

+ class NATTraverser;

+ virtual NATTraverser* getNATTraverser() const = 0;

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <vector>

+

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

+

+namespace Swift {

+ class NetworkInterface {

+ public:

+ NetworkInterface(const std::string& name, bool loopback) : name(name), loopback(loopback) {

+ }

+

+ void addAddress(const HostAddress& address) {

+ addresses.push_back(address);

+ }

+

+ const std::vector<HostAddress>& getAddresses() const {

+ return addresses;

+ }

+

+ const std::string& getName() const {

+ return name;

+ }

+

+ bool isLoopback() const {

+ return loopback;

+ }

+

+ private:

+ std::string name;

+ bool loopback;

+ std::vector<HostAddress> addresses;

+ };

+}

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <boost/optional.hpp>

+

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

+

+namespace Swift {

+ class NullNATTraversalInterface : public NATTraversalInterface {

+ public:

+ virtual bool isAvailable() {

+ return true;

+ }

+

+ virtual boost::optional<HostAddress> getPublicIP() {

+ return boost::optional<HostAddress>();

+ }

+

+ virtual boost::optional<NATPortMapping> addPortForward(int, int) {

+ return boost::optional<NATPortMapping>();

+ }

+

+ virtual bool removePortForward(const NATPortMapping&) {

+ return false;

+ }

+ };

+}

+/*

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

+

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

+#include <boost/bind.hpp>

+

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

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

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

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

+

+namespace Swift {

+

+class NullNATTraversalGetPublicIPRequest : public NATTraversalGetPublicIPRequest {

+ public:

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

+ }

+

+ virtual void run() {

+ eventLoop->postEvent(boost::bind(boost::ref(onResult), boost::optional<HostAddress>()));

+ }

+

+ private:

+ EventLoop* eventLoop;

+};

+

+class NullNATTraversalForwardPortRequest : public NATTraversalForwardPortRequest {

+ public:

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

+ }

+

+ virtual void run() {

+ eventLoop->postEvent(boost::bind(boost::ref(onResult), boost::optional<NATPortMapping>()));

+ }

+

+ private:

+ EventLoop* eventLoop;

+};

+

+class NullNATTraversalRemovePortForwardingRequest : public NATTraversalRemovePortForwardingRequest {

+ public:

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

+ }

+

+ virtual void run() {

+ eventLoop->postEvent(boost::bind(boost::ref(onResult), boost::optional<bool>(true)));

+ }

+

+ private:

+ EventLoop* eventLoop;

+};

+

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

+}

+

+boost::shared_ptr<NATTraversalGetPublicIPRequest> NullNATTraverser::createGetPublicIPRequest() {

+ return boost::make_shared<NullNATTraversalGetPublicIPRequest>(eventLoop);

+}

+

+boost::shared_ptr<NATTraversalForwardPortRequest> NullNATTraverser::createForwardPortRequest(int, int) {

+ return boost::make_shared<NullNATTraversalForwardPortRequest>(eventLoop);

+}

+

+boost::shared_ptr<NATTraversalRemovePortForwardingRequest> NullNATTraverser::createRemovePortForwardingRequest(int, int) {

+ return boost::make_shared<NullNATTraversalRemovePortForwardingRequest>(eventLoop);

+}

+

+}

+/*

+ * 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 <Swiften/Network/NATTraverser.h>

+

+namespace Swift {

+ class EventLoop;

+

+ class NullNATTraverser : public NATTraverser {

+ public:

+ NullNATTraverser(EventLoop* eventLoop);

+

+ boost::shared_ptr<NATTraversalGetPublicIPRequest> createGetPublicIPRequest();

+ boost::shared_ptr<NATTraversalForwardPortRequest> createForwardPortRequest(int localPort, int publicPort);

+ boost::shared_ptr<NATTraversalRemovePortForwardingRequest> createRemovePortForwardingRequest(int localPort, int publicPort);

+

+ private:

+ EventLoop* eventLoop;

+ };

+}

+/*

+ * 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>

+ int responseLength = res_query(const_cast<char*>(service.c_str()), ns_c_in, ns_t_srv, reinterpret_cast<u_char*>(vecptr(response)), response.size());

+ HEADER* header = reinterpret_cast<HEADER*>(vecptr(response));

+ unsigned char* messageStart = vecptr(response);

+ entryLength = dn_expand(messageStart, messageEnd, currentEntry, reinterpret_cast<char*>(vecptr(entry)), entry.size());

+ record.hostname = std::string(reinterpret_cast<const char*>(vecptr(entry)));

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

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

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#include "PlatformNATTraversalWorker.h"

+

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

+#include <boost/enable_shared_from_this.hpp>

+

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

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

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

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

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

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

+

+namespace Swift {

+

+class PlatformNATTraversalRequest : public boost::enable_shared_from_this<PlatformNATTraversalRequest> {

+ public:

+ typedef boost::shared_ptr<PlatformNATTraversalRequest> ref;

+

+ public:

+ PlatformNATTraversalRequest(PlatformNATTraversalWorker* worker) : worker(worker) {

+ }

+

+ virtual ~PlatformNATTraversalRequest() {

+ }

+

+ virtual void doRun() {

+ worker->addRequestToQueue(shared_from_this());

+ }

+

+ NATTraversalInterface* getNATTraversalInterface() const {

+ return worker->getNATTraversalInterface();

+ }

+

+

+ virtual void runBlocking() = 0;

+

+ private:

+ PlatformNATTraversalWorker* worker;

+};

+

+class PlatformNATTraversalGetPublicIPRequest : public NATTraversalGetPublicIPRequest, public PlatformNATTraversalRequest {

+ public:

+ PlatformNATTraversalGetPublicIPRequest(PlatformNATTraversalWorker* worker) : PlatformNATTraversalRequest(worker) {

+ }

+

+ virtual void run() {

+ doRun();

+ }

+

+ virtual void runBlocking() {

+ onResult(getNATTraversalInterface()->getPublicIP());

+ }

+};

+

+class PlatformNATTraversalForwardPortRequest : public NATTraversalForwardPortRequest, public PlatformNATTraversalRequest {

+ public:

+ PlatformNATTraversalForwardPortRequest(PlatformNATTraversalWorker* worker, unsigned int localIP, unsigned int publicIP) : PlatformNATTraversalRequest(worker), localIP(localIP), publicIP(publicIP) {

+ }

+

+ virtual void run() {

+ doRun();

+ }

+

+ virtual void runBlocking() {

+ onResult(getNATTraversalInterface()->addPortForward(localIP, publicIP));

+ }

+

+ private:

+ unsigned int localIP;

+ unsigned int publicIP;

+};

+

+class PlatformNATTraversalRemovePortForwardingRequest : public NATTraversalRemovePortForwardingRequest, public PlatformNATTraversalRequest {

+ public:

+ PlatformNATTraversalRemovePortForwardingRequest(PlatformNATTraversalWorker* worker, const NATPortMapping& mapping) : PlatformNATTraversalRequest(worker), mapping(mapping) {

+ }

+

+ virtual void run() {

+ doRun();

+ }

+

+ virtual void runBlocking() {

+ onResult(getNATTraversalInterface()->removePortForward(mapping));

+ }

+

+ private:

+ NATPortMapping mapping;

+};

+

+PlatformNATTraversalWorker::PlatformNATTraversalWorker(EventLoop* eventLoop) : eventLoop(eventLoop), stopRequested(false), natPMPSupported(boost::logic::indeterminate), natPMPInterface(NULL), miniUPnPSupported(boost::logic::indeterminate), miniUPnPInterface(NULL) {

+ nullNATTraversalInterface = new NullNATTraversalInterface();

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

+}

+

+PlatformNATTraversalWorker::~PlatformNATTraversalWorker() {

+ stopRequested = true;

+ addRequestToQueue(boost::shared_ptr<PlatformNATTraversalRequest>());

+ thread->join();

+ delete thread;

+ delete natPMPInterface;

+ delete miniUPnPInterface;

+ delete nullNATTraversalInterface;

+}

+

+NATTraversalInterface* PlatformNATTraversalWorker::getNATTraversalInterface() const {

+ if (boost::logic::indeterminate(miniUPnPSupported)) {

+ miniUPnPInterface = new MiniUPnPInterface();

+ miniUPnPSupported = miniUPnPInterface->isAvailable();

+ }

+ if (miniUPnPSupported) {

+ return miniUPnPInterface;

+ }

+

+

+ if (boost::logic::indeterminate(natPMPSupported)) {

+ natPMPInterface = new NATPMPInterface();

+ natPMPSupported = natPMPInterface->isAvailable();

+ }

+ if (natPMPSupported) {

+ return natPMPInterface;

+ }

+

+ return nullNATTraversalInterface;

+}

+

+boost::shared_ptr<NATTraversalGetPublicIPRequest> PlatformNATTraversalWorker::createGetPublicIPRequest() {

+ return boost::make_shared<PlatformNATTraversalGetPublicIPRequest>(this);

+}

+

+boost::shared_ptr<NATTraversalForwardPortRequest> PlatformNATTraversalWorker::createForwardPortRequest(int localPort, int publicPort) {

+ return boost::make_shared<PlatformNATTraversalForwardPortRequest>(this, localPort, publicPort);

+}

+

+boost::shared_ptr<NATTraversalRemovePortForwardingRequest> PlatformNATTraversalWorker::createRemovePortForwardingRequest(int localPort, int publicPort) {

+ NATPortMapping mapping(localPort, publicPort, NATPortMapping::TCP); // FIXME

+ return boost::make_shared<PlatformNATTraversalRemovePortForwardingRequest>(this, mapping);

+}

+

+void PlatformNATTraversalWorker::run() {

+ while (!stopRequested) {

+ PlatformNATTraversalRequest::ref request;

+ {

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

+ while (queue.empty()) {

+ queueNonEmpty.wait(lock);

+ }

+ request = queue.front();

+ queue.pop_front();

+ }

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

+ // worker)

+ if (request) {

+ request->runBlocking();

+ }

+ }

+}

+

+void PlatformNATTraversalWorker::addRequestToQueue(PlatformNATTraversalRequest::ref request) {

+ {

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

+ queue.push_back(request);

+ }

+ queueNonEmpty.notify_one();

+}

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <deque>

+#include <boost/optional.hpp>

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

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

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

+#include <boost/logic/tribool.hpp>

+

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

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

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

+

+namespace Swift {

+ class EventLoop;

+ class NATTraversalGetPublicIPRequest;

+ class NATTraversalForwardPortRequest;

+ class NATTraversalRemovePortForwardingRequest;

+ class PlatformNATTraversalRequest;

+ class NATPMPInterface;

+ class MiniUPnPInterface;

+ class NATTraversalInterface;

+ class NATPortMapping;

+

+ class PlatformNATTraversalWorker : public NATTraverser {

+ friend class PlatformNATTraversalRequest;

+

+ public:

+ PlatformNATTraversalWorker(EventLoop* eventLoop);

+ ~PlatformNATTraversalWorker();

+

+ boost::shared_ptr<NATTraversalGetPublicIPRequest> createGetPublicIPRequest();

+ boost::shared_ptr<NATTraversalForwardPortRequest> createForwardPortRequest(int localPort, int publicPort);

+ boost::shared_ptr<NATTraversalRemovePortForwardingRequest> createRemovePortForwardingRequest(int localPort, int publicPort);

+

+ private:

+ NATTraversalInterface* getNATTraversalInterface() const;

+ void addRequestToQueue(boost::shared_ptr<PlatformNATTraversalRequest>);

+ void run();

+

+ private:

+ EventLoop* eventLoop;

+ bool stopRequested;

+ boost::thread* thread;

+ std::deque<boost::shared_ptr<PlatformNATTraversalRequest> > queue;

+ boost::mutex queueMutex;

+ boost::condition_variable queueNonEmpty;

+

+ NullNATTraversalInterface* nullNATTraversalInterface;

+ mutable boost::logic::tribool natPMPSupported;

+ mutable NATPMPInterface* natPMPInterface;

+ mutable boost::logic::tribool miniUPnPSupported;

+ mutable MiniUPnPInterface* miniUPnPInterface;

+ };

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

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

+namespace Swift {

+ typedef UnixNetworkEnvironment PlatformNetworkEnvironment;

+}

+#elif defined(SWIFTEN_PLATFORM_WIN32)

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

+namespace Swift {

+ typedef WindowsNetworkEnvironment PlatformNetworkEnvironment;

+}

+#else

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

+namespace Swift {

+ typedef UnixNetworkEnvironment PlatformNetworkEnvironment;

+}

+#endif

+/*

+ * 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",

+ "NetworkEnvironment.cpp",

+ "BoostTimer.cpp",

+ "ProxyProvider.cpp",

+ "NullProxyProvider.cpp",

+ "NATTraverser.cpp",

+ "NullNATTraverser.cpp",

+ "NATTraversalGetPublicIPRequest.cpp",

+ "NATTraversalForwardPortRequest.cpp",

+ "NATTraversalRemovePortForwardingRequest.cpp",

+ "NATTraversalInterface.cpp",

+ ]

+

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

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

+ sourceList += [ "MacOSXProxyProvider.cpp" ]

+ sourceList += [ "UnixNetworkEnvironment.cpp" ]

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

+ sourceList += [ "WindowsProxyProvider.cpp" ]

+ sourceList += [ "WindowsNetworkEnvironment.cpp" ]

+else :

+ sourceList += [ "UnixNetworkEnvironment.cpp" ]

+ 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" ]

+

+if myenv["experimental"] :

+ # LibNATPMP classes

+ natpmp_env = myenv.Clone()

+ natpmp_env.Append(CPPDEFINES = natpmp_env["LIBNATPMP_FLAGS"].get("INTERNAL_CPPDEFINES", []))

+ objects += natpmp_env.SwiftenObject([

+ "NATPMPInterface.cpp",

+ ])

+

+ # LibMINIUPnP classes

+ upnp_env = myenv.Clone()

+ upnp_env.Append(CPPDEFINES = upnp_env["LIBMINIUPNPC_FLAGS"].get("INTERNAL_CPPDEFINES", []))

+ objects += upnp_env.SwiftenObject([

+ "MiniUPnPInterface.cpp",

+ ])

+ objects += myenv.SwiftenObject([

+ "PlatformNATTraversalWorker.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 SafeByteArray& 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;

+ SafeByteArray socksConnect;

+ socksConnect.push_back(0x05); // VER = SOCKS5 = 0x05

+ socksConnect.push_back(0x01); // Number of authentication methods after this byte.

+ socksConnect.push_back(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(boost::shared_ptr<SafeByteArray> data) {

+ SafeByteArray 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.push_back(0x05); // VER = SOCKS5 = 0x05

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

+ socksConnect.push_back(0x00); // reserved.

+ socksConnect.push_back(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.push_back(static_cast<char>(uc));

+

+ }

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

+ socksConnect.push_back(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 SafeByteArray& data);

+

+ virtual HostAddressPort getLocalAddress() const;

+

+ private:

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

+

+ void handleConnectionConnectFinished(bool error);

+ void handleDataRead(boost::shared_ptr<SafeByteArray> 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 SafeByteArray&) { 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>

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

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+#include <QA/Checker/IO.h>

+

+#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/Base/Algorithm.h>

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

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

+ eventLoop->processEvents();

+

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

+ eventLoop->processEvents();

+

+ CPPUNIT_ASSERT(connectFinished);

+ CPPUNIT_ASSERT(!connectFinishedWithError);

+ CPPUNIT_ASSERT(dataRead.empty());

+ }

+

+ void testConnect_ReceiveMalformedConnectResponse() {

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

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

+ eventLoop->processEvents();

+

+ connectionFactory->connections[0]->onDataRead(createSafeByteArrayRef("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(createSafeByteArrayRef("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(createSafeByteArrayRef("HTTP/1.0 200 Connection established\r\n\r\n"));

+ eventLoop->processEvents();

+

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

+

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

+ }

+

+ void testWrite_AfterConnect() {

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

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

+ eventLoop->processEvents();

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

+ eventLoop->processEvents();

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

+

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

+

+ CPPUNIT_ASSERT_EQUAL(createByteArray("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(createSafeByteArrayRef("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(boost::shared_ptr<SafeByteArray> d) {

+ append(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 SafeByteArray& d) {

+ append(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) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

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

+

+#include <string>

+#include <vector>

+#include <map>

+#include <boost/optional.hpp>

+#include <sys/types.h>

+#include <sys/socket.h>

+#include <arpa/inet.h>

+#include <net/if.h>

+#include <ifaddrs.h>

+

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

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

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

+

+namespace Swift {

+

+std::vector<NetworkInterface> UnixNetworkEnvironment::getNetworkInterfaces() const {

+ std::map<std::string, NetworkInterface> interfaces;

+

+ ifaddrs* addrs = 0;

+ int ret = getifaddrs(&addrs);

+ if (ret != 0) {

+ return std::vector<NetworkInterface>();

+ }

+

+ for (ifaddrs* a = addrs; a != 0; a = a->ifa_next) {

+ std::string name(a->ifa_name);

+ boost::optional<HostAddress> address;

+ if (a->ifa_addr->sa_family == PF_INET) {

+ sockaddr_in* sa = reinterpret_cast<sockaddr_in*>(a->ifa_addr);

+ address = HostAddress(reinterpret_cast<const unsigned char*>(&(sa->sin_addr)), 4);

+ }

+ else if (a->ifa_addr->sa_family == PF_INET6) {

+ sockaddr_in6* sa = reinterpret_cast<sockaddr_in6*>(a->ifa_addr);

+ address = HostAddress(reinterpret_cast<const unsigned char*>(&(sa->sin6_addr)), 16);

+ }

+ if (address) {

+ std::map<std::string, NetworkInterface>::iterator i = interfaces.insert(std::make_pair(name, NetworkInterface(name, a->ifa_flags & IFF_LOOPBACK))).first;

+ i->second.addAddress(*address);

+ }

+ }

+

+ freeifaddrs(addrs);

+

+ std::vector<NetworkInterface> result;

+ for (std::map<std::string,NetworkInterface>::const_iterator i = interfaces.begin(); i != interfaces.end(); ++i) {

+ result.push_back(i->second);

+ }

+ return result;

+}

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <vector>

+

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

+

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

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

+

+namespace Swift {

+

+class UnixNetworkEnvironment : public NetworkEnvironment {

+ public:

+ std::vector<NetworkInterface> getNetworkInterfaces() const;

+};

+

+}

+/*

+ * 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>

+#if defined(HAVE_GCONF)

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

+#endif

+

+namespace Swift {

+

+UnixProxyProvider::UnixProxyProvider() :

+ gconfProxyProvider(0),

+ environmentProxyProvider()

+{

+#if defined(HAVE_GCONF)

+ gconfProxyProvider = new GConfProxyProvider();

+#endif

+}

+

+UnixProxyProvider::~UnixProxyProvider() {

+#if defined(HAVE_GCONF)

+ delete gconfProxyProvider;

+#endif

+}

+

+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

+

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

+

+namespace Swift {

+ class GConfProxyProvider;

+

+ class UnixProxyProvider : public ProxyProvider {

+ public:

+ UnixProxyProvider();

+ ~UnixProxyProvider();

+

+ virtual HostAddressPort getHTTPConnectProxy() const;

+ virtual HostAddressPort getSOCKS5Proxy() const;

+

+ private:

+ GConfProxyProvider* gconfProxyProvider;

+ EnvironmentProxyProvider environmentProxyProvider;

+ };

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

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

+

+#include <string>

+#include <vector>

+#include <map>

+#include <boost/optional.hpp>

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

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

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

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

+

+#include <winsock2.h>

+#include <iphlpapi.h>

+

+namespace Swift {

+

+std::vector<NetworkInterface> WindowsNetworkEnvironment::getNetworkInterfaces() const {

+ std::vector<NetworkInterface> result;

+

+ ByteArray adapters;

+ ULONG bufferSize = 0;

+ ULONG ret;

+ ULONG flags = GAA_FLAG_INCLUDE_ALL_INTERFACES | GAA_FLAG_INCLUDE_PREFIX | GAA_FLAG_SKIP_MULTICAST | GAA_FLAG_SKIP_DNS_SERVER;

+ while ((ret = GetAdaptersAddresses(AF_UNSPEC, flags, NULL, reinterpret_cast<IP_ADAPTER_ADDRESSES*>(vecptr(adapters)), &bufferSize)) == ERROR_BUFFER_OVERFLOW) {

+ adapters.resize(bufferSize);

+ };

+ if (ret != ERROR_SUCCESS) {

+ return result;

+ }

+

+ std::map<std::string,NetworkInterface> interfaces;

+ for (IP_ADAPTER_ADDRESSES* adapter = reinterpret_cast<IP_ADAPTER_ADDRESSES*>(vecptr(adapters)); adapter; adapter = adapter->Next) {

+ std::string name(adapter->AdapterName);

+ if (adapter->OperStatus != IfOperStatusUp) {

+ continue;

+ }

+ for (IP_ADAPTER_UNICAST_ADDRESS* address = adapter->FirstUnicastAddress; address; address = address->Next) {

+ boost::optional<HostAddress> hostAddress;

+ if (address->Address.lpSockaddr->sa_family == PF_INET) {

+ sockaddr_in* sa = reinterpret_cast<sockaddr_in*>(address->Address.lpSockaddr);

+ hostAddress = HostAddress(reinterpret_cast<const unsigned char*>(&(sa->sin_addr)), 4);

+ }

+ else if (address->Address.lpSockaddr->sa_family == PF_INET6) {

+ sockaddr_in6* sa = reinterpret_cast<sockaddr_in6*>(address->Address.lpSockaddr);

+ hostAddress = HostAddress(reinterpret_cast<const unsigned char*>(&(sa->sin6_addr)), 16);

+ }

+ if (hostAddress) {

+ std::map<std::string, NetworkInterface>::iterator i = interfaces.insert(std::make_pair(name, NetworkInterface(name, false))).first;

+ i->second.addAddress(*hostAddress);

+ }

+ }

+ }

+

+ for (std::map<std::string,NetworkInterface>::const_iterator i = interfaces.begin(); i != interfaces.end(); ++i) {

+ result.push_back(i->second);

+ }

+ return result;

+}

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <vector>

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

+

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

+

+namespace Swift {

+ class WindowsNetworkEnvironment : public NetworkEnvironment {

+ public:

+ std::vector<NetworkInterface> getNetworkInterfaces() const;

+ };

+}

+/*

+ * 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*>(vecptr(dataBuffer)), &dataSize);

+ if(result == ERROR_SUCCESS) {

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

+ 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*>(vecptr(dataBuffer)), &dataSize);

+ if(result != ERROR_SUCCESS)

+ return ret;

+

+ for(size_t t = 0; t < dataBuffer.size(); 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;

+ };

+}