+#include "Swiften/Session/BasicSessionStream.h"

+

+#include <boost/bind.hpp>

+

+#include "Swiften/StreamStack/XMPPLayer.h"

+#include "Swiften/StreamStack/StreamStack.h"

+#include "Swiften/StreamStack/ConnectionLayer.h"

+#include "Swiften/StreamStack/WhitespacePingLayer.h"

+#include "Swiften/StreamStack/CompressionLayer.h"

+#include "Swiften/StreamStack/TLSLayer.h"

+#include "Swiften/StreamStack/TLSLayerFactory.h"

+

+namespace Swift {

+

+BasicSessionStream::BasicSessionStream(boost::shared_ptr<Connection> connection, PayloadParserFactoryCollection* payloadParserFactories, PayloadSerializerCollection* payloadSerializers, TLSLayerFactory* tlsLayerFactory, TimerFactory* timerFactory) : available(false), connection(connection), payloadParserFactories(payloadParserFactories), payloadSerializers(payloadSerializers), tlsLayerFactory(tlsLayerFactory), timerFactory(timerFactory) {

+}

+

+void BasicSessionStream::initialize() {

+ xmppLayer = boost::shared_ptr<XMPPLayer>(

+ new XMPPLayer(payloadParserFactories, payloadSerializers));

+ xmppLayer->onStreamStart.connect(boost::bind(&BasicSessionStream::handleStreamStartReceived, shared_from_this(), _1));

+ xmppLayer->onElement.connect(boost::bind(&BasicSessionStream::handleElementReceived, shared_from_this(), _1));

+ xmppLayer->onError.connect(boost::bind(

+ &BasicSessionStream::handleXMPPError, shared_from_this()));

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

+ xmppLayer->onWriteData.connect(boost::bind(&BasicSessionStream::handleDataWritten, shared_from_this(), _1));

+

+ connection->onDisconnected.connect(boost::bind(&BasicSessionStream::handleConnectionError, shared_from_this(), _1));

+ connectionLayer = boost::shared_ptr<ConnectionLayer>(

+ new ConnectionLayer(connection));

+

+ streamStack = new StreamStack(xmppLayer, connectionLayer);

+

+ available = true;

+}

+

+BasicSessionStream::~BasicSessionStream() {

+ delete streamStack;

+}

+

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

+ assert(available);

+ xmppLayer->writeHeader(header);

+}

+

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

+ assert(available);

+ xmppLayer->writeElement(element);

+}

+

+void BasicSessionStream::writeFooter() {

+ assert(available);

+ xmppLayer->writeFooter();

+}

+

+bool BasicSessionStream::isAvailable() {

+ return available;

+}

+

+bool BasicSessionStream::supportsTLSEncryption() {

+ return tlsLayerFactory && tlsLayerFactory->canCreate();

+}

+

+void BasicSessionStream::addTLSEncryption() {

+ assert(available);

+ tlsLayer = tlsLayerFactory->createTLSLayer();

+ if (hasTLSCertificate() && !tlsLayer->setClientCertificate(getTLSCertificate())) {

+ onError(boost::shared_ptr<Error>(new Error(Error::InvalidTLSCertificateError)));

+ }

+ else {

+ streamStack->addLayer(tlsLayer);

+ tlsLayer->onError.connect(boost::bind(&BasicSessionStream::handleTLSError, shared_from_this()));

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

+ tlsLayer->connect();

+ }

+}

+

+void BasicSessionStream::addZLibCompression() {

+ boost::shared_ptr<CompressionLayer> compressionLayer(new CompressionLayer());

+ streamStack->addLayer(compressionLayer);

+}

+

+void BasicSessionStream::setWhitespacePingEnabled(bool enabled) {

+ if (enabled) {

+ if (!whitespacePingLayer) {

+ whitespacePingLayer = boost::shared_ptr<WhitespacePingLayer>(new WhitespacePingLayer(timerFactory));

+ streamStack->addLayer(whitespacePingLayer);

+ }

+ whitespacePingLayer->setActive();

+ }

+ else if (whitespacePingLayer) {

+ whitespacePingLayer->setInactive();

+ }

+}

+

+void BasicSessionStream::resetXMPPParser() {

+ xmppLayer->resetParser();

+}

+

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

+ onStreamStartReceived(header);

+}

+

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

