client_->disconnect();

}

systemTrayController_->setConnecting();

if (rosterController_) {

rosterController_->getWindow()->setConnecting();

}

ClientOptions clientOptions;

clientOptions.forgetPassword = eagleMode_;

clientOptions.useTLS = eagleMode_ ? ClientOptions::RequireTLS : ClientOptions::UseTLSWhenAvailable;

client_->connect(clientOptions);

}

void MainController::handleDisconnected(const boost::optional<ClientError>& error) {

if (eagleMode_) {

purgeCachedCredentials();

}

if (quitRequested_) {

resetClient();

/**

* Use XEP-0198 acks in the stream when available.

* Default: true

*/

bool useAcks;

/**

* If non-empty, use BOSH instead of direct TCP, with the given URL.

* Default: empty (no BOSH)

*/

URL boshURL;

/**

* If non-empty, BOSH connections will try to connect over this HTTP CONNECT

* proxy instead of directly.

* Default: empty (no proxy)

*/

URL boshHTTPConnectProxyURL;

/**

* If this and matching Password are non-empty, BOSH connections over

* HTTP CONNECT proxies will use these credentials for proxy access.

* Default: empty (no authentication needed by the proxy)

*/

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

disconnectRequested_ = false;

assert(!connector_);

assert(proxyConnectionFactories.empty());

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

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

}

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

}

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

if (options.boshURL.empty()) {

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

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

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

connector_->setTimeoutMilliseconds(60*1000);

connector_->start();

}

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

sessionStream_ = boost::shared_ptr<BOSHSessionStream>(new BOSHSessionStream(

options.boshURL,

getPayloadParserFactories(),

getPayloadSerializers(),

networkFactories->getConnectionFactory(),

networkFactories->getXMLParserFactory(),

options.boshHTTPConnectProxyAuthPassword));

sessionStream_->onDataRead.connect(boost::bind(&CoreClient::handleDataRead, this, _1));

sessionStream_->onDataWritten.connect(boost::bind(&CoreClient::handleDataWritten, this, _1));

bindSessionToStream();

}

}

void CoreClient::bindSessionToStream() {

*/

#include <Swiften/Network/BOSHConnection.h>

#include <boost/bind.hpp>

#include <boost/thread.hpp>

#include <boost/lexical_cast.hpp>

#include <string>

#include <Swiften/Base/Log.h>

#include <Swiften/Base/String.h>

#include <Swiften/Base/Concat.h>

#include <Swiften/Base/ByteArray.h>

#include <Swiften/Network/HostAddressPort.h>

#include <Swiften/Parser/BOSHBodyExtractor.h>

namespace Swift {

parserFactory_(parserFactory),

sid_(),

waitingForStartResponse_(false),

pending_(false),

connectionReady_(false)

{

}

BOSHConnection::~BOSHConnection() {

if (connection_) {

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

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

}

disconnect();

}

void BOSHConnection::connect() {

}

void BOSHConnection::disconnect() {

if(connection_) {

connection_->disconnect();

sid_ = "";

}

}

void BOSHConnection::restartStream() {

write(createSafeByteArray(""), true, false);

}

void BOSHConnection::terminateStream() {

write(createSafeByteArray(""), false, true);

}

void BOSHConnection::write(const SafeByteArray& data) {

write(data, false, false);

}

size_t size;

std::stringstream content;

SafeByteArray contentTail = createSafeByteArray("</body>");

std::stringstream header;

content << "<body rid='" << rid << "' sid='" << sid << "'";

if (streamRestart) {

content << " xmpp:restart='true' xmlns:xmpp='urn:xmpp:xbosh'";

}

SafeByteArray safeHeader = createHTTPRequest(data, streamRestart, terminate, rid_, sid_, boshURL_).first;

onBOSHDataWritten(safeHeader);

connection_->write(safeHeader);

pending_ = true;

SWIFT_LOG(debug) << "write data: " << safeByteArrayToString(safeHeader) << std::endl;

}

}

