acdutils.c

TAPI ACD Samples

//////////////////////////////////////////////////////////////////
//
//  ACDUTILS.C
//
//  Some utility functions used in ACDSMPL
//
//////////////////////////////////////////////////////////////////



#include <windows.h>
#include "acdsmpl.h"

extern ACDGLOBALS   g;

//////////////////////////////////////////////////////////////////
//
//  LPVOID ACDAlloc(DWORD dwSize)
//
//////////////////////////////////////////////////////////////////
LPVOID ACDAlloc(DWORD dwSize)
{
    LPVOID  pBuf;

    pBuf = GlobalAlloc(GPTR, dwSize);

    return pBuf;
}

///////////////////////////////////////////////////////////////////
//
//  void ACDFree(LPVOID pBuf)
//
///////////////////////////////////////////////////////////////////
void ACDFree(LPVOID pBuf)
{
    if (pBuf)
        GlobalFree(pBuf);
}

///////////////////////////////////////////////////////////////////
//
// LPVOID ACDReAlloc()
//
///////////////////////////////////////////////////////////////////
LPVOID ACDReAlloc(LPVOID pBuf,
                  DWORD dwSize)
{
    if (pBuf)
    {
        pBuf = GlobalReAlloc(pBuf,
                             dwSize,
                             GMEM_MOVEABLE);
    }

    return pBuf;
}

///////////////////////////////////////////////////////////////////////////////
//
//  BOOL InsertStruct(PGENERICSTRUCT * ppRoot,
//                    PGENERICSTRUCT pStruct)
//
//    Adds a structure to the end of a linked list
//
///////////////////////////////////////////////////////////////////////////////
BOOL InsertStruct(PGENERICSTRUCT * ppRoot,
                  PGENERICSTRUCT pStruct)
{
    PGENERICSTRUCT      pHold = NULL;
    
    if (!*ppRoot)
    {
        *ppRoot = pStruct;
    }
    else
    {
        pHold = *ppRoot;
    }

    if (pHold)
    {
        while (pHold->pNext)
        {
            pHold = pHold->pNext;
        }

        pHold->pNext = pStruct;
        pStruct->pPrev = pHold;
    }

    return TRUE;
}

//////////////////////////////////////////////////////////////
//
//  BOOL DeleteStruct
//      Delete structure
//
//   Delete a structure from a linked list and
//   frees memory associated with it.
//
//////////////////////////////////////////////////////////////
BOOL DeleteStruct(PGENERICSTRUCT * ppRoot,
                  PGENERICSTRUCT pStruct)
{
    if (pStruct->pPrev)
    {
        pStruct->pPrev->pNext = pStruct->pNext;
    }
    else
    {
        *ppRoot = pStruct->pNext;
    }
    
    if (pStruct->pNext)
    {
        pStruct->pNext->pPrev = pStruct->pPrev;
    }

    ACDFree(pStruct);

    return TRUE;
}


//////////////////////////////////////////////////////////////
//
//  PGROUP AddGroup
//
//  Adds a group to the global group list
// 
//////////////////////////////////////////////////////////////
PGROUP AddGroup(LPTSTR lpszName,
                 DWORD dwDeviceID,
                 DWORD dwAddress)
{
    PGROUP                  pGroup, pHold = NULL;
    LONG                    lResult;
    
    // alloc memory
    pGroup = (PGROUP)ACDAlloc(sizeof(GROUP));

    if (!pGroup)
    {
        return NULL;
    }

    pGroup->lpszName = (LPTSTR)ACDAlloc((lstrlen(lpszName) + 1) * sizeof(TCHAR));

    // bail if there is a problem
    if (!pGroup->lpszName)
    {
        ACDFree(pGroup);
        return NULL;
    }

    // init stuff
    lstrcpy(pGroup->lpszName, lpszName);
    
    pGroup->dwKey = GROUPKEY;
    pGroup->dwSize = sizeof(GROUP);
    pGroup->dwDeviceID = dwDeviceID;


    // open the line in owner mode, so we can
    // get the incoming calls
    lResult = lineOpen(g.hLineApp,
                       dwDeviceID,
                       &pGroup->hLine,
                       TAPI_CURRENT_VERSION,
                       0,
                       0,
                       LINECALLPRIVILEGE_OWNER,
                       LINEMEDIAMODE_INTERACTIVEVOICE,
                       NULL);
    
    if (lResult < 0)
    {
//      LogTapiError(lResult, "lineOpen line %lu", dwDeviceID);
        ACDFree(pGroup->lpszName);
        ACDFree(pGroup);

        return NULL;
    }

    // insert into global list
    InsertStruct((PGENERICSTRUCT *)&g.pGroups,
                 (PGENERICSTRUCT)pGroup);

    // increment
    g.dwNumGroups++;

    return pGroup;
}

