sipxtapievents.h

基于sipfoundy 公司开发的sipx协议API

    CALLSTATE_TRANSFER_INITIATED      = CALLSTATE_TRANSFER + 1,         /**< A transfer attempt has been initiated.  This event
                                                                             is sent when a user agent attempts either a blind
                                                                             or consultative transfer. */
    CALLSTATE_TRANSFER_ACCEPTED,                                        /**< A transfer attempt has been accepted by the remote
                                                                             transferee.  This event indicates that the 
                                                                             transferee supports transfers (REFER method).  The
                                                                             event is fired upon a 2xx class response to the SIP
                                                                             REFER request. */
    CALLSTATE_TRANSFER_TRYING,                                          /**< The transfer target is attempting the transfer.  
                                                                             This event is sent when transfer target (or proxy /
                                                                             B2BUA) receives the call invitation, but before the
                                                                             the tranfer target accepts is. */
    CALLSTATE_TRANSFER_RINGING,                                         /**< The transfer target is ringing.  This event is 
                                                                             generally only sent during blind transfer.  
                                                                             Consultative transfer should proceed directly to 
                                                                             TRANSFER_SUCCESS or TRANSFER_FAILURE. */
    CALLSTATE_TRANSFER_SUCCESS,                                         /**< The transfer was completed successfully.  The
                                                                             original call to transfer target will
                                                                             automatically disconnect.*/
    CALLSTATE_TRANSFER_FAILURE,                                         /**< The transfer failed.  After a transfer fails,
                                                                             the application layer is responsible for 
                                                                             recovering original call to the transferee. 
                                                                             That call is left on hold. */
    CALLSTATE_SECURITY_SELF_SIGNED_CERT = CALLSTATE_SECURITY_EVENT + 1, /**< A self-signed certificate is being used for S/MIME. */
    CALLSTATE_SECURITY_SESSION_NOT_SECURED,                             /**< Fired if a secure session could not be made. */
    CALLSTATE_SECURITY_REMOTE_SMIME_UNSUPPORTED,                        /**< Fired if the remote party's user-agent does not
                                                                             support S/MIME. */
    CALLSTATE_IDENTITY_CHANGE_UNKNOWN = CALLSTATE_IDENTITY_CHANGE + 1,   /**< The P-Asserted-Identity changed for a unknown reason
                                                                             The identity may have changed because of a transfer or
                                                                             some other reason, but the signalling did not give any
                                                                             indication as to why it changed. */
    CALLSTATE_CAUSE_UNKNOWN,                                            /* used in applicaiton when not event based */

} SIPX_CALLSTATE_CAUSE ;

/**
 * Enumeration of possible linestate Events.
 */
 typedef enum SIPX_LINESTATE_EVENT
{
    LINESTATE_UNKNOWN  = -1,            /**< This is the initial Line event state. */
    LINESTATE_REGISTERING   = 20000,    /**< The REGISTERING event is fired when sipXtapi
                                             has successfully sent a REGISTER message,
                                             but has not yet received a success response from the
                                             registrar server */    
    LINESTATE_REGISTERED  = 21000,      /**< The REGISTERED event is fired after sipXtapi has received
                                             a response from the registrar server, indicating a successful
                                             registration. */
    LINESTATE_UNREGISTERING    = 22000, /**< The UNREGISTERING event is fired when sipXtapi
                                             has successfully sent a REGISTER message with an expires=0 parameter,
                                             but has not yet received a success response from the
                                             registrar server */
    LINESTATE_UNREGISTERED     = 23000, /**< The UNREGISTERED event is fired after sipXtapi has received
                                             a response from the registrar server, indicating a successful
                                             un-registration. */
    LINESTATE_REGISTER_FAILED  = 24000, /**< The REGISTER_FAILED event is fired to indicate a failure of REGISTRATION.
                                             It is fired in the following cases:  
                                             The client could not connect to the registrar server.
                                             The registrar server challenged the client for authentication credentials,
                                             and the client failed to supply valid credentials.
                                             The registrar server did not generate a success response (status code == 200)
                                             within a timeout period.  */
    LINESTATE_UNREGISTER_FAILED  = 25000,/**< The UNREGISTER_FAILED event is fired to indicate a failure of un-REGISTRATION.
                                             It is fired in the following cases:  
                                             The client could not connect to the registrar server.
                                             The registrar server challenged the client for authentication credentials,
                                             and the client failed to supply valid credentials.
                                             The registrar server did not generate a success response (status code == 200)
                                             within a timeout period.  */
    LINESTATE_PROVISIONED      = 26000, /**< The PROVISIONED event is fired when a sipXtapi Line is added, and Registration is not 
                                             requested (i.e. - sipxLineAdd is called with a bRegister parameter of false. */ 
} SIPX_LINESTATE_EVENT;  


