path: root/Src/Plugins/Library/ml_disc/copyfiles.cpp

#include "main.h"
#include "./copyfiles.h"
#include "./copyinternal.h"
#include "./resource.h"
#include "./settings.h"
#include "../nu/trace.h"
#include <api/service/waServiceFactory.h>
#include <shlwapi.h>
#include <strsafe.h>

static LONG szBusyDrive[26] = {0, };
static CRITICAL_SECTION	cs_copy = { 0,}; 

static void NotifyDialog(COPYDATA *pcd, UINT uTask, UINT uOperation, LPARAM lParam)
{
	if(pcd->hDialog) PostMessage(pcd->hDialog, CFM_NOTIFY, MAKEWPARAM(uTask, uOperation), lParam);
}

static INT_PTR QueryDialog(COPYDATA *pcd, UINT uTask, UINT uOperation, LPARAM lParam)
{
	return (pcd->hDialog) ? SendMessage(pcd->hDialog, CFM_NOTIFY, MAKEWPARAM(uTask, uOperation), lParam) : FALSE;
}

static void CopyFiles_MarkDrivesBusy(LPCTSTR *ppsz, INT count, BOOL bBusy)
{
	INT i, n;
	DWORD driveMask = 0x00;

	EnterCriticalSection(&cs_copy);
	if (bBusy)
	{
		for(i = 0; i < count; i++)
		{
			n = PathGetDriveNumber(ppsz[i]);
			if (-1 != n) 
			{
				if (0 == szBusyDrive[n]) driveMask |= (((DWORD)0x01) << n);
				szBusyDrive[n]++;
			}
		}
	}
	else
	{
		for(i = 0; i < count; i++)
		{
			n = PathGetDriveNumber(ppsz[i]);
			if (-1 != n) 
			{
				if (szBusyDrive[n] <= 0) continue;
				szBusyDrive[n]--;
				if (0 == szBusyDrive[n]) driveMask |= (((DWORD)0x01) << n);
			}
		}
	}
	LeaveCriticalSection(&cs_copy);

	if (0x00 != driveMask)
	{
		static UINT uMsgCopyNotify = 0;
		if (!uMsgCopyNotify) uMsgCopyNotify = RegisterWindowMessageA("WACOPY_BROADCAST_MSG");
		if (uMsgCopyNotify)
		{
			for (CHAR c = 'A'; 0x00 != driveMask; c++, driveMask>>=1)
			{
				if (0 == (0x01 & driveMask)) continue;
				if (bBusy) SendNotifyMessage(HWND_BROADCAST, uMsgCopyNotify, MAKEWPARAM(c, 0), (LPARAM)TRUE);
				else 
				{
					SendNotifyMessage(HWND_BROADCAST, uMsgCopyNotify, MAKEWPARAM(c, 0), (LPARAM)FALSE);
					SendNotifyMessage(HWND_BROADCAST, uMsgCopyNotify, MAKEWPARAM(0, 0xffff), (LPARAM)plugin.hwndWinampParent);
				}
			}
		}
	}
}
static BOOL ReadCopyParameters(COPYDATA *pcd)
{
	BOOL bVal;
	HRESULT hr = S_OK;
	pcd->uFlags = 0;
	if (S_OK == hr) hr = Settings_ReadString(C_COPY, CF_PATH, pcd->szDestination, ARRAYSIZE(pcd->szDestination));
	if (S_OK == hr) hr = Settings_ReadString(C_COPY, CF_TITLEFMT, pcd->szTitleFormat, ARRAYSIZE(pcd->szTitleFormat));
	if (S_OK == hr && S_OK == (hr = Settings_GetBool(C_COPY, CF_ADDTOMLDB, &bVal)) && bVal) pcd->uFlags |= FCF_ADDTOMLDB;
	if (S_OK == hr && S_OK == (hr = Settings_GetBool(C_COPY, CF_USETITLEFMT, &bVal)) && bVal) pcd->uFlags |= FCF_USETITLEFMT;
	CleanupDirectoryString(pcd->szDestination);

	return (S_OK == hr);

}

void MLDisc_InitializeCopyData()
{
	InitializeCriticalSection(&cs_copy);
}

void MLDisc_ReleaseCopyData()
{
	DeleteCriticalSection(&cs_copy);
}

