// ############################################################################ // Phone book APIs #include "pch.hpp" #ifdef WIN16 #include #include #include #include #include extern "C" { #include "bmp.h" } #endif #include "phbk.h" #include "misc.h" #include "phbkrc.h" #include "suapi.h" //#define ReadVerifyPhoneBookDW(x) AssertMsg(ReadPhoneBookDW(&(x),pcCSVFile),"Invalid DWORD in phone book"); #define ReadVerifyPhoneBookDW(x) if (!ReadPhoneBookDW(&(x),pcCSVFile)) \ { AssertMsg(0,"Invalid DWORD in phone book"); \ goto ReadError; } #define ReadVerifyPhoneBookW(x) if (!ReadPhoneBookW(&(x),pcCSVFile)) \ { AssertMsg(0,"Invalid DWORD in phone book"); \ goto ReadError; } #define ReadVerifyPhoneBookB(x) if (!ReadPhoneBookB(&(x),pcCSVFile)) \ { AssertMsg(0,"Invalid DWORD in phone book"); \ goto ReadError; } #define ReadVerifyPhoneBookSZ(x,y) if (!ReadPhoneBookSZ(&x[0],y+sizeof('\0'),pcCSVFile)) \ { AssertMsg(0,"Invalid DWORD in phone book"); \ goto ReadError; } #define CHANGE_BUFFER_SIZE 50 #define TEMP_PHONE_BOOK_PREFIX TEXT("PBH") #define ERROR_USERBACK 32766 #define ERROR_USERCANCEL 32767 TCHAR szTempBuffer[TEMP_BUFFER_LENGTH]; TCHAR szTempFileName[MAX_PATH]; #ifdef __cplusplus extern "C" { #endif HWND g_hWndMain; #ifdef __cplusplus } #endif #if !defined(WIN16) //+---------------------------------------------------------------------------- // // Function IsMSDUN12Installed // // Synopsis Check if MSDUN 1.2 or higher is installed // // Arguments none // // Returns TRUE - MSDUN 1.2 is installed // // History 5/28/97 ChrisK created for Olympus Bug 4392 // 8/7/97 ChrisK lifted from isign32 // //----------------------------------------------------------------------------- #define DUN_12_Version ((double)1.2) BOOL IsMSDUN12Installed() { TCHAR szBuffer[MAX_PATH] = {TEXT("\0")}; HKEY hkey = NULL; BOOL bRC = FALSE; DWORD dwType = 0; DWORD dwSize = sizeof(szBuffer); FLOAT flVersion = 0e0f; if (ERROR_SUCCESS != RegOpenKey(HKEY_LOCAL_MACHINE, TEXT("System\\CurrentControlSet\\Services\\RemoteAccess"), &hkey)) { goto IsMSDUN12InstalledExit; } if (ERROR_SUCCESS != RegQueryValueEx(hkey, TEXT("Version"), NULL, &dwType, (LPBYTE)szBuffer, &dwSize)) { goto IsMSDUN12InstalledExit; } #ifdef UNICODE CHAR szTmp[MAX_PATH]; wcstombs(szTmp, szBuffer, MAX_PATH); szTmp[MAX_PATH - 1] = '\0'; bRC = DUN_12_Version <= atof(szTmp); #else bRC = DUN_12_Version <= atof(szBuffer); #endif IsMSDUN12InstalledExit: if (hkey != NULL) { RegCloseKey(hkey); hkey = NULL; } return bRC; } #endif // ############################################################################ CPhoneBook::CPhoneBook() { HINSTANCE hInst = NULL; LONG lrc; #if !defined(WIN16) HKEY hkey; #endif DWORD dwType; DWORD dwSize; TCHAR szData[MAX_PATH+1]; m_rgPhoneBookEntry = NULL; m_hPhoneBookEntry = NULL; m_cPhoneBookEntries =0; m_rgLineCountryEntry=NULL; m_rgState=NULL; m_cStates=0; m_rgIDLookUp = NULL; m_rgNameLookUp = NULL; m_pLineCountryList = NULL; ZeroMemory(&m_szINFFile[0],MAX_PATH); ZeroMemory(&m_szINFCode[0],MAX_INFCODE); ZeroMemory(&m_szPhoneBook[0],MAX_PATH); #if !defined(WIN16) if (VER_PLATFORM_WIN32_NT == DWGetWin32Platform()) { m_bScriptingAvailable = TRUE; } else if (IsMSDUN12Installed()) { // // ChrisK 8/7/97 Olympus1 11814 // Display scripted phone numbers on system with DUN 1.2 installed // m_bScriptingAvailable = TRUE; } else { // // Verify scripting by checking for smmscrpt.dll in RemoteAccess registry key // if (1111 <= DWGetWin32BuildNumber()) { m_bScriptingAvailable = TRUE; } else { m_bScriptingAvailable = FALSE; hkey = NULL; lrc=RegOpenKey(HKEY_LOCAL_MACHINE,TEXT("System\\CurrentControlSet\\Services\\RemoteAccess\\Authentication\\SMM_FILES\\PPP"),&hkey); if (ERROR_SUCCESS == lrc) { dwSize = sizeof(TCHAR)*MAX_PATH; lrc = RegQueryValueEx(hkey,TEXT("Path"),0,&dwType,(LPBYTE)szData,&dwSize); if (ERROR_SUCCESS == lrc) { if (0 == lstrcmpi(szData,TEXT("smmscrpt.dll"))) m_bScriptingAvailable = TRUE; } } if (hkey) RegCloseKey(hkey); hkey = NULL; } // // Verify that the DLL can be loaded // if (m_bScriptingAvailable) { hInst = LoadLibrary(TEXT("smmscrpt.dll")); if (hInst) FreeLibrary(hInst); else m_bScriptingAvailable = FALSE; hInst = NULL; } } #endif // WIN16 } // ############################################################################ CPhoneBook::~CPhoneBook() { #ifdef WIN16 if (m_rgPhoneBookEntry) GlobalFree(m_rgPhoneBookEntry); #else if (m_hPhoneBookEntry) GlobalUnlock(m_hPhoneBookEntry); if (m_hPhoneBookEntry) GlobalFree(m_hPhoneBookEntry); #endif if (m_pLineCountryList) GlobalFree(m_pLineCountryList); if (m_rgIDLookUp) GlobalFree(m_rgIDLookUp); if (m_rgNameLookUp) GlobalFree(m_rgNameLookUp); if (m_rgState) GlobalFree(m_rgState); } // ############################################################################ BOOL CPhoneBook::ReadPhoneBookDW(DWORD far *pdw, CCSVFile far *pcCSVFile) { if (!pcCSVFile->ReadToken(szTempBuffer,TEMP_BUFFER_LENGTH)) return FALSE; return (FSz2Dw(szTempBuffer,pdw)); } // ############################################################################ BOOL CPhoneBook::ReadPhoneBookW(WORD far *pw, CCSVFile far *pcCSVFile) { if (!pcCSVFile->ReadToken(szTempBuffer,TEMP_BUFFER_LENGTH)) return FALSE; return (FSz2W(szTempBuffer,pw)); } // ############################################################################ BOOL CPhoneBook::ReadPhoneBookB(BYTE far *pb, CCSVFile far *pcCSVFile) { if (!pcCSVFile->ReadToken(szTempBuffer,TEMP_BUFFER_LENGTH)) return FALSE; return (FSz2B(szTempBuffer,pb)); } // ############################################################################ BOOL CPhoneBook::ReadPhoneBookSZ(LPTSTR psz, DWORD dwSize, CCSVFile far *pcCSVFile) { if (!pcCSVFile->ReadToken(psz,dwSize)) return FALSE; return TRUE; } // ############################################################################ BOOL CPhoneBook::FixUpFromRealloc(PACCESSENTRY paeOld, PACCESSENTRY paeNew) { BOOL bRC = FALSE; LONG_PTR lDiff = 0; DWORD idx = 0; // // No starting value or no move, therefore no fix-ups needed // if ((0 == paeOld) || (paeNew == paeOld)) { bRC = TRUE; goto FixUpFromReallocExit; } Assert(paeNew); Assert(((LONG)paeOld) > 0); // if these address look like negative numbers Assert(((LONG)paeNew) > 0); // I'm not sure the code would handle them lDiff = (LONG_PTR)paeOld - (LONG_PTR)paeNew; // // fix up STATES // for (idx = 0; idx < m_cStates; idx++) { if (m_rgState[idx].paeFirst) m_rgState[idx].paeFirst = (PACCESSENTRY )((LONG_PTR)m_rgState[idx].paeFirst - lDiff); } // // fix up ID look up array // for (idx = 0; idx < m_pLineCountryList->dwNumCountries ; idx++) { if (m_rgIDLookUp[idx].pFirstAE) m_rgIDLookUp[idx].pFirstAE = (PACCESSENTRY )((LONG_PTR)m_rgIDLookUp[idx].pFirstAE - lDiff); } bRC = TRUE; FixUpFromReallocExit: return bRC; } // ############################################################################ HRESULT CPhoneBook::Init(LPCTSTR pszISPCode) { LPLINECOUNTRYLIST pLineCountryTemp = NULL; HRESULT hr = ERROR_NOT_ENOUGH_MEMORY; DWORD dwLastState = 0; DWORD dwLastCountry = 0; DWORD dwSizeAllocated; PACCESSENTRY pCurAccessEntry; PACCESSENTRY pAETemp; LPLINECOUNTRYENTRY pLCETemp; DWORD idx; LPTSTR pszTemp; CCSVFile far *pcCSVFile=NULL; LPSTATE ps,psLast; //faster to use pointers. HGLOBAL hTemp = NULL; /*#ifdef WIN16 m_pLineCountryList = (LPLINECOUNTRYLIST)GlobalAlloc(GPTR, sizeof(LINECOUNTRYLIST) + sizeof(LINECOUNTRYENTRY) + 10); if (!m_pLineCountryList) goto InitExit; m_pLineCountryList->dwTotalSize = sizeof(LINECOUNTRYLIST) + sizeof(LINECOUNTRYENTRY) + 3; m_pLineCountryList->dwNeededSize = m_pLineCountryList->dwUsedSize = m_pLineCountryList->dwTotalSize; m_pLineCountryList->dwNumCountries = 1; m_pLineCountryList->dwCountryListSize = sizeof(LINECOUNTRYENTRY); m_pLineCountryList->dwCountryListOffset = sizeof(LINECOUNTRYLIST); pLCETemp = (LPLINECOUNTRYENTRY)((DWORD) m_pLineCountryList + m_pLineCountryList->dwCountryListOffset); pLCETemp->dwCountryID = 1; pLCETemp->dwCountryCode = 1; pLCETemp->dwNextCountryID = 0; pLCETemp->dwCountryNameSize = 3; pLCETemp->dwCountryNameOffset = sizeof(LINECOUNTRYLIST) + sizeof(LINECOUNTRYENTRY); pLCETemp->dwSameAreaRuleSize = 0; pLCETemp->dwSameAreaRuleOffset = 0; pLCETemp->dwLongDistanceRuleSize = 0; pLCETemp->dwLongDistanceRuleOffset = 0; pLCETemp->dwInternationalRuleSize = 0; pLCETemp->dwInternationalRuleOffset = 0; lstrcpy ((LPTSTR)((DWORD)m_pLineCountryList + pLCETemp->dwCountryNameOffset), TEXT("USA")); pszTemp = (LPTSTR)((DWORD)m_pLineCountryList + pLCETemp->dwCountryNameOffset); #else // WIN16 */ // Get TAPI country list m_pLineCountryList = (LPLINECOUNTRYLIST)GlobalAlloc(GPTR,sizeof(LINECOUNTRYLIST)); if (!m_pLineCountryList) goto InitExit; m_pLineCountryList->dwTotalSize = sizeof(LINECOUNTRYLIST); #if defined(WIN16) idx = (DWORD) IETapiGetCountry(0, m_pLineCountryList); #else idx = lineGetCountry(0,0x10003,m_pLineCountryList); #endif if (idx && idx != LINEERR_STRUCTURETOOSMALL) goto InitExit; Assert(m_pLineCountryList->dwNeededSize); pLineCountryTemp = (LPLINECOUNTRYLIST)GlobalAlloc(GPTR, (size_t)m_pLineCountryList->dwNeededSize); if (!pLineCountryTemp) goto InitExit; pLineCountryTemp->dwTotalSize = m_pLineCountryList->dwNeededSize; GlobalFree(m_pLineCountryList); m_pLineCountryList = pLineCountryTemp; pLineCountryTemp = NULL; #if defined(WIN16) if (IETapiGetCountry(0, m_pLineCountryList)) #else if (lineGetCountry(0,0x10003,m_pLineCountryList)) #endif goto InitExit; //#endif // WIN16 // Load Look Up arrays #ifdef DEBUG m_rgIDLookUp = (LPIDLOOKUPELEMENT)GlobalAlloc(GPTR, (int)(sizeof(IDLOOKUPELEMENT)*m_pLineCountryList->dwNumCountries+5)); #else m_rgIDLookUp = (LPIDLOOKUPELEMENT)GlobalAlloc(GPTR, (int)(sizeof(IDLOOKUPELEMENT)*m_pLineCountryList->dwNumCountries)); #endif if (!m_rgIDLookUp) goto InitExit; pLCETemp = (LPLINECOUNTRYENTRY)((DWORD_PTR)m_pLineCountryList + m_pLineCountryList->dwCountryListOffset); for (idx=0;idxdwNumCountries;idx++) { m_rgIDLookUp[idx].dwID = pLCETemp[idx].dwCountryID; m_rgIDLookUp[idx].pLCE = &pLCETemp[idx]; } qsort(m_rgIDLookUp,(int)m_pLineCountryList->dwNumCountries,sizeof(IDLOOKUPELEMENT), CompareIDLookUpElements); m_rgNameLookUp = (LPCNTRYNAMELOOKUPELEMENT)GlobalAlloc(GPTR, (int)(sizeof(CNTRYNAMELOOKUPELEMENT) * m_pLineCountryList->dwNumCountries)); if (!m_rgNameLookUp) goto InitExit; for (idx=0;idxdwNumCountries;idx++) { m_rgNameLookUp[idx].psCountryName = (LPTSTR)((LPBYTE)m_pLineCountryList + (DWORD)pLCETemp[idx].dwCountryNameOffset); m_rgNameLookUp[idx].dwNameSize = pLCETemp[idx].dwCountryNameSize; m_rgNameLookUp[idx].pLCE = &pLCETemp[idx]; } qsort(m_rgNameLookUp,(int)m_pLineCountryList->dwNumCountries,sizeof(CNTRYNAMELOOKUPELEMENT), CompareCntryNameLookUpElements); // Load States if (!SearchPath(NULL,STATE_FILENAME,NULL,TEMP_BUFFER_LENGTH,szTempBuffer,&pszTemp)) { AssertMsg(0,"STATE.ICW not found"); hr = ERROR_FILE_NOT_FOUND; goto InitExit; } pcCSVFile = new CCSVFile; if (!pcCSVFile) goto InitExit; if (!pcCSVFile->Open(szTempBuffer)) { AssertMsg(0,"Can not open STATE.ICW"); delete pcCSVFile; pcCSVFile = NULL; goto InitExit; } // first token in state file is the number of states if (!pcCSVFile->ReadToken(szTempBuffer,TEMP_BUFFER_LENGTH)) goto InitExit; if (!FSz2Dw(szTempBuffer,&m_cStates)) { AssertMsg(0,"STATE.ICW count is invalid"); goto InitExit; } m_rgState = (LPSTATE)GlobalAlloc(GPTR,(int)(sizeof(STATE)*m_cStates)); if (!m_rgState) goto InitExit; for (ps = m_rgState, psLast = &m_rgState[m_cStates - 1]; ps <= psLast;++ps) { pcCSVFile->ReadToken(ps->szStateName,cbStateName); } pcCSVFile->Close(); // Locate ISP's INF file if (!SearchPath(NULL,(LPCTSTR) pszISPCode,INF_SUFFIX,MAX_PATH, m_szINFFile,&pszTemp)) { wsprintf(szTempBuffer,TEXT("Can not find:%s%s (%d)"),pszISPCode,INF_SUFFIX,GetLastError()); AssertMsg(0,szTempBuffer); hr = ERROR_FILE_NOT_FOUND; goto InitExit; } //Load Phone Book if (!GetPrivateProfileString(INF_APP_NAME,INF_PHONE_BOOK,INF_DEFAULT, szTempBuffer,TEMP_BUFFER_LENGTH,m_szINFFile)) { AssertMsg(0,"PhoneBookFile not specified in INF file"); hr = ERROR_FILE_NOT_FOUND; goto InitExit; } #ifdef DEBUG if (!lstrcmp(szTempBuffer,INF_DEFAULT)) { wsprintf(szTempBuffer, TEXT("%s value not found in ISP file"), INF_PHONE_BOOK); AssertMsg(0,szTempBuffer); } #endif if (!SearchPath(NULL,szTempBuffer,NULL,MAX_PATH,m_szPhoneBook,&pszTemp)) { AssertMsg(0,"ISP phone book not found"); hr = ERROR_FILE_NOT_FOUND; goto InitExit; } if (!pcCSVFile->Open(m_szPhoneBook)) { AssertMsg(0,"Can not open phone book"); hr = GetLastError(); goto InitExit; } dwSizeAllocated = 0; do { Assert (dwSizeAllocated >= m_cPhoneBookEntries); // check that sufficient memory is allocated if (m_rgPhoneBookEntry) { if (dwSizeAllocated == m_cPhoneBookEntries) { // // we need more memory // // AssertMsg(0,"Out of memory originally allocated for phone book.\r\n"); // goto InitExit; pAETemp = m_rgPhoneBookEntry; #ifdef WIN16 dwSizeAllocated += PHONE_ENTRY_ALLOC_SIZE; m_rgPhoneBookEntry = (PACCESSENTRY)GlobalReAlloc(m_rgPhoneBookEntry, (int)(dwSizeAllocated * sizeof(ACCESSENTRY)),GHND); if (NULL == m_rgPhoneBookEntry) goto InitExit; #else // UNLOCK Assert(m_hPhoneBookEntry); if (FALSE == GlobalUnlock(m_hPhoneBookEntry)) { if (NO_ERROR != GetLastError()) goto InitExit; } // REALLOC dwSizeAllocated += PHONE_ENTRY_ALLOC_SIZE; hTemp = m_hPhoneBookEntry; m_hPhoneBookEntry = GlobalReAlloc(hTemp, (int)(dwSizeAllocated * sizeof(ACCESSENTRY)),GHND); if (NULL == m_hPhoneBookEntry) { GlobalFree(hTemp); goto InitExit; } else { hTemp = NULL; } // LOCK m_rgPhoneBookEntry = (PACCESSENTRY)GlobalLock(m_hPhoneBookEntry); if (NULL == m_rgPhoneBookEntry) goto InitExit; #endif FixUpFromRealloc(pAETemp, m_rgPhoneBookEntry); TraceMsg(TF_GENERAL, "Grow phone book to %d entries\n",dwSizeAllocated); pCurAccessEntry = (PACCESSENTRY)((LONG_PTR)pCurAccessEntry - ((LONG_PTR)pAETemp - (LONG_PTR)(m_rgPhoneBookEntry))); } } else { // // Initialization for the first time through // // ALLOC #ifdef WIN16 m_rgPhoneBookEntry = (PACCESSENTRY)GlobalAlloc(GHND,sizeof(ACCESSENTRY) * PHONE_ENTRY_ALLOC_SIZE); if(NULL == m_rgPhoneBookEntry) goto InitExit; #else m_hPhoneBookEntry = GlobalAlloc(GHND,sizeof(ACCESSENTRY) * PHONE_ENTRY_ALLOC_SIZE); if(NULL == m_hPhoneBookEntry) goto InitExit; // LOCK m_rgPhoneBookEntry = (PACCESSENTRY)GlobalLock(m_hPhoneBookEntry); if(NULL == m_rgPhoneBookEntry) goto InitExit; #endif dwSizeAllocated = PHONE_ENTRY_ALLOC_SIZE; pCurAccessEntry = m_rgPhoneBookEntry; } // Read a line from the phonebook hr = ReadOneLine(pCurAccessEntry,pcCSVFile); if (hr == ERROR_NO_MORE_ITEMS) { break; } else if (hr != ERROR_SUCCESS) { goto InitExit; } hr = ERROR_NOT_ENOUGH_MEMORY; // Check to see if this is the first phone number for a given country if (pCurAccessEntry->dwCountryID != dwLastCountry) { LPIDLOOKUPELEMENT lpIDLookupElement; // NOTE: Not sure about the first parameter here. lpIDLookupElement = (LPIDLOOKUPELEMENT)bsearch(&pCurAccessEntry->dwCountryID, m_rgIDLookUp,(int)m_pLineCountryList->dwNumCountries,sizeof(IDLOOKUPELEMENT), CompareIDLookUpElements); if (!lpIDLookupElement) { // bad country ID, but we can't assert here TraceMsg(TF_GENERAL,"Bad country ID in phone book %d\n",pCurAccessEntry->dwCountryID); continue; } else { // for a given country ID this is the first phone number lpIDLookupElement->pFirstAE = pCurAccessEntry; dwLastCountry = pCurAccessEntry->dwCountryID; } } // Check to see if this is the first phone number for a given state if (pCurAccessEntry->wStateID && (pCurAccessEntry->wStateID != dwLastState)) { idx = pCurAccessEntry->wStateID - 1; m_rgState[idx].dwCountryID = pCurAccessEntry->dwCountryID; m_rgState[idx].paeFirst = pCurAccessEntry; dwLastState = pCurAccessEntry->wStateID; } pCurAccessEntry++; m_cPhoneBookEntries++; } while (TRUE); // Trim the phone book for unused memory Assert(m_rgPhoneBookEntry && m_cPhoneBookEntries); pAETemp = m_rgPhoneBookEntry; #ifdef WIN16 m_rgPhoneBookEntry = (PACCESSENTRY)GlobalReAlloc(m_rgPhoneBookEntry,(int)(m_cPhoneBookEntries * sizeof(ACCESSENTRY)),GHND); if (!m_rgPhoneBookEntry) goto InitExit; #else // UNLOCK Assert(m_hPhoneBookEntry); if (FALSE != GlobalUnlock(m_hPhoneBookEntry)) { if (NO_ERROR != GetLastError()) goto InitExit; } // REALLOC hTemp = m_hPhoneBookEntry; m_hPhoneBookEntry = GlobalReAlloc(hTemp,(int)(m_cPhoneBookEntries * sizeof(ACCESSENTRY)),GHND); if (NULL == m_hPhoneBookEntry) { GlobalFree(hTemp); goto InitExit; } else { hTemp = NULL; } // LOCK m_rgPhoneBookEntry = (PACCESSENTRY)GlobalLock(m_hPhoneBookEntry); if (NULL == m_rgPhoneBookEntry) goto InitExit; #endif FixUpFromRealloc(pAETemp, m_rgPhoneBookEntry); hr = ERROR_SUCCESS; InitExit: // If something failed release everything if (hr != ERROR_SUCCESS) { #ifdef WIN16 GlobalFree(m_rgPhoneBookEntry); #else GlobalUnlock(m_hPhoneBookEntry); GlobalFree(m_hPhoneBookEntry); #endif GlobalFree(m_pLineCountryList); GlobalFree(m_rgIDLookUp); GlobalFree(m_rgNameLookUp); GlobalFree(m_rgState); m_cPhoneBookEntries = 0 ; m_cStates = 0; m_pLineCountryList = NULL; m_rgPhoneBookEntry = NULL; m_hPhoneBookEntry = NULL; m_rgIDLookUp=NULL; m_rgNameLookUp=NULL; m_rgState=NULL; } if (pcCSVFile) { pcCSVFile->Close(); delete pcCSVFile; } return hr; } // ############################################################################ HRESULT CPhoneBook::Merge(LPCTSTR pszChangeFile) { CCSVFile far *pcCSVFile; ACCESSENTRY aeChange; LPIDXLOOKUPELEMENT rgIdxLookUp; LPIDXLOOKUPELEMENT pCurIdxLookUp; DWORD dwAllocated; DWORD dwUsed; DWORD dwOriginalSize; HRESULT hr = ERROR_NOT_ENOUGH_MEMORY; DWORD dwIdx; #if !defined(WIN16) HANDLE hTemp; HANDLE hIdxLookUp; #else // Normandy 11746 LPVOID rgTemp; // 16-bit only #endif DWORD cch, cchWritten; HANDLE hFile; // Pad the phonebook for new entries. dwAllocated = m_cPhoneBookEntries + CHANGE_BUFFER_SIZE; #ifdef WIN16 Assert(m_rgPhoneBookEntry); rgTemp = GlobalReAlloc(m_rgPhoneBookEntry, (int)(sizeof(ACCESSENTRY) * dwAllocated),GHND); Assert(rgTemp); if (!rgTemp) goto MergeExit; m_rgPhoneBookEntry = (PACCESSENTRY)rgTemp; #else Assert(m_hPhoneBookEntry); GlobalUnlock(m_hPhoneBookEntry); hTemp = (HANDLE)GlobalReAlloc(m_hPhoneBookEntry, sizeof(ACCESSENTRY) * dwAllocated,GHND); Assert(hTemp); if (!hTemp) goto MergeExit; m_rgPhoneBookEntry = (PACCESSENTRY)GlobalLock(m_hPhoneBookEntry); if (!m_rgPhoneBookEntry) goto MergeExit; #endif // Create index to loaded phone book, sorted by index #ifdef WIN16 rgIdxLookUp = (LPIDXLOOKUPELEMENT)GlobalAlloc(GHND,(int)(sizeof(IDXLOOKUPELEMENT) * dwAllocated)); #else hIdxLookUp = (HANDLE)GlobalAlloc(GHND,sizeof(IDXLOOKUPELEMENT) * dwAllocated); rgIdxLookUp = (LPIDXLOOKUPELEMENT)GlobalLock(hIdxLookUp); #endif Assert(rgIdxLookUp); if (!rgIdxLookUp) goto MergeExit; for (dwIdx = 0; dwIdx < m_cPhoneBookEntries; dwIdx++) { rgIdxLookUp[dwIdx].dwIndex = rgIdxLookUp[dwIdx].pAE->dwIndex; rgIdxLookUp[dwIdx].pAE = &m_rgPhoneBookEntry[dwIdx]; } dwUsed = m_cPhoneBookEntries; dwOriginalSize = m_cPhoneBookEntries; qsort(rgIdxLookUp,(int)dwOriginalSize,sizeof(IDXLOOKUPELEMENT),CompareIdxLookUpElements); // Load changes to phone book pcCSVFile = new CCSVFile; Assert(pcCSVFile); if (!pcCSVFile) goto MergeExit; if (!pcCSVFile->Open(pszChangeFile)) goto MergeExit; do { // Read a change record ZeroMemory(&aeChange,sizeof(ACCESSENTRY)); hr = ReadOneLine(&aeChange, pcCSVFile); if(hr == ERROR_NO_MORE_ITEMS) { break; // no more enteries } else if (hr != ERROR_SUCCESS) { goto MergeExit; } hr = ERROR_NOT_ENOUGH_MEMORY; /* if (!ReadPhoneBookDW(&aeChange.dwIndex,pcCSVFile)) break; // no more enteries ReadVerifyPhoneBookDW(aeChange.dwCountryID); ReadVerifyPhoneBookW(aeChange.wStateID); ReadVerifyPhoneBookSZ(aeChange.szCity,cbCity); ReadVerifyPhoneBookSZ(aeChange.szAreaCode,cbAreaCode); // NOTE: 0 is a valid area code and ,, is a valid entry for an area code if (!FSz2Dw(aeChange.szAreaCode,&aeChange.dwAreaCode)) aeChange.dwAreaCode = NO_AREA_CODE; ReadVerifyPhoneBookSZ(aeChange.szAccessNumber,cbAccessNumber); ReadVerifyPhoneBookDW(aeChange.dwConnectSpeedMin); ReadVerifyPhoneBookDW(aeChange.dwConnectSpeedMax); ReadVerifyPhoneBookB(aeChange.bFlipFactor); ReadVerifyPhoneBookB(aeChange.fType); ReadVerifyPhoneBookSZ(aeChange.szDataCenter,cbDataCenter); */ // Determine if this is a delete or add record if (aeChange.szAccessNumber[0] == '0' && aeChange.szAccessNumber[1] == '\0') { // This is a delete record, find matching record // NOTE: we only search the numbers that existed before the change file, // because they are the only ones that are sorted. pCurIdxLookUp = (LPIDXLOOKUPELEMENT)bsearch(&aeChange,rgIdxLookUp,(int)dwOriginalSize, sizeof(IDXLOOKUPELEMENT),CompareIdxLookUpElements); AssertMsg(pCurIdxLookUp,"Attempting to delete a record that does not exist. The change file and phone book versions do not match."); if (pCurIdxLookUp) pCurIdxLookUp->pAE = NULL; //Create a dead entry in the look up table m_cPhoneBookEntries--; } else { // This is an add entry m_cPhoneBookEntries++; dwUsed++; // Make sure we have enough room if (m_cPhoneBookEntries > dwAllocated) { // Grow phone book dwAllocated += CHANGE_BUFFER_SIZE; #ifdef WIN16 Assert(m_rgPhoneBookEntry); rgTemp = GlobalReAlloc(m_rgPhoneBookEntry,(int)(sizeof(ACCESSENTRY)*dwAllocated),GHND); Assert(rgTemp); if (!rgTemp) goto MergeExit; m_rgPhoneBookEntry = (PACCESSENTRY)rgTemp; // Grow look up index Assert(rgIdxLookUp); rgTemp = GlobalReAlloc(rgIdxLookUp,(int)(sizeof(IDXLOOKUPELEMENT)*dwAllocated),GHND); Assert(rgTemp); if (!rgTemp) goto MergeExit; rgIdxLookUp = (LPIDXLOOKUPELEMENT)rgTemp; #else Assert(m_hPhoneBookEntry); GlobalUnlock(m_hPhoneBookEntry); hTemp = (HANDLE)GlobalReAlloc(m_hPhoneBookEntry,sizeof(ACCESSENTRY)*dwAllocated,GHND); Assert(hTemp); if (!hTemp) goto MergeExit; m_hPhoneBookEntry = hTemp; m_rgPhoneBookEntry = (PACCESSENTRY)GlobalLock(m_hPhoneBookEntry); Assert(m_rgPhoneBookEntry); if (!m_rgPhoneBookEntry) goto MergeExit; // Grow look up index Assert(hIdxLookUp); GlobalUnlock(hIdxLookUp); hTemp = (HANDLE)GlobalReAlloc(hIdxLookUp,sizeof(IDXLOOKUPELEMENT)*dwAllocated,GHND); Assert(hTemp); if (!hTemp) goto MergeExit; hIdxLookUp = hTemp; rgIdxLookUp = (LPIDXLOOKUPELEMENT)GlobalLock(hIdxLookUp); Assert(rgIdxLookUp); if (!rgIdxLookUp) goto MergeExit; #endif } //Add entry to the end of the phonebook and to end of look up index CopyMemory(&m_rgPhoneBookEntry[m_cPhoneBookEntries],&aeChange,sizeof(ACCESSENTRY)); rgIdxLookUp[m_cPhoneBookEntries].dwIndex = m_rgPhoneBookEntry[m_cPhoneBookEntries].dwIndex; rgIdxLookUp[m_cPhoneBookEntries].pAE = &m_rgPhoneBookEntry[m_cPhoneBookEntries]; // NOTE: because the entry is added to the end of the list, we can't add // and delete entries in the same change file. } } while (TRUE); // resort the IDXLookUp index to reflect the correct order of enteries // for the phonebook file, including all of the entries to be deleted. qsort(rgIdxLookUp,(int)dwUsed,sizeof(IDXLOOKUPELEMENT),CompareIdxLookUpElementsFileOrder); // Build a new phonebook file #ifdef WIN16 GetTempFileName(0, TEMP_PHONE_BOOK_PREFIX, 0, szTempFileName); #else if (!GetTempPath(TEMP_BUFFER_LENGTH,szTempBuffer)) goto MergeExit; if (!GetTempFileName(szTempBuffer,TEMP_PHONE_BOOK_PREFIX,0,szTempFileName)) goto MergeExit; #endif hFile = CreateFile(szTempFileName,GENERIC_WRITE,0,NULL,CREATE_ALWAYS, FILE_FLAG_WRITE_THROUGH,0); if (hFile == INVALID_HANDLE_VALUE) goto MergeExit; for (dwIdx = 0; dwIdx < m_cPhoneBookEntries; dwIdx++) { cch = wsprintf(szTempBuffer, TEXT("%lu,%lu,%lu,%s,%s,%s,%lu,%lu,%lu,%lu,%s\r\n"), rgIdxLookUp[dwIdx].pAE->dwIndex, rgIdxLookUp[dwIdx].pAE->dwCountryID, DWORD(rgIdxLookUp[dwIdx].pAE->wStateID), rgIdxLookUp[dwIdx].pAE->szCity, rgIdxLookUp[dwIdx].pAE->szAreaCode, rgIdxLookUp[dwIdx].pAE->szAccessNumber, rgIdxLookUp[dwIdx].pAE->dwConnectSpeedMin, rgIdxLookUp[dwIdx].pAE->dwConnectSpeedMax, DWORD(rgIdxLookUp[dwIdx].pAE->bFlipFactor), DWORD(rgIdxLookUp[dwIdx].pAE->fType), rgIdxLookUp[dwIdx].pAE->szDataCenter); if (!WriteFile(hFile,szTempBuffer,cch,&cchWritten,NULL)) { // something went wrong, get rid of the temporary file CloseHandle(hFile); DeleteFile(szTempFileName); hr = GetLastError(); goto MergeExit; } Assert(cch == cchWritten); } CloseHandle(hFile); hFile = NULL; // Move new phone book over old if (!MoveFileEx(szTempFileName,m_szPhoneBook,MOVEFILE_REPLACE_EXISTING)) { hr = GetLastError(); goto MergeExit; } // discard the phonebook in memory #ifndef WIN16 Assert(m_hPhoneBookEntry); GlobalUnlock(m_hPhoneBookEntry); #endif m_rgPhoneBookEntry = NULL; m_cPhoneBookEntries = 0; GlobalFree(m_pLineCountryList); GlobalFree(m_rgIDLookUp); GlobalFree(m_rgNameLookUp); GlobalFree(m_rgState); m_cStates = 0; lstrcpy(szTempBuffer,m_szINFCode); m_szINFFile[0] = '\0'; m_szPhoneBook[0] = '\0'; m_szINFCode[0] = '\0'; // Reload it (and rebuild look up arrays) hr = Init(szTempBuffer); MergeExit: if (hr != ERROR_SUCCESS) { GlobalFree(rgIdxLookUp); if (pcCSVFile) delete pcCSVFile; CloseHandle(hFile); } return hr; } // ############################################################################ HRESULT CPhoneBook::ReadOneLine(PACCESSENTRY lpAccessEntry, CCSVFile far *pcCSVFile) { HRESULT hr = ERROR_SUCCESS; #if !defined(WIN16) ReadOneLineStart: #endif //WIN16 if (!ReadPhoneBookDW(&lpAccessEntry->dwIndex,pcCSVFile)) { hr = ERROR_NO_MORE_ITEMS; // no more enteries goto ReadExit; } ReadVerifyPhoneBookDW(lpAccessEntry->dwCountryID); ReadVerifyPhoneBookW(lpAccessEntry->wStateID); ReadVerifyPhoneBookSZ(lpAccessEntry->szCity,cbCity); ReadVerifyPhoneBookSZ(lpAccessEntry->szAreaCode,cbAreaCode); // NOTE: 0 is a valid area code and ,, is a valid entry for an area code if (!FSz2Dw(lpAccessEntry->szAreaCode,&lpAccessEntry->dwAreaCode)) lpAccessEntry->dwAreaCode = NO_AREA_CODE; ReadVerifyPhoneBookSZ(lpAccessEntry->szAccessNumber,cbAccessNumber); ReadVerifyPhoneBookDW(lpAccessEntry->dwConnectSpeedMin); ReadVerifyPhoneBookDW(lpAccessEntry->dwConnectSpeedMax); ReadVerifyPhoneBookB(lpAccessEntry->bFlipFactor); ReadVerifyPhoneBookDW(lpAccessEntry->fType); ReadVerifyPhoneBookSZ(lpAccessEntry->szDataCenter,cbDataCenter); switch (lpAccessEntry->bFlipFactor) { case BOTH_ISDN_ANALOG: // This phone number supports both ISDN or Analog, return true // We want analog numbers, check the FlipFactor for zero lpAccessEntry->fType |= MASK_ISDN_BIT | MASK_ANALOG_BIT; break; case ANALOG_TYPE: // Analog only lpAccessEntry->fType |= MASK_ANALOG_BIT; break; case ISDN_TYPE: // We only want ISDN numbers lpAccessEntry->fType |= MASK_ISDN_BIT; break; } #if !defined(WIN16) // // If scripting is not available and the phonebook entry has a dun file other than // icwip.dun, then ignore the entry and read the one after that. // if (!m_bScriptingAvailable) { if (0 != lstrcmpi(lpAccessEntry->szDataCenter,TEXT("icwip.dun"))) { ZeroMemory(lpAccessEntry,sizeof(ACCESSENTRY)); goto ReadOneLineStart; } } #endif //WIN16 ReadExit: return hr; ReadError: hr = ERROR_INVALID_DATA; goto ReadExit; } // ############################################################################ HRESULT CPhoneBook::Suggest(PSUGGESTINFO pSuggest) { WORD wNumFound = 0; HRESULT hr = ERROR_NOT_ENOUGH_MEMORY; // char szFileName[MAX_PATH]; // char *pszTemp; // HANDLE hFile=NULL; // HANDLE hMap=NULL; // DWORD dwSize; // LPNPABLOCK rg950Data = NULL; // NPABLOCK *p950Data; // Validate parameters Assert(pSuggest); Assert(pSuggest->wNumber); if (wNumFound == pSuggest->wNumber) goto SuggestExit; LPIDLOOKUPELEMENT pCurLookUp; PACCESSENTRY lpAccessEntry; //REVIEW: double check this pCurLookUp = (LPIDLOOKUPELEMENT)bsearch(&pSuggest->dwCountryID,m_rgIDLookUp, (int)m_pLineCountryList->dwNumCountries,sizeof(IDLOOKUPELEMENT), CompareIDLookUpElements); // Check for invalid country if (!pCurLookUp) goto SuggestExit; // Check if there are any phone numbers for this country if (!pCurLookUp->pFirstAE) goto SuggestExit; lpAccessEntry = pCurLookUp->pFirstAE; do { // check for the right area code if (lpAccessEntry->dwAreaCode == pSuggest->wAreaCode) { // check for the right type of number if ((lpAccessEntry->fType & pSuggest->bMask) == pSuggest->fType) { pSuggest->rgpAccessEntry[wNumFound] = lpAccessEntry; wNumFound++; } } lpAccessEntry++; } while ((lpAccessEntry <= &m_rgPhoneBookEntry[m_cPhoneBookEntries-1]) && (wNumFound < pSuggest->wNumber) && (lpAccessEntry->dwCountryID == pSuggest->dwCountryID)); // // MKarki - Bug 340 no need to list more numbers if one already found // in Area Code specified by user // // 5/24/97 jmazner Olympus #340 and #71 // nope, this is wrong. We always want to return as many applicable // phone numbers as we find. Just because the area code matches // doesn't mean that we've found an ideal phone number. //if (wNumFound == 0) //{ // // if we couldn't find enough numnbers, try something else // // 10/15/96 jmazner ported fixes below from core\client\phbk // // Do this only if area code is not 0 - Bug #9349 (VetriV) // if ((pSuggest->wAreaCode != 0) && (wNumFound < pSuggest->wNumber)) // // No, there are some places (Finland? ChrisK knows) where 0 is a legit area code -- jmazner if (wNumFound < pSuggest->wNumber) { lpAccessEntry = pCurLookUp->pFirstAE; // Note: we are now only looking for Nationwide phone numbers (state = 0) // 8/13/96 jmazner MOS Normandy #4597 // We want nationwide toll-free numbers to display last, so for this pass, // only consider numbers that are _not_ toll free (fType bit #1 = 0) // // 5/24/97 jmazner Olympus #71 // As per GeoffR's spec, the search passes should not be based on // the tollfree bit at all // // 5/28/97 jmazner Olympus #71 // ahem...as per GeoffR's new spec, we _should_ consider the tollfree // bit and in this query only bring up toll free numbers. // // so, we will only return numbers whose area code match, or which are // tollfree // // // Tweak pSuggest->bMask to let through the toll/charge bit // pSuggest->bMask |= MASK_TOLLFREE_BIT; // //Tweak pSuggest->ftype to be charge //pSuggest->fType &= TYPE_SET_TOLL; // // make that tollfree! pSuggest->fType |= TYPE_SET_TOLLFREE; do { // 8/13/96 jmazner MOS Normandy #4598 // If this entry's area code matches pSuggest->wAreaCode, then we already // have included it in the previous pass, so don't duplicate it again here. if ((lpAccessEntry->fType & pSuggest->bMask) == pSuggest->fType && lpAccessEntry->wStateID == 0 && lpAccessEntry->dwAreaCode != pSuggest->wAreaCode) { pSuggest->rgpAccessEntry[wNumFound] = lpAccessEntry; wNumFound++; } lpAccessEntry++; } while ((lpAccessEntry <= &m_rgPhoneBookEntry[m_cPhoneBookEntries-1]) && (wNumFound < pSuggest->wNumber) && (lpAccessEntry->dwCountryID == pSuggest->dwCountryID) && (lpAccessEntry->wStateID == 0) ); } // 8/13/96 jmazner MOS Normandy #4597 // if we STILL couldn't find enough numnbers, widen the search to include tollfree #s // // 5/24/97 jmazner Olympus #71 // no need for this pass at all. See earlier comments. /**** if (wNumFound < pSuggest->wNumber) { lpAccessEntry = pCurLookUp->pFirstAE; // Tweak pSuggest->bMask to let through the toll/charge bit // REDUNDANT? If we made it to this point, we _should_ have done this above... // Better safe than sorry! Assert(pSuggest->bMask & MASK_TOLLFREE_BIT); pSuggest->bMask |= MASK_TOLLFREE_BIT; // Tweak pSuggest->ftype to be tollfree pSuggest->fType |= TYPE_SET_TOLLFREE; do { // 8/13/96 jmazner MOS Normandy #4598 // If this entry's area code matches pSuggest->wAreaCode, then we already // have included it in the first pass, so don't include it here. // Any entry that made it in in the 2nd pass will definitely not make it in here // (because of tollfree bit), so no need to worry about dups from there. if ((lpAccessEntry->fType & pSuggest->bMask) == pSuggest->fType && lpAccessEntry->wStateID == 0 && lpAccessEntry->dwAreaCode != pSuggest->wAreaCode) { pSuggest->rgpAccessEntry[wNumFound] = lpAccessEntry; wNumFound++; } lpAccessEntry++; } while ((lpAccessEntry <= &m_rgPhoneBookEntry[m_cPhoneBookEntries-1]) && (wNumFound < pSuggest->wNumber) && (lpAccessEntry->dwCountryID == pSuggest->dwCountryID) && (lpAccessEntry->wStateID == 0) ); } ****/ //} // End of If for Bug - 340 - MKarki /* // Flip factoring if (wNumFound == 2) { SYSTEMTIME st; GetSystemTime(&st); srand((UINT)st.wMilliseconds); if ((rand() % 10) > pSuggest->rgLPACCESSENTRY[0]->bFlipFactor) { lpAccessEntry = pSuggest->rgLPACCESSENTRY[0]; pSuggest->rgpAccessEntry[0] = pSuggest->rgpAccessEntry[1]; pSuggest->rgpAccessEntry[1] = lpAccessEntry; } } */ hr = ERROR_SUCCESS; SuggestExit: pSuggest->wNumber = wNumFound; return hr; } // ############################################################################ HRESULT CPhoneBook::GetCanonical (PACCESSENTRY pAE, LPTSTR psOut) { HRESULT hr = ERROR_SUCCESS; LPIDLOOKUPELEMENT pIDLookUp; pIDLookUp = (LPIDLOOKUPELEMENT)bsearch(&pAE->dwCountryID,m_rgIDLookUp, (int)m_pLineCountryList->dwNumCountries,sizeof(IDLOOKUPELEMENT),CompareIdxLookUpElements); if (!pIDLookUp) { hr = ERROR_INVALID_PARAMETER; } else { SzCanonicalFromAE (psOut, pAE, pIDLookUp->pLCE); } return hr; } // ############################################################################ DllExportH PhoneBookLoad(LPCTSTR pszISPCode, DWORD_PTR far *pdwPhoneID) { HRESULT hr = ERROR_NOT_ENOUGH_MEMORY; CPhoneBook far *pcPhoneBook; if (!g_hInstDll) g_hInstDll = GetModuleHandle(NULL); // validate parameters Assert(pszISPCode && *pszISPCode && pdwPhoneID); *pdwPhoneID = NULL; // allocate phone book pcPhoneBook = new CPhoneBook; // initialize phone book if (pcPhoneBook) hr = pcPhoneBook->Init(pszISPCode); // in case of failure if (hr && pcPhoneBook) { delete pcPhoneBook; } else { *pdwPhoneID = (DWORD_PTR)pcPhoneBook; } #if defined(WIN16) if (!hr) BMP_RegisterClass(g_hInstDll); #endif return hr; } // ############################################################################ DllExportH PhoneBookUnload(DWORD_PTR dwPhoneID) { Assert(dwPhoneID); if (dwPhoneID) { #if defined(WIN16) BMP_DestroyClass(g_hInstDll); #endif // Release contents delete (CPhoneBook far*)dwPhoneID; } return ERROR_SUCCESS; } // ############################################################################ DllExportH PhoneBookMergeChanges(DWORD_PTR dwPhoneID, LPCTSTR pszChangeFile) { return ((CPhoneBook far*)dwPhoneID)->Merge(pszChangeFile); } // ############################################################################ DllExportH PhoneBookSuggestNumbers(DWORD_PTR dwPhoneID, PSUGGESTINFO lpSuggestInfo) { HRESULT hr = ERROR_NOT_ENOUGH_MEMORY; // get suggested numbers lpSuggestInfo->rgpAccessEntry = (PACCESSENTRY *)GlobalAlloc(GPTR,sizeof(PACCESSENTRY) * lpSuggestInfo->wNumber); if (lpSuggestInfo->rgpAccessEntry) { hr = ((CPhoneBook far *)dwPhoneID)->Suggest(lpSuggestInfo); } return hr; } // ############################################################################ DllExportH PhoneBookGetCanonical (DWORD_PTR dwPhoneID, PACCESSENTRY pAE, LPTSTR psOut) { return ((CPhoneBook far*)dwPhoneID)->GetCanonical(pAE,psOut); } // ############################################################################ DllExportH PhoneBookDisplaySignUpNumbers (DWORD_PTR dwPhoneID, LPTSTR far *ppszPhoneNumbers, LPTSTR far *ppszDunFiles, WORD far *pwPhoneNumbers, DWORD far *pdwCountry, WORD far *pwRegion, BYTE fType, BYTE bMask, HWND hwndParent, DWORD dwFlags) { HRESULT hr; AssertMsg(ppszPhoneNumbers && pwPhoneNumbers && pdwCountry &&pwRegion,"invalid parameters"); //CAccessNumDlg *pcDlg; CSelectNumDlg far *pcDlg; pcDlg = new CSelectNumDlg; if (!pcDlg) { hr = GetLastError(); goto DisplayExit; } // Initialize information for dialog // pcDlg->m_dwPhoneBook = dwPhoneID; pcDlg->m_dwCountryID = *pdwCountry; pcDlg->m_wRegion = *pwRegion; pcDlg->m_fType = fType; pcDlg->m_bMask = bMask; pcDlg->m_dwFlags = dwFlags; // invoke the dialog // // BUG: NOT THREAD SAFE!! g_hWndMain = hwndParent; hr = (HRESULT)DialogBoxParam(g_hInstDll,MAKEINTRESOURCE(IDD_SELECTNUMBER), g_hWndMain, PhbkGenericDlgProc,(LPARAM)pcDlg); g_hWndMain = NULL; if (hr == IDC_CMDNEXT) { *pwRegion = pcDlg->m_wRegion; *pdwCountry = pcDlg->m_dwCountryID; Assert (ppszPhoneNumbers[0] && ppszDunFiles[0]); lstrcpy(ppszPhoneNumbers[0],&pcDlg->m_szPhoneNumber[0]); lstrcpy(ppszDunFiles[0],&pcDlg->m_szDunFile[0]); hr = ERROR_SUCCESS; } else if (hr == IDC_CMDBACK) hr = ERROR_USERBACK; else hr = ERROR_USERCANCEL; // hr == -1; DisplayExit: if (pcDlg) delete pcDlg; return hr; } //DllExportH TestBar() //{ // LPCSTR pszISPCode; // LPDWORD pdwPhoneID; // // HRESULT hr = ERROR_NOT_ENOUGH_MEMORY; // CPhoneBook FAR *pcPhoneBook; // // if (!g_hInstDll) // g_hInstDll = GetModuleHandle(NULL); // // // validate parameters ////1 Assert(pszISPCode && *pszISPCode && pdwPhoneID); ////1 *pdwPhoneID = NULL; // // // allocate phone book ////1 pcPhoneBook = new CPhoneBook; // // // initialize phone book // if (pcPhoneBook) // hr = pcPhoneBook->Init(pszISPCode); // // // in case of failure // if (hr && pcPhoneBook) // { // delete pcPhoneBook; // } else { // *pdwPhoneID = (DWORD)pcPhoneBook; // } // ////2#if defined(WIN16) ////2 if (!hr) ////2 BMP_RegisterClass(g_hInstDll); ////2#endif // // return hr; //} // //++-------------------------------------------------------------- // // API : GetSupportNumbers // // Synopsis: This is the API used to get the support // numbers // // Returns: HRESULT - success or error info // // Arguments: [OUT] PSUPPORTNUM - array of SUPPORTNUM structs // [IN/OUT] PDWORD - mem for buffersize // // Called By: by the EXE using the ICWPHBK.DLL // // History: MKarki Created 5/8/97 // //---------------------------------------------------------------- DllExportH GetSupportNumbers ( PSUPPORTNUM pBuffer, PDWORD pBufferSize ) { return (GetSupportNumsFromFile (pBuffer, pBufferSize)); } // end of GetSupportNumbers API call