sipxtapievents.cpp

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

// 
// 
// Copyright (C) 2005-2006 SIPez LLC.
// Licensed to SIPfoundry under a Contributor Agreement.
// 
// Copyright (C) 2004-2006 SIPfoundry Inc.
// Licensed by SIPfoundry under the LGPL license.
// 
// Copyright (C) 2004-2006 Pingtel Corp.
// Licensed to SIPfoundry under a Contributor Agreement.
// 
// $$
//////////////////////////////////////////////////////////////////////////////


// SYSTEM INCLUDES
#if !defined(_WIN32)
#  include <stddef.h>
#endif
#include <assert.h>
// APPLICATION INCLUDES
#include "tapi/sipXtapiEvents.h"
#include "tapi/sipXtapiInternal.h"
#include "tapi/SipXHandleMap.h"
#include "utl/UtlSList.h"
#include "utl/UtlSListIterator.h"
#include "utl/UtlVoidPtr.h"
#include "os/OsMutex.h"
#include "utl/UtlString.h"
#include "os/OsLock.h"
#include "net/Url.h"
#include "utl/UtlHashMap.h"
#include "utl/UtlString.h"
#include "net/SipSession.h"
#include "cp/CallManager.h"



#if defined(_VXWORKS)
extern "C" int snprintf (char *str, size_t count, const char *fmt, ...);
#endif


// DEFINES
#if defined(WIN32)
#define SNPRINTF _snprintf
#else
#define SNPRINTF snprintf
#endif

// #define DEBUG_SIPXTAPI_EVENTS

// GLOBAL VARIABLES
UtlSList*   g_pListeners = new UtlSList();
OsMutex*    g_pListenerLock = new OsMutex(OsMutex::Q_FIFO) ;
UtlSList*   g_pLineListeners = new UtlSList();
OsMutex*    g_pLineListenerLock = new OsMutex(OsMutex::Q_FIFO) ;
UtlSList*	g_pEventListeners = new UtlSList();
OsMutex*    g_pEventListenerLock = new OsMutex(OsMutex::Q_FIFO) ;

// EXTERNAL VARIABLES
extern SipXHandleMap* gpCallHandleMap ;   // sipXtapiInternal.cpp

// EXTERNAL FUNCTIONS
// STRUCTURES

// FUNCTION DECLARATIONS
static const char* MajorLineEventToString(SIPX_LINE_EVENT_TYPE_MAJOR eMajor);
static const char* MinorLineEventToString(SIPX_LINE_EVENT_TYPE_MINOR eMinor);

/* ============================ FUNCTIONS ================================= */

static const char* convertEventCategoryToString(SIPX_EVENT_CATEGORY category)
{
    const char* str = "Unknown" ;

    switch (category)
    {
        case EVENT_CATEGORY_CALLSTATE:
            str = "EVENT_CATEGORY_CALLSTATE" ;
            break ;
        case EVENT_CATEGORY_LINESTATE:
            str = "EVENT_CATEGORY_LINESTATE" ;
            break ;
        case EVENT_CATEGORY_INFO_STATUS:
            str = "EVENT_CATEGORY_INFO_STATUS" ;
            break ;
        case EVENT_CATEGORY_INFO:
            str = "EVENT_CATEGORY_INFO" ;
            break ;
        case EVENT_CATEGORY_SUB_STATUS:
            str = "EVENT_CATEGORY_SUB_STATUS" ;
            break ;
        case EVENT_CATEGORY_NOTIFY:
            str = "EVENT_CATEGORY_NOTIFY" ;
            break ;
        case EVENT_CATEGORY_CONFIG:
            str = "EVENT_CATEGORY_CONFIG" ;
            break ;
    }

    return str ;
}

