able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/printscan/fax/exchange/ab/util.c

1075 lines
33 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*
- util.c
-
* Microsoft At Work Fax Messaging Address Book
*
* Revision History:
*
* When Who What
* -------- ------------------ ---------------------------------------
* 7.24.96 Rick Turner ported from old code in fax tree
*
*/
/* ***************************************************************************/
/* inculde files */
#include "faxab.h"
/*******************************
**** Utility Functions ****
*******************************/
// ***************************************************************************
// GetCurrentLocationAreaCode *
// Get the area code for the current location *
// returns: the area code of the current location or "" if error *
//
TCHAR g_szAreaCode[ AREA_CODE_SIZE ];
DWORD g_dwTlsIndex; // index for private thread storage
LPTSTR GetCurrentLocationAreaCode()
{
LPLINETRANSLATECAPS lpLineTransCaps;
DWORD lResult, dwNumLocs;
LPLINELOCATIONENTRY lplle, lplleCur;
g_szAreaCode[0] = 0;
/* allocate buffer */
lpLineTransCaps = (LPLINETRANSLATECAPS)LocalAlloc(LPTR, 1024 );
if (!lpLineTransCaps)
{
goto err;
}
lpLineTransCaps->dwTotalSize = 1024;
/* try to get TranslateCaps */
lResult = lineGetTranslateCaps( NULL, TAPI_CURRENT_VERSION, lpLineTransCaps);
if (lResult != NO_ERROR)
{
goto err;
}
/* reallocate buffer if not big enough */
while (lpLineTransCaps->dwNeededSize > lpLineTransCaps->dwTotalSize)
{
DWORD lcbNeeded = lpLineTransCaps->dwNeededSize;
LocalFree(lpLineTransCaps);
lpLineTransCaps = (LPLINETRANSLATECAPS)LocalAlloc(LPTR, lcbNeeded);
if (!lpLineTransCaps)
{
goto err;
}
lpLineTransCaps->dwTotalSize = lcbNeeded;
/* try one more time */
lResult = lineGetTranslateCaps( NULL, TAPI_CURRENT_VERSION, lpLineTransCaps);
if (lResult != NO_ERROR)
{
goto err;
}
} /* while */
dwNumLocs = lpLineTransCaps->dwNumLocations;
// get the name and area code of the current location
lplle = (LPLINELOCATIONENTRY)((LPBYTE)(lpLineTransCaps) + lpLineTransCaps->dwLocationListOffset);
lplleCur = lplle;
while (dwNumLocs-- && lplleCur->dwPermanentLocationID != lpLineTransCaps->dwCurrentLocationID)
++lplleCur;
// Save the current location information
lstrcpyn( g_szAreaCode,
(LPTSTR)((LPBYTE)(lpLineTransCaps) + lplleCur->dwCityCodeOffset),
min(ARRAYSIZE(g_szAreaCode),lplleCur->dwCityCodeSize)
);
LocalFree( lpLineTransCaps );
return g_szAreaCode;
err:
if (lpLineTransCaps != NULL)
LocalFree(lpLineTransCaps);
return NULL;
} /* GetCurrentLocationAreaCode */
// ***************************************************************************
// GetCurrentLocationCountryID *
// Get the area code for the current location *
// returns: the country ID for the current location or 0 if error
//
DWORD GetCurrentLocationCountryID()
{
LPLINETRANSLATECAPS lpLineTransCaps;
DWORD lResult, dwNumLocs, dwCountryID;
LPLINELOCATIONENTRY lplle, lplleCur;
/* allocate buffer */
lpLineTransCaps = (LPLINETRANSLATECAPS)LocalAlloc(LPTR, 1024 );
if (!lpLineTransCaps)
{
goto err;
}
lpLineTransCaps->dwTotalSize = 1024;
/* try to get TranslateCaps */
lResult = lineGetTranslateCaps( NULL, TAPI_CURRENT_VERSION, lpLineTransCaps);
if (lResult != NO_ERROR)
{
goto err;
}
/* reallocate buffer if not big enough */
while (lpLineTransCaps->dwNeededSize > lpLineTransCaps->dwTotalSize)
{
DWORD lcbNeeded = lpLineTransCaps->dwNeededSize;
LocalFree(lpLineTransCaps);
lpLineTransCaps = (LPLINETRANSLATECAPS)LocalAlloc(LPTR, lcbNeeded);
if (!lpLineTransCaps)
{
goto err;
}
lpLineTransCaps->dwTotalSize = lcbNeeded;
/* try one more time */
lResult = lineGetTranslateCaps( NULL, TAPI_CURRENT_VERSION, lpLineTransCaps);
if (lResult != NO_ERROR)
{
goto err;
}
} /* while */
dwNumLocs = lpLineTransCaps->dwNumLocations;
// get the name and area code of the current location
lplle = (LPLINELOCATIONENTRY)((LPBYTE)(lpLineTransCaps) + lpLineTransCaps->dwLocationListOffset);
lplleCur = lplle;
while (dwNumLocs-- && lplleCur->dwPermanentLocationID != lpLineTransCaps->dwCurrentLocationID)
++lplleCur;
dwCountryID = lplleCur->dwCountryID;
LocalFree( lpLineTransCaps );
return dwCountryID;
err:
if (lpLineTransCaps != NULL)
LocalFree(lpLineTransCaps);
return 0;
} /* GetCurrentLocationCountryID */
/* ***************************************************************************
* GetCountry
*
* - gets the a country or a country list from TAPI
*
* Parameters: dwReqCountryID - a TAPI country ID. 0 for all countries
*
* Returns: TRUE on success, FALSE on failure.
*/
#define SIZE_OF_ONE_COUNTRY_BUFFER 150 // current number is 110
#define SIZE_OF_ALL_COUNTRIES_BUFFER 17000 // current number is 15694
BOOL GetCountry(DWORD dwReqCountryID, LPLINECOUNTRYLIST *lppLineCountryList)
{
ULONG ulMemNeeded;
WORD i;
LONG lError = NO_ERROR;
LPLINECOUNTRYLIST lpLineCountryList = NULL;
BOOL bResult = TRUE;
// See what size of a buffer I need to allocate
ulMemNeeded = (dwReqCountryID ? SIZE_OF_ONE_COUNTRY_BUFFER : SIZE_OF_ALL_COUNTRIES_BUFFER);
// Try to allocate buffer and call lineGetCountry twice
// If this does not work, allocate a buffer of the size
// requested by TAPI and try again
for (i=0; i < 2; i++)
{
// Allocate memory for the LINECOUNTRYLIST structure
lpLineCountryList = (LPLINECOUNTRYLIST)LocalAlloc( LPTR, ulMemNeeded );
if (!lpLineCountryList)
{
DEBUG_TRACE("GetCountry: could not alloc buffer(%d) for LPLINECOUNTRYLIST\n", i);
goto err;
}
// Set the size of the provided buffer for TAPI
lpLineCountryList->dwTotalSize = ulMemNeeded;
// Get the country inofmration for the requested country
lError = lineGetCountry(dwReqCountryID, TAPI_CURRENT_VERSION, lpLineCountryList);
// I give up if error and it's not because the structure passed in was too small
if ( (lError != NO_ERROR) &&
(lError != LINEERR_STRUCTURETOOSMALL) &&
// Remove next line after TAPI fixes bug
(lError != LINEERR_NOMEM)
)
{
DEBUG_TRACE("GetCountry: lineGetCountry returned error %lx\n", lError);
goto err;
}
// If I didn't get it all, free the buffer and try again with bigger size buffer
if (lpLineCountryList->dwNeededSize > lpLineCountryList->dwTotalSize)
{
// +1 is due to TAPI bug. Exactly won't work
ulMemNeeded = lpLineCountryList->dwNeededSize+1;
LocalFree(lpLineCountryList);
}
else // got it
break;
}
// should have valid lpLineCountryList here
if (lError != NO_ERROR)
goto err;
DEBUG_TRACE("GetCountry: %lx of the buffer used\n", lpLineCountryList->dwUsedSize);
out:
*lppLineCountryList = lpLineCountryList;
return bResult;
err:
// Free the buffer
if (lpLineCountryList)
LocalFree( lpLineCountryList );
lpLineCountryList = NULL;
bResult = FALSE;
goto out;
} /* GetCountry */
/* ***************************************************************************
* GetCountryCode
*
* - gets a country code when given a country ID
*
* Parameters: dwReqCountryID - a TAPI country ID
* lpdwCountryCode - an address of a DWORD in which to store the country code
*
* Returns: TRUE on success, FALSE on failure.
*/
BOOL GetCountryCode(DWORD dwReqCountryID, DWORD *lpdwCountryCode)
{
ULONG country;
LPLINECOUNTRYLIST lpLineCountryList = NULL;
LPLINECOUNTRYENTRY lprgLineCountryEntry = NULL;
BOOL bResult = FALSE;
// Get the country info structure from TAPI
if (!GetCountry(dwReqCountryID, &lpLineCountryList))
goto out;
// Point to the first country in the structure
lprgLineCountryEntry =
(LPLINECOUNTRYENTRY)((LPBYTE)(lpLineCountryList)
+ lpLineCountryList->dwCountryListOffset);
// Loop through LINECOUNTRYENTRY structures and look for the country ID.
for (country=0; country < lpLineCountryList->dwNumCountries; country++)
if ( (lprgLineCountryEntry[country].dwCountryNameSize != 0) &&
(lprgLineCountryEntry[country].dwCountryNameOffset != 0)
)
{
DWORD dwCountryCode = lprgLineCountryEntry[country].dwCountryCode;
DWORD dwCountryID = lprgLineCountryEntry[country].dwCountryID;
// If this is the requested country, get its country code
if (dwCountryID == dwReqCountryID)
{
*lpdwCountryCode = dwCountryCode;
bResult = TRUE;
break;
}
}
out:
// Free the buffer
if (lpLineCountryList)
LocalFree( lpLineCountryList );
if (!bResult)
*lpdwCountryCode = 1; // U.S.
return bResult;
} /* GetCountryCode */
/****************************************************************************
FUNCTION: MakeMessageBox
PURPOSE: Gets resource string and displays an error message box.
PARAMETERS: hInst - Instnace of the caller (for getting strings)
hWnd - Handle to parent window
ulResult - Result/Status code
0: information message
100-499: warning message
500 and up: error message
idString - Resource ID of message in StringTable
fStyle - style of the message box
RETURNS: the return value from MessageBox() function
****************************************************************************/
int MakeMessageBox(HINSTANCE hInst, HWND hWnd, DWORD ulResult, UINT idString, UINT fStyle, ...)
{
va_list va;
TCHAR szMessage[512]=TEXT("");
TCHAR szTempBuf[400];
TCHAR szTitle[128];
TCHAR szAppName[MAX_PATH];
// Get the application name from the resource file
LoadString (hInst, IDS_APP_NAME, szAppName, MAX_PATH);
// Do the title: 0: information message, 100-499: warning, 500 and up: critical (real error)
// Also, if an error msg, load the standard MAWF error message
if (ulResult == 0)
{
lstrcpy(szMessage, TEXT(""));
LoadString (hInst, IDS_INFORMATION_MESSAGE, szTempBuf, 128);
}
else // Error or warning
{
if ((ulResult >= 100) && (ulResult < 500))
{
// Warning
lstrcpy(szMessage, TEXT(""));
LoadString (hInst, IDS_WARNING_MESSAGE, szTempBuf, 128);
}
else // Error
{
// If an error msg, load the standard MAWF error message
LoadString (hInst, MAWF_E_GENERIC, szMessage, 64);
LoadString (hInst, IDS_CRITICAL_MESSAGE, szTempBuf, 128);
}
}
// Add a 'Microsoft At Work Fax' to the title
lstrcpy(szTitle, szAppName);
lstrcat(szTitle, TEXT(": "));
lstrcat(szTitle, szTempBuf);
// If there is a string ID, load the string from the resource file
if (idString)
{
TCHAR szFormat[400];
// Point to the first optional parameter. fStyle is the last required parameter
va_start(va, fStyle);
LoadString (hInst, idString, szFormat, 255);
wvsprintf(szTempBuf, szFormat, va);
va_end(va);
lstrcat (szMessage, szTempBuf);
}
return(MessageBox (hWnd, szMessage, szTitle, fStyle));
}
/* ***************************************************************************
* EncodeFaxAddress
*
* - encodes fax address components into the format name@+country-code (area-code) fax-number
*
* Parameters: lpszFaxAddr - address of a buffer in which to fill the encoded fax number
* lpParsedFaxAddr - an address of a PARSEDTELNUMBER structure which contains
* the components of the address that need to be encoded
*
* Returns: TRUE on success, FALSE on failure.
*
* CHECK: will need localization
*/
BOOL EncodeFaxAddress(LPTSTR lpszFaxAddr, LPPARSEDTELNUMBER lpParsedFaxAddr)
{
// somewhat validate parameters
if (!lpszFaxAddr)
return FALSE;
if (!lpParsedFaxAddr)
return FALSE;
// initialize the encoded string to an empty string
lstrcpy(lpszFaxAddr, TEXT(""));
// start with routing name and @, if any
if ((lpParsedFaxAddr->szRoutingName) && (lstrlen(lpParsedFaxAddr->szRoutingName) != 0))
{
lstrcat(lpszFaxAddr, lpParsedFaxAddr->szRoutingName);
lstrcat(lpszFaxAddr, TEXT("@"));
}
// must have a country code
if (lpParsedFaxAddr->szCountryCode)
{
// if the country code is not 0, start an canonical address
// a 0 country code is a special case, and address generated won't be canonincal
if ( (lstrlen(lpParsedFaxAddr->szCountryCode) != 0) &&
(lstrcmp(lpParsedFaxAddr->szCountryCode, TEXT("0")))
)
{
lstrcat(lpszFaxAddr, TEXT("+"));
lstrcat(lpszFaxAddr, lpParsedFaxAddr->szCountryCode);
lstrcat(lpszFaxAddr, TEXT(" "));
}
}
else
{
goto err;
}
// area code is optional
if ((lpParsedFaxAddr->szAreaCode) && (lstrlen(lpParsedFaxAddr->szAreaCode) != 0))
{
lstrcat(lpszFaxAddr, TEXT("("));
lstrcat(lpszFaxAddr, lpParsedFaxAddr->szAreaCode);
lstrcat(lpszFaxAddr, TEXT(")"));
lstrcat(lpszFaxAddr, TEXT(" "));
}
// must have a telephone number
if ((lpParsedFaxAddr->szTelNumber) && (lstrlen(lpParsedFaxAddr->szTelNumber) != 0))
{
lstrcat(lpszFaxAddr, lpParsedFaxAddr->szTelNumber);
}
else
{
goto err;
}
#ifdef UNICODE
{
CHAR szDebug[ MAX_PATH ];
szDebug[0] = 0;
WideCharToMultiByte( CP_ACP, 0, lpszFaxAddr, -1, szDebug, ARRAYSIZE(szDebug), NULL, NULL );
DEBUG_TRACE("EncodeFaxAddress: Canonical number: %s\n", szDebug);
}
#else
DEBUG_TRACE("EncodeFaxAddress: Canonical number: %s\n", lpszFaxAddr);
#endif
return TRUE;
err:
lstrcpy(lpszFaxAddr, TEXT(""));
return FALSE;
} /* EncodeFaxAddress */
/* ***************************************************************************
* DecodeFaxAddress
*
* - parses a fax address of the format name@+country-code (area-code) fax-number
*
* Parameters: lpszFaxAddr - a Fax address in the above format
* lpParsedFaxAddr - an address of a PARSEDTELNUMBER structure in which to
* fill the parsed information
*
* Returns: TRUE on success, FALSE on failure.
* success: full address
* no routing name
* no area code
* failure: no '+country-code '
* no telephone number
*
* CHECK: will need localization
*/
enum tAddrComp {error, country_code, area_code, tel_number};
BOOL DecodeFaxAddress(LPTSTR lpszFaxAddr, LPPARSEDTELNUMBER lpParsedFaxAddr)
{
TCHAR szTempBuf[sizeof(PARSEDTELNUMBER)] = {TEXT("")};
BOOL fRoutingNameAllowed = TRUE;
BOOL fAreaCodeAllowed = TRUE;
BOOL bResult = FALSE;
LPTSTR lpszTempBuf = szTempBuf;
enum tAddrComp nWhatStarted = tel_number;
WORD i;
// somewhat validate parameters
if (!lpszFaxAddr)
return FALSE;
if (!lpParsedFaxAddr)
return FALSE;
// Initialize to empty string values
lstrcpy(lpParsedFaxAddr->szCountryCode, TEXT(""));
lstrcpy(lpParsedFaxAddr->szAreaCode, TEXT(""));
lstrcpy(lpParsedFaxAddr->szTelNumber, TEXT(""));
lstrcpy(lpParsedFaxAddr->szRoutingName, TEXT(""));
// if the string empty, nothing to do
// (else, even if I don't find any "special" charachters in the string,
// I'll stash whatever is in there into the telephone number)
if (!lstrlen(lpszFaxAddr))
return TRUE;
// Scan once through the address. disallow fields as you progress
for (i=0; lpszFaxAddr[i] != 0; i++)
{
switch (lpszFaxAddr[i])
{
case TEXT('@'): // maybe the end of a mailbox name string, or just a @ in the name
if (fRoutingNameAllowed)
{
LPTSTR lpszTemp;
// is this the last @ in the number string ?
#ifdef UNICODE
lpszTemp = wcschr(lpszFaxAddr, TEXT('@'));
#else
lpszTemp = _mbsrchr(lpszFaxAddr, TEXT('@'));
#endif
if (lpszTemp == &(lpszFaxAddr[i]))
{
// end of mailbox name. beginning of "real" canonical number
lstrcpy(lpParsedFaxAddr->szRoutingName, szTempBuf);
lpszTempBuf = szTempBuf;
}
else
{
// not the end of the mailbox name yet. just continue.
*(lpszTempBuf++) = lpszFaxAddr[i];
*(lpszTempBuf) = 0;
}
}
break;
case TEXT('+'):
// next thing in the string should be the country code
// if there is a '+', I do not allow @ sign to be interpreted as a special character
fRoutingNameAllowed = FALSE;
lpszTempBuf = szTempBuf;
nWhatStarted = country_code;
break;
case TEXT('-'):
switch (nWhatStarted)
{
case country_code:
lstrcpy(lpParsedFaxAddr->szCountryCode, szTempBuf);
lpszTempBuf = szTempBuf;
nWhatStarted = area_code;
lstrcpy(szTempBuf, TEXT(""));
break;
case area_code:
lstrcpy (lpParsedFaxAddr->szAreaCode, szTempBuf);
lpszTempBuf = szTempBuf;
nWhatStarted = tel_number;
break;
default: // for any other character, store in a temp buffer
*(lpszTempBuf++) = lpszFaxAddr[i];
*(lpszTempBuf) = 0;
break;
}
break;
case TEXT('('):
// next thing in the string should be the area code
if (fAreaCodeAllowed)
{
lpszTempBuf = szTempBuf;
nWhatStarted = area_code;
}
break;
case TEXT(')'):
// copy without the ()
if ((fAreaCodeAllowed) && (nWhatStarted == area_code))
{
lstrcpy(lpParsedFaxAddr->szAreaCode, szTempBuf);
// advance beyond the space that follows the ')'
i++;
lpszTempBuf = szTempBuf;
nWhatStarted = tel_number;
fAreaCodeAllowed = FALSE;
}
break;
case TEXT(' '):
// this ends something
if (nWhatStarted == country_code)
{
lstrcpy(lpParsedFaxAddr->szCountryCode, szTempBuf);
lpszTempBuf = szTempBuf;
nWhatStarted = tel_number; // may be overriden be area code, if any
// if next character is not '(', I disallow area code
if (lpszFaxAddr[i+1] != '(')
fAreaCodeAllowed = FALSE;
break;
}
else if (nWhatStarted == area_code)
{
// should not happen
DEBUG_TRACE("DecodeFaxAddress: bad address. space in area code\n");
return FALSE;
}
else;
// Spaces are allowed in the mailbox or the phone number,
// so I fall through to the default case
default: // for any other character, store in a temp buffer
*(lpszTempBuf++) = lpszFaxAddr[i];
*(lpszTempBuf) = 0;
break;
} // switch (lpszFaxAddr[i])
} // for
// End of address string. Last component must be the telephone number
if (nWhatStarted == tel_number)
{
lstrcpy(lpParsedFaxAddr->szTelNumber, szTempBuf);
bResult = TRUE;
}
else
{
// we also get here on empty input string
bResult = FALSE;
}
return bResult;
} /* DecodeFaxAddress */
#ifdef DO_WE_REALLY_NEED_TAPI
/****************************************************************************
FUNCTION: DoThreadAttach()
PURPOSE: does the thread attach (DLL_THREAD_ATTACH) actions
PARAMETERS: [in/out] lppPTGData - address where to put the thread's private
storage pointer
RETURNS: TRUE on success, FALSE on failure
****************************************************************************/
BOOL DoThreadAttach(LPPTGDATA *lppPTGData)
{
LPPTGDATA lpPTGData=NULL;
// initialize the TLS index for this thread
lpPTGData = (LPPTGDATA) LocalAlloc(LPTR, sizeof(PTGDATA));
if (lpPTGData)
{
TlsSetValue(dwTlsIndex, lpPTGData);
}
else
{
DEBUG_TRACE("DoThreadAttach: LocalAlloc() failed for thread %x\n", GetCurrentThreadId());
goto error;
}
/*
* initilialize the per-thread data
*/
RtlZeroMemory((PVOID) lpPTGData, sizeof(PTGDATA));
// initialize the critical section that is used to control access to hInst
// to make sure this thread does not call us again
InitializeCriticalSection(&(pt_csInstance));
// initialize allocations array
if (!InitAllocations())
{
DEBUG_TRACE("DoThreadAttach: InitAllocations failed\n");
goto error;
}
// allocate and initialize the TAPI state structure
if (MAWFAllocBuff(SIZEOF(DTS), &pt_lpVdts))
{
DEBUG_TRACE("DoThreadAttach: allocation of vdts failed\n");
goto error;
}
RtlZeroMemory((PVOID) pt_lpVdts, SIZEOF(DTS));
pt_lpVdts->dwCurrentLocationID = (DWORD)-1;
lpPTGData->iLastDeviceAdded=LINEID_NONE; // what kind of device was last added
*lppPTGData = lpPTGData;
return TRUE;
error:
*lppPTGData = NULL;
return FALSE;
}
/****************************************************************************
FUNCTION: GetThreadStoragePointer()
PURPOSE: gets the private storage pointer for a thread, allocating one
if it does not exist (i.e. the thread didn't go through LibMain
THREAD_ATTACH)
PARAMETERS: none
RETURNS: a pointer to the thread's private storage
NULL, if there was a failure (usually memory allocation failure)
****************************************************************************/
LPPTGDATA GetThreadStoragePointer()
{
LPPTGDATA lpPTGData=TlsGetValue(dwTlsIndex);
// if the thread does not have a private storage, it did not go through
// THREAD_ATTACH and we need to do this here.
if (!lpPTGData)
{
DEBUG_TRACE("GetThreadStoragePointer: no private storage for this thread %x\n",
GetCurrentThreadId());
if (!DoThreadAttach(&lpPTGData))
lpPTGData = NULL;
}
return lpPTGData;
}
/* ***************************************************************************
* InitTAPI
*
* initializes TAPI by calling lineInitialize. enumerates all the available
* lines to set up pt_lpVdts->lprgLineInfo. also opens up each available line for
* monitoring. sets up pt_lpVdts->iLineCur and pt_lpVdts->iAddrCur by checking the
* preferred line/address name stored in the ini file against the available
* line/address names.
*
* Parameters: hInst - the instance of the calling module
* hWnd - window handle for UI
* lpszAppName - the name of the calling module
*
* returns NO_ERROR if success and the corresponding error code otherwise.
*/
DWORD
InitTAPI( HINSTANCE hInst,
HWND hWnd,
LPTSTR lpszAppName
)
{
LONG lResult;
LONG lResultLine = NO_ERROR;
DWORD iLine, iLineVoiceFirst = (DWORD)-1;
#ifdef LINE_ADDRESSES
DWORD iAddr, cAddr;
LPLINEADDRESSCAPS lpAddrCaps = NULL;
CHAR szPreferedAddress[cchAddrNameMac];
#endif
LPPTGDATA lpPTGData = GetThreadStoragePointer();
CHECK_THREAD_STORAGE_POINTER(lpPTGData, "InitTAPI", LINEERR_NOMEM);
/***************************************
********* initialize tapi *************
***************************************/
DEBUG_TRACE("InitTAPI: thread %x is initializing\n", GetCurrentThreadId());
DEBUG_TRACE("InitTAPI: cRefCount is %d\n", pt_lpVdts->cRefCount);
// see if this thread already initialized TAPI
if (pt_lpVdts->cRefCount)
{
lResult = NO_ERROR;
goto LDone;
}
if ((lResult = TAPIBasicInit(hInst, hWnd, lpszAppName)) != NO_ERROR)
goto LDone;
/***************************************
********* initialize lines ************
***************************************/
// initialize pt_lpVdts->lpgrLineInfo and open each available line for
// monitoring
// allocate buffer for storing LINEINFO for all the available lines
pt_lpVdts->lprgLineInfo = (LPLINEINFO)_fmalloc(SIZEOF(LINEINFO)*(int)pt_lpVdts->cLines);
if (pt_lpVdts->lprgLineInfo == NULL)
{
lResult = LINEERR_NOMEM;
goto LDone;
}
_fmemset(pt_lpVdts->lprgLineInfo,0,SIZEOF(LINEINFO)*(int)pt_lpVdts->cLines);
// init pt_lpVdts->lprgLineInfo and open each line to get its caps
// also count the fax lines
pt_lpVdts->cFaxLines = 0;
for (iLine = 0; iLine < pt_lpVdts->cLines; ++iLine)
{
// Open the line and get its capabilities, including its name
lResult = GetCachedLineInfo(iLine);
if (lResult != NO_ERROR)
{
// something went wrong with initializing a line that TAPI told me
// should be OK
// I save the lResult (but doing nothing with it for now)
// and continue with other lines. This line does not get enumerated.
lResultLine = lResult;
// this does not mean InitTAPI failed
lResult = NO_ERROR;
continue;
// goto LDone;
}
if ( (iLineVoiceFirst == (DWORD)-1) &&
pt_lpVdts->lprgLineInfo[iLine].fIsVoiceLine
)
{
iLineVoiceFirst = iLine;
}
// if it's a fax line, count it in
if (pt_lpVdts->lprgLineInfo[iLine].fIsVoiceLine)
// CHECK: && fIsFaxDevice))
{
pt_lpVdts->cFaxLines++;
}
} // for
// No reason to proceed if no Fax lines
if (pt_lpVdts->cFaxLines == 0)
{
/* no voice line, too bad */
lResult = ERROR_NO_LINES;
pt_lpVdts->iLineCur = NO_MODEM;
goto LDone;
}
// If no current line and there is a voice line, set the current line to be this voice line
// This code is probably not needed, as I later (InitLineDeviceLB()) set the current line
// from the profile
else if (pt_lpVdts->iLineCur == NO_MODEM)
{
pt_lpVdts->iLineCur = iLineVoiceFirst;
}
#ifdef LINE_ADDRESSES
/* **************************************************/
/* init pt_lpVdts->iAddrCur */
// Set the line address to a default value of 0 (the only one currently supported)
pt_lpVdts->iAddrCur = 0;
// allocate buffer for the lineGetAddressCaps calls
if ((lpAddrCaps = (LPLINEADDRESSCAPS)_fmalloc(lcbAddrDevCapsInitial))
== NULL)
{
lResult = LINEERR_NOMEM;
goto LDone;
}
lpAddrCaps->dwTotalSize = lcbAddrDevCapsInitial;
// enumerate all the available addresses to match szPreferedAddress with
// an address name
cAddr = pt_lpVdts->lprgLineInfo[pt_lpVdts->iLineCur].cAddr;
for (iAddr = 0; iAddr < cAddr; ++iAddr)
{
char szAddrName[cchAddrNameMac];
LPTSTR lpszAddrName;
// get address capability info
lResult = lineGetAddressCaps( pt_lpVdts->hApp,
pt_lpVdts->iLineCur,
iAddr,
tapiVersionCur,
0,
lpAddrCaps
);
if (lResult != NO_ERROR)
goto LDone;
// reallocate buffer if not big enough
while (lpAddrCaps->dwNeededSize > lpAddrCaps->dwTotalSize)
{
DWORD lcbNeeded = lpAddrCaps->dwNeededSize;
_ffree(lpAddrCaps);
if ((lpAddrCaps = (LPLINEADDRESSCAPS)_fmalloc((size_t)lcbNeeded))
== NULL)
{
lResult = LINEERR_NOMEM;
goto LDone;
}
lpAddrCaps->dwTotalSize = lcbNeeded;
/* try it one more time */
lResult = lineGetAddressCaps( pt_lpVdts->hApp,
pt_lpVdts->iLineCur,
iAddr,
tapiVersionCur,
0,
lpAddrCaps
);
if (lResult != NO_ERROR)
goto LDone;
} /* while */
/* get the address's name */
if (lpAddrCaps->dwAddressSize > 0)
lpszAddrName = (LPTSTR)((LPBYTE)(lpAddrCaps)+lpAddrCaps->dwAddressOffset);
else
{
/* use default name */
TCHAR szAddrFormat[32];
LoadString( hInst,
IDS_TAPI_LINE_NAME,
szAddrFormat,
ARRAYSIZEf(szAddrFormat)
);
wsprintf(szAddrName,szAddrFormat,iAddr);
lpszAddrName = (LPTSTR)szAddrName;
} /* else */
if (lstrcmpi(lpszAddrName,szPreferedAddress) == 0)
{
pt_lpVdts->iAddrCur = iAddr;
break;
} /* if */
} /* for */
#endif // #ifdef LINE_ADDRESSES
lResult = NO_ERROR;
LDone:
// free up memory allocated
#ifdef LINE_ADDRESSES
if (lpAddrCaps)
_ffree(lpAddrCaps);
#endif
// if InitTAPI succeeded, bump up the ref count
if ( (lResult == NO_ERROR) ||
(lResult == ERROR_NO_LINES)
)
{
pt_lpVdts->cRefCount++;
}
// else, free unneeded memory
else if (pt_lpVdts->lprgLineInfo)
{
_ffree(pt_lpVdts->lprgLineInfo);
pt_lpVdts->lprgLineInfo = NULL;
}
return lResult;
} /* InitTAPI */
/****************************************************************************
* DeinitTAPI
*
* frees up the memory allocated, closes all the lines we have opened for
* monitoring and calls lineShutDown to disconnect from TAPI.
*/
BOOL DeinitTAPI()
{
LPPTGDATA lpPTGData = GetThreadStoragePointer();
CHECK_THREAD_STORAGE_POINTER(lpPTGData, "DeinitTAPI", 0xffffffff);
DEBUG_TRACE("DeinitTAPI: thread %x is deinitializing\n", GetCurrentThreadId());
// if ref count is already 0, unbalanced calls, do nothing
if (!(pt_lpVdts->cRefCount))
return TRUE;
// don't want to deinit if ref count is still > 0
if (--pt_lpVdts->cRefCount)
return TRUE;
/* never mind if lineInitialize failed in the first place */
if (!pt_lpVdts->fLineInited)
return TRUE;
/* unregister STAPI */
FRegisterSimpleTapi(FALSE);
/* closes all the open lines and free pt_lpVdts->lprgLineInfo */
if (pt_lpVdts->lprgLineInfo)
{
DWORD iLine;
for (iLine = 0; iLine < pt_lpVdts->cLines; ++iLine)
{
DEBUG_TRACE( "Thread %x,DeinitTAPI: looking to close line %x...\n",
GetCurrentThreadId(),
iLine
);
if (pt_lpVdts->lprgLineInfo[iLine].dwAPIVersion == 0)
continue;
lineClose(pt_lpVdts->lprgLineInfo[iLine].hLine);
DEBUG_TRACE( "Thread %x,DeinitTAPI: line %x is closed\n",
GetCurrentThreadId(),
iLine
);
} /* for */
_ffree(pt_lpVdts->lprgLineInfo);
} /* if */
/* disconnect from TAPI */
lineShutdown(pt_lpVdts->hApp);
pt_lpVdts->hInst = NULL;
return TRUE;
} /* DeinitTAPI */
#endif // DO_WE_REALLY_NEED_TAPI
Reference in a new issue Copy permalink