/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <map>

#include <memory>

#include <string>

#include <boost/signals2.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/Command.h>

#include <Swiften/Elements/ErrorPayload.h>

#include <Swiften/JID/JID.h>

namespace Swift {

class IQRouter;

class SWIFTEN_API OutgoingAdHocCommandSession {

public:

/**

* Availability of action.

*/

enum ActionState {

Absent /** Action isn't applicable to this command. */ = 0,

Present /** Action is applicable to this command */= 1,

Enabled /** Action is applicable and currently available */ = 2,

EnabledAndPresent = 3};

OutgoingAdHocCommandSession(const JID& to, const std::string& commandNode, IQRouter* iqRouter);

~OutgoingAdHocCommandSession();

/**

* Send initial request to the target.

*/

void start();

/**

* Cancel command session with the target.

*/

void cancel();

/**

* Return to the previous stage.

*/

void goBack();

/**

* Send the form to complete the command.

* \param form Form for submission - if missing the command will be submitted with no form.

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <iosfwd>

#include <Swiften/Client/ClientSession.h>

namespace Swift {

class ClientError;

class Element;

}

SWIFTEN_API std::ostream& operator<<(std::ostream& os, const Swift::ClientError& error);

SWIFTEN_API std::ostream& operator<<(std::ostream& os, Swift::Element* ele);

SWIFTEN_API std::ostream& operator<<(std::ostream& os, Swift::ClientSession::State state);

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <string>

#include <boost/signals2.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Base/SafeByteArray.h>

#include <Swiften/Client/ClientError.h>

#include <Swiften/Client/ClientOptions.h>

#include <Swiften/Entity/Entity.h>

#include <Swiften/JID/JID.h>

#include <Swiften/TLS/CertificateWithKey.h>

namespace Swift {

class ChainedConnector;

class Error;

class IQRouter;

class NetworkFactories;

/**

* The central class for communicating with an XMPP server.

*

* This class is responsible for setting up the connection with the XMPP

* server, authenticating, and initializing the session.

*

* This class can be used directly in your application, although the Client

* subclass provides more functionality and interfaces, and is better suited

* for most needs.

*/

class SWIFTEN_API CoreClient : public Entity {

public:

/**

* Constructs a client for the given JID with the given password.

*/

CoreClient(const JID& jid, const SafeByteArray& password, NetworkFactories* networkFactories);

virtual ~CoreClient();

/**

* Set a client certificate to use for strong authentication with the server.

* Ensure that it is of the correct type for the TLS engine in use.

* This means, largely, PKCS12Certificate for OpenSSL and CAPICertificate for CAPI.

*/

void setCertificate(CertificateWithKey::ref certificate);

/**

* Connects the client to the server.

*

* After the connection is established, the client will set

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Client/NickManager.h>

namespace Swift {

class DummyNickManager : public NickManager {

public:

std::string getOwnNick() const {

return "";

}

void setOwnNick(const std::string&) {

}

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <string>

#include <boost/signals2.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Error.h>

#include <Swiften/Elements/Stanza.h>

#include <Swiften/Elements/ToplevelElement.h>

#include <Swiften/JID/JID.h>

#include <Swiften/Session/SessionStream.h>

namespace Swift {

class CryptoProvider;

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

public:

enum State {

Initial,

WaitingForStreamStart,

Authenticating,

Initialized,

Finishing,

Finished

};

struct Error : public Swift::Error {

enum Type {

AuthenticationFailedError,

UnexpectedElementError

} type;

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

};

~ComponentSession();

static std::shared_ptr<ComponentSession> create(const JID& jid, const std::string& secret, std::shared_ptr<SessionStream> stream, CryptoProvider* crypto) {

return std::shared_ptr<ComponentSession>(new ComponentSession(jid, secret, stream, crypto));

}

State getState() const {

return state;

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <string>

#include <boost/signals2.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Error.h>

#include <Swiften/Base/SafeByteArray.h>

#include <Swiften/Component/ComponentConnector.h>

#include <Swiften/Component/ComponentError.h>

#include <Swiften/Component/ComponentSession.h>

#include <Swiften/Component/ComponentSessionStanzaChannel.h>

#include <Swiften/Elements/Message.h>

#include <Swiften/Elements/Presence.h>

#include <Swiften/Entity/Entity.h>

#include <Swiften/JID/JID.h>

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

#include <Swiften/Serializer/PayloadSerializers/FullPayloadSerializerCollection.h>

namespace Swift {

class IQRouter;

class NetworkFactories;

/**

* The central class for communicating with an XMPP server as a component.

*

* This class is responsible for setting up the connection with the XMPP

* server and authenticating the component.

*

* This class can be used directly in your application, although the Component

* subclass provides more functionality and interfaces, and is better suited

* for most needs.

*/

class SWIFTEN_API CoreComponent : public Entity {

public:

CoreComponent(const JID& jid, const std::string& secret, NetworkFactories* networkFactories);

virtual ~CoreComponent();

void connect(const std::string& host, int port);

void disconnect();

void sendMessage(std::shared_ptr<Message>);

void sendPresence(std::shared_ptr<Presence>);

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

IQRouter* getIQRouter() const {

return iqRouter_;

}

StanzaChannel* getStanzaChannel() const {

return stanzaChannel_;

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <string>

#include <boost/optional.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/JID/JID.h>

namespace Swift {

class SWIFTEN_API MUCOccupant {

public:

enum Role {Moderator, Participant, Visitor, NoRole};

enum Affiliation {Owner, Admin, Member, Outcast, NoAffiliation};

MUCOccupant(const std::string &nick, Role role, Affiliation affiliation);

MUCOccupant(const MUCOccupant& other);

~MUCOccupant();

MUCOccupant& operator=(MUCOccupant other);

std::string getNick() const;

Role getRole() const;

Affiliation getAffiliation() const;

boost::optional<JID> getRealJID() const;

void setRealJID(const JID& jid);

void setNick(const std::string& nick);

private:

std::string nick_;

Role role_;

Affiliation affiliation_;

boost::optional<JID> realJID_;

/* If you add a field, remember to update the const copy constructor */

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <string>

#include <boost/cstdint.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Base/ByteArray.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/JingleS5BTransportPayload.h>

#include <Swiften/FileTransfer/FileTransferOptions.h>

#include <Swiften/FileTransfer/IncomingFileTransfer.h>

#include <Swiften/FileTransfer/JingleFileTransfer.h>

#include <Swiften/Jingle/JingleContentID.h>

namespace Swift {

class CryptoProvider;

class IncrementalBytestreamHashCalculator;

class JingleFileTransferDescription;

/**

* @brief The IncomingJingleFileTransfer class contains the business logic for managing incoming

* Jingle file transfers.

*

* Calling IncomingJingleFileTransfer::accept will start to negotiate possible transfer

* methods and after a working method has been decided among peers the trasnfer is started.

*/

class SWIFTEN_API IncomingJingleFileTransfer : public IncomingFileTransfer, public JingleFileTransfer {

public:

typedef std::shared_ptr<IncomingJingleFileTransfer> ref;

IncomingJingleFileTransfer(

const JID& recipient,

std::shared_ptr<JingleSession>,

std::shared_ptr<JingleContentPayload> content,

FileTransferTransporterFactory*,

TimerFactory*,

CryptoProvider*);

virtual ~IncomingJingleFileTransfer();

virtual void accept(std::shared_ptr<WriteBytestream>, const FileTransferOptions& = FileTransferOptions()) SWIFTEN_OVERRIDE;

virtual void cancel() SWIFTEN_OVERRIDE;

private:

enum State {

Initial,

GeneratingInitialLocalCandidates,

TryingCandidates,

WaitingForPeerProxyActivate,

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <vector>

#include <boost/signals2.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/ErrorPayload.h>

#include <Swiften/Elements/JingleS5BTransportPayload.h>

#include <Swiften/FileTransfer/FileTransfer.h>

#include <Swiften/Jingle/AbstractJingleSessionListener.h>

#include <Swiften/Jingle/JingleContentID.h>

namespace Swift {

class JingleSession;

class FileTransferTransporter;

class FileTransferTransporterFactory;

class TransportSession;

class SWIFTEN_API JingleFileTransfer : public AbstractJingleSessionListener {

public:

JingleFileTransfer(

std::shared_ptr<JingleSession>,

const JID& target,

FileTransferTransporterFactory*);

virtual ~JingleFileTransfer();

protected:

virtual void handleTransportInfoReceived(const JingleContentID&, JingleTransportPayload::ref);

virtual void handleLocalTransportCandidatesGenerated(

const std::string& s5bSessionID,

const std::vector<JingleS5BTransportPayload::Candidate>&,

const std::string& dstAddr) = 0;

virtual void handleProxyActivateFinished(

const std::string& s5bSessionID,

ErrorPayload::ref error);

virtual void decideOnCandidates();

void handleRemoteTransportCandidateSelectFinished(

const std::string& s5bSessionID, const boost::optional<JingleS5BTransportPayload::Candidate>&);

virtual JingleContentID getContentID() const = 0;

virtual void startTransferring(std::shared_ptr<TransportSession>) = 0;

virtual void terminate(JinglePayload::Reason::Type reason) = 0;

virtual void fallback() = 0;

virtual bool hasPriorityOnCandidateTie() const = 0;

/*

* Copyright (c) 2011 Tobias Markmann

* Licensed under the simplified BSD license.

* See Documentation/Licenses/BSD-simplified.txt for more information.

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <boost/optional/optional.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/JingleFileTransferFileInfo.h>

#include <Swiften/FileTransfer/FileTransferOptions.h>

#include <Swiften/FileTransfer/JingleFileTransfer.h>

#include <Swiften/FileTransfer/OutgoingFileTransfer.h>

#include <Swiften/Jingle/JingleContentID.h>

#include <Swiften/Network/Timer.h>

namespace Swift {

class CryptoProvider;

class FileTransferTransporterFactory;

class IDGenerator;

class IncrementalBytestreamHashCalculator;

class ReadBytestream;

class TimerFactory;

class TransportSession;

class SWIFTEN_API OutgoingJingleFileTransfer : public OutgoingFileTransfer, public JingleFileTransfer {

public:

OutgoingJingleFileTransfer(

const JID& to,

std::shared_ptr<JingleSession>,

std::shared_ptr<ReadBytestream>,

FileTransferTransporterFactory*,

TimerFactory*,

IDGenerator*,

const JingleFileTransferFileInfo&,

const FileTransferOptions&,

CryptoProvider*);

virtual ~OutgoingJingleFileTransfer();

virtual void start() SWIFTEN_OVERRIDE;

virtual void cancel() SWIFTEN_OVERRIDE;

private:

enum State {

Initial,

GeneratingInitialLocalCandidates,

WaitingForAccept,

TryingCandidates,

/*

* Copyright (c) 2011 Tobias Markmann

* Licensed under the simplified BSD license.

* See Documentation/Licenses/BSD-simplified.txt for more information.

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <boost/optional.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Base/ByteArray.h>

#include <Swiften/FileTransfer/FileTransferError.h>

#include <Swiften/FileTransfer/ReadBytestream.h>

#include <Swiften/FileTransfer/WriteBytestream.h>

#include <Swiften/JID/JID.h>

#include <Swiften/Network/Connection.h>

#include <Swiften/Network/HostAddressPort.h>

#include <Swiften/Network/Timer.h>

namespace Swift {

class Connection;

class TimerFactory;

/**

* A session which has been connected to a SOCKS5 server (requester).

*

*/

class SWIFTEN_API SOCKS5BytestreamClientSession {

public:

enum State {

Initial,

Hello,

Authenticating,

Ready,

Writing,

Reading,

Finished

};

public:

typedef std::shared_ptr<SOCKS5BytestreamClientSession> ref;

public:

SOCKS5BytestreamClientSession(

std::shared_ptr<Connection> connection,

const HostAddressPort&,

const std::string&,

TimerFactory*);

~SOCKS5BytestreamClientSession();

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <map>

#include <set>

#include <string>

#include <Swiften/Base/API.h>

#include <Swiften/Base/IDGenerator.h>

namespace Swift {

class SWIFTEN_API SOCKS5BytestreamRegistry {

public:

SOCKS5BytestreamRegistry();

void setHasBytestream(const std::string& destination, bool);

bool hasBytestream(const std::string& destination) const;

/**

* Generate a new session ID to use for new S5B streams.

*/

std::string generateSessionID();

private:

std::set<std::string> availableBytestreams;

IDGenerator idGenerator;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <map>

#include <memory>

#include <string>

#include <Swiften/Base/API.h>

#include <Swiften/FileTransfer/ReadBytestream.h>

#include <Swiften/FileTransfer/SOCKS5BytestreamRegistry.h>

#include <Swiften/JID/JID.h>

#include <Swiften/Network/ConnectionServer.h>

namespace Swift {

class SOCKS5BytestreamServerSession;

class SWIFTEN_API SOCKS5BytestreamServer {

public:

SOCKS5BytestreamServer(

std::shared_ptr<ConnectionServer> connectionServer,

SOCKS5BytestreamRegistry* registry);

HostAddressPort getAddressPort() const;

void start();

void stop();

std::vector< std::shared_ptr<SOCKS5BytestreamServerSession> > getSessions(const std::string& id) const;

private:

void handleNewConnection(std::shared_ptr<Connection> connection);

void handleSessionFinished(std::shared_ptr<SOCKS5BytestreamServerSession>);

private:

friend class SOCKS5BytestreamServerSession;

std::shared_ptr<ConnectionServer> connectionServer;

SOCKS5BytestreamRegistry* registry;

std::vector<std::shared_ptr<SOCKS5BytestreamServerSession> > sessions;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <map>

#include <memory>

#include <Swiften/Jingle/JingleSession.h>

#include <Swiften/Queries/GenericRequest.h>

namespace Swift {

class IQRouter;

class JingleSessionImpl : public JingleSession {

friend class JingleResponder;

public:

typedef std::shared_ptr<JingleSessionImpl> ref;

JingleSessionImpl(const JID& initiator, const JID&, const std::string& id, IQRouter* router);

virtual void sendInitiate(const JingleContentID&, JingleDescription::ref, JingleTransportPayload::ref);

virtual void sendTerminate(JinglePayload::Reason::Type reason);

virtual void sendInfo(std::shared_ptr<Payload>);

virtual void sendAccept(const JingleContentID&, JingleDescription::ref, JingleTransportPayload::ref);

virtual std::string sendTransportInfo(const JingleContentID&, JingleTransportPayload::ref);

virtual void sendTransportAccept(const JingleContentID&, JingleTransportPayload::ref);

virtual void sendTransportReject(const JingleContentID&, JingleTransportPayload::ref);

virtual void sendTransportReplace(const JingleContentID&, JingleTransportPayload::ref);

private:

typedef std::shared_ptr<GenericRequest<JinglePayload> > RequestRef;

void handleIncomingAction(JinglePayload::ref);

std::string sendSetRequest(JinglePayload::ref payload);

JinglePayload::ref createPayload() const;

void handleRequestResponse(RequestRef);

private:

IQRouter *iqRouter;

JID peerJID;

typedef std::map<RequestRef, boost::signals2::connection > RequestsMap;

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <list>

#include <memory>

#include <set>

#include <string>

#include <Swiften/Base/API.h>

#include <Swiften/Base/ByteArray.h>

#include <Swiften/EventLoop/EventOwner.h>

#include <Swiften/LinkLocal/DNSSD/DNSSDQuerier.h>

#include <Swiften/LinkLocal/DNSSD/DNSSDResolveServiceQuery.h>

#include <Swiften/Network/HostAddress.h>

namespace Swift {

class FakeDNSSDQuery;

class EventLoop;

class SWIFTEN_API FakeDNSSDQuerier :

public DNSSDQuerier,

public EventOwner,

public std::enable_shared_from_this<FakeDNSSDQuerier> {

public:

FakeDNSSDQuerier(const std::string& domain, EventLoop* eventLoop);

~FakeDNSSDQuerier();

void start() {}

void stop() {}

void clearAllQueriesEverRun() {

allQueriesEverRun.clear();

}

std::shared_ptr<DNSSDBrowseQuery> createBrowseQuery();

std::shared_ptr<DNSSDRegisterQuery> createRegisterQuery(

const std::string& name, int port, const ByteArray& info);

std::shared_ptr<DNSSDResolveServiceQuery> createResolveServiceQuery(

const DNSSDServiceID&);

std::shared_ptr<DNSSDResolveHostnameQuery> createResolveHostnameQuery(

const std::string& hostname, int interfaceIndex);

void addRunningQuery(std::shared_ptr<FakeDNSSDQuery>);

void removeRunningQuery(std::shared_ptr<FakeDNSSDQuery>);

void addService(const DNSSDServiceID& id);

void removeService(const DNSSDServiceID& id);

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <vector>

#include <boost/signals2.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/LinkLocal/LinkLocalService.h>

#include <Swiften/Network/Connection.h>

namespace Swift {

class DNSSDQuerier;

class DNSSDResolveHostnameQuery;

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

public:

LinkLocalConnector(

const LinkLocalService& service,

std::shared_ptr<DNSSDQuerier> querier,

std::shared_ptr<Connection> connection);

~LinkLocalConnector();

const LinkLocalService& getService() const {

return service;

}

void connect();

void cancel();

void queueElement(std::shared_ptr<ToplevelElement> element);

const std::vector<std::shared_ptr<ToplevelElement> >& getQueuedElements() const {

return queuedElements;

}

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

return connection;

}

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

private:

void handleHostnameResolved(const boost::optional<HostAddress>& address);

void handleConnected(bool error);

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <vector>

#include <boost/signals2.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/JID/JID.h>

#include <Swiften/Session/Session.h>

namespace Swift {

class PayloadParserFactoryCollection;

class PayloadSerializerCollection;

class SWIFTEN_API OutgoingLinkLocalSession : public Session {

public:

OutgoingLinkLocalSession(

const JID& localJID,

const JID& remoteJID,

std::shared_ptr<Connection> connection,

PayloadParserFactoryCollection* payloadParserFactories,

PayloadSerializerCollection* payloadSerializers,

XMLParserFactory* xmlParserFactory);

void queueElement(std::shared_ptr<ToplevelElement> element);

private:

void handleSessionStarted();

void handleElement(std::shared_ptr<ToplevelElement>);

void handleStreamStart(const ProtocolHeader&);

private:

std::vector<std::shared_ptr<ToplevelElement> > queuedElements_;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <map>

#include <memory>

#include <string>

#include <boost/signals2.hpp>

#include <boost/signals2/connection.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/Form.h>

#include <Swiften/Elements/MUCAdminPayload.h>

#include <Swiften/Elements/MUCOccupant.h>

#include <Swiften/Elements/MUCOwnerPayload.h>

#include <Swiften/Elements/Message.h>

#include <Swiften/Elements/Presence.h>

#include <Swiften/JID/JID.h>

#include <Swiften/MUC/MUCRegistry.h>

namespace Swift {

class SWIFTEN_API MUC {

public:

typedef std::shared_ptr<MUC> ref;

enum JoinResult { JoinSucceeded, JoinFailed };

enum LeavingType { LeavePart, LeaveKick, LeaveBan, LeaveDestroy, LeaveNotMember, Disconnect };

public:

virtual ~MUC();

/**

* Returns the (bare) JID of the MUC.

*/

virtual JID getJID() const = 0;

/**

* Returns if the room is unlocked and other people can join the room.

* @return True if joinable by others; false otherwise.

*/

virtual bool isUnlocked() const = 0;

virtual void joinAs(const std::string &nick) = 0;

virtual void joinWithContextSince(const std::string &nick, const boost::posix_time::ptime& since) = 0;

/*virtual void queryRoomInfo(); */

/*virtual void queryRoomItems(); */

/*virtual std::string getCurrentNick() = 0; */

virtual std::map<std::string, MUCOccupant> getOccupants() const = 0;

virtual void changeNickname(const std::string& newNickname) = 0;

virtual void part() = 0;

/*virtual void handleIncomingMessage(Message::ref message) = 0; */

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <map>

#include <memory>

#include <string>

#include <boost/signals2.hpp>

#include <boost/signals2/connection.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/Form.h>

#include <Swiften/Elements/MUCAdminPayload.h>

#include <Swiften/Elements/MUCOccupant.h>

#include <Swiften/Elements/MUCOwnerPayload.h>

#include <Swiften/Elements/Message.h>

#include <Swiften/Elements/Presence.h>

#include <Swiften/JID/JID.h>

#include <Swiften/MUC/MUC.h>

#include <Swiften/MUC/MUCRegistry.h>

namespace Swift {

class SWIFTEN_API MockMUC : public MUC{

public:

typedef std::shared_ptr<MockMUC> ref;

public:

MockMUC(const JID &muc);

virtual ~MockMUC();

/**

* Cause a user to appear to have entered the room. For testing only.

*/

void insertOccupant(const MUCOccupant& occupant);

/**

* Returns the (bare) JID of the MUC.

*/

virtual JID getJID() const {

return ownMUCJID.toBare();

}

/**

* Returns if the room is unlocked and other people can join the room.

* @return True if joinable by others; false otherwise.

*/

virtual bool isUnlocked() const { return true; }

virtual void joinAs(const std::string&) {}

virtual void joinWithContextSince(const std::string&, const boost::posix_time::ptime&) {}

/*virtual void queryRoomInfo(); */

/*virtual void queryRoomItems(); */

/*virtual std::string getCurrentNick() = 0; */

/*

* Copyright (c) 2011 Thilo Cestonaro

* Licensed under the simplified BSD license.

* See Documentation/Licenses/BSD-simplified.txt for more information.

*/

/*

* Copyright (c) 2011-2017 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Error.h>

#include <Swiften/Base/String.h>

#include <Swiften/Base/URL.h>

#include <Swiften/Network/Connection.h>

#include <Swiften/Network/Connector.h>

#include <Swiften/Network/HostAddressPort.h>

#include <Swiften/Session/SessionStream.h>

#include <Swiften/TLS/TLSError.h>

class BOSHConnectionTest;

namespace Swift {

class XMLParserFactory;

class TLSContextFactory;

class TLSLayer;

struct TLSOptions;

class HighLayer;

class SWIFTEN_API BOSHError : public SessionStream::SessionStreamError {

public:

enum Type {

BadRequest, HostGone, HostUnknown, ImproperAddressing,

InternalServerError, ItemNotFound, OtherRequest, PolicyViolation,

RemoteConnectionFailed, RemoteStreamError, SeeOtherURI, SystemShutdown, UndefinedCondition,

NoError};

BOSHError(Type type) : SessionStream::SessionStreamError(SessionStream::SessionStreamError::ConnectionReadError), type(type) {}

Type getType() const {return type;}

typedef std::shared_ptr<BOSHError> ref;

private:

Type type;

};

class SWIFTEN_API BOSHConnection : public std::enable_shared_from_this<BOSHConnection> {

public:

typedef std::shared_ptr<BOSHConnection> ref;

static ref create(const URL& boshURL, Connector::ref connector, XMLParserFactory* parserFactory, TLSContextFactory* tlsContextFactory, const TLSOptions& tlsOptions) {

return ref(new BOSHConnection(boshURL, connector, parserFactory, tlsContextFactory, tlsOptions));

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <vector>

#include <Swiften/Base/API.h>

#include <Swiften/Base/SafeString.h>

#include <Swiften/Network/BOSHConnection.h>

#include <Swiften/TLS/CertificateWithKey.h>

#include <Swiften/TLS/TLSOptions.h>

namespace Swift {

class CachingDomainNameResolver;

class EventLoop;

class HTTPTrafficFilter;

class TLSContextFactory;

class CachingDomainNameResolver;

class EventLoop;

class SWIFTEN_API BOSHConnectionPool : public boost::signals2::trackable {

public:

BOSHConnectionPool(const URL& boshURL, DomainNameResolver* resolver, ConnectionFactory* connectionFactory, XMLParserFactory* parserFactory, TLSContextFactory* tlsFactory, TimerFactory* timerFactory, EventLoop* eventLoop, const std::string& to, unsigned long long initialRID, const URL& boshHTTPConnectProxyURL, const SafeString& boshHTTPConnectProxyAuthID, const SafeString& boshHTTPConnectProxyAuthPassword, const TLSOptions& tlsOptions, std::shared_ptr<HTTPTrafficFilter> trafficFilter = std::shared_ptr<HTTPTrafficFilter>());

~BOSHConnectionPool();

void open();

void write(const SafeByteArray& data);

void writeFooter();

void close();

void restartStream();

void setTLSCertificate(CertificateWithKey::ref certWithKey);

bool isTLSEncrypted() const;

Certificate::ref getPeerCertificate() const;

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

std::shared_ptr<CertificateVerificationError> getPeerCertificateVerificationError() const;

boost::signals2::signal<void ()> onTLSConnectionEstablished;

boost::signals2::signal<void (BOSHError::ref)> onSessionTerminated;

boost::signals2::signal<void ()> onSessionStarted;

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

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

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

private:

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <mutex>

#include <boost/asio/io_service.hpp>

#include <boost/asio/ip/tcp.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Base/SafeByteArray.h>

#include <Swiften/EventLoop/EventOwner.h>

#include <Swiften/Network/Connection.h>

#include <Swiften/TLS/Certificate.h>

#include <Swiften/TLS/CertificateVerificationError.h>

#include <Swiften/TLS/CertificateWithKey.h>

namespace Swift {

class EventLoop;

class SWIFTEN_API BoostConnection : public Connection, public EventOwner, public std::enable_shared_from_this<BoostConnection> {

public:

typedef std::shared_ptr<BoostConnection> ref;

virtual ~BoostConnection();

static ref create(std::shared_ptr<boost::asio::io_service> ioService, EventLoop* eventLoop) {

return ref(new BoostConnection(ioService, eventLoop));

}

virtual void listen();

virtual void connect(const HostAddressPort& address);

virtual void disconnect();

virtual void write(const SafeByteArray& data);

boost::asio::ip::tcp::socket& getSocket() {

return socket_;

}

virtual HostAddressPort getLocalAddress() const;

virtual HostAddressPort getRemoteAddress() const;

bool setClientCertificate(CertificateWithKey::ref cert);

Certificate::ref getPeerCertificate() const;

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

std::shared_ptr<CertificateVerificationError> getPeerCertificateVerificationError() const;

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <boost/asio/io_service.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Network/BoostConnection.h>

#include <Swiften/Network/ConnectionFactory.h>

namespace Swift {

class SWIFTEN_API BoostConnectionFactory : public ConnectionFactory {

public:

BoostConnectionFactory(std::shared_ptr<boost::asio::io_service>, EventLoop* eventLoop);

virtual std::shared_ptr<Connection> createConnection();

private:

std::shared_ptr<boost::asio::io_service> ioService;

EventLoop* eventLoop;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <boost/asio/io_service.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Network/BoostTimer.h>

#include <Swiften/Network/TimerFactory.h>

namespace Swift {

class EventLoop;

class SWIFTEN_API BoostTimerFactory : public TimerFactory {

public:

BoostTimerFactory(std::shared_ptr<boost::asio::io_service>, EventLoop* eventLoop);

virtual std::shared_ptr<Timer> createTimer(int milliseconds);

private:

std::shared_ptr<boost::asio::io_service> ioService;

EventLoop* eventLoop;

};

}

/*

* Copyright (c) 2010-2011 Thilo Cestonaro

* Licensed under the simplified BSD license.

* See Documentation/Licenses/BSD-simplified.txt for more information.

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Network/ProxiedConnection.h>

namespace Swift {

class ConnectionFactory;

class DomainNameResolver;

class HTTPTrafficFilter;

class TimerFactory;

class SWIFTEN_API HTTPConnectProxiedConnection : public ProxiedConnection {

public:

typedef std::shared_ptr<HTTPConnectProxiedConnection> ref;

virtual ~HTTPConnectProxiedConnection();

static ref create(DomainNameResolver* resolver, ConnectionFactory* connectionFactory, TimerFactory* timerFactory, const std::string& proxyHost, int proxyPort, const SafeString& authID, const SafeString& authPassword) {

return ref(new HTTPConnectProxiedConnection(resolver, connectionFactory, timerFactory, proxyHost, proxyPort, authID, authPassword));

}

void setHTTPTrafficFilter(std::shared_ptr<HTTPTrafficFilter> trafficFilter);

private:

HTTPConnectProxiedConnection(DomainNameResolver* resolver, ConnectionFactory* connectionFactory, TimerFactory* timerFactory, const std::string& proxyHost, int proxyPort, const SafeString& authID, const SafeString& authPassword);

virtual void initializeProxy();

virtual void handleProxyInitializeData(std::shared_ptr<SafeByteArray> data);

void sendHTTPRequest(const std::string& statusLine, const std::vector<std::pair<std::string, std::string> >& headerFields);

void parseHTTPHeader(const std::string& data, std::string& statusLine, std::vector<std::pair<std::string, std::string> >& headerFields);

private:

SafeByteArray authID_;

SafeByteArray authPassword_;

std::shared_ptr<HTTPTrafficFilter> trafficFilter_;

std::string httpResponseBuffer_;

std::vector<std::pair<std::string, std::string> > nextHTTPRequestHeaders_;

/*

* All rights reserved.

* See the COPYING file for more information.

*/

/*

* Copyright (c) 2010-2011 Thilo Cestonaro

* Licensed under the simplified BSD license.

* See Documentation/Licenses/BSD-simplified.txt for more information.

*/

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Base/SafeString.h>

#include <Swiften/Network/ConnectionFactory.h>

#include <Swiften/Network/HostAddressPort.h>

namespace Swift {

class DomainNameResolver;

class HTTPTrafficFilter;

class SWIFTEN_API HTTPConnectProxiedConnectionFactory : public ConnectionFactory {

public:

HTTPConnectProxiedConnectionFactory(DomainNameResolver* resolver, ConnectionFactory* connectionFactory, TimerFactory* timerFactory, const std::string& proxyHost, int proxyPort, std::shared_ptr<HTTPTrafficFilter> httpTrafficFilter = std::shared_ptr<HTTPTrafficFilter>());

HTTPConnectProxiedConnectionFactory(DomainNameResolver* resolver, ConnectionFactory* connectionFactory, TimerFactory* timerFactory, const std::string& proxyHost, int proxyPort, const SafeString& authID, const SafeString& authPassword, std::shared_ptr<HTTPTrafficFilter> httpTrafficFilter = std::shared_ptr<HTTPTrafficFilter>());

virtual std::shared_ptr<Connection> createConnection();

private:

DomainNameResolver* resolver_;

ConnectionFactory* connectionFactory_;

TimerFactory* timerFactory_;

std::string proxyHost_;

int proxyPort_;

SafeString authID_;

SafeString authPassword_;

std::shared_ptr<HTTPTrafficFilter> httpTrafficFilter_;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/API.h>

namespace Swift {

class ConnectionFactory;

class ConnectionServerFactory;

class EventLoop;

class IDNConverter;

class NetworkEnvironment;

/**

* An interface collecting network factories.

*/

class SWIFTEN_API NetworkFactories {

public:

virtual ~NetworkFactories();

virtual TimerFactory* getTimerFactory() const = 0;

virtual ConnectionFactory* getConnectionFactory() const = 0;

virtual DomainNameResolver* getDomainNameResolver() const = 0;

virtual ConnectionServerFactory* getConnectionServerFactory() const = 0;

virtual NATTraverser* getNATTraverser() const = 0;

virtual NetworkEnvironment* getNetworkEnvironment() const = 0;

virtual XMLParserFactory* getXMLParserFactory() const = 0;

virtual TLSContextFactory* getTLSContextFactory() const = 0;

virtual ProxyProvider* getProxyProvider() const = 0;

virtual EventLoop* getEventLoop() const = 0;

virtual IDNConverter* getIDNConverter() const = 0;

virtual CryptoProvider* getCryptoProvider() const = 0;

};

}

/*

* Copyright (c) 2011 Tobias Markmann

* Licensed under the simplified BSD license.

* See Documentation/Licenses/BSD-simplified.txt for more information.

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <condition_variable>

#include <deque>

#include <mutex>

#include <thread>

#include <boost/logic/tribool.hpp>

#include <boost/optional.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Atomic.h>

#include <Swiften/Network/HostAddressPort.h>

#include <Swiften/Network/NATTraverser.h>

#include <Swiften/Network/NullNATTraversalInterface.h>

namespace Swift {

class EventLoop;

class NATTraversalGetPublicIPRequest;

class NATTraversalForwardPortRequest;

class NATTraversalRemovePortForwardingRequest;

class PlatformNATTraversalRequest;

class NATPMPInterface;

class MiniUPnPInterface;

class NATTraversalInterface;

class SWIFTEN_API PlatformNATTraversalWorker : public NATTraverser {

friend class PlatformNATTraversalRequest;

public:

PlatformNATTraversalWorker(EventLoop* eventLoop);

virtual ~PlatformNATTraversalWorker();

std::shared_ptr<NATTraversalGetPublicIPRequest> createGetPublicIPRequest();

std::shared_ptr<NATTraversalForwardPortRequest> createForwardPortRequest(int localPort, int publicPort);

std::shared_ptr<NATTraversalRemovePortForwardingRequest> createRemovePortForwardingRequest(int localPort, int publicPort);

private:

NATTraversalInterface* getNATTraversalInterface() const;

void addRequestToQueue(std::shared_ptr<PlatformNATTraversalRequest>);

void start();

void stop();

EventLoop* getEventLoop() const {

return eventLoop;

}

private:

EventLoop* eventLoop;

Atomic<bool> stopRequested;

std::thread* thread;

std::deque<std::shared_ptr<PlatformNATTraversalRequest> > queue;

std::mutex queueMutex;

std::condition_variable queueNonEmpty;

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Base/SafeString.h>

#include <Swiften/Network/Connection.h>

#include <Swiften/Network/Connector.h>

#include <Swiften/Network/HostAddressPort.h>

namespace Swift {

class ConnectionFactory;

class SWIFTEN_API ProxiedConnection : public Connection, public std::enable_shared_from_this<ProxiedConnection> {

public:

ProxiedConnection(DomainNameResolver* resolver, ConnectionFactory* connectionFactory, TimerFactory* timerFactory, const std::string& proxyHost, int proxyPort);

virtual ~ProxiedConnection();

virtual void listen();

virtual void connect(const HostAddressPort& address);

virtual void disconnect();

virtual void write(const SafeByteArray& data);

virtual HostAddressPort getLocalAddress() const;

virtual HostAddressPort getRemoteAddress() const;

private:

void handleConnectFinished(Connection::ref connection);

void handleDataRead(std::shared_ptr<SafeByteArray> data);

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

void cancelConnector();

protected:

void setProxyInitializeFinished(bool success);

virtual void initializeProxy() = 0;

virtual void handleProxyInitializeData(std::shared_ptr<SafeByteArray> data) = 0;

const HostAddressPort& getServer() const {

return server_;

/*

* Copyright (c) 2013 Tobias Markmann

* Licensed under the simplified BSD license.

* See Documentation/Licenses/BSD-simplified.txt for more information.

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <boost/asio.hpp>

#include <Swiften/EventLoop/EventOwner.h>

#include <Swiften/Network/DomainNameResolver.h>

#include <Swiften/Network/Timer.h>

struct ub_ctx;

struct ub_result;

namespace Swift {

class EventLoop;

class IDNConverter;

class UnboundDomainNameResolver;

class UnboundQuery;

class UnboundDomainNameResolver : public DomainNameResolver, public EventOwner, public std::enable_shared_from_this<UnboundDomainNameResolver> {

public:

UnboundDomainNameResolver(IDNConverter* idnConverter, std::shared_ptr<boost::asio::io_service> ioService, EventLoop* eventLoop);

virtual ~UnboundDomainNameResolver();

virtual std::shared_ptr<DomainNameServiceQuery> createServiceQuery(const std::string& serviceLookupPrefix, const std::string& domain);

virtual std::shared_ptr<DomainNameAddressQuery> createAddressQuery(const std::string& name);

static void unbound_callback_wrapper(void* data, int err, ub_result* result);

private:

void unbound_callback(std::shared_ptr<UnboundQuery> query, int err, ub_result* result);

void handleUBSocketReadable(boost::system::error_code);

void processData();

private:

IDNConverter* idnConverter;

std::shared_ptr<EventOwner> eventOwner;

std::shared_ptr<boost::asio::io_service> ioService;

boost::asio::posix::stream_descriptor ubDescriptior;

EventLoop* eventLoop;

ub_ctx* ubContext;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Parser/ElementParser.h>

namespace Swift {

template<typename ElementType>

class SWIFTEN_API GenericElementParser : public ElementParser {

public:

GenericElementParser() {

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

}

virtual std::shared_ptr<ToplevelElement> getElement() const {

return stanza_;

}

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

return stanza_;

}

private:

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

}

virtual void handleEndElement(const std::string&, const std::string&) {

}

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

}

private:

std::shared_ptr<ElementType> stanza_;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Parser/PayloadParser.h>

namespace Swift {

/**

* A generic payload parser for payloads of the given type.

*

* This class provides getPayloadInternal() for retrieving the actual

* payload.

*/

template<typename PAYLOAD_TYPE>

class GenericPayloadParser : public PayloadParser {

public:

GenericPayloadParser() : PayloadParser() {

payload_ = std::make_shared<PAYLOAD_TYPE>();

}

virtual std::shared_ptr<Payload> getPayload() const {

return payload_;

}

virtual std::shared_ptr<PAYLOAD_TYPE> getPayloadInternal() const {

return payload_;

}

private:

std::shared_ptr<PAYLOAD_TYPE> payload_;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Parser/PayloadParserFactory.h>

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

namespace Swift {

class SWIFTEN_API ChatStateParserFactory : public PayloadParserFactory {

public:

ChatStateParserFactory() {

}

virtual bool canParse(const std::string& element, const std::string& ns, const AttributeMap&) const {

return ns == "http://jabber.org/protocol/chatstates" &&

(element == "active" || element == "composing"

|| element == "paused" || element == "inactive" || element == "gone");

}

virtual PayloadParser* createPayloadParser() {

return new ChatStateParser();

}

};

}

/*

* Copyright (c) 2017 Tarun Gupta.

* Licensed under the simplified BSD license.

* See Documentation/Licenses/BSD-simplified.txt for more information.

*/

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Parser/PayloadParserFactory.h>

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

namespace Swift {

class SWIFTEN_API ClientStateParserFactory : public PayloadParserFactory {

public:

ClientStateParserFactory() {

}

virtual bool canParse(const std::string& element, const std::string& ns, const AttributeMap&) const {

return ns == "urn:xmpp:csi:0" &&

(element == "active" || element == "inactive");

}

virtual PayloadParser* createPayloadParser() {

return new ClientStateParser();

}

};

}

/*

* Copyright (c) 2011 Tobias Markmann

* Licensed under the BSD license.

* See http://www.opensource.org/licenses/bsd-license.php for more information.

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Parser/PayloadParserFactory.h>

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

namespace Swift {

class SWIFTEN_API DeliveryReceiptParserFactory : public PayloadParserFactory {

public:

DeliveryReceiptParserFactory() {

}

virtual bool canParse(const std::string& element, const std::string& ns, const AttributeMap&) const {

return ns == "urn:xmpp:receipts" && element == "received";

}

virtual PayloadParser* createPayloadParser() {

return new DeliveryReceiptParser();

}

};

}

/*

* Copyright (c) 2011 Tobias Markmann

* Licensed under the BSD license.

* See http://www.opensource.org/licenses/bsd-license.php for more information.

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Parser/PayloadParserFactory.h>

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

namespace Swift {

class SWIFTEN_API DeliveryReceiptRequestParserFactory : public PayloadParserFactory {

public:

DeliveryReceiptRequestParserFactory() {

}

virtual bool canParse(const std::string& element, const std::string& ns, const AttributeMap&) const {

return ns == "urn:xmpp:receipts" && element == "request";

}

virtual PayloadParser* createPayloadParser() {

return new DeliveryReceiptRequestParser();

}

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Elements/DiscoInfo.h>

#include <Swiften/Parser/GenericPayloadParser.h>

namespace Swift {

class SWIFTEN_API DiscoInfoParser : public GenericPayloadParser<DiscoInfo> {

public:

DiscoInfoParser();

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

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

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

private:

enum Level {

TopLevel = 0,

PayloadLevel = 1

};

int level_;

FormParser* formParser_;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Parser/PayloadParserFactory.h>

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

namespace Swift {

class SWIFTEN_API FormParserFactory : public PayloadParserFactory {

public:

FormParserFactory() {

}

virtual bool canParse(const std::string& /*element*/, const std::string& ns, const AttributeMap&) const {

return ns == "jabber:x:data";

}

virtual PayloadParser* createPayloadParser() {

return new FormParser();

}

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubError.h>

#include <Swiften/Parser/EnumParser.h>

#include <Swiften/Parser/GenericPayloadParser.h>

namespace Swift {

class SWIFTEN_API PubSubErrorParser : public GenericPayloadParser<PubSubError> {

public:

PubSubErrorParser();

virtual ~PubSubErrorParser();

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

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

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

private:

int level;

EnumParser<PubSubError::Type> typeParser;

EnumParser<PubSubError::UnsupportedFeatureType> unsupportedTypeParser;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/ResultSet.h>

#include <Swiften/Parser/GenericPayloadParser.h>

namespace Swift {

class SWIFTEN_API ResultSetParser : public GenericPayloadParser<ResultSet> {

public:

ResultSetParser();

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

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

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

enum Level {

TopLevel = 0,

PayloadLevel = 1

};

private:

std::string currentText_;

int level_;

};

}

/*

* Copyright (c) 2011 Jan Kaluza

* Licensed under the Simplified BSD license.

* See Documentation/Licenses/BSD-simplified.txt for more information.

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Elements/RosterItemExchangePayload.h>

#include <Swiften/Parser/GenericPayloadParser.h>

namespace Swift {

class SWIFTEN_API RosterItemExchangeParser : public GenericPayloadParser<RosterItemExchangePayload> {

public:

RosterItemExchangeParser();

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

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

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

private:

enum Level {

TopLevel = 0,

PayloadLevel = 1,

ItemLevel = 2

};

int level_;

bool inItem_;

RosterItemExchangePayload::Item currentItem_;

std::string currentText_;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Elements/VCardUpdate.h>

#include <Swiften/Parser/GenericPayloadParser.h>

namespace Swift {

class SWIFTEN_API VCardUpdateParser : public GenericPayloadParser<VCardUpdate> {

public:

VCardUpdateParser();

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

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

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

private:

enum Level {

TopLevel = 0,

PayloadLevel = 1

};

int level_;

std::string currentText_;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Elements/Payload.h>

#include <Swiften/Presence/PresenceSender.h>

namespace Swift {

/**

* This presence sender adds payloads to outgoing presences.

*

* This class isn't meant to be used with directed presence.

*/

class SWIFTEN_API PayloadAddingPresenceSender : public PresenceSender {

public:

PayloadAddingPresenceSender(PresenceSender*);

void sendPresence(std::shared_ptr<Presence>);

bool isAvailable() const;

/**

* Sets the payload to be added to outgoing presences.

* If initial presence has been sent, this will resend the last sent presence

* with an updated payload. Initial presence is reset when unavailable presence is

* sent, or when reset() is called.

*/

void setPayload(std::shared_ptr<Payload>);

/**

* Resets the presence sender.

* This puts the presence sender back in the initial state (before initial

* presence has been sent).

* This also resets the chained sender.

*/

void reset();

private:

std::shared_ptr<Presence> lastSentPresence;

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/PubSub/PubSubManager.h>

#define SWIFTEN_PUBSUBMANAGERIMPL_DECLARE_CREATE_REQUEST(payload, container, response) \

virtual std::shared_ptr< PubSubRequest<payload> > \

createRequest(IQ::Type type, const JID& receiver, std::shared_ptr<payload> p) SWIFTEN_OVERRIDE { \

return std::make_shared< PubSubRequest<payload> >(type, receiver, p, router); \

}

namespace Swift {

class StanzaChannel;

class Message;

class SWIFTEN_API PubSubManagerImpl : public PubSubManager {

public:

PubSubManagerImpl(StanzaChannel* stanzaChannel, IQRouter* router);

virtual ~PubSubManagerImpl();

SWIFTEN_PUBSUB_FOREACH_PUBSUB_PAYLOAD_TYPE(

SWIFTEN_PUBSUBMANAGERIMPL_DECLARE_CREATE_REQUEST)

private:

void handleMessageRecevied(std::shared_ptr<Message>);

private:

StanzaChannel* stanzaChannel;

IQRouter* router;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/IQ.h>

namespace Swift {

class SWIFTEN_API IQHandler {

public:

virtual ~IQHandler();

virtual bool handleIQ(std::shared_ptr<IQ>) = 0;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <string>

#include <boost/optional.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/ErrorPayload.h>

#include <Swiften/Elements/IQ.h>

#include <Swiften/Elements/Payload.h>

#include <Swiften/JID/JID.h>

#include <Swiften/Queries/IQHandler.h>

namespace Swift {

/**

* An IQ get/set request query.

*/

class SWIFTEN_API Request : public IQHandler, public std::enable_shared_from_this<Request> {

public:

std::string send();

const JID& getReceiver() const {

return receiver_;

}

/**

* Returns the ID of this request.

* This will only be set after send() is called.

*/

const std::string& getID() const {

return id_;

}

protected:

/**

* Constructs a request of a certain type to a specific receiver, and attaches the given

* payload.

*/

Request(

IQ::Type type,

const JID& receiver,

std::shared_ptr<Payload> payload,

IQRouter* router);

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Elements/Bytestreams.h>

#include <Swiften/Serializer/GenericPayloadSerializer.h>

namespace Swift {

class SWIFTEN_API BytestreamsSerializer : public GenericPayloadSerializer<Bytestreams> {

public:

BytestreamsSerializer();

virtual std::string serializePayload(std::shared_ptr<Bytestreams>) const;

};

}

/*

* Copyright (c) 2011 Tobias Markmann

* Licensed under the simplified BSD license.

* See Documentation/Licenses/BSD-simplified.txt for more information.

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Elements/JingleContentPayload.h>

#include <Swiften/Serializer/GenericPayloadSerializer.h>

namespace Swift {

class SWIFTEN_API JingleContentPayloadSerializer : public GenericPayloadSerializer<JingleContentPayload> {

public:

JingleContentPayloadSerializer();

virtual std::string serializePayload(std::shared_ptr<JingleContentPayload>) const;

private:

std::string creatorToString(JingleContentPayload::Creator creator) const;

};

}

/*

* Copyright (c) 2011 Tobias Markmann

* Licensed under the simplified BSD license.

* See Documentation/Licenses/BSD-simplified.txt for more information.

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Elements/JingleFileTransferDescription.h>

#include <Swiften/Serializer/GenericPayloadSerializer.h>

namespace Swift {

class SWIFTEN_API JingleFileTransferDescriptionSerializer : public GenericPayloadSerializer<JingleFileTransferDescription> {

public:

JingleFileTransferDescriptionSerializer();

virtual std::string serializePayload(std::shared_ptr<JingleFileTransferDescription>) const;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Elements/JingleFileTransferFileInfo.h>

#include <Swiften/Serializer/GenericPayloadSerializer.h>

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

namespace Swift {

class SWIFTEN_API JingleFileTransferFileInfoSerializer : public GenericPayloadSerializer<JingleFileTransferFileInfo> {

public:

JingleFileTransferFileInfoSerializer();

virtual std::string serializePayload(std::shared_ptr<JingleFileTransferFileInfo>) const;

};

}

/*

* Copyright (c) 2011 Tobias Markmann

* Licensed under the simplified BSD license.

* See Documentation/Licenses/BSD-simplified.txt for more information.

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Elements/JingleFileTransferHash.h>

#include <Swiften/Serializer/GenericPayloadSerializer.h>

namespace Swift {

class SWIFTEN_API JingleFileTransferHashSerializer : public GenericPayloadSerializer<JingleFileTransferHash> {

public:

JingleFileTransferHashSerializer();

virtual std::string serializePayload(std::shared_ptr<JingleFileTransferHash>) const;

};

}

/*

* Copyright (c) 2011 Tobias Markmann

* Licensed under the simplified BSD license.

* See Documentation/Licenses/BSD-simplified.txt for more information.

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Elements/JingleIBBTransportPayload.h>

#include <Swiften/Serializer/GenericPayloadSerializer.h>

namespace Swift {

class SWIFTEN_API JingleIBBTransportPayloadSerializer : public GenericPayloadSerializer<JingleIBBTransportPayload> {

public:

JingleIBBTransportPayloadSerializer();

virtual std::string serializePayload(std::shared_ptr<JingleIBBTransportPayload>) const;

};

}

/*

* Copyright (c) 2011 Tobias Markmann

* Licensed under the simplified BSD license.

* See Documentation/Licenses/BSD-simplified.txt for more information.

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Elements/JinglePayload.h>

#include <Swiften/Serializer/GenericPayloadSerializer.h>

namespace Swift {

class PayloadSerializerCollection;

class SWIFTEN_API JinglePayloadSerializer : public GenericPayloadSerializer<JinglePayload> {

public:

JinglePayloadSerializer(PayloadSerializerCollection*);

virtual std::string serializePayload(std::shared_ptr<JinglePayload>) const;

private:

std::string actionToString(JinglePayload::Action action) const;

std::string reasonTypeToString(JinglePayload::Reason::Type type) const;

private:

PayloadSerializerCollection* serializers;

};

}

/*

* Copyright (c) 2011 Tobias Markmann

* Licensed under the simplified BSD license.

* See Documentation/Licenses/BSD-simplified.txt for more information.

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Elements/JingleS5BTransportPayload.h>

#include <Swiften/Serializer/GenericPayloadSerializer.h>

namespace Swift {

class SWIFTEN_API JingleS5BTransportPayloadSerializer : public GenericPayloadSerializer<JingleS5BTransportPayload> {

public:

JingleS5BTransportPayloadSerializer();

virtual std::string serializePayload(std::shared_ptr<JingleS5BTransportPayload>) const;

private:

std::string modeToString(JingleS5BTransportPayload::Mode) const;

std::string typeToString(JingleS5BTransportPayload::Candidate::Type) const;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/MAMFin.h>

#include <Swiften/Serializer/GenericPayloadSerializer.h>

namespace Swift {

class SWIFTEN_API MAMFinSerializer : public GenericPayloadSerializer<MAMFin> {

public:

MAMFinSerializer();

virtual ~MAMFinSerializer();

virtual std::string serializePayload(std::shared_ptr<MAMFin>) const SWIFTEN_OVERRIDE;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/MAMQuery.h>

#include <Swiften/Serializer/GenericPayloadSerializer.h>

namespace Swift {

class SWIFTEN_API MAMQuerySerializer : public GenericPayloadSerializer<MAMQuery> {

public:

MAMQuerySerializer();

virtual ~MAMQuerySerializer();

virtual std::string serializePayload(std::shared_ptr<MAMQuery>) const SWIFTEN_OVERRIDE;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Elements/MUCDestroyPayload.h>

#include <Swiften/Serializer/GenericPayloadSerializer.h>

namespace Swift {

class SWIFTEN_API MUCDestroyPayloadSerializer : public GenericPayloadSerializer<MUCDestroyPayload> {

public:

MUCDestroyPayloadSerializer();

virtual std::string serializePayload(std::shared_ptr<MUCDestroyPayload> version) const;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/PubSubError.h>

#include <Swiften/Serializer/GenericPayloadSerializer.h>

namespace Swift {

class SWIFTEN_API PubSubErrorSerializer : public GenericPayloadSerializer<PubSubError> {

public:

PubSubErrorSerializer();

virtual ~PubSubErrorSerializer();

virtual std::string serializePayload(std::shared_ptr<PubSubError>) const SWIFTEN_OVERRIDE;

private:

static std::string serializeType(PubSubError::Type);

static std::string serializeUnsupportedFeatureType(PubSubError::UnsupportedFeatureType);

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/ResultSet.h>

#include <Swiften/Serializer/GenericPayloadSerializer.h>

namespace Swift {

class SWIFTEN_API ResultSetSerializer : public GenericPayloadSerializer<ResultSet> {

public:

ResultSetSerializer();

virtual ~ResultSetSerializer();

virtual std::string serializePayload(std::shared_ptr<ResultSet>) const SWIFTEN_OVERRIDE;

};

}

/*

* Copyright (c) 2011 Tobias Markmann

* Licensed under the simplified BSD license.

* See Documentation/Licenses/BSD-simplified.txt for more information.

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <boost/lexical_cast.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/S5BProxyRequest.h>

#include <Swiften/Serializer/GenericPayloadSerializer.h>

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

namespace Swift {

class SWIFTEN_API S5BProxyRequestSerializer : public GenericPayloadSerializer<S5BProxyRequest> {

public:

virtual std::string serializePayload(std::shared_ptr<S5BProxyRequest> s5bProxyRequest) const {

XMLElement queryElement("query", "http://jabber.org/protocol/bytestreams");

if (s5bProxyRequest && s5bProxyRequest->getStreamHost()) {

std::shared_ptr<XMLElement> streamHost = std::make_shared<XMLElement>("streamhost");

streamHost->setAttribute("host", s5bProxyRequest->getStreamHost().get().host);

streamHost->setAttribute("port", boost::lexical_cast<std::string>(s5bProxyRequest->getStreamHost().get().port));

streamHost->setAttribute("jid", s5bProxyRequest->getStreamHost().get().jid.toString());

queryElement.addNode(streamHost);

} else if (s5bProxyRequest && s5bProxyRequest->getActivate()) {

queryElement.setAttribute("sid", s5bProxyRequest->getSID());

std::shared_ptr<XMLElement> activate = std::make_shared<XMLElement>("activate", "", s5bProxyRequest->getActivate().get().toString());

queryElement.addNode(activate);

}

return queryElement.serialize();

}

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Elements/SearchPayload.h>

#include <Swiften/Serializer/GenericPayloadSerializer.h>

namespace Swift {

class SWIFTEN_API SearchPayloadSerializer : public GenericPayloadSerializer<SearchPayload> {

public:

SearchPayloadSerializer();

virtual std::string serializePayload(std::shared_ptr<SearchPayload>) const;

};

}

/*

* Copyright (c) 2011 Tobias Markmann

* Licensed under the simplified BSD license.

* See Documentation/Licenses/BSD-simplified.txt for more information.

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Elements/StreamInitiationFileInfo.h>

#include <Swiften/Serializer/GenericPayloadSerializer.h>

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

namespace Swift {

class SWIFTEN_API StreamInitiationFileInfoSerializer : public GenericPayloadSerializer<StreamInitiationFileInfo> {

public:

StreamInitiationFileInfoSerializer();

virtual std::string serializePayload(std::shared_ptr<StreamInitiationFileInfo>) const;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <string>

#include <vector>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/StreamType.h>

#include <Swiften/Elements/ToplevelElement.h>

#include <Swiften/Serializer/ElementSerializer.h>

namespace Swift {

class PayloadSerializerCollection;

class ProtocolHeader;

class SWIFTEN_API XMPPSerializer {

public:

XMPPSerializer(PayloadSerializerCollection*, StreamType type, bool setExplictNSonTopLevelElements);

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

SafeByteArray serializeElement(std::shared_ptr<ToplevelElement> stanza) const;

std::string serializeFooter() const;

private:

std::string getDefaultNamespace() const;

private:

StreamType type_;

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

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Base/SafeByteArray.h>

#include <Swiften/Base/SafeString.h>

#include <Swiften/Elements/StreamType.h>

#include <Swiften/EventLoop/EventOwner.h>

#include <Swiften/Network/BOSHConnectionPool.h>

#include <Swiften/Session/SessionStream.h>

#include <Swiften/TLS/TLSOptions.h>

namespace Swift {

class EventLoop;

class HTTPTrafficFilter;

class PayloadParserFactoryCollection;

class PayloadSerializerCollection;

class TLSContextFactory;

class TimerFactory;

class XMLParserFactory;

class XMPPLayer;

class SWIFTEN_API BOSHSessionStream : public SessionStream, public EventOwner, public std::enable_shared_from_this<BOSHSessionStream> {

public:

BOSHSessionStream(

const URL& boshURL,

PayloadParserFactoryCollection* payloadParserFactories,

PayloadSerializerCollection* payloadSerializers,

ConnectionFactory* connectionFactory,

TLSContextFactory* tlsContextFactory,

TimerFactory* whitespacePingLayerFactory,

XMLParserFactory* xmlParserFactory,

EventLoop* eventLoop,

DomainNameResolver* resolver,

const std::string& to,

const URL& boshHTTPConnectProxyURL,

const SafeString& boshHTTPConnectProxyAuthID,

const SafeString& boshHTTPConnectProxyAuthPassword,

const TLSOptions& tlsOptions,

std::shared_ptr<HTTPTrafficFilter> trafficFilter

);

virtual ~BOSHSessionStream();

void open();

virtual void close();

virtual bool isOpen();

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <boost/optional.hpp>

#include <boost/signals2.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Base/SafeByteArray.h>

#include <Swiften/Elements/ToplevelElement.h>

#include <Swiften/JID/JID.h>

#include <Swiften/Network/Connection.h>

#include <Swiften/StreamStack/ConnectionLayer.h>

namespace Swift {

class ProtocolHeader;

class StreamStack;

class PayloadParserFactoryCollection;

class PayloadSerializerCollection;

class XMPPLayer;

class XMLParserFactory;

class SWIFTEN_API Session : public std::enable_shared_from_this<Session> {

public:

enum SessionError {

ConnectionReadError,

ConnectionWriteError,

XMLError,

AuthenticationFailedError,

NoSupportedAuthMechanismsError,

UnexpectedElementError,

ResourceBindError,

SessionStartError,

TLSError,

ClientCertificateLoadError,

ClientCertificateError

};

Session(

std::shared_ptr<Connection> connection,

PayloadParserFactoryCollection* payloadParserFactories,

PayloadSerializerCollection* payloadSerializers,

XMLParserFactory* xmlParserFactory);

virtual ~Session();

void startSession();

void finishSession();

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <set>

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

#include <boost/signals2.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/ErrorPayload.h>

#include <Swiften/Elements/VCard.h>

#include <Swiften/JID/JID.h>

#include <Swiften/VCards/SetVCardRequest.h>

namespace Swift {

class IQRouter;

class VCardStorage;

class SWIFTEN_API VCardManager : public boost::signals2::trackable {

public:

VCardManager(const JID& ownJID, IQRouter* iqRouter, VCardStorage* vcardStorage);

~VCardManager();

VCard::ref getVCard(const JID& jid) const;

VCard::ref getVCardAndRequestWhenNeeded(const JID& jid, const boost::posix_time::time_duration& allowedAge = boost::posix_time::time_duration(boost::date_time::pos_infin));

void requestVCard(const JID& jid);

void requestOwnVCard();

std::string getPhotoHash(const JID& jid) const;

SetVCardRequest::ref createSetVCardRequest(VCard::ref);

public:

/**

* The JID will always be bare.

*/

boost::signals2::signal<void (const JID&, VCard::ref)> onVCardChanged;

/**

* Emitted when we received an error on looking up a vCard.

*/

boost::signals2::signal<void (const JID&, ErrorPayload::ref)> onVCardRetrievalError;

/**

* Emitted when our own vcard changes.

/*

* Copyright (c) 2012 Mateusz Piękos

* Licensed under the simplified BSD license.

* See Documentation/Licenses/BSD-simplified.txt for more information.

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <boost/signals2.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Base/IDGenerator.h>

#include <Swiften/Elements/Whiteboard/WhiteboardElement.h>

#include <Swiften/Elements/Whiteboard/WhiteboardOperation.h>

#include <Swiften/JID/JID.h>

#include <Swiften/Queries/GenericRequest.h>

namespace Swift {

class IQRouter;

class WhiteboardPayload;

class SWIFTEN_API WhiteboardSession {

public:

typedef std::shared_ptr<WhiteboardSession> ref;

public:

WhiteboardSession(const JID& jid, IQRouter* router);

virtual ~WhiteboardSession();

void handleIncomingAction(std::shared_ptr<WhiteboardPayload> payload);

void sendElement(const WhiteboardElement::ref element);

virtual void sendOperation(WhiteboardOperation::ref operation) = 0;

void cancel();

const JID& getTo() const;

public:

boost::signals2::signal< void(const WhiteboardElement::ref element)> onElementReceived;

boost::signals2::signal< void(const WhiteboardOperation::ref operation)> onOperationReceived;

boost::signals2::signal< void(const JID& contact)> onSessionTerminated;

boost::signals2::signal< void(const JID& contact)> onRequestAccepted;

boost::signals2::signal< void(const JID& contact)> onRequestRejected;

private:

virtual void handleIncomingOperation(WhiteboardOperation::ref operation) = 0;

protected:

void sendPayload(std::shared_ptr<WhiteboardPayload> payload);

JID toJID_;

IQRouter* router_;