BOOL MLDisc_IsDiscCopying(CHAR cLetter)
{
	if (cLetter >= 'a' && cLetter <= 'z') cLetter -= 0x20;
	return (cLetter >= 'A' && cLetter <= 'Z' && szBusyDrive[cLetter - 'A'] > 0);
}


BOOL MLDisc_CopyFiles(HWND hParent, LPWSTR *ppszFiles, ULONGLONG *pFSizes, INT count)
{
	if (!ppszFiles || !count) return FALSE;
	if (NULL == hParent) hParent = plugin.hwndLibraryParent;

	COPYDATA *pcd = (COPYDATA*)CoTaskMemAlloc(sizeof(COPYDATA));
	if (!pcd) return FALSE;
	ZeroMemory(pcd, sizeof(COPYDATA));

	CopyFiles_AddRef(pcd);

	pcd->hOwner = hParent;
	pcd->ppszFiles = ppszFiles;
	pcd->pFSizes = pFSizes;
	pcd->count = count;
	pcd->bCancel = FALSE;

	waServiceFactory *factory = plugin.service->service_getServiceByGuid(api_metadataGUID);
	if (factory) pcd->pMetaReader = (api_metadata*) factory->getInterface();
	factory = plugin.service->service_getServiceByGuid(mldbApiGuid);
	if (factory) pcd->pMlDb = (api_mldb*) factory->getInterface();

	HWND hRoot = GetAncestor(hParent, GA_ROOT);
	if (NULL == hRoot) hRoot = hParent;
	
	INT_PTR result = WASABI_API_DIALOGBOXPARAMW(IDD_FILECOPY_PREPARE, hRoot, CopyPrepare_DialogProc, (LPARAM)pcd);
	if (IDCANCEL != result)
	{
		if (ReadCopyParameters(pcd))
		{
			HWND hCopy = WASABI_API_CREATEDIALOGPARAMW(IDD_FILECOPY_PROGRESS, hRoot, CopyProgress_DialogProc, (LPARAM)pcd);
			if (hCopy)
			{
				pcd->hDialog = hCopy;
				ShowWindow(hCopy, SW_SHOWNORMAL);
				RedrawWindow(hCopy, NULL, NULL, RDW_INVALIDATE | RDW_UPDATENOW | RDW_ALLCHILDREN);
			}
			CopyFiles_StartCopy(pcd);
		}
	}

	CopyFiles_Release(pcd);
	return TRUE;
}

BOOL CopyFiles_CancelCopy(COPYDATA *pcd)
{
	if (pcd) pcd->bCancel = TRUE;
	return (NULL != pcd);
}

LONG CopyFiles_AddRef(COPYDATA *pcd)
{
	return (pcd) ? InterlockedIncrement(&pcd->ref) : 0;

}
LONG CopyFiles_Release(COPYDATA *pcd)
{	
	if (pcd && pcd->ref > 0)
	{
		LONG r = InterlockedDecrement(&pcd->ref);
        if ( 0 == r)
		{
			if (pcd->ppszFiles)
			{
				for (int i = 0; i < pcd->count; i++) CoTaskMemFree(pcd->ppszFiles[i]);
				CoTaskMemFree(pcd->ppszFiles);
			}
			if (pcd->pFSizes) CoTaskMemFree(pcd->pFSizes);
			if (pcd->hThread) CloseHandle(pcd->hThread);

			if(pcd->pMetaReader)
			{
				waServiceFactory *factory = plugin.service->service_getServiceByGuid(api_metadataGUID);
				if (factory) factory->releaseInterface(pcd->pMetaReader);
			}
			if(pcd->pMlDb)
			{				
				waServiceFactory *factory = plugin.service->service_getServiceByGuid(mldbApiGuid);
				if (factory) factory->releaseInterface(pcd->pMlDb);
			}
			CoTaskMemFree(pcd);
		}
		return r;
	}
	return 0;
}

