www.pudn.com > Acd.rar > AcdTapi.c

/////////////////////////////////////////////////////////////////////////////////// 
// 
//  ACDTAPI.C 
// 
//  This file handles all tapi functionality in the ACD sample 
// 
// 
// 
//////////////////////////////////////////////////////////////////////////////////// 
#include  
#include  
#include "acdsmpl.h" 
 
VOID CALLBACK LineCallback (DWORD hDevice, 
                            DWORD dwMsg, 
                            DWORD dwCallbackInstance,  
                            DWORD dwParam1, 
                            DWORD dwParam2,  
                            DWORD dwParam3); 
 
 
#define LogTapiError(__lResult__, __szString__) 
#define LogError(__szString__) 
 
extern ACDGLOBALS       g; 
 
 
//////////////////////////////////////////////////////////////////////////////////// 
// 
//  BOOL InitializeTapi() 
// 
//    Whatever is needed to init TAPI for the application.  This is called 
//    before the main window is created. 
// 
//////////////////////////////////////////////////////////////////////////////////// 
BOOL InitializeTapi() 
{ 
    DWORD                       dwAPIVersion; 
    LINEINITIALIZEEXPARAMS      exparams; 
    LONG                        lResult; 
    DWORD                       i; 
    LPLINEDEVCAPS               pLDC; 
 
 
    // fill in lineinitex parameters 
    exparams.dwTotalSize             = sizeof(LINEINITIALIZEEXPARAMS); 
    exparams.dwOptions               = LINEINITIALIZEEXOPTION_USEHIDDENWINDOW; 
     
    dwAPIVersion = TAPI_CURRENT_VERSION; 
 
    // line init 
    if ((lResult = lineInitializeEx(&g.hLineApp, 
                                    g.hInstance, 
                                    LineCallback, 
                                    SZAPPNAME, 
                                    &g.dwNumDevs, 
                                    &dwAPIVersion, 
                                    &exparams)) < 0) 
    { 
        LogTapiError(lResult, "lineInitializeEx"); 
        return FALSE; 
    } 
 
    // if there are no tapi devices, should probably 
    // not continue 
    if (g.dwNumDevs == 0) 
    { 
        LogError("No TAPI devices installed"); 
        lineShutdown(g.hLineApp); 
        return FALSE; 
    } 
 
    // need to get the permanent device IDs to map from 
    // an .ini file being read in 
    g.pdwPermIDs = (LPDWORD)ACDAlloc(g.dwNumDevs * sizeof(DWORD)); 
 
    if (!g.pdwPermIDs) 
    { 
        return FALSE; 
    } 
     
    for (i = 0; i < g.dwNumDevs; i++) 
    { 
        pLDC = LineGetDevCaps(g.hLineApp, 
                              i); 
 
        if (pLDC) 
        { 
            g.pdwPermIDs[i] = pLDC->dwPermanentLineID; 
            ACDFree(pLDC); 
        } 
    } 
 
    return TRUE; 
} 
 
 
////////////////////////////////////////////////////////////////////// 
// 
//  BOOL CleanUp() 
// 
//  Called while shutting down.  free memory, close down tapi 
// 
////////////////////////////////////////////////////////////////////// 
BOOL CleanUp() 
{ 
    PAGENT      pAgent, pAgentNext; 
    PGROUP      pGroup, pGroupNext; 
 
    // remove agents 
    pAgent = g.pAgents; 
    while(pAgent) 
    { 
        pAgentNext = pAgent->pNext; 
        DeleteAgent(pAgent); 
        pAgent = pAgentNext; 
    } 
 
    // remove groups 
    pGroup = g.pGroups; 
    while (pGroup) 
    { 
        pGroupNext = pGroup->pNext; 
        DeleteGroup(pGroup); 
        pGroup = pGroupNext; 
    } 
 
    // free id array 
    ACDFree(g.pdwPermIDs); 
 
    // shutdown 
    lineShutdown(g.hLineApp); 
 
    return TRUE; 
     
} 
//////////////////////////////////////////////////////////////////////////////// 
// 
//  LRESULT MakeGroupList(PAGENT pAgent, 
//                        LPLINEAGENTGROUPLIST pGroupList) 
// 
//    Creates a LINEAGENTGROUPLIST for pAgent - group that the agent 
//      is allowed to log into 
//    Assumption:  don't care about address for group list 
// 
//////////////////////////////////////////////////////////////////////////////// 
LRESULT MakeGroupList(PAGENT pAgent, 
                      LPLINEAGENTGROUPLIST pGroupList) 
{ 
    PGROUP                  pGroup; 
    DWORD                   dwTotalSizeNeeded, dwNameOffset, dwNumEntries; 
    LPLINEAGENTGROUPENTRY   pEntry; 
    LPTSTR                  pName; 
 
 
    pGroup = g.pGroups; 
    dwTotalSizeNeeded = sizeof(LINEAGENTGROUPLIST); 
    pGroupList->dwNumEntries = 0; 
    dwNumEntries = 0; 
 
    // walk list of groups 
    while (pGroup) 
    { 
        if (IsAgentInList(pGroup->pAgentList, 
                          pAgent)) 
        // if found the agent, add the group to the group list 
        { 
            // incrememt number of entries 
            dwNumEntries++; 
 
            // add to total size needed 
            dwTotalSizeNeeded += sizeof(LINEAGENTGROUPENTRY); 
            dwTotalSizeNeeded += (lstrlen(pGroup->lpszName) + 1) * sizeof(TCHAR); 
        } 
 
        pGroup = pGroup->pNext; 
    } 
 
    pGroupList->dwNeededSize = dwTotalSizeNeeded; 
     
    if (pGroupList->dwTotalSize < dwTotalSizeNeeded) 
    { 
        pGroupList->dwUsedSize = sizeof(LINEAGENTGROUPLIST); 
 
        return 0; 
//        return LINEERR_STRUCTURETOOSMALL; 
    } 
 
    pGroupList->dwNumEntries = dwNumEntries; 
 
    // set the list info 
    pGroupList->dwListSize = sizeof(LINEAGENTGROUPENTRY) * pGroupList->dwNumEntries; 
    pGroupList->dwListOffset = sizeof(LINEAGENTGROUPLIST); 
 
    // get the first agentgroup entry struct 
    pEntry = (LPLINEAGENTGROUPENTRY)(((LPBYTE)pGroupList) + pGroupList->dwListOffset); 
 
    dwNameOffset = pGroupList->dwListOffset + pGroupList->dwListSize; 
    pGroup = g.pGroups; 
 
    // loop through the groups again, and fill in the structure 
    while (pGroup) 
    { 
        if (IsAgentInList(pGroup->pAgentList, 
                          pAgent)) 
        { 
            // ID is just PGROUP 
            pEntry->GroupID.dwGroupID1 = (DWORD)pGroup; 
            pEntry->GroupID.dwGroupID2 = 0; 
            pEntry->GroupID.dwGroupID3 = 0; 
            pEntry->GroupID.dwGroupID4 = 0; 
 
            // set name of group 
            pName = (LPTSTR)(((LPBYTE)pGroupList) + dwNameOffset); 
                 
            pEntry->dwNameSize = (lstrlen(pGroup->lpszName) + 1) * sizeof(TCHAR); 
            pEntry->dwNameOffset = dwNameOffset; 
            lstrcpy(pName, 
                    pGroup->lpszName); 
 
            dwNameOffset += pEntry->dwNameSize; 
 
            // get next entry 
            pEntry++; 
        } 
 
        pGroup = pGroup->pNext; 
    } 
 
    pGroupList->dwUsedSize = dwTotalSizeNeeded; 
     
    return 0; 
} 
 
 
 
