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

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

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

+CoreClient::CoreClient(const JID& jid, const std::string& password, NetworkFactories* networkFactories) : jid_(jid), password_(password), networkFactories(networkFactories), useStreamCompression(true), useTLS(UseTLSWhenAvailable), proxyConnectionFactory_(NULL), disconnectRequested_(false), certificateTrustChecker(NULL) {

+ PlatformProxyProvider proxyProvider;

+

+ if(proxyProvider.getSOCKS5Proxy().isValid()) {

+ proxyConnectionFactory_ = new SOCKS5ProxiedConnectionFactory(networkFactories->getConnectionFactory(), proxyProvider.getSOCKS5Proxy());

+ }

+ else if(proxyProvider.getHTTPConnectProxy().isValid()) {

+ proxyConnectionFactory_ = new HTTPConnectProxiedConnectionFactory(networkFactories->getConnectionFactory(), proxyProvider.getHTTPConnectProxy());

+ }

+ delete proxyConnectionFactory_;

+ connector_ = Connector::create(host, networkFactories->getDomainNameResolver(), proxyConnectionFactory_ != NULL ? proxyConnectionFactory_ : networkFactories->getConnectionFactory(), networkFactories->getTimerFactory());

+ ConnectionFactory* proxyConnectionFactory_;

+/*

+ * 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-2011 Thilo Cestonaro

+ * Licensed under the simplified BSD license.

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

+ */

+

+#include <stdio.h>

+#include <stdlib.h>

+#include <iostream>

+

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

+

+#include "Swiften/Base/Log.h"

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

+

+namespace Swift {

+

+GConfProxyProvider::GConfProxyProvider() {

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

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

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

+}

+

+HostAddressPort GConfProxyProvider::getHTTPConnectProxy() const {

+ return httpProxy;

+}

+

+HostAddressPort GConfProxyProvider::getSOCKS5Proxy() const {

+ return socksProxy;

+}

+

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

+ std::string address;

+ int port = 0;

+ gchar* str;

+

+ GConfClient* client = gconf_client_get_default();

+

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

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

+

+ if(str) {

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

+ g_free(str);

+ }

+

+ g_object_unref(client);

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

+}

+

+}

+/*

+ * Copyright (c) 2010-2011 Thilo Cestonaro

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

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

+

+namespace Swift {

+ class GConfProxyProvider : public ProxyProvider {

+ public:

+ GConfProxyProvider();

+ virtual HostAddressPort getHTTPConnectProxy() const;

+ virtual HostAddressPort getSOCKS5Proxy() const;

+ private:

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

+ HostAddressPort socksProxy;

+ HostAddressPort httpProxy;

+ };

+}

+

+

+/*

+ * Copyright (c) 2010-2011 Thilo Cestonaro

+ * Licensed under the simplified BSD license.

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

+ */

+

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

+

+#include <iostream>

+#include <boost/bind.hpp>

+#include <boost/thread.hpp>

+#include <boost/lexical_cast.hpp>

+#include <math.h>

+

+#include "Swiften/Base/Log.h"

+#include "Swiften/Base/String.h"

+#include "Swiften/Base/ByteArray.h"

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

+

+namespace Swift {

+

+HTTPConnectProxiedConnection::HTTPConnectProxiedConnection(ConnectionFactory* connectionFactory, HostAddressPort proxy)

+: connectionFactory_(connectionFactory), proxy_(proxy), server_(HostAddressPort(HostAddress("0.0.0.0"), 0))

+{

+ connected_ = false;

+}

+

+HTTPConnectProxiedConnection::~HTTPConnectProxiedConnection() {

+ if(connection_) {

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

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

+ }

+

+ if(connected_) {

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

+ }

+}

+

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

+ server_ = server;

+ connection_ = connectionFactory_->createConnection();

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

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

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

+ connection_->connect(proxy_);

+}

+

+void HTTPConnectProxiedConnection::listen() {

+ assert(false);

+ connection_->listen();

+}

