windows-xp/Source/XPSP1/NT/base/ntsetup/oobe/msobcomm/refdial.cpp

// RefDial.cpp : Implementation of CRefDial
//#include "stdafx.h"
//#include "icwhelp.h"
#include <urlmon.h>
#include "commerr.h"
#include "RefDial.h"
#include "msobcomm.h"
#include "appdefs.h"
#include "commerr.h"
#include "util.h"
#include "msobdl.h"

#define STRSAFE_NO_DEPRECATE
#include <strsafe.h>

//#include <mshtmhst.h>
const WCHAR c_szCreditsMagicNum[] = L"1 425 555 1212";

const WCHAR c_szRegStrValDigitalPID[] = L"DigitalProductId";
const WCHAR c_szSignedPIDFName[] = L"signed.pid";

const WCHAR c_szRASProfiles[] = L"RemoteAccess\\Profile";
const WCHAR c_szProxyEnable[] = L"ProxyEnable";
const WCHAR c_szURLReferral[] = L"URLReferral";
const WCHAR c_szRegPostURL[]  = L"RegPostURL";
const WCHAR c_szStayConnected[] = L"Stayconnected";
static const WCHAR szOptionTag[] = L"<OPTION>%s";

WCHAR g_BINTOHEXLookup[16] =
{
   L'0',L'1',L'2',L'3',L'4',L'5',L'6',L'7',
   L'8',L'9',L'A',L'B',L'C',L'D',L'E',L'F'
};



extern CObCommunicationManager* gpCommMgr;
extern WCHAR cszUserName[];
extern WCHAR cszPassword[];

extern BOOL isAlnum(WCHAR c);

// ############################################################################
HRESULT Sz2URLValue(WCHAR *s, WCHAR *buf, UINT uiLen)
{
    HRESULT hr;
    WCHAR *t;
    hr = ERROR_SUCCESS;

    for (t=buf;*s; s++)
    {
        if (*s == L' ') *t++ = L'+';
        else if (isAlnum(*s)) *t++ = *s;
        else {
            wsprintf(t, L"%%%02X", (WCHAR) *s);
            t += 3;
        }
    }
    *t = L'\0';
    return hr;
}

//+---------------------------------------------------------------------------
//
//  Function:   LineCallback()
//
//  Synopsis:   Call back for TAPI line
//
//+---------------------------------------------------------------------------
void CALLBACK LineCallback(DWORD hDevice,
                           DWORD dwMessage,
                           DWORD_PTR dwInstance,
                           DWORD_PTR dwParam1,
                           DWORD_PTR dwParam2,
                           DWORD_PTR dwParam3)
{
    return;
}

void WINAPI MyProgressCallBack
(
    HINTERNET hInternet,
    DWORD_PTR dwContext,
    DWORD dwInternetStatus,
    LPVOID lpvStatusInformation,
    DWORD dwStatusInformationLength
)
{
    CRefDial    *pRefDial = (CRefDial *)dwContext;
    int         prc;

    if (!dwContext)
        return;

    switch(dwInternetStatus)
    {
        case CALLBACK_TYPE_PROGRESS:
            prc = *(int*)lpvStatusInformation;
            // Set the status string ID
            pRefDial->m_DownloadStatusID = 0;//IDS_RECEIVING_RESPONSE;

            // Post a message to fire an event
            PostMessage(gpCommMgr->m_hwndCallBack,
                        WM_OBCOMM_DOWNLOAD_PROGRESS,
                        gpCommMgr->m_pRefDial->m_dwCnType,
                        prc);
            break;

        case CALLBACK_TYPE_URL:
            if (lpvStatusInformation)
                lstrcpy(pRefDial->m_szRefServerURL, (LPWSTR)lpvStatusInformation);
            break;

        default:
            //TraceMsg(TF_GENERAL, L"CONNECT:Unknown Internet Status (%d.\n"), dwInternetStatus);
            pRefDial->m_DownloadStatusID = 0;
            break;
    }
}

DWORD WINAPI  DownloadThreadInit(LPVOID lpv)
{
    HRESULT     hr = ERROR_NOT_ENOUGH_MEMORY;
    CRefDial    *pRefDial = (CRefDial*)lpv;
    HINSTANCE   hDLDLL = NULL; // Download .DLL
    FARPROC     fp;

    //MinimizeRNAWindowEx();

    hDLDLL = LoadLibrary(DOWNLOAD_LIBRARY);
    if (!hDLDLL)
    {
        hr = ERROR_DOWNLOAD_NOT_FOUND;
        //AssertMsg(0, L"icwdl missing");
        goto ThreadInitExit;
    }

    // Set up for download
    //
    fp = GetProcAddress(hDLDLL, DOWNLOADINIT);
    if (fp == NULL)
    {
        hr = ERROR_DOWNLOAD_NOT_FOUND;
        //AssertMsg(0, L"DownLoadInit API missing");
        goto ThreadInitExit;
    }

    hr = ((PFNDOWNLOADINIT)fp)(pRefDial->m_szUrl, (DWORD FAR *)pRefDial, &pRefDial->m_dwDownLoad, gpCommMgr->m_hwndCallBack);
    if (hr != ERROR_SUCCESS)
        goto ThreadInitExit;

    // Set up call back for progress dialog
    //
    fp = GetProcAddress(hDLDLL, DOWNLOADSETSTATUS);
    //Assert(fp);
    hr = ((PFNDOWNLOADSETSTATUS)fp)(pRefDial->m_dwDownLoad, (INTERNET_STATUS_CALLBACK)MyProgressCallBack);

    // Download stuff MIME multipart
    //
    fp = GetProcAddress(hDLDLL, DOWNLOADEXECUTE);
    //Assert(fp);
    hr = ((PFNDOWNLOADEXECUTE)fp)(pRefDial->m_dwDownLoad);
    if (hr)
    {
        goto ThreadInitExit;
    }

    fp = GetProcAddress(hDLDLL, DOWNLOADPROCESS);
    //Assert(fp);
    hr = ((PFNDOWNLOADPROCESS)fp)(pRefDial->m_dwDownLoad);
    if (hr)
    {
        goto ThreadInitExit;
    }

    hr = ERROR_SUCCESS;

ThreadInitExit:

    // Clean up
    //
    if (pRefDial->m_dwDownLoad)
    {
        fp = GetProcAddress(hDLDLL, DOWNLOADCLOSE);
        //Assert(fp);
        ((PFNDOWNLOADCLOSE)fp)(pRefDial->m_dwDownLoad);
        pRefDial->m_dwDownLoad = 0;
    }

    // Call the OnDownLoadCompelete method
    if (ERROR_SUCCESS == hr)
    {
        PostMessage(gpCommMgr->m_hwndCallBack, WM_OBCOMM_DOWNLOAD_DONE, gpCommMgr->m_pRefDial->m_dwCnType, 0);
    }

    // Free the libs used to do the download
    if (hDLDLL)
        FreeLibrary(hDLDLL);

    return hr;
}



//+---------------------------------------------------------------------------
//
//  Function:   RasErrorToIDS()
//
//  Synopsis:   Interpret and wrap RAS errors
//
//+---------------------------------------------------------------------------
DWORD RasErrorToIDS(DWORD dwErr)
{
    switch(dwErr)
    {
    case SUCCESS:
        return 0;

    case ERROR_LINE_BUSY:
        return ERR_COMM_RAS_PHONEBUSY;

    case ERROR_NO_ANSWER:       // No pick up
    case ERROR_NO_CARRIER:      // No negotiation
    case ERROR_PPP_TIMEOUT:     // get this on CHAP timeout
        return ERR_COMM_RAS_SERVERBUSY;

    case ERROR_NO_DIALTONE:
        return ERR_COMM_RAS_NODIALTONE;

    case ERROR_HARDWARE_FAILURE:    // modem turned off
    case ERROR_PORT_ALREADY_OPEN:   // procomm/hypertrm/RAS has COM port
    case ERROR_PORT_OR_DEVICE:      // got this when hypertrm had the device open -- jmazner
        return ERR_COMM_RAS_NOMODEM;

    }
    return ERR_COMM_RAS_UNKNOWN;
}

DWORD DoConnMonitor(LPVOID lpv)
{
    if (gpCommMgr)
        gpCommMgr->m_pRefDial->ConnectionMonitorThread(NULL);

    return 1;
}

void CreateConnMonitorThread(LPVOID lpv)
{
    DWORD dwThreadID;
    if (gpCommMgr->m_pRefDial->m_hConnMonThread)
        gpCommMgr->m_pRefDial->TerminateConnMonitorThread();

    gpCommMgr->m_pRefDial->m_hConnMonThread = CreateThread(NULL,
                             0,
                             (LPTHREAD_START_ROUTINE)DoConnMonitor,
                             (LPVOID)0,
                             0,
                             &dwThreadID);

}

HRESULT CRefDial::OnDownloadEvent(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL* bHandled)
{
    if (uMsg == WM_OBCOMM_DOWNLOAD_DONE)
    {
        DWORD   dwThreadResults = STILL_ACTIVE;
        int     iRetries = 0;

        // We keep the RAS connection open here, it must be explicitly
        // close by the container (a call DoHangup)
        // This code will wait until the download thread exists, and
        // collect the download status.
        if (m_hThread)
        {
            do {
                if (!GetExitCodeThread(m_hThread, &dwThreadResults))
                {
                    //ASSERT(0, L"CONNECT:GetExitCodeThread failed.\n");
                }

                iRetries++;
                if (dwThreadResults  == STILL_ACTIVE)
                    Sleep(500);
            } while (dwThreadResults == STILL_ACTIVE && iRetries < MAX_EXIT_RETRIES);
            m_hThread = NULL;
        }

        // BUGBUG: Is bstrURL used for anything??
        // See if there is an URL to pass to the container
        BSTR    bstrURL;
        if (m_szRefServerURL[0] != L'\0')
            bstrURL = SysAllocString(m_szRefServerURL);
        else
            bstrURL = NULL;

        // The download is complete now, so we reset this to TRUE, so the RAS
        // event handler does not get confused
        m_bDownloadHasBeenCanceled = TRUE;

        // Read and parse the download folder.
        *bHandled = ParseISPInfo(NULL, ICW_ISPINFOPath, TRUE);

        // Free any memory allocated above during the conversion
        SysFreeString(bstrURL);

    }
    return 0;
}

//+---------------------------------------------------------------------------
//
//  Function:   TerminateConnMonitorThread()
//
//  Synopsis:   Termintate connection monitor thread
//
//+---------------------------------------------------------------------------
void CRefDial::TerminateConnMonitorThread()
{
    DWORD   dwThreadResults = STILL_ACTIVE;
    int     iRetries = 0;

    if (m_hConnMonThread)
    {
        SetEvent(m_hConnectionTerminate);

        // We keep the RAS connection open here, it must be explicitly
        // close by the container (a call DoHangup)
        // This code will wait until the monitor thread exists, and
        // collect the status.
        do
        {
            if (!GetExitCodeThread(m_hConnMonThread, &dwThreadResults))
            {
                break;
            }

            iRetries++;
            if (dwThreadResults  == STILL_ACTIVE)
                Sleep(500);
        } while (dwThreadResults == STILL_ACTIVE && iRetries < MAX_EXIT_RETRIES);


        CloseHandle(m_hConnMonThread);
        m_hConnMonThread = NULL;
    }
}

//+---------------------------------------------------------------------------
//
//  Function:   ConnectionMonitorThread()
//
//  Synopsis:   Monitor connection status
//
//+---------------------------------------------------------------------------
DWORD CRefDial::ConnectionMonitorThread(LPVOID pdata)
{
    HRESULT  hr   = E_FAIL;

    MSG     msg;
    DWORD   dwRetCode;
    HANDLE  hEventList[1];
    BOOL    bConnected;

    m_hConnectionTerminate = CreateEvent(NULL, TRUE, FALSE, NULL);

    hEventList[0] = m_hConnectionTerminate;


    while(TRUE)
    {
        // We will wait on window messages and also the named event.
        dwRetCode = MsgWaitForMultipleObjects(1,
                                              &hEventList[0],
                                              FALSE,
                                              1000,            // 1 second
                                              QS_ALLINPUT);
        if(dwRetCode == WAIT_TIMEOUT)
        {
            RasGetConnectStatus(&bConnected);
            // If we've got disconnected, then we notify UI
            if (!bConnected)
            {
                PostMessage(gpCommMgr->m_hwndCallBack, WM_OBCOMM_ONDIALERROR, (WPARAM)gpCommMgr->m_pRefDial->m_dwCnType, (LPARAM)ERROR_REMOTE_DISCONNECTION);
                break;
            }
        }
        else if(dwRetCode == WAIT_OBJECT_0)
        {
            break;
        }
        else if(dwRetCode == WAIT_OBJECT_0 + 1)
        {
            if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
            {
                if (WM_QUIT == msg.message)
                {
                    //*pbRetVal = FALSE;
                    break;
                }
                else
                {
                    TranslateMessage(&msg);
                    DispatchMessage(&msg);
                }
            }
        }

    }
    CloseHandle(m_hConnectionTerminate);
    m_hConnectionTerminate = NULL;
    return hr;
}

//+---------------------------------------------------------------------------
//
//  Function:   RasDialFunc()
//
//  Synopsis:   Call back for RAS
//
//+---------------------------------------------------------------------------
void CALLBACK CRefDial::RasDialFunc(HRASCONN        hRas,
                                    UINT            unMsg,
                                    RASCONNSTATE    rasconnstate,
                                    DWORD           dwError,
                                    DWORD           dwErrorEx)
{
    if (gpCommMgr)
    {
        if (dwError)
        {
            if (ERROR_USER_DISCONNECTION != dwError)
            {
                gpCommMgr->m_pRefDial->DoHangup();
                //gpCommMgr->Fire_DialError((DWORD)rasconnstate);

                TRACE1(L"DialError %d", dwError);

                gpCommMgr->m_pRefDial->m_dwRASErr = dwError;  // Store dialing error
                PostMessage(gpCommMgr->m_hwndCallBack, WM_OBCOMM_ONDIALERROR, (WPARAM)gpCommMgr->m_pRefDial->m_dwCnType, (LPARAM)gpCommMgr->m_pRefDial->m_dwRASErr);
            }
        }
        else
        {
            switch(rasconnstate)
            {
                case RASCS_OpenPort:
                    //gpCommMgr->Fire_Dialing((DWORD)rasconnstate);
                    PostMessage(gpCommMgr->m_hwndCallBack, WM_OBCOMM_ONDIALING, (WPARAM)gpCommMgr->m_pRefDial->m_dwCnType, (LPARAM)0);
                    break;

                case RASCS_StartAuthentication: // WIN 32 only
                    //gpCommMgr->Fire_Connecting();
                    PostMessage(gpCommMgr->m_hwndCallBack, WM_OBCOMM_ONCONNECTING, (WPARAM)gpCommMgr->m_pRefDial->m_dwCnType, (LPARAM)0);
                    break;
                case RASCS_Authenticate: // WIN 32 only
                    //gpCommMgr->Fire_Connecting();
                    if (IsNT())
                        PostMessage(gpCommMgr->m_hwndCallBack, WM_OBCOMM_ONCONNECTING, (WPARAM)gpCommMgr->m_pRefDial->m_dwCnType, (LPARAM)0);
                    break;
                case RASCS_PortOpened:
                    break;
                case RASCS_ConnectDevice:
                    break;
                case RASCS_DeviceConnected:
                case RASCS_AllDevicesConnected:
                    PostMessage(gpCommMgr->m_hwndCallBack, WM_OBCOMM_ONCONNECTING, (WPARAM)gpCommMgr->m_pRefDial->m_dwCnType, (LPARAM)0);
                    break;
                case RASCS_Connected:
                {
                    CreateConnMonitorThread(NULL);
                    PostMessage(gpCommMgr->m_hwndCallBack,
                                WM_OBCOMM_ONCONNECTED,
                                (WPARAM)gpCommMgr->m_pRefDial->m_dwCnType,
                                (LPARAM)0);
                    break;
                }
                case RASCS_Disconnected:
                {

                    if (CONNECTED_REFFERAL == gpCommMgr->m_pRefDial->m_dwCnType &&
                        !gpCommMgr->m_pRefDial->m_bDownloadHasBeenCanceled)
                    {
                        HINSTANCE hDLDLL = LoadLibrary(DOWNLOAD_LIBRARY);
                        if (hDLDLL)
                        {
                            FARPROC fp = GetProcAddress(hDLDLL, DOWNLOADCANCEL);
                            if(fp)
                                ((PFNDOWNLOADCANCEL)fp)(gpCommMgr->m_pRefDial->m_dwDownLoad);
                            FreeLibrary(hDLDLL);
                            hDLDLL = NULL;
                            gpCommMgr->m_pRefDial->m_bDownloadHasBeenCanceled = TRUE;
                        }
                    }


                    // If we get a disconnected status from the RAS server, then
                    // hangup the modem here
                    gpCommMgr->m_pRefDial->DoHangup();
                    //gpCommMgr->Fire_DialError((DWORD)rasconnstate);
                    PostMessage(gpCommMgr->m_hwndCallBack, WM_OBCOMM_ONDISCONNECT, (WPARAM)gpCommMgr->m_pRefDial->m_dwCnType, (LPARAM)0);
                    break;
                }

                default:
                    break;
            }
        }
    }
    return;
}