//////////////////////////////////////////////////////////////////////////// 
// 
//  LRESULT SetGroupList() 
// 
//   Sets the groups that the agent is logged into. 
//     This does not change the groups that the agent _can_ log into 
// 
//////////////////////////////////////////////////////////////////////////// 
LRESULT SetGroupList(PAGENT pAgent, 
                     DWORD dwAddress, 
                     LPLINEAGENTGROUPLIST pGroupList) 
{ 
    LPLINEAGENTGROUPENTRY   pGroupEntry; 
    PLISTITEM               pListEntry; 
    DWORD                   i; 
    PGROUP  *               ppGroups = NULL; 
    PGROUP                  pGroup; 
 
    ppGroups = (PGROUP*)ACDAlloc(sizeof(PGROUP) * pGroupList->dwNumEntries); 
     
    // get to the group entry struct 
    pGroupEntry = (LPLINEAGENTGROUPENTRY)(((LPBYTE)pGroupList) + pGroupList->dwListOffset); 
 
    // loop through all entries 
    for (i = 0; i < pGroupList->dwNumEntries; i++) 
    { 
        // get the group in entry 
        // NOTE! NOTE! NOTE! 
        // should protect here against bad pointers !!! 
        pGroup = (PGROUP)pGroupEntry->GroupID.dwGroupID1; 
 
        if (pGroup->dwKey != GROUPKEY) 
        { 
            return LINEERR_INVALAGENTGROUP; 
        } 
         
        pListEntry = pGroup->pAgentList; 
 
        // walk list of agents in that group 
        if (!IsAgentInList(pGroup->pAgentList, 
                           pAgent)) 
        { 
            ACDFree(ppGroups); 
            return LINEERR_INVALAGENTGROUP; 
        } 
 
        // save group for easy access 
        ppGroups[i] = pGroup; 
         
        // get the next entry (after the variable portion of 
        // the previous entry struct) 
        pGroupEntry++; 
    } 
 
    // now we know that the groups to be set are valid 
    // walk through the list of groups again, and 
    // set the status to logged in/ not logged in 
    // for every group that the agent is a member of 
 
    pGroup = g.pGroups; 
     
    // walk list of all groups 
    while (pGroup) 
    { 
        if (pListEntry = IsAgentInList(pGroup->pAgentList, 
                                       pAgent)) 
        { 
            // default to not logged in 
            pListEntry->bLoggedIn = FALSE; 
 
            // loop through groups being set 
            for (i = 0; i < pGroupList->dwNumEntries; i++) 
            { 
                // if this group is in list, set agent to logged in 
                if (pGroup == ppGroups[i]) 
                { 
                    pListEntry->bLoggedIn = TRUE; 
                    // assumption:  agent can only log into a group on one address. 
                    pListEntry->dwAddress = dwAddress; 
                    break; 
                } 
                 
            } // for 
             
        }  // agent in list 
 
        // next group 
        pGroup = pGroup->pNext; 
         
    } // while 
 
 
    ACDFree(ppGroups); 
     
    return 0; 
} 
 
 
///////////////////////////////////////////////////////////////////////// 
// 
//  BOOL MakeAgentActivityList() 
// 
//    Creates a LINEAGENTACTIVITYLIST for pAgent 
// 
//    for the sample, just generic names are used 
//    "Activity 1", "Activity 2".... 
// 
///////////////////////////////////////////////////////////////////////// 
LRESULT MakeAgentActivityList(PAGENT pAgent, 
                              LPLINEAGENTACTIVITYLIST pActivityList) 
{ 
    TCHAR                       szBuffer[64]; 
    DWORD                       dwTotalSize, dwNameOffset, i, dwNumEntries; 
    LPTSTR                      pName; 
    LPLINEAGENTACTIVITYENTRY    pEntry; 
 
    // init 
    dwTotalSize = sizeof(LINEAGENTACTIVITYLIST); 
    pActivityList->dwNumEntries = 0; 
    dwNumEntries = 0; 
     
    // just a static list of activities 
    for (i = 0; i < TOTALACTIVITIES; i++) 
    { 
        dwNumEntries++; 
 
        // create a name 
        wsprintf(szBuffer, TEXT("Activity %lu"), i); 
 
        // determine size of this entry 
        dwTotalSize += sizeof(LINEAGENTACTIVITYENTRY); 
        dwTotalSize += (lstrlen(szBuffer) + 1) * sizeof(TCHAR); 
    } 
 
    pActivityList->dwNeededSize = dwTotalSize; 
     
    // verify size 
    if (pActivityList->dwTotalSize < dwTotalSize) 
    { 
        pActivityList->dwUsedSize = sizeof(LINEAGENTACTIVITYLIST); 
 
        return 0; 
//        return LINEERR_STRUCTURETOOSMALL; 
    } 
 
    pActivityList->dwNumEntries = dwNumEntries; 
     
    // set list stuff 
    pActivityList->dwListSize = sizeof(LINEAGENTACTIVITYENTRY) * pActivityList->dwNumEntries; 
    pActivityList->dwListOffset = sizeof(LINEAGENTACTIVITYLIST); 
 
    // get first activityentry 
    pEntry = (LPLINEAGENTACTIVITYENTRY)(((LPBYTE)pActivityList) + pActivityList->dwListOffset); 
    dwNameOffset = pActivityList->dwListOffset + pActivityList->dwListSize; 
 
    // loop through activities again 
    for (i = 0; i < TOTALACTIVITIES; i++) 
    { 
        // fill in members 
        pEntry->dwID = i; 
 
        // create a name 
        wsprintf(szBuffer, TEXT("Activity %lu"), i); 
 
        pName = (LPTSTR)(((LPBYTE)pActivityList) + dwNameOffset); 
         
        pEntry->dwNameSize = (lstrlen(szBuffer) + 1) * sizeof(TCHAR); 
        pEntry->dwNameOffset = dwNameOffset; 
        lstrcpy(pName, 
                szBuffer); 
 
        dwNameOffset += pEntry->dwNameSize; 
         
        pEntry++; 
 
    } // for 
 
    // fill in used size 
    pActivityList->dwUsedSize = dwTotalSize; 
     
    return 0; 
} 
 
 
#define DWAGENTFEATURES         LINEAGENTFEATURE_SETAGENTGROUP | \ 
                                LINEAGENTFEATURE_SETAGENTSTATE | \ 
                                LINEAGENTFEATURE_SETAGENTACTIVITY | \ 
                                LINEAGENTFEATURE_GETAGENTACTIVITYLIST | \ 
                                LINEAGENTFEATURE_GETAGENTGROUP 
 
