www.pudn.com > ppc_Cellcore.rar > extapi.cpp

// 
// Copyright (c) Microsoft Corporation.  All rights reserved. 
// 
// 
// Use of this source code is subject to the terms of the Microsoft end-user 
// license agreement (EULA) under which you licensed this SOFTWARE PRODUCT. 
// If you did not accept the terms of the EULA, you are not authorized to use 
// this source code. For a copy of the EULA, please see the LICENSE.RTF on your 
// install media. 
// 
/* 
   ExTAPI.CPP 
   
   Sample that demonstrates some functionality of ExTAPI. 
   NOTE: ExTAPI is a privileged API and any application using it must 
   be signed using a priviliged certificate. 
 
*/ 
 
 
#include  
#include  
#include  
#include  
#include  
#include "resource.h" 
 
 
// some definitons 
#define ARRAY_LENGTH(x)         (sizeof(x)/sizeof((x)[0])) 
#define TAPI_API_LOW_VERSION    0x00020000 
#define TAPI_API_HIGH_VERSION   0x00020000 
#define EXT_API_LOW_VERSION     0x00010000 
#define EXT_API_HIGH_VERSION    0x00010000 
#define HUGE_BUFFER             4096 
 
// global variables 
HINSTANCE   g_hInstance; 
// Friendly application name passed to ExTAPI. 
// This is loaded from a STRINGTABLE in the program resources 
// to help enable internationalisation. 
TCHAR gszFriendlyAppName[160];  
 
// function declarations 
BOOL GetExTAPIInfo(); 
DWORD GetTSPLineDeviceID(const HLINEAPP hLineApp, const DWORD dwNumberDevices,  
                         const DWORD dwAPIVersionLow, const DWORD dwAPIVersionHigh,  
                         const TCHAR* const psTSPLineName); 
 
// *************************************************************************** 
// Function Name: WinMain 
// 
// Purpose: Main entry point into the ExTAPI program 
// 
// Arguments: Standard WinMain arguments 
// 
// Return Values: TRUE 
// 
// Description: 
//  This WinMain simply calls GetExTAPIInfo, which pops up a MessageBox 
 
int WINAPI WinMain (HINSTANCE hInstance, 
                    HINSTANCE hPreviousInstance, 
                    LPWSTR pszCommandLine, 
                    int nCommandShow) 
{ 
    // store the hInstance 
    g_hInstance = hInstance; 
     
    // Get the friendly application name from the STRINGTABLE 
    LoadString(g_hInstance, IDS_FRIENDLYNAME,  
               gszFriendlyAppName, ARRAY_LENGTH(gszFriendlyAppName));  
 
    // pop up a message box with general info 
    if (!GetExTAPIInfo())  
    { 
        TCHAR szCGI[160];  
        LoadString(g_hInstance, IDS_CANTGETINFO, szCGI, ARRAY_LENGTH(szCGI));  
        MessageBox(NULL, szCGI, gszFriendlyAppName, MB_OK | MB_ICONERROR); 
    } 
 
    return TRUE; 
} 
 
// *************************************************************************** 
// Function Name: GetExTAPIInfo 
// 
// Purpose: To get and display general ExTAPI information. 
// 
// Arguments: None 
// 
// Return Values:  
//  TRUE if all ExTAPI operations completed successfully, FALSE otherwise 
// 
// Description: 
//  This function initializes ExTAPI and then calls lineGetGeneralInfo. 
//  It then takes the info that lGGI returned and displays it in a MessageBox 
 
