-#ifndef SWIFTEN_COMPRESSIONLAYER_H

-#define SWIFTEN_COMPRESSIONLAYER_H

-

-#include <boost/noncopyable.hpp>

-#include <boost/signal.hpp>

-

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

-#include "Swiften/StreamStack/StreamLayer.h"

-#include "Swiften/Compress/ZLibException.h"

-#include "Swiften/Compress/ZLibCompressor.h"

-#include "Swiften/Compress/ZLibDecompressor.h"

-

-namespace Swift {

- class ZLibCompressor;

- class ZLibDecompressor;

-

- class CompressionLayer : public StreamLayer, boost::noncopyable {

- public:

- CompressionLayer() {}

-

- virtual void writeData(const ByteArray& data) {

- try {

- onWriteData(compressor_.process(data));

- }

- catch (const ZLibException& e) {

- onError();

- }

- }

-

- virtual void handleDataRead(const ByteArray& data) {

- try {

- onDataRead(decompressor_.process(data));

- }

- catch (const ZLibException& e) {

- onError();

- }

- }

-

- public:

- boost::signal<void ()> onError;

-

- private:

- ZLibCompressor compressor_;

- ZLibDecompressor decompressor_;

- };

-}

-

-#endif

-#pragma once

-

-#include <boost/signal.hpp>

-#include <boost/shared_ptr.hpp>

-

-#include "Swiften/StreamStack/LowLayer.h"

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

-

-namespace Swift {

- class ConnectionLayer : public LowLayer {

- public:

- ConnectionLayer(boost::shared_ptr<Connection> connection) : connection(connection) {

- connection->onDataRead.connect(onDataRead);

- }

-

- void writeData(const ByteArray& data) {

- connection->write(data);

- }

-

- private:

- boost::shared_ptr<Connection> connection;

- };

-}

-#include "Swiften/StreamStack/HighLayer.h"

-

-namespace Swift {

-

-HighLayer::~HighLayer() {

-}

-

-}

-#ifndef SWIFTEN_HIGHLAYER_H

-#define SWIFTEN_HIGHLAYER_H

-

-#include <boost/signal.hpp>

-

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

-

-namespace Swift {

- class HighLayer {

- public:

- virtual ~HighLayer();

-

- virtual void handleDataRead(const ByteArray& data) = 0;

-

- boost::signal<void (const ByteArray&)> onWriteData;

- };

-}

-

-#endif

-#include "Swiften/StreamStack/LowLayer.h"

-

-namespace Swift {

-

-LowLayer::~LowLayer() {

-}

-

-}

-#ifndef SWIFTEN_LOWLAYER_H

-#define SWIFTEN_LOWLAYER_H

-

-#include <boost/signal.hpp>

-

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

-

-namespace Swift {

- class LowLayer {

- public:

- virtual ~LowLayer();

-

- virtual void writeData(const ByteArray& data) = 0;

-

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

- };

-}

-

-#endif

-#include "Swiften/StreamStack/OpenSSLLayer.h"

-

-namespace Swift {

-

-OpenSSLLayer::OpenSSLLayer() {

- context_.onDataForNetwork.connect(onWriteData);

- context_.onDataForApplication.connect(onDataRead);

- context_.onConnected.connect(onConnected);

- context_.onError.connect(onError);

-}

-

-void OpenSSLLayer::connect() {

- context_.connect();

-}

-

-void OpenSSLLayer::writeData(const ByteArray& data) {

- context_.handleDataFromApplication(data);

-}

-

-void OpenSSLLayer::handleDataRead(const ByteArray& data) {

- context_.handleDataFromNetwork(data);

-}

-

-bool OpenSSLLayer::setClientCertificate(const PKCS12Certificate& certificate) {

- return context_.setClientCertificate(certificate);

-}

-

-}

-#ifndef SWIFTEN_OpenSSLLayer_H

-#define SWIFTEN_OpenSSLLayer_H

-

-#include <boost/noncopyable.hpp>

-#include <boost/signal.hpp>

-

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

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

-#include "Swiften/TLS/OpenSSL/OpenSSLContext.h"

-

