#include <memory>

#include <string>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/Command.h>

#include <Swiften/Elements/ErrorPayload.h>

#include <Swiften/JID/JID.h>

/**

* Emitted when the form for the next stage is available.

*/

/**

* Emitted on error.

*/

/**

* Get the state of a given action.

bool isMultiStage_;

std::string sessionID_;

std::map<Command::Action, ActionState> actionStates_;

};

}

#pragma once

#include <boost/filesystem/path.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Base/ByteArray.h>

namespace Swift {

class JID;

virtual ByteArray getAvatar(const JID&) const = 0;

virtual boost::filesystem::path getAvatarPath(const JID&) const = 0;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#include <string>

#include <Swiften/Base/API.h>

namespace Swift {

class JID;

virtual boost::optional<std::string> getAvatarHash(const JID&) const = 0;

};

}

class VCardManager;

class CryptoProvider;

public:

VCardUpdateAvatarManager(VCardManager*, StanzaChannel*, AvatarStorage*, CryptoProvider* crypto, MUCRegistry* = nullptr);

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/ChatState.h>

#include <Swiften/Elements/Message.h>

#include <Swiften/JID/JID.h>

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/ChatState.h>

#include <Swiften/Elements/Message.h>

#include <Swiften/Elements/Presence.h>

ChatStateTracker();

void handleMessageReceived(std::shared_ptr<Message> message);

void handlePresenceChange(std::shared_ptr<Presence> newPresence);

private:

void changeState(ChatState::ChatStateType state);

ChatState::ChatStateType currentState_;

#include <vector>

#include <Swiften/Base/API.h>

#include <Swiften/JID/JID.h>

namespace Swift {

bool isBlocked(const JID& jid) const;

public:

};

}

/**

* This signal is emitted when a JID changes presence.

*/

private:

Storages* getStorages() const;

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Client/BlockList.h>

#include <Swiften/Client/BlockListImpl.h>

#include <Swiften/Elements/BlockListPayload.h>

#include <memory>

#include <string>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Error.h>

#include <Swiften/Elements/ToplevelElement.h>

#include <Swiften/JID/JID.h>

#include <Swiften/Session/SessionStream.h>

}

public:

private:

ClientSession(

private:

XMLBeautifier *beautifier;

bool bosh;

};

}

#include <memory>

#include <string>

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

* If the connection was due to a non-recoverable error, the type

* of error will be passed as a parameter.

*/

/**

* Emitted when the client is connected and authenticated,

* and stanzas can be sent.

*/

/**

* Emitted when the client receives data.

* This signal is emitted before the XML data is parsed,

* so this data is unformatted.

*/

/**

* Emitted when the client sends data.

* This signal is emitted after the XML was serialized, and

* is unformatted.

*/

/**

* Emitted when a message is received.

*/

/**

* Emitted when a presence stanza is received.

*/

/**

* Emitted when the server acknowledges receipt of a

*

* \see getStreamManagementEnabled()

*/

protected:

std::shared_ptr<ClientSession> getSession() const {

#include <string>

#include <Swiften/Base/API.h>

namespace Swift {

class SWIFTEN_API NickManager {

virtual std::string getOwnNick() const = 0;

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

};

}

#include <memory>

#include <string>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/VCard.h>

#include <Swiften/JID/JID.h>

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

private:

void handleVCardReceived(const JID& jid, VCard::ref vCard);

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/Message.h>

#include <Swiften/Elements/Presence.h>

#include <Swiften/Queries/IQChannel.h>

virtual bool getStreamManagementEnabled() const = 0;

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

};

}

#include <stack>

#include <string>

#include <Swiften/Base/API.h>

#include <Swiften/Parser/XMLParser.h>

#include <Swiften/Parser/XMLParserClient.h>

#include <Swiften/Parser/XMLParserFactory.h>

#include <memory>

#include <string>

#include <Swiften/Base/API.h>

#include <Swiften/Network/Connection.h>

#include <Swiften/Network/DomainNameResolveError.h>

#include <Swiften/Network/HostAddressPort.h>

class ConnectionFactory;

class TimerFactory;

public:

