You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1746 lines
53 KiB
1746 lines
53 KiB
#include "precomp.h"
|
|
#include "t120app.h"
|
|
|
|
|
|
BOOL InitAppletSDK(void)
|
|
{
|
|
CheckStructCompatible();
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
void CleanupAppletSDK(void)
|
|
{
|
|
}
|
|
|
|
|
|
void CALLBACK T120AppletSessionCallback
|
|
(
|
|
T120AppletSessionMsg *pMsg
|
|
)
|
|
{
|
|
CNmAppletSession *pSession = (CNmAppletSession *) pMsg->pSessionContext;
|
|
if (NULL != pSession)
|
|
{
|
|
pSession->T120Callback(pMsg);
|
|
}
|
|
}
|
|
|
|
|
|
void CALLBACK T120AppletCallback
|
|
(
|
|
T120AppletMsg *pMsg
|
|
)
|
|
{
|
|
CNmAppletObj *pApplet = (CNmAppletObj *) pMsg->pAppletContext;
|
|
if (NULL != pApplet)
|
|
{
|
|
pApplet->T120Callback(pMsg);
|
|
}
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////
|
|
//
|
|
// CNmAppletSession
|
|
//
|
|
|
|
CNmAppletSession::CNmAppletSession
|
|
(
|
|
CNmAppletObj *pApplet,
|
|
IT120AppletSession *pSession,
|
|
BOOL fAutoJoin
|
|
)
|
|
:
|
|
m_cRef(1),
|
|
m_pApplet(pApplet),
|
|
m_pT120SessReq(NULL),
|
|
m_pT120Session(pSession),
|
|
m_pNotify(NULL),
|
|
m_fAutoJoin(fAutoJoin)
|
|
{
|
|
m_pApplet->AddRef();
|
|
pSession->Advise(T120AppletSessionCallback, m_pApplet, this);
|
|
}
|
|
|
|
|
|
CNmAppletSession::~CNmAppletSession(void)
|
|
{
|
|
ASSERT(0 == m_cRef);
|
|
|
|
m_pApplet->Release();
|
|
|
|
if (NULL != m_pT120Session)
|
|
{
|
|
m_pT120Session->ReleaseInterface();
|
|
m_pT120Session = NULL;
|
|
}
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////
|
|
//
|
|
// IUnknown @ CNmAppletSession
|
|
//
|
|
|
|
HRESULT CNmAppletSession::QueryInterface
|
|
(
|
|
REFIID riid,
|
|
void **ppv
|
|
)
|
|
{
|
|
if (NULL != ppv)
|
|
{
|
|
*ppv = NULL;
|
|
|
|
if (riid == IID_IAppletSession || riid == IID_IUnknown)
|
|
{
|
|
*ppv = (IAppletSession *) this;
|
|
AddRef();
|
|
return S_OK;
|
|
}
|
|
|
|
return E_NOINTERFACE;
|
|
}
|
|
|
|
return E_POINTER;
|
|
}
|
|
|
|
|
|
ULONG CNmAppletSession::AddRef(void)
|
|
{
|
|
::InterlockedIncrement(&m_cRef);
|
|
return (ULONG) m_cRef;
|
|
}
|
|
|
|
|
|
ULONG CNmAppletSession::Release(void)
|
|
{
|
|
ASSERT(m_cRef > 0);
|
|
|
|
if (::InterlockedDecrement(&m_cRef) == 0)
|
|
{
|
|
delete this;
|
|
return 0;
|
|
}
|
|
|
|
return (ULONG) m_cRef;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////
|
|
//
|
|
// Basic Info @ CNmAppletSession
|
|
//
|
|
|
|
HRESULT CNmAppletSession::GetConfID
|
|
(
|
|
AppletConfID *pnConfID
|
|
)
|
|
{
|
|
if (NULL != m_pT120Session)
|
|
{
|
|
*pnConfID = m_pT120Session->GetConfID();
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
return APPLET_E_NO_SERVICE;
|
|
}
|
|
|
|
|
|
HRESULT CNmAppletSession::IsThisNodeTopProvider
|
|
(
|
|
BOOL *pfTopProvider
|
|
)
|
|
{
|
|
if (NULL != m_pT120Session)
|
|
{
|
|
*pfTopProvider = m_pT120Session->IsThisNodeTopProvider();
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
return APPLET_E_NO_SERVICE;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////
|
|
//
|
|
// Join Conference @ CNmAppletSession
|
|
//
|
|
|
|
HRESULT CNmAppletSession::Join
|
|
(
|
|
AppletSessionRequest *pRequest
|
|
)
|
|
{
|
|
if (NULL != m_pNotify)
|
|
{
|
|
if (NULL != m_pT120Session)
|
|
{
|
|
if (NULL == m_pT120SessReq)
|
|
{
|
|
m_pT120SessReq = ::AllocateJoinSessionRequest(pRequest);
|
|
if (NULL != m_pT120SessReq)
|
|
{
|
|
T120Error rc = m_pT120Session->Join(m_pT120SessReq);
|
|
ASSERT(T120_NO_ERROR == rc);
|
|
|
|
if (T120_NO_ERROR == rc)
|
|
{
|
|
return S_OK;
|
|
}
|
|
|
|
::FreeJoinSessionRequest(m_pT120SessReq);
|
|
m_pT120SessReq = NULL;
|
|
|
|
return APPLET_E_SERVICE_FAIL;
|
|
}
|
|
|
|
return APPLET_E_INVALID_JOIN_REQUEST;
|
|
}
|
|
|
|
return APPLET_E_ALREADY_JOIN;
|
|
}
|
|
|
|
return APPLET_E_NO_SERVICE;
|
|
|
|
}
|
|
return APPLET_E_NOT_ADVISED;
|
|
}
|
|
|
|
|
|
HRESULT CNmAppletSession::Leave(void)
|
|
{
|
|
if (NULL != m_pT120Session)
|
|
{
|
|
if (m_fAutoJoin)
|
|
{
|
|
m_pT120Session->Leave();
|
|
m_fAutoJoin = FALSE;
|
|
|
|
return S_OK;
|
|
}
|
|
else
|
|
if (NULL != m_pT120SessReq)
|
|
{
|
|
m_pT120Session->Leave();
|
|
|
|
::FreeJoinSessionRequest(m_pT120SessReq);
|
|
m_pT120SessReq = NULL;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
return APPLET_E_NOT_JOINED;
|
|
}
|
|
|
|
return APPLET_E_NO_SERVICE;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////
|
|
//
|
|
// Send Data @ CNmAppletSession
|
|
//
|
|
|
|
HRESULT CNmAppletSession::SendData
|
|
(
|
|
BOOL fUniformSend,
|
|
AppletChannelID nChannelID,
|
|
AppletPriority ePriority,
|
|
ULONG cbBufSize,
|
|
BYTE *pBuffer // size_is(cbBufSize)
|
|
)
|
|
{
|
|
if (NULL != m_pT120Session)
|
|
{
|
|
if (cbBufSize && NULL != pBuffer)
|
|
{
|
|
T120Error rc = m_pT120Session->SendData(
|
|
fUniformSend ? UNIFORM_SEND_DATA : NORMAL_SEND_DATA,
|
|
nChannelID,
|
|
ePriority,
|
|
pBuffer,
|
|
cbBufSize,
|
|
APP_ALLOCATION);
|
|
ASSERT(T120_NO_ERROR == rc);
|
|
|
|
return (T120_NO_ERROR == rc) ? S_OK : APPLET_E_SERVICE_FAIL;
|
|
}
|
|
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
return APPLET_E_NO_SERVICE;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////
|
|
//
|
|
// Invoke Applet @ CNmAppletSession
|
|
//
|
|
|
|
HRESULT CNmAppletSession::InvokeApplet
|
|
(
|
|
AppletRequestTag *pnReqTag,
|
|
AppletProtocolEntity *pAPE,
|
|
ULONG cNodes,
|
|
AppletNodeID aNodeIDs[] // size_is(cNodes)
|
|
)
|
|
{
|
|
if (NULL != m_pNotify)
|
|
{
|
|
if (NULL != m_pT120Session)
|
|
{
|
|
if (NULL != pAPE && NULL != pnReqTag)
|
|
{
|
|
// set up node list
|
|
GCCSimpleNodeList NodeList;
|
|
NodeList.cNodes = cNodes;
|
|
NodeList.aNodeIDs = aNodeIDs;
|
|
|
|
// set up ape list
|
|
GCCAppProtEntityList APEList;
|
|
APEList.cApes = 1;
|
|
APEList.apApes = (T120APE **) &pAPE;
|
|
|
|
T120Error rc = m_pT120Session->InvokeApplet(&APEList, &NodeList, pnReqTag);
|
|
ASSERT(T120_NO_ERROR == rc);
|
|
|
|
return (T120_NO_ERROR == rc) ? S_OK : APPLET_E_SERVICE_FAIL;
|
|
}
|
|
|
|
return E_POINTER;
|
|
}
|
|
|
|
return APPLET_E_NO_SERVICE;
|
|
}
|
|
|
|
return APPLET_E_NOT_ADVISED;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////
|
|
//
|
|
// Inquiry @ CNmAppletSession
|
|
//
|
|
|
|
HRESULT CNmAppletSession::InquireRoster
|
|
(
|
|
AppletSessionKey *pSessionKey
|
|
)
|
|
{
|
|
if (NULL != m_pNotify)
|
|
{
|
|
if (NULL != m_pT120Session)
|
|
{
|
|
T120Error rc = m_pT120Session->InquireRoster((T120SessionKey *) pSessionKey);
|
|
ASSERT(T120_NO_ERROR == rc);
|
|
|
|
return (T120_NO_ERROR == rc) ? S_OK : APPLET_E_SERVICE_FAIL;
|
|
}
|
|
|
|
return APPLET_E_NO_SERVICE;
|
|
}
|
|
|
|
return APPLET_E_NOT_ADVISED;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////
|
|
//
|
|
// Registry Services @ CNmAppletSession
|
|
//
|
|
|
|
HRESULT CNmAppletSession::RegistryRequest
|
|
(
|
|
AppletRegistryRequest *pRequest
|
|
)
|
|
{
|
|
if (NULL != m_pNotify)
|
|
{
|
|
if (NULL != m_pT120Session)
|
|
{
|
|
T120RegistryRequest reg_req;
|
|
::AppletRegistryRequestToT120One(pRequest, ®_req);
|
|
|
|
T120Error rc = m_pT120Session->RegistryRequest(®_req);
|
|
ASSERT(T120_NO_ERROR == rc);
|
|
|
|
return (T120_NO_ERROR == rc) ? S_OK : APPLET_E_SERVICE_FAIL;
|
|
}
|
|
|
|
return APPLET_E_NO_SERVICE;
|
|
}
|
|
|
|
return APPLET_E_NOT_ADVISED;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////
|
|
//
|
|
// Channel Services @ CNmAppletSession
|
|
//
|
|
|
|
HRESULT CNmAppletSession::ChannelRequest
|
|
(
|
|
AppletChannelRequest *pRequest
|
|
)
|
|
{
|
|
if (NULL != m_pNotify)
|
|
{
|
|
if (NULL != m_pT120Session)
|
|
{
|
|
T120Error rc = m_pT120Session->ChannelRequest((T120ChannelRequest *) pRequest);
|
|
ASSERT(T120_NO_ERROR == rc);
|
|
|
|
return (T120_NO_ERROR == rc) ? S_OK : APPLET_E_SERVICE_FAIL;
|
|
}
|
|
|
|
return APPLET_E_NO_SERVICE;
|
|
}
|
|
|
|
return APPLET_E_NOT_ADVISED;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////
|
|
//
|
|
// Token Services @ CNmAppletSession
|
|
//
|
|
|
|
HRESULT CNmAppletSession::TokenRequest
|
|
(
|
|
AppletTokenRequest *pRequest
|
|
)
|
|
{
|
|
if (NULL != m_pNotify)
|
|
{
|
|
if (NULL != m_pT120Session)
|
|
{
|
|
T120Error rc = m_pT120Session->TokenRequest((T120TokenRequest *) pRequest);
|
|
ASSERT(T120_NO_ERROR == rc);
|
|
|
|
return (T120_NO_ERROR == rc) ? S_OK : APPLET_E_SERVICE_FAIL;
|
|
}
|
|
|
|
return APPLET_E_NO_SERVICE;
|
|
}
|
|
|
|
return APPLET_E_NOT_ADVISED;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////
|
|
//
|
|
// Notification @ CNmAppletSession
|
|
//
|
|
|
|
HRESULT CNmAppletSession::Advise
|
|
(
|
|
IAppletSessionNotify *pNotify,
|
|
DWORD *pdwCookie
|
|
)
|
|
{
|
|
if (NULL != m_pT120Session)
|
|
{
|
|
if (NULL == m_pNotify)
|
|
{
|
|
if (NULL != pNotify && NULL != pdwCookie)
|
|
{
|
|
pNotify->AddRef();
|
|
m_pNotify = pNotify;
|
|
m_pSessionObj = this;
|
|
*pdwCookie = 1;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
return E_POINTER;
|
|
}
|
|
|
|
return APPLET_E_ALREADY_ADVISED;
|
|
}
|
|
|
|
return APPLET_E_NO_SERVICE;
|
|
}
|
|
|
|
|
|
HRESULT CNmAppletSession::UnAdvise
|
|
(
|
|
DWORD dwCookie
|
|
)
|
|
{
|
|
if (NULL != m_pT120Session)
|
|
{
|
|
if (NULL != m_pNotify)
|
|
{
|
|
if (dwCookie == 1 && m_pSessionObj == this)
|
|
{
|
|
m_pNotify->Release();
|
|
m_pNotify = NULL;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
return APPLET_E_INVALID_COOKIE;
|
|
}
|
|
|
|
return APPLET_E_NOT_ADVISED;
|
|
}
|
|
|
|
return APPLET_E_NO_SERVICE;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////
|
|
//
|
|
// T120 Applet Session Callback @ CNmAppletSession
|
|
//
|
|
|
|
void CNmAppletSession::T120Callback
|
|
(
|
|
T120AppletSessionMsg *pMsg
|
|
)
|
|
{
|
|
HRESULT hrNotify;
|
|
HRESULT hrResult;
|
|
IAppletSession *pAppletSession;
|
|
T120ChannelID *aChannelIDs;
|
|
AppletOctetString ostr;
|
|
AppletRegistryCommand eRegistryCommand;
|
|
AppletTokenCommand eTokenCommand;
|
|
AppletRegistryItem RegItem;
|
|
AppletRegistryItem *pRegItem;
|
|
AppletRegistryEntryOwner EntryOwner;
|
|
|
|
if (NULL != m_pNotify)
|
|
{
|
|
switch (pMsg->eMsgType)
|
|
{
|
|
//
|
|
// Join Session
|
|
//
|
|
case T120_JOIN_SESSION_CONFIRM:
|
|
hrResult = APPLET_E_SERVICE_FAIL;
|
|
pAppletSession = NULL;
|
|
aChannelIDs = NULL;
|
|
if (T120_RESULT_SUCCESSFUL == pMsg->JoinSessionConfirm.eResult &&
|
|
T120_NO_ERROR == pMsg->JoinSessionConfirm.eError)
|
|
{
|
|
hrResult = S_OK;
|
|
if (pMsg->JoinSessionConfirm.cResourceReqs)
|
|
{
|
|
aChannelIDs = new T120ChannelID[pMsg->JoinSessionConfirm.cResourceReqs];
|
|
if (NULL != aChannelIDs)
|
|
{
|
|
for (ULONG i = 0; i < pMsg->JoinSessionConfirm.cResourceReqs; i++)
|
|
{
|
|
aChannelIDs[i] = pMsg->JoinSessionConfirm.aResourceReqs[i].nChannelID;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ASSERT(NULL != aChannelIDs);
|
|
hrResult = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
}
|
|
if (S_OK == hrResult)
|
|
{
|
|
hrNotify = m_pNotify->JoinSessionConfirm(
|
|
hrResult,
|
|
pMsg->JoinSessionConfirm.uidMyself,
|
|
pMsg->JoinSessionConfirm.nidMyself,
|
|
pMsg->JoinSessionConfirm.sidMyself,
|
|
pMsg->JoinSessionConfirm.eidMyself,
|
|
pMsg->JoinSessionConfirm.cResourceReqs,
|
|
aChannelIDs);
|
|
ASSERT(SUCCEEDED(hrNotify));
|
|
}
|
|
else
|
|
{
|
|
hrNotify = m_pNotify->JoinSessionConfirm(hrResult, 0, 0, 0, 0, 0, NULL);
|
|
ASSERT(SUCCEEDED(hrNotify));
|
|
}
|
|
delete [] aChannelIDs;
|
|
break;
|
|
|
|
//
|
|
// Detach User
|
|
//
|
|
case MCS_DETACH_USER_INDICATION:
|
|
hrNotify = m_pNotify->LeaveSessionIndication(::GetAppletReason(pMsg->DetachUserInd.eReason),
|
|
pMsg->DetachUserInd.nUserID);
|
|
ASSERT(SUCCEEDED(hrNotify));
|
|
break;
|
|
|
|
//
|
|
// Send Data
|
|
//
|
|
case MCS_SEND_DATA_INDICATION:
|
|
case MCS_UNIFORM_SEND_DATA_INDICATION:
|
|
ostr.cbStrSize = pMsg->SendDataInd.user_data.length;
|
|
ostr.pbValue = pMsg->SendDataInd.user_data.value;
|
|
hrNotify = m_pNotify->SendDataIndication(MCS_UNIFORM_SEND_DATA_INDICATION == pMsg->eMsgType,
|
|
pMsg->SendDataInd.initiator,
|
|
pMsg->SendDataInd.channel_id,
|
|
(AppletPriority) pMsg->SendDataInd.data_priority,
|
|
ostr);
|
|
ASSERT(SUCCEEDED(hrNotify));
|
|
break;
|
|
|
|
//
|
|
// Roster
|
|
//
|
|
case GCC_APP_ROSTER_REPORT_INDICATION:
|
|
hrNotify = m_pNotify->RosterReportIndication((ULONG) pMsg->AppRosterReportInd.cRosters,
|
|
(AppletRoster **) pMsg->AppRosterReportInd.apAppRosters);
|
|
ASSERT(SUCCEEDED(hrNotify));
|
|
break;
|
|
|
|
case GCC_APP_ROSTER_INQUIRE_CONFIRM:
|
|
hrNotify = m_pNotify->InquireRosterConfirm(::GetHrResult(pMsg->AppRosterInquireConfirm.nResult),
|
|
(ULONG) pMsg->AppRosterInquireConfirm.cRosters,
|
|
(AppletRoster **) pMsg->AppRosterInquireConfirm.apAppRosters);
|
|
ASSERT(SUCCEEDED(hrNotify));
|
|
break;
|
|
|
|
//
|
|
// Applet Invoke
|
|
//
|
|
case GCC_APPLICATION_INVOKE_CONFIRM:
|
|
hrNotify = m_pNotify->InvokeAppletConfirm(pMsg->AppInvokeConfirm.nReqTag,
|
|
::GetHrResult(pMsg->AppInvokeConfirm.nResult));
|
|
ASSERT(SUCCEEDED(hrNotify));
|
|
break;
|
|
|
|
//
|
|
// Registry
|
|
//
|
|
case GCC_REGISTER_CHANNEL_CONFIRM:
|
|
eRegistryCommand = APPLET_REGISTER_CHANNEL;
|
|
RegistryCommon_1:
|
|
if (NULL != pMsg->RegistryConfirm.pRegItem)
|
|
{
|
|
pRegItem = (AppletRegistryItem *) pMsg->RegistryConfirm.pRegItem;
|
|
}
|
|
else
|
|
{
|
|
::ZeroMemory(&RegItem, sizeof(RegItem));
|
|
pRegItem = &RegItem;
|
|
}
|
|
hrNotify = m_pNotify->RegistryConfirm(eRegistryCommand,
|
|
::GetHrResult(pMsg->RegistryConfirm.nResult),
|
|
(AppletRegistryKey *) pMsg->RegistryConfirm.pRegKey,
|
|
pRegItem,
|
|
(AppletRegistryEntryOwner *) &pMsg->RegistryConfirm.EntryOwner,
|
|
pMsg->RegistryConfirm.eRights);
|
|
ASSERT(SUCCEEDED(hrNotify));
|
|
break;
|
|
|
|
case GCC_ASSIGN_TOKEN_CONFIRM:
|
|
eRegistryCommand = APPLET_ASSIGN_TOKEN;
|
|
goto RegistryCommon_1;
|
|
|
|
case GCC_SET_PARAMETER_CONFIRM:
|
|
eRegistryCommand = APPLET_SET_PARAMETER;
|
|
goto RegistryCommon_1;
|
|
|
|
case GCC_RETRIEVE_ENTRY_CONFIRM:
|
|
hrResult = ::GetHrResult(pMsg->RegistryConfirm.nResult);
|
|
if (GCC_RESULT_SUCCESSFUL == pMsg->RegistryConfirm.nResult)
|
|
{
|
|
if (NULL != pMsg->RegistryConfirm.pRegItem)
|
|
{
|
|
pRegItem = (AppletRegistryItem *) pMsg->RegistryConfirm.pRegItem;
|
|
}
|
|
else
|
|
{
|
|
::ZeroMemory(&RegItem, sizeof(RegItem));
|
|
pRegItem = &RegItem;
|
|
}
|
|
hrNotify = m_pNotify->RegistryConfirm(APPLET_RETRIEVE_ENTRY,
|
|
hrResult,
|
|
(AppletRegistryKey *) pMsg->RegistryConfirm.pRegKey,
|
|
pRegItem,
|
|
(AppletRegistryEntryOwner *) &pMsg->RegistryConfirm.EntryOwner,
|
|
pMsg->RegistryConfirm.eRights);
|
|
ASSERT(SUCCEEDED(hrNotify));
|
|
}
|
|
else
|
|
{
|
|
::ZeroMemory(&RegItem, sizeof(RegItem));
|
|
::ZeroMemory(&EntryOwner, sizeof(EntryOwner));
|
|
hrNotify = m_pNotify->RegistryConfirm(APPLET_RETRIEVE_ENTRY,
|
|
hrResult,
|
|
(AppletRegistryKey *) pMsg->RegistryConfirm.pRegKey,
|
|
&RegItem,
|
|
&EntryOwner,
|
|
APPLET_NO_MODIFICATION_RIGHTS_SPECIFIED);
|
|
ASSERT(SUCCEEDED(hrNotify));
|
|
}
|
|
break;
|
|
|
|
case GCC_DELETE_ENTRY_CONFIRM:
|
|
hrResult = ::GetHrResult(pMsg->RegistryConfirm.nResult);
|
|
if (GCC_RESULT_INDEX_ALREADY_OWNED == pMsg->RegistryConfirm.nResult)
|
|
{
|
|
if (NULL != pMsg->RegistryConfirm.pRegItem)
|
|
{
|
|
pRegItem = (AppletRegistryItem *) pMsg->RegistryConfirm.pRegItem;
|
|
}
|
|
else
|
|
{
|
|
::ZeroMemory(&RegItem, sizeof(RegItem));
|
|
pRegItem = &RegItem;
|
|
}
|
|
hrNotify = m_pNotify->RegistryConfirm(APPLET_DELETE_ENTRY,
|
|
hrResult,
|
|
(AppletRegistryKey *) pMsg->RegistryConfirm.pRegKey,
|
|
pRegItem,
|
|
(AppletRegistryEntryOwner *) &pMsg->RegistryConfirm.EntryOwner,
|
|
pMsg->RegistryConfirm.eRights);
|
|
ASSERT(SUCCEEDED(hrNotify));
|
|
}
|
|
else
|
|
{
|
|
::ZeroMemory(&RegItem, sizeof(RegItem));
|
|
::ZeroMemory(&EntryOwner, sizeof(EntryOwner));
|
|
hrNotify = m_pNotify->RegistryConfirm(APPLET_DELETE_ENTRY,
|
|
hrResult,
|
|
(AppletRegistryKey *) pMsg->RegistryConfirm.pRegKey,
|
|
&RegItem,
|
|
&EntryOwner,
|
|
APPLET_NO_MODIFICATION_RIGHTS_SPECIFIED);
|
|
ASSERT(SUCCEEDED(hrNotify));
|
|
}
|
|
break;
|
|
|
|
case GCC_ALLOCATE_HANDLE_CONFIRM:
|
|
hrNotify = m_pNotify->AllocateHandleConfirm(::GetHrResult(pMsg->RegAllocHandleConfirm.nResult),
|
|
pMsg->RegAllocHandleConfirm.nFirstHandle,
|
|
pMsg->RegAllocHandleConfirm.cHandles);
|
|
ASSERT(SUCCEEDED(hrNotify));
|
|
break;
|
|
|
|
//
|
|
// Channel
|
|
//
|
|
case MCS_CHANNEL_JOIN_CONFIRM:
|
|
hrNotify = m_pNotify->ChannelConfirm(APPLET_JOIN_CHANNEL,
|
|
::GetHrResult(pMsg->ChannelConfirm.eResult),
|
|
pMsg->ChannelConfirm.nChannelID);
|
|
ASSERT(SUCCEEDED(hrNotify));
|
|
break;
|
|
|
|
case MCS_CHANNEL_CONVENE_CONFIRM:
|
|
hrNotify = m_pNotify->ChannelConfirm(APPLET_CONVENE_CHANNEL,
|
|
::GetHrResult(pMsg->ChannelConfirm.eResult),
|
|
pMsg->ChannelConfirm.nChannelID);
|
|
ASSERT(SUCCEEDED(hrNotify));
|
|
break;
|
|
|
|
case MCS_CHANNEL_LEAVE_INDICATION:
|
|
hrNotify = m_pNotify->ChannelIndication(APPLET_LEAVE_CHANNEL,
|
|
pMsg->ChannelInd.nChannelID,
|
|
::GetAppletReason(pMsg->ChannelInd.eReason),
|
|
0);
|
|
ASSERT(SUCCEEDED(hrNotify));
|
|
break;
|
|
|
|
case MCS_CHANNEL_DISBAND_INDICATION:
|
|
hrNotify = m_pNotify->ChannelIndication(APPLET_DISBAND_CHANNEL,
|
|
pMsg->ChannelInd.nChannelID,
|
|
::GetAppletReason(pMsg->ChannelInd.eReason),
|
|
0);
|
|
ASSERT(SUCCEEDED(hrNotify));
|
|
break;
|
|
|
|
case MCS_CHANNEL_ADMIT_INDICATION:
|
|
hrNotify = m_pNotify->ChannelIndication(APPLET_ADMIT_CHANNEL,
|
|
pMsg->ChannelInd.nChannelID,
|
|
APPLET_R_UNSPECIFIED,
|
|
pMsg->ChannelInd.nManagerID);
|
|
ASSERT(SUCCEEDED(hrNotify));
|
|
break;
|
|
|
|
case MCS_CHANNEL_EXPEL_INDICATION:
|
|
hrNotify = m_pNotify->ChannelIndication(APPLET_EXPEL_CHANNEL,
|
|
pMsg->ChannelInd.nChannelID,
|
|
::GetAppletReason(pMsg->ChannelInd.eReason),
|
|
0);
|
|
ASSERT(SUCCEEDED(hrNotify));
|
|
break;
|
|
|
|
//
|
|
// Token
|
|
//
|
|
case MCS_TOKEN_GRAB_CONFIRM:
|
|
eTokenCommand = APPLET_GRAB_TOKEN;
|
|
Token_Common_1:
|
|
hrNotify = m_pNotify->TokenConfirm(eTokenCommand,
|
|
::GetHrResult(pMsg->TokenConfirm.eResult),
|
|
pMsg->TokenConfirm.nTokenID);
|
|
ASSERT(SUCCEEDED(hrNotify));
|
|
break;
|
|
|
|
case MCS_TOKEN_INHIBIT_CONFIRM:
|
|
eTokenCommand = APPLET_INHIBIT_TOKEN;
|
|
goto Token_Common_1;
|
|
|
|
case MCS_TOKEN_GIVE_CONFIRM:
|
|
eTokenCommand = APPLET_GIVE_TOKEN;
|
|
goto Token_Common_1;
|
|
|
|
case MCS_TOKEN_RELEASE_CONFIRM:
|
|
eTokenCommand = APPLET_RELEASE_TOKEN;
|
|
goto Token_Common_1;
|
|
|
|
case MCS_TOKEN_TEST_CONFIRM:
|
|
hrNotify = m_pNotify->TestTokenConfirm(pMsg->TokenConfirm.nTokenID,
|
|
pMsg->TokenConfirm.eTokenStatus);
|
|
ASSERT(SUCCEEDED(hrNotify));
|
|
break;
|
|
|
|
case MCS_TOKEN_GIVE_INDICATION:
|
|
hrNotify = m_pNotify->TokenIndication(APPLET_GIVE_TOKEN,
|
|
APPLET_R_UNSPECIFIED,
|
|
pMsg->TokenInd.nTokenID,
|
|
pMsg->TokenInd.nUserID);
|
|
ASSERT(SUCCEEDED(hrNotify));
|
|
break;
|
|
|
|
case MCS_TOKEN_PLEASE_INDICATION:
|
|
hrNotify = m_pNotify->TokenIndication(APPLET_PLEASE_TOKEN,
|
|
APPLET_R_UNSPECIFIED,
|
|
pMsg->TokenInd.nTokenID,
|
|
pMsg->TokenInd.nUserID);
|
|
ASSERT(SUCCEEDED(hrNotify));
|
|
break;
|
|
|
|
case MCS_TOKEN_RELEASE_INDICATION:
|
|
hrNotify = m_pNotify->TokenIndication(APPLET_RELEASE_TOKEN,
|
|
::GetAppletReason(pMsg->TokenInd.eReason),
|
|
pMsg->TokenInd.nTokenID,
|
|
0);
|
|
ASSERT(SUCCEEDED(hrNotify));
|
|
break;
|
|
} // switch
|
|
} // if
|
|
}
|
|
|
|
|
|
HRESULT GetHrResult(T120Result rc)
|
|
{
|
|
HRESULT hrResult;
|
|
switch (rc)
|
|
{
|
|
case T120_RESULT_SUCCESSFUL:
|
|
hrResult = S_OK;
|
|
break;
|
|
case GCC_RESULT_ENTRY_ALREADY_EXISTS:
|
|
hrResult = APPLET_E_ENTRY_ALREADY_EXISTS;
|
|
break;
|
|
case GCC_RESULT_ENTRY_DOES_NOT_EXIST:
|
|
hrResult = APPLET_E_ENTRY_DOES_NOT_EXIST;
|
|
break;
|
|
case GCC_RESULT_INDEX_ALREADY_OWNED:
|
|
hrResult = APPLET_E_NOT_OWNER;
|
|
break;
|
|
default:
|
|
hrResult = APPLET_E_SERVICE_FAIL;
|
|
break;
|
|
}
|
|
return hrResult;
|
|
}
|
|
|
|
|
|
AppletReason GetAppletReason(T120Reason rc)
|
|
{
|
|
AppletReason eAppletReason;
|
|
switch (rc)
|
|
{
|
|
case REASON_USER_REQUESTED:
|
|
eAppletReason = APPLET_R_USER_REJECTED;
|
|
break;
|
|
case REASON_DOMAIN_DISCONNECTED:
|
|
case REASON_PROVIDER_INITIATED:
|
|
eAppletReason = APPLET_R_CONFERENCE_GONE;
|
|
ERROR_OUT (("WHAT!!!"));
|
|
|
|
break;
|
|
case REASON_TOKEN_PURGED:
|
|
case REASON_CHANNEL_PURGED:
|
|
eAppletReason = APPLET_R_RESOURCE_PURGED;
|
|
break;
|
|
default:
|
|
eAppletReason = APPLET_R_UNSPECIFIED;
|
|
break;
|
|
}
|
|
return eAppletReason;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////
|
|
//
|
|
// CNmAppletObj
|
|
//
|
|
|
|
CNmAppletObj::CNmAppletObj(void)
|
|
:
|
|
m_cRef(0),
|
|
m_pT120Applet(NULL),
|
|
m_pT120AutoJoinReq(NULL),
|
|
m_pNotify(NULL),
|
|
m_nPendingConfID(0)
|
|
{
|
|
}
|
|
|
|
|
|
CNmAppletObj::~CNmAppletObj(void)
|
|
{
|
|
ASSERT(0 == m_cRef);
|
|
|
|
if (NULL != m_pT120Applet)
|
|
{
|
|
m_pT120Applet->ReleaseInterface();
|
|
m_pT120Applet = NULL;
|
|
}
|
|
|
|
::FreeJoinSessionRequest(m_pT120AutoJoinReq);
|
|
}
|
|
|
|
|
|
HRESULT CNmAppletObj::Initialize(void)
|
|
{
|
|
T120Error rc = ::T120_CreateAppletSAP(&m_pT120Applet);
|
|
if (T120_NO_ERROR == rc)
|
|
{
|
|
m_pT120Applet->Advise(T120AppletCallback, this);
|
|
return S_OK;
|
|
}
|
|
|
|
return APPLET_E_NO_SERVICE;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////
|
|
//
|
|
// Auto Join @ CNmAppletObj
|
|
//
|
|
|
|
HRESULT CNmAppletObj::RegisterAutoJoin
|
|
(
|
|
AppletSessionRequest *pRequest
|
|
)
|
|
{
|
|
if (NULL != m_pNotify)
|
|
{
|
|
if (NULL != m_pT120Applet)
|
|
{
|
|
if (NULL != pRequest)
|
|
{
|
|
if (NULL == m_pT120AutoJoinReq)
|
|
{
|
|
m_pT120AutoJoinReq = ::AllocateJoinSessionRequest(pRequest);
|
|
if (NULL != m_pT120AutoJoinReq)
|
|
{
|
|
T120Error rc = m_pT120Applet->RegisterAutoJoin(m_pT120AutoJoinReq);
|
|
ASSERT(T120_NO_ERROR == rc);
|
|
|
|
if (T120_NO_ERROR == rc)
|
|
{
|
|
return S_OK;
|
|
}
|
|
|
|
::FreeJoinSessionRequest(m_pT120AutoJoinReq);
|
|
m_pT120AutoJoinReq = NULL;
|
|
|
|
return APPLET_E_SERVICE_FAIL;
|
|
}
|
|
|
|
return APPLET_E_INVALID_JOIN_REQUEST;
|
|
}
|
|
|
|
return APPLET_E_ALREADY_REGISTERED;
|
|
}
|
|
|
|
return E_POINTER;
|
|
}
|
|
|
|
return APPLET_E_NO_SERVICE;
|
|
}
|
|
|
|
return APPLET_E_NOT_ADVISED;
|
|
}
|
|
|
|
|
|
HRESULT CNmAppletObj::UnregisterAutoJoin(void)
|
|
{
|
|
if (NULL != m_pT120Applet)
|
|
{
|
|
if (NULL != m_pT120AutoJoinReq)
|
|
{
|
|
m_pT120Applet->UnregisterAutoJoin();
|
|
|
|
::FreeJoinSessionRequest(m_pT120AutoJoinReq);
|
|
m_pT120AutoJoinReq = NULL;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
return APPLET_E_NOT_REGISTERED;
|
|
}
|
|
|
|
return APPLET_E_NO_SERVICE;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////
|
|
//
|
|
// Session @ CNmAppletObj
|
|
//
|
|
|
|
HRESULT CNmAppletObj::CreateSession
|
|
(
|
|
IAppletSession **ppSession,
|
|
AppletConfID nConfID
|
|
)
|
|
{
|
|
if (NULL != m_pT120Applet)
|
|
{
|
|
if (NULL != ppSession)
|
|
{
|
|
*ppSession = NULL;
|
|
|
|
if (nConfID)
|
|
{
|
|
IT120AppletSession *pT120Session = NULL;
|
|
T120Error rc = m_pT120Applet->CreateSession(&pT120Session, nConfID);
|
|
if (T120_NO_ERROR == rc)
|
|
{
|
|
*ppSession = (IAppletSession *) new CNmAppletSession(this, pT120Session);
|
|
if (NULL != *ppSession)
|
|
{
|
|
return S_OK;
|
|
}
|
|
|
|
pT120Session->ReleaseInterface();
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
return APPLET_E_SERVICE_FAIL;
|
|
}
|
|
|
|
return APPLET_E_INVALID_CONFERENCE;
|
|
}
|
|
|
|
return E_POINTER;
|
|
}
|
|
|
|
return APPLET_E_NO_SERVICE;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////
|
|
//
|
|
// Notification @ CNmAppletObj
|
|
//
|
|
|
|
HRESULT CNmAppletObj::Advise
|
|
(
|
|
IAppletNotify *pNotify,
|
|
DWORD *pdwCookie
|
|
)
|
|
{
|
|
if (NULL != m_pT120Applet)
|
|
{
|
|
if (NULL == m_pNotify)
|
|
{
|
|
if (NULL != pNotify && NULL != pdwCookie)
|
|
{
|
|
pNotify->AddRef();
|
|
m_pNotify = pNotify;
|
|
m_pAppletObj = this;
|
|
*pdwCookie = 1;
|
|
|
|
if (m_nPendingConfID)
|
|
{
|
|
m_pNotify->PermitToJoinSessionIndication(m_nPendingConfID, TRUE);
|
|
m_nPendingConfID = 0;
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
return E_POINTER;
|
|
}
|
|
|
|
return APPLET_E_ALREADY_ADVISED;
|
|
}
|
|
|
|
return APPLET_E_NO_SERVICE;
|
|
}
|
|
|
|
|
|
HRESULT CNmAppletObj::UnAdvise
|
|
(
|
|
DWORD dwCookie
|
|
)
|
|
{
|
|
if (NULL != m_pT120Applet)
|
|
{
|
|
if (NULL != m_pNotify)
|
|
{
|
|
if (dwCookie == 1 && m_pAppletObj == this)
|
|
{
|
|
m_pNotify->Release();
|
|
m_pNotify = NULL;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
return APPLET_E_INVALID_COOKIE;
|
|
}
|
|
|
|
return APPLET_E_NOT_ADVISED;
|
|
}
|
|
|
|
return APPLET_E_NO_SERVICE;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////
|
|
//
|
|
// T120 Applet @ CNmAppletObj
|
|
//
|
|
|
|
void CNmAppletObj::T120Callback
|
|
(
|
|
T120AppletMsg *pMsg
|
|
)
|
|
{
|
|
HRESULT hrNotify;
|
|
HRESULT hrResult;
|
|
IAppletSession *pAppletSession;
|
|
T120ChannelID *aChannelIDs;
|
|
|
|
if (NULL != m_pNotify)
|
|
{
|
|
switch (pMsg->eMsgType)
|
|
{
|
|
case GCC_PERMIT_TO_ENROLL_INDICATION:
|
|
ASSERT(0 == m_nPendingConfID);
|
|
hrNotify = m_pNotify->PermitToJoinSessionIndication(
|
|
pMsg->PermitToEnrollInd.nConfID,
|
|
pMsg->PermitToEnrollInd.fPermissionGranted);
|
|
ASSERT(SUCCEEDED(hrNotify));
|
|
break;
|
|
case T120_JOIN_SESSION_CONFIRM:
|
|
hrResult = APPLET_E_SERVICE_FAIL;
|
|
pAppletSession = NULL;
|
|
aChannelIDs = NULL;
|
|
if (T120_RESULT_SUCCESSFUL == pMsg->AutoJoinSessionInd.eResult &&
|
|
T120_NO_ERROR == pMsg->AutoJoinSessionInd.eError)
|
|
{
|
|
hrResult = S_OK;
|
|
if (pMsg->AutoJoinSessionInd.cResourceReqs)
|
|
{
|
|
aChannelIDs = new T120ChannelID[pMsg->AutoJoinSessionInd.cResourceReqs];
|
|
if (NULL != aChannelIDs)
|
|
{
|
|
for (ULONG i = 0; i < pMsg->AutoJoinSessionInd.cResourceReqs; i++)
|
|
{
|
|
aChannelIDs[i] = pMsg->AutoJoinSessionInd.aResourceReqs[i].nChannelID;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ASSERT(NULL != aChannelIDs);
|
|
hrResult = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
|
|
if (S_OK == hrResult)
|
|
{
|
|
ASSERT(NULL != pMsg->AutoJoinSessionInd.pIAppletSession);
|
|
pAppletSession = new CNmAppletSession(this, pMsg->AutoJoinSessionInd.pIAppletSession, TRUE);
|
|
ASSERT(NULL != pAppletSession);
|
|
|
|
hrResult = (NULL != pAppletSession) ? S_OK : E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
|
|
if (S_OK == hrResult)
|
|
{
|
|
hrNotify = m_pNotify->AutoJoinSessionIndication(
|
|
pAppletSession,
|
|
hrResult,
|
|
pMsg->AutoJoinSessionInd.uidMyself,
|
|
pMsg->AutoJoinSessionInd.nidMyself,
|
|
pMsg->AutoJoinSessionInd.sidMyself,
|
|
pMsg->AutoJoinSessionInd.eidMyself,
|
|
pMsg->AutoJoinSessionInd.cResourceReqs,
|
|
aChannelIDs);
|
|
ASSERT(SUCCEEDED(hrNotify));
|
|
}
|
|
else
|
|
{
|
|
hrNotify = m_pNotify->AutoJoinSessionIndication(NULL, hrResult, 0, 0, 0, 0, 0, NULL);
|
|
ASSERT(SUCCEEDED(hrNotify));
|
|
|
|
if (NULL != pMsg->AutoJoinSessionInd.pIAppletSession)
|
|
{
|
|
pMsg->AutoJoinSessionInd.pIAppletSession->ReleaseInterface();
|
|
}
|
|
}
|
|
|
|
delete [] aChannelIDs;
|
|
break;
|
|
} // switch
|
|
}
|
|
else
|
|
{
|
|
// free memory for unwanted message
|
|
if (T120_JOIN_SESSION_CONFIRM == pMsg->eMsgType &&
|
|
T120_RESULT_SUCCESSFUL == pMsg->AutoJoinSessionInd.eResult &&
|
|
T120_NO_ERROR == pMsg->AutoJoinSessionInd.eError)
|
|
{
|
|
if (NULL != pMsg->AutoJoinSessionInd.pIAppletSession)
|
|
{
|
|
pMsg->AutoJoinSessionInd.pIAppletSession->ReleaseInterface();
|
|
}
|
|
}
|
|
else
|
|
if (GCC_PERMIT_TO_ENROLL_INDICATION == pMsg->eMsgType)
|
|
{
|
|
if (pMsg->PermitToEnrollInd.fPermissionGranted)
|
|
{
|
|
m_nPendingConfID = pMsg->PermitToEnrollInd.nConfID;
|
|
}
|
|
else
|
|
{
|
|
if (m_nPendingConfID == pMsg->PermitToEnrollInd.nConfID)
|
|
{
|
|
m_nPendingConfID = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////
|
|
//
|
|
// Join Session Request
|
|
//
|
|
|
|
T120JoinSessionRequest * AllocateJoinSessionRequest
|
|
(
|
|
AppletSessionRequest *pAppletRequest
|
|
)
|
|
{
|
|
T120JoinSessionRequest *pT120One = new T120JoinSessionRequest;
|
|
if (NULL != pT120One)
|
|
{
|
|
::ZeroMemory(pT120One, sizeof(*pT120One));
|
|
|
|
ULONG i;
|
|
|
|
pT120One->dwAttachmentFlags = ATTACHMENT_DISCONNECT_IN_DATA_LOSS;
|
|
|
|
if (! ::DuplicateSessionKey(&pT120One->SessionKey, (T120SessionKey *) &pAppletRequest->SessionKey))
|
|
{
|
|
goto MyError;
|
|
}
|
|
|
|
pT120One->fConductingCapable = FALSE;
|
|
|
|
pT120One->nStartupChannelType = pAppletRequest->nStartupChannelType;
|
|
|
|
if (::ConvertNonCollapsedCaps(&pT120One->apNonCollapsedCaps,
|
|
pAppletRequest->apNonCollapsedCaps,
|
|
pAppletRequest->cNonCollapsedCaps))
|
|
{
|
|
pT120One->cNonCollapsedCaps = pAppletRequest->cNonCollapsedCaps;
|
|
}
|
|
else
|
|
{
|
|
goto MyError;
|
|
}
|
|
|
|
if (::ConvertCollapsedCaps(&pT120One->apCollapsedCaps,
|
|
pAppletRequest->apCollapsedCaps,
|
|
pAppletRequest->cCollapsedCaps))
|
|
{
|
|
pT120One->cCollapsedCaps = pAppletRequest->cCollapsedCaps;
|
|
}
|
|
else
|
|
{
|
|
goto MyError;
|
|
}
|
|
|
|
if (0 != (pT120One->cStaticChannels = pAppletRequest->cStaticChannels))
|
|
{
|
|
pT120One->aStaticChannels = new T120ChannelID[pT120One->cStaticChannels];
|
|
if (NULL != pT120One->aStaticChannels)
|
|
{
|
|
::CopyMemory(pT120One->aStaticChannels,
|
|
pAppletRequest->aStaticChannels,
|
|
pT120One->cStaticChannels * sizeof(T120ChannelID));
|
|
}
|
|
else
|
|
{
|
|
goto MyError;
|
|
}
|
|
}
|
|
|
|
if (0 != (pT120One->cResourceReqs = pAppletRequest->cDynamicChannels))
|
|
{
|
|
if (NULL != (pT120One->aResourceReqs = new T120ResourceRequest[pT120One->cResourceReqs]))
|
|
{
|
|
::ZeroMemory(pT120One->aResourceReqs, pT120One->cResourceReqs * sizeof(T120ResourceRequest));
|
|
for (i = 0; i < pT120One->cResourceReqs; i++)
|
|
{
|
|
pT120One->aResourceReqs[i].eCommand = APPLET_JOIN_DYNAMIC_CHANNEL;
|
|
if (! ::DuplicateRegistryKey(&pT120One->aResourceReqs[i].RegKey,
|
|
(T120RegistryKey *) &pAppletRequest->aChannelRegistryKeys[i]))
|
|
{
|
|
goto MyError;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
goto MyError;
|
|
}
|
|
}
|
|
|
|
return pT120One;
|
|
}
|
|
|
|
MyError:
|
|
|
|
::FreeJoinSessionRequest(pT120One);
|
|
return NULL;
|
|
}
|
|
|
|
|
|
void FreeJoinSessionRequest
|
|
(
|
|
T120JoinSessionRequest *pT120One
|
|
)
|
|
{
|
|
if (NULL != pT120One)
|
|
{
|
|
::FreeSessionKey(&pT120One->SessionKey);
|
|
|
|
::FreeNonCollapsedCaps(pT120One->apNonCollapsedCaps, pT120One->cNonCollapsedCaps);
|
|
|
|
::FreeCollapsedCaps(pT120One->apCollapsedCaps, pT120One->cCollapsedCaps);
|
|
|
|
if (pT120One->cStaticChannels)
|
|
{
|
|
delete [] pT120One->aStaticChannels;
|
|
}
|
|
|
|
if (pT120One->cResourceReqs)
|
|
{
|
|
for (ULONG i = 0; i < pT120One->cResourceReqs; i++)
|
|
{
|
|
::FreeRegistryKey(&pT120One->aResourceReqs[i].RegKey);
|
|
}
|
|
delete [] pT120One->aResourceReqs;
|
|
}
|
|
|
|
delete pT120One;
|
|
}
|
|
}
|
|
|
|
|
|
BOOL ConvertCollapsedCaps(T120AppCap ***papDst, AppletCapability **apSrc, ULONG cItems)
|
|
{
|
|
if (cItems)
|
|
{
|
|
T120AppCap **arr_ptr;
|
|
ULONG cbTotalSize = cItems * (sizeof(T120AppCap*) + sizeof(T120AppCap));
|
|
if (NULL != (arr_ptr = (T120AppCap**) new BYTE[cbTotalSize]))
|
|
{
|
|
::ZeroMemory(arr_ptr, cbTotalSize);
|
|
T120AppCap *arr_obj = (T120AppCap *) (arr_ptr + cItems);
|
|
for (ULONG i = 0; i < cItems; i++)
|
|
{
|
|
arr_ptr[i] = &arr_obj[i];
|
|
if (! ::DuplicateCollapsedCap(arr_ptr[i], (T120AppCap *) apSrc[i]))
|
|
{
|
|
::FreeCollapsedCaps(arr_ptr, cItems);
|
|
return FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
*papDst = arr_ptr;
|
|
return (NULL != arr_ptr);
|
|
}
|
|
|
|
*papDst = NULL;
|
|
return TRUE;
|
|
}
|
|
|
|
void FreeCollapsedCaps(T120AppCap **apDst, ULONG cItems)
|
|
{
|
|
if (cItems && NULL != apDst)
|
|
{
|
|
T120AppCap **arr_ptr = apDst;
|
|
T120AppCap *arr_obj = (T120AppCap *) (arr_ptr + cItems);
|
|
for (ULONG i = 0; i < cItems; i++)
|
|
{
|
|
::FreeCollapsedCap(&arr_obj[i]);
|
|
}
|
|
delete [] (LPBYTE) arr_ptr;
|
|
}
|
|
}
|
|
|
|
|
|
BOOL DuplicateCollapsedCap(T120AppCap *pDst, T120AppCap *pSrc)
|
|
{
|
|
pDst->number_of_entities = pSrc->number_of_entities;
|
|
pDst->capability_class = pSrc->capability_class; // no memory allocation
|
|
return ::DuplicateCapID(&pDst->capability_id, &pSrc->capability_id);
|
|
}
|
|
|
|
void FreeCollapsedCap(T120AppCap *pDst)
|
|
{
|
|
::FreeCapID(&pDst->capability_id);
|
|
}
|
|
|
|
|
|
BOOL DuplicateCapID(T120CapID *pDst, T120CapID *pSrc)
|
|
{
|
|
pDst->capability_id_type = pSrc->capability_id_type;
|
|
switch (pDst->capability_id_type)
|
|
{
|
|
case GCC_STANDARD_CAPABILITY:
|
|
pDst->standard_capability = pSrc->standard_capability;
|
|
return TRUE;
|
|
case GCC_NON_STANDARD_CAPABILITY:
|
|
return ::DuplicateObjectKey(&pDst->non_standard_capability, &pSrc->non_standard_capability);
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
void FreeCapID(T120CapID *pDst)
|
|
{
|
|
switch (pDst->capability_id_type)
|
|
{
|
|
case GCC_NON_STANDARD_CAPABILITY:
|
|
::FreeObjectKey(&pDst->non_standard_capability);
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
BOOL ConvertNonCollapsedCaps(T120NonCollCap ***papDst, AppletCapability2 **apSrc, ULONG cItems)
|
|
{
|
|
if (cItems)
|
|
{
|
|
T120NonCollCap **arr_ptr;
|
|
ULONG cbTotalSize = cItems * (sizeof(T120NonCollCap*) + sizeof(T120NonCollCap));
|
|
if (NULL != (arr_ptr = (T120NonCollCap**) new BYTE[cbTotalSize]))
|
|
{
|
|
::ZeroMemory(arr_ptr, cbTotalSize);
|
|
T120NonCollCap *arr_obj = (T120NonCollCap *) (arr_ptr + cItems);
|
|
for (ULONG i = 0; i < cItems; i++)
|
|
{
|
|
arr_ptr[i] = &arr_obj[i];
|
|
if (! ::DuplicateNonCollapsedCap(arr_ptr[i], (T120NonCollCap *) apSrc[i]))
|
|
{
|
|
::FreeNonCollapsedCaps(arr_ptr, cItems);
|
|
return FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
*papDst = arr_ptr;
|
|
return (NULL != arr_ptr);
|
|
}
|
|
|
|
*papDst = NULL;
|
|
return TRUE;
|
|
}
|
|
|
|
void FreeNonCollapsedCaps(T120NonCollCap **apDst, ULONG cItems)
|
|
{
|
|
if (cItems && NULL != apDst)
|
|
{
|
|
T120NonCollCap **arr_ptr = apDst;
|
|
T120NonCollCap *arr_obj = (T120NonCollCap *) (arr_ptr + cItems);
|
|
for (ULONG i = 0; i < cItems; i++)
|
|
{
|
|
::FreeNonCollapsedCap(&arr_obj[i]);
|
|
}
|
|
delete [] (LPBYTE) arr_ptr;
|
|
}
|
|
}
|
|
|
|
|
|
BOOL DuplicateNonCollapsedCap(T120NonCollCap *pDst, T120NonCollCap *pSrc)
|
|
{
|
|
if (::DuplicateCapID(&pDst->capability_id, &pSrc->capability_id))
|
|
{
|
|
if (NULL == pSrc->application_data)
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
if (NULL != (pDst->application_data = new OSTR))
|
|
{
|
|
return ::DuplicateOSTR(pDst->application_data, pSrc->application_data);
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
void FreeNonCollapsedCap(T120NonCollCap *pDst)
|
|
{
|
|
::FreeCapID(&pDst->capability_id);
|
|
|
|
if (NULL != pDst->application_data)
|
|
{
|
|
::FreeOSTR(pDst->application_data);
|
|
delete pDst->application_data;
|
|
}
|
|
}
|
|
|
|
|
|
BOOL DuplicateRegistryKey(T120RegistryKey *pDst, T120RegistryKey *pSrc)
|
|
{
|
|
if (::DuplicateSessionKey(&pDst->session_key, &pSrc->session_key))
|
|
{
|
|
return ::DuplicateOSTR(&pDst->resource_id, &pSrc->resource_id);
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
void FreeRegistryKey(T120RegistryKey *pDst)
|
|
{
|
|
::FreeSessionKey(&pDst->session_key);
|
|
::FreeOSTR(&pDst->resource_id);
|
|
}
|
|
|
|
|
|
BOOL DuplicateSessionKey(T120SessionKey *pDst, T120SessionKey *pSrc)
|
|
{
|
|
pDst->session_id = pSrc->session_id;
|
|
return ::DuplicateObjectKey(&pDst->application_protocol_key, &pSrc->application_protocol_key);
|
|
}
|
|
|
|
void FreeSessionKey(T120SessionKey *pDst)
|
|
{
|
|
::FreeObjectKey(&pDst->application_protocol_key);
|
|
}
|
|
|
|
|
|
BOOL DuplicateObjectKey(T120ObjectKey *pDst, T120ObjectKey *pSrc)
|
|
{
|
|
pDst->key_type = pSrc->key_type;
|
|
switch (pDst->key_type)
|
|
{
|
|
case GCC_OBJECT_KEY:
|
|
pDst->object_id.long_string_length = pSrc->object_id.long_string_length;
|
|
if (pSrc->object_id.long_string_length && NULL != pSrc->object_id.long_string)
|
|
{
|
|
if (NULL != (pDst->object_id.long_string = new ULONG[pDst->object_id.long_string_length]))
|
|
{
|
|
::CopyMemory(pDst->object_id.long_string,
|
|
pSrc->object_id.long_string,
|
|
pDst->object_id.long_string_length * sizeof(ULONG));
|
|
return TRUE;
|
|
}
|
|
}
|
|
break;
|
|
case GCC_H221_NONSTANDARD_KEY:
|
|
return ::DuplicateOSTR(&pDst->h221_non_standard_id, &pSrc->h221_non_standard_id);
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
void FreeObjectKey(T120ObjectKey *pDst)
|
|
{
|
|
switch (pDst->key_type)
|
|
{
|
|
case GCC_OBJECT_KEY:
|
|
if (pDst->object_id.long_string_length)
|
|
{
|
|
delete [] pDst->object_id.long_string;
|
|
}
|
|
break;
|
|
case GCC_H221_NONSTANDARD_KEY:
|
|
::FreeOSTR(&pDst->h221_non_standard_id);
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
BOOL DuplicateOSTR(OSTR *pDst, OSTR *pSrc)
|
|
{
|
|
if (pSrc->length && NULL != pSrc->value)
|
|
{
|
|
pDst->length = pSrc->length;
|
|
if (NULL != (pDst->value = new BYTE[pDst->length]))
|
|
{
|
|
::CopyMemory(pDst->value, pSrc->value, pDst->length);
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
void FreeOSTR(OSTR *pDst)
|
|
{
|
|
if (pDst->length)
|
|
{
|
|
delete [] pDst->value;
|
|
}
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////
|
|
//
|
|
// Conversion
|
|
//
|
|
|
|
void AppletRegistryRequestToT120One
|
|
(
|
|
AppletRegistryRequest *pAppletRequest,
|
|
T120RegistryRequest *pT120One
|
|
)
|
|
{
|
|
pT120One->eCommand = pAppletRequest->eCommand;
|
|
pT120One->pRegistryKey = (T120RegistryKey *) &pAppletRequest->RegistryKey;
|
|
switch (pT120One->eCommand)
|
|
{
|
|
case APPLET_REGISTER_CHANNEL:
|
|
pT120One->nChannelID = pAppletRequest->nChannelID;
|
|
break;
|
|
case APPLET_SET_PARAMETER:
|
|
pT120One->Param.postrValue = (OSTR *) &pAppletRequest->ostrParamValue;
|
|
pT120One->Param.eModifyRights = pAppletRequest->eParamModifyRights;
|
|
break;
|
|
case APPLET_ALLOCATE_HANDLE:
|
|
pT120One->cHandles = pAppletRequest->cHandles;
|
|
break;
|
|
case APPLET_RETRIEVE_ENTRY:
|
|
case APPLET_DELETE_ENTRY:
|
|
case APPLET_ASSIGN_TOKEN:
|
|
case APPLET_MONITOR:
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef _DEBUG
|
|
void CheckStructCompatible(void)
|
|
{
|
|
ASSERT(sizeof(AppletOctetString) == sizeof(OSTR));
|
|
ASSERT(FIELD_OFFSET(AppletOctetString, cbStrSize) == FIELD_OFFSET(OSTR, length));
|
|
ASSERT(FIELD_OFFSET(AppletOctetString, pbValue) == FIELD_OFFSET(OSTR, value));
|
|
|
|
ASSERT(sizeof(AppletLongString) == sizeof(T120LongString));
|
|
ASSERT(FIELD_OFFSET(AppletLongString, nStrLen) == FIELD_OFFSET(T120LongString, long_string_length));
|
|
ASSERT(FIELD_OFFSET(AppletLongString, pnValue) == FIELD_OFFSET(T120LongString, long_string));
|
|
|
|
ASSERT(sizeof(AppletObjectKey) == sizeof(T120ObjectKey));
|
|
ASSERT(FIELD_OFFSET(AppletObjectKey, eType) == FIELD_OFFSET(T120ObjectKey, key_type));
|
|
ASSERT(FIELD_OFFSET(AppletObjectKey, lstrObjectID) == FIELD_OFFSET(T120ObjectKey, object_id));
|
|
ASSERT(FIELD_OFFSET(AppletObjectKey, ostrH221NonStdID) == FIELD_OFFSET(T120ObjectKey, h221_non_standard_id));
|
|
|
|
ASSERT(sizeof(AppletSessionKey) == sizeof(T120SessionKey));
|
|
ASSERT(FIELD_OFFSET(AppletSessionKey, AppletProtocolKey) == FIELD_OFFSET(T120SessionKey, application_protocol_key));
|
|
ASSERT(FIELD_OFFSET(AppletSessionKey, nSessionID) == FIELD_OFFSET(T120SessionKey, session_id));
|
|
|
|
ASSERT(sizeof(AppletRegistryKey) == sizeof(T120RegistryKey));
|
|
ASSERT(FIELD_OFFSET(AppletRegistryKey, SessionKey) == FIELD_OFFSET(T120RegistryKey, session_key));
|
|
ASSERT(FIELD_OFFSET(AppletRegistryKey, ostrResourceID) == FIELD_OFFSET(T120RegistryKey, resource_id));
|
|
|
|
ASSERT(sizeof(AppletRegistryItem) == sizeof(T120RegistryItem));
|
|
ASSERT(FIELD_OFFSET(AppletRegistryItem, ItemType) == FIELD_OFFSET(T120RegistryItem, item_type));
|
|
ASSERT(FIELD_OFFSET(AppletRegistryItem, nChannelID) == FIELD_OFFSET(T120RegistryItem, channel_id));
|
|
ASSERT(FIELD_OFFSET(AppletRegistryItem, nTokenID) == FIELD_OFFSET(T120RegistryItem, token_id));
|
|
ASSERT(FIELD_OFFSET(AppletRegistryItem, ostrParamValue) == FIELD_OFFSET(T120RegistryItem, parameter));
|
|
|
|
ASSERT(sizeof(AppletRegistryEntryOwner) == sizeof(T120RegistryEntryOwner));
|
|
ASSERT(FIELD_OFFSET(AppletRegistryEntryOwner, fEntryOwned) == FIELD_OFFSET(T120RegistryEntryOwner, entry_is_owned));
|
|
ASSERT(FIELD_OFFSET(AppletRegistryEntryOwner, nOwnerNodeID) == FIELD_OFFSET(T120RegistryEntryOwner, owner_node_id));
|
|
ASSERT(FIELD_OFFSET(AppletRegistryEntryOwner, nOwnerEntityID) == FIELD_OFFSET(T120RegistryEntryOwner, owner_entity_id));
|
|
|
|
ASSERT(sizeof(AppletCapabilityID) == sizeof(T120CapID));
|
|
ASSERT(FIELD_OFFSET(AppletCapabilityID, eType) == FIELD_OFFSET(T120CapID, capability_id_type));
|
|
ASSERT(FIELD_OFFSET(AppletCapabilityID, nNonStdCap) == FIELD_OFFSET(T120CapID, non_standard_capability));
|
|
ASSERT(FIELD_OFFSET(AppletCapabilityID, nStdCap) == FIELD_OFFSET(T120CapID, standard_capability));
|
|
|
|
ASSERT(sizeof(AppletCapability) == sizeof(T120AppCap));
|
|
ASSERT(FIELD_OFFSET(AppletCapability, CapID) == FIELD_OFFSET(T120AppCap, capability_id));
|
|
ASSERT(FIELD_OFFSET(AppletCapability, CapClass) == FIELD_OFFSET(T120AppCap, capability_class));
|
|
ASSERT(FIELD_OFFSET(AppletCapability, cEntities) == FIELD_OFFSET(T120AppCap, number_of_entities));
|
|
|
|
ASSERT(sizeof(AppletCapability2) == sizeof(T120NonCollCap));
|
|
ASSERT(FIELD_OFFSET(AppletCapability2, CapID) == FIELD_OFFSET(T120NonCollCap, capability_id));
|
|
ASSERT(FIELD_OFFSET(AppletCapability2, pCapData) == FIELD_OFFSET(T120NonCollCap, application_data));
|
|
|
|
ASSERT(sizeof(AppletProtocolEntity) == sizeof(T120APE)); // array of structs vs array of pointers
|
|
ASSERT(FIELD_OFFSET(AppletProtocolEntity, SessionKey) == FIELD_OFFSET(T120APE, session_key));
|
|
ASSERT(FIELD_OFFSET(AppletProtocolEntity, eStartupChannelType) == FIELD_OFFSET(T120APE, startup_channel_type));
|
|
ASSERT(FIELD_OFFSET(AppletProtocolEntity, fMustBeInvoked) == FIELD_OFFSET(T120APE, must_be_invoked));
|
|
ASSERT(FIELD_OFFSET(AppletProtocolEntity, cExpectedCapabilities) == FIELD_OFFSET(T120APE, number_of_expected_capabilities));
|
|
ASSERT(FIELD_OFFSET(AppletProtocolEntity, apExpectedCapabilities) == FIELD_OFFSET(T120APE, expected_capabilities_list));
|
|
|
|
ASSERT(sizeof(AppletRecord) == sizeof(T120AppRecord)); // array of structs vs array of pointers
|
|
ASSERT(FIELD_OFFSET(AppletRecord, nNodeID) == FIELD_OFFSET(T120AppRecord, node_id));
|
|
ASSERT(FIELD_OFFSET(AppletRecord, nEntityID) == FIELD_OFFSET(T120AppRecord, entity_id));
|
|
ASSERT(FIELD_OFFSET(AppletRecord, fEnrolledActively) == FIELD_OFFSET(T120AppRecord, is_enrolled_actively));
|
|
ASSERT(FIELD_OFFSET(AppletRecord, fConductingCapable) == FIELD_OFFSET(T120AppRecord, is_conducting_capable));
|
|
ASSERT(FIELD_OFFSET(AppletRecord, eStartupChannelType) == FIELD_OFFSET(T120AppRecord, startup_channel_type));
|
|
ASSERT(FIELD_OFFSET(AppletRecord, nAppletUserID) == FIELD_OFFSET(T120AppRecord, application_user_id));
|
|
ASSERT(FIELD_OFFSET(AppletRecord, cCapabilities) == FIELD_OFFSET(T120AppRecord, number_of_non_collapsed_caps));
|
|
ASSERT(FIELD_OFFSET(AppletRecord, apCapabilities) == FIELD_OFFSET(T120AppRecord, non_collapsed_caps_list));
|
|
|
|
ASSERT(sizeof(AppletRoster) == sizeof(T120AppRoster)); // array of structs vs array of pointers
|
|
ASSERT(FIELD_OFFSET(AppletRoster, SessionKey) == FIELD_OFFSET(T120AppRoster, session_key));
|
|
ASSERT(FIELD_OFFSET(AppletRoster, fRosterChanged) == FIELD_OFFSET(T120AppRoster, application_roster_was_changed));
|
|
ASSERT(FIELD_OFFSET(AppletRoster, nInstanceNumber) == FIELD_OFFSET(T120AppRoster, instance_number));
|
|
ASSERT(FIELD_OFFSET(AppletRoster, fNodesAdded) == FIELD_OFFSET(T120AppRoster, nodes_were_added));
|
|
ASSERT(FIELD_OFFSET(AppletRoster, fNodesRemoved) == FIELD_OFFSET(T120AppRoster, nodes_were_removed));
|
|
ASSERT(FIELD_OFFSET(AppletRoster, fCapabilitiesChanged) == FIELD_OFFSET(T120AppRoster, capabilities_were_changed));
|
|
ASSERT(FIELD_OFFSET(AppletRoster, cRecords) == FIELD_OFFSET(T120AppRoster, number_of_records));
|
|
ASSERT(FIELD_OFFSET(AppletRoster, apAppletRecords) == FIELD_OFFSET(T120AppRoster, application_record_list));
|
|
ASSERT(FIELD_OFFSET(AppletRoster, cCapabilities) == FIELD_OFFSET(T120AppRoster, number_of_capabilities));
|
|
ASSERT(FIELD_OFFSET(AppletRoster, apCapabilities) == FIELD_OFFSET(T120AppRoster, capabilities_list));
|
|
|
|
|
|
ASSERT(sizeof(AppletChannelRequest) == sizeof(T120ChannelRequest));
|
|
ASSERT(FIELD_OFFSET(AppletChannelRequest, eCommand) == FIELD_OFFSET(T120ChannelRequest, eCommand));
|
|
ASSERT(FIELD_OFFSET(AppletChannelRequest, nChannelID) == FIELD_OFFSET(T120ChannelRequest, nChannelID));
|
|
ASSERT(FIELD_OFFSET(AppletChannelRequest, cUsers) == FIELD_OFFSET(T120ChannelRequest, cUsers));
|
|
ASSERT(FIELD_OFFSET(AppletChannelRequest, aUsers) == FIELD_OFFSET(T120ChannelRequest, aUsers));
|
|
|
|
ASSERT(sizeof(AppletTokenRequest) == sizeof(T120TokenRequest));
|
|
ASSERT(FIELD_OFFSET(AppletTokenRequest, eCommand) == FIELD_OFFSET(T120TokenRequest, eCommand));
|
|
ASSERT(FIELD_OFFSET(AppletTokenRequest, nTokenID) == FIELD_OFFSET(T120TokenRequest, nTokenID));
|
|
ASSERT(FIELD_OFFSET(AppletTokenRequest, uidGiveTo) == FIELD_OFFSET(T120TokenRequest, uidGiveTo));
|
|
ASSERT(FIELD_OFFSET(AppletTokenRequest, hrGiveResponse) == FIELD_OFFSET(T120TokenRequest, eGiveResponse));
|
|
}
|
|
#endif // _DEBUG
|
|
|
|
|
|
|