BOOL GetExTAPIInfo() 
{ 
    DWORD dwNumDevs; 
    DWORD dwAPIVersion = TAPI_API_HIGH_VERSION; 
    LINEINITIALIZEEXPARAMS liep; 
    HLINEAPP hLineApp = 0; 
    HLINE hLine = 0; 
    DWORD dwExtVersion; 
    TCHAR szMBString[HUGE_BUFFER]; 
    BOOL bRetVal = FALSE; 
    LPBYTE pLineGeneralInfoBytes = NULL; 
    DWORD dwTAPILineDeviceID; 
    const DWORD dwMediaMode = LINEMEDIAMODE_DATAMODEM | LINEMEDIAMODE_INTERACTIVEVOICE; 
    LINEGENERALINFO lviGeneralInfo; 
    LPLINEGENERALINFO plviGeneralInfo; 
    LPTSTR tsManufacturer, tsModel, tsRevision, tsSerialNumber, tsSubscriberNumber; 
    TCHAR szUnavailable[160];  
 
    // Load text from STRINGTABLE 
    LoadString(g_hInstance, IDS_UNAVAILABLE, szUnavailable, ARRAY_LENGTH(szUnavailable));  
 
    // set the line init params 
    liep.dwTotalSize = sizeof(liep); 
    liep.dwOptions = LINEINITIALIZEEXOPTION_USEEVENT; 
     
    if (lineInitializeEx(&hLineApp, 0, 0, gszFriendlyAppName,  
                         &dwNumDevs, &dwAPIVersion, &liep))  
    { 
        goto cleanup; 
    } 
 
    // get the device ID 
    dwTAPILineDeviceID = GetTSPLineDeviceID(hLineApp, dwNumDevs,  
                                                  TAPI_API_LOW_VERSION,  
                                                  TAPI_API_HIGH_VERSION,  
                                                  CELLTSP_LINENAME_STRING); 
 
    // error getting the line device ID? 
    if (0xffffffff == dwTAPILineDeviceID)  
    { 
        goto cleanup; 
    } 
 
    // now try and open the line 
    if(lineOpen(hLineApp, dwTAPILineDeviceID,  
                &hLine, dwAPIVersion, 0, 0,  
                LINECALLPRIVILEGE_OWNER, dwMediaMode, 0))  
    { 
        goto cleanup; 
    } 
 
    // set up ExTAPI 
    if (lineNegotiateExtVersion(hLineApp, dwTAPILineDeviceID,  
                                dwAPIVersion, EXT_API_LOW_VERSION,  
                                EXT_API_HIGH_VERSION, &dwExtVersion))  
    { 
        goto cleanup; 
    } 
 
    // try to get the general info 
    lviGeneralInfo.dwTotalSize = sizeof(lviGeneralInfo); 
 
    // step 1: find out how much space we need 
    if (lineGetGeneralInfo(hLine, &lviGeneralInfo))  
    { 
        goto cleanup; 
    } 
 
    // step 2: malloc space for all the info we need 
    pLineGeneralInfoBytes = new BYTE[lviGeneralInfo.dwNeededSize]; 
    plviGeneralInfo = (LPLINEGENERALINFO)pLineGeneralInfoBytes; 
 
    // step 3: call lGGI again with the appropriately sized buffer 
    if(NULL != pLineGeneralInfoBytes)  
    { 
        plviGeneralInfo->dwTotalSize = lviGeneralInfo.dwNeededSize; 
        if (lineGetGeneralInfo(hLine, plviGeneralInfo))  
        { 
            goto cleanup; 
        } 
    } else  
    { 
        goto cleanup; 
    } 
 
    // step 4: cast all the arguments to strings 
    if(0 < plviGeneralInfo->dwManufacturerSize) 
    {  
        tsManufacturer = (WCHAR*)(((BYTE*)plviGeneralInfo)+plviGeneralInfo->dwManufacturerOffset); 
    } 
    else 
    { 
        tsManufacturer = szUnavailable; 
    } 
 
    if(0 < plviGeneralInfo->dwModelSize) 
    {  
        tsModel = (WCHAR*)(((BYTE*)plviGeneralInfo)+plviGeneralInfo->dwModelOffset); 
    } 
    else 
    { 
        tsModel = szUnavailable; 
    } 
 
    if(0 < plviGeneralInfo->dwRevisionSize) 
    { 
        tsRevision = (WCHAR*)(((BYTE*)plviGeneralInfo)+plviGeneralInfo->dwRevisionOffset); 
    } 
    else 
    { 
        tsRevision = szUnavailable; 
    } 
 
    if(0 < plviGeneralInfo->dwSerialNumberSize) 
    { 
        tsSerialNumber = (WCHAR*)(((BYTE*)plviGeneralInfo)+plviGeneralInfo->dwSerialNumberOffset); 
    } 
    else 
    { 
        tsSerialNumber = szUnavailable; 
    } 
 
    if(0 < plviGeneralInfo->dwSubscriberNumberSize) 
    { 
        tsSubscriberNumber = (WCHAR*)(((BYTE*)plviGeneralInfo)+plviGeneralInfo->dwSubscriberNumberOffset); 
    } 
    else 
    { 
        tsSubscriberNumber = szUnavailable; 
    } 
    // create the message box string. 
    //  
    { 
        TCHAR szManufacturer[80];  
        TCHAR szModel[80];  
        TCHAR szRevision[80]; 
        TCHAR szSerialNumber[80]; 
        TCHAR szSubscriberNumber[80]; 
 
        LoadString(g_hInstance, IDS_MANUFACTURER, szManufacturer, ARRAY_LENGTH(szManufacturer));  
        LoadString(g_hInstance, IDS_MODEL, szModel, ARRAY_LENGTH(szModel));  
        LoadString(g_hInstance, IDS_REVISION, szRevision, ARRAY_LENGTH(szRevision));  
        LoadString(g_hInstance, IDS_SERIALNUMBER, szSerialNumber, ARRAY_LENGTH(szSerialNumber));  
        LoadString(g_hInstance, IDS_SUBSCRIBERNUMBER, szSubscriberNumber, ARRAY_LENGTH(szSubscriberNumber));  
 
        _sntprintf(szMBString, ARRAY_LENGTH(szMBString), 
                   TEXT("%s: %s\n%s: %s\n%s: %s\n%s: %s\n%s: %s\n"), 
                   szManufacturer, tsManufacturer,  
                   szModel, tsModel,  
                   szRevision, tsRevision,  
                   szSerialNumber, tsSerialNumber,  
                   szSubscriberNumber, tsSubscriberNumber); 
    } 
    // pop up the message box 
    { 
        TCHAR szExTapiLineInfo[80]; 
        LoadString(g_hInstance, IDS_EXTAPILINEINFO, szExTapiLineInfo, ARRAY_LENGTH(szExTapiLineInfo));  
        MessageBox(NULL, szMBString, szExTapiLineInfo, MB_OK | MB_ICONINFORMATION); 
    } 
    bRetVal = TRUE; 
 
cleanup: 
    if (pLineGeneralInfoBytes) delete [] pLineGeneralInfoBytes; 
    if (hLine) lineClose(hLine); 
    if (hLineApp) lineShutdown(hLineApp); 
 
    return bRetVal; 
} 
 