/////////////////////////////////////////////////////////////////////////////
// CRefDial
CRefDial::CRefDial()
{

    HKEY        hkey                    = NULL;
    DWORD       dwResult                = 0;

    *m_szCurrentDUNFile                 = 0;
    *m_szLastDUNFile                    = 0;
    *m_szEntryName                      = 0;
    *m_szConnectoid                     = 0;
    *m_szPID                            = 0;
    *m_szRefServerURL                   = 0;
    *m_szRegServerName                  = 0;
    m_nRegServerPort                    = INTERNET_INVALID_PORT_NUMBER;
    m_fSecureRegServer                  = FALSE;
    *m_szRegFormAction                  = 0;
    *m_szISPSupportNumber               = 0;
    *m_szISPFile                        = 0;
    m_hrDisplayableNumber               = ERROR_SUCCESS;
    m_dwCountryCode                     = 0;
    m_RasStatusID                       = 0;
    m_dwTapiDev                         = 0xFFFFFFFF; // NOTE: 0 is a valid value
    m_dwWizardVersion                   = 0;
    m_lCurrentModem                     = -1;
    m_lAllOffers                        = 0;
    m_PhoneNumberEnumidx                = 0;
    m_dwRASErr                          = 0;
    m_bDownloadHasBeenCanceled          = TRUE;      // This will get set to FALSE when a DOWNLOAD starts
    m_bQuitWizard                       = FALSE;
    m_bTryAgain                         = FALSE;
    m_bDisconnect                       = FALSE;
    m_bDialCustom                       = FALSE;
    m_bModemOverride                    = FALSE;     //allows campus net to be used.
    m_hrasconn                          = NULL;
    m_pszDisplayable                    = NULL;
    m_pcRNA                             = NULL;
    m_hRasDll                           = NULL;
    m_fpRasDial                         = NULL;
    m_fpRasGetEntryDialParams           = NULL;
    m_lpGatherInfo                      = new GATHERINFO;
    m_reflpRasEntryBuff                 = NULL;
    m_reflpRasDevInfoBuff               = NULL;
    m_hThread                           = NULL;
    m_hDialThread                       = NULL;
    m_hConnMonThread                    = NULL;
    m_bUserInitiateHangup               = FALSE;
    m_pszOriginalDisplayable            = NULL;
    m_bDialAlternative                  = TRUE;

    memset(&m_SuggestInfo, 0, sizeof(m_SuggestInfo));
    memset(&m_szConnectoid, 0, RAS_MaxEntryName+1);

    m_dwAppMode                         = 0;
    m_bDial                             = FALSE;
    m_dwCnType                    = CONNECTED_ISP_SIGNUP;
    m_pszISPList                        = FALSE;
    m_dwNumOfAutoConfigOffers           = 0;
    m_pCSVList                          = NULL;
    m_unSelectedISP                     = 0;

    m_bstrPromoCode                     = SysAllocString(L"\0");
    m_bstrProductCode                   = SysAllocString(L"\0");
    m_bstrSignedPID                     = SysAllocString(L"\0");
    m_bstrSupportNumber                 = SysAllocString(L"\0");
    m_bstrLoggingStartUrl               = SysAllocString(L"\0");
    m_bstrLoggingEndUrl                 = SysAllocString(L"\0");

    // This Critical Section is used by DoHangup and GetDisplayableNumber
    InitializeCriticalSection (&m_csMyCriticalSection);

    // Initialize m_dwConnectionType.
    m_dwConnectionType                  = 0;
    if ( RegOpenKey(HKEY_LOCAL_MACHINE, ICSSETTINGSPATH,&hkey) == ERROR_SUCCESS)
    {
        DWORD dwSize = sizeof(DWORD);
        DWORD dwType = REG_DWORD;

        if (RegQueryValueEx(hkey, ICSCLIENT,NULL,&dwType,(LPBYTE)&dwResult, &dwSize) != ERROR_SUCCESS)
            dwResult = 0;

        RegCloseKey(hkey);
    }
    if ( 0 != dwResult )
        m_dwConnectionType = CONNECTION_ICS_TYPE;

    m_bAutodialModeSaved = FALSE;
    m_bCleanupAutodial = FALSE;

}

CRefDial::~CRefDial()
{

    if (m_hrasconn)
        DoHangup();

    if (m_hConnMonThread)
    {
        SetEvent(m_hConnectionTerminate);
    }

    CleanupAutodial();

    if (NULL != m_hThread)
    {
        CloseHandle(m_hThread);
        m_hThread = NULL;
    }

    if (NULL != m_hDialThread)
    {
        CloseHandle(m_hDialThread);
        m_hDialThread = NULL;
    }

    if (NULL != m_hConnMonThread)
    {
        CloseHandle(m_hConnMonThread);
        m_hConnMonThread = NULL;
    }

    if (m_lpGatherInfo)
        delete(m_lpGatherInfo);

    if( (m_pcRNA!=NULL) && (*m_szConnectoid != 0) )
    {
        m_pcRNA->RasDeleteEntry(NULL, m_szConnectoid);
    }

    if ( m_pcRNA )
        delete m_pcRNA;

    if(m_reflpRasEntryBuff)
    {
        GlobalFree(m_reflpRasEntryBuff);
        m_reflpRasEntryBuff = NULL;
    }
    if(m_reflpRasDevInfoBuff)
    {
        GlobalFree(m_reflpRasDevInfoBuff);
        m_reflpRasDevInfoBuff = NULL;
    }
    if (m_pszISPList)
        delete [] m_pszISPList;
    DeleteCriticalSection(&m_csMyCriticalSection);

    if (m_pszOriginalDisplayable)
    {
        GlobalFree(m_pszOriginalDisplayable);
        m_pszOriginalDisplayable = NULL;
    }

    CleanISPList();
}

void CRefDial::CleanISPList(void)
{
    if (m_pCSVList)
    {
        ISPLIST*        pCurr;
        while (m_pCSVList->pNext != NULL)
        {
            pCurr = m_pCSVList;
            if (NULL != m_pCSVList->pElement)
            {
                delete pCurr->pElement;
            }
            m_pCSVList = pCurr->pNext;
            delete pCurr;
        }
        if (NULL != m_pCSVList->pElement)
            delete m_pCSVList->pElement;
        delete m_pCSVList;
        m_pCSVList = NULL;
        m_pSelectedISPInfo = NULL;
    }
}

/******************************************************************************
// These functions come from the existing ICW code and are use to setup a
// connectiod to the referral server, dial it, and perform the download.
******************************************************************************/

//+----------------------------------------------------------------------------
//    Function:    ReadConnectionInformation
//
//    Synopsis:    Read the contents from the ISP file
//
//    Arguments:    none
//
//    Returns:    error value - ERROR_SUCCESS = succes
//
//    History:    1/9/98      DONALDM     Adapted from ICW 1.x
//-----------------------------------------------------------------------------
//INT _convert;
DWORD CRefDial::ReadConnectionInformation(void)
{

    DWORD       hr;
    WCHAR       szUserName[UNLEN+1];
    WCHAR       szPassword[PWLEN+1];
    LPWSTR       pszTemp;
    BOOL        bReboot;
    LPWSTR       lpRunOnceCmd;

    bReboot = FALSE;
    lpRunOnceCmd = NULL;


    //
    // Get the name of DUN file from ISP file, if there is one.
    //
    WCHAR pszDunFile[MAX_PATH];
    *m_szCurrentDUNFile = 0;
    hr = GetDataFromISPFile(m_szISPFile, INF_SECTION_ISPINFO, INF_DUN_FILE, pszDunFile,MAX_PATH);
    if (ERROR_SUCCESS == hr)
    {
        //
        // Get the full path to the DUN File
        //
        WCHAR    szTempPath[MAX_PATH];
        lstrcpy(szTempPath, pszDunFile);
        if (!(hr = SearchPath(NULL, szTempPath,NULL,MAX_PATH,pszDunFile,&pszTemp)))
        {
            //ErrorMsg1(m_hWnd, IDS_CANTREADTHISFILE, CharUpper(pszDunFile));
            goto ReadConnectionInformationExit;
        }

        //
        // save current DUN file name in global (for ourself)
        //
        lstrcpy(m_szCurrentDUNFile, pszDunFile);
    }

    //
    // Read the DUN/ISP file File
    //

    hr = m_ISPImport.ImportConnection(*m_szCurrentDUNFile != 0 ? m_szCurrentDUNFile : m_szISPFile,
                                      m_szISPSupportNumber,
                                      m_szEntryName,
                                      szUserName,
                                      szPassword,
                                      &bReboot);

    lstrcpyn( m_szConnectoid, m_szEntryName, lstrlen(m_szEntryName) + 1);

    if (/*(VER_PLATFORM_WIN32_NT == g_dwPlatform) &&*/ (ERROR_INVALID_PARAMETER == hr))
    {
        // If there are only dial-out entries configured on NT, we get
        // ERROR_INVALID_PARAMETER returned from RasSetEntryProperties,
        // which InetConfigClient returns to ImportConnection which
        // returns it to us.  If we get this error, we want to display
        // a different error instructing the user to configure a modem
        // for dial-out.
        ////MessageBox(GetSz(IDS_NODIALOUT),
        //           GetSz(IDS_TITLE),
        //           MB_ICONERROR | MB_OK | MB_APPLMODAL);
        goto ReadConnectionInformationExit;
    }
    else
    if (ERROR_CANNOT_FIND_PHONEBOOK_ENTRY == hr)
    {
        //
        // The disk is full, or something is wrong with the
        // phone book file
        ////MessageBox(GetSz(IDS_NOPHONEENTRY),
        //           GetSz(IDS_TITLE),
        //           MB_ICONERROR | MB_OK | MB_APPLMODAL);
        goto ReadConnectionInformationExit;
    }
    else if (hr == ERROR_CANCELLED)
    {
        ////TraceMsg(TF_GENERAL, L"ICWHELP: User cancelled, quitting.\n");
        goto ReadConnectionInformationExit;
    }
    else if (hr == ERROR_RETRY)
    {
        //TraceMsg(TF_GENERAL, L"ICWHELP: User retrying.\n");
        goto ReadConnectionInformationExit;
    }
    else if (hr != ERROR_SUCCESS)
    {
        ////ErrorMsg1(m_hWnd, IDS_CANTREADTHISFILE, CharUpper(pszDunFile));
        goto ReadConnectionInformationExit;
    }
    else
    {

        //
        // place the name of the connectoid in the registry
        //
        if (ERROR_SUCCESS != (hr = StoreInSignUpReg((LPBYTE)m_szEntryName, BYTES_REQUIRED_BY_SZ(m_szEntryName), REG_SZ, RASENTRYVALUENAME)))
        {
            ////MsgBox(IDS_CANTSAVEKEY, MB_MYERROR);
            goto ReadConnectionInformationExit;
        }
    }

ReadConnectionInformationExit:
    return hr;
}

HRESULT CRefDial::ReadPhoneBook(LPGATHERINFO lpGatherInfo, PSUGGESTINFO pSuggestInfo)
{
    HRESULT hr = ERROR_CANNOT_FIND_PHONEBOOK_ENTRY;;
    if (pSuggestInfo && m_lpGatherInfo)
    {
        //
        // If phonenumber is not filled in by the ISP file,
        // get phone number from oobe phone book
        //

        pSuggestInfo->wNumber = 1;
        lpGatherInfo->m_bUsePhbk = TRUE;


        WCHAR   szEntrySection[3];
        WCHAR   szEntryName[MAX_PATH];
        WCHAR   szEntryValue[MAX_PATH];
        INT     nPick = 1;
        INT     nTotal= 3;

        WCHAR    szFileName[MAX_PATH];
        LPWSTR   pszTemp;

        // Get Country ID from TAPI
        m_SuggestInfo.AccessEntry.dwCountryCode = m_lpGatherInfo->m_dwCountryCode;


        // Get the name of phone book
        GetPrivateProfileString(INF_SECTION_ISPINFO,
                              INF_PHONE_BOOK,
                              cszOobePhBkFile,
                              szEntryValue,
                              MAX_CHARS_IN_BUFFER(szEntryValue),
                              m_szISPFile);


        SearchPath(NULL, szEntryValue,NULL,MAX_PATH,&szFileName[0],&pszTemp);
        wsprintf(szEntrySection, L"%ld", m_lpGatherInfo->m_dwCountryID);

        // Read the total number of phone numbers
        nTotal = GetPrivateProfileInt(szEntrySection,
                              cszOobePhBkCount,
                              1,
                              szFileName);

        GetPrivateProfileString(szEntrySection,
                              cszOobePhBkRandom,
                              L"No",
                              szEntryValue,
                              MAX_CHARS_IN_BUFFER(szEntryValue),
                              szFileName);

        if (0 == lstrcmp(szEntryValue, L"Yes"))
        {
            // Pick a random number to dial
            nPick = (rand() % nTotal) + 1;
        }
        else
        {
            nPick = (pSuggestInfo->dwPick % nTotal) + 1;
        }


        // Read the name of the city
        wsprintf(szEntryName, cszOobePhBkCity, nPick);
        GetPrivateProfileString(szEntrySection,
                              szEntryName,
                              L"",
                              szEntryValue,
                              MAX_CHARS_IN_BUFFER(szEntryValue),
                              szFileName);
        lstrcpy(pSuggestInfo->AccessEntry.szCity, szEntryValue);
        if (0 == lstrlen(szEntryValue))
        {
            goto ReadPhoneBookExit;
        }

        // Read the dunfile entry from the phonebook
        // lstrcpy(pSuggestInfo->AccessEntry.szDataCenter, L"icwip.dun");
        wsprintf(szEntryName, cszOobePhBkDunFile, nPick);
        GetPrivateProfileString(szEntrySection,
                              szEntryName,
                              L"",
                              szEntryValue,
                              MAX_CHARS_IN_BUFFER(szEntryValue),
                              szFileName);
        lstrcpy(pSuggestInfo->AccessEntry.szDataCenter, szEntryValue);
        if (0 == lstrlen(szEntryValue))
        {
            goto ReadPhoneBookExit;
        }

        // Pick up country code from the Phonebook
        wsprintf(szEntryName, cszOobePhBkAreaCode, nPick);
        GetPrivateProfileString(szEntrySection,
                              szEntryName,
                              L"",
                              szEntryValue,
                              MAX_CHARS_IN_BUFFER(szEntryValue),
                              szFileName);
        lstrcpy(pSuggestInfo->AccessEntry.szAreaCode, szEntryValue);
        // No area code is possible

        // Read the phone number (without areacode) from the Phonebook
        wsprintf(szEntryName, cszOobePhBkNumber, nPick);
        GetPrivateProfileString(szEntrySection,
                              szEntryName,
                              L"",
                              szEntryValue,
                              MAX_CHARS_IN_BUFFER(szEntryValue),
                              szFileName);
        lstrcpy(pSuggestInfo->AccessEntry.szAccessNumber, szEntryValue);
        if (0 == lstrlen(szEntryValue))
        {
            goto ReadPhoneBookExit;
        }

        hr = ERROR_SUCCESS;
    }
ReadPhoneBookExit:
    return hr;
}

