able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/net/tapi/skywalker/h323/tsp/call.cpp

11829 lines
311 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1999 Microsoft Corporation
Module Name:
call.cpp
Abstract:
TAPI Service Provider functions related to manipulating calls.
TSPI_lineAnswer
TSPI_lineCloseCall
TSPI_lineDrop
TSPI_lineGetCallAddressID
TSPI_lineGetCallInfo
TSPI_lineGetCallStatus
TSPI_lineMakeCall
TSPI_lineMonitorDigits
TSPI_lineSendUserUserInfo
TSPI_lineReleaseUserUserInfo
Author:
Nikhil Bobde (NikhilB)
Revision History:
--*/
//
// Include files
//
#include "globals.h"
#include "line.h"
#include "q931pdu.h"
#include "q931obj.h"
#include "ras.h"
#include "config.h"
#define SETUP_SENT_TIMEOUT 8000
#define H450_ENCODED_ARG_LEN 0x4000
#define MAX_DIVERSION_COUNTER 14
static LONG g_H323CallID;
static LONG g_lNumberOfcalls;
LONG g_lCallReference;
//
// Public functions
//
//
//The function that handles a network event(CONNECT|CLOSE) on any of the
//Q931 calls. This function needs to find out the exact event
// that took place and the socket on which it took place
//
void NTAPI Q931TransportEventHandler (
IN PVOID Parameter,
IN BOOLEAN TimerFired)
{
PH323_CALL pCall;
H323DBG(( DEBUG_LEVEL_TRACE, "Q931 transport event recvd." ));
pCall = g_pH323Line -> FindH323CallAndLock ((HDRVCALL) Parameter);
if( pCall != NULL )
{
pCall -> HandleTransportEvent();
pCall -> Unlock();
}
}
//
// returns S_OK if socket was consumed
// returns E_FAIL if socket should be destroyed by caller
//
static HRESULT CallCreateIncomingCall (
IN SOCKET Socket,
IN SOCKADDR_IN * LocalAddress,
IN SOCKADDR_IN * RemoteAddress)
{
PH323_CALL pCall;
HANDLE SelectEvent;
HANDLE SelectWaitHandle;
BOOL fSuccess = TRUE;
BOOL DeleteCall = FALSE;
TCHAR ptstrEventName[100];
BOOL retVal;
pCall = new CH323Call;
if( pCall == NULL )
{
H323DBG(( DEBUG_LEVEL_ERROR,
"failed to allocate memory for CH323Call." ));
return E_OUTOFMEMORY;
}
_stprintf( ptstrEventName, _T("%s-%p"),
_T( "H323TSP_Incoming_TransportHandlerEvent" ), pCall );
// create the wait event
SelectEvent = H323CreateEvent (NULL, FALSE,
FALSE, ptstrEventName );
if( SelectEvent == NULL )
{
H323DBG(( DEBUG_LEVEL_ERROR, "CALL: failed to create select event." ));
delete pCall;
return GetLastResult();
}
retVal = pCall -> Initialize( NULL,
LINECALLORIGIN_INBOUND,
CALLTYPE_NORMAL );
if( retVal == FALSE )
{
H323DBG ((DEBUG_LEVEL_ERROR, "failed to initialize CH323Call."));
CloseHandle (SelectEvent);
delete pCall;
return E_FAIL;
}
//add it to the call context array
if (!pCall -> InitializeQ931 (Socket))
{
H323DBG(( DEBUG_LEVEL_ERROR,
"Failed to initialize incoming call Q.931 state." ));
DeleteCall = FALSE;
pCall -> Shutdown (&DeleteCall);
delete pCall;
if (SelectEvent)
{
CloseHandle (SelectEvent);
}
return E_FAIL;
}
pCall -> SetQ931CallState (Q931_CALL_CONNECTED);
pCall -> Lock();
if (!RegisterWaitForSingleObject(
&SelectWaitHandle, // pointer to the returned handle.
SelectEvent, // the event handle to wait for.
Q931TransportEventHandler, // the callback function.
(PVOID)pCall -> GetCallHandle(),// the context for the callback.
INFINITE, // wait forever.
WT_EXECUTEDEFAULT)) // use the wait thread to call the callback.
{
goto cleanup;
}
_ASSERTE( SelectWaitHandle );
if( SelectWaitHandle == NULL )
{
goto cleanup;
}
//store this in the call context
pCall -> SetNewCallInfo (SelectWaitHandle, SelectEvent,
Q931_CALL_CONNECTED);
SelectEvent = NULL;
pCall -> InitializeRecvBuf();
//post a buffer to winsock to accept messages from the peer
if(!pCall -> PostReadBuffer())
{
H323DBG(( DEBUG_LEVEL_ERROR, "failed to post read buffer on call." ));
goto cleanup;
}
pCall -> Unlock();
H323DBG(( DEBUG_LEVEL_TRACE, "successfully created incoming Q.931 call." ));
//success
return S_OK;
cleanup:
if (pCall)
{
pCall -> Unlock();
pCall -> Shutdown (&DeleteCall);
delete pCall;
}
if (SelectEvent)
{
CloseHandle (SelectEvent);
}
return E_OUTOFMEMORY;
}
void CallProcessIncomingCall (
IN SOCKET Socket,
IN SOCKADDR_IN * LocalAddress,
IN SOCKADDR_IN * RemoteAddress)
{
HRESULT hr;
hr = CallCreateIncomingCall (Socket, LocalAddress, RemoteAddress);
if (hr != S_OK)
{
closesocket (Socket);
}
}
#if DBG
DWORD
ProcessTAPICallRequest(
IN PVOID ContextParameter
)
{
__try
{
return ProcessTAPICallRequestFre( ContextParameter );
}
__except( 1 )
{
TAPI_CALLREQUEST_DATA* pRequestData =
(TAPI_CALLREQUEST_DATA*)ContextParameter;
H323DBG(( DEBUG_LEVEL_TRACE, "TSPI %s event threw exception: %p, %p.",
EventIDToString(pRequestData -> EventID),
pRequestData -> pCall,
pRequestData -> pCallforwardParams ));
_ASSERTE( FALSE );
return 0;
}
}
#endif
DWORD
ProcessTAPICallRequestFre(
IN PVOID ContextParameter)
{
_ASSERTE( ContextParameter );
TAPI_CALLREQUEST_DATA* pCallRequestData = (TAPI_CALLREQUEST_DATA*)ContextParameter;
PH323_CALL pCall = pCallRequestData->pCall;
BOOL fDelete = FALSE;
H323DBG(( DEBUG_LEVEL_TRACE, "TSPI %s event recvd.",
EventIDToString(pCallRequestData -> EventID) ));
pCall -> Lock();
if( pCallRequestData -> EventID == TSPI_DELETE_CALL )
{
pCall -> Unlock();
delete pCallRequestData;
delete pCall;
return EXIT_SUCCESS;
}
if( pCall -> IsCallShutdown() == FALSE )
{
switch( pCallRequestData -> EventID )
{
case TSPI_MAKE_CALL:
pCall -> MakeCall();
break;
case TSPI_ANSWER_CALL:
pCall -> AcceptCall();
break;
case TSPI_DROP_CALL:
pCall -> DropUserInitiated( 0 );
//pCall -> DropCall(0);
break;
case TSPI_RELEASE_U2U:
pCall -> ReleaseU2U();
break;
case TSPI_CALL_HOLD:
pCall -> Hold();
break;
case TSPI_CALL_UNHOLD:
pCall -> UnHold();
break;
case TSPI_CALL_DIVERT:
pCall -> CallDivertOnNoAnswer();
break;
case TSPI_LINEFORWARD_NOSPECIFIC:
case TSPI_LINEFORWARD_SPECIFIC:
pCall -> Forward( pCallRequestData -> EventID,
pCallRequestData -> pCallforwardParams );
break;
case TSPI_SEND_U2U:
pCall -> SendU2U( pCallRequestData -> pBuf->pbBuffer,
pCallRequestData->pBuf->dwLength );
delete pCallRequestData -> pBuf;
break;
default:
_ASSERTE(0);
break;
}
}
pCall -> DecrementIoRefCount( &fDelete );
pCall -> Unlock();
delete pCallRequestData;
if( fDelete == TRUE )
{
H323DBG((DEBUG_LEVEL_TRACE, "call delete:%p.", pCall ));
delete pCall;
}
return EXIT_SUCCESS;
}
//
// CH323Call Methods
//
CH323Call::CH323Call(void)
{
ZeroMemory( (PVOID)this, sizeof(CH323Call) );
/*m_dwFlags = 0;
m_pwszDisplay = NULL;
m_fMonitoringDigits = FALSE;
m_hdCall = NULL;
m_htCall = NULL;
m_dwCallState = NULL;
m_dwOrigin = NULL;
m_dwAddressType = NULL;
m_dwIncomingModes = NULL;
m_dwOutgoingModes = NULL;
m_dwRequestedModes = NULL; // requested media modes
m_hdMSPLine = NULL;
m_htMSPLine = NULL;
//m_fGateKeeperPresent = FALSE;
m_fReadyToAnswer = FALSE;
m_fCallAccepted = FALSE;
// reset addresses
memset((PVOID)&m_CalleeAddr,0,sizeof(H323_ADDR));
memset((PVOID)&m_CallerAddr,0,sizeof(H323_ADDR));
// reset addresses
m_pCalleeAliasNames = NULL;
m_pCallerAliasNames = NULL;
//reset non standard data
memset( (PVOID)&m_NonStandardData, 0, sizeof(H323NonStandardData ) );
//reset the conference ID
ZeroMemory (&m_ConferenceID, sizeof m_ConferenceID);
pFastStart = NULL;
//redet the peer information
memset( (PVOID)&m_peerH245Addr, 0, sizeof(H323_ADDR) );
memset( (PVOID)&m_selfH245Addr, 0, sizeof(H323_ADDR) );
memset( (PVOID)&m_peerNonStandardData, 0, sizeof(H323NonStandardData ) );
memset( (PVOID)&m_peerVendorInfo, 0, sizeof(H323_VENDORINFO) );
memset( (PVOID)&m_peerEndPointType, 0, sizeof(H323_ENDPOINTTYPE) );
m_pPeerFastStart = NULL;
m_pPeerExtraAliasNames = NULL;
m_pPeerDisplay = NULL;
m_hCallEstablishmentTimer = NULL;
m_hCallDivertOnNATimer = NULL;
//Q931call data
m_hTransport = NULL;
m_hTransportWait = NULL;
pRecvBuf = NULL;
m_hSetupSentTimer = NULL;
m_dwStateMachine = 0;
m_dwQ931Flags = 0;
//
fActiveMC = FALSE;
memset( (PVOID)&m_ASNCoderInfo, 0, sizeof(m_ASNCoderInfo));
m_wCallReference = NULL;
m_wQ931CallRef = NULL;
m_IoRefCount = 0;
//RAS call data
wARQSeqNum = 0;
m_wDRQSeqNum = 0;
m_pARQExpireContext = NULL;
m_pDRQExpireContext= NULL;
m_hARQTimer = NULL;
m_hDRQTimer = NULL;
m_dwDRQRetryCount = 0;
m_dwARQRetryCount = 0;
m_fCallInTrnasition = FALSE
m_dwAppSpecific = 0;*/
m_dwFastStart = FAST_START_UNDECIDED;
m_callSocket = INVALID_SOCKET;
m_bStartOfPDU = TRUE;
H323DBG(( DEBUG_LEVEL_TRACE,
"Initialize:m_IoRefCount:%d:%p.", m_IoRefCount, this ));
m_dwRASCallState = RASCALL_STATE_IDLE;
if( InterlockedIncrement( &g_lNumberOfcalls ) == 1 )
{
H323DBG(( DEBUG_LEVEL_TRACE,
"pCall no goes from 0 to 1:g_hCanUnloadDll set.", this ));
ResetEvent( g_hCanUnloadDll );
}
H323DBG(( DEBUG_LEVEL_TRACE, "New pCall object created:%p.", this ));
}
CH323Call::~CH323Call()
{
CALL_SEND_CONTEXT* pSendBuf;
PLIST_ENTRY pLE;
H323DBG(( DEBUG_LEVEL_ERROR, "pCall object deleted:%p.", this ));
if( m_dwFlags & CALLOBJECT_INITIALIZED )
{
while( IsListEmpty( &m_sendBufList ) == FALSE )
{
pLE = RemoveHeadList( &m_sendBufList );
pSendBuf = CONTAINING_RECORD( pLE, CALL_SEND_CONTEXT, ListEntry);
delete pSendBuf->WSABuf.buf;
delete pSendBuf;
}
if( m_hTransportWait != NULL )
{
if( UnregisterWaitEx( m_hTransportWait, NULL ) == FALSE )
{
GetLastError();
}
m_hTransportWait = NULL;
}
if( m_hTransport != NULL )
{
if(!CloseHandle(m_hTransport))
{
WSAGetLastError();
}
m_hTransport = NULL;
}
if( m_callSocket != INVALID_SOCKET )
{
closesocket( m_callSocket );
m_callSocket = INVALID_SOCKET;
}
TermASNCoder();
DeleteCriticalSection( &m_CriticalSection );
}
if( InterlockedDecrement( &g_lNumberOfcalls ) == 0 )
{
H323DBG(( DEBUG_LEVEL_ERROR, "Unload dll event set.%p.", this ));
SetEvent( g_hCanUnloadDll );
}
}
//!!no need to lock
BOOL
CH323Call::Initialize(
IN HTAPICALL htCall,
IN DWORD dwOrigin,
IN DWORD dwCallType
)
{
int index;
int rc;
H323DBG(( DEBUG_LEVEL_ERROR, "call init entered:%p.",this ));
m_pCallerAliasNames = new H323_ALIASNAMES;
if( m_pCallerAliasNames == NULL )
{
H323DBG(( DEBUG_LEVEL_ERROR, "could not allocate caller name." ));
return FALSE;
}
memset( (PVOID)m_pCallerAliasNames, 0, sizeof(H323_ALIASNAMES) );
//H323DBG(( DEBUG_LEVEL_ERROR, "Caller alias count:%d : %p", m_pCallerAliasNames->wCount, this ));
m_pCalleeAliasNames = new H323_ALIASNAMES;
if( m_pCalleeAliasNames == NULL )
{
H323DBG(( DEBUG_LEVEL_ERROR, "could not allocate callee name." ));
goto error1;
}
memset( (PVOID)m_pCalleeAliasNames, 0, sizeof(H323_ALIASNAMES) );
__try
{
if( !InitializeCriticalSectionAndSpinCount( &m_CriticalSection,
0x80000000 ) )
{
H323DBG(( DEBUG_LEVEL_ERROR, "couldn't alloc critsec for call." ));
goto error2;
}
}
__except( 1 )
{
goto error2;
}
if( dwOrigin == LINECALLORIGIN_OUTBOUND )
{
int iresult = UuidCreate( &m_callIdentifier );
if( (iresult != RPC_S_OK) && (iresult !=RPC_S_UUID_LOCAL_ONLY) )
{
goto error3;
}
}
rc = InitASNCoder();
if( rc != ASN1_SUCCESS )
{
H323DBG((DEBUG_LEVEL_ERROR, "Q931_InitCoder() returned: %d ", rc));
goto error3;
}
rc = InitH450ASNCoder();
if( rc != ASN1_SUCCESS )
{
H323DBG((DEBUG_LEVEL_ERROR, "Q931_InitCoder() returned: %d ", rc));
goto error4;
}
//Create the CRV for this call.
do
{
m_wCallReference = ((WORD)InterlockedIncrement( &g_lCallReference ))
& 0x7fff;
} while( (m_wCallReference == 0) ||
g_pH323Line->CallReferenceDuped( m_wCallReference ) );
//add the call to the call table
index = g_pH323Line -> AddCallToTable((PH323_CALL)this);
if( index == -1 )
{
H323DBG(( DEBUG_LEVEL_ERROR,
"could not add call to call table." ));
goto error5;
}
//By incrementing the g_H323CallID and taking lower 16 bits we get 65536
//unique values and then same values are repeated. Thus we can have only
//65535 simultaneous calls. By using the call table index we make sure that
//no two existing calls have same call handle.
do
{
m_hdCall = (HDRVCALL)( ((BYTE*)NULL) +
MAKELONG( LOWORD((DWORD)index),
(WORD)InterlockedIncrement(&g_H323CallID) ));
} while ( m_hdCall == NULL );
ZeroMemory( (PVOID)&m_prepareToAnswerMsgData, sizeof(BUFFERDESCR) );
m_dwFlags |= CALLOBJECT_INITIALIZED;
m_htCall = htCall;
m_dwCallState = LINECALLSTATE_IDLE;
m_dwOrigin = dwOrigin;
m_hdConf = NULL;
m_wQ931CallRef = m_wCallReference;
m_dwCallType = dwCallType;
// initialize user user information
InitializeListHead( &m_IncomingU2U );
InitializeListHead( &m_OutgoingU2U );
InitializeListHead( &m_sendBufList );
H323DBG(( DEBUG_LEVEL_TRACE,
"m_hdCall:%lx m_htCall:%lx m_wCallReference:%lx : %p .",
m_hdCall, m_htCall, m_wCallReference, this ));
H323DBG(( DEBUG_LEVEL_TRACE, "call init exited:%p.",this ));
return TRUE;
error5:
TermH450ASNCoder();
error4:
TermASNCoder();
error3:
DeleteCriticalSection( &m_CriticalSection );
error2:
delete m_pCalleeAliasNames;
m_pCalleeAliasNames = NULL;
error1:
delete m_pCallerAliasNames;
m_pCallerAliasNames = NULL;
return FALSE;
}
//
//!!must be always called in a lock
//Queues a request made by TAPI to the thread pool
//
BOOL
CH323Call::QueueTAPICallRequest(
IN DWORD EventID,
IN PVOID pBuf
)
{
TAPI_CALLREQUEST_DATA * pCallRequestData = new TAPI_CALLREQUEST_DATA;
BOOL fResult = TRUE;
if( pCallRequestData != NULL )
{
pCallRequestData -> EventID = EventID;
pCallRequestData -> pCall = this;
pCallRequestData -> pBuf = (PBUFFERDESCR)pBuf;
if( !QueueUserWorkItem( ProcessTAPICallRequest, pCallRequestData,
WT_EXECUTEDEFAULT ) )
{
delete pCallRequestData;
fResult = FALSE;
}
m_IoRefCount++;
H323DBG(( DEBUG_LEVEL_TRACE, "TAPICallRequest:m_IoRefCount:%d:%p.",
m_IoRefCount, this ));
}
else
{
fResult = FALSE;
}
return fResult;
}
//always called in lock
void
CH323Call::CopyCallStatus(
IN LPLINECALLSTATUS pCallStatus
)
{
H323DBG(( DEBUG_LEVEL_ERROR, "CopyCallStatus entered:%p.",this ));
// transer call state information
pCallStatus->dwCallState = m_dwCallState;
pCallStatus->dwCallStateMode = m_dwCallStateMode;
// determine call feature based on state
pCallStatus->dwCallFeatures = ( m_dwCallState != LINECALLSTATE_IDLE)?
(H323_CALL_FEATURES) : 0;
H323DBG(( DEBUG_LEVEL_ERROR, "CopyCallStatus exited:%p.",this ));
}
//always called in lock
LONG
CH323Call::CopyCallInfo(
IN LPLINECALLINFO pCallInfo
)
{
DWORD dwCalleeNameSize = 0;
DWORD dwCallerNameSize = 0;
DWORD dwCallerAddressSize = 0;
WCHAR wszIPAddress[20];
DWORD dwNextOffset = sizeof(LINECALLINFO);
DWORD dwU2USize = 0;
PBYTE pU2U = NULL;
LONG retVal = NOERROR;
DWORD dwDivertingNameSize = 0;
DWORD dwDiversionNameSize = 0;
DWORD dwDivertedToNameSize = 0;
DWORD dwCallDataSize = 0;
H323DBG(( DEBUG_LEVEL_ERROR, "CopyCallInfo entered:%p.",this ));
// see if user user info available
if( IsListEmpty( &m_IncomingU2U) == FALSE )
{
PLIST_ENTRY pLE;
PUserToUserLE pU2ULE;
// get first list entry
pLE = m_IncomingU2U.Flink;
// convert to user user structure
pU2ULE = CONTAINING_RECORD(pLE, UserToUserLE, Link);
// transfer info
dwU2USize = pU2ULE->dwU2USize;
pU2U = pU2ULE->pU2U;
}
// initialize caller and callee id flags now
pCallInfo->dwCalledIDFlags = LINECALLPARTYID_UNAVAIL;
pCallInfo->dwCallerIDFlags = LINECALLPARTYID_UNAVAIL;
pCallInfo->dwRedirectingIDFlags = LINECALLPARTYID_UNAVAIL;
pCallInfo->dwRedirectionIDFlags = LINECALLPARTYID_UNAVAIL;
// calculate memory necessary for strings
if( m_pCalleeAliasNames && m_pCalleeAliasNames -> wCount !=0 )
{
dwCalleeNameSize =
H323SizeOfWSZ( m_pCalleeAliasNames -> pItems[0].pData );
}
if( m_pCallerAliasNames && (m_pCallerAliasNames->wCount) )
{
//H323DBG(( DEBUG_LEVEL_ERROR, "Caller alias count:%d : %p", m_pCallerAliasNames->wCount, this ));
dwCallerNameSize =
sizeof(WCHAR) * (m_pCallerAliasNames->pItems[0].wDataLength + 1);
}
if( m_CallerAddr.Addr.IP_Binary.dwAddr != 0 )
{
wsprintfW(wszIPAddress, L"%d.%d.%d.%d",
(m_CallerAddr.Addr.IP_Binary.dwAddr >> 24) & 0xff,
(m_CallerAddr.Addr.IP_Binary.dwAddr >> 16) & 0xff,
(m_CallerAddr.Addr.IP_Binary.dwAddr >> 8) & 0xff,
(m_CallerAddr.Addr.IP_Binary.dwAddr) & 0xff
);
dwCallerAddressSize = (wcslen(wszIPAddress) + 1) * sizeof(WCHAR);
}
if( m_dwCallType & CALLTYPE_DIVERTEDDEST )
{
if( m_pCallReroutingInfo->divertingNrAlias &&
(m_pCallReroutingInfo->divertingNrAlias->wCount !=0) )
{
dwDivertingNameSize = H323SizeOfWSZ(
m_pCallReroutingInfo->divertingNrAlias-> pItems[0].pData );
}
if( m_pCallReroutingInfo->divertedToNrAlias &&
(m_pCallReroutingInfo->divertedToNrAlias->wCount != 0) )
{
dwDivertedToNameSize = sizeof(WCHAR) *
m_pCallReroutingInfo->divertedToNrAlias->pItems[0].wDataLength;
}
}
if( m_dwCallType & CALLTYPE_DIVERTEDSRC_NOROUTING )
{
if( m_pCallReroutingInfo->divertedToNrAlias &&
(m_pCallReroutingInfo->divertedToNrAlias->wCount != 0) )
{
dwDivertedToNameSize = sizeof(WCHAR) *
m_pCallReroutingInfo->divertedToNrAlias->pItems[0].wDataLength;
}
}
if( m_dwCallType & CALLTYPE_DIVERTEDSRC)
{
if( m_pCallReroutingInfo->divertedToNrAlias &&
(m_pCallReroutingInfo->divertedToNrAlias->wCount != 0) )
{
dwDivertedToNameSize = sizeof(WCHAR) *
m_pCallReroutingInfo->divertedToNrAlias->pItems[0].wDataLength;
}
if( m_pCallReroutingInfo->divertingNrAlias &&
(m_pCallReroutingInfo->divertingNrAlias->wCount !=0) )
{
dwDivertingNameSize = H323SizeOfWSZ(
m_pCallReroutingInfo->divertingNrAlias-> pItems[0].pData );
}
}
if( m_CallData.wOctetStringLength != 0 )
{
dwCallDataSize = m_CallData.wOctetStringLength;
}
// determine number of bytes needed
pCallInfo->dwNeededSize = sizeof(LINECALLINFO) +
dwCalleeNameSize +
dwCallerNameSize +
dwCallerAddressSize +
dwDivertingNameSize +
dwDiversionNameSize +
dwDivertedToNameSize +
dwU2USize +
dwCallDataSize
;
// see if structure size is large enough
if (pCallInfo->dwTotalSize >= pCallInfo->dwNeededSize)
{
// record number of bytes used
pCallInfo->dwUsedSize = pCallInfo->dwNeededSize;
// validate string size
if (dwCalleeNameSize > 0)
{
if( m_pCalleeAliasNames -> pItems[0].wType == e164_chosen )
{
// callee number was specified
pCallInfo->dwCalledIDFlags = LINECALLPARTYID_ADDRESS;
// determine size and offset for callee number
pCallInfo->dwCalledIDSize = dwCalleeNameSize;
pCallInfo->dwCalledIDOffset = dwNextOffset;
// copy call info after fixed portion
CopyMemory(
(PVOID)((LPBYTE)pCallInfo + pCallInfo->dwCalledIDOffset),
(LPBYTE)m_pCalleeAliasNames -> pItems[0].pData,
pCallInfo->dwCalledIDSize );
}
else
{
// callee name was specified
pCallInfo->dwCalledIDFlags = LINECALLPARTYID_NAME;
// determine size and offset for callee name
pCallInfo->dwCalledIDNameSize = dwCalleeNameSize;
pCallInfo->dwCalledIDNameOffset = dwNextOffset;
// copy call info after fixed portion
CopyMemory(
(PVOID)((LPBYTE)pCallInfo + pCallInfo->dwCalledIDNameOffset),
(LPBYTE)m_pCalleeAliasNames -> pItems[0].pData,
pCallInfo->dwCalledIDNameSize );
}
// adjust offset to include string
dwNextOffset += dwCalleeNameSize;
H323DBG(( DEBUG_LEVEL_TRACE,
"callee name: %S.", m_pCalleeAliasNames -> pItems[0].pData ));
}
// validate string size
if (dwCallerNameSize > 0)
{
// caller name was specified
pCallInfo->dwCallerIDFlags = LINECALLPARTYID_NAME;
// determine size and offset for caller name
pCallInfo->dwCallerIDNameSize = dwCallerNameSize;
pCallInfo->dwCallerIDNameOffset = dwNextOffset;
// copy call info after fixed portion
CopyMemory(
(PVOID)((LPBYTE)pCallInfo + pCallInfo->dwCallerIDNameOffset),
(LPBYTE)m_pCallerAliasNames -> pItems[0].pData,
pCallInfo->dwCallerIDNameSize );
//H323DBG(( DEBUG_LEVEL_ERROR, "Caller alias count:%d : %p", m_pCallerAliasNames->wCount, this ));
// adjust offset to include string
dwNextOffset += dwCallerNameSize;
H323DBG(( DEBUG_LEVEL_TRACE,
"caller name: %S.", m_pCallerAliasNames -> pItems[0].pData ));
}
if( dwCallerAddressSize > 0 )
{
// caller number was specified
pCallInfo->dwCallerIDFlags |= LINECALLPARTYID_ADDRESS;
// determine size and offset for caller number
pCallInfo->dwCallerIDSize = dwCallerAddressSize;
pCallInfo->dwCallerIDOffset = dwNextOffset;
// copy call info after fixed portion
CopyMemory(
(PVOID)((LPBYTE)pCallInfo + pCallInfo->dwCallerIDOffset),
(LPBYTE)wszIPAddress,
pCallInfo->dwCallerIDSize );
// adjust offset to include string
dwNextOffset += dwCallerAddressSize;
}
// validate buffer
if (dwU2USize > 0)
{
// determine size and offset of info
pCallInfo->dwUserUserInfoSize = dwU2USize;
pCallInfo->dwUserUserInfoOffset = dwNextOffset;
// copy user user info after fixed portion
CopyMemory(
(PVOID)((LPBYTE)pCallInfo + pCallInfo->dwUserUserInfoOffset),
(LPBYTE)pU2U,
pCallInfo->dwUserUserInfoSize );
// adjust offset to include string
dwNextOffset += pCallInfo->dwUserUserInfoSize;
}
if( dwDivertingNameSize > 0 )
{
// caller name was specified
pCallInfo->dwRedirectingIDFlags = LINECALLPARTYID_NAME;
// determine size and offset for caller name
pCallInfo->dwRedirectingIDNameSize = dwDivertingNameSize;
pCallInfo->dwRedirectingIDNameOffset = dwNextOffset;
// copy call info after fixed portion
CopyMemory(
(PVOID)((LPBYTE)pCallInfo + pCallInfo->dwRedirectingIDNameOffset),
(LPBYTE)(m_pCallReroutingInfo->divertingNrAlias->pItems[0].pData),
pCallInfo->dwRedirectingIDNameSize );
// adjust offset to include string
dwNextOffset += dwDivertingNameSize;
H323DBG(( DEBUG_LEVEL_TRACE, "diverting name: %S.",
m_pCallReroutingInfo->divertingNrAlias->pItems[0].pData ));
}
if( dwDiversionNameSize > 0 )
{
// caller name was specified
pCallInfo->dwRedirectionIDFlags = LINECALLPARTYID_NAME;
// determine size and offset for caller name
pCallInfo->dwRedirectionIDNameSize = dwDiversionNameSize;
pCallInfo->dwRedirectionIDNameOffset = dwNextOffset;
// copy call info after fixed portion
CopyMemory(
(PVOID)((LPBYTE)pCallInfo + pCallInfo->dwRedirectionIDNameOffset),
(LPBYTE)(m_pCallReroutingInfo->diversionNrAlias->pItems[0].pData),
pCallInfo->dwRedirectionIDNameSize );
// adjust offset to include string
dwNextOffset += dwDiversionNameSize;
H323DBG(( DEBUG_LEVEL_TRACE, "redirection name: %S.",
m_pCallReroutingInfo->diversionNrAlias->pItems[0].pData ));
}
if( dwDivertedToNameSize > 0 )
{
pCallInfo->dwRedirectionIDFlags = LINECALLPARTYID_NAME;
// determine size and offset for caller name
pCallInfo->dwRedirectionIDNameSize = dwDivertedToNameSize;
pCallInfo->dwRedirectionIDNameOffset = dwNextOffset;
// copy call info after fixed portion
CopyMemory(
(PVOID)((LPBYTE)pCallInfo + pCallInfo->dwRedirectionIDNameOffset),
(LPBYTE)(m_pCallReroutingInfo->divertedToNrAlias->pItems[0].pData),
pCallInfo->dwRedirectionIDNameSize );
// adjust offset to include string
dwNextOffset += pCallInfo->dwRedirectionIDNameSize;
// adjust offset to include string
dwNextOffset += dwDivertedToNameSize;
H323DBG(( DEBUG_LEVEL_TRACE, "redirection name: %S.",
m_pCallReroutingInfo->divertedToNrAlias->pItems[0].pData ));
}
//pass on the call data
if( dwCallDataSize > 0 )
{
pCallInfo -> dwCallDataSize = dwCallDataSize;
pCallInfo -> dwCallDataOffset = dwNextOffset;
CopyMemory(
(PVOID)((LPBYTE)pCallInfo + pCallInfo -> dwCallDataOffset),
(LPBYTE)m_CallData.pOctetString,
pCallInfo -> dwCallDataSize );
dwNextOffset += dwCallDataSize;
}
}
else if (pCallInfo->dwTotalSize >= sizeof(LINECALLINFO))
{
H323DBG(( DEBUG_LEVEL_WARNING,
"linecallinfo structure too small for strings." ));
// structure only contains fixed portion
pCallInfo->dwUsedSize = sizeof(LINECALLINFO);
}
else
{
H323DBG(( DEBUG_LEVEL_ERROR, "linecallinfo structure too small." ));
// structure is too small
return LINEERR_STRUCTURETOOSMALL;
}
// initialize call line device and address info
pCallInfo->dwLineDeviceID = g_pH323Line->GetDeviceID();
pCallInfo->dwAddressID = 0;
// initialize variable call parameters
pCallInfo->dwOrigin = m_dwOrigin;
pCallInfo->dwMediaMode = m_dwIncomingModes | m_dwOutgoingModes;
if( m_dwCallType & CALLTYPE_DIVERTEDDEST )
{
if(m_pCallReroutingInfo->diversionReason==DiversionReason_cfu)
{
pCallInfo->dwReason = LINECALLREASON_FWDUNCOND;
}
else if(m_pCallReroutingInfo->diversionReason==DiversionReason_cfnr)
{
pCallInfo->dwReason = LINECALLREASON_FWDNOANSWER;
}
else
{
pCallInfo->dwReason = LINECALLREASON_FWDBUSY;
}
}
if( m_dwCallType & CALLTYPE_TRANSFEREDDEST )
{
pCallInfo->dwReason = LINECALLREASON_TRANSFER;
}
else
{
pCallInfo->dwReason = LINECALLREASON_DIRECT;
}
pCallInfo->dwCallStates = (m_dwOrigin==LINECALLORIGIN_INBOUND)
? H323_CALL_INBOUNDSTATES
: H323_CALL_OUTBOUNDSTATES
;
// initialize constant call parameters
pCallInfo->dwBearerMode = H323_LINE_BEARERMODES;
pCallInfo->dwRate = H323_LINE_MAXRATE;
// initialize unsupported call capabilities
pCallInfo->dwConnectedIDFlags = LINECALLPARTYID_UNAVAIL;
//pass on the dwAppSpecific info
pCallInfo -> dwAppSpecific = m_dwAppSpecific;
H323DBG(( DEBUG_LEVEL_ERROR, "CopyCallInfo exited:%p.",this ));
return retVal;
}
//!!always called in lock
BOOL
CH323Call::HandleReadyToInitiate(
IN PTspMspMessage pMessage
)
{
Q931_SETUP_ASN setupASN;
WORD wCount;
DWORD dwAPDUType = 0;
H323DBG(( DEBUG_LEVEL_ERROR, "HandleReadyToInitiate entered:%p.", this ));
//set the additional callee addresses and callee aliases
//see if there is a fast-connect proposal
if( pMessage->dwEncodedASNSize != 0 )
{
if( !ParseSetupASN( pMessage ->pEncodedASNBuf,
pMessage->dwEncodedASNSize,
&setupASN,
&dwAPDUType ))
{
goto cleanup;
}
if( setupASN.fFastStartPresent )
{
_ASSERTE( !m_pFastStart );
m_pFastStart = setupASN.pFastStart;
setupASN.pFastStart = NULL;
m_dwFastStart = FAST_START_SELF_AVAIL;
}
else
{
m_dwFastStart = FAST_START_NOTAVAIL;
}
if( setupASN.pCallerAliasList && !RasIsRegistered() )
{
//_ASSERTE(0);
if( m_pCallerAliasNames == NULL )
{
m_pCallerAliasNames = setupASN.pCallerAliasList;
//dont release this alias list
setupASN.pCallerAliasList = NULL;
}
else
{
wCount = m_pCallerAliasNames->wCount +
setupASN.pCallerAliasList->wCount;
PH323_ALIASITEM tempPtr = setupASN.pCallerAliasList->pItems;
setupASN.pCallerAliasList->pItems = (PH323_ALIASITEM)realloc(
(PVOID)setupASN.pCallerAliasList->pItems,
wCount * sizeof(H323_ALIASITEM) );
if( setupASN.pCallerAliasList->pItems == NULL )
{
//restore the old pointer in case enough memory was not
//available to expand the memory block
setupASN.pCallerAliasList->pItems = tempPtr;
}
else
{
CopyMemory(
(PVOID)&(setupASN.pCallerAliasList->pItems[setupASN.pCallerAliasList->wCount]),
(PVOID)m_pCallerAliasNames->pItems,
m_pCallerAliasNames->wCount * sizeof(H323_ALIASITEM) );
setupASN.pCallerAliasList->wCount = wCount;
delete m_pCallerAliasNames->pItems;
delete m_pCallerAliasNames;
m_pCallerAliasNames = setupASN.pCallerAliasList;
setupASN.pCallerAliasList = NULL;
}
}
}
//add the callee aliases sent by the MSP
if( setupASN.pCalleeAliasList != NULL )
{
//_ASSERTE(0);
if( m_pCalleeAliasNames == NULL )
{
m_pCalleeAliasNames = setupASN.pCalleeAliasList;
//dont release this alias list
setupASN.pCalleeAliasList = NULL;
}
else
{
wCount = m_pCalleeAliasNames->wCount +
setupASN.pCalleeAliasList->wCount;
PH323_ALIASITEM tempPtr = m_pCalleeAliasNames->pItems;
m_pCalleeAliasNames->pItems = (PH323_ALIASITEM)realloc(
(PVOID)m_pCalleeAliasNames->pItems,
wCount * sizeof(H323_ALIASITEM) );
if( m_pCalleeAliasNames->pItems == NULL )
{
//restore the old pointer in case enough memory was not
//available to expand the memory block
m_pCalleeAliasNames->pItems = tempPtr;
goto cleanup;
}
CopyMemory(
(PVOID)&(m_pCalleeAliasNames->pItems[m_pCalleeAliasNames->wCount]),
(PVOID)setupASN.pCalleeAliasList->pItems,
setupASN.pCalleeAliasList->wCount * sizeof(H323_ALIASITEM) );
m_pCalleeAliasNames->wCount = wCount;
delete setupASN.pCalleeAliasList->pItems;
delete setupASN.pCalleeAliasList;
setupASN.pCalleeAliasList = NULL;
}
}
FreeSetupASN( &setupASN );
}
else
{
m_dwFastStart = FAST_START_NOTAVAIL;
}
//send the setup message
if( !SendSetupMessage() )
{
DropCall( 0 );
}
H323DBG(( DEBUG_LEVEL_ERROR, "HandleReadyToInitiate exited:%p.", this ));
return TRUE;
cleanup:
CloseCall( 0 );
FreeSetupASN( &setupASN );
return FALSE;
}
//!!always called in lock
BOOL
CH323Call::HandleProceedWithAnswer(
IN PTspMspMessage pMessage
)
{
Q931_CALL_PROCEEDING_ASN proceedingASN;
DWORD dwAPDUType = 0;
PH323_ALIASITEM pwszDivertedToAlias = NULL;
WCHAR *pwszAliasName = NULL;
WORD wAliasLength = 0;
H323DBG(( DEBUG_LEVEL_TRACE, "HandleProceedWithAnswer entered:%p.", this ));
if( m_dwCallType & CALLTYPE_DIVERTED_SERVED )
{
H323DBG(( DEBUG_LEVEL_TRACE,
"Call already diverted. ignore the message:%p.", this ));
return TRUE;
}
//see if there is a fast-connect proposal
if( pMessage->dwEncodedASNSize != 0 )
{
if( !ParseProceedingASN(pMessage ->pEncodedASNBuf,
pMessage->dwEncodedASNSize,
&proceedingASN,
&dwAPDUType ) )
{
goto cleanup;
}
if( proceedingASN.fH245AddrPresent )
{
m_selfH245Addr = proceedingASN.h245Addr;
}
if( proceedingASN.fFastStartPresent &&
(m_dwFastStart!=FAST_START_NOTAVAIL) )
{
_ASSERTE( m_pFastStart == NULL );
m_pFastStart = proceedingASN.pFastStart;
m_dwFastStart = FAST_START_AVAIL;
//we keep a reference to the fast start list so don't release it
proceedingASN.pFastStart = NULL;
proceedingASN.fFastStartPresent = FALSE;
}
/*else
{
m_dwFastStart = FAST_START_NOTAVAIL;
}*/
FreeProceedingASN( &proceedingASN );
}
/*else
{
m_dwFastStart = FAST_START_NOTAVAIL;
}*/
//send proceeding message to the peer
if(!SendProceeding() )
{
goto cleanup;
}
//send alerting message to the peer
if( !SendQ931Message(NO_INVOKEID, 0, 0, ALERTINGMESSAGETYPE, NO_H450_APDU) )
{
goto cleanup;
}
m_dwStateMachine = Q931_ALERT_SENT;
//for TRANSFEREDDEST call directly accept the call wihtout the user
//answering the call
if( (m_dwCallType & CALLTYPE_TRANSFEREDDEST) && m_hdRelatedCall )
{
AcceptCall();
}
if( m_pCallerAliasNames && (m_pCallerAliasNames -> wCount > 0) )
{
pwszAliasName = m_pCallerAliasNames->pItems[0].pData;
wAliasLength = (m_pCallerAliasNames->pItems[0].wDataLength+1)
* sizeof(WCHAR);
//H323DBG(( DEBUG_LEVEL_ERROR, "Caller alias count:%d : %p", m_pCallerAliasNames->wCount, this ));
}
pwszDivertedToAlias = g_pH323Line->CallToBeDiverted(
pwszAliasName,
wAliasLength,
LINEFORWARDMODE_NOANSW | LINEFORWARDMODE_NOANSWSPECIFIC |
LINEFORWARDMODE_BUSYNA | LINEFORWARDMODE_BUSYNASPECIFIC );
//if call is to be diverted for no answer, start the timer
if( pwszDivertedToAlias != NULL )
{
if( !StartTimerForCallDiversionOnNA( pwszDivertedToAlias ) )
{
goto cleanup;
}
}
H323DBG(( DEBUG_LEVEL_TRACE, "HandleProceedWithAnswer exited:%p.",this ));
return TRUE;
cleanup:
CloseCall( 0 );
return FALSE;
}
//!!always called in lock
BOOL
CH323Call::HandleReadyToAnswer(
IN PTspMspMessage pMessage
)
{
Q931_CALL_PROCEEDING_ASN proceedingASN;
DWORD dwAPDUType = 0;
PH323_CALL pConsultCall = NULL;
H323DBG(( DEBUG_LEVEL_ERROR, "HandleReadyToAnswer entered:%p.",this ));
m_fReadyToAnswer = TRUE;
//see if there is a fast-connect proposal
if( pMessage->dwEncodedASNSize != 0 )
{
if( !ParseProceedingASN(pMessage ->pEncodedASNBuf,
pMessage->dwEncodedASNSize,
&proceedingASN,
&dwAPDUType) )
{
goto cleanup;
}
if( proceedingASN.fH245AddrPresent )
{
m_selfH245Addr = proceedingASN.h245Addr;
}
if( proceedingASN.fFastStartPresent &&
(m_dwFastStart!=FAST_START_NOTAVAIL) )
{
_ASSERTE( m_pFastStart == NULL );
m_pFastStart = proceedingASN.pFastStart;
m_dwFastStart = FAST_START_AVAIL;
//we keep a reference to the fast start list so don't release it
proceedingASN.pFastStart = NULL;
proceedingASN.fFastStartPresent = FALSE;
}
else
{
m_dwFastStart = FAST_START_NOTAVAIL;
}
FreeProceedingASN( &proceedingASN );
}
else
{
m_dwFastStart = FAST_START_NOTAVAIL;
}
if( m_fCallAccepted )
{
// validate status
if( !AcceptH323Call() )
{
H323DBG(( DEBUG_LEVEL_ERROR,
"error answering call 0x%08lx.", this ));
// failure
goto cleanup;
}
//lock the primary call after replacement call to avoid deadlock
if( (m_dwCallType & CALLTYPE_TRANSFEREDDEST) && m_hdRelatedCall )
{
QueueSuppServiceWorkItem( SWAP_REPLACEMENT_CALL,
m_hdCall, (ULONG_PTR)m_hdRelatedCall );
}
else
{
//send MSP start H245
SendMSPStartH245( NULL, NULL );
//tell MSP about connect state
SendMSPMessage( SP_MSG_ConnectComplete, 0, 0, NULL );
}
//change call state to accepted from offering
ChangeCallState( LINECALLSTATE_CONNECTED, 0 );
}
H323DBG(( DEBUG_LEVEL_ERROR, "HandleReadyToAnswer exited:%p.",this ));
return TRUE;
cleanup:
CloseCall( 0 );
return FALSE;
}
//!!This function must be always called in a lock. The calling function should
//not unlock the call object as this function itself unlocks the call object
BOOL
CH323Call::HandleMSPMessage(
IN PTspMspMessage pMessage,
IN HDRVMSPLINE hdMSPLine,
IN HTAPIMSPLINE htMSPLine
)
{
BOOL fResult = TRUE;
PH323_CALL pCall = NULL;
ASN1octetstring_t pH245PDU;
H323DBG(( DEBUG_LEVEL_TRACE, "HandleMSPMessage entered:%p.",this ));
H323DBG(( DEBUG_LEVEL_TRACE, "MSP message:%s recvd.",
H323TSPMessageToString(pMessage->MessageType) ));
switch( pMessage -> MessageType )
{
case SP_MSG_ReadyToInitiate:
// The Q.931 connection should be in the connected state by now
if( pMessage -> MsgBody.ReadyToInitiateMessage.hMSPReplacementCall != NULL )
{
//unlock the primary call before locking the related call
Unlock();
pCall=g_pH323Line -> FindH323CallAndLock(m_hdRelatedCall);
if( pCall == NULL )
{
//transfered call is not around so close the primary call
CloseCall( 0 );
return TRUE;
}
fResult = pCall -> HandleReadyToInitiate( pMessage );
pCall -> Unlock();
}
else
{
m_hdMSPLine = hdMSPLine;
m_htMSPLine = htMSPLine;
fResult = HandleReadyToInitiate( pMessage );
Unlock();
}
break;
case SP_MSG_ProceedWithAnswer:
if( pMessage -> MsgBody.ProceedWithAnswerMessage.hMSPReplacementCall != NULL )
{
//unlock the primary call before locking the related call
Unlock();
pCall=g_pH323Line -> FindH323CallAndLock(m_hdRelatedCall);
if( pCall == NULL )
{
//transfered call is not around so close the primary call
CloseCall( 0 );
return FALSE;
}
fResult = pCall -> HandleProceedWithAnswer( pMessage );
pCall -> Unlock();
}
else
{
m_hdMSPLine = hdMSPLine;
m_htMSPLine = htMSPLine;
fResult = HandleProceedWithAnswer( pMessage );
Unlock();
}
break;
case SP_MSG_ReadyToAnswer:
if( pMessage -> MsgBody.ReadyToAnswerMessage.hMSPReplacementCall != NULL )
{
//unlock the primary call before locking the related call
Unlock();
pCall=g_pH323Line -> FindH323CallAndLock(m_hdRelatedCall);
if( pCall== NULL )
{
//transfered call is not around so close the primary call
CloseCall( 0 );
return FALSE;
}
fResult = pCall -> HandleReadyToAnswer( pMessage );
pCall -> Unlock();
}
else
{
//decode call_proceding message and extract local fast
//start inforamtion and local H245 address
fResult = HandleReadyToAnswer( pMessage );
Unlock();
}
break;
case SP_MSG_ReleaseCall:
//shutdown the H323 call
CloseCall( LINEDISCONNECTMODE_CANCELLED );
Unlock();
break;
case SP_MSG_H245Terminated:
//shutdown the H323 call
CloseCall( LINEDISCONNECTMODE_NORMAL );
Unlock();
break;
case SP_MSG_SendDTMFDigits:
if( m_fMonitoringDigits == TRUE )
{
WCHAR * pwch = pMessage->pWideChars;
H323DBG(( DEBUG_LEVEL_VERBOSE, "dtmf digits recvd:%S.", pwch));
// process each digit
WORD indexI=0;
while( indexI < pMessage->MsgBody.SendDTMFDigitsMessage.wNumDigits )
{
// signal incoming
PostLineEvent(
LINE_MONITORDIGITS,
(DWORD_PTR)*pwch,
LINEDIGITMODE_DTMF,
GetTickCount()
);
++pwch;
indexI++;
}
}
Unlock();
break;
case SP_MSG_LegacyDefaultAlias:
if( pMessage -> MsgBody.LegacyDefaultAliasMessage.wNumChars > 0 )
{
if( !RasIsRegistered() )
{
_ASSERTE( m_pwszDisplay == NULL );
m_pwszDisplay = new WCHAR[
pMessage -> MsgBody.LegacyDefaultAliasMessage.wNumChars ];
if( m_pwszDisplay != NULL )
{
CopyMemory(
(PVOID)m_pwszDisplay,
pMessage->pWideChars,
sizeof(WCHAR) * pMessage -> MsgBody.LegacyDefaultAliasMessage.wNumChars
);
}
}
}
Unlock();
break;
case SP_MSG_H245PDU:
if( (pMessage ->pEncodedASNBuf) && (pMessage->dwEncodedASNSize != 0) )
{
pH245PDU.value = pMessage ->pEncodedASNBuf;
pH245PDU.length = pMessage->dwEncodedASNSize;
fResult = SendQ931Message( NO_INVOKEID, 0, (ULONG_PTR)&pH245PDU,
FACILITYMESSAGETYPE, NO_H450_APDU );
}
Unlock();
break;
case SP_MSG_RASRegistrationEvent:
default:
_ASSERTE(0);
Unlock();
break;
}
H323DBG(( DEBUG_LEVEL_ERROR, "HandleMSPMessage exited:%p.",this ));
return fResult;
}
//!!always called in a lock
void
CH323Call::SendMSPMessage(
IN TspMspMessageType messageType,
IN BYTE* pbEncodedBuf,
IN DWORD dwLength,
IN HDRVCALL hReplacementCall
)
{
TspMspMessageEx messageEx;
HTAPIMSPLINE hMSP = MSP_HANDLE_UNKNOWN;
int iError = 0;
int iLen = sizeof(SOCKADDR_IN);
SOCKADDR_IN* psaLocalQ931Addr = NULL;
H323DBG(( DEBUG_LEVEL_ERROR, "SendMSPMessage:%s entered:%p.",
H323TSPMessageToString(messageType), this ));
messageEx.message.MessageType = messageType;
switch( messageType )
{
case SP_MSG_InitiateCall:
messageEx.message.MsgBody.InitiateCallMessage.hTSPReplacementCall =
(HANDLE)hReplacementCall;
messageEx.message.MsgBody.InitiateCallMessage.hTSPConferenceCall =
m_hdConf;
psaLocalQ931Addr =
&messageEx.message.MsgBody.InitiateCallMessage.saLocalQ931Addr;
ZeroMemory( (PVOID)psaLocalQ931Addr, sizeof(SOCKADDR_IN) );
*psaLocalQ931Addr = m_LocalAddr;
psaLocalQ931Addr->sin_family = AF_INET;
break;
case SP_MSG_PrepareToAnswer:
if( (dwLength<=0) || (dwLength > sizeof(messageEx.pEncodedASN)) ||
(!pbEncodedBuf) )
{
CloseCall( 0 );
return;
}
messageEx.message.MsgBody.PrepareToAnswerMessage.hReplacementCall =
(HANDLE)hReplacementCall;
psaLocalQ931Addr =
&messageEx.message.MsgBody.PrepareToAnswerMessage.saLocalQ931Addr;
ZeroMemory( (PVOID)psaLocalQ931Addr, sizeof(SOCKADDR_IN) );
*psaLocalQ931Addr = m_LocalAddr;
psaLocalQ931Addr->sin_family = AF_INET;
//send the received Setup message. This should have the information
//about m_pPeerFastStart param as wel
CopyMemory( (PVOID)messageEx.message.pEncodedASNBuf,
(PVOID)pbEncodedBuf, dwLength );
break;
case SP_MSG_SendDTMFDigits:
if( (dwLength<=0) || (dwLength > sizeof(messageEx.pEncodedASN)) ||
(!pbEncodedBuf) )
{
CloseCall( 0 );
return;
}
hMSP = m_htMSPLine;
messageEx.message.MsgBody.SendDTMFDigitsMessage.wNumDigits =
(WORD)dwLength;
dwLength = (dwLength+1) * sizeof(WCHAR);
CopyMemory( (PVOID)messageEx.message.pEncodedASNBuf,
(PVOID)pbEncodedBuf, dwLength );
break;
case SP_MSG_ConnectComplete:
case SP_MSG_CallShutdown:
//dont set anything
hMSP = m_htMSPLine;
break;
case SP_MSG_H245PDU:
case SP_MSG_AnswerCall:
hMSP = m_htMSPLine;
break;
case SP_MSG_Hold:
hMSP = m_htMSPLine;
messageEx.message.MsgBody.HoldMessage.fHold = (BOOL)dwLength;
dwLength = 0;
break;
}
messageEx.message.dwMessageSize = sizeof(TspMspMessage) + dwLength
- ((dwLength)?sizeof(WORD):0);
if( messageType == SP_MSG_SendDTMFDigits )
{
messageEx.message.dwEncodedASNSize = 0;
}
else
{
messageEx.message.dwEncodedASNSize = dwLength;
}
//send msp message
PostLineEvent (
LINE_SENDMSPDATA,
(DWORD_PTR)hMSP, //This handle should be NULL when htCall param is a valid value
(DWORD_PTR)&(messageEx.message),
messageEx.message.dwMessageSize);
H323DBG(( DEBUG_LEVEL_ERROR, "SendMSPMessage exited:%p.",this ));
return;
}
//always called in lock
void
CH323Call::SendMSPStartH245(
PH323_ADDR pPeerH245Addr,
PH323_FASTSTART pPeerFastStart
)
{
TspMspMessageEx messageEx;
WORD wEncodedLength;
BYTE* pEncodedASNBuffer;
H323DBG(( DEBUG_LEVEL_ERROR, "SendMSPStartH245 entered:%p.", this ));
wEncodedLength = 0;
messageEx.message.MessageType = SP_MSG_StartH245;
messageEx.message.MsgBody.StartH245Message.hMSPReplaceCall = NULL;
messageEx.message.MsgBody.StartH245Message.hTSPReplacementCall =
(HANDLE)pPeerH245Addr;
ZeroMemory( messageEx.message.MsgBody.StartH245Message.ConferenceID,
sizeof(GUID) );
messageEx.message.MsgBody.StartH245Message.fH245TunnelCapability = FALSE;
messageEx.message.MsgBody.StartH245Message.fH245AddressPresent = FALSE;
memset( (PVOID)&messageEx.message.MsgBody.StartH245Message.saH245Addr,
0, sizeof(SOCKADDR_IN) );
//for outgoing call send the fast start proposal.
if( (m_dwOrigin==LINECALLORIGIN_OUTBOUND) || pPeerH245Addr )
{
if( pPeerH245Addr == NULL )
{
pPeerFastStart = m_pPeerFastStart;
}
if( pPeerFastStart != NULL )
{
if( !EncodeFastStartProposal( pPeerFastStart, &pEncodedASNBuffer,
&wEncodedLength ) )
{
CloseCall( 0 );
return;
}
CopyMemory( (PVOID)messageEx.message.pEncodedASNBuf,
(PVOID)pEncodedASNBuffer, wEncodedLength );
ASN1_FreeEncoded(m_ASNCoderInfo.pEncInfo, pEncodedASNBuffer );
}
}
//If outgoing call send peer's H245 address
if( (m_dwOrigin == LINECALLORIGIN_OUTBOUND) || pPeerH245Addr )
{
if( pPeerH245Addr == NULL )
{
pPeerH245Addr = &m_peerH245Addr;
}
messageEx.message.MsgBody.StartH245Message.fH245AddressPresent = FALSE;
if( pPeerH245Addr->Addr.IP_Binary.dwAddr != 0 )
{
messageEx.message.MsgBody.StartH245Message.saH245Addr.sin_family = AF_INET;
messageEx.message.MsgBody.StartH245Message.saH245Addr.sin_port =
htons(pPeerH245Addr->Addr.IP_Binary.wPort);
messageEx.message.MsgBody.StartH245Message.saH245Addr.sin_addr.s_addr =
htonl(pPeerH245Addr->Addr.IP_Binary.dwAddr);
messageEx.message.MsgBody.StartH245Message.fH245AddressPresent = TRUE;
}
}
//set the Q931 address
ZeroMemory( (PVOID)&messageEx.message.MsgBody.StartH245Message.saQ931Addr,
sizeof(SOCKADDR_IN) );
messageEx.message.MsgBody.StartH245Message.saQ931Addr.sin_family = AF_INET;
messageEx.message.MsgBody.StartH245Message.saQ931Addr.sin_port =
htons( m_CalleeAddr.Addr.IP_Binary.wPort );
messageEx.message.MsgBody.StartH245Message.saQ931Addr.sin_addr.s_addr =
htonl( m_CalleeAddr.Addr.IP_Binary.dwAddr );
messageEx.message.MsgBody.StartH245Message.fH245TunnelCapability =
(m_fh245Tunneling & REMOTE_H245_TUNNELING) &&
(m_fh245Tunneling & LOCAL_H245_TUNNELING);
messageEx.message.dwMessageSize = sizeof(messageEx.message) +
wEncodedLength - ((wEncodedLength)?1:0);
messageEx.message.dwEncodedASNSize = wEncodedLength;
// send msp message
PostLineEvent (
LINE_SENDMSPDATA,
//this handle should be NULL when htCall is a valid handle.
(DWORD_PTR)NULL,
(DWORD_PTR)&(messageEx.message),
messageEx.message.dwMessageSize);
m_dwFlags |= H245_START_MSG_SENT;
H323DBG(( DEBUG_LEVEL_ERROR, "SendMSPStartH245 exited:%p.",this ));
return;
}
//always called in lock
BOOL
CH323Call::AddU2U(
IN DWORD dwDirection,
IN DWORD dwDataSize,
IN PBYTE pData
)
/*++
Routine Description:
Create user user structure and adds to list.
Arguments:
pLftHead - Pointer to list in which to add user user info.
dwDataSize - Size of buffer pointed to by pData.
pData - Pointer to user user info.
Return Values:
Returns true if successful.
--*/
{
PLIST_ENTRY pListHead = NULL;
PUserToUserLE pU2ULE;
H323DBG(( DEBUG_LEVEL_ERROR, "AddU2U entered:%p.",this ));
if( dwDirection == U2U_OUTBOUND )
{
pListHead = &m_OutgoingU2U;
}
else
{
pListHead = &m_IncomingU2U;
}
// validate data buffer pointer and size
if( (pData != NULL) && (dwDataSize > 0) )
{
// allocate memory for user user info
pU2ULE = (PUserToUserLE)new char[ dwDataSize + sizeof(UserToUserLE) ];
// validate pointer
if (pU2ULE == NULL)
{
H323DBG(( DEBUG_LEVEL_ERROR,
"could not allocate user user info." ));
// failure
return FALSE;
}
// aim pointer at the end of the buffer by default
pU2ULE->pU2U = (LPBYTE)pU2ULE + sizeof(UserToUserLE);
pU2ULE->dwU2USize = dwDataSize;
// transfer user user info into list entry
CopyMemory( (PVOID)pU2ULE->pU2U, (PVOID)pData, pU2ULE->dwU2USize);
// add list entry to back of list
InsertTailList(pListHead, &pU2ULE->Link);
H323DBG(( DEBUG_LEVEL_VERBOSE,
"added user user info 0x%08lx (%d bytes).",
pU2ULE->pU2U,
pU2ULE->dwU2USize
));
}
H323DBG(( DEBUG_LEVEL_ERROR, "AddU2U exited:%p.",this ));
// success
return TRUE;
}
/*++
Routine Description:
Create user user structure and adds to list.
!!always called in lock.
Arguments:
pLftHead - Pointer to list in which to add user user info.
dwDataSize - Size of buffer pointed to by pData.
pData - Pointer to user user info.
Return Values:
Returns true if successful.
--*/
BOOL
CH323Call::AddU2UNoAlloc(
IN DWORD dwDirection,
IN DWORD dwDataSize,
IN PBYTE pData
)
{
PLIST_ENTRY pListHead = NULL;
PUserToUserLE pU2ULE;
H323DBG(( DEBUG_LEVEL_ERROR, "AddU2U entered:%p.",this ));
if( dwDirection == U2U_OUTBOUND )
{
pListHead = &m_OutgoingU2U;
}
else
{
pListHead = &m_IncomingU2U;
}
// validate data buffer pointer and size
if( (pData != NULL) && (dwDataSize > 0) )
{
// allocate memory for user user info
pU2ULE = new UserToUserLE;
// validate pointer
if (pU2ULE == NULL)
{
H323DBG(( DEBUG_LEVEL_ERROR,
"could not allocate user user info." ));
// failure
return FALSE;
}
// aim pointer at the end of the buffer by default
pU2ULE->pU2U = pData;
pU2ULE->dwU2USize = dwDataSize;
// add list entry to back of list
InsertTailList(pListHead, &pU2ULE->Link);
H323DBG(( DEBUG_LEVEL_VERBOSE,
"added user user info 0x%08lx (%d bytes).",
pU2ULE->pU2U,
pU2ULE->dwU2USize
));
}
H323DBG(( DEBUG_LEVEL_ERROR, "AddU2U exited:%p.",this ));
// success
return TRUE;
}
//!!must be always called in a lock.
BOOL
CH323Call::RemoveU2U(
IN DWORD dwDirection,
IN PUserToUserLE * ppU2ULE
)
/*++
Routine Description:
Removes user user info structure from list.
Arguments:
pListHead - Pointer to list in which to remove user user info.
ppU2ULE - Pointer to pointer to list entry.
Return Values:
Returns true if successful.
--*/
{
PLIST_ENTRY pListHead = NULL;
PLIST_ENTRY pLE;
H323DBG(( DEBUG_LEVEL_ERROR, "RemoveU2U entered:%p.",this ));
if( dwDirection == U2U_OUTBOUND )
{
pListHead = &m_OutgoingU2U;
}
else
{
pListHead = &m_IncomingU2U;
}
// process list until empty
if( IsListEmpty(pListHead) == FALSE )
{
// retrieve first entry
pLE = RemoveHeadList(pListHead);
// convert list entry to structure pointer
*ppU2ULE = CONTAINING_RECORD(pLE, UserToUserLE, Link);
H323DBG(( DEBUG_LEVEL_VERBOSE,
"removed user user info 0x%08lx (%d bytes).",
(*ppU2ULE)->pU2U, (*ppU2ULE)->dwU2USize ));
H323DBG(( DEBUG_LEVEL_ERROR, "RemoveU2U exited:%p.",this ));
// success
return TRUE;
}
// failure
return FALSE;
}
BOOL
CH323Call::FreeU2U(
IN DWORD dwDirection
)
/*++
Routine Description:
Releases memory for user user list.
!!must be always called in a lock.
Arguments
pListHead - Pointer to list in which to free user user info.
Return Values:
Returns true if successful.
--*/
{
PLIST_ENTRY pLE;
PUserToUserLE pU2ULE;
PLIST_ENTRY pListHead = NULL;
H323DBG(( DEBUG_LEVEL_ERROR, "FreeU2U entered:%p.",this ));
if( dwDirection == U2U_OUTBOUND )
{
pListHead = &m_OutgoingU2U;
}
else
{
pListHead = &m_IncomingU2U;
}
// process list until empty
while( IsListEmpty(pListHead) == FALSE )
{
// retrieve first entry
pLE = RemoveHeadList(pListHead);
// convert list entry to structure pointer
pU2ULE = CONTAINING_RECORD(pLE, UserToUserLE, Link);
// release memory
if( pU2ULE )
{
delete pU2ULE;
pU2ULE = NULL;
}
}
H323DBG(( DEBUG_LEVEL_ERROR, "FreeU2U exited:%p.",this ));
// success
return TRUE;
}
/*++
Routine Description:
Resets call object to original state for re-use.
Arguments:
Return Values:
Returns true if successful.
--*/
void
CH323Call::Shutdown(
OUT BOOL * fDelete
)
{
H323DBG(( DEBUG_LEVEL_ERROR, "Shutdown entered:%p.",this ));
if( !(m_dwFlags & CALLOBJECT_INITIALIZED) )
{
return;
}
//acquire the lock on call table before acquiring the lock on call object
g_pH323Line -> LockCallTable();
Lock();
if( m_dwFlags & CALLOBJECT_SHUTDOWN )
{
Unlock();
g_pH323Line -> UnlockCallTable();
return;
}
// reset tapi info
m_dwCallState = LINECALLSTATE_UNKNOWN;
m_dwCallStateMode = 0;
m_dwOrigin = LINECALLORIGIN_UNKNOWN;
m_dwAddressType = 0;
m_dwIncomingModes = 0;
m_dwOutgoingModes = 0;
m_dwRequestedModes = 0;
m_fMonitoringDigits = FALSE;
// reset tapi handles
m_htCall = (HTAPICALL)NULL;
// reset addresses
memset( (PVOID)&m_CalleeAddr,0,sizeof(H323_ADDR));
memset( (PVOID)&m_CallerAddr,0,sizeof(H323_ADDR));
H323DBG(( DEBUG_LEVEL_ERROR, "deleting calleealias:%p.",this ));
FreeAliasNames( m_pCalleeAliasNames );
m_pCalleeAliasNames = NULL;
if( m_pCallerAliasNames != NULL )
{
//H323DBG(( DEBUG_LEVEL_ERROR, "Caller alias count:%d : %p", m_pCallerAliasNames->wCount, this ));
FreeAliasNames( m_pCallerAliasNames );
m_pCallerAliasNames = NULL;
}
//reset non standard data
memset( (PVOID)&m_NonStandardData, 0, sizeof(H323NonStandardData) );
// release user user information
FreeU2U( U2U_OUTBOUND );
FreeU2U( U2U_INBOUND );
//shutdown the Q931 call if not shutdown yet
if( m_hSetupSentTimer != NULL )
{
DeleteTimerQueueTimer( H323TimerQueue, m_hSetupSentTimer, NULL );
m_hSetupSentTimer = NULL;
}
if( m_hCallEstablishmentTimer )
{
DeleteTimerQueueTimer(H323TimerQueue, m_hCallEstablishmentTimer, NULL);
m_hCallEstablishmentTimer = NULL;
}
if( m_hCallDivertOnNATimer )
{
DeleteTimerQueueTimer(H323TimerQueue, m_hCallDivertOnNATimer, NULL);
m_hCallDivertOnNATimer = NULL;
}
*fDelete = FALSE;
if( m_IoRefCount == 0 )
{
*fDelete = TRUE;
}
m_dwStateMachine = Q931_CALL_STATE_NONE;
if( m_callSocket != INVALID_SOCKET )
{
if(shutdown( m_callSocket, SD_BOTH ) == SOCKET_ERROR)
{
H323DBG((DEBUG_LEVEL_TRACE, "couldn't shutdown the socket:%d, %p.",
WSAGetLastError(), this ));
}
closesocket( m_callSocket );
m_callSocket = INVALID_SOCKET;
}
m_pwszDisplay = NULL;
FreeVendorInfo( &m_peerVendorInfo );
if( m_peerNonStandardData.sData.pOctetString )
{
H323DBG(( DEBUG_LEVEL_ERROR, "deleting nonstd:%p.",this ));
delete m_peerNonStandardData.sData.pOctetString;
m_peerNonStandardData.sData.pOctetString = NULL;
}
H323DBG(( DEBUG_LEVEL_ERROR, "deleting xtraalias:%p.",this ));
FreeAliasNames( m_pPeerExtraAliasNames );
m_pPeerExtraAliasNames = NULL;
H323DBG(( DEBUG_LEVEL_ERROR, "deleting display:%p.",this ));
if( m_pPeerDisplay )
{
delete m_pPeerDisplay;
m_pPeerDisplay = NULL;
}
if( m_CallData.pOctetString != NULL )
{
delete m_CallData.pOctetString;
}
H323DBG(( DEBUG_LEVEL_ERROR, "deleting hdconf:%p.",this ));
// delete conference
if( m_hdConf != NULL )
{
g_pH323Line -> GetH323ConfTable() -> Remove( m_hdConf );
delete m_hdConf;
m_hdConf = NULL;
}
H323DBG(( DEBUG_LEVEL_ERROR, "deleting preparetoans:%p.",this ));
if( m_prepareToAnswerMsgData.pbBuffer )
{
delete m_prepareToAnswerMsgData.pbBuffer;
}
ZeroMemory( (PVOID)&m_prepareToAnswerMsgData, sizeof(BUFFERDESCR) );
H323DBG(( DEBUG_LEVEL_ERROR, "deleting drq timer:%p.",this ));
//ras related data structures
if( m_hDRQTimer != NULL )
{
DeleteTimerQueueTimer( H323TimerQueue, m_hDRQTimer, NULL );
m_hDRQTimer = NULL;
}
H323DBG(( DEBUG_LEVEL_ERROR, "deleting arq timer:%p.",this ));
if( m_hARQTimer != NULL )
{
DeleteTimerQueueTimer( H323TimerQueue, m_hARQTimer, NULL );
m_hARQTimer = NULL;
}
if( m_pPeerFastStart != NULL )
{
FreeFastStart( m_pPeerFastStart );
m_pPeerFastStart = NULL;
}
if( m_pFastStart != NULL )
{
FreeFastStart( m_pFastStart );
m_pFastStart = NULL;
}
if( m_pARQExpireContext != NULL )
{
delete m_pARQExpireContext;
m_pARQExpireContext = NULL;
}
if( m_pDRQExpireContext != NULL )
{
delete m_pDRQExpireContext;
m_pDRQExpireContext = NULL;
}
FreeCallForwardData();
g_pH323Line -> RemoveCallFromTable (m_hdCall);
m_dwFlags |= CALLOBJECT_SHUTDOWN;
Unlock();
g_pH323Line -> UnlockCallTable();
H323DBG(( DEBUG_LEVEL_ERROR, "Shutdown exited:%p.",this ));
return;
}
void
CH323Call::FreeCallForwardData()
{
if( m_pCallReroutingInfo )
{
FreeCallReroutingInfo();
}
if( m_hCheckRestrictionTimer )
{
DeleteTimerQueueTimer( H323TimerQueue, m_hCheckRestrictionTimer,
NULL );
m_hCheckRestrictionTimer = NULL;
}
if( m_hCallReroutingTimer )
{
DeleteTimerQueueTimer( H323TimerQueue, m_hCallReroutingTimer, NULL );
m_hCallReroutingTimer = NULL;
}
if( m_hCTIdentifyTimer )
{
DeleteTimerQueueTimer( H323TimerQueue, m_hCTIdentifyTimer, NULL );
m_hCTIdentifyTimer = NULL;
}
if( m_hCTIdentifyRRTimer )
{
DeleteTimerQueueTimer( H323TimerQueue, m_hCTIdentifyRRTimer, NULL );
m_hCTIdentifyRRTimer = NULL;
}
if( m_hCTInitiateTimer )
{
DeleteTimerQueueTimer( H323TimerQueue, m_hCTInitiateTimer, NULL );
m_hCTInitiateTimer = NULL;
}
if( m_pTransferedToAlias )
{
FreeAliasNames( m_pTransferedToAlias );
m_pTransferedToAlias = NULL;
}
if( m_dwCallType & CALLTYPE_TRANSFERED2_CONSULT )
{
g_pH323Line -> RemoveFromCTCallIdentityTable( m_hdCall );
}
if( m_H450ASNCoderInfo.pEncInfo )
{
TermH450ASNCoder();
}
if( m_pCallForwardParams )
{
FreeCallForwardParams( m_pCallForwardParams );
m_pCallForwardParams = NULL;
}
if( m_pForwardAddress )
{
FreeForwardAddress( m_pForwardAddress );
m_pForwardAddress = NULL;
}
}
BOOL
CH323Call::ResolveCallerAddress(void)
/*++
Routine Description:
Resolves caller address from callee address.
!!must be always called in a lock.
Arguments:
Return Values:
Returns true if successful.
--*/
{
INT nStatus;
SOCKET hCtrlSocket = INVALID_SOCKET;
SOCKADDR CalleeSockAddr;
SOCKADDR CallerSockAddr;
DWORD dwNumBytesReturned = 0;
H323DBG(( DEBUG_LEVEL_ERROR, "ResolveCallerAddress entered:%p.",this ));
// allocate control socket
hCtrlSocket = WSASocket(
AF_INET, // af
SOCK_DGRAM, // type
IPPROTO_IP, // protocol
NULL, // lpProtocolInfo
0, // g
WSA_FLAG_OVERLAPPED // dwFlags
);
// validate control socket
if (hCtrlSocket == INVALID_SOCKET)
{
H323DBG(( DEBUG_LEVEL_ERROR,
"error %d creating control socket.", WSAGetLastError() ));
// failure
return FALSE;
}
// initialize ioctl parameters
memset( (PVOID)&CalleeSockAddr,0,sizeof(SOCKADDR));
memset( (PVOID)&CallerSockAddr,0,sizeof(SOCKADDR));
// initialize address family
CalleeSockAddr.sa_family = AF_INET;
// transfer callee information
((SOCKADDR_IN*)&CalleeSockAddr)->sin_addr.s_addr =
htonl(m_CalleeAddr.Addr.IP_Binary.dwAddr);
// query stack
nStatus = WSAIoctl(
hCtrlSocket,
SIO_ROUTING_INTERFACE_QUERY,
&CalleeSockAddr,
sizeof(SOCKADDR),
&CallerSockAddr,
sizeof(SOCKADDR),
&dwNumBytesReturned,
NULL,
NULL
);
// release handle
closesocket(hCtrlSocket);
// validate return code
if (nStatus == SOCKET_ERROR)
{
H323DBG(( DEBUG_LEVEL_ERROR,
"error 0x%08lx calling SIO_ROUTING_INTERFACE_QUERY.",
WSAGetLastError() ));
// failure
return FALSE;
}
// save interface address of best route
m_CallerAddr.nAddrType = H323_IP_BINARY;
m_CallerAddr.Addr.IP_Binary.dwAddr =
ntohl(((SOCKADDR_IN*)&CallerSockAddr)->sin_addr.s_addr);
m_CallerAddr.Addr.IP_Binary.wPort =
LOWORD(g_RegistrySettings.dwQ931ListenPort);
m_CallerAddr.bMulticast =
IN_MULTICAST(m_CallerAddr.Addr.IP_Binary.dwAddr);
H323DBG(( DEBUG_LEVEL_TRACE,
"caller address resolved to %s.",
H323AddrToString(((SOCKADDR_IN*)&CallerSockAddr)->sin_addr.s_addr) ));
H323DBG(( DEBUG_LEVEL_ERROR, "ResolveCallerAddress exited:%p.",this ));
// success
return TRUE;
}
BOOL
CH323Call::ResolveE164Address(
IN LPCWSTR pwszDialableAddr
)
/*++
Routine Description:
Resolves E.164 address ("4259367111").
!!must be always called in a lock.
Arguments:
pwszDialableAddr - Specifies a pointer to the dialable address specified
by the TAPI application.
Return Values:
Returns true if successful.
--*/
{
WCHAR wszAddr[H323_MAXDESTNAMELEN+1];
DWORD dwE164AddrSize;
H323DBG(( DEBUG_LEVEL_ERROR, "ResolveE164Address entered:%p.",this ));
// make sure pstn gateway has been specified
if ((g_RegistrySettings.fIsGatewayEnabled == FALSE) ||
(g_RegistrySettings.gatewayAddr.nAddrType == 0))
{
H323DBG(( DEBUG_LEVEL_ERROR,
"pstn gateway not specified."
));
// failure
return FALSE;
}
// save gateway address as callee address
m_CalleeAddr = g_RegistrySettings.gatewayAddr;
dwE164AddrSize = ValidateE164Address( pwszDialableAddr, wszAddr );
if( dwE164AddrSize == 0 )
{
H323DBG(( DEBUG_LEVEL_ERROR,
"invlid e164 callee alias ."));
return FALSE;
}
H323DBG(( DEBUG_LEVEL_TRACE,
"callee alias resolved to E.164 number." ));
H323DBG(( DEBUG_LEVEL_ERROR, "ResolveE164Address exited:%p.",this ));
//determine caller address
return ResolveCallerAddress();
}
DWORD
ValidateE164Address(
LPCWSTR pwszDialableAddr,
WCHAR* wszAddr
)
{
DWORD dwE164AddrSize = 0;
WCHAR * pwszValidE164Chars;
WCHAR wszValidE164Chars[] = { H323_ALIAS_H323_PHONE_CHARS L"\0" };
// process until termination char
while (*pwszDialableAddr != L'\0')
{
// reset pointer to valid characters
pwszValidE164Chars = wszValidE164Chars;
// process until termination char
while (*pwszValidE164Chars != L'\0')
{
// see if valid E.164 character specified
if (*pwszDialableAddr == *pwszValidE164Chars)
{
// save valid character in temp buffer
wszAddr[dwE164AddrSize++] = *pwszDialableAddr;
break;
}
// next valid char
++pwszValidE164Chars;
}
// next input char
++pwszDialableAddr;
}
// terminate string
wszAddr[dwE164AddrSize++] = L'\0';
// validate string
if (dwE164AddrSize == 0)
{
H323DBG(( DEBUG_LEVEL_TRACE,
"no valid E.164 characters in string." ));
}
return dwE164AddrSize;
}
/*++
Routine Description:
Resolves IP address ("172.31.255.231") or DNS entry ("NIKHILB1").
!!must be always called in a lock.
Arguments:
pszDialableAddr - Specifies a pointer to the dialable address specified
by the TAPI application.
Return Values:
Returns true if successful.
--*/
BOOL
CH323Call::ResolveIPAddress(
IN LPSTR pszDialableAddr
)
{
DWORD dwIPAddr;
struct hostent* pHost;
H323DBG(( DEBUG_LEVEL_ERROR, "ResolveIPAddress entered:%p.",this ));
// attempt to convert ip address
dwIPAddr = inet_addr(pszDialableAddr);
// see if address converted
if( dwIPAddr == INADDR_NONE )
{
// attempt to lookup hostname
pHost = gethostbyname(pszDialableAddr);
// validate pointer
if( pHost != NULL )
{
// retrieve host address from structure
dwIPAddr = *(unsigned long *)pHost->h_addr;
}
}
// see if address converted
if( dwIPAddr == INADDR_NONE )
{
H323DBG(( DEBUG_LEVEL_ERROR,
"error 0x%08lx resolving IP address.",
WSAGetLastError() ));
// failure
return FALSE;
}
// save converted address
m_CalleeAddr.nAddrType = H323_IP_BINARY;
m_CalleeAddr.Addr.IP_Binary.dwAddr = ntohl(dwIPAddr);
m_CalleeAddr.Addr.IP_Binary.wPort =
LOWORD(g_RegistrySettings.dwQ931ListenPort);
m_CalleeAddr.bMulticast =
IN_MULTICAST(m_CalleeAddr.Addr.IP_Binary.dwAddr);
H323DBG(( DEBUG_LEVEL_TRACE,
"callee address resolved to %s:%d.",
H323AddrToString(dwIPAddr),
m_CalleeAddr.Addr.IP_Binary.wPort ));
H323DBG(( DEBUG_LEVEL_ERROR, "ResolveIPAddress exited:%p.",this ));
// determine caller address
return ResolveCallerAddress();
}
BOOL
CH323Call::ResolveEmailAddress(
IN LPCWSTR pwszDialableAddr,
IN LPSTR pszUser,
IN LPSTR pszDomain
)
/*++
Routine Description:
Resolves e-mail address ("nikhilb@microsoft.com").
!!must be always called in a lock.
Arguments:
pwszDialableAddr - Specifies a pointer to the dialable address specified
by the TAPI application.
pszUser - Specifies a pointer to the user component of e-mail name.
pszDomain - Specified a pointer to the domain component of e-mail name.
Return Values:
Returns true if successful.
--*/
{
DWORD dwAddrSize;
H323DBG(( DEBUG_LEVEL_ERROR, "ResolveEmailAddress entered:%p.",this ));
// size destination address string
dwAddrSize = wcslen(pwszDialableAddr) + 1;
// attempt to resolve domain locally
if( ResolveIPAddress( pszDomain) )
{
// success
return TRUE;
}
// make sure proxy has been specified
if( (g_RegistrySettings.fIsProxyEnabled == FALSE) ||
(g_RegistrySettings.proxyAddr.nAddrType == 0) )
{
H323DBG(( DEBUG_LEVEL_ERROR, "proxy not specified." ));
// failure
return FALSE;
}
// save proxy address as callee address
m_CalleeAddr = g_RegistrySettings.proxyAddr;
H323DBG(( DEBUG_LEVEL_TRACE,
"callee alias resolved to H.323 alias."));
H323DBG(( DEBUG_LEVEL_ERROR, "ResolveEmailAddress exited:%p.",this ));
// determine caller address
return ResolveCallerAddress();
}
/*++
Routine Description:
Resolves remote address and determines the correct local address
to use in order to reach remote address.
!!must be always called in a lock.
Arguments:
pwszDialableAddr - Specifies a pointer to the dialable address specified
by the TAPI application.
Return Values:
Returns true if successful.
--*/
BOOL
CH323Call::ResolveAddress(
IN LPCWSTR pwszDialableAddr
)
{
CHAR szDelimiters[] = "@ \t\n";
CHAR szAddr[H323_MAXDESTNAMELEN+1];
LPSTR pszUser = NULL;
LPSTR pszDomain = NULL;
H323DBG(( DEBUG_LEVEL_ERROR, "ResolveAddress entered:%p.",this ));
// validate pointerr
if (pwszDialableAddr == NULL)
{
H323DBG(( DEBUG_LEVEL_ERROR, "null destination address." ));
// failure
return FALSE;
}
H323DBG(( DEBUG_LEVEL_TRACE,
"resolving %s %S.",
H323AddressTypeToString( m_dwAddressType),
pwszDialableAddr ));
// check whether phone number has been specified
if( m_dwAddressType == LINEADDRESSTYPE_PHONENUMBER )
{
// need to direct call to pstn gateway
return ResolveE164Address( pwszDialableAddr);
}
// convert address from unicode
if (WideCharToMultiByte(
CP_ACP,
0,
pwszDialableAddr,
-1,
szAddr,
sizeof(szAddr),
NULL,
NULL
) == 0)
{
H323DBG(( DEBUG_LEVEL_ERROR,
"could not convert address from unicode." ));
// failure
return FALSE;
}
// parse user name
pszUser = strtok(szAddr, szDelimiters);
// parse domain name
pszDomain = strtok(NULL, szDelimiters);
// validate pointer
if (pszUser == NULL)
{
H323DBG(( DEBUG_LEVEL_ERROR, "could not parse destination address." ));
// failure
return FALSE;
}
// validate pointer
if (pszDomain == NULL)
{
// switch pointers
pszDomain = pszUser;
// re-initialize
pszUser = NULL;
}
H323DBG(( DEBUG_LEVEL_VERBOSE,
"resolving user %s domain %s.",
pszUser,
pszDomain
));
H323DBG(( DEBUG_LEVEL_ERROR, "ResolveAddress exited:%p.",this ));
// process e-mail and domain names
return ResolveEmailAddress(
pwszDialableAddr,
pszUser,
pszDomain
);
}
BOOL
/*++
Routine Description:
Validate optional call parameters specified by user.
!!no need to call in a lock because not added to the call table yet
Arguments:
pCallParams - Pointer to specified call parameters to be
validated.
pwszDialableAddr - Pointer to the dialable address specified
by the TAPI application.
pdwStatus - Pointer to DWORD containing error code if this
routine fails for any reason.
Return Values:
Returns true if successful.
--*/
CH323Call::ValidateCallParams(
IN LPLINECALLPARAMS pCallParams,
IN LPCWSTR pwszDialableAddr,
IN PDWORD pdwStatus
)
{
DWORD dwMediaModes = H323_LINE_DEFMEDIAMODES;
DWORD dwAddrSize;
WCHAR wszAddr[H323_MAXDESTNAMELEN+1];
PH323_ALIASNAMES pAliasList;
WCHAR* wszMachineName;
H323DBG(( DEBUG_LEVEL_TRACE, "ValidateCallParams entered:%p.", this ));
H323DBG(( DEBUG_LEVEL_VERBOSE, "clearing unknown media mode." ));
// validate pointer
if( (pCallParams == NULL) || (pwszDialableAddr == NULL) )
{
return FALSE;
}
// retrieve media modes specified
dwMediaModes = pCallParams->dwMediaMode;
// retrieve address type specified
m_dwAddressType = pCallParams->dwAddressType;
// see if we support call parameters
if( pCallParams->dwCallParamFlags != 0 )
{
H323DBG(( DEBUG_LEVEL_ERROR,
"do not support call parameters 0x%08lx.",
pCallParams->dwCallParamFlags ));
// do not support param flags
*pdwStatus = LINEERR_INVALCALLPARAMS;
// failure
return FALSE;
}
// see if unknown bit is specified
if( dwMediaModes & LINEMEDIAMODE_UNKNOWN )
{
H323DBG(( DEBUG_LEVEL_VERBOSE,
"clearing unknown media mode." ));
// clear unknown bit from modes
dwMediaModes &= ~LINEMEDIAMODE_UNKNOWN;
}
// see if both audio bits are specified
if( (dwMediaModes & LINEMEDIAMODE_AUTOMATEDVOICE) &&
(dwMediaModes & LINEMEDIAMODE_INTERACTIVEVOICE) )
{
H323DBG(( DEBUG_LEVEL_VERBOSE,
"clearing automated voice media mode." ));
// clear extra audio bit from modes
dwMediaModes &= ~LINEMEDIAMODE_INTERACTIVEVOICE;
}
// see if we support media modes specified
if( dwMediaModes & ~H323_LINE_MEDIAMODES )
{
H323DBG(( DEBUG_LEVEL_ERROR,
"do not support media modes 0x%08lx.",
pCallParams->dwMediaMode ));
// do not support media mode
*pdwStatus = LINEERR_INVALMEDIAMODE;
// failure
return FALSE;
}
// see if we support bearer modes
if( pCallParams->dwBearerMode & ~H323_LINE_BEARERMODES )
{
H323DBG(( DEBUG_LEVEL_ERROR,
"do not support bearer mode 0x%08lx.",
pCallParams->dwBearerMode ));
// do not support bearer mode
*pdwStatus = LINEERR_INVALBEARERMODE;
// failure
return FALSE;
}
// see if we support address modes
if( pCallParams->dwAddressMode & ~H323_LINE_ADDRESSMODES )
{
H323DBG(( DEBUG_LEVEL_ERROR,
"do not support address mode 0x%08lx.",
pCallParams->dwAddressMode ));
// do not support address mode
*pdwStatus = LINEERR_INVALADDRESSMODE;
// failure
return FALSE;
}
// validate address id specified
if (pCallParams->dwAddressID != 0 )
{
H323DBG(( DEBUG_LEVEL_ERROR, "address id 0x%08lx invalid.",
pCallParams->dwAddressID ));
// invalid address id
*pdwStatus = LINEERR_INVALADDRESSID;
// failure
return FALSE;
}
// validate destination address type specified
if( m_dwAddressType & ~H323_LINE_ADDRESSTYPES )
{
H323DBG(( DEBUG_LEVEL_ERROR, "address type 0x%08lx invalid.",
pCallParams->dwAddressType ));
// invalid address type
*pdwStatus = LINEERR_INVALADDRESSTYPE;
//failure
return FALSE;
}
if( m_dwAddressType == LINEADDRESSTYPE_PHONENUMBER )
{
dwAddrSize = ValidateE164Address( pwszDialableAddr, wszAddr );
//add the callee alias
if( dwAddrSize==0 )
{
H323DBG(( DEBUG_LEVEL_ERROR,
"invlid e164 callee alias ."));
return FALSE;
}
if( (dwAddrSize > MAX_E164_ADDR_LEN) || (dwAddrSize == 0) )
return FALSE;
if(!AddAliasItem( m_pCalleeAliasNames,
(BYTE*)wszAddr,
dwAddrSize * sizeof(WCHAR),
e164_chosen ))
{
H323DBG(( DEBUG_LEVEL_ERROR,
"could not allocate for callee alias ."));
// invalid destination addr
*pdwStatus = LINEERR_INVALADDRESS;
return FALSE;
}
H323DBG(( DEBUG_LEVEL_ERROR, "callee alias added:%S.", wszAddr ));
}
else
{
dwAddrSize = (wcslen(pwszDialableAddr)+1);
if( (dwAddrSize > MAX_H323_ADDR_LEN) || (dwAddrSize == 0) )
return FALSE;
if(!AddAliasItem( m_pCalleeAliasNames,
(BYTE*)pwszDialableAddr,
dwAddrSize * sizeof(WCHAR),
h323_ID_chosen ))
{
H323DBG(( DEBUG_LEVEL_ERROR,
"could not allocate for callee alias ."));
// invalid destination addr
*pdwStatus = LINEERR_INVALADDRESS;
return FALSE;
}
H323DBG(( DEBUG_LEVEL_ERROR, "callee alias added:%S.", pwszDialableAddr ));
}
// see if callee alias specified
if( pCallParams->dwCalledPartySize > 0 )
{
//avoid duplicate aliases
dwAddrSize *= sizeof(WCHAR);
if( ( (m_dwAddressType != LINEADDRESSTYPE_PHONENUMBER) ||
(memcmp(
(PVOID)((BYTE*)pCallParams + pCallParams->dwCalledPartyOffset),
wszAddr,
pCallParams->dwCalledPartySize ) != 0 )
) &&
( memcmp(
(PVOID)((BYTE*)pCallParams + pCallParams->dwCalledPartyOffset),
pwszDialableAddr,
pCallParams->dwCalledPartySize ) != 0
)
)
{
// allocate memory for callee string
if( !AddAliasItem( m_pCalleeAliasNames,
(BYTE*)pCallParams + pCallParams->dwCalledPartyOffset,
pCallParams->dwCalledPartySize,
(m_dwAddressType != LINEADDRESSTYPE_PHONENUMBER)?
h323_ID_chosen : e164_chosen) )
{
H323DBG(( DEBUG_LEVEL_ERROR,
"could not allocate caller name." ));
// invalid address id
*pdwStatus = LINEERR_NOMEM;
// failure
return FALSE;
}
H323DBG(( DEBUG_LEVEL_ERROR, "callee alias added:%S.",
((BYTE*)pCallParams + pCallParams->dwCalledPartyOffset) ));
}
}
// see if caller name specified
if( pCallParams->dwCallingPartyIDSize > 0 )
{
//H323DBG(( DEBUG_LEVEL_ERROR, "Caller alias count:%d : %p", m_pCallerAliasNames->wCount, this ));
// allocate memory for callee string
if(!AddAliasItem( m_pCallerAliasNames,
(BYTE*)pCallParams + pCallParams->dwCallingPartyIDOffset,
pCallParams->dwCallingPartyIDSize,
h323_ID_chosen ) )
{
H323DBG(( DEBUG_LEVEL_ERROR,
"could not allocate caller name." ));
// invalid address id
*pdwStatus = LINEERR_NOMEM;
// failure
return FALSE;
}
//H323DBG(( DEBUG_LEVEL_ERROR, "Caller alias count:%d : %p", m_pCallerAliasNames->wCount, this ));
}
else if( RasIsRegistered() )
{
//ARQ message must have a caller alias
pAliasList = RASGetRegisteredAliasList();
wszMachineName = pAliasList -> pItems[0].pData;
//H323DBG(( DEBUG_LEVEL_ERROR, "Caller alias count:%d : %p", m_pCallerAliasNames->wCount, this ));
//set the value for m_pCallerAliasNames
if( !AddAliasItem( m_pCallerAliasNames,
(BYTE*)(wszMachineName),
sizeof(WCHAR) * (wcslen(wszMachineName) + 1 ),
pAliasList -> pItems[0].wType ) )
{
H323DBG(( DEBUG_LEVEL_ERROR,
"could not allocate caller name." ));
// invalid address id
*pdwStatus = LINEERR_NOMEM;
// failure
return FALSE;
}
//H323DBG(( DEBUG_LEVEL_ERROR, "Caller alias count:%d : %p", m_pCallerAliasNames->wCount, this ));
}
// check for user user information
if( pCallParams->dwUserUserInfoSize > 0 )
{
// save user user info
if (AddU2U( U2U_OUTBOUND, pCallParams->dwUserUserInfoSize,
(LPBYTE)pCallParams + pCallParams->dwUserUserInfoOffset ) == FALSE )
{
//no need to free above aloocated memory for m_CalleeAlias and
//m_CallerAlias
// invalid address id
*pdwStatus = LINEERR_NOMEM;
// failure
return FALSE;
}
}
// save call data buffer.
if( SetCallData( (LPBYTE)pCallParams + pCallParams->dwCallDataOffset,
pCallParams->dwCallDataSize ) == FALSE )
{
//no need to free above aloocated memory for m_CalleeAlias and
//m_CallerAlias
// invalid address id
*pdwStatus = LINEERR_NOMEM;
// failure
return FALSE;
}
// clear incoming modes
m_dwIncomingModes = 0;
// outgoing modes will be finalized after H.245 stage
m_dwOutgoingModes = dwMediaModes | LINEMEDIAMODE_UNKNOWN;
// save media modes specified
m_dwRequestedModes = dwMediaModes;
H323DBG(( DEBUG_LEVEL_TRACE, "ValidateCallParams exited:%p.", this ));
// success
return TRUE;
}
/*++
Routine Description:
Associates call object with the specified conference id.
Arguments:
Return Values:
Returns true if successful.
--*/
PH323_CONFERENCE
CH323Call::CreateConference (
IN GUID* pConferenceId OPTIONAL)
{
int iresult;
H323DBG(( DEBUG_LEVEL_TRACE, "CreateConference entered:%p.", this ));
Lock();
_ASSERTE( m_hdConf == NULL );
// create conference
m_hdConf = new H323_CONFERENCE( this );
// validate
if ( m_hdConf == NULL )
{
H323DBG(( DEBUG_LEVEL_ERROR,
"could no allocate the conference object."));
Unlock();
return NULL;
}
if (pConferenceId)
{
m_ConferenceID = *pConferenceId;
}
else
{
iresult = UuidCreate (&m_ConferenceID);
if ((iresult == RPC_S_OK) || (iresult ==RPC_S_UUID_LOCAL_ONLY))
{
H323DBG ((DEBUG_LEVEL_INFO, "generated new conference id (GUID)."));
}
else
{
H323DBG(( DEBUG_LEVEL_ERROR,
"failed to generate GUID for conference id: %d.", iresult ));
ZeroMemory (&m_ConferenceID, sizeof m_ConferenceID);
}
}
Unlock();
H323DBG(( DEBUG_LEVEL_TRACE, "CreateConference exited:%p.", this ));
return m_hdConf;
}
/*++
Routine Description:
Initiates outbound call to specified destination.
!!always called in a lock
Arguments:
none
Return Values:
Returns true if successful.
--*/
BOOL
CH323Call::PlaceCall(void)
{
H323DBG(( DEBUG_LEVEL_TRACE, "PlaceCall entered:%p.", this ));
if( m_dwFlags & CALLOBJECT_SHUTDOWN )
{
return FALSE;
}
// see if user user information specified
CopyU2UAsNonStandard( U2U_OUTBOUND );
if( m_pwszDisplay == NULL )
{
// see if caller alias specified
if( m_pCallerAliasNames && m_pCallerAliasNames -> wCount )
{
if((m_pCallerAliasNames ->pItems[0].wType == h323_ID_chosen) ||
(m_pCallerAliasNames ->pItems[0].wType == e164_chosen) )
{
// send caller name as display
m_pwszDisplay = m_pCallerAliasNames -> pItems[0].pData;
//H323DBG(( DEBUG_LEVEL_ERROR, "Caller alias count:%d : %p", m_pCallerAliasNames->wCount, this ));
}
//H323DBG(( DEBUG_LEVEL_ERROR, "Caller alias count:%d : %p", m_pCallerAliasNames->wCount, this ));
}
}
// validate
if( !SetupCall() )
{
H323DBG(( DEBUG_LEVEL_VERBOSE, "Q931 call: failed." ));
return FALSE;
}
H323DBG(( DEBUG_LEVEL_TRACE, "PlaceCall exited:%p.", this ));
// return status
return TRUE;
}
void
CH323Call::DropUserInitiated(
IN DWORD dwDisconnectMode
)
{
//since this is a user initiated drop, the transfered call should also
//be dropped for a primary call and vice versa
if( IsTransferredCall( m_dwCallType ) && m_hdRelatedCall )
{
QueueTAPILineRequest(
TSPI_CLOSE_CALL,
m_hdRelatedCall,
NULL,
dwDisconnectMode,
m_wCallReference );
}
DropCall(dwDisconnectMode);
}
//always called in lock
BOOL
/*++
Routine Description:
Hangs up call (if necessary) and changes state to idle.
Arguments:
dwDisconnectMode - Status code for disconnect.
Return Values:
Returns true if successful.
--*/
CH323Call::DropCall(
IN DWORD dwDisconnectMode
)
{
PUserToUserLE pU2ULE = NULL;
if( m_dwFlags & CALLOBJECT_SHUTDOWN )
{
return FALSE;
}
H323DBG(( DEBUG_LEVEL_TRACE, "DropCall entered:%p.", this ));
if( (m_dwRASCallState == RASCALL_STATE_REGISTERED ) ||
(m_dwRASCallState == RASCALL_STATE_ARQSENT ) )
{
//disengage from the GK
SendDRQ( forcedDrop_chosen, NOT_RESEND_SEQ_NUM, TRUE );
}
// determine call state
switch (m_dwCallState)
{
case LINECALLSTATE_CONNECTED:
// hangup call (this will invoke async indication)
// validate
//encode ASN.1 and send Q931release message to the peer
if(!SendQ931Message( NO_INVOKEID,
0,
0,
RELEASECOMPLMESSAGETYPE,
NO_H450_APDU ))
{
//post a message to the callback thread to shutdown the H323 call
H323DBG(( DEBUG_LEVEL_ERROR,
"error hanging up call 0x%08lx.", this ));
}
else
{
m_dwStateMachine = Q931_RELEASE_SENT;
H323DBG(( DEBUG_LEVEL_VERBOSE, "call 0x%08lx hung up.", this ));
}
// change call state to disconnected
ChangeCallState(LINECALLSTATE_DISCONNECTED, dwDisconnectMode);
break;
case LINECALLSTATE_OFFERING:
// see if user user information specified
CopyU2UAsNonStandard( U2U_OUTBOUND );
// reject call
//encode ASN.1 and send Q931Setup message to the peer
if( SendQ931Message( NO_INVOKEID,
0,
0,
RELEASECOMPLMESSAGETYPE,
NO_H450_APDU ))
{
m_dwStateMachine = Q931_RELEASE_SENT;
H323DBG(( DEBUG_LEVEL_VERBOSE, "call 0x%08lx rejected.", this ));
}
else
{
H323DBG(( DEBUG_LEVEL_ERROR, "error reject call 0x%08lx.",this));
}
// change call state to disconnected
ChangeCallState(LINECALLSTATE_DISCONNECTED, dwDisconnectMode);
break;
case LINECALLSTATE_RINGBACK:
case LINECALLSTATE_ACCEPTED:
// cancel outbound call
if( SendQ931Message( NO_INVOKEID,
0,
0,
RELEASECOMPLMESSAGETYPE,
NO_H450_APDU ))
{
H323DBG(( DEBUG_LEVEL_ERROR,
"error cancelling call 0x%08lx.", this ));
}
else
{
H323DBG(( DEBUG_LEVEL_ERROR,
"error reject call 0x%08lx.", this ));
}
// change call state to disconnected
ChangeCallState(LINECALLSTATE_DISCONNECTED, dwDisconnectMode);
break;
case LINECALLSTATE_DIALING:
// change call state to disconnected
ChangeCallState(LINECALLSTATE_DISCONNECTED, dwDisconnectMode);
break;
case LINECALLSTATE_DISCONNECTED:
//
// disconnected but still need to clean up
//
break;
case LINECALLSTATE_IDLE:
//
// call object already idle
//
if( (m_dwCallType == CALLTYPE_NORMAL) &&
(m_dwStateMachine == Q931_SETUP_RECVD) )
{
if( SendQ931Message( NO_INVOKEID,
0,
0,
RELEASECOMPLMESSAGETYPE,
NO_H450_APDU ))
{
H323DBG(( DEBUG_LEVEL_ERROR,
"error cancelling call 0x%08lx.", this ));
}
else
{
H323DBG(( DEBUG_LEVEL_ERROR,
"error reject call 0x%08lx.", this ));
}
}
DropSupplementaryServicesCalls();
return TRUE;
}
if( ( (m_dwCallType & CALLTYPE_TRANSFEREDDEST) && m_hdRelatedCall ) ||
( (m_dwCallType & CALLTYPE_TRANSFEREDSRC ) && m_hdRelatedCall ) )
{
m_dwCallState = LINECALLSTATE_IDLE;
}
else
{
// Tell the MSP to stop streaming.
SendMSPMessage( SP_MSG_CallShutdown, 0, 0, NULL );
// change call state to idle
ChangeCallState( LINECALLSTATE_IDLE, 0 );
}
if( (m_dwCallType & CALLTYPE_TRANSFEREDSRC ) && m_hdRelatedCall )
{
//drop the primary call
if( !QueueTAPILineRequest(
TSPI_CLOSE_CALL,
m_hdRelatedCall,
NULL,
LINEDISCONNECTMODE_NORMAL,
NULL ) )
{
H323DBG((DEBUG_LEVEL_ERROR, "could not post H323 close event"));
}
}
H323DBG(( DEBUG_LEVEL_TRACE, "DropCall exited:%p.", this ));
// success
return TRUE;
}
void
CH323Call::DropSupplementaryServicesCalls()
{
if( (m_dwCallType & CALLTYPE_FORWARDCONSULT) ||
(m_dwCallType & CALLTYPE_DIVERTED_SERVED) ||
(m_dwCallType & CALLTYPE_DIVERTEDSRC) ||
(m_dwCallType & CALLTYPE_DIVERTEDSRC_NOROUTING) )
{
if( m_dwQ931Flags & Q931_CALL_CONNECTED )
{
if( SendQ931Message( NO_INVOKEID,
0,
0,
RELEASECOMPLMESSAGETYPE,
NO_H450_APDU ))
{
m_dwStateMachine = Q931_RELEASE_SENT;
H323DBG(( DEBUG_LEVEL_VERBOSE, "call 0x%08lx rejected.", this ));
}
}
g_pH323Line->m_fForwardConsultInProgress = FALSE;
}
if( (m_dwCallType & CALLTYPE_FORWARDCONSULT) &&
(m_dwOrigin == LINECALLORIGIN_OUTBOUND ) )
{
//inform the user about failure of line forward operation
if( m_dwCallDiversionState != H4503_CHECKRESTRICTION_SUCC )
{
(*g_pfnLineEventProc)(
g_pH323Line->m_htLine,
(HTAPICALL)NULL,
(DWORD)LINE_ADDRESSSTATE,
(DWORD)LINEADDRESSSTATE_FORWARD,
(DWORD)LINEADDRESSSTATE_FORWARD,
(DWORD)0
);
}
}
if( m_dwCallType & CALLTYPE_DIVERTEDSRC )
{
ChangeCallState( LINECALLSTATE_IDLE, 0 );
}
}
//!!always called in a lock
BOOL
CH323Call::HandleConnectMessage(
IN Q931_CONNECT_ASN *pConnectASN
)
{
PH323_CALL pPrimaryCall = NULL;
H323DBG(( DEBUG_LEVEL_TRACE, "HandleConnectMessage entered:%p.", this ));
if( pConnectASN->fNonStandardDataPresent )
{
//add user user info
if( AddU2UNoAlloc( U2U_INBOUND,
pConnectASN->nonStandardData.sData.wOctetStringLength,
pConnectASN->nonStandardData.sData.pOctetString ) == TRUE )
{
H323DBG(( DEBUG_LEVEL_VERBOSE,
"user user info available in CONNECT PDU." ));
if( !(m_dwCallType & CALLTYPE_TRANSFEREDSRC) )
{
// signal incoming
PostLineEvent (
LINE_CALLINFO,
LINECALLINFOSTATE_USERUSERINFO, 0, 0 );
}
//don't release the data buffer
pConnectASN->fNonStandardDataPresent = FALSE;
}
else
{
H323DBG(( DEBUG_LEVEL_WARNING,
"could not save incoming user user info." ));
//memory failure : shutdown the H323 call
CloseCall( 0 );
goto cleanup;
}
}
//get the vendor info
if( pConnectASN->EndpointType.pVendorInfo )
{
FreeVendorInfo( &m_peerVendorInfo );
m_peerVendorInfo = pConnectASN->VendorInfo;
pConnectASN->EndpointType.pVendorInfo = NULL;
}
if( pConnectASN->h245AddrPresent )
{
m_peerH245Addr = pConnectASN->h245Addr;
}
//copy the fast start proposal
if( pConnectASN->fFastStartPresent &&
(m_dwFastStart!=FAST_START_NOTAVAIL) )
{
if( m_pPeerFastStart )
{
//we had received fast start params in previous proceeding
//or alerting message
FreeFastStart( m_pPeerFastStart );
}
m_pPeerFastStart = pConnectASN->pFastStart;
m_dwFastStart = FAST_START_AVAIL;
//we are keeping a reference to the fast start list so don't release it
pConnectASN->pFastStart = NULL;
}
else
{
m_dwFastStart = FAST_START_NOTAVAIL;
}
if( ( (m_dwCallType & CALLTYPE_TRANSFEREDSRC)||
(m_dwCallType & CALLTYPE_DIVERTEDTRANSFERED) ) && m_hdRelatedCall )
{
QueueSuppServiceWorkItem( SWAP_REPLACEMENT_CALL,
m_hdCall, (ULONG_PTR)m_hdRelatedCall );
}
else
{
//start H245
SendMSPStartH245( NULL, NULL );
SendMSPMessage( SP_MSG_ConnectComplete, 0, 0, NULL );
}
//If we join MCU we get the conference ID of the conference we
//joined and not the one that we sent in Setup message.
if( IsEqualConferenceID( &pConnectASN->ConferenceID ) == FALSE )
{
H323DBG ((DEBUG_LEVEL_ERROR,
"OnReceiveConnect: We received different conference id." ));
m_ConferenceID = pConnectASN->ConferenceID;
}
//tell TAPI about state change
ChangeCallState( LINECALLSTATE_CONNECTED, 0 );
FreeConnectASN( pConnectASN );
H323DBG(( DEBUG_LEVEL_TRACE, "HandleConnectMessage exited:%p.", this ));
return TRUE;
cleanup:
FreeConnectASN( pConnectASN );
return FALSE;
}
//!!always called in a lock
void
CH323Call::HandleAlertingMessage(
IN Q931_ALERTING_ASN * pAlertingASN
)
{
H323DBG(( DEBUG_LEVEL_TRACE, "HandleAlertingMessage entered:%p.", this ));
if( pAlertingASN->fNonStandardDataPresent )
{
// add user user info
if( AddU2UNoAlloc( U2U_INBOUND,
pAlertingASN->nonStandardData.sData.wOctetStringLength,
pAlertingASN->nonStandardData.sData.pOctetString ) == TRUE )
{
H323DBG(( DEBUG_LEVEL_VERBOSE,
"user user info available in ALERT PDU." ));
// signal incoming
if( !(m_dwCallType & CALLTYPE_TRANSFEREDSRC) )
{
PostLineEvent (
LINE_CALLINFO,
LINECALLINFOSTATE_USERUSERINFO, 0, 0 );
}
//don't release the data buffer
pAlertingASN->fNonStandardDataPresent = FALSE;
}
else
{
H323DBG(( DEBUG_LEVEL_WARNING,
"could not save incoming user user info." ));
//memory failure : shutdown the H323 call
CloseCall( 0 );
return;
}
}
if( pAlertingASN->fH245AddrPresent )
{
m_peerH245Addr = pAlertingASN->h245Addr;
}
if( pAlertingASN->fFastStartPresent &&
(m_dwFastStart!=FAST_START_NOTAVAIL) )
{
if( m_pPeerFastStart )
{
//we had received fast start params in previous proceeding
//or alerting message
FreeFastStart( m_pPeerFastStart );
}
m_pPeerFastStart = pAlertingASN->pFastStart;
m_dwFastStart = FAST_START_AVAIL;
//we are keeping a reference to the fast start list so don't release it
pAlertingASN->pFastStart = NULL;
pAlertingASN->fFastStartPresent = FALSE;
}
//for DIVERTEDSRC, call its ok to tell TAPI about this state
ChangeCallState( LINECALLSTATE_RINGBACK, 0 );
/*if( pAlertingASN->fH245AddrPresent && !(m_dwFlags & H245_START_MSG_SENT) )
{
//start early H245
SendMSPStartH245( NULL, NULL);
}*/
FreeAlertingASN( pAlertingASN );
H323DBG(( DEBUG_LEVEL_TRACE, "HandleAlertingMessage exited:%p.", this ));
return;
}
//!!must be always called in a lock
BOOL
CH323Call::HandleSetupMessage(
IN Q931MESSAGE* pMessage
)
{
PH323_ALIASITEM pwszDivertedToAlias = NULL;
WCHAR * pwszAliasName = NULL;
WORD wAliasLength = 0;
H323DBG(( DEBUG_LEVEL_TRACE, "HandleSetupMessage entered:%p.", this ));
if( m_pCallerAliasNames && (m_pCallerAliasNames -> wCount > 0) )
{
pwszAliasName = m_pCallerAliasNames->pItems[0].pData;
wAliasLength = (m_pCallerAliasNames->pItems[0].wDataLength+1)
* sizeof(WCHAR);
//H323DBG(( DEBUG_LEVEL_ERROR, "Caller alias count:%d : %p", m_pCallerAliasNames->wCount, this ));
}
pwszDivertedToAlias = g_pH323Line->CallToBeDiverted(
pwszAliasName,
wAliasLength,
LINEFORWARDMODE_UNCOND | LINEFORWARDMODE_UNCONDSPECIFIC );
if( pwszDivertedToAlias )
{
if( !InitiateCallDiversion( pwszDivertedToAlias, DiversionReason_cfu ) )
{
return FALSE;
}
return TRUE;
}
//send the proceeding message to the peer if not already sent by the GK
//SendProceeding();
if(RasIsRegistered())
{
if( !SendARQ( NOT_RESEND_SEQ_NUM ) )
{
return FALSE;
}
//copy the data to be sent in preparetoanswer message
if( m_prepareToAnswerMsgData.pbBuffer )
delete m_prepareToAnswerMsgData.pbBuffer;
ZeroMemory( (PVOID)&m_prepareToAnswerMsgData, sizeof(BUFFERDESCR) );
m_prepareToAnswerMsgData.pbBuffer =
(BYTE*)new char[pMessage->UserToUser.wUserInfoLen];
if( m_prepareToAnswerMsgData.pbBuffer == NULL )
{
return FALSE;
}
CopyMemory( (PVOID)m_prepareToAnswerMsgData.pbBuffer,
(PVOID)pMessage->UserToUser.pbUserInfo,
pMessage->UserToUser.wUserInfoLen );
m_prepareToAnswerMsgData.dwLength = pMessage->UserToUser.wUserInfoLen;
}
else
{
if( (m_dwCallType & CALLTYPE_TRANSFEREDDEST) && m_hdRelatedCall )
{
MSPMessageData* pMSPMessageData = new MSPMessageData;
if( pMSPMessageData == NULL )
{
return FALSE;
}
pMSPMessageData->hdCall = m_hdRelatedCall;
pMSPMessageData->messageType = SP_MSG_PrepareToAnswer;
pMSPMessageData->pbEncodedBuf =
new BYTE[pMessage->UserToUser.wUserInfoLen];
if( pMSPMessageData->pbEncodedBuf == NULL )
{
delete pMSPMessageData;
return FALSE;
}
CopyMemory( pMSPMessageData->pbEncodedBuf,
(PVOID)pMessage->UserToUser.pbUserInfo,
pMessage->UserToUser.wUserInfoLen );
pMSPMessageData->wLength = pMessage->UserToUser.wUserInfoLen;
pMSPMessageData->hReplacementCall = m_hdCall;
if( !QueueUserWorkItem( SendMSPMessageOnRelatedCall,
pMSPMessageData, WT_EXECUTEDEFAULT ) )
{
delete pMSPMessageData->pbEncodedBuf;
delete pMSPMessageData;
return FALSE;
}
}
else
{
// signal incoming call
_ASSERTE(!m_htCall);
PostLineEvent (
LINE_NEWCALL,
(DWORD_PTR)m_hdCall,
(DWORD_PTR)&m_htCall, 0);
_ASSERTE( m_htCall );
if( m_htCall == NULL )
return FALSE;
if( IsListEmpty(&m_IncomingU2U) == FALSE )
{
// signal incoming
PostLineEvent (
LINE_CALLINFO,
LINECALLINFOSTATE_USERUSERINFO, 0, 0);
}
ChangeCallState( LINECALLSTATE_OFFERING, 0 );
//Send the new call message to the unspecified MSP
SendMSPMessage( SP_MSG_PrepareToAnswer,
pMessage->UserToUser.pbUserInfo,
pMessage->UserToUser.wUserInfoLen, NULL );
}
}
H323DBG(( DEBUG_LEVEL_TRACE, "HandleSetupMessage exited:%p.", this ));
return TRUE;
}
BOOL
CH323Call::HandleCallDiversionFacility(
PH323_ADDR pAlternateAddress )
{
PSTR pszAlias;
WCHAR pwszAliasName[H323_MAXDESTNAMELEN];
in_addr addr;
if( m_pCallReroutingInfo == NULL )
{
m_pCallReroutingInfo = new CALLREROUTINGINFO;
if( m_pCallReroutingInfo == NULL )
{
return FALSE;
}
ZeroMemory( (PVOID)m_pCallReroutingInfo, sizeof(CALLREROUTINGINFO) );
}
m_pCallReroutingInfo->diversionCounter = 1;
m_pCallReroutingInfo->diversionReason = DiversionReason_cfu;
//free any previous divertedTo alias
if( m_pCallReroutingInfo->divertedToNrAlias )
{
FreeAliasNames( m_pCallReroutingInfo->divertedToNrAlias );
m_pCallReroutingInfo->divertedToNrAlias = NULL;
}
addr.S_un.S_addr = htonl( pAlternateAddress->Addr.IP_Binary.dwAddr );
pszAlias = inet_ntoa( addr );
if( pszAlias == NULL )
return FALSE;
m_pCallReroutingInfo->divertedToNrAlias = new H323_ALIASNAMES;
if( m_pCallReroutingInfo->divertedToNrAlias == NULL )
{
return FALSE;
}
ZeroMemory( m_pCallReroutingInfo->divertedToNrAlias,
sizeof(H323_ALIASNAMES) );
MultiByteToWideChar(
GetACP(),
MB_PRECOMPOSED,
pszAlias,
strlen(pszAlias)+1,
pwszAliasName,
H323_MAXDESTNAMELEN
);
if( !AddAliasItem( m_pCallReroutingInfo->divertedToNrAlias,
pwszAliasName, h323_ID_chosen ) )
{
delete m_pCallReroutingInfo->divertedToNrAlias;
m_pCallReroutingInfo->divertedToNrAlias = NULL;
return FALSE;
}
m_CalleeAddr = *pAlternateAddress;
if( m_pCalleeAliasNames && m_pCalleeAliasNames->wCount )
{
m_pCallReroutingInfo->divertingNrAlias = new H323_ALIASNAMES;
if( m_pCallReroutingInfo->divertingNrAlias != NULL )
{
ZeroMemory( (PVOID)m_pCallReroutingInfo->divertingNrAlias,
sizeof(H323_ALIASNAMES) );
if( !AddAliasItem( m_pCallReroutingInfo->divertingNrAlias,
m_pCalleeAliasNames->pItems[0].pData,
m_pCalleeAliasNames->pItems[0].wType ) )
{
delete m_pCallReroutingInfo->divertingNrAlias;
m_pCallReroutingInfo->divertingNrAlias = NULL;
}
}
}
m_dwCallType |= CALLTYPE_DIVERTEDSRC;
m_dwCallDiversionState = H4503_CALLREROUTING_RECVD;
H323DBG(( DEBUG_LEVEL_TRACE, "HandleCallDiversionFacility exited:%p.",
this ));
return TRUE;
}
BOOL
CH323Call::HandleCallDiversionFacility(
PH323_ALIASNAMES pAliasList )
{
if( !m_pCallReroutingInfo )
{
m_pCallReroutingInfo = new CALLREROUTINGINFO;
if( m_pCallReroutingInfo == NULL )
{
return FALSE;
}
ZeroMemory( (PVOID)m_pCallReroutingInfo, sizeof(CALLREROUTINGINFO) );
}
m_pCallReroutingInfo->diversionCounter = 1;
m_pCallReroutingInfo->diversionReason = DiversionReason_cfu;
if( m_pCallReroutingInfo->divertedToNrAlias )
{
FreeAliasNames( m_pCallReroutingInfo->divertedToNrAlias );
m_pCallReroutingInfo->divertedToNrAlias = NULL;
}
m_pCallReroutingInfo->divertedToNrAlias = pAliasList;
if( m_pCalleeAliasNames && m_pCalleeAliasNames->wCount )
{
m_pCallReroutingInfo->divertingNrAlias = new H323_ALIASNAMES;
if( m_pCallReroutingInfo->divertingNrAlias != NULL )
{
ZeroMemory( (PVOID)m_pCallReroutingInfo->divertingNrAlias,
sizeof(H323_ALIASNAMES) );
if( !AddAliasItem( m_pCallReroutingInfo->divertingNrAlias,
m_pCalleeAliasNames->pItems[0].pData,
m_pCalleeAliasNames->pItems[0].wType ) )
{
delete m_pCallReroutingInfo->divertingNrAlias;
m_pCallReroutingInfo->divertingNrAlias = NULL;
}
}
}
m_dwCallType |= CALLTYPE_DIVERTEDSRC;
m_dwCallDiversionState = H4503_CALLREROUTING_RECVD;
H323DBG(( DEBUG_LEVEL_TRACE, "HandleCallDiversionFacility exited:%p.",
this ));
return TRUE;
}
BOOL
CH323Call::HandleTransferFacility(
PH323_ALIASNAMES pAliasList )
{
H323DBG(( DEBUG_LEVEL_TRACE, "HandleTransferFacility entered:%p.", this ));
//argument.callIdentity
ZeroMemory( (PVOID)m_pCTCallIdentity, sizeof(m_pCTCallIdentity) );
//argument.reroutingNumber
FreeAliasNames( m_pTransferedToAlias );
m_pTransferedToAlias = pAliasList;
m_dwCallType |= CALLTYPE_TRANSFERED_PRIMARY;
m_dwCallDiversionState = H4502_CTINITIATE_RECV;
//queue an event for creating a new call
if( !QueueSuppServiceWorkItem( TSPI_DIAL_TRNASFEREDCALL, m_hdCall,
(ULONG_PTR)m_pTransferedToAlias ))
{
H323DBG(( DEBUG_LEVEL_TRACE, "could not post dial transfer event." ));
}
H323DBG(( DEBUG_LEVEL_TRACE, "HandleTransferFacility entered:%p.", this ));
return TRUE;
}
BOOL
CH323Call::HandleTransferFacility(
PH323_ADDR pAlternateAddress )
{
PSTR pszAlias;
WCHAR pwszAliasName[H323_MAXDESTNAMELEN];
in_addr addr;
H323DBG(( DEBUG_LEVEL_TRACE, "HandleTransferFacility entered:%p.", this ));
//argument.callIdentity
ZeroMemory( (PVOID)m_pCTCallIdentity, sizeof(m_pCTCallIdentity) );
//argument.reroutingNumber
//free any previous divertedTo alias
FreeAliasNames( m_pTransferedToAlias );
addr.S_un.S_addr = htonl( pAlternateAddress->Addr.IP_Binary.dwAddr );
pszAlias = inet_ntoa( addr );
if( pszAlias == NULL )
{
return FALSE;
}
m_pTransferedToAlias = new H323_ALIASNAMES;
if( m_pTransferedToAlias == NULL )
{
return FALSE;
}
ZeroMemory( m_pTransferedToAlias, sizeof(H323_ALIASNAMES) );
MultiByteToWideChar(
GetACP(),
MB_PRECOMPOSED,
pszAlias,
strlen(pszAlias)+1,
pwszAliasName,
H323_MAXDESTNAMELEN
);
if( !AddAliasItem( m_pTransferedToAlias, pwszAliasName, h323_ID_chosen ) )
{
delete m_pTransferedToAlias;
m_pTransferedToAlias = NULL;
return FALSE;
}
m_CalleeAddr = *pAlternateAddress;
m_dwCallType |= CALLTYPE_TRANSFERED_PRIMARY;
m_dwCallDiversionState = H4502_CTINITIATE_RECV;
//queue an event for creating a new call
if( !QueueSuppServiceWorkItem( TSPI_DIAL_TRNASFEREDCALL, m_hdCall,
(ULONG_PTR)m_pTransferedToAlias ))
{
H323DBG(( DEBUG_LEVEL_TRACE, "could not post dial transfer event." ));
}
H323DBG(( DEBUG_LEVEL_TRACE, "HandleTransferFacility entered:%p.", this ));
return TRUE;
}
//!!always called in a lock
void
CH323Call::HandleFacilityMessage(
IN DWORD dwInvokeID,
IN Q931_FACILITY_ASN * pFacilityASN
)
{
H323DBG(( DEBUG_LEVEL_TRACE, "HandleFacilityMessage entered:%p.", this ));
if( pFacilityASN->fNonStandardDataPresent )
{
// add user user info
if( AddU2UNoAlloc( U2U_INBOUND,
pFacilityASN->nonStandardData.sData.wOctetStringLength,
pFacilityASN->nonStandardData.sData.pOctetString ) == TRUE )
{
H323DBG(( DEBUG_LEVEL_VERBOSE,
"user user info available in ALERT PDU." ));
// signal incoming
if( !(m_dwCallType & CALLTYPE_TRANSFEREDSRC) )
{
PostLineEvent (
LINE_CALLINFO,
LINECALLINFOSTATE_USERUSERINFO, 0, 0);
}
//don't release the data buffer
pFacilityASN->fNonStandardDataPresent = FALSE;
}
else
{
H323DBG(( DEBUG_LEVEL_WARNING,
"could not save incoming user user info." ));
//memory failure : shutdown the H323 call
CloseCall( 0 );
return;
}
}
if( (pFacilityASN->bReason == callForwarded_chosen) ||
(pFacilityASN->bReason == FacilityReason_routeCallToGatekeeper_chosen) ||
(pFacilityASN->bReason == routeCallToMC_chosen) )
{
if( pFacilityASN->pAlternativeAliasList != NULL )
{
if( m_dwCallState == LINECALLSTATE_CONNECTED )
{
HandleTransferFacility( pFacilityASN->pAlternativeAliasList );
//don't free the alias list
pFacilityASN->pAlternativeAliasList = NULL;
}
else if( m_dwCallState != LINECALLSTATE_DISCONNECTED )
{
//redirect the call if not yet connected
if( HandleCallDiversionFacility(
pFacilityASN->pAlternativeAliasList ) )
{
OnCallReroutingReceive( NO_INVOKEID );
//don't free the alias list
pFacilityASN->pAlternativeAliasList = NULL;
}
}
}
else if( pFacilityASN->fAlternativeAddressPresent )
{
if( m_dwCallState == LINECALLSTATE_CONNECTED )
{
HandleTransferFacility( &pFacilityASN->AlternativeAddr );
}
else if( m_dwCallState != LINECALLSTATE_DISCONNECTED )
{
//redirect the call if not yet connected
if( HandleCallDiversionFacility( &pFacilityASN->AlternativeAddr ) )
{
OnCallReroutingReceive( NO_INVOKEID );
}
}
}
}
//Handle H.450 APDU
if( pFacilityASN->dwH450APDUType == DIVERTINGLEGINFO1_OPCODE )
{
if( m_dwOrigin != LINECALLORIGIN_OUTBOUND )
{
return;
}
if( m_pCallReroutingInfo->fPresentAllow )
{
PostLineEvent (
LINE_CALLINFO,
LINECALLINFOSTATE_REDIRECTINGID, 0, 0);
}
}
else if( pFacilityASN->dwH450APDUType == CALLREROUTING_OPCODE )
{
OnCallReroutingReceive( dwInvokeID );
}
else if( pFacilityASN->dwH450APDUType == REMOTEHOLD_OPCODE )
{
if( m_fRemoteHoldInitiated )
{
//Hold();
m_fRemoteHoldInitiated = FALSE;
}
}
else if( pFacilityASN->dwH450APDUType == REMOTERETRIEVE_OPCODE )
{
if( m_fRemoteRetrieveInitiated )
{
//UnHold();
m_fRemoteRetrieveInitiated = FALSE;
}
}
else if( pFacilityASN->fH245AddrPresent )
{
m_peerH245Addr = pFacilityASN->h245Addr;
H323DBG(( DEBUG_LEVEL_TRACE, "H245 address received in facility." ));
//If Q931 call already connected then send another StartH245.
if( m_dwCallState == LINECALLSTATE_CONNECTED )
{
SendMSPStartH245( NULL, NULL );
}
}
H323DBG(( DEBUG_LEVEL_TRACE, "HandleFacilityMessage exited:%p.", this ));
return;
}
void
CH323Call::SetNewCallInfo(
HANDLE hConnWait,
HANDLE hWSAEvent,
DWORD dwState
)
{
H323DBG(( DEBUG_LEVEL_TRACE, "SetNewCallInfo entered." ));
Lock();
m_hTransportWait = hConnWait;
m_hTransport = hWSAEvent;
SetQ931CallState( dwState );
Unlock();
H323DBG(( DEBUG_LEVEL_TRACE, "SetNewCallInfo exited." ));
}
//!!no need to call in a lock
void
CH323Call::SetQ931CallState( DWORD dwState )
{
H323DBG(( DEBUG_LEVEL_TRACE, "SetQ931CallState entered." ));
//turn off the current state
m_dwQ931Flags &= ~(Q931_CALL_CONNECTING |
Q931_CALL_CONNECTED |
Q931_CALL_DISCONNECTED );
//set the new state
m_dwQ931Flags |= dwState;
H323DBG(( DEBUG_LEVEL_TRACE, "SetQ931CallState exited." ));
}
void
CH323Call::DialCall()
{
H323DBG(( DEBUG_LEVEL_TRACE, "DialCall entered:%p.", this ));
Lock();
ChangeCallState( LINECALLSTATE_DIALING, 0);
if( RasIsRegistered() )
{
if( !SendARQ( NOT_RESEND_SEQ_NUM ) )
{
//If a forward consult call then enable theforwarding anyway.
if( (m_dwCallType & CALLTYPE_FORWARDCONSULT )&&
(m_dwOrigin == LINECALLORIGIN_OUTBOUND ) )
{
//Success of forwarding
EnableCallForwarding();
}
CloseCall( 0 );
}
}
else
{
if( !PlaceCall() )
{
//If a forward consult call then enable theforwarding anyway.
if( (m_dwCallType & CALLTYPE_FORWARDCONSULT )&&
(m_dwOrigin == LINECALLORIGIN_OUTBOUND ) )
{
//Success of forwarding
EnableCallForwarding();
}
CloseCall( LINEDISCONNECTMODE_UNREACHABLE );
}
}
Unlock();
H323DBG(( DEBUG_LEVEL_TRACE, "DialCall exited:%p.", this ));
}
//!!always called in a lock
void
CH323Call::MakeCall()
{
H323DBG(( DEBUG_LEVEL_TRACE, "MakeCall entered:%p.", this ));
ChangeCallState( LINECALLSTATE_DIALING, 0 );
// resolve dialable into local and remote address
if( !RasIsRegistered() &&
!ResolveAddress( GetDialableAddress() ) )
{
CloseCall( LINEDISCONNECTMODE_BADADDRESS );
}
else
{
if( RasIsRegistered() )
{
if( !SendARQ( NOT_RESEND_SEQ_NUM ) )
{
//If a forward consult call then enable theforwarding anyway.
if( (m_dwCallType & CALLTYPE_FORWARDCONSULT )&&
(m_dwOrigin == LINECALLORIGIN_OUTBOUND ) )
{
//Success of forwarding
EnableCallForwarding();
}
CloseCall( 0 );
}
}
else
{
if( !PlaceCall() )
{
//If a forward consult call then enable theforwarding anyway.
if( (m_dwCallType & CALLTYPE_FORWARDCONSULT )&&
(m_dwOrigin == LINECALLORIGIN_OUTBOUND ) )
{
//Success of forwarding
EnableCallForwarding();
}
CloseCall( LINEDISCONNECTMODE_UNREACHABLE );
}
}
}
H323DBG(( DEBUG_LEVEL_TRACE, "MakeCall exited:%p.", this ));
}
//!!always called in a lock
void
CH323Call::HandleProceedingMessage(
IN Q931_ALERTING_ASN * pProceedingASN
)
{
H323DBG(( DEBUG_LEVEL_TRACE, "HandleProceedingMessage entered:%p.", this ));
if( pProceedingASN->fNonStandardDataPresent )
{
// add user user info
if( AddU2UNoAlloc( U2U_INBOUND,
pProceedingASN->nonStandardData.sData.wOctetStringLength,
pProceedingASN->nonStandardData.sData.pOctetString ) == TRUE )
{
H323DBG(( DEBUG_LEVEL_VERBOSE,
"user user info available in ALERT PDU." ));
// signal incoming
if( !(m_dwCallType & CALLTYPE_TRANSFEREDSRC) )
{
PostLineEvent (
LINE_CALLINFO,
LINECALLINFOSTATE_USERUSERINFO, 0, 0);
}
//don't release the data buffer
pProceedingASN->fNonStandardDataPresent = FALSE;
}
else
{
H323DBG(( DEBUG_LEVEL_WARNING,
"could not save incoming user user info." ));
//memory failure : shutdown the H323 call
CloseCall( 0 );
return;
}
}
if( pProceedingASN->fH245AddrPresent )
{
m_peerH245Addr = pProceedingASN->h245Addr;
}
if( pProceedingASN->fFastStartPresent &&
(m_dwFastStart!=FAST_START_NOTAVAIL) )
{
if( m_pPeerFastStart )
{
//we had received fast start params in previous proceeding
//or alerting message
FreeFastStart( m_pPeerFastStart );
}
m_pPeerFastStart = pProceedingASN->pFastStart;
m_dwFastStart = FAST_START_AVAIL;
//we are keeping a reference to the fast start list so don't release it
pProceedingASN->pFastStart = NULL;
pProceedingASN->fFastStartPresent = FALSE;
}
/*
if( pProceedingASN->fH245AddrPresent && !(m_dwFlags & H245_START_MSG_SENT) )
{
//start early H245
SendMSPStartH245( NULL, NULL );
}*/
FreeProceedingASN( pProceedingASN );
H323DBG(( DEBUG_LEVEL_TRACE, "HandleProceedingMessage exited:%p.", this ));
return;
}
//!!always called in a lock
BOOL
CH323Call::HandleReleaseMessage(
IN Q931_RELEASE_COMPLETE_ASN *pReleaseASN
)
{
DWORD dwDisconnectMode = LINEDISCONNECTMODE_NORMAL;
H323DBG(( DEBUG_LEVEL_TRACE, "HandleReleaseMessage entered:%p.", this ));
if( (m_dwCallType & CALLTYPE_TRANSFERED_PRIMARY) &&
(m_hdRelatedCall != NULL) )
{
return QueueSuppServiceWorkItem( DROP_PRIMARY_CALL,
m_hdRelatedCall, (ULONG_PTR)m_hdCall );
}
//change the state to disconnected before callong drop call.
//This will ensure that release message is not sent to the peer
ChangeCallState( LINECALLSTATE_DISCONNECTED, 0 );
//release non standard data
if( pReleaseASN->fNonStandardDataPresent )
{
delete pReleaseASN->nonStandardData.sData.pOctetString;
pReleaseASN->nonStandardData.sData.pOctetString = NULL;
}
//Should we drop the primary call if the transfered call in rejected?
if( (m_dwCallType == CALLTYPE_TRANSFEREDSRC) && m_hdRelatedCall )
{
if( !QueueTAPILineRequest(
TSPI_CLOSE_CALL,
m_hdRelatedCall,
NULL,
LINEDISCONNECTMODE_NORMAL,
NULL ) )
{
H323DBG((DEBUG_LEVEL_ERROR, "could not post H323 close event"));
}
}
//close call
if( m_dwCallState != LINECALLSTATE_CONNECTED )
{
dwDisconnectMode = LINEDISCONNECTMODE_REJECT;
}
CloseCall( dwDisconnectMode );
H323DBG(( DEBUG_LEVEL_TRACE, "HandleReleaseMessage exited:%p.", this ));
return TRUE;
}
//never call in lock
BOOL
CH323Call::InitializeIncomingCall(
IN Q931_SETUP_ASN* pSetupASN,
IN DWORD dwCallType,
IN WORD wCallRef
)
{
PH323_CONFERENCE pConf;
WCHAR* wszMachineName;
H323DBG((DEBUG_LEVEL_TRACE, "InitializeIncomingCall entered:%p.",this));
//bind outgoing call
pConf = CreateConference( &(pSetupASN->ConferenceID) );
if( pConf == NULL )
{
H323DBG(( DEBUG_LEVEL_ERROR, "could not create conference." ));
goto cleanup;
}
if( !g_pH323Line -> GetH323ConfTable() -> Add( pConf ) )
{
H323DBG(( DEBUG_LEVEL_ERROR,
"could not add conf to conf table." ));
// failure
goto cleanup;
}
// save caller transport address
if( !GetPeerAddress(&m_CallerAddr) )
{
goto cleanup;
}
if( !GetHostAddress(&m_CalleeAddr) )
{
goto cleanup;
}
//get endpoint info
m_peerEndPointType = pSetupASN->EndpointType;
//get the vendor info
if( pSetupASN->EndpointType.pVendorInfo )
{
m_peerVendorInfo = pSetupASN->VendorInfo;
//we have copied the vendor info pointers. So dont release
//the pointers in the ASN's vendor info struct
pSetupASN->EndpointType.pVendorInfo = NULL;
}
if( pSetupASN -> fCallIdentifierPresent )
{
m_callIdentifier = pSetupASN->callIdentifier;
}
else
{
int iresult = UuidCreate( &m_callIdentifier );
if( (iresult != RPC_S_OK) && (iresult !=RPC_S_UUID_LOCAL_ONLY) )
{
goto cleanup;
}
}
_ASSERTE( !m_pPeerFastStart );
if( pSetupASN->fFastStartPresent &&
(m_dwFastStart!=FAST_START_NOTAVAIL) )
{
m_pPeerFastStart = pSetupASN->pFastStart;
m_dwFastStart = FAST_START_PEER_AVAIL;
//we are keeping a reference to the fast start list so don't release it
pSetupASN->pFastStart = NULL;
pSetupASN->fFastStartPresent = FALSE;
}
else
{
m_dwFastStart = FAST_START_NOTAVAIL;
}
//get the alias names
if( pSetupASN->pCalleeAliasList )
{
_ASSERTE( m_pCalleeAliasNames );
delete m_pCalleeAliasNames;
m_pCalleeAliasNames = pSetupASN->pCalleeAliasList;
pSetupASN->pCalleeAliasList = NULL;
}
else
{
if( RasIsRegistered() )
{
PH323_ALIASNAMES pAliasList = RASGetRegisteredAliasList();
AddAliasItem( m_pCalleeAliasNames,
pAliasList->pItems[0].pData,
pAliasList->pItems[0].wType );
}
else
{
wszMachineName = g_pH323Line->GetMachineName();
//set the value for m_pCalleeAliasNames
AddAliasItem( m_pCalleeAliasNames,
(BYTE*)(wszMachineName),
sizeof(WCHAR) * (wcslen(wszMachineName) + 1 ),
h323_ID_chosen );
}
}
_ASSERTE( m_pCallerAliasNames );
delete m_pCallerAliasNames;
m_pCallerAliasNames = NULL;
if( pSetupASN->pCallerAliasList )
{
m_pCallerAliasNames = pSetupASN->pCallerAliasList;
pSetupASN->pCallerAliasList = NULL;
//H323DBG(( DEBUG_LEVEL_ERROR, "Caller alias count:%d : %p", m_pCallerAliasNames->wCount, this ));
}
if( pSetupASN->pExtraAliasList )
{
m_pPeerExtraAliasNames = pSetupASN->pExtraAliasList;
pSetupASN->pExtraAliasList = NULL;
}
//non -standard info
if( pSetupASN->fNonStandardDataPresent )
{
// add user user info
if( AddU2UNoAlloc( U2U_INBOUND,
pSetupASN->nonStandardData.sData.wOctetStringLength,
pSetupASN->nonStandardData.sData.pOctetString ) == TRUE )
{
H323DBG(( DEBUG_LEVEL_VERBOSE,
"user user info available in Setup PDU." ));
//don't release the data buffer
pSetupASN->fNonStandardDataPresent = FALSE;
}
else
{
H323DBG(( DEBUG_LEVEL_WARNING,
"could not save incoming user user info." ));
goto cleanup;
}
}
if( pSetupASN->fSourceAddrPresent )
{
m_CallerAddr = pSetupASN->sourceAddr;
}
m_dwCallType = dwCallType;
if( wCallRef )
{
m_wQ931CallRef = (wCallRef | 0x8000);
}
//clear incoming modes
m_dwIncomingModes = 0;
//outgoing modes will be finalized during H.245 phase
m_dwOutgoingModes = g_pH323Line->GetMediaModes() | LINEMEDIAMODE_UNKNOWN;
//save media modes specified
m_dwRequestedModes = g_pH323Line->GetMediaModes();
H323DBG(( DEBUG_LEVEL_TRACE, "InitializeIncomingCall exited:%p.", this ));
return TRUE;
cleanup:
return FALSE;
}
//!!always called in a lock
BOOL
CH323Call::ChangeCallState(
IN DWORD dwCallState,
IN DWORD dwCallStateMode
)
/*++
Routine Description:
Reports call state of specified call object.
Arguments:
dwCallState - Specifies new state of call object.
dwCallStateMode - Specifies new state mode of call object.
Return Values:
Returns true if successful.
--*/
{
H323DBG(( DEBUG_LEVEL_VERBOSE, "call 0x%08lx %s. state mode: 0x%08lx.",
this, H323CallStateToString(dwCallState), dwCallStateMode ));
// save new call state
m_dwCallState = dwCallState;
m_dwCallStateMode = dwCallStateMode;
if(
((m_dwCallType & CALLTYPE_TRANSFEREDDEST) && m_hdRelatedCall ) ||
((m_dwCallType & CALLTYPE_TRANSFEREDSRC ) && m_hdRelatedCall ) ||
(m_dwCallType & CALLTYPE_FORWARDCONSULT )
)
{
return TRUE;
}
// report call status
PostLineEvent (
LINE_CALLSTATE,
m_dwCallState,
m_dwCallStateMode,
m_dwIncomingModes | m_dwOutgoingModes);
// success
return TRUE;
}
//always called in a lock
void
CH323Call::CopyU2UAsNonStandard(
IN DWORD dwDirection
)
{
PUserToUserLE pU2ULE = NULL;
H323DBG(( DEBUG_LEVEL_TRACE, "CopyU2UAsNonStandard entered:%p.", this ));
if( RemoveU2U( dwDirection, &pU2ULE ) )
{
// transfer header information
m_NonStandardData.bCountryCode = H221_COUNTRY_CODE_USA;
m_NonStandardData.bExtension = H221_COUNTRY_EXT_USA;
m_NonStandardData.wManufacturerCode = H221_MFG_CODE_MICROSOFT;
// initialize octet string containing data
m_NonStandardData.sData.wOctetStringLength = LOWORD(pU2ULE->dwU2USize);
if( m_NonStandardData.sData.pOctetString )
{
delete m_NonStandardData.sData.pOctetString;
m_NonStandardData.sData.pOctetString = NULL;
}
m_NonStandardData.sData.pOctetString = pU2ULE->pU2U;
}
else
{
//reset non standard data
memset( (PVOID)&m_NonStandardData,0,sizeof(H323NonStandardData ));
}
H323DBG(( DEBUG_LEVEL_TRACE, "CopyU2UAsNonStandard exited:%p.", this ));
}
void
CH323Call::AcceptCall(void)
/*++
Routine Description:
Accepts incoming call.
!!always called in lock
Arguments:
Return Values:
Returns true if successful.
--*/
{
PH323_CALL pCall = NULL;
H323DBG(( DEBUG_LEVEL_TRACE, "AcceptCall entered:%p.", this ));
if( m_dwFlags & CALLOBJECT_SHUTDOWN )
{
return;
}
// see if user user information specified
CopyU2UAsNonStandard( U2U_OUTBOUND );
if( m_pwszDisplay == NULL )
{
// see if callee alias specified
if( m_pCalleeAliasNames && m_pCalleeAliasNames -> wCount )
{
if((m_pCalleeAliasNames->pItems[0].wType == h323_ID_chosen) ||
(m_pCalleeAliasNames ->pItems[0].wType == e164_chosen) )
{
// send callee name as display
m_pwszDisplay = m_pCalleeAliasNames -> pItems[0].pData;
}
}
}
//send answer call message to the MSP instance
if( (m_dwCallType & CALLTYPE_TRANSFEREDDEST) && m_hdRelatedCall )
{
MSPMessageData* pMSPMessageData = new MSPMessageData;
if( pMSPMessageData == NULL )
{
CloseCall( 0 );
return;
}
pMSPMessageData->hdCall = m_hdRelatedCall;
pMSPMessageData->messageType = SP_MSG_AnswerCall;
pMSPMessageData->pbEncodedBuf = NULL;
pMSPMessageData->wLength = 0;
pMSPMessageData->hReplacementCall = m_hdCall;
if( !QueueUserWorkItem( SendMSPMessageOnRelatedCall, pMSPMessageData,
WT_EXECUTEDEFAULT ) )
{
delete pMSPMessageData;
CloseCall( 0 );
return;
}
}
else
{
SendMSPMessage( SP_MSG_AnswerCall, 0, 0, NULL );
}
m_fCallAccepted = TRUE;
if( m_fReadyToAnswer )
{
// validate status
if( !AcceptH323Call() )
{
H323DBG(( DEBUG_LEVEL_ERROR, "error answering call 0x%08lx.",
this ));
// drop call using disconnect mode
DropCall( LINEDISCONNECTMODE_TEMPFAILURE );
// failure
return;
}
if( !(m_dwFlags & H245_START_MSG_SENT) )
{
//start H245
SendMSPStartH245( NULL, NULL );
}
//tell MSP about connect state
SendMSPMessage( SP_MSG_ConnectComplete, 0, 0, NULL );
//change call state to accepted from offering
ChangeCallState( LINECALLSTATE_CONNECTED, 0 );
}
H323DBG(( DEBUG_LEVEL_TRACE, "AcceptCall exited:%p.", this ));
// success
return;
}
//always called in lock
void
CH323Call::ReleaseU2U(void)
{
PUserToUserLE pU2ULE = NULL;
PLIST_ENTRY pLE;
H323DBG(( DEBUG_LEVEL_TRACE, "ReleaseU2U entered:%p.", this ));
if( m_dwFlags & CALLOBJECT_SHUTDOWN )
{
return;
}
// see if list is empty
if( IsListEmpty( &m_IncomingU2U ) == FALSE )
{
// remove first entry from list
pLE = RemoveHeadList( &m_IncomingU2U );
// convert to user user structure
pU2ULE = CONTAINING_RECORD(pLE, UserToUserLE, Link);
// release memory
if(pU2ULE)
{
delete pU2ULE;
pU2ULE = NULL;
}
}
// see if list contains pending data
if( IsListEmpty( &m_IncomingU2U ) == FALSE )
{
H323DBG(( DEBUG_LEVEL_VERBOSE,
"more user user info available." ));
// signal incoming
PostLineEvent (
LINE_CALLINFO,
LINECALLINFOSTATE_USERUSERINFO, 0, 0);
}
H323DBG(( DEBUG_LEVEL_TRACE, "ReleaseU2U exited:%p.", this ));
}
//always called in lock
void
CH323Call::SendU2U(
IN BYTE* pUserUserInfo,
IN DWORD dwSize
)
{
H323DBG(( DEBUG_LEVEL_TRACE, "SendU2U entered:%p.", this ));
if( m_dwFlags & CALLOBJECT_SHUTDOWN )
{
return;
}
// check for user user info
if( pUserUserInfo != NULL )
{
// transfer header information
m_NonStandardData.bCountryCode = H221_COUNTRY_CODE_USA;
m_NonStandardData.bExtension = H221_COUNTRY_EXT_USA;
m_NonStandardData.wManufacturerCode = H221_MFG_CODE_MICROSOFT;
// initialize octet string containing data
m_NonStandardData.sData.wOctetStringLength = (WORD)dwSize;
if( m_NonStandardData.sData.pOctetString != NULL )
{
delete m_NonStandardData.sData.pOctetString;
m_NonStandardData.sData.pOctetString = NULL;
}
m_NonStandardData.sData.pOctetString = pUserUserInfo;
}
// send user user data
if( !SendQ931Message( 0, 0, 0, FACILITYMESSAGETYPE, NO_H450_APDU ) )
{
H323DBG(( DEBUG_LEVEL_ERROR,
"error sending non-standard message."));
}
H323DBG(( DEBUG_LEVEL_TRACE, "SendU2U exited:%p.", this ));
return;
}
BOOL
CH323Call::InitializeQ931(
IN SOCKET callSocket
)
{
BOOL fSuccess;
H323DBG((DEBUG_LEVEL_ERROR, "q931 call initialize entered:%p.", this ));
if( !BindIoCompletionCallback(
(HANDLE)callSocket,
CH323Call::IoCompletionCallback,
0) )
{
H323DBG(( DEBUG_LEVEL_ERROR,
"couldn't bind i/o completion callabck:%d:%p.",
GetLastError(), this ));
return FALSE;
}
//initilize the member variables
m_callSocket = callSocket;
H323DBG((DEBUG_LEVEL_ERROR, "q931 call initialize exited:%lx, %p.",
m_callSocket, this ));
return TRUE;
}
//no need to lock
BOOL
CH323Call::GetPeerAddress(
IN H323_ADDR *pAddr
)
{
SOCKADDR_IN sockaddr;
int len = sizeof(sockaddr);
H323DBG((DEBUG_LEVEL_ERROR, "GetPeerAddress entered:%p.", this ));
if( getpeername( m_callSocket, (SOCKADDR*)&sockaddr, &len)
== SOCKET_ERROR )
{
H323DBG(( DEBUG_LEVEL_ERROR,
"error 0x%08lx calling getpeername.", WSAGetLastError() ));
return FALSE;
}
pAddr->nAddrType = H323_IP_BINARY;
pAddr->bMulticast = FALSE;
pAddr->Addr.IP_Binary.wPort = ntohs(sockaddr.sin_port);
pAddr->Addr.IP_Binary.dwAddr = ntohl(sockaddr.sin_addr.S_un.S_addr);
H323DBG(( DEBUG_LEVEL_ERROR, "GetPeerAddress exited:%p.", this ));
return TRUE;
}
//no need to lock
BOOL CH323Call::GetHostAddress(
IN H323_ADDR *pAddr
)
{
int len = sizeof(m_LocalAddr);
H323DBG((DEBUG_LEVEL_ERROR, "GetHostAddress entered:%p.", this ));
if( getsockname( m_callSocket, (SOCKADDR *)&m_LocalAddr, &len) ==
SOCKET_ERROR)
{
H323DBG(( DEBUG_LEVEL_ERROR,
"error 0x%08lx calling getockname.", WSAGetLastError() ));
return FALSE;
}
pAddr->nAddrType = H323_IP_BINARY;
pAddr->bMulticast = FALSE;
pAddr->Addr.IP_Binary.wPort = ntohs(m_LocalAddr.sin_port);
pAddr->Addr.IP_Binary.dwAddr = ntohl(m_LocalAddr.sin_addr.S_un.S_addr);
H323DBG((DEBUG_LEVEL_ERROR, "GetHostAddress exited:%p.", this ));
return TRUE;
}
//!!always called in a lock
BOOL
CH323Call::OnReceiveFacility(
IN Q931MESSAGE* pMessage
)
{
Q931_FACILITY_ASN facilityASN;
H323DBG((DEBUG_LEVEL_TRACE, "OnReceiveFacility entered: %p.", this ));
//decode the U2U information
if( !pMessage ->UserToUser.fPresent ||
pMessage ->UserToUser.wUserInfoLen == 0 )
{
//Ignore this message. Don't shutdown the call.
return FALSE;
}
if( !ParseFacilityASN( pMessage->UserToUser.pbUserInfo,
pMessage->UserToUser.wUserInfoLen, &facilityASN ))
{
//memory failure : shutdown the H323 call
CloseCall( 0 );
return FALSE;
}
if( (facilityASN.pH245PDU.length != 0) && facilityASN.pH245PDU.value )
{
SendMSPMessage( SP_MSG_H245PDU, facilityASN.pH245PDU.value,
facilityASN.pH245PDU.length, NULL );
delete facilityASN.pH245PDU.value;
}
HandleFacilityMessage( facilityASN.dwInvokeID, &facilityASN );
H323DBG((DEBUG_LEVEL_TRACE, "OnReceiveFacility exited: %p.", this ));
return TRUE;
}
//!!always called in a lock
BOOL
CH323Call::OnReceiveProceeding(
IN Q931MESSAGE* pMessage
)
{
Q931_CALL_PROCEEDING_ASN proceedingASN;
DWORD dwAPDUType = 0;
H323DBG((DEBUG_LEVEL_TRACE, "OnReceiveProceeding entered: %p.", this ));
//decode the U2U information
if( (pMessage ->UserToUser.fPresent == FALSE) ||
(pMessage ->UserToUser.wUserInfoLen == 0) )
{
//ignore this message. don't shutdown the call.
return FALSE;
}
if( (m_dwOrigin!=LINECALLORIGIN_OUTBOUND) ||
( (m_dwStateMachine != Q931_SETUP_SENT) &&
(m_dwStateMachine != Q931_PROCEED_RECVD) )
)
{
//ignore this message. don't shutdown the Q931 call.
return FALSE;
}
if( !ParseProceedingASN(
pMessage->UserToUser.pbUserInfo,
pMessage->UserToUser.wUserInfoLen,
&proceedingASN,
&dwAPDUType ))
{
//Ignore the wrong proceeding message.
H323DBG(( DEBUG_LEVEL_ERROR, "wrong proceeding PDU:%p.", this ));
H323DUMPBUFFER( pMessage->UserToUser.pbUserInfo,
(DWORD)pMessage->UserToUser.wUserInfoLen );
return TRUE;
}
if( (m_dwCallType & CALLTYPE_FORWARDCONSULT )&&
(m_dwOrigin == LINECALLORIGIN_OUTBOUND ) )
{
//success of forwarding
EnableCallForwarding();
CloseCall( 0 );
return TRUE;
}
HandleProceedingMessage( &proceedingASN );
//reset the timeout for setup sent
if( m_hSetupSentTimer != NULL )
{
DeleteTimerQueueTimer( H323TimerQueue, m_hSetupSentTimer, NULL );
m_hSetupSentTimer = NULL;
}
H323DBG((DEBUG_LEVEL_TRACE, "OnReceiveProceeding exited: %p.", this ));
m_dwStateMachine = Q931_PROCEED_RECVD;
return TRUE;
}
//!!always called in a lock
BOOL
CH323Call::OnReceiveAlerting(
IN Q931MESSAGE* pMessage
)
{
Q931_ALERTING_ASN alertingASN;
DWORD dwAPDUType = 0;
H323DBG((DEBUG_LEVEL_TRACE, "OnReceiveAlerting entered: %p.", this ));
//decode the U2U information
if( (pMessage ->UserToUser.fPresent == FALSE) ||
(pMessage ->UserToUser.wUserInfoLen == 0) )
{
//ignore this message. don't shutdown the call.
return FALSE;
}
if( (m_dwOrigin!=LINECALLORIGIN_OUTBOUND) ||
!( (m_dwStateMachine==Q931_SETUP_SENT) ||
(m_dwStateMachine==Q931_PROCEED_RECVD)
)
)
{
//ignore this message. don't shutdown the Q931 call.
return FALSE;
}
if( !ParseAlertingASN( pMessage->UserToUser.pbUserInfo,
pMessage->UserToUser.wUserInfoLen,
&alertingASN,
&dwAPDUType ))
{
//memory failure : shutdown the H323 call
CloseCall( 0 );
return FALSE;
}
if( (m_dwCallType & CALLTYPE_FORWARDCONSULT )&&
(m_dwOrigin == LINECALLORIGIN_OUTBOUND ) )
{
//success of forwarding
EnableCallForwarding();
CloseCall( 0 );
return FALSE;
}
//reset the timeout for setup sent
if( m_hSetupSentTimer != NULL )
{
DeleteTimerQueueTimer( H323TimerQueue, m_hSetupSentTimer, NULL );
m_hSetupSentTimer = NULL;
}
if( !CreateTimerQueueTimer(
&m_hCallEstablishmentTimer,
H323TimerQueue,
CH323Call::CallEstablishmentExpiredCallback,
(PVOID)m_hdCall,
g_RegistrySettings.dwQ931AlertingTimeout, 0,
WT_EXECUTEINIOTHREAD | WT_EXECUTEONLYONCE ))
{
CloseCall( 0 );
return FALSE;
}
HandleAlertingMessage( &alertingASN );
m_dwStateMachine = Q931_ALERT_RECVD;
H323DBG((DEBUG_LEVEL_TRACE, "OnReceiveAlerting exited: %p.", this ));
return TRUE;
}
//!!always called in lock
void
CH323Call::SetupSentTimerExpired(void)
{
DWORD dwState;
H323DBG((DEBUG_LEVEL_TRACE, "SetupSentTimerExpired entered."));
dwState = m_dwStateMachine;
if( m_hSetupSentTimer != NULL )
{
DeleteTimerQueueTimer( H323TimerQueue, m_hSetupSentTimer, NULL );
m_hSetupSentTimer = NULL;
}
if( (dwState!= Q931_CONNECT_RECVD) &&
(dwState != Q931_ALERT_RECVD) &&
(dwState != Q931_PROCEED_RECVD) &&
(dwState != Q931_RELEASE_RECVD)
)
{
//time out has occured
CloseCall( 0 );
}
H323DBG((DEBUG_LEVEL_TRACE, "SetupSentTimerExpired exited." ));
}
//!!always called in a lock
BOOL
CH323Call::OnReceiveRelease(
IN Q931MESSAGE* pMessage
)
{
DWORD dwAPDUType = 0;
Q931_RELEASE_COMPLETE_ASN releaseASN;
//decode the U2U information
if( (pMessage ->UserToUser.fPresent == FALSE) ||
(pMessage ->UserToUser.wUserInfoLen == 0) )
{
H323DBG(( DEBUG_LEVEL_ERROR, "ReleaseComplete PDU did not contain "
"user-to-user information, ignoring message." ));
//ignore this message. don't shutdown the call.
return FALSE;
}
if( !ParseReleaseCompleteASN(
pMessage->UserToUser.pbUserInfo,
pMessage->UserToUser.wUserInfoLen,
&releaseASN,
&dwAPDUType ))
{
H323DBG(( DEBUG_LEVEL_ERROR,
"ReleaseComplete PDU could not be parsed, terminating call." ));
//memory failure : shutdown the H323 call
CloseCall( 0 );
return FALSE;
}
H323DBG ((DEBUG_LEVEL_INFO, "Received ReleaseComplete PDU."));
HandleReleaseMessage( &releaseASN );
m_dwStateMachine = Q931_RELEASE_RECVD;
return TRUE;
}
//!!always called in a lock
BOOL
CH323Call::OnReceiveConnect(
IN Q931MESSAGE* pMessage
)
{
Q931_CONNECT_ASN connectASN;
DWORD dwH450APDUType = 0;
H323DBG((DEBUG_LEVEL_TRACE, "OnReceiveConnect entered: %p.", this ));
//decode the U2U information
if( (pMessage ->UserToUser.fPresent == FALSE) ||
(pMessage ->UserToUser.wUserInfoLen == 0) )
{
//ignore this message. don't shutdown the call.
return FALSE;
}
if( m_dwOrigin!=LINECALLORIGIN_OUTBOUND )
{
//ignore this message. don't shutdown the Q931 call.
return FALSE;
}
if( (m_dwStateMachine != Q931_SETUP_SENT) &&
(m_dwStateMachine != Q931_ALERT_RECVD) &&
(m_dwStateMachine != Q931_PROCEED_RECVD)
)
{
//ignore this message. don't shutdown the Q931 call.
return FALSE;
}
if( ParseConnectASN( pMessage->UserToUser.pbUserInfo,
pMessage->UserToUser.wUserInfoLen,
&connectASN,
&dwH450APDUType) == FALSE )
{
//memory failure : shutdown the H323 call
CloseCall( 0 );
return FALSE;
}
if( m_dwCallType & CALLTYPE_FORWARDCONSULT )
{
FreeConnectASN( &connectASN );
if( dwH450APDUType == H4503_DUMMYTYPERETURNRESULT_APDU)
{
//assuming this return result is for check restriction operation
return TRUE;
}
else
{
//success of forwarding
EnableCallForwarding();
CloseCall( 0 );
return FALSE;
}
}
if( !HandleConnectMessage( &connectASN ) )
{
return FALSE;
}
//reset the timeout for setup sent
if( m_hSetupSentTimer != NULL )
{
DeleteTimerQueueTimer( H323TimerQueue, m_hSetupSentTimer, NULL );
m_hSetupSentTimer = NULL;
}
if( m_hCallEstablishmentTimer )
{
DeleteTimerQueueTimer(H323TimerQueue, m_hCallEstablishmentTimer, NULL);
m_hCallEstablishmentTimer = NULL;
}
m_dwStateMachine = Q931_CONNECT_RECVD;
H323DBG((DEBUG_LEVEL_TRACE, "OnReceiveConnect exited: %p.", this ));
return TRUE;
}
//!!always called in a lock
BOOL
CH323Call::OnReceiveSetup(
IN Q931MESSAGE* pMessage
)
{
Q931_SETUP_ASN setupASN;
DWORD dwH450APDUType = 0;
PH323_CALL pCall = NULL;
WCHAR pwszCallingPartyNr[H323_MAXPATHNAMELEN];
WCHAR pwszCalledPartyNr[H323_MAXPATHNAMELEN];
BYTE* pstrTemp;
//decode the U2U information
if( (pMessage ->UserToUser.fPresent == FALSE) ||
(pMessage ->UserToUser.wUserInfoLen == 0) )
{
H323DBG(( DEBUG_LEVEL_ERROR,
"Setup message did not contain H.323 UUIE, ignoring."));
//ignore this message. don't shutdown the call.
return FALSE;
}
if( m_dwOrigin != LINECALLORIGIN_INBOUND )
{
H323DBG(( DEBUG_LEVEL_ERROR,
"Received Setup message on outbound call, ignoring."));
//ignore this message. don't shutdown the call.
return FALSE;
}
if( m_dwStateMachine != Q931_CALL_STATE_NONE )
{
H323DBG( (DEBUG_LEVEL_ERROR,
"Received Setup message on a call that is already in progress." ));
//This Q931 call has already received a setup!!!!
CloseCall( 0 );
return FALSE;
}
if( !ParseSetupASN( pMessage->UserToUser.pbUserInfo,
pMessage->UserToUser.wUserInfoLen,
&setupASN,
&dwH450APDUType ))
{
H323DBG(( DEBUG_LEVEL_ERROR,
"Failed to parse Setup UUIE, closing call." ));
//shutdown the Q931 call
CloseCall( 0 );
return FALSE;
}
if( dwH450APDUType )
{
if( m_dwCallType & CALLTYPE_FORWARDCONSULT )
{
return TRUE;
}
}
if( (pMessage->CallingPartyNumber.fPresent == TRUE) &&
(pMessage->CallingPartyNumber.dwLength > 1) &&
(setupASN.pCallerAliasList == NULL ) )
{
// Always skip 1st byte in the contents.
// Skip the 2nd byte if its not an e.164 char (could be the screening indicator byte)
pstrTemp = pMessage->CallingPartyNumber.pbContents +
((pMessage->CallingPartyNumber.pbContents[1] & 0x80)? 2 : 1);
MultiByteToWideChar( CP_ACP,
0,
(const char *)(pstrTemp),
-1,
pwszCallingPartyNr,
sizeof(pwszCallingPartyNr)/sizeof(WCHAR));
setupASN.pCallerAliasList = new H323_ALIASNAMES;
if( setupASN.pCallerAliasList != NULL )
{
ZeroMemory( setupASN.pCallerAliasList, sizeof(H323_ALIASNAMES) );
AddAliasItem( setupASN.pCallerAliasList,
pwszCallingPartyNr,
e164_chosen );
}
}
if( (pMessage->CalledPartyNumber.fPresent == TRUE) &&
(pMessage->CalledPartyNumber.PartyNumberLength > 0) &&
(setupASN.pCalleeAliasList == NULL ) )
{
// Always skip 1st byte in the contents.
// Skip the 2nd byte if its not an e.164 char (could be the screening indicator byte)
MultiByteToWideChar(CP_ACP,
0,
(const char *)(pMessage->CalledPartyNumber.PartyNumbers),
-1,
pwszCalledPartyNr,
sizeof(pwszCalledPartyNr) / sizeof(WCHAR) );
setupASN.pCalleeAliasList = new H323_ALIASNAMES;
if( setupASN.pCalleeAliasList != NULL )
{
ZeroMemory( setupASN.pCalleeAliasList, sizeof(H323_ALIASNAMES) );
AddAliasItem( setupASN.pCalleeAliasList,
pwszCalledPartyNr,
e164_chosen );
}
}
//don't change the call type here
if( !InitializeIncomingCall( &setupASN, m_dwCallType, pMessage->wCallRef ) )
{
H323DBG ((DEBUG_LEVEL_ERROR,
"Failed to initialize incoming call, closing call."));
//shutdown the Q931 call
FreeSetupASN( &setupASN );
CloseCall( 0 );
return FALSE;
}
FreeSetupASN( &setupASN );
m_dwStateMachine = Q931_SETUP_RECVD;
if( !HandleSetupMessage( pMessage ) )
{
H323DBG ((DEBUG_LEVEL_ERROR,
"Failed to process Setup message, closing call."));
CloseCall( 0 );
return FALSE;
}
return TRUE;
}
//!!always called in a lock
void
CH323Call::CloseCall(
IN DWORD dwDisconnectMode )
{
H323DBG((DEBUG_LEVEL_INFO, "[%08XH] Terminating call.", this ));
if (!QueueTAPILineRequest(
TSPI_CLOSE_CALL,
m_hdCall,
NULL,
dwDisconnectMode,
m_wCallReference ))
{
H323DBG(( DEBUG_LEVEL_ERROR, "could not post H323 close event." ));
}
}
//!!always called in a lock
void
CH323Call::ReadEvent(
IN DWORD cbTransfer
)
{
H323DBG((DEBUG_LEVEL_TRACE, "ReadEvent entered: %p.", this ));
H323DBG((DEBUG_LEVEL_TRACE, "bytes received: %d.", cbTransfer));
m_RecvBuf.dwBytesCopied += cbTransfer;
//update the recv buffer
if( m_bStartOfPDU )
{
if( m_RecvBuf.dwBytesCopied < sizeof(TPKT_HEADER_SIZE) )
{
//set the buffer to get the remainig TPKT_HEADER
m_RecvBuf.WSABuf.buf =
m_RecvBuf.arBuf + m_RecvBuf.dwBytesCopied;
m_RecvBuf.WSABuf.len =
TPKT_HEADER_SIZE - m_RecvBuf.dwBytesCopied;
}
else
{
m_RecvBuf.dwPDULen = GetTpktLength( m_RecvBuf.arBuf );
if( (m_RecvBuf.dwPDULen < TPKT_HEADER_SIZE) ||
(m_RecvBuf.dwPDULen > Q931_RECV_BUFFER_LENGTH) )
{
//messed up peer. close the call.
H323DBG(( DEBUG_LEVEL_ERROR, "error:PDULen:%d.",
m_RecvBuf.dwPDULen ));
//close the call
CloseCall( 0 );
return;
}
else if( m_RecvBuf.dwPDULen == TPKT_HEADER_SIZE )
{
InitializeRecvBuf();
}
else
{
//set the buffer to get the remaining PDU
m_bStartOfPDU = FALSE;
m_RecvBuf.WSABuf.buf = m_RecvBuf.arBuf +
m_RecvBuf.dwBytesCopied;
m_RecvBuf.WSABuf.len = m_RecvBuf.dwPDULen -
m_RecvBuf.dwBytesCopied;
}
}
}
else
{
_ASSERTE( m_RecvBuf.dwBytesCopied <= m_RecvBuf.dwPDULen );
if( m_RecvBuf.dwBytesCopied == m_RecvBuf.dwPDULen )
{
//we got the whole PDU
if( !ProcessQ931PDU( &m_RecvBuf ) )
{
H323DBG(( DEBUG_LEVEL_ERROR,
"error in processing PDU:%p.", this ));
H323DUMPBUFFER( (BYTE*)m_RecvBuf.arBuf, m_RecvBuf.dwPDULen );
}
//if the call has been already shutdown due to
//a fatal error while processing the PDU or because of receiveing
//release complete message then dont post any more read buffers
if( (m_dwFlags & CALLOBJECT_SHUTDOWN) ||
(m_dwQ931Flags & Q931_CALL_DISCONNECTED) )
{
return;
}
InitializeRecvBuf();
}
else
{
//set the buffer to get the remainig PDU
m_RecvBuf.WSABuf. buf =
m_RecvBuf.arBuf + m_RecvBuf.dwBytesCopied;
m_RecvBuf.WSABuf. len =
m_RecvBuf.dwPDULen - m_RecvBuf.dwBytesCopied;
}
}
//post a read for the remaining PDU
if(!PostReadBuffer())
{
//post a message to the callback thread to shutdown the H323 call
CloseCall( 0 );
}
H323DBG((DEBUG_LEVEL_TRACE, "ReadEvent exited: %p.", this ));
}
/*
Parse a generic Q931 message and place the fields of the buffer
into the appropriate structure fields.
Parameters:
pBuf Pointer to buffer descriptor of an
input packet containing the 931 message.
pMessage Pointer to space for parsed output information.
*/
//!!always called in a lock
HRESULT
CH323Call::Q931ParseMessage(
IN BYTE * pbCodedBuffer,
IN DWORD dwCodedBufferLength,
OUT PQ931MESSAGE pMessage
)
{
HRESULT hr;
BUFFERDESCR pBuf;
pBuf.dwLength = dwCodedBufferLength;
pBuf.pbBuffer = pbCodedBuffer;
H323DBG((DEBUG_LEVEL_TRACE, "Q931ParseMessage entered: %p.", this ));
memset( (PVOID)pMessage, 0, sizeof(Q931MESSAGE));
hr = ParseProtocolDiscriminator(&pBuf, &pMessage->ProtocolDiscriminator);
if( hr != S_OK )
{
return hr;
}
hr = ParseCallReference( &pBuf, &pMessage->wCallRef);
if( hr != S_OK )
{
return hr;
}
hr = ParseMessageType( &pBuf, &pMessage->MessageType );
if( hr != S_OK )
{
return hr;
}
while (pBuf.dwLength)
{
hr = ParseQ931Field(&pBuf, pMessage);
if (hr != S_OK)
{
return hr;
}
}
H323DBG((DEBUG_LEVEL_TRACE, "Q931ParseMessage exited: %p.", this ));
return S_OK;
}
//decode the PDU and release the buffer
//!!always called in a lock
BOOL
CH323Call::ProcessQ931PDU(
IN CALL_RECV_CONTEXT* pRecvBuf
)
{
PQ931MESSAGE pMessage;
BOOL retVal;
HRESULT hr;
H323DBG((DEBUG_LEVEL_TRACE, "ProcessQ931PDU entered: %p.", this ));
pMessage = new Q931MESSAGE;
if( pMessage == NULL )
{
return FALSE;
}
hr = Q931ParseMessage( (BYTE*)(pRecvBuf->arBuf + sizeof(TPKT_HEADER_SIZE)),
pRecvBuf->dwPDULen - 4,
pMessage );
if( !SUCCEEDED( hr) )
{
delete pMessage;
return FALSE;
}
if( (m_dwCallType & CALLTYPE_TRANSFERED_PRIMARY ) &&
(m_dwCallDiversionState == H4502_CTINITIATE_RECV) &&
(pMessage->MessageType != RELEASECOMPLMESSAGETYPE) )
{
// If this endpoint has already been transferred then
// ignore any further messages on the primary call.
delete pMessage;
return FALSE;
}
switch( pMessage->MessageType )
{
case ALERTINGMESSAGETYPE:
retVal = OnReceiveAlerting( pMessage );
break;
case PROCEEDINGMESSAGETYPE:
retVal = OnReceiveProceeding( pMessage );
break;
case CONNECTMESSAGETYPE:
retVal = OnReceiveConnect( pMessage );
break;
case RELEASECOMPLMESSAGETYPE:
retVal = OnReceiveRelease( pMessage );
break;
case SETUPMESSAGETYPE:
retVal = OnReceiveSetup( pMessage );
break;
case FACILITYMESSAGETYPE:
retVal = OnReceiveFacility( pMessage );
break;
default:
H323DBG(( DEBUG_LEVEL_TRACE, "unrecognised PDU recvd:%d,%p.",
pMessage->MessageType, this ));
retVal = FALSE;
}
delete pMessage;
H323DBG((DEBUG_LEVEL_TRACE, "ProcessQ931PDU exited: %p.", this ));
return retVal;
}
//!!always called in a lock
void
CH323Call::OnConnectComplete(void)
{
BOOL fSuccess = TRUE;
PH323_CALL pCall = NULL;
H323DBG((DEBUG_LEVEL_TRACE, "OnConnectComplete entered: %p.", this ));
_ASSERTE( m_dwOrigin==LINECALLORIGIN_OUTBOUND );
if( !GetHostAddress( &m_CallerAddr) )
{
//memory failure : shutdown the H323 call
CloseCall( 0 );
return;
}
InitializeRecvBuf();
//post a buffer to winsock to accept messages from the peer
if( !PostReadBuffer() )
{
//memory failure : shutdown the H323 call
CloseCall( 0 );
return;
}
//set the state to connected
SetQ931CallState( Q931_CALL_CONNECTED );
if( (m_dwCallType == CALLTYPE_NORMAL) ||
(m_dwCallType & CALLTYPE_TRANSFERING_CONSULT) )
{
SendMSPMessage( SP_MSG_InitiateCall, 0, 0, NULL );
}
else if( m_dwCallType & CALLTYPE_TRANSFEREDSRC )
{
_ASSERTE( m_hdRelatedCall );
MSPMessageData* pMSPMessageData = new MSPMessageData;
if( pMSPMessageData == NULL )
{
CloseCall( 0 );
return;
}
pMSPMessageData->hdCall = m_hdRelatedCall;
pMSPMessageData->messageType = SP_MSG_InitiateCall;
pMSPMessageData->pbEncodedBuf = NULL;
pMSPMessageData->wLength = 0;
pMSPMessageData->hReplacementCall = m_hdCall;
if( !QueueUserWorkItem( SendMSPMessageOnRelatedCall, pMSPMessageData,
WT_EXECUTEDEFAULT ) )
{
delete pMSPMessageData;
CloseCall( 0 );
return;
}
}
else
{
//send the setup message
if( !SendSetupMessage() )
{
DropCall( 0 );
}
}
H323DBG((DEBUG_LEVEL_TRACE, "OnConnectComplete exited: %p.", this ));
}
//!!aleways called in a lock
BOOL
CH323Call::SendSetupMessage(void)
{
BOOL retVal = TRUE;
DWORD dwAPDUType = NO_H450_APDU;
H323DBG((DEBUG_LEVEL_TRACE, "SendSetupMessage entered: %p.", this ));
//encode ASN.1 and send Q931Setup message to the peer
if( m_dwCallType & CALLTYPE_FORWARDCONSULT )
{
//send the callRerouitng.invoke APDU if this is a forwardconsult call
retVal = SendQ931Message( NO_INVOKEID,
(DWORD)create_chosen,
(DWORD)pointToPoint_chosen,
SETUPMESSAGETYPE,
CHECKRESTRICTION_OPCODE| H450_INVOKE );
if( retVal )
{
m_dwStateMachine = Q931_SETUP_SENT;
m_dwCallDiversionState = H4503_CHECKRESTRICTION_SENT;
retVal = CreateTimerQueueTimer(
&m_hCheckRestrictionTimer,
H323TimerQueue,
CH323Call::CheckRestrictionTimerCallback,
(PVOID)m_hdCall,
CHECKRESTRICTION_EXPIRE_TIME, 0,
WT_EXECUTEINIOTHREAD | WT_EXECUTEONLYONCE );
}
}
else
{
if( ( m_dwCallType & CALLTYPE_DIVERTEDSRC ) ||
( m_dwCallType & CALLTYPE_DIVERTEDSRC_NOROUTING ) )
{
dwAPDUType = DIVERTINGLEGINFO2_OPCODE | H450_INVOKE;
}
else if( m_dwCallType & CALLTYPE_TRANSFEREDSRC )
{
dwAPDUType = CTSETUP_OPCODE | H450_INVOKE;
}
retVal = SendQ931Message( NO_INVOKEID,
(DWORD)create_chosen,
(DWORD)pointToPoint_chosen,
SETUPMESSAGETYPE,
dwAPDUType );
if( retVal )
{
m_dwStateMachine = Q931_SETUP_SENT;
retVal = CreateTimerQueueTimer(
&m_hSetupSentTimer,
H323TimerQueue,
CH323Call::SetupSentTimerCallback,
(PVOID)m_hdCall,
SETUP_SENT_TIMEOUT, 0,
WT_EXECUTEINIOTHREAD | WT_EXECUTEONLYONCE );
}
}
if( retVal == FALSE )
{
CloseCall( 0 );
return FALSE;
}
H323DBG((DEBUG_LEVEL_TRACE, "SendSetupMessage exited: %p.", this ));
return TRUE;
}
//!!always called in a lock
BOOL
CH323Call::SendProceeding(void)
{
H323DBG((DEBUG_LEVEL_TRACE, "SendProceeding entered: %p.", this ));
_ASSERTE( m_dwOrigin == LINECALLORIGIN_INBOUND );
//encode ASN.1 and send Q931Setup message to the peer
if(!SendQ931Message( NO_INVOKEID, 0, 0, PROCEEDINGMESSAGETYPE, NO_H450_APDU ))
{
return FALSE;
}
m_dwStateMachine = Q931_PROCEED_SENT;
H323DBG((DEBUG_LEVEL_TRACE, "SendProceeding exited: %p.", this ));
return TRUE;
}
//!!always called in a lock
BOOL
CH323Call::PostReadBuffer(void)
{
int iError;
DWORD dwByteReceived = 0;
BOOL fDelete = FALSE;
H323DBG((DEBUG_LEVEL_TRACE, "PostReadBuffer entered: %p.", this ));
m_RecvBuf.Type = OVERLAPPED_TYPE_RECV;
m_RecvBuf.pCall = this;
m_RecvBuf.dwFlags = 0;
m_RecvBuf.BytesTransferred = 0;
ZeroMemory( (PVOID)&m_RecvBuf.Overlapped, sizeof(OVERLAPPED) );
//register with winsock for overlappped I/O
if( WSARecv( m_callSocket,
&(m_RecvBuf.WSABuf),
1,
&(m_RecvBuf.BytesTransferred),
&(m_RecvBuf.dwFlags),
&(m_RecvBuf.Overlapped),
NULL ) == SOCKET_ERROR )
{
iError = WSAGetLastError();
if( iError != WSA_IO_PENDING )
{
//take care of error conditions here
H323DBG((DEBUG_LEVEL_ERROR, "error while recving buf: %d.",
iError ));
return FALSE;
}
}
else
{
//There is some data to read!!!!!
H323DBG(( DEBUG_LEVEL_TRACE, "bytes received immediately: %d.",
m_RecvBuf.BytesTransferred ));
}
m_IoRefCount++;
H323DBG((DEBUG_LEVEL_TRACE,
"PostReadBuffer:m_IoRefCount: %d:%p.", m_IoRefCount, this ));
H323DBG((DEBUG_LEVEL_TRACE, "PostReadBuffer exited: %p.", this ));
return TRUE;
}
//!!always called in a lock
BOOL
CH323Call::SendBuffer(
IN BYTE* pbBuffer,
IN DWORD dwLength
)
{
int iError;
CALL_SEND_CONTEXT* pSendBuf = NULL;
DWORD cbTransfer;
BOOL fDelete = FALSE;
H323DBG((DEBUG_LEVEL_TRACE, "SendBuffer entered: %p.", this ));
if( !(m_dwQ931Flags & Q931_CALL_CONNECTED) )
{
goto cleanup;
}
pSendBuf = new CALL_SEND_CONTEXT;
if( pSendBuf == NULL )
{
goto cleanup;
}
ZeroMemory( (PVOID)pSendBuf, sizeof(CALL_SEND_CONTEXT) );
pSendBuf->WSABuf.buf = (char*)pbBuffer;
pSendBuf->WSABuf.len = dwLength;
pSendBuf->BytesTransferred = 0;
pSendBuf->pCall = this;
pSendBuf->Type = OVERLAPPED_TYPE_SEND;
InsertTailList( &m_sendBufList, &(pSendBuf ->ListEntry) );
if( WSASend(m_callSocket,
&(pSendBuf->WSABuf),
1,
&(pSendBuf->BytesTransferred),
0,
&(pSendBuf->Overlapped),
NULL) == SOCKET_ERROR )
{
iError = WSAGetLastError();
if( iError != WSA_IO_PENDING )
{
H323DBG((DEBUG_LEVEL_TRACE, "error sending the buf: %lx.", iError));
RemoveEntryList( &pSendBuf->ListEntry );
goto cleanup;
}
}
else
{
//data was sent immediately!!!
H323DBG((DEBUG_LEVEL_TRACE, "data sent immediately!!." ));
}
m_IoRefCount++;
H323DBG((DEBUG_LEVEL_TRACE, "SendBuffer:m_IoRefCount11: %d:%p.",
m_IoRefCount, this ));
H323DBG((DEBUG_LEVEL_TRACE, "SendBuffer exited: %p.", this ));
return TRUE;
cleanup:
if(pSendBuf)
{
delete pSendBuf;
}
delete pbBuffer;
return FALSE;
}
//!!aleways called in a lock
BOOL
CH323Call::SetupCall(void)
{
SOCKET Q931CallSocket = INVALID_SOCKET;
SOCKADDR_IN sin;
HANDLE hWSAEvent;
HANDLE hConnWait;
BOOL fSuccess = TRUE;
int iError;
BOOL fDelete;
DWORD dwEnable = 1;
TCHAR ptstrEventName[100];
H323DBG((DEBUG_LEVEL_TRACE, "SetupCall entered."));
//create a socket
Q931CallSocket = WSASocket(
AF_INET,
SOCK_STREAM,
IPPROTO_IP,
NULL,
NULL,
WSA_FLAG_OVERLAPPED );
if( Q931CallSocket == INVALID_SOCKET )
{
H323DBG((DEBUG_LEVEL_ERROR, "error while creating socket: %lx.",
WSAGetLastError() ));
goto error1;
}
//create a new Q931 call object
if( InitializeQ931(Q931CallSocket) == NULL )
{
goto error2;
}
_stprintf( ptstrEventName, _T("%s-%p") ,
_T( "H323TSP_OutgoingCall_TransportHandlerEvent" ), this );
//create the wait event
hWSAEvent = H323CreateEvent( NULL, FALSE,
FALSE, ptstrEventName );
if( hWSAEvent == NULL )
{
H323DBG((DEBUG_LEVEL_ERROR, "couldn't create wsaevent" ));
goto error3;
}
//register with thread pool the event handle and handler proc
fSuccess = RegisterWaitForSingleObject(
&hConnWait, // pointer to the returned handle
hWSAEvent, // the event handle to wait for.
Q931TransportEventHandler, // the callback function.
(PVOID)m_hdCall, // the context for the callback.
INFINITE, // wait forever.
// probably don't need this flag set
WT_EXECUTEDEFAULT // use the wait thread to call the callback.
);
if ( ( !fSuccess ) || (hConnWait== NULL) )
{
GetLastError();
if( !CloseHandle( hWSAEvent ) )
{
H323DBG((DEBUG_LEVEL_ERROR, "couldn't close wsaevent" ));
}
goto error3;
}
//store this in the call context
SetNewCallInfo( hConnWait, hWSAEvent, Q931_CALL_CONNECTING );
//register with Winsock the event handle and the events
if( WSAEventSelect( Q931CallSocket,
hWSAEvent,
FD_CONNECT | FD_CLOSE
) == SOCKET_ERROR )
{
H323DBG((DEBUG_LEVEL_ERROR,
"error selecting event outgoing call: %lx.", WSAGetLastError()));
goto error3;
}
if( setsockopt( Q931CallSocket,
IPPROTO_TCP,
TCP_NODELAY,
(char*)&dwEnable,
sizeof(DWORD)
) == SOCKET_ERROR )
{
H323DBG(( DEBUG_LEVEL_WARNING,
"Couldn't set NODELAY option on outgoing call socket:%d, %p",
WSAGetLastError(), this ));
}
//set the address structure
memset( (PVOID)&sin, 0, sizeof(SOCKADDR_IN) );
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = htonl( m_CalleeAddr.Addr.IP_Binary.dwAddr );
sin.sin_port = htons( m_CalleeAddr.Addr.IP_Binary.wPort );
//make the winsock connection
if( WSAConnect( Q931CallSocket,
(sockaddr*)&sin,
sizeof(SOCKADDR_IN),
NULL, NULL, NULL, NULL
)
== SOCKET_ERROR )
{
iError = WSAGetLastError();
if(iError != WSAEWOULDBLOCK )
{
H323DBG(( DEBUG_LEVEL_ERROR,
"error while connecting socket: %lx.", iError ));
goto error3;
}
}
else
{ //connection went through immediately!!!
OnConnectComplete();
}
//success
H323DBG((DEBUG_LEVEL_TRACE, "SetupCall exited."));
return TRUE;
error3:
Unlock();
Shutdown( &fDelete );
Lock();
error2:
closesocket( Q931CallSocket );
error1:
return FALSE;
}
//!!aleways called in a lock
BOOL
CH323Call::AcceptH323Call(void)
{
DWORD dwAPDUType = NO_H450_APDU;
DWORD dwInvokeID = NO_INVOKEID;
H323DBG((DEBUG_LEVEL_TRACE, "AcceptH323Call entered: %p.", this ));
if( m_dwCallType & CALLTYPE_DIVERTEDDEST )
{
dwAPDUType = (DIVERTINGLEGINFO3_OPCODE | H450_INVOKE);
}
else if( m_dwCallType & CALLTYPE_TRANSFEREDDEST )
{
dwAPDUType = (CTSETUP_OPCODE | H450_RETURNRESULT);
dwInvokeID = m_dwInvokeID;
}
ChangeCallState( LINECALLSTATE_ACCEPTED, 0 );
//if pCall Divert On No Answer is enabled, then stop the timer
if( m_hCallDivertOnNATimer )
{
DeleteTimerQueueTimer( H323TimerQueue, m_hCallDivertOnNATimer, NULL );
m_hCallDivertOnNATimer = NULL;
}
//encode and send Q931Connect message to the peer
if( !SendQ931Message( dwInvokeID, 0, 0, CONNECTMESSAGETYPE, dwAPDUType ) )
{
//post a message to the callback thread to shutdown the H323 call
CloseCall( 0 );
return FALSE;
}
m_dwStateMachine = Q931_CONNECT_SENT;
H323DBG((DEBUG_LEVEL_TRACE, "AcceptH323Call exited: %p.", this ));
return TRUE;
}
//!!always called in a lock
BOOL
CH323Call::SendQ931Message(
IN DWORD dwInvokeID,
IN ULONG_PTR dwParam1,
IN ULONG_PTR dwParam2,
IN DWORD dwMessageType,
IN DWORD dwAPDUType
)
{
BINARY_STRING userUserData;
DWORD dwCodedLengthPDU;
BYTE *pbCodedPDU;
BOOL retVal = FALSE;
WCHAR * pwszCalledPartyNumber = NULL;
H323DBG((DEBUG_LEVEL_TRACE, "SendQ931Message entered: %p.", this ));
//check if socket is connected
if( !(m_dwQ931Flags & Q931_CALL_CONNECTED) )
{
return FALSE;
}
switch ( dwMessageType )
{
//encode the UU message
case SETUPMESSAGETYPE:
retVal = EncodeSetupMessage( dwInvokeID, (WORD)dwParam1, //dwGoal
(WORD)dwParam2, //dwCalType
&userUserData.pbBuffer,
&userUserData.length,
dwAPDUType );
break;
case ALERTINGMESSAGETYPE:
retVal = EncodeAlertMessage( dwInvokeID,
&userUserData.pbBuffer,
&userUserData.length,
dwAPDUType );
break;
case PROCEEDINGMESSAGETYPE:
retVal = EncodeProceedingMessage( dwInvokeID,
&userUserData.pbBuffer,
&userUserData.length,
dwAPDUType );
break;
case RELEASECOMPLMESSAGETYPE:
retVal = EncodeReleaseCompleteMessage( dwInvokeID,
(BYTE*)dwParam1, //pbReason
&userUserData.pbBuffer,
&userUserData.length,
dwAPDUType );
break;
case CONNECTMESSAGETYPE:
retVal = EncodeConnectMessage( dwInvokeID,
&userUserData.pbBuffer,
&userUserData.length,
dwAPDUType );
break;
case FACILITYMESSAGETYPE:
retVal = EncodeFacilityMessage( dwInvokeID,
(BYTE)dwParam1,
(ASN1octetstring_t*)dwParam2,
&userUserData.pbBuffer,
&userUserData.length,
dwAPDUType );
break;
}
if( retVal == FALSE )
{
H323DBG(( DEBUG_LEVEL_ERROR,
"could not encode message:%d.", dwMessageType));
if( userUserData.pbBuffer )
{
ASN1_FreeEncoded(m_ASNCoderInfo.pEncInfo, userUserData.pbBuffer );
}
return FALSE;
}
if (m_dwAddressType == LINEADDRESSTYPE_PHONENUMBER)
{
_ASSERTE( m_pCalleeAliasNames->pItems[0].wType == e164_chosen );
pwszCalledPartyNumber = m_pCalleeAliasNames ->pItems[0].pData;
}
//encode the PDU
retVal = EncodePDU( &userUserData,
&pbCodedPDU,
&dwCodedLengthPDU,
dwMessageType,
pwszCalledPartyNumber );
if( retVal == FALSE )
{
H323DBG(( DEBUG_LEVEL_ERROR,
"could not encode PDU: %d.", dwMessageType ));
}
else if(!SendBuffer( pbCodedPDU, dwCodedLengthPDU ))
{
retVal = FALSE;
}
if( userUserData.pbBuffer )
{
ASN1_FreeEncoded(m_ASNCoderInfo.pEncInfo, userUserData.pbBuffer );
}
H323DBG((DEBUG_LEVEL_TRACE, "SendQ931Message exited: %p.", this ));
return retVal;
}
//!!always called in a lock
BOOL
CH323Call::EncodeFastStartProposal(
PH323_FASTSTART pFastStart,
BYTE** ppEncodedBuf,
WORD* pwEncodedLength
)
{
int rc;
H323_UserInformation UserInfo;
H323DBG((DEBUG_LEVEL_TRACE, "EncodeFastStartProposal entered: %p.", this ));
CallProceeding_UUIE & proceedingMessage =
UserInfo.h323_uu_pdu.h323_message_body.u.callProceeding;
*ppEncodedBuf = NULL;
*pwEncodedLength = 0;
memset( (PVOID)&UserInfo, 0, sizeof(H323_UserInformation));
UserInfo.bit_mask = 0;
//copy the call identifier
proceedingMessage.bit_mask |= CallProceeding_UUIE_callIdentifier_present;
CopyMemory( (PVOID)&proceedingMessage.callIdentifier.guid.value,
(PVOID)&m_callIdentifier,
sizeof(GUID) );
proceedingMessage.callIdentifier.guid.length = sizeof(GUID);
// make sure the user_data_present flag is turned off.
UserInfo.bit_mask &= (~user_data_present);
UserInfo.h323_uu_pdu.bit_mask = 0;
UserInfo.h323_uu_pdu.h323_message_body.choice = callProceeding_chosen;
proceedingMessage.protocolIdentifier = OID_H225ProtocolIdentifierV2;
proceedingMessage.bit_mask |= CallProceeding_UUIE_fastStart_present;
proceedingMessage.fastStart = (PCallProceeding_UUIE_fastStart)pFastStart;
rc = EncodeASN( (void *) &UserInfo,
H323_UserInformation_PDU,
ppEncodedBuf,
pwEncodedLength);
if (ASN1_FAILED(rc) || (*ppEncodedBuf == NULL) || (pwEncodedLength == 0) )
{
return FALSE;
}
H323DBG((DEBUG_LEVEL_TRACE, "EncodeFastStartProposal exited: %p.", this ));
//success
return TRUE;
}
//!!always called in a lock
BOOL
CH323Call::EncodeFacilityMessage(
IN DWORD dwInvokeID,
IN BYTE bReason,
IN ASN1octetstring_t* pH245PDU,
OUT BYTE **ppEncodedBuf,
OUT WORD *pdwEncodedLength,
IN DWORD dwAPDUType
)
{
H323_UU_PDU_h4501SupplementaryService h4501APDU;
int rc;
H323_UserInformation UserInfo;
DWORD dwAPDULen = 0;
BYTE* pEncodedAPDU = NULL;
H323DBG((DEBUG_LEVEL_TRACE, "EncodeFacilityMessage entered: %p.", this ));
Facility_UUIE & facilityMessage =
UserInfo.h323_uu_pdu.h323_message_body.u.facility;
*ppEncodedBuf = NULL;
*pdwEncodedLength = 0;
memset( (PVOID)&UserInfo, 0, sizeof(H323_UserInformation));
UserInfo.bit_mask = 0;
// make sure the user_data_present flag is turned off.
UserInfo.bit_mask &= (~user_data_present);
UserInfo.h323_uu_pdu.bit_mask = 0;
//send the appropriate ADPDUS
if( dwAPDUType != NO_H450_APDU )
{
if( !EncodeH450APDU(dwInvokeID, dwAPDUType,
&pEncodedAPDU, &dwAPDULen ) )
{
return FALSE;
}
UserInfo.h323_uu_pdu.h4501SupplementaryService = &h4501APDU;
UserInfo.h323_uu_pdu.h4501SupplementaryService -> next = NULL;
UserInfo.h323_uu_pdu.h4501SupplementaryService -> value.value = pEncodedAPDU;
UserInfo.h323_uu_pdu.h4501SupplementaryService -> value.length = dwAPDULen;
UserInfo.h323_uu_pdu.bit_mask |= h4501SupplementaryService_present;
}
UserInfo.h323_uu_pdu.h245Tunneling = FALSE;//(m_fh245Tunneling & LOCAL_H245_TUNNELING);
UserInfo.h323_uu_pdu.bit_mask |= h245Tunneling_present;
SetNonStandardData( UserInfo );
UserInfo.h323_uu_pdu.h323_message_body.choice = facility_chosen;
facilityMessage.protocolIdentifier = OID_H225ProtocolIdentifierV2;
facilityMessage.bit_mask = 0;
TransportAddress& transportAddress = facilityMessage.alternativeAddress;
if( IsGuidSet( &m_ConferenceID ) )
{
CopyConferenceID(&facilityMessage.conferenceID, &m_ConferenceID);
facilityMessage.bit_mask |= Facility_UUIE_conferenceID_present;
}
switch (bReason)
{
case H323_REJECT_ROUTE_TO_GATEKEEPER:
facilityMessage.reason.choice =
FacilityReason_routeCallToGatekeeper_chosen;
break;
case H323_REJECT_CALL_FORWARDED:
facilityMessage.reason.choice = callForwarded_chosen;
break;
case H323_REJECT_ROUTE_TO_MC:
facilityMessage.reason.choice = routeCallToMC_chosen;
break;
default:
facilityMessage.reason.choice = FacilityReason_undefinedReason_chosen;
}
facilityMessage.bit_mask |= Facility_UUIE_callIdentifier_present;
CopyMemory( (PVOID)&facilityMessage.callIdentifier.guid.value,
(PVOID)"abcdabcdabcdabcdabcd",
sizeof(GUID) );
facilityMessage.callIdentifier.guid.length = sizeof(GUID);
if( pH245PDU && (pH245PDU->value != NULL) )
{
//h245 PDU to be sent
UserInfo.h323_uu_pdu.h245Control->next = NULL;
UserInfo.h323_uu_pdu.h245Control->value.length = pH245PDU->length;
UserInfo.h323_uu_pdu.h245Control->value.value = pH245PDU->value;
}
rc = EncodeASN((void *) &UserInfo,
H323_UserInformation_PDU,
ppEncodedBuf,
pdwEncodedLength);
if( ASN1_FAILED(rc) || (*ppEncodedBuf == NULL) || (pdwEncodedLength == 0) )
{
if( pEncodedAPDU != NULL )
{
ASN1_FreeEncoded(m_H450ASNCoderInfo.pEncInfo, pEncodedAPDU );
}
return FALSE;
}
if( pEncodedAPDU != NULL )
{
ASN1_FreeEncoded(m_H450ASNCoderInfo.pEncInfo, pEncodedAPDU );
}
H323DBG((DEBUG_LEVEL_TRACE, "EncodeFacilityMessage exited: %p.", this ));
//success
return TRUE;
}
//!!always called in a lock
BOOL
CH323Call::EncodeAlertMessage(
IN DWORD dwInvokeID,
OUT BYTE **ppEncodedBuf,
OUT WORD *pdwEncodedLength,
IN DWORD dwAPDUType
)
{
H323_UU_PDU_h4501SupplementaryService h4501APDU;
int rc;
H323_UserInformation UserInfo;
DWORD dwAPDULen = 0;
BYTE* pEncodedAPDU = NULL;
H323DBG(( DEBUG_LEVEL_TRACE, "EncodeAlertMessage entered: %p.", this ));
Alerting_UUIE & alertingMessage =
UserInfo.h323_uu_pdu.h323_message_body.u.alerting;
*ppEncodedBuf = NULL;
*pdwEncodedLength = 0;
memset( (PVOID)&UserInfo, 0, sizeof(H323_UserInformation));
UserInfo.bit_mask = 0;
// make sure the user_data_present flag is turned off.
UserInfo.bit_mask &= (~user_data_present);
UserInfo.h323_uu_pdu.bit_mask = 0;
if( dwAPDUType != NO_H450_APDU )
{
if( !EncodeH450APDU( dwInvokeID, dwAPDUType, &pEncodedAPDU, &dwAPDULen ) )
{
return FALSE;
}
UserInfo.h323_uu_pdu.h4501SupplementaryService = &h4501APDU;
UserInfo.h323_uu_pdu.h4501SupplementaryService -> next = NULL;
UserInfo.h323_uu_pdu.h4501SupplementaryService -> value.value = pEncodedAPDU;
UserInfo.h323_uu_pdu.h4501SupplementaryService -> value.length = dwAPDULen;
UserInfo.h323_uu_pdu.bit_mask |= h4501SupplementaryService_present;
}
UserInfo.h323_uu_pdu.h245Tunneling = FALSE;//(m_fh245Tunneling & LOCAL_H245_TUNNELING);
UserInfo.h323_uu_pdu.bit_mask |= h245Tunneling_present;
SetNonStandardData( UserInfo );
UserInfo.h323_uu_pdu.h323_message_body.choice = alerting_chosen;
alertingMessage.protocolIdentifier = OID_H225ProtocolIdentifierV2;
alertingMessage.destinationInfo.bit_mask = 0;
//copy the vendor info
alertingMessage.destinationInfo.bit_mask |= vendor_present;
CopyVendorInfo( &alertingMessage.destinationInfo.vendor );
//its a terminal
alertingMessage.destinationInfo.bit_mask = terminal_present;
alertingMessage.destinationInfo.terminal.bit_mask = 0;
//not na MC
alertingMessage.destinationInfo.mc = 0;
alertingMessage.destinationInfo.undefinedNode = 0;
TransportAddress& transportAddress = alertingMessage.h245Address;
//send H245 address only if the caller hasn't proposed FasrStart
//or the fast start proposal has been accepeted
if( (m_pPeerFastStart == NULL) || m_pFastStart )
{
if( m_selfH245Addr.Addr.IP_Binary.dwAddr != 0 )
{
CopyTransportAddress( transportAddress, &m_selfH245Addr );
alertingMessage.bit_mask |= (Alerting_UUIE_h245Address_present);
}
else
{
alertingMessage.bit_mask &= (~Alerting_UUIE_h245Address_present);
}
}
if( m_pFastStart != NULL )
{
_ASSERTE( m_pPeerFastStart );
alertingMessage.bit_mask |= Alerting_UUIE_fastStart_present;
alertingMessage.fastStart = (PAlerting_UUIE_fastStart)m_pFastStart;
}
else
{
alertingMessage.bit_mask &= ~Alerting_UUIE_fastStart_present;
}
//copy the call identifier
alertingMessage.bit_mask |= Alerting_UUIE_callIdentifier_present;
CopyMemory( (PVOID)&alertingMessage.callIdentifier.guid.value,
(PVOID)&m_callIdentifier,
sizeof(GUID) );
alertingMessage.callIdentifier.guid.length = sizeof(GUID);
rc = EncodeASN( (void *) &UserInfo,
H323_UserInformation_PDU,
ppEncodedBuf,
pdwEncodedLength);
if (ASN1_FAILED(rc) || (*ppEncodedBuf == NULL) || (pdwEncodedLength == 0) )
{
if( pEncodedAPDU != NULL )
{
ASN1_FreeEncoded(m_H450ASNCoderInfo.pEncInfo, pEncodedAPDU );
}
return FALSE;
}
if( pEncodedAPDU != NULL )
{
ASN1_FreeEncoded(m_H450ASNCoderInfo.pEncInfo, pEncodedAPDU );
}
H323DBG((DEBUG_LEVEL_TRACE, "EncodeAlertMessage exited: %p.", this ));
//success
return TRUE;
}
//!!always called in a lock
BOOL
CH323Call::EncodeProceedingMessage(
IN DWORD dwInvokeID,
OUT BYTE **ppEncodedBuf,
OUT WORD *pdwEncodedLength,
IN DWORD dwAPDUType
)
{
H323_UU_PDU_h4501SupplementaryService h4501APDU;
int rc;
H323_UserInformation UserInfo;
DWORD dwAPDULen = 0;
BYTE* pEncodedAPDU = NULL;
H323DBG((DEBUG_LEVEL_TRACE, "EncodeProceedingMessage entered: %p.", this ));
CallProceeding_UUIE & proceedingMessage =
UserInfo.h323_uu_pdu.h323_message_body.u.callProceeding;
*ppEncodedBuf = NULL;
*pdwEncodedLength = 0;
memset( (PVOID)&UserInfo, 0, sizeof(H323_UserInformation));
UserInfo.bit_mask = 0;
// make sure the user_data_present flag is turned off.
UserInfo.bit_mask &= (~user_data_present);
UserInfo.h323_uu_pdu.bit_mask = 0;
if( dwAPDUType != NO_H450_APDU )
{
if( !EncodeH450APDU( dwInvokeID, dwAPDUType, &pEncodedAPDU, &dwAPDULen ) )
{
return FALSE;
}
UserInfo.h323_uu_pdu.h4501SupplementaryService = &h4501APDU;
UserInfo.h323_uu_pdu.h4501SupplementaryService -> next = NULL;
UserInfo.h323_uu_pdu.h4501SupplementaryService -> value.value = pEncodedAPDU;
UserInfo.h323_uu_pdu.h4501SupplementaryService -> value.length = dwAPDULen;
UserInfo.h323_uu_pdu.bit_mask |= h4501SupplementaryService_present;
}
UserInfo.h323_uu_pdu.h245Tunneling = FALSE;//(m_fh245Tunneling & LOCAL_H245_TUNNELING);
UserInfo.h323_uu_pdu.bit_mask |= h245Tunneling_present;
SetNonStandardData( UserInfo );
UserInfo.h323_uu_pdu.h323_message_body.choice = callProceeding_chosen;
proceedingMessage.protocolIdentifier = OID_H225ProtocolIdentifierV2;
TransportAddress& transportAddress = proceedingMessage.h245Address;
//send H245 address only if the caller hasn't proposed FasrStart
//or the fast start proposal has been accepeted
if( (m_pPeerFastStart == NULL) || m_pFastStart )
{
if( m_selfH245Addr.Addr.IP_Binary.dwAddr != 0 )
{
CopyTransportAddress( transportAddress, &m_selfH245Addr );
proceedingMessage.bit_mask |= CallProceeding_UUIE_h245Address_present;
}
else
{
proceedingMessage.bit_mask &= ~CallProceeding_UUIE_h245Address_present;
}
}
proceedingMessage.destinationInfo.bit_mask = 0;
//copy the vendor info
proceedingMessage.destinationInfo.bit_mask |= vendor_present;
CopyVendorInfo( &proceedingMessage.destinationInfo.vendor );
proceedingMessage.destinationInfo.mc = 0;
proceedingMessage.destinationInfo.undefinedNode = 0;
if( m_pFastStart != NULL )
{
_ASSERTE( m_pPeerFastStart );
proceedingMessage.bit_mask |= Alerting_UUIE_fastStart_present;
proceedingMessage.fastStart =
(PCallProceeding_UUIE_fastStart)m_pFastStart;
}
else
{
proceedingMessage.bit_mask &= ~Alerting_UUIE_fastStart_present;
}
//copy the call identifier
proceedingMessage.bit_mask |= CallProceeding_UUIE_callIdentifier_present;
CopyMemory( (PVOID)&proceedingMessage.callIdentifier.guid.value,
(PVOID)&m_callIdentifier,
sizeof(GUID) );
proceedingMessage.callIdentifier.guid.length = sizeof(GUID);
rc = EncodeASN( (void *) &UserInfo,
H323_UserInformation_PDU,
ppEncodedBuf,
pdwEncodedLength);
if (ASN1_FAILED(rc) || (*ppEncodedBuf == NULL) || (pdwEncodedLength == 0) )
{
if( pEncodedAPDU != NULL )
{
ASN1_FreeEncoded(m_H450ASNCoderInfo.pEncInfo, pEncodedAPDU );
}
return FALSE;
}
if( pEncodedAPDU != NULL )
{
ASN1_FreeEncoded(m_H450ASNCoderInfo.pEncInfo, pEncodedAPDU );
}
H323DBG((DEBUG_LEVEL_TRACE, "EncodeProceedingMessage exited: %p.", this ));
//success
return TRUE;
}
//!!always called in a lock
BOOL
CH323Call::EncodeReleaseCompleteMessage(
IN DWORD dwInvokeID,
IN BYTE *pbReason,
OUT BYTE **ppEncodedBuf,
OUT WORD *pdwEncodedLength,
IN DWORD dwAPDUType
)
{
H323_UU_PDU_h4501SupplementaryService h4501APDU;
int rc;
H323_UserInformation UserInfo;
DWORD dwAPDULen = 0;
BYTE* pEncodedAPDU = NULL;
H323DBG((DEBUG_LEVEL_TRACE, "EncodeReleaseCompleteMessage entered: %p.", this ));
ReleaseComplete_UUIE & releaseMessage =
UserInfo.h323_uu_pdu.h323_message_body.u.releaseComplete;
*ppEncodedBuf = NULL;
*pdwEncodedLength = 0;
memset( (PVOID)&UserInfo, 0, sizeof(H323_UserInformation));
UserInfo.bit_mask = 0;
// make sure the user_data_present flag is turned off.
UserInfo.bit_mask &= (~user_data_present);
UserInfo.h323_uu_pdu.bit_mask = 0;
if( dwAPDUType != NO_H450_APDU )
{
if( !EncodeH450APDU( dwInvokeID, dwAPDUType, &pEncodedAPDU, &dwAPDULen ) )
{
return FALSE;
}
UserInfo.h323_uu_pdu.h4501SupplementaryService = &h4501APDU;
UserInfo.h323_uu_pdu.h4501SupplementaryService -> next = NULL;
UserInfo.h323_uu_pdu.h4501SupplementaryService -> value.value = pEncodedAPDU;
UserInfo.h323_uu_pdu.h4501SupplementaryService -> value.length = dwAPDULen;
UserInfo.h323_uu_pdu.bit_mask |= h4501SupplementaryService_present;
}
SetNonStandardData( UserInfo );
UserInfo.h323_uu_pdu.h323_message_body.choice = releaseComplete_chosen;
releaseMessage.protocolIdentifier = OID_H225ProtocolIdentifierV2;
if( pbReason )
{
releaseMessage.reason.choice = 0;
releaseMessage.bit_mask |= (ReleaseComplete_UUIE_reason_present);
switch (*pbReason)
{
case H323_REJECT_NO_BANDWIDTH:
releaseMessage.reason.choice = noBandwidth_chosen;
break;
case H323_REJECT_GATEKEEPER_RESOURCES:
releaseMessage.reason.choice = gatekeeperResources_chosen;
break;
case H323_REJECT_UNREACHABLE_DESTINATION:
releaseMessage.reason.choice = unreachableDestination_chosen;
break;
case H323_REJECT_DESTINATION_REJECTION:
releaseMessage.reason.choice = destinationRejection_chosen;
break;
case H323_REJECT_INVALID_REVISION:
releaseMessage.reason.choice
= ReleaseCompleteReason_invalidRevision_chosen;
break;
case H323_REJECT_NO_PERMISSION:
releaseMessage.reason.choice = noPermission_chosen;
break;
case H323_REJECT_UNREACHABLE_GATEKEEPER:
releaseMessage.reason.choice = unreachableGatekeeper_chosen;
break;
case H323_REJECT_GATEWAY_RESOURCES:
releaseMessage.reason.choice = gatewayResources_chosen;
break;
case H323_REJECT_BAD_FORMAT_ADDRESS:
releaseMessage.reason.choice = badFormatAddress_chosen;
break;
case H323_REJECT_ADAPTIVE_BUSY:
releaseMessage.reason.choice = adaptiveBusy_chosen;
break;
case H323_REJECT_IN_CONF:
releaseMessage.reason.choice = inConf_chosen;
break;
case H323_REJECT_CALL_DEFLECTION:
releaseMessage.reason.choice =
ReleaseCompleteReason_undefinedReason_chosen ;
break;
case H323_REJECT_UNDEFINED_REASON:
releaseMessage.reason.choice = ReleaseCompleteReason_undefinedReason_chosen ;
break;
case H323_REJECT_USER_BUSY:
releaseMessage.reason.choice = inConf_chosen;
break;
default:
//log
if( pEncodedAPDU != NULL )
{
ASN1_FreeEncoded(m_H450ASNCoderInfo.pEncInfo, pEncodedAPDU );
}
return FALSE;
}
}
rc = EncodeASN( (void *) &UserInfo,
H323_UserInformation_PDU,
ppEncodedBuf,
pdwEncodedLength);
if (ASN1_FAILED(rc) || (*ppEncodedBuf == NULL) || (pdwEncodedLength == 0) )
{
if( pEncodedAPDU != NULL )
{
ASN1_FreeEncoded(m_H450ASNCoderInfo.pEncInfo, pEncodedAPDU );
}
return FALSE;
}
if( pEncodedAPDU != NULL )
{
ASN1_FreeEncoded(m_H450ASNCoderInfo.pEncInfo, pEncodedAPDU );
}
H323DBG((DEBUG_LEVEL_TRACE, "EncodeReleaseCompleteMessage exited: %p.", this ));
//success
return TRUE;
}
//!!always called in a lock
BOOL
CH323Call::EncodeConnectMessage(
IN DWORD dwInvokeID,
OUT BYTE **ppEncodedBuf,
OUT WORD *pdwEncodedLength,
IN DWORD dwAPDUType
)
{
H323_UU_PDU_h4501SupplementaryService h4501APDU;
int rc;
H323_UserInformation UserInfo;
DWORD dwAPDULen = 0;
BYTE* pEncodedAPDU = NULL;
H323DBG((DEBUG_LEVEL_TRACE, "EncodeConnectMessage entered: %p.", this ));
Connect_UUIE & connectMessage =
UserInfo.h323_uu_pdu.h323_message_body.u.connect;
*ppEncodedBuf = NULL;
*pdwEncodedLength = 0;
memset( (PVOID)&UserInfo, 0, sizeof(H323_UserInformation));
UserInfo.bit_mask = 0;
// make sure the user_data_present flag is turned off.
UserInfo.bit_mask &= (~user_data_present);
UserInfo.h323_uu_pdu.bit_mask = 0;
//send the appropriate ADPDUS
if( dwAPDUType != NO_H450_APDU )
{
if( !EncodeH450APDU( dwInvokeID, dwAPDUType,
&pEncodedAPDU, &dwAPDULen ) )
{
return FALSE;
}
UserInfo.h323_uu_pdu.h4501SupplementaryService = &h4501APDU;
UserInfo.h323_uu_pdu.h4501SupplementaryService -> next = NULL;
UserInfo.h323_uu_pdu.h4501SupplementaryService -> value.value = pEncodedAPDU;
UserInfo.h323_uu_pdu.h4501SupplementaryService -> value.length = dwAPDULen;
UserInfo.h323_uu_pdu.bit_mask |= h4501SupplementaryService_present;
}
UserInfo.h323_uu_pdu.h245Tunneling = FALSE;//(m_fh245Tunneling & LOCAL_H245_TUNNELING);
UserInfo.h323_uu_pdu.bit_mask |= h245Tunneling_present;
SetNonStandardData( UserInfo );
UserInfo.h323_uu_pdu.h323_message_body.choice = connect_chosen;
connectMessage.protocolIdentifier = OID_H225ProtocolIdentifierV2;
TransportAddress& transportAddress = connectMessage.h245Address;
CopyTransportAddress( transportAddress, &m_selfH245Addr );
connectMessage.bit_mask |= (Connect_UUIE_h245Address_present);
connectMessage.destinationInfo.bit_mask = 0;
//copy the vendor info
connectMessage.destinationInfo.bit_mask |= vendor_present;
CopyVendorInfo( &connectMessage.destinationInfo.vendor );
//terminal is present
connectMessage.destinationInfo.bit_mask |= terminal_present;
connectMessage.destinationInfo.terminal.bit_mask = 0;
connectMessage.destinationInfo.mc = 0;
connectMessage.destinationInfo.undefinedNode = 0;
//copy the 16 byte conference ID
CopyConferenceID (&connectMessage.conferenceID, &m_ConferenceID);
if( m_pFastStart != NULL )
{
_ASSERTE( m_pPeerFastStart );
connectMessage.bit_mask |= Connect_UUIE_fastStart_present;
connectMessage.fastStart = (PConnect_UUIE_fastStart)m_pFastStart;
}
else
{
connectMessage.bit_mask &= ~Alerting_UUIE_fastStart_present;
}
//copy the call identifier
connectMessage.bit_mask |= Connect_UUIE_callIdentifier_present;
CopyMemory( (PVOID)&connectMessage.callIdentifier.guid.value,
(PVOID)&m_callIdentifier,
sizeof(GUID) );
connectMessage.callIdentifier.guid.length = sizeof(GUID);
rc = EncodeASN( (void *) &UserInfo,
H323_UserInformation_PDU,
ppEncodedBuf,
pdwEncodedLength);
if (ASN1_FAILED(rc) || (*ppEncodedBuf == NULL) || (pdwEncodedLength == 0) )
{
if( pEncodedAPDU != NULL )
{
ASN1_FreeEncoded(m_H450ASNCoderInfo.pEncInfo, pEncodedAPDU );
}
return FALSE;
}
if( pEncodedAPDU != NULL )
{
ASN1_FreeEncoded(m_H450ASNCoderInfo.pEncInfo, pEncodedAPDU );
}
H323DBG((DEBUG_LEVEL_TRACE, "EncodeConnectMessage exited: %p.", this ));
//success
return TRUE;
}
//!!always called in a lock
void CH323Call::SetNonStandardData(
OUT H323_UserInformation & UserInfo
)
{
if( m_NonStandardData.sData.pOctetString )
{
H221NonStandard & nonStd =
UserInfo.h323_uu_pdu.nonStandardData.nonStandardIdentifier.u.h221NonStandard;
UserInfo.h323_uu_pdu.bit_mask |= H323_UU_PDU_nonStandardData_present;
UserInfo.h323_uu_pdu.nonStandardData.nonStandardIdentifier.choice
= H225NonStandardIdentifier_h221NonStandard_chosen;
nonStd.t35CountryCode = m_NonStandardData.bCountryCode;
nonStd.t35Extension = m_NonStandardData.bExtension;
nonStd.manufacturerCode = m_NonStandardData.wManufacturerCode;
UserInfo.h323_uu_pdu.nonStandardData.data.length =
m_NonStandardData.sData.wOctetStringLength;
UserInfo.h323_uu_pdu.nonStandardData.data.value =
m_NonStandardData.sData.pOctetString;
// Maintain only one reference to the buffer.
m_NonStandardData.sData.pOctetString = NULL;
}
else
{
UserInfo.h323_uu_pdu.bit_mask &= (~H323_UU_PDU_nonStandardData_present);
}
}
//!!always called in a lock
BOOL
CH323Call::EncodeSetupMessage(
IN DWORD dwInvokeID,
IN WORD wGoal,
IN WORD wCallType,
OUT BYTE **ppEncodedBuf,
OUT WORD *pdwEncodedLength,
IN DWORD dwAPDUType
)
{
H323_UU_PDU_h4501SupplementaryService h4501APDU;
H323_UserInformation UserInfo;
int rc = 0;
BOOL retVal = TRUE;
DWORD dwAPDULen = 0;
BYTE* pEncodedAPDU = NULL;
*ppEncodedBuf = NULL;
*pdwEncodedLength = 0;
H323DBG((DEBUG_LEVEL_TRACE, "EncodeSetupMessage entered: %p.", this ));
Setup_UUIE & setupMessage = UserInfo.h323_uu_pdu.h323_message_body.u.setup;
TransportAddress& calleeAddr = setupMessage.destCallSignalAddress;
TransportAddress& callerAddr = setupMessage.sourceCallSignalAddress;
memset( (PVOID)&UserInfo, 0, sizeof(H323_UserInformation));
UserInfo.bit_mask = 0;
// make sure the user_data_present flag is turned off.
UserInfo.bit_mask &= (~user_data_present);
UserInfo.h323_uu_pdu.bit_mask = 0;
//send the appropriate ADPDUS
if( dwAPDUType != NO_H450_APDU )
{
if( !EncodeH450APDU( dwInvokeID, dwAPDUType, &pEncodedAPDU, &dwAPDULen ) )
{
return FALSE;
}
UserInfo.h323_uu_pdu.h4501SupplementaryService = &h4501APDU;
UserInfo.h323_uu_pdu.h4501SupplementaryService -> next = NULL;
UserInfo.h323_uu_pdu.h4501SupplementaryService -> value.value = pEncodedAPDU;
UserInfo.h323_uu_pdu.h4501SupplementaryService -> value.length = dwAPDULen;
UserInfo.h323_uu_pdu.bit_mask |= h4501SupplementaryService_present;
}
UserInfo.h323_uu_pdu.h245Tunneling = FALSE;//(m_fh245Tunneling & LOCAL_H245_TUNNELING);
UserInfo.h323_uu_pdu.bit_mask |= h245Tunneling_present;
SetNonStandardData( UserInfo );
UserInfo.h323_uu_pdu.h323_message_body.choice = setup_chosen;
setupMessage.bit_mask = 0;
setupMessage.protocolIdentifier = OID_H225ProtocolIdentifierV2;
if( m_pCallerAliasNames && m_pCallerAliasNames -> wCount )
{
//H323DBG(( DEBUG_LEVEL_ERROR, "Caller alias count:%d : %p", m_pCallerAliasNames->wCount, this ));
setupMessage.sourceAddress = SetMsgAddressAlias(m_pCallerAliasNames);
if( setupMessage.sourceAddress != NULL )
{
setupMessage.bit_mask |= (sourceAddress_present);
}
else
{
setupMessage.bit_mask &= (~sourceAddress_present);
}
}
else
{
setupMessage.bit_mask &= (~sourceAddress_present);
}
setupMessage.sourceInfo.bit_mask = 0;
//pass the vendor info
setupMessage.sourceInfo.bit_mask |= vendor_present;
CopyVendorInfo( &setupMessage.sourceInfo.vendor );
//terminal is present
setupMessage.sourceInfo.bit_mask |= terminal_present;
setupMessage.sourceInfo.terminal.bit_mask = 0;
//not an MC
setupMessage.sourceInfo.mc = FALSE;
setupMessage.sourceInfo.undefinedNode = 0;
if( m_pCalleeAliasNames && m_pCalleeAliasNames -> wCount )
{
setupMessage.destinationAddress = (PSetup_UUIE_destinationAddress)
SetMsgAddressAlias( m_pCalleeAliasNames );
if( setupMessage.destinationAddress != NULL )
{
setupMessage.bit_mask |= (destinationAddress_present);
}
else
{
setupMessage.bit_mask &= (~destinationAddress_present);
}
}
else
{
setupMessage.bit_mask &= (~destinationAddress_present);
}
//extra alias not present
setupMessage.bit_mask &= (~Setup_UUIE_destExtraCallInfo_present );
//If talking to gateway then don't pass on destn call signal address
if( m_dwAddressType != LINEADDRESSTYPE_PHONENUMBER )
{
CopyTransportAddress( calleeAddr, &m_CalleeAddr );
setupMessage.bit_mask |= Setup_UUIE_destCallSignalAddress_present;
}
//not an MC
setupMessage.activeMC = m_fActiveMC;
//copy the 16 byte conference ID
CopyConferenceID (&setupMessage.conferenceID, &m_ConferenceID);
//copy the call identifier
setupMessage.bit_mask |= Setup_UUIE_callIdentifier_present;
CopyConferenceID (&setupMessage.callIdentifier.guid, &m_callIdentifier);
//fast start params
if( m_pFastStart != NULL )
{
setupMessage.bit_mask |= Setup_UUIE_fastStart_present;
setupMessage.fastStart = (PSetup_UUIE_fastStart)m_pFastStart;
}
else
{
setupMessage.bit_mask &= ~Setup_UUIE_fastStart_present;
}
//copy media wait for connect
setupMessage.mediaWaitForConnect = FALSE;
setupMessage.conferenceGoal.choice = (BYTE)wGoal;
setupMessage.callType.choice = (BYTE)wCallType;
CopyTransportAddress( callerAddr, &m_CallerAddr );
setupMessage.bit_mask |= sourceCallSignalAddress_present;
//no extension alias
setupMessage.bit_mask &= (~Setup_UUIE_remoteExtensionAddress_present);
rc = EncodeASN( (void *) &UserInfo,
H323_UserInformation_PDU,
ppEncodedBuf,
pdwEncodedLength);
if( ASN1_FAILED(rc) || (*ppEncodedBuf == NULL) || (pdwEncodedLength == 0) )
{
if( pEncodedAPDU != NULL )
{
ASN1_FreeEncoded(m_H450ASNCoderInfo.pEncInfo, pEncodedAPDU );
}
retVal = FALSE;
}
// Free the alias name structures from the UserInfo area.
if( setupMessage.bit_mask & sourceAddress_present )
{
FreeAddressAliases( (PSetup_UUIE_destinationAddress)
setupMessage.sourceAddress );
}
if( setupMessage.bit_mask & destinationAddress_present )
{
FreeAddressAliases( setupMessage.destinationAddress );
}
if( pEncodedAPDU != NULL )
{
ASN1_FreeEncoded(m_H450ASNCoderInfo.pEncInfo, pEncodedAPDU );
}
H323DBG((DEBUG_LEVEL_TRACE, "EncodeSetupMessage exited: %p.", this ));
//success/failure
return retVal;
}
//!!always called in a lock
BOOL
CH323Call::EncodeH450APDU(
IN DWORD dwInvokeID,
IN DWORD dwAPDUType,
OUT BYTE** ppEncodedAPDU,
OUT DWORD* pdwAPDULen
)
{
H4501SupplementaryService SupplementaryServiceAPDU;
ServiceApdus_rosApdus rosAPDU;
DWORD dwErrorCode = 0;
DWORD dwOperationType = (dwAPDUType & 0x0000FF00);
dwAPDUType &= 0x000000FF;
H323DBG((DEBUG_LEVEL_TRACE, "EncodeH450APDU entered: %p.", this ));
ZeroMemory( (PVOID)&SupplementaryServiceAPDU,
sizeof(H4501SupplementaryService) );
//interpretationAPDU
SupplementaryServiceAPDU.interpretationApdu.choice =
rejectAnyUnrecognizedInvokePdu_chosen;
SupplementaryServiceAPDU.bit_mask |= interpretationApdu_present;
//NFE
SupplementaryServiceAPDU.networkFacilityExtension.bit_mask = 0;
SupplementaryServiceAPDU.networkFacilityExtension.destinationEntity.choice
= endpoint_chosen;
SupplementaryServiceAPDU.networkFacilityExtension.sourceEntity.choice
= endpoint_chosen;
SupplementaryServiceAPDU.bit_mask |= networkFacilityExtension_present;
//serviceAPDUS
SupplementaryServiceAPDU.serviceApdu.choice = rosApdus_chosen;
SupplementaryServiceAPDU.serviceApdu.u.rosApdus = &rosAPDU;
SupplementaryServiceAPDU.serviceApdu.u.rosApdus->next = NULL;
if( dwOperationType == H450_REJECT )
{
if( !EncodeRejectAPDU( &SupplementaryServiceAPDU, dwInvokeID,
ppEncodedAPDU, pdwAPDULen ) )
{
return FALSE;
}
}
else if( dwOperationType == H450_RETURNERROR )
{
EncodeReturnErrorAPDU( dwInvokeID, dwErrorCode,
&SupplementaryServiceAPDU, ppEncodedAPDU, pdwAPDULen );
}
else if( dwOperationType == H450_RETURNRESULT )
{
if( !EncodeDummyReturnResultAPDU( dwInvokeID,
dwAPDUType, &SupplementaryServiceAPDU,
ppEncodedAPDU, pdwAPDULen ) )
{
return FALSE;
}
}
else //H450_INVOKE
{
switch( dwAPDUType )
{
case CHECKRESTRICTION_OPCODE:
if( !EncodeCheckRestrictionAPDU( &SupplementaryServiceAPDU,
ppEncodedAPDU, pdwAPDULen ) )
{
return FALSE;
}
break;
case CALLREROUTING_OPCODE:
if( !EncodeCallReroutingAPDU( &SupplementaryServiceAPDU,
ppEncodedAPDU, pdwAPDULen ) )
{
return FALSE;
}
break;
case DIVERTINGLEGINFO2_OPCODE:
if( !EncodeDivertingLeg2APDU( &SupplementaryServiceAPDU,
ppEncodedAPDU, pdwAPDULen ) )
{
return FALSE;
}
break;
case DIVERTINGLEGINFO3_OPCODE:
if( !EncodeDivertingLeg3APDU( &SupplementaryServiceAPDU,
ppEncodedAPDU, pdwAPDULen ) )
{
return FALSE;
}
break;
case HOLDNOTIFIC_OPCODE:
case REMOTEHOLD_OPCODE:
case RETRIEVENOTIFIC_OPCODE:
case REMOTERETRIEVE_OPCODE:
case CTIDENTIFY_OPCODE:
if( !EncodeH450APDUNoArgument( dwAPDUType, &SupplementaryServiceAPDU,
ppEncodedAPDU, pdwAPDULen ) )
{
return FALSE;
}
break;
case CTSETUP_OPCODE:
if( !EncodeCTSetupAPDU( &SupplementaryServiceAPDU,
ppEncodedAPDU, pdwAPDULen ) )
{
return FALSE;
}
break;
case CTINITIATE_OPCODE:
if( !EncodeCTInitiateAPDU( &SupplementaryServiceAPDU,
ppEncodedAPDU, pdwAPDULen ) )
{
return FALSE;
}
break;
default:
_ASSERTE( 0 );
return FALSE;
}
}
H323DBG((DEBUG_LEVEL_TRACE, "EncodeH450APDU exited: %p.", this ));
return TRUE;
}
//!!always called in a lock
BOOL
CH323Call::EncodePDU(
IN BINARY_STRING *pUserUserData,
OUT BYTE ** ppbCodedBuffer,
OUT DWORD * pdwCodedBufferLength,
IN DWORD dwMessageType,
WCHAR * pwszCalledPartyNumber
)
{
PQ931MESSAGE pMessage;
BYTE bBandwidth;
char pszDisplay[131] = "";
DWORD dwMessageLength = 0;
BYTE indexI;
BOOL retVal;
H323DBG(( DEBUG_LEVEL_TRACE, "EncodePDU entered: %p.", this ));
pMessage = new Q931MESSAGE;
if( pMessage == NULL )
{
return FALSE;
}
// fill in the required fields for the Q931 message.
memset( (PVOID)pMessage, 0, sizeof(Q931MESSAGE));
pMessage->ProtocolDiscriminator = Q931PDVALUE;
pMessage->wCallRef = m_wQ931CallRef;
pMessage->MessageType = (BYTE)dwMessageType;
dwMessageLength +=
( 1 + sizeof(PDTYPE) + sizeof(CRTYPE) + sizeof(MESSAGEIDTYPE) );
if( (dwMessageType == SETUPMESSAGETYPE) ||
(dwMessageType == CONNECTMESSAGETYPE) )
{
if( m_pwszDisplay &&
WideCharToMultiByte(CP_ACP,
0,
m_pwszDisplay,
-1,
pszDisplay,
sizeof(pszDisplay),
NULL,
NULL) == 0)
{
delete pMessage;
return FALSE;
}
if( *pszDisplay )
{
pMessage->Display.fPresent = TRUE;
pMessage->Display.dwLength = (BYTE)(strlen(pszDisplay) + 1);
strcpy((char *)pMessage->Display.pbContents, pszDisplay);
dwMessageLength += (2 + pMessage->Display.dwLength);
}
pMessage->BearerCapability.fPresent = TRUE;
pMessage->BearerCapability.dwLength = 3;
pMessage->BearerCapability.pbContents[0] =
(BYTE)(BEAR_EXT_BIT | BEAR_CCITT | BEAR_UNRESTRICTED_DIGITAL);
pMessage->BearerCapability.pbContents[1] =
(BYTE)(BEAR_EXT_BIT | 0x17); //64kbps
pMessage->BearerCapability.pbContents[2] = (BYTE)
(BEAR_EXT_BIT | BEAR_LAYER1_INDICATOR | BEAR_LAYER1_H221_H242);
dwMessageLength += (2+pMessage->BearerCapability.dwLength);
}
//if talking to gateway encode the called party number
if( m_dwAddressType == LINEADDRESSTYPE_PHONENUMBER )
{
BYTE bLen = (BYTE)(wcslen(pwszCalledPartyNumber)+1);
pMessage->CalledPartyNumber.fPresent = TRUE;
pMessage->CalledPartyNumber.NumberType =
(BYTE)(CALLED_PARTY_EXT_BIT | CALLED_PARTY_TYPE_UNKNOWN);
pMessage->CalledPartyNumber.NumberingPlan =
(BYTE)(CALLED_PARTY_PLAN_E164);
pMessage->CalledPartyNumber.PartyNumberLength = bLen;
for( indexI =0; indexI < bLen; indexI++ )
{
pMessage->CalledPartyNumber.PartyNumbers[indexI] =
(BYTE)pwszCalledPartyNumber[indexI];
}
dwMessageLength += (2 + pMessage->CalledPartyNumber.PartyNumberLength);
}
if( dwMessageType == FACILITYMESSAGETYPE )
{
// The facility ie is encoded as present, but empty...
pMessage->Facility.fPresent = TRUE;
pMessage->Facility.dwLength = 0;
pMessage->Facility.pbContents[0] = 0;
dwMessageLength += (2 + pMessage->Facility.dwLength);
}
if (pUserUserData && pUserUserData->pbBuffer)
{
if (pUserUserData->length > sizeof(pMessage->UserToUser.pbUserInfo))
{
delete pMessage;
return FALSE;
}
pMessage->UserToUser.fPresent = TRUE;
pMessage->UserToUser.wUserInfoLen = pUserUserData->length;
//This CopyMemory should be avoided
//may be we should do:pMessage->UserToUser.pbUserInfo = pUserUserData->pbBuffer;
//change the definition of pMessage->UserToUser.pbUserInfo to BYTE* from BYTE[0x1000]
CopyMemory( (PVOID)pMessage->UserToUser.pbUserInfo,
(PVOID)pUserUserData->pbBuffer, pUserUserData->length );
dwMessageLength += (4+pMessage->UserToUser.wUserInfoLen);
}
_ASSERTE( dwMessageLength );
retVal = EncodeMessage( pMessage, ppbCodedBuffer,
pdwCodedBufferLength, dwMessageLength );
delete pMessage;
return retVal;
}
//!!always called in a lock
BOOL
CH323Call::EncodeMessage(
IN PQ931MESSAGE pMessage,
OUT BYTE **ppbCodedMessage,
OUT DWORD *pdwCodedMessageLength,
IN DWORD dwMessageLength
)
{
BUFFERDESCR pBuf;
DWORD dwPDULen = 0;
H323DBG((DEBUG_LEVEL_TRACE, "EncodeMessage entered: %p.", this ));
*ppbCodedMessage = (BYTE *)new char[ dwMessageLength + 100 ];
if( *ppbCodedMessage == NULL )
{
return FALSE;
}
pBuf.dwLength = dwMessageLength + 100;
pBuf.pbBuffer = *ppbCodedMessage + TPKT_HEADER_SIZE;
WriteQ931Fields(&pBuf, pMessage, &dwPDULen );
_ASSERTE( dwPDULen == dwMessageLength );
SetupTPKTHeader( *ppbCodedMessage , dwPDULen );
*pdwCodedMessageLength = dwPDULen + 4;
H323DBG((DEBUG_LEVEL_TRACE, "EncodeMessage exited: %p.", this ));
return TRUE;
}
//!!always called in a lock
void
CH323Call::WriteQ931Fields(
IN PBUFFERDESCR pBuf,
IN PQ931MESSAGE pMessage,
OUT DWORD * pdwPDULen
)
{
H323DBG((DEBUG_LEVEL_TRACE, "WriteQ931Fields entered: %p.", this ));
// write the required information elements...
WriteProtocolDiscriminator( pBuf, pdwPDULen );
WriteCallReference( pBuf, &pMessage->wCallRef,
pdwPDULen );
WriteMessageType(pBuf, &pMessage->MessageType,
pdwPDULen);
// try to write all other information elements...
// don't write this message.
if (pMessage->Facility.fPresent)
{
WriteVariableOctet(pBuf, IDENT_FACILITY,
pMessage->Facility.dwLength,
pMessage->Facility.pbContents,
pdwPDULen);
}
if( pMessage->BearerCapability.fPresent
&& pMessage->BearerCapability.dwLength )
{
WriteVariableOctet(pBuf, IDENT_BEARERCAP,
pMessage->BearerCapability.dwLength,
pMessage->BearerCapability.pbContents,
pdwPDULen);
}
if (pMessage->Display.fPresent && pMessage->Display.dwLength)
{
WriteVariableOctet(pBuf, IDENT_DISPLAY,
pMessage->Display.dwLength,
pMessage->Display.pbContents,
pdwPDULen);
}
if( pMessage->CalledPartyNumber.fPresent )
{
WritePartyNumber(pBuf,
IDENT_CALLEDNUMBER,
pMessage->CalledPartyNumber.NumberType,
pMessage->CalledPartyNumber.NumberingPlan,
pMessage->CalledPartyNumber.PartyNumberLength,
pMessage->CalledPartyNumber.PartyNumbers,
pdwPDULen);
}
if( pMessage->UserToUser.fPresent &&
pMessage->UserToUser.wUserInfoLen )
{
WriteUserInformation(pBuf,
IDENT_USERUSER,
pMessage->UserToUser.wUserInfoLen,
pMessage->UserToUser.pbUserInfo,
pdwPDULen);
}
H323DBG((DEBUG_LEVEL_TRACE, "WriteQ931Fields exited: %p.", this ));
}
//!!always calld in a lock
void
CH323Call::HandleTransportEvent(void)
{
WSANETWORKEVENTS networkEvents;
int iError;
H323DBG(( DEBUG_LEVEL_TRACE, "HandleTransportEvent entered: %p.", this ));
if( (m_callSocket == INVALID_SOCKET) &&
(m_dwCallType == CALLTYPE_DIVERTEDSRC) )
{
H323DBG(( DEBUG_LEVEL_TRACE, "The diverted call is not initialized yet."
"This is probably an event for the primary call. Ignore it %p.",
this ));
return;
}
//find out the event that took place
if(WSAEnumNetworkEvents(m_callSocket,
m_hTransport,
&networkEvents ) == SOCKET_ERROR )
{
H323DBG((DEBUG_LEVEL_TRACE, "WSAEnumNetworkEvents error:%d, %lx, %p.",
WSAGetLastError(), m_callSocket, this ));
return;
}
if( networkEvents.lNetworkEvents & FD_CLOSE )
{
H323DBG((DEBUG_LEVEL_TRACE, "socket close event: %p.", this ));
//if the call is in transition then don't close the call when the
//old socket gets closed
if( m_fCallInTrnasition == TRUE )
{
//the call is noot in transition mode anymore
m_fCallInTrnasition = FALSE;
return;
}
//convey the Q931 close status to the TAPI call object
//and the tapisrv
iError = networkEvents.iErrorCode[FD_CLOSE_BIT];
SetQ931CallState( Q931_CALL_DISCONNECTED );
//clean up the Q931 call
CloseCall( 0 );
return;
}
//This can occur only for outbound calls
if( (networkEvents.lNetworkEvents) & FD_CONNECT )
{
H323DBG((DEBUG_LEVEL_TRACE, "socket connect event: %p.", this ));
//FD_CONNECT event received
//This func is called by the callback thread when m_hEventQ931Conn is
//signalled. This function takes care of the outgoing Q931 calls only
//call the member function
iError = networkEvents.iErrorCode[FD_CONNECT_BIT];
if(iError != ERROR_SUCCESS)
{
if( (m_dwCallType & CALLTYPE_FORWARDCONSULT )&&
(m_dwOrigin == LINECALLORIGIN_OUTBOUND ) )
{
//Success of forwarding
EnableCallForwarding();
}
H323DBG((DEBUG_LEVEL_ERROR, "FD_CONNECT returned error: %d.",
iError ));
CloseCall( 0 );
return;
}
OnConnectComplete();
}
H323DBG((DEBUG_LEVEL_TRACE, "HandleTransportEvent exited: %p.", this ));
}
//!!always called in a lock
int
CH323Call::InitASNCoder(void)
{
int rc;
H323DBG((DEBUG_LEVEL_TRACE, "InitASNCoder entered: %p.", this ));
memset((PVOID)&m_ASNCoderInfo, 0, sizeof(m_ASNCoderInfo));
if( H225ASN_Module == NULL)
{
return ASN1_ERR_BADARGS;
}
rc = ASN1_CreateEncoder(
H225ASN_Module, // ptr to mdule
&(m_ASNCoderInfo.pEncInfo), // ptr to encoder info
NULL, // buffer ptr
0, // buffer size
NULL); // parent ptr
if (rc == ASN1_SUCCESS)
{
_ASSERTE(m_ASNCoderInfo.pEncInfo );
rc = ASN1_CreateDecoder(
H225ASN_Module, // ptr to mdule
&(m_ASNCoderInfo.pDecInfo), // ptr to decoder info
NULL, // buffer ptr
0, // buffer size
NULL); // parent ptr
_ASSERTE(m_ASNCoderInfo.pDecInfo );
}
if (rc != ASN1_SUCCESS)
{
TermASNCoder();
}
H323DBG((DEBUG_LEVEL_TRACE, "InitASNCoder exited: %p.", this ));
return rc;
}
//!!always called in a lock
int
CH323Call::TermASNCoder(void)
{
if( H225ASN_Module == NULL )
{
return ASN1_ERR_BADARGS;
}
ASN1_CloseEncoder(m_ASNCoderInfo.pEncInfo);
ASN1_CloseDecoder(m_ASNCoderInfo.pDecInfo);
memset( (PVOID)&m_ASNCoderInfo, 0, sizeof(m_ASNCoderInfo));
return ASN1_SUCCESS;
}
//!!always called in a lock
int
CH323Call::EncodeASN(
IN void * pStruct,
IN int nPDU,
OUT BYTE ** ppEncoded,
OUT WORD * pcbEncodedSize
)
{
H323DBG((DEBUG_LEVEL_TRACE, "EncodeASN entered: %p.", this ));
ASN1encoding_t pEncInfo = m_ASNCoderInfo.pEncInfo;
int rc = ASN1_Encode(
pEncInfo, // ptr to encoder info
pStruct, // pdu data structure
nPDU, // pdu id
ASN1ENCODE_ALLOCATEBUFFER, // flags
NULL, // do not provide buffer
0); // buffer size if provided
if (ASN1_SUCCEEDED(rc))
{
if( rc != ASN1_SUCCESS )
{
H323DBG((DEBUG_LEVEL_TRACE, "warning while encoding ASN:%d.", rc ));
}
*pcbEncodedSize = (WORD)pEncInfo->len; // len of encoded data in buffer
*ppEncoded = pEncInfo->buf; // buffer to encode into
}
else
{
H323DBG((DEBUG_LEVEL_TRACE, "error while encoding ASN:%d.", rc ));
*pcbEncodedSize = 0;
*ppEncoded = NULL;
}
H323DBG((DEBUG_LEVEL_TRACE, "EncodeASN exited: %p.", this ));
return rc;
}
//!!always called in a lock
int
CH323Call::DecodeASN(
OUT void ** ppStruct,
IN int nPDU,
IN BYTE * pEncoded,
IN DWORD cbEncodedSize
)
{
H323DBG((DEBUG_LEVEL_TRACE, "h323call DecodeASN entered: %p.", this ));
ASN1decoding_t pDecInfo = m_ASNCoderInfo.pDecInfo;
int rc = ASN1_Decode(
pDecInfo, // ptr to encoder info
ppStruct, // pdu data structure
nPDU, // pdu id
ASN1DECODE_SETBUFFER, // flags
pEncoded, // do not provide buffer
cbEncodedSize); // buffer size if provided
if (ASN1_SUCCEEDED(rc))
{
if( rc != ASN1_SUCCESS )
{
H323DBG((DEBUG_LEVEL_TRACE, "warning while deciding ASN:%d.", rc ));
}
}
else
{
H323DBG((DEBUG_LEVEL_TRACE, "error while deciding ASN:%d.", rc ));
H323DUMPBUFFER( (BYTE*)pEncoded, cbEncodedSize);
*ppStruct = NULL;
}
H323DBG((DEBUG_LEVEL_TRACE, "h323call DecodeASN exited: %p.", this ));
return rc;
}
//!!always called in a lock
int
CH323Call::InitH450ASNCoder(void)
{
int rc;
H323DBG((DEBUG_LEVEL_TRACE, "InitH450ASNCoder entered: %p.", this ));
memset((PVOID)&m_H450ASNCoderInfo, 0, sizeof(m_H450ASNCoderInfo));
if( H4503PP_Module == NULL)
{
return ASN1_ERR_BADARGS;
}
rc = ASN1_CreateEncoder(
H4503PP_Module, // ptr to mdule
&(m_H450ASNCoderInfo.pEncInfo), // ptr to encoder info
NULL, // buffer ptr
0, // buffer size
NULL); // parent ptr
if (rc == ASN1_SUCCESS)
{
_ASSERTE(m_H450ASNCoderInfo.pEncInfo );
rc = ASN1_CreateDecoder(
H4503PP_Module, // ptr to mdule
&(m_H450ASNCoderInfo.pDecInfo), // ptr to decoder info
NULL, // buffer ptr
0, // buffer size
NULL ); // parent ptr
_ASSERTE( m_H450ASNCoderInfo.pDecInfo );
}
if (rc != ASN1_SUCCESS)
{
TermH450ASNCoder();
}
H323DBG((DEBUG_LEVEL_TRACE, "InitH450ASNCoder exited: %p.", this ));
return rc;
}
//!!always called in a lock
int
CH323Call::TermH450ASNCoder(void)
{
if( H4503PP_Module == NULL )
{
return ASN1_ERR_BADARGS;
}
ASN1_CloseEncoder(m_H450ASNCoderInfo.pEncInfo);
ASN1_CloseDecoder(m_H450ASNCoderInfo.pDecInfo);
memset( (PVOID)&m_H450ASNCoderInfo, 0, sizeof(m_ASNCoderInfo));
return ASN1_SUCCESS;
}
//!!always called in a lock
int
CH323Call::EncodeH450ASN(
IN void * pStruct,
IN int nPDU,
OUT BYTE ** ppEncoded,
OUT WORD * pcbEncodedSize
)
{
H323DBG((DEBUG_LEVEL_TRACE, "EncodeH450ASN entered: %p.", this ));
ASN1encoding_t pEncInfo = m_H450ASNCoderInfo.pEncInfo;
int rc = ASN1_Encode(
pEncInfo, // ptr to encoder info
pStruct, // pdu data structure
nPDU, // pdu id
ASN1ENCODE_ALLOCATEBUFFER, // flags
NULL, // do not provide buffer
0); // buffer size if provided
if (ASN1_SUCCEEDED(rc))
{
if( rc != ASN1_SUCCESS )
{
H323DBG((DEBUG_LEVEL_TRACE, "warning while encoding ASN:%d.", rc ));
}
*pcbEncodedSize = (WORD)pEncInfo->len; // len of encoded data in buffer
*ppEncoded = pEncInfo->buf; // buffer to encode into
}
else
{
H323DBG((DEBUG_LEVEL_TRACE, "error while encoding ASN:%d.", rc ));
*pcbEncodedSize = 0;
*ppEncoded = NULL;
}
H323DBG((DEBUG_LEVEL_TRACE, "EncodeH450ASN exited: %p.", this ));
return rc;
}
//!!always called in a lock
int
CH323Call::DecodeH450ASN(
OUT void ** ppStruct,
IN int nPDU,
IN BYTE * pEncoded,
IN DWORD cbEncodedSize
)
{
H323DBG((DEBUG_LEVEL_TRACE, "h323call DecodeH450ASN entered: %p.", this ));
ASN1decoding_t pDecInfo = m_H450ASNCoderInfo.pDecInfo;
int rc = ASN1_Decode(
pDecInfo, // ptr to encoder info
ppStruct, // pdu data structure
nPDU, // pdu id
ASN1DECODE_SETBUFFER, // flags
pEncoded, // do not provide buffer
cbEncodedSize); // buffer size if provided
if( ASN1_SUCCEEDED(rc) )
{
if( rc != ASN1_SUCCESS )
{
H323DBG((DEBUG_LEVEL_TRACE, "warning while deciding ASN:%d.", rc ));
}
}
else
{
H323DBG((DEBUG_LEVEL_TRACE, "error while deciding ASN:%d.", rc ));
H323DUMPBUFFER( (BYTE*)pEncoded, cbEncodedSize);
*ppStruct = NULL;
}
H323DBG(( DEBUG_LEVEL_TRACE, "h323call DecodeH450ASN exited: %p.", this ));
return rc;
}
//------------------------------------------------------------------------
//------------------------------------------------------------------------
//!!always called in a lock
BOOL
CH323Call::ParseReleaseCompleteASN(
IN BYTE *pEncodedBuf,
IN DWORD dwEncodedLength,
OUT Q931_RELEASE_COMPLETE_ASN *pReleaseASN,
OUT DWORD* pdwH450APDUType
)
{
H323_UserInformation *pUserInfo;
int iResult;
DWORD dwInvokeID = 0;
H323DBG((DEBUG_LEVEL_TRACE, "ParseReleaseCompleteASN entered: %p.", this ));
memset( (PVOID)pReleaseASN, 0, sizeof(Q931_RELEASE_COMPLETE_ASN));
iResult = DecodeASN((void **) &pUserInfo,
H323_UserInformation_PDU,
pEncodedBuf,
dwEncodedLength);
if (ASN1_FAILED(iResult) || (pUserInfo == NULL))
{
return FALSE;
}
*pdwH450APDUType = 0;
if( (pUserInfo->h323_uu_pdu.bit_mask & h4501SupplementaryService_present) &&
pUserInfo->h323_uu_pdu.h4501SupplementaryService )
{
if( !HandleH450APDU( pUserInfo->h323_uu_pdu.h4501SupplementaryService,
pdwH450APDUType, &dwInvokeID, NULL ) )
{
goto cleanup;
}
}
// validate that the PDU user-data uses ASN encoding.
if( (pUserInfo->bit_mask & user_data_present) &&
(pUserInfo->user_data.protocol_discriminator != USE_ASN1_ENCODING) )
{
goto cleanup;
}
// validate that the PDU is H323 Release Complete information.
if( pUserInfo->h323_uu_pdu.h323_message_body.choice != releaseComplete_chosen )
{
goto cleanup;
}
// parse the message contained in pUserInfo.
pReleaseASN->fNonStandardDataPresent = FALSE;
if( pUserInfo->h323_uu_pdu.bit_mask & H323_UU_PDU_nonStandardData_present )
{
if( !ParseNonStandardData( &pReleaseASN -> nonStandardData,
&pUserInfo->h323_uu_pdu.nonStandardData ) )
{
goto cleanup;
}
pReleaseASN->fNonStandardDataPresent = TRUE;
}
if (pUserInfo->h323_uu_pdu.h323_message_body.u.releaseComplete.bit_mask &
ReleaseComplete_UUIE_reason_present)
{
switch( pUserInfo->h323_uu_pdu.h323_message_body.u.releaseComplete.reason.choice )
{
case noBandwidth_chosen:
pReleaseASN->bReason = H323_REJECT_NO_BANDWIDTH;
break;
case gatekeeperResources_chosen:
pReleaseASN->bReason = H323_REJECT_GATEKEEPER_RESOURCES;
break;
case unreachableDestination_chosen:
pReleaseASN->bReason = H323_REJECT_UNREACHABLE_DESTINATION;
break;
case destinationRejection_chosen:
pReleaseASN->bReason = H323_REJECT_DESTINATION_REJECTION;
break;
case ReleaseCompleteReason_invalidRevision_chosen:
pReleaseASN->bReason = H323_REJECT_INVALID_REVISION;
break;
case noPermission_chosen:
pReleaseASN->bReason = H323_REJECT_NO_PERMISSION;
break;
case unreachableGatekeeper_chosen:
pReleaseASN->bReason = H323_REJECT_UNREACHABLE_GATEKEEPER;
break;
case gatewayResources_chosen:
pReleaseASN->bReason = H323_REJECT_GATEWAY_RESOURCES;
break;
case badFormatAddress_chosen:
pReleaseASN->bReason = H323_REJECT_BAD_FORMAT_ADDRESS;
break;
case adaptiveBusy_chosen:
pReleaseASN->bReason = H323_REJECT_ADAPTIVE_BUSY;
break;
case inConf_chosen:
pReleaseASN->bReason = H323_REJECT_IN_CONF;
break;
case facilityCallDeflection_chosen:
pReleaseASN->bReason = H323_REJECT_CALL_DEFLECTION;
break;
default:
pReleaseASN->bReason = H323_REJECT_UNDEFINED_REASON;
} // switch
}
else
{
pReleaseASN->bReason = H323_REJECT_UNDEFINED_REASON;
}
H323DBG(( DEBUG_LEVEL_TRACE,
"ParseReleaseCompleteASN error:%d, q931 error:%d, exit:%p.",
pReleaseASN->bReason,
pUserInfo->h323_uu_pdu.h323_message_body.u.releaseComplete.reason.choice,
this ));
// Free the PDU data.
ASN1_FreeDecoded(m_ASNCoderInfo.pDecInfo, pUserInfo,
H323_UserInformation_PDU );
return TRUE;
cleanup:
if( pReleaseASN->fNonStandardDataPresent )
{
delete pReleaseASN -> nonStandardData.sData.pOctetString;
pReleaseASN -> nonStandardData.sData.pOctetString = NULL;
pReleaseASN->fNonStandardDataPresent = FALSE;
}
ASN1_FreeDecoded( m_ASNCoderInfo.pDecInfo, pUserInfo,
H323_UserInformation_PDU);
return FALSE;
}
//------------------------------------------------------------------------
//------------------------------------------------------------------------
//!!always called in a lock
BOOL
CH323Call::ParseConnectASN(
IN BYTE *pEncodedBuf,
IN DWORD dwEncodedLength,
OUT Q931_CONNECT_ASN *pConnectASN,
OUT DWORD* pdwH450APDUType
)
{
H323_UserInformation *pUserInfo;
int iResult;
DWORD dwInvokeID = 0;
H323DBG((DEBUG_LEVEL_TRACE, "ParseConnectASN entered: %p.", this ));
memset( (PVOID) pConnectASN, 0, sizeof(Q931_CONNECT_ASN) );
iResult = DecodeASN((void **) &pUserInfo ,
H323_UserInformation_PDU,
pEncodedBuf,
dwEncodedLength);
if (ASN1_FAILED(iResult) || (pUserInfo == NULL))
{
return FALSE;
}
Connect_UUIE & connectMessage =
pUserInfo->h323_uu_pdu.h323_message_body.u.connect;
*pdwH450APDUType = 0;
if( (pUserInfo->h323_uu_pdu.bit_mask & h4501SupplementaryService_present) &&
pUserInfo->h323_uu_pdu.h4501SupplementaryService )
{
if( !HandleH450APDU( pUserInfo->h323_uu_pdu.h4501SupplementaryService,
pdwH450APDUType, &dwInvokeID, NULL ) )
{
goto cleanup;
}
}
// validate that the PDU user-data uses ASN encoding.
if( (pUserInfo->bit_mask & user_data_present) &&
(pUserInfo->user_data.protocol_discriminator != USE_ASN1_ENCODING) )
{
goto cleanup;
}
// validate that the PDU is H323 Connect information.
if (pUserInfo->h323_uu_pdu.h323_message_body.choice != connect_chosen)
{
goto cleanup;
}
// make sure that the conference id is formed correctly.
if (connectMessage.conferenceID.length >
sizeof(connectMessage.conferenceID.value))
{
goto cleanup;
}
// parse the message contained in pUserInfo.
pConnectASN->h245Addr.bMulticast = FALSE;
pConnectASN->fNonStandardDataPresent = FALSE;
if( pUserInfo->h323_uu_pdu.bit_mask & H323_UU_PDU_nonStandardData_present )
{
if( !ParseNonStandardData( &pConnectASN -> nonStandardData,
&pUserInfo->h323_uu_pdu.nonStandardData ) )
{
goto cleanup;
}
pConnectASN->fNonStandardDataPresent = TRUE;
}
pConnectASN->h245AddrPresent = FALSE;
if( connectMessage.bit_mask & Connect_UUIE_h245Address_present )
{
if( connectMessage.h245Address.choice != ipAddress_chosen )
{
goto cleanup;
}
pConnectASN->h245Addr.nAddrType = H323_IP_BINARY;
pConnectASN->h245Addr.Addr.IP_Binary.wPort =
connectMessage.h245Address.u.ipAddress.port;
pConnectASN->h245Addr.Addr.IP_Binary.dwAddr =
ntohl( *((DWORD*)connectMessage.h245Address.u.ipAddress.ip.value) );
pConnectASN->h245AddrPresent = TRUE;
}
// no validation of destinationInfo needed.
pConnectASN->EndpointType.pVendorInfo = NULL;
if( connectMessage.destinationInfo.bit_mask & (vendor_present))
{
if( !ParseVendorInfo( &pConnectASN->VendorInfo,
&connectMessage.destinationInfo.vendor) )
{
goto cleanup;
}
pConnectASN->EndpointType.pVendorInfo = &(pConnectASN->VendorInfo);
}
pConnectASN->EndpointType.bIsTerminal = FALSE;
if (connectMessage.destinationInfo.bit_mask & (terminal_present))
{
pConnectASN->EndpointType.bIsTerminal = TRUE;
}
pConnectASN->EndpointType.bIsGateway = FALSE;
if (connectMessage.destinationInfo.bit_mask & (gateway_present))
{
pConnectASN->EndpointType.bIsGateway = TRUE;
}
pConnectASN -> fFastStartPresent = FALSE;
if( (connectMessage.bit_mask & Connect_UUIE_fastStart_present) &&
connectMessage.fastStart )
{
pConnectASN->pFastStart = CopyFastStart(
(PSetup_UUIE_fastStart)connectMessage.fastStart );
if( pConnectASN->pFastStart != NULL )
{
pConnectASN -> fFastStartPresent = TRUE;
}
}
CopyConferenceID( &pConnectASN -> ConferenceID,
&connectMessage.conferenceID );
if( pUserInfo->h323_uu_pdu.h245Tunneling )
{
//the remote endpoint has sent a tunneling proposal
m_fh245Tunneling |= REMOTE_H245_TUNNELING;
}
// Free the PDU data.
ASN1_FreeDecoded(m_ASNCoderInfo.pDecInfo, pUserInfo,
H323_UserInformation_PDU);
H323DBG((DEBUG_LEVEL_TRACE, "ParseConnectASN exited: %p.", this ));
return TRUE;
cleanup:
FreeConnectASN( pConnectASN );
ASN1_FreeDecoded(m_ASNCoderInfo.pDecInfo, pUserInfo,
H323_UserInformation_PDU );
return FALSE;
}
//!!always called in a lock
BOOL
CH323Call::ParseAlertingASN(
IN BYTE *pEncodedBuf,
IN DWORD dwEncodedLength,
OUT Q931_ALERTING_ASN *pAlertingASN,
OUT DWORD* pdwH450APDUType
)
{
H323_UserInformation *pUserInfo;
int iResult;
DWORD dwInvokeID = 0;
H323DBG((DEBUG_LEVEL_TRACE, "ParseAlertingASN entered: %p.", this ));
memset( (PVOID) pAlertingASN, 0, sizeof(Q931_ALERTING_ASN) );
iResult = DecodeASN((void **) &pUserInfo,
H323_UserInformation_PDU,
pEncodedBuf,
dwEncodedLength);
if (ASN1_FAILED(iResult) || (pUserInfo == NULL))
{
return FALSE;
}
Alerting_UUIE & alertingMessage =
pUserInfo->h323_uu_pdu.h323_message_body.u.alerting;
*pdwH450APDUType = 0;
if( (pUserInfo->h323_uu_pdu.bit_mask & h4501SupplementaryService_present) &&
pUserInfo->h323_uu_pdu.h4501SupplementaryService )
{
if( !HandleH450APDU( pUserInfo->h323_uu_pdu.h4501SupplementaryService,
pdwH450APDUType, &dwInvokeID, NULL ) )
{
goto cleanup;
}
}
// validate that the PDU user-data uses ASN encoding.
if( (pUserInfo->bit_mask & user_data_present ) &&
(pUserInfo->user_data.protocol_discriminator != USE_ASN1_ENCODING) )
{
goto cleanup;
}
// validate that the PDU is H323 Alerting information.
if (pUserInfo->h323_uu_pdu.h323_message_body.choice != alerting_chosen)
{
goto cleanup;
}
// parse the message contained in pUserInfo.
pAlertingASN->h245Addr.bMulticast = FALSE;
pAlertingASN->fNonStandardDataPresent = FALSE;
if( pUserInfo->h323_uu_pdu.bit_mask & H323_UU_PDU_nonStandardData_present )
{
if( !ParseNonStandardData( &pAlertingASN -> nonStandardData,
&pUserInfo->h323_uu_pdu.nonStandardData ) )
{
goto cleanup;
}
pAlertingASN->fNonStandardDataPresent = TRUE;
}
if( alertingMessage.bit_mask & Alerting_UUIE_h245Address_present )
{
if( alertingMessage.h245Address.choice != ipAddress_chosen )
{
goto cleanup;
}
pAlertingASN->h245Addr.nAddrType = H323_IP_BINARY;
pAlertingASN->h245Addr.Addr.IP_Binary.wPort =
alertingMessage.h245Address.u.ipAddress.port;
AddressReverseAndCopy(
&(pAlertingASN->h245Addr.Addr.IP_Binary.dwAddr),
alertingMessage.h245Address.u.ipAddress.ip.value );
}
pAlertingASN -> fFastStartPresent = FALSE;
if( (alertingMessage.bit_mask & Alerting_UUIE_fastStart_present) &&
alertingMessage.fastStart )
{
pAlertingASN->pFastStart = CopyFastStart(
(PSetup_UUIE_fastStart)alertingMessage.fastStart);
if( pAlertingASN->pFastStart != NULL )
pAlertingASN-> fFastStartPresent = TRUE;
}
if( pUserInfo->h323_uu_pdu.h245Tunneling )
{
m_fh245Tunneling |= REMOTE_H245_TUNNELING;
}
// Free the PDU data.
ASN1_FreeDecoded(m_ASNCoderInfo.pDecInfo, pUserInfo,
H323_UserInformation_PDU);
H323DBG((DEBUG_LEVEL_TRACE, "ParseAlertingASN exited: %p.", this ));
return TRUE;
cleanup:
FreeAlertingASN( pAlertingASN );
ASN1_FreeDecoded( m_ASNCoderInfo.pDecInfo, pUserInfo,
H323_UserInformation_PDU );
return FALSE;
}
//!!aleways called in a lock
BOOL
CH323Call::ParseProceedingASN(
IN BYTE *pEncodedBuf,
IN DWORD dwEncodedLength,
OUT Q931_CALL_PROCEEDING_ASN *pProceedingASN,
OUT DWORD* pdwH450APDUType
)
{
H323_UserInformation * pUserInfo;
int iResult;
DWORD dwInvokeID = 0;
H323DBG((DEBUG_LEVEL_TRACE, "ParseProceedingASN entered: %p.", this ));
memset( (PVOID) pProceedingASN, 0, sizeof(Q931_CALL_PROCEEDING_ASN) );
iResult = DecodeASN((void **) &pUserInfo,
H323_UserInformation_PDU,
pEncodedBuf,
dwEncodedLength);
if (ASN1_FAILED(iResult) || (pUserInfo == NULL))
{
return FALSE;
}
CallProceeding_UUIE & proceedingMessage =
pUserInfo->h323_uu_pdu.h323_message_body.u.callProceeding;
*pdwH450APDUType = 0;
if( (pUserInfo->h323_uu_pdu.bit_mask & h4501SupplementaryService_present) &&
pUserInfo->h323_uu_pdu.h4501SupplementaryService )
{
if( !HandleH450APDU( pUserInfo->h323_uu_pdu.h4501SupplementaryService,
pdwH450APDUType, &dwInvokeID, NULL ) )
goto cleanup;
}
// validate that the PDU user-data uses ASN encoding.
if( (pUserInfo->bit_mask & user_data_present) &&
(pUserInfo->user_data.protocol_discriminator != USE_ASN1_ENCODING) )
{
goto cleanup;
}
// validate that the PDU is H323 Proceeding information.
// validate that the PDU is H323 pCall Proceeding information.
if( pUserInfo->h323_uu_pdu.h323_message_body.choice != callProceeding_chosen )
{
goto cleanup;
}
// parse the message contained in pUserInfo.
pProceedingASN->fNonStandardDataPresent = FALSE;
if( pUserInfo->h323_uu_pdu.bit_mask & H323_UU_PDU_nonStandardData_present )
{
if( !ParseNonStandardData( &pProceedingASN -> nonStandardData,
&pUserInfo->h323_uu_pdu.nonStandardData ) )
{
goto cleanup;
}
pProceedingASN->fNonStandardDataPresent = TRUE;
}
//copy the H245 address information
pProceedingASN->fH245AddrPresent = FALSE;
if( proceedingMessage.bit_mask & CallProceeding_UUIE_h245Address_present )
{
if( proceedingMessage.h245Address.choice != ipAddress_chosen )
{
goto cleanup;
}
pProceedingASN->h245Addr.nAddrType = H323_IP_BINARY;
pProceedingASN->h245Addr.Addr.IP_Binary.wPort =
proceedingMessage.h245Address.u.ipAddress.port;
AddressReverseAndCopy(
&(pProceedingASN->h245Addr.Addr.IP_Binary.dwAddr),
proceedingMessage.h245Address.u.ipAddress.ip.value );
pProceedingASN->h245Addr.bMulticast = FALSE;
pProceedingASN->fH245AddrPresent = TRUE;
}
pProceedingASN -> fFastStartPresent = FALSE;
if( (proceedingMessage.bit_mask & CallProceeding_UUIE_fastStart_present) &&
proceedingMessage.fastStart )
{
pProceedingASN->pFastStart = CopyFastStart(
(PSetup_UUIE_fastStart)proceedingMessage.fastStart);
if( pProceedingASN->pFastStart != NULL )
pProceedingASN-> fFastStartPresent = TRUE;
}
//ignore the destinationInfo field.
if( pUserInfo->h323_uu_pdu.h245Tunneling )
{
if( m_dwOrigin == LINECALLORIGIN_INBOUND )
{
//the msp has enabled tunneling in ProceedWithAnswer messsage
m_fh245Tunneling |= LOCAL_H245_TUNNELING;
}
else
//the remote endpoint has sent a tunneling proposal
m_fh245Tunneling |= REMOTE_H245_TUNNELING;
}
// Free the PDU data.
ASN1_FreeDecoded(m_ASNCoderInfo.pDecInfo, pUserInfo,
H323_UserInformation_PDU );
H323DBG((DEBUG_LEVEL_TRACE, "ParseProceedingASN exited: %p.", this ));
return TRUE;
cleanup:
FreeProceedingASN( pProceedingASN );
ASN1_FreeDecoded(m_ASNCoderInfo.pDecInfo, pUserInfo,
H323_UserInformation_PDU );
return FALSE;
}
//!!always called in a lock
BOOL
CH323Call::ParseFacilityASN(
IN BYTE * pEncodedBuf,
IN DWORD dwEncodedLength,
OUT Q931_FACILITY_ASN * pFacilityASN
)
{
H323_UserInformation *pUserInfo;
int iResult;
H323DBG((DEBUG_LEVEL_TRACE, "ParseFacilityASN entered: %p.", this ));
ZeroMemory( (PVOID) pFacilityASN, sizeof(Q931_FACILITY_ASN) );
iResult = DecodeASN((void **) &pUserInfo,
H323_UserInformation_PDU,
pEncodedBuf,
dwEncodedLength);
if( ASN1_FAILED(iResult) || (pUserInfo == NULL) )
{
return FALSE;
}
// validate that the PDU is H323 facility information.
if( pUserInfo->h323_uu_pdu.h323_message_body.choice == facility_chosen )
{
Facility_UUIE & facilityMessage =
pUserInfo->h323_uu_pdu.h323_message_body.u.facility;
// validate that the PDU user-data uses ASN encoding.
if( (pUserInfo->bit_mask & user_data_present) &&
(pUserInfo->user_data.protocol_discriminator != USE_ASN1_ENCODING) )
{
goto cleanup;
}
// make sure that the conference id is formed correctly.
if( facilityMessage.conferenceID.length >
sizeof(facilityMessage.conferenceID.value) )
{
//goto cleanup;
}
// parse the message contained in pUserInfo.
pFacilityASN->fNonStandardDataPresent = FALSE;
if( pUserInfo->h323_uu_pdu.bit_mask & H323_UU_PDU_nonStandardData_present )
{
if( !ParseNonStandardData( &pFacilityASN -> nonStandardData,
&pUserInfo->h323_uu_pdu.nonStandardData ) )
{
goto cleanup;
}
pFacilityASN->fNonStandardDataPresent = TRUE;
}
pFacilityASN->fAlternativeAddressPresent = FALSE;
if( facilityMessage.bit_mask & alternativeAddress_present )
{
if( facilityMessage.alternativeAddress.choice == ipAddress_chosen )
{
pFacilityASN->AlternativeAddr.nAddrType = H323_IP_BINARY;
pFacilityASN->AlternativeAddr.Addr.IP_Binary.wPort =
facilityMessage.alternativeAddress.u.ipAddress.port;
AddressReverseAndCopy(
&(pFacilityASN->AlternativeAddr.Addr.IP_Binary.dwAddr),
facilityMessage.alternativeAddress.u.ipAddress.ip.value );
pFacilityASN->fAlternativeAddressPresent = TRUE;
}
}
if( facilityMessage.bit_mask & alternativeAliasAddress_present )
{
if( !AliasAddrToAliasNames( &(pFacilityASN->pAlternativeAliasList),
(PSetup_UUIE_sourceAddress)
&(facilityMessage.alternativeAliasAddress) ) )
{
pFacilityASN -> pAlternativeAliasList = NULL;
//goto cleanup;
}
}
if( facilityMessage.bit_mask & Facility_UUIE_conferenceID_present )
{
CopyConferenceID( &pFacilityASN -> ConferenceID,
&facilityMessage.conferenceID );
pFacilityASN -> ConferenceIDPresent = TRUE;
}
pFacilityASN->bReason = facilityMessage.reason.choice;
pFacilityASN->fH245AddrPresent = FALSE;
if( facilityMessage.bit_mask & Facility_UUIE_h245Address_present )
{
if( facilityMessage.h245Address.choice == ipAddress_chosen )
{
pFacilityASN->h245Addr.nAddrType = H323_IP_BINARY;
pFacilityASN->h245Addr.Addr.IP_Binary.wPort =
facilityMessage.h245Address.u.ipAddress.port;
pFacilityASN->h245Addr.Addr.IP_Binary.dwAddr =
ntohl( *((DWORD*)facilityMessage.h245Address.u.ipAddress.ip.value) );
pFacilityASN->fH245AddrPresent = TRUE;
}
}
}
pFacilityASN->dwH450APDUType = 0;
if( (pUserInfo->h323_uu_pdu.bit_mask & h4501SupplementaryService_present) &&
pUserInfo->h323_uu_pdu.h4501SupplementaryService )
{
pFacilityASN->dwInvokeID = 0;
if( !HandleH450APDU( pUserInfo->h323_uu_pdu.h4501SupplementaryService,
&pFacilityASN->dwH450APDUType, &pFacilityASN->dwInvokeID, NULL ) )
{
goto cleanup;
}
}
if( pUserInfo->h323_uu_pdu.bit_mask & h245Control_present )
{
if( pUserInfo->h323_uu_pdu.h245Control != NULL )
{
pFacilityASN->pH245PDU.value =
new BYTE[pUserInfo->h323_uu_pdu.h245Control->value.length];
if( pFacilityASN->pH245PDU.value != NULL )
{
CopyMemory( (PVOID)pFacilityASN->pH245PDU.value,
(PVOID)pUserInfo->h323_uu_pdu.h245Control->value.value,
pUserInfo->h323_uu_pdu.h245Control->value.length );
}
pFacilityASN->pH245PDU.length =
pUserInfo->h323_uu_pdu.h245Control->value.length;
}
}
ASN1_FreeDecoded( m_ASNCoderInfo.pDecInfo, pUserInfo,
H323_UserInformation_PDU );
H323DBG((DEBUG_LEVEL_TRACE, "ParseFacilityASN exited: %p.", this ));
return TRUE;
cleanup:
if( pFacilityASN -> pAlternativeAliasList != NULL )
{
FreeAliasNames( pFacilityASN -> pAlternativeAliasList );
pFacilityASN -> pAlternativeAliasList = NULL;
}
if( pFacilityASN->fNonStandardDataPresent != NULL )
{
delete pFacilityASN->nonStandardData.sData.pOctetString;
pFacilityASN->nonStandardData.sData.pOctetString = NULL;
pFacilityASN->fNonStandardDataPresent = NULL;
}
ASN1_FreeDecoded(m_ASNCoderInfo.pDecInfo, pUserInfo,
H323_UserInformation_PDU );
return FALSE;
}
//!!aleways called in a lock
BOOL
CH323Call::ParseSetupASN(
IN BYTE *pEncodedBuf,
IN DWORD dwEncodedLength,
OUT Q931_SETUP_ASN *pSetupASN,
OUT DWORD* pdwH450APDUType
)
{
H323_UserInformation *pUserInfo;
HRESULT hr;
int iResult;
DWORD dwInvokeID = 0;
H323DBG((DEBUG_LEVEL_TRACE, "ParseSetupASN entered: %p.", this ));
memset( (PVOID)pSetupASN, 0, sizeof(Q931_SETUP_ASN));
iResult = DecodeASN((void **) &pUserInfo,
H323_UserInformation_PDU,
pEncodedBuf,
dwEncodedLength);
if (ASN1_FAILED(iResult) || (pUserInfo == NULL))
{
return FALSE;
}
Setup_UUIE & setupMessage = pUserInfo->h323_uu_pdu.h323_message_body.u.setup;
// validate that the PDU user-data uses ASN encoding.
if( (pUserInfo->bit_mask & user_data_present) &&
(pUserInfo->user_data.protocol_discriminator != USE_ASN1_ENCODING) )
{
//log
goto cleanup;
}
// validate that the PDU is H323 Setup information.
if( pUserInfo->h323_uu_pdu.h323_message_body.choice != setup_chosen )
{
//log
goto cleanup;
}
// make sure that the conference id is formed correctly.
if (setupMessage.conferenceID.length >
sizeof(setupMessage.conferenceID.value))
{
goto cleanup;
}
// parse the message contained in pUserInfo.
pSetupASN->sourceAddr.bMulticast = FALSE;
pSetupASN->callerAddr.bMulticast = FALSE;
pSetupASN->calleeDestAddr.bMulticast = FALSE;
pSetupASN->calleeAddr.bMulticast = FALSE;
// no validation of sourceInfo needed.
//copy thevendor info
pSetupASN->EndpointType.pVendorInfo = NULL;
if( setupMessage.sourceInfo.bit_mask & vendor_present )
{
if( !ParseVendorInfo( &pSetupASN->VendorInfo,
&setupMessage.sourceInfo.vendor) )
{
goto cleanup;
}
pSetupASN->EndpointType.pVendorInfo = &(pSetupASN->VendorInfo);
}
pSetupASN->EndpointType.bIsTerminal = FALSE;
if( setupMessage.sourceInfo.bit_mask & terminal_present )
{
pSetupASN->EndpointType.bIsTerminal = TRUE;
}
pSetupASN->EndpointType.bIsGateway = FALSE;
if( setupMessage.sourceInfo.bit_mask & gateway_present )
{
pSetupASN->EndpointType.bIsGateway = TRUE;
}
pSetupASN->fNonStandardDataPresent = FALSE;
if( pUserInfo->h323_uu_pdu.bit_mask & H323_UU_PDU_nonStandardData_present )
{
if( !ParseNonStandardData( &pSetupASN -> nonStandardData,
&pUserInfo->h323_uu_pdu.nonStandardData ) )
{
goto cleanup;
}
pSetupASN->fNonStandardDataPresent = TRUE;
}
// parse the sourceAddress aliases here...
if( setupMessage.bit_mask & sourceAddress_present )
{
if( !AliasAddrToAliasNames( &(pSetupASN->pCallerAliasList),
setupMessage.sourceAddress ) )
{
pSetupASN->pCallerAliasList = NULL;
//goto cleanup;
}
}
// parse the destinationAddress aliases here...
if( (setupMessage.bit_mask & destinationAddress_present) &&
setupMessage.destinationAddress )
{
if( !AliasAddrToAliasNames( &(pSetupASN->pCalleeAliasList),
(PSetup_UUIE_sourceAddress)setupMessage.destinationAddress) )
{
pSetupASN->pCalleeAliasList = NULL;
//goto cleanup;
}
}
// parse the destExtraCallInfo aliases here...
if( (setupMessage.bit_mask & Setup_UUIE_destExtraCallInfo_present) &&
setupMessage.destExtraCallInfo )
{
if( !AliasAddrToAliasNames(&(pSetupASN->pExtraAliasList),
(PSetup_UUIE_sourceAddress)setupMessage.destExtraCallInfo) )
{
pSetupASN->pExtraAliasList = NULL;
//goto cleanup;
}
}
// parse the remoteExtensionAddress aliases here...
if( setupMessage.bit_mask & Setup_UUIE_remoteExtensionAddress_present )
{
pSetupASN->pExtensionAliasItem = new H323_ALIASITEM;
if( pSetupASN->pExtensionAliasItem == NULL )
{
goto cleanup;
}
hr = AliasAddrToAliasItem(pSetupASN->pExtensionAliasItem,
&(setupMessage.remoteExtensionAddress));
if( hr == E_OUTOFMEMORY )
{
goto cleanup;
}
}
pSetupASN -> fCalleeDestAddrPresent = FALSE;
if( setupMessage.bit_mask & Setup_UUIE_destCallSignalAddress_present )
{
if( setupMessage.destCallSignalAddress.choice != ipAddress_chosen )
{
goto cleanup;
}
pSetupASN->calleeDestAddr.nAddrType = H323_IP_BINARY;
pSetupASN->calleeDestAddr.Addr.IP_Binary.wPort =
setupMessage.destCallSignalAddress.u.ipAddress.port;
AddressReverseAndCopy(
&(pSetupASN->calleeDestAddr.Addr.IP_Binary.dwAddr),
setupMessage.destCallSignalAddress.u.ipAddress.ip.value );
pSetupASN -> fCalleeDestAddrPresent = TRUE;
}
pSetupASN->fSourceAddrPresent = FALSE;
if( setupMessage.bit_mask & sourceCallSignalAddress_present )
{
if( setupMessage.sourceCallSignalAddress.choice != ipAddress_chosen )
{
goto cleanup;
}
pSetupASN->sourceAddr.nAddrType = H323_IP_BINARY;
pSetupASN->sourceAddr.Addr.IP_Binary.wPort =
setupMessage.sourceCallSignalAddress.u.ipAddress.port;
pSetupASN->sourceAddr.Addr.IP_Binary.dwAddr = ntohl( *((DWORD*)
setupMessage.sourceCallSignalAddress.u.ipAddress.ip.value) );
pSetupASN->fSourceAddrPresent = TRUE;
}
pSetupASN->bCallerIsMC = setupMessage.activeMC;
pSetupASN -> fFastStartPresent = FALSE;
if( (setupMessage.bit_mask & Setup_UUIE_fastStart_present) &&
setupMessage.fastStart )
{
pSetupASN->pFastStart = CopyFastStart( setupMessage.fastStart );
if( pSetupASN->pFastStart != NULL )
{
pSetupASN -> fFastStartPresent = TRUE;
}
}
CopyConferenceID (&pSetupASN -> ConferenceID, &setupMessage.conferenceID);
//copy the call identifier
pSetupASN -> fCallIdentifierPresent = FALSE;
if( setupMessage.bit_mask & Setup_UUIE_callIdentifier_present )
{
pSetupASN -> fCallIdentifierPresent = TRUE;
CopyMemory( (PVOID)&(pSetupASN->callIdentifier),
setupMessage.callIdentifier.guid.value,
sizeof(GUID) );
}
if( pUserInfo->h323_uu_pdu.h245Tunneling )
{
if( m_dwOrigin == LINECALLORIGIN_INBOUND )
{
//the remote endpoint has sent a tunneling proposal
m_fh245Tunneling |= REMOTE_H245_TUNNELING;
}
else
{
//the msp has enabled tunneling in ReadyToInitiate messsage
m_fh245Tunneling |= LOCAL_H245_TUNNELING;
}
}
pSetupASN->wGoal = (WORD)setupMessage.conferenceGoal.choice;
pSetupASN->wCallType = setupMessage.callType.choice;
*pdwH450APDUType = 0;
if( (pUserInfo->h323_uu_pdu.bit_mask & h4501SupplementaryService_present) &&
pUserInfo->h323_uu_pdu.h4501SupplementaryService )
{
if( !HandleH450APDU( pUserInfo->h323_uu_pdu.h4501SupplementaryService,
pdwH450APDUType, &dwInvokeID, pSetupASN ) )
{
goto cleanup;
}
}
// Free the PDU data.
ASN1_FreeDecoded( m_ASNCoderInfo.pDecInfo, pUserInfo,
H323_UserInformation_PDU );
H323DBG(( DEBUG_LEVEL_TRACE, "ParseSetupASN exited: %p.", this ));
return TRUE;
cleanup:
FreeSetupASN( pSetupASN );
ASN1_FreeDecoded(m_ASNCoderInfo.pDecInfo, pUserInfo,
H323_UserInformation_PDU);
return FALSE;
}
//-----------------------------------------------------------------------------
//GLOBAL CALLBACK FUNCTIONS CALLED BY THREAD POOL
//-----------------------------------------------------------------------------
// static
void
NTAPI CH323Call::IoCompletionCallback(
IN DWORD dwStatus,
IN DWORD dwBytesTransferred,
IN OVERLAPPED * pOverlapped
)
{
CALL_OVERLAPPED *pCallOverlapped;
CH323Call* pCall;
H323DBG(( DEBUG_LEVEL_TRACE, "CH323Call-IoCompletionCallback entered." ));
_ASSERTE (pOverlapped);
pCallOverlapped = CONTAINING_RECORD( pOverlapped, CALL_OVERLAPPED,
Overlapped );
pCall = pCallOverlapped -> pCall;
switch (pCallOverlapped -> Type)
{
case OVERLAPPED_TYPE_SEND:
pCall -> OnWriteComplete( dwStatus,
static_cast<CALL_SEND_CONTEXT *>(pCallOverlapped) );
break;
case OVERLAPPED_TYPE_RECV:
pCallOverlapped -> BytesTransferred = dwBytesTransferred;
pCall -> OnReadComplete( dwStatus,
static_cast<CALL_RECV_CONTEXT *>(pCallOverlapped) );
break;
default:
_ASSERTE(FALSE);
}
H323DBG(( DEBUG_LEVEL_TRACE, "CH323Call-IoCompletionCallback exited." ));
}
void
CH323Call::OnWriteComplete(
IN DWORD dwStatus,
IN CALL_SEND_CONTEXT * pSendContext
)
{
H323DBG(( DEBUG_LEVEL_TRACE, "OnWriteComplete entered:%p.",this ));
Lock();
_ASSERTE( m_IoRefCount != 0 );
m_IoRefCount--;
H323DBG((DEBUG_LEVEL_TRACE, "WriteComplete:m_IoRefCount: %d:%p.",
m_IoRefCount, this ));
if( m_dwFlags & CALLOBJECT_SHUTDOWN )
{
if( m_IoRefCount == 0 )
{
QueueTAPICallRequest( TSPI_DELETE_CALL, NULL );
H323DBG((DEBUG_LEVEL_TRACE, "call delete:%p.", this ));
}
}
else if( dwStatus == ERROR_SUCCESS )
{
if( IsInList( &m_sendBufList, &pSendContext->ListEntry ) )
{
RemoveEntryList( &pSendContext->ListEntry );
delete pSendContext->WSABuf.buf;
delete pSendContext;
}
}
Unlock();
H323DBG(( DEBUG_LEVEL_TRACE, "OnWriteComplete exited:%p.",this ));
}
void
CH323Call::OnReadComplete(
IN DWORD dwStatus,
IN CALL_RECV_CONTEXT * pRecvContext )
{
H323DBG(( DEBUG_LEVEL_TRACE, "OnReadComplete entered:%p.",this ));
Lock();
_ASSERTE( m_IoRefCount != 0 );
m_IoRefCount --;
H323DBG(( DEBUG_LEVEL_TRACE, "RecvBuffer:m_IoRefCount:%d:%p.",
m_IoRefCount, this ));
if( m_dwFlags & CALLOBJECT_SHUTDOWN )
{
if( m_IoRefCount == 0 )
{
QueueTAPICallRequest( TSPI_DELETE_CALL, NULL );
H323DBG((DEBUG_LEVEL_TRACE, "call delete:%p.", this ));
}
}
else
{
if( dwStatus == ERROR_SUCCESS )
{
_ASSERTE( m_pRecvBuffer == pRecvContext );
if( pRecvContext->BytesTransferred == 0 )
{
CloseCall( 0 );
H323DBG((DEBUG_LEVEL_TRACE, "0 bytes recvd:%p.", this ));
}
else
{
ReadEvent( pRecvContext->BytesTransferred );
}
}
}
Unlock();
H323DBG(( DEBUG_LEVEL_TRACE, "OnReadComplete exited:%p.",this ));
}
// static
void
NTAPI CH323Call::SetupSentTimerCallback(
IN PVOID Parameter1,
IN BOOLEAN bTimer
)
{
PH323_CALL pCall = NULL;
//if the timer expired
_ASSERTE( bTimer );
H323DBG(( DEBUG_LEVEL_TRACE, "Q931 setup expired event recvd." ));
pCall=g_pH323Line -> FindH323CallAndLock((HDRVCALL) Parameter1);
if( pCall != NULL )
{
pCall -> SetupSentTimerExpired();
pCall -> Unlock();
}
}
// static
void
NTAPI CH323Call::CheckRestrictionTimerCallback(
IN PVOID Parameter1,
IN BOOLEAN bTimer
)
{
//if the timer expired
_ASSERTE( bTimer );
H323DBG(( DEBUG_LEVEL_TRACE, "CheckRestrictionTimerCallback entered." ));
if(!QueueTAPILineRequest(
TSPI_CLOSE_CALL,
(HDRVCALL) Parameter1,
NULL,
LINEDISCONNECTMODE_NOANSWER,
NULL) )
{
H323DBG(( DEBUG_LEVEL_ERROR, "could not post H323 close event." ));
}
H323DBG(( DEBUG_LEVEL_TRACE, "CheckRestrictionTimerCallback exited." ));
}
// static
void
NTAPI CH323Call::CallReroutingTimerCallback(
IN PVOID Parameter1,
IN BOOLEAN bTimer
)
{
//If the timer expired
_ASSERTE( bTimer );
H323DBG(( DEBUG_LEVEL_TRACE, "CallReroutingTimerCallback entered." ));
if(!QueueTAPILineRequest(
TSPI_CLOSE_CALL,
(HDRVCALL) Parameter1,
NULL,
LINEDISCONNECTMODE_NOANSWER,
NULL) )
{
H323DBG(( DEBUG_LEVEL_ERROR, "could not post H323 close event." ));
}
H323DBG(( DEBUG_LEVEL_TRACE, "CallReroutingTimerCallback exited." ));
}
//-----------------------------------------------------------------------------
//CALL DIVERSION (H450.3) ENCODE/DECODE ROUTINES
//-----------------------------------------------------------------------------
BOOL
CH323Call::HandleH450APDU(
IN PH323_UU_PDU_h4501SupplementaryService pH450APDU,
IN DWORD* pdwH450APDUType,
OUT DWORD* pdwInvokeID,
IN Q931_SETUP_ASN* pSetupASN
)
{
BOOL retVal = TRUE;
H4501SupplementaryService * pH450APDUStruct = NULL;
ServiceApdus_rosApdus * pROSApdu = NULL;
int iResult;
BYTE pEncodedArg[H450_ENCODED_ARG_LEN];
DWORD dwEncodedArgLen;
DWORD dwOpcode;
H323DBG(( DEBUG_LEVEL_TRACE, "HandleH450APDU entered:%p.", this ));
//right now assuming that only one APDU is passed at a time
iResult = DecodeH450ASN( (void **) &pH450APDUStruct,
H4501SupplementaryService_PDU,
pH450APDU->value.value,
pH450APDU->value.length );
if( ASN1_FAILED(iResult) || (pH450APDUStruct == NULL) )
{
return FALSE;
}
if( pH450APDUStruct->serviceApdu.choice != rosApdus_chosen )
{
ASN1_FreeDecoded( m_H450ASNCoderInfo.pDecInfo, pH450APDUStruct,
H4501SupplementaryService_PDU );
return FALSE;
}
pROSApdu = pH450APDUStruct->serviceApdu.u.rosApdus;
switch( pROSApdu->value.choice )
{
case H4503ROS_invoke_chosen:
if( (pROSApdu->value.u.invoke.opcode.choice != local_chosen) ||
(pROSApdu->value.u.invoke.argument.length > H450_ENCODED_ARG_LEN) )
{
ASN1_FreeDecoded( m_H450ASNCoderInfo.pDecInfo, pH450APDUStruct,
H4501SupplementaryService_PDU );
return FALSE;
}
*pdwInvokeID = pROSApdu->value.u.invoke.invokeId;
dwEncodedArgLen = pROSApdu->value.u.invoke.argument.length;
CopyMemory( (PVOID)pEncodedArg,
(PVOID)pROSApdu->value.u.invoke.argument.value,
dwEncodedArgLen );
dwOpcode = pROSApdu->value.u.invoke.opcode.u.local;
ASN1_FreeDecoded( m_H450ASNCoderInfo.pDecInfo, pH450APDUStruct,
H4501SupplementaryService_PDU );
*pdwH450APDUType = dwOpcode;
switch( dwOpcode )
{
case CALLREROUTING_OPCODE:
retVal = HandleCallRerouting( pEncodedArg, dwEncodedArgLen );
break;
case DIVERTINGLEGINFO1_OPCODE:
retVal = HandleDiversionLegInfo1( pEncodedArg, dwEncodedArgLen );
break;
case DIVERTINGLEGINFO2_OPCODE:
retVal = HandleDiversionLegInfo2( pEncodedArg, dwEncodedArgLen );
break;
case DIVERTINGLEGINFO3_OPCODE:
//Don't bail out even if this function fails.
HandleDiversionLegInfo3( pEncodedArg, dwEncodedArgLen );
break;
case CHECKRESTRICTION_OPCODE:
if( pSetupASN == NULL )
{
retVal = FALSE;
}
else
{
retVal = HandleCheckRestriction( pEncodedArg, dwEncodedArgLen,
pSetupASN );
}
if( retVal )
{
retVal = SendQ931Message( *pdwInvokeID, 0, 0,
CONNECTMESSAGETYPE,
H450_RETURNRESULT|CHECKRESTRICTION_OPCODE );
}
break;
case CTIDENTIFY_OPCODE:
retVal = HandleCTIdentify( *pdwInvokeID );
m_dwInvokeID = *pdwInvokeID;
break;
case CTINITIATE_OPCODE:
retVal = HandleCTInitiate( pEncodedArg, dwEncodedArgLen );
m_dwInvokeID = *pdwInvokeID;
break;
case CTSETUP_OPCODE:
retVal = HandleCTSetup( pEncodedArg, dwEncodedArgLen );
m_dwInvokeID = *pdwInvokeID;
break;
case HOLDNOTIFIC_OPCODE:
//local hold request from the remote endpoint
if( m_dwCallState != LINECALLSTATE_ONHOLD )
{
SendMSPMessage( SP_MSG_Hold, 0, 1, NULL );
ChangeCallState( LINECALLSTATE_ONHOLD, 0 );
}
break;
case RETRIEVENOTIFIC_OPCODE:
//local retrieve request from the remote endpoint
if( (m_dwCallState == LINECALLSTATE_ONHOLD) &&
!(m_dwFlags & TSPI_CALL_LOCAL_HOLD) )
{
SendMSPMessage( SP_MSG_Hold, 0, 0, NULL );
ChangeCallState( LINECALLSTATE_CONNECTED, 0 );
}
break;
case REMOTEHOLD_OPCODE:
//remote hold request from remote endpoint
if( m_dwCallState != LINECALLSTATE_ONHOLD )
{
SendMSPMessage( SP_MSG_Hold, 0, 1, NULL );
ChangeCallState( LINECALLSTATE_ONHOLD, 0 );
retVal = SendQ931Message( *pdwInvokeID, 0, 0,
FACILITYMESSAGETYPE,
REMOTEHOLD_OPCODE| H450_RETURNRESULT );
}
break;
case REMOTERETRIEVE_OPCODE:
//remote retrieve request from remote endpoint
if( m_dwCallState == LINECALLSTATE_ONHOLD )
{
SendMSPMessage( SP_MSG_Hold, 0, 0, NULL );
ChangeCallState( LINECALLSTATE_CONNECTED, 0 );
retVal = SendQ931Message( *pdwInvokeID, 0, 0,
FACILITYMESSAGETYPE,
REMOTERETRIEVE_OPCODE| H450_RETURNRESULT );
}
break;
default:
_ASSERTE( 0 );
return FALSE;
}
break;
case H4503ROS_returnResult_chosen:
*pdwH450APDUType = H4503_DUMMYTYPERETURNRESULT_APDU;
*pdwInvokeID =
pH450APDUStruct->serviceApdu.u.rosApdus->value.u.returnResult.invokeId;
retVal = HandleReturnResultDummyType( pH450APDUStruct );
// Free the PDU data.
ASN1_FreeDecoded( m_H450ASNCoderInfo.pDecInfo, pH450APDUStruct,
H4501SupplementaryService_PDU );
break;
case H4503ROS_returnError_chosen:
*pdwH450APDUType = H4503_RETURNERROR_APDU;
*pdwInvokeID =
pH450APDUStruct->serviceApdu.u.rosApdus->value.u.returnError.invokeId;
retVal = HandleReturnError( pH450APDUStruct );
// Free the PDU data.
ASN1_FreeDecoded( m_H450ASNCoderInfo.pDecInfo, pH450APDUStruct,
H4501SupplementaryService_PDU );
break;
case reject_chosen:
*pdwH450APDUType = H4503_REJECT_APDU;
*pdwInvokeID =
pH450APDUStruct->serviceApdu.u.rosApdus->value.u.reject.invokeId;
retVal = HandleReject( pH450APDUStruct );
// Free the PDU data.
ASN1_FreeDecoded( m_H450ASNCoderInfo.pDecInfo, pH450APDUStruct,
H4501SupplementaryService_PDU );
break;
default:
_ASSERTE( 0 );
ASN1_FreeDecoded( m_H450ASNCoderInfo.pDecInfo, pH450APDUStruct,
H4501SupplementaryService_PDU );
return FALSE;
break;
}
if( retVal == FALSE )
{
SendQ931Message( *pdwInvokeID,
0,
0,
RELEASECOMPLMESSAGETYPE,
H450_REJECT );
}
H323DBG(( DEBUG_LEVEL_TRACE, "HandleH450APDU exited:%p.", this ));
return retVal;
}
BOOL
CH323Call::HandleReturnError(
IN H4501SupplementaryService * pH450APDUStruct
)
{
H323DBG(( DEBUG_LEVEL_TRACE, "HandleReturnError entered:%p.", this ));
ReturnError * pReturnError =
&(pH450APDUStruct->serviceApdu.u.rosApdus->value.u.returnError);
if( IsValidInvokeID( pReturnError->invokeId ) == FALSE )
{
//ignore APDU
return TRUE;
}
CloseCall( 0 );
H323DBG(( DEBUG_LEVEL_TRACE, "HandleReturnError exited:%p.", this ));
return TRUE;
}
BOOL
CH323Call::HandleReject(
IN H4501SupplementaryService * pH450APDUStruct
)
{
H323DBG(( DEBUG_LEVEL_TRACE, "HandleReject entered:%p.", this ));
Reject * pReject =
&(pH450APDUStruct->serviceApdu.u.rosApdus->value.u.reject);
if( IsValidInvokeID( pReject->invokeId ) == FALSE )
{
//ignore the APDU
return TRUE;
}
CloseCall( 0 );
H323DBG(( DEBUG_LEVEL_TRACE, "HandleReject exited:%p.", this ));
return TRUE;
}
BOOL
CH323Call::HandleReturnResultDummyType(
IN H4501SupplementaryService * pH450APDUStruct
)
{
H323DBG(( DEBUG_LEVEL_TRACE, "HandleReturnResultDummyType entered:%p.",
this ));
ReturnResult* dummyResult =
&(pH450APDUStruct->serviceApdu.u.rosApdus->value.u.returnResult);
if( dummyResult->bit_mask & result_present )
{
if( dummyResult->result.opcode.choice != local_chosen )
{
return FALSE;
}
switch( dummyResult->result.opcode.u.local )
{
case CHECKRESTRICTION_OPCODE:
//forwarding has been enabled. inform the user
if( !EnableCallForwarding() )
{
return FALSE;
}
//close the call
CloseCall( 0 );
break;
case CALLREROUTING_OPCODE:
//call has been rerouted. log the info or inform the user
m_dwCallDiversionState = H4503_CALLREROUTING_RRSUCC;
_ASSERTE( m_hCallReroutingTimer );
if( m_hCallReroutingTimer != NULL )
{
DeleteTimerQueueTimer( H323TimerQueue,
m_hCallReroutingTimer, NULL );
m_hCallReroutingTimer = NULL;
}
break;
case CTIDENTIFY_OPCODE:
//call tranfer has been accepted by transfered-to endpoint
m_dwCallDiversionState = H4502_CIIDENTIFY_RRSUCC;
_ASSERTE( m_hCTIdentifyTimer );
if( m_hCTIdentifyTimer != NULL )
{
DeleteTimerQueueTimer( H323TimerQueue, m_hCTIdentifyTimer, NULL );
m_hCTIdentifyTimer = NULL;
}
return HandleCTIdentifyReturnResult( dummyResult->result.result.value,
dummyResult->result.result.length );
break;
case CTINITIATE_OPCODE:
_ASSERTE( m_hCTInitiateTimer );
if( m_hCTInitiateTimer != NULL )
{
DeleteTimerQueueTimer( H323TimerQueue, m_hCTInitiateTimer, NULL );
m_hCTInitiateTimer = NULL;
}
break;
case CTSETUP_OPCODE:
case REMOTEHOLD_OPCODE:
case REMOTERETRIEVE_OPCODE:
//no processing required
break;
default:
H323DBG(( DEBUG_LEVEL_ERROR, "wrong opcode.",
dummyResult->result.opcode.u.local ));
break;
}
}
else if( IsValidInvokeID( dummyResult->invokeId ) == FALSE )
{
return FALSE;
}
H323DBG(( DEBUG_LEVEL_TRACE, "HandleReturnResultDummyType exited:%p.",
this ));
return TRUE;
}
BOOL
CH323Call::EnableCallForwarding()
{
m_dwCallDiversionState = H4503_CHECKRESTRICTION_SUCC;
if( m_pCallForwardParams != NULL )
{
g_pH323Line->SetCallForwardParams( m_pCallForwardParams );
m_pCallForwardParams = NULL;
}
else if( m_pForwardAddress != NULL )
{
if( !g_pH323Line->SetCallForwardParams( m_pForwardAddress ) )
{
return FALSE;
}
m_pForwardAddress = NULL;
}
//_ASSERTE( m_hCheckRestrictionTimer );
//stop the timer
if( m_hCheckRestrictionTimer )
{
DeleteTimerQueueTimer( H323TimerQueue, m_hCheckRestrictionTimer,
NULL );
m_hCheckRestrictionTimer = NULL;
}
//inform the user about change in line forward state
(*g_pfnLineEventProc)(
g_pH323Line->m_htLine,
(HTAPICALL)NULL,
(DWORD)LINE_ADDRESSSTATE,
(DWORD)LINEADDRESSSTATE_FORWARD,
(DWORD)LINEADDRESSSTATE_FORWARD,
(DWORD)0
);
return TRUE;
}
BOOL
CH323Call::HandleCTIdentifyReturnResult(
IN BYTE * pEncodeArg,
IN DWORD dwEncodedArgLen
)
{
PH323_CALL pCall = NULL;
CTIdentifyRes * pCTIdentifyRes;
int iResult;
H323DBG(( DEBUG_LEVEL_TRACE, "HandleCTIdentifyReturnResult entered:%p.", this ));
if( (pEncodeArg == NULL) || (dwEncodedArgLen==0) )
{
return FALSE;
}
iResult = DecodeH450ASN( (void **) &pCTIdentifyRes,
CTIdentifyRes_PDU, pEncodeArg, dwEncodedArgLen );
if( ASN1_FAILED(iResult) || (pCTIdentifyRes == NULL) )
{
return FALSE;
}
//send a CTInitiate message on the primary call
if( !QueueSuppServiceWorkItem( SEND_CTINITIATE_MESSAGE, m_hdRelatedCall,
(ULONG_PTR)pCTIdentifyRes ))
{
//close the consultation call.
CloseCall( 0 );
}
H323DBG(( DEBUG_LEVEL_TRACE, "HandleCTIdentifyReturnResult exited:%p.", this ));
return TRUE;
}
BOOL
CH323Call::HandleCTIdentify(
IN DWORD dwInvokeID
)
{
H323DBG(( DEBUG_LEVEL_TRACE, "HandleCTIdentify entered:%p.", this ));
BOOL retVal = TRUE;
//send the return result for CTIdentify
retVal = SendQ931Message( dwInvokeID, 0, 0, FACILITYMESSAGETYPE,
H450_RETURNRESULT|CTIDENTIFY_OPCODE );
m_dwCallType |= CALLTYPE_TRANSFERED2_CONSULT;
//start the timer for CTIdenity message
if( retVal )
{
retVal = CreateTimerQueueTimer(
&m_hCTIdentifyRRTimer,
H323TimerQueue,
CH323Call::CTIdentifyRRExpiredCallback,
(PVOID)m_hdCall,
CTIDENTIFYRR_SENT_TIMEOUT, 0,
WT_EXECUTEINIOTHREAD | WT_EXECUTEONLYONCE );
}
H323DBG(( DEBUG_LEVEL_TRACE, "HandleCTIdentify exited:%p.", this ));
return retVal;
}
BOOL
CH323Call::HandleCTInitiate(
IN BYTE * pEncodeArg,
IN DWORD dwEncodedArgLen
)
{
H323DBG(( DEBUG_LEVEL_TRACE, "HandleCTInitiate entered:%p.", this ));
CTInitiateArg * pCTInitiateArg;
int iResult = DecodeH450ASN( (void **) &pCTInitiateArg,
CTInitiateArg_PDU,
pEncodeArg, dwEncodedArgLen );
if( ASN1_FAILED(iResult) || (pCTInitiateArg == NULL) )
{
return FALSE;
}
//argument.callIdentity
CopyMemory( (PVOID)m_pCTCallIdentity, pCTInitiateArg->callIdentity,
sizeof(m_pCTCallIdentity) );
//argument.reroutingNumber
if( !AliasAddrToAliasNames( &m_pTransferedToAlias,
(PSetup_UUIE_sourceAddress)
pCTInitiateArg->reroutingNumber.destinationAddress ) )
{
goto cleanup;
}
m_dwCallType |= CALLTYPE_TRANSFERED_PRIMARY;
m_dwCallDiversionState = H4502_CTINITIATE_RECV;
ASN1_FreeDecoded( m_H450ASNCoderInfo.pDecInfo, pCTInitiateArg,
CTInitiateArg_PDU );
//queue an event for creating a new call
if( !QueueSuppServiceWorkItem( TSPI_DIAL_TRNASFEREDCALL, m_hdCall,
(ULONG_PTR)m_pTransferedToAlias ))
{
H323DBG(( DEBUG_LEVEL_TRACE, "could not post dial transfer event." ));
}
H323DBG(( DEBUG_LEVEL_TRACE, "HandleCTInitiate exited:%p.", this ));
return TRUE;
cleanup:
ASN1_FreeDecoded( m_H450ASNCoderInfo.pDecInfo, pCTInitiateArg,
CTInitiateArg_PDU );
return FALSE;
}
//!!always called in a lock
BOOL
CH323Call::HandleCTSetup(
IN BYTE * pEncodeArg,
IN DWORD dwEncodedArgLen
)
{
PH323_CALL pCall = NULL;
WORD wRelatedCallRef = 0;
int iCTCallID;
H323DBG(( DEBUG_LEVEL_TRACE, "HandleCTSetup entered:%p.", this ));
CTSetupArg * pCTSetupArg;
int iResult = DecodeH450ASN( (void **) &pCTSetupArg,
CTSetupArg_PDU, pEncodeArg, dwEncodedArgLen );
if( ASN1_FAILED(iResult) || (pCTSetupArg == NULL) )
{
return FALSE;
}
m_dwCallType |= CALLTYPE_TRANSFEREDDEST;
m_dwCallDiversionState = H4502_CTSETUP_RECV;
iCTCallID = atoi( pCTSetupArg->callIdentity );
if( iCTCallID != 0 )
{
m_hdRelatedCall = g_pH323Line -> GetCallFromCTCallIdentity( iCTCallID );
if( m_hdRelatedCall )
{
if( !QueueSuppServiceWorkItem( STOP_CTIDENTIFYRR_TIMER,
m_hdRelatedCall, (ULONG_PTR)m_hdCall ))
{
m_hdRelatedCall = NULL;
}
}
}
ASN1_FreeDecoded( m_H450ASNCoderInfo.pDecInfo, pCTSetupArg,
CTSetupArg_PDU );
H323DBG(( DEBUG_LEVEL_TRACE, "HandleCTSEtup exited:%p.", this ));
return TRUE;
}
BOOL
CH323Call::HandleCheckRestriction(
IN BYTE * pEncodeArg,
IN DWORD dwEncodedArgLen,
IN Q931_SETUP_ASN* pSetupASN
)
{
H323DBG(( DEBUG_LEVEL_TRACE, "HandleCheckRestriction entered:%p.", this ));
CheckRestrictionArgument * pCheckRestriction;
int iResult = DecodeH450ASN( (void **) &pCheckRestriction,
CheckRestrictionArgument_PDU,
pEncodeArg, dwEncodedArgLen );
if( ASN1_FAILED(iResult) || (pCheckRestriction == NULL) )
{
return FALSE;
}
if( pSetupASN->pCalleeAliasList != NULL )
{
FreeAliasNames( pSetupASN->pCalleeAliasList );
pSetupASN->pCalleeAliasList = NULL;
}
if( !AliasAddrToAliasNames( &(pSetupASN->pCalleeAliasList),
(PSetup_UUIE_sourceAddress)pCheckRestriction->divertedToNr.destinationAddress ) )
{
pSetupASN->pCalleeAliasList = NULL;
goto cleanup;
}
if( pSetupASN->pCallerAliasList != NULL )
{
FreeAliasNames( pSetupASN->pCallerAliasList );
pSetupASN->pCallerAliasList = NULL;
}
if( !AliasAddrToAliasNames( &(pSetupASN->pCallerAliasList),
(PSetup_UUIE_sourceAddress)
pCheckRestriction->servedUserNr.destinationAddress ) )
{
pSetupASN->pCallerAliasList = NULL;
goto cleanup;
}
m_dwCallType |= CALLTYPE_FORWARDCONSULT;
if( !InitializeIncomingCall( pSetupASN, CALLTYPE_FORWARDCONSULT, 0 ) )
{
goto cleanup;
}
FreeSetupASN( pSetupASN );
m_dwStateMachine = Q931_SETUP_RECVD;
m_dwCallDiversionState = H4503_CHECKRESTRICTION_RECV;
ASN1_FreeDecoded( m_H450ASNCoderInfo.pDecInfo, pCheckRestriction,
CheckRestrictionArgument_PDU );
H323DBG(( DEBUG_LEVEL_TRACE, "HandleCheckRestriction exited:%p.", this ));
return TRUE;
cleanup:
ASN1_FreeDecoded( m_H450ASNCoderInfo.pDecInfo, pCheckRestriction,
CheckRestrictionArgument_PDU );
return FALSE;
}
BOOL
CH323Call::HandleDiversionLegInfo1(
IN BYTE * pEncodeArg,
IN DWORD dwEncodedArgLen
)
{
H323DBG(( DEBUG_LEVEL_TRACE, "HandleDiversionLegInfo1 entered:%p.", this ));
DivertingLegInformation1Argument * plegInfo1Invoke;
int iResult = DecodeH450ASN( (void **) &plegInfo1Invoke,
DivertingLegInformation1Argument_PDU,
pEncodeArg, dwEncodedArgLen );
if( ASN1_FAILED(iResult) || (plegInfo1Invoke == NULL) )
{
return FALSE;
}
if( m_pCallReroutingInfo == NULL )
{
m_pCallReroutingInfo = new CALLREROUTINGINFO;
if( m_pCallReroutingInfo == NULL )
{
return FALSE;
}
ZeroMemory( (PVOID)m_pCallReroutingInfo, sizeof(CALLREROUTINGINFO) );
}
m_pCallReroutingInfo->diversionReason = plegInfo1Invoke->diversionReason;
m_pCallReroutingInfo->fPresentAllow = plegInfo1Invoke->subscriptionOption;
//argument.divertedToNr
if( m_pCallReroutingInfo->divertedToNrAlias != NULL )
{
FreeAliasNames( m_pCallReroutingInfo->divertedToNrAlias );
m_pCallReroutingInfo->divertedToNrAlias = NULL;
}
if( !AliasAddrToAliasNames( &(m_pCallReroutingInfo->divertedToNrAlias),
(PSetup_UUIE_sourceAddress)
(plegInfo1Invoke->nominatedNr.destinationAddress) ) )
{
goto cleanup;
}
m_dwCallType |= CALLTYPE_DIVERTEDSRC_NOROUTING;
m_dwCallDiversionState = H4503_DIVERSIONLEG1_RECVD;
ASN1_FreeDecoded( m_H450ASNCoderInfo.pDecInfo, plegInfo1Invoke,
DivertingLegInformation1Argument_PDU );
H323DBG(( DEBUG_LEVEL_TRACE, "HandleDiversionLegInfo1 exited:%p.", this ));
return TRUE;
cleanup:
ASN1_FreeDecoded( m_H450ASNCoderInfo.pDecInfo, plegInfo1Invoke,
DivertingLegInformation1Argument_PDU );
FreeCallReroutingInfo();
return FALSE;
}
BOOL
CH323Call::HandleDiversionLegInfo2(
IN BYTE * pEncodeArg,
IN DWORD dwEncodedArgLen
)
{
H323DBG(( DEBUG_LEVEL_TRACE, "HandleDiversionLegInfo2 entered:%p.", this ));
DivertingLegInformation2Argument * plegInfo2Invoke;
int iResult = DecodeH450ASN( (void **) &plegInfo2Invoke,
DivertingLegInformation2Argument_PDU,
pEncodeArg, dwEncodedArgLen );
if( ASN1_FAILED(iResult) || (plegInfo2Invoke == NULL) )
{
return FALSE;
}
_ASSERTE(!m_pCallReroutingInfo);
m_pCallReroutingInfo = new CALLREROUTINGINFO;
if( m_pCallReroutingInfo == NULL )
{
H323DBG(( DEBUG_LEVEL_TRACE, "memory failure." ));
goto cleanup;
}
ZeroMemory( (PVOID)m_pCallReroutingInfo, sizeof(CALLREROUTINGINFO) );
//argument.diversionCounter
m_pCallReroutingInfo->diversionCounter =
plegInfo2Invoke->diversionCounter;
//argument.diversionReason
m_pCallReroutingInfo->diversionReason = plegInfo2Invoke->diversionReason;
if( m_pCallReroutingInfo->divertingNrAlias != NULL )
{
FreeAliasNames( m_pCallReroutingInfo->divertingNrAlias );
m_pCallReroutingInfo->divertingNrAlias = NULL;
}
if( (plegInfo2Invoke->bit_mask & divertingNr_present ) &&
plegInfo2Invoke->divertingNr.destinationAddress )
{
//argument.divertingNr
if( !AliasAddrToAliasNames( &(m_pCallReroutingInfo->divertingNrAlias),
(PSetup_UUIE_sourceAddress)
(plegInfo2Invoke->divertingNr.destinationAddress) ) )
{
H323DBG(( DEBUG_LEVEL_TRACE, "no divertingnr alias." ));
//goto cleanup;
}
}
//argument.originalCalledNr
if( (plegInfo2Invoke->bit_mask &
DivertingLegInformation2Argument_originalCalledNr_present ) &&
plegInfo2Invoke->originalCalledNr.destinationAddress )
{
if( m_pCallReroutingInfo->originalCalledNr != NULL )
{
FreeAliasNames( m_pCallReroutingInfo->originalCalledNr );
m_pCallReroutingInfo->originalCalledNr = NULL;
}
if( !AliasAddrToAliasNames( &(m_pCallReroutingInfo->originalCalledNr),
(PSetup_UUIE_sourceAddress)
(plegInfo2Invoke->originalCalledNr.destinationAddress)) )
{
H323DBG(( DEBUG_LEVEL_TRACE, "no originalcalled alias." ));
//goto cleanup;
}
}
m_dwCallType |= CALLTYPE_DIVERTEDDEST;
m_dwCallDiversionState = H4503_DIVERSIONLEG2_RECVD;
ASN1_FreeDecoded( m_H450ASNCoderInfo.pDecInfo, plegInfo2Invoke,
DivertingLegInformation2Argument_PDU );
H323DBG(( DEBUG_LEVEL_TRACE, "HandleDiversionLegInfo2 exited:%p.", this ));
return TRUE;
cleanup:
ASN1_FreeDecoded( m_H450ASNCoderInfo.pDecInfo, plegInfo2Invoke,
DivertingLegInformation2Argument_PDU );
FreeCallReroutingInfo();
return FALSE;
}
void
CH323Call::FreeCallReroutingInfo(void)
{
H323DBG(( DEBUG_LEVEL_TRACE, "FreeCallReroutingInfo entered:%p.", this ));
if( m_pCallReroutingInfo != NULL )
{
FreeAliasNames( m_pCallReroutingInfo->divertingNrAlias );
FreeAliasNames( m_pCallReroutingInfo->originalCalledNr );
FreeAliasNames( m_pCallReroutingInfo->divertedToNrAlias );
FreeAliasNames( m_pCallReroutingInfo->diversionNrAlias );
delete m_pCallReroutingInfo;
m_pCallReroutingInfo = NULL;
}
H323DBG(( DEBUG_LEVEL_TRACE, "FreeCallReroutingInfo exited:%p.", this ));
}
BOOL
CH323Call::HandleDiversionLegInfo3(
IN BYTE * pEncodeArg,
IN DWORD dwEncodedArgLen
)
{
H323DBG(( DEBUG_LEVEL_TRACE, "HandleDiversionLegInfo3 entered:%p.", this ));
DivertingLegInformation3Argument * plegInfo3Invoke;
int iResult = DecodeH450ASN( (void **) &plegInfo3Invoke,
DivertingLegInformation3Argument_PDU,
pEncodeArg, dwEncodedArgLen );
if( ASN1_FAILED(iResult) || (plegInfo3Invoke == NULL) )
{
return FALSE;
}
_ASSERTE(m_pCallReroutingInfo);
m_pCallReroutingInfo-> fPresentAllow =
plegInfo3Invoke->presentationAllowedIndicator;
if( m_pCallReroutingInfo->diversionNrAlias )
{
FreeAliasNames( m_pCallReroutingInfo->diversionNrAlias );
m_pCallReroutingInfo->diversionNrAlias = NULL;
}
//argument.redirectionNr
if( (plegInfo3Invoke->bit_mask & redirectionNr_present ) &&
plegInfo3Invoke->redirectionNr.destinationAddress )
{
if( !AliasAddrToAliasNames( &(m_pCallReroutingInfo->diversionNrAlias),
(PSetup_UUIE_sourceAddress)
(plegInfo3Invoke->redirectionNr.destinationAddress) ) )
{
//goto cleanup;
}
}
_ASSERTE( (m_dwCallType & CALLTYPE_DIVERTEDSRC ) ||
(m_dwCallType & CALLTYPE_DIVERTEDSRC_NOROUTING ) );
m_dwCallDiversionState = H4503_DIVERSIONLEG3_RECVD;
ASN1_FreeDecoded( m_H450ASNCoderInfo.pDecInfo, plegInfo3Invoke,
DivertingLegInformation3Argument_PDU );
H323DBG(( DEBUG_LEVEL_TRACE, "HandleDiversionLegInfo3 exited:%p.", this ));
return TRUE;
/*cleanup:
ASN1_FreeDecoded( m_H450ASNCoderInfo.pDecInfo, plegInfo3Invoke,
DivertingLegInformation3Argument_PDU );
FreeCallReroutingInfo();
return FALSE;
*/
}
BOOL
CH323Call::HandleCallRerouting(
IN BYTE * pEncodeArg,
IN DWORD dwEncodedArgLen
)
{
H323DBG(( DEBUG_LEVEL_TRACE, "HandleCallRerouting entered:%p.", this ));
CallReroutingArgument* pCallReroutingInv;
int iResult = DecodeH450ASN( (void **) &pCallReroutingInv,
CallReroutingArgument_PDU,
pEncodeArg, dwEncodedArgLen );
if( ASN1_FAILED(iResult) || (pCallReroutingInv == NULL) )
{
return FALSE;
}
if( m_pCallReroutingInfo == NULL )
{
m_pCallReroutingInfo = new CALLREROUTINGINFO;
if( m_pCallReroutingInfo == NULL )
{
goto cleanup;
}
ZeroMemory( (PVOID)m_pCallReroutingInfo, sizeof(CALLREROUTINGINFO) );
}
if( pCallReroutingInv->diversionCounter > MAX_DIVERSION_COUNTER )
return FALSE;
m_pCallReroutingInfo->diversionCounter =
pCallReroutingInv->diversionCounter;
m_pCallReroutingInfo->diversionReason = pCallReroutingInv->reroutingReason;
if( pCallReroutingInv->bit_mask & originalReroutingReason_present )
{
m_pCallReroutingInfo->originalDiversionReason =
pCallReroutingInv->originalReroutingReason;
}
else
{
m_pCallReroutingInfo->originalDiversionReason =
pCallReroutingInv->reroutingReason;
}
if( ( pCallReroutingInv->bit_mask &
CallReroutingArgument_originalCalledNr_present ) &&
pCallReroutingInv->originalCalledNr.destinationAddress )
{
if( m_pCallReroutingInfo->originalCalledNr != NULL )
{
FreeAliasNames( m_pCallReroutingInfo->originalCalledNr );
m_pCallReroutingInfo->originalCalledNr = NULL;
}
if( !AliasAddrToAliasNames( &(m_pCallReroutingInfo->originalCalledNr),
(PSetup_UUIE_sourceAddress)
(pCallReroutingInv->originalCalledNr.destinationAddress) ) )
{
//goto cleanup;
}
}
if( m_pCallReroutingInfo->divertingNrAlias != NULL )
{
FreeAliasNames( m_pCallReroutingInfo->divertingNrAlias );
m_pCallReroutingInfo->divertingNrAlias = NULL;
}
if( !AliasAddrToAliasNames( &(m_pCallReroutingInfo->divertingNrAlias),
(PSetup_UUIE_sourceAddress)
(pCallReroutingInv->lastReroutingNr.destinationAddress) ) )
{
goto cleanup;
}
if( m_pCallReroutingInfo->divertedToNrAlias != NULL )
{
FreeAliasNames( m_pCallReroutingInfo->divertedToNrAlias );
m_pCallReroutingInfo->divertedToNrAlias = NULL;
}
if( !AliasAddrToAliasNames( &(m_pCallReroutingInfo->divertedToNrAlias),
(PSetup_UUIE_sourceAddress)
(pCallReroutingInv->calledAddress.destinationAddress) ) )
{
goto cleanup;
}
m_dwCallType |= CALLTYPE_DIVERTEDSRC;
m_dwCallDiversionState = H4503_CALLREROUTING_RECVD;
ASN1_FreeDecoded( m_H450ASNCoderInfo.pDecInfo, pCallReroutingInv,
CallReroutingArgument_PDU );
H323DBG(( DEBUG_LEVEL_TRACE, "HandleCallRerouting exited:%p.", this ));
return TRUE;
cleanup:
ASN1_FreeDecoded( m_H450ASNCoderInfo.pDecInfo, pCallReroutingInv,
CallReroutingArgument_PDU );
FreeCallReroutingInfo();
return FALSE;
}
BOOL
CH323Call::EncodeRejectAPDU(
IN H4501SupplementaryService * pSupplementaryServiceAPDU,
IN DWORD dwInvokeID,
OUT BYTE** ppEncodedAPDU,
OUT DWORD* pdwAPDULen
)
{
WORD wAPDULen;
H323DBG(( DEBUG_LEVEL_TRACE, "EncodeRejectAPDU entered:%p.", this ));
ServiceApdus_rosApdus *pROSAPDU =
pSupplementaryServiceAPDU->serviceApdu.u.rosApdus;
pROSAPDU->next = NULL;
pROSAPDU->value.choice = reject_chosen;
pROSAPDU->value.u.reject.invokeId = (WORD)dwInvokeID;
pROSAPDU->value.u.reject.problem.choice = H4503ROS_invoke_chosen;
pROSAPDU->value.u.reject.problem.u.invoke = InvokeProblem_mistypedArgument;
//call ASN.1 encoding functions
int rc = EncodeH450ASN( (void *) pSupplementaryServiceAPDU,
H4501SupplementaryService_PDU,
ppEncodedAPDU,
&wAPDULen );
*pdwAPDULen = wAPDULen;
if( ASN1_FAILED(rc) || (*ppEncodedAPDU == NULL) || (pdwAPDULen == 0) )
{
return FALSE;
}
H323DBG(( DEBUG_LEVEL_TRACE, "EncodeRejectAPDU exited:%p.", this ));
return TRUE;
}
BOOL
CH323Call::EncodeReturnErrorAPDU(
IN DWORD dwInvokeID,
IN DWORD dwErrorCode,
IN H4501SupplementaryService *pH450APDU,
OUT BYTE** ppEncodedAPDU,
OUT DWORD* pdwAPDULen
)
{
WORD wAPDULen;
H323DBG(( DEBUG_LEVEL_TRACE, "EncodeReturnErrorAPDU entered:%p.", this ));
ServiceApdus_rosApdus *pROSAPDU = pH450APDU->serviceApdu.u.rosApdus;
pROSAPDU->next = NULL;
pROSAPDU ->value.choice = H4503ROS_returnError_chosen;
pROSAPDU ->value.u.returnError.invokeId = (WORD)dwInvokeID;
pROSAPDU ->value.u.returnError.errcode.choice = local_chosen;
pROSAPDU ->value.u.returnError.errcode.u.local = dwErrorCode;
//call ASN.1 encoding functions
int rc = EncodeH450ASN( (void *) pH450APDU,
H4501SupplementaryService_PDU,
ppEncodedAPDU,
&wAPDULen );
*pdwAPDULen = wAPDULen;
if( ASN1_FAILED(rc) || (*ppEncodedAPDU == NULL) || (pdwAPDULen == 0) )
{
return FALSE;
}
H323DBG(( DEBUG_LEVEL_TRACE, "EncodeReturnErrorAPDU exited:%p.", this ));
return TRUE;
}
BOOL
CH323Call::EncodeDummyReturnResultAPDU(
IN DWORD dwInvokeID,
IN DWORD dwOpCode,
IN H4501SupplementaryService *pH450APDU,
OUT BYTE** ppEncodedAPDU,
OUT DWORD* pdwAPDULen
)
{
BYTE pBufEncodedArg[H450_ENCODED_ARG_LEN];
WORD wEncodedLen = 0;
int rc;
H323DBG(( DEBUG_LEVEL_TRACE, "EncodeDummyReturnResultAPDU entered:%p.",
this ));
ServiceApdus_rosApdus *pROSAPDU = pH450APDU->serviceApdu.u.rosApdus;
pROSAPDU->next = NULL;
pROSAPDU ->value.choice = H4503ROS_returnResult_chosen;
pROSAPDU ->value.u.returnResult.invokeId = (WORD)dwInvokeID;
pROSAPDU ->value.u.returnResult.bit_mask = result_present;
pROSAPDU ->value.u.returnResult.result.opcode.choice = local_chosen;
pROSAPDU ->value.u.returnResult.result.opcode.u.local = dwOpCode;
//dummy result not present
pROSAPDU ->value.u.returnResult.result.result.length = 0;
pROSAPDU ->value.u.returnResult.result.result.value = NULL;
switch( dwOpCode )
{
case CTIDENTIFY_OPCODE:
pROSAPDU ->value.u.returnResult.result.result.value = pBufEncodedArg;
if( !EncodeCTIdentifyReturnResult( pROSAPDU ) )
{
return FALSE;
}
break;
default:
pROSAPDU ->value.u.returnResult.result.result.value = pBufEncodedArg;
if( !EncodeDummyResult( pROSAPDU ) )
{
return FALSE;
}
break;
}
//call ASN.1 encoding functions
rc = EncodeH450ASN( (void *) pH450APDU,
H4501SupplementaryService_PDU,
ppEncodedAPDU,
&wEncodedLen );
*pdwAPDULen = wEncodedLen;
if( ASN1_FAILED(rc) || (*ppEncodedAPDU == NULL) || (pdwAPDULen == 0) )
{
return FALSE;
}
H323DBG(( DEBUG_LEVEL_TRACE, "EncodeDummyReturnResultAPDU exited:%p.",
this ));
return TRUE;
}
BOOL
CH323Call::EncodeDummyResult(
OUT ServiceApdus_rosApdus *pROSAPDU
)
{
DummyRes dummyRes;
BYTE *pEncodedArg = NULL;
WORD wEncodedLen = 0;
int rc;
UCHAR sData[3] = "MS";
H323DBG(( DEBUG_LEVEL_TRACE, "EncodeDummyResult entered:%p.", this ));
ZeroMemory( (PVOID)&dummyRes, sizeof(DummyRes) );
dummyRes.choice = DummyRes_nonStandardData_chosen;
dummyRes.u.nonStandardData.nonStandardIdentifier.choice
= H225NonStandardIdentifier_h221NonStandard_chosen;
dummyRes.u.nonStandardData.nonStandardIdentifier.u.h221NonStandard.t35CountryCode
= H221_COUNTRY_CODE_USA;
dummyRes.u.nonStandardData.nonStandardIdentifier.u.h221NonStandard.t35Extension
= H221_COUNTRY_EXT_USA;
dummyRes.u.nonStandardData.nonStandardIdentifier.u.h221NonStandard.manufacturerCode
= H221_MFG_CODE_MICROSOFT;
dummyRes.u.nonStandardData.data.length = 2;
dummyRes.u.nonStandardData.data.value = sData;
//encode the return result argument.
rc = EncodeH450ASN( (void*) &dummyRes,
DummyRes_PDU,
&pEncodedArg,
&wEncodedLen );
if( ASN1_FAILED(rc) || (pEncodedArg == NULL) || (wEncodedLen == 0) )
{
return FALSE;
}
pROSAPDU ->value.u.returnResult.result.result.length = wEncodedLen;
CopyMemory( (PVOID)pROSAPDU ->value.u.returnResult.result.result.value,
pEncodedArg, wEncodedLen );
//free the previous asn buffer before
ASN1_FreeEncoded(m_ASNCoderInfo.pEncInfo, pEncodedArg );
H323DBG(( DEBUG_LEVEL_TRACE, "EncodeDummyResult exited:%p.", this ));
return TRUE;
}
BOOL
CH323Call::EncodeCTIdentifyReturnResult(
OUT ServiceApdus_rosApdus *pROSAPDU
)
{
CTIdentifyRes cTIdentifyRes;
BYTE *pEncodedArg = NULL;
WORD wEncodedLen = 0;
int iCallID;
int rc;
ZeroMemory( (PVOID)&cTIdentifyRes, sizeof(CTIdentifyRes) );
iCallID = g_pH323Line -> GetCTCallIdentity(m_hdCall );
if( iCallID == 0 )
{
return FALSE;
}
//argument.callIdentity
_itoa( iCallID, (char*)m_pCTCallIdentity, 10 );
CopyMemory( (PVOID)cTIdentifyRes.callIdentity, (PVOID)m_pCTCallIdentity,
sizeof(m_pCTCallIdentity) );
//argument.reroutingNumber
cTIdentifyRes.reroutingNumber.bit_mask = 0;
cTIdentifyRes.reroutingNumber.destinationAddress =
(PEndpointAddress_destinationAddress)
SetMsgAddressAlias( m_pCalleeAliasNames );
if( cTIdentifyRes.reroutingNumber.destinationAddress == NULL )
{
return FALSE;
}
//encode the return result argument.
rc = EncodeH450ASN( (void *) &cTIdentifyRes,
CTIdentifyRes_PDU,
&pEncodedArg,
&wEncodedLen );
if( ASN1_FAILED(rc) || (pEncodedArg == NULL) || (wEncodedLen == 0) )
{
FreeAddressAliases( (PSetup_UUIE_destinationAddress)
cTIdentifyRes.reroutingNumber.destinationAddress );
return FALSE;
}
pROSAPDU ->value.u.returnResult.result.result.length = wEncodedLen;
CopyMemory( (PVOID)pROSAPDU ->value.u.returnResult.result.result.value,
pEncodedArg, wEncodedLen );
//free the previous asn buffer before
ASN1_FreeEncoded(m_ASNCoderInfo.pEncInfo, pEncodedArg );
FreeAddressAliases( (PSetup_UUIE_destinationAddress)
cTIdentifyRes.reroutingNumber.destinationAddress );
return TRUE;
}
//supplemantary services functions
BOOL
CH323Call::EncodeCheckRestrictionAPDU(
OUT H4501SupplementaryService *pSupplementaryServiceAPDU,
OUT BYTE** ppEncodedAPDU,
OUT DWORD* pdwAPDULen
)
{
BYTE *pEncodedArg = NULL;
WORD wEncodedLen = 0;
BYTE pBufEncodedArg[H450_ENCODED_ARG_LEN];
BOOL retVal = FALSE;
int rc = 0;
TCHAR szMsg[20];
H323DBG(( DEBUG_LEVEL_TRACE, "EncodeCheckRestrictionAPDU entered:%p.",
this ));
ServiceApdus_rosApdus *pROSAPDU =
pSupplementaryServiceAPDU->serviceApdu.u.rosApdus;
pROSAPDU->next = NULL;
pROSAPDU->value.choice = H4503ROS_invoke_chosen;
pROSAPDU->value.u.invoke.bit_mask = argument_present;
//invoke ID
pROSAPDU->value.u.invoke.invokeId = g_pH323Line->GetNextInvokeID();
m_dwInvokeID = pROSAPDU->value.u.invoke.invokeId;
//opcode
pROSAPDU->value.u.invoke.opcode.choice = local_chosen;
pROSAPDU->value.u.invoke.opcode.u.local = CHECKRESTRICTION_OPCODE;
//argument
CheckRestrictionArgument checkRestrictionArgument;
ZeroMemory( (PVOID)&checkRestrictionArgument,
sizeof(CheckRestrictionArgument) );
//argument.divertedToNR
checkRestrictionArgument.divertedToNr.bit_mask = 0;
checkRestrictionArgument.divertedToNr.destinationAddress =
(PEndpointAddress_destinationAddress)
SetMsgAddressAlias( m_pCalleeAliasNames );
if( checkRestrictionArgument.divertedToNr.destinationAddress == NULL )
{
goto cleanup;
}
if( m_pCallerAliasNames == NULL )
{
m_pCallerAliasNames = new H323_ALIASNAMES;
if( m_pCallerAliasNames == NULL )
{
H323DBG(( DEBUG_LEVEL_ERROR, "could not allocate caller name." ));
goto cleanup;
}
memset( (PVOID)m_pCallerAliasNames, 0, sizeof(H323_ALIASNAMES) );
LoadString( g_hInstance,
IDS_UNKNOWN,
szMsg,
20
);
if( !AddAliasItem( m_pCallerAliasNames,
szMsg,
h323_ID_chosen ) )
{
goto cleanup;
}
//H323DBG(( DEBUG_LEVEL_ERROR, "Caller alias count:%d : %p", m_pCallerAliasNames->wCount, this ));
}
//argument.servedUserNR
checkRestrictionArgument.servedUserNr.bit_mask = 0;
checkRestrictionArgument.servedUserNr.destinationAddress =
(PEndpointAddress_destinationAddress)
SetMsgAddressAlias( m_pCallerAliasNames );
//H323DBG(( DEBUG_LEVEL_ERROR, "Caller alias count:%d : %p", m_pCallerAliasNames->wCount, this ));
if( checkRestrictionArgument.servedUserNr.destinationAddress == NULL )
{
goto cleanup;
}
//argument.basicservice
checkRestrictionArgument.basicService = allServices;
//encode the checkrestriction argument.
rc = EncodeH450ASN( (void *) &checkRestrictionArgument,
CheckRestrictionArgument_PDU,
&pEncodedArg,
&wEncodedLen );
if( ASN1_FAILED(rc) || (pEncodedArg == NULL) || (wEncodedLen == 0) )
{
goto cleanup;
}
pROSAPDU->value.u.invoke.argument.value = pBufEncodedArg;
pROSAPDU->value.u.invoke.argument.length = wEncodedLen;
CopyMemory( (PVOID)pROSAPDU->value.u.invoke.argument.value,
pEncodedArg, wEncodedLen );
//free the previous asn buffer before
ASN1_FreeEncoded(m_ASNCoderInfo.pEncInfo, pEncodedArg );
//call ASN.1 encoding functions
rc = EncodeH450ASN( (void *) pSupplementaryServiceAPDU,
H4501SupplementaryService_PDU,
ppEncodedAPDU,
&wEncodedLen );
*pdwAPDULen = wEncodedLen;
if( ASN1_FAILED(rc) || (*ppEncodedAPDU == NULL) || (pdwAPDULen == 0) )
{
goto cleanup;
}
H323DBG(( DEBUG_LEVEL_TRACE, "EncodeCheckRestrictionAPDU exited:%p.",
this ));
retVal = TRUE;
cleanup:
if( checkRestrictionArgument.servedUserNr.destinationAddress )
{
FreeAddressAliases( (PSetup_UUIE_destinationAddress)
checkRestrictionArgument.servedUserNr.destinationAddress );
}
if( checkRestrictionArgument.divertedToNr.destinationAddress )
{
FreeAddressAliases( (PSetup_UUIE_destinationAddress)
checkRestrictionArgument.divertedToNr.destinationAddress );
}
return retVal;
}
BOOL
CH323Call::EncodeDivertingLeg2APDU(
OUT H4501SupplementaryService *pSupplementaryServiceAPDU,
OUT BYTE** ppEncodedAPDU,
OUT DWORD* pdwAPDULen
)
{
BYTE *pEncodedArg = NULL;
WORD wEncodedLen = 0;
BYTE pBufEncodedArg[H450_ENCODED_ARG_LEN];
BOOL retVal = FALSE;
int rc = 0;
H323DBG(( DEBUG_LEVEL_TRACE, "EncodeDivertingLeg2APDU entered:%p.", this ));
pSupplementaryServiceAPDU->interpretationApdu.choice =
discardAnyUnrecognizedInvokePdu_chosen;
ServiceApdus_rosApdus *pROSAPDU =
pSupplementaryServiceAPDU->serviceApdu.u.rosApdus;
pROSAPDU->next = NULL;
pROSAPDU->value.choice = H4503ROS_invoke_chosen;
pROSAPDU->value.u.invoke.bit_mask = argument_present;
//invoke ID
pROSAPDU->value.u.invoke.invokeId = g_pH323Line->GetNextInvokeID();
//opcode
pROSAPDU->value.u.invoke.opcode.choice = local_chosen;
pROSAPDU->value.u.invoke.opcode.u.local = DIVERTINGLEGINFO2_OPCODE;
//argument
DivertingLegInformation2Argument divertLegInfo2Arg;
ZeroMemory( (PVOID)&divertLegInfo2Arg,
sizeof(DivertingLegInformation2Argument) );
//argument.diversionCounter
divertLegInfo2Arg.diversionCounter
= (WORD)m_pCallReroutingInfo->diversionCounter;
//argument.diversionreason
divertLegInfo2Arg.diversionReason = m_pCallReroutingInfo->diversionReason;
//argument.originalDiversionReason
if( m_pCallReroutingInfo->originalDiversionReason != 0 )
{
divertLegInfo2Arg.originalDiversionReason =
m_pCallReroutingInfo->originalDiversionReason;
divertLegInfo2Arg.bit_mask |= originalDiversionReason_present;
}
//argument.divertingNr
if( m_pCallReroutingInfo->divertingNrAlias != NULL )
{
divertLegInfo2Arg.bit_mask |= divertingNr_present;
divertLegInfo2Arg.divertingNr.bit_mask = 0;
divertLegInfo2Arg.divertingNr.destinationAddress
= (PEndpointAddress_destinationAddress)
SetMsgAddressAlias( m_pCallReroutingInfo->divertingNrAlias );
if( divertLegInfo2Arg.divertingNr.destinationAddress == NULL )
{
return FALSE;
}
}
//argument.originalCalledNr
if( m_pCallReroutingInfo->originalCalledNr != NULL )
{
divertLegInfo2Arg.bit_mask |=
DivertingLegInformation2Argument_originalCalledNr_present;
divertLegInfo2Arg.originalCalledNr.bit_mask = 0;
divertLegInfo2Arg.originalCalledNr.destinationAddress
= (PEndpointAddress_destinationAddress)
SetMsgAddressAlias( m_pCallReroutingInfo->originalCalledNr );
if( divertLegInfo2Arg.originalCalledNr.destinationAddress == NULL )
{
goto cleanup;
}
}
//encode the divertingleg2 argument.
rc = EncodeH450ASN( (void *) &divertLegInfo2Arg,
DivertingLegInformation2Argument_PDU,
&pEncodedArg,
&wEncodedLen );
if( ASN1_FAILED(rc) || (pEncodedArg == NULL) || (wEncodedLen == 0) )
{
goto cleanup;
}
pROSAPDU->value.u.invoke.argument.value = pBufEncodedArg;
pROSAPDU->value.u.invoke.argument.length = wEncodedLen;
CopyMemory( (PVOID)pROSAPDU->value.u.invoke.argument.value,
pEncodedArg, wEncodedLen );
//free the previous asn buffer before encoding new one
ASN1_FreeEncoded(m_ASNCoderInfo.pEncInfo, pEncodedArg );
//call ASN.1 encoding function for APDU
rc = EncodeH450ASN( (void *) pSupplementaryServiceAPDU,
H4501SupplementaryService_PDU,
ppEncodedAPDU,
&wEncodedLen );
*pdwAPDULen = wEncodedLen;
if( ASN1_FAILED(rc) || (*ppEncodedAPDU == NULL) || (pdwAPDULen == 0) )
{
goto cleanup;
}
H323DBG(( DEBUG_LEVEL_TRACE, "EncodeDivertingLeg2APDU exited:%p.", this ));
retVal= TRUE;
cleanup:
if( divertLegInfo2Arg.divertingNr.destinationAddress )
{
FreeAddressAliases( (PSetup_UUIE_destinationAddress)
divertLegInfo2Arg.divertingNr.destinationAddress );
}
if( divertLegInfo2Arg.originalCalledNr.destinationAddress )
{
FreeAddressAliases( (PSetup_UUIE_destinationAddress)
divertLegInfo2Arg.originalCalledNr.destinationAddress );
}
return retVal;
}
BOOL
CH323Call::EncodeDivertingLeg3APDU(
OUT H4501SupplementaryService *pSupplementaryServiceAPDU,
OUT BYTE** ppEncodedAPDU,
OUT DWORD* pdwAPDULen
)
{
BYTE *pEncodedArg = NULL;
WORD wEncodedLen = 0;
BYTE pBufEncodedArg[H450_ENCODED_ARG_LEN];
H323DBG(( DEBUG_LEVEL_TRACE, "EncodeDivertingLeg3APDU entered:%p.", this ));
pSupplementaryServiceAPDU->interpretationApdu.choice =
discardAnyUnrecognizedInvokePdu_chosen;
ServiceApdus_rosApdus *pROSAPDU =
pSupplementaryServiceAPDU->serviceApdu.u.rosApdus;
pROSAPDU->next = NULL;
pROSAPDU->value.choice = H4503ROS_invoke_chosen;
pROSAPDU->value.u.invoke.bit_mask = argument_present;
//invoke ID
pROSAPDU->value.u.invoke.invokeId = g_pH323Line->GetNextInvokeID();
//opcode
pROSAPDU->value.u.invoke.opcode.choice = local_chosen;
pROSAPDU->value.u.invoke.opcode.u.local = DIVERTINGLEGINFO3_OPCODE;
//argument
DivertingLegInformation3Argument divertLegInfo3Arg;
ZeroMemory( (PVOID)&divertLegInfo3Arg,
sizeof(DivertingLegInformation3Argument) );
//argument.presentationallowed
divertLegInfo3Arg.presentationAllowedIndicator = TRUE;
//argument.redirectionNr
divertLegInfo3Arg.redirectionNr.bit_mask = 0;
divertLegInfo3Arg.redirectionNr.destinationAddress =
(PEndpointAddress_destinationAddress)
SetMsgAddressAlias( m_pCalleeAliasNames );
if( divertLegInfo3Arg.redirectionNr.destinationAddress )
{
divertLegInfo3Arg.bit_mask |= redirectionNr_present;
}
//encode the divertingleg3 argument.
int rc = EncodeH450ASN( (void *) &divertLegInfo3Arg,
DivertingLegInformation3Argument_PDU,
&pEncodedArg,
&wEncodedLen );
if( ASN1_FAILED(rc) || (pEncodedArg == NULL) || (wEncodedLen == 0) )
{
if( divertLegInfo3Arg.redirectionNr.destinationAddress )
{
FreeAddressAliases( (PSetup_UUIE_destinationAddress)
divertLegInfo3Arg.redirectionNr.destinationAddress );
}
return FALSE;
}
pROSAPDU->value.u.invoke.argument.value = pBufEncodedArg;
pROSAPDU->value.u.invoke.argument.length = wEncodedLen;
CopyMemory( (PVOID)pROSAPDU->value.u.invoke.argument.value,
pEncodedArg, wEncodedLen );
//free the previous asn buffer before encoding new one
ASN1_FreeEncoded(m_ASNCoderInfo.pEncInfo, pEncodedArg );
if( divertLegInfo3Arg.redirectionNr.destinationAddress )
{
FreeAddressAliases( (PSetup_UUIE_destinationAddress)
divertLegInfo3Arg.redirectionNr.destinationAddress );
}
//call ASN.1 encoding function for APDU
rc = EncodeH450ASN( (void *) pSupplementaryServiceAPDU,
H4501SupplementaryService_PDU,
ppEncodedAPDU,
&wEncodedLen );
*pdwAPDULen = wEncodedLen;
if( ASN1_FAILED(rc) || (*ppEncodedAPDU == NULL) || (pdwAPDULen == 0) )
{
return FALSE;
}
H323DBG(( DEBUG_LEVEL_TRACE, "EncodeDivertingLeg3APDU exited:%p.", this ));
return TRUE;
}
BOOL
CH323Call::EncodeCallReroutingAPDU(
OUT H4501SupplementaryService *pSupplementaryServiceAPDU,
OUT BYTE** ppEncodedAPDU,
OUT DWORD* pdwAPDULen
)
{
BYTE *pEncodedArg = NULL;
WORD wEncodedLen = 0;
BYTE pBufEncodedArg[H450_ENCODED_ARG_LEN];
BOOL retVal = FALSE;
int rc = 0;
UCHAR bearerCap[5];
TCHAR szMsg[20];
PH323_ALIASNAMES pCallerAliasNames = m_pCallerAliasNames;
H323DBG(( DEBUG_LEVEL_TRACE, "EncodeCallReroutingAPDU entered:%p.", this ));
_ASSERTE( m_pCallReroutingInfo );
ServiceApdus_rosApdus *pROSAPDU =
pSupplementaryServiceAPDU->serviceApdu.u.rosApdus;
pROSAPDU->next = NULL;
pROSAPDU->value.choice = H4503ROS_invoke_chosen;
pROSAPDU->value.u.invoke.bit_mask = argument_present;
//invoke ID
pROSAPDU->value.u.invoke.invokeId = g_pH323Line->GetNextInvokeID();
m_dwInvokeID = pROSAPDU->value.u.invoke.invokeId;
//opcode
pROSAPDU->value.u.invoke.opcode.choice = local_chosen;
pROSAPDU->value.u.invoke.opcode.u.local = CALLREROUTING_OPCODE;
//argument
CallReroutingArgument callReroutingArg;
ZeroMemory( (PVOID)&callReroutingArg, sizeof(CallReroutingArgument) );
//argument.reroutingReason
callReroutingArg.reroutingReason = m_pCallReroutingInfo->diversionReason;
//argument.originalReroutingReason
if( m_pCallReroutingInfo->originalDiversionReason != 0 )
{
callReroutingArg.originalReroutingReason
= m_pCallReroutingInfo->originalDiversionReason;
}
else
{
callReroutingArg.originalReroutingReason
= m_pCallReroutingInfo->diversionReason;
}
//argument.diversionCounter
callReroutingArg.diversionCounter =
++(m_pCallReroutingInfo->diversionCounter);
//argument.calledAddress
callReroutingArg.calledAddress.bit_mask = 0;
callReroutingArg.calledAddress.destinationAddress
= (PEndpointAddress_destinationAddress)
SetMsgAddressAlias(m_pCallReroutingInfo->divertedToNrAlias);
if( callReroutingArg.calledAddress.destinationAddress == NULL )
{
goto cleanup;
}
//argument.lastReroutingNr
callReroutingArg.lastReroutingNr.bit_mask = 0;
callReroutingArg.lastReroutingNr.destinationAddress
= (PEndpointAddress_destinationAddress)
SetMsgAddressAlias(m_pCalleeAliasNames);
if( callReroutingArg.lastReroutingNr.destinationAddress == NULL )
{
goto cleanup;
}
//argument.subscriptionoption
callReroutingArg.subscriptionOption = notificationWithDivertedToNr;
//argument.callingNumber
callReroutingArg.callingNumber.bit_mask = 0;
if( pCallerAliasNames == NULL )
{
pCallerAliasNames = new H323_ALIASNAMES;
if( pCallerAliasNames == NULL )
{
H323DBG(( DEBUG_LEVEL_ERROR, "could not allocate caller name." ));
goto cleanup;
}
memset( (PVOID)pCallerAliasNames, 0, sizeof(H323_ALIASNAMES) );
LoadString( g_hInstance,
IDS_UNKNOWN,
szMsg,
20
);
if( !AddAliasItem( pCallerAliasNames,
szMsg,
h323_ID_chosen ) )
{
goto cleanup;
}
}
callReroutingArg.callingNumber.destinationAddress
= (PEndpointAddress_destinationAddress)
SetMsgAddressAlias(pCallerAliasNames);
if( callReroutingArg.callingNumber.destinationAddress == NULL )
{
goto cleanup;
}
//argumnt.h225infoelement
callReroutingArg.h225InfoElement.length = 5;
callReroutingArg.h225InfoElement.value = bearerCap;
bearerCap[0]= IDENT_BEARERCAP;
bearerCap[1]= 0x03; //length of the bearer capability
bearerCap[2]= (BYTE)(BEAR_EXT_BIT | BEAR_CCITT | BEAR_UNRESTRICTED_DIGITAL);
bearerCap[3]= BEAR_EXT_BIT | 0x17;
bearerCap[4]= (BYTE)(BEAR_EXT_BIT | BEAR_LAYER1_INDICATOR |
BEAR_LAYER1_H221_H242);
//argument.callingNumber
if( m_pCallReroutingInfo->originalCalledNr != NULL )
{
callReroutingArg.originalCalledNr.bit_mask = 0;
callReroutingArg.originalCalledNr.destinationAddress
= (PEndpointAddress_destinationAddress)
SetMsgAddressAlias( m_pCallReroutingInfo->originalCalledNr );
if( callReroutingArg.originalCalledNr.destinationAddress != NULL )
{
callReroutingArg.bit_mask |=
CallReroutingArgument_originalCalledNr_present;
}
}
//encode the callrerouting argument.
rc = EncodeH450ASN( (void *) &callReroutingArg,
CallReroutingArgument_PDU,
&pEncodedArg,
&wEncodedLen );
if( ASN1_FAILED(rc) || (pEncodedArg == NULL) || (wEncodedLen == 0) )
{
goto cleanup;
}
pROSAPDU->value.u.invoke.argument.value = pBufEncodedArg;
pROSAPDU->value.u.invoke.argument.length = wEncodedLen;
CopyMemory( (PVOID)pROSAPDU->value.u.invoke.argument.value,
pEncodedArg, wEncodedLen );
//free the previous asn buffer before encoding new one
ASN1_FreeEncoded(m_ASNCoderInfo.pEncInfo, pEncodedArg );
//call ASN.1 encoding function for APDU
rc = EncodeH450ASN( (void *) pSupplementaryServiceAPDU,
H4501SupplementaryService_PDU,
ppEncodedAPDU,
&wEncodedLen );
*pdwAPDULen = wEncodedLen;
if( ASN1_FAILED(rc) || (*ppEncodedAPDU == NULL) || (pdwAPDULen == 0) )
{
goto cleanup;
}
H323DBG(( DEBUG_LEVEL_TRACE, "EncodeCallReroutingAPDU exited:%p.", this ));
retVal = TRUE;
cleanup:
if( pCallerAliasNames != m_pCallerAliasNames )
{
FreeAliasNames( pCallerAliasNames );
}
FreeCallReroutingArg( &callReroutingArg );
return retVal;
}
//No need to call in a lock!!
void
CH323Call::FreeCallReroutingArg(
CallReroutingArgument* pCallReroutingArg
)
{
//free all the aliases
if( pCallReroutingArg->calledAddress.destinationAddress != NULL )
{
FreeAddressAliases( (PSetup_UUIE_destinationAddress)
pCallReroutingArg->calledAddress.destinationAddress );
}
if( pCallReroutingArg->lastReroutingNr.destinationAddress != NULL )
{
FreeAddressAliases( (PSetup_UUIE_destinationAddress)
pCallReroutingArg->lastReroutingNr.destinationAddress );
}
if( pCallReroutingArg->callingNumber.destinationAddress != NULL )
{
FreeAddressAliases( (PSetup_UUIE_destinationAddress)
pCallReroutingArg->callingNumber.destinationAddress );
}
if( pCallReroutingArg->originalCalledNr.destinationAddress != NULL )
{
FreeAddressAliases( (PSetup_UUIE_destinationAddress)
pCallReroutingArg->originalCalledNr.destinationAddress );
}
}
// static
void
NTAPI CH323Call::CallEstablishmentExpiredCallback(
IN PVOID DriverCallHandle, // HDRVCALL
IN BOOLEAN bTimer)
{
PH323_CALL pCall = NULL;
H323DBG(( DEBUG_LEVEL_TRACE, "CallEstablishmentExpiredCallback entered." ));
//if the timer expired
_ASSERTE( bTimer );
H323DBG(( DEBUG_LEVEL_TRACE, "Q931 setup expired event recvd." ));
pCall=g_pH323Line -> FindH323CallAndLock((HDRVCALL) DriverCallHandle);
if( pCall != NULL )
{
if( pCall -> GetStateMachine() != Q931_CONNECT_RECVD )
{
//time out has occured
pCall -> CloseCall( LINEDISCONNECTMODE_NOANSWER );
}
pCall -> Unlock();
}
H323DBG(( DEBUG_LEVEL_TRACE, "CallEstablishmentExpiredCallback exited." ));
}
//-----------------------------------------------------------------------------
//CALL TRANSFER (H450.2) ENCODE/DECODE ROUTINES
//-----------------------------------------------------------------------------
BOOL
CH323Call::EncodeH450APDUNoArgument(
IN DWORD dwOpcode,
OUT H4501SupplementaryService *pSupplementaryServiceAPDU,
OUT BYTE** ppEncodedAPDU,
OUT DWORD* pdwAPDULen
)
{
BYTE *pEncodedArg = NULL;
WORD wEncodedLen = 0;
int rc;
H323DBG(( DEBUG_LEVEL_TRACE, "EncodeH450APDUNoArgument entered:%p.",
this ));
ServiceApdus_rosApdus *pROSAPDU =
pSupplementaryServiceAPDU->serviceApdu.u.rosApdus;
pROSAPDU->next = NULL;
pROSAPDU->value.choice = H4503ROS_invoke_chosen;
pROSAPDU->value.u.invoke.bit_mask = 0;
//invoke ID
pROSAPDU->value.u.invoke.invokeId = g_pH323Line->GetNextInvokeID();
m_dwInvokeID = pROSAPDU->value.u.invoke.invokeId;
//opcode
pROSAPDU->value.u.invoke.opcode.choice = local_chosen;
pROSAPDU->value.u.invoke.opcode.u.local = dwOpcode;
//no argument passed
//call ASN.1 encoding function for APDU
rc = EncodeH450ASN( (void *) pSupplementaryServiceAPDU,
H4501SupplementaryService_PDU,
ppEncodedAPDU,
&wEncodedLen );
*pdwAPDULen = wEncodedLen;
if( ASN1_FAILED(rc) || (*ppEncodedAPDU == NULL) || (pdwAPDULen == 0) )
{
return FALSE;
}
H323DBG(( DEBUG_LEVEL_TRACE, "EncodeH450APDUNoArgument exited:%p.",
this ));
return TRUE;
}
BOOL
CH323Call::EncodeCTInitiateAPDU(
OUT H4501SupplementaryService *pSupplementaryServiceAPDU,
OUT BYTE** ppEncodedAPDU,
OUT DWORD* pdwAPDULen
)
{
BYTE *pEncodedArg = NULL;
WORD wEncodedLen = 0;
BYTE pBufEncodedArg[H450_ENCODED_ARG_LEN];
int rc = 0;
H323DBG(( DEBUG_LEVEL_TRACE, "EncodeCTInitiateAPDU entered:%p.", this ));
ServiceApdus_rosApdus *pROSAPDU =
pSupplementaryServiceAPDU->serviceApdu.u.rosApdus;
pROSAPDU->next = NULL;
pROSAPDU->value.choice = H4503ROS_invoke_chosen;
pROSAPDU->value.u.invoke.bit_mask = argument_present;
//invoke ID
pROSAPDU->value.u.invoke.invokeId = g_pH323Line->GetNextInvokeID();
m_dwInvokeID = pROSAPDU->value.u.invoke.invokeId;
//opcode
pROSAPDU->value.u.invoke.opcode.choice = local_chosen;
pROSAPDU->value.u.invoke.opcode.u.local = CTINITIATE_OPCODE;
//argument
CTInitiateArg cTInitiateArg;
ZeroMemory( (PVOID)&cTInitiateArg, sizeof(CTInitiateArg) );
//argument.callIdentity
CopyMemory( (PVOID)cTInitiateArg.callIdentity,
(PVOID)m_pCTCallIdentity, sizeof(m_pCTCallIdentity) );
//argument.reroutingNumber
cTInitiateArg.reroutingNumber.bit_mask = 0;
cTInitiateArg.reroutingNumber.destinationAddress =
(PEndpointAddress_destinationAddress)
SetMsgAddressAlias( m_pTransferedToAlias );
if( cTInitiateArg.reroutingNumber.destinationAddress == NULL )
{
return FALSE;
}
//encode the CTSetup argument.
rc = EncodeH450ASN( (void *) &cTInitiateArg,
CTInitiateArg_PDU,
&pEncodedArg,
&wEncodedLen );
if( ASN1_FAILED(rc) || (pEncodedArg == NULL) || (wEncodedLen == 0) )
{
FreeAddressAliases( (PSetup_UUIE_destinationAddress)
cTInitiateArg.reroutingNumber.destinationAddress );
return FALSE;
}
pROSAPDU->value.u.invoke.argument.value = pBufEncodedArg;
pROSAPDU->value.u.invoke.argument.length = wEncodedLen;
CopyMemory( (PVOID)pROSAPDU->value.u.invoke.argument.value,
pEncodedArg, wEncodedLen );
//free the previous asn buffer before encoding new one
ASN1_FreeEncoded(m_ASNCoderInfo.pEncInfo, pEncodedArg );
FreeAddressAliases( (PSetup_UUIE_destinationAddress)
cTInitiateArg.reroutingNumber.destinationAddress );
//call ASN.1 encoding function for APDU
rc = EncodeH450ASN( (void *) pSupplementaryServiceAPDU,
H4501SupplementaryService_PDU,
ppEncodedAPDU,
&wEncodedLen );
*pdwAPDULen = wEncodedLen;
if( ASN1_FAILED(rc) || (*ppEncodedAPDU == NULL) || (pdwAPDULen == 0) )
{
return FALSE;
}
H323DBG(( DEBUG_LEVEL_TRACE, "EncodeCTInitiateAPDU exited:%p.", this ));
return TRUE;
}
BOOL
CH323Call::EncodeCTSetupAPDU(
OUT H4501SupplementaryService *pSupplementaryServiceAPDU,
OUT BYTE** ppEncodedAPDU,
OUT DWORD* pdwAPDULen
)
{
BYTE *pEncodedArg = NULL;
WORD wEncodedLen = 0;
BYTE pBufEncodedArg[H450_ENCODED_ARG_LEN];
H323DBG(( DEBUG_LEVEL_TRACE, "EncodeCTSetupAPDU entered:%p.", this ));
ServiceApdus_rosApdus *pROSAPDU =
pSupplementaryServiceAPDU->serviceApdu.u.rosApdus;
pROSAPDU->next = NULL;
pROSAPDU->value.choice = H4503ROS_invoke_chosen;
pROSAPDU->value.u.invoke.bit_mask = argument_present;
//invoke ID
pROSAPDU->value.u.invoke.invokeId = g_pH323Line->GetNextInvokeID();
m_dwInvokeID = pROSAPDU->value.u.invoke.invokeId;
//opcode
pROSAPDU->value.u.invoke.opcode.choice = local_chosen;
pROSAPDU->value.u.invoke.opcode.u.local = CTSETUP_OPCODE;
//argument
CTSetupArg cTSetupArg;
ZeroMemory( (PVOID)&cTSetupArg, sizeof(CTSetupArg) );
//argument.callIdentity
CopyMemory( (PVOID)cTSetupArg.callIdentity,
(PVOID)m_pCTCallIdentity, sizeof(m_pCTCallIdentity) );
//no argument.transferingNumber
//encode the CTSetup argument.
int rc = EncodeH450ASN( (void *) &cTSetupArg,
CTSetupArg_PDU,
&pEncodedArg,
&wEncodedLen );
if( ASN1_FAILED(rc) || (pEncodedArg == NULL) || (wEncodedLen == 0) )
{
return FALSE;
}
pROSAPDU->value.u.invoke.argument.value = pBufEncodedArg;
pROSAPDU->value.u.invoke.argument.length = wEncodedLen;
CopyMemory( (PVOID)pROSAPDU->value.u.invoke.argument.value,
pEncodedArg, wEncodedLen );
//free the previous asn buffer before encoding new one
ASN1_FreeEncoded(m_ASNCoderInfo.pEncInfo, pEncodedArg );
//call ASN.1 encoding function for APDU
rc = EncodeH450ASN( (void *) pSupplementaryServiceAPDU,
H4501SupplementaryService_PDU,
ppEncodedAPDU,
&wEncodedLen );
*pdwAPDULen = wEncodedLen;
if( ASN1_FAILED(rc) || (*ppEncodedAPDU == NULL) || (pdwAPDULen == 0) )
{
return FALSE;
}
H323DBG(( DEBUG_LEVEL_TRACE, "EncodeCTSetupAPDU exited:%p.", this ));
return TRUE;
}
void CH323Call::PostLineEvent (
IN DWORD MessageID,
IN DWORD_PTR Parameter1,
IN DWORD_PTR Parameter2,
IN DWORD_PTR Parameter3)
{
(*g_pfnLineEventProc) (
g_pH323Line -> m_htLine,
m_htCall,
MessageID,
Parameter1,
Parameter2,
Parameter3);
}
//!!must be always called in a lock
void
CH323Call::DecrementIoRefCount(
OUT BOOL * pfDelete
)
{
_ASSERTE( m_IoRefCount != 0 );
m_IoRefCount--;
H323DBG((DEBUG_LEVEL_TRACE, "DecrementIoRefCount:m_IoRefCount:%d:%p.",
m_IoRefCount, this ));
*pfDelete = FALSE;
if( m_dwFlags & CALLOBJECT_SHUTDOWN )
{
*pfDelete = (m_IoRefCount==0) ? TRUE : FALSE;
}
}
//!!must be always called in a lock
void
CH323Call::StopCTIdentifyRRTimer(
HDRVCALL hdRelatedCall
)
{
if( m_hCTIdentifyRRTimer != NULL )
{
DeleteTimerQueueTimer( H323TimerQueue, m_hCTIdentifyRRTimer, NULL );
m_hCTIdentifyRRTimer = NULL;
}
m_hdRelatedCall = hdRelatedCall;
}
void
CH323Call::InitializeRecvBuf()
{
m_RecvBuf.WSABuf.len = sizeof(TPKT_HEADER_SIZE);
m_RecvBuf.WSABuf.buf = m_RecvBuf.arBuf;
m_RecvBuf.dwPDULen = m_RecvBuf.dwBytesCopied = 0;
m_bStartOfPDU = TRUE;
}
BOOL
CH323Call::SetCallData(
LPVOID lpCallData,
DWORD dwSize )
{
if( m_CallData.pOctetString != NULL )
{
delete m_CallData.pOctetString;
}
m_CallData.pOctetString = new BYTE[dwSize];
if( m_CallData.pOctetString == NULL )
{
m_CallData.wOctetStringLength = 0;
return FALSE;
}
CopyMemory( (PVOID)m_CallData.pOctetString, lpCallData, dwSize );
m_CallData.wOctetStringLength = (WORD)dwSize;
return TRUE;
}
// Global Functions
BOOL
IsPhoneNumber(
char * szAddr
)
{
while( *szAddr )
{
if( !isdigit(*szAddr) &&
('#' != *szAddr) &&
('*' != *szAddr) &&
('+' != *szAddr)
)
return FALSE;
szAddr++;
}
return TRUE;
}
BOOL
IsValidE164String(
IN WCHAR* wszDigits
)
{
for( ; (*wszDigits) != L'\0'; wszDigits++ )
{
if(!(
((*wszDigits >= L'0') && (*wszDigits <= L'9')) ||
(*wszDigits == L'*') ||
(*wszDigits == L'#') ||
(*wszDigits == L'!') ||
(*wszDigits == L',')
))
{
return FALSE;
}
}
return TRUE;
}
Reference in a new issue Copy permalink