+

+void HTTPConnectProxiedConnection::disconnect() {

+ connected_ = false;

+ connection_->disconnect();

+}

+

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

+ onDisconnected(error);

+}

+

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

+ connection_->write(data);

+}

+

+void HTTPConnectProxiedConnection::handleConnectionConnectFinished(bool error) {

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

+ if(!error) {

+ proxyState_ = ProxyConnecting;

+ std::stringstream connect;

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

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

+ }

+ else {

+ onConnectFinished(true);

+ }

+}

+

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

+ if (!connected_) {

+ if (proxyState_ == ProxyConnecting) {

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

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

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

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

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

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

+ connected_ = true;

+ onConnectFinished(false);

+ return;

+ }

+ }

+

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

+ return;

+ }

+ }

+ else {

+ onDataRead(data);

+ return;

+ }

+ disconnect();

+ onConnectFinished(true);

+}

+

+HostAddressPort HTTPConnectProxiedConnection::getLocalAddress() const {

+ return connection_->getLocalAddress();

+}

+

+//namespace

+}

+/*

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

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

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

+

+namespace boost {

+ class thread;

+ namespace system {

+ class error_code;

+ }

+}

+

+namespace Swift {

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

+ public:

+ typedef boost::shared_ptr<HTTPConnectProxiedConnection> ref;

+

+ ~HTTPConnectProxiedConnection();

+

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

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

+ }

+

+ virtual void listen();

+ virtual void connect(const HostAddressPort& address);

+ virtual void disconnect();

+ virtual void write(const ByteArray& data);

+

+ virtual HostAddressPort getLocalAddress() const;

+ private:

+ enum {

+ ProxyAuthenticating = 0,

+ ProxyConnecting,

+ } proxyState_;

+

+ HTTPConnectProxiedConnection(ConnectionFactory* connectionFactory, HostAddressPort proxy);

+

+ void handleConnectionConnectFinished(bool error);

+ void handleDataRead(const ByteArray& data);

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

+

+ private:

+ bool connected_;

+ ConnectionFactory* connectionFactory_;

+ HostAddressPort proxy_;

+ HostAddressPort server_;

+ boost::shared_ptr<Connection> connection_;

+ };

+}

+/*

+ * Copyright (c) 2010-2011 Thilo Cestonaro

+ * Licensed under the simplified BSD license.

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

+ */

+

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

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

+

+namespace Swift {

+

+HTTPConnectProxiedConnectionFactory::HTTPConnectProxiedConnectionFactory(ConnectionFactory* connectionFactory, 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/HTTPConnectProxiedConnection.h"

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

+

+namespace Swift {

+ class HTTPConnectProxiedConnection;

+

+ class HTTPConnectProxiedConnectionFactory : public ConnectionFactory {

+ public:

+ HTTPConnectProxiedConnectionFactory(ConnectionFactory* connectionFactory, HostAddressPort proxy);

+

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

+

+ private:

+ ConnectionFactory* connectionFactory_;

+ HostAddressPort proxy_;

+ };

+}

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

+ return address_;

+}

+

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

+#include <boost/lexical_cast.hpp>

+

+ std::string toString() const {

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

+ }

+/*

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

+

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

+#include <SystemConfiguration/SystemConfiguration.h>

+

+namespace Swift {

+

+MacOSXProxyProvider::MacOSXProxyProvider()

+: ProxyProvider()

+{

+ CFDictionaryRef proxies = SCDynamicStoreCopyProxies(NULL);

+ if(proxies != NULL) {

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

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

+ }

+}

+

+HostAddressPort MacOSXProxyProvider::getHTTPConnectProxy() const {

+ return httpProxy;

+}

+

+HostAddressPort MacOSXProxyProvider::getSOCKS5Proxy() const {

+ return socksProxy;

+}

+

+HostAddressPort MacOSXProxyProvider::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;

+}

+

+}

+/*

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

+

+ private:

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

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

+ */

+

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

+ "BoostTimer.cpp",

+ "ProxyProvider.cpp"

+ ]