HRESULT CRefDial::GetDisplayableNumber()
{
    HRESULT                 hr = ERROR_SUCCESS;
    LPRASENTRY              lpRasEntry = NULL;
    LPRASDEVINFO            lpRasDevInfo = NULL;
    DWORD                   dwRasEntrySize = 0;
    DWORD                   dwRasDevInfoSize = 0;
    RNAAPI                  *pcRNA = NULL;
    LPLINETRANSLATEOUTPUT   lpOutput1 = NULL;

    DWORD dwNumDev;
    LPLINETRANSLATEOUTPUT lpOutput2;
    LPLINEEXTENSIONID lpExtensionID = NULL;

    // Turns out that DialThreadInit can call this at the same time
    // that script will call this. So, we need to prevent them from
    // stepping on shared variables - m_XXX.
    EnterCriticalSection (&m_csMyCriticalSection);

    //
    // Get phone number from connectoid
    //
    hr = MyRasGetEntryProperties(NULL,
                                m_szConnectoid,
                                &lpRasEntry,
                                &dwRasEntrySize,
                                &lpRasDevInfo,
                                &dwRasDevInfoSize);


    if (hr != ERROR_SUCCESS || NULL == lpRasEntry)
    {
        goto GetDisplayableNumberExit;
    }

    //
    // If this is a dial as is number, just get it from the structure
    //
    m_bDialAsIs = !(lpRasEntry->dwfOptions & RASEO_UseCountryAndAreaCodes);
    if (m_bDialAsIs)
    {
        if (m_pszDisplayable) GlobalFree(m_pszDisplayable);
        m_pszDisplayable = (LPWSTR)GlobalAlloc(GPTR, BYTES_REQUIRED_BY_SZ(lpRasEntry->szLocalPhoneNumber));
        if (!m_pszDisplayable)
        {
            hr = ERROR_NOT_ENOUGH_MEMORY;
            goto GetDisplayableNumberExit;
        }
        lstrcpy(m_szPhoneNumber, lpRasEntry->szLocalPhoneNumber);
        lstrcpy(m_pszDisplayable, lpRasEntry->szLocalPhoneNumber);
        WCHAR szAreaCode[MAX_AREACODE+1];
        WCHAR szCountryCode[8];
        if (SUCCEEDED(tapiGetLocationInfo(szCountryCode, szAreaCode)))
        {
            if (szCountryCode[0] != L'\0')
                m_dwCountryCode = _wtoi(szCountryCode);
            else
                m_dwCountryCode = 1;
        }
        else
        {
            m_dwCountryCode = 1;

        }

    }
    else
    {
        //
        // If there is no area code, don't use parentheses
        //
        if (lpRasEntry->szAreaCode[0])
            wsprintf(m_szPhoneNumber, L"+%lu (%s) %s\0",lpRasEntry->dwCountryCode,
                        lpRasEntry->szAreaCode, lpRasEntry->szLocalPhoneNumber);
        else
            wsprintf(m_szPhoneNumber, L"+%lu %s\0",lpRasEntry->dwCountryCode,
                        lpRasEntry->szLocalPhoneNumber);


        //
        //  Initialize TAPIness
        //
        dwNumDev = 0;

        DWORD dwVer = 0x00020000;

        hr = lineInitializeEx(&m_hLineApp,
                              NULL,
                              LineCallback,
                              NULL,
                              &dwNumDev,
                              &dwVer,
                              NULL);

        if (hr != ERROR_SUCCESS)
            goto GetDisplayableNumberExit;

        lpExtensionID = (LPLINEEXTENSIONID )GlobalAlloc(GPTR, sizeof(LINEEXTENSIONID));
        if (!lpExtensionID)
        {
            hr = ERROR_NOT_ENOUGH_MEMORY;
            goto GetDisplayableNumberExit;
        }

        if (m_dwTapiDev == 0xFFFFFFFF)
        {
                m_dwTapiDev = 0;
        }

        //
        // ChrisK Olympus 5558 6/11/97
        // PPTP device will choke the version negotiating
        //

        do {  //E_FAIL here?
            hr = lineNegotiateAPIVersion(m_hLineApp,
                                         m_dwTapiDev,
                                         0x00010004,
                                         0x00020000,
                                         &m_dwAPIVersion,
                                         lpExtensionID);

        } while (hr != ERROR_SUCCESS && m_dwTapiDev++ < dwNumDev - 1);

        if (m_dwTapiDev >= dwNumDev)
        {
            m_dwTapiDev = 0;
        }

        // ditch it since we don't use it
        //
        if (lpExtensionID) GlobalFree(lpExtensionID);
        lpExtensionID = NULL;
        if (hr != ERROR_SUCCESS)
            goto GetDisplayableNumberExit;

        // Format the phone number
        //

        lpOutput1 = (LPLINETRANSLATEOUTPUT)GlobalAlloc(GPTR, sizeof(LINETRANSLATEOUTPUT));
        if (!lpOutput1)
        {
            hr = ERROR_NOT_ENOUGH_MEMORY;
            goto GetDisplayableNumberExit;
        }
        lpOutput1->dwTotalSize = sizeof(LINETRANSLATEOUTPUT);

        // Turn the canonical form into the "displayable" form
        //

        hr = lineTranslateAddress(m_hLineApp, m_dwTapiDev,m_dwAPIVersion,
                                    m_szPhoneNumber, 0,
                                    LINETRANSLATEOPTION_CANCELCALLWAITING,
                                    lpOutput1);

        // We've seen hr == ERROR_SUCCESS but the size is too small,
        // Also, the docs hint that some error cases are due to struct too small.
        if (lpOutput1->dwNeededSize > lpOutput1->dwTotalSize)
        {
            lpOutput2 = (LPLINETRANSLATEOUTPUT)GlobalAlloc(GPTR, (size_t)lpOutput1->dwNeededSize);
            if (!lpOutput2)
            {
                hr = ERROR_NOT_ENOUGH_MEMORY;
                goto GetDisplayableNumberExit;
            }
            lpOutput2->dwTotalSize = lpOutput1->dwNeededSize;
            GlobalFree(lpOutput1);
            lpOutput1 = lpOutput2;
            lpOutput2 = NULL;
            hr = lineTranslateAddress(m_hLineApp, m_dwTapiDev,
                                        m_dwAPIVersion, m_szPhoneNumber,0,
                                        LINETRANSLATEOPTION_CANCELCALLWAITING,
                                        lpOutput1);
        }

        if (hr != ERROR_SUCCESS)
        {
            goto GetDisplayableNumberExit;
        }

        if (m_pszDisplayable)
        {
            GlobalFree(m_pszDisplayable);
        }
        m_pszDisplayable = (LPWSTR)GlobalAlloc(GPTR, ((size_t)lpOutput1->dwDisplayableStringSize+1));
        if (!m_pszDisplayable)
        {
            hr = ERROR_NOT_ENOUGH_MEMORY;
            goto GetDisplayableNumberExit;
        }

        lstrcpyn(m_pszDisplayable,
                    (LPWSTR)&((LPBYTE)lpOutput1)[lpOutput1->dwDisplayableStringOffset],
                    (int)(lpOutput1->dwDisplayableStringSize/sizeof(WCHAR)));

        WCHAR szAreaCode[MAX_AREACODE+1];
        WCHAR szCountryCode[8];
        if (SUCCEEDED(tapiGetLocationInfo(szCountryCode, szAreaCode)))
        {
            if (szCountryCode[0] != L'\0')
                m_dwCountryCode = _wtoi(szCountryCode);
            else
                m_dwCountryCode = 1;
        }
        else
        {
            m_dwCountryCode = 1;

        }

    }

GetDisplayableNumberExit:

    if (lpOutput1) GlobalFree(lpOutput1);
    if (m_hLineApp) lineShutdown(m_hLineApp);

    // Release ownership of the critical section
    LeaveCriticalSection (&m_csMyCriticalSection);

    return hr;
}

BOOL CRefDial::FShouldRetry(HRESULT hrErr)
{
    BOOL bRC;

    m_uiRetry++;

    if (hrErr == ERROR_LINE_BUSY ||
        hrErr == ERROR_VOICE_ANSWER ||
        hrErr == ERROR_NO_ANSWER ||
        hrErr == ERROR_NO_CARRIER ||
        hrErr == ERROR_AUTHENTICATION_FAILURE ||
        hrErr == ERROR_PPP_TIMEOUT ||
        hrErr == ERROR_REMOTE_DISCONNECTION ||
        hrErr == ERROR_AUTH_INTERNAL ||
        hrErr == ERROR_PROTOCOL_NOT_CONFIGURED ||
        hrErr == ERROR_PPP_NO_PROTOCOLS_CONFIGURED)
    {
        bRC = TRUE;
    } else {
        bRC = FALSE;
    }

    bRC = bRC && m_uiRetry < MAX_RETIES;

    return bRC;
}
DWORD CRefDial:: DialThreadInit(LPVOID pdata)
{


    WCHAR               szPassword[PWLEN+1];
    WCHAR               szUserName[UNLEN + 1];
    WCHAR               szDomain[DNLEN+1];
    LPRASDIALPARAMS     lpRasDialParams = NULL;
    LPRASDIALEXTENSIONS lpRasDialExtentions = NULL;
    HRESULT             hr = ERROR_SUCCESS;
    BOOL                bPW;
    DWORD               dwResult;
    // Initialize the dial error member
    m_dwRASErr = 0;
    if (!m_pcRNA)
    {
        hr = E_FAIL;
        goto DialExit;
    }

    // Get connectoid information
    //
    lpRasDialParams = (LPRASDIALPARAMS)GlobalAlloc(GPTR, sizeof(RASDIALPARAMS));
    if (!lpRasDialParams)
    {
        hr = ERROR_NOT_ENOUGH_MEMORY;
        goto DialExit;
    }
    lpRasDialParams->dwSize = sizeof(RASDIALPARAMS);
    lstrcpyn(lpRasDialParams->szEntryName, m_szConnectoid,MAX_CHARS_IN_BUFFER(lpRasDialParams->szEntryName));
    bPW = FALSE;
    hr = m_pcRNA->RasGetEntryDialParams(NULL, lpRasDialParams,&bPW);
    if (hr != ERROR_SUCCESS)
    {
        goto DialExit;
    }

    lpRasDialExtentions = (LPRASDIALEXTENSIONS)GlobalAlloc(GPTR, sizeof(RASDIALEXTENSIONS));
    if (lpRasDialExtentions)
    {
        lpRasDialExtentions->dwSize = sizeof(RASDIALEXTENSIONS);
        lpRasDialExtentions->dwfOptions = RDEOPT_UsePrefixSuffix;
    }


    //
    // Add the user's password
    //
    szPassword[0] = 0;
    szUserName[0] = 0;

    WCHAR   szOOBEInfoINIFile[MAX_PATH];
    SearchPath(NULL, cszOOBEINFOINI, NULL, MAX_CHARS_IN_BUFFER(szOOBEInfoINIFile), szOOBEInfoINIFile, NULL);


    GetPrivateProfileString(INFFILE_USER_SECTION,
                            INFFILE_PASSWORD,
                            NULLSZ,
                            szPassword,
                            PWLEN + 1,
                            *m_szCurrentDUNFile != 0 ? m_szCurrentDUNFile : m_szISPFile);

    if (m_lpGatherInfo->m_bUsePhbk)
    {
        if (GetPrivateProfileString(DUN_SECTION,
                                USERNAME,
                                NULLSZ,
                                szUserName,
                                UNLEN + 1,
                                szOOBEInfoINIFile))
        {
            if(szUserName[0])
                lstrcpy(lpRasDialParams->szUserName, szUserName);
        }

    }

    if(szPassword[0])
        lstrcpy(lpRasDialParams->szPassword, szPassword);

    GetPrivateProfileString(INFFILE_USER_SECTION,
                            INFFILE_DOMAIN,
                            NULLSZ,
                            szDomain,
                            DNLEN + 1,
                            *m_szCurrentDUNFile != 0 ? m_szCurrentDUNFile : m_szISPFile);
    szDomain[0]   = 0;
    if (szDomain[0])
        lstrcpy(lpRasDialParams->szDomain, szDomain);

    dwResult = m_pcRNA->RasDial(  lpRasDialExtentions,
                        NULL,
                        lpRasDialParams,
                        1,
                        CRefDial::RasDialFunc,
                        &m_hrasconn);

    if (( dwResult != ERROR_SUCCESS))
    {
        // We failed to connect for some reason, so hangup
        if (m_hrasconn)
        {
            if (m_pcRNA)
            {
                m_pcRNA->RasHangUp(m_hrasconn);
                m_hrasconn = NULL;
            }
        }
        goto DialExit;
    }

    if (m_bFromPhoneBook && (GetDisplayableNumber() == ERROR_SUCCESS))
    {
        if (m_pszOriginalDisplayable)
            GlobalFree(m_pszOriginalDisplayable);
        m_pszOriginalDisplayable = (LPWSTR)GlobalAlloc(GPTR, BYTES_REQUIRED_BY_SZ(m_pszDisplayable));
        lstrcpy(m_pszOriginalDisplayable, m_pszDisplayable);

        TRACE1(L"DialThreadInit: Dialing phone number %s", 
            m_pszOriginalDisplayable);

        m_bFromPhoneBook = FALSE;
    }

DialExit:
    if (lpRasDialParams)
        GlobalFree(lpRasDialParams);
    lpRasDialParams = NULL;

    if (lpRasDialExtentions)
        GlobalFree(lpRasDialExtentions);
    lpRasDialExtentions = NULL;

    PostMessage(gpCommMgr->m_hwndCallBack, WM_OBCOMM_DIAL_DONE, 0, 0);
    //m_dwRASErr = RasErrorToIDS(hr);
    m_dwRASErr = hr;
    return S_OK;
}

DWORD WINAPI DoDial(LPVOID lpv)
{
    if (gpCommMgr)
        gpCommMgr->m_pRefDial->DialThreadInit(NULL);

    return 1;
}

// This function will perform the actual dialing
HRESULT CRefDial::DoConnect(BOOL * pbRetVal)
{

    //Fix for redialing, on win9x we need to make sure we "hangup"
    //and free the rna resources in case we are redialing.
    //NT - is smart enough not to need it but it won't hurt.
    if (m_hrasconn)
    {
        if (m_pcRNA)
            m_pcRNA->RasHangUp(m_hrasconn);
        m_hrasconn = NULL;
    }

    if (CONNECTED_REFFERAL == m_dwCnType)
        FormReferralServerURL(pbRetVal);

#if defined(PRERELEASE)
    if (FCampusNetOverride())
    {
        m_bModemOverride = TRUE;
        if (gpCommMgr)
        {
            // Pretend we have the connection
            PostMessage(gpCommMgr->m_hwndCallBack, WM_OBCOMM_ONCONNECTED, (WPARAM)gpCommMgr->m_pRefDial->m_dwCnType , (LPARAM)0);

            // Pretend we have connection and downloaded
            //PostMessage(gpCommMgr->m_hwndCallBack, WM_OBCOMM_DOWNLOAD_DONE, (WPARAM)gpCommMgr->m_pRefDial->m_dwCnType, (LPARAM)0);
        }
    }
#endif

    if (!m_bModemOverride)
    {
        DWORD dwThreadID;
        if (m_hThread)
            CloseHandle(m_hThread);

        m_hDialThread = CreateThread(NULL,
                                 0,
                                 (LPTHREAD_START_ROUTINE)DoDial,
                                 (LPVOID)0,
                                 0,
                                 &dwThreadID);
    }

    m_bModemOverride = FALSE;

    *pbRetVal = (NULL != m_hThread);

    return S_OK;
}


//+---------------------------------------------------------------------------
//
//  Function:   MyRasGetEntryProperties()
//
//  Synopsis:   Performs some buffer size checks and then calls RasGetEntryProperties()
//                See the RasGetEntryProperties() docs to understand why this is needed.
//
//  Arguments:  Same as RasGetEntryProperties with the following exceptions:
//                lplpRasEntryBuff -- pointer to a pointer to a RASENTRY struct.  On successfull
//                                    return, *lplpRasEntryBuff will point to the RASENTRY struct
//                                    and buffer returned by RasGetEntryProperties.
//                                    NOTE: should not have memory allocated to it at call time!
//                                          To emphasize this point, *lplpRasEntryBuff must be NULL
//                lplpRasDevInfoBuff -- pointer to a pointer to a RASDEVINFO struct.  On successfull
//                                    return, *lplpRasDevInfoBuff will point to the RASDEVINFO struct
//                                    and buffer returned by RasGetEntryProperties.
//                                    NOTE: should not have memory allocated to it at call time!
//                                          To emphasize this point, *lplpRasDevInfoBuff must be NULL
//                                    NOTE: Even on a successfull call to RasGetEntryProperties,
//                                          *lplpRasDevInfoBuff may return with a value of NULL
//                                          (occurs when there is no extra device info)
//
//    Returns:    ERROR_NOT_ENOUGH_MEMORY if unable to allocate either RASENTRY or RASDEVINFO buffer
//                Otherwise, it retuns the error code from the call to RasGetEntryProperties.
//                NOTE: if return is anything other than ERROR_SUCCESS, *lplpRasDevInfoBuff and
//                      *lplpRasEntryBuff will be NULL,
//                      and *lpdwRasEntryBuffSize and *lpdwRasDevInfoBuffSize will be 0
//
//  Example:
//
//      LPRASENTRY    lpRasEntry = NULL;
//      LPRASDEVINFO  lpRasDevInfo = NULL;
//      DWORD            dwRasEntrySize, dwRasDevInfoSize;
//
//      hr = MyRasGetEntryProperties( NULL,
//                                      g_pcDialErr->m_szConnectoid,
//                                    &lpRasEntry,
//                                    &dwRasEntrySize,
//                                    &lpRasDevInfo,
//                                    &dwRasDevInfoSize);
//
//
//      if (hr != ERROR_SUCCESS)
//      {
//            //handle errors here
//      } else
//      {
//            //continue processing
//      }
//
//
//  History:    9/10/96     JMazner        Created for icwconn2
//                9/17/96        JMazner        Adapted for icwconn1
//              1/8/98      DONALDM     Moved to the new ICW/GetConn project
//----------------------------------------------------------------------------
HRESULT CRefDial::MyRasGetEntryProperties(LPWSTR lpszPhonebookFile,
                                LPWSTR lpszPhonebookEntry,
                                LPRASENTRY *lplpRasEntryBuff,
                                LPDWORD lpdwRasEntryBuffSize,
                                LPRASDEVINFO *lplpRasDevInfoBuff,
                                LPDWORD lpdwRasDevInfoBuffSize)
{

    HRESULT hr;
    DWORD dwOldDevInfoBuffSize;

    //Assert( NULL != lplpRasEntryBuff );
    //Assert( NULL != lpdwRasEntryBuffSize );
    //Assert( NULL != lplpRasDevInfoBuff );
    //Assert( NULL != lpdwRasDevInfoBuffSize );

    *lpdwRasEntryBuffSize = 0;
    *lpdwRasDevInfoBuffSize = 0;

    if (!m_pcRNA)
    {
        m_pcRNA = new RNAAPI;
        hr = ERROR_NOT_ENOUGH_MEMORY;
        goto MyRasGetEntryPropertiesErrExit;
    }

    // use RasGetEntryProperties with a NULL lpRasEntry pointer to find out size buffer we need
    // As per the docs' recommendation, do the same with a NULL lpRasDevInfo pointer.

    hr = m_pcRNA->RasGetEntryProperties(lpszPhonebookFile, lpszPhonebookEntry,
                                (LPBYTE) NULL,
                                lpdwRasEntryBuffSize,
                                (LPBYTE) NULL,
                                lpdwRasDevInfoBuffSize);

    // we expect the above call to fail because the buffer size is 0
    // If it doesn't fail, that means our RasEntry is messed, so we're in trouble
    if( ERROR_BUFFER_TOO_SMALL != hr )
    {
        goto MyRasGetEntryPropertiesErrExit;
    }

    // dwRasEntryBuffSize and dwRasDevInfoBuffSize now contain the size needed for their
    // respective buffers, so allocate the memory for them

    // dwRasEntryBuffSize should never be less than the size of the RASENTRY struct.
    // If it is, we'll run into problems sticking values into the struct's fields

    //Assert( *lpdwRasEntryBuffSize >= sizeof(RASENTRY) );

    if (m_reflpRasEntryBuff)
    {
        if (*lpdwRasEntryBuffSize > m_reflpRasEntryBuff->dwSize)
        {
            m_reflpRasEntryBuff = (LPRASENTRY)GlobalReAlloc(m_reflpRasEntryBuff, *lpdwRasEntryBuffSize, GPTR);
        }
    }
    else
    {
        m_reflpRasEntryBuff = (LPRASENTRY)GlobalAlloc(GPTR, *lpdwRasEntryBuffSize);
    }


    if (!m_reflpRasEntryBuff)
    {
        hr = ERROR_NOT_ENOUGH_MEMORY;
        goto MyRasGetEntryPropertiesErrExit;
    }

    // This is a bit convoluted:  lpRasEntrySize->dwSize needs to contain the size of _only_ the
    // RASENTRY structure, and _not_ the actual size of the buffer that lpRasEntrySize points to.
    // This is because the dwSize field is used by RAS for compatability purposes to determine which
    // version of the RASENTRY struct we're using.
    // Same holds for lpRasDevInfo->dwSize

    m_reflpRasEntryBuff->dwSize = sizeof(RASENTRY);

    //
    // Allocate the DeviceInfo size that RasGetEntryProperties told us we needed.
    // If size is 0, don't alloc anything
    //
    if( *lpdwRasDevInfoBuffSize > 0 )
    {
        //Assert( *lpdwRasDevInfoBuffSize >= sizeof(RASDEVINFO) );
        if (m_reflpRasDevInfoBuff)
        {
            // check if existing size is not sufficient
            if ( *lpdwRasDevInfoBuffSize > m_reflpRasDevInfoBuff->dwSize )
            {
                m_reflpRasDevInfoBuff = (LPRASDEVINFO)GlobalReAlloc(m_reflpRasDevInfoBuff, *lpdwRasDevInfoBuffSize, GPTR);
            }
        }
        else
        {
            m_reflpRasDevInfoBuff = (LPRASDEVINFO)GlobalAlloc(GPTR, *lpdwRasDevInfoBuffSize);
        }

        if (!m_reflpRasDevInfoBuff)
        {
            hr = ERROR_NOT_ENOUGH_MEMORY;
            goto MyRasGetEntryPropertiesErrExit;
        }
    }
    else
    {
        m_reflpRasDevInfoBuff = NULL;
    }

    if( m_reflpRasDevInfoBuff )
    {
        m_reflpRasDevInfoBuff->dwSize = sizeof(RASDEVINFO);
    }


    // now we're ready to make the actual call...

    // jmazner   see below for why this is needed
    dwOldDevInfoBuffSize = *lpdwRasDevInfoBuffSize;

    hr = m_pcRNA->RasGetEntryProperties(lpszPhonebookFile, lpszPhonebookEntry,
                                (LPBYTE) m_reflpRasEntryBuff,
                                lpdwRasEntryBuffSize,
                                (LPBYTE) m_reflpRasDevInfoBuff,
                                lpdwRasDevInfoBuffSize);

    // jmazner 10/7/96  Normandy #8763
    // For unknown reasons, in some cases on win95, devInfoBuffSize increases after the above call,
    // but the return code indicates success, not BUFFER_TOO_SMALL.  If this happens, set the
    // size back to what it was before the call, so the DevInfoBuffSize and the actuall space allocated
    // for the DevInfoBuff match on exit.
    if( (ERROR_SUCCESS == hr) && (dwOldDevInfoBuffSize != *lpdwRasDevInfoBuffSize) )
    {
        *lpdwRasDevInfoBuffSize = dwOldDevInfoBuffSize;
    }

    *lplpRasEntryBuff = m_reflpRasEntryBuff;
    *lplpRasDevInfoBuff = m_reflpRasDevInfoBuff;

    return( hr );

MyRasGetEntryPropertiesErrExit:

    if(m_reflpRasEntryBuff)
    {
        GlobalFree(m_reflpRasEntryBuff);
        m_reflpRasEntryBuff = NULL;
        *lplpRasEntryBuff = NULL;
    }
    if(m_reflpRasDevInfoBuff)
    {
        GlobalFree(m_reflpRasDevInfoBuff);
        m_reflpRasDevInfoBuff = NULL;
        *lplpRasDevInfoBuff = NULL;
    }
    *lpdwRasEntryBuffSize = 0;
    *lpdwRasDevInfoBuffSize = 0;

    return( hr );
}