#define DWSTATES                LINEAGENTSTATE_LOGGEDOFF | \ 
                                LINEAGENTSTATE_NOTREADY | \ 
                                LINEAGENTSTATE_READY | \ 
                                LINEAGENTSTATE_BUSYACD | \ 
                                LINEAGENTSTATE_BUSYINCOMING | \ 
                                LINEAGENTSTATE_BUSYOUTBOUND | \ 
                                LINEAGENTSTATE_BUSYOTHER | \ 
                                LINEAGENTSTATE_WORKINGAFTERCALL | \ 
                                LINEAGENTSTATE_UNKNOWN | \ 
                                LINEAGENTSTATE_UNAVAIL 
 
#define DWNEXTSTATES            LINEAGENTSTATE_LOGGEDOFF | \ 
                                LINEAGENTSTATE_NOTREADY | \ 
                                LINEAGENTSTATE_READY | \ 
                                LINEAGENTSTATE_BUSYACD | \ 
                                LINEAGENTSTATE_BUSYINCOMING | \ 
                                LINEAGENTSTATE_BUSYOUTBOUND | \ 
                                LINEAGENTSTATE_BUSYOTHER | \ 
                                LINEAGENTSTATE_WORKINGAFTERCALL | \ 
                                LINEAGENTSTATE_UNKNOWN | \ 
                                LINEAGENTSTATE_UNAVAIL 
 