+ onElementReceived(element);

+}

+

+void BasicSessionStream::handleXMPPError() {

+ available = false;

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

+}

+

+void BasicSessionStream::handleTLSConnected() {

+ onTLSEncrypted();

+}

+

+void BasicSessionStream::handleTLSError() {

+ available = false;

+ onError(boost::shared_ptr<Error>(new Error(Error::TLSError)));

+}

+

+void BasicSessionStream::handleConnectionError(const boost::optional<Connection::Error>& error) {

+ available = false;

+ if (error == Connection::ReadError) {

+ onError(boost::shared_ptr<Error>(new Error(Error::ConnectionReadError)));

+ }

+ else {

+ onError(boost::shared_ptr<Error>(new Error(Error::ConnectionWriteError)));

+ }

+}

+

+void BasicSessionStream::handleDataRead(const ByteArray& data) {

+ onDataRead(String(data.getData(), data.getSize()));

+}

+

+void BasicSessionStream::handleDataWritten(const ByteArray& data) {

+ onDataWritten(String(data.getData(), data.getSize()));

+}

+

+};

+#pragma once

+

+#include <boost/shared_ptr.hpp>

+#include <boost/enable_shared_from_this.hpp>

+

+#include "Swiften/Network/Connection.h"

+#include "Swiften/Session/SessionStream.h"

+

+namespace Swift {

+ class TLSLayerFactory;

+ class TLSLayer;

+ class TimerFactory;

+ class WhitespacePingLayer;

+ class PayloadParserFactoryCollection;

+ class PayloadSerializerCollection;

+ class StreamStack;

+ class XMPPLayer;

+ class ConnectionLayer;

+ class CompressionLayer;

+

+ class BasicSessionStream :

+ public SessionStream,

+ public boost::enable_shared_from_this<BasicSessionStream> {

+ public:

+ BasicSessionStream(

+ boost::shared_ptr<Connection> connection,

+ PayloadParserFactoryCollection* payloadParserFactories,

+ PayloadSerializerCollection* payloadSerializers,

+ TLSLayerFactory* tlsLayerFactory,

+ TimerFactory* whitespacePingLayerFactory

+ );

+ ~BasicSessionStream();

+

+ void initialize();

+

+ virtual bool isAvailable();

+

+ virtual void writeHeader(const ProtocolHeader& header);

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

+ virtual void writeFooter();

+

+ virtual void addZLibCompression();

+

+ virtual bool supportsTLSEncryption();

+ virtual void addTLSEncryption();

+

+ virtual void setWhitespacePingEnabled(bool);

+

+ virtual void resetXMPPParser();

+

+ private:

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

+ void handleXMPPError();

+ void handleTLSConnected();

+ void handleTLSError();

+ void handleStreamStartReceived(const ProtocolHeader&);

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

+ void handleDataRead(const ByteArray& data);

+ void handleDataWritten(const ByteArray& data);

+

+ private:

+ bool available;

+ boost::shared_ptr<Connection> connection;

+ PayloadParserFactoryCollection* payloadParserFactories;

+ PayloadSerializerCollection* payloadSerializers;

+ TLSLayerFactory* tlsLayerFactory;

+ TimerFactory* timerFactory;

+ boost::shared_ptr<XMPPLayer> xmppLayer;

+ boost::shared_ptr<ConnectionLayer> connectionLayer;

+ StreamStack* streamStack;

+ boost::shared_ptr<CompressionLayer> compressionLayer;

+ boost::shared_ptr<TLSLayer> tlsLayer;

+ boost::shared_ptr<WhitespacePingLayer> whitespacePingLayer;

+ };

+}

+#include "Swiften/Session/Session.h"

+

+#include <boost/bind.hpp>

+

+#include "Swiften/StreamStack/XMPPLayer.h"

+#include "Swiften/StreamStack/StreamStack.h"

+