+

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

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

+ sourceList += [ "MacOSXProxyProvider.cpp" ]

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

+ sourceList += [ "WindowsProxyProvider.cpp" ]

+else :

+ sourceList += [ "UnixProxyProvider.cpp" ]

+ sourceList += [ "EnvironmentProxyProvider.cpp" ]

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

+ myenv.Append(CPPDEFINES = "HAVE_GCONF")

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

+ sourceList += [ "GConfProxyProvider.cpp" ]

+/*

+ * Copyright (c) 2010-2011 Thilo Cestonaro

+ * Licensed under the simplified BSD license.

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

+ */

+

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

+

+#include <iostream>

+#include <boost/bind.hpp>

+#include <boost/thread.hpp>

+#include <math.h>

+

+#include "Swiften/Base/Log.h"

+#include "Swiften/Base/String.h"

+#include "Swiften/Base/ByteArray.h"

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

+

+namespace Swift {

+

+SOCKS5ProxiedConnection::SOCKS5ProxiedConnection(ConnectionFactory* connectionFactory, HostAddressPort proxy)

+: connectionFactory_(connectionFactory), proxy_(proxy), server_(HostAddressPort(HostAddress("0.0.0.0"), 0))

+{

+ connected_ = false;

+}

+

+SOCKS5ProxiedConnection::~SOCKS5ProxiedConnection() {

+ if(connection_) {

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

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

+ }

+

+ if(connected_) {

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

+ }

+}

+

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

+ server_ = server;

+ connection_ = connectionFactory_->createConnection();

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

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

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

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

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

+ connection_->connect(proxy_);

+}

+

+void SOCKS5ProxiedConnection::listen() {

+ assert(false);

+ connection_->listen();

+}

+

+void SOCKS5ProxiedConnection::disconnect() {

+ connected_ = false;

+ if(connection_)

+ connection_->disconnect();

+}

+

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

+ onDisconnected(error);

+}

+

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

+ if(connection_)

+ connection_->write(data);

+}

+

+void SOCKS5ProxiedConnection::handleConnectionConnectFinished(bool error) {

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

+ if(!error) {

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

+

+ proxyState_ = ProxyAuthenticating;

+ ByteArray socksConnect;

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

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

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

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

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

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

+ connection_->write(socksConnect);

+ }

+ else {

+ onConnectFinished(true);

+ }

+}

+

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

+ ByteArray socksConnect;

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

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

+ if (!connected_) {

+ if (proxyState_ == ProxyAuthenticating) {

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

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

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

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

+ case 0x00:

+ try {

+ proxyState_ = ProxyConnecting;

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

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

+ socksConnect += 0x00; // reserved.

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

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

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

+ unsigned char uc;

+ if(rawAddress.is_v4()) {

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

+ }

+ else

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

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

+

+ }

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

+ socksConnect += static_cast<unsigned char> (server_.getPort()); // 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();

+}

+

+//namespace

+}

+/*

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

+#include <boost/enable_shared_from_this.hpp>

+

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

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

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

+

+namespace boost {

+ class thread;

+ namespace system {

+ class error_code;

+ }

+}

+

+namespace Swift {

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

+ public:

+ typedef boost::shared_ptr<SOCKS5ProxiedConnection> ref;

+

+ ~SOCKS5ProxiedConnection();

+

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

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

+ }

+

+ virtual void listen();

+ virtual void connect(const HostAddressPort& address);

+ virtual void disconnect();

+ virtual void write(const ByteArray& data);

+

+ virtual HostAddressPort getLocalAddress() const;

+ private:

+ enum {

+ ProxyAuthenticating = 0,

+ ProxyConnecting,

+ } proxyState_;

+

+ SOCKS5ProxiedConnection(ConnectionFactory* connectionFactory, HostAddressPort proxy);

+

+ void handleConnectionConnectFinished(bool error);

+ void handleDataRead(const ByteArray& data);

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

+

+ private:

+ bool connected_;

+ ConnectionFactory* connectionFactory_;

+ HostAddressPort proxy_;

+ HostAddressPort server_;

+ boost::shared_ptr<Connection> connection_;

+ };

+}

+/*

+ * Copyright (c) 2010-2011 Thilo Cestonaro

+ * Licensed under the simplified BSD license.

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

+ */

