windows-server-2003/inetcore/connectionwizard/inetcfg/rnacall.cpp

//*********************************************************************
//*                  Microsoft Windows                               **
//*            Copyright(c) Microsoft Corp., 1994                    **
//*********************************************************************
//
//  RNACALL.C - functions to call RNA dll to create connectoid
//
//  HISTORY:
//  
//  1/18/95   jeremys Cloned from RNA UI code
//  96/01/31  markdu  Renamed CONNENTDLG to OLDCONNENTDLG to avoid
//            conflicts with RNAP.H.
//  96/02/23  markdu  Replaced RNAValidateEntryName with
//            RASValidateEntryName
//  96/02/24  markdu  Re-wrote the implementation of ENUM_MODEM to
//            use RASEnumDevices() instead of RNAEnumDevices().
//            Also eliminated IsValidDevice() and RNAGetDeviceInfo().
//  96/02/24  markdu  Re-wrote the implementation of ENUM_CONNECTOID to
//            use RASEnumEntries() instead of RNAEnumConnEntries().
//  96/02/26  markdu  Replaced all remaining internal RNA APIs.
//  96/03/07  markdu  Extend ENUM_MODEM class, and use global modem
//            enum object.
//  96/03/08  markdu  Do complete verification of device name and type
//            strings passed in to CreateConnectoid.
//  96/03/09  markdu  Moved generic RASENTRY initialization into
//            its own function (InitRasEntry).  Added a wait cursor
//            during loading of RNA.
//  96/03/09  markdu  Added LPRASENTRY parameter to CreateConnectoid()
//  96/03/09  markdu  Moved all references to 'need terminal window after
//            dial' into RASENTRY.dwfOptions.
//            Also no longer need GetConnectoidPhoneNumber function.
//  96/03/10  markdu  Moved all references to modem name into RASENTRY.
//  96/03/10  markdu  Moved all references to phone number into RASENTRY.
//  96/03/11  markdu  Moved code to set username and password out of
//            CreateConnectoid into SetConnectoidUsername so it can be reused.
//  96/03/11  markdu  Added some flags in InitRasEntry.
//  96/03/13  markdu  Change ValidateConncectoidName to take LPCSTR.
//  96/03/16  markdu  Added ReInit member function to re-enumerate modems.
//  96/03/21  markdu  Work around RNA bug in ENUM_MODEM::ReInit().
//  96/03/24  markdu  Replaced memset with ZeroMemory for consistency.
//  96/03/24  markdu  Replaced lstrcpy with lstrcpyn where appropriate.
//  96/03/25  markdu  Removed GetIPInfo and SetIPInfo.
//  96/04/04  markdu  Added phonebook name param to CreateConnectoid,
//            ValidateConnectoidName, and SetConnectoidUsername.
//  96/04/07  markdu  NASH BUG 15645 Work around RNA bug where area code
//            string is required even though it is not being used.
//  96/04/26  markdu  NASH BUG 18605 Handle ERROR_FILE_NOT_FOUND return
//            from ValidateConnectoidName.
//  96/05/14  markdu  NASH BUG 22730 Work around RNA bug.  Flags for terminal
//            settings are swapped by RasSetEntryproperties.
//  96/05/16  markdu  NASH BUG 21810 Added function for IP address validation.
//  96/06/04  markdu  OSR  BUG 7246 Add RASEO_SwCompression and
//            RASEO_ModemLights to default RASENTRY.
//

#include "wizard.h"
#include "tapi.h"

#include "wininet.h"

// WARNING  This flag is defined if WINVER is >= 0x500, but we do not want to build with WINVER >= 0x500
// since we must be able to run on older platforms (Win 95, etc).  This is defined original in ras.h
#ifndef RASEO_ShowDialingProgress
#define RASEO_ShowDialingProgress       0x04000000
#endif
// WARNING  This flag is defined if WINVER is >= 401, but we do not want to build with WINVER >= 401
// since we must be able to run on older platforms (Win 95, etc)
#ifndef RASEO_SecureLocalFiles
#define RASEO_SecureLocalFiles          0x00010000
#endif

typedef BOOL (WINAPI * INTERNETSETOPTION) (IN HINTERNET hInternet OPTIONAL,IN DWORD dwOption,IN LPVOID lpBuffer,IN DWORD dwBufferLength);
static const TCHAR cszWininet[] = TEXT("WININET.DLL");
static const  CHAR cszInternetSetOption[] = "InternetSetOptionA";

// instance handle must be in per-instance data segment
#pragma data_seg(DATASEG_PERINSTANCE)

// Global variables
HINSTANCE ghInstRNADll=NULL; // handle to RNA dll we load explicitly
HINSTANCE ghInstRNAPHDll=NULL;  // handle to RNAPH dll we load explicitly
DWORD     dwRefCount=0;
BOOL      fRNALoaded=FALSE; // TRUE if RNA function addresses have been loaded
TCHAR *   gpCountryCodeBuf = NULL;  // global list of COUNTRYCODE structures

// global function pointers for RNA apis
RASGETCOUNTRYINFO       lpRasGetCountryInfo=NULL;
RASENUMDEVICES          lpRasEnumDevices=NULL;
RASVALIDATEENTRYNAME    lpRasValidateEntryName=NULL;
RASGETENTRYDIALPARAMS   lpRasGetEntryDialParams=NULL;
RASSETENTRYDIALPARAMS   lpRasSetEntryDialParams=NULL;
RASGETERRORSTRING       lpRasGetErrorString=NULL;
RASSETENTRYPROPERTIES   lpRasSetEntryProperties=NULL;
RASGETENTRYPROPERTIES   lpRasGetEntryProperties=NULL;
RASENUMENTRIES          lpRasEnumEntries=NULL;

// API table for function addresses to fetch
#define NUM_RNAAPI_PROCS   9
APIFCN RnaApiList[NUM_RNAAPI_PROCS] =
{
  { (PVOID *) &lpRasEnumDevices,szRasEnumDevices},
  { (PVOID *) &lpRasGetCountryInfo,szRasGetCountryInfo},
  { (PVOID *) &lpRasValidateEntryName,szRasValidateEntryName},
  { (PVOID *) &lpRasGetEntryDialParams,szRasGetEntryDialParams},
  { (PVOID *) &lpRasSetEntryDialParams,szRasSetEntryDialParams},
  { (PVOID *) &lpRasGetErrorString,szRasGetErrorString},
  { (PVOID *) &lpRasSetEntryProperties,szRasSetEntryProperties},
  { (PVOID *) &lpRasGetEntryProperties,szRasGetEntryProperties},
  { (PVOID *) &lpRasEnumEntries,szRasEnumEntries}
};
//BUGBUG 21-May-1995 bens use #define...sizeof() to define NUM_RNAAPI_PROCS

#pragma data_seg(DATASEG_DEFAULT)

VOID  ShortenName(LPTSTR szLongName, LPTSTR szShortName, DWORD cbShort);
BOOL  GetApiProcAddresses(HMODULE hModDLL,APIFCN * pApiProcList,UINT nApiProcs);
VOID  SwapDwBytes(LPDWORD lpdw);
void  SwapDWBits(LPDWORD lpdw, DWORD dwBit1, DWORD dwBit2);

#define NO_INTRO  0x00000080  // flag used by RNA wizard
#define US_COUNTRY_CODE    1  // US country code is 1
#define US_COUNTRY_ID      1  // US country ID is 1

/*******************************************************************

  NAME:    InitRNA

  SYNOPSIS:  Loads the RNA dll (RASAPI32), gets proc addresses,
        and loads RNA engine

  EXIT:    TRUE if successful, or FALSE if fails.  Displays its
        own error message upon failure.

  NOTES:    We load the RNA dll explicitly and get proc addresses
        because these are private APIs and not guaranteed to
        be supported beyond Windows 95.  This way, if the DLL
        isn't there or the entry points we expect aren't there,
        we can display a coherent message instead of the weird
        Windows dialog you get if implicit function addresses
        can't be resolved.

********************************************************************/
BOOL InitRNA(HWND hWnd)
{
  DEBUGMSG("rnacall.c::InitRNA()");

  // only actually do init stuff on first call to this function
  // (when reference count is 0), just increase reference count
  // for subsequent calls
  if (dwRefCount == 0) {

    TCHAR szRNADll[SMALL_BUF_LEN];

    DEBUGMSG("Loading RNA DLL");

    // set an hourglass cursor
    WAITCURSOR WaitCursor;

    // get the filename (RASAPI32.DLL) out of resource
    LoadSz(IDS_RNADLL_FILENAME,szRNADll,ARRAYSIZE(szRNADll));

    // load the RNA api dll
    ghInstRNADll = LoadLibrary(szRNADll);
    if (!ghInstRNADll) {
      UINT uErr = GetLastError();
      DisplayErrorMessage(hWnd,IDS_ERRLoadRNADll1,uErr,ERRCLS_STANDARD,
        MB_ICONSTOP);
      return FALSE;
    }

    // cycle through the API table and get proc addresses for all the APIs we
    // need
    if (!GetApiProcAddresses(ghInstRNADll,RnaApiList,NUM_RNAAPI_PROCS)) {
      MsgBox(hWnd,IDS_ERRLoadRNADll2,MB_ICONSTOP,MB_OK);
      DeInitRNA();
      return FALSE;
    }

  }

  fRNALoaded = TRUE;

  dwRefCount ++;

  return TRUE;
}

