1931 lines
43 KiB
C
1931 lines
43 KiB
C
#include "precomp.h"
|
|
#pragma hdrstop
|
|
/*++
|
|
|
|
Copyright (c) 1990 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
vdm.c
|
|
|
|
Abstract:
|
|
|
|
Routines to handle VDM config files
|
|
|
|
Detect Routines:
|
|
----------------
|
|
|
|
1. GetDosPathVar: This finds out the value of the DOS Path variable
|
|
|
|
2. GetWindowsPath: THis finds out the directory where windows in installed
|
|
on the current system
|
|
|
|
3. GetInstalledOSNames: Finds out all the OSs installed on current system.
|
|
|
|
Install Routines Workers:
|
|
-------------------------
|
|
|
|
1. VdmFixupWorker: This forms the NT VDM configuration files from DOS
|
|
configuration files and NT VDM template config files.
|
|
|
|
2. MigrateWinIniWorker: This migrates windows ini configuration from
|
|
win.ini files. BUGBUG**REMOVED
|
|
|
|
General Subroutines:
|
|
--------------------
|
|
|
|
1. FFileExist: Whether a file exists or not.
|
|
|
|
2. FileSize: The size of a file.
|
|
|
|
|
|
Author:
|
|
|
|
Sunil Pai (sunilp) Mar 31, 1992
|
|
|
|
--*/
|
|
|
|
#define WIN_COM "WIN.COM"
|
|
#define INI ".INI"
|
|
#define TMP ".TMP"
|
|
|
|
#define CONFIG_SYS "C:\\CONFIG.SYS"
|
|
#define BATCH_BAT "C:\\AUTOEXEC.BAT"
|
|
|
|
#define CONFIG_NT "\\CONFIG.NT"
|
|
#define BATCH_NT "\\AUTOEXEC.NT"
|
|
|
|
#define CONFIG_TMP "\\CONFIG.TMP"
|
|
#define BATCH_TMP "\\AUTOEXEC.TMP"
|
|
|
|
#define IO_SYS "C:\\IO.SYS"
|
|
#define MSDOS_SYS "C:\\MSDOS.SYS"
|
|
#define IBMBIO_COM "C:\\IBMBIO.COM"
|
|
#define IBMDOS_COM "C:\\IBMDOS.COM"
|
|
#define OS2LDR "C:\\OS2LDR"
|
|
#define STARTUPCMD "C:\\STARTUP.CMD"
|
|
|
|
#define DOS "DOS"
|
|
#define OS2 "OS2"
|
|
|
|
//
|
|
// Local prototypes
|
|
//
|
|
|
|
BOOL FilterDosConfigFile(LPSTR szSrc, LPSTR szDst, LPSTR szTemplate);
|
|
BOOL DosConfigFilter(IN OUT TEXTFILE *SrcText, IN OUT FILE *f, OUT RGSZ *rgszFound);
|
|
DWORD FileSize(SZ szFile);
|
|
BOOL AppendSzToFile( SZ szFileName, SZ szAddOnSz );
|
|
SZ SzGetDosPathVar(DWORD MaxLength);
|
|
BOOL GetPathVarFromLine( SZ, SZ, DWORD );
|
|
BOOL CheckDosConfigModified( IN LPSTR szConfig);
|
|
|
|
|
|
#if 0
|
|
BOOL FilterDosBatchFile(LPSTR szSrc, LPSTR szDst, LPSTR szTemplate);
|
|
BOOL DosBatchFilter( TEXTFILE*, FILE* );
|
|
BOOL FixConfigFileMacroChar(SZ szConfigFile, CHAR cReplaceChar, SZ szSystemDir);
|
|
|
|
|
|
BOOL FFindAndCopyIniFiles( SZ szSrcDir, SZ szDstDir );
|
|
BOOL FMigrateStandardIniData( SZ szWindowsDir );
|
|
BOOL FMigrateWinIniAppSections( SZ szWindowsDir );
|
|
SZ SzMapStandardIni( SZ szIniFile );
|
|
VOID CleanupIniFiles( SZ szWindowsDir );
|
|
BOOL FIsStandardWinIniSection( SZ szSection );
|
|
#endif
|
|
|
|
|
|
// ***************************************************************************
|
|
//
|
|
// DOS VDM FIXUP MAIN ROUTINE
|
|
//
|
|
// ***************************************************************************
|
|
|
|
BOOL
|
|
VdmFixupWorker(
|
|
LPSTR szAddOnConfig,
|
|
LPSTR szAddOnBatch
|
|
)
|
|
{
|
|
CHAR szConfigVDM[MAX_PATH], szBatchVDM[MAX_PATH];
|
|
CHAR szConfigTmp[MAX_PATH], szBatchTmp[MAX_PATH];
|
|
SZ szConfigDOS, szBatchDOS;
|
|
CHAR szSystemDir[ MAX_PATH ];
|
|
DWORD dwDosConfigAttr = FILE_ATTRIBUTE_NORMAL;
|
|
DWORD dwDosBatchAttr = FILE_ATTRIBUTE_NORMAL;
|
|
DWORD dw;
|
|
BOOL bStatus = TRUE;
|
|
|
|
//
|
|
// A. Determine names to use: no renaming any more. Config.sys and
|
|
// autoexec.bat on root of C drive are the files to use for DOS,
|
|
// config.nt and autoexec.nt in the system directory are the files
|
|
// to use for nt. the template config.nt and autoexec.nt are
|
|
// still copied into the root of the C drive for reference.
|
|
//
|
|
|
|
GetSystemDirectory( szSystemDir, MAX_PATH );
|
|
|
|
szConfigDOS = CONFIG_SYS;
|
|
szBatchDOS = BATCH_BAT;
|
|
|
|
lstrcpy( szConfigVDM, szSystemDir );
|
|
lstrcat( szConfigVDM, CONFIG_NT );
|
|
|
|
lstrcpy( szBatchVDM, szSystemDir );
|
|
lstrcat( szBatchVDM, BATCH_NT );
|
|
|
|
lstrcpy( szConfigTmp, szSystemDir );
|
|
lstrcat( szConfigTmp, CONFIG_TMP );
|
|
|
|
lstrcpy( szBatchTmp, szSystemDir );
|
|
lstrcat( szBatchTmp, BATCH_TMP );
|
|
|
|
|
|
//
|
|
// Verify that the template files exist, else
|
|
//
|
|
|
|
if ( !(FFileExist( szConfigTmp ) && FFileExist( szBatchTmp )) ) {
|
|
SetErrorText(IDS_ERROR_OPENFAIL);
|
|
return( fFalse );
|
|
}
|
|
else {
|
|
SetFileAttributes ( szConfigTmp, FILE_ATTRIBUTE_NORMAL );
|
|
SetFileAttributes ( szBatchTmp, FILE_ATTRIBUTE_NORMAL );
|
|
}
|
|
|
|
//
|
|
// Fix the attributes of the DOS CONFIG FILES so that we can look at
|
|
// them henceforth
|
|
//
|
|
|
|
if ( FFileExist(szConfigDOS) ) {
|
|
if ( (dw = GetFileAttributes( szConfigDOS )) != 0xFFFFFFFF) {
|
|
dwDosConfigAttr = dw;
|
|
}
|
|
SetFileAttributes( szConfigDOS, FILE_ATTRIBUTE_NORMAL );
|
|
}
|
|
|
|
if ( FFileExist(szBatchDOS) ) {
|
|
if ( (dw = GetFileAttributes( szBatchDOS )) != 0xFFFFFFFF) {
|
|
dwDosBatchAttr = dw;
|
|
}
|
|
SetFileAttributes( szBatchDOS, FILE_ATTRIBUTE_NORMAL );
|
|
}
|
|
|
|
//
|
|
// Delete the existing config files for the vdm - no upgrade supported
|
|
// at this moment.
|
|
//
|
|
|
|
if ( FFileExist( szConfigVDM ) ) {
|
|
SetFileAttributes ( szConfigVDM, FILE_ATTRIBUTE_NORMAL );
|
|
DeleteFile( szConfigVDM );
|
|
}
|
|
|
|
if ( FFileExist( szBatchVDM ) ) {
|
|
SetFileAttributes ( szBatchVDM, FILE_ATTRIBUTE_NORMAL );
|
|
DeleteFile( szBatchVDM );
|
|
}
|
|
|
|
|
|
//
|
|
// Check if configuration information exists, else just rename
|
|
// the default temporary configuration files to the final names.
|
|
//
|
|
|
|
if ((!FFileExist(szConfigDOS)) ||
|
|
(!CheckConfigTypeWorker(szConfigDOS))
|
|
) {
|
|
if( !( MoveFile( szConfigTmp, szConfigVDM ) &&
|
|
MoveFile( szBatchTmp, szBatchVDM ))) {
|
|
SetErrorText(IDS_ERROR_WRITE);
|
|
bStatus = fFalse;
|
|
goto cleanup;
|
|
}
|
|
}
|
|
else {
|
|
if( !FilterDosConfigFile(szConfigDOS, szConfigVDM, szConfigTmp) ) {
|
|
bStatus = fFalse;
|
|
goto cleanup;
|
|
}
|
|
|
|
//
|
|
// Nothing is being migrated from the DOS batch file, so we
|
|
// can just rename the temporary file to the permanent one
|
|
//
|
|
|
|
if( !MoveFile( szBatchTmp, szBatchVDM ) ) {
|
|
SetErrorText(IDS_ERROR_WRITE);
|
|
bStatus = fFalse;
|
|
goto cleanup;
|
|
}
|
|
|
|
}
|
|
|
|
//
|
|
// Append the NT Signature blocks onto the existing config files. If
|
|
// files don't exist then create them
|
|
//
|
|
|
|
if(!CheckDosConfigModified(szConfigDOS) ) {
|
|
if( !AppendSzToFile( szConfigDOS, szAddOnConfig ) ) {
|
|
//
|
|
// Silently fail if unable to append the signature.
|
|
// Failure will occur if c: is not formatted.
|
|
//
|
|
// bStatus = fFalse;
|
|
goto cleanup;
|
|
}
|
|
}
|
|
|
|
if(!CheckDosConfigModified(szBatchDOS) ) {
|
|
if( !AppendSzToFile( szBatchDOS, szAddOnBatch ) ) {
|
|
//
|
|
// Silently fail if unable to append the signature.
|
|
// Failure will occur if c: is not formatted.
|
|
//
|
|
// bStatus = fFalse;
|
|
goto cleanup;
|
|
}
|
|
}
|
|
|
|
cleanup:
|
|
|
|
//
|
|
// If autoexec.nt and config.nt files not found, try creating them from
|
|
// the tmp files if possible
|
|
//
|
|
|
|
if( !FFileExist( szConfigVDM ) ) {
|
|
MoveFile( szConfigTmp, szConfigVDM );
|
|
}
|
|
if( !FFileExist( szBatchVDM ) ) {
|
|
MoveFile( szBatchTmp, szBatchVDM );
|
|
}
|
|
|
|
//
|
|
// Remove the temporary config files if they exist.
|
|
//
|
|
|
|
DeleteFile( szConfigTmp );
|
|
DeleteFile( szBatchTmp );
|
|
|
|
//
|
|
// reset the attributs on the DOS config files, if they exist
|
|
//
|
|
|
|
if ( FFileExist( szConfigDOS ) ) {
|
|
SetFileAttributes( szConfigDOS, dwDosConfigAttr );
|
|
}
|
|
|
|
if ( FFileExist( szBatchDOS ) ) {
|
|
SetFileAttributes( szBatchDOS, dwDosBatchAttr );
|
|
}
|
|
|
|
#if 0
|
|
//
|
|
// If the NT config files have been created, set the attributes of these
|
|
// to system and readonly
|
|
//
|
|
|
|
if( FFileExist( szConfigVDM ) ) {
|
|
SetFileAttributes(
|
|
szConfigVDM,
|
|
FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_READONLY
|
|
);
|
|
}
|
|
if( FFileExist( szBatchVDM ) ) {
|
|
SetFileAttributes(
|
|
szBatchVDM,
|
|
FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_READONLY
|
|
);
|
|
}
|
|
#endif
|
|
|
|
return( bStatus );
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
//
|
|
// DOS CONFIG.SYS ROUTINES
|
|
//
|
|
// ***************************************************************************
|
|
|
|
//
|
|
// copy a DOS config file REMing out any line that is not a
|
|
// SET or a PATH command
|
|
//
|
|
// szSrc: Source batch file (DOS c:\autoexec.bat )
|
|
// szDst: Destination batch file (NT VDM c:\autoexec.nt )
|
|
|
|
BOOL
|
|
FilterDosConfigFile(
|
|
LPSTR szSrc,
|
|
LPSTR szDst,
|
|
LPSTR szTemplate
|
|
|
|
)
|
|
{
|
|
TEXTFILE SrcText, TemplateText;
|
|
FILE* f;
|
|
size_t Idx;
|
|
RGSZ rgszFound = NULL;
|
|
BOOL bStatus = TRUE;
|
|
SZ sz, szLine;
|
|
CHAR Buffer[ MAX_PATH ];
|
|
|
|
//
|
|
// If destination already exists get rid of it
|
|
//
|
|
|
|
if (FFileExist( szDst )) {
|
|
bStatus = SetFileAttributes ( szDst, FILE_ATTRIBUTE_NORMAL );
|
|
if (bStatus) {
|
|
bStatus = DeleteFile( szDst );
|
|
}
|
|
}
|
|
|
|
if (!bStatus) {
|
|
SetErrorText(IDS_ERROR_WRITE);
|
|
return (fFalse);
|
|
}
|
|
|
|
//
|
|
// Open destination file for writing.
|
|
//
|
|
|
|
if ( !(f = fopen( szDst, "w" )) ) {
|
|
SetErrorText(IDS_ERROR_WRITE);
|
|
return( FALSE );
|
|
}
|
|
|
|
//
|
|
// Open source file and filter it
|
|
//
|
|
|
|
if ( FFileExist( szSrc ) &&
|
|
TextFileOpen( szSrc, &SrcText ) ) {
|
|
|
|
bStatus = DosConfigFilter( &SrcText, f, &rgszFound );
|
|
TextFileClose( &SrcText );
|
|
|
|
}
|
|
|
|
if( !bStatus ) {
|
|
goto err;
|
|
}
|
|
|
|
//
|
|
// Now add on the default config file from the template file
|
|
//
|
|
|
|
if ( !TextFileOpen( szTemplate, &TemplateText ) ) {
|
|
bStatus = fFalse;
|
|
SetErrorText(IDS_ERROR_OPENFAIL);
|
|
goto err;
|
|
}
|
|
|
|
while ( TextFileReadLine( &TemplateText ) ) {
|
|
BOOL fFound = FALSE;
|
|
|
|
szLine = TextFileGetLine( &TemplateText );
|
|
sz = TextFileSkipBlanks( szLine );
|
|
|
|
|
|
//
|
|
// If blank line, ignore
|
|
//
|
|
|
|
if ( sz && *sz != '\0' && rgszFound ) {
|
|
Idx = strcspn( sz, " \t=" );
|
|
if ( Idx <= strlen(sz) ) {
|
|
|
|
PSZ psz;
|
|
|
|
memcpy( Buffer, sz, Idx );
|
|
Buffer[Idx] = '\0';
|
|
|
|
//
|
|
// If one of the entries we have found from a dos config file
|
|
// set fFound to true so that we don't copy this file
|
|
//
|
|
|
|
psz = rgszFound;
|
|
|
|
while ( *psz ) {
|
|
if ( !lstrcmpi( Buffer, *psz ) ) {
|
|
fFound = fTrue;
|
|
break;
|
|
}
|
|
psz++;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
if( !fFound ) {
|
|
fprintf( f, "%s\n", szLine );
|
|
}
|
|
|
|
}
|
|
TextFileClose( &TemplateText );
|
|
bStatus = fTrue;
|
|
err:
|
|
fclose( f );
|
|
if( rgszFound ) {
|
|
RgszFree( rgszFound );
|
|
}
|
|
|
|
return(bStatus);
|
|
}
|
|
|
|
|
|
|
|
BOOL
|
|
DosConfigFilter(
|
|
IN OUT TEXTFILE * SrcText,
|
|
IN OUT FILE* f,
|
|
OUT RGSZ* rgszFound
|
|
)
|
|
{
|
|
SZ szLine;
|
|
SZ sz;
|
|
CHAR Buffer[ MAX_PATH ];
|
|
size_t Idx;
|
|
int i;
|
|
RGSZ rgsz;
|
|
|
|
#define NUM_RESPECTED_ENTRIES 4
|
|
|
|
CHAR *ConfEntry[NUM_RESPECTED_ENTRIES] = {
|
|
"BREAK", "FCBS",
|
|
"FILES", "LASTDRIVE"
|
|
};
|
|
|
|
BOOL ConfEntryFound[NUM_RESPECTED_ENTRIES] = {
|
|
FALSE,FALSE,FALSE,FALSE
|
|
};
|
|
|
|
|
|
if( !(rgsz = RgszAlloc(1)) ) {
|
|
SetErrorText(IDS_ERROR_DLLOOM);
|
|
return( FALSE );
|
|
}
|
|
|
|
while ( TextFileReadLine( SrcText ) ) {
|
|
|
|
szLine = TextFileGetLine( SrcText );
|
|
sz = TextFileSkipBlanks( szLine );
|
|
|
|
|
|
//
|
|
// If blank line, ignore
|
|
//
|
|
if ( !sz || *sz == '\0' ) {
|
|
continue;
|
|
}
|
|
|
|
|
|
Idx = strcspn( sz, " \t=" );
|
|
if ( Idx <= strlen(sz) ) {
|
|
|
|
memcpy( Buffer, sz, Idx );
|
|
Buffer[Idx] = '\0';
|
|
|
|
//
|
|
// If one of the entries we respect, copy the line out verbatim
|
|
//
|
|
|
|
for (i = 0; i<NUM_RESPECTED_ENTRIES; i++) {
|
|
|
|
if(!ConfEntryFound[i] && !lstrcmpi( Buffer, ConfEntry[i] ) ) {
|
|
|
|
ConfEntryFound[i] = TRUE;
|
|
|
|
if( !RgszAdd( &rgsz, SzDup(Buffer) ) ) {
|
|
SetErrorText(IDS_ERROR_DLLOOM);
|
|
return( FALSE );
|
|
}
|
|
fprintf( f, "%s\n", szLine );
|
|
break;
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
*rgszFound = rgsz;
|
|
return fTrue;
|
|
}
|
|
|
|
|
|
|
|
|
|
// ***************************************************************************
|
|
//
|
|
// DOS/OS2 DETECT and WORKER ROUTINES
|
|
//
|
|
// ***************************************************************************
|
|
|
|
|
|
/*
|
|
list of installed OS names (DOS / OS2)
|
|
*/
|
|
CB
|
|
GetInstalledOSNames(
|
|
IN RGSZ Args,
|
|
IN USHORT cArgs,
|
|
OUT SZ ReturnBuffer,
|
|
IN CB cbReturnBuffer
|
|
)
|
|
{
|
|
|
|
#define TEMP_INSTALLEDOSNAMES "{}"
|
|
|
|
RGSZ rgsz;
|
|
SZ sz;
|
|
CB cbRet;
|
|
|
|
Unused(Args);
|
|
Unused(cArgs);
|
|
Unused(cbReturnBuffer);
|
|
|
|
rgsz = RgszAlloc(1);
|
|
|
|
//
|
|
// Check for DOS first
|
|
//
|
|
|
|
if ( FFileExist( CONFIG_SYS ) ) {
|
|
|
|
//
|
|
// Look for Kernel and IO files to see if DOS installed
|
|
//
|
|
|
|
if ( (FFileExist(MSDOS_SYS) && FFileExist(IO_SYS)) ||
|
|
(FFileExist(IBMDOS_COM) && FFileExist(IBMBIO_COM)) ) {
|
|
|
|
RgszAdd ( &rgsz, SzDup( DOS ) );
|
|
}
|
|
|
|
//
|
|
// Look at OS2LDR and STARTUP.CMD to see if OS2 installed
|
|
//
|
|
|
|
if ( FFileExist( OS2LDR ) && FFileExist( STARTUPCMD ) ) {
|
|
RgszAdd ( &rgsz, SzDup( OS2 ) );
|
|
}
|
|
}
|
|
|
|
sz = SzListValueFromRgsz( rgsz );
|
|
|
|
if ( sz ) {
|
|
|
|
lstrcpy( ReturnBuffer, sz );
|
|
cbRet = lstrlen( sz ) + 1;
|
|
SFree( sz );
|
|
|
|
|
|
}
|
|
else {
|
|
lstrcpy(ReturnBuffer,TEMP_INSTALLEDOSNAMES);
|
|
cbRet = lstrlen( TEMP_INSTALLEDOSNAMES ) + 1;
|
|
}
|
|
|
|
if ( rgsz ) {
|
|
RgszFree( rgsz );
|
|
}
|
|
|
|
return ( cbRet );
|
|
}
|
|
|
|
|
|
|
|
BOOL
|
|
CheckConfigTypeWorker(
|
|
IN LPSTR szConfig
|
|
)
|
|
{
|
|
TEXTFILE SrcText;
|
|
SZ szLine;
|
|
SZ sz;
|
|
CHAR Buffer[ MAX_PATH ];
|
|
size_t Idx;
|
|
BOOL DosType = FALSE;
|
|
INT i;
|
|
|
|
|
|
CHAR *ConfEntry[] = {
|
|
"DISKCACHE", "LIBPATH", "PAUSEONERROR",
|
|
"RMSIZE", "RUN", "SWAPPATH",
|
|
"IOPL", "MAXWAIT", "MEMMAN",
|
|
"PRIORITY", "PROTSHELL", "PROTECTONLY",
|
|
"THREADS", "TIMESLICE", "TRACE",
|
|
"TRACEBUF", "DEVINFO", NULL
|
|
};
|
|
|
|
//
|
|
// Open source file
|
|
//
|
|
|
|
if ( FFileExist( szConfig ) &&
|
|
TextFileOpen( szConfig, &SrcText ) ) {
|
|
|
|
DosType = TRUE;
|
|
|
|
//
|
|
// Process config file, line by line
|
|
//
|
|
|
|
while ( TextFileReadLine( &SrcText ) && DosType ) {
|
|
|
|
szLine = TextFileGetLine( &SrcText );
|
|
sz = TextFileSkipBlanks( szLine );
|
|
|
|
|
|
//
|
|
// If blank line, skip
|
|
//
|
|
if ( !sz || *sz == '\0' ) {
|
|
continue;
|
|
}
|
|
|
|
|
|
//
|
|
// Get first field
|
|
//
|
|
|
|
Idx = strcspn( sz, " \t=" );
|
|
if ( Idx <= strlen(sz) ) {
|
|
|
|
memcpy( Buffer, sz, Idx );
|
|
Buffer[Idx] = '\0';
|
|
|
|
//
|
|
// Compare against list of known key words for OS2
|
|
//
|
|
|
|
|
|
for (i = 0; ConfEntry[i] != NULL; i++) {
|
|
if ( !lstrcmpi( Buffer, ConfEntry[i] ) ) {
|
|
DosType = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
TextFileClose(&SrcText);
|
|
}
|
|
|
|
return( DosType );
|
|
}
|
|
|
|
BOOL
|
|
CheckDosConfigModified(
|
|
IN LPSTR szConfig
|
|
)
|
|
{
|
|
TEXTFILE SrcText;
|
|
SZ szLine;
|
|
SZ sz;
|
|
BOOL Modified = FALSE;
|
|
|
|
#define SEARCH_STRING "REM Windows NT DOS subsystem"
|
|
|
|
//
|
|
// Open source file
|
|
//
|
|
|
|
if ( FFileExist( szConfig ) &&
|
|
TextFileOpen( szConfig, &SrcText ) ) {
|
|
|
|
//
|
|
// Process config file, line by line
|
|
//
|
|
|
|
while ( TextFileReadLine( &SrcText ) ) {
|
|
|
|
szLine = TextFileGetLine( &SrcText );
|
|
sz = TextFileSkipBlanks( szLine );
|
|
|
|
|
|
//
|
|
// If blank line, skip
|
|
//
|
|
if ( !sz || *sz == '\0' ) {
|
|
continue;
|
|
}
|
|
|
|
|
|
//
|
|
// Search for search_string. If this is found it means that
|
|
// the config file has already been modified during an
|
|
// earlier installation.
|
|
//
|
|
|
|
if( strstr( sz, SEARCH_STRING ) ) {
|
|
Modified = TRUE;
|
|
break;
|
|
}
|
|
|
|
}
|
|
TextFileClose(&SrcText);
|
|
}
|
|
return( Modified );
|
|
}
|
|
|
|
|
|
BOOL
|
|
AppendSzToFile(
|
|
SZ szFileName,
|
|
SZ szAddOnSz
|
|
)
|
|
{
|
|
DWORD BytesWritten;
|
|
HANDLE hfile;
|
|
|
|
//
|
|
// Open the file
|
|
//
|
|
|
|
hfile = CreateFile(
|
|
szFileName,
|
|
GENERIC_WRITE | GENERIC_READ,
|
|
FILE_SHARE_READ,
|
|
NULL,
|
|
OPEN_ALWAYS,
|
|
FILE_ATTRIBUTE_NORMAL,
|
|
NULL
|
|
);
|
|
|
|
if (hfile == INVALID_HANDLE_VALUE) {
|
|
SetErrorText(IDS_ERROR_OPENFAIL);
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Go to end of file
|
|
//
|
|
|
|
SetFilePointer (
|
|
hfile,
|
|
0,
|
|
NULL,
|
|
FILE_END
|
|
);
|
|
|
|
//
|
|
// Append string passed in at the end of the file
|
|
//
|
|
|
|
WriteFile (
|
|
hfile,
|
|
szAddOnSz,
|
|
lstrlen( szAddOnSz ),
|
|
&BytesWritten,
|
|
NULL
|
|
);
|
|
|
|
CloseHandle (hfile);
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
//
|
|
// DOS AND WINDOWS PATH DETECT ROUTINES
|
|
//
|
|
// ***************************************************************************
|
|
|
|
//
|
|
// Get the PATH environment variable used in AUTOEXEC.BAT
|
|
//
|
|
|
|
CB
|
|
GetDosPathVar(
|
|
IN RGSZ Args,
|
|
IN USHORT cArgs,
|
|
OUT SZ ReturnBuffer,
|
|
IN CB cbReturnBuffer
|
|
)
|
|
{
|
|
#define NODOSPATH "{}"
|
|
SZ sz;
|
|
SZ PathVar;
|
|
RGSZ rgszDosPath;
|
|
BOOL fOkay = fFalse;
|
|
|
|
|
|
Unused( Args );
|
|
Unused( cArgs );
|
|
|
|
|
|
if ( PathVar = SzGetDosPathVar(cbReturnBuffer-1) ) {
|
|
if (lstrcmpi( PathVar, "" )) {
|
|
if ( rgszDosPath = RgszFromPath( PathVar ) ) {
|
|
|
|
sz = SzListValueFromRgsz( rgszDosPath );
|
|
RgszFree( rgszDosPath );
|
|
|
|
if ( sz ) {
|
|
strncpy( ReturnBuffer, sz, cbReturnBuffer-1 );
|
|
ReturnBuffer[cbReturnBuffer-1] = 0;
|
|
SFree( sz );
|
|
fOkay = fTrue;
|
|
}
|
|
}
|
|
}
|
|
|
|
SFree( PathVar );
|
|
}
|
|
|
|
if ( !fOkay ) {
|
|
lstrcpy(ReturnBuffer, NODOSPATH);
|
|
}
|
|
|
|
return(lstrlen(ReturnBuffer)+1);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
// Get the PATH environment variable used in AUTOEXEC.BAT
|
|
//
|
|
SZ
|
|
SzGetDosPathVar(
|
|
IN DWORD MaxLength
|
|
)
|
|
{
|
|
TEXTFILE AutoexecBat;
|
|
SZ szPath = (SZ)NULL;
|
|
SZ szConfigDOS, szBatchDOS;
|
|
BOOL fOkay = fFalse;
|
|
|
|
szConfigDOS = CONFIG_SYS;
|
|
szBatchDOS = BATCH_BAT;
|
|
|
|
if (szPath = SAlloc( MaxLength )) {
|
|
|
|
*szPath = '\0';
|
|
|
|
//
|
|
// Open AUTOEXEC.BAT file
|
|
//
|
|
if ( FFileExist(szConfigDOS) &&
|
|
CheckConfigTypeWorker(szConfigDOS) &&
|
|
FFileExist( szBatchDOS ) &&
|
|
TextFileOpen( szBatchDOS, &AutoexecBat ) ) {
|
|
|
|
//
|
|
// Read all lines in the file and update the PATH
|
|
// environment variable
|
|
//
|
|
while ( TextFileReadLine( &AutoexecBat ) ) {
|
|
|
|
GetPathVarFromLine( TextFileGetLine( &AutoexecBat ), szPath, MaxLength );
|
|
}
|
|
|
|
TextFileClose( &AutoexecBat );
|
|
}
|
|
}
|
|
|
|
return szPath;
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
// Parse a line and update the PATH variable
|
|
//
|
|
BOOL
|
|
GetPathVarFromLine(
|
|
IN SZ szLine,
|
|
OUT SZ szPath,
|
|
IN DWORD MaxLength
|
|
)
|
|
{
|
|
|
|
#define PATH "PATH"
|
|
|
|
PCHAR PrevPath = NULL;
|
|
CHAR Buffer[ MAX_PATH ];
|
|
size_t Idx;
|
|
BOOL fSet = fFalse;
|
|
SZ pBegin, pEnd, pLast;
|
|
DWORD PrevPathLen,BeginLen;
|
|
|
|
//
|
|
// Skip blanks. return if blank line
|
|
//
|
|
|
|
szLine = TextFileSkipBlanks( szLine );
|
|
if( !szLine || *szLine == '\0') {
|
|
return( fFalse );
|
|
}
|
|
|
|
//
|
|
// If "no echo" command, skip the '@'
|
|
//
|
|
if ( *szLine == '@' ) {
|
|
szLine++;
|
|
}
|
|
|
|
Idx = strcspn( szLine, " \t=" );
|
|
if ( Idx < strlen(szLine) ) {
|
|
|
|
//
|
|
// If this is a SET command, skip over the SET and set the
|
|
// fSet flag.
|
|
//
|
|
memcpy( Buffer, szLine, Idx );
|
|
Buffer[Idx] = '\0';
|
|
|
|
if ( !_strcmpi( Buffer, "SET" ) ) {
|
|
|
|
//
|
|
// SET command
|
|
//
|
|
fSet = fTrue;
|
|
szLine = TextFileSkipBlanks( szLine+Idx );
|
|
if( !szLine || *szLine == '\0' ) {
|
|
return ( fFalse );
|
|
}
|
|
|
|
Idx = strcspn( szLine, " \t=" );
|
|
|
|
if ( Idx >= strlen(szLine) ) {
|
|
return fFalse;
|
|
}
|
|
|
|
memcpy( Buffer, szLine, Idx );
|
|
Buffer[Idx] = '\0';
|
|
|
|
}
|
|
else if (*(szLine + Idx) == '=') {
|
|
|
|
//
|
|
// This is a command of type Var=Value ( A Set command without
|
|
// the "SET" keyword
|
|
|
|
fSet = fTrue;
|
|
}
|
|
|
|
//
|
|
// At this point we should be pointing to "PATH" and fSet tells
|
|
// us whether this is a SET command or not.
|
|
//
|
|
if ( !_strcmpi( Buffer, PATH ) ) {
|
|
|
|
szLine = TextFileSkipBlanks( szLine+Idx );
|
|
if( !szLine || *szLine == '\0' ) {
|
|
return ( fFalse );
|
|
}
|
|
|
|
//
|
|
// If SET, skip the "="
|
|
//
|
|
if ( fSet ) {
|
|
if ( *szLine != '=' ) {
|
|
return fFalse;
|
|
}
|
|
szLine = TextFileSkipBlanks( szLine+1 );
|
|
if( !szLine || *szLine == '\0' ) {
|
|
return ( fFalse );
|
|
}
|
|
}
|
|
|
|
//
|
|
// Now we point at the value of PATH.
|
|
//
|
|
// Remember all value of PATH
|
|
//
|
|
PrevPathLen = lstrlen(szPath);
|
|
PrevPath = SAlloc(PrevPathLen+1);
|
|
strcpy( PrevPath, szPath );
|
|
szPath[0] = '\0';
|
|
|
|
pBegin = szLine;
|
|
pLast = pBegin + strlen( pBegin );
|
|
|
|
//
|
|
// Copy the new value of PATH, one directory at a time
|
|
//
|
|
do {
|
|
|
|
pEnd = strchr(pBegin, ';' );
|
|
|
|
if ( pEnd == NULL ) {
|
|
pEnd = pBegin + strlen( pBegin );
|
|
}
|
|
*pEnd = '\0';
|
|
|
|
if ( (BeginLen = strlen(pBegin)) > 0 ) {
|
|
|
|
//
|
|
// If a variable substitution, only do it if it is
|
|
// substituting "PATH"
|
|
//
|
|
if ( *pBegin == '%' &&
|
|
*(pEnd-1) == '%' ) {
|
|
|
|
memcpy( Buffer, pBegin+1, (size_t)(pEnd-pBegin-2) );
|
|
Buffer[pEnd-pBegin-2] = '\0';
|
|
|
|
if ( !_strcmpi( Buffer, PATH ) ) {
|
|
if(lstrlen(szPath)+PrevPathLen < MaxLength) {
|
|
strcat( szPath, PrevPath );
|
|
if ( pEnd != pLast ) {
|
|
strcat( szPath, ";" );
|
|
}
|
|
}
|
|
}
|
|
|
|
} else {
|
|
|
|
if(lstrlen(szPath)+BeginLen < MaxLength) {
|
|
strcat( szPath, pBegin );
|
|
if ( pEnd != pLast ) {
|
|
strcat( szPath, ";" );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
pBegin = pEnd+1;
|
|
|
|
} while ( pBegin < pLast );
|
|
|
|
SFree(PrevPath);
|
|
}
|
|
}
|
|
|
|
return fFalse;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
// Get Windows Path, "" if not installed
|
|
//
|
|
CB
|
|
GetWindowsPath(
|
|
IN RGSZ Args,
|
|
IN USHORT cArgs,
|
|
OUT SZ ReturnBuffer,
|
|
IN CB cbReturnBuffer
|
|
)
|
|
{
|
|
|
|
#define WIN_PTH_NONE ""
|
|
|
|
SZ szDosPath;
|
|
RGSZ rgszDosPath;
|
|
INT i;
|
|
CHAR szFile[ MAX_PATH ];
|
|
BOOL fOkay = fFalse;
|
|
SZ szEnd;
|
|
|
|
Unused( Args );
|
|
Unused( cArgs );
|
|
|
|
if ( szDosPath = SzGetDosPathVar(cbReturnBuffer-1) ) {
|
|
|
|
if ( rgszDosPath = RgszFromPath( szDosPath ) ) {
|
|
|
|
for ( i=0; rgszDosPath[i]; i++ ) {
|
|
|
|
strcpy( szFile, rgszDosPath[i] );
|
|
if ( szFile[strlen(szFile)-1] != '\\' ) {
|
|
strcat( szFile, "\\" );
|
|
}
|
|
szEnd = szFile + strlen(szFile);
|
|
strcat( szFile, WIN_COM );
|
|
|
|
if ( FFileExist( szFile ) ) {
|
|
*szEnd = '\0';
|
|
strcpy( ReturnBuffer, szFile );
|
|
fOkay = fTrue;
|
|
break;
|
|
}
|
|
}
|
|
|
|
RgszFree( rgszDosPath );
|
|
|
|
if ( !fOkay ) {
|
|
strcpy( ReturnBuffer, WIN_PTH_NONE );
|
|
fOkay = fTrue;
|
|
}
|
|
}
|
|
|
|
SFree( szDosPath );
|
|
}
|
|
|
|
if ( fOkay ) {
|
|
return lstrlen( ReturnBuffer )+1;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
// ***************************************************************************
|
|
//
|
|
// COMMON SUBROUTINES
|
|
//
|
|
// ***************************************************************************
|
|
|
|
//
|
|
// Determine if the specified file is present.
|
|
//
|
|
|
|
BOOL
|
|
FFileExist(
|
|
IN LPSTR szFile
|
|
)
|
|
{
|
|
DWORD Attr;
|
|
|
|
Attr = GetFileAttributes( szFile );
|
|
|
|
return ((Attr != -1) && !(Attr & FILE_ATTRIBUTE_DIRECTORY ));
|
|
|
|
}
|
|
|
|
//
|
|
// File Size
|
|
//
|
|
|
|
|
|
DWORD
|
|
FileSize(
|
|
SZ szFile
|
|
)
|
|
{
|
|
DWORD Size = 0xFFFFFFFF;
|
|
FILE* f;
|
|
|
|
if( f = fopen( szFile, "r" ) ) {
|
|
if( !fseek( f, 0L, SEEK_END ) ) {
|
|
Size = (DWORD) ftell( f ) ;
|
|
}
|
|
fclose( f );
|
|
}
|
|
return ( Size );
|
|
}
|
|
|
|
|
|
//
|
|
// BUGBUG** Following code has been removed because it is no longer needed
|
|
// It is still being kept in the file till it is determined that it
|
|
// is definitely not needed
|
|
//
|
|
|
|
#if 0
|
|
|
|
|
|
#define MAX_CONFIG_SIZE 1024
|
|
|
|
BOOL
|
|
FixConfigFileMacroChar(
|
|
SZ szConfigFile,
|
|
CHAR cReplaceChar,
|
|
SZ szSystemDir
|
|
)
|
|
{
|
|
|
|
CHAR Buffer [MAX_CONFIG_SIZE];
|
|
DWORD len,i;
|
|
DWORD BytesRead,BytesWritten;
|
|
HANDLE hfile;
|
|
|
|
hfile = CreateFile(
|
|
szConfigFile,
|
|
GENERIC_WRITE | GENERIC_READ,
|
|
FILE_SHARE_READ,
|
|
NULL,
|
|
OPEN_EXISTING,
|
|
FILE_ATTRIBUTE_NORMAL,
|
|
NULL
|
|
);
|
|
|
|
if (hfile == INVALID_HANDLE_VALUE) {
|
|
SetErrorText(IDS_ERROR_OPENFAIL);
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
if (!ReadFile(hfile, Buffer, MAX_CONFIG_SIZE, &BytesRead, NULL)){
|
|
CloseHandle (hfile);
|
|
SetErrorText( IDS_ERROR_READFAILED );
|
|
return FALSE;
|
|
}
|
|
|
|
if (BytesRead == MAX_CONFIG_SIZE) {
|
|
CloseHandle (hfile);
|
|
SetErrorText( IDS_ERROR_READFAILED );
|
|
return FALSE;
|
|
}
|
|
|
|
SetFilePointer (
|
|
hfile,
|
|
0,
|
|
NULL,
|
|
FILE_BEGIN
|
|
);
|
|
|
|
len = strlen (szSystemDir);
|
|
|
|
for (i=0; i < BytesRead; i++) {
|
|
if (Buffer [i] != cReplaceChar){
|
|
WriteFile (
|
|
hfile,
|
|
&Buffer[i],
|
|
1,
|
|
&BytesWritten,
|
|
NULL
|
|
);
|
|
}
|
|
else {
|
|
WriteFile (
|
|
hfile,
|
|
szSystemDir,
|
|
len,
|
|
&BytesWritten,
|
|
NULL
|
|
);
|
|
}
|
|
}
|
|
|
|
CloseHandle (hfile);
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
|
|
// ***************************************************************************
|
|
//
|
|
// DOS AUTOEXEC.BAT ROUTINES
|
|
//
|
|
// ***************************************************************************
|
|
|
|
//
|
|
// copy a DOS batch file REMing out any line that is not a
|
|
// SET or a PATH command
|
|
//
|
|
// szSrc: Source batch file (DOS c:\autoexec.bat )
|
|
// szDst: Destination batch file (NT VDM c:\autoexec.nt )
|
|
|
|
BOOL
|
|
FilterDosBatchFile(
|
|
LPSTR szSrc,
|
|
LPSTR szDst,
|
|
LPSTR szTemplate
|
|
)
|
|
{
|
|
TEXTFILE SrcText, TemplateText;
|
|
FILE* f;
|
|
BOOL bStatus = TRUE;
|
|
SZ szLine;
|
|
CHAR Buffer[ MAX_PATH ];
|
|
|
|
//
|
|
// Open the destination file for write access
|
|
//
|
|
|
|
if (FFileExist( szDst )) {
|
|
bStatus = SetFileAttributes ( szDst, FILE_ATTRIBUTE_NORMAL );
|
|
if (bStatus) {
|
|
bStatus = DeleteFile( szDst );
|
|
}
|
|
}
|
|
|
|
if(!bStatus) {
|
|
SetErrorText(IDS_ERROR_WRITE);
|
|
return( FALSE );
|
|
}
|
|
|
|
if ( !(f = fopen( szDst, "w" )) ) {
|
|
SetErrorText(IDS_ERROR_OPENFAIL);
|
|
return( FALSE );
|
|
}
|
|
|
|
|
|
//
|
|
// Open source file
|
|
//
|
|
|
|
if ( FFileExist( szSrc ) &&
|
|
TextFileOpen( szSrc, &SrcText ) ) {
|
|
|
|
SZ TempBuffer = " @echo off\n";
|
|
|
|
//
|
|
// First put an echo off command here
|
|
//
|
|
|
|
fputs( TempBuffer, f );
|
|
|
|
//
|
|
// Then migrate the existing batch file
|
|
//
|
|
|
|
bStatus = DosBatchFilter( &SrcText, f );
|
|
TextFileClose( &SrcText );
|
|
}
|
|
|
|
if(!bStatus) {
|
|
fclose( f );
|
|
return( FALSE );
|
|
}
|
|
|
|
//
|
|
// Now add on the default autoexec file from the template file
|
|
//
|
|
|
|
if ( !TextFileOpen( szTemplate, &TemplateText ) ) {
|
|
SetErrorText(IDS_ERROR_OPENFAIL);
|
|
return( FALSE );
|
|
}
|
|
|
|
while ( TextFileReadLine( &TemplateText ) ) {
|
|
|
|
szLine = TextFileGetLine( &TemplateText );
|
|
sprintf( Buffer, " %s\n", szLine );
|
|
fputs( Buffer, f );
|
|
}
|
|
|
|
TextFileClose( &TemplateText );
|
|
fclose( f );
|
|
return( fTrue );
|
|
}
|
|
|
|
|
|
BOOL
|
|
DosBatchFilter(
|
|
IN OUT TEXTFILE * SrcText,
|
|
IN OUT FILE* f
|
|
)
|
|
{
|
|
SZ szLine;
|
|
SZ sz;
|
|
CHAR Buffer[ MAX_PATH ],*temp;
|
|
size_t Idx;
|
|
|
|
|
|
|
|
while ( TextFileReadLine( SrcText ) ) {
|
|
|
|
szLine = TextFileGetLine( SrcText );
|
|
sz = TextFileSkipBlanks( szLine );
|
|
|
|
|
|
//
|
|
// If blank line, ignore it
|
|
//
|
|
if ( !sz || *sz == '\0' || *sz == EOF ) {
|
|
// fputs( " \n", f );
|
|
// fprintf( f, "\n" );
|
|
continue;
|
|
}
|
|
|
|
|
|
//
|
|
// If this is a comment line, a SET or a PATH command, we
|
|
// write it verbatim, otherwise we REM it out
|
|
//
|
|
|
|
//
|
|
// If "no echo" command, skip the '@'
|
|
//
|
|
if ( *sz == '@' ) {
|
|
sz++;
|
|
}
|
|
|
|
Idx = strcspn( sz, " \t" );
|
|
if ( Idx <= strlen(sz) ) {
|
|
|
|
memcpy( Buffer, sz, Idx );
|
|
Buffer[Idx] = '\0';
|
|
|
|
if ( !_strcmpi( Buffer, "SET" ) ) {
|
|
|
|
// special hack to take out comspec line. we dont need
|
|
// this one for nt dos.
|
|
|
|
temp = &sz[Idx+1]; // point after set
|
|
|
|
// skip blanks
|
|
|
|
while (*temp && (*temp == ' ' || *temp == '\t')) {
|
|
temp++;
|
|
}
|
|
|
|
if (*temp == '\0') {
|
|
continue;
|
|
}
|
|
|
|
if (_strnicmp (temp,"comspec",7) == 0) { // ignore comspec
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// SET line, copy verbatim
|
|
//
|
|
sprintf( Buffer, " %s\n", szLine );
|
|
fputs( Buffer, f );
|
|
//fprintf( f, "%s\n", szLine );
|
|
continue;
|
|
|
|
} else if ( !_strcmpi( Buffer, "PATH" ) ) {
|
|
|
|
//
|
|
// PATH line, copy verbatim
|
|
//
|
|
sprintf( Buffer, " %s\n", szLine );
|
|
fputs( Buffer, f );
|
|
//fprintf( f, "%s\n", szLine );
|
|
continue;
|
|
|
|
} else {
|
|
|
|
//
|
|
// Any other, ignore
|
|
//
|
|
// sprintf( Buffer, " REM %s\n", szLine );
|
|
// fputs( Buffer, f );
|
|
// fprintf( f, "REM %s\n", szLine );
|
|
continue;
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
return fTrue;
|
|
}
|
|
|
|
|
|
|
|
// ***************************************************************************
|
|
//
|
|
// Windows Ini File Migration
|
|
//
|
|
// ***************************************************************************
|
|
|
|
|
|
|
|
|
|
BOOL
|
|
MigrateWinIniWorker(
|
|
LPSTR szWin31Dir
|
|
)
|
|
{
|
|
CHAR szPath[ MAX_PATH ];
|
|
CHAR szWindowsDir[ MAX_PATH ];
|
|
BOOL bStatus = FALSE;
|
|
|
|
//
|
|
// Check validity of windows directory
|
|
//
|
|
|
|
if ( !lstrcmpi( szWin31Dir, "" ) ) {
|
|
return ( TRUE );
|
|
}
|
|
|
|
lstrcpy( szPath, szWin31Dir );
|
|
lstrcat( szPath, WIN_COM );
|
|
if ( !FFileExist( szPath ) ) {
|
|
return( TRUE );
|
|
}
|
|
|
|
//
|
|
// Initialize local variables
|
|
//
|
|
|
|
if( !GetWindowsDirectory( szWindowsDir, MAX_PATH ) ) {
|
|
// BUGBUG -- Some error here
|
|
return( FALSE );
|
|
}
|
|
lstrcat ( szWindowsDir, "\\" );
|
|
|
|
//
|
|
// If win31 directory and NT windows directory the same then we don't
|
|
// have to do anything
|
|
//
|
|
|
|
if( !lstrcmpi( szWin31Dir, szWindowsDir ) ) {
|
|
return( TRUE );
|
|
}
|
|
|
|
//
|
|
// INI FILE MIGRATION:
|
|
// -------------------
|
|
// We will copy over any ini files found in the win31 directory over
|
|
// to the NT Windows directory. standard ini files that ship with win31 are
|
|
// copied over under alternate names so that when we access these with
|
|
// profile api, these do not map to the registry. Then we will use
|
|
// private profile api to migrate information selectively from the
|
|
// standard set to the nt ini files. Lastly the win3.1 win.ini is search
|
|
// for sections which do not ship with the default win.ini and these
|
|
// sections are transferred over to the NT win.ini useing private profile
|
|
// api
|
|
//
|
|
|
|
|
|
|
|
//
|
|
// Locate all ini files and copy over ini files from win31 directory to
|
|
// nt windows directory
|
|
//
|
|
|
|
if( !FFindAndCopyIniFiles( szWin31Dir, szWindowsDir ) ) {
|
|
goto cleanup;
|
|
}
|
|
|
|
//
|
|
// Migrate over all information we need to from infs in standard set
|
|
//
|
|
|
|
if( !FMigrateStandardIniData( szWindowsDir ) ) {
|
|
goto cleanup;
|
|
}
|
|
|
|
//
|
|
// Go through win.ini using Rtl routines and migrate information to
|
|
// our win.ini
|
|
//
|
|
|
|
if( !FMigrateWinIniAppSections( szWindowsDir ) ) {
|
|
goto cleanup;
|
|
}
|
|
|
|
//
|
|
// Do Ini cleanup where all the temporary ini files that were
|
|
//
|
|
|
|
bStatus = TRUE;
|
|
cleanup:
|
|
CleanupIniFiles( szWindowsDir );
|
|
return ( bStatus );
|
|
}
|
|
|
|
|
|
BOOL
|
|
FFindAndCopyIniFiles(
|
|
SZ szSrcDir,
|
|
SZ szDstDir
|
|
)
|
|
{
|
|
HANDLE hff;
|
|
CHAR szFindFile[ MAX_PATH ];
|
|
CHAR szSrcFile[ MAX_PATH ];
|
|
CHAR szDstFile[ MAX_PATH ];
|
|
WIN32_FIND_DATA FindFileData;
|
|
|
|
|
|
//
|
|
// Do find first, find next search and copy over any infs found which
|
|
// are not in the standard set under the same name and any under the
|
|
// standard set with a tmp extenstion
|
|
//
|
|
|
|
lstrcpy( szFindFile, szSrcDir );
|
|
lstrcat( szFindFile, "*.ini" );
|
|
|
|
if ((hff = FindFirstFile( szFindFile, &FindFileData )) != (HANDLE)-1) {
|
|
|
|
do {
|
|
SZ sz;
|
|
|
|
lstrcpy( szSrcFile, szSrcDir );
|
|
lstrcat( szSrcFile, (SZ)FindFileData.cFileName );
|
|
lstrcpy( szDstFile, szDstDir );
|
|
|
|
if ( sz = SzMapStandardIni( (SZ)FindFileData.cFileName ) ) {
|
|
if( !lstrcmpi( sz, "" ) ) {
|
|
continue;
|
|
}
|
|
lstrcat( szDstFile, sz );
|
|
}
|
|
else {
|
|
lstrcat( szDstFile, (SZ)FindFileData.cFileName );
|
|
}
|
|
|
|
if( FFileExist( szDstFile ) ) {
|
|
SetFileAttributes ( szDstFile, FILE_ATTRIBUTE_NORMAL );
|
|
DeleteFile( szDstFile );
|
|
}
|
|
|
|
if (!CopyFile( szSrcFile, szDstFile, FALSE )) {
|
|
SetErrorText(IDS_ERROR_COPYFILE);
|
|
FindClose( hff );
|
|
return( FALSE );
|
|
}
|
|
|
|
}
|
|
while (FindNextFile(hff, &FindFileData));
|
|
|
|
FindClose( hff );
|
|
}
|
|
|
|
return ( TRUE );
|
|
}
|
|
|
|
//
|
|
// The following is the data the migration routines work off
|
|
//
|
|
|
|
typedef struct _inifilenames {
|
|
SZ szIniFileName;
|
|
SZ szIniTmpFileName;
|
|
} INIFILENAMES;
|
|
|
|
INIFILENAMES IniList[] = {
|
|
{"win.ini" , "win.tmp" },
|
|
{"system.ini" , "" },
|
|
{"mouse.ini" , "" },
|
|
{"winfile.ini" , "" },
|
|
{"control.ini" , "" },
|
|
{"msd.ini" , "" },
|
|
{"dosapp.ini" , "" },
|
|
{"progman.ini" , "" }
|
|
};
|
|
|
|
INT nIniList = sizeof(IniList) / sizeof( INIFILENAMES ) ;
|
|
|
|
typedef struct _inimigratedata {
|
|
SZ szSrcIniFile;
|
|
SZ szSrcSection;
|
|
SZ szSrcKey;
|
|
SZ szDstIniFile;
|
|
SZ szDstSection;
|
|
SZ szDstKey;
|
|
} INIMIGRATEDATA;
|
|
|
|
INIMIGRATEDATA IniMigrateList[] = {
|
|
{"win.tmp", "windows", "NullPort" , "win.ini", "windows", "NullPort" },
|
|
};
|
|
|
|
INT nIniMigrateList = sizeof( IniMigrateList ) / sizeof( INIMIGRATEDATA );
|
|
|
|
|
|
//
|
|
// BUGBUG ** Post BETA enumerate them from the registry
|
|
//
|
|
|
|
SZ WinIniStandardSections[] = {
|
|
"windows" ,
|
|
"Desktop" ,
|
|
"intl" ,
|
|
"ports" ,
|
|
"Sounds" ,
|
|
"Compatibility" ,
|
|
"fonts" ,
|
|
"Network" ,
|
|
"Windows Help" ,
|
|
"spooler" ,
|
|
"MS Proofing Tools" ,
|
|
"devices" ,
|
|
"Winlogon" ,
|
|
"Console" ,
|
|
"Extensions" ,
|
|
"MCI Extensions" ,
|
|
"Clock" ,
|
|
"Terminal" ,
|
|
"FontSubstitutes" ,
|
|
"FontCache" ,
|
|
"TrueType" ,
|
|
"Colors" ,
|
|
"Sounds" ,
|
|
"MMDEBUG" ,
|
|
NULL
|
|
};
|
|
|
|
//
|
|
// Migration worker routines
|
|
//
|
|
|
|
BOOL
|
|
FMigrateStandardIniData(
|
|
SZ szWindowsDir
|
|
)
|
|
{
|
|
CHAR szValue[ MAX_PATH ];
|
|
CHAR szSrcFile[ MAX_PATH ];
|
|
|
|
|
|
INT i;
|
|
|
|
for( i = 0; i < nIniMigrateList; i++ ) {
|
|
lstrcpy( szSrcFile, szWindowsDir );
|
|
lstrcat( szSrcFile, IniMigrateList[i].szSrcIniFile );
|
|
|
|
if( FFileExist( szSrcFile ) &&
|
|
GetPrivateProfileString(
|
|
IniMigrateList[i].szSrcSection,
|
|
IniMigrateList[i].szSrcKey,
|
|
"",
|
|
(LPSTR)szValue,
|
|
(DWORD)MAX_PATH,
|
|
szSrcFile
|
|
) ) {
|
|
|
|
if( !WritePrivateProfileString(
|
|
IniMigrateList[i].szDstSection,
|
|
IniMigrateList[i].szDstKey,
|
|
szValue,
|
|
IniMigrateList[i].szDstIniFile
|
|
) ) {
|
|
//
|
|
// BUGBUG .. what do we do here .. do we quit or do
|
|
// we continue
|
|
//
|
|
|
|
KdPrint(("SETUPDLL: Failed to migrate ini entry."));
|
|
}
|
|
}
|
|
}
|
|
return ( TRUE );
|
|
}
|
|
|
|
|
|
BOOL
|
|
FMigrateWinIniAppSections(
|
|
SZ szWindowsDir
|
|
)
|
|
{
|
|
CHAR szConfig[ MAX_PATH ];
|
|
CHAR szSection[ MAX_PATH ];
|
|
TEXTFILE SrcText;
|
|
SZ szLine;
|
|
SZ sz, szEnd;
|
|
DWORD dwSize;
|
|
|
|
#define MAX_SECTION_BUFFER 10 * 1024
|
|
PVOID Buffer;
|
|
|
|
lstrcpy( szConfig, szWindowsDir );
|
|
lstrcat( szConfig, "win.tmp" );
|
|
|
|
//
|
|
// Open source file
|
|
//
|
|
|
|
if ( FFileExist( szConfig ) &&
|
|
TextFileOpen( szConfig, &SrcText ) ) {
|
|
|
|
//
|
|
// Allocate section buffer
|
|
//
|
|
|
|
if ( !(Buffer = SAlloc((CB) MAX_SECTION_BUFFER))) {
|
|
TextFileClose(&SrcText);
|
|
SetErrorText(IDS_ERROR_DLLOOM);
|
|
return( FALSE );
|
|
}
|
|
|
|
//
|
|
// Process config file, line by line
|
|
//
|
|
|
|
while ( TextFileReadLine( &SrcText ) ) {
|
|
|
|
szLine = TextFileGetLine( &SrcText );
|
|
sz = TextFileSkipBlanks( szLine );
|
|
|
|
|
|
//
|
|
// If first character not [ get next line
|
|
//
|
|
|
|
if ( !sz || *sz != '[' ) {
|
|
continue;
|
|
}
|
|
|
|
sz++;
|
|
szEnd = strchr( sz, ']' );
|
|
if ( szEnd ) {
|
|
|
|
dwSize = szEnd - sz;
|
|
if ( dwSize > MAX_PATH ) {
|
|
continue;
|
|
}
|
|
|
|
memcpy( szSection, sz, dwSize );
|
|
*(szSection + dwSize) = '\0';
|
|
|
|
//
|
|
// If section name one of standard set ignore
|
|
//
|
|
|
|
if( FIsStandardWinIniSection( szSection ) ) {
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// Read the entire section corresponding to the section
|
|
// from the source file and transfer it to the destination
|
|
// file using profile api
|
|
//
|
|
|
|
if( GetPrivateProfileSection(
|
|
szSection,
|
|
(LPSTR)Buffer,
|
|
MAX_SECTION_BUFFER,
|
|
szConfig
|
|
) ) {
|
|
|
|
if (!WriteProfileSection( szSection, Buffer ) ) {
|
|
// BUGBUG Do we quit here??
|
|
KdPrint(("SETUPDLL: Failed to migrate ini section."));
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
SFree( Buffer );
|
|
TextFileClose(&SrcText);
|
|
}
|
|
|
|
return ( TRUE );
|
|
}
|
|
|
|
|
|
|
|
SZ
|
|
SzMapStandardIni(
|
|
SZ szIniFile
|
|
)
|
|
{
|
|
INT i;
|
|
|
|
for ( i = 0; i < nIniList; i++ ) {
|
|
|
|
if( !lstrcmpi(szIniFile, IniList[i].szIniFileName ) ) {
|
|
return( IniList[i].szIniTmpFileName );
|
|
}
|
|
}
|
|
|
|
return( NULL );
|
|
}
|
|
|
|
|
|
VOID
|
|
CleanupIniFiles(
|
|
SZ szWindowsDir
|
|
)
|
|
{
|
|
CHAR szFile[ MAX_PATH ];
|
|
|
|
INT i;
|
|
|
|
for ( i = 0; i < nIniList; i++ ) {
|
|
if ( lstrcmpi( IniList[i].szIniTmpFileName, "" ) ) {
|
|
|
|
lstrcpy( szFile, szWindowsDir );
|
|
lstrcat( szFile, IniList[i].szIniTmpFileName );
|
|
|
|
if( FFileExist( szFile ) ) {
|
|
SetFileAttributes ( szFile, FILE_ATTRIBUTE_NORMAL );
|
|
DeleteFile( szFile );
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
BOOL
|
|
FIsStandardWinIniSection(
|
|
SZ szSection
|
|
)
|
|
{
|
|
PSZ psz;
|
|
|
|
psz = WinIniStandardSections;
|
|
while ( *psz ) {
|
|
if( !lstrcmpi( *psz++, szSection ) ) {
|
|
return ( TRUE );
|
|
}
|
|
}
|
|
return( FALSE );
|
|
|
|
}
|
|
|
|
#endif
|