static ULONGLONG CopyFiles_CalculateTotalSize(COPYDATA *pcd)
{
	ULONGLONG total = 0;
	if (!pcd->pFSizes) 
	{
		pcd->pFSizes = (ULONGLONG*)CoTaskMemAlloc(sizeof(ULONGLONG)*pcd->count);
		if (!pcd->pFSizes)
		{
			pcd->errorCode = ERROR_NOT_ENOUGH_MEMORY;
			return 0;
		}
		LARGE_INTEGER fs;
		for(int i = 0; i < pcd->count; i++)
		{
			HANDLE hFile = CreateFile(pcd->ppszFiles[i], FILE_READ_ATTRIBUTES, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
			if (INVALID_HANDLE_VALUE == hFile) 
			{
				pcd->errorCode = GetLastError();
				return 0;
			}
			if (!GetFileSizeEx(hFile, &fs)) { pcd->errorCode = GetLastError(); CloseHandle(hFile); return 0; }
			CloseHandle(hFile);
			pcd->pFSizes[i] = fs.QuadPart;
		}
	}
	for(int i = 0; i < pcd->count; i++) total += pcd->pFSizes[i];
	return total;
}

BOOL CopyFiles_CreateDirectory(LPCTSTR pszDirectory)
{
	DWORD ec = ERROR_SUCCESS;
	if (!CreateDirectory(pszDirectory, NULL))
	{
		ec = GetLastError();
		if (ERROR_PATH_NOT_FOUND == ec)
		{
			LPCTSTR pszBlock = pszDirectory;
			TCHAR szBuffer[MAX_PATH] = {0};
			
			LPCTSTR pszCursor = PathFindNextComponent(pszBlock);
			ec = (pszCursor == pszBlock || S_OK != StringCchCopyN(szBuffer, ARRAYSIZE(szBuffer), pszBlock, (pszCursor - pszBlock))) ?
					ERROR_INVALID_NAME : ERROR_SUCCESS;
			
			pszBlock = pszCursor;
			
			while (ERROR_SUCCESS == ec && NULL != (pszCursor = PathFindNextComponent(pszBlock)))
			{
				if (pszCursor == pszBlock || S_OK != StringCchCatN(szBuffer, ARRAYSIZE(szBuffer), pszBlock, (pszCursor - pszBlock)))
					ec = ERROR_INVALID_NAME;

				if (ERROR_SUCCESS == ec && !CreateDirectory(szBuffer, NULL))
				{
					ec = GetLastError();
					if (ERROR_ALREADY_EXISTS == ec) ec = ERROR_SUCCESS;
				}
				pszBlock = pszCursor;
			}
		}

		if (ERROR_ALREADY_EXISTS == ec) ec = ERROR_SUCCESS;
	}
	SetLastError(ec);
	return (ERROR_SUCCESS == ec);
}


static BOOL CopyFiles_CheckDestination(COPYDATA *pcd, ULONGLONG needSize)
{
	TCHAR szRoot[MAX_PATH] = {0};
	if (S_OK != StringCchCopy(szRoot, ARRAYSIZE(szRoot), pcd->szDestination))
	{
		pcd->errorCode = ERROR_OUTOFMEMORY;
		return FALSE;
	}
	PathStripToRoot(szRoot);
	ULARGE_INTEGER free, total;
	if (!GetDiskFreeSpaceEx(szRoot, &free, &total, NULL))
	{
		pcd->errorCode = GetLastError();
		return FALSE;
	}
	if (needSize > free.QuadPart)  
	{
		pcd->errorCode = ERROR_DISK_FULL;
		return FALSE;
	}

	if (INVALID_FILE_ATTRIBUTES == GetFileAttributes(pcd->szDestination))
	{
		DWORD ec = GetLastError();
		if (ERROR_PATH_NOT_FOUND == ec || ERROR_FILE_NOT_FOUND == ec)
		{
			if (TRUE == QueryDialog(pcd, CFT_CONFLICT, CFO_DESTNOTEXIST, (LPARAM)pcd->szDestination))
				pcd->errorCode = ERROR_REQUEST_ABORTED;
		}
		else pcd->errorCode = ec;
		
		if (ERROR_SUCCESS != pcd->errorCode)
		{
			pcd->errorMsgId = IDS_COPY_ERRMSG_DIRECTORYCREATE_FAILED;
			return FALSE;
		}
		
	}

	if (!CopyFiles_CreateDirectory(pcd->szDestination))
	{
		pcd->errorMsgId = IDS_COPY_ERRMSG_DIRECTORYCREATE_FAILED;
		pcd->errorCode = ERROR_CANNOT_MAKE;
		return FALSE;
	}
	return TRUE;
}

static BOOL CopyFiles_FixCdAttributes(LPCTSTR pszFileName)
{
	DWORD attr = GetFileAttributes(pszFileName);
	if (INVALID_FILE_ATTRIBUTES == attr) return FALSE;
	return SetFileAttributes(pszFileName, (attr & ~FILE_ATTRIBUTE_READONLY) | FILE_ATTRIBUTE_ARCHIVE);
}



static BOOL CopyFiles_DeleteFile(LPCTSTR pszFileName, COPYDATA *pcd)
{
	DWORD attr = GetFileAttributes(pszFileName);
	if (INVALID_FILE_ATTRIBUTES == attr) return FALSE;
	if (FILE_ATTRIBUTE_READONLY & attr)
	{
		BOOL bReset = FALSE;
		if (FCF_DELETEREADONLY & pcd->uFlags) bReset = TRUE;
		else 
		{
			INT_PTR r = QueryDialog(pcd, CFT_CONFLICT, CFO_READONLY, (LPARAM)pszFileName);
			switch(r)
			{
				case READONLY_CANCELCOPY:	
					pcd->errorMsgId = IDS_COPY_ERRMSG_COPYFILE_USERABORT;
					SetLastError(ERROR_REQUEST_ABORTED);
					return FALSE;
				case READONLY_DELETEALL:		pcd->uFlags |= FCF_DELETEREADONLY; // no break
				case READONLY_DELETE:		bReset = TRUE; break;
			}
		}

		if (bReset)
		{
			if (!SetFileAttributes(pszFileName, (attr & ~FILE_ATTRIBUTE_READONLY)))
			return FALSE;
		}
	}
	return DeleteFile(pszFileName);
}

#define NOT_EXIST			0
#define EXIST_AND_SKIP		1
#define EXIST_AND_OVERWRITE 	2
#define EXIST_AND_CANCEL 	3

static DWORD CopyFiles_CheckIfExist(LPCTSTR pszFileNameDest, LPCTSTR pszFileNameSource, COPYDATA *pcd)
{
    if (INVALID_FILE_ATTRIBUTES == GetFileAttributes(pszFileNameDest))
	{
		return NOT_EXIST;
	}
	

	if (FCF_SKIPFILE & pcd->uFlags) return EXIST_AND_SKIP;
	if (FCF_OVERWRITEFILE & pcd->uFlags) return EXIST_AND_OVERWRITE;

	FILECONFLICT conflict;
	ZeroMemory(&conflict, sizeof(FILECONFLICT));

	pcd->uFlags &= ~(FCF_SKIPFILE | FCF_OVERWRITEFILE);

	conflict.pszNameExisting = pszFileNameDest;
	conflict.pszNameNew	= pszFileNameSource;
		
	INT_PTR  r = QueryDialog(pcd, CFT_CONFLICT, CFO_FILEALREDYEXIST, (LPARAM)&conflict);
		
	switch(0xFF & r)
	{
		case EXISTFILE_CANCELCOPY:	return EXIST_AND_CANCEL;
		case EXISTFILE_SKIP:		
			if (EXISTFILE_APPLY_TO_ALL & r) pcd->uFlags |= FCF_SKIPFILE;
			return EXIST_AND_SKIP;
		case EXISTFILE_OVERWRITE:	
			if (EXISTFILE_APPLY_TO_ALL & r) pcd->uFlags |= FCF_OVERWRITEFILE;
			return EXIST_AND_OVERWRITE;
	}

	return NOT_EXIST;
}

typedef struct _COPYPROGRESS
{
	ULONGLONG total;
	ULONGLONG completed;
	HWND hDialog;
	INT percent;
} COPYPROGRESS;

static DWORD CALLBACK CopyFiles_ProgressRoutine(LARGE_INTEGER TotalFileSize, LARGE_INTEGER TotalBytesTransferred, LARGE_INTEGER StreamSize,
												LARGE_INTEGER StreamBytesTransferred, DWORD dwStreamNumber, DWORD dwCallbackReason, 
												HANDLE hSourceFile, HANDLE hDestinationFile, LPVOID lpData)
{
	COPYPROGRESS *pProgress = (COPYPROGRESS*)lpData;
	if (pProgress)
	{
		switch(dwCallbackReason)
		{
			case CALLBACK_STREAM_SWITCH:
				pProgress->completed += TotalFileSize.QuadPart;
				break;

		}
		INT p = (INT)((pProgress->completed - TotalFileSize.QuadPart + TotalBytesTransferred.QuadPart) * 100 / pProgress->total);
		if (p != pProgress->percent)
		{
			pProgress->percent = p;
			if (pProgress->hDialog) 
				PostMessage(pProgress->hDialog, CFM_NOTIFY, MAKEWPARAM(CFT_COPYING, CFO_PROGRESS), p);
		}
	}
	return PROGRESS_CONTINUE;
};

static DWORD WINAPI CopyFiles_ThreadProc(LPVOID param)
{
	
	COPYDATA *pcd = (COPYDATA*)param;
	if (!pcd) return 1;
	
	CopyFiles_MarkDrivesBusy((LPCTSTR*)pcd->ppszFiles, pcd->count, TRUE);

	ULONGLONG needSize;
	NotifyDialog(pcd, CFT_INITIALIZING, CFO_INIT, 0L);
	NotifyDialog(pcd, CFT_INITIALIZING, CFO_CACLSIZE, 0L);
	needSize = CopyFiles_CalculateTotalSize(pcd);
	BOOL bSuccess = (ERROR_SUCCESS == pcd->errorCode);
	if (bSuccess)
	{
		NotifyDialog(pcd, CFT_INITIALIZING, CFO_CHECKDESTINATION, 0L);
		bSuccess = CopyFiles_CheckDestination(pcd, needSize);
	}

	if (!bSuccess) 
	{
		if (0 == pcd->errorMsgId) 
			pcd->errorMsgId = IDS_COPY_ERRMSG_INITIALIZATION_FAILED;
		NotifyDialog(pcd, CFT_FINISHED, CFO_FAILED, pcd->errorCode);
		CopyFiles_MarkDrivesBusy((LPCTSTR*)pcd->ppszFiles, pcd->count, FALSE);
		CopyFiles_Release(pcd);
		return 0;
	}

	COPYPROGRESS progress;
	ZeroMemory(&progress, sizeof(COPYPROGRESS));
	progress.total = needSize;
	progress.hDialog = pcd->hDialog;

	NotifyDialog(pcd, CFT_COPYING, CFO_INIT, 0L);

	TCHAR szFile[MAX_PATH] = {0};

	for (int i = 0; i < pcd->count && ERROR_SUCCESS == pcd->errorCode; i++)
	{	
		if (pcd->bCancel)
		{
			pcd->errorMsgId = IDS_COPY_ERRMSG_COPYFILE_USERABORT;
			pcd->errorCode = ERROR_REQUEST_ABORTED;
		}

		LPCTSTR pszOrigFileName = PathFindFileName(pcd->ppszFiles[i]);
		
		NotifyDialog(pcd, CFT_COPYING, CFO_NEXTFILE, MAKELPARAM(i, pcd->count));
		
		if (NULL == PathCombine(szFile, pcd->szDestination, pszOrigFileName))
		{
			pcd->errorMsgId = IDS_COPY_ERRMSG_COPYFILE_FAILED;
			pcd->errorCode = ERROR_BAD_PATHNAME;
		}

		DWORD r = CopyFiles_CheckIfExist(szFile, pcd->ppszFiles[i], pcd);
		switch(r)
		{			
			case EXIST_AND_SKIP:
				continue;
				break;
			case EXIST_AND_OVERWRITE:
				if (!CopyFiles_DeleteFile(szFile, pcd))
				{
					pcd->errorMsgId = IDS_COPY_ERRMSG_DELETEFILE_FAILED;
					pcd->errorCode = GetLastError();
				}
				break;
			case EXIST_AND_CANCEL:
				pcd->errorMsgId = IDS_COPY_ERRMSG_COPYFILE_USERABORT;
				pcd->errorCode = ERROR_REQUEST_ABORTED;
				break;
		}	

		// copy
		if (ERROR_SUCCESS == pcd->errorCode && !CopyFileEx(pcd->ppszFiles[i], szFile, CopyFiles_ProgressRoutine, &progress, &pcd->bCancel, 0))
		{
			pcd->errorMsgId = IDS_COPY_ERRMSG_COPYFILE_FAILED;
			pcd->errorCode = GetLastError();
		}

		if (pcd->bCancel)
		{
			pcd->errorMsgId = IDS_COPY_ERRMSG_COPYFILE_USERABORT;
			pcd->errorCode = ERROR_REQUEST_ABORTED;
		}
		
		if (ERROR_SUCCESS == pcd->errorCode) // post copy
		{
			// fix attributes
			if (ERROR_SUCCESS == pcd->errorCode && !CopyFiles_FixCdAttributes(szFile))
			{
				pcd->errorMsgId = IDS_COPY_ERRMSG_SETATTRIBUTES_FAILED;
				pcd->errorCode = GetLastError();
			}

			// format title & rename
			if (ERROR_SUCCESS == pcd->errorCode && (FCF_USETITLEFMT & pcd->uFlags) && pcd->pMetaReader)
			{				
				TCHAR szBuffer[MAX_PATH] = {0};
				if (!CopyFiles_FormatFileName(szBuffer, ARRAYSIZE(szBuffer), szFile, pszOrigFileName, 
						pcd->szDestination, pcd->szTitleFormat, pcd->pMetaReader))
				{
					pcd->errorMsgId = IDS_COPY_ERRMSG_TITLEFORMAT_FAILED;
					pcd->errorCode = GetLastError();
				}

				if (pcd->bCancel)
				{
					pcd->errorMsgId = IDS_COPY_ERRMSG_COPYFILE_USERABORT;
					pcd->errorCode = ERROR_REQUEST_ABORTED;
				}
				
				if (ERROR_SUCCESS == pcd->errorCode && 
					CSTR_EQUAL != CompareString(STRCOMP_INVARIANT, 0, szBuffer, -1, szFile, -1))
				{

					DWORD r = CopyFiles_CheckIfExist(szBuffer, szFile, pcd);
					switch(r)
					{			
						case EXIST_AND_SKIP:
							CopyFiles_DeleteFile(szFile, pcd);
							continue;
							break;
						case EXIST_AND_OVERWRITE:
							if (!CopyFiles_DeleteFile(szBuffer, pcd))
							{
								pcd->errorMsgId = IDS_COPY_ERRMSG_DELETEFILE_FAILED;
								pcd->errorCode = GetLastError();
							}
							break;
						case EXIST_AND_CANCEL:
							pcd->errorMsgId = IDS_COPY_ERRMSG_COPYFILE_USERABORT;
							pcd->errorCode = ERROR_REQUEST_ABORTED;
							break;
					}	

					if (ERROR_SUCCESS == pcd->errorCode)
					{
						if (!MoveFileEx(szFile, szBuffer, MOVEFILE_WRITE_THROUGH | MOVEFILE_COPY_ALLOWED)) 
						{
							pcd->errorMsgId = IDS_COPY_ERRMSG_TITLEFORMAT_FAILED;
							pcd->errorCode = GetLastError();
						}
						else StringCchCopy(szFile, ARRAYSIZE(szFile), szBuffer);
					}
					
				}
			}
			
			
			if (ERROR_SUCCESS != pcd->errorCode)
			{
				CopyFiles_DeleteFile(szFile, pcd);
			}
			else if ((FCF_ADDTOMLDB & pcd->uFlags) && pcd->pMlDb)
			{
				if (0 == pcd->pMlDb->AddFile(szFile))
				{
					pcd->errorMsgId = IDS_COPY_ERRMSG_ADDTOMLDB_FAILED;
					pcd->errorCode = ERROR_FILE_NOT_FOUND;
				}
			}
		}
	
	}
	  
	NotifyDialog(pcd, CFT_FINISHED, (ERROR_SUCCESS == pcd->errorCode) ? CFO_SUCCESS : CFO_FAILED, pcd->errorCode);
	if ((FCF_ADDTOMLDB & pcd->uFlags) && pcd->pMlDb) pcd->pMlDb->Sync();
	CopyFiles_MarkDrivesBusy((LPCTSTR*)pcd->ppszFiles, pcd->count, FALSE);
	CopyFiles_Release(pcd);
	return 0;
}

BOOL CopyFiles_StartCopy(COPYDATA *pcd)
{
	DWORD threadId;
	
	CopyFiles_AddRef(pcd);
	
	pcd->hThread = CreateThread(NULL, 0, CopyFiles_ThreadProc, pcd, 0, &threadId);
	if (pcd->hThread) return TRUE;
	

	pcd->errorCode = GetLastError();
	NotifyDialog(pcd, CFT_FINISHED, CFO_FAILED, pcd->errorCode);
	CopyFiles_Release(pcd);
	return FALSE;
}