static const char* MajorEventToString(SIPX_CALLSTATE_MAJOR eMajor)
{
    const char* str = "Unknown" ;
    switch (eMajor)
    {
        case CALLSTATE_UNKNOWN:
            str = "UNKNOWN" ;
            break ;
        case NEWCALL:
                str = "NEWCALL" ;
                break ;
        case DIALTONE:
                str = "DIALTONE" ;
                break ;
        case REMOTE_OFFERING:
                str = "REMOTE_OFFERING" ;
                break ;
        case REMOTE_ALERTING:
                str = "REMOTE_ALERTING" ;
                break ;
        case CONNECTED:
                str = "CONNECTED" ;
                break ;
        case DISCONNECTED:
                str = "DISCONNECTED" ;
                break ;
        case OFFERING:
                str = "OFFERING" ;
                break ;
        case ALERTING:
                str = "ALERTING" ;
                break ;
        case DESTROYED:
                str = "DESTROYED" ;
                break;
        case AUDIO_EVENT:
                str = "AUDIO_EVENT" ;
                break ;
        case TRANSFER:
                str = "TRANSFER" ;
                break ;
        case SECURITY_EVENT:
                str = "SECURITY_EVENT";
                break;
        case IDENTITY_CHANGE:
                str = "IDENTITY_CHANGE";
                break;
    }
   return str;
}

static const char* MinorEventToString(SIPX_CALLSTATE_MINOR eMinor)
{
    const char* str = "Unknown" ;
    switch (eMinor)
    {
        case NEW_CALL_NORMAL:
                str = "NEW_CALL_NORMAL" ;
                break ;
        case NEW_CALL_TRANSFERRED:
                str = "NEW_CALL_TRANSFERRED" ;
                break ;
        case NEW_CALL_TRANSFER:
                str = "NEW_CALL_TRANSFER" ;
                break ;
        case DIALTONE_UNKNOWN:
                str = "DIALTONE_UNKNOWN" ;
                break ;
        case DIALTONE_CONFERENCE:
                str = "DIALTONE_CONFERENCE" ;
                break ;
        case REMOTE_OFFERING_NORMAL:
                str = "REMOTE_OFFERING_NORMAL" ;
                break ;
        case REMOTE_ALERTING_NORMAL:
                str = "REMOTE_ALERTING_NORMAL" ;
                break ;
        case REMOTE_ALERTING_MEDIA:
                str = "REMOTE_ALERTING_MEDIA" ;
                break ;
        case CONNECTED_ACTIVE:
                str = "CONNECTED_ACTIVE" ;
                break ;
        case CONNECTED_ACTIVE_HELD:
                str = "CONNECTED_ACTIVE_HELD" ;
                break ;
        case CONNECTED_INACTIVE:
                str = "CONNECTED_INACTIVE" ;
                break ;
        case DISCONNECTED_BADADDRESS:
                str = "DISCONNECTED_BADADDRESS" ;
                break ;
        case DISCONNECTED_BUSY:
                str = "DISCONNECTED_BUSY" ;
                break ;
        case DISCONNECTED_NORMAL:
                str = "DISCONNECTED_NORMAL" ;
                break ;
        case DISCONNECTED_RESOURCES:
                str = "DISCONNECTED_RESOURCES" ;
                break ;
        case DISCONNECTED_NETWORK:
                str = "DISCONNECTED_NETWORK" ;
                break ;
        case DISCONNECTED_REDIRECTED:
                str = "DISCONNECTED_REDIRECTED" ;
                break ;
        case DISCONNECTED_NO_RESPONSE:
                str = "DISCONNECTED_NO_RESPONSE" ;
                break ;
        case DISCONNECTED_AUTH:
                str = "DISCONNECTED_AUTH" ;
                break ;
        case DISCONNECTED_UNKNOWN:
                str = "DISCONNECTED_UNKNOWN" ;
                break ;
        case OFFERING_ACTIVE:
                str = "OFFERING_ACTIVE" ;
                break ;
        case ALERTING_NORMAL:
                str = "ALERTING_NORMAL" ;
                break ;
        case DESTROYED_NORMAL:
                str = "DESTROYED_NORMAL" ;
                break ;
        case AUDIO_START:
                str = "AUDIO_START";
                break;
        case AUDIO_STOP:
                str = "AUDIO_STOP";
                break;
        case TRANSFER_INITIATED:
                str = "TRANSFER_INITIATED";
                break;
        case TRANSFER_ACCEPTED:
                str = "TRANSFER_ACCEPTED";
                break;
        case TRANSFER_TRYING:
                str = "TRANSFER_TRYING";
                break;
        case TRANSFER_RINGING:
                str = "TRANSFER_RINGING";
                break;
        case TRANSFER_SUCCESS:
                str = "TRANSFER_SUCCESS";
                break;
        case TRANSFER_FAILURE:
                str = "TRANSFER_FAILURE";
                break;
        case SECURITY_SELF_SIGNED_CERT:
                str = "SECURITY_SELF_SIGNED_CERT";
                break;
        case SECURITY_SESSION_NOT_SECURED:
                str = "SECURITY_SESSION_NOT_SECURED";
                break;
        case SECURITY_REMOTE_SMIME_UNSUPPORTED:
                str = "SECURITY_REMOTE_SMIME_UNSUPPORTED";
                break;
        case IDENTITY_CHANGE_UNKNOWN:
                str = "IDENTITY_CHANGE_UNKNOWN";
                break;
    }
    return str;
}


