+/*

+ * Copyright (c) 2011 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

+#include <string>

+

+namespace Swift {

+

+class URL {

+ public:

+

+ URL() : scheme(""), user(""), password(""), host(""), port(-1), path(""), isEmpty(true) {

+ }

+

+ URL(const std::string& scheme, const std::string& host, int port, const std::string& path) : scheme(scheme), user(), password(), host(host), port(port), path(path), isEmpty(false) {

+

+ }

+

+ /**

+ * Whether the URL is empty.

+ */

+ bool empty() const {

+ return isEmpty;

+ }

+

+ /**

+ * Scheme used for the URL (http, https etc.)

+ */

+ const std::string& getScheme() const {

+ return scheme;

+ }

+

+ /**

+ * Hostname

+ */

+ const std::string& getHost() const {

+ return host;

+ }

+

+ /**

+ * Port number

+ */

+ int getPort() const {

+ return port;

+ }

+

+ /**

+ * Path

+ */

+ const std::string& getPath() const {

+ return path;

+ }

+

+

+

+ private:

+ std::string scheme;

+ std::string user;

+ std::string password;

+ std::string host;

+ int port;

+ std::string path;

+ bool isEmpty;

+ };

+}

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

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

+

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

+

+ /**

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

+ * The host currently needs to be specified by IP, rather than hostname.

+ * Default: empty (no BOSH)

+ */

+ URL boshURL;

+

+ /**

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

+ * proxy instead of directly.

+ * Must be specified by IP, rather than hostname.

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

+ */

+ SafeString boshHTTPConnectProxyAuthID;

+ SafeString boshHTTPConnectProxyAuthPassword;

+ else if (useStreamCompression && stream->supportsZLibCompression() && streamFeatures->hasCompressionMethod("zlib")) {

+ClientXMLTracer::ClientXMLTracer(CoreClient* client, bool bosh) : bosh(bosh) {

+ if (bosh) {

+ std::string line = byteArrayToString(ByteArray(data.begin(), data.end()));

+ size_t endOfHTTP = line.find("\r\n\r\n");

+ if (false && endOfHTTP != std::string::npos) {

+ /* Disabled because it swallows bits of XML (namespaces, if I recall) */

+ std::cerr << line.substr(0, endOfHTTP) << std::endl << beautifier->beautify(line.substr(endOfHTTP)) << std::endl;

+ }

+ else {

+ std::cerr << line << std::endl;

+ }

+ }

+ else {

+ std::cerr << beautifier->beautify(byteArrayToString(ByteArray(data.begin(), data.end()))) << std::endl;

+ }

+ ClientXMLTracer(CoreClient* client, bool bosh = false);

+ bool bosh;

+ * Copyright (c) 2010-2011 Remko Tronçon

+#include <Swiften/Session/BOSHSessionStream.h>

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

+ }

+ 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_ = boost::shared_ptr<BOSHSessionStream>(new 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_);

+ session_->setCertificateTrustChecker(certificateTrustChecker);

+ session_->setUseStreamCompression(options.useStreamCompression);

+ session_->setAllowPLAINOverNonTLS(options.allowPLAINWithoutTLS);

+ switch(options.useTLS) {

+ case ClientOptions::UseTLSWhenAvailable:

+ session_->setUseTLS(ClientSession::UseTLSWhenAvailable);

+ break;

+ case ClientOptions::NeverUseTLS:

+ session_->setUseTLS(ClientSession::NeverUseTLS);

+ break;

+ case ClientOptions::RequireTLS:

+ session_->setUseTLS(ClientSession::RequireTLS);

+ break;

+ }

+ session_->setUseAcks(options.useAcks);

+ stanzaChannel_->setSession(session_);

+ session_->onFinished.connect(boost::bind(&CoreClient::handleSessionFinished, this, _1));

+ session_->onNeedCredentials.connect(boost::bind(&CoreClient::handleNeedCredentials, this));

+ session_->start();

+/**

+ * Only called for TCP sessions. BOSH is handled inside the BOSHSessionStream.

+ */

+ bindSessionToStream();

+ if (connection_) {

+ connection_->disconnect();

+ }

+ else if (boost::dynamic_pointer_cast<BOSHSessionStream>(sessionStream_)) {

+ sessionStream_->close();

+ }

+ sessionStream_.reset();

+ class SessionStream;

+ void bindSessionToStream();

+ boost::shared_ptr<SessionStream> sessionStream_;

+ virtual bool supportsZLibCompression() {

+ return true;

+ }

+

+ virtual bool supportsZLibCompression() {

+ return true;

+ }

+

+/*

+ * Copyright (c) 2011 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

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

+

+#include <boost/lexical_cast.hpp>

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

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

+#include <Swiften/Parser/BOSHBodyExtractor.h>

+BOSHConnection::BOSHConnection(const URL& boshURL, ConnectionFactory* connectionFactory, XMLParserFactory* parserFactory, TLSContextFactory* tlsFactory)

+ : boshURL_(boshURL),

+ connectionFactory_(connectionFactory),

+ parserFactory_(parserFactory),

+ sid_(),

+ waitingForStartResponse_(false),

+ pending_(false),

+ tlsFactory_(tlsFactory),

+ connectionReady_(false)

+{

+}

+BOSHConnection::~BOSHConnection() {

+ if (connection_) {

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

+ 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(const HostAddressPort& server) {

+ /* FIXME: Redundant parameter */

+ Connection::ref rawConnection = connectionFactory_->createConnection();

+ connection_ = (boshURL_.getScheme() == "https") ? boost::make_shared<TLSConnection>(rawConnection, tlsFactory_) : rawConnection;

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

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

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

+ connection_->connect(HostAddressPort(HostAddress(boshURL_.getHost()), boshURL_.getPort()));

+}

+void BOSHConnection::listen() {

+ assert(false);

+}

+

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

+}

+

+std::pair<SafeByteArray, size_t> BOSHConnection::createHTTPRequest(const SafeByteArray& data, bool streamRestart, bool terminate, long rid, const std::string& sid, const URL& boshURL) {

+ 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'";

+ if (terminate) {

+ content << " type='terminate'";

+ }

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

+ SafeByteArray safeContent = createSafeByteArray(content.str());

+ safeContent.insert(safeContent.end(), data.begin(), data.end());

+ safeContent.insert(safeContent.end(), contentTail.begin(), contentTail.end());

+ size = safeContent.size();

+

+ header << "POST /" << boshURL.getPath() << " HTTP/1.1\r\n"

+ << "Host: " << boshURL.getHost() << ":" << boshURL.getPort() << "\r\n"

+ /*<< "Accept-Encoding: deflate\r\n"*/

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

+ << "Content-Length: " << size << "\r\n\r\n";

+

+ SafeByteArray safeHeader = createSafeByteArray(header.str());

+ safeHeader.insert(safeHeader.end(), safeContent.begin(), safeContent.end());

+

+ return std::pair<SafeByteArray, size_t>(safeHeader, size);

+}

+

+void BOSHConnection::write(const SafeByteArray& data, bool streamRestart, bool terminate) {

+ assert(connectionReady_);

+ assert(!sid_.empty());

+

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

+}

+

+void BOSHConnection::handleConnectionConnectFinished(bool error) {

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

+ connectionReady_ = !error;

+ onConnectFinished(error);

+}

+

