/*

* Licensed under the GNU General Public License v3.

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

*/

#include <Swiften/Client/CoreClient.h>

#include <boost/bind.hpp>

#include <boost/smart_ptr/make_shared.hpp>

#include <Swiften/Base/IDGenerator.h>

#include <Swiften/Base/Log.h>

#include <Swiften/Base/foreach.h>

#include <Swiften/Base/Algorithm.h>

#include <Swiften/Client/ClientSession.h>

#include <Swiften/TLS/CertificateVerificationError.h>

#include <Swiften/TLS/TLSError.h>

}

std::vector<ConnectionFactory*> connectionFactories(proxyConnectionFactories);

if (useDirectConnection) {

connectionFactories.push_back(networkFactories->getConnectionFactory());

}

// Create connector

std::string host = o.manualHostname.empty() ? jid_.getDomain() : o.manualHostname;

int port = o.manualPort;

assert(!connector_);

if (options.boshURL.isEmpty()) {

connector_->onConnectFinished.connect(boost::bind(&CoreClient::handleConnectorFinished, this, _1, _2));

connector_->setTimeoutMilliseconds(2*60*1000);

connector_->start();

}

else {

/* Autodiscovery of which proxy works is largely ok with a TCP session, because this is a one-off. With BOSH

* it would be quite painful given that potentially every stanza could be sent on a new connection.

*/

//sessionStream_ = boost::make_shared<BOSHSessionStream>(boost::make_shared<BOSHConnectionFactory>(options.boshURL, networkFactories->getConnectionFactory(), networkFactories->getXMLParserFactory(), networkFactories->getTLSContextFactory()), getPayloadParserFactories(), getPayloadSerializers(), networkFactories->getTLSContextFactory(), networkFactories->getTimerFactory(), networkFactories->getXMLParserFactory(), networkFactories->getEventLoop(), host, options.boshHTTPConnectProxyURL, options.boshHTTPConnectProxyAuthID, options.boshHTTPConnectProxyAuthPassword);

// handleSessionTerminated(boost::make_shared<BOSHError>(BOSHError::UndefinedCondition));

//}

else {

/* We might have just freed up a connection slot to send with */

tryToSendQueuedData();

}

}

boost::shared_ptr<BOSHConnection> BOSHConnectionPool::createConnection() {

BOSHConnection::ref connection = BOSHConnection::create(boshURL, connector, xmlParserFactory);

connection->onXMPPDataRead.connect(boost::bind(&BOSHConnectionPool::handleDataRead, this, _1));

connection->onSessionStarted.connect(boost::bind(&BOSHConnectionPool::handleSessionStarted, this, _1, _2));

connection->onBOSHDataRead.connect(boost::bind(&BOSHConnectionPool::handleBOSHDataRead, this, _1));

connection->onBOSHDataWritten.connect(boost::bind(&BOSHConnectionPool::handleBOSHDataWritten, this, _1));

connection->onDisconnected.connect(boost::bind(&BOSHConnectionPool::handleConnectionDisconnected, this, _1, connection));

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

connection->onSessionTerminated.connect(boost::bind(&BOSHConnectionPool::handleSessionTerminated, this, _1));

connection->onHTTPError.connect(boost::bind(&BOSHConnectionPool::handleHTTPError, this, _1));

#include <Swiften/Base/foreach.h>

#include <Swiften/Network/Connector.h>

#include <Swiften/Network/ConnectionFactory.h>

using namespace Swift;

ChainedConnector::ChainedConnector(

const std::string& hostname,

int port,

DomainNameResolver* resolver,

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

TimerFactory* timerFactory) :

hostname(hostname),

port(port),

resolver(resolver),

connectionFactories(connectionFactories),

timerFactory(timerFactory),

timeoutMilliseconds(0) {

}

void ChainedConnector::setTimeoutMilliseconds(int milliseconds) {

timeoutMilliseconds = milliseconds;

}

assert(!currentConnector);

if (connectionFactoryQueue.empty()) {

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

finish(boost::shared_ptr<Connection>(), lastError);

}

else {

ConnectionFactory* connectionFactory = connectionFactoryQueue.front();

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

connectionFactoryQueue.pop_front();

currentConnector->setTimeoutMilliseconds(timeoutMilliseconds);

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

currentConnector->start();

}

}

void ChainedConnector::handleConnectorFinished(boost::shared_ptr<Connection> connection, boost::shared_ptr<Error> error) {

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

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

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

*/

#pragma once

#include <string>

#include <vector>

#include <deque>

#include <boost/shared_ptr.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Base/boost_bsignals.h>

#include <Swiften/Base/Error.h>

namespace Swift {

class Connection;

class Connector;

class ConnectionFactory;

class TimerFactory;

class DomainNameResolver;

class SWIFTEN_API ChainedConnector {

public:

void setTimeoutMilliseconds(int milliseconds);

void start();

void stop();

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

private:

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

void tryNextConnectionFactory();

void handleConnectorFinished(boost::shared_ptr<Connection>, boost::shared_ptr<Error>);

private:

std::string hostname;

int port;

DomainNameResolver* resolver;

std::vector<ConnectionFactory*> connectionFactories;

TimerFactory* timerFactory;

int timeoutMilliseconds;

std::deque<ConnectionFactory*> connectionFactoryQueue;

boost::shared_ptr<Connector> currentConnector;

boost::shared_ptr<Error> lastError;

};

}

#include <Swiften/Network/ConnectionFactory.h>

#include <Swiften/Network/DomainNameResolver.h>

#include <Swiften/Network/DomainNameAddressQuery.h>

#include <Swiften/Network/TimerFactory.h>

#include <Swiften/Base/Log.h>

namespace Swift {

}

void Connector::setTimeoutMilliseconds(int milliseconds) {

timeoutMilliseconds = milliseconds;

}

void Connector::start() {

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

//std::cout << "Connector::start()" << std::endl;

assert(!currentConnection);

assert(!serviceQuery);

assert(!timer);

queriedAllServices = false;

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

}

serviceQuery->run();

}