/**
 * Enumeration of possible INFO status events
 */
enum SIPX_INFOSTATUS_EVENT
{
    INFOSTATUS_UNKNOWN = -1,            /**< This is the initial value for an INFOSTATUS event. */
    INFOSTATUS_RESPONSE = 1000,         /**< This event is fired if a response is received after an
                                             INFO message has been sent */
    INFOSTATUS_NETWORK_ERROR = 2000     /**< This event is fired in case a network error was encountered
                                             while trying to send an INFO event. */
};


/**
 * Enumeration of possible linestate Event causes.
 */
typedef enum SIPX_LINESTATE_CAUSE
{
    LINESTATE_CAUSE_UNKNOWN                           = -1,                                /**< No cause specified. */
    LINESTATE_REGISTERING_NORMAL                      = LINESTATE_REGISTERING + 1,         /**< See LINESTATE_REGISTERING
                                                                                                event. */ 
    LINESTATE_REGISTERED_NORMAL                       = LINESTATE_REGISTERED + 1,          /**< See LINESTATE_REGISTERED
                                                                                                event. */
    LINESTATE_UNREGISTERING_NORMAL                    = LINESTATE_UNREGISTERING + 1,       /**< See LINESTATE_UNREGISTERING
                                                                                                event. */
    LINESTATE_UNREGISTERED_NORMAL                     = LINESTATE_UNREGISTERED + 1,        /**< See LINESTATE_UNREGISTERED
                                                                                                event. */
    LINESTATE_REGISTER_FAILED_COULD_NOT_CONNECT       = LINESTATE_REGISTER_FAILED + 1,     /**< Failed to register because
                                                                                                of a connectivity problem. */
    LINESTATE_REGISTER_FAILED_NOT_AUTHORIZED          = LINESTATE_REGISTER_FAILED + 2,     /**< Failed to register because
                                                                                                of an authorization / 
                                                                                                authentication failure. */
    LINESTATE_REGISTER_FAILED_TIMEOUT                 = LINESTATE_REGISTER_FAILED + 3,     /**< Failed to register because of
                                                                                                a timeout. */
    LINESTATE_UNREGISTER_FAILED_COULD_NOT_CONNECT     = LINESTATE_UNREGISTER_FAILED + 1,   /**< Failed to unregister because of
                                                                                                a connectivity problem. */
    LINESTATE_UNREGISTER_FAILED_NOT_AUTHORIZED        = LINESTATE_UNREGISTER_FAILED + 2,   /**< Failed to unregister because of
                                                                                                of an authorization / 
                                                                                                authentication failure. */
    LINESTATE_UNREGISTER_FAILED_TIMEOUT               = LINESTATE_UNREGISTER_FAILED + 3,   /**< Failed to register because of
                                                                                                a timeout. */
    LINESTATE_PROVISIONED_NORMAL                      = LINESTATE_PROVISIONED + 1          /**< See LINESTATE_PROVISIONED
                                                                                                event. */
} SIPX_LINESTATE_CAUSE;


/**
 * Enumeration of possible configuration events
 */
enum SIPX_CONFIG_EVENT
{
    CONFIG_UNKNOWN = -1,    /**< Unknown configuration event */
    CONFIG_STUN_SUCCESS,    /**< A STUN binding has been obtained for signaling purposes.
                                 For a SIPX_CONFIG_EVENT type of CONFIG_STUN_SUCCESS, 
                                 the pData pointer of the info structure will point to a
                                 SIPX_CONTACT_ADDRESS structure. */
    CONFIG_STUN_FAILURE,    /**< Unable to obtain a STUN binding for signaling purposes. */
} ;


