clientbase.h

00001 /*
00002   Copyright (c) 2005-2006 by Jakob Schroeter <js@camaya.net>
00003   This file is part of the gloox library. http://camaya.net/gloox
00004 
00005   This software is distributed under a license. The full license
00006   agreement can be found in the file LICENSE in this distribution.
00007   This software may not be copied, modified, sold or distributed
00008   other than expressed in the named license agreement.
00009 
00010   This software is distributed without any warranty.
00011 */
00012 
00013 
00014 
00015 #ifndef CLIENTBASE_H__
00016 #define CLIENTBASE_H__
00017 
00018 #include "macros.h"
00019 #include "gloox.h"
00020 #include "jid.h"
00021 #include "logsink.h"
00022 
00023 namespace gloox
00024 {
00025 
00026   class string;
00027   class map;
00028   class list;
00029   class Connection;
00030   class Packet;
00031   class Tag;
00032   class Stanza;
00033   class Parser;
00034   class MessageSessionHandler;
00035   class ConnectionListener;
00036   class IqHandler;
00037   class MessageHandler;
00038   class PresenceHandler;
00039 //   class RosterListener;
00040   class SubscriptionHandler;
00041 //   class LogHandler;
00042   class TagHandler;
00043 
00051   class GLOOX_API ClientBase
00052   {
00053 
00054     friend class Parser;
00055     friend class RosterManager;
00056 
00057     public:
00066       ClientBase( const std::string& ns, const std::string& server, int port = -1 );
00067 
00077       ClientBase( const std::string& ns, const std::string& password,
00078                   const std::string& server, int port = -1 );
00079 
00083       virtual ~ClientBase();
00084 
00095       bool connect( bool block = true );
00096 
00104       ConnectionError recv( int timeout = -1 );
00105 
00110       virtual const std::string username() const = 0;
00111 
00118       JID& jid() { return m_jid; };
00119 
00124       void setSasl( bool sasl ) { m_sasl = sasl; };
00125 
00130       void setTls( bool tls ) { m_tls = tls; };
00131 
00137       void setPort( int port ) { m_port = port; };
00138 
00145       void setServer( const std::string &server ) { m_server = server; };
00146 
00151       void setPassword( const std::string &password ) { m_password = password; };
00152 
00157       const std::string server() const { return m_server; };
00158 
00163       bool sasl() const { return m_sasl; };
00164 
00169       bool tls() const { return m_tls; };
00170 
00176       int port() const { return m_port; };
00177 
00182       virtual const std::string password() const { return m_password; };
00183 
00189       const std::string getID();
00190 
00197       virtual void send( Tag *tag );
00198 
00203       bool authed() const { return m_authed; };
00204 
00209       ConnectionState state() const;
00210 
00215       const std::string& xmlLang() const { return m_xmllang; };
00216 
00223       void setXmlLang( const std::string& xmllang ) { m_xmllang = xmllang; };
00224 
00231       int fileDescriptor();
00232 
00236       void ping();
00237 
00242       void registerConnectionListener( ConnectionListener *cl );
00243 
00250       void registerIqHandler( IqHandler *ih, const std::string& xmlns );
00251 
00260       void trackID( IqHandler *ih, const std::string& id, int context );
00261 
00266       void registerMessageHandler( MessageHandler *mh );
00267 
00275       void registerMessageHandler( const std::string& jid,  MessageHandler *mh );
00276 
00281       void registerPresenceHandler( PresenceHandler *ph );
00282 
00287       void registerSubscriptionHandler( SubscriptionHandler *sh );
00288 
00296       void registerTagHandler( TagHandler *th, const std::string& tag,
00297                                                 const std::string& xmlns );
00298 
00303       void removeConnectionListener( ConnectionListener *cl );
00304 
00309       void removeIqHandler( const std::string& xmlns );
00310 
00315       void removeMessageHandler( MessageHandler *mh );
00316 
00321       void removeMessageHandler( const std::string& jid );
00322 
00327       void removePresenceHandler( PresenceHandler *ph );
00328 
00333       void removeSubscriptionHandler( SubscriptionHandler *sh );
00334 
00341       void removeTagHandler( TagHandler *th, const std::string& tag,
00342                                              const std::string& xmlns );
00343 
00349       void setCACerts( const StringList& cacerts ) { m_cacerts = cacerts; };
00350 
00362       void setClientCert( const std::string& clientKey, const std::string& clientCerts );
00363 
00374       void setAutoMessageSession( bool autoMS, MessageSessionHandler *msh );
00375 
00380       LogSink& logInstance();
00381 
00386       StreamError streamError() const { return m_streamError; };
00387 
00397       const std::string streamErrorText( const std::string& lang = "default" ) const;
00398 
00405       const std::string streamErrorCData() const { return m_streamErrorCData; };
00406 
00412       const Tag* streamErrorAppCondition() const { return m_streamErrorAppCondition; };
00413 
00419       AuthenticationError authError() const { return m_authError; };
00420 
00421     protected:
00422       enum SaslMechanisms
00423       {
00424         SaslDigestMd5,          
00425         SaslPlain,               
00426         SaslAnonymous,           
00428         SaslExternal             
00429       };
00430 
00431       void notifyOnResourceBindError( ResourceBindError error );
00432       void notifyOnSessionCreateError( SessionCreateError error );
00433       bool notifyOnTLSConnect( const CertInfo& info );
00434       void notifyOnConnect();
00435       virtual void disconnect( ConnectionError reason );
00436       void header();
00437       void setAuthed( bool authed ) { m_authed = authed; };
00438       void setAuthFailure( AuthenticationError e ) { m_authError = e; };
00439       virtual bool checkStreamVersion( const std::string& version );
00440 
00441       void startSASL( SaslMechanisms type );
00442       void processSASLChallenge( const std::string& challenge );
00443       void processSASLError( Stanza *stanza );
00444       void startTls();
00445       bool hasTls();
00446 
00447       JID m_jid;
00448       Connection *m_connection;
00449 
00450       std::string m_clientCerts;
00451       std::string m_clientKey;
00452       std::string m_namespace;
00453       std::string m_password;
00454       std::string m_xmllang;
00455       std::string m_server;
00456       std::string m_sid;
00457       bool m_authed;
00458       bool m_sasl;
00459       bool m_tls;
00460       int m_port;
00461 
00462     private:
00463       enum NodeType
00464       {
00465         NODE_STREAM_START,             
00466         NODE_STREAM_ERROR,             
00467         NODE_STREAM_CLOSE,             
00468         NODE_STREAM_CHILD              
00469       };
00470 
00471       virtual void handleStartNode() = 0;
00472       virtual bool handleNormalNode( Stanza *stanza ) = 0;
00473       virtual void rosterFilled() = 0;
00474       virtual void cleanup();
00475       void handleStreamError( Stanza *stanza );
00476 
00477       void notifyIqHandlers( Stanza *stanza );
00478       void notifyMessageHandlers( Stanza *stanza );
00479       void notifyPresenceHandlers( Stanza *stanza );
00480       void notifySubscriptionHandlers( Stanza *stanza );
00481       void notifyTagHandlers( Stanza *stanza );
00482       void notifyOnDisconnect( ConnectionError e );
00483       void filter( NodeType type, Stanza *stanza );
00484       void logEvent( const char *data, size_t size, int is_incoming );
00485       void send( const std::string& xml );
00486 
00487       struct TrackStruct
00488       {
00489         IqHandler *ih;
00490         int context;
00491       };
00492 
00493       struct TagHandlerStruct
00494       {
00495         TagHandler *th;
00496         std::string xmlns;
00497         std::string tag;
00498       };
00499 
00500       typedef std::list<ConnectionListener*>                ConnectionListenerList;
00501       typedef std::map<const std::string, IqHandler*>       IqHandlerMap;
00502       typedef std::map<const std::string, TrackStruct>      IqTrackMap;
00503       typedef std::map<const std::string, MessageHandler*>  MessageHandlerMap;
00504       typedef std::list<MessageHandler*>                    MessageHandlerList;
00505       typedef std::list<PresenceHandler*>                   PresenceHandlerList;
00506       typedef std::list<SubscriptionHandler*>               SubscriptionHandlerList;
00507       typedef std::list<TagHandlerStruct>                   TagHandlerList;
00508 
00509       ConnectionListenerList  m_connectionListeners;
00510       IqHandlerMap            m_iqNSHandlers;
00511       IqTrackMap              m_iqIDHandlers;
00512       MessageHandlerMap       m_messageJidHandlers;
00513       MessageHandlerList      m_messageHandlers;
00514       PresenceHandlerList     m_presenceHandlers;
00515       SubscriptionHandlerList m_subscriptionHandlers;
00516       TagHandlerList          m_tagHandlers;
00517       StringList              m_cacerts;
00518       MessageSessionHandler  *m_messageSessionHandler;
00519 
00520       Parser *m_parser;
00521       LogSink m_logInstance;
00522 
00523       AuthenticationError m_authError;
00524       StreamError m_streamError;
00525       StringMap m_streamErrorText;
00526       std::string m_streamErrorCData;
00527       Tag *m_streamErrorAppCondition;
00528       int m_idCount;
00529       bool m_autoMessageSession;
00530       bool m_fdRequested;
00531 
00532   };
00533 
00534 }
00535 
00536 #endif // CLIENTBASE_H__

Generated on Sun Sep 24 21:57:31 2006 for gloox by  doxygen 1.4.7