/*******************************************************************

  NAME:    DeInitRNA

  SYNOPSIS:  Unloads RNA dll.

********************************************************************/
VOID DeInitRNA()
{
  DEBUGMSG("rnacall.c::DeInitRNA()");

  UINT nIndex;

  // decrement reference count
  if (dwRefCount)
    dwRefCount --;

  // when the reference count hits zero, do real deinitialization stuff
  if (dwRefCount == 0)
  {
    if (fRNALoaded)
    {
      // set function pointers to NULL
      for (nIndex = 0;nIndex<NUM_RNAAPI_PROCS;nIndex++) 
        *RnaApiList[nIndex].ppFcnPtr = NULL;

      fRNALoaded = FALSE;
    }

    // free the RNA dll
    if (ghInstRNADll)
    {
    DEBUGMSG("Unloading RNA DLL");
      FreeLibrary(ghInstRNADll);
      ghInstRNADll = NULL;
    }

    // free the RNAPH dll
    if (ghInstRNAPHDll)
    {
    DEBUGMSG("Unloading RNAPH DLL");
      FreeLibrary(ghInstRNAPHDll);
      ghInstRNAPHDll = NULL;
    }
  }
}

/*******************************************************************

  NAME:    CreateConnectoid

  SYNOPSIS:  Creates a connectoid (phone book entry) with specified
        name and phone number

  ENTRY:    pszConnectionName - name for the new connectoid
        pszUserName - optional.  If non-NULL, this will be set for the
          user name in new connectoid
        pszPassword - optional.  If non-NULL, this will be set for the
          password in new connectoid

  EXIT:    returns ERROR_SUCCESS if successful, or an RNA error code

  HISTORY:
  96/02/26  markdu    Moved ClearConnectoidIPParams functionality 
            into CreateConnectoid

********************************************************************/
DWORD CreateConnectoid(LPCTSTR pszPhonebook, LPCTSTR pszConnectionName,
  LPRASENTRY lpRasEntry, LPCTSTR pszUserName,LPCTSTR pszPassword)
{
  DEBUGMSG("rnacall.c::CreateConnectoid()");

  DWORD dwRet;

  ASSERT(pszConnectionName);

  // if we don't have a valid RasEntry, bail
  if ((NULL == lpRasEntry) || (sizeof(RASENTRY) != lpRasEntry->dwSize))
  {
    return ERROR_INVALID_PARAMETER;
  }

  // Load RNA if not already loaded
  dwRet = EnsureRNALoaded();
  if (ERROR_SUCCESS != dwRet)
  {
    return dwRet;
  }

  // Enumerate the modems.
  if (gpEnumModem)
  {
    // Re-enumerate the modems to be sure we have the most recent changes  
    dwRet = gpEnumModem->ReInit();
  }
  else
  {
    // The object does not exist, so create it.
    gpEnumModem = new ENUM_MODEM;
    if (gpEnumModem)
    {
      dwRet = gpEnumModem->GetError();
    }
    else
    {
      dwRet = ERROR_NOT_ENOUGH_MEMORY;
    }
  }
  if (ERROR_SUCCESS != dwRet)
  {
    return dwRet;
  }

  // Make sure there is at least one device
  if (0 == gpEnumModem->GetNumDevices())
  {
    return ERROR_DEVICE_DOES_NOT_EXIST;
  }

  // Validate the device if possible
  if (lstrlen(lpRasEntry->szDeviceName) && lstrlen(lpRasEntry->szDeviceType))
  {
    // Verify that there is a device with the given name and type
    if (!gpEnumModem->VerifyDeviceNameAndType(lpRasEntry->szDeviceName, 
      lpRasEntry->szDeviceType))
    {
      // There was no device that matched both name and type,
      // so try to get the first device with matching name.
      LPTSTR szDeviceType = 
        gpEnumModem->GetDeviceTypeFromName(lpRasEntry->szDeviceName);
      if (szDeviceType)
      {
        lstrcpy (lpRasEntry->szDeviceType, szDeviceType);
      }
      else
      {
        // There was no device that matched the given name,
        // so try to get the first device with matching type.
        // If this fails, fall through to recovery case below.
        LPTSTR szDeviceName = 
          gpEnumModem->GetDeviceNameFromType(lpRasEntry->szDeviceType);
        if (szDeviceName)
        {
          lstrcpy (lpRasEntry->szDeviceName, szDeviceName);
        }
        else
        {
          // There was no device that matched the given name OR
          // the given type.  Reset the values so they will be
          // replaced with the first device.
          lpRasEntry->szDeviceName[0] = '\0';
          lpRasEntry->szDeviceType[0] = '\0';
        }
      }
    }
  }
  else if (lstrlen(lpRasEntry->szDeviceName))
  {
    // Only the name was given.  Try to find a matching type.
    // If this fails, fall through to recovery case below.
    LPTSTR szDeviceType = 
      gpEnumModem->GetDeviceTypeFromName(lpRasEntry->szDeviceName);
    if (szDeviceType)
    {
      lstrcpy (lpRasEntry->szDeviceType, szDeviceType);
    }
  }
  else if (lstrlen(lpRasEntry->szDeviceType))
  {
    // Only the type was given.  Try to find a matching name.
    // If this fails, fall through to recovery case below.
    LPTSTR szDeviceName = 
      gpEnumModem->GetDeviceNameFromType(lpRasEntry->szDeviceType);
    if (szDeviceName)
    {
      lstrcpy (lpRasEntry->szDeviceName, szDeviceName);
    }
  }

  // If either name or type is missing, just get first device.
  // Since we already verified that there was at least one device,
  // we can assume that this will succeed.
  if(!lstrlen(lpRasEntry->szDeviceName) ||
     !lstrlen(lpRasEntry->szDeviceType))
  {
    lstrcpy (lpRasEntry->szDeviceName, gpEnumModem->Next());
    lstrcpy (lpRasEntry->szDeviceType,
      gpEnumModem->GetDeviceTypeFromName(lpRasEntry->szDeviceName));
    ASSERT(lstrlen(lpRasEntry->szDeviceName));
    ASSERT(lstrlen(lpRasEntry->szDeviceType));
  }

  // Verify the connectoid name
  dwRet = ValidateConnectoidName(pszPhonebook, pszConnectionName);
  if ((ERROR_SUCCESS != dwRet) &&
    (ERROR_ALREADY_EXISTS != dwRet))
  {
    DEBUGMSG("RasValidateEntryName returned %lu",dwRet);
    return dwRet;
  }

  // 99/04/13  vyung  NT5 BUG 279833
  // New features in NT5 to show progress while dialing. Enable it by default
  if (IsNT5())
  {
    // For NT 5 and greater, File sharing is disabled per connectoid by setting this RAS option.
    lpRasEntry->dwfOptions |= RASEO_SecureLocalFiles;  
    lpRasEntry->dwfOptions |= RASEO_ShowDialingProgress;
  }

  //  96/04/07  markdu  NASH BUG 15645
  // If there is no area code string, and RASEO_UseCountryAndAreaCodes is not
  // set, then the area code will be ignored so put in a default otherwise the
  // call to RasSetEntryProperties will fail due to an RNA bug.
  // if RASEO_UseCountryAndAreaCodes is set, then area code is required, so not
  // having one is an error.  Let RNA report the error.
  if (!lstrlen(lpRasEntry->szAreaCode) &&
    !(lpRasEntry->dwfOptions & RASEO_UseCountryAndAreaCodes))
  {
    lstrcpy (lpRasEntry->szAreaCode, szDefaultAreaCode);
  }

  // 96/05/14 markdu  NASH BUG 22730 Work around RNA bug.  Flags for terminal
  // settings are swapped by RasSetEntryproperties, so we swap them before
  // the call.  
  if (IsWin95())
      SwapDWBits(&lpRasEntry->dwfOptions, RASEO_TerminalBeforeDial,
      RASEO_TerminalAfterDial);

  // call RNA to create the connectoid
  ASSERT(lpRasSetEntryProperties);
#ifdef UNICODE
  LPRASENTRY lpRasEntryTmp;

  lpRasEntryTmp = (LPRASENTRY)GlobalAlloc(GPTR, sizeof(RASENTRY) + 512);
  if(lpRasEntry)
    memcpy(lpRasEntryTmp, lpRasEntry, sizeof(RASENTRY));
  else
    lpRasEntryTmp = (LPRASENTRY)lpRasEntry;

  dwRet = lpRasSetEntryProperties(pszPhonebook, pszConnectionName,
    (LPBYTE)lpRasEntryTmp, sizeof(RASENTRY)+512, NULL, 0);

  if(lpRasEntryTmp && lpRasEntryTmp != (LPRASENTRY)lpRasEntry)
  {
    memcpy(lpRasEntry, lpRasEntryTmp, sizeof(RASENTRY));
    GlobalFree(lpRasEntryTmp);
  }

#else
  dwRet = lpRasSetEntryProperties(pszPhonebook, pszConnectionName,
    (LPBYTE)lpRasEntry, sizeof(RASENTRY), NULL, 0);
#endif

  // 96/05/14 markdu  NASH BUG 22730 Work around RNA bug.  Put the bits back
  // to the way they were originally,
  if (IsWin95())
    SwapDWBits(&lpRasEntry->dwfOptions, RASEO_TerminalBeforeDial,
    RASEO_TerminalAfterDial);

  // populate the connectoid with user's account name and password.
  if (dwRet == ERROR_SUCCESS)
  {
    if (pszUserName || pszPassword)
    {
      dwRet = SetConnectoidUsername(pszPhonebook, pszConnectionName,
        pszUserName, pszPassword);
    }
  }
  else
  {
    DEBUGMSG("RasSetEntryProperties returned %lu",dwRet);
  }

  if (dwRet == ERROR_SUCCESS)
  {
    // BUGBUG This prevents the make new connection wizard from being
    //        launched the first time the user opens the RNA folder.
    //        Now that we own the make new connection wizard, we
    //        have to decide whether to do this or not.
    // set a flag to tell RNA not to run the RNA wizard automatically
    // when the folder is opened (they set this flag from their wizard
    // whenever they create a new connectoid).  If this fails just
    // go on, not a critical error
    RegEntry reRNAFolder(szRegPathRNAWizard,HKEY_CURRENT_USER);
    ASSERT(reRNAFolder.GetError() == ERROR_SUCCESS);
    DWORD dwVal = NO_INTRO;
    RegSetValueEx(reRNAFolder.GetKey(),szRegValRNAWizard,
      0,REG_BINARY,(LPBYTE) &dwVal,sizeof(dwVal));


    // We don't use auto discovery for referral and signup connectoid
    if (!g_bUseAutoProxyforConnectoid)
    {
        // VYUNG 12/16/1998
        // REMOVE AUTO DISCOVERY FROM THE DIALUP CONNECTOID

        INTERNET_PER_CONN_OPTION_LISTA list;
        DWORD   dwBufSize = sizeof(list);

        // fill out list struct
        list.dwSize = sizeof(list);
        CHAR szConnectoid [RAS_MaxEntryName];
#ifdef UNICODE
        wcstombs(szConnectoid, pszConnectionName, RAS_MaxEntryName);
#else
        lstrcpyn(szConnectoid, pszConnectionName, lstrlen(pszConnectionName)+1);
#endif
        list.pszConnection = szConnectoid;         
        list.dwOptionCount = 1;                         // one option
        list.pOptions = new INTERNET_PER_CONN_OPTIONA[1];   

        if(list.pOptions)
        {
            // set flags
            list.pOptions[0].dwOption = INTERNET_PER_CONN_FLAGS;
            list.pOptions[0].Value.dwValue = PROXY_TYPE_DIRECT;           // no proxy, autoconfig url, or autodiscovery

            // tell wininet
            HINSTANCE hInst = NULL;
            FARPROC fpInternetSetOption = NULL;

            dwRet = ERROR_SUCCESS;
    
            hInst = LoadLibrary(cszWininet);
            if (hInst)
            {
                fpInternetSetOption = GetProcAddress(hInst,cszInternetSetOption);
                if (fpInternetSetOption)
                {
                    if( !((INTERNETSETOPTION)fpInternetSetOption) (NULL, INTERNET_OPTION_PER_CONNECTION_OPTION, &list, dwBufSize) )
                    {
                        dwRet = GetLastError();
                        DEBUGMSG("INETCFG export.c::InetSetAutodial() InternetSetOption failed");
                    }
                }
                else
                    dwRet = GetLastError();
                FreeLibrary(hInst);
            }

            delete [] list.pOptions;
        }
    }

  }

  return dwRet;
}

