/*

* Licensed under the GNU General Public License v3.

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

*/

#include "Limber/Server/ServerFromClientSession.h"

#include <boost/smart_ptr/make_shared.hpp>

#include <boost/bind.hpp>

Session(connection, payloadParserFactories, payloadSerializers, xmlParserFactory),

id_(id),

userRegistry_(userRegistry),

authenticated_(false),

initialized(false),

allowSASLEXTERNAL(false) {

}

if (isInitialized()) {

onElementReceived(element);

}

else {

if (AuthRequest* authRequest = dynamic_cast<AuthRequest*>(element.get())) {

if (authRequest->getMechanism() == "PLAIN" || (allowSASLEXTERNAL && authRequest->getMechanism() == "EXTERNAL")) {

if (authRequest->getMechanism() == "EXTERNAL") {

getXMPPLayer()->writeElement(boost::make_shared<AuthSuccess>());

authenticated_ = true;

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <boost/enable_shared_from_this.hpp>

#include <string>

#include <Swiften/Base/boost_bsignals.h>

#include <Swiften/Session/Session.h>

#include <Swiften/JID/JID.h>

#include <Swiften/Network/Connection.h>

#include <Swiften/Base/ByteArray.h>

namespace Swift {

class ProtocolHeader;

class Stanza;

class PayloadParserFactoryCollection;

class PayloadSerializerCollection;

class StreamStack;

class UserRegistry;

class XMPPLayer;

class ConnectionLayer;

class Connection;

class XMLParserFactory;

PayloadParserFactoryCollection* payloadParserFactories,

PayloadSerializerCollection* payloadSerializers,

XMLParserFactory* xmlParserFactory,

UserRegistry* userRegistry);

boost::signal<void ()> onSessionStarted;

void setAllowSASLEXTERNAL();

private:

void handleStreamStart(const ProtocolHeader& header);

void setInitialized();

bool isInitialized() const {

return initialized;

}

private:

std::string id_;

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <string>

#include <boost/bind.hpp>

#include <boost/shared_ptr.hpp>

#include "Swiften/Elements/IQ.h"

session->onElementReceived.connect(boost::bind(&Server::handleElementReceived, this, _1, session));

session->onSessionFinished.connect(boost::bind(&Server::handleSessionFinished, this, session));

session->startSession();

}

void handleSessionFinished(boost::shared_ptr<ServerFromClientSession> session) {

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;

}

stanza->setFrom(session->getRemoteJID());

if (!stanza->getTo().isValid()) {

stanza->setTo(JID(session->getLocalJID()));

}

if (!stanza->getTo().isValid() || stanza->getTo() == session->getLocalJID() || stanza->getTo() == session->getRemoteJID().toBare()) {

/*

* Licensed under the GNU General Public License v3.

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

*/

#include "Slimber/Server.h"

#include <string>

#include <boost/bind.hpp>

#include <iostream>

#include "Swiften/Base/String.h"

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

#include "Swiften/Network/BoostConnectionServer.h"

#include "Swiften/Session/SessionTracer.h"

#include "Swiften/Elements/IQ.h"

#include "Swiften/Elements/VCard.h"

#include "Limber/Server/UserRegistry.h"

#include "Swiften/Session/Session.h"

}

void Server::unregisterService() {

if (linkLocalServiceRegistered) {

linkLocalServiceRegistered = false;

linkLocalServiceBrowser->unregisterService();

}

}

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

if (!stanza) {

return;

}

stanza->setFrom(session->getRemoteJID());

if (!stanza->getTo().isValid()) {

stanza->setTo(session->getLocalJID());

}

}

void Server::handleLinkLocalSessionFinished(boost::shared_ptr<Session> session) {

//std::cout << "Link local session from " << session->getRemoteJID() << " ended" << std::endl;

linkLocalSessions.erase(

std::remove(linkLocalSessions.begin(), linkLocalSessions.end(), session),

linkLocalSessions.end());

}

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

JID fromJID = session->getRemoteJID();

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

return; // TODO: Send error back

}

stanza->setFrom(fromJID);

serverFromClientSession->sendElement(stanza);

}

}

if (error) {

std::cerr << "Error connecting" << std::endl;

// TODO: Send back queued stanzas

}

else {

boost::shared_ptr<OutgoingLinkLocalSession> outgoingSession(

new OutgoingLinkLocalSession(

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

&payloadParserFactories, &payloadSerializers, &xmlParserFactory));

outgoingSession->queueElement(element);

}

registerLinkLocalSession(outgoingSession);

}

connectors.erase(std::remove(connectors.begin(), connectors.end(), connector), connectors.end());

}

