OS_Develop/Windows-Server-2003
OS_Develop/Windows-Server-2003
1
0
Fork 0
Code Pull Requests Activity
7507d3c0e1
Windows-Server-2003/inetcore/connectionwizard/inetcfg/export.cpp

4363 lines
134 KiB
C++
Raw Blame History

//*******************************************************************
//
// Copyright(c) Microsoft Corporation, 1996
//
// FILE: EXPORT.C
//
// PURPOSE: Contains external API's for use by signup wizard.
//
// HISTORY:
// 96/03/05 markdu Created.
// 96/03/11 markdu Added InetConfigClient()
// 96/03/11 markdu Added InetGetAutodial() and InetSetAutodial().
// 96/03/12 markdu Added UI during file install.
// 96/03/12 markdu Added ValidateConnectoidData().
// 96/03/12 markdu Set connectoid for autodial if INETCFG_SETASAUTODIAL
// is set. Renamed ValidateConnectoidData to MakeConnectoid.
// 96/03/12 markdu Added hwnd param to InetConfigClient() and
// InetConfigSystem().
// 96/03/13 markdu Added INETCFG_OVERWRITEENTRY. Create unique neame
// for connectoid if it already exists and we can't overwrite.
// 96/03/13 markdu Added InstallTCPAndRNA().
// 96/03/13 markdu Added LPINETCLIENTINFO param to InetConfigClient()
// 96/03/16 markdu Added INETCFG_INSTALLMODEM flag.
// 96/03/16 markdu Use ReInit member function to re-enumerate modems.
// 96/03/19 markdu Split export.h into export.h and csexport.h
// 96/03/20 markdu Combined export.h and iclient.h into inetcfg.h
// 96/03/23 markdu Replaced CLIENTINFO references with CLIENTCONFIG.
// 96/03/24 markdu Replaced lstrcpy with lstrcpyn where appropriate.
// 96/03/25 markdu Validate lpfNeedsRestart before using.
// 96/03/25 markdu Clean up some error handling.
// 96/03/26 markdu Use MAX_ISP_NAME instead of RAS_MaxEntryName
// because of bug in RNA.
// 96/03/26 markdu Implemented UpdateMailSettings().
// 96/03/27 mmaclin InetGetProxy()and InetSetProxy().
// 96/04/04 markdu NASH BUG 15610 Check for file and printer sharing
// bound to TCP/IP .
// 96/04/04 markdu Added phonebook name param to InetConfigClient,
// MakeConnectoid, SetConnectoidUsername, CreateConnectoid,
// and ValidateConnectoidName.
// 96/04/05 markdu Set internet icon on desktop to point to browser.
// 96/04/06 mmaclin Changed InetSetProxy to check for NULL.
// 96/04/06 markdu NASH BUG 16404 Initialize gpWizardState in
// UpdateMailSettings.
// 96/04/06 markdu NASH BUG 16441 If InetSetAutodial is called with NULL
// as the connection name, the entry is not changed.
// 96/04/18 markdu NASH BUG 18443 Make exports WINAPI.
// 96/04/19 markdu NASH BUG 18605 Handle ERROR_FILE_NOT_FOUND return
// from ValidateConnectoidName.
// 96/04/19 markdu NASH BUG 17760 Do not show choose profile UI.
// 96/04/22 markdu NASH BUG 18901 Do not set desktop internet icon to
// browser if we are just creating a temp connectoid.
// 96/04/23 markdu NASH BUG 18719 Make the choose profile dialog TOPMOST.
// 96/04/25 markdu NASH BUG 19572 Only show choose profile dialog if
// there is an existing profile.
// 96/04/29 markdu NASH BUG 20003 Added InetConfigSystemFromPath
// and removed InstallTCPAndRNA.
// 96/05/01 markdu NASH BUG 20483 Do not display "installing files" dialog
// if INETCFG_SUPPRESSINSTALLUI is set.
// 96/05/01 markdu ICW BUG 8049 Reboot if modem is installed. This is
// required because sometimes the configuration manager does not
// set up the modem correctly, and the user will not be able to
// dial (will get cryptic error message) until reboot.
// 96/05/06 markdu NASH BUG 21027 If DNS is set globally, clear it out so
// the per-connectoid settings will be saved.
// 96/05/14 markdu NASH BUG 21706 Removed BigFont functions.
// 96/05/25 markdu Use ICFG_ flags for lpNeedDrivers and lpInstallDrivers.
// 96/05/27 markdu Use lpIcfgInstallInetComponents and lpIcfgNeedInetComponents.
// 96/05/28 markdu Moved InitConfig and DeInitConfig to DllEntryPoint.
// 96/10/21 valdonb Added CheckConnectionWizard and InetCreateMailNewsAccount
//
//*******************************************************************
#include "wizard.h"
#include "inetcfg.h"
#include "icwextsn.h"
#include <icwcfg.h>
// constants
#define LEN_APPEND_INT 3 // number of digits for MAX_APPEND_INT
#define MAX_APPEND_INT 999 // maximum number to append to connectoid name // when cycling through names to create unique name
#pragma data_seg(".rdata")
// Registry constants
static const TCHAR cszRegPathInternetSettings[] = REGSTR_PATH_INTERNET_SETTINGS;
static const TCHAR cszRegPathInternetLanSettings[] = REGSTR_PATH_INTERNET_LAN_SETTINGS;
static const TCHAR cszRegValProxyEnable[] = REGSTR_VAL_PROXYENABLE;
static const TCHAR cszRegValProxyServer[] = REGSTR_VAL_PROXYSERVER;
static const TCHAR cszRegValProxyOverride[] = REGSTR_VAL_PROXYOVERRIDE;
static const TCHAR cszRegValAutoProxyDetectMode[] = TEXT("AutoProxyDetectMode");
static const TCHAR cszRegValAutoConfigURL[] = TEXT("AutoConfigURL");
static const TCHAR cszWininet[] = TEXT("WININET.DLL");
static const CHAR cszInternetSetOption[] = "InternetSetOptionA";
static const CHAR cszInternetQueryOption[] = "InternetQueryOptionA";
#define REGSTR_PATH_TELEPHONYLOCATIONS REGSTR_PATH_SETUP TEXT("\\Telephony\\Locations")
#pragma data_seg()
// structure to pass data back from IDD_NEEDDRIVERS handler
typedef struct tagNEEDDRIVERSDLGINFO
{
DWORD dwfOptions;
LPBOOL lpfNeedsRestart;
} NEEDDRIVERSDLGINFO, * PNEEDDRIVERSDLGINFO;
// structure to pass data back from IDD_CHOOSEMODEMNAME handler
typedef struct tagCHOOSEMODEMDLGINFO
{
TCHAR szModemName[RAS_MaxDeviceName + 1];
} CHOOSEMODEMDLGINFO, * PCHOOSEMODEMDLGINFO;
// structure to pass data back from IDD_CHOOSEPROFILENAME handler
typedef struct tagCHOOSEPROFILEDLGINFO
{
TCHAR szProfileName[cchProfileNameMax+1];
BOOL fSetProfileAsDefault;
} CHOOSEPROFILEDLGINFO, * PCHOOSEPROFILEDLGINFO;
// Function prototypes internal to this file
HRESULT UpdateMailSettings(HWND hwndParent, LPINETCLIENTINFO lpINetClientInfo,
LPTSTR lpszEntryName);
INT_PTR CALLBACK ChooseModemDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam,
LPARAM lParam);
BOOL ChooseModemDlgInit(HWND hDlg,PCHOOSEMODEMDLGINFO pChooseModemDlgInfo);
BOOL ChooseModemDlgOK(HWND hDlg,PCHOOSEMODEMDLGINFO pChooseModemDlgInfo);
INT_PTR CALLBACK NeedDriversDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam,
LPARAM lParam);
BOOL NeedDriversDlgInit(HWND hDlg,PNEEDDRIVERSDLGINFO pNeedDriversDlgInfo);
int NeedDriversDlgOK(HWND hDlg,PNEEDDRIVERSDLGINFO pNeedDriversDlgInfo);
VOID EnableDlg(HWND hDlg,BOOL fEnable);
INT_PTR CALLBACK ChooseProfileDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);
BOOL ChooseProfileDlgInit(HWND hDlg,CHOOSEPROFILEDLGINFO * pChooseProfileDlgInfo);
BOOL ChooseProfileDlgOK(HWND hDlg,CHOOSEPROFILEDLGINFO * pChooseProfileDlgInfo);
DWORD MakeConnectoid(
HWND hwndParent,
DWORD dwfOptions,
LPCTSTR lpszPhonebook,
LPCTSTR lpszEntryName,
LPRASENTRY lpRasEntry,
LPCTSTR lpszUsername,
LPCTSTR lpszPassword,
LPBOOL lpfNeedsRestart);
HWND WaitCfgInit(HWND hwndParent, DWORD dwIDS);
// Function prototypes external to this file
VOID InitWizardState(WIZARDSTATE * pWizardState, DWORD dwFlags);
BOOL DoNewProfileDlg(HWND hDlg);
extern DWORD SetIEClientInfo(LPINETCLIENTINFO lpClientInfo);
extern ICFGSETINSTALLSOURCEPATH lpIcfgSetInstallSourcePath;
extern ICFGINSTALLSYSCOMPONENTS lpIcfgInstallInetComponents;
extern ICFGNEEDSYSCOMPONENTS lpIcfgNeedInetComponents;
extern ICFGGETLASTINSTALLERRORTEXT lpIcfgGetLastInstallErrorText;
extern BOOL ValidateProductSuite(LPTSTR SuiteName);
#ifdef UNICODE
PWCHAR ToUnicodeWithAlloc(LPCSTR);
VOID ToAnsiClientInfo(LPINETCLIENTINFOA, LPINETCLIENTINFOW);
VOID ToUnicodeClientInfo(LPINETCLIENTINFOW, LPINETCLIENTINFOA);
#endif
//
// from rnacall.cpp
//
extern BOOL InitTAPILocation(HWND hwndParent);
#define SMART_RUNICW TRUE
#define SMART_QUITICW FALSE
#include "wininet.h"
typedef BOOL (WINAPI * INTERNETSETOPTION) (IN HINTERNET hInternet OPTIONAL,IN DWORD dwOption,IN LPVOID lpBuffer,IN DWORD dwBufferLength);
typedef BOOL (WINAPI * INTERNETQUERYOPTION) (IN HINTERNET hInternet OPTIONAL,IN DWORD dwOption,IN LPVOID lpBuffer,IN LPDWORD dwBufferLength);
static const TCHAR g_szRegPathICWSettings[] = TEXT("Software\\Microsoft\\Internet Connection Wizard");
static const TCHAR g_szRegValICWCompleted[] = TEXT("Completed");
BOOL g_bUseAutoProxyforConnectoid = TRUE;
//*******************************************************************
//
// FUNCTION: InetConfigSystem
//
// PURPOSE: This function will install files that are needed
// for internet access (such as TCP/IP and RNA) based
// the state of the options flags.
//
// PARAMETERS: hwndParent - window handle of calling application. This
// handle will be used as the parent for any dialogs that
// are required for error messages or the "installing files"
// dialog.
// dwfOptions - a combination of INETCFG_ flags that controls
// the installation and configuration as follows:
//
// INETCFG_INSTALLMAIL - install exchange and internet mail
// INETCFG_INSTALLMODEM - Invoke InstallModem wizard if NO
// MODEM IS INSTALLED.
// INETCFG_INSTALLRNA - install RNA (if needed)
// INETCFG_INSTALLTCP - install TCP/IP (if needed)
// INETCFG_CONNECTOVERLAN - connecting with LAN (vs modem)
// INETCFG_WARNIFSHARINGBOUND - Check if TCP/IP file sharing is
// turned on, and warn user to turn
// it off. Reboot is required if
// the user turns it off.
// INETCFG_REMOVEIFSHARINGBOUND - Check if TCP/IP file sharing is
// turned on, and force user to turn
// it off. If user does not want to
// turn it off, return will be
// ERROR_CANCELLED. Reboot is
// required if the user turns it off.
//
// lpfNeedsRestart - if non-NULL, then on return, this will be
// TRUE if windows must be restarted to complete the installation.
//
// RETURNS: HRESULT code, ERROR_SUCCESS if no errors occurred
//
// HISTORY:
// 96/03/05 markdu Created.
//
//*******************************************************************
extern "C" HRESULT WINAPI InetConfigSystem(
HWND hwndParent,
DWORD dwfOptions,
LPBOOL lpfNeedsRestart)
{
DWORD dwRet = ERROR_SUCCESS;
BOOL fNeedsRestart = FALSE; // Default to no reboot needed
// 4/2/97 ChrisK Olympus 209
HWND hwndWaitDlg = NULL;
TCHAR szWindowTitle[255];
BOOL bSleepNeeded = FALSE;
/*
We do this messy NT 5.0 hack because for the time being the
NT 4.0 API call fails to kil off the modem wizard in NT 5.0
, so we need to pretend we are like 9x
In the future when this problem is corrected the origional code should
prpoably be restored -- ALL references to this BOOL should be deleted.
a-jaswed
*/
BOOL bNT5NeedModem = FALSE;
DEBUGMSG("export.c::InetConfigSystem()");
// Validate the parent hwnd
if (hwndParent && !IsWindow(hwndParent))
{
return ERROR_INVALID_PARAMETER;
}
// Set up the install options
DWORD dwfInstallOptions = 0;
if (dwfOptions & INETCFG_INSTALLTCP)
{
dwfInstallOptions |= ICFG_INSTALLTCP;
}
if (dwfOptions & INETCFG_INSTALLRNA)
{
dwfInstallOptions |= ICFG_INSTALLRAS;
}
if (dwfOptions & INETCFG_INSTALLMAIL)
{
dwfInstallOptions |= ICFG_INSTALLMAIL;
}
// see if we need to install drivers
BOOL fNeedSysComponents = FALSE;
// 4/2/97 ChrisK Olympus 209 Display busy dialog
if (INETCFG_SHOWBUSYANIMATION == (dwfOptions & INETCFG_SHOWBUSYANIMATION))
hwndWaitDlg = WaitCfgInit(hwndParent,IDS_WAITCHECKING);
//
// Kill Modem control panel if it's already running
// 4/16/97 ChrisK Olympus 239
// 6/9/97 jmazner moved this functionality from InvokeModemWizard
szWindowTitle[0] = '\0';
LoadSz(IDS_MODEM_WIZ_TITLE,szWindowTitle,255);
HWND hwndModem = FindWindow(TEXT("#32770"),szWindowTitle);
if (NULL != hwndModem)
{
// Close modem installation wizard
PostMessage(hwndModem, WM_CLOSE, 0, 0);
bSleepNeeded = TRUE;
}
// close modem control panel applet
LoadSz(IDS_MODEM_CPL_TITLE,szWindowTitle,255);
hwndModem = FindWindow(TEXT("#32770"),szWindowTitle);
if (NULL != hwndModem)
{
PostMessage(hwndModem, WM_SYSCOMMAND,SC_CLOSE, 0);
bSleepNeeded = TRUE;
}
if (bSleepNeeded)
{
Sleep(1000);
}
dwRet = lpIcfgNeedInetComponents(dwfInstallOptions, &fNeedSysComponents);
if (ERROR_SUCCESS != dwRet)
{
TCHAR szErrorText[MAX_ERROR_TEXT+1]=TEXT("");
// 4/2/97 ChrisK Olympus 209
// Dismiss busy dialog
if (NULL != hwndWaitDlg)
{
BringWindowToTop(hwndParent);
DestroyWindow(hwndWaitDlg);
hwndWaitDlg = NULL;
}
//
// Get the text of the error message and display it.
//
if (lpIcfgGetLastInstallErrorText(szErrorText, MAX_ERROR_TEXT+1))
{
MsgBoxSz(NULL,szErrorText,MB_ICONEXCLAMATION,MB_OK);
}
return dwRet;
}
if (fNeedSysComponents)
{
// 4/2/97 ChrisK Olympus 209
// if we are going to install something the busy dialog isn't needed
if (NULL != hwndWaitDlg)
{
BringWindowToTop(hwndParent);
ShowWindow(hwndWaitDlg,SW_HIDE);
}
if (dwfOptions & INETCFG_SUPPRESSINSTALLUI)
{
dwRet = lpIcfgInstallInetComponents(hwndParent, dwfInstallOptions, &fNeedsRestart);
//
// Display error message only if it failed due to something
// other than user cancel
//
if ((ERROR_SUCCESS != dwRet) && (ERROR_CANCELLED != dwRet))
{
TCHAR szErrorText[MAX_ERROR_TEXT+1]=TEXT("");
// Get the text of the error message and display it.
if (lpIcfgGetLastInstallErrorText(szErrorText, MAX_ERROR_TEXT+1))
{
MsgBoxSz(NULL,szErrorText,MB_ICONEXCLAMATION,MB_OK);
}
}
}
else
{
// structure to pass to dialog to fill out
NEEDDRIVERSDLGINFO NeedDriversDlgInfo;
NeedDriversDlgInfo.dwfOptions = dwfInstallOptions;
NeedDriversDlgInfo.lpfNeedsRestart = &fNeedsRestart;
// Clear out the last error code so we can safely use it.
SetLastError(ERROR_SUCCESS);
// Display a dialog and allow the user to cancel install
int iRet = (int)DialogBoxParam(ghInstance,MAKEINTRESOURCE(IDD_NEEDDRIVERS),hwndParent,
NeedDriversDlgProc,(LPARAM) &NeedDriversDlgInfo);
if (0 == iRet)
{
// user cancelled
dwRet = ERROR_CANCELLED;
}
else if (-1 == iRet)
{
// an error occurred.
dwRet = GetLastError();
if (ERROR_SUCCESS == dwRet)
{
// Error occurred, but the error code was not set.
dwRet = ERROR_INETCFG_UNKNOWN;
}
}
}
}
if ( (ERROR_SUCCESS == dwRet) && (TRUE == IsNT()) && (dwfOptions & INETCFG_INSTALLMODEM))
{
BOOL bNeedModem = FALSE;
if (NULL == lpIcfgNeedModem)
{
//
// 4/2/97 ChrisK Olympus 209
//
if (NULL != hwndWaitDlg)
{
BringWindowToTop(hwndParent);
DestroyWindow(hwndWaitDlg);
hwndWaitDlg = NULL;
}
return ERROR_GEN_FAILURE;
}
//
// 4/2/97 ChrisK Olympus 209
// Show busy dialog here, this can take a few seconds
//
if (NULL != hwndWaitDlg)
ShowWindow(hwndWaitDlg,SW_SHOW);
dwRet = (*lpIcfgNeedModem)(0, &bNeedModem);
if (ERROR_SUCCESS != dwRet)
{
//
// 4/2/97 ChrisK Olympus 209
//
if (NULL != hwndWaitDlg)
{
BringWindowToTop(hwndParent);
DestroyWindow(hwndWaitDlg);
hwndWaitDlg = NULL;
}
return dwRet;
}
if (TRUE == bNeedModem)
{
if (IsNT5() == TRUE)
{
bNT5NeedModem = bNeedModem;
}
else
{
// 4/2/97 ChrisK Olympus 209
if (NULL != hwndWaitDlg)
{
BringWindowToTop(hwndParent);
DestroyWindow(hwndWaitDlg);
hwndWaitDlg = NULL;
}
MsgBoxParam(hwndParent,IDS_ERRNoDialOutModem,MB_ICONERROR,MB_OK);
return ERROR_GEN_FAILURE;
}
}
//
// 7/15/97 jmazner Olympus #6294
// make sure TAPI location info is valid
//
if (!InitTAPILocation(hwndParent))
{
if (NULL != hwndWaitDlg)
{
BringWindowToTop(hwndParent);
DestroyWindow(hwndWaitDlg);
hwndWaitDlg = NULL;
}
return ERROR_CANCELLED;
}
}
// 4/2/97 ChrisK Olympus 209
if (NULL != hwndWaitDlg)
{
BringWindowToTop(hwndParent);
ShowWindow(hwndWaitDlg,SW_HIDE);
}
// See if we are supposed to check if file sharing is turned on
if (ERROR_SUCCESS == dwRet && !(ValidateProductSuite( TEXT("Small Business") )))
{
BOOL fNeedsRestartTmp = FALSE;
if (dwfOptions & INETCFG_REMOVEIFSHARINGBOUND)
{
// Tell user that we cannot continue unless binding is removed.
dwRet = RemoveIfServerBound(hwndParent,
(dwfOptions & INETCFG_CONNECTOVERLAN)? INSTANCE_NETDRIVER : INSTANCE_PPPDRIVER, &fNeedsRestartTmp);
}
else if (dwfOptions & INETCFG_WARNIFSHARINGBOUND)
{
// Warn user that binding should be removed.
dwRet = WarnIfServerBound(hwndParent,
(dwfOptions & INETCFG_CONNECTOVERLAN)?INSTANCE_NETDRIVER : INSTANCE_PPPDRIVER, &fNeedsRestartTmp);
}
// If the settings were removed, we need to reboot.
if ((ERROR_SUCCESS == dwRet) && (TRUE == fNeedsRestartTmp))
{
fNeedsRestart = TRUE;
}
// If user installed net component but we need cancel F&P sharing, we still need to restart
// or NT becomes unstable - Bug 68641
if(ERROR_CANCELLED == dwRet && fNeedsRestart && IsNT())
dwRet = ERROR_SUCCESS;
}
// 4/2/97 ChrisK Olympus 209
// Dismiss dialog for good
if (NULL != hwndWaitDlg)
{
BringWindowToTop(hwndParent);
DestroyWindow(hwndWaitDlg);
hwndWaitDlg = NULL;
}
//
// If not NT then we install the modem after installing RAS
//
// See if we are supposed to install a modem
if (((FALSE == IsNT()) || (bNT5NeedModem)) && (ERROR_SUCCESS == dwRet) &&
(dwfOptions & INETCFG_INSTALLMODEM))
{
// Load RNA if not already loaded since ENUM_MODEM needs it.
dwRet = EnsureRNALoaded();
if (ERROR_SUCCESS != dwRet)
{
return dwRet;
}
// Enumerate the modems
ENUM_MODEM EnumModem;
dwRet = EnumModem.GetError();
if (ERROR_SUCCESS != dwRet)
{
return dwRet;
}
// If there are no modems, install one if requested.
if (0 == EnumModem.GetNumDevices())
{
//
// 5/22/97 jmazner Olympus #4698
// On Win95, calling RasEnumDevices launches RNAAP.EXE
// If RNAAP.EXE is running, any modems you install won't be usable
// So, nuke RNAAP.EXE before installing the modem.
//
TCHAR szWindowTitle[255] = TEXT("\0nogood");
//
// Unload the RAS dll's before killing RNAAP, just to be safe
//
DeInitRNA();
LoadSz(IDS_RNAAP_TITLE,szWindowTitle,255);
HWND hwnd = FindWindow(szWindowTitle, NULL);
if (NULL != hwnd)
{
if (!PostMessage(hwnd, WM_CLOSE, 0, 0))
{
DEBUGMSG("Trying to kill RNAAP window returned getError %d", GetLastError());
}
}
// invoke the modem wizard UI to install the modem
UINT uRet = InvokeModemWizard(hwndParent);
if (ERROR_PRIVILEGE_NOT_HELD == uRet)
{
TCHAR szAdminDenied [MAX_PATH] = TEXT("\0");
LoadSz(IDS_ADMIN_ACCESS_DENIED, szAdminDenied, MAX_PATH);
MsgBoxSz(hwndParent,szAdminDenied,MB_ICONEXCLAMATION,MB_OK);
return ERROR_CANCELLED;
}
else if (uRet != ERROR_SUCCESS)
{
DisplayErrorMessage(hwndParent,IDS_ERRInstallModem,uRet,
ERRCLS_STANDARD,MB_ICONEXCLAMATION);
return ERROR_INVALID_PARAMETER;
}
// Reload the RAS dlls now that the modem has been safely installed.
InitRNA(hwndParent);
// Re-numerate the modems to be sure we have the most recent changes
dwRet = EnumModem.ReInit();
if (ERROR_SUCCESS != dwRet)
{
return dwRet;
}
// If there are still no modems, user cancelled
if (0 == EnumModem.GetNumDevices())
{
return ERROR_CANCELLED;
}
else
{
// removed per GeoffR request 5-2-97
//// 96/05/01 markdu ICW BUG 8049 Reboot if modem is installed.
//fNeedsRestart = TRUE;
}
}
else
{
//
// 7/15/97 jmazner Olympus #6294
// make sure TAPI location info is valid
//
// 4/15/99 vyung Tapi changed the location dlg
if (!InitTAPILocation(hwndParent))
{
if (NULL != hwndWaitDlg)
{
BringWindowToTop(hwndParent);
DestroyWindow(hwndWaitDlg);
hwndWaitDlg = NULL;
}
return ERROR_CANCELLED;
}
}
}
// tell caller whether we need to reboot or not
if ((ERROR_SUCCESS == dwRet) && (lpfNeedsRestart))
{
*lpfNeedsRestart = fNeedsRestart;
}
// 4/2/97 ChrisK Olympus 209
// Sanity check
if (NULL != hwndWaitDlg)
{
BringWindowToTop(hwndParent);
DestroyWindow(hwndWaitDlg);
hwndWaitDlg = NULL;
}
return dwRet;
}
//*******************************************************************
//
// FUNCTION: InetNeedSystemComponents
//
// PURPOSE: This function will check is components that are needed
// for internet access (such as TCP/IP and RNA) are already
// configured based the state of the options flags.
//
// PARAMETERS: dwfOptions - a combination of INETCFG_ flags that controls
// the installation and configuration as follows:
//
// INETCFG_INSTALLRNA - install RNA (if needed)
// INETCFG_INSTALLTCP - install TCP/IP (if needed)
//
// lpfNeedsConfig - On return, this will be
// TRUE if system component(s)
// should be installed
//
// RETURNS: HRESULT code, ERROR_SUCCESS if no errors occurred
//
// HISTORY: 05/02/97 VetriV Created.
// 05/08/97 ChrisK Added INSTALLLAN, INSTALLDIALUP, and
// INSTALLTCPONLY
//
//*******************************************************************
extern "C" HRESULT WINAPI InetNeedSystemComponents(DWORD dwfOptions,
LPBOOL lpbNeedsConfig)
{
DWORD dwRet = ERROR_SUCCESS;
DEBUGMSG("export.cpp::InetNeedSystemComponents()");
//
// Validate parameters
//
if (!lpbNeedsConfig)
{
return ERROR_INVALID_PARAMETER;
}
//
// Set up the install options
//
DWORD dwfInstallOptions = 0;
if (dwfOptions & INETCFG_INSTALLTCP)
{
dwfInstallOptions |= ICFG_INSTALLTCP;
}
if (dwfOptions & INETCFG_INSTALLRNA)
{
dwfInstallOptions |= ICFG_INSTALLRAS;
}
//
// ChrisK 5/8/97
//
if (dwfOptions & INETCFG_INSTALLLAN)
{
dwfInstallOptions |= ICFG_INSTALLLAN;
}
if (dwfOptions & INETCFG_INSTALLDIALUP)
{
dwfInstallOptions |= ICFG_INSTALLDIALUP;
}
if (dwfOptions & INETCFG_INSTALLTCPONLY)
{
dwfInstallOptions |= ICFG_INSTALLTCPONLY;
}
//
// see if we need to install drivers
//
BOOL bNeedSysComponents = FALSE;
dwRet = lpIcfgNeedInetComponents(dwfInstallOptions, &bNeedSysComponents);
if (ERROR_SUCCESS != dwRet)
{
TCHAR szErrorText[MAX_ERROR_TEXT+1]=TEXT("");
//
// Get the text of the error message and display it.
//
if (lpIcfgGetLastInstallErrorText(szErrorText, MAX_ERROR_TEXT+1))
{
DEBUGMSG(szErrorText);
}
return dwRet;
}
*lpbNeedsConfig = bNeedSysComponents;
return ERROR_SUCCESS;
}
//*******************************************************************
//
// FUNCTION: InetNeedModem
//
// PURPOSE: This function will check if modem is needed or not
//
// PARAMETERS: lpfNeedsConfig - On return, this will be
// TRUE if modem
// should be installed
//
// RETURNS: HRESULT code, ERROR_SUCCESS if no errors occurred
//
// HISTORY: 05/02/97 VetriV Created.
//
//*******************************************************************
extern "C" HRESULT WINAPI InetNeedModem(LPBOOL lpbNeedsModem)
{
DWORD dwRet = ERROR_SUCCESS;
//
// Validate parameters
//
if (!lpbNeedsModem)
{
return ERROR_INVALID_PARAMETER;
}
if (TRUE == IsNT())
{
//
// On NT call icfgnt.dll to determine if modem is needed
//
BOOL bNeedModem = FALSE;
if (NULL == lpIcfgNeedModem)
{
return ERROR_GEN_FAILURE;
}
dwRet = (*lpIcfgNeedModem)(0, &bNeedModem);
if (ERROR_SUCCESS != dwRet)
{
return dwRet;
}
*lpbNeedsModem = bNeedModem;
return ERROR_SUCCESS;
}
else
{
//
// Load RNA if not already loaded since ENUM_MODEM needs it.
//
dwRet = EnsureRNALoaded();
if (ERROR_SUCCESS != dwRet)
{
return dwRet;
}
//
// Enumerate the modems
//
ENUM_MODEM EnumModem;
dwRet = EnumModem.GetError();
if (ERROR_SUCCESS != dwRet)
{
return dwRet;
}
//
// If there are no modems, we need to install one
//
if (0 == EnumModem.GetNumDevices())
{
*lpbNeedsModem = TRUE;
}
else
{
*lpbNeedsModem = FALSE;
}
return ERROR_SUCCESS;
}
}
//*******************************************************************
//
// FUNCTION: InetConfigSystemFromPath
//
// PURPOSE: This function will install files that are needed
// for internet access (such as TCP/IP and RNA) based
// the state of the options flags and from the given [ath.
//
// PARAMETERS: hwndParent - window handle of calling application. This
// handle will be used as the parent for any dialogs that
// are required for error messages or the "installing files"
// dialog.
// dwfOptions - a combination of INETCFG_ flags that controls
// the installation and configuration as follows:
//
// INETCFG_INSTALLMAIL - install exchange and internet mail
// INETCFG_INSTALLMODEM - Invoke InstallModem wizard if NO
// MODEM IS INSTALLED.
// INETCFG_INSTALLRNA - install RNA (if needed)
// INETCFG_INSTALLTCP - install TCP/IP (if needed)
// INETCFG_CONNECTOVERLAN - connecting with LAN (vs modem)
// INETCFG_WARNIFSHARINGBOUND - Check if TCP/IP file sharing is
// turned on, and warn user to turn
// it off. Reboot is required if
// the user turns it off.
// INETCFG_REMOVEIFSHARINGBOUND - Check if TCP/IP file sharing is
// turned on, and force user to turn
// it off. If user does not want to
// turn it off, return will be
// ERROR_CANCELLED. Reboot is
// required if the user turns it off.
//
// lpfNeedsRestart - if non-NULL, then on return, this will be
// TRUE if windows must be restarted to complete the installation.
// lpszSourcePath - full path of location of files to install. If
// this is NULL, default path is used.
//
// RETURNS: HRESULT code, ERROR_SUCCESS if no errors occurred
//
// HISTORY:
// 96/04/29 markdu Created.
//
//*******************************************************************
#ifdef UNICODE
HRESULT WINAPI InetConfigSystemFromPathA
(
HWND hwndParent,
DWORD dwfOptions,
LPBOOL lpfNeedsRestart,
LPCSTR lpszSourcePath
)
{
TCHAR szSourcePath[MAX_PATH+1];
mbstowcs(szSourcePath, lpszSourcePath, lstrlenA(lpszSourcePath)+1);
return InetConfigSystemFromPathW(hwndParent, dwfOptions,
lpfNeedsRestart, szSourcePath);
}
HRESULT WINAPI InetConfigSystemFromPathW
#else
HRESULT WINAPI InetConfigSystemFromPathA
#endif
(
HWND hwndParent,
DWORD dwfOptions,
LPBOOL lpfNeedsRestart,
LPCTSTR lpszSourcePath
)
{
DWORD dwRet;
DEBUGMSG("export.c::InetConfigSystemFromPath()");
// Validate the parent hwnd
if (hwndParent && !IsWindow(hwndParent))
{
return ERROR_INVALID_PARAMETER;
}
// Set the install path here
if (lpszSourcePath && lstrlen(lpszSourcePath))
{
dwRet = lpIcfgSetInstallSourcePath(lpszSourcePath);
if (ERROR_SUCCESS != dwRet)
{
return dwRet;
}
}
// Install files if needed.
dwRet = InetConfigSystem(hwndParent,
dwfOptions, lpfNeedsRestart);
return dwRet;
}
//*******************************************************************
//
// FUNCTION: InetConfigClient
//
// PURPOSE: This function requires a valid phone book entry name
// (unless it is being used just to set the client info).
// If lpRasEntry points to a valid RASENTRY struct, the phone
// book entry will be created (or updated if it already exists)
// with the data in the struct.
// If username and password are given, these
// will be set as the dial params for the phone book entry.
// If a client info struct is given, that data will be set.
// Any files (ie TCP and RNA) that are needed will be
// installed by calling InetConfigSystem().
// This function will also perform verification on the device
// specified in the RASENTRY struct. If no device is specified,
// the user will be prompted to install one if there are none
// installed, or they will be prompted to choose one if there
// is more than one installed.
//
// PARAMETERS: hwndParent - window handle of calling application. This
// handle will be used as the parent for any dialogs that
// are required for error messages or the "installing files"
// dialog.
// lpszPhonebook - name of phone book to store the entry in
// lpszEntryName - name of phone book entry to be
// created or modified
// lpRasEntry - specifies a RASENTRY struct that contains
// the phone book entry data for the entry lpszEntryName
// lpszUsername - username to associate with the phone book entry
// lpszPassword - password to associate with the phone book entry
// lpszProfileName - Name of client info profile to
// retrieve. If this is NULL, the default profile is used.
// lpINetClientInfo - client information
// dwfOptions - a combination of INETCFG_ flags that controls
// the installation and configuration as follows:
//
// INETCFG_INSTALLMAIL - install exchange and internet mail
// INETCFG_INSTALLMODEM - Invoke InstallModem wizard if NO
// MODEM IS INSTALLED. Note that if
// no modem is installed and this flag
// is not set, the function will fail
// INETCFG_INSTALLRNA - install RNA (if needed)
// INETCFG_INSTALLTCP - install TCP/IP (if needed)
// INETCFG_CONNECTOVERLAN - connecting with LAN (vs modem)
// INETCFG_SETASAUTODIAL - Set the phone book entry for autodial
// INETCFG_OVERWRITEENTRY - Overwrite the phone book entry if it
// exists. Note: if this flag is not
// set, and the entry exists, a unique
// name will be created for the entry.
// INETCFG_WARNIFSHARINGBOUND - Check if TCP/IP file sharing is
// turned on, and warn user to turn
// it off. Reboot is required if
// the user turns it off.
// INETCFG_REMOVEIFSHARINGBOUND - Check if TCP/IP file sharing is
// turned on, and force user to turn
// it off. If user does not want to
// turn it off, return will be
// ERROR_CANCELLED. Reboot is
// required if the user turns it off.
//
// lpfNeedsRestart - if non-NULL, then on return, this will be
// TRUE if windows must be restarted to complete the installation.
//
// RETURNS: HRESULT code, ERROR_SUCCESS if no errors occurred
//
// HISTORY:
// 96/03/11 markdu Created.
//
//*******************************************************************
#ifdef UNICODE
extern "C" HRESULT WINAPI InetConfigClientA
(
HWND hwndParent,
LPCSTR lpszPhonebook,
LPCSTR lpszEntryName,
LPRASENTRY lpRasEntry,
LPCSTR lpszUsername,
LPCSTR lpszPassword,
LPCSTR lpszProfileName,
LPINETCLIENTINFOA lpINetClientInfo,
DWORD dwfOptions,
LPBOOL lpfNeedsRestart
)
{
LPTSTR pszPhonebook = NULL;
LPTSTR pszEntryName = NULL;
LPTSTR pszUsername = NULL;
LPTSTR pszPassword = NULL;
LPTSTR pszProfileName = NULL;
INETCLIENTINFOW *pINetClientInfo = NULL;
TCHAR szPhonebook[sizeof(TCHAR*)*(MAX_PATH+1)] = TEXT("");
TCHAR szEntryName[sizeof(TCHAR*)*(MAX_PATH+1)] = TEXT("");
TCHAR szUsername[sizeof(TCHAR*)*(MAX_PATH+1)] = TEXT("");
TCHAR szPassword[sizeof(TCHAR*)*(MAX_PATH+1)] = TEXT("");
TCHAR szProfileName[sizeof(TCHAR*)*(MAX_PATH+1)] = TEXT("");
INETCLIENTINFOW INetClientInfo;
if (NULL != lpszPhonebook)
{
mbstowcs(szPhonebook, lpszPhonebook, lstrlenA(lpszPhonebook)+1);
pszPhonebook = szPhonebook;
}
if (NULL != lpszEntryName)
{
mbstowcs(szEntryName, lpszEntryName, lstrlenA(lpszEntryName)+1);
pszEntryName = szEntryName;
}
if (NULL != lpszUsername)
{
mbstowcs(szUsername, lpszUsername, lstrlenA(lpszUsername)+1);
pszUsername = szUsername;
}
if (NULL != lpszPassword)
{
mbstowcs(szPassword, lpszPassword, lstrlenA(lpszPassword)+1);
pszPassword = szPassword;
}
if (NULL != lpszProfileName)
{
mbstowcs(szProfileName, lpszProfileName, lstrlenA(lpszProfileName)+1);
pszProfileName = szProfileName;
}
if (lpINetClientInfo)
{
ToUnicodeClientInfo(&INetClientInfo, lpINetClientInfo);
pINetClientInfo = &INetClientInfo;
}
return InetConfigClientW(hwndParent,
pszPhonebook,
pszEntryName,
lpRasEntry,
pszUsername,
pszPassword,
pszProfileName,
pINetClientInfo,
dwfOptions,
lpfNeedsRestart);
}
extern "C" HRESULT WINAPI InetConfigClientW
#else
extern "C" HRESULT WINAPI InetConfigClientA
#endif
(
HWND hwndParent,
LPCTSTR lpszPhonebook,
LPCTSTR lpszEntryName,
LPRASENTRY lpRasEntry,
LPCTSTR lpszUsername,
LPCTSTR lpszPassword,
LPCTSTR lpszProfileName,
LPINETCLIENTINFO lpINetClientInfo,
DWORD dwfOptions,
LPBOOL lpfNeedsRestart
)
{
TCHAR szConnectoidName[MAX_ISP_NAME + 1] = TEXT("");
BOOL fNeedsRestart = FALSE; // Default to no reboot needed
HWND hwndWaitDlg = NULL;
DEBUGMSG("export.c::InetConfigClient()");
// Install files if needed.
// Note: the parent hwnd is validated in InetConfigSystem
// We must also mask out the InstallModem flag since we want to
// do that here, not in InetConfigSystem
DWORD dwRet = InetConfigSystem(hwndParent,
dwfOptions & ~INETCFG_INSTALLMODEM, &fNeedsRestart);
if (ERROR_SUCCESS != dwRet)
{
return dwRet;
}
// 4/2/97 ChrisK Olympus 209 Display busy dialog
if (INETCFG_SHOWBUSYANIMATION == (dwfOptions & INETCFG_SHOWBUSYANIMATION))
hwndWaitDlg = WaitCfgInit(hwndParent,IDS_WAITCONNECT);
// Make sure we have a connectoid name
if (lpszEntryName && lstrlen(lpszEntryName))
{
// Copy the name into a private buffer in case we have
// to muck around with it
lstrcpyn(szConnectoidName, lpszEntryName, sizeof(szConnectoidName)/sizeof(TCHAR));
// Make sure the name is valid.
dwRet = ValidateConnectoidName(lpszPhonebook, szConnectoidName);
if ((ERROR_SUCCESS == dwRet) ||
(ERROR_ALREADY_EXISTS == dwRet))
{
// Find out if we can overwrite an existing connectoid
if (!(dwfOptions & INETCFG_OVERWRITEENTRY) &&
(ERROR_ALREADY_EXISTS == dwRet))
{
TCHAR szConnectoidNameBase[MAX_ISP_NAME + 1];
// Create a base string that is truncated to leave room for a space
// and a 3-digit number to be appended. So, the buffer size will be
// MAX_ISP_NAME + 1 - (LEN_APPEND_INT + 1)
lstrcpyn(szConnectoidNameBase, szConnectoidName,
MAX_ISP_NAME - LEN_APPEND_INT);
// If the entry exists, we have to create a unique name
int nSuffix = 2;
while ((ERROR_ALREADY_EXISTS == dwRet) && (nSuffix < MAX_APPEND_INT))
{
// Add the integer to the end of the base string and then bump it
wsprintf(szConnectoidName, szFmtAppendIntToString,
szConnectoidNameBase, nSuffix++);
// Validate this new name
dwRet = ValidateConnectoidName(lpszPhonebook, szConnectoidName);
}
// If we could not create a unique name, bail
// Note that dwRet should still be ERROR_ALREADY_EXISTS in this case
if (nSuffix >= MAX_APPEND_INT)
{
if (NULL != hwndWaitDlg)
DestroyWindow(hwndWaitDlg);
hwndWaitDlg = NULL;
return dwRet;
}
}
if (lpRasEntry && lpRasEntry->dwSize == sizeof(RASENTRY))
{
// Create a connectoid with given properties
dwRet = MakeConnectoid(hwndParent, dwfOptions, lpszPhonebook,
szConnectoidName, lpRasEntry, lpszUsername, lpszPassword, &fNeedsRestart);
}
// If we created a connectoid, we already updated the dial params
// with the user name and password. However, if we didn't create a
// connectoid we still may need to update dial params of an existing one
else if ((lpszUsername && lstrlen(lpszUsername)) ||
(lpszPassword && lstrlen(lpszPassword)))
{
// Update the dial params for the given connectoid.
dwRet = SetConnectoidUsername(lpszPhonebook, szConnectoidName,
lpszUsername, lpszPassword);
}
// If the connectoid was created/updated successfully, see
// if it is supposed to be set as the autodial connectoid.
if ((ERROR_SUCCESS == dwRet) && (dwfOptions & INETCFG_SETASAUTODIAL))
{
dwRet = InetSetAutodial((DWORD)TRUE, szConnectoidName);
// make sure "The Internet" icon on desktop points to web browser
// (it may initially be pointing at internet wizard)
// 96/04/22 markdu NASH BUG 18901 Do not do this for temp connectoids.
if (!(dwfOptions & INETCFG_TEMPPHONEBOOKENTRY))
{
// //10/24/96 jmazner Normandy 6968
// //No longer neccessary thanks to Valdon's hooks for invoking ICW.
// 11/21/96 jmazner Normandy 11812
// oops, it _is_ neccessary, since if user downgrades from IE 4 to IE 3,
// ICW 1.1 needs to morph the IE 3 icon.
SetDesktopInternetIconToBrowser();
}
}
}
}
// Now set the client info if provided and no errors have occurred yet.
if (ERROR_SUCCESS == dwRet)
{
if (NULL != lpINetClientInfo)
{
dwRet = InetSetClientInfo(lpszProfileName, lpINetClientInfo);
if (ERROR_SUCCESS != dwRet)
{
if (NULL != hwndWaitDlg)
DestroyWindow(hwndWaitDlg);
hwndWaitDlg = NULL;
return dwRet;
}
// update IE news settings
dwRet = SetIEClientInfo(lpINetClientInfo);
if (ERROR_SUCCESS != dwRet)
{
if (NULL != hwndWaitDlg)
DestroyWindow(hwndWaitDlg);
hwndWaitDlg = NULL;
return dwRet;
}
}
// Now update the mail client if we were asked to do so.
// Note: if we got here without errors, and INETCFG_INSTALLMAIL is set,
// then mail has been installed by now.
if (dwfOptions & INETCFG_INSTALLMAIL)
{
INETCLIENTINFO INetClientInfo;
ZeroMemory(&INetClientInfo, sizeof(INETCLIENTINFO));
INetClientInfo.dwSize = sizeof(INETCLIENTINFO);
// Use a temp pointer that we can modify.
LPINETCLIENTINFO lpTmpINetClientInfo = lpINetClientInfo;
// If no client info struct was given, try to get the profile by name
if ((NULL == lpTmpINetClientInfo) && (NULL != lpszProfileName) &&
lstrlen(lpszProfileName))
{
lpTmpINetClientInfo = &INetClientInfo;
dwRet = InetGetClientInfo(lpszProfileName, lpTmpINetClientInfo);
if (ERROR_SUCCESS != dwRet)
{
if (NULL != hwndWaitDlg)
DestroyWindow(hwndWaitDlg);
hwndWaitDlg = NULL;
return dwRet;
}
}
// If we still don't have client info, we should enumerate the profiles
// If there is one profile, get it. If multiple, show UI to allow user
// to choose. If none, there is nothing to do at this point.
// For now, we don't support enumeration, so just try to get the default.
if (NULL == lpTmpINetClientInfo)
{
lpTmpINetClientInfo = &INetClientInfo;
dwRet = InetGetClientInfo(NULL, lpTmpINetClientInfo);
if (ERROR_SUCCESS != dwRet)
{
if (NULL != hwndWaitDlg)
DestroyWindow(hwndWaitDlg);
hwndWaitDlg = NULL;
return dwRet;
}
}
// If we have client info, update mail settings.
if (NULL != lpTmpINetClientInfo)
{
dwRet = UpdateMailSettings(hwndParent, lpTmpINetClientInfo,
szConnectoidName);
}
}
}
// tell caller whether we need to reboot or not
if ((ERROR_SUCCESS == dwRet) && (lpfNeedsRestart))
{
*lpfNeedsRestart = fNeedsRestart;
}
if (NULL != hwndWaitDlg)
DestroyWindow(hwndWaitDlg);
hwndWaitDlg = NULL;
return dwRet;
}
//*******************************************************************
//
// FUNCTION: UpdateMailSettings
//
// PURPOSE: This function will update the settings for mail in
// the profile of the user's choice.
//
// PARAMETERS: hwndParent - window handle of calling application. This
// handle will be used as the parent for any dialogs that
// are required for error messages or the "choose profile"
// dialog.
// lpINetClientInfo - client information
// lpszEntryName - name of phone book entry to be
// set for connection.
//
// RETURNS: HRESULT code, ERROR_SUCCESS if no errors occurred
//
// HISTORY:
// 96/03/26 markdu Created.
//
//*******************************************************************
HRESULT UpdateMailSettings(
HWND hwndParent,
LPINETCLIENTINFO lpINetClientInfo,
LPTSTR lpszEntryName)
{
DWORD dwRet = ERROR_SUCCESS;
MAILCONFIGINFO MailConfigInfo;
ZeroMemory(&MailConfigInfo,sizeof(MAILCONFIGINFO)); // zero out structure
if (NULL == gpWizardState)
{
gpWizardState = new WIZARDSTATE;
ASSERT(gpWizardState);
if (gpWizardState)
{
InitWizardState(gpWizardState, 0);
}
else
{
return ERROR_OUTOFMEMORY;
}
}
// call MAPI to set up profile and store this information in it
if (InitMAPI(hwndParent))
{
CHOOSEPROFILEDLGINFO ChooseProfileDlgInfo;
ZeroMemory(&ChooseProfileDlgInfo, sizeof(CHOOSEPROFILEDLGINFO));
ChooseProfileDlgInfo.fSetProfileAsDefault = TRUE;
ENUM_MAPI_PROFILE* pEnumMapiProfile = new(ENUM_MAPI_PROFILE);
if (pEnumMapiProfile && pEnumMapiProfile->GetEntryCount())
{
// Display a dialog and allow the user to select/create profile
BOOL fRet=(BOOL)DialogBoxParam(ghInstance,MAKEINTRESOURCE(IDD_CHOOSEPROFILENAME),
hwndParent, ChooseProfileDlgProc,(LPARAM) &ChooseProfileDlgInfo);
if (FALSE == fRet)
{
// user cancelled, bail
return ERROR_CANCELLED;
}
}
if (pEnumMapiProfile)
{
delete(pEnumMapiProfile);
pEnumMapiProfile = NULL;
}
// set up a structure with mail config information
MailConfigInfo.pszEmailAddress = lpINetClientInfo->szEMailAddress;
MailConfigInfo.pszEmailServer = lpINetClientInfo->szPOPServer;
MailConfigInfo.pszEmailDisplayName = lpINetClientInfo->szEMailName;
MailConfigInfo.pszEmailAccountName = lpINetClientInfo->szPOPLogonName;
MailConfigInfo.pszEmailAccountPwd = lpINetClientInfo->szPOPLogonPassword;
MailConfigInfo.pszConnectoidName = lpszEntryName;
MailConfigInfo.fRememberPassword = TRUE;
MailConfigInfo.pszProfileName = ChooseProfileDlgInfo.szProfileName;
MailConfigInfo.fSetProfileAsDefault = ChooseProfileDlgInfo.fSetProfileAsDefault;
// BUGBUG SMTP
// set up the profile through MAPI
dwRet = SetMailProfileInformation(&MailConfigInfo);
if (ERROR_SUCCESS != dwRet)
{
DisplayErrorMessage(hwndParent,IDS_ERRConfigureMail,
(DWORD) dwRet,ERRCLS_MAPI,MB_ICONEXCLAMATION);
}
DeInitMAPI();
}
else
{
// an error occurred.
dwRet = GetLastError();
if (ERROR_SUCCESS == dwRet)
{
// Error occurred, but the error code was not set.
dwRet = ERROR_INETCFG_UNKNOWN;
}
}
return dwRet;
}
//*******************************************************************
//
// FUNCTION: MakeConnectoid
//
// PURPOSE: This function will create a connectoid with the
// supplied name if lpRasEntry points to a valid RASENTRY
// struct. If username and password are given, these
// will be set as the dial params for the connectoid.
//
// PARAMETERS:
// hwndParent - window handle of calling application. This
// handle will be used as the parent for any dialogs that
// are required for error messages or the "choose modem"
// dialog.
// dwfOptions - a combination of INETCFG_ flags that controls
// the installation and configuration.
// lpszPhonebook - name of phone book to store the entry in
// lpszEntryName - name of connectoid to create/modify
// lpRasEntry - connectoid data
// lpszUsername - username to associate with connectoid
// lpszPassword - password to associate with connectoid
// lpfNeedsRestart - set to true if we need a restart. Note that
// since this is an internal helper function, we
// assume that the pointer is valid, and we don't
// initialize it (we only touch it if we are setting
// it to TRUE).
//
// RETURNS: HRESULT code, ERROR_SUCCESS if no errors occurred
//
// HISTORY:
// 96/03/12 markdu Created.
//
//*******************************************************************
DWORD MakeConnectoid(
HWND hwndParent,
DWORD dwfOptions,
LPCTSTR lpszPhonebook,
LPCTSTR lpszEntryName,
LPRASENTRY lpRasEntry,
LPCTSTR lpszUsername,
LPCTSTR lpszPassword,
LPBOOL lpfNeedsRestart)
{
DWORD dwRet;
ASSERT(lpfNeedsRestart);
if (dwfOptions & RASEO_UseCountryAndAreaCodes)
{
if ((0 == lpRasEntry->dwCountryCode) || (0 == lpRasEntry->dwCountryID))
return ERROR_INVALID_PARAMETER;
}
if (0 == lstrlen(lpRasEntry->szLocalPhoneNumber))
{
return ERROR_INVALID_PARAMETER;
}
// Load RNA if not already loaded since ENUM_MODEM needs it.
dwRet = EnsureRNALoaded();
if (ERROR_SUCCESS != dwRet)
{
return dwRet;
}
//
// Enumerate the modems
//
ENUM_MODEM EnumModem;
dwRet = EnumModem.GetError();
if (ERROR_SUCCESS != dwRet)
{
return dwRet;
}
if (TRUE == IsNT())
{
BOOL bNeedModem = FALSE;
if (NULL == lpIcfgNeedModem)
return ERROR_GEN_FAILURE;
dwRet = (*lpIcfgNeedModem)(0, &bNeedModem);
if (ERROR_SUCCESS != dwRet)
{
return dwRet;
}
if (TRUE == bNeedModem)
{
if (NULL == lpIcfgInstallModem)
return ERROR_GEN_FAILURE;
dwRet = (*lpIcfgInstallModem)(NULL, 0, lpfNeedsRestart);
//
// TODO: Check to see if user cancelled
//
}
}
else
{
// If there are no modems, install one if requested.
if (0 == EnumModem.GetNumDevices())
{
if (!(dwfOptions & INETCFG_INSTALLMODEM))
{
// We have not been asked to install a modem, so there
// is nothing further we can do.
return ERROR_INVALID_PARAMETER;
}
if (FALSE == IsNT())
{
//
// 5/22/97 jmazner Olympus #4698
// On Win95, calling RasEnumDevices launches RNAAP.EXE
// If RNAAP.EXE is running, any modems you install won't be usable
// So, nuke RNAAP.EXE before installing the modem.
//
TCHAR szWindowTitle[255] = TEXT("\0nogood");
//
// Unload the RAS dll's before killing RNAAP, just to be safe
//
DeInitRNA();
LoadSz(IDS_RNAAP_TITLE,szWindowTitle,255);
HWND hwnd = FindWindow(szWindowTitle, NULL);
if (NULL != hwnd)
{
if (!PostMessage(hwnd, WM_CLOSE, 0, 0))
{
DEBUGMSG("Trying to kill RNAAP window returned getError %d", GetLastError());
}
}
}
// invoke the modem wizard UI to install the modem
UINT uRet = InvokeModemWizard(NULL);
if (uRet != ERROR_SUCCESS)
{
DisplayErrorMessage(hwndParent,IDS_ERRInstallModem,uRet,
ERRCLS_STANDARD,MB_ICONEXCLAMATION);
return ERROR_INVALID_PARAMETER;
}
if (FALSE == IsNT())
{
// Reload the RAS dlls now that the modem has been safely installed.
InitRNA(hwndParent);
}
// Re-numerate the modems to be sure we have the most recent changes
dwRet = EnumModem.ReInit();
if (ERROR_SUCCESS != dwRet)
{
return dwRet;
}
// If there are still no modems, user cancelled
if (0 == EnumModem.GetNumDevices())
{
return ERROR_CANCELLED;
}
else
{
// ChrisK 5-2-97 Removed per GeoffR
// // 96/05/01 markdu ICW BUG 8049 Reboot if modem is installed.
// *lpfNeedsRestart = TRUE;
}
}
}
// Validate the device if possible
if (lstrlen(lpRasEntry->szDeviceName) && lstrlen(lpRasEntry->szDeviceType))
{
// Verify that there is a device with the given name and type
if (!EnumModem.VerifyDeviceNameAndType(lpRasEntry->szDeviceName,
lpRasEntry->szDeviceType))
{
// There was no device that matched both name and type,
// so reset the strings and bring up the choose modem UI.
lpRasEntry->szDeviceName[0] = '\0';
lpRasEntry->szDeviceType[0] = '\0';
}
}
else if (lstrlen(lpRasEntry->szDeviceName))
{
// Only the name was given. Try to find a matching type.
// If this fails, fall through to recovery case below.
LPTSTR szDeviceType =
EnumModem.GetDeviceTypeFromName(lpRasEntry->szDeviceName);
if (szDeviceType)
{
lstrcpy (lpRasEntry->szDeviceType, szDeviceType);
}
}
else if (lstrlen(lpRasEntry->szDeviceType))
{
// Only the type was given. Try to find a matching name.
// If this fails, fall through to recovery case below.
LPTSTR szDeviceName =
EnumModem.GetDeviceNameFromType(lpRasEntry->szDeviceType);
if (szDeviceName)
{
lstrcpy (lpRasEntry->szDeviceName, szDeviceName);
}
}
// If either name or type is missing, bring up choose modem UI if there
// are multiple devices, else just get first device.
// Since we already verified that there was at least one device,
// we can assume that this will succeed.
if(!lstrlen(lpRasEntry->szDeviceName) ||
!lstrlen(lpRasEntry->szDeviceType))
{
if (1 == EnumModem.GetNumDevices())
{
// There is just one device installed, so copy the name
lstrcpy (lpRasEntry->szDeviceName, EnumModem.Next());
}
else
{
// structure to pass to dialog to fill out
CHOOSEMODEMDLGINFO ChooseModemDlgInfo;
// Display a dialog and allow the user to select modem
BOOL fRet=(BOOL)DialogBoxParam(ghInstance,MAKEINTRESOURCE(IDD_CHOOSEMODEMNAME),hwndParent,
ChooseModemDlgProc,(LPARAM) &ChooseModemDlgInfo);
if (FALSE == fRet)
{
// user cancelled or an error occurred.
dwRet = GetLastError();
if (ERROR_SUCCESS == dwRet)
{
// Error occurred, but the error code was not set.
dwRet = ERROR_INETCFG_UNKNOWN;
}
return dwRet;
}
// Copy the modem name string
lstrcpy (lpRasEntry->szDeviceName, ChooseModemDlgInfo.szModemName);
}
// Now get the type string for this modem
lstrcpy (lpRasEntry->szDeviceType,
EnumModem.GetDeviceTypeFromName(lpRasEntry->szDeviceName));
ASSERT(lstrlen(lpRasEntry->szDeviceName));
ASSERT(lstrlen(lpRasEntry->szDeviceType));
}
// Create a connectoid with given properties
dwRet = CreateConnectoid(lpszPhonebook, lpszEntryName, lpRasEntry,
lpszUsername,lpszPassword);
// 96/05/06 markdu NASH BUG 21027 If DNS is set globally, clear it out so
// the per-connectoid settings will be saved.
BOOL fTemp;
DoDNSCheck(hwndParent,&fTemp);
if (TRUE == fTemp)
{
*lpfNeedsRestart = TRUE;
}
return dwRet;
}
//*******************************************************************
//
// FUNCTION: InetGetAutodial
//
// PURPOSE: This function will get the autodial settings from the registry.
//
// PARAMETERS: lpfEnable - on return, this will be TRUE if autodial
// is enabled
// lpszEntryName - on return, this buffer will contain the
// name of the phone book entry that is set for autodial
// cbEntryNameSize - size of buffer for phone book entry name
//
// RETURNS: HRESULT code, ERROR_SUCCESS if no errors occurred
//
// HISTORY:
// 96/03/11 markdu Created.
//
//*******************************************************************
#ifdef UNICODE
extern "C" HRESULT WINAPI InetGetAutodialA
(
LPBOOL lpfEnable,
LPSTR lpszEntryName,
DWORD cbEntryNameSize
)
{
HRESULT hr;
TCHAR *szEntryName = (TCHAR *)new TCHAR[cbEntryNameSize+1];
if(szEntryName == NULL)
{
lpszEntryName[0] = '\0';
return ERROR_NOT_ENOUGH_MEMORY;
}
hr = InetGetAutodialW(lpfEnable, szEntryName, (cbEntryNameSize)*sizeof(TCHAR));
if (hr == ERROR_SUCCESS)
{
wcstombs(lpszEntryName, szEntryName, cbEntryNameSize);
}
delete [] szEntryName;
return hr;
}
extern "C" HRESULT WINAPI InetGetAutodialW
#else
extern "C" HRESULT WINAPI InetGetAutodialA
#endif
(
LPBOOL lpfEnable,
LPTSTR lpszEntryName,
DWORD cbEntryNameSize
)
{
HRESULT dwRet;
DEBUGMSG("export.c::InetGetAutodial()");
ASSERT(lpfEnable);
ASSERT(lpszEntryName);
ASSERT(cbEntryNameSize);
if (!lpfEnable || !lpszEntryName || (cbEntryNameSize == 0))
{
return ERROR_BAD_ARGUMENTS;
}
HINSTANCE hInst = NULL;
FARPROC fp = NULL;
hInst = LoadLibrary(cszWininet);
if (hInst)
{
fp = GetProcAddress(hInst,cszInternetQueryOption);
if (fp)
{
CHAR szDefaultConnection[RAS_MaxEntryName+1];
DWORD cchDefaultConnection =
sizeof(szDefaultConnection) / sizeof(szDefaultConnection[0]);
// cchDefaultConnection counts the null-terminator
if (!((INTERNETQUERYOPTION)(fp))(
NULL,
INTERNET_OPTION_AUTODIAL_CONNECTION,
szDefaultConnection,
&cchDefaultConnection
))
{
dwRet = GetLastError();
}
else if ((cchDefaultConnection * sizeof(TCHAR)) > cbEntryNameSize)
{
dwRet = ERROR_INSUFFICIENT_BUFFER;
}
else
{
dwRet = ERROR_SUCCESS;
if (cchDefaultConnection == 0)
{
lpszEntryName[0] = TEXT('\0');
}
else
{
#ifdef UNICODE
mbstowcs(lpszEntryName, szDefaultConnection, cchDefaultConnection);
#else
lstrcpyn(lpszEntryName, szDefaultConnection, cchDefaultConnection);
#endif
}
}
}
else
{
dwRet = GetLastError();
}
FreeLibrary(hInst);
hInst = NULL;
}
else
{
dwRet = GetLastError();
}
if (ERROR_SUCCESS != dwRet)
{
// Get the name of the connectoid set for autodial.
// HKCU\RemoteAccess\InternetProfile
RegEntry reName(szRegPathRNAWizard,HKEY_CURRENT_USER);
dwRet = reName.GetError();
if (ERROR_SUCCESS == dwRet)
{
reName.GetString(szRegValInternetProfile,lpszEntryName,cbEntryNameSize);
dwRet = reName.GetError();
}
if (ERROR_SUCCESS != dwRet)
{
return dwRet;
}
}
// Get setting from registry that indicates whether autodialing is enabled.
// HKCU\Software\Microsoft\Windows\CurrentVersion\InternetSettings\EnableAutodial
RegEntry reEnable(szRegPathInternetSettings,HKEY_CURRENT_USER);
dwRet = reEnable.GetError();
if (ERROR_SUCCESS == dwRet)
{
DWORD dwVal = reEnable.GetNumber(szRegValEnableAutodial, 0);
dwRet = reEnable.GetError();
if (ERROR_SUCCESS == dwRet)
{
*lpfEnable = dwVal;
}
}
return dwRet;
}
//*******************************************************************
//
// FUNCTION: InetSetAutodial
//
// PURPOSE: This function will set the autodial settings in the registry.
//
// PARAMETERS: fEnable - If set to TRUE, autodial will be enabled.
// If set to FALSE, autodial will be disabled.
// lpszEntryName - name of the phone book entry to set
// for autodial. If this is "", the
// entry is cleared. If NULL, it is not changed.
//
// RETURNS: HRESULT code, ERROR_SUCCESS if no errors occurred
//
// HISTORY:
// 96/03/11 markdu Created.
//
//*******************************************************************
#ifdef UNICODE
extern "C" HRESULT WINAPI InetSetAutodialA
(
BOOL fEnable,
LPCSTR lpszEntryName
)
{
HRESULT hr;
LPTSTR szEntryName;
szEntryName = ToUnicodeWithAlloc(lpszEntryName);
hr = InetSetAutodialW(fEnable, szEntryName);
if(szEntryName)
GlobalFree(szEntryName);
return hr;
}
extern "C" HRESULT WINAPI InetSetAutodialW
#else
extern "C" HRESULT WINAPI InetSetAutodialA
#endif
(
BOOL fEnable,
LPCTSTR lpszEntryName
)
{
HRESULT dwRet = ERROR_SUCCESS;
BOOL bRet = FALSE;
DEBUGMSG("export.c::InetSetAutodial()");
// 2 seperate calls:
HINSTANCE hInst = NULL;
FARPROC fp = NULL;
dwRet = ERROR_SUCCESS;
hInst = LoadLibrary(cszWininet);
if (hInst && lpszEntryName)
{
fp = GetProcAddress(hInst,cszInternetSetOption);
if (fp)
{
CHAR szNewDefaultConnection[RAS_MaxEntryName+1];
#ifdef UNICODE
wcstombs(szNewDefaultConnection, lpszEntryName, RAS_MaxEntryName);
#else
lstrcpyn(szNewDefaultConnection, lpszEntryName, lstrlen(lpszEntryName)+1);
#endif
bRet = ((INTERNETSETOPTION)fp) (NULL,
INTERNET_OPTION_AUTODIAL_CONNECTION,
szNewDefaultConnection,
strlen(szNewDefaultConnection));
if (bRet)
{
DWORD dwMode = AUTODIAL_MODE_ALWAYS;
bRet = ((INTERNETSETOPTION)fp) (NULL, INTERNET_OPTION_AUTODIAL_MODE, &dwMode, sizeof(DWORD));
}
if( !bRet )
{
dwRet = GetLastError();
DEBUGMSG("INETCFG export.c::InetSetAutodial() InternetSetOption failed");
}
}
else
{
dwRet = GetLastError();
}
}
// From DarrnMi, INTERNETSETOPTION for autodial is new for 5.5.
// We should try it this way and if the InternetSetOption fails (you'll get invalid option),
// set the registry the old way. That'll work everywhere.
if (!bRet)
{
// Set the name if given, else do not change the entry.
if (lpszEntryName)
{
// Set the name of the connectoid for autodial.
// HKCU\RemoteAccess\InternetProfile
RegEntry reName(szRegPathRNAWizard,HKEY_CURRENT_USER);
dwRet = reName.GetError();
if (ERROR_SUCCESS == dwRet)
{
dwRet = reName.SetValue(szRegValInternetProfile,lpszEntryName);
}
}
//
// 9/9/97 jmazner IE bug #57426
// IE 4 uses HKEY_CURRENT_CONFIG to store autodial settings based on current
// hardware config. We need to update this key as well as HK_CU
//
if (ERROR_SUCCESS == dwRet)
{
// Set setting in the registry that indicates whether autodialing is enabled.
// HKCC\Software\Microsoft\Windows\CurrentVersion\InternetSettings\EnableAutodial
RegEntry reEnable(szRegPathInternetSettings,HKEY_CURRENT_CONFIG);
dwRet = reEnable.GetError();
if (ERROR_SUCCESS == dwRet)
{
dwRet = reEnable.SetValue(szRegValEnableAutodial, fEnable);
}
}
if (ERROR_SUCCESS == dwRet)
{
// Set setting in the registry that indicates whether autodialing is enabled.
// HKCU\Software\Microsoft\Windows\CurrentVersion\InternetSettings\EnableAutodial
RegEntry reEnable(szRegPathInternetSettings,HKEY_CURRENT_USER);
dwRet = reEnable.GetError();
if (ERROR_SUCCESS == dwRet)
{
dwRet = reEnable.SetValue(szRegValEnableAutodial, fEnable);
dwRet = reEnable.SetValue(szRegValNoNetAutodial, (unsigned long)FALSE);
}
}
// 2/10/97 jmazner Normandy #9705, 13233
// Notify wininet when we change proxy or autodial
if (fp)
{
if( !((INTERNETSETOPTION)fp) (NULL, INTERNET_OPTION_SETTINGS_CHANGED, NULL, 0) )
{
dwRet = GetLastError();
DEBUGMSG("INETCFG export.c::InetSetAutodial() InternetSetOption failed");
}
}
else
{
dwRet = GetLastError();
}
}
if (hInst)
{
FreeLibrary(hInst);
hInst = NULL;
}
return dwRet;
}
/*******************************************************************
NAME: NeedDriversDlgProc
SYNOPSIS: Dialog proc for installing drivers
********************************************************************/
UINT g_uQueryCancelAutoPlay = 0;
INT_PTR CALLBACK NeedDriversDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam,LPARAM lParam)
{
switch (uMsg)
{
case WM_INITDIALOG:
{
// lParam contains pointer to NEEDDRIVERSDLGINFO struct, set it
// in window data
ASSERT(lParam);
SetWindowLongPtr(hDlg,DWLP_USER,lParam);
return NeedDriversDlgInit(hDlg,(PNEEDDRIVERSDLGINFO) lParam);
break;
}
case WM_COMMAND:
{
switch (LOWORD(wParam))
{
case IDOK:
{
// get data pointer from window data
PNEEDDRIVERSDLGINFO pNeedDriversDlgInfo =
(PNEEDDRIVERSDLGINFO) GetWindowLongPtr(hDlg,DWLP_USER);
ASSERT(pNeedDriversDlgInfo);
// pass the data to the OK handler
int fRet=NeedDriversDlgOK(hDlg,pNeedDriversDlgInfo);
EndDialog(hDlg,fRet);
break;
}
case IDCANCEL:
{
SetLastError(ERROR_CANCELLED);
EndDialog(hDlg,0);
break;
}
}
break;
}
default:
{
if(!g_uQueryCancelAutoPlay)
g_uQueryCancelAutoPlay = RegisterWindowMessage(TEXT("QueryCancelAutoPlay"));
if (uMsg && uMsg == g_uQueryCancelAutoPlay)
return 1;
}
}
return FALSE;
}
/*******************************************************************
NAME: NeedDriversDlgInit
SYNOPSIS: proc to handle initialization of dialog for installing files
********************************************************************/
BOOL NeedDriversDlgInit(HWND hDlg,PNEEDDRIVERSDLGINFO pNeedDriversDlgInfo)
{
ASSERT(pNeedDriversDlgInfo);
// put the dialog in the center of the screen
RECT rc;
GetWindowRect(hDlg, &rc);
SetWindowPos(hDlg, NULL,
((GetSystemMetrics(SM_CXSCREEN) - (rc.right - rc.left)) / 2),
((GetSystemMetrics(SM_CYSCREEN) - (rc.bottom - rc.top)) / 2),
0, 0, SWP_NOSIZE | SWP_NOACTIVATE);
return TRUE;
}
/*******************************************************************
NAME: NeedDriversDlgOK
SYNOPSIS: OK handler for dialog for installing files
********************************************************************/
int NeedDriversDlgOK(HWND hDlg,PNEEDDRIVERSDLGINFO pNeedDriversDlgInfo)
{
int nResult = 1;
ASSERT(pNeedDriversDlgInfo);
// set the dialog text to "Installing files..." to give feedback to
// user
TCHAR szMsg[MAX_RES_LEN+1];
LoadSz(IDS_INSTALLING_FILES,szMsg,sizeof(szMsg));
SetDlgItemText(hDlg,IDC_TX_STATUS,szMsg);
// disable buttons & dialog so it can't get focus
EnableDlg(hDlg, FALSE);
FARPROC hShell32VersionProc = NULL;
BOOL bWasEnabled = FALSE;
// install the drivers we need
HMODULE hShell32Mod = (HMODULE)LoadLibrary(TEXT("shell32.dll"));
if (hShell32Mod)
hShell32VersionProc = GetProcAddress(hShell32Mod, "DllGetVersion");
if(!hShell32VersionProc)
bWasEnabled = TweakAutoRun(FALSE);
DWORD dwRet = lpIcfgInstallInetComponents(hDlg,
pNeedDriversDlgInfo->dwfOptions,
pNeedDriversDlgInfo->lpfNeedsRestart);
if(!hShell32VersionProc)
TweakAutoRun(bWasEnabled);
if (ERROR_SUCCESS != dwRet)
{
//
// Don't display error message if user cancelled
//
nResult = 0;
// Enable the dialog again
EnableDlg(hDlg, TRUE);
SetLastError(dwRet);
}
else
{
// Enable the dialog again
EnableDlg(hDlg, TRUE);
}
return nResult;
}
/*******************************************************************
NAME: EnableDlg
SYNOPSIS: Enables or disables the dlg buttons and the dlg
itself (so it can't receive focus)
********************************************************************/
VOID EnableDlg(HWND hDlg,BOOL fEnable)
{
// disable/enable ok and cancel buttons
EnableWindow(GetDlgItem(hDlg,IDOK),fEnable);
EnableWindow(GetDlgItem(hDlg,IDCANCEL),fEnable);
// disable/enable dlg
EnableWindow(hDlg,fEnable);
UpdateWindow(hDlg);
}
/*******************************************************************
NAME: ChooseModemDlgProc
SYNOPSIS: Dialog proc for choosing modem
********************************************************************/
INT_PTR CALLBACK ChooseModemDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam,
LPARAM lParam)
{
BOOL fRet;
switch (uMsg)
{
case WM_INITDIALOG:
// lParam contains pointer to CHOOSEMODEMDLGINFO struct, set it
// in window data
ASSERT(lParam);
SetWindowLongPtr(hDlg,DWLP_USER,lParam);
fRet = ChooseModemDlgInit(hDlg,(PCHOOSEMODEMDLGINFO) lParam);
if (!fRet)
{
// An error occured.
EndDialog(hDlg,FALSE);
}
return fRet;
break;
case WM_COMMAND:
switch (LOWORD(wParam))
{
case IDOK:
{
// get data pointer from window data
PCHOOSEMODEMDLGINFO pChooseModemDlgInfo =
(PCHOOSEMODEMDLGINFO) GetWindowLongPtr(hDlg,DWLP_USER);
ASSERT(pChooseModemDlgInfo);
// pass the data to the OK handler
fRet=ChooseModemDlgOK(hDlg,pChooseModemDlgInfo);
if (fRet)
{
EndDialog(hDlg,TRUE);
}
}
break;
case IDCANCEL:
SetLastError(ERROR_CANCELLED);
EndDialog(hDlg,FALSE);
break;
}
break;
}
return FALSE;
}
/*******************************************************************
NAME: ChooseModemDlgInit
SYNOPSIS: proc to handle initialization of dialog for choosing modem
********************************************************************/
BOOL ChooseModemDlgInit(HWND hDlg,PCHOOSEMODEMDLGINFO pChooseModemDlgInfo)
{
ASSERT(pChooseModemDlgInfo);
// put the dialog in the center of the screen
RECT rc;
GetWindowRect(hDlg, &rc);
SetWindowPos(hDlg, NULL,
((GetSystemMetrics(SM_CXSCREEN) - (rc.right - rc.left)) / 2),
((GetSystemMetrics(SM_CYSCREEN) - (rc.bottom - rc.top)) / 2),
0, 0, SWP_NOSIZE | SWP_NOACTIVATE);
// fill the combobox with available modems
DWORD dwRet = InitModemList(GetDlgItem(hDlg,IDC_MODEM));
if (ERROR_SUCCESS != dwRet)
{
DisplayErrorMessage(hDlg,IDS_ERREnumModem,dwRet,
ERRCLS_STANDARD,MB_ICONEXCLAMATION);
SetLastError(dwRet);
return FALSE;
}
return TRUE;
}
/*******************************************************************
NAME: ChooseModemDlgOK
SYNOPSIS: OK handler for dialog for choosing modem
********************************************************************/
BOOL ChooseModemDlgOK(HWND hDlg,PCHOOSEMODEMDLGINFO pChooseModemDlgInfo)
{
ASSERT(pChooseModemDlgInfo);
// should always have a selection in combo box if we get here
ASSERT(ComboBox_GetCurSel(GetDlgItem(hDlg,IDC_MODEM)) >= 0);
// get modem name out of combo box
ComboBox_GetText(GetDlgItem(hDlg,IDC_MODEM),
pChooseModemDlgInfo->szModemName,
ARRAYSIZE(pChooseModemDlgInfo->szModemName));
NULL_TERM_TCHARS(pChooseModemDlgInfo->szModemName);
ASSERT(lstrlen(pChooseModemDlgInfo->szModemName));
// clear the modem list
ComboBox_ResetContent(GetDlgItem(hDlg,IDC_MODEM));
return TRUE;
}
/*******************************************************************
NAME: ChooseProfileDlgProc
SYNOPSIS: Dialog proc for choosing profile
********************************************************************/
INT_PTR CALLBACK ChooseProfileDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam,
LPARAM lParam)
{
switch (uMsg)
{
case WM_INITDIALOG:
// lParam contains pointer to CHOOSEPROFILEDLGINFO struct, set it
// in window data
ASSERT(lParam);
SetWindowLongPtr(hDlg,DWLP_USER,lParam);
return ChooseProfileDlgInit(hDlg,(PCHOOSEPROFILEDLGINFO) lParam);
break;
case WM_COMMAND:
switch (LOWORD(wParam))
{
case IDOK:
{
// get data pointer from window data
PCHOOSEPROFILEDLGINFO pChooseProfileDlgInfo =
(PCHOOSEPROFILEDLGINFO) GetWindowLongPtr(hDlg,DWLP_USER);
ASSERT(pChooseProfileDlgInfo);
// pass the data to the OK handler
BOOL fRet=ChooseProfileDlgOK(hDlg,pChooseProfileDlgInfo);
if (fRet)
{
EndDialog(hDlg,TRUE);
}
}
break;
case IDCANCEL:
EndDialog(hDlg,FALSE);
break;
case IDC_NEW_PROFILE:
// user has requested to create a new profile
DoNewProfileDlg(hDlg);
return TRUE;
break;
}
break;
}
return FALSE;
}
/*******************************************************************
NAME: ChooseProfileDlgInit
SYNOPSIS: proc to handle initialization of dialog for choosing profile
********************************************************************/
BOOL ChooseProfileDlgInit(HWND hDlg,PCHOOSEPROFILEDLGINFO pChooseProfileDlgInfo)
{
ASSERT(pChooseProfileDlgInfo);
// put the dialog in the center of the screen
// 96/04/23 markdu NASH BUG 18719 Make the choose profile dialog TOPMOST.
RECT rc;
GetWindowRect(hDlg, &rc);
SetWindowPos(hDlg, HWND_TOPMOST,
((GetSystemMetrics(SM_CXSCREEN) - (rc.right - rc.left)) / 2),
((GetSystemMetrics(SM_CYSCREEN) - (rc.bottom - rc.top)) / 2),
0, 0, SWP_NOSIZE | SWP_NOACTIVATE);
// populate the combo box with names of profiles
ENUM_MAPI_PROFILE EnumMapiProfile;
LPTSTR pProfileName=NULL;
BOOL fDefault;
int iSel;
HWND hwndCombo = GetDlgItem(hDlg,IDC_PROFILE_LIST);
ASSERT(hwndCombo);
// enumerate profile names
while (EnumMapiProfile.Next(&pProfileName,&fDefault))
{
ASSERT(pProfileName);
// add profile names to combo box
iSel=ComboBox_AddString(hwndCombo,pProfileName);
ASSERT(iSel >= 0);
// if this is the default profile, set it as selection
if (fDefault)
{
ComboBox_SetCurSel(hwndCombo,iSel);
}
}
// should always be a default profile (and should always be at least
// one existing profile if we get here)... but just in case, select
// the first profile in list if there's no selection made so far
if (ComboBox_GetCurSel(hwndCombo) < 0)
ComboBox_SetCurSel(hwndCombo,0);
// initialize "set this profile as default" checkbox to be the
// value that was passed in (in the structure)
CheckDlgButton(hDlg,IDC_SETDEFAULT,pChooseProfileDlgInfo->fSetProfileAsDefault);
return TRUE;
}
/*******************************************************************
NAME: ChooseProfileDlgOK
SYNOPSIS: OK handler for dialog for choosing profile
********************************************************************/
BOOL ChooseProfileDlgOK(HWND hDlg,PCHOOSEPROFILEDLGINFO pChooseProfileDlgInfo)
{
ASSERT(pChooseProfileDlgInfo);
// should always have a selection in combo box if we get here
ASSERT(ComboBox_GetCurSel(GetDlgItem(hDlg,IDC_PROFILE_LIST)) >= 0);
// get selected profile from combo box
ComboBox_GetText(GetDlgItem(hDlg,IDC_PROFILE_LIST),
pChooseProfileDlgInfo->szProfileName,
ARRAYSIZE(pChooseProfileDlgInfo->szProfileName));
NULL_TERM_TCHARS(pChooseProfileDlgInfo->szProfileName);
// get 'use as default profile' checkbox state
pChooseProfileDlgInfo->fSetProfileAsDefault = IsDlgButtonChecked(hDlg,
IDC_SETDEFAULT);
return TRUE;
}
//*******************************************************************
//
// FUNCTION: InetSetAutoProxy
//
// PURPOSE: This function will set the auto config proxy settings
// in the registry.
//
// PARAMETERS: fEnable - If set to TRUE, proxy will be enabled.
// If set to FALSE, proxy will be disabled.
// dwProxyDetectMode - value to be update in the
// HKEY_CURRENT_USER\Software\Microsoft
// \Windows\CurrentVersion\Internet Settings
// AutoProxyDetectMode
// lpszScriptAddr - value to be update in
// HKEY_CURRENT_USER\Software\Microsoft
// \Windows\CurrentVersion\Internet Settings
// AutoConfigURL
//
// RETURNS: HRESULT code, ERROR_SUCCESS if no errors occurred
//
//*******************************************************************
#ifdef UNICODE
HRESULT WINAPI InetSetAutoProxyA
(
BOOL fEnable,
DWORD dwProxyDetectMode,
LPCSTR lpszScriptAddr
)
{
HRESULT hr;
LPTSTR szScriptAddr;
szScriptAddr = ToUnicodeWithAlloc(lpszScriptAddr);
hr = InetSetAutoProxyW(fEnable, dwProxyDetectMode, szScriptAddr);
if(szScriptAddr)
GlobalFree(szScriptAddr);
return hr;
}
HRESULT WINAPI InetSetAutoProxyW
#else
HRESULT WINAPI InetSetAutoProxyA
#endif
(
BOOL fEnable,
DWORD dwProxyDetectMode,
LPCTSTR lpszScriptAddr
)
{
DWORD dwRet = ERROR_GEN_FAILURE;
HKEY hKey;
if (!fEnable)
return ERROR_SUCCESS;
if (ERROR_SUCCESS == (dwRet = RegOpenKey(HKEY_CURRENT_USER, REGSTR_PATH_INTERNET_SETTINGS, &hKey)) )
{
RegSetValueEx(hKey,
cszRegValAutoProxyDetectMode,
0,
REG_BINARY,
(LPBYTE) &dwProxyDetectMode,
sizeof(DWORD));
RegSetValueEx(hKey,
cszRegValAutoConfigURL,
0,
REG_SZ,
(LPBYTE) lpszScriptAddr,
sizeof(TCHAR)*(lstrlen(lpszScriptAddr) + 1 ));
RegCloseKey(hKey);
}
return dwRet;
}
//*******************************************************************
//
// FUNCTION: InetSetProxy
//
// PURPOSE: This function will set the proxy settings in the registry.
// On Win32 platforms, it will then attempt to notify WinInet
// of the changes made.
//
// PARAMETERS: fEnable - If set to TRUE, proxy will be enabled.
// If set to FALSE, proxy will be disabled.
// lpszServer - name of the proxy server. If this is "", the
// entry is cleared. If NULL, it is not changed.
// lpszOverride - proxy override. If this is "", the
// entry is cleared. If NULL, it is not changed.
//
// RETURNS: HRESULT code, ERROR_SUCCESS if no errors occurred
//
//*******************************************************************
#ifdef UNICODE
HRESULT WINAPI InetSetProxyA
(
BOOL fEnable,
LPCSTR lpszServer,
LPCSTR lpszOverride
)
{
return ERROR_SUCCESS;
}
HRESULT WINAPI InetSetProxyW
#else
HRESULT WINAPI InetSetProxyA
#endif
(
BOOL fEnable,
LPCTSTR lpszServer,
LPCTSTR lpszOverride
)
{
return ERROR_SUCCESS;
}
//*******************************************************************
//
// FUNCTION: InetSetProxyEx
//
// PURPOSE: This function will set the proxy settings in the registry.
//
// PARAMETERS: fEnable - If set to TRUE, proxy will be enabled.
// If set to FALSE, proxy will be disabled.
// lpszConnectoidName - Name of connectoid to set proxy on
// NULL for LAN
// lpszServer - name of the proxy server. If this is "", the
// entry is cleared. If NULL, it is not changed.
// lpszOverride - proxy override. If this is "", the
// entry is cleared. If NULL, it is not changed.
//
// RETURNS: HRESULT code, ERROR_SUCCESS if no errors occurred
//
//*******************************************************************
#ifdef UNICODE
HRESULT WINAPI InetSetProxyExA
(
BOOL fEnable,
LPCSTR lpszConnectoidName,
LPCSTR lpszServer,
LPCSTR lpszOverride
)
{
TCHAR szConnectoidNameW[MAX_ISP_NAME + 1];
TCHAR szServerW[MAX_URL_STRING + 1];
TCHAR szOverrideW[MAX_URL_STRING + 1];
mbstowcs(szConnectoidNameW,lpszConnectoidName,lstrlenA(lpszConnectoidName)+1);
mbstowcs(szServerW, lpszServer, lstrlenA(lpszServer)+1);
mbstowcs(szOverrideW, lpszOverride, lstrlenA(lpszOverride)+1);
return InetSetProxyExW(fEnable, szConnectoidNameW, szServerW, szOverrideW);
}
HRESULT WINAPI InetSetProxyExW
#else
HRESULT WINAPI InetSetProxyExA
#endif
(
BOOL fEnable,
LPCTSTR lpszConnectoidName,
LPCTSTR lpszServer,
LPCTSTR lpszOverride
)
{
HKEY hKeyCU;
HKEY hKeyCC;
HKEY hKeyCULan;
DWORD dwRet = ERROR_SUCCESS;
DWORD dwSize;
DWORD dwType;
DWORD dwVal;
DEBUGMSG("export.c::InetSetProxy()");
// 12/15/98 vyung
// Change to use Wininet API to set proxy info. Old way of changing
// it through the registry is no longer supported.
HINSTANCE hInst = NULL;
FARPROC fpInternetSetOption, fpInternetQueryOption = NULL;
dwRet = ERROR_SUCCESS;
hInst = LoadLibrary(cszWininet);
if (hInst)
{
fpInternetSetOption = GetProcAddress(hInst,cszInternetSetOption);
fpInternetQueryOption = GetProcAddress(hInst,cszInternetQueryOption);
if (fpInternetSetOption)
{
INTERNET_PER_CONN_OPTION_LISTA list;
DWORD dwBufSize = sizeof(list);
CHAR szProxyServer[RAS_MaxEntryName+1];
CHAR szProxyOverride[RAS_MaxEntryName+1];
CHAR szConnectoidName[RAS_MaxEntryName+1];
DWORD dwOptions = 4; // always save FLAGS & DISCOVERY_FLAGS
BOOL fRes;
memset(szProxyServer, 0, sizeof(szProxyServer));
memset(szProxyOverride, 0, sizeof(szProxyServer));
memset(szConnectoidName, 0, sizeof(szProxyServer));
#ifdef UNICODE
if (lpszServer)
wcstombs(szProxyServer, lpszServer, RAS_MaxEntryName+1);
if(lpszOverride)
wcstombs(szProxyOverride, lpszOverride, RAS_MaxEntryName+1);
if(lpszConnectoidName)
wcstombs(szConnectoidName, lpszConnectoidName, RAS_MaxEntryName+1);
#else
if (lpszServer)
lstrcpy(szProxyServer, lpszServer);
if(lpszOverride)
lstrcpy(szProxyOverride, lpszOverride);
if(lpszConnectoidName)
lstrcpy(szConnectoidName, lpszConnectoidName);
#endif
// fill out list struct
list.dwSize = sizeof(list);
if (NULL == lpszConnectoidName)
list.pszConnection = NULL; // NULL == LAN,
else
list.pszConnection = szConnectoidName; // otherwise connectoid name
list.dwOptionCount = 1; // set three options
list.pOptions = new INTERNET_PER_CONN_OPTIONA[5];
if(NULL != list.pOptions)
{
// set flags
list.pOptions[0].dwOption = INTERNET_PER_CONN_AUTODISCOVERY_FLAGS;
//
// Query autodiscover flags - we just need to set one bit in there
//
if (fpInternetQueryOption)
{
if( !((INTERNETQUERYOPTION)fpInternetQueryOption) (NULL, INTERNET_OPTION_PER_CONNECTION_OPTION, &list, &dwBufSize) )
{
dwRet = GetLastError();
DEBUGMSG("INETCFG export.c::InetSetAutodial() InternetSetOption failed");
}
}
else
dwRet = GetLastError();
//
// save off all other options
//
list.pOptions[0].Value.dwValue |= AUTO_PROXY_FLAG_USER_SET;
list.pOptions[1].dwOption = INTERNET_PER_CONN_FLAGS;
list.pOptions[1].Value.dwValue = PROXY_TYPE_DIRECT;
//
// save proxy settings
//
if (fEnable)
{
list.pOptions[1].Value.dwValue |= PROXY_TYPE_PROXY;
}
list.pOptions[2].dwOption = INTERNET_PER_CONN_PROXY_SERVER;
list.pOptions[2].Value.pszValue = szProxyServer;
list.pOptions[3].dwOption = INTERNET_PER_CONN_PROXY_BYPASS;
list.pOptions[3].Value.pszValue = szProxyOverride;
if (gpUserInfo)
{
//
// save autodetect
//
if (gpUserInfo->bAutoDiscovery)
{
list.pOptions[1].Value.dwValue |= PROXY_TYPE_AUTO_DETECT;
}
//
// save autoconfig
//
if (gpUserInfo->bAutoConfigScript)
{
list.pOptions[1].Value.dwValue |= PROXY_TYPE_AUTO_PROXY_URL;
list.pOptions[dwOptions].dwOption = INTERNET_PER_CONN_AUTOCONFIG_URL;
#ifdef UNICODE
CHAR szAutoConfigURL[MAX_URL_STRING+1];
wcstombs(szAutoConfigURL, gpUserInfo->szAutoConfigURL, MAX_URL_STRING+1);
list.pOptions[dwOptions].Value.pszValue = szAutoConfigURL;
#else
list.pOptions[dwOptions].Value.pszValue = gpUserInfo->szAutoConfigURL;
#endif
dwOptions++;
}
}
list.dwOptionCount = dwOptions;
if( !((INTERNETSETOPTION)fpInternetSetOption) (NULL, INTERNET_OPTION_PER_CONNECTION_OPTION, &list, dwBufSize) )
{
dwRet = GetLastError();
DEBUGMSG("INETCFG export.c::InetSetProxy() InternetSetOption failed");
}
delete [] list.pOptions;
}
}
else
dwRet = GetLastError();
FreeLibrary(hInst);
hInst = NULL;
}
else
{
dwRet = GetLastError();
}
return dwRet;
}
//*******************************************************************
//
// FUNCTION: InetGetProxy
//
// PURPOSE: This function will get the proxy settings from the registry.
//
// PARAMETERS: lpfEnable - on return, this will be TRUE if proxy
// is enabled
// lpszServer - on return, this buffer will contain the
// name of the proxy server
// cbServer - size of buffer for proxy server name
// lpszOverride - on return, this buffer will contain the
// name of the proxy server
// cbOverride - size of buffer for proxy override
//
// RETURNS: HRESULT code, ERROR_SUCCESS if no errors occurred
//
//*******************************************************************
#ifdef UNICODE
HRESULT WINAPI InetGetProxyA
(
LPBOOL lpfEnable,
LPSTR lpszServer,
DWORD cbServer,
LPSTR lpszOverride,
DWORD cbOverride
)
{
HRESULT hr;
TCHAR szServer[MAX_URL_STRING+1];
TCHAR szOverride[MAX_URL_STRING+1];
hr = InetGetProxyW(lpfEnable, szServer, cbServer, szOverride, cbOverride);
wcstombs(lpszServer, szServer, MAX_URL_STRING+1);
wcstombs(lpszOverride, szOverride, MAX_URL_STRING+1);
return hr;
}
HRESULT WINAPI InetGetProxyW
#else
HRESULT WINAPI InetGetProxyA
#endif
(
LPBOOL lpfEnable,
LPTSTR lpszServer,
DWORD cbServer,
LPTSTR lpszOverride,
DWORD cbOverride
)
{
HKEY hKey;
DWORD dwRet;
DWORD dwSize;
DWORD dwType;
DWORD dwVal;
DEBUGMSG("export.c::InetGetProxy()");
// NEW WININET API
//
// Read proxy and autoconfig settings for this connection
//
// Comment for UNICODE
// Wininet.dll doesn't support INTERNET_OPTION_PER_CONNECTION_OPTION
// in InternetQueryOptionW. Only InternetQueryOptionA supports the flag.
// Because of restriction of Wininet.dll I have to use A version.
// WTSEO : 3/19/99
INTERNET_PER_CONN_OPTION_LISTA list;
DWORD dwBufSize = sizeof(list);
//CHAR szEntryA[RAS_MaxEntryName + 1];
list.pszConnection = NULL;
list.dwSize = sizeof(list);
list.dwOptionCount = 4;
list.pOptions = new INTERNET_PER_CONN_OPTIONA[4];
if(NULL == list.pOptions)
{
return FALSE;
}
list.pOptions[0].dwOption = INTERNET_PER_CONN_FLAGS;
list.pOptions[1].dwOption = INTERNET_PER_CONN_PROXY_SERVER;
list.pOptions[2].dwOption = INTERNET_PER_CONN_PROXY_BYPASS;
list.pOptions[3].dwOption = INTERNET_PER_CONN_AUTOCONFIG_URL;
HINSTANCE hInst = NULL;
FARPROC fp = NULL;
dwRet = ERROR_SUCCESS;
hInst = LoadLibrary(cszWininet);
if (hInst)
{
fp = GetProcAddress(hInst,cszInternetQueryOption);
if (fp)
{
if( !((INTERNETQUERYOPTION)fp) (NULL, INTERNET_OPTION_PER_CONNECTION_OPTION, &list, &dwBufSize) )
{
dwRet = 0;//GetLastError();
DEBUGMSG("INETCFG export.c::InetSetAutodial() InternetSetOption failed");
}
}
else
dwRet = GetLastError();
FreeLibrary(hInst);
hInst = NULL;
}
else
{
dwRet = GetLastError();
}
//
// move options to gpUserInfo struct
//
if (gpUserInfo)
{
gpUserInfo->fProxyEnable = (list.pOptions[0].Value.dwValue & PROXY_TYPE_PROXY);
}
if(list.pOptions[1].Value.pszValue)
{
#ifdef UNICODE
mbstowcs(lpszServer, list.pOptions[1].Value.pszValue, MAX_URL_STRING);
#else
lstrcpyn(lpszServer, list.pOptions[1].Value.pszValue, MAX_URL_STRING);
#endif
cbServer = lstrlen(lpszServer);
}
if(list.pOptions[2].Value.pszValue)
{
#ifdef UNICODE
mbstowcs(lpszOverride, list.pOptions[2].Value.pszValue, MAX_URL_STRING);
#else
lstrcpyn(lpszOverride, list.pOptions[2].Value.pszValue, MAX_URL_STRING);
#endif
cbOverride = lstrlen(lpszOverride);;
}
//
// fill in autoconfig and autoproxy field
//
if (gpUserInfo)
{
// autoconfig enable and url
gpUserInfo->bAutoConfigScript = list.pOptions[0].Value.dwValue & PROXY_TYPE_AUTO_PROXY_URL;
if(list.pOptions[3].Value.pszValue)
{
#ifdef UNICODE
mbstowcs(gpUserInfo->szAutoConfigURL, list.pOptions[3].Value.pszValue,
lstrlenA(list.pOptions[3].Value.pszValue)+1);
#else
lstrcpy(gpUserInfo->szAutoConfigURL, list.pOptions[3].Value.pszValue);
#endif
}
// autodiscovery enable
gpUserInfo->bAutoDiscovery = list.pOptions[0].Value.dwValue & PROXY_TYPE_AUTO_DETECT;
}
// all done with options list
delete [] list.pOptions;
return dwRet;
}
//+----------------------------------------------------------------------------
// Function InetStartServices
//
// Synopsis This function guarentees that RAS services are running
//
// Arguments none
//
// Return ERROR_SUCCESS - if the services are enabled and running
//
// History 10/16/96 ChrisK Created
//-----------------------------------------------------------------------------
extern "C" HRESULT WINAPI InetStartServices()
{
ASSERT(lpIcfgStartServices);
if (NULL == lpIcfgStartServices)
return ERROR_GEN_FAILURE;
return (lpIcfgStartServices());
}
//+----------------------------------------------------------------------------
//
// Function: IEInstalled
//
// Synopsis: Tests whether a version of Internet Explorer is installed via registry keys
//
// Arguments: None
//
// Returns: TRUE - Found the IE executable
// FALSE - No IE executable found
//
// History: jmazner Created 8/19/96 (as fix for Normandy #4571)
// valdonb 10/22/96 Shamelessly stole and used for my own purposes.
//
//-----------------------------------------------------------------------------
BOOL IEInstalled(void)
{
HRESULT hr;
HKEY hKey = 0;
HANDLE hFindResult;
TCHAR szTempPath[MAX_PATH + 1] = TEXT("");
TCHAR szIELocalPath[MAX_PATH + 1] = TEXT("");
DWORD dwPathSize;
WIN32_FIND_DATA foundData;
hr = RegOpenKeyEx(HKEY_LOCAL_MACHINE, szRegPathIexploreAppPath, 0, KEY_READ, &hKey);
if (hr != ERROR_SUCCESS) return( FALSE );
dwPathSize = sizeof (szIELocalPath);
hr = RegQueryValueEx(hKey, NULL, NULL, NULL, (LPBYTE) szIELocalPath, &dwPathSize);
RegCloseKey( hKey );
if (hr != ERROR_SUCCESS) return( FALSE );
//
// Olympus 9214 ChrisK
// NT5 stores the path of IExplorer with environment strings
//
if (0 == ExpandEnvironmentStrings(szIELocalPath,szTempPath,MAX_PATH))
{
return (FALSE);
};
hFindResult = FindFirstFile( szTempPath, &foundData );
FindClose( hFindResult );
if (INVALID_HANDLE_VALUE == hFindResult) return( FALSE );
return(TRUE);
}
//+----------------------------------------------------------------------------
//
// Function: IsIEAKSignUpNeeded
//
// Synopsis: Determine if the IEAK signup should be run by checking the
// IEAK's registry flag and signup file location
//
// Arguments: pszPath - buffer to contain path to signup file
// dwPathLen - size of pszPath
//
// Returns: TRUE - if IEAK signup should be run
// FALSE - IEAK signup should not be run
//
// History: ChrisK 6/18/97 Created
//
//-----------------------------------------------------------------------------
BOOL IsIEAKSignUpNeeded(LPTSTR pszPath, DWORD dwPathLen)
{
BOOL bRC = FALSE;
//
// Validate parameters
//
DEBUGMSG("INETCFG: IsIEAKSignUpNeeded.\n");
ASSERT(pszPath);
ASSERT(dwPathLen);
if (NULL == pszPath || 0 == dwPathLen)
{
goto IsIEAKSignUpNeededExit;
}
//
// Check if IEAK registry key is set
//
{
RegEntry re(szRegIEAKSettings,HKEY_CURRENT_USER);
if (ERROR_SUCCESS != re.GetError())
goto IsIEAKSignUpNeededExit;
if (0 == re.GetNumber(szREgIEAKNeededKey, 0))
{
bRC = FALSE;
goto IsIEAKSignUpNeededExit;
}
}
//
// Check to see if IEAK signup page is available.
//
{
RegEntry rePath(szRegPathIexploreAppPath,HKEY_LOCAL_MACHINE);
if (ERROR_SUCCESS != rePath.GetError())
goto IsIEAKSignUpNeededExit;
if (NULL == rePath.GetString(szPathSubKey,pszPath,dwPathLen))
{
goto IsIEAKSignUpNeededExit;
}
dwPathLen = lstrlen(pszPath);
ASSERT(dwPathLen);
}
//
// Massage path to point at signup file
//
TCHAR *pc, *pcTemp;
pc = &(pszPath[dwPathLen]);
pc = CharPrev(pszPath,pc);
if ('\\' == *pc)
{
//
// add signup part of filename after \ character
//
pc = CharNext(pc);
}
else if (';' == *pc)
{
//
// overwrite trailing ; character
//
// pc = pc
pcTemp = CharPrev(pszPath,pc);
//
// check for trailing \ character and add one if needed
//
if ('\\' != *pcTemp)
{
*pc = '\\';
pc = CharNext(pc);
}
}
else
{
//
// The path value contains something we don't understand
//
ASSERT(0);
}
lstrcpy(pc,szIEAKSignupFilename);
if (0xFFFFFFFF != GetFileAttributes(pszPath))
{
bRC = TRUE;
}
IsIEAKSignUpNeededExit:
if (FALSE == bRC)
{
pszPath[0] = '\0';
}
return bRC;
}
/***************************************************************************
Function CheckConnectionWizard
Synopsis This function checks if ICW is present and if it has been run
before. If it is present but has not been run it does one of
the following based on the value of dwRunFlags: returns, runs
the full ICW, or runs the manual path.
Arguments dwRunFlags is a combination of the following bit flags.
Value Meaning
ICW_CHECKSTATUS Check if ICW is present and if it
has been run.
ICW_LAUNCHFULL If ICW is present and the full path
is available, run the full path, if
possible.
ICW_LAUNCHMANUAL If ICW is present, run the manual path.
ICW_USE_SHELLNEXT If the full ICW path will be run, pass the
value set by SetShellNext to icwconn1 using
the /shellnext command line flag.
ICW_FULL_SMARTSTART If ICW is present and the full path
is available, and ICW_LAUNCHFULL is
specified, then add /smartstart parameter
to command line.
lpdwReturnFlags contains the results of the call. It is a
combination of the following bit flags.
Value Meaning
ICW_FULLPRESENT ICW full path is present on the system.
ICW_MANUALPRESENT ICW manual path is present. This will
always be set if ICW_FULLPRESENT is set.
ICW_ALREADYRUN ICW has already been run to completion
before.
ICW_LAUNCHEDFULL The full path of ICW was started.
ICW_LAUNCHEDMANUAL The manual path of ICW was started.
Note: The calling application should exit if ICW_LAUNCHEDFULL or
ICW_LAUNCHEDMANUAL are set. ICW may cause the system to
reboot if required system software needs to be installed.
Return ERROR_SUCCESS indicates a successful call.
Any other value indicates failure.
****************************************************************************/
#define LAUNCHFULL_PARAMETER_SIZE (MAX_PATH + 2 + lstrlen(szICWShellNextFlag) + lstrlen(szICWSmartStartFlag))
extern "C" DWORD WINAPI CheckConnectionWizard(DWORD dwRunFlags, LPDWORD lpdwReturnFlags)
{
DWORD dwRetFlags = 0;
DWORD dwResult = ERROR_SUCCESS;
TCHAR *szParameter = NULL;
HINSTANCE hinst = NULL;
//
// ChrisK IE 39452 6/18/97
// IEAK support of ISP mode
//
BOOL fIEAKNeeded = FALSE;
TCHAR szIEAKPage[MAX_PATH + 1] = TEXT("\0invalid");
fIEAKNeeded = IsIEAKSignUpNeeded(szIEAKPage,MAX_PATH);
// Find out if full ICW is installed. Since ICW is bound to the base
// install of IE, we can just check if IE 3.0 is installed or not.
// This may change in the future.
if (IEInstalled())
dwRetFlags |= ICW_FULLPRESENT;
// Find out if manual ICW is installed. Since this if part of INETCFG.DLL
// and it also contains the manual ICW it is always present.
dwRetFlags |= ICW_MANUALPRESENT;
// If nothing's installed, exit now
#if 0 // Always at least manual path
if (!((dwRetFlags & ICW_FULLPRESENT) || (dwRetFlags & ICW_MANUALPRESENT)))
goto CheckConnectionWizardExit;
#endif
// Find out if ICW has been run
{
RegEntry re(szRegPathICWSettings,HKEY_CURRENT_USER);
dwResult = re.GetError();
if (ERROR_SUCCESS != dwResult)
goto CheckConnectionWizardExit;
if (re.GetNumber(szRegValICWCompleted, 0))
{
dwRetFlags |= ICW_ALREADYRUN;
goto CheckConnectionWizardExit;
}
}
if ((dwRetFlags & ICW_FULLPRESENT) && (dwRunFlags & ICW_LAUNCHFULL))
{
#if !defined(WIN16)
if( dwRunFlags & ICW_USE_SHELLNEXT )
{
RegEntry re(szRegPathICWSettings,HKEY_CURRENT_USER);
dwResult = re.GetError();
if (ERROR_SUCCESS == dwResult)
{
TCHAR szShellNextCmd[MAX_PATH + 1];
ZeroMemory( szShellNextCmd, sizeof(szShellNextCmd) );
if( re.GetString(szRegValShellNext, szShellNextCmd, sizeof(szShellNextCmd)) )
{
DEBUGMSG("CheckConnectionWizard read ShellNext = %s", szShellNextCmd);
szParameter = (TCHAR *)GlobalAlloc(GPTR, sizeof(TCHAR)*LAUNCHFULL_PARAMETER_SIZE);
if( szParameter )
{
ZeroMemory( szParameter, sizeof(szParameter) );
lstrcpy( szParameter, szICWShellNextFlag );
lstrcat( szParameter, szShellNextCmd );
//
// clean up after ourselves
//
// 7/9/97 jmazner Olympus #9170
// Nope, leave the reg key there for the manual path to find.
// conn1 and man path should clean this up when they finish.
//re.DeleteValue(szRegValShellNext);
//
}
}
}
}
//
// ChrisK 5/25/97 Add the /smartstart parameter if appropriate
//
if (!fIEAKNeeded && dwRunFlags & ICW_FULL_SMARTSTART)
{
//
// 6/6/97 jmazner Olympus #5927
//
//if(IsSmartStart())
if( SMART_QUITICW == IsSmartStart() )
{
//
// ChrisK Olympus 5902 6/6/97
// Set completed flag is SmartStart is TRUE
//
RegEntry reg(szRegPathICWSettings,HKEY_CURRENT_USER);
if (ERROR_SUCCESS == (dwResult = reg.GetError()))
{
reg.SetValue(szRegValICWCompleted, (DWORD)1);
}
dwRetFlags |= ICW_ALREADYRUN;
goto CheckConnectionWizardExit;
}
}
#endif
if (!fIEAKNeeded)
{
// Launch the full ICW (ICWCONN1.EXE)
hinst = ShellExecute (NULL, NULL, szFullICWFileName, szParameter, NULL, SW_NORMAL);
}
else
{
ASSERT(szIEAKPage[0]);
//
// Launch IEAK signup
//
hinst = ShellExecute (NULL, NULL, szISignupICWFileName, szIEAKPage, NULL, SW_NORMAL);
}
if (32 >= (DWORD_PTR)hinst)
{
if (NULL == hinst)
dwResult = ERROR_OUTOFMEMORY;
else
dwResult = (DWORD)((DWORD_PTR)hinst);
goto CheckConnectionWizardExit;
}
dwRetFlags |= ICW_LAUNCHEDFULL;
}
else if ((dwRetFlags & ICW_MANUALPRESENT) &&
((dwRunFlags & ICW_LAUNCHFULL) || (dwRunFlags & ICW_LAUNCHMANUAL)))
{
// Launch the manual ICW (INETWIZ.EXE)
HINSTANCE hinst = ShellExecute (NULL, NULL, szManualICWFileName, NULL, NULL, SW_NORMAL);
if (32 >= (DWORD)((DWORD_PTR)hinst))
{
if (NULL == hinst)
dwResult = ERROR_OUTOFMEMORY;
else
dwResult = (DWORD)((DWORD_PTR)hinst);
goto CheckConnectionWizardExit;
}
dwRetFlags |= ICW_LAUNCHEDMANUAL;
}
CheckConnectionWizardExit:
if( szParameter )
{
GlobalFree( szParameter );
}
*lpdwReturnFlags = dwRetFlags;
return dwResult;
}
/******
*
* InetCreateMailNewsAccount and InetCreateDirectoryService, below, have
* been obsoleted by the move to the wizard/apprentice model. The Account
* Manager now owns the UI for mail/news/ldap creation, thus there is no
* longer a need for these entry points.
*
* 4/23/97 jmazner Olympus #3136
*
******/
/***************************************************************************
Function InetCreateMailNewsAccount
Synopsis The InetCreateMailNewsAccount function will create a new Internet
mail or news account. The user is prompted through a wizard
interface for the minimum required information to setup a new
Internet mail or news account.
Arguments hwndparent is the window handle of the parent for the wizard
dialogs. If it is NULL the dialogs will be parentless.
dwConfigType is of the following two enumerated types from ACCTTYPE.
Value Meaning
ICW_ACCTMAIL (0) Create a new Internet mail account.
ICW_ACCTNEWS (1) Create a new Internet news account.
lpMailNewsInfo is a pointer to a IMNACCTINFO struct. The values
passed in will be used as defaults and the user's entries will
be returned in this structure. If this is NULL then ICW will
use defaults as indicated in parentheses below.
Return ERROR_SUCCESS indicates a successful call.
ERROR_CANCELLED indicates the user canceled the wizard.
Any other value indicates failure.
****************************************************************************/
/***
extern "C" DWORD WINAPI InetCreateMailNewsAccount(
HWND hwndParent, //parent of wizard dialogs
ICW_ACCTTYPE AccountType, //account type
IMNACCTINFO *lpMailNewsInfo, // mail or news account information
DWORD dwInFlags // setup flags
)
{
DWORD dwResult = ERROR_SUCCESS;
DWORD dwFlags = 0;
// Initialize the wizard
gpWizardState = new WIZARDSTATE;
gpUserInfo = new USERINFO;
gdwRasEntrySize = sizeof(RASENTRY);
gpRasEntry = (LPRASENTRY) GlobalAlloc(GPTR,gdwRasEntrySize);
if (!gpWizardState || !gpUserInfo || !gpRasEntry)
{
// display an out of memory error
MsgBox(NULL,IDS_ERROutOfMemory,MB_ICONEXCLAMATION,MB_OK);
dwResult = ERROR_OUTOFMEMORY;
goto InetCreateMailNewsAccountExit;
}
// Assign the global defaults pointer so we will use it later
gpMailNewsInfo = lpMailNewsInfo;
gfUseMailNewsDefaults = (dwInFlags & ICW_USEDEFAULTS);
// Set the start page
switch(AccountType)
{
case ICW_ACCTMAIL:
dwFlags |= RSW_MAILACCT;
break;
case ICW_ACCTNEWS:
dwFlags |= RSW_NEWSACCT;
break;
default:
dwResult = ERROR_INVALID_PARAMETER;
goto InetCreateMailNewsAccountExit;
break;
}
gfUserFinished = FALSE;
gfUserCancelled = FALSE;
RunSignupWizard(dwFlags, hwndParent);
if (gfUserFinished)
dwResult = ERROR_SUCCESS;
else if (gfUserCancelled)
dwResult = ERROR_CANCELLED;
else
dwResult = ERROR_GEN_FAILURE;
InetCreateMailNewsAccountExit:
// free global structures
if (gpWizardState)
delete gpWizardState;
if (gpUserInfo)
delete gpUserInfo;
if (gpEnumModem)
delete gpEnumModem;
if (gpRasEntry)
GlobalFree(gpRasEntry);
return dwResult;
}
******/
/***************************************************************************
Function InetCreateDirectoryService
Synopsis The InetCreateDirectoryService function will create a new Internet
directory service (LDAP account). The user is prompted through a wizard
interface for the minimum required information to setup the service
Arguments hwndparent is the window handle of the parent for the wizard
dialogs. If it is NULL the dialogs will be parentless.
AccountType should be ICW_ACCTDIRSERV
lpDirServiceInfo is a pointer to a DIRSERVINFO struct. The values
passed in will be used as defaults and the user's entries will
be returned in this structure. If this is NULL then ICW will
use defaults as indicated in parentheses below.
Return ERROR_SUCCESS indicates a successful call.
ERROR_CANCELLED indicates the user canceled the wizard.
Any other value indicates failure.
****************************************************************************/
/***********
extern "C" DWORD WINAPI InetCreateDirectoryService(
HWND hwndParent, // parent of wizard dialogs
ICW_ACCTTYPE AccountType, // account type
DIRSERVINFO *lpDirServiceInfo, // LDAP account information
DWORD dwInFlags // setup flags
)
{
DWORD dwRet = ERROR_SUCCESS;
DWORD dwFlags = 0;
// Initialize the wizard
gpWizardState = new WIZARDSTATE;
gpUserInfo = new USERINFO;
gdwRasEntrySize = sizeof(RASENTRY);
gpRasEntry = (LPRASENTRY) GlobalAlloc(GPTR,gdwRasEntrySize);
if (!gpWizardState || !gpUserInfo || !gpRasEntry)
{
// display an out of memory error
MsgBox(NULL,IDS_ERROutOfMemory,MB_ICONEXCLAMATION,MB_OK);
dwRet = ERROR_OUTOFMEMORY;
goto InetCreateDirectoryServiceExit;
}
// Assign the global defaults pointer so we will use it later
gpDirServiceInfo = lpDirServiceInfo;
gfUseDirServiceDefaults = (dwInFlags & ICW_USEDEFAULTS);
// Set the start page
switch(AccountType)
{
case ICW_ACCTDIRSERV:
dwFlags |= RSW_DIRSERVACCT;
break;
default:
dwRet = ERROR_INVALID_PARAMETER;
goto InetCreateDirectoryServiceExit;
break;
}
gfUserFinished = FALSE;
gfUserCancelled = FALSE;
RunSignupWizard(dwFlags, hwndParent);
if (gfUserFinished)
dwRet = ERROR_SUCCESS;
else if (gfUserCancelled)
dwRet = ERROR_CANCELLED;
else
dwRet = ERROR_GEN_FAILURE;
InetCreateDirectoryServiceExit:
// free global structures
if (gpWizardState)
delete gpWizardState;
if (gpUserInfo)
delete gpUserInfo;
if (gpEnumModem)
delete gpEnumModem;
if (gpRasEntry)
GlobalFree(gpRasEntry);
return dwRet;
}
******/
#if !defined(WIN16)
// 4/1/97 ChrisK Olympus 209
//+----------------------------------------------------------------------------
// Function: WaitCfgDlgProc
//
// Synopsis: Handle busy dialog messages
//
// Arguments: standard DialogProc
//
// Returns: standard DialogProc
//
// History: 4/2/97 ChrisK Created
//-----------------------------------------------------------------------------
INT_PTR CALLBACK WaitCfgDlgProc(
HWND hDlg,
UINT uMsg,
WPARAM wParam,
LPARAM lParam
)
{
HWND hwndAni;
switch (uMsg)
{
case WM_DESTROY:
hwndAni = GetDlgItem(hDlg,IDC_ANIMATE);
if (hwndAni)
{
Animate_Stop(hwndAni);
Animate_Close(hwndAni);
hwndAni = NULL;
}
break;
case WM_INITDIALOG:
// Loop animation forever.
hwndAni = GetDlgItem(hDlg,IDC_ANIMATE);
if (hwndAni)
{
Animate_Open(hwndAni,MAKEINTRESOURCE(IDA_WAITINGCONFIG));
Animate_Play(hwndAni, 0, -1, -1);
hwndAni = NULL;
}
break;
}
return FALSE;
}
//+----------------------------------------------------------------------------
// Function: WaitCfgInit
//
// Synopsis: Create, center, and display busy dialog
//
// Arguments: hwndParent - handle of parent window
// dwIDS - ID of string resource to display
//
// Return: handle to busy window
//
// History: 4/2/97 ChrisK Created
//-----------------------------------------------------------------------------
HWND WaitCfgInit(HWND hwndParent, DWORD dwIDS)
{
HWND hwnd;
RECT MyRect;
RECT DTRect;
TCHAR szMessage[255];
// Create dialog
hwnd = CreateDialog (ghInstance, MAKEINTRESOURCE(IDD_CONFIGWAIT), hwndParent, WaitCfgDlgProc);
if (NULL != hwnd)
{
// Center dialog on desktop
GetWindowRect(hwnd, &MyRect);
GetWindowRect(GetDesktopWindow(), &DTRect);
MoveWindow(hwnd, (DTRect.right - (MyRect.right - MyRect.left)) / 2, (DTRect.bottom - (MyRect.bottom - MyRect.top)) /2,
(MyRect.right - MyRect.left), (MyRect.bottom - MyRect.top), FALSE);
// Load string for message
szMessage[0] = '\0';
LoadSz(dwIDS,szMessage,sizeof(szMessage)-1);
SetDlgItemText(hwnd,IDC_LBLWAITCFG,szMessage);
// Display dialog and paint text
ShowWindow(hwnd,SW_SHOW);
UpdateWindow(hwnd);
}
return hwnd;
}
//+----------------------------------------------------------------------------
// Function: SetShellNext
//
// Synopsis: Sets the ShellNext registry key with the passed in value. This
// key is passed to icwconn1 via the /shellnext command line option
// if the ICW_USE_SHELLNEXT option is specified.
//
// Arguments: szShellNext -- pointer to a string containing the /shellnext cmd.
// **should have length <= MAX_PATH**
//
// Return: a win32 result code. ERROR_SUCCESS indicates success.
//
// History: 5/21/97 jmazner Created for Olympus bug #4157
//-----------------------------------------------------------------------------
#ifdef UNICODE
extern "C" DWORD WINAPI SetShellNextA(CHAR *szShellNext)
{
TCHAR* szShellNextW = new TCHAR[INTERNET_MAX_URL_LENGTH+1];
DWORD dwRet = ERROR_INVALID_PARAMETER;
if (szShellNextW)
{
mbstowcs(szShellNextW, szShellNext, lstrlenA(szShellNext)+1);
dwRet = SetShellNextW(szShellNextW);
delete [] szShellNextW;
}
return dwRet;
}
extern "C" DWORD WINAPI SetShellNextW(WCHAR *szShellNext)
#else
extern "C" DWORD WINAPI SetShellNextA(CHAR *szShellNext)
#endif
{
DWORD dwResult = ERROR_SUCCESS;
if( !szShellNext || !szShellNext[0] )
{
DEBUGMSG("SetShellNext got an invalid parameter\n");
return ERROR_INVALID_PARAMETER;
}
RegEntry re(szRegPathICWSettings,HKEY_CURRENT_USER);
dwResult = re.GetError();
if (ERROR_SUCCESS == dwResult)
{
if( ERROR_SUCCESS == re.SetValue(szRegValShellNext, szShellNext) )
{
DEBUGMSG("SetShellNext set ShellNext = %s", szShellNext);
}
else
{
dwResult = re.GetError();
}
}
return dwResult;
}
#ifdef OLD_SMART_START
#define IE4_PROXYSERVER_SETTING_KEY "ProxyServer"
#define IE4_PROXYENABLE_SETTING_KEY "ProxyEnable"
#define IE4_SETTINGS_STARTPAGE "Start Page"
#define IE4_SETTINGS_KEY "Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings"
#define IE4_SETTINGS_MAIN "Software\\Microsoft\\Internet Explorer\\Main"
#define INETCFG_INETGETAUTODIAL "InetGetAutodial"
#define INETCFG_INETNEEDSYSTEMCOMPONENTS "InetNeedSystemComponents"
typedef HRESULT (WINAPI* PFNINETNEEDSYSTEMCOMPONENTS)(DWORD,LPBOOL);
typedef HRESULT (WINAPI* PFNINETGETAUTODIAL)(LPBOOL,LPTSTR,DWORD);
typedef DWORD (WINAPI* PFNRASGETAUTODIALADDRESS)(LPTSTR,LPDWORD,LPRASAUTODIALENTRY,LPDWORD,LPDWORD);
#define MIN_HTTP_ADDRESS (sizeof(SMART_HTTP) + 1)
#define SMART_HTTP TEXT("http://")
//+----------------------------------------------------------------------------
//
// Function: SmartStartNetcard
//
// Synopsis: Check machine to see if it is setup to connect via a netcard
// and proxy
//
// Arguments: none
//
// Returns: TRUE - run ICW; FALSE - quit now
//
// History: 5/10/97 ChrisK Created
//
//-----------------------------------------------------------------------------
BOOL SmartStartNetcard()
{
BOOL bResult = FALSE;
HKEY hkey = NULL;
DWORD dwSize = 0;
DWORD dwData = 0;
BOOL bRC = SMART_RUNICW;
DEBUGMSG("INETCFG: SmartStartNetcard\n");
//
// Call Inetcfg to check for LAN card and TCP binding to that card
//
if (ERROR_SUCCESS != InetNeedSystemComponents(INETCFG_INSTALLLAN,
&bResult) || bResult)
{
DEBUGMSG("INETCFG: SmartStart not Netcard or not bound.\n");
goto SmartStartNetcardExit;
}
//
// Check to see if there are IE4 proxy settings
//
hkey = NULL;
if (ERROR_SUCCESS != RegOpenKey(HKEY_CURRENT_USER,
IE4_SETTINGS_KEY,
&hkey)
|| NULL == hkey)
{
DEBUGMSG("INETCFG: SmartSmart IE4 Proxy key is not available.\n");
goto SmartStartNetcardExit;
}
dwSize = sizeof(dwData);
if (ERROR_SUCCESS != RegQueryValueEx(hkey,
IE4_PROXYENABLE_SETTING_KEY,
NULL, // lpReserved
NULL, // lpType
(LPBYTE)&dwData, // lpData
&dwSize)
|| 0 == dwData)
{
DEBUGMSG("INETCFG: SmartStart IE4 Proxy not enabled.\n");
goto SmartStartNetcardExit;
}
if (ERROR_SUCCESS != RegQueryValueEx(hkey,
IE4_PROXYSERVER_SETTING_KEY,
NULL, // lpReserved
NULL, // lpType
NULL, // lpData
&dwSize)
|| 1 >= dwSize) // note: a single null character is length 1
{
DEBUGMSG("INETCFG: SmartStart IE 4 Proxy server not available.\n");
goto SmartStartNetcardExit;
}
//
// The user appears to have a valid configuration. Do not
// run the ICW.
//
bRC = SMART_QUITICW;
SmartStartNetcardExit:
if (NULL != hkey)
{
RegCloseKey(hkey);
hkey = NULL;
}
return bRC;
}
//+----------------------------------------------------------------------------
//
// Function: IsSmartPPPConnectoid
//
// Synopsis: Given a connectoid name determine if the framing protocol is PPP
//
// Arguments: lpszEntry - name of connectoid
//
// Returns: TRUE - the framing protocol is PPP; FALSE - it is something else
//
// History: 5/10/97 ChrisK Created
//
//-----------------------------------------------------------------------------
BOOL IsSmartPPPConnectoid(LPTSTR lpszEntry)
{
LPRASENTRY lpRasEntry = NULL;
DWORD dwRasEntrySize = 0;
LPRASDEVINFO lpRasDevInfo = NULL;
DWORD dwRasDevInfoSize = 0;
DWORD dwSize;
BOOL bRC = FALSE;
DEBUGMSG("INETCFG: IsSmartPPPConnectoid\n");
//
// Check for PPP connectoid
//
//
// ChrisK Olympus 6055 6/7/97
// Make sure RNA dll functions are loaded, otherwise
// GetEntry will assert.
//
if (ERROR_SUCCESS != EnsureRNALoaded() ||
ERROR_SUCCESS != GetEntry(&lpRasEntry,
&dwRasEntrySize,
lpszEntry) ||
RASFP_Ppp != lpRasEntry->dwFramingProtocol)
{
goto IsSmartPPPConnectoidExit;
}
else
{
//
// The user appears to have a working modem connectoid
// so skip the ICW
//
bRC = TRUE;
goto IsSmartPPPConnectoidExit;
}
IsSmartPPPConnectoidExit:
//
// Release memory
//
if (NULL != lpRasEntry)
{
GlobalFree(lpRasEntry);
lpRasEntry = NULL;
}
if (NULL != lpRasDevInfo)
{
GlobalFree(lpRasDevInfo);
lpRasDevInfo = NULL;
}
return bRC;
}
//+----------------------------------------------------------------------------
//
// Function: SmartStartPPPConnectoidNT
//
// Synopsis: Check that the connectoid for the address of the start page is
// a PPP connectoid
//
// Arguments:
//
// Returns: TRUE - run ICW; FALSE - quit NOW
//
// History: 5/10/97 ChrisK Created
//
//-----------------------------------------------------------------------------
BOOL SmartStartPPPConnectoidNT()
{
BOOL bRC = SMART_RUNICW;
HKEY hkey;
TCHAR szStartPage[1024];
TCHAR *pchFrom, *pchTo;
HINSTANCE hRASAPI32;
LPRASAUTODIALENTRY lpRasAutoDialEntry = NULL;
DWORD dwSize=0;
DWORD dwNum=0;
FARPROC fp = NULL;
DEBUGMSG("INETCFG: SmartStartPPPConnectoidNT\n");
//
// Read start page from registry
//
if (ERROR_SUCCESS != RegOpenKey(HKEY_CURRENT_USER,
IE4_SETTINGS_MAIN,
&hkey) && hkey)
{
goto SmartStartPPPConnectoidNTExit;
}
if (ERROR_SUCCESS != RegQueryValueEx(hkey,
IE4_SETTINGS_STARTPAGE,
NULL, //lpReserved
NULL, //lpType
(LPBYTE)szStartPage,//lpData
&dwSize) //lpcbData
&& dwSize >= MIN_HTTP_ADDRESS)
{
goto SmartStartPPPConnectoidNTExit;
}
//
// Parse server name out of start page URL and save it in szStartPage
//
if (2 != CompareString(LOCALE_SYSTEM_DEFAULT,
NORM_IGNORECASE,
szStartPage,
lstrlen(SMART_HTTP),
SMART_HTTP,
lstrlen(SMART_HTTP)))
{
goto SmartStartPPPConnectoidNTExit;
}
pchFrom = &szStartPage[sizeof(SMART_HTTP)];
pchTo = &szStartPage[0];
while (*pchFrom && '/' != *pchFrom)
{
*pchTo++ = *pchFrom++;
}
*pchTo = '\0';
//
// Look up address in RasAutodial database
//
if (NULL == (hRASAPI32 = LoadLibrary("rasapi32.dll")))
{
DEBUGMSG("INETCFG: rasapi32.dll didn't load.\n");
goto SmartStartPPPConnectoidNTExit;
}
#ifdef UNICODE
if (NULL == (fp = GetProcAddress(hRASAPI32,"RasGetAutodialAddressW")))
#else
if (NULL == (fp = GetProcAddress(hRASAPI32,"RasGetAutodialAddressA")))
#endif
{
DEBUGMSG("INETCFG: RasGetAutodialAddressA didn't load.\n");
goto SmartStartPPPConnectoidNTExit;
}
if (ERROR_SUCCESS != ((PFNRASGETAUTODIALADDRESS)fp)(szStartPage,
NULL, // lpdwReserved
NULL, // lpAutoDialEntries
&dwSize, // lpdwcbAutoDialEntries
&dwNum) // lpdwcAutoDialEntries
|| 0 == dwNum)
{
goto SmartStartPPPConnectoidNTExit;
}
if (NULL == (lpRasAutoDialEntry = (LPRASAUTODIALENTRY)GlobalAlloc(GPTR,dwSize)))
{
goto SmartStartPPPConnectoidNTExit;
}
lpRasAutoDialEntry->dwSize = dwSize;
if (ERROR_SUCCESS != ((PFNRASGETAUTODIALADDRESS)fp)(szStartPage,
NULL, // lpdwReserved
lpRasAutoDialEntry, // lpAutoDialEntries
&dwSize, // lpdwcbAutoDialEntries
&dwNum)) // lpdwcAutoDialEntries
{
goto SmartStartPPPConnectoidNTExit;
}
//
// Determine if the connectoid is PPP
//
if (IsSmartPPPConnectoid(lpRasAutoDialEntry->szEntry))
{
bRC = SMART_QUITICW;
}
SmartStartPPPConnectoidNTExit:
if (hkey)
{
RegCloseKey(hkey);
hkey = NULL;
}
return bRC;
}
//+----------------------------------------------------------------------------
//
// Function: SmartStartPPPConnectoid95
//
// Synopsis: Check that the connectoid set in the autodial setting is a PPP
// connectoid
//
// Arguments:
//
// Returns: TRUE - run ICW; FALSE - quit NOW
//
// History: 5/10/97 ChrisK Created
//
//-----------------------------------------------------------------------------
BOOL SmartStartPPPConnectoid95()
{
BOOL bAutodialEnabled = FALSE;
CHAR szAutodialName[RAS_MaxEntryName + 1];
DWORD dwSize;
BOOL bRC = SMART_RUNICW;
DEBUGMSG("INETCFG: SmartStartPPPConnectoid95\n");
//
// Get Autodial connectoid
//
dwSize = RAS_MaxEntryName;
if (ERROR_SUCCESS != InetGetAutodial(&bAutodialEnabled,
szAutodialName,
dwSize) ||
!bAutodialEnabled ||
0 == lstrlen(szAutodialName))
{
goto SmartStartPPPConnectoid95Exit;
}
//
// Determine if the connectoid is PPP
//
if (IsSmartPPPConnectoid(szAutodialName))
{
bRC = SMART_QUITICW;
}
SmartStartPPPConnectoid95Exit:
return bRC;
}
//+----------------------------------------------------------------------------
//
// Function: AtLeastOneTAPILocation
//
// Synopsis: Check machine to verify that there is at least 1 tapi dialing
// location
//
// Arguments: none
//
// Returns: TRUE
//
// History: 3 18 98 donaldm
//
//-----------------------------------------------------------------------------
BOOL AtLeastOneTAPILocation()
{
HKEY hkey;
BOOL bRet = FALSE;
if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_LOCAL_MACHINE,
REGSTR_PATH_TELEPHONYLOCATIONS,
0,
KEY_ALL_ACCESS,
&hkey))
{
DWORD dwSubKeys = 0;
if (ERROR_SUCCESS == RegQueryInfoKey(hkey,
NULL,
NULL,
NULL,
&dwSubKeys,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL))
{
// If there are any subkeys under locaitons, then there is at least 1
if (dwSubKeys)
bRet = TRUE;
}
RegCloseKey(hkey);
}
return(bRet);
}
//+----------------------------------------------------------------------------
//
// Function: SmartStartModem
//
// Synopsis: Check machine to verify that there is a modem and an autodial
// connectoid
//
// Arguments: none
//
// Returns: TRUE - run ICW; FALSE - quit now
//
// History: 5/10/97 ChrisK Created
//
//-----------------------------------------------------------------------------
BOOL SmartStartModem()
{
BOOL bResult = FALSE;
DWORD dwSize = 0;
BOOL bRC = SMART_RUNICW;
FARPROC fp;
DEBUGMSG("INETCFG: SmartStartModem\n");
//
// Call Inetcfg to see if a modem is properly installed with TCP
//
if (ERROR_SUCCESS == InetNeedSystemComponents(INETCFG_INSTALLDIALUP,
&bResult)
&& !bResult)
{
//
// Check to see if Dial-Up networking/RAS/RNA is install
//
if (ERROR_SUCCESS == InetNeedSystemComponents(INETCFG_INSTALLRNA,
&bResult)
&& !bResult)
{
// DONALDM: GETCON bug 94. If there are no tapi locations, then
// we can fail smart start, because there is no way the use
// is connected. We want to bail here because InetNeedModem will call
// RasEnumDevices, which will pop up the TAPI locations dialog
if (AtLeastOneTAPILocation())
{
//
// ChrisK Olympus 6324 6/11/97
// Need to explicitly check for modem
//
if (ERROR_SUCCESS == InetNeedModem(&bResult) &&
!bResult)
{
if (IsNT())
{
//
// Check that Ras services are running
//
//!JACOBBUGBUG!
if (ERROR_SUCCESS != InetStartServices())
{
goto SmartStartNetcardExit;
}
bRC = SmartStartPPPConnectoidNT();
}
else
{
bRC = SmartStartPPPConnectoid95();
}
}
}
}
}
SmartStartNetcardExit:
return bRC;
}
//+----------------------------------------------------------------------------
//
// Function: IsSmartStart
//
// Synopsis: This function will determine if the ICW should be run. The
// decision is made based on the current state of the user's machine.
//
// Arguments: none
//
// Returns: TRUE - run ICW; FALSE - quit now
//
// History: 5/8/97 ChrisK Created
//
//-----------------------------------------------------------------------------
extern "C" DWORD WINAPI IsSmartStart()
{
BOOL bRC = SMART_RUNICW;
BOOL bResult;
DEBUGMSG("INETCFG: IsSmartStart\n");
if (IsNT())
{
DEBUGMSG("INETCFG: SmartStart not enabled on NT.\n");
goto IsSmartStartExit;
}
//
// #1. Check to see if TCP is installed
//
bResult = FALSE;
if (ERROR_SUCCESS != InetNeedSystemComponents(INETCFG_INSTALLTCPONLY,
&bResult) || bResult)
{
DEBUGMSG("INETCFG: SmartStart TCP is missing\n");
goto IsSmartStartExit;
}
//
// #2. Check to see if there is a netcard installed
//
if (SMART_QUITICW == (bRC = SmartStartNetcard()))
{
DEBUGMSG("INETCFG: SmartStart LAN setup found.\n");
goto IsSmartStartExit;
}
//
// #3. Check to see if there is a modem installed
//
bRC = SmartStartModem();
if (SMART_QUITICW == bRC)
{
DEBUGMSG("INETCFG: SmartStart Modem setup found.\n");
}
else
{
DEBUGMSG("INETCFG: SmartStart no valid setup found.\n");
}
IsSmartStartExit:
return bRC;
}
#endif // OLD_SMART_START
//+----------------------------------------------------------------------------
//
// Function: IsSmartStartEx
//
// Synopsis: This function will determine if the ICW should be run. The
// decision is made based on the current state of the user's machine.
//
// Arguments: none
//
// Returns: TRUE - run ICW; FALSE - quit now
//
// History: 5/8/97 ChrisK Created
//
//-----------------------------------------------------------------------------
typedef DWORD (WINAPI *PFNInternetGetConnectedState) (LPDWORD, DWORD);
typedef DWORD (WINAPI *PFNInternetGetConnectedStateEx) (LPDWORD, LPTSTR, DWORD, DWORD);
extern "C" DWORD WINAPI IsSmartStartEx(LPTSTR lpszConnectionName, DWORD dwBufLen)
{
DEBUGMSG("INETCFG: IsSmartStartEx\n");
BOOL bRC = SMART_RUNICW;
DWORD dwConnectedFlags = 0;
HINSTANCE hWinInet = LoadLibrary(TEXT("wininet.dll"));
if (hWinInet)
{
PFNInternetGetConnectedState pfnInternetGetConnectedState = NULL;
PFNInternetGetConnectedStateEx pfnInternetGetConnectedStateEx = NULL;
#ifdef UNICODE
pfnInternetGetConnectedStateEx = (PFNInternetGetConnectedStateEx)GetProcAddress(hWinInet,"InternetGetConnectedStateExW");
#else
pfnInternetGetConnectedStateEx = (PFNInternetGetConnectedStateEx)GetProcAddress(hWinInet,"InternetGetConnectedStateEx");
#endif
pfnInternetGetConnectedState = (PFNInternetGetConnectedState)GetProcAddress(hWinInet,"InternetGetConnectedState");
if (pfnInternetGetConnectedStateEx)
{
pfnInternetGetConnectedStateEx(&dwConnectedFlags,
lpszConnectionName,
dwBufLen,
0);
}
else if(pfnInternetGetConnectedState)
{
pfnInternetGetConnectedState(&dwConnectedFlags, 0);
}
FreeLibrary(hWinInet);
}
// Existing connectoin is determined by existing modem or proxy, no need to run ICW
// Check to see if there is a MODEM or PROXY connection
if (dwConnectedFlags &
(INTERNET_CONNECTION_CONFIGURED | INTERNET_CONNECTION_LAN |
INTERNET_CONNECTION_PROXY | INTERNET_CONNECTION_MODEM
)
)
{
bRC = SMART_QUITICW;
}
return bRC;
}
//+----------------------------------------------------------------------------
//
// Function: IsSmartStart
//
// Synopsis: This function will determine if the ICW should be run. The
// decision is made based on the current state of the user's machine.
//
// Arguments: none
//
// Returns: TRUE - run ICW; FALSE - quit now
//
// History: 5/8/97 ChrisK Created
//
//-----------------------------------------------------------------------------
extern "C" DWORD WINAPI IsSmartStart()
{
return IsSmartStartEx(NULL, 0);
}
//*******************************************************************
//
// FUNCTION: SetAutoProxyConnectoid
//
// PURPOSE: This function will set the enable/disable auto
// proxy settings in creating connectoid.
//
// PARAMETERS: fEnable - If set to TRUE, proxy will be enabled.
// If set to FALSE, proxy will be disabled.
//
//*******************************************************************
HRESULT WINAPI SetAutoProxyConnectoid( BOOL bEnable)
{
g_bUseAutoProxyforConnectoid = bEnable;
return ERROR_SUCCESS;
}
#endif //!WIN16
View Git Blame Copy Permalink