static const char* convertInfoStatusEventToString(SIPX_INFOSTATUS_EVENT event)
{
    const char* str = "Unknown" ;

    switch (event)
    {
        case INFOSTATUS_UNKNOWN:
            str = "INFOSTATUS_UNKNOWN" ;
            break ;
        case INFOSTATUS_RESPONSE:
            str = "INFOSTATUS_RESPONSE" ;
            break ;
        case INFOSTATUS_NETWORK_ERROR:
            str = "INFOSTATUS_NETWORK_ERROR" ;
            break;
    }

    return str ;
}

static const char* convertMessageStatusToString(SIPX_MESSAGE_STATUS status)
{
    const char* str = "Unknown" ;

    switch (status)
    {
        case SIPX_MESSAGE_OK:
            str = "SIPX_MESSAGE_OK" ;
            break ;
        case SIPX_MESSAGE_FAILURE:
            str = "SIPX_MESSAGE_FAILURE" ;
            break ;
        case SIPX_MESSAGE_SERVER_FAILURE:
            str = "SIPX_MESSAGE_SERVER_FAILURE" ;
            break ;
        case SIPX_MESSAGE_GLOBAL_FAILURE:
            str = "SIPX_MESSAGE_GLOBAL_FAILURE" ;
            break ;
    }

    return str ;
}


static const char* convertConfigEventToString(SIPX_CONFIG_EVENT event)
{
    const char* str = "Unknown" ;

    switch (event)
    {
        case CONFIG_UNKNOWN:
            str = "CONFIG_UNKNOWN" ;
            break ;
        case CONFIG_STUN_SUCCESS:
            str = "CONFIG_STUN_SUCCESS" ;
            break ;
        case CONFIG_STUN_FAILURE:
            str = "CONFIG_STUN_FAILURE" ;
            break ;
    }
 
    return str ;
}

const char* convertSubscriptionStateToString(SIPX_SUBSCRIPTION_STATE state)
{
    const char* str = "Unknown" ;

    switch (state)
    {
        case SIPX_SUBSCRIPTION_PENDING:
            str = "SIPX_SUBSCRIPTION_PENDING" ;
            break ;
        case SIPX_SUBSCRIPTION_ACTIVE:
            str = "SIPX_SUBSCRIPTION_ACTIVE" ;
            break ;
        case SIPX_SUBSCRIPTION_FAILED:
            str = "SIPX_SUBSCRIPTION_FAILED" ;
            break ;
        case SIPX_SUBSCRIPTION_EXPIRED:
            str = "SIPX_SUBSCRIPTION_EXPIRED" ;
            break ;
    }

    return str ;
}

const char* convertSubscriptionCauseToString(SIPX_SUBSCRIPTION_CAUSE cause)
{
    const char* str = "Unknown" ;

    switch (cause)
    {
        case SUBSCRIPTION_CAUSE_UNKNOWN:
            str = "SUBSCRIPTION_CAUSE_UNKNOWN" ;
            break ;
        case SUBSCRIPTION_CAUSE_NORMAL:
            str = "SUBSCRIPTION_CAUSE_NORMAL" ;
            break ;
    }