assert(connectionReady_);

// Session Creation Request

std::stringstream content;

std::stringstream header;

content << "<body content='text/xml; charset=utf-8'"

<< " hold='1'"

<< " to='" << to << "'"

<< " rid='" << rid << "'"

void BOSHConnection::setRID(unsigned long long rid) {

rid_ = rid;

}

void BOSHConnection::setSID(const std::string& sid) {

sid_ = sid;

}

void BOSHConnection::handleDisconnected(const boost::optional<Connection::Error>& error) {

onDisconnected(error);

sid_ = "";

connectionReady_ = false;

}

bool BOSHConnection::isReadyToSend() {

/* Without pipelining you need to not send more without first receiving the response */

/* With pipelining you can. Assuming we can't, here */

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

*/

#pragma once

#include <boost/enable_shared_from_this.hpp>

#include <Swiften/Network/Connection.h>

#include <Swiften/Network/HostAddressPort.h>

#include <Swiften/Base/String.h>

#include <Swiften/Base/URL.h>

#include <Swiften/Base/Error.h>

#include <Swiften/Session/SessionStream.h>

namespace boost {

class thread;

namespace system {

class error_code;

}

}

class BOSHConnectionTest;

namespace Swift {

class XMLParserFactory;

class TLSContextFactory;

class BOSHError : public SessionStream::Error {

public:

enum Type {BadRequest, HostGone, HostUnknown, ImproperAddressing,

InternalServerError, ItemNotFound, OtherRequest, PolicyViolation,

RemoteConnectionFailed, RemoteStreamError, SeeOtherURI, SystemShutdown, UndefinedCondition,

NoError};

private:

Type type;

};

class BOSHConnection : public boost::enable_shared_from_this<BOSHConnection> {

public:

typedef boost::shared_ptr<BOSHConnection> ref;

}

virtual ~BOSHConnection();

virtual void connect();

virtual void disconnect();

virtual void write(const SafeByteArray& data);

const std::string& getSID();

void setRID(unsigned long long rid);

void setSID(const std::string& sid);

void terminateStream();

bool isReadyToSend();

void restartStream();

boost::signal<void (bool /* error */)> onConnectFinished;

boost::signal<void (bool /* error */)> onDisconnected;

boost::signal<void (BOSHError::ref)> onSessionTerminated;

boost::signal<void (const std::string& /*sid*/, size_t /*requests*/)> onSessionStarted;

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

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

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

boost::signal<void (const std::string&)> onHTTPError;

private:

friend class ::BOSHConnectionTest;

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

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

void write(const SafeByteArray& data, bool streamRestart, bool terminate); /* FIXME: refactor */

BOSHError::Type parseTerminationCondition(const std::string& text);

URL boshURL_;

XMLParserFactory* parserFactory_;

boost::shared_ptr<Connection> connection_;

std::string sid_;

bool waitingForStartResponse_;

unsigned long long rid_;

SafeByteArray buffer_;

bool pending_;

bool connectionReady_;

};

}

#include <climits>

#include <boost/bind.hpp>

#include <boost/lexical_cast.hpp>

#include <Swiften/Base/foreach.h>

#include <Swiften/Base/SafeString.h>

#include <Swiften/Network/TLSConnectionFactory.h>

#include <Swiften/Network/HTTPConnectProxiedConnectionFactory.h>

namespace Swift {

boshURL(boshURL),

xmlParserFactory(parserFactory),

tlsFactory(tlsFactory),

rid(initialRID),

pendingTerminate(false),

to(to),

requestLimit(2),

restartCount(0),

pendingRestart(false) {

if (boshHTTPConnectProxyURL.getScheme() == "https") {

}

}

createConnection();

}

BOSHConnectionPool::~BOSHConnectionPool() {

close();

}

void BOSHConnectionPool::write(const SafeByteArray& data) {

dataQueue.push_back(data);

tryToSendQueuedData();

}