-namespace Swift {

- class OpenSSLLayer : public TLSLayer, boost::noncopyable {

- public:

- OpenSSLLayer();

-

- virtual void connect();

- virtual bool setClientCertificate(const PKCS12Certificate&);

-

- virtual void writeData(const ByteArray& data);

- virtual void handleDataRead(const ByteArray& data);

-

- private:

- OpenSSLContext context_;

- };

-}

-

-#endif

-#include "Swiften/StreamStack/PlatformTLSLayerFactory.h"

-

-#include <cassert>

-

-#ifdef HAVE_OPENSSL

-#include "Swiften/StreamStack/OpenSSLLayer.h"

-#endif

-

-namespace Swift {

-

-PlatformTLSLayerFactory::PlatformTLSLayerFactory() {

-}

-

-bool PlatformTLSLayerFactory::canCreate() const {

-#ifdef HAVE_OPENSSL

- return true;

-#else

- return false;

-#endif

-}

-

-boost::shared_ptr<TLSLayer> PlatformTLSLayerFactory::createTLSLayer() {

-#ifdef HAVE_OPENSSL

- return boost::shared_ptr<TLSLayer>(new OpenSSLLayer());

-#else

- assert(false);

- return boost::shared_ptr<TLSLayer>();

-#endif

-}

-

-}

-#pragma once

-

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

-

-namespace Swift {

- class PlatformTLSLayerFactory : public TLSLayerFactory {

- public:

- PlatformTLSLayerFactory();

-

- bool canCreate() const;

- virtual boost::shared_ptr<TLSLayer> createTLSLayer();

- };

-}

-Import("swiften_env")

-

-myenv = swiften_env.Clone()

-myenv.MergeFlags(swiften_env["OPENSSL_FLAGS"])

-

-sources = [

- "HighLayer.cpp",

- "LowLayer.cpp",

- "PlatformTLSLayerFactory.cpp",

- "StreamStack.cpp",

- "TLSLayerFactory.cpp",

- "WhitespacePingLayer.cpp",

- "XMPPLayer.cpp",

- ]

-

-if myenv.get("HAVE_OPENSSL", 0) :

- myenv.Append(CPPDEFINES = "HAVE_OPENSSL")

- sources += ["OpenSSLLayer.cpp"]

-

-objects = myenv.StaticObject(sources)

-swiften_env.Append(SWIFTEN_OBJECTS = [objects])

-#ifndef SWIFTEN_STREAMLAYER_H

-#define SWIFTEN_STREAMLAYER_H

-

-#include <boost/signal.hpp>

-

-#include "Swiften/StreamStack/LowLayer.h"

-#include "Swiften/StreamStack/HighLayer.h"

-

-namespace Swift {

- class StreamLayer : public LowLayer, public HighLayer {

- public:

- StreamLayer() {}

- };

-}

-

-#endif

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

-

-#include <boost/bind.hpp>

-

-#include "Swiften/Base/foreach.h"

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

-#include "Swiften/StreamStack/LowLayer.h"

-#include "Swiften/StreamStack/StreamLayer.h"

-

-namespace Swift {

-

-StreamStack::StreamStack(boost::shared_ptr<XMPPLayer> xmppLayer, boost::shared_ptr<LowLayer> physicalLayer) : xmppLayer_(xmppLayer), physicalLayer_(physicalLayer) {

- xmppReadSlotConnection_ = physicalLayer_->onDataRead.connect(boost::bind(&XMPPLayer::parseData, xmppLayer_, _1));

- xmppWriteSignalConnection_ = xmppLayer_->onWriteData.connect(boost::bind(&LowLayer::writeData, physicalLayer_, _1));

-}

-

-StreamStack::~StreamStack() {

- // Disconnect the write signal connections to break cyclic signal

- // dependencies. The read signal connections have

- // to remain, since these can be reached from the main event loop.

- xmppWriteSignalConnection_.disconnect();

- foreach(const boost::bsignals::connection& connection, writeSignalConnections_) {

- connection.disconnect();

- }

-}

-

-void StreamStack::addLayer(boost::shared_ptr<StreamLayer> newLayer) {

- xmppReadSlotConnection_.disconnect();

- xmppWriteSignalConnection_.disconnect();

-

- boost::shared_ptr<LowLayer> lowLayer = (layers_.empty() ? physicalLayer_ : *layers_.rbegin());

-

- lowLayer->onDataRead.connect(boost::bind(&HighLayer::handleDataRead, newLayer, _1), boost::bsignals::at_front);

- writeSignalConnections_.push_back(newLayer->onWriteData.connect(boost::bind(&LowLayer::writeData, lowLayer, _1), boost::bsignals::at_front));

- xmppWriteSignalConnection_ = xmppLayer_->onWriteData.connect(boost::bind(&LowLayer::writeData, newLayer, _1), boost::bsignals::at_front);

- xmppReadSlotConnection_ = newLayer->onDataRead.connect(boost::bind(&XMPPLayer::parseData, xmppLayer_, _1), boost::bsignals::at_front);

- layers_.push_back(newLayer);

-}

-

-}