typedef std::shared_ptr<ComponentConnector> ref;

void start();

void stop();

private:

ComponentConnector(const std::string& hostname, int port, DomainNameResolver*, ConnectionFactory*, TimerFactory*);

#include <memory>

#include <string>

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

void sendStanza(std::shared_ptr<Stanza>);

public:

private:

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

#include <memory>

#include <string>

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

}

public:

private:

void handleConnectorFinished(std::shared_ptr<Connection>);

#include <map>

#include <set>

#include <Swiften/Base/API.h>

#include <Swiften/Disco/CapsProvider.h>

#include <Swiften/Elements/CapsInfo.h>

#include <Swiften/Elements/DiscoInfo.h>

class CapsStorage;

class CryptoProvider;

public:

CapsManager(CapsStorage*, StanzaChannel*, IQRouter*, CryptoProvider*);

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Elements/CapsInfo.h>

#include <Swiften/Elements/DiscoInfo.h>

virtual DiscoInfo::ref getCaps(const std::string&) const = 0;

};

}

#include <string>

#include <vector>

#include <Swiften/Base/API.h>

#include <Swiften/Disco/GetDiscoInfoRequest.h>

#include <Swiften/Disco/GetDiscoItemsRequest.h>

#include <Swiften/Elements/DiscoInfo.h>

}

/** Emitted for each service found. */

/** Emitted when walking is aborted. */

/** Emitted when walking is complete.*/

private:

void walkNode(const JID& jid);

#include <map>

#include <Swiften/Base/API.h>

#include <Swiften/Disco/EntityCapsProvider.h>

#include <Swiften/Elements/DiscoInfo.h>

#include <Swiften/Elements/ErrorPayload.h>

* This information is provided in the form of service discovery

* information.

*/

public:

EntityCapsManager(CapsProvider*, StanzaChannel*);

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Elements/DiscoInfo.h>

#include <Swiften/JID/JID.h>

/**

* Emitted when the capabilities of a JID changes.

*/

};

}

static Client* client = nullptr;

static JID recipient;

static int exitCode = CANNOT_CONNECT;

static void handleServerDiscoInfoResponse(std::shared_ptr<DiscoInfo> /*info*/, ErrorPayload::ref error) {

if (!error) {

static JID recipient;

static std::string messageBody;

static int exitCode = 2;

static void handleConnected() {

#include <boost/cstdint.hpp>

#include <boost/optional.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/FileTransfer/FileTransferError.h>

namespace Swift {

}

public:

protected:

void setState(const State& state);

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

#include <boost/filesystem/path.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/DiscoInfo.h>

#include <Swiften/FileTransfer/FileTransferOptions.h>

#include <Swiften/FileTransfer/IncomingFileTransfer.h>

static bool isSupportedBy(const DiscoInfo::ref info);

};

}

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

#include <boost/filesystem/path.hpp>

#include <boost/optional.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Base/IDGenerator.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/S5BProxyRequest.h>

#include <Swiften/FileTransfer/FileTransferManager.h>

#include <Swiften/FileTransfer/FileTransferOptions.h>

#include <vector>

#include <boost/optional/optional_fwd.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/JingleS5BTransportPayload.h>

namespace Swift {

virtual std::shared_ptr<TransportSession> createLocalCandidateSession(

std::shared_ptr<WriteBytestream>, const JingleS5BTransportPayload::Candidate& candidate) = 0;

};

}

#include <memory>

#include <boost/optional/optional_fwd.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/IBB.h>

#include <Swiften/FileTransfer/FileTransferError.h>

#include <Swiften/FileTransfer/WriteBytestream.h>

return to;

}

private:

bool handleSetRequest(const JID& from, const JID& to, const std::string& id, IBB::ref payload);

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/FileTransfer/IBBReceiveSession.h>

#include <Swiften/FileTransfer/TransportSession.h>

private:

std::shared_ptr<IBBReceiveSession> session;

};

}

#include <memory>

#include <boost/optional.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/ErrorPayload.h>

#include <Swiften/Elements/IBB.h>

#include <Swiften/FileTransfer/FileTransferError.h>