+namespace Swift {

+

+Session::Session(

+ boost::shared_ptr<Connection> connection,

+ PayloadParserFactoryCollection* payloadParserFactories,

+ PayloadSerializerCollection* payloadSerializers) :

+ connection(connection),

+ payloadParserFactories(payloadParserFactories),

+ payloadSerializers(payloadSerializers),

+ streamStack(0),

+ finishing(false) {

+}

+

+Session::~Session() {

+ delete streamStack;

+}

+

+void Session::startSession() {

+ initializeStreamStack();

+ handleSessionStarted();

+}

+

+void Session::finishSession() {

+ finishing = true;

+ connection->disconnect();

+ handleSessionFinished(boost::optional<SessionError>());

+ finishing = false;

+ onSessionFinished(boost::optional<SessionError>());

+}

+

+void Session::finishSession(const SessionError& error) {

+ finishing = true;

+ connection->disconnect();

+ handleSessionFinished(boost::optional<SessionError>(error));

+ finishing = false;

+ onSessionFinished(boost::optional<SessionError>(error));

+}

+

+void Session::initializeStreamStack() {

+ xmppLayer = boost::shared_ptr<XMPPLayer>(

+ new XMPPLayer(payloadParserFactories, payloadSerializers));

+ xmppLayer->onStreamStart.connect(

+ boost::bind(&Session::handleStreamStart, shared_from_this(), _1));

+ xmppLayer->onElement.connect(boost::bind(&Session::handleElement, shared_from_this(), _1));

+ xmppLayer->onError.connect(

+ boost::bind(&Session::finishSession, shared_from_this(), XMLError));

+ xmppLayer->onDataRead.connect(boost::bind(boost::ref(onDataRead), _1));

+ xmppLayer->onWriteData.connect(boost::bind(boost::ref(onDataWritten), _1));

+ connection->onDisconnected.connect(

+ boost::bind(&Session::handleDisconnected, shared_from_this(), _1));

+ connectionLayer = boost::shared_ptr<ConnectionLayer>(new ConnectionLayer(connection));

+ streamStack = new StreamStack(xmppLayer, connectionLayer);

+}

+

+void Session::sendElement(boost::shared_ptr<Element> stanza) {

+ xmppLayer->writeElement(stanza);

+}

+

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

+ if (connectionError) {

+ switch (*connectionError) {

+ case Connection::ReadError:

+ finishSession(ConnectionReadError);

+ break;

+ case Connection::WriteError:

+ finishSession(ConnectionWriteError);

+ break;

+ }

+ }

+ else {

+ finishSession();

+ }

+}

+

+}

+#pragma once

+

+#include <boost/shared_ptr.hpp>

+#include <boost/signal.hpp>

+#include <boost/optional.hpp>

+#include <boost/enable_shared_from_this.hpp>

+

+#include "Swiften/JID/JID.h"

+#include "Swiften/Elements/Element.h"

+#include "Swiften/Network/Connection.h"

+#include "Swiften/StreamStack/ConnectionLayer.h"

+

+namespace Swift {

+ class ProtocolHeader;

+ class StreamStack;

+ class JID;

+ class Element;

+ class ByteArray;

+ class PayloadParserFactoryCollection;

+ class PayloadSerializerCollection;

+ class XMPPLayer;

+

+ class Session : public boost::enable_shared_from_this<Session> {

+ public:

+ enum SessionError {

+ ConnectionReadError,

+ ConnectionWriteError,

+ XMLError,

+ AuthenticationFailedError,

+ NoSupportedAuthMechanismsError,

+ UnexpectedElementError,

+ ResourceBindError,

+ SessionStartError,

+ TLSError,

+ ClientCertificateLoadError,

+ ClientCertificateError

+ };

+

+ Session(

+ boost::shared_ptr<Connection> connection,

+ PayloadParserFactoryCollection* payloadParserFactories,

+ PayloadSerializerCollection* payloadSerializers);

+ virtual ~Session();

+

+ void startSession();

+ void finishSession();

+

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

+

+ const JID& getLocalJID() const {

+ return localJID;

+ }

+

+ const JID& getRemoteJID() const {

+ return remoteJID;

+ }

+

+ boost::signal<void (boost::shared_ptr<Element>)> onElementReceived;

+ boost::signal<void (const boost::optional<SessionError>&)> onSessionFinished;

+ boost::signal<void (const ByteArray&)> onDataWritten;

+ boost::signal<void (const ByteArray&)> onDataRead;

+

+ protected:

+ void setRemoteJID(const JID& j) {

+ remoteJID = j;

+ }

+

+ void setLocalJID(const JID& j) {

+ localJID = j;

+ }

+

+ void finishSession(const SessionError&);

+

+ virtual void handleSessionStarted() {}

+ virtual void handleSessionFinished(const boost::optional<SessionError>&) {}

+ virtual void handleElement(boost::shared_ptr<Element>) = 0;

+ virtual void handleStreamStart(const ProtocolHeader&) = 0;

+

+ void initializeStreamStack();

+

+ boost::shared_ptr<XMPPLayer> getXMPPLayer() const {

+ return xmppLayer;

+ }

+

+ StreamStack* getStreamStack() const {

+ return streamStack;

+ }

+

+ void setFinished();

+

+ private:

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

+

+ private:

+ JID localJID;

+ JID remoteJID;

+ boost::shared_ptr<Connection> connection;

+ PayloadParserFactoryCollection* payloadParserFactories;

+ PayloadSerializerCollection* payloadSerializers;

+ boost::shared_ptr<XMPPLayer> xmppLayer;

+ boost::shared_ptr<ConnectionLayer> connectionLayer;

+ StreamStack* streamStack;

+ bool finishing;

+ };

+}