void Server::registerLinkLocalSession(boost::shared_ptr<Session> session) {

session->onSessionFinished.connect(

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <boost/optional.hpp>

#include <vector>

boost::signal<void (bool)> onSelfConnected;

boost::signal<void (boost::optional<ServerError>)> onStopped;

private:

void stop(boost::optional<ServerError>);

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

void handleLinkLocalConnectionServerStopped(

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

boost::shared_ptr<Session> getLinkLocalSessionForJID(const JID& jid);

boost::shared_ptr<LinkLocalConnector> getLinkLocalConnectorForJID(const JID& jid);

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

void unregisterService();

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <Swiften/Client/ClientSession.h>

#include <boost/bind.hpp>

#include <boost/uuid/uuid.hpp>

#include <boost/uuid/uuid_io.hpp>

stanzaAckRequester_->handleStanzaSent(stanza);

}

}

void ClientSession::handleStreamStart(const ProtocolHeader&) {

CHECK_STATE_OR_RETURN(WaitingForStreamStart);

state = Negotiating;

}

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

if (stanzaAckResponder_) {

stanzaAckResponder_->handleStanzaReceived();

}

if (getState() == Initialized) {

onStanzaReceived(stanza);

}

else if (boost::shared_ptr<IQ> iq = boost::dynamic_pointer_cast<IQ>(element)) {

if (state == BindingResource) {

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <Swiften/Base/boost_bsignals.h>

#include <boost/shared_ptr.hpp>

#include <boost/enable_shared_from_this.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Error.h>

#include <Swiften/Session/SessionStream.h>

#include <string>

#include <Swiften/JID/JID.h>

#include <Swiften/StreamManagement/StanzaAckRequester.h>

#include <Swiften/StreamManagement/StanzaAckResponder.h>

namespace Swift {

class ClientAuthenticator;

class CertificateTrustChecker;

class IDNConverter;

class CryptoProvider;

void finishSession(Error::Type error);

void finishSession(boost::shared_ptr<Swift::Error> error);

JID getRemoteJID() const {

return JID("", localJID.getDomain());

}

void sendStreamHeader();

void handleStreamStart(const ProtocolHeader&);

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

void handleTLSEncrypted();

bool checkState(State);

void continueSessionInitialization();

void requestAck();

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include <deque>

#include <boost/bind.hpp>

#include <boost/optional.hpp>

}

void handleSessionNeedCredentials() {

needCredentials = true;

}

class MockSessionStream : public SessionStream {

public:

struct Event {

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

Event() : footer(true) {}

boost::optional<ProtocolHeader> header;

bool footer;

};

MockSessionStream() : available(true), canTLSEncrypt(true), tlsEncrypted(false), compressed(false), whitespacePingEnabled(false), resetCount(0) {

}

virtual void close() {

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

virtual void writeHeader(const ProtocolHeader& header) {

receivedEvents.push_back(Event(header));

}

virtual void writeFooter() {

receivedEvents.push_back(Event());

}

receivedEvents.push_back(Event(element));

}

virtual void writeData(const std::string&) {

}

virtual bool supportsTLSEncryption() {

return canTLSEncrypt;

}

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <Swiften/Component/ComponentSession.h>

#include <boost/bind.hpp>

#include <boost/smart_ptr/make_shared.hpp>

stream->writeElement(stanza);

}

void ComponentSession::handleStreamStart(const ProtocolHeader& header) {

checkState(WaitingForStreamStart);

state = Authenticating;

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

}

else {

finishSession(Error::UnexpectedElementError);

}

}

else if (boost::dynamic_pointer_cast<ComponentHandshake>(element)) {

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <boost/enable_shared_from_this.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/JID/JID.h>

#include <Swiften/Base/boost_bsignals.h>

#include <Swiften/Base/Error.h>

#include <string>

#include <Swiften/Elements/Stanza.h>

#include <Swiften/Session/SessionStream.h>

namespace Swift {

class ComponentAuthenticator;

class CryptoProvider;

class SWIFTEN_API ComponentSession : public boost::enable_shared_from_this<ComponentSession> {

public:

private:

ComponentSession(const JID& jid, const std::string& secret, boost::shared_ptr<SessionStream>, CryptoProvider*);

void finishSession(Error::Type error);

void finishSession(boost::shared_ptr<Swift::Error> error);

void sendStreamHeader();

void handleStreamStart(const ProtocolHeader&);

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

bool checkState(State);

private:

JID jid;

std::string secret;

boost::shared_ptr<SessionStream> stream;

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include <deque>

#include <boost/bind.hpp>

#include <boost/optional.hpp>

void handleSessionFinished(boost::shared_ptr<Error> error) {

sessionFinishedReceived = true;

sessionFinishedError = error;

}

class MockSessionStream : public SessionStream {

public:

struct Event {

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

Event() : footer(true) {}

boost::optional<ProtocolHeader> header;

bool footer;

};

MockSessionStream() : available(true), whitespacePingEnabled(false), resetCount(0) {

}

virtual void close() {

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

virtual void writeHeader(const ProtocolHeader& header) {

receivedEvents.push_back(Event(header));

}

virtual void writeFooter() {

receivedEvents.push_back(Event());

}

receivedEvents.push_back(Event(element));

}

virtual void writeData(const std::string&) {

}

virtual bool supportsTLSEncryption() {

return false;

}

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <boost/optional.hpp>

#include <vector>

namespace Swift {

public:

AuthChallenge() {

}

AuthChallenge(const std::vector<unsigned char>& value) : value(value) {

}

const boost::optional< std::vector<unsigned char> >& getValue() const {

return value;

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <boost/shared_ptr.hpp>

namespace Swift {

public:

typedef boost::shared_ptr<AuthFailure> ref;

AuthFailure() {}

};

}

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <vector>

#include <string>

#include <boost/optional.hpp>

#include <Swiften/Base/SafeByteArray.h>

namespace Swift {

public:

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

}

AuthRequest(const std::string& mechanism, const SafeByteArray& message) :

mechanism_(mechanism), message_(message) {

}

AuthRequest(const std::string& mechanism, const boost::optional<SafeByteArray>& message) :

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <vector>

#include <boost/optional.hpp>

#include <Swiften/Base/SafeByteArray.h>

namespace Swift {

public:

AuthResponse() {

}

AuthResponse(const SafeByteArray& value) : value(value) {

}

AuthResponse(const boost::optional<SafeByteArray>& value) : value(value) {

}

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <vector>

#include <boost/optional.hpp>

namespace Swift {

public:

AuthSuccess() {}

const boost::optional<std::vector<unsigned char> >& getValue() const {

return value;

}

void setValue(const std::vector<unsigned char>& value) {

this->value = boost::optional<std::vector<unsigned char> >(value);

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <string>

namespace Swift {

public:

typedef boost::shared_ptr<ComponentHandshake> ref;

ComponentHandshake(const std::string& data = "") : data(data) {

}

void setData(const std::string& d) {

data = d;

}

/*

* 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) {}

const std::string& getMethod() const {

return method_;

}

void setMethod(const std::string& 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() {}

};

}

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <Swiften/Base/API.h>

namespace Swift {

public:

typedef boost::shared_ptr<Payload> ref;

public:

Payload() {}

SWIFTEN_DEFAULT_COPY_CONSTRUCTOR(Payload)

virtual ~Payload();

SWIFTEN_DEFAULT_COPY_ASSIGMNENT_OPERATOR(Payload)

};

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <vector>

#include <string>

#include <boost/shared_ptr.hpp>

#include <boost/optional/optional_fwd.hpp>

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

protected:

Stanza();

public:

virtual ~Stanza();

SWIFTEN_DEFAULT_COPY_CONSTRUCTOR(Stanza)

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <boost/shared_ptr.hpp>

namespace Swift {

public:

typedef boost::shared_ptr<StanzaAck> ref;

StanzaAck() : valid(false), handledStanzasCount(0) {}

StanzaAck(unsigned int handledStanzasCount) : valid(true), handledStanzasCount(handledStanzasCount) {}

virtual ~StanzaAck();

unsigned int getHandledStanzasCount() const {

return handledStanzasCount;

/*

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

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <string>

namespace Swift {

public:

typedef boost::shared_ptr<StreamError> ref;

enum Type {

BadFormat,

BadNamespacePrefix,

Conflict,

ConnectionTimeout,

HostGone,

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <vector>

#include <string>

#include <boost/shared_ptr.hpp>

#include <Swiften/Base/API.h>

namespace Swift {

public:

typedef boost::shared_ptr<StreamFeatures> ref;

StreamFeatures() : hasStartTLS_(false), hasResourceBind_(false), hasSession_(false), hasStreamManagement_(false), hasRosterVersioning_(false) {}

void setHasStartTLS() {

hasStartTLS_ = true;

}

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <string>

#include <Swiften/Base/API.h>

namespace Swift {

public:

StreamManagementEnabled();

~StreamManagementEnabled();

void setResumeSupported() {

resumeSupported = true;

}

bool getResumeSupported() const {

/*

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

*/

#pragma once

#include <string>

#include <boost/optional.hpp>

namespace Swift {

public:

StreamResume();

~StreamResume();

void setResumeID(const std::string& id) {

resumeID = id;

}

const std::string& getResumeID() const {

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <string>

#include <boost/optional.hpp>

namespace Swift {

public:

StreamResumed();

~StreamResumed();

void setResumeID(const std::string& id) {

resumeID = id;

}

const std::string& getResumeID() const {

/*

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

}

}

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

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

*/

#include <iostream>

#include <fstream>

#include <typeinfo>

#include <Swiften/Parser/UnitTest/ParserTester.h>

#include <Swiften/Parser/PayloadParsers/FullPayloadParserFactoryCollection.h>

using namespace Swift;

class MyXMPPParserClient : public XMPPParserClient {

public:

virtual void handleStreamStart(const ProtocolHeader&) {

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

}

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

}

virtual void handleStreamEnd() {

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

}

};

int main(int argc, char* argv[]) {

if (argc != 2) {

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <Swiften/LinkLocal/IncomingLinkLocalSession.h>

#include <boost/bind.hpp>

#include <boost/smart_ptr/make_shared.hpp>

if (incomingHeader.getVersion() == "1.0") {

getXMPPLayer()->writeElement(boost::make_shared<StreamFeatures>());

}

else {

setInitialized();

}

}

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

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

// initialized

if (stanza && !isInitialized()) {

setInitialized();

}

onElementReceived(element);

}

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <Swiften/Base/boost_bsignals.h>

#include <Swiften/Session/Session.h>

#include <Swiften/JID/JID.h>

#include <Swiften/Network/Connection.h>

namespace Swift {

class ProtocolHeader;

class XMLParserFactory;

class PayloadParserFactoryCollection;

class PayloadSerializerCollection;

class IncomingLinkLocalSession : public Session {

public:

IncomingLinkLocalSession(

const JID& localJID,

boost::shared_ptr<Connection> connection,

PayloadParserFactoryCollection* payloadParserFactories,

PayloadSerializerCollection* payloadSerializers,

XMLParserFactory* xmlParserFactory);

boost::signal<void ()> onSessionStarted;

private:

void handleStreamStart(const ProtocolHeader&);

void setInitialized();

bool isInitialized() const {

return initialized;

}

bool initialized;

};

}

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <Swiften/LinkLocal/LinkLocalConnector.h>

#include <boost/bind.hpp>

#include <Swiften/Network/Connection.h>

}

}

void LinkLocalConnector::handleConnected(bool error) {

onConnectFinished(error);

assert(connectionConnectFinishedConnection.connected());

connectionConnectFinishedConnection.disconnect();

}

queuedElements.push_back(element);

}

}

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <Swiften/Base/boost_bsignals.h>

#include <boost/enable_shared_from_this.hpp>

#include <vector>

#include <Swiften/Base/API.h>

#include <Swiften/Network/Connection.h>

#include <Swiften/LinkLocal/LinkLocalService.h>

namespace Swift {

class ConnectionFactory;

class HostAddress;

class PayloadParserFactoryCollection;

class PayloadSerializerCollection;

class DNSSDQuerier;

class DNSSDResolveHostnameQuery;

class SWIFTEN_API LinkLocalConnector : public boost::enable_shared_from_this<LinkLocalConnector> {

public:

LinkLocalConnector(

const LinkLocalService& service,

boost::shared_ptr<Connection> connection);

~LinkLocalConnector();

const LinkLocalService& getService() const {

return service;

}

void connect();

void cancel();

return queuedElements;

}

boost::shared_ptr<Connection> getConnection() const {

return connection;

}

boost::signal<void (bool)> onConnectFinished;

void handleConnected(bool error);

private:

LinkLocalService service;

boost::shared_ptr<DNSSDQuerier> querier;

boost::shared_ptr<DNSSDResolveHostnameQuery> resolveQuery;

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.

*/

#include <Swiften/LinkLocal/OutgoingLinkLocalSession.h>

#include <boost/bind.hpp>

#include <Swiften/Base/foreach.h>

}

void OutgoingLinkLocalSession::handleSessionStarted() {

ProtocolHeader header;

header.setFrom(getLocalJID());

getXMPPLayer()->writeHeader(header);

}

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.

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <Swiften/Base/boost_bsignals.h>

#include <boost/enable_shared_from_this.hpp>

#include <vector>

#include <Swiften/Session/Session.h>

#include <Swiften/JID/JID.h>

namespace Swift {

class ConnectionFactory;

class XMLParserFactory;

class PayloadParserFactoryCollection;

class PayloadSerializerCollection;

class OutgoingLinkLocalSession : public Session {

public:

OutgoingLinkLocalSession(

const JID& localJID,

const JID& remoteJID,

boost::shared_ptr<Connection> connection,

PayloadParserFactoryCollection* payloadParserFactories,

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.

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <string>

#include <Swiften/Base/API.h>

#include <Swiften/Parser/AttributeMap.h>

namespace Swift {

class SWIFTEN_API ElementParser {

public:

virtual ~ElementParser();

virtual void handleStartElement(const std::string& element, const std::string& ns, const AttributeMap& attributes) = 0;

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.

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <boost/smart_ptr/make_shared.hpp>

class PayloadParserFactoryCollection;

template<typename ElementType>

class GenericElementParser : public ElementParser {

public:

GenericElementParser() {

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

}

return stanza_;

}

virtual boost::shared_ptr<ElementType> getElementGeneric() const {

return stanza_;

}

private:

virtual void handleStartElement(const std::string&, const std::string&, const AttributeMap&) {

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <boost/smart_ptr/make_shared.hpp>

template<typename STANZA_TYPE>

class GenericStanzaParser : public StanzaParser {

public:

GenericStanzaParser(PayloadParserFactoryCollection* collection) :

StanzaParser(collection) {

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

}

return stanza_;

}

virtual boost::shared_ptr<STANZA_TYPE> getStanzaGeneric() const {

return stanza_;

}

private:

boost::shared_ptr<STANZA_TYPE> stanza_;

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <boost/noncopyable.hpp>

#include <boost/shared_ptr.hpp>

class SWIFTEN_API StanzaParser : public ElementParser, public boost::noncopyable {

public:

StanzaParser(PayloadParserFactoryCollection* factories);

~StanzaParser();

void handleStartElement(const std::string& element, const std::string& ns, const AttributeMap& attributes);

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 {

return boost::dynamic_pointer_cast<Stanza>(getElement());

}

private:

bool inPayload() const {

return currentDepth_ > 1;

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include <Swiften/Parser/StanzaParser.h>

#include <Swiften/Parser/GenericPayloadParser.h>

class MyStanzaParser : public StanzaParser

{

public:

MyStanzaParser(PayloadParserFactoryCollection* collection) : StanzaParser(collection)

{

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

}

return stanza_;

}

private:

boost::shared_ptr<MyStanza> stanza_;

};

MyPayload1ParserFactory factory1_;

MyPayload2ParserFactory factory2_;

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include <vector>

#include <Swiften/Elements/ProtocolHeader.h>

CPPUNIT_ASSERT(!testling.parse("<tream/>"));

}

private:

class Client : public XMPPParserClient {

public:

enum Type { StreamStart, ElementEvent, StreamEnd };

struct Event {

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

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

Event(Type type) : type(type) {}

Type type;

boost::optional<ProtocolHeader> header;

};

Client() {}

void handleStreamStart(const ProtocolHeader& header) {

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

}

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

}

void handleStreamEnd() {

events.push_back(Event(StreamEnd));

}

std::vector<Event> events;

} client_;

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <Swiften/Base/API.h>

namespace Swift {

class ProtocolHeader;

class SWIFTEN_API XMPPParserClient {

public:

virtual ~XMPPParserClient();

virtual void handleStreamStart(const ProtocolHeader&) = 0;

virtual void handleStreamEnd() = 0;

};

}

"Client/XMLBeautifier.cpp",

"Compress/ZLibCodecompressor.cpp",

"Compress/ZLibDecompressor.cpp",

"Compress/ZLibCompressor.cpp",

"Elements/DiscoInfo.cpp",

"Elements/Presence.cpp",

"Elements/Form.cpp",

"Elements/FormField.cpp",

"Elements/StreamFeatures.cpp",

"Elements/IQ.cpp",

"Elements/Payload.cpp",

"Elements/PubSubPayload.cpp",

"Elements/PubSubOwnerPayload.cpp",

"Elements/PubSubEventPayload.cpp",

"Elements/RosterItemExchangePayload.cpp",

"Elements/RosterPayload.cpp",

"Elements/SecurityLabel.cpp",

"Elements/Stanza.cpp",

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <Swiften/Serializer/AuthChallengeSerializer.h>

#include <Swiften/Elements/AuthChallenge.h>

#include <Swiften/StringCodecs/Base64.h>

#include <Swiften/Base/ByteArray.h>

namespace Swift {

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

if (message) {

if ((*message).empty()) {

value = "=";

}

else {

value = Base64::encode(ByteArray(*message));

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/AuthChallenge.h>

#include <Swiften/Serializer/GenericElementSerializer.h>

namespace Swift {

class SWIFTEN_API AuthChallengeSerializer : public GenericElementSerializer<AuthChallenge> {

public:

AuthChallengeSerializer();

};

}

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <Swiften/Elements/AuthFailure.h>

#include <Swiften/Serializer/GenericElementSerializer.h>

#include <Swiften/Serializer/XML/XMLElement.h>

namespace Swift {

class AuthFailureSerializer : public GenericElementSerializer<AuthFailure> {

public:

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.

*/

#include <Swiften/Serializer/AuthRequestSerializer.h>

#include <Swiften/Elements/AuthRequest.h>

#include <Swiften/StringCodecs/Base64.h>

#include <Swiften/Base/SafeByteArray.h>

#include <Swiften/Base/Concat.h>

namespace Swift {

AuthRequestSerializer::AuthRequestSerializer() {

}

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

SafeByteArray value;

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

if (message) {

if ((*message).empty()) {

value = createSafeByteArray("=");

}

else {

value = Base64::encode(*message);

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/AuthRequest.h>

#include <Swiften/Serializer/GenericElementSerializer.h>

namespace Swift {

class SWIFTEN_API AuthRequestSerializer : public GenericElementSerializer<AuthRequest> {

public:

AuthRequestSerializer();

};

}

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <Swiften/Serializer/AuthResponseSerializer.h>

#include <Swiften/Elements/AuthResponse.h>

#include <Swiften/StringCodecs/Base64.h>

#include <Swiften/Base/SafeByteArray.h>

#include <Swiften/Base/Concat.h>

namespace Swift {

AuthResponseSerializer::AuthResponseSerializer() {

}

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

SafeByteArray value;

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

if (message) {

if ((*message).empty()) {

value = createSafeByteArray("=");

}

else {

value = Base64::encode(*message);

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/AuthResponse.h>

#include <Swiften/Serializer/GenericElementSerializer.h>

namespace Swift {

class SWIFTEN_API AuthResponseSerializer : public GenericElementSerializer<AuthResponse> {

public:

AuthResponseSerializer();

};

}

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <Swiften/Serializer/AuthSuccessSerializer.h>

#include <Swiften/Elements/AuthSuccess.h>

#include <Swiften/StringCodecs/Base64.h>

#include <Swiften/Base/ByteArray.h>

namespace Swift {

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

if (message) {

if ((*message).empty()) {

value = "=";

}

else {

value = Base64::encode(ByteArray(*message));

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/AuthSuccess.h>

#include <Swiften/Serializer/GenericElementSerializer.h>

namespace Swift {

class SWIFTEN_API AuthSuccessSerializer : public GenericElementSerializer<AuthSuccess> {

public:

AuthSuccessSerializer();

};

}

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <Swiften/Serializer/ComponentHandshakeSerializer.h>

#include <Swiften/Elements/ComponentHandshake.h>

namespace Swift {

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.

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <Swiften/Elements/ComponentHandshake.h>

#include <Swiften/Serializer/GenericElementSerializer.h>

namespace Swift {

class ComponentHandshakeSerializer : public GenericElementSerializer<ComponentHandshake> {

public:

ComponentHandshakeSerializer();

};

}

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <Swiften/Elements/CompressFailure.h>

#include <Swiften/Serializer/GenericElementSerializer.h>

#include <Swiften/Serializer/XML/XMLElement.h>

namespace Swift {

class CompressFailureSerializer : public GenericElementSerializer<CompressFailure> {

public:

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.

*/

#include <Swiften/Serializer/CompressRequestSerializer.h>

#include <Swiften/Elements/CompressRequest.h>

namespace Swift {

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.

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <Swiften/Serializer/ElementSerializer.h>

namespace Swift {

class CompressRequestSerializer : public ElementSerializer {

public:

CompressRequestSerializer();

};

}

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <Swiften/Base/SafeByteArray.h>

namespace Swift {

class ElementSerializer {

public:

virtual ~ElementSerializer();

};

}

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <Swiften/Elements/EnableStreamManagement.h>

#include <Swiften/Serializer/GenericElementSerializer.h>

#include <Swiften/Serializer/XML/XMLElement.h>

namespace Swift {

class EnableStreamManagementSerializer : public GenericElementSerializer<EnableStreamManagement> {

public:

EnableStreamManagementSerializer() : GenericElementSerializer<EnableStreamManagement>() {

}

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

}

};

}

#include <boost/shared_ptr.hpp>

#include <Swiften/Serializer/ElementSerializer.h>

namespace Swift {

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.

*/

#pragma once

#include <Swiften/Serializer/StanzaSerializer.h>

namespace Swift {

template<typename STANZA_TYPE>

class GenericStanzaSerializer : public StanzaSerializer {

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

}

virtual void setStanzaSpecificAttributesGeneric(

boost::shared_ptr<STANZA_TYPE>,

XMLElement&) const = 0;

};

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <Swiften/Elements/StanzaAckRequest.h>

#include <Swiften/Serializer/GenericElementSerializer.h>

#include <Swiften/Serializer/XML/XMLElement.h>

namespace Swift {

class StanzaAckRequestSerializer : public GenericElementSerializer<StanzaAckRequest> {

public:

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.

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <boost/lexical_cast.hpp>

#include <Swiften/Serializer/GenericElementSerializer.h>

#include <Swiften/Serializer/XML/XMLElement.h>

namespace Swift {

class StanzaAckSerializer : public GenericElementSerializer<StanzaAck> {

public:

StanzaAckSerializer() : GenericElementSerializer<StanzaAck>() {

}

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

assert(stanzaAck->isValid());

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

result.setAttribute("h", std::string(boost::lexical_cast<std::string>(stanzaAck->getHandledStanzasCount())));

return createSafeByteArray(result.serialize());

}

};

}

#include <Swiften/Serializer/PayloadSerializer.h>

#include <Swiften/Serializer/PayloadSerializerCollection.h>

#include <Swiften/Elements/Stanza.h>

namespace Swift {

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

if (stanza->getFrom().isValid()) {

stanzaElement.setAttribute("from", stanza->getFrom());

}

if (stanza->getTo().isValid()) {

stanzaElement.setAttribute("to", stanza->getTo());

}

namespace Swift {

class PayloadSerializerCollection;

class XMLElement;

class StanzaSerializer : public ElementSerializer {

public:

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

private:

std::string tag_;

PayloadSerializerCollection* payloadSerializers_;

};

}

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <Swiften/Elements/StartTLSFailure.h>

#include <Swiften/Serializer/GenericElementSerializer.h>

#include <Swiften/Serializer/XML/XMLElement.h>

namespace Swift {

class StartTLSFailureSerializer : public GenericElementSerializer<StartTLSFailure> {

public:

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.

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <Swiften/Elements/StartTLSRequest.h>

#include <Swiften/Serializer/GenericElementSerializer.h>

#include <Swiften/Serializer/XML/XMLElement.h>

namespace Swift {

class StartTLSRequestSerializer : public GenericElementSerializer<StartTLSRequest> {

public:

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.

*/

#include <Swiften/Serializer/StreamErrorSerializer.h>

#include <boost/smart_ptr/make_shared.hpp>

#include <Swiften/Serializer/XML/XMLElement.h>

namespace Swift {

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

}

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

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

std::string typeTag;

switch (error->getType()) {

case StreamError::BadFormat: typeTag = "bad-format"; break;

case StreamError::BadNamespacePrefix: typeTag = "bad-namespace-prefix"; break;

case StreamError::Conflict: typeTag = "conflict"; break;

case StreamError::ConnectionTimeout: typeTag = "connection-timeout"; break;

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <Swiften/Serializer/GenericElementSerializer.h>

#include <Swiften/Elements/StreamError.h>

namespace Swift {

class StreamErrorSerializer : public GenericElementSerializer<StreamError> {

public:

StreamErrorSerializer();

};

}

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <Swiften/Serializer/StreamFeaturesSerializer.h>

#include <boost/smart_ptr/make_shared.hpp>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLTextNode.h>

#include <Swiften/Base/foreach.h>

namespace Swift {

StreamFeaturesSerializer::StreamFeaturesSerializer() {

}

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

XMLElement streamFeaturesElement("stream:features");

if (streamFeatures->hasStartTLS()) {

streamFeaturesElement.addNode(boost::make_shared<XMLElement>("starttls", "urn:ietf:params:xml:ns:xmpp-tls"));

}

if (!streamFeatures->getCompressionMethods().empty()) {

boost::shared_ptr<XMLElement> compressionElement(new XMLElement("compression", "http://jabber.org/features/compress"));

foreach(const std::string& method, streamFeatures->getCompressionMethods()) {

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/StreamFeatures.h>

#include <Swiften/Serializer/GenericElementSerializer.h>

namespace Swift {

class SWIFTEN_API StreamFeaturesSerializer : public GenericElementSerializer<StreamFeatures> {

public:

StreamFeaturesSerializer();

};

}

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <Swiften/Serializer/StreamManagementEnabledSerializer.h>

#include <boost/shared_ptr.hpp>

#include <Swiften/Elements/StreamManagementEnabled.h>

#include <Swiften/Serializer/XML/XMLElement.h>

using namespace Swift;

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

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

}

if (e->getResumeSupported()) {

element.setAttribute("resume", "true");

}

return createSafeByteArray(element.serialize());

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <Swiften/Elements/StreamManagementEnabled.h>

#include <Swiften/Serializer/GenericElementSerializer.h>

namespace Swift {

class StreamManagementEnabledSerializer : public GenericElementSerializer<StreamManagementEnabled> {

public:

StreamManagementEnabledSerializer();

};

}

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <Swiften/Elements/StreamManagementFailed.h>

#include <Swiften/Serializer/GenericElementSerializer.h>

#include <Swiften/Serializer/XML/XMLElement.h>

namespace Swift {

class StreamManagementFailedSerializer : public GenericElementSerializer<StreamManagementFailed> {

public:

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.

*/

#include <Swiften/Serializer/StreamResumeSerializer.h>

#include <boost/shared_ptr.hpp>

#include <boost/lexical_cast.hpp>

#include <Swiften/Elements/StreamResume.h>

#include <Swiften/Serializer/XML/XMLElement.h>

using namespace Swift;

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

if (e->getHandledStanzasCount()) {

element.setAttribute("h", boost::lexical_cast<std::string>(e->getHandledStanzasCount()));

}

return createSafeByteArray(element.serialize());

}

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <Swiften/Elements/StreamResume.h>

#include <Swiften/Serializer/GenericElementSerializer.h>

namespace Swift {

class StreamResumeSerializer : public GenericElementSerializer<StreamResume> {

public:

StreamResumeSerializer();

};

}

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <Swiften/Serializer/StreamResumedSerializer.h>

#include <boost/shared_ptr.hpp>

#include <boost/lexical_cast.hpp>

#include <Swiften/Elements/StreamResumed.h>

#include <Swiften/Serializer/XML/XMLElement.h>

using namespace Swift;

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

if (e->getHandledStanzasCount()) {

element.setAttribute("h", boost::lexical_cast<std::string>(e->getHandledStanzasCount()));

}

return createSafeByteArray(element.serialize());

}

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <Swiften/Elements/StreamResumed.h>

#include <Swiften/Serializer/GenericElementSerializer.h>

namespace Swift {

class StreamResumedSerializer : public GenericElementSerializer<StreamResumed> {

public:

StreamResumedSerializer();

};

}

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <Swiften/Elements/TLSProceed.h>

#include <Swiften/Serializer/GenericElementSerializer.h>

#include <Swiften/Serializer/XML/XMLElement.h>

namespace Swift {

class TLSProceedSerializer : public GenericElementSerializer<TLSProceed> {

public:

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.

*/

#include <Swiften/Serializer/XMPPSerializer.h>

#include <boost/bind.hpp>

#include <boost/smart_ptr/make_shared.hpp>

#include <iostream>

result += " id=\"" + header.getID() + "\"";

}

if (!header.getVersion().empty()) {

result += " version=\"" + header.getVersion() + "\"";

}

result += ">";

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

}

else {

std::cerr << "Could not find serializer for " << typeid(*(element.get())).name() << std::endl;

return createSafeByteArray("");

}

}

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <vector>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/StreamType.h>

#include <string>

#include <Swiften/Serializer/ElementSerializer.h>

namespace Swift {

class PayloadSerializerCollection;

class CompressRequestSerializer;

class ProtocolHeader;

class SWIFTEN_API XMPPSerializer {

public:

XMPPSerializer(PayloadSerializerCollection*, StreamType type);

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

std::string serializeFooter() const;

private:

std::string getDefaultNamespace() const;

private:

StreamType type_;

std::vector< boost::shared_ptr<ElementSerializer> > serializers_;

};

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <Swiften/Session/BOSHSessionStream.h>

#include <boost/bind.hpp>

#include <boost/random/mersenne_twister.hpp>

xmppLayer->onWriteData.disconnect(boost::bind(&BOSHSessionStream::handleXMPPLayerDataWritten, this, _1));

delete xmppLayer;

xmppLayer = NULL;

}

void BOSHSessionStream::handlePoolXMPPDataRead(const SafeByteArray& data) {

xmppLayer->handleDataRead(data);

}

assert(available);

xmppLayer->writeElement(element);

}

void BOSHSessionStream::writeFooter() {

connectionPool->writeFooter();

}

void BOSHSessionStream::writeData(const std::string& data) {

void BOSHSessionStream::resetXMPPParser() {

xmppLayer->resetParser();

}

void BOSHSessionStream::handleStreamStartReceived(const ProtocolHeader& header) {

onStreamStartReceived(header);

}

onElementReceived(element);

}

void BOSHSessionStream::handleXMPPError() {

available = false;

onClosed(boost::make_shared<SessionStreamError>(SessionStreamError::ParseError));

}

void BOSHSessionStream::handlePoolSessionStarted() {

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <Swiften/Base/SafeString.h>

const SafeString& boshHTTPConnectProxyAuthID,

const SafeString& boshHTTPConnectProxyAuthPassword

);

~BOSHSessionStream();

virtual void close();

virtual bool isOpen();

virtual void writeHeader(const ProtocolHeader& header);

virtual void writeFooter();

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

virtual bool supportsZLibCompression();

virtual void addZLibCompression();

virtual bool supportsTLSEncryption();

virtual void addTLSEncryption();

virtual bool isTLSEncrypted();

virtual ByteArray getTLSFinishMessage() const;

virtual void setWhitespacePingEnabled(bool);

virtual void resetXMPPParser();

private:

void handleXMPPError();

void handleStreamStartReceived(const ProtocolHeader&);

void handlePoolXMPPDataRead(const SafeByteArray& data);

void handleXMPPLayerDataWritten(const SafeByteArray& data);

void handlePoolSessionStarted();

void handlePoolBOSHDataRead(const SafeByteArray& data);

void handlePoolBOSHDataWritten(const SafeByteArray& data);

void handlePoolSessionTerminated(BOSHError::ref condition);

private:

void fakeStreamHeaderReceipt();

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <Swiften/Session/BasicSessionStream.h>

#include <boost/bind.hpp>

#include <boost/smart_ptr/make_shared.hpp>

xmppLayer->onWriteData.disconnect(boost::bind(&BasicSessionStream::handleDataWritten, this, _1));

delete xmppLayer;

}

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

assert(available);

xmppLayer->writeHeader(header);

}

assert(available);

xmppLayer->writeElement(element);

}

void BasicSessionStream::writeFooter() {

assert(available);

xmppLayer->writeFooter();

}

void BasicSessionStream::resetXMPPParser() {

xmppLayer->resetParser();

}

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

onStreamStartReceived(header);

}

onElementReceived(element);

}

void BasicSessionStream::handleXMPPError() {

available = false;

onClosed(boost::make_shared<SessionStreamError>(SessionStreamError::ParseError));

}

void BasicSessionStream::handleTLSConnected() {

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <Swiften/Base/SafeByteArray.h>

TimerFactory* whitespacePingLayerFactory,

XMLParserFactory* xmlParserFactory

);

~BasicSessionStream();

virtual void close();

virtual bool isOpen();

virtual void writeHeader(const ProtocolHeader& header);

virtual void writeFooter();

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

virtual bool supportsZLibCompression();

virtual void addZLibCompression();

virtual bool supportsTLSEncryption();

virtual void addTLSEncryption();

virtual bool isTLSEncrypted();

virtual void resetXMPPParser();

private:

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

void handleXMPPError();

void handleTLSConnected();

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

void handleStreamStartReceived(const ProtocolHeader&);

void handleDataRead(const SafeByteArray& data);

void handleDataWritten(const SafeByteArray& data);

private:

bool available;

boost::shared_ptr<Connection> connection;

TLSContextFactory* tlsContextFactory;

TimerFactory* timerFactory;

XMPPLayer* xmppLayer;

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <Swiften/Session/Session.h>

#include <boost/bind.hpp>

#include <Swiften/StreamStack/XMPPLayer.h>

boost::bind(&Session::finishSession, 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, this, _1));

connectionLayer = new ConnectionLayer(connection);

streamStack = new StreamStack(xmppLayer, connectionLayer);

}

xmppLayer->writeElement(stanza);

}

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

connection->onDisconnected.disconnect(

boost::bind(&Session::handleDisconnected, this, _1));

if (connectionError) {

switch (*connectionError) {

case Connection::ReadError:

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <Swiften/Base/boost_bsignals.h>

#include <boost/optional.hpp>

#include <boost/enable_shared_from_this.hpp>

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

namespace Swift {

class ProtocolHeader;

class StreamStack;

class JID;

class Element;

boost::shared_ptr<Connection> connection,

PayloadParserFactoryCollection* payloadParserFactories,

PayloadSerializerCollection* payloadSerializers,

XMLParserFactory* xmlParserFactory);

virtual ~Session();

void startSession();

void finishSession();

const JID& getLocalJID() const {

return localJID;

}

const JID& getRemoteJID() const {

return remoteJID;

}

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

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

boost::signal<void (const SafeByteArray&)> 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 handleStreamStart(const ProtocolHeader&) = 0;

void initializeStreamStack();

XMPPLayer* getXMPPLayer() const {

return xmppLayer;

}

StreamStack* getStreamStack() const {

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <Swiften/Base/boost_bsignals.h>

#include <boost/shared_ptr.hpp>

#include <boost/optional.hpp>

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

#include <Swiften/TLS/Certificate.h>

#include <Swiften/TLS/CertificateVerificationError.h>

namespace Swift {

class SWIFTEN_API SessionStream {

public:

SessionStream(): certificate() {}

virtual ~SessionStream();

virtual void close() = 0;

virtual bool isOpen() = 0;

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

virtual void writeFooter() = 0;

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

virtual bool supportsZLibCompression() = 0;

virtual void addZLibCompression() = 0;

virtual bool supportsTLSEncryption() = 0;

virtual void addTLSEncryption() = 0;

virtual bool isTLSEncrypted() = 0;

virtual void setWhitespacePingEnabled(bool enabled) = 0;

}

virtual Certificate::ref getPeerCertificate() const = 0;

virtual std::vector<Certificate::ref> getPeerCertificateChain() const = 0;

virtual boost::shared_ptr<CertificateVerificationError> getPeerCertificateVerificationError() const = 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;

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

protected:

CertificateWithKey::ref getTLSCertificate() const {

return certificate;

}

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <Swiften/Base/ByteArray.h>

#include <QA/Checker/IO.h>

#include <vector>

#include <boost/bind.hpp>

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

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

testling.addLayer(xStream.get());

xmppStream_->writeData("foo");

CPPUNIT_ASSERT_EQUAL(1, dataWriteReceived_);

}

++elementsReceived_;

}

void handleWriteData(const SafeByteArray&) {

++dataWriteReceived_;

}

private:

class MyStreamLayer : public StreamLayer {

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <vector>

#include <boost/bind.hpp>

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

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

}

void testWriteFooter() {

testling_->writeFooter();

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

}

++elementsReceived_;

}

++elementsReceived_;

testling_->resetParser();

}

void handleError() {

++errorReceived_;

}

private:

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <Swiften/StreamStack/XMPPLayer.h>

#include <Swiften/Parser/XMPPParser.h>

#include <Swiften/Serializer/XMPPSerializer.h>

#include <Swiften/Elements/ProtocolHeader.h>

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

writeDataInternal(createSafeByteArray(xmppSerializer_->serializeHeader(header)));

}

void XMPPLayer::writeFooter() {

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

}

writeDataInternal(xmppSerializer_->serializeElement(element));

}

void XMPPLayer::writeData(const std::string& data) {

writeDataInternal(createSafeByteArray(data));

}

void XMPPLayer::writeDataInternal(const SafeByteArray& data) {

onWriteData(data);

delete xmppParser_;

xmppParser_ = new XMPPParser(this, payloadParserFactories_, xmlParserFactory_);

resetParserAfterParse_ = false;

}

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

onStreamStart(header);

}

onElement(stanza);

}

void XMPPLayer::handleStreamEnd() {

}

void XMPPLayer::resetParser() {

if (inParser_) {

resetParserAfterParse_ = true;

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <Swiften/Base/boost_bsignals.h>

#include <boost/noncopyable.hpp>

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

namespace Swift {

class ProtocolHeader;

class XMPPParser;

class PayloadParserFactoryCollection;

class XMPPSerializer;

class PayloadSerializerCollection;

XMPPLayer(

PayloadParserFactoryCollection* payloadParserFactories,

PayloadSerializerCollection* payloadSerializers,

XMLParserFactory* xmlParserFactory,

StreamType streamType);

~XMPPLayer();

void writeHeader(const ProtocolHeader& header);

void writeFooter();

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

void resetParser();

protected:

void handleDataRead(const SafeByteArray& data);

void writeDataInternal(const SafeByteArray& data);

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

private:

PayloadParserFactoryCollection* payloadParserFactories_;

XMPPParser* xmppParser_;

PayloadSerializerCollection* payloadSerializers_;

XMLParserFactory* xmlParserFactory_;