- client->connect(host);

- ClientOptions() : useStreamCompression(true), useTLS(UseTLSWhenAvailable), allowPLAINWithoutTLS(false), useStreamResumption(false), forgetPassword(false), useAcks(true), boshHTTPConnectProxyAuthID(""), boshHTTPConnectProxyAuthPassword("") {

- options = o;

- connect(jid_.getDomain());

-}

-void CoreClient::connect(const std::string& host) {

-

- SWIFT_LOG(debug) << "Connecting to host " << host << std::endl;

- assert(!connector_);

- if (networkFactories->getProxyProvider()->getSOCKS5Proxy().isValid()) {

- proxyConnectionFactories.push_back(new SOCKS5ProxiedConnectionFactory(networkFactories->getConnectionFactory(), networkFactories->getProxyProvider()->getSOCKS5Proxy()));

- }

- if(networkFactories->getProxyProvider()->getHTTPConnectProxy().isValid()) {

- proxyConnectionFactories.push_back(new HTTPConnectProxiedConnectionFactory(networkFactories->getDomainNameResolver(), networkFactories->getConnectionFactory(), networkFactories->getTimerFactory(), networkFactories->getEventLoop(), networkFactories->getProxyProvider()->getHTTPConnectProxy().getAddress().toString(), networkFactories->getProxyProvider()->getHTTPConnectProxy().getPort()));

- if (options.boshURL.empty()) {

- connector_ = boost::make_shared<ChainedConnector>(host, networkFactories->getDomainNameResolver(), connectionFactories, networkFactories->getTimerFactory());

- void connect(const std::string& host);

-

- client->connect(connectHost);

- client->connect(connectHost);

- connectionFactory = new HTTPConnectProxiedConnectionFactory(realResolver, connectionFactory, timerFactory, eventLoop, boshHTTPConnectProxyURL.getHost(), boshHTTPConnectProxyURL.getPort(), boshHTTPConnectProxyAuthID, boshHTTPConnectProxyAuthPassword);

- Connector::ref connector = Connector::create(boshURL.getHost(), resolver, connectionFactory, timerFactory, boshURL.getPort());

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

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

-Connector::Connector(const std::string& hostname, DomainNameResolver* resolver, ConnectionFactory* connectionFactory, TimerFactory* timerFactory, int defaultPort) : hostname(hostname), resolver(resolver), connectionFactory(connectionFactory), timerFactory(timerFactory), defaultPort(defaultPort), timeoutMilliseconds(0), queriedAllServices(true), foundSomeDNS(false) {

- serviceQuery = resolver->createServiceQuery("_xmpp-client._tcp." + hostname);

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

- if (timeoutMilliseconds > 0) {

- timer = timerFactory->createTimer(timeoutMilliseconds);

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

- timer->start();

- }

- serviceQuery->run();

- int port = defaultPort;

- port = serviceQueryResults.front().port;

- tryConnect(HostAddressPort(address, port));

- static Connector::ref create(const std::string& hostname, DomainNameResolver* resolver, ConnectionFactory* connectionFactory, TimerFactory* timerFactory, int defaultPort = 5222) {

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

- Connector(const std::string& hostname, DomainNameResolver*, ConnectionFactory*, TimerFactory*, int defaultPort);

- int defaultPort;

-#include <boost/thread.hpp>

-#include <Swiften/Network/CachingNameOnlyDomainNameResolver.h>

-HTTPConnectProxiedConnection::HTTPConnectProxiedConnection(DomainNameResolver* resolver, ConnectionFactory* connectionFactory, TimerFactory* timerFactory, EventLoop* eventLoop, const std::string& proxyHost, int proxyPort, const SafeString& authID, const SafeString& authPassword) : connectionFactory_(connectionFactory), timerFactory_(timerFactory), proxyHost_(proxyHost), proxyPort_(proxyPort), server_(HostAddressPort(HostAddress("0.0.0.0"), 0)), authID_(authID), authPassword_(authPassword) {

- resolver_ = new CachingNameOnlyDomainNameResolver(resolver, eventLoop);

- connected_ = false;

-HTTPConnectProxiedConnection::~HTTPConnectProxiedConnection() {

- cancelConnector();

- delete resolver_;

- 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::cancelConnector() {

- if (connector_) {

- connector_->onConnectFinished.disconnect(boost::bind(&HTTPConnectProxiedConnection::handleConnectFinished, shared_from_this(), _1));

- connector_->stop();

- connector_.reset();

- }

-}

-

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

- server_ = server;

- connector_ = Connector::create(proxyHost_, resolver_, connectionFactory_, timerFactory_, proxyPort_);

- connector_->onConnectFinished.connect(boost::bind(&HTTPConnectProxiedConnection::handleConnectFinished, shared_from_this(), _1));

- connector_->start();

-}

-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::handleConnectFinished(Connection::ref connection) {

- cancelConnector();

- if (connection) {

- connection_ = connection;

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

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

-

- std::stringstream connect;

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

- SafeByteArray data = createSafeByteArray(connect.str());

- if (!authID_.empty() && !authPassword_.empty()) {

- append(data, createSafeByteArray("Proxy-Authorization: Basic "));

- SafeByteArray credentials = authID_;

- append(credentials, createSafeByteArray(":"));

- append(credentials, authPassword_);

- append(data, Base64::encode(credentials));

- append(data, createSafeByteArray("\r\n"));

- }

- SWIFT_LOG(debug) << "HTTP Proxy send headers: " << byteArrayToString(ByteArray(data.begin(), data.end())) << std::endl;

- connection_->write(data);

- }

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

-#include <boost/enable_shared_from_this.hpp>

-

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

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

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

-#include <Swiften/Base/SafeString.h>

-

-namespace boost {

- class thread;

- namespace system {

- class error_code;

- }

-}

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

- ~HTTPConnectProxiedConnection();

-

- static ref create(DomainNameResolver* resolver, ConnectionFactory* connectionFactory, TimerFactory* timerFactory, EventLoop* eventLoop, const std::string& proxyHost, int proxyPort, const SafeString& authID, const SafeString& authPassword) {

- return ref(new HTTPConnectProxiedConnection(resolver, connectionFactory, timerFactory, eventLoop, proxyHost, proxyPort, authID, authPassword));

- virtual void listen();

- virtual void connect(const HostAddressPort& address);

- virtual void disconnect();

- virtual void write(const SafeByteArray& data);

-

- virtual HostAddressPort getLocalAddress() const;

- HTTPConnectProxiedConnection(DomainNameResolver* resolver, ConnectionFactory* connectionFactory, TimerFactory* timerFactory, EventLoop* eventLoop, const std::string& proxyHost, int proxyPort, const SafeString& authID, const SafeString& authPassword);

- void handleConnectFinished(Connection::ref connection);

- void handleDataRead(boost::shared_ptr<SafeByteArray> data);

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

- void cancelConnector();

- bool connected_;

- DomainNameResolver* resolver_;

- ConnectionFactory* connectionFactory_;

- TimerFactory* timerFactory_;

- std::string proxyHost_;

- int proxyPort_;

- HostAddressPort server_;

- Connector::ref connector_;

- boost::shared_ptr<Connection> connection_;

-HTTPConnectProxiedConnectionFactory::HTTPConnectProxiedConnectionFactory(DomainNameResolver* resolver, ConnectionFactory* connectionFactory, TimerFactory* timerFactory, EventLoop* eventLoop, const std::string& proxyHost, int proxyPort) : resolver_(resolver), connectionFactory_(connectionFactory), timerFactory_(timerFactory), eventLoop_(eventLoop), proxyHost_(proxyHost), proxyPort_(proxyPort), authID_(""), authPassword_("") {

-HTTPConnectProxiedConnectionFactory::HTTPConnectProxiedConnectionFactory(DomainNameResolver* resolver, ConnectionFactory* connectionFactory, TimerFactory* timerFactory, EventLoop* eventLoop, const std::string& proxyHost, int proxyPort, const SafeString& authID, const SafeString& authPassword) : resolver_(resolver), connectionFactory_(connectionFactory), timerFactory_(timerFactory), eventLoop_(eventLoop), proxyHost_(proxyHost), proxyPort_(proxyPort), authID_(authID), authPassword_(authPassword) {

- return HTTPConnectProxiedConnection::create(resolver_, connectionFactory_, timerFactory_, eventLoop_, proxyHost_, proxyPort_, authID_, authPassword_);

- HTTPConnectProxiedConnectionFactory(DomainNameResolver* resolver, ConnectionFactory* connectionFactory, TimerFactory* timerFactory, EventLoop* eventLoop, const std::string& proxyHost, int proxyPort);

- HTTPConnectProxiedConnectionFactory(DomainNameResolver* resolver, ConnectionFactory* connectionFactory, TimerFactory* timerFactory, EventLoop* eventLoop, const std::string& proxyHost, int proxyPort, const SafeString& authID, const SafeString& authPassword);

- EventLoop* eventLoop_;

-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) {

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

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

- else {

- onDataRead(data);

- return;

- disconnect();

- onConnectFinished(true);

-}

-

-HostAddressPort SOCKS5ProxiedConnection::getLocalAddress() const {

- return connection_->getLocalAddress();

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

- }

-}

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

- ~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;

-

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

- void handleConnectionConnectFinished(bool error);

- void handleDataRead(boost::shared_ptr<SafeByteArray> data);

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

- bool connected_;

- ConnectionFactory* connectionFactory_;

- HostAddressPort proxy_;

- HostAddressPort server_;

- boost::shared_ptr<Connection> connection_;

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

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

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

- HostAddressPort proxy_;

- Connector::ref connector = Connector::create("wonderland.lit", resolver, connectionFactory, timerFactory, 5280);

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

- Connector::ref createConnector() {

- Connector::ref connector = Connector::create("foo.com", resolver, connectionFactory, timerFactory);

- boost::shared_ptr<HTTPConnectProxiedConnection> c = HTTPConnectProxiedConnection::create(resolver, connectionFactory, timerFactory, eventLoop, proxyHost, proxyPort, "", "");