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__