this->blockSize = blockSize;

}

private:

void handleIBBResponse(IBB::ref, ErrorPayload::ref);

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/FileTransfer/IBBSendSession.h>

#include <Swiften/FileTransfer/TransportSession.h>

private:

std::shared_ptr<IBBSendSession> session;

};

}

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/FileTransfer/FileTransfer.h>

#include <Swiften/FileTransfer/FileTransferOptions.h>

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/FileTransfer/IncomingFileTransfer.h>

#include <Swiften/Jingle/IncomingJingleSessionHandler.h>

CryptoProvider* crypto);

virtual ~IncomingFileTransferManager();

private:

bool handleIncomingJingleSession(

std::map<std::string, ByteArray> hashes;

FileTransferOptions options;

};

}

#include <memory>

#include <vector>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/ErrorPayload.h>

#include <Swiften/Elements/JingleS5BTransportPayload.h>

#include <Swiften/FileTransfer/FileTransfer.h>

std::shared_ptr<TransportSession> transportSession;

};

}

#include <Swiften/FileTransfer/LocalJingleTransportCandidateGenerator.h>

#include <Swiften/Base/IDGenerator.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/JingleS5BTransportPayload.h>

#include <Swiften/FileTransfer/FileTransferOptions.h>

#include <Swiften/FileTransfer/SOCKS5BytestreamProxyFinder.h>

virtual void start();

virtual void stop();

private:

void handleS5BServerInitialized(bool success);

Timer::ref waitForRemoteTermination;

};

}

#include <memory>

#include <vector>

#include <Swiften/Base/API.h>

namespace Swift {

class SWIFTEN_API ReadBytestream {

virtual bool isFinished() const = 0;

public:

};

}

#include <memory>

#include <boost/bind.hpp>

#include <Swiften/Base/Log.h>

#include <Swiften/Base/foreach.h>

#include <Swiften/Elements/JingleS5BTransportPayload.h>

#include <Swiften/FileTransfer/SOCKS5BytestreamRegistry.h>

virtual void startSelectingCandidate();

virtual void stopSelectingCandidate();

private:

void tryNextCandidate();

std::vector<JingleS5BTransportPayload::Candidate>,

JingleS5BTransportPayload::CompareCandidate> candidates;

std::shared_ptr<SOCKS5BytestreamClientSession> s5bSession;

JingleS5BTransportPayload::Candidate lastCandidate;

std::string socks5DstAddr;

FileTransferOptions options;

#pragma once

#include <boost/bind.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/FileTransfer/ReadBytestream.h>

#include <Swiften/FileTransfer/TransportSession.h>

#include <Swiften/FileTransfer/WriteBytestream.h>

std::shared_ptr<ReadBytestream> readStream;

std::shared_ptr<WriteBytestream> writeStream;

};

}

HostAddressPort getAddressPort() const;

private:

void process();

Timer::ref weFailedTimeout;

};

}

std::shared_ptr<SOCKS5BytestreamClientSession> createSOCKS5BytestreamClientSession(HostAddressPort addressPort, const std::string& destAddr);

public:

private:

void handleProxiesFound(std::vector<S5BProxyRequest::ref> proxyHosts);

void start();

void stop();

private:

void sendBytestreamQuery(const JID&);

#include <memory>

#include <vector>

#include <Swiften/Base/API.h>

#include <Swiften/Network/HostAddressPort.h>

#include <Swiften/Network/NATPortMapping.h>

void handleForwardPortResult(boost::optional<NATPortMapping> mapping);

void handleUnforwardPortResult(boost::optional<bool> result);

private:

friend class SOCKS5BytestreamServerInitializeRequest;

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/API.h>

namespace Swift {

bool isForwardingSetup() const;

private:

void handleServerManagerPortForwardingSetup(bool successful);

private:

SOCKS5BytestreamServerManager* s5bServerManager_;

};

}

#pragma once

#include <Swiften/Base/API.h>

namespace Swift {

bool isInitialized() const;

private:

void handleServerManagerInitialized(bool successfulInitialize);

private:

SOCKS5BytestreamServerManager* s5bServerManager_;

};

}

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/FileTransfer/FileTransferError.h>

