+ * Copyright (c) 2011-2019 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+#include <string>

+#include <thread>

+

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

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

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

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

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

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

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

+BOSHConnection::BOSHConnection(const URL& boshURL, Connector::ref connector, XMLParserFactory* parserFactory, TLSContextFactory* tlsContextFactory, const TLSOptions& tlsOptions)

+ : boshURL_(boshURL),

+ connector_(connector),

+ parserFactory_(parserFactory),

+ sid_(),

+ waitingForStartResponse_(false),

+ rid_(~0ULL),

+ pending_(false),

+ connectionReady_(false)

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

+ auto tlsContext = tlsContextFactory->createTLSContext(tlsOptions);

+ tlsLayer_ = std::make_shared<TLSLayer>(std::move(tlsContext));

+ // The following dummyLayer_ is needed as the TLSLayer will pass the decrypted data to its parent layer.

+ // The dummyLayer_ will serve as the parent layer.

+ dummyLayer_ = std::make_shared<DummyStreamLayer>(tlsLayer_.get());

+ }

+ cancelConnector();

+ if (connection_) {

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

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

+ }

+ BOSHConnection::disconnect();

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

+ connector_->start();

+ if (connector_) {

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

+ connector_->stop();

+ connector_.reset();

+ }

+}

+

+void BOSHConnection::handleTLSConnected() {

+ SWIFT_LOG(debug);

+ onConnectFinished(false);

+}

+

+void BOSHConnection::handleTLSApplicationDataRead(const SafeByteArray& data) {

+ SWIFT_LOG(debug);

+ handleDataRead(std::make_shared<SafeByteArray>(data));

+}

+

+void BOSHConnection::handleTLSNetowrkDataWriteRequest(const SafeByteArray& data) {

+ SWIFT_LOG(debug);

+ connection_->write(data);

+}

+

+void BOSHConnection::handleRawDataRead(std::shared_ptr<SafeByteArray> data) {

+ SWIFT_LOG(debug);

+ tlsLayer_->handleDataRead(*data.get());

+}

+

+void BOSHConnection::handleTLSError(std::shared_ptr<TLSError> error) {

+ SWIFT_LOG(debug) << (error ? error->getMessage() : "Unknown TLS error");

+}

+

+void BOSHConnection::writeData(const SafeByteArray& data) {

+ if (tlsLayer_) {

+ tlsLayer_->writeData(data);

+ }

+ else {

+ connection_->write(data);

+ }

+ if (connection_) {

+ connection_->disconnect();

+ sid_ = "";

+ }

+ else {

+ /* handleDisconnected takes care of the connector_ as well */

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

+ }

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

+}

+

+bool BOSHConnection::setClientCertificate(CertificateWithKey::ref cert) {

+ if (tlsLayer_) {

+ SWIFT_LOG(debug) << "set client certificate";

+ return tlsLayer_->setClientCertificate(cert);

+ }

+ else {

+ return false;

+ }

+}

+

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

+ Certificate::ref peerCertificate;

+ if (tlsLayer_) {

+ peerCertificate = tlsLayer_->getPeerCertificate();

+ }

+ return peerCertificate;

+}

+

+std::vector<Certificate::ref> BOSHConnection::getPeerCertificateChain() const {

+ std::vector<Certificate::ref> peerCertificateChain;

+ if (tlsLayer_) {

+ peerCertificateChain = tlsLayer_->getPeerCertificateChain();

+ }

+ return peerCertificateChain;

+}

+

+CertificateVerificationError::ref BOSHConnection::getPeerCertificateVerificationError() const {

+ CertificateVerificationError::ref verificationError;

+ if (tlsLayer_) {

+ verificationError = tlsLayer_->getPeerCertificateVerificationError();

+ }

+ return verificationError;

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

+ write(data, false, false);

+ size_t size;

+ std::stringstream content;

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

+ std::stringstream header;

+

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

+ if (streamRestart) {

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

+ }

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

+ if (boshURL.getPort()) {

+ header << ":" << *boshURL.getPort();

+ }

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

+ assert(connectionReady_);

+ assert(!sid_.empty());

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

+ onBOSHDataWritten(safeHeader);

+ writeData(safeHeader);

+ pending_ = true;

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

+ cancelConnector();

+ connectionReady_ = !!connection;

+ if (connectionReady_) {

+ connection_ = connection;

+ if (tlsLayer_) {

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

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

+

+ tlsLayer_->getContext()->onDataForNetwork.connect(boost::bind(&BOSHConnection::handleTLSNetowrkDataWriteRequest, shared_from_this(), _1));

+ tlsLayer_->getContext()->onDataForApplication.connect(boost::bind(&BOSHConnection::handleTLSApplicationDataRead, shared_from_this(), _1));

+ tlsLayer_->onConnected.connect(boost::bind(&BOSHConnection::handleTLSConnected, shared_from_this()));

+ tlsLayer_->onError.connect(boost::bind(&BOSHConnection::handleTLSError, shared_from_this(), _1));

+ tlsLayer_->connect();

+ }

+ else {

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

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

+ }

+ }

+

+ if (!connectionReady_ || !tlsLayer_) {

+ onConnectFinished(!connectionReady_);

+ }

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

+ if (boshURL_.getPort()) {

+ header << ":" << *boshURL_.getPort();

+ }

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

+ writeData(safeHeader);

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

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

+ onBOSHDataRead(*data);

+ buffer_ = concat(buffer_, *data);

+ 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 ? std::shared_ptr<BOSHError>() : std::make_shared<BOSHError>(errorType));

+ return;

+ }

+ buffer_.clear();

+ if (waitingForStartResponse_) {

+ waitingForStartResponse_ = false;

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

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

+ size_t requests = 2;

+ if (!requestsString.empty()) {

+ try {

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

+ }

+ catch (const boost::bad_lexical_cast&) {

+ }

+ }

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

+ return sid_;

+ rid_ = rid;

+ sid_ = sid;

+ cancelConnector();

+ onDisconnected(error ? true : false);

+ sid_ = "";

+ connectionReady_ = false;

+ /* 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-2017 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+#include <memory>

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

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

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

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

+ class XMLParserFactory;

+ class TLSContextFactory;

+ class TLSLayer;

+ class TLSOptions;

+ class HighLayer;

+

+ class SWIFTEN_API BOSHError : public SessionStream::SessionStreamError {

+ public:

+ enum Type {

+ BadRequest, HostGone, HostUnknown, ImproperAddressing,

+ InternalServerError, ItemNotFound, OtherRequest, PolicyViolation,

+ RemoteConnectionFailed, RemoteStreamError, SeeOtherURI, SystemShutdown, UndefinedCondition,

+ NoError};

+

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

+ Type getType() const {return type;}

+ typedef std::shared_ptr<BOSHError> ref;

+

+ private:

+ Type type;

+ };

+

+ class SWIFTEN_API BOSHConnection : public std::enable_shared_from_this<BOSHConnection> {

+ public:

+ typedef std::shared_ptr<BOSHConnection> ref;

+ static ref create(const URL& boshURL, Connector::ref connector, XMLParserFactory* parserFactory, TLSContextFactory* tlsContextFactory, const TLSOptions& tlsOptions) {

+ return ref(new BOSHConnection(boshURL, connector, parserFactory, tlsContextFactory, tlsOptions));

+ }

+ virtual ~BOSHConnection();

+ virtual void connect();

+ virtual void disconnect();

+ virtual void write(const SafeByteArray& data);

+

+ const std::string& getSID();

+ void setRID(unsigned long long rid);

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

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

+ void terminateStream();

+ bool isReadyToSend();

+ void restartStream();

+

+ bool setClientCertificate(CertificateWithKey::ref cert);

+ Certificate::ref getPeerCertificate() const;

+ std::vector<Certificate::ref> getPeerCertificateChain() const;

+ CertificateVerificationError::ref getPeerCertificateVerificationError() const;

+

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

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

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

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

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

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

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

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

+

+ private:

+ friend class ::BOSHConnectionTest;

+

+ BOSHConnection(const URL& boshURL, Connector::ref connector, XMLParserFactory* parserFactory, TLSContextFactory* tlsContextFactory, const TLSOptions& tlsOptions);

+

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

+ void handleConnectFinished(Connection::ref);

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

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

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

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

+ void cancelConnector();

+

+ void handleTLSConnected();

+ void handleTLSApplicationDataRead(const SafeByteArray& data);

+ void handleTLSNetowrkDataWriteRequest(const SafeByteArray& data);

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

+ void handleTLSError(std::shared_ptr<TLSError> error);

+ void writeData(const SafeByteArray& data);

+

+ URL boshURL_;

+ Connector::ref connector_;

+ XMLParserFactory* parserFactory_;

+ std::shared_ptr<Connection> connection_;

+ std::shared_ptr<HighLayer> dummyLayer_;

+ std::shared_ptr<TLSLayer> tlsLayer_;

+ std::string sid_;

+ bool waitingForStartResponse_;

+ unsigned long long rid_;

+ SafeByteArray buffer_;

+ bool pending_;

+ bool connectionReady_;

+ };

+ * Copyright (c) 2011-2019 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

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

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

+BOSHConnectionPool::BOSHConnectionPool(const URL& boshURL, DomainNameResolver* realResolver, ConnectionFactory* connectionFactoryParameter, XMLParserFactory* parserFactory, TLSContextFactory* tlsFactory, TimerFactory* timerFactory, EventLoop* eventLoop, const std::string& to, unsigned long long initialRID, const URL& boshHTTPConnectProxyURL, const SafeString& boshHTTPConnectProxyAuthID, const SafeString& boshHTTPConnectProxyAuthPassword, const TLSOptions& tlsOptions, std::shared_ptr<HTTPTrafficFilter> trafficFilter) :

+ boshURL(boshURL),

+ connectionFactory(connectionFactoryParameter),

+ xmlParserFactory(parserFactory),

+ timerFactory(timerFactory),

+ rid(initialRID),

+ pendingTerminate(false),

+ to(to),

+ requestLimit(2),

+ restartCount(0),

+ pendingRestart(false),

+ tlsContextFactory_(tlsFactory),

+ tlsOptions_(tlsOptions) {

+

+ if (!boshHTTPConnectProxyURL.isEmpty()) {

+ connectionFactory = new HTTPConnectProxiedConnectionFactory(realResolver, connectionFactory, timerFactory, boshHTTPConnectProxyURL.getHost(), URL::getPortOrDefaultPort(boshHTTPConnectProxyURL), boshHTTPConnectProxyAuthID, boshHTTPConnectProxyAuthPassword, trafficFilter);

+ }

+ resolver = new CachingDomainNameResolver(realResolver, eventLoop);

+ /* Don't do a normal close here. Instead kill things forcibly, as close() or writeFooter() will already have been called */

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

+ for (auto&& connection : connectionCopies) {

+ if (connection) {

+ destroyConnection(connection);

+ connection->disconnect();

+ }

+ }

+ for (auto factory : myConnectionFactories) {

+ delete factory;

+ }

+ delete resolver;

+ dataQueue.push_back(data);

+ tryToSendQueuedData();

+ onXMPPDataRead(data);

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

+ BOSHConnection::ref connection = getSuitableConnection();

+ if (connection) {

+ pendingRestart = false;

+ rid++;

+ connection->setRID(rid);

+ connection->restartStream();

+ restartCount++;

+ }

+ else {

+ pendingRestart = true;

+ }

+}