void BOSHConnectionPool::handleDataRead(const SafeByteArray& data) {

onXMPPDataRead(data);

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

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

connection->connect();

#include <vector>

#include <Swiften/Base/SafeString.h>

#include <Swiften/Network/BOSHConnection.h>

namespace Swift {

class HTTPConnectProxiedConnectionFactory;

class TLSConnectionFactory;

class BOSHConnectionPool : public boost::bsignals::trackable {

public:

~BOSHConnectionPool();

void write(const SafeByteArray& data);

void writeFooter();

void close();

void restartStream();

boost::signal<void (BOSHError::ref)> onSessionTerminated;

boost::signal<void ()> onSessionStarted;

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

void destroyConnection(BOSHConnection::ref connection);

void tryToSendQueuedData();

BOSHConnection::ref getSuitableConnection();

private:

URL boshURL;

ConnectionFactory* connectionFactory;

XMLParserFactory* xmlParserFactory;

TLSContextFactory* tlsFactory;

std::vector<BOSHConnection::ref> connections;

std::string sid;

std::vector<SafeByteArray> dataQueue;

bool pendingTerminate;

std::string to;

size_t requestLimit;

int restartCount;

bool pendingRestart;

};

}

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

serviceQueryResults.pop_front();

}

tryNextServiceOrFallback();

}

else {

SWIFT_LOG(debug) << "Trying next address" << std::endl;

HostAddress address = addressQueryResults.front();

addressQueryResults.pop_front();

if (!serviceQueryResults.empty()) {

port = serviceQueryResults.front().port;

}

tryConnect(HostAddressPort(address, port));

}

}

void Connector::tryConnect(const HostAddressPort& target) {

class DomainNameAddressQuery;

class DomainNameResolver;

class ConnectionFactory;

class TimerFactory;

class 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>)> 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 finish(boost::shared_ptr<Connection>);

void handleTimeout();

private:

std::string hostname;

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;

bool queriedAllServices;

boost::shared_ptr<Connection> currentConnection;

};

/*

* Copyright (c) 2010-2011 Thilo Cestonaro

* Licensed under the simplified BSD license.

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

*/

/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.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/Algorithm.h>

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

#include <Swiften/StringCodecs/Base64.h>

using namespace Swift;

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;

}

void HTTPConnectProxiedConnection::listen() {

assert(false);

connection_->listen();

}

void HTTPConnectProxiedConnection::disconnect() {

connected_ = false;

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

onDisconnected(error);

}

void HTTPConnectProxiedConnection::write(const SafeByteArray& data) {

connection_->write(data);

}

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

/*

* Copyright (c) 2010-2011 Thilo Cestonaro

* Licensed under the simplified BSD license.

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

*/

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <boost/enable_shared_from_this.hpp>

#include <Swiften/Network/Connection.h>

#include <Swiften/Network/HostAddressPort.h>

#include <Swiften/Base/SafeString.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();

}

virtual void listen();

virtual void connect(const HostAddressPort& address);

virtual void disconnect();

virtual void write(const SafeByteArray& data);

virtual HostAddressPort getLocalAddress() const;

private:

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

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

private:

bool connected_;

ConnectionFactory* connectionFactory_;

HostAddressPort server_;

SafeByteArray authID_;

SafeByteArray authPassword_;

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 {

}

}

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

}

}

/*

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

#include <Swiften/Base/SafeString.h>

namespace Swift {

class HTTPConnectProxiedConnectionFactory : public ConnectionFactory {

public:

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

private:

ConnectionFactory* connectionFactory_;

SafeString authID_;

SafeString authPassword_;

};

}

"SOCKS5ProxiedConnection.cpp",

"SOCKS5ProxiedConnectionFactory.cpp",

"BoostConnection.cpp",

"BoostConnectionFactory.cpp",

"BoostConnectionServer.cpp",

"BoostConnectionServerFactory.cpp",

"BoostIOServiceThread.cpp",

"BOSHConnection.cpp",

"BOSHConnectionPool.cpp",

"ConnectionFactory.cpp",

"ConnectionServer.cpp",

"ConnectionServerFactory.cpp",

"DummyConnection.cpp",

"FakeConnection.cpp",

"ChainedConnector.cpp",

"Connector.cpp",

"Connection.cpp",

"TimerFactory.cpp",

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

*/