-#pragma once

-

-#include <boost/shared_ptr.hpp>

-#include <boost/signal.hpp>

-#include <vector>

-

-#include "Swiften/Elements/Stanza.h"

-#include "Swiften/Base/foreach.h"

-

-namespace Swift {

- class XMPPLayer;

- class LowLayer;

- class StreamLayer;

-

- class StreamStack {

- public:

- StreamStack(boost::shared_ptr<XMPPLayer> xmppLayer, boost::shared_ptr<LowLayer> physicalLayer);

- ~StreamStack();

-

- void addLayer(boost::shared_ptr<StreamLayer>);

-

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

- return xmppLayer_;

- }

-

- template<typename T> boost::shared_ptr<T> getLayer() {

- foreach(const boost::shared_ptr<StreamLayer>& streamLayer, layers_) {

- boost::shared_ptr<T> layer = boost::dynamic_pointer_cast<T>(streamLayer);

- if (layer) {

- return layer;

- }

- }

- return boost::shared_ptr<T>();

- }

-

- private:

- boost::shared_ptr<XMPPLayer> xmppLayer_;

- boost::shared_ptr<LowLayer> physicalLayer_;

- std::vector< boost::shared_ptr<StreamLayer> > layers_;

- boost::bsignals::connection xmppReadSlotConnection_;

- boost::bsignals::connection xmppWriteSignalConnection_;

- std::vector< boost::bsignals::connection > writeSignalConnections_;

- };

-}

-#ifndef SWIFTEN_TLSLayer_H

-#define SWIFTEN_TLSLayer_H

-

-#include "Swiften/StreamStack/StreamLayer.h"

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

-

-namespace Swift {

- class TLSLayer : public StreamLayer {

- public:

- virtual void connect() = 0;

- virtual bool setClientCertificate(const PKCS12Certificate&) = 0;

-

- public:

- boost::signal<void ()> onError;

- boost::signal<void ()> onConnected;

- };

-}

-

-#endif

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

-

-namespace Swift {

-

-TLSLayerFactory::~TLSLayerFactory() {

-}

-

-}

-#pragma once

-

-#include <boost/shared_ptr.hpp>

-

-namespace Swift {

- class TLSLayer;

-

- class TLSLayerFactory {

- public:

- virtual ~TLSLayerFactory();

- virtual bool canCreate() const = 0;

-

- virtual boost::shared_ptr<TLSLayer> createTLSLayer() = 0;

- };

-}

-#include <vector>

-#include <boost/bind.hpp>

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

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

-

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

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

-#include "Swiften/StreamStack/LowLayer.h"

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

-#include "Swiften/StreamStack/StreamLayer.h"

-#include "Swiften/Parser/PayloadParsers/FullPayloadParserFactoryCollection.h"

-#include "Swiften/Serializer/PayloadSerializers/FullPayloadSerializerCollection.h"

-

-using namespace Swift;

-

-class StreamStackTest : public CppUnit::TestFixture