+void BOSHConnection::startStream(const std::string& to, unsigned long rid) {

+ 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 << "'"

+ << " ver='1.6'"

+ << " wait='60'" /* FIXME: we probably want this configurable*/

+ /*<< " ack='0'" FIXME: support acks */

+ << " xml:lang='en'"

+ << " xmlns:xmpp='urn:xmpp:bosh'"

+ << " xmpp:version='1.0'"

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

+

+ std::string contentString = content.str();

+

+ header << "POST /" << boshURL_.getPath() << " HTTP/1.1\r\n"

+ << "Host: " << boshURL_.getHost() << ":" << boshURL_.getPort() << "\r\n"

+ /*<< "Accept-Encoding: deflate\r\n"*/

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

+ << "Content-Length: " << contentString.size() << "\r\n\r\n"

+ << contentString;

+

+ waitingForStartResponse_ = true;

+ SafeByteArray safeHeader = createSafeByteArray(header.str());

+ onBOSHDataWritten(safeHeader);

+ connection_->write(safeHeader);

+ SWIFT_LOG(debug) << "write stream header: " << safeByteArrayToString(safeHeader) << std::endl;

+}

+

+void BOSHConnection::handleDataRead(boost::shared_ptr<SafeByteArray> data) {

+ onBOSHDataRead(*data.get());

+ buffer_ = concat(buffer_, *data.get());

+ std::string response = safeByteArrayToString(buffer_);

+ if (response.find("\r\n\r\n") == std::string::npos) {

+ onBOSHDataRead(createSafeByteArray("[[Previous read incomplete, pending]]"));

+ return;

+ }

+

+ std::string httpCode = response.substr(response.find(" ") + 1, 3);

+ if (httpCode != "200") {

+ onHTTPError(httpCode);

+ return;

+ BOSHBodyExtractor parser(parserFactory_, createByteArray(response.substr(response.find("\r\n\r\n") + 4)));

+ if (parser.getBody()) {

+ if ((*parser.getBody()).attributes.getAttribute("type") == "terminate") {

+ BOSHError::Type errorType = parseTerminationCondition((*parser.getBody()).attributes.getAttribute("condition"));

+ onSessionTerminated(errorType == BOSHError::NoError ? boost::shared_ptr<BOSHError>() : boost::make_shared<BOSHError>(errorType));

+ }

+ buffer_.clear();

+ if (waitingForStartResponse_) {

+ waitingForStartResponse_ = false;

+ sid_ = (*parser.getBody()).attributes.getAttribute("sid");

+ std::string requestsString = (*parser.getBody()).attributes.getAttribute("requests");

+ int requests = 2;

+ if (!requestsString.empty()) {

+ requests = boost::lexical_cast<size_t>(requestsString);

+ onSessionStarted(sid_, requests);

+ SafeByteArray payload = createSafeByteArray((*parser.getBody()).content);

+ /* Say we're good to go again, so don't add anything after here in the method */

+ pending_ = false;

+ onXMPPDataRead(payload);

+}

+BOSHError::Type BOSHConnection::parseTerminationCondition(const std::string& text) {

+ BOSHError::Type condition = BOSHError::UndefinedCondition;

+ if (text == "bad-request") {

+ condition = BOSHError::BadRequest;

+ }

+ else if (text == "host-gone") {

+ condition = BOSHError::HostGone;

+ }

+ else if (text == "host-unknown") {

+ condition = BOSHError::HostUnknown;

+ }

+ else if (text == "improper-addressing") {

+ condition = BOSHError::ImproperAddressing;

+ }

+ else if (text == "internal-server-error") {

+ condition = BOSHError::InternalServerError;

+ }

+ else if (text == "item-not-found") {

+ condition = BOSHError::ItemNotFound;

+ }

+ else if (text == "other-request") {

+ condition = BOSHError::OtherRequest;

+ }

+ else if (text == "policy-violation") {

+ condition = BOSHError::PolicyViolation;

+ }

+ else if (text == "remote-connection-failed") {

+ condition = BOSHError::RemoteConnectionFailed;

+ }

+ else if (text == "remote-stream-error") {

+ condition = BOSHError::RemoteStreamError;

+ else if (text == "see-other-uri") {

+ condition = BOSHError::SeeOtherURI;

+ }

+ else if (text == "system-shutdown") {

+ condition = BOSHError::SystemShutdown;

+ }

+ else if (text == "") {

+ condition = BOSHError::NoError;

+ }

+ return condition;

+}

+

+const std::string& BOSHConnection::getSID() {

+ return sid_;

+}

+

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

+ rid_ = rid;

+}

+

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

+ sid_ = sid;

+}

+

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

+ onDisconnected(error);

+ sid_ = "";

+ connectionReady_ = false;

+}

+

+HostAddressPort BOSHConnection::getLocalAddress() const {

+ return connection_->getLocalAddress();

+}

+

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

+ return connectionReady_ && !pending_ && !waitingForStartResponse_ && !sid_.empty();

+}

+

+/*

+ * Copyright (c) 2011 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+

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

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

+#include <Swiften/Session/SessionStream.h>

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

+ BOSHError(Type type) : SessionStream::Error(SessionStream::Error::ConnectionReadError), type(type) {}

+ Type getType() {return type;}

+ typedef boost::shared_ptr<BOSHError> ref;

+ private:

+ Type type;

+

+ };

+

+ static ref create(const URL& boshURL, ConnectionFactory* connectionFactory, XMLParserFactory* parserFactory, TLSContextFactory* tlsFactory) {

+ return ref(new BOSHConnection(boshURL, connectionFactory, parserFactory, tlsFactory));

+

+ const std::string& getSID();

+ void setRID(unsigned long rid);

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

+ void startStream(const std::string& to, unsigned long rid);

+ void terminateStream();

+ bool isReadyToSend();

+ void restartStream();

+ static std::pair<SafeByteArray, size_t> createHTTPRequest(const SafeByteArray& data, bool streamRestart, bool terminate, long rid, const std::string& sid, const URL& boshURL);

+

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

+ BOSHConnection(const URL& boshURL, ConnectionFactory* connectionFactory, XMLParserFactory* parserFactory, TLSContextFactory* tlsFactory);

+

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

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

+ bool waitingForStartResponse_;

+ unsigned long rid_;

+ SafeByteArray buffer_;

+ bool pending_;

+ TLSContextFactory* tlsFactory_;

+ bool connectionReady_;

+/*

+ * Copyright (c) 2011 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

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

+BOSHConnectionFactory::BOSHConnectionFactory(const URL& boshURL, ConnectionFactory* connectionFactory, XMLParserFactory* xmlParserFactory, TLSContextFactory* tlsFactory) : boshURL(boshURL), connectionFactory(connectionFactory), xmlParserFactory(xmlParserFactory), tlsFactory(tlsFactory) {

+boost::shared_ptr<Connection> BOSHConnectionFactory::createConnection(ConnectionFactory* overrideFactory) {

+ return BOSHConnection::create(boshURL, overrideFactory != NULL ? overrideFactory : connectionFactory, xmlParserFactory, tlsFactory);

+/*

+ * Copyright (c) 2011 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#include <string>

+

+#include <Swiften/TLS/TLSContextFactory.h>

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

+class XMLParserFactory;

+

+class BOSHConnectionFactory {

+ public:

+ BOSHConnectionFactory(const URL& boshURL, ConnectionFactory* connectionFactory, XMLParserFactory* xmlParserFactory, TLSContextFactory* tlsFactory);

+

+ /**

+ * @param overrideFactory If non-NULL, creates a connection over the given factory instead.

+ */

+ boost::shared_ptr<Connection> createConnection(ConnectionFactory* overrideFactory);

+ ConnectionFactory* getRawConnectionFactory() {return connectionFactory;}

+ TLSContextFactory* getTLSContextFactory() {return tlsFactory;}

+ private:

+ URL boshURL;

+ ConnectionFactory* connectionFactory;

+ XMLParserFactory* xmlParserFactory;

+ TLSContextFactory* tlsFactory;

+};