//////////////////////////////////////////////////////////////
//
// PAGENT AddAgent
//
//  Adds an agent to the global agent list
//
//  NOTE:  There is a ton of verification type stuff that can
//  be put in here for a real implementation.   For example,
//  might want to restrict a user to a single line, or restrict
//  a single line to have one person.
//   
//////////////////////////////////////////////////////////////
PAGENT AddAgent(LPTSTR lpszName,
                LPTSTR lpszNumber,
                DWORD dwDeviceID)
{
    PAGENT              pAgent, pHold = NULL;
    LPLINEDEVCAPS       pLDC;
    LPLINECALLPARAMS    pLCP;
    LONG                lResult;
    LPDWORD             pdwProxyRequests;

    // alloc memory
    pAgent = (PAGENT)ACDAlloc(sizeof(AGENT));

    if (!pAgent)
    {
        return NULL;
    }

    pAgent->lpszName = (LPTSTR)ACDAlloc((lstrlen(lpszName) + 1) * sizeof(TCHAR));
    pAgent->lpszNumber = (LPTSTR)ACDAlloc((lstrlen(lpszNumber) + 1) * sizeof(TCHAR));    

    // bail if there is a problem
    if (!pAgent->lpszName || !pAgent->lpszNumber)
    {
        ACDFree(pAgent);
        return NULL;
    }


    // init stuff
    lstrcpy(pAgent->lpszName, lpszName);
    lstrcpy(pAgent->lpszNumber, lpszNumber);
    
    pAgent->dwKey       = AGENTKEY;
    pAgent->dwSize      = sizeof(AGENT);
    pAgent->dwDeviceID  = dwDeviceID;
    pAgent->dwPermID    = g.pdwPermIDs[dwDeviceID];

    // insert into global agent list
    InsertStruct((PGENERICSTRUCT *)&g.pAgents,
                 (PGENERICSTRUCT)pAgent);

    // lineOpen is where the application lets TAPI know that it is a Proxy Request handler
    // for this line.  The LINEOPENOPTION_PROXY is added to the privileges.  Also,
    // the dev specific portion of LINECALLPARAMS contains the proxy request constants
    // that indicate which requests this app can handle

    // This sample handles 7 types of proxy requests - all the ones that are defined
    // except for AGENTSPECIFIC
    pLCP = (LPLINECALLPARAMS)ACDAlloc(sizeof(LINECALLPARAMS) + 7*sizeof(DWORD));

    pLCP->dwTotalSize           = sizeof(LINECALLPARAMS) + 7*sizeof(DWORD);
    pLCP->dwDevSpecificOffset   = sizeof(LINECALLPARAMS);
    pLCP->dwDevSpecificSize     = sizeof(DWORD) * 7;

    pdwProxyRequests = (LPDWORD)((LPBYTE)pLCP + sizeof(LINECALLPARAMS));
    // each constant is in a DWORD at the end of LINECALLPARAMS
    *pdwProxyRequests++ = LINEPROXYREQUEST_SETAGENTGROUP;
    *pdwProxyRequests++ = LINEPROXYREQUEST_SETAGENTSTATE;
    *pdwProxyRequests++ = LINEPROXYREQUEST_SETAGENTACTIVITY;
    *pdwProxyRequests++ = LINEPROXYREQUEST_GETAGENTSTATUS;
    *pdwProxyRequests++ = LINEPROXYREQUEST_GETAGENTCAPS;
    *pdwProxyRequests++ = LINEPROXYREQUEST_GETAGENTACTIVITYLIST;
    *pdwProxyRequests   = LINEPROXYREQUEST_GETAGENTGROUPLIST;        
        
    lResult = lineOpen(g.hLineApp,
                       dwDeviceID,
                       &pAgent->hLine,
                       TAPI_CURRENT_VERSION,
                       0,
                       0,
                       LINEOPENOPTION_PROXY | LINECALLPRIVILEGE_MONITOR,
                       LINEMEDIAMODE_INTERACTIVEVOICE,
                       pLCP);
    
    ACDFree(pLCP);
    
    if (lResult)
    {
        //
        ACDFree(pAgent->lpszName);
        ACDFree(pAgent);
        
    }

    pLDC = LineGetDevCaps(g.hLineApp,
                          pAgent->dwDeviceID);

    if (!pLDC)
    {
        return FALSE;
    }

    // alloc memory for address specific info
    pAgent->pAddressInfo = (PADDRESSINFO)ACDAlloc(sizeof(ADDRESSINFO) * pLDC->dwNumAddresses);
    pAgent->dwNumAddresses = pLDC->dwNumAddresses;

    ACDFree(pLDC);

    // increment number of agents
    g.dwNumAgents++;

    return pAgent;
}


