clientbase.h

/*
  Copyright (c) 2005-2009 by Jakob Schroeter <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 "connectiondatahandler.h"
#include "parser.h"
#include "tlshandler.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 ConnectionBase;
  class ConnectionTLS;
  class ConnectionCompression;
  class StanzaExtensionFactory;

  class GLOOX_API ClientBase : public TagHandler, public ConnectionDataHandler,
                               public IqHandler, public TLSHandler
  {

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

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

      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; }

      // reimplemented from ParserHandler
      virtual void handleTag( Tag* tag );

      // 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:
      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 );

      void processSASLSuccess();

      void processSASLChallenge( const std::string& challenge );

      void processSASLError( Tag* tag );

      void setNTLMDomain( const std::string& domain ) { m_ntlmDomain = domain; }

      void startTls();

      bool hasTls();
      bool hasCompression();

      JID m_jid;                         
      JID m_authzid;                     
      std::string m_authcid;             
      ConnectionBase* m_connection;      
      ConnectionTLS* m_encryption;       
      ConnectionCompression* m_compression; 
      Disco* m_disco;                    
      StanzaExtensionList m_presenceExtensions;
      LogSink m_logInstance;
      StringList m_cacerts;

      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_block;                      
      bool m_sasl;                       
      TLSPolicy m_tls;                   
      int m_port;                        
      int m_availableSaslMechs;          
    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() = 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 parse( const std::string& data );
      void init();
      void handleStreamError( Tag* tag );

      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 send( const std::string& xml );
      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::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;
      MessageSessionList       m_messageSessions;
      MessageHandlerList       m_messageHandlers;
      PresenceHandlerList      m_presenceHandlers;
      PresenceJidHandlerList   m_presenceJidHandlers;
      SubscriptionHandlerList  m_subscriptionHandlers;
      TagHandlerList           m_tagHandlers;
      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; // TODO Enable this mutex again. However
                                          // it must be possible to register new IQ handlers
                                          // while an IQ is being handled!

      Parser m_parser;
      StanzaExtensionFactory* m_seFactory;
      EventDispatcher m_dispatcher;

      AuthenticationError m_authError;
      StreamError m_streamError;
      StringMap m_streamErrorText;
      std::string m_streamErrorCData;
      Tag* m_streamErrorAppCondition;

      ConnectionBase* m_transportConnection;

      StatisticsStruct m_stats;

      SaslMechanism m_selectedSaslMech;

      std::string m_ntlmDomain;
      bool m_autoMessageSession;

#if defined( _WIN32 ) && !defined( __SYMBIAN32__ )
      CredHandle m_credHandle;
      CtxtHandle m_ctxtHandle;
#endif

  };

}

#endif // CLIENTBASE_H__

---