HRESULT MyGetFileVersion(LPCWSTR pszFileName, LPGATHERINFO lpGatherInfo)
{
    HRESULT hr = ERROR_NOT_ENOUGH_MEMORY;
    DWORD   dwSize = 0;
    DWORD   dwTemp = 0;
    LPVOID  pv = NULL, pvVerInfo = NULL;
    UINT    uiSize;
    DWORD   dwVerPiece;
    //int idx;


    // verify parameters
    //
    //Assert(pszFileName && lpGatherInfo);

    // Get version
    //
    dwSize = GetFileVersionInfoSize((LPWSTR)pszFileName, &dwTemp);
    if (!dwSize)
    {
        hr = GetLastError();
        goto MyGetFileVersionExit;
    }
    pv = (LPVOID)GlobalAlloc(GPTR, (size_t)dwSize);
    if (!pv) goto MyGetFileVersionExit;
    if (!GetFileVersionInfo((LPWSTR)pszFileName, dwTemp,dwSize,pv))
    {
        hr = GetLastError();
        goto MyGetFileVersionExit;
    }

    if (!VerQueryValue(pv, L"\\\0",&pvVerInfo,&uiSize))
    {
        hr = GetLastError();
        goto MyGetFileVersionExit;
    }
    pvVerInfo = (LPVOID)((DWORD_PTR)pvVerInfo + sizeof(DWORD)*4);
    lpGatherInfo->m_szSUVersion[0] = L'\0';
    dwVerPiece = (*((LPDWORD)pvVerInfo)) >> 16;
    wsprintf(lpGatherInfo->m_szSUVersion, L"%d.",dwVerPiece);

    dwVerPiece = (*((LPDWORD)pvVerInfo)) & 0x0000ffff;
    wsprintf(lpGatherInfo->m_szSUVersion, L"%s%d.",lpGatherInfo->m_szSUVersion,dwVerPiece);

    dwVerPiece = (((LPDWORD)pvVerInfo)[1]) >> 16;
    wsprintf(lpGatherInfo->m_szSUVersion, L"%s%d.",lpGatherInfo->m_szSUVersion,dwVerPiece);

    dwVerPiece = (((LPDWORD)pvVerInfo)[1]) & 0x0000ffff;
    wsprintf(lpGatherInfo->m_szSUVersion, L"%s%d",lpGatherInfo->m_szSUVersion,dwVerPiece);

    if (!VerQueryValue(pv, L"\\VarFileInfo\\Translation",&pvVerInfo,&uiSize))
    {
        hr = GetLastError();
        goto MyGetFileVersionExit;
    }

    // separate version information from character set
    lpGatherInfo->m_lcidApps = (LCID)(LOWORD(*(DWORD*)pvVerInfo));

    hr = ERROR_SUCCESS;

MyGetFileVersionExit:
    if (pv) GlobalFree(pv);

    return hr;
}

DWORD CRefDial::FillGatherInfoStruct(LPGATHERINFO lpGatherInfo)
{
    HKEY        hkey = NULL;
    SYSTEM_INFO si;
    WCHAR        szTempPath[MAX_PATH];
    DWORD       dwRet = ERROR_SUCCESS;

    lpGatherInfo->m_lcidUser  = GetUserDefaultLCID();
    lpGatherInfo->m_lcidSys   = GetSystemDefaultLCID();

    OSVERSIONINFO osvi;
    ZeroMemory(&osvi, sizeof(OSVERSIONINFO));
    osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);

     if (!GetVersionEx(&osvi))
    {
        // Nevermind, we'll just assume the version is 0.0 if we can't read it
        //
        ZeroMemory(&osvi, sizeof(OSVERSIONINFO));
    }

    lpGatherInfo->m_dwOS = osvi.dwPlatformId;
    lpGatherInfo->m_dwMajorVersion = osvi.dwMajorVersion;
    lpGatherInfo->m_dwMinorVersion = osvi.dwMinorVersion;

    ZeroMemory(&si, sizeof(SYSTEM_INFO));
    GetSystemInfo(&si);

    lpGatherInfo->m_wArchitecture = si.wProcessorArchitecture;

    // Sign-up version
    //
    lpGatherInfo->m_szSUVersion[0] = L'\0';
    if( GetModuleFileName(0/*_Module.GetModuleInstance()*/, szTempPath, MAX_PATH))
    {
        if ((MyGetFileVersion(szTempPath, lpGatherInfo)) != ERROR_SUCCESS)
        {
            return (GetLastError());
        }
    }
    else
        return( GetLastError() );


    // 2/20/97    jmazner    Olympus #259
    if ( RegOpenKey(HKEY_LOCAL_MACHINE, ICWSETTINGSPATH,&hkey) == ERROR_SUCCESS)
    {
        DWORD dwSize;
        DWORD dwType;
        dwType = REG_SZ;
        dwSize = BYTES_REQUIRED_BY_CCH(MAX_RELPROD + 1);
        if (RegQueryValueEx(hkey, RELEASEPRODUCTKEY,NULL,&dwType,(LPBYTE)&lpGatherInfo->m_szRelProd[0],&dwSize) != ERROR_SUCCESS)
            lpGatherInfo->m_szRelProd[0] = L'\0';

        dwSize = BYTES_REQUIRED_BY_CCH(MAX_RELVER + 1);
        if (RegQueryValueEx(hkey, RELEASEVERSIONKEY,NULL,&dwType,(LPBYTE)&lpGatherInfo->m_szRelVer[0],&dwSize) != ERROR_SUCCESS)
            lpGatherInfo->m_szRelVer[0] = L'\0';


        RegCloseKey(hkey);
    }

    // PromoCode
    lpGatherInfo->m_szPromo[0] = L'\0';

    WCHAR    szPIDPath[MAX_PATH];        // Reg path to the PID

    // Form the Path, it is HKLM\\Software\\Microsoft\Windows[ NT]\\CurrentVersion
    lstrcpy(szPIDPath, L"");


    // Form the Path, it is HKLM\\Software\\Microsoft\Windows[ NT]\\CurrentVersion
    lstrcpy(szPIDPath, L"Software\\Microsoft\\Windows");
    lstrcat(szPIDPath, L"\\CurrentVersion");

    BYTE    byDigitalPID[MAX_DIGITAL_PID];

    // Get the Product ID for this machine
    if ( RegOpenKey(HKEY_LOCAL_MACHINE, szPIDPath,&hkey) == ERROR_SUCCESS)
    {
        DWORD dwSize;
        DWORD dwType;
        dwType = REG_BINARY;
        dwSize = sizeof(byDigitalPID);
        if (RegQueryValueEx(hkey,
                            c_szRegStrValDigitalPID,
                            NULL,
                            &dwType,
                            (LPBYTE)byDigitalPID,
                            &dwSize) == ERROR_SUCCESS)
        {
            // BINHEX the digital PID data so we can send it to the ref_server
            int     i = 0;
            BYTE    by;
            for (DWORD dwX = 0; dwX < dwSize; dwX++)
            {
                by = byDigitalPID[dwX];
                m_szPID[i++] = g_BINTOHEXLookup[((by & 0xF0) >> 4)];
                m_szPID[i++] = g_BINTOHEXLookup[(by & 0x0F)];
            }
            m_szPID[i] = L'\0';
        }
        else
        {
            m_szPID[0] = L'\0';
        }
        RegCloseKey(hkey);
    }
    return( dwRet );
}

// ############################################################################
HRESULT CRefDial::CreateEntryFromDUNFile(LPWSTR pszDunFile)
{
    WCHAR    szFileName[MAX_PATH];
    WCHAR    szUserName[UNLEN+1];
    WCHAR    szPassword[PWLEN+1];
    LPWSTR   pszTemp;
    HRESULT hr;
    BOOL    fNeedsRestart=FALSE;


    hr = ERROR_SUCCESS;

    // Get fully qualified path name
    //

    if (!SearchPath(NULL, pszDunFile,NULL,MAX_PATH,&szFileName[0],&pszTemp))
    {
        hr = ERROR_FILE_NOT_FOUND;
        goto CreateEntryFromDUNFileExit;
    }

    // save current DUN file name in global
    lstrcpy(m_szCurrentDUNFile, &szFileName[0]);

    hr = m_ISPImport.ImportConnection (&szFileName[0], m_szISPSupportNumber, m_szEntryName, szUserName, szPassword, &fNeedsRestart);

    // place the name of the connectoid in the registry
    //
    if (ERROR_SUCCESS != (StoreInSignUpReg((LPBYTE)m_szEntryName,
                BYTES_REQUIRED_BY_SZ(m_szEntryName),
                REG_SZ, RASENTRYVALUENAME)))
    {
        goto CreateEntryFromDUNFileExit;
    }
    lstrcpy(m_szLastDUNFile, pszDunFile);

CreateEntryFromDUNFileExit:
    return hr;
}



HRESULT CRefDial::SetupForRASDialing
(
    LPGATHERINFO lpGatherInfo,
    HINSTANCE hPHBKDll,
    LPDWORD lpdwPhoneBook,
    PSUGGESTINFO pSuggestInfo,
    WCHAR *pszConnectoid,
    BOOL FAR *bConnectiodCreated
)
{

    WCHAR           szEntry[MAX_RASENTRYNAME];
    DWORD           dwSize              = BYTES_REQUIRED_BY_CCH(MAX_RASENTRYNAME);
    RASENTRY        *prasentry          = NULL;
    RASDEVINFO      *prasdevinfo        = NULL;
    DWORD           dwRasentrySize      = 0;
    DWORD           dwRasdevinfoSize    = 0;
    HINSTANCE       hRasDll             = NULL;
    LPRASCONN       lprasconn           = NULL;
    HRESULT         hr                  = ERROR_NOT_ENOUGH_MEMORY;
    m_bUserInitiateHangup = FALSE;

    // Load the connectoid
    //
    if (!m_pcRNA)
        m_pcRNA = new RNAAPI;
    if (!m_pcRNA)
        goto SetupForRASDialingExit;

    prasentry = (RASENTRY*)GlobalAlloc(GPTR, sizeof(RASENTRY)+2);
    //Assert(prasentry);
    if (!prasentry)
    {
        hr = GetLastError();
        goto SetupForRASDialingExit;
    }
    prasentry->dwSize = sizeof(RASENTRY);
    dwRasentrySize = sizeof(RASENTRY);


    prasdevinfo = (RASDEVINFO*)GlobalAlloc(GPTR, sizeof(RASDEVINFO));

    if (!prasdevinfo)
    {
        hr = GetLastError();
        goto SetupForRASDialingExit;
    }
    prasdevinfo->dwSize = sizeof(RASDEVINFO);
    dwRasdevinfoSize = sizeof(RASDEVINFO);


    hr = ReadSignUpReg((LPBYTE)&szEntry[0], &dwSize, REG_SZ,
                        RASENTRYVALUENAME);
    if (hr != ERROR_SUCCESS)
        goto SetupForRASDialingExit;

    hr = m_pcRNA->RasGetEntryProperties(NULL, szEntry,
                                            (LPBYTE)prasentry,
                                            &dwRasentrySize,
                                            (LPBYTE)prasdevinfo,
                                            &dwRasdevinfoSize);
    if (hr == ERROR_BUFFER_TOO_SMALL)
    {
        GlobalFree(prasentry);
        prasentry = (RASENTRY*)GlobalAlloc(GPTR, ((size_t)dwRasentrySize));
        prasentry->dwSize = dwRasentrySize;

        GlobalFree(prasdevinfo);
        prasdevinfo = (RASDEVINFO*)GlobalAlloc(GPTR, ((size_t)dwRasdevinfoSize));
        prasdevinfo->dwSize = dwRasdevinfoSize;
        hr = m_pcRNA->RasGetEntryProperties(NULL, szEntry,
                                                (LPBYTE)prasentry,
                                                &dwRasentrySize,
                                                (LPBYTE)prasdevinfo,
                                                &dwRasdevinfoSize);
    }
    if (hr != ERROR_SUCCESS)
        goto SetupForRASDialingExit;

    //
    // Check to see if the phone number was filled in
    //
    if (lstrcmp(&prasentry->szLocalPhoneNumber[0], DUN_NOPHONENUMBER) == 0)
    {
        //
        // If phonenumber is not filled in by the ISP file,
        // get phone number from oobe phone book
        //
        m_bFromPhoneBook = TRUE;
        hr = ReadPhoneBook(lpGatherInfo, pSuggestInfo);
    }
    else
    {
        ZeroMemory(pszConnectoid, dwSize);
        hr = ReadSignUpReg((LPBYTE)pszConnectoid, &dwSize, REG_SZ,
                           RASENTRYVALUENAME);
        if (hr != ERROR_SUCCESS)
            goto SetupForRASDialingExit;

        // Use the RASENTRY that we have to create the connectiod
        hr = m_pcRNA->RasSetEntryProperties(NULL,
                                            pszConnectoid,
                                            (LPBYTE)prasentry,
                                            dwRasentrySize,
                                            (LPBYTE)prasdevinfo,
                                            dwRasdevinfoSize);
        *bConnectiodCreated = TRUE;
    }

SetupForRASDialingExit:
    if (prasentry)
        GlobalFree(prasentry);
    if (prasdevinfo)
        GlobalFree(prasdevinfo);

    return hr;
}



