/*

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

class PayloadSerializerCollection;

void setAllowSASLEXTERNAL();

private:

void handleStreamStart(const ProtocolHeader& header);

void setInitialized();

/*

* Licensed under the GNU General Public License v3.

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

*/

serverFromClientSessions_.erase(std::remove(serverFromClientSessions_.begin(), serverFromClientSessions_.end(), session), serverFromClientSessions_.end());

}

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

if (!stanza) {

return;

/*

* Licensed under the GNU General Public License v3.

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

*/

#include "Swiften/LinkLocal/LinkLocalConnector.h"

#include "Swiften/Network/Connection.h"

#include "Swiften/Session/SessionTracer.h"

#include "Swiften/Elements/Presence.h"

#include "Swiften/Elements/RosterPayload.h"

#include "Swiften/Network/BoostConnection.h"

}

}

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

if (!stanza) {

return;

linkLocalSessions.end());

}

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

JID fromJID = session->getRemoteJID();

if (!presenceManager->getServiceForJID(fromJID.toBare())) {

new OutgoingLinkLocalSession(

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

&payloadParserFactories, &payloadSerializers, &xmlParserFactory));

outgoingSession->queueElement(element);

}

registerLinkLocalSession(outgoingSession);

/*

* Licensed under the GNU General Public License v3.

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

*/

void handleNewClientConnection(boost::shared_ptr<Connection> c);

void handleSessionStarted();

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

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

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

void handleServiceRegistered(const DNSSDServiceID& service);

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(

boost::optional<BoostConnectionServer::Error>);

/*

* Licensed under the GNU General Public License v3.

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

*/

state = Negotiating;

}

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

if (stanzaAckResponder_) {

stanzaAckResponder_->handleStanzaReceived();

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <Swiften/Session/SessionStream.h>

#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.

*/

class MockSessionStream : public SessionStream {

public:

struct Event {

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

Event() : footer(true) {}

boost::optional<ProtocolHeader> header;

bool footer;

};

receivedEvents.push_back(Event());

}

receivedEvents.push_back(Event(element));

}

/*

* Licensed under the GNU General Public License v3.

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

*/

stream->writeElement(ComponentHandshake::ref(new ComponentHandshake(ComponentHandshakeGenerator::getHandshake(header.getID(), secret, crypto))));

}

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

if (getState() == Initialized) {

onStanzaReceived(stanza);

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <Swiften/Base/boost_bsignals.h>

#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.

*/

class MockSessionStream : public SessionStream {

public:

struct Event {

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

Event() : footer(true) {}

boost::optional<ProtocolHeader> header;

bool footer;

};

receivedEvents.push_back(Event());

}

receivedEvents.push_back(Event(element));

}

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <boost/optional.hpp>

#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 <string>

#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 <vector>

#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 <vector>

#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 <boost/shared_ptr.hpp>

#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.

*/

#pragma once

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:

CompressRequest(const std::string& method = "") : method_(method) {}

/*

* 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 <boost/shared_ptr.hpp>

#include <Swiften/Base/API.h>

namespace Swift {

public:

typedef boost::shared_ptr<Payload> ref;

public:

/*

* Licensed under the GNU General Public License v3.

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

*/

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

#include <Swiften/Base/API.h>

#include <Swiften/JID/JID.h>

namespace Swift {

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 <boost/shared_ptr.hpp>

#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 <string>

#include <Swiften/Base/API.h>

namespace Swift {

public:

StreamManagementEnabled();

~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 <string>

#include <boost/optional.hpp>

namespace Swift {

public:

StreamResume();

~StreamResume();

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <string>

#include <boost/optional.hpp>

namespace Swift {

public:

StreamResumed();

~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 {

}

}

#include <Swiften/Base/API.h>

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.

*/

virtual void handleStreamStart(const ProtocolHeader&) {

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

}

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

}

virtual void handleStreamEnd() {

/*

* 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

// initialized

/*

* Licensed under the GNU General Public License v3.

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

*/

namespace Swift {

class ProtocolHeader;

class XMLParserFactory;

class PayloadParserFactoryCollection;

class PayloadSerializerCollection;

boost::signal<void ()> onSessionStarted;

private:

void handleStreamStart(const ProtocolHeader&);

void setInitialized();

bool isInitialized() const {

/*

* Licensed under the GNU General Public License v3.

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

*/

connectionConnectFinishedConnection.disconnect();

}

queuedElements.push_back(element);

}

/*

* Licensed under the GNU General Public License v3.

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

*/

namespace Swift {

class ConnectionFactory;

class HostAddress;

class PayloadParserFactoryCollection;

class PayloadSerializerCollection;

class DNSSDQuerier;

void connect();

void cancel();

return queuedElements;

}

boost::bsignals::connection resolveQueryHostNameResolvedConnection;

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

}

queuedElements_.clear();

}

onElementReceived(element);

}

queuedElements_.push_back(element);

}

/*

* Licensed under the GNU General Public License v3.

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

*/