-{

- CPPUNIT_TEST_SUITE(StreamStackTest);

- CPPUNIT_TEST(testWriteData_NoIntermediateStreamStack);

- CPPUNIT_TEST(testWriteData_OneIntermediateStream);

- CPPUNIT_TEST(testWriteData_TwoIntermediateStreamStack);

- CPPUNIT_TEST(testReadData_NoIntermediateStreamStack);

- CPPUNIT_TEST(testReadData_OneIntermediateStream);

- CPPUNIT_TEST(testReadData_TwoIntermediateStreamStack);

- CPPUNIT_TEST(testAddLayer_ExistingOnWriteDataSlot);

- CPPUNIT_TEST_SUITE_END();

-

- public:

- StreamStackTest() {}

-

- void setUp() {

- physicalStream_ = boost::shared_ptr<TestLowLayer>(new TestLowLayer());

- xmppStream_ = boost::shared_ptr<XMPPLayer>(new XMPPLayer(&parserFactories_, &serializers_));

- elementsReceived_ = 0;

- dataWriteReceived_ = 0;

- }

-

- void tearDown() {

- }

-

- void testWriteData_NoIntermediateStreamStack() {

- StreamStack testling(xmppStream_, physicalStream_);

-

- xmppStream_->writeData("foo");

-

- CPPUNIT_ASSERT_EQUAL(static_cast<size_t>(1), physicalStream_->data_.size());

- CPPUNIT_ASSERT_EQUAL(ByteArray("foo"), physicalStream_->data_[0]);

- }

-

- void testWriteData_OneIntermediateStream() {

- StreamStack testling(xmppStream_, physicalStream_);

- boost::shared_ptr<MyStreamLayer> xStream(new MyStreamLayer("X"));

- testling.addLayer(xStream);

-

- xmppStream_->writeData("foo");

-

- CPPUNIT_ASSERT_EQUAL(static_cast<size_t>(1), physicalStream_->data_.size());

- CPPUNIT_ASSERT_EQUAL(ByteArray("Xfoo"), physicalStream_->data_[0]);

- }

-

- void testWriteData_TwoIntermediateStreamStack() {

- StreamStack testling(xmppStream_, physicalStream_);

- boost::shared_ptr<MyStreamLayer> xStream(new MyStreamLayer("X"));

- boost::shared_ptr<MyStreamLayer> yStream(new MyStreamLayer("Y"));

- testling.addLayer(xStream);

- testling.addLayer(yStream);

-

- xmppStream_->writeData("foo");

-

- CPPUNIT_ASSERT_EQUAL(static_cast<size_t>(1), physicalStream_->data_.size());

- CPPUNIT_ASSERT_EQUAL(ByteArray("XYfoo"), physicalStream_->data_[0]);

- }

-

- void testReadData_NoIntermediateStreamStack() {

- StreamStack testling(xmppStream_, physicalStream_);

- xmppStream_->onElement.connect(boost::bind(&StreamStackTest::handleElement, this, _1));

-

- physicalStream_->onDataRead(ByteArray("<stream:stream xmlns:stream='http://etherx.jabber.org/streams'><presence/>"));

-

- CPPUNIT_ASSERT_EQUAL(1, elementsReceived_);

- }

-

- void testReadData_OneIntermediateStream() {

- StreamStack testling(xmppStream_, physicalStream_);

- xmppStream_->onElement.connect(boost::bind(&StreamStackTest::handleElement, this, _1));

- boost::shared_ptr<MyStreamLayer> xStream(new MyStreamLayer("<"));

- testling.addLayer(xStream);

-

- physicalStream_->onDataRead(ByteArray("stream:stream xmlns:stream='http://etherx.jabber.org/streams'><presence/>"));

-

- CPPUNIT_ASSERT_EQUAL(1, elementsReceived_);

- }

-

- void testReadData_TwoIntermediateStreamStack() {

- StreamStack testling(xmppStream_, physicalStream_);

- xmppStream_->onElement.connect(boost::bind(&StreamStackTest::handleElement, this, _1));

- boost::shared_ptr<MyStreamLayer> xStream(new MyStreamLayer("s"));

- boost::shared_ptr<MyStreamLayer> yStream(new MyStreamLayer("<"));

- testling.addLayer(xStream);

- testling.addLayer(yStream);

-

- physicalStream_->onDataRead(ByteArray("tream:stream xmlns:stream='http://etherx.jabber.org/streams'><presence/>"));

-

- CPPUNIT_ASSERT_EQUAL(1, elementsReceived_);

- }

-

- void testAddLayer_ExistingOnWriteDataSlot() {

- StreamStack testling(xmppStream_, physicalStream_);

- xmppStream_->onWriteData.connect(boost::bind(&StreamStackTest::handleWriteData, this, _1));

- boost::shared_ptr<MyStreamLayer> xStream(new MyStreamLayer("X"));

- testling.addLayer(xStream);

-

- xmppStream_->writeData("foo");

-

- CPPUNIT_ASSERT_EQUAL(1, dataWriteReceived_);

- }

-

- void handleElement(boost::shared_ptr<Element>) {

- ++elementsReceived_;

- }

-

- void handleWriteData(ByteArray) {

- ++dataWriteReceived_;

- }

-

- private:

- class MyStreamLayer : public StreamLayer {

- public:

- MyStreamLayer(const String& prepend) : prepend_(prepend) {

- }

-

- virtual void writeData(const ByteArray& data) {

- onWriteData(ByteArray(prepend_) + data);

- }

-

- virtual void handleDataRead(const ByteArray& data) {

- onDataRead(ByteArray(prepend_) + data);

- }

-

- private:

- String prepend_;

- };

-

- class TestLowLayer : public LowLayer {

- public:

- TestLowLayer() {

- }

-

- virtual void writeData(const ByteArray& data) {

- data_.push_back(data);

- }

-

- std::vector<ByteArray> data_;

- };

-

- private:

- FullPayloadParserFactoryCollection parserFactories_;

- FullPayloadSerializerCollection serializers_;

- boost::shared_ptr<TestLowLayer> physicalStream_;

- boost::shared_ptr<XMPPLayer> xmppStream_;

- int elementsReceived_;

- int dataWriteReceived_;

-};