+/*

+ * Copyright (c) 2011 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

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

+

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

+BOSHConnectionPool::BOSHConnectionPool(boost::shared_ptr<BOSHConnectionFactory> connectionFactory, const std::string& to, long initialRID, const URL& boshHTTPConnectProxyURL, const SafeString& boshHTTPConnectProxyAuthID, const SafeString& boshHTTPConnectProxyAuthPassword)

+ : connectionFactory(connectionFactory),

+ rid(initialRID),

+ pendingTerminate(false),

+ to(to),

+ requestLimit(2),

+ restartCount(0),

+ pendingRestart(false) {

+ tlsConnectionFactory = NULL;

+ if (boshHTTPConnectProxyURL.empty()) {

+ connectProxyFactory = NULL;

+ }

+ else {

+ ConnectionFactory* rawFactory = connectionFactory->getRawConnectionFactory();

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

+ tlsConnectionFactory = new TLSConnectionFactory(connectionFactory->getTLSContextFactory(), rawFactory);

+ rawFactory = tlsConnectionFactory;

+ }

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

+ }

+ createConnection();

+}

+

+BOSHConnectionPool::~BOSHConnectionPool() {

+ close();

+ delete connectProxyFactory;

+ delete tlsConnectionFactory;

+}

+

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

+ dataQueue.push_back(data);

+ tryToSendQueuedData();

+}

+

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

+ onXMPPDataRead(data);

+ tryToSendQueuedData(); /* Will rebalance the connections */

+}

+

+void BOSHConnectionPool::restartStream() {

+ BOSHConnection::ref connection = getSuitableConnection();

+ if (connection) {

+ pendingRestart = false;

+ rid++;

+ connection->setRID(rid);

+ connection->restartStream();

+ restartCount++;

+ }

+ else {

+ pendingRestart = true;

+ }

+}

+

+void BOSHConnectionPool::writeFooter() {

+ pendingTerminate = true;

+ tryToSendQueuedData();

+}

+

+void BOSHConnectionPool::close() {

+ /* TODO: Send a terminate here. */

+ std::vector<BOSHConnection::ref> connectionCopies = connections;

+ foreach (BOSHConnection::ref connection, connectionCopies) {

+ if (connection) {

+ connection->disconnect();

+ destroyConnection(connection);

+ }

+ }

+}

+

+void BOSHConnectionPool::handleSessionStarted(const std::string& sessionID, size_t requests) {

+ sid = sessionID;

+ requestLimit = requests;

+ onSessionStarted();

+}

+

+void BOSHConnectionPool::handleConnectFinished(bool error, BOSHConnection::ref connection) {

+ if (error) {

+ onSessionTerminated(boost::make_shared<BOSHError>(BOSHError::UndefinedCondition));

+ /*TODO: We can probably manage to not terminate the stream here and use the rid/ack retry

+ * logic to just swallow the error and try again (some number of tries).

+ */

+ }

+ else {

+ if (sid.empty()) {

+ connection->startStream(to, rid);

+ }

+ if (pendingRestart) {

+ restartStream();

+ }

+ tryToSendQueuedData();

+ }

+}

+

+BOSHConnection::ref BOSHConnectionPool::getSuitableConnection() {

+ BOSHConnection::ref suitableConnection;

+ foreach (BOSHConnection::ref connection, connections) {

+ if (connection->isReadyToSend()) {

+ suitableConnection = connection;

+ break;

+ }

+ }

+

+ if (!suitableConnection && connections.size() < requestLimit) {

+ /* This is not a suitable connection because it won't have yet connected and added TLS if needed. */

+ BOSHConnection::ref newConnection = createConnection();

+ newConnection->setSID(sid);

+ }

+ assert(connections.size() <= requestLimit);

+ assert((!suitableConnection) || suitableConnection->isReadyToSend());

+ return suitableConnection;

+}

+

+void BOSHConnectionPool::tryToSendQueuedData() {

+ if (sid.empty()) {

+ /* If we've not got as far as stream start yet, pend */

+ return;

+ }

+

+ BOSHConnection::ref suitableConnection = getSuitableConnection();

+ bool sent = false;

+ bool toSend = !dataQueue.empty();

+ if (suitableConnection) {

+ if (toSend) {

+ rid++;

+ suitableConnection->setRID(rid);

+ SafeByteArray data;

+ foreach (const SafeByteArray& datum, dataQueue) {

+ data.insert(data.end(), datum.begin(), datum.end());

+ }

+ suitableConnection->write(data);

+ sent = true;

+ dataQueue.clear();

+ }

+ else if (pendingTerminate) {

+ rid++;

+ suitableConnection->setRID(rid);

+ suitableConnection->terminateStream();

+ sent = true;

+ onSessionTerminated(boost::shared_ptr<BOSHError>());

+ }

+ }

+ if (!pendingTerminate) {

+ /* Ensure there's always a session waiting to read data for us */

+ bool pending = false;

+ foreach (BOSHConnection::ref connection, connections) {

+ if (connection && !connection->isReadyToSend()) {

+ pending = true;

+ }

+ }

+ if (!pending) {

+ if (restartCount >= 1) {

+ /* Don't open a second connection until we've restarted the stream twice - i.e. we've authed and resource bound.*/

+ if (suitableConnection) {

+ rid++;

+ suitableConnection->setRID(rid);

+ suitableConnection->write(createSafeByteArray(""));

+ }

+ else {

+ /* My thought process I went through when writing this, to aid anyone else confused why this can happen...

+ *

+ * What to do here? I think this isn't possible.

+ If you didn't have two connections, suitable would have made one.

+ If you have two connections and neither is suitable, pending would be true.

+ If you have a non-pending connection, it's suitable.

+

+ If I decide to do something here, remove assert above.

+

+ Ah! Yes, because there's a period between creating the connection and it being connected. */

+ }

+ }

+ }

+ }

+}

+

+void BOSHConnectionPool::handleHTTPError(const std::string& /*errorCode*/) {

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

+}

+

+void BOSHConnectionPool::handleConnectionDisconnected(const boost::optional<Connection::Error>& error, BOSHConnection::ref connection) {

+ destroyConnection(connection);

+ if (false && error) {

+ 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 = boost::dynamic_pointer_cast<BOSHConnection>(connectionFactory->createConnection(connectProxyFactory));

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

+ connections.push_back(connection);

+ return connection;

+}

+

+void BOSHConnectionPool::destroyConnection(boost::shared_ptr<BOSHConnection> connection) {

+ connections.erase(std::remove(connections.begin(), connections.end(), connection), connections.end());

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

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

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

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

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

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

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

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

+}

+

+void BOSHConnectionPool::handleSessionTerminated(BOSHError::ref error) {

+ onSessionTerminated(error);

+}

+

+void BOSHConnectionPool::handleBOSHDataRead(const SafeByteArray& data) {

+ onBOSHDataRead(data);

+}

+

+void BOSHConnectionPool::handleBOSHDataWritten(const SafeByteArray& data) {

+ onBOSHDataWritten(data);

+}

+

+}