/*******************************************************************

  NAME:    InitModemList

  SYNOPSIS:  Fills a combo box window with installed modems

  ENTRY:    hCB - combo box window to fill
  
********************************************************************/
HRESULT InitModemList (HWND hCB)
{
  DEBUGMSG("rnacall.c::InitModemList()");

  LPTSTR pNext;
  int   nIndex;
  DWORD dwRet;

  ASSERT(hCB);

  // Load RNA if not already loaded
  dwRet = EnsureRNALoaded();
  if (ERROR_SUCCESS != dwRet)
  {
    return dwRet;
  }

  // Enumerate the modems.
  if (gpEnumModem)
  {
    // Re-enumerate the modems to be sure we have the most recent changes  
    dwRet = gpEnumModem->ReInit();
  }
  else
  {
    // The object does not exist, so create it.
    gpEnumModem = new ENUM_MODEM;
    if (gpEnumModem)
    {
      dwRet = gpEnumModem->GetError();
    }
    else
    {
      dwRet = ERROR_NOT_ENOUGH_MEMORY;
    }
  }
  if (ERROR_SUCCESS != dwRet)
  {
    return dwRet;
  }

  // clear out the combo box
  ComboBox_ResetContent(hCB);

  while ( pNext = gpEnumModem->Next())
  {
    // Add the device to the combo box
    nIndex = ComboBox_AddString(hCB, pNext);
    ComboBox_SetItemData(hCB, nIndex, NULL);
  }

  // Select the default device
  ComboBox_SetCurSel(hCB, nIndex);

  return ERROR_SUCCESS;
}

/*******************************************************************

  NAME:    InitConnectoidList

  SYNOPSIS:  Fills a list box window with list of RNA connectoids

  ENTRY:    hLB - list box window to fill
            lpszSelect - The connectoid name to select as default
  
********************************************************************/
VOID InitConnectoidList(HWND hLB, LPTSTR lpszSelect)
{
  DEBUGMSG("rnacall.c::InitConnectoidList()");

  ASSERT(hLB);

  LPTSTR pNext;

  // Load RNA if not already loaded
  if (EnsureRNALoaded() != ERROR_SUCCESS)
    return;

  ENUM_CONNECTOID EnumConnectoid;    // class object for enum

  // clear out the list box
  ListBox_ResetContent(hLB);

  int index;
  BOOL fSelected = FALSE;

  // enumerate connectoids
  while ( pNext = EnumConnectoid.Next()) {
    // Add the connectoid to the combo box
    index = ListBox_AddString(hLB, pNext);
        if (!fSelected && !lstrcmpi(pNext, lpszSelect))
        {
                fSelected = TRUE;
                ListBox_SetCurSel(hLB, index);
        }
  }
  if (!fSelected)
          ListBox_SetSel(hLB, TRUE, 0);
}


/*******************************************************************

  NAME:     GetConnectoidUsername

  SYNOPSIS: Get the username and password strings from the phonebook
            entry name specified.

  ENTRY:    pszConnectoidName - phonebook entry name
            pszUserName - string to hold user name
            cbUserName - size of pszUserName buffer
            pszPassword - string to hold password
            cbPassword - size of pszPassword buffer

  EXIT:     TRUE if username and password were copied successfully

********************************************************************/

BOOL GetConnectoidUsername(TCHAR * pszConnectoidName,TCHAR * pszUserName,
  DWORD cbUserName,TCHAR * pszPassword,DWORD cbPassword)
{
  DEBUGMSG("rnacall.c::GetConnectoidUsername()");

  ASSERT(pszConnectoidName);
  ASSERT(pszUserName);
  ASSERT(pszPassword);

  BOOL fRet = FALSE;

  // Load RNA if not already loaded
  DWORD dwRet = EnsureRNALoaded();
  if (dwRet != ERROR_SUCCESS) {
    return FALSE;
  }

  RASDIALPARAMS RasDialParams;
  ZeroMemory(&RasDialParams,sizeof(RASDIALPARAMS));
  RasDialParams.dwSize = sizeof(RASDIALPARAMS);

  lstrcpyn(RasDialParams.szEntryName,pszConnectoidName,
    ARRAYSIZE(RasDialParams.szEntryName));

  // call RNA to get user name and password
  ASSERT(lpRasGetEntryDialParams);
  BOOL fPasswordSaved;
  dwRet = lpRasGetEntryDialParams(NULL,&RasDialParams,&fPasswordSaved);

  if (dwRet == ERROR_SUCCESS) {
    // copy user name and password to caller's buffers
    lstrcpyn(pszUserName,RasDialParams.szUserName,cbUserName);
    lstrcpyn(pszPassword,RasDialParams.szPassword,cbPassword);
    fRet = TRUE;
  }

  return fRet;
}


/*******************************************************************

  NAME:     SetConnectoidUsername

  SYNOPSIS: Set the username and password strings for the phonebook
            entry name specified.

  ENTRY:    pszConnectoidName - phonebook entry name
            pszUserName - string with user name
            pszPassword - string with password

  EXIT:     Return value of GetEntryDialParams or SetEntryDialParams

********************************************************************/

DWORD SetConnectoidUsername(LPCTSTR pszPhonebook, LPCTSTR pszConnectoidName,
  LPCTSTR pszUserName, LPCTSTR pszPassword)
{
  BOOL bSkipSetting;
  bSkipSetting = TRUE;

  DEBUGMSG("rnacall.c::SetConnectoidUsername()");

  ASSERT(pszConnectoidName);

  // allocate a struct to use to set dialing params
  LPRASDIALPARAMS pRASDialParams = new RASDIALPARAMS;
  if (!pRASDialParams)
    return ERROR_ALLOCATING_MEMORY;

  ZeroMemory(pRASDialParams,sizeof(RASDIALPARAMS));  // zero out structure
  pRASDialParams->dwSize = sizeof(RASDIALPARAMS);
  lstrcpyn(pRASDialParams->szEntryName,pszConnectoidName,
    ARRAYSIZE(pRASDialParams->szEntryName));

  // get the dialing params for this connectoid so we don't have
  // to reconstruct the fields in struct we aren't changing
  ASSERT(lpRasGetEntryDialParams);
  BOOL fPasswordSaved;
  DWORD dwRet = lpRasGetEntryDialParams(pszPhonebook,
    pRASDialParams,&fPasswordSaved);
  if (dwRet == ERROR_SUCCESS)
  {
    // set the user name and password fields in struct
    // user name and password are optional parameters to this function,
    // make sure pointer is valid
    if (0 != lstrcmp(pRASDialParams->szUserName,pszUserName))
                bSkipSetting = FALSE;
    if (0 != lstrcmp(pRASDialParams->szPassword,pszPassword))
                bSkipSetting = FALSE;

    if (pszUserName)
      lstrcpyn(pRASDialParams->szUserName,pszUserName,
        ARRAYSIZE(pRASDialParams->szUserName));
    if (pszPassword)
      lstrcpyn(pRASDialParams->szPassword,pszPassword,
        ARRAYSIZE(pRASDialParams->szPassword));

    // if no password is specified, then set fRemovePassword to TRUE
    // to remove any old password in the connectoid
    BOOL fRemovePassword = (pRASDialParams->szPassword[0] ?
      FALSE : TRUE);

        bSkipSetting = !fRemovePassword && bSkipSetting;

    // set these parameters for connectoid
    ASSERT(lpRasSetEntryDialParams);
        if (!bSkipSetting)
        {
                dwRet = lpRasSetEntryDialParams(pszPhonebook,pRASDialParams,
                  fRemovePassword);
                if (dwRet != ERROR_SUCCESS)
                {
                  DEBUGMSG("RasSetEntryDialParams returned %lu",dwRet);
                }
        }

// ChrisK 9-20-96   Normandy 6096
// For NT4.0 we also have to call RasSetCredentials

        // Check to see if we are running on NT.
        OSVERSIONINFO osver;
        FARPROC fp;
        fp = NULL;
        ZeroMemory(&osver,sizeof(osver));
        osver.dwOSVersionInfoSize = sizeof(osver);
        if (GetVersionEx(&osver))
        {
                if (VER_PLATFORM_WIN32_NT == osver.dwPlatformId)
                {
                        // fill in credential structure
                        RASCREDENTIALS rascred;
                        ZeroMemory(&rascred,sizeof(rascred));
                        rascred.dwSize = sizeof(rascred);
                        rascred.dwMask = RASCM_UserName | RASCM_Password | RASCM_Domain;
                        lstrcpyn(rascred.szUserName,pszUserName,UNLEN);
                        lstrcpyn(rascred.szPassword,pszPassword,PWLEN);
                        lstrcpyn(rascred.szDomain,TEXT(""),DNLEN);
                        ASSERT(ghInstRNADll);

                        // load API
                        fp = GetProcAddress(ghInstRNADll,szRasSetCredentials);

                        if (fp)
                        {
                                dwRet = ((RASSETCREDENTIALS)fp)(NULL,(LPTSTR)pszConnectoidName,&rascred,FALSE);
                                DEBUGMSG("RasSetCredentials returned, %lu",dwRet);
                        }
                        else
                        {
                                DEBUGMSG("RasSetCredentials api not found.");
                        }
                }
        }


  }
  else
  {
    DEBUGMSG("RasGetEntryDialParams returned %lu",dwRet);
  }

  delete pRASDialParams;

  return dwRet;
}