//////////////////////////////////////////////////////////////////////////
//
// BOOL DeleteAgent(PAGENT pAgent)
//
//  Frees all memory associated with pAgent, removes
//  agent from group lists, and remove pAgent from
//  global agent list
//
//////////////////////////////////////////////////////////////////////////
BOOL DeleteAgent(PAGENT pAgent)
{
    PGROUP      pGroup;

    
    lineClose(pAgent->hLine);
    
    // free name
    ACDFree(pAgent->lpszName);
    ACDFree(pAgent->lpszNumber);

    // free address info
    ACDFree(pAgent->pAddressInfo);

    pGroup = g.pGroups;

    // walk through groups and remove from
    // group list if in group list
    while (pGroup)
    {
        if (IsAgentInList(pGroup->pAgentList,
                          pAgent))
        {
            RemoveFromGroupList(pGroup,
                                pAgent);
        }

        pGroup = pGroup->pNext;
        
    }

    // finally, remove pAgent from global list
    DeleteStruct((PGENERICSTRUCT *)&g.pAgents,
                 (PGENERICSTRUCT)pAgent);

    return TRUE;
}


//////////////////////////////////////////////////////////////////////////
//
// BOOL DeleteGroup(PGROUP pGroup)
//
//  Frees memory assocated with pGroup, and removes the structure from
//  the global list
//
//////////////////////////////////////////////////////////////////////////
BOOL DeleteGroup(PGROUP pGroup)
{
    PLISTITEM       pList, pListNext;

    lineClose(pGroup->hLine);
    
    ACDFree(pGroup->lpszName);

    pList = pGroup->pAgentList;

    while (pList)
    {
        pListNext = pList->pNext;
        ACDFree(pList);
        pList = pListNext;
    }

    DeleteStruct((PGENERICSTRUCT *)&g.pGroups,
                 (PGENERICSTRUCT)pGroup);

    return TRUE;
}


//////////////////////////////////////////////////////////////////////////
//
// BOOL InsertIntoGroupList(PGROUP pGroup,
//                          PAGENT pAgent)
//
//  Insert an agent in a group
//
//////////////////////////////////////////////////////////////////////////
BOOL InsertIntoGroupList(PGROUP pGroup,
                         PAGENT pAgent)
{
    PLISTITEM       pListItem;

    pListItem = (PLISTITEM)ACDAlloc(sizeof(LISTITEM));