+/*

+ * Copyright (c) 2011 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+

+#pragma once

+

+#include <vector>

+

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

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

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

+

+namespace Swift {

+ class HTTPConnectProxiedConnectionFactory;

+ class TLSConnectionFactory;

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

+ public:

+ BOSHConnectionPool(boost::shared_ptr<BOSHConnectionFactory> factory, const std::string& to, long initialRID, const URL& boshHTTPConnectProxyURL, const SafeString& boshHTTPConnectProxyAuthID, const SafeString& boshHTTPConnectProxyAuthPassword);

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

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

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

+

+ private:

+ void handleDataRead(const SafeByteArray& data);

+ void handleSessionStarted(const std::string& sid, size_t requests);

+ void handleBOSHDataRead(const SafeByteArray& data);

+ void handleBOSHDataWritten(const SafeByteArray& data);

+ void handleSessionTerminated(BOSHError::ref condition);

+ void handleConnectFinished(bool, BOSHConnection::ref connection);

+ void handleConnectionDisconnected(const boost::optional<Connection::Error>& error, BOSHConnection::ref connection);

+ void handleHTTPError(const std::string& errorCode);

+

+ private:

+ BOSHConnection::ref createConnection();

+ void destroyConnection(BOSHConnection::ref connection);

+ void tryToSendQueuedData();

+ BOSHConnection::ref getSuitableConnection();

+

+ private:

+ boost::shared_ptr<BOSHConnectionFactory> connectionFactory;

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

+ HTTPConnectProxiedConnectionFactory* connectProxyFactory;

+ TLSConnectionFactory* tlsConnectionFactory;

+ };

+}

+BoostNetworkFactories::BoostNetworkFactories(EventLoop* eventLoop) : eventLoop(eventLoop){

+ virtual EventLoop* getEventLoop() const {

+ return eventLoop;

+ }

+

+ EventLoop* eventLoop;

+/*

+ * Copyright (c) 2011 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+

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

+#include <Swiften/StringCodecs/Base64.h>

+HTTPConnectProxiedConnection::HTTPConnectProxiedConnection(ConnectionFactory* connectionFactory, HostAddressPort proxy, const SafeString& authID, const SafeString& authPassword) : connectionFactory_(connectionFactory), proxy_(proxy), server_(HostAddressPort(HostAddress("0.0.0.0"), 0)), authID_(authID), authPassword_(authPassword) {

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

+ }

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

+ connection_->write(data);

+/*

+ * Copyright (c) 2011 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+

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

+ static ref create(ConnectionFactory* connectionFactory, HostAddressPort proxy, const SafeString& authID, const SafeString& authPassword) {

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

+ HTTPConnectProxiedConnection(ConnectionFactory* connectionFactory, HostAddressPort proxy, const SafeString& authID, const SafeString& authPassword);

+ SafeByteArray authID_;

+ SafeByteArray authPassword_;

+HTTPConnectProxiedConnectionFactory::HTTPConnectProxiedConnectionFactory(ConnectionFactory* connectionFactory, const HostAddressPort& proxy) : connectionFactory_(connectionFactory), proxy_(proxy), authID_(""), authPassword_("") {

+}

+

+

+HTTPConnectProxiedConnectionFactory::HTTPConnectProxiedConnectionFactory(ConnectionFactory* connectionFactory, const HostAddressPort& proxy, const SafeString& authID, const SafeString& authPassword) : connectionFactory_(connectionFactory), proxy_(proxy), authID_(authID), authPassword_(authPassword) {

+ return HTTPConnectProxiedConnection::create(connectionFactory_, proxy_, authID_, authPassword_);

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

+ HTTPConnectProxiedConnectionFactory(ConnectionFactory* connectionFactory, const HostAddressPort& proxy, const SafeString& authID, const SafeString& authPassword);

+ SafeString authID_;

+ SafeString authPassword_;

+ class EventLoop;

+ virtual EventLoop* getEventLoop() const {};

+ "BOSHConnectionPool.cpp",

+ "BOSHConnectionFactory.cpp",

+ "TLSConnection.cpp",

+ "TLSConnectionFactory.cpp",

+/*

+ * Copyright (c) 2011 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

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

+

+#include <boost/bind.hpp>

+

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

+#include <Swiften/TLS/TLSContext.h>

+#include <Swiften/TLS/TLSContextFactory.h>

+

+namespace Swift {

+

+TLSConnection::TLSConnection(Connection::ref connection, TLSContextFactory* tlsFactory) : connection(connection) {

+ context = tlsFactory->createTLSContext();

+ context->onDataForNetwork.connect(boost::bind(&TLSConnection::handleTLSDataForNetwork, this, _1));

+ context->onDataForApplication.connect(boost::bind(&TLSConnection::handleTLSDataForApplication, this, _1));

+ context->onConnected.connect(boost::bind(&TLSConnection::handleTLSConnectFinished, this, false));

+ context->onError.connect(boost::bind(&TLSConnection::handleTLSConnectFinished, this, true));

+

+ connection->onConnectFinished.connect(boost::bind(&TLSConnection::handleRawConnectFinished, this, _1));

+ connection->onDataRead.connect(boost::bind(&TLSConnection::handleRawDataRead, this, _1));

+ connection->onDataWritten.connect(boost::bind(&TLSConnection::handleRawDataWritten, this));

+ connection->onDisconnected.connect(boost::bind(&TLSConnection::handleRawDisconnected, this, _1));

+}

+

+TLSConnection::~TLSConnection() {

+ connection->onConnectFinished.disconnect(boost::bind(&TLSConnection::handleRawConnectFinished, this, _1));

+ connection->onDataRead.disconnect(boost::bind(&TLSConnection::handleRawDataRead, this, _1));

+ connection->onDataWritten.disconnect(boost::bind(&TLSConnection::handleRawDataWritten, this));

+ connection->onDisconnected.disconnect(boost::bind(&TLSConnection::handleRawDisconnected, this, _1));

+ delete context;

+}

+

+void TLSConnection::handleTLSConnectFinished(bool error) {

+ onConnectFinished(error);

+ if (error) {

+ disconnect();

+ }

+}

+

+void TLSConnection::handleTLSDataForNetwork(const SafeByteArray& data) {

+ connection->write(data);

+}

+

+void TLSConnection::handleTLSDataForApplication(const SafeByteArray& data) {

+ onDataRead(boost::make_shared<SafeByteArray>(data));

+}

+

+void TLSConnection::connect(const HostAddressPort& address) {

+ connection->connect(address);

+}

+

+void TLSConnection::disconnect() {

+ connection->disconnect();

+}

+

+void TLSConnection::write(const SafeByteArray& data) {

+ context->handleDataFromApplication(data);

+}

+

+HostAddressPort TLSConnection::getLocalAddress() const {

+ return connection->getLocalAddress();

+}

+

+void TLSConnection::handleRawConnectFinished(bool error) {

+ connection->onConnectFinished.disconnect(boost::bind(&TLSConnection::handleRawConnectFinished, this, _1));

+ if (error) {

+ onConnectFinished(true);

+ }

+ else {

+ context->connect();

+ }

+}

+

+void TLSConnection::handleRawDisconnected(const boost::optional<Error>& error) {

+ onDisconnected(error);

+}

+

+void TLSConnection::handleRawDataRead(boost::shared_ptr<SafeByteArray> data) {

+ context->handleDataFromNetwork(*data);

+}

+

+void TLSConnection::handleRawDataWritten() {

+ onDataWritten();

+}

+

+}

+/*

+ * Copyright (c) 2011 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

+#include <boost/shared_ptr.hpp>

+#include <boost/enable_shared_from_this.hpp>

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

+

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

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

+

+namespace Swift {

+ class HostAddressPort;

+ class TLSContextFactory;

+ class TLSContext;

+

+ class TLSConnection : public Connection {

+ public:

+

+ TLSConnection(Connection::ref connection, TLSContextFactory* tlsFactory);

+ virtual ~TLSConnection();

+

+ virtual void listen() {assert(false);};

+ virtual void connect(const HostAddressPort& address);

+ virtual void disconnect();

+ virtual void write(const SafeByteArray& data);

+

+ virtual HostAddressPort getLocalAddress() const;

+

+ private:

+ void handleRawConnectFinished(bool error);

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

+ void handleRawDataRead(boost::shared_ptr<SafeByteArray> data);

+ void handleRawDataWritten();

+ void handleTLSConnectFinished(bool error);

+ void handleTLSDataForNetwork(const SafeByteArray& data);

+ void handleTLSDataForApplication(const SafeByteArray& data);

+ private:

+ TLSContext* context;

+ Connection::ref connection;

+ };

+}

+/*

+ * Copyright (c) 2011 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

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

+

+#include <boost/shared_ptr.hpp>

+

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

+

+namespace Swift {

+

+TLSConnectionFactory::TLSConnectionFactory(TLSContextFactory* contextFactory, ConnectionFactory* connectionFactory) : contextFactory(contextFactory), connectionFactory(connectionFactory){

+

+}

+

+TLSConnectionFactory::~TLSConnectionFactory() {

+

+}

+

+

+boost::shared_ptr<Connection> TLSConnectionFactory::createConnection() {

+ return boost::make_shared<TLSConnection>(connectionFactory->createConnection(), contextFactory);

+}

+

+}

+/*

+ * Copyright (c) 2011 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

+#include <boost/shared_ptr.hpp>

+

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

+#include <Swiften/TLS/TLSContextFactory.h>

+

+namespace Swift {

+ class Connection;

+

+ class TLSConnectionFactory : public ConnectionFactory {

+ public:

+ TLSConnectionFactory(TLSContextFactory* contextFactory, ConnectionFactory* connectionFactory);

+ virtual ~TLSConnectionFactory();

+

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

+ private:

+ TLSContextFactory* contextFactory;

+ ConnectionFactory* connectionFactory;

+ };

+}

+/*

+ * Copyright (c) 2011 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#include <QA/Checker/IO.h>

+

+#include <cppunit/extensions/HelperMacros.h>

+#include <cppunit/extensions/TestFactoryRegistry.h>

+

+#include <boost/optional.hpp>

+#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/BOSHConnectionFactory.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);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ void setUp() {

+ to = "wonderland.lit";

+ path = "http-bind";

+ port = "5280";

+ sid = "MyShinySID";

+ initial = "<body wait='60' "

+ "inactivity='30' "

+ "polling='5' "

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

+ factory = boost::make_shared<BOSHConnectionFactory>(URL("http", to, 5280, path), connectionFactory, &parserFactory, static_cast<TLSContextFactory*>(NULL));

+ 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(1, sessionStarted);

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

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

+ eventLoop->processEvents();

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

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

+ testling->restartStream();

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

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

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

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

+ eventLoop->processEvents();

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

+ }

+

+ void testConnectionCount_ThreeWrites_ManualConnect() {

+ connectionFactory->autoFinishConnect = false;

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

+ long rid = initialRID;

+

+ PoolRef testling = createTestling();

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

+ c0 = connectionFactory->connections[0];

+ eventLoop->processEvents();

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

+

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

+ CPPUNIT_ASSERT_EQUAL(fullBody, lastBody());

+ CPPUNIT_ASSERT(c0->pending);

+ CPPUNIT_ASSERT(c1->pending);

+

+

+ rid++;

+ readResponse("<body xmlns='http://jabber.org/protocol/httpbind'><message><splatploing/></message></body>", c0); /* Doesn't include necessary attributes - as the support is improved this'll start to fail */