/*******************************************************************

  NAME:     ValidateConnectoidName

  SYNOPSIS: Validates the phonebook entry name specified.

  ENTRY:    pszConnectoidName - phonebook entry name

  EXIT:     Result of RasValidateEntryName

********************************************************************/

DWORD ValidateConnectoidName(LPCTSTR pszPhonebook, LPCTSTR pszConnectoidName)
{
  DEBUGMSG("rnacall.c::ValidateConnectoidName()");

  ASSERT(pszConnectoidName);

  // Load RNA if not already loaded
  DWORD dwRet = EnsureRNALoaded();
  if (dwRet != ERROR_SUCCESS) {
    return dwRet;
  }

  ASSERT(lpRasValidateEntryName);

  // Although we require a const char *, RasValidateEntryName will
  // accept it, so we have to cast.
  dwRet = lpRasValidateEntryName(pszPhonebook, (LPTSTR)pszConnectoidName);

  // If there are no previous entries, RasValidateEntryName may return
  // ERROR_CANNOT_OPEN_PHONEBOOK.  This is okay.
  if (ERROR_CANNOT_OPEN_PHONEBOOK == dwRet)
          dwRet = ERROR_SUCCESS;

  return dwRet;
}


/*******************************************************************

  NAME:     GetEntry

  SYNOPSIS: Gets the phonebook entry specified.  To get default
            entry, use "" as entry name. 

  ENTRY:    lpEntry - pointer to RASENTRY struct to fill
            szEntryName - phonebook entry name

  EXIT:     Result of RasGetEntryProperties

********************************************************************/

DWORD GetEntry(LPRASENTRY *lplpEntry, LPDWORD lpdwEntrySize, LPCTSTR szEntryName)
{
  DEBUGMSG("rnacall.c::GetEntry()");

  ASSERT(fRNALoaded);  // RNA should be loaded if we get here
  ASSERT(lplpEntry);
  ASSERT(szEntryName);

  // Allocate space if needed
  if (NULL == *lplpEntry)
  {
          *lpdwEntrySize = sizeof(RASENTRY);
          *lplpEntry = (LPRASENTRY) GlobalAlloc(GPTR,*lpdwEntrySize);
          if (NULL == *lplpEntry)
          {
                  *lpdwEntrySize = 0;
                  return ERROR_ALLOCATING_MEMORY;
          }
  }

  // get connectoid information from RNA
  DWORD dwSize = *lpdwEntrySize;
  (*lplpEntry)->dwSize = sizeof(RASENTRY);

  ASSERT(lpRasGetEntryProperties);
  DWORD dwRet = (lpRasGetEntryProperties) (NULL, szEntryName,
    (LPBYTE)*lplpEntry, &dwSize, NULL, NULL);

  // Allocate more space if needed
  if (ERROR_BUFFER_TOO_SMALL == dwRet)
  {
          LPRASENTRY lpNewEntry;

          lpNewEntry = (LPRASENTRY) GlobalReAlloc(*lplpEntry,dwSize,GMEM_MOVEABLE);
          if (NULL == lpNewEntry)
          {
                  return ERROR_ALLOCATING_MEMORY;
          }
          
          *lplpEntry = lpNewEntry;
          *lpdwEntrySize = dwSize;
          dwRet = (lpRasGetEntryProperties) (NULL, szEntryName,
                                                                                 (LPBYTE)*lplpEntry, &dwSize, NULL, NULL);
  }

  return dwRet;
}

VOID FAR PASCAL LineCallback(DWORD hDevice, DWORD dwMsg, 
    DWORD dwCallbackInstance, DWORD dwParam1, DWORD dwParam2, 
    DWORD dwParam3)
{
        return;
}
 
//+----------------------------------------------------------------------------
//
//      Function        GetTapiCountryID
//
//      Synopsis        Get the currenty country ID for the tapi settings
//
//      Arguments       none
//
//      Returns         pdwCountryID - contains address of country ID
//                              ERROR_SUCCESS - no errors
//
//      History         1/8/97  ChrisK Copied from icwconn1/dialerr.cpp
//
//-----------------------------------------------------------------------------
// Normandy 13097 - ChrisK 1/8/97
// NT returns the country ID not the country code
HRESULT GetTapiCountryID(LPDWORD pdwCountryID)
{
        HRESULT hr = ERROR_SUCCESS;
        HLINEAPP hLineApp = NULL;
        DWORD dwCurDev;
        DWORD cDevices;
        DWORD dwAPI;
        LONG lrc;
        LPLINETRANSLATECAPS pTC = NULL;
        LPVOID pv = NULL;
        LPLINELOCATIONENTRY plle = NULL;
        LINEEXTENSIONID leid;
        DWORD dwCurLoc;

        // Get CountryID from TAPI
        //

        *pdwCountryID = 0;

        // Get the handle to the line app
        //

        lineInitialize(&hLineApp,ghInstance,LineCallback," ",&cDevices);
        if (!hLineApp)
        {
                hr = GetLastError();
                goto GetTapiCountryIDExit;
        }

        if (cDevices)
        {

                // Get the TAPI API version
                //

                dwCurDev = 0;
                dwAPI = 0;
                lrc = -1;
                while (lrc && dwCurDev < cDevices)
                {
                        // NOTE: device ID's are 0 based
                        lrc = lineNegotiateAPIVersion(hLineApp,dwCurDev,0x00010004,0x00010004,&dwAPI,&leid);
                        dwCurDev++;
                }
                if (lrc)
                {
                        // TAPI and us can't agree on anything so nevermind...
                        hr = ERROR_GEN_FAILURE;
                        goto GetTapiCountryIDExit;
                }

                // Find the CountryID in the translate cap structure
                //

                pTC = (LINETRANSLATECAPS FAR *)GlobalAlloc(GPTR,sizeof(LINETRANSLATECAPS));
                if (!pTC)
                {
                        // we are in real trouble here, get out!
                        hr = ERROR_NOT_ENOUGH_MEMORY;
                        goto GetTapiCountryIDExit;
                }

                // Get the needed size
                //

                pTC->dwTotalSize = sizeof(LINETRANSLATECAPS);
                lrc = lineGetTranslateCaps(hLineApp,dwAPI,pTC);
                if(lrc)
                {
                        hr = lrc;
                        goto GetTapiCountryIDExit;
                }

                pv = (LPVOID) GlobalAlloc(GPTR,((size_t)pTC->dwNeededSize));
                if (!pv)
                {
                        hr = ERROR_NOT_ENOUGH_MEMORY;
                        goto GetTapiCountryIDExit;
                }
                ((LINETRANSLATECAPS FAR *)pv)->dwTotalSize = pTC->dwNeededSize;
                GlobalFree(pTC);
                pTC = (LINETRANSLATECAPS FAR *)pv;
                pv = NULL;
                lrc = lineGetTranslateCaps(hLineApp,dwAPI,pTC);
                if(lrc)
                {
                        hr = lrc;
                        goto GetTapiCountryIDExit;
                }
        
                plle = LPLINELOCATIONENTRY (LPTSTR(pTC) + pTC->dwLocationListOffset);
                for (dwCurLoc = 0; dwCurLoc < pTC->dwNumLocations; dwCurLoc++)
                {
                        *pdwCountryID = plle->dwPermanentLocationID;
                        if (pTC->dwCurrentLocationID == plle->dwPermanentLocationID)
                        {
                                        *pdwCountryID = plle->dwCountryID;
                                        break; // for loop
                        }
                        plle++;
                }
        }
GetTapiCountryIDExit:
        // 3/4/97       jmazner Olympus #1336
        if( hLineApp )
        {
                // we never call lineOpen, so no need to lineClose
                lineShutdown( hLineApp );
                hLineApp = NULL;
        }
        return hr;
}


