gloox.h

/*
  Copyright (c) 2005-2015 by Jakob Schröter <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 GLOOX_H__
#define GLOOX_H__

#include "macros.h"

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

namespace gloox
{
  GLOOX_API extern const std::string XMLNS_CLIENT;

  GLOOX_API extern const std::string XMLNS_COMPONENT_ACCEPT;

  GLOOX_API extern const std::string XMLNS_COMPONENT_CONNECT;

  GLOOX_API extern const std::string XMLNS_DISCO_INFO;

  GLOOX_API extern const std::string XMLNS_DISCO_ITEMS;

  GLOOX_API extern const std::string XMLNS_DISCO_PUBLISH;

  GLOOX_API extern const std::string XMLNS_ADHOC_COMMANDS;

  GLOOX_API extern const std::string XMLNS_COMPRESSION;

  GLOOX_API extern const std::string XMLNS_OFFLINE;

  GLOOX_API extern const std::string XMLNS_CHAT_STATES;

  GLOOX_API extern const std::string XMLNS_AMP;

  GLOOX_API extern const std::string XMLNS_IBB;

  GLOOX_API extern const std::string XMLNS_FEATURE_NEG;

  GLOOX_API extern const std::string XMLNS_CHATNEG;

  GLOOX_API extern const std::string XMLNS_XHTML_IM;

  GLOOX_API extern const std::string XMLNS_DELAY;

  GLOOX_API extern const std::string XMLNS_ROSTER;

  GLOOX_API extern const std::string XMLNS_VERSION;

  GLOOX_API extern const std::string XMLNS_REGISTER;

  GLOOX_API extern const std::string XMLNS_PRIVACY;

  GLOOX_API extern const std::string XMLNS_AUTH;

  GLOOX_API extern const std::string XMLNS_PRIVATE_XML;

  GLOOX_API extern const std::string XMLNS_LAST;

  GLOOX_API extern const std::string XMLNS_SEARCH;

  GLOOX_API extern const std::string XMLNS_IQ_OOB;

  GLOOX_API extern const std::string XMLNS_X_DATA;

  GLOOX_API extern const std::string XMLNS_X_EVENT;

  GLOOX_API extern const std::string XMLNS_X_OOB;

  GLOOX_API extern const std::string XMLNS_X_DELAY;

  GLOOX_API extern const std::string XMLNS_X_GPGSIGNED;

  GLOOX_API extern const std::string XMLNS_X_GPGENCRYPTED;

  GLOOX_API extern const std::string XMLNS_VCARD_TEMP;

  GLOOX_API extern const std::string XMLNS_X_VCARD_UPDATE;

  GLOOX_API extern const std::string XMLNS_BOOKMARKS;

  GLOOX_API extern const std::string XMLNS_ANNOTATIONS;

  GLOOX_API extern const std::string XMLNS_ROSTER_DELIMITER;

  GLOOX_API extern const std::string XMLNS_XMPP_PING;

  GLOOX_API extern const std::string XMLNS_SI;

  GLOOX_API extern const std::string XMLNS_SI_FT;

  GLOOX_API extern const std::string XMLNS_BYTESTREAMS;

  GLOOX_API extern const std::string XMLNS_MUC;

  GLOOX_API extern const std::string XMLNS_MUC_USER;

  GLOOX_API extern const std::string XMLNS_MUC_ADMIN;

  GLOOX_API extern const std::string XMLNS_MUC_UNIQUE;

  GLOOX_API extern const std::string XMLNS_MUC_OWNER;

  GLOOX_API extern const std::string XMLNS_MUC_ROOMINFO;

  GLOOX_API extern const std::string XMLNS_MUC_ROOMS;

  GLOOX_API extern const std::string XMLNS_MUC_REQUEST;

  GLOOX_API extern const std::string XMLNS_PUBSUB;

  GLOOX_API extern const std::string XMLNS_PUBSUB_ERRORS;

  GLOOX_API extern const std::string XMLNS_PUBSUB_EVENT;

  GLOOX_API extern const std::string XMLNS_PUBSUB_OWNER;

  GLOOX_API extern const std::string XMLNS_CAPS;

  GLOOX_API extern const std::string XMLNS_FT_FASTMODE;

  GLOOX_API extern const std::string XMLNS_STREAM;

  GLOOX_API extern const std::string XMLNS_XMPP_STREAM;

  GLOOX_API extern const std::string XMLNS_XMPP_STANZAS;

  GLOOX_API extern const std::string XMLNS_STREAM_TLS;

  GLOOX_API extern const std::string XMLNS_STREAM_SASL;

  GLOOX_API extern const std::string XMLNS_STREAM_BIND;

  GLOOX_API extern const std::string XMLNS_STREAM_SESSION;

  GLOOX_API extern const std::string XMLNS_STREAM_IQAUTH;

  GLOOX_API extern const std::string XMLNS_STREAM_IQREGISTER;

  GLOOX_API extern const std::string XMLNS_STREAM_COMPRESS;

  GLOOX_API extern const std::string XMLNS_HTTPBIND;

  GLOOX_API extern const std::string XMLNS_XMPP_BOSH;

  GLOOX_API extern const std::string XMLNS_RECEIPTS;

  GLOOX_API extern const std::string XMLNS_NICKNAME;

  GLOOX_API extern const std::string XMLNS_JABBER_RPC;

  GLOOX_API extern const std::string XMLNS_JINGLE;

  GLOOX_API extern const std::string XMLNS_JINGLE_ERRORS;

  GLOOX_API extern const std::string XMLNS_JINGLE_ICE_UDP;

  GLOOX_API extern const std::string XMLNS_JINGLE_FILE_TRANSFER;

  GLOOX_API extern const std::string XMLNS_JINGLE_FILE_TRANSFER_MULTI;

  GLOOX_API extern const std::string XMLNS_SHIM;

  GLOOX_API extern const std::string XMLNS_ATTENTION;

  GLOOX_API extern const std::string XMLNS_STREAM_MANAGEMENT;

  GLOOX_API extern const std::string XMLNS_STANZA_FORWARDING;

  GLOOX_API extern const std::string XMLNS_MESSAGE_CARBONS;

  GLOOX_API extern const std::string XMLNS_HASHES;

  GLOOX_API extern const std::string XMLNS_IODATA;

  GLOOX_API extern const std::string XMPP_STREAM_VERSION_MAJOR;

  GLOOX_API extern const std::string XMPP_STREAM_VERSION_MINOR;

  GLOOX_API extern const std::string GLOOX_VERSION;

  GLOOX_API extern const std::string GLOOX_CAPS_NODE;

  GLOOX_API extern const std::string XMLNS;

  GLOOX_API extern const std::string TYPE;

  GLOOX_API extern const std::string EmptyString;

  enum ConnectionState
  {
    StateDisconnected,              
    StateConnecting,                
    StateConnected                  
  };

  enum StreamEvent
  {
    StreamEventConnecting,          
    StreamEventEncryption,          
    StreamEventCompression,         
    StreamEventAuthentication,      
    StreamEventSessionInit,         
    StreamEventResourceBinding,     
    StreamEventSMEnable,            
    StreamEventSMResume,            
    StreamEventSMResumed,           
    StreamEventSMEnableFailed,      
    StreamEventSMResumeFailed,      
    StreamEventSessionCreation,     
    StreamEventRoster,              
    StreamEventFinished             
  };

  enum ConnectionError
  {
    ConnNoError,                    
    ConnStreamError,                
    ConnStreamVersionError,         
    ConnStreamClosed,               
    ConnProxyAuthRequired,          
    ConnProxyAuthFailed,            
    ConnProxyNoSupportedAuth,       
    ConnIoError,                    
    ConnParseError,                 
    ConnConnectionRefused,          
    ConnDnsError,                   
    ConnOutOfMemory,                
    ConnNoSupportedAuth,            
    ConnTlsFailed,                  
    ConnTlsNotAvailable,            
    ConnCompressionFailed,          
    ConnAuthenticationFailed,       
    ConnUserDisconnected,           
    ConnNotConnected                
  };

  enum TLSPolicy
  {
    TLSDisabled,                    
    TLSOptional,                    
    TLSRequired                     
  };

  enum StreamFeature
  {
    StreamFeatureBind             =    1, 
    StreamFeatureUnbind           =    2, 
    StreamFeatureSession          =    4, 
    StreamFeatureStartTls         =    8, 
    StreamFeatureIqRegister       =   16, 
    StreamFeatureIqAuth           =   32, 
    StreamFeatureCompressZlib     =   64, 
    StreamFeatureCompressDclz     =  128, 
    StreamFeatureStreamManagement =  256  
    // SaslMechanism below must be adjusted accordingly.
  };

  // must be adjusted with changes to StreamFeature enum above
  enum SaslMechanism
  {
    SaslMechNone          =      0, 
    SaslMechScramSha1     =   2048, 
    SaslMechScramSha1Plus =   1024, 
    SaslMechDigestMd5     =   4096, 
    SaslMechPlain         =   8192, 
    SaslMechAnonymous     =  16384, 
    SaslMechExternal      =  32768, 
    SaslMechGssapi        =  65536, 
    SaslMechNTLM          = 131072, 
    SaslMechAll           = 262143  
  };

  enum StreamError
  {
    StreamErrorBadFormat,           
    StreamErrorBadNamespacePrefix,  
    StreamErrorConflict,            
    StreamErrorConnectionTimeout,   
    StreamErrorHostGone,            
    StreamErrorHostUnknown,         
    StreamErrorImproperAddressing,  
    StreamErrorInternalServerError, 
    StreamErrorInvalidFrom,         
    StreamErrorInvalidId,           
    StreamErrorInvalidNamespace,    
    StreamErrorInvalidXml,          
    StreamErrorNotAuthorized,       
    StreamErrorPolicyViolation,     
    StreamErrorRemoteConnectionFailed,
    StreamErrorResourceConstraint,  
    StreamErrorRestrictedXml,       
    StreamErrorSeeOtherHost,        
    StreamErrorSystemShutdown,      
    StreamErrorUndefinedCondition,  
    StreamErrorUnsupportedEncoding, 
    StreamErrorUnsupportedStanzaType,
    StreamErrorUnsupportedVersion,  
    StreamErrorXmlNotWellFormed,    
    StreamErrorUndefined            
  };

  enum StanzaErrorType
  {
    StanzaErrorTypeAuth,            
    StanzaErrorTypeCancel,          
    StanzaErrorTypeContinue,        
    StanzaErrorTypeModify,          
    StanzaErrorTypeWait,            
    StanzaErrorTypeUndefined        
  };

  enum StanzaError
  {

    StanzaErrorBadRequest,          
    StanzaErrorConflict,            
    StanzaErrorFeatureNotImplemented,
    StanzaErrorForbidden,           
    StanzaErrorGone,                
    StanzaErrorInternalServerError, 
    StanzaErrorItemNotFound,        
    StanzaErrorJidMalformed,        
    StanzaErrorNotAcceptable,       
    StanzaErrorNotAllowed,          
    StanzaErrorNotAuthorized,       
    StanzaErrorNotModified,         
    StanzaErrorPaymentRequired,     
    StanzaErrorRecipientUnavailable,
    StanzaErrorRedirect,            
    StanzaErrorRegistrationRequired,
    StanzaErrorRemoteServerNotFound,
    StanzaErrorRemoteServerTimeout, 
    StanzaErrorResourceConstraint,  
    StanzaErrorServiceUnavailable,  
    StanzaErrorSubscribtionRequired,
    StanzaErrorUndefinedCondition,  
    StanzaErrorUnexpectedRequest,   
    StanzaErrorUnknownSender,       
    StanzaErrorUndefined            
  };

//   enum Presence
//   {
//     PresenceUnknown,                /**< Unknown status. */
//     PresenceAvailable,              /**< The entity or resource is online and available. */
//     PresenceChat,                   /**< The entity or resource is actively interested in chatting. */
//     PresenceAway,                   /**< The entity or resource is temporarily away. */
//     PresenceDnd,                    /**< The entity or resource is busy (dnd = "Do Not Disturb"). */
//     PresenceXa,                     /**< The entity or resource is away for an extended period (xa =
//                                      * "eXtended Away"). */
//     PresenceUnavailable             /**< The entity or resource is offline. */
//   };

  enum CertStatus
  {
    CertOk               =  0,      
    CertInvalid          =  1,      
    CertSignerUnknown    =  2,      
    CertRevoked          =  4,      
    CertExpired          =  8,      
    CertNotActive        = 16,      
    CertWrongPeer        = 32,      
    CertSignerNotCa      = 64       
  };

  struct CertInfo
  {
    int status;                     
    bool chain;                     
    std::string issuer;             
    std::string server;             
    int date_from;                  
    int date_to;                    
    std::string protocol;           
    std::string cipher;             
    std::string mac;                
    std::string compression;        
  };

  enum AuthenticationError
  {
    AuthErrorUndefined,             
    SaslAborted,                    
    SaslIncorrectEncoding,          
    SaslInvalidAuthzid,             
    SaslInvalidMechanism,           
    SaslMalformedRequest,           
    SaslMechanismTooWeak,           
    SaslNotAuthorized,              
    SaslTemporaryAuthFailure,       
    NonSaslConflict,                
    NonSaslNotAcceptable,           
    NonSaslNotAuthorized            
  };

  enum LogArea
  {
    LogAreaClassParser                = 0x000001, 
    LogAreaClassConnectionTCPBase     = 0x000002, 
    LogAreaClassClient                = 0x000004, 
    LogAreaClassClientbase            = 0x000008, 
    LogAreaClassComponent             = 0x000010, 
    LogAreaClassDns                   = 0x000020, 
    LogAreaClassConnectionHTTPProxy   = 0x000040, 
    LogAreaClassConnectionSOCKS5Proxy = 0x000080, 
    LogAreaClassConnectionTCPClient   = 0x000100, 
    LogAreaClassConnectionTCPServer   = 0x000200, 
    LogAreaClassS5BManager            = 0x000400, 
    LogAreaClassSOCKS5Bytestream      = 0x000800, 
    LogAreaClassConnectionBOSH        = 0x001000, 
    LogAreaClassConnectionTLS         = 0x002000, 
    LogAreaLinkLocalManager           = 0x004000, 
    LogAreaAllClasses                 = 0x01FFFF, 
    LogAreaXmlIncoming                = 0x020000, 
    LogAreaXmlOutgoing                = 0x040000, 
    LogAreaUser                       = 0x800000, 
    LogAreaAll                        = 0xFFFFFF  
  };

  enum LogLevel
  {
    LogLevelDebug,                  
    LogLevelWarning,                
    LogLevelError                   
  };

  enum MessageEventType
  {
    MessageEventOffline   =  1,     
    MessageEventDelivered =  2,     
    MessageEventDisplayed =  4,     
    MessageEventComposing =  8,     
    MessageEventInvalid   = 16,     
    MessageEventCancel    = 32      
  };

  enum ChatStateType
  {
    ChatStateActive       =  1,     
    ChatStateComposing    =  2,     
    ChatStatePaused       =  4,     
    ChatStateInactive     =  8,     
    ChatStateGone         = 16,     
    ChatStateInvalid      = 32      
  };

  enum ResourceBindError
  {
    RbErrorUnknownError,            
    RbErrorBadRequest,              
    RbErrorNotAllowed,              
    RbErrorConflict                 
  };

  enum SessionCreateError
  {
    ScErrorUnknownError,            
    ScErrorInternalServerError,     
    ScErrorForbidden,               
    ScErrorConflict                 
  };

  enum MessageSessionFilter
  {
    FilterMessageEvents    = 1,     
    FilterChatStates       = 2      
  };

  enum MUCRoomAffiliation
  {
    AffiliationNone,                
    AffiliationOutcast,             
    AffiliationMember,              
    AffiliationOwner,               
    AffiliationAdmin,               
    AffiliationInvalid              
  };

  enum MUCRoomRole
  {
    RoleNone,                       
    RoleVisitor,                    
    RoleParticipant,                
    RoleModerator,                  
    RoleInvalid                     
  };

  enum MUCRoomFlag
  {
    FlagPasswordProtected  = 1<< 1, 
    FlagPublicLogging      = 1<< 2, 
    FlagPublicLoggingOff   = 1<< 3, 
    FlagHidden             = 1<< 4, 
    FlagMembersOnly        = 1<< 5, 
    FlagModerated          = 1<< 6, 
    FlagNonAnonymous       = 1<< 7, 
    FlagOpen               = 1<< 8, 
    FlagPersistent         = 1<< 9, 
    FlagPublic             = 1<<10, 
    FlagSemiAnonymous      = 1<<11, 
    FlagTemporary          = 1<<12, 
    FlagUnmoderated        = 1<<13, 
    FlagUnsecured          = 1<<14, 
    FlagFullyAnonymous     = 1<<15  
    // keep in sync with MUCUserFlag below
  };

  // keep in sync with MUCRoomFlag above
  enum MUCUserFlag
  {
    UserSelf               = 1<<16, 
    UserNickChanged        = 1<<17, 
    UserKicked             = 1<<18, 
    UserBanned             = 1<<19, 
    UserAffiliationChanged = 1<<20, 
    UserRoomDestroyed      = 1<<21, 
    UserNickAssigned       = 1<<22, 
    UserNewRoom            = 1<<23, 
    UserMembershipRequired = 1<<24, 
    UserRoomShutdown       = 1<<25, 
    UserAffiliationChangedWNR = 1<<26 
  };

  enum SubscriptionType
  {
    S10nNone,                       
    S10nNoneOut,                    
    S10nNoneIn,                     
    S10nNoneOutIn,                  
    S10nTo,                         
    S10nToIn,                       
    S10nFrom,                       
    S10nFromOut,                    
    S10nBoth                        
  };

  typedef std::list<std::string> StringList;

  typedef std::list<std::string*> StringPList;

  typedef std::map<std::string, std::string> StringMap;

  typedef std::multimap<std::string, std::string> StringMultiMap;

  class StanzaExtension;
  typedef std::list<const StanzaExtension*> StanzaExtensionList;
}

extern "C"
{
  GLOOX_API const char* gloox_version();
}

#endif // GLOOX_H__