namespace Swift {

class ConnectionFactory;

class XMLParserFactory;

class PayloadParserFactoryCollection;

class PayloadSerializerCollection;

PayloadSerializerCollection* payloadSerializers,

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>

namespace Swift {

virtual void handleEndElement(const std::string& element, const std::string& ns) = 0;

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

};

}

/*

* Licensed under the GNU General Public License v3.

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

*/

stanza_ = boost::make_shared<ElementType>();

}

return stanza_;

}

/*

* Licensed under the GNU General Public License v3.

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

*/

stanza_ = boost::make_shared<STANZA_TYPE>();

}

return stanza_;

}

/*

* Licensed under the GNU General Public License v3.

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

*/

void handleEndElement(const std::string& element, const std::string& ns);

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

virtual void handleStanzaAttributes(const AttributeMap&) {}

virtual boost::shared_ptr<Stanza> getStanza() const {

/*

* Licensed under the GNU General Public License v3.

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

*/

stanza_ = boost::make_shared<MyStanza>();

}

return stanza_;

}

/*

* Licensed under the GNU General Public License v3.

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

*/

public:

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;

};

Client() {}

events.push_back(Event(StreamStart, header));

}

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

}

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <boost/shared_ptr.hpp>

#include <Swiften/Base/API.h>

namespace Swift {

virtual ~XMPPParserClient();

virtual void handleStreamStart(const ProtocolHeader&) = 0;

virtual void handleStreamEnd() = 0;

};

}

"Elements/Form.cpp",

"Elements/FormField.cpp",

"Elements/StreamFeatures.cpp",

"Elements/IQ.cpp",

"Elements/Payload.cpp",

"Elements/PubSubPayload.cpp",

/*

* Licensed under the GNU General Public License v3.

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

*/

AuthChallengeSerializer::AuthChallengeSerializer() {

}

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

std::string value;

boost::optional<std::vector<unsigned char> > message = authChallenge->getValue();

/*

* Licensed under the GNU General Public License v3.

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

*/

public:

AuthChallengeSerializer();

};

}

/*

* Licensed under the GNU General Public License v3.

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

*/

AuthFailureSerializer() : GenericElementSerializer<AuthFailure>() {

}

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.

*/

AuthRequestSerializer::AuthRequestSerializer() {

}

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

SafeByteArray value;

boost::optional<SafeByteArray> message = authRequest->getMessage();

/*

* Licensed under the GNU General Public License v3.

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

*/

public:

AuthRequestSerializer();

};

}

/*

* Licensed under the GNU General Public License v3.

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

*/

AuthResponseSerializer::AuthResponseSerializer() {

}

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

SafeByteArray value;

boost::optional<SafeByteArray> message = authResponse->getValue();

/*

* Licensed under the GNU General Public License v3.

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

*/

public:

AuthResponseSerializer();

};

}

/*

* Licensed under the GNU General Public License v3.

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

*/

AuthSuccessSerializer::AuthSuccessSerializer() {

}

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

std::string value;

boost::optional<std::vector<unsigned char> > message = authSuccess->getValue();

/*

* Licensed under the GNU General Public License v3.

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

*/

public:

AuthSuccessSerializer();

};

}

/*

* Licensed under the GNU General Public License v3.

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

*/

ComponentHandshakeSerializer::ComponentHandshakeSerializer() {

}

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.

*/

public:

ComponentHandshakeSerializer();

};

}

/*

* Licensed under the GNU General Public License v3.

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

*/

CompressFailureSerializer() : GenericElementSerializer<CompressFailure>() {

}

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.

*/

CompressRequestSerializer::CompressRequestSerializer() {

}

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.

*/

public:

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>

namespace Swift {

public:

virtual ~ElementSerializer();

};

}

/*

* Licensed under the GNU General Public License v3.

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

*/

EnableStreamManagementSerializer() : GenericElementSerializer<EnableStreamManagement>() {

}

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

}

};

template<typename T>

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.

*/

public:

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(

boost::dynamic_pointer_cast<STANZA_TYPE>(stanza), element);

/*

* Licensed under the GNU General Public License v3.

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

*/

StanzaAckRequestSerializer() : GenericElementSerializer<StanzaAckRequest>() {

}

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.

*/

StanzaAckSerializer() : GenericElementSerializer<StanzaAck>() {

}

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

assert(stanzaAck->isValid());

XMLElement result("a", "urn:xmpp:sm:2");

StanzaSerializer::StanzaSerializer(const std::string& tag, PayloadSerializerCollection* payloadSerializers) : tag_(tag), payloadSerializers_(payloadSerializers) {

}

return serialize(element, "");

}

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

XMLElement stanzaElement(tag_, xmlns);

public:

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

private:

std::string tag_;

/*

* Licensed under the GNU General Public License v3.

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

*/

StartTLSFailureSerializer() : GenericElementSerializer<StartTLSFailure>() {

}

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.

*/

StartTLSRequestSerializer() : GenericElementSerializer<StartTLSRequest>() {

}

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.

