/*
* Copyright (c) 2010-2016 Isode Limited.
* 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 Message;
class Presence;
class Error;
class IQRouter;
class TLSContextFactory;
class ConnectionFactory;
class Connection;
class TimerFactory;
class ClientSession;
class StanzaChannel;
class Stanza;
class SessionStream;
class CertificateTrustChecker;
class NetworkFactories;
class ClientSessionStanzaChannel;
/**
* 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
* initialize the stream and authenticate.
*/
void connect(const ClientOptions& = ClientOptions());
/**
* Disconnects the client from the server.
*/
void disconnect();
/**
* Sends a message.
*/
void sendMessage(std::shared_ptr<Message>);
/**
* Sends a presence stanza.
*/
void sendPresence(std::shared_ptr<Presence>);
/**
* Sends raw, unchecked data.
*/
void sendData(const std::string& data);
/**
* Returns the IQ router for this client.
*/
IQRouter* getIQRouter() const {
return iqRouter_;
}
/**
* Checks whether the client is connected to the server,
* and stanzas can be sent.
*/
bool isAvailable() const;
/**
* Checks whether the client is active.
*
* A client is active when it is connected or connecting to the server.
*/
bool isActive() const;
/**
* Returns the JID of the client.
* After the session was initialized, this returns the bound JID.
*/
const JID& getJID() const;
/**
* Checks whether stream management is enabled.
*
* If stream management is enabled, onStanzaAcked will be
* emitted when a stanza is received by the server.
*
* \see onStanzaAcked
*/
bool getStreamManagementEnabled() const;
/**
* Checks whether stream encryption (TLS) is currently active.
*/
bool isStreamEncrypted() const;
StanzaChannel* getStanzaChannel() const;
/**
* Sets the certificate trust checker.
*
* This checker will be called when the server sends a
* TLS certificate that does not validate. If the trust checker
* says the certificate is trusted, then connecting will proceed;
* if not, the connection will end with an error.
*/
void setCertificateTrustChecker(CertificateTrustChecker*);
public:
/**
* Emitted when the client was disconnected from the network.
*
* If the connection was due to a non-recoverable error, the type
* of error will be passed as a parameter.
*/
boost::signals2::signal<void (const boost::optional<ClientError>&)> onDisconnected;
/**
* Emitted when the client is connected and authenticated,
* and stanzas can be sent.
*/
boost::signals2::signal<void ()> onConnected;
/**
* Emitted when the client receives data.
*
* This signal is emitted before the XML data is parsed,
* so this data is unformatted.
*/
boost::signals2::signal<void (const SafeByteArray&)> onDataRead;
/**
* Emitted when the client sends data.
*
* This signal is emitted after the XML was serialized, and
* is unformatted.
*/
boost::signals2::signal<void (const SafeByteArray&)> onDataWritten;
/**
* Emitted when a message is received.
*/
boost::signals2::signal<void (std::shared_ptr<Message>)> onMessageReceived;
/**
* Emitted when a presence stanza is received.
*/
boost::signals2::signal<void (std::shared_ptr<Presence>) > onPresenceReceived;
/**
* Emitted when the server acknowledges receipt of a
* stanza (if acknowledgements are available).
*
* \see getStreamManagementEnabled()
*/
boost::signals2::signal<void (std::shared_ptr<Stanza>)> onStanzaAcked;
protected:
std::shared_ptr<ClientSession> getSession() const {
return session_;
}
NetworkFactories* getNetworkFactories() const {
return networkFactories;
}
/**
* Called before onConnected signal is emmitted.
*/
virtual void handleConnected() {}
private:
void handleConnectorFinished(std::shared_ptr<Connection>, std::shared_ptr<Error> error);
void handleStanzaChannelAvailableChanged(bool available);
void handleSessionFinished(std::shared_ptr<Error>);
void handleNeedCredentials();
void handleDataRead(const SafeByteArray&);
void handleDataWritten(const SafeByteArray&);
void handlePresenceReceived(std::shared_ptr<Presence>);
void handleMessageReceived(std::shared_ptr<Message>);
void handleStanzaAcked(std::shared_ptr<Stanza>);
void purgePassword();
void bindSessionToStream();
void resetConnector();
void resetSession();
void forceReset();
private:
JID jid_;
SafeByteArray password_;
NetworkFactories* networkFactories;
ClientSessionStanzaChannel* stanzaChannel_;
IQRouter* iqRouter_;
ClientOptions options;
std::shared_ptr<ChainedConnector> connector_;
std::vector<ConnectionFactory*> proxyConnectionFactories;
std::shared_ptr<Connection> connection_;
std::shared_ptr<SessionStream> sessionStream_;
std::shared_ptr<ClientSession> session_;
CertificateWithKey::ref certificate_;
bool disconnectRequested_;
CertificateTrustChecker* certificateTrustChecker;
};
}