/****************************************************************************\
NEWFILES.C / OPK Wizard (OPKWIZ.EXE)
Microsoft Confidential
Copyright (c) Microsoft Corporation 1998
All rights reserved
3/99 - Jason Cohen (JCOHEN)
Added this new source file for the OPK Wizard as part of the OOBE
update.
09/2000 - Stephen Lodwick (STELO)
Ported OPK Wizard to Whistler
\****************************************************************************/
//
// Include file(s):
//
#include "pch.h"
#include "newfiles.h"
#include "resource.h"
//
// Internal Defined Value(s):
//
#define DIR_CONFIG_OOBE _T("$OEM$")
#define INF_SECT_SOURCEDISK _T("SourcedisksFiles")
#define INF_SECT_DESTDIRS _T("DestinationDirs")
#define INF_SECT_OOBE _T("RegisterOOBE")
#define INF_LINE_COPYFILES _T("CopyFiles")
#define INF_PREFIX _T("X")
#define SOURCENUM_OPTIONS_CAB _T("782")
#define DESTLDID_OOBE _T("11")
#define STR_SEARCH _T("*")
#define STR_PADDING _T("\r\n\r\n")
#define MAX_BUFFER 16384 // 32768
#ifndef CSTR_EQUAL
#define CSTR_EQUAL 2
#endif // CSTR_EQUAL
//
// Internal Structure(s):
//
typedef struct _FILELIST
{
LPTSTR lpFileName;
LPTSTR lpDirectory;
struct _FILELIST * lpNext;
} FILELIST, *PFILELIST, *LPFILELIST;
//
// Internal Function Prototype(s):
//
static void DelFiles(LPTSTR, LPTSTR, DWORD, LPTSTR, LPTSTR);
static LPFILELIST AllocFileList(HWND, LPTSTR, LPTSTR);
static BOOL CompareFiles(LPTSTR, LPTSTR);
//
// External Function(s):
//
//////////////////////////////////////////////////////////////////////////////
// AddFiles - lpSourceDir = location of files to copy to OOBE directory.
// Destination = location of the system directory where installed to
// LDID.
// lpConfigDir = location of oemaudit.inf, and config files.
// lpSourceDir -> OOBE -> lpDestDir
//
void AddFiles(HWND hwndParent, LPTSTR lpSourceDir, LPTSTR lpDestLdid,
LPTSTR lpDestDir, LPTSTR lpDestName, LPTSTR lpConfigDir)
{
LPTSTR lpFilePart,
lpFile,
lpFileName,
lpSectEnd,
lpSearch,
lpTarget,
lpNext;
TCHAR szBuffer[MAX_PATH + 32] = NULLSTR,
szCurDir[MAX_PATH] = NULLSTR,
szSourceDir[MAX_PATH] = NULLSTR,
szCopyDir[MAX_PATH],
szWinbom[MAX_PATH],
szCopyFiles[MAX_PATH + 32];
LPFILELIST lpflHead = NULL,
lpflCur,
lpflBuf;
BOOL bFound;
DWORD dwNum;
int iFilePartLen;
HRESULT hrCat;
HRESULT hrPrintf;
//
// First thing we do is setup the directories and strings
// that we need to do all the work.
//
// We need the path to the config directory. Copydir is where
// the files are going to be copied to from the SourceDir
// so it needs to be cleaned out before we do the CopyFile.
// CopyDir will be created if not exists.
//
lstrcpyn(szCopyDir, lpConfigDir, AS(szCopyDir));
AddPathN(szCopyDir, DIR_CONFIG_OOBE,AS(szCopyDir));
AddPathN(szCopyDir, _T("\\"),AS(szCopyDir));
lpFilePart = szCopyDir + lstrlen(szCopyDir);
iFilePartLen= AS(szCopyDir)-lstrlen(szCopyDir);
// Need a full path to the oemaudit inf.
//
lstrcpyn(szWinbom, lpConfigDir,AS(szWinbom));
AddPathN(szWinbom, FILE_WINBOM_INI,AS(szWinbom));
// We need to construct the prefix to the copy
// files section name.
//
lstrcpyn(szCopyFiles, INF_PREFIX,AS(szCopyFiles));
hrCat=StringCchCat(szCopyFiles, AS(szCopyFiles), lpDestLdid ? lpDestLdid : DESTLDID_OOBE);
if ( lpDestDir && *lpDestDir )
hrCat=StringCchCat(szCopyFiles, AS(szCopyFiles), lpDestDir);
StrRem(szCopyFiles, CHR_BACKSLASH);
lpSectEnd = szCopyFiles + lstrlen(szCopyFiles);
//
// Now that we have that info, we need to get rid of any files that
// may have already been put in the inf and the destination directory.
//
// Cleaned out of the inf and destination directory only if we are
// passed in NULL for the source.
//
if ( !(lpSourceDir && *lpSourceDir) )
DelFiles(szCopyDir, lpFilePart, iFilePartLen, szWinbom, szCopyFiles);
//
// Now we make a list of all the files we are going to add to the
// inf and destination directory.
//
// If the source isn't a valid dir, we must have just wanted to clean up.
//
if ( ( lpSourceDir && *lpSourceDir ) &&
( GetFullPathName(lpSourceDir, sizeof(szSourceDir) / sizeof(TCHAR), szSourceDir, &lpFile) && szSourceDir[0] ) &&
( (dwNum = GetFileAttributes(szSourceDir)) != 0xFFFFFFFF ) )
{
// Check to see if we were passed a file or a directory.
//
if ( ( dwNum & FILE_ATTRIBUTE_DIRECTORY ) ||
( lpFile <= szSourceDir ) )
{
// We are search for all the files in the diretory.
//
lpFile = STR_SEARCH;
}
else
{
// We are only doing one file. We need to separate
// the file from the directory.
//
*(lpFile - 1) = NULLCHR;
}
// Set the staring point for our file search.
//
GetCurrentDirectory(sizeof(szCurDir) / sizeof(TCHAR), szCurDir);
SetCurrentDirectory(szSourceDir);
// Get the file list.
//
lpflHead = AllocFileList(hwndParent, szBuffer, lpFile);
// Make sure the destination dir exits.
//
*lpFilePart = NULLCHR;
CreatePath(szCopyDir);
//
// Now that we have the file list, go through each one processing
// it separately and then free the memory allocated for it.
//
// Loop through all the files in our linked list.
//
for ( lpflCur = lpflHead; lpflCur; lpflCur = lpflBuf )
{
//
// First copy the file into the flat directory.
//
// Setup the relative path from the currect directory
// to the file we want to copy.
//
if ( lpflCur->lpDirectory && *lpflCur->lpDirectory )
lstrcpyn(szBuffer, lpflCur->lpDirectory,AS(szBuffer));
else
szBuffer[0] = NULLCHR;
AddPathN(szBuffer, lpflCur->lpFileName,AS(szBuffer));
// Support for a different file name for the destination.
//
lpFileName = lpDestName ? lpDestName : lpflCur->lpFileName;
// Setup the destination file name.
//
lstrcpyn(lpFilePart, lpFileName, iFilePartLen);
// Copy the file to the Options\Cabs directory and display
// an error if the copy failed. Probably means that this
// is a duplicate file.
//
if ( !CopyFile(szBuffer, szCopyDir, TRUE) )
{
// Save the CopyFile error and then check to see if the file
// is actaully different then the one tried to copy over.
//
dwNum = GetLastError();
if ( ( !CompareFiles(szBuffer, szCopyDir) ) &&
( lpTarget = (LPTSTR) MALLOC(256 * sizeof(TCHAR)) ) )
{
//
// I hate doing UI in backend type code. Because of time I don't have
// much choice, but in the future, this UI code should be replaced
// with a call back mechanism so the caller can do the UI.
//
// This is the first of only two places where UI is used in here.
//
// Allocate another buffer to hold the message with the file name.
//
if ( ( LoadString(NULL, dwNum == ERROR_FILE_EXISTS ? IDS_ERR_DUPFILE : IDS_ERR_COPY, lpTarget, 256 * sizeof(TCHAR)) ) &&
( lpNext = (LPTSTR) MALLOC((lstrlen(lpFileName) + lstrlen(lpTarget) + 1) * sizeof(TCHAR)) ) )
{
// Add the file name to the message, get the title for the message
// box and display the error.
//
hrPrintf=StringCchPrintf(lpNext, (lstrlen(lpFileName) + lstrlen(lpTarget) + 1), lpTarget, lpFileName);
*lpTarget = NULLCHR;
LoadString(NULL, IDS_APPNAME, lpTarget, 256 * sizeof(TCHAR));
MessageBox(hwndParent, lpNext, lpTarget, MB_OK | MB_ICONWARNING | MB_APPLMODAL);
FREE(lpNext);
}
FREE(lpTarget);
}
}
//
// Now add the file to the [SourceDiskFiles] section.
//
// We just use WritePrivateProfileString() to write
// FILENAME=781 to the [SourceDiskFiles] section.
//
WritePrivateProfileString(INF_SECT_SOURCEDISK, lpFileName, SOURCENUM_OPTIONS_CAB, szWinbom);
//
// This code figures out what the copy files section will be
// called. This is based on the path where the files will
// be copied.
//
// Create the name of the copy files section the file will be in.
//
*lpSectEnd = NULLCHR;
if ( lpflCur->lpDirectory && *lpflCur->lpDirectory )
lstrcpyn(lpSectEnd, lpflCur->lpDirectory, AS(szCopyFiles)-(int)(lpSectEnd - szCopyFiles) );
StrRem(lpSectEnd, CHR_BACKSLASH);
//
// Now add the file path to the [DestinationDirs] section.
//
// Create the LDID and dir combo to write to the dest dir section.
//
lstrcpyn(szBuffer, lpDestLdid ? lpDestLdid : DESTLDID_OOBE,AS(szBuffer));
if ( ( lpDestDir && *lpDestDir ) ||
( lpflCur->lpDirectory && *lpflCur->lpDirectory ) )
{
hrCat=StringCchCat(szBuffer,AS(szBuffer), _T(",\""));
if ( lpDestDir && *lpDestDir )
{
hrCat=StringCchCat(szBuffer, AS(szBuffer),lpDestDir);
if ( lpflCur->lpDirectory && *lpflCur->lpDirectory )
AddPathN(szBuffer, lpflCur->lpDirectory,AS(szBuffer));
}
else
hrCat=StringCchCat(szBuffer, AS(szBuffer), lpflCur->lpDirectory);
hrCat=StringCchCat(szBuffer, AS(szBuffer), _T("\""));
}
// We just use WritePrivateProfileString() to write
// COPYFILES=11,"OOBE\\DIR" to the [DestinationDirs] section.
//
WritePrivateProfileString(INF_SECT_DESTDIRS, szCopyFiles, szBuffer, szWinbom);
//
// Now add the copy files section to the CopyFiles line.
//
// First get current CopyFiles line.
//
szBuffer[0] = NULLCHR;
GetPrivateProfileString(INF_SECT_OOBE, INF_LINE_COPYFILES, NULLSTR, szBuffer, sizeof(szBuffer) / sizeof(TCHAR), szWinbom);
// Search each section listed in the CopyFiles line to see
// if we need to add this one. The sections are divided by
// commas.
//
// ISSUE-2002/02/28-stelo- May want to take qutoes into account, but I don't think so.
//
bFound = FALSE;
for ( lpTarget = szBuffer; !bFound && lpTarget && *lpTarget; lpTarget = lpNext )
{
// Get rid of proceeding spaces.
//
while ( *lpTarget == CHR_SPACE )
lpTarget = CharNext(lpTarget);
// NULL terminate at the ',' and setup
// the lpNext pointer.
//
if ( lpNext = StrChr(lpTarget, _T(',')) )
*lpNext = NULLCHR;
// Make sure there are no trailing spaces.
//
if ( lpSearch = StrChr(lpTarget, CHR_SPACE) )
*lpSearch = NULLCHR;
// Check if this section is the same as the one
// we are going to add.
//
if ( CompareString(LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE, lpTarget, -1, szCopyFiles, -1) == CSTR_EQUAL )
bFound = TRUE;
// Need to restore the characters we may have stomped on.
//
if ( lpNext )
*lpNext++ = _T(',');
if ( lpSearch )
*lpSearch = CHR_SPACE;
}
// Now see if we need to add the line.
//
if ( !bFound )
{
// Append our copy files section.
//
if ( szBuffer[0] )
hrCat=StringCchCat(szBuffer,AS(szBuffer), _T(", "));
hrCat=StringCchCat(szBuffer, AS(szBuffer), szCopyFiles);
// We just use WritePrivateProfileString() to write
// the CopyFiles line back to the [RegisterOOBE] section
// with our added copy files section on it.
//
WritePrivateProfileString(INF_SECT_OOBE, INF_LINE_COPYFILES, szBuffer, szWinbom);
}
//
// Now write the file name to it's copy files section.
//
// First get the entire copy files section.
//
GetPrivateProfileSection(szCopyFiles, szBuffer, sizeof(szBuffer) / sizeof(TCHAR), szWinbom);
// Loop throught the strings to see if the file is already there.
//
bFound = FALSE;
for ( lpTarget = szBuffer; !bFound && *lpTarget; lpTarget += (lstrlen(lpTarget) + 1) )
{
// Get rid of proceeding spaces.
//
while ( *lpTarget == CHR_SPACE )
lpTarget = CharNext(lpTarget);
// Make sure there are no trailing spaces.
//
if ( lpSearch = StrChr(lpTarget, CHR_SPACE) )
*lpSearch = NULLCHR;
// Check if this section is the same as the one
// we are going to add.
//
if ( CompareString(LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE, lpTarget, -1, lpFileName, -1) == CSTR_EQUAL )
bFound = TRUE;
// Need to restore the character we may have stomped on.
//
if ( lpSearch )
*lpSearch = CHR_SPACE;
}
// Now write back the section if we need to.
//
if ( !bFound )
{
// Need to a pointer to the end of the sub strings.
//
for ( lpSearch = szBuffer; *lpSearch; lpSearch += (lstrlen(lpSearch) + 1) );
// Copy the string to the end and add an extra NULL.
//
lstrcpyn(lpSearch, lpFileName, ((MAX_PATH+32)-(int)(lpSearch-szBuffer)) );
lpSearch += (lstrlen(lpSearch) + 1);
*lpSearch = NULLCHR;
// We need to call WritePrivateProfileSection() with NULL
// to remove the section. We shouldn't have to do this,
// but the Win32 docs are not correct.
//
WritePrivateProfileSection(szCopyFiles, NULL, szWinbom);
// We just use WritePrivateProfileSection() to write the
// copy files section back with our added file in it.
//
WritePrivateProfileSection(szCopyFiles, szBuffer, szWinbom);
}
//
// Now free the structure and the data within it.
//
// Save the next pointer before we free the structure.
//
lpflBuf = lpflCur->lpNext;
// Free the file buffers and the structure.
//
FREE(lpflCur->lpFileName);
FREE(lpflCur->lpDirectory);
FREE(lpflCur);
}
//
// All done, now just clean up.
//
// Put the current directory back to where it should be.
//
if ( szCurDir[0] )
SetCurrentDirectory(szCurDir);
}
// Make sure the changes to the inf are flushed to disk
//
WritePrivateProfileString(NULL, NULL, NULL, szWinbom);
}
//
// Internal Function(s):
//
static void DelFiles(LPTSTR lpszCopyDir, LPTSTR lpszFilePart, DWORD cbFilePart, LPTSTR lpszWinbom, LPTSTR lpszCopyFiles)
{
LPTSTR lpSearch,
lpSection,
lpFileName,
lpTarget,
lpNext;
LPTSTR lpszSections = NULL,
lpszFileNames = NULL,
lpszBuffer = NULL;
BOOL bFound;
//
// Allocate buffers...
//
lpszSections = MALLOC(MAX_BUFFER * sizeof(TCHAR));
lpszFileNames = MALLOC(MAX_BUFFER * sizeof(TCHAR));
lpszBuffer = MALLOC(MAX_BUFFER * sizeof(TCHAR));
if ( !lpszSections || !lpszFileNames || !lpszBuffer )
{
// Free the buffers... Note: FREE macro checks for NULL
//
FREE( lpszSections );
FREE( lpszFileNames );
FREE( lpszBuffer );
return;
}
// We need all the section names.
//
GetPrivateProfileSectionNames(lpszSections, MAX_BUFFER, lpszWinbom);
// Loop throught the section to see if there is any that match our search criteria.
//
for ( lpSection = lpszSections; lpSection && *lpSection; lpSection += (lstrlen(lpSection) + 1) )
{
// Get rid of proceeding spaces.
//
while ( *lpSection == CHR_SPACE )
lpSection = CharNext(lpSection);
// Make sure there are no trailing spaces.
//
if ( lpSearch = StrChr(lpSection, CHR_SPACE) )
*lpSearch = NULLCHR;
// Check if this section is the same as the one
// we are going to add.
//
if ( CompareString(LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE, lpSection, lstrlen(lpszCopyFiles), lpszCopyFiles, lstrlen(lpszCopyFiles)) == CSTR_EQUAL )
{
// We need all the files in the section.
//
GetPrivateProfileSection(lpSection, lpszFileNames, MAX_BUFFER, lpszWinbom);
// Loop throught the section to see if there is any that match our search criteria.
//
for ( lpFileName = lpszFileNames; *lpFileName; lpFileName += (lstrlen(lpFileName) + 1) )
{
// Get rid of proceeding spaces.
//
while ( *lpFileName == CHR_SPACE )
lpFileName = CharNext(lpFileName);
// Make sure there are no trailing spaces.
//
if ( lpSearch = StrChr(lpFileName, CHR_SPACE) )
*lpSearch = NULLCHR;
// Delete the file from the destination directory.
//
lstrcpyn(lpszFilePart, lpFileName, cbFilePart);
DeleteFile(lpszCopyDir);
// Remove the line from the source disk section.
//
WritePrivateProfileString(INF_SECT_SOURCEDISK, lpFileName, NULL, lpszWinbom);
}
// Search each section listed in the CopyFiles and remove
// this one. The sections are divided by commas.
//
bFound = FALSE;
GetPrivateProfileString(INF_SECT_OOBE, INF_LINE_COPYFILES, NULLSTR, lpszBuffer, MAX_BUFFER, lpszWinbom);
for ( lpTarget = lpszBuffer; !bFound && lpTarget && *lpTarget; lpTarget = lpNext )
{
// Get rid of proceeding spaces.
//
while ( *lpTarget == CHR_SPACE )
lpTarget = CharNext(lpTarget);
// NULL terminate at the ',' and setup
// the lpNext pointer.
//
if ( lpNext = StrChr(lpTarget, _T(',')) )
*lpNext = NULLCHR;
// Make sure there are no trailing spaces.
//
if ( lpSearch = StrChr(lpTarget, CHR_SPACE) )
*lpSearch = NULLCHR;
// Check if this section is the same as the one
// we are going to remove.
//
if ( CompareString(LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE, lpTarget, -1, lpSection, -1) == CSTR_EQUAL )
bFound = TRUE;
// Need to restore the characters we may have stomped on.
//
if ( lpNext )
*lpNext++ = _T(',');
if ( lpSearch )
*lpSearch = CHR_SPACE;
if ( bFound )
{
// Go back to the ',' or the beginning of the buffer.
//
while ( ( lpTarget > lpszBuffer) && ( *lpTarget != _T(',') ) )
lpTarget = CharPrev(lpszBuffer, lpTarget);
// Now overwrite the string we took out.
//
if ( lpNext )
lstrcpyn(lpTarget, lpNext - 1, (MAX_BUFFER-(int)(lpTarget-lpszBuffer)));
else
*lpTarget = NULLCHR;
}
}
if ( bFound )
{
// We should eat any preceeding spaces and/or commas just
// for good measure.
//
for ( lpTarget = lpszBuffer; ( *lpTarget == CHR_SPACE ) || ( *lpTarget == _T(',') ); lpTarget = CharNext(lpTarget) );
// Now write the buffer back to the inf file.
//
WritePrivateProfileString(INF_SECT_OOBE, INF_LINE_COPYFILES, *lpTarget ? lpTarget : NULL, lpszWinbom);
}
// Remove the line from the destination dirs section.
//
WritePrivateProfileString(INF_SECT_DESTDIRS, lpSection, NULL, lpszWinbom);
// Remove this section entirely.
//
WritePrivateProfileSection(lpSection, NULL, lpszWinbom);
}
}
// Free the buffers... Note: FREE macro checks for NULL
//
FREE( lpszSections );
FREE( lpszFileNames );
FREE( lpszBuffer );
}
static LPFILELIST AllocFileList(HWND hwndParent, LPTSTR lpDirectory, LPTSTR lpSearch)
{
WIN32_FIND_DATA FileFound;
HANDLE hFile;
LPTSTR lpEnd,
lpFileName;
LPFILELIST lpflHead = NULL;
LPFILELIST* lplpflNext = &lpflHead;
HRESULT hrPrintf;
// Process all the files and directories.
//
if ( (hFile = FindFirstFile(lpSearch, &FileFound)) != INVALID_HANDLE_VALUE )
{
do
{
// Display an error if the short and long file names don't match.
// Means that it is a LFN, which INFs don't like.
//
if ( ( FileFound.cAlternateFileName[0] ) &&
( CompareString(LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE, FileFound.cAlternateFileName, -1, FileFound.cFileName, -1) != CSTR_EQUAL ) &&
( lpEnd = (LPTSTR) MALLOC(256 * sizeof(TCHAR)) ) )
{
//
// I hate doing UI in backend type code. Because of time I don't have
// much choice, but in the future, this UI code should be replaced
// with a call back mechanism so the caller can do the UI.
//
// This is the second of only two places where UI is used in here.
//
// Allocate another buffer to hold the message with the file name.
//
if ( ( LoadString(NULL, IDS_ERR_LFN, lpEnd, 256) ) &&
( lpFileName = (LPTSTR) MALLOC((lstrlen(FileFound.cFileName) + lstrlen(lpEnd) + 1) * sizeof(TCHAR)) ) )
{
// Add the file name to the message, get the title for the message
// box and display the error.
//
hrPrintf=StringCchPrintf(lpFileName, (lstrlen(FileFound.cFileName) + lstrlen(lpEnd) + 1), lpEnd, FileFound.cFileName);
*lpEnd = NULLCHR;
LoadString(NULL, IDS_APPNAME, lpEnd, 256 * sizeof(TCHAR));
MessageBox(hwndParent, lpFileName, lpEnd, MB_OK | MB_ICONWARNING | MB_APPLMODAL);
FREE(lpFileName);
}
FREE(lpEnd);
}
// Get a pointer to the file name, the short one if possible.
//
if ( FileFound.cAlternateFileName[0] )
lpFileName = FileFound.cAlternateFileName;
else
lpFileName = FileFound.cFileName;
// First check to see if this is a files (not a directory).
//
if ( !( FileFound.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ) )
{
// Allocate the next item in the structure.
//
if ( *lplpflNext = (LPFILELIST) MALLOC(sizeof(FILELIST)) )
{
// Allocate the buffer for the file name and path and
// make sure that none of the allocations fail.
//
if ( ( (*lplpflNext)->lpFileName = (LPTSTR) MALLOC((lstrlen(lpFileName) + 1) * sizeof(TCHAR)) ) &&
( (*lplpflNext)->lpDirectory = (LPTSTR) MALLOC((lstrlen(lpDirectory) + 1) * sizeof(TCHAR)) ) )
{
// Copy the file name and path into the buffers.
//
lstrcpyn((*lplpflNext)->lpFileName, lpFileName, (lstrlen(lpFileName) + 1));
lstrcpyn((*lplpflNext)->lpDirectory, lpDirectory, (lstrlen(lpDirectory) + 1));
// Null the next pointer so we know this is the last item.
//
(*lplpflNext)->lpNext = NULL;
// Set the next pointer to point to the address of
// the next member of this new structure.
//
lplpflNext = &((*lplpflNext)->lpNext);
}
else
{
// Don't worry, the FREE() macro checks for NULL
// before it frees the memory.
//
FREE((*lplpflNext)->lpFileName);
FREE(*lplpflNext);
}
}
}
// Otherwise, make sure the directory is not "." or "..".
//
else if ( ( lstrcmp(lpFileName, _T(".")) ) &&
( lstrcmp(lpFileName, _T("..")) ) )
{
// Tack on this directory name to the current path saving
// the end pointer so that it is easy to get rid of this
// directory name when we return back.
//
lpEnd = lpDirectory + lstrlen(lpDirectory);
AddPath(lpDirectory, lpFileName);
// Go into the next directory, get all the files, and
// the set the current directory back to the original
// directory.
//
SetCurrentDirectory(lpFileName);
*lplpflNext = AllocFileList(hwndParent, lpDirectory, lpSearch);
SetCurrentDirectory(_T(".."));
// Get rid of the directory name off our path buffer.
//
*lpEnd = NULLCHR;
// Need to setup our next pointer to the end of the list
// returned to us.
//
while ( *lplpflNext )
lplpflNext = &((*lplpflNext)->lpNext);
}
}
while ( FindNextFile(hFile, &FileFound) );
FindClose(hFile);
}
return lpflHead;
}
static BOOL CompareFiles(LPTSTR lpFile1, LPTSTR lpFile2)
{
BOOL bCompare,
bRead1,
bRead2;
HANDLE hFile1,
hFile2;
BYTE baBuffer1[4096],
baBuffer2[4096];
DWORD dwBytes1,
dwBytes2,
dwCount;
// Open the files.
//
hFile1 = CreateFile(lpFile1, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
hFile2 = CreateFile(lpFile2, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
// Make sure the files were opened.
//
if ( ( hFile1 != INVALID_HANDLE_VALUE ) &&
( hFile2 != INVALID_HANDLE_VALUE ) )
{
// Read all the data from the files.
//
do
{
// Read in the max buffer from each file.
//
bRead1 = ReadFile(hFile1, baBuffer1, sizeof(baBuffer1), &dwBytes1, NULL);
bRead2 = ReadFile(hFile2, baBuffer2, sizeof(baBuffer2), &dwBytes2, NULL);
// Make sure the reads didn't fail.
//
if ( bRead1 && bRead2 )
{
// Check to make sure the sizes are the same.
//
if ( bCompare = ( dwBytes1 == dwBytes2 ) )
{
// Make sure the buffers are identical.
//
for ( dwCount = 0; bCompare && ( dwCount < dwBytes1 ); dwCount++ )
bCompare = ( baBuffer1[dwCount] == baBuffer2[dwCount] );
}
}
else
// If both the reads failed, we will return true.
//
bCompare = ( !bRead1 && !bRead2 );
}
while ( bCompare && bRead1 && bRead2 && dwBytes1 && dwBytes2 );
}
else
// If both the files does not exist, then we will
// return false.
//
bCompare = ( ( hFile1 != INVALID_HANDLE_VALUE ) && ( hFile2 != INVALID_HANDLE_VALUE ) );
// Close the files.
//
if ( hFile1 == INVALID_HANDLE_VALUE )
CloseHandle(hFile1);
if ( hFile2 == INVALID_HANDLE_VALUE )
CloseHandle(hFile2);
return bCompare;
}