#include <Swiften/Network/StaticDomainNameResolver.h>

#include <boost/bind.hpp>

#include <boost/lexical_cast.hpp>

#include <Swiften/Network/DomainNameResolveError.h>

#include <string>

using namespace Swift;

namespace {

struct ServiceQuery : public DomainNameServiceQuery, public boost::enable_shared_from_this<ServiceQuery> {

virtual void run() {

if (!resolver->getIsResponsive()) {

return;

}

std::vector<DomainNameServiceQuery::Result> results;

for(StaticDomainNameResolver::ServicesCollection::const_iterator i = resolver->getServices().begin(); i != resolver->getServices().end(); ++i) {

if (i->first == service) {

results.push_back(i->second);

}

}

}

void emitOnResult(std::vector<DomainNameServiceQuery::Result> results) {

onResult(results);

}

EventLoop* eventLoop;

std::string service;

StaticDomainNameResolver* resolver;

};

struct AddressQuery : public DomainNameAddressQuery, public boost::enable_shared_from_this<AddressQuery> {

virtual void run() {

if (!resolver->getIsResponsive()) {

return;

}

StaticDomainNameResolver::AddressesMap::const_iterator i = resolver->getAddresses().find(host);

if (i != resolver->getAddresses().end()) {

eventLoop->postEvent(

boost::bind(&AddressQuery::emitOnResult, shared_from_this(), i->second, boost::optional<DomainNameResolveError>()));

}

else {

}

}

void emitOnResult(std::vector<HostAddress> results, boost::optional<DomainNameResolveError> error) {

onResult(results, error);

}

EventLoop* eventLoop;

std::string host;

StaticDomainNameResolver* resolver;

};

}

namespace Swift {

}

void StaticDomainNameResolver::addAddress(const std::string& domain, const HostAddress& address) {

addresses[domain].push_back(address);

}

void StaticDomainNameResolver::addService(const std::string& service, const DomainNameServiceQuery::Result& result) {

services.push_back(std::make_pair(service, result));

}

addService("_xmpp-client._tcp." + domain, ServiceQuery::Result(hostname, address.getPort(), 0, 0));

addAddress(hostname, address.getAddress());

}

void StaticDomainNameResolver::addXMPPClientService(const std::string& domain, const std::string& hostname, int port) {

addService("_xmpp-client._tcp." + domain, ServiceQuery::Result(hostname, port, 0, 0));

}

boost::shared_ptr<DomainNameServiceQuery> StaticDomainNameResolver::createServiceQuery(const std::string& name) {

}

boost::shared_ptr<DomainNameAddressQuery> StaticDomainNameResolver::createAddressQuery(const std::string& name) {

}

}

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

namespace Swift {

class StaticDomainNameResolver : public DomainNameResolver {

public:

typedef std::map<std::string, std::vector<HostAddress> > AddressesMap;

typedef std::vector< std::pair<std::string, DomainNameServiceQuery::Result> > ServicesCollection;

public:

StaticDomainNameResolver(EventLoop* eventLoop);

void addAddress(const std::string& domain, const HostAddress& address);

void addService(const std::string& service, const DomainNameServiceQuery::Result& result);

void addXMPPClientService(const std::string& domain, const HostAddressPort&);

void addXMPPClientService(const std::string& domain, const std::string& host, int port);

const AddressesMap& getAddresses() const {

return addresses;

}

return isResponsive;

}

void setIsResponsive(bool b) {

isResponsive = b;

}

virtual boost::shared_ptr<DomainNameServiceQuery> createServiceQuery(const std::string& name);

virtual boost::shared_ptr<DomainNameAddressQuery> createAddressQuery(const std::string& name);

private:

EventLoop* eventLoop;

bool isResponsive;

AddressesMap addresses;

ServicesCollection services;

};

}