// 10/22/96    jmazner    Normandy #9923
// Since in SetupConnectoidExit we're treating results other than ERROR_SUCCESS as
// indicating successfull completion, we need bSuccess to provide a simple way for the
// caller to tell whether the function completed.
HRESULT CRefDial::SetupConnectoid
(
    PSUGGESTINFO    pSuggestInfo,
    int             irc,
    WCHAR            *pszConnectoid,
    DWORD           dwSize,
    BOOL            *pbSuccess
)
{

    HRESULT     hr = ERROR_NOT_ENOUGH_MEMORY;
    RASENTRY    *prasentry = NULL;
    RASDEVINFO  *prasdevinfo = NULL;
    DWORD       dwRasentrySize = 0;
    DWORD       dwRasdevinfoSize = 0;
    HINSTANCE   hPHBKDll = NULL;
    HINSTANCE   hRasDll =NULL;

    LPWSTR       lpszSetupFile;
    LPRASCONN   lprasconn = NULL;

    //Assert(pbSuccess);

    if (!pSuggestInfo)
    {
        hr = ERROR_PHBK_NOT_FOUND;
        goto SetupConnectoidExit;
    }

    lpszSetupFile = *m_szCurrentDUNFile != 0 ? m_szCurrentDUNFile : m_szISPFile;

    WCHAR    szFileName[MAX_PATH];
    LPWSTR   pszTemp;

    SearchPath(NULL, pSuggestInfo->AccessEntry.szDataCenter,NULL,MAX_PATH,&szFileName[0],&pszTemp);

    if(0 != lstrcmpi(m_szCurrentDUNFile, szFileName))
    {
        hr = CreateEntryFromDUNFile(pSuggestInfo->AccessEntry.szDataCenter);
        if (hr == ERROR_SUCCESS)
        {
            ZeroMemory(pszConnectoid, dwSize);
            hr = ReadSignUpReg((LPBYTE)pszConnectoid, &dwSize, REG_SZ,
                               RASENTRYVALUENAME);
            if (hr != ERROR_SUCCESS)
                goto SetupConnectoidExit;

            if( prasentry )
            {
                GlobalFree( prasentry );
                prasentry = NULL;
                dwRasentrySize = NULL;
            }

            if( prasdevinfo )
            {
                GlobalFree( prasdevinfo );
                prasdevinfo = NULL;
                dwRasdevinfoSize = NULL;
            }
        }
        else
        {
            // 10/22/96    jmazner    Normandy #9923
            goto SetupConnectoidExit;
        }
    }

    hr = MyRasGetEntryProperties(NULL,
                                pszConnectoid,
                                &prasentry,
                                &dwRasentrySize,
                                &prasdevinfo,
                                &dwRasdevinfoSize);
    if (hr != ERROR_SUCCESS || NULL == prasentry)
        goto SetupConnectoidExit;
    /*
    else
    {
        goto SetupConnectoidExit;
    }*/

    prasentry->dwCountryID = pSuggestInfo->AccessEntry.dwCountryID;

    lstrcpyn(prasentry->szAreaCode,
                pSuggestInfo->AccessEntry.szAreaCode,
                MAX_CHARS_IN_BUFFER(prasentry->szAreaCode));
    lstrcpyn(prasentry->szLocalPhoneNumber,
                pSuggestInfo->AccessEntry.szAccessNumber,
                MAX_CHARS_IN_BUFFER(prasentry->szLocalPhoneNumber));

    prasentry->dwCountryCode = 0;
    prasentry->dwfOptions |= RASEO_UseCountryAndAreaCodes;

    // 10/19/96 jmazner Multiple modems problems
    // If no device name and type has been specified, grab the one we've stored
    // in ConfigRasEntryDevice

    if( 0 == lstrlen(prasentry->szDeviceName) )
    {
        // doesn't make sense to have an empty device name but a valid device type
        //Assert( 0 == lstrlen(prasentry->szDeviceType) );

        // double check that we've already stored the user's choice.
        //Assert( lstrlen(m_ISPImport.m_szDeviceName) );
        //Assert( lstrlen(m_ISPImport.m_szDeviceType) );

        lstrcpyn( prasentry->szDeviceName, m_ISPImport.m_szDeviceName, lstrlen(m_ISPImport.m_szDeviceName) );
        lstrcpyn( prasentry->szDeviceType, m_ISPImport.m_szDeviceType, lstrlen(m_ISPImport.m_szDeviceType) );
    }

    // Write out new connectoid
    if (m_pcRNA)
        hr = m_pcRNA->RasSetEntryProperties(NULL, pszConnectoid,
                                                (LPBYTE)prasentry,
                                                dwRasentrySize,
                                                (LPBYTE)prasdevinfo,
                                                dwRasdevinfoSize);


    // Set this connetiod to have not proxy enabled
    /*
    WCHAR        szConnectionProfile[REGSTR_MAX_VALUE_LENGTH];

    lstrcpy(szConnectionProfile, c_szRASProfiles);
    lstrcat(szConnectionProfile, L"\\");
    lstrcat(szConnectionProfile,  pszConnectoid);

    reg.CreateKey(HKEY_CURRENT_USER, szConnectionProfile);
    reg.SetValue(c_szProxyEnable, (DWORD)0);*/


SetupConnectoidExit:

    *pbSuccess = FALSE;

    if (hr == ERROR_SUCCESS)
        *pbSuccess = TRUE;
    return hr;
}

void CRefDial::GetISPFileSettings(LPWSTR lpszFile)
{

    WCHAR szTemp[INTERNET_MAX_URL_LENGTH];

    /*GetINTFromISPFile(lpszFile,
                      (LPWSTR)cszBrandingSection,
                      (LPWSTR)cszBrandingFlags,
                      (int FAR *)&m_lBrandingFlags,
                      BRAND_DEFAULT);*/

    // Read the Support Number
    if (ERROR_SUCCESS == GetDataFromISPFile(lpszFile,
                                     (LPWSTR)cszSupportSection,
                                     (LPWSTR)cszSupportNumber,
                                     szTemp,
                                     MAX_CHARS_IN_BUFFER(szTemp)))
    {
        m_bstrSupportNumber= SysAllocString(szTemp);
    }
    else
        m_bstrSupportNumber = NULL;


    if (ERROR_SUCCESS == GetDataFromISPFile(lpszFile,
                                     (LPWSTR)cszLoggingSection,
                                     (LPWSTR)cszStartURL,
                                     szTemp,
                                     MAX_CHARS_IN_BUFFER(szTemp)))
    {
        m_bstrLoggingStartUrl = SysAllocString(szTemp);
    }
    else
        m_bstrLoggingStartUrl = NULL;


    if (ERROR_SUCCESS == GetDataFromISPFile(lpszFile,
                                     (LPWSTR)cszLoggingSection,
                                     (LPWSTR)cszEndURL,
                                     szTemp,
                                     MAX_CHARS_IN_BUFFER(szTemp)))
    {
        m_bstrLoggingEndUrl = SysAllocString(szTemp);
    }
    else
        m_bstrLoggingEndUrl = NULL;


}


// This function will accept user selected values that are necessary to
// setup a connectiod for dialing
// Returns:
//      TRUE        OK to dial
//      FALSE       Some kind of problem
//                  QuitWizard - TRUE, then terminate
//                  UserPickNumber - TRUE, then display Pick a Number DLG
//                  QuitWizard and UserPickNumber both FALSE, then just
//                  display the page prior to Dialing UI.
HRESULT CRefDial::SetupForDialing
(
    UINT nType,
    BSTR bstrISPFile,
    DWORD dwCountry,
    BSTR bstrAreaCode,
    DWORD dwFlag,
    DWORD dwAppMode,
    DWORD dwMigISPIdx,
    LPCWSTR szRasDeviceName
)
{
    HRESULT             hr = S_OK;
    long                lRC = 0;
    HINSTANCE           hPHBKDll = NULL;
    DWORD               dwPhoneBook = 0;
    BOOL                bSuccess = FALSE;
    BOOL                bConnectiodCreated = FALSE;
    LPWSTR   pszTemp;
    WCHAR    szISPPath[MAX_PATH];
    WCHAR    szShortISPPath[MAX_PATH];

    CleanupAutodial();

    m_dwCnType = nType;
    if (!bstrAreaCode)
        goto SetupForDialingExit;

    if (CONNECTED_ISP_MIGRATE == m_dwCnType)  // ACCOUNT MIGRATION
    {
        if (!m_pCSVList)
            ParseISPInfo(NULL, ICW_ISPINFOPath, TRUE);
        if (m_pCSVList && (dwMigISPIdx < m_dwNumOfAutoConfigOffers))
        {
            ISPLIST*        pCurr = m_pCSVList;
            for( UINT i = 0; i < dwMigISPIdx && pCurr->pNext != NULL; i++)
                pCurr = pCurr->pNext;

            if (NULL != (m_pSelectedISPInfo = (CISPCSV *) pCurr->pElement))
            {
                lstrcpy(szShortISPPath, m_pSelectedISPInfo->get_szISPFilePath());
            }
        }
    }
    else // ISP FILE SIGNUP
    {
        if (!bstrISPFile)
            goto SetupForDialingExit;
        lstrcpyn(szShortISPPath, bstrISPFile, MAX_PATH);

    }

    // Locate ISP file
    if (!SearchPath(NULL, szShortISPPath,INF_SUFFIX,MAX_PATH,szISPPath,&pszTemp))
    {
        hr = ERROR_FILE_NOT_FOUND;
        goto SetupForDialingExit;
    }


    if(0 == lstrcmpi(m_szISPFile, szISPPath) &&
       0 == lstrcmpi(m_lpGatherInfo->m_szAreaCode, bstrAreaCode) &&
       m_lpGatherInfo->m_dwCountryID == dwCountry)
    {
        if (m_bDialCustom)
        {
            m_bDialCustom = FALSE;
            return S_OK;
        }
        // If ISP file is the same, no need to recreate connectoid
        // Modify the connectiod here

        // If we used the phonebook for this connectoid, we need to
        // continue and import the dun files. Otherwise, we are done
        if (!m_lpGatherInfo->m_bUsePhbk)
        {
            return S_OK;
        }
        if (m_bDialAlternative)
        {
            m_SuggestInfo.dwPick++;
        }
    }
    else
    {
        BOOL bRet;
        RemoveConnectoid(&bRet);
        m_SuggestInfo.dwPick = 0;
        m_bDialCustom = FALSE;
    }

    if (CONNECTED_REFFERAL == m_dwCnType)
    {
        // Check whether the isp file is ICW capable by reading the referral URL
        GetPrivateProfileString(INF_SECTION_ISPINFO,
                            c_szURLReferral,
                            L"",
                            m_szRefServerURL,
                            INTERNET_MAX_URL_LENGTH,
                            szISPPath);
    }


    lstrcpy(m_szISPFile, szISPPath);

    m_dwAppMode = dwAppMode;

    // Initialize failure codes
    m_bQuitWizard = FALSE;
    m_bUserPickNumber = FALSE;
    m_lpGatherInfo->m_bUsePhbk = FALSE;


    // Stuff the Area Code, and Country Code into the GatherInfo struct

    m_lpGatherInfo->m_dwCountryID = dwCountry;
    m_lpGatherInfo->m_dwCountryCode = dwFlag;

    lstrcpyn(
        m_lpGatherInfo->m_szAreaCode,
        bstrAreaCode,
        MAX_CHARS_IN_BUFFER(m_lpGatherInfo->m_szAreaCode)
        );


    m_SuggestInfo.AccessEntry.dwCountryID = dwCountry;
    m_SuggestInfo.AccessEntry.dwCountryCode = dwFlag;
    lstrcpy(m_SuggestInfo.AccessEntry.szAreaCode, bstrAreaCode);

    GetISPFileSettings(szISPPath);

    lstrcpyn(
        m_ISPImport.m_szDeviceName,
        szRasDeviceName,
        MAX_CHARS_IN_BUFFER(m_ISPImport.m_szDeviceName)
        );
    
    // Read the Connection File information which will create
    // a connectiod from the passed in ISP file
    hr = ReadConnectionInformation();

    //  If we failed for some reason above, we need to return
    //  the error to the caller, and Quit The Wizard.
    if (S_OK != hr)
        goto SetupForDialingExit;
    FillGatherInfoStruct(m_lpGatherInfo);

    // Setup, and possible create a connectiod
    hr = SetupForRASDialing(m_lpGatherInfo,
                         hPHBKDll,
                         &dwPhoneBook,
                         &m_SuggestInfo,
                         &m_szConnectoid[0],
                         &bConnectiodCreated);
    if (ERROR_SUCCESS != hr)
    {
        m_bQuitWizard = TRUE;
        goto SetupForDialingExit;
    }

    // If we have a RASENTRY struct from SetupForRASDialing, then just use it
    // otherwise use the suggest info
    if (!bConnectiodCreated)
    {

        // If there is only 1 suggested number, then we setup the
        // connectiod, and we are ready to dial
        if (1 == m_SuggestInfo.wNumber)
        {
            hr = SetupConnectoid(&m_SuggestInfo, 0, &m_szConnectoid[0],
                                sizeof(m_szConnectoid), &bSuccess);
            if( !bSuccess )
            {
                goto SetupForDialingExit;
            }
        }
        else
        {
            // More than 1 entry in the Phonebook, so we need to
            // ask the user which one they want to use
            hr = ERROR_FILE_NOT_FOUND;
            goto SetupForDialingExit;
        }
    }

    // Success if we get to here


SetupForDialingExit:

    if (ERROR_SUCCESS != hr)
        *m_szISPFile = 0;
    return hr;
}

HRESULT CRefDial::CheckPhoneBook
(
    BSTR bstrISPFile,
    DWORD dwCountry,
    BSTR bstrAreaCode,
    DWORD dwFlag,
    BOOL *pbRetVal
)
{
    HRESULT             hr = S_OK;
    long                lRC = 0;
    HINSTANCE           hPHBKDll = NULL;
    DWORD               dwPhoneBook = 0;
    BOOL                bSuccess = FALSE;
    BOOL                bConnectiodCreated = FALSE;
    LPWSTR              pszTemp;
    WCHAR               szISPPath[MAX_PATH];

    *pbRetVal = FALSE;
    if (!bstrISPFile || !bstrAreaCode)
    {
        hr = ERROR_FILE_NOT_FOUND;
        goto CheckPhoneBookExit;
    }

    // Locate ISP file
    if (!SearchPath(NULL, bstrISPFile,INF_SUFFIX,MAX_PATH,szISPPath,&pszTemp))
    {
        hr = ERROR_FILE_NOT_FOUND;
        goto CheckPhoneBookExit;
    }

    //lstrcpy(m_szISPFile, szISPPath);

    // Stuff the Area Code, and Country Code into the GatherInfo struct

    m_lpGatherInfo->m_dwCountryID = dwCountry;
    m_lpGatherInfo->m_dwCountryCode = dwFlag;

    lstrcpy(m_lpGatherInfo->m_szAreaCode, bstrAreaCode);


    m_SuggestInfo.AccessEntry.dwCountryID = dwCountry;
    m_SuggestInfo.AccessEntry.dwCountryCode = dwFlag;
    lstrcpy(m_SuggestInfo.AccessEntry.szAreaCode, bstrAreaCode);

    //
    // If phonenumber is not filled in by the ISP file,
    // get phone number from oobe phone book
    //
    hr = ReadPhoneBook(m_lpGatherInfo, &m_SuggestInfo);

    if (ERROR_CANNOT_FIND_PHONEBOOK_ENTRY != hr)
        *pbRetVal = TRUE;


CheckPhoneBookExit:
    return hr;
}


// This function will determine if we can connect to the next server in
// the same phone call
// Returns:
//      S_OK        OK to stay connected
//      E_FAIL      Need to redial
HRESULT CRefDial::CheckStayConnected(BSTR bstrISPFile, BOOL *pbVal)
{
    BOOL                bSuccess    = FALSE;
    LPWSTR   pszTemp;
    WCHAR    szISPPath[MAX_PATH];

    *pbVal = FALSE;
    // Locate ISP file
    if (SearchPath(NULL, bstrISPFile,INF_SUFFIX,MAX_PATH,szISPPath,&pszTemp))
    {
        if (GetPrivateProfileInt(INF_SECTION_CONNECTION,
                                            c_szStayConnected,
                                            0,
                                            szISPPath))
        {
            *pbVal = TRUE;
        }
    }
    return S_OK;
}
HRESULT CRefDial::RemoveConnectoid(BOOL * pVal)
{
    if (m_hrasconn)
        DoHangup();

    if( (m_pcRNA!=NULL) && (m_szConnectoid[0]!=L'\0') )
    {
       m_pcRNA->RasDeleteEntry(NULL, m_szConnectoid);
    }
    return S_OK;
}

HRESULT CRefDial::GetDialPhoneNumber(BSTR * pVal)
{
    if (pVal == NULL)
        return E_POINTER;

    // Generate a Displayable number
    if (GetDisplayableNumber() == ERROR_SUCCESS)
        *pVal = SysAllocString(m_pszDisplayable);
    else
        *pVal = SysAllocString(m_szPhoneNumber);

    return S_OK;
}

HRESULT CRefDial::GetPhoneBookNumber(BSTR * pVal)
{
    if (pVal == NULL)
        return E_POINTER;

    // Generate a Displayable number
    if (m_pszOriginalDisplayable)
        *pVal = SysAllocString(m_pszOriginalDisplayable);
    else if (GetDisplayableNumber() == ERROR_SUCCESS)
        *pVal = SysAllocString(m_pszDisplayable);
    else
        *pVal = SysAllocString(m_szPhoneNumber);

    return S_OK;
}