#define DWSTATUSMESSAGES        LINEAGENTSTATUS_GROUP | \ 
                                LINEAGENTSTATUS_STATE | \ 
                                LINEAGENTSTATUS_NEXTSTATE | \ 
                                LINEAGENTSTATUS_ACTIVITY | \ 
                                LINEAGENTSTATUS_ACTIVITYLIST | \ 
                                LINEAGENTSTATUS_GROUPLIST | \ 
                                LINEAGENTSTATUS_CAPSCHANGE | \ 
                                LINEAGENTSTATUS_VALIDSTATES | \ 
                                LINEAGENTSTATUS_VALIDNEXTSTATES 
 
 
//////////////////////////////////////////////////////////////////// 
// 
//  BOOL IsValidState(DWORD dwState) 
// 
//////////////////////////////////////////////////////////////////// 
BOOL IsValidState(DWORD dwState) 
{ 
    if (!dwState) 
    { 
        return TRUE; 
    } 
 
    if ((dwState) & (dwState - 1)) 
    { 
        // more than one bit set 
        return FALSE; 
    } 
 
    // make sure it's one of the valid states 
    return (dwState & DWSTATES); 
 
} 
 
 
//////////////////////////////////////////////////////////////////// 
// 
//  BOOL IsValidNextState(DWORD dwState) 
// 
//////////////////////////////////////////////////////////////////// 
BOOL IsValidNextState(DWORD dwState) 
{ 
    if (!dwState) 
    { 
        return TRUE; 
    } 
 
    if ((dwState) & (dwState - 1)) 
    { 
        // more than one bit set 
        return FALSE; 
    } 
 
    // make sure it's one of the valid states 
    return (dwState & DWNEXTSTATES); 
 
} 
 
 
/////////////////////////////////////////////////////////////////////// 
// 
//  BOOL IsValidActivityID(DWORD dwActivityID) 
// 
/////////////////////////////////////////////////////////////////////// 
BOOL IsValidActivityID(DWORD dwActivityID) 
{ 
    return (dwActivityID <= TOTALACTIVITIES); 
} 
 
 
 
//////////////////////////////////////////////////////////////////////// 
// 
//  LRESULT MakeAgentCaps(PAGENT pAgent, 
//                        LPLINEAGENTCAPS pAgentCaps) 
// 
//    Creates a LINEAGENTCAPS for pAgent 
//    Features/states/messages are hardcoded 
//     for this example 
// 
//////////////////////////////////////////////////////////////////////// 
LRESULT MakeAgentCaps(PAGENT pAgent, 
                      LPLINEAGENTCAPS pAgentCaps) 
{ 
    DWORD       dwStringSize; 
     
    dwStringSize = (lstrlen(SZAPPNAME) + 1) * sizeof(TCHAR); 
 
    pAgentCaps->dwNeededSize = sizeof(LINEAGENTCAPS) + dwStringSize; 
 
    if (pAgentCaps->dwTotalSize < pAgentCaps->dwNeededSize) 
    { 
        pAgentCaps->dwUsedSize = sizeof(LINEAGENTCAPS); 
        return 0; 
//        return LINEERR_STRUCTURETOOSMALL; 
    } 
 
     
    pAgentCaps->dwAgentHandlerInfoSize = dwStringSize; 
    pAgentCaps->dwAgentHandlerInfoOffset = sizeof(LINEAGENTCAPS); 
 
    pAgentCaps->dwCapsVersion = TAPI_CURRENT_VERSION; 
 
    // these features are hardcoded here. 
    // a real implementation may set specific features 
    // per agent or line or address 
    pAgentCaps->dwFeatures              = DWAGENTFEATURES; 
    pAgentCaps->dwStates                = DWSTATES; 
    pAgentCaps->dwNextStates            = DWNEXTSTATES; 
    pAgentCaps->dwMaxNumGroupEntries    = NUMGROUPENTRIES; 
    pAgentCaps->dwAgentStatusMessages   = DWSTATUSMESSAGES; 
 
    // no extensions 
    pAgentCaps->dwNumAgentExtensionIDs = 0; 
    pAgentCaps->dwAgentExtensionIDListSize = 0; 
    pAgentCaps->dwAgentExtensionIDListOffset = 0; 
 
 
    pAgentCaps->dwUsedSize = pAgentCaps->dwNeededSize; 
     
    return 0; 
} 
 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  LRESULT GetAgentStatus() 