+ eventLoop->processEvents();

+ CPPUNIT_ASSERT(!c0->pending);

+ CPPUNIT_ASSERT(c1->pending);

+ CPPUNIT_ASSERT_EQUAL(st(4), boshDataWritten.size()); /* don't send empty in [0], still have [1] waiting */

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

+

+ rid++;

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

+ factory = boost::make_shared<BOSHConnectionFactory>(URL("http", to, 5280, path), connectionFactory, &parserFactory, static_cast<TLSContextFactory*>(NULL));

+

+

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

+ eventLoop->processEvents();

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

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

+

+ std::string send = "<auth xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\" mechanism=\"SCRAM-SHA-1\">biwsbj1hZG1pbixyPWZhOWE5ZDhiLWZmMDctNGE4Yy04N2E3LTg4YWRiNDQxZGUwYg==</auth>";

+ testling->write(createSafeByteArray(send));

+ eventLoop->processEvents();

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

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

+

+ response = "<body xmlns='http://jabber.org/protocol/httpbind' sid='743da605-4c2e-4de1-afac-ac040dd4a940' xmlns:stream = 'http://etherx.jabber.org/streams'><challenge xmlns='urn:ietf:params:xml:ns:xmpp-sasl'>cj1mYTlhOWQ4Yi1mZjA3LTRhOGMtODdhNy04OGFkYjQ0MWRlMGJhZmZlMWNhMy1mMDJkLTQ5NzEtYjkyNS0yM2NlNWQ2MDQyMjYscz1OVGd5WkdWaFptTXRaVE15WXkwMFpXUmhMV0ZqTURRdFpqYzRNbUppWmpGa1pqWXgsaT00MDk2</challenge></body>";

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

+ eventLoop->processEvents();

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

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

+

+ send = "<response xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\">Yz1iaXdzLHI9ZmE5YTlkOGItZmYwNy00YThjLTg3YTctODhhZGI0NDFkZTBiYWZmZTFjYTMtZjAyZC00OTcxLWI5MjUtMjNjZTVkNjA0MjI2LHA9aU11NWt3dDN2VWplU2RqL01Jb3VIRldkZjBnPQ==</response>";

+ testling->write(createSafeByteArray(send));

+ eventLoop->processEvents();

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

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

+

+ response = "<body xmlns='http://jabber.org/protocol/httpbind' sid='743da605-4c2e-4de1-afac-ac040dd4a940' xmlns:stream = 'http://etherx.jabber.org/streams'><success xmlns='urn:ietf:params:xml:ns:xmpp-sasl'>dj1YNmNBY3BBOWxHNjNOOXF2bVQ5S0FacERrVm89</success></body>";

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

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

+ c0 = connectionFactory->connections[0];

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

+ eventLoop->processEvents();

+

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

+ PoolRef pool = boost::make_shared<BOSHConnectionPool>(factory, to, initialRID, URL(), "", "");

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

+ }

+

+ size_t st(int val) {

+ return static_cast<size_t>(val);

+ }

+

+ void handleXMPPDataRead(const SafeByteArray& d) {

+ xmppDataRead.push_back(safeByteArrayToString(d));

+ }

+

+ void handleBOSHDataRead(const SafeByteArray& d) {

+ boshDataRead.push_back(safeByteArrayToString(d));

+ }

+

+ void handleBOSHDataWritten(const SafeByteArray& d) {

+ boshDataWritten.push_back(safeByteArrayToString(d));

+ }

+

+

+ void handleSessionStarted() {

+ sessionStarted++;

+ }

+

+ void handleSessionTerminated() {

+ sessionTerminated++;

+ }

+

+ struct MockConnection : public Connection {

+ public:

+ MockConnection(const std::vector<HostAddressPort>& failingPorts, EventLoop* eventLoop, bool autoFinishConnect) : eventLoop(eventLoop), failingPorts(failingPorts), disconnected(false), pending(false), autoFinishConnect(autoFinishConnect) {

+ }

+

+ void listen() { assert(false); }

+

+ void connect(const HostAddressPort& address) {

+ hostAddressPort = address;

+ bool fail = std::find(failingPorts.begin(), failingPorts.end(), address) != failingPorts.end();

+ if (autoFinishConnect) {

+ eventLoop->postEvent(boost::bind(boost::ref(onConnectFinished), fail));

+ }

+ }

+

+ HostAddressPort getLocalAddress() const { return HostAddressPort(); }

+

+ void disconnect() {

+ disconnected = true;

+ onDisconnected(boost::optional<Connection::Error>());

+ }

+

+ void write(const SafeByteArray& d) {

+ append(dataWritten, d);

+ pending = true;

+ }

+

+ EventLoop* eventLoop;

+ boost::optional<HostAddressPort> hostAddressPort;

+ std::vector<HostAddressPort> failingPorts;

+ ByteArray dataWritten;

+ bool disconnected;

+ bool pending;

+ bool autoFinishConnect;

+ };