+

+void BOSHConnectionPool::setTLSCertificate(CertificateWithKey::ref certWithKey) {

+ clientCertificate = certWithKey;

+}

+

+bool BOSHConnectionPool::isTLSEncrypted() const {

+ return !pinnedCertificateChain_.empty();

+}

+

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

+ Certificate::ref peerCertificate;

+ if (!pinnedCertificateChain_.empty()) {

+ peerCertificate = pinnedCertificateChain_[0];

+ }

+ return peerCertificate;

+}

+

+std::vector<Certificate::ref> BOSHConnectionPool::getPeerCertificateChain() const {

+ return pinnedCertificateChain_;

+}

+

+std::shared_ptr<CertificateVerificationError> BOSHConnectionPool::getPeerCertificateVerificationError() const {

+ return lastVerificationError_;

+ pendingTerminate = true;

+ tryToSendQueuedData();

+}

+

+void BOSHConnectionPool::open() {

+ createConnection();

+ if (!sid.empty()) {

+ writeFooter();

+ }

+ else {

+ pendingTerminate = true;

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

+ for (auto&& connection : connectionCopies) {

+ if (connection) {

+ connection->disconnect();

+ }

+ }

+ }

+ sid = sessionID;

+ requestLimit = requests;

+ onSessionStarted();

+ if (error) {

+ onSessionTerminated(std::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 (connection->getPeerCertificate() && pinnedCertificateChain_.empty()) {

+ pinnedCertificateChain_ = connection->getPeerCertificateChain();

+ }

+ if (!pinnedCertificateChain_.empty()) {

+ lastVerificationError_ = connection->getPeerCertificateVerificationError();

+ onTLSConnectionEstablished();

+ }

+

+ if (sid.empty()) {

+ connection->startStream(to, rid);

+ }

+ if (pendingRestart) {

+ restartStream();

+ }

+ tryToSendQueuedData();

+ }

+ BOSHConnection::ref suitableConnection;

+ for (auto&& 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;

+ if (sid.empty()) {

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

+ return;

+ }

+

+ BOSHConnection::ref suitableConnection = getSuitableConnection();

+ bool toSend = !dataQueue.empty();

+ if (suitableConnection) {

+ if (toSend) {

+ rid++;

+ suitableConnection->setRID(rid);

+ SafeByteArray data;

+ for (const auto& datum : dataQueue) {

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

+ }

+ suitableConnection->write(data);

+ dataQueue.clear();

+ }

+ else if (pendingTerminate) {

+ rid++;

+ suitableConnection->setRID(rid);

+ suitableConnection->terminateStream();

+ sid = "";

+ close();

+ }

+ }

+ if (!pendingTerminate) {

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

+ bool pending = false;

+ for (auto&& 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. */

+ }

+ }

+ }

+ }

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

+ destroyConnection(connection);

+ if (pendingTerminate && sid.empty() && connections.empty()) {

+ handleSessionTerminated(BOSHError::ref());

+ }

+ //else if (error) {

+ // handleSessionTerminated(std::make_shared<BOSHError>(BOSHError::UndefinedCondition));

+ //}

+ else {

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

+ tryToSendQueuedData();

+ }

+std::shared_ptr<BOSHConnection> BOSHConnectionPool::createConnection() {

+ Connector::ref connector = Connector::create(boshURL.getHost(), URL::getPortOrDefaultPort(boshURL), boost::optional<std::string>(), resolver, connectionFactory, timerFactory);

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

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

+

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

+ bool success = connection->setClientCertificate(clientCertificate);

+ SWIFT_LOG(debug) << "setClientCertificate, success: " << success;

+ }

+

+ connection->connect();

+ connections.push_back(connection);

+ return connection;

+void BOSHConnectionPool::destroyConnection(std::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));

+ onSessionTerminated(error);

+ onBOSHDataRead(data);

+ onBOSHDataWritten(data);

+ * Copyright (c) 2011-2017 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

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

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

+ class CachingDomainNameResolver;

+ class EventLoop;

+ class HTTPTrafficFilter;

+ class TLSContextFactory;

+ class CachingDomainNameResolver;

+ class EventLoop;