/**
 * Callstate event information structure
 */
typedef struct 
{
    // TODO: Add a bitmask that identified which structure items are valid.  For 
    //       example, codec and hAssociatedCall are only valid for certain event
    //       sequences.

    size_t    nSize;                /**< The size of this structure. */
    SIPX_CALL hCall;                /**< Call handle associated with the callstate event. */
    SIPX_LINE hLine;                /**< Line handle associated with the callstate event. */
    SIPX_CALLSTATE_EVENT event;     /**< Callstate event enum code.
                                         Identifies the callstate event. */
    SIPX_CALLSTATE_CAUSE cause;     /**< Callstate cause enum code. 
                                         Identifies the cause of the callstate event. */
    SIPX_CODEC_INFO codecs;         /**< Structure containing audio and video codec information */
    SIPX_CALL hAssociatedCall ;     /**< Call associated with this event.  For example, when
                                         a new call is created as part of a consultative 
                                         transfer, this handle contains the handle of the 
                                         original call. */
    const char* szRemoteIdentity;   /**< The asserted identity of the remote party on this call. */

} SIPX_CALLSTATE_INFO; 


/**
 * Linestate event information structure
 */
typedef struct                      
{
    size_t    nSize ;               /**< The size of this structure. */
    SIPX_LINE hLine;                /**< Line handle associated with the linestate event. */ 
    SIPX_LINESTATE_EVENT event ;    /**< Callstate event enum code.
                                         Identifies the linestate event. */
    SIPX_LINESTATE_CAUSE cause ;    /**< Callstate cause enum code. 
                                         Identifies the cause of the linestate event. */
    const char *szBodyBytes;        /**< msg body to extract reg body */

} SIPX_LINESTATE_INFO ;


/**
 *  Major classifications of response statuses for a SIP message.
 */
typedef enum 
{
    SIPX_MESSAGE_OK,                  /**< The message was successfully processed (200) */ 
    SIPX_MESSAGE_FAILURE,             /**< The server received the message, but could or would
                                           not process it. */
    SIPX_MESSAGE_SERVER_FAILURE,      /**< The server encountered an error while trying to process
                                           the message. */
    SIPX_MESSAGE_GLOBAL_FAILURE,      /**< Fatal error encountered. */
} SIPX_MESSAGE_STATUS ;

/**
 * An INFOSTATUS event informs that application layer of the status
 * of an outbound INFO requests;
 */
typedef struct
{
    size_t              nSize ;             /**< the size of this structure in bytes */
    SIPX_INFO           hInfo ;             /**< the handle used to make the outbound info request. */ 
    SIPX_MESSAGE_STATUS status ;            /**< Emumerated status for this
                                                 request acknowledgement. */
    int                 responseCode ;      /**< Numerical status code for this
                                                 request acknowledgement. */
    const char*         szResponseText ;    /**< The text of the request acknowledgement. */
    SIPX_INFOSTATUS_EVENT event;            /**< Event code for this INFO STATUS message */
} SIPX_INFOSTATUS_INFO ;


/**
 * An INFO event signals the application layer that an INFO message
 * was sent to this user agent.  If the INFO message was sent to a 
 * call context (session) hCall will desiginate the call session. 
 */
typedef struct
{
    size_t      nSize ;             /**< Size of structure */
    SIPX_CALL   hCall ;             /**< Call handle if available */
    SIPX_LINE   hLine ;             /**< Line handle if available */
    const char* szFromURL ;         /**< the URL of the host that originated
                                         the INFO message */
    const char* szUserAgent;        /**< the User Agent string of the source agent */
    const char* szContentType ;     /**< string indicating the info content type */
    const char* pContent ;          /**< pointer to the INFO message content */
    size_t      nContentLength ;    /**< length of the INFO message content */
  
} SIPX_INFO_INFO ;

/**
 * Enumeration of the possible subscription states visible to the client.
 */
typedef enum