+

+ struct MockConnectionFactory : public ConnectionFactory {

+ MockConnectionFactory(EventLoop* eventLoop, bool autoFinishConnect = true) : eventLoop(eventLoop), autoFinishConnect(autoFinishConnect) {

+ }

+

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

+ boost::shared_ptr<MockConnection> connection = boost::make_shared<MockConnection>(failingPorts, eventLoop, autoFinishConnect);

+ connections.push_back(connection);

+ return connection;

+ }

+

+ EventLoop* eventLoop;

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

+ std::vector<HostAddressPort> failingPorts;

+ bool autoFinishConnect;

+ };

+

+ void readResponse(const std::string& response, boost::shared_ptr<MockConnection> connection) {

+ connection->pending = false;

+ boost::shared_ptr<SafeByteArray> data1 = boost::make_shared<SafeByteArray>(createSafeByteArray(

+ "HTTP/1.1 200 OK\r\n"

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

+ "Access-Control-Allow-Origin: *\r\n"

+ "Access-Control-Allow-Headers: Content-Type\r\n"

+ "Content-Length: "));

+ connection->onDataRead(data1);

+ boost::shared_ptr<SafeByteArray> data2 = boost::make_shared<SafeByteArray>(createSafeByteArray(boost::lexical_cast<std::string>(response.size())));

+ connection->onDataRead(data2);

+ boost::shared_ptr<SafeByteArray> data3 = boost::make_shared<SafeByteArray>(createSafeByteArray("\r\n\r\n"));

+ connection->onDataRead(data3);

+ boost::shared_ptr<SafeByteArray> data4 = boost::make_shared<SafeByteArray>(createSafeByteArray(response));

+ connection->onDataRead(data4);

+ }

+

+ std::string fullRequestFor(const std::string& data) {

+ std::string body = data;

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

+ boost::shared_ptr<BOSHConnectionFactory> factory;

+ int sessionStarted;

+ int sessionTerminated;

+

+};

+

+

+CPPUNIT_TEST_SUITE_REGISTRATION(BOSHConnectionPoolTest);