/*******************************************************************

  NAME:     InitRasEntry

  SYNOPSIS: Initializes some parts of the RASENTRY struct.

  ENTRY:    lpEntry - pointer to RASENTRY struct to init

  NOTES:    Since this may be called before RNA is loaded, must not
            make any RNA calls.

  96/06/04  markdu  OSR  BUG 7246 Add RASEO_SwCompression and
            RASEO_ModemLights to default RASENTRY.

********************************************************************/

void InitRasEntry(LPRASENTRY lpEntry)
{
  DEBUGMSG("rnacall.c::InitRasEntry()");

  DWORD dwSize = sizeof(RASENTRY);
  ZeroMemory(lpEntry, dwSize);
  lpEntry->dwSize = dwSize;

  // default to use country code and area code
  lpEntry->dwfOptions |= RASEO_UseCountryAndAreaCodes;

  // default to use IP header compression
  lpEntry->dwfOptions |= RASEO_IpHeaderCompression;

  // default to use remote default gateway
  lpEntry->dwfOptions |= RASEO_RemoteDefaultGateway;

  // configure connectoid to not log on to network
  lpEntry->dwfOptions &= ~RASEO_NetworkLogon;    

  // default to use software compression
  lpEntry->dwfOptions |= RASEO_SwCompression;

  // default to use modem lights
  lpEntry->dwfOptions |= RASEO_ModemLights;

  // set connectoid for PPP
  lpEntry->dwFramingProtocol = RASFP_Ppp;

  // only use TCP/IP protocol
  lpEntry->dwfNetProtocols = RASNP_Ip;

  // default to use TAPI area code and country code
  TCHAR szCountryCode[8];       // 8 is from tapiGetLocationInfo documentation

  if (ERROR_SUCCESS == tapiGetLocationInfo(szCountryCode, lpEntry->szAreaCode))
  {
        // Normandy 13097 - ChrisK 1/8/97
        // NT returns the country ID not the country code
        if (szCountryCode[0])
        {
                if (IsNT())
                {
                        lpEntry->dwCountryID = myatoi(szCountryCode);
                        lpEntry->dwCountryCode = US_COUNTRY_CODE;

                        // Initialize data
                        LINECOUNTRYLIST FAR * lpLineCountryList;
                        DWORD dwSize;
                        dwSize = 0;
                        lpLineCountryList = (LINECOUNTRYLIST FAR *)
                                GlobalAlloc(GPTR,sizeof(LINECOUNTRYLIST));
                        if (NULL == lpLineCountryList)
                                return;
                        lpLineCountryList->dwTotalSize = sizeof(LINECOUNTRYENTRY);

                        // Get size of data structre
                        if(ERROR_SUCCESS != lineGetCountry(lpEntry->dwCountryID,0x10004,lpLineCountryList))
                        {
                                GlobalFree(lpLineCountryList);
                                return;
                        }
                        dwSize = lpLineCountryList->dwNeededSize;
                        GlobalFree(lpLineCountryList);
                        lpLineCountryList = (LINECOUNTRYLIST FAR *)GlobalAlloc(GPTR,dwSize);
                        if (NULL == lpLineCountryList)
                                return;
                        lpLineCountryList->dwTotalSize = dwSize;

                        // Get Country information for given ID
                        if(ERROR_SUCCESS != lineGetCountry(lpEntry->dwCountryID,0x10004,lpLineCountryList))
                        {
                                GlobalFree(lpLineCountryList);
                                return;
                        }
                
                        lpEntry->dwCountryCode = ((LINECOUNTRYENTRY FAR *)((DWORD_PTR)lpLineCountryList +
                                (DWORD)(lpLineCountryList->dwCountryListOffset)))->dwCountryCode;

                        GlobalFree(lpLineCountryList);
                        lpLineCountryList = NULL;

                }
                else
                {
                        lpEntry->dwCountryCode = myatoi(szCountryCode);
                        if (ERROR_SUCCESS != GetTapiCountryID(&lpEntry->dwCountryID))
                                lpEntry->dwCountryID = US_COUNTRY_ID;
                }
        }
  }
  else
  {
          lpEntry->dwCountryCode = US_COUNTRY_CODE;
  }
}


/*******************************************************************

  NAME:    InitCountryCodeList_w

  SYNOPSIS:  Worker function that fills a specified combo box with
        country code selections

  ENTRY:    hLB - HWND of combo box to fill
        dwSelectCountryID - if non-zero, the ID of country code
          to select as default
        fAll - if TRUE, all country codes are enumerated into
          combo box (potentially slow).  If FALSE, only
          the country code in dwSelectCountryID is enumerated.

  NOTES:    Cloned from RNA UI code

********************************************************************/
void InitCountryCodeList_w (HWND hLB, DWORD dwSelectCountryID,BOOL fAll)
{
  DEBUGMSG("rnacall.c::InitCountryCodeList_w()");

  LPRASCTRYINFO lpRasCtryInfo;
  LPCOUNTRYCODE pNext;
  DWORD cbSize;
  DWORD cbList;
  DWORD dwNextCountryID, dwRet;
  LPTSTR szCountryDesc;
  int   nIndex, iSelect;

  ASSERT(fRNALoaded);  // RNA should be loaded if we get here

  BUFFER Fmt(MAX_RES_LEN + SMALL_BUF_LEN);
  BUFFER CountryInfo(DEF_COUNTRY_INFO_SIZE);
  ASSERT(Fmt);
  ASSERT(CountryInfo);
  if (!Fmt || !CountryInfo) 
    return;

  // Load the display format
  LoadSz(IDS_COUNTRY_FMT,Fmt.QueryPtr(),SMALL_BUF_LEN);
  szCountryDesc = Fmt.QueryPtr()+SMALL_BUF_LEN;

  cbList = (DWORD)(fAll ? sizeof(COUNTRYCODE)*MAX_COUNTRY : sizeof(COUNTRYCODE));

  gpCountryCodeBuf = new TCHAR[cbList];
  ASSERT(gpCountryCodeBuf);
  if (!gpCountryCodeBuf)
    return;
  
  // Start enumerating the info from the first country
  dwNextCountryID   = (fAll || (dwSelectCountryID==0)) ?
                    1 : dwSelectCountryID;
  pNext = (LPCOUNTRYCODE) gpCountryCodeBuf;
  iSelect = 0;
  lpRasCtryInfo = (LPRASCTRYINFO) CountryInfo.QueryPtr();
  lpRasCtryInfo->dwSize = sizeof(RASCTRYINFO);
  ComboBox_ResetContent(hLB);

  // For each country
  while (dwNextCountryID != 0)
  {
    lpRasCtryInfo->dwCountryID  = dwNextCountryID;
    cbSize = CountryInfo.QuerySize();

    // Get the current country information
    ASSERT(lpRasGetCountryInfo);
    dwRet = lpRasGetCountryInfo(lpRasCtryInfo, &cbSize);
    if (ERROR_SUCCESS == dwRet)
    {
      TCHAR  szCountryDisp[MAX_COUNTRY_NAME+1];

      // Make a displayable name
      ShortenName((LPTSTR)(((LPBYTE)lpRasCtryInfo)+lpRasCtryInfo->dwCountryNameOffset),
        szCountryDisp, MAX_COUNTRY_NAME+1);

      // Add the country to the list
      wsprintf(szCountryDesc,Fmt.QueryPtr(), szCountryDisp, lpRasCtryInfo->dwCountryCode);
      nIndex = ComboBox_AddString(hLB, szCountryDesc);
      ASSERT(nIndex >= 0);

      // Copy the country information to our short list
      pNext->dwCountryID   = lpRasCtryInfo->dwCountryID;
      pNext->dwCountryCode = lpRasCtryInfo->dwCountryCode;
      dwNextCountryID      = lpRasCtryInfo->dwNextCountryID;
      ComboBox_SetItemData(hLB, nIndex, pNext);

      // If it is the specified country, make it a default one
      if (pNext->dwCountryID == dwSelectCountryID)
        ComboBox_SetCurSel(hLB, nIndex);

      // if need only one item, bail out
      //
      if (!fAll)
        break;

      // Advance to the next country
      pNext++;
    }
    else
    {
      // If the buffer is too small, reallocate a new one and retry
      if (dwRet == ERROR_BUFFER_TOO_SMALL)
      {
        BOOL fRet=CountryInfo.Resize(cbSize);
        ASSERT(fRet);
        if (!fRet || !CountryInfo)
          return;

        lpRasCtryInfo = (LPRASCTRYINFO) CountryInfo.QueryPtr();
      }
      else
      {
        break;
      }
    }
  }

  // Select the default device
  if ((dwRet == SUCCESS) && (ComboBox_GetCurSel(hLB) == CB_ERR))
    ComboBox_SetCurSel(hLB, 0);

  return;
}

/*******************************************************************

  NAME:    InitCountryCodeList

  SYNOPSIS:  Puts the (single) default country code in specified combo box

  ENTRY:    hLB - HWND of combo box to fill

  NOTES:    -Cloned from RNA UI code
        -Calls InitCountryCodeList_w to do work
        -Caller must call DeInitCountryCodeList when done to free buffer
        -Caller should call FillCountryCodeList when the combo box
          is touched to fill in the whole list of country codes

********************************************************************/
void InitCountryCodeList(HWND hLB)
{
  DEBUGMSG("rnacall.c::InitCountryCodeList()");

  DWORD dwCountryCodeID;

  // Load RNA if not already loaded
  if (EnsureRNALoaded() != ERROR_SUCCESS)
    return;

  // if there is a global rasentry, set default country code to
  // be the same as it... otherwise set default country code to US
  if (sizeof(RASENTRY) == gpRasEntry->dwSize)
  {
    dwCountryCodeID = gpRasEntry->dwCountryID;
  }
  else
  {
    dwCountryCodeID = US_COUNTRY_CODE;
  }

  InitCountryCodeList_w(hLB,dwCountryCodeID,FALSE);
}