+#include "Swiften/Session/SessionStream.h"

+

+namespace Swift {

+

+SessionStream::~SessionStream() {

+}

+

+};

+#pragma once

+

+#include <boost/signal.hpp>

+#include <boost/shared_ptr.hpp>

+

+#include "Swiften/Elements/ProtocolHeader.h"

+#include "Swiften/Elements/Element.h"

+#include "Swiften/Base/Error.h"

+#include "Swiften/TLS/PKCS12Certificate.h"

+

+namespace Swift {

+ class SessionStream {

+ public:

+ class Error : public Swift::Error {

+ public:

+ enum Type {

+ ParseError,

+ TLSError,

+ InvalidTLSCertificateError,

+ ConnectionReadError,

+ ConnectionWriteError

+ };

+

+ Error(Type type) : type(type) {}

+

+ Type type;

+ };

+

+ virtual ~SessionStream();

+

+ virtual bool isAvailable() = 0;

+

+ virtual void writeHeader(const ProtocolHeader& header) = 0;

+ virtual void writeFooter() = 0;

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

+

+ virtual void addZLibCompression() = 0;

+

+ virtual bool supportsTLSEncryption() = 0;

+ virtual void addTLSEncryption() = 0;

+ virtual void setWhitespacePingEnabled(bool enabled) = 0;

+

+ virtual void resetXMPPParser() = 0;

+

+ void setTLSCertificate(const PKCS12Certificate& cert) {

+ certificate = cert;

+ }

+

+ virtual bool hasTLSCertificate() {

+ return !certificate.isNull();

+ }

+

+

+ boost::signal<void (const ProtocolHeader&)> onStreamStartReceived;

+ boost::signal<void (boost::shared_ptr<Element>)> onElementReceived;

+ boost::signal<void (boost::shared_ptr<Error>)> onError;

+ boost::signal<void ()> onTLSEncrypted;

+ boost::signal<void (const String&)> onDataRead;

+ boost::signal<void (const String&)> onDataWritten;

+

+ protected:

+ const PKCS12Certificate& getTLSCertificate() const {

+ return certificate;

+ }

+

+ private:

+ PKCS12Certificate certificate;

+ };

+}

+#pragma once

+

+#include <iostream>

+

+#include "Swiften/Session/Session.h"

+#include "Swiften/Base/String.h"

+#include "Swiften/Base/ByteArray.h"

+

+namespace Swift {

+ class SessionTracer {

+ public:

+ SessionTracer(boost::shared_ptr<Session> session) : session(session) {

+ session->onDataRead.connect(boost::bind(&SessionTracer::printData, this, '<', _1));

+ session->onDataWritten.connect(boost::bind(&SessionTracer::printData, this, '>', _1));

+ }

+

+ private:

+ void printData(char direction, const ByteArray& data) {

+ std::cerr << direction << direction << " " << session->getLocalJID() << " ";

+ for (unsigned int i = 0; i < 72 - session->getLocalJID().toString().getLength() - session->getRemoteJID().toString().getLength(); ++i) {

+ std::cerr << direction;

+ }

+ std::cerr << " " << session->getRemoteJID()<< " " << direction << direction << std::endl;

+ std::cerr << String(data.getData(), data.getSize()) << std::endl;

+ }

+

+ boost::shared_ptr<Session> session;

+ };

+}