#include <boost/shared_ptr.hpp>

#include <boost/lexical_cast.hpp>

#include <Swiften/Base/Algorithm.h>

#include <Swiften/Network/Connection.h>

#include <Swiften/Network/ConnectionFactory.h>

#include <Swiften/Network/BOSHConnection.h>

#include <Swiften/Network/BOSHConnectionPool.h>

#include <Swiften/Network/HostAddressPort.h>

#include <Swiften/EventLoop/DummyEventLoop.h>

#include <Swiften/Parser/PlatformXMLParserFactory.h>

using namespace Swift;

typedef boost::shared_ptr<BOSHConnectionPool> PoolRef;

class BOSHConnectionPoolTest : public CppUnit::TestFixture {

CPPUNIT_TEST_SUITE(BOSHConnectionPoolTest);

CPPUNIT_TEST(testConnectionCount_OneWrite);

CPPUNIT_TEST(testConnectionCount_TwoWrites);

CPPUNIT_TEST(testConnectionCount_ThreeWrites);

CPPUNIT_TEST(testConnectionCount_ThreeWrites_ManualConnect);

CPPUNIT_TEST(testConnectionCount_ThreeWritesTwoReads);

CPPUNIT_TEST(testSession);

CPPUNIT_TEST(testWrite_Empty);

eventLoop = new DummyEventLoop();

connectionFactory = new MockConnectionFactory(eventLoop);

boshURL = URL("http", to, 5280, path);

sessionTerminated = 0;

sessionStarted = 0;

initialRID = 2349876;

xmppDataRead.clear();

boshDataRead.clear();

boshDataWritten.clear();

}

void tearDown() {

eventLoop->processEvents();

delete connectionFactory;

delete eventLoop;

}

void testConnectionCount_OneWrite() {

PoolRef testling = createTestling();

CPPUNIT_ASSERT_EQUAL(st(1), connectionFactory->connections.size());

eventLoop->processEvents();

CPPUNIT_ASSERT_EQUAL(0, sessionStarted);

readResponse(initial, connectionFactory->connections[0]);

CPPUNIT_ASSERT_EQUAL(st(1), connectionFactory->connections.size());

CPPUNIT_ASSERT_EQUAL(1, sessionStarted);

}

void testConnectionCount_TwoWrites() {

PoolRef testling = createTestling();

CPPUNIT_ASSERT_EQUAL(st(1), connectionFactory->connections.size());

eventLoop->processEvents();

readResponse(initial, connectionFactory->connections[0]);

testling->write(createSafeByteArray("<blah/>"));

CPPUNIT_ASSERT_EQUAL(st(1), connectionFactory->connections.size());

testling->write(createSafeByteArray("<bleh/>"));

eventLoop->processEvents();

CPPUNIT_ASSERT_EQUAL(st(2), connectionFactory->connections.size());

}