HRESULT CRefDial::PutDialPhoneNumber(BSTR bstrNewVal)
{


    LPRASENTRY              lpRasEntry = NULL;
    LPRASDEVINFO            lpRasDevInfo = NULL;
    DWORD                   dwRasEntrySize = 0;
    DWORD                   dwRasDevInfoSize = 0;
    RNAAPI                  *pcRNA = NULL;
    HRESULT                 hr;

    // Get the current RAS entry properties
    hr = MyRasGetEntryProperties(NULL,
                                m_szConnectoid,
                                &lpRasEntry,
                                &dwRasEntrySize,
                                &lpRasDevInfo,
                                &dwRasDevInfoSize);

    if (NULL ==lpRasDevInfo)
    {
        dwRasDevInfoSize = 0;
    }

    if (hr == ERROR_SUCCESS && NULL != lpRasEntry)
    {
        // Replace the phone number with the new one
        //
        lstrcpy(lpRasEntry->szLocalPhoneNumber, bstrNewVal);

        // non-zero dummy values are required due to bugs in win95
        lpRasEntry->dwCountryID = 1;
        lpRasEntry->dwCountryCode = 1;
        lpRasEntry->szAreaCode[1] = L'\0';
        lpRasEntry->szAreaCode[0] = L'8';

        // Set to dial as is
        //
        lpRasEntry->dwfOptions &= ~RASEO_UseCountryAndAreaCodes;

        pcRNA = new RNAAPI;
        if (pcRNA)
        {
            TRACE6(L"CRefDial::put_DialPhoneNumber - MyRasGetEntryProperties()"
                  L"lpRasEntry->dwfOptions: %ld"
                  L"lpRasEntry->dwCountryID: %ld"
                  L"lpRasEntry->dwCountryCode: %ld"
                  L"lpRasEntry->szAreaCode: %s"
                  L"lpRasEntry->szLocalPhoneNumber: %s"
                  L"lpRasEntry->dwAlternateOffset: %ld",
                  lpRasEntry->dwfOptions,
                  lpRasEntry->dwCountryID,
                  lpRasEntry->dwCountryCode,
                  lpRasEntry->szAreaCode,
                  lpRasEntry->szLocalPhoneNumber,
                  lpRasEntry->dwAlternateOffset
                );

            pcRNA->RasSetEntryProperties(NULL,
                                         m_szConnectoid,
                                         (LPBYTE)lpRasEntry,
                                         dwRasEntrySize,
                                         (LPBYTE)lpRasDevInfo,
                                         dwRasDevInfoSize);

            delete pcRNA;
            m_bDialCustom = TRUE;
        }
    }

    // Regenerate the displayable number
    //GetDisplayableNumber();

    return S_OK;
}

//+---------------------------------------------------------------------------
//
//  Function:   SetDialAlternative
//
//  Synopsis:   Set whether or not to look for another number in phonebook
//              when dialing next time
//
//+---------------------------------------------------------------------------
HRESULT CRefDial::SetDialAlternative(BOOL bVal)
{
    m_bDialAlternative = bVal;

    return S_OK;
}

//+---------------------------------------------------------------------------
//
//  Function:   DoHangup
//
//  Synopsis:   Hangup the modem for the currently active RAS session
//
//+---------------------------------------------------------------------------
HRESULT CRefDial::DoHangup()
{
    // Set the disconnect flag as the system may be too busy with dialing.
    // Once we get a chance to terminate dialing, we know we have to hangu
    EnterCriticalSection (&m_csMyCriticalSection);

    // Your code to access the shared resource goes here.
    TerminateConnMonitorThread();

    if (NULL != m_hrasconn)
    {
        RNAAPI* pRNA = new RNAAPI();
        if (pRNA)
        {
            pRNA->RasHangUp(m_hrasconn);
            m_hrasconn = NULL;
            delete pRNA;
        }
    }
    // Release ownership of the critical section
    LeaveCriticalSection (&m_csMyCriticalSection);

    return (m_hrasconn == NULL) ? S_OK : E_POINTER;
}


BOOL CRefDial::get_QueryString(WCHAR* szTemp, DWORD cchMax)
{
    WCHAR   szOOBEInfoINIFile[MAX_PATH];
    WCHAR   szISPSignup[MAX_PATH];
    WCHAR   szOEMName[MAX_PATH];
    WCHAR   szQueryString[MAX_SECTIONS_BUFFER*2];
    WCHAR   szBroadbandDeviceName[MAX_STRING];
    WCHAR   szBroadbandDevicePnpid[MAX_STRING];

    OSVERSIONINFO osvi;
    ZeroMemory(&osvi, sizeof(OSVERSIONINFO));
    osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);

    if (!GetVersionEx(&osvi))
        ZeroMemory(&osvi, sizeof(OSVERSIONINFO));

    if (VER_PLATFORM_WIN32_WINDOWS == osvi.dwPlatformId)
        m_lpGatherInfo->m_dwOS = 1;
    else if (VER_PLATFORM_WIN32_NT == osvi.dwPlatformId)
        m_lpGatherInfo->m_dwOS = 2;
    else
        m_lpGatherInfo->m_dwOS = 0;

    SearchPath(NULL, cszOOBEINFOINI, NULL, MAX_CHARS_IN_BUFFER(szOOBEInfoINIFile), szOOBEInfoINIFile, NULL);

    DWORD dwOfferCode = 0;
    if(m_dwAppMode == APMD_MSN)
    {
        lstrcpy(szISPSignup, L"MSN");
    }
    else
    {
        GetPrivateProfileString(cszSignup,
                                cszISPSignup,
                                L"",
                                szISPSignup,
                                MAX_CHARS_IN_BUFFER(szISPSignup),
                                szOOBEInfoINIFile);
         dwOfferCode = GetPrivateProfileInt(cszSignup,
                                            cszOfferCode,
                                            0,
                                            szOOBEInfoINIFile);
    }
    GetPrivateProfileString(cszBranding,
                            cszOEMName,
                            L"",
                            szOEMName,
                            MAX_CHARS_IN_BUFFER(szOEMName),
                            szOOBEInfoINIFile);

    GetPrivateProfileString(cszOptions,
                            cszBroadbandDeviceName,
                            L"",
                            szBroadbandDeviceName,
                            MAX_CHARS_IN_BUFFER(szBroadbandDeviceName),
                            szOOBEInfoINIFile);
    GetPrivateProfileString(cszOptions,
                            cszBroadbandDevicePnpid,
                            L"",
                            szBroadbandDevicePnpid,
                            MAX_CHARS_IN_BUFFER(szBroadbandDevicePnpid),
                            szOOBEInfoINIFile);

    //DT tells the ISP if the query is coming from fullscreen OOBE or the desktop (windowed) version of OOBE. DT=1 means desktop version, DT=0 means fullscreen.
    INT nDT = (m_dwAppMode == APMD_OOBE) ? 0 : 1;

    wsprintf(szQueryString, L"LCID=%lu&TCID=%lu&ISPSignup=%s&OfferCode=%lu&OS=%lu%&BUILD=%ld&DT=%lu&OEMName=%s&BroadbandDeviceName=%s&BroadbandDevicePnpid=%s",
            GetUserDefaultUILanguage(),
            m_lpGatherInfo->m_dwCountryID,
            szISPSignup,
            dwOfferCode,
            m_lpGatherInfo->m_dwOS,
            LOWORD(osvi.dwBuildNumber),
            nDT,
            szOEMName,
            szBroadbandDeviceName,
            szBroadbandDevicePnpid);

    // Parse the ISP section in the INI file to find query pair to append
    WCHAR *pszKeys = NULL;
    PWSTR pszKey = NULL;
    WCHAR szValue[MAX_PATH];
    ULONG ulRetVal     = 0;
    BOOL  bEnumerate = TRUE;
    ULONG ulBufferSize = MAX_SECTIONS_BUFFER;
    WCHAR szOobeinfoPath[MAX_PATH + 1];

    //BUGBUG :: this search path is foir the same file as the previous one and is redundant.
    SearchPath(NULL, cszOOBEINFOINI, NULL, MAX_PATH, szOobeinfoPath, NULL);

    // Loop to find the appropriate buffer size to retieve the ins to memory
    ulBufferSize = MAX_KEYS_BUFFER;
    ulRetVal = 0;

    if (!(pszKeys = (LPWSTR)GlobalAlloc(GPTR, ulBufferSize*sizeof(WCHAR)))) {
        return FALSE;
    }
    while (ulRetVal < (ulBufferSize - 2))
    {

        ulRetVal = ::GetPrivateProfileString(cszISPQuery, NULL, L"", pszKeys, ulBufferSize, szOobeinfoPath);
        if (0 == ulRetVal)
           bEnumerate = FALSE;

        if (ulRetVal < (ulBufferSize - 2))
        {
            break;
        }
        GlobalFree( pszKeys );
        ulBufferSize += ulBufferSize;
        pszKeys = (LPWSTR)GlobalAlloc(GPTR, ulBufferSize*sizeof(WCHAR));
        if (!pszKeys)
        {
            bEnumerate = FALSE;
        }

    }


    if (bEnumerate)
    {
        // Enumerate each key value pair in the section
        pszKey = pszKeys;
        while (*pszKey)
        {
            ulRetVal = ::GetPrivateProfileString(cszISPQuery, pszKey, L"", szValue, MAX_CHARS_IN_BUFFER(szValue), szOobeinfoPath);
            if ((ulRetVal != 0) && (ulRetVal < MAX_CHARS_IN_BUFFER(szValue) - 1))
            {
                // Append query pair
                wsprintf(szQueryString, L"%s&%s=%s", szQueryString, pszKey, szValue);
            }
            pszKey += lstrlen(pszKey) + 1;
        }
    }

    if(GetPrivateProfileInt(INF_SECTION_URL,
                            ISP_MSNSIGNUP,
                            0,
                            m_szISPFile))
    {
        lstrcat(szQueryString, QUERY_STRING_MSNSIGNUP);
    }

    if (pszKeys)
        GlobalFree( pszKeys );


    if (cchMax < (DWORD)lstrlen(szQueryString) + 1)
        return FALSE;

    lstrcpy(szTemp, szQueryString);
    return TRUE;

}

HRESULT CRefDial::get_SignupURL(BSTR * pVal)
{
    WCHAR szTemp[INTERNET_MAX_URL_LENGTH] = L"";

    if (pVal == NULL)
        return E_POINTER;

    // Get the URL from the ISP file, and then convert it
    if (SUCCEEDED(GetDataFromISPFile(m_szISPFile, INF_SECTION_URL, INF_SIGNUP_URL,&szTemp[0],INTERNET_MAX_URL_LENGTH)))
    {
        if(*szTemp)
        {
            WCHAR   szUrl[INTERNET_MAX_URL_LENGTH];

            WCHAR szQuery[MAX_PATH * 4] = L"\0";
            get_QueryString(szQuery, MAX_CHARS_IN_BUFFER(szQuery));

            wsprintf(szUrl, L"%s%s",
                    szTemp,
                    szQuery);

            *pVal = SysAllocString(szUrl);
        }
        else
            *pVal = NULL;

    }
    else
    {
        *pVal = NULL;
    }
    return S_OK;
}

//BUGBUG:: this should be combined with get_SignupURL
HRESULT CRefDial::get_ReconnectURL(BSTR * pVal)
{
    WCHAR szTemp[INTERNET_MAX_URL_LENGTH] = L"\0";

    if (pVal == NULL)
        return E_POINTER;

    // Get the URL from the ISP file, and then convert it
    if (SUCCEEDED(GetDataFromISPFile(m_szISPFile, INF_SECTION_URL, INF_RECONNECT_URL,&szTemp[0],INTERNET_MAX_URL_LENGTH)))
    {
        WCHAR   szUrl[INTERNET_MAX_URL_LENGTH];
        WCHAR   szQuery[MAX_PATH * 4] = L"\0";
        DWORD   dwErr = 0;

        if(*szTemp)
        {
            get_QueryString(szQuery, MAX_CHARS_IN_BUFFER(szQuery));

            if (m_dwRASErr)
                dwErr = 1;

                wsprintf(szUrl, L"%s%s&Error=%ld",
                        szTemp,
                        szQuery,
                        dwErr);

            *pVal = SysAllocString(szUrl);
        }
        else
            *pVal = NULL;
    }
    else
    {
        *pVal = NULL;
    }
    return S_OK;
}

HRESULT CRefDial::GetConnectionType(DWORD * pdwVal)
{
    *pdwVal = m_dwConnectionType;
    return S_OK;
}



HRESULT CRefDial::GetDialErrorMsg(BSTR * pVal)
{

    if (pVal == NULL)
        return E_POINTER;

    return S_OK;
}


HRESULT CRefDial::GetSupportNumber(BSTR * pVal)
{

    /*
    WCHAR    szSupportNumber[MAX_PATH];

    if (pVal == NULL)
        return E_POINTER;

    if (m_SupportInfo.GetSupportInfo(szSupportNumber, m_dwCountryCode))
        *pVal = SysAllocString(szSupportNumber);
    else
        *pVal = NULL;
*/
    return S_OK;
}


BOOL CRefDial::IsDBCSString( CHAR *sz )
{
    if (!sz)
        return FALSE;

    while( NULL != *sz )
    {
         if (IsDBCSLeadByte(*sz)) return FALSE;
         sz++;
    }

    return TRUE;
}

//+---------------------------------------------------------------------------
//
//  Function:   RasGetConnectStatus
//
//  Synopsis:   Checks for existing Ras connection; return TRUE for connected
//              Return FALSE for disconnect.
//
//+---------------------------------------------------------------------------

HRESULT CRefDial::RasGetConnectStatus(BOOL *pVal)
{
    HRESULT     hr = E_FAIL;

    *pVal = FALSE;

    if (NULL != m_hrasconn)
    {
        RASCONNSTATUS rasConnectState;
        rasConnectState.dwSize = sizeof(RASCONNSTATUS);
        if (m_pcRNA)
        {
            if (0 == m_pcRNA->RasGetConnectStatus(m_hrasconn, &rasConnectState))
            {
                if (RASCS_Disconnected != rasConnectState.rasconnstate)
                    *pVal = TRUE;
            }

            hr = S_OK;
        }
    }

    return hr;
}


//+---------------------------------------------------------------------------
//
//  Function:   DoOfferDownload
//
//  Synopsis:   Download the ISP offer from the ISP server
//
//+---------------------------------------------------------------------------
HRESULT CRefDial::DoOfferDownload(BOOL *pbRetVal)
{
    HRESULT hr;
       RNAAPI  *pcRNA;


    //
    // Hide RNA window on Win95 retail
    //
//        MinimizeRNAWindow(m_pszConnectoid, g_hInst);
        // 4/2/97    ChrisK    Olympus 296
//        g_hRNAZapperThread = LaunchRNAReestablishZapper(g_hInst);
    //
    // The connection is open and ready.  Start the download.
    //
    m_dwThreadID = 0;
    m_hThread = CreateThread(NULL,
                             0,
                             (LPTHREAD_START_ROUTINE)DownloadThreadInit,
                             (LPVOID)this,
                             0,
                             &m_dwThreadID);

    // 5-1-97    ChrisK Olympus 2934
//    m_objBusyMessages.Start(m_hWnd, IDC_LBLSTATUS,m_hrasconn);

    // If we dont get the donwload thread, then kill the open
    // connection
    if (!m_hThread)
    {
        hr = GetLastError();
        if (m_hrasconn)
        {
            pcRNA = new RNAAPI;
            if (pcRNA)
            {
                pcRNA->RasHangUp(m_hrasconn);
                m_hrasconn = NULL;
                delete pcRNA;
                pcRNA = NULL;
            }
        }

        *pbRetVal = FALSE;
    }
    else
    {
        // Download has started.
        m_bDownloadHasBeenCanceled = FALSE;
        *pbRetVal = TRUE;
    }
    return S_OK;
}

