1268 lines
38 KiB
C++
1268 lines
38 KiB
C++
//+-------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1996 - 1996.
|
|
//
|
|
// File: ftc.cxx
|
|
//
|
|
// Contents: Fast multi-threaded tree copy program.
|
|
//
|
|
// History: ?-?-94 IsaacHe Created
|
|
// 11-Jun-96 BruceFo Fixed bugs, put this header here.
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
#if defined( UNICODE )
|
|
#undef UNICODE
|
|
#endif
|
|
|
|
#include <windows.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <malloc.h>
|
|
#include <direct.h>
|
|
#include <sys\types.h>
|
|
#include <sys\stat.h>
|
|
#include <io.h>
|
|
#include <conio.h>
|
|
#include <errno.h>
|
|
#include <process.h>
|
|
#include <ctype.h>
|
|
|
|
#define MAXQUEUE 10000
|
|
#define ARRAYLEN(x) (sizeof(x) / sizeof((x)[0]))
|
|
|
|
/*
|
|
* These are the attributes we use to compare for file attribute identity
|
|
*/
|
|
const DWORD FILE_ATTRIBUTE_MASK = FILE_ATTRIBUTE_READONLY |
|
|
FILE_ATTRIBUTE_HIDDEN |
|
|
FILE_ATTRIBUTE_SYSTEM |
|
|
FILE_ATTRIBUTE_ARCHIVE;
|
|
|
|
class CProtectedLong
|
|
{
|
|
CRITICAL_SECTION _cs;
|
|
LONG _value;
|
|
|
|
public:
|
|
CProtectedLong() { InitializeCriticalSection( &_cs ); _value = 0; }
|
|
LONG operator++(int) {
|
|
EnterCriticalSection( &_cs );
|
|
LONG tmp = _value++;
|
|
LeaveCriticalSection( &_cs );
|
|
return tmp;
|
|
}
|
|
LONG operator--( int ) {
|
|
EnterCriticalSection( &_cs );
|
|
LONG tmp = _value--;
|
|
LeaveCriticalSection( &_cs );
|
|
return tmp;
|
|
}
|
|
LONG operator+=( LONG incr ) {
|
|
EnterCriticalSection( &_cs );
|
|
LONG tmp = (_value += incr );
|
|
LeaveCriticalSection( &_cs );
|
|
return tmp;
|
|
}
|
|
LONG operator=( LONG val ) {
|
|
EnterCriticalSection( &_cs );
|
|
_value = val;
|
|
LeaveCriticalSection( &_cs );
|
|
return val;
|
|
}
|
|
operator LONG() { return _value; }
|
|
operator int() { return _value; }
|
|
};
|
|
|
|
class CHandle
|
|
{
|
|
HANDLE _h;
|
|
|
|
public:
|
|
CHandle() : _h(INVALID_HANDLE_VALUE) { }
|
|
~CHandle();
|
|
HANDLE operator=( HANDLE h );
|
|
BOOL operator==( HANDLE h ) { return (h == _h) ? TRUE : FALSE; }
|
|
BOOL operator!=( HANDLE h ) { return (h != _h) ? TRUE : FALSE; }
|
|
operator HANDLE() { return _h; }
|
|
};
|
|
|
|
CHandle::~CHandle()
|
|
{
|
|
if( _h != INVALID_HANDLE_VALUE && _h != NULL )
|
|
CloseHandle( _h );
|
|
}
|
|
|
|
HANDLE
|
|
CHandle::operator=( HANDLE h )
|
|
{
|
|
if( _h != INVALID_HANDLE_VALUE && _h != NULL )
|
|
CloseHandle( _h );
|
|
return _h = h;
|
|
}
|
|
|
|
DWORD dwElapsedTime; // time we've been copying data
|
|
CProtectedLong ulTotalBytesCopied; // running total count of bytes
|
|
CProtectedLong ulTotalBytesSkipped; // obvious?
|
|
CProtectedLong ulTotalBytesScanned;
|
|
CProtectedLong nFilesOnQueue; // number of files to copy or examine
|
|
CProtectedLong nFcopy; // number of files copied
|
|
CProtectedLong nSkipped; // number of files skipped over
|
|
CProtectedLong nMappedCopy; // number of files copied using MapFile...
|
|
CProtectedLong nCopyFile; // number of files copied using CopyFile()...
|
|
CProtectedLong nInProgress; // number of copies currently in progress
|
|
CProtectedLong MaxThreads; // Max number of threads for copying
|
|
DWORD ExitCode = 0; // each thread's exit code
|
|
|
|
BOOL bThreadStop = FALSE; // are we trying to exit?
|
|
BOOL bWorkListComplete = FALSE; // have we scanned all the directories yet?
|
|
|
|
BOOL tFlag = FALSE; // only copy if newer
|
|
BOOL iFlag = FALSE; // skip seemingly identical files
|
|
BOOL rFlag = FALSE; // replace read-only files
|
|
BOOL vFlag = FALSE; // verbose
|
|
BOOL AFlag = FALSE; // keep going even if there are errors
|
|
BOOL FFlag = FALSE; // just produce file list. No copies
|
|
BOOL oFlag = TRUE; // should we overwrite files already at dest?
|
|
BOOL wFlag = FALSE; // should we wait for the source to show up?
|
|
BOOL qFlag = FALSE; // quiet mode?
|
|
BOOL yFlag = FALSE; // no recurse on target?
|
|
BOOL zFlag = FALSE; // no recurse on source?
|
|
|
|
BOOL pFlag = FALSE; // pattern?
|
|
CHAR szPattern[100]; // pattern string, if pFlag is TRUE
|
|
|
|
struct WorkList // copy file at 'src' to 'dest'
|
|
{
|
|
struct WorkList *next;
|
|
char *src; // Pathname relative to the source
|
|
WIN32_FIND_DATA srcfind;
|
|
char *dest;
|
|
} *WorkList = NULL;
|
|
struct WorkList* WorkListTail = NULL; // always add files to copy to the *tail*
|
|
// of the work list. This is to make
|
|
// sure we always do work in order, instead
|
|
// of starting on a directory but finishing
|
|
// it much much much later, because we've
|
|
// pushed all the work to the deep tail of
|
|
// the list and never returned to it!
|
|
|
|
CHandle hWorkAvailSem; // signalled whenever there's work on the list
|
|
CHandle hMaxWorkQueueSem; // used to control lenght of work queue
|
|
|
|
CRITICAL_SECTION csMsg; // used to serialize screen output
|
|
CRITICAL_SECTION csWorkList; // used when manipulating the linked list
|
|
CRITICAL_SECTION csSourceList; // used when manipulating the source list
|
|
|
|
struct SourceList
|
|
{
|
|
char *name; // pathname of the source. Ends in '\'
|
|
LONG count; // number of files currently being copied
|
|
LONG ulTotalFiles; // total for the entire copy
|
|
struct {
|
|
unsigned valid : 1; // do we know that the source is valid?
|
|
} flags;
|
|
} SourceList[ 20 ];
|
|
int MaxSources = 0;
|
|
|
|
char *DirectoryExcludeList[ 50 ];
|
|
int MaxDirectoryExcludes = 0;
|
|
|
|
char OldConsoleTitle[ 100 ];
|
|
|
|
void
|
|
__cdecl
|
|
errormsg( char const *pszfmt, ... )
|
|
{
|
|
va_list ArgList;
|
|
va_start( ArgList, pszfmt );
|
|
|
|
if( bThreadStop == FALSE && pszfmt != NULL ) {
|
|
EnterCriticalSection( &csMsg );
|
|
vprintf( pszfmt, ArgList );
|
|
LeaveCriticalSection( &csMsg );
|
|
}
|
|
|
|
va_end( ArgList );
|
|
}
|
|
|
|
DWORD __stdcall
|
|
StatusWorker( void *arg )
|
|
{
|
|
char ostatbuf[ 100 ];
|
|
char nstatbuf[ 100 ];
|
|
|
|
while( bThreadStop == FALSE ) {
|
|
ULONG Remaining = (int)ulTotalBytesScanned - (int)ulTotalBytesCopied - (int)ulTotalBytesSkipped;
|
|
if (Remaining < 1000) {
|
|
sprintf(nstatbuf,
|
|
"Remaining Files %d Bytes %d",
|
|
(int)nFilesOnQueue,
|
|
Remaining);
|
|
} else if (Remaining < 1000000) {
|
|
sprintf(nstatbuf,
|
|
"Remaining Files %d Bytes %d,%03.3d",
|
|
(int)nFilesOnQueue,
|
|
Remaining / 1000,
|
|
Remaining % 1000);
|
|
} else if (Remaining < 1000000000) {
|
|
sprintf(nstatbuf,
|
|
"Remaining Files %d Bytes %d,%03.3d,%03.3d",
|
|
(int)nFilesOnQueue,
|
|
Remaining / 1000000,
|
|
(Remaining / 1000) % 1000,
|
|
Remaining % 1000,
|
|
Remaining);
|
|
} else {
|
|
sprintf(nstatbuf,
|
|
"Remaining Files %d Bytes %d,%03.3d,%03.3d,%03.3d",
|
|
(int)nFilesOnQueue,
|
|
Remaining / 1000000000,
|
|
(Remaining / 1000000) % 1000,
|
|
(Remaining / 1000) % 1000,
|
|
Remaining % 1000);
|
|
}
|
|
|
|
if( strcmp( ostatbuf, nstatbuf ) ) {
|
|
SetConsoleTitle( nstatbuf );
|
|
strcpy( ostatbuf, nstatbuf );
|
|
}
|
|
Sleep( 1 * 1000 );
|
|
}
|
|
|
|
SetConsoleTitle( OldConsoleTitle );
|
|
ExitThread( ExitCode );
|
|
arg = arg;
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
__cdecl
|
|
msg( char const *pszfmt, ... )
|
|
{
|
|
if( qFlag )
|
|
return;
|
|
|
|
va_list ArgList;
|
|
va_start( ArgList, pszfmt );
|
|
|
|
EnterCriticalSection( &csMsg );
|
|
vprintf( pszfmt, ArgList );
|
|
LeaveCriticalSection( &csMsg );
|
|
va_end( ArgList );
|
|
}
|
|
|
|
void
|
|
__cdecl
|
|
errorexit (char const *pszfmt, ... )
|
|
{
|
|
|
|
if( bThreadStop == FALSE && pszfmt != NULL ) {
|
|
va_list ArgList;
|
|
va_start( ArgList, pszfmt );
|
|
|
|
EnterCriticalSection( &csMsg );
|
|
vprintf( pszfmt, ArgList );
|
|
LeaveCriticalSection( &csMsg );
|
|
|
|
va_end( ArgList );
|
|
}
|
|
|
|
if( AFlag == FALSE ) {
|
|
bThreadStop = TRUE;
|
|
|
|
EnterCriticalSection( &csWorkList );
|
|
WorkList = NULL;
|
|
WorkListTail = NULL;
|
|
LeaveCriticalSection( &csWorkList );
|
|
|
|
if( hWorkAvailSem != NULL )
|
|
ReleaseSemaphore( hWorkAvailSem, (int)MaxThreads+1, NULL );
|
|
|
|
if( hMaxWorkQueueSem != NULL )
|
|
ReleaseSemaphore( hMaxWorkQueueSem, 1, NULL );
|
|
|
|
SetConsoleTitle( OldConsoleTitle );
|
|
ExitThread (ExitCode = 1);
|
|
}
|
|
}
|
|
|
|
DWORD
|
|
fcopy( char *src, WIN32_FIND_DATA *srcfind, char *dst, char *errorbuf )
|
|
{
|
|
CHandle srcfh;
|
|
CHandle dstfh;
|
|
CHandle hsrc;
|
|
DWORD nBytesWritten, totalbytes;
|
|
char *result = NULL;
|
|
char *psrc;
|
|
BOOL ret = TRUE;
|
|
char dostatus = 0;
|
|
DWORD errcode;
|
|
|
|
*errorbuf = '\0';
|
|
|
|
if( srcfind->nFileSizeHigh != 0 ) {
|
|
if( CopyFile( src, dst, TRUE ) == FALSE ) {
|
|
errcode = GetLastError();
|
|
sprintf( errorbuf, "CopyFile failed, error %d", errcode );
|
|
return errcode;
|
|
}
|
|
nCopyFile++;
|
|
|
|
} else {
|
|
|
|
srcfh = CreateFile( src, GENERIC_READ, FILE_SHARE_READ, NULL,
|
|
OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN, NULL );
|
|
if( srcfh == INVALID_HANDLE_VALUE ) {
|
|
errcode = GetLastError();
|
|
sprintf( errorbuf, "Unable to open source file, error %d", errcode);
|
|
return errcode;
|
|
}
|
|
|
|
dstfh = CreateFile( dst, GENERIC_WRITE, FILE_SHARE_WRITE,NULL,
|
|
CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, srcfh);
|
|
|
|
if( dstfh == INVALID_HANDLE_VALUE ) {
|
|
errcode = GetLastError();
|
|
sprintf( errorbuf, "Unable to create dest file, error %d", errcode);
|
|
return errcode;
|
|
}
|
|
|
|
if( srcfind->nFileSizeLow != 0 ) {
|
|
hsrc = CreateFileMapping( srcfh, NULL, PAGE_READONLY, 0,
|
|
srcfind->nFileSizeLow, NULL );
|
|
if( hsrc == NULL ) {
|
|
dstfh = INVALID_HANDLE_VALUE;
|
|
DeleteFile( dst );
|
|
if( CopyFile( src, dst, TRUE ) == FALSE ) {
|
|
errcode = GetLastError();
|
|
sprintf( errorbuf, "Unable to create file mapping, and CopyFile failed, error %d", errcode );
|
|
return errcode;
|
|
}
|
|
nCopyFile++;
|
|
ulTotalBytesCopied += srcfind->nFileSizeLow;
|
|
goto DoTime;
|
|
}
|
|
if( (psrc = (char *)MapViewOfFile( hsrc, FILE_MAP_READ, 0, 0, 0 )) == NULL){
|
|
dstfh = INVALID_HANDLE_VALUE;
|
|
DeleteFile( dst );
|
|
if( CopyFile( src, dst, TRUE ) == FALSE ) {
|
|
errcode = GetLastError();
|
|
sprintf( errorbuf, "Unable to map source file, and CopyFile failed: error %d", errcode );
|
|
return errcode;
|
|
}
|
|
nCopyFile++;
|
|
ulTotalBytesCopied += srcfind->nFileSizeLow;
|
|
goto DoTime;
|
|
}
|
|
totalbytes = 0;
|
|
while( !bThreadStop && totalbytes < srcfind->nFileSizeLow && ret == TRUE ) {
|
|
ret = WriteFile( dstfh,
|
|
psrc + totalbytes,
|
|
min( 64*1024, srcfind->nFileSizeLow - totalbytes ),
|
|
&nBytesWritten, NULL );
|
|
totalbytes += nBytesWritten;
|
|
ulTotalBytesCopied += nBytesWritten;
|
|
}
|
|
errcode = GetLastError();
|
|
UnmapViewOfFile( psrc );
|
|
|
|
if( bThreadStop == TRUE ) {
|
|
dstfh = INVALID_HANDLE_VALUE;
|
|
DeleteFile( dst );
|
|
*errorbuf = '\0';
|
|
return errcode;
|
|
}
|
|
|
|
if( ret == FALSE ) {
|
|
dstfh = INVALID_HANDLE_VALUE;
|
|
DeleteFile( dst );
|
|
if( CopyFile( src, dst, TRUE ) == FALSE ) {
|
|
errcode = GetLastError();
|
|
sprintf( errorbuf, "%s: CopyFile failed: error %d", dst, errcode);
|
|
return GetLastError();
|
|
}
|
|
nCopyFile++;
|
|
ulTotalBytesCopied += srcfind->nFileSizeLow;
|
|
goto DoTime;
|
|
}
|
|
|
|
nMappedCopy++;
|
|
}
|
|
}
|
|
|
|
DoTime:
|
|
if( dstfh == INVALID_HANDLE_VALUE ) {
|
|
dstfh = CreateFile( dst, GENERIC_WRITE,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING,
|
|
0, NULL );
|
|
}
|
|
|
|
if( dstfh == INVALID_HANDLE_VALUE ) {
|
|
errcode = GetLastError();
|
|
DeleteFile( dst );
|
|
sprintf( errorbuf, "Unable to open destination file to set time, error %d", errcode );
|
|
return errcode;
|
|
}
|
|
|
|
if( !SetFileTime( dstfh, &srcfind->ftCreationTime,
|
|
&srcfind->ftLastAccessTime, &srcfind->ftLastWriteTime )) {
|
|
errcode = GetLastError();
|
|
sprintf( errorbuf, "Unable to set destination file times, error %d\n", errcode );
|
|
return errcode;
|
|
}
|
|
|
|
nFcopy++;
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Pick the source having the fewest outstanding operations at the moment.
|
|
*/
|
|
int
|
|
SelectSource()
|
|
{
|
|
int index = -1;
|
|
struct SourceList *psl;
|
|
struct SourceList *opsl;
|
|
static min;
|
|
|
|
EnterCriticalSection( &csSourceList );
|
|
|
|
//
|
|
// Find the first valid source
|
|
//
|
|
for( opsl = SourceList; opsl < &SourceList[ MaxSources ]; opsl++ )
|
|
if( opsl->flags.valid == TRUE )
|
|
break;
|
|
|
|
//
|
|
// Now locate the source having the fewest pending operations right now
|
|
//
|
|
for( psl = opsl+1; psl < &SourceList[ MaxSources ]; psl++ ) {
|
|
if( psl->flags.valid == TRUE && psl->count < opsl->count )
|
|
opsl = psl;
|
|
}
|
|
|
|
if( opsl->flags.valid == TRUE ) {
|
|
opsl->count++;
|
|
index = (int)(opsl - SourceList);
|
|
}
|
|
|
|
LeaveCriticalSection( &csSourceList );
|
|
|
|
return index;
|
|
}
|
|
|
|
/*
|
|
* We've completed the operation on source 'index'
|
|
*/
|
|
void
|
|
SourceCopyComplete( int index, BOOL fFile )
|
|
{
|
|
EnterCriticalSection( &csSourceList );
|
|
SourceList[ index ].count--;
|
|
if (fFile) SourceList[ index ].ulTotalFiles++;
|
|
LeaveCriticalSection( &csSourceList );
|
|
}
|
|
|
|
void
|
|
DisableSource( int index )
|
|
{
|
|
if( index >= 0 && index < MaxSources ) {
|
|
EnterCriticalSection( &csSourceList );
|
|
if( SourceList[ index ].flags.valid == TRUE ) {
|
|
errormsg( "Disabling %s\n", SourceList[ index ].name );
|
|
SourceList[ index ].flags.valid = FALSE;
|
|
}
|
|
LeaveCriticalSection( &csSourceList );
|
|
}
|
|
}
|
|
BOOL
|
|
FileTimesEqual( CONST FILETIME *pt1, CONST FILETIME *pt2 )
|
|
{
|
|
SYSTEMTIME s1, s2;
|
|
|
|
if( !FileTimeToSystemTime( pt1, &s1 ) || !FileTimeToSystemTime( pt2, &s2 ) )
|
|
return FALSE;
|
|
|
|
return s1.wHour == s2.wHour &&
|
|
s1.wMinute == s2.wMinute &&
|
|
s1.wMonth == s2.wMonth &&
|
|
s1.wDay == s2.wDay &&
|
|
s1.wYear == s2.wYear;
|
|
}
|
|
void
|
|
PrintFileTime( char *str, CONST FILETIME *ft )
|
|
{
|
|
SYSTEMTIME st;
|
|
|
|
if( FileTimeToSystemTime( ft, &st ) == FALSE ) {
|
|
errormsg( "????\n" );
|
|
return;
|
|
}
|
|
|
|
msg( "%s %u:%u.%u.%u %u/%u/%u\n", str,
|
|
st.wHour, st.wMinute, st.wSecond, st.wMilliseconds,
|
|
st.wMonth, st.wDay, st.wYear );
|
|
}
|
|
|
|
DWORD __stdcall
|
|
ThreadWorker( void *arg )
|
|
{
|
|
struct WorkList *pdl = NULL;
|
|
HANDLE hdestfind;
|
|
WIN32_FIND_DATA destfind;
|
|
int index = 0;
|
|
char errorbuf[ 100 ];
|
|
char pathbuf[ MAX_PATH ];
|
|
DWORD errcode;
|
|
|
|
MaxThreads++;
|
|
|
|
while( 1 ) {
|
|
if( pdl != NULL ) {
|
|
free( pdl->src );
|
|
free( pdl->dest );
|
|
free( pdl );
|
|
pdl = NULL;
|
|
}
|
|
|
|
if( bThreadStop == TRUE )
|
|
break;
|
|
|
|
// Poll for new stuff every 2 seconds. If the thread is set to stop,
|
|
// then go away.
|
|
DWORD dwWait;
|
|
while( 1 )
|
|
{
|
|
dwWait = WaitForSingleObject( hWorkAvailSem, 1000 );
|
|
if( dwWait == WAIT_OBJECT_0 ) {
|
|
break;
|
|
}
|
|
|
|
if( dwWait == WAIT_TIMEOUT ) {
|
|
if( bThreadStop == TRUE )
|
|
break;
|
|
} else {
|
|
errormsg( "Thread %p: Semaphore wait failed\n", arg );
|
|
break;
|
|
}
|
|
}
|
|
if ( dwWait != WAIT_OBJECT_0 ) {
|
|
break;
|
|
}
|
|
|
|
// pick an item off the head of the work list
|
|
EnterCriticalSection( &csWorkList );
|
|
pdl = WorkList;
|
|
if( pdl != NULL ) {
|
|
WorkList = pdl->next;
|
|
if (NULL == WorkList) {
|
|
// just pulled off the tail entry
|
|
WorkListTail = NULL;
|
|
}
|
|
}
|
|
LeaveCriticalSection( &csWorkList );
|
|
ReleaseSemaphore( hMaxWorkQueueSem, 1, NULL );
|
|
|
|
if( pdl == NULL )
|
|
break;
|
|
|
|
nFilesOnQueue--;
|
|
|
|
if( pdl->srcfind.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ) {
|
|
errormsg( "Logic Error: Directory on work list!\n" );
|
|
continue;
|
|
}
|
|
|
|
pdl->srcfind.dwFileAttributes &= FILE_ATTRIBUTE_MASK;
|
|
|
|
hdestfind = FindFirstFile( pdl->dest, &destfind );
|
|
if( hdestfind != INVALID_HANDLE_VALUE ) {
|
|
FindClose( hdestfind );
|
|
destfind.dwFileAttributes &= FILE_ATTRIBUTE_MASK;
|
|
|
|
/*
|
|
* Destination file exists. What should we do?
|
|
*/
|
|
|
|
if( oFlag == FALSE ) {
|
|
/*
|
|
* We should not overwrite the existing file at the dest
|
|
*/
|
|
if( vFlag )
|
|
msg( "%s [SKIP: exists]\n", pdl->dest );
|
|
ulTotalBytesSkipped += destfind.nFileSizeLow;
|
|
nSkipped++;
|
|
continue;
|
|
}
|
|
|
|
if( iFlag && vFlag ) {
|
|
|
|
if( destfind.dwFileAttributes !=pdl->srcfind.dwFileAttributes)
|
|
msg( "%s [ ATTRIBUTES differ ]\n", pdl->dest );
|
|
if(!FileTimesEqual( &destfind.ftLastWriteTime, &pdl->srcfind.ftLastWriteTime)) {
|
|
EnterCriticalSection( &csMsg );
|
|
msg( "%s [ TIMES differ ]\n", pdl->dest );
|
|
PrintFileTime( "Dest: ", &destfind.ftLastWriteTime );
|
|
PrintFileTime( "Src: ", &pdl->srcfind.ftLastWriteTime );
|
|
LeaveCriticalSection( &csMsg );
|
|
}
|
|
if( (destfind.nFileSizeHigh != pdl->srcfind.nFileSizeHigh) ||
|
|
(destfind.nFileSizeLow != pdl->srcfind.nFileSizeLow) )
|
|
msg( "%s [ SIZES differ ]\n", pdl->dest );
|
|
}
|
|
|
|
if( iFlag &&
|
|
(destfind.dwFileAttributes == pdl->srcfind.dwFileAttributes) &&
|
|
FileTimesEqual( &destfind.ftLastWriteTime, &pdl->srcfind.ftLastWriteTime) &&
|
|
(destfind.nFileSizeHigh == pdl->srcfind.nFileSizeHigh) &&
|
|
(destfind.nFileSizeLow == pdl->srcfind.nFileSizeLow) ) {
|
|
if( vFlag )
|
|
msg("%s [SKIP: same atts, time, size]\n",pdl->dest);
|
|
ulTotalBytesSkipped += destfind.nFileSizeLow;
|
|
nSkipped++;
|
|
continue;
|
|
}
|
|
|
|
if( tFlag &&
|
|
CompareFileTime( &destfind.ftLastWriteTime, &pdl->srcfind.ftLastWriteTime) >= 0 ) {
|
|
if( vFlag )
|
|
msg("%s [SKIP: same or newer time]\n", pdl->dest );
|
|
ulTotalBytesSkipped += destfind.nFileSizeLow;
|
|
nSkipped++;
|
|
continue;
|
|
}
|
|
|
|
if( destfind.dwFileAttributes & FILE_ATTRIBUTE_READONLY )
|
|
if( rFlag == FALSE && bThreadStop == FALSE ) {
|
|
if( vFlag )
|
|
msg( "%s [SKIP: readonly]\n", pdl->dest );
|
|
ulTotalBytesSkipped += destfind.nFileSizeLow;
|
|
nSkipped++;
|
|
continue;
|
|
}
|
|
|
|
/*
|
|
* Delete the destination file
|
|
*/
|
|
if( destfind.dwFileAttributes & FILE_ATTRIBUTE_READONLY ) {
|
|
destfind.dwFileAttributes &= ~FILE_ATTRIBUTE_READONLY;
|
|
SetFileAttributes( pdl->dest, destfind.dwFileAttributes );
|
|
}
|
|
|
|
if( FFlag == FALSE )
|
|
(void)DeleteFile( pdl->dest );
|
|
|
|
}
|
|
|
|
if( FFlag == FALSE ) {
|
|
while( bThreadStop == FALSE && (index = SelectSource()) >= 0 ) {
|
|
strcpy( pathbuf, SourceList[index].name );
|
|
strcat( pathbuf, pdl->src );
|
|
|
|
nInProgress++;
|
|
errcode = fcopy( pathbuf,&pdl->srcfind,pdl->dest,errorbuf);
|
|
nInProgress--;
|
|
|
|
if( errcode == 0 ) {
|
|
SourceCopyComplete( index, TRUE );
|
|
msg("%s -> %s [OK]\n", pathbuf, pdl->dest );
|
|
SetFileAttributes(pdl->dest,pdl->srcfind.dwFileAttributes);
|
|
break;
|
|
}
|
|
|
|
if( errcode == ERROR_SWAPERROR ) {
|
|
errormsg( "%s [ SWAP ERROR, will try again... ]\n",pathbuf);
|
|
Sleep( 5 * 1000 * 60 );
|
|
continue;
|
|
}
|
|
if( bThreadStop == FALSE )
|
|
errormsg( "%s [FAILED: %s ]\n", pathbuf, errorbuf );
|
|
if( AFlag == TRUE )
|
|
break;
|
|
DisableSource( index );
|
|
}
|
|
} else {
|
|
msg( "%s\n", pdl->dest );
|
|
}
|
|
|
|
if( AFlag == FALSE && index < 0 )
|
|
errorexit( "%s [FAILED completely]\n", pdl->dest );
|
|
}
|
|
|
|
if( pdl != NULL ) {
|
|
free( pdl->src );
|
|
free( pdl->dest );
|
|
free( pdl );
|
|
}
|
|
|
|
if( MaxThreads-- == 1 ) {
|
|
if( ExitCode == 0 ) {
|
|
dwElapsedTime = GetTickCount() - dwElapsedTime;
|
|
dwElapsedTime /= 1000;
|
|
BOOL oldqFlag = qFlag;
|
|
qFlag = FALSE;
|
|
msg( "%u files copied (%u memory mappped, %u CopyFile )\n",
|
|
(int)nFcopy, (int)nMappedCopy, (int)nCopyFile );
|
|
msg( "%u files skipped\n", (int)nSkipped);
|
|
msg( "%lu bytes in %u seconds: %lu bits/sec\n",
|
|
(int)ulTotalBytesCopied, dwElapsedTime,
|
|
dwElapsedTime ? (LONG)(((LONG)ulTotalBytesCopied*8L)/dwElapsedTime) : 0L );
|
|
|
|
qFlag = oldqFlag;
|
|
EnterCriticalSection( &csSourceList );
|
|
for (int i = 0; i < MaxSources; i++)
|
|
{
|
|
if (TRUE == SourceList[i].flags.valid)
|
|
{
|
|
msg( "%s %5lu files\n", SourceList[i].name, SourceList[i].ulTotalFiles);
|
|
}
|
|
}
|
|
LeaveCriticalSection( &csSourceList );
|
|
}
|
|
SetConsoleTitle( OldConsoleTitle );
|
|
ExitProcess( ExitCode );
|
|
}
|
|
|
|
ExitThread( ExitCode );
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
AddToWorkList( char *src, char *dest, WIN32_FIND_DATA *pfind )
|
|
{
|
|
struct WorkList *pdl;
|
|
|
|
if( WaitForSingleObject( hMaxWorkQueueSem, INFINITE ) != WAIT_OBJECT_0 ) {
|
|
errormsg( "Semaphore wait failed, can't add to work list\n" );
|
|
return;
|
|
}
|
|
|
|
if( bThreadStop == TRUE )
|
|
return;
|
|
|
|
if( (pdl = (struct WorkList *)malloc( sizeof( struct WorkList ) ) ) == NULL ){
|
|
errorexit( "Out of Memory!\n" );
|
|
return;
|
|
}
|
|
|
|
if( (pdl->dest = _strdup( dest )) == NULL ) {
|
|
errorexit( "Out of memory!\n" );
|
|
free( pdl );
|
|
return;
|
|
}
|
|
|
|
if( (pdl->src = _strdup( src )) == NULL ) {
|
|
errorexit( "Out of memory!\n" );
|
|
free( pdl->dest );
|
|
free( pdl );
|
|
return;
|
|
}
|
|
|
|
pdl->srcfind = *pfind;
|
|
pdl->next = NULL;
|
|
|
|
EnterCriticalSection( &csWorkList );
|
|
if (NULL == WorkList) {
|
|
WorkListTail = WorkList = pdl;
|
|
} else {
|
|
WorkListTail->next = pdl; // point the tail to the new entry
|
|
WorkListTail = pdl; // the new entry becomes the tail
|
|
}
|
|
LeaveCriticalSection( &csWorkList );
|
|
|
|
nFilesOnQueue++;
|
|
ReleaseSemaphore( hWorkAvailSem, 1, NULL );
|
|
}
|
|
|
|
void
|
|
ScanDirectory(
|
|
char *relpath,
|
|
char *dest
|
|
);
|
|
|
|
void
|
|
ScanDirectoryHelp(
|
|
char *relpath, // path relative to the source
|
|
char *dest, // resulting destination directory
|
|
BOOL fOnlyDirectories, // TRUE if we only want to look for dirs
|
|
BOOL fOnlyFiles // TRUE if we only want to look for files
|
|
)
|
|
{
|
|
int index;
|
|
int destlen = strlen( dest );
|
|
int rellen = strlen( relpath );
|
|
WIN32_FIND_DATA fbuf;
|
|
HANDLE hfind = INVALID_HANDLE_VALUE;
|
|
char SourceName[ MAX_PATH ];
|
|
|
|
while( 1 ) {
|
|
if( (index = SelectSource()) < 0 )
|
|
return;
|
|
/*
|
|
* FindFirst/Next is such low overhead on the server that we shouldn't
|
|
* really count it as a load on the server...
|
|
*/
|
|
SourceCopyComplete( index, FALSE );
|
|
|
|
strcpy( SourceName, SourceList[ index ].name );
|
|
if( rellen ) {
|
|
strcat( SourceName, relpath );
|
|
strcat( SourceName, "\\" );
|
|
}
|
|
|
|
strcat( SourceName,
|
|
fOnlyDirectories
|
|
? "*.*"
|
|
: (pFlag ? szPattern : "*.*" ) );
|
|
|
|
hfind = FindFirstFile( SourceName, &fbuf );
|
|
if( hfind != INVALID_HANDLE_VALUE )
|
|
break;
|
|
|
|
if (pFlag && ERROR_FILE_NOT_FOUND == GetLastError()) {
|
|
// simply no files that match the pattern in the directory
|
|
return;
|
|
}
|
|
|
|
errormsg( "Dir scan of %s failed, error %d [DISABLING]\n", SourceName, GetLastError() );
|
|
DisableSource( index );
|
|
}
|
|
|
|
do {
|
|
if( !strcmp( fbuf.cFileName, "." ) || !strcmp( fbuf.cFileName, ".." ) )
|
|
continue;
|
|
|
|
sprintf( &dest[ destlen ], "%s%s",
|
|
dest[destlen-1] == '\\' ? "" : "\\", fbuf.cFileName );
|
|
|
|
if((fbuf.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0 ) {
|
|
//
|
|
// Not a directory
|
|
//
|
|
|
|
if (fOnlyDirectories) {
|
|
continue;
|
|
}
|
|
|
|
/*
|
|
* Queue this file into the work queue!
|
|
*/
|
|
if( rellen ) {
|
|
strcpy( SourceName, relpath );
|
|
strcat( SourceName, "\\" );
|
|
} else
|
|
SourceName[0] = '\0';
|
|
|
|
strcat( SourceName, fbuf.cFileName );
|
|
ulTotalBytesScanned += fbuf.nFileSizeLow;
|
|
AddToWorkList( SourceName, dest, &fbuf );
|
|
continue;
|
|
}
|
|
|
|
/*
|
|
* We've found a directory. Descend into it and scan (if we're
|
|
* not excluding it)
|
|
*/
|
|
|
|
if (fOnlyFiles) {
|
|
continue;
|
|
}
|
|
|
|
if (zFlag) { // no recurse on source: ignore it!
|
|
continue;
|
|
}
|
|
|
|
for( int i=0; i < MaxDirectoryExcludes; i++ )
|
|
if( !_stricmp( DirectoryExcludeList[i], fbuf.cFileName ) )
|
|
break;
|
|
|
|
if( i != MaxDirectoryExcludes ) {
|
|
if( vFlag )
|
|
msg( "Directory: %s [EXCLUDED]\n", dest );
|
|
nSkipped++;
|
|
continue;
|
|
}
|
|
|
|
sprintf( &relpath[ rellen ], "%s%s", rellen ? "\\":"", fbuf.cFileName );
|
|
if (yFlag) { // no recurse on target: nuke end of dest (the new dir)
|
|
dest[ destlen ] = '\0';
|
|
}
|
|
ScanDirectory( relpath, dest );
|
|
relpath[ rellen ] = '\0';
|
|
|
|
} while( !bThreadStop && FindNextFile( hfind, &fbuf ) == TRUE );
|
|
|
|
dest[ destlen ] = '\0';
|
|
|
|
FindClose( hfind );
|
|
}
|
|
|
|
void
|
|
ScanDirectory(
|
|
char *relpath, // path relative to the source
|
|
char *dest // resulting destination directory
|
|
)
|
|
{
|
|
DWORD dwattrs;
|
|
|
|
if( (dwattrs = GetFileAttributes( dest )) == 0xFFFFFFFF ) {
|
|
msg( "Creating Directory: %s\n", dest );
|
|
if( FFlag == FALSE && CreateDirectory( dest, NULL ) == FALSE ) {
|
|
errorexit( "Can not create directory: %s\n", dest );
|
|
return;
|
|
}
|
|
|
|
} else if( !(dwattrs & FILE_ATTRIBUTE_DIRECTORY) ) {
|
|
errorexit( "Not a directory: %s\n", dest );
|
|
return;
|
|
}
|
|
|
|
if (pFlag) {
|
|
// two passes: one looking for files, one looking for directories
|
|
|
|
ScanDirectoryHelp(relpath, dest, FALSE, TRUE);
|
|
ScanDirectoryHelp(relpath, dest, TRUE, FALSE);
|
|
} else {
|
|
ScanDirectoryHelp(relpath, dest, FALSE, FALSE);
|
|
}
|
|
}
|
|
|
|
static void
|
|
appendslash( char *p )
|
|
{
|
|
if( p[ strlen(p) - 1 ] != '\\' )
|
|
strcat( p, "\\" );
|
|
}
|
|
|
|
BOOL
|
|
rootpath( char *src, char *dst )
|
|
{
|
|
char* FilePart;
|
|
char *p;
|
|
|
|
if( src == NULL || *src == '\0' )
|
|
return FALSE;
|
|
|
|
if( GetFullPathName( src, MAX_PATH, dst, &FilePart ) == 0 )
|
|
return FALSE;
|
|
|
|
p = src + strlen(src) - 1;
|
|
if( *p == '.' )
|
|
if( p > src ) {
|
|
p--;
|
|
if( *p != '.' && *p != ':' && (*p == '\\' || *p == '/') )
|
|
strcat( dst, "." );
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
Usage( char *s )
|
|
{
|
|
errormsg( "Usage: %s [flags] [-p pattern] [src ...] dest\n", s );
|
|
errormsg( "Flags:\n" );
|
|
|
|
errormsg( "\t-i Skip seemingly identical files (time, attrs, size agree)\n" );
|
|
errormsg( "\t-l Execute at lower priority\n" );
|
|
errormsg( "\t-o Do not overwrite any files that are already at dest\n" );
|
|
errormsg( "\t-p pattern Only files matching the pattern are copied\n" );
|
|
errormsg( "\t-q Quiet mode\n" );
|
|
errormsg( "\t-r Overwrite read-only files at dest\n" );
|
|
errormsg( "\t-t Copy only newer files to dest\n" );
|
|
errormsg( "\t-v Verbose\n" );
|
|
errormsg( "\t-y Don't recurse on target\n" );
|
|
errormsg( "\t-z Don't recurse on source\n" );
|
|
errormsg( "\t-A Keep going even if there are errors\n" );
|
|
errormsg( "\t-F Don't actually copy files or create directories\n" );
|
|
errormsg( "\t~dir Skip any directory named 'dir'\n" );
|
|
errormsg( "\nIf environment variable FTC_PARANOID is set, then the meaning of -o is\n" );
|
|
errormsg( "reversed: no -o means don't overwrite, -o means go ahead and overwrite.\n" );
|
|
|
|
errormsg( "\nExamples:\n" );
|
|
errormsg( " Copy from two sources, no 'obj' dir: ftc ~obj \\\\foo\\dir \\\\bar\\dir dest\n" );
|
|
ExitProcess( 1 );
|
|
}
|
|
|
|
BOOL __stdcall
|
|
ControlHandlerRoutine( DWORD dwCtrlType )
|
|
{
|
|
msg( "Interrupted!\n" );
|
|
bThreadStop = TRUE;
|
|
ExitCode = 1;
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
int
|
|
__cdecl
|
|
main(int argc, char *argv[])
|
|
{
|
|
char *p;
|
|
SECURITY_ATTRIBUTES sa;
|
|
int i, argno;
|
|
DWORD IDThread;
|
|
char dest[ MAX_PATH ];
|
|
char relpath[ MAX_PATH ];
|
|
BOOL lFlag = FALSE; // low priority?
|
|
BOOL fParanoid = FALSE; // is FTC_PARANOID set in the environment?
|
|
SYSTEM_INFO si;
|
|
CHandle CThread;
|
|
|
|
InitializeCriticalSection( &csMsg );
|
|
InitializeCriticalSection( &csWorkList );
|
|
InitializeCriticalSection( &csSourceList );
|
|
ZeroMemory(&si, sizeof( si ));
|
|
GetConsoleTitle( OldConsoleTitle, sizeof( OldConsoleTitle ) );
|
|
|
|
TCHAR szParanoid[100];
|
|
DWORD len = GetEnvironmentVariable(TEXT("FTC_PARANOID"), szParanoid, ARRAYLEN(szParanoid));
|
|
if (len > 0)
|
|
{
|
|
fParanoid = TRUE;
|
|
}
|
|
|
|
if (fParanoid)
|
|
{
|
|
oFlag = FALSE;
|
|
}
|
|
else
|
|
{
|
|
oFlag = TRUE;
|
|
}
|
|
|
|
for( argno = 1;
|
|
argno < argc && (argv[argno][0] == '-' || argv[argno][0] == '/' || argv[argno][0] == '~') ;
|
|
argno++ )
|
|
{
|
|
if( argv[argno][0] == '~' )
|
|
{
|
|
DirectoryExcludeList[ MaxDirectoryExcludes++ ] = &argv[argno][1];
|
|
|
|
}
|
|
else for( int j=1; argv[argno][j]; j++ )
|
|
{
|
|
switch( argv[argno][j] ) {
|
|
case 'l':
|
|
lFlag = TRUE;
|
|
break;
|
|
case 'q':
|
|
qFlag = TRUE;
|
|
break;
|
|
case 'y':
|
|
yFlag = TRUE;
|
|
break;
|
|
case 'z':
|
|
zFlag = TRUE;
|
|
break;
|
|
case 'w':
|
|
wFlag = TRUE;
|
|
break;
|
|
case 'o':
|
|
if (fParanoid)
|
|
{
|
|
oFlag = TRUE;
|
|
}
|
|
else
|
|
{
|
|
oFlag = FALSE;
|
|
}
|
|
break;
|
|
case 'F':
|
|
FFlag = TRUE;
|
|
break;
|
|
case 'A':
|
|
AFlag = TRUE;
|
|
break;
|
|
case 'p':
|
|
if( j == 1 ) {
|
|
if ( strcmp( &argv[argno][j], "p" ) == 0 ) {
|
|
if (argno + 1 < argc) {
|
|
pFlag = TRUE;
|
|
strcpy( szPattern, argv[++argno] );
|
|
goto nextarg; // go to next argument
|
|
} else Usage( argv[0] );
|
|
} else Usage( argv[0] );
|
|
} else Usage( argv[0] );
|
|
break;
|
|
case 'v':
|
|
vFlag = TRUE;
|
|
break;
|
|
case 'r':
|
|
rFlag = TRUE;
|
|
break;
|
|
case 'i':
|
|
iFlag = TRUE;
|
|
break;
|
|
case 't':
|
|
tFlag = TRUE;
|
|
break;
|
|
default:
|
|
case '?':
|
|
Usage( argv[0] );
|
|
break;
|
|
|
|
}
|
|
}
|
|
|
|
nextarg:
|
|
;
|
|
|
|
}
|
|
|
|
for( ; argno < argc-1; argno++ ) {
|
|
if( rootpath( argv[argno], dest ) == FALSE ) {
|
|
errorexit( "invalid source\n" );
|
|
ExitProcess(1);
|
|
}
|
|
for( p = dest; *p; p++ )
|
|
if( *p == '/' )
|
|
*p = '\\';
|
|
if( (SourceList[ MaxSources ].name = (char *)malloc( strlen( dest ) + 2 )) == NULL ) {
|
|
errorexit( "Out of memory!\n" );
|
|
ExitProcess(1);
|
|
}
|
|
strcpy( SourceList[ MaxSources++ ].name, dest );
|
|
}
|
|
|
|
if( MaxSources == 0 )
|
|
Usage( argv[0] );
|
|
|
|
for( i=0; i < MaxDirectoryExcludes; i++ )
|
|
msg( "Exclude Directory: %s\n", DirectoryExcludeList[i] );
|
|
|
|
while( 1 ) {
|
|
char statusbuffer[ MAX_PATH ];
|
|
|
|
for( i=0; i < MaxSources; i++ ) {
|
|
appendslash( SourceList[i].name );
|
|
if( vFlag == TRUE || wFlag == FALSE )
|
|
msg( "Validating %s....", SourceList[i].name );
|
|
sprintf( statusbuffer, "Validating %s", SourceList[i].name );
|
|
SetConsoleTitle( statusbuffer );
|
|
if( GetFileAttributes( SourceList[i].name ) == 0xFFFFFFFF ) {
|
|
if( vFlag == TRUE || wFlag == FALSE )
|
|
msg( "[DISABLING %s]\n", SourceList[i].name );
|
|
SourceList[i].flags.valid = FALSE;
|
|
} else {
|
|
SourceList[i].flags.valid = TRUE;
|
|
if( vFlag == TRUE || wFlag == FALSE )
|
|
msg( "[OK]\n" );
|
|
}
|
|
}
|
|
|
|
for( i=0; i < MaxSources; i++ )
|
|
if( SourceList[i].flags.valid == TRUE )
|
|
break;
|
|
|
|
if( i != MaxSources )
|
|
break;
|
|
|
|
if( wFlag == TRUE ) {
|
|
SetConsoleTitle( "Sleeping awhile..." );
|
|
Sleep( 3 * 1000 * 60 );
|
|
} else {
|
|
SetConsoleTitle( OldConsoleTitle );
|
|
ExitProcess(1);
|
|
}
|
|
}
|
|
|
|
SetConsoleTitle( "Sources Present" );
|
|
LONG cThreads = (MaxSources * 3) + 1;
|
|
|
|
/*
|
|
* hack for ftc -w -678 to exit when the release shares are available
|
|
*/
|
|
if( argno == argc && wFlag )
|
|
ExitProcess( 0 );
|
|
|
|
if ( argno != argc - 1 ) {
|
|
Usage( argv[0] );
|
|
} else if (rootpath (argv[argno], dest) == FALSE ) {
|
|
errorexit( "Invalid destination\n" );
|
|
ExitProcess(1);
|
|
}
|
|
|
|
for( p = dest; *p; p++ )
|
|
if( *p == '/' )
|
|
*p = '\\';
|
|
|
|
for( i=0; i < MaxSources; i++ )
|
|
if (!strcmp(SourceList[i].name, dest)) {
|
|
errorexit("Source == dest == %s", SourceList[i].name );
|
|
ExitThread(1);
|
|
}
|
|
|
|
/*
|
|
* Create the semaphores for the work lists
|
|
*/
|
|
sa.nLength = sizeof( sa );
|
|
sa.lpSecurityDescriptor = NULL;
|
|
sa.bInheritHandle = TRUE;
|
|
if( (hWorkAvailSem = CreateSemaphore( &sa, 0, 100000, NULL)) == NULL ) {
|
|
errorexit( "Unable to create semaphore (err %u)!\n", GetLastError() );
|
|
ExitProcess(1);
|
|
}
|
|
|
|
hMaxWorkQueueSem = CreateSemaphore( &sa, MAXQUEUE, MAXQUEUE, NULL );
|
|
if( hMaxWorkQueueSem == NULL ) {
|
|
errorexit( "Unable to create queue length semaphore (err %u)!\n", GetLastError() );
|
|
ExitProcess( 1 );
|
|
}
|
|
|
|
/*
|
|
* Create the thread pool to do the copies
|
|
*/
|
|
for( i=0; i < cThreads - 1; i++ ) {
|
|
CThread = CreateThread( (LPSECURITY_ATTRIBUTES)NULL, 0,
|
|
ThreadWorker, (LPVOID *)IntToPtr(i), 0, &IDThread );
|
|
if( CThread == NULL || CThread == INVALID_HANDLE_VALUE )
|
|
break;
|
|
SetThreadPriority( CThread, THREAD_PRIORITY_NORMAL );
|
|
CThread = INVALID_HANDLE_VALUE;
|
|
}
|
|
|
|
/*
|
|
* Create the 'update status' thread
|
|
*/
|
|
CThread = CreateThread( (LPSECURITY_ATTRIBUTES)NULL, 0,
|
|
StatusWorker,(LPVOID *)0,0,&IDThread );
|
|
if( CThread != NULL && CThread != INVALID_HANDLE_VALUE ) {
|
|
// SetThreadPriority( CThread, THREAD_PRIORITY_BELOW_NORMAL );
|
|
CThread = INVALID_HANDLE_VALUE;
|
|
}
|
|
|
|
SetConsoleCtrlHandler( ControlHandlerRoutine, TRUE );
|
|
|
|
/*
|
|
* Produce the directory list
|
|
*/
|
|
relpath[0] = '\0';
|
|
dwElapsedTime = GetTickCount();
|
|
|
|
SetThreadPriority( GetCurrentThread(), THREAD_PRIORITY_ABOVE_NORMAL );
|
|
ScanDirectory( relpath, dest );
|
|
|
|
if( lFlag )
|
|
SetPriorityClass( GetCurrentProcess(), IDLE_PRIORITY_CLASS );
|
|
|
|
SetThreadPriority( GetCurrentThread(), THREAD_PRIORITY_NORMAL );
|
|
|
|
// OK, now hWorkAvailSem has a count for every item to copy. But when they
|
|
// finish copying, each thread waits on this semaphore again. At the end,
|
|
// everyone will still be waiting! So, add the number of threads to the
|
|
// count, so each thread notices, one by one, that everything's done.
|
|
ReleaseSemaphore( hWorkAvailSem, (int)cThreads+1, NULL );
|
|
|
|
if( bThreadStop == FALSE )
|
|
ThreadWorker( 0 );
|
|
|
|
return ExitCode;
|
|
}
|