/*++ Copyright (c) 1999 Microsoft Corporation Module Name: line.cpp Abstract: TAPI Service Provider functions related to manipulating lines. TSPI_lineClose TSPI_lineGetDevCaps TSPI_lineGetLineDevStatus TSPI_lineGetNumAddressIDs TSPI_lineOpen Author: Nikhil Bobde (NikhilB) Revision History: --*/ // // Include files // #include "globals.h" #include "line.h" #include "call.h" #include "q931obj.h" #include "ras.h" static LONG g_CTCallIdentity; CH323Line g_H323Line; H323_OCTETSTRING g_ProductID = { (BYTE*)H323_PRODUCT_ID, sizeof(H323_PRODUCT_ID) }; H323_OCTETSTRING g_ProductVersion = { (BYTE*)H323_PRODUCT_VERSION, sizeof(H323_PRODUCT_VERSION) }; //Queues a request made by TAPI to the thread pool BOOL QueueTAPILineRequest( IN DWORD EventID, IN HDRVCALL hdCall1, IN HDRVCALL hdCall2, IN DWORD dwDisconnectMode, IN WORD wCallReference) { BOOL fResult = TRUE; TAPI_LINEREQUEST_DATA * pLineRequestData = new TAPI_LINEREQUEST_DATA; H323DBG(( DEBUG_LEVEL_TRACE, "QueueTAPILineRequest entered." )); if( pLineRequestData != NULL ) { pLineRequestData -> EventID = EventID; pLineRequestData -> hdCall1 = hdCall1; if( hdCall2 != NULL ) { pLineRequestData -> hdCall2 = hdCall2; } else { pLineRequestData -> dwDisconnectMode = dwDisconnectMode; } pLineRequestData -> wCallReference = wCallReference; if( !QueueUserWorkItem( ProcessTAPILineRequest, pLineRequestData, WT_EXECUTEDEFAULT) ) { delete pLineRequestData; fResult = FALSE; } } else { fResult = FALSE; } H323DBG(( DEBUG_LEVEL_TRACE, "QueueTAPILineRequest exited." )); return fResult; } #if DBG DWORD ProcessTAPILineRequest( IN PVOID ContextParameter ) { __try { return ProcessTAPILineRequestFre( ContextParameter ); } __except( 1 ) { TAPI_LINEREQUEST_DATA* pRequestData = (TAPI_LINEREQUEST_DATA*)ContextParameter; H323DBG(( DEBUG_LEVEL_TRACE, "TSPI %s event threw exception: %p, %p, %d.", EventIDToString(pRequestData -> EventID), pRequestData -> hdCall1, pRequestData -> hdCall2, pRequestData -> wCallReference )); _ASSERTE( FALSE ); return 0; } } #endif DWORD ProcessTAPILineRequestFre( IN PVOID ContextParam ) { _ASSERTE( ContextParam ); PH323_CALL pCall = NULL; PH323_CALL pConsultCall = NULL; TAPI_LINEREQUEST_DATA* pLineRequestData = (TAPI_LINEREQUEST_DATA*)ContextParam; H323DBG(( DEBUG_LEVEL_TRACE, "TSPI %s event recvd.", EventIDToString(pLineRequestData -> EventID) )); switch( pLineRequestData -> EventID ) { case TSPI_CLOSE_CALL: g_pH323Line -> H323ReleaseCall( pLineRequestData->hdCall1, pLineRequestData->dwDisconnectMode, pLineRequestData->wCallReference ); break; case TSPI_COMPLETE_TRANSFER: pConsultCall = g_pH323Line -> Find2H323CallsAndLock( pLineRequestData->hdCall2, pLineRequestData->hdCall1, &pCall ); if( pConsultCall != NULL ) { pConsultCall -> CompleteTransfer( pCall ); pCall -> Unlock(); pConsultCall -> Unlock(); } break; } delete pLineRequestData; return EXIT_SUCCESS; } // // Private procedures // CH323Line::CH323Line() { m_nState = H323_LINESTATE_NONE; m_hdLine = NULL; m_htLine = NULL; m_dwDeviceID = -1; m_dwTSPIVersion = NULL; m_dwMediaModes = NULL; m_hdNextMSPHandle = NULL; m_wszAddr[0] = UNICODE_NULL; m_dwInitState = NULL; m_VendorInfo.bCountryCode = H221_COUNTRY_CODE_USA; m_VendorInfo.bExtension = H221_COUNTRY_EXT_USA; m_VendorInfo.wManufacturerCode = H221_MFG_CODE_MICROSOFT; m_VendorInfo.pProductNumber = &(g_ProductID); m_VendorInfo.pVersionNumber = &(g_ProductVersion); m_pCallForwardParams = NULL; m_dwInvokeID = 256; m_fForwardConsultInProgress = FALSE; } PH323_CALL CH323Line::Find2H323CallsAndLock ( IN HDRVCALL hdCall1, IN HDRVCALL hdCall2, OUT PH323_CALL * ppCall2 ) { int iIndex1 = MakeCallIndex (hdCall1); int iIndex2 = MakeCallIndex (hdCall2); PH323_CALL pCall1 = NULL, pCall2 = NULL; H323DBG(( DEBUG_LEVEL_TRACE, "Find2H323CallsAndLock entered:%lx:%lx.", hdCall1, hdCall2 )); LockCallTable(); //lock the call so that nobody else would be able to delete the call pCall1 = m_H323CallTable[iIndex1]; if( pCall1 != NULL ) { pCall1 -> Lock(); if( pCall1->GetCallHandle() != hdCall1 ) { pCall1 -> Unlock(); pCall1 = NULL; } else { if( pCall2=m_H323CallTable[iIndex2] ) { pCall2 -> Lock(); if( pCall2->GetCallHandle() != hdCall2 ) { pCall2 -> Unlock(); pCall2 = NULL; pCall1 -> Unlock(); pCall1 = NULL; } } else { pCall1 -> Unlock(); pCall1 = NULL; } } } UnlockCallTable(); *ppCall2 = pCall2; H323DBG(( DEBUG_LEVEL_TRACE, "Find2H323CallsAndLock exited:%lx:%lx.", hdCall1, hdCall2 )); return pCall1; } PH323_CALL CH323Line::FindH323CallAndLock ( IN HDRVCALL hdCall) { H323DBG(( DEBUG_LEVEL_TRACE, "FindH323CallAndLock entered:%lx.", hdCall )); int iIndex = MakeCallIndex (hdCall); PH323_CALL pCall = NULL; LockCallTable(); //lock the call so that nobody else would be able to delete the call if( pCall=m_H323CallTable[iIndex] ) { pCall -> Lock(); if( pCall->GetCallHandle() != hdCall ) { pCall -> Unlock(); pCall = NULL; } } UnlockCallTable(); H323DBG(( DEBUG_LEVEL_TRACE, "FindH323CallAndLock exited:%p.", pCall )); return pCall; } PH323_CALL CH323Line::FindCallByARQSeqNumAndLock( WORD seqNumber ) { PH323_CALL pCall = NULL; int iIndex; H323DBG(( DEBUG_LEVEL_TRACE, "FindCallByARQSeqNumAndLock entered:%d.", seqNumber )); LockCallTable(); //lock the call so that nobody else would be able to delete the call for( iIndex=0; iIndex < m_H323CallTable.GetAllocSize(); iIndex++ ) { if( pCall=m_H323CallTable[iIndex] ) { if( pCall->GetARQSeqNumber() == seqNumber ) { pCall -> Lock(); break; } pCall = NULL; } } UnlockCallTable(); H323DBG(( DEBUG_LEVEL_TRACE, "FindCallByARQSeqNumAndLock exited." )); return pCall; } //the code is replicated for the purpose of effeciency PH323_CALL CH323Line::FindCallByDRQSeqNumAndLock( WORD seqNumber ) { PH323_CALL pCall = NULL; int iIndex; H323DBG(( DEBUG_LEVEL_TRACE, "FindCallByDRQSeqNumAndLock entered:%d.", seqNumber )); LockCallTable(); //lock the call so that nobody else would be able to delete the call for( iIndex=0; iIndex < m_H323CallTable.GetAllocSize(); iIndex++ ) { if( pCall=m_H323CallTable[iIndex] ) { if( pCall->GetDRQSeqNumber() == seqNumber ) { pCall -> Lock(); break; } pCall = NULL; } } UnlockCallTable(); H323DBG(( DEBUG_LEVEL_TRACE, "FindCallByDRQSeqNumAndLock exited:%d.", seqNumber )); return pCall; } //the code is replicated for the purpose of effeciency PH323_CALL CH323Line::FindCallByCallRefAndLock( WORD wCallRef ) { PH323_CALL pCall = NULL; int iIndex; H323DBG(( DEBUG_LEVEL_TRACE, "FindCallByCallRefAndLock entered:%d.", wCallRef )); wCallRef &= 0x7fff; LockCallTable(); //lock the call so that nobody else would be able to delete the call for( iIndex=0; iIndex < m_H323CallTable.GetAllocSize(); iIndex++ ) { if( pCall=m_H323CallTable[iIndex] ) { if( pCall->GetCallRef() == wCallRef ) { pCall -> Lock(); break; } pCall = NULL; } } UnlockCallTable(); H323DBG(( DEBUG_LEVEL_TRACE, "FindCallByCallRefAndLock exited:%d.", wCallRef )); return pCall; } void CH323Line::RemoveFromCTCallIdentityTable( HDRVCALL hdCall ) { int iIndex; PCTCALLID_CONTEXT pCTCallIDContext = NULL; H323DBG(( DEBUG_LEVEL_TRACE, "RemoveFromCTCallIdentityTable entered:%lx.", hdCall )); m_CTCallIDTable.Lock(); for( iIndex=0; iIndex < m_CTCallIDTable.GetAllocSize(); iIndex++ ) { pCTCallIDContext = m_CTCallIDTable[iIndex]; if( pCTCallIDContext != NULL ) { if( pCTCallIDContext -> hdCall == hdCall) { m_CTCallIDTable.RemoveAt(iIndex); } } } m_CTCallIDTable.Unlock(); H323DBG(( DEBUG_LEVEL_TRACE, "RemoveFromCTCallIdentityTable exited:%lx.", hdCall )); } void CH323Line::ShutdownCTCallIDTable() { int iIndex; PCTCALLID_CONTEXT pCTCallIDContext = NULL; H323DBG(( DEBUG_LEVEL_TRACE, "ShutdownCTCallIDTable entered." )); m_CTCallIDTable.Lock(); for( iIndex=0; iIndex < m_CTCallIDTable.GetAllocSize(); iIndex++ ) { pCTCallIDContext = m_CTCallIDTable[iIndex]; if( pCTCallIDContext != NULL ) { delete pCTCallIDContext; m_CTCallIDTable[iIndex] = NULL; } } m_CTCallIDTable.Unlock(); H323DBG(( DEBUG_LEVEL_TRACE, "ShutdownCTCallIDTable exited." )); } BOOL CH323Line::CallReferenceDuped( WORD wCallRef ) { PH323_CALL pCall = NULL; int iIndex; H323DBG(( DEBUG_LEVEL_TRACE, "CallReferenceDuped entered:%d.", wCallRef )); wCallRef &= 0x7FFF; LockCallTable(); for( iIndex=0; iIndex < m_H323CallTable.GetAllocSize(); iIndex++ ) { if( pCall=m_H323CallTable[iIndex] ) { if( pCall->GetCallRef() == wCallRef ) { UnlockCallTable(); return TRUE; } } } UnlockCallTable(); H323DBG(( DEBUG_LEVEL_TRACE, "CallReferenceDuped exited:%d.", wCallRef )); return FALSE; } HDRVCALL CH323Line::GetCallFromCTCallIdentity( int iCTCallID ) { int iIndex; PCTCALLID_CONTEXT pCTCallIDContext = NULL; H323DBG(( DEBUG_LEVEL_TRACE, "GetCallFromCTCallIdentity entered:%d.", iCTCallID )); m_CTCallIDTable.Lock(); for( iIndex=0; iIndex < m_CTCallIDTable.GetAllocSize(); iIndex++ ) { pCTCallIDContext = m_CTCallIDTable[iIndex]; if( pCTCallIDContext != NULL ) { if( pCTCallIDContext -> iCTCallIdentity == iCTCallID ) { m_CTCallIDTable.Unlock(); return (HDRVCALL)(pCTCallIDContext -> hdCall); } } } m_CTCallIDTable.Unlock(); H323DBG(( DEBUG_LEVEL_TRACE, "GetCallFromCTCallIdentity exited:%d.", iCTCallID )); return NULL; } int CH323Line::GetCTCallIdentity( IN HDRVCALL hdCall) { int CTCallID = 0; int iIndex; PCTCALLID_CONTEXT pCTCallIDContext = NULL; H323DBG(( DEBUG_LEVEL_TRACE, "GetCTCallIdentity entered:%lx.", hdCall )); m_CTCallIDTable.Lock(); do { g_CTCallIdentity++; if( g_CTCallIdentity == 10000 ) { g_CTCallIdentity = 1; } //lock the call so that nobody else would be able to delete the call for( iIndex=0; iIndex < m_CTCallIDTable.GetAllocSize(); iIndex++ ) { pCTCallIDContext = m_CTCallIDTable[iIndex] ; if( pCTCallIDContext != NULL ) { if( pCTCallIDContext -> iCTCallIdentity == g_CTCallIdentity ) { break; } } } if( iIndex == m_CTCallIDTable.GetAllocSize() ) { CTCallID = g_CTCallIdentity; } }while( CTCallID == 0 ); pCTCallIDContext = new CTCALLID_CONTEXT; if( pCTCallIDContext == NULL ) { m_CTCallIDTable.Unlock(); return 0; } pCTCallIDContext->iCTCallIdentity = CTCallID; pCTCallIDContext->hdCall = hdCall; if( m_CTCallIDTable.Add(pCTCallIDContext) == -1 ) { m_CTCallIDTable.Unlock(); delete pCTCallIDContext; return 0; } m_CTCallIDTable.Unlock(); H323DBG(( DEBUG_LEVEL_TRACE, "GetCTCallIdentity exited:%lx.", hdCall )); return CTCallID; } void CH323Line::SetCallForwardParams( IN CALLFORWARDPARAMS* pCallForwardParams ) { H323DBG(( DEBUG_LEVEL_TRACE, "SetCallForwardParams entered." )); if( m_pCallForwardParams != NULL ) { FreeCallForwardParams( m_pCallForwardParams ); m_pCallForwardParams = NULL; } m_pCallForwardParams = pCallForwardParams; H323DBG(( DEBUG_LEVEL_TRACE, "SetCallForwardParams exited." )); } BOOL CH323Line::SetCallForwardParams( IN LPFORWARDADDRESS pForwardAddress ) { H323DBG(( DEBUG_LEVEL_TRACE, "SetCallForwardParams entered." )); if( m_pCallForwardParams != NULL ) { pForwardAddress->next = m_pCallForwardParams->pForwardedAddresses; m_pCallForwardParams->pForwardedAddresses = pForwardAddress; } else { m_pCallForwardParams = new CALLFORWARDPARAMS; if( m_pCallForwardParams == NULL ) { return FALSE; } ZeroMemory( m_pCallForwardParams, sizeof(CALLFORWARDPARAMS) ); m_pCallForwardParams->fForwardingEnabled = TRUE; m_pCallForwardParams->pForwardedAddresses = pForwardAddress; pForwardAddress -> next = NULL; } //set unconditional forwarding m_pCallForwardParams->fForwardForAllOrigins = FALSE; H323DBG(( DEBUG_LEVEL_TRACE, "SetCallForwardParams exited." )); return TRUE; } CH323Line::~CH323Line() { DeleteCriticalSection (&m_CriticalSection); } /*++ Routine Description: Hangs up call (if necessary) and closes call object. Arguments: Handle of the call. Return Values: none. --*/ void CH323Line::H323ReleaseCall( IN HDRVCALL hdCall, IN DWORD dwDisconnectMode, IN WORD wCallReference ) { H323DBG(( DEBUG_LEVEL_TRACE, "H323ReleaseCall entered:%lx.", hdCall )); int iIndex = MakeCallIndex (hdCall); PH323_CALL pCall; BOOL fDelete = FALSE; LockCallTable(); //lock the call so that nobody else would be able to delete the call if( (pCall=m_H323CallTable[iIndex]) && (hdCall==pCall->GetCallHandle()) ) { pCall -> Lock(); if( (wCallReference != 0) && (wCallReference != pCall->GetCallRef()) ) { //This message is for some other call. Ignore the message. H323DBG(( DEBUG_LEVEL_VERBOSE, "TSPI_CLOSE_CALL message ignored.")); } else { // drop call using normal disconnect code pCall -> DropCall( dwDisconnectMode ); pCall -> Shutdown( &fDelete ); H323DBG(( DEBUG_LEVEL_VERBOSE, "call 0x%08lx closed.", pCall )); } pCall -> Unlock(); //release the H323 call object if( fDelete == TRUE ) { H323DBG(( DEBUG_LEVEL_VERBOSE, "call delete:0x%08lx.", pCall )); delete pCall; } } UnlockCallTable(); H323DBG(( DEBUG_LEVEL_TRACE, "H323ReleaseCall exited: %p.", pCall )); } BOOL CH323Line::Initialize ( IN DWORD dwLineDeviceIDBase) { DWORD dwSize; H323DBG((DEBUG_LEVEL_TRACE, "line Initialize entered.")); if( m_dwInitState & LINEOBJECT_INITIALIZED ) { return TRUE; } __try { if( !InitializeCriticalSectionAndSpinCount( &m_CriticalSection, 0x80000000 ) ) { return FALSE; } } __except( 1 ) { return FALSE; } m_dwDeviceID = dwLineDeviceIDBase; m_dwInitState = LINEOBJECT_INITIALIZED; //m_dwMediaModes = H323_LINE_MEDIAMODES; m_hdLine = (HDRVLINE__ *)this; m_dwNumRingsNoAnswer = H323_NUMRINGS_NOANSWER; dwSize = sizeof( m_wszAddr ); //create displayable address GetComputerNameW( m_wszAddr, &dwSize ); H323DBG(( DEBUG_LEVEL_TRACE, "line %d initialized (addr=%S)(hdLine=%d).", m_dwDeviceID, m_wszAddr, m_hdLine)); // change line device state to closed m_nState = H323_LINESTATE_NONE; //init the mSP handles list m_MSPHandleList = NULL; H323DBG(( DEBUG_LEVEL_TRACE, "line Initialize exited." )); // success return TRUE; } BOOL CH323Line::AddMSPInstance( HTAPIMSPLINE htMSPLine, HDRVMSPLINE hdMSPLine ) { MSPHANDLEENTRY* pMSPHandleEntry; H323DBG(( DEBUG_LEVEL_TRACE, "AddMSPInstance entered." )); Lock(); pMSPHandleEntry = new MSPHANDLEENTRY; if( pMSPHandleEntry == NULL ) { Unlock(); return FALSE; } pMSPHandleEntry->htMSPLine = htMSPLine; pMSPHandleEntry->hdMSPLine = hdMSPLine; pMSPHandleEntry->next = m_MSPHandleList; m_MSPHandleList = pMSPHandleEntry; Unlock(); H323DBG(( DEBUG_LEVEL_TRACE, "AddMSPInstance exited." )); return TRUE; } BOOL CH323Line::IsValidMSPHandle( HDRVMSPLINE hdMSPLine, HTAPIMSPLINE* phtMSPLine ) { Lock(); MSPHANDLEENTRY* pMSPHandle = m_MSPHandleList; while( pMSPHandle ) { if( pMSPHandle->hdMSPLine == hdMSPLine ) { *phtMSPLine = pMSPHandle->htMSPLine; Unlock(); return TRUE; } pMSPHandle = pMSPHandle->next; } Unlock(); return FALSE; } BOOL CH323Line::DeleteMSPInstance( HTAPIMSPLINE* phtMSPLine, HDRVMSPLINE hdMSPLine ) { MSPHANDLEENTRY* pMSPHandle; MSPHANDLEENTRY* pMSPHandleDel; BOOL fRetVal = TRUE; H323DBG(( DEBUG_LEVEL_TRACE, "DeleteMSPInstance entered." )); Lock(); if( m_MSPHandleList == NULL ) { fRetVal = FALSE; goto func_exit; } if( m_MSPHandleList->hdMSPLine == hdMSPLine ) { *phtMSPLine = m_MSPHandleList->htMSPLine; pMSPHandleDel = m_MSPHandleList; m_MSPHandleList = m_MSPHandleList->next; delete pMSPHandleDel; fRetVal = TRUE; goto func_exit; } for( pMSPHandle=m_MSPHandleList; pMSPHandle->next; pMSPHandle=pMSPHandle->next ) { if( pMSPHandle->next->hdMSPLine == hdMSPLine ) { *phtMSPLine = pMSPHandle->next->htMSPLine; pMSPHandleDel = pMSPHandle->next; pMSPHandle->next = pMSPHandle->next->next; delete pMSPHandleDel; fRetVal = TRUE; goto func_exit; } } func_exit: Unlock(); H323DBG(( DEBUG_LEVEL_TRACE, "DeleteMSPInstance exited." )); return fRetVal; } //!!always called in a lock void CH323Line::ShutdownAllCalls(void) { PH323_CALL pCall; H323_CONFERENCE* pConf; DWORD indexI; DWORD dwSize; BOOL fDelete = FALSE; if( !(m_dwInitState & LINEOBJECT_INITIALIZED) ) return; H323DBG((DEBUG_LEVEL_TRACE, "ShutdownAllCalls entered.")); if( m_dwInitState & LINEOBJECT_SHUTDOWN ) { return; } //shutdown all calls, delete all calls LockCallTable(); dwSize = m_H323CallTable.GetAllocSize(); for( indexI=0; indexI < dwSize; indexI++ ) { pCall = m_H323CallTable[indexI]; if( pCall != NULL ) { pCall -> DropCall( 0 ); pCall -> Shutdown(&fDelete); if(fDelete) { H323DBG((DEBUG_LEVEL_TRACE, "call delete:%p.", pCall )); delete pCall; } } } UnlockCallTable(); dwSize = m_H323ConfTable.GetSize(); for( indexI=0; indexI < dwSize; indexI++ ) { pConf = m_H323ConfTable[indexI]; //m_H323ConfTable.RemoveAt( indexI ); if( pConf != NULL ) { delete pConf; m_H323ConfTable[indexI] = NULL; } } H323DBG((DEBUG_LEVEL_TRACE, "ShutdownAllCalls exited.")); } void CH323Line::Shutdown(void) { BOOL fDelete = FALSE; MSPHANDLEENTRY* pMSPHandle; if( !(m_dwInitState & LINEOBJECT_INITIALIZED) ) { return; } H323DBG((DEBUG_LEVEL_TRACE, "line Shutdown entered.")); Lock(); if( m_dwInitState & LINEOBJECT_SHUTDOWN ) { Unlock(); return; } FreeCallForwardParams( m_pCallForwardParams ); m_pCallForwardParams = NULL; Close(); m_dwMediaModes = NULL; //m_hdLine = NULL; m_hdNextMSPHandle = NULL; m_htLine = NULL; //Free the MSP handles list while( m_MSPHandleList ) { pMSPHandle = m_MSPHandleList; m_MSPHandleList = m_MSPHandleList->next; delete pMSPHandle; } m_dwInitState |= LINEOBJECT_SHUTDOWN; Unlock(); H323DBG(( DEBUG_LEVEL_TRACE, "line Shutdown exited." )); } LONG CH323Line::CopyLineInfo( IN DWORD dwDeviceID, OUT LPLINEADDRESSCAPS pAddressCaps ) { DWORD dwAddressSize; H323DBG((DEBUG_LEVEL_TRACE, "line CopyLineInfo entered.")); // determine size of address name dwAddressSize = H323SizeOfWSZ( m_wszAddr ); // calculate number of bytes needed pAddressCaps->dwNeededSize = sizeof(LINEADDRESSCAPS) + dwAddressSize ; // validate buffer allocated is large enough if (pAddressCaps->dwTotalSize >= pAddressCaps->dwNeededSize) { // record amount of memory used pAddressCaps->dwUsedSize = pAddressCaps->dwNeededSize; // position address name after fixed portion pAddressCaps->dwAddressSize = dwAddressSize; pAddressCaps->dwAddressOffset = sizeof(LINEADDRESSCAPS); // copy address name after fixed portion CopyMemory((LPBYTE)pAddressCaps + pAddressCaps->dwAddressOffset, (LPBYTE)m_wszAddr, pAddressCaps->dwAddressSize ); } else if (pAddressCaps->dwTotalSize >= sizeof(LINEADDRESSCAPS)) { H323DBG(( DEBUG_LEVEL_WARNING, "lineaddresscaps structure too small for strings." )); // record amount of memory used pAddressCaps->dwUsedSize = sizeof(LINEADDRESSCAPS); } else { H323DBG((DEBUG_LEVEL_ERROR, "lineaddresscaps structure too small.")); // allocated structure too small return LINEERR_STRUCTURETOOSMALL; } H323DBG(( DEBUG_LEVEL_VERBOSE, "addr 0 capabilities requested." )); // transfer associated device id pAddressCaps->dwLineDeviceID = dwDeviceID; // initialize number of calls allowed per address pAddressCaps->dwMaxNumActiveCalls = H323_MAXCALLSPERADDR; // initialize supported address capabilities pAddressCaps->dwAddressSharing = H323_ADDR_ADDRESSSHARING; pAddressCaps->dwCallInfoStates = H323_ADDR_CALLINFOSTATES; pAddressCaps->dwCallStates = H323_ADDR_CALLSTATES; pAddressCaps->dwDisconnectModes = H323_ADDR_DISCONNECTMODES; pAddressCaps->dwAddrCapFlags = H323_ADDR_CAPFLAGS; pAddressCaps->dwCallFeatures = H323_ADDR_CALLFEATURES; pAddressCaps->dwAddressFeatures = H323_ADDR_ADDRFEATURES; pAddressCaps->dwCallerIDFlags = H323_ADDR_CALLPARTYIDFLAGS; pAddressCaps->dwCalledIDFlags = H323_ADDR_CALLPARTYIDFLAGS; // initialize unsupported address capabilities pAddressCaps->dwConnectedIDFlags = LINECALLPARTYID_UNAVAIL; pAddressCaps->dwRedirectionIDFlags = LINECALLPARTYID_UNAVAIL; pAddressCaps->dwRedirectingIDFlags = LINECALLPARTYID_UNAVAIL; H323DBG((DEBUG_LEVEL_TRACE, "line CopyLineInfo exited.")); H323DBG(( DEBUG_LEVEL_TRACE, "TSPI_lineGetAddressCaps - Exited." )); // success return NOERROR; } /*++ Routine Description: Initiate activities on line device and allocate resources. Arguments: htLine - TAPI's handle describing line device to open. dwTSPIVersion - The TSPI version negotiated through TSPI_lineNegotiateTSPIVersion under which the Service Provider is willing to operate. Return Values: Returns true if successful. --*/ LONG CH323Line::Open( IN DWORD DeviceID, IN HTAPILINE TapiLine, IN DWORD TspiVersion, IN HDRVLINE * ReturnDriverLine) { HRESULT hr; LONG dwStatus = ERROR_SUCCESS; H323DBG(( DEBUG_LEVEL_TRACE, "H323 line open entered." )); if (GetDeviceID() != DeviceID) { // do not recognize device return LINEERR_BADDEVICEID; } // make sure this is a version we support if (!H323ValidateTSPIVersion (TspiVersion)) { return LINEERR_INCOMPATIBLEAPIVERSION; } Lock(); switch (m_nState) { case H323_LINESTATE_OPENED: H323DBG ((DEBUG_LEVEL_ERROR, "H323 line is already open (H323_LINESTATE_OPENED), cannot reopen")); dwStatus = LINEERR_INUSE; break; case H323_LINESTATE_LISTENING: H323DBG ((DEBUG_LEVEL_ERROR, "H323 line is already open (H323_LINESTATE_LISTENING), cannot reopen")); dwStatus = LINEERR_INUSE; break; case H323_LINESTATE_CLOSING: H323DBG ((DEBUG_LEVEL_ERROR, "H323 line cannot be opened (H323_LINESTATE_CLOSING)")); dwStatus = LINEERR_INVALLINESTATE; break; case H323_LINESTATE_OPENING: H323DBG ((DEBUG_LEVEL_ERROR, "H323 line cannot be opened (H323_LINESTATE_OPENING)")); dwStatus = LINEERR_INVALLINESTATE; break; case H323_LINESTATE_NONE: // attempt to open line device H323DBG ((DEBUG_LEVEL_TRACE, "H323 line is opening")); // start listen if necessary if (IsMediaDetectionEnabled()) { hr = Q931AcceptStart(); if (hr == S_OK) { dwStatus = ERROR_SUCCESS; RasStart(); } else { H323DBG ((DEBUG_LEVEL_ERROR, "failed to listen on Q.931")); dwStatus = LINEERR_OPERATIONFAILED; } } if (dwStatus == ERROR_SUCCESS) { H323DBG ((DEBUG_LEVEL_TRACE, "H323 line successfully opened")); // save line variables now m_nState = IsMediaDetectionEnabled()? H323_LINESTATE_LISTENING:H323_LINESTATE_OPENED; m_htLine = TapiLine; m_dwTSPIVersion = TspiVersion; *ReturnDriverLine = (HDRVLINE) this; } else { Q931AcceptStop(); } break; default: _ASSERTE( FALSE ); } Unlock(); H323DBG(( DEBUG_LEVEL_TRACE, "H323 line open exited." )); return dwStatus; } /*++ Routine Description: Terminate activities on line device. Arguments: Return Values: Returns true if successful. --*/ LONG CH323Line::Close(void) { LONG dwStatus; H323DBG(( DEBUG_LEVEL_TRACE, "H323 line close entered." )); Lock(); switch (m_nState) { case H323_LINESTATE_OPENED: case H323_LINESTATE_LISTENING: if( m_fForwardConsultInProgress == TRUE ) { H323DBG(( DEBUG_LEVEL_TRACE, "H323 line closed while forward is in progress." )); //Unlock(); //return NOERROR; } // change line device state to closing m_nState = H323_LINESTATE_CLOSING; //shutdown all the calls ShutdownAllCalls(); RasStop(); if (IsMediaDetectionEnabled()) { Q931AcceptStop(); } ShutdownCTCallIDTable(); // reset variables m_htLine = (HTAPILINE) NULL; m_dwTSPIVersion = 0; // change line device state to closed m_nState = H323_LINESTATE_NONE; dwStatus = ERROR_SUCCESS; break; default: H323DBG(( DEBUG_LEVEL_ERROR, "H323: lineclose called in bogus state:%d", m_nState )); dwStatus = LINEERR_OPERATIONFAILED; break; } Unlock(); H323DBG(( DEBUG_LEVEL_TRACE, "H323 line close exited." )); return dwStatus; } // // TSPI procedures // /*++ Routine Description: This function closes the specified open line device after completing or aborting all outstanding calls and asynchronous operations on the device. The Service Provider has the responsibility to (eventually) report completion for every operation it decides to execute asynchronously. If this procedure is called for a line on which there are outstanding asynchronous operations, the operations should be reported complete with an appropriate result or error code before this procedure returns. Generally the TAPI DLL would wait for these to complete in an orderly fashion. However, the Service Provider should be prepared to handle an early call to TSPI_lineClose in "abort" or "emergency shutdown" situtations. A similar requirement exists for active calls on the line. Such calls must be dropped, with outstanding operations reported complete with appropriate result or error codes. After this procedure returns the Service Provider must report no further events on the line or calls that were on the line. The Service Provider's opaque handles for the line and calls on the line become "invalid". The Service Provider must relinquish non-sharable resources it reserves while the line is open. For example, closing a line accessed through a comm port and modem should result in closing the comm port, making it once available for use by other applications. This function is presumed to complete successfully and synchronously. Arguments: hdLine - Specifies the Service Provider's opaque handle to the line to be closed. After the line has been successfully closed, this handle is no longer valid. Return Values: Returns zero if the function is successful, or a negative error number if an error has occurred. Possible error returns are: LINEERR_INVALLINEHANDLE - The specified device handle is invalid. LINEERR_OPERATIONFAILED - The specified operation failed for unknown reasons. --*/ LONG TSPIAPI TSPI_lineClose ( IN HDRVLINE DriverLine) { _ASSERTE(DriverLine); _ASSERTE(DriverLine == (HDRVLINE) &g_H323Line); H323DBG(( DEBUG_LEVEL_TRACE, "TSPI_lineClose - Entered." )); return ((CH323Line *) DriverLine) -> Close(); } /*++ Routine Description: This function queries a specified line device to determine its telephony capabilities. The returned information is valid for all addresses on the line device. Line device ID numbering for a Service Provider is sequential from the value set by the function TSPI_lineSetDeviceIDBase. The dwExtVersion field of pLineDevCaps has already been filled in to indicate the version number of the Extension information requested. If it is zero, no Extension information is requested. If it is non-zero it holds a value that has already been negotiated for this device with the function TSPI_lineNegotiateExtVersion. The Service Provider should fill in Extension information according to the Extension version specified. One of the fields in the LINEDEVCAPS structure returned by this function contains the number of addresses assigned to the specified line device. The actual address IDs used to reference individual addresses vary from zero to one less than the returned number. The capabilities of each address may be different. Use TSPI_lineGetAddressCaps for each available combination to determine the exact capabilities of each address. Arguments: dwDeviceID - Specifies the line device to be queried. dwTSPIVersion - Specifies the negotiated TSPI version number. This value has already been negotiated for this device through the TSPI_lineNegotiateTSPIVersion function. pLineDevCaps - Specifies a far pointer to a variable sized structure of type LINEDEVCAPS. Upon successful completion of the request, this structure is filled with line device capabilities information. Return Values: Returns zero if the function is successful or a negative error number if an error has occurred. Possible error returns are: LINEERR_BADDEVICEID - The specified line device ID is out of range. LINEERR_INCOMPATIBLEAPIVERSION - The application requested an API version or version range that is either incompatible or cannot be supported by the Telephony API implementation and/or corresponding service provider. LINEERR_STRUCTURETOOSMALL - The dwTotalSize member of a structure does not specify enough memory to contain the fixed portion of the structure. The dwNeededSize field has been set to the amount required. --*/ LONG TSPIAPI TSPI_lineGetDevCaps( DWORD dwDeviceID, DWORD dwTSPIVersion, DWORD dwExtVersion, LPLINEDEVCAPS pLineDevCaps ) { DWORD dwLineNameSize; DWORD dwProviderInfoSize; H323DBG(( DEBUG_LEVEL_TRACE, "TSPI_lineGetDevCaps - Entered." )); if( g_pH323Line -> GetDeviceID() != dwDeviceID ) { // do not recognize device return LINEERR_BADDEVICEID; } // make sure this is a version we support if (!H323ValidateTSPIVersion(dwTSPIVersion)) { // do not support tspi version return LINEERR_INCOMPATIBLEAPIVERSION; } // determine string lengths dwProviderInfoSize = H323SizeOfWSZ(g_pwszProviderInfo); dwLineNameSize = H323SizeOfWSZ(g_pwszLineName); // calculate number of bytes required pLineDevCaps->dwNeededSize = sizeof(LINEDEVCAPS) + dwProviderInfoSize + dwLineNameSize ; // make sure buffer is large enough for variable length data if (pLineDevCaps->dwTotalSize >= pLineDevCaps->dwNeededSize) { // record amount of memory used pLineDevCaps->dwUsedSize = pLineDevCaps->dwNeededSize; // position provider info after fixed portion pLineDevCaps->dwProviderInfoSize = dwProviderInfoSize; pLineDevCaps->dwProviderInfoOffset = sizeof(LINEDEVCAPS); // position line name after device class pLineDevCaps->dwLineNameSize = dwLineNameSize; pLineDevCaps->dwLineNameOffset = pLineDevCaps->dwProviderInfoOffset + pLineDevCaps->dwProviderInfoSize ; // copy provider info after fixed portion CopyMemory((LPBYTE)pLineDevCaps + pLineDevCaps->dwProviderInfoOffset, (LPBYTE)g_pwszProviderInfo, pLineDevCaps->dwProviderInfoSize ); // copy line name after device class CopyMemory((LPBYTE)pLineDevCaps + pLineDevCaps->dwLineNameOffset, (LPBYTE)g_pwszLineName, pLineDevCaps->dwLineNameSize ); } else if (pLineDevCaps->dwTotalSize >= sizeof(LINEDEVCAPS)) { H323DBG(( DEBUG_LEVEL_WARNING, "linedevcaps structure too small for strings." )); // structure only contains fixed portion pLineDevCaps->dwUsedSize = sizeof(LINEDEVCAPS); } else { H323DBG(( DEBUG_LEVEL_WARNING, "linedevcaps structure too small." )); // structure is too small return LINEERR_STRUCTURETOOSMALL; } H323DBG(( DEBUG_LEVEL_VERBOSE, "line capabilities requested.")); // construct permanent line identifier pLineDevCaps->dwPermanentLineID = (DWORD)MAKELONG( dwDeviceID - g_dwLineDeviceIDBase, g_dwPermanentProviderID ); // notify tapi that strings returned are in unicode pLineDevCaps->dwStringFormat = STRINGFORMAT_UNICODE; // initialize line device capabilities pLineDevCaps->dwNumAddresses = H323_MAXADDRSPERLINE; pLineDevCaps->dwMaxNumActiveCalls = H323_MAXCALLSPERLINE; pLineDevCaps->dwAddressModes = H323_LINE_ADDRESSMODES; pLineDevCaps->dwBearerModes = H323_LINE_BEARERMODES; pLineDevCaps->dwDevCapFlags = H323_LINE_DEVCAPFLAGS; pLineDevCaps->dwLineFeatures = H323_LINE_LINEFEATURES; pLineDevCaps->dwMaxRate = H323_LINE_MAXRATE; pLineDevCaps->dwMediaModes = H323_LINE_MEDIAMODES; pLineDevCaps->dwRingModes = 0; // initialize address types to include phone numbers pLineDevCaps->dwAddressTypes = H323_LINE_ADDRESSTYPES; // line guid pLineDevCaps->PermanentLineGuid = LINE_H323; // modify GUID to be unique for each line pLineDevCaps->PermanentLineGuid.Data1 += dwDeviceID - g_dwLineDeviceIDBase; // protocol guid pLineDevCaps->ProtocolGuid = TAPIPROTOCOL_H323; // add dtmf support via H.245 user input messages pLineDevCaps->dwGenerateDigitModes = LINEDIGITMODE_DTMF; pLineDevCaps->dwMonitorDigitModes = LINEDIGITMODE_DTMF; H323DBG(( DEBUG_LEVEL_TRACE, "TSPI_lineGetDevCaps - Exited." )); // success return NOERROR; } /*++ Routine Description: This operation enables the TAPI DLL to query the specified open line device for its current status. The TAPI DLL uses TSPI_lineGetLineDevStatus to query the line device for its current line status. This status information applies globally to all addresses on the line device. Use TSPI_lineGetAddressStatus to determine status information about a specific address on a line. Arguments: hdLine - Specifies the Service Provider's opaque handle to the line to be queried. pLineDevStatus - Specifies a far pointer to a variable sized data structure of type LINEDEVSTATUS. Upon successful completion of the request, this structure is filled with the line's device status. Return Values: Returns zero if the function is successful or a negative error number if an error has occurred. Possible error returns are: LINEERR_INVALLINEHANDLE - The specified line device handle is invalid. LINEERR_STRUCTURETOOSMALL - The dwTotalSize member of a structure does not specify enough memory to contain the fixed portion of the structure. The dwNeededSize field has been set to the amount required. --*/ LONG TSPIAPI TSPI_lineGetLineDevStatus( HDRVLINE hdLine, LPLINEDEVSTATUS pLineDevStatus ) { H323DBG(( DEBUG_LEVEL_TRACE, "TSPI_lineGetDevStatus - Entered." )); if( hdLine != g_pH323Line -> GetHDLine() ) { return LINEERR_INVALLINEHANDLE; } // determine number of bytes needed pLineDevStatus->dwNeededSize = sizeof(LINEDEVSTATUS); // see if allocated structure is large enough if (pLineDevStatus->dwTotalSize < pLineDevStatus->dwNeededSize) { H323DBG(( DEBUG_LEVEL_ERROR, "linedevstatus structure too small." )); // structure too small return LINEERR_STRUCTURETOOSMALL; } // record number of bytes used pLineDevStatus->dwUsedSize = pLineDevStatus->dwNeededSize; // initialize supported line device status fields pLineDevStatus->dwLineFeatures = H323_LINE_LINEFEATURES; pLineDevStatus->dwDevStatusFlags = H323_LINE_DEVSTATUSFLAGS; // determine number of active calls on the line device pLineDevStatus -> dwNumActiveCalls = g_pH323Line -> GetNoOfCalls(); H323DBG(( DEBUG_LEVEL_TRACE, "TSPI_lineGetDevStatus - Exited." )); // success return NOERROR; } /*++ Routine Description: Retrieves the number of address IDs supported on the indicated line. This function is called by TAPI.DLL in response to an application calling lineSetNumRings, lineGetNumRings, or lineGetNewCalls. TAPI.DLL uses the retrieved value to determine if the specified address ID is within the range supported by the service provider. Arguments: hdLine - Specifies the handle to the line for which the number of address IDs is to be retrieved. pdwNumAddressIDs - Specifies a far pointer to a DWORD. The location is filled with the number of address IDs supported on the indicated line. The value should be one or larger. Return Values: Returns zero if the function is successful, or a negative error number if an error has occurred. Possible return values are as follows: LINEERR_INVALLINEHANDLE - The specified line device handle is invalid. --*/ LONG TSPIAPI TSPI_lineGetNumAddressIDs( HDRVLINE hdLine, LPDWORD pdwNumAddressIDs ) { H323DBG(( DEBUG_LEVEL_TRACE, "TSPI_lineGetNumAddressIDs - Entered." )); if( hdLine != g_pH323Line -> GetHDLine() ) { H323DBG(( DEBUG_LEVEL_TRACE, "TSPI_lineGetNumAddressIDs - bad linehandle:%lx, %lx.", hdLine, g_pH323Line -> GetHDLine() )); return LINEERR_INVALLINEHANDLE ; } // transfer number of addresses *pdwNumAddressIDs = H323_MAXADDRSPERLINE; H323DBG(( DEBUG_LEVEL_TRACE, "TSPI_lineGetNumAddressIDs - Exited." )); // success return NOERROR; } /*++ Routine Description: This function opens the line device whose device ID is given, returning the Service Provider's opaque handle for the device and retaining the TAPI DLL's opaque handle for the device for use in subsequent calls to the LINEEVENT procedure. Opening a line entitles the TAPI DLL to make further requests on the line. The line becomes "active" in the sense that the TAPI DLL can initiate outbound calls and the Service Provider can report inbound calls. The Service Provider reserves whatever non-sharable resources are required to manage the line. For example, opening a line accessed through a comm port and modem should result in opening the comm port, making it no longer available for use by other applications. If the function is successful, both the TAPI DLL and the Service Provider become committed to operating under the specified interface version number for this open device. Subsquent operations and events identified using the exchanged opaque line handles conform to that interface version. This commitment and the validity of the handles remain in effect until the TAPI DLL closes the line using the TSPI_lineClose operation or the Service Provider reports the LINE_CLOSE event. If the function is not successful, no such commitment is made and the handles are not valid. Arguments: dwDeviceID - Identifies the line device to be opened. The value LINE_MAPPER for a device ID is not permitted. htLine - Specifies the TAPI DLL's opaque handle for the line device to be used in subsequent calls to the LINEEVENT callback procedure to identify the device. phdLine - A far pointer to a HDRVLINE where the Service Provider fills in its opaque handle for the line device to be used by the TAPI DLL in subsequent calls to identify the device. dwTSPIVersion - The TSPI version negotiated through TSPI_lineNegotiateTSPIVersion under which the Service Provider is willing to operate. pfnEventProc - A far pointer to the LINEEVENT callback procedure supplied by the TAPI DLL that the Service Provider will call to report subsequent events on the line. Return Values: Returns zero if the function is successful, or a negative error number if an error has occurred. Possible return values are as follows: LINEERR_BADDEVICEID - The specified line device ID is out of range. LINEERR_INCOMPATIBLEAPIVERSION - The passed TSPI version or version range did not match an interface version definition supported by the service provider. LINEERR_INUSE - The line device is in use and cannot currently be configured, allow a party to be added, allow a call to be answered, or allow a call to be placed. LINEERR_OPERATIONFAILED - The operation failed for an unspecified or unknown reason. --*/ LONG TSPIAPI TSPI_lineOpen ( IN DWORD DeviceID, IN HTAPILINE TapiLine, IN LPHDRVLINE ReturnDriverLine, IN DWORD TspiVersion, IN LINEEVENT pfnEventProc) { return g_H323Line.Open (DeviceID, TapiLine, TspiVersion, ReturnDriverLine); } LONG TSPIAPI TSPI_lineCreateMSPInstance( HDRVLINE hdLine, DWORD dwAddressID, HTAPIMSPLINE htMSPLine, LPHDRVMSPLINE phdMSPLine ) { H323DBG(( DEBUG_LEVEL_TRACE, "TSPI_lineCreateMSPInstance - Entered." )); if( hdLine != g_pH323Line -> GetHDLine() ) { return LINEERR_RESOURCEUNAVAIL; } // We are not keeping the msp handles. Just fake a handle here. *phdMSPLine = g_pH323Line->GetNextMSPHandle(); if( !g_pH323Line->AddMSPInstance( htMSPLine , *phdMSPLine ) ) { return LINEERR_NOMEM; } H323DBG(( DEBUG_LEVEL_TRACE, "MSP instance created. hdMSP:%lx, htMSP:%lx.", *phdMSPLine, htMSPLine )); H323DBG(( DEBUG_LEVEL_TRACE, "TSPI_lineCreateMSPInstance - Exited." )); // success return NOERROR; } LONG TSPIAPI TSPI_lineCloseMSPInstance( HDRVMSPLINE hdMSPLine ) { HTAPIMSPLINE htMSPLine; H323DBG(( DEBUG_LEVEL_TRACE, "TSPI_lineCloseMSPInstance - Entered." )); if( !g_pH323Line->DeleteMSPInstance( &htMSPLine , hdMSPLine ) ) { return LINEERR_INVALPOINTER; } H323DBG(( DEBUG_LEVEL_TRACE, "MSP instance deleted. hdMSP:%lx, htMSP:%lx.", hdMSPLine, htMSPLine )); H323DBG(( DEBUG_LEVEL_TRACE, "TSPI_lineCloseMSPInstance - Exited." )); // success return NOERROR; }