#include "stdinc.h" // actually from dll\whistler directory
/*-----------------------------------------------------------------------------
Side X ("by") Side Test
-----------------------------------------------------------------------------*/
#include "nt.h"
#include "ntrtl.h"
#include "nturtl.h"
#include "windows.h"
#include "fusionlastwin32error.h"
#include <stddef.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#pragma warning(push)
#pragma warning(disable: 4511)
#pragma warning(disable: 4512)
#pragma warning(disable: 4663)
#include <yvals.h>
#pragma warning(disable: 4663)
#include <string>
#include <deque>
#include <vector>
#pragma warning(pop)
#include "fusionbuffer.h"
#include "fusion.h"
#include "sxsasmname.h"
#include "util.h"
#include "filestream.cpp"
#include "sxsapi.h"
#include "fusiontrace.h"
#include "cresourcestream.cpp"
#include "cmemorystream.cpp"
#include "wintrust.h"
#include "softpub.h"
#include "perfclocking.h"
#include "strongname.h"
#include "fusionversion.h"
#include "fusionhash.h"
#include "fusiondeque.h"
BOOL
MySetFilePointerEx(
HANDLE File, // handle to file
LARGE_INTEGER DistanceToMove, // bytes to move pointer
PLARGE_INTEGER NewFilePointer, // new file pointer
DWORD MoveMethod // starting point
)
{
LONG DistanceToMoveLow = static_cast<LONG>(DistanceToMove.LowPart);
LONG DistanceToMoveHigh = DistanceToMove.HighPart;
DWORD NewPositionLow = SetFilePointer(File, DistanceToMoveLow, &DistanceToMoveHigh, MoveMethod);
if (NewPositionLow == INVALID_SET_FILE_POINTER)
{
if (GetLastError() != NO_ERROR)
return FALSE;
}
if (NewFilePointer != NULL)
{
NewFilePointer->LowPart = NewPositionLow;
NewFilePointer->HighPart = DistanceToMoveHigh;
}
return TRUE;
}
BOOL FusionpAreWeInOSSetupMode(BOOL* pfIsInSetup) { *pfIsInSetup = FALSE; return TRUE; }
void ReportFailure(const char szFormat[], ...);
PCWSTR g_pszImage = L"mjgcopy";
CRITICAL_SECTION g_cs;
ULONGLONG g_FilesCopied = 0;
ULONGLONG g_BytesCopied = 0;
ULONGLONG g_FilesLinked = 0;
ULONGLONG g_DirectoriesCopied = 0;
ULONGLONG g_CopiesSkipped = 0;
ULONGLONG g_LinksSkipped = 0;
ULONGLONG g_FileCopiesProcessed = 0;
ULONGLONG g_FileLinksProcessed = 0;
ULONGLONG g_DirScansProcessed = 0;
ULONGLONG g_BytesToCopy = 0;
bool g_fAnnounceDirectories = true;
bool g_fAnnounceCopies = false;
bool g_fAnnounceDeletes = true;
bool g_fAnnounceLinks = true;
bool g_fAnnounceSkips = false;
bool g_fSilent = false;
bool g_fShowProgress = true;
HANDLE g_hIoCompletionPort = NULL;
HANDLE g_hWorkItemDoneEvent = INVALID_HANDLE_VALUE;
DWORD g_dwDestinationSectorsPerCluster = 0;
DWORD g_dwDestinationBytesPerSector = 0;
DWORD g_dwDestinationNumberOfFreeClusters = 0;
DWORD g_dwDestinationTotalNumberOfClusters = 0;
ULONG g_nThreads = 3;
HANDLE g_rghThreads[32];
class CFileCopy;
class CFileLink;
class CDir;
// BOOL ScanAndCopyDir(PCWSTR szSource, PCWSTR szDest);
BOOL BuildDirList(const CBaseStringBuffer &rbuffSource, const CBaseStringBuffer &rbuffDestination);
BOOL MakeDirectoryStructure();
BOOL QueueDirScans();
BOOL QueueFileCopies();
BOOL QueueFileLinks();
DWORD WINAPI WorkerThreadProc(LPVOID pvParameter);
void ComputeTimeDeltas(const SYSTEMTIME &rstStart, const SYSTEMTIME &rstEnd, SYSTEMTIME &rstDelta);
BOOL ProcessFileCopy(CFileCopy *pFileCopy, bool &rfReQueue, BYTE *pBuffer, DWORD cbBuffer);
BOOL ProcessFileLink(CFileLink *pFileLink, bool &rfReQueue);
BOOL ProcessDirScan(CDir *pDir, bool &rfReQueue);
BOOL ResumeWorkerThreads();
BOOL SuspendWorkerThreads();
BOOL
WaitForWorkersToComplete(
ULONGLONG &rullCounter,
ULONGLONG ullLimit,
PCSTR pszOperationName
);
BOOL
MyCopyFile(
BYTE *pBuffer,
DWORD cbBuffer,
PCWSTR lpExistingFileName,
PCWSTR lpNewFileName,
BOOL fFailIfExists,
HANDLE &rhNewFileHandle
);
class CEntry
{
private:
CEntry(const CEntry&); // deliberately not implemented
void operator=(const CEntry&); // deliberately not implemented
public:
CEntry() : m_cRetries(0) { }
~CEntry() { }
virtual BOOL BaseDoYourThing(bool &rfReQueue, BYTE *pBuffer, DWORD cbBuffer)
{
LARGE_INTEGER liStart, liEnd;
::QueryPerformanceCounter(&liStart);
BOOL fResult = this->DoYourThing(rfReQueue, pBuffer, cbBuffer);
if (fResult && rfReQueue)
{
m_cRetries++;
if (m_cRetries > 100)
fResult = FALSE;
}
CSxsPreserveLastError ple;
::QueryPerformanceCounter(&liEnd);
ple.Restore();
m_ullStart = static_cast<ULONGLONG>(liStart.QuadPart);
m_ullEnd = static_cast<ULONGLONG>(liEnd.QuadPart);
return fResult;
}
virtual BOOL DoYourThing(bool &rfReQueue, BYTE *pbBuffer, DWORD cbBuffer) = 0;
ULONGLONG m_ullStart, m_ullEnd;
ULONG m_cRetries;
};
class CDir : public CEntry
{
private:
CDir(const CDir&); // deliberately not implemented
void operator=(const CDir&); // deliberately not implemented
public:
CDir() { };
~CDir() { };
BOOL Initialize(const CBaseStringBuffer &rbuffSource, const CBaseStringBuffer &rbuffDestination)
{
BOOL fSuccess = FALSE;
if (!m_buffSource.Win32Assign(rbuffSource))
goto Exit;
if (!m_buffDestination.Win32Assign(rbuffDestination))
goto Exit;
fSuccess = TRUE;
Exit:
return fSuccess;
}
virtual BOOL DoYourThing(bool &rfReQueue, BYTE *, DWORD) { return ::ProcessDirScan(this, rfReQueue); }
CStringBuffer m_buffSource;
CStringBuffer m_buffDestination;
CDequeLinkage m_linkage;
};
class CFileBase : public CEntry
{
private:
CFileBase(const CFileBase&); // deliberately not implemented
void operator=(const CFileBase&); // deliberately not implemented
public:
CFileBase() : m_fDone(false) { }
~CFileBase() { }
BOOL Initialize(
CDir *pDir,
PCWSTR pszFilename,
FILETIME ftSourceCreationTime,
FILETIME ftSourceLastAccessTime,
FILETIME ftSourceLastWriteTime,
ULONGLONG ullFileIndex,
ULONGLONG cbSize
)
{
BOOL fSuccess = FALSE;
FN_TRACE_WIN32(fSuccess);
IFW32FALSE_EXIT(m_buffFilename.Win32Assign(pszFilename, wcslen(pszFilename)));
m_ftSourceCreationTime = ftSourceCreationTime;
m_ftSourceLastAccessTime = ftSourceLastAccessTime;
m_ftSourceLastWriteTime = ftSourceLastWriteTime;
m_ullFileIndex = ullFileIndex;
m_cbSize = cbSize;
m_pDir = pDir;
fSuccess = TRUE;
Exit:
return fSuccess;
}
virtual BOOL GetSource(CBaseStringBuffer &rbuff)
{
BOOL fSuccess = FALSE;
FN_TRACE_WIN32(fSuccess);
IFW32FALSE_EXIT(rbuff.Win32Assign(m_pDir->m_buffSource));
IFW32FALSE_EXIT(rbuff.Win32Append(m_buffFilename));
fSuccess = TRUE;
Exit:
return fSuccess;
}
virtual BOOL GetDestination(CBaseStringBuffer &rbuff)
{
BOOL fSuccess = FALSE;
FN_TRACE_WIN32(fSuccess);
IFW32FALSE_EXIT(rbuff.Win32Assign(m_pDir->m_buffDestination));
IFW32FALSE_EXIT(rbuff.Win32Append(m_buffFilename));
fSuccess = TRUE;
Exit:
return fSuccess;
}
CStringBuffer m_buffFilename;
FILETIME m_ftSourceCreationTime;
FILETIME m_ftSourceLastAccessTime;
FILETIME m_ftSourceLastWriteTime;
ULONGLONG m_ullFileIndex;
ULONGLONG m_cbSize;
CDir *m_pDir;
bool m_fSkipped; // used to avoid skewed statistics about number of bytes copied/sec etc.
bool m_fDone;
CDequeLinkage m_linkage;
};
class CFileCopy : public CFileBase
{
public:
CFileCopy() { }
~CFileCopy() { }
virtual BOOL DoYourThing(bool &rfReQueue, BYTE *pBuffer, DWORD cbBuffer) { return ::ProcessFileCopy(this, rfReQueue, pBuffer, cbBuffer); }
static int __cdecl QSortBySize(const void *param1, const void *param2)
{
CFileCopy **pp1 = (CFileCopy **) param1;
CFileCopy **pp2 = (CFileCopy **) param2;
CFileCopy *p1 = *pp1;
CFileCopy *p2 = *pp2;
int iRet = 0;
if (p1->m_fSkipped)
{
if (p2->m_fSkipped)
{
if (p1->m_cbSize < p2->m_cbSize)
iRet = 1;
else if (p1->m_cbSize > p2->m_cbSize)
iRet = -1;
else
{
if (p1->m_ullFileIndex < p2->m_ullFileIndex)
iRet = -1;
else
iRet = 1;
}
}
else
iRet = -1;
}
else
{
if (p2->m_fSkipped)
iRet = 1;
else
{
if (p1->m_cbSize < p2->m_cbSize)
iRet = 1;
else if (p1->m_cbSize > p2->m_cbSize)
iRet = -1;
else
{
if (p1->m_ullFileIndex < p2->m_ullFileIndex)
iRet = -1;
else
iRet = 1;
}
}
}
return iRet;
}
private:
CFileCopy(const CFileCopy &r);
void operator =(const CFileCopy &r);
};
class CFileLink : public CFileBase
{
public:
CFileLink() { }
~CFileLink() { }
virtual BOOL DoYourThing(bool &rfReQueue, BYTE *pBuffer, DWORD cbBuffer) { return ::ProcessFileLink(this, rfReQueue); }
BOOL GetSource(CBaseStringBuffer &rbuff);
private:
CFileLink(const CFileLink &r);
void operator =(const CFileLink &r);
};
CDeque<CDir, offsetof(CDir, m_linkage)> *g_pDirs = NULL;
CDir **g_prgpDirs = NULL;
CDeque<CFileCopy, offsetof(CFileCopy, m_linkage)> *g_pFileCopies = NULL;
CFileCopy **g_prgpFileCopies = NULL;
CDeque<CFileLink, offsetof(CFileLink, m_linkage)> *g_pFileLinks = NULL;
CFileLink **g_prgpFileLinks = NULL;
class CFileIdHashHelper : public CHashTableHelper<ULONGLONG, ULONGLONG, PCWSTR, CStringBuffer>
{
private:
CFileIdHashHelper(const CFileIdHashHelper&); // deliberately not implemented
void operator=(const CFileIdHashHelper&); // deliberately not implemented
public:
static BOOL HashKey(ULONGLONG keyin, ULONG &rulPseudoKey) { rulPseudoKey = static_cast<ULONG>(keyin); return TRUE; }
static BOOL CompareKey(ULONGLONG keyin, const ULONGLONG &rtkeystored, bool &rfMatch) { rfMatch = keyin == rtkeystored; return TRUE; }
static VOID PreInitializeKey(ULONGLONG &rtkeystored) { rtkeystored = 0; }
static VOID PreInitializeValue(CFileCopy *&rtvaluestored) { rtvaluestored = NULL; }
static BOOL InitializeKey(ULONGLONG keyin, ULONGLONG &rtkeystored) { rtkeystored = keyin; return TRUE; }
static BOOL InitializeValue(CFileCopy *vin, CFileCopy *&rvstored) { rvstored = vin; return TRUE; }
static BOOL UpdateValue(CFileCopy *vin, CFileCopy *&rvstored) { rvstored = vin; return TRUE; }
static VOID FinalizeKey(ULONGLONG &rtkeystored) { }
static VOID FinalizeValue(CFileCopy *&rvstored) { rvstored = NULL; }
};
class CFileIdHashTable : public CHashTable<ULONGLONG, ULONGLONG, CFileCopy *, CFileCopy *, CFileIdHashHelper>
{
private:
CFileIdHashTable(const CFileIdHashTable&); // deliberately not implemented
void operator=(const CFileIdHashTable&); // deliberately not implemented
public:
CFileIdHashTable() { }
~CFileIdHashTable() { }
};
CFileIdHashTable *g_pFiles = NULL;
FILE *g_pLogFile = NULL;
BOOL
CFileLink::GetSource(CBaseStringBuffer &rbuff)
{
BOOL fSuccess = FALSE;
FN_TRACE_WIN32(fSuccess);
CStringBuffer *pbuff = NULL;
CFileCopy **ppFileCopy = NULL;
if (!g_pFiles->Find(m_ullFileIndex, ppFileCopy))
{
::ReportFailure("Finding file index %I64u in the file table failed.\n");
goto Exit;
}
IFW32FALSE_EXIT((*ppFileCopy)->GetDestination(rbuff));
FN_EPILOG
}
extern "C" int __cdecl wmain(int argc, wchar_t** argv)
{
int iReturnStatus = EXIT_FAILURE;
SYSTEMTIME stStart, stAfterScan, stAfterDirCreation, stAfterCopies, stAfterLinks, stEnd;
ULONG i;
CStringBuffer buffSource;
CStringBuffer buffDestination;
int iSource = 0;
int iDestination = 0;
SYSTEMTIME stAfterScanDelta, stAfterDirCreationDelta, stAfterCopiesDelta, stAfterLinksDelta, stEndDelta;
ULONGLONG ullTemp;
int iArg;
// DWORD dwRetVal;
WCHAR rgwchSourceVolumePath[MAX_PATH];
WCHAR rgwchSourceVolumeName[MAX_PATH];
DWORD dwSourceVolumeSerialNumber;
DWORD dwSourceMaximumComponentLength;
DWORD dwSourceFileSystemFlags;
WCHAR rgwchSourceFileSystemNameBuffer[MAX_PATH];
WCHAR rgwchSourceRemoteName[MAX_PATH];
DWORD dwSourceRemoteNameLength = NUMBER_OF(rgwchSourceRemoteName);
UINT uiSourceDriveType;
WCHAR rgwchDestinationVolumePath[MAX_PATH];
WCHAR rgwchDestinationVolumeName[MAX_PATH];
DWORD dwDestinationVolumeSerialNumber;
DWORD dwDestinationMaximumComponentLength;
DWORD dwDestinationFileSystemFlags;
WCHAR rgwchDestinationFileSystemNameBuffer[MAX_PATH];
WCHAR rgwchDestinationRemoteName[MAX_PATH];
DWORD dwDestinationRemoteNameLength = NUMBER_OF(rgwchDestinationRemoteName);
UINT uiDestinationDriveType;
if (!::FusionpInitializeHeap(NULL))
goto Exit;
iArg = 1;
while (iArg < argc)
{
PCWSTR arg = argv[iArg];
// Let's see if we see some switches...
if ((arg[0] == L'-') || (arg[0] == L'/'))
{
arg++;
if ((_wcsicmp(arg, L"threads") == 0) ||
(_wcsicmp(arg, L"t") == 0))
{
PWSTR pszDummy;
iArg++;
if (iArg >= argc)
break;
g_nThreads = wcstol(argv[iArg], &pszDummy, 10);
if (g_nThreads < 1)
g_nThreads = 1;
if (g_nThreads > RTL_NUMBER_OF(g_rghThreads))
g_nThreads = RTL_NUMBER_OF(g_rghThreads);
iArg++;
continue;
}
else if ((_wcsicmp(arg, L"quiet") == 0) ||
(_wcsicmp(arg, L"q") == 0))
{
g_fSilent = true;
iArg++;
continue;
}
else if (_wcsicmp(arg, L"logfile") == 0)
{
iArg++;
if (iArg >= argc)
break;
g_pLogFile = ::_wfopen(argv[iArg], L"w+");
if (g_pLogFile == NULL)
{
::perror("Error opening logfile");
goto Exit;
}
iArg++;
}
}
// This must be it! We hope; there should be two things left
if ((iArg + 2) != argc)
break;
iSource = iArg;
iDestination = iArg + 1;
break;
}
if (iSource == 0)
{
fprintf(stderr,
"%ls: usage:\n"
" %ls [-threads n] [-quiet] <source> <dest>\n",
argv[0], argv[0]);
goto Exit;
}
// Abuse these buffers for debugging purposes...
{
HANDLE h;
if (!::GetLogicalDriveStringsW(NUMBER_OF(rgwchSourceVolumePath), rgwchSourceVolumePath))
{
::ReportFailure("GetLogicalDriveStringsW failed\n");
goto Exit;
}
h = ::FindFirstVolumeW(rgwchSourceVolumePath, NUMBER_OF(rgwchSourceVolumePath));
if (h == INVALID_HANDLE_VALUE)
{
::ReportFailure("FindFirstVolumeW failed\n");
goto Exit;
}
for (;;)
{
DWORD cchReturnLength;
if (!::GetVolumePathNamesForVolumeNameW(rgwchSourceVolumePath, rgwchDestinationVolumePath, NUMBER_OF(rgwchDestinationVolumePath), &cchReturnLength))
{
::ReportFailure("GetVolumePathNamesForVolumeNameW failed\n");
goto Exit;
}
if (!::FindNextVolumeW(h, rgwchSourceVolumePath, NUMBER_OF(rgwchSourceVolumePath)))
{
const DWORD dwLastError = ::GetLastError();
if (dwLastError != ERROR_NO_MORE_FILES)
{
::ReportFailure("FindNextVolumeW failed\n");
goto Exit;
}
break;
}
}
::FindVolumeClose(h);
}
if (!::GetVolumePathNameW(argv[iSource], rgwchSourceVolumePath, NUMBER_OF(rgwchSourceVolumePath)))
{
::ReportFailure("GetVolumePathName(L\"%ls\", ...) failed\n", argv[iSource]);
goto Exit;
}
uiSourceDriveType = ::GetDriveTypeW(rgwchSourceVolumePath);
if (!::GetVolumePathNameW(argv[iDestination], rgwchDestinationVolumePath, NUMBER_OF(rgwchDestinationVolumePath)))
{
::ReportFailure("GetVolumePathName(L\"%ls\", ...) failed\n", argv[iDestination]);
goto Exit;
}
uiDestinationDriveType = ::GetDriveTypeW(rgwchDestinationVolumePath);
if (!::GetVolumeInformationW(
rgwchSourceVolumePath,
rgwchSourceVolumeName,
NUMBER_OF(rgwchSourceVolumeName),
&dwSourceVolumeSerialNumber,
&dwSourceMaximumComponentLength,
&dwSourceFileSystemFlags,
rgwchSourceFileSystemNameBuffer,
NUMBER_OF(rgwchSourceFileSystemNameBuffer)))
{
::ReportFailure("GetVolumeInformation(L\"%ls\", ...) failed\n", rgwchSourceVolumePath);
goto Exit;
}
if (!::GetVolumeInformationW(
rgwchDestinationVolumePath,
rgwchDestinationVolumeName,
NUMBER_OF(rgwchDestinationVolumeName),
&dwDestinationVolumeSerialNumber,
&dwDestinationMaximumComponentLength,
&dwDestinationFileSystemFlags,
rgwchDestinationFileSystemNameBuffer,
NUMBER_OF(rgwchDestinationFileSystemNameBuffer)))
{
::ReportFailure("GetVolumeInformation(L\"%ls\", ...) failed\n", rgwchDestinationVolumePath);
goto Exit;
}
if (!::GetDiskFreeSpaceW(
rgwchDestinationVolumePath,
&g_dwDestinationSectorsPerCluster,
&g_dwDestinationBytesPerSector,
&g_dwDestinationNumberOfFreeClusters,
&g_dwDestinationTotalNumberOfClusters))
{
::ReportFailure("GetDiskFreeSpaceW(L\"%ls\", ...) failed\n", rgwchDestinationVolumePath);
goto Exit;
}
#if 0
if ((dwRetVal = ::WNetGetConnectionW(rgwchSourceVolumePath, rgwchSourceRemoteName, &dwSourceRemoteNameLength)) != NO_ERROR)
{
::SetLastError(dwRetVal);
::ReportFailure("WNetGetConnection(L\"%ls\", ...) failed\n", rgwchSourceVolumePath);
goto Exit;
}
#endif // 0
InitializeCriticalSection(&g_cs);
g_pFiles = new CFileIdHashTable;
g_pDirs = new CDeque<CDir, offsetof(CDir, m_linkage)>;
g_pFileCopies = new CDeque<CFileCopy, offsetof(CFileCopy, m_linkage)>;
g_pFileLinks = new CDeque<CFileLink, offsetof(CFileLink, m_linkage)>;
g_pszImage = wcsrchr(argv[0], L'\\');
if (g_pszImage == NULL)
g_pszImage = argv[0];
else
g_pszImage++;
g_hIoCompletionPort = ::CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, g_nThreads);
if (g_hIoCompletionPort == NULL)
{
::ReportFailure("Creating I/O Completion Port with %lu concurrent threads failed.\n", g_nThreads);
goto Exit;
}
g_hWorkItemDoneEvent = ::CreateEventW(NULL, FALSE, FALSE, NULL);
if (g_hWorkItemDoneEvent == NULL)
{
::ReportFailure("Creating the file copied event failed.\n");
goto Exit;
}
for (i=0; i<g_nThreads; i++)
{
g_rghThreads[i] = ::CreateThread(NULL, 0, &WorkerThreadProc, NULL, CREATE_SUSPENDED, NULL);
if (g_rghThreads[i] == NULL)
{
::ReportFailure("Creating worker thread number %lu failed.\n", i);
goto Exit;
}
}
::GetSystemTime(&stStart);
if (!buffSource.Win32Assign(argv[iSource], wcslen(argv[iSource])))
goto Exit;
if (!buffDestination.Win32Assign(argv[iDestination], wcslen(argv[iDestination])))
goto Exit;
if (!::BuildDirList(buffSource, buffDestination))
goto Exit;
if (!g_fSilent)
printf("%ls: Found %Iu directories.\n", g_pszImage, g_pDirs->GetEntryCount());
if (!::QueueDirScans())
goto Exit;
if (!::WaitForWorkersToComplete(g_DirScansProcessed, g_pDirs->GetEntryCount(), "Directory scans"))
goto Exit;
::GetSystemTime(&stAfterScan);
if (!g_fSilent)
{
printf("%ls: Copying %Iu files (%I64u bytes)\n", g_pszImage, g_pFileCopies->GetEntryCount(), g_BytesToCopy);
printf("%ls: Linking %Iu files\n", g_pszImage, g_pFileLinks->GetEntryCount());
}
if (!::MakeDirectoryStructure())
goto Exit;
if (!g_fSilent)
printf("%ls: Created %Iu directories.\n", g_pszImage, g_pDirs->GetEntryCount());
::GetSystemTime(&stAfterDirCreation);
if (!::QueueFileCopies())
goto Exit;
if (!::WaitForWorkersToComplete(g_FileCopiesProcessed, g_pFileCopies->GetEntryCount(), "File copies"))
goto Exit;
::GetSystemTime(&stAfterCopies);
::qsort(g_prgpFileCopies, g_pFileCopies->GetEntryCount(), sizeof(CFileCopy *), &CFileCopy::QSortBySize);
if (g_pLogFile != NULL)
{
LARGE_INTEGER liFreq;
ULONGLONG ullFreqDiv100;
CStringBuffer buffDestination;
::QueryPerformanceFrequency(&liFreq);
ullFreqDiv100 = (liFreq.QuadPart / 100);
for (i=0; i<g_pFileCopies->GetEntryCount(); i++)
{
ULONGLONG diff = g_prgpFileCopies[i]->m_ullEnd - g_prgpFileCopies[i]->m_ullStart;
diff = diff / ullFreqDiv100;
if (!g_prgpFileCopies[i]->GetDestination(buffDestination))
goto Exit;
fprintf(g_pLogFile, "%ls,%Iu,%Iu\n", static_cast<PCWSTR>(buffDestination), diff, g_prgpFileCopies[i]->m_cbSize);
}
}
if (!::QueueFileLinks())
goto Exit;
if (!::WaitForWorkersToComplete(g_FileLinksProcessed, g_pFileLinks->GetEntryCount(), "File links"))
goto Exit;
::GetSystemTime(&stAfterLinks);
::GetSystemTime(&stEnd);
::ComputeTimeDeltas(stStart, stAfterScan, stAfterScanDelta);
::ComputeTimeDeltas(stAfterScan, stAfterDirCreation, stAfterDirCreationDelta);
::ComputeTimeDeltas(stAfterDirCreation, stAfterCopies, stAfterCopiesDelta);
::ComputeTimeDeltas(stAfterCopies, stAfterLinks, stAfterLinksDelta);
::ComputeTimeDeltas(stStart, stEnd, stEndDelta);
printf(
"%ls: Statistics:\n"
" Directories Copied: %I64u\n"
" Files Copied: %I64u\n"
" Bytes Copied: %I64u\n"
" Files Linked: %I64u\n"
" Copies Skipped: %I64u\n"
" Links Skipped: %I64u\n",
g_pszImage,
g_DirectoriesCopied,
g_FilesCopied,
g_BytesCopied,
g_FilesLinked,
g_CopiesSkipped,
g_LinksSkipped);
printf(
" Times:\n"
" Scan: %u:%02u:%02u.%03u\n"
" Directory Creation: %u:%02u:%02u.%03u\n"
" Copying Files: %u:%02u:%02u.%03u\n"
" Linking Files: %u:%02u:%02u.%03u\n"
" Total: %u:%02u:%02u.%03u\n",
stAfterScanDelta.wHour, stAfterScanDelta.wMinute, stAfterScanDelta.wSecond, stAfterScanDelta.wMilliseconds,
stAfterDirCreationDelta.wHour, stAfterDirCreationDelta.wMinute, stAfterDirCreationDelta.wSecond, stAfterDirCreationDelta.wMilliseconds,
stAfterCopiesDelta.wHour, stAfterCopiesDelta.wMinute, stAfterCopiesDelta.wSecond, stAfterCopiesDelta.wMilliseconds,
stAfterLinksDelta.wHour, stAfterLinksDelta.wMinute, stAfterLinksDelta.wSecond, stAfterLinksDelta.wMilliseconds,
stEndDelta.wHour, stEndDelta.wMinute, stEndDelta.wSecond, stEndDelta.wMilliseconds
);
ullTemp = (((((stAfterCopiesDelta.wHour * 60) + stAfterCopiesDelta.wMinute) * 60) + stAfterCopiesDelta.wSecond) * 1000) + stAfterCopiesDelta.wMilliseconds;
if (ullTemp != 0)
{
ULONGLONG ullFilesPerMS = ((g_FilesCopied * 1000000ui64) / ullTemp);
ULONGLONG ullBytesPerMS = ((g_BytesCopied * 1000000ui64) / ullTemp);
printf(
" Files copied per second: %I64u.%03u\n"
" Bytes copied per second: %I64u.%03u\n",
static_cast<ULONGLONG>(ullFilesPerMS / 1000ui64), static_cast<ULONG>(ullFilesPerMS % 1000ui64),
static_cast<ULONGLONG>(ullBytesPerMS / 1000ui64), static_cast<ULONG>(ullBytesPerMS % 1000ui64));
#if 0
static_cast<ULONGLONG>((g_FilesCopied / ullTemp) * 1000ui64), static_cast<unsigned int>((g_FilesCopied / ullTemp) % 1000),
static_cast<ULONGLONG>((g_BytesCopied / ullTemp) * 1000ui64), static_cast<unsigned int>((g_BytesCopied / ullTemp) % 1000));
#endif
}
ullTemp = (((stAfterLinksDelta.wHour * 60) + stAfterLinksDelta.wMinute) * 60) + stAfterLinksDelta.wSecond;
if (ullTemp != 0)
{
printf(
" Files linked per second: %I64u\n",
static_cast<ULONGLONG>(g_FilesLinked / ullTemp));
}
ullTemp = (((stEndDelta.wHour * 60) + stEndDelta.wMinute) * 60) + stEndDelta.wSecond;
if (ullTemp != 0)
{
printf(
" Overall files per second: %I64u\n",
static_cast<ULONGLONG>((g_FilesCopied + g_CopiesSkipped + g_FilesLinked + g_LinksSkipped + g_pDirs->GetEntryCount()) / ullTemp));
}
iReturnStatus = EXIT_SUCCESS;
Exit:
// Wake the children; process termination doesn't seem to work if we don't.
::ResumeWorkerThreads();
if (g_pLogFile != NULL)
{
fflush(g_pLogFile);
fclose(g_pLogFile);
}
return iReturnStatus;
}
BOOL
ResumeWorkerThreads()
{
BOOL fSuccess = FALSE;
ULONG i;
for (i=0; i<g_nThreads; i++)
{
if (::ResumeThread(g_rghThreads[i]) == -1)
{
::ReportFailure("Failed to resume worker thread %lu\n", i + 1);
goto Exit;
}
}
fSuccess = TRUE;
Exit:
return fSuccess;
}
BOOL
SuspendWorkerThreads()
{
BOOL fSuccess = FALSE;
ULONG i;
for (i=0; i<g_nThreads; i++)
{
if (::SuspendThread(g_rghThreads[i]) == -1)
{
::ReportFailure("Failed to suspend worker thread %lu\n", i + 1);
goto Exit;
}
}
fSuccess = TRUE;
Exit:
return fSuccess;
}
BOOL
WaitForWorkersToComplete(
ULONGLONG &rullCounter,
ULONGLONG ullLimit,
PCSTR pszOperationName
)
{
BOOL fSuccess = FALSE;
ULONGLONG i;
if (!::ResumeWorkerThreads())
goto Exit;
i = 0;
while (rullCounter < ullLimit)
{
// Don't wake more than every tenth of a second...
::Sleep(100);
DWORD dwWFSO = ::WaitForSingleObject(g_hWorkItemDoneEvent, INFINITE);
if (dwWFSO == WAIT_FAILED)
{
::ReportFailure("Waiting for work item done event failed\n");
goto Exit;
}
i++;
if ((i % 50) == 0)
{
if (!g_fSilent)
printf("%ls: %s processed (%I64u total): %I64u\n", g_pszImage, pszOperationName, ullLimit, rullCounter);
}
}
if (!::SuspendWorkerThreads())
goto Exit;
fSuccess = TRUE;
Exit:
return fSuccess;
}
void
ComputeTimeDeltas(
const SYSTEMTIME &rstStart,
const SYSTEMTIME &rstEnd,
SYSTEMTIME &rstDelta
)
{
FILETIME ftStart, ftEnd;
ULARGE_INTEGER uliStart, uliEnd;
ULONGLONG ullDiff, ullTemp;
ULONG ulHours, ulMinutes, ulSeconds, ulMilliseconds;
::SystemTimeToFileTime(&rstStart, &ftStart);
::SystemTimeToFileTime(&rstEnd, &ftEnd);
uliStart.LowPart = ftStart.dwLowDateTime;
uliStart.HighPart = ftStart.dwHighDateTime;
uliEnd.LowPart = ftEnd.dwLowDateTime;
uliEnd.HighPart = ftEnd.dwHighDateTime;
ullDiff = (uliEnd.QuadPart - uliStart.QuadPart);
ulHours = (ULONG) (ullDiff / (10000000ui64 * 60 * 60));
ullTemp = ullDiff - ((ULONGLONG) ulHours) * (10000000ui64 * 60 * 60);
ulMinutes = (ULONG) (ullTemp / (10000000ui64 * 60));
ullTemp -= ((ULONGLONG) ulMinutes) * (10000000ui64 * 60);
ulSeconds = (ULONG) (ullTemp / 10000000ui64);
ullTemp -= ((ULONGLONG) ulSeconds) * 10000000ui64;
ulMilliseconds = (ULONG) (ullTemp / 10000ui64);
rstDelta.wYear = 0;
rstDelta.wMonth = 0;
rstDelta.wDayOfWeek = 0;
rstDelta.wDay = 0;
rstDelta.wHour = (WORD) ulHours;
rstDelta.wMinute = (WORD) ulMinutes;
rstDelta.wSecond = (WORD) ulSeconds;
rstDelta.wMilliseconds = (WORD) ulMilliseconds;
}
BOOL
BuildDirList(
const CBaseStringBuffer &rbuffSource,
const CBaseStringBuffer &rbuffDestination
)
{
PCWSTR szSrc = rbuffSource;
BOOL fSuccess = FALSE;
DWORD dwFileAttributes;
CStringBuffer buffSrc;
CStringBuffer buffSrcWildcard;
CStringBuffer buffDst;
WIN32_FIND_DATAW wfd;
HANDLE hFind = INVALID_HANDLE_VALUE;
HANDLE hFile = INVALID_HANDLE_VALUE;
SIZE_T cchSrc, cchDst;
CDir *pDir = NULL;
dwFileAttributes = ::GetFileAttributesW(rbuffSource);
if (dwFileAttributes == ((DWORD) -1))
{
::ReportFailure("GetFileAttributesW() on the source \"%ls\" failed\n", szSrc);
goto Exit;
}
if (!(dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
{
::SetLastError(ERROR_INVALID_PARAMETER);
::ReportFailure("Source directory \"%ls\" is not a directory!\n");
goto Exit;
}
if (!buffSrc.Win32Assign(rbuffSource))
goto Exit;
if (!buffSrc.Win32EnsureTrailingPathSeparator())
goto Exit;
if (!buffDst.Win32Assign(rbuffDestination))
goto Exit;
if (!buffDst.Win32EnsureTrailingPathSeparator())
goto Exit;
cchSrc = buffSrc.Cch();
cchDst = buffDst.Cch();
pDir = new CDir;
if (pDir == NULL)
{
::SetLastError(ERROR_OUTOFMEMORY);
::ReportFailure("Failed to allocate new CDir object\n");
goto Exit;
}
if (!pDir->Initialize(buffSrc, buffDst))
goto Exit;
g_pDirs->AddToTail(pDir);
pDir = NULL;
if ((g_pDirs->GetEntryCount() % 50) == 0)
{
if (!g_fSilent)
printf("%ls: Found %Iu directories...\n", g_pszImage, g_pDirs->GetEntryCount());
}
if (!buffSrcWildcard.Win32Assign(buffSrc))
goto Exit;
if (!buffSrcWildcard.Win32Append(L"*", 1))
goto Exit;
if ((hFind = ::FindFirstFileExW(
buffSrcWildcard,
FindExInfoStandard,
&wfd,
FindExSearchLimitToDirectories,
NULL,
0)) == INVALID_HANDLE_VALUE)
{
const DWORD dwLastError = ::GetLastError();
if (dwLastError != ERROR_NO_MORE_FILES)
{
::ReportFailure("FindFirstFileW(L\"%ls\", ...) failed.\n", static_cast<PCWSTR>(buffSrcWildcard));
goto Exit;
}
}
for (;;)
{
if ((wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) &&
(wcscmp(wfd.cFileName, L".") != 0) &&
(wcscmp(wfd.cFileName, L"..") != 0))
{
buffSrc.Left(cchSrc);
buffDst.Left(cchDst);
if (!buffSrc.Win32Append(wfd.cFileName, wcslen(wfd.cFileName)))
goto Exit;
if (!buffDst.Win32Append(wfd.cFileName, wcslen(wfd.cFileName)))
goto Exit;
if (!::BuildDirList(buffSrc, buffDst))
goto Exit;
}
if (!::FindNextFileW(hFind, &wfd))
{
if (::GetLastError() == ERROR_NO_MORE_FILES)
break;
::ReportFailure("FindNextFileW() failed\n");
goto Exit;
}
}
fSuccess = TRUE;
Exit:
if (hFind != INVALID_HANDLE_VALUE)
{
CSxsPreserveLastError ple;
::FindClose(hFind);
ple.Restore();
}
if (pDir != NULL)
delete pDir;
return fSuccess;
}
BOOL
BuildDirFileList(
CSxsLockCriticalSection &rlcs,
CDir *pDir
)
{
PCWSTR szSrc = pDir->m_buffSource;
BOOL fSuccess = FALSE;
DWORD dwFileAttributes;
CStringBuffer buffSrc;
CStringBuffer buffSrcWildcard;
CStringBuffer buffDst;
WIN32_FIND_DATAW wfd;
HANDLE hFind = INVALID_HANDLE_VALUE;
HANDLE hFile = INVALID_HANDLE_VALUE;
SIZE_T cchSrc, cchDst;
CFileLink *pFileLink = NULL;
CFileCopy *pFileCopy = NULL;
dwFileAttributes = ::GetFileAttributesW(pDir->m_buffSource);
if (dwFileAttributes == ((DWORD) -1))
{
::ReportFailure("GetFileAttributesW() on the source \"%ls\" failed", szSrc);
goto Exit;
}
if (!(dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
{
::SetLastError(ERROR_INVALID_PARAMETER);
::ReportFailure("Source directory \"%ls\" is not a directory!\n", szSrc);
goto Exit;
}
if (!buffSrc.Win32Assign(pDir->m_buffSource))
goto Exit;
if (!buffSrc.Win32EnsureTrailingPathSeparator())
goto Exit;
if (!buffDst.Win32Assign(pDir->m_buffDestination))
goto Exit;
if (!buffDst.Win32EnsureTrailingPathSeparator())
goto Exit;
cchSrc = buffSrc.Cch();
cchDst = buffDst.Cch();
if (!buffSrcWildcard.Win32Assign(buffSrc))
goto Exit;
if (!buffSrcWildcard.Win32Append(L"*", 1))
goto Exit;
if ((hFind = ::FindFirstFileW(buffSrcWildcard, &wfd)) == INVALID_HANDLE_VALUE)
{
const DWORD dwLastError = ::GetLastError();
if (::GetLastError() != ERROR_NO_MORE_FILES)
{
::ReportFailure("FindFirstFileW(L\"%ls\", ...) failed\n", static_cast<PCWSTR>(buffSrcWildcard));
goto Exit;
}
}
for (;;)
{
if ((wcscmp(wfd.cFileName, L".") != 0) && (wcscmp(wfd.cFileName, L"..") != 0))
{
buffSrc.Left(cchSrc);
buffDst.Left(cchDst);
if (!buffSrc.Win32Append(wfd.cFileName, wcslen(wfd.cFileName)))
goto Exit;
if (!buffDst.Win32Append(wfd.cFileName, wcslen(wfd.cFileName)))
goto Exit;
dwFileAttributes = ::GetFileAttributesW(buffSrc);
if (dwFileAttributes == ((DWORD) -1))
{
::ReportFailure("GetFileAttribuesW(L\"%ls\") failed\n", static_cast<PCWSTR>(buffSrc));
goto Exit;
}
if ((dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0)
{
BY_HANDLE_FILE_INFORMATION bhfi;
ULONGLONG ullFileIndex;
ULONGLONG ullFileSize;
CFileCopy **ppFileCopy = NULL;
hFile = ::CreateFileW(buffSrc, 0, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (hFile == INVALID_HANDLE_VALUE)
{
::ReportFailure("CreateFileW(L\"%ls\", ...) failed\n", static_cast<PCWSTR>(buffSrc));
goto Exit;
}
if (!::GetFileInformationByHandle(hFile, &bhfi))
{
::ReportFailure("Failed to GetFileInformationByHandle(%p, ...) on file \"%ls\"\n", hFile, static_cast<PCWSTR>(buffSrc));
goto Exit;
}
::CloseHandle(hFile);
hFile = INVALID_HANDLE_VALUE;
ullFileIndex = (((ULONGLONG) bhfi.nFileIndexHigh) << 32) | ((ULONGLONG) bhfi.nFileIndexLow);
ullFileSize = (((ULONGLONG) bhfi.nFileSizeHigh) << 32) | ((ULONGLONG) bhfi.nFileSizeLow);
g_BytesToCopy += ullFileSize;
if (!rlcs.Lock())
{
::ReportFailure("Failed to lock global critical section");
goto Exit;
}
if (!g_pFiles->Find(ullFileIndex, ppFileCopy))
{
::ReportFailure("Finding file index %I64u in file table failed.\n", ullFileIndex);
goto Exit;
}
if (ppFileCopy != NULL)
{
pFileLink = new CFileLink;
if (pFileLink == NULL)
{
::SetLastError(ERROR_OUTOFMEMORY);
goto Exit;
}
if (!pFileLink->Initialize(
pDir,
wfd.cFileName,
bhfi.ftCreationTime,
bhfi.ftLastAccessTime,
bhfi.ftLastWriteTime,
ullFileIndex,
ullFileSize))
goto Exit;
g_pFileLinks->AddToTail(pFileLink);
pFileLink = NULL;
}
else
{
pFileCopy = new CFileCopy;
if (pFileCopy == NULL)
{
::SetLastError(ERROR_OUTOFMEMORY);
::ReportFailure("Allocating new CFileCopy object failed.\n");
goto Exit;
}
if (!pFileCopy->Initialize(
pDir,
wfd.cFileName,
bhfi.ftCreationTime,
bhfi.ftLastAccessTime,
bhfi.ftLastWriteTime,
ullFileIndex,
ullFileSize))
goto Exit;
if (!g_pFiles->Insert(ullFileIndex, pFileCopy))
goto Exit;
g_pFileCopies->AddToTail(pFileCopy);
pFileCopy = NULL;
}
rlcs.Unlock();
}
}
if (!::FindNextFileW(hFind, &wfd))
{
const DWORD dwLastError = ::GetLastError();
if (dwLastError == ERROR_NO_MORE_FILES)
break;
::ReportFailure("FindNextFileW() call failed\n");
goto Exit;
}
}
fSuccess = TRUE;
Exit:
if (hFind != INVALID_HANDLE_VALUE)
{
CSxsPreserveLastError ple;
::FindClose(hFind);
ple.Restore();
}
if (pFileLink != NULL)
delete pFileLink;
if (pFileCopy != NULL)
delete pFileCopy;
return fSuccess;
}
BOOL
MakeDirectoryStructure()
{
BOOL fSuccess = FALSE;
CDequeIterator<CDir, offsetof(CDir, m_linkage)> dirIter;
dirIter.Rebind(g_pDirs);
for (dirIter.Reset(); dirIter.More(); dirIter.Next())
{
if (!::CreateDirectoryW(dirIter->m_buffDestination, NULL))
{
const DWORD dwLastError = ::GetLastError();
if (dwLastError != ERROR_ALREADY_EXISTS)
{
::ReportFailure("Unable to create directory \"%ls\"", static_cast<PCWSTR>(dirIter->m_buffDestination));
goto Exit;
}
}
}
fSuccess = TRUE;
Exit:
return fSuccess;
}
void
ReportFailure(
const char szFormat[],
...
)
{
const DWORD dwLastError = ::GetLastError();
va_list ap;
char rgchBuffer[4096];
WCHAR rgchWin32Error[4096];
va_start(ap, szFormat);
_vsnprintf(rgchBuffer, sizeof(rgchBuffer) / sizeof(rgchBuffer[0]), szFormat, ap);
va_end(ap);
if (!::FormatMessageW(
FORMAT_MESSAGE_FROM_SYSTEM,
NULL,
dwLastError,
0,
rgchWin32Error,
NUMBER_OF(rgchWin32Error),
&ap))
{
const DWORD dwLastError2 = ::GetLastError();
_snwprintf(rgchWin32Error, sizeof(rgchWin32Error) / sizeof(rgchWin32Error[0]), L"Error formatting Win32 error %lu\nError from FormatMessage is %lu", dwLastError, dwLastError2);
}
fprintf(stderr, "%ls: %s\n%ls\n", g_pszImage, rgchBuffer, rgchWin32Error);
}
DWORD
WINAPI
WorkerThreadProc(
LPVOID pvParameter
)
{
ULONG nThread = (ULONG)(ULONG_PTR)pvParameter;
DWORD dwReturnValue = 0;
BYTE *pBuffer = NULL;
DWORD cbBuffer;
cbBuffer = 8192 * 32;
pBuffer = (BYTE *) ::VirtualAlloc(NULL, cbBuffer, MEM_COMMIT, PAGE_READWRITE);
if (pBuffer == NULL)
{
ReportFailure("VirtualAlloc() for thread %lu failed.\n", nThread);
goto Exit;
}
for (;;)
{
DWORD nBytes = 0;
ULONG_PTR ulpCompletionKey = 0;
LPOVERLAPPED lpo = NULL;
CEntry *pEntry = NULL;
bool fReQueue = false;
if (!::GetQueuedCompletionStatus(g_hIoCompletionPort, &nBytes, &ulpCompletionKey, &lpo, INFINITE))
{
ReportFailure("Thread %lu failed call to GetQueuedCompletionStatus()\n", nThread);
dwReturnValue = ::GetLastError();
goto Exit;
}
pEntry = (CEntry *) lpo;
DoItAgain:
if (!pEntry->BaseDoYourThing(fReQueue, pBuffer, cbBuffer))
goto Exit;
if (fReQueue)
{
if (!::PostQueuedCompletionStatus(g_hIoCompletionPort, 0, NULL, lpo))
{
ReportFailure("Thread %lu failed to requeue item; retrying directly.\n", nThread);
goto DoItAgain;
}
}
::SetEvent(g_hWorkItemDoneEvent);
}
Exit:
// Heavy handed but what else can we do?
::ExitProcess(dwReturnValue);
return dwReturnValue;
}
BOOL
QueueDirScans()
{
BOOL fSuccess = FALSE;
SIZE_T i;
g_prgpDirs = new (CDir *[g_pDirs->GetEntryCount()]);
CDequeIterator<CDir, offsetof(CDir, m_linkage)> dirIter;
dirIter.Rebind(g_pDirs);
for (dirIter.Reset(), i=0; dirIter.More(); dirIter.Next(), i++)
{
g_prgpDirs[i] = dirIter;
if (!::PostQueuedCompletionStatus(g_hIoCompletionPort, 0, 0, (LPOVERLAPPED) dirIter.Current()))
{
ReportFailure("Failed to queue dir scan\n");
goto Exit;
}
}
fSuccess = TRUE;
Exit:
return fSuccess;
}
BOOL
QueueFileCopies()
{
BOOL fSuccess = FALSE;
SIZE_T i;
FN_TRACE_WIN32(fSuccess);
CDequeIterator<CFileCopy, offsetof(CFileCopy, m_linkage)> fileIter;
g_prgpFileCopies = new (CFileCopy *[g_pFileCopies->GetEntryCount()]);
fileIter.Rebind(g_pFileCopies);
i=0;
for (fileIter.Reset(); fileIter.More(); fileIter.Next())
{
if (!::PostQueuedCompletionStatus(g_hIoCompletionPort, 0, 0, (LPOVERLAPPED) fileIter.Current()))
{
ReportFailure("Failed to queue file copy\n");
goto Exit;
}
g_prgpFileCopies[i++] = fileIter;
}
fSuccess = TRUE;
Exit:
return fSuccess;
}
BOOL
QueueFileLinks()
{
BOOL fSuccess = FALSE;
SIZE_T i;
CDequeIterator<CFileLink, offsetof(CFileLink, m_linkage)> fileIter;
g_prgpFileLinks = new (CFileLink *[g_pFileLinks->GetEntryCount()]);
fileIter.Rebind(g_pFileLinks);
i=0;
for (fileIter.Reset(); fileIter.More(); fileIter.Next())
{
if (!::PostQueuedCompletionStatus(g_hIoCompletionPort, 0, 0, (LPOVERLAPPED) fileIter.Current()))
{
ReportFailure("Failed to queue file link\n");
goto Exit;
}
g_prgpFileLinks[i++] = fileIter;
}
fSuccess = TRUE;
Exit:
return fSuccess;
}
BOOL
ProcessDirScan(
CDir *pDir,
bool &rfReQueue
)
{
BOOL fSuccess = FALSE;
CSxsLockCriticalSection l(g_cs);
rfReQueue = false;
if (!::BuildDirFileList(l, pDir))
goto Exit;
if (!l.Lock())
{
ReportFailure("Failed to lock global critical section");
goto Exit;
}
g_DirScansProcessed++;
l.Unlock();
fSuccess = TRUE;
Exit:
return fSuccess;
}
BOOL
ProcessFileCopy(
CFileCopy *pFile,
bool &rfReQueue,
BYTE *pBuffer,
DWORD cbBuffer
)
{
BOOL fSuccess = FALSE;
FN_TRACE_WIN32(fSuccess);
CSxsLockCriticalSection l(g_cs);
bool fDoCopy = true;
DWORD dwFileAttributes;
HANDLE hFile = INVALID_HANDLE_VALUE;
CStringBuffer buffSource, buffDestination;
rfReQueue = false;
// If we're about to copy it, it's worth taking a look at the target to see if it's more-or-less
// out of date.
WIN32_FILE_ATTRIBUTE_DATA wfad;
IFW32FALSE_EXIT(pFile->GetSource(buffSource));
IFW32FALSE_EXIT(pFile->GetDestination(buffDestination));
if (!::GetFileAttributesExW(buffDestination, GetFileExInfoStandard, &wfad))
{
const DWORD dwLastError = ::GetLastError();
if (dwLastError != ERROR_FILE_NOT_FOUND)
{
::ReportFailure("Error opening target file \"%ls\"\n", static_cast<PCWSTR>(buffDestination));
goto Exit;
}
wfad.dwFileAttributes = ((DWORD) -1);
}
else
{
ULONGLONG cbFileSize = (wfad.nFileSizeHigh << 32) | wfad.nFileSizeLow;
ASSERT_NTC(cbFileSize >= wfad.nFileSizeLow);
if ((cbFileSize == pFile->m_cbSize) &&
(wfad.ftCreationTime == pFile->m_ftSourceCreationTime))
{
pFile->m_fSkipped = true;
fDoCopy = false;
}
}
if (fDoCopy)
{
bool fSetTimestamp = true;
bool fClearedReadOnly = false;
// Destructively clear the read-only bit if th destination file exists and is read-only.
dwFileAttributes = wfad.dwFileAttributes;
// We already filtered out all other reasons for failure other than FILE_NOT_FOUND.
if (dwFileAttributes != ((DWORD) -1))
{
if (dwFileAttributes & FILE_ATTRIBUTE_READONLY)
{
// If it's readonly, clear that bit as well as all the others that
// are illegal to set via SetFileAttributes()
dwFileAttributes &=
~(FILE_ATTRIBUTE_READONLY |
FILE_ATTRIBUTE_COMPRESSED |
FILE_ATTRIBUTE_DEVICE |
FILE_ATTRIBUTE_DIRECTORY |
FILE_ATTRIBUTE_ENCRYPTED |
FILE_ATTRIBUTE_REPARSE_POINT |
FILE_ATTRIBUTE_SPARSE_FILE);
if (!::SetFileAttributesW(buffDestination, dwFileAttributes))
{
::ReportFailure("Error setting file attributes for target file \"%ls\" to 0x%08lx to allow overwrite\n", static_cast<PCWSTR>(buffDestination), dwFileAttributes);
goto Exit;
}
}
}
if (g_fAnnounceCopies)
printf("Copying \"%ls\" to \"%ls\"\n", static_cast<PCWSTR>(buffSource), static_cast<PCWSTR>(buffDestination));
// Hey, it's not there. Let's copy it and put the entry in the table.
if (!::MyCopyFile(pBuffer, cbBuffer, buffSource, buffDestination, FALSE, hFile))
{
::ReportFailure("Failed to copy \"%ls\" to \"%ls\".\n", static_cast<PCWSTR>(buffSource), static_cast<PCWSTR>(buffDestination));
goto Exit;
}
if (fSetTimestamp)
{
if (!::SetFileTime(hFile, &pFile->m_ftSourceCreationTime, &pFile->m_ftSourceLastAccessTime, &pFile->m_ftSourceLastWriteTime))
{
::ReportFailure("Failed call to SetFileTime on file \"%ls\"\n", static_cast<PCWSTR>(buffDestination));
goto Exit;
}
::CloseHandle(hFile);
hFile = INVALID_HANDLE_VALUE;
}
if (!l.Lock())
{
::ReportFailure("Failed to lock global critical section\n");
goto Exit;
}
g_FilesCopied++;
g_FileCopiesProcessed++;
g_BytesCopied += pFile->m_cbSize;
l.Unlock();
}
else
{
if (g_fAnnounceSkips)
::printf("Skipping copy from \"%ls\" to \"%ls\"\n", static_cast<PCWSTR>(buffSource), static_cast<PCWSTR>(buffDestination));
if (!l.Lock())
{
::ReportFailure("Failed to lock global critical section\n");
goto Exit;
}
g_CopiesSkipped++;
g_FileCopiesProcessed++;
l.Unlock();
}
fSuccess = TRUE;
Exit:
if (hFile != INVALID_HANDLE_VALUE)
{
CSxsPreserveLastError ple;
::CloseHandle(hFile);
ple.Restore();
}
if (::GetLastError() == ERROR_TOO_MANY_OPEN_FILES)
{
rfReQueue = true;
fSuccess = TRUE;
}
return fSuccess;
}
BOOL
ProcessFileLink(
CFileLink *pFile,
bool &rfReQueue
)
{
BOOL fSuccess = FALSE;
FN_TRACE_WIN32(fSuccess);
CSxsLockCriticalSection l(g_cs);
bool fDoLink = true;
CStringBuffer buffSource, buffDestination;
WIN32_FILE_ATTRIBUTE_DATA wfad;
rfReQueue = false;
IFW32FALSE_EXIT(pFile->GetSource(buffSource));
IFW32FALSE_EXIT(pFile->GetDestination(buffDestination));
// CreateHardLinkW() doesn't deal with replace-existing like copyfile, so we'll see if a
// file by that name is already present and if so, delete it.
if (!::GetFileAttributesExW(buffDestination, GetFileExInfoStandard, &wfad))
{
// It failed. But did it fail for the right reason?
DWORD dwLastError = ::GetLastError();
if (dwLastError != ERROR_FILE_NOT_FOUND)
{
::ReportFailure("Error probing destination for \"%ls\"\n", static_cast<PCWSTR>(buffDestination));
goto Exit;
}
}
else
{
ULONGLONG cbFileSize = (wfad.nFileSizeHigh << 32) | wfad.nFileSizeLow;
ASSERT_NTC(cbFileSize >= wfad.nFileSizeLow);
if ((pFile->m_cbSize == cbFileSize) &&
(pFile->m_ftSourceCreationTime == wfad.ftCreationTime))
{
fDoLink = false;
pFile->m_fSkipped = true;
}
else
{
if (g_fAnnounceDeletes)
::printf("Deleting file \"%ls\" in preparation for hard link creation\n", static_cast<PCWSTR>(buffDestination));
if (!::DeleteFileW(buffDestination))
{
::ReportFailure("Error deleting destination \"%ls\" in preparation of hard link creation\n", static_cast<PCWSTR>(buffDestination));
goto Exit;
}
}
}
if (fDoLink)
{
if (g_fAnnounceLinks)
::printf("Creating hard link from \"%ls\" to \"%ls\"\n", static_cast<PCWSTR>(buffDestination), static_cast<PCWSTR>(buffSource));
// Hey, it's already there. Let's link it.
if (!::CreateHardLinkW(buffDestination, buffSource, NULL))
{
::ReportFailure("Error creating hard link from \"%ls\" to \"%ls\"\n", static_cast<PCWSTR>(buffDestination), static_cast<PCWSTR>(buffSource));
goto Exit;
}
if (!l.Lock())
{
::ReportFailure("Failed to lock global critical section\n");
goto Exit;
}
g_FilesLinked++;
g_FileLinksProcessed++;
l.Unlock();
}
else
{
if (g_fAnnounceSkips)
::printf("Skipping hard link creation from \"%ls\" to \"%ls\"\n", static_cast<PCWSTR>(buffDestination), static_cast<PCWSTR>(buffSource));
if (!l.Lock())
{
::ReportFailure("Failed to lock global critical section\n");
goto Exit;
}
g_LinksSkipped++;
g_FileLinksProcessed++;
l.Unlock();
}
fSuccess = TRUE;
Exit:
if (::GetLastError() == ERROR_TOO_MANY_OPEN_FILES)
{
rfReQueue = true;
fSuccess = TRUE;
}
return fSuccess;
}
BOOL
MyCopyFile(
BYTE *pBuffer,
DWORD cbBuffer,
PCWSTR lpExistingFileName,
PCWSTR lpNewFileName,
BOOL fFailIfExists,
HANDLE &rhFile
)
{
BOOL fSuccess = FALSE;
FN_TRACE_WIN32(fSuccess);
LARGE_INTEGER liFileSize;
rhFile = INVALID_HANDLE_VALUE;
HANDLE hIn = INVALID_HANDLE_VALUE, hOut = INVALID_HANDLE_VALUE;
hIn = ::CreateFileW(lpExistingFileName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN, NULL);
if (hIn == INVALID_HANDLE_VALUE)
{
::ReportFailure("Failed to open input file \"%ls\"\n", lpExistingFileName);
goto Exit;
}
hOut = ::CreateFileW(lpNewFileName, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_FLAG_NO_BUFFERING, NULL);
if (hOut == INVALID_HANDLE_VALUE)
{
::ReportFailure("Failed to open output file \"%ls\"\n", lpNewFileName);
goto Exit;
}
liFileSize.QuadPart = 0;
// let the games begin...
for (;;)
{
DWORD dwBytesRead, dwBytesWritten;
DWORD dwBytesToWrite = 0;
if (!::ReadFile(hIn, pBuffer, cbBuffer, &dwBytesRead, NULL))
{
::ReportFailure("Error reading from file \"%ls\"\n", lpExistingFileName);
goto Exit;
}
if (dwBytesRead == 0)
break;
liFileSize.QuadPart += dwBytesRead;
if (dwBytesRead != cbBuffer)
{
// We have to round to the cluster size for the write...
dwBytesToWrite = dwBytesRead + (g_dwDestinationBytesPerSector - 1);
dwBytesToWrite -= (dwBytesToWrite % g_dwDestinationBytesPerSector);
}
else
dwBytesToWrite = dwBytesRead;
if (!::WriteFile(hOut, pBuffer, dwBytesToWrite, &dwBytesWritten, NULL))
{
::ReportFailure("Error writing to file \"%ls\"\n", lpNewFileName);
goto Exit;
}
}
// If the file size wasn't a multiple of the sector size, we need to open the
// file without the unbuffered flag so that we can set its size to the exact
// correct byte count.
if ((liFileSize.QuadPart % g_dwDestinationBytesPerSector) != 0)
{
::CloseHandle(hOut);
hOut = INVALID_HANDLE_VALUE;
hOut = ::CreateFileW(lpNewFileName, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
if (hOut == INVALID_HANDLE_VALUE)
{
::ReportFailure("Unable to reopen output file \"%ls\"\n", lpNewFileName);
goto Exit;
}
// Truncate the file appropriately
if (!::MySetFilePointerEx(hOut, liFileSize, NULL, FILE_BEGIN))
{
::ReportFailure("Error setting file pointer on file \"%ls\"\n", lpNewFileName);
goto Exit;
}
if (!::SetEndOfFile(hOut))
{
::ReportFailure("Error setting end of file on file \"%ls\"\n", lpNewFileName);
goto Exit;
}
}
::CloseHandle(hIn);
hIn = INVALID_HANDLE_VALUE;
// Pass the handle back out and set it to INVALID_HANDLE_VALUE so that we don't
// try to close it in the exit path.
rhFile = hOut;
hOut = INVALID_HANDLE_VALUE;
fSuccess = TRUE;
Exit:
if (hIn != INVALID_HANDLE_VALUE)
{
CSxsPreserveLastError ple;
::CloseHandle(hIn);
ple.Restore();
}
if (hOut != INVALID_HANDLE_VALUE)
{
CSxsPreserveLastError ple;
::CloseHandle(hOut);
ple.Restore();
}
return fSuccess;
}