|
|
//**********************************************************************
// File name: RefDial.cpp
//
// Implementation of CRefDial
//
// Functions:
//
// Copyright (c) 1992 - 1999 Microsoft Corporation. All rights reserved.
//**********************************************************************
#include "stdafx.h"
#include "icwhelp.h"
#include "RefDial.h"
#include "appdefs.h"
#include <regstr.h>
#include <urlmon.h>
#include <mshtmhst.h>
const TCHAR c_szCreditsMagicNum[] = TEXT("1 425 555 1212");
const TCHAR c_szRegStrValDigitalPID[] = TEXT("DigitalProductId");const TCHAR c_szSignedPIDFName[] = TEXT("signed.pid");
const TCHAR c_szRASProfiles[] = TEXT("RemoteAccess\\Profile");const TCHAR c_szProxyEnable[] = TEXT("ProxyEnable");
TCHAR g_BINTOHEXLookup[16] = { TEXT('0'), TEXT('1'), TEXT('2'), TEXT('3'), TEXT('4'), TEXT('5'), TEXT('6'), TEXT('7'), TEXT('8'), TEXT('9'), TEXT('A'), TEXT('B'), TEXT('C'), TEXT('D'), TEXT('E'), TEXT('F')};
typedef DWORD (WINAPI * GETICWCONNVER) ();GETICWCONNVER lpfnGetIcwconnVer;
HWND g_hwndRNAApp = NULL; /////////////////////////////////////////////////////////////////////////////
// CRefDial
HRESULT CRefDial::OnDraw(ATL_DRAWINFO& di){ return S_OK;}
LRESULT CRefDial::OnCreate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled){ // Register the RASDIALEVENT message
m_unRasDialMsg = RegisterWindowMessageA( RASDIALEVENT ); if (m_unRasDialMsg == 0) { m_unRasDialMsg = WM_RASDIALEVENT; } // Make sure the window is hidden
ShowWindow(SW_HIDE); return 0;}
LRESULT CRefDial::OnDownloadEvent(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled){ USES_CONVERSION; if (uMsg == WM_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.
do { if (!GetExitCodeThread(m_hThread,&dwThreadResults)) { AssertMsg(0,TEXT("CONNECT:GetExitCodeThread failed.\n")); }
iRetries++; if (dwThreadResults == STILL_ACTIVE) Sleep(500); } while (dwThreadResults == STILL_ACTIVE && iRetries < MAX_EXIT_RETRIES);
// See if there is an URL to pass to the container
BSTR bstrURL; if (m_szRefServerURL[0] != TEXT('\0')) bstrURL = (BSTR)A2BSTR(m_szRefServerURL); else bstrURL = NULL;
m_RasStatusID = IDS_DOWNLOAD_COMPLETE; Fire_DownloadComplete(bstrURL, dwThreadResults); // The download is complete now, so we reset this to TRUE, so the RAS
// event handler does not get confused
m_bDownloadHasBeenCanceled = TRUE; // Free any memory allocated above during the conversion
SysFreeString(bstrURL);
} else if (uMsg == WM_DOWNLOAD_PROGRESS) { // Fire a progress event to the container
m_RasStatusID = IDS_DOWNLOADING; Fire_DownloadProgress((long)wParam); } return 0;}
static const TCHAR szRnaAppWindowClass[] = _T("#32770"); // hard coded dialog class name
BOOL NeedZapperEx(void){ OSVERSIONINFO oi; memset(&oi, 0, sizeof(oi)); oi.dwOSVersionInfoSize = sizeof(oi);
if( GetVersionEx(&oi) && (oi.dwPlatformId==VER_PLATFORM_WIN32_WINDOWS) && (oi.dwMajorVersion==4) && (oi.dwMinorVersion==0) && (LOWORD(oi.dwBuildNumber) <= 1070) ) return TRUE; else return FALSE;}
void GetRNAWindowEx(){ TCHAR szTitle[MAX_PATH] = TEXT("\0");
if (!LoadString(_Module.GetModuleInstance(), IDS_CONNECTED, szTitle, ARRAYSIZE(szTitle))) lstrcpy(szTitle , _T("Connected To "));
g_hwndRNAApp = FindWindow(szRnaAppWindowClass, szTitle);}
BOOL MinimizeRNAWindowEx(){ if(g_hwndRNAApp) { // Get the main frame window's style
LONG window_style = GetWindowLong(g_hwndRNAApp, GWL_STYLE);
//Remove the system menu from the window's style
window_style |= WS_MINIMIZE; //set the style attribute of the main frame window
SetWindowLong(g_hwndRNAApp, GWL_STYLE, window_style);
ShowWindow(g_hwndRNAApp, SW_MINIMIZE);
return TRUE; } return FALSE;}
LRESULT CRefDial::OnRasDialEvent(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled){ RNAAPI* pcRNA;
TraceMsg(TF_GENERAL, TEXT("ICWHELP: Ras event %u error code (%ld)\n"),wParam,lParam);
TCHAR dzRasError[10]; wsprintf(dzRasError,TEXT("%d %d"),wParam,lParam); RegSetValue(HKEY_LOCAL_MACHINE,TEXT("Software\\Microsoft\\iSignUp"),REG_SZ,dzRasError,lstrlen(dzRasError)+1);
// In NT4, it gives wParma with error code in lParam rather than a
// actual wParam message
if (lParam) { wParam = RASCS_Disconnected; }
m_RasStatusID = 0; switch(wParam) { case RASCS_OpenPort: m_RasStatusID = IDS_RAS_OPENPORT; break; case RASCS_PortOpened: m_RasStatusID = IDS_RAS_PORTOPENED; break; case RASCS_ConnectDevice: m_RasStatusID = IDS_RAS_DIALING; break; case RASCS_DeviceConnected: m_RasStatusID = IDS_RAS_CONNECTED; break; case RASCS_AllDevicesConnected: m_RasStatusID = IDS_RAS_CONNECTED; break; case RASCS_Authenticate: m_RasStatusID = IDS_RAS_CONNECTING; break; case RASCS_StartAuthentication: case RASCS_LogonNetwork: m_RasStatusID = IDS_RAS_LOCATING; break; case RASCS_Connected: { m_RasStatusID = IDS_RAS_CONNECTED;
//
// Hide RNA window on Win95 retail
//
if (NeedZapperEx()) GetRNAWindowEx(); break; } case RASCS_Disconnected: // Normandy 13184 - ChrisK 1-9-97
m_RasStatusID = IDS_RAS_HANGINGUP; IF_NTONLY // jmazner Normandy #5603 ported from ChrisK's fix in icwdial
// There is a possibility that we will get multiple disconnects in NT
// and we only want to handle the first one. Note: the flag is reset
// in the INITIALIZE event, so we should handle 1 disconnect per instance
// of the dialog.
if (m_bDisconnect) break; else m_bDisconnect = TRUE; ENDIF_NTONLY //
// If we are in the middle of a download, cancel the it!
//
//
// ChrisK 5240 Olympus
// Only the thread that creates the dwDownload should invalidate it
// so we need another method to track if the cancel button has been
// pressed.
//
if (!m_bDownloadHasBeenCanceled) { HINSTANCE hDLDLL = LoadLibrary(DOWNLOAD_LIBRARY); if (hDLDLL) { FARPROC fp = GetProcAddress(hDLDLL,DOWNLOADCANCEL); if(fp) ((PFNDOWNLOADCANCEL)fp)(m_dwDownLoad); FreeLibrary(hDLDLL); hDLDLL = NULL; m_bDownloadHasBeenCanceled = TRUE; } }
// If we get a disconnected status from the RAS server, then
// hangup the modem here
if (m_hrasconn) { pcRNA = new RNAAPI; if (pcRNA) { pcRNA->RasHangUp(m_hrasconn); m_hrasconn = NULL; delete pcRNA; pcRNA = NULL; } } break; }
// Fire the event to the container.
Fire_RasDialStatus((USHORT)wParam);
// If we are connected then fire an event telling the container
// that we are ready
if (wParam == RASCS_Connected) Fire_RasConnectComplete(TRUE); else if (wParam == RASCS_Disconnected) { m_hrDialErr = (HRESULT)lParam; Fire_RasConnectComplete(FALSE); }
return 0;}
STDMETHODIMP CRefDial::get_DownloadStatusString(BSTR * pVal){ USES_CONVERSION; if (pVal == NULL) return E_POINTER; if (m_DownloadStatusID) *pVal = (BSTR)A2BSTR(GetSz((USHORT)m_DownloadStatusID)); else *pVal = (BSTR)A2BSTR(TEXT(""));
return S_OK;}
/******************************************************************************
// 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
//-----------------------------------------------------------------------------
DWORD CRefDial::ReadConnectionInformation(void){ USES_CONVERSION; DWORD hr; TCHAR szUserName[UNLEN+1]; TCHAR szPassword[PWLEN+1]; LPTSTR pszTemp; BOOL bReboot; LPTSTR lpRunOnceCmd; bReboot = FALSE; lpRunOnceCmd = NULL;
//
// Get the name of DUN file from ISP file, if there is one.
//
TCHAR pszDunFile[MAX_PATH];#ifdef UNICODE
hr = GetDataFromISPFile(m_bstrISPFile,INF_SECTION_ISPINFO, INF_DUN_FILE, pszDunFile,MAX_PATH);#else
hr = GetDataFromISPFile(OLE2A(m_bstrISPFile),INF_SECTION_ISPINFO, INF_DUN_FILE, pszDunFile,MAX_PATH);#endif
if (ERROR_SUCCESS == hr) { //
// Get the full path to the DUN File
//
TCHAR 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] != '\0' ? m_szCurrentDUNFile : OLE2A(m_bstrISPFile), m_szISPSupportNumber, m_szEntryName, szUserName, szPassword, &bReboot);
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, TEXT("ICWHELP: User cancelled, quitting.\n")); goto ReadConnectionInformationExit; } else if (hr == ERROR_RETRY) { TraceMsg(TF_GENERAL, TEXT("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, lstrlen(m_szEntryName)+1, REG_SZ, RASENTRYVALUENAME))) { MsgBox(IDS_CANTSAVEKEY,MB_MYERROR); goto ReadConnectionInformationExit; } }
AssertMsg(!bReboot, TEXT("ICWHELP: We should never reboot here.\r\n"));ReadConnectionInformationExit: 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; //
// 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 = (LPTSTR)GlobalAlloc(GPTR, sizeof(TCHAR)*(lstrlen(lpRasEntry->szLocalPhoneNumber)+1)); if (!m_pszDisplayable) { hr = ERROR_NOT_ENOUGH_MEMORY; goto GetDisplayableNumberExit; } lstrcpy(m_szPhoneNumber, lpRasEntry->szLocalPhoneNumber); lstrcpy(m_pszDisplayable, lpRasEntry->szLocalPhoneNumber); TCHAR szAreaCode[MAX_AREACODE+1]; TCHAR szCountryCode[8]; if (SUCCEEDED(tapiGetLocationInfo(szCountryCode,szAreaCode))) { if (szCountryCode[0] != '\0') m_dwCountryCode = _ttoi(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,TEXT("+%lu (%s) %s\0"),lpRasEntry->dwCountryCode, lpRasEntry->szAreaCode,lpRasEntry->szLocalPhoneNumber); else wsprintf(m_szPhoneNumber,TEXT("+%lu %s\0"),lpRasEntry->dwCountryCode, lpRasEntry->szLocalPhoneNumber); //
// Initialize TAPIness
//
dwNumDev = 0; hr = lineInitialize(&m_hLineApp,_Module.GetModuleInstance(),LineCallback,(LPSTR)NULL,&dwNumDev);
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 { hr = lineNegotiateAPIVersion(m_hLineApp, m_dwTapiDev, 0x00010004, 0x00010004, &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);
if (hr != ERROR_SUCCESS || (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; }
m_pszDisplayable = (LPTSTR)GlobalAlloc(GPTR, ((size_t)lpOutput1->dwDisplayableStringSize+1)); if (!m_pszDisplayable) { hr = ERROR_NOT_ENOUGH_MEMORY; goto GetDisplayableNumberExit; }
lstrcpyn(m_pszDisplayable, (LPTSTR)&((LPBYTE)lpOutput1)[lpOutput1->dwDisplayableStringOffset], (int)lpOutput1->dwDisplayableStringSize);
TCHAR szAreaCode[MAX_AREACODE+1]; TCHAR szCountryCode[8]; if (SUCCEEDED(tapiGetLocationInfo(szCountryCode,szAreaCode))) { if (szCountryCode[0] != '\0') m_dwCountryCode = _ttoi(szCountryCode); else m_dwCountryCode = 1; } else { m_dwCountryCode = 1; }
}
GetDisplayableNumberExit:
if (lpOutput1) GlobalFree(lpOutput1); if (m_hLineApp) lineShutdown(m_hLineApp); return hr;}
typedef DWORD (WINAPI* PFNRASDIALA)(LPRASDIALEXTENSIONS,LPSTR,LPRASDIALPARAMSA,DWORD,LPVOID,LPHRASCONN);DWORD CRefDial::MyRasDial( LPRASDIALEXTENSIONS lpRasDialExtensions, LPTSTR lpszPhonebook, LPRASDIALPARAMS lpRasDialParams, DWORD dwNotifierType, LPVOID lpvNotifier, LPHRASCONN lphRasConn){ HRESULT hr; if (!m_hRasDll) m_hRasDll = LoadLibrary(TEXT("RasApi32.dll"));
if (!m_hRasDll) { hr = GetLastError(); goto MyRasDialExit; }
if (m_hRasDll && !m_fpRasDial) m_fpRasDial = GetProcAddress(m_hRasDll,"RasDialA");
if (!m_fpRasDial) { hr = GetLastError(); goto MyRasDialExit; }
if (m_fpRasDial) {#ifdef UNICODE
// RasDialW version always fails to connect.
// I don't know why. So I want to call RasDialA even if this is UNICODE build.
RASDIALPARAMSA RasDialParams; RasDialParams.dwSize = sizeof(RASDIALPARAMSA); wcstombs(RasDialParams.szEntryName, lpRasDialParams->szEntryName, RAS_MaxEntryName+1); wcstombs(RasDialParams.szPhoneNumber, lpRasDialParams->szPhoneNumber, RAS_MaxPhoneNumber+1); wcstombs(RasDialParams.szCallbackNumber, lpRasDialParams->szCallbackNumber, RAS_MaxCallbackNumber+1); wcstombs(RasDialParams.szUserName, lpRasDialParams->szUserName, UNLEN+1); wcstombs(RasDialParams.szPassword, lpRasDialParams->szPassword, PWLEN+1); wcstombs(RasDialParams.szDomain, lpRasDialParams->szDomain, DNLEN+1);
hr = ((PFNRASDIALA)m_fpRasDial)(lpRasDialExtensions,NULL, &RasDialParams, dwNotifierType, (LPVOID) lpvNotifier, lphRasConn);#else
hr = ((PFNRASDIAL)m_fpRasDial)(lpRasDialExtensions,lpszPhonebook, lpRasDialParams, dwNotifierType, (LPVOID) lpvNotifier, lphRasConn);#endif
Assert(hr == ERROR_SUCCESS); } MyRasDialExit: return hr;}
DWORD CRefDial::MyRasGetEntryDialParams( LPTSTR lpszPhonebook, LPRASDIALPARAMS lprasdialparams, LPBOOL lpfPassword){ HRESULT hr;
if (!m_hRasDll) m_hRasDll = LoadLibrary(TEXT("RasApi32.dll"));
if (!m_hRasDll) { hr = GetLastError(); goto MyRasGetEntryDialParamsExit; }
if (m_hRasDll && !m_fpRasGetEntryDialParams)#ifdef UNICODE
m_fpRasGetEntryDialParams = GetProcAddress(m_hRasDll,"RasGetEntryDialParamsW");#else
m_fpRasGetEntryDialParams = GetProcAddress(m_hRasDll,"RasGetEntryDialParamsA");#endif
if (!m_fpRasGetEntryDialParams) { hr = GetLastError(); goto MyRasGetEntryDialParamsExit; }
if (m_fpRasGetEntryDialParams) hr = ((PFNRASGETENTRYDIALPARAMS)m_fpRasGetEntryDialParams)(lpszPhonebook,lprasdialparams,lpfPassword);
MyRasGetEntryDialParamsExit: 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;}
// This function will perform the actual dialing
STDMETHODIMP CRefDial::DoConnect(BOOL * pbRetVal){ USES_CONVERSION;
TCHAR szPassword[PWLEN+2]; LPRASDIALPARAMS lpRasDialParams = NULL; LPRASDIALEXTENSIONS lpRasDialExtentions = NULL; HRESULT hr = ERROR_SUCCESS; BOOL bPW;
// Initialize the dial error member
m_hrDialErr = ERROR_SUCCESS; // 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,ARRAYSIZE(lpRasDialParams->szEntryName)); bPW = FALSE; hr = MyRasGetEntryDialParams(NULL,lpRasDialParams,&bPW); if (hr != ERROR_SUCCESS) { goto DialExit; }
//
// This is only used on WINNT
//
lpRasDialExtentions = (LPRASDIALEXTENSIONS)GlobalAlloc(GPTR,sizeof(RASDIALEXTENSIONS)); if (lpRasDialExtentions) { lpRasDialExtentions->dwSize = sizeof(RASDIALEXTENSIONS); lpRasDialExtentions->dwfOptions = RDEOPT_UsePrefixSuffix; }
//
// Add the user's password
//
szPassword[0] = 0; GetPrivateProfileString(INFFILE_USER_SECTION, INFFILE_PASSWORD, NULLSZ, szPassword, PWLEN + 1, m_szCurrentDUNFile[0] != '\0'? m_szCurrentDUNFile : OLE2A(m_bstrISPFile));
if(szPassword[0]) lstrcpy(lpRasDialParams->szPassword, szPassword); //
// Dial connectoid
//
//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_pcRNA) m_pcRNA->RasHangUp(m_hrasconn); m_hrasconn = NULL;
#if defined(DEBUG)
if (FCampusNetOverride()) { m_bModemOverride = TRUE; }#endif
if (m_bModemOverride) { // Skip dialing because the server is on the campus network
//
PostMessage(RegisterWindowMessageA(RASDIALEVENT),RASCS_Connected,0); hr = ERROR_SUCCESS; } else hr = MyRasDial(lpRasDialExtentions,NULL,lpRasDialParams,0xFFFFFFFF, m_hWnd, &m_hrasconn);
m_bModemOverride = FALSE;
if (( hr != ERROR_SUCCESS) || m_bWaitingToHangup) { // We failed to connect for some reason, so hangup
if (m_hrasconn) { if (!m_pcRNA) m_pcRNA = new RNAAPI; if (!m_pcRNA) { MsgBox(IDS_OUTOFMEMORY,MB_MYERROR); } else { m_pcRNA->RasHangUp(m_hrasconn); m_bWaitingToHangup = FALSE; m_hrasconn = NULL; } } goto DialExit; }
if (lpRasDialParams) GlobalFree(lpRasDialParams); lpRasDialParams = NULL;
DialExit: if (lpRasDialExtentions) GlobalFree(lpRasDialExtentions); lpRasDialExtentions = NULL;
// Set the return value for the method
if (hr != ERROR_SUCCESS) *pbRetVal = FALSE; else *pbRetVal = TRUE;
m_hrDialErr = hr; 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(LPTSTR lpszPhonebookFile, LPTSTR lpszPhonebookEntry, LPRASENTRY *lplpRasEntryBuff, LPDWORD lpdwRasEntryBuffSize, LPRASDEVINFO *lplpRasDevInfoBuff, LPDWORD lpdwRasDevInfoBuffSize){
HRESULT hr; RNAAPI *pcRNA = NULL;
DWORD dwOldDevInfoBuffSize;
Assert( NULL != lplpRasEntryBuff ); Assert( NULL != lpdwRasEntryBuffSize ); Assert( NULL != lplpRasDevInfoBuff ); Assert( NULL != lpdwRasDevInfoBuffSize );
*lpdwRasEntryBuffSize = 0; *lpdwRasDevInfoBuffSize = 0;
pcRNA = new RNAAPI; if (!pcRNA) { 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 = 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) { LPRASENTRY pTemp = m_reflpRasEntryBuff; m_reflpRasEntryBuff = (LPRASENTRY)GlobalReAlloc(pTemp, *lpdwRasEntryBuffSize, GPTR); if (m_reflpRasEntryBuff == NULL) { GlobalFree(pTemp); } } } 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 ) { LPRASDEVINFO pTemp = m_reflpRasDevInfoBuff; m_reflpRasDevInfoBuff = (LPRASDEVINFO)GlobalReAlloc(pTemp,*lpdwRasDevInfoBuffSize, GPTR); if (m_reflpRasDevInfoBuff == NULL) { GlobalFree(pTemp); } } } 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 = 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; }
if( pcRNA ) { delete pcRNA; pcRNA = NULL; }
*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; } if( pcRNA ) { delete pcRNA; pcRNA = NULL; }
*lpdwRasEntryBuffSize = 0; *lpdwRasDevInfoBuffSize = 0; return( hr );}
//+---------------------------------------------------------------------------
//
// Function: LineCallback()
//
// Synopsis: Call back for TAPI line
//
//+---------------------------------------------------------------------------
void CALLBACK LineCallback(DWORD hDevice, DWORD dwMessage, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2, DWORD dwParam3){}
HRESULT MyGetFileVersion(LPCTSTR 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((LPTSTR)pszFileName,&dwTemp); if (!dwSize) { hr = GetLastError(); goto MyGetFileVersionExit; } pv = (LPVOID)GlobalAlloc(GPTR, (size_t)dwSize); if (!pv) goto MyGetFileVersionExit; if (!GetFileVersionInfo((LPTSTR)pszFileName,dwTemp,dwSize,pv)) { hr = GetLastError(); goto MyGetFileVersionExit; }
if (!VerQueryValue(pv,TEXT("\\\0"),&pvVerInfo,&uiSize)) { hr = GetLastError(); goto MyGetFileVersionExit; } pvVerInfo = (LPVOID)((DWORD_PTR)pvVerInfo + sizeof(DWORD)*4); lpGatherInfo->m_szSUVersion[0] = '\0'; dwVerPiece = (*((LPDWORD)pvVerInfo)) >> 16; wsprintf(lpGatherInfo->m_szSUVersion,TEXT("%d."),dwVerPiece);
dwVerPiece = (*((LPDWORD)pvVerInfo)) & 0x0000ffff; wsprintf(lpGatherInfo->m_szSUVersion,TEXT("%s%d."),lpGatherInfo->m_szSUVersion,dwVerPiece);
dwVerPiece = (((LPDWORD)pvVerInfo)[1]) >> 16; wsprintf(lpGatherInfo->m_szSUVersion,TEXT("%s%d."),lpGatherInfo->m_szSUVersion,dwVerPiece);
dwVerPiece = (((LPDWORD)pvVerInfo)[1]) & 0x0000ffff; wsprintf(lpGatherInfo->m_szSUVersion,TEXT("%s%d"),lpGatherInfo->m_szSUVersion,dwVerPiece);
if (!VerQueryValue(pv,TEXT("\\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){ USES_CONVERSION; HKEY hkey = NULL; SYSTEM_INFO si; TCHAR 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] = '\0'; if( GetModuleFileName(_Module.GetModuleInstance(), szTempPath, MAX_PATH)) { if ((MyGetFileVersion(szTempPath, lpGatherInfo)) != ERROR_SUCCESS) { return (GetLastError()); } } else return( GetLastError() );
// OEM code
//
TCHAR szOeminfoPath[MAX_PATH + 1]; TCHAR *lpszTerminator = NULL; TCHAR *lpszLastChar = NULL; TCHAR szTemp[MAX_PATH]; if( 0 != GetSystemDirectory( szOeminfoPath, MAX_PATH + 1 ) ) { lpszTerminator = &(szOeminfoPath[ lstrlen(szOeminfoPath) ]); lpszLastChar = CharPrev( szOeminfoPath, lpszTerminator );
if( '\\' != *lpszLastChar ) { lpszLastChar = CharNext( lpszLastChar ); *lpszLastChar = '\\'; lpszLastChar = CharNext( lpszLastChar ); *lpszLastChar = '\0'; }
lstrcat( szOeminfoPath, ICW_OEMINFO_FILENAME );
//Default oem code must be NULL if it doesn't exist in oeminfo.ini
if (!GetPrivateProfileString(ICW_OEMINFO_OEMSECTION, ICW_OEMINFO_OEMKEY, TEXT(""), m_szOEM, MAX_OEMNAME, szOeminfoPath)) { //oem = (nothing), set to NULL
m_szOEM[0] = '\0'; } // Get the Product Code, Promo code and ALLOFFERS code if they exist
if (GetPrivateProfileString(ICW_OEMINFO_ICWSECTION, ICW_OEMINFO_PRODUCTCODE, DEFAULT_PRODUCTCODE, szTemp, ARRAYSIZE(szTemp), szOeminfoPath)) { m_bstrProductCode = A2BSTR(szTemp); } else m_bstrProductCode = A2BSTR(DEFAULT_PRODUCTCODE); if (GetPrivateProfileString(ICW_OEMINFO_ICWSECTION, ICW_OEMINFO_PROMOCODE, DEFAULT_PROMOCODE, szTemp, ARRAYSIZE(szTemp), szOeminfoPath)) { m_bstrPromoCode = A2BSTR(szTemp); } else m_bstrPromoCode = A2BSTR(DEFAULT_PROMOCODE); m_lAllOffers = GetPrivateProfileInt(ICW_OEMINFO_ICWSECTION, ICW_OEMINFO_ALLOFFERS, 1, szOeminfoPath); }
// 2/20/97 jmazner Olympus #259
if ( RegOpenKey(HKEY_LOCAL_MACHINE,ICWSETTINGSPATH,&hkey) == ERROR_SUCCESS) { DWORD dwSize; DWORD dwType; dwType = REG_SZ; dwSize = sizeof(TCHAR)*(MAX_RELPROD + 1); if (RegQueryValueEx(hkey,RELEASEPRODUCTKEY,NULL,&dwType,(LPBYTE)&lpGatherInfo->m_szRelProd[0],&dwSize) != ERROR_SUCCESS) lpGatherInfo->m_szRelProd[0] = '\0';
dwSize = sizeof(TCHAR)*(MAX_RELVER + 1); if (RegQueryValueEx(hkey,RELEASEVERSIONKEY,NULL,&dwType,(LPBYTE)&lpGatherInfo->m_szRelVer[0],&dwSize) != ERROR_SUCCESS) lpGatherInfo->m_szRelVer[0] = '\0';
RegCloseKey(hkey); }
// PromoCode
lpGatherInfo->m_szPromo[0] = '\0';
TCHAR szPIDPath[MAX_PATH]; // Reg path to the PID
// Form the Path, it is HKLM\\Software\\Microsoft\Windows[ NT]\\CurrentVersion
lstrcpy(szPIDPath, TEXT("Software\\Microsoft\\Windows")); IF_NTONLY lstrcat(szPIDPath, TEXT(" NT")); ENDIF_NTONLY lstrcat(szPIDPath, TEXT("\\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] = '\0'; } else { m_szPID[0] = '\0'; } RegCloseKey(hkey); }
return( dwRet );}
// ############################################################################
HRESULT CRefDial::CreateEntryFromDUNFile(LPTSTR pszDunFile){ TCHAR szFileName[MAX_PATH]; TCHAR szUserName[UNLEN+1]; TCHAR szPassword[PWLEN+1]; LPTSTR 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, lstrlen(m_szEntryName)+1, REG_SZ, RASENTRYVALUENAME))) { goto CreateEntryFromDUNFileExit; } lstrcpy(m_szLastDUNFile, pszDunFile);
CreateEntryFromDUNFileExit: return hr;}
HRESULT CRefDial::UserPickANumber(HWND hWnd, LPGATHERINFO lpGatherInfo, PSUGGESTINFO lpSuggestInfo, HINSTANCE hPHBKDll, DWORD_PTR dwPhoneBook, TCHAR *pszConnectoid, DWORD dwSize, DWORD dwPhoneDisplayFlags){ USES_CONVERSION; HRESULT hr = ERROR_NOT_ENOUGH_MEMORY; FARPROC fp; RASENTRY *prasentry = NULL; RASDEVINFO *prasdevinfo = NULL; DWORD dwRasentrySize = 0; DWORD dwRasdevinfoSize = 0; TCHAR szTemp[256]; TCHAR *ppszDunFiles[1]; TCHAR *ppszTemp[1]; TCHAR szDunFile[12]; BOOL bStatus = TRUE; //
// If the phone book can't find a number let the user pick
//
ppszDunFiles[0] = &szDunFile[0]; lstrcpy(&szDunFile[0],OLE2A(m_bstrISPFile));
fp = GetProcAddress(hPHBKDll, PHBK_DISPLAYAPI); AssertMsg(fp != NULL,TEXT("display access number api is missing")); ppszTemp[0] = szTemp;
//
// donsc - 3/10/98
//
// We have seen at least one code-path that could bring you into
// here with lpSuggestInfo or lpGatherInfo == NULL. That has been
// fixed, but to be defensive, we will ensure that these pointers
// are valid...even if they don't have information, we will still let
// the user pick a number.
SUGGESTINFO SugInfo; GATHERINFO GatInfo; ::ZeroMemory(&SugInfo,sizeof(SugInfo)); ::ZeroMemory(&GatInfo,sizeof(GatInfo));
if(lpSuggestInfo == NULL) { TraceMsg(TF_GENERAL, TEXT("UserPickANumber: lpSuggestInfo is NULL\n")); lpSuggestInfo = &SugInfo; }
if(lpGatherInfo == NULL) { TraceMsg(TF_GENERAL, TEXT("UserPickANumber: lpGatherInfo is NULL\n")); lpGatherInfo = &GatInfo; }
hr = ((PFNPHONEDISPLAY)fp)(dwPhoneBook, ppszTemp, ppszDunFiles, &(lpSuggestInfo->wNumber), &(lpSuggestInfo->dwCountryID), &(lpGatherInfo->m_wState), lpGatherInfo->m_fType, lpGatherInfo->m_bMask, hWnd, dwPhoneDisplayFlags); if (hr != ERROR_SUCCESS) goto UserPickANumberExit;
ZeroMemory(pszConnectoid,dwSize); hr = ReadSignUpReg((LPBYTE)pszConnectoid, &dwSize, REG_SZ, RASENTRYVALUENAME); if (hr != ERROR_SUCCESS) goto UserPickANumberExit;
hr = MyRasGetEntryProperties(NULL, pszConnectoid, &prasentry, &dwRasentrySize, &prasdevinfo, &dwRasdevinfoSize); if (hr != ERROR_SUCCESS) goto UserPickANumberExit; //
// Check to see if the user selected a phone number with a different dun file
// than the one already used to create the connectoid
//
TCHAR szTempPath[MAX_PATH];
// If we did not use dun file last time, assumed we used the default.
if ( *m_szLastDUNFile ) lstrcpy(szTempPath, m_szLastDUNFile); else bStatus = (ERROR_SUCCESS == GetDataFromISPFile(OLE2A(m_bstrISPFile),INF_SECTION_ISPINFO, INF_DUN_FILE,szTempPath,MAX_PATH));
if (bStatus) { if (_tcsicmp(szTempPath,ppszDunFiles[0])) {
//
// Rats, they changed dun files. We now get to build the connectoid
// from scratch
//
if (CreateEntryFromDUNFile(ppszDunFiles[0]) == ERROR_SUCCESS) { prasentry = NULL; dwRasentrySize = 0; prasdevinfo = NULL; dwRasdevinfoSize = 0; hr = MyRasGetEntryProperties(NULL, pszConnectoid, &prasentry, &dwRasentrySize, &prasdevinfo, &dwRasdevinfoSize); if (hr != ERROR_SUCCESS || NULL == prasentry) goto UserPickANumberExit; BreakUpPhoneNumber(prasentry, szTemp); prasentry->dwCountryID = lpSuggestInfo->dwCountryID; } else { hr = ERROR_READING_DUN; goto UserPickANumberExit; } } else { BreakUpPhoneNumber(prasentry, szTemp); prasentry->dwCountryID = lpSuggestInfo->dwCountryID; } } else { hr = ERROR_READING_ISP; goto UserPickANumberExit; }
prasentry->dwfOptions |= RASEO_UseCountryAndAreaCodes; //
// Write out new connectoid
//
if (m_pcRNA) hr = m_pcRNA->RasSetEntryProperties(NULL, pszConnectoid, (LPBYTE)prasentry, dwRasentrySize, (LPBYTE)prasdevinfo, dwRasdevinfoSize); if (hr != ERROR_SUCCESS) goto UserPickANumberExit; return hr;
UserPickANumberExit: TCHAR szBuff256[257]; if (hr == ERROR_READING_ISP) { MsgBox(IDS_CANTREADMSNSUISP, MB_MYERROR); } else if (hr == ERROR_READING_DUN) { MsgBox(IDS_CANTREADMSDUNFILE, MB_MYERROR); } else if (hr == ERROR_PHBK_NOT_FOUND) { wsprintf(szBuff256,GetSz(IDS_CANTLOADINETCFG),TEXT("ICWPHBK.DLL")); MessageBox(szBuff256,GetSz(IDS_TITLE),MB_MYERROR); } else if (hr == ERROR_PHBK_NOT_FOUND) { wsprintf(szBuff256,GetSz(IDS_CANTLOADINETCFG),TEXT("ICWDL.DLL")); MessageBox(szBuff256,GetSz(IDS_TITLE),MB_MYERROR); } else if (hr == ERROR_USERBACK || hr == ERROR_USERCANCEL) { // Do nothing
} else if (hr == ERROR_NOT_ENOUGH_MEMORY) { MsgBox(IDS_OUTOFMEMORY,MB_MYERROR); } else if ((hr == ERROR_NO_MORE_ITEMS) || (hr == ERROR_INVALID_DATA) || (hr == ERROR_FILE_NOT_FOUND)) { MsgBox(IDS_CORRUPTPHONEBOOK, MB_MYERROR); } else if (hr != ERROR_SUCCESS) { wsprintf(szBuff256,TEXT("You can ignore this, just report it and include this number (%d).\n"),hr); AssertMsg(0,szBuff256); }
return hr;}
HRESULT CRefDial::SetupForRASDialing( LPGATHERINFO lpGatherInfo, HINSTANCE hPHBKDll, DWORD_PTR *lpdwPhoneBook, PSUGGESTINFO *ppSuggestInfo, TCHAR *pszConnectoid, BOOL FAR *bConnectiodCreated){ USES_CONVERSION;
HRESULT hr = ERROR_NOT_ENOUGH_MEMORY; FARPROC fp; PSUGGESTINFO pSuggestInfo = NULL; TCHAR szEntry[MAX_RASENTRYNAME]; DWORD dwSize = sizeof(szEntry); RASENTRY *prasentry = NULL; RASDEVINFO *prasdevinfo = NULL; DWORD dwRasentrySize = 0; DWORD dwRasdevinfoSize = 0; HINSTANCE hRasDll =NULL; TCHAR szBuff256[257];
LPRASCONN lprasconn = NULL;
// 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)); Assert(prasdevinfo); 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;
#ifdef UNICODE
// Comment for UNICODE.
// RasGetEntryProperties fails in case of UNICODE
// because of size. So I ask the size first before actual call.
hr = m_pcRNA->RasGetEntryProperties(NULL, szEntry, NULL, &dwRasentrySize, NULL, &dwRasdevinfoSize);#else
hr = m_pcRNA->RasGetEntryProperties(NULL, szEntry, (LPBYTE)prasentry, &dwRasentrySize, (LPBYTE)prasdevinfo, &dwRasdevinfoSize);#endif
if (hr == ERROR_BUFFER_TOO_SMALL) { // Comment for UNICODE.
// This must be happen for UNICODE.
TraceMsg(TF_GENERAL,TEXT("CONNECT:RasGetEntryProperties failed, try a new size.\n")); GlobalFree(prasentry); prasentry = (RASENTRY*)GlobalAlloc(GPTR,((size_t)dwRasentrySize)); prasentry->dwSize = dwRasentrySize;
GlobalFree(prasdevinfo); if(dwRasdevinfoSize > 0) { prasdevinfo = (RASDEVINFO*)GlobalAlloc(GPTR,((size_t)dwRasdevinfoSize)); prasdevinfo->dwSize = dwRasdevinfoSize; } else prasdevinfo = NULL; hr = m_pcRNA->RasGetEntryProperties(NULL, szEntry, (LPBYTE)prasentry, &dwRasentrySize, (LPBYTE)prasdevinfo, &dwRasdevinfoSize); } if (hr != ERROR_SUCCESS) goto SetupForRASDialingExit;
lpGatherInfo->m_wState = 0; lpGatherInfo->m_fType = TYPE_SIGNUP_ANY | (m_ISPImport.m_bIsISDNDevice ? MASK_ISDN_BIT:MASK_ANALOG_BIT); lpGatherInfo->m_bMask = MASK_SIGNUP_ANY | (m_ISPImport.m_bIsISDNDevice ? MASK_ISDN_BIT:MASK_ANALOG_BIT);
//
// Check to see if the phone number was filled in
//
if (lstrcmp(&prasentry->szLocalPhoneNumber[0],DUN_NOPHONENUMBER) == 0) { //
// allocate and intialize memory
//
pSuggestInfo = (PSUGGESTINFO)GlobalAlloc(GPTR,sizeof(SUGGESTINFO)); Assert(pSuggestInfo); if (!pSuggestInfo) { hr = GetLastError(); goto SetupForRASDialingExit; } *ppSuggestInfo = pSuggestInfo; // set phone number type and mask
pSuggestInfo->fType = TYPE_SIGNUP_ANY | (m_ISPImport.m_bIsISDNDevice ? MASK_ISDN_BIT:MASK_ANALOG_BIT); pSuggestInfo->bMask = MASK_SIGNUP_ANY | (m_ISPImport.m_bIsISDNDevice ? MASK_ISDN_BIT:MASK_ANALOG_BIT);
pSuggestInfo->wAreaCode = Sz2W(lpGatherInfo->m_szAreaCode); pSuggestInfo->dwCountryID = lpGatherInfo->m_dwCountry;
// Load Microsoft's phonebook
//
fp = GetProcAddress(hPHBKDll,PHBK_LOADAPI); AssertMsg(fp != NULL,TEXT("PhoneBookLoad is missing from icwphbk.dll"));
hr = ((PFNPHONEBOOKLOAD)fp)(OLE2A(m_bstrISPFile),lpdwPhoneBook); if (hr != ERROR_SUCCESS) goto SetupForRASDialingExit; AssertMsg((*lpdwPhoneBook == TRUE),TEXT("Phonebook Load return no error and 0 for phonebook"));
//
// Load Suggest procedure
//
fp = GetProcAddress(hPHBKDll,PHBK_SUGGESTAPI); AssertMsg(fp != NULL,TEXT("PhoneBookSuggest is missing from icwphbk.dll"));
// Set the number of suggestions
pSuggestInfo->wNumber = NUM_PHBK_SUGGESTIONS; // get phone number
hr = ((PFPHONEBOOKSUGGEST)fp)(*lpdwPhoneBook,pSuggestInfo);
// Inore error because we can continue even without a suggested
// phone number (the user will just have to pick one).
hr = ERROR_SUCCESS; } 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); if (hr == ERROR_READING_ISP) { MsgBox(IDS_CANTREADMSNSUISP, MB_MYERROR); } else if (hr == ERROR_READING_DUN) { MsgBox(IDS_CANTREADMSDUNFILE, MB_MYERROR); } else if (hr == ERROR_PHBK_NOT_FOUND) { wsprintf(szBuff256,GetSz(IDS_CANTLOADINETCFG),TEXT("ICWPHBK.DLL")); MessageBox(szBuff256,GetSz(IDS_TITLE),MB_MYERROR); } else if (hr == ERROR_PHBK_NOT_FOUND) { wsprintf(szBuff256,GetSz(IDS_CANTLOADINETCFG),TEXT("ICWDL.DLL")); MessageBox(szBuff256,GetSz(IDS_TITLE),MB_MYERROR); } else if (hr == ERROR_USERBACK || hr == ERROR_USERCANCEL) { // Do nothing
} else if (hr == ERROR_NOT_ENOUGH_MEMORY) { MsgBox(IDS_OUTOFMEMORY,MB_MYERROR); } else if ((hr == ERROR_NO_MORE_ITEMS) || (hr == ERROR_INVALID_DATA) || (hr == ERROR_FILE_NOT_FOUND)) { MsgBox(IDS_CORRUPTPHONEBOOK, MB_MYERROR); } else if (hr != ERROR_SUCCESS) { wsprintf(szBuff256,TEXT("You can ignore this, just report it and include this number (%d).\n"),hr); AssertMsg(0,szBuff256); } 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, TCHAR *pszConnectoid, DWORD dwSize, BOOL *pbSuccess){ USES_CONVERSION; HRESULT hr = ERROR_NOT_ENOUGH_MEMORY; RASENTRY *prasentry = NULL; RASDEVINFO *prasdevinfo = NULL; DWORD dwRasentrySize = 0; DWORD dwRasdevinfoSize = 0; HINSTANCE hPHBKDll = NULL; HINSTANCE hRasDll =NULL;
LPTSTR lpszSetupFile; LPRASCONN lprasconn = NULL; CMcRegistry reg;
Assert(pbSuccess);
if (!pSuggestInfo) { hr = ERROR_PHBK_NOT_FOUND; goto SetupConnectoidExit; } lpszSetupFile = m_szCurrentDUNFile[0] != '\0' ? m_szCurrentDUNFile : OLE2A(m_bstrISPFile); if (lstrcmp(pSuggestInfo->rgpAccessEntry[irc]->szDataCenter,lpszSetupFile)) { hr = CreateEntryFromDUNFile(pSuggestInfo->rgpAccessEntry[irc]->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; }
hr = MyRasGetEntryProperties(NULL, pszConnectoid, &prasentry, &dwRasentrySize, &prasdevinfo, &dwRasdevinfoSize); if (hr != ERROR_SUCCESS || NULL == prasentry) goto SetupConnectoidExit; } else { // 10/22/96 jmazner Normandy #9923
goto SetupConnectoidExit; } } else { goto SetupConnectoidExit; } prasentry->dwCountryID = pSuggestInfo->rgpAccessEntry[irc]->dwCountryID; lstrcpyn(prasentry->szAreaCode, pSuggestInfo->rgpAccessEntry[irc]->szAreaCode, ARRAYSIZE(prasentry->szAreaCode)); lstrcpyn(prasentry->szLocalPhoneNumber, pSuggestInfo->rgpAccessEntry[irc]->szAccessNumber, ARRAYSIZE(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
TCHAR szConnectionProfile[REGSTR_MAX_VALUE_LENGTH]; lstrcpy(szConnectionProfile, c_szRASProfiles); lstrcat(szConnectionProfile, TEXT("\\")); lstrcat(szConnectionProfile, pszConnectoid); reg.CreateKey(HKEY_CURRENT_USER, szConnectionProfile); reg.SetValue(c_szProxyEnable, (DWORD)0); SetupConnectoidExit:
*pbSuccess = FALSE; TCHAR szBuff256[257]; if (hr == ERROR_READING_ISP) { MsgBox(IDS_CANTREADMSNSUISP, MB_MYERROR); } else if (hr == ERROR_READING_DUN) { MsgBox(IDS_CANTREADMSDUNFILE, MB_MYERROR); } else if (hr == ERROR_PHBK_NOT_FOUND) { wsprintf(szBuff256,GetSz(IDS_CANTLOADINETCFG),TEXT("ICWPHBK.DLL")); MessageBox(szBuff256,GetSz(IDS_TITLE),MB_MYERROR); } else if (hr == ERROR_PHBK_NOT_FOUND) { wsprintf(szBuff256,GetSz(IDS_CANTLOADINETCFG),TEXT("ICWDL.DLL")); MessageBox(szBuff256,GetSz(IDS_TITLE),MB_MYERROR); } else if (hr == ERROR_USERBACK || hr == ERROR_USERCANCEL || hr == ERROR_SUCCESS) { // Do nothing
*pbSuccess = TRUE; } else if (hr == ERROR_NOT_ENOUGH_MEMORY) { MsgBox(IDS_OUTOFMEMORY,MB_MYERROR); } else if ((hr == ERROR_NO_MORE_ITEMS) || (hr == ERROR_INVALID_DATA) || (hr == ERROR_FILE_NOT_FOUND)) { MsgBox(IDS_CORRUPTPHONEBOOK, MB_MYERROR); } else if (hr != ERROR_SUCCESS) { wsprintf(szBuff256,TEXT("You can ignore this, just report it and include this number (%d).\n"),hr); AssertMsg(0,szBuff256); *pbSuccess = TRUE; } return hr;}
// Form the Dialing URL. Must be called after setting up for dialing.
HRESULT CRefDial::FormURL(){ USES_CONVERSION;
TCHAR szTemp[MAX_PATH]; TCHAR szPromo[MAX_PATH]; TCHAR szProd[MAX_PATH]; TCHAR szArea[MAX_PATH]; TCHAR szOEM[MAX_PATH]; DWORD dwCONNWIZVersion = 0; // Version of CONNWIZ.HTM
//
// ChrisK Olympus 3997 5/25/97
//
TCHAR szRelProd[MAX_PATH]; TCHAR szRelProdVer[MAX_PATH]; HRESULT hr = ERROR_SUCCESS; OSVERSIONINFO osvi;
//
// Build URL complete with name value pairs
//
hr = GetDataFromISPFile(OLE2A(m_bstrISPFile),INF_SECTION_ISPINFO, INF_REFERAL_URL,&szTemp[0],256); if ('\0' == szTemp[0]) { MsgBox(IDS_MSNSU_WRONG,MB_MYERROR); return hr; } Assert(szTemp[0]);
ANSI2URLValue(m_szOEM,szOEM,0); ANSI2URLValue(m_lpGatherInfo->m_szAreaCode,szArea,0); if (m_bstrProductCode) ANSI2URLValue(OLE2A((BSTR)m_bstrProductCode),szProd,0); else ANSI2URLValue(DEFAULT_PRODUCTCODE,szProd,0);
if (m_bstrPromoCode) ANSI2URLValue(OLE2A((BSTR)m_bstrPromoCode),szPromo,0); else ANSI2URLValue(DEFAULT_PROMOCODE,szProd,0); //
// ChrisK Olympus 3997 5/25/97
//
ANSI2URLValue(m_lpGatherInfo->m_szRelProd, szRelProd, 0); ANSI2URLValue(m_lpGatherInfo->m_szRelVer, szRelProdVer, 0); ZeroMemory(&osvi,sizeof(OSVERSIONINFO)); osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); if (!GetVersionEx(&osvi)) { ZeroMemory(&osvi,sizeof(OSVERSIONINFO)); }
#if defined(DEBUG)
LoadTestingLocaleOverride(&m_lpGatherInfo->m_dwCountry, &m_lpGatherInfo->m_lcidUser);#endif //DEBUG
HINSTANCE hInstIcwconn = LoadLibrary(ICW_DOWNLOADABLE_COMPONENT_NAME);
if (hInstIcwconn) { lpfnGetIcwconnVer = (GETICWCONNVER)GetProcAddress(hInstIcwconn, ICW_DOWNLOADABLE_COMPONENT_GETVERFUNC); // Get the version of ICWCONN.DLL
if (lpfnGetIcwconnVer) dwCONNWIZVersion = lpfnGetIcwconnVer(); FreeLibrary(hInstIcwconn); }
#if defined(DEBUG)
if (FRefURLOverride()) { TweakRefURL(szTemp, &m_lpGatherInfo->m_lcidUser, &m_lpGatherInfo->m_dwOS, &m_lpGatherInfo->m_dwMajorVersion, &m_lpGatherInfo->m_dwMinorVersion, &m_lpGatherInfo->m_wArchitecture, szPromo, szOEM, szArea, &m_lpGatherInfo->m_dwCountry, &m_lpGatherInfo->m_szSUVersion[0], szProd, &osvi.dwBuildNumber, //For this we really want to LOWORD
szRelProd, szRelProdVer, &dwCONNWIZVersion, m_szPID, &m_lAllOffers); }#endif //DEBUG
// 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,TEXT("%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_dwCountry, &m_lpGatherInfo->m_szSUVersion[0], szProd, LOWORD(osvi.dwBuildNumber), szRelProd, szRelProdVer, dwCONNWIZVersion, m_szPID, m_lpGatherInfo->m_dwFlag);
// Update registry values
//
wsprintf(m_lpGatherInfo->m_szISPFile,TEXT("%s\\%s"),g_pszAppDir,OLE2A(m_bstrISPFile)); lstrcpyn(m_lpGatherInfo->m_szAppDir,g_pszAppDir,ARRAYSIZE(m_lpGatherInfo->m_szAppDir));
StoreInSignUpReg( (LPBYTE)m_lpGatherInfo, sizeof(GATHERINFO), REG_BINARY, GATHERINFOVALUENAME); return hr;}
static const TCHAR cszBrandingSection[] = TEXT("Branding");static const TCHAR cszBrandingFlags[] = TEXT("Flags");
static const TCHAR cszSupportSection[] = TEXT("Support");static const TCHAR cszSupportNumber[] = TEXT("SupportPhoneNumber");
static const TCHAR cszLoggingSection[] = TEXT("Logging");static const TCHAR cszStartURL[] = TEXT("StartURL");static const TCHAR cszEndURL[] = TEXT("EndURL");
void CRefDial::GetISPFileSettings(LPTSTR lpszFile){ TCHAR szTemp[INTERNET_MAX_URL_LENGTH];
GetINTFromISPFile(lpszFile, (LPTSTR)cszBrandingSection, (LPTSTR)cszBrandingFlags, (int FAR *)&m_lBrandingFlags, BRAND_DEFAULT);
// Read the Support Number
if (ERROR_SUCCESS == GetDataFromISPFile(lpszFile, (LPTSTR)cszSupportSection, (LPTSTR)cszSupportNumber, szTemp, ARRAYSIZE(szTemp))) m_bstrSupportNumber = A2BSTR(szTemp); else m_bstrSupportNumber.Empty();
if (ERROR_SUCCESS == GetDataFromISPFile(lpszFile, (LPTSTR)cszLoggingSection, (LPTSTR)cszStartURL, szTemp, ARRAYSIZE(szTemp))) m_bstrLoggingStartUrl = A2BSTR(szTemp); else m_bstrLoggingStartUrl.Empty();
if (ERROR_SUCCESS == GetDataFromISPFile(lpszFile, (LPTSTR)cszLoggingSection, (LPTSTR)cszEndURL, szTemp, ARRAYSIZE(szTemp))) m_bstrLoggingEndUrl = A2BSTR(szTemp); else m_bstrLoggingEndUrl.Empty();
}
// 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.
STDMETHODIMP CRefDial::SetupForDialing( BSTR bstrISPFile, DWORD dwCountry, BSTR bstrAreaCode, DWORD dwFlag, BOOL *pbRetVal){ USES_CONVERSION; HRESULT hr = S_OK; long lRC = 0; LPLINECOUNTRYENTRY pLCETemp; HINSTANCE hPHBKDll = NULL; DWORD_PTR dwPhoneBook = 0; DWORD idx; BOOL bSuccess = FALSE; BOOL bConnectiodCreated = FALSE; // Create a Window. We need a window, which will be hidden, so that we can process RAS status
// messages
RECT rcPos; Create(NULL, rcPos, NULL, 0, 0, 0 ); // Initialize failure codes
*pbRetVal = FALSE; m_bQuitWizard = FALSE; m_bUserPickNumber = FALSE;
// Stuff the Area Code, and Country Code into the GatherInfo struct
Assert(bstrAreaCode); lstrcpy(m_lpGatherInfo->m_szAreaCode,OLE2A(bstrAreaCode));
m_lpGatherInfo->m_dwCountry = dwCountry; m_lpGatherInfo->m_dwFlag = dwFlag;
// Make a copy of the ISP file we should use.
Assert(bstrISPFile); m_bstrISPFile = bstrISPFile;
// Read the ISP file stuff
GetISPFileSettings(OLE2A(m_bstrISPFile));
// Read the Connection File information which will create
// a connectiod from the passed in ISP file
switch(ReadConnectionInformation()) { case ERROR_SUCCESS: { // Fill in static info into the GatherInfo sturct
DWORD dwRet = FillGatherInfoStruct(m_lpGatherInfo); switch( dwRet ) { case ERROR_FILE_NOT_FOUND: MsgBox(IDS_MSNSU_WRONG,MB_MYERROR); m_bQuitWizard = TRUE; hr = S_FALSE; break; case ERROR_SUCCESS: //do nothing
break; default: AssertMsg(dwRet, TEXT("FillGatherInfoStruct did not successfully complete. DUNfile entry corrupt?")); break; } break; } case ERROR_CANCELLED: hr = S_FALSE; m_bQuitWizard = TRUE; goto SetupForDialingExit; break; case ERROR_RETRY: m_bTryAgain = TRUE; hr = S_FALSE; break; default: MsgBox(IDS_MSNSU_WRONG,MB_MYERROR); hr = S_FALSE; break; }
// 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;
// we need to pass a valid window handle to lineTranslateDialog
// API call -MKarki (4/17/97) Fix for Bug #428
//
if (m_lpGatherInfo != NULL) { m_lpGatherInfo->m_hwnd = GetActiveWindow(); }
//
// Fill in country
//
m_lpGatherInfo->m_pLineCountryList = (LPLINECOUNTRYLIST)GlobalAlloc(GPTR,sizeof(LINECOUNTRYLIST)); Assert(m_lpGatherInfo->m_pLineCountryList); if (!(m_lpGatherInfo->m_pLineCountryList)) { m_bQuitWizard = TRUE; MsgBox(IDS_OUTOFMEMORY,MB_MYERROR); goto SetupForDialingExit; } m_lpGatherInfo->m_pLineCountryList->dwTotalSize = sizeof(LINECOUNTRYLIST);
//
// figure out how much memory we will need
//
lRC = lineGetCountry(m_lpGatherInfo->m_dwCountry,0x10004, m_lpGatherInfo->m_pLineCountryList); if ( lRC && lRC != LINEERR_STRUCTURETOOSMALL) AssertMsg(0,TEXT("lineGetCountry error")); Assert(m_lpGatherInfo->m_pLineCountryList->dwNeededSize); LPLINECOUNTRYLIST pLineCountryTemp; pLineCountryTemp = (LPLINECOUNTRYLIST)GlobalAlloc(GPTR, ((size_t)m_lpGatherInfo->m_pLineCountryList->dwNeededSize)); Assert (pLineCountryTemp); if (!pLineCountryTemp) { m_bQuitWizard = TRUE; MsgBox(IDS_OUTOFMEMORY,MB_MYERROR); goto SetupForDialingExit; } //
// initialize structure
//
pLineCountryTemp->dwTotalSize = m_lpGatherInfo->m_pLineCountryList->dwNeededSize; GlobalFree(m_lpGatherInfo->m_pLineCountryList); m_lpGatherInfo->m_pLineCountryList = pLineCountryTemp; pLineCountryTemp = NULL;
//
// fetch information from TAPI
//
lRC = lineGetCountry(m_lpGatherInfo->m_dwCountry,0x10004, m_lpGatherInfo->m_pLineCountryList); if (lRC) { Assert(0); m_bQuitWizard = TRUE; // BUGBUG Probably should have an error message here
goto SetupForDialingExit; }
//
// On Windows 95, lineGetCountry has a bug -- if we try to retrieve the
// dialing properties of just one country (i.e, if the first parameter is
// not zero), it returns m_pLineCountryList->dwNumCountries = 0!!
// But the m_pLineCountryList still has valid data
//
if (VER_PLATFORM_WIN32_NT != g_dwPlatform) { if (0 == m_lpGatherInfo->m_pLineCountryList->dwNumCountries) m_lpGatherInfo->m_pLineCountryList->dwNumCountries = 1; }
pLCETemp = (LPLINECOUNTRYENTRY)((UINT_PTR)m_lpGatherInfo->m_pLineCountryList + (UINT)m_lpGatherInfo->m_pLineCountryList->dwCountryListOffset);
//
// build look up array
//
m_lpGatherInfo->m_rgNameLookUp = (LPCNTRYNAMELOOKUPELEMENT)GlobalAlloc(GPTR,((size_t)(sizeof(CNTRYNAMELOOKUPELEMENT) * m_lpGatherInfo->m_pLineCountryList->dwNumCountries)));
for (idx=0; idx < m_lpGatherInfo->m_pLineCountryList->dwNumCountries; idx++) { m_lpGatherInfo->m_rgNameLookUp[idx].psCountryName = (LPTSTR)((DWORD_PTR)m_lpGatherInfo->m_pLineCountryList + (DWORD)pLCETemp[idx].dwCountryNameOffset); m_lpGatherInfo->m_rgNameLookUp[idx].dwNameSize = pLCETemp[idx].dwCountryNameSize; m_lpGatherInfo->m_rgNameLookUp[idx].pLCE = &pLCETemp[idx]; AssertMsg(m_lpGatherInfo->m_rgNameLookUp[idx].psCountryName[0], TEXT("Blank country name in look up array")); }
// Prepare to Setup for Dialing, which will use the phonebook
// to get a suggested number
hPHBKDll = LoadLibrary(PHONEBOOK_LIBRARY); AssertMsg(hPHBKDll != NULL,TEXT("Phonebook DLL is missing")); if (!hPHBKDll) { //
// TODO: BUGBUG Pop-up error message
//
m_bQuitWizard = TRUE; goto SetupForDialingExit; }
// Setup, and possible create a connectiod
hr = SetupForRASDialing(m_lpGatherInfo, hPHBKDll, &dwPhoneBook, &m_pSuggestInfo, &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_pSuggestInfo->wNumber) { SetupConnectoid(m_pSuggestInfo, 0, &m_szConnectoid[0], sizeof(m_szConnectoid), &bSuccess); if( !bSuccess ) { m_bQuitWizard = TRUE; goto SetupForDialingExit; } } else { // More than 1 entry in the Phonebook, so we need to
// ask the user which one they want to use
if (m_pSuggestInfo->wNumber > 1) { // we are going to have to save these values for later
if (m_rgpSuggestedAE) { // We allocated an extra pointer so we'd have NULL on the
// end of the list and this for loop will work
for (int i=0; m_rgpSuggestedAE[i]; i++) GlobalFree(m_rgpSuggestedAE[i]); GlobalFree(m_rgpSuggestedAE); m_rgpSuggestedAE = NULL; }
// We first need to allocate space for the pointers.
// We'll allocate an extra one so that we will have
// a NULL pointer at the end of the list for when
// we free g_rgpSuggestedAE. We don't need to set
// the pointers to NULL because GPTR includes a flag
// to tell GlobalAlloc to initialize the memory to zero.
m_rgpSuggestedAE = (PACCESSENTRY*)GlobalAlloc(GPTR, sizeof(PACCESSENTRY)*(m_pSuggestInfo->wNumber + 1));
if (NULL == m_rgpSuggestedAE) hr = E_ABORT; else if (m_pSuggestInfo->rgpAccessEntry) { for (UINT i=0; i < m_pSuggestInfo->wNumber; i++) { m_rgpSuggestedAE[i] = (PACCESSENTRY)GlobalAlloc(GPTR, sizeof(ACCESSENTRY)); if (NULL == m_rgpSuggestedAE[i]) { hr = E_ABORT; break; // for loop
} memmove(m_rgpSuggestedAE[i], m_pSuggestInfo->rgpAccessEntry[i], sizeof(ACCESSENTRY)); } m_pSuggestInfo->rgpAccessEntry = m_rgpSuggestedAE; }
if (E_ABORT == hr) { MsgBox(IDS_OUTOFMEMORY,MB_MYERROR); m_bQuitWizard = TRUE; goto SetupForDialingExit; }
m_bUserPickNumber = TRUE; goto SetupForDialingExit; } else { // Call RAS to have the user pick a number to dial
hr = UserPickANumber( GetActiveWindow(), m_lpGatherInfo, m_pSuggestInfo, hPHBKDll, dwPhoneBook, &m_szConnectoid[0], sizeof(m_szConnectoid), 0); if (ERROR_USERBACK == hr) { goto SetupForDialingExit; } else if (ERROR_USERCANCEL == hr) { m_bQuitWizard = TRUE; goto SetupForDialingExit; } else if (ERROR_SUCCESS != hr) { // Go back to prev page.
goto SetupForDialingExit; }
// Error SUCCESS will fall through and set pbRetVal to TRUE below
} } }
// Success if we get to here
*pbRetVal = TRUE;
// Generate a Displayable number
m_hrDisplayableNumber = GetDisplayableNumber();
SetupForDialingExit:
if (hPHBKDll) { if (dwPhoneBook) { FARPROC fp = GetProcAddress(hPHBKDll,PHBK_UNLOADAPI); ASSERT(fp); ((PFNPHONEBOOKUNLOAD)fp)(dwPhoneBook); dwPhoneBook = 0; } FreeLibrary(hPHBKDll); hPHBKDll = NULL; } return S_OK;}
STDMETHODIMP CRefDial::RemoveConnectoid(BOOL * pVal){ if (m_hrasconn) DoHangup();
if (m_pSuggestInfo) { GlobalFree(m_pSuggestInfo->rgpAccessEntry); GlobalFree(m_pSuggestInfo); m_pSuggestInfo = NULL; }
if( (m_pcRNA!=NULL) && (m_szConnectoid[0]!='\0') ) { m_pcRNA->RasDeleteEntry(NULL,m_szConnectoid); delete m_pcRNA; m_pcRNA = NULL; } return S_OK;}
STDMETHODIMP CRefDial::get_QuitWizard(BOOL * pVal){ if (pVal == NULL) return E_POINTER; *pVal = m_bQuitWizard; return S_OK;}
STDMETHODIMP CRefDial::get_UserPickNumber(BOOL * pVal){ if (pVal == NULL) return E_POINTER; *pVal = m_bUserPickNumber; return S_OK;}
STDMETHODIMP CRefDial::get_DialPhoneNumber(BSTR * pVal){ USES_CONVERSION; if (pVal == NULL) return E_POINTER; if (m_hrDisplayableNumber == ERROR_SUCCESS) *pVal = A2BSTR(m_pszDisplayable); else *pVal = A2BSTR(m_szPhoneNumber); return S_OK;}
STDMETHODIMP CRefDial::put_DialPhoneNumber(BSTR newVal){ USES_CONVERSION;
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, OLE2A(newVal));
// non-zero dummy values are required due to bugs in win95
lpRasEntry->dwCountryID = 1; lpRasEntry->dwCountryCode = 1; lpRasEntry->szAreaCode[1] = '\0'; lpRasEntry->szAreaCode[0] = '8';
// Set to dial as is
//
lpRasEntry->dwfOptions &= ~RASEO_UseCountryAndAreaCodes;
pcRNA = new RNAAPI; if (pcRNA) {#if defined(DEBUG)
TCHAR szMsg[256]; OutputDebugString(TEXT("CRefDial::put_DialPhoneNumber - MyRasGetEntryProperties()")); wsprintf(szMsg, TEXT("lpRasEntry->dwfOptions: %ld"), lpRasEntry->dwfOptions); OutputDebugString(szMsg); wsprintf(szMsg, TEXT("lpRasEntry->dwCountryID: %ld"), lpRasEntry->dwCountryID); OutputDebugString(szMsg); wsprintf(szMsg, TEXT("lpRasEntry->dwCountryCode: %ld"), lpRasEntry->dwCountryCode); OutputDebugString(szMsg); wsprintf(szMsg, TEXT("lpRasEntry->szAreaCode: %s"), lpRasEntry->szAreaCode); OutputDebugString(szMsg); wsprintf(szMsg, TEXT("lpRasEntry->szLocalPhoneNumber: %s"), lpRasEntry->szLocalPhoneNumber); OutputDebugString(szMsg); wsprintf(szMsg, TEXT("lpRasEntry->dwAlternateOffset: %ld"), lpRasEntry->dwAlternateOffset); OutputDebugString(szMsg);#endif //DEBUG
pcRNA->RasSetEntryProperties(NULL, m_szConnectoid, (LPBYTE)lpRasEntry, dwRasEntrySize, (LPBYTE)lpRasDevInfo, dwRasDevInfoSize);
delete pcRNA; } }
// Regenerate the displayable number
GetDisplayableNumber();
return S_OK;}
STDMETHODIMP CRefDial::get_URL(BSTR * pVal){ USES_CONVERSION; TCHAR szTemp[256];
if (pVal == NULL) return E_POINTER;
// Get the URL from the ISP file, and then convert it
if (SUCCEEDED(GetDataFromISPFile(OLE2A(m_bstrISPFile),INF_SECTION_ISPINFO, INF_REFERAL_URL,&szTemp[0],256))) { *pVal = A2BSTR(szTemp); } else { *pVal = NULL; } return S_OK;}
STDMETHODIMP CRefDial::get_PromoCode(BSTR * pVal){ if (pVal == NULL) return E_POINTER; *pVal = m_bstrPromoCode.Copy(); return S_OK;}
STDMETHODIMP CRefDial::put_PromoCode(BSTR newVal){ if (newVal && wcslen(newVal)) m_bstrPromoCode = newVal; return S_OK;}
STDMETHODIMP CRefDial::get_ProductCode(BSTR * pVal){ if (pVal == NULL) return E_POINTER; *pVal = m_bstrProductCode; return S_OK;}
STDMETHODIMP CRefDial::put_ProductCode(BSTR newVal){ if (newVal && wcslen(newVal)) m_bstrProductCode = newVal; return S_OK;}
STDMETHODIMP CRefDial::put_OemCode(BSTR newVal){ USES_CONVERSION;
if (newVal && wcslen(newVal)) lstrcpy(m_szOEM, OLE2A(newVal)); return S_OK;}
STDMETHODIMP CRefDial::put_AllOfferCode(long newVal){ m_lAllOffers = newVal; return S_OK;}
//+---------------------------------------------------------------------------
//
// Function: DoOfferDownload
//
// Synopsis: Download the ISP offer from the ISP server
//
//+---------------------------------------------------------------------------
STDMETHODIMP 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;}
STDMETHODIMP CRefDial::get_DialStatusString(BSTR * pVal){ USES_CONVERSION; if (pVal == NULL) return E_POINTER; if (m_RasStatusID) { if (m_bRedial) { switch (m_RasStatusID) { case IDS_RAS_DIALING: case IDS_RAS_PORTOPENED: case IDS_RAS_OPENPORT: { *pVal = A2BSTR(GetSz(IDS_RAS_REDIALING)); return S_OK; } default: break; } } *pVal = A2BSTR(GetSz((USHORT)m_RasStatusID)); } else *pVal = A2BSTR(TEXT(""));
return S_OK;}
//+---------------------------------------------------------------------------
//
// Function: DoInit
//
// Synopsis: Initialize cancel status and the displayable number for this
// round of dialing.
//
//+---------------------------------------------------------------------------
STDMETHODIMP CRefDial::DoInit(){ m_bWaitingToHangup = FALSE;
// Update the phone number to display if user has changed dialing properties
// This function should be called re-init the dialing properties.
// SetupforDialing should be called prior to this.
GetDisplayableNumber(); return S_OK;}
//+---------------------------------------------------------------------------
//
// Function: DoHangup
//
// Synopsis: Hangup the modem for the currently active RAS session
//
//+---------------------------------------------------------------------------
STDMETHODIMP CRefDial::DoHangup(){ RNAAPI *pcRNA;
// 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 hangup
m_bWaitingToHangup = TRUE; if (NULL != m_hrasconn) { pcRNA = new RNAAPI; if (pcRNA) { pcRNA->RasHangUp(m_hrasconn); m_hrasconn = NULL; delete pcRNA; pcRNA = NULL; } }
return (m_hrasconn == NULL) ? S_OK : E_POINTER;}
STDMETHODIMP CRefDial::ProcessSignedPID(BOOL * pbRetVal){ USES_CONVERSION; HANDLE hfile; DWORD dwFileSize; DWORD dwBytesRead; LPBYTE lpbSignedPID; LPTSTR 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 TCHAR[(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] = '\0';
// Convert the signed pid to a BSTR
m_bstrSignedPID = A2BSTR(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;}
STDMETHODIMP CRefDial::get_SignedPID(BSTR * pVal){ if (pVal == NULL) return E_POINTER; *pVal = m_bstrSignedPID.Copy(); return S_OK;}
STDMETHODIMP CRefDial::FormReferralServerURL(BOOL * pbRetVal){ // Form the URL to be used to access the referal server
if (ERROR_SUCCESS != FormURL()) *pbRetVal = FALSE; else *pbRetVal = TRUE;
return S_OK;}
STDMETHODIMP CRefDial::get_SignupURL(BSTR * pVal){ USES_CONVERSION; TCHAR szTemp[256];
if (pVal == NULL) return E_POINTER;
// Get the URL from the ISP file, and then convert it
if (SUCCEEDED(GetDataFromISPFile(OLE2A(m_bstrISPFile),INF_SECTION_URL, INF_SIGNUP_URL,&szTemp[0],256))) { *pVal = A2BSTR(szTemp); } else { *pVal = NULL; } return S_OK;}
STDMETHODIMP CRefDial::get_AutoConfigURL(BSTR * pVal){ USES_CONVERSION; TCHAR szTemp[256];
if (pVal == NULL) return E_POINTER;
// Get the URL from the ISP file, and then convert it
if (SUCCEEDED(GetDataFromISPFile(OLE2A(m_bstrISPFile),INF_SECTION_URL, INF_AUTOCONFIG_URL,&szTemp[0],256))) { *pVal = A2BSTR(szTemp); } else { *pVal = NULL; } return S_OK;}
STDMETHODIMP CRefDial::get_ISDNURL(BSTR * pVal){ USES_CONVERSION; TCHAR szTemp[256];
if (pVal == NULL) return E_POINTER;
// Get the ISDN URL from the ISP file, and then convert it
if (SUCCEEDED(GetDataFromISPFile(OLE2A(m_bstrISPFile),INF_SECTION_URL, INF_ISDN_URL,&szTemp[0],256))) { *pVal = A2BSTR(szTemp); } else { *pVal = NULL; } if (0 == szTemp[0] || NULL == *pVal) { // Get the sign up URL from the ISP file, and then convert it
if (SUCCEEDED(GetDataFromISPFile(OLE2A(m_bstrISPFile),INF_SECTION_URL, INF_SIGNUP_URL,&szTemp[0],256))) { *pVal = A2BSTR(szTemp); } else { *pVal = NULL; }
} return S_OK;}
STDMETHODIMP CRefDial::get_ISDNAutoConfigURL(BSTR * pVal){ USES_CONVERSION; TCHAR szTemp[256];
if (pVal == NULL) return E_POINTER;
// Get the URL from the ISP file, and then convert it
if (SUCCEEDED(GetDataFromISPFile(OLE2A(m_bstrISPFile),INF_SECTION_URL, INF_ISDN_AUTOCONFIG_URL,&szTemp[0],256))) { *pVal = A2BSTR(szTemp); } else { *pVal = NULL; } return S_OK;}
STDMETHODIMP CRefDial::get_TryAgain(BOOL * pVal){ if (pVal == NULL) return E_POINTER; *pVal = m_bTryAgain; return S_OK;}
STDMETHODIMP CRefDial::get_DialError(HRESULT * pVal){ *pVal = m_hrDialErr; return S_OK;}
STDMETHODIMP CRefDial::put_ModemOverride(BOOL newbVal){ m_bModemOverride = newbVal; return S_OK;}
STDMETHODIMP CRefDial::put_Redial(BOOL newbVal){ m_bRedial = newbVal;
return S_OK;}
STDMETHODIMP CRefDial::get_DialErrorMsg(BSTR * pVal){ USES_CONVERSION;
if (pVal == NULL) return E_POINTER;
if (m_hrDialErr != ERROR_SUCCESS) { DWORD dwIDS = RasErrorToIDS(m_hrDialErr); if (dwIDS != -1 && dwIDS !=0) { *pVal = A2BSTR(GetSz((WORD)dwIDS)); } else { *pVal = A2BSTR(GetSz(IDS_PPPRANDOMFAILURE)); } } else { *pVal = A2BSTR(GetSz(IDS_PPPRANDOMFAILURE)); } return S_OK;}
STDMETHODIMP CRefDial::ModemEnum_Reset(){ m_emModemEnum.ResetIndex();
return S_OK;}
STDMETHODIMP CRefDial::ModemEnum_Next(BSTR *pDeviceName){ if (pDeviceName == NULL) return E_POINTER;
*pDeviceName = A2BSTR(m_emModemEnum.Next()); return S_OK;}
STDMETHODIMP CRefDial::get_ModemEnum_NumDevices(long * pVal){ if (pVal == NULL) return E_POINTER;
m_emModemEnum.ReInit(); *pVal = m_emModemEnum.GetNumDevices();
if(m_ISPImport.m_szDeviceName[0]!='\0') { //
// Find out what the current device index is
//
for(int l=0; l<(*pVal); l++) { if(lstrcmp(m_ISPImport.m_szDeviceName,m_emModemEnum.GetDeviceName(l))==0) { m_lCurrentModem = l; break; } } if(l == (*pVal)) m_lCurrentModem = -1; } else m_lCurrentModem = -1; return S_OK;}
STDMETHODIMP CRefDial::get_SupportNumber(BSTR * pVal){ USES_CONVERSION;
TCHAR szSupportNumber[MAX_PATH];
if (pVal == NULL) return E_POINTER;
if (m_SupportInfo.GetSupportInfo(szSupportNumber, m_dwCountryCode)) *pVal = A2BSTR(szSupportNumber); else *pVal = NULL;
return S_OK;}
STDMETHODIMP CRefDial::get_ISPSupportNumber(BSTR * pVal){ USES_CONVERSION;
if (pVal == NULL) return E_POINTER;
if (*m_szISPSupportNumber) *pVal = A2BSTR(m_szISPSupportNumber); else *pVal = NULL;
return S_OK;}
STDMETHODIMP CRefDial::ShowDialingProperties(BOOL * pbRetVal){ HRESULT hr; DWORD dwNumDev = 0;
*pbRetVal = FALSE; hr = lineInitialize(&m_hLineApp,_Module.GetModuleInstance(),LineCallback,(LPSTR)NULL,&dwNumDev);
if (hr == ERROR_SUCCESS) { LPLINEEXTENSIONID lpExtensionID; if (m_dwTapiDev == 0xFFFFFFFF) { m_dwTapiDev = 0; }
lpExtensionID = (LPLINEEXTENSIONID)GlobalAlloc(GPTR,sizeof(LINEEXTENSIONID)); if (lpExtensionID) { //
// Negotiate version - without this call
// lineTranslateDialog would fail
//
do { hr = lineNegotiateAPIVersion(m_hLineApp, m_dwTapiDev, 0x00010004, 0x00010004, &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
//
GlobalFree(lpExtensionID); lpExtensionID = NULL;
if (hr == ERROR_SUCCESS) { hr = lineTranslateDialog(m_hLineApp, m_dwTapiDev, m_dwAPIVersion, GetActiveWindow(), m_szPhoneNumber);
lineShutdown(m_hLineApp); m_hLineApp = NULL; } } } if (hr == ERROR_SUCCESS) { GetDisplayableNumber(); *pbRetVal = TRUE; } return S_OK;}
STDMETHODIMP CRefDial::ShowPhoneBook(DWORD dwCountryCode, long newVal, BOOL * pbRetVal){ USES_CONVERSION;
DWORD_PTR dwPhoneBook; HINSTANCE hPHBKDll; FARPROC fp; BOOL bBookLoaded = FALSE;
*pbRetVal = FALSE; // Assume Failure
hPHBKDll = LoadLibrary(PHONEBOOK_LIBRARY); if (hPHBKDll) { if (NULL != (fp = GetProcAddress(hPHBKDll,PHBK_LOADAPI))) { if (ERROR_SUCCESS == ((PFNPHONEBOOKLOAD)fp)(OLE2A(m_bstrISPFile),&dwPhoneBook)) { bBookLoaded = TRUE; m_pSuggestInfo->dwCountryID = dwCountryCode;
// Update the device type so we can distinguish ISDN numbers
TCHAR *pszNewType = m_emModemEnum.GetDeviceType(newVal); m_ISPImport.m_bIsISDNDevice = (lstrcmpi(pszNewType, RASDT_Isdn) == 0); m_lpGatherInfo->m_fType = TYPE_SIGNUP_ANY | (m_ISPImport.m_bIsISDNDevice ? MASK_ISDN_BIT:MASK_ANALOG_BIT); m_lpGatherInfo->m_bMask = MASK_SIGNUP_ANY | (m_ISPImport.m_bIsISDNDevice ? MASK_ISDN_BIT:MASK_ANALOG_BIT);
if (ERROR_SUCCESS == UserPickANumber(GetActiveWindow(), m_lpGatherInfo, m_pSuggestInfo, hPHBKDll, dwPhoneBook, &m_szConnectoid[0], sizeof(m_szConnectoid), DIALERR_IN_PROGRESS)) { // Regenerate the displayable number
GetDisplayableNumber(); // Base the Country code on the ras entry, since it was
// directly modified in this case
LPRASENTRY lpRasEntry = NULL; LPRASDEVINFO lpRasDevInfo = NULL; DWORD dwRasEntrySize = 0; DWORD dwRasDevInfoSize = 0; if (SUCCEEDED(MyRasGetEntryProperties(NULL, m_szConnectoid, &lpRasEntry, &dwRasEntrySize, &lpRasDevInfo, &dwRasDevInfoSize))) { m_dwCountryCode = lpRasEntry->dwCountryCode; } // Set the return code
*pbRetVal = TRUE; } } } FreeLibrary(hPHBKDll); }
if (! bBookLoaded) { // Give the user a message
MsgBox(IDS_CANTINITPHONEBOOK,MB_MYERROR); } return S_OK;}
BOOL CRefDial::IsSBCSString( TCHAR *sz ){ Assert(sz);
#ifdef UNICODE
// Check if the string contains only ASCII chars.
int attrib = IS_TEXT_UNICODE_ASCII16 | IS_TEXT_UNICODE_CONTROLS; return (BOOL)IsTextUnicode(sz, lstrlen(sz), &attrib);#else
while( NULL != *sz ) { if (IsDBCSLeadByte(*sz)) return FALSE; sz++; }
return TRUE;#endif
}
TCHAR szValidPhoneCharacters[] = {TEXT("0123456789AaBbCcDdPpTtWw!@$ -.()+*#,&\0")};
STDMETHODIMP CRefDial::ValidatePhoneNumber(BSTR bstrPhoneNumber, BOOL * pbRetVal){ USES_CONVERSION;
// Bail if an empty string is passed
if (!bstrPhoneNumber || !wcslen(bstrPhoneNumber)) { MsgBox(IDS_INVALIDPHONE,MB_MYERROR); *pbRetVal = FALSE; return(S_OK); } // Check that the phone number only contains valid characters
LPTSTR lpNum, lpValid; LPTSTR lpszDialNumber = OLE2A(bstrPhoneNumber);
// vyung 03/06/99 Remove Easter egg as requested by NT5
#ifdef ICW_EASTEREGG
if (lstrcmp(lpszDialNumber, c_szCreditsMagicNum) == 0) { ShowCredits(); *pbRetVal = FALSE; return(S_OK); }#endif
*pbRetVal = TRUE;
if (!IsSBCSString(lpszDialNumber)) { MsgBox(IDS_SBCSONLY,MB_MYEXCLAMATION); *pbRetVal = FALSE; } else {
for (lpNum = lpszDialNumber;*lpNum;lpNum++) { for(lpValid = szValidPhoneCharacters;*lpValid;lpValid++) { if (*lpNum == *lpValid) { break; // p2 for loop
} } if (!*lpValid) { break; // p for loop
} } }
if (*lpNum) { MsgBox(IDS_INVALIDPHONE,MB_MYERROR); *pbRetVal = FALSE; }
return S_OK;}
STDMETHODIMP CRefDial::get_HavePhoneBook(BOOL * pVal){ USES_CONVERSION;
DWORD_PTR dwPhoneBook; HINSTANCE hPHBKDll; FARPROC fp;
if (pVal == NULL) return E_POINTER;
// Assume failure.
*pVal = FALSE;
// Try to load the phone book
hPHBKDll = LoadLibrary(PHONEBOOK_LIBRARY); if (hPHBKDll) { if (NULL != (fp = GetProcAddress(hPHBKDll,PHBK_LOADAPI))) { if (ERROR_SUCCESS == ((PFNPHONEBOOKLOAD)fp)(OLE2A(m_bstrISPFile),&dwPhoneBook)) { *pVal = TRUE; // Got IT!
} } FreeLibrary(hPHBKDll); } return S_OK;}
STDMETHODIMP CRefDial::get_BrandingFlags(long * pVal){ if (pVal == NULL) return E_POINTER;
*pVal = m_lBrandingFlags;
return S_OK;}
STDMETHODIMP CRefDial::put_BrandingFlags(long newVal){ m_lBrandingFlags = newVal;
return S_OK;}
/**********************************************************************///
// FUNCTION: get_CurrentModem
// put_CurrentModem
//
// DESCRIPTION:
// These functions are used to set the current modem
// based on the enumerated modem list, and should only
// be used after taking a snapshot of the modem list
// with the ModemEnum_* functions. The functions are also
// intended to be used with an existing RAS connectoid, not
// to set-up the RefDial object before connecting.
//
// HISTORY:
//
// donsc - 3/11/98 Added these functions to support the dial error
// page in the HTML JavaScript code.
//
/**********************************************************************/
//
// get_CurrentModem will return -1 if the modem list was not enumerated
// or no modem has been selected for this RefDial object
//
STDMETHODIMP CRefDial::get_CurrentModem(long * pVal){ if (pVal == NULL) return E_POINTER;
*pVal = m_lCurrentModem;
return S_OK;}
STDMETHODIMP CRefDial::put_CurrentModem(long newVal){ LPRASENTRY lpRasEntry = NULL; LPRASDEVINFO lpRasDevInfo = NULL; DWORD dwRasEntrySize = 0; DWORD dwRasDevInfoSize = 0; RNAAPI *pcRNA = NULL; HRESULT hr = S_OK;
TCHAR *pszNewName = m_emModemEnum.GetDeviceName(newVal); TCHAR *pszNewType = m_emModemEnum.GetDeviceType(newVal);
if((pszNewName==NULL) || (pszNewType==NULL)) return E_INVALIDARG;
if(m_lCurrentModem == newVal) return S_OK;
//
// Must have a connectoid already established to set the
// current modem.
//
if(m_szConnectoid[0]=='\0') return E_FAIL;
// Get the current RAS entry properties
hr = MyRasGetEntryProperties(NULL, m_szConnectoid, &lpRasEntry, &dwRasEntrySize, &lpRasDevInfo, &dwRasDevInfoSize);
//
// The MyRas function returns 0 on success, not technically
// an HRESULT
//
if(hr!=0 || NULL == lpRasEntry) hr = E_FAIL;
lpRasDevInfo = NULL; dwRasDevInfoSize = 0;
if (SUCCEEDED(hr)) { //
// Retrieve the dial entry params of the existing entry
//
LPRASDIALPARAMS lpRasDialParams = (LPRASDIALPARAMS)GlobalAlloc(GPTR,sizeof(RASDIALPARAMS)); BOOL bPW = FALSE;
if (!lpRasDialParams) { hr = ERROR_NOT_ENOUGH_MEMORY; goto PutModemExit; } lpRasDialParams->dwSize = sizeof(RASDIALPARAMS); lstrcpyn(lpRasDialParams->szEntryName,m_szConnectoid,ARRAYSIZE(lpRasDialParams->szEntryName)); bPW = FALSE; hr = MyRasGetEntryDialParams(NULL,lpRasDialParams,&bPW); if (FAILED(hr)) goto PutModemExit;
//
// Enter the new ras device info.
//
lstrcpy(lpRasEntry->szDeviceName,pszNewName); lstrcpy(lpRasEntry->szDeviceType,pszNewType);
//
// Set to dial as is
//
pcRNA = new RNAAPI; if (pcRNA) { //
// When changing the actual device, it is not always reliable
// to just set the new properties. We need to remove the
// previous entry and create a new one.
//
pcRNA->RasDeleteEntry(NULL,m_szConnectoid); if(pcRNA->RasSetEntryProperties(NULL, m_szConnectoid, (LPBYTE)lpRasEntry, dwRasEntrySize, (LPBYTE)NULL, 0)==0) { //
// And set the other dialing parameters
//
if(pcRNA->RasSetEntryDialParams(NULL,lpRasDialParams,!bPW)!=0) hr = E_FAIL; } else hr = E_FAIL;
delete pcRNA; } else hr = E_FAIL;
GlobalFree(lpRasDialParams); }
PutModemExit:
if(SUCCEEDED(hr)) { m_lCurrentModem = newVal; lstrcpy(m_ISPImport.m_szDeviceName,pszNewName); lstrcpy(m_ISPImport.m_szDeviceType,pszNewType); // Get the device name and type in the registry, since ConfigRasEntryDevice
// will use them. ConfigRasEntryDevice is called when the new connectoid
// is being created, so if the user changes the modem, we want that
// reflected in the new connectoid (BUG 20841)
m_ISPImport.SetDeviceSelectedByUser(DEVICENAMEKEY, pszNewName); m_ISPImport.SetDeviceSelectedByUser (DEVICETYPEKEY, pszNewType);
m_ISPImport.m_bIsISDNDevice = (lstrcmpi(pszNewType, RASDT_Isdn) == 0); m_lpGatherInfo->m_fType = TYPE_SIGNUP_ANY | (m_ISPImport.m_bIsISDNDevice ? MASK_ISDN_BIT:MASK_ANALOG_BIT); m_lpGatherInfo->m_bMask = MASK_SIGNUP_ANY | (m_ISPImport.m_bIsISDNDevice ? MASK_ISDN_BIT:MASK_ANALOG_BIT); }
return hr;}
STDMETHODIMP CRefDial::get_ISPSupportPhoneNumber(BSTR * pVal){ if (pVal == NULL) return E_POINTER;
*pVal = m_bstrSupportNumber.Copy(); return S_OK;}
STDMETHODIMP CRefDial::put_ISPSupportPhoneNumber(BSTR newVal){ // TODO: Add your implementation code here
m_bstrSupportNumber = newVal; return S_OK;}
STDMETHODIMP CRefDial::get_LoggingStartUrl(BSTR * pVal){ if(pVal == NULL) return E_POINTER;
*pVal = m_bstrLoggingStartUrl;
return S_OK;}
STDMETHODIMP CRefDial::get_LoggingEndUrl(BSTR * pVal){ if(pVal == NULL) return E_POINTER;
*pVal = m_bstrLoggingEndUrl;
return S_OK;}
void CRefDial::ShowCredits(){#ifdef ICW_EASTEREGG
HINSTANCE hinstMSHTML = LoadLibrary(TEXT("MSHTML.DLL"));
if(hinstMSHTML) { SHOWHTMLDIALOGFN *pfnShowHTMLDialog; pfnShowHTMLDialog = (SHOWHTMLDIALOGFN*)GetProcAddress(hinstMSHTML, "ShowHTMLDialog");
if(pfnShowHTMLDialog) { IMoniker *pmk; TCHAR szTemp[MAX_PATH*2]; BSTR bstr;
lstrcpy(szTemp, TEXT("res://")); GetModuleFileName(_Module.GetModuleInstance(), szTemp + lstrlen(szTemp), ARRAYSIZE(szTemp) - lstrlen(szTemp)); lstrcat(szTemp, TEXT("/CREDITS_RESOURCE"));
bstr = A2BSTR((LPTSTR) szTemp);
CreateURLMoniker(NULL, bstr, &pmk);
if(pmk) { HRESULT hr; VARIANT varReturn; VariantInit(&varReturn);
hr = (*pfnShowHTMLDialog)(NULL, pmk, NULL, NULL, &varReturn);
pmk->Release(); } SysFreeString(bstr); } FreeLibrary(hinstMSHTML); }#endif
}
STDMETHODIMP CRefDial::SelectedPhoneNumber(long newVal, BOOL * pbRetVal){ BOOL bSuccess = FALSE; *pbRetVal = TRUE; SetupConnectoid(m_pSuggestInfo, newVal, &m_szConnectoid[0], sizeof(m_szConnectoid), &bSuccess); if( !bSuccess ) { m_bQuitWizard = TRUE; *pbRetVal = FALSE; } else { // Generate a Displayable number
m_hrDisplayableNumber = GetDisplayableNumber(); } return S_OK;} STDMETHODIMP CRefDial::PhoneNumberEnum_Reset(){ m_PhoneNumberEnumidx = 0;
return S_OK;}
#define MAX_PAN_NUMBER_LEN 64
STDMETHODIMP CRefDial::PhoneNumberEnum_Next(BSTR *pNumber){ TCHAR szTemp[MAX_PAN_NUMBER_LEN + 1]; PACCESSENTRY pAE;
if (pNumber == NULL) return E_POINTER;
if (m_PhoneNumberEnumidx > m_pSuggestInfo->wNumber - 1) m_PhoneNumberEnumidx = m_pSuggestInfo->wNumber -1; pAE = m_pSuggestInfo->rgpAccessEntry[m_PhoneNumberEnumidx]; wsprintf(szTemp,TEXT("%s (%s) %s"),pAE->szCity,pAE->szAreaCode,pAE->szAccessNumber); ++m_PhoneNumberEnumidx; *pNumber = A2BSTR(szTemp); return S_OK;}
STDMETHODIMP CRefDial::get_PhoneNumberEnum_NumDevices(long * pVal){ if (pVal == NULL) return E_POINTER;
m_PhoneNumberEnumidx = 0; *pVal = m_pSuggestInfo->wNumber; return S_OK;}
STDMETHODIMP CRefDial::get_bIsISDNDevice(BOOL *pVal){ if (pVal == NULL) return E_POINTER;
// NOTE SetupForDialing needs to be called before this API, otherwise the return
// value is really undefined
// Set the return value based on the ISPImport object (that is the object which
// imports the data from the .ISP file, and also selects the RAS device used
// to connect
*pVal = m_ISPImport.m_bIsISDNDevice; return (S_OK);}
//+---------------------------------------------------------------------------
//
// Function: get_RasGetConnectStatus
//
// Synopsis: Checks for existing Ras connection
//
//+---------------------------------------------------------------------------
STDMETHODIMP CRefDial::get_RasGetConnectStatus(BOOL *pVal){ RNAAPI *pcRNA; HRESULT hr = E_FAIL; *pVal = FALSE;
if (NULL != m_hrasconn) { RASCONNSTATUS rasConnectState; rasConnectState.dwSize = sizeof(RASCONNSTATUS); pcRNA = new RNAAPI; if (pcRNA) { if (0 == pcRNA->RasGetConnectStatus(m_hrasconn, &rasConnectState)) { if (RASCS_Disconnected != rasConnectState.rasconnstate) *pVal = TRUE; } delete pcRNA; pcRNA = NULL; hr = S_OK; } }
return hr;}
|
