Microsoft/Windows2003-3790
Microsoft/Windows2003-3790
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
master
Windows2003-3790/inetcore/connectionwizard/isign32/isignup.cpp
Microsoft 50969b0ea2 First commit
2020-09-30 16:53:55 +02:00

7312 lines
210 KiB
C++
Raw Permalink Blame History

/*----------------------------------------------------------------------------
isignup.cpp
This is the "main" file for the internet signup "wizard".
Copyright (C) 1995-96 Microsoft Corporation
All right reserved
Authors:
MMaclin Mark Maclin
History:
Sat 10-Mar-1996 23:50:40 -by- Mark MacLin [mmaclin]
8/2/96 ChrisK Ported to Win32
9/27/96 jmazner Modified to use OLE Automation to control IE
----------------------------------------------------------------------------*/
#include "isignup.h"
#include "icw.h"
#ifdef WIN32
#include "icwacct.h"
#include "isignole.h"
#include "enumodem.h"
#include "..\inc\semaphor.h"
#include <shlobj.h>
#include <math.h>
#include <stdlib.h>
#endif
#include "..\inc\icwdial.h"
#ifndef WIN32
#include <string.h>
#include <direct.h>
#include <time.h>
#include <io.h>
DWORD GetFullPathName(
LPCTSTR lpFileName,
DWORD nBufferLength,
LPTSTR lpBuffer,
LPTSTR FAR *lpFilePart);
BOOL SetCurrentDirectory(
LPCTSTR lpPathName);
BOOL ShutDownIEDial(HWND hWnd);
#endif
const TCHAR g_szICWCONN1[] = TEXT("ICWCONN1.EXE");
const TCHAR g_szRestoreDesktop[] = TEXT("/restoredesktop");
#ifdef WIN32
#define SETUPSTACK 1
#endif
// Signup Entry Flags
#define SEF_RUNONCE 0x0001
#define SEF_PROGRESS 0x0002
#define SEF_SPLASH 0x0004
// 3/14/97 jmazner TEMP
// temporary hack until we can work with IE for a better solution
#define SEF_NOSECURITYBACKUP 0x0008
// Signup eXit Flags
#define SXF_RESTOREAUTODIAL 0x0001
#define SXF_RUNEXECUTABLE 0x0002
#define SXF_WAITEXECUTABLE 0x0004
#define SXF_KEEPCONNECTION 0x0008
#define SXF_KEEPBROWSER 0x0010
#define SXF_RESTOREDEFCHECK 0x0020
// 8/21/96 jmazner Normandy 4592
#define SXF_RESTOREIEWINDOWPLACEMENT 0x0040
extern void Dprintf(LPCSTR pcsz, ...);
/*** moved to isignup.h
typedef enum
{
UNKNOWN_FILE,
INS_FILE,
ISP_FILE,
HTML_FILE
} INET_FILETYPE;
*/
#define WAIT_TIME 20 // time in seconds to wait after exec'ing browser
// before checking if it has gone away.
#define MAX_RETRIES 3 // number of times the dialer with attempt automatic redials
#pragma data_seg(".rdata")
static const TCHAR szBrowserClass1[] = TEXT("IExplorer_Frame");
static const TCHAR szBrowserClassIE4[] = TEXT("CabinetWClass");
static const TCHAR szBrowserClass2[] = TEXT("Internet Explorer_Frame");
static const TCHAR szBrowserClass3[] = TEXT("IEFrame");
static const TCHAR cszURLSection[] = TEXT("URL");
static const TCHAR cszSignupURL[] = TEXT("Signup");
static const TCHAR cszExtINS[] = TEXT(".ins");
static const TCHAR cszExtISP[] = TEXT(".isp");
static const TCHAR cszExtHTM[] = TEXT(".htm");
static const TCHAR cszExtHTML[] = TEXT(".html");
static const TCHAR cszEntrySection[] = TEXT("Entry");
static const TCHAR cszEntryName[] = TEXT("Entry_Name");
static const TCHAR cszCancel[] = TEXT("Cancel");
static const TCHAR cszHangup[] = TEXT("Hangup");
static const TCHAR cszRun[] = TEXT("Run");
static const TCHAR cszArgument[] = TEXT("Argument");
static const TCHAR cszConnect2[] = TEXT("icwconn2.exe");
static const TCHAR cszClientSetupSection[] = TEXT("ClientSetup");
static const TCHAR cszUserSection[] = TEXT("User");
static const TCHAR cszRequiresLogon[] = TEXT("Requires_Logon");
static const TCHAR cszCustomSection[] = TEXT("Custom");
static const TCHAR cszKeepConnection[] = TEXT("Keep_Connection");
static const TCHAR cszKeepBrowser[] = TEXT("Keep_Browser");
static const TCHAR cszBrandingSection[] = TEXT("Branding");
static const TCHAR cszBrandingFlags[] = TEXT("Flags");
static const TCHAR cszBrandingServerless[] = TEXT("Serverless");
static const TCHAR cszHTTPS[] = TEXT("https:");
// code relies on these two being the same length
static const TCHAR cszHTTP[] = TEXT("http:");
static const TCHAR cszFILE[] = TEXT("file:");
#if defined(WIN16)
// "-d" disables the security warnings
static const TCHAR cszKioskMode[] = TEXT("-d -k ");
#else
static const CHAR cszKioskMode[] = "-k ";
#endif
static const TCHAR cszOpen[] = TEXT("open");
static const TCHAR cszBrowser[] = TEXT("iexplore.exe");
static const TCHAR szNull[] = TEXT("");
static const TCHAR cszYes[] = TEXT("yes");
static const TCHAR cszNo[] = TEXT("no");
// UNDONE: finish porting warnings disable
static const TCHAR cszDEFAULT_BROWSER_KEY[] = TEXT("Software\\Microsoft\\Internet Explorer\\Main");
static const TCHAR cszDEFAULT_BROWSER_VALUE[] = TEXT("check_associations");
// 8/21/96 jmazner Normandy #4592
static const TCHAR cszIEWINDOW_PLACEMENT[] = TEXT("Window_Placement");
// Registry keys which will contain News and Mail settings
//#define MAIL_KEY "SOFTWARE\\Microsoft\\Internet Mail and News\\Mail"
//#define MAIL_POP3_KEY "SOFTWARE\\Microsoft\\Internet Mail and News\\Mail\\POP3\\"
//#define MAIL_SMTP_KEY "SOFTWARE\\Microsoft\\Internet Mail and News\\Mail\\SMTP\\"
//#define NEWS_KEY "SOFTWARE\\Microsoft\\Internet Mail and News\\News"
//#define MAIL_NEWS_INPROC_SERVER32 "CLSID\\{89292102-4755-11cf-9DC2-00AA006C2B84}\\InProcServer32"
#define ICWSETTINGSPATH TEXT("Software\\Microsoft\\Internet Connection Wizard")
#define ICWCOMPLETEDKEY TEXT("Completed")
#define ICWDESKTOPCHANGED TEXT("DesktopChanged")
//typedef HRESULT (WINAPI *PFNSETDEFAULTNEWSHANDLER)(void);
//
// TEMP TEMP TEMP TEMP TEMP
// 6/4/97 jmazner
// these typedefs live in icwacct.h, but we can't include icwacct.h in 16 bit builds
// just yet because the OLE stuff is all goofy. So, for now, copy these in here to
// make 16 bit build correctly.
#ifdef WIN16
typedef enum
{
CONNECT_LAN = 0,
CONNECT_MANUAL,
CONNECT_RAS
};
typedef struct tagCONNECTINFO
{
DWORD cbSize;
DWORD type;
TCHAR szConnectoid[MAX_PATH];
} CONNECTINFO;
#endif
typedef HRESULT (WINAPI *PFNCREATEACCOUNTSFROMFILEEX)(LPTSTR szFile, CONNECTINFO *pCI, DWORD dwFlags);
// These are the field names from an INS file that will
// determine the mail and news settings
//static const CHAR cszMailSection[] = "Internet_Mail";
//static const CHAR cszEmailName[] = "Email_Name";
//static const CHAR cszEmailAddress[] = "Email_Address";
//static const CHAR cszEntryName[] = "Entry_Name";
//static const CHAR cszPOPServer[] = "POP_Server";
//static const CHAR cszPOPServerPortNumber[] = "POP_Server_Port_Number";
//static const CHAR cszPOPLogonName[] = "POP_Logon_Name";
//static const CHAR cszPOPLogonPassword[] = "POP_Logon_Password";
//static const CHAR cszSMTPServer[] = "SMTP_Server";
//static const CHAR cszSMTPServerPortNumber[] = "SMTP_Server_Port_Number";
//static const CHAR cszNewsSection[] = "Internet_News";
//static const CHAR cszNNTPServer[] = "NNTP_Server";
//static const CHAR cszNNTPServerPortNumber[] = "NNTP_Server_Port_Number";
// 8/19/96 jmazner Normandy #4601
//static const CHAR cszNNTPLogonRequired[] = "Logon_Required";
//static const CHAR cszNNTPLogonName[] = "NNTP_Logon_Name";
//static const CHAR cszNNTPLogonPassword[] = "NNTP_Logon_Password";
//static const CHAR cszUseMSInternetMail[] = "Install_Mail";
//static const CHAR cszUseMSInternetNews[] = "Install_News";
// These are the value names where the INS settings will be saved
// into the registry
/****
static const TCHAR cszMailSenderName[] = TEXT("Sender Name");
static const TCHAR cszMailSenderEMail[] = TEXT("Sender EMail");
static const TCHAR cszMailRASPhonebookEntry[]= TEXT("RAS Phonebook Entry");
static const TCHAR cszMailConnectionType[] = TEXT("Connection Type");
static const TCHAR cszDefaultPOP3Server[] = TEXT("Default POP3 Server");
static const TCHAR cszDefaultSMTPServer[] = TEXT("Default SMTP Server");
static const TCHAR cszPOP3Account[] = TEXT("Account");
static const TCHAR cszPOP3Password[] = TEXT("Password");
static const TCHAR cszPOP3Port[] = TEXT("Port");
static const TCHAR cszSMTPPort[] = TEXT("Port");
static const TCHAR cszNNTPSenderName[] = TEXT("Sender Name");
static const TCHAR cszNNTPSenderEMail[] = TEXT("Sender EMail");
static const TCHAR cszNNTPDefaultServer[] = TEXT("DefaultServer"); // NOTE: NO space between "Default" and "Server".
static const TCHAR cszNNTPAccountName[] = TEXT("Account Name");
static const TCHAR cszNNTPPassword[] = TEXT("Password");
static const TCHAR cszNNTPPort[] = TEXT("Port");
static const TCHAR cszNNTPRasPhonebookEntry[]= TEXT("RAS Phonebook Entry");
static const TCHAR cszNNTPConnectionType[] = TEXT("Connection Type");
****/
static const TCHAR arBase64[] = {'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U',
'V','W','X','Y','Z','a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p',
'q','r','s','t','u','v','w','x','y','z','0','1','2','3','4','5','6','7','8','9','+','/','='};
#pragma data_seg()
#define BRAND_FAVORITES 1
#define BRAND_STARTSEARCH 2
#define BRAND_TITLE 4
#define BRAND_BITMAPS 8
#define BRAND_MAIL 16
#define BRAND_NEWS 32
#define BRAND_DEFAULT (BRAND_FAVORITES | BRAND_TITLE | BRAND_BITMAPS)
//********* Start of Memory Map File for Share Data ************
#define SCF_SIGNUPCOMPLETED 0x00000001
#define SCF_SYSTEMCONFIGURED 0x00000002
#define SCF_BROWSERLAUNCHED 0x00000004
#define SCF_AUTODIALSAVED 0x00000008
#define SCF_AUTODIALENABLED 0x00000010
#define SCF_PROXYENABLED 0x00000020
#define SCF_LOGONREQUIRED 0x00000040
#if !defined(WIN16)
#define SCF_SAFESET 0x00000080
#define SCF_NEEDBACKUPSECURITY 0x00000100
#define SCF_ISPPROCESSING 0x00000200
#define SCF_RASREADY 0x00000400
#define SCF_RECONNECTTHREADQUITED 0x00000800
#define SCF_HANGUPEXPECTED 0x00001000
#define SCF_ICWCOMPLETEDKEYRESETED 0x00002000
#endif
#define SCF_CANCELINSPROCESSED 0x00004000
#define SCF_HANGUPINSPROCESSED 0x00008000
#define SCF_SILENT 0x00010000
typedef struct tagISign32Share
{
DWORD dwControlFlags;
DWORD dwExitFlags;
DWORD dwBrandFlags;
TCHAR szAutodialConnection[RAS_MaxEntryName + 1];
TCHAR szSignupConnection[RAS_MaxEntryName + 1];
TCHAR szPassword[PWLEN + 1];
TCHAR szCheckAssociations[20];
#if !defined(WIN16)
TCHAR szFile[MAX_PATH + 1];
TCHAR szISPFile[MAX_PATH + 1];
HANDLE hReconnectEvent;
#endif
TCHAR szRunExecutable[_MAX_PATH + 1];
TCHAR szRunArgument[_MAX_PATH + 1];
BYTE pbIEWindowPlacement[_MAX_PATH];
DWORD dwIEWindowPlacementSize;
HWND hwndMain;
HWND hwndBrowser;
HWND hwndLaunch;
} ISIGN32SHARE, *PISIGN32SHARE;
static PISIGN32SHARE pDynShare = NULL;
inline BOOL TestControlFlags(DWORD filter)
{
return ((pDynShare->dwControlFlags & filter) != 0);
}
inline void SetControlFlags(DWORD filter)
{
pDynShare->dwControlFlags |= filter;
}
inline void ClearControlFlags(DWORD filter)
{
pDynShare->dwControlFlags &= (~filter);
}
inline BOOL TestExitFlags(DWORD filter)
{
return (pDynShare->dwExitFlags & (filter)) != 0;
}
inline void SetExitFlags(DWORD filter)
{
pDynShare->dwExitFlags |= (filter);
}
inline void ClearExitFlags(DWORD filter)
{
pDynShare->dwExitFlags &= (~filter);
}
BOOL LibShareEntry(BOOL fInit)
{
static TCHAR szSharedMemName[] = TEXT("ISIGN32_SHAREMEMORY");
static HANDLE hSharedMem = 0;
BOOL retval = FALSE;
if (fInit)
{
DWORD dwErr = ERROR_SUCCESS;
SetLastError(0);
hSharedMem = CreateFileMapping(
INVALID_HANDLE_VALUE,
NULL,
PAGE_READWRITE,
0,
sizeof(ISIGN32SHARE),
szSharedMemName);
dwErr = GetLastError();
switch (dwErr)
{
case ERROR_ALREADY_EXISTS:
case ERROR_SUCCESS:
pDynShare = (PISIGN32SHARE) MapViewOfFile(
hSharedMem,
FILE_MAP_WRITE,
0,
0,
0);
if (pDynShare != NULL)
{
if (dwErr == ERROR_SUCCESS)
{
pDynShare->dwControlFlags = 0;
pDynShare->dwBrandFlags = BRAND_DEFAULT;
pDynShare->dwExitFlags = 0;
pDynShare->szAutodialConnection[0] = (TCHAR)0;
pDynShare->szCheckAssociations[0] = (TCHAR)0;
#if !defined(WIN16)
pDynShare->szISPFile[0] = (TCHAR)0;
lstrcpyn(
pDynShare->szFile,
TEXT("uninited\0"),
SIZEOF_TCHAR_BUFFER(pDynShare->szFile));
pDynShare->hReconnectEvent = NULL;
SetControlFlags(SCF_NEEDBACKUPSECURITY);
#endif
pDynShare->szSignupConnection[0] = (TCHAR)0;
pDynShare->szPassword[0] = (TCHAR)0;
pDynShare->szRunExecutable[0] = (TCHAR)0;
pDynShare->szRunArgument[0] = (TCHAR)0;
pDynShare->pbIEWindowPlacement[0] = (TCHAR)0;
pDynShare->dwIEWindowPlacementSize = 0;
pDynShare->hwndBrowser = NULL;
pDynShare->hwndMain = NULL;
pDynShare->hwndLaunch = NULL;
}
else // dwErr == ERROR_ALREADY_EXISTS
{
}
retval = TRUE;
}
else
{
Dprintf("MapViewOfFile failed: 0x%08lx", GetLastError());
CloseHandle(hSharedMem);
hSharedMem = 0;
retval = FALSE;
}
break;
default:
Dprintf("CreateFileMapping failed: 0x08lx", dwErr);
hSharedMem = 0;
retval = FALSE;
}
}
else
{
if (pDynShare)
{
UnmapViewOfFile(pDynShare);
pDynShare = NULL;
}
if (hSharedMem)
{
CloseHandle(hSharedMem);
hSharedMem = NULL;
}
retval = TRUE;
}
return retval;
}
//************ End of Memory Map File for Share Data ************
TCHAR FAR cszWndClassName[] = TEXT("Internet Signup\0");
TCHAR FAR cszAppName[MAX_PATH + 1] = TEXT("");
TCHAR FAR cszICWDIAL_DLL[] = TEXT("ICWDIAL.DLL\0");
CHAR FAR cszICWDIAL_DIALDLG[] = "DialingDownloadDialog\0";
CHAR FAR cszICWDIAL_ERRORDLG[] = "DialingErrorDialog\0";
HINSTANCE ghInstance;
#ifdef WIN32
// NOT shared
IWebBrowserApp FAR * g_iwbapp = NULL;
CDExplorerEvents * g_pMySink = NULL;
IConnectionPoint *g_pCP = NULL;
//BOOL g_bISPWaiting = FALSE;
TCHAR g_szISPPath[MAX_URL + 1] = TEXT("not initialized\0");
// For single instance checking.
HANDLE g_hSemaphore = NULL;
//
// ChrisK Olympus 6198 6/10/97
//
#define REG_ZONE3_KEY TEXT("Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings\\Zones\\3")
#define REG_ZONE1601_KEY TEXT("1601")
DWORD g_dwZone_1601 = 0;
BOOL g_fReadZone = FALSE;
#endif
static DWORD dwConnectedTime = 0;
static BOOL ProcessCommandLine(LPCTSTR lpszCmdLine, LPDWORD lpdwFlags, LPTSTR lpszFile, DWORD cb);
//static INET_FILETYPE GetInetFileType(LPCTSTR lpszFile);
INET_FILETYPE GetInetFileType(LPCTSTR lpszFile);
static BOOL ProcessHTML(HWND hwnd, LPCTSTR lpszFile);
static BOOL ProcessINS(HWND hwnd, LPCTSTR lpszFile, BOOL fSignup);
//static BOOL ProcessISP(HWND hwnd, LPCTSTR lpszFile);
static DWORD SetRunOnce(LPCTSTR lpszFileName);
static BOOL GetURL(LPCTSTR lpszFile,LPCTSTR lpszKey, LPTSTR lpszURL, DWORD cb);
static void DoExit();
static HWND MainInit(void);
static void SaveAutoDial(void);
static void RestoreAutoDial(void);
static DWORD RunExecutable(BOOL bWait);
static DWORD CreateConnection(LPCTSTR lpszFile);
static DWORD KillConnection(void);
static BOOL ExecBrowser(HWND hwnd, LPCTSTR lpszURL);
VOID RemoveQuotes (LPTSTR pCommandLine); //MKarki -(5/1/97) Fix forBug #4049
#if !defined(WIN16)
// 8/19/96 jmazner Normandy #4571
static BOOL IEInstalled(void);
static BOOL GetAppVersion(PDWORD pdwVerNumMS, PDWORD pdwVerNumLS, LPTSTR lpszAppName);
// 8/21/96 jmazner Normandy #4592
static BOOL RestoreIEWindowPlacement( void );
static BOOL SaveIEWindowPlacement( void );
// 10-9-96 Chrisk 8782
static void InstallScripter(void);
// 10-15-96 ChrisK
static BOOL FGetSystemShutdownPrivledge();
// 10-17-96 ChrisK
static BOOL VerifyRasServicesRunning(HWND hwnd);
// 1/20/97 jmazner Normandy #9403
static BOOL SetStartUpCommand(LPTSTR lpCmd);
static void DeleteStartUpCommand( void );
// 1/28/97 jmazner Normandy #13454
static BOOL GetICWCompleted( DWORD *pdwCompleted );
static BOOL SetICWCompleted( DWORD dwCompleted );
// 2/19/97 jmazner Olympus #1106 -- SAM/SBS integration
TCHAR FAR cszSBSCFG_DLL[] = TEXT("SBSCFG.DLL\0");
CHAR FAR cszSBSCFG_CONFIGURE[] = "Configure\0";
typedef DWORD (WINAPI * SBSCONFIGURE) (HWND hwnd, LPTSTR lpszINSFile, LPTSTR szConnectoidName);
SBSCONFIGURE lpfnConfigure;
// 8/7/97 jmazner Olympus #6059
BOOL CreateSecurityPatchBackup( void );
// 3/11/97 jmazner Olympus #1545
VOID RestoreSecurityPatch( void );
#endif
static HWND FindBrowser(void);
static void KillBrowser(void);
static DWORD ImportBrandingInfo(LPCTSTR lpszFile);
static DWORD MassageFile(LPCTSTR lpszFile);
static HWND LaunchInit(HWND hwndParent);
static HRESULT DialConnection(LPCTSTR lpszFile);
static DWORD ImportMailAndNewsInfo(LPCTSTR lpszFile, BOOL fConnectPhone);
//static HRESULT WriteMailAndNewsKey(HKEY hKey, LPCTSTR lpszSection, LPCTSTR lpszValue, LPTSTR lpszBuff, DWORD dwBuffLen,LPCTSTR lpszSubKey, DWORD dwType, LPCTSTR lpszFile);
static HRESULT PreparePassword(LPTSTR szBuff, DWORD dwBuffLen);
//static BOOL FIsAthenaPresent();
static BOOL FTurnOffBrowserDefaultChecking();
static BOOL FRestoreBrowserDefaultChecking();
static HRESULT DeleteFileKindaLikeThisOne(LPCTSTR lpszFileName);
/*
#ifdef DEBUG
#define DebugOut(sz) OutputDebugString(sz)
#else
#define DebugOut(sz)
#endif
*/
LRESULT FAR PASCAL WndProc (HWND, UINT, WPARAM, LPARAM) ;
#if !defined(ERROR_USERCANCEL)
# define ERROR_USERCANCEL 32767
#endif
#if !defined(ERROR_USERBACK)
# define ERROR_USERBACK 32766
#endif
#if !defined(ERROR_USERNEXT)
# define ERROR_USERNEXT 32765
#endif
#define MAX_ERROR_MESSAGE 1024
typedef HRESULT (WINAPI*PFNDIALDLG)(PDIALDLGDATA pDD);
typedef HRESULT (WINAPI*PFNERRORDLG)(PERRORDLGDATA pED);
//
// WIN32 only function prototypes
//
#define DEVICENAMEKEY TEXT("DeviceName")
#define DEVICETYPEKEY TEXT("DeviceType")
static BOOL DeleteUserDeviceSelection(LPTSTR szKey);
VOID WINAPI RasDial1Callback(HRASCONN, UINT, RASCONNSTATE, DWORD, DWORD);
DWORD WINAPI StartNTReconnectThread (HRASCONN hrasconn);
DWORD ConfigRasEntryDevice( LPRASENTRY lpRasEntry );
TCHAR g_szDeviceName[RAS_MaxDeviceName + 1] = TEXT("\0"); //holds the user's modem choice when multiple
TCHAR g_szDeviceType[RAS_MaxDeviceType + 1] = TEXT("\0"); // modems are installed
BOOL IsSingleInstance(BOOL bProcessingINS);
void ReleaseSingleInstance();
#define ISIGNUP_KEY TEXT("Software\\Microsoft\\ISIGNUP")
#if !defined(WIN16)
// There are other headers that contain copies of this structure (AUTODIAL).
// so if you change anything here, you have to go hunt down the other copies.
//
#pragma pack(2)
#define MAX_PROMO 64
#define MAX_OEMNAME 64
#define MAX_AREACODE RAS_MaxAreaCode
#define MAX_EXCHANGE 8
#define MAX_VERSION_LEN 40
typedef struct tagGATHEREDINFO
{
LCID lcid;
DWORD dwOS;
DWORD dwMajorVersion;
DWORD dwMinorVersion;
WORD wArchitecture;
TCHAR szPromo[MAX_PROMO];
TCHAR szOEM[MAX_OEMNAME];
TCHAR szAreaCode[MAX_AREACODE+1];
TCHAR szExchange[MAX_EXCHANGE+1];
DWORD dwCountry;
TCHAR szSUVersion[MAX_VERSION_LEN];
WORD wState;
BYTE fType;
BYTE bMask;
TCHAR szISPFile[MAX_PATH+1];
TCHAR szAppDir[MAX_PATH+1];
} GATHEREDINFO, *PGATHEREDINFO;
#pragma pack()
#endif //!WIN16
#ifdef DEBUG
void _ISIGN32_Assert(LPCTSTR strFile, unsigned uLine)
{
TCHAR buf[512];
wsprintf(buf, TEXT("Assertion failed: %s, line %u"),
strFile, uLine);
OutputDebugString(buf);
}
#endif
#ifdef WIN32
/*******************************************************************
NAME: DllEntryPoint
SYNOPSIS: Entry point for DLL.
NOTES:
********************************************************************/
extern "C" BOOL APIENTRY LibMain(HINSTANCE hInstDll, DWORD fdwReason, LPVOID lpvReserved)
{
BOOL retval = TRUE;
if( fdwReason == DLL_PROCESS_ATTACH )
{
ghInstance = hInstDll;
LoadString(ghInstance, IDS_APP_TITLE, cszAppName, SIZEOF_TCHAR_BUFFER(cszAppName));
retval = LibShareEntry(TRUE);
}
else if ( fdwReason == DLL_PROCESS_DETACH )
{
retval = LibShareEntry(FALSE);
}
return retval;
}
#else
/*******************************************************************
NAME: LibMain
SYNOPSIS: Used to trace NDI messages
ENTRY: hinst - handle of library instance
wDataSeg - library data segment
cbHeapSize - default heap size
lpszCmdLine - command-line arguments
EXIT: returns 1
NOTES:
********************************************************************/
int CALLBACK LibMain(
HINSTANCE hinst, /* handle of library instance */
WORD wDataSeg, /* library data segment */
WORD cbHeapSize, /* default heap size */
LPTSTR lpszCmdLine /* command-line arguments */
)
{
ghInstance = hinst;
LoadString(ghInstance, IDS_APP_TITLE, cszAppName, SIZEOF_TCHAR_BUFFER(cszAppName));
return LibShareEntry(TRUE);
}
#endif
int EXPORT WINAPI Signup
(
HANDLE hInstance,
HANDLE hPrevInstance,
LPTSTR lpszCmdLine,
int nCmdShow
)
{
HWND hwnd = NULL;
BOOL fRet;
DWORD dwFlags;
TCHAR szFileName[_MAX_PATH + 1];
int iRet = 0;
INET_FILETYPE fileType;
HWND hwndProgress = NULL;
HKEY hKey = NULL;
TCHAR szTemp[4];
BOOL bISetAsSAFE = FALSE;
if (!LoadInetFunctions(pDynShare->hwndMain))
{
return 0;
}
if (!ProcessCommandLine(lpszCmdLine, &dwFlags, szFileName, sizeof(szFileName)))
{
if (0 == lstrlen(lpszCmdLine))
{
ErrorMsg(pDynShare->hwndMain, IDS_NOCMDLINE);
}
else
{
ErrorMsg1(pDynShare->hwndMain, IDS_INVALIDCMDLINE,
lpszCmdLine ? lpszCmdLine : TEXT("\0"));
}
goto exit;
}
if (dwFlags & SEF_RUNONCE)
{
SetControlFlags(SCF_SYSTEMCONFIGURED);
}
fileType = GetInetFileType(szFileName);
switch (fileType)
{
case INS_FILE:
DebugOut("ISIGNUP: Process INS\n");
IsSingleInstance( TRUE );
ProcessINS(pDynShare->hwndMain, szFileName, NULL != pDynShare->hwndMain);
if (NULL == pDynShare->hwndMain)
{
DoExit();
}
goto exit;
case HTML_FILE:
case ISP_FILE:
{
if (!IsSingleInstance(FALSE))
return FALSE;
TCHAR szDrive [_MAX_DRIVE] = TEXT("\0");
TCHAR szDir [_MAX_DIR] = TEXT("\0");
TCHAR szTemp [_MAX_PATH + 1] = TEXT("\0");
_tsplitpath(szFileName, szDrive, szDir, NULL, NULL);
_tmakepath (szTemp, szDrive, szDir, HARDCODED_IEAK_ISP_FILENAME, NULL);
//Examine the isp or htm file to see if they want to run the ICW
if ((GetFileAttributes(szTemp) != 0xFFFFFFFF) && (UseICWForIEAK(szTemp)))
{
//they do .. let's do it.
RunICWinIEAKMode(szTemp);
}
else //else RUN IEXPLORE Kiosk
{
// 8/19/96 jmazner Normandy #4571 and #10293
// Check to ensure that the right version IE is installed before trying to exec it
if ( !IEInstalled() )
{
ErrorMsg( hwnd, IDS_MISSINGIE );
return(FALSE);
}
DWORD dwVerMS, dwVerLS;
if( !GetAppVersion( &dwVerMS, &dwVerLS,IE_PATHKEY ) )
{
ErrorMsg( hwnd, IDS_MISSINGIE );
return (FALSE);
}
if( !( (dwVerMS >= IE_MINIMUM_VERSIONMS) && (dwVerLS >= IE_MINIMUM_VERSIONLS) ) )
{
Dprintf("ISIGN32: user has IE version %d.%d.%d.%d; min ver is %d.%d.%d.%d\n",
HIWORD(dwVerMS), LOWORD(dwVerMS), HIWORD(dwVerLS), LOWORD(dwVerLS),
HIWORD(IE_MINIMUM_VERSIONMS),LOWORD(IE_MINIMUM_VERSIONMS),
HIWORD(IE_MINIMUM_VERSIONLS),LOWORD(IE_MINIMUM_VERSIONLS));
ErrorMsg1( hwnd, IDS_IELOWVERSION, IE_MINIMUM_VERSION_HUMAN_READABLE );
return(FALSE);
}
// 8/21/96 jmazner Normandy #4592
if( !TestControlFlags(SCF_BROWSERLAUNCHED) )
{
if ( SaveIEWindowPlacement() )
{
SetExitFlags(SXF_RESTOREIEWINDOWPLACEMENT);
}
}
// check to see if we are the first window
if (NULL == pDynShare->hwndMain)
{
DebugOut("ISIGNUP: First Window\n");
hwnd = pDynShare->hwndMain = MainInit();
if (dwFlags & SEF_SPLASH)
{
pDynShare->hwndLaunch = LaunchInit(NULL);
}
if (dwFlags & SEF_PROGRESS)
{
// 8/16/96 jmazner Normandy #4593 pass NULL as ProgressInit's parent window
hwndProgress = ProgressInit(NULL);
}
}
// 3/11/97 jmazner Olympus #1545
// -------------------------------------------------------------------------
// The entire section between here and the #endif was added to fix a security
// hole in IE3.01. The problem was based around .INS files being marked as
// safe when in fact they could be used to launch any application if you knew
// the right incantation, and someone figured it out.
//
//
if (FALSE == TestControlFlags(SCF_SAFESET))
{
#define ISIGNUP_PATHKEY TEXT("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\ISIGNUP.EXE")
hKey = NULL;
//szPath[0] = '\0';
//hSecureRegFile = INVALID_HANDLE_VALUE;
Dprintf("ISIGN32: Adjusting EditFlags settings\n");
//
// ChrisK Olympus 6198 6/10/97
// Allow HTML form submissions from ICW
//
if (ERROR_SUCCESS == RegOpenKey(HKEY_CURRENT_USER,REG_ZONE3_KEY,&hKey))
{
DWORD dwZoneData;
DWORD dwType;
DWORD dwSize;
g_dwZone_1601 = 0;
dwSize = sizeof(g_dwZone_1601);
dwType = 0;
//
// Read current setting for zone3 1601
//
if (ERROR_SUCCESS == RegQueryValueEx(hKey,
REG_ZONE1601_KEY,
NULL,
&dwType,
(LPBYTE)&g_dwZone_1601,
&dwSize))
{
DebugOut("ISIGN32: Read zone settings succesfully.\n");
g_fReadZone = TRUE;
}
else
{
DebugOut("ISIGN32: Read zone settings failed.\n");
}
RegCloseKey(hKey);
hKey = NULL;
}
//
// 8/7/97 jmazner Olympus #6059
// Due to the way IE 4 shell deals with RunOnce processing,
// don't add any thing to RunOnce until the browser is
// completely initialized (we get a DISPID_NAVIGATECOMPLETE event.)
//
if (!(SEF_NOSECURITYBACKUP & dwFlags))
{
SetControlFlags(SCF_NEEDBACKUPSECURITY);
}
else
{
ClearControlFlags(SCF_NEEDBACKUPSECURITY);
}
// Fix security hole for malious .isp/.ins file combinations
BYTE szBytes[4];
szBytes[0] = (BYTE)0;
szBytes[1] = (BYTE)0;
szBytes[2] = (BYTE)1;
szBytes[3] = (BYTE)0;
// Mark various registry entries as safe.
if (ERROR_SUCCESS == RegOpenKey(HKEY_CLASSES_ROOT,TEXT("x-internet-signup"),&hKey))
{
RegSetValueEx(hKey,TEXT("EditFlags"),(DWORD)NULL,(DWORD)REG_BINARY,(BYTE*)&szBytes[0],(DWORD)4);
RegCloseKey(hKey);
hKey = NULL;
}
if (ERROR_SUCCESS == RegOpenKey(HKEY_CLASSES_ROOT,TEXT(".ins"),&hKey))
{
RegSetValueEx(hKey,TEXT("EditFlags"),(DWORD)NULL,(DWORD)REG_BINARY,(BYTE*)&szBytes[0],(DWORD)4);
RegCloseKey(hKey);
hKey = NULL;
}
if (ERROR_SUCCESS == RegOpenKey(HKEY_CLASSES_ROOT,TEXT(".isp"),&hKey))
{
RegSetValueEx(hKey,TEXT("EditFlags"),(DWORD)NULL,(DWORD)REG_BINARY,(BYTE*)&szBytes[0],(DWORD)4);
RegCloseKey(hKey);
hKey = NULL;
}
bISetAsSAFE=TRUE;
SetControlFlags(SCF_SAFESET);
//
// ChrisK Olympus 6198 6/10/97
// Allow HTML form submissions from ICW
//
if (g_fReadZone &&
ERROR_SUCCESS == RegOpenKey(HKEY_CURRENT_USER,REG_ZONE3_KEY,&hKey))
{
DWORD dwZoneData;
//
// Set value for zone to 0, therefore opening security window
//
dwZoneData = 0;
RegSetValueEx(hKey,
REG_ZONE1601_KEY,
NULL,
REG_DWORD,
(LPBYTE)&dwZoneData,
sizeof(dwZoneData));
RegCloseKey(hKey);
hKey = NULL;
}
}
//EndOfSecurityHandling:
// jmazner 11/5/96 Normandy #8717
// save autodial and clear out proxy _before_ bringing up the
// IE instance.
SaveAutoDial();
SetExitFlags(SXF_RESTOREAUTODIAL);
if (HTML_FILE == fileType)
{
DebugOut("ISIGNUP: Process HTML\n");
fRet = ProcessHTML(pDynShare->hwndMain, szFileName);
}
else
{
DebugOut("ISIGNUP: Process ISP\n");
if (TestControlFlags(SCF_ISPPROCESSING))
{
SetForegroundWindow(pDynShare->hwndMain);
ReleaseSingleInstance();
return FALSE;
}
else
{
SetControlFlags(SCF_ISPPROCESSING);
}
fRet = ProcessISP(pDynShare->hwndMain, szFileName);
SetControlFlags(SCF_ISPPROCESSING);
}
}//end else RUN IEXPLORE Kiosk
break;
}
default:
if (IsSingleInstance(FALSE))
{
ErrorMsg1(pDynShare->hwndMain, IDS_INVALIDFILETYPE, szFileName);
}
if (NULL != pDynShare->hwndMain)
{
PostMessage(pDynShare->hwndMain, WM_CLOSE, 0, 0);
}
break;
}
// if we are the first window
if ((hwnd == pDynShare->hwndMain) && (NULL != hwnd))
{
if (fRet)
{
MSG msg;
SetTimer(hwnd, 0, 1000, NULL);
DebugOut("ISIGNUP: Message loop\n");
while (GetMessage (&msg, NULL, 0, 0))
{
TranslateMessage (&msg) ;
DispatchMessage (&msg) ;
}
iRet = (int)msg.wParam ;
}
DoExit();
if (NULL != hwndProgress)
{
DestroyWindow(hwndProgress);
hwndProgress = NULL;
}
if (NULL != pDynShare->hwndLaunch)
{
DestroyWindow(pDynShare->hwndLaunch);
pDynShare->hwndLaunch = NULL;
}
if (pDynShare->hwndMain)
{
DeleteUserDeviceSelection(DEVICENAMEKEY);
DeleteUserDeviceSelection(DEVICETYPEKEY);
}
pDynShare->hwndMain = NULL;
}
exit:
// 3/11/97 jmazner Olympus #1545
if (TRUE == bISetAsSAFE)
{
RestoreSecurityPatch();
ClearControlFlags(SCF_SAFESET);
}
UnloadInetFunctions();
ReleaseSingleInstance();
return iRet;
}
HWND MainInit()
{
HWND hwnd ;
WNDCLASS wndclass ;
wndclass.style = CS_HREDRAW | CS_VREDRAW ;
wndclass.lpfnWndProc = WndProc ;
wndclass.cbClsExtra = 0 ;
wndclass.cbWndExtra = 0 ;
wndclass.hInstance = ghInstance ;
wndclass.hIcon = LoadIcon (ghInstance, TEXT("ICO_APP")) ;
wndclass.hCursor = LoadCursor (NULL, IDC_ARROW) ;
wndclass.hbrBackground = (HBRUSH)GetStockObject (WHITE_BRUSH) ;
wndclass.lpszMenuName = NULL ;
wndclass.lpszClassName = cszWndClassName;
RegisterClass (&wndclass) ;
hwnd = CreateWindow (cszWndClassName, // window class name
cszAppName, // window caption
WS_POPUP, // window style
CW_USEDEFAULT, // initial x position
CW_USEDEFAULT, // initial y position
CW_USEDEFAULT, // initial x size
CW_USEDEFAULT, // initial y size
NULL, // parent window handle
NULL, // window menu handle
ghInstance, // program instance handle
NULL) ; // creation parameters
return hwnd;
}
LRESULT EXPORT FAR PASCAL WndProc (
HWND hwnd,
UINT message,
WPARAM wParam,
LPARAM lParam)
{
switch (message)
{
#ifdef WIN32
case WM_PROCESSISP:
DebugOut("ISIGNUP: Message loop got WM_PROCESSISP");
if (TestControlFlags(SCF_ISPPROCESSING))
{
DebugOut("ISIGNUP: Received another WM_PROCESSISP message with gbCurrentlyProcessingISP = TRUE\r\n");
SetForegroundWindow(pDynShare->hwndMain);
// that's it, don't do anything else!
}
else
{
SetControlFlags(SCF_ISPPROCESSING);
if ( !ProcessISP(pDynShare->hwndMain, g_szISPPath) )
{
PostMessage(pDynShare->hwndMain, WM_CLOSE, 0, 0);
}
}
break;
#endif
case WM_TIMER:
{
HWND hwndTemp = FindBrowser();
if (NULL == hwndTemp)
{
if (!TestControlFlags(SCF_SIGNUPCOMPLETED))
{
++dwConnectedTime;
if (pDynShare->hwndBrowser != NULL)
{
// browser went away
KillTimer(hwnd, 0);
KillConnection();
InfoMsg(hwnd, IDS_BROWSERTERMINATED);
PostQuitMessage(0);
}
else if (dwConnectedTime > WAIT_TIME)
{
KillTimer(hwnd, 0);
if (NULL != pDynShare->hwndLaunch)
{
ShowWindow(pDynShare->hwndLaunch, SW_HIDE);
}
InfoMsg(hwnd, IDS_BROWSERNEVERFOUND);
PostQuitMessage(0);
}
}
}
else
{
#ifdef WIN32 // don't do this with OLE automation; we're already full screen, and this causes flicker
//if (NULL == hwndBrowser)
//{
//first time browser has been detected
// ShowWindow(hwndTemp, SW_MAXIMIZE);
//}
#endif
if ((NULL != pDynShare->hwndLaunch) && IsWindowVisible(hwndTemp))
{
ShowWindow(pDynShare->hwndLaunch, SW_HIDE);
}
}
pDynShare->hwndBrowser = hwndTemp;
}
break;
case WM_DESTROY:
#if !defined(WIN16)
if (pDynShare->hReconnectEvent)
{
DebugOut("ISIGN32: Set event to end reconnect thread.\r\n");
SetControlFlags(SCF_RECONNECTTHREADQUITED);
SetEvent(pDynShare->hReconnectEvent);
CloseHandle(pDynShare->hReconnectEvent);
pDynShare->hReconnectEvent = NULL;
}
#endif
PostQuitMessage(0);
return 0 ;
}
return DefWindowProc (hwnd, message, wParam, lParam) ;
}
void DoExit(void)
{
if (TestExitFlags(SXF_RESTOREDEFCHECK))
{
// restore IE check for default browser
FRestoreBrowserDefaultChecking();
}
if (!TestExitFlags(SXF_KEEPCONNECTION))
{
// make sure the connection is closed
KillConnection();
}
if (!TestExitFlags(SXF_KEEPBROWSER))
{
// make sure the browser is closed
KillBrowser();
}
if (TestExitFlags(SXF_RESTOREAUTODIAL))
{
// restore original autodial settings
RestoreAutoDial();
}
#if !defined(WIN16)
// 8/21/96 jmazner Normandy #4592
if ( TestExitFlags( SXF_RESTOREIEWINDOWPLACEMENT ))
{
RestoreIEWindowPlacement();
}
#endif
if (TestExitFlags(SXF_RUNEXECUTABLE))
{
BOOL fWait;
fWait = TestExitFlags(SXF_WAITEXECUTABLE);
if (RunExecutable(fWait) != ERROR_SUCCESS)
{
// clean up left overs
if (TestExitFlags(SXF_KEEPCONNECTION))
{
// make sure the connection is closed
KillConnection();
}
if (TestExitFlags(SXF_KEEPBROWSER))
{
// make sure the browser is closed
KillBrowser();
}
ErrorMsg1(NULL, IDS_EXECFAILED, pDynShare->szRunExecutable);
return;
}
}
}
BOOL HasPrefix(LPCTSTR lpszURL)
{
TCHAR szTemp[sizeof(cszHTTPS)];
//
// Check is the prefix is https
//
lstrcpyn(szTemp, lpszURL, lstrlen(cszHTTPS) + 1);
if (lstrcmp(szTemp, cszHTTPS) == 0)
return TRUE;
else
{
TCHAR szTemp[sizeof(cszHTTP)];
lstrcpyn(szTemp, lpszURL, lstrlen(cszHTTP) + 1);
return ((lstrcmp(szTemp, cszHTTP) == 0) || (lstrcmp(szTemp, cszFILE) == 0));
}
}
#ifdef WIN32
DWORD FixUpLocalURL(LPCTSTR lpszURL, LPTSTR lpszFullURL, DWORD cb)
{
TCHAR szLong[MAX_URL];
TCHAR szShort[MAX_URL];
DWORD dwSize;
if (GetFullPathName(
lpszURL,
MAX_URL,
szLong,
NULL) != 0)
{
NULL_TERM_TCHAR_BUFFER(szLong);
if (GetShortPathName(
szLong,
szShort,
SIZEOF_TCHAR_BUFFER(szShort)) != 0)
{
NULL_TERM_TCHAR_BUFFER(szShort);
dwSize = sizeof(cszFILE) + lstrlen(szShort);
if (dwSize < cb)
{
lpszFullURL[0] = '\0';
// Do not prepend file: for local files
// IE3.0 hack for bug :MSN Systems Bugs #9280
// lstrcpy(lpszFullURL, cszFILE);
lstrcat(lpszFullURL, szShort);
return dwSize;
}
}
}
return 0;
}
#else
DWORD FixUpLocalURL(LPCTSTR lpszURL, LPTSTR lpszFullURL, DWORD cb)
{
TCHAR szPath[MAX_URL];
DWORD dwSize;
if (GetFullPathName(
lpszURL,
MAX_URL,
szPath,
NULL) != 0)
{
dwSize = sizeof(cszFILE) + lstrlen(szPath);
if (dwSize < cb)
{
lstrcpy(lpszFullURL, cszFILE);
lstrcat(lpszFullURL, szPath);
return dwSize;
}
}
return 0;
}
#endif
DWORD FixUpURL(LPCTSTR lpszURL, LPTSTR lpszFullURL, DWORD cb)
{
DWORD dwSize;
if (HasPrefix(lpszURL))
{
dwSize = lstrlen(lpszURL);
if (dwSize < cb)
{
lstrcpyn(lpszFullURL, lpszURL, (int)cb);
return dwSize;
}
else
{
return 0;
}
}
else
{
return (FixUpLocalURL(lpszURL, lpszFullURL, cb));
}
}
BOOL GetURL(LPCTSTR lpszFile, LPCTSTR lpszKey, LPTSTR lpszURL, DWORD cb)
{
return (GetPrivateProfileString(cszURLSection,
lpszKey,
szNull,
lpszURL,
(int)cb,
lpszFile) != 0);
}
LPTSTR mystrrchr(LPCTSTR lpString, TCHAR ch)
{
LPCTSTR lpTemp = lpString;
LPTSTR lpLast = NULL;
while (*lpTemp)
{
if (*lpTemp == ch)
{
lpLast = (LPTSTR)lpTemp;
}
lpTemp = CharNext(lpTemp);
}
return lpLast;
}
#if !defined(WIN16)
//+----------------------------------------------------------------------------
// Function CopyUntil
//
// Synopsis Copy from source until destination until running out of source
// or until the next character of the source is the chend character
//
// Arguments dest - buffer to recieve characters
// src - source buffer
// lpdwLen - length of dest buffer
// chend - the terminating character
//
// Returns FALSE - ran out of room in dest buffer
//
// Histroy 10/25/96 ChrisK Created
//-----------------------------------------------------------------------------
static BOOL CopyUntil(LPTSTR *dest, LPTSTR *src, LPDWORD lpdwLen, TCHAR chend)
{
while (('\0' != **src) && (chend != **src) && (0 != *lpdwLen))
{
**dest = **src;
(*lpdwLen)--;
(*dest)++;
(*src)++;
}
return (0 != *lpdwLen);
}
//+----------------------------------------------------------------------------
// Function ConvertToLongFilename
//
// Synopsis convert a file to the full long file name
// ie. c:\progra~1\icw-in~1\isignup.exe becomes
// c:\program files\icw-internet connection wizard\isignup.exe
//
// Arguments szOut - output buffer
// szIn - filename to be converted
// dwSize - size of the output buffer
//
// Returns TRUE - success
//
// History 10/25/96 ChrisK Created
//-----------------------------------------------------------------------------
static BOOL ConvertToLongFilename(LPTSTR szOut, LPTSTR szIn, DWORD dwSize)
{
BOOL bRC = FALSE;
LPTSTR pCur = szIn;
LPTSTR pCurOut = szOut;
LPTSTR pCurOutFilename = NULL;
WIN32_FIND_DATA fd;
DWORD dwSizeTemp;
LPTSTR pTemp = NULL;
ZeroMemory(pCurOut,dwSize);
//
// Validate parameters
//
if (NULL != pCurOut && NULL != pCur && 0 != dwSize)
{
//
// Copy drive letter
//
if (!CopyUntil(&pCurOut,&pCur,&dwSize,'\\'))
goto ConvertToLongFilenameExit;
pCurOut[0] = '\\';
dwSize--;
pCur++;
pCurOut++;
pCurOutFilename = pCurOut;
while (*pCur)
{
//
// Copy over possibly short name
//
pCurOut = pCurOutFilename;
dwSizeTemp = dwSize;
if (!CopyUntil(&pCurOut,&pCur,&dwSize,'\\'))
goto ConvertToLongFilenameExit;
ZeroMemory(&fd, sizeof(fd));
//
// Get long filename
//
if (INVALID_HANDLE_VALUE != FindFirstFile(szOut,&fd))
{
//
// Replace short filename with long filename
//
dwSize = dwSizeTemp;
pTemp = &(fd.cFileName[0]);
if (!CopyUntil(&pCurOutFilename,&pTemp,&dwSize,'\0'))
goto ConvertToLongFilenameExit;
if (*pCur)
{
//
// If there is another section then we just copied a directory
// name. Append a \ character;
//
pTemp = (LPTSTR)memcpy(TEXT("\\X"),TEXT("\\X"),0);
if (!CopyUntil(&pCurOutFilename,&pTemp,&dwSize,'X'))
goto ConvertToLongFilenameExit;
pCur++;
}
}
else
{
break;
}
}
//
// Did we get to the end (TRUE) or fail before that (FALSE)?
//
bRC = ('\0' == *pCur);
}
ConvertToLongFilenameExit:
return bRC;
}
#endif //!WIN16
INET_FILETYPE GetInetFileType(LPCTSTR lpszFile)
{
LPTSTR lpszExt;
INET_FILETYPE ft = UNKNOWN_FILE;
lpszExt = mystrrchr(lpszFile, '.');
if (NULL != lpszExt)
{
if (!lstrcmpi(lpszExt, cszExtINS))
{
ft = INS_FILE;
}
else if (!lstrcmpi(lpszExt, cszExtISP))
{
ft = ISP_FILE;
}
else if (!lstrcmpi(lpszExt, cszExtHTM))
{
ft = HTML_FILE;
}
else if (!lstrcmpi(lpszExt, cszExtHTML))
{
ft = HTML_FILE;
}
}
return ft;
}
#ifdef SETUPSTACK
DWORD SetRunOnce(LPCTSTR lpszFileName)
{
TCHAR szTemp[MAX_PATH + MAX_PATH + 1];
TCHAR szTemp2[MAX_PATH + 1];
DWORD dwRet = ERROR_CANTREAD;
HKEY hKey;
LPTSTR lpszFilePart;
if (GetModuleFileName(NULL,szTemp2,SIZEOF_TCHAR_BUFFER(szTemp2)) != 0)
{
NULL_TERM_TCHAR_BUFFER(szTemp2);
//
// Will not convert the ShortPathName into LongPathName even in
// case of NT/Win-95 as START.EXE parses long file names incorrectly
// on NT (short path names will work fine from Win-95's RUNONCE registry
// entry too. MKarki - Fix for Bug #346(OLYMPUS) 4/21/97
//
#if 0 //!defined(WIN16)
// szTemp2 contains the module name in short format
ConvertToLongFilename(szTemp,szTemp2,MAX_PATH);
// add quotes
wsprintf(szTemp2,TEXT("\"%s\""),szTemp);
// copy back into szTemp
lstrcpy(szTemp,szTemp2);
#else
GetShortPathName (szTemp2, szTemp, SIZEOF_TCHAR_BUFFER(szTemp));
NULL_TERM_TCHAR_BUFFER(szTemp);
//lstrcpy(szTemp,szTemp2);
#endif
// Determine Version
OSVERSIONINFO osvi;
ZeroMemory(&osvi,sizeof(OSVERSIONINFO));
osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
if (!GetVersionEx(&osvi))
{
ZeroMemory(&osvi,sizeof(OSVERSIONINFO));
}
// 1/20/96 jmazner Normandy #9403
// For NT only, use the startup menu
if (VER_PLATFORM_WIN32_NT == osvi.dwPlatformId)
{
// 3/14/97 jmazner TEMP
// temporary hack until we can work with IE for a better solution
//lstrcat(szTemp, " -r ");
//
// adding a -b switch so that when we start again we
// know that we are starting of a batch file
// MKarki (5/1/97) -Fix for Bug #4049
//
lstrcat(szTemp, TEXT(" -b -r -h "));
//
// adding extra quote at the front and end of file
// as we dont want start.exe to parse the filename
// MKarki (5/1/97) -Fix for Bug #4049
//
lstrcat (szTemp,TEXT("\""));
lstrcat(szTemp, lpszFileName);
lstrcat (szTemp,TEXT("\""));
SetStartUpCommand( szTemp );
}
else
{
//
// 3/14/97 jmazner TEMP
// temporary hack until we can work with IE for a better solution
//
// 8/8/97 jmazner Olympus #6059
// Well, we have a somewhat better solution. The problem here was that
// isignup without the -h sticks the backup security into the RunOnce key.
// But if Isignup itself was started from a RunOnce entry, there was a
// chance that RunOnce would also then execute the backup plan. For 6059
// the backup plan RunOnce entry has been defered, so it's okay to get
// rid of the -h now
//
lstrcat(szTemp, TEXT(" -r "));
//lstrcat(szTemp, TEXT(" -r -h "));
lstrcat(szTemp, lpszFileName);
dwRet = RegCreateKey(
HKEY_LOCAL_MACHINE,
REGSTR_PATH_RUNONCE,
&hKey);
if (ERROR_SUCCESS == dwRet)
{
dwRet = RegSetValueEx(
hKey,
cszAppName,
0L,
REG_SZ,
(LPBYTE)szTemp,
MAX_PATH + MAX_PATH + 1);
RegCloseKey(hKey);
}
}
}
return dwRet;
}
#endif
static BOOL ProcessCommandLine(
LPCTSTR lpszCmdLine,
LPDWORD lpdwfOptions,
LPTSTR lpszFile,
DWORD cb)
{
LPTSTR lpszCmd = NULL;
TCHAR szCommandLine[MAX_PATH +1];
TCHAR szTemp[_MAX_PATH + 1] = TEXT("");
LPTSTR lpszFilePart = NULL;
LPTSTR lpszConn = NULL;
BOOL fEnabled;
//
// need to copy the command line into our own buffers
// as it might be modified
// MKarki (5/1/97) - Fix for Bug#4049
//
CopyMemory (szCommandLine, lpszCmdLine, MAX_PATH);
lpszCmd = szCommandLine;
*lpdwfOptions = SEF_SPLASH;
#ifdef WIN32
// Determine Version
OSVERSIONINFO osvi;
ZeroMemory(&osvi,sizeof(OSVERSIONINFO));
osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
if (!GetVersionEx(&osvi))
{
ZeroMemory(&osvi,sizeof(OSVERSIONINFO));
}
#endif
// check to see if invoked from run once
while ((*lpszCmd == '-') || (*lpszCmd == '/'))
{
++lpszCmd; // skip '-' or '/'
switch (*lpszCmd)
{
case 'b': // we are running off a batch file
++lpszCmd; // skip 'b'
#ifdef WIN32
//
// another thing specific to WINNT is to remove the
// quotes from front and end of the file name, these
// have been put so that start.exe does not act smart
// and start parsing it and find things like & as special
// chars
// MKarki (5/1/97) - Fix for Bug #4049
if (VER_PLATFORM_WIN32_NT == osvi.dwPlatformId)
{
RemoveQuotes (lpszCmd);
}
#endif
case 'r':
++lpszCmd; // skip 'r'
*lpdwfOptions |= SEF_RUNONCE;
#ifdef WIN32
// 1/20/96 jmazner Normandy #9403
// clean up the .bat file if we did a run once under NT
if (VER_PLATFORM_WIN32_NT == osvi.dwPlatformId)
{
DeleteStartUpCommand();
}
#endif
break;
case 'a':
++lpszCmd; // skip 'a'
*lpdwfOptions &= ~SEF_SPLASH;
SetControlFlags(SCF_AUTODIALSAVED);
SetExitFlags(SXF_RESTOREAUTODIAL);
// get the name of the ISBU referal server, we may need it later.
lpfnInetGetAutodial(
&fEnabled,
pDynShare->szSignupConnection,
sizeof(pDynShare->szSignupConnection));
if (*lpszCmd++ == '1')
{
SetControlFlags(SCF_AUTODIALENABLED);
}
break;
case 'p':
++lpszCmd; // skip 'p'
if (*lpszCmd++ == '1')
{
SetControlFlags(SCF_PROXYENABLED);
}
break;
case 'c':
++lpszCmd; // skip 'c'
if (*lpszCmd++ != '"')
{
return FALSE;
}
lpszConn = pDynShare->szAutodialConnection;
while(*lpszCmd)
{
if (*lpszCmd == '"')
{
++lpszCmd; // skip '"'
break;
}
*lpszConn++ = *lpszCmd++;
}
*lpszConn = 0; // terminate string
break;
case 'x':
++lpszCmd; // skip 'x'
*lpdwfOptions |= SEF_PROGRESS;
break;
#if !defined(WIN16)
case 's':
++lpszCmd; // skip 's'
SetControlFlags(SCF_SILENT);
break;
#endif
// 3/14/97 jmazner TEMP
// temporary hack until we can work with IE for a better solution
case 'h':
++lpszCmd; // skip 'h'
*lpdwfOptions |= SEF_NOSECURITYBACKUP;
break;
default:
break;
}
// strip away spaces
while(*lpszCmd == ' ')
{
++lpszCmd;
}
}
if (0 == GetFullPathName(lpszCmd, _MAX_PATH + 1, szTemp, &lpszFilePart))
{
return FALSE;
}
// 11/26/96 jmazner Normandy #12142
// GetFullPathName called with lpszCmd == "c:" will return successfully, but
// lpszFilePart will be NULL. Check for that case.
if( !lpszFilePart )
return FALSE;
if (lstrlen(szTemp) >= (int)cb)
{
return FALSE;
}
lstrcpy(lpszFile, szTemp);
*lpszFilePart = '\0';
// set the current directory
// so that relative path will work
if (!SetCurrentDirectory(szTemp))
{
return FALSE;
}
return TRUE;
}
static BOOL KeepBrowser(LPCTSTR lpszFile)
{
TCHAR szTemp[10];
GetPrivateProfileString(cszCustomSection,
cszKeepBrowser,
cszNo,
szTemp,
10,
lpszFile);
return (!lstrcmpi(szTemp, cszYes));
}
static BOOL KeepConnection(LPCTSTR lpszFile)
{
TCHAR szTemp[10];
GetPrivateProfileString(cszCustomSection,
cszKeepConnection,
cszNo,
szTemp,
10,
lpszFile);
return (!lstrcmpi(szTemp, cszYes));
}
#if defined(WIN16)
static int CopyFile(LPCTSTR lpcszSrcFile, LPCTSTR lpcszDestFile)
{
HFILE hSrcFile, hDestFile;
UINT uiBytesRead = 0;
TCHAR szBuf[2048];
hSrcFile = _lopen(lpcszSrcFile, READ);
if (HFILE_ERROR == hSrcFile)
return -1;
//
// Create new file or if the file esists truncate it
//
hDestFile = _lcreat(lpcszDestFile, 0);
if (HFILE_ERROR == hDestFile)
{
_lclose(hSrcFile);
return -1;
}
do
{
uiBytesRead = _lread(hSrcFile, &szBuf[0], 2048);
if (HFILE_ERROR == uiBytesRead)
break;
_lwrite(hDestFile, &szBuf[0], uiBytesRead);
} while (0 != uiBytesRead);
_lclose(hSrcFile);
_lclose(hDestFile);
return 0;
}
#endif
#if defined(WIN16)
//+----------------------------------------------------------------------------
//
// Function: BackUpINSFile
//
// Synopsis: The 3.1 version of IE2.01 will delete the .ins file too soon
// therefore the ICW will make a backup of the ins file for use
// later.
//
// Arguments: lpszFile - name of INS file
//
// Returns: TRUE - success
// FALSE - failure
//
// History: 3/19/97 ChrisK extracted from ProcessINS
//-----------------------------------------------------------------------------
BOOL BackUpINSFile(LPCTSTR lpszFile)
{
LPTSTR lpszTemp;
TCHAR szNewFileName[MAX_PATH+2];
BOOL bRC = FALSE;
HWND hwnd = NULL;
ZeroMemory(&szNewFileName[0], MAX_PATH+1);
//
// Check if the last character in prefix is 'a'
// If it is, change it to 'b' in the new file name
// otherwise, change it to 'a' in the new file name
// Eg.: C:\iexplore\vetriv.ins --> C:\iexplore\vetria.ins
// Eg.: C:\iexplore\aaaaa.ins --> C:\iexplore\aaaab.ins
//
lpszTemp = strrchr(lpszFile, '.');
if (NULL == lpszTemp)
{
ErrorMsg(hwnd, IDS_CANNOTPROCESSINS);
goto BackUpINSFileExit;
}
lstrcpyn(szNewFileName, lpszFile, lpszTemp - lpszFile);
if ((*(lpszTemp - 1)) == 'a')
lstrcat(szNewFileName, TEXT("b.INS"));
else
lstrcat(szNewFileName, TEXT("a.INS"));
//
// Copy the contents
//
if (0 != CopyFile(lpszFile, szNewFileName))
{
ErrorMsg(hwnd, IDS_CANNOTPROCESSINS);
goto BackUpINSFileExit;
}
else
{
lpszFile = &szNewFileName[0];
}
bRC = TRUE;
BackUpINSFileExit:
return bRC;
}
#endif // WIN16
//+----------------------------------------------------------------------------
//
// Function: IsCancelINSFile
//
// Synopsis: This function will determine if the ins file is a cancel
// file, and if it is this function will handle it accordingly
//
// Arguments: lpszFile - name of ins file
// fSignup - TRUE if part of the signup process
//
// Returns: TRUE - ins file is a cancel file
//
// History: 3/19/97 ChrisK separated from process INS
//-----------------------------------------------------------------------------
BOOL IsCancelINSFile(LPCTSTR lpszFile,BOOL fSignup)
{
TCHAR szTemp[_MAX_PATH] = TEXT("XX");
BOOL bRC = FALSE;
HWND hwndMsg;
if (GetPrivateProfileString(cszEntrySection,
cszCancel,
szNull,
szTemp,
_MAX_PATH,
lpszFile) != 0)
{
bRC = TRUE;
if (fSignup && !TestControlFlags(SCF_CANCELINSPROCESSED))
{
// If this instance is part of a signup process
#if !defined(WIN16)
SetControlFlags(SCF_HANGUPEXPECTED);
#endif // !WIN16
SetControlFlags(SCF_CANCELINSPROCESSED);
KillConnection();
// jmazner 4/17/97 Olympus #2471
// kill IE window here to prevent user from clicking on cancel.ins link
// multiple times.
PostMessage(pDynShare->hwndMain, WM_CLOSE, 0, 0);
InfoMsg(NULL, IDS_SIGNUPCANCELLED);
//PostMessage(hwndMain, WM_CLOSE, 0, 0);
}
else if (TestControlFlags(SCF_CANCELINSPROCESSED))
{
// Bring the ISIGNUP widows to the front
hwndMsg = FindWindow(TEXT("#32770"),cszAppName);
if (hwndMsg)
{
#if !defined(WIN16)
SetForegroundWindow (hwndMsg);
#else // !WIN16
SetFocus (hwndMsg);
#endif // !WIN16
}
}
}
return bRC;
}
//+----------------------------------------------------------------------------
//
// Function: IsHangupINSFile
//
// Synopsis: This function will determine if the ins file is a hangup
// file, and if it is this function will handle it accordingly
//
// Arguments: lpszFile - name of ins file
// fSignup - TRUE if part of the signup process
//
// Returns: TRUE - ins file is a hangup file
//
// History: 3/19/97 donaldm
//-----------------------------------------------------------------------------
BOOL IsHangupINSFile(LPCTSTR lpszFile,BOOL fSignup)
{
TCHAR szTemp[_MAX_PATH] = TEXT("XX");
BOOL bRC = FALSE;
HWND hwndMsg;
if (GetPrivateProfileString(cszEntrySection,
cszHangup,
szNull,
szTemp,
_MAX_PATH,
lpszFile) != 0)
{
bRC = TRUE;
if (fSignup && !TestControlFlags(SCF_HANGUPINSPROCESSED))
{
// If this instance is part of a signup process
#if !defined(WIN16)
SetControlFlags(SCF_HANGUPEXPECTED);
#endif // !WIN16
SetControlFlags(SCF_HANGUPINSPROCESSED);
KillConnection();
// jmazner 4/17/97 Olympus #2471
// kill IE window here to prevent user from clicking on cancel.ins link
// multiple times.
PostMessage(pDynShare->hwndMain, WM_CLOSE, 0, 0);
}
else if (TestControlFlags(SCF_HANGUPINSPROCESSED))
{
// Bring the ISIGNUP widows to the front
hwndMsg = FindWindow(TEXT("#32770"),cszAppName);
if (hwndMsg)
{
#if !defined(WIN16)
SetForegroundWindow (hwndMsg);
#else // !WIN16
SetFocus (hwndMsg);
#endif // !WIN16
}
}
}
return bRC;
}
//+----------------------------------------------------------------------------
//
// Function: ProcessINS
//
// Synopsis: This function will process the contents of an .INS file
//
// Arguments: hwnd - pointer to parent window for all UI elements
// lpszFile - name of .INS file
// fSignup - if TRUE then this INS file is being processed as
// part a signup
//
// Returns: TRUE - success
// FALSE - failure
//
// History: 3/19/97 ChrisK Reworked the function considerbly to clean up
// a lot of problem with deleting INS files.
//-----------------------------------------------------------------------------
BOOL ProcessINS(HWND hwnd, LPCTSTR lpszFile, BOOL fSignup)
{
BOOL fNeedsRestart = FALSE;
LPRASENTRY lpRasEntry = NULL;
BOOL fConnectoidCreated = FALSE;
DWORD dwRet = 0xFF;
TCHAR szTemp[MAX_PATH] = TEXT("XX");
TCHAR szConnectoidName[RAS_MaxEntryName*2] = TEXT("");
BOOL fClientSetup = FALSE;
BOOL bRC = FALSE;
BOOL fErrMsgShown = FALSE;
#if !defined(WIN16)
DWORD dwSBSRet = ERROR_SUCCESS;
#endif // WIN16
HKEY hKey = NULL;
DWORD dwSize = sizeof(DWORD);
DWORD dwDesktopChanged = 0;
// 3/11/97 jmazner Olympus #1545
// close up the security hole ASAP. This will unfortunately also
// prevent a clever .ins file from bringing the user back to the
// referall page to choose a different ISP
#if !defined (WIN16)
RestoreSecurityPatch();
#endif // !WIN16
//
// Insure that the contents of the file are formatted correctly so
// that the GetPrivateProfile calls can parse the contents.
//
dwRet = MassageFile(lpszFile);
if (ERROR_SUCCESS != dwRet)
{
ErrorMsg(hwnd, IDS_CANNOTPROCESSINS);
goto ProcessINSExit;
}
//
// Determine if the .INS file is a "cancel" file
//
if (FALSE != IsCancelINSFile(lpszFile,fSignup))
goto ProcessINSExit;
//
// Determine if the .INS file is a "hangup" file
//
if (FALSE != IsHangupINSFile(lpszFile,fSignup))
goto ProcessINSExit;
//
// Make sure that the RAS services are running before calling any RAS APIs.
// This only applies to NT, but the function is smart enough to figure that
// out
//
#if !defined(WIN16)
if (!VerifyRasServicesRunning(hwnd))
goto ProcessINSExit;
#endif // !WIN16
//
// If we are no in the signup process, warn the user before changing there
// settings
//
if (!fSignup && !TestControlFlags(SCF_SILENT))
{
if (!WarningMsg(NULL, IDS_INSFILEWARNING))
{
goto ProcessINSExit;
}
}
else
{
#if !defined (WIN16)
// If there is a ClientSetup section, then we know that icwconn2
// will have to be run after isignup in order to handle the
// settings
if (GetPrivateProfileSection(cszClientSetupSection,
szTemp,
MAX_PATH,
lpszFile) != 0)
fClientSetup = TRUE;
#endif // !WIN16
if (fClientSetup || KeepConnection(lpszFile))
SetExitFlags(SXF_KEEPCONNECTION);
if (KeepBrowser(lpszFile))
SetExitFlags(SXF_KEEPBROWSER);
if (!TestExitFlags(SXF_KEEPCONNECTION))
KillConnection();
}
//
// Import various information from INS file
//
// Import name of executable to be launched after isignup
ImportCustomInfo(
lpszFile,
pDynShare->szRunExecutable,
SIZEOF_TCHAR_BUFFER(pDynShare->szRunExecutable),
pDynShare->szRunArgument,
SIZEOF_TCHAR_BUFFER(pDynShare->szRunArgument));
// Import RAS log-on script file
ImportCustomFile(lpszFile);
// Import network connection settings information and configure client
// pieces to use them.
dwRet = ConfigureClient(
hwnd,
lpszFile,
&fNeedsRestart,
&fConnectoidCreated,
TestControlFlags(SCF_LOGONREQUIRED),
szConnectoidName,
RAS_MaxEntryName);
//
// 6/2/97 jmazner Olympus #4573
// display an appropriate error msg
//
if( ERROR_SUCCESS != dwRet )
{
// 10/07/98 vyung IE bug#32882 hack.
// If we do not detect the [Entry] section in the ins file,
// we will assume it is an OE ins file. Then we will assume
// we have a autodial connection and pass the INS to OE.
if (ERROR_NO_MATCH == dwRet)
{
ImportMailAndNewsInfo(lpszFile, TRUE);
return TRUE;
}
else
{
ErrorMsg(hwnd, IDS_INSTALLFAILED);
fErrMsgShown = TRUE;
}
}
// Import information used to brand the broswer
ImportBrandingInfo(lpszFile, szConnectoidName);
#if !defined(WIN16)
// If we created a connectoid, tell the world that ICW
// has left the building...
SetICWCompleted( (DWORD)1 );
ClearControlFlags(SCF_ICWCOMPLETEDKEYRESETED);
// 2/19/97 jmazner Olympus 1106
// For SBS/SAM integration.
dwSBSRet = CallSBSConfig(hwnd, lpszFile);
switch( dwSBSRet )
{
case ERROR_SUCCESS:
break;
case ERROR_MOD_NOT_FOUND:
case ERROR_DLL_NOT_FOUND:
Dprintf("ISIGN32: SBSCFG DLL not found, I guess SAM ain't installed.\n");
break;
default:
ErrorMsg(hwnd, IDS_SBSCFGERROR);
}
#endif // !WIN16
#if defined(WIN16)
//
// Since IE 21 deletes the file from cache, we have to make
// a private copy of it, if we are going to run a 3rd EXE
//
if (*(pDynShare->szRunExecutable))
{
if (FALSE == BackUpINSFile(lpszFile))
goto ProcessINSExit;
}
#endif // WIN16
#if !defined (WIN16)
//
// If the INS file contains the ClientSetup section, build the commandline
// arguments for ICWCONN2.exe.
//
if (fClientSetup)
{
// Check to see if a REBOOT is needed and tell the next application to
// handle it.
if (fNeedsRestart)
{
wsprintf(pDynShare->szRunArgument,TEXT(" /INS:\"%s\" /REBOOT"),lpszFile);
fNeedsRestart = FALSE;
}
else
{
wsprintf(pDynShare->szRunArgument,TEXT(" /INS:\"%s\""),lpszFile);
}
}
#else // !WIN16
wsprintf(szRunArgument," /INS:\"%s\"",lpszFile);
#endif // !WIN16
SetControlFlags(SCF_SIGNUPCOMPLETED);
if (!TestExitFlags(SXF_KEEPBROWSER))
KillBrowser();
#ifdef WIN32
// humongous hack for ISBU
if (ERROR_SUCCESS != dwRet && fConnectoidCreated)
{
InfoMsg(hwnd, IDS_MAILFAILED);
dwRet = ERROR_SUCCESS;
}
#endif
//
// Import settings for mail and new read from INS file (ChrisK, 7/1/96)
//
if (ERROR_SUCCESS == dwRet)
ImportMailAndNewsInfo(lpszFile, fConnectoidCreated);
//
// Close up final details and clean up
//
if (ERROR_SUCCESS == dwRet)
{
// if the connectoid was created, do not restore the old autodial settings
if (fConnectoidCreated)
ClearExitFlags(SXF_RESTOREAUTODIAL);
#ifdef SETUPSTACK
// Is it necessary to reboot for configuration to take effect?
if (fNeedsRestart)
{
// what do we do if we need to run executable and
// we need the link or the browser BARF!!
if (PromptRestart(hwnd))
{
// 3/13/97 jmazner Olympus #1682
// technically, shouldn't need this here since we did it at the start
// of processINS, but better safe...
RestoreSecurityPatch();
FGetSystemShutdownPrivledge();
ExitWindowsEx(EWX_REBOOT, 0);
//
// We will wait for the System to release all
// resources, 5 minutes should be more than
// enough for this
// - MKarki (4/22/97) - MKarki
// Fix for Bug #3109
//
// 7/8/97 jmazner Olympus 4212
// No, sleeping for 5 minutes turns out not to be such a good idea.
//Sleep (300000);
//
}
}
else
#endif
{
if (*(pDynShare->szRunExecutable))
{
SetExitFlags(SXF_RUNEXECUTABLE | SXF_WAITEXECUTABLE);
}
else
{
if (!TestControlFlags(SCF_SILENT))
InfoMsg(hwnd, IDS_SIGNUPCOMPLETE);
}
}
}
else
{
// In case of an error with network or connection settings
ClearExitFlags(~SXF_RESTOREAUTODIAL);
if( !fErrMsgShown )
{
ErrorMsg(hwnd, IDS_BADSETTINGS);
fErrMsgShown = TRUE;
}
}
// If this is part of signup process, then signal the first instance
// to close
if (fSignup)
{
PostMessage(pDynShare->hwndMain, WM_CLOSE, 0, 0);
}
// Restore the desktop icons if we have the newer version of ICWCONN1.EXE,
// and we previsouly munged them.
if (ERROR_SUCCESS == RegOpenKey(HKEY_CURRENT_USER,ICWSETTINGSPATH,&hKey))
{
RegQueryValueEx(hKey,
ICWDESKTOPCHANGED,
0,
NULL,
(BYTE*)&dwDesktopChanged,
&dwSize);
RegCloseKey(hKey);
}
if (dwDesktopChanged)
{
DWORD dwVerMS, dwVerLS;
if( GetAppVersion( &dwVerMS, &dwVerLS, ICW20_PATHKEY ) )
{
// if( ( (dwVerMS >= ICW20_MINIMUM_VERSIONMS) && (dwVerLS >= ICW20_MINIMUM_VERSIONLS) ) )
if(dwVerMS >= ICW20_MINIMUM_VERSIONMS)
{
ShellExecute(NULL, cszOpen, g_szICWCONN1, g_szRestoreDesktop, NULL, SW_HIDE);
}
}
}
bRC = TRUE;
ProcessINSExit:
// 3/11/97 jmazner Olympus #1233, 252
// if no 3rd exe, and this instance is part of a signup process and
// SERVERLESS flag is not set for IEAK, then delete the .ins file
if ( (fSignup) &&
(('\0' == pDynShare->szRunExecutable[0]) || (ERROR_SUCCESS != dwRet)) )
{
if (1 != GetPrivateProfileInt(
cszBrandingSection,
cszBrandingServerless,
0,
lpszFile))
{
DeleteFileKindaLikeThisOne(lpszFile);
}
else
{
Dprintf("ISIGN32: Preserving .ins file for SERVERLESS flag\n");
}
}
return bRC;
}
static BOOL RequiresLogon(LPCTSTR lpszFile)
{
TCHAR szTemp[10];
GetPrivateProfileString(cszUserSection,
cszRequiresLogon,
cszNo,
szTemp,
10,
lpszFile);
return (!lstrcmpi(szTemp, cszYes));
}
static UINT GetBrandingFlags(LPCTSTR lpszFile)
{
return GetPrivateProfileInt(
cszBrandingSection,
cszBrandingFlags,
BRAND_DEFAULT,
lpszFile);
}
//+----------------------------------------------------------------------------
//
// Function: SetGlobalOffline
//
// Synopsis: Set IE4 into online or offline mode
//
// Arguments: fOffline - TRUE to set OFFLINE mode
// FALSE to set ONLINE mode
//
// Returns: none
//
// History: 7/15/97 ChrisK imported from DarrenMi's email
//
//-----------------------------------------------------------------------------
typedef struct {
DWORD dwConnectedState;
DWORD dwFlags;
} INTERNET_CONNECTED_INFO, * LPINTERNET_CONNECTED_INFO;
//
// the following can be indicated in a state change notification:
//
#define INTERNET_STATE_CONNECTED 0x00000001 // connected state (mutually exclusive with disconnected)
#define INTERNET_STATE_DISCONNECTED 0x00000002 // disconnected from network
#define INTERNET_STATE_DISCONNECTED_BY_USER 0x00000010 // disconnected by user request
#define INTERNET_STATE_IDLE 0x00000100 // no network requests being made (by Wininet)
#define INTERNET_STATE_BUSY 0x00000200 // network requests being made (by Wininet)
#define ISO_FORCE_DISCONNECTED 0x00000001
#define INTERNET_OPTION_CONNECTED_STATE 50
typedef BOOL (WINAPI *PFNSETINTERNETOPTIONA)(LPVOID, DWORD, LPVOID, DWORD);
void SetGlobalOffline(BOOL fOffline)
{
DebugOut("ISIGN32: SetGlobalOffline.\n");
INTERNET_CONNECTED_INFO ci;
HMODULE hMod = LoadLibrary(TEXT("wininet.dll"));
FARPROC fp = NULL;
BOOL bRC = FALSE;
ZeroMemory(&ci, sizeof(ci));
if (NULL == hMod)
{
Dprintf("ISIGN32: Wininet.dll did not load. Error:%d.\n",GetLastError());
goto InternetSetOptionExit;
}
#ifdef UNICODE
if (NULL == (fp = GetProcAddress(hMod,"InternetSetOptionW")))
#else
if (NULL == (fp = GetProcAddress(hMod,"InternetSetOptionA")))
#endif
{
Dprintf("ISIGN32: InternetSetOptionA did not load. Error:%d.\n",GetLastError());
goto InternetSetOptionExit;
}
if(fOffline) {
ci.dwConnectedState = INTERNET_STATE_DISCONNECTED_BY_USER;
ci.dwFlags = ISO_FORCE_DISCONNECTED;
} else {
ci.dwConnectedState = INTERNET_STATE_CONNECTED;
}
DebugOut("ISIGN32: Setting offline\\online.\n");
bRC = ((PFNSETINTERNETOPTIONA)fp) (NULL, INTERNET_OPTION_CONNECTED_STATE, &ci, sizeof(ci));
#ifdef DEBUG
if (bRC)
{
DebugOut("ISIGN32: GetGlobalOffline returned TRUE.\n");
}
else
{
DebugOut("ISIGN32: GetGlobalOffline returned FALSE.\n");
}
#endif
InternetSetOptionExit:
DebugOut("ISIGN32: Exit SetGlobalOffline.\n");
return;
}
BOOL ProcessISP(HWND hwnd, LPCTSTR lpszFile)
{
TCHAR szSignupURL[MAX_URL + 1];
#if !defined(WIN16)
HKEY hKey;
GATHEREDINFO gi;
#endif //!WIN16
//
// 4/30/97 jmazner Olympus 3969
// For security reasons, do not process the [Custom] Run= command in an .isp
// file!
//
#if DEBUG
if (GetPrivateProfileString(
cszEntrySection,
cszRun,
szNull,
pDynShare->szRunExecutable,
SIZEOF_TCHAR_BUFFER(pDynShare->szRunExecutable),
lpszFile) != 0)
{
//
// 4/30/97 jmazner Olympus 3969
// For security reasons, do not process the [Custom] Run= command in an .isp
// file!
//
lstrcpyn(pDynShare->szRunExecutable, TEXT("\0"), 1);
ClearExitFlags(SXF_RUNEXECUTABLE | SXF_WAITEXECUTABLE);
Dprintf("ISIGN32: The file %s has the [Custom] Run= command!", lpszFile);
MessageBox( hwnd,
TEXT("The .isp file you're running contains the [Custom] Run= command.\n\nThis functionality has been removed."),
TEXT("DEBUG information msgBox -- this is NOT a bug"),
MB_OK );
/*****
dwExitFlags |= (SXF_RUNEXECUTABLE | SXF_WAITEXECUTABLE);
GetPrivateProfileString(cszEntrySection,
cszArgument,
szNull,
szRunArgument,
sizeof(szRunArgument),
lpszFile);
PostMessage(hwnd, WM_CLOSE, 0, 0);
return FALSE;
******/
}
#endif
#if !defined(WIN16)
// Make sure the isp file exists before setting up stack.
if (0xFFFFFFFF == GetFileAttributes(lpszFile))
{
DWORD dwFileErr = GetLastError();
Dprintf("ISIGN32: ProcessISP couldn't GetAttrib for %s, error = %d",
lpszFile, dwFileErr);
if( ERROR_FILE_NOT_FOUND == dwFileErr )
{
ErrorMsg1(hwnd, IDS_INVALIDCMDLINE, lpszFile);
}
ErrorMsg(hwnd, IDS_BADSIGNUPFILE);
return FALSE;
}
#endif
// Register file extensions if not already registered
// Configure stack if not already configured.
// This may required a restart. If so warn the user.
// We may want to check to see if the user is calling
// us again without restarting after configuring the stack.
#ifdef SETUPSTACK
if (!TestControlFlags(SCF_SYSTEMCONFIGURED))
{
DWORD dwRet;
BOOL fNeedsRestart = FALSE;
//
// ChrisK Olympus 4756 5/25/97
// Do not display busy animation on Win95
//
dwRet = lpfnInetConfigSystem(
hwnd,
INETCFG_INSTALLRNA |
INETCFG_INSTALLTCP |
INETCFG_INSTALLMODEM |
(IsNT()?INETCFG_SHOWBUSYANIMATION:0) |
INETCFG_REMOVEIFSHARINGBOUND,
&fNeedsRestart);
if (ERROR_SUCCESS == dwRet)
{
SetControlFlags(SCF_SYSTEMCONFIGURED);
InstallScripter();
if (fNeedsRestart)
{
if (PromptRestartNow(hwnd))
{
SetRunOnce(lpszFile);
// 3/13/97 jmazner Olympus #1682
RestoreSecurityPatch();
FGetSystemShutdownPrivledge();
ExitWindowsEx(EWX_REBOOT, 0);
//
// We will wait for the System to release all
// resources, 5 minutes should be more than
// enough for this
// - MKarki (4/22/97) - MKarki
// Fix for Bug #3109
//
// 7/8/97 jmazner Olympus 4212
// No, sleeping for 5 minutes turns out not to be such a good idea.
//Sleep (300000);
//
}
return FALSE;
}
}
else
{
ErrorMsg(hwnd, IDS_INSTALLFAILED);
return FALSE;
}
}
if (!VerifyRasServicesRunning(hwnd))
return FALSE;
#endif
/******** 11/5/96 jmazner Normandy #8717
// if the original autodial settings have not been saved
SaveAutoDial();
dwExitFlags |= SXF_RESTOREAUTODIAL;
********/
// kill the old connection
KillConnection();
// Create a new connectoid and set the autodial
DWORD dwRC;
dwRC = CreateConnection(lpszFile);
if (ERROR_SUCCESS != dwRC)
{
//
// ChrisK Olympus 6083 6/10/97
// If the user canceled, we have already acknowledged it.
//
if (ERROR_CANCELLED != dwRC)
{
ErrorMsg(hwnd, IDS_BADSIGNUPFILE);
}
return FALSE;
}
#ifndef WIN16
//
// Dial connectoid
//
if (ERROR_USERNEXT != DialConnection(lpszFile))
{
SetControlFlags(SCF_BROWSERLAUNCHED);
KillBrowser();
return FALSE;
}
lstrcpyn(
pDynShare->szISPFile,
lpszFile,
SIZEOF_TCHAR_BUFFER(pDynShare->szISPFile));
//
// Tell IE that it is OK to make a connection to the Internet and do not
// display the dialog asking if the user wants to go online.
//
SetGlobalOffline(FALSE);
#endif
// Get the URL that we need for signup
GetURL(lpszFile,
cszSignupURL,
szSignupURL,
MAX_URL + 1);
#ifdef WIN32
if (RequiresLogon(lpszFile))
{
SetControlFlags(SCF_LOGONREQUIRED);
if (ERROR_CANCELLED == SignupLogon(hwnd))
{
InfoMsg(NULL, IDS_SIGNUPCANCELLED);
PostMessage(pDynShare->hwndMain, WM_CLOSE, 0, 0);
return FALSE;
}
}
// OSR 10582
// We need to pass the name of the ISP file to the autodialer, so that the
// autodialer can extract the password that may be included
ZeroMemory(&gi,sizeof(gi));
hKey = NULL;
lstrcpyn(gi.szISPFile,lpszFile,MAX_PATH);
if (ERROR_SUCCESS == RegCreateKey(HKEY_LOCAL_MACHINE,
ISIGNUP_KEY,&hKey))
{
RegSetValueEx(hKey,TEXT("UserInfo"),0,REG_BINARY,(LPBYTE)&gi,sizeof(gi));
RegCloseKey(hKey);
hKey = NULL;
}
#endif
pDynShare->dwBrandFlags = GetBrandingFlags(lpszFile);
return (ExecBrowser(hwnd, szSignupURL));
}
//+---------------------------------------------------------------------------
//
// Function: WaitForConnectionTermination
//
// Synopsis: Waits for the given Ras Connection to complete termination
//
// Arguments: hConn - Connection handle of the RAS connection being terminated
//
// Returns: TRUE if wait till connection termination was successful
// FALSE otherwise
//
// History: 6/30/96 VetriV Created
// 8/29/96 VetriV Added code to sleep for a second on WIN 3.1
//----------------------------------------------------------------------------
// Normandy #12547 Chrisk 12-18-96
#define MAX_TIME_FOR_TERMINATION 5
BOOL WaitForConnectionTermination(HRASCONN hConn)
{
RASCONNSTATUS RasConnStatus;
DWORD dwRetCode;
// Normandy #12547 Chrisk 12-18-96
#if !defined(WIN16)
INT cnt = 0;
#endif
//
// Get Connection status for hConn in a loop until
// RasGetConnectStatus returns ERROR_INVALID_HANDLE
//
do
{
//
// Intialize RASCONNSTATUS struct
// GetConnectStatus API will fail if dwSize is not set correctly!!
//
ZeroMemory(&RasConnStatus, sizeof(RASCONNSTATUS));
RasConnStatus.dwSize = sizeof(RASCONNSTATUS);
//
// Sleep for a second and then get the connection status
//
#if defined(WIN16)
time_t StartTime = time(NULL);
do
{
MSG msg;
if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
//
// Check if we have waited atleast 1 second and less than 2 seconds
//
}
while ((time(NULL) - StartTime) <= 1);
#else
Sleep(1000L);
// Normandy #12547 Chrisk 12-18-96
cnt++;
#endif
if (NULL == lpfnRasGetConnectStatus)
return FALSE;
dwRetCode = lpfnRasGetConnectStatus(hConn, &RasConnStatus);
if (0 != dwRetCode)
return FALSE;
#if defined(WIN16)
} while (RASCS_Disconnected != RasConnStatus.rasconnstate);
#else
// Normandy #12547 Chrisk 12-18-96
} while ((ERROR_INVALID_HANDLE != RasConnStatus.dwError) && (cnt < MAX_TIME_FOR_TERMINATION));
#endif
return TRUE;
}
BOOL ProcessHTML(HWND hwnd, LPCTSTR lpszFile)
{
BOOL fNeedsRestart = FALSE;
#if SETUPSTACK
DWORD dwRet;
if (!TestControlFlags(SCF_SYSTEMCONFIGURED))
{
//
// ChrisK Olympus 4756 5/25/97
// Do not display busy animation on Win95
//
dwRet = lpfnInetConfigSystem(
hwnd,
INETCFG_INSTALLRNA |
INETCFG_INSTALLTCP |
INETCFG_INSTALLMODEM |
(IsNT()?INETCFG_SHOWBUSYANIMATION:0) |
INETCFG_REMOVEIFSHARINGBOUND,
&fNeedsRestart);
if (ERROR_SUCCESS == dwRet)
{
SetControlFlags(SCF_SYSTEMCONFIGURED);
InstallScripter();
if (fNeedsRestart)
{
if (PromptRestart(hwnd))
{
SetRunOnce(lpszFile);
// 3/13/97 jmazner Olympus #1682
RestoreSecurityPatch();
FGetSystemShutdownPrivledge();
ExitWindowsEx(EWX_REBOOT, 0);
//
// We will wait for the System to release all
// resources, 5 minutes should be more than
// enough for this
// - MKarki (4/22/97) - MKarki
// Fix for Bug #3109
//
// 7/8/97 jmazner Olympus 4212
// No, sleeping for 5 minutes turns out not to be such a good idea.
//Sleep (300000);
//
}
return FALSE;
}
}
else
{
ErrorMsg(hwnd, IDS_INSTALLFAILED);
return FALSE;
}
}
if (!VerifyRasServicesRunning(hwnd))
return FALSE;
#endif
return (ExecBrowser(hwnd, lpszFile));
}
#ifdef WIN32
DWORD RunExecutable(BOOL fWait)
{
DWORD dwRet;
SHELLEXECUTEINFO sei;
sei.cbSize = sizeof(sei);
sei.fMask = SEE_MASK_NOCLOSEPROCESS;
sei.hwnd = NULL;
sei.lpVerb = cszOpen;
sei.lpFile = pDynShare->szRunExecutable;
sei.lpParameters = pDynShare->szRunArgument;
sei.lpDirectory = NULL;
sei.nShow = SW_SHOWNORMAL;
sei.hInstApp = NULL;
// Optional members
sei.hProcess = NULL;
if (ShellExecuteEx(&sei))
{
if (fWait)
{
// WaitForSingleObject(sei.hProcess, INFINITE);
DWORD iWaitResult = 0;
// wait for event or msgs. Dispatch msgs. Exit when event is signalled.
while((iWaitResult=MsgWaitForMultipleObjects(1, &sei.hProcess, FALSE, INFINITE, QS_ALLINPUT))==(WAIT_OBJECT_0 + 1))
{
MSG msg ;
// read all of the messages in this next loop
// removing each message as we read it
while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
{
// how to handle quit message?
if (msg.message == WM_QUIT)
{
CloseHandle(sei.hProcess);
return NO_ERROR;
}
else
DispatchMessage(&msg);
}
}
}
CloseHandle(sei.hProcess);
dwRet = ERROR_SUCCESS;
}
else
{
dwRet = GetLastError();
}
return dwRet;
}
#else
DWORD RunExecutable(BOOL fWait)
{
DWORD dwRet;
dwRet = (DWORD)ShellExecute(
NULL,
cszOpen,
pDynShare->szRunExecutable,
pDynShare->szRunArgument,
NULL,
SW_SHOWNORMAL);
if (32 < dwRet)
{
dwRet = ERROR_SUCCESS;
}
else if (0 == dwRet)
{
dwRet = ERROR_OUTOFMEMORY;
}
return dwRet;
}
#endif
void SaveAutoDial(void)
{
// if the original autodial settings have not been saved
if (!TestControlFlags(SCF_AUTODIALSAVED))
{
// save the current autodial settings
BOOL fEnabled;
lpfnInetGetAutodial(
&fEnabled,
pDynShare->szAutodialConnection,
sizeof(pDynShare->szAutodialConnection));
if (fEnabled)
{
SetControlFlags(SCF_AUTODIALENABLED);
}
else
{
ClearControlFlags(SCF_AUTODIALENABLED);
}
#ifdef WIN32
lpfnInetGetProxy(
&fEnabled,
NULL, 0,
NULL, 0);
if (fEnabled)
{
SetControlFlags(SCF_PROXYENABLED);
}
else
{
ClearControlFlags(SCF_PROXYENABLED);
}
// turn off proxy
lpfnInetSetProxy(FALSE, NULL, NULL);
#endif
SetControlFlags(SCF_AUTODIALSAVED);
}
}
void RestoreAutoDial(void)
{
if (TestControlFlags(SCF_AUTODIALSAVED))
{
// restore original autodial settings
lpfnInetSetAutodial(
TestControlFlags(SCF_AUTODIALENABLED),
pDynShare->szAutodialConnection);
#ifdef WIN32
lpfnInetSetProxy(TestControlFlags(SCF_PROXYENABLED), NULL, NULL);
#endif
ClearControlFlags(SCF_AUTODIALSAVED);
}
}
DWORD CreateConnection(LPCTSTR lpszFile)
{
DWORD dwRet;
LPICONNECTION pConn;
// Allocate a buffer for connection object
//
pConn = (LPICONNECTION)LocalAlloc(LPTR, sizeof(ICONNECTION));
if (NULL == pConn)
{
return ERROR_OUTOFMEMORY;
};
dwRet = ImportConnection(lpszFile, pConn);
if (ERROR_SUCCESS == dwRet)
{
#ifdef WIN32
if ((0 == *pConn->RasEntry.szAutodialDll) ||
(0 == *pConn->RasEntry.szAutodialFunc))
{
lstrcpy(pConn->RasEntry.szAutodialDll, TEXT("ICWDIAL.dll"));
lstrcpy(pConn->RasEntry.szAutodialFunc, TEXT("AutoDialHandler"));
// save the password in case it doesn't get cached
lstrcpyn(
pDynShare->szPassword,
pConn->szPassword,
SIZEOF_TCHAR_BUFFER(pDynShare->szPassword));
}
#endif
dwRet = lpfnInetConfigClient(
NULL,
NULL,
pConn->szEntryName,
&pConn->RasEntry,
pConn->szUserName,
pConn->szPassword,
NULL,
NULL,
INETCFG_SETASAUTODIAL |
INETCFG_OVERWRITEENTRY |
INETCFG_TEMPPHONEBOOKENTRY,
NULL);
#if !defined(WIN16)
LclSetEntryScriptPatch(pConn->RasEntry.szScript,pConn->szEntryName);
#endif
if (ERROR_SUCCESS == dwRet)
{
lstrcpyn(
pDynShare->szSignupConnection,
pConn->szEntryName,
RAS_MaxEntryName + 1);
}
}
LocalFree(pConn);
return dwRet;
}
DWORD DeleteConnection(void)
{
if (*(pDynShare->szSignupConnection))
{
// delete the signup entry
lpfnRasDeleteEntry(NULL, pDynShare->szSignupConnection);
pDynShare->szSignupConnection[0] = (TCHAR)'\0';
}
return ERROR_SUCCESS;
}
//+----------------------------------------------------------------------------
// Function: KillThisConnection
//
// Synopsis: Disconnects the connectoid named in lpzConnectoid and waits
// until the connection is completely torn down. Then the
// connectoid is deleted.
//
// Arguments: lpzConnectoid - name of connection to disconnect
//
// Returns: (return) - win32 error code
//
// History: 4/27/97 Chrisk Created
//-----------------------------------------------------------------------------
DWORD KillThisConnection(LPTSTR lpzConnectoid)
{
LPRASCONN pRasConn=NULL;
DWORD dwSize = sizeof(RASCONN);
DWORD dwSizeRasConn = dwSize;
DWORD dwRet = ERROR_SUCCESS;
if ('\0' == *lpzConnectoid)
return ERROR_NO_CONNECTION;
// OK were ready for Rna now
if (!LoadRnaFunctions(pDynShare->hwndMain))
return ERROR_NO_CONNECTION;
if ((pRasConn = (LPRASCONN)LocalAlloc(LPTR, (int)dwSize)) == NULL)
return ERROR_NOT_ENOUGH_MEMORY;
pRasConn->dwSize = dwSize;
dwRet = lpfnRasEnumConnections(pRasConn, &dwSize, &dwSizeRasConn);
if (ERROR_SUCCESS != dwRet)
{
dwRet = ERROR_NO_CONNECTION;
goto KillThisConnectionExit;
}
// check entry name to see if
// its ours
#ifndef WIN32
//
// Workaround for WIN16 RAS Bug - it sometimes truncates
// the name of the connectoid
//
if (!strncmp(pRasConn->szEntryName, lpzConnectoid,
lstrlen(pRasConn->szEntryName)))
#else
if (!lstrcmp(pRasConn->szEntryName, lpzConnectoid))
#endif
{
// Normandy 12642 ChrisK 12-18-9
// We don't want the user to reconnect here.
#if !defined(WIN16)
SetControlFlags(SCF_HANGUPEXPECTED);
#endif
// then hangup
lpfnRasHangUp(pRasConn->hrasconn);
WaitForConnectionTermination(pRasConn->hrasconn);
}
// delete the signup entry
lpfnRasDeleteEntry(NULL, lpzConnectoid);
KillThisConnectionExit:
if (pRasConn)
LocalFree(pRasConn);
return dwRet;
}
//+----------------------------------------------------------------------------
// Function: KillConnection
//
// Synopsis: Calls KillThisConnection and passes in the name of the signup
// connection that is saved in szSignupConnection
//
// Arguments: none
//
// Returns: (return) - win32 error code
//
// History: 4/27/97 Chrisk modified to call KillThisConnection
//-----------------------------------------------------------------------------
DWORD KillConnection(void)
{
DWORD dwRet;
dwRet = KillThisConnection(pDynShare->szSignupConnection);
#if defined(WIN16)
ShutDownIEDial(pDynShare->hwndMain);
#endif // WIN16
pDynShare->szSignupConnection[0] = (TCHAR)'\0';
UnloadRnaFunctions();
return dwRet;
}
BOOL ExecBrowser(HWND hwnd, LPCTSTR lpszURL)
{
HRESULT hresult;
TCHAR szFullURL[MAX_URL + 1];
if (!FixUpURL(lpszURL, szFullURL, MAX_URL + 1))
{
//
// ChrisK Olympus 4002 5/26/97
// If the URL is empty, this error message doesn't make
// a lot of sense. So use a different message.
//
if (lstrlen(lpszURL))
{
ErrorMsg1(hwnd, IDS_INVALIDURL, lpszURL);
}
else
{
ErrorMsg(hwnd, IDS_INVALIDNOURL);
}
return FALSE;
}
if (TestControlFlags(SCF_BROWSERLAUNCHED))
{
#ifdef WIN32
// No assert macro defined for isign32????
//Assert(g_iwbapp);
if( !g_iwbapp )
{
DebugOut("ISIGNUP: fatal err, fBrowserLaunched disagrees with g_iwbapp\n");
return( FALSE );
}
// TODO find out what the result codes should be!
hresult = IENavigate( szFullURL );
if( FAILED(hresult) )
{
DebugOut("ISIGNUP: second Navigate _failed_, hresult was failure\n");
return FALSE;
}
else
{
DebugOut("ISIGNUP: second Navigate success!, hresult was success\n");
}
//g_iwbapp->put_Visible( TRUE );
#else
DDEInit(ghInstance);
OpenURL(szFullURL);
DDEClose();
#endif
}
else
{
TCHAR szTemp[MAX_URL + sizeof(cszKioskMode)/sizeof(TCHAR)];
HWND hwndTemp;
HANDLE hBrowser;
#ifndef WIN32
time_t start;
#endif
if (NULL != pDynShare->hwndLaunch)
{
ShowWindow(pDynShare->hwndLaunch, SW_SHOW);
UpdateWindow(pDynShare->hwndLaunch);
}
// for OLE Autmoation we only want to pass in the URL (no "-k") and then call FullScreen,
// so only -k for win16
#ifndef WIN32
lstrcpy(szTemp, cszKioskMode);
lstrcat(szTemp, szFullURL);
// no point in doing this for IE4, which may have lots of windows already open
hwndTemp = FindBrowser();
if (NULL != hwndTemp)
{
PostMessage(hwndTemp, WM_CLOSE, 0, 0L);
}
#endif
#ifdef WIN32
// 8/19/96 jmazner Normandy #4571
// Check to ensure that the right version IE is installed before trying to exec it
/******** Normandy #10293, do this verification before going through the whole
dialing process
if ( !IEInstalled() )
{
ErrorMsg( hwnd, IDS_MISSINGIE );
return(FALSE);
}
DWORD dwVerMS, dwVerLS;
if( !GetAppVersion( &dwVerMS, &dwVerLS,IE_PATHKEY ) )
return (FALSE);
if( !( (dwVerMS >= IE_MINIMUM_VERSIONMS) && (dwVerLS >= IE_MINIMUM_VERSIONLS) ) )
{
Dprintf("ISIGN32: user has IE version %d.%d.%d.%d; min ver is %d.%d.%d.%d\n",
HIWORD(dwVerMS), LOWORD(dwVerMS), HIWORD(dwVerLS), LOWORD(dwVerLS),
HIWORD(IE_MINIMUM_VERSIONMS),LOWORD(IE_MINIMUM_VERSIONMS),
HIWORD(IE_MINIMUM_VERSIONLS),LOWORD(IE_MINIMUM_VERSIONLS));
ErrorMsg1( hwnd, IDS_IELOWVERSION, IE_MINIMUM_VERSION_HUMAN_READABLE );
return(FALSE);
}
***********/
if (FTurnOffBrowserDefaultChecking())
{
SetExitFlags(SXF_RESTOREDEFCHECK);
}
/*
hBrowser = ShellExecute(
NULL,
cszOpen,
cszBrowser,
szTemp,
NULL,
SW_SHOWNORMAL);
*/
// 1/20/97 jmazner Normandy #13454
// need make sure the ICW completed reg key is set before trying
// to browse to an html page with IE
DWORD dwICWCompleted = 0;
GetICWCompleted(&dwICWCompleted);
if( 1 != dwICWCompleted )
{
SetControlFlags(SCF_ICWCOMPLETEDKEYRESETED);
SetICWCompleted( 1 );
}
hresult = InitOle();
if( FAILED(hresult) )
{
DebugOut("ISIGNUP: InitOle failed\n");
ErrorMsg(hwnd, IDS_LAUNCHFAILED);
return FALSE;
}
SetControlFlags(SCF_BROWSERLAUNCHED);
//
// we want to hook up the event sink before doing that first navigate!
//
/******************* SINK code starts here ***********/
if (!g_iwbapp)
return (NULL);
g_pMySink = new CDExplorerEvents;
//
// 5/10/97 ChrisK Windows NT Bug 82032
//
g_pMySink->AddRef();
if ( !g_pMySink )
{
DebugOut("Unable to allocate g_pMySink\r\n");
return FALSE;
}
g_pCP = GetConnectionPoint();
if ( !g_pCP )
{
DebugOut("Unable to GetConnectionPoint\r\n");
return FALSE;
}
hresult = g_pCP->Advise(g_pMySink, &(g_pMySink->m_dwCookie));
if ( FAILED(hresult) )
{
DebugOut("Unable to Advise for IConnectionPointContainter:IWebBrowserApp\r\n");
return FALSE;
}
/*************** SINK code ends here *****************/
// TODO figure out result codes
hresult = IENavigate( szFullURL );
if( FAILED(hresult) )
{
DebugOut("ISIGNUP: first Navigate _failed_, hresult was failure\n");
ErrorMsg(hwnd, IDS_LAUNCHFAILED);
return FALSE;
}
else
{
DebugOut("ISIGNUP: first Navigate success!, hresult was success\n");
}
g_iwbapp->put_FullScreen( TRUE );
g_iwbapp->put_Visible( TRUE );
// IE 4 for win95 isn't bringing us up as the foreground window!
g_iwbapp->get_HWND( (LONG_PTR *)&(pDynShare->hwndBrowser) );
SetForegroundWindow( pDynShare->hwndBrowser );
#else
start = time(NULL);
if (NULL != hwndTemp)
{
MSG msg;
SetTimer(hwnd, 0, 1000, NULL);
DebugOut("ISIGNUP: Timer message loop\n");
while (GetMessage (&msg, NULL, 0, 0))
{
if (WM_TIMER == msg.message)
{
DebugOut("ISIGNUP: Got timer message\n");
if (NULL == FindBrowser())
{
DebugOut("ISIGNUP: Browser is gone\n");
break;
}
}
TranslateMessage (&msg) ;
DispatchMessage (&msg) ;
}
KillTimer(hwnd, 0);
}
while (((hBrowser = ShellExecute(
NULL,
cszOpen,
cszBrowser,
szTemp,
NULL,
SW_SHOWNORMAL)) == 16) && ((time(NULL) - start) < 180))
{
DebugOut("ISIGNUP: Yielding\n");
Yield();
}
#endif
DebugOut("ISIGNUP: I am back!!\n");
if (NULL != pDynShare->hwndLaunch)
{
ShowWindow(pDynShare->hwndLaunch, SW_HIDE);
}
#ifdef WIN16
if (hBrowser <= (HANDLE)32)
{
ErrorMsg(hwnd, IDS_LAUNCHFAILED);
return FALSE;
}
#endif
SetControlFlags(SCF_BROWSERLAUNCHED);
}
return TRUE;
}
//+----------------------------------------------------------------------------
//
// 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)
//
//-----------------------------------------------------------------------------
#if !defined(WIN16)
BOOL IEInstalled(void)
{
HRESULT hr;
HKEY hKey = 0;
HANDLE hFindResult;
TCHAR szIELocalPath[MAX_PATH + 1] = TEXT("");
DWORD dwPathSize;
WIN32_FIND_DATA foundData;
hr = RegOpenKeyEx(HKEY_LOCAL_MACHINE, IE_PATHKEY,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 );
hFindResult = FindFirstFile( szIELocalPath, &foundData );
FindClose( hFindResult );
if (INVALID_HANDLE_VALUE == hFindResult) return( FALSE );
return(TRUE);
}
//+----------------------------------------------------------------------------
//
// Function: GetAppVersion
//
// Synopsis: Gets the major and minor version # of the installed copy of Internet Explorer
//
// Arguments: pdwVerNumMS - pointer to a DWORD;
// On succesful return, the top 16 bits will contain the major version number,
// and the lower 16 bits will contain the minor version number
// (this is the data in VS_FIXEDFILEINFO.dwProductVersionMS)
// pdwVerNumLS - pointer to a DWORD;
// On succesful return, the top 16 bits will contain the release number,
// and the lower 16 bits will contain the build number
// (this is the data in VS_FIXEDFILEINFO.dwProductVersionLS)
//
// Returns: TRUE - Success. *pdwVerNumMS and LS contains installed IE version number
// FALSE - Failure. *pdVerNumMS == *pdVerNumLS == 0
//
// History: jmazner Created 8/19/96 (as fix for Normandy #4571)
// jmazner updated to deal with release.build as well 10/11/96
//
//-----------------------------------------------------------------------------
BOOL GetAppVersion(PDWORD pdwVerNumMS, PDWORD pdwVerNumLS, LPTSTR lpszApp)
{
HRESULT hr;
HKEY hKey = 0;
LPVOID lpVerInfoBlock;
VS_FIXEDFILEINFO *lpTheVerInfo;
UINT uTheVerInfoSize;
DWORD dwVerInfoBlockSize, dwUnused, dwPathSize;
TCHAR szIELocalPath[MAX_PATH + 1] = TEXT("");
*pdwVerNumMS = 0;
*pdwVerNumLS = 0;
// get path to the IE executable
hr = RegOpenKeyEx(HKEY_LOCAL_MACHINE, lpszApp,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 );
// now go through the convoluted process of digging up the version info
dwVerInfoBlockSize = GetFileVersionInfoSize( szIELocalPath, &dwUnused );
if ( 0 == dwVerInfoBlockSize ) return( FALSE );
lpVerInfoBlock = GlobalAlloc( GPTR, dwVerInfoBlockSize );
if( NULL == lpVerInfoBlock ) return( FALSE );
if( !GetFileVersionInfo( szIELocalPath, NULL, dwVerInfoBlockSize, lpVerInfoBlock ) )
return( FALSE );
if( !VerQueryValue(lpVerInfoBlock, TEXT("\\"), (void **)&lpTheVerInfo, &uTheVerInfoSize) )
return( FALSE );
*pdwVerNumMS = lpTheVerInfo->dwProductVersionMS;
*pdwVerNumLS = lpTheVerInfo->dwProductVersionLS;
GlobalFree( lpVerInfoBlock );
return( TRUE );
}
#endif // !defined(WIN16)
HWND FindBrowser(void)
{
HWND hwnd;
if ((hwnd = FindWindow(szBrowserClass1, NULL)) == NULL)
{
if ((hwnd = FindWindow(szBrowserClass2, NULL)) == NULL)
{
if( (hwnd = FindWindow(szBrowserClass3, NULL)) == NULL )
{
hwnd = FindWindow(szBrowserClassIE4, NULL);
}
}
}
return hwnd;
}
void KillBrowser(void)
{
#ifdef WIN32
if( TestControlFlags(SCF_ICWCOMPLETEDKEYRESETED) )
{
SetICWCompleted( 0 );
}
if( g_iwbapp )
{
g_iwbapp->Quit();
}
KillOle();
return;
#else
// if we launched the browser
if (TestControlFlags(SCF_BROWSERLAUNCHED))
{
HWND hwndBrowser;
// find it and close it
hwndBrowser = FindBrowser();
if (NULL != hwndBrowser)
{
PostMessage(hwndBrowser, WM_CLOSE, 0, 0L);
}
SetControlFlags(SCF_BROWSERLAUNCHED);
}
#endif
}
DWORD ImportBrandingInfo(LPCTSTR lpszFile, LPCTSTR lpszConnectoidName)
{
TCHAR szPath[_MAX_PATH + 1];
GetWindowsDirectory(szPath, _MAX_PATH + 1);
// Load the branding library.
// Note: if we cannot load the library we just fail quietly and assume
// we cannot brand
if (LoadBrandingFunctions())
{
#ifdef WIN32
#ifdef UNICODE
CHAR szEntry[RAS_MaxEntryName];
CHAR szFile[_MAX_PATH + 1];
CHAR szAsiPath[_MAX_PATH + 1];
wcstombs(szEntry, lpszConnectoidName, RAS_MaxEntryName);
wcstombs(szFile, lpszFile, _MAX_PATH + 1);
wcstombs(szAsiPath, szPath, _MAX_PATH + 1);
lpfnBrandICW(szFile, szAsiPath, pDynShare->dwBrandFlags, szEntry);
#else
lpfnBrandICW(lpszFile, szPath, pDynShare->dwBrandFlags, lpszConnectoidName);
#endif
#else
lpfnBrandMe(lpszFile, szPath);
#endif
UnloadBrandingFunctions();
}
return ERROR_SUCCESS;
}
//+----------------------------------------------------------------------------
//
// Function: CallSBSConfig
//
// Synopsis: Call into the SBSCFG dll's Configure function to allow SBS to
// process the .ins file as needed
//
// Arguements: hwnd -- hwnd of parent, in case sbs wants to put up messages
// lpszINSFile -- full path to the .ins file
//
// Returns: windows error code that sbscfg returns.
//
// History: 2/19/97 jmazner Created for Olympus #1106
//
//-----------------------------------------------------------------------------
#if defined(WIN32)
DWORD CallSBSConfig(HWND hwnd, LPCTSTR lpszINSFile)
{
HINSTANCE hSBSDLL = NULL;
DWORD dwRet = ERROR_SUCCESS;
TCHAR lpszConnectoidName[RAS_MaxEntryName] = TEXT("nogood\0");
//
// Get name of connectoid we created by looking in autodial
// We need to pass this name into SBSCFG
// 5/14/97 jmazner Windosw NT Bugs #87209
//
BOOL fEnabled = FALSE;
if( NULL == lpfnInetGetAutodial )
{
Dprintf("lpfnInetGetAutodial is NULL!!!!");
return ERROR_INVALID_FUNCTION;
}
dwRet = lpfnInetGetAutodial(&fEnabled,lpszConnectoidName,RAS_MaxEntryName);
Dprintf("ISIGN32: Calling LoadLibrary on %s\n", cszSBSCFG_DLL);
hSBSDLL = LoadLibrary(cszSBSCFG_DLL);
// Load DLL and entry point
if (NULL != hSBSDLL)
{
Dprintf("ISIGN32: Calling GetProcAddress on %s\n", cszSBSCFG_CONFIGURE);
lpfnConfigure = (SBSCONFIGURE)GetProcAddress(hSBSDLL,cszSBSCFG_CONFIGURE);
}
else
{
// 4/2/97 ChrisK Olympus 2759
// If the DLL can't be loaded, pick a specific error message to return.
dwRet = ERROR_DLL_NOT_FOUND;
goto CallSBSConfigExit;
}
// Call function
if( hSBSDLL && lpfnConfigure )
{
Dprintf("ISIGN32: Calling the Configure entry point: %s, %s\n", lpszINSFile, lpszConnectoidName);
dwRet = lpfnConfigure(hwnd, (TCHAR *)lpszINSFile, lpszConnectoidName);
}
else
{
Dprintf("ISIGN32: Unable to call the Configure entry point\n");
dwRet = GetLastError();
}
CallSBSConfigExit:
if( hSBSDLL )
FreeLibrary(hSBSDLL);
if( lpfnConfigure )
lpfnConfigure = NULL;
Dprintf("ISIGN32: CallSBSConfig exiting with error code %d \n", dwRet);
return dwRet;
}
#endif
#if defined(WIN16)
#define FILE_BUFFER_SIZE 8092
#else
#define FILE_BUFFER_SIZE 65534
#endif
#ifndef FILE_BEGIN
#define FILE_BEGIN 0
#endif
DWORD MassageFile(LPCTSTR lpszFile)
{
LPBYTE lpBufferIn;
LPBYTE lpBufferOut;
HFILE hfile;
DWORD dwRet = ERROR_SUCCESS;
#ifdef WIN32
if (!SetFileAttributes(lpszFile, FILE_ATTRIBUTE_NORMAL))
{
return GetLastError();
}
#endif
lpBufferIn = (LPBYTE) LocalAlloc(LPTR, 2 * FILE_BUFFER_SIZE);
if (NULL == lpBufferIn)
{
return ERROR_OUTOFMEMORY;
}
lpBufferOut = lpBufferIn + FILE_BUFFER_SIZE;
#ifdef UNICODE
CHAR szTmp[MAX_PATH+1];
wcstombs(szTmp, lpszFile, MAX_PATH+1);
hfile = _lopen(szTmp, OF_READWRITE);
#else
hfile = _lopen(lpszFile, OF_READWRITE);
#endif
if (HFILE_ERROR != hfile)
{
BOOL fChanged = FALSE;
UINT uBytesOut = 0;
UINT uBytesIn = _lread(hfile, lpBufferIn, (UINT)(FILE_BUFFER_SIZE - 1));
// Note: we asume, in our use of lpCharIn, that the file is always less than
// FILE_BUFFER_SIZE
if (HFILE_ERROR != uBytesIn)
{
LPBYTE lpCharIn = lpBufferIn;
LPBYTE lpCharOut = lpBufferOut;
while ((*lpCharIn) && (FILE_BUFFER_SIZE - 2 > uBytesOut))
{
*lpCharOut++ = *lpCharIn;
uBytesOut++;
if ((0x0d == *lpCharIn) && (0x0a != *(lpCharIn + 1)))
{
fChanged = TRUE;
*lpCharOut++ = 0x0a;
uBytesOut++;
}
lpCharIn++;
}
if (fChanged)
{
if (HFILE_ERROR != _llseek(hfile, 0, FILE_BEGIN))
{
if (HFILE_ERROR ==_lwrite(hfile, (LPCSTR)lpBufferOut, uBytesOut))
{
#ifdef WIN32
dwRet = GetLastError();
#else
dwRet = ERROR_CANTWRITE;
#endif
}
}
else
{
#ifdef WIN32
dwRet = GetLastError();
#else
dwRet = ERROR_CANTWRITE;
#endif
}
}
}
else
{
#ifdef WIN32
dwRet = GetLastError();
#else
dwRet = ERROR_CANTREAD;
#endif
}
_lclose(hfile);
}
else
{
#ifdef WIN32
dwRet = GetLastError();
#else
dwRet = ERROR_CANTOPEN;
#endif
}
LocalFree(lpBufferIn);
return dwRet;
}
#ifndef WIN32
// This function only handle formats like
// drive:\file, drive:\dir1\file, drive:\dir1\dir2\file, etc
// file, dir1\file, dir1\dir2\file, etc.
// It does not currently handle
// drive:file, drive:dir\file, etc.
// \file, \dir\file, etc.
// ..\file, ..\dir\file, etc.
DWORD MakeFullPathName(
LPCTSTR lpDir,
LPCTSTR lpFileName,
DWORD nBufferLength,
LPTSTR lpBuffer)
{
DWORD dwSize;
// check for unsupported format
if ('.' == *lpFileName)
{
return 0;
}
// check for full path name
// assuming full path if ":" is in path
if (strchr(lpFileName, ':') != NULL)
{
dwSize = lstrlen(lpFileName);
if (dwSize > nBufferLength)
{
return dwSize;
}
lstrcpy(lpBuffer, lpFileName);
}
else
{
lstrcpy(lpBuffer, lpDir);
// make sure the directory ends in back slash
if (lpBuffer[lstrlen(lpBuffer) - 1] != '\\')
{
lstrcat(lpBuffer, TEXT("\\"));
}
dwSize = lstrlen(lpBuffer) + lstrlen(lpFileName);
if (dwSize > nBufferLength)
{
return dwSize;
}
lstrcat(lpBuffer, lpFileName);
}
return dwSize;
}
// This function only handle formats like
// drive:\file, drive:\dir1\file, drive:\dir1\dir2\file, etc
// file, dir1\file, dir1\dir2\file, etc.
// It does not currently handle
// drive:file, drive:dir\file, etc.
// \file, \dir\file, etc.
// ..\file, ..\dir\file, etc.
DWORD GetFullPathName(
LPCTSTR lpFileName,
DWORD nBufferLength,
LPTSTR lpBuffer,
LPTSTR FAR *lpFilePart)
{
DWORD dwSize;
TCHAR szDir[_MAX_PATH + 1];
if (_getcwd(szDir, _MAX_PATH + 1) == NULL)
{
return 0;
}
dwSize = MakeFullPathName(
szDir,
lpFileName,
nBufferLength,
lpBuffer);
if ((0 != dwSize) && (NULL != lpFilePart))
{
// find last back slash
*lpFilePart = strrchr(lpBuffer, '\\');
if (NULL == *lpFilePart)
{
// must have been in the unsupported format of drive:file
return 0;
}
// point to the filename
*lpFilePart += 1;
}
return dwSize;
}
BOOL SetCurrentDirectory(
LPCTSTR lpPathName)
{
TCHAR szTemp[_MAX_PATH];
TCHAR FAR* lpChar;
lstrcpy(szTemp, lpPathName);
lpChar = szTemp + lstrlen(szTemp) - 1;
if (*lpChar == '\\' && *(lpChar - 1) != ':')
{
*lpChar = '\0';
}
return (0 == _chdir(szTemp));
}
#endif
#ifdef WIN16
extern "C" BOOL CALLBACK __export LaunchDlgProc(
#else
INT_PTR CALLBACK LaunchDlgProc(
#endif
HWND hDlg,
UINT uMsg,
WPARAM wParam,
LPARAM lParam);
HWND LaunchInit(HWND hwndParent)
{
HWND hwnd;
hwnd = CreateDialog (ghInstance, TEXT("Launch"), NULL, LaunchDlgProc);
if (NULL != hwnd)
{
CenterWindow(hwnd, NULL);
}
return hwnd;
}
#ifdef WIN16
extern "C" BOOL CALLBACK __export LaunchDlgProc(
#else
INT_PTR CALLBACK LaunchDlgProc(
#endif
HWND hDlg,
UINT uMsg,
WPARAM wParam,
LPARAM lParam
)
{
return FALSE;
}
//+----------------------------------------------------------------------------
// Function: ReleaseConnectionStructures
//
// Synopsis: Free memory allocated for dialing and error dialogs
//
// Arguments: pDDD - pointer to dialing dialog data
// pEDD - pointer to error dialog data
//
// Returns: HRESULT - ERROR_SUCCESS indicates success
//
// History:
// 7/23/96 ChrisK Created
//
//-----------------------------------------------------------------------------
HRESULT ReleaseConnectionStructures(LPDIALDLGDATA pDDD, LPERRORDLGDATA pEDD)
{
DebugOut("ISIGN32:ReleaseConnectionStructures()\r\n");
if (pDDD->pszMessage)
LocalFree(pDDD->pszMessage);
if (pDDD->pszDunFile)
LocalFree(pDDD->pszDunFile);
if (pDDD->pszRasEntryName)
LocalFree(pDDD->pszRasEntryName);
if (pEDD->pszRasEntryName)
LocalFree(pEDD->pszRasEntryName);
if (pEDD->pszMessage)
LocalFree(pEDD->pszMessage);
ZeroMemory(pDDD,sizeof(DIALDLGDATA));
ZeroMemory(pEDD,sizeof(ERRORDLGDATA));
return ERROR_SUCCESS;
}
//+----------------------------------------------------------------------------
// Function: FillConnectionStructures
//
// Synopsis: Fills in structures for dialing and error dialogs
//
// Arguments: lpszFile - ISP file name
// pDDD - pointer to dialing dialog data
// pEDD - pointer to error dialog data
//
// Returns: HRESULT - ERROR_SUCCESS indicates success
//
// History:
// 7/23/96 ChrisK Created
//
//-----------------------------------------------------------------------------
static HRESULT FillConnectionStructures(LPCTSTR lpszFile,LPDIALDLGDATA pDDD, LPERRORDLGDATA pEDD)
{
HRESULT hr = ERROR_SUCCESS;
DebugOut("ISIGN32:FillConnectionStructures()\r\n");
//
// Initialize DDD structure
//
ZeroMemory(pDDD,sizeof(DIALDLGDATA));
pDDD->dwSize = sizeof(DIALDLGDATA);
pDDD->hInst = ghInstance;
pDDD->pfnStatusCallback = StatusMessageCallback;
//
// Set DUN file, in this case the ISP file contains the contents of a DUN file
//
pDDD->pszDunFile = (LPTSTR)LocalAlloc(LPTR,(lstrlen(lpszFile)+1)* sizeof(TCHAR));
if (0 == pDDD->pszDunFile)
{
hr = ERROR_NOT_ENOUGH_MEMORY;
goto FillConnectionStructuresExit;
}
lstrcpy(pDDD->pszDunFile,lpszFile);
//
// Load message string
//
pDDD->pszMessage = (LPTSTR)LocalAlloc(LPTR,1024* sizeof(TCHAR));
if (0 == pDDD->pszMessage)
{
hr = ERROR_NOT_ENOUGH_MEMORY;
goto FillConnectionStructuresExit;
}
if (0 == LoadString(ghInstance,IDS_ISP_DIAL_MESSAGE,
pDDD->pszMessage,1024))
{
hr = GetLastError();
goto FillConnectionStructuresExit;
}
//
// Get Connectoid name
//
pDDD->pszRasEntryName = (LPTSTR)LocalAlloc(LPTR, (RAS_MaxEntryName + 1)*sizeof(TCHAR));
if (0 == pDDD->pszRasEntryName)
{
hr = ERROR_NOT_ENOUGH_MEMORY;
goto FillConnectionStructuresExit;
}
if( 0 == GetPrivateProfileString(cszEntrySection,cszEntryName,szNull,
pDDD->pszRasEntryName,RAS_MaxEntryName,lpszFile))
{
hr = ERROR_INVALID_PARAMETER;
goto FillConnectionStructuresExit;
}
//
// Hook in reconnect mechanism
//
#if !defined(WIN16)
pDDD->pfnRasDialFunc1 = RasDial1Callback;
#endif
//
// Initialize EDD structure
//
ZeroMemory(pEDD,sizeof(ERRORDLGDATA));
pEDD->dwSize = sizeof(ERRORDLGDATA);
//
// Copy common fields to Error dialog data
//
pEDD->hInst = pDDD->hInst;
pEDD->pszRasEntryName = (LPTSTR)LocalAlloc(LPTR,(lstrlen(pDDD->pszRasEntryName)+1)*sizeof(TCHAR));
if (NULL == pEDD->pszRasEntryName)
{
hr = ERROR_NOT_ENOUGH_MEMORY;
goto FillConnectionStructuresExit;
}
lstrcpy(pEDD->pszRasEntryName,pDDD->pszRasEntryName);
//
// Allocate buffer for error messages
//
pEDD->pszMessage = (LPTSTR)LocalAlloc(LPTR,MAX_ERROR_MESSAGE*sizeof(TCHAR));
if (NULL == pEDD->pszMessage)
{
hr = ERROR_NOT_ENOUGH_MEMORY;
goto FillConnectionStructuresExit;
}
FillConnectionStructuresExit:
return hr;
}
//+----------------------------------------------------------------------------
// Function FShouldRetry
//
// Synopsis Given a RAS error should the dialer automatically retry
//
// Arguments dwErr - RAS error value
//
// Returns TRUE - the dialer should automatically retry
//
// Histroy 10/16/96 ChrisK Ported from icwconn1
//
//-----------------------------------------------------------------------------
static BOOL FShouldRetry(DWORD dwErr)
{
BOOL bRC;
if (dwErr == ERROR_LINE_BUSY ||
dwErr == ERROR_VOICE_ANSWER ||
dwErr == ERROR_NO_ANSWER ||
dwErr == ERROR_NO_CARRIER ||
dwErr == ERROR_AUTHENTICATION_FAILURE ||
dwErr == ERROR_PPP_TIMEOUT ||
dwErr == ERROR_REMOTE_DISCONNECTION ||
dwErr == ERROR_AUTH_INTERNAL ||
dwErr == ERROR_PROTOCOL_NOT_CONFIGURED ||
dwErr == ERROR_PPP_NO_PROTOCOLS_CONFIGURED)
{
bRC = TRUE;
} else {
bRC = FALSE;
}
return bRC;
}
//+----------------------------------------------------------------------------
//
// Function: RepairDeviceInfo
//
// Synopsis: In some win95 configurations, RasSetEntryProperties will create
// a connectoid with invalid information about the modem. This
// function attempts to correct the problem by reading and
// rewriting the connectoid.
//
// Arguments: lpszEntry - name of connectoid
//
// Returns: none
//
// History: ChrisK 7/25/97 Created
//
//-----------------------------------------------------------------------------
#if !defined(WIN16)
BOOL RepairDeviceInfo(LPTSTR lpszEntry)
{
DWORD dwEntrySize = 0;
DWORD dwDeviceSize = 0;
LPRASENTRY lpRasEntry = NULL;
LPBYTE lpbDevice = NULL;
OSVERSIONINFO osver;
TCHAR szTemp[1024];
BOOL bRC = FALSE;
RASDIALPARAMS rasdialp;
BOOL bpassword = FALSE;
//
// Validate parameters
//
if (NULL == lpszEntry)
{
DebugOut("ISIGN32: RepairDevice invalid parameter.\n");
goto RepairDeviceInfoExit;
}
//
// This fix only applies to golden win95 build 950
//
osver.dwOSVersionInfoSize = sizeof(osver);
GetVersionEx(&osver);
if (VER_PLATFORM_WIN32_WINDOWS != osver.dwPlatformId ||
4 != osver.dwMajorVersion ||
0 != osver.dwMinorVersion ||
950 != LOWORD(osver.dwBuildNumber))
{
DebugOut("ISIGN32: RepairDevice wrong platform.\n");
wsprintf(szTemp,TEXT("ISIGN32: %d.%d.%d.\n"),
osver.dwMajorVersion,
osver.dwMinorVersion,
LOWORD(osver.dwBuildNumber));
DebugOut(szTemp);
goto RepairDeviceInfoExit;
}
//
// Get the RAS Entry
//
lpfnRasGetEntryProperties(NULL,
lpszEntry,
NULL,
&dwEntrySize,
NULL,
&dwDeviceSize);
lpRasEntry = (LPRASENTRY)LocalAlloc(LPTR, dwEntrySize);
lpbDevice = (LPBYTE)LocalAlloc(LPTR,dwDeviceSize);
if (NULL == lpRasEntry || NULL == lpbDevice)
{
DebugOut("ISIGN32: RepairDevice Out of memory.\n");
goto RepairDeviceInfoExit;
}
if (sizeof(RASENTRY) != dwEntrySize)
{
DebugOut("ISIGN32: RepairDevice Entry size is not equal to sizeof(RASENTRY).\n");
}
lpRasEntry->dwSize = sizeof(RASENTRY);
if (ERROR_SUCCESS != lpfnRasGetEntryProperties(NULL,
lpszEntry,
(LPBYTE)lpRasEntry,
&dwEntrySize,
lpbDevice,
&dwDeviceSize))
{
DebugOut("ISIGN32: RepairDevice can not read entry.\n");
goto RepairDeviceInfoExit;
}
//
// Get the connectoid's user ID and password
//
ZeroMemory(&rasdialp,sizeof(rasdialp));
rasdialp.dwSize = sizeof(rasdialp);
lstrcpyn(rasdialp.szEntryName,lpszEntry,RAS_MaxEntryName);
if (ERROR_SUCCESS != lpfnRasGetEntryDialParams(NULL,
&rasdialp,
&bpassword))
{
DebugOut("ISIGN32: RepairDevice can not read dial params.\n");
goto RepairDeviceInfoExit;
}
//
// Delete the existing entry
//
if (ERROR_SUCCESS != lpfnRasDeleteEntry(NULL,lpszEntry))
{
DebugOut("ISIGN32: RepairDevice can not delete entry.\n");
goto RepairDeviceInfoExit;
}
//
// Rewrite entry with "fixed" device size
//
if (ERROR_SUCCESS != lpfnRasSetEntryProperties(NULL,
lpszEntry,
(LPBYTE)lpRasEntry,
dwEntrySize,
NULL,
0))
{
DebugOut("ISIGN32: RepairDevice can not write entry.\n");
goto RepairDeviceInfoExit;
}
//
// Clear unnecessary values
//
rasdialp.szPhoneNumber[0] = '\0';
rasdialp.szCallbackNumber[0] = '\0';
//
// Save connectoid's username and password
//
if (ERROR_SUCCESS != lpfnRasSetEntryDialParams(NULL,
&rasdialp,
FALSE))
{
DebugOut("ISIGN32: RepairDevice can not write dial params.\n");
goto RepairDeviceInfoExit;
}
bRC = TRUE;
RepairDeviceInfoExit:
if (lpRasEntry)
{
LocalFree(lpRasEntry);
}
if (lpbDevice)
{
LocalFree(lpbDevice);
}
return bRC;
}
#endif
//+----------------------------------------------------------------------------
// Function: DialConnection
//
// Synopsis: Dials connectoin created for ISP file
//
// Arguments: lpszFile - ISP file name
//
// Returns: HRESULT - ERROR_SUCCESS indicates success
//
// History:
// 7/22/96 ChrisK Created
//
//-----------------------------------------------------------------------------
static HRESULT DialConnection(LPCTSTR lpszFile)
{
HRESULT hr = ERROR_SUCCESS;
DIALDLGDATA dddISPDialDlg;
ERRORDLGDATA eddISPDialDlg;
HINSTANCE hDialDLL = NULL;
PFNDIALDLG pfnDial = NULL;
PFNERRORDLG pfnError = NULL;
INT iRetry;
DebugOut("ISIGNUP:DialConnection()\r\n");
//
// Initize data structures
//
hr = FillConnectionStructures(lpszFile,&dddISPDialDlg, &eddISPDialDlg);
if (ERROR_SUCCESS != hr)
goto DialConnectionExit;
//
// Load functions
//
TCHAR szBuffer[MAX_PATH];
if (GetSystemDirectory(szBuffer,MAX_PATH))
{
lstrcat(szBuffer, TEXT("\\"));
lstrcat(szBuffer, cszICWDIAL_DLL);
hDialDLL = LoadLibrary(szBuffer);
}
if (!hDialDLL)
hDialDLL = LoadLibrary(cszICWDIAL_DLL);
if (NULL != hDialDLL)
{
pfnDial = (PFNDIALDLG)GetProcAddress(hDialDLL,cszICWDIAL_DIALDLG);
if (NULL != pfnDial)
pfnError = (PFNERRORDLG)GetProcAddress(hDialDLL,cszICWDIAL_ERRORDLG);
}
if(!(hDialDLL && pfnDial && pfnError))
{
hr = GetLastError();
goto DialConnectionExit;
}
//
// Dial connection
//
iRetry = 0;
DialConnectionDial:
hr = pfnDial(&dddISPDialDlg);
if (1 == hr)
{
// This is a special case when the user has killed the browser
// out from behind the dialer. In this case, shut down and exit
// as cleanly as possible.
goto DialConnectionExit;
}
else if (ERROR_USERNEXT != hr)
{
if ((iRetry < MAX_RETRIES) && FShouldRetry(hr))
{
iRetry++;
goto DialConnectionDial;
}
else
{
#if !defined(WIN16)
if (0 == iRetry && ERROR_WRONG_INFO_SPECIFIED == hr)
{
DebugOut("ISIGN32: Attempt device info repair.\n");
if (RepairDeviceInfo(dddISPDialDlg.pszRasEntryName))
{
iRetry++;
goto DialConnectionDial;
}
}
#endif
iRetry = 0;
hr = LoadDialErrorString(hr,eddISPDialDlg.pszMessage,MAX_ERROR_MESSAGE);
hr = pfnError(&eddISPDialDlg);
if (ERROR_USERCANCEL == hr)
goto DialConnectionExit;
else if (ERROR_USERNEXT == hr)
goto DialConnectionDial;
else
goto DialConnectionExit;
}
}
DialConnectionExit:
ReleaseConnectionStructures(&dddISPDialDlg, &eddISPDialDlg);
if (hDialDLL)
{
FreeLibrary(hDialDLL);
hDialDLL = NULL;
pfnDial = NULL;
pfnError = NULL;
}
return hr;
}
#ifdef WIN16
LPVOID MyLocalAlloc(DWORD flag, DWORD size)
{
LPVOID lpv;
lpv = calloc(1, (INT)size);
return lpv;
}
LPVOID MyLocalFree(LPVOID lpv)
{
free(lpv);
return NULL;
}
#endif
// ############################################################################
//
// Name: ImportMailAndNewsInfo
//
// Description: Import information from INS file and set the associated
// registry keys for Internet Mail and News (Athena)
//
// Input: lpszFile - Fully qualified filename of INS file
//
// Return: Error value
//
// History: 6/27/96 Created
// 5/12/97 Updated to use the new CreateAccountsFromFile
// in Athena's inetcomm.dll. This function was
// created expresly for us to use here.
// (See Olympus #266) -- jmazner
//
// ############################################################################
static DWORD ImportMailAndNewsInfo(LPCTSTR lpszFile, BOOL fConnectPhone)
{
DWORD dwRet = ERROR_SUCCESS;
#ifndef WIN16
TCHAR szAcctMgrPath[MAX_PATH + 1] = TEXT("");
TCHAR szExpandedPath[MAX_PATH + 1] = TEXT("");
DWORD dwAcctMgrPathSize = 0;
HRESULT hr = S_OK;
HKEY hKey = NULL;
HINSTANCE hInst = NULL;
CONNECTINFO connectInfo;
TCHAR szConnectoidName[RAS_MaxEntryName] = TEXT("nogood\0");
PFNCREATEACCOUNTSFROMFILEEX fp = NULL;
// get path to the AcctMgr dll
dwRet = RegOpenKeyEx(HKEY_LOCAL_MACHINE, ACCTMGR_PATHKEY,0, KEY_READ, &hKey);
if ( (dwRet != ERROR_SUCCESS) || (NULL == hKey) )
{
Dprintf("ImportMailAndNewsInfo couldn't open reg key %s\n", ACCTMGR_PATHKEY);
return( dwRet );
}
dwAcctMgrPathSize = sizeof (szAcctMgrPath);
dwRet = RegQueryValueEx(hKey, ACCTMGR_DLLPATH, NULL, NULL, (LPBYTE) szAcctMgrPath, &dwAcctMgrPathSize);
RegCloseKey( hKey );
if ( dwRet != ERROR_SUCCESS )
{
Dprintf("ImportMailAndNewsInfo: RegQuery failed with error %d\n", dwRet);
return( dwRet );
}
// 6/18/97 jmazner Olympus #6819
Dprintf("ImportMailAndNewsInfo: read in DllPath of %s\n", szAcctMgrPath);
ExpandEnvironmentStrings( szAcctMgrPath, szExpandedPath, MAX_PATH + 1 );
//
// 6/4/97 jmazner
// if we created a connectoid, then get its name and use that as the
// connection type. Otherwise, assume we're supposed to connect via LAN
//
connectInfo.cbSize = sizeof(CONNECTINFO);
connectInfo.type = CONNECT_LAN;
if( fConnectPhone && lpfnInetGetAutodial )
{
BOOL fEnabled = FALSE;
dwRet = lpfnInetGetAutodial(&fEnabled,szConnectoidName,RAS_MaxEntryName);
if( ERROR_SUCCESS==dwRet && szConnectoidName[0] )
{
connectInfo.type = CONNECT_RAS;
#ifdef UNICODE
wcstombs(connectInfo.szConnectoid, szConnectoidName, MAX_PATH);
#else
lstrcpyn( connectInfo.szConnectoid, szConnectoidName, MAX_PATH );
#endif
Dprintf("ImportMailAndNewsInfo: setting connection type to RAS with %s\n", szConnectoidName);
}
}
if( CONNECT_LAN == connectInfo.type )
{
Dprintf("ImportMailAndNewsInfo: setting connection type to LAN\n");
#ifdef UNICODE
wcstombs(connectInfo.szConnectoid, TEXT("I said CONNECT_LAN!"), MAX_PATH);
#else
lstrcpy( connectInfo.szConnectoid, TEXT("I said CONNECT_LAN!") );
#endif
}
hInst = LoadLibrary(szExpandedPath);
if (hInst)
{
fp = (PFNCREATEACCOUNTSFROMFILEEX) GetProcAddress(hInst,"CreateAccountsFromFileEx");
if (fp)
hr = fp( (TCHAR *)lpszFile, &connectInfo, NULL );
}
else
{
Dprintf("ImportMailAndNewsInfo unable to LoadLibrary on %s\n", szAcctMgrPath);
}
//
// Clean up and release resourecs
//
if( hInst)
{
FreeLibrary(hInst);
hInst = NULL;
}
if( fp )
{
fp = NULL;
}
//ImportMailAndNewsInfoExit:
#endif
return dwRet;
}
// ############################################################################
//
// Name: WriteMailAndNewsKey
//
// Description: Read a string value from the given INS file and write it
// to the registry
//
// Input: hKey - Registry key where the data will be written
// lpszSection - Section name inside of INS file where data is read
// from
// lpszValue - Name of value to read from INS file
// lpszBuff - buffer where data will be read into
// dwBuffLen - size of lpszBuff
// lpszSubKey - Value name where information will be written to
// dwType - data type (Should always be REG_SZ)
// lpszFileName - Fully qualified filename to INS file
//
// Return: Error value
//
// Histroy: 6/27/96 Created
// 5/12/97 Commented out -- no longer needed
// (See Olympus #266)
//
// ############################################################################
/***
static HRESULT WriteMailAndNewsKey(HKEY hKey, LPCTSTR lpszSection, LPCTSTR lpszValue,
LPTSTR lpszBuff, DWORD dwBuffLen,LPCTSTR lpszSubKey,
DWORD dwType, LPCTSTR lpszFile)
{
#ifndef WIN16
ZeroMemory(lpszBuff,dwBuffLen);
GetPrivateProfileString(lpszSection,lpszValue,TEXT(""),lpszBuff,dwBuffLen,lpszFile);
if (lstrlen(lpszBuff))
{
return RegSetValueEx(hKey,lpszSubKey,0,dwType,(CONST BYTE*)lpszBuff,
sizeof(TCHAR)*(lstrlen(lpszBuff)+1));
}
else
{
DebugOut("ISIGNUP: WriteMailAndNewsKey, missing value in INS file\n");
return ERROR_NO_MORE_ITEMS;
}
#else
return ERROR_GEN_FAILURE;
#endif
}
***/
// ############################################################################
//
// Name: PreparePassword
//
// Description: Encode given password and return value in place. The
// encoding is done right to left in order to avoid having
// to allocate a copy of the data. The encoding uses base64
// standard as specified in RFC 1341 5.2
//
// Input: szBuff - Null terminated data to be encoded
// dwBuffLen - Full length of buffer, this should exceed the length of
// the input data by at least 1/3
//
// Return: Error value
//
// Histroy: 6/27/96 Created
//
// ############################################################################
static HRESULT PreparePassword(LPTSTR szBuff, DWORD dwBuffLen)
{
DWORD dw;
LPTSTR szOut = NULL;
LPTSTR szNext = NULL;
HRESULT hr = ERROR_SUCCESS;
BYTE bTemp = 0;
DWORD dwLen = 0;
dwLen = lstrlen(szBuff);
if (!dwLen)
{
hr = ERROR_INVALID_PARAMETER;
goto PreparePasswordExit;
}
// Calculate the size of the buffer that will be needed to hold
// encoded data
//
szNext = &szBuff[dwLen-1];
dwLen = (((dwLen % 3 ? (3-(dwLen%3)):0) + dwLen) * 4 / 3);
if (dwBuffLen < dwLen+1)
{
hr = ERROR_INVALID_PARAMETER;
goto PreparePasswordExit;
}
szOut = &szBuff[dwLen];
*szOut-- = '\0';
// Add padding = characters
//
switch (lstrlen(szBuff) % 3)
{
case 0:
// no padding
break;
case 1:
*szOut-- = 64;
*szOut-- = 64;
*szOut-- = (*szNext & 0x3) << 4;
*szOut-- = (*szNext-- & 0xFC) >> 2;
break;
case 2:
*szOut-- = 64;
*szOut-- = (*szNext & 0xF) << 2;
*szOut = ((*szNext-- & 0xF0) >> 4);
*szOut-- |= ((*szNext & 0x3) << 4);
*szOut-- = (*szNext-- & 0xFC) >> 2;
}
// Encrypt data into indicies
//
while (szOut > szNext && szNext >= szBuff)
{
*szOut-- = *szNext & 0x3F;
*szOut = ((*szNext-- & 0xC0) >> 6);
*szOut-- |= ((*szNext & 0xF) << 2);
*szOut = ((*szNext-- & 0xF0) >> 4);
*szOut-- |= ((*szNext & 0x3) << 4);
*szOut-- = (*szNext-- & 0xFC) >> 2;
}
// Translate indicies into printable characters
//
szNext = szBuff;
// BUG OSR#10435--if there is a 0 in the generated string of base-64
// encoded digits (this can happen if the password is "Willypassword"
// for example), then instead of encoding the 0 to 'A', we just quit
// at this point, produces an invalid base-64 string.
// while (*szNext)
for(dw=0; dw<dwLen; dw++)
*szNext = arBase64[*szNext++];
PreparePasswordExit:
return hr;
}
// ############################################################################
//
// Name: FIsAthenaPresent
//
// Description: Determine if Microsoft Internet Mail And News client (Athena)
// is installed
//
// Input: none
//
// Return: TRUE - Athena is installed
// FALSE - Athena is NOT installed
//
// History: 7/1/96 Created
// 5/14/97 No longer needed after work for Olympus #266
//
// ############################################################################
/****
static BOOL FIsAthenaPresent()
{
#ifndef WIN16
TCHAR szBuff[MAX_PATH + 1];
HRESULT hr = ERROR_SUCCESS;
HINSTANCE hInst = NULL;
LONG lLen = 0;
// Get path to Athena client
//
lLen = MAX_PATH;
hr = RegQueryValue(HKEY_CLASSES_ROOT,MAIL_NEWS_INPROC_SERVER32,szBuff,&lLen);
if (hr == ERROR_SUCCESS)
{
// Attempt to load client
//
hInst = LoadLibrary(szBuff);
if (!hInst)
{
DebugOut("ISIGNUP: Internet Mail and News server didn't load.\n");
hr = ERROR_FILE_NOT_FOUND;
} else {
FreeLibrary(hInst);
}
hInst = NULL;
}
return (hr == ERROR_SUCCESS);
#else
return FALSE;
#endif // win16
}
*****/
// ############################################################################
//
// Name: FTurnOffBrowserDefaultChecking
//
// Description: Turn Off IE checking to see if it is the default browser
//
// Input: none
//
// Output: TRUE - success
// FALSE - failed
//
// History: 7/2/96 Created
//
// ############################################################################
static BOOL FTurnOffBrowserDefaultChecking()
{
BOOL bRC = TRUE;
#ifndef WIN16
HKEY hKey = NULL;
DWORD dwType = 0;
DWORD dwSize = 0;
//
// Open IE settings registry key
//
if (RegOpenKey(HKEY_CURRENT_USER,cszDEFAULT_BROWSER_KEY,&hKey))
{
bRC = FALSE;
goto FTurnOffBrowserDefaultCheckingExit;
}
//
// Read current settings for check associations
//
dwType = 0;
dwSize = sizeof(pDynShare->szCheckAssociations);
ZeroMemory(pDynShare->szCheckAssociations, dwSize);
RegQueryValueEx(hKey,
cszDEFAULT_BROWSER_VALUE,
0,
&dwType,
(LPBYTE)pDynShare->szCheckAssociations,
&dwSize);
// ignore return value, even if the calls fails we are going to try
// to change the setting to "NO"
//
// Set value to "no" to turn off checking
//
if (RegSetValueEx(hKey,
cszDEFAULT_BROWSER_VALUE,
0,
REG_SZ,
(LPBYTE)cszNo,
sizeof(TCHAR)*(lstrlen(cszNo)+1)))
{
bRC = FALSE;
goto FTurnOffBrowserDefaultCheckingExit;
}
//
// Clean up and return
//
FTurnOffBrowserDefaultCheckingExit:
if (hKey)
RegCloseKey(hKey);
if (bRC)
SetExitFlags(SXF_RESTOREDEFCHECK);
hKey = NULL;
#endif
return bRC;
}
// ############################################################################
//
// Name: FRestoreBrowserDefaultChecking
//
// Description: Restore IE checking to see if it is the default browser
//
// Input: none
//
// Output: TRUE - success
// FALSE - failed
//
// History: 7/2/96 Created
//
// ############################################################################
static BOOL FRestoreBrowserDefaultChecking()
{
BOOL bRC = TRUE;
#ifndef WIN16
HKEY hKey = NULL;
//
// Open IE settings registry key
//
if (RegOpenKey(HKEY_CURRENT_USER,cszDEFAULT_BROWSER_KEY,&hKey))
{
bRC = FALSE;
goto FRestoreBrowserDefaultCheckingExit;
}
//
// Set value to original value
//
if (RegSetValueEx(hKey,
cszDEFAULT_BROWSER_VALUE,
0,
REG_SZ,
(LPBYTE)pDynShare->szCheckAssociations,
sizeof(TCHAR)*(lstrlen(pDynShare->szCheckAssociations)+1)))
{
bRC = FALSE;
goto FRestoreBrowserDefaultCheckingExit;
}
FRestoreBrowserDefaultCheckingExit:
if (hKey)
RegCloseKey(hKey);
hKey = NULL;
#endif
return bRC;
}
#if !defined(WIN16)
//+----------------------------------------------------------------------------
//
// Function: SaveIEWindowPlacement
//
// Synopsis: Saves the registry value for IE window placement into a global for later restoration
// Should only be called once in the signup process.
//
// Arguments: None, but uses global pbIEWindowPlacement, which it expects to be NULL
//
// Returns: TRUE - The value was read and stored
// FALSE - function failed.
//
// History: 8/21/96 jmazner Created (as fix for Normandy #4592)
// 10/11/96 jmazner updated to dynamicaly determine size of the key
//
//-----------------------------------------------------------------------------
BOOL SaveIEWindowPlacement( void )
{
HKEY hKey = NULL;
//DWORD dwSize = 0;
LONG lQueryErr = 0xEE; // initialize to something strange
DWORD dwIEWindowPlacementSize = 0;
PBYTE pbIEWindowPlacement = NULL;
// Argh, no Assert defined in isign32!
if ( pDynShare->dwIEWindowPlacementSize != 0 )
{
#if DEBUG
DebugOut("ISIGN32: SaveIEWindowPlacement called a second time!\n");
MessageBox(
hwndMain,
TEXT("ISIGN32 ERROR: Window_Placement global var is not null --jmazner\n"),
cszAppName,
MB_SETFOREGROUND |
MB_ICONEXCLAMATION |
MB_OKCANCEL);
#endif
DebugOut("ISIGN32: SaveIEWindowPlacement called a second time!\n");
goto SaveIEWindowPlacementErrExit;
}
//
// Open IE settings registry key
//
if ( ERROR_SUCCESS != RegOpenKeyEx(HKEY_CURRENT_USER,
cszDEFAULT_BROWSER_KEY,
NULL,
KEY_READ,
&hKey) )
goto SaveIEWindowPlacementErrExit;
// Determine size of buffer needed to hold the window_placement key
lQueryErr = RegQueryValueEx(hKey,
cszIEWINDOW_PLACEMENT,
NULL,
NULL,
NULL,
&dwIEWindowPlacementSize);
// for unknown reasons, lQueryErr is ending up as ERROR_SUCCESS after this call!
// if( ERROR_MORE_DATA != lQueryErr )
// goto SaveIEWindowPlacementErrExit;
ISIGN32_ASSERT(sizeof(pDynShare->pbIEWindowPlacement) >= dwIEWindowPlacementSize);
pbIEWindowPlacement = pDynShare->pbIEWindowPlacement;
//
// Read current settings for window_placement
//
//dwSize = sizeof(pbIEWindowPlacement);
//ZeroMemory(pbIEWindowPlacement,dwSize);
lQueryErr = RegQueryValueEx(hKey,
cszIEWINDOW_PLACEMENT,
NULL,
NULL,
(LPBYTE)pbIEWindowPlacement,
&dwIEWindowPlacementSize);
if (ERROR_SUCCESS != lQueryErr)
{
#ifdef DEBUG
MessageBox(
hwndMain,
TEXT("ISIGNUP ERROR: Window_Placement reg key is longer than expected! --jmazner\n"),
cszAppName,
MB_SETFOREGROUND |
MB_ICONEXCLAMATION |
MB_OKCANCEL);
#endif
DebugOut("ISIGN32 ERROR: SaveIEWindowPlacement RegQueryValue failed\n");
goto SaveIEWindowPlacementErrExit;
}
RegCloseKey( hKey );
pDynShare->dwIEWindowPlacementSize = dwIEWindowPlacementSize;
return( TRUE );
SaveIEWindowPlacementErrExit:
if ( hKey ) RegCloseKey( hKey );
return( FALSE );
}
// note we're still in #if !defined(WIN16)
//+----------------------------------------------------------------------------
//
// Function: RestoreIEWindowPlacement
//
// Synopsis: Restores the registry value for IE window placement from a global
// NOTE: compatability with Nashville/IE 4?
//
// Arguments: None
//
// Returns: TRUE - The value was restored
// FALSE - function failed.
//
// History: jmazner Created 8/21/96 (as fix for Normandy #4592)
//
//-----------------------------------------------------------------------------
BOOL RestoreIEWindowPlacement( void )
{
HKEY hKey = NULL;
if ( pDynShare->dwIEWindowPlacementSize == 0 )
{
DebugOut("ISIGN32: RestoreIEWindowPlacement called with null global!\n");
return( FALSE );
}
//
// Open IE settings registry key
//
if ( ERROR_SUCCESS != RegOpenKeyEx(HKEY_CURRENT_USER,
cszDEFAULT_BROWSER_KEY,
NULL,
KEY_SET_VALUE,
&hKey) )
return( FALSE );
//
// Write saved settings for window_placement
//
if (ERROR_SUCCESS != RegSetValueEx(hKey,
cszIEWINDOW_PLACEMENT,
NULL,
REG_BINARY,
(LPBYTE)pDynShare->pbIEWindowPlacement,
pDynShare->dwIEWindowPlacementSize) )
{
RegCloseKey( hKey );
return( FALSE );
}
RegCloseKey( hKey );
pDynShare->pbIEWindowPlacement[0] = (TCHAR) 0;
pDynShare->dwIEWindowPlacementSize = 0;
return( TRUE );
}
#endif //(!defined win16)
//+----------------------------------------------------------------------------
//
// Function: DeleteFileKindaLikeThisOne
//
// Synopsis: This function serve the single function of cleaning up after
// IE3.0, because IE3.0 will issue multiple POST and get back
// multiple .INS files. These files contain sensative data that
// we don't want lying around, so we are going out, guessing what
// their names are, and deleting them.
//
// Arguments: lpszFileName - the full name of the file to delete
//
// Returns: error code, ERROR_SUCCESS == success
//
// History: 7/96 ChrisK Created
// 7/96 ChrisK Bug fix for long filenames
// 8/2/96 ChrisK Port to Win32
//-----------------------------------------------------------------------------
static HRESULT DeleteFileKindaLikeThisOne(LPCTSTR lpszFileName)
{
HRESULT hr = ERROR_SUCCESS;
#ifndef WIN16
LPCTSTR lpNext = NULL;
WORD wRes = 0;
HANDLE hFind = NULL;
WIN32_FIND_DATA sFoundFile;
TCHAR szPath[MAX_PATH];
TCHAR szSearchPath[MAX_PATH + 1];
LPTSTR lpszFilePart = NULL;
// Validate parameter
//
if (!lpszFileName || lstrlen(lpszFileName) <= 4)
{
hr = ERROR_INVALID_PARAMETER;
goto DeleteFileKindaLikeThisOneExit;
}
// Determine the directory name where the INS files are located
//
ZeroMemory(szPath,MAX_PATH);
if (GetFullPathName(lpszFileName,MAX_PATH,szPath,&lpszFilePart))
{
*lpszFilePart = '\0';
} else {
hr = GetLastError();
goto DeleteFileKindaLikeThisOneExit;
};
// Munge filename into search parameters
//
lpNext = &lpszFileName[lstrlen(lpszFileName)-4];
if (CompareString(LOCALE_SYSTEM_DEFAULT,NORM_IGNORECASE,lpNext,4,TEXT(".INS"),4) != 2) goto DeleteFileKindaLikeThisOneExit;
ZeroMemory(szSearchPath,MAX_PATH + 1);
lstrcpyn(szSearchPath,szPath,MAX_PATH);
lstrcat(szSearchPath,TEXT("*.INS"));
// Start wiping out files
//
ZeroMemory(&sFoundFile,sizeof(sFoundFile));
hFind = FindFirstFile(szSearchPath,&sFoundFile);
if (hFind)
{
do {
lstrcpy(lpszFilePart,sFoundFile.cFileName);
SetFileAttributes(szPath,FILE_ATTRIBUTE_NORMAL);
DeleteFile(szPath);
ZeroMemory(&sFoundFile,sizeof(sFoundFile));
} while (FindNextFile(hFind,&sFoundFile));
FindClose(hFind);
}
hFind = NULL;
DeleteFileKindaLikeThisOneExit:
#endif
return hr;
}
#if defined(WIN16)
#define MAIN_WNDCLASS_NAME "IE_DialerMainWnd"
#define IEDIAL_REGISTER_MSG "IEDialQueryPrevInstance"
#define IEDIALMSG_QUERY (0)
#define IEDIALMSG_SHUTDOWN (1)
#define IEDIAL_SHUTDOWN_TIMER 1001
//+---------------------------------------------------------------------------
//
// Function: ShutDownIEDial()
//
// Synopsis: Shutdown the instance IEDial if it running and
// in disconnected state - otherwise it interfers with dialing
// from icwconn2
//
// Arguments: [hWnd - Window handle (used for creating timer)
//
// Returns: TRUE if successful shutdown or instance does not exist
// FALSE otherwise
//
// History: 8/24/96 VetriV Created
//
//----------------------------------------------------------------------------
BOOL ShutDownIEDial(HWND hWnd)
{
HINSTANCE hInstance;
static UINT WM_IEDIAL_INSTANCEQUERY = 0;
UINT uiAttempts = 0;
MSG msg;
//
// Check if IEDial is running
//
hInstance = FindWindow(MAIN_WNDCLASS_NAME, NULL);
if (NULL != hInstance)
{
if (0 == WM_IEDIAL_INSTANCEQUERY)
WM_IEDIAL_INSTANCEQUERY= RegisterWindowMessage(IEDIAL_REGISTER_MSG);
//
// Check if it is in connected state
//
if (SendMessage(hInstance, WM_IEDIAL_INSTANCEQUERY,
IEDIALMSG_QUERY, 0))
{
//
// Not connected - Send quit message
//
SendMessage(hInstance, WM_IEDIAL_INSTANCEQUERY,
IEDIALMSG_SHUTDOWN, 0);
return TRUE;
}
//
// If IEDIAL is in connected state try for another 3 seconds
// waiting for 1 second between tries
// We have to do this because, IEDIAL can take upto 2 seconds
// to realize it lost the connection!!
//
SetTimer(hWnd, IEDIAL_SHUTDOWN_TIMER, 1000, NULL);
DebugOut("ISIGNUP: IEDIAL Timer message loop\n");
while (GetMessage (&msg, NULL, 0, 0))
{
if (WM_TIMER == msg.message)
{
//
// Check if it is in connected state
//
if (SendMessage(hInstance, WM_IEDIAL_INSTANCEQUERY,
IEDIALMSG_QUERY, 0))
{
//
// Not connected - Send quit message
//
SendMessage(hInstance, WM_IEDIAL_INSTANCEQUERY,
IEDIALMSG_SHUTDOWN, 0);
break;
}
//
// If we have tried thrice - get out
//
if (++uiAttempts > 3)
break;
}
else
{
TranslateMessage (&msg) ;
DispatchMessage (&msg) ;
}
}
KillTimer(hWnd, IEDIAL_SHUTDOWN_TIMER);
if (uiAttempts > 3)
return FALSE;
}
return TRUE;
}
#endif // WIN16
#if !defined(WIN16)
//+----------------------------------------------------------------------------
//
// Function LclSetEntryScriptPatch
//
// Synopsis Softlink to RasSetEntryPropertiesScriptPatch
//
// Arguments see RasSetEntryPropertiesScriptPatch
//
// Returns see RasSetEntryPropertiesScriptPatch
//
// Histroy 10/3/96 ChrisK Created
//
//-----------------------------------------------------------------------------
typedef BOOL (WINAPI* LCLSETENTRYSCRIPTPATCH)(LPTSTR, LPTSTR);
BOOL LclSetEntryScriptPatch(LPTSTR lpszScript,LPTSTR lpszEntry)
{
HINSTANCE hinst = NULL;
LCLSETENTRYSCRIPTPATCH fp = NULL;
BOOL bRC = FALSE;
hinst = LoadLibrary(TEXT("ICWDIAL.DLL"));
if (hinst)
{
fp = (LCLSETENTRYSCRIPTPATCH)GetProcAddress(hinst,"RasSetEntryPropertiesScriptPatch");
if (fp)
bRC = (fp)(lpszScript,lpszEntry);
FreeLibrary(hinst);
hinst = NULL;
fp = NULL;
}
return bRC;
}
#endif //!WIN16
#if !defined(WIN16)
//+----------------------------------------------------------------------------
//
// Function IsMSDUN12Installed
//
// Synopsis Check if MSDUN 1.2 or higher is installed
//
// Arguments none
//
// Returns TRUE - MSDUN 1.2 is installed
//
// History 5/28/97 ChrisK created for Olympus Bug 4392
//
//-----------------------------------------------------------------------------
//
// 8/5/97 jmazner Olympus #11404
//
//#define DUN_12_Version (1.2e0f)
#define DUN_12_Version ((double)1.2)
BOOL IsMSDUN12Installed()
{
TCHAR szBuffer[MAX_PATH] = {TEXT("\0")};
HKEY hkey = NULL;
BOOL bRC = FALSE;
DWORD dwType = 0;
DWORD dwSize = sizeof(szBuffer);
FLOAT flVersion = 0e0f;
if (ERROR_SUCCESS != RegOpenKey(HKEY_LOCAL_MACHINE,
TEXT("System\\CurrentControlSet\\Services\\RemoteAccess"),
&hkey))
{
goto IsMSDUN12InstalledExit;
}
if (ERROR_SUCCESS != RegQueryValueEx(hkey,
TEXT("Version"),
NULL,
&dwType,
(LPBYTE)szBuffer,
&dwSize))
{
goto IsMSDUN12InstalledExit;
}
#ifdef UNICODE
CHAR szTmp[MAX_PATH];
wcstombs(szTmp, szBuffer, MAX_PATH);
szTmp[MAX_PATH-1] = '\0';
bRC = DUN_12_Version <= atof(szTmp);
#else
bRC = DUN_12_Version <= atof(szBuffer);
#endif
IsMSDUN12InstalledExit:
if (hkey != NULL)
{
RegCloseKey(hkey);
hkey = NULL;
}
return bRC;
}
//+----------------------------------------------------------------------------
//
// Function IsScriptingInstalled
//
// Synopsis Check to see if scripting is already installed
//
// Arguments none
//
// Returns TRUE - scripting has been installed
//
// History 10/14/96 ChrisK Creaed
//
//-----------------------------------------------------------------------------
static BOOL IsScriptingInstalled()
{
BOOL bRC = FALSE;
HKEY hkey = NULL;
DWORD dwSize = 0;
DWORD dwType = 0;
LONG lrc = 0;
HINSTANCE hInst = NULL;
TCHAR szData[MAX_PATH+1];
OSVERSIONINFO osver;
//
// Check version information
//
ZeroMemory(&osver,sizeof(osver));
osver.dwOSVersionInfoSize = sizeof(osver);
GetVersionEx(&osver);
//
// check for SMMSCRPT.DLL being present
//
if (VER_PLATFORM_WIN32_NT == osver.dwPlatformId)
{
bRC = TRUE;
}
else if (IsMSDUN12Installed())
{
bRC = TRUE;
}
else
{
//
// Verify scripting by checking for smmscrpt.dll in RemoteAccess registry key
//
if (1111 <= (osver.dwBuildNumber & 0xFFFF))
{
bRC = TRUE;
}
else
{
bRC = FALSE;
hkey = NULL;
lrc=RegOpenKey(HKEY_LOCAL_MACHINE,TEXT("System\\CurrentControlSet\\Services\\RemoteAccess\\Authentication\\SMM_FILES\\PPP"),&hkey);
if (ERROR_SUCCESS == lrc)
{
dwSize = sizeof(TCHAR)*MAX_PATH;
lrc = RegQueryValueEx(hkey,TEXT("Path"),0,&dwType,(LPBYTE)szData,&dwSize);
if (ERROR_SUCCESS == lrc)
{
if (0 == lstrcmpi(szData,TEXT("smmscrpt.dll")))
bRC = TRUE;
}
}
if (hkey)
RegCloseKey(hkey);
hkey = NULL;
}
//
// Verify that the DLL can be loaded
//
if (bRC)
{
hInst = LoadLibrary(TEXT("smmscrpt.dll"));
if (hInst)
FreeLibrary(hInst);
else
bRC = FALSE;
hInst = NULL;
}
}
return bRC;
}
//+----------------------------------------------------------------------------
//
// Function InstallScripter
//
// Synopsis Install scripting on win95 950.6 builds (not on OSR2)
//
// Arguments none
//
// Returns none
//
// History 10/9/96 ChrisK Copied from mt.cpp in \\trango sources
//
//-----------------------------------------------------------------------------
static void InstallScripter(void)
{
STARTUPINFO si;
PROCESS_INFORMATION pi;
MSG msg ;
DWORD iWaitResult = 0;
HINSTANCE hInst = LoadLibrary(TEXT("smmscrpt.dll"));
DebugOut("ISIGN32: Install Scripter.\r\n");
//
// Check if we need to install scripting
//
if (!IsScriptingInstalled())
{
TCHAR szCommandLine[] = TEXT("\"icwscrpt.exe\"");
memset(&pi, 0, sizeof(pi));
memset(&si, 0, sizeof(si));
if(!CreateProcess(NULL, szCommandLine, NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi))
{
DebugOut("ISIGN32: Cant find ICWSCRPT.EXE\r\n");
}
else
{
DebugOut("ISIGN32: Launched ICWSCRPT.EXE. Waiting for exit.\r\n");
//
// wait for event or msgs. Dispatch msgs. Exit when event is signalled.
//
while((iWaitResult=MsgWaitForMultipleObjects(1, &pi.hProcess, FALSE, INFINITE, QS_ALLINPUT))==(WAIT_OBJECT_0 + 1))
{
//
// read all of the messages in this next loop
// removing each message as we read it
//
while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
{
DebugOut("ISIGN32: Got msg\r\n");
//
// how to handle quit message?
//
if (msg.message == WM_QUIT)
{
DebugOut("ISIGN32: Got quit msg\r\n");
goto done;
}
else
DispatchMessage(&msg);
}
}
done:
CloseHandle(pi.hThread);
CloseHandle(pi.hProcess);
DebugOut("ISIGN32: ICWSCRPT.EXE done\r\n");
}
}
}
//+----------------------------------------------------------------------------
//
// Function: FGetSystemShutdownPrivledge
//
// Synopsis: For windows NT the process must explicitly ask for permission
// to reboot the system.
//
// Arguements: none
//
// Return: TRUE - privledges granted
// FALSE - DENIED
//
// History: 8/14/96 ChrisK Created
//
// Note: BUGBUG for Win95 we are going to have to softlink to these
// entry points. Otherwise the app won't even load.
// Also, this code was originally lifted out of MSDN July96
// "Shutting down the system"
//-----------------------------------------------------------------------------
static BOOL FGetSystemShutdownPrivledge()
{
HANDLE hToken = NULL;
TOKEN_PRIVILEGES tkp;
BOOL bRC = FALSE;
OSVERSIONINFO osver;
ZeroMemory(&osver,sizeof(osver));
osver.dwOSVersionInfoSize = sizeof(osver);
if (!GetVersionEx(&osver))
goto FGetSystemShutdownPrivledgeExit;
if (VER_PLATFORM_WIN32_NT == osver.dwPlatformId)
{
//
// Get the current process token handle
// so we can get shutdown privilege.
//
if (!OpenProcessToken(GetCurrentProcess(),
TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken))
goto FGetSystemShutdownPrivledgeExit;
//
// Get the LUID for shutdown privilege.
//
ZeroMemory(&tkp,sizeof(tkp));
LookupPrivilegeValue(NULL, SE_SHUTDOWN_NAME,
&tkp.Privileges[0].Luid);
tkp.PrivilegeCount = 1; /* one privilege to set */
tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
//
// Get shutdown privilege for this process.
//
AdjustTokenPrivileges(hToken, FALSE, &tkp, 0,
(PTOKEN_PRIVILEGES) NULL, 0);
if (ERROR_SUCCESS == GetLastError())
bRC = TRUE;
}
else
{
bRC = TRUE;
}
FGetSystemShutdownPrivledgeExit:
if (hToken) CloseHandle(hToken);
return bRC;
}
//+----------------------------------------------------------------------------
// Function VerifyRasServicesRunning
//
// Synopsis Make sure that the RAS services are enabled and running
//
// Arguments HWND - parent window
//
// Return FALSE - if the services couldn't be started
//
// History 10/16/96 ChrisK Created
//-----------------------------------------------------------------------------
typedef HRESULT (WINAPI *PFINETSTARTSERVICES)(void);
#define MAX_STRING 256
static BOOL VerifyRasServicesRunning(HWND hwnd)
{
HINSTANCE hInst = NULL;
FARPROC fp = NULL;
BOOL bRC = FALSE;
HRESULT hr = ERROR_SUCCESS;
hInst = LoadLibrary(TEXT("INETCFG.DLL"));
if (hInst)
{
fp = GetProcAddress(hInst, "InetStartServices");
if (fp)
{
//
// Check Services
//
hr = ((PFINETSTARTSERVICES)fp)();
if (ERROR_SUCCESS == hr)
{
bRC = TRUE;
}
else
{
//
// Report the erorr
//
TCHAR szMsg[MAX_STRING + 1];
LoadString(
ghInstance,
IDS_SERVICEDISABLED,
szMsg,
SIZEOF_TCHAR_BUFFER(szMsg));
//
// we reach here in the condition when
// 1) user deliberately removes some file
// 2) Did not reboot after installing RAS
// MKarki - (5/7/97) - Fix for Bug #4004
//
MessageBox(
hwnd,
szMsg,
cszAppName,
MB_OK| MB_ICONERROR | MB_SETFOREGROUND
);
bRC = FALSE;
}
}
FreeLibrary(hInst);
}
#if !defined(WIN16)
if (bRC)
{
SetControlFlags(SCF_RASREADY);
}
else
{
ClearControlFlags(SCF_RASREADY);
}
#endif
return bRC;
}
//+----------------------------------------------------------------------------
//
// Function GetDeviceSelectedByUser
//
// Synopsis Get the name of the RAS device that the user had already picked
//
// Arguements szKey - name of sub key
// szBuf - pointer to buffer
// dwSize - size of buffer
//
// Return TRUE - success
//
// History 10/24/96 ChrisK Created
//-----------------------------------------------------------------------------
static BOOL GetDeviceSelectedByUser (LPTSTR szKey, LPTSTR szBuf, DWORD dwSize)
{
BOOL bRC = FALSE;
HKEY hkey = NULL;
DWORD dwType = 0;
if (ERROR_SUCCESS == RegOpenKey(HKEY_LOCAL_MACHINE,
ISIGNUP_KEY,&hkey))
{
if (ERROR_SUCCESS == RegQueryValueEx(hkey,szKey,0,&dwType,
(LPBYTE)szBuf,&dwSize))
bRC = TRUE;
}
if (hkey)
RegCloseKey(hkey);
return bRC;
}
//+----------------------------------------------------------------------------
// Function SetDeviceSelectedByUser
//
// Synopsis Write user's device selection to registry
//
// Arguments szKey - name of key
// szBuf - data to write to key
//
// Returns TRUE - success
//
// History 10/24/96 ChrisK Created
//-----------------------------------------------------------------------------
static BOOL SetDeviceSelectedByUser (LPTSTR szKey, LPTSTR szBuf)
{
BOOL bRC = FALSE;
HKEY hkey = 0;
if (ERROR_SUCCESS == RegOpenKey(HKEY_LOCAL_MACHINE,
ISIGNUP_KEY,&hkey))
{
if (ERROR_SUCCESS == RegSetValueEx(hkey,szKey,0,REG_SZ,
(LPBYTE)szBuf,sizeof(TCHAR)*lstrlen(szBuf)))
bRC = TRUE;
}
if (hkey)
RegCloseKey(hkey);
return bRC;
}
//+----------------------------------------------------------------------------
// Funciton DeleteUserDeviceSelection
//
// Synopsis Remove registry keys with device selection
//
// Arguments szKey - name of value to remove
//
// Returns TRUE - success
//
// History 10/24/96 ChrisK Created
//-----------------------------------------------------------------------------
static BOOL DeleteUserDeviceSelection(LPTSTR szKey)
{
BOOL bRC = FALSE;
HKEY hkey = NULL;
if (ERROR_SUCCESS == RegOpenKey(HKEY_LOCAL_MACHINE,
ISIGNUP_KEY,&hkey))
{
bRC = (ERROR_SUCCESS == RegDeleteValue(hkey,szKey));
RegCloseKey(hkey);
}
return bRC;
}
//+---------------------------------------------------------------------------
//
// Function: ConfigRasEntryDevice()
//
// Synopsis: Checks whether user has already specified a modem to use;
// If so, verifies that modem is valid.
// If not, or if modem is invalid, presents user a dialog
// to choose which modem to use (if only one modem is installed,
// it automaticaly selects that device and bypasses the dialog)
//
// Arguments: lpRasEntry - Pointer to the RasEntry whose szDeviceName and
// szDeviceType members you wish to verify/configure
//
// Returns: ERROR_CANCELLED - Had to bring up "Choose Modem" dialog, and
// and user hit its "Cancel" button
// Otherwise returns any error code encountered.
// ERROR_SUCCESS indicates success.
//
// History: 5/18/96 VetriV Created
//
//----------------------------------------------------------------------------
DWORD ConfigRasEntryDevice( LPRASENTRY lpRasEntry )
{
DWORD dwRet = ERROR_SUCCESS;
CEnumModem EnumModem;
GetDeviceSelectedByUser(DEVICENAMEKEY, g_szDeviceName, sizeof(g_szDeviceName));
GetDeviceSelectedByUser(DEVICETYPEKEY, g_szDeviceType, sizeof(g_szDeviceType));
dwRet = EnumModem.GetError();
if (ERROR_SUCCESS != dwRet)
{
return dwRet;
}
// If there are no modems, we're horked
if (0 == EnumModem.GetNumDevices())
{
DebugOut("ISIGN32: import.cpp: ConfigRasEntryDevice: ERROR: No modems installed!\n");
//
// ChrisK Olympus 6796 6/24/97
// If there is no modem currently configured, there will be by the time the
// connectoid is created.
//
return ERROR_SUCCESS;
}
// Validate the device if possible
if ( lpRasEntry->szDeviceName[0] && lpRasEntry->szDeviceType[0] )
{
// 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 ( lpRasEntry->szDeviceName[0] )
{
// 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 ( lpRasEntry->szDeviceType[0] )
{
// 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, check whether the user has already made a choice.
// if not, 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( !(lpRasEntry->szDeviceName[0]) ||
!(lpRasEntry->szDeviceType[0]) )
{
DebugOut("ISIGN32: ConfigRasEntryDevice: no valid device passed in\n");
if( g_szDeviceName[0] )
{
// it looks like we have already stored the user's choice.
// store the DeviceName in lpRasEntry, then call GetDeviceTypeFromName
// to confirm that the deviceName we saved actually exists on the system
lstrcpy(lpRasEntry->szDeviceName, g_szDeviceName);
if( 0 == lstrcmp(EnumModem.GetDeviceTypeFromName(lpRasEntry->szDeviceName),
g_szDeviceType) )
{
//DebugOut("ISIGN32: ConfigRasEntryDevice using previously stored choice, '%s'\n",
// g_szDeviceName);
lstrcpy(lpRasEntry->szDeviceType, g_szDeviceType);
return ERROR_SUCCESS;
}
else
{
// whatever we previously stored has somehow gone bad; fall through to code below
//DebugOut("ISIGN32: ConfigRasEntryDevice: previously stored choice '%s' is not valid\n",
// g_szDeviceName);
}
}
if (1 == EnumModem.GetNumDevices())
{
// There is just one device installed, so copy the name
DebugOut("ISIGN32: import.cpp: ConfigRasEntryDevice: only one modem installed, using it\n");
lstrcpy (lpRasEntry->szDeviceName, EnumModem.Next());
}
else
{
DebugOut("ISIGN32: import.cpp: ConfigRasEntryDevice: multiple modems detected\n");
// structure to pass to dialog to fill out
CHOOSEMODEMDLGINFO ChooseModemDlgInfo;
// Display a dialog and allow the user to select modem
// TODO: is g_hWndMain the right thing to use for parent?
int iRet = (int)DialogBoxParam(
GetModuleHandle(TEXT("ISIGN32.DLL")),
MAKEINTRESOURCE(IDD_CHOOSEMODEMNAME),
pDynShare->hwndMain,
ChooseModemDlgProc,
(LPARAM) &ChooseModemDlgInfo);
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;
}
}
// 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));
}
lstrcpy(g_szDeviceName, lpRasEntry->szDeviceName);
lstrcpy(g_szDeviceType, lpRasEntry->szDeviceType);
// Save data in registry
SetDeviceSelectedByUser(DEVICENAMEKEY, g_szDeviceName);
SetDeviceSelectedByUser (DEVICETYPEKEY, g_szDeviceType);
return dwRet;
}
//+----------------------------------------------------------------------------
// Function RasDial1Callback
//
// Synopsis This function will be called with RAS status information.
// For most message this function will simply pass the data on to
// the hwnd in the dialer. However, if the connection is dropped
// unexpectedly then the function will allow the user to
// reconnect. Note, the reconnection only applies to NT since
// win95 machines will automatically handle this.
//
// Arguments hrasconn, // handle to RAS connection
// unMsg, // type of event that has occurred
// rascs, // connection state about to be entered
// dwError, // error that may have occurred
// dwExtendedError // extended error information for some errors
// (See RasDialFunc for more details)
//
// Returns none
//
// History 10/28/96 ChrisK Created
//-----------------------------------------------------------------------------
VOID WINAPI RasDial1Callback(
HRASCONN hrasconn, // handle to RAS connection
UINT unMsg, // type of event that has occurred
RASCONNSTATE rascs, // connection state about to be entered
DWORD dwError, // error that may have occurred
DWORD dwExtendedError // extended error information for some errors
)
{
static BOOL fIsConnected = FALSE;
static HWND hwndDialDlg = NULL;
static DWORD dwPlatformId = 0xFFFFFFFF;
static UINT unRasMsg = 0;
OSVERSIONINFO osver;
HANDLE hThread = INVALID_HANDLE_VALUE;
DWORD dwTID = 0;
//
// Initial registration
//
if (WM_RegisterHWND == unMsg)
{
//
// dwError actually contains an HWND in this case.
//
if (hwndDialDlg)
{
DebugOut("ISIGN32: ERROR hwndDialDlg is not NULL.\r\n");
}
if (fIsConnected)
{
DebugOut("ISIGN32: ERROR fIsConnected is not FALSE.\r\n");
}
if (0xFFFFFFFF != dwPlatformId)
{
DebugOut("ISIGN32: ERROR dwPlatformId is not initial value.\r\n");
}
//
// Remember HWND value
//
hwndDialDlg = (HWND)UlongToPtr(dwError);
//
// Determine the current platform
//
ZeroMemory(&osver,sizeof(osver));
osver.dwOSVersionInfoSize = sizeof(osver);
if (GetVersionEx(&osver))
dwPlatformId = osver.dwPlatformId;
//
// Figure out ras event value
//
unRasMsg = RegisterWindowMessageA(RASDIALEVENT);
if (unRasMsg == 0) unRasMsg = WM_RASDIALEVENT;
//
// Don't call into the HWND if this is the initial call
//
goto RasDial1CallbackExit;
}
//
// Remember if the connection was successfull
//
if (RASCS_Connected == rascs)
{
fIsConnected = TRUE;
if (VER_PLATFORM_WIN32_NT == dwPlatformId)
{
hThread = CreateThread(NULL,0,
(LPTHREAD_START_ROUTINE)StartNTReconnectThread,
(LPVOID)hrasconn,0,&dwTID);
if (hThread)
CloseHandle(hThread);
else
DebugOut("ISIGN32: Failed to start reconnect thread.\r\n");
}
}
//
// Pass the message on to the Dialing dialog
//
if (IsWindow(hwndDialDlg))
{
if (WM_RASDIALEVENT == unMsg)
{
if (0 == unRasMsg)
{
DebugOut("ISIGN32: ERROR we are about to send message 0. Very bad...\r\n");
}
SendMessage(hwndDialDlg,unRasMsg,(WPARAM)rascs,(LPARAM)dwError);
}
else
{
SendMessage(hwndDialDlg,unMsg,(WPARAM)rascs,(LPARAM)dwError);
}
}
RasDial1CallbackExit:
return;
}
//+----------------------------------------------------------------------------
// Function SLRasConnectionNotification
//
// Synopsis Soft link to RasConnectionNotification
//
// Arguments hrasconn - handle to connection
// hEvent - handle to event
// dwFlags - flags to determine the type of notification
//
// Returns ERROR_SUCCESS - if successful
//
// History 10/29/96 ChrisK Created
//-----------------------------------------------------------------------------
typedef DWORD (APIENTRY *PFNRASCONNECTIONNOTIFICATION)( HRASCONN, HANDLE, DWORD );
// 1/7/96 jmazner already defined in ras2.h
//#define RASCN_Disconnection 2
#define CONNECT_CHECK_INTERVAL 500
static DWORD SLRasConnectionNotification(HRASCONN hrasconn, HANDLE hEvent, DWORD dwFlags)
{
DWORD dwRC = ERROR_DLL_NOT_FOUND;
FARPROC fp = NULL;
HINSTANCE hinst = NULL;
if(hinst = LoadLibrary(TEXT("RASAPI32.DLL")))
#ifdef UNICODE
if (fp = GetProcAddress(hinst,"RasConnectionNotificationW"))
#else
if (fp = GetProcAddress(hinst,"RasConnectionNotificationA"))
#endif
dwRC = ((PFNRASCONNECTIONNOTIFICATION)fp)(hrasconn, hEvent, dwFlags);
if (hinst)
FreeLibrary(hinst);
return dwRC;
}
//+----------------------------------------------------------------------------
// Function IsConnectionClosed
//
// Synopsis Given a particular connection handle, determine if the
// connection is still valid
//
// Arguments hrasconn - handle to the connection to be checked
//
// Returns TRUE - if the connection is closed
//
// History 10/29/96 ChrisK Created
//-----------------------------------------------------------------------------
static BOOL IsConnectionClosed(HRASCONN hrasconn)
{
BOOL bRC = FALSE;
LPRASCONN lprasconn = NULL;
DWORD dwSize = 0;
DWORD cConnections = 0;
DWORD dwRet = 0;
//
// Make sure the DLL is loaded
//
if (!lpfnRasEnumConnections)
if (!LoadRnaFunctions(NULL))
goto IsConnectionClosedExit;
//
// Get list of current connections
//
lprasconn = (LPRASCONN)GlobalAlloc(GPTR,sizeof(RASCONN));
if (!lprasconn)
goto IsConnectionClosedExit;
lprasconn->dwSize = dwSize = sizeof(RASCONN);
cConnections = 0;
dwRet = lpfnRasEnumConnections(lprasconn, &dwSize, &cConnections);
if (ERROR_BUFFER_TOO_SMALL == dwRet)
{
GlobalFree(lprasconn);
lprasconn = (LPRASCONN)GlobalAlloc(GPTR,dwSize);
if (!lprasconn)
goto IsConnectionClosedExit;
lprasconn->dwSize = dwSize;
dwRet = lpfnRasEnumConnections(lprasconn, &dwSize, &cConnections);
}
if (ERROR_SUCCESS != dwRet)
goto IsConnectionClosedExit;
//
// Check to see if the handle matches
//
while (cConnections)
{
if (lprasconn[cConnections-1].hrasconn == hrasconn)
goto IsConnectionClosedExit; // The connection is still open
cConnections--;
}
bRC = TRUE;
IsConnectionClosedExit:
if (lprasconn)
GlobalFree(lprasconn);
return bRC;
}
//+----------------------------------------------------------------------------
// Function StartNTReconnectThread
//
// Synopsis This function will detect when the connection has been dropped
// unexpectedly and it will then offer the user a chance to
// reconnect
//
// Arguments hrasconn - the connection to be watched
//
// Returns none
//
// History 10/29/96 ChrisK Created
//-----------------------------------------------------------------------------
DWORD WINAPI StartNTReconnectThread (HRASCONN hrasconn)
{
TCHAR szEntryName[RAS_MaxEntryName + 1];
DWORD dwRC = 0;
//
// Validate state
//
if (NULL == hrasconn)
goto StartNTReconnectThreadExit;
if (TestControlFlags(SCF_RECONNECTTHREADQUITED) != FALSE)
goto StartNTReconnectThreadExit;
if (NULL != pDynShare->hReconnectEvent)
goto StartNTReconnectThreadExit;
//
// Register Event
//
pDynShare->hReconnectEvent = CreateEvent(NULL,FALSE,FALSE,NULL);
if (NULL == pDynShare->hReconnectEvent)
goto StartNTReconnectThreadExit;
if (0 != SLRasConnectionNotification(hrasconn, pDynShare->hReconnectEvent,RASCN_Disconnection))
goto StartNTReconnectThreadExit;
//
// Wait for event
//
do {
dwRC = WaitForSingleObject(pDynShare->hReconnectEvent,CONNECT_CHECK_INTERVAL);
if (WAIT_FAILED == dwRC)
{
DebugOut("ISIGN32: Quitting reconnect thread because wait failed.\r\n");
goto StartNTReconnectThreadExit;
}
} while ((WAIT_TIMEOUT == dwRC) && !IsConnectionClosed(hrasconn));
//
// Clear values
//
hrasconn = NULL;
CloseHandle(pDynShare->hReconnectEvent);
pDynShare->hReconnectEvent = NULL;
//
// Determine if we should offer to reconnect
//
if (FALSE != TestControlFlags(SCF_RECONNECTTHREADQUITED))
{
DebugOut("ISIGN32: Quitting reconnect thread because app is quitting.\r\n");
goto StartNTReconnectThreadExit;
}
else if (FALSE == TestControlFlags(SCF_HANGUPEXPECTED))
{
DebugOut("ISIGN32: Reconnect thread will ask about reconnecting.\r\n");
TCHAR szMsg[MAX_STRING + 1];
//
// Prompt user
//
LoadString(ghInstance,IDS_RECONNECT_QUERY,szMsg,SIZEOF_TCHAR_BUFFER(szMsg));
if (IDYES == MessageBox(
pDynShare->hwndMain,
szMsg,
cszAppName,
MB_SETFOREGROUND | MB_ICONEXCLAMATION | MB_YESNO))
{
//
// Reconnect
//
if (ERROR_USERNEXT != DialConnection(pDynShare->szISPFile))
{
DebugOut("ISIGN32: Quitting reconnect thread because user canceled dialing.\r\n");
KillConnection();
InfoMsg(NULL, IDS_SIGNUPCANCELLED);
PostMessage(pDynShare->hwndMain, WM_CLOSE, 0, 0);
goto StartNTReconnectThreadExit;
}
}
else
{
//
// Forget it, we're out of here (close down signup)
//
KillConnection();
InfoMsg(NULL, IDS_SIGNUPCANCELLED);
PostMessage(pDynShare->hwndMain, WM_CLOSE, 0, 0);
DebugOut("ISIGN32: Quitting reconnect thread because user doesn't want to reconnect.\r\n");
goto StartNTReconnectThreadExit;
}
}
StartNTReconnectThreadExit:
return 1;
}
//+----------------------------------------------------------------------------
// Function IsSingleInstance and ReleaseSingleInstance
//
// Synopsis These two function check to see if another instance of isignup
// is already running. ISign32 does have to allow mutliple instances
// to run in order to handle the .INS files, but in other instances
// there should only be one copy running at a time
//
// Arguments bProcessingINS -- are we in the .ins path?
//
// Returns IsSingleInstance - TRUE - this is the first instance
// ReleaseSingleInstance - none
//
// History 11/1/96 ChrisK Created
// 12/3/96 jmazner Modified to allow the processINS path to create
// a semaphore (to prevent others from running),
// but to not check whether the create succeeded.
//-----------------------------------------------------------------------------
// superceded by definition in semaphor.h
//#define SEMAPHORE_NAME "Internet Connection Wizard ISIGNUP.EXE"
BOOL IsSingleInstance(BOOL bProcessingINS)
{
g_hSemaphore = CreateSemaphore(NULL, 1, 1, ICW_ELSE_SEMAPHORE);
DWORD dwErr = GetLastError();
if( ERROR_ALREADY_EXISTS == dwErr )
{
g_hSemaphore = NULL;
if( !bProcessingINS )
IsAnotherComponentRunning32( NULL );
return FALSE;
}
return TRUE;
}
void ReleaseSingleInstance()
{
if (g_hSemaphore)
{
CloseHandle(g_hSemaphore);
g_hSemaphore = NULL;
}
return;
}
//+---------------------------------------------------------------------------
//
// Function: IsAnotherComponentRunning32()
//
// Synopsis: Checks if there's another ICW component already
// running. If so, it will set focus to that component's window.
//
// This functionality is needed by all of our .exe's. However,
// the actual components to check for differ between .exe's.
// The comment COMPONENT SPECIFIC designates lines of code
// that vary between components' source code.
//
// For ISIGN32, this function only gets called if we couldn't create
// the ICW_ELSE semaphore, so all we need to do here is find the
// other running ICW_ELSE component and bring it to the foreground.
//
// Arguments: bUnused -- not used in this component
//
// Returns: TRUE if another component is already running
// FALSE otherwise
//
// History: 12/3/96 jmazner Created, with help from IsAnotherInstanceRunning
// in icwconn1\connmain.cpp
//
//----------------------------------------------------------------------------
BOOL IsAnotherComponentRunning32(BOOL bUnused)
{
HWND hWnd = NULL;
HANDLE hSemaphore = NULL;
DWORD dwErr = 0;
// for isignup, we only get here if we failed to create the ICW_ELSE semaphore
// try and bring focus to the IE window if we have one
if( pDynShare->hwndBrowser )
{
SetFocus(pDynShare->hwndBrowser);
SetForegroundWindow(pDynShare->hwndBrowser);
}
else
{
// if that didn't work, try finding a conn2 or inetwiz instance
// Bring the running instance's window to the foreground
// if conn1 is running, we may accidentaly bring it to the foreground,
// since it shares a window name with conn2 and inetwiz. oh well.
hWnd = FindWindow(DIALOG_CLASS_NAME, cszAppName);
if( hWnd )
{
SetFocus(hWnd);
SetForegroundWindow(hWnd);
}
}
return TRUE;
/**
if( hWnd || hwndBrowser )
{
return TRUE;
}
else
{
return FALSE;
}
**/
}
#endif //!WIN16
#if !defined(WIN16)
//+----------------------------------------------------------------------------
//
// Function SetStartUpCommand
//
// Synopsis On an NT machine the RunOnce method is not reliable. Therefore
// we will restart the ICW by placing a .BAT file in the common
// startup directory.
//
// Arguments lpCmd - command line used to restart the ICW
//
// Returns TRUE if it worked
// FALSE otherwise.
//
// History 1-10-97 ChrisK Created
//
//-----------------------------------------------------------------------------
static const TCHAR cszICW_StartFileName[] = TEXT("ICWStart.bat");
static const TCHAR cszICW_StartCommand[] = TEXT("@start ");
static const TCHAR cszICW_DummyWndName[] = TEXT("\"ICW\" ");
static const TCHAR cszICW_ExitCommand[] = TEXT("\r\n@exit");
BOOL SetStartUpCommand(LPTSTR lpCmd)
{
BOOL bRC = FALSE;
HANDLE hFile = INVALID_HANDLE_VALUE ;
DWORD dwWLen; // dummy variable used to make WriteFile happy
TCHAR szCommandLine[MAX_PATH + 1];
LPITEMIDLIST lpItemDList = NULL;
HRESULT hr = ERROR_SUCCESS;
IMalloc *pMalloc = NULL;
// build full filename
// NOTE: the memory allocated for lpItemDList is leaked. We are not real
// concerned about this since this code is only run once and then the
// system is restarted. In order to free the memory appropriately
// this code would have to call SHGetMalloc to retrieve the shell's IMalloc
// implementation and then free the memory.
hr = SHGetSpecialFolderLocation(NULL,CSIDL_COMMON_STARTUP,&lpItemDList);
if (ERROR_SUCCESS != hr)
goto SetStartUpCommandExit;
if (FALSE == SHGetPathFromIDList(lpItemDList, szCommandLine))
goto SetStartUpCommandExit;
//
// Free up the memory allocated for LPITEMIDLIST
// because seems like we are clobberig something later
// by not freeing this
//
hr = SHGetMalloc (&pMalloc);
if (SUCCEEDED (hr))
{
pMalloc->Free (lpItemDList);
pMalloc->Release ();
}
// make sure there is a trailing \ character
if ('\\' != szCommandLine[lstrlen(szCommandLine)-1])
lstrcat(szCommandLine,TEXT("\\"));
lstrcat(szCommandLine,cszICW_StartFileName);
// Open file
hFile = CreateFile(szCommandLine,GENERIC_WRITE,0,0,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL |
FILE_FLAG_WRITE_THROUGH,NULL);
if (INVALID_HANDLE_VALUE == hFile)
goto SetStartUpCommandExit;
// Write the restart commands to the file
if (FALSE == WriteFile(hFile,cszICW_StartCommand,lstrlen(cszICW_StartCommand),&dwWLen,NULL))
goto SetStartUpCommandExit;
// 1/20/96 jmazner Normandy #13287
// Start command considers the first thing it sees in quotes to be a window title
// So, since our path is in quotes, put in a fake window title
if (FALSE == WriteFile(hFile,cszICW_DummyWndName,lstrlen(cszICW_DummyWndName),&dwWLen,NULL))
goto SetStartUpCommandExit;
if (FALSE == WriteFile(hFile,lpCmd,lstrlen(lpCmd),&dwWLen,NULL))
goto SetStartUpCommandExit;
if (FALSE == WriteFile(hFile,cszICW_ExitCommand,lstrlen(cszICW_ExitCommand),&dwWLen,NULL))
goto SetStartUpCommandExit;
bRC = TRUE;
SetStartUpCommandExit:
// Close handle and exit
if (INVALID_HANDLE_VALUE != hFile)
CloseHandle(hFile);
return bRC;
}
//+----------------------------------------------------------------------------
//
// Function: DeleteStartUpCommand
//
// Synopsis: After restart the ICW we need to delete the .bat file from
// the common startup directory
//
// Arguements: None
//
// Returns: None
//
// History: 1-10-97 ChrisK Created
//
//-----------------------------------------------------------------------------
void DeleteStartUpCommand ()
{
TCHAR szStartUpFile[MAX_PATH + 1];
LPITEMIDLIST lpItemDList = NULL;
HRESULT hr = ERROR_SUCCESS;
IMalloc *pMalloc = NULL;
// build full filename
// NOTE: the memory allocated for lpItemDList is leaked. We are not real
// concerned about this since this code is only run once and then the
// system is restarted. In order to free the memory appropriately
// this code would have to call SHGetMalloc to retrieve the shell's IMalloc
// implementation and then free the memory.
hr = SHGetSpecialFolderLocation(NULL,CSIDL_COMMON_STARTUP,&lpItemDList);
if (ERROR_SUCCESS != hr)
goto DeleteStartUpCommandExit;
if (FALSE == SHGetPathFromIDList(lpItemDList, szStartUpFile))
goto DeleteStartUpCommandExit;
//
// Free up the memory allocated for LPITEMIDLIST
// because seems like we are clobberig something later
// by not freeing this
//
hr = SHGetMalloc (&pMalloc);
if (SUCCEEDED (hr))
{
pMalloc->Free (lpItemDList);
pMalloc->Release ();
}
// make sure there is a trailing \ character
if ('\\' != szStartUpFile[lstrlen(szStartUpFile)-1])
lstrcat(szStartUpFile,TEXT("\\"));
lstrcat(szStartUpFile,cszICW_StartFileName);
DeleteFile(szStartUpFile);
DeleteStartUpCommandExit:
return;
}
#endif //!Win16
#ifdef WIN32
BOOL GetICWCompleted( DWORD *pdwCompleted )
{
HKEY hKey = NULL;
DWORD dwSize = sizeof(DWORD);
HRESULT hr = RegOpenKey(HKEY_CURRENT_USER,ICWSETTINGSPATH,&hKey);
if (ERROR_SUCCESS == hr)
{
hr = RegQueryValueEx(hKey, ICWCOMPLETEDKEY, 0, NULL,
(BYTE*)pdwCompleted, &dwSize);
RegCloseKey(hKey);
}
if( ERROR_SUCCESS == hr )
return TRUE;
else
return FALSE;
}
BOOL SetICWCompleted( DWORD dwCompleted )
{
HKEY hKey = NULL;
HRESULT hr = RegCreateKey(HKEY_CURRENT_USER,ICWSETTINGSPATH,&hKey);
if (ERROR_SUCCESS == hr)
{
hr = RegSetValueEx(hKey, ICWCOMPLETEDKEY, 0, REG_DWORD,
(CONST BYTE*)&dwCompleted, sizeof(dwCompleted));
RegCloseKey(hKey);
}
if( ERROR_SUCCESS == hr )
return TRUE;
else
return FALSE;
}
#endif
#ifdef WIN32
//+----------------------------------------------------------------------------
//
// Function: CreateSecurityPatchBackup
//
// Synopsis: Creates a .reg file to restore security settings, and installs
// the filenmae into the RunOnce reg keys.
//
// Arguements: None
//
// Returns: None
//
// History: 8/7/97 jmazner Created for Olympus #6059
//
//-----------------------------------------------------------------------------
BOOL CreateSecurityPatchBackup( void )
{
Dprintf("ISIGN32: CreateSecurityPatchBackup\n");
HKEY hKey = NULL;
TCHAR szPath[MAX_PATH + 1] = TEXT("\0");
HANDLE hSecureRegFile = INVALID_HANDLE_VALUE;
TCHAR szRegText[1024];
TCHAR szRunOnceEntry[1024];
DWORD dwBytesWritten = 0;
if (0 == GetTempPath(MAX_PATH,szPath))
{
//
// if GetTempPath Failed, use the current directory
//
if (0 == GetCurrentDirectory (MAX_PATH, szPath))
{
Dprintf("ISIGN32: unable to get temp path or current directory!\n");
return FALSE;
}
}
//
// Get the name of the temporary file
//
if (0 == GetTempFileName(szPath, TEXT("hyjk"), 0, pDynShare->szFile))
{
//
// If we failed, probably, the TMP directory does not
// exist, we should use the current directory
// MKarki (4/27/97) - Fix for Bug #3504
//
if (0 == GetCurrentDirectory (MAX_PATH, szPath))
{
return FALSE;
}
//
// try getting the temp file name again
//
if (0 == GetTempFileName(szPath, TEXT("hyjk"), 0, pDynShare->szFile))
{
return FALSE;
}
}
hSecureRegFile = CreateFile(pDynShare->szFile,
GENERIC_WRITE,
0, //no sharing
NULL, //no inheritance allowed
CREATE_ALWAYS,
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_WRITE_THROUGH,
NULL //no template file
);
if (INVALID_HANDLE_VALUE == hSecureRegFile)
{
Dprintf("ISIGN32: unable to createFile secureRegFile %s\n", pDynShare->szFile);
return FALSE;
}
else
{
Dprintf("ISIGN32: writing secureRegFile %s\n",pDynShare->szFile );
ZeroMemory( szRegText, 1023 );
dwBytesWritten = 0;
lstrcpy(szRegText, TEXT("REGEDIT4\n\n"));
lstrcat(szRegText, TEXT("[HKEY_CLASSES_ROOT\\.ins]\n"));
lstrcat(szRegText, TEXT("\"EditFlags\"=hex:00,00,00,00\n\n"));
lstrcat(szRegText, TEXT("[HKEY_CLASSES_ROOT\\.isp]\n"));
lstrcat(szRegText, TEXT("\"EditFlags\"=hex:00,00,00,00\n\n"));
lstrcat(szRegText, TEXT("[HKEY_CLASSES_ROOT\\x-internet-signup]\n"));
lstrcat(szRegText, TEXT("\"EditFlags\"=hex:00,00,00,00\n\n"));
//
// ChrisK Olympus 6198 6/10/97
//
lstrcat(szRegText, TEXT("[HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings\\Zones\\3]\n"));
lstrcat(szRegText, TEXT("\"1601\"=dword:"));
TCHAR szZoneSetting[16];
wsprintf(szZoneSetting,TEXT("%08x\n\n"),g_dwZone_1601);
lstrcat(szRegText, szZoneSetting);
WriteFile(hSecureRegFile, (LPVOID) &szRegText[0], lstrlen(szRegText),
&dwBytesWritten, NULL );
CloseHandle(hSecureRegFile);
hSecureRegFile = INVALID_HANDLE_VALUE;
Dprintf("ISIGN32: installing security RunOnce entry\n");
ZeroMemory(szRunOnceEntry, 1023 );
wsprintf(szRunOnceEntry, TEXT("regedit /s \"%s\""), pDynShare->szFile);
if (ERROR_SUCCESS == RegOpenKey(HKEY_LOCAL_MACHINE,TEXT("Software\\Microsoft\\Windows\\CurrentVersion\\RunOnce"),&hKey))
{
RegSetValueEx(hKey,TEXT("hyjk"),(DWORD)NULL,(DWORD)REG_SZ,
(BYTE*)szRunOnceEntry,sizeof(TCHAR)*lstrlen(szRunOnceEntry));
RegCloseKey(hKey);
hKey = NULL;
}
}
return TRUE;
}
//+----------------------------------------------------------------------------
//
// Function: RestoreSecurityPatch
//
// Synopsis: Reset the EditFlags for our file types to indicate that these
// files are not safe. Remove the runOnce we set as a backup.
//
// Arguements: None
//
// Returns: None
//
// History: 3/11/97 jmazner created for Olympus #1545
//
//-----------------------------------------------------------------------------
VOID RestoreSecurityPatch( void )
{
HKEY hKey = NULL;
TCHAR szTemp[4];
hKey = NULL;
szTemp[0] = (TCHAR)0;
szTemp[1] = (TCHAR)0;
szTemp[2] = (TCHAR)0;
szTemp[3] = (TCHAR)0;
Dprintf("ISIGN32: Restoring EditFlags settings\n");
// Mark various registry entries as unsafe.
if (ERROR_SUCCESS == RegOpenKey(HKEY_CLASSES_ROOT,TEXT("x-internet-signup"),&hKey))
{
RegSetValueEx(hKey,TEXT("EditFlags"),(DWORD)NULL,(DWORD)REG_BINARY,(BYTE*)&szTemp[0],(DWORD)4);
RegCloseKey(hKey);
}
if (ERROR_SUCCESS == RegOpenKey(HKEY_CLASSES_ROOT,TEXT(".ins"),&hKey))
{
RegSetValueEx(hKey,TEXT("EditFlags"),(DWORD)NULL,(DWORD)REG_BINARY,(BYTE*)&szTemp[0],(DWORD)4);
RegCloseKey(hKey);
}
if (ERROR_SUCCESS == RegOpenKey(HKEY_CLASSES_ROOT,TEXT(".isp"),&hKey))
{
RegSetValueEx(hKey,TEXT("EditFlags"),(DWORD)NULL,(DWORD)REG_BINARY,(BYTE*)&szTemp[0],(DWORD)4);
RegCloseKey(hKey);
}
//
// ChrisK Olympus 6198 6/10/97
// replace HTML form submission value.
//
if (g_fReadZone &&
ERROR_SUCCESS == RegOpenKey(HKEY_CURRENT_USER,REG_ZONE3_KEY,&hKey))
{
//
// Set value for zone to initial value.
//
RegSetValueEx(hKey,
REG_ZONE1601_KEY,
NULL,
REG_DWORD,
(LPBYTE)&g_dwZone_1601,
sizeof(g_dwZone_1601));
RegCloseKey(hKey);
}
// Remove run once key
if (ERROR_SUCCESS == RegOpenKey(HKEY_LOCAL_MACHINE,TEXT("Software\\microsoft\\Windows\\CurrentVersion\\RunOnce"),&hKey))
{
RegDeleteValue(hKey,TEXT("hyjk"));
RegCloseKey(hKey);
}
// Remove reg file
DeleteFile(pDynShare->szFile);
}
#endif
#ifdef WIN32
//++--------------------------------------------------------------
//
// Function: RemoveQuotes
//
// Synopsis: This Function strips the file name in the command
// line of its quote
// Fix For Bug #4049
//
// Arguments: [IN] PTSTR - pointer to command line
//
// Returns: VOID
//
// Called By: Signup Function
//
// History: MKarki Created 5/1/97
//
//----------------------------------------------------------------
VOID
RemoveQuotes (
LPTSTR pCommandLine
)
{
const TCHAR QUOTE = '"';
const TCHAR SPACE = ' ';
const TCHAR NIL = '\0';
TCHAR * pTemp = NULL;
if (NULL == pCommandLine)
return;
//
// find the starting quote first
// do we care for MBCS/UNICODE ?
//
pTemp = _tcschr (pCommandLine, QUOTE);
if (NULL != pTemp)
{
//
// replace the quote with a space
//
*pTemp = SPACE;
//
// search for the ending quote now
//
pTemp = _tcsrchr (pCommandLine, QUOTE);
if (NULL != pTemp)
{
//
// end the string here
//
*pTemp = NIL;
}
}
return;
} // end of RemoveQuotes function
#endif
//++--------------------------------------------------------------
//
// Function: IEAKProcessISP
//
// Synopsis: A hacked version of ProcessISP, intended for use
// by the IEAK folks. The function will create a
// connectoid and establish a connection in the same
// manner as ProcsesISP. However, once the connection
// is established, we will execute the command in the
// [Entry] Run= section and exit
//
// This function does _not_ wait around for the
// .exe that it launches, and thus does _not_ kill the
// dial-up connection. It's up to the calling app to
// worry about that.
//
// Arguments: [IN] hwnd - handle of parent window
// [IN] LPCTSTR - pointer to path to .isp file
//
// Returns: TRUE if able to create the connectoid and dial
// FALSE otherwise
//
//
// History: 5/23/97 jmazner Created for Olympus #4679
//
//----------------------------------------------------------------
#ifdef WIN16
extern "C" BOOL WINAPI __export IEAKProcessISP(HWND hwnd, LPCTSTR lpszFile)
#else
#ifdef UNICODE
BOOL EXPORT WINAPI IEAKProcessISPW(HWND, LPCTSTR);
BOOL EXPORT WINAPI IEAKProcessISPA
(
HWND hwnd,
LPCSTR lpszFile
)
{
TCHAR szFile[MAX_PATH+1];
mbstowcs(szFile, lpszFile, lstrlenA(lpszFile)+1);
return IEAKProcessISPW(hwnd, szFile);
}
BOOL EXPORT WINAPI IEAKProcessISPW
#else
BOOL EXPORT WINAPI IEAKProcessISPA
#endif
(
HWND hwnd,
LPCTSTR lpszFile
)
#endif
{
TCHAR szSignupURL[MAX_URL + 1];
#if !defined(WIN16)
HKEY hKey;
GATHEREDINFO gi;
#endif //!WIN16
#if !defined(WIN16)
if (!IsSingleInstance(FALSE))
return FALSE;
#endif
if (!LoadInetFunctions(hwnd))
{
Dprintf("ISIGN32: IEAKProcessISP couldn't load INETCFG.DLL!");
return FALSE;
}
#if !defined(WIN16)
// Make sure the isp file exists before setting up stack.
if (0xFFFFFFFF == GetFileAttributes(lpszFile))
{
DWORD dwFileErr = GetLastError();
Dprintf("ISIGN32: ProcessISP couldn't GetAttrib for %s, error = %d",
lpszFile, dwFileErr);
if( ERROR_FILE_NOT_FOUND == dwFileErr )
{
ErrorMsg1(hwnd, IDS_INVALIDCMDLINE, lpszFile);
}
ErrorMsg(hwnd, IDS_BADSIGNUPFILE);
return FALSE;
}
#endif
// Configure stack if not already configured.
// If this requires a restart, we're in trouble, so
// just return FALSE.
#ifdef SETUPSTACK
if (!TestControlFlags(SCF_SYSTEMCONFIGURED))
{
DWORD dwRet;
BOOL fNeedsRestart = FALSE;
dwRet = lpfnInetConfigSystem(
hwnd,
INETCFG_INSTALLRNA |
INETCFG_INSTALLTCP |
INETCFG_INSTALLMODEM |
INETCFG_SHOWBUSYANIMATION |
INETCFG_REMOVEIFSHARINGBOUND,
&fNeedsRestart);
if (ERROR_SUCCESS == dwRet)
{
SetControlFlags(SCF_SYSTEMCONFIGURED);
InstallScripter();
if (fNeedsRestart)
{
Dprintf("ISIGN32: IEAKProcessISP needs to restart!");
return FALSE;
}
}
else
{
ErrorMsg(hwnd, IDS_INSTALLFAILED);
return FALSE;
}
}
if (!VerifyRasServicesRunning(hwnd))
return FALSE;
#endif
// kill the old connection
KillConnection();
// Create a new connectoid and set the autodial
if (ERROR_SUCCESS != CreateConnection(lpszFile))
{
ErrorMsg(hwnd, IDS_BADSIGNUPFILE);
return FALSE;
}
#ifndef WIN16
//
// Dial connectoid
//
if (ERROR_USERNEXT != DialConnection(lpszFile))
{
Dprintf("ISIGN32: IEAKProcessISP unable to DialConnection!");
return FALSE;
}
#endif
if (GetPrivateProfileString(cszEntrySection,
cszRun,
szNull,
pDynShare->szRunExecutable,
SIZEOF_TCHAR_BUFFER(pDynShare->szRunExecutable),
lpszFile) != 0)
{
GetPrivateProfileString(cszEntrySection,
cszArgument,
szNull,
pDynShare->szRunArgument,
SIZEOF_TCHAR_BUFFER(pDynShare->szRunArgument),
lpszFile);
if (RunExecutable(FALSE) != ERROR_SUCCESS)
{
// make sure the connection is closed
KillConnection();
ErrorMsg1(NULL, IDS_EXECFAILED, pDynShare->szRunExecutable);
return FALSE;
}
}
DeleteConnection();
UnloadInetFunctions();
#if !defined(WIN16)
ReleaseSingleInstance();
#endif
return( TRUE );
}
#ifdef WIN16
CHAR* GetPassword()
{
return pDynShare->szPassword;
}
#else
TCHAR* GetPassword()
{
return pDynShare->szPassword;
}
BOOL IsRASReady()
{
return TestControlFlags(SCF_RASREADY);
}
#endif
BOOL IsCurrentlyProcessingISP()
{
#if !defined(WIN16)
return TestControlFlags(SCF_ISPPROCESSING);
#else
return FALSE;
#endif
}
BOOL NeedBackupSecurity()
{
#if !defined(WIN16)
return TestControlFlags(SCF_NEEDBACKUPSECURITY);
#else
return FALSE;
#endif
}
HWND GetHwndMain()
{
return pDynShare->hwndMain;
}
Reference in New Issue View Git Blame Copy Permalink