clientbase.h

/*
  Copyright (c) 2005-2008 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 "taghandler.h"
#include "statisticshandler.h"
#include "tlshandler.h"
#include "compressiondatahandler.h"
#include "connectiondatahandler.h"
#include "parser.h"

#include <string>
#include <list>
#include <map>

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

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

      GLOOX_DEPRECATED void registerIqHandler( IqHandler* ih, const std::string& xmlns );

      void registerIqHandler( IqHandler* ih, int exttype );

      GLOOX_DEPRECATED void trackID( IqHandler* ih, const std::string& id, int context );

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

      GLOOX_DEPRECATED void removeIqHandler( IqHandler* ih, const std::string& xmlns );

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

      // 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:
      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 processSASLChallenge( const std::string& challenge );
      void processSASLError( Tag* tag );
      void startTls();
      bool hasTls();

      JID m_jid;
      JID m_authzid;
      std::string m_authcid;
      ConnectionBase* m_connection;
      TLSBase* m_encryption;
      CompressionBase* m_compression;
      Disco* m_disco;

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

      };

      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 );
      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 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;
      StringList               m_cacerts;
      StatisticsHandler      * m_statisticsHandler;
      MUCInvitationHandler   * m_mucInvitationHandler;
      MessageSessionHandler  * m_messageSessionHandlerChat;
      MessageSessionHandler  * m_messageSessionHandlerGroupchat;
      MessageSessionHandler  * m_messageSessionHandlerHeadline;
      MessageSessionHandler  * m_messageSessionHandlerNormal;

      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;

      int m_idCount;
      bool m_autoMessageSession;

  };

}

#endif // CLIENTBASE_H__

---