2004 lines
47 KiB
C++
2004 lines
47 KiB
C++
// File: icall.cpp
|
|
|
|
#include "precomp.h"
|
|
|
|
#include "icall.h"
|
|
#include "rostinfo.h"
|
|
#include "imanager.h"
|
|
#include "mperror.h"
|
|
#include "nmremote.h"
|
|
#include "util.h"
|
|
|
|
typedef struct
|
|
{
|
|
BOOL fMCU;
|
|
PWSTR * pwszConfNames;
|
|
BSTR * pbstrConfToJoin;
|
|
} REMOTE_CONFERENCE;
|
|
|
|
typedef struct
|
|
{
|
|
BSTR bstrConference;
|
|
BSTR *pbstrPassword;
|
|
PBYTE pbRemoteCred;
|
|
DWORD cbRemoteCred;
|
|
BOOL fIsService;
|
|
} REMOTE_PASSWORD;
|
|
|
|
|
|
HRESULT OnNotifyCallError(IUnknown *pCallNotify, PVOID pv, REFIID riid);
|
|
|
|
static HRESULT OnNotifyRemoteConference(IUnknown *pCallNotify, PVOID pv, REFIID riid);
|
|
static HRESULT OnNotifyRemotePassword(IUnknown *pCallNotify, PVOID pv, REFIID riid);
|
|
|
|
static const IID * g_apiidCP[] =
|
|
{
|
|
{&IID_INmCallNotify},
|
|
{&IID_INmCallNotify2}
|
|
};
|
|
|
|
// String Functions
|
|
inline VOID FreeBstr(BSTR *pbstr)
|
|
{
|
|
if (NULL != pbstr)
|
|
{
|
|
SysFreeString(*pbstr);
|
|
*pbstr = NULL;
|
|
}
|
|
}
|
|
|
|
/* P S Z A L L O C */
|
|
/*-------------------------------------------------------------------------
|
|
%%Function: PszAlloc
|
|
|
|
-------------------------------------------------------------------------*/
|
|
LPTSTR PszAlloc(LPCTSTR pszSrc)
|
|
{
|
|
if (NULL == pszSrc)
|
|
return NULL;
|
|
|
|
LPTSTR pszDest = new TCHAR[lstrlen(pszSrc) + 1];
|
|
if (NULL != pszDest)
|
|
{
|
|
lstrcpy(pszDest, pszSrc);
|
|
}
|
|
return pszDest;
|
|
}
|
|
|
|
COutgoingCall::COutgoingCall(CConfObject* pco,
|
|
DWORD dwFlags, NM_ADDR_TYPE addrType,
|
|
BSTR bstrName, BSTR bstrDest, BSTR bstrAlias,
|
|
BSTR bstrConference, BSTR bstrPassword, BSTR bstrUserString) :
|
|
CConnectionPointContainer(g_apiidCP, ARRAY_ELEMENTS(g_apiidCP)),
|
|
m_pConfObject (pco),
|
|
m_addrType (addrType),
|
|
m_dwFlags (dwFlags),
|
|
m_bstrName (SysAllocString(bstrName)),
|
|
m_bstrAlias (SysAllocString(bstrAlias)),
|
|
m_bstrConfToJoin (SysAllocString(bstrConference)),
|
|
m_bstrPassword (SysAllocString(bstrPassword)),
|
|
m_bstrUserString (SysAllocString(bstrUserString)),
|
|
m_hRequest (NULL),
|
|
m_pH323Connection (NULL),
|
|
m_fCanceled (FALSE),
|
|
m_cnResult (CN_RC_NOERROR),
|
|
m_cnState (CNS_IDLE),
|
|
m_fService (FALSE)
|
|
{
|
|
m_pszAddr = PszAlloc(CUSTRING(bstrDest));
|
|
DbgMsg(iZONE_OBJECTS, "Obj: %08X created COutgoingCall", this);
|
|
}
|
|
|
|
COutgoingCall::~COutgoingCall()
|
|
{
|
|
delete m_pszAddr;
|
|
|
|
FreeBstr(&m_bstrName);
|
|
FreeBstr(&m_bstrAlias);
|
|
FreeBstr(&m_bstrConfToJoin);
|
|
FreeBstr(&m_bstrPassword);
|
|
FreeBstr(&m_bstrUserString);
|
|
|
|
ASSERT(NULL == m_pH323Connection);
|
|
|
|
DbgMsg(iZONE_OBJECTS, "Obj: %08X destroyed COutgoingCall", this);
|
|
}
|
|
|
|
|
|
BOOL COutgoingCall::MatchActiveCallee(LPCTSTR pszAddr, BSTR bstrAlias, BSTR bstrConference)
|
|
{
|
|
return ((0 == lstrcmp(pszAddr, m_pszAddr)) &&
|
|
(0 == UnicodeCompare(bstrAlias, m_bstrAlias)));
|
|
|
|
}
|
|
|
|
/* P L A C E C A L L */
|
|
/*-------------------------------------------------------------------------
|
|
%%Function: PlaceCall
|
|
|
|
-------------------------------------------------------------------------*/
|
|
VOID COutgoingCall::PlaceCall(void)
|
|
{
|
|
DebugEntry(COutgoingCall::PlaceCall);
|
|
|
|
COprahNCUI *pOprahNCUI = COprahNCUI::GetInstance();
|
|
ASSERT(NULL != pOprahNCUI);
|
|
|
|
SetCallState(CNS_SEARCHING);
|
|
|
|
if ((CRPCF_H323CC & m_dwFlags) && (NULL != g_pH323UI))
|
|
{
|
|
SetCallState(CNS_CONNECTING_H323);
|
|
|
|
// Start placing the H.323 call:
|
|
CNSTATUS cnResult = ConnectH323();
|
|
if (CN_RC_NOERROR != cnResult)
|
|
{
|
|
m_cnResult = cnResult;
|
|
SetCallState(CNS_COMPLETE);
|
|
}
|
|
}
|
|
else if ((CRPCF_DATA & m_dwFlags) && (NULL != g_pNodeController))
|
|
{
|
|
// Start placing the T.120 call
|
|
CNSTATUS cnResult = StartT120Call();
|
|
if (CN_RC_NOERROR != cnResult)
|
|
{
|
|
m_cnResult = cnResult;
|
|
SetCallState(CNS_COMPLETE);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_cnResult = CN_RC_TRANSPORT_FAILURE;
|
|
SetCallState(CNS_COMPLETE);
|
|
}
|
|
|
|
DebugExitVOID(COutgoingCall::PlaceCall);
|
|
}
|
|
|
|
CNSTATUS COutgoingCall::ConnectH323()
|
|
{
|
|
DBGENTRY(COutgoingCall::ConnectH323);
|
|
H323ALIASLIST AliasList;
|
|
H323ALIASNAME AliasName;
|
|
P_H323ALIASLIST pAliasList = &AliasList;
|
|
SOCKADDR_IN sin;
|
|
LPCWSTR pcwszPhone = NULL;
|
|
CNSTATUS cnResult = CN_RC_NOERROR;
|
|
|
|
if (NULL == g_pH323UI)
|
|
return cnResult;
|
|
|
|
AliasName.aType = AT_H323_ID;
|
|
AliasName.lpwData = m_bstrAlias;
|
|
AliasName.wDataLength = (WORD)SysStringLen(m_bstrAlias);// # of unicode chars, w/o NULL terminator
|
|
AliasList.wCount = 1;
|
|
AliasList.pItems = &AliasName;
|
|
|
|
sin.sin_family = AF_INET;
|
|
sin.sin_addr.s_addr = inet_addr(m_pszAddr);
|
|
|
|
switch (m_addrType)
|
|
{
|
|
case NM_ADDR_PSTN:
|
|
case NM_ADDR_H323_GATEWAY:
|
|
case NM_ADDR_ALIAS_E164:
|
|
// overide alias type and phone number
|
|
AliasName.aType = AT_H323_E164;
|
|
pcwszPhone = m_bstrAlias;
|
|
break;
|
|
|
|
case NM_ADDR_IP:
|
|
case NM_ADDR_MACHINENAME:
|
|
// overide alias list
|
|
pAliasList = NULL;
|
|
break;
|
|
|
|
case NM_ADDR_ALIAS_ID:
|
|
case NM_ADDR_ULS:
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (INADDR_NONE != sin.sin_addr.s_addr)
|
|
{
|
|
HRESULT hr;
|
|
ASSERT(g_pH323UI);
|
|
|
|
DWORD dwUserData = 0;
|
|
APP_CALL_SETUP_DATA acsd;
|
|
P_APP_CALL_SETUP_DATA pacsd = NULL;
|
|
BYTE *pbUserData = NULL;
|
|
|
|
COprahNCUI *pOprahNCUI = COprahNCUI::GetInstance();
|
|
ASSERT(NULL !=pOprahNCUI);
|
|
|
|
if (CRPCF_DATA & m_dwFlags)
|
|
{
|
|
if (CRPCF_SECURE & m_dwFlags)
|
|
{
|
|
dwUserData |= H323UDF_SECURE;
|
|
}
|
|
|
|
if (m_pConfObject->IsConferenceActive())
|
|
{
|
|
dwUserData |= H323UDF_INVITE;
|
|
}
|
|
else if (m_bstrConfToJoin != NULL)
|
|
{
|
|
dwUserData |= H323UDF_JOIN;
|
|
}
|
|
else
|
|
{
|
|
dwUserData |= H323UDF_INVITE | H323UDF_JOIN;
|
|
}
|
|
}
|
|
|
|
if (CRPCF_AUDIO & m_dwFlags)
|
|
{
|
|
dwUserData |= H323UDF_AUDIO;
|
|
}
|
|
if (CRPCF_VIDEO & m_dwFlags)
|
|
{
|
|
dwUserData |= H323UDF_VIDEO;
|
|
}
|
|
|
|
CRosterInfo ri;
|
|
PVOID pvRosterData;
|
|
UINT cbRosterData = 0;
|
|
|
|
if (pOprahNCUI->GetULSName(&ri))
|
|
{
|
|
if (FAILED(ri.Save(&pvRosterData, &cbRosterData)))
|
|
{
|
|
cbRosterData = 0;
|
|
}
|
|
}
|
|
|
|
UINT cbUserString = 0;
|
|
if (m_bstrUserString)
|
|
{
|
|
cbUserString = SysStringByteLen(m_bstrUserString);
|
|
}
|
|
|
|
DWORD dwTotalSize = sizeof(DWORD);
|
|
if (cbRosterData)
|
|
{
|
|
dwTotalSize += sizeof(GUID) + sizeof(DWORD) + cbRosterData;
|
|
}
|
|
if (cbUserString)
|
|
{
|
|
dwTotalSize += sizeof(GUID) + sizeof(DWORD) + cbUserString;
|
|
}
|
|
dwTotalSize += sizeof(GUID) + sizeof(DWORD) + sizeof(GUID);
|
|
|
|
pbUserData = new BYTE [dwTotalSize];
|
|
if (NULL != pbUserData)
|
|
{
|
|
BYTE *pb = pbUserData;
|
|
|
|
// H323UDF_ first
|
|
*((DWORD*)pb) = dwUserData;
|
|
pb += sizeof(DWORD);
|
|
|
|
if(cbRosterData)
|
|
{
|
|
// RosterInfo GUID next
|
|
*((GUID*)pb) = g_csguidRostInfo,
|
|
pb += sizeof(GUID);
|
|
|
|
// then RosterInfo size (a DWORD)
|
|
*((DWORD*)pb) = cbRosterData;
|
|
pb += sizeof(DWORD);
|
|
|
|
// then RosterInfo data
|
|
CopyMemory(pb, pvRosterData, cbRosterData);
|
|
pb += cbRosterData;
|
|
}
|
|
|
|
if(cbUserString)
|
|
{
|
|
// string GUID next
|
|
*((GUID*)pb) = g_csguidUserString,
|
|
pb += sizeof(GUID);
|
|
|
|
// then string size (a DWORD)
|
|
*((DWORD*)pb) = cbUserString;
|
|
pb += sizeof(DWORD);
|
|
|
|
// then string data
|
|
CopyMemory(pb, m_bstrUserString, cbUserString);
|
|
pb += cbUserString;
|
|
}
|
|
|
|
{
|
|
// string GUID next
|
|
*((GUID*)pb) = g_csguidNodeIdTag,
|
|
pb += sizeof(GUID);
|
|
|
|
// then string size (a DWORD)
|
|
*((DWORD*)pb) = sizeof(GUID);
|
|
pb += sizeof(DWORD);
|
|
|
|
// then GUID data
|
|
*(GUID*)pb = g_guidLocalNodeId;
|
|
pb += sizeof(GUID);
|
|
}
|
|
|
|
acsd.dwDataSize = dwTotalSize;
|
|
acsd.lpData = pbUserData;
|
|
pacsd = &acsd;
|
|
}
|
|
|
|
sin.sin_port = htons(H323_PORT);
|
|
hr = Connect(&sin, pAliasList, pcwszPhone, pacsd, PID_H323, &m_pH323Connection);
|
|
delete [] pbUserData;
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
TRACE_OUT(("COutgoingCall - Connect() succeeded!"));
|
|
cnResult = CN_RC_NOERROR;
|
|
}
|
|
else
|
|
{
|
|
WARNING_OUT(("COutgoingCall - Connect() failed!"));
|
|
if (CONN_E_GK_NOT_REGISTERED == hr)
|
|
{
|
|
cnResult = CN_RC_GK_NOT_REGISTERED;
|
|
}
|
|
else
|
|
{
|
|
cnResult = CN_RC_AUDIO_CONNECT_FAILED;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
WARNING_OUT(("COutgoingCall - inet_addr failed!"));
|
|
cnResult = CN_RC_NAME_RESOLUTION_FAILED;
|
|
}
|
|
return cnResult;
|
|
}
|
|
|
|
|
|
HRESULT COutgoingCall::Connect( PSOCKADDR_IN psin,
|
|
P_H323ALIASLIST pAliasList,
|
|
LPCWSTR pcwszPSTNAddress,
|
|
P_APP_CALL_SETUP_DATA lpvMNMData,
|
|
GUID PIDofProtocolType,
|
|
IH323Endpoint * *ppConnection)
|
|
{
|
|
DebugEntry(CH323UI::Connect);
|
|
|
|
HRESULT hr = E_ACCESSDENIED;
|
|
|
|
*ppConnection = NULL;
|
|
|
|
COprahNCUI *pOprahNCUI = COprahNCUI::GetInstance();
|
|
ASSERT(NULL != pOprahNCUI);
|
|
|
|
IH323CallControl * pH323CallControl = g_pH323UI->GetH323CallControl();
|
|
|
|
// create the connection
|
|
IH323Endpoint* pConn = NULL;
|
|
ASSERT(pH323CallControl);
|
|
|
|
hr = pH323CallControl->CreateConnection(&pConn, PIDofProtocolType);
|
|
if (FAILED(hr) || (NULL == pConn))
|
|
{
|
|
ERROR_OUT(("Could not create a connection, hr=0x%lx", hr));
|
|
}
|
|
else
|
|
{
|
|
// if the following operations fail, we still can delete this conn obj
|
|
*ppConnection = pConn;
|
|
|
|
if (!pOprahNCUI->AcquireAV(pConn))
|
|
{
|
|
// we did not get AV, clear out the flags
|
|
m_dwFlags &= ~(CRPCF_AUDIO | CRPCF_VIDEO);
|
|
}
|
|
|
|
hr = pConn->SetAdviseInterface (pOprahNCUI);
|
|
ASSERT(SUCCEEDED(hr));
|
|
|
|
// if we are using an alias, tell the Gatekeeper to resolve it
|
|
BOOL fUseGKResolution = (NULL != pAliasList);
|
|
|
|
// start the connection
|
|
hr = pConn->PlaceCall (fUseGKResolution, psin, pAliasList, NULL, pcwszPSTNAddress, lpvMNMData);
|
|
if (FAILED(hr))
|
|
{
|
|
// ERROR_OUT(("COutgoingCall::Connect: couldn't StartConnection, hr=0x%lx", hr));
|
|
if(hr == CONN_E_GK_NOT_REGISTERED)
|
|
{
|
|
WARNING_OUT(("COutgoingCall::Connect: not registered. Do you want to re-register..., hr=0x%lx", hr));
|
|
}
|
|
*ppConnection = NULL;
|
|
|
|
pConn->Release();
|
|
|
|
pOprahNCUI->ReleaseAV(pConn);
|
|
}
|
|
}
|
|
|
|
DebugExitULONG(CH323UI::Connect, hr);
|
|
|
|
return hr;
|
|
}
|
|
|
|
BOOL COutgoingCall::OnConferenceEnded()
|
|
{
|
|
DebugEntry(COutgoingCall::OnConferenceEnded);
|
|
|
|
BOOL bRet = FALSE;
|
|
|
|
switch (m_cnState)
|
|
{
|
|
case CNS_INVITING_REMOTE:
|
|
{
|
|
TRACE_OUT(("COutgoingCall (calling) rec. UNEXPECTED ConfEnded event"));
|
|
|
|
SetCallState(CNS_COMPLETE);
|
|
|
|
bRet = TRUE;
|
|
break;
|
|
}
|
|
|
|
case CNS_JOINING_REMOTE:
|
|
{
|
|
// JoinConference failed!
|
|
TRACE_OUT(("COutgoingCall (joining) received ConferenceEnded event"));
|
|
|
|
m_cnResult = CN_RC_CONFERENCE_JOIN_DENIED;
|
|
SetCallState(CNS_COMPLETE);
|
|
|
|
bRet = TRUE;
|
|
break;
|
|
}
|
|
|
|
case CNS_TERMINATING_AFTER_INVITE:
|
|
{
|
|
TRACE_OUT(("COutgoingCall (terminating after invite) received ConferenceEnded event"));
|
|
|
|
SetCallState(CNS_QUERYING_REMOTE_AFTER_INVITE);
|
|
|
|
ASSERT(g_pNodeController);
|
|
|
|
HRESULT hr = g_pNodeController->QueryRemote(this, m_pszAddr,
|
|
m_pConfObject->IsConfObjSecure(),
|
|
m_pConfObject->IsConferenceActive());
|
|
if (S_OK != hr)
|
|
{
|
|
m_cnResult = CN_RC_QUERY_FAILED;
|
|
SetCallState(CNS_COMPLETE);
|
|
}
|
|
|
|
bRet = TRUE;
|
|
break;
|
|
}
|
|
|
|
default:
|
|
{
|
|
WARNING_OUT(("COutgoingCall received unexpected ConfEnded event"));
|
|
}
|
|
}
|
|
|
|
DebugExitBOOL(COutgoingCall::OnConferenceEnded, bRet);
|
|
return bRet;
|
|
}
|
|
|
|
BOOL COutgoingCall::OnInviteResult(HRESULT ncsResult, UINT uNodeID)
|
|
{
|
|
DebugEntry(COutgoingCall::OnInviteResult);
|
|
|
|
BOOL bRet = TRUE;
|
|
|
|
ASSERT(CNS_INVITING_REMOTE == m_cnState);
|
|
|
|
TRACE_OUT(("COutgoingCall (calling) received InviteResult event"));
|
|
|
|
// Clear the current request handle
|
|
m_hRequest = NULL;
|
|
|
|
if (0 == ncsResult)
|
|
{
|
|
SetCallState(CNS_COMPLETE);
|
|
if (m_pH323Connection)
|
|
{
|
|
m_pConfObject->OnT120Connected(m_pH323Connection, uNodeID);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (UI_RC_USER_REJECTED == ncsResult)
|
|
{
|
|
SetCallState(CNS_TERMINATING_AFTER_INVITE);
|
|
|
|
// Issue "soft" leave attempt (to allow auto-terminate)
|
|
ASSERT(m_pConfObject);
|
|
if (S_OK != m_pConfObject->LeaveConference(FALSE))
|
|
{
|
|
m_cnResult = CN_RC_CONFERENCE_INVITE_DENIED;
|
|
SetCallState(CNS_COMPLETE);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// make sure that we are not recieving this notification due to
|
|
// the conference going away
|
|
ASSERT(m_pConfObject);
|
|
if (CS_GOING_DOWN != m_pConfObject->GetT120State())
|
|
{
|
|
TRACE_OUT(("COutgoingCall - invite failed / couldn't connect -> leaving"));
|
|
|
|
m_cnResult = CN_RC_INVITE_FAILED;
|
|
SetCallState(CNS_COMPLETE);
|
|
|
|
// Issue "soft" leave attempt (to allow auto-terminate)
|
|
ASSERT(m_pConfObject);
|
|
m_pConfObject->LeaveConference(FALSE);
|
|
}
|
|
}
|
|
}
|
|
|
|
DebugExitBOOL(COutgoingCall::OnInviteResult, bRet);
|
|
return bRet;
|
|
}
|
|
|
|
BOOL COutgoingCall::OnQueryRemoteResult(HRESULT ncsResult,
|
|
BOOL fMCU,
|
|
PWSTR pwszConfNames[],
|
|
PT120PRODUCTVERSION pVersion,
|
|
PWSTR pwszConfDescriptors[])
|
|
{
|
|
DebugEntry(COutgoingCall::OnQueryRemoteResult);
|
|
|
|
ASSERT ((CNS_QUERYING_REMOTE == m_cnState) ||
|
|
(CNS_QUERYING_REMOTE_AFTER_INVITE == m_cnState));
|
|
ASSERT (NULL == m_bstrConfToJoin);
|
|
|
|
if (SUCCEEDED(ncsResult))
|
|
{
|
|
BOOL fRemoteInConf = FALSE;
|
|
if ((NULL != pwszConfNames) && (NULL != pwszConfNames[0]))
|
|
{
|
|
fRemoteInConf = TRUE;
|
|
}
|
|
|
|
m_fService = FALSE;
|
|
if (fRemoteInConf && (NULL != pwszConfDescriptors) && (NULL != pwszConfDescriptors[0]))
|
|
{
|
|
if (0 == UnicodeCompare(pwszConfDescriptors[0],RDS_CONFERENCE_DESCRIPTOR))
|
|
{
|
|
m_fService = TRUE;
|
|
}
|
|
}
|
|
|
|
if (m_pConfObject->IsConferenceActive())
|
|
{
|
|
if (fMCU)
|
|
{
|
|
TRACE_OUT(("COutgoingCall - QR ok, but is MCU -> complete"));
|
|
m_cnResult = CN_RC_CANT_INVITE_MCU;
|
|
}
|
|
else if (fRemoteInConf)
|
|
{
|
|
TRACE_OUT(("COutgoingCall - QR ok, but callee is in a conference"));
|
|
m_cnResult = CN_RC_INVITE_DENIED_REMOTE_IN_CONF;
|
|
}
|
|
else
|
|
{
|
|
if (CNS_QUERYING_REMOTE_AFTER_INVITE == m_cnState)
|
|
{
|
|
m_cnResult = CN_RC_CONFERENCE_INVITE_DENIED;
|
|
SetCallState(CNS_COMPLETE);
|
|
}
|
|
else
|
|
{
|
|
SetCallState(CNS_INVITING_REMOTE);
|
|
|
|
HRESULT hr = m_pConfObject->InviteConference(m_pszAddr, m_bstrUserString, &m_hRequest);
|
|
if (S_OK != hr)
|
|
{
|
|
// Failure while inviting:
|
|
m_cnResult = CN_RC_INVITE_FAILED;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (CN_RC_NOERROR != m_cnResult)
|
|
{
|
|
SetCallState(CNS_COMPLETE);
|
|
}
|
|
}
|
|
else if (fRemoteInConf || fMCU)
|
|
{
|
|
TRACE_OUT(("COutgoingCall - QR succeeded (>0 conf) -> joining"));
|
|
TRACE_OUT(("\tfMCU is %d", fMCU));
|
|
|
|
// There are remote conferences
|
|
HRESULT hr = E_FAIL; // Assume a failure
|
|
|
|
SetCallState(CNS_JOINING_REMOTE);
|
|
|
|
if (!fMCU && (NULL == pwszConfNames[1]))
|
|
{
|
|
// we're not calling an MCU and we have just one conference, so join it
|
|
m_bstrConfToJoin = SysAllocString(pwszConfNames[0]);
|
|
hr = m_pConfObject->JoinConference( m_bstrConfToJoin,
|
|
m_bstrPassword,
|
|
m_pszAddr,
|
|
m_bstrUserString);
|
|
}
|
|
else
|
|
{
|
|
ASSERT(NULL == m_bstrConfToJoin);
|
|
REMOTE_CONFERENCE remoteConf;
|
|
remoteConf.fMCU = fMCU;
|
|
remoteConf.pwszConfNames = pwszConfNames;
|
|
remoteConf.pbstrConfToJoin = &m_bstrConfToJoin;
|
|
|
|
// Ask the app which conference to join
|
|
NotifySink(&remoteConf, OnNotifyRemoteConference);
|
|
|
|
if (NULL != m_bstrConfToJoin)
|
|
{
|
|
hr = m_pConfObject->JoinConference( m_bstrConfToJoin,
|
|
m_bstrPassword,
|
|
m_pszAddr,
|
|
m_bstrUserString);
|
|
}
|
|
}
|
|
|
|
if (S_OK != hr)
|
|
{
|
|
// JoinConference failed!
|
|
m_cnResult = CN_RC_JOIN_FAILED;
|
|
SetCallState(CNS_COMPLETE);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (CNS_QUERYING_REMOTE_AFTER_INVITE == m_cnState)
|
|
{
|
|
m_cnResult = CN_RC_CONFERENCE_INVITE_DENIED;
|
|
SetCallState(CNS_COMPLETE);
|
|
}
|
|
else
|
|
{
|
|
// No conferences on remote machine, so create local:
|
|
TRACE_OUT(("COutgoingCall - QR succeeded (no conf)-> creating local"));
|
|
|
|
// Create local conf
|
|
ASSERT(m_pConfObject);
|
|
SetCallState(CNS_CREATING_LOCAL);
|
|
HRESULT hr = m_pConfObject->CreateConference();
|
|
|
|
if (S_OK != hr)
|
|
{
|
|
// CreateConference failed!
|
|
m_cnResult = CN_RC_CONFERENCE_CREATE_FAILED;
|
|
SetCallState(CNS_COMPLETE);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// The QueryRemote failed
|
|
switch( ncsResult )
|
|
{
|
|
case UI_RC_USER_REJECTED:
|
|
// The initial QueryRemote failed because GCC symmetry determined
|
|
// that the other node is calling someone, and it might be us
|
|
// See Bug 1886
|
|
TRACE_OUT(("COutgoingCall - QueryRemote rejected -> complete"));
|
|
m_cnResult = CN_RC_REMOTE_PLACING_CALL;
|
|
break;
|
|
case UI_RC_T120_REMOTE_REQUIRE_SECURITY:
|
|
m_cnResult = CN_RC_CONNECT_REMOTE_REQUIRE_SECURITY;
|
|
break;
|
|
case UI_RC_T120_SECURITY_FAILED:
|
|
m_cnResult = CN_RC_SECURITY_FAILED;
|
|
break;
|
|
case UI_RC_T120_REMOTE_NO_SECURITY:
|
|
m_cnResult = CN_RC_CONNECT_REMOTE_NO_SECURITY;
|
|
break;
|
|
case UI_RC_T120_REMOTE_DOWNLEVEL_SECURITY:
|
|
m_cnResult = CN_RC_CONNECT_REMOTE_DOWNLEVEL_SECURITY;
|
|
break;
|
|
case UI_RC_T120_AUTHENTICATION_FAILED:
|
|
m_cnResult = CN_RC_CONNECT_AUTHENTICATION_FAILED;
|
|
break;
|
|
default:
|
|
m_cnResult = CN_RC_CONNECT_FAILED;
|
|
break;
|
|
}
|
|
SetCallState(CNS_COMPLETE);
|
|
}
|
|
|
|
DebugExitBOOL(COutgoingCall::OnQueryRemoteResult, TRUE);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL COutgoingCall::OnConferenceStarted(CONF_HANDLE hNewConf, HRESULT ncsResult)
|
|
{
|
|
DebugEntry(COutgoingCall::OnConferenceStarted);
|
|
|
|
switch (m_cnState)
|
|
{
|
|
case CNS_CREATING_LOCAL:
|
|
{
|
|
TRACE_OUT(("COutgoingCall (inviting) received ConferenceStarted event"));
|
|
|
|
if (0 == ncsResult)
|
|
{
|
|
ASSERT(m_pConfObject);
|
|
ASSERT(NULL == m_hRequest);
|
|
|
|
SetCallState(CNS_INVITING_REMOTE);
|
|
|
|
HRESULT hr = m_pConfObject->InviteConference(m_pszAddr, m_bstrUserString, &m_hRequest);
|
|
if (S_OK != hr)
|
|
{
|
|
m_hRequest = NULL;
|
|
m_cnResult = CN_RC_INVITE_FAILED;
|
|
SetCallState(CNS_COMPLETE);
|
|
|
|
// Issue "soft" leave attempt (to allow auto-terminate)
|
|
ASSERT(m_pConfObject);
|
|
hr = m_pConfObject->LeaveConference(FALSE);
|
|
if (FAILED(hr))
|
|
{
|
|
WARNING_OUT(("Couldn't leave after failed invite"));
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
WARNING_OUT(("CreateConference (local) failed - need UI here!"));
|
|
m_cnResult = CN_RC_CONFERENCE_CREATE_FAILED;
|
|
SetCallState(CNS_COMPLETE);
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case CNS_JOINING_REMOTE:
|
|
{
|
|
TRACE_OUT(("COutgoingCall (joining) received ConferenceStarted event"));
|
|
|
|
if (0 == ncsResult)
|
|
{
|
|
SetCallState(CNS_COMPLETE);
|
|
if (m_pH323Connection)
|
|
{
|
|
UINT uNodeID = hNewConf->GetParentNodeID();
|
|
|
|
m_pConfObject->OnT120Connected(m_pH323Connection, uNodeID);
|
|
}
|
|
}
|
|
else if (UI_RC_INVALID_PASSWORD == ncsResult)
|
|
{
|
|
TRACE_OUT(("COutgoingCall - invalid password, prompt for password"));
|
|
|
|
BSTR bstrPassword = NULL;
|
|
REMOTE_PASSWORD remotePw;
|
|
remotePw.bstrConference = m_bstrConfToJoin;
|
|
remotePw.pbstrPassword = &bstrPassword;
|
|
if (NO_ERROR != hNewConf->GetCred(&remotePw.pbRemoteCred, &remotePw.cbRemoteCred))
|
|
{
|
|
remotePw.pbRemoteCred = NULL;
|
|
remotePw.cbRemoteCred = 0;
|
|
}
|
|
remotePw.fIsService = m_fService;
|
|
NotifySink(&remotePw, OnNotifyRemotePassword);
|
|
|
|
if (NULL != bstrPassword)
|
|
{
|
|
SysFreeString(m_bstrPassword);
|
|
m_bstrPassword = bstrPassword;
|
|
|
|
// reissue join with new password
|
|
ASSERT(m_pConfObject);
|
|
HRESULT ncs =
|
|
m_pConfObject->JoinConference( m_bstrConfToJoin,
|
|
m_bstrPassword,
|
|
m_pszAddr,
|
|
m_bstrUserString,
|
|
TRUE); // retry
|
|
|
|
if (0 != ncs)
|
|
{
|
|
// JoinConference failed!
|
|
m_cnResult = CN_RC_JOIN_FAILED;
|
|
SetCallState(CNS_COMPLETE);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// cancel from pw dlg
|
|
m_cnResult = CN_RC_INVALID_PASSWORD;
|
|
SetCallState(CNS_COMPLETE);
|
|
|
|
ASSERT(m_pConfObject);
|
|
HRESULT hr = m_pConfObject->LeaveConference(TRUE);
|
|
if (FAILED(hr))
|
|
{
|
|
ERROR_OUT(("Couldn't leave after cancelling pw join!"));
|
|
}
|
|
}
|
|
}
|
|
else if (UI_RC_UNKNOWN_CONFERENCE == ncsResult)
|
|
{
|
|
TRACE_OUT(("Join failed (conf does not exist) "
|
|
"- notifying user"));
|
|
|
|
// error while joining
|
|
m_cnResult = CN_RC_CONFERENCE_DOES_NOT_EXIST;
|
|
SetCallState(CNS_COMPLETE);
|
|
}
|
|
else
|
|
{
|
|
TRACE_OUT(("Join failed - notifying user"));
|
|
|
|
// error while joining
|
|
m_cnResult = CN_RC_CONFERENCE_JOIN_DENIED;
|
|
SetCallState(CNS_COMPLETE);
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
default:
|
|
{
|
|
if (m_pConfObject->GetConfHandle() == hNewConf)
|
|
{
|
|
WARNING_OUT(("COutgoingCall received unexpected ConferenceStarted event"));
|
|
}
|
|
else
|
|
{
|
|
TRACE_OUT(("COutgoingCall ignoring ConferenceStarted event - not our conf"));
|
|
}
|
|
}
|
|
}
|
|
|
|
DebugExitBOOL(COutgoingCall::OnConferenceStarted, TRUE);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL COutgoingCall::OnH323Connected(IH323Endpoint * pConnection)
|
|
{
|
|
DebugEntry(COutgoingCall::OnH323Connected);
|
|
|
|
BOOL bRet = TRUE;
|
|
|
|
ASSERT(m_pH323Connection == pConnection);
|
|
|
|
if (m_dwFlags & CRPCF_DATA)
|
|
{
|
|
PCC_VENDORINFO pLocalVendorInfo;
|
|
PCC_VENDORINFO pRemoteVendorInfo;
|
|
|
|
pConnection->GetVersionInfo(&pLocalVendorInfo, &pRemoteVendorInfo);
|
|
H323VERSION version = GetH323Version(pRemoteVendorInfo);
|
|
|
|
if (H323_NetMeeting20 == version)
|
|
{
|
|
if ((m_addrType != NM_ADDR_H323_GATEWAY) &&
|
|
(m_addrType != NM_ADDR_PSTN) &&
|
|
(m_addrType != NM_ADDR_ALIAS_ID) &&
|
|
(m_addrType != NM_ADDR_ALIAS_E164))
|
|
{
|
|
CNSTATUS cnResult = StartT120Call();
|
|
if (CN_RC_NOERROR != cnResult)
|
|
{
|
|
m_cnResult = cnResult;
|
|
SetCallState(CNS_COMPLETE);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SetCallState(CNS_COMPLETE);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// wait for results of T.120 open logical channel
|
|
TRACE_OUT(("COutgoingCall - H323Connected received -> waiting for T120 channel open"));
|
|
SetCallState(CNS_WAITING_T120_OPEN);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// no T120 for this call
|
|
TRACE_OUT(("COutgoingCall - our H323 call started -> complete"));
|
|
SetCallState(CNS_COMPLETE);
|
|
}
|
|
|
|
CConfObject *pco = ::GetConfObject();
|
|
if (NULL != pco)
|
|
{
|
|
// add member if we are calling with A/V
|
|
BOOL fAddMember = m_dwFlags & (CRPCF_AUDIO | CRPCF_VIDEO);
|
|
|
|
pco->OnH323Connected(pConnection, m_dwFlags, fAddMember, GUID_NULL);
|
|
}
|
|
|
|
DebugExitBOOL(COutgoingCall::OnH323Connected, bRet);
|
|
return bRet;
|
|
}
|
|
|
|
BOOL COutgoingCall::OnH323Disconnected(IH323Endpoint * pConnection)
|
|
{
|
|
DebugEntry(COutgoingCall::OnH323Disconnected);
|
|
|
|
BOOL bRet = TRUE;
|
|
|
|
ASSERT(m_pH323Connection == pConnection);
|
|
|
|
HRESULT hSummary = m_pH323Connection->GetSummaryCode();
|
|
// Check summary code for gatekeeper-caused disconnect
|
|
// Note: this applies only to MY gatekeeper, not the callee's gatekeeper
|
|
if(CUSTOM_FACILITY(hSummary) == FACILITY_GKIADMISSION)
|
|
{
|
|
DWORD dwRejectReason;
|
|
dwRejectReason = CUSTOM_FACILITY_CODE(hSummary);
|
|
|
|
// should the T.120 call be placed anyway?
|
|
switch (dwRejectReason)
|
|
{
|
|
case ARJ_CALLEE_NOT_REGISTERED:
|
|
m_cnResult = CN_RC_GK_CALLEE_NOT_REGISTERED;
|
|
break;
|
|
case ARJ_TIMEOUT:
|
|
m_cnResult = CN_RC_GK_TIMEOUT;
|
|
break;
|
|
case ARJ_INVALID_PERMISSION:
|
|
case ARJ_REQUEST_DENIED:
|
|
case ARJ_UNDEFINED:
|
|
case ARJ_CALLER_NOT_REGISTERED:
|
|
case ARJ_ROUTE_TO_GK:
|
|
case ARJ_INVALID_ENDPOINT_ID:
|
|
case ARJ_RESOURCE_UNAVAILABLE:
|
|
case ARJ_SECURTY_DENIAL:
|
|
case ARJ_QOS_CONTROL_NOT_SUPPORTED:
|
|
case ARJ_INCOMPLETE_ADDRESS:
|
|
default:
|
|
m_cnResult = CN_RC_GK_REJECTED;
|
|
break;
|
|
}
|
|
|
|
SetCallState(CNS_COMPLETE);
|
|
}
|
|
else if (CNS_CONNECTING_H323 == m_cnState)
|
|
{
|
|
// attempted an H.323 call without success.
|
|
|
|
TRACE_OUT(("COutgoingCall - our leading H323 call ended -> complete"));
|
|
|
|
// check for cases of remote refusing the call
|
|
switch (hSummary)
|
|
{
|
|
case CCR_REMOTE_DISCONNECT:
|
|
case CCR_REMOTE_REJECTED:
|
|
m_cnResult = CN_RC_CONFERENCE_INVITE_DENIED;
|
|
SetCallState(CNS_COMPLETE);
|
|
break;
|
|
case CCR_LOCAL_DISCONNECT:
|
|
// cancelled by user, do not report error
|
|
m_cnResult = CN_RC_LOCAL_CANCELED;
|
|
m_fCanceled = TRUE;
|
|
SetCallState(CNS_COMPLETE);
|
|
break;
|
|
case CCR_GK_NO_RESOURCES:
|
|
// callee's gatekeeper would not let callee answer
|
|
// do the same as CCR_REMOTE_REJECTED
|
|
// as a temporary measure !!!!
|
|
m_cnResult = CN_RC_CONFERENCE_INVITE_DENIED;
|
|
SetCallState(CNS_COMPLETE);
|
|
break;
|
|
case CCR_REMOTE_SECURITY_DENIED:
|
|
if (m_pConfObject->IsConfObjSecure())
|
|
{
|
|
m_cnResult = CN_RC_CONNECT_REMOTE_NO_SECURITY;
|
|
}
|
|
else
|
|
{
|
|
m_cnResult = CN_RC_CONNECT_REMOTE_REQUIRE_SECURITY;
|
|
}
|
|
SetCallState(CNS_COMPLETE);
|
|
break;
|
|
case CCR_REMOTE_BUSY:
|
|
if (m_pConfObject->IsConferenceActive())
|
|
{
|
|
m_cnResult = CN_RC_INVITE_DENIED_REMOTE_IN_CONF;
|
|
SetCallState(CNS_COMPLETE);
|
|
break;
|
|
}
|
|
// else fall through
|
|
|
|
default:
|
|
if ((m_dwFlags & CRPCF_DATA) &&
|
|
(m_addrType != NM_ADDR_H323_GATEWAY) &&
|
|
(m_addrType != NM_ADDR_PSTN) &&
|
|
(m_addrType != NM_ADDR_ALIAS_ID) &&
|
|
(m_addrType != NM_ADDR_ALIAS_E164))
|
|
{
|
|
// The endpoint is not there, not listening for H.323 calls, or is busy,
|
|
// and the address is a resolvable type (not an H.323 alias or E.164 number)
|
|
// go back into the T.120 call state path
|
|
CNSTATUS cnResult = StartT120Call();
|
|
if (CN_RC_NOERROR != cnResult)
|
|
{
|
|
m_cnResult = cnResult;
|
|
SetCallState(CNS_COMPLETE);
|
|
bRet = FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch (hSummary)
|
|
{
|
|
case CCR_REMOTE_BUSY:
|
|
m_cnResult = CN_RC_INVITE_DENIED_REMOTE_IN_CONF;
|
|
break;
|
|
case CCR_REMOTE_MEDIA_ERROR:
|
|
m_cnResult = CN_RC_AUDIO_IN_USE_REMOTE;
|
|
break;
|
|
case CCR_LOCAL_MEDIA_ERROR:
|
|
m_cnResult = CN_RC_AUDIO_IN_USE_LOCAL;
|
|
break;
|
|
case CCR_GK_NO_RESOURCES:
|
|
m_cnResult = CN_RC_GK_REJECTED;
|
|
break;
|
|
default:
|
|
m_cnResult = CN_RC_AUDIO_CONNECT_FAILED;
|
|
break;
|
|
}
|
|
SetCallState(CNS_COMPLETE);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
else if (CNS_WAITING_T120_OPEN == m_cnState)
|
|
{
|
|
TRACE_OUT(("COutgoingCall - OnH323Disconnected received -> call is canceled"));
|
|
m_cnResult = CN_RC_CONFERENCE_INVITE_DENIED;
|
|
SetCallState(CNS_COMPLETE);
|
|
}
|
|
else
|
|
{
|
|
TRACE_OUT(("COutgoingCall - OnH323Disconnected received -> canceling call"));
|
|
ASSERT(m_pConfObject);
|
|
|
|
if (NULL != m_hRequest)
|
|
{
|
|
REQUEST_HANDLE hRequest = m_hRequest;
|
|
m_hRequest = NULL;
|
|
m_pConfObject->CancelInvite(hRequest);
|
|
}
|
|
|
|
if (m_pConfObject->IsConferenceActive())
|
|
{
|
|
// Issue "soft" leave attempt (to allow auto-terminate)
|
|
m_pConfObject->LeaveConference(FALSE);
|
|
}
|
|
}
|
|
|
|
// the connection may have been released due to the LeaveConference above
|
|
// bug 3996
|
|
if (m_pH323Connection)
|
|
{
|
|
m_pH323Connection->Release();
|
|
m_pH323Connection = NULL;
|
|
}
|
|
|
|
DebugExitBOOL(COutgoingCall::OnH323Disconnected, bRet);
|
|
return bRet;
|
|
}
|
|
|
|
BOOL COutgoingCall::OnT120ChannelOpen(ICommChannel *pIChannel, DWORD dwStatus)
|
|
{
|
|
DebugEntry(COutgoingCall::OnT120ChannelOpen);
|
|
|
|
BOOL bRet = TRUE;
|
|
|
|
// sometimes we get an extra T120 channel open
|
|
// this is most likely due the master/slave anomolies that
|
|
// venkatg discovered.
|
|
if (CNS_WAITING_T120_OPEN == m_cnState)
|
|
{
|
|
switch(dwStatus)
|
|
{
|
|
case CHANNEL_OPEN:
|
|
{
|
|
// start the T.120 part of the call
|
|
// get the negotiated address
|
|
SOCKADDR_IN sin_T120;
|
|
HRESULT hr = pIChannel->GetRemoteAddress(&sin_T120);
|
|
delete m_pszAddr; // we won't be needing this anymore
|
|
|
|
TCHAR szAddress[256]; // allow plenty of room for conversion from numberic to string
|
|
wsprintf(szAddress, "%s:%d", inet_ntoa(sin_T120.sin_addr), ntohs(sin_T120.sin_port));
|
|
m_pszAddr = PszAlloc(szAddress);
|
|
|
|
CNSTATUS cnResult = StartT120Call();
|
|
if (CN_RC_NOERROR != cnResult)
|
|
{
|
|
m_cnResult = cnResult;
|
|
SetCallState(CNS_COMPLETE);
|
|
}
|
|
}
|
|
break;
|
|
case CHANNEL_CLOSED:
|
|
// if the T.120 channel is being closed
|
|
// the H.323 call is going down, so don't continue waiting for
|
|
// T.120 to connect!
|
|
m_cnResult = CN_RC_CONNECT_FAILED;
|
|
SetCallState(CNS_COMPLETE);
|
|
|
|
if (NULL != m_hRequest)
|
|
{
|
|
REQUEST_HANDLE hRequest = m_hRequest;
|
|
m_hRequest = NULL;
|
|
ASSERT(m_pConfObject);
|
|
m_pConfObject->CancelInvite(hRequest);
|
|
}
|
|
break;
|
|
|
|
case CHANNEL_NO_CAPABILITY:
|
|
case CHANNEL_REJECTED:
|
|
case CHANNEL_OPEN_ERROR:
|
|
default:
|
|
m_cnResult = CN_RC_CONNECT_FAILED;
|
|
SetCallState(CNS_COMPLETE);
|
|
break;
|
|
}
|
|
}
|
|
|
|
DebugExitBOOL(COutgoingCall::OnT120ChannelOpen, bRet);
|
|
return bRet;
|
|
}
|
|
|
|
|
|
void COutgoingCall::CallComplete()
|
|
{
|
|
DebugEntry(COutgoingCall::CallComplete);
|
|
|
|
// If this fails, we are being destructed unexpectedly
|
|
|
|
ASSERT( (m_cnState == CNS_IDLE) ||
|
|
(m_cnState == CNS_COMPLETE));
|
|
|
|
// The request handle should have been reset
|
|
ASSERT(NULL == m_hRequest);
|
|
|
|
// make sure that the H323 connection is released
|
|
if (m_pH323Connection)
|
|
{
|
|
if (!IsDataOnly() &&
|
|
((CN_RC_TRANSPORT_FAILURE == m_cnResult) ||
|
|
(CN_RC_QUERY_FAILED == m_cnResult) ||
|
|
(CN_RC_CONNECT_FAILED == m_cnResult)))
|
|
{
|
|
m_cnResult = CN_RC_NOERROR;
|
|
}
|
|
|
|
if (CN_RC_NOERROR != m_cnResult)
|
|
{
|
|
m_pH323Connection->Disconnect();
|
|
}
|
|
m_pH323Connection->Release();
|
|
m_pH323Connection = NULL;
|
|
}
|
|
|
|
if (!FCanceled() && (CN_RC_NOERROR != m_cnResult))
|
|
{
|
|
ReportError(m_cnResult);
|
|
}
|
|
|
|
NM_CALL_STATE state;
|
|
GetState(&state);
|
|
NotifySink((PVOID) state, OnNotifyCallStateChanged);
|
|
|
|
TRACE_OUT(("ConfNode destroying addr %s", m_pszAddr));
|
|
DebugExitVOID(COutgoingCall::CallComplete);
|
|
}
|
|
|
|
BOOL COutgoingCall::ReportError(CNSTATUS cns)
|
|
{
|
|
DebugEntry(COutgoingCall::ReportError);
|
|
TRACE_OUT(("CNSTATUS 0x%08x", cns));
|
|
|
|
NotifySink((PVOID)cns, OnNotifyCallError);
|
|
|
|
DebugExitBOOL(COutgoingCall::ReportError, TRUE);
|
|
return TRUE;
|
|
}
|
|
|
|
CNSTATUS COutgoingCall::StartT120Call()
|
|
{
|
|
DebugEntry(COutgoingCall::StartT120Call);
|
|
|
|
CNSTATUS cnResult = CN_RC_NOERROR;
|
|
|
|
if (NULL == m_bstrConfToJoin)
|
|
{
|
|
// conference name not specified
|
|
// need to start out with a QueryRemote
|
|
SetCallState(CNS_QUERYING_REMOTE);
|
|
|
|
ASSERT(g_pNodeController);
|
|
|
|
HRESULT hr = g_pNodeController->QueryRemote(this, m_pszAddr,
|
|
m_pConfObject->IsConfObjSecure(),
|
|
m_pConfObject->IsConferenceActive());
|
|
if (S_OK != hr)
|
|
{
|
|
cnResult = CN_RC_QUERY_FAILED;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ASSERT(m_pConfObject);
|
|
// conference name has been specified
|
|
// time to do a JoinConference
|
|
SetCallState(CNS_JOINING_REMOTE);
|
|
|
|
HRESULT hr = m_pConfObject->JoinConference( m_bstrConfToJoin,
|
|
m_bstrPassword,
|
|
m_pszAddr,
|
|
m_bstrUserString);
|
|
if (S_OK != hr)
|
|
{
|
|
cnResult = CN_RC_JOIN_FAILED;
|
|
}
|
|
}
|
|
|
|
DebugExitINT(COutgoingCall::StartT120Call, cnResult);
|
|
return cnResult;
|
|
}
|
|
|
|
|
|
VOID COutgoingCall::SetCallState(CNODESTATE cnState)
|
|
{
|
|
NM_CALL_STATE stateOld;
|
|
NM_CALL_STATE stateNew;
|
|
GetState(&stateOld);
|
|
|
|
m_cnState = cnState;
|
|
|
|
// completion state will be fired off later
|
|
if (CNS_COMPLETE != cnState)
|
|
{
|
|
GetState(&stateNew);
|
|
if (stateOld != stateNew)
|
|
{
|
|
NotifySink((PVOID) stateNew, OnNotifyCallStateChanged);
|
|
}
|
|
}
|
|
}
|
|
|
|
HRESULT COutgoingCall::_Cancel(BOOL fLeaving)
|
|
{
|
|
DebugEntry(COutgoingCall::Cancel);
|
|
|
|
BOOL fAbortT120 = (m_cnState != CNS_COMPLETE);
|
|
|
|
if (fAbortT120)
|
|
{
|
|
m_fCanceled = TRUE;
|
|
|
|
// Abort T.120 Call:
|
|
|
|
|
|
// Attempt to make this transition regardless of our
|
|
// current state:
|
|
SetCallState(CNS_COMPLETE);
|
|
|
|
ASSERT(m_pConfObject);
|
|
|
|
if (NULL != m_hRequest)
|
|
{
|
|
REQUEST_HANDLE hRequest = m_hRequest;
|
|
m_hRequest = NULL;
|
|
m_pConfObject->CancelInvite(hRequest);
|
|
}
|
|
|
|
if (!fLeaving && m_pConfObject->IsConferenceActive())
|
|
{
|
|
HRESULT hr = m_pConfObject->LeaveConference(FALSE);
|
|
if (FAILED(hr))
|
|
{
|
|
WARNING_OUT(("Couldn't leave after disconnecting"));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (NULL != m_pH323Connection)
|
|
{
|
|
m_fCanceled = TRUE;
|
|
|
|
// Abort H.323 Call:
|
|
m_pH323Connection->Disconnect();
|
|
}
|
|
|
|
DebugExitULONG(COutgoingCall::Abort, m_cnResult);
|
|
|
|
return CN_RC_NOERROR ? S_OK : E_FAIL;
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG) COutgoingCall::AddRef(void)
|
|
{
|
|
return RefCount::AddRef();
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG) COutgoingCall::Release(void)
|
|
{
|
|
return RefCount::Release();
|
|
}
|
|
|
|
HRESULT STDMETHODCALLTYPE COutgoingCall::QueryInterface(REFIID riid, PVOID *ppv)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
if ((riid == IID_INmCall) || (riid == IID_IUnknown))
|
|
{
|
|
*ppv = (INmCall *)this;
|
|
ApiDebugMsg(("COutgoingCall::QueryInterface()"));
|
|
}
|
|
else if (riid == IID_IConnectionPointContainer)
|
|
{
|
|
*ppv = (IConnectionPointContainer *) this;
|
|
ApiDebugMsg(("CNmCall::QueryInterface(): Returning IConnectionPointContainer."));
|
|
}
|
|
else
|
|
{
|
|
hr = E_NOINTERFACE;
|
|
*ppv = NULL;
|
|
ApiDebugMsg(("COutgoingCall::QueryInterface(): Called on unknown interface."));
|
|
}
|
|
|
|
if (S_OK == hr)
|
|
{
|
|
AddRef();
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT COutgoingCall::IsIncoming(void)
|
|
{
|
|
return S_FALSE;
|
|
}
|
|
|
|
HRESULT COutgoingCall::GetState(NM_CALL_STATE *pState)
|
|
{
|
|
HRESULT hr = E_POINTER;
|
|
|
|
if (NULL != pState)
|
|
{
|
|
if (FCanceled())
|
|
{
|
|
*pState = NM_CALL_CANCELED;
|
|
}
|
|
else
|
|
{
|
|
switch (m_cnState)
|
|
{
|
|
case CNS_IDLE:
|
|
*pState = NM_CALL_INIT;
|
|
break;
|
|
|
|
case CNS_SEARCHING:
|
|
*pState = NM_CALL_SEARCH;
|
|
break;
|
|
|
|
case CNS_CONNECTING_H323:
|
|
case CNS_WAITING_T120_OPEN:
|
|
case CNS_QUERYING_REMOTE:
|
|
case CNS_CREATING_LOCAL:
|
|
case CNS_INVITING_REMOTE:
|
|
case CNS_JOINING_REMOTE:
|
|
*pState = NM_CALL_WAIT;
|
|
break;
|
|
|
|
case CNS_COMPLETE:
|
|
switch (m_cnResult)
|
|
{
|
|
case CN_RC_NOERROR:
|
|
*pState = NM_CALL_ACCEPTED;
|
|
break;
|
|
case CN_RC_CONFERENCE_JOIN_DENIED:
|
|
case CN_RC_CONFERENCE_INVITE_DENIED:
|
|
case CN_RC_CONFERENCE_DOES_NOT_EXIST:
|
|
case CN_RC_AUDIO_CONNECT_FAILED:
|
|
case CN_RC_GK_CALLEE_NOT_REGISTERED:
|
|
case CN_RC_GK_TIMEOUT:
|
|
case CN_RC_GK_REJECTED:
|
|
case CN_RC_GK_NOT_REGISTERED:
|
|
case CN_RC_CONNECT_REMOTE_NO_SECURITY:
|
|
case CN_RC_CONNECT_REMOTE_DOWNLEVEL_SECURITY:
|
|
case CN_RC_CONNECT_REMOTE_REQUIRE_SECURITY:
|
|
case CN_RC_TRANSPORT_FAILURE:
|
|
case CN_RC_QUERY_FAILED:
|
|
case CN_RC_CONNECT_FAILED:
|
|
*pState = NM_CALL_REJECTED;
|
|
break;
|
|
|
|
case CN_RC_ALREADY_IN_CONFERENCE:
|
|
case CN_RC_CANT_INVITE_MCU:
|
|
case CN_RC_CANT_JOIN_ALREADY_IN_CALL:
|
|
case CN_RC_INVITE_DENIED_REMOTE_IN_CONF:
|
|
case CN_RC_REMOTE_PLACING_CALL:
|
|
case CN_RC_ALREADY_IN_CONFERENCE_MCU:
|
|
case CN_RC_INVALID_PASSWORD:
|
|
default:
|
|
*pState = NM_CALL_CANCELED;
|
|
break;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
*pState = NM_CALL_INVALID;
|
|
break;
|
|
}
|
|
}
|
|
|
|
hr = S_OK;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
HRESULT COutgoingCall::GetName(BSTR * pbstrName)
|
|
{
|
|
if (NULL == pbstrName)
|
|
return E_POINTER;
|
|
|
|
*pbstrName = SysAllocString(m_bstrName);
|
|
return (*pbstrName ? S_OK : E_FAIL);
|
|
}
|
|
|
|
|
|
HRESULT COutgoingCall::GetAddr(BSTR *pbstrAddr, NM_ADDR_TYPE *puType)
|
|
{
|
|
if ((NULL == pbstrAddr) || (NULL == puType))
|
|
return E_POINTER;
|
|
|
|
*pbstrAddr = SysAllocString(CUSTRING(m_pszAddr));
|
|
*puType = m_addrType;
|
|
|
|
return *pbstrAddr ? S_OK : E_FAIL;
|
|
}
|
|
|
|
HRESULT COutgoingCall::GetUserData(REFGUID rguid, BYTE **ppb, ULONG *pcb)
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
HRESULT COutgoingCall::GetConference(INmConference **ppConference)
|
|
{
|
|
HRESULT hr = E_POINTER;
|
|
|
|
if (NULL != ppConference)
|
|
{
|
|
*ppConference = m_pConfObject;
|
|
return S_OK;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT COutgoingCall::Accept(void)
|
|
{
|
|
return E_UNEXPECTED;
|
|
}
|
|
|
|
HRESULT COutgoingCall::Reject(void)
|
|
{
|
|
return E_UNEXPECTED;
|
|
}
|
|
|
|
HRESULT COutgoingCall::Cancel(void)
|
|
{
|
|
DebugEntry(COutgoingCall::Cancel);
|
|
|
|
AddRef(); // protect against Release() while processing
|
|
// disconnect related indications & callbacks
|
|
|
|
HRESULT hr = _Cancel(FALSE);
|
|
|
|
if (FIsComplete())
|
|
{
|
|
COprahNCUI *pOprahNCUI = COprahNCUI::GetInstance();
|
|
ASSERT(NULL !=pOprahNCUI);
|
|
pOprahNCUI->OnOutgoingCallCanceled(this);
|
|
}
|
|
|
|
DebugExitULONG(COutgoingCall::Abort, m_cnResult);
|
|
|
|
Release();
|
|
|
|
return hr;
|
|
}
|
|
|
|
/* O N N O T I F Y C A L L E R R O R */
|
|
/*-------------------------------------------------------------------------
|
|
%%Function: OnNotifyCallError
|
|
|
|
-------------------------------------------------------------------------*/
|
|
HRESULT OnNotifyCallError(IUnknown *pCallNotify, PVOID pv, REFIID riid)
|
|
{
|
|
ASSERT(NULL != pCallNotify);
|
|
CNSTATUS cnStatus = (CNSTATUS)((DWORD_PTR)pv);
|
|
switch (cnStatus)
|
|
{
|
|
case CN_RC_ALREADY_IN_CONFERENCE:
|
|
case CN_RC_CANT_INVITE_MCU:
|
|
case CN_RC_CANT_JOIN_ALREADY_IN_CALL:
|
|
case CN_RC_INVITE_DENIED_REMOTE_IN_CONF:
|
|
case CN_RC_REMOTE_PLACING_CALL:
|
|
case CN_RC_ALREADY_IN_CONFERENCE_MCU:
|
|
((INmCallNotify*)pCallNotify)->NmUI(CONFN_CALL_IN_CONFERENCE);
|
|
break;
|
|
case CN_RC_CONFERENCE_JOIN_DENIED:
|
|
case CN_RC_CONFERENCE_INVITE_DENIED:
|
|
case CN_RC_CONFERENCE_DOES_NOT_EXIST:
|
|
case CN_RC_GK_CALLEE_NOT_REGISTERED:
|
|
case CN_RC_GK_TIMEOUT:
|
|
case CN_RC_GK_REJECTED:
|
|
case CN_RC_GK_NOT_REGISTERED:
|
|
case CN_RC_CONNECT_REMOTE_NO_SECURITY:
|
|
case CN_RC_CONNECT_REMOTE_DOWNLEVEL_SECURITY:
|
|
case CN_RC_CONNECT_REMOTE_REQUIRE_SECURITY:
|
|
((INmCallNotify*)pCallNotify)->NmUI(CONFN_CALL_IGNORED);
|
|
break;
|
|
case CN_RC_CONNECT_FAILED:
|
|
case CN_RC_AUDIO_CONNECT_FAILED:
|
|
((INmCallNotify*)pCallNotify)->NmUI(CONFN_CALL_FAILED);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (IID_INmCallNotify2 == riid)
|
|
{
|
|
((INmCallNotify2*)pCallNotify)->CallError(cnStatus);
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
/* O N N O T I F Y R E M O T E C O N F E R E N C E */
|
|
/*-------------------------------------------------------------------------
|
|
%%Function: OnNotifyRemoteConference
|
|
|
|
-------------------------------------------------------------------------*/
|
|
HRESULT OnNotifyRemoteConference(IUnknown *pCallNotify, PVOID pv, REFIID riid)
|
|
{
|
|
REMOTE_CONFERENCE *prc = (REMOTE_CONFERENCE *)pv;
|
|
|
|
// WARNING: pwszConfName is an PWSTR array, not a BSTR
|
|
|
|
ASSERT(NULL != pCallNotify);
|
|
((INmCallNotify2*)pCallNotify)->RemoteConference(prc->fMCU,
|
|
(BSTR *) prc->pwszConfNames, prc->pbstrConfToJoin);
|
|
return S_OK;
|
|
}
|
|
|
|
/* O N N O T I F Y R E M O T E P A S S W O R D */
|
|
/*-------------------------------------------------------------------------
|
|
%%Function: OnNotifyRemotePassword
|
|
|
|
-------------------------------------------------------------------------*/
|
|
HRESULT OnNotifyRemotePassword(IUnknown *pCallNotify, PVOID pv, REFIID riid)
|
|
{
|
|
REMOTE_PASSWORD *prp = (REMOTE_PASSWORD *)pv;
|
|
|
|
ASSERT(NULL != pCallNotify);
|
|
((INmCallNotify2*)pCallNotify)->RemotePassword(prp->bstrConference, prp->pbstrPassword, prp->pbRemoteCred, prp->cbRemoteCred, prp->fIsService);
|
|
return S_OK;
|
|
}
|
|
|
|
COutgoingCallManager::COutgoingCallManager()
|
|
{
|
|
}
|
|
|
|
COutgoingCallManager::~COutgoingCallManager()
|
|
{
|
|
// Empty the call list:
|
|
while (!m_CallList.IsEmpty())
|
|
{
|
|
COutgoingCall* pCall = (COutgoingCall*) m_CallList.RemoveHead();
|
|
// Shouldn't have any NULL entries:
|
|
ASSERT(pCall);
|
|
pCall->Release();
|
|
}
|
|
}
|
|
|
|
UINT COutgoingCallManager::GetCallCount()
|
|
{
|
|
UINT nNodes = 0;
|
|
POSITION pos = m_CallList.GetHeadPosition();
|
|
while (pos)
|
|
{
|
|
nNodes++;
|
|
m_CallList.GetNext(pos);
|
|
}
|
|
return nNodes;
|
|
}
|
|
|
|
COutgoingCall* COutgoingCallManager::FindCall(IH323Endpoint * lpConnection)
|
|
{
|
|
POSITION pos = m_CallList.GetHeadPosition();
|
|
while (pos)
|
|
{
|
|
COutgoingCall* pCall = (COutgoingCall*) m_CallList.GetNext(pos);
|
|
|
|
if ((NULL != pCall) &&
|
|
(pCall->GetH323Connection() == lpConnection))
|
|
{
|
|
return pCall;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
BOOL COutgoingCallManager::MatchActiveCallee(LPCTSTR pszDest, BSTR bstrAlias, BSTR bstrConference)
|
|
{
|
|
// Try to find a matching callee
|
|
POSITION pos = m_CallList.GetHeadPosition();
|
|
while (pos)
|
|
{
|
|
COutgoingCall* pCall = (COutgoingCall*) m_CallList.GetNext(pos);
|
|
|
|
if (NULL != pCall)
|
|
{
|
|
if (pCall->MatchActiveCallee(pszDest, bstrAlias, bstrConference))
|
|
{
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
HRESULT COutgoingCallManager::Call(
|
|
INmCall **ppCall,
|
|
COprahNCUI* pManager,
|
|
DWORD dwFlags,
|
|
NM_ADDR_TYPE addrType,
|
|
BSTR bstrName,
|
|
BSTR bstrSetup,
|
|
BSTR bstrDest,
|
|
BSTR bstrAlias,
|
|
BSTR bstrURL,
|
|
BSTR bstrConference,
|
|
BSTR bstrPassword,
|
|
BSTR bstrUserString)
|
|
{
|
|
DebugEntry(COutgoingCallManager::CallConference);
|
|
HRESULT hr = E_FAIL;
|
|
COutgoingCall* pCall = NULL;
|
|
CConfObject* pConfObject = pManager->GetConfObject();
|
|
|
|
if (NULL != ppCall)
|
|
{
|
|
*ppCall = NULL;
|
|
}
|
|
|
|
if (MatchActiveCallee(CUSTRING(bstrDest), bstrAlias, bstrConference))
|
|
{
|
|
hr = NM_CALLERR_ALREADY_CALLING;
|
|
}
|
|
else if (pConfObject->IsConferenceActive() && (NULL != bstrConference))
|
|
{
|
|
hr= NM_CALLERR_IN_CONFERENCE;
|
|
}
|
|
else
|
|
{
|
|
if (!pConfObject->IsConferenceActive())
|
|
{
|
|
pConfObject->SetConfSecurity(0 != (CRPCF_SECURE & dwFlags));
|
|
}
|
|
|
|
//
|
|
// Check outgoing call settings
|
|
//
|
|
if (pConfObject->GetNumMembers() >= pConfObject->GetConfMaxParticipants())
|
|
{
|
|
ASSERT(pConfObject->GetNumMembers() == pConfObject->GetConfMaxParticipants());
|
|
WARNING_OUT(("Outgoing call denied, reached limit of participants"));
|
|
goto END_CALL;
|
|
}
|
|
|
|
if ((pConfObject->IsHosting() != S_OK) &&
|
|
!(pConfObject->GetConfAttendeePermissions() & NM_PERMIT_OUTGOINGCALLS))
|
|
{
|
|
WARNING_OUT(("Outgoing call denied, not permitted by meeting settings"));
|
|
goto END_CALL;
|
|
}
|
|
|
|
pCall = new COutgoingCall( pConfObject,
|
|
dwFlags,
|
|
addrType,
|
|
bstrName,
|
|
bstrDest,
|
|
bstrAlias,
|
|
bstrConference,
|
|
bstrPassword,
|
|
bstrUserString);
|
|
if (NULL != pCall)
|
|
{
|
|
m_CallList.AddTail(pCall);
|
|
|
|
if (NULL != ppCall)
|
|
{
|
|
pCall->AddRef();
|
|
|
|
// This MUST be set before OnNotifyCallCreated
|
|
*ppCall = pCall;
|
|
}
|
|
|
|
pCall->AddRef();
|
|
|
|
pManager->OnOutgoingCallCreated(pCall);
|
|
|
|
pCall->PlaceCall();
|
|
|
|
if (pCall->FIsComplete())
|
|
{
|
|
RemoveFromList(pCall);
|
|
}
|
|
|
|
pCall->Release();
|
|
|
|
// let the caller know that we successfully created the call
|
|
// any error will be reported asynchronously
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
|
|
END_CALL:
|
|
DebugExitHRESULT(COutgoingCallManager::CallConference, hr);
|
|
return hr;
|
|
}
|
|
|
|
BOOL COutgoingCallManager::RemoveFromList(COutgoingCall* pCall)
|
|
{
|
|
DebugEntry(COutgoingCallManager::RemoveFromList);
|
|
ASSERT(pCall);
|
|
BOOL bRet = FALSE;
|
|
|
|
POSITION pos = m_CallList.GetPosition(pCall);
|
|
if (NULL != pos)
|
|
{
|
|
m_CallList.RemoveAt(pos);
|
|
|
|
pCall->CallComplete();
|
|
pCall->Release();
|
|
|
|
bRet = TRUE;
|
|
}
|
|
else
|
|
{
|
|
WARNING_OUT(("COutgoingCallManager::RemoveFromList() could not match call"));
|
|
}
|
|
|
|
DebugExitBOOL(COutgoingCallManager::RemoveFromList, bRet);
|
|
return bRet;
|
|
}
|
|
|
|
BOOL COutgoingCallManager::OnH323Connected(IH323Endpoint* lpConnection)
|
|
{
|
|
DebugEntry(COutgoingCallManager::OnH323Connected);
|
|
|
|
BOOL fFound = FALSE;
|
|
|
|
COutgoingCall* pCall = FindCall(lpConnection);
|
|
if (pCall)
|
|
{
|
|
fFound = TRUE;
|
|
|
|
pCall->AddRef();
|
|
pCall->OnH323Connected(lpConnection);
|
|
if (pCall->FIsComplete())
|
|
{
|
|
RemoveFromList(pCall);
|
|
}
|
|
pCall->Release();
|
|
}
|
|
|
|
DebugExitBOOL(COutgoingCallManager::OnH323Connected, fFound);
|
|
|
|
return fFound;
|
|
}
|
|
|
|
|
|
BOOL COutgoingCallManager::OnH323Disconnected(IH323Endpoint * lpConnection)
|
|
{
|
|
DebugEntry(COutgoingCallManager::OnH323Disconnected);
|
|
|
|
BOOL fFound = FALSE;
|
|
|
|
COutgoingCall* pCall = FindCall(lpConnection);
|
|
if (pCall)
|
|
{
|
|
fFound = TRUE;
|
|
|
|
pCall->AddRef();
|
|
pCall->OnH323Disconnected(lpConnection);
|
|
if (pCall->FIsComplete())
|
|
{
|
|
RemoveFromList(pCall);
|
|
}
|
|
pCall->Release();
|
|
}
|
|
|
|
DebugExitBOOL(COutgoingCallManager::OnH323Disconnected, fFound);
|
|
|
|
return fFound;
|
|
}
|
|
|
|
VOID COutgoingCallManager::OnT120ChannelOpen(ICommChannel *pIChannel, IH323Endpoint * lpConnection, DWORD dwStatus)
|
|
{
|
|
DebugEntry(COutgoingCallManager::OnT120ChannelOpen);
|
|
|
|
COutgoingCall* pCall = FindCall(lpConnection);
|
|
if (pCall)
|
|
{
|
|
pCall->AddRef();
|
|
pCall->OnT120ChannelOpen(pIChannel, dwStatus);
|
|
if (pCall->FIsComplete())
|
|
{
|
|
RemoveFromList(pCall);
|
|
}
|
|
pCall->Release();
|
|
}
|
|
|
|
DebugExitVOID(COutgoingCallManager::OnT120ChannelOpen);
|
|
}
|
|
|
|
VOID COutgoingCallManager::OnConferenceStarted(CONF_HANDLE hConference, HRESULT hResult)
|
|
{
|
|
DebugEntry(COutgoingCallManager::OnConferenceStarted);
|
|
|
|
// Tell all ConfNode's that a conference has started
|
|
POSITION pos = m_CallList.GetHeadPosition();
|
|
while (pos)
|
|
{
|
|
COutgoingCall* pCall = (COutgoingCall*) m_CallList.GetNext(pos);
|
|
|
|
if (NULL != pCall)
|
|
{
|
|
pCall->AddRef();
|
|
pCall->OnConferenceStarted(hConference, hResult);
|
|
if (pCall->FIsComplete())
|
|
{
|
|
RemoveFromList(pCall);
|
|
}
|
|
pCall->Release();
|
|
}
|
|
}
|
|
|
|
DebugExitVOID(COutgoingCallManager::OnConferenceStarted);
|
|
}
|
|
|
|
VOID COutgoingCallManager::OnQueryRemoteResult(PVOID pvCallerContext,
|
|
HRESULT hResult,
|
|
BOOL fMCU,
|
|
PWSTR* ppwszConferenceNames,
|
|
PT120PRODUCTVERSION pVersion,
|
|
PWSTR* ppwszConfDescriptors)
|
|
{
|
|
DebugEntry(COutgoingCallManager::OnQueryRemoteResult);
|
|
|
|
POSITION pos = m_CallList.GetHeadPosition();
|
|
while (pos)
|
|
{
|
|
COutgoingCall* pCall = (COutgoingCall*) m_CallList.GetNext(pos);
|
|
|
|
// Notify the node that issued the query:
|
|
|
|
if ((COutgoingCall*) pvCallerContext == pCall)
|
|
{
|
|
pCall->AddRef();
|
|
pCall->OnQueryRemoteResult( hResult,
|
|
fMCU,
|
|
ppwszConferenceNames,
|
|
pVersion,
|
|
ppwszConfDescriptors);
|
|
if (pCall->FIsComplete())
|
|
{
|
|
RemoveFromList(pCall);
|
|
}
|
|
pCall->Release();
|
|
break;
|
|
}
|
|
}
|
|
|
|
DebugExitVOID(COutgoingCallManager::OnQueryRemoteResult);
|
|
}
|
|
|
|
VOID COutgoingCallManager::OnInviteResult( CONF_HANDLE hConference,
|
|
REQUEST_HANDLE hRequest,
|
|
UINT uNodeID,
|
|
HRESULT hResult,
|
|
PT120PRODUCTVERSION pVersion)
|
|
{
|
|
DebugEntry(COutgoingCallManager::OnInviteResult);
|
|
|
|
POSITION pos = m_CallList.GetHeadPosition();
|
|
while (pos)
|
|
{
|
|
COutgoingCall* pCall = (COutgoingCall*) m_CallList.GetNext(pos);
|
|
|
|
if ((NULL != pCall) &&
|
|
(pCall->GetCurrentRequestHandle() == hRequest))
|
|
{
|
|
pCall->AddRef();
|
|
pCall->OnInviteResult(hResult, uNodeID);
|
|
if (pCall->FIsComplete())
|
|
{
|
|
RemoveFromList(pCall);
|
|
}
|
|
pCall->Release();
|
|
break;
|
|
}
|
|
}
|
|
|
|
DebugExitVOID(COutgoingCallManager::OnInviteResult);
|
|
}
|
|
|
|
VOID COutgoingCallManager::OnConferenceEnded(CONF_HANDLE hConference)
|
|
{
|
|
DebugEntry(COutgoingCallManager::OnConferenceEnded);
|
|
|
|
// Tell all ConfNode's that a conference has started
|
|
POSITION pos = m_CallList.GetHeadPosition();
|
|
while (pos)
|
|
{
|
|
COutgoingCall* pCall = (COutgoingCall*) m_CallList.GetNext(pos);
|
|
|
|
if (NULL != pCall)
|
|
{
|
|
pCall->AddRef();
|
|
pCall->OnConferenceEnded();
|
|
if (pCall->FIsComplete())
|
|
{
|
|
RemoveFromList(pCall);
|
|
}
|
|
pCall->Release();
|
|
}
|
|
}
|
|
|
|
DebugExitVOID(COutgoingCallManager::OnConferenceEnded);
|
|
}
|
|
|
|
VOID COutgoingCallManager::CancelCalls()
|
|
{
|
|
DebugEntry(COutgoingCallManager::CancelCalls);
|
|
|
|
// Tell all ConfNode's that a conference has started
|
|
POSITION pos = m_CallList.GetHeadPosition();
|
|
while (pos)
|
|
{
|
|
COutgoingCall* pCall = (COutgoingCall*) m_CallList.GetNext(pos);
|
|
|
|
if (NULL != pCall)
|
|
{
|
|
pCall->AddRef();
|
|
pCall->_Cancel(TRUE);
|
|
if (pCall->FIsComplete())
|
|
{
|
|
RemoveFromList(pCall);
|
|
}
|
|
pCall->Release();
|
|
}
|
|
}
|
|
|
|
DebugExitVOID(COutgoingCallManager::CancelCalls);
|
|
}
|