+/*

+ * Copyright (c) 2011 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#include <QA/Checker/IO.h>

+

+#include <cppunit/extensions/HelperMacros.h>

+#include <cppunit/extensions/TestFactoryRegistry.h>

+

+#include <boost/optional.hpp>

+#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/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(testReadiness_pending);

+ CPPUNIT_TEST(testReadiness_disconnect);

+ CPPUNIT_TEST(testReadiness_noSID);

+ CPPUNIT_TEST(testWrite_Receive);

+ CPPUNIT_TEST(testWrite_ReceiveTwice);

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

+ dataRead.clear();

+ }

+

+ void tearDown() {

+ eventLoop->processEvents();

+ delete connectionFactory;

+ delete eventLoop;

+ }

+

+ void testHeader() {

+ BOSHConnection::ref testling = createTestling();

+ testling->connect(HostAddressPort(HostAddress("127.0.0.1"), 5280));

+ eventLoop->processEvents();

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

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

+ "inactivity='30' "

+ "polling='5' "

+ "requests='2' "

+ "hold='1' "

+ "maxpause='120' "

+ "sid='MyShinySID' "

+ "ver='1.6' "

+ "from='wonderland.lit' "

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

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

+ CPPUNIT_ASSERT_EQUAL(std::string("MyShinySID"), sid);

+ CPPUNIT_ASSERT(testling->isReadyToSend());

+ }

+

+ void testReadiness_ok() {

+ BOSHConnection::ref testling = createTestling();

+ testling->connect(HostAddressPort(HostAddress("127.0.0.1"), 5280));

+ eventLoop->processEvents();

+ testling->setSID("blahhhhh");

+ CPPUNIT_ASSERT(testling->isReadyToSend());

+ }

+

+ void testReadiness_pending() {

+ BOSHConnection::ref testling = createTestling();

+ testling->connect(HostAddressPort(HostAddress("127.0.0.1"), 5280));

+ eventLoop->processEvents();

+ testling->setSID("mySID");

+ CPPUNIT_ASSERT(testling->isReadyToSend());

+ testling->write(createSafeByteArray("<mypayload/>"));

+ CPPUNIT_ASSERT(!testling->isReadyToSend());

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

+ CPPUNIT_ASSERT(testling->isReadyToSend());

+ }

+

+ void testReadiness_disconnect() {

+ BOSHConnection::ref testling = createTestling();

+ testling->connect(HostAddressPort(HostAddress("127.0.0.1"), 5280));

+ eventLoop->processEvents();

+ testling->setSID("mySID");

+ CPPUNIT_ASSERT(testling->isReadyToSend());

+ connectionFactory->connections[0]->onDisconnected(false);

+ CPPUNIT_ASSERT(!testling->isReadyToSend());

+ }

+

+

+ void testReadiness_noSID() {

+ BOSHConnection::ref testling = createTestling();

+ testling->connect(HostAddressPort(HostAddress("127.0.0.1"), 5280));

+ eventLoop->processEvents();

+ CPPUNIT_ASSERT(!testling->isReadyToSend());

+ }

+

+ void testWrite_Receive() {

+ BOSHConnection::ref testling = createTestling();

+ testling->connect(HostAddressPort(HostAddress("127.0.0.1"), 5280));

+ eventLoop->processEvents();

+ testling->setSID("mySID");

+ testling->write(createSafeByteArray("<mypayload/>"));

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

+ CPPUNIT_ASSERT_EQUAL(std::string("<blah/>"), byteArrayToString(dataRead));

+

+ }

+

+ void testWrite_ReceiveTwice() {

+ BOSHConnection::ref testling = createTestling();

+ testling->connect(HostAddressPort(HostAddress("127.0.0.1"), 5280));

+ eventLoop->processEvents();

+ testling->setSID("mySID");

+ testling->write(createSafeByteArray("<mypayload/>"));

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

+ CPPUNIT_ASSERT_EQUAL(std::string("<blah/>"), byteArrayToString(dataRead));

+ dataRead.clear();

+ testling->write(createSafeByteArray("<mypayload2/>"));

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

+ CPPUNIT_ASSERT_EQUAL(std::string("<bleh/>"), byteArrayToString(dataRead));

+ }

+

+ void testRead_Fragment() {

+ BOSHConnection::ref testling = createTestling();

+ testling->connect(HostAddressPort(HostAddress("127.0.0.1"), 5280));

+ eventLoop->processEvents();

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

+ boost::shared_ptr<MockConnection> connection = connectionFactory->connections[0];

+ boost::shared_ptr<SafeByteArray> data1 = boost::make_shared<SafeByteArray>(createSafeByteArray(

+ "HTTP/1.1 200 OK\r\n"

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

+ "Access-Control-Allow-Origin: *\r\n"

+ "Access-Control-Allow-Headers: Content-Type\r\n"

+ "Content-Length: 64\r\n"));

+ boost::shared_ptr<SafeByteArray> data2 = boost::make_shared<SafeByteArray>(createSafeByteArray(

+ "\r\n<body xmlns='http://jabber.org/protocol/httpbind'>"

+ "<bl"));

+ boost::shared_ptr<SafeByteArray> data3 = boost::make_shared<SafeByteArray>(createSafeByteArray(

+ "ah/>"

+ "</body>"));

+ connection->onDataRead(data1);

+ connection->onDataRead(data2);

+ CPPUNIT_ASSERT(dataRead.empty());

+ connection->onDataRead(data3);

+ CPPUNIT_ASSERT_EQUAL(std::string("<blah/>"), byteArrayToString(dataRead));

+ }

+

+ void testHTTPRequest() {

+ std::string data = "<blah/>";

+ std::string sid = "wigglebloom";

+ std::string fullBody = "<body xmlns='http://jabber.org/protocol/httpbind' sid='" + sid + "' rid='20'>" + data + "</body>";

+ std::pair<SafeByteArray, size_t> http = BOSHConnection::createHTTPRequest(createSafeByteArray(data), false, false, 20, sid, URL());

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

+ }

+

+ void testHTTPRequest_Empty() {

+ std::string data = "";

+ std::string sid = "wigglebloomsickle";

+ std::string fullBody = "<body rid='42' sid='" + sid + "' xmlns='http://jabber.org/protocol/httpbind'>" + data + "</body>";

+ std::pair<SafeByteArray, size_t> http = BOSHConnection::createHTTPRequest(createSafeByteArray(data), false, false, 42, sid, URL());

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

+ BOSHConnection::ref c = BOSHConnection::create(URL("http", "wonderland.lit", 5280, "http-bind"), connectionFactory, &parserFactory, static_cast<TLSContextFactory*>(NULL));

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

+ connectFinished = true;

+ connectFinishedWithError = error;

+ }

+

+ void handleDisconnected(const boost::optional<Connection::Error>& e) {

+ disconnected = true;

+ disconnectedError = e;

+ }

+

+ void handleDataRead(const SafeByteArray& d) {

+ append(dataRead, d);

+ }

+

+ void handleSID(const std::string& s) {

+ sid = s;

+ }

+

+ struct MockConnection : public Connection {

+ public:

+ MockConnection(const std::vector<HostAddressPort>& failingPorts, EventLoop* eventLoop) : eventLoop(eventLoop), failingPorts(failingPorts), disconnected(false) {

+ }

+

+ void listen() { assert(false); }

+

+ void connect(const HostAddressPort& address) {

+ hostAddressPort = address;

+ bool fail = std::find(failingPorts.begin(), failingPorts.end(), address) != failingPorts.end();

+ eventLoop->postEvent(boost::bind(boost::ref(onConnectFinished), fail));

+ }

+

+ HostAddressPort getLocalAddress() const { return HostAddressPort(); }

+

+ void disconnect() {

+ disconnected = true;

+ onDisconnected(boost::optional<Connection::Error>());

+ }

+

+ void write(const SafeByteArray& d) {

+ append(dataWritten, d);

+ }

+

+ EventLoop* eventLoop;

+ boost::optional<HostAddressPort> hostAddressPort;

+ std::vector<HostAddressPort> failingPorts;

+ ByteArray dataWritten;

+ bool disconnected;

+ };

+

+ struct MockConnectionFactory : public ConnectionFactory {

+ MockConnectionFactory(EventLoop* eventLoop) : eventLoop(eventLoop) {

+ }

+

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

+ boost::shared_ptr<MockConnection> connection = boost::make_shared<MockConnection>(failingPorts, eventLoop);

+ connections.push_back(connection);

+ return connection;

+ }

+

+ EventLoop* eventLoop;

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

+ std::vector<HostAddressPort> failingPorts;

+ };

+

+ void readResponse(const std::string& response, boost::shared_ptr<MockConnection> connection) {

+ boost::shared_ptr<SafeByteArray> data1 = boost::make_shared<SafeByteArray>(createSafeByteArray(

+ "HTTP/1.1 200 OK\r\n"

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

+ "Access-Control-Allow-Origin: *\r\n"

+ "Access-Control-Allow-Headers: Content-Type\r\n"

+ "Content-Length: "));

+ connection->onDataRead(data1);

+ boost::shared_ptr<SafeByteArray> data2 = boost::make_shared<SafeByteArray>(createSafeByteArray(boost::lexical_cast<std::string>(response.size())));

+ connection->onDataRead(data2);

+ boost::shared_ptr<SafeByteArray> data3 = boost::make_shared<SafeByteArray>(createSafeByteArray("\r\n\r\n"));

+ connection->onDataRead(data3);

+ boost::shared_ptr<SafeByteArray> data4 = boost::make_shared<SafeByteArray>(createSafeByteArray(response));

+ connection->onDataRead(data4);

+ }

+

+

+ private:

+ DummyEventLoop* eventLoop;

+ MockConnectionFactory* connectionFactory;

+ bool connectFinished;

+ bool connectFinishedWithError;

+ bool disconnected;

+ boost::optional<Connection::Error> disconnectedError;

+ ByteArray dataRead;

+ PlatformXMLParserFactory parserFactory;

+ std::string sid;

+

+};

+

+

+CPPUNIT_TEST_SUITE_REGISTRATION(BOSHConnectionTest);

+ boost::shared_ptr<HTTPConnectProxiedConnection> c = HTTPConnectProxiedConnection::create(connectionFactory, proxyHost, "", "");

+ /* TODO: This needs to be only validating the BOSH <body> element, so that XMPP parsing errors are caught at

+ the correct higher layer */

+ClientOptions options;

+ client->connect(options);

+ char* boshHost = getenv("SWIFT_CLIENTTEST_BOSH_HOST");

+ char* boshPort = getenv("SWIFT_CLIENTTEST_BOSH_PORT");

+ char* boshPath = getenv("SWIFT_CLIENTTEST_BOSH_PATH");

+

+ if (boshHost && boshPort && boshPath) {

+ std::cout << "Using BOSH with URL: http://" << boshHost << ":" << boshPort << "/" << boshPath << std::endl;

+ options.boshURL = URL("http", boshHost, atoi(boshPort), boshPath);

+ }

+

+ ClientXMLTracer* tracer = new ClientXMLTracer(client, !options.boshURL.empty());

+ client->connect(options);

+ "Session/BOSHSessionStream.cpp",

+ File("Network/UnitTest/BOSHConnectionTest.cpp"),

+ File("Network/UnitTest/BOSHConnectionPoolTest.cpp"),

+/*

+ * Copyright (c) 2011 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+

+#include <Swiften/Session/BOSHSessionStream.h>

+

+#include <boost/bind.hpp>

+#include <boost/random/mersenne_twister.hpp>

+#include <boost/random/uniform_int.hpp>

+#include <boost/random/variate_generator.hpp>

+

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

+#include <Swiften/Elements/StreamType.h>

+#include <Swiften/StreamStack/XMPPLayer.h>

+#include <Swiften/StreamStack/StreamStack.h>

+#include <Swiften/StreamStack/ConnectionLayer.h>

+#include <Swiften/StreamStack/WhitespacePingLayer.h>

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

+ boost::shared_ptr<BOSHConnectionFactory> connectionFactory, /*FIXME: probably rip out*/

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

+ boost::uniform_int<> dist(0, LONG_MAX);

+ random.seed(time(NULL));

+ boost::variate_generator<boost::mt19937&, boost::uniform_int<> > randomRID(random, dist);

+ long initialRID = randomRID();

+

+ connectionPool = new BOSHConnectionPool(connectionFactory, to, initialRID, boshHTTPConnectProxyURL, boshHTTPConnectProxyAuthID, boshHTTPConnectProxyAuthPassword);

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

+ xmppLayer->onError.connect(boost::bind(&BOSHSessionStream::handleXMPPError, this));

