mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2859 lines
80 KiB
2859 lines
80 KiB
#include <windows.h>
|
|
#if 0
|
|
#include <stdtypes.h>
|
|
#endif
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <direct.h>
|
|
#include <dos.h>
|
|
#include <sys\types.h>
|
|
#include <sys\stat.h>
|
|
#include <ctype.h> /* isspace */
|
|
#include <io.h>
|
|
#include <limits.h> /* UINT_MAX */
|
|
#include <memory.h> /* _fmemcpy, _fmemccpy */
|
|
#include <lzexpand.h>
|
|
#include <shellapi.h> /* HKEY, HKEY_CLASSES_ROOT, ERROR_SUCCESS */
|
|
#include "setup.h"
|
|
#include "genthk.h" /* thunks for calls to get 32-bit version */
|
|
#include "driveex.h"
|
|
#include <stdtypes.h>
|
|
|
|
/* Messages for optional background task.
|
|
*/
|
|
#define IDM_ACME_STARTING 261
|
|
#define IDM_ACME_COMPLETE 262
|
|
#define IDM_ACME_FAILURE 263
|
|
|
|
#ifdef APPCOMP
|
|
#include <decomp.h>
|
|
#endif /* APPCOMP */
|
|
#include <fdi.h>
|
|
|
|
|
|
/* List file extension */
|
|
char szLstExt[] = "LST";
|
|
|
|
|
|
/* List file section names */
|
|
char szDefaultParamsSect[] = "Params";
|
|
char szDefaultFilesSect[] = "Files";
|
|
|
|
char szWin3xParamsSect[] = "Win3.x Params";
|
|
char szWin3xFilesSect[] = "Win3.x Files";
|
|
|
|
char szWin95ParamsSect[] = "Windows 95 Params";
|
|
char szWin95FilesSect[] = "Windows 95 Files";
|
|
|
|
char szNTAlphaParamsSect[] = "NT Alpha Params";
|
|
char szNTAlphaFilesSect[] = "NT Alpha Files";
|
|
|
|
char szNTMipsParamsSect[] = "NT Mips Params";
|
|
char szNTMipsFilesSect[] = "NT Mips Files";
|
|
|
|
char szNTPpcParamsSect[] = "NT PPC Params";
|
|
char szNTPpcFilesSect[] = "NT PPC Files";
|
|
|
|
char szNTIntelParamsSect[] = "NT Intel Params";
|
|
char szNTIntelFilesSect[] = "NT Intel Files";
|
|
|
|
char szNTVerIntelParamsSect[] = "NT3.51 Intel Params";
|
|
char szNTVerIntelFilesSect[] = "NT3.51 Intel Files";
|
|
|
|
char * szParamsSect = szNull;
|
|
char * szFilesSect = szNull;
|
|
|
|
typedef struct _PLATFORM_SPEC
|
|
{
|
|
BYTE minMajorVersion;
|
|
BYTE minMinorVersion;
|
|
char *szParamsSect;
|
|
char *szFilesSect;
|
|
} PLATFORM_SPEC, *PPLATFORM_SPEC;
|
|
|
|
PLATFORM_SPEC aIntelSpec[] =
|
|
{
|
|
{3, 51, szNTVerIntelParamsSect, szNTVerIntelFilesSect},
|
|
{0, 0, szNTIntelParamsSect, szNTIntelFilesSect},
|
|
{0, 0, NULL, NULL}
|
|
};
|
|
|
|
PLATFORM_SPEC aAlphaSpec[] =
|
|
{
|
|
{0, 0, szNTAlphaParamsSect, szNTAlphaFilesSect},
|
|
{3, 51, szNTVerIntelParamsSect, szNTVerIntelFilesSect},
|
|
{0, 0, szNTIntelParamsSect, szNTIntelFilesSect},
|
|
{0, 0, NULL, NULL}
|
|
};
|
|
|
|
PLATFORM_SPEC aMipsSpec[] =
|
|
{
|
|
{0, 0, szNTMipsParamsSect, szNTMipsFilesSect},
|
|
{0, 0, NULL, NULL}
|
|
};
|
|
|
|
PLATFORM_SPEC aPpcSpec[] =
|
|
{
|
|
{0, 0, szNTPpcParamsSect, szNTPpcFilesSect},
|
|
{0, 0, NULL, NULL}
|
|
};
|
|
|
|
|
|
PLATFORM_SPEC aEmptySpec[] =
|
|
{
|
|
{0, 0, NULL, NULL}
|
|
};
|
|
|
|
// Note: this is indexed by PROCESSOR_ARCHITECTURE_xxx
|
|
// definitions in ntexapi.h
|
|
//
|
|
// Note: may want to add extra sections for IA64 and AXP64
|
|
PPLATFORM_SPEC aaPlatformSpecs[] =
|
|
{
|
|
aIntelSpec, // PROCESSOR_ARCHITECTURE_INTEL 0
|
|
aMipsSpec, // PROCESSOR_ARCHITECTURE_MIPS 1
|
|
aAlphaSpec, // PROCESSOR_ARCHITECTURE_ALPHA 2
|
|
aPpcSpec, // PROCESSOR_ARCHITECTURE_PPC 3
|
|
aEmptySpec, // PROCESSOR_ARCHITECTURE_SHX 4
|
|
aEmptySpec, // PROCESSOR_ARCHITECTURE_ARM 5
|
|
aIntelSpec, // PROCESSOR_ARCHITECTURE_IA64 6
|
|
aAlphaSpec, // PROCESSOR_ARCHITECTURE_ALPHA64 7
|
|
};
|
|
|
|
|
|
/* CPU environment variable and values */
|
|
/* (NOTE: These must be upper case) */
|
|
char szCpuEnvVarName[] = "PROCESSOR_ARCHITECTURE";
|
|
char szIntelEnvVarVal[] = "X86";
|
|
char szIA64EnvVarVal[] = "IA64";
|
|
char szAlphaEnvVarVal[] = "ALPHA";
|
|
char szAXP64EnvVarVal[] = "AXP64";
|
|
char szMipsEnvVarVal[] = "MIPS";
|
|
char szPpcEnvVarVal[] = "PPC";
|
|
|
|
|
|
/* Bootstrapper class name */
|
|
char szBootClass[] = "STUFF-BOOT";
|
|
|
|
/* String buffer sizes */
|
|
#define cchLstLineMax 128
|
|
#define cchWinExecLineMax (256 + cchFullPathMax)
|
|
|
|
/* No. of retries to attempt when removing files or dirs,
|
|
* or when executing a chmod.
|
|
*/
|
|
#define cRetryMax 1200
|
|
|
|
/* SetErrorMode flags */
|
|
#define fNoErrMes 1
|
|
#define fErrMes 0
|
|
|
|
/* Quiet Mode -- Note: EEL must be kept in sync with acmsetup.h */
|
|
typedef UINT EEL; /* Exit Error Level */
|
|
#define eelSuccess ((EEL)0x0000)
|
|
#define eelBootstrapperFailed ((EEL)0x0009) /* Used only in Bootstrapper! */
|
|
|
|
EEL eelExitErrorLevel = eelBootstrapperFailed;
|
|
BOOL fQuietMode = fFalse;
|
|
BOOL fExeced = fFalse;
|
|
BOOL fWin31 = fFalse;
|
|
|
|
/* Forward Declarations */
|
|
VOID CleanUpTempDir ( char *, char * );
|
|
BRC BrcInstallFiles ( char *, char *, char * );
|
|
BOOL FCreateTempDir ( char *, char * );
|
|
BRC BrcCopyFiles ( char *, char *, char * );
|
|
VOID RemoveFiles ( char * );
|
|
BRC BrcCopy ( char *, char * );
|
|
LONG LcbFreeDrive ( int );
|
|
BOOL FVirCheck ( HANDLE );
|
|
HWND HwndInitBootWnd ( HANDLE );
|
|
LRESULT CALLBACK BootWndProc ( HWND, UINT, WPARAM, LPARAM );
|
|
BOOL FGetFileSize ( char *, UINT * );
|
|
BRC BrcBuildFileLists ( char *, UINT );
|
|
VOID FreeFileLists ( VOID );
|
|
BOOL FExecAndWait ( char *, HWND );
|
|
BOOL FWriteBatFile ( OFSTRUCT, char *, char * );
|
|
BOOL FLstSectionExists ( char * szLstFileName, char * szSect );
|
|
DWORD GetCpuArchitecture();
|
|
BOOL FNotifyAcme ( VOID );
|
|
BOOL FGetAcmeErrorLevel ( EEL * peel );
|
|
BOOL FCreateRegKey ( CSZC cszcKey );
|
|
BOOL FDoesRegKeyExist ( CSZC cszcKey );
|
|
BOOL FCreateRegKeyValue ( CSZC cszcKey, CSZC cszcValue );
|
|
BOOL FGetRegKeyValue ( CSZC cszcKey, SZ szBuf, CB cbBufMax );
|
|
VOID DeleteRegKey ( CSZC cszcKey );
|
|
BOOL FFlushRegKey ( VOID );
|
|
BOOL FWriteToRestartFile ( SZ szTmpDir );
|
|
BOOL FCreateIniFileName ( SZ szIniFile, CB cbBufMax );
|
|
BOOL FReadIniFile ( SZ szIniFile, HLOCAL * phlocal, PCB pcbBuf );
|
|
BOOL FAllocNewBuf ( CB cbOld, SZ szTmpDir, SZ szSection, SZ szKey,
|
|
HLOCAL * phlocal, PCB pcbToBuf );
|
|
BOOL FProcessFile ( HLOCAL hlocalFrom, HLOCAL hlocalTo, CB cbToBuf,
|
|
SZ szTmpDir, SZ szSection, SZ szKey );
|
|
VOID CopyIniLine ( SZ szKey, SZ szTmpDir, SZ szFile, PSZ pszToBuf );
|
|
BOOL FWriteIniFile ( SZ szIniFile, HLOCAL hlocalTo );
|
|
BRC BrcInsertDisk(CHAR *pchStf, CHAR *pchSrcDrive);
|
|
BOOL FRenameBadMaintStf ( SZ szStf );
|
|
|
|
|
|
/* Bootstrapper list file params */
|
|
char rgchSetupDirName[cchLstLineMax];
|
|
#ifdef UNUSED /* Replaced by DrvWinClass */
|
|
char rgchDrvModName[cchLstLineMax];
|
|
#endif /* UNUSED */
|
|
char rgchDrvWinClass[cchLstLineMax];
|
|
char rgchCmdLine[cchLstLineMax];
|
|
char rgchBootTitle[cchLstLineMax];
|
|
char rgchBootMess[cchLstLineMax];
|
|
char rgchWin31Mess[cchLstLineMax];
|
|
char rgchCabinetFName[cchLstLineMax];
|
|
char rgchBackgroundFName[cchLstLineMax];
|
|
char rgchBkgWinClass[cchLstLineMax];
|
|
char rgchInsertCDMsg[cchLstLineMax];
|
|
char rgchInsertDiskMsg[cchLstLineMax];
|
|
LONG lcbDiskFreeMin;
|
|
int cFirstCabinetNum;
|
|
int cLastCabinetNum;
|
|
HANDLE hSrcLst = NULL;
|
|
HANDLE hDstLst = NULL;
|
|
char rgchErrorFile[cchFullPathMax];
|
|
HANDLE hinstBoot = NULL;
|
|
HWND hwndBoot = NULL;
|
|
|
|
|
|
CHAR rgchInsufMem[cchSzMax] = "";
|
|
CHAR rgchInitErr[cchSzMax] = "";
|
|
CHAR rgchSetup[cchSzMax] = "";
|
|
|
|
|
|
/*
|
|
** 'Fixup' temp dir string by removing any subdirs and ensuring
|
|
** extension is only one character. (Note - Win3.0 has bug with
|
|
** WinExec'ing some EXEs from a full 8.3 directory!)
|
|
**************************************************************************/
|
|
void FixupTempDirName( LPSTR szDir )
|
|
{
|
|
LPSTR szNext;
|
|
int cch = 0;
|
|
|
|
if (*szDir == '\\'
|
|
|| *(AnsiNext(szDir)) == ':')
|
|
{
|
|
lstrcpy(szDir, "~msstfqf.t");
|
|
return;
|
|
}
|
|
|
|
while (*szDir != '\\'
|
|
&& *szDir != '.'
|
|
&& *szDir != '\0'
|
|
&& *szDir != ':'
|
|
&& cch++ < 8)
|
|
{
|
|
szDir = AnsiNext(szDir);
|
|
}
|
|
|
|
szNext = AnsiNext(szDir);
|
|
if (*szDir == '.'
|
|
&& *szNext != '.'
|
|
&& *szNext != '\\'
|
|
&& *szNext != '\0'
|
|
&& *szNext != ':')
|
|
{
|
|
*(AnsiNext(szNext)) = '\0';
|
|
return;
|
|
}
|
|
|
|
*szDir = '\0';
|
|
lstrcat(szDir, ".t");
|
|
}
|
|
|
|
|
|
/* Displays bootstrapper messages.
|
|
* If fError is true, it's an error message, otherwise it's
|
|
* just a message (e.g. insert disk 1).
|
|
**************************************************************************/
|
|
int DispErrBrc ( BRC brc, BOOL fError, UINT fuStyle,
|
|
const char *sz1, const char *sz2,
|
|
const char *sz3 )
|
|
{
|
|
char rgchTitle[256];
|
|
char rgchMessage[256];
|
|
char szBuf[256 + cchFullPathMax + 256];
|
|
|
|
#ifndef DEBUG
|
|
if (fQuietMode)
|
|
{
|
|
return (IDCANCEL);
|
|
}
|
|
#endif
|
|
|
|
if (LoadString(hinstBoot, brcGen, rgchTitle, 256) == 0
|
|
|| LoadString(hinstBoot, brc, rgchMessage, 256) == 0)
|
|
{
|
|
MessageBox(hwndBoot, rgchInsufMem, rgchInitErr, MB_OK | MB_ICONSTOP);
|
|
return 0;
|
|
}
|
|
|
|
if (!fError)
|
|
lstrcpy(rgchTitle, rgchSetup);
|
|
|
|
if (sz1 == NULL) sz1 = "";
|
|
if (sz2 == NULL) sz2 = "";
|
|
if (sz3 == NULL) sz3 = "";
|
|
|
|
if (brc == brcFile)
|
|
wsprintf(szBuf, rgchMessage, (LPSTR)AnsiUpper(rgchErrorFile));
|
|
else if (brc == brcDS || brc == brcMemDS)
|
|
wsprintf(szBuf, rgchMessage, lcbDiskFreeMin / 1024L);
|
|
else
|
|
wsprintf(szBuf, rgchMessage, sz1, sz2, sz3);
|
|
|
|
if ((brc == brcMemDS || brc == brcNoSpill)
|
|
&& LoadString(hinstBoot, brcMemDSHlp, rgchMessage, 256))
|
|
{
|
|
lstrcat(szBuf, rgchMessage);
|
|
}
|
|
else if (brc == brcConnectToSource
|
|
&& LoadString(hinstBoot, brcConnectHlp, rgchMessage, 256))
|
|
{
|
|
lstrcat(szBuf, rgchMessage);
|
|
}
|
|
|
|
return (MessageBox(hwndBoot, szBuf, rgchTitle, fuStyle));
|
|
}
|
|
|
|
|
|
/*
|
|
** Purpose:
|
|
** Installs Setup executable in a temporary directory on an
|
|
** available hardrive, and launches Setup. After Setup
|
|
** completes, removes the temporary files and directory.
|
|
** Arguments:
|
|
** Standard Windows WinMain args.
|
|
** Returns:
|
|
** Returns eelExitErrorLevel. 0 == Success.
|
|
**************************************************************************/
|
|
int WINAPI WinMain ( HINSTANCE hInstance, HINSTANCE hPrevInstance,
|
|
LPSTR lpszCmdParam, int nCmdShow )
|
|
{
|
|
char chDrive;
|
|
char rgchDstDir[cchFullPathMax] = " :\\"; // WARN: kept as OEM chars
|
|
char * szDstDirSlash = szNull;
|
|
char rgchModuleFileName[cchFullPathMax]; // WARN: kept as ANSI chars
|
|
char rgchLstFileName[cchFullPathMax];
|
|
char rgchTemp[cchFullPathMax];
|
|
char rgchSrcDir[cchFullPathMax];
|
|
UINT cbLstSize;
|
|
char rgchWinExecLine[cchWinExecLineMax];
|
|
UINT uiRes;
|
|
int iModLen;
|
|
BRC brc;
|
|
BOOL fCleanupTemp = FALSE;
|
|
LPSTR sz;
|
|
HWND hWndBkg = 0; /* window of background task */
|
|
UINT hMod;
|
|
|
|
Unused(nCmdShow);
|
|
hinstBoot = hInstance;
|
|
|
|
rgchErrorFile[0] = '\0';
|
|
|
|
if (LoadString(hinstBoot, IDS_InsufMem, rgchInsufMem,
|
|
sizeof rgchInsufMem) == 0
|
|
|| LoadString(hinstBoot, IDS_InitErr, rgchInitErr,
|
|
sizeof rgchInitErr) == 0
|
|
|| LoadString(hinstBoot, IDS_Setup, rgchSetup,
|
|
sizeof rgchSetup) == 0)
|
|
{
|
|
/* REVIEW: If these LoadStrngs fail, the user will never know...
|
|
* But we can't hard-code strings in an .h file because INTL
|
|
* requires all localizable strings to be in resources!
|
|
*/
|
|
#ifdef DEBUG
|
|
MessageBox(NULL, "Initial LoadString's failed; probably out of memory.",
|
|
szDebugMsg, MB_OK | MB_ICONEXCLAMATION);
|
|
|
|
#endif /* DEBUG */
|
|
}
|
|
|
|
for (sz = lpszCmdParam; *sz != '\0'; sz = AnsiNext(sz))
|
|
{
|
|
if ((*sz == '-' || *sz == '/')
|
|
&& toupper(*(sz+1)) == 'Q' && toupper(*(sz+2)) == 'T')
|
|
{
|
|
fQuietMode = fTrue;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* REVIEW: Check that this code is still functional before restoring it.
|
|
*/
|
|
#if VIRCHECK
|
|
if (!FVirCheck(hInstance))
|
|
{
|
|
DispErrBrc(brcVir, TRUE, MB_OK | MB_ICONSTOP, NULL, NULL, NULL);
|
|
goto LCleanupAndExit;
|
|
}
|
|
#endif
|
|
|
|
if (hPrevInstance || FindWindow(szBootClass, NULL) != NULL)
|
|
{
|
|
DispErrBrc(brcInst, TRUE, MB_OK | MB_ICONSTOP, NULL, NULL, NULL);
|
|
goto LCleanupAndExit;
|
|
}
|
|
|
|
GetModuleFileName(hInstance, rgchModuleFileName, cchFullPathMax);
|
|
|
|
/*
|
|
* If the first switch on the command line is /M, then it specifies
|
|
* the real module name to use.
|
|
*/
|
|
if ((lpszCmdParam[0] == '-' || lpszCmdParam[0] == '/')
|
|
&& toupper(lpszCmdParam[1]) == 'M')
|
|
{
|
|
char *pCh, *pCh2;
|
|
BOOL fQuotedFileName;
|
|
|
|
/* Skip the spaces */
|
|
for (pCh = lpszCmdParam+2; *pCh == ' '; pCh++);
|
|
fQuotedFileName = (*pCh == '\"');
|
|
if (fQuotedFileName)
|
|
{
|
|
pCh++;
|
|
}
|
|
|
|
/* Copy the file name, and add the EOS */
|
|
lstrcpy(rgchModuleFileName, pCh);
|
|
for (pCh2=rgchModuleFileName;
|
|
(*pCh2 != ' ' || fQuotedFileName) &&
|
|
(*pCh2 != '\"' || !fQuotedFileName) &&
|
|
*pCh2 != '\0';
|
|
pCh2++);
|
|
*pCh2 = '\0';
|
|
|
|
/* Remove the /M param from the command line */
|
|
lpszCmdParam = pCh + lstrlen(rgchModuleFileName);
|
|
if (fQuotedFileName && *lpszCmdParam == '\"')
|
|
{
|
|
lpszCmdParam++;
|
|
}
|
|
|
|
/* Remove trailing whitespace from the command line */
|
|
for (pCh = lpszCmdParam; *pCh == ' '; pCh++);
|
|
lpszCmdParam = pCh;
|
|
}
|
|
|
|
|
|
OemToAnsi(rgchModuleFileName, rgchModuleFileName);
|
|
|
|
// Windows 3.0 bug with UNC paths - prepends windows drive letter
|
|
sz = (LPSTR)rgchModuleFileName;
|
|
if (*sz != '\0'
|
|
&& *sz != '\\'
|
|
&& *(sz = AnsiNext(sz)) == ':'
|
|
&& *(sz = AnsiNext(sz)) == '\\'
|
|
&& *AnsiNext(sz) == '\\')
|
|
{
|
|
LPSTR szDst = (LPSTR)rgchModuleFileName;
|
|
|
|
while ((*szDst++ = *sz++) != '\0')
|
|
;
|
|
}
|
|
|
|
iModLen = lstrlen(rgchModuleFileName);
|
|
lstrcpy(rgchSrcDir, rgchModuleFileName);
|
|
sz = (LPSTR)&rgchSrcDir[iModLen];
|
|
while (sz > (LPSTR)rgchSrcDir && *sz != '\\')
|
|
sz = AnsiPrev(rgchSrcDir, sz);
|
|
Assert(sz > (LPSTR)rgchSrcDir);
|
|
*(AnsiNext(sz)) = '\0';
|
|
|
|
/*
|
|
* If the first switch on the command line is /L, then it specifies
|
|
* the name of the .lst file to use.
|
|
*/
|
|
rgchTemp[0] = '\0';
|
|
if ((lpszCmdParam[0] == '-' || lpszCmdParam[0] == '/')
|
|
&& toupper(lpszCmdParam[1]) == 'L')
|
|
{
|
|
char *pCh, *pCh2;
|
|
|
|
/* Skip the spaces */
|
|
for (pCh = lpszCmdParam+2; *pCh == ' ' && *pCh != '\0'; pCh++);
|
|
|
|
/* Copy the .lst file name, and add the newline */
|
|
lstrcpy(rgchTemp, pCh);
|
|
for (pCh2=rgchTemp; *pCh2 != ' ' && *pCh2!= '\0'; pCh2++);
|
|
*pCh2 = '\0';
|
|
|
|
/* Remove the /L param from the command line */
|
|
lpszCmdParam = pCh + lstrlen(rgchTemp);
|
|
for (pCh = lpszCmdParam; *pCh == ' ' && *pCh != '\0'; pCh++);
|
|
lpszCmdParam = pCh;
|
|
}
|
|
|
|
|
|
/* If there is something on the command line, use it as the .lst file */
|
|
if (*rgchTemp != '\0')
|
|
{
|
|
lstrcpy(rgchLstFileName, rgchSrcDir);
|
|
lstrcat(rgchLstFileName, rgchTemp);
|
|
}
|
|
else
|
|
{
|
|
lstrcpy(rgchLstFileName, rgchModuleFileName);
|
|
sz = (LPSTR)&rgchLstFileName[iModLen];
|
|
while (sz > (LPSTR)rgchLstFileName && *sz != '.')
|
|
sz = AnsiPrev(rgchLstFileName, sz);
|
|
Assert(sz > (LPSTR)rgchLstFileName);
|
|
*(AnsiNext(sz)) = '\0';
|
|
lstrcat(rgchLstFileName, szLstExt);
|
|
}
|
|
|
|
if (!FGetFileSize(rgchLstFileName, &cbLstSize) || cbLstSize == 0)
|
|
{
|
|
lstrcpy(rgchErrorFile, rgchLstFileName);
|
|
DispErrBrc(brcFile, TRUE, MB_OK | MB_ICONSTOP, NULL, NULL, NULL);
|
|
goto LCleanupAndExit;
|
|
}
|
|
|
|
#ifndef WF_WINNT
|
|
#define WF_WINNT 0x4000
|
|
#endif
|
|
|
|
/* Attempt to use appropriate platform.
|
|
*/
|
|
szParamsSect = szNull;
|
|
szFilesSect = szNull;
|
|
|
|
if (1)
|
|
{
|
|
DWORD dwVers = 0;
|
|
DWORD dwCpuArchitecture;
|
|
DWORD dwMajorVersion;
|
|
DWORD dwMinorVersion;
|
|
PPLATFORM_SPEC pPlatformSpec;
|
|
|
|
dwCpuArchitecture = GetCpuArchitecture();
|
|
|
|
dwVers = GetVersion();
|
|
dwMajorVersion = LOBYTE(LOWORD(dwVers));
|
|
dwMinorVersion = HIBYTE(LOWORD(dwVers));
|
|
|
|
if (dwCpuArchitecture < (sizeof (aaPlatformSpecs) / sizeof(aaPlatformSpecs[0])))
|
|
{
|
|
pPlatformSpec = aaPlatformSpecs[dwCpuArchitecture];
|
|
}
|
|
else
|
|
{
|
|
pPlatformSpec = aEmptySpec;
|
|
}
|
|
|
|
for (; pPlatformSpec->szParamsSect != NULL; pPlatformSpec++)
|
|
{
|
|
if (((pPlatformSpec->minMajorVersion < dwMajorVersion) ||
|
|
(pPlatformSpec->minMajorVersion == dwMajorVersion && pPlatformSpec->minMinorVersion <= dwMinorVersion)) &&
|
|
FLstSectionExists(rgchLstFileName, pPlatformSpec->szParamsSect))
|
|
{
|
|
szParamsSect = pPlatformSpec->szParamsSect;
|
|
szFilesSect = pPlatformSpec->szFilesSect;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else /* non-WinNT */
|
|
{
|
|
if (FLstSectionExists(rgchLstFileName, szWin95ParamsSect)
|
|
&& (LOBYTE(LOWORD(GetVersion())) > 3
|
|
|| HIBYTE(LOWORD(GetVersion())) >= 95))
|
|
{
|
|
szParamsSect = szWin95ParamsSect;
|
|
szFilesSect = szWin95FilesSect;
|
|
}
|
|
else
|
|
{
|
|
fWin31 = fTrue;
|
|
if (FLstSectionExists(rgchLstFileName, szWin3xParamsSect))
|
|
{
|
|
szParamsSect = szWin3xParamsSect;
|
|
szFilesSect = szWin3xFilesSect;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (szParamsSect == szNull)
|
|
{
|
|
if (FLstSectionExists(rgchLstFileName, szDefaultParamsSect))
|
|
{
|
|
szParamsSect = szDefaultParamsSect;
|
|
szFilesSect = szDefaultFilesSect;
|
|
}
|
|
else
|
|
{
|
|
DispErrBrc(brcNoCpuSect, TRUE, MB_OK | MB_ICONSTOP, NULL,
|
|
NULL, NULL);
|
|
goto LCleanupAndExit;
|
|
}
|
|
}
|
|
|
|
if (GetPrivateProfileString(szParamsSect, "TmpDirName", "",
|
|
rgchSetupDirName, cchLstLineMax, rgchLstFileName) <= 0
|
|
|| (lcbDiskFreeMin = GetPrivateProfileInt(szParamsSect,
|
|
"TmpDirSize", 0, rgchLstFileName) * 1024L) <= 0
|
|
|| (cFirstCabinetNum = GetPrivateProfileInt(szParamsSect,
|
|
"FirstCabNum", 1, rgchLstFileName)) <= 0
|
|
|| (cLastCabinetNum = GetPrivateProfileInt(szParamsSect,
|
|
"LastCabNum", 1, rgchLstFileName)) <= 0
|
|
#ifdef UNUSED
|
|
|| GetPrivateProfileString(szParamsSect, "DrvModName", "",
|
|
rgchDrvModName, cchLstLineMax, rgchLstFileName) <= 0
|
|
#endif /* UNUSED */
|
|
|| GetPrivateProfileString(szParamsSect, "DrvWinClass", "",
|
|
rgchDrvWinClass, cchLstLineMax, rgchLstFileName) <= 0
|
|
|| GetPrivateProfileString(szParamsSect, "CmdLine", "", rgchCmdLine,
|
|
cchLstLineMax, rgchLstFileName) <= 0
|
|
//|| GetPrivateProfileString(szParamsSect, "Require31", "",
|
|
// rgchWin31Mess, cchLstLineMax, rgchLstFileName) <= 0
|
|
|| GetPrivateProfileString(szParamsSect, "WndTitle", "",
|
|
rgchBootTitle, cchLstLineMax, rgchLstFileName) <= 0
|
|
|| GetPrivateProfileString(szParamsSect, "WndMess", "",
|
|
rgchBootMess, cchLstLineMax, rgchLstFileName) <= 0)
|
|
{
|
|
DispErrBrc(brcLst, TRUE, MB_OK | MB_ICONSTOP, NULL, NULL, NULL);
|
|
goto LCleanupAndExit;
|
|
}
|
|
|
|
if (FindWindow(rgchDrvWinClass, NULL) != NULL)
|
|
{
|
|
DispErrBrc(brcInst, TRUE, MB_OK | MB_ICONSTOP, NULL, NULL, NULL);
|
|
goto LCleanupAndExit;
|
|
}
|
|
|
|
GetPrivateProfileString(szParamsSect, "CabinetFile", "",
|
|
rgchCabinetFName, cchLstLineMax, rgchLstFileName);
|
|
|
|
GetPrivateProfileString(szParamsSect, "InsertCDMsg", "",
|
|
rgchInsertCDMsg, cchLstLineMax, rgchLstFileName);
|
|
|
|
GetPrivateProfileString(szParamsSect, "InsertDiskMsg", "",
|
|
rgchInsertDiskMsg, cchLstLineMax, rgchLstFileName);
|
|
|
|
if (rgchWin31Mess[0] != '\0'
|
|
&& LOBYTE(LOWORD((DWORD)GetVersion())) == 3
|
|
&& HIBYTE(LOWORD((DWORD)GetVersion())) < 10)
|
|
{
|
|
if (!fQuietMode)
|
|
{
|
|
char rgchTitle[256];
|
|
|
|
if (LoadString(hinstBoot, brcGen, rgchTitle, 256) == 0)
|
|
lstrcpy(rgchTitle, rgchSetup);
|
|
MessageBox(hwndBoot, rgchWin31Mess, rgchTitle,
|
|
MB_OK | MB_ICONSTOP);
|
|
}
|
|
goto LCleanupAndExit;
|
|
}
|
|
|
|
FixupTempDirName(rgchSetupDirName);
|
|
|
|
for (sz = rgchBootMess; *sz != '\0'; sz = AnsiNext(sz))
|
|
if (*sz == '\\' && *(sz+1) == 'n')
|
|
{
|
|
*sz++ = '\r';
|
|
*sz = '\n';
|
|
}
|
|
|
|
/* If there is a /W then is specifies we are in add/remove mode with
|
|
the setup app not installed. We need to read it off CD/Floppy/Network
|
|
*/
|
|
if ((lpszCmdParam[0] == '-' || lpszCmdParam[0] == '/')
|
|
&& toupper(lpszCmdParam[1]) == 'W')
|
|
{
|
|
CHAR rgchStf[_MAX_PATH];
|
|
char *pCh, *pCh2, *pCh3;
|
|
|
|
/* Skip the spaces */
|
|
for (pCh = lpszCmdParam+2; *pCh == ' ' && *pCh != '\0'; pCh++);
|
|
|
|
lstrcpy(rgchStf, rgchSrcDir);
|
|
pCh3 = rgchStf + lstrlen(rgchStf);
|
|
/* Copy the .stf file name, and add the newline */
|
|
for (pCh2=pCh; *pCh2 != ' ' && *pCh2!= '\0'; pCh2++)
|
|
*pCh3++ = *pCh2;
|
|
*pCh3 = '\0';
|
|
|
|
/* Remove the /W parameter */
|
|
lpszCmdParam = pCh2;
|
|
|
|
/* Get them to insert the correct disk */
|
|
if ((brc = BrcInsertDisk(rgchStf, rgchSrcDir)) != brcOkay)
|
|
{
|
|
if (brc != brcMax)
|
|
DispErrBrc(brc, TRUE, MB_OK | MB_ICONSTOP, rgchStf, NULL, NULL);
|
|
goto LCleanupAndExit;
|
|
}
|
|
}
|
|
|
|
GetPrivateProfileString(szParamsSect, "Background", "",
|
|
rgchBackgroundFName, cchLstLineMax, rgchLstFileName);
|
|
GetPrivateProfileString(szParamsSect, "BkgWinClass", "",
|
|
rgchBkgWinClass, cchLstLineMax, rgchLstFileName);
|
|
if (rgchBackgroundFName[0] != '\0')
|
|
{
|
|
lstrcpy(rgchTemp, rgchSrcDir);
|
|
lstrcat(rgchTemp, rgchBackgroundFName);
|
|
if (rgchBkgWinClass[0] != '\0')
|
|
{
|
|
lstrcat(rgchTemp, " /C");
|
|
lstrcat(rgchTemp, rgchBkgWinClass);
|
|
}
|
|
lstrcat(rgchTemp, " /T");
|
|
lstrcat(rgchTemp, rgchBootTitle);
|
|
lstrcat(rgchTemp, " /M");
|
|
lstrcat(rgchTemp, rgchBootMess);
|
|
|
|
hMod = WinExec(rgchTemp, SW_SHOWNORMAL); /* ignore if exec failed */
|
|
#ifdef DEBUG
|
|
if (hMod < 32)
|
|
{
|
|
wsprintf(szDebugBuf, "%s: Background WinExec failed.",
|
|
rgchBackgroundFName);
|
|
MessageBox(NULL, szDebugBuf, szDebugMsg, MB_OK | MB_ICONSTOP);
|
|
}
|
|
#endif /* DEBUG */
|
|
|
|
hWndBkg = FindWindow(rgchBkgWinClass, rgchBootTitle);
|
|
}
|
|
if (!hWndBkg && (hwndBoot = HwndInitBootWnd(hInstance)) == NULL)
|
|
{
|
|
DispErrBrc(brcMem, TRUE, MB_OK | MB_ICONSTOP, NULL, NULL, NULL);
|
|
goto LCleanupAndExit;
|
|
}
|
|
|
|
if ((brc = BrcBuildFileLists(rgchLstFileName, cbLstSize)) != brcOkay)
|
|
{
|
|
DispErrBrc(brc, TRUE, MB_OK | MB_ICONSTOP, NULL, NULL, NULL);
|
|
goto LCleanupAndExit;
|
|
}
|
|
|
|
lstrcat(rgchDstDir, "~MSSETUP.T");
|
|
szDstDirSlash = rgchDstDir + lstrlen(rgchDstDir);
|
|
lstrcat(rgchDstDir, "\\");
|
|
|
|
lstrcat(rgchDstDir, rgchSetupDirName);
|
|
AnsiToOem(rgchDstDir, rgchDstDir);
|
|
for (chDrive = 'Z'; chDrive >= 'A'; --chDrive)
|
|
{
|
|
UINT fModeSav;
|
|
BOOL fDriveFixed;
|
|
|
|
fModeSav = SetErrorMode(fNoErrMes);
|
|
fDriveFixed = (GetDriveTypeEx(chDrive - 'A') == EX_DRIVE_FIXED);
|
|
SetErrorMode(fModeSav);
|
|
if (fDriveFixed)
|
|
{
|
|
*rgchDstDir = chDrive;
|
|
brc = BrcInstallFiles(rgchSrcDir, rgchDstDir, szDstDirSlash);
|
|
if (brc == brcOkay)
|
|
break;
|
|
if (brc == brcFile)
|
|
{
|
|
DispErrBrc(brc, TRUE, MB_OK | MB_ICONSTOP, NULL, NULL, NULL);
|
|
goto LCleanupAndExit;
|
|
}
|
|
else if (brc == brcNoSpill)
|
|
{
|
|
/* Message already handled in HfOpenSpillFile */
|
|
goto LCleanupAndExit;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (chDrive < 'A')
|
|
{
|
|
uiRes = GetWindowsDirectory(rgchDstDir, cchFullPathMax);
|
|
Assert(uiRes > 0);
|
|
#if DBCS // [J1] Fixed DBCS raid #46.
|
|
AnsiUpper(rgchDstDir);
|
|
#endif
|
|
/* BLOCK */
|
|
{
|
|
LPSTR sz = (LPSTR)&rgchDstDir[uiRes];
|
|
|
|
sz = AnsiPrev(rgchDstDir, sz);
|
|
if (*sz != '\\')
|
|
lstrcat(rgchDstDir, "\\");
|
|
}
|
|
|
|
lstrcat(rgchDstDir, "~MSSETUP.T");
|
|
szDstDirSlash = rgchDstDir + lstrlen(rgchDstDir);
|
|
lstrcat(rgchDstDir, "\\");
|
|
|
|
Assert(lstrlen(rgchDstDir) + lstrlen(rgchSetupDirName)
|
|
< cchFullPathMax);
|
|
lstrcat(rgchDstDir, rgchSetupDirName);
|
|
AnsiToOem(rgchDstDir, rgchDstDir);
|
|
brc = BrcInstallFiles(rgchSrcDir, rgchDstDir, szDstDirSlash);
|
|
if (brc != brcOkay)
|
|
{
|
|
/* NoSpill message already handled in HfOpenSpillFile */
|
|
if (brc != brcNoSpill)
|
|
{
|
|
DispErrBrc(brc, TRUE, MB_OK | MB_ICONSTOP, NULL, NULL, NULL);
|
|
}
|
|
goto LCleanupAndExit;
|
|
}
|
|
}
|
|
|
|
hSrcLst = LocalFree(hSrcLst); /* don't need src list anymore */
|
|
Assert(hSrcLst == NULL);
|
|
|
|
/* Use full path to .exe; don't rely on cwd (fails under Win95).
|
|
*/
|
|
/* block */
|
|
{
|
|
char rgchTmp[cchWinExecLineMax];
|
|
|
|
wsprintf(rgchTmp, rgchCmdLine, (LPSTR)rgchSrcDir,
|
|
lpszCmdParam);
|
|
|
|
Assert(lstrlen(rgchTmp) + lstrlen(rgchDstDir) + 1 < cchWinExecLineMax);
|
|
|
|
lstrcpy(rgchWinExecLine, rgchDstDir);
|
|
lstrcat(rgchWinExecLine, "\\");
|
|
lstrcat(rgchWinExecLine, rgchTmp);
|
|
}
|
|
GlobalCompact((DWORD)(64L * 1024L));
|
|
fCleanupTemp = TRUE;
|
|
|
|
if (!fWin31 && !FNotifyAcme())
|
|
{
|
|
#if DEBUG
|
|
DispErrBrc(brcRegDb, TRUE, MB_OK | MB_ICONEXCLAMATION, NULL, NULL, NULL);
|
|
#endif /* DEBUG */
|
|
/* Try running Acme anyway. */
|
|
}
|
|
if (!fWin31 && !FWriteToRestartFile(rgchDstDir))
|
|
{
|
|
#ifdef DEBUG
|
|
MessageBox(NULL, "Write to restart file failed. Setup can continue, "
|
|
"but some initialization files might not get removed "
|
|
"if Setup must restart Windows.",
|
|
szDebugMsg, MB_OK | MB_ICONEXCLAMATION);
|
|
|
|
#endif /* DEBUG */
|
|
/*
|
|
* Any errors encountered will have been displayed where they occured.
|
|
* Try running Acme anyway.
|
|
*/
|
|
}
|
|
if (hWndBkg)
|
|
SendMessage(hWndBkg, WM_COMMAND, IDM_ACME_STARTING, 0);
|
|
|
|
if (!FExecAndWait(rgchWinExecLine, hwndBoot))
|
|
{
|
|
DispErrBrc(brcMem, TRUE, MB_OK | MB_ICONSTOP, NULL, NULL, NULL);
|
|
goto LCleanupAndExit;
|
|
}
|
|
fExeced = fTrue;
|
|
|
|
LCleanupAndExit:
|
|
if (fCleanupTemp && szDstDirSlash != szNull)
|
|
CleanUpTempDir(rgchDstDir, szDstDirSlash);
|
|
FreeFileLists();
|
|
eelExitErrorLevel = eelBootstrapperFailed;
|
|
if (fExeced && !FGetAcmeErrorLevel(&eelExitErrorLevel))
|
|
{
|
|
#ifdef UNUSED
|
|
/* NOTE: Removed to avoid the message on WinNT. On NT, Acme can
|
|
* exit and the bootstrapper can kick in before the restart
|
|
* actually happens, causing this message (since Acme has already
|
|
* removed the reg key as part of its reboot cleanup). We'll
|
|
* leave the eelFailed value, though, since no one should be
|
|
* relying on it at reboot anyway, and it may help catch other
|
|
* problems down the road.
|
|
*/
|
|
DispErrBrc(brcRegDb, TRUE, MB_OK | MB_ICONSTOP, NULL, NULL, NULL);
|
|
#endif /* UNUSED */
|
|
Assert(eelExitErrorLevel == eelBootstrapperFailed);
|
|
}
|
|
if (hwndBoot != NULL)
|
|
DestroyWindow(hwndBoot);
|
|
if (hWndBkg && IsWindow(hWndBkg))
|
|
{
|
|
SendMessage(hWndBkg, WM_COMMAND, eelExitErrorLevel == eelSuccess ?
|
|
IDM_ACME_COMPLETE : IDM_ACME_FAILURE, 0);
|
|
if (IsWindow(hWndBkg))
|
|
PostMessage(hWndBkg, WM_QUIT, 0, 0);
|
|
}
|
|
return (eelExitErrorLevel);
|
|
}
|
|
|
|
|
|
/*
|
|
** Purpose:
|
|
** Creates and temporary subdirectory at the given path,
|
|
** appends it to the given path, and copies the Setup files
|
|
** into it.
|
|
** Arguments:
|
|
** szModule: Full path to bootstrapper's directory (ANSI chars).
|
|
** rgchDstDir: Full path to destination directory (OEM chars).
|
|
** Returns:
|
|
** One of the following Bootstrapper return codes:
|
|
** brcMem out of memory
|
|
** brcDS out of disk space
|
|
** brcMemDS out of memory or disk space
|
|
** brcFile expected source file missing
|
|
** brcOkay completed without error
|
|
**************************************************************************/
|
|
BRC BrcInstallFiles ( char * szModule, char * rgchDstDir,
|
|
char * szDstDirSlash )
|
|
{
|
|
BRC brc;
|
|
|
|
if (LcbFreeDrive(*rgchDstDir - 'A' + 1) < lcbDiskFreeMin)
|
|
return (brcDS);
|
|
if (!FCreateTempDir(rgchDstDir, szDstDirSlash))
|
|
return (brcMemDS);
|
|
if ((brc = BrcCopyFiles(szModule, rgchDstDir, szDstDirSlash)) != brcOkay)
|
|
{
|
|
CleanUpTempDir(rgchDstDir, szDstDirSlash);
|
|
return (brc);
|
|
}
|
|
|
|
SetFileAttributes(rgchDstDir, FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_READONLY);
|
|
|
|
Assert(szDstDirSlash);
|
|
Assert(*szDstDirSlash == '\\');
|
|
*szDstDirSlash = '\0';
|
|
SetFileAttributes(rgchDstDir, FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_READONLY);
|
|
*szDstDirSlash = '\\';
|
|
|
|
return (brcOkay);
|
|
}
|
|
|
|
|
|
/*
|
|
** Purpose:
|
|
** Removes the temporary files and directory.
|
|
** Arguments:
|
|
** rgchDstDir: Full path to temp directory (OEM chars).
|
|
** Returns:
|
|
** None.
|
|
**************************************************************************/
|
|
VOID CleanUpTempDir ( char * rgchDstDir, char * szDstDirSlash )
|
|
{
|
|
char rgchRoot[] = " :\\";
|
|
int i;
|
|
|
|
RemoveFiles(rgchDstDir);
|
|
|
|
rgchRoot[0] = *rgchDstDir;
|
|
_chdir(rgchRoot);
|
|
|
|
SetFileAttributes(rgchDstDir, FILE_ATTRIBUTE_NORMAL);
|
|
|
|
/* Try to remove the directory up to cRetryMax times.
|
|
*/
|
|
for (i = 0; i < cRetryMax; i++)
|
|
{
|
|
if (_rmdir(rgchDstDir) == 0)
|
|
break;
|
|
}
|
|
|
|
Assert(szDstDirSlash);
|
|
Assert(*szDstDirSlash == '\\');
|
|
*szDstDirSlash = '\0';
|
|
SetFileAttributes(rgchDstDir, FILE_ATTRIBUTE_NORMAL);
|
|
|
|
/* Try to remove the directory up to cRetryMax times.
|
|
*/
|
|
for (i = 0; i < cRetryMax; i++)
|
|
{
|
|
if (_rmdir(rgchDstDir) == 0)
|
|
break;
|
|
}
|
|
|
|
*szDstDirSlash = '\\';
|
|
}
|
|
|
|
|
|
/*
|
|
** Purpose:
|
|
** Creates a temporary subdirectory at the given path,
|
|
** and appends it to the given path.
|
|
** Arguments:
|
|
** rgchDir: Full path to destination directory (OEM chars).
|
|
** Returns:
|
|
** TRUE if directory was successfully created,
|
|
** FALSE if not.
|
|
**************************************************************************/
|
|
BOOL FCreateTempDir ( char * rgchDir, char * szDstDirSlash )
|
|
{
|
|
char rgchTmp[cchFullPathMax];
|
|
FILE * fp;
|
|
char * pch;
|
|
int fErr;
|
|
int i = 0;
|
|
|
|
pch = (char *)(&rgchDir[lstrlen(rgchDir)]);
|
|
Assert(*pch == '\0');
|
|
_chdrive(*rgchDir - 'A' + 1);
|
|
|
|
Assert(szDstDirSlash);
|
|
Assert(*szDstDirSlash == '\\');
|
|
*szDstDirSlash = '\0';
|
|
_mkdir(rgchDir);
|
|
*szDstDirSlash = '\\';
|
|
|
|
while (!_access(rgchDir, 0))
|
|
{
|
|
if (!_chdir(rgchDir))
|
|
{
|
|
/* verify dir is write-able */
|
|
lstrcpy(rgchTmp, rgchDir);
|
|
lstrcat(rgchTmp, "\\tXXXXXX");
|
|
Assert(lstrlen(rgchTmp) < cchFullPathMax);
|
|
if (_mktemp(rgchTmp) != NULL
|
|
&& (fp = fopen(rgchTmp, "w")) != NULL)
|
|
{
|
|
fErr = fclose(fp);
|
|
Assert(!fErr);
|
|
|
|
fErr = remove(rgchTmp);
|
|
#ifdef DBCS // [J2] Fixed DBCS raid #28.
|
|
if (fErr) // Keep the directory name
|
|
*pch = '\0';
|
|
#else
|
|
*pch = '\0';
|
|
#endif
|
|
return (!fErr);
|
|
}
|
|
}
|
|
if (++i > 9)
|
|
break;
|
|
_itoa(i, pch, 10);
|
|
Assert(lstrlen(rgchDir) < cchFullPathMax);
|
|
}
|
|
|
|
if (i <= 9 && !_mkdir(rgchDir))
|
|
{
|
|
fErr = _chdir(rgchDir);
|
|
Assert(!fErr);
|
|
#ifdef DBCS // [J2] Fixed DBCS raid #28.
|
|
// Keep the directory name
|
|
#else
|
|
*pch = '\0';
|
|
#endif
|
|
return (TRUE);
|
|
}
|
|
|
|
*pch = '\0';
|
|
|
|
return (FALSE);
|
|
}
|
|
|
|
/*
|
|
** Purpose:
|
|
** Reopens BAT file and writes DEL or RMDIR line.
|
|
** Arguments:
|
|
** of: OFSTRUCT to REOPEN.
|
|
** szCmd: Command (ANSI chars). ["DEL" or "RMDIR"]
|
|
** szArg: Fully qualified pathname for argument (OEM chars).
|
|
** Returns:
|
|
** TRUE or FALSE.
|
|
**************************************************************************/
|
|
BOOL FWriteBatFile ( OFSTRUCT of, char * szCmd, char * szArg )
|
|
{
|
|
int fhBat = -1;
|
|
BOOL fRet = TRUE;
|
|
|
|
if ((fhBat = OpenFile("a", &of, OF_REOPEN | OF_WRITE)) == -1
|
|
|| _llseek(fhBat, 0L, 2) == -1L
|
|
|| _lwrite(fhBat, szCmd, lstrlen(szCmd)) != (UINT)lstrlen(szCmd)
|
|
|| _lwrite(fhBat, (LPSTR)" ", 1) != 1
|
|
|| _lwrite(fhBat, szArg, lstrlen(szArg)) != (UINT)lstrlen(szArg)
|
|
|| _lwrite(fhBat, (LPSTR)"\r\n", 2) != 2)
|
|
{
|
|
fRet = FALSE;
|
|
}
|
|
|
|
if (fhBat != -1)
|
|
{
|
|
int fErr = _lclose(fhBat);
|
|
|
|
Assert(fErr != -1);
|
|
}
|
|
|
|
return (fRet);
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
/*
|
|
** Purpose:
|
|
** Checks if destination filename is a valid 8.3 name with no path
|
|
*/
|
|
BOOL FValidFATFileName ( char* szName )
|
|
{
|
|
int iLen, ch;
|
|
for (iLen = 0; (ch = *szName++) != '\0'; iLen++)
|
|
{
|
|
if (ch <= ' ' || ch == '\\' || ch == ':' || ch == ',')
|
|
return fFalse;
|
|
if (ch == '.')
|
|
{
|
|
if (iLen == 0 || iLen > 8)
|
|
return fFalse;
|
|
iLen = 9;
|
|
}
|
|
if (iLen == 8 || iLen == 13)
|
|
return fFalse;
|
|
}
|
|
return (iLen > 0);
|
|
}
|
|
#endif /* DEBUG */
|
|
|
|
|
|
/*
|
|
** Purpose:
|
|
** Copies the source files into the given destination dir.
|
|
** Arguments:
|
|
** szModule: Source path (ANSI chars).
|
|
** szDstDir: Destination path (OEM chars).
|
|
** Returns:
|
|
** One of the following bootstrapper return codes:
|
|
** brcMem out of memory
|
|
** brcDS out of disk space
|
|
** brcMemDS out of memory or disk space
|
|
** brcFile expected source file missing
|
|
** brcOkay completed without error
|
|
**************************************************************************/
|
|
BRC BrcCopyFiles ( char * szModule, char * szDstDir, char * szDstDirSlash )
|
|
{
|
|
char rgchSrcFullPath[cchFullPathMax];
|
|
char rgchDstFullPath[cchFullPathMax];
|
|
char rgchTmpDirPath[cchFullPathMax];
|
|
char * szSrc;
|
|
char * szDst;
|
|
int cbSrc;
|
|
BRC brc = brcOkay;
|
|
int fhBat = -1;
|
|
OFSTRUCT ofBat;
|
|
int fErr;
|
|
BOOL fCabinetFiles = FALSE;
|
|
|
|
lstrcpy(rgchDstFullPath, szDstDir);
|
|
lstrcat(rgchDstFullPath, "\\_MSSETUP._Q_");
|
|
Assert(lstrlen(rgchDstFullPath) < cchFullPathMax);
|
|
_chmod(rgchDstFullPath, S_IREAD | S_IWRITE);
|
|
remove(rgchDstFullPath);
|
|
|
|
OemToAnsi(rgchDstFullPath, rgchDstFullPath);
|
|
fhBat = OpenFile(rgchDstFullPath, &ofBat, OF_CREATE | OF_WRITE);
|
|
AnsiToOem(rgchDstFullPath, rgchDstFullPath);
|
|
if (fhBat == -1)
|
|
return (brcMemDS);
|
|
|
|
fErr = _lclose(fhBat);
|
|
Assert(!fErr);
|
|
|
|
szSrc = (char *)LocalLock(hSrcLst);
|
|
if (szSrc == NULL)
|
|
return (brcMem);
|
|
|
|
szDst = (char *)LocalLock(hDstLst);
|
|
|
|
if (szDst == NULL) {
|
|
LocalUnlock (hSrcLst);
|
|
return (brcMem);
|
|
}
|
|
|
|
for (;
|
|
(cbSrc = lstrlen(szSrc)) != 0;
|
|
szSrc += cbSrc + 1, szDst += lstrlen(szDst) + 1)
|
|
{
|
|
|
|
//
|
|
// This code has been added so that we can detect a path
|
|
// in setup.lst for the right hand side of the equals sign. This
|
|
// allows us flexiblity in specifying where files like setup.inf
|
|
// should be pulled from, otherwise we always use the files from
|
|
// the original source location. If we detect "<anything>:\" or
|
|
// "\\" then we assume it is a path.
|
|
//
|
|
if( ((':' == szSrc[1]) && ('\\' == szSrc[2])) ||
|
|
(('\\' == szSrc[0]) && ('\\' == szSrc[1])) )
|
|
{
|
|
rgchSrcFullPath[0] = '\0';
|
|
}
|
|
else
|
|
{
|
|
lstrcpy(rgchSrcFullPath, szModule);
|
|
}
|
|
|
|
lstrcat(rgchSrcFullPath, szSrc);
|
|
lstrcpy(rgchDstFullPath, szDstDir);
|
|
lstrcat(rgchDstFullPath, "\\");
|
|
lstrcat(rgchDstFullPath, szDst);
|
|
#ifdef DEBUG
|
|
if (!FValidFATFileName(szDst))
|
|
{
|
|
wsprintf(szDebugBuf, "Invalid destination file, must be 8.3: %s",
|
|
szDst);
|
|
MessageBox(NULL, szDebugBuf, szDebugMsg, MB_OK | MB_ICONSTOP);
|
|
continue;
|
|
}
|
|
#endif /* DEBUG */
|
|
Assert(lstrlen(rgchSrcFullPath) < cchFullPathMax);
|
|
Assert(lstrlen(rgchDstFullPath) < cchFullPathMax);
|
|
if ( !FWriteBatFile(ofBat, "ATTRIB -R", rgchDstFullPath)
|
|
|| !FWriteBatFile(ofBat, "DEL", rgchDstFullPath))
|
|
{
|
|
brc = brcDS;
|
|
break;
|
|
}
|
|
|
|
if (*szSrc == '@') /* cabinet file */
|
|
{
|
|
if (*rgchCabinetFName == '\0')
|
|
{
|
|
brc = brcFile;
|
|
#ifdef DEBUG
|
|
lstrcpy(rgchErrorFile, ". Missing CABINET= line");
|
|
#endif //DEBUG
|
|
break;
|
|
}
|
|
fCabinetFiles = TRUE;
|
|
continue;
|
|
}
|
|
|
|
if ((brc = BrcCopy(rgchSrcFullPath, rgchDstFullPath)) != brcOkay)
|
|
break;
|
|
_chmod(rgchDstFullPath, S_IREAD);
|
|
}
|
|
LocalUnlock(hSrcLst);
|
|
LocalUnlock(hDstLst);
|
|
|
|
lstrcpy(rgchDstFullPath, szDstDir);
|
|
lstrcat(rgchDstFullPath, "\\_MSSETUP._Q_");
|
|
Assert(lstrlen(rgchDstFullPath) < cchFullPathMax);
|
|
|
|
Assert(szDstDirSlash != szNull);
|
|
Assert(*szDstDirSlash == chDirSep);
|
|
*szDstDirSlash = chEos;
|
|
lstrcpy(rgchTmpDirPath, szDstDir);
|
|
*szDstDirSlash = chDirSep;
|
|
|
|
if (brc == brcOkay
|
|
&& (!FWriteBatFile(ofBat, "DEL", rgchDstFullPath)
|
|
|| !FWriteBatFile(ofBat, "RMDIR", szDstDir)
|
|
|| !FWriteBatFile(ofBat, "RMDIR", rgchTmpDirPath)))
|
|
{
|
|
return (brcDS);
|
|
}
|
|
|
|
if (fCabinetFiles && brc == brcOkay)
|
|
{
|
|
szSrc = (char *)LocalLock(hSrcLst);
|
|
if(szSrc == NULL)
|
|
return (brcMem);
|
|
|
|
szDst = (char *)LocalLock(hDstLst);
|
|
if( szDst == NULL) {
|
|
LocalUnlock (hSrcLst);
|
|
return (brcMem);
|
|
}
|
|
#ifdef DEBUG
|
|
if (!FValidFATFileName(rgchCabinetFName))
|
|
{
|
|
wsprintf(szDebugBuf, "Invalid cabinet file, must be 8.3: %s",
|
|
rgchCabinetFName);
|
|
MessageBox(NULL, szDebugBuf, szDebugMsg, MB_OK | MB_ICONSTOP);
|
|
}
|
|
else
|
|
#endif /* DEBUG */
|
|
|
|
brc = BrcHandleCabinetFiles(hwndBoot, rgchCabinetFName,
|
|
cFirstCabinetNum, cLastCabinetNum, szModule, szDstDir,
|
|
szSrc, szDst, rgchErrorFile, rgchDstFullPath);
|
|
|
|
LocalUnlock(hSrcLst);
|
|
LocalUnlock(hDstLst);
|
|
}
|
|
|
|
return (brc);
|
|
}
|
|
|
|
|
|
/*
|
|
** Purpose:
|
|
** Removes the files previously copied to the temp dest dir.
|
|
** Arguments:
|
|
** szDstDir: full path to destination directory (OEM chars).
|
|
** Returns:
|
|
** None.
|
|
**************************************************************************/
|
|
VOID RemoveFiles ( char * szDstDir )
|
|
{
|
|
char rgchDstFullPath[cchFullPathMax];
|
|
char * szDst;
|
|
int cbDst;
|
|
int i;
|
|
OFSTRUCT ofs;
|
|
UINT fModeSav;
|
|
|
|
fModeSav = SetErrorMode(fNoErrMes);
|
|
szDst = (char *)LocalLock(hDstLst);
|
|
|
|
if (szDst == NULL)
|
|
return;
|
|
|
|
for (; (cbDst = lstrlen(szDst)) != 0; szDst += cbDst + 1)
|
|
{
|
|
lstrcpy(rgchDstFullPath, szDstDir);
|
|
lstrcat(rgchDstFullPath, "\\");
|
|
lstrcat(rgchDstFullPath, szDst);
|
|
Assert(lstrlen(rgchDstFullPath) < cchFullPathMax);
|
|
|
|
/* Don't try to remove the file if it doesn't exist */
|
|
if (OpenFile(rgchDstFullPath, &ofs, OF_EXIST) == HFILE_ERROR)
|
|
continue;
|
|
|
|
/* Try to _chmod the file up to cRetryMax times.
|
|
*/
|
|
for (i = 0; i < cRetryMax; i++)
|
|
{
|
|
if (_chmod(rgchDstFullPath, S_IWRITE) == 0)
|
|
break;
|
|
FYield();
|
|
}
|
|
|
|
/* Try to remove the file up to cRetryMax times.
|
|
*/
|
|
for (i = 0; i < cRetryMax; i++)
|
|
{
|
|
if (remove(rgchDstFullPath) == 0)
|
|
break;
|
|
FYield();
|
|
}
|
|
}
|
|
|
|
LocalUnlock(hDstLst);
|
|
SetErrorMode(fModeSav);
|
|
|
|
lstrcpy(rgchDstFullPath, szDstDir);
|
|
lstrcat(rgchDstFullPath, "\\_MSSETUP._Q_");
|
|
Assert(lstrlen(rgchDstFullPath) < cchFullPathMax);
|
|
_chmod(rgchDstFullPath, S_IWRITE);
|
|
remove(rgchDstFullPath);
|
|
}
|
|
|
|
|
|
/*
|
|
** Purpose:
|
|
** Copies the given source file to the given destination.
|
|
** Arguments:
|
|
** szFullPathSrc: full path name of source file (ANSI chars).
|
|
** szFullPathDst: full path name of destination file (OEM chars).
|
|
** Returns:
|
|
** One of the following bootstrapper return codes:
|
|
** brcMem out of memory
|
|
** brcDS out of disk space
|
|
** brcMemDS out of memory or disk space
|
|
** brcFile expected source file missing
|
|
** brcOkay completed without error
|
|
**************************************************************************/
|
|
BRC BrcCopy ( char * szFullPathSrc, char * szFullPathDst )
|
|
{
|
|
int fhSrc = -1;
|
|
int fhDst = -1;
|
|
OFSTRUCT ofSrc, ofDst;
|
|
BRC brc = brcMemDS;
|
|
int fErr;
|
|
|
|
#ifdef APPCOMP
|
|
if ((fhSrc = OpenFile(szFullPathSrc, &ofSrc, OF_READ)) == -1)
|
|
{
|
|
brc = brcFile;
|
|
lstrcpy(rgchErrorFile, szFullPathSrc);
|
|
goto CopyFailed;
|
|
}
|
|
#endif /* APPCOMP */
|
|
|
|
/* REVIEW: BUG: if szFullPathDst is an existing subdirectory
|
|
** instead of a file, we'll fail trying to open it, think we're
|
|
** out of disk space, and go back up to try another disk.
|
|
** This is acceptable for now.
|
|
*/
|
|
_chmod(szFullPathDst, S_IREAD | S_IWRITE);
|
|
OemToAnsi(szFullPathDst, szFullPathDst);
|
|
fhDst = OpenFile(szFullPathDst, &ofDst, OF_CREATE | OF_WRITE);
|
|
AnsiToOem(szFullPathDst, szFullPathDst);
|
|
if (fhDst == -1)
|
|
goto CopyFailed;
|
|
|
|
#ifdef APPCOMP
|
|
if (WReadHeaderInfo(fhSrc) > 0)
|
|
{
|
|
LONG lRet;
|
|
|
|
lRet = LcbDecompFile(fhSrc, fhDst, -1, 0, TRUE, NULL, 0L, NULL, 0,
|
|
NULL);
|
|
if (lRet < 0L)
|
|
{
|
|
if (lRet == (LONG)rcOutOfMemory)
|
|
brc = brcMem;
|
|
if (lRet == (LONG)rcWriteError)
|
|
brc = brcDS;
|
|
goto CopyFailed;
|
|
}
|
|
FFreeHeaderInfo();
|
|
}
|
|
else /* copy the file using LZExpand */
|
|
#endif /* APPCOMP */
|
|
{
|
|
HFILE hSrcLZ;
|
|
DWORD dwRet;
|
|
|
|
#ifdef APPCOMP
|
|
fErr = _lclose(fhSrc);
|
|
Assert(!fErr);
|
|
fhSrc = -1;
|
|
#endif /* APPCOMP */
|
|
|
|
if ((hSrcLZ = LZOpenFile(szFullPathSrc, &ofSrc, OF_READ)) == -1)
|
|
{
|
|
brc = brcFile;
|
|
lstrcpy(rgchErrorFile, szFullPathSrc);
|
|
goto CopyFailed;
|
|
}
|
|
|
|
/* We would like to yield more often, but LZCopy has no callbacks */
|
|
FYield();
|
|
|
|
dwRet = LZCopy(hSrcLZ, fhDst);
|
|
LZClose(hSrcLZ);
|
|
|
|
if (dwRet >= LZERROR_UNKNOWNALG)
|
|
{
|
|
if (dwRet == LZERROR_GLOBALLOC)
|
|
brc = brcMem;
|
|
if (dwRet == LZERROR_WRITE)
|
|
brc = brcDS;
|
|
goto CopyFailed;
|
|
}
|
|
}
|
|
|
|
brc = brcOkay;
|
|
|
|
CopyFailed:
|
|
#ifdef APPCOMP
|
|
if (fhSrc != -1)
|
|
{
|
|
fErr = _lclose(fhSrc);
|
|
Assert(!fErr);
|
|
}
|
|
#endif /* APPCOMP */
|
|
if (fhDst != -1)
|
|
{
|
|
fErr = _lclose(fhDst);
|
|
Assert(!fErr);
|
|
}
|
|
|
|
return (brc);
|
|
}
|
|
|
|
|
|
/*
|
|
** Purpose:
|
|
** Determine the storage space remaining on disk.
|
|
** Arguments:
|
|
** nDrive: drive number (1='A', 2='B', etc.)
|
|
** Returns:
|
|
** Number of bytes free on disk,
|
|
** or 0 if not a valid drive.
|
|
+++
|
|
** Implementation:
|
|
** Calls DOS interrupt 21h, funct 36h.
|
|
**************************************************************************/
|
|
LONG LcbFreeDrive ( int nDrive )
|
|
{
|
|
LONG lcbRet;
|
|
CHAR achRoot[4];
|
|
ULARGE_INTEGER freeBytes;
|
|
|
|
achRoot[0] = 'A'+nDrive-1;
|
|
achRoot[1] = ':';
|
|
achRoot[2] = '\\';
|
|
achRoot[3] = 0;
|
|
memset(&freeBytes, 0, sizeof(freeBytes));
|
|
|
|
GetDiskFreeSpaceEx(achRoot, &freeBytes, 0, 0);
|
|
lcbRet = freeBytes.LowPart;
|
|
|
|
/* KLUDGE: Drives bigger than 2 GB can return zero total space!
|
|
*/
|
|
if (lcbRet < 0L || lcbRet > (999999L * 1024L))
|
|
{
|
|
return (999999L * 1024L);
|
|
}
|
|
|
|
return (lcbRet);
|
|
}
|
|
|
|
|
|
/*
|
|
** Purpose:
|
|
** Creates and displays bootstrapper window.
|
|
** Arguments:
|
|
** hInstance: process instance handle
|
|
** Returns:
|
|
** Window handle to bootstrapper window, or
|
|
** NULL if the window could not be created.
|
|
**************************************************************************/
|
|
HWND HwndInitBootWnd ( HANDLE hInstance )
|
|
{
|
|
WNDCLASS wc;
|
|
HWND hwnd;
|
|
int cx, cy;
|
|
|
|
wc.style = 0;
|
|
wc.lpfnWndProc = BootWndProc;
|
|
wc.cbClsExtra = 0;
|
|
wc.cbWndExtra = 0;
|
|
wc.hInstance = hInstance;
|
|
wc.hIcon = NULL;
|
|
wc.hCursor = NULL;
|
|
wc.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
|
|
wc.lpszMenuName = NULL;
|
|
wc.lpszClassName = szBootClass;
|
|
if (!RegisterClass(&wc))
|
|
return (NULL);
|
|
|
|
cx = GetSystemMetrics(SM_CXSCREEN) / 2;
|
|
cy = GetSystemMetrics(SM_CYSCREEN) / 3;
|
|
|
|
hwnd = CreateWindow(szBootClass, rgchBootTitle,
|
|
WS_DLGFRAME, cx / 2, cy, cx, cy, NULL, NULL, hInstance, NULL);
|
|
|
|
if (hwnd == NULL)
|
|
return (NULL);
|
|
|
|
if (!fQuietMode)
|
|
{
|
|
ShowWindow(hwnd, SW_SHOWNORMAL);
|
|
UpdateWindow(hwnd);
|
|
}
|
|
|
|
return (hwnd);
|
|
}
|
|
|
|
// ripped off from mvdm\wow32\wgtext.c
|
|
ULONG GetTextExtent(HDC hdc, LPSTR lpstr, int cbString)
|
|
{
|
|
ULONG ul = 0;
|
|
SIZE size4;
|
|
|
|
if ((GetTextExtentPoint(
|
|
hdc,
|
|
lpstr,
|
|
cbString,
|
|
&size4
|
|
)))
|
|
{
|
|
// check if either cx or cy are bigger than SHRT_MAX == 7fff
|
|
// but do it in ONE SINGLE check
|
|
|
|
if ((size4.cx | size4.cy) & ~SHRT_MAX)
|
|
{
|
|
if (size4.cx > SHRT_MAX)
|
|
ul = SHRT_MAX;
|
|
else
|
|
ul = (ULONG)size4.cx;
|
|
|
|
if (size4.cy > SHRT_MAX)
|
|
ul |= (SHRT_MAX << 16);
|
|
else
|
|
ul |= (ULONG)(size4.cy << 16);
|
|
}
|
|
else
|
|
{
|
|
ul = (ULONG)(size4.cx | (size4.cy << 16));
|
|
}
|
|
|
|
}
|
|
return (ul);
|
|
}
|
|
|
|
/*
|
|
** Purpose:
|
|
** WndProc for bootstrapper window.
|
|
** Arguments:
|
|
** Standard Windows WndProc arguments.
|
|
** Returns:
|
|
** Result of call DefWindowProc, or zero if WM_PAINT message.
|
|
**************************************************************************/
|
|
LRESULT CALLBACK BootWndProc ( HWND hwnd, UINT wMsgID, WPARAM wParam,
|
|
LPARAM lParam )
|
|
{
|
|
HDC hdc;
|
|
PAINTSTRUCT ps;
|
|
RECT rect;
|
|
UINT iMargin;
|
|
|
|
switch (wMsgID)
|
|
{
|
|
#ifdef DBCS // [J3] Fixed KK raid #12.
|
|
case WM_CREATE:
|
|
{
|
|
if (!fQuietMode)
|
|
{
|
|
int x, y, cx, cy;
|
|
hdc = BeginPaint(hwnd, &ps);
|
|
GetClientRect(hwnd, &rect);
|
|
cx = (LOWORD(GetTextExtent(hdc, rgchBootMess, lstrlen(rgchBootMess))) + 13) / 14 * 16 + 2;
|
|
if (cx > rect.right)
|
|
{
|
|
if (cx > GetSystemMetrics(SM_CXSCREEN))
|
|
cx = GetSystemMetrics(SM_CXSCREEN);
|
|
x = (GetSystemMetrics(SM_CXSCREEN) - cx) / 2;
|
|
y = cy = GetSystemMetrics(SM_CYSCREEN) / 3;
|
|
SetWindowPos(hwnd, NULL, x, y, cx, cy, SWP_NOZORDER);
|
|
}
|
|
EndPaint(hwnd, &ps);
|
|
}
|
|
break;
|
|
}
|
|
#endif
|
|
case WM_PAINT:
|
|
if (!fQuietMode)
|
|
{
|
|
hdc = BeginPaint(hwnd, &ps);
|
|
GetClientRect(hwnd, &rect);
|
|
iMargin = rect.right / 16;
|
|
rect.top = rect.bottom / 2 - GetSystemMetrics(SM_CYCAPTION);
|
|
rect.left = iMargin;
|
|
rect.right -= iMargin;
|
|
SetBkMode(hdc, TRANSPARENT);
|
|
DrawText(hdc, rgchBootMess, -1, &rect,
|
|
DT_WORDBREAK | DT_CENTER | DT_NOPREFIX);
|
|
EndPaint(hwnd, &ps);
|
|
}
|
|
break;
|
|
default:
|
|
return (DefWindowProc(hwnd, wMsgID, wParam, lParam));
|
|
}
|
|
|
|
return (0L);
|
|
}
|
|
|
|
|
|
/*
|
|
** Purpose:
|
|
** Get size of file.
|
|
** Arguments:
|
|
** szFile: List file name (full path, ANSI).
|
|
** pcbSize: Pointer to variable to receive file size.
|
|
** Returns:
|
|
** FALSE if file found and size >= 64K.
|
|
** TRUE otherwise.
|
|
**************************************************************************/
|
|
BOOL FGetFileSize ( char * szFile, UINT * pcbSize )
|
|
{
|
|
int fh;
|
|
int fErr;
|
|
LONG lcb;
|
|
|
|
*pcbSize = 0;
|
|
if ((fh = _lopen(szFile, OF_READ)) == -1)
|
|
{
|
|
return (TRUE);
|
|
}
|
|
|
|
if ((lcb = _llseek(fh, 0L, 2)) > 65535)
|
|
{
|
|
#pragma warning(disable:4127) /* conditional expression is constant */
|
|
Assert(FALSE);
|
|
#pragma warning(default:4127)
|
|
_lclose(fh);
|
|
return (FALSE);
|
|
}
|
|
*pcbSize = (UINT)lcb;
|
|
fErr = _lclose(fh);
|
|
Assert(!fErr);
|
|
|
|
return (TRUE);
|
|
}
|
|
|
|
|
|
/*
|
|
** Purpose:
|
|
** Build file Src and Dst lists from LST file.
|
|
** Arguments:
|
|
** szFile: List file name (full path, ANSI).
|
|
** cbFile: Size of list file
|
|
** Note:
|
|
** Sets globals: hSrcLst, hDstLst.
|
|
** Returns:
|
|
** One of the following Bootstrapper return codes:
|
|
** brcMem out of memory
|
|
** brcLst list file is corrupted
|
|
** brcOkay completed without error
|
|
**************************************************************************/
|
|
BRC BrcBuildFileLists ( char * szFile, UINT cbFile )
|
|
{
|
|
char rgchDst[cchLstLineMax];
|
|
char * szSrc;
|
|
char * szDst;
|
|
char * pchDstStart;
|
|
int cbSrc;
|
|
UINT i;
|
|
|
|
/* Build Src List */
|
|
|
|
if ((hSrcLst = LocalAlloc(LMEM_MOVEABLE, cbFile)) == NULL)
|
|
return (brcMem);
|
|
szSrc = (char *)LocalLock(hSrcLst);
|
|
if(szSrc == (char *)NULL)
|
|
return (brcMem);
|
|
|
|
i = GetPrivateProfileString(szFilesSect, NULL, "", szSrc, cbFile, szFile);
|
|
if (i <= 0)
|
|
{
|
|
LocalUnlock(hSrcLst);
|
|
hSrcLst = LocalFree(hSrcLst);
|
|
Assert(hSrcLst == NULL);
|
|
return (brcLst);
|
|
}
|
|
Assert(i+1 < cbFile);
|
|
szSrc[i++] = '\0'; /* force double zero at end */
|
|
szSrc[i++] = '\0';
|
|
LocalUnlock(hSrcLst);
|
|
hSrcLst = LocalReAlloc(hSrcLst, i, LMEM_MOVEABLE);
|
|
if(hSrcLst == NULL)
|
|
return (brcMem);
|
|
|
|
/* Build Dst List */
|
|
if ((hDstLst = LocalAlloc(LMEM_MOVEABLE, cbFile)) == NULL)
|
|
{
|
|
hSrcLst = LocalFree(hSrcLst);
|
|
Assert(hSrcLst == NULL);
|
|
return (brcMem);
|
|
}
|
|
|
|
szSrc = (char *)LocalLock(hSrcLst);
|
|
if (szSrc == (char *)NULL)
|
|
return (brcMem);
|
|
|
|
szDst = pchDstStart = (char *)LocalLock(hDstLst);
|
|
if (szDst == (char *)NULL) {
|
|
LocalUnlock (hDstLst);
|
|
return (brcMem);
|
|
}
|
|
|
|
for (;
|
|
(cbSrc = lstrlen(szSrc)) != 0;
|
|
szSrc += cbSrc + 1, szDst += lstrlen(szDst) + 1)
|
|
{
|
|
if (GetPrivateProfileString(szFilesSect, szSrc, "", rgchDst,
|
|
cchLstLineMax, szFile) <= 0)
|
|
{
|
|
LocalUnlock(hSrcLst);
|
|
LocalUnlock(hDstLst);
|
|
FreeFileLists();
|
|
return (brcLst);
|
|
}
|
|
AnsiToOem(rgchDst, rgchDst);
|
|
lstrcpy(szDst, rgchDst);
|
|
}
|
|
*szDst = '\0'; /* force double zero at end */
|
|
LocalUnlock(hSrcLst);
|
|
LocalUnlock(hDstLst);
|
|
hDstLst = LocalReAlloc(hDstLst, (int)(szDst - pchDstStart) + 1,
|
|
LMEM_MOVEABLE);
|
|
if (hDstLst == NULL)
|
|
return (brcMem);
|
|
|
|
return (brcOkay);
|
|
}
|
|
|
|
|
|
/*
|
|
** Purpose:
|
|
** Frees file list buffers with non-NULL handles
|
|
** and sets them to NULL.
|
|
** Arguments:
|
|
** none.
|
|
** Returns:
|
|
** none.
|
|
**************************************************************************/
|
|
VOID FreeFileLists ()
|
|
{
|
|
if (hSrcLst != NULL)
|
|
hSrcLst = LocalFree(hSrcLst);
|
|
if (hDstLst != NULL)
|
|
hDstLst = LocalFree(hDstLst);
|
|
Assert(hSrcLst == NULL);
|
|
Assert(hDstLst == NULL);
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
** Purpose:
|
|
** Spawns off a process with WinExec and waits for it to complete.
|
|
** Arguments:
|
|
** szCmdLn: Line passed to WinExec (cannot have leading spaces).
|
|
** Returns:
|
|
** TRUE if successful, FALSE if not.
|
|
+++
|
|
** Implementation:
|
|
** GetModuleUsage will RIP under Win 3.0 Debug if module count is
|
|
** zero (okay to ignore and continue), but the GetModuleHandle
|
|
** check will catch all zero cases for single instances of the
|
|
** driver, the usual case. [Under Win 3.1 we will be able to
|
|
** replace both checks with just an IsTask(hMod) check.]
|
|
**************************************************************************/
|
|
BOOL FExecAndWait ( char * szCmdLn, HWND hwndHide )
|
|
{
|
|
UINT hMod;
|
|
MSG msg;
|
|
|
|
Assert(!isspace(*szCmdLn)); /* leading space kills WinExec */
|
|
|
|
if ((hMod = WinExec(szCmdLn, SW_SHOWNORMAL)) > 32)
|
|
{
|
|
UINT i;
|
|
UINT_PTR idTimer;
|
|
|
|
/* KLUDGE: Give the app some time to create its main window.
|
|
*
|
|
* On newer versions of NT, we were exiting the while loop
|
|
* (below) and cleaning up the temp dir before the app had
|
|
* even put up its window.
|
|
*
|
|
* NOTE: In trials, we only had to retry once, so cRetryMax
|
|
* may be overkill, but it should be pretty rare that this
|
|
* would fail in shipping products anyway.
|
|
*/
|
|
for (i = 0; i < cRetryMax; i++)
|
|
{
|
|
if(FindWindow(rgchDrvWinClass, NULL) != NULL)
|
|
break;
|
|
if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
|
|
{
|
|
TranslateMessage(&msg);
|
|
DispatchMessage(&msg);
|
|
}
|
|
}
|
|
|
|
/* Set the timer to fire every 1/10 of a second. This is
|
|
necessary because we might never return from GetMessage */
|
|
idTimer = SetTimer(NULL, 0, 100, NULL);
|
|
/*
|
|
** REVIEW - FindWindow() will wait until the LAST setup quits (not
|
|
** necessarily this setup. If exec'ing a 16-bit app we could
|
|
** use the old code:
|
|
** while (GetModuleHandle(rgchDrvModName) && GetModuleUsage(hMod))
|
|
** but on NT this fails so for 32-bit apps we could attempt to
|
|
** remove one of the executable files (slow?).
|
|
**
|
|
** REVIEW - This loop becomes a busy wait under NT, which is bad.
|
|
** However, it doesn't appear to affect ACME's performance
|
|
** noticeably.
|
|
*/
|
|
while (FindWindow(rgchDrvWinClass, NULL) != NULL)
|
|
{
|
|
if (GetMessage(&msg, NULL, 0, 0))
|
|
{
|
|
TranslateMessage(&msg);
|
|
DispatchMessage(&msg);
|
|
}
|
|
if (msg.message == WM_TIMER && hwndHide != (HWND)NULL)
|
|
{
|
|
ShowWindow(hwndHide, SW_HIDE);
|
|
hwndHide = (HWND)NULL;
|
|
}
|
|
}
|
|
if (idTimer != 0)
|
|
KillTimer(0, idTimer);
|
|
return (TRUE);
|
|
}
|
|
#ifdef DEBUG
|
|
wsprintf(szDebugBuf, "WinExec Error: %d", hMod);
|
|
MessageBox(NULL, szDebugBuf, szDebugMsg, MB_OK | MB_ICONSTOP);
|
|
#endif /* DEBUG */
|
|
|
|
return (FALSE);
|
|
}
|
|
|
|
|
|
/*
|
|
** Purpose: Processes messages that may be in the queue.
|
|
** Arguments: none
|
|
** Returns: none
|
|
**************************************************************************/
|
|
void PUBLIC FYield ( VOID )
|
|
{
|
|
MSG msg;
|
|
|
|
while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
|
|
{
|
|
TranslateMessage(&msg);
|
|
DispatchMessage(&msg);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
**************************************************************************/
|
|
BOOL FLstSectionExists ( char * szLstFileName, char * szSect )
|
|
{
|
|
return (GetPrivateProfileString(szSect, "CmdLine", "", rgchCmdLine,
|
|
cchLstLineMax, szLstFileName) > 0);
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
**************************************************************************/
|
|
DWORD GetCpuArchitecture ()
|
|
{
|
|
SYSTEM_INFO sysInfo;
|
|
|
|
GetSystemInfo(&sysInfo);
|
|
|
|
return sysInfo.wProcessorArchitecture;
|
|
}
|
|
|
|
|
|
static CSZC cszcBootstrapperKey = "MS Setup (ACME)\\Bootstrapper\\Exit Level";
|
|
static CSZC cszcEelRunning = "Running";
|
|
|
|
/*
|
|
** Purpose:
|
|
** Lets Acme know the bootstrapper launched it. So Acme will let
|
|
** us know its exit error level.
|
|
** Arguments:
|
|
** none.
|
|
** Returns:
|
|
** fTrue if successful, fFalse otherwise.
|
|
** Notes:
|
|
** REVIEW: Probably should use DDE instead of the Registration
|
|
** Database.
|
|
**************************************************************************/
|
|
BOOL FNotifyAcme ( VOID )
|
|
{
|
|
if (!FCreateRegKey(cszcBootstrapperKey))
|
|
{
|
|
return (fFalse);
|
|
}
|
|
if (!FCreateRegKeyValue(cszcBootstrapperKey, cszcEelRunning))
|
|
{
|
|
return (fFalse);
|
|
}
|
|
if (!FFlushRegKey())
|
|
{
|
|
return (fFalse);
|
|
}
|
|
return (fTrue);
|
|
}
|
|
|
|
|
|
/*
|
|
** Purpose:
|
|
** Get the exit error level set by Acme and clean up the Registration
|
|
** Database.
|
|
** Arguments:
|
|
** peel: Exit error level (to be set).
|
|
** Returns:
|
|
** fTrue if successful, fFalse otherwise.
|
|
**************************************************************************/
|
|
BOOL FGetAcmeErrorLevel ( EEL * peel )
|
|
{
|
|
CHAR rgchValue[cchSzMax];
|
|
|
|
if (FGetRegKeyValue(cszcBootstrapperKey, rgchValue, sizeof rgchValue))
|
|
{
|
|
#ifdef DEBUG
|
|
/*
|
|
* Assert(isdigit(rgchValue[0]));
|
|
* Assert(isdigit(rgchValue[1]) || rgchValue[1] == chEos);
|
|
*/
|
|
UINT i;
|
|
BOOL fValidValue = fFalse;
|
|
|
|
/* Assumes valid values are 1 or 2 digit numbers. */
|
|
for (i = 0; rgchValue[i] != chEos; i++)
|
|
{
|
|
fValidValue = fTrue;
|
|
if (!isdigit(rgchValue[i]) || i > 1)
|
|
{
|
|
fValidValue = fFalse;
|
|
break;
|
|
}
|
|
}
|
|
if (!fValidValue)
|
|
{
|
|
char szBuf[cchSzMax];
|
|
|
|
wsprintf(szBuf, "RegKeyValue (%s)", rgchValue);
|
|
MessageBox(NULL, szBuf, "Debug Assertion in FGetAcmeErrorLevel",
|
|
MB_OK | MB_ICONSTOP);
|
|
}
|
|
#endif /* DEBUG */
|
|
|
|
*peel = atoi(rgchValue);
|
|
DeleteRegKey(cszcBootstrapperKey);
|
|
return (fTrue);
|
|
}
|
|
else
|
|
{
|
|
if (fWin31)
|
|
{
|
|
*peel = eelSuccess;
|
|
return fTrue;
|
|
}
|
|
return (fFalse);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
** Purpose:
|
|
** Creates a Registration Database key that is a subkey of
|
|
** cszcBootstrapperKey.
|
|
****************************************************************************/
|
|
BOOL FCreateRegKey ( CSZC cszcKey )
|
|
{
|
|
HKEY hkey;
|
|
|
|
if (RegCreateKey(HKEY_CLASSES_ROOT, cszcKey, &hkey) != ERROR_SUCCESS)
|
|
{
|
|
DispErrBrc(brcRegDb, TRUE, MB_OK | MB_ICONSTOP, NULL, NULL, NULL);
|
|
return (fFalse);
|
|
}
|
|
|
|
if (RegCloseKey(hkey) != ERROR_SUCCESS)
|
|
{
|
|
DispErrBrc(brcRegDb, TRUE, MB_OK | MB_ICONSTOP, NULL, NULL, NULL);
|
|
return (fFalse);
|
|
}
|
|
|
|
return (fTrue);
|
|
}
|
|
|
|
|
|
/*
|
|
** Purpose:
|
|
** API to check for the existence of the specified key in
|
|
** the Registration Database.
|
|
****************************************************************************/
|
|
BOOL FDoesRegKeyExist ( CSZC cszcKey )
|
|
{
|
|
HKEY hkey;
|
|
|
|
if (RegOpenKey(HKEY_CLASSES_ROOT, cszcKey, &hkey) != ERROR_SUCCESS)
|
|
return (fFalse);
|
|
|
|
RegCloseKey(hkey);
|
|
|
|
return (fTrue);
|
|
}
|
|
|
|
|
|
/*
|
|
** Purpose:
|
|
** Creates a Registration Database key that is a subkey of
|
|
** HKEY_CLASSES_ROOT and associates a value with the key.
|
|
****************************************************************************/
|
|
BOOL FCreateRegKeyValue ( CSZC cszcKey, CSZC cszcValue )
|
|
{
|
|
if (RegSetValue(HKEY_CLASSES_ROOT, cszcKey, REG_SZ, cszcValue,
|
|
lstrlen(cszcKey)) != ERROR_SUCCESS)
|
|
{
|
|
DispErrBrc(brcRegDb, TRUE, MB_OK | MB_ICONSTOP, NULL, NULL, NULL);
|
|
return (fFalse);
|
|
}
|
|
|
|
return (fTrue);
|
|
}
|
|
|
|
|
|
/*
|
|
** Purpose:
|
|
** Determines the value associated with the specified Registration
|
|
** Database key.
|
|
****************************************************************************/
|
|
BOOL FGetRegKeyValue ( CSZC cszcKey, SZ szBuf, CB cbBufMax )
|
|
{
|
|
LONG lcb = cbBufMax;
|
|
|
|
if (szBuf != szNull && cbBufMax != 0)
|
|
*szBuf = chEos;
|
|
|
|
if (!FDoesRegKeyExist(cszcKey))
|
|
return (fFalse);
|
|
|
|
if (RegQueryValue(HKEY_CLASSES_ROOT, cszcKey, szBuf, &lcb)
|
|
!= ERROR_SUCCESS)
|
|
{
|
|
DispErrBrc(brcRegDb, TRUE, MB_OK | MB_ICONSTOP, NULL, NULL, NULL);
|
|
return (fFalse);
|
|
}
|
|
|
|
Assert(lcb < cbMaxConst);
|
|
|
|
return (fTrue);
|
|
}
|
|
|
|
|
|
/*
|
|
** Purpose:
|
|
** API to remove the specified Registration Database key,
|
|
** its associated values, and subkeys.
|
|
****************************************************************************/
|
|
VOID DeleteRegKey ( CSZC cszcKey )
|
|
{
|
|
char rgchKey[cchSzMax], rgchBuffer[cchSzMax];
|
|
char *pch;
|
|
HKEY hKeyT = NULL;
|
|
|
|
lstrcpy(rgchKey, cszcKey);
|
|
RegDeleteKey(HKEY_CLASSES_ROOT, rgchKey);
|
|
pch = rgchKey + 1;
|
|
|
|
while(pch > rgchKey)
|
|
{
|
|
pch = rgchKey + lstrlen(rgchKey);
|
|
while (pch > rgchKey)
|
|
{
|
|
if (*pch == '\\')
|
|
break;
|
|
pch--;
|
|
}
|
|
if (*pch != '\\')
|
|
break;
|
|
*pch = '\0';
|
|
if (RegOpenKey(HKEY_CLASSES_ROOT, rgchKey, &hKeyT) != ERROR_SUCCESS)
|
|
break;
|
|
if (RegEnumKey(hKeyT, 0, rgchBuffer, sizeof(rgchBuffer)) == ERROR_SUCCESS)
|
|
{
|
|
break;
|
|
}
|
|
|
|
RegCloseKey(hKeyT);
|
|
hKeyT = NULL;
|
|
RegDeleteKey(HKEY_CLASSES_ROOT, rgchKey);
|
|
}
|
|
|
|
if (hKeyT != NULL)
|
|
RegCloseKey(hKeyT);
|
|
|
|
}
|
|
|
|
|
|
/*
|
|
** Purpose:
|
|
** API to flush the specified Registration Database key.
|
|
****************************************************************************/
|
|
BOOL FFlushRegKey ( VOID )
|
|
{
|
|
/* REVIEW: Does 16 bit code need to flush the RegDb? RegFlushKey is
|
|
32 bit.
|
|
if (RegFlushKey(HKEY_CLASSES_ROOT)) != ERROR_SUCCESS)
|
|
{
|
|
DispErrBrc(brcRegDb, TRUE, MB_OK | MB_ICONSTOP, NULL, NULL, NULL);
|
|
return (fFalse);
|
|
}
|
|
*/
|
|
|
|
return (fTrue);
|
|
}
|
|
|
|
|
|
/*
|
|
** Purpose:
|
|
** Write temporary files to restart ini file. So that if Acme reboots,
|
|
** the files in the temporary directory will be removed. Win95 only.
|
|
** Arguments:
|
|
** szTmpDir: Full path to destination directory (OEM chars).
|
|
** Returns:
|
|
** fTrue if successful, fFalse otherwise.
|
|
**
|
|
** REVIEW: The files are removed, but not the temp directories.
|
|
** There may be a way to do that via the wininit.ini file.
|
|
** This should be looked into.
|
|
**************************************************************************/
|
|
BOOL FWriteToRestartFile ( SZ szTmpDir )
|
|
{
|
|
char rgchIniFile[_MAX_PATH];
|
|
CB cbFrom;
|
|
CB cbTo;
|
|
HLOCAL hlocalFrom = (HLOCAL)NULL;
|
|
HLOCAL hlocalTo = (HLOCAL)NULL;
|
|
BOOL fRet = fFalse;
|
|
|
|
SZ szSection = "rename";
|
|
SZ szKey = "NUL";
|
|
|
|
/* This code is not used under NT. */
|
|
if (1)
|
|
{
|
|
return (fTrue);
|
|
}
|
|
|
|
if (!FCreateIniFileName(rgchIniFile, sizeof rgchIniFile))
|
|
{
|
|
goto LCleanupAndReturn;
|
|
}
|
|
if (!FGetFileSize(rgchIniFile, &cbFrom))
|
|
{
|
|
goto LCleanupAndReturn;
|
|
}
|
|
if (!FReadIniFile(rgchIniFile, &hlocalFrom, &cbFrom))
|
|
{
|
|
goto LCleanupAndReturn;
|
|
}
|
|
if (!FAllocNewBuf(cbFrom, szTmpDir, szSection, szKey, &hlocalTo, &cbTo))
|
|
{
|
|
goto LCleanupAndReturn;
|
|
}
|
|
if (!FProcessFile(hlocalFrom, hlocalTo, cbTo, szTmpDir, szSection, szKey))
|
|
{
|
|
goto LCleanupAndReturn;
|
|
}
|
|
if (!FWriteIniFile(rgchIniFile, hlocalTo))
|
|
{
|
|
goto LCleanupAndReturn;
|
|
}
|
|
fRet = fTrue;
|
|
|
|
LCleanupAndReturn:
|
|
if (hlocalFrom != (HLOCAL)NULL)
|
|
{
|
|
hlocalFrom = LocalFree(hlocalFrom);
|
|
Assert(hlocalFrom == (HLOCAL)NULL);
|
|
}
|
|
if (hlocalTo != (HLOCAL)NULL)
|
|
{
|
|
hlocalTo = LocalFree(hlocalTo);
|
|
Assert(hlocalTo == (HLOCAL)NULL);
|
|
}
|
|
|
|
return (fRet);
|
|
}
|
|
|
|
|
|
/*
|
|
** Purpose:
|
|
** Create the restart file name.
|
|
** Arguments:
|
|
** szIniFile: Buffer to hold file name.
|
|
** cbBufMax: Size of buffer.
|
|
** Returns:
|
|
** fTrue if successful, fFalse otherwise.
|
|
**************************************************************************/
|
|
BOOL FCreateIniFileName ( SZ szIniFile, CB cbBufMax )
|
|
{
|
|
CB cbWinDir;
|
|
|
|
cbWinDir = GetWindowsDirectory((LPSTR)szIniFile, cbBufMax);
|
|
if (cbWinDir == 0)
|
|
{
|
|
#pragma warning(disable:4127) /* conditional expression is constant */
|
|
Assert(fFalse); /* Unusual if this happens. */
|
|
#pragma warning(default:4127)
|
|
return (fFalse);
|
|
}
|
|
Assert(isalpha(*szIniFile));
|
|
Assert(*(szIniFile + 1) == ':');
|
|
|
|
if (*(AnsiPrev((LPSTR)szIniFile, (LPSTR)&szIniFile[cbWinDir])) != '\\')
|
|
lstrcat((LPSTR)szIniFile, "\\");
|
|
lstrcat((LPSTR)szIniFile, "wininit.ini");
|
|
Assert((CB)lstrlen(szIniFile) < cbBufMax);
|
|
|
|
return (fTrue);
|
|
}
|
|
|
|
|
|
/*
|
|
** Purpose:
|
|
** Read the data from the ini file
|
|
** Arguments:
|
|
** szIniFile: Ini file name
|
|
** phlocal: Pointer to memory handle.
|
|
** pcbBuf: Pointer to the number of bytes in the buffer.
|
|
** Returns:
|
|
** fTrue if successful, fFalse otherwise.
|
|
**************************************************************************/
|
|
BOOL FReadIniFile ( SZ szIniFile, HLOCAL * phlocal, PCB pcbBuf )
|
|
{
|
|
UINT fModeSav;
|
|
HLOCAL hlocal;
|
|
SZ szBuf;
|
|
CB cbBuf;
|
|
BOOL fRet = fFalse;
|
|
|
|
Assert(szIniFile != szNull);
|
|
Assert(phlocal != (HLOCAL *)NULL);
|
|
Assert(pcbBuf != pcbNull);
|
|
|
|
fModeSav = SetErrorMode(fNoErrMes);
|
|
hlocal = *phlocal;
|
|
cbBuf = *pcbBuf;
|
|
|
|
Assert(hlocal == (HLOCAL)NULL);
|
|
|
|
if (cbBuf == 0) /* Ini file does not exist or is empty. */
|
|
{
|
|
/* Alloc room for CR, LF, EOS. */
|
|
hlocal = LocalAlloc(LMEM_MOVEABLE, 3);
|
|
if (hlocal == NULL)
|
|
{
|
|
#ifdef DEBUG
|
|
MessageBox(NULL, "Out of memory in FReadIniFile.", szDebugMsg,
|
|
MB_OK | MB_ICONEXCLAMATION);
|
|
#endif /* DEBUG */
|
|
}
|
|
else
|
|
{
|
|
szBuf = (SZ)LocalLock(hlocal);
|
|
|
|
if(szBuf == szNull)
|
|
return fFalse;
|
|
|
|
*szBuf++ = chCR;
|
|
*szBuf++ = chEol;
|
|
*szBuf = chEos;
|
|
*pcbBuf = 2;
|
|
fRet = fTrue;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
HFILE hfile;
|
|
OFSTRUCT ofs;
|
|
CB cbRead;
|
|
|
|
/* Flush cache before calling OpenFile() */
|
|
WritePrivateProfileString(szNull, szNull, szNull, szIniFile);
|
|
hfile = OpenFile(szIniFile, &ofs, OF_READWRITE | OF_SHARE_EXCLUSIVE);
|
|
if (hfile == HFILE_ERROR)
|
|
{
|
|
#ifdef DEBUG
|
|
wsprintf(szDebugBuf, "Can't open file: %s.", szIniFile);
|
|
MessageBox(NULL, szDebugBuf, szDebugMsg,
|
|
MB_OK | MB_ICONEXCLAMATION);
|
|
#endif /* DEBUG */
|
|
goto LCleanupAndReturn;
|
|
}
|
|
hlocal = LocalAlloc(LMEM_MOVEABLE, cbBuf + 1);
|
|
if (hlocal == NULL)
|
|
{
|
|
#ifdef DEBUG
|
|
MessageBox(NULL, "Out of memory in FReadIniFile.", szDebugMsg,
|
|
MB_OK | MB_ICONEXCLAMATION);
|
|
#endif /* DEBUG */
|
|
}
|
|
else
|
|
{
|
|
szBuf = (SZ)LocalLock(hlocal);
|
|
if(szBuf == szNull)
|
|
return fFalse;
|
|
|
|
cbRead = (CB)_lread(hfile, szBuf, cbBuf + 1);
|
|
if (cbRead == HFILE_ERROR)
|
|
{
|
|
#ifdef DEBUG
|
|
wsprintf(szDebugBuf, "Can't read file: %s.", szIniFile);
|
|
MessageBox(NULL, szDebugBuf, szDebugMsg,
|
|
MB_OK | MB_ICONEXCLAMATION);
|
|
#endif /* DEBUG */
|
|
}
|
|
else
|
|
{
|
|
Assert(cbRead == cbBuf);
|
|
*(szBuf + cbBuf) = chEos;
|
|
fRet = fTrue;
|
|
}
|
|
}
|
|
hfile = _lclose(hfile);
|
|
Assert(hfile != HFILE_ERROR);
|
|
}
|
|
|
|
LCleanupAndReturn:
|
|
if (hlocal != NULL)
|
|
{
|
|
LocalUnlock(hlocal);
|
|
}
|
|
*phlocal = hlocal;
|
|
SetErrorMode(fModeSav);
|
|
|
|
return (fRet);
|
|
}
|
|
|
|
|
|
/*
|
|
** Purpose:
|
|
** Allocate buffer for new file.
|
|
** Arguments:
|
|
** cbOld: Size of existing file
|
|
** szTmpDir: Full path to destination directory (OEM chars).
|
|
** szSection: Ini section name
|
|
** szKey: Ini key name
|
|
** phlocal: Pointer to memory handle.
|
|
** pcbToBuf: Pointer to total size of new buffer.
|
|
** Returns:
|
|
** fTrue if successful, fFalse if LocalAlloc failed.
|
|
**************************************************************************/
|
|
BOOL FAllocNewBuf ( CB cbOld, SZ szTmpDir, SZ szSection, SZ szKey,
|
|
HLOCAL * phlocal, PCB pcbToBuf )
|
|
{
|
|
UINT fModeSav;
|
|
SZ szDst;
|
|
CB cbDst;
|
|
CB cbOverhead;
|
|
CB cbNew;
|
|
BOOL fRet = fFalse;
|
|
|
|
fModeSav = SetErrorMode(fNoErrMes);
|
|
szDst = (SZ)LocalLock(hDstLst);
|
|
if(szDst == szNull)
|
|
return fFalse;
|
|
/*
|
|
* Added to the old file will be one line per temporary file
|
|
* and (possibly) a section line. cbNew is initialized with
|
|
* the size of the section line, plus enough for the file
|
|
* (_MSSETUP._Q_) which is not in the DstLst.
|
|
*
|
|
* Each line will look like:
|
|
* <szKey>=<szTmpDir>\<szFile><CR><LF>
|
|
*/
|
|
cbOverhead = lstrlen(szKey) + 1 + lstrlen(szTmpDir) + 1 + 2;
|
|
cbNew = lstrlen(szSection) + 5 + _MAX_PATH;
|
|
for (; (cbDst = lstrlen(szDst)) != 0; szDst += cbDst + 1)
|
|
{
|
|
cbNew += cbOverhead + cbDst;
|
|
}
|
|
|
|
LocalUnlock(hDstLst);
|
|
|
|
*pcbToBuf = cbOld + cbNew;
|
|
*phlocal = LocalAlloc(LMEM_MOVEABLE, *pcbToBuf);
|
|
if (*phlocal == NULL)
|
|
{
|
|
#ifdef DEBUG
|
|
MessageBox(NULL, "Out of memory in FAllocNewBuf.", szDebugMsg,
|
|
MB_OK | MB_ICONEXCLAMATION);
|
|
#endif /* DEBUG */
|
|
}
|
|
else
|
|
fRet = fTrue;
|
|
SetErrorMode(fModeSav);
|
|
|
|
return (fRet);
|
|
}
|
|
|
|
|
|
/*
|
|
** Purpose:
|
|
** Add the new lines to the ini file.
|
|
** Arguments:
|
|
** hlocalFrom: Handle to Src memory.
|
|
** hlocalTo: Handle to Dst memory.
|
|
** cbToBuf: Total size of Dst memory.
|
|
** szTmpDir: Full path to destination directory (OEM chars).
|
|
** szSection: Ini section name
|
|
** szKey: Ini key name
|
|
** Returns:
|
|
** fTrue if successful, fFalse otherwise.
|
|
**
|
|
** REVIEW: DBCS writes out different order. See DBCS J6 code and
|
|
** comments in sysinicm.c.
|
|
**************************************************************************/
|
|
BOOL FProcessFile ( HLOCAL hlocalFrom, HLOCAL hlocalTo, CB cbToBuf,
|
|
SZ szTmpDir, SZ szSection, SZ szKey )
|
|
{
|
|
UINT fModeSav;
|
|
SZ szFromBuf;
|
|
SZ szToBuf;
|
|
SZ szToStart;
|
|
SZ szCur;
|
|
SZ szDst;
|
|
CB cbSect;
|
|
CB cbDst;
|
|
|
|
Unused(cbToBuf); /* Used in debug only */
|
|
|
|
fModeSav = SetErrorMode(fNoErrMes);
|
|
|
|
szFromBuf = (SZ)LocalLock(hlocalFrom);
|
|
if(szFromBuf == szNull)
|
|
return fFalse;
|
|
|
|
szToBuf = (SZ)LocalLock(hlocalTo);
|
|
if(szToBuf != szNull) {
|
|
LocalUnlock (hlocalFrom);
|
|
return fFalse;
|
|
}
|
|
|
|
szToStart = szToBuf;
|
|
|
|
cbSect = lstrlen(szSection);
|
|
for (szCur = szFromBuf; *szCur != chEos; szCur = AnsiNext(szCur))
|
|
{
|
|
if (*szCur == '[' && *((szCur + cbSect + 1)) == ']'
|
|
&& _memicmp(szSection, AnsiNext(szCur), cbSect) == 0)
|
|
{
|
|
/* Found section. Copy up to section line. */
|
|
CB cbCopy = (CB)(szCur - szFromBuf);
|
|
|
|
memcpy(szToBuf, szFromBuf, cbCopy);
|
|
szToBuf += cbCopy;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Copy section line. */
|
|
*szToBuf++ = '[';
|
|
memcpy(szToBuf, szSection, cbSect);
|
|
szToBuf += cbSect;
|
|
*szToBuf++ = ']';
|
|
*szToBuf++ = chCR;
|
|
*szToBuf++ = chEol;
|
|
|
|
/* Copy new lines. */
|
|
szDst = (SZ)LocalLock(hDstLst);
|
|
if (szDst == szNull) {
|
|
|
|
LocalUnlock(hlocalFrom);
|
|
LocalUnlock(hlocalTo);
|
|
return fFalse;
|
|
}
|
|
|
|
for (; (cbDst = lstrlen(szDst)) != 0; szDst += cbDst + 1)
|
|
{
|
|
CopyIniLine(szKey, szTmpDir, szDst, &szToBuf);
|
|
}
|
|
LocalUnlock(hDstLst);
|
|
CopyIniLine(szKey, szTmpDir, "_MSSETUP._Q_", &szToBuf);
|
|
|
|
/* Copy rest of file. */
|
|
if (*szCur == '[')
|
|
{
|
|
/*
|
|
* Skip section line in From buffer. Allow room for '[', section,
|
|
* ']', CR, LF.
|
|
*/
|
|
szCur += cbSect + 4;
|
|
}
|
|
else
|
|
{
|
|
szCur = szFromBuf;
|
|
}
|
|
szToBuf = _memccpy(szToBuf, szCur, chEos, UINT_MAX);
|
|
Assert(szToBuf != szNull);
|
|
Assert((CB)lstrlen(szToStart) < cbToBuf);
|
|
|
|
LocalUnlock(hlocalFrom);
|
|
LocalUnlock(hlocalTo);
|
|
SetErrorMode(fModeSav);
|
|
|
|
return (fTrue);
|
|
}
|
|
|
|
|
|
/*
|
|
** Purpose:
|
|
** Constructs and copies an ini line to a buffer.
|
|
** Arguments:
|
|
** szKey: Ini key name
|
|
** szTmpDir: Full path to destination directory (OEM chars).
|
|
** szFile: Name of file in temporary directory.
|
|
** pszToBuf: Pointer to new buffer.
|
|
** Returns:
|
|
** none
|
|
**************************************************************************/
|
|
VOID CopyIniLine ( SZ szKey, SZ szTmpDir, SZ szFile, PSZ pszToBuf )
|
|
{
|
|
char rgchSysIniLine[256];
|
|
CB cbCopy;
|
|
|
|
lstrcpy(rgchSysIniLine, szKey);
|
|
lstrcat(rgchSysIniLine, "=");
|
|
lstrcat(rgchSysIniLine, szTmpDir);
|
|
lstrcat(rgchSysIniLine, "\\");
|
|
lstrcat(rgchSysIniLine, szFile);
|
|
Assert(lstrlen(rgchSysIniLine) < sizeof rgchSysIniLine);
|
|
cbCopy = lstrlen(rgchSysIniLine);
|
|
memcpy(*pszToBuf, rgchSysIniLine, cbCopy);
|
|
(*pszToBuf) += cbCopy;
|
|
*(*pszToBuf)++ = chCR;
|
|
*(*pszToBuf)++ = chEol;
|
|
}
|
|
|
|
|
|
/*
|
|
** Purpose:
|
|
** Writes out the new ini file.
|
|
** Arguments:
|
|
** szIniFile: Buffer to hold file name.
|
|
** hlocalTo: Handle to Src memory.
|
|
** Returns:
|
|
** fTrue if successful, fFalse otherwise.
|
|
**************************************************************************/
|
|
BOOL FWriteIniFile ( SZ szIniFile, HLOCAL hlocalTo )
|
|
{
|
|
UINT fModeSav;
|
|
SZ szToBuf;
|
|
HFILE hfile;
|
|
OFSTRUCT ofs;
|
|
CB cbWrite;
|
|
BOOL fRet = fFalse;
|
|
|
|
fModeSav = SetErrorMode(fNoErrMes);
|
|
szToBuf = (SZ)LocalLock(hlocalTo);
|
|
if(szToBuf == szNull)
|
|
return fFalse;
|
|
|
|
hfile = OpenFile(szIniFile, &ofs, OF_CREATE | OF_WRITE);
|
|
if (hfile == HFILE_ERROR)
|
|
{
|
|
#ifdef DEBUG
|
|
wsprintf(szDebugBuf, "Can't open file: %s.", szIniFile);
|
|
MessageBox(NULL, szDebugBuf, szDebugMsg,
|
|
MB_OK | MB_ICONEXCLAMATION);
|
|
#endif /* DEBUG */
|
|
goto LUnlockAndReturn;
|
|
}
|
|
|
|
cbWrite = _lwrite(hfile, szToBuf, lstrlen(szToBuf));
|
|
if (cbWrite == HFILE_ERROR)
|
|
{
|
|
#ifdef DEBUG
|
|
wsprintf(szDebugBuf, "Can't write to file: %s.", szIniFile);
|
|
MessageBox(NULL, szDebugBuf, szDebugMsg,
|
|
MB_OK | MB_ICONEXCLAMATION);
|
|
#endif /* DEBUG */
|
|
}
|
|
else
|
|
{
|
|
fRet = fTrue;
|
|
}
|
|
|
|
hfile = _lclose(hfile);
|
|
Assert(hfile != HFILE_ERROR);
|
|
|
|
LUnlockAndReturn:
|
|
LocalUnlock(hlocalTo);
|
|
SetErrorMode(fModeSav);
|
|
|
|
return (fRet);
|
|
}
|
|
|
|
CHAR szcStfSrcDir[] = "Source Directory\t";
|
|
#define cchStfSrcDir (sizeof(szcStfSrcDir)-1)
|
|
|
|
/* Finds the source directory for the installation, asks the user
|
|
to insert the disk. And returns */
|
|
|
|
BRC BrcInsertDisk(CHAR *pchStf, CHAR *pchSrcDrive)
|
|
{
|
|
CHAR rgbBuf[_MAX_PATH];
|
|
BYTE rgbFileBuf[32];
|
|
UINT iFileBuf = sizeof(rgbFileBuf), cFileBuf = sizeof(rgbFileBuf);
|
|
CHAR *pchBuf = rgbBuf;
|
|
CHAR *pchMsg;
|
|
int iStf = 0;
|
|
HFILE hFile;
|
|
BRC brc = brcLst;
|
|
char chDrv;
|
|
BOOL fQuote = FALSE;
|
|
int drvType;
|
|
BOOL fFirst = TRUE;
|
|
BOOL fOpen = FALSE;
|
|
HFILE hFileT;
|
|
BOOL fRenameStf = fFalse;
|
|
|
|
if ((hFile = _lopen(pchStf, OF_READ)) == HFILE_ERROR)
|
|
return brcNoStf;
|
|
|
|
/* Find the path to the original setup. This is stored in the .stf file on the
|
|
Source Directory line */
|
|
while (pchBuf < rgbBuf + sizeof(rgbBuf))
|
|
{
|
|
BYTE ch;
|
|
|
|
if (iFileBuf == cFileBuf)
|
|
{
|
|
if ((cFileBuf = _lread(hFile, rgbFileBuf, sizeof(rgbFileBuf))) == 0)
|
|
goto LDone;
|
|
iFileBuf = 0;
|
|
}
|
|
ch = rgbFileBuf[iFileBuf++];
|
|
if (iStf < cchStfSrcDir)
|
|
{
|
|
if (ch == szcStfSrcDir[iStf])
|
|
iStf++;
|
|
else
|
|
iStf = 0;
|
|
continue;
|
|
}
|
|
if(fQuote)
|
|
fQuote = FALSE;
|
|
else if (ch == '"')
|
|
{
|
|
fQuote = TRUE;
|
|
continue;
|
|
}
|
|
else if (ch == '\x0d' || ch == '\t')
|
|
break;
|
|
*pchBuf++ = (CHAR)ch;
|
|
/* Case of having the last character be a DBCS character */
|
|
if (IsDBCSLeadByte(ch))
|
|
{
|
|
if (iFileBuf == cFileBuf)
|
|
{
|
|
_lread(hFile, &ch, 1);
|
|
*pchBuf++ = (CHAR) ch;
|
|
}
|
|
else
|
|
*pchBuf++ = rgbFileBuf[iFileBuf++];
|
|
}
|
|
}
|
|
|
|
LDone:
|
|
*pchBuf = 0;
|
|
if (rgbBuf[0] == 0)
|
|
{
|
|
fRenameStf = fTrue;
|
|
goto LClose;
|
|
}
|
|
chDrv = (char)toupper(rgbBuf[0]);
|
|
if (rgbBuf[1] != ':' || chDrv < 'A' || chDrv > 'Z')
|
|
{
|
|
/* We know this is a network drive - UNC Name */
|
|
drvType = EX_DRIVE_REMOTE;
|
|
Assert(rgbBuf[0] == '\\' && rgbBuf[1] == '\\');
|
|
}
|
|
else
|
|
{
|
|
drvType = GetDriveTypeEx(chDrv - 'A');
|
|
}
|
|
|
|
lstrcpy(pchSrcDrive, rgbBuf);
|
|
if (*AnsiPrev(rgbBuf, pchBuf) != '\\')
|
|
{
|
|
*pchBuf++ = '\\';
|
|
*pchBuf = 0;
|
|
}
|
|
|
|
lstrcat(rgbBuf, "Setup.ini");
|
|
|
|
while (!fOpen)
|
|
{
|
|
switch (drvType)
|
|
{
|
|
case EX_DRIVE_FIXED:
|
|
case EX_DRIVE_REMOTE:
|
|
case EX_DRIVE_RAMDISK:
|
|
case EX_DRIVE_INVALID:
|
|
default:
|
|
if (!fFirst)
|
|
{
|
|
/* We've been here before */
|
|
DispErrBrc(brcConnectToSource, TRUE, MB_OK | MB_ICONSTOP, pchSrcDrive, NULL, NULL);
|
|
brc = brcMax;
|
|
goto LClose;
|
|
}
|
|
/* The setup stuff should be available, change directories and go for it */
|
|
break;
|
|
case EX_DRIVE_FLOPPY:
|
|
case EX_DRIVE_REMOVABLE:
|
|
/* Ask to insert disk */
|
|
pchMsg = rgchInsertDiskMsg;
|
|
goto LAskUser;
|
|
break;
|
|
case EX_DRIVE_CDROM:
|
|
/* Ask to insert their CD */
|
|
pchMsg = rgchInsertCDMsg;
|
|
LAskUser:
|
|
if (fFirst)
|
|
{
|
|
if (DispErrBrc(brcString, FALSE, MB_ICONEXCLAMATION|MB_OKCANCEL,
|
|
pchMsg, NULL, NULL) != IDOK)
|
|
{
|
|
brc = brcUserQuit;
|
|
goto LClose;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (DispErrBrc(brcInsCDRom2, FALSE, MB_ICONEXCLAMATION|MB_OKCANCEL,
|
|
rgbBuf, pchMsg, NULL) != IDOK)
|
|
{
|
|
brc = brcUserQuit;
|
|
goto LClose;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
if ((hFileT = _lopen(rgbBuf, OF_READ)) != HFILE_ERROR)
|
|
{
|
|
_lclose(hFileT);
|
|
fOpen = fTrue;
|
|
}
|
|
|
|
fFirst = FALSE;
|
|
|
|
}
|
|
|
|
brc = brcOkay;
|
|
|
|
LClose:
|
|
_lclose(hFile);
|
|
|
|
/* If we can't find the source path in the maintenance mode .STF,
|
|
* assume it's corrupted and rename it, so when the user runs again
|
|
* from the source image, we will just run in 'floppy' mode,
|
|
* avoiding the bad .STF file.
|
|
* (NOTE: Assumes /W is only used in maint mode!!)
|
|
*/
|
|
if (fRenameStf)
|
|
{
|
|
FRenameBadMaintStf(pchStf);
|
|
brc = brcNoStf;
|
|
}
|
|
|
|
return brc;
|
|
|
|
}
|
|
|
|
|
|
/*
|
|
****************************************************************************/
|
|
BOOL FRenameBadMaintStf ( SZ szStf )
|
|
{
|
|
CHAR rgch[_MAX_FNAME];
|
|
|
|
_splitpath(szStf, szNull, szNull, rgch, szNull);
|
|
if (*rgch == '\0')
|
|
lstrcpy(rgch, "stf");
|
|
|
|
Assert(lstrlen(rgch) + 4 < sizeof rgch);
|
|
lstrcat(rgch, ".000");
|
|
|
|
rename(szStf, rgch);
|
|
|
|
/* Remove the original .STF in case the rename failed
|
|
* (probably due to a previously renamed .STF file).
|
|
*/
|
|
remove(szStf);
|
|
|
|
return (fTrue); /* Always returns true */
|
|
}
|