else {

queryAddress(hostname);

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <deque>

#include <Swiften/Base/boost_bsignals.h>

#include <boost/shared_ptr.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Network/DomainNameServiceQuery.h>

#include <Swiften/Network/Connection.h>

#include <Swiften/Network/Timer.h>

#include <Swiften/Network/HostAddressPort.h>

#include <string>

#include <Swiften/Network/DomainNameResolveError.h>

namespace Swift {

class DomainNameAddressQuery;

class DomainNameResolver;

class ConnectionFactory;

class TimerFactory;

class SWIFTEN_API Connector : public boost::bsignals::trackable, public boost::enable_shared_from_this<Connector> {

public:

typedef boost::shared_ptr<Connector> ref;

}

void setTimeoutMilliseconds(int milliseconds);

void start();

void stop();

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

private:

void handleServiceQueryResult(const std::vector<DomainNameServiceQuery::Result>& result);

void handleAddressQueryResult(const std::vector<HostAddress>& address, boost::optional<DomainNameResolveError> error);

void queryAddress(const std::string& hostname);

void tryNextServiceOrFallback();

void tryNextAddress();

void tryConnect(const HostAddressPort& target);

void handleConnectionConnectFinished(bool error);

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

void handleTimeout();

private:

std::string hostname;

int port;

DomainNameResolver* resolver;

ConnectionFactory* connectionFactory;

TimerFactory* timerFactory;

int timeoutMilliseconds;

boost::shared_ptr<Timer> timer;

boost::shared_ptr<DomainNameServiceQuery> serviceQuery;

std::deque<DomainNameServiceQuery::Result> serviceQueryResults;

boost::shared_ptr<DomainNameAddressQuery> addressQuery;

std::deque<HostAddress> addressQueryResults;

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

connector_->stop();

connector_.reset();

}

}

void ProxiedConnection::connect(const HostAddressPort& server) {

server_ = server;

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

connector_->start();

}

void ProxiedConnection::listen() {

assert(false);

connection_->listen();

}

std::string response = safeByteArrayToString(http.first);

size_t bodyPosition = response.find("\r\n\r\n");

CPPUNIT_ASSERT_EQUAL(fullBody, response.substr(bodyPosition+4));

}

private:

BOSHConnection::ref createTestling() {

resolver->addAddress("wonderland.lit", HostAddress("127.0.0.1"));

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

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

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

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

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

c->setRID(42);

return c;

}

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

connector->onConnectFinished.connect(boost::bind(&ChainedConnectorTest::handleConnectorFinished, this, _1, _2));

return connector;

}

void handleConnectorFinished(boost::shared_ptr<Connection> connection, boost::shared_ptr<Error> resultError) {

error = resultError;

boost::shared_ptr<MockConnection> c(boost::dynamic_pointer_cast<MockConnection>(connection));

if (connection) {

assert(c);

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include <boost/optional.hpp>

#include <boost/bind.hpp>

eventLoop->processEvents();

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

CPPUNIT_ASSERT(connections[0]);

CPPUNIT_ASSERT(host1 == *(connections[0]->hostAddressPort));

CPPUNIT_ASSERT(!boost::dynamic_pointer_cast<DomainNameResolveError>(error));

}

void testConnect_NoServiceLookups() {

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

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

resolver->addAddress("foo.com", host3.getAddress());

testling->start();

eventLoop->processEvents();

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

CPPUNIT_ASSERT(connections[0]);

CPPUNIT_ASSERT(host3.getAddress() == (*(connections[0]->hostAddressPort)).getAddress());

CPPUNIT_ASSERT(4321 == (*(connections[0]->hostAddressPort)).getPort());

CPPUNIT_ASSERT(!boost::dynamic_pointer_cast<DomainNameResolveError>(error));

}

void testConnect_NoServiceLookups_DefaultPort() {

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

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

resolver->addAddress("foo.com", host3.getAddress());

testling->start();

eventLoop->processEvents();

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

CPPUNIT_ASSERT(connections[0]);

timerFactory->setTime(10);

eventLoop->processEvents();

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

CPPUNIT_ASSERT(!connections[0]);

}

private:

connector->onConnectFinished.connect(boost::bind(&ConnectorTest::handleConnectorFinished, this, _1, _2));

return connector;

}

void handleConnectorFinished(boost::shared_ptr<Connection> connection, boost::shared_ptr<Error> resultError) {

boost::shared_ptr<MockConnection> c(boost::dynamic_pointer_cast<MockConnection>(connection));

if (connection) {

assert(c);

}