clientbase.h

/*
  Copyright (c) 2005-2006 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 "jid.h"
#include "logsink.h"

namespace gloox
{

  class string;
  class map;
  class list;
  class Connection;
  class Packet;
  class Tag;
  class Stanza;
  class Parser;
  class MessageSessionHandler;
  class ConnectionListener;
  class IqHandler;
  class MessageHandler;
  class PresenceHandler;
//   class RosterListener;
  class SubscriptionHandler;
//   class LogHandler;
  class TagHandler;

  class GLOOX_API ClientBase
  {

    friend class Parser;
    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 = 0;

      JID& jid() { return m_jid; };

      void setSasl( bool sasl ) { m_sasl = sasl; };

      void setTls( bool tls ) { m_tls = tls; };

      void setPort( int port ) { m_port = port; };

      void setServer( const std::string &server ) { m_server = server; };

      void setPassword( const std::string &password ) { m_password = password; };

      const std::string server() const { return m_server; };

      bool sasl() const { return m_sasl; };

      bool tls() const { return m_tls; };

      int port() const { return m_port; };

      virtual const std::string password() const { return m_password; };

      const std::string getID();

      virtual void send( Tag *tag );

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

      int fileDescriptor();

      void registerConnectionListener( ConnectionListener *cl );

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

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

      void registerMessageHandler( MessageHandler *mh );

      void registerMessageHandler( const std::string& jid,  MessageHandler *mh );

      void registerPresenceHandler( PresenceHandler *ph );

      void registerSubscriptionHandler( SubscriptionHandler *sh );

      void registerTagHandler( TagHandler *th, const std::string& tag,
                                                const std::string& xmlns );

      void removeConnectionListener( ConnectionListener *cl );

      void removeIqHandler( const std::string& xmlns );

      void removeMessageHandler( MessageHandler *mh );

      void removeMessageHandler( const std::string& jid );

      void removePresenceHandler( PresenceHandler *ph );

      void removeSubscriptionHandler( SubscriptionHandler *sh );

      void removeTagHandler( TagHandler *th, const std::string& tag,
                                              const std::string& xmlns );

      void setCACerts( const StringList& cacerts ) { m_cacerts = cacerts; };

      void setClientCert( const std::string& clientKey, const std::string& clientCerts );

      void setAutoMessageSession( bool autoMS, MessageSessionHandler *msh );

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

    protected:
      enum SaslMechanisms
      {
        SaslDigestMd5,          
        SaslPlain,               
        SaslAnonymous,           
        SaslExternal             
      };

      void notifyOnResourceBindError( ResourceBindError error );
      void notifyOnSessionCreateError( SessionCreateError error );
      bool notifyOnTLSConnect( const CertInfo& info );
      void notifyOnConnect();
      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( SaslMechanisms type );
      void processSASLChallenge( const std::string& challenge );
      void processSASLError( Stanza *stanza );
      void startTls();
      bool hasTls();

      JID m_jid;
      Connection *m_connection;

      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_authed;
      bool m_sasl;
      bool m_tls;
      int m_port;

    private:
      enum NodeType
      {
        NODE_STREAM_START,             
        NODE_STREAM_ERROR,             
        NODE_STREAM_CLOSE,             
        NODE_STREAM_CHILD              
      };

      virtual void handleStartNode() = 0;
      virtual bool handleNormalNode( Stanza *stanza ) = 0;
      virtual void rosterFilled() = 0;
      virtual void cleanup();
      void handleStreamError( Stanza *stanza );

      void notifyIqHandlers( Stanza *stanza );
      void notifyMessageHandlers( Stanza *stanza );
      void notifyPresenceHandlers( Stanza *stanza );
      void notifySubscriptionHandlers( Stanza *stanza );
      void notifyTagHandlers( Stanza *stanza );
      void notifyOnDisconnect( ConnectionError e );
      void filter( NodeType type, Stanza *stanza );
      void logEvent( const char *data, size_t size, int is_incoming );
      void send( const std::string& xml );

      struct TrackStruct
      {
        IqHandler *ih;
        int context;
      };

      struct TagHandlerStruct
      {
        TagHandler *th;
        std::string xmlns;
        std::string tag;
      };

      typedef std::list<ConnectionListener*>                ConnectionListenerList;
      typedef std::map<const std::string, IqHandler*>       IqHandlerMap;
      typedef std::map<const std::string, TrackStruct>      IqTrackMap;
      typedef std::map<const std::string, MessageHandler*>  MessageHandlerMap;
      typedef std::list<MessageHandler*>                    MessageHandlerList;
      typedef std::list<PresenceHandler*>                   PresenceHandlerList;
      typedef std::list<SubscriptionHandler*>               SubscriptionHandlerList;
      typedef std::list<TagHandlerStruct>                   TagHandlerList;

      ConnectionListenerList  m_connectionListeners;
      IqHandlerMap            m_iqNSHandlers;
      IqTrackMap              m_iqIDHandlers;
      MessageHandlerMap       m_messageJidHandlers;
      MessageHandlerList      m_messageHandlers;
      PresenceHandlerList     m_presenceHandlers;
      SubscriptionHandlerList m_subscriptionHandlers;
      TagHandlerList          m_tagHandlers;
      StringList              m_cacerts;
      MessageSessionHandler  *m_messageSessionHandler;

      Parser *m_parser;
      LogSink m_logInstance;

      AuthenticationError m_authError;
      StreamError m_streamError;
      StringMap m_streamErrorText;
      std::string m_streamErrorCData;
      Tag *m_streamErrorAppCondition;
      int m_idCount;
      bool m_autoMessageSession;
      bool m_fdRequested;

  };

}

#endif // CLIENTBASE_H__

---