void testConnectionCount_ThreeWrites() {

PoolRef testling = createTestling();

CPPUNIT_ASSERT_EQUAL(st(1), connectionFactory->connections.size());

eventLoop->processEvents();

readResponse(initial, connectionFactory->connections[0]);

testling->restartStream();

PoolRef testling = createTestling();

CPPUNIT_ASSERT_EQUAL(st(1), connectionFactory->connections.size());

CPPUNIT_ASSERT_EQUAL(st(0), boshDataWritten.size()); /* Connection not connected yet, can't send data */

connectionFactory->connections[0]->onConnectFinished(false);

eventLoop->processEvents();

CPPUNIT_ASSERT_EQUAL(st(1), boshDataWritten.size()); /* Connection finished, stream header sent */

readResponse(initial, connectionFactory->connections[0]);

CPPUNIT_ASSERT_EQUAL(st(1), connectionFactory->connections.size());

CPPUNIT_ASSERT_EQUAL(st(1), boshDataWritten.size()); /* Don't respond to initial data with a holding call */

testling->restartStream();

readResponse("<body/>", connectionFactory->connections[0]);

testling->restartStream();

testling->write(createSafeByteArray("<blah/>"));

CPPUNIT_ASSERT_EQUAL(st(2), connectionFactory->connections.size());

CPPUNIT_ASSERT_EQUAL(st(3), boshDataWritten.size()); /* New connection isn't up yet. */

connectionFactory->connections[1]->onConnectFinished(false);

eventLoop->processEvents();

CPPUNIT_ASSERT_EQUAL(st(4), boshDataWritten.size()); /* New connection ready. */

testling->write(createSafeByteArray("<bleh/>"));

testling->write(createSafeByteArray("<bluh/>"));

CPPUNIT_ASSERT_EQUAL(st(4), boshDataWritten.size()); /* New data can't be sent, no free connections. */

eventLoop->processEvents();

CPPUNIT_ASSERT(st(2) >= connectionFactory->connections.size());

}

void testConnectionCount_ThreeWritesTwoReads() {

boost::shared_ptr<MockConnection> c0;

boost::shared_ptr<MockConnection> c1;

rid++;

readResponse(initial, c0);

CPPUNIT_ASSERT_EQUAL(st(1), boshDataWritten.size());

CPPUNIT_ASSERT_EQUAL(st(1), connectionFactory->connections.size());

CPPUNIT_ASSERT(!c0->pending);

rid++;

testling->restartStream();

readResponse("<body/>", connectionFactory->connections[0]);

rid++;

testling->write(createSafeByteArray("<blah/>"));

eventLoop->processEvents();

CPPUNIT_ASSERT_EQUAL(st(2), connectionFactory->connections.size()); /* 0 was waiting for response, open and send on 1 */

CPPUNIT_ASSERT_EQUAL(st(4), boshDataWritten.size()); /* data */

c1 = connectionFactory->connections[1];

std::string fullBody = "<body rid='" + boost::lexical_cast<std::string>(rid) + "' sid='" + sid + "' xmlns='http://jabber.org/protocol/httpbind'><blah/></body>"; /* check empty write */

readResponse("<body xmlns='http://jabber.org/protocol/httpbind'><message><splatploing><blittlebarg/></splatploing></message></body>", c1);

eventLoop->processEvents();

CPPUNIT_ASSERT(!c1->pending);

CPPUNIT_ASSERT(c0->pending);

CPPUNIT_ASSERT_EQUAL(st(5), boshDataWritten.size()); /* empty to make room */

CPPUNIT_ASSERT_EQUAL(st(2), connectionFactory->connections.size());

rid++;

testling->write(createSafeByteArray("<bleh/>"));

CPPUNIT_ASSERT(c0->pending);

CPPUNIT_ASSERT(c1->pending);

CPPUNIT_ASSERT_EQUAL(st(6), boshDataWritten.size()); /* data */

rid++;

testling->write(createSafeByteArray("<bluh/>"));

CPPUNIT_ASSERT(c0->pending);

CPPUNIT_ASSERT(c1->pending);

CPPUNIT_ASSERT_EQUAL(st(6), boshDataWritten.size()); /* Don't send data, no room */

eventLoop->processEvents();

CPPUNIT_ASSERT_EQUAL(st(2), connectionFactory->connections.size());

}