// Form the Dialing URL.  Must be called after setting up for dialing.
HRESULT CRefDial::FormReferralServerURL(BOOL * pbRetVal)
{

    WCHAR    szTemp[MAX_PATH] = L"\0";
    WCHAR    szPromo[MAX_PATH]= L"\0";
    WCHAR    szProd[MAX_PATH] = L"\0";
    WCHAR    szArea[MAX_PATH] = L"\0";
    WCHAR    szOEM[MAX_PATH]  = L"\0";
    DWORD    dwCONNWIZVersion = 500;        // Version of CONNWIZ.HTM

    //
    // ChrisK Olympus 3997 5/25/97
    //
    WCHAR szRelProd[MAX_PATH] = L"\0";
    WCHAR szRelProdVer[MAX_PATH] = L"\0";
    HRESULT hr = ERROR_SUCCESS;
    OSVERSIONINFO osvi;


    //
    // Build URL complete with name value pairs
    //
    hr = GetDataFromISPFile(m_szISPFile, INF_SECTION_ISPINFO, INF_REFERAL_URL,&szTemp[0],256);
    if (L'\0' == szTemp[0])
    {
        //MsgBox(IDS_MSNSU_WRONG, MB_MYERROR);
        return hr;
    }

    //Assert(szTemp[0]);

    Sz2URLValue(m_szOEM, szOEM,0);
    Sz2URLValue(m_lpGatherInfo->m_szAreaCode, szArea,0);
    if (m_bstrProductCode)
        Sz2URLValue(m_bstrProductCode, szProd,0);
    else
        Sz2URLValue(DEFAULT_PRODUCTCODE, szProd,0);

    if (m_bstrPromoCode)
        Sz2URLValue(((BSTR)m_bstrPromoCode), szPromo,0);
    else
        Sz2URLValue(DEFAULT_PROMOCODE, szPromo,0);


    //
    // ChrisK Olympus 3997 5/25/97
    //
    Sz2URLValue(m_lpGatherInfo->m_szRelProd, szRelProd, 0);
    Sz2URLValue(m_lpGatherInfo->m_szRelVer, szRelProdVer, 0);
    ZeroMemory(&osvi, sizeof(OSVERSIONINFO));
    osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
    if (!GetVersionEx(&osvi))
    {
        ZeroMemory(&osvi, sizeof(OSVERSIONINFO));
    }

    // Autoconfig will set alloffers always.
    if ( m_lAllOffers || (m_lpGatherInfo->m_dwFlag & ICW_CFGFLAG_AUTOCONFIG) )
    {
        m_lpGatherInfo->m_dwFlag |= ICW_CFGFLAG_ALLOFFERS;
    }
    wsprintf(m_szUrl, L"%slcid=%lu&sysdeflcid=%lu&appslcid=%lu&icwos=%lu&osver=%lu.%2.2d%s&arch=%u&promo=%s&oem=%s&area=%s&country=%lu&icwver=%s&prod=%s&osbld=%d&icwrp=%s&icwrpv=%s&wizver=%lu&PID=%s&cfgflag=%lu",
                 szTemp,
                 m_lpGatherInfo->m_lcidUser,
                 m_lpGatherInfo->m_lcidSys,
                 m_lpGatherInfo->m_lcidApps,
                 m_lpGatherInfo->m_dwOS,
                 m_lpGatherInfo->m_dwMajorVersion,
                 m_lpGatherInfo->m_dwMinorVersion,
                 ICW_OS_VER,
                 m_lpGatherInfo->m_wArchitecture,
                 szPromo,
                 szOEM,
                 szArea,
                 m_lpGatherInfo->m_dwCountryCode,
                 &m_lpGatherInfo->m_szSUVersion[0],
                 szProd,
                 LOWORD(osvi.dwBuildNumber),
                 szRelProd,
                 szRelProdVer,
                 dwCONNWIZVersion,
                 m_szPID,
                 m_lpGatherInfo->m_dwFlag);


    StoreInSignUpReg(
        (LPBYTE)m_lpGatherInfo,
        sizeof(GATHERINFO),
        REG_BINARY,
        GATHERINFOVALUENAME);
    return hr;
}


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

  NAME:    ParseISPInfo

  SYNOPSIS:  Called when page is displayed

  ENTRY:    hDlg - dialog window
        fFirstInit - TRUE if this is the first time the dialog
        is initialized, FALSE if this InitProc has been called
        before (e.g. went past this page and backed up)

********************************************************************/
BOOL CRefDial::ParseISPInfo
(
    HWND hDlg,
    WCHAR *pszCSVFileName,
    BOOL bCheckDupe
)
{
    // On the first init, we will read the ISPINFO.CSV file, and populate the ISP LISTVIEW

    CCSVFile    far *pcCSVFile;
    CISPCSV     far *pcISPCSV;
    BOOL        bRet = TRUE;
    BOOL        bHaveCNSOffer = FALSE;
    BOOL        bISDNMode = FALSE;
    HRESULT     hr;

    CleanISPList();
    ISPLIST* pCurr = NULL;


    DWORD dwCurrISPListSize = 1;
    m_dwNumOfAutoConfigOffers = 0;
    m_unSelectedISP = 0;

    // Open and process the CSV file
    pcCSVFile = new CCSVFile;
    if (!pcCSVFile)
    {
        // BUGBUG: Show Error Message
        return (FALSE);
    }

    if (!pcCSVFile->Open(pszCSVFileName))
    {
        // BUGBUG: Show Error Message
        delete pcCSVFile;
        pcCSVFile = NULL;

        return (FALSE);
    }

    // Read the first line, since it contains field headers
    pcISPCSV = new CISPCSV;
    if (!pcISPCSV)
    {
        // BUGBUG Show error message
        delete pcCSVFile;
        return (FALSE);
    }

    if (ERROR_SUCCESS != (hr = pcISPCSV->ReadFirstLine(pcCSVFile)))
    {
        // Handle the error case
        delete pcCSVFile;
        pcCSVFile = NULL;

        return (FALSE);
    }
    delete pcISPCSV;        // Don't need this one any more

    // Create the SELECT tag for the html so it can get all the country names in one shot.
    if (m_pszISPList)
        delete [] m_pszISPList;
    m_pszISPList = new WCHAR[1024];
    if (!m_pszISPList)
        return FALSE;

    memset(m_pszISPList, 0, sizeof(m_pszISPList));

    do {
        // Allocate a new ISP record
        pcISPCSV = new CISPCSV;
        if (!pcISPCSV)
        {
            // BUGBUG Show error message
            bRet = FALSE;
            break;

        }

        // Read a line from the ISPINFO file
        hr = pcISPCSV->ReadOneLine(pcCSVFile);
        if (hr == ERROR_SUCCESS)
        {
            // If this line contains a nooffer flag, then leave now
            if (!(pcISPCSV->get_dwCFGFlag() & ICW_CFGFLAG_OFFERS))
            {
                m_dwNumOfAutoConfigOffers = 0;
                break;
            }
            if ((pcISPCSV->get_dwCFGFlag() & ICW_CFGFLAG_AUTOCONFIG) &&
                (bISDNMode ? (pcISPCSV->get_dwCFGFlag() & ICW_CFGFLAG_ISDN_OFFER) : TRUE) )
            {
                // Form the ISP list option tag for HTML

                WCHAR szBuffer[MAX_PATH];
                wsprintf(szBuffer, szOptionTag, pcISPCSV->get_szISPName());
                DWORD dwSizeReq = (DWORD)lstrlen(m_pszISPList) + lstrlen(szBuffer) + 1;
                if (dwCurrISPListSize < dwSizeReq)
                {
                    WCHAR *szTemp = new WCHAR[dwSizeReq];
                    if (szTemp)
                        lstrcpy(szTemp, m_pszISPList);
                    dwCurrISPListSize =  dwSizeReq;
                    delete [] m_pszISPList;
                    m_pszISPList = szTemp;
                }

                // Add the isp to the list.
                if (m_pszISPList)
                    lstrcat(m_pszISPList, szBuffer);

                if (m_pCSVList == NULL) // First one
                {
                    // Add the CSV file object to the first node of linked list
                    ISPLIST* pNew = new ISPLIST;
                    pNew->pElement = pcISPCSV;
                    pNew->uElem = m_dwNumOfAutoConfigOffers;
                    pNew->pNext = NULL;
                    pCurr = pNew;
                    m_pCSVList = pCurr;
                }
                else
                {
                    // Append CSV object to the end of list
                    ISPLIST* pNew = new ISPLIST;
                    pNew->pElement = pcISPCSV;
                    pNew->uElem = m_dwNumOfAutoConfigOffers;
                    pNew->pNext = NULL;
                    pCurr->pNext = pNew;
                    pCurr = pCurr->pNext;
                }
                ++m_dwNumOfAutoConfigOffers;

            }
            else
            {
                delete pcISPCSV;
            }
        }
        else if (hr == ERROR_NO_MORE_ITEMS)
        {
            delete pcISPCSV;        // We don't need this one
            break;
        }
        else if (hr == ERROR_FILE_NOT_FOUND)
        {
            // do not show this ISP when its data is invalid
            // we don't want to halt everything. Just let it contine
            delete pcISPCSV;
        }
        else
        {
            // Show error message Later
            delete pcISPCSV;
            //iNumOfAutoConfigOffers = ISP_INFO_NO_VALIDOFFER;
            bRet = FALSE;
            break;
        }

    } while (TRUE);

    delete pcCSVFile;

    return bRet;
}

HRESULT CRefDial::GetISPList(BSTR* pbstrISPList)
{

    if (pbstrISPList)
        *pbstrISPList = NULL;
    else
        return E_FAIL;

    if (!m_pszISPList)
    {
        ParseISPInfo(NULL, ICW_ISPINFOPath, TRUE);
    }
    if (m_pszISPList && *m_pszISPList)
    {
        *pbstrISPList = SysAllocString(m_pszISPList);
        return S_OK;
    }
    return E_FAIL;
}

HRESULT CRefDial::Set_SelectISP(UINT nVal)
{
    if (nVal < m_dwNumOfAutoConfigOffers)
    {
        m_unSelectedISP = nVal;
    }
    return S_OK;
}

HRESULT CRefDial::Set_ConnectionMode(UINT nVal)
{
    if (nVal < m_dwNumOfAutoConfigOffers)
    {
        m_unSelectedISP = nVal;
    }
    return S_OK;
}

HRESULT CRefDial::Get_ConnectionMode(UINT *pnVal)
{
    if (pnVal)
    {
        *pnVal = m_dwCnType;
        return S_OK;
    }
    return E_FAIL;
}


HRESULT CRefDial::ProcessSignedPID(BOOL * pbRetVal)
{
    HANDLE  hfile;
    DWORD   dwFileSize;
    DWORD   dwBytesRead;
    LPBYTE  lpbSignedPID;
    LPWSTR  lpszSignedPID;

    *pbRetVal = FALSE;

    // Open the PID file for Binary Reading.  It will be in the CWD
    if (INVALID_HANDLE_VALUE != (hfile = CreateFile(c_szSignedPIDFName,
                                                  GENERIC_READ,
                                                  0,
                                                  NULL,
                                                  OPEN_EXISTING,
                                                  FILE_ATTRIBUTE_NORMAL,
                                                  NULL)))
    {
        dwFileSize = GetFileSize(hfile, NULL);

        // Allocate a buffer to read the file, and one to store the BINHEX version
        lpbSignedPID = new BYTE[dwFileSize];
        lpszSignedPID = new WCHAR[(dwFileSize * 2) + 1];

        if (lpbSignedPID && lpszSignedPID)
        {
            if (ReadFile(hfile, (LPVOID) lpbSignedPID, dwFileSize, &dwBytesRead, NULL) &&
                    (dwFileSize == dwBytesRead))
            {
                // BINHEX the signed PID data so we can send it to the signup server
                DWORD   dwX = 0;
                BYTE    by;
                for (DWORD dwY = 0; dwY < dwFileSize; dwY++)
                {
                    by = lpbSignedPID[dwY];
                    lpszSignedPID[dwX++] = g_BINTOHEXLookup[((by & 0xF0) >> 4)];
                    lpszSignedPID[dwX++] = g_BINTOHEXLookup[(by & 0x0F)];
                }
                lpszSignedPID[dwX] = L'\0';

                // Convert the signed pid to a BSTR
                m_bstrSignedPID = SysAllocString(lpszSignedPID);

                // Set the return value
                *pbRetVal = TRUE;
            }
        }

        // Free the buffers we allocated
        if (lpbSignedPID)
        {
            delete[] lpbSignedPID;
        }
        if (lpszSignedPID)
        {
            delete[] lpszSignedPID;
        }

        // Close the File
        CloseHandle(hfile);

#ifndef DEBUG
        // Delete the File
        // defer removal of this file until the container app exits.
        // see BUG 373.
        //DeleteFile(c_szSignedPIDFName);
#endif
    }

    return S_OK;
}

HRESULT CRefDial::get_SignedPID(BSTR * pVal)
{
    if (pVal == NULL)
         return E_POINTER;
    *pVal = SysAllocString(m_bstrSignedPID);
    return S_OK;
}

HRESULT CRefDial::get_ISDNAutoConfigURL(BSTR * pVal)
{
    WCHAR szTemp[256];

    if (pVal == NULL)
        return E_POINTER;

    // Get the URL from the ISP file, and then convert it
    if (SUCCEEDED(GetDataFromISPFile(m_szISPFile, INF_SECTION_URL, INF_ISDN_AUTOCONFIG_URL,&szTemp[0],256)))
    {
        *pVal = SysAllocString(szTemp);
    }
    else
    {
        *pVal = NULL;
    }
    return S_OK;
}

HRESULT CRefDial::get_ISPName(BSTR * pVal)
{
    if (m_pSelectedISPInfo)
    {
        *pVal = SysAllocString(m_pSelectedISPInfo->get_szISPName());
    }
    else
    {
        *pVal = NULL;
    }
    return S_OK;
}

HRESULT CRefDial::get_AutoConfigURL(BSTR * pVal)
{
    WCHAR szTemp[256];

    if (pVal == NULL)
        return E_POINTER;

    // Get the URL from the ISP file, and then convert it
    if (SUCCEEDED(GetDataFromISPFile(m_szISPFile, INF_SECTION_URL, INF_AUTOCONFIG_URL,&szTemp[0],256)))
    {
        *pVal = SysAllocString(szTemp);
    }
    else
    {
        *pVal = NULL;
    }
    return S_OK;
}


HRESULT CRefDial::DownloadISPOffer(BOOL *pbVal, BSTR *pVal)
{
    HRESULT hr = S_OK;
    // Download the ISP file, and then copy its contents
    // If Ras is complete
    if (pbVal && pVal)
    {

        // Download the first page from Webgate
        BSTR    bstrURL = NULL;
        BSTR    bstrQueryURL = NULL;
        BOOL    bRet;

        *pVal = NULL;
        *pbVal = FALSE;

        m_pISPData = new CICWISPData;

        WCHAR   szTemp[10];      // Big enough to format a WORD

        // Add the PID, GIUD, and Offer ID to the ISP data object
        ProcessSignedPID(&bRet);
        if (bRet)
        {
            m_pISPData->PutDataElement(ISPDATA_SIGNED_PID, m_bstrSignedPID, FALSE);
        }
        else
        {
            m_pISPData->PutDataElement(ISPDATA_SIGNED_PID, NULL, FALSE);
        }

        // GUID comes from the ISPCSV file
        m_pISPData->PutDataElement(ISPDATA_GUID,
                                                m_pSelectedISPInfo->get_szOfferGUID(),
                                                FALSE);

        // Offer ID comes from the ISPCSV file as a WORD
        // NOTE: This is the last one, so besure AppendQueryPair does not add an Ampersand
        if (m_pSelectedISPInfo)
        {
            wsprintf (szTemp, L"%d", m_pSelectedISPInfo->get_wOfferID());
            m_pISPData->PutDataElement(ISPDATA_OFFERID, szTemp, FALSE);
        }


        // BUGBUG: If ISDN get the ISDN Autoconfig URL
        if (m_ISPImport.m_bIsISDNDevice)
        {
            get_ISDNAutoConfigURL(&bstrURL);
        }
        else
        {
            get_AutoConfigURL(&bstrURL);
        }

        if (*bstrURL)
        {
            // Get the full signup url with Query string params added to it
            m_pISPData->GetQueryString(bstrURL, &bstrQueryURL);

            // Setup WebGate
            if (S_OK != gpCommMgr->FetchPage(bstrQueryURL, pVal))
            {
                // Download problem:
                // User has disconnected
                if (TRUE == m_bUserInitiateHangup)
                {
                    hr = E_FAIL;
                }
            }
            else
            {
                *pbVal = TRUE;
            }
        }


        // Now that webgate is done with it, free the queryURL
        SysFreeString(bstrQueryURL);

        // Memory cleanup
        SysFreeString(bstrURL);

        delete m_pISPData;
        m_pISPData = NULL;

    }
    return hr;
}

HRESULT CRefDial::RemoveDownloadDir()
{
    DWORD dwAttribs;
    WCHAR szDownloadDir[MAX_PATH];
    WCHAR szSignedPID[MAX_PATH];

    // form the ICW98 dir.  It is basically the CWD
    if(!GetOOBEPath(szDownloadDir))
        return S_OK;

    // remove the signed.pid file from the ICW directory (see BUG 373)
    wsprintf(szSignedPID, L"%s%s", szDownloadDir, L"\\signed.pid");
    if (GetFileAttributes(szSignedPID) != 0xFFFFFFFF)
    {
      SetFileAttributes(szSignedPID, FILE_ATTRIBUTE_NORMAL);
      DeleteFile(szSignedPID);
    }

    lstrcat(szDownloadDir, L"\\download");

    // See if the directory exists
    dwAttribs = GetFileAttributes(szDownloadDir);
    if (dwAttribs != 0xFFFFFFFF && dwAttribs & FILE_ATTRIBUTE_DIRECTORY)
      DeleteDirectory(szDownloadDir);
    return S_OK;
}

void CRefDial::DeleteDirectory (LPCWSTR szDirName)
{
   WIN32_FIND_DATA fdata;
   WCHAR szPath[MAX_PATH];
   HANDLE hFile;
   BOOL fDone;

   wsprintf(szPath, L"%s\\*.*", szDirName);
   hFile = FindFirstFile (szPath, &fdata);
   if (INVALID_HANDLE_VALUE != hFile)
      fDone = FALSE;
   else
      fDone = TRUE;

   while (!fDone)
   {
      wsprintf(szPath, L"%s\\%s", szDirName, fdata.cFileName);
      if (fdata.dwFileAttributes == FILE_ATTRIBUTE_DIRECTORY)
      {
         if (lstrcmpi(fdata.cFileName, L".")  != 0 &&
             lstrcmpi(fdata.cFileName, L"..") != 0)
         {
            // recursively delete this dir too
            DeleteDirectory(szPath);
         }
      }
      else
      {
         SetFileAttributes(szPath, FILE_ATTRIBUTE_NORMAL);
         DeleteFile(szPath);
      }
      if (FindNextFile(hFile, &fdata) == 0)
      {
         FindClose(hFile);
         fDone = TRUE;
      }
   }
   SetFileAttributes(szDirName, FILE_ATTRIBUTE_NORMAL);
   RemoveDirectory(szDirName);
}

