#include <Swiften/Network/NetworkFactories.h>

#include <Swiften/Network/ProxyProvider.h>

#include <Swiften/TLS/PKCS12Certificate.h>

#include <Swiften/Session/BasicSessionStream.h>

#include <Swiften/Session/BOSHSessionStream.h>

#include <Swiften/Queries/IQRouter.h>

#include <Swiften/Client/ClientSessionStanzaChannel.h>

#include <Swiften/Network/SOCKS5ProxiedConnectionFactory.h>

#include <Swiften/Network/HTTPConnectProxiedConnectionFactory.h>

namespace Swift {

CoreClient::CoreClient(const JID& jid, const SafeByteArray& password, NetworkFactories* networkFactories) : jid_(jid), password_(password), networkFactories(networkFactories), disconnectRequested_(false), certificateTrustChecker(NULL) {

stanzaChannel_ = new ClientSessionStanzaChannel();

stanzaChannel_->onMessageReceived.connect(boost::bind(&CoreClient::handleMessageReceived, this, _1));

stanzaChannel_->onPresenceReceived.connect(boost::bind(&CoreClient::handlePresenceReceived, this, _1));

stanzaChannel_->onStanzaAcked.connect(boost::bind(&CoreClient::handleStanzaAcked, this, _1));

stanzaChannel_->onAvailableChanged.connect(boost::bind(&CoreClient::handleStanzaChannelAvailableChanged, this, _1));

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

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

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

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

bindSessionToStream();

}

}

void CoreClient::bindSessionToStream() {

session_ = ClientSession::create(jid_, sessionStream_);

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

rid(initialRID),

pendingTerminate(false),

to(to),

requestLimit(2),

restartCount(0),

pendingRestart(false) {

tlsConnectionFactory = NULL;

if (boshHTTPConnectProxyURL.empty()) {

connectProxyFactory = NULL;

}

else {

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

rawFactory = tlsConnectionFactory;

}

connectProxyFactory = new HTTPConnectProxiedConnectionFactory(rawFactory, HostAddressPort(HostAddress(boshHTTPConnectProxyURL.getHost()), boshHTTPConnectProxyURL.getPort()), boshHTTPConnectProxyAuthID, boshHTTPConnectProxyAuthPassword);

}

createConnection();

}

BOSHConnectionPool::~BOSHConnectionPool() {

close();

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(HostAddressPort(HostAddress("0.0.0.0"), 0));

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

*/

#pragma once

#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 handleHTTPError(const std::string& errorCode);

private:

BOSHConnection::ref createConnection();

void destroyConnection(BOSHConnection::ref connection);

void tryToSendQueuedData();

BOSHConnection::ref getSuitableConnection();

private:

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

std::string sid;

unsigned long rid;

std::vector<SafeByteArray> dataQueue;

bool pendingTerminate;

std::string to;

size_t requestLimit;

int restartCount;

bool pendingRestart;

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

#include <boost/bind.hpp>

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

"requests='2' "

"hold='1' "

"maxpause='120' "

"sid='" + sid + "' "

"ver='1.6' "

"from='wonderland.lit' "

"xmlns='http://jabber.org/protocol/httpbind'/>";

eventLoop = new DummyEventLoop();

connectionFactory = new MockConnectionFactory(eventLoop);

sessionTerminated = 0;

sessionStarted = 0;

initialRID = 2349876;

xmppDataRead.clear();

boshDataRead.clear();

boshDataWritten.clear();

}

void tearDown() {

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

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

std::string response = "<body authid='743da605-4c2e-4de1-afac-ac040dd4a940' xmpp:version='1.0' xmlns:stream='http://etherx.jabber.org/streams' xmlns:xmpp='urn:xmpp:xbosh' inactivity='60' wait='60' polling='5' secure='true' hold='1' from='prosody.doomsong.co.uk' ver='1.6' sid='743da605-4c2e-4de1-afac-ac040dd4a940' requests='2' xmlns='http://jabber.org/protocol/httpbind'><stream:features><auth xmlns='http://jabber.org/features/iq-auth'/><mechanisms xmlns='urn:ietf:params:xml:ns:xmpp-sasl'><mechanism>SCRAM-SHA-1</mechanism><mechanism>DIGEST-MD5</mechanism></mechanisms></stream:features></body>";

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

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 result = "POST /" + path + " HTTP/1.1\r\n"

+ "Host: " + to + ":" + port + "\r\n"

+ "Content-Type: text/xml; charset=utf-8\r\n"

+ "Content-Length: " + boost::lexical_cast<std::string>(body.size()) + "\r\n\r\n"

+ body;

return result;

}

private:

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;

};

CPPUNIT_TEST_SUITE_REGISTRATION(BOSHConnectionPoolTest);

#include <Swiften/StreamStack/CompressionLayer.h>

#include <Swiften/StreamStack/TLSLayer.h>

#include <Swiften/TLS/TLSContextFactory.h>

#include <Swiften/TLS/TLSContext.h>

#include <Swiften/EventLoop/EventLoop.h>

namespace Swift {

BOSHSessionStream::BOSHSessionStream(

PayloadParserFactoryCollection* payloadParserFactories,

PayloadSerializerCollection* payloadSerializers,

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

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <Swiften/Base/SafeString.h>

#include <Swiften/Base/SafeByteArray.h>

#include <Swiften/Network/BOSHConnectionPool.h>

#include <Swiften/Session/SessionStream.h>

#include <Swiften/Elements/StreamType.h>

#include <Swiften/EventLoop/EventOwner.h>

namespace Swift {

class TimerFactory;

class PayloadParserFactoryCollection;

class PayloadSerializerCollection;

class StreamStack;

class ConnectionLayer;

class CompressionLayer;

class XMLParserFactory;

class TLSContextFactory;

class EventLoop;

class BOSHSessionStream : public SessionStream, public EventOwner, public boost::enable_shared_from_this<BOSHSessionStream> {

public:

BOSHSessionStream(

);

~BOSHSessionStream();

virtual void close();

virtual bool isOpen();

virtual void writeHeader(const ProtocolHeader& header);

virtual void writeElement(boost::shared_ptr<Element>);

virtual void writeFooter();