// 
//  Creates a LINEAGENTSTATUS for pAgent 
// 
////////////////////////////////////////////////////////////////////////// 
LRESULT GetAgentStatus(PAGENT pAgent, 
                       DWORD dwAddress, 
                       LPLINEAGENTSTATUS pAgentStatus) 
{ 
    PGROUP                  pGroup; 
    LPLINEAGENTGROUPENTRY   pGroupEntry; 
    DWORD                   dwTotalSize, dwNameOffset, dwCount; 
    TCHAR                   szActivityName[NAMESIZE]; 
    PGROUP *                ppGroups; 
    PLISTITEM               pEntry; 
 
    // init total size 
    dwTotalSize = sizeof(LINEAGENTSTATUS); 
 
    if (dwAddress >= pAgent->dwNumAddresses) 
    { 
        return LINEERR_INVALADDRESSID; 
    } 
     
    // set know members 
    // for valid states / next states / agent features, just setting it to 
    // generic stuff.  a real implementation may want to set these 
    // field depending on current state / agent / hline 
    pAgentStatus->dwState           = pAgent->pAddressInfo[dwAddress].dwState; 
    pAgentStatus->dwNextState       = pAgent->pAddressInfo[dwAddress].dwNextState; 
    pAgentStatus->dwActivityID      = pAgent->pAddressInfo[dwAddress].dwActivity; 
    pAgentStatus->dwAgentFeatures   = DWAGENTFEATURES; 
    pAgentStatus->dwValidStates     = DWSTATES; 
    pAgentStatus->dwValidNextStates = DWNEXTSTATES; 
 
    // create the activity name 
    wsprintf(szActivityName, TEXT("Activity %lu"), pAgent->pAddressInfo[dwAddress].dwActivity); 
    dwTotalSize += (lstrlen(szActivityName) + 1) * sizeof(TCHAR); 
 
    ppGroups = (PGROUP *)ACDAlloc(sizeof(PGROUP) * g.dwNumGroups); 
 
    pGroup = g.pGroups; 
 
    pAgentStatus->dwNumEntries = 0; 
 
    // walk list of groups 
    while (pGroup) 
    { 
        pEntry = pGroup->pAgentList; 
 
        // walk each agent in each group 
        while (pEntry) 
        { 
            if (pEntry->pAgent == pAgent) 
            { 
                if ((!pEntry->bLoggedIn) || 
                    (pEntry->dwAddress != dwAddress)) 
                { 
                    break; 
                } 
 
                // save group 
                ppGroups[pAgentStatus->dwNumEntries] = pGroup; 
 
                // adjust total size / entries 
                pAgentStatus->dwNumEntries++; 
                dwTotalSize += sizeof(LINEAGENTGROUPENTRY); 
                dwTotalSize += (lstrlen(pGroup->lpszName) + 1) * sizeof(TCHAR); 
 
                break; 
            } 
 
            pEntry = pEntry->pNext; 
             
        }  // while (pEntry) 
 
        pGroup = pGroup->pNext; 
         
    } // while (pGroup) 
 
    // set needed size 
    pAgentStatus->dwNeededSize = dwTotalSize; 
 
    // do we have enough room? 
    if (pAgentStatus->dwTotalSize < dwTotalSize) 
    { 
        // if not, return 
        pAgentStatus->dwUsedSize = sizeof(LINEAGENTSTATUS); 
        ACDFree(ppGroups); 
 
        return 0; 
//        return LINEERR_STRUCTURETOOSMALL; 
    } 
 
 
    // set the group entries... 
 
    // first get the offset to the first entry 
    pGroupEntry = (LPLINEAGENTGROUPENTRY)(((LPBYTE)pAgentStatus) + sizeof(LINEAGENTSTATUS)); 
    pAgentStatus->dwGroupListOffset = sizeof(LINEAGENTSTATUS); 
 
    // figure out where the names can go (after all the fixed structures) 
    dwNameOffset = sizeof(LINEAGENTSTATUS) + 
                   sizeof(LINEAGENTGROUPENTRY) * pAgentStatus->dwNumEntries; 
 
    // loop through all the group that the agent is logged into 
    for (dwCount = 0; dwCount < pAgentStatus->dwNumEntries; dwCount++) 
    { 
        // set the it (just the pGroup) 
        pGroupEntry->GroupID.dwGroupID1 = (DWORD)ppGroups[dwCount]; 
        pGroupEntry->GroupID.dwGroupID2 = 0; 
        pGroupEntry->GroupID.dwGroupID3 = 0; 
        pGroupEntry->GroupID.dwGroupID4 = 0; 
 
        // set name size and offset 
        pGroupEntry->dwNameSize = (lstrlen(ppGroups[dwCount]->lpszName) + 1) * sizeof(TCHAR); 
        pGroupEntry->dwNameOffset = dwNameOffset; 
 
        // copy name 
        lstrcpy((LPTSTR)(((LPBYTE)pAgentStatus) + dwNameOffset), 
                ppGroups[dwCount]->lpszName); 
 
        // fix the name offset 
        dwNameOffset += pGroupEntry->dwNameSize; 
 
        // next entry 
        pGroupEntry++; 
         
    } 
 
    pAgentStatus->dwGroupListSize = dwNameOffset - pAgentStatus->dwGroupListOffset; 
     
    // put the activity name at the end 
    pAgentStatus->dwActivitySize = (lstrlen(szActivityName) + 1) * sizeof(TCHAR); 
    pAgentStatus->dwActivityOffset = dwNameOffset; 
 
    lstrcpy((LPTSTR)(((LPBYTE)pAgentStatus) + dwNameOffset), 
            szActivityName); 
 
     
    ACDFree(ppGroups); 
 
    pAgentStatus->dwUsedSize = pAgentStatus->dwNeededSize; 
    // return success 
    return 0; 
} 
 
 
///////////////////////////////////////////////////////////////////// 
// 
//  LRESULT SetAgentState() 
// 
//    Sets the current and next state for pAgent 
//    on that specific address 
// 
// 
///////////////////////////////////////////////////////////////////// 
LRESULT SetAgentState(PAGENT pAgent, 
                      DWORD dwAddress, 
                      DWORD dwState, 
                      DWORD dwNextState) 
{ 
    // make sure valid 
    if ((!IsValidState(dwState)) || 
        (!IsValidNextState(dwNextState))) 
    { 
        return LINEERR_INVALAGENTSTATE; 
    } 
 
    // check address 
    if (dwAddress >= pAgent->dwNumAddresses) 
    { 
        return LINEERR_INVALADDRESSID; 
    } 
 
    // set the state if specified 
    if (dwState) 
    { 
        pAgent->pAddressInfo[dwAddress].dwState = dwState; 
    } 
 
    if (dwNextState) 
    { 
        pAgent->pAddressInfo[dwAddress].dwNextState = dwNextState; 
    } 
     
    return 0; 
} 
 
 
/////////////////////////////////////////////////////////////////////////////// 
// 
//  LRESULT SetAgentActivity() 
// 
//   Sets the activity for pAgent 
// 
/////////////////////////////////////////////////////////////////////////////// 
LRESULT SetAgentActivity(PAGENT pAgent, 
                         DWORD dwAddress, 
                         DWORD dwActivityID) 
{ 
    if (dwAddress >= pAgent->dwNumAddresses) 
    { 
        return LINEERR_INVALADDRESSID; 
    } 
 
    if (!IsValidActivityID(dwActivityID)) 
    { 
        return LINEERR_INVALAGENTACTIVITY; 
    } 
 
    pAgent->pAddressInfo[dwAddress].dwActivity = dwActivityID; 
     
    return 0; 
} 
 
 
//////////////////////////////////////////////////////////////////////////////// 
// 
//  BOOL HandleOffering(HCALL hCall) 
// 
//    Handles a LINECALLSTATE_OFFERING message 
//      Determines the group associated with the address 
//      that the call came in on, finds an available 
//      agent in that group, and transfers the call to that 
//      agent. 
// 
//////////////////////////////////////////////////////////////////////////////// 
BOOL HandleOffering(HCALL hCall) 
{ 
    LPLINECALLINFO      pLCI; 
    PGROUP              pGroup; 
    PLISTITEM           pEntry; 
    LONG                lResult; 
     
    pLCI = LineGetCallInfo(hCall); 
 
    if (!pLCI) 
    { 
        return FALSE; 
    } 
 
    pGroup = g.pGroups; 
 
    // find the group that this call came in on 
    // walk all the groups 
    while (pGroup) 
    { 
        // if the line and address match, it's the 
        // correct address 
        if ((pGroup->hLine == pLCI->hLine) && 
            (pGroup->dwAddress == pLCI->dwAddressID)) 
        { 
            break; 
        } 
 
        pGroup = pGroup->pNext; 
    } 
 
    // couldn't find the group 
    if (!pGroup) 
    { 
        // error! 
        ACDFree(pLCI); 
        return FALSE; 
    } 
 
    // OK - found the group that this call is for.  Now transfer to 
    // an agent that is available. 
    pEntry = pGroup->pAgentList; 
 
    while (pEntry) 
    { 
        if (pEntry->bLoggedIn && 
            (pEntry->pAgent->pAddressInfo[pEntry->dwAddress].dwState == 
                LINEAGENTSTATE_READY)) 
        { 
            // found someone 
            // doing a blind transfer here 
            // other implementations may need to 
            // do lineSetupTransfer / lineDial / lineCompleteTransfer 
            if (lResult = lineBlindTransfer(hCall, 
                                            (LPCWSTR)pEntry->pAgent->lpszNumber, 
                                            0)) 
            { 
                //LogTapiError(TEXT("lineBlindTransfer"), lResult); 
                // don't break - try the next agent 
            } 
            else 
            { 
                // set the state to reflect that 
                // a call is being handled 
                SetAgentState(pEntry->pAgent, 
                              pEntry->dwAddress, 
                              LINEAGENTSTATE_BUSYACD, 
                              LINEAGENTSTATE_READY); 
 
                break; 
            } 
 
        } 
         
        pEntry = pEntry->pNext; 
    } 
 
    if (!pEntry) 
    { 
        // couldn't find an available agent 
 
        // NOTE! NOTE! NOTE! NOTE! NOTE! 
        // something should be done here with this call.  put into 
        // a queue on hold or something.  For this sample, we are just 
        // ignoring it 
    } 
 
    ACDFree(pLCI); 
 
    return TRUE; 
} 
 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  BOOL HandleIdle(HCALL hCall) 