HRESULT CRefDial::PostRegData(DWORD dwSrvType, LPWSTR szPath)
{
    static WCHAR hdrs[]     = L"Content-Type: application/x-www-form-urlencoded";
    static WCHAR accept[]   = L"Accept: */*";
    static LPCWSTR rgsz[]   = {accept, NULL};
    WCHAR  szRegPostURL[INTERNET_MAX_URL_LENGTH] = L"\0";
    HRESULT hRet = E_FAIL;


    if (POST_TO_MS & dwSrvType)
    {
        // Get the RegPostURL from Reg.isp file for MS registration
        GetPrivateProfileString(INF_SECTION_URL,
                                c_szRegPostURL,
                                L"",
                                szRegPostURL,
                                INTERNET_MAX_URL_LENGTH,
                                m_szISPFile);
    }
    else if (POST_TO_OEM & dwSrvType)
    {
        WCHAR   szOOBEInfoINIFile[MAX_PATH];
        SearchPath(NULL, cszOOBEINFOINI, NULL, MAX_CHARS_IN_BUFFER(szOOBEInfoINIFile), szOOBEInfoINIFile, NULL);
        GetPrivateProfileString(INF_OEMREGPAGE,
                                c_szRegPostURL,
                                L"",
                                szRegPostURL,
                                INTERNET_MAX_URL_LENGTH,
                                szOOBEInfoINIFile);
    }


    // Connecting to http://mscomdev.dns.microsoft.com/register.asp.
    if (CrackUrl(
        szRegPostURL,
        m_szRegServerName,
        m_szRegFormAction,
        &m_nRegServerPort,
        &m_fSecureRegServer))
    {

        HINTERNET hSession = InternetOpen(
            L"OOBE",
            INTERNET_OPEN_TYPE_PRECONFIG,
            NULL,
            NULL,
            0
            );

        if (hSession)
        {
            HINTERNET hConnect = InternetConnect(
                hSession,
                m_szRegServerName,
                m_nRegServerPort,
                NULL,
                NULL,
                INTERNET_SERVICE_HTTP,
                0,
                1
                );

            if (hConnect)
            {
                // INTERNET_FLAG_SECURE is needed KB Q168151
                
                HINTERNET hRequest = HttpOpenRequest(
                    hConnect,
                    L"POST",
                    m_szRegFormAction,
                    NULL,
                    NULL,
                    rgsz,
                    (m_fSecureRegServer) ? INTERNET_FLAG_SECURE : 0,
                    1
                    );

                if (hRequest)
                {
                    // The data for the HttpSendRequest has to be in ANSI. The server side does
                    // not understand a UNICODE string. If the server side gets changed to understand
                    // UNICODE data, the conversion below needs to be removed.
                    LPSTR szAnsiData = NULL;
                    INT   iLength;
                    // compute the length
                    //
                    iLength =  WideCharToMultiByte(CP_ACP, 0, szPath, -1, NULL, 0, NULL, NULL);
                    if (iLength > 0)
                    {
                        szAnsiData  = new char[iLength];
                        if (szAnsiData)
                        {
                            WideCharToMultiByte(CP_ACP, 0, szPath, -1, szAnsiData, iLength, NULL, NULL);
                            szAnsiData[iLength - 1] = 0;
                        }
                    }
                    if (szAnsiData)
                    {
                        // 2nd/3rd params are a string/char length pair,
                        // but 4th/5th params are a buffer/byte length pair.
                        if (HttpSendRequest(hRequest, hdrs, lstrlen(hdrs), szAnsiData, lstrlenA(szAnsiData)))
                        {
                            // Get size of file in bytes.
                            WCHAR bufQuery[32] ;
                            DWORD dwFileSize ;
                            DWORD cchMaxBufQuery = MAX_CHARS_IN_BUFFER(bufQuery);
                            BOOL bQuery = HttpQueryInfo(hRequest,
                                HTTP_QUERY_CONTENT_LENGTH,
                                bufQuery,
                                &cchMaxBufQuery,
                                NULL) ;
                            if (bQuery)
                            {
                                // The Query was successful, so allocate the memory.
                                dwFileSize = (DWORD)_wtol(bufQuery) ;
                            }
                            else
                            {
                                // The Query failed. Allocate some memory. Should allocate memory in blocks.
                                dwFileSize = 5*1024 ;
                            }

                            // BUGBUG: What is the purpose of this code??  It
                            // appears to read a file, null-terminate the buffer,
                            // then delete the buffer.  Why??

                            BYTE* rgbFile = new BYTE[dwFileSize+1] ;
                            if (rgbFile)
                            {
                                DWORD dwBytesRead ;
                                BOOL bRead = InternetReadFile(hRequest,
                                    rgbFile,
                                    dwFileSize+1,
                                    &dwBytesRead);
                                if (bRead)
                                {
                                    rgbFile[dwBytesRead] = 0 ;
                                    hRet = S_OK;
                                } // InternetReadFile
                                delete [] rgbFile;
                            }

                        }
                        else
                        {
                            DWORD dwErr = GetLastError();
                        }
                        delete [] szAnsiData;
                    }
                    InternetCloseHandle(hRequest);
                    hRet = S_OK;
                }
                InternetCloseHandle(hConnect);
            }
            InternetCloseHandle(hSession);
        }
    }

    if (hRet != S_OK)
    {
        DWORD dwErr = GetLastError();
        hRet = HRESULT_FROM_WIN32(dwErr);
    }

    TRACE2(TEXT("Post registration data to %s 0x%08lx"), szRegPostURL, hRet);

    return hRet;


}




// This function will accept user selected values that are necessary to
// setup a connectiod for dialing
// Returns:
//      TRUE        OK to dial
//      FALSE       Some kind of problem
//                  QuitWizard - TRUE, then terminate
//                  UserPickNumber - TRUE, then display Pick a Number DLG
//                  QuitWizard and UserPickNumber both FALSE, then just
//                  display the page prior to Dialing UI.
HRESULT CRefDial::Connect
(
    UINT nType,
    BSTR bstrISPFile,
    DWORD dwCountry,
    BSTR bstrAreaCode,
    DWORD dwFlag,
    DWORD dwAppMode
)
{
    HRESULT             hr = S_OK;
    BOOL                bSuccess = FALSE;
    BOOL                bRetVal = FALSE;

    LPWSTR   pszTemp;
    WCHAR    szISPPath[MAX_PATH];

    m_dwCnType = nType;

    if (!bstrISPFile || !bstrAreaCode)
    {
        return E_FAIL;
    }


    // Locate ISP file
    if (!SearchPath(NULL, bstrISPFile,INF_SUFFIX,MAX_PATH,szISPPath,&pszTemp))
    {
        hr = ERROR_FILE_NOT_FOUND;
        return hr;
    }


    // Check whether the isp file is ICW capable by reading the referral URL
    GetPrivateProfileString(INF_SECTION_ISPINFO,
                            c_szURLReferral,
                            L"",
                            m_szRefServerURL,
                            INTERNET_MAX_URL_LENGTH,
                            szISPPath);

    lstrcpy(m_szISPFile, szISPPath);

    m_dwAppMode = dwAppMode;


    // Initialize failure codes
    m_bQuitWizard = FALSE;
    m_bUserPickNumber = FALSE;
    m_lpGatherInfo->m_bUsePhbk = FALSE;


    // Stuff the Area Code, and Country Code into the GatherInfo struct

    m_lpGatherInfo->m_dwCountryID = dwCountry;
    m_lpGatherInfo->m_dwCountryCode = dwFlag;

    lstrcpy(m_lpGatherInfo->m_szAreaCode, bstrAreaCode);


    m_SuggestInfo.AccessEntry.dwCountryID = dwCountry;
    m_SuggestInfo.AccessEntry.dwCountryCode = dwFlag;
    lstrcpy(m_SuggestInfo.AccessEntry.szAreaCode, bstrAreaCode);

    GetISPFileSettings(szISPPath);

    FillGatherInfoStruct(m_lpGatherInfo);

    if (CONNECTED_REFFERAL == m_dwCnType)
        FormReferralServerURL(&bRetVal);

    // LAN connection support in desktop mode
    if (gpCommMgr)
    {
        // Pretend we have the connection
        PostMessage(gpCommMgr->m_hwndCallBack, WM_OBCOMM_ONCONNECTED, (WPARAM)gpCommMgr->m_pRefDial->m_dwCnType , (LPARAM)0);

    }

    return hr;
}


HRESULT CRefDial::CheckOnlineStatus(BOOL *pbVal)
{
    // #if defined(DEBUG)
    //     *pbVal = TRUE;
    //     return S_OK;
    // #endif

    *pbVal = (BOOL)(m_hrasconn != NULL);
    return S_OK;
}


BOOL CRefDial::CrackUrl(
    const WCHAR* lpszUrlIn,
    WCHAR* lpszHostOut,
    WCHAR* lpszActionOut,
    INTERNET_PORT* lpnHostPort,
    BOOL*  lpfSecure)
{
    URL_COMPONENTS urlcmpTheUrl;

    LPURL_COMPONENTS lpUrlComp = &urlcmpTheUrl;

    urlcmpTheUrl.dwStructSize = sizeof(urlcmpTheUrl);

    urlcmpTheUrl.lpszScheme = NULL;
    urlcmpTheUrl.lpszHostName = NULL;
    urlcmpTheUrl.lpszUserName = NULL;
    urlcmpTheUrl.lpszPassword = NULL;
    urlcmpTheUrl.lpszUrlPath = NULL;
    urlcmpTheUrl.lpszExtraInfo = NULL;

    urlcmpTheUrl.dwSchemeLength = 1;
    urlcmpTheUrl.dwHostNameLength = 1;
    urlcmpTheUrl.dwUserNameLength = 1;
    urlcmpTheUrl.dwPasswordLength = 1;
    urlcmpTheUrl.dwUrlPathLength = 1;
    urlcmpTheUrl.dwExtraInfoLength = 1;

    if (!InternetCrackUrl(lpszUrlIn, lstrlen(lpszUrlIn),0, lpUrlComp) || !lpszHostOut || !lpszActionOut || !lpnHostPort || !lpfSecure)
    {
        return FALSE;
    }
    else
    {

        if (urlcmpTheUrl.dwHostNameLength != 0)
        {
            lstrcpyn(lpszHostOut, urlcmpTheUrl.lpszHostName, urlcmpTheUrl.dwHostNameLength+1);
        }

        if (urlcmpTheUrl.dwUrlPathLength != 0)
        {
            lstrcpyn(lpszActionOut, urlcmpTheUrl.lpszUrlPath, urlcmpTheUrl.dwUrlPathLength+1);
        }

        *lpfSecure = (urlcmpTheUrl.nScheme == INTERNET_SCHEME_HTTPS) ? TRUE : FALSE;
        *lpnHostPort = urlcmpTheUrl.nPort;

        return TRUE;
    }
}

//+---------------------------------------------------------------------------
//
//  Function:   SetupForAutoDial
//
//  Synopsis:   Enable/disable autodial to the current connectoid, and with
//              optional new credential. If autodial is enabled, initiate
//              unattended autodial using IE's dialog box
//
//  Return:     S_OK - successful
//              S_FALSE - no current connectoid or autodial was cancelled
//              HRESULT error code
//
//+---------------------------------------------------------------------------
HRESULT CRefDial::SetupForAutoDial(
    IN BOOL bEnabled,
    IN BSTR bstrUserSection OPTIONAL
    )
{
#define AUTOCONNECT_KEY_FORMAT      L"RemoteAccess\\Profile\\%s"
#define AUTOCONNECT_VALUE           L"AutoConnect"

    HRESULT hr = S_OK;
    DWORD dwValue;

    if ((m_szConnectoid[0] == L'\0') ||
        (m_szCurrentDUNFile[0] == L'\0' && m_szISPFile[0] == L'\0'))
    {
        hr = S_FALSE;
        goto cleanup;
    }

    if (bstrUserSection != NULL)
    {
        RASCREDENTIALS rascred;
        LPWSTR szCurrentFile = *m_szCurrentDUNFile != 0 ? m_szCurrentDUNFile : m_szISPFile;
        
        ZeroMemory(&rascred, sizeof(rascred));
        rascred.dwSize = sizeof(rascred);
        rascred.dwMask = RASCM_UserName | RASCM_Password | RASCM_DefaultCreds;

        if (!GetPrivateProfileString(
                bstrUserSection,
                cszUserName,
                L"",
                rascred.szUserName,
                ARRAYSIZE(rascred.szUserName),
                szCurrentFile) || 
            !GetPrivateProfileString(
                bstrUserSection,
                cszPassword,
                L"",
                rascred.szPassword,
                ARRAYSIZE(rascred.szPassword),
                szCurrentFile))
        {
            TRACE2(
                L"Credentials not available in %s [%s]",
                szCurrentFile,
                bstrUserSection
                );
            
            hr = E_INVALIDARG;
            goto cleanup;
        }

        TRACE2(
            L"Update Credentials UserName=%s, Password=%s",
            rascred.szUserName,
            rascred.szPassword
            );

        hr = HRESULT_FROM_WIN32(RasSetCredentials(
                NULL,
                m_szConnectoid,
                &rascred,
                FALSE));
        if (FAILED(hr))
        {
            TRACE1(L"Update Credentials failed 0x%08lx", hr);
            goto cleanup;
        }
    }

    //
    // Even though we call InternetDial directly, we enable autodial
    // so that if the connection is disconnected while browsering
    // in IE, IE will prompt users for reconnect.
    //

    if (!m_bAutodialModeSaved)
    {
        DWORD dwSize = sizeof(DWORD);
        
        m_bAutodialModeSaved = InternetQueryOption(
            NULL,
            INTERNET_OPTION_AUTODIAL_MODE,
            &m_dwOrigAutodialMode,
            &dwSize);

        if (m_bAutodialModeSaved)
        {
            TRACE1(L"Save original autodial mode %d", m_dwOrigAutodialMode);
        }
        else
        {
            TRACE1(L"Save original autodial mode failed: %d", GetLastError());
        }
    }

    dwValue = (bEnabled) ? AUTODIAL_MODE_NO_NETWORK_PRESENT : AUTODIAL_MODE_NEVER;

    TRACE1(L"Set autodial mode to %d", dwValue);
    
    if (!InternetSetOption(
        NULL,
        INTERNET_OPTION_AUTODIAL_MODE,
        &dwValue,
        sizeof(DWORD)))
    {
        hr = HRESULT_FROM_WIN32(GetLastError());
        
        TRACE1(L"Set autodial mode failed: 0x%08lx", hr);
        
        goto cleanup;
    }
    else
    {
        //
        // need to cleanup if autodial has been enabled or is enabled.
        //
        
        m_bCleanupAutodial = m_bCleanupAutodial || bEnabled;
    }

    //
    // Make the connectoid autoconnect to avoid the username confusing user
    //
    
    if (bEnabled)
    {
        //
        // ISSUE 2002/06/12 chunhoc - hack to make the Autodial dialog remain 
        // opened in case of dialing error, while autoconnect is used.
        //
        
        WCHAR szKey[ARRAYSIZE(AUTOCONNECT_KEY_FORMAT) + ARRAYSIZE(m_szConnectoid)];
        
        StringCchPrintf(
            szKey,
            ARRAYSIZE(szKey),
            AUTOCONNECT_KEY_FORMAT,
            m_szConnectoid
            );

        dwValue = 1;
        SHSetValue(
            HKEY_CURRENT_USER,
            szKey,
            AUTOCONNECT_VALUE,
            REG_DWORD,
            &dwValue,
            sizeof(DWORD)
            );
        
        TRACE(L"Start InternetDial ...");
        
        dwValue = 0;
        hr = InternetDial(
                gpCommMgr->m_hwndCallBack,
                m_szConnectoid,
                INTERNET_AUTODIAL_FORCE_ONLINE | INTERNET_AUTODIAL_FORCE_UNATTENDED,
                &dwValue,
                0
                );

        TRACE2(L"InternetDial returns %d, dwConnection=0x%08lx", hr, dwValue);

        if (SUCCEEDED(hr) && !dwValue)
        {
            //
            // User may have cancelled the dialing.
            //
            
            hr = S_FALSE;
        }
    }

cleanup:

    return hr;
}

void CRefDial::CleanupAutodial()
{   
    if (m_bAutodialModeSaved)
    {
        TRACE1(L"Restore autodial mode %d", m_dwOrigAutodialMode);
        if (!InternetSetOption(
            NULL,
            INTERNET_OPTION_AUTODIAL_MODE,
            &m_dwOrigAutodialMode,
            sizeof(DWORD)))
        {
            TRACE1(L"Restore autodial mode failed %d", GetLastError());
        }
        
        m_bAutodialModeSaved = FALSE;
    }

    if (m_bCleanupAutodial)
    {
        HGLOBAL pBufferToFree = NULL;
        RASCONN rasconn;
        LPRASCONN prc = &rasconn;
        prc->dwSize = sizeof(RASCONN);
        DWORD cbSize = sizeof(RASCONN);
        DWORD cConnection;
        DWORD dwError;
        
        dwError = RasEnumConnections(prc, &cbSize, &cConnection);
        if (dwError == ERROR_BUFFER_TOO_SMALL)
        {
            pBufferToFree = GlobalAlloc(GPTR, cbSize);

            prc = (RASCONN*) pBufferToFree;
            if (prc)
            {
                prc->dwSize = sizeof(RASCONN);

                dwError = RasEnumConnections(prc, &cbSize, &cConnection);
            }
        }

        if (dwError == ERROR_SUCCESS)
        {
            for (DWORD i = 0; i < cConnection; i++)
            {
                if (!lstrcmp(prc[i].szEntryName, m_szConnectoid))
                {
                    dwError = RasHangUp(prc[i].hrasconn);
                    
                    TRACE2(L"Hangup connection [%s]: %d",
                        prc[i].szEntryName,
                        dwError
                        );
                }
            }
        }

        if (pBufferToFree)
        {
            GlobalFree(pBufferToFree);
        }

        m_bCleanupAutodial = FALSE;
    }
}