-

-CPPUNIT_TEST_SUITE_REGISTRATION(StreamStackTest);

-#include <vector>

-#include <boost/bind.hpp>

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

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

-

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

-#include "Swiften/Elements/Presence.h"

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

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

-#include "Swiften/Parser/PayloadParsers/FullPayloadParserFactoryCollection.h"

-#include "Swiften/Serializer/PayloadSerializers/FullPayloadSerializerCollection.h"

-

-using namespace Swift;

-

-class XMPPLayerTest : public CppUnit::TestFixture

-{

- CPPUNIT_TEST_SUITE(XMPPLayerTest);

- CPPUNIT_TEST(testParseData_Error);

- CPPUNIT_TEST(testResetParser);

- CPPUNIT_TEST(testResetParser_FromSlot);

- CPPUNIT_TEST(testWriteHeader);

- CPPUNIT_TEST(testWriteElement);

- CPPUNIT_TEST(testWriteFooter);

- CPPUNIT_TEST_SUITE_END();

-

- public:

- XMPPLayerTest() {}

-

- void setUp() {

- testling_ = new XMPPLayer(&parserFactories_, &serializers_);

- elementsReceived_ = 0;

- dataReceived_ = "";

- errorReceived_ = 0;

- }

-

- void tearDown() {

- delete testling_;

- }

-

- void testParseData_Error() {

- testling_->onError.connect(boost::bind(&XMPPLayerTest::handleError, this));

-

- testling_->parseData("<iq>");

-

- CPPUNIT_ASSERT_EQUAL(1, errorReceived_);

- }

-

- void testResetParser() {

- testling_->onElement.connect(boost::bind(&XMPPLayerTest::handleElement, this, _1));

- testling_->onError.connect(boost::bind(&XMPPLayerTest::handleError, this));

-

- testling_->parseData("<stream:stream to=\"example.com\" xmlns=\"jabber:client\" xmlns:stream=\"http://etherx.jabber.org/streams\" >");

- testling_->resetParser();

- testling_->parseData("<stream:stream to=\"example.com\" xmlns=\"jabber:client\" xmlns:stream=\"http://etherx.jabber.org/streams\" >");

- testling_->parseData("<presence/>");

-

- CPPUNIT_ASSERT_EQUAL(1, elementsReceived_);

- CPPUNIT_ASSERT_EQUAL(0, errorReceived_);

- }

-

- void testResetParser_FromSlot() {

- testling_->onElement.connect(boost::bind(&XMPPLayerTest::handleElementAndReset, this, _1));

- testling_->parseData("<stream:stream to=\"example.com\" xmlns=\"jabber:client\" xmlns:stream=\"http://etherx.jabber.org/streams\" ><presence/>");

- testling_->parseData("<stream:stream to=\"example.com\" xmlns=\"jabber:client\" xmlns:stream=\"http://etherx.jabber.org/streams\" ><presence/>");

-

- CPPUNIT_ASSERT_EQUAL(2, elementsReceived_);

- CPPUNIT_ASSERT_EQUAL(0, errorReceived_);

- }

-

- void testWriteHeader() {

- testling_->onWriteData.connect(boost::bind(&XMPPLayerTest::handleWriteData, this, _1));

- ProtocolHeader header;

- header.setTo("example.com");

- testling_->writeHeader(header);

-

- CPPUNIT_ASSERT_EQUAL(String("<?xml version=\"1.0\"?><stream:stream xmlns=\"jabber:client\" xmlns:stream=\"http://etherx.jabber.org/streams\" to=\"example.com\" version=\"1.0\">"), dataReceived_);

- }

-

- void testWriteElement() {

- testling_->onWriteData.connect(boost::bind(&XMPPLayerTest::handleWriteData, this, _1));

- testling_->writeElement(boost::shared_ptr<Presence>(new Presence()));

-

- CPPUNIT_ASSERT_EQUAL(String("<presence/>"), dataReceived_);

- }

-

- void testWriteFooter() {

- testling_->onWriteData.connect(boost::bind(&XMPPLayerTest::handleWriteData, this, _1));

- testling_->writeFooter();

-

- CPPUNIT_ASSERT_EQUAL(String("</stream:stream>"), dataReceived_);

- }

-

- void handleElement(boost::shared_ptr<Element>) {

- ++elementsReceived_;

- }

-

- void handleElementAndReset(boost::shared_ptr<Element>) {

- ++elementsReceived_;

- testling_->resetParser();

- }

-

- void handleWriteData(ByteArray ba) {

- dataReceived_ += std::string(ba.getData(), ba.getSize());

- }

-

- void handleError() {

- ++errorReceived_;

- }

-

- private:

- FullPayloadParserFactoryCollection parserFactories_;

- FullPayloadSerializerCollection serializers_;

- XMPPLayer* testling_;

- int elementsReceived_;

- String dataReceived_;

- int errorReceived_;

-};