/*******************************************************************

  NAME:    FillCountryCodeList

  SYNOPSIS:  Fills the country code listbox with list of all
        country codes

  ENTRY:    hLB - HWND of combo box to fill

  NOTES:    -Cloned from RNA UI code
        -May take a while!  (several seconds)  This shouldn't
          be called unless user plays with combo box
        -Assumes InitCountryCodeList has been called            
        -Caller must call DeInitCountryCodeList when done to free buffer

********************************************************************/
void FillCountryCodeList(HWND hLB)
{
  DEBUGMSG("rnacall.c::FillCountryCodeList()");

  LPCOUNTRYCODE lpcc;
  DWORD dwSelectID;

  ASSERT(fRNALoaded);  // RNA should be loaded if we get here

  // If we already complete the list, do nothing
  if (ComboBox_GetCount(hLB) > 1)
    return;

  // Get the currently selected country code
  if ((lpcc = (LPCOUNTRYCODE)ComboBox_GetItemData(hLB, 0)) != NULL)
  {
    dwSelectID = lpcc->dwCountryID;
  }
  else
  {
    dwSelectID = US_COUNTRY_CODE;
  }

  // free the country code buffer
  DeInitCountryCodeList();

  // set an hourglass cursor
  WAITCURSOR WaitCursor;

  // Enumerate full list of country codes
  InitCountryCodeList_w(hLB, dwSelectID, TRUE);
}

/*******************************************************************

  NAME:     GetCountryCodeSelection

  SYNOPSIS: Gets selected country code and ID based on combo box
        selection and fills them in in phone number struct

  ENTRY:    hLB - handle of combo box
            lpCountryCode - fill in with country code info

********************************************************************/
void GetCountryCodeSelection(HWND hLB,LPCOUNTRYCODE* plpCountryCode)
{
  DEBUGMSG("rnacall.c::GetCountryCodeSelection()");

  ASSERT(hLB);
  ASSERT(plpCountryCode);

  // get index of selected item in combo box
  int iSel = ComboBox_GetCurSel(hLB);

  ASSERT(iSel >= 0);  // should always be a selection
  if (iSel >= 0)
  {
    // get data for item, which is pointer to country code struct
    *plpCountryCode = (LPCOUNTRYCODE) ComboBox_GetItemData(hLB,iSel);
  }
}

/*******************************************************************

  NAME:    SetCountryIDSelection

  SYNOPSIS:  Sets selected country code in combo box

  EXIT:    returns TRUE if successful, FALSE if country code not
        in combo box

********************************************************************/
BOOL SetCountryIDSelection(HWND hwndCB,DWORD dwCountryID)
{
  DEBUGMSG("rnacall.c::SetCountryIDSelection()");

  BOOL fRet = FALSE;

  ASSERT(hwndCB);

  int iCount,iIndex;
  COUNTRYCODE * pcc;

  // search through items in combo box until we find one that
  // matches the specified country ID
  iCount = ComboBox_GetCount(hwndCB);
  for (iIndex = 0;iIndex < iCount;iIndex ++) {
    pcc = (COUNTRYCODE *) ComboBox_GetItemData(hwndCB,iIndex);
    if (pcc && pcc->dwCountryID == dwCountryID) {
      ComboBox_SetCurSel(hwndCB,iIndex);
      return TRUE;
    }
  }

  return FALSE;  // couldn't find country code in combo box
}

/*******************************************************************

  NAME:    DeInitCountryCodeList

  SYNOPSIS:  Frees buffer of country codes

  NOTES:    Call when done with combo box that displays country codes

********************************************************************/
void DeInitCountryCodeList(VOID)
{
  DEBUGMSG("rnacall.c::DeInitCountryCodeList()");

  // free the country code buffer
  ASSERT(gpCountryCodeBuf);
  if (gpCountryCodeBuf)
  {
    delete gpCountryCodeBuf;
    gpCountryCodeBuf = NULL;
  }
}

/*******************************************************************

  NAME:    ShortenName

  SYNOPSIS:  Copies a name to a (potentially shorter) buffer;
        if the name is too large it truncates it and adds "..."

  NOTES:    Cloned from RNA UI code

********************************************************************/
void ShortenName(LPTSTR szLongName, LPTSTR szShortName, DWORD cbShort)
{
//  DEBUGMSG("rnacall.c::ShortenName()");

  static BOOL    gfShortFmt  = FALSE;
  static TCHAR   g_szShortFmt[SMALL_BUF_LEN];
  static DWORD   gdwShortFmt = 0;

  ASSERT(szLongName);
  ASSERT(szShortName);

  // Get the shorten format
  if (!gfShortFmt)
  {
    gdwShortFmt  = LoadString(ghInstance, IDS_SHORT_FMT, g_szShortFmt,
      SMALL_BUF_LEN);
    gdwShortFmt -= 2;  // lstrlen("%s")
    gfShortFmt   = TRUE;
  };

  // Check the size of the long name
  if ((DWORD)lstrlen(szLongName)+1 <= cbShort)
  {
    // The name is shorter than the specified size, copy back the name
    lstrcpy(szShortName, szLongName);
  } else {
    BUFFER bufShorten(cbShort*2);
    ASSERT(bufShorten);

    if (bufShorten) {
      lstrcpyn(bufShorten.QueryPtr(), szLongName, cbShort-gdwShortFmt);
      wsprintf(szShortName, g_szShortFmt,bufShorten.QueryPtr());
    } else {
         lstrcpyn(szShortName, szLongName, cbShort);
    }
  }
}


/*******************************************************************

  NAME:    EnsureRNALoaded

  SYNOPSIS:  Loads RNA if not already loaded

********************************************************************/
DWORD EnsureRNALoaded(VOID)
{
  DEBUGMSG("rnacall.c::EnsureRNALoaded()");

  DWORD dwRet = ERROR_SUCCESS;

  // load RNA if necessary
  if (!fRNALoaded) {
    if (InitRNA(NULL))
      fRNALoaded = TRUE;
    else return ERROR_FILE_NOT_FOUND;
  }

  return dwRet;
}


/*******************************************************************

  NAME:    ENUM_MODEM::ENUM_MODEM

  SYNOPSIS:  Constructor for class to enumerate modems

  NOTES:    Useful to have a class rather than C functions for
        this, due to how the enumerators function

********************************************************************/
ENUM_MODEM::ENUM_MODEM() :
  m_dwError(ERROR_SUCCESS),m_lpData(NULL),m_dwIndex(0)
{
  DWORD cbSize = 0;

  // Use the reinit member function to do the work.
  this->ReInit();
}


/*******************************************************************

  NAME:     ENUM_MODEM::ReInit

  SYNOPSIS: Re-enumerate the modems, freeing the old memory.

********************************************************************/
DWORD ENUM_MODEM::ReInit()
{
  DWORD cbSize = 0;

  // Clean up the old list
  if (m_lpData)
  {
    delete m_lpData;
    m_lpData = NULL;             
  }
  m_dwNumEntries = 0;
  m_dwIndex = 0;

  // call RasEnumDevices with no buffer to find out required buffer size
  ASSERT(lpRasEnumDevices);
  m_dwError = lpRasEnumDevices(NULL, &cbSize, &m_dwNumEntries);

  // Special case check to work around RNA bug where ERROR_BUFFER_TOO_SMALL
  // is returned even if there are no devices.
  // If there are no devices, we are finished.
  if (0 == m_dwNumEntries)
  {
    m_dwError = ERROR_SUCCESS;
    return m_dwError;
  }

  // Since we were just checking how much mem we needed, we expect
  // a return value of ERROR_BUFFER_TOO_SMALL, or it may just return
  // ERROR_SUCCESS (ChrisK  7/9/96).
  if (ERROR_BUFFER_TOO_SMALL != m_dwError && ERROR_SUCCESS != m_dwError)
  {
    return m_dwError;
  }

  // Allocate the space for the data
  m_lpData = (LPRASDEVINFO) new TCHAR[cbSize];
  if (NULL == m_lpData)
  {
    DEBUGTRAP("ENUM_MODEM: Failed to allocate device list buffer");
    m_dwError = ERROR_NOT_ENOUGH_MEMORY;
    return m_dwError;
  }
  m_lpData->dwSize = sizeof(RASDEVINFO);
  m_dwNumEntries = 0;

  // enumerate the modems into buffer
  m_dwError = lpRasEnumDevices(m_lpData, &cbSize,
    &m_dwNumEntries);

  if (ERROR_SUCCESS != m_dwError)
          return m_dwError;

    //
    // ChrisK Olympus 4560 do not include VPN's in the list
    //
    DWORD dwTempNumEntries;
    DWORD idx;
    LPRASDEVINFO lpNextValidDevice;

    dwTempNumEntries = m_dwNumEntries;
    lpNextValidDevice = m_lpData;

        //
        // Walk through the list of devices and copy non-VPN device to the first
        // available element of the array.
        //
        for (idx = 0;idx < dwTempNumEntries; idx++)
        {
        // We only want to show Modem and ISDN (or ADSL in future) device type
        // in this dialog.
        // 
        // char b[400];
        // wsprintf(b, "Type:%s, Name:%s", m_lpData[idx].szDeviceType, m_lpData[idx].szDeviceName);
        // MessageBox(0, b, "Devices", MB_OK);
        //
                if ((0 == lstrcmpi(TEXT("MODEM"),m_lpData[idx].szDeviceType)) ||
            (0 == lstrcmpi(TEXT("ISDN"),m_lpData[idx].szDeviceType)))
                {
                        if (lpNextValidDevice != &m_lpData[idx])
                        {
                                MoveMemory(lpNextValidDevice ,&m_lpData[idx],sizeof(RASDEVINFO));
                        }
                        lpNextValidDevice++;
                }
                else
                {
                        m_dwNumEntries--;
                }
        }
  
  return m_dwError;
}


