gloox.h

Jabber code library, developed with c

                                     * error if doing so would provide information about the intended
                                     * recipient's network availability to an entity that is not authorized
                                     * to know such information). */
    StanzaErrorRedirect,            /**< The recipient or server is redirecting requests for this information
                                     * to another entity, usually temporarily (the error stanza SHOULD
                                     * contain the alternate address, which MUST be a valid JID, in the XML
                                     * character data of the &lt;redirect/&gt; element); the associated
                                     * error type SHOULD be "modify". */
    StanzaErrorRegistrationRequired,/**< The requesting entity is not authorized to access the requested
                                     * service because registration is required; the associated error type
                                     * SHOULD be "auth". */
    StanzaErrorRemoteServerNotFound,/**< A remote server or service specified as part or all of the JID of
                                     * the intended recipient does not exist; the associated error type
                                     * SHOULD be "cancel". */
    StanzaErrorRemoteServerTimeout, /**< A remote server or service specified as part or all of the JID of
                                     * the intended recipient (or required to fulfill a request) could not be
                                     * contacted within a reasonable amount of time; the associated error
                                     * type SHOULD be "wait". */
    StanzaErrorResourceConstraint,  /**< The server or recipient lacks the system resources necessary to
                                     * service the request; the associated error type SHOULD be "wait". */
    StanzaErrorServiceUnavailable,  /**< The server or recipient does not currently provide the requested
                                     * service; the associated error type SHOULD be "cancel". */
    StanzaErrorSubscribtionRequired,/**< The requesting entity is not authorized to access the requested
                                     * service because a subscription is required; the associated error type
                                     * SHOULD be "auth". */
    StanzaErrorUndefinedCondition,  /**< The error condition is not one of those defined by the other
                                     * conditions in this list; any error type may be associated with this
                                     * condition, and it SHOULD be used only in conjunction with an
                                     * application-specific condition. */
    StanzaErrorUnexpectedRequest    /**< The recipient or server understood the request but was not expecting
                                     * it at this time (e.g., the request was out of order); the associated
                                     * error type SHOULD be "wait". */
  };

  /**
   * Describes the possible 'available presence' types.
   */
  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. */
  };

  /**
   * Describes the verification results of a certificate.
   */
  enum CertStatus
  {
    CertOk               =  0,      /**< The certificate is valid and trusted. */
    CertInvalid          =  1,      /**< The certificate is not trusted. */
    CertSignerUnknown    =  2,      /**< The certificate hasn't got a known issuer. */
    CertRevoked          =  4,      /**< The certificate has been revoked. */
    CertExpired          =  8,      /**< The certificate has expired. */
    CertNotActive        = 16,      /**< The certifiacte is not yet active. */
    CertWrongPeer        = 32,      /**< The certificate has not been issued for the
                                     * peer we're connected to. */
    CertSignerNotCa      = 64       /**< The signer is not a CA. */
  };

  /**
   * Describes the certificate presented by the peer.
   */
  struct CertInfo
  {
    int status;                     /**< Bitwise or'ed CertStatus or CertOK. */
    bool chain;                     /**< Determines whether the cert chain verified ok. */
    std::string issuer;             /**< The name of the issuing entity.*/
    std::string server;             /**< The server the certificate has been issued for. */
    int date_from;                  /**< The date from which onwards the certificate is valid
                                     * (in UTC, not set when using OpenSSL). */
    int date_to;                    /**< The date up to which the certificate is valid
                                     * (in UTC, not set when using OpenSSL). */
    std::string protocol;           /**< The encryption protocol used for the connection. */
    std::string cipher;             /**< The cipher used for the connection. */
    std::string mac;                /**< The MAC used for the connection. */
    std::string compression;        /**< The compression used for the connection. */
  };

  /**
   * Describes the defined SASL error conditions.
   */
  enum AuthenticationError
  {
    AuthErrorUndefined,             /**< No error occurred, or error condition is unknown. */
    SaslAborted,                    /**< The receiving entity acknowledges an &lt;abort/&gt; element sent
                                     * by the initiating entity; sent in reply to the &lt;abort/&gt;
                                     * element. */
    SaslIncorrectEncoding,          /**< The data provided by the initiating entity could not be processed
                                     * because the [BASE64] encoding is incorrect (e.g., because the encoding
                                     * does not adhere to the definition in Section 3 of [BASE64]); sent in
                                     * reply to a &lt;response/&gt; element or an &lt;auth/&gt; element with
                                     * initial response data. */
    SaslInvalidAuthzid,             /**< The authzid provided by the initiating entity is invalid, either
                                     * because it is incorrectly formatted or because the initiating entity
                                     * does not have permissions to authorize that ID; sent in reply to a
                                     * &lt;response/&gt; element or an &lt;auth/&gt; element with initial
                                     * response data.*/
    SaslInvalidMechanism,           /**< The initiating entity did not provide a mechanism or requested a
                                     * mechanism that is not supported by the receiving entity; sent in reply
                                     * to an &lt;auth/&gt; element. */
    SaslMechanismTooWeak,           /**< The mechanism requested by the initiating entity is weaker than
                                     * server policy permits for that initiating entity; sent in reply to a
                                     * &lt;response/&gt; element or an &lt;auth/&gt; element with initial
                                     * response data. */
    SaslNotAuthorized,              /**< The authentication failed because the initiating entity did not
                                     * provide valid credentials (this includes but is not limited to the
                                     * case of an unknown username); sent in reply to a &lt;response/&gt;
                                     * element or an &lt;auth/&gt; element with initial response data. */
    SaslTemporaryAuthFailure,       /**< The authentication failed because of a temporary error condition
                                     * within the receiving entity; sent in reply to an &lt;auth/&gt; element
                                     * or &lt;response/&gt; element. */
    NonSaslConflict,                /**< XEP-0078: Resource Conflict */
    NonSaslNotAcceptable,           /**< XEP-0078: Required Information Not Provided */
    NonSaslNotAuthorized            /**< XEP-0078: Incorrect Credentials */
  };

  /**
   * Identifies log sources.
   */
  enum LogArea
  {
    LogAreaClassParser                = 0x00001, /**< Log messages from Parser. */
    LogAreaClassConnectionTCPBase     = 0x00002, /**< Log messages from ConnectionTCPBase. */
    LogAreaClassClient                = 0x00004, /**< Log messages from Client. */
    LogAreaClassClientbase            = 0x00008, /**< Log messages from ClientBase. */
    LogAreaClassComponent             = 0x00010, /**< Log messages from Component. */
    LogAreaClassDns                   = 0x00020, /**< Log messages from DNS. */
    LogAreaClassConnectionHTTPProxy   = 0x00040, /**< Log messages from ConnectionHTTPProxy */
    LogAreaClassConnectionSOCKS5Proxy = 0x00080, /**< Log messages from ConnectionHTTPProxy */
    LogAreaClassConnectionTCPClient   = 0x00100, /**< Log messages from ConnectionTCPClient. */
    LogAreaClassConnectionTCPServer   = 0x00200, /**< Log messages from ConnectionTCPServer. */
    LogAreaClassS5BManager            = 0x00400, /**< Log messages from SOCKS5BytestreamManager. */
    LogAreaAllClasses                 = 0x01FFF, /**< All log messages from all the classes. */
    LogAreaXmlIncoming                = 0x02000, /**< Incoming XML. */
    LogAreaXmlOutgoing                = 0x04000, /**< Outgoing XML. */
    LogAreaUser                       = 0x80000, /**< User-defined sources. */
    LogAreaAll                        = 0xFFFFF  /**< All log sources. */
  };

  /**
   * Describes a log message's severity.
   */
  enum LogLevel
  {
    LogLevelDebug,                  /**< Debug messages. */
    LogLevelWarning,                /**< Non-crititcal warning messages. */
    LogLevelError                   /**< Critical, unrecoverable errors. */
  };

  /**
   * The possible Message Events according to XEP-0022.
   */
  enum MessageEventType
  {
    MessageEventCancel    = 0,      /**< Cancels the 'Composing' event. */
    MessageEventOffline   = 1,      /**< Indicates that the message has been stored offline by the
                                     * intended recipient's server. */
    MessageEventDelivered = 2,      /**< Indicates that the message has been delivered to the
                                     * recipient. */
    MessageEventDisplayed = 4,      /**< Indicates that the message has been displayed */
    MessageEventComposing = 8       /**< Indicates that a reply is being composed. */
  };

  /**
   * The possible Chat States according to XEP-0085.
   */
  enum ChatStateType
  {
    ChatStateActive       =  1,     /**< User is actively participating in the chat session. */
    ChatStateComposing    =  2,     /**< User is composing a message. */
    ChatStatePaused       =  4,     /**< User had been composing but now has stopped. */
    ChatStateInactive     =  8,     /**< User has not been actively participating in the chat session. */
    ChatStateGone         = 16      /**< User has effectively ended their participation in the chat
                                     * session. */
  };

  /**
   * Describes the possible error conditions for resource binding.
   */
  enum ResourceBindError
  {
    RbErrorUnknownError,            /**< An unknown error occured. */
    RbErrorBadRequest,              /**< Resource identifier cannot be processed. */
    RbErrorNotAllowed,              /**< Client is not allowed to bind a resource. */
    RbErrorConflict                 /**< Resource identifier is in use. */
  };

  /**
   * Describes the possible error conditions for session establishemnt.
   */
  enum SessionCreateError
  {
    ScErrorUnknownError,            /**< An unknown error occured. */
    ScErrorInternalServerError,     /**< Internal server error. */
    ScErrorForbidden,               /**< Username or resource not allowed to create session. */
    ScErrorConflict                 /**< Server informs newly-requested session of resource
                                     * conflict. */
  };

  /**
   * Currently implemented message session filters.
   */
  enum MessageSessionFilter
  {
    FilterMessageEvents    = 1,     /**< Message Events (XEP-0022) */
    FilterChatStates       = 2      /**< Chat State Notifications (XEP-0085) */
  };

  /**
   * Defined MUC room affiliations. See XEP-0045 for default privileges.
   */
  enum MUCRoomAffiliation
  {
    AffiliationNone,                /**< No affiliation with the room. */
    AffiliationOutcast,             /**< The user has been banned from the room. */
    AffiliationMember,              /**< The user is a member of the room. */
    AffiliationOwner,               /**< The user is a room owner. */
    AffiliationAdmin                /**< The user is a room admin. */
  };

  /**
   * Defined MUC room roles. See XEP-0045 for default privileges.
   */
  enum MUCRoomRole
  {
    RoleNone,                       /**< Not present in room. */
    RoleVisitor,                    /**< The user visits a room. */
    RoleParticipant,                /**< The user has voice in a moderatd room. */
    RoleModerator                   /**< The user is a room moderator. */
  };

  /**
   * Configuration flags for a room.
   */
  enum MUCRoomFlag
  {
    FlagPasswordProtected  =    1,  /**< Password-protected room.*/
    FlagPublicLogging      =    2,  /**< Room conversation is publicly logged. */
    FlagHidden             =    4,  /**< Hidden room. */
    FlagMembersOnly        =    8,  /**< Members-only room. */
    FlagModerated          =   16,  /**< Moderated room. */
    FlagNonAnonymous       =   32,  /**< Non-anonymous room. */
    FlagOpen               =   64,  /**< Open room. */
    FlagPersistent         =  128,  /**< Persistent room .*/
    FlagPublic             =  256,  /**< Public room. */
    FlagSemiAnonymous      =  512,  /**< Semi-anonymous room. */
    FlagTemporary          = 1024,  /**< Temporary room. */
    FlagUnmoderated        = 2048,  /**< Unmoderated room. */
    FlagUnsecured          = 4096,  /**< Unsecured room. */
    FlagFullyAnonymous     = 8192   /**< Fully anonymous room. */
  };

  /**
   * Configuration flags for a user.
   */
  enum MUCUserFlag
  {
    UserSelf               =   1,   /**< Other flags relate to the current user him/herself. */
    UserNickChanged        =   2,   /**< The user changed his/her nickname. */
    UserKicked             =   4,   /**< The user has been kicked. */
    UserBanned             =   8,   /**< The user has been banned. */
    UserAffiliationChanged =  16,   /**< The user's affiliation with the room changed. */
    UserRoomDestroyed      =  32    /**< The room has been destroyed. */
  };

  /**
   * A list of strings.
   */
  typedef std::list<std::string> StringList;

  /**
   * A map of strings.
   */
  typedef std::map<std::string, std::string> StringMap;

}

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

#endif // GLOOX_H__