+

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

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

+

+namespace Swift {

+

+SOCKS5ProxiedConnectionFactory::SOCKS5ProxiedConnectionFactory(ConnectionFactory* connectionFactory, 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 <boost/asio.hpp>

+

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

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

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

+

+namespace Swift {

+ class SOCKS5ProxiedConnection;

+

+ class SOCKS5ProxiedConnectionFactory : public ConnectionFactory {

+ public:

+ SOCKS5ProxiedConnectionFactory(ConnectionFactory* connectionFactory, HostAddressPort proxy);

+

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

+

+ private:

+ ConnectionFactory* connectionFactory_;

+ HostAddressPort proxy_;

+ };

+}

+/*

+ * Copyright (c) 2010-2011 Thilo Cestonaro

+ * Licensed under the simplified BSD license.

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

+ */

+

+#include <stdio.h>

+#include <stdlib.h>

+#include <iostream>

+

+#include "Swiften/Base/foreach.h"

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

+

+namespace Swift {

+

+UnixProxyProvider::UnixProxyProvider() :

+#if defined(HAVE_GCONF)

+ gconfProxyProvider(),

+#endif

+ environmentProxyProvider()

+{

+}

+

+HostAddressPort UnixProxyProvider::getSOCKS5Proxy() const {

+ HostAddressPort proxy;

+#if defined(HAVE_GCONF)

+ proxy = gconfProxyProvider.getSOCKS5Proxy();

+ if(proxy.isValid()) {

+ return proxy;

+ }

+#endif

+ proxy = environmentProxyProvider.getSOCKS5Proxy();

+ if(proxy.isValid()) {

+ return proxy;

+ }

+ return HostAddressPort(HostAddress(), 0);

+}

+

+HostAddressPort UnixProxyProvider::getHTTPConnectProxy() const {

+ HostAddressPort proxy;

+#if defined(HAVE_GCONF)

+ proxy = gconfProxyProvider.getHTTPConnectProxy();

+ if(proxy.isValid()) {

+ return proxy;

+ }

+#endif

+ proxy = environmentProxyProvider.getHTTPConnectProxy();

+ if(proxy.isValid()) {

+ return proxy;

+ }

+ return HostAddressPort(HostAddress(), 0);

+}

+

+

+}

+/*

+ * Copyright (c) 2010-2011 Thilo Cestonaro

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+#if defined(HAVE_GCONF)

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

+#endif

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

+

+namespace Swift {

+ class UnixProxyProvider : public ProxyProvider {

+ public:

+ UnixProxyProvider();

+ virtual HostAddressPort getHTTPConnectProxy() const;

+ virtual HostAddressPort getSOCKS5Proxy() const;

+ private:

+#if defined(HAVE_GCONF)

+ GConfProxyProvider gconfProxyProvider;

+#endif

+ EnvironmentProxyProvider environmentProxyProvider;

+ };

+}

+/*

+ * Copyright (c) 2010-2011 Thilo Cestonaro

+ * Licensed under the simplified BSD license.

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

+ */

+

+#include <stdio.h>

+#include <stdlib.h>

+#include <math.h>

+#include <iostream>

+#include <boost/lexical_cast.hpp>

+

+#include "Swiften/Base/log.h"

+#include "Swiften/Base/foreach.h"

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

+#include "Swiften/Base/ByteArray.h"

+

+#include <windows.h>

+

+namespace Swift {

+

+WindowsProxyProvider::WindowsProxyProvider()

+: ProxyProvider()

+{

+ HKEY hKey = (HKEY)INVALID_HANDLE_VALUE;

+ long result;

+

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

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

+ DWORD dataType = REG_SZ;

+ DWORD dataSize = 0;

+ ByteArray dataBuffer;

+

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

+ if(result != ERROR_SUCCESS) {

+ return;

+ }

+ dataBuffer.resize(dataSize);

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

+ if(result == ERROR_SUCCESS) {

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

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

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

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

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

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

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

+ socksProxy = getAsHostAddressPort(protocolAndProxy.second);

+ }

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

+ httpProxy = getAsHostAddressPort(protocolAndProxy.second);

+ }

+ }

+ }

+ }