/*******************************************************************

  NAME:    ENUM_MODEM::~ENUM_MODEM

  SYNOPSIS:  Destructor for class

********************************************************************/
ENUM_MODEM::~ENUM_MODEM()
{
  if (m_lpData)
  {
    delete m_lpData;
    m_lpData = NULL;             
  }
}

/*******************************************************************

  NAME:     ENUM_MODEM::Next

  SYNOPSIS: Enumerates next modem 

  EXIT:     Returns a pointer to device info structure.  Returns
            NULL if no more modems or error occurred.  Call GetError
            to determine if error occurred.

********************************************************************/
TCHAR * ENUM_MODEM::Next()
{
  if (m_dwIndex < m_dwNumEntries)
  {
    return m_lpData[m_dwIndex++].szDeviceName;
  }

  return NULL;
}


/*******************************************************************

  NAME:     ENUM_MODEM::GetDeviceTypeFromName

  SYNOPSIS: Returns type string for specified device.

  EXIT:     Returns a pointer to device type string for first
            device name that matches.  Returns
            NULL if no device with specified name is found

********************************************************************/

TCHAR * ENUM_MODEM::GetDeviceTypeFromName(LPTSTR szDeviceName)
{
  DWORD dwIndex = 0;

  while (dwIndex < m_dwNumEntries)
  {
    if (!lstrcmp(m_lpData[dwIndex].szDeviceName, szDeviceName))
    {
      return m_lpData[dwIndex].szDeviceType;
    }
    dwIndex++;
  }

  return NULL;
}


/*******************************************************************

  NAME:     ENUM_MODEM::GetDeviceNameFromType

  SYNOPSIS: Returns type string for specified device.

  EXIT:     Returns a pointer to device name string for first
            device type that matches.  Returns
            NULL if no device with specified Type is found

********************************************************************/

TCHAR * ENUM_MODEM::GetDeviceNameFromType(LPTSTR szDeviceType)
{
  DWORD dwIndex = 0;

  while (dwIndex < m_dwNumEntries)
  {
    if (!lstrcmp(m_lpData[dwIndex].szDeviceType, szDeviceType))
    {
      return m_lpData[dwIndex].szDeviceName;
    }
    dwIndex++;
  }

  return NULL;
}


/*******************************************************************

  NAME:     ENUM_MODEM::VerifyDeviceNameAndType

  SYNOPSIS: Determines whether there is a device with the name
            and type given.

  EXIT:     Returns TRUE if the specified device was found, 
            FALSE otherwise.

********************************************************************/

BOOL ENUM_MODEM::VerifyDeviceNameAndType(LPTSTR szDeviceName, LPTSTR szDeviceType)
{
  DWORD dwIndex = 0;

  while (dwIndex < m_dwNumEntries)
  {
    if (!lstrcmp(m_lpData[dwIndex].szDeviceType, szDeviceType) &&
      !lstrcmp(m_lpData[dwIndex].szDeviceName, szDeviceName))
    {
      return TRUE;
    }
    dwIndex++;
  }

  return FALSE;
}


/*******************************************************************

  NAME:    ENUM_CONNECTOID::ENUM_CONNECTOID

  SYNOPSIS:  Constructor for class to enumerate connectoids

  NOTES:    Useful to have a class rather than C functions for
        this, due to how the enumerators function

********************************************************************/
ENUM_CONNECTOID::ENUM_CONNECTOID() :
  m_dwError(ERROR_SUCCESS),m_dwNumEntries(0),m_lpData(NULL),m_dwIndex(0)
{
  DWORD cbSize;
  RASENTRYNAME   rasEntryName;
  
  cbSize = sizeof(RASENTRYNAME);
  rasEntryName.dwSize = cbSize;

  // call RasEnumEntries with a temp structure.  this will not likely
  // be big enough, but cbSize will be filled with the required size
  ASSERT(lpRasEnumEntries);
  m_dwError = lpRasEnumEntries(NULL, NULL, &rasEntryName,
    &cbSize, &m_dwNumEntries);
  if ((ERROR_BUFFER_TOO_SMALL != m_dwError) &&
    (ERROR_SUCCESS != m_dwError))
  {
    return;
  }

  // Make sure that there is at least enough room for the structure
  // (RasEnumEntries will return 0 as cbSize if there are no entries)
  cbSize = (cbSize > sizeof(RASENTRYNAME)) ? cbSize : sizeof(RASENTRYNAME);

  // Allocate the space for the data
  m_lpData = (LPRASENTRYNAME) new TCHAR[cbSize];
  if (NULL == m_lpData)
  {
    DEBUGTRAP("ENUM_CONNECTOID: Failed to allocate connectoid list buffer");
    m_dwError = ERROR_NOT_ENOUGH_MEMORY;
    return;
  }
  m_lpData->dwSize = sizeof(RASENTRYNAME);

  m_dwNumEntries = 0;

  // enumerate the connectoids into buffer
  m_dwError = lpRasEnumEntries(NULL, NULL, m_lpData, &cbSize, &m_dwNumEntries);

  if (IsNT5())
  {
    DWORD dwNumEntries = 0;
  
    if (ERROR_SUCCESS == m_dwError && m_dwNumEntries) 
    {
      for(DWORD dwIndx=0; dwIndx < m_dwNumEntries; dwIndx++)
      {
          LPRASENTRY  lpRasEntry = NULL;
          DWORD       dwRasEntrySize = 0;
          if (GetEntry(&lpRasEntry, &dwRasEntrySize, m_lpData[dwIndx].szEntryName) == ERROR_SUCCESS)
          {
              // check connection type
              if ((0 != lstrcmpi(TEXT("MODEM"), lpRasEntry->szDeviceType)) &&
                 (0 != lstrcmpi(TEXT("ISDN"), lpRasEntry->szDeviceType)))
                    *(m_lpData[dwIndx].szEntryName) = 0;
              else
                  dwNumEntries++;
          }
          //
          // Release memory
          //
          if (NULL != lpRasEntry)
          {
              GlobalFree(lpRasEntry);
              lpRasEntry = NULL;
          }
      } // End for loop
      m_dwNumEntries = dwNumEntries;
    }
 
  }


}

/*******************************************************************

  NAME:    ENUM_CONNECTOID::~ENUM_CONNECTOID

  SYNOPSIS:  Destructor for class

********************************************************************/
ENUM_CONNECTOID::~ENUM_CONNECTOID()
{
  if (m_lpData)
  {
    delete m_lpData;
    m_lpData = NULL;             
  }
}

/*******************************************************************

  NAME:    ENUM_CONNECTOID::Next

  SYNOPSIS:  Enumerates next connectoid

  EXIT:    Returns a pointer to connectoid name.  Returns NULL
        if no more connectoids or error occurred.  Call GetError
        to determine if error occurred.

********************************************************************/
TCHAR * ENUM_CONNECTOID::Next()
{
  while (m_dwIndex < m_dwNumEntries)
  {
      if (0 == *(m_lpData[m_dwIndex].szEntryName))
      {
          m_dwIndex++;
      }
      else
      {
         return m_lpData[m_dwIndex++].szEntryName;
      }
  }

  return NULL;
}

/*******************************************************************

  NAME:    ENUM_CONNECTOID::NumEntries

  SYNOPSIS:  returns number of connectoids stored in this instance

  EXIT:    Returns value of m_dwNumEntries

  HISTORY:      11/11/96        jmazner         Created.

********************************************************************/
DWORD ENUM_CONNECTOID::NumEntries()
{
        return m_dwNumEntries;
}

//+----------------------------------------------------------------------------
//      Function:       FRasValidatePatch
//
//      Synopsis:       With all of the other Ras functions there exists a common entry
//                              point for WinNT and Win95, usually the A version.  However,
//                              RasValidateEntryName only has an A and W version on WinNT and
//                              an unqualified version on Win95.  Therefore we have to do some
//                              special processing to try to find it
//
//      Input:          ppFP - Location to save function point to
//                              hInst1 - First DLL to check for entry point
//                              hInst2 - Second DLL to check for entry point
//                              lpszName - Name of the function (if it isn't RasValidateEntryName)
//                                      we just skip it and move on.
//
//      Return:         TRUE - success
//
//      History:        7/3/96          Created, ChrisK
//
//-----------------------------------------------------------------------------
BOOL FRasValidatePatch(PVOID *ppFP, HINSTANCE hInst1, HINSTANCE hInst2, LPCSTR lpszName)
{
        BOOL bRC = TRUE;

        //
        // Validate parameters
        //
        if (ppFP && hInst1 && lpszName)
        {

                //
                // Check that we are really looking for RasValidateEntryName
                //
                if (0 == lstrcmpA(lpszName,szRasValidateEntryName))
                {
                        //
                        // Find entry point with alternate name
                        //
                        *ppFP = GetProcAddress(hInst1,szRasValidateEntryName);
                        if (!*ppFP && hInst2)
                                *ppFP = GetProcAddress(hInst2,szRasValidateEntryName);
                        if (!*ppFP)
                        {
                                DEBUGMSG("INETCFG: FRasValidatePatch entry point not found is either DLL.\n");
                                bRC = FALSE;
                        }
                }
                else
                {
                        bRC = FALSE;
                }
        }
        else
        {
                DEBUGMSG("INETCFG: FRasValidatePatch invalid parameters.\n");
                bRC = FALSE;
        }

//FRasValidatePatchExit:
        return bRC;
}

