clientbase.h
/*
Copyright (c) 2005-2023 by Jakob Schröter <js@camaya.net>
This file is part of the gloox library. http://camaya.net/gloox
This software is distributed under a license. The full license
agreement can be found in the file LICENSE in this distribution.
This software may not be copied, modified, sold or distributed
other than expressed in the named license agreement.
This software is distributed without any warranty.
*/
#ifndef CLIENTBASE_H__
#define CLIENTBASE_H__
#include "macros.h"
#include "gloox.h"
#include "eventdispatcher.h"
#include "iqhandler.h"
#include "jid.h"
#include "logsink.h"
#include "mutex.h"
#include "taghandler.h"
#include "statisticshandler.h"
#include "tlshandler.h"
#include "compressiondatahandler.h"
#include "connectiondatahandler.h"
#include "parser.h"
#include "atomicrefcount.h"
#include <string>
#include <list>
#include <map>
#if defined( _WIN32 ) && !defined( __SYMBIAN32__ )
#include <windows.h>
#define SECURITY_WIN32
#include <security.h>
#endif
namespace gloox
{
class Disco;
class EventHandler;
class Event;
class Tag;
class IQ;
class Message;
class Presence;
class Subscription;
class MessageSessionHandler;
class ConnectionListener;
class MessageHandler;
class MessageSession;
class PresenceHandler;
class SubscriptionHandler;
class MUCInvitationHandler;
class TagHandler;
class TLSBase;
class ConnectionBase;
class CompressionBase;
class StanzaExtensionFactory;
class GLOOX_API ClientBase : public TagHandler, public ConnectionDataHandler,
public CompressionDataHandler, public TLSHandler,
public IqHandler
{
friend class RosterManager;
public:
ClientBase( const std::string& ns, const std::string& server, int port = -1 );
ClientBase( const std::string& ns, const std::string& password,
const std::string& server, int port = -1 );
virtual ~ClientBase();
bool connect( bool block = true );
virtual ConnectionError recv( int timeout = -1 );
virtual const std::string& username() const { return m_jid.username(); }
const JID& jid() { return m_authzid ? m_authzid : m_jid; }
void setSasl( bool sasl ) { m_sasl = sasl; }
void setTls( TLSPolicy tls ) { m_tls = tls; }
void setCompression( bool compression ) { m_compress = compression; }
void setPort( int port ) { m_port = port; }
void setServer( const std::string &server );
void setPassword( const std::string &password ) { m_password = password; }
const std::string& server() const { return m_server; }
bool sasl() const { return m_sasl; }
TLSPolicy tls() const { return m_tls; }
bool compression() const { return m_compress; }
int port() const { return m_port; }
virtual const std::string& password() const { return m_password; }
virtual Disco* disco() const { return m_disco; }
const std::string getID();
void send( Tag* tag );
void send( IQ& iq, IqHandler* ih, int context, bool del = false );
void send( const IQ& iq );
void send( const Message& msg );
void send( const Subscription& sub );
void send( const Presence& pres );
bool authed() const { return m_authed; }
ConnectionState state() const;
const std::string& xmlLang() const { return m_xmllang; }
void setXmlLang( const std::string& xmllang ) { m_xmllang = xmllang; }
ConnectionBase* connectionImpl() const { return m_connection; }
void setConnectionImpl( ConnectionBase* cb );
TLSBase* encryptionImpl() const { return m_encryption; }
void setEncryptionImpl( TLSBase* tb );
CompressionBase* compressionImpl() const { return m_compression; }
void setCompressionImpl( CompressionBase* cb );
void whitespacePing();
void xmppPing( const JID& to, EventHandler* eh );
void setAuthzid( const JID& authzid ) { m_authzid = authzid; }
void setAuthcid( const std::string& authcid ) { m_authcid = authcid; }
void setSASLMechanisms( int mechanisms ) { m_availableSaslMechs = mechanisms; }
void registerStanzaExtension( StanzaExtension* ext );
bool removeStanzaExtension( int ext );
void registerConnectionListener( ConnectionListener* cl );
void registerIqHandler( IqHandler* ih, int exttype );
void removeIDHandler( IqHandler* ih );
void registerMessageHandler( MessageHandler* mh );
void removeMessageHandler( MessageHandler* mh );
void registerMessageSession( MessageSession* session );
void disposeMessageSession( MessageSession* session );
void registerPresenceHandler( PresenceHandler* ph );
void registerPresenceHandler( const JID& jid, PresenceHandler* ph );
void registerSubscriptionHandler( SubscriptionHandler* sh );
void registerTagHandler( TagHandler* th, const std::string& tag,
const std::string& xmlns );
void registerStatisticsHandler( StatisticsHandler* sh );
void removeConnectionListener( ConnectionListener* cl );
void removeIqHandler( IqHandler* ih, int exttype );
void removePresenceHandler( PresenceHandler* ph );
void removePresenceHandler( const JID& jid, PresenceHandler* ph );
void removeSubscriptionHandler( SubscriptionHandler* sh );
void removeTagHandler( TagHandler* th, const std::string& tag,
const std::string& xmlns );
void removeStatisticsHandler();
void setCACerts( const StringList& cacerts ) { m_cacerts = cacerts; }
void setClientCert( const std::string& clientKey, const std::string& clientCerts );
void registerMessageSessionHandler( MessageSessionHandler* msh, int types = 0 );
LogSink& logInstance() { return m_logInstance; }
StreamError streamError() const { return m_streamError; }
const std::string& streamErrorText( const std::string& lang = "default" ) const;
const std::string& streamErrorCData() const { return m_streamErrorCData; }
const Tag* streamErrorAppCondition() const { return m_streamErrorAppCondition; }
AuthenticationError authError() const { return m_authError; }
StatisticsStruct getStatistics();
void registerMUCInvitationHandler( MUCInvitationHandler* mih );
void removeMUCInvitationHandler();
void addPresenceExtension( StanzaExtension* se );
bool removePresenceExtension( int type );
const StanzaExtensionList& presenceExtensions() const { return m_presenceExtensions; }
const TagList sendQueue();
// reimplemented from ParserHandler
virtual void handleTag( Tag* tag );
// reimplemented from CompressionDataHandler
virtual void handleCompressedData( const std::string& data );
// reimplemented from CompressionDataHandler
virtual void handleDecompressedData( const std::string& data );
// reimplemented from ConnectionDataHandler
virtual void handleReceivedData( const ConnectionBase* connection, const std::string& data );
// reimplemented from ConnectionDataHandler
virtual void handleConnect( const ConnectionBase* connection );
// reimplemented from ConnectionDataHandler
virtual void handleDisconnect( const ConnectionBase* connection, ConnectionError reason );
// reimplemented from TLSHandler
virtual void handleEncryptedData( const TLSBase* base, const std::string& data );
// reimplemented from TLSHandler
virtual void handleDecryptedData( const TLSBase* base, const std::string& data );
// reimplemented from TLSHandler
virtual void handleHandshakeResult( const TLSBase* base, bool success, CertInfo &certinfo );
protected:
#ifdef CLIENTBASE_TEST
public:
#endif
void notifyOnResourceBindError( const Error* error );
void notifyOnResourceBind( const std::string& resource );
void notifyOnSessionCreateError( const Error* error );
bool notifyOnTLSConnect( const CertInfo& info );
void notifyOnConnect();
void notifyStreamEvent( StreamEvent event );
virtual void disconnect( ConnectionError reason );
void header();
void setAuthed( bool authed ) { m_authed = authed; }
void setAuthFailure( AuthenticationError e ) { m_authError = e; }
virtual bool checkStreamVersion( const std::string& version );
void startSASL( SaslMechanism type );
bool processSASLSuccess( const std::string& payload );
void processSASLChallenge( const std::string& challenge );
void processSASLError( Tag* tag );
void setNTLMDomain( const std::string& domain ) { m_ntlmDomain = domain; }
void startTls();
bool hasTls();
void send( const std::string& xml );
void checkQueue( int handled, bool resend );
int stanzasSent() const { return m_smSent; }
std::string getRandom();
JID m_jid;
JID m_authzid;
std::string m_authcid;
ConnectionBase* m_connection;
TLSBase* m_encryption;
CompressionBase* m_compression;
Disco* m_disco;
StanzaExtensionList m_presenceExtensions;
GLOOX_DEPRECATED std::string m_selectedResource;
std::string m_clientCerts;
std::string m_clientKey;
std::string m_namespace;
std::string m_password;
std::string m_xmllang;
std::string m_server;
std::string m_sid;
bool m_compressionActive;
bool m_encryptionActive;
bool m_compress;
bool m_authed;
bool m_resourceBound;
bool m_block;
bool m_sasl;
TLSPolicy m_tls;
int m_port;
int m_availableSaslMechs;
enum SMContext
{
CtxSMInvalid,
CtxSMFailed,
CtxSMEnable,
CtxSMResume,
CtxSMEnabled,
CtxSMResumed
};
SMContext m_smContext;
int m_smHandled;
private:
#ifdef CLIENTBASE_TEST
public:
#endif
class Ping : public StanzaExtension
{
public:
Ping();
virtual ~Ping();
// reimplemented from StanzaExtension
virtual const std::string& filterString() const;
// reimplemented from StanzaExtension
virtual StanzaExtension* newInstance( const Tag* tag ) const
{
(void)tag;
return new Ping();
}
// reimplemented from StanzaExtension
virtual Tag* tag() const
{
return new Tag( "ping", "xmlns", XMLNS_XMPP_PING );
}
// reimplemented from StanzaExtension
virtual StanzaExtension* clone() const
{
return new Ping();
}
};
ClientBase( const ClientBase& );
ClientBase& operator=( const ClientBase& );
virtual void handleStartNode( const Tag* start ) = 0;
virtual bool handleNormalNode( Tag* tag ) = 0;
virtual void rosterFilled() = 0;
virtual void cleanup() {}
virtual void handleIqIDForward( const IQ& iq, int context ) { (void) iq; (void) context; }
void send( Tag* tag, bool queue, bool del );
std::string hmac( const std::string& str, const std::string& key );
std::string hi( const std::string& str, const std::string& key, int iter );
void parse( const std::string& data );
void init();
void handleStreamError( Tag* tag );
TLSBase* getDefaultEncryption();
CompressionBase* getDefaultCompression();
void notifyIqHandlers( IQ& iq );
void notifyMessageHandlers( Message& msg );
void notifyPresenceHandlers( Presence& presence );
void notifySubscriptionHandlers( Subscription& s10n );
void notifyTagHandlers( Tag* tag );
void notifyOnDisconnect( ConnectionError e );
void addFrom( Tag* tag );
void addNamespace( Tag* tag );
// reimplemented from IqHandler
virtual bool handleIq( const IQ& iq );
// reimplemented from IqHandler
virtual void handleIqID( const IQ& iq, int context );
struct TrackStruct
{
IqHandler* ih;
int context;
bool del;
};
struct TagHandlerStruct
{
TagHandler* th;
std::string xmlns;
std::string tag;
};
struct JidPresHandlerStruct
{
JID* jid;
PresenceHandler* ph;
};
enum TrackContext
{
XMPPPing
};
typedef std::list<ConnectionListener*> ConnectionListenerList;
typedef std::multimap<const std::string, IqHandler*> IqHandlerMapXmlns;
typedef std::multimap<const int, IqHandler*> IqHandlerMap;
typedef std::map<const std::string, TrackStruct> IqTrackMap;
typedef std::map<const std::string, MessageHandler*> MessageHandlerMap;
typedef std::map<int, Tag*> SMQueueMap;
typedef std::list<MessageSession*> MessageSessionList;
typedef std::list<MessageHandler*> MessageHandlerList;
typedef std::list<PresenceHandler*> PresenceHandlerList;
typedef std::list<JidPresHandlerStruct> PresenceJidHandlerList;
typedef std::list<SubscriptionHandler*> SubscriptionHandlerList;
typedef std::list<TagHandlerStruct> TagHandlerList;
ConnectionListenerList m_connectionListeners;
IqHandlerMapXmlns m_iqNSHandlers;
IqHandlerMap m_iqExtHandlers;
IqTrackMap m_iqIDHandlers;
SMQueueMap m_smQueue;
MessageSessionList m_messageSessions;
MessageHandlerList m_messageHandlers;
PresenceHandlerList m_presenceHandlers;
PresenceJidHandlerList m_presenceJidHandlers;
SubscriptionHandlerList m_subscriptionHandlers;
TagHandlerList m_tagHandlers;
StringList m_cacerts;
StatisticsHandler * m_statisticsHandler;
MUCInvitationHandler * m_mucInvitationHandler;
MessageSessionHandler * m_messageSessionHandlerChat;
MessageSessionHandler * m_messageSessionHandlerGroupchat;
MessageSessionHandler * m_messageSessionHandlerHeadline;
MessageSessionHandler * m_messageSessionHandlerNormal;
util::Mutex m_iqHandlerMapMutex;
util::Mutex m_iqExtHandlerMapMutex;
util::Mutex m_queueMutex;
Parser m_parser;
LogSink m_logInstance;
StanzaExtensionFactory* m_seFactory;
EventDispatcher m_dispatcher;
AuthenticationError m_authError;
StreamError m_streamError;
StringMap m_streamErrorText;
std::string m_streamErrorCData;
Tag* m_streamErrorAppCondition;
StatisticsStruct m_stats;
SaslMechanism m_selectedSaslMech;
std::string m_clientFirstMessageBare;
std::string m_serverSignature;
std::string m_gs2Header;
std::string m_ntlmDomain;
bool m_customConnection;
std::string m_uniqueBaseId;
util::AtomicRefCount m_nextId;
int m_smSent;
#if defined( _WIN32 ) && !defined( __SYMBIAN32__ )
CredHandle m_credHandle;
CtxtHandle m_ctxtHandle;
#endif
};
}
#endif // CLIENTBASE_H__
gloox::ClientBase
This is the common base class for a Jabber/XMPP Client and a Jabber Component.
Definition clientbase.h:79
gloox::ClientBase::streamErrorCData
const std::string & streamErrorCData() const
Definition clientbase.h:626
gloox::ClientBase::m_smContext
SMContext m_smContext
Definition clientbase.h:920
gloox::ClientBase::compression
bool compression() const
Definition clientbase.h:214
gloox::ClientBase::setCompression
void setCompression(bool compression)
Definition clientbase.h:168
gloox::ClientBase::m_sid
std::string m_sid
Definition clientbase.h:890
gloox::ClientBase::port
int port() const
Definition clientbase.h:221
gloox::ClientBase::m_clientCerts
std::string m_clientCerts
Definition clientbase.h:883
gloox::ClientBase::m_resourceBound
bool m_resourceBound
Definition clientbase.h:898
gloox::ClientBase::m_authcid
std::string m_authcid
Definition clientbase.h:870
gloox::ClientBase::logInstance
LogSink & logInstance()
Definition clientbase.h:599
gloox::ClientBase::m_encryptionActive
bool m_encryptionActive
Definition clientbase.h:893
gloox::ClientBase::server
const std::string & server() const
Definition clientbase.h:196
gloox::ClientBase::m_availableSaslMechs
int m_availableSaslMechs
Definition clientbase.h:905
gloox::ClientBase::setAuthFailure
void setAuthFailure(AuthenticationError e)
Definition clientbase.h:784
gloox::ClientBase::setAuthed
void setAuthed(bool authed)
Definition clientbase.h:777
gloox::ClientBase::setCACerts
void setCACerts(const StringList &cacerts)
Definition clientbase.h:568
gloox::ClientBase::tls
TLSPolicy tls() const
Definition clientbase.h:208
gloox::ClientBase::m_jid
JID m_jid
Definition clientbase.h:868
gloox::ClientBase::setAuthcid
void setAuthcid(const std::string &authcid)
Definition clientbase.h:391
gloox::ClientBase::recv
virtual ConnectionError recv(int timeout=-1)
Definition clientbase.cpp:183
gloox::ClientBase::m_authed
bool m_authed
Definition clientbase.h:897
gloox::ClientBase::m_disco
Disco * m_disco
Definition clientbase.h:874
gloox::ClientBase::m_encryption
TLSBase * m_encryption
Definition clientbase.h:872
gloox::ClientBase::SMContext
SMContext
Definition clientbase.h:911
gloox::ClientBase::CtxSMResumed
@ CtxSMResumed
Definition clientbase.h:917
gloox::ClientBase::CtxSMInvalid
@ CtxSMInvalid
Definition clientbase.h:912
gloox::ClientBase::CtxSMEnable
@ CtxSMEnable
Definition clientbase.h:914
gloox::ClientBase::CtxSMResume
@ CtxSMResume
Definition clientbase.h:915
gloox::ClientBase::CtxSMEnabled
@ CtxSMEnabled
Definition clientbase.h:916
gloox::ClientBase::CtxSMFailed
@ CtxSMFailed
Definition clientbase.h:913
gloox::ClientBase::m_presenceExtensions
StanzaExtensionList m_presenceExtensions
Definition clientbase.h:877
gloox::ClientBase::streamErrorAppCondition
const Tag * streamErrorAppCondition() const
Definition clientbase.h:633
gloox::ClientBase::password
virtual const std::string & password() const
Definition clientbase.h:227
gloox::ClientBase::m_port
int m_port
Definition clientbase.h:902
gloox::ClientBase::setPassword
void setPassword(const std::string &password)
Definition clientbase.h:190
gloox::ClientBase::m_xmllang
std::string m_xmllang
Definition clientbase.h:887
gloox::ClientBase::presenceExtensions
const StanzaExtensionList & presenceExtensions() const
Definition clientbase.h:680
gloox::ClientBase::m_compressionActive
bool m_compressionActive
Definition clientbase.h:891
gloox::ClientBase::m_clientKey
std::string m_clientKey
Definition clientbase.h:884
gloox::ClientBase::m_authzid
JID m_authzid
Definition clientbase.h:869
gloox::ClientBase::m_sasl
bool m_sasl
Definition clientbase.h:900
gloox::ClientBase::ClientBase
ClientBase(const std::string &ns, const std::string &server, int port=-1)
Definition clientbase.cpp:94
gloox::ClientBase::m_compression
CompressionBase * m_compression
Definition clientbase.h:873
gloox::ClientBase::m_block
bool m_block
Definition clientbase.h:899
gloox::ClientBase::authError
AuthenticationError authError() const
Definition clientbase.h:640
gloox::ClientBase::m_password
std::string m_password
Definition clientbase.h:886
gloox::ClientBase::xmlLang
const std::string & xmlLang() const
Definition clientbase.h:302
gloox::ClientBase::encryptionImpl
TLSBase * encryptionImpl() const
Definition clientbase.h:333
gloox::ClientBase::connect
bool connect(bool block=true)
Definition clientbase.cpp:191
gloox::ClientBase::m_server
std::string m_server
Definition clientbase.h:888
gloox::ClientBase::m_selectedResource
GLOOX_DEPRECATED std::string m_selectedResource
Definition clientbase.h:879
gloox::ClientBase::connectionImpl
ConnectionBase * connectionImpl() const
Definition clientbase.h:317
gloox::ClientBase::setSasl
void setSasl(bool sasl)
Definition clientbase.h:154
gloox::ClientBase::jid
const JID & jid()
Definition clientbase.h:147
gloox::ClientBase::m_namespace
std::string m_namespace
Definition clientbase.h:885
gloox::ClientBase::m_tls
TLSPolicy m_tls
Definition clientbase.h:901
gloox::ClientBase::username
virtual const std::string & username() const
Definition clientbase.h:138
gloox::ClientBase::m_smHandled
int m_smHandled
Definition clientbase.h:921
gloox::ClientBase::setSASLMechanisms
void setSASLMechanisms(int mechanisms)
Definition clientbase.h:403
gloox::ClientBase::sasl
bool sasl() const
Definition clientbase.h:202
gloox::ClientBase::setNTLMDomain
void setNTLMDomain(const std::string &domain)
Definition clientbase.h:826
gloox::ClientBase::setAuthzid
void setAuthzid(const JID &authzid)
Definition clientbase.h:381
gloox::ClientBase::setXmlLang
void setXmlLang(const std::string &xmllang)
Definition clientbase.h:310
gloox::ClientBase::disco
virtual Disco * disco() const
Definition clientbase.h:233
gloox::ClientBase::m_connection
ConnectionBase * m_connection
Definition clientbase.h:871
gloox::ClientBase::stanzasSent
int stanzasSent() const
Definition clientbase.h:860
gloox::ClientBase::setTls
void setTls(TLSPolicy tls)
Definition clientbase.h:161
gloox::ClientBase::compressionImpl
CompressionBase * compressionImpl() const
Definition clientbase.h:349
gloox::ClientBase::authed
bool authed() const
Definition clientbase.h:290
gloox::ClientBase::streamError
StreamError streamError() const
Definition clientbase.h:607
gloox::ClientBase::setPort
void setPort(int port)
Definition clientbase.h:175
gloox::ClientBase::m_compress
bool m_compress
Definition clientbase.h:895
gloox::CompressionBase
This is an abstract base class for stream compression implementations.
Definition compressionbase.h:35
gloox::CompressionDataHandler
An abstract base class used to receive de/compressed data from a CompressionBase-derived object.
Definition compressiondatahandler.h:35
gloox::ConnectionBase
An abstract base class for a connection.
Definition connectionbase.h:35
gloox::ConnectionDataHandler
This is an abstract base class to receive events from a ConnectionBase-derived object.
Definition connectiondatahandler.h:36
gloox::ConnectionListener
Derived classes can be registered as ConnectionListeners with the Client.
Definition connectionlistener.h:34
gloox::Disco
This class implements XEP-0030 (Service Discovery) and XEP-0092 (Software Version).
Definition disco.h:46
gloox::Error
A stanza error abstraction implemented as a StanzaExtension.
Definition error.h:35
gloox::EventHandler
An base class for event handlers.
Definition eventhandler.h:29
gloox::Event
A base class for events.
Definition event.h:29
gloox::IQ
An abstraction of an IQ stanza.
Definition iq.h:34
gloox::IqHandler
A virtual interface which can be reimplemented to receive IQ stanzas.
Definition iqhandler.h:32
gloox::JID
An abstraction of a JID.
Definition jid.h:31
gloox::LogSink
An implementation of log sink and source.
Definition logsink.h:39
gloox::MUCInvitationHandler
A handler that can be used to receive invitations to MUC rooms.
Definition mucinvitationhandler.h:36
gloox::MessageHandler
A virtual interface which can be reimplemented to receive incoming message stanzas.
Definition messagehandler.h:37
gloox::MessageSessionHandler
A virtual interface which can be reimplemented to receive incoming message sessions.
Definition messagesessionhandler.h:35
gloox::MessageSession
An abstraction of a message session between any two entities.
Definition messagesession.h:146
gloox::Message
An abstraction of a message stanza.
Definition message.h:34
gloox::PresenceHandler
A virtual interface which can be reimplemented to receive presence stanzas.
Definition presencehandler.h:31
gloox::Presence
An abstraction of a presence stanza.
Definition presence.h:33
gloox::StanzaExtensionFactory
A Factory that creates StanzaExtensions from Tags.
Definition stanzaextensionfactory.h:42
gloox::StanzaExtension
This class abstracts a stanza extension, which is usually an XML child element in a specific namespac...
Definition stanzaextension.h:204
gloox::StatisticsHandler
A virtual interface which can be reimplemented to receive connection statistics.
Definition statisticshandler.h:64
gloox::SubscriptionHandler
A virtual interface which can be reimplemented to receive incoming subscription stanzas.
Definition subscriptionhandler.h:30
gloox::Subscription
An abstraction of a subscription stanza.
Definition subscription.h:32
gloox::TLSBase
An abstract base class for TLS implementations.
Definition tlsbase.h:32
gloox::TLSHandler
An interface that allows for interacting with TLS implementations derived from TLSBase.
Definition tlshandler.h:35
gloox::TagHandler
A virtual interface which can be reimplemented to receive non-XMPP Core stanzas.
Definition taghandler.h:33
gloox::Tag
This is an abstraction of an XML element.
Definition tag.h:47
gloox
The namespace for the gloox library.
Definition adhoc.cpp:28
gloox::TagList
std::list< Tag * > TagList
Definition tag.h:31
gloox::XMLNS_XMPP_PING
const std::string XMLNS_XMPP_PING
Definition gloox.cpp:62
gloox::ConnectionError
ConnectionError
Definition gloox.h:684
gloox::StanzaExtensionList
std::list< const StanzaExtension * > StanzaExtensionList
Definition gloox.h:1272
gloox::StringList
std::list< std::string > StringList
Definition gloox.h:1251
gloox::AuthenticationError
AuthenticationError
Definition gloox.h:1011
gloox::StreamEvent
StreamEvent
Definition gloox.h:653
gloox::TLSPolicy
TLSPolicy
Definition gloox.h:722
gloox::StreamError
StreamError
Definition gloox.h:775
gloox::SaslMechanism
SaslMechanism
Definition gloox.h:757
gloox::ConnectionState
ConnectionState
Definition gloox.h:641
gloox::StringMap
std::map< std::string, std::string > StringMap
Definition gloox.h:1261
gloox::CertInfo
Definition gloox.h:990
gloox::StatisticsStruct
Definition statisticshandler.h:26