// *************************************************************************** 
// Function Name: GetTSPLineDeviceID 
// 
// Purpose: To get a TSP Line Device ID 
// 
// Arguments: 
//  hLineApp = the HLINEAPP returned by lineInitializeEx 
//  dwNumberDevices = also returned by lineInitializeEx 
//  dwAPIVersionLow/High = min version of TAPI that we need 
//  psTSPLineName = "Cellular Line" 
// 
// Return Values: Current Device ID 
// 
// Description: 
//  This function returns the device ID of a named TAPI TSP.  The Device ID is  
//  used in the call to lineOpen 
 
DWORD GetTSPLineDeviceID(const HLINEAPP hLineApp,  
                         const DWORD dwNumberDevices,  
                         const DWORD dwAPIVersionLow,  
                         const DWORD dwAPIVersionHigh,  
                         const TCHAR* const psTSPLineName) 
{ 
    DWORD dwReturn = 0xffffffff; 
    for(DWORD dwCurrentDevID = 0 ; dwCurrentDevID < dwNumberDevices ; dwCurrentDevID++) 
    { 
        DWORD dwAPIVersion; 
        LINEEXTENSIONID LineExtensionID; 
        if(0 == lineNegotiateAPIVersion(hLineApp, dwCurrentDevID,  
                                        dwAPIVersionLow, dwAPIVersionHigh,  
                                        &dwAPIVersion, &LineExtensionID))  
        { 
            LINEDEVCAPS LineDevCaps; 
            LineDevCaps.dwTotalSize = sizeof(LineDevCaps); 
            if(0 == lineGetDevCaps(hLineApp, dwCurrentDevID,  
                                   dwAPIVersion, 0, &LineDevCaps))  
            { 
                BYTE* pLineDevCapsBytes = new BYTE[LineDevCaps.dwNeededSize]; 
                if(0 != pLineDevCapsBytes)  
                { 
                    LINEDEVCAPS* pLineDevCaps = (LINEDEVCAPS*)pLineDevCapsBytes; 
                    pLineDevCaps->dwTotalSize = LineDevCaps.dwNeededSize; 
                    if(0 == lineGetDevCaps(hLineApp, dwCurrentDevID,  
                                           dwAPIVersion, 0, pLineDevCaps))  
                    { 
                        if(0 == _tcscmp((TCHAR*)((BYTE*)pLineDevCaps+pLineDevCaps->dwLineNameOffset),  
                                        psTSPLineName))  
                        { 
                            dwReturn = dwCurrentDevID; 
                        } 
                    } 
                    delete[]  pLineDevCapsBytes; 
                } 
            } 
        } 
    } 
    return dwReturn; 
}