#include <Swiften/FileTransfer/ReadBytestream.h>

#include <Swiften/FileTransfer/WriteBytestream.h>

HostAddressPort getAddressPort() const;

const std::string& getStreamID() const {

return streamID;

std::shared_ptr<WriteBytestream> writeBytestream;

bool waitingForData;

};

}

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/FileTransfer/FileTransferError.h>

namespace Swift {

virtual void start() = 0;

virtual void stop() = 0;

};

}

onDataSent(data);

}

EventLoop* eventLoop;

boost::optional<HostAddressPort> hostAddressPort;

#include <memory>

#include <vector>

#include <Swiften/Base/API.h>

namespace Swift {

class SWIFTEN_API WriteBytestream {

*/

virtual bool write(const std::vector<unsigned char>&) = 0;

};

}

#include <string>

#include <vector>

#include <boost/variant.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Base/SimpleIDGenerator.h>

#include <Swiften/Elements/JinglePayload.h>

#include <Swiften/JID/JID.h>

#include <Swiften/Jingle/JingleContentID.h>

#include <vector>

#include <boost/optional.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Listenable.h>

#include <Swiften/Elements/JinglePayload.h>

#include <Swiften/JID/JID.h>

private:

IQRouter *iqRouter;

JID peerJID;

RequestsMap pendingRequests;

};

}

#include <map>

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Jingle/JingleSessionImpl.h>

namespace Swift {

#pragma once

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

namespace Swift {

virtual void startBrowsing() = 0;

virtual void stopBrowsing() = 0;

};

}

#pragma once

#include <boost/optional.hpp>

#include <Swiften/Base/ByteArray.h>

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

namespace Swift {

virtual void unregisterService() = 0;

virtual void updateServiceInfo(const ByteArray& info) = 0;

};

}

#pragma once

#include <boost/optional.hpp>

#include <Swiften/Network/HostAddress.h>

namespace Swift {

virtual void run() = 0;

virtual void finish() = 0;

};

}

#pragma once

#include <boost/optional.hpp>

#include <Swiften/Base/ByteArray.h>

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

namespace Swift {

virtual void start() = 0;

virtual void stop() = 0;

};

}

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/JID/JID.h>

#include <Swiften/Network/Connection.h>

#include <Swiften/Session/Session.h>

PayloadSerializerCollection* payloadSerializers,

XMLParserFactory* xmlParserFactory);

private:

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

#include <memory>

#include <vector>

#include <Swiften/Base/API.h>

#include <Swiften/LinkLocal/LinkLocalService.h>

#include <Swiften/Network/Connection.h>

return connection;

}

private:

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

LinkLocalService service;

std::shared_ptr<DNSSDQuerier> querier;

std::shared_ptr<DNSSDResolveHostnameQuery> resolveQuery;

std::shared_ptr<Connection> connection;

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

};

}

#include <vector>

#include <boost/optional.hpp>

#include <Swiften/Base/API.h>

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

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

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

return querier;

}

private:

void handleServiceAdded(const DNSSDServiceID&);

#include <memory>

#include <vector>

#include <Swiften/Base/API.h>

#include <Swiften/JID/JID.h>

#include <Swiften/Session/Session.h>

#include <memory>

#include <string>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/Form.h>

#include <Swiften/Elements/MUCAdminPayload.h>

#include <Swiften/Elements/MUCOccupant.h>

virtual void setPassword(const boost::optional<std::string>& password) = 0;

public:

};

}

#include <vector>

#include <boost/optional.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/ErrorPayload.h>

#include <Swiften/Elements/Storage.h>

#include <Swiften/MUC/MUCBookmark.h>

const std::vector<MUCBookmark>& getBookmarks() const;

public:

/**

* When server bookmarks are ready to be used (request response has been received).

*/

private:

bool containsEquivalent(const std::vector<MUCBookmark>& list, const MUCBookmark& bookmark);

#include <memory>

#include <string>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/Form.h>

#include <Swiften/Elements/MUCAdminPayload.h>

#include <Swiften/Elements/MUCOccupant.h>

