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 
00277       void registerMessageHandler( const std::string& jid, MessageHandler *mh, bool wantUpgrade );
00278 
00283       void registerPresenceHandler( PresenceHandler *ph );
00284 
00289       void registerSubscriptionHandler( SubscriptionHandler *sh );
00290 
00298       void registerTagHandler( TagHandler *th, const std::string& tag,
00299                                                 const std::string& xmlns );
00300 
00305       void removeConnectionListener( ConnectionListener *cl );
00306 
00311       void removeIqHandler( const std::string& xmlns );
00312 
00317       void removeMessageHandler( MessageHandler *mh );
00318 
00323       void removeMessageHandler( const std::string& jid );
00324 
00329       void removePresenceHandler( PresenceHandler *ph );
00330 
00335       void removeSubscriptionHandler( SubscriptionHandler *sh );
00336 
00343       void removeTagHandler( TagHandler *th, const std::string& tag,
00344                                              const std::string& xmlns );
00345 
00351       void setCACerts( const StringList& cacerts ) { m_cacerts = cacerts; };
00352 
00364       void setClientCert( const std::string& clientKey, const std::string& clientCerts );
00365 
00376       void setAutoMessageSession( bool autoMS, MessageSessionHandler *msh );
00377 
00382       LogSink& logInstance();
00383 
00388       StreamError streamError() const { return m_streamError; };
00389 
00399       const std::string streamErrorText( const std::string& lang = "default" ) const;
00400 
00407       const std::string streamErrorCData() const { return m_streamErrorCData; };
00408 
00414       const Tag* streamErrorAppCondition() const { return m_streamErrorAppCondition; };
00415 
00421       AuthenticationError authError() const { return m_authError; };
00422 
00423     protected:
00424       enum SaslMechanisms
00425       {
00426         SaslDigestMd5,          
00427         SaslPlain,               
00428         SaslAnonymous,           
00430         SaslExternal             
00431       };
00432 
00433       void notifyOnResourceBindError( ResourceBindError error );
00434       void notifyOnSessionCreateError( SessionCreateError error );
00435       bool notifyOnTLSConnect( const CertInfo& info );
00436       void notifyOnConnect();
00437       virtual void disconnect( ConnectionError reason );
00438       void header();
00439       void setAuthed( bool authed ) { m_authed = authed; };
00440       void setAuthFailure( AuthenticationError e ) { m_authError = e; };
00441       virtual bool checkStreamVersion( const std::string& version );
00442 
00443       void startSASL( SaslMechanisms type );
00444       void processSASLChallenge( const std::string& challenge );
00445       void processSASLError( Stanza *stanza );
00446       void startTls();
00447       bool hasTls();
00448 
00449       JID m_jid;
00450       Connection *m_connection;
00451 
00452       std::string m_clientCerts;
00453       std::string m_clientKey;
00454       std::string m_namespace;
00455       std::string m_password;
00456       std::string m_xmllang;
00457       std::string m_server;
00458       std::string m_sid;
00459       bool m_authed;
00460       bool m_sasl;
00461       bool m_tls;
00462       int m_port;
00463 
00464     private:
00465       enum NodeType
00466       {
00467         NODE_STREAM_START,             
00468         NODE_STREAM_ERROR,             
00469         NODE_STREAM_CLOSE,             
00470         NODE_STREAM_CHILD              
00471       };
00472 
00473       virtual void handleStartNode() = 0;
00474       virtual bool handleNormalNode( Stanza *stanza ) = 0;
00475       virtual void rosterFilled() = 0;
00476       virtual void cleanup();
00477       void handleStreamError( Stanza *stanza );
00478 
00479       void notifyIqHandlers( Stanza *stanza );
00480       void notifyMessageHandlers( Stanza *stanza );
00481       void notifyPresenceHandlers( Stanza *stanza );
00482       void notifySubscriptionHandlers( Stanza *stanza );
00483       void notifyTagHandlers( Stanza *stanza );
00484       void notifyOnDisconnect( ConnectionError e );
00485       void filter( NodeType type, Stanza *stanza );
00486       void logEvent( const char *data, size_t size, int is_incoming );
00487       void send( const std::string& xml );
00488 
00489       struct TrackStruct
00490       {
00491         IqHandler *ih;
00492         int context;
00493       };
00494 
00495       struct TagHandlerStruct
00496       {
00497         TagHandler *th;
00498         std::string xmlns;
00499         std::string tag;
00500       };
00501 
00502       struct JidHandlerStruct
00503       {
00504         MessageHandler *mh;
00505         bool wantUpgrade;
00506       };
00507 
00508       typedef std::list<ConnectionListener*>                ConnectionListenerList;
00509       typedef std::map<const std::string, IqHandler*>       IqHandlerMap;
00510       typedef std::map<const std::string, TrackStruct>      IqTrackMap;
00511       typedef std::map<const std::string, MessageHandler*>  MessageHandlerMap;
00512       typedef std::map<const std::string, JidHandlerStruct> MessageJidHandlerMap;
00513       typedef std::list<MessageHandler*>                    MessageHandlerList;
00514       typedef std::list<PresenceHandler*>                   PresenceHandlerList;
00515       typedef std::list<SubscriptionHandler*>               SubscriptionHandlerList;
00516       typedef std::list<TagHandlerStruct>                   TagHandlerList;
00517 
00518       ConnectionListenerList  m_connectionListeners;
00519       IqHandlerMap            m_iqNSHandlers;
00520       IqTrackMap              m_iqIDHandlers;
00521       MessageJidHandlerMap    m_messageJidHandlers;
00522       MessageHandlerList      m_messageHandlers;
00523       PresenceHandlerList     m_presenceHandlers;
00524       SubscriptionHandlerList m_subscriptionHandlers;
00525       TagHandlerList          m_tagHandlers;
00526       StringList              m_cacerts;
00527       MessageSessionHandler  *m_messageSessionHandler;
00528 
00529       Parser *m_parser;
00530       LogSink m_logInstance;
00531 
00532       AuthenticationError m_authError;
00533       StreamError m_streamError;
00534       StringMap m_streamErrorText;
00535       std::string m_streamErrorCData;
00536       Tag *m_streamErrorAppCondition;
00537       int m_idCount;
00538       bool m_autoMessageSession;
00539       bool m_fdRequested;
00540 
00541   };
00542 
00543 }
00544 
00545 #endif // CLIENTBASE_H__

Generated on Wed Dec 20 18:25:28 2006 for gloox by  doxygen 1.5.1