+ xmppLayer->onWriteData.connect(boost::bind(&BOSHSessionStream::handleXMPPLayerDataWritten, this, _1));

+

+ available = true;

+}

+

+BOSHSessionStream::~BOSHSessionStream() {

+ close();

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

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

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

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

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

+ delete connectionPool;

+ connectionPool = NULL;

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

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

+ xmppLayer->onError.disconnect(boost::bind(&BOSHSessionStream::handleXMPPError, this));

+ xmppLayer->onWriteData.disconnect(boost::bind(&BOSHSessionStream::handleXMPPLayerDataWritten, this, _1));

+ delete xmppLayer;

+ xmppLayer = NULL;

+}

+

+void BOSHSessionStream::handlePoolXMPPDataRead(const SafeByteArray& data) {

+ xmppLayer->handleDataRead(data);

+}

+

+void BOSHSessionStream::writeElement(boost::shared_ptr<Element> element) {

+ assert(available);

+ xmppLayer->writeElement(element);

+}

+

+void BOSHSessionStream::writeFooter() {

+ connectionPool->writeFooter();

+}

+

+void BOSHSessionStream::writeData(const std::string& data) {

+ assert(available);

+ xmppLayer->writeData(data);

+}

+

+void BOSHSessionStream::close() {

+ connectionPool->close();

+}

+

+bool BOSHSessionStream::isOpen() {

+ return available;

+}

+

+bool BOSHSessionStream::supportsTLSEncryption() {

+ return false;

+}

+

+void BOSHSessionStream::addTLSEncryption() {

+ assert(available);

+}

+

+bool BOSHSessionStream::isTLSEncrypted() {

+ return false;

+}

+

+Certificate::ref BOSHSessionStream::getPeerCertificate() const {

+ return Certificate::ref();

+}

+

+boost::shared_ptr<CertificateVerificationError> BOSHSessionStream::getPeerCertificateVerificationError() const {

+ return boost::shared_ptr<CertificateVerificationError>();

+}

+

+ByteArray BOSHSessionStream::getTLSFinishMessage() const {

+ return ByteArray();

+}

+

+bool BOSHSessionStream::supportsZLibCompression() {

+ return false;

+}

+

+void BOSHSessionStream::addZLibCompression() {

+

+}

+

+void BOSHSessionStream::setWhitespacePingEnabled(bool /*enabled*/) {

+ return;

+}

+

+void BOSHSessionStream::resetXMPPParser() {

+ xmppLayer->resetParser();

+}

+

+void BOSHSessionStream::handleStreamStartReceived(const ProtocolHeader& header) {

+ onStreamStartReceived(header);

+}

+

+void BOSHSessionStream::handleElementReceived(boost::shared_ptr<Element> element) {

+ onElementReceived(element);

+}

+

+void BOSHSessionStream::handleXMPPError() {

+ available = false;

+ onClosed(boost::shared_ptr<Error>(new Error(Error::ParseError)));

+}

+

+void BOSHSessionStream::handlePoolSessionStarted() {

+ fakeStreamHeaderReceipt();

+}

+

+void BOSHSessionStream::handlePoolSessionTerminated(BOSHError::ref error) {

+ eventLoop->postEvent(boost::bind(&BOSHSessionStream::fakeStreamFooterReceipt, this, error), shared_from_this());

+}

+

+void BOSHSessionStream::writeHeader(const ProtocolHeader& header) {

+ streamHeader = header;

+ /*First time we're told to do this, don't (the sending of the initial header is handled on connect)

+ On subsequent requests we should restart the stream the BOSH way.

+ */

+ if (!firstHeader) {

+ eventLoop->postEvent(boost::bind(&BOSHSessionStream::fakeStreamHeaderReceipt, this), shared_from_this());

+ eventLoop->postEvent(boost::bind(&BOSHConnectionPool::restartStream, connectionPool), shared_from_this());

+ }

+ firstHeader = false;

+}

+

+

+void BOSHSessionStream::fakeStreamHeaderReceipt() {

+ std::stringstream header;

+ header << "<stream:stream xmlns='jabber:client' xmlns:stream='http://etherx.jabber.org/streams' from='";

+ header << streamHeader.getTo() << "' id='dummy' version='1.0'>";

+

+ xmppLayer->handleDataRead(createSafeByteArray(header.str()));

+}

+

+void BOSHSessionStream::fakeStreamFooterReceipt(BOSHError::ref error) {

+ std::string footer("</stream:stream>");

+ xmppLayer->handleDataRead(createSafeByteArray(footer));

+ onClosed(error);

+}

+

+void BOSHSessionStream::handleXMPPLayerDataWritten(const SafeByteArray& data) {

+ eventLoop->postEvent(boost::bind(&BOSHConnectionPool::write, connectionPool, data), shared_from_this());

+}

+

+void BOSHSessionStream::handlePoolBOSHDataRead(const SafeByteArray& data) {

+ onDataRead(data);

+}

+

+void BOSHSessionStream::handlePoolBOSHDataWritten(const SafeByteArray& data) {

+ onDataWritten(data);

+}

+

+};

+/*

+ * Copyright (c) 2011 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

+#include <boost/shared_ptr.hpp>

+

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

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

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

+#include <Swiften/Network/BOSHConnectionFactory.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 XMPPLayer;

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

+ boost::shared_ptr<BOSHConnectionFactory> connectionFactory,

+ PayloadParserFactoryCollection* payloadParserFactories,

+ PayloadSerializerCollection* payloadSerializers,

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

+

+ virtual void writeHeader(const ProtocolHeader& header);

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

+ virtual void writeFooter();

+ virtual void writeData(const std::string& data);

+

+ virtual bool supportsZLibCompression();

+ virtual void addZLibCompression();

+

+ virtual bool supportsTLSEncryption();

+ virtual void addTLSEncryption();

+ virtual bool isTLSEncrypted();

+ virtual Certificate::ref getPeerCertificate() const;

+ virtual boost::shared_ptr<CertificateVerificationError> getPeerCertificateVerificationError() const;

+ virtual ByteArray getTLSFinishMessage() const;

+

+ virtual void setWhitespacePingEnabled(bool);

+

+ virtual void resetXMPPParser();

+

+ private:

+ void handleXMPPError();

+ void handleStreamStartReceived(const ProtocolHeader&);

+ void handleElementReceived(boost::shared_ptr<Element>);

+ void handlePoolXMPPDataRead(const SafeByteArray& data);

+ void handleXMPPLayerDataWritten(const SafeByteArray& data);

+ void handlePoolSessionStarted();

+ void handlePoolBOSHDataRead(const SafeByteArray& data);

+ void handlePoolBOSHDataWritten(const SafeByteArray& data);

+ void handlePoolSessionTerminated(BOSHError::ref condition);

+

+ private:

+ void fakeStreamHeaderReceipt();

+ void fakeStreamFooterReceipt(BOSHError::ref error);

+

+ private:

+ BOSHConnectionPool* connectionPool;

+ bool available;

+ PayloadParserFactoryCollection* payloadParserFactories;

+ PayloadSerializerCollection* payloadSerializers;

+ TLSContextFactory* tlsContextFactory;

+ TimerFactory* timerFactory;

+ XMLParserFactory* xmlParserFactory;

+ XMPPLayer* xmppLayer;

+ ProtocolHeader streamHeader;

+ EventLoop* eventLoop;

+ bool firstHeader;

+ };

+

+}

+bool BasicSessionStream::supportsZLibCompression() {

+ return true;

+}

+

+ virtual bool supportsZLibCompression();

+ virtual bool supportsZLibCompression() = 0;

+ class BOSHSessionStream;

+ friend class BOSHSessionStream;