void testSession() {

to = "prosody.doomsong.co.uk";

path = "http-bind/";

boshURL = URL("http", to, 5280, path);

PoolRef testling = createTestling();

CPPUNIT_ASSERT_EQUAL(st(1), connectionFactory->connections.size());

eventLoop->processEvents();

CPPUNIT_ASSERT_EQUAL(st(1), boshDataWritten.size()); /* header*/

CPPUNIT_ASSERT_EQUAL(st(1), connectionFactory->connections.size());

eventLoop->processEvents();

CPPUNIT_ASSERT_EQUAL(st(3), boshDataWritten.size());

CPPUNIT_ASSERT_EQUAL(st(1), connectionFactory->connections.size());

}

void testWrite_Empty() {

boost::shared_ptr<MockConnection> c0;

PoolRef testling = createTestling();

CPPUNIT_ASSERT_EQUAL(st(1), connectionFactory->connections.size());

readResponse(initial, c0);

CPPUNIT_ASSERT_EQUAL(st(1), boshDataWritten.size()); /* Shouldn't have sent anything extra */

testling->restartStream();

CPPUNIT_ASSERT_EQUAL(st(2), boshDataWritten.size());

readResponse("<body></body>", c0);

CPPUNIT_ASSERT_EQUAL(st(3), boshDataWritten.size());

std::string fullBody = "<body rid='" + boost::lexical_cast<std::string>(initialRID + 2) + "' sid='" + sid + "' xmlns='http://jabber.org/protocol/httpbind'></body>";

std::string response = boshDataWritten[2];

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

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

}

private:

PoolRef createTestling() {

pool->onXMPPDataRead.connect(boost::bind(&BOSHConnectionPoolTest::handleXMPPDataRead, this, _1));

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

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

pool->onSessionStarted.connect(boost::bind(&BOSHConnectionPoolTest::handleSessionStarted, this));

pool->onSessionTerminated.connect(boost::bind(&BOSHConnectionPoolTest::handleSessionTerminated, this));

return pool;

}

std::string lastBody() {

std::string response = boshDataWritten[boshDataWritten.size() - 1];

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

return response.substr(bodyPosition+4);

}

private:

URL boshURL;

DummyEventLoop* eventLoop;

MockConnectionFactory* connectionFactory;

std::vector<std::string> xmppDataRead;

std::vector<std::string> boshDataRead;

std::vector<std::string> boshDataWritten;

PlatformXMLParserFactory parserFactory;

std::string to;

std::string path;

std::string port;

std::string sid;

std::string initial;

long initialRID;

int sessionStarted;

int sessionTerminated;

#include <boost/smart_ptr/make_shared.hpp>

#include <boost/shared_ptr.hpp>

#include <boost/lexical_cast.hpp>

#include <Swiften/Base/Algorithm.h>

#include <Swiften/Network/Connection.h>

#include <Swiften/Network/ConnectionFactory.h>

#include <Swiften/Network/BOSHConnection.h>

#include <Swiften/Network/HostAddressPort.h>

#include <Swiften/EventLoop/DummyEventLoop.h>

#include <Swiften/Parser/PlatformXMLParserFactory.h>

using namespace Swift;

class BOSHConnectionTest : public CppUnit::TestFixture {

CPPUNIT_TEST_SUITE(BOSHConnectionTest);

CPPUNIT_TEST(testHeader);

CPPUNIT_TEST(testReadiness_ok);

CPPUNIT_TEST(testRead_Fragment);

CPPUNIT_TEST(testHTTPRequest);

CPPUNIT_TEST(testHTTPRequest_Empty);

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

eventLoop = new DummyEventLoop();

connectionFactory = new MockConnectionFactory(eventLoop);

connectFinished = false;

disconnected = false;

disconnectedError = false;

dataRead.clear();

}

void tearDown() {

eventLoop->processEvents();

delete connectionFactory;

}