/*******************************************************************

  NAME:    GetApiProcAddresses

  SYNOPSIS:  Gets proc addresses for a table of functions

  EXIT:    returns TRUE if successful, FALSE if unable to retrieve
        any proc address in table

  HISTORY: 
  96/02/28  markdu  If the api is not found in the module passed in,
            try the backup (RNAPH.DLL)

********************************************************************/
BOOL GetApiProcAddresses(HMODULE hModDLL,APIFCN * pApiProcList,UINT nApiProcs)
{
  DEBUGMSG("rnacall.c::GetApiProcAddresses()");

  UINT nIndex;
  // cycle through the API table and get proc addresses for all the APIs we
  // need
  for (nIndex = 0;nIndex < nApiProcs;nIndex++)
  {
    if (!(*pApiProcList[nIndex].ppFcnPtr = (PVOID) GetProcAddress(hModDLL,
      pApiProcList[nIndex].pszName)))
    {
      // Try to find the address in RNAPH.DLL.  This is useful in the
      // case thatRASAPI32.DLL did not contain the function that we
      // were trying to load.
      if (FALSE == IsNT())
          {
                  if (!ghInstRNAPHDll)
                  {
                        TCHAR szRNAPHDll[SMALL_BUF_LEN];

                        LoadSz(IDS_RNAPHDLL_FILENAME,szRNAPHDll,ARRAYSIZE(szRNAPHDll));
                        ghInstRNAPHDll = LoadLibrary(szRNAPHDll);
                  }

                  if ((!ghInstRNAPHDll) ||  !(*pApiProcList[nIndex].ppFcnPtr =
                        (PVOID) GetProcAddress(ghInstRNAPHDll,pApiProcList[nIndex].pszName)))
                  {
                          if (!FRasValidatePatch(pApiProcList[nIndex].ppFcnPtr, hModDLL,
                                  ghInstRNAPHDll, pApiProcList[nIndex].pszName))
                          {
                                DEBUGMSG("Unable to get address of function %s",
                                        pApiProcList[nIndex].pszName);

                                for (nIndex = 0;nIndex<nApiProcs;nIndex++)
                                        *pApiProcList[nIndex].ppFcnPtr = NULL;

                                return FALSE;
                          }
                  }
                }
        }
  }

  return TRUE;
}


/*******************************************************************

  NAME:    GetRNAErrorText

  SYNOPSIS:  Gets text string corresponding to RNA error code

  ENTRY:    uErr - RNA error code
        pszErrText - buffer to retrieve error text description
        cbErrText - size of pszErrText buffer

********************************************************************/

VOID GetRNAErrorText(UINT uErr,TCHAR * pszErrText,DWORD cbErrText)
{
  DEBUGMSG("rnacall.c::GetRNAErrorText()");

  ASSERT(pszErrText);

  ASSERT(lpRasGetErrorString);
  DWORD dwRet = lpRasGetErrorString(uErr,pszErrText,cbErrText);

  if (dwRet != ERROR_SUCCESS) {
    // if we couldn't get real error text, then make generic string
    // with the error number
    TCHAR szFmt[SMALL_BUF_LEN+1];
    LoadSz(IDS_GENERIC_RNA_ERROR,szFmt,ARRAYSIZE(szFmt));
    wsprintf(pszErrText,szFmt,uErr);
  }
}


/* S W A P  D W  B Y T E S Taken from rnaph.c */
/*----------------------------------------------------------------------------
  %%Function: SwapDwBytes

  Swap the bytes of a DWORD.
  (BSWAP isn't available on a 386)

----------------------------------------------------------------------------*/
VOID SwapDwBytes(LPDWORD lpdw)
{
  IADDR iaddr;

  iaddr.ia.a = ((PIADDR) lpdw)->ia.d;
  iaddr.ia.b = ((PIADDR) lpdw)->ia.c;
  iaddr.ia.c = ((PIADDR) lpdw)->ia.b;
  iaddr.ia.d = ((PIADDR) lpdw)->ia.a;

  *lpdw = iaddr.dw;
}

/* C O P Y  D W  2  I A   Taken from rnaph.c */
/*----------------------------------------------------------------------------
  %%Function: CopyDw2Ia

  Convert a DWORD to an Internet Address

----------------------------------------------------------------------------*/
VOID CopyDw2Ia(DWORD dw, RASIPADDR* pia)
{
  SwapDwBytes(&dw);
  *pia = ((PIADDR) &dw)->ia;
}

/* D W  F R O M  I A Taken from rnaph.c */
/*----------------------------------------------------------------------------
  %%Function: DwFromIa

  Convert an Internet Address to a DWORD

----------------------------------------------------------------------------*/
DWORD DwFromIa(RASIPADDR *pia)
{
  IADDR iaddr;

  iaddr.dw = * (LPDWORD) pia;
  SwapDwBytes(&iaddr.dw);  
  
  return iaddr.dw;
}

/* F  V A L I D  I A    Taken from rnaph.c */
/*----------------------------------------------------------------------------
  %%Function: FValidIa

  Return TRUE if the IP address is valid

----------------------------------------------------------------------------*/
BOOL FValidIa(RASIPADDR *pia)
{
  BYTE b;

  b = ((PIADDR) pia)->ia.a;
  if (b < MIN_IP_FIELD1 || b > MAX_IP_FIELD1 || b == 127)
    return FALSE;

  b = ((PIADDR) pia)->ia.d;
  if (b > MAX_IP_FIELD4)
    return FALSE;

  return TRUE;
}


/*******************************************************************

  NAME:     SwapDwBits

  SYNOPSIS: Swap the values of the specified bits

  ENTRY:    lpdw - address of DWORD with bits to be swapped
            dwBit1 - mask for first bit
            dwBit2 - mask for second bit

  HISTORY:
  96/05/14  markdu  NASH BUG 22730 Created to work around RNA bug.

********************************************************************/

void SwapDWBits(LPDWORD lpdw, DWORD dwBit1, DWORD dwBit2)
{
  ASSERT(lpdw);

  // Only need to swap if exactly one of the two bits is set since
  // otherwise the bits are identical.
  if (((*lpdw & dwBit1) &&
    !(*lpdw & dwBit2)) ||
    (!(*lpdw & dwBit1) &&
    (*lpdw & dwBit2)))
  {
    // Since only one of the two bits was set, we can simulate the swap
    // by flipping each bit.
    *lpdw ^= dwBit1;
    *lpdw ^= dwBit2;
  }
}

//+----------------------------------------------------------------------------
//
//      Function:       InitTAPILocation
//
//      Synopsis:       Ensure that TAPI location information is configured correctly;
//                              if not, prompt user to fill it in.
//
//      Arguments:      hwndParent -- parent window for TAPI dialog to use
//                                                      (_must_ be a valid window HWND, see note below)
//
//      Returns:        void
//
//      Notes:          The docs for lineTranslateDialog lie when they say that the
//                              fourth parameter (hwndOwner) can be null.  In fact, if this
//                              is null, the call will return with LINEERR_INVALPARAM.
//                              
//
//      History:        7/15/97 jmazner Created for Olympus #6294
//
//-----------------------------------------------------------------------------
BOOL InitTAPILocation(HWND hwndParent)
{
    HLINEAPP hLineApp=NULL;
    TCHAR szTempCountryCode[8];
    TCHAR szTempCityCode[8];
    BOOL bRetVal = TRUE;
    DWORD dwTapiErr = 0;
    DWORD cDevices=0;
    DWORD dwCurDevice = 0;


    ASSERT( IsWindow(hwndParent) );

    //
    // see if we can get location info from TAPI
    //
    dwTapiErr = tapiGetLocationInfo(szTempCountryCode,szTempCityCode);
    if( 0 != dwTapiErr )
    {
        // 
        // GetLocation failed.  let's try calling the TAPI mini dialog.  Note
        // that when called in this fashion, the dialog has _no_ cancel option,
        // the user is forced to enter info and hit OK.
        //
        DEBUGMSG("InitTAPILocation, tapiGetLocationInfo failed");
        
        dwTapiErr = lineInitialize(&hLineApp,ghInstance,LineCallback," ",&cDevices);
        if (dwTapiErr == ERROR_SUCCESS)
        {
            //
            // loop through all TAPI devices and try to call lineTranslateDialog
            // The call might fail for VPN devices, thus we want to try every
            // device until we get a success.
            //
            dwTapiErr = LINEERR_INVALPARAM;

            while( (dwTapiErr != 0) && (dwCurDevice < cDevices) )
            {
                BOOL bIsNT5 = IsNT5();
                if (bIsNT5)
                    EnableWindow(hwndParent, FALSE);
                dwTapiErr = lineTranslateDialog(hLineApp,dwCurDevice,0x10004,hwndParent,NULL);
                if (bIsNT5)
                    EnableWindow(hwndParent, TRUE);

                if( 0 != dwTapiErr )
                {
                    DEBUGMSG("InitTAPILocation, lineTranslateDialog on device %d failed with err = %d!",
                        dwCurDevice, dwTapiErr);
                    if (bIsNT5)
                    {
                        bRetVal = FALSE;
                        break;
                    }
                }
                dwCurDevice++;
            }
        }
        else
        {
            DEBUGMSG("InitTAPILocation, lineInitialize failed with err = %d", dwTapiErr);
        }

        dwTapiErr = tapiGetLocationInfo(szTempCountryCode,szTempCityCode);
        if( 0 != dwTapiErr )
        {
            DEBUGMSG("InitTAPILocation still failed on GetLocationInfo, bummer.");
        }
        else
        {
            DEBUGMSG("InitTAPILocation, TAPI location is initialized now");
        }
    }

    if( hLineApp )
    {
        lineShutdown(hLineApp);
        hLineApp = NULL;
    }

    return bRetVal;
}