-

-CPPUNIT_TEST_SUITE_REGISTRATION(XMPPLayerTest);

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

-

-#include <boost/bind.hpp>

-

-#include "Swiften/Network/TimerFactory.h"

-#include "Swiften/Network/Timer.h"

-

-namespace Swift {

-

-static const int TIMEOUT_MILLISECONDS = 60000;

-

-WhitespacePingLayer::WhitespacePingLayer(TimerFactory* timerFactory) : isActive(false) {

- timer = timerFactory->createTimer(TIMEOUT_MILLISECONDS);

- timer->onTick.connect(boost::bind(&WhitespacePingLayer::handleTimerTick, this));

-}

-

-void WhitespacePingLayer::writeData(const ByteArray& data) {

- onWriteData(data);

-}

-

-void WhitespacePingLayer::handleDataRead(const ByteArray& data) {

- onDataRead(data);

-}

-

-void WhitespacePingLayer::handleTimerTick() {

- onWriteData(" ");

-}

-

-void WhitespacePingLayer::setActive() {

- isActive = true;

- timer->start();

-}

-

-void WhitespacePingLayer::setInactive() {

- timer->stop();

- isActive = false;

-}

-

-}

-#pragma once

-

-#include <boost/noncopyable.hpp>

-#include <boost/shared_ptr.hpp>

-

-#include "Swiften/StreamStack/StreamLayer.h"

-

-namespace Swift {

- class Timer;

- class TimerFactory;

-

- class WhitespacePingLayer : public StreamLayer, boost::noncopyable {

- public:

- WhitespacePingLayer(TimerFactory* timerFactory);

-

- void setActive();

- void setInactive();

- void writeData(const ByteArray& data);

- void handleDataRead(const ByteArray& data);

-

- bool getIsActive() const {

- return isActive;

- }

-

- private:

- void handleTimerTick();

-

- private:

- bool isActive;

- boost::shared_ptr<Timer> timer;

- };

-}

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