// 
//    Handles LINECALLSTATE_IDLE 
//     Should always always always deallocate when 
//     getting an IDLE message.  Also, determine if this is a call 
//     that we know about and set the agent state appropriatly 
// 
////////////////////////////////////////////////////////////////////////// 
BOOL HandleIdle(HCALL hCall) 
{ 
    LPLINECALLINFO      pLCI; 
    PAGENT              pAgent; 
 
    pLCI = LineGetCallInfo(hCall); 
 
    // always deallocate the call 
    lineDeallocateCall(hCall); 
 
    if (!pLCI) 
    { 
        return FALSE; 
    } 
 
    // get the agent associated with the line 
    pAgent = GetAgentFromhLine(pLCI->hLine); 
 
    if (!pAgent) 
    { 
        ACDFree(pLCI); 
        return FALSE; 
    } 
               
 
    // set that agent to their next state 
    // Assumption:  only calls that the ACD app know about 
    // occur.  For example, if an agent made an outgoing call 
    // and it transitioned to idle, this code would still be executed. 
    // May make more sense to not handle NextState in the ACD app, and let 
    // the client app handle it. 
    SetAgentState(pAgent, 
                  pLCI->dwAddressID, 
                  pAgent->pAddressInfo[pLCI->dwAddressID].dwNextState, 
                  0); 
 
    ACDFree(pLCI); 
     
    return TRUE; 
     
} 
 
 
//////////////////////////////////////////////////////////////////////////// 
// 
//  void HandleLineProxyRequest(HLINE hLine, 
//                              LPLINEPROXYREQUEST pProxyRequest) 
// 
//    Handles LINE_PROXYREQUEST message 
//     Just dispatches to appropriate functions 
// 
//////////////////////////////////////////////////////////////////////////// 
void HandleLineProxyRequest(HLINE hLine, 
                            LPLINEPROXYREQUEST pProxyRequest) 
{ 
    PAGENT       pAgent; 
    LRESULT      lResult; 
 
    pAgent = GetAgentFromName((LPTSTR)(((LPBYTE)pProxyRequest) + 
                                       pProxyRequest->dwClientUserNameOffset)); 
     
    if (!pAgent) 
    { 
        lineProxyResponse(hLine, 
                          pProxyRequest, 
                          LINEERR_INVALAGENTID); 
 
        return; 
    } 
     
    switch (pProxyRequest->dwRequestType) 
    { 
        case LINEPROXYREQUEST_SETAGENTGROUP: 
 
            lResult = SetGroupList(pAgent, 
                                   pProxyRequest->SetAgentGroup.dwAddressID, 
                                   &pProxyRequest->SetAgentGroup.GroupList); 
 
            lineProxyResponse(hLine, 
                              pProxyRequest, 
                              lResult); 
 
            return; 
             
        case LINEPROXYREQUEST_SETAGENTSTATE: 
 
            lResult = SetAgentState(pAgent, 
                                    pProxyRequest->SetAgentState.dwAddressID, 
                                    pProxyRequest->SetAgentState.dwAgentState, 
                                    pProxyRequest->SetAgentState.dwNextAgentState); 
 
            lineProxyResponse(hLine, 
                              pProxyRequest, 
                              lResult); 
             
            break; 
             
        case LINEPROXYREQUEST_SETAGENTACTIVITY: 
 
            lResult = SetAgentActivity(pAgent, 
                                       pProxyRequest->SetAgentActivity.dwAddressID, 
                                       pProxyRequest->SetAgentActivity.dwActivityID); 
 
            lineProxyResponse(hLine, 
                              pProxyRequest, 
                              lResult); 
             
            break; 
             
        case LINEPROXYREQUEST_GETAGENTSTATUS: 
 
            lResult = GetAgentStatus(pAgent, 
                                     pProxyRequest->GetAgentStatus.dwAddressID, 
                                     &pProxyRequest->GetAgentStatus.AgentStatus); 
 
            lineProxyResponse(hLine, 
                              pProxyRequest, 
                              lResult); 
             
            break; 
             
        case LINEPROXYREQUEST_GETAGENTCAPS: 
 
            if ((hLine == pAgent->hLine) && 
                (pProxyRequest->GetAgentCaps.dwAddressID < pAgent->dwNumAddresses)) 
            { 
                lResult = MakeAgentCaps(pAgent, 
                                        &pProxyRequest->GetAgentCaps.AgentCaps); 
            } 
            else 
            { 
                lResult = LINEERR_BADDEVICEID; 
            } 
 
            lineProxyResponse(hLine, 
                              pProxyRequest, 
                              lResult); 
            break; 
             
        case LINEPROXYREQUEST_GETAGENTACTIVITYLIST: 
 
            lResult = MakeAgentActivityList(pAgent, 
                                            &pProxyRequest->GetAgentActivityList.ActivityList); 
 
            lineProxyResponse(hLine, 
                              pProxyRequest, 
                              lResult); 
             
            break; 
             
        case LINEPROXYREQUEST_GETAGENTGROUPLIST: 
 
            lResult = MakeGroupList(pAgent, 
                                    &pProxyRequest->GetAgentGroupList.GroupList); 
 
            lineProxyResponse(hLine, 
                              pProxyRequest, 
                              lResult); 
            return; 
             
 
    } 
    return; 
} 
 
