/*

* Licensed under the GNU General Public License v3.

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

if (isInitialized()) {

onElementReceived(element);

/*

* Licensed under the GNU General Public License v3.

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

namespace Swift {

class ProtocolHeader;

class Stanza;

class PayloadParserFactoryCollection;

private:

void handleStreamStart(const ProtocolHeader& header);

/*

* Licensed under the GNU General Public License v3.

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

}

boost::shared_ptr<Stanza> stanza(boost::dynamic_pointer_cast<Stanza>(element));

if (!stanza) {

/*

* Licensed under the GNU General Public License v3.

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

#include "Swiften/Network/Connection.h"

#include "Swiften/Session/SessionTracer.h"

#include "Swiften/Elements/Presence.h"

#include "Swiften/Elements/RosterPayload.h"

}

boost::shared_ptr<Stanza> stanza = boost::dynamic_pointer_cast<Stanza>(element);

if (!stanza) {

}

if (boost::shared_ptr<Stanza> stanza = boost::dynamic_pointer_cast<Stanza>(element)) {

JID fromJID = session->getRemoteJID();

selfJID, connector->getService().getJID(), connector->getConnection(),

&payloadParserFactories, &payloadSerializers, &xmlParserFactory));

outgoingSession->queueElement(element);

}

/*

* Licensed under the GNU General Public License v3.

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

void handleSessionStarted();

void handleSessionFinished(boost::shared_ptr<ServerFromClientSession>);

void handleRosterChanged(boost::shared_ptr<RosterPayload> roster);

void handlePresenceChanged(boost::shared_ptr<Presence> presence);

void handleNewLinkLocalConnection(boost::shared_ptr<Connection> connection);

void handleLinkLocalSessionFinished(boost::shared_ptr<Session> session);

void handleConnectFinished(boost::shared_ptr<LinkLocalConnector> connector, bool error);

void handleClientConnectionServerStopped(

/*

* Licensed under the GNU General Public License v3.

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

}

if (boost::shared_ptr<Stanza> stanza = boost::dynamic_pointer_cast<Stanza>(element)) {

if (stanzaAckResponder_) {

/*

* Licensed under the GNU General Public License v3.

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

#include <string>

#include <Swiften/JID/JID.h>

#include <Swiften/StreamManagement/StanzaAckRequester.h>

#include <Swiften/StreamManagement/StanzaAckResponder.h>

void sendStreamHeader();

void handleStreamStart(const ProtocolHeader&);

void handleStreamClosed(boost::shared_ptr<Swift::Error>);

/*

* Licensed under the GNU General Public License v3.

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

public:

struct Event {

Event(const ProtocolHeader& header) : header(header), footer(false) {}

Event() : footer(true) {}

boost::optional<ProtocolHeader> header;

bool footer;

}

receivedEvents.push_back(Event(element));

}

/*

* Licensed under the GNU General Public License v3.

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

}

if (boost::shared_ptr<Stanza> stanza = boost::dynamic_pointer_cast<Stanza>(element)) {

if (getState() == Initialized) {

/*

* Licensed under the GNU General Public License v3.

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

#include <Swiften/Base/Error.h>

#include <string>

#include <Swiften/Elements/Stanza.h>

#include <Swiften/Session/SessionStream.h>

void sendStreamHeader();

void handleStreamStart(const ProtocolHeader&);

void handleStreamClosed(boost::shared_ptr<Swift::Error>);

/*

* Licensed under the GNU General Public License v3.

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

public:

struct Event {

Event(const ProtocolHeader& header) : header(header), footer(false) {}

Event() : footer(true) {}

boost::optional<ProtocolHeader> header;

bool footer;

}

receivedEvents.push_back(Event(element));

}

/*

* Licensed under the GNU General Public License v3.

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

#include <vector>

namespace Swift {

public:

AuthChallenge() {

/*

* Licensed under the GNU General Public License v3.

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

#include <boost/shared_ptr.hpp>

namespace Swift {

public:

typedef boost::shared_ptr<AuthFailure> ref;

/*

* Licensed under the GNU General Public License v3.

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

#include <boost/optional.hpp>

#include <Swiften/Base/SafeByteArray.h>

namespace Swift {

public:

AuthRequest(const std::string& mechanism = "") : mechanism_(mechanism) {

/*

* Licensed under the GNU General Public License v3.

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

#include <boost/optional.hpp>

#include <Swiften/Base/SafeByteArray.h>

namespace Swift {

public:

AuthResponse() {

/*

* Licensed under the GNU General Public License v3.

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

#include <boost/optional.hpp>

namespace Swift {

public:

AuthSuccess() {}

/*

* Licensed under the GNU General Public License v3.

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

#include <string>

namespace Swift {

public:

typedef boost::shared_ptr<ComponentHandshake> ref;

/*

* Licensed under the GNU General Public License v3.

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

namespace Swift {

public:

CompressFailure() {}

/*

* Licensed under the GNU General Public License v3.

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

#pragma once

namespace Swift {

{

public:

/*

* Licensed under the GNU General Public License v3.

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

#pragma once

namespace Swift {

public:

Compressed() {}

/*

* Licensed under the GNU General Public License v3.

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

#pragma once

namespace Swift {

public:

EnableStreamManagement() {}

#include <Swiften/Base/API.h>

namespace Swift {

public:

typedef boost::shared_ptr<Payload> ref;

/*

* Licensed under the GNU General Public License v3.

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

#include <Swiften/Base/API.h>

#include <Swiften/JID/JID.h>

class Payload;

public:

typedef boost::shared_ptr<Stanza> ref;

/*

* Licensed under the GNU General Public License v3.

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

#include <boost/shared_ptr.hpp>

namespace Swift {

public:

typedef boost::shared_ptr<StanzaAck> ref;

/*

* Licensed under the GNU General Public License v3.

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

#pragma once

namespace Swift {

};

}

/*

* Licensed under the GNU General Public License v3.

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

#pragma once

namespace Swift {

public:

StartTLSFailure() {}

/*

* Licensed under the GNU General Public License v3.

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

#pragma once

namespace Swift {

public:

StartTLSRequest() {}

/*

* Licensed under the GNU General Public License v3.

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

#include <boost/shared_ptr.hpp>

#include <string>

namespace Swift {

public:

typedef boost::shared_ptr<StreamError> ref;

/*

* Licensed under the GNU General Public License v3.

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

#include <Swiften/Base/API.h>

namespace Swift {

public:

typedef boost::shared_ptr<StreamFeatures> ref;

/*

* Licensed under the GNU General Public License v3.

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

#include <Swiften/Base/API.h>

namespace Swift {

public:

StreamManagementEnabled();

/*

* Licensed under the GNU General Public License v3.

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

#pragma once

namespace Swift {

public:

StreamManagementFailed() {}

/*

* Licensed under the GNU General Public License v3.

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

#include <boost/optional.hpp>

namespace Swift {

public:

StreamResume();

/*

* Licensed under the GNU General Public License v3.

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

#include <boost/optional.hpp>

namespace Swift {

public:

StreamResumed();

/*

* Licensed under the GNU General Public License v3.

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

#pragma once

namespace Swift {

public:

TLSProceed() {}

/*

* Licensed under the GNU General Public License v3.

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

*/