+ class SWIFTEN_API BOSHConnectionPool : public boost::signals2::trackable {

+ public:

+ BOSHConnectionPool(const URL& boshURL, DomainNameResolver* resolver, ConnectionFactory* connectionFactory, XMLParserFactory* parserFactory, TLSContextFactory* tlsFactory, TimerFactory* timerFactory, EventLoop* eventLoop, const std::string& to, unsigned long long initialRID, const URL& boshHTTPConnectProxyURL, const SafeString& boshHTTPConnectProxyAuthID, const SafeString& boshHTTPConnectProxyAuthPassword, const TLSOptions& tlsOptions, std::shared_ptr<HTTPTrafficFilter> trafficFilter = std::shared_ptr<HTTPTrafficFilter>());

+ ~BOSHConnectionPool();

+ void open();

+ void write(const SafeByteArray& data);

+ void writeFooter();

+ void close();

+ void restartStream();

+ void setTLSCertificate(CertificateWithKey::ref certWithKey);

+ bool isTLSEncrypted() const;

+ Certificate::ref getPeerCertificate() const;

+ std::vector<Certificate::ref> getPeerCertificateChain() const;

+ std::shared_ptr<CertificateVerificationError> getPeerCertificateVerificationError() const;

+ boost::signals2::signal<void ()> onTLSConnectionEstablished;

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

+ boost::signals2::signal<void ()> onSessionStarted;

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

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

+ boost::signals2::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(bool 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:

+ URL boshURL;

+ ConnectionFactory* connectionFactory;

+ XMLParserFactory* xmlParserFactory;

+ TimerFactory* timerFactory;

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

+ std::string sid;

+ unsigned long long rid;

+ std::vector<SafeByteArray> dataQueue;

+ bool pendingTerminate;

+ std::string to;

+ size_t requestLimit;

+ int restartCount;

+ bool pendingRestart;

+ std::vector<ConnectionFactory*> myConnectionFactories;

+ CachingDomainNameResolver* resolver;

+ CertificateWithKey::ref clientCertificate;

+ TLSContextFactory* tlsContextFactory_;

+ TLSOptions tlsOptions_;

+ std::vector<std::shared_ptr<Certificate> > pinnedCertificateChain_;

+ std::shared_ptr<CertificateVerificationError> lastVerificationError_;

+ };

+ * Copyright (c) 2010-2019 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+#include <memory>

+#include <mutex>

+#include <string>

+

+#include <boost/bind.hpp>

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

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

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

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

+ public:

+ SharedBuffer(const SafeByteArray& data) :

+ data_(new std::vector<char, SafeAllocator<char> >(data.begin(), data.end())),

+ buffer_(boost::asio::buffer(*data_)) {

+ }

+

+ // ConstBufferSequence requirements.

+ typedef boost::asio::const_buffer value_type;

+ typedef const boost::asio::const_buffer* const_iterator;

+ const boost::asio::const_buffer* begin() const { return &buffer_; }

+ const boost::asio::const_buffer* end() const { return &buffer_ + 1; }

+

+ private:

+ std::shared_ptr< std::vector<char, SafeAllocator<char> > > data_;

+ boost::asio::const_buffer buffer_;

+BoostConnection::BoostConnection(std::shared_ptr<boost::asio::io_service> ioService, EventLoop* eventLoop) :

+ eventLoop(eventLoop), ioService(ioService), socket_(*ioService), writing_(false), closeSocketAfterNextWrite_(false) {

+ doRead();

+ boost::asio::ip::tcp::endpoint endpoint(

+ boost::asio::ip::address::from_string(addressPort.getAddress().toString()), addressPort.getPort());

+ socket_.async_connect(

+ endpoint,

+ boost::bind(&BoostConnection::handleConnectFinished, shared_from_this(), boost::asio::placeholders::error));

+ //MainEventLoop::removeEventsFromOwner(shared_from_this());

+

+ // Mac OS X apparently exhibits a problem where closing a socket during a write could potentially go into uninterruptable sleep.

+ // See e.g. http://bugs.python.org/issue7401

+ // We therefore wait until any pending write finishes, which hopefully should fix our hang on exit during close().

+ std::lock_guard<std::mutex> lock(writeMutex_);

+ if (writing_) {

+ closeSocketAfterNextWrite_ = true;

+ } else {

+ closeSocket();

+ }

+ std::lock_guard<std::mutex> lock(readCloseMutex_);

+ boost::system::error_code errorCode;

+ socket_.shutdown(boost::asio::ip::tcp::socket::shutdown_both, errorCode);

+ socket_.close();

+ std::lock_guard<std::mutex> lock(writeMutex_);

+ if (!writing_) {

+ writing_ = true;

+ doWrite(data);

+ }

+ else {

+ append(writeQueue_, data);

+ }

+ boost::asio::async_write(socket_, SharedBuffer(data),

+ boost::bind(&BoostConnection::handleDataWritten, shared_from_this(), boost::asio::placeholders::error));

+ SWIFT_LOG(debug) << "Connect finished: " << error;

+ if (!error) {

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

+ doRead();

+ }

+ else if (error != boost::asio::error::operation_aborted) {

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

+ }

+ readBuffer_ = std::make_shared<SafeByteArray>(BUFFER_SIZE);

+ std::lock_guard<std::mutex> lock(readCloseMutex_);

+ socket_.async_read_some(

+ boost::asio::buffer(*readBuffer_),

+ boost::bind(&BoostConnection::handleSocketRead, shared_from_this(), boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred));

+ SWIFT_LOG(debug) << "Socket read " << error;

+ if (!error) {

+ readBuffer_->resize(bytesTransferred);

+ eventLoop->postEvent(boost::bind(boost::ref(onDataRead), readBuffer_), shared_from_this());

+ doRead();

+ }

+ else if (/*error == boost::asio::error::eof ||*/ error == boost::asio::error::operation_aborted) {

+ eventLoop->postEvent(boost::bind(boost::ref(onDisconnected), boost::optional<Error>()), shared_from_this());

+ }

+ else {

+ eventLoop->postEvent(boost::bind(boost::ref(onDisconnected), ReadError), shared_from_this());

+ }

+ SWIFT_LOG(debug) << "Data written " << error;

+ if (!error) {

+ eventLoop->postEvent(boost::ref(onDataWritten), shared_from_this());

+ }

+ else if (/*error == boost::asio::error::eof || */error == boost::asio::error::operation_aborted) {

+ eventLoop->postEvent(boost::bind(boost::ref(onDisconnected), boost::optional<Error>()), shared_from_this());

+ }

+ else {

+ eventLoop->postEvent(boost::bind(boost::ref(onDisconnected), WriteError), shared_from_this());

+ }

+ {

+ std::lock_guard<std::mutex> lock(writeMutex_);

+ if (writeQueue_.empty()) {

+ writing_ = false;

+ if (closeSocketAfterNextWrite_) {

+ closeSocket();

+ }

+ }

+ else {

+ doWrite(writeQueue_);

+ writeQueue_.clear();

+ }

+ }

+ return HostAddressPort(socket_.local_endpoint());

+}

+

+HostAddressPort BoostConnection::getRemoteAddress() const {

+ return HostAddressPort(socket_.remote_endpoint());

+ * Copyright (c) 2010-2017 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+#include <memory>

+#include <mutex>

+

+#include <Swiften/EventLoop/EventOwner.h>

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

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

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

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

+ class EventLoop;

+

+ class SWIFTEN_API BoostConnection : public Connection, public EventOwner, public std::enable_shared_from_this<BoostConnection> {

+ public:

+ typedef std::shared_ptr<BoostConnection> ref;

+

+ virtual ~BoostConnection();

+

+ static ref create(std::shared_ptr<boost::asio::io_service> ioService, EventLoop* eventLoop) {

+ return ref(new BoostConnection(ioService, eventLoop));

+ }

+

+ virtual void listen();

+ virtual void connect(const HostAddressPort& address);

+ virtual void disconnect();

+ virtual void write(const SafeByteArray& data);

+

+ boost::asio::ip::tcp::socket& getSocket() {

+ return socket_;

+ }

+

+ virtual HostAddressPort getLocalAddress() const;

+ virtual HostAddressPort getRemoteAddress() const;

+

+ bool setClientCertificate(CertificateWithKey::ref cert);

+

+ Certificate::ref getPeerCertificate() const;

+ std::vector<Certificate::ref> getPeerCertificateChain() const;

+ std::shared_ptr<CertificateVerificationError> getPeerCertificateVerificationError() const;

+

+ private:

+ BoostConnection(std::shared_ptr<boost::asio::io_service> ioService, EventLoop* eventLoop);

+

+ void handleConnectFinished(const boost::system::error_code& error);

+ void handleSocketRead(const boost::system::error_code& error, size_t bytesTransferred);

+ void handleDataWritten(const boost::system::error_code& error);

+ void doRead();

+ void doWrite(const SafeByteArray& data);

+ void closeSocket();

+

+ private:

+ EventLoop* eventLoop;

+ std::shared_ptr<boost::asio::io_service> ioService;

+ boost::asio::ip::tcp::socket socket_;

+ std::shared_ptr<SafeByteArray> readBuffer_;

+ std::mutex writeMutex_;

+ bool writing_;

+ SafeByteArray writeQueue_;

+ bool closeSocketAfterNextWrite_;

+ std::mutex readCloseMutex_;

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+

+BoostConnectionFactory::BoostConnectionFactory(std::shared_ptr<boost::asio::io_service> ioService, EventLoop* eventLoop) : ioService(ioService), eventLoop(eventLoop) {

+std::shared_ptr<Connection> BoostConnectionFactory::createConnection() {

+ return BoostConnection::create(ioService, eventLoop);

+ * Copyright (c) 2010-2017 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

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

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

+ class SWIFTEN_API BoostConnectionFactory : public ConnectionFactory {

+ public:

+ BoostConnectionFactory(std::shared_ptr<boost::asio::io_service>, EventLoop* eventLoop);

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

+ private:

+ std::shared_ptr<boost::asio::io_service> ioService;

+ EventLoop* eventLoop;

+ };

+ * Copyright (c) 2010-2019 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+#include <boost/asio/ip/v6_only.hpp>

+#include <boost/bind.hpp>

+#include <boost/system/error_code.hpp>

+#include <boost/system/system_error.hpp>

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

+BoostConnectionServer::BoostConnectionServer(unsigned short port, std::shared_ptr<boost::asio::io_service> ioService, EventLoop* eventLoop) : port_(port), ioService_(ioService), eventLoop(eventLoop), acceptor_(nullptr) {

+BoostConnectionServer::BoostConnectionServer(const HostAddress &address, unsigned short port, std::shared_ptr<boost::asio::io_service> ioService, EventLoop* eventLoop) : address_(address), port_(port), ioService_(ioService), eventLoop(eventLoop), acceptor_(nullptr) {

+ boost::optional<Error> error = tryStart();

+ if (error) {

+ eventLoop->postEvent(boost::bind(boost::ref(onStopped), *error), shared_from_this());

+ }

+ try {

+ assert(!acceptor_);

+ boost::asio::ip::tcp::endpoint endpoint;

+ if (address_.isValid()) {

+ endpoint = boost::asio::ip::tcp::endpoint(address_.getRawAddress(), port_);

+ }

+ else {

+ endpoint = boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v6(), port_);

+ }

+ acceptor_ = new boost::asio::ip::tcp::acceptor(*ioService_, endpoint);

+ if (endpoint.protocol() == boost::asio::ip::tcp::v6()) {

+ boost::system::error_code ec;

+ acceptor_->set_option(boost::asio::ip::v6_only(false), ec);

+ SWIFT_LOG_ASSERT(ec, warning) << "IPv4/IPv6 dual-stack support is not supported on this platform.";

+ }

+ acceptNextConnection();

+ }

+ catch (const boost::system::system_error& e) {

+ if (e.code() == boost::asio::error::address_in_use) {

+ return Conflict;

+ }

+ else {

+ return UnknownError;

+ }

+ }

+ catch (const boost::numeric::bad_numeric_cast&) {

+ return UnknownError;

+ }

+ return boost::optional<Error>();

+ stop(boost::optional<Error>());

+ if (acceptor_) {

+ acceptor_->close();

+ delete acceptor_;

+ acceptor_ = nullptr;

+ }

+ eventLoop->postEvent(boost::bind(boost::ref(onStopped), e), shared_from_this());

+ BoostConnection::ref newConnection(BoostConnection::create(ioService_, eventLoop));

+ acceptor_->async_accept(newConnection->getSocket(),

+ boost::bind(&BoostConnectionServer::handleAccept, shared_from_this(), newConnection, boost::asio::placeholders::error));

+void BoostConnectionServer::handleAccept(std::shared_ptr<BoostConnection> newConnection, const boost::system::error_code& error) {

+ if (error) {

+ eventLoop->postEvent(

+ boost::bind(

+ &BoostConnectionServer::stop, shared_from_this(), UnknownError),

+ shared_from_this());

+ }

+ else {

+ eventLoop->postEvent(

+ boost::bind(boost::ref(onNewConnection), newConnection),

+ shared_from_this());

+ newConnection->listen();

+ acceptNextConnection();

+ }

+ if (acceptor_) {

+ return HostAddressPort(acceptor_->local_endpoint());

+ }

+ else {

+ return HostAddressPort();

+ }

+ * Copyright (c) 2010-2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+#include <memory>

+

+#include <boost/optional/optional.hpp>

+#include <boost/signals2.hpp>

+#include <Swiften/EventLoop/EventOwner.h>

+ class SWIFTEN_API BoostConnectionServer : public ConnectionServer, public EventOwner, public std::enable_shared_from_this<BoostConnectionServer> {

+ public:

+ typedef std::shared_ptr<BoostConnectionServer> ref;

+ static ref create(unsigned short port, std::shared_ptr<boost::asio::io_service> ioService, EventLoop* eventLoop) {

+ return ref(new BoostConnectionServer(port, ioService, eventLoop));

+ }

+ static ref create(const HostAddress &address, unsigned short port, std::shared_ptr<boost::asio::io_service> ioService, EventLoop* eventLoop) {

+ return ref(new BoostConnectionServer(address, port, ioService, eventLoop));

+ }

+ virtual boost::optional<Error> tryStart(); // FIXME: This should become the new start

+ virtual void start();

+ virtual void stop();

+ virtual HostAddressPort getAddressPort() const;

+ boost::signals2::signal<void (boost::optional<Error>)> onStopped;

+ private:

+ BoostConnectionServer(unsigned short port, std::shared_ptr<boost::asio::io_service> ioService, EventLoop* eventLoop);

+ BoostConnectionServer(const HostAddress &address, unsigned short port, std::shared_ptr<boost::asio::io_service> ioService, EventLoop* eventLoop);

+ void stop(boost::optional<Error> e);

+ void acceptNextConnection();

+ void handleAccept(std::shared_ptr<BoostConnection> newConnection, const boost::system::error_code& error);

+ private:

+ HostAddress address_;

+ unsigned short port_;

+ std::shared_ptr<boost::asio::io_service> ioService_;

+ EventLoop* eventLoop;

+ boost::asio::ip::tcp::acceptor* acceptor_;

+ };

+/*

+ * Copyright (c) 2016 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+

+BoostConnectionServerFactory::BoostConnectionServerFactory(std::shared_ptr<boost::asio::io_service> ioService, EventLoop* eventLoop) : ioService(ioService), eventLoop(eventLoop) {

+std::shared_ptr<ConnectionServer> BoostConnectionServerFactory::createConnectionServer(unsigned short port) {

+ return BoostConnectionServer::create(port, ioService, eventLoop);

+std::shared_ptr<ConnectionServer> BoostConnectionServerFactory::createConnectionServer(const Swift::HostAddress &hostAddress, unsigned short port) {

+ return BoostConnectionServer::create(hostAddress, port, ioService, eventLoop);

+/*

+ * Copyright (c) 2015-2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

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

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

+ class ConnectionServer;

+ class SWIFTEN_API BoostConnectionServerFactory : public ConnectionServerFactory {

+ public:

+ BoostConnectionServerFactory(std::shared_ptr<boost::asio::io_service>, EventLoop* eventLoop);

+ virtual std::shared_ptr<ConnectionServer> createConnectionServer(unsigned short port);

+ virtual std::shared_ptr<ConnectionServer> createConnectionServer(const Swift::HostAddress &hostAddress, unsigned short port);

+ private:

+ std::shared_ptr<boost::asio::io_service> ioService;

+ EventLoop* eventLoop;

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+#include <memory>

+

+#include <boost/bind.hpp>

+BoostIOServiceThread::BoostIOServiceThread(std::shared_ptr<boost::asio::io_service> ioService) {

+ if (!!ioService) {

+ ioService_ = ioService;

+ thread_ = nullptr;

+ }

+ else {

+ ioService_ = std::make_shared<boost::asio::io_service>();

+ thread_ = new std::thread(boost::bind(&BoostIOServiceThread::doRun, this));

+ }

+ if (thread_) {

+ ioService_->stop();

+ thread_->join();

+ delete thread_;

+ }

+ boost::asio::io_service::work work(*ioService_);

+ ioService_->run();

+ * Copyright (c) 2010-2016 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+#include <memory>

+#include <thread>

+

+ class SWIFTEN_API BoostIOServiceThread {

+ public:

+ /**

+ * Construct the object.

+ * @param ioService If this optional parameter is provided, the behaviour

+ * of this class changes completely - it no longer spawns its own thread

+ * and instead acts as a simple wrapper of the io_service. Use this if

+ * you are re-using an io_service from elsewhere (particularly if you

+ * are using the BoostASIOEventLoop).

+ */

+ BoostIOServiceThread(std::shared_ptr<boost::asio::io_service> ioService = std::shared_ptr<boost::asio::io_service>());

+ ~BoostIOServiceThread();

+

+ std::shared_ptr<boost::asio::io_service> getIOService() const {

+ return ioService_;

+ }

+

+ private:

+ void doRun();

+

+ private:

+ std::shared_ptr<boost::asio::io_service> ioService_;

+ std::thread* thread_;

+ };

+ * Copyright (c) 2010-2019 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+#include <Swiften/Crypto/CryptoProvider.h>

+#include <Swiften/Crypto/PlatformCryptoProvider.h>

+#include <Swiften/IDN/IDNConverter.h>

+#include <Swiften/IDN/PlatformIDNConverter.h>

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

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

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

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

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

+BoostNetworkFactories::BoostNetworkFactories(EventLoop* eventLoop, std::shared_ptr<boost::asio::io_service> ioService) : ioServiceThread(ioService), eventLoop(eventLoop) {

+ timerFactory = new BoostTimerFactory(ioServiceThread.getIOService(), eventLoop);

+ connectionFactory = new BoostConnectionFactory(ioServiceThread.getIOService(), eventLoop);

+ connectionServerFactory = new BoostConnectionServerFactory(ioServiceThread.getIOService(), eventLoop);

+ natTraverser = new PlatformNATTraversalWorker(eventLoop);

+ natTraverser = new NullNATTraverser(eventLoop);

+ networkEnvironment = new PlatformNetworkEnvironment();

+ xmlParserFactory = new PlatformXMLParserFactory();

+ tlsFactories = new PlatformTLSFactories();

+ proxyProvider = new PlatformProxyProvider();

+ idnConverter = PlatformIDNConverter::create();

+ // TODO: What to do about idnConverter.

+ domainNameResolver = new UnboundDomainNameResolver(idnConverter.get(), ioServiceThread.getIOService(), eventLoop);

+ domainNameResolver = new PlatformDomainNameResolver(idnConverter.get(), eventLoop);

+ cryptoProvider = PlatformCryptoProvider::create();

+ delete cryptoProvider;

+ delete domainNameResolver;

+ delete proxyProvider;

+ delete tlsFactories;

+ delete xmlParserFactory;

+ delete networkEnvironment;

+ delete natTraverser;

+ delete connectionServerFactory;

+ delete connectionFactory;

+ delete timerFactory;

+ return tlsFactories->getTLSContextFactory();

+ * Copyright (c) 2010-2019 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+#include <memory>

+

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

+ class EventLoop;

+ class NATTraverser;

+ class PlatformTLSFactories;

+

+ class SWIFTEN_API BoostNetworkFactories : public NetworkFactories {

+ public:

+ /**

+ * Construct the network factories, using the provided EventLoop.

+ * @param ioService If this optional parameter is provided, it will be

+ * used for the construction of the BoostIOServiceThread.

+ */

+ BoostNetworkFactories(EventLoop* eventLoop, std::shared_ptr<boost::asio::io_service> ioService = std::shared_ptr<boost::asio::io_service>());

+ virtual ~BoostNetworkFactories() override;

+

+ virtual TimerFactory* getTimerFactory() const override {

+ return timerFactory;

+ }

+

+ virtual ConnectionFactory* getConnectionFactory() const override {

+ return connectionFactory;

+ }

+

+ BoostIOServiceThread* getIOServiceThread() {

+ return &ioServiceThread;

+ }

+

+ DomainNameResolver* getDomainNameResolver() const override {

+ return domainNameResolver;

+ }

+

+ ConnectionServerFactory* getConnectionServerFactory() const override {

+ return connectionServerFactory;

+ }

+

+ NetworkEnvironment* getNetworkEnvironment() const override {

+ return networkEnvironment;

+ }

+

+ NATTraverser* getNATTraverser() const override {

+ return natTraverser;

+ }

+

+ virtual XMLParserFactory* getXMLParserFactory() const override {

+ return xmlParserFactory;

+ }

+

+ virtual TLSContextFactory* getTLSContextFactory() const override;

+

+ virtual ProxyProvider* getProxyProvider() const override {

+ return proxyProvider;

+ }

+

+ virtual EventLoop* getEventLoop() const override {

+ return eventLoop;

+ }

+

+ virtual IDNConverter* getIDNConverter() const override {

+ return idnConverter.get();

+ }

+

+ virtual CryptoProvider* getCryptoProvider() const override {

+ return cryptoProvider;

+ }

+

+ private:

+ BoostIOServiceThread ioServiceThread;

+ TimerFactory* timerFactory;

+ ConnectionFactory* connectionFactory;

+ DomainNameResolver* domainNameResolver;

+ ConnectionServerFactory* connectionServerFactory;

+ NATTraverser* natTraverser;

+ NetworkEnvironment* networkEnvironment;

+ XMLParserFactory* xmlParserFactory;

+ PlatformTLSFactories* tlsFactories;

+ ProxyProvider* proxyProvider;

+ EventLoop* eventLoop;

+ std::unique_ptr<IDNConverter> idnConverter;

+ CryptoProvider* cryptoProvider;

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+#include <boost/date_time/posix_time/posix_time.hpp>

+BoostTimer::BoostTimer(int milliseconds, std::shared_ptr<boost::asio::io_service> service, EventLoop* eventLoop) :

+ timeout(milliseconds), ioService(service), eventLoop(eventLoop), shuttingDown(false) {

+ timer.reset(new boost::asio::deadline_timer(*service));

+}

+

+BoostTimer::~BoostTimer() {

+ {

+ std::unique_lock<std::mutex> lockTimer(timerMutex);

+ timer.reset();

+ }

+ {

+ std::unique_lock<std::mutex> lockTimer(timerMutex);

+ shuttingDown = false;

+ timer->expires_from_now(boost::posix_time::milliseconds(timeout));

+ timer->async_wait(boost::bind(&BoostTimer::handleTimerTick, shared_from_this(), boost::asio::placeholders::error));

+ }

+ {

+ std::unique_lock<std::mutex> lockTimer(timerMutex);

+ shuttingDown = true;

+ timer->cancel();

+ eventLoop->removeEventsFromOwner(shared_from_this());

+ }

+ if (error) {

+ assert(error == boost::asio::error::operation_aborted);

+ }

+ else {

+ {

+ std::unique_lock<std::mutex> lockTimer(timerMutex);

+ if (shuttingDown) {

+ return;

+ }

+ eventLoop->postEvent(boost::bind(boost::ref(onTick)), shared_from_this());

+ }

+ }

+ * Copyright (c) 2010-2016 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+#include <memory>

+#include <mutex>

+

+#include <boost/asio/io_service.hpp>

+#include <boost/scoped_ptr.hpp>

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

+ class EventLoop;

+

+ class SWIFTEN_API BoostTimer : public Timer, public EventOwner, public std::enable_shared_from_this<BoostTimer> {

+ public:

+ typedef std::shared_ptr<BoostTimer> ref;

+ virtual ~BoostTimer();

+ static ref create(int milliseconds, std::shared_ptr<boost::asio::io_service> service, EventLoop* eventLoop) {

+ return ref(new BoostTimer(milliseconds, service, eventLoop));

+ }

+ virtual void start();

+ virtual void stop();

+ private:

+ BoostTimer(int milliseconds, std::shared_ptr<boost::asio::io_service> service, EventLoop* eventLoop);

+ void handleTimerTick(const boost::system::error_code& error);

+ private:

+ int timeout;

+ std::shared_ptr<boost::asio::io_service> ioService;

+ boost::scoped_ptr<boost::asio::deadline_timer> timer;

+ std::mutex timerMutex;

+ EventLoop* eventLoop;

+ bool shuttingDown;

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+

+BoostTimerFactory::BoostTimerFactory(std::shared_ptr<boost::asio::io_service> ioService, EventLoop* eventLoop) : ioService(ioService), eventLoop(eventLoop) {

+std::shared_ptr<Timer> BoostTimerFactory::createTimer(int milliseconds) {

+ return BoostTimer::create(milliseconds, ioService, eventLoop);

+ * Copyright (c) 2010-2017 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

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

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

+ class EventLoop;

+ class SWIFTEN_API BoostTimerFactory : public TimerFactory {

+ public:

+ BoostTimerFactory(std::shared_ptr<boost::asio::io_service>, EventLoop* eventLoop);

+ virtual std::shared_ptr<Timer> createTimer(int milliseconds);

+ private:

+ std::shared_ptr<boost::asio::io_service> ioService;

+ EventLoop* eventLoop;

+ };

+ * Copyright (c) 2012-2016 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+#include <memory>

+DomainNameServiceQuery::ref CachingDomainNameResolver::createServiceQuery(const std::string& serviceLookupPrefix, const std::string& domain) {

+ //TODO: Cache

+ return realResolver->createServiceQuery(serviceLookupPrefix, domain);

+ //TODO: Cache

+ return realResolver->createAddressQuery(name);

+ * Copyright (c) 2012-2016 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+#include <memory>

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

+ class EventLoop;

+ class SWIFTEN_API CachingDomainNameResolver : public DomainNameResolver {

+ public:

+ CachingDomainNameResolver(DomainNameResolver* realResolver, EventLoop* eventLoop);

+ ~CachingDomainNameResolver();

+ virtual DomainNameServiceQuery::ref createServiceQuery(const std::string& serviceLookupPrefix, const std::string& domain);

+ virtual DomainNameAddressQuery::ref createAddressQuery(const std::string& name);

+ private:

+ DomainNameResolver* realResolver;

+ };

+ * Copyright (c) 2011-2019 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+#include <boost/bind.hpp>

+

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

+ const std::string& hostname,

+ unsigned short port,

+ const boost::optional<std::string>& serviceLookupPrefix,

+ DomainNameResolver* resolver,

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

+ TimerFactory* timerFactory) :

+ hostname(hostname),

+ port(port),

+ serviceLookupPrefix(serviceLookupPrefix),

+ resolver(resolver),

+ connectionFactories(connectionFactories),

+ timerFactory(timerFactory),

+ timeoutMilliseconds(0) {

+}

+

+ChainedConnector::~ChainedConnector() {

+ if (currentConnector) {

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

+ currentConnector->stop();

+ currentConnector.reset();

+ }

+ timeoutMilliseconds = milliseconds;

+ SWIFT_LOG(debug) << "Starting queued connector for " << hostname;

+ connectionFactoryQueue = std::deque<ConnectionFactory*>(connectionFactories.begin(), connectionFactories.end());

+ tryNextConnectionFactory();

+ if (currentConnector) {

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

+ currentConnector->stop();

+ currentConnector.reset();

+ }

+ finish(std::shared_ptr<Connection>(), std::shared_ptr<Error>());

+ assert(!currentConnector);

+ if (connectionFactoryQueue.empty()) {

+ SWIFT_LOG(debug) << "No more connection factories";

+ finish(std::shared_ptr<Connection>(), lastError);

+ }

+ else {

+ ConnectionFactory* connectionFactory = connectionFactoryQueue.front();

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

+ connectionFactoryQueue.pop_front();

+ currentConnector = Connector::create(hostname, port, serviceLookupPrefix, resolver, connectionFactory, timerFactory);

+ currentConnector->setTimeoutMilliseconds(timeoutMilliseconds);

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

+ currentConnector->start();

+ }

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

+ SWIFT_LOG(debug) << "Connector finished";

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

+ lastError = error;

+ currentConnector.reset();

+ if (connection) {

+ finish(connection, error);

+ }

+ else {

+ tryNextConnectionFactory();

+ }

+void ChainedConnector::finish(std::shared_ptr<Connection> connection, std::shared_ptr<Error> error) {

+ onConnectFinished(connection, error);

+ * Copyright (c) 2011-2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+#include <deque>

+#include <memory>

+

+#include <boost/optional.hpp>

+#include <boost/signals2.hpp>

+ class Connection;

+ class Connector;

+ class ConnectionFactory;

+ class TimerFactory;

+ class DomainNameResolver;

+

+ class SWIFTEN_API ChainedConnector {

+ public:

+ ChainedConnector(const std::string& hostname, unsigned short port, const boost::optional<std::string>& serviceLookupPrefix, DomainNameResolver*, const std::vector<ConnectionFactory*>&, TimerFactory*);

+ ~ChainedConnector();

+

+ void setTimeoutMilliseconds(int milliseconds);

+ void start();

+ void stop();

+

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

+

+ private:

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

+ void tryNextConnectionFactory();

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

+

+ private:

+ std::string hostname;

+ unsigned short port;

+ boost::optional<std::string> serviceLookupPrefix;

+ DomainNameResolver* resolver;

+ std::vector<ConnectionFactory*> connectionFactories;

+ TimerFactory* timerFactory;

+ int timeoutMilliseconds;

+ std::deque<ConnectionFactory*> connectionFactoryQueue;

+ std::shared_ptr<Connector> currentConnector;

+ std::shared_ptr<Error> lastError;

+ };

+ * Copyright (c) 2010 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ * Copyright (c) 2010-2016 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+#include <memory>

+

+#include <boost/signals2.hpp>

+ class HostAddressPort;

+

+ class SWIFTEN_API Connection {

+ public:

+ typedef std::shared_ptr<Connection> ref;

+

+ enum Error {

+ ReadError,

+ WriteError

+ };

+

+ Connection();

+ virtual ~Connection();

+

+ virtual void listen() = 0;

+ virtual void connect(const HostAddressPort& address) = 0;

+ virtual void disconnect() = 0;

+ virtual void write(const SafeByteArray& data) = 0;

+

+ virtual HostAddressPort getLocalAddress() const = 0;

+ virtual HostAddressPort getRemoteAddress() const = 0;

+

+ public:

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

+ boost::signals2::signal<void (const boost::optional<Error>&)> onDisconnected;

+ boost::signals2::signal<void (std::shared_ptr<SafeByteArray>)> onDataRead;

+ boost::signals2::signal<void ()> onDataWritten;

+ };

+ * Copyright (c) 2010 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ * Copyright (c) 2010-2016 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+#include <memory>

+ class Connection;

+ class SWIFTEN_API ConnectionFactory {

+ public:

+ virtual ~ConnectionFactory();

+ virtual std::shared_ptr<Connection> createConnection() = 0;

+ };

+ * Copyright (c) 2010 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ * Copyright (c) 2010-2016 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+#include <memory>

+

+#include <boost/optional/optional.hpp>

+#include <boost/signals2.hpp>

+ class SWIFTEN_API ConnectionServer {

+ public:

+ enum Error {

+ Conflict,

+ UnknownError

+ };

+ virtual ~ConnectionServer();

+ virtual HostAddressPort getAddressPort() const = 0;

+ virtual boost::optional<Error> tryStart() = 0; // FIXME: This should become the new start

+ virtual void start() = 0;

+ virtual void stop() = 0;

+ boost::signals2::signal<void (std::shared_ptr<Connection>)> onNewConnection;

+ };

+/*

+ * Copyright (c) 2015-2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#include <memory>

+

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

+ class ConnectionServer;

+ class HostAddress;

+ class SWIFTEN_API ConnectionServerFactory {

+ public:

+ virtual ~ConnectionServerFactory();

+ virtual std::shared_ptr<ConnectionServer> createConnectionServer(unsigned short port) = 0;

+ virtual std::shared_ptr<ConnectionServer> createConnectionServer(const Swift::HostAddress& hostAddress, unsigned short port) = 0;

+ };

+ * Copyright (c) 2010-2019 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

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

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

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

+Connector::Connector(const std::string& hostname, unsigned short port, const boost::optional<std::string>& serviceLookupPrefix, DomainNameResolver* resolver, ConnectionFactory* connectionFactory, TimerFactory* timerFactory) : hostname(hostname), port(port), serviceLookupPrefix(serviceLookupPrefix), resolver(resolver), connectionFactory(connectionFactory), timerFactory(timerFactory), timeoutMilliseconds(0), queriedAllServices(true), foundSomeDNS(false) {

+ timeoutMilliseconds = milliseconds;

+ SWIFT_LOG(debug) << "Starting connector for " << hostname;

+ assert(!currentConnection);

+ assert(!serviceQuery);

+ assert(!timer);

+ auto hostAddress = HostAddress::fromString(hostname);

+ if (timeoutMilliseconds > 0) {

+ timer = timerFactory->createTimer(timeoutMilliseconds);

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

+ }

+ if (serviceLookupPrefix) {

+ queriedAllServices = false;

+ serviceQuery = resolver->createServiceQuery(*serviceLookupPrefix, hostname);

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

+ serviceQuery->run();

+ }

+ else if (hostAddress) {

+ // hostname is already a valid address; skip name lookup.

+ foundSomeDNS = true;

+ addressQueryResults.push_back(hostAddress.get());

+ tryNextAddress();

+ } else {

+ queryAddress(hostname);

+ }

+ if (currentConnection) {

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

+ currentConnection->disconnect();

+ }

+ finish(std::shared_ptr<Connection>());

+ assert(!addressQuery);

+ addressQuery = resolver->createAddressQuery(hostname);

+ addressQuery->onResult.connect(boost::bind(&Connector::handleAddressQueryResult, shared_from_this(), _1, _2));

+ addressQuery->run();

+ SWIFT_LOG(debug) << result.size() << " SRV result(s)";

+ serviceQueryResults = std::deque<DomainNameServiceQuery::Result>(result.begin(), result.end());

+ serviceQuery.reset();

+ if (!serviceQueryResults.empty()) {

+ foundSomeDNS = true;

+ }

+ tryNextServiceOrFallback();

+ if (queriedAllServices) {

+ SWIFT_LOG(debug) << "Queried all services";

+ finish(std::shared_ptr<Connection>());

+ }

+ else if (serviceQueryResults.empty()) {

+ SWIFT_LOG(debug) << "Falling back on A resolution";

+ // Fall back on simple address resolving

+ queriedAllServices = true;

+ queryAddress(hostname);

+ }

+ else {

+ SWIFT_LOG(debug) << "Querying next address";

+ queryAddress(serviceQueryResults.front().hostname);

+ }

+ SWIFT_LOG(debug) << addresses.size() << " addresses";

+ addressQuery.reset();

+ if (error || addresses.empty()) {

+ if (!serviceQueryResults.empty()) {

+ serviceQueryResults.pop_front();

+ }

+ tryNextServiceOrFallback();

+ }

+ else {

+ foundSomeDNS = true;

+ addressQueryResults = std::deque<HostAddress>(addresses.begin(), addresses.end());

+ tryNextAddress();

+ }

+ if (addressQueryResults.empty()) {

+ SWIFT_LOG(debug) << "Done trying addresses. Moving on.";

+ // Done trying all addresses. Move on to the next host.

+ if (!serviceQueryResults.empty()) {

+ serviceQueryResults.pop_front();

+ }

+ tryNextServiceOrFallback();

+ }

+ else {

+ SWIFT_LOG(debug) << "Trying next address";

+ HostAddress address = addressQueryResults.front();

+ addressQueryResults.pop_front();

+

+ unsigned short connectPort = (port == 0 ? 5222 : port);

+ if (!serviceQueryResults.empty()) {

+ connectPort = serviceQueryResults.front().port;

+ }

+

+ tryConnect(HostAddressPort(address, connectPort));

+ }

+ assert(!currentConnection);

+ SWIFT_LOG(debug) << "Trying to connect to " << target.getAddress().toString() << ":" << target.getPort();

+ currentConnection = connectionFactory->createConnection();

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

+ currentConnection->connect(target);

+ if (timer) {

+ timer->start();

+ }

+ SWIFT_LOG(debug) << "ConnectFinished: " << (error ? "error" : "success");

+ if (timer) {

+ timer->stop();

+ timer.reset();

+ }

+ if (!currentConnection) {

+ // We've hit a race condition where multiple finisheds were on the eventloop queue at once.

+ // This is particularly likely on macOS where the hourly momentary wakeup while asleep

+ // can cause both a timeout and an onConnectFinished to be queued sequentially (SWIFT-232).

+ // Let the first one process as normal, but ignore the second.

+ return;

+ }

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

+ if (error) {

+ currentConnection.reset();

+ if (!addressQueryResults.empty()) {

+ tryNextAddress();

+ }

+ else {

+ if (!serviceQueryResults.empty()) {

+ serviceQueryResults.pop_front();

+ }

+ tryNextServiceOrFallback();

+ }

+ }

+ else {

+ finish(currentConnection);

+ }

+void Connector::finish(std::shared_ptr<Connection> connection) {

+ if (timer) {

+ timer->stop();

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

+ timer.reset();

+ }

+ if (serviceQuery) {

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

+ serviceQuery.reset();

+ }

+ if (addressQuery) {

+ addressQuery->onResult.disconnect(boost::bind(&Connector::handleAddressQueryResult, shared_from_this(), _1, _2));

+ addressQuery.reset();

+ }

+ if (currentConnection) {

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

+ currentConnection.reset();

+ }

+ onConnectFinished(connection, (connection || foundSomeDNS) ? std::shared_ptr<Error>() : std::make_shared<DomainNameResolveError>());

+ SWIFT_LOG(debug) << "Timeout";

+ SWIFT_LOG_ASSERT(currentConnection, error) << "Connection not valid but triggered a timeout";

+ handleConnectionConnectFinished(true);

+ * Copyright (c) 2010-2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+#include <memory>

+#include <string>

+

+#include <boost/optional.hpp>

+#include <boost/signals2.hpp>

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

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

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

+ class DomainNameAddressQuery;

+ class DomainNameResolver;

+ class ConnectionFactory;

+ class TimerFactory;

+ class SWIFTEN_API Connector : public boost::signals2::trackable, public std::enable_shared_from_this<Connector> {

+ public:

+ typedef std::shared_ptr<Connector> ref;

+ static Connector::ref create(const std::string& hostname, unsigned short port, const boost::optional<std::string>& serviceLookupPrefix, DomainNameResolver* resolver, ConnectionFactory* connectionFactory, TimerFactory* timerFactory) {

+ return ref(new Connector(hostname, port, serviceLookupPrefix, resolver, connectionFactory, timerFactory));

+ }

+ void setTimeoutMilliseconds(int milliseconds);

+ /**

+ * Start the connection attempt.

+ * Note that after calling this method, the caller is responsible for calling #stop()

+ * if it wants to cancel it. Not doing so can leak references.

+ */

+ void start();

+ void stop();

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

+ private:

+ Connector(const std::string& hostname, unsigned short port, const boost::optional<std::string>& serviceLookupPrefix, DomainNameResolver*, ConnectionFactory*, TimerFactory*);

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

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

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

+ void tryNextServiceOrFallback();

+ void tryNextAddress();

+ void tryConnect(const HostAddressPort& target);

+ void handleConnectionConnectFinished(bool error);

+ void finish(std::shared_ptr<Connection>);

+ void handleTimeout();

+ private:

+ std::string hostname;

+ unsigned short port;

+ boost::optional<std::string> serviceLookupPrefix;

+ DomainNameResolver* resolver;

+ ConnectionFactory* connectionFactory;

+ TimerFactory* timerFactory;

+ int timeoutMilliseconds;

+ std::shared_ptr<Timer> timer;

+ std::shared_ptr<DomainNameServiceQuery> serviceQuery;

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

+ std::shared_ptr<DomainNameAddressQuery> addressQuery;

+ std::deque<HostAddress> addressQueryResults;

+ bool queriedAllServices;

+ std::shared_ptr<Connection> currentConnection;

+ bool foundSomeDNS;

+ };

+ * Copyright (c) 2010 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ * Copyright (c) 2010-2016 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+#include <memory>

+

+#include <boost/signals2.hpp>

+ class DomainNameAddressQuery {

+ public:

+ typedef std::shared_ptr<DomainNameAddressQuery> ref;

+ virtual ~DomainNameAddressQuery();

+ virtual void run() = 0;

+ boost::signals2::signal<void (const std::vector<HostAddress>&, boost::optional<DomainNameResolveError>)> onResult;

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

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

+ class SWIFTEN_API DomainNameResolveError : public Error {

+ public:

+ DomainNameResolveError() {}

+ SWIFTEN_DEFAULT_COPY_CONSTRUCTOR(DomainNameResolveError)

+ SWIFTEN_DEFAULT_COPY_ASSIGMNENT_OPERATOR(DomainNameResolveError)

+ };

+ * Copyright (c) 2010 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ * Copyright (c) 2010-2016 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+#include <memory>

+ class DomainNameServiceQuery;

+ class DomainNameAddressQuery;

+ class SWIFTEN_API DomainNameResolver {

+ public:

+ virtual ~DomainNameResolver();

+

+ virtual std::shared_ptr<DomainNameServiceQuery> createServiceQuery(const std::string& serviceLookupPrefix, const std::string& domain) = 0;

+ virtual std::shared_ptr<DomainNameAddressQuery> createAddressQuery(const std::string& name) = 0;

+ };

+ * Copyright (c) 2010-2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+#include <numeric>

+

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

+ struct ResultPriorityComparator {

+ bool operator()(const DomainNameServiceQuery::Result& a, const DomainNameServiceQuery::Result& b) const {

+ return a.priority < b.priority;

+ }

+ };

+ ResultPriorityComparator comparator;

+ std::stable_sort(queries.begin(), queries.end(), comparator);

+ std::vector<DomainNameServiceQuery::Result>::iterator i = queries.begin();

+ while (i != queries.end()) {

+ std::vector<DomainNameServiceQuery::Result>::iterator next = std::upper_bound(i, queries.end(), *i, comparator);

+ if (std::distance(i, next) > 1) {

+ std::vector<int> weights;

+ std::transform(i, next, std::back_inserter(weights), [](const DomainNameServiceQuery::Result& result) {

+ /* easy hack to account for '0' weights getting at least some weight */

+ return result.weight + 1;

+ });

+ try {

+ for (int j = 0; j < boost::numeric_cast<int>(weights.size()) - 1; ++j) {

+ std::vector<int> cumulativeWeights;

+ std::partial_sum(

+ weights.begin() + j,

+ weights.end(),

+ std::back_inserter(cumulativeWeights));

+ int randomNumber = generator.generateRandomInteger(cumulativeWeights.back());

+ auto selectedIndex = std::lower_bound(cumulativeWeights.begin(), cumulativeWeights.end(), randomNumber) - cumulativeWeights.begin();

+ std::swap(i[j], i[j + selectedIndex]);

+ std::swap(weights.begin()[j], weights.begin()[j + selectedIndex]);

+ }

+ }

+ catch (const boost::numeric::bad_numeric_cast&) {

+ // In the unlikely event of weights.size() being too large, use the list as-is.

+ }

+ }

+ i = next;

+ }

+ * Copyright (c) 2010-2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+#include <memory>

+#include <string>

+#include <boost/optional.hpp>

+#include <boost/signals2.hpp>

+

+ class RandomGenerator;

+ class SWIFTEN_API DomainNameServiceQuery {

+ public:

+ typedef std::shared_ptr<DomainNameServiceQuery> ref;

+ struct Result {

+ Result(const std::string& hostname = "", unsigned short port = 0, int priority = -1, int weight = -1) : hostname(hostname), port(port), priority(priority), weight(weight) {}

+ std::string hostname;

+ unsigned short port;

+ int priority;

+ int weight;

+ };

+ virtual ~DomainNameServiceQuery();

+ virtual void run() = 0;

+ static void sortResults(std::vector<DomainNameServiceQuery::Result>& queries, RandomGenerator& generator);

+ boost::signals2::signal<void (const std::vector<Result>&)> onResult;

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+#include <memory>

+

+#include <boost/bind.hpp>

+ eventLoop->postEvent(boost::bind(boost::ref(onDataRead), std::make_shared<SafeByteArray>(data)), shared_from_this());

+ assert(false);

+ assert(false);

+ * Copyright (c) 2010-2016 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+#include <memory>

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

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

+ class SWIFTEN_API DummyConnection : public Connection, public EventOwner, public std::enable_shared_from_this<DummyConnection> {

+ public:

+ DummyConnection(EventLoop* eventLoop);

+

+ void listen();

+ void connect(const HostAddressPort&);

+ void disconnect() {

+ //assert(false);

+ }

+ void write(const SafeByteArray& data) {

+ eventLoop->postEvent(boost::ref(onDataWritten), shared_from_this());

+ onDataSent(data);

+ }

+ void receive(const SafeByteArray& data);

+ HostAddressPort getLocalAddress() const {

+ return localAddress;

+ }

+ HostAddressPort getRemoteAddress() const {

+ return remoteAddress;

+ }

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

+ EventLoop* eventLoop;

+ HostAddressPort localAddress;

+ HostAddressPort remoteAddress;

+ };

+/*

+ * Copyright (c) 2016 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#include <memory>

+ DummyConnectionFactory(EventLoop *eventLoop) : eventLoop(eventLoop) {}

+ virtual ~DummyConnectionFactory() {}

+ virtual std::shared_ptr<Connection> createConnection() {

+ return std::make_shared<DummyConnection>(eventLoop);

+ }

+ EventLoop* eventLoop;

+/*

+ * Copyright (c) 2010-2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#pragma once

+

+#include <memory>

+

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

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

+#include <Swiften/EventLoop/EventOwner.h>

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

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

+

+namespace Swift {

+ class SWIFTEN_API DummyConnectionServer : public ConnectionServer, public EventOwner, public std::enable_shared_from_this<DummyConnectionServer> {

+ public:

+ DummyConnectionServer(EventLoop* /*eventLoop*/, unsigned short port) : localAddressPort(HostAddress(), port) {}

+ DummyConnectionServer(EventLoop* /*eventLoop*/, const Swift::HostAddress& hostAddress, unsigned short port) : localAddressPort(hostAddress, port) {}

+ virtual ~DummyConnectionServer() {}

+

+ virtual HostAddressPort getAddressPort() const {

+ return localAddressPort;

+ }

+

+ virtual boost::optional<Error> tryStart() {

+ return boost::optional<Error>();

+ }

+

+ virtual void start() {

+

+ }

+

+ virtual void stop() {

+

+ }

+

+ private:

+ HostAddressPort localAddressPort;

+ };

+}

+/*

+ * Copyright (c) 2014-2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#pragma once

+

+#include <memory>

+

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

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

+

+namespace Swift {

+

+class EventLoop;

+

+class DummyConnectionServerFactory : public ConnectionServerFactory {

+public:

+ DummyConnectionServerFactory(EventLoop* eventLoop) : eventLoop(eventLoop) {}

+ virtual ~DummyConnectionServerFactory() {}

+

+ virtual std::shared_ptr<ConnectionServer> createConnectionServer(unsigned short port) {

+ return std::make_shared<DummyConnectionServer>(eventLoop, port);

+ }

+

+ virtual std::shared_ptr<ConnectionServer> createConnectionServer(const Swift::HostAddress& hostAddress, unsigned short port) {

+ return std::make_shared<DummyConnectionServer>(eventLoop, hostAddress, port);

+ }

+

+private:

+ EventLoop* eventLoop;

+};

+

+}

+ * Copyright (c) 2010-2016 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ public:

+ DummyTimer(int timeout, DummyTimerFactory* factory) : timeout(timeout), factory(factory), isRunning(false), startTime(~0) {

+ }

+

+ virtual void start() {

+ isRunning = true;

+ startTime = factory->currentTime;

+ }

+

+ virtual void stop() {

+ isRunning = false;

+ }

+

+ int getAlarmTime() const {

+ return startTime + timeout;

+ }

+

+ int timeout;

+ DummyTimerFactory* factory;

+ bool isRunning;

+ int startTime;

+std::shared_ptr<Timer> DummyTimerFactory::createTimer(int milliseconds) {

+ std::shared_ptr<DummyTimer> timer(new DummyTimer(milliseconds, this));

+ timers.push_back(timer);

+ return timer;

+ assert(time > currentTime);

+ for (auto&& timer : timers) {

+ if (timer->getAlarmTime() > currentTime && timer->getAlarmTime() <= time && timer->isRunning) {

+ timer->onTick();

+ }

+ }

+ currentTime = time;

+ * Copyright (c) 2010-2016 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ class SWIFTEN_API DummyTimerFactory : public TimerFactory {

+ public:

+ class DummyTimer;

+ DummyTimerFactory();

+ virtual std::shared_ptr<Timer> createTimer(int milliseconds);

+ void setTime(int time);

+ private:

+ friend class DummyTimer;

+ int currentTime;

+ std::list<std::shared_ptr<DummyTimer> > timers;

+ };

+/*

+ * Copyright (c) 2016-2019 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

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

+

+

+#include <boost/numeric/conversion/cast.hpp>

+

+ socksProxy = getFromEnv("all_proxy", "socks");

+ httpProxy = getFromEnv("http_proxy", "http");

+ SWIFT_LOG(debug) << "Environment: SOCKS5 => " << socksProxy.toString() << "; HTTP Connect => " << httpProxy.toString();

+ return httpProxy;

+ return socksProxy;

+ char* envVar = nullptr;

+ std::string address;

+ unsigned short port = 0;

+

+ envVar = getenv(envVarName);

+

+ proxyProtocol += "://";

+ address = envVar != nullptr ? envVar : "0.0.0.0";

+ if(envVar != nullptr && address.compare(0, proxyProtocol.length(), proxyProtocol) == 0) {

+ address = address.substr(proxyProtocol.length(), address.length());

+ try {

+ port = boost::numeric_cast<unsigned short>(atoi(address.substr(address.find(':') + 1, address.length()).c_str()));

+ }

+ catch (boost::numeric::bad_numeric_cast&) {

+ }

+ address = address.substr(0, address.find(':'));

+ }

+

+ return HostAddressPort(HostAddress::fromString(address).get_value_or(HostAddress()), port);

+/*

+ * Copyright (c) 2015 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

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

+ class SWIFTEN_API EnvironmentProxyProvider : public ProxyProvider {

+ public:

+ EnvironmentProxyProvider();

+ virtual HostAddressPort getHTTPConnectProxy() const;

+ virtual HostAddressPort getSOCKS5Proxy() const;

+ private:

+ HostAddressPort getFromEnv(const char* envVarName, std::string proxyProtocol);

+ HostAddressPort socksProxy;

+ HostAddressPort httpProxy;

+ };

+ * Copyright (c) 2010-2014 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ assert(false);

+ error = boost::optional<Error>(e);

+ state = DisconnectedWithError;

+ if (connectedTo) {

+ eventLoop->postEvent(

+ boost::bind(boost::ref(onDisconnected), error),

+ shared_from_this());

+ }

+ if (delayConnect) {

+ state = Connecting;

+ }

+ else {

+ if (!error) {

+ connectedTo = address;

+ state = Connected;

+ }

+ else {

+ state = DisconnectedWithError;

+ }

+ eventLoop->postEvent(

+ boost::bind(boost::ref(onConnectFinished), error ? true : false),

+ shared_from_this());

+ }

+ if (!error) {

+ state = Disconnected;

+ }

+ else {

+ state = DisconnectedWithError;

+ }

+ connectedTo.reset();

+ eventLoop->postEvent(

+ boost::bind(boost::ref(onDisconnected), error),

+ shared_from_this());

+ * Copyright (c) 2010-2016 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+#include <memory>

+#include <boost/optional.hpp>

+

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

+#include <Swiften/EventLoop/EventOwner.h>

+ class SWIFTEN_API FakeConnection :

+ public Connection,

+ public EventOwner,

+ public std::enable_shared_from_this<FakeConnection> {

+ public:

+ enum State {

+ Initial,

+ Connecting,

+ Connected,

+ Disconnected,

+ DisconnectedWithError

+ };

+

+ FakeConnection(EventLoop* eventLoop);

+ virtual ~FakeConnection();

+

+ virtual void listen();

+ virtual HostAddressPort getLocalAddress() const {

+ return HostAddressPort();

+ }

+ virtual HostAddressPort getRemoteAddress() const {

+ return HostAddressPort();

+ }

+

+ void setError(const Error& e);

+ virtual void connect(const HostAddressPort& address);

+ virtual void disconnect();

+

+ virtual void write(const SafeByteArray& data) {

+ dataWritten.push_back(data);

+ }

+

+ void setDelayConnect() {

+ delayConnect = true;

+ }

+

+ EventLoop* eventLoop;

+ boost::optional<HostAddressPort> connectedTo;

+ std::vector<SafeByteArray> dataWritten;

+ boost::optional<Error> error;

+ State state;

+ bool delayConnect;

+ };

+/*

+ * Copyright (c) 2016-2019 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

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

+

+#include <cstdio>

+#include <cstdlib>

+

+extern "C" {

+}

+

+#include <boost/numeric/conversion/cast.hpp>

+#if !GLIB_CHECK_VERSION(2,35,0)

+ // Ensure static GLib initialization methods are called

+ static bool glibInitialized = false;

+ if (!glibInitialized) {

+ g_type_init();

+ glibInitialized = true;

+ }

+#endif

+

+ socksProxy = getFromGConf("/system/proxy/socks_host", "/system/proxy/socks_port");

+ httpProxy = getFromGConf("/system/http_proxy/host", "/system/http_proxy/port");

+ SWIFT_LOG(debug) << "GConf: SOCKS5 => " << socksProxy.toString() << "; HTTP Connect => " << httpProxy.toString();

+ return httpProxy;

+ return socksProxy;

+ std::string address;

+ unsigned short port = 0;

+ gchar* str;

+ GConfClient* client = gconf_client_get_default();

+ str = gconf_client_get_string(client, gcHost, NULL);

+ try {

+ port = boost::numeric_cast<unsigned short>(gconf_client_get_int(client, gcPort, NULL));

+ }

+ catch (const boost::numeric::bad_numeric_cast&) {

+ }

+ if(str) {

+ address = static_cast<char*> (str);

+ g_free(str);

+ }

+ g_object_unref(client);

+ return HostAddressPort(HostAddress::fromString(address).get_value_or(HostAddress()), port);

+ class GConfProxyProvider : public ProxyProvider {

+ public:

+ GConfProxyProvider();

+ virtual HostAddressPort getHTTPConnectProxy() const;

+ virtual HostAddressPort getSOCKS5Proxy() const;

+ private:

+ HostAddressPort getFromGConf(const char* gcHost, const char* gcPort);

+ HostAddressPort socksProxy;

+ HostAddressPort httpProxy;

+ };

+ * Copyright (c) 2011-2019 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+#include <utility>

+

+#include <boost/algorithm/string.hpp>

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

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

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

+ DomainNameResolver* resolver,

+ ConnectionFactory* connectionFactory,

+ TimerFactory* timerFactory,

+ const std::string& proxyHost,

+ unsigned short proxyPort,

+ const SafeString& authID,

+ const SafeString& authPassword) :

+ ProxiedConnection(resolver, connectionFactory, timerFactory, proxyHost, proxyPort),

+ authID_(authID),

+ authPassword_(authPassword) {

+}

+

+HTTPConnectProxiedConnection::~HTTPConnectProxiedConnection() {

+

+void HTTPConnectProxiedConnection::setHTTPTrafficFilter(std::shared_ptr<HTTPTrafficFilter> trafficFilter) {

+ trafficFilter_ = trafficFilter;

+}

+ httpResponseBuffer_.clear();

+

+ std::stringstream connect;

+ connect << "CONNECT " << getServer().getAddress().toString() << ":" << getServer().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"));

+ }

+ else if (!nextHTTPRequestHeaders_.empty()) {

+ for (const auto& headerField : nextHTTPRequestHeaders_) {

+ append(data, createSafeByteArray(headerField.first));

+ append(data, createSafeByteArray(": "));

+ append(data, createSafeByteArray(headerField.second));

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

+ }

+

+ nextHTTPRequestHeaders_.clear();

+ }

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

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

+ write(data);

+void HTTPConnectProxiedConnection::parseHTTPHeader(const std::string& data, std::string& statusLine, std::vector<std::pair<std::string, std::string> >& headerFields) {

+ std::istringstream dataStream(data);

+

+ // parse status line

+ std::getline(dataStream, statusLine);

+

+ // parse fields

+ std::string headerLine;

+ std::string::size_type splitIndex;

+ while (std::getline(dataStream, headerLine) && headerLine != "\r") {

+ splitIndex = headerLine.find(':', 0);

+ if (splitIndex != std::string::npos) {

+ headerFields.push_back(std::pair<std::string, std::string>(headerLine.substr(0, splitIndex), headerLine.substr(splitIndex + 1)));

+ }

+ }

+}

+

+void HTTPConnectProxiedConnection::sendHTTPRequest(const std::string& statusLine, const std::vector<std::pair<std::string, std::string> >& headerFields) {

+ std::stringstream request;

+

+ request << statusLine << "\r\n";

+ for (const auto& field : headerFields) {

+ request << field.first << ":" << field.second << "\r\n";

+ }

+ request << "\r\n";

+ write(createSafeByteArray(request.str()));

+}

+

+void HTTPConnectProxiedConnection::handleProxyInitializeData(std::shared_ptr<SafeByteArray> data) {

+ std::string dataString = byteArrayToString(ByteArray(data->begin(), data->end()));

+ SWIFT_LOG(debug) << data;

+ httpResponseBuffer_.append(dataString);

+

+ std::string statusLine;

+ std::vector<std::pair<std::string, std::string> > headerFields;

+

+ std::string::size_type headerEnd = httpResponseBuffer_.find("\r\n\r\n", 0);

+ if (headerEnd == std::string::npos) {

+ if ((httpResponseBuffer_.size() > 4) && (httpResponseBuffer_.substr(0, 4) != "HTTP")) {

+ setProxyInitializeFinished(false);

+ }

+ return;

+ }

+

+ parseHTTPHeader(httpResponseBuffer_.substr(0, headerEnd), statusLine, headerFields);

+

+ if (trafficFilter_) {

+ std::vector<std::pair<std::string, std::string> > newHeaderFields = trafficFilter_->filterHTTPResponseHeader(statusLine, headerFields);

+ if (!newHeaderFields.empty()) {

+ std::stringstream statusLine;

+ reconnect();

+ nextHTTPRequestHeaders_ = newHeaderFields;

+ return;

+ }

+ }

+

+ std::vector<std::string> tmp = String::split(statusLine, ' ');

+ if (tmp.size() > 1) {

+ try {

+ int status = boost::lexical_cast<int>(tmp[1]);

+ SWIFT_LOG(debug) << "Proxy Status: " << status;

+ if (status / 100 == 2) { // all 2XX states are OK

+ setProxyInitializeFinished(true);

+ }

+ else {

+ SWIFT_LOG(debug) << "HTTP Proxy returned an error: " << httpResponseBuffer_;

+ setProxyInitializeFinished(false);

+ }

+ }

+ catch (boost::bad_lexical_cast&) {

+ SWIFT_LOG(warning) << "Unexpected response: " << tmp[1];

+ setProxyInitializeFinished(false);

+ }

+ }

+ else {

+ setProxyInitializeFinished(false);

+ }

+ httpResponseBuffer_.clear();

+ * Copyright (c) 2011-2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+#include <memory>

+

+ class ConnectionFactory;

+ class DomainNameResolver;

+ class HTTPTrafficFilter;

+ class TimerFactory;

+

+ class SWIFTEN_API HTTPConnectProxiedConnection : public ProxiedConnection {

+ public:

+ typedef std::shared_ptr<HTTPConnectProxiedConnection> ref;

+

+ virtual ~HTTPConnectProxiedConnection();

+

+ static ref create(DomainNameResolver* resolver, ConnectionFactory* connectionFactory, TimerFactory* timerFactory, const std::string& proxyHost, unsigned short proxyPort, const SafeString& authID, const SafeString& authPassword) {

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

+ }

+ void setHTTPTrafficFilter(std::shared_ptr<HTTPTrafficFilter> trafficFilter);

+ private:

+ HTTPConnectProxiedConnection(DomainNameResolver* resolver, ConnectionFactory* connectionFactory, TimerFactory* timerFactory, const std::string& proxyHost, unsigned short proxyPort, const SafeString& authID, const SafeString& authPassword);

+ virtual void initializeProxy();

+ virtual void handleProxyInitializeData(std::shared_ptr<SafeByteArray> data);

+ void sendHTTPRequest(const std::string& statusLine, const std::vector<std::pair<std::string, std::string> >& headerFields);

+ void parseHTTPHeader(const std::string& data, std::string& statusLine, std::vector<std::pair<std::string, std::string> >& headerFields);

+ private:

+ SafeByteArray authID_;

+ SafeByteArray authPassword_;

+ std::shared_ptr<HTTPTrafficFilter> trafficFilter_;

+ std::string httpResponseBuffer_;

+ std::vector<std::pair<std::string, std::string> > nextHTTPRequestHeaders_;

+ };

+ * Copyright (c) 2012-2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+HTTPConnectProxiedConnectionFactory::HTTPConnectProxiedConnectionFactory(DomainNameResolver* resolver, ConnectionFactory* connectionFactory, TimerFactory* timerFactory, const std::string& proxyHost, unsigned short proxyPort, std::shared_ptr<HTTPTrafficFilter> httpTrafficFilter) : resolver_(resolver), connectionFactory_(connectionFactory), timerFactory_(timerFactory), proxyHost_(proxyHost), proxyPort_(proxyPort), authID_(""), authPassword_(""), httpTrafficFilter_(httpTrafficFilter) {

+HTTPConnectProxiedConnectionFactory::HTTPConnectProxiedConnectionFactory(DomainNameResolver* resolver, ConnectionFactory* connectionFactory, TimerFactory* timerFactory, const std::string& proxyHost, unsigned short proxyPort, const SafeString& authID, const SafeString& authPassword, std::shared_ptr<HTTPTrafficFilter> httpTrafficFilter) : resolver_(resolver), connectionFactory_(connectionFactory), timerFactory_(timerFactory), proxyHost_(proxyHost), proxyPort_(proxyPort), authID_(authID), authPassword_(authPassword), httpTrafficFilter_(httpTrafficFilter) {

+std::shared_ptr<Connection> HTTPConnectProxiedConnectionFactory::createConnection() {

+ HTTPConnectProxiedConnection::ref proxyConnection = HTTPConnectProxiedConnection::create(resolver_, connectionFactory_, timerFactory_, proxyHost_, proxyPort_, authID_, authPassword_);

+ proxyConnection->setHTTPTrafficFilter(httpTrafficFilter_);

+ return proxyConnection;

+ * Copyright (c) 2012-2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

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

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

+ class DomainNameResolver;

+ class HTTPTrafficFilter;

+ class TimerFactory;

+

+ class SWIFTEN_API HTTPConnectProxiedConnectionFactory : public ConnectionFactory {

+ public:

+ HTTPConnectProxiedConnectionFactory(DomainNameResolver* resolver, ConnectionFactory* connectionFactory, TimerFactory* timerFactory, const std::string& proxyHost, unsigned short proxyPort, std::shared_ptr<HTTPTrafficFilter> httpTrafficFilter = std::shared_ptr<HTTPTrafficFilter>());

+ HTTPConnectProxiedConnectionFactory(DomainNameResolver* resolver, ConnectionFactory* connectionFactory, TimerFactory* timerFactory, const std::string& proxyHost, unsigned short proxyPort, const SafeString& authID, const SafeString& authPassword, std::shared_ptr<HTTPTrafficFilter> httpTrafficFilter = std::shared_ptr<HTTPTrafficFilter>());

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

+ private:

+ DomainNameResolver* resolver_;

+ ConnectionFactory* connectionFactory_;

+ TimerFactory* timerFactory_;

+ std::string proxyHost_;

+ unsigned short proxyPort_;

+ SafeString authID_;

+ SafeString authPassword_;

+ std::shared_ptr<HTTPTrafficFilter> httpTrafficFilter_;

+ };

+/*

+ * Copyright (c) 2015 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

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

+

+namespace Swift {

+

+HTTPTrafficFilter::~HTTPTrafficFilter() {

+

+}

+

+}

+/*

+ * Copyright (c) 2015 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#pragma once

+

+#include <string>

+#include <utility>

+#include <vector>

+

+#include <boost/optional.hpp>

+

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

+

+namespace Swift {

+

+class SWIFTEN_API HTTPTrafficFilter {

+ public:

+ virtual ~HTTPTrafficFilter();

+ /**

+ * @brief This method is called by the HTTPConnectPRoxiedConnection on every incoming HTTP response.

+ * It can be used to insert additional HTTP requests into the HTTP CONNECT proxy initalization process.

+ * @return A vector of HTTP header fields to use in a new request. If an empty vector is returned,

+ * no new request will be send and the normal proxy logic continues.

+ */

+ virtual std::vector<std::pair<std::string, std::string> > filterHTTPResponseHeader(const std::string& statusLine, const std::vector<std::pair<std::string, std::string> >& /* responseHeader */) = 0;

+};

+

+}

+ * Copyright (c) 2010-2019 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+#include <cstring>

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

+

+ assert(length == 4 || length == 16);

+ if (length == 4) {

+ boost::asio::ip::address_v4::bytes_type data;

+ std::memcpy(data.data(), address, length);

+ address_ = boost::asio::ip::address(boost::asio::ip::address_v4(data));

+ }

+ else {

+ boost::asio::ip::address_v6::bytes_type data;

+ std::memcpy(data.data(), address, length);

+ address_ = boost::asio::ip::address(boost::asio::ip::address_v6(data));

+ }

+ std::string addressString;

+ boost::system::error_code errorCode;

+

+ addressString = address_.to_string(errorCode);

+ if (errorCode) {

+ SWIFT_LOG(debug) << "error: " << errorCode.message();

+ }

+

+ return addressString;

+ return !(address_.is_v4() && address_.to_v4().to_ulong() == 0);

+ return address_;

+ return address_ == localhost4 || address_ == localhost6;

+}

+

+boost::optional<HostAddress> HostAddress::fromString(const std::string& addressString) {

+ boost::optional<HostAddress> hostAddress;

+ boost::system::error_code errorCode;

+ boost::asio::ip::address address = boost::asio::ip::address::from_string(addressString, errorCode);

+ if (!errorCode) {

+ hostAddress = HostAddress(address);

+ }

+ return hostAddress;

+ * Copyright (c) 2010-2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+

+

+#include <boost/optional.hpp>

+ class SWIFTEN_API HostAddress {

+ public:

+ HostAddress();

+ HostAddress(const unsigned char* address, size_t length);

+ HostAddress(const boost::asio::ip::address& address);

+

+ std::string toString() const;

+ boost::asio::ip::address getRawAddress() const;

+

+ bool operator==(const HostAddress& o) const {

+ return address_ == o.address_;

+ }

+

+ bool operator<(const HostAddress& o) const {

+ return address_ < o.address_;

+ }

+

+ bool isValid() const;

+ bool isLocalhost() const;

+

+ static boost::optional<HostAddress> fromString(const std::string& addressString);

+

+ private:

+ boost::asio::ip::address address_;

+ };

+ * Copyright (c) 2010-2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+HostAddressPort::HostAddressPort(const HostAddress& address, unsigned short port) : address_(address), port_(port) {

+ address_ = HostAddress(endpoint.address());

+ port_ = endpoint.port();

+ std::string portAsString;

+ try {

+ portAsString = std::to_string(getPort());

+ } catch (boost::bad_lexical_cast&) {

+ }

+ return getAddress().toString() + ":" + portAsString;

+ * Copyright (c) 2010-2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ class SWIFTEN_API HostAddressPort {

+ public:

+ HostAddressPort(const HostAddress& address = HostAddress(), unsigned short port = 0);

+ HostAddressPort(const boost::asio::ip::tcp::endpoint& endpoint);

+

+ const HostAddress& getAddress() const {

+ return address_;

+ }

+

+ unsigned short getPort() const {

+ return port_;

+ }

+

+ bool operator==(const HostAddressPort& o) const {

+ return address_ == o.address_ && port_ == o.port_;

+ }

+

+ bool operator<(const HostAddressPort& o) const {

+ if (address_ < o.address_) {

+ return true;

+ }

+ return address_ == o.address_ && port_ < o.port_;

+ }

+

+ bool isValid() const {

+ return address_.isValid() && port_ > 0;

+ }

+

+ std::string toString() const;

+

+ private:

+ HostAddress address_;

+ unsigned short port_;

+ };

+ * Copyright (c) 2012 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ struct ToStringVisitor : public boost::static_visitor<std::string> {

+ std::string operator()(const HostAddress& address) const {

+ return address.toString();

+ }

+

+ std::string operator()(const std::string & str) const {

+ return str;

+ }

+ };

+ return boost::apply_visitor(ToStringVisitor(), address);