able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/ntsetup/bom/files/files.c
CryptoAlgo Inc b3cac27891 Add source files
2020-09-26 16:20:57 +08:00

3191 lines
94 KiB
C
Raw Permalink Blame History

//
// 06.05.95 Joe Holman Created to copy the system files for
// the new shell and cairo releases.
// Currently, it only copies uncompressed system files.
// 06.16.95 Joe Holman Allow debugging tools to be copied. Uses _media.inx
// 06.19.95 Joe Holman Copy compressed version of file if specified in _layout.inx.
// 06.22.95 Joe Holman Added bCairoSuckNameHack to pick up files from
// the inf\cairo\_layout.cai file.
// 06.22.95 Joe Holman Added the SRV_INF fix so that we will pick up the compressed
// Server Infs in a different location than the Workstation compressed
// 06.22.95 Joe Holman For now, we won't use compressed Cairo files. Will change in July.
// INFs (due to the collision of names and difference with cdrom.w|s).
// 06.28.95 Joe Holman Won't make CHECKED Server.
// 07.07.95 Joe Holman For Cairo, we need to also look at the _layout.cai and
// _media.cai files
// for additional files (superset) that goes into Cairo.
// 08.03.95 Joe Holman Allow Cairo to have compressed files -> note, build team needs to
// private 2 locations, one for Shell release and one for Cairo release,
// ie, \\x86fre\cdcomp$.
// 08.14.95 Joe Holman Figure out if we copy the .dbg file for a particular file.
// 08.14.95 Joe Holman Allow DBG files for Cairo.
// 08.23.95 Joe Holman Add code to make tallying work with compressed/noncomp files and
// winn32 local source space needed.
// 10.13.95 Joe Holman Get MAPISVC.INF and MDM*.INF from Workstation location.
// 10.25.95 Joe Holman Put code in to use SetupDecompressOrCopyFile.
// 10.30.95 Joe Holman Don't give errors for vmmreg32.dbg - this is a file given
// by Win95 guys.
// 11.02.95 Joe Holman Allow multi-threaded support when SetupDecompressOrCopyFile
// is fixed.
// Pickup all for PPC on Cairo.
// 11.17.95 Joe Holman Check for upgrade size.
// 11.30.95 Joe Holman compare current dosnet.inf and txtsetup.sif values and error
// if we go over. Search for //code here.
// 12.04.95 Joe Holman Use Layout.inx instead of _layout.inx.
// 03.11.96 Joe Holman Don't give errors on MFC*.dbg if missing, since no .dbgs
// provided.
// 04.05.96 Joe Holman Add values for INETSRV and DRVLIB.NIC directories. Both of
// these get copied as local source. Inetsrv is NEVER installed
// automatically (unless via an unattend file) and one card is
// small. Thus, we will only add INETSRV and DRVLIB.NIC sizes
// to local source code below.
// and one or two of drvlib.nic MAY get installed.
// 04.19.96 Joe Holman Add code to NOT count *.ppd files in order to reduce
// minimum disk space required.
// 09.10.96 Joe Holman Add code that supports setup's new disk space calculation.
// Basically, we just need to provide values for each cluster
// size stored in dosnet.inf.
// 10.17.96 Joe Holman Comment out MIPS code, but leave in for P7.
// 12.06.96 Joe Holman Backported MSKK's DBCS changes.
// 01.20.97 Joe Holman Take out PPC.
// 05.15.97 Joe Holman Grovels layout.inf on release shares rather than file chked-in.
// xx.xx.xx Joe Holman Allow files not to worry about .dbgs for to be in a file.
// 08.01.97 Joe Holman Add code to check for 0 file size in layout.inf files.
// 08.26.97 Joe Holman Add code to pick-up files for NEC PC-98 machine for JA.
// 10.16.97 Joe Holman Added space calculation for .PNF files made
// during gui-mode setup.
// 11.07.97 Joe Holman Add code to verify that a filename is 8.3.
// 01.26.98 Joe Holman Since we are going to ship Enterprise Edition
// in addition to Workstation and Server,
// generalize the code to call files.exe 3 times
// in the script for each type of product.
// 07.06.98 Joe Holman Change default cluster size to 32, instead of 16.
// 11.02.98 Joe Holman Use new keys for local source and fresh install
// space requirements.
// 11.05.98 Joe Holman Added check to look for 0 byte length files
// after copy.
// 12.04.98 Joe Holman Added code for 4th floppy.
// 02.26.99 Joe Holman Add code that turns dbg file copying off/on.
// 03.15.99 Joe Holman Check that files in the drvindex.inf are not also in
// dosnet.inf, except for files on the bootfloppies.
// 05.13.99 Joe Holman Change dbg/pdb copying to use INF provided on release
// shares.
// 08.20.99 Joe Holman Remove Alpha.
// xx.xx.xx Joe Holman Provide switch that flush bits to disk after copy, then does a DIFF.
//
// Need to get space for:
// - inside cab and zip files ++ 20M
// - lang directory [ or maybe not, if we aren't going to install another lang] ++ 90M
// - uniproc directory ++ 2M
// - win9xmig ++2M
// - win9xupg ++3M
// - winntupg ++2M
//
//
#include <windows.h>
#include <setupapi.h>
#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#include <ctype.h>
#define MFL 256
CRITICAL_SECTION CriticalSection;
#define MAX_NUMBER_OF_FILES_IN_PRODUCT 14500 // # greater than # of files in product.
#define EIGHT_DOT_THREE 8+1+3+1
struct _tag {
WORD wNumFiles;
BOOL bCopyComp [MAX_NUMBER_OF_FILES_IN_PRODUCT];
char wcFilesArray[MAX_NUMBER_OF_FILES_IN_PRODUCT][EIGHT_DOT_THREE];
char wcSubPath [MAX_NUMBER_OF_FILES_IN_PRODUCT][EIGHT_DOT_THREE]; // used for debugging files
BOOL bCountBytes [MAX_NUMBER_OF_FILES_IN_PRODUCT];
BOOL bTextMode [MAX_NUMBER_OF_FILES_IN_PRODUCT];
BOOL bCopyItToCD [MAX_NUMBER_OF_FILES_IN_PRODUCT];
};
BOOL bNec98 = FALSE;
BOOL bNec98LikeX86 = FALSE;
BOOL bChecked = FALSE;
BOOL bVerifyBits = FALSE;
BOOL bGetSizeLater = TRUE;
struct _tag ix386;
struct _tag Nec98;
DWORD x86From351 = 0;
DWORD x86From400 = 0;
DWORD x86From500 = 0;
BOOL hack;
BOOL fX86, fNec98;
BOOL bCopyCompX86 = FALSE; // flag to tell if file shall be copied in its compressed format.
BOOL bCopyCompNec98 = FALSE;
//
// Following are masks that correspond to the particular data in a DOS date
//
#define DOS_DATE_MASK_DAY (WORD) 0x001f // low 5 bits (1-31)
#define DOS_DATE_MASK_MONTH (WORD) 0x01e0 // mid 4 bits (1-12)
#define DOS_DATE_MASK_YEAR (WORD) 0xfe00 // high 7 bits (0-119)
//
// Following are masks that correspond to the particular data in a DOS time
//
#define DOS_TIME_MASK_SECONDS (WORD) 0x001f // low 5 bits (0-29)
#define DOS_TIME_MASK_MINUTES (WORD) 0x07e0 // mid 6 bits (0-59)
#define DOS_TIME_MASK_HOURS (WORD) 0xf800 // high 5 bits (0-23)
//
// Shift constants used for building/getting DOS dates and times
//
#define DOS_DATE_SHIFT_DAY 0
#define DOS_DATE_SHIFT_MONTH 5
#define DOS_DATE_SHIFT_YEAR 9
#define DOS_TIME_SHIFT_SECONDS 0
#define DOS_TIME_SHIFT_MINUTES 5
#define DOS_TIME_SHIFT_HOURS 11
//
// Macros to extract the data out of DOS dates and times.
//
// Note: Dos years are offsets from 1980. Dos seconds have 2 second
// granularity
//
#define GET_DOS_DATE_YEAR(wDate) ( ( (wDate & DOS_DATE_MASK_YEAR) >> \
DOS_DATE_SHIFT_YEAR ) + \
(WORD) 1980 )
#define GET_DOS_DATE_MONTH(wDate) ( (wDate & DOS_DATE_MASK_MONTH) >> \
DOS_DATE_SHIFT_MONTH )
#define GET_DOS_DATE_DAY(wDate) ( wDate & DOS_DATE_MASK_DAY )
#define GET_DOS_TIME_HOURS(wTime) ( (wTime & DOS_TIME_MASK_HOURS) >> \
DOS_TIME_SHIFT_HOURS )
#define GET_DOS_TIME_MINUTES(wTime) ( (wTime & DOS_TIME_MASK_MINUTES) >> \
DOS_TIME_SHIFT_MINUTES )
#define GET_DOS_TIME_SECONDS(wTime) ( (wTime & DOS_TIME_MASK_SECONDS) << 1 )
// Paths loaded in from the command line.
//
char szLogFile[MFL];
char szProductName[MFL];
char szX86Src[MFL];
char szEnlistDrv[MFL];
char szX86DstDrv[MFL];
char szUnCompX86[MFL];
char szUnCompNec98[MFL];
char szNec98Src[MFL];
#define I386_DIR "\\i386\\SYSTEM32"
#define NEC98_DIR "\\NEC98\\SYSTEM32"
#define NETMON "\\netmon"
#define I386_DIR_RAW "\\i386"
#define NEC98_DIR_RAW "\\NEC98"
#define idBase 0
#define idX86 1
HANDLE hInfDosnet = NULL;
HANDLE hInfLayout = NULL;
HANDLE hInfDrvIndex = NULL;
#define NUM_EXTS 14
char * cExtra[] = { "acm", "ax", "cfm", "com", "cpl", "dll", "drv", "ds", "exe", "io", "ocx", "scr", "sys", "tsp" };
// Tally up the # of bytes required for the system from the files included.
//
struct _ClusterSizes {
DWORD Kh1;
DWORD K1;
DWORD K2;
DWORD K4;
DWORD K8;
DWORD K16;
DWORD K32;
DWORD K64;
DWORD K128;
DWORD K256;
};
// Cluster sizes for local source, ie. the ~ls directory.
//
struct _ClusterSizes lX86;
struct _ClusterSizes lNec98;
// Cluster sizes for fresh install space.
//
struct _ClusterSizes freshX86;
struct _ClusterSizes freshNec98;
// Cluster sizes for textmode savings.
//
struct _ClusterSizes tX86;
struct _ClusterSizes tNec98;
//DWORD bytesX86;
//DWORD bytesNec98;
//
// Macro for rounding up any number (x) to multiple of (n) which
// must be a power of 2. For example, ROUNDUP( 2047, 512 ) would
// yield result of 2048.
//
#define ROUNDUP2( x, n ) (((x) + ((n) - 1 )) & ~((n) - 1 ))
FILE* logFile;
void GiveThreadId ( const CHAR * szFormat, ... ) {
va_list vaArgs;
va_start ( vaArgs, szFormat );
vprintf ( szFormat, vaArgs );
vfprintf ( logFile, szFormat, vaArgs );
va_end ( vaArgs );
}
void Msg ( const CHAR * szFormat, ... ) {
va_list vaArgs;
EnterCriticalSection ( &CriticalSection );
GiveThreadId ( "%s %ld: ", szProductName, GetCurrentThreadId () );
va_start ( vaArgs, szFormat );
vprintf ( szFormat, vaArgs );
vfprintf ( logFile, szFormat, vaArgs );
va_end ( vaArgs );
LeaveCriticalSection ( &CriticalSection );
}
void Header(argv,argc)
char * argv[];
int argc;
{
time_t t;
char tmpTime[100];
CHAR wtmpTime[200];
Msg ( "\n=========== FILES ====================\n" );
Msg ( "Log file : %s\n", szLogFile );
Msg ( "Product Name : %s\n", szProductName );
Msg ( "enlisted drive : %s\n", szEnlistDrv );
Msg ( "x86 files : %s\n", szX86Src);
Msg ( "drive to put x86 : %s\n", szX86DstDrv );
Msg ( "uncompressed x86 files : %s\n", szUnCompX86 );
if ( bNec98 ) {
Msg ( "nec98 files : %s\n", szNec98Src);
Msg ( "uncompressed nec98 files : %s\n", szUnCompNec98 );
}
time(&t);
Msg ( "Time: %s", ctime(&t) );
Msg ( "========================================\n\n");
}
void Usage( void ) {
printf( "PURPOSE: Copies the system files that compose the product.\n");
printf( "\n");
printf( "PARAMETERS:\n");
printf( "\n");
printf( "[LogFile] - Path to append a log of actions and errors.\n");
printf( "[ProductName] - product name\n" );
printf( "[enlisted drive]- drive that is enlisted\n" );
printf( "[files share] - location of x86 files.\n" );
printf( "[dest path x86] - drive to put files\n" );
printf( "[uncompressed x86] - drive to put files\n" );
if ( bNec98 ) {
printf( "[files share]- location of nec98 files\n" );
printf( "[uncomp nec98]- location to get sizes from\n" );
}
printf( "\n" );
}
char dbgStr1[30];
char dbgStr2[30];
BOOL IsFileInSpecialWinnt32Directory ( char * szFileName ) {
char szUpCasedName[MFL];
int i;
char * foo[] = {
"WINNT32.EXE",
"WINNT32A.DLL",
"WINNT32U.DLL",
"WINNT32.HLP",
(char *) 0
};
strcpy ( szUpCasedName, szFileName );
_strupr ( szUpCasedName );
for ( i=0; foo[i] != 0; i++ ) {
//Msg ( "Comparing: %s vs. %s\n", szUpCasedName, foo[i] );
if ( strstr ( szUpCasedName, foo[i] ) ) {
return TRUE; // file should be in this directory
}
}
return FALSE; // no, file doesn't go in the winnt32 directory
}
void ShowMeDosDateTime ( CHAR * srcPath, WORD wDateSrc, WORD wTimeSrc,
CHAR * dstPath, WORD wDateDst, WORD wTimeDst ) {
Msg ( "%s %02d.%02d.%02d %02d:%02d.%02d\n",
srcPath,
GET_DOS_DATE_MONTH(wDateSrc),
GET_DOS_DATE_DAY(wDateSrc),
GET_DOS_DATE_YEAR(wDateSrc),
GET_DOS_TIME_HOURS(wTimeSrc),
GET_DOS_TIME_MINUTES(wTimeSrc),
GET_DOS_TIME_SECONDS(wTimeSrc) );
Msg ( "%s %02d.%02d.%02d %02d:%02d.%02d\n",
dstPath,
GET_DOS_DATE_MONTH(wDateDst),
GET_DOS_DATE_DAY(wDateDst),
GET_DOS_DATE_YEAR(wDateDst),
GET_DOS_TIME_HOURS(wTimeDst),
GET_DOS_TIME_MINUTES(wTimeDst),
GET_DOS_TIME_SECONDS(wTimeSrc) );
}
void Replay ( char * srcBuf, char * dstBuf, DWORD srcBytesRead, DWORD startIndex ) {
DWORD i;
for ( i = startIndex; (i < startIndex+5) && (i <= srcBytesRead); ++i ) {
Msg ( "srcBuf[%ld] = %x, dstBuf[%ld] = %x\n", i, srcBuf[i], i, dstBuf[i] );
}
}
BOOL IsDstCompressed ( char * szPath ) {
// Msg ( ">>> char %s: %c\n", szPath, szPath[strlen(szPath)-1] );
if ( szPath[strlen(szPath)-1] == '_' ) {
return(TRUE);
}
return (FALSE);
}
#define V_I386 "C:\\testi386"
#define V_NEC98 "C:\\testnec98"
BOOL MyCopyFile ( char * fileSrcPath, char * fileDstPath ) {
HANDLE hSrc, hDst;
WIN32_FIND_DATA wfdSrc, wfdDst;
BOOL bDoCopy = FALSE;
#define NUM_BYTES_TO_READ 2048
unsigned char srcBuf[NUM_BYTES_TO_READ];
unsigned char dstBuf[NUM_BYTES_TO_READ];
WORD srcDate, srcTime, dstDate, dstTime;
DWORD dwAttributes;
char szTmpFile[MFL] = { '\0' };
UINT uiRetSize = 299;
char szJustFileName[MFL];
char szJustDirectoryName[MFL];
BOOL b;
// Find the source file.
//
hSrc = FindFirstFile ( fileSrcPath, &wfdSrc );
if ( hSrc == INVALID_HANDLE_VALUE ) {
// HACK: Since the release shares put WINNT32.EXE in the WINNT32 directory
// instead of leaving it in the flat root, verify that if the fileSrcPath
// contains WINNT32.EXE we look in the WINNT32 dir also before error'ing out.
//
if ( IsFileInSpecialWinnt32Directory ( fileSrcPath ) ) {
char tmpSrcPath[MFL];
strcpy ( tmpSrcPath, fileSrcPath );
if ( strstr ( fileSrcPath, ".HLP" ) ||
strstr ( fileSrcPath, ".hlp" ) ) {
strcpy ( &tmpSrcPath[ strlen(tmpSrcPath) - 4 ], "\\WINNT32.HLP" );
}
else if ( strstr ( fileSrcPath, ".MSI" ) ||
strstr ( fileSrcPath, ".msi" ) ) {
strcpy ( &tmpSrcPath[ strlen(tmpSrcPath) - 4 ], "\\WINNT32.MSI" );
}
else if ( strstr ( fileSrcPath, "a.dll" ) ||
strstr ( fileSrcPath, "A.DLL" ) ) {
strcpy ( &tmpSrcPath[ strlen(tmpSrcPath) - 5 ], "\\WINNT32a.dll" );
}
else if ( strstr ( fileSrcPath, "u.dll" ) ||
strstr ( fileSrcPath, "U.DLL" ) ) {
strcpy ( &tmpSrcPath[ strlen(tmpSrcPath) - 5 ], "\\WINNT32u.dll" );
}
else {
strcpy ( &tmpSrcPath[ strlen(tmpSrcPath) - 4 ], "\\WINNT32.EXE" );
}
hSrc = FindFirstFile ( tmpSrcPath, &wfdSrc );
if ( hSrc == INVALID_HANDLE_VALUE ) {
Msg ( "ERROR on fileSrcPath(tmpSrcPath) = %s, gle = %ld\n", tmpSrcPath, GetLastError() );
return (FALSE);
}
else {
strcpy ( fileSrcPath, tmpSrcPath );
}
}
else {
Msg ( "ERROR on fileSrcPath = %s, gle = %ld\n", fileSrcPath, GetLastError() );
return (FALSE);
}
}
// Find the destination file.
//
hDst = FindFirstFile ( fileDstPath, &wfdDst );
if ( hDst == INVALID_HANDLE_VALUE ) {
DWORD gle;
gle = GetLastError();
if ( gle == ERROR_FILE_NOT_FOUND ) {
// The file doesn't exist on the destination. Do the copy.
//
bDoCopy = TRUE;
}
else {
// Got another kind of error, report this problem.
//
Msg ( "ERROR FindFirstFile fileDstPath = %s, gle = %ld\n", fileDstPath, gle );
FindClose ( hSrc );
return ( FALSE );
}
}
else {
// Both the src and dst exist.
// Let's see if the src is NEWER than the dst, if so, copy.
//
//
b = FileTimeToDosDateTime ( &wfdSrc.ftLastWriteTime, &srcDate, &srcTime );
b = FileTimeToDosDateTime ( &wfdDst.ftLastWriteTime, &dstDate, &dstTime );
if ( (srcDate != dstDate) || (srcTime != dstTime) ) {
ShowMeDosDateTime ( fileSrcPath, srcDate, srcTime, fileDstPath, dstDate, dstTime );
bDoCopy = TRUE;
}
}
// Additional check, verify the file sizes are the same.
//
if ( wfdSrc.nFileSizeLow != wfdSrc.nFileSizeLow ) {
bDoCopy = TRUE;
}
if ( wfdSrc.nFileSizeHigh != wfdDst.nFileSizeHigh ) {
bDoCopy = TRUE;
}
if ( bDoCopy ) {
BOOL b;
DWORD gle;
// Make sure our destination is never READ-ONLY.
//
b = SetFileAttributes ( fileDstPath, FILE_ATTRIBUTE_NORMAL );
if ( !b ) {
// Don't error if the file doesn't exist yet.
//
if ( GetLastError() != ERROR_FILE_NOT_FOUND ) {
Msg ( "ERROR: SetFileAttributes: gle = %ld, %s\n", GetLastError(), fileDstPath);
}
}
b = CopyFile ( fileSrcPath, fileDstPath, FALSE );
if ( b ) {
Msg ( "Copy: %s >>> %s [OK]\n", fileSrcPath, fileDstPath );
}
else {
Msg ( "ERROR Copy: %s >>> %s, gle = %ld\n", fileSrcPath, fileDstPath, GetLastError() );
}
}
else {
Msg ( "%s %d %d %ld %ld +++ %s %d %d %ld %ld [SAME]\n", fileSrcPath, srcDate, srcTime, wfdSrc.nFileSizeLow, wfdSrc.nFileSizeHigh, fileDstPath , dstDate, dstTime, wfdDst.nFileSizeLow, wfdDst.nFileSizeHigh );
}
FindClose ( hSrc );
FindClose ( hDst );
// Make sure our destination is never READ-ONLY.
//
b = SetFileAttributes ( fileDstPath, FILE_ATTRIBUTE_NORMAL );
if ( !b ) {
Msg ( "ERROR: SetFileAttributes: gle = %ld, %s\n", GetLastError(), fileDstPath);
}
// Let's make sure that the file is not 0 bytes in length, due to some
// network problem.
//
hDst = FindFirstFile ( fileDstPath, &wfdDst );
if ( hDst == INVALID_HANDLE_VALUE ) {
Msg ( "ERROR: Can't get size of %s, gle=%ld\n", fileDstPath, GetLastError() );
}
else {
if ( wfdDst.nFileSizeLow == 0 && wfdDst.nFileSizeHigh == 0 ) {
Msg ( "ERROR: Warning: %s is 0 bytes in length !\n", fileDstPath );
}
FindClose ( hDst );
}
// Do bit verification here on all files coming into MyCopyFile.
//
if ( bVerifyBits ) {
BOOL bNoError = TRUE;
HANDLE SrcFileHandle, DstFileHandle;
BOOL b;
BY_HANDLE_FILE_INFORMATION srcFileInformation;
BY_HANDLE_FILE_INFORMATION dstFileInformation;
DWORD srcBytesRead;
DWORD dstBytesRead;
DWORD i;
DWORD totalBytesRead = 0;
#define OFFSET_FILENAME 0x3C // address of file name in diamond header.
// >>> use struct later instead of this hack.
#define OFFSET_PAST_FILENAME 8 + 1 + 3 + 2 // we only use 8.3 filenames.
char unCompressedFileName[OFFSET_PAST_FILENAME];
BOOL bIsDstCompressed = FALSE;
DWORD dw;
char szExpandToDir[MFL];
char target[MFL];
int iRc;
unsigned short unicodeFileLocation[MFL];
unsigned short unicodeTargetLocation[MFL];
bIsDstCompressed = IsDstCompressed ( fileDstPath );
if ( bIsDstCompressed ) {
FILE * fHandle;
char szEndingFileName[MFL];
// Figure out where source should be from.
// Ie., we need to figure out the uncompressed path from the compressed path.
//
if ( fileDstPath[0] == szX86DstDrv[0] ) {
// We are working with Workstation binaries.
//
if ( strstr ( fileSrcPath, szX86Src ) ) {
strcpy ( fileSrcPath, szX86Src );
strcpy ( szExpandToDir, V_I386 );
}
else {
Msg ( "ERROR: couldn't determined location for: %s\n", fileSrcPath );
bNoError = FALSE;
goto cleanup0;
}
}
else {
Msg ( "ERROR: couldn't determined drive for: %s\n", fileDstPath );
bNoError = FALSE;
goto cleanup0;
}
// NOTE: At this point, fileSrcPath ONLY has a path, it now has NO filename !
//
// Find the expanded file name from the compressed file.
//
fHandle = fopen ( fileDstPath, "rb" );
if ( fHandle == NULL) {
Msg ( "ERROR Couldn't open file with fopen to find expanded name: %s\n", fileDstPath );
bNoError = FALSE;
goto cleanup0;
}
else {
size_t bytesRead;
int location;
location = fseek ( fHandle, OFFSET_FILENAME, SEEK_SET );
if ( location != 0 ) {
Msg ( "fseek ERROR\n" );
bNoError = FALSE;
fclose ( fHandle );
goto cleanup0;
}
bytesRead = fread ( unCompressedFileName, 1, OFFSET_PAST_FILENAME, fHandle );
/***
for ( i = 0; i < bytesRead; ++i ) {
printf ( "%X(%c) ", buffer[i], buffer[i] );
}
printf ( "\n" );
***/
if ( bytesRead != OFFSET_PAST_FILENAME ) {
Msg ( "ERROR: bytesRead = %x not %x\n", bytesRead, OFFSET_PAST_FILENAME );
bNoError = FALSE;
fclose ( fHandle );
goto cleanup0;
}
fclose ( fHandle );
}
// Expand the file.
//
sprintf ( target, "%s\\%s", szExpandToDir, unCompressedFileName );
iRc = MultiByteToWideChar ( CP_ACP,
MB_PRECOMPOSED,
fileDstPath,
strlen ( fileDstPath )+1,
unicodeFileLocation,
MFL/2 );
if ( !iRc ) {
Msg ( "MultiByteToWideChar: ERROR, gle = %ld, %s\n", GetLastError(), fileDstPath );
}
iRc = MultiByteToWideChar ( CP_ACP,
MB_PRECOMPOSED,
target,
strlen ( target )+1,
unicodeTargetLocation,
MFL/2 );
if ( !iRc ) {
Msg ( "MultiByteToWideChar: ERROR, gle = %ld, %s\n", GetLastError(), target );
}
dw = SetupDecompressOrCopyFileW (
unicodeFileLocation,
unicodeTargetLocation,
NULL );
if ( dw ) {
Msg ( "ERROR SetupDecompressOrCopyFile, dw = %d, fileDstPath=%s, target=%s\n",
dw, fileDstPath, target );
bNoError = FALSE;
goto cleanup0;
}
else {
Msg ( "SetupDecompressOrCopyFile: %s >> %s [OK]\n", fileDstPath, target );
}
// Put the Source and Destination paths and filenames back together
// now so we can do the file compare.
//
strcat ( fileSrcPath, "\\" );
strcat ( fileSrcPath, unCompressedFileName );
sprintf ( fileDstPath, "%s\\%s", szExpandToDir, unCompressedFileName );
}
SrcFileHandle = CreateFile ( fileSrcPath,
GENERIC_READ /*| FILE_EXECUTE*/,
FILE_SHARE_READ /*| FILE_SHARE_DELETE*/,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_NO_BUFFERING,
NULL);
if ( SrcFileHandle == INVALID_HANDLE_VALUE) {
Msg ( "ERROR verify: Couldn't open source: %s, gle = %ld\n", fileSrcPath, GetLastError() );
bNoError = FALSE;
goto cleanup0;
}
DstFileHandle = CreateFile ( fileDstPath,
GENERIC_READ /*| FILE_EXECUTE*/,
FILE_SHARE_READ /*| FILE_SHARE_DELETE*/,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_NO_BUFFERING,
NULL);
if ( DstFileHandle == INVALID_HANDLE_VALUE) {
Msg ( "ERROR verify: Couldn't open destination: %s, gle = %ld\n", fileDstPath, GetLastError() );
bNoError = FALSE;
CloseHandle ( SrcFileHandle );
goto cleanup0;
}
//GetDiskFreeSpace(); // get sector size. // need to use this sector size in reads due to above NO_BUFFERING flag.
b = GetFileInformationByHandle ( SrcFileHandle, &srcFileInformation );
if ( !b ) {
Msg ( "ERROR: GetFileInformationByHandle on src, gle = %ld\n", GetLastError() );
bNoError = FALSE;
srcFileInformation.nFileSizeLow = 0;
goto cleanup1;
}
b = GetFileInformationByHandle ( DstFileHandle, &dstFileInformation );
if ( !b ) {
Msg ( "ERROR: GetFileInformationByHandle on dst, gle = %ld\n", GetLastError() );
bNoError = FALSE;
dstFileInformation.nFileSizeLow = 0;
goto cleanup1;
}
// Make sure the files are the same size.
//
if ( srcFileInformation.nFileSizeLow != dstFileInformation.nFileSizeLow ) {
Msg ( "ERROR: file size different: %s %ld %s %ld\n", fileSrcPath, srcFileInformation.nFileSizeLow, fileDstPath, dstFileInformation.nFileSizeLow );
bNoError = FALSE;
goto cleanup1;
}
// Compare the bits.
//
totalBytesRead = 0;
while ( 1 ) {
b = ReadFile ( SrcFileHandle, &srcBuf, NUM_BYTES_TO_READ, &srcBytesRead, NULL );
if ( !b ) {
Msg ( "ERROR: ReadFile src, gle = %ld\n", GetLastError() );
bNoError = FALSE;
goto cleanup1;
break;
}
b = ReadFile ( DstFileHandle, &dstBuf, NUM_BYTES_TO_READ, &dstBytesRead, NULL );
if ( !b ) {
Msg ( "ERROR: ReadFile dst, gle = %ld\n", GetLastError() );
bNoError = FALSE;
goto cleanup1;
break;
}
// Read # of bytes need to be the same.
//
if ( srcBytesRead != dstBytesRead ) {
Msg ( "ERROR: file read sizes different: %ld vs. %ld\n", srcBytesRead, dstBytesRead );
bNoError = FALSE;
goto cleanup1;
break;
}
// Successfully read to end of file, we can break out now.
//
if ( srcBytesRead == 0 || dstBytesRead == 0 ) {
if ( totalBytesRead != srcFileInformation.nFileSizeLow ) {
Msg ( "ERROR: totalBytesRead = %ld notequal srcFileInformation.nFileSizeLow = %ld\n",
totalBytesRead, srcFileInformation.nFileSizeLow );
bNoError = FALSE;
goto cleanup1;
}
break;
}
totalBytesRead += srcBytesRead;
for ( i = 0; i < srcBytesRead; ++i ) {
if ( srcBuf[i] != dstBuf[i] ) {
Msg ( "ERROR: srcBuf %d != dstBuf %d, i = %ld srcBytesRead = %ld totalBytesRead = %ld %s %s \n", srcBuf[i], dstBuf[i], i, srcBytesRead, totalBytesRead, fileSrcPath, fileDstPath );
bNoError = FALSE;
Replay ( srcBuf, dstBuf, srcBytesRead, i );
goto cleanup1;
}
}
//Msg ( "%s %ld of %ld examined...\n", fileSrcPath, totalBytesRead, srcFileInformation.nFileSizeLow );
}
// Close the file handles.
//
cleanup1:;
CloseHandle ( SrcFileHandle );
CloseHandle ( DstFileHandle );
Msg ( "Verify: %s >>> %s [OK]\n", fileSrcPath, fileDstPath );
cleanup0:;
// If the file is compressed, ie. expanded, and the there wasn't an error
// comparing, get rid of the expanded file so it doesn't take up any space.
// But, if there was an error, leave it around for examination purposes.
//
if ( bIsDstCompressed && bNoError ) {
char szDeleteFile[MFL];
BOOL b;
sprintf ( szDeleteFile, "%s\\%s", szExpandToDir, unCompressedFileName );
b = DeleteFile ( szDeleteFile );
if ( !b ) {
Msg ( "ERROR: DeleteFile FAILED %s, gle = %ld\n", szDeleteFile, GetLastError() );
}
}
}
return (TRUE);
}
#define FILE_SECTION_BASE "[SourceDisksFiles]"
#define FILE_SECTION_X86 "[SourceDisksFiles.x86]"
BOOL CreateDir ( char * wcPath ) {
BOOL b;
char cPath[MFL];
char cPath2[MFL];
int iIndex = 0;
char * ptr=wcPath;
// Msg ( "CreateDir: wcPath = %s\n", wcPath );
do {
cPath[iIndex] = *wcPath;
cPath[iIndex+1] = '\0';
//Msg ( "cPath = %s\n", cPath );
if ( cPath[iIndex] == '\\' || cPath[iIndex] == '\0' ) {
if ( iIndex <= 2 ) {
//Msg ( "skpdrv: iIndex = %d\n", iIndex );
goto skipdrv;
}
strcpy ( cPath2, cPath );
cPath2[iIndex] = '\0';
//Msg ( "Create with: >>>%s<<<\n", cPath2 );
b = CreateDirectory ( cPath, NULL );
if ( !b ) {
DWORD dwGle;
dwGle = GetLastError();
if ( dwGle != ERROR_ALREADY_EXISTS ) {
Msg ( "ERROR CreateDirectory gle = %ld, wcPath = %s\n", dwGle, ptr );
return(FALSE);
}
}
else {
Msg ( "Made dir: %s\n", cPath );
}
if ( cPath[iIndex] == '\0' ) {
break;
}
}
skipdrv:;
++iIndex;
++wcPath;
} while ( 1 );
return(TRUE);
}
BOOL CreateDestinationDirs ( void ) {
CHAR dstDirectory[MFL];
// Create the directories to compare the bits, used later in MyCopyFile().
//
CreateDir ( V_I386 );
if ( bNec98 ) {
CreateDir ( V_NEC98 );
}
// Create the %platform%\system32 directories.
//
sprintf ( dstDirectory, "%s%s", szX86DstDrv, I386_DIR ); CreateDir ( dstDirectory );
if ( bNec98 ) {
sprintf ( dstDirectory, "%s%s", szX86DstDrv, NEC98_DIR ); CreateDir ( dstDirectory );
}
return(TRUE);
}
VOID MakeCompName ( const char * inFile, char * outFile ) {
unsigned i;
unsigned period;
strcpy( outFile, inFile );
for ( period=(unsigned)(-1), i = 0 ; i < strlen(inFile); i++ ) {
if ( inFile[i] == '.' ) {
period = i;
}
}
if ( period == (strlen(inFile)-4) ) {
outFile[strlen(outFile)-1] = '_';
}
else if ( period == (unsigned)(-1)) {
strcat ( outFile, "._");
}
else {
strcat ( outFile, "_");
}
}
DWORD CopyX86 ( void ) {
char fileSrcPath[256];
char fileDstPath[256];
DWORD i;
fX86 = FALSE;
Msg ( "CopyX86...\n" );
for ( i = 0; i < ix386.wNumFiles; ++i ) {
//Msg ( "0.working on %ld of %ld files: %s\n", i, ix386.wNumFiles, ix386.wcFilesArray[i] );
// Copy the system file.
//
if ( !ix386.bCopyItToCD[i] ) {
Msg ( "Not going to copy inner cab file to CD: %s\n", ix386.wcFilesArray[i] );
goto JustX86;
}
if ( ix386.bCopyComp[i] ) {
char szCompressedName[256];
MakeCompName ( ix386.wcFilesArray[i], szCompressedName );
sprintf ( fileSrcPath, "%s\\%s", szX86Src, szCompressedName );
sprintf ( fileDstPath, "%s\\i386\\%s", szX86DstDrv, szCompressedName );
Msg ( "compressed source Path = %s\n", fileSrcPath );
}
else {
sprintf ( fileSrcPath, "%s\\%s", szX86Src, ix386.wcFilesArray[i] );
sprintf ( fileDstPath, "%s\\i386\\%s", szX86DstDrv, ix386.wcFilesArray[i] );
}
MyCopyFile ( fileSrcPath, fileDstPath );
JustX86:;
}
fX86 = TRUE;
return (TRUE);
}
DWORD CopyNec98 ( void ) {
char fileSrcPath[256];
char fileDstPath[256];
DWORD i;
fNec98 = FALSE;
Msg ( "CopyNec98...\n" );
for ( i = 0; i < Nec98.wNumFiles; ++i ) {
// Copy the system file.
//
if ( !Nec98.bCopyItToCD[i] ) {
Msg ( "Not going to copy inner cab file to CD: %s\n", Nec98.wcFilesArray[i] );
goto JustNec98;
}
if ( Nec98.bCopyComp[i] ) {
char szCompressedName[256];
MakeCompName ( Nec98.wcFilesArray[i], szCompressedName );
sprintf ( fileSrcPath, "%s\\%s", szNec98Src, szCompressedName );
sprintf ( fileDstPath, "%s\\Nec98\\%s", szX86DstDrv, szCompressedName );
Msg ( "compressed source Path = %s\n", fileSrcPath );
}
else {
sprintf ( fileSrcPath, "%s\\%s", szNec98Src, Nec98.wcFilesArray[i] );
sprintf ( fileDstPath, "%s\\Nec98\\%s", szX86DstDrv, Nec98.wcFilesArray[i] );
}
MyCopyFile ( fileSrcPath, fileDstPath );
JustNec98:;
}
fNec98 = TRUE;
return (TRUE);
}
BOOL CopyTheFiles ( void ) {
DWORD tId;
HANDLE hThread;
hThread = CreateThread ( NULL, 0, (LPTHREAD_START_ROUTINE) CopyX86, NULL, 0, &tId );
if ( hThread == NULL ) {
Msg ( "x86 CreateThread ERROR gle = %ld\n", GetLastError() );
}
// Assume TRUE here so if we don't copy Nec98 files, our while loop won't
// be dependant on this variable.
//
fNec98 = TRUE;
if ( bNec98 ) {
hThread = CreateThread ( NULL, 0, (LPTHREAD_START_ROUTINE) CopyNec98, NULL, 0, &tId );
if ( hThread == NULL ) {
Msg ( "Nec98 CreateThread ERROR gle = %ld\n", GetLastError() );
}
}
while ( fX86 == FALSE ||
fNec98 == FALSE ) {
Sleep ( 1000 );
}
return(TRUE);
}
#define FILE_SECTION_NOT_USED 0xFFFF
DWORD dwInsideSection = FILE_SECTION_NOT_USED;
DWORD FigureSection ( char * Line ) {
Msg ( "FigureSection on: %s\n", Line );
if ( strstr ( Line, FILE_SECTION_BASE ) ) {
dwInsideSection = idBase;
}
else
if ( strstr ( Line, FILE_SECTION_X86 ) ) {
dwInsideSection = idX86;
}
else {
dwInsideSection = FILE_SECTION_NOT_USED;
}
Msg ( "dwInsideSection = %x\n", dwInsideSection );
return(dwInsideSection);
}
char * SuckName ( const char * Line ) {
static char szSuckedName[MFL];
DWORD dwIndex = 0;
// Copy the file name until a space is encountered.
//
while ( *Line != ' ' ) {
szSuckedName[dwIndex] = *Line;
szSuckedName[dwIndex+1] = '\0';
++Line;
++dwIndex;
}
return szSuckedName;
}
char * SuckSubName ( const char * Line ) {
static char szSub[150];
DWORD i = 0;
char * sPtr;
char * ePtr;
Msg ( "SuckSubName Line = %s\n", Line );
// Find the = sign in the line.
//
sPtr = strchr ( Line, '=' );
if ( sPtr == NULL ) {
Msg ( "SuckSubName ERROR, couldn't find '=' character in string: %s\n", Line );
strcpy ( szSub, "" );
return (szSub);
}
// Go past the '=' and 'space' character.
//
++sPtr;
++sPtr;
//Msg ( "sPtr = >>>%s<<<\n", sPtr );
// Find the , character, this is the end of the string.
//
ePtr = strchr ( Line, ',' );
if ( ePtr == NULL ) {
Msg ( "SuckSubName ERROR, couldn't find ',' character in string: %s\n", Line );
strcpy ( szSub, "" );
return (szSub);
}
// Copy the string.
do {
szSub[i] = *sPtr;
++i;
++sPtr;
} while ( sPtr < ePtr );
szSub[i] = '\0';
//Msg ( "szSub = >>>%s<<<\n\n", szSub );
return szSub;
}
void ShowX86 ( void ) {
int i;
for ( i = 0; i < ix386.wNumFiles; ++i ) {
Msg ( "%d %s Comp=%d CopyItToCD=%d\n",
i,
ix386.wcFilesArray[i],
ix386.bCopyComp[i],
ix386.bCopyItToCD[i] );
}
}
void ShowNec98 ( void ) {
int i;
for ( i = 0; i < Nec98.wNumFiles; ++i ) {
Msg ( "%d %s Comp=%d\n",
i,
Nec98.wcFilesArray[i],
Nec98.bCopyComp[i] );
}
}
void AddFileToX86 ( const char * fileName, BOOL bCopyComp, BOOL bTextMode, BOOL bCopyItToCD ) {
ix386.bCopyComp[ix386.wNumFiles] = bCopyComp;
ix386.bCountBytes[ix386.wNumFiles] = bGetSizeLater;
ix386.bTextMode[ix386.wNumFiles] = bTextMode;
ix386.bCopyItToCD[ix386.wNumFiles] = bCopyItToCD;
strcpy ( ix386.wcFilesArray[ix386.wNumFiles], fileName );
++ix386.wNumFiles;
if ( ix386.wNumFiles > MAX_NUMBER_OF_FILES_IN_PRODUCT ) {
Msg ( "FATAL ERROR: Increase MAX_NUM in Files.C\n" );
exit ( 1 );
}
}
void AddFileToNec98 ( const char * fileName, BOOL bCopyComp, BOOL bTextMode, BOOL bCopyItToCD ) {
Nec98.bCopyComp[Nec98.wNumFiles] = bCopyComp;
Nec98.bCountBytes[Nec98.wNumFiles] = bGetSizeLater;
Nec98.bTextMode[Nec98.wNumFiles] = bTextMode;
Nec98.bCopyItToCD[Nec98.wNumFiles] = bCopyItToCD;
strcpy ( Nec98.wcFilesArray[Nec98.wNumFiles], fileName );
++Nec98.wNumFiles;
if ( Nec98.wNumFiles > MAX_NUMBER_OF_FILES_IN_PRODUCT ) {
Msg ( "FATAL ERROR: Increase MAX_NUM in Files.C\n" );
exit ( 1 );
}
}
void CopyCompressedFile ( const char * Line ) {
const char * Ptr = Line;
DWORD i = 0;
#define COMP_FIELD 6
// Let's assume that we will compress the files and have to prove that we don't.
//
bCopyCompX86 = TRUE;
bCopyCompNec98 = TRUE;
while ( *Line != '\0' ) {
// If we are at the correct field,
// then stop counting fields.
//
if ( i == COMP_FIELD ) {
break;
}
// Found another field, increment our counter.
//
if ( *Line == ',' ) {
++i;
}
// Look at next char.
//
++Line;
}
if ( i != COMP_FIELD ) {
Msg ( "CopyCompressedFile ERROR: we are out of while loop, but didn't find the field >>> %s\n", Ptr );
}
// Determine if we should keep the file compressed or not.
//
switch ( *Line ) {
case '_' :
// Indicator that we do NOT want this file compressed.
//
bCopyCompX86 = FALSE;
bCopyCompNec98 = FALSE;
break;
case 'x' :
case 'X' :
case '1' :
case '2' :
case '3' :
case '4' :
// do nothing...
break;
case ',' :
// do nothing, there is nothing in the field, meaning get compressed files.
//
break;
default :
Msg ( "CopyCompressedFile ERROR: *Line default char >>%c<<\n", *Line );
}
}
#define X86_F 0
#define NEC98_F 4
#define DBGS_AND_NON_INSTALLED 6
// Verify that the files line in layout.inf has a file space
// associated with it, so if it ever used in optional components it
// will be added up.
//
void CheckSpace ( char * Line, char * Location, char * fileName ) {
char tLine[MFL];
int i, val;
char * sPtr = Line;
int numCommas = 0;
//Msg ( "CheckSpace: Line = %s", Line );
while ( 1 ) {
if ( *sPtr == ',' ) {
++numCommas;
}
if ( numCommas == 2 ) {
break;
}
++sPtr;
}
// At this point, we are pointing to the 2nd comma.
// So, let's go one char further.
//
++sPtr;
// Copy the string until we get to the next comma.
//
strcpy ( tLine, sPtr );
sPtr = tLine;
while ( 1 ) {
if ( *sPtr == ',' ) {
*sPtr = '\0';
break;
}
else {
++sPtr;
}
}
val = atoi ( tLine );
if ( val > 0 ) {
//Msg ( "val = %d >>> Line = %s", val, Line );
}
else {
if ( !strstr ( Line, "desktop.ini" ) ) {
Msg ( "CheckSpace ERROR - Tell build lab to run INFSIZE.EXE: location=%s, val = %d, Line = >>>%s<<<, fileName = %s\n", Location, val, Line, fileName );
}
}
}
void CheckLength ( char * Line ) {
if ( strlen ( Line ) > 12 ) {
Msg ( "ERROR CheckLength - file name is NOT an 8.3 DOS filename - tell the owner of this file to shorten it's filename length: %s\n", Line );
}
// Check for the optional . part.
//
// tbd
// Check for the optional 3 part.
//
// tbd
}
BOOL TextMode ( const char * fileName ) {
// Determine if this file has a 0 in the xth column which denotes
// it will be moved during textmode on a single partition scenario.
// If it has a 0, return TRUE to denote it gets moved on a fresh
// installed where ~ls is on the same partition that the %windir%
// will be on.
//
//const char * Ptr = Line;
DWORD i = 0;
BOOL b;
INFCONTEXT ic;
CHAR returnBuffer[MFL];
DWORD dwRequiredSize;
#define SDF "SourceDisksFiles"
#define SDF_X86 "SourceDisksFiles.x86"
#define TEXTMODE_FIELD 9
b = SetupFindFirstLine ( hInfLayout,
SDF,
fileName,
&ic );
if ( !b ) {
b = SetupFindFirstLine ( hInfLayout,
SDF_X86,
fileName,
&ic );
if ( !b ) {
if ( !strstr ( fileName, "usetup.exe" ) ) {
Msg ( "ERROR: TextMode: SetupFindFirstLine >>%s<< not found in SourceDiskFiles[.x86]\n", fileName, SDF );
return (FALSE);
}
}
}
else {
// Get the 9th field
//
b = SetupGetStringField ( &ic,
TEXTMODE_FIELD,
(LPSTR) &returnBuffer,
sizeof ( returnBuffer ),
&dwRequiredSize );
if ( !b ) {
Msg ( "ERROR: SetupGetStringField gle = %ld\n", GetLastError());
}
else {
if ( returnBuffer[0] == '0' ) {
Msg ( "file is copied during textmode: %s\n", fileName );
return (TRUE);
}
else {
Msg ( "file is NOT copied during textmode: %s\n", fileName );
return (FALSE);
}
}
}
return (FALSE);
// herehere
/****
Msg ( "4.1.hInfLayout = %ld\n", hInfLayout );
Msg ( "the Line:%s\n", Line );
while ( *Line != '\0' ) {
// If we are at the correct field,
// then stop counting fields.
//
if ( i == TEXTMODE_FIELD ) {
//++Line;
Msg ( "we are at the correct field, stop counting...\n" );
break;
}
// Found another field, increment our counter.
//
if ( *Line == ',' ) {
Msg ( "found another field, increment our counter...\n" );
++i;
}
// Look at next char.
//
++Line;
Msg ( "now pointing at:%s\n", Line );
}
Msg ( "we're at:%s\n", Line );
Msg ( "4.2hInfLayout = %ld\n", hInfLayout );
if ( i == TEXTMODE_FIELD ) {
if ( *Line == '0' ) {
Msg ( "TextMode: This file is copied during textmode: %s\n", Ptr );
return (TRUE);
}
else {
Msg ( "TextMode (*Line = %c): This file is NOT copied during textmode: %s\n", *Line, Ptr );
}
}
else {
Msg ( "TextMode Warning: we are out of while loop, but didn't find the field >>> %s\n", Ptr );
}
Msg ( "4.3hInfLayout = %ld\n", hInfLayout );
return (FALSE);
***/
}
void CheckSpaceAndLength ( char * Line, char * Location, char * fileName ) {
CheckSpace ( Line, Location, fileName );
//CheckLength ( Line );
}
void AddFiles ( char * fileName, DWORD dwPlatform, BOOL bCopyItToCD ) {
CHAR Line[MFL];
BOOL bTextMode = FALSE;
BOOL b;
DWORD dwRequiredSize;
INFCONTEXT ic;
bCopyCompX86 = FALSE;
bCopyCompNec98 = FALSE;
switch ( dwPlatform ) {
case X86_F :
Msg ( "AddToX86Files: %s\n", fileName );
// Get the entire string.
//
b = SetupGetLineText ( NULL,
hInfLayout,
SDF,
fileName,
(LPSTR) &Line,
sizeof ( Line ),
&dwRequiredSize );
if ( !b ) {
b = SetupGetLineText ( NULL,
hInfLayout,
SDF_X86,
fileName,
(LPSTR) &Line,
sizeof ( Line ),
&dwRequiredSize );
if ( !b ) {
if ( strstr ( fileName, "driver.cab" ) ||
strstr ( fileName, "drvindex.inf" ) ) {
goto AddX86;
}
Msg ( "ERROR: 1.SetupGetLineText not found in %s for %s, gle=%ld, dwRequiredSize = %ld\n", "SourceDisksFiles[.x86]", fileName, GetLastError(), dwRequiredSize );
break;
}
}
Msg ( "Line:>>%s<<\n", Line );
CheckSpaceAndLength ( Line, "x86", fileName );
CopyCompressedFile ( Line );
bTextMode = TextMode ( fileName );
AddX86:
CheckLength ( fileName );
AddFileToX86 ( fileName, bCopyCompX86, bTextMode, bCopyItToCD );
break;
case NEC98_F :
Msg ( "AddToNecFiles: %s\n", fileName );
// Get the entire string.
//
b = SetupGetLineText ( NULL,
hInfLayout,
SDF,
fileName,
(LPSTR) &Line,
sizeof ( Line ),
&dwRequiredSize );
if ( !b ) {
b = SetupGetLineText ( NULL,
hInfLayout,
SDF_X86,
fileName,
(LPSTR) &Line,
sizeof ( Line ),
&dwRequiredSize );
if ( !b ) {
if ( strstr ( fileName, "driver.cab" ) ||
strstr ( fileName, "drvindex.inf" ) ) {
goto AddNec98;
}
Msg ( "ERROR: 3.SetupGetLineText not found in %s for %s, gle=%ld, dwRequiredSize = %ld\n", "SourceDisksFiles[.x86]", fileName, GetLastError(), dwRequiredSize );
break;
}
}
Msg ( "Line:>>%s<<\n", Line );
CheckSpaceAndLength ( Line, "nec", fileName );
CopyCompressedFile ( Line );
bTextMode = TextMode ( fileName );
AddNec98:;
CheckLength ( fileName );
AddFileToNec98 ( fileName, bCopyCompNec98, bTextMode, bCopyItToCD );
break;
default :
Msg ( "ERROR: AddFiles - uknown platform %ld\n", dwPlatform );
}
}
BOOL PlatformFilesToCopy ( char * szInfPath, DWORD dwPlatform ) {
CHAR infFilePath[MFL];
BOOL b;
DWORD dwRequiredSize;
INFCONTEXT ic;
CHAR returnBuffer[MAX_PATH];
#define FILES_SECTION "Files"
#define FILES_SECTION_DRIVER "driver"
Msg ( "\n\n\n" );
Msg ( "PlatformFilesToCopy: szInfPath = %s, dwPlatform = %ld\n", szInfPath, dwPlatform );
// Open up a handle to dosnet.inf
//
sprintf ( infFilePath, "%s\\%s", szInfPath, "dosnet.inf" );
Msg ( "infFilePath = %s\n", infFilePath );
hInfDosnet = SetupOpenInfFile ( infFilePath, NULL, INF_STYLE_WIN4, NULL );
if ( hInfDosnet == INVALID_HANDLE_VALUE ) {
Msg ( "FATAL ERROR: could not open INF: %s, gle = %ld\n", infFilePath, GetLastError() );
exit ( GetLastError() );
}
Msg ( "hInfDosnet = %ld\n", hInfDosnet );
// Open up a handle to layout.inf
//
sprintf ( infFilePath, "%s\\%s", szInfPath, "layout.inf" );
Msg ( "infFilePath = %s\n", infFilePath );
hInfLayout = SetupOpenInfFile ( infFilePath, NULL, INF_STYLE_WIN4, NULL );
if ( hInfLayout == INVALID_HANDLE_VALUE ) {
Msg ( "FATAL ERROR: could not open INF: %s, gle = %ld\n", infFilePath, GetLastError() );
exit ( GetLastError() );
}
Msg ( "hInfLayout = %ld\n", hInfLayout );
// Open up a handle to drvindex.inf
//
sprintf ( infFilePath, "%s\\%s", szInfPath, "drvindex.inf" );
Msg ( "infFilePath = %s\n", infFilePath );
hInfDrvIndex = SetupOpenInfFile ( infFilePath, NULL, INF_STYLE_WIN4, NULL );
if ( hInfDrvIndex == INVALID_HANDLE_VALUE ) {
Msg ( "FATAL ERROR: could not open INF: %s, gle = %ld\n", infFilePath, GetLastError() );
exit ( GetLastError () );
}
Msg ( "hInfDrvIndex = %ld\n", hInfDrvIndex );
// Get the files listed in dosnet.inf to copy to the CD.
// Denote them to be copied to the CD by specifying TRUE to AddFiles().
//
b = SetupFindFirstLine ( hInfDosnet,
FILES_SECTION,
NULL,
&ic );
if ( !b ) {
Msg ( "ERROR: SetupFindFirstLine not found in %s\n", FILES_SECTION );
}
else {
// Get the 2nd field, ie. the filename, such as in d1,ntkrnlmp.exe
//
b = SetupGetStringField ( &ic,
2,
(LPSTR) &returnBuffer,
sizeof ( returnBuffer ),
&dwRequiredSize );
if ( !b ) {
Msg ( "ERROR: SetupGetStringField gle = %ld\n", GetLastError());
}
else {
AddFiles ( returnBuffer, dwPlatform, TRUE );
}
while ( 1 ) {
// Get the next line in the section.
//
b = SetupFindNextLine ( &ic,
&ic );
if ( !b ) {
// Denotes that there is NOT another line.
//
Msg ( "no more files in section...\n" );
break;
}
else {
// Get the 2nd field's filename,
// such as in d1,ntoskrnl.exe.
//
b = SetupGetStringField ( &ic,
2,
(LPSTR) &returnBuffer,
sizeof ( returnBuffer ),
&dwRequiredSize );
if ( !b ) {
Msg ( "ERROR: SetupGetStringField gle = %ld\n", GetLastError());
}
else {
AddFiles ( returnBuffer, dwPlatform, TRUE );
}
}
}
}
// Get the files listed in drvindex.inf to later calculate disk space.
// Denote them NOT to be copied to the CD by specifying FALSE to AddFiles().
//
b = SetupFindFirstLine ( hInfDrvIndex,
FILES_SECTION_DRIVER,
NULL,
&ic );
if ( !b ) {
Msg ( "ERROR: SetupFindFirstLine not found in %s\n", FILES_SECTION_DRIVER );
}
else {
// Get the 1st field, ie. the filename, such as changer.sys.
//
b = SetupGetStringField ( &ic,
1,
(LPSTR) &returnBuffer,
sizeof ( returnBuffer ),
&dwRequiredSize );
if ( !b ) {
Msg ( "ERROR: SetupGetStringField gle = %ld\n", GetLastError());
}
else {
Msg ( "found -> %s\n", returnBuffer );
AddFiles ( returnBuffer, dwPlatform, FALSE );
}
while ( 1 ) {
// Get the next line in the section.
//
b = SetupFindNextLine ( &ic,
&ic );
if ( !b ) {
// Denotes that there is NOT another line.
//
Msg ( "no more files in section...\n" );
break;
}
else {
// Get the 1st field's filename,
// such as in changer.sys.
//
b = SetupGetStringField ( &ic,
1,
(LPSTR) &returnBuffer,
sizeof ( returnBuffer ),
&dwRequiredSize );
if ( !b ) {
Msg ( "ERROR: SetupGetStringField gle = %ld\n", GetLastError());
}
else {
Msg ( "found -> %s\n", returnBuffer );
AddFiles ( returnBuffer, dwPlatform, FALSE );
}
}
}
}
// Close all the inf handles.
//
SetupCloseInfFile ( hInfDosnet );
SetupCloseInfFile ( hInfLayout );
SetupCloseInfFile ( hInfDrvIndex );
return (TRUE);
}
BOOL GetTheFiles ( char * DosnetInfPath, char * dosnetFile, int AddToList ) {
CHAR infFilePath[MFL];
DWORD dwErrorLine;
BOOL b;
char dstDirectory[MFL];
FILE * fHandle;
char Line[MFL];
HANDLE hDosnetInf;
// Open the inx file for processing.
//
sprintf ( infFilePath, "%s\\%s", DosnetInfPath, dosnetFile );
Msg ( "infFilePath = %s\n", infFilePath );
fHandle = fopen ( infFilePath, "rt" );
if ( fHandle ) {
Msg ( "dwInsideSection = %x\n", dwInsideSection );
while ( fgets ( Line, sizeof(Line), fHandle ) ) {
int i;
char * p = Line;
int iCommas;
BOOL bTextMode = FALSE;
Msg ( "Line: %s\n", Line );
if ( Line[0] == '[' ) {
// We may have a new section.
//
dwInsideSection = FigureSection ( Line );
continue;
}
// Reasons to ignore this line from further processing.
//
//
// File section not one we process.
//
if ( dwInsideSection == FILE_SECTION_NOT_USED ) {
continue;
}
// Line just contains a non-usefull short string.
//
i = strlen ( Line );
if ( i < 4 ) {
continue;
}
// Line contains just a comment.
//
if ( Line[0] == ';' ) {
continue;
}
// There are not enough commas in the line.
//
iCommas = 0;
while ( 1 ) {
if ( *p == '\0' ) {
break;
}
if ( *p == ',' ) {
++iCommas;
}
++p;
}
if ( iCommas < 5 ) {
Msg ( "ERROR - there are not enough commas in the line: %s\n", Line );
continue;
}
switch ( AddToList ) {
case DBGS_AND_NON_INSTALLED :
CheckLength ( SuckName(Line) );
bCopyCompX86 = FALSE;
bCopyCompNec98 = FALSE;
bTextMode = FALSE;
if ( dwInsideSection == idBase ) {
CopyCompressedFile ( Line );
AddFileToX86 ( SuckName(Line), bCopyCompX86, bTextMode, TRUE );
if ( bNec98 ) {
AddFileToNec98 ( SuckName(Line), bCopyCompNec98, bTextMode, TRUE );
}
break;
}
if ( dwInsideSection == idX86 ) {
CopyCompressedFile ( Line );
AddFileToX86 ( SuckName(Line), bCopyCompX86, bTextMode, TRUE );
if ( bNec98 ) {
AddFileToNec98 ( SuckName(Line), bCopyCompNec98, bTextMode, TRUE );
}
break;
}
break;
default :
Msg ( "ERROR: AddToList = %d\n", AddToList );
}
}
if ( ferror(fHandle) ) {
Msg ( "ERROR fgets reading from file...\n" );
}
}
else {
Msg ( "fopen ERROR %s\n", infFilePath );
return (FALSE);
}
fclose ( fHandle );
return (TRUE);
}
void ShowFreshLocalSpace ( char * fileName, DWORD dwFresh, DWORD dwLocal ) {
Msg ( "processing: %s freshBytes->K32 = %ld, localSrcBytes->K32 = %ld\n",
fileName, dwFresh, dwLocal );
}
//
// textModeBytes is used to subtract out the bytes not really
// needed to be counted by setup for a 1 partition move of the files.
//
void TallyInstalled ( char * szUncompPath, char * szCompPath,
struct _tag * tagStruct,
// DWORD * numBytes,
struct _ClusterSizes * freshBytes,
struct _ClusterSizes * localSrcBytes,
struct _ClusterSizes * textModeBytes ) {
int i;
char szCompressedName[MFL];
char szPath[MFL];
//*numBytes = 0;
#define _h1K 512
#define _1K 1*1024
#define _2K 2*1024
#define _4K 4*1024
#define _8K 8*1024
#define _16K 16*1024
#define _32K 32*1024
#define _64K 64*1024
#define _128K 128*1024
#define _256K 256*1024
freshBytes->Kh1 = 0;
freshBytes->K1 = 0;
freshBytes->K2 = 0;
freshBytes->K4 = 0;
freshBytes->K8 = 0;
freshBytes->K16 = 0;
freshBytes->K32 = 0;
freshBytes->K64 = 0;
freshBytes->K128 = 0;
freshBytes->K256 = 0;
localSrcBytes->Kh1 = 0;
localSrcBytes->K1 = 0;
localSrcBytes->K2 = 0;
localSrcBytes->K4 = 0;
localSrcBytes->K8 = 0;
localSrcBytes->K16 = 0;
localSrcBytes->K32 = 0;
localSrcBytes->K64 = 0;
localSrcBytes->K128 = 0;
localSrcBytes->K256 = 0;
textModeBytes->Kh1 = 0;
textModeBytes->K1 = 0;
textModeBytes->K2 = 0;
textModeBytes->K4 = 0;
textModeBytes->K8 = 0;
textModeBytes->K16 = 0;
textModeBytes->K32 = 0;
textModeBytes->K64 = 0;
textModeBytes->K128 = 0;
textModeBytes->K256 = 0;
for ( i = 0; i < tagStruct->wNumFiles; ++i ) {
WIN32_FIND_DATA wfd;
HANDLE hFind;
// Don't add in space requirements for files in media.inx, since
// these files are NEVER installed.
//
if ( !tagStruct->bCountBytes[i] ) {
Msg ( "Warning: not going to count bytes for: %s\n", tagStruct->wcFilesArray[i] );
continue;
}
sprintf ( szPath, "%s\\%s", szUncompPath, tagStruct->wcFilesArray[i] );
// Need to find out space for .cab files contents.
//
if ( strstr ( szPath, ".cab" ) ||
strstr ( szPath, ".CAB" ) ) {
Msg ( "JOEHOL >>> get .cab contents filesizes for: %s\n", szPath );
}
// Calculate the installed system space required.
// This is the stuff installed into the %SYSTEMDIR% and all the other stuff
// uncompressed on the harddrive.
// This value will include the driver.cab, plus all the other files, since we
// assume worst case scenario.
//
hFind = FindFirstFile ( szPath, &wfd );
if ( hFind == INVALID_HANDLE_VALUE ) {
if ( strstr ( szPath, "desktop.ini" ) ||
strstr ( szPath, "DESKTOP.INI" ) ) {
// Build lab sometimes doesn't put the uncompressed
// file on the release shares, say the file is 512 bytes.
//
#define MAX_SETUP_CLUSTER_SIZE 32*1024
//*numBytes += ROUNDUP2 ( 512, MAX_SETUP_CLUSTER_SIZE );
freshBytes->Kh1 += ROUNDUP2 ( 512, _h1K );
freshBytes->K1 += ROUNDUP2 ( 512, _1K );
freshBytes->K2 += ROUNDUP2 ( 512, _2K );
freshBytes->K4 += ROUNDUP2 ( 512, _4K );
freshBytes->K8 += ROUNDUP2 ( 512, _8K );
freshBytes->K16 += ROUNDUP2 ( 512, _16K );
freshBytes->K32 += ROUNDUP2 ( 512, _32K );
freshBytes->K64 += ROUNDUP2 ( 512, _64K );
freshBytes->K128+= ROUNDUP2 ( 512, _128K );
freshBytes->K256+= ROUNDUP2 ( 512, _256K );
}
else
if ( strstr ( szPath, "WINNT32.EXE" ) ||
strstr ( szPath, "winnt32.exe" ) ||
strstr ( szPath, "winnt32a.dll" ) ||
strstr ( szPath, "winnt32u.dll" ) ||
strstr ( szPath, "WINNT32A.DLL" ) ||
strstr ( szPath, "WINNT32U.DLL" ) ||
strstr ( szPath, "WINNT32.HLP" ) ||
strstr ( szPath, "winnt32.hlp" ) ) {
char tmpSrcPath[MFL];
strcpy ( tmpSrcPath, szPath );
if ( strstr ( tmpSrcPath, ".HLP" ) ||
strstr ( tmpSrcPath, ".hlp" ) ) {
strcpy ( &tmpSrcPath[ strlen(tmpSrcPath) - 4 ], "\\WINNT32.HLP" );
}
else if ( strstr ( tmpSrcPath, "a.dll" ) ||
strstr ( tmpSrcPath, "A.DLL" ) ) {
strcpy ( &tmpSrcPath[ strlen(tmpSrcPath) - 5 ], "\\WINNT32a.dll" );
}
else if ( strstr ( tmpSrcPath, "u.dll" ) ||
strstr ( tmpSrcPath, "U.DLL" ) ) {
strcpy ( &tmpSrcPath[ strlen(tmpSrcPath) - 5 ], "\\WINNT32u.dll" );
}
else {
strcpy ( &tmpSrcPath[ strlen(tmpSrcPath) - 4 ], "\\WINNT32.EXE" );
}
hFind = FindFirstFile ( tmpSrcPath, &wfd );
if ( hFind == INVALID_HANDLE_VALUE ) {
Msg ( "ERROR Tally: FindFirstFile %s(%s), gle = %ld\n", szPath, tmpSrcPath, GetLastError() );
}
}
else {
Msg ( "ERROR Tally: FindFirstFile %s, gle = %ld\n", szPath, GetLastError() );
}
}
else {
// NOTE: .PNF files are made by the PNP system
// during Gui-mode setup, and are NOT listed anywhere.
// These files are compiled inf files.
// They are generally 2-3 times
// bigger than their associated .INF file.
// So, if we see and .INF file, increase it's size by
// 3 times. We need to do this, because in a low disk
// space situation, a .PNF file could be made and take
// up all the space.
//
if ( strstr ( szPath, ".INF" ) ||
strstr ( szPath, ".inf" ) ) {
wfd.nFileSizeLow *= 3;
Msg ( "Warning .PNF - %d\n %s\n", wfd.nFileSizeLow, szPath );
}
//*numBytes += ROUNDUP2 ( wfd.nFileSizeLow, MAX_SETUP_CLUSTER_SIZE );
freshBytes->Kh1 += ROUNDUP2 ( wfd.nFileSizeLow, _h1K );
freshBytes->K1 += ROUNDUP2 ( wfd.nFileSizeLow, _1K );
freshBytes->K2 += ROUNDUP2 ( wfd.nFileSizeLow, _2K );
freshBytes->K4 += ROUNDUP2 ( wfd.nFileSizeLow, _4K );
freshBytes->K8 += ROUNDUP2 ( wfd.nFileSizeLow, _8K );
freshBytes->K16 += ROUNDUP2 ( wfd.nFileSizeLow, _16K );
freshBytes->K32 += ROUNDUP2 ( wfd.nFileSizeLow, _32K );
freshBytes->K64 += ROUNDUP2 ( wfd.nFileSizeLow, _64K );
freshBytes->K128+= ROUNDUP2 ( wfd.nFileSizeLow, _128K );
freshBytes->K256+= ROUNDUP2 ( wfd.nFileSizeLow, _256K );
FindClose ( hFind );
//Msg ( "%s = %ld\n", szPath, *numBytes );
}
// Calculate the local space required.
//
//
// NOTE: If we don't copy this file to the CD, ie. it is in the driver.cab
// file, then we don't need to add it's space into the values here,
// since once counted for the driver.cab file itself is OK.
//
if ( !tagStruct->bCopyItToCD[i] ) {
Msg ( "Already in CAB file, won't add in space for local source: %s\n",
tagStruct->wcFilesArray[i] );
continue;
}
if ( tagStruct->bCopyComp[i] ) {
char szCompressedName[MFL];
MakeCompName ( tagStruct->wcFilesArray[i], szCompressedName );
sprintf ( szPath, "%s\\%s", szCompPath, szCompressedName );
}
else {
sprintf ( szPath, "%s\\%s", szUncompPath, tagStruct->wcFilesArray[i] );
}
hFind = FindFirstFile ( szPath, &wfd );
if ( hFind == INVALID_HANDLE_VALUE ) {
if ( strstr ( szPath, "WINNT32.EXE" ) ||
strstr ( szPath, "winnt32.exe" ) ||
strstr ( szPath, "winnt32a.dll" ) ||
strstr ( szPath, "winnt32u.dll" ) ||
strstr ( szPath, "WINNT32A.DLL" ) ||
strstr ( szPath, "WINNT32U.DLL" ) ||
strstr ( szPath, "WINNT32.HLP" ) ||
strstr ( szPath, "winnt32.hlp" ) ) {
char tmpSrcPath[MFL];
strcpy ( tmpSrcPath, szPath );
if ( strstr ( tmpSrcPath, ".HLP" ) ||
strstr ( tmpSrcPath, ".hlp" ) ) {
strcpy ( &tmpSrcPath[ strlen(tmpSrcPath) - 4 ], "\\WINNT32.HLP" );
}
else if ( strstr ( tmpSrcPath, "a.dll" ) ||
strstr ( tmpSrcPath, "A.DLL" ) ) {
strcpy ( &tmpSrcPath[ strlen(tmpSrcPath) - 5 ], "\\WINNT32a.dll" );
}
else if ( strstr ( tmpSrcPath, "u.dll" ) ||
strstr ( tmpSrcPath, "U.DLL" ) ) {
strcpy ( &tmpSrcPath[ strlen(tmpSrcPath) - 5 ], "\\WINNT32u.dll" );
}
else {
strcpy ( &tmpSrcPath[ strlen(tmpSrcPath) - 4 ], "\\WINNT32.EXE" );
}
hFind = FindFirstFile ( tmpSrcPath, &wfd );
if ( hFind == INVALID_HANDLE_VALUE ) {
Msg ( "ERROR Tally: FindFirstFile %s(%s), gle = %ld\n", szPath, tmpSrcPath, GetLastError() );
}
}
else {
Msg ( "ERROR Tally: FindFirstFile %s, gle = %ld\n", szPath, GetLastError() );
}
}
else {
// For each cluster size, add in the files bytes
// used in the ~ls directory.
//
localSrcBytes->Kh1 += ROUNDUP2 ( wfd.nFileSizeLow, _h1K );
localSrcBytes->K1 += ROUNDUP2 ( wfd.nFileSizeLow, _1K );
localSrcBytes->K2 += ROUNDUP2 ( wfd.nFileSizeLow, _2K );
localSrcBytes->K4 += ROUNDUP2 ( wfd.nFileSizeLow, _4K );
localSrcBytes->K8 += ROUNDUP2 ( wfd.nFileSizeLow, _8K );
localSrcBytes->K16 += ROUNDUP2 ( wfd.nFileSizeLow, _16K );
localSrcBytes->K32 += ROUNDUP2 ( wfd.nFileSizeLow, _32K );
localSrcBytes->K64 += ROUNDUP2 ( wfd.nFileSizeLow, _64K );
localSrcBytes->K128+= ROUNDUP2 ( wfd.nFileSizeLow, _128K );
localSrcBytes->K256+= ROUNDUP2 ( wfd.nFileSizeLow, _256K );
//Msg ( "localSrc32: %s, size=%ld, roundupsize=%ld, total32K=%ld\n", szPath, wfd.nFileSizeLow, ROUNDUP2(wfd.nFileSizeLow,_32K),localSrcBytes->K32 );
/***
if (hack){
char buf[MFL];
sprintf ( buf, "copy %s d:\\myLS", szPath );
Msg ( "thecopy: %s\n", buf );
system ( buf );
}
***/
FindClose ( hFind );
// For the special marketing calculation number, if a
// file for a single partition installation using the ~ls
// directory, add in the file's bytes that will actually
// turn into free disk space.
//
if ( tagStruct->bTextMode[i] ) {
textModeBytes->Kh1 += ROUNDUP2 ( wfd.nFileSizeLow, _h1K );
textModeBytes->K1 += ROUNDUP2 ( wfd.nFileSizeLow, _1K );
textModeBytes->K2 += ROUNDUP2 ( wfd.nFileSizeLow, _2K );
textModeBytes->K4 += ROUNDUP2 ( wfd.nFileSizeLow, _4K );
textModeBytes->K8 += ROUNDUP2 ( wfd.nFileSizeLow, _8K );
textModeBytes->K16 += ROUNDUP2 ( wfd.nFileSizeLow, _16K );
textModeBytes->K32 += ROUNDUP2 ( wfd.nFileSizeLow, _32K );
textModeBytes->K64 += ROUNDUP2 ( wfd.nFileSizeLow, _64K );
textModeBytes->K128+= ROUNDUP2 ( wfd.nFileSizeLow, _128K );
textModeBytes->K256+= ROUNDUP2 ( wfd.nFileSizeLow, _256K );
//Msg ( "tagStruct->bTextMode TRUE for: %s, %ld\n", tagStruct->wcFilesArray[i], textModeBytes->K32 );
}
else {
//Msg ( "tagStruct->bTextMode FALSE for: %s\n", tagStruct->wcFilesArray[i]);
}
}
// ShowFreshLocalSpace ( tagStruct->wcFilesArray[i], freshBytes->K32, localSrcBytes->K32 );
}
}
DWORD GetTheSize ( const char * szPath, const char * szKey ) {
FILE * fHandle;
char Line[MFL];
Msg ( "GetTheSize: szPath = %s\n", szPath );
fHandle = fopen ( szPath, "rt" );
if ( fHandle ) {
while ( fgets ( Line, sizeof(Line), fHandle ) ) {
if ( strncmp ( Line, szKey, strlen(szKey)-1 ) == 0 ) {
char * LinePtr = Line;
Msg ( "key Line: %s\n", Line );
// First, find the equal sign.
//
LinePtr = strstr ( Line, "=" );
// Now, find the first character that is a number.
//
while ( isdigit(*LinePtr) == 0 ) {
++LinePtr;
}
Msg ( "# = %s\n", LinePtr );
fclose ( fHandle );
return ( atoi ( LinePtr ) );
}
}
Msg ( "GetTheSize: Couldn't find key: %s\n", szKey );
fclose ( fHandle );
}
else {
Msg ( "GetTheSize: Couldn't fopen (%s)\n", szPath );
}
return 0;
}
void ShowCheckFreshSpace ( struct _ClusterSizes * Section, char * String, char * netServer ) {
DWORD dwSize = 0;
#define OHPROBLEM "problem"
char returnedString[MFL];
#define SD "DiskSpaceRequirements"
char sifFile[MFL];
char rS512[MFL];
char rS1[MFL];
char rS2[MFL];
char rS4[MFL];
char rS8[MFL];
char rS16[MFL];
char rS32[MFL];
char rS64[MFL];
char rS128[MFL];
char rS256[MFL];
ULONG dwSize512;
ULONG dwSize1;
ULONG dwSize2;
ULONG dwSize4;
ULONG dwSize8;
ULONG dwSize16;
ULONG dwSize32;
ULONG dwSize64;
ULONG dwSize128;
ULONG dwSize256;
sprintf ( sifFile, "%s\\txtsetup.sif", netServer );
Msg ( "TxtSetup.Sif location: %s\n", sifFile );
Msg ( "Clyde: SPACE REQUIRED TO DO A FRESH INSTALL.\n" );
Msg ( "Clyde:\n" );
Msg ( "Clyde: %s 512 Cluster = %ld\n", String, Section->Kh1 );
Msg ( "Clyde: %s 1K Cluster = %ld\n", String, Section->K1 );
Msg ( "Clyde: %s 2K Cluster = %ld\n", String, Section->K2 );
Msg ( "Clyde: %s 4K Cluster = %ld\n", String, Section->K4 );
Msg ( "Clyde: %s 8K Cluster = %ld\n", String, Section->K8 );
Msg ( "Clyde: %s 16K Cluster = %ld\n", String, Section->K16 );
Msg ( "Clyde: %s 32K Cluster = %ld\n", String, Section->K32 );
Msg ( "Clyde: %s 64K Cluster = %ld\n", String, Section->K64 );
Msg ( "Clyde: %s 128K Cluster = %ld\n", String, Section->K128 );
Msg ( "Clyde: %s 256K Cluster = %ld\n", String, Section->K256 );
Msg ( "Clyde:\n" );
#define FUDGE_PLUS 4*1024*1024 // ie, grow by 4 M for future growth.
GetPrivateProfileString ( SD, "WinDirSpace512", "0", rS512, MFL, sifFile );
GetPrivateProfileString ( SD, "WinDirSpace1K", "0", rS1, MFL, sifFile );
GetPrivateProfileString ( SD, "WinDirSpace2K", "0", rS2, MFL, sifFile );
GetPrivateProfileString ( SD, "WinDirSpace4K", "0", rS4, MFL, sifFile );
GetPrivateProfileString ( SD, "WinDirSpace8K", "0", rS8, MFL, sifFile );
GetPrivateProfileString ( SD, "WinDirSpace16K", "0", rS16, MFL, sifFile );
GetPrivateProfileString ( SD, "WinDirSpace32K", "0", rS32, MFL, sifFile );
GetPrivateProfileString ( SD, "WinDirSpace64K", "0", rS64, MFL, sifFile );
GetPrivateProfileString ( SD, "WinDirSpace128K","0", rS128, MFL, sifFile );
GetPrivateProfileString ( SD, "WinDirSpace256K","0", rS256, MFL, sifFile );
dwSize512 = atoi ( rS512 ) * 1024;
dwSize1 = atoi ( rS1 ) * 1024;
dwSize2 = atoi ( rS2 ) * 1024;
dwSize4 = atoi ( rS4 ) * 1024;
dwSize8 = atoi ( rS8 ) * 1024;
dwSize16 = atoi ( rS16 ) * 1024;
dwSize32 = atoi ( rS32 ) * 1024;
dwSize64 = atoi ( rS64 ) * 1024;
dwSize128 = atoi ( rS128) * 1024;
dwSize256 = atoi ( rS256) * 1024;
if ( Section->Kh1 > dwSize512 ) {
Msg ( "matth ERROR: %s txtsetup.sif's WinDirSpace512 value is %ld Use: %ld\n", String, dwSize512, (Section->Kh1 + FUDGE_PLUS) / 1024 );
}
if ( Section->K1 > dwSize1 ) {
Msg ( "matth ERROR: %s txtsetup.sif's WinDirSpace1K value is %ld Use: %ld\n", String, dwSize1, (Section->K1 + FUDGE_PLUS) / 1024 );
}
if ( Section->K2 > dwSize2 ) {
Msg ( "matth ERROR: %s txtsetup.sif's WinDirSpace2K value is %ld Use: %ld\n", String, dwSize2, (Section->K2 + FUDGE_PLUS) / 1024 );
}
if ( Section->K4 > dwSize4 ) {
Msg ( "matth ERROR: %s txtsetup.sif's WinDirSpace4K value is %ld Use: %ld\n", String, dwSize4, (Section->K4 + FUDGE_PLUS) / 1024 );
}
if ( Section->K8 > dwSize8 ) {
Msg ( "matth ERROR: %s txtsetup.sif's WinDirSpace8K value is %ld Use: %ld\n", String, dwSize8, (Section->K8 + FUDGE_PLUS) / 1024 );
}
if ( Section->K16 > dwSize16 ) {
Msg ( "matth ERROR: %s txtsetup.sif's WinDirSpace16K value is %ld Use: %ld\n", String, dwSize16, (Section->K16 + FUDGE_PLUS) / 1024 );
}
if ( Section->K32 > dwSize32 ) {
Msg ( "matth ERROR: %s txtsetup.sif's WinDirSpace32K value is %ld Use: %ld\n", String, dwSize32, (Section->K32 + FUDGE_PLUS) / 1024 );
}
if ( Section->K64 > dwSize64 ) {
Msg ( "matth ERROR: %s txtsetup.sif's WinDirSpace64K value is %ld Use: %ld\n", String, dwSize64, (Section->K64 + FUDGE_PLUS) / 1024 );
}
if ( Section->K128 > dwSize128 ) {
Msg ( "matth ERROR: %s txtsetup.sif's WinDirSpace128K value is %ld Use: %ld\n", String, dwSize128, (Section->K128 + FUDGE_PLUS) / 1024 );
}
if ( Section->K256 > dwSize256 ) {
Msg ( "matth ERROR: %s txtsetup.sif's WinDirSpace256K value is %ld Use: %ld\n", String, dwSize256, (Section->K256 + FUDGE_PLUS) / 1024 );
}
}
void EnoughTempDirSpace ( char * Key, DWORD dwSpaceNeeded, char * String, char * dosnetFile ) {
DWORD dwSize = 0;
#define OHPROBLEM "problem"
#define SP "DiskSpaceRequirements"
char returnedString[MFL];
GetPrivateProfileString ( SP, Key, OHPROBLEM, returnedString, MFL, dosnetFile );
if ( strncmp ( returnedString, OHPROBLEM, sizeof ( OHPROBLEM ) ) == 0 ) {
Msg ( "ERROR: %d section not found\n", Key );
}
dwSize = atoi ( returnedString );
if ( dwSpaceNeeded > dwSize ) {
Msg ( "matth ERROR: %s dosnet.inf's %s value is %ld Use: %ld\n", String, Key, dwSize, dwSpaceNeeded + FUDGE_PLUS );
}
if ( dwSpaceNeeded+FUDGE_PLUS < dwSize ) {
Msg ( "matth ERROR - let's optimize(reduce)!: %s dosnet.inf's %s value is %ld Use: %ld\n", String, Key, dwSize, dwSpaceNeeded + FUDGE_PLUS );
}
}
void ShowCheckLocalSpace ( struct _ClusterSizes * Section, char * String, char * netServer ) {
char dosnetFile[MFL];
sprintf ( dosnetFile, "%s\\dosnet.inf", netServer );
Msg ( "Dosnet.Inf location: %s\n", dosnetFile );
Msg ( "Clyde: SPACE REQUIRED TO COPY FILES TO LOCAL DRIVE FROM CD.\n" );
Msg ( "Clyde:\n" );
Msg ( "Clyde: %s 512 Cluster = %ld\n", String, (8*1024*1024) );
Msg ( "Clyde: %s 1K Cluster = %ld\n", String, (8*1024*1024) );
Msg ( "Clyde: %s 2K Cluster = %ld\n", String, (8*1024*1024) );
Msg ( "Clyde: %s 4K Cluster = %ld\n", String, (8*1024*1024) );
Msg ( "Clyde: %s 8K Cluster = %ld\n", String, (8*1024*1024) );
Msg ( "Clyde: %s 16K Cluster = %ld\n", String, (8*1024*1024) );
Msg ( "Clyde: %s 32K Cluster = %ld\n", String, (8*1024*1024) );
Msg ( "Clyde: %s 64K Cluster = %ld\n", String, (8*1024*1024) ) ;
Msg ( "Clyde: %s 128K Cluster = %ld\n", String, (8*1024*1024) );
Msg ( "Clyde: %s 256K Cluster = %ld\n", String, (8*1024*1024) );
Msg ( "Clyde:\n" );
Msg ( "Clyde: SPACE REQUIRED TO COPY FILES TO LOCAL DRIVE FROM NETWORK.\n" );
Msg ( "Clyde:\n" );
// Note: this 8*1024*1024 is the ~bt space - 8M is average today.
// But, to be more accurate we could get the value from the inf.
//
Msg ( "Clyde: %s 512 Cluster = %ld\n", String, Section->Kh1+(8*1024*1024) );
Msg ( "Clyde: %s 1K Cluster = %ld\n", String, Section->K1+(8*1024*1024) );
Msg ( "Clyde: %s 2K Cluster = %ld\n", String, Section->K2+(8*1024*1024) );
Msg ( "Clyde: %s 4K Cluster = %ld\n", String, Section->K4+(8*1024*1024) );
Msg ( "Clyde: %s 8K Cluster = %ld\n", String, Section->K8+(8*1024*1024) );
Msg ( "Clyde: %s 16K Cluster = %ld\n", String, Section->K16+(8*1024*1024) );
Msg ( "Clyde: %s 32K Cluster = %ld\n", String, Section->K32+(8*1024*1024) );
Msg ( "Clyde: %s 64K Cluster = %ld\n", String, Section->K64+(8*1024*1024) ) ;
Msg ( "Clyde: %s 128K Cluster = %ld\n", String, Section->K128+(8*1024*1024) );
Msg ( "Clyde: %s 256K Cluster = %ld\n", String, Section->K256+(8*1024*1024) );
Msg ( "Clyde:\n" );
EnoughTempDirSpace ( "TempDirSpace512", Section->Kh1, String, dosnetFile );
EnoughTempDirSpace ( "TempDirSpace1K", Section->K1, String, dosnetFile );
EnoughTempDirSpace ( "TempDirSpace2K", Section->K2, String, dosnetFile );
EnoughTempDirSpace ( "TempDirSpace4K", Section->K4, String, dosnetFile );
EnoughTempDirSpace ( "TempDirSpace8K", Section->K8, String, dosnetFile );
EnoughTempDirSpace ( "TempDirSpace16K", Section->K16, String, dosnetFile );
EnoughTempDirSpace ( "TempDirSpace32K", Section->K32, String, dosnetFile );
EnoughTempDirSpace ( "TempDirSpace64K", Section->K64, String, dosnetFile );
EnoughTempDirSpace ( "TempDirSpace128K",Section->K128,String, dosnetFile );
EnoughTempDirSpace ( "TempDirSpace256K",Section->K256,String, dosnetFile );
}
void ClydeR ( char * String, char * desString, DWORD dwFresh, DWORD dwLocal, DWORD dwTextMode ) {
DWORD dwPageFile = 0;
DWORD dwLocalSource = 0;
DWORD dwFreshInstall = 0;
DWORD dwTextModeSavings = 0;
DWORD dwTotal = 0;
DWORD dwLocalBoot = 0;
#define LOCAL_BOOT 8*1024*1024
DWORD dwMigrationDlls = 0;
DWORD MigrationDllsK32 = 24*1024*1024; // as of 12.11.98
DWORD dwOsSizeDiff = 0;
DWORD dwCacheDelete = 0;
Msg ( "Clyde: %s Scenario 1 - Fresh install using CD (CD-boot or with floppies) on a blank machine on a 1 partition %s cluster drive.\n", String, desString );
dwPageFile = (64+11) * 1024 * 1024;
dwFreshInstall = dwFresh;
dwTotal = dwPageFile + dwFreshInstall;
Msg ( "Clyde: Pagefile for 64M RAM = %ld\n", dwPageFile );
Msg ( "Clyde: Fresh install = %ld\n", dwFreshInstall );
Msg ( "Clyde: \n" );
Msg ( "Clyde: TOTAL Space Required = %ld\n", dwTotal );
Msg ( "Clyde: \n" );
Msg ( "Clyde: \n" );
Msg ( "Clyde: %s Scenario 2 - Fresh Install Using Winnt32 (on Win9x or NT) and a CD on a 1 partition %s cluster drive.\n", String, desString );
dwPageFile = (64+11) * 1024 * 1024;
dwFreshInstall = dwFresh;
dwLocalBoot = LOCAL_BOOT;
dwTotal = dwPageFile + dwFreshInstall + dwLocalBoot;
Msg ( "Clyde: Pagefile for 64M RAM = %ld\n", dwPageFile );
Msg ( "Clyde: Local boot = %ld\n", dwLocalBoot );
Msg ( "Clyde: Fresh install = %ld\n", dwFreshInstall );
Msg ( "Clyde: \n" );
Msg ( "Clyde: TOTAL Space Required = %ld\n", dwTotal );
Msg ( "Clyde: \n" );
Msg ( "Clyde: \n" );
Msg ( "Clyde: %s Scenario 3 - Fresh Install Using Winnt32 (on Win9x or NT) over the network on a 1 partition %s cluster drive.\n", String, desString );
dwPageFile = (64+11) * 1024 * 1024;
dwLocalSource = dwLocal;
dwFreshInstall = dwFresh;
dwTextModeSavings = dwTextMode;
dwLocalBoot = LOCAL_BOOT;
dwTotal = dwPageFile + dwLocalSource + dwFreshInstall + dwLocalBoot - dwTextModeSavings;
Msg ( "Clyde: Pagefile for 64M RAM = %ld\n", dwPageFile );
Msg ( "Clyde: Local source = %ld\n", dwLocalSource );
Msg ( "Clyde: Fresh install = %ld\n", dwFreshInstall );
Msg ( "Clyde: TextMode savings = %ld\n", dwTextModeSavings );
Msg ( "Clyde: Local boot = %ld\n", dwLocalBoot );
Msg ( "Clyde: \n" );
Msg ( "Clyde: TOTAL Space Required = %ld\n", dwTotal );
Msg ( "Clyde: \n" );
Msg ( "Clyde: \n" );
Msg ( "Clyde: %s Scenario 4 - Upgrade using Winnt32 (on NT 4.0 Workstation) and a CD on a 1 partition %s cluster drive.\n", String, desString );
dwFreshInstall = dwFresh;
dwOsSizeDiff = x86From400;
dwLocalBoot = LOCAL_BOOT;
dwCacheDelete = 0;
dwTotal = dwFreshInstall - dwOsSizeDiff + dwLocalBoot - dwCacheDelete;
Msg ( "Clyde: Fresh install = %ld\n", dwFreshInstall );
Msg ( "Clyde: OsSizeDiff = %ld\n", dwOsSizeDiff );
Msg ( "Clyde: Local Boot = %ld\n", dwLocalBoot );
Msg ( "Clyde: Cache Delete = %ld\n", dwCacheDelete );
Msg ( "Clyde: \n" );
Msg ( "Clyde: TOTAL Space Required = %ld\n", dwTotal );
Msg ( "Clyde: \n" );
Msg ( "Clyde: \n" );
Msg ( "Clyde: %s Scenario 5 - Upgrade using Winnt32 (on NT 4.0 Workstation) over the network on a 1 partition %s cluster drive.\n", String, desString );
dwFreshInstall = dwFresh;
dwOsSizeDiff = x86From400;
dwLocalBoot = LOCAL_BOOT;
dwLocalSource = dwLocal;
dwCacheDelete = 0;
dwTotal = dwFreshInstall - dwOsSizeDiff + dwLocalBoot + dwLocalSource - dwCacheDelete;
Msg ( "Clyde: Fresh install = %ld\n", dwFreshInstall );
Msg ( "Clyde: OsSizeDiff = %ld\n", dwOsSizeDiff );
Msg ( "Clyde: Local Boot = %ld\n", dwLocalBoot );
Msg ( "Clyde: Local Source = %ld\n", dwLocalSource );
Msg ( "Clyde: Cache Delete = %ld\n", dwCacheDelete );
Msg ( "Clyde: \n" );
Msg ( "Clyde: TOTAL Space Required = %ld\n", dwTotal );
Msg ( "Clyde: \n" );
Msg ( "Clyde: \n" );
Msg ( "Clyde: %s Scenario 6 - Upgrade using Winnt32 (on Win9x) and a CD on a 1 partition %s cluster drive.\n", String, desString );
dwPageFile = (64+11) * 1024 * 1024;
dwFreshInstall = dwFresh;
dwLocalBoot = LOCAL_BOOT;
dwMigrationDlls = MigrationDllsK32;
dwCacheDelete = 0;
dwTotal = dwPageFile + dwFreshInstall + dwLocalBoot + dwMigrationDlls - dwCacheDelete;
Msg ( "Clyde: Pagefile for 64M RAM = %ld\n", dwPageFile );
Msg ( "Clyde: Fresh install = %ld\n", dwFreshInstall );
Msg ( "Clyde: Local Boot = %ld\n", dwLocalBoot );
Msg ( "Clyde: Migration DLLs = %ld\n", dwMigrationDlls );
Msg ( "Clyde: Cache Delete = %ld\n", dwCacheDelete );
Msg ( "Clyde: \n" );
Msg ( "Clyde: TOTAL Space Required = %ld\n", dwTotal );
Msg ( "Clyde: \n" );
Msg ( "Clyde: \n" );
Msg ( "Clyde: %s Scenario 7 - Upgrade using Winnt32 (on Win9x) over the network on a 1 partition %s cluster drive.\n", String, desString );
dwPageFile = (64+11) * 1024 * 1024;
dwFreshInstall = dwFresh;
dwLocalBoot = LOCAL_BOOT;
dwMigrationDlls = MigrationDllsK32;
dwLocalSource = dwLocal;
dwCacheDelete = 0;
dwTotal = dwPageFile + dwFreshInstall + dwLocalBoot + dwMigrationDlls + dwLocalSource - dwCacheDelete;
Msg ( "Clyde: Pagefile for 64M RAM = %ld\n", dwPageFile );
Msg ( "Clyde: Fresh install = %ld\n", dwFreshInstall );
Msg ( "Clyde: Local Boot = %ld\n", dwLocalBoot );
Msg ( "Clyde: Migration DLLs = %ld\n", dwMigrationDlls );
Msg ( "Clyde: Local Source = %ld\n", dwLocalSource );
Msg ( "Clyde: Cache Delete = %ld\n", dwCacheDelete );
Msg ( "Clyde: \n" );
Msg ( "Clyde: TOTAL Space Required = %ld\n", dwTotal );
Msg ( "Clyde: \n" );
Msg ( "Clyde: \n" );
}
void ShowTextModeSpace ( struct _ClusterSizes * FreshInstall,
struct _ClusterSizes * LocalSource,
struct _ClusterSizes * TextModeSavings,
char * String ) {
Msg ( "Clyde: TEXTMODE SPACE.\n" );
Msg ( "Clyde:\n" );
Msg ( "Clyde: %s 512 Cluster = %ld\n", String, TextModeSavings->Kh1 );
Msg ( "Clyde: %s 1K Cluster = %ld\n", String, TextModeSavings->K1 );
Msg ( "Clyde: %s 2K Cluster = %ld\n", String, TextModeSavings->K2 );
Msg ( "Clyde: %s 4K Cluster = %ld\n", String, TextModeSavings->K4 );
Msg ( "Clyde: %s 8K Cluster = %ld\n", String, TextModeSavings->K8 );
Msg ( "Clyde: %s 16K Cluster = %ld\n", String, TextModeSavings->K16);
Msg ( "Clyde: %s 32K Cluster = %ld\n", String, TextModeSavings->K32);
Msg ( "Clyde: %s 64K Cluster = %ld\n", String, TextModeSavings->K64);
Msg ( "Clyde: %s 128K Cluster = %ld\n", String, TextModeSavings->K128);
Msg ( "Clyde: %s 256K Cluster = %ld\n", String, TextModeSavings->K256);
Msg ( "Clyde:\n" );
Msg ( "Clyde: SCENARIOS VALUES FOLLOW\n" );
Msg ( "Clyde: \n" );
Msg ( "Clyde: \n" );
ClydeR ( String, "512 byte", FreshInstall->Kh1, LocalSource->Kh1, TextModeSavings->Kh1 );
ClydeR ( String, "4K byte", FreshInstall->K4 , LocalSource->K4, TextModeSavings->K4 );
ClydeR ( String, "32K byte", FreshInstall->K32 , LocalSource->K32, TextModeSavings->K32 );
}
int __cdecl main(argc,argv)
int argc;
char * argv[];
{
HANDLE h;
int records, i;
WIN32_FIND_DATA fd;
time_t t;
DWORD dwSize;
char szFileName[MFL];
#define MAKE_NEC98 "MAKE_NEC98"
#define SKIP_AS "SKIP_AS"
#define SKIP_SRV "SKIP_SRV"
#define SKIP_DC "SKIP_DC"
if ( getenv ( MAKE_NEC98 ) != NULL ) {
bNec98 = TRUE;
if ( argc != 9 ) {
printf ( "NEC98 special...\n" );
printf ( "You specified %d arguments - you need 9.\n\n", argc );
for ( i = 0; i < argc; ++i ) {
printf ( "Argument #%d >>>%s<<<\n", i, argv[i] );
}
printf ( "\n\n" );
Usage();
return(1);
}
}
else {
if ( argc != 7 ) {
printf ( "You specified %d arguments - you need 7.\n\n", argc );
for ( i = 0; i < argc; ++i ) {
printf ( "Argument #%d >>>%s<<<\n", i, argv[i] );
}
printf ( "\n\n" );
Usage();
return(1);
}
}
// Initialize the critical section object.
//
InitializeCriticalSection ( &CriticalSection );
// Retail %platform% files.
//
ix386.wNumFiles = 0;
Nec98.wNumFiles = 0;
strcpy ( szLogFile, argv[1] );
strcpy ( szProductName, argv[2] );
strcpy ( szEnlistDrv, argv[3] );
strcpy ( szX86Src, argv[4] );
strcpy ( szX86DstDrv, argv[5] );
strcpy ( szUnCompX86, argv[6] );
if ( bNec98 ) {
strcpy ( szNec98Src, argv[7] );
strcpy ( szUnCompNec98, argv[8] );
}
logFile = fopen ( argv[1], "a" );
if ( logFile == NULL ) {
printf("ERROR Couldn't open log file: %s\n",argv[1]);
return(1);
}
// Do bit comparison to release shares on all copies ?
//
#define VERIFY_COPIES "VERIFY"
if ( getenv ( VERIFY_COPIES ) != NULL ) {
bVerifyBits = TRUE;
Msg ( "Will verify copies...\n" );
}
if ( getenv ( SKIP_SRV ) && strstr ( szProductName, "Server" ) ) {
Msg ( "Warning: skipping making Server product.\n" );
exit ( 0 );
}
if ( getenv ( SKIP_AS ) && strstr ( szProductName, "AdvancedServer" ) ) {
Msg ( "Warning: skipping making Advanced Server product.\n" );
exit ( 0 );
}
if ( getenv ( SKIP_DC ) && strstr ( szProductName, "DataCenter" ) ) {
Msg ( "Warning: skipping making Data Center product.\n" );
exit ( 0 );
}
if ( strstr ( szX86Src, "chk." ) ||
strstr ( szX86Src, "CHK." ) ) {
Msg ( "Warning: We believe this is a checked build script, thus, we'll put put .dbgs in CHECKED directory...\n" );
bChecked = TRUE;
}
else {
Msg ( "Warning: We believe this is a free build script, thus, we'll put put .dbgs in FREE directory...\n" );
bChecked = FALSE;
}
Header(argv,argc);
CreateDestinationDirs ();
// Get files that product installs.
//
bGetSizeLater = TRUE;
PlatformFilesToCopy ( szX86Src, X86_F );
if ( bNec98 ) {
bNec98LikeX86 = TRUE;
PlatformFilesToCopy ( szNec98Src, NEC98_F );
}
bGetSizeLater = FALSE;
// Get the files from _media.inx in
// C:\nt\private\windows\setup\bom directory.
//
GetTheFiles ( "C:\\nt\\private\\windows\\setup\\bom",
"_media.inx",
DBGS_AND_NON_INSTALLED );
//ShowX86();
//ShowNec98 ();
Msg ( "# files i386 = %ld\n", ix386.wNumFiles );
if ( bNec98 ) {
Msg ( "# files Nec98 = %ld\n", Nec98.wNumFiles );
}
// Make some threads and copy all the files.
//
CopyTheFiles();
//
// Don't tally anything for checked builds since the INF sizes are off, ie. retail.
//
if ( bChecked ) {
Msg ( "Warning: We have a checked build here and will not tally file space...\n" );
goto END_MAIN;
}
Msg ( "========= Minimum setup install bytes required (all files uncompressed): ==========\n" );
TallyInstalled ( szUnCompX86, szX86Src, &ix386, &freshX86, &lX86, &tX86 );
if ( bNec98 ) {
TallyInstalled ( szUnCompNec98, szNec98Src, &Nec98, &freshNec98, &lNec98, &tNec98 );
}
// Give tally counts.
//
ShowCheckFreshSpace ( &freshX86, "freshX86", szX86Src );
if ( bNec98 ) {
ShowCheckFreshSpace ( &freshNec98, "freshNec98", szNec98Src );
}
Msg ( "Clyde: FreshInstall->K32 = %ld\n", freshX86.K32 );
Msg ( "Clyde: TextModeSavings->K32 = %ld\n", tX86.K32 );
Msg ( "Clyde: Local->K32 = %ld\n", lX86.K32 );
Msg ( "========= Maximum setup local-source bytes required (some files compressed) : =====\n" );
ShowCheckLocalSpace ( &lX86, "lX86", szX86Src );
if ( bNec98 ) {
ShowCheckLocalSpace ( &lNec98, "lNec98", szNec98Src );
}
Msg ( "========= Special TextMode files space =====\n" );
ShowTextModeSpace ( &freshX86, &lX86, &tX86, "X86" );
if ( bNec98 ) {
ShowTextModeSpace ( &freshNec98, &lNec98, &tNec98, "Nec98" );
}
END_MAIN:;
Msg ( "==============================\n");
time(&t);
Msg ( "Time: %s", ctime(&t) );
Msg ( "==============================\n\n");
fclose(logFile);
return(777);
}
Reference in a new issue View git blame Copy permalink