void testHeader() {

BOSHConnection::ref testling = createTestling();

testling->connect();

eventLoop->processEvents();

testling->startStream("wonderland.lit", 1);

std::string initial("<body wait='60' "

"inactivity='30' "

CPPUNIT_ASSERT_EQUAL(fullBody.size(), http.second);

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

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;

}

void handleConnectFinished(bool error) {

private:

DummyEventLoop* eventLoop;

MockConnectionFactory* connectionFactory;

bool connectFinished;

bool connectFinishedWithError;

bool disconnected;

bool disconnectedError;

ByteArray dataRead;

PlatformXMLParserFactory parserFactory;

std::string sid;

};

CPPUNIT_TEST_SUITE_REGISTRATION(BOSHConnectionTest);

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

CPPUNIT_TEST(testConnect_ReceiveDataAfterConnect);

CPPUNIT_TEST(testWrite_AfterConnect);

CPPUNIT_TEST(testDisconnect_AfterConnectRequest);

CPPUNIT_TEST(testDisconnect_AfterConnect);

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

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

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

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

CPPUNIT_ASSERT(!connectFinished);

}

void testConnect_SendsConnectRequest() {

HTTPConnectProxiedConnection::ref testling(createTestling());

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

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

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

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

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

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

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

CPPUNIT_ASSERT(disconnected);

CPPUNIT_ASSERT(!disconnectedError);

}

void testDisconnect_AfterConnect() {

HTTPConnectProxiedConnection::ref testling(createTestling());

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

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;

return connection;

}

EventLoop* eventLoop;

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

std::vector<HostAddressPort> failingPorts;

};

private:

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

BOSHSessionStream::BOSHSessionStream(

const URL& boshURL,

PayloadParserFactoryCollection* payloadParserFactories,

PayloadSerializerCollection* payloadSerializers,

ConnectionFactory* connectionFactory,

TLSContextFactory* tlsContextFactory,

TimerFactory* timerFactory,

XMLParserFactory* xmlParserFactory,

EventLoop* eventLoop,

const std::string& to,

const URL& boshHTTPConnectProxyURL,

const SafeString& boshHTTPConnectProxyAuthID,

const SafeString& boshHTTPConnectProxyAuthPassword) :

available(false),

payloadParserFactories(payloadParserFactories),

payloadSerializers(payloadSerializers),

tlsContextFactory(tlsContextFactory),

timerFactory(timerFactory),

xmlParserFactory(xmlParserFactory),

eventLoop(eventLoop),

firstHeader(true) {

boost::mt19937 random;

random.seed(time(NULL));

connectionPool->onSessionTerminated.connect(boost::bind(&BOSHSessionStream::handlePoolSessionTerminated, this, _1));

connectionPool->onSessionStarted.connect(boost::bind(&BOSHSessionStream::handlePoolSessionStarted, this));

connectionPool->onXMPPDataRead.connect(boost::bind(&BOSHSessionStream::handlePoolXMPPDataRead, this, _1));

connectionPool->onBOSHDataRead.connect(boost::bind(&BOSHSessionStream::handlePoolBOSHDataRead, this, _1));

connectionPool->onBOSHDataWritten.connect(boost::bind(&BOSHSessionStream::handlePoolBOSHDataWritten, this, _1));

xmppLayer = new XMPPLayer(payloadParserFactories, payloadSerializers, xmlParserFactory, ClientStreamType);

xmppLayer->onStreamStart.connect(boost::bind(&BOSHSessionStream::handleStreamStartReceived, this, _1));

xmppLayer->onElement.connect(boost::bind(&BOSHSessionStream::handleElementReceived, this, _1));

BOSHSessionStream(

const URL& boshURL,

PayloadParserFactoryCollection* payloadParserFactories,

PayloadSerializerCollection* payloadSerializers,

ConnectionFactory* connectionFactory,

TLSContextFactory* tlsContextFactory,

TimerFactory* whitespacePingLayerFactory,

XMLParserFactory* xmlParserFactory,

EventLoop* eventLoop,

const std::string& to,

const URL& boshHTTPConnectProxyURL,

const SafeString& boshHTTPConnectProxyAuthID,

const SafeString& boshHTTPConnectProxyAuthPassword

);

~BOSHSessionStream();

virtual void close();

virtual bool isOpen();