-#include "Swiften/Parser/XMPPParser.h"

-#include "Swiften/Serializer/XMPPSerializer.h"

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

-

-namespace Swift {

-

-XMPPLayer::XMPPLayer(

- PayloadParserFactoryCollection* payloadParserFactories,

- PayloadSerializerCollection* payloadSerializers) :

- payloadParserFactories_(payloadParserFactories),

- payloadSerializers_(payloadSerializers),

- resetParserAfterParse_(false),

- inParser_(false) {

- xmppParser_ = new XMPPParser(this, payloadParserFactories_);

- xmppSerializer_ = new XMPPSerializer(payloadSerializers_);

-}

-

-XMPPLayer::~XMPPLayer() {

- delete xmppSerializer_;

- delete xmppParser_;

-}

-

-void XMPPLayer::writeHeader(const ProtocolHeader& header) {

- onWriteData(ByteArray(xmppSerializer_->serializeHeader(header)));

-}

-

-void XMPPLayer::writeFooter() {

- onWriteData(ByteArray(xmppSerializer_->serializeFooter()));

-}

-

-void XMPPLayer::writeElement(boost::shared_ptr<Element> element) {

- onWriteData(ByteArray(xmppSerializer_->serializeElement(element)));

-}

-

-void XMPPLayer::writeData(const String& data) {

- onWriteData(ByteArray(data));

-}

-

-void XMPPLayer::parseData(ByteArray data) {

- onDataRead(data);

- inParser_ = true;

- if (!xmppParser_->parse(String(data.getData(), data.getSize()))) {

- inParser_ = false;

- onError();

- return;

- }

- inParser_ = false;

- if (resetParserAfterParse_) {

- doResetParser();

- }

-}

-

-void XMPPLayer::doResetParser() {

- delete xmppParser_;

- xmppParser_ = new XMPPParser(this, payloadParserFactories_);

- resetParserAfterParse_ = false;

-}

-

-void XMPPLayer::handleStreamStart(const ProtocolHeader& header) {

- onStreamStart(header);

-}

-

-void XMPPLayer::handleElement(boost::shared_ptr<Element> stanza) {

- onElement(stanza);

-}

-

-void XMPPLayer::handleStreamEnd() {

-}

-

-void XMPPLayer::resetParser() {

- if (inParser_) {

- resetParserAfterParse_ = true;

- }

- else {

- doResetParser();

- }

-}

-

-}

-#pragma once

-

-#include <boost/shared_ptr.hpp>

-#include <boost/signal.hpp>

-#include <boost/noncopyable.hpp>

-

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

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

-#include "Swiften/Parser/XMPPParserClient.h"

-

-namespace Swift {

- class ProtocolHeader;

- class XMPPParser;

- class PayloadParserFactoryCollection;

- class XMPPSerializer;

- class PayloadSerializerCollection;

-

- class XMPPLayer : public XMPPParserClient, boost::noncopyable {

- public:

- XMPPLayer(

- PayloadParserFactoryCollection* payloadParserFactories,

- PayloadSerializerCollection* payloadSerializers);

- ~XMPPLayer();

-

- void writeHeader(const ProtocolHeader& header);

- void writeFooter();

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

- void writeData(const String& data);

-

- void parseData(ByteArray data);

- void resetParser();

-

- public:

- boost::signal<void (const ProtocolHeader&)> onStreamStart;

- boost::signal<void (boost::shared_ptr<Element>)> onElement;

- boost::signal<void (const ByteArray&)> onWriteData;

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

- boost::signal<void ()> onError;

-

- private:

- void handleStreamStart(const ProtocolHeader&);

- void handleElement(boost::shared_ptr<Element>);

- void handleStreamEnd();

-

- void doResetParser();

-

- private:

- PayloadParserFactoryCollection* payloadParserFactories_;

- XMPPParser* xmppParser_;

- PayloadSerializerCollection* payloadSerializers_;

- XMPPSerializer* xmppSerializer_;

- bool resetParserAfterParse_;

- bool inParser_;

- };

-}