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.
1267 lines
35 KiB
1267 lines
35 KiB
/*++
|
|
|
|
Copyright (c) 1997-1999 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
agenthand.cpp
|
|
|
|
Abstract:
|
|
|
|
Implementation of the CAll centre interface for TAPI 3.0.
|
|
AgentHandler class
|
|
|
|
Author:
|
|
|
|
noela - 03/16/98
|
|
|
|
Notes:
|
|
|
|
optional-notes
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
|
|
#define UNICODE
|
|
#include "stdafx.h"
|
|
#include "lmcons.h"
|
|
|
|
extern CHashTable * gpAgentHandlerHashTable ;
|
|
|
|
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// ITAgentHandler
|
|
|
|
|
|
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
// Class : CAgentHandler
|
|
// Method : Initialize
|
|
//
|
|
//
|
|
//
|
|
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
STDMETHODIMP CAgentHandler::Initialize(PWSTR pszProxyName, GUID proxyGUID, CTAPI *tapiObj)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
|
|
LOG((TL_TRACE, "Initialize - enter" ));
|
|
|
|
m_GUID = proxyGUID;
|
|
m_tapiObj = tapiObj;
|
|
m_pAddressLine = NULL;
|
|
|
|
// copy the Name
|
|
if (pszProxyName != NULL)
|
|
{
|
|
m_szName = (PWSTR) ClientAlloc((lstrlenW(pszProxyName) + 1) * sizeof (WCHAR));
|
|
if (m_szName != NULL)
|
|
{
|
|
lstrcpyW(m_szName,pszProxyName);
|
|
}
|
|
else
|
|
{
|
|
LOG((TL_ERROR, "Initialize - Alloc m_szName failed" ));
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LOG((TL_ERROR, "Initialize - name is NULL" ));
|
|
m_szName = NULL;
|
|
}
|
|
|
|
// Initialize our hash tables
|
|
//
|
|
m_AgentSessionHashtable.Initialize(1);
|
|
m_QueueHashtable.Initialize(1);
|
|
|
|
|
|
LOG((TL_TRACE, hr, "Initialize - exit" ));
|
|
return hr;
|
|
}
|
|
|
|
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
// Class : CAgentHandler
|
|
// Method : AddAddress
|
|
//
|
|
//
|
|
//
|
|
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
void CAgentHandler::AddAddress(CAddress *pAddress)
|
|
{
|
|
|
|
LOG((TL_TRACE, "AddAddress - enter"));
|
|
|
|
|
|
//
|
|
// good address?
|
|
//
|
|
|
|
if (IsBadReadPtr(pAddress, sizeof(CAddress) ))
|
|
{
|
|
LOG((TL_ERROR, "AddAddress - bad address pointer"));
|
|
return;
|
|
}
|
|
|
|
|
|
//
|
|
// get ITAddress out of the CAddress pointer
|
|
//
|
|
|
|
ITAddress *pITAddress = dynamic_cast<ITAddress *>(pAddress);
|
|
|
|
if (NULL == pITAddress)
|
|
{
|
|
LOG((TL_ERROR, "AddAddress - pITAddress is NULL"));
|
|
return;
|
|
}
|
|
|
|
|
|
//
|
|
// log address' name
|
|
//
|
|
|
|
#if DBG
|
|
|
|
{
|
|
BSTR bstrName = NULL;
|
|
|
|
HRESULT hr = pITAddress->get_AddressName(&bstrName);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
LOG((TL_TRACE, "AddAddress - using address %ls ",bstrName));
|
|
SysFreeString( bstrName );
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
//
|
|
// first see if this ITAddress is in the array of my addresses
|
|
//
|
|
|
|
int nIndex = m_AddressArray.Find( pITAddress );
|
|
|
|
if (nIndex >= 0)
|
|
{
|
|
|
|
LOG((TL_TRACE,
|
|
"AddAddress - address already in the array. doing nothing"));
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
//
|
|
// add address to the array of managed addresses
|
|
//
|
|
|
|
BOOL bAddSuccess = m_AddressArray.Add( pITAddress );
|
|
|
|
|
|
//
|
|
// log a message if the object failed to be added to the array
|
|
//
|
|
|
|
if ( !bAddSuccess )
|
|
{
|
|
|
|
LOG((TL_ERROR,
|
|
"AddAddress - failed to add address to the array"));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
LOG((TL_TRACE, "AddAddress - exit"));
|
|
}
|
|
|
|
|
|
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
// Class : CAgentHandler
|
|
// Method : getHLine
|
|
//
|
|
//
|
|
//
|
|
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
HLINE CAgentHandler::getHLine()
|
|
{
|
|
CAddress * pAddress;
|
|
HLINE hLine = 0;
|
|
HRESULT hr = S_OK;
|
|
|
|
LOG((TL_TRACE, "getHLine - enter"));
|
|
|
|
if (m_pAddressLine != NULL)
|
|
{
|
|
hLine = m_pAddressLine->t3Line.hLine;
|
|
}
|
|
else
|
|
{
|
|
// If we don't have a line, find one
|
|
pAddress = dynamic_cast<CAddress *>(m_AddressArray[0]);
|
|
|
|
if ( NULL != pAddress )
|
|
{
|
|
|
|
#if DBG
|
|
{
|
|
BSTR bstrName;
|
|
|
|
((ITAddress *)(pAddress))->get_AddressName(&bstrName);
|
|
LOG((TL_INFO, "getHLine - using address %ls ",bstrName));
|
|
SysFreeString( bstrName );
|
|
}
|
|
#endif
|
|
|
|
hr = pAddress->FindOrOpenALine (LINEMEDIAMODE_INTERACTIVEVOICE, &m_pAddressLine);
|
|
|
|
if (SUCCEEDED(hr) )
|
|
{
|
|
hLine = m_pAddressLine->t3Line.hLine;
|
|
|
|
// We've got a line open to the proxy, so lets add it to the AH hash table
|
|
gpAgentHandlerHashTable->Lock();
|
|
gpAgentHandlerHashTable->Insert( (ULONG_PTR)hLine, (ULONG_PTR)this );
|
|
gpAgentHandlerHashTable->Unlock();
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
LOG((TL_TRACE,hr, "getHLine(%8x) - exit", hLine));
|
|
return hLine;
|
|
}
|
|
|
|
|
|
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
// Class : CAgentHandler
|
|
// Method : FinalRelease
|
|
//
|
|
//
|
|
//
|
|
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
void CAgentHandler::FinalRelease()
|
|
{
|
|
CAddress * pAddress;
|
|
|
|
LOG((TL_TRACE, "FinalRelease AgentHandler - %S", m_szName ));
|
|
|
|
if ( m_szName != NULL )
|
|
{
|
|
ClientFree(m_szName);
|
|
}
|
|
|
|
// If we have a line open close it
|
|
if (m_pAddressLine != NULL)
|
|
{
|
|
// We've got a line open to the proxy, so lets remove it from the AH hash table
|
|
gpAgentHandlerHashTable->Lock();
|
|
gpAgentHandlerHashTable->Remove( (ULONG_PTR)(m_pAddressLine->t3Line.hLine) );
|
|
gpAgentHandlerHashTable->Unlock();
|
|
|
|
// And then close it
|
|
pAddress = dynamic_cast<CAddress *>(m_AddressArray[0]);
|
|
|
|
if ( NULL != pAddress )
|
|
{
|
|
pAddress->MaybeCloseALine (&m_pAddressLine);
|
|
}
|
|
}
|
|
|
|
m_AddressArray.Shutdown();
|
|
m_GroupArray.Shutdown();
|
|
m_AgentArray.Shutdown();
|
|
|
|
// Shutdown our hash tables
|
|
//
|
|
m_AgentSessionHashtable.Shutdown();
|
|
m_QueueHashtable.Shutdown();
|
|
|
|
|
|
LOG((TL_TRACE, "FinalRelease AgentHandler - exit" ));
|
|
}
|
|
|
|
|
|
|
|
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
// Class : CAgentHandler
|
|
// Method : FindSessionObject
|
|
//
|
|
//
|
|
//
|
|
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
BOOL CAgentHandler::FindSessionObject(
|
|
HAGENTSESSION hAgentSession,
|
|
CAgentSession ** ppAgentSession
|
|
)
|
|
{
|
|
BOOL bResult = FALSE;
|
|
|
|
|
|
m_AgentSessionHashtable.Lock();
|
|
|
|
if ( SUCCEEDED(m_AgentSessionHashtable.Find( (ULONG_PTR)hAgentSession, (ULONG_PTR *)ppAgentSession )) )
|
|
{
|
|
bResult = TRUE;
|
|
}
|
|
else
|
|
{
|
|
bResult = FALSE;
|
|
}
|
|
|
|
m_AgentSessionHashtable.Unlock();
|
|
|
|
return bResult;
|
|
}
|
|
|
|
|
|
|
|
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
// Class : CAgentHandler
|
|
// Method : FindSessionObject
|
|
//
|
|
//
|
|
//
|
|
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
BOOL CAgentHandler::FindQueueObject(
|
|
DWORD dwQueueID,
|
|
CQueue ** ppQueue
|
|
)
|
|
{
|
|
BOOL bResult = FALSE;
|
|
|
|
|
|
m_QueueHashtable.Lock();
|
|
|
|
|
|
if ( SUCCEEDED(m_QueueHashtable.Find( (ULONG_PTR)dwQueueID, (ULONG_PTR *)ppQueue )) )
|
|
{
|
|
bResult = TRUE;
|
|
}
|
|
else
|
|
{
|
|
bResult = FALSE;
|
|
}
|
|
|
|
m_QueueHashtable.Unlock();
|
|
|
|
return bResult;
|
|
}
|
|
|
|
|
|
|
|
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
// Class : CAgentHandler
|
|
// Method : FindAgentObject
|
|
//
|
|
//
|
|
//
|
|
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
BOOL CAgentHandler::FindAgentObject(
|
|
HAGENT hAgent,
|
|
CAgent ** ppAgent
|
|
)
|
|
{
|
|
HRESULT hr = FALSE;
|
|
CAgent *pAgent;
|
|
int iCount;
|
|
|
|
LOG((TL_TRACE, "FindAgent %d", hAgent));
|
|
|
|
for ( iCount = 0; iCount < m_AgentArray.GetSize(); iCount++ )
|
|
{
|
|
pAgent = dynamic_cast<CComObject<CAgent>*>(m_AgentArray[iCount]);
|
|
if (pAgent !=NULL)
|
|
{
|
|
if (hAgent == pAgent->getHandle() )
|
|
{
|
|
// Found it
|
|
*ppAgent = pAgent;
|
|
hr = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
// Class : CACDGroup
|
|
// Method : UpdateAgentHandlerList
|
|
//
|
|
//
|
|
//
|
|
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
HRESULT CAgentHandler::UpdateGroupArray()
|
|
{
|
|
HRESULT hr = S_OK;
|
|
DWORD dwNumberOfEntries;
|
|
LPLINEAGENTGROUPLIST pGroupList = NULL;
|
|
LPLINEAGENTGROUPENTRY pGroupEntry = NULL;
|
|
PWSTR pszGroupName;
|
|
DWORD dwCount;
|
|
GUID * pGroupID;
|
|
BOOL foundIt;
|
|
CACDGroup * thisGroup = NULL;
|
|
int iCount;
|
|
|
|
|
|
LOG((TL_TRACE, "UpdateGroupArray - enter"));
|
|
|
|
|
|
// Call lineGetGroupList to get list of Groups
|
|
hr = LineGetGroupList( getHLine(), &pGroupList );
|
|
if( SUCCEEDED(hr) )
|
|
{
|
|
dwNumberOfEntries = pGroupList->dwNumEntries;
|
|
LOG((TL_INFO, "UpdateGroupArray - Number of entries: %d", dwNumberOfEntries));
|
|
if ( dwNumberOfEntries !=0 )
|
|
{
|
|
// Run through the new list from the Proxy &see if any new groups have appeared
|
|
// By Comparing IDs from the new list with those in TAPIs list
|
|
|
|
|
|
// Find position of 1st LINEAGENTGROUPEENTRY structure in the LINEAGENTGROUPLIST
|
|
pGroupEntry = (LPLINEAGENTGROUPENTRY) ((BYTE*)(pGroupList) + pGroupList->dwListOffset);
|
|
|
|
// Run though the received list
|
|
for (dwCount = 0; dwCount < dwNumberOfEntries; dwCount++)
|
|
{
|
|
pszGroupName= (PWSTR)( (PBYTE)pGroupList + pGroupEntry->dwNameOffset);
|
|
pGroupID = (GUID*)&pGroupEntry->GroupID;
|
|
|
|
#if DBG
|
|
{
|
|
WCHAR guidName[100];
|
|
|
|
StringFromGUID2(*pGroupID, (LPOLESTR)&guidName, 100);
|
|
LOG((TL_INFO, "UpdateGroupArray - Group Name : %S", pszGroupName));
|
|
LOG((TL_INFO, "UpdateGroupArray - Group GUID : %S", guidName));
|
|
}
|
|
#endif
|
|
|
|
// Run through the array of Groups & see if we already have this one in the list
|
|
// by comparing IDs
|
|
foundIt = FALSE;
|
|
Lock();
|
|
|
|
for (iCount = 0; iCount < m_GroupArray.GetSize(); iCount++)
|
|
{
|
|
thisGroup = dynamic_cast<CComObject<CACDGroup>*>(m_GroupArray[iCount]);
|
|
if (thisGroup != NULL)
|
|
{
|
|
if ( IsEqualGUID(*pGroupID, thisGroup->getID() ) )
|
|
{
|
|
foundIt = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
Unlock();
|
|
|
|
if (foundIt == FALSE)
|
|
{
|
|
// Didn't match so lets add this Group
|
|
LOG((TL_INFO, "UpdateGroupArray - create new Group"));
|
|
|
|
CComObject<CACDGroup> * pGroup;
|
|
hr = CComObject<CACDGroup>::CreateInstance( &pGroup );
|
|
if( SUCCEEDED(hr) )
|
|
{
|
|
ITACDGroup * pITGroup;
|
|
hr = pGroup->QueryInterface(IID_ITACDGroup, (void **)&pITGroup);
|
|
if ( SUCCEEDED(hr) )
|
|
{
|
|
// initialize the Group
|
|
hr = pGroup->Initialize(pszGroupName, *pGroupID, this);
|
|
if( SUCCEEDED(hr) )
|
|
{
|
|
|
|
LOG((TL_TRACE, "UpdateGroupArray - Initialize Group succeededed" ));
|
|
|
|
//
|
|
// add to Array of Groups
|
|
//
|
|
Lock();
|
|
m_GroupArray.Add(pITGroup);
|
|
Unlock();
|
|
pITGroup->Release();
|
|
|
|
LOG((TL_INFO, "UpdateGroupArray - Added Group to Array"));
|
|
|
|
}
|
|
else
|
|
{
|
|
LOG((TL_ERROR, "UpdateGroupArray - Initialize Group failed" ));
|
|
delete pGroup;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LOG((TL_ERROR, "UpdateGroupArray - QueryInterface failed" ));
|
|
delete pGroup;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LOG((TL_ERROR, "UpdateGroupArray - Create Group failed" ));
|
|
}
|
|
}
|
|
else // foundIt == TRUE
|
|
{
|
|
LOG((TL_INFO, "UpdateGroupArray - Group Object exists for this entry" ));
|
|
// Just in case is was previously inactive
|
|
thisGroup->SetActive();
|
|
|
|
}
|
|
|
|
// next entry in list
|
|
pGroupEntry ++;
|
|
} //for(dwCount = 0......)
|
|
|
|
|
|
|
|
|
|
// Run through the list of Groups & see if any groups have been removed by the Proxy
|
|
// By comparing IDs of those in TAPIs list with the new list from the Proxy
|
|
for (iCount = 0; iCount < m_GroupArray.GetSize(); iCount++)
|
|
{
|
|
thisGroup = dynamic_cast<CComObject<CACDGroup>*>( m_GroupArray[iCount] );
|
|
if (thisGroup != NULL)
|
|
{
|
|
foundIt = FALSE;
|
|
// Find position of 1st LINEAGENTGROUPEENTRY structure in the LINEAGENTGROUPLIST
|
|
pGroupEntry = (LPLINEAGENTGROUPENTRY) ((BYTE*)(pGroupList) + pGroupList->dwListOffset);
|
|
// Run though the list
|
|
for (dwCount = 0; dwCount < dwNumberOfEntries; dwCount++)
|
|
{
|
|
pGroupID = (GUID*)&pGroupEntry->GroupID;
|
|
if ( IsEqualGUID(*pGroupID, thisGroup->getID() ) )
|
|
{
|
|
foundIt = TRUE;
|
|
break;
|
|
}
|
|
pGroupEntry ++; // next
|
|
} // for (dwCount = 0......)
|
|
|
|
|
|
if (foundIt == FALSE)
|
|
{
|
|
// Didn't match so it's no longer a valid group , according to the Proxy
|
|
LOG((TL_INFO, "UpdateGroupArray - Group has gone from the proxy"));
|
|
thisGroup->SetInactive();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LOG((TL_ERROR, "UpdateGroupArray - lineGetGroupList failed - empty list"));
|
|
hr = E_FAIL;
|
|
}
|
|
|
|
}
|
|
else // lineGetGroupList failed
|
|
{
|
|
LOG((TL_ERROR, "UpdateGroupArray - lineGetGroupList failed"));
|
|
}
|
|
|
|
|
|
|
|
|
|
// finished with memory block so release
|
|
if ( pGroupList != NULL )
|
|
ClientFree( pGroupList );
|
|
|
|
|
|
LOG((TL_TRACE, hr, "UpdateGroupArray - exit"));
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
// Class : CAgentHandler
|
|
// Interface : ITAgentHandler
|
|
// Method : get_Name
|
|
//
|
|
//
|
|
//
|
|
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
STDMETHODIMP CAgentHandler::get_Name(BSTR * Name)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
LOG((TL_TRACE, "Name - enter" ));
|
|
Lock();
|
|
if(!TAPIIsBadWritePtr( Name, sizeof(BSTR) ) )
|
|
{
|
|
*Name = SysAllocString(m_szName);
|
|
|
|
if (*Name == NULL)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LOG((TL_ERROR, "Name - bad Name pointer" ));
|
|
hr = E_POINTER;
|
|
}
|
|
|
|
Unlock();
|
|
LOG((TL_TRACE, hr, "Name - exit" ));
|
|
return hr;
|
|
}
|
|
|
|
|
|
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
// Class : CAgentHandler
|
|
// Interface : ITAgentHandler
|
|
// Method : CreateAgent
|
|
//
|
|
//
|
|
//
|
|
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
STDMETHODIMP CAgentHandler::CreateAgent(ITAgent **ppAgent)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
CAgent * pAgent;
|
|
|
|
LOG((TL_TRACE, "CreateAgent - enter"));
|
|
if(!TAPIIsBadWritePtr( ppAgent, sizeof(ITAgent *) ) )
|
|
{
|
|
hr = InternalCreateAgent(NULL, NULL, &pAgent);
|
|
if ( SUCCEEDED(hr) )
|
|
{
|
|
//
|
|
// put result in out pointer - also
|
|
pAgent->QueryInterface(IID_ITAgent, (void **)ppAgent );
|
|
}
|
|
else
|
|
{
|
|
LOG((TL_ERROR, "CreateAgent - InternalCreateAgent failed" ));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LOG((TL_ERROR, "CreateAgent - Bad ppAgent Pointer"));
|
|
hr = E_POINTER;
|
|
}
|
|
LOG((TL_TRACE, hr, "CreateAgent - exit"));
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
// Class : CAgentHandler
|
|
// Interface : ITAgentHandler
|
|
// Method : CreateAgentWithID
|
|
//
|
|
//
|
|
//
|
|
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
STDMETHODIMP CAgentHandler::CreateAgentWithID(BSTR pID, BSTR pPIN, ITAgent **ppAgent)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
CAgent * pAgent;
|
|
|
|
LOG((TL_TRACE, "CreateAgentWithID - enter"));
|
|
|
|
if(!TAPIIsBadWritePtr( ppAgent, sizeof(ITAgent *) ) )
|
|
{
|
|
if (!IsBadStringPtrW( pID, -1 ))
|
|
{
|
|
// ID Pointer OK, is it empty ?
|
|
if( *pID != NULL)
|
|
{
|
|
if (!IsBadStringPtrW( pPIN, -1 ))
|
|
{
|
|
// All OK so far, so try to create
|
|
hr = InternalCreateAgent(pID, pPIN, &pAgent);
|
|
if ( SUCCEEDED(hr) )
|
|
{
|
|
// put result in out pointer - also
|
|
pAgent->QueryInterface(IID_ITAgent, (void **)ppAgent );
|
|
}
|
|
else // InternalCreateAgent failed
|
|
{
|
|
LOG((TL_ERROR, "CreateAgentWithID - InternalCreateAgent failed" ));
|
|
}
|
|
}
|
|
else // bad PIN pointer
|
|
{
|
|
LOG((TL_ERROR, "CreateAgentWithID - Bad PIN pointer" ));
|
|
hr = E_POINTER;
|
|
}
|
|
}
|
|
else // NULL ID
|
|
{
|
|
LOG((TL_ERROR, "CreateAgentWithID - ID is Empty String" ));
|
|
hr = E_INVALIDARG;
|
|
}
|
|
}
|
|
else // bad ID pointer
|
|
{
|
|
LOG((TL_ERROR, "CreateAgentWithID - Bad ID pointer" ));
|
|
hr = E_POINTER;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LOG((TL_ERROR, "CreateAgentWithID - Bad ppAgent Pointer"));
|
|
hr = E_POINTER;
|
|
}
|
|
|
|
LOG((TL_TRACE, hr, "CreateAgentWithID - exit"));
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
// Class : CAgentHandler
|
|
// Method : InternalCreateAgent
|
|
//
|
|
//
|
|
//
|
|
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
HRESULT CAgentHandler::InternalCreateAgent(BSTR pID, BSTR pPIN, CAgent ** ppAgent)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
HAGENT hAgent;
|
|
DWORD dwUserNameSize = (UNLEN + 1);
|
|
PWSTR pszName = NULL;
|
|
|
|
LOG((TL_TRACE, "InternalCreateAgent - enter"));
|
|
|
|
hr = LineCreateAgent(getHLine(), pID, pPIN, &hAgent);
|
|
if ( SUCCEEDED(hr) )
|
|
{
|
|
hr = WaitForReply( hr );
|
|
if ( SUCCEEDED(hr) )
|
|
{
|
|
// Successs, so create agent
|
|
LOG((TL_INFO, "InternalCreateAgent - create new Agent Handler" ));
|
|
|
|
CComObject<CAgent> * pAgent;
|
|
hr = CComObject<CAgent>::CreateInstance( &pAgent);
|
|
if( SUCCEEDED(hr) )
|
|
{
|
|
// initialize the AgentHandler
|
|
pszName = (PWSTR)ClientAlloc((dwUserNameSize + 1) * sizeof(WCHAR) );
|
|
if (pszName != NULL)
|
|
{
|
|
if ( GetUserNameW( pszName, &dwUserNameSize) )
|
|
{
|
|
ITAgent *pITAgent;
|
|
hr = pAgent->QueryInterface(IID_ITAgent, (void **)&pITAgent);
|
|
|
|
if( SUCCEEDED(hr ))
|
|
{
|
|
hr = pAgent->Initialize(hAgent, pszName, pID, pPIN, this );
|
|
if( SUCCEEDED(hr) )
|
|
{
|
|
//
|
|
// add to list
|
|
//
|
|
Lock();
|
|
m_AgentArray.Add(pITAgent);
|
|
Unlock();
|
|
|
|
pITAgent->Release();
|
|
LOG((TL_INFO, "InternalCreateAgent - Added Agent to array"));
|
|
|
|
// Return new Agent object
|
|
*ppAgent = pAgent;
|
|
}
|
|
else
|
|
{
|
|
LOG((TL_ERROR, "InternalCreateAgent - Initialize Agent failed" ));
|
|
delete pAgent;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LOG((TL_ERROR, "InternalCreateAgent - QueryInterface failed" ));
|
|
delete pAgent;
|
|
}
|
|
|
|
}
|
|
else // GetUserName fail
|
|
{
|
|
LOG((TL_ERROR, "InternalCreateAgent - GetUserNameW failed" ));
|
|
hr = TAPI_E_CALLCENTER_INVALAGENTID;
|
|
}
|
|
}
|
|
else // pszName == NULL
|
|
{
|
|
LOG((TL_ERROR, "InternalCreateAgent - ClientAlloc pszName failed" ));
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LOG((TL_ERROR, "InternalCreateAgent - Create Agent failed" ));
|
|
}
|
|
}
|
|
else // LineCreateAgent failed async
|
|
{
|
|
LOG((TL_ERROR, "InternalCreateAgent - LineCreateAgent failed async" ));
|
|
}
|
|
}
|
|
else // LineCreateAgent failed
|
|
{
|
|
LOG((TL_ERROR, "InternalCreateAgent - LineCreateAgent failed" ));
|
|
}
|
|
|
|
|
|
if(pszName != NULL)
|
|
ClientFree(pszName);
|
|
|
|
|
|
LOG((TL_TRACE, hr, "InternalCreateAgent - exit"));
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
|
|
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
// Class : CAgentHandler
|
|
// Interface : ITAgentHandler
|
|
// Method : EnumerateACDGroups
|
|
//
|
|
//
|
|
//
|
|
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
STDMETHODIMP CAgentHandler::EnumerateACDGroups(IEnumACDGroup ** ppEnumACDGroup)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
LOG((TL_TRACE, "EnumerateACDGroups - enter"));
|
|
|
|
if(!TAPIIsBadWritePtr( ppEnumACDGroup, sizeof(IEnumACDGroup *) ) )
|
|
{
|
|
UpdateGroupArray();
|
|
|
|
//
|
|
// create the enumerator
|
|
//
|
|
CComObject< CTapiEnum<IEnumACDGroup, ITACDGroup, &IID_IEnumACDGroup> > * pEnum;
|
|
hr = CComObject< CTapiEnum<IEnumACDGroup, ITACDGroup, &IID_IEnumACDGroup> > ::CreateInstance( &pEnum );
|
|
|
|
if (SUCCEEDED(hr) )
|
|
{
|
|
// initialize it with our group list
|
|
Lock();
|
|
hr = pEnum->Initialize( m_GroupArray );
|
|
Unlock();
|
|
if ( SUCCEEDED(hr) )
|
|
{
|
|
// return it
|
|
*ppEnumACDGroup = pEnum;
|
|
}
|
|
else // failed to initialize
|
|
{
|
|
LOG((TL_ERROR, "EnumerateACDGroup - could not initialize enum" ));
|
|
pEnum->Release();
|
|
}
|
|
}
|
|
else // failed to create enum
|
|
{
|
|
LOG((TL_ERROR, "EnumerateACDGroups - could not create enum" ));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LOG((TL_ERROR, "EnumerateACDGroups - bad ppEnumACDGroup ponter" ));
|
|
hr = E_POINTER;
|
|
}
|
|
|
|
LOG((TL_TRACE, hr, "EnumerateACDGroups - exit"));
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
// Class : CAgentHandler
|
|
// Interface : ITAgentHandler
|
|
// Method : get_ACDGroups
|
|
//
|
|
// Return a collection of calls usable for this Agent Handler
|
|
//
|
|
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
STDMETHODIMP CAgentHandler::get_ACDGroups(VARIANT * pVariant)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
IDispatch * pDisp = NULL;
|
|
|
|
|
|
LOG((TL_TRACE, "get_ACDGroups - enter"));
|
|
|
|
if (!TAPIIsBadWritePtr( pVariant, sizeof(VARIANT) ) )
|
|
{
|
|
UpdateGroupArray();
|
|
|
|
//
|
|
// create the collection
|
|
//
|
|
CComObject< CTapiCollection< ITACDGroup > > * p;
|
|
hr = CComObject< CTapiCollection< ITACDGroup > >::CreateInstance( &p );
|
|
|
|
if (SUCCEEDED(hr) )
|
|
{
|
|
// initialize it with our address list
|
|
Lock();
|
|
hr = p->Initialize( m_GroupArray );
|
|
Unlock();
|
|
|
|
if ( SUCCEEDED(hr) )
|
|
{
|
|
// get the IDispatch interface
|
|
hr = p->_InternalQueryInterface( IID_IDispatch, (void **) &pDisp );
|
|
|
|
if ( SUCCEEDED(hr) )
|
|
{
|
|
// put it in the variant
|
|
VariantInit(pVariant);
|
|
pVariant->vt = VT_DISPATCH;
|
|
pVariant->pdispVal = pDisp;
|
|
}
|
|
else
|
|
{
|
|
LOG((TL_ERROR, "get_ACDGroups - could not get IDispatch interface" ));
|
|
delete p;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LOG((TL_ERROR, "get_ACDGroups - could not initialize collection" ));
|
|
delete p;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LOG((TL_ERROR, "get_ACDGroups - could not create collection" ));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LOG((TL_ERROR, "get_ACDGroups - bad pVariant pointer" ));
|
|
hr = E_POINTER;
|
|
}
|
|
|
|
|
|
LOG((TL_TRACE, hr, "get_ACDGroups - exit"));
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
|
|
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
// Class : CAgentHandler
|
|
// Interface : ITAgentHandler
|
|
// Method : EnumerateUsableAddresses
|
|
//
|
|
//
|
|
//
|
|
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
STDMETHODIMP CAgentHandler::EnumerateUsableAddresses(IEnumAddress ** ppEnumAddress)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
LOG((TL_TRACE, "EnumerateUsableAddresses - enter"));
|
|
|
|
|
|
if(!TAPIIsBadWritePtr( ppEnumAddress, sizeof(IEnumAddress *) ) )
|
|
{
|
|
//
|
|
// create the enumerator
|
|
//
|
|
CComObject< CTapiEnum<IEnumAddress, ITAddress, &IID_IEnumAddress> > * pEnum;
|
|
hr = CComObject< CTapiEnum<IEnumAddress, ITAddress, &IID_IEnumAddress> > ::CreateInstance( &pEnum );
|
|
|
|
if ( SUCCEEDED(hr) )
|
|
{
|
|
//
|
|
// initialize it with our address array
|
|
//
|
|
Lock();
|
|
|
|
hr = pEnum->Initialize( m_AddressArray );
|
|
|
|
Unlock();
|
|
|
|
if ( SUCCEEDED(hr) )
|
|
{
|
|
// return it
|
|
*ppEnumAddress = pEnum;
|
|
}
|
|
else // failed to initialize
|
|
{
|
|
LOG((TL_ERROR, "EnumerateUsableAddresses - could not initialize enum" ));
|
|
pEnum->Release();
|
|
}
|
|
}
|
|
else // failed to create enum
|
|
{
|
|
LOG((TL_ERROR, "EnumerateUsableAddresses - could not create enum" ));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LOG((TL_ERROR, "EnumerateUsableAddresses - bad ppEnumAddress pointer" ));
|
|
hr = E_POINTER;
|
|
}
|
|
|
|
|
|
LOG((TL_TRACE, hr, "EnumerateUsableAddresses - exit"));
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
// Class : CAgentHandler
|
|
// Interface : ITAgentHandler
|
|
// Method : get_UsableAddresses
|
|
//
|
|
// Return a collection of calls usable for this Agent Handler
|
|
//
|
|
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
STDMETHODIMP CAgentHandler::get_UsableAddresses(VARIANT * pVariant)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
IDispatch * pDisp = NULL;
|
|
|
|
|
|
LOG((TL_TRACE, "get_UsableAddresses - enter"));
|
|
|
|
if (!TAPIIsBadWritePtr( pVariant, sizeof(VARIANT) ) )
|
|
{
|
|
//
|
|
// create the collection
|
|
//
|
|
CComObject< CTapiCollection< ITAddress > > * p;
|
|
hr = CComObject< CTapiCollection< ITAddress > >::CreateInstance( &p );
|
|
|
|
if (SUCCEEDED(hr) )
|
|
{
|
|
// initialize it with our address Array
|
|
Lock();
|
|
|
|
hr = p->Initialize( m_AddressArray );
|
|
|
|
Unlock();
|
|
|
|
if ( SUCCEEDED(hr) )
|
|
{
|
|
// get the IDispatch interface
|
|
hr = p->_InternalQueryInterface( IID_IDispatch, (void **) &pDisp );
|
|
|
|
if ( SUCCEEDED(hr) )
|
|
{
|
|
// put it in the variant
|
|
VariantInit(pVariant);
|
|
pVariant->vt = VT_DISPATCH;
|
|
pVariant->pdispVal = pDisp;
|
|
}
|
|
else
|
|
{
|
|
LOG((TL_ERROR, "get_UsableAddresses - could not get IDispatch interface" ));
|
|
delete p;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LOG((TL_ERROR, "get_UsableAddresses - could not initialize collection" ));
|
|
delete p;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LOG((TL_ERROR, "get_UsableAddresses - could not create collection" ));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LOG((TL_ERROR, "get_UsableAddresses - bad pVariant pointer" ));
|
|
hr = E_POINTER;
|
|
}
|
|
|
|
|
|
LOG((TL_TRACE, hr, "get_UsableAddresses - exit"));
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CAgentEvent
|
|
|
|
|
|
|
|
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
// Class : CAgentEvent
|
|
// Method : FireEvent
|
|
//
|
|
//
|
|
//
|
|
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
HRESULT CAgentHandlerEvent::FireEvent(CAgentHandler* pAgentHandler, AGENTHANDLER_EVENT Event)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
CComObject<CAgentHandlerEvent> * pEvent;
|
|
IDispatch * pIDispatch;
|
|
|
|
if ( IsBadReadPtr(pAgentHandler, sizeof(CAgentHandler)) )
|
|
{
|
|
STATICLOG((TL_ERROR, "FireEvent - pAgentHandler is an invalid pointer"));
|
|
return E_POINTER;
|
|
}
|
|
|
|
//
|
|
// create event
|
|
//
|
|
hr = CComObject<CAgentHandlerEvent>::CreateInstance( &pEvent );
|
|
|
|
if ( SUCCEEDED(hr) )
|
|
{
|
|
//
|
|
// initialize
|
|
//
|
|
pEvent->m_AgentHandlerEvent = Event;
|
|
pEvent->m_pAgentHandler= dynamic_cast<ITAgentHandler *>(pAgentHandler);
|
|
pEvent->m_pAgentHandler->AddRef();
|
|
|
|
//
|
|
// get idisp interface
|
|
//
|
|
hr = pEvent->QueryInterface( IID_IDispatch, (void **)&pIDispatch );
|
|
|
|
if ( SUCCEEDED(hr) )
|
|
{
|
|
//
|
|
// get callback & fire event
|
|
|
|
//
|
|
CTAPI *pTapi = pAgentHandler->GetTapi();
|
|
pTapi->Event( TE_AGENTHANDLER, pIDispatch );
|
|
|
|
// release stuff
|
|
//
|
|
pIDispatch->Release();
|
|
|
|
}
|
|
else
|
|
{
|
|
STATICLOG((TL_ERROR, "FireEvent - Could not get disp interface of AgentHandlerEvent object"));
|
|
delete pEvent;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
STATICLOG((TL_ERROR, "FireEvent - Could not create AgentHandlerEvent object"));
|
|
}
|
|
|
|
|
|
STATICLOG((TL_TRACE, hr, "FireEvent - exit"));
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
// Class : CAgentHandlerEvent
|
|
// Method : FinalRelease
|
|
//
|
|
//
|
|
//
|
|
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
void CAgentHandlerEvent::FinalRelease()
|
|
{
|
|
m_pAgentHandler->Release();
|
|
|
|
}
|
|
|
|
|
|
|
|
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
// Class : CAgentEvent
|
|
// Interface : ITAgentEvent
|
|
// Method : Agent
|
|
//
|
|
//
|
|
//
|
|
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
STDMETHODIMP CAgentHandlerEvent::get_AgentHandler(ITAgentHandler ** ppAgentHandler)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
|
|
LOG((TL_TRACE, "(Event)AgentHandler - enter" ));
|
|
if(!TAPIIsBadWritePtr( ppAgentHandler, sizeof(ITAgentHandler *) ) )
|
|
{
|
|
*ppAgentHandler = m_pAgentHandler;
|
|
m_pAgentHandler->AddRef();
|
|
}
|
|
else
|
|
{
|
|
LOG((TL_ERROR, "(Event)AgentHandler - bad ppAgentHandler Pointer"));
|
|
hr = E_POINTER;
|
|
}
|
|
|
|
|
|
LOG((TL_TRACE, hr, "(Event)AgentHandler - exit"));
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
// Class : CAgentEvent
|
|
// Interface : ITAgentEvent
|
|
// Method : Event
|
|
//
|
|
//
|
|
//
|
|
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
STDMETHODIMP CAgentHandlerEvent::get_Event(AGENTHANDLER_EVENT * pEvent)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
LOG((TL_TRACE, "Event - enter" ));
|
|
if(!TAPIIsBadWritePtr( pEvent, sizeof(AGENTHANDLER_EVENT) ) )
|
|
{
|
|
*pEvent = m_AgentHandlerEvent;
|
|
}
|
|
else
|
|
{
|
|
LOG((TL_ERROR, "Event - bad pEvent Pointer"));
|
|
hr = E_POINTER;
|
|
}
|
|
|
|
|
|
LOG((TL_TRACE, hr, "Event - exit"));
|
|
return hr;
|
|
}
|
|
|
|
|
|
|