namespace Swift {

}

namespace Swift {

public:

};

}

/*

* Licensed under the GNU General Public License v3.

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

#pragma once

namespace Swift {

public:

UnknownElement() {}

/*

* Licensed under the GNU General Public License v3.

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

std::cout << "-> Stream start" << std::endl;

}

std::cout << "-> Element " << typeid(*element.get()).name() << std::endl;

}

/*

* Licensed under the GNU General Public License v3.

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

}

boost::shared_ptr<Stanza> stanza = boost::dynamic_pointer_cast<Stanza>(element);

// If we get our first stanza before streamfeatures, our session is implicitly

/*

* Licensed under the GNU General Public License v3.

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

class ProtocolHeader;

class XMLParserFactory;

class PayloadParserFactoryCollection;

class PayloadSerializerCollection;

private:

void handleStreamStart(const ProtocolHeader&);

void setInitialized();

/*

* Licensed under the GNU General Public License v3.

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

}

queuedElements.push_back(element);

}

/*

* Licensed under the GNU General Public License v3.

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

class ConnectionFactory;

class HostAddress;

class PayloadParserFactoryCollection;

class PayloadSerializerCollection;

void connect();

void cancel();

return queuedElements;

}

boost::shared_ptr<Connection> connection;

boost::bsignals::connection connectionConnectFinishedConnection;

};

}

/*

* Licensed under the GNU General Public License v3.

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

void OutgoingLinkLocalSession::handleStreamStart(const ProtocolHeader&) {

sendElement(stanza);

}

}

onElementReceived(element);

}

queuedElements_.push_back(element);

}

/*

* Licensed under the GNU General Public License v3.

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

class ConnectionFactory;

class XMLParserFactory;

class PayloadParserFactoryCollection;

class PayloadSerializerCollection;

XMLParserFactory* xmlParserFactory);

private:

void handleSessionStarted();

void handleStreamStart(const ProtocolHeader&);

private:

};

}

/*

* Licensed under the GNU General Public License v3.

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

#include <string>

#include <Swiften/Base/API.h>

#include <Swiften/Parser/AttributeMap.h>

virtual void handleCharacterData(const std::string& data) = 0;

};

}

/*

* Licensed under the GNU General Public License v3.

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

}

return stanza_;

}

/*

* Licensed under the GNU General Public License v3.

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

}

return stanza_;

}

/*

* Licensed under the GNU General Public License v3.

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

void handleCharacterData(const std::string& data);

virtual void handleStanzaAttributes(const AttributeMap&) {}

/*

* Licensed under the GNU General Public License v3.

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

}

return stanza_;

}

/*

* Licensed under the GNU General Public License v3.

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

enum Type { StreamStart, ElementEvent, StreamEnd };

struct Event {

: type(type), element(element) {}

Event(Type type, const ProtocolHeader& header) : type(type), header(header) {}

Type type;

boost::optional<ProtocolHeader> header;

};

}

events.push_back(Event(ElementEvent, element));

}

/*

* Licensed under the GNU General Public License v3.

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

#include <Swiften/Base/API.h>

namespace Swift {

virtual void handleStreamStart(const ProtocolHeader&) = 0;

virtual void handleStreamEnd() = 0;

};

"Elements/FormField.cpp",

"Elements/StreamFeatures.cpp",

"Elements/IQ.cpp",

"Elements/Payload.cpp",

/*

* Licensed under the GNU General Public License v3.

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

}

boost::shared_ptr<AuthChallenge> authChallenge(boost::dynamic_pointer_cast<AuthChallenge>(element));

std::string value;

/*

* Licensed under the GNU General Public License v3.

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

AuthChallengeSerializer();

};

}

/*

* Licensed under the GNU General Public License v3.

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

}

return createSafeByteArray(XMLElement("failure", "urn:ietf:params:xml:ns:xmpp-sasl").serialize());

}

/*

* Licensed under the GNU General Public License v3.

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

}

boost::shared_ptr<AuthRequest> authRequest(boost::dynamic_pointer_cast<AuthRequest>(element));

SafeByteArray value;

/*

* Licensed under the GNU General Public License v3.

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

AuthRequestSerializer();

};

}

/*

* Licensed under the GNU General Public License v3.

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

}

boost::shared_ptr<AuthResponse> authResponse(boost::dynamic_pointer_cast<AuthResponse>(element));

SafeByteArray value;

/*

* Licensed under the GNU General Public License v3.

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

AuthResponseSerializer();

};

}

/*

* Licensed under the GNU General Public License v3.

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

}

boost::shared_ptr<AuthSuccess> authSuccess(boost::dynamic_pointer_cast<AuthSuccess>(element));

std::string value;

/*

* Licensed under the GNU General Public License v3.

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

AuthSuccessSerializer();

};

}

/*

* Licensed under the GNU General Public License v3.

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

}

boost::shared_ptr<ComponentHandshake> handshake(boost::dynamic_pointer_cast<ComponentHandshake>(element));

return createSafeByteArray("<handshake>" + handshake->getData() + "</handshake>");

/*

* Licensed under the GNU General Public License v3.

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

ComponentHandshakeSerializer();

};

}

/*

* Licensed under the GNU General Public License v3.

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

}

return createSafeByteArray(XMLElement("failure", "http://jabber.org/protocol/compress").serialize());

}

/*

* Licensed under the GNU General Public License v3.

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

}

boost::shared_ptr<CompressRequest> compressRequest(boost::dynamic_pointer_cast<CompressRequest>(element));

return createSafeByteArray("<compress xmlns='http://jabber.org/protocol/compress'><method>" + compressRequest->getMethod() + "</method></compress>");

}

return boost::dynamic_pointer_cast<CompressRequest>(element) != 0;

}

/*

* Licensed under the GNU General Public License v3.

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

CompressRequestSerializer();

};

}

/*

* Licensed under the GNU General Public License v3.

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

#include <boost/shared_ptr.hpp>

#include <Swiften/Base/SafeByteArray.h>

virtual ~ElementSerializer();

};

}

/*

* Licensed under the GNU General Public License v3.

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

}

return createSafeByteArray(XMLElement("enable", "urn:xmpp:sm:2").serialize());

}

class GenericElementSerializer : public ElementSerializer {

public:

return !!boost::dynamic_pointer_cast<T>(element);

}

/*

* Licensed under the GNU General Public License v3.

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

GenericStanzaSerializer(const std::string& tag, PayloadSerializerCollection* payloadSerializers) : StanzaSerializer(tag, payloadSerializers) {}

return dynamic_cast<STANZA_TYPE*>(element.get()) != 0;

}

virtual void setStanzaSpecificAttributes(

XMLElement& element) const {

setStanzaSpecificAttributesGeneric(

/*

* Licensed under the GNU General Public License v3.

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

}

return createSafeByteArray(XMLElement("r", "urn:xmpp:sm:2").serialize());

}

/*

* Licensed under the GNU General Public License v3.

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

}

StanzaAck::ref stanzaAck(boost::dynamic_pointer_cast<StanzaAck>(element));

assert(stanzaAck->isValid());

}

return serialize(element, "");

}

boost::shared_ptr<Stanza> stanza(boost::dynamic_pointer_cast<Stanza>(element));

StanzaSerializer(const std::string& tag, PayloadSerializerCollection* payloadSerializers);

private:

/*

* Licensed under the GNU General Public License v3.

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

}

return createSafeByteArray(XMLElement("failure", "urn:ietf:params:xml:ns:xmpp-tls").serialize());

}

/*

* Licensed under the GNU General Public License v3.

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

}

return createSafeByteArray(XMLElement("starttls", "urn:ietf:params:xml:ns:xmpp-tls").serialize());

}

/*

* Licensed under the GNU General Public License v3.

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

}

StreamError::ref error = boost::dynamic_pointer_cast<StreamError>(element);

XMLElement errorElement("error", "http://etherx.jabber.org/streams");

/*

* Licensed under the GNU General Public License v3.

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

StreamErrorSerializer();

};

}

/*

* Licensed under the GNU General Public License v3.

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

}

boost::shared_ptr<StreamFeatures> streamFeatures(boost::dynamic_pointer_cast<StreamFeatures>(element));

/*

* Licensed under the GNU General Public License v3.

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

StreamFeaturesSerializer();

};

}

/*

* Licensed under the GNU General Public License v3.

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

}

boost::shared_ptr<StreamManagementEnabled> e(boost::dynamic_pointer_cast<StreamManagementEnabled>(el));

XMLElement element("enabled", "urn:xmpp:sm:2");

/*

* Licensed under the GNU General Public License v3.

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

StreamManagementEnabledSerializer();

};

}

/*

* Licensed under the GNU General Public License v3.

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

}

return createSafeByteArray(XMLElement("failed", "urn:xmpp:sm:2").serialize());

}

/*

* Licensed under the GNU General Public License v3.

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

}

boost::shared_ptr<StreamResume> e(boost::dynamic_pointer_cast<StreamResume>(el));

XMLElement element("resume", "urn:xmpp:sm:2");

/*

* Licensed under the GNU General Public License v3.

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

StreamResumeSerializer();

};

}

/*

* Licensed under the GNU General Public License v3.

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

}

boost::shared_ptr<StreamResumed> e(boost::dynamic_pointer_cast<StreamResumed>(el));

XMLElement element("resumed", "urn:xmpp:sm:2");

/*

* Licensed under the GNU General Public License v3.

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

StreamResumedSerializer();

};

}

/*

* Licensed under the GNU General Public License v3.

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

}

return createSafeByteArray(XMLElement("proceed", "urn:ietf:params:xml:ns:xmpp-tls").serialize());

}

/*

* Licensed under the GNU General Public License v3.

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

}

std::vector< boost::shared_ptr<ElementSerializer> >::const_iterator i = std::find_if(serializers_.begin(), serializers_.end(), boost::bind(&ElementSerializer::canSerialize, _1, element));

if (i != serializers_.end()) {

/*

* Licensed under the GNU General Public License v3.

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

#include <Swiften/Base/API.h>

#include <Swiften/Elements/StreamType.h>

#include <string>

std::string serializeHeader(const ProtocolHeader&) const;

std::string serializeFooter() const;

/*

* Licensed under the GNU General Public License v3.

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

}

assert(available);

xmppLayer->writeElement(element);

}

onElementReceived(element);

}

/*

* Licensed under the GNU General Public License v3.

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

virtual void writeHeader(const ProtocolHeader& header);

virtual void writeFooter();

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

void handleXMPPError();

void handleStreamStartReceived(const ProtocolHeader&);

void handlePoolXMPPDataRead(const SafeByteArray& data);

void handleXMPPLayerDataWritten(const SafeByteArray& data);

/*

* Licensed under the GNU General Public License v3.

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

}

assert(available);

xmppLayer->writeElement(element);

}

onElementReceived(element);

}

/*

* Licensed under the GNU General Public License v3.

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

virtual void writeHeader(const ProtocolHeader& header);

virtual void writeFooter();

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

void handleTLSError(boost::shared_ptr<TLSError>);

void handleStreamStartReceived(const ProtocolHeader&);

void handleDataRead(const SafeByteArray& data);

void handleDataWritten(const SafeByteArray& data);

/*

* Licensed under the GNU General Public License v3.

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

}

xmppLayer->writeElement(stanza);

}

/*

* Licensed under the GNU General Public License v3.

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

#include <Swiften/Base/API.h>

#include <Swiften/JID/JID.h>

#include <Swiften/Network/Connection.h>

#include <Swiften/StreamStack/ConnectionLayer.h>

void finishSession();

const JID& getLocalJID() const {

}

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

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

virtual void handleSessionStarted() {}

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

virtual void handleStreamStart(const ProtocolHeader&) = 0;

/*

* Licensed under the GNU General Public License v3.

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

#include <Swiften/Base/API.h>

#include <Swiften/Elements/ProtocolHeader.h>

#include <Swiften/Base/Error.h>

#include <Swiften/Base/SafeByteArray.h>

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

virtual void writeFooter() = 0;

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

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

boost::signal<void (boost::shared_ptr<Error>)> onClosed;

boost::signal<void ()> onTLSEncrypted;

/*

* Licensed under the GNU General Public License v3.

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

}

++elementsReceived_;

}

/*

* Licensed under the GNU General Public License v3.

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

}

++elementsReceived_;

}

++elementsReceived_;

testling_->resetParser();

/*

* Licensed under the GNU General Public License v3.

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

}

writeDataInternal(xmppSerializer_->serializeElement(element));

}

}

onElement(stanza);

}

/*

* Licensed under the GNU General Public License v3.

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

#include <Swiften/StreamStack/HighLayer.h>

#include <Swiften/Base/SafeByteArray.h>

#include <Swiften/Elements/StreamType.h>

#include <Swiften/Parser/XMPPParserClient.h>

void writeHeader(const ProtocolHeader& header);

void writeFooter();

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

public:

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

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

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

private:

void handleStreamStart(const ProtocolHeader&);

void handleStreamEnd();