std::map<std::string, MUCOccupant> occupants;

bool joinSucceeded_;

bool joinComplete_;

boost::posix_time::ptime joinSince_;

bool createAsReservedIfNew;

bool unlocking;

#include <memory>

#include <string>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/Form.h>

#include <Swiften/Elements/MUCAdminPayload.h>

#include <Swiften/Elements/MUCOccupant.h>

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

CertificateVerificationError::ref getPeerCertificateVerificationError() const;

private:

friend class ::BOSHConnectionTest;

class CachingDomainNameResolver;

class EventLoop;

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

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

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

private:

void handleDataRead(const SafeByteArray& data);

#include <boost/asio/io_service.hpp>

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

#include <boost/optional/optional_fwd.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/EventLoop/EventOwner.h>

#include <Swiften/Network/BoostConnection.h>

#include <Swiften/Network/ConnectionServer.h>

virtual HostAddressPort getAddressPort() const;

private:

BoostConnectionServer(int port, std::shared_ptr<boost::asio::io_service> ioService, EventLoop* eventLoop);

#include <vector>

#include <boost/optional.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Error.h>

namespace Swift {

class Connection;

void start();

void stop();

private:

void finish(std::shared_ptr<Connection> connection, std::shared_ptr<Error>);

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Base/SafeByteArray.h>

namespace Swift {

class HostAddressPort;

virtual HostAddressPort getRemoteAddress() const = 0;

public:

};

}

#include <memory>

#include <boost/optional/optional_fwd.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Network/Connection.h>

#include <Swiften/Network/HostAddressPort.h>

virtual void stop() = 0;

};

}

#include <string>

#include <boost/optional.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Network/Connection.h>

#include <Swiften/Network/DomainNameResolveError.h>

#include <Swiften/Network/DomainNameServiceQuery.h>

class ConnectionFactory;

class TimerFactory;

public:

typedef std::shared_ptr<Connector> ref;

void start();

void stop();

private:

Connector(const std::string& hostname, int port, const boost::optional<std::string>& serviceLookupPrefix, DomainNameResolver*, ConnectionFactory*, TimerFactory*);

#include <memory>

#include <boost/optional.hpp>

#include <Swiften/Network/DomainNameResolveError.h>

#include <Swiften/Network/HostAddress.h>

virtual void run() = 0;

};

}

#include <vector>

#include <boost/optional.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Network/DomainNameResolveError.h>

namespace Swift {

virtual void run() = 0;

static void sortResults(std::vector<DomainNameServiceQuery::Result>& queries, RandomGenerator& generator);

};

}

return remoteAddress;

}

EventLoop* eventLoop;

HostAddressPort localAddress;

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Network/NATPortMapping.h>

namespace Swift {

virtual void start() = 0;

virtual void stop() = 0;

};

}

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Network/HostAddress.h>

namespace Swift {

virtual void start() = 0;

virtual void stop() = 0;

};

}

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Network/HostAddress.h>

namespace Swift {

virtual void start() = 0;

virtual void stop() = 0;

};

}

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

*/

#pragma once

#include <vector>

#include <Swiften/Base/API.h>

#include <Swiften/Network/NetworkInterface.h>

namespace Swift {

#include <vector>

#include <boost/optional.hpp>

#include <net/if.h>

#include <sys/socket.h>

#include <sys/types.h>

#include <unistd.h>

#include <Swiften/Network/HostAddress.h>

#include <Swiften/Network/NetworkInterface.h>

#include <vector>

#include <Swiften/Network/NetworkEnvironment.h>

#include <Swiften/Network/NetworkInterface.h>

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Base/SafeByteArray.h>

#include <Swiften/Network/Connection.h>

#include <Swiften/TLS/TLSOptions.h>

#pragma once

#include <Swiften/Base/API.h>

namespace Swift {

/**

/**

* Emitted when the timer expires.

*/

};

}

#include <Swiften/Network/UnixNetworkEnvironment.h>

#include <string>

#include <vector>

#include <boost/optional.hpp>

#include <arpa/inet.h>

#include <net/if.h>

#ifndef __ANDROID__