*/

StreamErrorSerializer::StreamErrorSerializer() : GenericElementSerializer<StreamError>() {

}

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.

*/

public:

StreamErrorSerializer();

};

}

/*

* Licensed under the GNU General Public License v3.

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

*/

StreamFeaturesSerializer::StreamFeaturesSerializer() {

}

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

XMLElement streamFeaturesElement("stream:features");

/*

* Licensed under the GNU General Public License v3.

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

*/

public:

StreamFeaturesSerializer();

};

}

/*

* Licensed under the GNU General Public License v3.

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

*/

StreamManagementEnabledSerializer::StreamManagementEnabledSerializer() : GenericElementSerializer<StreamManagementEnabled>() {

}

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

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

if (!e->getResumeID().empty()) {

/*

* Licensed under the GNU General Public License v3.

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

*/

public:

StreamManagementEnabledSerializer();

};

}

/*

* Licensed under the GNU General Public License v3.

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

*/

StreamManagementFailedSerializer() : GenericElementSerializer<StreamManagementFailed>() {

}

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.

*/

StreamResumeSerializer::StreamResumeSerializer() : GenericElementSerializer<StreamResume>() {

}

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

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

element.setAttribute("previd", e->getResumeID());

/*

* Licensed under the GNU General Public License v3.

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

*/

public:

StreamResumeSerializer();

};

}

/*

* Licensed under the GNU General Public License v3.

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

*/

StreamResumedSerializer::StreamResumedSerializer() : GenericElementSerializer<StreamResumed>() {

}

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

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

element.setAttribute("previd", e->getResumeID());

/*

* Licensed under the GNU General Public License v3.

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

*/

public:

StreamResumedSerializer();

};

}

/*

* Licensed under the GNU General Public License v3.

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

*/

TLSProceedSerializer() : GenericElementSerializer<TLSProceed>() {

}

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.

*/

return result;

}

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

return (*i)->serialize(element);

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <vector>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/StreamType.h>

#include <string>

#include <Swiften/Serializer/ElementSerializer.h>

XMPPSerializer(PayloadSerializerCollection*, StreamType type);

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

std::string serializeFooter() const;

private:

/*

* Licensed under the GNU General Public License v3.

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

*/

xmppLayer->handleDataRead(data);

}

assert(available);

xmppLayer->writeElement(element);

}

onStreamStartReceived(header);

}

onElementReceived(element);

}

/*

* Licensed under the GNU General Public License v3.

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

*/

virtual bool isOpen();

virtual void writeHeader(const ProtocolHeader& header);

virtual void writeFooter();

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

private:

void handleXMPPError();

void handleStreamStartReceived(const ProtocolHeader&);

void handlePoolXMPPDataRead(const SafeByteArray& data);

void handleXMPPLayerDataWritten(const SafeByteArray& data);

void handlePoolSessionStarted();

/*

* Licensed under the GNU General Public License v3.

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

*/

xmppLayer->writeHeader(header);

}

assert(available);

xmppLayer->writeElement(element);

}

onStreamStartReceived(header);

}

onElementReceived(element);

}

/*

* Licensed under the GNU General Public License v3.

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

*/

virtual bool isOpen();

virtual void writeHeader(const ProtocolHeader& header);

virtual void writeFooter();

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

void handleTLSConnected();

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.

*/

streamStack = new StreamStack(xmppLayer, connectionLayer);

}

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>

#include <Swiften/Base/SafeByteArray.h>

void startSession();

void finishSession();

const JID& getLocalJID() const {

return localJID;

return remoteJID;

}

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

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

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

virtual void handleSessionStarted() {}

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

virtual void handleStreamStart(const ProtocolHeader&) = 0;

void initializeStreamStack();

/*

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

#include <Swiften/TLS/CertificateWithKey.h>

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

virtual void writeFooter() = 0;

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

virtual bool supportsZLibCompression() = 0;

virtual ByteArray getTLSFinishMessage() const = 0;

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

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

boost::signal<void ()> onTLSEncrypted;

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

/*

* Licensed under the GNU General Public License v3.

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

*/

CPPUNIT_ASSERT_EQUAL(1, dataWriteReceived_);

}

++elementsReceived_;

}

/*

* Licensed under the GNU General Public License v3.

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

*/

CPPUNIT_ASSERT_EQUAL(std::string("</stream:stream>"), lowLayer_->writtenData);

}

++elementsReceived_;

}

++elementsReceived_;

testling_->resetParser();

}

/*

* Licensed under the GNU General Public License v3.

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

*/

writeDataInternal(createSafeByteArray(xmppSerializer_->serializeFooter()));

}

writeDataInternal(xmppSerializer_->serializeElement(element));

}

onStreamStart(header);

}

onElement(stanza);

}

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <Swiften/Base/API.h>

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

void resetParser();

public:

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

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

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

boost::signal<void ()> onError;

private:

void handleStreamStart(const ProtocolHeader&);

void handleStreamEnd();

void doResetParser();