///////////////////////////////////////////////////////////// 
// 
//  void HandleLineCallState(DWORD dwDevice, 
// 
//  Handles callstate messages we are interested in 
// 
///////////////////////////////////////////////////////////// 
void HandleLineCallState(DWORD dwDevice, 
                         DWORD dwParam1, 
                         DWORD dwParam2, 
                         DWORD dwParam3) 
{ 
    switch (dwParam1) 
    { 
    case LINECALLSTATE_OFFERING: 
    { 
        LPLINECALLSTATUS        pLCS; 
 
        // get the call privilege. 
        // NOTE:  the new LINE_APPNEWCALL message notifies applications 
        // of their priv for new calls not created by app 
        pLCS = LineGetCallStatus((HCALL)dwDevice); 
        if (!pLCS) 
        { 
            break; 
        } 
         
        if (pLCS->dwCallPrivilege & LINECALLPRIVILEGE_OWNER) 
        { 
            HandleOffering((HCALL)dwDevice); 
        } 
 
        ACDFree(pLCS); 
         
        break; 
    } 
    case LINECALLSTATE_CONNECTED: 
        break; 
 
    case LINECALLSTATE_DISCONNECTED: 
        break; 
 
    case LINECALLSTATE_IDLE: 
 
        HandleIdle((HCALL)dwDevice); 
         
        break; 
 
    case LINECALLSTATE_BUSY: 
        break; 
 
    default: 
        break; 
    } 
} 
 
 
/////////////////////////////////////////////////////////////////////// 
// TAPI message handlers.  For this sample, they don't 
// do anything 
/////////////////////////////////////////////////////////////////////// 
void HandleLineDevState(DWORD dwParam1, 
                        DWORD dwParam2, 
                        DWORD dwParam3) 
{ 
} 
 
 
void HandleLineReply(DWORD dwParam1, 
                     DWORD dwParam2, 
                     DWORD dwParam3) 
{ 
} 
void HandleLineCallInfo(DWORD dwParam1, 
                             DWORD dwParam2, 
                             DWORD dwParam3) 
{ 
} 
 