#include <ifaddrs.h>

#endif

#include <Swiften/Network/HostAddress.h>

#include <Swiften/Network/NetworkInterface.h>

#include <vector>

#include <Swiften/Network/NetworkEnvironment.h>

#include <Swiften/Network/NetworkInterface.h>

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

*/

#pragma once

#include <vector>

#include <Swiften/Base/API.h>

#include <Swiften/Network/NetworkEnvironment.h>

namespace Swift {

#include <string>

#include <vector>

#include <Swiften/Base/API.h>

#include <Swiften/Parser/AttributeMap.h>

namespace Swift {

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#include <map>

#include <string>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/Presence.h>

namespace Swift {

Presence::ref getAccountPresence(const JID& jid) const;

public:

private:

void handleIncomingPresence(Presence::ref presence);

#include <map>

#include <string>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/Presence.h>

#include <Swiften/JID/JID.h>

* received. This is useful when the subscriber adds extensions to

* the request.

*/

private:

void handleIncomingPresence(Presence::ref presence);

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/IQ.h>

#include <Swiften/Elements/PubSub.h>

#include <Swiften/Elements/PubSubAffiliations.h>

SWIFTEN_PUBSUB_FOREACH_PUBSUB_PAYLOAD_TYPE(

SWIFTEN_PUBSUBMANAGER_DECLARE_CREATE_REQUEST)

};

}

#include <boost/bind.hpp>

#include <boost/filesystem.hpp>

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include <Swiften/Base/ByteArray.h>

#include <Swiften/FileTransfer/FileWriteBytestream.h>

using namespace Swift;

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Queries/Request.h>

namespace Swift {

/**

* Signal emitted when a reply to the iq has been received. Contains a payload if one was present, and an error if one was present.

*/

};

}

#include <memory>

#include <string>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/IQ.h>

namespace Swift {

virtual bool isAvailable() const = 0;

};

}

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/ContainerPayload.h>

#include <Swiften/Elements/PubSub.h>

#include <Swiften/Elements/PubSubAffiliations.h>

}

public:

};

}

#include <memory>

#include <typeinfo>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/ErrorPayload.h>

#include <Swiften/Elements/RawXMLPayload.h>

#include <Swiften/Queries/Request.h>

return ref(new RawRequest(type, recipient, data, router));

}

private:

RawRequest(IQ::Type type, const JID& receiver, const std::string& data, IQRouter* router) : Request(type, receiver, std::make_shared<RawXMLPayload>(data), router) {

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/ErrorPayload.h>

#include <Swiften/Elements/PrivateStorage.h>

#include <Swiften/Queries/Request.h>

}

public:

};

}

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/ErrorPayload.h>

#include <Swiften/Elements/PrivateStorage.h>

#include <Swiften/Queries/Request.h>

}

public:

};

}

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/InBandRegistrationPayload.h>

#include <Swiften/Queries/Request.h>

}

public:

};

}

}

public:

};

public:

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Elements/RosterPayload.h>

#include <Swiften/Queries/SetResponder.h>

RosterPushResponder(IQRouter* router) : SetResponder<RosterPayload>(router) {}

public:

private:

virtual bool handleSetRequest(const JID& from, const JID&, const std::string& id, std::shared_ptr<RosterPayload> payload) {

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/RosterPayload.h>

#include <Swiften/Queries/Request.h>

}

public:

};

}

#include <vector>

#include <boost/optional.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/RosterItemPayload.h>

#include <Swiften/JID/JID.h>

#include <Swiften/Roster/XMPPRosterItem.h>

/**

* Emitted when the given JID is added to the roster.

*/

/**

* Emitted when the given JID is removed from the roster.

*/

/**

* Emitted when the name or the groups of the roster item with the

* given JID changes.

*/

/**

* Emitted when the roster is reset (e.g. due to logging in/logging out).

* After this signal is emitted, the roster is empty. It will be repopulated through

* onJIDAdded and onJIDRemoved events.

*/

/**

* Emitted after the last contact of the initial roster request response

* was added.

*/

};

}

#include <memory>

#include <string>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/IQ.h>

