//************************************************************* // // Functions to copy the profile directory // // Microsoft Confidential // Copyright (c) Microsoft Corporation 1995 // All rights reserved // //************************************************************* #include "uenv.h" // // Local function proto-types // BOOL RecurseDirectory (HANDLE hTokenUser, LPTSTR lpSrcDir, LPTSTR lpDestDir, DWORD dwFlags, LPFILEINFO *llSrcDirs, LPFILEINFO *llSrcFiles, BOOL bSkipNtUser, LPTSTR lpExcludeList, BOOL bRecurseDest); BOOL AddFileInfoNode (LPFILEINFO *lpFileInfo, LPTSTR lpSrcFile, LPTSTR lpDestFile, LPFILETIME ftLastWrite, LPFILETIME ftCreate, DWORD dwFileSize, DWORD dwFileAttribs, BOOL bHive); BOOL FreeFileInfoList (LPFILEINFO lpFileInfo); BOOL SyncItems (LPFILEINFO lpSrcItems, LPFILEINFO lpDestItems, BOOL bFile, LPFILETIME ftDelRefTime); void CopyFileFunc (LPTHREADINFO lpThreadInfo); LPTSTR ConvertExclusionList (LPCTSTR lpSourceDir, LPCTSTR lpExclusionList); DWORD FindDirectorySize(LPTSTR lpDir, LPFILEINFO lpFiles, DWORD dwFlags, DWORD* pdwLargestHiveFile, DWORD* pdwTotalFiles); DWORD FindTotalDiskSpaceNeeded(DWORD dwTotalSrcFiles, DWORD dwTotalDestFiles, DWORD dwLargestHiveFile, LPFILEINFO lpSrcFiles, DWORD dwFlags); DWORD FindTotalNMaxFileSize(LPFILEINFO lpSrcFiles, DWORD dwNumOfFiles); BOOL ReconcileDirectory(LPTSTR lpSrcDir, LPTSTR lpDestDir, DWORD dwFlags, DWORD dwSrcAttribs); //************************************************************* // // CopyProfileDirectoryEx() // // Purpose: Copies the profile directory from the source // to the destination // // // Parameters: LPCTSTR lpSourceDir - Source directory // LPCTSTR lpDestDir - Destination directory // DWORD dwFlags - Flags // LPFILETIME ftDelRefTime - Delete file reference time // LPCTSTR lpExclusionList - List of directories to exclude // // // Return: (BOOL) TRUE if successful // FALSE if an error occurs // // // Comments: Called after impersonating the user. // // // History: Date Author Comment // 5/24/95 ericflo Created // 4/09/98 ericflo Converted to CopyProfileDirectoryEx // 9/28/98 ushaji Modified to check for free space // 3/14/00 weiruc Modified to copy hive file even if // hive is still loaded and ignore copy // hive file errors. // //************************************************************* BOOL CopyProfileDirectoryEx (LPCTSTR lpSourceDir, LPCTSTR lpDestinationDir, DWORD dwFlags, LPFILETIME ftDelRefTime, LPCTSTR lpExclusionList) { LPTSTR lpSrcDir = NULL, lpDestDir = NULL; LPTSTR lpSrcEnd, lpDestEnd; LPTSTR lpExcludeListSrc = NULL; LPTSTR lpExcludeListDest = NULL; LPFILEINFO lpSrcFiles = NULL, lpDestFiles = NULL; LPFILEINFO lpSrcDirs = NULL, lpDestDirs = NULL; LPFILEINFO lpTemp; THREADINFO ThreadInfo = {0, NULL, NULL, 0, NULL, NULL, NULL, NULL}; DWORD dwThreadId; HANDLE hThreads[NUM_COPY_THREADS]; HANDLE hStatusThread = 0; DWORD dwThreadCount = 0; HANDLE hFile; WIN32_FIND_DATA fd; BOOL bResult = FALSE; BOOL bSynchronize = FALSE; UINT i; DWORD dwTotalSrcFiles = 0; DWORD dwTotalDestFiles = 0; DWORD dwLargestHiveFile; DWORD dwTotalDiskSpaceNeeded; ULARGE_INTEGER ulFreeBytesAvailableToCaller, ulTotalNumberOfBytes, ulTotalNumberOfFreeBytes; DWORD dwErr, dwErr1=0; TCHAR szErr[MAX_PATH]; TCHAR szTmpHive[MAX_PATH]; BOOL bReconcileHiveSucceeded; HKEY hkCurrentUser = NULL; HANDLE hTokenUser = NULL; dwErr = GetLastError(); // // Verbose output // DebugMsg((DM_VERBOSE, TEXT("CopyProfileDirectoryEx: Entering, lpSourceDir = <%s>, lpDestinationDir = <%s>, dwFlags = 0x%x"), lpSourceDir, lpDestinationDir, dwFlags)); // // Validate parameters // if (!lpSourceDir || !lpDestinationDir) { DebugMsg((DM_WARNING, TEXT("CopyProfileDirectoryEx: received NULL pointer"))); SetLastError(ERROR_INVALID_PARAMETER); return FALSE; } // // Get the caller's token // if (!OpenThreadToken (GetCurrentThread(), TOKEN_IMPERSONATE | TOKEN_QUERY | TOKEN_DUPLICATE, TRUE, &hTokenUser)) { if (!OpenProcessToken(GetCurrentProcess(), TOKEN_IMPERSONATE | TOKEN_QUERY | TOKEN_DUPLICATE, &hTokenUser)) { DebugMsg((DM_WARNING, TEXT("CopyProfileDirectoryEx: Fail to get process token with error %d."), GetLastError())); return FALSE; } } // // If there is an exclusion list, convert it into an array of null // terminate strings (double null at the end) based upon the source // directory // if ((dwFlags & CPD_USEEXCLUSIONLIST) && lpExclusionList) { DebugMsg((DM_VERBOSE, TEXT("CopyProfileDirectoryEx: lpExclusionList = <%s>"), lpExclusionList)); lpExcludeListSrc = ConvertExclusionList (lpSourceDir, lpExclusionList); if (!lpExcludeListSrc) { DebugMsg((DM_WARNING, TEXT("CopyProfileDirectoryEx: Failed to convert exclusion list for source"))); goto Exit; } if (!(dwFlags & CPD_DELDESTEXCLUSIONS)) { lpExcludeListDest = ConvertExclusionList (lpDestinationDir, lpExclusionList); if (!lpExcludeListDest) { DebugMsg((DM_WARNING, TEXT("CopyProfileDirectoryEx: Failed to convert exclusion list for destination"))); dwErr = ERROR_INVALID_DATA; goto Exit; } } } // // Get the desktop handle // ThreadInfo.hDesktop = GetThreadDesktop(GetCurrentThreadId()); // // Is this a full sync copy (delete extra files / directories in dest). // if (dwFlags & CPD_SYNCHRONIZE) { bSynchronize = TRUE; } // // Test / Create the destination directory // if (!CreateNestedDirectory(lpDestinationDir, NULL)) { DebugMsg((DM_WARNING, TEXT("CopyProfileDirectoryEx: Failed to create the destination directory. Error = %d"), GetLastError())); dwErr = GetLastError(); goto Exit; } // // Create and set up the directory buffers // lpSrcDir = LocalAlloc(LPTR, (2 * MAX_PATH) * sizeof(TCHAR)); lpDestDir = LocalAlloc(LPTR, (2 * MAX_PATH) * sizeof(TCHAR)); if (!lpSrcDir || !lpDestDir) { DebugMsg((DM_WARNING, TEXT("CopyProfileDirectoryEx: Failed to allocate memory for working directories"))); dwErr = GetLastError(); goto Exit; } lstrcpy (lpSrcDir, lpSourceDir); lstrcpy (lpDestDir, lpDestinationDir); // // Setup ending pointers // lpSrcEnd = CheckSlash (lpSrcDir); lpDestEnd = CheckSlash (lpDestDir); // // Recurse through the folders gathering info // if (!(dwFlags & CPD_COPYHIVEONLY)) { // // Recurse the source directory // if (!RecurseDirectory(hTokenUser, lpSrcDir, lpDestDir, dwFlags, &lpSrcDirs, &lpSrcFiles, TRUE, lpExcludeListSrc, FALSE)) { DebugMsg((DM_VERBOSE, TEXT("CopyProfileDirectoryEx: RecurseDirectory returned FALSE"))); dwErr = GetLastError(); goto Exit; } if (bSynchronize) { // // Recurse the destination directory // if (!RecurseDirectory(hTokenUser, lpDestDir, lpSrcDir, dwFlags, &lpDestDirs, &lpDestFiles, TRUE, lpExcludeListDest, TRUE)) { DebugMsg((DM_VERBOSE, TEXT("CopyProfileDirectoryEx: RecurseDirectory returned FALSE"))); dwErr = GetLastError(); goto Exit; } } } // // determine the source and destination sizes // if(FindDirectorySize(lpSrcDir, lpSrcFiles, dwFlags, &dwLargestHiveFile, &dwTotalSrcFiles) != ERROR_SUCCESS) { DebugMsg((DM_WARNING, TEXT("FindDirectorySize: Error = %08x"), GetLastError())); dwErr = GetLastError(); goto Exit; } if(FindDirectorySize(lpDestDir, lpDestFiles, dwFlags, NULL, &dwTotalDestFiles)) { DebugMsg((DM_WARNING, TEXT("FindDirectorySize: Error = %08x"), GetLastError())); dwErr = GetLastError(); goto Exit; } // // determine the disk space needed // dwTotalDiskSpaceNeeded = FindTotalDiskSpaceNeeded(dwTotalSrcFiles, dwTotalDestFiles, dwLargestHiveFile, lpSrcFiles, dwFlags); // // CopyProfileDirectoryEx is called with impersonation on // if (!GetDiskFreeSpaceEx(lpDestDir, &ulFreeBytesAvailableToCaller, &ulTotalNumberOfBytes, &ulTotalNumberOfFreeBytes)) { DebugMsg((DM_WARNING, TEXT("CopyProfileDirectoryEx: Failed to get the Free Disk Space <%s>. Error = %d"), lpDestDir, GetLastError())); dwErr = GetLastError(); goto Exit; } DebugMsg((DM_VERBOSE, TEXT("Available\t\t%d"), ulFreeBytesAvailableToCaller.QuadPart)); DebugMsg((DM_VERBOSE, TEXT("Needed\t\t%d"), dwTotalDiskSpaceNeeded)); DebugMsg((DM_VERBOSE, TEXT("Src size\t\t%d"), dwTotalSrcFiles)); DebugMsg((DM_VERBOSE, TEXT("Dest size\t\t%d"), dwTotalDestFiles)); DebugMsg((DM_VERBOSE, TEXT("Largest hive file\t\t%d"), dwLargestHiveFile)); if(dwTotalDiskSpaceNeeded > ulFreeBytesAvailableToCaller.QuadPart) { DebugMsg((DM_WARNING, TEXT("CopyProfileDirectoryEx: Not enough disk space on <%s>"), lpDestDir)); dwErr = ERROR_DISK_FULL; goto Exit; } // // Synchronize the directories and files if appropriate // if (bSynchronize) { // // Files first... // SyncItems (lpSrcFiles, lpDestFiles, TRUE, (dwFlags & CPD_USEDELREFTIME) ? ftDelRefTime : NULL); // // Now the directories... // SyncItems (lpSrcDirs, lpDestDirs, FALSE, (dwFlags & CPD_USEDELREFTIME) ? ftDelRefTime : NULL); } // // Copy the actual hive, log, ini files first // if (!(dwFlags & CPD_IGNOREHIVE)) { // // Search for all user hives // if (dwFlags & CPD_WIN95HIVE) { lstrcpy (lpSrcEnd, c_szUserStar); } else { lstrcpy (lpSrcEnd, c_szNTUserStar); } // // Enumerate // hFile = FindFirstFile(lpSrcDir, &fd); if (hFile != INVALID_HANDLE_VALUE) { do { // // Setup the filename // if((dwFlags & CPD_USETMPHIVEFILE) && (lstrcmpi(fd.cFileName, c_szNTUserMan) == 0 || lstrcmpi(fd.cFileName, c_szNTUserDat) == 0)) { DebugMsg((DM_VERBOSE, TEXT("CopyProfileDirectoryEx: Hive is still loaded, use temporary hive file"))); // // Use temporary hive file because unloading hive failed. // lstrcpy(lpSrcEnd, c_szNTUserTmp); } else { lstrcpy (lpSrcEnd, fd.cFileName); } lstrcpy (lpDestEnd, fd.cFileName); // // Do not reconcile the log file if we are using the tmp hive // file. Skip it. // if((dwFlags & CPD_USETMPHIVEFILE) && lstrcmpi(fd.cFileName + lstrlen(fd.cFileName) - lstrlen(c_szLog), c_szLog) == 0) { DebugMsg((DM_VERBOSE, TEXT("CopyProfileDirectoryEx: Log file %s skipped"), lpDestDir)); continue; } // // Skip the temporary hive file here. Will deal with it when // we find an actual hive file. // if(lstrcmpi(fd.cFileName, c_szNTUserTmp) == 0) { DebugMsg((DM_VERBOSE, TEXT("CopyProfileDirectoryEx: %s skipped"), fd.cFileName)); continue; } DebugMsg((DM_VERBOSE, TEXT("CopyProfileDirectoryEx: Found hive file %s"), fd.cFileName)); if(!ReconcileFile(lpSrcDir, lpDestDir, dwFlags, NULL, fd.nFileSizeLow, TRUE)) { dwErr1 = GetLastError(); DebugMsg((DM_WARNING, TEXT("CopyProfileDirectoryEx: ReconcileFile failed with error = %d"), dwErr1)); if (!(dwFlags & CPD_IGNORECOPYERRORS)) { dwErr = dwErr1; ReportError(hTokenUser, PI_NOUI, 3, EVENT_COPYERROR, lpSrcDir, lpDestDir, GetErrString(dwErr, szErr)); FindClose(hFile); goto Exit; } else { ReportError(hTokenUser, PI_NOUI | EVENT_WARNING_TYPE, 3, EVENT_COPYERROR, lpSrcDir, lpDestDir, GetErrString(dwErr1, szErr)); } } // // Find the next entry // } while (FindNextFile(hFile, &fd)); FindClose(hFile); dwErr = ERROR_SUCCESS; } else { dwErr = GetLastError(); DebugMsg((DM_VERBOSE, TEXT("CopyProfileDirectoryEx: FindFirstFile failed to find a hive!. Error = %d"), dwErr)); } } // // Create all the directories // if (!(dwFlags & CPD_COPYHIVEONLY)) { DebugMsg((DM_VERBOSE, TEXT("CopyProfileDirectoryEx: Calling ReconcileDirectory for all Directories"))); lpTemp = lpSrcDirs; while (lpTemp) { if (!ReconcileDirectory(lpTemp->szSrc, lpTemp->szDest, dwFlags, lpTemp->dwFileAttribs)) { dwErr1 = GetLastError(); DebugMsg((DM_WARNING, TEXT("CopyProfileDirectoryEx: Failed to create the destination directory <%s>. Error = %d"), lpTemp->szDest, GetLastError())); if (!(dwFlags & CPD_IGNORECOPYERRORS)) { // // Show the error UI and bail out. // ReportError(hTokenUser, ((dwFlags & CPD_NOERRORUI)? PI_NOUI:0), 3, EVENT_COPYERROR, lpTemp->szSrc, lpTemp->szDest, GetErrString(dwErr1, szErr)); dwErr = dwErr1; goto Exit; } else { ReportError(hTokenUser, PI_NOUI | EVENT_WARNING_TYPE, 3, EVENT_COPYERROR, lpTemp->szSrc, lpTemp->szDest, GetErrString(dwErr1, szErr)); } } lpTemp = lpTemp->pNext; } DebugMsg((DM_VERBOSE, TEXT("CopyProfileDirectoryEx: Reconcile Directory Done for all Directories"))); // // Copy the files // if (dwFlags & CPD_SLOWCOPY) { // // Copy the files one at a time... // lpTemp = lpSrcFiles; while (lpTemp) { if (lpTemp->bHive) { // // Hive files have already been copied.. // lpTemp = lpTemp->pNext; continue; } if (!ReconcileFile (lpTemp->szSrc, lpTemp->szDest, dwFlags, &lpTemp->ftLastWrite, lpTemp->dwFileSize, FALSE)) { dwErr1 = GetLastError(); DebugMsg((DM_WARNING, TEXT("CopyProfileDirectoryEx: Failed to copy the file <%s> to <%s> due to error = %d"), lpTemp->szSrc, lpTemp->szDest, GetLastError())); if (!(dwFlags & CPD_IGNORECOPYERRORS)) { // // Show the error UI and since the user picks to abort // then we leave now. // ReportError(hTokenUser, ((dwFlags & CPD_NOERRORUI)? PI_NOUI:0), 3, EVENT_COPYERROR, lpTemp->szSrc, lpTemp->szDest, GetErrString(dwErr1, szErr)); dwErr = dwErr1; goto Exit; } else { ReportError(hTokenUser, PI_NOUI | EVENT_WARNING_TYPE, 3, EVENT_COPYERROR, lpTemp->szSrc, lpTemp->szDest, GetErrString(dwErr1, szErr)); } } lpTemp = lpTemp->pNext; } } else { if (lpSrcFiles) { HANDLE hThreadToken=NULL; if (!OpenThreadToken (GetCurrentThread(), TOKEN_IMPERSONATE | TOKEN_QUERY | TOKEN_DUPLICATE, TRUE, &hThreadToken)) { DebugMsg((DM_VERBOSE, TEXT("CopyProfileDirectoryEx: Failed to get token with %d. This is ok if thread is not impersonating"), GetLastError())); } // // Multi-threaded copy // // Null sd, auto set, initially signalled, unnamed.. if (!(ThreadInfo.hCopyEvent = CreateEvent(NULL, FALSE, TRUE, NULL))) { DebugMsg((DM_WARNING, TEXT("CopyProfileDirectoryEx: CreateEvent for CopyEvent failed with error %d"), GetLastError())); dwErr = GetLastError(); goto Exit; } ThreadInfo.dwFlags = dwFlags; ThreadInfo.lpSrcFiles = lpSrcFiles; ThreadInfo.hTokenUser = hTokenUser; // // Required for PrivCopyFileEx to work, threads should be created using the // process token // RevertToSelf(); // // Create the file copy threads // for (i = 0; i < NUM_COPY_THREADS; i++) { if (hThreads[dwThreadCount] = CreateThread (NULL, 0, (LPTHREAD_START_ROUTINE) CopyFileFunc, (LPVOID) &ThreadInfo, CREATE_SUSPENDED, &dwThreadId)) { dwThreadCount++; } } // // Put the token back. // if (!SetThreadToken(NULL, hThreadToken)) { DebugMsg((DM_WARNING, TEXT("CopyProfileDirectoryEx: Impersonation failed with error %d"), GetLastError())); dwErr = GetLastError(); // terminate and close handles for all the threads for (i = 0; i < dwThreadCount; i++) { TerminateThread (hThreads[i], 1); CloseHandle (hThreads[i]); } if (hThreadToken) CloseHandle (hThreadToken); goto Exit; } for (i = 0; i < dwThreadCount; i++) { if (!SetThreadToken(&hThreads[i], hThreadToken) || !ResumeThread (hThreads[i])) { TerminateThread(hThreads[i], 1); } } // // Wait for the threads to finish // if (WaitForMultipleObjects (dwThreadCount, hThreads, TRUE, INFINITE) == WAIT_FAILED) { ThreadInfo.dwError = GetLastError(); } // // Clean up // if (hThreadToken) CloseHandle (hThreadToken); for (i = 0; i < dwThreadCount; i++) { CloseHandle (hThreads[i]); } if (ThreadInfo.dwError) { dwErr = ThreadInfo.dwError; goto Exit; } } } } // // Restore the time on the directories to be the same as from Src. // This is required because the times on directory have been modified by // creation and deletion of files above. // DebugMsg((DM_VERBOSE, TEXT("CopyProfileDirectoryEx: Setting Directory TimeStamps all Directories"))); lpTemp = lpSrcDirs; while (lpTemp) { HANDLE hFile; SetFileAttributes (lpTemp->szDest, FILE_ATTRIBUTE_NORMAL); hFile = CreateFile(lpTemp->szDest, GENERIC_WRITE, FILE_SHARE_DELETE | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_BACKUP_SEMANTICS, NULL); if (hFile != INVALID_HANDLE_VALUE) { if (!SetFileTime(hFile, NULL, NULL, &(lpTemp->ftLastWrite))) { DebugMsg((DM_WARNING, TEXT("CopyProfileDirectoryEx: Failed to set the write time on the directory <%s>. Error = %d"), lpTemp->szDest, GetLastError())); } CloseHandle(hFile); } else { DebugMsg((DM_WARNING, TEXT("CopyProfileDirectoryEx: CreateFile failed for directory %s with error %d"), lpTemp->szDest, GetLastError())); } SetFileAttributes (lpTemp->szDest, lpTemp->dwFileAttribs); lpTemp = lpTemp->pNext; } DebugMsg((DM_VERBOSE, TEXT("CopyProfileDirectoryEx: Set times on all directories"))); // // Success // bResult = TRUE; Exit: if (ThreadInfo.hCopyEvent) { CloseHandle (ThreadInfo.hCopyEvent); } if ( ThreadInfo.hDesktop ) { CloseDesktop( ThreadInfo.hDesktop ); } // // Free the memory allocated above // if (hTokenUser) { CloseHandle(hTokenUser); } if (lpSrcDir) { LocalFree(lpSrcDir); } if (lpDestDir) { LocalFree(lpDestDir); } if (lpExcludeListSrc) { LocalFree (lpExcludeListSrc); } if (lpExcludeListDest) { LocalFree (lpExcludeListDest); } if (lpSrcFiles) { FreeFileInfoList(lpSrcFiles); } if (lpDestFiles) { FreeFileInfoList(lpDestFiles); } if (lpSrcDirs) { FreeFileInfoList(lpSrcDirs); } if (lpDestDirs) { FreeFileInfoList(lpDestDirs); } SetLastError(dwErr); // // Verbose output // DebugMsg((DM_VERBOSE, TEXT("CopyProfileDirectoryEx: Leaving with a return value of %d"), bResult)); return bResult; } //************************************************************* // // RecurseDirectory() // // Purpose: Recurses through the subdirectory coping files. // // Parameters: hTokenUser - User's token // lpSrcDir - Source directory working buffer // lpDestDir - Destination directory working buffer // dwFlags - dwFlags // llSrcDirs - Link list of directories // llSrcFiles - Link list of files // bSkipNtUser - Skip ntuser.* files // lpExcludeList - List of directories to exclude // bRecurseDest - The destination Dir is being recursed // // Return: TRUE if successful // FALSE if an error occurs // // Comments: 1) The source and dest directories will already have // the trailing backslash when entering this function. // 2) The current working directory is the source directory. // // // Notes: // CPD_SYSTEMDIRSONLY Do not keep track of anything unless the dir is // marked with system bit. // CPD_SYSTEMFILES Only Systemfiles // CPD_NONENCRYPTEDONLY Only Non EncryptedFile/Directory. // // History: Date Author Comment // 5/25/95 ericflo Created // //************************************************************* BOOL RecurseDirectory (HANDLE hTokenUser, LPTSTR lpSrcDir, LPTSTR lpDestDir, DWORD dwFlags, LPFILEINFO *llSrcDirs, LPFILEINFO *llSrcFiles, BOOL bMarkNtUser, LPTSTR lpExcludeList, BOOL bRecurseDest) { HANDLE hFile = INVALID_HANDLE_VALUE; WIN32_FIND_DATA fd; LPTSTR lpSrcEnd, lpDestEnd, lpTemp; BOOL bResult = TRUE; BOOL bSkip; DWORD dwErr, dwErr1 = 0; TCHAR szErr[MAX_PATH]; BOOL bHive; dwErr = GetLastError(); // // Setup the ending pointers // lpSrcEnd = CheckSlash (lpSrcDir); lpDestEnd = CheckSlash (lpDestDir); // // Append *.* to the source directory // lstrcpy(lpSrcEnd, c_szStarDotStar); // // Search through the source directory // hFile = FindFirstFile(lpSrcDir, &fd); if (hFile == INVALID_HANDLE_VALUE) { if ( (GetLastError() == ERROR_FILE_NOT_FOUND) || (GetLastError() == ERROR_PATH_NOT_FOUND) ) { // // bResult is already initialized to TRUE, so // just fall through. // } else { dwErr1 = GetLastError(); DebugMsg((DM_WARNING, TEXT("RecurseDirectory: FindFirstFile failed. Error = %d"), dwErr1)); *lpSrcEnd = TEXT('\0'); *lpDestEnd = TEXT('\0'); if (!(dwFlags & CPD_IGNORECOPYERRORS)) { if (!bRecurseDest) { ReportError(hTokenUser, ((dwFlags & CPD_NOERRORUI)? PI_NOUI:0), 3, EVENT_COPYERROR, lpSrcDir, lpDestDir, GetErrString(dwErr1, szErr)); } else { ReportError(hTokenUser, ((dwFlags & CPD_NOERRORUI)? PI_NOUI:0), 3, EVENT_COPYERROR, lpDestDir, lpSrcDir, GetErrString(dwErr1, szErr)); } dwErr = dwErr1; bResult = FALSE; } } goto RecurseDir_Exit; } do { bHive = FALSE; // // Check whether we have enough space in our buffers // *lpSrcEnd = TEXT('\0'); *lpDestEnd = TEXT('\0'); if ((lstrlen(lpSrcDir)+lstrlen(fd.cFileName) >= MAX_PATH) || (lstrlen(lpDestDir)+lstrlen(fd.cFileName) >= MAX_PATH)) { LPTSTR lpErrSrc=NULL, lpErrDest=NULL; BOOL bRet; DebugMsg((DM_WARNING, TEXT("RecurseDirectory: %s is too long. src = %s, dest = %s"), fd.cFileName, lpSrcDir, lpDestDir)); if (dwFlags & CPD_IGNORELONGFILENAMES) continue; // // Allocate a buffer to show the file names // lpErrSrc = LocalAlloc(LPTR, (lstrlen(lpSrcDir)+lstrlen(fd.cFileName)+1)*sizeof(TCHAR)); lpErrDest = LocalAlloc(LPTR, (lstrlen(lpDestDir)+lstrlen(fd.cFileName)+1)*sizeof(TCHAR)); // // Show the UI // if ((!lpErrSrc) || (!lpErrDest)) { if (!bRecurseDest) { ReportError(hTokenUser, ((dwFlags & CPD_NOERRORUI)? PI_NOUI:0), 3, EVENT_COPYERROR, lpSrcDir, lpDestDir, GetErrString(ERROR_FILENAME_EXCED_RANGE, szErr)); } else { ReportError(hTokenUser, ((dwFlags & CPD_NOERRORUI)? PI_NOUI:0), 3, EVENT_COPYERROR, lpDestDir, lpSrcDir, GetErrString(ERROR_FILENAME_EXCED_RANGE, szErr)); } } else { lstrcpy(lpErrSrc, lpSrcDir); lstrcpy(lpErrSrc+lstrlen(lpErrSrc), fd.cFileName); lstrcpy(lpErrDest, lpDestDir); lstrcpy(lpErrDest+lstrlen(lpErrDest), fd.cFileName); if (!bRecurseDest) { ReportError(hTokenUser, ((dwFlags & CPD_NOERRORUI)? PI_NOUI:0), 3, EVENT_COPYERROR, lpErrSrc, lpErrDest, GetErrString(ERROR_FILENAME_EXCED_RANGE, szErr)); } else { ReportError(hTokenUser, ((dwFlags & CPD_NOERRORUI)? PI_NOUI:0), 3, EVENT_COPYERROR, lpErrDest, lpErrSrc, GetErrString(ERROR_FILENAME_EXCED_RANGE, szErr)); } } if (lpErrSrc) LocalFree(lpErrSrc); if (lpErrDest) LocalFree(lpErrDest); // // Set the error and quit. // dwErr = ERROR_FILENAME_EXCED_RANGE; bResult = FALSE; goto RecurseDir_Exit; } // // Append the file / directory name to the working buffers // lstrcpy (lpSrcEnd, fd.cFileName); lstrcpy (lpDestEnd, fd.cFileName); if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) { // // Check for "." and ".." // if (!lstrcmpi(fd.cFileName, c_szDot)) { continue; } if (!lstrcmpi(fd.cFileName, c_szDotDot)) { continue; } // // Check for reparse point // if (fd.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) { DebugMsg((DM_WARNING, TEXT("RecurseDirectory: Found a reparse point <%s>, skip it!"), lpSrcDir)); continue; } // // Check if this directory should be excluded // if (lpExcludeList) { bSkip = FALSE; lpTemp = lpExcludeList; while (*lpTemp) { if (lstrcmpi (lpTemp, lpSrcDir) == 0) { bSkip = TRUE; break; } lpTemp += lstrlen (lpTemp) + 1; } if (bSkip) { DebugMsg((DM_VERBOSE, TEXT("RecurseDirectory: Skipping <%s> due to exclusion list."), lpSrcDir)); continue; } } // // Found a directory. // // 1) Change into that subdirectory on the source drive. // 2) Recurse down that tree. // 3) Back up one level. // // // Add to the list of directories // if (dwFlags & CPD_SYSTEMDIRSONLY) { // // if it is encrypted, don't recurse into it // if (!(fd.dwFileAttributes & FILE_ATTRIBUTE_ENCRYPTED)) { DWORD dwNewFlags = dwFlags; // // Add to the list of directories only if marked as system, o/w just recurse through // if (fd.dwFileAttributes & FILE_ATTRIBUTE_SYSTEM) { if (!AddFileInfoNode (llSrcDirs, lpSrcDir, lpDestDir, &fd.ftLastWriteTime, &fd.ftCreationTime, 0, fd.dwFileAttributes, bHive)) { DebugMsg((DM_WARNING, TEXT("RecurseDirectory: AddFileInfoNode failed"))); dwErr = GetLastError(); goto RecurseDir_Exit; } dwNewFlags ^= CPD_SYSTEMDIRSONLY; DebugMsg((DM_VERBOSE, TEXT("RecurseDirectory: Adding %s to the list of directories because system bit is on"), lpSrcDir)); } // // Recurse the subdirectory // if (!RecurseDirectory(hTokenUser, lpSrcDir, lpDestDir, dwNewFlags, llSrcDirs, llSrcFiles, FALSE, lpExcludeList, bRecurseDest)) { DebugMsg((DM_VERBOSE, TEXT("RecurseDirectory: RecurseDirectory returned FALSE"))); bResult = FALSE; dwErr = GetLastError(); goto RecurseDir_Exit; } } else { DebugMsg((DM_VERBOSE, TEXT("RecurseDirectory: Skipping <%s> since the encrypted attribute is set."), lpSrcDir)); } continue; } // // Popup time // if (dwFlags & CPD_NONENCRYPTEDONLY) { if (fd.dwFileAttributes & FILE_ATTRIBUTE_ENCRYPTED) { DebugMsg((DM_VERBOSE, TEXT("RecurseDirectory: Detected Encrypted file %s, Aborting.."), lpSrcDir)); dwErr = ERROR_FILE_ENCRYPTED; bResult = FALSE; goto RecurseDir_Exit; } } // // Ignore encrypted file // if (dwFlags & CPD_IGNOREENCRYPTEDFILES) { if (fd.dwFileAttributes & FILE_ATTRIBUTE_ENCRYPTED) { DebugMsg((DM_VERBOSE, TEXT("RecurseDirectory: Skipping <%s> since the encrypted attribute is set..."), lpSrcDir)); continue; } } // // Add it to the list // if (!AddFileInfoNode (llSrcDirs, lpSrcDir, lpDestDir, &fd.ftLastWriteTime, &fd.ftCreationTime, 0, fd.dwFileAttributes, bHive)) { DebugMsg((DM_WARNING, TEXT("RecurseDirectory: AddFileInfoNode failed"))); dwErr = GetLastError(); goto RecurseDir_Exit; } // // Recurse the subdirectory // if (!RecurseDirectory(hTokenUser, lpSrcDir, lpDestDir, dwFlags, llSrcDirs, llSrcFiles, FALSE, lpExcludeList, bRecurseDest)) { DebugMsg((DM_VERBOSE, TEXT("RecurseDirectory: RecurseDirectory returned FALSE"))); bResult = FALSE; dwErr = GetLastError(); goto RecurseDir_Exit; } DebugMsg((DM_VERBOSE, TEXT("RecurseDirectory: Adding %s to the list of directories"), lpSrcDir)); } else { // // if the directories only bit is set, don't copy anything else // if (dwFlags & CPD_SYSTEMDIRSONLY) { DebugMsg((DM_VERBOSE, TEXT("RecurseDirectory: Skipping <%s> since the system directories only attribute is set."), lpSrcDir)); continue; } // // If the filename found starts with "ntuser", then ignore // it because the hive will be copied below (if appropriate). // if (bMarkNtUser && lstrlen(fd.cFileName) >= 6) { if (CompareString (LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE, fd.cFileName, 6, TEXT("ntuser"), 6) == CSTR_EQUAL) { bHive = TRUE; } } // // Check if this file should be excluded // if (dwFlags & CPD_SYSTEMFILES) { if (!(fd.dwFileAttributes & FILE_ATTRIBUTE_SYSTEM)) { DebugMsg((DM_VERBOSE, TEXT("RecurseDirectory: Skipping <%s> since the system attribute is not set."), lpSrcDir)); continue; } } // // if it is systemfile, it can not be encrypted. // if (dwFlags & CPD_NONENCRYPTEDONLY) { if (fd.dwFileAttributes & FILE_ATTRIBUTE_ENCRYPTED) { DebugMsg((DM_VERBOSE, TEXT("RecurseDirectory: Detected Encrypted file %s, Aborting..."), lpSrcDir)); dwErr = ERROR_FILE_ENCRYPTED; bResult = FALSE; goto RecurseDir_Exit; } } if (dwFlags & CPD_IGNOREENCRYPTEDFILES) { if (fd.dwFileAttributes & FILE_ATTRIBUTE_ENCRYPTED) { DebugMsg((DM_VERBOSE, TEXT("RecurseDirectory: Skipping <%s> since the encrypted attribute is set."), lpSrcDir)); continue; } } // // We found a file. Add it to the list. // if (!AddFileInfoNode (llSrcFiles, lpSrcDir, lpDestDir, &fd.ftLastWriteTime, &fd.ftCreationTime, fd.nFileSizeLow, fd.dwFileAttributes, bHive)) { DebugMsg((DM_WARNING, TEXT("RecurseDirectory: AddFileInfoNode failed"))); dwErr = GetLastError(); goto RecurseDir_Exit; } } // // Find the next entry // } while (FindNextFile(hFile, &fd)); RecurseDir_Exit: // // Remove the file / directory name appended above // *lpSrcEnd = TEXT('\0'); *lpDestEnd = TEXT('\0'); // // Close the search handle // if (hFile != INVALID_HANDLE_VALUE) { FindClose(hFile); } SetLastError(dwErr); return bResult; } //************************************************************* // // CopyProgressRoutine() // // Purpose: Callback function for CopyFileEx // // Parameters: See doc's. // // Return: PROGRESS_CONTINUE // //************************************************************* DWORD WINAPI CopyProgressRoutine(LARGE_INTEGER TotalFileSize, LARGE_INTEGER TotalBytesTransferred, LARGE_INTEGER StreamSize, LARGE_INTEGER StreamBytesTransferred, DWORD dwStreamNumber, DWORD dwCallbackReason, HANDLE hSourceFile, HANDLE hDestinationFile, LPVOID lpData) { switch (dwCallbackReason) { case PRIVCALLBACK_ENCRYPTION_FAILED: case PRIVCALLBACK_COMPRESSION_FAILED: case PRIVCALLBACK_SPARSE_FAILED: case PRIVCALLBACK_OWNER_GROUP_FAILED: case PRIVCALLBACK_DACL_ACCESS_DENIED: case PRIVCALLBACK_SACL_ACCESS_DENIED: case PRIVCALLBACK_OWNER_GROUP_ACCESS_DENIED: return PROGRESS_CANCEL; default: return PROGRESS_CONTINUE; //all other conditions can be safely ignored } } //************************************************************* // // ReconcileDirectory() // // Purpose: Compares the source and destination file. // If the source is newer, then it is copied // over the destination. // // Parameters: lpSrcDir - source filename // lpDestDir - destination filename // dwFlags - flags // dwSrcAttribs Source Attributes for decompression, // decryption later on. // // // Return: 1 if successful (no file copied) // 0 if an error occurs // // Comments: // // History: Date Author Comment // 2/26/99 ushaji Created // //************************************************************* BOOL ReconcileDirectory(LPTSTR lpSrcDir, LPTSTR lpDestDir, DWORD dwFlags, DWORD dwSrcAttribs) { DWORD dwCopyFlags=0, dwErr; BOOL bCancel = FALSE; // // Clear any existing attributes // SetFileAttributes (lpDestDir, FILE_ATTRIBUTE_NORMAL); if (!CreateNestedDirectory(lpDestDir, NULL)) { DebugMsg((DM_WARNING, TEXT("ReconcileDirectory: Failed to create the destination directory <%s>. Error = %d"), lpDestDir, GetLastError())); return FALSE; } // // Set up the copy flags to copy the encryption/compression on dirs over. // if (!(dwFlags & CPD_IGNORESECURITY)) dwCopyFlags = PRIVCOPY_FILE_METADATA | PRIVCOPY_FILE_SKIP_DACL; dwCopyFlags |= PRIVCOPY_FILE_DIRECTORY | PRIVCOPY_FILE_SUPERSEDE; if (!PrivCopyFileExW(lpSrcDir, lpDestDir, (LPPROGRESS_ROUTINE) CopyProgressRoutine, NULL, &bCancel, dwCopyFlags)) { dwErr = GetLastError(); DebugMsg((DM_WARNING, TEXT("ReconcileDirectory: Failed to copy over the attributes src <%s> to destination directory <%s>. Error = %d"), lpSrcDir, lpDestDir, dwErr)); RemoveDirectory(lpDestDir); SetLastError(dwErr); return FALSE; } return TRUE; } //************************************************************* // // ReconcileFile() // // Purpose: Compares the source and destination file. // If the source is newer, then it is copied // over the destination. // // Parameters: lpSrcFile - source filename // lpDestFile - destination filename // dwFlags - flags // ftSrcTime - Src file time (can be NULL) // dwFileSize - File size // bHiveFile - Flag to indicate hive file // // // Return: 1 if successful (no file copied) // 2 if successful (and a file was copied) // 0 if an error occurs // // Comments: // // History: Date Author Comment // 5/25/95 ericflo Created // 7/20/00 santanuc added flag bHiveFile // //************************************************************* INT ReconcileFile (LPCTSTR lpSrcFile, LPCTSTR lpDestFile, DWORD dwFlags, LPFILETIME ftSrcTime, DWORD dwFileSize, BOOL bHiveFile) { WIN32_FILE_ATTRIBUTE_DATA fad; FILETIME ftWriteSrc, ftWriteDest; INT iCopyFile = 0; DWORD dwErr = ERROR_SUCCESS, dwErr1 = 0; // // If the flags have CPD_FORCECOPY, then skip to the // copy file call without checking the timestamps. // if (!(dwFlags & CPD_FORCECOPY)) { // // If we were given a source file time, use that // if (ftSrcTime) { ftWriteSrc.dwLowDateTime = ftSrcTime->dwLowDateTime; ftWriteSrc.dwHighDateTime = ftSrcTime->dwHighDateTime; } else { // // Query for the source file time // if (!GetFileAttributesEx (lpSrcFile, GetFileExInfoStandard, &fad)) { dwErr = GetLastError(); DebugMsg((DM_WARNING, TEXT("ReconcileFile: GetFileAttributes on the source failed with error = %d"), dwErr)); goto Exit; } ftWriteSrc.dwLowDateTime = fad.ftLastWriteTime.dwLowDateTime; ftWriteSrc.dwHighDateTime = fad.ftLastWriteTime.dwHighDateTime; } // // Attempt to open the destination file // if (!GetFileAttributesEx (lpDestFile, GetFileExInfoStandard, &fad)) { DWORD dwError; // // GetFileAttributesEx failed to query the destination // file. If the last error is file not found // then we automaticaly will copy the file. // dwError = GetLastError(); if (dwError == ERROR_FILE_NOT_FOUND) { iCopyFile = 1; } else { // // GetFileAttributesEx failed with some other error // DebugMsg((DM_WARNING, TEXT("ReconcileFile: GetFileAttributesEx on the destination failed with error = %d"), dwError)); dwErr = dwError; goto Exit; } } else { ftWriteDest.dwLowDateTime = fad.ftLastWriteTime.dwLowDateTime; ftWriteDest.dwHighDateTime = fad.ftLastWriteTime.dwHighDateTime; } } else { // // The CPD_FORCECOPY flag is turned on, set iCopyFile to 1. // iCopyFile = 1; } // // If iCopyFile is still zero, then we need to compare // the last write time stamps. // if (!iCopyFile) { LONG lResult; // // If the source is later than the destination // we need to copy the file. // lResult = CompareFileTime(&ftWriteSrc, &ftWriteDest); if (lResult == 1) { iCopyFile = 1; } if ( (dwFlags & CPD_COPYIFDIFFERENT) && (lResult == -1) ) { iCopyFile = 1; } } // // Copy the file if appropriate // if (iCopyFile) { BOOL bCancel = FALSE; TCHAR szTempFile[MAX_PATH + 1]; TCHAR szTempDir[MAX_PATH + 1]; LPTSTR lpTemp; DWORD dwCopyFlags; // // Clear any existing attributes // SetFileAttributes (lpDestFile, FILE_ATTRIBUTE_NORMAL); if (!(dwFlags & CPD_IGNORESECURITY)) dwCopyFlags = PRIVCOPY_FILE_METADATA | PRIVCOPY_FILE_SKIP_DACL; else dwCopyFlags = 0; dwCopyFlags |= PRIVCOPY_FILE_SUPERSEDE; // // Figure out what the destination directory is // lstrcpy (szTempDir, lpDestFile); lpTemp = szTempDir + lstrlen (szTempDir); while ((lpTemp > szTempDir) && (*lpTemp != TEXT('\\'))) { lpTemp--; } if (lpTemp == szTempDir) { lstrcpy (szTempDir, TEXT(".")); } else { *lpTemp = TEXT('\0'); } // // Generate a temporary file name // if (GetTempFileName (szTempDir, TEXT("prf"), 0, szTempFile)) { // // Copy the file to the temp file name // if (PrivCopyFileExW(lpSrcFile, szTempFile, (LPPROGRESS_ROUTINE) CopyProgressRoutine, NULL, &bCancel, dwCopyFlags)) { // If it is hive file then open the temporary file, flush and close it to make it more transacted if (bHiveFile) { HANDLE hTempFile; hTempFile = CreateFile(szTempFile, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); if ( hTempFile != INVALID_HANDLE_VALUE ) { if ( !FlushFileBuffers(hTempFile) ) DebugMsg((DM_WARNING, TEXT("ReconcileFile: Unable to flush temporary file"))); if ( !CloseHandle(hTempFile) ) DebugMsg((DM_WARNING, TEXT("ReconcileFile: Unable to close temporary file handle"))); } else DebugMsg((DM_WARNING, TEXT("ReconcileFile: Unable to open temporary file"))); } // // Delete the original file // if (!DeleteFile (lpDestFile)) { if (GetLastError() != ERROR_FILE_NOT_FOUND) { dwErr1 = GetLastError(); DebugMsg((DM_WARNING, TEXT("ReconcileFile: Failed to delete file <%s> with error = %d"), lpDestFile, dwErr1)); DeleteFile(szTempFile); goto CopyError; } } // // Rename the temp file to the original file name // if (!MoveFile (szTempFile, lpDestFile)) { DWORD dwError = ERROR_SUCCESS; //isolate MoveFile error from other below dwErr1 = GetLastError(); // // If we get access denied, let's try to remove the READ ONLY attribute (can't rename files // with +r attribute on a Netware Server) from the temp file, do the rename and restore the // attributes // if ( dwErr1 == ERROR_ACCESS_DENIED ) { if (!GetFileAttributesEx (szTempFile, GetFileExInfoStandard, &fad)) { dwError = GetLastError(); DebugMsg((DM_WARNING, TEXT("ReconcileFile: GetFileAttributes on file <%s> failed with error = %d\n"), szTempFile,dwError)); } else { if ( fad.dwFileAttributes & FILE_ATTRIBUTE_READONLY ) { dwErr1 = ERROR_SUCCESS ; if (!SetFileAttributes (szTempFile, fad.dwFileAttributes & ~FILE_ATTRIBUTE_READONLY)) { dwError = GetLastError(); DebugMsg((DM_WARNING, TEXT("ReconcileFile: SetFileAttributes on file <%s> failed with error = %d\n"), szTempFile,dwError)); } else { if (!MoveFile (szTempFile,lpDestFile)) { // Debug message displayed below dwErr1 = GetLastError(); } else { if ( !SetFileAttributes (lpDestFile,fad.dwFileAttributes) ) { dwError = GetLastError(); DebugMsg((DM_WARNING, TEXT("ReconcileFile: SetFileAttributes on file <%s> failed with error = %d\n"), szTempFile,dwError)); } } } } } } // End of ERROR_ACCESS_DENIED test if (dwErr1 != ERROR_SUCCESS || dwError != ERROR_SUCCESS) { DebugMsg((DM_WARNING, TEXT("ReconcileFile: Failed to rename file <%s> to <%s> with error = %d"), szTempFile, lpDestFile, dwErr1)); // do not remove it in this case. goto CopyError; } } DebugMsg((DM_VERBOSE, TEXT("ReconcileFile: %s ==> %s [OK]"), lpSrcFile, lpDestFile)); iCopyFile = 2; } else { dwErr1 = GetLastError(); DeleteFile(szTempFile); DebugMsg((DM_WARNING, TEXT("ReconcileFile: %s ==> %s [FAILED!!!]"), lpSrcFile, szTempFile)); DebugMsg((DM_WARNING, TEXT("ReconcileFile: CopyFile failed with error = %d"), dwErr1)); goto CopyError; } } else { dwErr1 = GetLastError(); DebugMsg((DM_WARNING, TEXT("ReconcileFile: GetTempFileName failed with %d"), dwErr1)); goto CopyError; } } else { // // No need to copy the file since the time stamps are the same // Set iCopyFile to 1 so the return value is success without // copying a file. // iCopyFile = 1; } goto Exit; CopyError: iCopyFile = 0; dwErr = dwErr1; Exit: SetLastError(dwErr); return iCopyFile; } //************************************************************* // // AddFileInfoNode() // // Purpose: Adds a node to the linklist of files // // Parameters: lpFileInfo - Link list to add to // lpSrcFile - Source filename // lpDestFile - Destination filename // ftLastWrite - Last write time stamp // ftCreationTime - File creation time // dwFileSize - Size of the file // dwFileAttribs - File attributes // // Return: TRUE if successful // FALSE if an error occurs // // Comments: // // History: Date Author Comment // 9/28/95 ericflo Created // //************************************************************* BOOL AddFileInfoNode (LPFILEINFO *lpFileInfo, LPTSTR lpSrcFile, LPTSTR lpDestFile, LPFILETIME ftLastWrite, LPFILETIME ftCreationTime, DWORD dwFileSize, DWORD dwFileAttribs, BOOL bHive) { LPFILEINFO lpNode; lpNode = (LPFILEINFO) LocalAlloc(LPTR, sizeof(FILEINFO)); if (!lpNode) { return FALSE; } lstrcpy (lpNode->szSrc, lpSrcFile); lstrcpy (lpNode->szDest, lpDestFile); lpNode->ftLastWrite.dwLowDateTime = ftLastWrite->dwLowDateTime; lpNode->ftLastWrite.dwHighDateTime = ftLastWrite->dwHighDateTime; lpNode->ftCreationTime.dwLowDateTime = ftCreationTime->dwLowDateTime; lpNode->ftCreationTime.dwHighDateTime = ftCreationTime->dwHighDateTime; lpNode->dwFileSize = dwFileSize; lpNode->bHive = bHive; lpNode->dwFileAttribs = (dwFileAttribs & ~FILE_ATTRIBUTE_DIRECTORY); lpNode->pNext = *lpFileInfo; *lpFileInfo = lpNode; return TRUE; } //************************************************************* // // FreeFileInfoList() // // Purpose: Free's a file info link list // // Parameters: lpFileInfo - List to be freed // // Return: TRUE if successful // FALSE if an error occurs // // Comments: // // History: Date Author Comment // 9/28/95 ericflo Created // //************************************************************* BOOL FreeFileInfoList (LPFILEINFO lpFileInfo) { LPFILEINFO lpNext; if (!lpFileInfo) { return TRUE; } lpNext = lpFileInfo->pNext; while (lpFileInfo) { LocalFree (lpFileInfo); lpFileInfo = lpNext; if (lpFileInfo) { lpNext = lpFileInfo->pNext; } } return TRUE; } //************************************************************* // // SyncItems() // // Purpose: Removes unnecessary items from the destination // directory tree // // Parameters: lpSrcItems - Link list of source items // lpDestItems - Link list of dest items // bFile - File or directory list // // Return: TRUE if successful // FALSE if an error occurs // Comments: // // History: Date Author Comment // 9/28/95 ericflo Created // //************************************************************* BOOL SyncItems (LPFILEINFO lpSrcItems, LPFILEINFO lpDestItems, BOOL bFile, LPFILETIME ftDelRefTime) { LPFILEINFO lpTempSrc, lpTempDest; // // Check for NULL pointers // #ifdef DBG if (ftDelRefTime) { SYSTEMTIME SystemTime; FileTimeToSystemTime(ftDelRefTime, &SystemTime); DebugMsg((DM_VERBOSE, TEXT("SyncItems: DelRefTime. Year: %d, Month %d, Day %d, Hour %d, Minute %d"), SystemTime.wYear, SystemTime.wMonth, SystemTime.wDay, SystemTime.wHour, SystemTime.wMinute)); } #endif if (!lpSrcItems || !lpDestItems) { return TRUE; } // // Loop through everyitem in lpDestItems to see if it // is in lpSrcItems. If not, delete it. // lpTempDest = lpDestItems; while (lpTempDest) { lpTempSrc = lpSrcItems; while (lpTempSrc) { if (lstrcmpi(lpTempDest->szSrc, lpTempSrc->szDest) == 0) { break; } lpTempSrc = lpTempSrc->pNext; } // // If lpTempSrc is NULL, then this file / directory is a candidate // for being deleted // if (!lpTempSrc) { BOOL bDelete = TRUE; // // If a delete reference time was offered, compare the // source time with the ref time and only delete files // which have a source time older than the ref time // if (ftDelRefTime) { if (CompareFileTime (&lpTempDest->ftLastWrite, ftDelRefTime) == 1) { bDelete = FALSE; } else if (CompareFileTime (&lpTempDest->ftCreationTime, ftDelRefTime) == 1) { bDelete = FALSE; } } if (bDelete) { // // Delete the file / directory // DebugMsg((DM_VERBOSE, TEXT("SyncItems: removing <%s>"), lpTempDest->szSrc)); if (bFile) { SetFileAttributes(lpTempDest->szSrc, FILE_ATTRIBUTE_NORMAL); if (!DeleteFile (lpTempDest->szSrc)) { DebugMsg((DM_WARNING, TEXT("SyncItems: Failed to delete <%s>. Error = %d."), lpTempDest->szSrc, GetLastError())); } } else { SetFileAttributes(lpTempDest->szSrc, FILE_ATTRIBUTE_NORMAL); if (!RemoveDirectory (lpTempDest->szSrc)) { DebugMsg((DM_WARNING, TEXT("SyncItems: Failed to remove <%s>. Error = %d"), lpTempDest->szSrc, GetLastError())); } } } else { DebugMsg((DM_VERBOSE, TEXT("SyncItems: New file or directory <%s> in destination since this profile was loaded. This will NOT be deleted."), lpTempDest->szSrc)); #ifdef DBG { SYSTEMTIME SystemTime; FileTimeToSystemTime(&lpTempDest->ftLastWrite, &SystemTime); DebugMsg((DM_VERBOSE, TEXT("SyncItems: File WriteTime. Year: %d, Month %d, Day %d, Hour %d, Minute %d"), SystemTime.wYear, SystemTime.wMonth, SystemTime.wDay, SystemTime.wHour, SystemTime.wMinute)); FileTimeToSystemTime(&lpTempDest->ftCreationTime, &SystemTime); DebugMsg((DM_VERBOSE, TEXT("SyncItems: File CreationTime. Year: %d, Month %d, Day %d, Hour %d, Minute %d"), SystemTime.wYear, SystemTime.wMonth, SystemTime.wDay, SystemTime.wHour, SystemTime.wMinute)); } #endif } } lpTempDest = lpTempDest->pNext; } return TRUE; } //************************************************************* // // CopyFileFunc() // // Purpose: Copies files // // Parameters: lpThreadInfo - Thread information // // Return: void // // Comments: // // History: Date Author Comment // 2/23/96 ericflo Created // //************************************************************* void CopyFileFunc (LPTHREADINFO lpThreadInfo) { HANDLE hInstDll; LPFILEINFO lpSrcFile; BOOL bRetVal = TRUE; DWORD dwError; TCHAR szErr[MAX_PATH]; hInstDll = LoadLibrary (TEXT("userenv.dll")); SetThreadDesktop (lpThreadInfo->hDesktop); while (TRUE) { if (lpThreadInfo->dwError) { break; } // // Query for the next file to copy.. // ignore the hive file since it is already copied.. // WaitForSingleObject(lpThreadInfo->hCopyEvent, INFINITE); do { lpSrcFile = lpThreadInfo->lpSrcFiles; if (lpSrcFile) lpThreadInfo->lpSrcFiles = lpThreadInfo->lpSrcFiles->pNext; } while (lpSrcFile && (lpSrcFile->bHive)); SetEvent(lpThreadInfo->hCopyEvent); // // If NULL, then we're finished. // if (!lpSrcFile || lpThreadInfo->dwError) { break; } // // Copy the file // if (!ReconcileFile (lpSrcFile->szSrc, lpSrcFile->szDest, lpThreadInfo->dwFlags, &lpSrcFile->ftLastWrite, lpSrcFile->dwFileSize, FALSE)) { if (!(lpThreadInfo->dwFlags & CPD_IGNORECOPYERRORS)) { WaitForSingleObject(lpThreadInfo->hCopyEvent, INFINITE); if (!(lpThreadInfo->dwError)) { dwError = GetLastError(); ReportError(lpThreadInfo->hTokenUser, ((lpThreadInfo->dwFlags & CPD_NOERRORUI) ? PI_NOUI:0), 3, EVENT_COPYERROR, lpSrcFile->szSrc, lpSrcFile->szDest, GetErrString(dwError, szErr)); lpThreadInfo->dwError = dwError; bRetVal = FALSE; } SetEvent(lpThreadInfo->hCopyEvent); break; } else { dwError = GetLastError(); ReportError(lpThreadInfo->hTokenUser, PI_NOUI | EVENT_WARNING_TYPE, 3, EVENT_COPYERROR, lpSrcFile->szSrc, lpSrcFile->szDest, GetErrString(dwError, szErr)); } } } // // Clean up // if (hInstDll) { FreeLibraryAndExitThread(hInstDll, bRetVal); } else { ExitThread (bRetVal); } } //************************************************************* // // ConvertExclusionList() // // Purpose: Converts the semi-colon profile relative exclusion // list to fully qualified null terminated exclusion // list // // Parameters: lpSourceDir - Profile root directory // lpExclusionList - List of directories to exclude // // Return: List if successful // NULL if an error occurs // //************************************************************* LPTSTR ConvertExclusionList (LPCTSTR lpSourceDir, LPCTSTR lpExclusionList) { LPTSTR lpExcludeList = NULL, lpInsert, lpEnd, lpTempList; LPCTSTR lpTemp, lpDir; TCHAR szTemp[MAX_PATH]; DWORD dwSize = 2; // double null terminator DWORD dwStrLen; // // Setup a temp buffer to work with // lstrcpy (szTemp, lpSourceDir); lpEnd = CheckSlash (szTemp); // // Loop through the list // lpTemp = lpDir = lpExclusionList; while (*lpTemp) { // // Look for the semicolon separator // while (*lpTemp && ((*lpTemp) != TEXT(';'))) { lpTemp++; } // // Remove any leading spaces // while (*lpDir == TEXT(' ')) { lpDir++; } // // Note: // Empty Spaces will not make the whole profile dir excluded // in RecurseDirectory. // // // Put the directory name on the temp buffer // lstrcpyn (lpEnd, lpDir, (int)(lpTemp - lpDir + 1)); DebugMsg((DM_VERBOSE, TEXT("ConvertExclusionList: Adding %s to ExclusionList"), szTemp)); // // Add the string to the exclusion list // if (lpExcludeList) { dwStrLen = lstrlen (szTemp) + 1; dwSize += dwStrLen; lpTempList = LocalReAlloc (lpExcludeList, dwSize * sizeof(TCHAR), LMEM_MOVEABLE | LMEM_ZEROINIT); if (!lpTempList) { DebugMsg((DM_WARNING, TEXT("ConvertExclusionList: Failed to realloc memory with %d"), GetLastError())); LocalFree (lpExcludeList); lpExcludeList = NULL; goto Exit; } lpExcludeList = lpTempList; lpInsert = lpExcludeList + dwSize - dwStrLen - 1; lstrcpy (lpInsert, szTemp); } else { dwSize += lstrlen (szTemp); lpExcludeList = LocalAlloc (LPTR, dwSize * sizeof(TCHAR)); if (!lpExcludeList) { DebugMsg((DM_WARNING, TEXT("ConvertExclusionList: Failed to alloc memory with %d"), GetLastError())); goto Exit; } lstrcpy (lpExcludeList, szTemp); } // // If we are at the end of the exclusion list, we're done // if (!(*lpTemp)) { goto Exit; } // // Prep for the next entry // lpTemp++; lpDir = lpTemp; } Exit: return lpExcludeList; } //************************************************************* // // FindDirectorySize() // // Purpose: Takes the Directory Name and the list of files // returned by RecurseDir and gets the total size. // // Parameters: lpDir - '\' terminated Source Directory // lpFiles - List of files to be copied // dwFlags - Flags // pdwLargestHiveFile - optional parameter that // returns the largest hive // file size. // pdwTotalFiles - the size of the directory // // Return: Win32 error code. // //************************************************************* DWORD FindDirectorySize(LPTSTR lpDir, LPFILEINFO lpFiles, DWORD dwFlags, DWORD* pdwLargestHiveFile, DWORD* pdwTotalFiles) { LPFILEINFO lpTemp = NULL; if(pdwLargestHiveFile) { *pdwLargestHiveFile = 0; } if(!pdwTotalFiles) { SetLastError(ERROR_INVALID_PARAMETER); return ERROR_INVALID_PARAMETER; } else { *pdwTotalFiles = 0; } lpTemp = lpFiles; while (lpTemp) { if (lpTemp->bHive) { if (!(dwFlags & CPD_IGNOREHIVE)) { if(pdwLargestHiveFile && (*pdwLargestHiveFile < lpTemp->dwFileSize)) { *pdwLargestHiveFile = lpTemp->dwFileSize; } *pdwTotalFiles += lpTemp->dwFileSize; } } else { *pdwTotalFiles += lpTemp->dwFileSize; } lpTemp = lpTemp->pNext; } return ERROR_SUCCESS; } //************************************************************* // // FindTotalDiskSpaceNeeded() // // Purpose: Calculate the maximum amount of disk space on the // destination drive that is needed to reconcile the // source and the destination directories. The // algorithm is as follows: // max(source size, destination size) + // NUM_COPY_THREADS * size of the largest file in source dir - // destination size // The reason for this algorithm is that the copy // operation is done by NUM_COPY_THREADS threads. // They copy the files to a temp file and then delete // the destination file and rename the temp file. // // Parameters: dwTotalSrcFiles total size of the source files // dwTotalDestFiles total size of the destination files // dwLargestHiveFile largest hive file // lpSrcFiles List of source files // dwFlags - Flags // // Return: Disk space needed. // // History: Created WeiruC 2/10/2000 // //************************************************************* DWORD FindTotalDiskSpaceNeeded(DWORD dwTotalSrcFiles, DWORD dwTotalDestFiles, DWORD dwLargestHiveFile, LPFILEINFO lpSrcFiles, DWORD dwFlags) { DWORD dwNumOfCopyThreads = NUM_COPY_THREADS; DWORD dwDiskSpaceNeeded = 0; LPFILEINFO lpCur = lpSrcFiles; DWORD i, j; // loop counters // // Check for empty file list. // if(!lpSrcFiles) { return dwLargestHiveFile; } // // How many copy threads are there actually? // if(dwFlags & CPD_SLOWCOPY) { dwNumOfCopyThreads = 1; } // // Find the size of the largest file in the source file list. The hive // files are not in this file list, be careful not to forget them. Hive // files have to be treated very carefully because they are always copied // over before we create those copy threads. // dwDiskSpaceNeeded = FindTotalNMaxFileSize(lpSrcFiles, dwNumOfCopyThreads); DebugMsg((DM_VERBOSE, TEXT("FindTotalDiskSpaceNeeded: Largest %d file size is %d"), dwNumOfCopyThreads, dwDiskSpaceNeeded)); // // The actual disk space needed. // if(dwDiskSpaceNeeded < dwLargestHiveFile) { dwDiskSpaceNeeded = dwLargestHiveFile; } if(dwTotalSrcFiles > dwTotalDestFiles) { dwDiskSpaceNeeded += dwTotalSrcFiles - dwTotalDestFiles; } // // It is too much of a pain to actually figure out cluster size impact. // We'll just add an extra 10% of the disk space needed. // dwDiskSpaceNeeded += dwDiskSpaceNeeded / 10; return dwDiskSpaceNeeded; } //************************************************************* // // FindTotalNMaxFileSize() // // Purpose: Calculates the total size for dwNumOfFiles // number of largest files. // // Parameters: lpSrcFiles - List of source files // dwNumOfFiles - Number of files. // dwNumOfFiles <= NUM_COPY_THREADS // // Return: Disk space needed for n largest files. // // History: Created santanuc 10/03/2000 // //************************************************************* DWORD FindTotalNMaxFileSize(LPFILEINFO lpSrcFiles, DWORD dwNumOfFiles) { DWORD pdwNMaxVal[NUM_COPY_THREADS], dwIndex; LPFILEINFO lpCur; DWORD dwTotalSize = 0, dwTmp; if (!lpSrcFiles) return 0; for(dwIndex = 0; dwIndex < dwNumOfFiles; dwIndex++) { pdwNMaxVal[dwIndex] = 0; } for(lpCur = lpSrcFiles; lpCur; lpCur = lpCur->pNext) { if (!lpCur->bHive) { dwIndex = dwNumOfFiles-1; if (lpCur->dwFileSize > pdwNMaxVal[dwIndex]) { pdwNMaxVal[dwIndex] = lpCur->dwFileSize; while (dwIndex > 0 && pdwNMaxVal[dwIndex] > pdwNMaxVal[dwIndex-1]) { dwTmp = pdwNMaxVal[dwIndex-1]; pdwNMaxVal[dwIndex-1] = pdwNMaxVal[dwIndex]; pdwNMaxVal[dwIndex] = dwTmp; dwIndex--; } } } } for(dwIndex = 0; dwIndex < dwNumOfFiles; dwIndex++) { dwTotalSize += pdwNMaxVal[dwIndex]; } return dwTotalSize; }