void HandleLineClose(DWORD dwParam1, 
                          DWORD dwParam2, 
                          DWORD dwParam3) 
{ 
} 
 
 
////////////////////////////////////////////////////////////////////////////////// 
// 
// LineCallback() - TAPI callback function 
// 
////////////////////////////////////////////////////////////////////////////////// 
VOID CALLBACK LineCallback (DWORD hDevice, 
                            DWORD dwMsg, 
                            DWORD dwCallbackInstance,  
                            DWORD dwParam1, 
                            DWORD dwParam2,  
                            DWORD dwParam3) 
{ 
    switch(dwMsg) 
    { 
      case LINE_PROXYREQUEST: 
           HandleLineProxyRequest((HLINE) hDevice, 
                                  (LPLINEPROXYREQUEST)dwParam1); 
           return; 
            
      case LINE_LINEDEVSTATE: 
          HandleLineDevState(dwParam1, 
                             dwParam2, 
                             dwParam3); 
          return; 
      case LINE_REPLY: 
          HandleLineReply(dwParam1, 
                          dwParam2, 
                          dwParam3); 
          return; 
      case LINE_CALLSTATE: 
          HandleLineCallState(hDevice, 
                              dwParam1, 
                              dwParam2, 
                              dwParam3); 
          return;  
      case LINE_CALLINFO: 
          HandleLineCallInfo(dwParam1, 
                             dwParam2, 
                             dwParam3); 
          return; 
      case LINE_CLOSE: 
          HandleLineClose(dwParam1, 
                          dwParam2, 
                          dwParam3); 
          return; 
 
      default: 
          return; 
   } 
}