#include <Swiften/Elements/RosterPayload.h>

#include <Swiften/JID/JID.h>

#include <Sspi.h>

#include <Swiften/Base/API.h>

#include <Swiften/Base/SafeByteArray.h>

namespace Swift {

#include <memory>

#include <boost/optional.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>

return remoteJID;

}

protected:

void setRemoteJID(const JID& j) {

#include <memory>

#include <boost/optional.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Error.h>

#include <Swiften/Base/SafeByteArray.h>

#include <Swiften/Elements/ProtocolHeader.h>

#include <Swiften/Elements/ToplevelElement.h>

#include <Swiften/TLS/Certificate.h>

virtual ByteArray getTLSFinishMessage() const = 0;

protected:

CertificateWithKey::ref getTLSCertificate() const {

#include <deque>

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/Stanza.h>

namespace Swift {

void handleAckReceived(unsigned int handledStanzasCount);

public:

private:

friend class StanzaAckRequesterTest;

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/Stanza.h>

namespace Swift {

void handleAckRequestReceived();

public:

private:

friend class StanzaAckResponderTest;

#pragma once

#include <boost/noncopyable.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Base/SafeByteArray.h>

#include <Swiften/Compress/ZLibCompressor.h>

#include <Swiften/Compress/ZLibDecompressor.h>

#include <Swiften/Compress/ZLibException.h>

}

public:

private:

ZLibCompressor compressor_;

#include <memory>

#include <vector>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/Stanza.h>

namespace Swift {

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Base/SafeByteArray.h>

#include <Swiften/StreamStack/StreamLayer.h>

#include <Swiften/TLS/Certificate.h>

#include <Swiften/TLS/CertificateVerificationError.h>

}

public:

private:

TLSContext* context;

* See the COPYING file for more information.

*/

#include <vector>

#include <boost/bind.hpp>

#include <QA/Checker/IO.h>

#include <memory>

#include <boost/noncopyable.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Base/SafeByteArray.h>

#include <Swiften/Elements/StreamType.h>

#include <Swiften/Elements/ToplevelElement.h>

#include <Swiften/Parser/XMPPParserClient.h>

void writeDataInternal(const SafeByteArray& data);

public:

private:

void handleStreamStart(const ProtocolHeader&);

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Base/SafeByteArray.h>

#include <Swiften/TLS/CertificateWithKey.h>

#include <Swiften/Network/Timer.h>

const std::string& getSmartCardReaderName() const;

public:

private:

void setUri (const std::string& capiUri);

#pragma once

#include <boost/noncopyable.hpp>

#include <openssl/ssl.h>

#include <Swiften/Base/ByteArray.h>

#include <Swiften/TLS/CertificateWithKey.h>

#include <Swiften/TLS/TLSContext.h>

#pragma once

#include <Swiften/TLS/TLSContext.h>

#include <Swiften/TLS/Schannel/SchannelUtil.h>

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Base/SafeByteArray.h>

#include <Swiften/TLS/Certificate.h>

#include <Swiften/TLS/CertificateVerificationError.h>

#include <Swiften/TLS/CertificateWithKey.h>

virtual ByteArray getFinishMessage() const = 0;

public:

};

}

#include <set>

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

#include <Swiften/Base/API.h>

#include <Swiften/Elements/ErrorPayload.h>

#include <Swiften/Elements/VCard.h>

#include <Swiften/JID/JID.h>

class JID;

class VCardStorage;

public:

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

~VCardManager();

/**

* The JID will always be bare.

*/

/**

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

*/

/**

* Emitted when our own vcard changes.

*

* onVCardChanged will also be emitted.

*/

private:

void handleVCardReceived(const JID& from, VCard::ref, ErrorPayload::ref);

#include <memory>

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

const JID& getTo() const;

public:

private:

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

#include <map>

#include <Swiften/Base/API.h>

#include <Swiften/Client/StanzaChannel.h>

#include <Swiften/JID/JID.h>

#include <Swiften/Queries/IQRouter.h>

WhiteboardSession::ref requestSession(const JID& to);

public:

private:

JID getFullJID(const JID& bareJID);