+ }

+}

+

+HostAddressPort WindowsProxyProvider::getHTTPConnectProxy() const {

+ return httpProxy;

+}

+

+HostAddressPort WindowsProxyProvider::getSOCKS5Proxy() const {

+ return socksProxy;

+}

+

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

+ HostAddressPort ret(HostAddress(), 0);

+

+ try {

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

+ int port = 0;

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

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

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

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

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

+ }

+ catch(...) {

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

+ }

+

+ return ret;

+}

+

+

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

+ bool ret = false;

+ long result;

+ DWORD dataType = REG_DWORD;

+ DWORD dataSize = 0;

+ DWORD data = 0;

+ ByteArray dataBuffer;

+

+ if(hKey == INVALID_HANDLE_VALUE)

+ return ret;

+

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

+ if(result != ERROR_SUCCESS)

+ return ret;

+

+ dataBuffer.resize(dataSize);

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

+ if(result != ERROR_SUCCESS)

+ return ret;

+

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

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

+ }

+ return (data == 1);

+}

+

+}

+/*

+ * Copyright (c) 2010-2011 Thilo Cestonaro

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

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

+

+namespace Swift {

+ class WindowsProxyProvider : public ProxyProvider {

+ public:

+ WindowsProxyProvider();

+ virtual HostAddressPort getHTTPConnectProxy() const;

+ virtual HostAddressPort getSOCKS5Proxy() const;

+ private:

+ HostAddressPort getAsHostAddressPort(std::string proxy);

+ bool proxyEnabled(HKEY hKey) const;

+ HostAddressPort socksProxy;

+ HostAddressPort httpProxy;

+ };

+}

+ProxyProviderTest

+/*

+ * Copyright (c) 2010 Thilo Cestonaro

+ * Licensed under the BSD License.

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

+ */

+

+#include <iostream>

+

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

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

+

+using namespace Swift;

+

+int main(void)

+{

+ int ret = 0;

+ HostAddressPort hap;

+

+ std::cout << "constructing PlatfromProxyProvider instance ..." << std::endl;

+ PlatformProxyProvider ppp;

+

+ hap = ppp.getSOCKS5Proxy();

+ std::cout << "SOCKS5 Proxy configured: " << hap.isValid() << std::endl;

+ if(hap.isValid()) {

+ std::cout << "SOCKS5 Proxy: " << hap.getAddress().toString() << ":" << hap.getPort() << std::endl;

+ }

+

+ hap = ppp.getHTTPConnectProxy();

+ std::cout << "HTTPConnect Proxy configured: " << hap.isValid() << std::endl;

+ if(hap.isValid()) {

+ std::cout << "HTTPConnect Proxy: " << hap.getAddress().toString() << ":" << hap.getPort() << std::endl;

+ }

+

+ return ret;

+}

+import os

+

+Import("env")

+

+myenv = env.Clone()

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

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

+

+myenv.Program("ProxyProviderTest", [

+ "ProxyProviderTest.cpp",

+ ])

+ "ProxyProviderTest",

+ if myenv["PLATFORM"] != "darwin" and myenv["PLATFORM"] != "win32" and myenv.get("HAVE_GCONF", 0) :

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

+

+ if file.find("ProxyProvider") != -1 :

+ continue