// Copyright (c) <1995-1999> Microsoft Corporation #include "shellprv.h" #pragma hdrstop #include #include #include // for TreeResetNamedSecurityInfo #include "shlwapip.h" // for SHGlobalCounterDecrement #include "ynlist.h" #define INTERNAL_COPY_ENGINE #include "copy.h" #include "shell32p.h" #include "control.h" #include "cdburn.h" #include "propsht.h" #include "prshtcpp.h" #define REG_VAL_GENERAL_RENAMEHTMLFILE TEXT("RenameHtmlFile") #define TF_DEBUGCOPY 0x00800000 #define VERBOSE_STATUS // REVIEW, we should tune this size down as small as we can // to get smoother multitasking (without effecting performance) #define COPYMAXBUFFERSIZE 0x10000 // 0xFFFF this is 32-bit code! #define MIN_MINTIME4FEEDBACK 5 // is it worth showing estimated time to completion feedback? #define MS_RUNAVG 10000 // ms, window for running average time to completion estimate #define MS_TIMESLICE 2000 // ms, (MUST be > 1000!) first average time to completion estimate #define MAXDIRDEPTH 128 // # of directories we will deal with recursivly #define SHOW_PROGRESS_TIMEOUT 1000 // 1 second #define MINSHOWTIME 1000 // 1 sec // progress dialog message #define PDM_SHUTDOWN WM_APP #define PDM_NOOP (WM_APP + 1) #define PDM_UPDATE (WM_APP + 2) #define OPER_MASK 0x0F00 #define OPER_ENTERDIR 0x0100 #define OPER_LEAVEDIR 0x0200 #define OPER_DOFILE 0x0300 #define OPER_ERROR 0x0400 #define FOFuncToStringID(wFunc) (IDS_UNDO_FILEOP + wFunc) // // The following is a list of folder suffixes in all international languages. This list is NOT // read from a resource because we do NOT want the strings in this list to be mistakenly localized. // This list will allow NT5 shell to operate on files created by any international version of // office 9. // This list is taken from "http://officeweb/specs/webclient/files.htm" // // WARNING: Do not localize the strings in this table. Do not make any changes to this table // without consulting AlanRa (Office9 PM) // static const LPCTSTR c_apszSuffixes[] = { TEXT(".files"), TEXT("_files"), TEXT("-Dateien"), TEXT("_fichiers"), TEXT("_bestanden"), TEXT("_file"), TEXT("_archivos"), TEXT("-filer"), TEXT("_tiedostot"), TEXT("_pliki"), TEXT("_soubory"), TEXT("_elemei"), TEXT("_ficheiros"), TEXT("_arquivos"), TEXT("_dosyalar"), TEXT("_datoteke"), TEXT("_fitxers"), TEXT("_failid"), TEXT("_fails"), TEXT("_bylos"), TEXT("_fajlovi"), TEXT("_fitxategiak"), }; // The reg value under HKCU\REGSTR_PATH_EXPLORER that specifies Connection ON/OFF switch #define REG_VALUE_NO_FILEFOLDER_CONNECTION TEXT("NoFileFolderConnection") //////////////////////////////////////////////////////////////////////////// ///// directory tree cache. // this is set if pdtnChild has not been traversed (as opposed to NULL which means // there are no children #define DTN_DELAYED ((PDIRTREENODE)-1) // DIRTREENODE is a node in a linked list/tree cache of the directory structure. // except for the top level (which is specified by the caller of the api), the order // are all files first, then all directories. typedef struct _dirtreenode { struct _dirtreenode *pdtnNext; // sibling struct _dirtreenode *pdtnChild; // head of children linked list struct _dirtreenode *pdtnParent; DWORD dwFileAttributes; FILETIME ftCreationTime; FILETIME ftLastWriteTime; DWORD nFileSizeLow; DWORD nFileSizeHigh; LARGE_INTEGER liFileSizeCopied; BOOL fNewRoot : 1; BOOL fDummy : 1; // this marks the node as a dummy node (a wildcard that didn't match anything) BOOL fConnectedElement : 1; // this marks the node as an element that was implicitly added // to the Move/Copy source list because of an office9 type of // connection established in the registry. //The following is a union because not all nodes need all the fields. union { // The following is valid only if fConnectedElement is FALSE. struct _dirtreenode *pdtnConnected; // The following structure is valid only if fConnectedElemet is TRUE. struct { LPTSTR pFromConnected; // if fNewRoot && fConnectedElement, then these two elements LPTSTR pToConnected; // have the pFrom and pTo. DWORD dwConfirmation; // The result of confirnation given by end-user } ConnectedInfo; }; TCHAR szShortName[14]; TCHAR szName[1]; // this struct is dynamic } DIRTREENODE, *PDIRTREENODE; typedef struct { BOOL fChanged; DWORD dwFiles; // number of files DWORD dwFolders; // number of folders LARGE_INTEGER liSize; // total size of all files } DIRTOTALS, *PDIRTOTALS; typedef struct { UINT oper; DIRTOTALS dtAll; // totals for all files DIRTOTALS dtDone; // totals of what's done BOOL fChangePosted; PDIRTREENODE pdtn; // first directory tree node PDIRTREENODE pdtnCurrent; PDIRTREENODE pdtnConnectedItems; //Pointer to the begining of connected elements node. TCHAR bDiskCheck[26]; // how much does each operation cost in the progress... int iFilePoints; int iFolderPoints; int iSizePoints; LPTSTR pTo; // this holds the top level target list LPTSTR pFrom; // this holds the top level source list BOOL fMultiDest; TCHAR szSrcPath[MAX_PATH]; TCHAR szDestPath[MAX_PATH]; // this is the current destination for pdtn and all it's children (not siblings) // lpszDestPath includes pdtn's first path component HDSA hdsaRenamePairs; } DIRTREEHEADER, *PDIRTREEHEADER; // We spend a lot of time creating simple PIDLs, so use this cache // to speed things up. typedef struct SIMPLEPIDLCACHE { IBindCtx *pbcFile; // Empty filesys bind context for files IBindCtx *pbcFolder; // Empty filesys bind context for folders IShellFolder *psfDesktop; // Desktop folder (for ParseDisplayName) int iInit; // 0 = not inited; 1 = inited; -1 = init failed IShellFolder *psf; // Current folder LPITEMIDLIST pidlFolder; // Current folder TCHAR szFolder[MAX_PATH]; // Current folder } SIMPLEPIDLCACHE, *PSIMPLEPIDLCACHE; typedef struct { int nRef; // struct reference count int nSourceFiles; LPTSTR lpCopyBuffer; // global file copy buffer UINT uSize; // size of this buffer FILEOP_FLAGS fFlags; // from SHFILEOPSTRUCT HWND hwndProgress; // dialog/progress window HWND hwndDlgParent; // parent window for message boxes CONFIRM_DATA cd; // confirmation stuff UNDOATOM *lpua; // the undo atom that this file operation will make BOOL fNoConfirmRecycle; BOOL bAbort; BOOL fMerge; // are we doing a merge of folders BOOL fDone; BOOL fProgressOk; BOOL fDTBuilt; BOOL fLostEncryptOk; BOOL fFromCDRom; // Clear readonly bits if copying from CDRom // folowing fields are used for giving estimated time for completion // feedback to the user during longer than MINTIME4FEEDBACK operations BOOL fFlushWrites; // Should we flush writes for destinations on slow links DWORD dwPreviousTime; // calculate transfer rate int iLastProgressPoints; // how many progress points we had the last time we updated the time est DWORD dwPointsPerSec; LPCTSTR lpszProgressTitle; LPSHFILEOPSTRUCT lpfo; DIRTREEHEADER dth; BOOL fInitialize; const WIN32_FIND_DATA* pfd; BOOL bStreamLossPossible; // Could stream loss happen in this directory? SIMPLEPIDLCACHE spc; } COPY_STATE, *LPCOPY_STATE; // we have a seperate struct that we pass off to the FOUIThread so that he can get to the pcs, // but since the FOUIThread can outlive the main thread (!!) in some cases, we can't let him have a // ref to pcs->lpfo since it is owned by SHFileOperations caller and we crash if we try to refrence // it after SHFileOperation returns and the caller has freed the memory. The only two things the // FOUIThread uses out of the pcs->lpfo are the wFunc and the lpszProgressTitle (to see if the // recycle bin was being emptied or not), so we make private copies of that info for the thread. typedef struct { COPY_STATE* pcs; UINT wFunc; BOOL bIsEmptyRBOp; } FOUITHREADINFO, *PFOUITHREADINFO; // Information to determine folder's movability to the recycle bin typedef struct { BOOL bProcessedRoot; // tells if we are the first call in the recursive chain and we need to do root-specific processing int cchBBDir; // count of characters in the recycle bin dir (eg "C:\Recycler\") int cchDelta; // count of characters that the path will increase (or decrease if negative) by when moved under the recycle bin directory ULONGLONG cbSize; // size of the folder TCHAR szNonDeletableFile[MAX_PATH]; // an output buffer that holds the name of the file that cannot be deleted, if one exists TCHAR szPath[MAX_PATH]; // scratch buffer for stack savings when recursing WIN32_FIND_DATA fd; // also for stack savings } FOLDERDELETEINFO; // function declarations void _ProcessNameMappings(LPTSTR pszTarget, HDSA hdsaRenamePairs); int GetNameDialog(HWND hwnd, COPY_STATE *pcs, BOOL fMultiple,UINT wOp, LPTSTR pFrom, LPTSTR pTo); void AddRenamePairToHDSA(LPCTSTR pszOldPath, LPCTSTR pszNewPath, HDSA* phdsaRenamePairs); BOOL FOQueryAbort(COPY_STATE *pcs); UINT DTAllocConnectedItemNodes(PDIRTREEHEADER pdth, COPY_STATE *pcs, WIN32_FIND_DATA *pfd, LPTSTR pszPath, BOOL fRecurse, PDIRTREENODE *ppdtnConnectedItems); void CALLBACK FOUndo_Invoke(UNDOATOM *lpua); LONG CheckFolderSizeAndDeleteability(LPCTSTR pszDir, FOLDERDELETEINFO* pfdi, LPCOPY_STATE pcs); BOOL DeleteFileBB(LPTSTR pszFile, INT *piReturn, COPY_STATE *pcs, BOOL fIsDir, WIN32_FIND_DATA *pfd, HDPA *phdpaDeletedFiles); BOOL DTDiskCheck(PDIRTREEHEADER pdth, COPY_STATE *pcs, LPTSTR pszPath) { int iDrive = PathGetDriveNumber(pszPath); if (iDrive != -1) { if (!pdth->bDiskCheck[iDrive]) { HWND hwnd = pcs->hwndDlgParent; TCHAR szDrive[] = TEXT("A:\\"); szDrive[0] += (CHAR)iDrive; // Sometimes pszPath is a dir and sometimes it's a file. All we really care about is if the // drive is ready (inserted, formated, net path mapped, etc). We know that we don't have a // UNC path because PathGetDriveNumber would have failed and we are already busted in terms // of mounted volumes, again because we use PathGetDriveNumber, so we don't have to worry about // these two cases. As such we build the root path and use that instead. pdth->bDiskCheck[iDrive] = SUCCEEDED(SHPathPrepareForWrite(((pcs->fFlags & FOF_NOERRORUI) ? NULL : hwnd), NULL, szDrive, 0)); } return pdth->bDiskCheck[iDrive]; } return TRUE; // always succeed for net drives } //-------------------------------------------------------------------------------------------- // Simple pidl cache stuff //-------------------------------------------------------------------------------------------- void SimplePidlCache_Release(SIMPLEPIDLCACHE *pspc) { ATOMICRELEASE(pspc->pbcFile); ATOMICRELEASE(pspc->pbcFolder); ATOMICRELEASE(pspc->psfDesktop); ATOMICRELEASE(pspc->psf); ILFree(pspc->pidlFolder); } const WIN32_FIND_DATA c_fdFolder = { FILE_ATTRIBUTE_DIRECTORY }; BOOL SimplePidlCache_Init(SIMPLEPIDLCACHE *pspc) { ASSERT(pspc->iInit == 0); if (SUCCEEDED(SHCreateFileSysBindCtx(NULL, &pspc->pbcFile)) && SUCCEEDED(SHCreateFileSysBindCtx(&c_fdFolder, &pspc->pbcFolder)) && SUCCEEDED(SHGetDesktopFolder(&pspc->psfDesktop))) { pspc->psf = pspc->psfDesktop; pspc->psf->lpVtbl->AddRef(pspc->psf); // It's okay to leave pidlFolder as NULL; ILCombine won't barf pspc->iInit = 1; return TRUE; } else { pspc->iInit = -1; return FALSE; } } LPITEMIDLIST SimplePidlCache_GetFilePidl(SIMPLEPIDLCACHE *pspc, LPCTSTR pszFile) { LPITEMIDLIST pidlChild; LPITEMIDLIST pidlRet; LPTSTR pszFileName; TCHAR szFolder[MAX_PATH]; USES_CONVERSION; if (pspc->iInit < 0) return NULL; // Initialization failed if (!pspc->iInit && !SimplePidlCache_Init(pspc)) return NULL; // If this file is in a different folder from the one we cached, // need to dump the old one and get a new one. lstrcpyn(szFolder, pszFile, ARRAYSIZE(szFolder)); PathRemoveFileSpec(szFolder); // We use StrCmpC instead of lstrcmpi because the vast majority // of the time, the path will match even in case, and if we get // it wrong, it's no big whoop: we just don't use the cache. if (StrCmpC(pspc->szFolder, szFolder) != 0) { LPITEMIDLIST pidlFolder = NULL; // In case it's on the desktop IShellFolder *psf; if (szFolder[0]) // An actual folder { // Get a simple pidl to the folder. if (FAILED(pspc->psfDesktop->lpVtbl->ParseDisplayName(pspc->psfDesktop, NULL, pspc->pbcFolder, T2W(szFolder), NULL, &pidlFolder, NULL))) return NULL; } else // Going for the desktop { /* pidlFolder already preinitialized to NULL */ } // Bind to that folder if (FAILED(SHBindToObject(pspc->psfDesktop, IID_X_PPV_ARG(IShellFolder, pidlFolder, &psf)))) { ILFree(pidlFolder); return NULL; } // Woo-hoo, everybody is happy. Save the results into our cache. ATOMICRELEASE(pspc->psf); pspc->psf = psf; ILFree(pspc->pidlFolder); pspc->pidlFolder = pidlFolder; lstrcpyn(pspc->szFolder, szFolder, ARRAYSIZE(pspc->szFolder)); } // Get a simple pidl to the filename pszFileName = PathFindFileName(pszFile); // T2W is a macro with multiple evaluation if (FAILED(pspc->psf->lpVtbl->ParseDisplayName(pspc->psf, NULL, pspc->pbcFile, T2W(pszFileName), NULL, &pidlChild, NULL))) return NULL; // Combine it with the parent pidlRet = ILCombine(pspc->pidlFolder, pidlChild); ILFree(pidlChild); return pidlRet; } //-------------------------------------------------------------------------------------------- // ConvertToConnectedItemname: // Given a file/folder name, this function checks to see if it has any connection and if // there is a connection, then it will convert the given name to that of the connected element // and return length of the prefix. If no connection exists, it returns zero. // The fDirectory parameter specifies if the given filename is a FOLDER or not! // // dwBuffSize: The size of pszFileName buffer in CHARACTERS. // // Examples: // "foo.htm" => "foo*" (returns 3 because the prefix("foo") length is 3) // "foobar files" => "foobar.htm?" (returns 6 as the prefix length) // //-------------------------------------------------------------------------------------------- int ConvertToConnectedItemName(LPTSTR pszFileName, DWORD dwBuffSize, BOOL fDirectory) { LPTSTR pszDest, pszConnectedElemSuffix; int iPrefixLength; if (fDirectory) { // Look for a suffix which is one of the standard suffixes. if (!(pszDest = (LPTSTR)PathFindSuffixArray(pszFileName, c_apszSuffixes, ARRAYSIZE(c_apszSuffixes)))) return FALSE; // " files" suffix is found. Replace it with ".htm?" pszConnectedElemSuffix = TEXT(".htm?"); } else { // Look for the extension ".htm" or ".html" and replace it with "*". if (!(pszDest = PathFindExtension(pszFileName))) return FALSE; if (lstrcmpi(pszDest, TEXT(".htm")) && (lstrcmpi(pszDest, TEXT(".html")))) return FALSE; // Extension ".htm" or ".html" is found. Replace it with "*" pszConnectedElemSuffix = (LPTSTR)c_szStar; } iPrefixLength = (int)(pszDest - pszFileName); //Check if the input buffer is big enough to over-write the suffix in-place if ((((int)dwBuffSize - iPrefixLength) - 1) < lstrlen(pszConnectedElemSuffix)) return 0; //Replace the source suffix with the connected element's suffix. lstrcpy(pszDest, pszConnectedElemSuffix); return(iPrefixLength); } PDIRTREENODE DTAllocNode(PDIRTREEHEADER pdth, WIN32_FIND_DATA* pfd, PDIRTREENODE pdtnParent, PDIRTREENODE pdtnNext, BOOL fConnectedElement) { int iLen = pfd ? lstrlen(pfd->cFileName) * sizeof(TCHAR) : 0; PDIRTREENODE pdtn = (PDIRTREENODE)LocalAlloc(LPTR, sizeof(DIRTREENODE) + iLen); if (pdtn) { pdtn->fConnectedElement = fConnectedElement; // Initializing the following to NULL is not needed because of the LPTR (zero init) done // above. // if (fConnectedElement) //{ // pdtn->ConnectedInfo.pFromConnected = pdtn->ConnectedInfo.pToConnected = NULL; // pdtn->ConnectedInfo.dwConfirmation = 0; //} //else // pdtn->pdtnConnected = NULL; pdtn->pdtnParent = pdtnParent; pdtn->pdtnNext = pdtnNext; if (pfd) { pdtn->dwFileAttributes = pfd->dwFileAttributes; pdtn->ftCreationTime = pfd->ftCreationTime; pdtn->ftLastWriteTime = pfd->ftLastWriteTime; pdtn->nFileSizeLow = pfd->nFileSizeLow; pdtn->nFileSizeHigh = pfd->nFileSizeHigh; // only the stuff we care about lstrcpy(pdtn->szShortName, pfd->cAlternateFileName); lstrcpy(pdtn->szName, pfd->cFileName); if (ISDIRFINDDATA(*pfd)) { pdth->dtAll.dwFolders++; pdtn->pdtnChild = DTN_DELAYED; } else { LARGE_INTEGER li; li.LowPart = pfd->nFileSizeLow; li.HighPart = pfd->nFileSizeHigh; pdth->dtAll.liSize.QuadPart += li.QuadPart; pdth->dtAll.dwFiles++; } // increment the header stats pdth->dtAll.fChanged = TRUE; } } return pdtn; } #if defined(DEBUG) /// && defined(DEBUGCOPY) void DebugDumpPDTN(PDIRTREENODE pdtn, LPTSTR ptext) { DebugMsg(TF_DEBUGCOPY, TEXT("***** PDTN %x (%s)"), pdtn, ptext); //Safe-guard against pdtn being NULL! if (pdtn) { DebugMsg(TF_DEBUGCOPY, TEXT("** %s %s"), pdtn->szShortName, pdtn->szName); DebugMsg(TF_DEBUGCOPY, TEXT("** %x %d"), pdtn->dwFileAttributes, pdtn->nFileSizeLow); DebugMsg(TF_DEBUGCOPY, TEXT("** %x %x %x"), pdtn->pdtnParent, pdtn->pdtnNext, pdtn->pdtnChild); DebugMsg(TF_DEBUGCOPY, TEXT("** NewRoot:%x, Connected:%x, Dummy:%x"), pdtn->fNewRoot, pdtn->fConnectedElement, pdtn->fDummy); if (pdtn->fConnectedElement) { DebugMsg(TF_DEBUGCOPY, TEXT("**** Connected: pFromConnected:%s, pToConnected:%s, dwConfirmation:%x"), pdtn->ConnectedInfo.pFromConnected, pdtn->ConnectedInfo.pToConnected, pdtn->ConnectedInfo.dwConfirmation); } else { DebugMsg(TF_DEBUGCOPY, TEXT("**** Origin: pdtnConnected:%x"), pdtn->pdtnConnected); } } else { DebugMsg(TF_DEBUGCOPY, TEXT("** NULL pointer(PDTN)")); } } #else #define DebugDumpPDTN(p, x) 0 #endif BOOL DoesSuffixMatch(LPTSTR lpSuffix, const LPCTSTR *apSuffixes, int iArraySize) { while (iArraySize--) { // Note: This must be a case sensitive compare, because we don't want to pickup // "Program Files". if (!lstrcmp(lpSuffix, *apSuffixes++)) return TRUE; } return FALSE; } //-------------------------------------------------------------------------------------------- // // DTPathToDTNode: // This function is used to build a list of nodes that correspond to the given pszPath. // This list is built under "ppdtn". If ppdtnConnectedItems is given, another list of nodes that // correspond to the connected elements(files/folders) of the nodes in the first list is also built // under "ppdtnConnectedItems". // // WARNING: This parties directly on pszPath and pfd so that it doesn't need to allocate // on the stack. This recurses, so we want to use as little stack as possible // // this will wack off one component from pszPath // // // ppdtn: Points to where the header of the list being built will be stored. // ppdtnConnectedItems: If this is NULL, then we are not interested in finding and building the // connected elements. If this is NOT null, it points to where the header of // the connected items list will be stored. // fConnectedElement: Each node being built under ppdtn needs to be marked with this bit. // iPrefixLength: This parameter is zero if fConnectedElement is FALSE. Otherwise, it contains the // Length of the prefix part of the file or foldername (path is NOT included). // For example, if "c:\windows\foo*" is passed in, iPrefixLength is 3 (length of "foo") // // dwFilesOrFolders parameter can specify if we need to look for only FILES or FOLDERs or BOTH. #define DTF_FILES_ONLY 0x00000001 //Operate only on Files. #define DTF_FOLDERS_ONLY 0x00000002 //Operate only on Folders. #define DTF_FILES_AND_FOLDERS (DTF_FILES_ONLY | DTF_FOLDERS_ONLY) //Operate on files AND folders. UINT DTPathToDTNode(PDIRTREEHEADER pdth, COPY_STATE *pcs, LPTSTR pszPath, BOOL fRecurse, DWORD dwFilesOrFolders, PDIRTREENODE* ppdtn, WIN32_FIND_DATA *pfd, PDIRTREENODE pdtnParent, PDIRTREENODE* ppdtnConnectedItems, BOOL fConnectedElement, int iPrefixLength) { int iError = 0; // this points to the var where all items are inserted. // folders are placed after it, files are placed before // keep the stack vars to a minimum because this is recursive PDIRTREENODE *ppdtnMiddle = ppdtn; BOOL fNeedToFindNext = TRUE; HANDLE hfind = FindFirstFile(pszPath, pfd); DebugMsg(TF_DEBUGCOPY, TEXT("DTPathToDTNode Entering %s"), pszPath); *ppdtnMiddle = NULL; // in case there are no children if (hfind == INVALID_HANDLE_VALUE) { // this is allowable only if the path is wild... // and the parent exists if (PathIsWild(pszPath)) { PathRemoveFileSpec(pszPath); if (PathFileExists(pszPath)) { return 0; } } return OPER_ERROR | ERROR_FILE_NOT_FOUND; } //Remove the filespec before passing it onto DTAllocConnectedItemNodes. PathRemoveFileSpec(pszPath); do { // We skip the following files: // "." and ".." filenames // Folders when DTF_FILES_ONLY is set // Files when DTF_FOLDERS_ONLY is set if (!PathIsDotOrDotDot(pfd->cFileName) && (((dwFilesOrFolders & DTF_FILES_ONLY) && !ISDIRFINDDATA(*pfd)) || ((dwFilesOrFolders & DTF_FOLDERS_ONLY) && ISDIRFINDDATA(*pfd)))) { //Check if we are looking for connected elements if ((!pdtnParent) && fConnectedElement) { // We found what we are looking for. If we are looking for a top-level connected item and // if it is a folder, then we need to make sure that the suffix exactly matches one of the // suffixes in the array c_apszSuffixes[]. LPTSTR lpSuffix = (LPTSTR)(pfd->cFileName + iPrefixLength); if (ISDIRFINDDATA(*pfd)) { // What we found is a directory! // See if it has one of the standard suffixes for connected folders. if (!DoesSuffixMatch(lpSuffix, c_apszSuffixes, ARRAYSIZE(c_apszSuffixes))) continue; //This is not what we look for. So, find next. } else { // What we found is a file (i.e Not a directory) // See if it has one of the standard suffixes for html files. if (lstrcmpi(lpSuffix, TEXT(".htm")) && lstrcmpi(lpSuffix, TEXT(".html"))) continue; //This is not what we look for. So, find next. } // Now we know that we found the connected element that we looked for. // So, no need to FindNext again. We can get out of the loop after processing // it once. fNeedToFindNext = FALSE; } *ppdtnMiddle = DTAllocNode(pdth, pfd, pdtnParent, *ppdtnMiddle, fConnectedElement); if (!*ppdtnMiddle) { FindClose(hfind); return OPER_ERROR | ERROR_NOT_ENOUGH_MEMORY; } // make sure that the parent's pointer always points to the head of // this linked list if (*ppdtn == (*ppdtnMiddle)->pdtnNext) *ppdtn = (*ppdtnMiddle); DebugDumpPDTN(*ppdtnMiddle, TEXT("DTPathToDTNode, DTAllocNode")); //We need to check for Connected elements only for the top level items if ((!(pcs->fFlags & FOF_NO_CONNECTED_ELEMENTS)) && ppdtnConnectedItems) { //Make sure this is a top level item ASSERT(!pdtnParent); //Create a list of connected items and attach it to the head of the list. iError = DTAllocConnectedItemNodes(pdth, pcs, pfd, pszPath, fRecurse, ppdtnConnectedItems); DebugDumpPDTN(*ppdtnConnectedItems, TEXT("DTPathToDTNode, DTAllocConnectedNodes")); // It is possible that the connected files do not exist. That condition is not really // an error. So, we check for insufficient memory error condition alone here. if (iError == (OPER_ERROR | ERROR_NOT_ENOUGH_MEMORY)) { FindClose(hfind); return(iError); } //If a connected item exists, then make the origin item point to this connected item. if (*ppdtnConnectedItems) { (*ppdtnMiddle)->pdtnConnected = *ppdtnConnectedItems; // Also by default, set the Confirmation result to NO so that the connected element // will not be copied/moved etc., in case of a conflict. However, if the origin had // a conflict, we would put up a confirmation dlg and the result of that dlg will // over-write this value. (*ppdtnConnectedItems)->ConnectedInfo.dwConfirmation = IDNO; } //Move to the last node in the connected items list. while (*ppdtnConnectedItems) ppdtnConnectedItems = &((*ppdtnConnectedItems)->pdtnNext); } else { // This should have been initialized to zero during allocation, but lets be paranoid ASSERT(NULL == (*ppdtnMiddle)->pdtnConnected); } // if this is not a directory, move the ppdtnMiddle up one if (!ISDIRFINDDATA(*pfd)) { ppdtnMiddle = &(*ppdtnMiddle)->pdtnNext; } } } while (fNeedToFindNext && !FOQueryAbort(pcs) && FindNextFile(hfind, pfd)); iError = 0; //It is possible that iError contains other errors value now! So, reset it! FindClose(hfind); // now go and recurse into folders (if desired) // we don't have to check to see if these pdtn's are dirs, because the // way we inserted them above ensures that everything in from of // ppdtnMiddle are folders // we're going to tack on a specific child // then add the *.* after that while (!FOQueryAbort(pcs) && *ppdtnMiddle) { BOOL fRecurseThisItem = fRecurse; if ((*ppdtnMiddle)->dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) { // Recurse into reparse points unless they asked not to if (pcs->fFlags & FOF_NORECURSEREPARSE) { fRecurseThisItem = FALSE; } } if (fRecurseThisItem) { if (PathAppend(pszPath, (*ppdtnMiddle)->szName)) { if (PathAppend(pszPath, c_szStarDotStar)) { // NULL indicates that we do not want to get the connected elements. // This is because we want the connected elements only for the top-level items. iError = DTPathToDTNode(pdth, pcs, pszPath, TRUE, DTF_FILES_AND_FOLDERS, &((*ppdtnMiddle)->pdtnChild), pfd, *ppdtnMiddle, NULL, fConnectedElement, 0); } else { iError = OPER_ERROR | DE_INVALIDFILES; } PathRemoveFileSpec(pszPath); } else { iError = OPER_ERROR | DE_INVALIDFILES; } } else { // if we don't want to recurse, just mark them all as having no children (*ppdtnMiddle)->pdtnChild = NULL; } if (iError) { return iError; } ppdtnMiddle = &(*ppdtnMiddle)->pdtnNext; } return 0; } UINT DTAllocConnectedItemNodes(PDIRTREEHEADER pdth, COPY_STATE *pcs, WIN32_FIND_DATA *pfd, LPTSTR pszPath, BOOL fRecurse, PDIRTREENODE *ppdtnConnectedItems) { // Since DTAllocConnectedItemNodes() gets called only for the top-level items in the src list, // there is no danger of this function getting called recursively. Hence, I didn't worry about // allocating the following on the stack. // If "too-much-stack-is-used" problem arises, we can optimize the stack usage by splitting // the following function into two such that the most common case (of no connection) // doesn't use much stack. DWORD dwFileOrFolder; TCHAR szFullPath[MAX_PATH]; TCHAR szFileName[MAX_PATH]; WIN32_FIND_DATA fd; int iPrefixLength; //This is the length of "foo" if the filename is "foo.htm" or "foo files" //Make a copy of the filename; This copy will get munged by ConvertToConnectedItemName(). lstrcpy(szFileName, pfd->cFileName); // Convert the given file/foder name into the connected item's name with wild card characters. if (!(iPrefixLength = ConvertToConnectedItemName(szFileName, ARRAYSIZE(szFileName), ISDIRFINDDATA(*pfd)))) return 0; //No connections exist for the given folder/file. // Now szFileName has the name of connected element with wildcard character. // If the given element is a directory, we want to look for connected FILES only and // if the given element is a file, we want to look for connected FOLDERS only. dwFileOrFolder = ISDIRFINDDATA(*pfd) ? DTF_FILES_ONLY : DTF_FOLDERS_ONLY; // Form the file/folder name with the complete path! lstrcpy(szFullPath, pszPath); PathAppend(szFullPath, szFileName); // The file-element has some "connected" items. DebugMsg(TF_DEBUGCOPY, TEXT("DTAllocConnectedItemNodes Looking for %s"), szFullPath); return(DTPathToDTNode(pdth, pcs, szFullPath, fRecurse, dwFileOrFolder, ppdtnConnectedItems, &fd, NULL, NULL, TRUE, iPrefixLength)); } void DTInitProgressPoints(PDIRTREEHEADER pdth, COPY_STATE *pcs) { pdth->iFilePoints = 1; pdth->iFolderPoints = 1; switch (pcs->lpfo->wFunc) { case FO_RENAME: case FO_DELETE: pdth->iSizePoints = 0; break; case FO_COPY: pdth->iSizePoints = 1; break; case FO_MOVE: if (PathIsSameRoot(pcs->lpfo->pFrom, pcs->lpfo->pTo)) { pdth->iSizePoints = 0; } else { // if it's across volumes, these points increase // because we need to nuke the source as well as // create the target... // whereas we don't need to nuke the "size" of the source pdth->iFilePoints = 2; pdth->iFolderPoints = 2; pdth->iSizePoints = 1; } break; } } UINT DTBuild(COPY_STATE* pcs) { PDIRTREEHEADER pdth = &pcs->dth; WIN32_FIND_DATA fd; TCHAR szPath[MAX_PATH]; PDIRTREENODE *ppdtn; PDIRTREENODE *ppdtnConnectedItems; int iError = 0; pcs->dth.pFrom = (LPTSTR)pcs->lpfo->pFrom; pcs->dth.pTo = (LPTSTR)pcs->lpfo->pTo; // A tree of original items will be built under ppdtn. ppdtn = &pdth->pdtn; // A tree of items "connected" to the orginal items will be built under ppdtnConnectedItems. ppdtnConnectedItems = &pdth->pdtnConnectedItems; DTInitProgressPoints(pdth, pcs); while (!FOQueryAbort(pcs) && *pdth->pFrom) { BOOL fRecurse = TRUE; switch (pcs->lpfo->wFunc) { case FO_MOVE: // The move operation doesn't need to recurse if we are moving from and to the same // volume. In this case we know that we don't need to display any warnings for // things like LFN to 8.3 filename conversion or stream loss. Instead, we can do // the operation with one single win32 file operation that just does a rename. // NTRAID89119-2000/02/25-toddb // This is only true if we don't cross a mount point! If we cross // a mount point then we might have to warn about these things. if ((pcs->fFlags & FOF_NORECURSION) || PathIsSameRoot(pdth->pFrom, pdth->pTo)) { fRecurse = FALSE; } break; case FO_COPY: // For a copy we always recurse unless we're told not to. if (pcs->fFlags & FOF_NORECURSION) { fRecurse = FALSE; } break; case FO_RENAME: // for a rename we never recurse fRecurse = FALSE; break; case FO_DELETE: // for a delete we don't need to recurse IF the recycle bin will be able to handle // the given item. If the recycle bin handles the delete then we can undo from // the recycle bin if we need to. if ((pcs->fFlags & FOF_ALLOWUNDO) && BBWillRecycle(pdth->pFrom, NULL)) { fRecurse = FALSE; } break; } lstrcpy(szPath, pdth->pFrom); DebugMsg(TF_DEBUGCOPY, TEXT("DTBuild: %s"), szPath); // If the file is on removable media, we need to check for media in the drive. // Prompt the user to insert the media if it's missing. if (!DTDiskCheck(pdth, pcs, szPath)) { iError = ERROR_CANCELLED; break; } iError = DTPathToDTNode(pdth, pcs, szPath, fRecurse, ((PathIsWild(pdth->pFrom) && (pcs->lpfo->fFlags & FOF_FILESONLY)) ? DTF_FILES_ONLY : DTF_FILES_AND_FOLDERS), ppdtn,&fd, NULL, ppdtnConnectedItems, FALSE, 0); DebugMsg(TF_DEBUGCOPY, TEXT("DTBuild: returned %d"), iError); // FEATURE: If an error occured we should allow the user to skip the file that caused the error. That way // if one of the source files doesn't exists the rest will still get copied. Do this only in the multi- // source case, blah blah blah. This helps in the case where one of the source files cannot be moved or // copied (usually due to Access Denied, could be insuffecent permissions or file is in use, etc). if (iError) break; if (!(*ppdtn) && PathIsWild(pdth->pFrom)) { // no files are associated with this path... this // can happen when we have wildcards... // alloc a dummy node *ppdtn = DTAllocNode(pdth, NULL, NULL, NULL, FALSE); if (*ppdtn) { (*ppdtn)->fDummy = TRUE; } } if (*ppdtn) { // mark this as the start of a root spec... this is // necessary in case we have several wild specs (*ppdtn)->fNewRoot = TRUE; } if (*ppdtnConnectedItems) { // Mark this as the start of a root spec. (*ppdtnConnectedItems)->fNewRoot = TRUE; // For connected items, we need to remember the path. (*ppdtnConnectedItems)->ConnectedInfo.pFromConnected = pdth->pFrom; (*ppdtnConnectedItems)->ConnectedInfo.pToConnected = pdth->pTo; } while (*ppdtn) { ppdtn = &(*ppdtn)->pdtnNext; } while (*ppdtnConnectedItems) { ppdtnConnectedItems = &(*ppdtnConnectedItems)->pdtnNext; } pdth->pFrom += lstrlen(pdth->pFrom) + 1; if (pcs->lpfo->wFunc != FO_DELETE && (pcs->lpfo->fFlags & FOF_MULTIDESTFILES)) { pdth->pTo += lstrlen(pdth->pTo) + 1; } } //Attach the "ConnectedElements" Tree to the end of the source element tree. *ppdtn = pcs->dth.pdtnConnectedItems; pcs->dth.pFrom = (LPTSTR)pcs->lpfo->pFrom; pcs->dth.pTo = (LPTSTR)pcs->lpfo->pTo; pcs->fDTBuilt = TRUE; // set up the initial time information pcs->dwPreviousTime = GetTickCount(); pcs->dwPointsPerSec = 0; pcs->iLastProgressPoints = 0; return iError; } #define DTNIsRootNode(pdtn) ((pdtn)->pdtnParent == NULL) #define DTNIsDirectory(pdtn) (pdtn->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) // This macro determines if the given node is an "Origin" of a connection. i.e. Does this node // point to a connected element that needs to be moved/copied etc., along with it? // For example, if "foo.htm" is moved, "foo files" is also moved. // Here, "foo.htm" is the "Connect origin" (fConnectedElement = FALSE; pdtnConnected is valid) // and "foo files" is the "connected element". (fConnectedElement = TRUE;) #define DTNIsConnectOrigin(pdtn) ((!pdtn->fConnectedElement) && (pdtn->pdtnConnected != NULL)) #define DTNIsConnected(pdtn) (pdtn && (pdtn->fConnectedElement)) // UINT DTEnumChildren(PDIRTREEHEADER pdth, COPY_STATE *pcs, BOOL fRecurse, DWORD dwFileOrFolder) { int iError = 0; if (pdth->pdtnCurrent->pdtnChild == DTN_DELAYED) { WIN32_FIND_DATA fd; // fill in all the children and update the stats in pdth if (PathAppend(pdth->szSrcPath, c_szStarDotStar)) { iError = DTPathToDTNode(pdth, pcs, pdth->szSrcPath, fRecurse, dwFileOrFolder, &pdth->pdtnCurrent->pdtnChild, &fd, pdth->pdtnCurrent, NULL, pdth->pdtnCurrent->fConnectedElement, 0); } else { iError = OPER_ERROR | DE_INVALIDFILES; } // If we get "File Not Found" Error now and if it is a connected item, then this item // must have already been moved/renamed/deleted etc., So, this is not really an error. // All this means is that this connected item was also explicitly selected and hence appeared // as or "Origin" item earlier in the list and it had already been operated upon. // So, reset the error here. // (Example: If end-user selects "foo.htm" AND "foo files" folder and moves them, then we // will get a file-not-found error when we attempt to move the connected items. To avoid // this error dialog, we reset the error here.) if (DTNIsConnected(pdth->pdtnCurrent) && (iError == (OPER_ERROR | ERROR_FILE_NOT_FOUND))) iError = 0; } return iError; } // // DTNGetConfirmationResult: // When a file("foo.htm") is moved/copied, we may put up a confirmation dialog in case // of a conflict and the end-user might have responded saying "Yes", "no" etc., When the // corresponding connected element ("foo files") is also moved/copied etc., we should NOT put up // a confirmation dialog again. We must simply store the answer to the original confirmation and // use it later. // This function retries the result of the original confirmation from the top-level connected // element. int DTNGetConfirmationResult(PDIRTREENODE pdtn) { //Confirmation results are saved only for Connected items; Not for Connection Origins. if (!pdtn || !DTNIsConnected(pdtn)) return 0; //Confirmation results are stored only at the top-level node. So, go there. while (pdtn->pdtnParent) pdtn = pdtn->pdtnParent; return(pdtn->ConnectedInfo.dwConfirmation); } void DTGetWin32FindData(PDIRTREENODE pdtn, WIN32_FIND_DATA* pfd) { // only the stuff we care about lstrcpy(pfd->cAlternateFileName, pdtn->szShortName); lstrcpy(pfd->cFileName, pdtn->szName); pfd->dwFileAttributes = pdtn->dwFileAttributes; pfd->ftCreationTime = pdtn->ftCreationTime; pfd->ftLastWriteTime = pdtn->ftLastWriteTime; pfd->nFileSizeLow = pdtn->nFileSizeLow; pfd->nFileSizeHigh = pdtn->nFileSizeHigh; } void DTSetFileCopyProgress(PDIRTREEHEADER pdth, LARGE_INTEGER liRead) { LARGE_INTEGER liDelta; liDelta.QuadPart = (liRead.QuadPart - pdth->pdtnCurrent->liFileSizeCopied.QuadPart); DebugMsg(TF_DEBUGCOPY, TEXT("DTSetFileCopyProgress %d %d %d"), liDelta.LowPart, liRead.LowPart, pdth->dtDone.liSize.QuadPart); pdth->pdtnCurrent->liFileSizeCopied.QuadPart += liDelta.QuadPart; pdth->dtDone.liSize.QuadPart += liDelta.QuadPart; DebugMsg(TF_DEBUGCOPY, TEXT("DTSetFileCopyProgress %d %d"), liDelta.LowPart, pdth->dtDone.liSize.LowPart); pdth->dtDone.fChanged = TRUE; } void DTFreeNode(PDIRTREEHEADER pdth, PDIRTREENODE pdtn) { if (pdth) { ASSERT(pdtn->pdtnChild == NULL || pdtn->pdtnChild == DTN_DELAYED); // we're done with this node.. update the header totals if (DTNIsDirectory(pdtn)) { pdth->dtDone.dwFolders++; } else { LARGE_INTEGER li; li.LowPart = pdtn->nFileSizeLow; li.HighPart = pdtn->nFileSizeHigh; pdth->dtDone.dwFiles++; pdth->dtDone.liSize.QuadPart += (li.QuadPart - pdtn->liFileSizeCopied.QuadPart); } pdth->dtDone.fChanged = TRUE; // repoint parent pointer if (!pdtn->pdtnParent) { // no parent... must be a root type thing ASSERT(pdth->pdtn == pdtn); pdth->pdtn = pdtn->pdtnNext; } else { ASSERT(pdtn->pdtnParent->pdtnChild == pdtn); if (pdtn->pdtnParent->pdtnChild == pdtn) { // if my parent was pointing to me, point him to my sib pdtn->pdtnParent->pdtnChild = pdtn->pdtnNext; } } } LocalFree(pdtn); } // this frees all children of (but NOT including) the current node. // it doesn' free the current node because it's assumed that // DTGoToNextNode will be called right afterwards, and that will // free the current node void DTFreeChildrenNodes(PDIRTREEHEADER pdth, PDIRTREENODE pdtn) { PDIRTREENODE pdtnChild = pdtn->pdtnChild; while (pdtnChild && pdtnChild != DTN_DELAYED) { PDIRTREENODE pdtnNext = pdtnChild->pdtnNext; // recurse and free these children if (DTNIsDirectory(pdtnChild)) { DTFreeChildrenNodes(pdth, pdtnChild); } DTFreeNode(pdth, pdtnChild); pdtnChild = pdtnNext; } pdtn->pdtnChild = NULL; } void DTForceEnumChildren(PDIRTREEHEADER pdth) { if (!pdth->pdtnCurrent->pdtnChild) pdth->pdtnCurrent->pdtnChild = DTN_DELAYED; } void DTAbortCurrentNode(PDIRTREEHEADER pdth) { DTFreeChildrenNodes((pdth), (pdth)->pdtnCurrent); if (pdth->oper == OPER_ENTERDIR) pdth->oper = OPER_LEAVEDIR; } void DTCleanup(PDIRTREEHEADER pdth) { PDIRTREENODE pdtn; while (pdth->pdtnCurrent && pdth->pdtnCurrent->pdtnParent) { // in case we bailed deep in a tree pdth->pdtnCurrent = pdth->pdtnCurrent->pdtnParent; } while (pdth->pdtnCurrent) { pdtn = pdth->pdtnCurrent; pdth->pdtnCurrent = pdtn->pdtnNext; DTFreeChildrenNodes(NULL, pdtn); DTFreeNode(NULL, pdtn); } } BOOL DTInitializePaths(PDIRTREEHEADER pdth, COPY_STATE *pcs) { ASSERT(pdth->pdtnCurrent); // If we have no current node then how can we Initialize its paths? lstrcpyn(pdth->szSrcPath, pdth->pFrom, ARRAYSIZE(pdth->szSrcPath)); // For the "Origins" we need to do this only if a wild card exists. However, for connected elements, // we need to do this everytime because connected elements may not exist for every "Origins" if (PathIsWild(pdth->pFrom) || (pdth->pdtnCurrent->fNewRoot && DTNIsConnected(pdth->pdtnCurrent))) { PathRemoveFileSpec(pdth->szSrcPath); if (!PathAppend(pdth->szSrcPath, pdth->pdtnCurrent->szName)) return FALSE; } if (!pdth->pTo) { // no dest, make it the same as the source and we're done lstrcpyn(pdth->szDestPath, pdth->szSrcPath, ARRAYSIZE(pdth->szSrcPath)); return TRUE; } if (pdth->pTo) { lstrcpyn(pdth->szDestPath, pdth->pTo, ARRAYSIZE(pdth->szSrcPath)); } if (!pdth->fMultiDest) { if (!PathAppend(pdth->szDestPath, pdth->pdtnCurrent->szName)) return FALSE; } else { //When undo of a move operation is done, fMultiDest is set. // When fMultiDest is set, we need to strip out the filename given by pTo and // append the current filename. // For RENAME operations, the source and destination names are different. This is handled // seperately below. So, we handle only other operations here where source and dest names are the same. if ((pcs->lpfo->wFunc != FO_RENAME) && pdth->pdtnCurrent->fNewRoot && DTNIsConnected(pdth->pdtnCurrent)) { PathRemoveFileSpec(pdth->szDestPath); if (!PathAppend(pdth->szDestPath, pdth->pdtnCurrent->szName)) return FALSE; } } //We will never try to rename a connected element! Make sure we don't hit this! ASSERT(!((pcs->lpfo->wFunc == FO_RENAME) && DTNIsConnected(pdth->pdtnCurrent))); return TRUE; } UINT DTValidatePathNames(PDIRTREEHEADER pdth, UINT operation, COPY_STATE * pcs) { if (pcs->lpfo->wFunc != FO_DELETE) { // Why process name mappings? Here's why. If we are asked to copy directory "c:\foo" and // file "c:\foo\file" to another directory (say "d:\") we might have a name confilct when // we copy "c:\foo" so instead we create "d:\Copy Of foo". Later, we walk to the second // dirtree node and we are asked to copy "c:\foo\file" to "d:\foo", all of which is valid. // HOWEVER, it's not what we want to do. We use _ProccessNameMappings to convert // "d:\foo\file" into "d:\Copy of foo\file". _ProcessNameMappings(pdth->szDestPath, pdth->hdsaRenamePairs); // REVIEW, do we need to do the name mapping here or just let the // VFAT do it? if vfat does it we need to rip out all of the GetNameDialog() stuff. if ((operation != OPER_LEAVEDIR) && !IsLFNDrive(pdth->szDestPath) && PathIsLFNFileSpec(PathFindFileName(pdth->szSrcPath)) && PathIsLFNFileSpec(PathFindFileName(pdth->szDestPath))) { int iRet; TCHAR szOldDest[MAX_PATH]; lstrcpyn(szOldDest, pdth->szDestPath, ARRAYSIZE(szOldDest)); iRet = GetNameDialog(pcs->hwndDlgParent, pcs, (pcs->nSourceFiles != 1) || !DTNIsRootNode(pdth->pdtnCurrent), // if we're entering a dir, multiple spec, or not at root operation, pdth->szSrcPath, pdth->szDestPath); switch (iRet) { case IDNO: case IDCANCEL: return iRet; default: AddRenamePairToHDSA(szOldDest, pdth->szDestPath, &pcs->dth.hdsaRenamePairs); break; } } if (operation == OPER_ENTERDIR) { // Make sure the new directory is not a subdir of the original... int cchFrom = lstrlen(pdth->szSrcPath); // NTRAID89511-2000/02/25-KishoreP // Shouldn't we get the short names for both these directories and compair those? // Otherwise I can copy "C:\Long Directory Name" to "C:\LongDi~1\foo" without error. if (!(pcs->fFlags & FOF_RENAMEONCOLLISION) && !StrCmpNI(pdth->szSrcPath, pdth->szDestPath, cchFrom)) { TCHAR chNext = pdth->szDestPath[cchFrom]; // Get the next char in the dest. if (!chNext) { return OPER_ERROR | DE_DESTSAMETREE; } else if (chNext == TEXT('\\')) { // The two fully qualified strings are equal up to the end // of the source directory ==> the destination is a subdir. // Must return an error. // if, stripping the last file name and the backslash give the same length, they are the // same file/folder if ((PathFindFileName(pdth->szDestPath) - pdth->szDestPath - 1) == lstrlen(pdth->szSrcPath)) { return OPER_ERROR | DE_DESTSAMETREE; } else { return OPER_ERROR | DE_DESTSUBTREE; } } } } } return 0; } // this moves to the next node (child, sib, parent) and sets up the // directory path info and oper state UINT DTGoToNextNode(PDIRTREEHEADER pdth, COPY_STATE *pcs) { UINT oper = OPER_ENTERDIR; // the default int iError; if (!pdth->pdtnCurrent) { pdth->pdtnCurrent = pdth->pdtn; if (pdth->pdtnCurrent) { if (pdth->pdtnCurrent->fDummy) { // if this is just a placeholder... go on to the next one return DTGoToNextNode(pdth, pcs); } if (!DTInitializePaths(pdth, pcs)) { return OPER_ERROR | DE_INVALIDFILES; } } else { // Our tree is completely empty. // REVIEW: What do we do here? If pdtnCurrent is still NULL then our list is completely empty. // Is that a bug or what? My hunch is that we should return an error code here, most likely // OPER_ERROR | DE_INVALIDFILES. If we do nothing here then we will fail silently. return OPER_ERROR | DE_INVALIDFILES; } } else { UINT iError; BOOL fFreeLastNode = TRUE; PDIRTREENODE pdtnLastCurrent = pdth->pdtnCurrent; TCHAR szTemp[MAX_PATH]; if (iError = DTEnumChildren(pdth, pcs, FALSE, DTF_FILES_AND_FOLDERS)) return iError; if (pdth->pdtnCurrent->pdtnChild) { fFreeLastNode = FALSE; pdth->pdtnCurrent = pdth->pdtnCurrent->pdtnChild; // if the source long name is too long, try the short name if (!PathCombine(szTemp, pdth->szSrcPath, pdth->pdtnCurrent->szName)) { if (!PathCombine(szTemp, pdth->szSrcPath, pdth->pdtnCurrent->szShortName)) { return OPER_ERROR | DE_INVALIDFILES; } } StrCpyN(pdth->szSrcPath, szTemp, ARRAYSIZE(pdth->szSrcPath)); // if the dest long name is too long, try the short name if (!PathCombine(szTemp, pdth->szDestPath, pdth->pdtnCurrent->szName)) { if (!PathCombine(szTemp, pdth->szDestPath, pdth->pdtnCurrent->szShortName)) { return OPER_ERROR | DE_INVALIDFILES; } } StrCpyN(pdth->szDestPath, szTemp, ARRAYSIZE(pdth->szDestPath)); } else if (pdth->oper == OPER_ENTERDIR) { // if the last operation was an enterdir and it has no children // (because it failed the above test // then we should do a leave dir on it now oper = OPER_LEAVEDIR; fFreeLastNode = FALSE; } else if (pdth->pdtnCurrent->pdtnNext) { pdth->pdtnCurrent = pdth->pdtnCurrent->pdtnNext; if (!pdth->pdtnCurrent->pdtnParent) { // if this was the top, we need to build the next path info // from scratch if (pdth->pdtnCurrent->fNewRoot) { if (pdth->pdtnCurrent->fConnectedElement) { // Since this is a new root in a Connected list, the pFrom and pTo are // stored in the node itself. This is needed because Connected elements may // not exist for every item in the source list and we do not want to create dummy // nodes for each one of them. So, pFrom and pTo are stored for every NewRoot of // connected elements and we use these here. pdth->pFrom = pdth->pdtnCurrent->ConnectedInfo.pFromConnected; pdth->pTo = pdth->pdtnCurrent->ConnectedInfo.pToConnected; } else { // go to the next path pair pdth->pFrom += lstrlen(pdth->pFrom) + 1; if (pdth->pTo) { if (pdth->fMultiDest) { pdth->pTo += lstrlen(pdth->pTo) + 1; } } } } if (pdth->pdtnCurrent->fDummy) { // if this is just a placeholder... go on to the next one if (fFreeLastNode) { DTFreeNode(pdth, pdtnLastCurrent); } return DTGoToNextNode(pdth, pcs); } DTInitializePaths(pdth, pcs); } else { PathRemoveFileSpec(pdth->szSrcPath); PathRemoveFileSpec(pdth->szDestPath); // if the source long name is too long, try the short name if (!PathCombine(szTemp, pdth->szSrcPath, pdth->pdtnCurrent->szName)) { if (!PathCombine(szTemp, pdth->szSrcPath, pdth->pdtnCurrent->szShortName)) { return OPER_ERROR | DE_INVALIDFILES; } } StrCpyN(pdth->szSrcPath, szTemp, ARRAYSIZE(pdth->szSrcPath)); // if the dest long name is too long, try the short name if (!PathCombine(szTemp, pdth->szDestPath, pdth->pdtnCurrent->szName)) { if (!PathCombine(szTemp, pdth->szDestPath, pdth->pdtnCurrent->szShortName)) { return OPER_ERROR | DE_INVALIDFILES; } } StrCpyN(pdth->szDestPath, szTemp, ARRAYSIZE(pdth->szDestPath)); } } else { oper = OPER_LEAVEDIR; PathRemoveFileSpec(pdth->szSrcPath); PathRemoveFileSpec(pdth->szDestPath); pdth->pdtnCurrent = pdth->pdtnCurrent->pdtnParent; } if (fFreeLastNode) { DTFreeNode(pdth, pdtnLastCurrent); } } if (!pdth->pdtnCurrent) { // no more! we're done! return 0; } DebugDumpPDTN(pdth->pdtnCurrent, TEXT("PDTNCurrent")); if (oper == OPER_ENTERDIR) { if (pcs->lpfo->wFunc == FO_RENAME || !DTNIsDirectory(pdth->pdtnCurrent)) { oper = OPER_DOFILE; } } if (DTNIsRootNode(pdth->pdtnCurrent)) { // we need to diskcheck the source and target because this might // be the first time we've seen this drive if (!DTDiskCheck(pdth, pcs, pdth->szSrcPath) || !DTDiskCheck(pdth, pcs, pdth->szDestPath)) { pcs->bAbort = TRUE; return 0; } } iError = DTValidatePathNames(pdth, oper, pcs); if (iError) { if (iError & OPER_ERROR) { //For connected nodes, ignore the error and silently abort the node! if (DTNIsConnected(pdth->pdtnCurrent)) { DTAbortCurrentNode(pdth); return DTGoToNextNode(pdth, pcs); } else return iError; } else { switch (iError) { case IDNO: DTAbortCurrentNode(pdth); pcs->lpfo->fAnyOperationsAborted = TRUE; return DTGoToNextNode(pdth, pcs); case IDCANCEL: // User cancelled the operation pcs->bAbort = TRUE; return 0; } } } pdth->oper = oper; return oper; } int CopyMoveRetry(COPY_STATE *pcs, LPCTSTR pszDest, int error, ULARGE_INTEGER* puliFileSize); void CopyError(LPCOPY_STATE, LPCTSTR, LPCTSTR, int, UINT, int); void SetProgressTime(COPY_STATE *pcs); void SetProgressText(COPY_STATE *pcs, LPCTSTR pszFrom, LPCTSTR pszTo); void FOUndo_AddInfo(UNDOATOM *lpua, LPTSTR lpszSrc, LPTSTR lpszDest, DWORD dwAttributes); void CALLBACK FOUndo_Release(UNDOATOM *lpua); void FOUndo_FileReallyDeleted(LPTSTR lpszFile); void AddRenamePairToHDSA(LPCTSTR pszOldPath, LPCTSTR pszNewPath, HDSA* phdsaRenamePairs); BOOL_PTR CALLBACK FOFProgressDlgProc(HWND hDlg, UINT wMsg, WPARAM wParam, LPARAM lParam); typedef struct { LPTSTR lpszName; DWORD dwAttributes; } FOUNDO_DELETEDFILEINFO, *LPFOUNDO_DELETEDFILEINFO; typedef struct { HDPA hdpa; HDSA hdsa; } FOUNDODATA, *LPFOUNDODATA; void ReleasePCS(COPY_STATE *pcs) { if (0 == InterlockedDecrement(&pcs->nRef)) { SimplePidlCache_Release(&pcs->spc); LocalFree(pcs); } } DWORD CALLBACK AddRefPCS(COPY_STATE *pcs) { return InterlockedIncrement(&pcs->nRef); } DWORD CALLBACK FOUIThreadProc(COPY_STATE *pcs) { DebugMsg(TF_DEBUGCOPY, TEXT("FOUIThreadProc -- Begin")); Sleep(SHOW_PROGRESS_TIMEOUT); if (!pcs->fDone) { HWND hwndParent; FOUITHREADINFO fouiti = {0}; ENTERCRITICAL; if (!pcs->fDone) { // need to check again within the critsec to make sure that pcs->lpfo is still valid fouiti.pcs = pcs; fouiti.wFunc = pcs->lpfo->wFunc; fouiti.bIsEmptyRBOp = ((pcs->lpfo->lpszProgressTitle == MAKEINTRESOURCE(IDS_BB_EMPTYINGWASTEBASKET)) || (pcs->lpfo->lpszProgressTitle == MAKEINTRESOURCE(IDS_BB_DELETINGWASTEBASKETFILES))); hwndParent = pcs->lpfo->hwnd; } LEAVECRITICAL; if (fouiti.pcs) { HWND hwnd = CreateDialogParam(HINST_THISDLL, MAKEINTRESOURCE(DLG_MOVECOPYPROGRESS), hwndParent, FOFProgressDlgProc, (LPARAM)&fouiti); if (hwnd) { MSG msg; DWORD dwShowTime; int iShowTimeLeft; // crit section to sync with main thread termination ENTERCRITICAL; if (!pcs->fDone) { pcs->hwndProgress = hwnd; } LEAVECRITICAL; dwShowTime = GetTickCount(); while (!pcs->fDone && GetMessage(&msg, NULL, 0, 0)) { if (!pcs->fDone && !IsDialogMessage(pcs->hwndProgress, &msg)) { TranslateMessage(&msg); DispatchMessage(&msg); } } // if we've put it up, we need to keep it up for at least some minimal amount of time iShowTimeLeft = MINSHOWTIME - (GetTickCount() - dwShowTime); if (iShowTimeLeft > 0) { DebugMsg(TF_DEBUGCOPY, TEXT("FOUIThreadProc -- doing an extra sleep")); Sleep(iShowTimeLeft); } // Keep us from doing this while other thread processing... ENTERCRITICAL; pcs->hwndProgress = NULL; LEAVECRITICAL; DestroyWindow(hwnd); } } else { // main thread must have finished ASSERT(pcs->fDone); } } ReleasePCS(pcs); DebugMsg(TF_DEBUGCOPY, TEXT("FOUIThreadProc -- End . Completed")); return 0; } // this queries the progress dialog for a cancel and yields. // it also will show the progress dialog if a certain amount of time has passed // // returns: // TRUE cacnel was pressed, abort the operation // FALSE continue BOOL FOQueryAbort(COPY_STATE *pcs) { if (!pcs->bAbort && pcs->hwndProgress) { if (pcs->hwndProgress != pcs->hwndDlgParent) { // do this here rather than on the FOUIThreadProc so that we don't have // synchronization problems with this thread popping up a dialog on // hwndDlgParent then the progress dialog coming up afterwards on top. pcs->hwndDlgParent = pcs->hwndProgress; ShowWindow(pcs->hwndProgress, SW_SHOW); SetForegroundWindow(pcs->hwndProgress); SetFocus(GetDlgItem(pcs->hwndProgress, IDCANCEL)); SetProgressText(pcs, pcs->dth.szSrcPath, pcs->lpfo->wFunc == FO_DELETE ? NULL : pcs->dth.szDestPath); } else { MSG msg; // win95 handled messages in here. // we need to do the same in order to flush the input queue as well as // for backwards compatability. // we need to flush the input queue now because hwndProgress is // on a different thread... which means it has attached thread inputs // inorder to unlock the attached threads, we need to remove some // sort of message until there's none left... any type of message.. while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) { if (!IsDialogMessage(pcs->hwndProgress, &msg)) { TranslateMessage(&msg); DispatchMessage(&msg); } } } if (pcs->dth.dtAll.fChanged || pcs->dth.dtDone.fChanged) { if (!pcs->dth.fChangePosted) { // set the flag first because with async threads // the progress window could handle it and clear the // bit before we set it.. then we'd lose further messages // thinking that one was still pending pcs->dth.fChangePosted = TRUE; if (!PostMessage(pcs->hwndProgress, PDM_UPDATE, 0, 0)) pcs->dth.fChangePosted = FALSE; } } } return pcs->bAbort; } typedef struct _confdlg_data { LPCTSTR pFileDest; LPCTSTR pFileSource; LPCTSTR pStreamNames; const WIN32_FIND_DATA *pfdDest; const WIN32_FIND_DATA *pfdSource; BOOL bShowCancel; // allow cancel out of this operation BOOL bShowDates; // use date/size info in message UINT uDeleteWarning; // warn that the delete's not going to the wastebasket BOOL bFireIcon; BOOL bShrinkDialog; // should we move the buttons up to the text? int nSourceFiles; // if != 1 used to build "n files" string int idText; // if != 0 use to override string in dlg template CONFIRM_FLAG fConfirm; // we will confirm things set here CONFIRM_FLAG fYesMask; // these bits are cleared in fConfirm on "yes" // Only use fYesMask for things that should be confirmed once per operation CONFIRM_FLAG fYesToAllMask; // these bits are cleared in fConfirm on "yes to all" //COPY_STATE *pcs; CONFIRM_DATA *pcd; void (*InitConfirmDlg)(HWND hDlg, struct _confdlg_data *pcd); // routine to initialize dialog BOOL bARPWarning; } CONFDLG_DATA; BOOL BuildDateLine(LPTSTR pszDateLine, const WIN32_FIND_DATA *pFind, LPCTSTR pFileName) { TCHAR szTemplate[64]; TCHAR szNum[32], szTmp[64]; WIN32_FIND_DATA fd; ULARGE_INTEGER liFileSize; if (!pFind) { HANDLE hfind = FindFirstFile(pFileName, &fd); ASSERT(hfind != INVALID_HANDLE_VALUE); FindClose(hfind); pFind = &fd; } liFileSize.LowPart = pFind->nFileSizeLow; liFileSize.HighPart = pFind->nFileSizeHigh; // There are cases where the date is 0, this is especially true when the // source is from a file contents... if (pFind->ftLastWriteTime.dwLowDateTime || pFind->ftLastWriteTime.dwHighDateTime) { DWORD dwFlags = FDTF_LONGDATE | FDTF_RELATIVE | FDTF_LONGTIME; SHFormatDateTime(&pFind->ftLastWriteTime, &dwFlags, szTmp, SIZECHARS(szTmp)); LoadString(HINST_THISDLL, IDS_DATESIZELINE, szTemplate, ARRAYSIZE(szTemplate)); wsprintf(pszDateLine, szTemplate, StrFormatByteSize64(liFileSize.QuadPart, szNum, ARRAYSIZE(szNum)), szTmp); } else { // Simpy output the number to the string StrFormatByteSize64(liFileSize.QuadPart, pszDateLine, 64); if (liFileSize.QuadPart == 0) return FALSE; } return TRUE; // valid data in the strings } // hide the cancel button and move "Yes" and "No" over to the right positions. // // "Yes" is IDYES // "No" is IDNO // #define HideYesToAllAndCancel(hdlg) HideConfirmButtons(hdlg, IDCANCEL) #define HideYesToAllAndNo(hdlg) HideConfirmButtons(hdlg, IDNO) void HideConfirmButtons(HWND hdlg, int idHide) { HWND hwndCancel = GetDlgItem(hdlg, IDCANCEL); HWND hwndYesToAll = GetDlgItem(hdlg, IDD_YESTOALL); if (hwndCancel) { RECT rcCancel; HWND hwndNo; GetWindowRect(hwndCancel, &rcCancel); hwndNo = GetDlgItem(hdlg, IDNO); if (hwndNo) { RECT rcNo; HWND hwndYes; GetWindowRect(hwndNo, &rcNo); MapWindowRect(NULL, hdlg, &rcCancel); SetWindowPos(hwndNo, NULL, rcCancel.left, rcCancel.top, 0, 0, SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOSIZE); hwndYes = GetDlgItem(hdlg, IDYES); if (hwndYes) { MapWindowRect(NULL, hdlg, &rcNo); SetWindowPos(hwndYes, NULL, rcNo.left, rcNo.top, 0, 0, SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOSIZE); } } // Although the function is called "Hide", we actually destroy // the windows, because keyboard accelerators for hidden windows // are still active! if (hwndYesToAll) DestroyWindow(hwndYesToAll); DestroyWindow(GetDlgItem(hdlg, idHide)); } } int MoveDlgItem(HWND hDlg, UINT id, int y) { RECT rc; HWND hwnd = GetDlgItem(hDlg, id); if (hwnd) { GetWindowRect(hwnd, &rc); MapWindowRect(NULL, hDlg, &rc); SetWindowPos(hwnd, NULL, rc.left, y, 0,0, SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE); return rc.top - y; // return how much it moved } return 0; } void ShrinkDialog(HWND hDlg, UINT idText) { RECT rc; int y; HWND hwnd; hwnd = GetDlgItem(hDlg, idText); ASSERT(hwnd); GetWindowRect(hwnd, &rc); MapWindowRect(NULL, hDlg, &rc); y = rc.bottom + 12; // move all the buttons MoveDlgItem(hDlg, IDNO, y); MoveDlgItem(hDlg, IDCANCEL, y); MoveDlgItem(hDlg, IDD_YESTOALL, y); y = MoveDlgItem(hDlg, IDYES, y); // now resize the entire dialog GetWindowRect(hDlg, &rc); SetWindowPos(hDlg, NULL, 0, 0, rc.right - rc.left, rc.bottom - y - rc.top, SWP_NOMOVE | SWP_NOZORDER |SWP_NOACTIVATE); } void InitConfirmDlg(HWND hDlg, CONFDLG_DATA *pcd) { TCHAR szMessage[255]; TCHAR szDeleteWarning[80]; TCHAR szSrc[32]; TCHAR szFriendlyName[MAX_PATH]; SHFILEINFO sfi; SHFILEINFO sfiDest; LPTSTR pszFileDest = NULL; LPTSTR pszMsg, pszSource; int i; int cxWidth; RECT rc; HDC hdc; HFONT hfont; HFONT hfontSave; SIZE size; BOOL bIsARPWarning = pcd->bARPWarning; ASSERT((bIsARPWarning && (pcd->nSourceFiles == 1)) || (!bIsARPWarning)); hdc = GetDC(hDlg); hfont = (HFONT)SendMessage(hDlg, WM_GETFONT, 0, 0); hfontSave = (HFONT)SelectObject(hdc, hfont); // get the size of the text boxes GetWindowRect(GetDlgItem(hDlg, pcd->idText), &rc); cxWidth = rc.right - rc.left; // // There are cases where, if the filename has no spaces, the static text // control will put the entire file name with our quote character down // on the 2nd line. To account for this, we subtract off the width of a // the quote character. Since the quote character comes from the resource // string, it could really be just about an character, with just about // any width. So we assume its about the width of the letter 0, which // should be more than wide enough. size.cx = 0; GetTextExtentPoint(hdc, TEXT("0"), 1, &size); cxWidth -= size.cx * 2; if (!bIsARPWarning && !pcd->bShowCancel) HideYesToAllAndCancel(hDlg); switch (pcd->nSourceFiles) { case -1: LoadString(HINST_THISDLL, IDS_SELECTEDFILES, szSrc, ARRAYSIZE(szSrc)); pszSource = szSrc; break; case 1: if (bIsARPWarning) { TCHAR szTarget[MAX_PATH]; DWORD cchFriendlyName = ARRAYSIZE(szFriendlyName); HRESULT hres = GetPathFromLinkFile(pcd->pFileSource, szTarget, ARRAYSIZE(szTarget)); if (S_OK == hres) { if (SUCCEEDED(AssocQueryString(ASSOCF_VERIFY | ASSOCF_OPEN_BYEXENAME, ASSOCSTR_FRIENDLYAPPNAME, szTarget, NULL, szFriendlyName, &cchFriendlyName))) { pszSource = szFriendlyName; } else { pszSource = PathFindFileName(szTarget); } } else if (S_FALSE == hres) { TCHAR szProductCode[MAX_PATH]; szProductCode[0] = 0; if ((ERROR_SUCCESS == MsiDecomposeDescriptor(szTarget, szProductCode, NULL, NULL, NULL)) && (ERROR_SUCCESS == MsiGetProductInfo(szProductCode, INSTALLPROPERTY_PRODUCTNAME, szFriendlyName, &cchFriendlyName))) { pszSource = szFriendlyName; } else goto UNKNOWNAPP; } else { UNKNOWNAPP: LoadString(HINST_THISDLL, IDS_UNKNOWNAPPLICATION, szSrc, ARRAYSIZE(szSrc)); pszSource = szSrc; } } else { SHGetFileInfo(pcd->pFileSource, (pcd->fConfirm==CONFIRM_DELETE_FOLDER || pcd->fConfirm==CONFIRM_WONT_RECYCLE_FOLDER)? FILE_ATTRIBUTE_DIRECTORY : 0, &sfi, sizeof(sfi), SHGFI_DISPLAYNAME | SHGFI_USEFILEATTRIBUTES); pszSource = sfi.szDisplayName; PathCompactPath(hdc, pszSource, cxWidth); } break; default: pszSource = AddCommas(pcd->nSourceFiles, szSrc, ARRAYSIZE(szSrc)); break; } // if we're supposed to show the date info, grab the icons and format the date string if (pcd->bShowDates) { SHFILEINFO sfi2; TCHAR szDateSrc[64], szDateDest[64]; BuildDateLine(szDateSrc, pcd->pfdSource, pcd->pFileSource); SetDlgItemText(hDlg, IDD_FILEINFO_NEW, szDateSrc); BuildDateLine(szDateDest, pcd->pfdDest, pcd->pFileDest); SetDlgItemText(hDlg, IDD_FILEINFO_OLD, szDateDest); SHGetFileInfo(pcd->pFileDest, pcd->pfdDest ? pcd->pfdDest->dwFileAttributes : 0, &sfi2, sizeof(sfi2), pcd->pfdDest ? (SHGFI_USEFILEATTRIBUTES|SHGFI_ICON|SHGFI_LARGEICON) : (SHGFI_ICON|SHGFI_LARGEICON)); ReplaceDlgIcon(hDlg, IDD_ICON_OLD, sfi2.hIcon); SHGetFileInfo(pcd->pFileSource, pcd->pfdSource ? pcd->pfdSource->dwFileAttributes : 0, &sfi2, sizeof(sfi2), pcd->pfdSource ? (SHGFI_USEFILEATTRIBUTES|SHGFI_ICON|SHGFI_LARGEICON) : (SHGFI_ICON|SHGFI_LARGEICON)); ReplaceDlgIcon(hDlg, IDD_ICON_NEW, sfi2.hIcon); } if (!bIsARPWarning) { // there are multiple controls: // IDD_TEXT contains regular text (normal file/folder) // IDD_TEXT1 - IDD_TEXT4 contain optional secondary text for (i = IDD_TEXT; i <= IDD_TEXT4; i++) { if (i == pcd->idText) { szMessage[0] = 0; GetDlgItemText(hDlg, i, szMessage, ARRAYSIZE(szMessage)); } else { HWND hwndCtl = GetDlgItem(hDlg, i); if (hwndCtl) ShowWindow(hwndCtl, SW_HIDE); } } } else { GetDlgItemText(hDlg, IDD_ARPWARNINGTEXT, szMessage, ARRAYSIZE(szMessage)); } // REVIEW Is there some better way? The code above always hides // this control, and I don't see a way around this if (pcd->pStreamNames) { SetDlgItemText(hDlg, IDD_TEXT1, pcd->pStreamNames); ShowWindow(GetDlgItem(hDlg, IDD_TEXT1), SW_SHOW); } if (pcd->bShrinkDialog) ShrinkDialog(hDlg, pcd->idText); if (pcd->pFileDest) { SHGetFileInfo(pcd->pFileDest, 0, &sfiDest, sizeof(sfiDest), SHGFI_DISPLAYNAME | SHGFI_USEFILEATTRIBUTES); pszFileDest = sfiDest.szDisplayName; PathCompactPath(hdc, pszFileDest, cxWidth); } if (pcd->uDeleteWarning) { LPITEMIDLIST pidl; if (SUCCEEDED(SHGetSpecialFolderLocation(NULL, CSIDL_BITBUCKET, &pidl))) { SHFILEINFO fi; if (SHGetFileInfo((LPCTSTR)pidl, 0, &fi, sizeof(fi), SHGFI_PIDL | SHGFI_ICON |SHGFI_LARGEICON)) { ReplaceDlgIcon(hDlg, IDD_ICON_WASTEBASKET, fi.hIcon); } ILFree(pidl); } LoadString(HINST_THISDLL, pcd->uDeleteWarning, szDeleteWarning, ARRAYSIZE(szDeleteWarning)); } else szDeleteWarning[0] = 0; if (pcd->bFireIcon) { ReplaceDlgIcon(hDlg, IDD_ICON_WASTEBASKET, LoadImage(HINST_THISDLL, MAKEINTRESOURCE(IDI_NUKEFILE), IMAGE_ICON, 0, 0, LR_LOADMAP3DCOLORS)); } pszMsg = ShellConstructMessageString(HINST_THISDLL, szMessage, pszSource, pszFileDest, szDeleteWarning); if (pszMsg) { SetDlgItemText(hDlg, pcd->idText, pszMsg); LocalFree(pszMsg); } SelectObject(hdc, hfontSave); ReleaseDC(hDlg, hdc); } BOOL_PTR CALLBACK ConfirmDlgProc(HWND hDlg, UINT wMsg, WPARAM wParam, LPARAM lParam) { CONFDLG_DATA *pcd = (CONFDLG_DATA *)GetWindowLongPtr(hDlg, DWLP_USER); switch (wMsg) { case WM_INITDIALOG: SetWindowLongPtr(hDlg, DWLP_USER, lParam); pcd = (CONFDLG_DATA *)lParam; pcd->InitConfirmDlg(hDlg, pcd); break; case WM_DESTROY: // Handle case where the allocation of the PCD failed. if (!pcd) break; if (pcd->bShowDates) { ReplaceDlgIcon(hDlg, IDD_ICON_NEW, NULL); ReplaceDlgIcon(hDlg, IDD_ICON_OLD, NULL); } ReplaceDlgIcon(hDlg, IDD_ICON_WASTEBASKET, NULL); break; case WM_COMMAND: if (!pcd) break; switch (GET_WM_COMMAND_ID(wParam, lParam)) { case IDNO: if (GetKeyState(VK_SHIFT) < 0) // force NOTOALL { // I use the fYesToAllMask here. There used to be a fNoToAllMask but I // removed it. When you select "No To All" what you are saying is that // anything I would be saying yes to all for I am actually saying "no to // all" for. I feel that it is confusing and unnecessary to have both. pcd->pcd->fNoToAll |= pcd->fYesToAllMask; } EndDialog(hDlg, IDNO); break; case IDD_YESTOALL: // pcd is the confirmation data for just this file/folder. pcd->pcd is the // confirm data for the entire copy operation. When we get a Yes To All we // remove the coresponding bits from the entire operation. pcd->pcd->fConfirm &= ~pcd->fYesToAllMask; EndDialog(hDlg, IDYES); break; case IDYES: // There are some messages that we only want to tell the use once even if they // select Yes instead of Yes To All. As such we sometimes remove bits from the // global confirm state even on a simple Yes. This mask is usually zero. pcd->pcd->fConfirm &= ~pcd->fYesMask; EndDialog(hDlg, IDYES); break; case IDCANCEL: EndDialog(hDlg, IDCANCEL); break; } break; case WM_NOTIFY: switch (((LPNMHDR)lParam)->code) { case NM_RETURN: case NM_CLICK: { TCHAR szModule[MAX_PATH]; if (GetSystemDirectory(szModule, ARRAYSIZE(szModule))) { if (PathAppend(szModule, TEXT("appwiz.cpl"))) { TCHAR szParam[1 + MAX_PATH + 2 + MAX_CCH_CPLNAME]; // See MakeCPLCommandLine function TCHAR szAppwiz[64]; LoadString(g_hinst, IDS_APPWIZCPL, szAppwiz, SIZECHARS(szAppwiz)); MakeCPLCommandLine(szModule, szAppwiz, szParam, ARRAYSIZE(szParam)); SHRunControlPanelEx(szParam, NULL, FALSE); } } EndDialog(hDlg, IDNO); } break; } break; default: return FALSE; } return TRUE; } void SetConfirmMaskAndText(CONFDLG_DATA *pcd, DWORD dwFileAttributes, LPCTSTR pszFile) { if (IS_SYSTEM_HIDDEN(dwFileAttributes) && !ShowSuperHidden()) { dwFileAttributes &= ~FILE_ATTRIBUTE_SUPERHIDDEN; } // we used to have a desktop.ini "ConfirmFileOp" flag that was set // to avoid this case, but there are no folders that are marked READONLY // or SYSTEM for a reason other than the shell, so don't consider any as such if ((dwFileAttributes & (FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_READONLY)) && (dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) { dwFileAttributes &= ~(FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_READONLY); } if (dwFileAttributes & FILE_ATTRIBUTE_SYSTEM) { pcd->fConfirm = CONFIRM_SYSTEM_FILE; pcd->fYesToAllMask |= CONFIRM_SYSTEM_FILE; pcd->idText = IDD_TEXT2; } else if (dwFileAttributes & FILE_ATTRIBUTE_READONLY) { pcd->fConfirm = CONFIRM_READONLY_FILE; pcd->fYesToAllMask |= CONFIRM_READONLY_FILE; pcd->idText = IDD_TEXT1; } else if (pszFile && ((dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0) && PathIsRegisteredProgram(pszFile)) { pcd->fConfirm = CONFIRM_PROGRAM_FILE; pcd->fYesToAllMask |= CONFIRM_PROGRAM_FILE; pcd->idText = IDD_TEXT3; } } void PauseAnimation(COPY_STATE *pcs, BOOL bStop) { // only called from within the hwndProgress wndproc so assum it's there if (bStop) Animate_Stop(GetDlgItem(pcs->hwndProgress, IDD_ANIMATE)); else Animate_Play(GetDlgItem(pcs->hwndProgress, IDD_ANIMATE), -1, -1, -1); } // confirm a file operation UI. // // this routine uses the CONFIRM_DATA in the copy state structure to // decide if it needs to put up a dailog to confirm the given file operation. // // in: // pcs current copy state (confirm flags, hwnd) // fConfirm only one bit may be set! (operation to confirm) // pFileSource source file // pFileDest optional destination file // pfdSource // pfdDest find data describing the destination // // returns: // IDYES // IDNO // IDCANCEL // ERROR_ (DE_) error codes (DE_MEMORY) // int ConfirmFileOp(HWND hwnd, COPY_STATE *pcs, CONFIRM_DATA *pcd, int nSourceFiles, int cDepth, CONFIRM_FLAG fConfirm, LPCTSTR pFileSource, const WIN32_FIND_DATA *pfdSource, LPCTSTR pFileDest, const WIN32_FIND_DATA *pfdDest, LPCTSTR pStreamNames) { int dlg; int ret; CONFDLG_DATA cdd; CONFIRM_FLAG fConfirmType; if (pcs) nSourceFiles = pcs->nSourceFiles; cdd.pfdSource = pfdSource; cdd.pfdDest = NULL; // pfdDest is only partially filed in cdd.pFileSource = pFileSource; cdd.pFileDest = pFileDest; cdd.pcd = pcd; cdd.fConfirm = fConfirm; // default, changed below cdd.fYesMask = 0; cdd.fYesToAllMask = 0; cdd.nSourceFiles = 1; // default to individual file names in message cdd.idText = IDD_TEXT; // default string from the dlg template cdd.bShowCancel = ((nSourceFiles != 1) || cDepth); cdd.uDeleteWarning = 0; cdd.bFireIcon = FALSE; cdd.bShowDates = FALSE; cdd.bShrinkDialog = FALSE; cdd.InitConfirmDlg = InitConfirmDlg; cdd.pStreamNames = NULL; cdd.bARPWarning = FALSE; fConfirmType = fConfirm & CONFIRM_FLAG_TYPE_MASK; switch (fConfirmType) { case CONFIRM_DELETE_FILE: case CONFIRM_DELETE_FOLDER: { BOOL bIsFolderShortcut = FALSE; cdd.bShrinkDialog = TRUE; // find data for source is in pdfDest if ((nSourceFiles != 1) && (pcd->fConfirm & CONFIRM_MULTIPLE)) { // this is the special CONFIRM_MULTIPLE case (usuall SHIFT+DELETE, or // SHIFT+DRAG to Recycle Bin). if the user says yes to this, they // basically get no more warnings. cdd.nSourceFiles = nSourceFiles; if ((fConfirm & CONFIRM_WASTEBASKET_PURGE) || (!pcs || !(pcs->fFlags & FOF_ALLOWUNDO)) || !BBWillRecycle(cdd.pFileSource, NULL)) { // have the fire icon and the REALLY delete warning cdd.uDeleteWarning = IDS_FOLDERDELETEWARNING; cdd.bFireIcon = TRUE; if (pcs) pcs->fFlags &= ~FOF_ALLOWUNDO; if (nSourceFiles == -1) { // -1 indicates that there were >= MAX_EMPTY_FILES files, so we stoped counting // them all up for perf. We use the more generic message in this case. cdd.idText = IDD_TEXT3; } else { // use the "are you sure you want to nuke XX files?" message cdd.idText = IDD_TEXT4; } } else { // uDeleteWarning must be set for the proper recycle icon to be loaded. cdd.uDeleteWarning = IDS_FOLDERDELETEWARNING; } if (!pcs || !pcs->fNoConfirmRecycle) { POINT ptInvoke; HWND hwndPos = NULL; if ((GetNumberOfMonitors() > 1) && GetCursorPos(&ptInvoke)) { HMONITOR hMon = MonitorFromPoint(ptInvoke, MONITOR_DEFAULTTONULL); if (hMon) { hwndPos = _CreateStubWindow(&ptInvoke, hwnd); } } ret = (int)DialogBoxParam(HINST_THISDLL, MAKEINTRESOURCE(DLG_DELETE_MULTIPLE), hwndPos ? hwndPos : hwnd, ConfirmDlgProc, (LPARAM)&cdd); if (hwndPos) { DestroyWindow(hwndPos); } if (ret != IDYES) { return IDCANCEL; } } // clear all other possible warnings pcd->fConfirm &= ~(CONFIRM_MULTIPLE | CONFIRM_DELETE_FILE | CONFIRM_DELETE_FOLDER); cdd.fConfirm &= ~(CONFIRM_DELETE_FILE | CONFIRM_DELETE_FOLDER); cdd.nSourceFiles = 1; // use individual file name } SetConfirmMaskAndText(&cdd, pfdDest->dwFileAttributes, cdd.pFileSource); if ((pfdDest->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) && PathIsShortcut(cdd.pFileSource, pfdDest->dwFileAttributes)) { // Its a folder and its a shortcut... must be a FolderShortcut! bIsFolderShortcut = TRUE; // since its a folder, we need to clear out all of these warnings cdd.fYesMask |= CONFIRM_DELETE_FILE | CONFIRM_DELETE_FOLDER | CONFIRM_MULTIPLE; cdd.fYesToAllMask |= CONFIRM_DELETE_FILE | CONFIRM_DELETE_FOLDER | CONFIRM_MULTIPLE; } // we want to treat FolderShortcuts as "files" instead of folders. We do this so we don't display dialogs // that say stuff like "do you want to delete this and all of its contents" when to the user, this looks like // an item instead of a folder (eg nethood shortcut). if ((fConfirmType == CONFIRM_DELETE_FILE) || bIsFolderShortcut) { dlg = DLG_DELETE_FILE; if ((nSourceFiles == 1) && PathIsShortcutToProgram(cdd.pFileSource)) { dlg = DLG_DELETE_FILE_ARP; cdd.idText = IDD_ARPWARNINGTEXT; cdd.bShrinkDialog = FALSE; cdd.bARPWarning = TRUE; } if ((fConfirm & CONFIRM_WASTEBASKET_PURGE) || (!pcs || !(pcs->fFlags & FOF_ALLOWUNDO)) || !BBWillRecycle(cdd.pFileSource, NULL)) { // we are really nuking it, so show the appropriate icon/dialog cdd.bFireIcon = TRUE; if (pcs) { pcs->fFlags &= ~FOF_ALLOWUNDO; } cdd.uDeleteWarning = IDS_FILEDELETEWARNING; if (cdd.idText == IDD_TEXT) { cdd.idText = IDD_TEXT4; } } else { // we are recycling it cdd.uDeleteWarning = IDS_FILERECYCLEWARNING; } } else { // fConfirmType == CONFIRM_DELETE_FOLDER if (pcs) { // show cancel on NEXT confirm dialog pcs->nSourceFiles = -1; } cdd.fYesMask |= CONFIRM_DELETE_FILE | CONFIRM_DELETE_FOLDER | CONFIRM_MULTIPLE; cdd.fYesToAllMask |= CONFIRM_DELETE_FILE | CONFIRM_DELETE_FOLDER | CONFIRM_MULTIPLE; dlg = DLG_DELETE_FOLDER; if ((fConfirm & CONFIRM_WASTEBASKET_PURGE) || (!pcs || !(pcs->fFlags & FOF_ALLOWUNDO)) || !BBWillRecycle(cdd.pFileSource, NULL)) { // we are really nuking it, so show the appropriate icon/dialog cdd.bFireIcon = TRUE; if (pcs) { pcs->fFlags &= ~FOF_ALLOWUNDO; } cdd.uDeleteWarning = IDS_FOLDERDELETEWARNING; } else { // we are recycling it cdd.uDeleteWarning = IDS_FOLDERRECYCLEWARNING; } } // // NTRAID#NTBUG9-100335-2001/01/03-jeffreys // See also #128485 in the OSR v 4.1 database // // The fix for 128485 added the BBWillRecycle check below, but this // caused NTBUG9-100335. These 2 bugs say the opposite things. // We've had several customer complaints (see dupes of 100335) // so I'm putting it back to the way it worked in Windows 2000. // if (pcs && pcs->fNoConfirmRecycle /*&& BBWillRecycle(cdd.pFileSource, NULL)*/) { cdd.fConfirm = 0; } } break; case CONFIRM_WONT_RECYCLE_FILE: case CONFIRM_WONT_RECYCLE_FOLDER: cdd.bShrinkDialog = TRUE; cdd.nSourceFiles = 1; cdd.bFireIcon = TRUE; cdd.idText = IDD_TEXT; cdd.fYesMask = CONFIRM_MULTIPLE; cdd.fConfirm = fConfirmType; cdd.fYesToAllMask = fConfirmType | CONFIRM_MULTIPLE; // set the dialog to be file or folder if (fConfirmType == CONFIRM_WONT_RECYCLE_FOLDER) { dlg = DLG_WONT_RECYCLE_FOLDER; } else { dlg = DLG_WONT_RECYCLE_FILE; } break; case CONFIRM_PATH_TOO_LONG: cdd.bShrinkDialog = TRUE; cdd.nSourceFiles = 1; cdd.bFireIcon = TRUE; cdd.idText = IDD_TEXT; cdd.fYesMask = CONFIRM_MULTIPLE; cdd.fConfirm = CONFIRM_PATH_TOO_LONG; cdd.fYesToAllMask = CONFIRM_PATH_TOO_LONG | CONFIRM_MULTIPLE; dlg = DLG_PATH_TOO_LONG; break; case CONFIRM_WONT_RECYCLE_OFFLINE: cdd.bShrinkDialog = TRUE; cdd.nSourceFiles = 1; cdd.bFireIcon = TRUE; cdd.idText = IDD_TEXT; cdd.fYesMask = CONFIRM_MULTIPLE; cdd.fConfirm = fConfirmType; cdd.fYesToAllMask = fConfirmType | CONFIRM_MULTIPLE; dlg = DLG_WONT_RECYCLE_OFFLINE; break; case CONFIRM_STREAMLOSS: cdd.bShrinkDialog = FALSE; cdd.nSourceFiles = 1; cdd.idText = IDD_TEXT; cdd.fConfirm = CONFIRM_STREAMLOSS; cdd.fYesToAllMask = CONFIRM_STREAMLOSS; cdd.pStreamNames = pStreamNames; dlg = DLG_STREAMLOSS_ON_COPY; break; case CONFIRM_FAILED_ENCRYPT: cdd.bShrinkDialog = FALSE; cdd.nSourceFiles = 1; cdd.idText = IDD_TEXT; cdd.bShowCancel = TRUE; cdd.fConfirm = CONFIRM_FAILED_ENCRYPT; cdd.fYesToAllMask = CONFIRM_FAILED_ENCRYPT; dlg = DLG_FAILED_ENCRYPT; break; case CONFIRM_LOST_ENCRYPT_FILE: case CONFIRM_LOST_ENCRYPT_FOLDER: cdd.bShrinkDialog = FALSE; cdd.nSourceFiles = 1; cdd.idText = IDD_TEXT; cdd.bShowCancel = TRUE; cdd.fConfirm = CONFIRM_LOST_ENCRYPT_FILE | CONFIRM_LOST_ENCRYPT_FOLDER; cdd.fYesToAllMask = CONFIRM_LOST_ENCRYPT_FILE | CONFIRM_LOST_ENCRYPT_FOLDER; if (fConfirmType == CONFIRM_LOST_ENCRYPT_FILE) { dlg = DLG_LOST_ENCRYPT_FILE; } else { dlg = DLG_LOST_ENCRYPT_FOLDER; } break; case CONFIRM_REPLACE_FILE: cdd.bShowDates = TRUE; cdd.fYesToAllMask = CONFIRM_REPLACE_FILE; SetConfirmMaskAndText(&cdd, pfdDest->dwFileAttributes, NULL); dlg = DLG_REPLACE_FILE; break; case CONFIRM_REPLACE_FOLDER: cdd.bShowCancel = TRUE; if (pcs) pcs->nSourceFiles = -1; // show cancel on NEXT confirm dialog // this implies operations on the files cdd.fYesMask = CONFIRM_REPLACE_FILE; cdd.fYesToAllMask = CONFIRM_REPLACE_FILE | CONFIRM_REPLACE_FOLDER; dlg = DLG_REPLACE_FOLDER; break; case CONFIRM_MOVE_FILE: cdd.fYesToAllMask = CONFIRM_MOVE_FILE; SetConfirmMaskAndText(&cdd, pfdSource->dwFileAttributes, NULL); dlg = DLG_MOVE_FILE; break; case CONFIRM_MOVE_FOLDER: cdd.bShowCancel = TRUE; cdd.fYesToAllMask = CONFIRM_MOVE_FOLDER; SetConfirmMaskAndText(&cdd, pfdSource->dwFileAttributes, cdd.pFileSource); dlg = DLG_MOVE_FOLDER; break; case CONFIRM_RENAME_FILE: SetConfirmMaskAndText(&cdd, pfdSource->dwFileAttributes, NULL); dlg = DLG_RENAME_FILE; break; case CONFIRM_RENAME_FOLDER: cdd.bShowCancel = TRUE; if (pcs) pcs->nSourceFiles = -1; // show cancel on NEXT confirm dialog SetConfirmMaskAndText(&cdd, pfdSource->dwFileAttributes, cdd.pFileSource); dlg = DLG_RENAME_FOLDER; break; default: DebugMsg(DM_WARNING, TEXT("bogus confirm option")); return IDCANCEL; } // Does this operation need to be confirmed? if (pcd->fConfirm & cdd.fConfirm) { // Has the user already said "No To All" for this operation? if ((pcd->fNoToAll & cdd.fConfirm) == cdd.fConfirm) { ret = IDNO; } else { // HACK for multimon, make sure the file operation dialog box comes // up on the correct monitor POINT ptInvoke; HWND hwndPos = NULL; if ((GetNumberOfMonitors() > 1) && GetCursorPos(&ptInvoke)) { HMONITOR hMon = MonitorFromPoint(ptInvoke, MONITOR_DEFAULTTONULL); if (hMon) { hwndPos = _CreateStubWindow(&ptInvoke, hwnd); } } ret = (int)DialogBoxParam(HINST_THISDLL, MAKEINTRESOURCE(dlg), (hwndPos ? hwndPos : hwnd), ConfirmDlgProc, (LPARAM)&cdd); if (hwndPos) DestroyWindow(hwndPos); if (ret == -1) ret = ERROR_NOT_ENOUGH_MEMORY; } } else { ret = IDYES; } return ret; } // // DTNIsParentConnectOrigin() // // When a folder ("c:\foo files") is moved to a different drive ("a:\"), the source and the // destinations have different roots, and therefore the "fRecursive" flag is turned ON by default. // This results in confirmations obtained for the individual files ("c:\foo files\aaa.gif") // rather than the folder itself. We need to first find the parent and then save the confirmation // in the connected element of it's parent. This function gets the top-most parent and then // checks to see if it is a connect origin and if so returns that parent pointer. // PDIRTREENODE DTNGetConnectOrigin(PDIRTREENODE pdtn) { PDIRTREENODE pdtnParent = pdtn; //Get the top-level parent of the given node. while (pdtn) { pdtnParent = pdtn; pdtn = pdtn->pdtnParent; } //Now check if the parent is a connect origin. if (pdtnParent && DTNIsConnectOrigin(pdtnParent)) return pdtnParent; //If so, return him. else return NULL; } // // CachedConfirmFileOp() // // When a file("foo.htm") is moved/copied, we may put up a confirmation dialog in case // of a conflict and the end-user might have responded saying "Yes", "no" etc., When the // corresponding connected element ("foo files") is also moved/copied etc., we should NOT put up // a confirmation dialog again. We must simply store the answer to the original confirmation and // use it later. // // What this function does is: if the given node is a connected element, it simply retrieves the // confirmation for the original operation and returns. If the given element is NOT a connected // element, then this function calls the ConfirmFileOp and stores the confirmation result in // it's connected element sothat, it later it can be used by the connected element. // int CachedConfirmFileOp(HWND hwnd, COPY_STATE *pcs, CONFIRM_DATA *pcd, int nSourceFiles, int cDepth, CONFIRM_FLAG fConfirm, LPCTSTR pFileSource, const WIN32_FIND_DATA *pfdSource, LPCTSTR pFileDest, const WIN32_FIND_DATA *pfdDest, LPCTSTR pStreamNames) { int result; //See if this is a connected item. if (DTNIsConnected(pcs->dth.pdtnCurrent)) { // Since this is a connected item, the confirmation must already have been obtained from // the user and get it from the cache! result = DTNGetConfirmationResult(pcs->dth.pdtnCurrent); } else { PDIRTREENODE pdtnConnectOrigin; result = ConfirmFileOp(hwnd, pcs, pcd, nSourceFiles, cDepth, fConfirm, pFileSource, pfdSource, pFileDest, pfdDest, pStreamNames); //Check if this node has a connection. if (pdtnConnectOrigin = DTNGetConnectOrigin(pcs->dth.pdtnCurrent)) { pdtnConnectOrigin->pdtnConnected->ConnectedInfo.dwConfirmation = result; // PERF: Can we check for the result to be IDCANCEL or IDNO and if so make the // connected node a Dummy? Currently this won't work because current code assumes // that dummy nodes do not have children. This connected node might have some children. // if ((result == IDCANCEL) || (result == IDNO)) // pdtnConnectOrigin->pdtnConnected->fDummy = TRUE; } } return result; } void GuessAShortName(LPCTSTR p, LPTSTR szT) { int i, j, fDot, cMax; for (i = j = fDot = 0, cMax = 8; *p; p++) { if (*p == TEXT('.')) { // if there was a previous dot, step back to it // this way, we get the last extension if (fDot) i -= j+1; // set number of chars to 0, put the dot in j = 0; szT[i++] = TEXT('.'); // remember we saw a dot and set max 3 chars. fDot = TRUE; cMax = 3; } else if (j < cMax && (PathGetCharType(*p) & GCT_SHORTCHAR)) { // if *p is a lead byte, we move forward one more if (IsDBCSLeadByte(*p)) { szT[i] = *p++; if (++j >= cMax) continue; ++i; } j++; szT[i++] = *p; } } szT[i] = 0; } /* GetNameDialog * * Runs the dialog box to prompt the user for a new filename when copying * or moving from HPFS to FAT. */ typedef struct { LPTSTR pszDialogFrom; LPTSTR pszDialogTo; BOOL bShowCancel; } GETNAME_DATA; BOOL_PTR CALLBACK GetNameDlgProc(HWND hDlg, UINT wMsg, WPARAM wParam, LPARAM lParam) { TCHAR szT[14]; TCHAR szTo[MAX_PATH]; GETNAME_DATA * pgn = (GETNAME_DATA *)GetWindowLongPtr(hDlg, DWLP_USER); switch (wMsg) { case WM_INITDIALOG: SetWindowLongPtr(hDlg, DWLP_USER, lParam); pgn = (GETNAME_DATA *)lParam; // inform the user of the old name PathSetDlgItemPath(hDlg, IDD_FROM, pgn->pszDialogFrom); // directory the file will go into PathRemoveFileSpec(pgn->pszDialogTo); PathSetDlgItemPath(hDlg, IDD_DIR, pgn->pszDialogTo); // generate a guess for the new name GuessAShortName(PathFindFileName(pgn->pszDialogFrom), szT); lstrcpy(szTo, pgn->pszDialogTo); PathAppend(szTo, szT); // make sure that name is unique PathYetAnotherMakeUniqueName(szTo, szTo, NULL, NULL); SetDlgItemText(hDlg, IDD_TO, PathFindFileName(szTo)); SendDlgItemMessage(hDlg, IDD_TO, EM_LIMITTEXT, 13, 0L); SHAutoComplete(GetDlgItem(hDlg, IDD_TO), 0); if (!pgn->bShowCancel) HideYesToAllAndNo(hDlg); break; case WM_COMMAND: switch (GET_WM_COMMAND_ID(wParam, lParam)) { case IDD_YESTOALL: case IDYES: GetDlgItemText(hDlg, IDD_TO, szT, ARRAYSIZE(szT)); PathAppend(pgn->pszDialogTo, szT); PathQualify(pgn->pszDialogTo); // fall through case IDNO: case IDCANCEL: EndDialog(hDlg,GET_WM_COMMAND_ID(wParam, lParam)); break; case IDD_TO: { LPCTSTR p; GetDlgItemText(hDlg, IDD_TO, szT, ARRAYSIZE(szT)); for (p = szT; *p; p = CharNext(p)) { if (!(PathGetCharType(*p) & GCT_SHORTCHAR)) break; } EnableWindow(GetDlgItem(hDlg,IDYES), ((!*p) && (p != szT))); } break; default: return FALSE; } break; default: return FALSE; } return TRUE; } int GetNameDialog(HWND hwnd, COPY_STATE *pcs, BOOL fMultiple,UINT wOp, LPTSTR pFrom, LPTSTR pTo) { int iRet; // if we don't want to confirm this, just mock up a string and return ok if (!(pcs->cd.fConfirm & CONFIRM_LFNTOFAT)) { TCHAR szTemp[MAX_PATH]; GuessAShortName(PathFindFileName(pFrom), szTemp); PathRemoveFileSpec(pTo); PathAppend(pTo, szTemp); // make sure that name is unique PathYetAnotherMakeUniqueName(pTo, pTo, NULL, NULL); iRet = IDYES; } else { GETNAME_DATA gn; gn.pszDialogFrom = pFrom; gn.pszDialogTo = pTo; gn.bShowCancel = fMultiple; iRet = (int)DialogBoxParam(HINST_THISDLL, MAKEINTRESOURCE(DLG_LFNTOFAT), hwnd, GetNameDlgProc, (LPARAM)(GETNAME_DATA *)&gn); if (iRet == IDD_YESTOALL) pcs->cd.fConfirm &= ~CONFIRM_LFNTOFAT; } return iRet; } STDAPI_(void) SHFreeNameMappings(void *hNameMappings) { HDSA hdsaRenamePairs = (HDSA)hNameMappings; int i; if (!hdsaRenamePairs) return; i = DSA_GetItemCount(hdsaRenamePairs) - 1; for (; i >= 0; i--) { SHNAMEMAPPING FAR* prp = DSA_GetItemPtr(hdsaRenamePairs, i); LocalFree(prp->pszOldPath); LocalFree(prp->pszNewPath); } DSA_Destroy(hdsaRenamePairs); } void _ProcessNameMappings(LPTSTR pszTarget, HDSA hdsaRenamePairs) { int i; if (!hdsaRenamePairs) return; for (i = DSA_GetItemCount(hdsaRenamePairs) - 1; i >= 0; i--) { TCHAR cTemp; SHNAMEMAPPING FAR* prp = DSA_GetItemPtr(hdsaRenamePairs, i); // I don't call StrCmpNI 'cause I already know cchOldPath, and // it has to do a couple of lstrlen()s to calculate it. cTemp = pszTarget[prp->cchOldPath]; pszTarget[prp->cchOldPath] = 0; // Does the target match this collision renaming entry? // NOTE: We are trying to compare a path to a path. prp->pszOldPath // does not have a trailing "\" character, so this isn't covered // by the lstrcmpi below. As such, cTemp had best be the path // seperator character to ensure that the modified pszTarget is actually // a path and not a filename or a longer path name that doesn't match // but happens to start with the same characters as prp->pszOldPath. if ((cTemp == TEXT('\\')) && !lstrcmpi(pszTarget, prp->pszOldPath)) { // Get subtree string of the target. TCHAR *pszSubTree = &(pszTarget[prp->cchOldPath + 1]); // Generate the new target path. PathCombine(pszTarget, prp->pszNewPath, pszSubTree); break; } else { // Restore the trounced character. pszTarget[prp->cchOldPath] = cTemp; } } } /* Sets the status dialog item in the modeless status dialog box. */ // used for both the drag drop status dialogs and the manual user // entry dialogs so be careful what you change void SetProgressText(COPY_STATE *pcs, LPCTSTR pszFrom, LPCTSTR pszTo) { HWND hwndProgress = pcs->hwndProgress; if (hwndProgress && !(pcs->fFlags & FOF_SIMPLEPROGRESS)) { TCHAR szFrom[MAX_PATH], szTo[MAX_PATH]; LPTSTR pszMsg = NULL; HDC hdc; HFONT hfont; HFONT hfontSave; RECT rc; int cxWidth; SIZE size; // // Compute the size we can use for our file names (REVIEW: Cache this result?) // hdc = GetDC(hwndProgress); hfont = (HFONT)SendMessage(hwndProgress, WM_GETFONT, 0, 0); hfontSave = (HFONT)SelectObject(hdc, hfont); GetWindowRect(GetDlgItem(hwndProgress, IDD_TONAME), &rc); cxWidth = rc.right - rc.left; if (NULL != pszTo && pcs->fFlags & FOF_MULTIDESTFILES) { lstrcpy(szFrom, pszTo); } else { lstrcpy(szFrom, pszFrom); } PathStripPath(szFrom); PathCompactPath(hdc, szFrom, cxWidth); SetDlgItemText(hwndProgress, IDD_NAME, szFrom); lstrcpy(szFrom, pszFrom); if (szFrom[0]) { LPTSTR pszResource = MAKEINTRESOURCE(IDS_FROM); LPTSTR pszToUsable = NULL; szTo[0] = TEXT('\0'); if (pszTo) { pszToUsable = szTo; pszResource = MAKEINTRESOURCE(IDS_FROMTO); } pszMsg = ShellConstructMessageString(HINST_THISDLL, pszResource, "", pszToUsable); if (NULL != pszMsg) { GetTextExtentPoint(hdc, pszMsg, lstrlen(pszMsg), &size); cxWidth -= size.cx; LocalFree(pszMsg); } // // Now build the file names // PathRemoveFileSpec(szFrom); PathStripPath(szFrom); if (pszTo) { lstrcpy(szTo, pszTo); PathRemoveFileSpec(szTo); PathStripPath(szTo); PathCompactPath(hdc, szFrom, cxWidth/2); PathCompactPath(hdc, szTo, cxWidth/2); } else { PathCompactPath(hdc, szFrom, cxWidth); } // // Now create the real message // pszMsg = ShellConstructMessageString(HINST_THISDLL, pszResource, szFrom, pszToUsable); } else if (!pcs->fDTBuilt) { TCHAR szFunc[80]; if (LoadString(HINST_THISDLL, FOFuncToStringID(pcs->lpfo->wFunc), szFunc, ARRAYSIZE(szFunc))) { pszMsg = ShellConstructMessageString(HINST_THISDLL, MAKEINTRESOURCE(IDS_PREPARINGTO), szFunc); } } if (pszMsg) { SetDlgItemText(hwndProgress, IDD_TONAME, pszMsg); LocalFree(pszMsg); } SelectObject(hdc, hfontSave); ReleaseDC(hwndProgress, hdc); } } void SetProgressTimeEst(COPY_STATE *pcs, DWORD dwTimeLeft) { TCHAR szFmt[60]; TCHAR szOut[70]; DWORD dwTime; if (pcs->hwndProgress) { if (dwTimeLeft > 4*60*60) // 4 hours and over you get no text { szFmt[0] = TEXT('\0'); } else if (dwTimeLeft > 60) { // Note that dwTime is at least 2, so we only need a plural form LoadString(HINST_THISDLL, IDS_TIMEEST_MINUTES, szFmt, ARRAYSIZE(szFmt)); dwTime = (dwTimeLeft / 60) + 1; } else { LoadString(HINST_THISDLL, IDS_TIMEEST_SECONDS, szFmt, ARRAYSIZE(szFmt)); // Round up to 5 seconds so it doesn't look so random dwTime = ((dwTimeLeft+4) / 5) * 5; } wsprintf(szOut, szFmt, dwTime); SetDlgItemText(pcs->hwndProgress, IDD_TIMEEST, szOut); } } // this updates the animation, which could change because we could switch between // doing a move to recycle bin and really nuke if the file/folder was bigger that // the allowable size of the recycle bin. void UpdateProgressAnimation(COPY_STATE *pcs) { if (pcs->hwndProgress && pcs->lpfo) { INT_PTR idAni, idAniCurrent; HWND hwndAnimation; switch (pcs->lpfo->wFunc) { case FO_DELETE: if ((pcs->lpfo->lpszProgressTitle == MAKEINTRESOURCE(IDS_BB_EMPTYINGWASTEBASKET)) || (pcs->lpfo->lpszProgressTitle == MAKEINTRESOURCE(IDS_BB_DELETINGWASTEBASKETFILES))) { idAni = IDA_FILENUKE; break; } else if (!(pcs->fFlags & FOF_ALLOWUNDO)) { idAni = IDA_FILEDELREAL; break; } // else fall through to default default: idAni = (IDA_FILEMOVE + (int)pcs->lpfo->wFunc - FO_MOVE); } hwndAnimation = GetDlgItem(pcs->hwndProgress,IDD_ANIMATE); idAniCurrent = (INT_PTR) GetProp(hwndAnimation, TEXT("AnimationID")); if (idAni != idAniCurrent) { // the one we should be using is different from the one we have, // so update it // close the old clip Animate_Close(hwndAnimation); // open the new one Animate_Open(hwndAnimation, idAni); // if the window is enabled, start the new animation playing if (IsWindowEnabled(pcs->hwndProgress)) Animate_Play(hwndAnimation, -1, -1, -1); // set the current idAni SetProp(hwndAnimation, TEXT("AnimationID"), (HANDLE)idAni); // at the same time we update the animation, we also update the text, // so that the two will always be in sync SetProgressText(pcs, pcs->dth.szSrcPath, pcs->lpfo->wFunc == FO_DELETE ? NULL : pcs->dth.szDestPath); } } } void SendProgressMessage(COPY_STATE *pcs, UINT uMsg, WPARAM wParam, LPARAM lParam) { if (pcs->hwndProgress) SendDlgItemMessage(pcs->hwndProgress, IDD_PROBAR, uMsg, wParam, lParam); } // // creates folder and all parts of the path if necessary (parent does not need // to exists) and verifies that the contents of the folder will be visibile. // // in: // hwnd hwnd to post UI on // pszPath full path to create // psa security attributes // // returns: // ERROR_SUCCESS (0) success // ERROR_ failure // STDAPI_(int) SHCreateDirectoryEx(HWND hwnd, LPCTSTR pszPath, SECURITY_ATTRIBUTES *psa) { int ret = ERROR_SUCCESS; if (PathIsRelative(pszPath)) { // if not a "full" path bail // to ensure that we dont create a dir in the current working directory SetLastError(ERROR_BAD_PATHNAME); return ERROR_BAD_PATHNAME; } if (!Win32CreateDirectory(pszPath, psa)) { TCHAR *pEnd, *pSlash, szTemp[MAX_PATH]; ret = GetLastError(); // There are certain error codes that we should bail out here // before going through and walking up the tree... switch (ret) { case ERROR_FILENAME_EXCED_RANGE: case ERROR_FILE_EXISTS: case ERROR_ALREADY_EXISTS: return ret; } lstrcpyn(szTemp, pszPath, ARRAYSIZE(szTemp)); pEnd = PathAddBackslash(szTemp); // for the loop below // assume we have 'X:\' to start this should even work // on UNC names because will will ignore the first error pSlash = szTemp + 3; // create each part of the dir in order while (*pSlash) { while (*pSlash && *pSlash != TEXT('\\')) pSlash = CharNext(pSlash); if (*pSlash) { ASSERT(*pSlash == TEXT('\\')); *pSlash = 0; // terminate path at seperator ret = Win32CreateDirectory(szTemp, pSlash + 1 == pEnd ? psa : NULL) ? ERROR_SUCCESS : GetLastError(); } *pSlash++ = TEXT('\\'); // put the seperator back } } if (ERROR_SUCCESS != ret) { // We failed, so let's try to display error UI. if (hwnd && ERROR_CANCELLED != ret) { SHSysErrorMessageBox(hwnd, NULL, IDS_CANNOTCREATEFOLDER, ret, pszPath ? PathFindFileName(pszPath) : NULL, MB_OK | MB_ICONEXCLAMATION); ret = ERROR_CANCELLED; // Indicate we already displayed Error UI. } } return ret; } STDAPI_(int) SHCreateDirectory(HWND hwnd, LPCTSTR pszPath) { return SHCreateDirectoryEx(hwnd, pszPath, NULL); } #ifdef UNICODE STDAPI_(int) SHCreateDirectoryExA(HWND hwnd, LPCSTR pszPath, SECURITY_ATTRIBUTES *psa) { WCHAR wsz[MAX_PATH]; SHAnsiToUnicode(pszPath, wsz, SIZECHARS(wsz)); return SHCreateDirectoryEx(hwnd, wsz, psa); } #else STDAPI_(int) SHCreateDirectoryExW(HWND hwnd, LPCWSTR pszPath, SECURITY_ATTRIBUTES *psa) { char sz[MAX_PATH]; SHUnicodeToAnsi(pszPath, sz, SIZECHARS(sz)); return SHCreateDirectoryEx(hwnd, sz, psa); } #endif // call MPR to find out the speed of a given path // // returns // 0 for unknown // 144 for 14.4 modems // 96 for 9600 // 24 for 2400 // // if the device does not return a speed we return 0 // DWORD GetPathSpeed(LPCTSTR pszPath) { NETCONNECTINFOSTRUCT nci; NETRESOURCE nr; TCHAR szPath[MAX_PATH]; lstrcpyn(szPath, pszPath, ARRAYSIZE(szPath)); PathStripToRoot(szPath); // get a root to this path memset(&nci, 0, sizeof(nci)); nci.cbStructure = sizeof(nci); memset(&nr, 0, sizeof(nr)); if (PathIsUNC(szPath)) nr.lpRemoteName = szPath; else { // Don't bother for local drives if (!IsRemoteDrive(DRIVEID(szPath))) return 0; // we are passing in a local drive and MPR does not like us to pass a // local name as Z:\ but only wants Z: szPath[2] = 0; // Strip off after character and : nr.lpLocalName = szPath; } // dwSpeed is returned by MultinetGetConnectionPerformance MultinetGetConnectionPerformance(&nr, &nci); return nci.dwSpeed; } DWORD CopyCallbackProc(LARGE_INTEGER liTotSize, LARGE_INTEGER liBytes, LARGE_INTEGER liStreamSize, LARGE_INTEGER liStreamBytes, DWORD dwStream, DWORD dwCallback, HANDLE hSource, HANDLE hDest, void *pv) { COPY_STATE *pcs = (COPY_STATE *)pv; DebugMsg(DM_TRACE, TEXT("CopyCallbackProc[%08lX], totsize=%08lX, bytes=%08lX"), dwCallback, liTotSize.LowPart, liBytes.LowPart); if (FOQueryAbort(pcs)) return PROGRESS_CANCEL; DTSetFileCopyProgress(&pcs->dth, liBytes); if (pcs->fInitialize) { // preserve the create date when moving across volumes, otherwise use the // create date the file system picked when we did the CreateFile() // always preserve modified date (ftLastWriteTime) // bummer is we loose accuracy when going to VFAT compared to NT servers SetFileTime((HANDLE)hDest, (pcs->lpfo->wFunc == FO_MOVE) ? &pcs->pfd->ftCreationTime : NULL, NULL, &pcs->pfd->ftLastWriteTime); pcs->fInitialize = FALSE; } switch (dwCallback) { case CALLBACK_STREAM_SWITCH: break; case CALLBACK_CHUNK_FINISHED: break; default: break; } return PROGRESS_CONTINUE; } // copy the SECURITY_DESCRIPTOR for two files // // in: // pszSource fully qualified source path // pszDest fully qualified destination path // // returns: // 0 ERROR_SUCCESS // WIN32 error codes // DWORD CopyFileSecurity(LPCTSTR pszSource, LPCTSTR pszDest) { DWORD err = ERROR_SUCCESS; BOOL fRet = TRUE; BYTE buf[512]; // arbitrarily saying do everything we can // except SACL_SECURITY_INFORMATION because SECURITY_INFORMATION si = OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION; PSECURITY_DESCRIPTOR psd = (PSECURITY_DESCRIPTOR) buf; DWORD cbPsd = sizeof(buf); if (!SHRestricted(REST_FORCECOPYACLWITHFILE)) { // shell restriction so return access denied? return ERROR_ACCESS_DENIED; } fRet = GetFileSecurity(pszSource, si, psd, cbPsd, &cbPsd); if (!fRet) { err = GetLastError(); if (ERROR_INSUFFICIENT_BUFFER == err) { // just need to resize the buffer and try again psd = (PSECURITY_DESCRIPTOR) LocalAlloc(LPTR, cbPsd); if (psd) { fRet = GetFileSecurity(pszSource, si, psd, cbPsd, &cbPsd); } else { err = ERROR_NOT_ENOUGH_MEMORY; } } } if (fRet) { fRet = SetFileSecurity(pszDest, si, psd); if (!fRet) err = GetLastError(); } if (psd && psd != buf) LocalFree(psd); if (fRet) return ERROR_SUCCESS; return err; } // reset the SECURITY_DESCRIPTOR on a file or directory // // in: // pszDest fully qualified destination path // // returns: // 0 ERROR_SUCCESS // WIN32 error codes // DWORD ResetFileSecurity(LPCTSTR pszDest) { DWORD err = ERROR_SUCCESS; if (!SHRestricted(REST_FORCECOPYACLWITHFILE)) { ACL acl; InitializeAcl(&acl, sizeof(acl), ACL_REVISION); // TreeResetNamedSecurityInfo has a callback mechanism, but // we currently don't use it. Note that the paths passed to // the callback look like // "\Device\HarddiskVolume1\dir\name" err = TreeResetNamedSecurityInfo((LPTSTR)pszDest, SE_FILE_OBJECT, DACL_SECURITY_INFORMATION | UNPROTECTED_DACL_SECURITY_INFORMATION, NULL, NULL, &acl, NULL, FALSE, // KeepExplicit (perms on children) NULL, ProgressInvokeNever, NULL); } return err; } // // in: // hwnd Window to report things to. // pszSource fully qualified source path // pszDest fully qualified destination path // pfd source file find data (size/date/time/attribs) // // returns: // ERROR_SUCCESS (0) // other Win32 ERROR_ codes // UINT FileCopy(COPY_STATE *pcs, LPCTSTR pszSource, LPCTSTR pszDest, const WIN32_FIND_DATA *pfd, BOOL fCreateAlways) { UINT iRet = ERROR_CANCELLED; BOOL fRetryPath = FALSE; BOOL fRetryAttr = FALSE; BOOL fCopyOrMoveSucceeded = FALSE; BOOL fSecurityObtained = FALSE; DWORD dwCopyFlags; // Buffers for security info BYTE rgbSecurityDescriptor[512]; SECURITY_INFORMATION si = OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION; PSECURITY_DESCRIPTOR psd = (PSECURITY_DESCRIPTOR) rgbSecurityDescriptor; DWORD cbPsd = sizeof(rgbSecurityDescriptor); // Make sure we can start if (FOQueryAbort(pcs)) return ERROR_CANCELLED; // // Now do the file copy/move // // Get the security info from the source file. If there is a problem // (e.g. the file is on FAT) we ignore it and proceed with the copy/move. if (!(pcs->fFlags & FOF_NOCOPYSECURITYATTRIBS)) { if (SHRestricted(REST_FORCECOPYACLWITHFILE)) { if (GetFileSecurity(pszSource, si, psd, cbPsd, &cbPsd)) { fSecurityObtained = TRUE; } else { if (ERROR_INSUFFICIENT_BUFFER == GetLastError()) { psd = (PSECURITY_DESCRIPTOR) LocalAlloc(LPTR, cbPsd); if (psd) { if (GetFileSecurity(pszSource, si, psd, cbPsd, &cbPsd)) { fSecurityObtained = TRUE; } } } } } } TryCopyAgain: pcs->fInitialize = TRUE; pcs->pfd = pfd; SetProgressText(pcs, pszSource, pszDest); dwCopyFlags = 0; if (pcs->fLostEncryptOk) { dwCopyFlags |= COPY_FILE_ALLOW_DECRYPTED_DESTINATION; } if (FO_MOVE == pcs->lpfo->wFunc) { fCopyOrMoveSucceeded = MoveFileWithProgress(pszSource, pszDest, CopyCallbackProc, pcs, MOVEFILE_COPY_ALLOWED | (fCreateAlways ? MOVEFILE_REPLACE_EXISTING : 0)); } else { if (!fCreateAlways) { dwCopyFlags |= COPY_FILE_FAIL_IF_EXISTS; } fCopyOrMoveSucceeded = CopyFileEx(pszSource, pszDest, CopyCallbackProc, pcs, &pcs->bAbort, dwCopyFlags); } if (!fCopyOrMoveSucceeded) { int iLastError = (int)GetLastError(); DebugMsg(TF_DEBUGCOPY, TEXT("FileCopy() failed, get last error returned 0x%08x"), iLastError); switch (iLastError) { // Let the caller handle this one case ERROR_FILE_EXISTS: case ERROR_ALREADY_EXISTS: // nt5 221893 CopyFileEx now returns this for some reason... iRet = ERROR_FILE_EXISTS; goto Exit; case ERROR_DISK_FULL: if (PathIsUNC(pszDest) || !IsRemovableDrive(DRIVEID(pszDest)) || PathIsSameRoot(pszDest,pszSource)) { break; } iLastError = ERROR_DISK_FULL; // Fall through case ERROR_PATH_NOT_FOUND: if (!fRetryPath) { // ask the user to stick in another disk or empty wastebasket ULARGE_INTEGER ulFileSize; ulFileSize.LowPart = pfd->nFileSizeLow; ulFileSize.HighPart = pfd->nFileSizeHigh; iLastError = CopyMoveRetry(pcs, pszDest, iLastError, &ulFileSize); if (!iLastError) { fRetryPath = TRUE; goto TryCopyAgain; } CopyError(pcs, pszSource, pszDest, (UINT)iLastError | ERRORONDEST, FO_COPY, OPER_DOFILE); iRet = ERROR_CANCELLED; goto Exit; } break; case ERROR_ENCRYPTION_FAILED: if (pfd->dwFileAttributes & FILE_ATTRIBUTE_ENCRYPTED && FALSE == pcs->fLostEncryptOk) { int result; result = CachedConfirmFileOp(pcs->hwndDlgParent, pcs, &pcs->cd, pcs->nSourceFiles, FALSE, CONFIRM_LOST_ENCRYPT_FILE, pszSource, pfd, pszDest, NULL, NULL); switch (result) { case IDYES: pcs->fLostEncryptOk = TRUE; goto TryCopyAgain; case IDNO: case IDCANCEL: pcs->bAbort = TRUE; iRet = result; break; default: iRet = result; break; } } break; case ERROR_ACCESS_DENIED: // check if the filename is too long if (lstrlen(PathFindFileName(pszSource)) + lstrlen(pszDest) >= MAX_PATH) { iLastError = DE_FILENAMETOOLONG; } else if (!fRetryAttr) { // If the file is readonly, reset the readonly attribute // and have another go at it DWORD dwAttributes = GetFileAttributes(pszDest); if (0xFFFFFFFF != dwAttributes) { dwAttributes &= ~(FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM); if (SetFileAttributes(pszDest, dwAttributes)) { fRetryAttr = TRUE; goto TryCopyAgain; } } // GetFileAttributes() 10 lines above clobers GetLastError() and CopyError() // needs it. SetLastError(iLastError); } break; } if (!pcs->bAbort) { CopyError(pcs, pszSource, pszDest, iLastError, FO_COPY, OPER_DOFILE); } iRet = ERROR_CANCELLED; // error already reported goto Exit; } // If copying from a CDRom - clear the read-only bit if (pcs->fFromCDRom) { SetFileAttributes(pszDest, pfd->dwFileAttributes & ~FILE_ATTRIBUTE_READONLY); } // Set the source's security on the destination, ignoring any error. if (fSecurityObtained) { SetFileSecurity(pszDest, si, psd); } SHChangeNotify(SHCNE_CREATE, SHCNF_PATH, pszDest, NULL); if (FO_MOVE == pcs->lpfo->wFunc) { // Let windows waiting on notifications of Source know of change. We have to check // to see if the file is actually gone in order to tell if it actually moved or not. if (!PathFileExists(pszSource)) SHChangeNotify(SHCNE_DELETE, SHCNF_PATH, pszSource, NULL); } else if (0 == StrCmpIC(pfd->cFileName, TEXT("desktop.ini"))) { // clean out stuff from the desktop.ini WritePrivateProfileSection(TEXT("DeleteOnCopy"), NULL, pszDest); } iRet = ERROR_SUCCESS; // 0 Exit: // If we had to alloc a buffer for the security descriptor, // free it now. if (psd && (rgbSecurityDescriptor != psd)) LocalFree(psd); return iRet; } // note: this is a very slow call DWORD GetFreeClusters(LPCTSTR szPath) { DWORD dwFreeClus; DWORD dwTemp; if (GetDiskFreeSpace(szPath, &dwTemp, &dwTemp, &dwFreeClus, &dwTemp)) return dwFreeClus; else return (DWORD)-1; } // note: this is a very slow call BOOL TotalCapacity(LPCTSTR szPath, ULARGE_INTEGER *puliDiskSize) { int idDrive = PathGetDriveNumber(szPath); if (idDrive != -1) { TCHAR szDrive[5]; ULARGE_INTEGER ullDiskFreeForUser; PathBuildRoot(szDrive, idDrive); return GetDiskFreeSpaceEx(szDrive, &ullDiskFreeForUser, puliDiskSize, NULL); } return FALSE; } typedef struct { LPTSTR pszTitle; LPTSTR pszText; } DISKERRORPARAM; BOOL_PTR CALLBACK DiskErrDlgProc(HWND hDlg, UINT uMessage, WPARAM wParam, LPARAM lParam) { switch (uMessage) { case WM_INITDIALOG: { DISKERRORPARAM *pDiskError = (DISKERRORPARAM *) lParam; if (pDiskError) { SetWindowText(hDlg, pDiskError->pszTitle); SetDlgItemText(hDlg, IDC_DISKERR_EXPLAIN, pDiskError->pszText); } Static_SetIcon(GetDlgItem(hDlg, IDC_DISKERR_STOPICON), LoadIcon(NULL, IDI_HAND)); } break; case WM_COMMAND: switch (LOWORD(wParam)) { case IDOK: case IDCANCEL: case IDC_DISKERR_LAUNCHCLEANUP: EndDialog (hDlg, LOWORD(wParam)); break; default: return FALSE; } break; default: return FALSE; } return TRUE; } void DisplayFileOperationError(HWND hParent, int idVerb, int wFunc, int nError, LPCTSTR pszReason, LPCTSTR pszPath, LPCTSTR pszDest) { TCHAR szBuffer[80]; DISKERRORPARAM diskparams; // Grab title from resource if (LoadString(HINST_THISDLL, IDS_FILEERROR + wFunc, szBuffer, ARRAYSIZE(szBuffer))) { diskparams.pszTitle = szBuffer; } else { diskparams.pszTitle = NULL; } // Build Message to display diskparams.pszText = ShellConstructMessageString(HINST_THISDLL, MAKEINTRESOURCE(idVerb), pszReason, PathFindFileName(pszPath)); if (diskparams.pszText) { int idDrive = DriveIDFromBBPath(pszDest); //if we want to show Disk cleanup do our stuff, otherwise do MessageBox if (nError == ERROR_DISK_FULL && IsBitBucketableDrive(idDrive) && !PathIsUNC(pszDest) && GetDiskCleanupPath(NULL, 0)) { if (DialogBoxParam(HINST_THISDLL, MAKEINTRESOURCE(DLG_DISKERR), hParent, DiskErrDlgProc, (LPARAM)&diskparams) == IDC_DISKERR_LAUNCHCLEANUP) { LaunchDiskCleanup(hParent, idDrive, DISKCLEANUP_NOFLAG); } } else { MessageBox(hParent, diskparams.pszText, diskparams.pszTitle, MB_OK | MB_ICONSTOP | MB_SETFOREGROUND); } LocalFree(diskparams.pszText); } } /***********************************************************************\ DESCRIPTION: We received an SHARINGVIOLATION or ACCESSDENIED error. We want to generate the most accruate error message for the user to inform them better. These are the cases we care about: ERROR_ACCESS_DENIED: This is the legacy case with the message: "Access is denied. The source file may be in use." DE_DEST_IS_CDROM: This is displayed in case the user copies a file to their cd-rom drive. DE_DEST_IS_CDRECORD: user deletes from CD recordable drive, we need an error message that isn't so scary about "cant copy files to CD". DE_DEST_IS_DVD: This is displayed in case the user copies a file to their DVD drive DE_SHARING_VIOLATION: The file can't be copied because it's open by someone who doesn't allow others to read the file while they use it. DE_PERMISSIONDENIED: This should be displayed if the user doesn't have the ACLs (security permissions) to read/copy the file. \***********************************************************************/ int GenAccessDeniedError(LPCTSTR pszSource, LPCTSTR pszDest, int nError) { int nErrorMsg = ERROR_ACCESS_DENIED; int iDrive = PathGetDriveNumber(pszDest); if (iDrive != -1) { if (IsCDRomDrive(iDrive)) { WCHAR szDrive[4]; // check if user is deleting from cd-r drive. error message saying "cant copy or move files to cd drive" // doesn't apply. since we're about to put up ui its not like we have to be super fast here, call into cdburning code. if (SUCCEEDED(CDBurn_GetRecorderDriveLetter(szDrive, ARRAYSIZE(szDrive))) && (DRIVEID(szDrive) == iDrive)) { nErrorMsg = DE_DEST_IS_CDRECORD; } else { nErrorMsg = DE_DEST_IS_CDROM; } } if (DriveIsDVD(iDrive)) nErrorMsg = DE_DEST_IS_DVD; } // TODO: DE_SHARING_VIOLATION, DE_PERMISSIONDENIED return nErrorMsg; } // // The following function reports errors for the copy engine // // Parameters // pszSource source file name // pszDest destination file name // nError dos (or our exteneded) error code // 0xFFFF for special case NET error // wFunc FO_* values // nOper OPER_* values, operation being performed // void CopyError(LPCOPY_STATE pcs, LPCTSTR pszSource, LPCTSTR pszDest, int nError, UINT wFunc, int nOper) { TCHAR szReason[200]; TCHAR szFile[MAX_PATH]; int idVerb; BOOL bDest; BOOL fSysError = FALSE; DWORD dwError = GetLastError(); // get Extended error now before we blow it away. if (!pcs || (pcs->fFlags & FOF_NOERRORUI)) return; // caller doesn't want to report errors bDest = nError & ERRORONDEST; // was dest file cause of error nError &= ~ERRORONDEST; // clear the dest bit // We also may need to remap some new error codes into old error codes // if (nError == ERROR_BAD_PATHNAME) nError = DE_INVALIDFILES; if (nError == ERROR_CANCELLED) // user abort return; lstrcpyn(szFile, bDest ? pszDest : pszSource, ARRAYSIZE(szFile)); if (!szFile[0]) { LoadString(HINST_THISDLL, IDS_FILE, szFile, ARRAYSIZE(szFile)); } else { // make the path fits on the screen RECT rcMonitor; HWND hwnd = pcs->hwndProgress ? pcs->hwndProgress : pcs->hwndDlgParent; GetMonitorRect(MonitorFromWindow(hwnd, TRUE), &rcMonitor); PathCompactPath(NULL, szFile, (rcMonitor.right - rcMonitor.left) / 3); } // get the verb string // since we now recycle folders as well as files, added OPER_ENTERDIR check here if ((nOper == OPER_DOFILE) || (nOper == OPER_ENTERDIR) || (nOper == 0)) { if ((nError != -1) && bDest) { idVerb = IDS_REPLACING; } else { idVerb = IDS_VERBS + wFunc; } } else { idVerb = IDS_ACTIONS + (nOper >> 8); } // get the reason string if (nError == 0xFFFF) { DWORD dw; WNetGetLastError(&dw, szReason, ARRAYSIZE(szReason), NULL, 0); } else { // transform some error cases if (bDest) { // This caseing of error codes is error prone.. it would // be better to find the explicit ones we wish to map to // this one instead of trying to guess all the ones // we don't want to map... if ((nError == ERROR_DISK_FULL) || ((nError != ERROR_ACCESS_DENIED) && (nError != ERROR_NETWORK_ACCESS_DENIED) && (nError != ERROR_WRITE_PROTECT) && (nError != ERROR_BAD_NET_NAME) && (GetFreeClusters(pszDest) == 0L))) { nError = ERROR_DISK_FULL; } else if (dwError == ERROR_WRITE_FAULT) { nError = ERROR_WRITE_FAULT; } else if (dwError == ERROR_INVALID_NAME) { nError = ERROR_INVALID_NAME; } } else { if (nError == ERROR_ACCESS_DENIED) { // Check the extended error for more info about the error... // We just map these errors to something generic that // tells the user something weird is going on. switch (dwError) { case ERROR_CRC: case ERROR_SEEK: case ERROR_SECTOR_NOT_FOUND: case ERROR_READ_FAULT: case ERROR_GEN_FAILURE: nError = ERROR_GEN_FAILURE; break; // We can't test for ERROR_FILE_NOT_FOUND because in the case where we copy to // a write-protected dest we check to see if the reason we got access denied was // because there's already a read-only file there. If there isn't _that_ test is // going to SetLastError() to ERROR_FILE_NOT_FOUND and that's what we're going to // report as an error. [davepl] // // case ERROR_FILE_NOT_FOUND: // nError = ERROR_GEN_FAILURE; // break; case ERROR_SHARING_VIOLATION: case ERROR_ACCESS_DENIED: nError = GenAccessDeniedError(pszSource, pszDest, nError); break; default: TraceMsg(TF_WARNING, "CopyEngine: hit error %x , not currently special cased", dwError); break; } } else { // This error occures when a user drags & drops a file from point a to // point b twice. The second time fails because the first time hasn't finished. if (nError == (OPER_ERROR | ERROR_FILE_NOT_FOUND)) { nError = ERROR_GEN_FAILURE; } } } } // the error munging above is in several places, but there are some errors that we // know for SURE the user will never want to see so zap them to generic failures. // this whole thing needs a redesign... we shouldnt depend generally on errors getting // UI ("There is not enough space on the disk.") because then we get crap like this. // but everybody already knows that. switch (nError) { case ERROR_SWAPERROR: // Error performing inpage operation. nError = ERROR_GEN_FAILURE; break; } if (nError <= DE_ERROR_MAX) { BOOL fOverridden = FALSE; if (nError == ERROR_SHARING_VIOLATION) { // in the sharing violation case we can try to be a little better in the error UI by // going through the running object table and seeing if the file is registered in there. // if it's not in there, no biggie, just use our normal handling. PWSTR pszApp; if (SUCCEEDED(FindAppForFileInUse(bDest ? pszDest : pszSource, &pszApp))) { PWSTR pszMessage = ShellConstructMessageString(HINST_THISDLL, MAKEINTRESOURCE(IDS_SHAREVIOLATION_HINT), pszApp); if (pszMessage) { StrCpyN(szReason, pszMessage, ARRAYSIZE(szReason)); fOverridden = TRUE; LocalFree(pszMessage); } LocalFree(pszApp); } } if (!fOverridden) { fSysError = !LoadString(HINST_THISDLL, IDS_REASONS + nError, szReason, ARRAYSIZE(szReason)); } } if (nOper == OPER_DOFILE) { PathRemoveExtension(szFile); } if (fSysError) { SHSysErrorMessageBox(pcs->hwndDlgParent, MAKEINTRESOURCE(IDS_FILEERROR + wFunc), idVerb, nError, PathFindFileName(szFile), MB_OK | MB_ICONSTOP | MB_SETFOREGROUND); } else { if (nError > DE_ERROR_MAX && 0 == FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, nError, 0, szReason, ARRAYSIZE(szReason), NULL)) { szReason[0] = 0; } DisplayFileOperationError(pcs->hwndDlgParent, idVerb, wFunc, nError, szReason, szFile, pszDest); } } // // The following function is used to retry failed move/copy operations // due to out of disk situations or path not found errors // on the destination. // // parameters: // pszDest Fully qualified path to destination file (ANSI) // nError type of error: ERROR_DISK_FULL or ERROR_PATH_NOT_FOUND // dwFileSize amount of space needed for this file if ERROR_DISK_FULL // // returns: // 0 success (destination path has been created) // != 0 dos error code including ERROR_CANCELLED // int CopyMoveRetry(COPY_STATE *pcs, LPCTSTR pszDest, int nError, ULARGE_INTEGER* pulFileSize) { UINT wFlags; int result; LPCTSTR wID; TCHAR szTemp[MAX_PATH]; BOOL fFirstRetry = TRUE; if (pcs->fFlags & FOF_NOERRORUI) { result = ERROR_CANCELLED; goto ErrorExit; } lstrcpyn(szTemp, pszDest, ARRAYSIZE(szTemp)); PathRemoveFileSpec(szTemp); do { // until the destination path has been created if (nError == ERROR_PATH_NOT_FOUND) { if (!(pcs->fFlags & FOF_NOCONFIRMMKDIR)) { wID = MAKEINTRESOURCE(IDS_PATHNOTTHERE); wFlags = MB_ICONEXCLAMATION | MB_YESNO; } else { wID = 0; } } else // ERROR_DISK_FULL { ULARGE_INTEGER ulDiskSize; wFlags = MB_ICONEXCLAMATION | MB_RETRYCANCEL; if (pulFileSize && TotalCapacity(pszDest, &ulDiskSize) && pulFileSize->QuadPart > ulDiskSize.QuadPart) { wID = MAKEINTRESOURCE(IDS_FILEWONTFIT); } else { wID = MAKEINTRESOURCE(IDS_DESTFULL); } } if (wID) { // szTemp will be ignored if there's no %1%s in the string. result = ShellMessageBox(HINST_THISDLL, pcs->hwndDlgParent, wID, MAKEINTRESOURCE(IDS_UNDO_FILEOP + pcs->lpfo->wFunc), wFlags, (LPTSTR)szTemp); } else { result = IDYES; } if (result == IDRETRY || result == IDYES) { TCHAR szDrive[5]; int idDrive; // Allow the disk to be formatted // REVIEW, could this be FO_MOVE as well? if (FAILED(SHPathPrepareForWrite(((pcs->fFlags & FOF_NOERRORUI) ? NULL : pcs->hwndDlgParent), NULL, szTemp, SHPPFW_DEFAULT))) return ERROR_CANCELLED; idDrive = PathGetDriveNumber(szTemp); if (idDrive != -1) PathBuildRoot(szDrive, idDrive); else szDrive[0] = 0; // if we're not copying to the root if (lstrcmpi(szTemp, szDrive)) { result = SHCreateDirectory(pcs->hwndDlgParent, szTemp); if (result == ERROR_CANCELLED) goto ErrorExit; if (result == ERROR_ALREADY_EXISTS) { // if SHPathPrepareForWrite created the directory we shouldn't treat this as an error result = 0; } else if (result && (nError == ERROR_PATH_NOT_FOUND)) { result |= ERRORONDEST; // We try twice to allow the recyclebin to be flushed. if (fFirstRetry) fFirstRetry = FALSE; else goto ErrorExit; } } else { result = 0; } } else { result = ERROR_CANCELLED; goto ErrorExit; } } while (result); ErrorExit: return result; // success } BOOL ValidFilenames(LPCTSTR pList) { if (!*pList) return FALSE; for (; *pList; pList += lstrlen(pList) + 1) { if (PathIsInvalid(pList)) { return FALSE; } } return TRUE; } void AddRenamePairToHDSA(LPCTSTR pszOldPath, LPCTSTR pszNewPath, HDSA* phdsaRenamePairs) { // // Update our collision mapping table // if (!*phdsaRenamePairs) *phdsaRenamePairs = DSA_Create(sizeof(SHNAMEMAPPING), 4); if (*phdsaRenamePairs) { SHNAMEMAPPING rp; rp.cchOldPath = lstrlen(pszOldPath); rp.cchNewPath = lstrlen(pszNewPath); rp.pszOldPath = StrDup(pszOldPath); if (rp.pszOldPath) { rp.pszNewPath = StrDup(pszNewPath); if (rp.pszNewPath) { if (DSA_AppendItem(*phdsaRenamePairs, &rp) == -1) { LocalFree(rp.pszOldPath); LocalFree(rp.pszNewPath); } } else { LocalFree(rp.pszOldPath); } } } } BOOL _HandleRename(LPCTSTR pszSource, LPTSTR pszDest, FILEOP_FLAGS fFlags, COPY_STATE * pcs) { TCHAR *pszConflictingName = PathFindFileName(pszSource); TCHAR szTemp[MAX_PATH]; TCHAR szTemplate[MAX_PATH]; LPTSTR lpszLongPlate; PathRemoveFileSpec(pszDest); if (LoadString(HINST_THISDLL, IDS_COPYLONGPLATE, szTemplate, ARRAYSIZE(szTemplate))) { LPTSTR lpsz; lpsz = pszConflictingName; lpszLongPlate = szTemplate; // see if the first part of the template is the same as the name "Copy #" while (*lpsz && *lpszLongPlate && *lpsz == *lpszLongPlate && *lpszLongPlate != TEXT('(')) { lpsz++; lpszLongPlate++; } if (*lpsz == TEXT('(') && *lpszLongPlate == TEXT('(')) { // conflicting name already in the template, use it instead lpszLongPlate = pszConflictingName; } else { // otherwise build our own // We need to make sure not to overflow a max buffer. int ichFixed = lstrlen(szTemplate) + lstrlen(pszDest) + 5; lpszLongPlate = szTemplate; if ((ichFixed + lstrlen(pszConflictingName)) <= MAX_PATH) { lstrcat(lpszLongPlate, pszConflictingName); } else { // Need to remove some of the name LPTSTR pszExt = StrRChr(pszConflictingName, NULL, TEXT('.')); if (pszExt) { int ichTemplate = lstrlen(lpszLongPlate); lstrcpyn(lpszLongPlate + ichTemplate, pszConflictingName, max(MAX_PATH - ichFixed - lstrlen(pszExt), 0)); // use as much of the buffer as possible StrCatBuff(lpszLongPlate, pszExt, max(MAX_PATH - ichFixed + ichTemplate, 0)); } else { lstrcpyn(lpszLongPlate + lstrlen(lpszLongPlate), pszConflictingName, MAX_PATH - ichFixed); } } } } else { lpszLongPlate = NULL; } if (PathYetAnotherMakeUniqueName(szTemp, pszDest, pszConflictingName, lpszLongPlate)) { // // If there are any other files in the queue which are to // be copied into a subtree of pszDest, we must update them // as well. // // Put the new (renamed) target in pszDest. lstrcpy(pszDest, szTemp); // Rebuild the old dest name and put it in szTemp. // I'm going for minimum stack usage here, so I don't want more // than one MAX_PATH lying around. PathRemoveFileSpec(szTemp); PathAppend(szTemp, pszConflictingName); AddRenamePairToHDSA(szTemp, pszDest, &pcs->dth.hdsaRenamePairs); return TRUE; } return FALSE; } // test input for "multiple" filespec // // examples: // 1 foo.bar (single non directory file) // -1 *.exe (wild card on any of the files) // n foo.bar bletch.txt (number of files) // int CountFiles(LPCTSTR pInput) { int count; for (count = 0; *pInput; pInput += lstrlen(pInput) + 1, count++) { // wild cards imply multiple files if (PathIsWild(pInput)) return -1; } return count; } #define ISDIGIT(c) ((c) >= TEXT('0') && (c) <= TEXT('9')) BOOL IsCompressedVolume(LPCTSTR pszSource, DWORD dwAttributes) { int i; LPTSTR pszFileName, pszExtension; TCHAR szPath[MAX_PATH]; // must be marked system and hidden if (!IS_SYSTEM_HIDDEN(dwAttributes)) return FALSE; lstrcpy(szPath, pszSource); pszFileName = PathFindFileName(szPath); pszExtension = PathFindExtension(pszFileName); // make sure the extension is a 3 digit number if (!*pszExtension) return FALSE; // no extension for (i = 1; i < 4; i++) { if (!pszExtension[i] || !ISDIGIT(pszExtension[i])) return FALSE; } // make sure it's null terminated here if (pszExtension[4]) return FALSE; // now knock off the extension and make sure the stem matches *pszExtension = 0; if (lstrcmpi(pszFileName, TEXT("DRVSPACE")) && lstrcmpi(pszFileName, TEXT("DBLSPACE"))) { return FALSE; } // make sure it's in the root PathRemoveFileSpec(szPath); if (!PathIsRoot(szPath)) { return FALSE; } return TRUE; // passed all tests! } void _DeferMoveDlgItem(HDWP hdwp, HWND hDlg, int nItem, int x, int y) { RECT rc; HWND hwnd = GetDlgItem(hDlg, nItem); GetClientRect(hwnd, &rc); MapWindowPoints(hwnd, hDlg, (LPPOINT) &rc, 2); DeferWindowPos(hdwp, hwnd, 0, rc.left + x, rc.top + y, 0, 0, SWP_NOZORDER | SWP_NOSIZE | SWP_SHOWWINDOW | SWP_NOACTIVATE); } void _RecalcWindowHeight(HWND hWnd, LPTSTR lpszText) { HDC hdc = GetDC(hWnd); RECT rc; HWND hwndText = GetDlgItem(hWnd,IDC_MBC_TEXT); HDWP hdwp; int iHeightDelta, cx; // Get the starting rect of the text area (for the width) GetClientRect(hwndText, &rc); MapWindowPoints(hwndText, hWnd, (LPPOINT) &rc, 2); // Calc how high the static text area needs to be, given the above width iHeightDelta = RECTHEIGHT(rc); cx = RECTWIDTH(rc); DrawText(hdc, lpszText, -1, &rc, DT_CALCRECT | DT_WORDBREAK | DT_LEFT | DT_INTERNAL | DT_EDITCONTROL); iHeightDelta = RECTHEIGHT(rc) - iHeightDelta; cx = RECTWIDTH(rc) - cx; // Should only change for really long words w/o spaces if (cx < 0) cx = 0; ReleaseDC(hWnd, hdc); hdwp = BeginDeferWindowPos(4); if (hdwp) { hdwp = DeferWindowPos(hdwp, hwndText, 0, rc.left, rc.top, RECTWIDTH(rc), RECTHEIGHT(rc), SWP_NOZORDER | SWP_NOACTIVATE); if (hdwp) { _DeferMoveDlgItem(hdwp, hWnd, IDC_MESSAGEBOXCHECKEX, 0, iHeightDelta); _DeferMoveDlgItem(hdwp, hWnd, IDYES, cx, iHeightDelta); _DeferMoveDlgItem(hdwp, hWnd, IDNO, cx, iHeightDelta); EndDeferWindowPos(hdwp); } } GetWindowRect(hWnd, &rc); SetWindowPos(hWnd, 0, rc.left - (cx/2), rc.top - (iHeightDelta/2), RECTWIDTH(rc)+cx, RECTHEIGHT(rc)+iHeightDelta, SWP_NOZORDER | SWP_NOACTIVATE); return; } BOOL_PTR CALLBACK RenameMsgBoxCheckDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) { switch (uMsg) { // we only handle the WM_INITDIALOG so that we can resize the dialog // approprately and to set the default button to IDNO case WM_INITDIALOG: { HWND hwndNO = GetDlgItem(hDlg, IDNO); _RecalcWindowHeight(hDlg, (LPTSTR)lParam); SetDlgItemText(hDlg,IDC_MBC_TEXT,(LPTSTR)lParam); SendMessage(hDlg, DM_SETDEFID, IDNO, 0); SetFocus(hwndNO); return FALSE; // we set the focus, so return false } } // didnt handle this message return FALSE; } int ConfirmRenameOfConnectedItem(COPY_STATE *pcs, WIN32_FIND_DATA *pfd, LPTSTR szSource) { int result = IDYES; //For non-connected elements, the default is IDYES! LPTSTR pszMessage; LPTSTR lpConnectedItem, lpConnectOrigin; LPTSTR lpStringID; //Check if this item being renamed has a connected item. if (DTNIsConnectOrigin(pcs->dth.pdtnCurrent)) { //Yes! It has a connected element! Form the strings to create the confirmation dialog! //Get the name of the connected element lpConnectedItem = PathFindFileName(pcs->dth.pdtnCurrent->pdtnConnected->szName); lpConnectOrigin = PathFindFileName(pcs->dth.pFrom); // Mark the connected item as dummy as this will never get renamed. // (Note that this connected node could be a folder. It is still OK to mark it as // dummy because for rename operation, a folder is treated just like a file in // DTGotoNextNode()). pcs->dth.pdtnCurrent->pdtnConnected->fDummy = TRUE; if (pfd && (pfd->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) lpStringID = MAKEINTRESOURCE(IDS_HTML_FOLDER_RENAME); else lpStringID = MAKEINTRESOURCE(IDS_HTML_FILE_RENAME); //Load the confirmation message and format it! pszMessage = ShellConstructMessageString(HINST_THISDLL, lpStringID, lpConnectedItem, lpConnectOrigin); if (pszMessage) { //Get the confirmation from the end-user; result = SHMessageBoxCheckEx(pcs->hwndDlgParent, HINST_THISDLL, MAKEINTRESOURCE(DLG_RENAME_MESSAGEBOXCHECK), RenameMsgBoxCheckDlgProc, (void *)pszMessage, IDYES, REG_VAL_GENERAL_RENAMEHTMLFILE); //It is possible we get IDCANCEL if the "X" in the caption is clicked to clost // the dialog. The following code makes sure we get one of the return code that we want. if ((result != IDYES) && (result != IDNO)) result = IDNO; SHFree(pszMessage); } else result = IDNO; //For connected elements, the default is "Don't rename"; } else { if (DTNIsConnected(pcs->dth.pdtnCurrent)) result = IDNO; //Connected elements, do not get renamed. } return result; } int AllConfirmations(COPY_STATE *pcs, WIN32_FIND_DATA *pfd, UINT oper, UINT wFunc, LPTSTR szSource, LPTSTR szDest, BOOL bTimeToUpdate, WIN32_FIND_DATA *pfdDest, LPINT lpret) { int result = IDYES; LPTSTR p; LPTSTR pszStatusDest = NULL; CONFIRM_FLAG fConfirm; WIN32_FIND_DATA *pfdUse1 = NULL; WIN32_FIND_DATA *pfdUse2; BOOL fSetProgress = FALSE; BOOL fShowConfirm = FALSE; switch (oper | wFunc) { case OPER_ENTERDIR | FO_MOVE: if (PathIsSameRoot(szSource, szDest)) { fConfirm = CONFIRM_MOVE_FOLDER; pfdUse1 = pfd; pfdUse2 = pfdDest; fShowConfirm = TRUE; } break; case OPER_ENTERDIR | FO_DELETE: // Confirm removal of directory on this pass. The directories // are actually removed on the OPER_LEAVEDIR pass if (DTNIsRootNode(pcs->dth.pdtnCurrent)) fSetProgress = TRUE; if (!PathIsRoot(szSource)) { fShowConfirm = TRUE; pfdUse2 = pfd; fConfirm = CONFIRM_DELETE_FOLDER; szDest = NULL; } break; case OPER_DOFILE | FO_RENAME: // pszStatusDest = szDest; fSetProgress = TRUE; p = PathFindFileName(szSource); if (!IntlStrEqNI(szSource, szDest, (int)(p - szSource))) { result = DE_DIFFDIR; } else { if (pfd && (pfd->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) fConfirm = CONFIRM_RENAME_FOLDER; else fConfirm = CONFIRM_RENAME_FILE; if (PathIsRoot(szSource) || (PathIsRoot(szDest))) { result = DE_ROOTDIR | ERRORONDEST; } else { // We need to bring up a special confirmation dialog if this file/folder being // renamed has a connected element (if "foo.htm" or "foo files" is renamed that // will break the links). result = ConfirmRenameOfConnectedItem(pcs, pfd, szSource); if (result != IDNO) { fShowConfirm = TRUE; pfdUse2 = pfdDest; pfdUse1 = pfd; } } } break; case OPER_DOFILE | FO_MOVE: fSetProgress = TRUE; pszStatusDest = szDest; if (PathIsRoot(szSource)) { result = DE_ROOTDIR; } else if (PathIsRoot(szDest)) { result = DE_ROOTDIR | ERRORONDEST; } else { fConfirm = CONFIRM_MOVE_FILE; fShowConfirm = TRUE; pfdUse2 = pfdDest; pfdUse1 = pfd; } break; case OPER_DOFILE | FO_DELETE: fSetProgress = TRUE; if (IsCompressedVolume(szSource, pfd->dwFileAttributes)) { CopyError(pcs, szSource, szDest, DE_COMPRESSEDVOLUME, wFunc, oper); result = IDNO; } else { fShowConfirm = TRUE; szDest = NULL; pfdUse2 = pfd; fConfirm = CONFIRM_DELETE_FILE; } break; } if (fShowConfirm) { result = CachedConfirmFileOp(pcs->hwndDlgParent, pcs, &pcs->cd, pcs->nSourceFiles, !DTNIsRootNode(pcs->dth.pdtnCurrent), fConfirm, szSource, pfdUse1, szDest, pfdUse2, NULL); } if (oper == OPER_DOFILE || oper == OPER_ENTERDIR) { if ((wFunc == FO_MOVE) || (wFunc == FO_COPY)) { if ((result != IDNO) && (result != IDCANCEL)) { LPTSTR pszDataToBeLost; WCHAR wszDestDir[MAX_PATH]; BOOL bNoStreamLossThisDir = FALSE; lstrcpy(wszDestDir, szDest); PathRemoveFileSpec(wszDestDir); // Files with multiple streams will suffer stream loss on a downlevel // copy, but CopyFile special-cases native structure storage. pszDataToBeLost = GetDownlevelCopyDataLossText(szSource, wszDestDir, (oper == OPER_ENTERDIR), &bNoStreamLossThisDir); if (pszDataToBeLost) { fConfirm = CONFIRM_STREAMLOSS; pfdUse2 = pfd; result = CachedConfirmFileOp(pcs->hwndDlgParent, pcs, &pcs->cd, pcs->nSourceFiles, !DTNIsRootNode(pcs->dth.pdtnCurrent), fConfirm, szSource, pfdUse1, szDest, pfdUse2, pszDataToBeLost); LocalFree(pszDataToBeLost); } else if (bNoStreamLossThisDir) { // pcs->bStreamLossPossible = FALSE; } } } } // We only really care about OPER_ENTERDIR when deleting and // OPER_DOFILE when renaming, but I guess the hook will figure it out if ((result == IDYES) && ISDIRFINDDATA(*pfd) && (oper==OPER_ENTERDIR || oper==OPER_DOFILE)) { result = CallFileCopyHooks(pcs->hwndDlgParent, wFunc, pcs->fFlags, szSource, pfd->dwFileAttributes, szDest, pfdDest->dwFileAttributes); } if ((result != IDCANCEL) && (result != IDNO) && fSetProgress && bTimeToUpdate) SetProgressText(pcs, szSource, pszStatusDest); return result; } // return TRUE if they're the same file // assumes that given two file specs, the short name will // be identical (except case) BOOL SameFile(LPTSTR pszSource, LPTSTR pszDest) { TCHAR szShortSrc[MAX_PATH]; if (GetShortPathName(pszSource, szShortSrc, ARRAYSIZE(szShortSrc))) { TCHAR szShortDest[MAX_PATH]; if (GetShortPathName(pszDest, szShortDest, ARRAYSIZE(szShortDest))) return !lstrcmpi(szShortSrc, szShortDest); } return FALSE; } // make sure we aren't operating on the current dir to avoid // ERROR_CURRENT_DIRECTORY kinda errors void AvoidCurrentDirectory(LPCTSTR p) { TCHAR szTemp[MAX_PATH]; GetCurrentDirectory(ARRAYSIZE(szTemp), szTemp); if (lstrcmpi(szTemp, p) == 0) { DebugMsg(TF_DEBUGCOPY, TEXT("operating on current dir(%s), cd .."), p); PathRemoveFileSpec(szTemp); SetCurrentDirectory(szTemp); } } // this resolves short/long name collisions such as moving // "NewFolde" onto a dir with "New Folder" whose short name is "NEWFOLDE" // // we resolve this by renaming "New Folder" to a unique short name (like TMP1) // // making a temporary file of name "NEWFOLDE" // // renaming TMP1 back to "New Folder" (at which point it will have a new short // name like "NEWFOL~1" // PERF: it'd be faster if we didn't make the temporary file, but that // would require that we rename the file back to the long name at the // end of the operation.. which would mean we'd need to queue them all up.. // too much for right now. BOOL ResolveShortNameCollisions(LPCTSTR lpszDest, WIN32_FIND_DATA *pfd) { BOOL fRet = FALSE; // first verify that we're in the name collision. // we are if lpszDest is the same as the pfd's short name which is different // than it's long name. if (!lstrcmpi(PathFindFileName(lpszDest), pfd->cAlternateFileName) && lstrcmpi(pfd->cAlternateFileName, pfd->cFileName)) { // yes... do the renaming TCHAR szTemp[MAX_PATH]; TCHAR szLongName[MAX_PATH]; lstrcpy(szTemp, lpszDest); PathRemoveFileSpec(szTemp); // build the original long name lstrcpy(szLongName, szTemp); PathAppend(szLongName, pfd->cFileName); GetTempFileName(szTemp, c_szNULL, 1, szTemp); DebugMsg(TF_DEBUGCOPY, TEXT("Got %s as a temp file"), szTemp); // rename "New Folder" to "tmp1" if (Win32MoveFile(szLongName, szTemp, ISDIRFINDDATA(*pfd))) { // make a temporary "NewFolde" fRet = CreateWriteCloseFile(NULL, lpszDest, NULL, 0); ASSERT(fRet); // move it back... if (!Win32MoveFile(szTemp, szLongName, ISDIRFINDDATA(*pfd))) { // // Can't move it back, so delete the empty dir and then // move it back. Return FALSE to denote failure. // DeleteFile(lpszDest); Win32MoveFile(szTemp, szLongName, ISDIRFINDDATA(*pfd)); fRet = FALSE; } else { // send this out because we could have confused views // with this swapping files around... by the time they get the first // move file notification, the temp file is likely gone // so they could blow that off.. which would mess up the rest of this. SHChangeNotify(SHCNE_UPDATEITEM, SHCNF_PATH, szLongName, NULL); // // We've now created an empty dir entry of this name type. // Win32DeleteFile(lpszDest); } DebugMsg(TF_DEBUGCOPY, TEXT("ResolveShortNameCollision: %s = original, %s = destination,\n %s = temp file, %d = return"), szLongName, lpszDest, szTemp, fRet); } } return fRet; } typedef struct { LPTSTR szFilename; int iResult; } RENAMEEXEMPTIONINFO; RENAMEEXEMPTIONINFO g_rgExemptions[] = { { TEXT("thumbs.db"), IDYES } }; // return values. // // IDCANCEL = bail out of all operations // IDNO = skip this one // IDRETRY = try operation again // IDUNKNOWN = this (collision) is not the problem #define IDUNKNOWN IDOK int CheckForRenameCollision(COPY_STATE *pcs, UINT oper, LPTSTR pszSource, LPTSTR pszDest, WIN32_FIND_DATA *pfdDest, WIN32_FIND_DATA* pfd) { int iRet = IDUNKNOWN; ASSERT((pcs->lpfo->wFunc != FO_DELETE) && (oper != OPER_LEAVEDIR)); /* Check to see if we are overwriting an existing file or directory. If so, better confirm */ if ((oper == OPER_DOFILE) || ((oper == OPER_ENTERDIR) && (pcs->fFlags & FOF_RENAMEONCOLLISION))) { HANDLE hfindT; // REVIEW this slows things down checking for the dest file if ((hfindT = FindFirstFile(pszDest, pfdDest)) != INVALID_HANDLE_VALUE) { FindClose(hfindT); iRet = IDCANCEL; if (pcs->lpfo->wFunc != FO_RENAME || !SameFile(pszSource, pszDest)) { if (!ResolveShortNameCollisions(pszDest, pfdDest)) { if (pcs->fFlags & FOF_RENAMEONCOLLISION) { // The client wants us to generate a new name for the // source file to avoid a collision at the destination // dir. Must also update the current queue and the // copy root. _HandleRename(pszSource, pszDest, pcs->fFlags, pcs); iRet = IDRETRY; } else { int result = IDRETRY; if (pcs->lpfo->wFunc == FO_RENAME) { return ERROR_ALREADY_EXISTS; } // Is this a super-hidden file we don't want to prompt the // user regarding? if (IS_SYSTEM_HIDDEN(pfd->dwFileAttributes) && IS_SYSTEM_HIDDEN(pfdDest->dwFileAttributes) && !ShowSuperHidden()) { int cExempt = 0; for (; cExempt < ARRAYSIZE(g_rgExemptions); cExempt++) { if (0 == StrCmpI(g_rgExemptions[cExempt].szFilename, PathFindFileName(pszSource))) { result = g_rgExemptions[cExempt].iResult; break; } } } // REVIEW, if the destination file we are copying over // is actually a directory we are doomed. we can // try to remove the dir but that will fail if there // are files there. we probably need a special error message // for this case. if (result == IDRETRY) { result = CachedConfirmFileOp(pcs->hwndDlgParent, pcs, &pcs->cd, pcs->nSourceFiles, !DTNIsRootNode(pcs->dth.pdtnCurrent), CONFIRM_REPLACE_FILE, pszSource, pfd, pszDest, pfdDest, NULL); } switch (result) { case IDYES: if ((pcs->lpfo->wFunc == FO_MOVE) && (PathIsSameRoot(pszSource, pszDest))) { int ret; // For FO_MOVE we need to delete the // destination first. Do that now. // FEATURE this replace options should be undable ret = Win32DeleteFile(pszDest) ? 0 : GetLastError(); if (ret) { ret |= ERRORONDEST; result = ret; } } if (pcs->lpua) FOUndo_Release(pcs->lpua); iRet = IDRETRY; break; case IDNO: case IDCANCEL: pcs->lpfo->fAnyOperationsAborted = TRUE; iRet = result; break; default: iRet = result; break; } } } else { iRet = IDRETRY; } } } } return iRet; } int LeaveDir_Delete(COPY_STATE *pcs, LPTSTR pszSource) { int ret; if (PathIsRoot(pszSource)) return 0; AvoidCurrentDirectory(pszSource); // We already confirmed the delete at MKDIR time, so attempt // to delete the directory ret = Win32RemoveDirectory(pszSource) ? 0 : GetLastError(); if (!ret) { FOUndo_FileReallyDeleted(pszSource); } return ret; } int EnterDir_Copy(COPY_STATE* pcs, LPTSTR pszSource, LPTSTR pszDest, WIN32_FIND_DATA *pfd, WIN32_FIND_DATA * pfdDest, BOOL fRenameTried) { int ret; int result; BOOL fSetDestAttributes = FALSE; DWORD dwDesiredAttributes = pfd->dwFileAttributes; // Whenever we enter a directory, we need to reset the bStreamLossPossible flag, // since we could have stepped out from an NTFS->NTFS to NTFS->FAT scenario via // a junction point pcs->bStreamLossPossible = TRUE; // SHMoveFile restricts the based on path length. To be consistent, we make the same // restricton on Copy directory also. if (IsDirPathTooLongForCreateDir(pszDest)) { ret = ERROR_FILENAME_EXCED_RANGE; } else { BOOL fWithoutTemplate = FALSE; if (pcs->fLostEncryptOk) { dwDesiredAttributes &= ~FILE_ATTRIBUTE_ENCRYPTED; // Pretend its not encrypted fSetDestAttributes = TRUE; fWithoutTemplate = TRUE; } if (pfd->dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) { if (!(pcs->fFlags & FOF_NORECURSEREPARSE)) { dwDesiredAttributes &= ~FILE_ATTRIBUTE_REPARSE_POINT; // Pretend like its just a folder fSetDestAttributes = TRUE; fWithoutTemplate = TRUE; } } if (fWithoutTemplate) { ret = (CreateDirectory(pszDest, NULL) ? 0 : GetLastError()); // Since we didn't call CreateDirectoryEx, we need to manually // propogate the attributes to the dest directory. fSetDestAttributes = TRUE; } else { ret = (CreateDirectoryEx(pszSource, pszDest, NULL) ? 0 : GetLastError()); } if (ret == ERROR_SUCCESS) { SHChangeNotify(SHCNE_MKDIR, SHCNF_PATH, pszDest, NULL); } } switch (ret) { case 0: // successful folder creation (or it already exists) // propogate the attributes (if there are any) if (pcs->fFromCDRom) { // Don't propogate read-only from CDRoms dwDesiredAttributes &= ~FILE_ATTRIBUTE_READONLY; fSetDestAttributes = TRUE; } if (fSetDestAttributes) { // Avoid setting FILE_ATTRIBUTE_DIRECTORY, since its // already a directory, and is less error prone. SetFileAttributes(pszDest, dwDesiredAttributes); } // we should set the security ACLs here on NT // we ignore any kind of failure though, is that OK? // CopyFileSecurity(pszSource, pszDest); // add to the undo atom if (pcs->lpua) { if (DTNIsRootNode(pcs->dth.pdtnCurrent) && !DTNIsConnected(pcs->dth.pdtnCurrent)) FOUndo_AddInfo(pcs->lpua, pszSource, pszDest, 0); } break; case ERROR_ALREADY_EXISTS: case ERROR_DISK_FULL: case ERROR_ACCESS_DENIED: case ERROR_INVALID_NAME: { DWORD dwFileAttributes; if (!fRenameTried) { int result = CheckForRenameCollision(pcs, OPER_ENTERDIR, pszSource, pszDest, pfdDest, pfd); switch (result) { case IDUNKNOWN: break; case IDRETRY: return EnterDir_Copy(pcs, pszSource, pszDest, pfd, pfdDest, TRUE); case IDCANCEL: pcs->bAbort = TRUE; return result; case IDNO: return result; default: return result; } } dwFileAttributes = GetFileAttributes(pszDest); if (dwFileAttributes == (DWORD)-1) { // The dir does not exist, so it looks like a problem // with a read-only drive or disk full if (ret == ERROR_DISK_FULL && IsRemovableDrive(DRIVEID(pszDest)) && !PathIsSameRoot(pszDest, pszSource)) { ret = CopyMoveRetry(pcs, pszDest, ERROR_DISK_FULL, NULL); if (!ret) { return EnterDir_Copy(pcs, pszSource, pszDest, pfd, pfdDest, fRenameTried); } else { pcs->bAbort = TRUE; return ret; } } // Maybe its an encrypted folder thats losing its encryption? if (pfd->dwFileAttributes & FILE_ATTRIBUTE_ENCRYPTED) { int result; result = CachedConfirmFileOp(pcs->hwndDlgParent, pcs, &pcs->cd, pcs->nSourceFiles, FALSE, CONFIRM_LOST_ENCRYPT_FOLDER, pszSource, pfd, pszDest, NULL, NULL); switch (result) { case IDYES: pcs->fLostEncryptOk = TRUE; return EnterDir_Copy(pcs, pszSource, pszDest, pfd, pfdDest, fRenameTried); case IDNO: case IDCANCEL: pcs->bAbort = TRUE; ret = result; break; default: ret = result; break; } return ret; } CopyError(pcs, pszSource, pszDest, ERROR_ACCESS_DENIED | ERRORONDEST, FO_COPY, OPER_DOFILE); pcs->bAbort = TRUE; return ret; } if (!(dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) { // A file with this name already exists CopyError(pcs, pszSource, pszDest, DE_FLDDESTISFILE | ERRORONDEST, FO_COPY, OPER_DOFILE); pcs->bAbort = TRUE; return ret; } result = CachedConfirmFileOp(pcs->hwndDlgParent, pcs, &pcs->cd, pcs->nSourceFiles, !DTNIsRootNode(pcs->dth.pdtnCurrent), CONFIRM_REPLACE_FOLDER, pszSource, pfd, pszDest, pfdDest, NULL); switch (result) { case IDYES: ret = 0; // convert to no error pcs->fMerge = TRUE; if (pcs->lpua) FOUndo_Release(pcs->lpua); break; case IDNO: DTAbortCurrentNode(&pcs->dth); // so we don't recurse down this folder pcs->lpfo->fAnyOperationsAborted = TRUE; ret = IDNO; // Don't put up error message on this one... // Since the end-user cancelled the copy operation on this folder, we can cancel the // copy operation on the corresponding connected file too! if (DTNIsConnectOrigin(pcs->dth.pdtnCurrent)) pcs->dth.pdtnCurrent->pdtnConnected->fDummy = TRUE; break; case IDCANCEL: pcs->lpfo->fAnyOperationsAborted = TRUE; pcs->bAbort = TRUE; // Since the end-user cancelled the copy operation on this folder, we can cancel the // copy operation on the corresponding connected file too! if (DTNIsConnectOrigin(pcs->dth.pdtnCurrent)) pcs->dth.pdtnCurrent->pdtnConnected->fDummy = TRUE; break; default: result = ret; break; } break; } case ERROR_CANCELLED: pcs->bAbort = TRUE; break; case ERROR_FILENAME_EXCED_RANGE: DTAbortCurrentNode(&pcs->dth); // so we don't recurse down this folder break; default: // ret != 0 (dos error code) ret |= ERRORONDEST; break; } return ret; } int EnterDir_Move(COPY_STATE* pcs, LPTSTR pszSource, LPTSTR pszDest, WIN32_FIND_DATA *pfd, WIN32_FIND_DATA * pfdDest, BOOL fRenameTried) { int ret; // Whenever we enter a directory, we need to reset the bStreamLossPossible flag, // since we could have stepped out from an NTFS->NTFS to NTFS->FAT scenario via // a junction point pcs->bStreamLossPossible = TRUE; // if these are in the same drive, try using MoveFile on it. // if that fails then fail through to the copy if (PathIsSameRoot(pszSource, pszDest)) { AvoidCurrentDirectory(pszSource); ret = Win32MoveFile(pszSource, pszDest, TRUE) ? 0 : GetLastError(); switch (ret) { case 0: DebugMsg(TF_DEBUGCOPY, TEXT("Move Folder worked!")); DTAbortCurrentNode(&pcs->dth); // so we don't recurse down this folder // add to the undo atom if (pcs->lpua && DTNIsRootNode(pcs->dth.pdtnCurrent) && !DTNIsConnected(pcs->dth.pdtnCurrent)) FOUndo_AddInfo(pcs->lpua, pszSource, pszDest, 0); if (!SHRestricted(REST_NOENCRYPTONMOVE) && !(pfd->dwFileAttributes & FILE_ATTRIBUTE_ENCRYPTED)) { TCHAR szDestDir[MAX_PATH]; DWORD dwAttribs; StrCpyN(szDestDir, pszDest, ARRAYSIZE(szDestDir)); PathRemoveFileSpec(szDestDir); dwAttribs = GetFileAttributes(szDestDir); if ((dwAttribs != -1) && (dwAttribs & FILE_ATTRIBUTE_ENCRYPTED)) { // Encrypt the directory by pretending we are the // property sheet properties->Advanced. Fill in the fake // information and call the helper. FILEPROPSHEETPAGE fpsp; FOLDERCONTENTSINFO fci; fci.fIsCompressionAvailable = FALSE; fci.fMultipleFiles = TRUE; ZeroMemory(&fpsp, SIZEOF(fpsp)); fpsp.hDlg = GetWindow(pcs->hwndDlgParent, GW_CHILD); fpsp.fRecursive = TRUE; fpsp.fIsDirectory = TRUE; fpsp.pfci = &fci; // As long as asInitial.* == asCurrent.* it won't be changed fpsp.asInitial.fReadOnly = BST_INDETERMINATE; fpsp.asInitial.fHidden = BST_INDETERMINATE; fpsp.asInitial.fIndex = BST_INDETERMINATE; fpsp.asInitial.fArchive = BST_INDETERMINATE; fpsp.asInitial.fCompress = BST_INDETERMINATE; fpsp.asInitial.fEncrypt = BST_UNCHECKED; // Not encrypted yet fpsp.asInitial.fRecordingEnabled = BST_INDETERMINATE; fpsp.asCurrent.fReadOnly = BST_INDETERMINATE; fpsp.asCurrent.fHidden = BST_INDETERMINATE; fpsp.asCurrent.fIndex = BST_INDETERMINATE; fpsp.asCurrent.fArchive = BST_INDETERMINATE; fpsp.asCurrent.fCompress = BST_INDETERMINATE; fpsp.asCurrent.fEncrypt = BST_CHECKED; // Now encrypt fpsp.asCurrent.fRecordingEnabled = BST_INDETERMINATE; ApplyRecursiveFolderAttribs(pszDest, &fpsp); } } // Win32MoveFile on a single-volume leaves the original ACL // intact. If necessary, pick up perms from the destination. if (pcs->fFlags & FOF_NOCOPYSECURITYATTRIBS) { ResetFileSecurity(pszDest); } return 0; case ERROR_PATH_NOT_FOUND: ret = CopyMoveRetry(pcs, pszDest, ret, NULL); if (!ret) return EnterDir_Move(pcs, pszSource, pszDest, pfd, pfdDest, fRenameTried); return ret; case ERROR_ALREADY_EXISTS: case ERROR_FILE_EXISTS: if (!fRenameTried) { int result = CheckForRenameCollision(pcs, OPER_ENTERDIR, pszSource, pszDest, pfdDest, pfd); switch (result) { case IDUNKNOWN: break; case IDRETRY: return EnterDir_Move(pcs, pszSource, pszDest, pfd, pfdDest, TRUE); case IDCANCEL: pcs->bAbort = TRUE; return result; case IDNO: return result; default: return result; } } break; case ERROR_FILENAME_EXCED_RANGE: case ERROR_ONLY_IF_CONNECTED: DTAbortCurrentNode(&pcs->dth); // so we don't recurse down this folder return ret; } } // we're going to recurse in.... if we've not enumerated the children for // this folder, set it for delayed enumeration now. if (!pcs->dth.pdtnCurrent->pdtnChild) { pcs->dth.pdtnCurrent->pdtnChild = DTN_DELAYED; } if (DTNIsConnected(pcs->dth.pdtnCurrent) && !PathFileExists(pszSource)) { // This can happen if the end-user moved "foo.htm" AND "foo files" together. // As a result the connected element "foo files" has already been moved. DTAbortCurrentNode(&pcs->dth); // so we don't recurse down this folder return(0); //No error! This connected element seems to have been moved. } return EnterDir_Copy(pcs, pszSource, pszDest, pfd, pfdDest, FALSE); } int EnterDir_Delete(COPY_STATE * pcs, WIN32_FIND_DATA *pfdSrc, LPTSTR pszSource, HDPA *phdpaDeletedFiles) { int iRet = 0; if (!DTNIsRootNode(pcs->dth.pdtnCurrent)) { // we are not at a root node... when doing a delete this can only mean // that we are really nuking the folder. we dont need to enum children // because we already did a non-lazy enum at the root node. return iRet; } else if (!pcs->lpua) { NukeFolder: // we are at a root node and we have no undo atom, this means that we // really want to nuke this whole dir, so enum the children DTForceEnumChildren(&pcs->dth); // do a non-layz enum of the children to prevent the progress // bar from going back and forth as we recurse down into any subdirs. DTEnumChildren(&pcs->dth, pcs, TRUE, DTF_FILES_AND_FOLDERS); return iRet; } if (DeleteFileBB(pszSource, &iRet, pcs, TRUE, pfdSrc, phdpaDeletedFiles)) { DTAbortCurrentNode(&pcs->dth); // so we don't recurse down this folder } else { // DeleteFileBB failed, check iRet to find out why switch (iRet) { case BBDELETE_PATH_TOO_LONG: case BBDELETE_SIZE_TOO_BIG: case BBDELETE_NUKE_OFFLINE: { // This is the case where the folder is too big to fit in the Recycle Bin or the folder // is offline. We have no choice but to really nuke it, but we warn the user first since // they may have thought that it was being sent to the recycle bin. int result = CachedConfirmFileOp(pcs->hwndDlgParent, pcs, &pcs->cd, pcs->nSourceFiles, FALSE, (iRet == BBDELETE_SIZE_TOO_BIG) ? CONFIRM_WONT_RECYCLE_FOLDER : ((iRet == BBDELETE_NUKE_OFFLINE) ? CONFIRM_WONT_RECYCLE_OFFLINE : CONFIRM_PATH_TOO_LONG), pszSource, pfdSrc, NULL, NULL, NULL); switch (result) { case IDNO: // user said "please dont really nuke the file" DTAbortCurrentNode(&pcs->dth); // so we don't recurse down this folder pcs->lpfo->fAnyOperationsAborted = TRUE; iRet = IDNO; // Don't put up error message for this case //Because the Delete on this FOLDER is aborted, we can cancel the "Delete" // on the corresponding FILE too! if (DTNIsConnectOrigin(pcs->dth.pdtnCurrent)) { pcs->dth.pdtnCurrent->pdtnConnected->fDummy = TRUE; } break; case IDCANCEL: // user canceled the operation pcs->lpfo->fAnyOperationsAborted = TRUE; pcs->bAbort = TRUE; //Because the Delete on this FOLDER is cancelled, we can cancel the "Delete" // on the corresponding FILE too! if (DTNIsConnectOrigin(pcs->dth.pdtnCurrent)) { pcs->dth.pdtnCurrent->pdtnConnected->fDummy = TRUE; } break; case IDYES: default: // user said "please nuke the file" // assume noerror iRet = 0; // set this so the is correct progress animation is displayed if (pcs) { pcs->fFlags &= ~FOF_ALLOWUNDO; } // dont allow undo since we are really nuking it (cant bring it back...) if (pcs->lpua) { FOUndo_Release(pcs->lpua); } UpdateProgressAnimation(pcs); goto NukeFolder; break; } } break; case BBDELETE_CANNOT_DELETE: { // This is the non-deletable file case. Note: this is an NT only case, and // it could be caused by acls or the fact that the file is currently in use. // We attemt to really delete the file (which should fail) so we can generate // the proper error value DWORD dwAttributes = GetFileAttributes(pszSource); if (dwAttributes & FILE_ATTRIBUTE_DIRECTORY) { iRet = Win32RemoveDirectory(pszSource); } else { iRet = Win32DeleteFile(pszSource); } if (!iRet) { // indeed, the file/folder could not be deleted. // Get last error to find out why iRet = GetLastError(); } else { // DeleteFileBB said that it couldn't be deleted, but we just nuked it. We will // end up falling into this case when we hit things like Mounted Volumes. // As Obi-Wan would say: "You don't need to see his identification... these aren't // the droids you are looking for... He can go about his business... Move along." iRet = ERROR_SUCCESS; DTAbortCurrentNode(&pcs->dth); // so we don't recurse down this folder // dont allow undo since we reall nuked it (cant bring it back...) if (pcs->lpua) { FOUndo_Release(pcs->lpua); } } } break; case BBDELETE_FORCE_NUKE: { // This is the catch-all case. If iRet = BDETETE_FORCE_NUKE, then we just nuke the // file without warning. // return noerror so we recurse into this dir and nuke it iRet = ERROR_SUCCESS; // set this so the is correct progress animation is displayed if (pcs) { pcs->fFlags &= ~FOF_ALLOWUNDO; } // dont allow undo since we are really nuking it (cant bring it back...) if (pcs->lpua) { FOUndo_Release(pcs->lpua); } UpdateProgressAnimation(pcs); goto NukeFolder; } break; case BBDELETE_CANCELLED: { // user canceled the operation pcs->lpfo->fAnyOperationsAborted = TRUE; pcs->bAbort = TRUE; //Because the Delete on this FOLDER is cancelled, we can cancel the "Delete" // on the corresponding FILE too! if (DTNIsConnectOrigin(pcs->dth.pdtnCurrent)) { pcs->dth.pdtnCurrent->pdtnConnected->fDummy = TRUE; } } case BBDELETE_UNKNOWN_ERROR: default: { iRet = GetLastError(); ASSERT(iRet != ERROR_SUCCESS); } break; } } // DeleteFileBB return iRet; } BOOL DoFile_Win32DeleteFileWithPidl(LPCTSTR pszFile, SIMPLEPIDLCACHE *pspc) { LPITEMIDLIST pidlFile = NULL; int iRet; if (pspc) { pidlFile = SimplePidlCache_GetFilePidl(pspc, pszFile); } iRet = Win32DeleteFilePidl(pszFile, pidlFile); ILFree(pidlFile); return iRet; } int DoFile_Delete(COPY_STATE* pcs, WIN32_FIND_DATA *pfdSrc, LPTSTR pszSource, HDPA *phdpaDeletedFiles, BOOL fShouldSuspendEvents) { int iRet = 0; // if we dont have an undo atom or this isint a root node or if this is a network file // then we need to really nuke it if (!pcs->lpua || !DTNIsRootNode(pcs->dth.pdtnCurrent) || IsNetDrive(PathGetDriveNumber(pszSource))) { iRet = DoFile_Win32DeleteFileWithPidl(pszSource, fShouldSuspendEvents ? NULL : &pcs->spc) ? 0 : GetLastError(); if (!iRet) { FOUndo_FileReallyDeleted(pszSource); } } else if (!DeleteFileBB(pszSource, &iRet, pcs, FALSE, pfdSrc, phdpaDeletedFiles)) { // DeleteFileBB failed, check iRet to find out why switch (iRet) { case BBDELETE_SIZE_TOO_BIG: case BBDELETE_NUKE_OFFLINE: { // This is the case where the file is too big to fit in the Recycle Bin. We have no // choice but to really nuke it, but we warn the user first since they may have thought // that it was being sent to the recycle bin. int result = CachedConfirmFileOp(pcs->hwndDlgParent, pcs, &pcs->cd, pcs->nSourceFiles, FALSE, (iRet == BBDELETE_SIZE_TOO_BIG) ? CONFIRM_WONT_RECYCLE_FOLDER : CONFIRM_WONT_RECYCLE_OFFLINE, pszSource, pfdSrc, NULL, NULL, NULL); switch (result) { case IDNO: // user said "please dont really nuke the file" pcs->lpfo->fAnyOperationsAborted = TRUE; iRet = IDNO; // Don't put up error message for this case // WARNING: It is tempting to mark the corresponding connected folder as dummy here. // But, this will not work because currently folders (nodes with children) can not be // marked as dummy. break; case IDCANCEL: // user canceled the operation pcs->lpfo->fAnyOperationsAborted = TRUE; pcs->bAbort = TRUE; // WARNING: It is tempting to mark the corresponding connected folder as dummy here. // But, this will not work because currently folders (nodes with children) can not be // marked as dummy. break; case IDYES: default: // user said "please nuke the file" // set this so the is correct progress animation is displayed if (pcs) { pcs->fFlags &= ~FOF_ALLOWUNDO; } // dont allow undo since we are really nuking it if (pcs->lpua) { FOUndo_Release(pcs->lpua); } UpdateProgressAnimation(pcs); iRet = DoFile_Win32DeleteFileWithPidl(pszSource, &pcs->spc) ? 0 : GetLastError(); break; } } break; case BBDELETE_CANNOT_DELETE: { // This is the non-deletable file case. Note: this is an NT only case, and // it could be caused by acls or the fact that the file is currently in use. // We attemt to really delete the file (which should fail) so we can generate // the proper error value iRet = Win32DeleteFile(pszSource); if (!iRet) { // indeed, the file/folder could not be deleted. // Get last error to find out why iRet = GetLastError(); } else { // DeleteFileBB said that it couldn't be deleted, but we just nuked it. We will // end up falling into this case when we hit things like Mounted Volumes and other // reparse points that we can't "recycle". // As Obi-Wan would say: "You don't need to see his identification... these aren't // the droids you are looking for... He can go about his business... Move along." iRet = ERROR_SUCCESS; DTAbortCurrentNode(&pcs->dth); // so we don't recurse down this folder // dont allow undo since we really nuked it (cant bring it back...) if (pcs->lpua) { FOUndo_Release(pcs->lpua); } } } break; case BBDELETE_FORCE_NUKE: { // This is the catch-all case. If iRet = BDETETE_FORCE_NUKE, then we just nuke the // file without warning. // set this so the is correct progress animation is displayed if (pcs) { pcs->fFlags &= ~FOF_ALLOWUNDO; } // dont allow undo since we are going to nuke this file if (pcs->lpua) { FOUndo_Release(pcs->lpua); } UpdateProgressAnimation(pcs); iRet = DoFile_Win32DeleteFileWithPidl(pszSource, &pcs->spc) ? 0 : GetLastError(); } break; case BBDELETE_CANCELLED: { // user canceled the operation pcs->lpfo->fAnyOperationsAborted = TRUE; pcs->bAbort = TRUE; } break; case BBDELETE_UNKNOWN_ERROR: default: { iRet = GetLastError(); ASSERT(iRet != ERROR_SUCCESS); } break; } } // !DeleteFileBB return iRet; } int DoFile_Copy(COPY_STATE* pcs, LPTSTR pszSource, LPTSTR pszDest, WIN32_FIND_DATA *pfd, WIN32_FIND_DATA * pfdDest, BOOL fRenameTried) { /* Now try to copy the file. Do extra error processing only in 2 cases: 1) If a removeable drive is full let the user stick in a new disk 2) If the path doesn't exist (the user typed in and explicit path that doesn't exits) ask if we should create it for him. */ int ret = FileCopy(pcs, pszSource, pszDest, pfd, fRenameTried); if (ret == ERROR_CANCELLED) { pcs->bAbort = TRUE; return ret; } if ((ret & ~ERRORONDEST) == ERROR_FILE_EXISTS) { if (!fRenameTried) { int result = CheckForRenameCollision(pcs, OPER_DOFILE, pszSource, pszDest, pfdDest, pfd); switch (result) { case IDUNKNOWN: break; case IDRETRY: return DoFile_Copy(pcs, pszSource, pszDest, pfd, pfdDest, TRUE); case IDCANCEL: pcs->bAbort = TRUE; return result; case IDNO: return result; default: return result; } } } if ((((ret & ~ERRORONDEST) == ERROR_DISK_FULL) && IsRemovableDrive(DRIVEID(pszDest))) || ((ret & ~ERRORONDEST) == ERROR_PATH_NOT_FOUND)) { ULARGE_INTEGER ulFileSize; ulFileSize.LowPart = pfd->nFileSizeLow; ulFileSize.HighPart = pfd->nFileSizeHigh; ret = CopyMoveRetry(pcs, pszDest, ret & ~ERRORONDEST, &ulFileSize); if (!ret) { return DoFile_Copy(pcs, pszSource, pszDest, pfd, pfdDest, fRenameTried); } else { pcs->bAbort = TRUE; return ret; } } if (!ret) { // add to the undo atom // if we're doing a copy, only keep track of the highest most // level.. unless we're doing a merge sort of copy if (pcs->lpua) { if (DTNIsRootNode(pcs->dth.pdtnCurrent) && !DTNIsConnected(pcs->dth.pdtnCurrent)) FOUndo_AddInfo(pcs->lpua, pszSource, pszDest, 0); } // if we copied in a new desktop ini, send out an update event for the paretn if (!lstrcmpi(PathFindFileName(pszDest), c_szDesktopIni)) { TCHAR szDest[MAX_PATH]; lstrcpyn(szDest, pszDest, ARRAYSIZE(szDest)); PathRemoveFileSpec(szDest); SHChangeNotify(SHCNE_UPDATEITEM, SHCNF_PATH, szDest, NULL); } } return ret; } int DoFile_Move(COPY_STATE* pcs, LPTSTR pszSource, LPTSTR pszDest, WIN32_FIND_DATA *pfd, WIN32_FIND_DATA * pfdDest, BOOL fRenameTried) { int ret = 0; if (PathIsRoot(pszSource)) { return DE_ROOTDIR; } if (PathIsRoot(pszDest)) { return DE_ROOTDIR | ERRORONDEST; } AvoidCurrentDirectory(pszSource); if (PathIsSameRoot(pszSource, pszDest)) { TryAgain: ret = Win32MoveFile(pszSource, pszDest, ISDIRFINDDATA(*pfd)) ? 0 : GetLastError(); // try to create the destination if it is not there if (ret == ERROR_PATH_NOT_FOUND) { ret = CopyMoveRetry(pcs, pszDest, ret, NULL); if (!ret) { goto TryAgain; } } if (ret == ERROR_ALREADY_EXISTS) { if (!fRenameTried) { int result = CheckForRenameCollision(pcs, OPER_DOFILE, pszSource, pszDest, pfdDest, pfd); switch (result) { case IDUNKNOWN: break; case IDRETRY: fRenameTried = TRUE; goto TryAgain; case IDCANCEL: pcs->bAbort = TRUE; return result; case IDNO: return result; default: return result; } } } if ((ret == ERROR_SUCCESS) && !SHRestricted(REST_NOENCRYPTONMOVE) && !(pfd->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) && !(pfd->dwFileAttributes & FILE_ATTRIBUTE_ENCRYPTED)) { TCHAR szDestDir[MAX_PATH]; DWORD dwAttribs; // We are moving a file that is NOT encrypted. On Win2k, we need to check to see if this was a move to // an encrypted folder. If so, we automatically encrypt the file. lstrcpyn(szDestDir, pszDest, ARRAYSIZE(szDestDir)); PathRemoveFileSpec(szDestDir); dwAttribs = GetFileAttributes(szDestDir); if ((dwAttribs != -1) && (dwAttribs & FILE_ATTRIBUTE_ENCRYPTED)) { // sainity check ASSERT(dwAttribs & FILE_ATTRIBUTE_DIRECTORY); // attempt to encrypt the file if (!SHEncryptFile(pszDest, TRUE)) { int result = CachedConfirmFileOp(pcs->hwndDlgParent, pcs, &pcs->cd, pcs->nSourceFiles, FALSE, CONFIRM_FAILED_ENCRYPT, pszDest, pfd, // since we just moved it, the attibs should be the same as the src NULL, NULL, NULL); switch (result) { case IDCANCEL: // user canceled the operation pcs->lpfo->fAnyOperationsAborted = TRUE; pcs->bAbort = TRUE; break; case IDNO: // user choose to "restore" the file to its original location ret = Win32MoveFile(pszDest, pszSource, ISDIRFINDDATA(*pfd)) ? 0 : GetLastError(); case IDYES: default: // user ignored the error break; } } } } if (ret == ERROR_SUCCESS) { if (pcs->lpua && DTNIsRootNode(pcs->dth.pdtnCurrent) && !DTNIsConnected(pcs->dth.pdtnCurrent)) { // add to the undo atom FOUndo_AddInfo(pcs->lpua, pszSource, pszDest, 0); } // Win32MoveFile on a single-volume leaves the original ACL // intact. If necessary, pick up perms from the destination. if (pcs->fFlags & FOF_NOCOPYSECURITYATTRIBS) { ResetFileSecurity(pszDest); } // if we copied in a new desktop ini, send out an update event for the paretn if (!lstrcmpi(PathFindFileName(pszDest), c_szDesktopIni)) { TCHAR szDest[MAX_PATH]; lstrcpyn(szDest, pszDest, ARRAYSIZE(szDest)); PathRemoveFileSpec(szDest); SHChangeNotify(SHCNE_UPDATEITEM, SHCNF_PATH, szDest, NULL); } } } else { // we must force all copies to go through // straight so we can remove the source if (DTNIsConnected(pcs->dth.pdtnCurrent) && !PathFileExists(pszSource)) { //This can happen if "foo.htm" and "foo files" were moved by the end-user. // The connected file had already been moved and hence this is not an error! ret = 0; //No error! That file has been moved already! } else { ret = DoFile_Copy(pcs, pszSource, pszDest, pfd, pfdDest, FALSE); } } return ret; } int DoFile_Rename(COPY_STATE* pcs, LPTSTR pszSource, LPTSTR pszDest, WIN32_FIND_DATA *pfd, WIN32_FIND_DATA * pfdDest, BOOL fRenameTried) { LPTSTR p = PathFindFileName(pszSource); /* Get raw source and dest paths. Check to make sure the paths are the same */ int ret = !IntlStrEqNI(pszSource, pszDest, (int)(p - pszSource)); if (ret) { return DE_DIFFDIR; } return DoFile_Move(pcs, pszSource, pszDest, pfd, pfdDest, fRenameTried); } int MoveCopyInitPCS(COPY_STATE * pcs) { BOOL fMultiDest = FALSE; int ret = 0; LPTSTR p = NULL; TCHAR szDestPath[MAX_PATH]; pcs->nSourceFiles = CountFiles(pcs->lpfo->pFrom); // multiple source files? pcs->fProgressOk = TRUE; // skip destination processing if we are deleting files if (pcs->lpfo->wFunc != FO_DELETE) { lstrcpyn(szDestPath, pcs->lpfo->pTo, ARRAYSIZE(szDestPath)); if (!szDestPath[0]) // NULL dest is same as "." { szDestPath[0] = TEXT('.'); szDestPath[1] = 0; } if (PathIsInvalid(szDestPath)) { CopyError(pcs, c_szNULL, c_szNULL, DE_INVALIDFILES | ERRORONDEST, pcs->lpfo->wFunc, 0); return ERROR_ACCESS_DENIED; } if (pcs->lpfo->wFunc == FO_RENAME) { // don't let them rename multiple files to one single file if ((pcs->nSourceFiles != 1) && !PathIsWild(szDestPath)) { CopyError(pcs, c_szNULL, c_szNULL, DE_MANYSRC1DEST, pcs->lpfo->wFunc, 0); return DE_MANYSRC1DEST; } fMultiDest = TRUE; } else // FO_COPY or FO_MOVE at this point { fMultiDest = ((pcs->fFlags & FOF_MULTIDESTFILES) && (pcs->nSourceFiles == CountFiles(pcs->lpfo->pTo))); if (!fMultiDest) { // for backwards compat. // copy c:\foo.bar c:\folder\foo.bar means // multi dest if foo.bar doesn't exist. // Hack if it is a root we special case this for the offline // floppy case... if (pcs->nSourceFiles == 1 && !PathIsRoot(szDestPath) && !PathIsDirectory(szDestPath)) { fMultiDest = TRUE; } } } } pcs->dth.fMultiDest = fMultiDest; return 0; } DWORD g_dwStopWatchMode = 0xffffffff; // Shell performance mode // actually this does move/copy/rename/delete int MoveCopyDriver(COPY_STATE *pcs) { int ret; WIN32_FIND_DATA fdSrc; WIN32_FIND_DATA fdDest; HDPA hdpaDeletedFiles = NULL; LPSHFILEOPSTRUCT lpfo = pcs->lpfo; TCHAR szText[28]; BOOL bInitialAllowUndo = FALSE; DWORD dwLastUpdateTime = 0; BOOL fShouldSuspendEvents = FALSE; HANDLE hEventRunning; if (g_dwStopWatchMode) { if (g_dwStopWatchMode == 0xffffffff) { g_dwStopWatchMode = StopWatchMode(); // Since the stopwatch funcs live in shdocvw, delay this call so we don't load shdocvw until we need to } if (g_dwStopWatchMode) { lstrcpy((LPTSTR)szText, TEXT("Shell ")); switch (lpfo->wFunc) { case FO_COPY: lstrcat((LPTSTR)szText, TEXT("Copy ")); break; case FO_MOVE: lstrcat((LPTSTR)szText, TEXT("Move ")); break; case FO_DELETE: lstrcat((LPTSTR)szText, TEXT("Delete")); break; case FO_RENAME: lstrcat((LPTSTR)szText, TEXT("Rename")); break; default: lstrcat((LPTSTR)szText, TEXT("Copy? ")); break; } lstrcat((LPTSTR)szText, TEXT(": Start")); StopWatch_Start(SWID_COPY, (LPCTSTR)szText, SPMODE_SHELL | SPMODE_DEBUGOUT); } } // start by assuming an error. Non-zero means an error has occured. If we don't // start with this assumption then we will return success if MoveCopyInitPCS fails. ret = ERROR_GEN_FAILURE; if (!ValidFilenames(lpfo->pFrom)) { CopyError(pcs, c_szNULL, c_szNULL, DE_INVALIDFILES, lpfo->wFunc, 0); return ERROR_ACCESS_DENIED; } StartCopyEngine(&hEventRunning); // Check the pcs destination directory to make sure it is valid for the given source file list if (MoveCopyInitPCS(pcs)) { goto ExitLoop; // Destination is invalid so we bail out } // Build a tree where each node is a source file, a dest file, and an operation to perform ret = DTBuild(pcs); if (ret) { goto ShowMessageBox; } // Speed optimization: for a delete, sending all FSNotifies really bogs down the system, // so we skip it and rely on the file system notifies. if ((lpfo->wFunc == FO_DELETE || lpfo->wFunc == FO_MOVE) && pcs->dth.dtAll.dwFiles > 100) { // Only suspend notifies for local moves if (lpfo->wFunc == FO_MOVE) { if (lpfo->pTo) { int idDrive = PathGetDriveNumber(lpfo->pFrom); if (idDrive == PathGetDriveNumber(lpfo->pTo) && !IsNetDrive(idDrive)) { fShouldSuspendEvents = TRUE; } } } else { fShouldSuspendEvents = TRUE; } } if (fShouldSuspendEvents) { // SuspendSHNotify can fail if another thread is using it. Only one thread at a time can suspend notify. fShouldSuspendEvents = SuspendSHNotify(); } // save off the initial state of the allowundo flag if (pcs->fFlags & FOF_ALLOWUNDO) { bInitialAllowUndo = TRUE; } // When first starting, we assume that stream loss is possible until we prove // otherwise for the current directory. This gets reset to true each time we // enter a new dir via EnterDir_Move or EnterDir_Copy pcs->bStreamLossPossible = TRUE; for (;;) { BOOL bUpdateAnimation = FALSE; int result; DWORD dwTickCount; BOOL bTimeToUpdate = FALSE; pcs->dth.oper = DTGoToNextNode(&pcs->dth,pcs); dwTickCount = GetTickCount(); if ((dwTickCount - dwLastUpdateTime) > 10) { dwLastUpdateTime = dwTickCount; bTimeToUpdate = TRUE; } if ((pcs->dth.oper & OPER_MASK) == OPER_ERROR) { CopyError(pcs, pcs->dth.szSrcPath, pcs->dth.szDestPath, LOBYTE(pcs->dth.oper), pcs->lpfo->wFunc, OPER_DOFILE); // If the directory is copied but a file inside that directory could not // be copied because of long filename, check to see if this is // a connected element. If so, invoke undo, sothat we getback the orginal html file // in the same place as the associated folder. if ((pcs->dth.oper == (OPER_ERROR | DE_INVALIDFILES)) && (DTNIsConnected(pcs->dth.pdtnCurrent))) { if (pcs->lpua) { pcs->lpua->foFlags |= FOF_NOCONFIRMATION; FOUndo_Invoke(pcs->lpua); pcs->lpua = NULL; } } break; } if (!pcs->dth.oper || pcs->bAbort) // all done? { break; } if (DTNIsRootNode(pcs->dth.pdtnCurrent) && (pcs->dth.oper != OPER_LEAVEDIR)) { int iDrive; // check to see if we switched between doing a move to // recycle bin and a true delete (this would happen when // there was an object that was too big for the recycle bin) if (!(pcs->fFlags & FOF_ALLOWUNDO) && bInitialAllowUndo) { // reset the allowundo flag since we have a new root node, and we // want to attempt to send it to the recycle bin pcs->fFlags |= FOF_ALLOWUNDO; // we delay to update the progress animation till we are basically // done, which allows us to keep the progress and animation in sync bUpdateAnimation = TRUE; } pcs->fMerge = FALSE; pcs->fFromCDRom = FALSE; // Check source for being a CDRom iDrive = PathGetDriveNumber(pcs->dth.szSrcPath); if (-1 != iDrive) { TCHAR szDrive[4]; if (DRIVE_CDROM == GetDriveType(PathBuildRoot(szDrive, iDrive))) { pcs->fFromCDRom = TRUE; } } } DTGetWin32FindData(pcs->dth.pdtnCurrent, &fdSrc); fdDest.dwFileAttributes = 0; DebugMsg(TF_DEBUGCOPY, TEXT("MoveCopyDriver(): Oper %x From(%s) To(%s)"), pcs->dth.oper, (LPCTSTR)pcs->dth.szSrcPath, (LPCTSTR)pcs->dth.szDestPath); // some operation that may effect the destination (have a collision) if ((pcs->lpfo->wFunc != FO_DELETE) && (pcs->dth.oper != OPER_LEAVEDIR)) { // this compare needs to be case sensitive, and locale insensitive if (!StrCmpC(pcs->dth.szSrcPath, pcs->dth.szDestPath) && !(pcs->fFlags & FOF_RENAMEONCOLLISION)) { // Source and dest are the same file, and name collision // resolution is not turned on, so we just return an error. // TODO: Show the error dialog here and allow for SKIP ret = DE_SAMEFILE; goto ShowMessageBox; } } result = AllConfirmations(pcs, &fdSrc, pcs->dth.oper, pcs->lpfo->wFunc, pcs->dth.szSrcPath, pcs->dth.szDestPath, bTimeToUpdate, &fdDest, &ret); switch (result) { case IDNO: DTAbortCurrentNode(&pcs->dth); lpfo->fAnyOperationsAborted = TRUE; continue; case IDCANCEL: pcs->bAbort = TRUE; goto ExitLoop; case IDYES: break; default: ret = result; goto ShowMessageBox; } /* Now determine which operation to perform */ switch (pcs->dth.oper | pcs->lpfo->wFunc) { // Note that ENTERDIR is not done for a root, even though LEAVEDIR is case OPER_ENTERDIR | FO_MOVE: // Create dest, verify source delete ret = EnterDir_Move(pcs, pcs->dth.szSrcPath, pcs->dth.szDestPath, &fdSrc, &fdDest, FALSE); break; case OPER_ENTERDIR | FO_COPY: // Create destination directory ret = EnterDir_Copy(pcs, pcs->dth.szSrcPath, pcs->dth.szDestPath, &fdSrc, &fdDest, FALSE); break; case OPER_LEAVEDIR | FO_MOVE: case OPER_LEAVEDIR | FO_DELETE: ret = LeaveDir_Delete(pcs, pcs->dth.szSrcPath); break; case OPER_LEAVEDIR | FO_COPY: break; case OPER_DOFILE | FO_COPY: ret = DoFile_Copy(pcs, pcs->dth.szSrcPath, pcs->dth.szDestPath, &fdSrc, &fdDest, FALSE); break; case OPER_DOFILE | FO_RENAME: ret = DoFile_Rename(pcs, pcs->dth.szSrcPath, pcs->dth.szDestPath, &fdSrc, &fdDest, FALSE); break; case OPER_DOFILE | FO_MOVE: ret = DoFile_Move(pcs, pcs->dth.szSrcPath, pcs->dth.szDestPath, &fdSrc, &fdDest, FALSE); break; case OPER_ENTERDIR | FO_DELETE: ret = EnterDir_Delete(pcs, &fdSrc, pcs->dth.szSrcPath, &hdpaDeletedFiles); break; case OPER_DOFILE | FO_DELETE: ret = DoFile_Delete(pcs, &fdSrc, pcs->dth.szSrcPath, &hdpaDeletedFiles, fShouldSuspendEvents); break; default: DebugMsg(DM_ERROR, TEXT("Invalid file operation")); ret = 0; // internal error break; } // switch (pcs->dth.oper | pcs->lpfo->wFunc) if (pcs->bAbort) break; if (ret == IDNO) { pcs->lpfo->fAnyOperationsAborted = TRUE; } else if (ret) { // any errors? ShowMessageBox: // If source file is a connected item and is not found, that means that // we have already moved/deleted/renamed it. So, don't report that as error! if ((!pcs->dth.pdtnCurrent) || (!pcs->dth.pdtnCurrent->fConnectedElement) || ((ret != ERROR_FILE_NOT_FOUND) && (ret != ERROR_PATH_NOT_FOUND))) { CopyError(pcs, pcs->dth.szSrcPath, pcs->dth.szDestPath, ret, pcs->lpfo->wFunc, pcs->dth.oper); // If the directory is copied but a file inside that directory could not // be copied because of long filename, check to see if this is // a connected element. If so, invoke undo, sothat we getback the orginal html file // in the same place as the associated folder. if ((ret == ERROR_FILENAME_EXCED_RANGE) && (DTNIsConnected(pcs->dth.pdtnCurrent))) { if (pcs->lpua) { pcs->lpua->foFlags |= FOF_NOCONFIRMATION; FOUndo_Invoke(pcs->lpua); pcs->lpua = NULL; } } break; } } if (bTimeToUpdate) { // perform the delayed update of the dialog if (bUpdateAnimation) { UpdateProgressAnimation(pcs); bUpdateAnimation = FALSE; } // We check to see if we are finished here (instead of at the // start) since we want to keep the progress a step behind what // we are doing to ensure we have the correct progress animation // and text (since FOQueryAbort updates the progress text) if (FOQueryAbort(pcs)) break; } } ExitLoop: // this happens in error cases where we broke out of the pcr loop // without hitting the end lpfo->hNameMappings = pcs->dth.hdsaRenamePairs; DTCleanup(&pcs->dth); BBFinishDelete(hdpaDeletedFiles); if (fShouldSuspendEvents) { ResumeSHNotify(); if (lpfo->wFunc == FO_DELETE) { TCHAR szBBPath[MAX_PATH]; // Since we probably blew away any chance at having the FSNotify work, make sure // we update item for this path... we can send the message on any drive since // the bitbucket listens for changes on all drives. DriveIDToBBPath(DriveIDFromBBPath(lpfo->pFrom), szBBPath); SHChangeNotify(SHCNE_UPDATEDIR, SHCNF_PATH, szBBPath, NULL); } } if (g_dwStopWatchMode) { lstrcpy((LPTSTR)&szText[12], TEXT(": Stop ")); StopWatch_Stop(SWID_COPY, (LPCTSTR)szText, SPMODE_SHELL | SPMODE_DEBUGOUT); } EndCopyEngine(hEventRunning); return ret; } void SetWindowTextFromRes(HWND hwnd, int id) { TCHAR szTemp[80]; LoadString(HINST_THISDLL, id, szTemp, ARRAYSIZE(szTemp)); SetWindowText(hwnd, szTemp); } int CountProgressPoints(COPY_STATE *pcs, PDIRTOTALS pdt) { // point value for each item int iTotal = 0; UINT uSize = pcs->uSize; if (!uSize) { uSize = 32*1024; } // now add it up. iTotal += (UINT)((pdt->liSize.QuadPart/uSize) * pcs->dth.iSizePoints); iTotal += pdt->dwFiles * pcs->dth.iFilePoints; iTotal += pdt->dwFolders * pcs->dth.iFolderPoints; return iTotal; } void UpdateProgressDialog(COPY_STATE* pcs) { int iRange; // from 0 to iRange int iPos; // how much is done. if (pcs->fProgressOk) { if (pcs->dth.dtAll.fChanged) { pcs->dth.dtAll.fChanged = FALSE; iRange = CountProgressPoints(pcs, &pcs->dth.dtAll); SendProgressMessage(pcs, PBM_SETRANGE32, 0, iRange); DebugMsg(TF_DEBUGCOPY, TEXT("UpdateProgressDialog iRange = %d "), iRange); } if (pcs->dth.dtDone.fChanged) { pcs->dth.dtDone.fChanged = FALSE; iPos = CountProgressPoints(pcs, &pcs->dth.dtDone); SendProgressMessage(pcs, PBM_SETPOS, iPos, 0); DebugMsg(TF_DEBUGCOPY, TEXT("UpdateProgressDialog iPos = %d "), iPos); } } } // NOTE: !! do NOT refrence pcs->lpfo anywhere in this dialog proc !! // // It can be freed while we are still running. If you need to get information from it, // add a new member to the FOUITHREADINFO struct and copy the value from the pcs->lpfo // into the member (while holding the critsec) right before we create this dlg. BOOL_PTR CALLBACK FOFProgressDlgProc(HWND hDlg, UINT wMsg, WPARAM wParam, LPARAM lParam) { FOUITHREADINFO* pfouiti = (FOUITHREADINFO*)GetWindowLongPtr(hDlg, DWLP_USER); COPY_STATE *pcs = (pfouiti ? pfouiti->pcs : NULL); if (WM_INITDIALOG == wMsg) { SetWindowLongPtr(hDlg, DWLP_USER, lParam); pfouiti = (FOUITHREADINFO*)lParam; pcs = pfouiti->pcs; SetWindowTextFromRes(hDlg, IDS_ACTIONTITLE + pfouiti->wFunc); if (pcs->fFlags & FOF_SIMPLEPROGRESS) { TCHAR szFrom[MAX_PATH]; if (pcs->lpszProgressTitle) { if (IS_INTRESOURCE(pcs->lpszProgressTitle)) { LoadString(HINST_THISDLL, PtrToUlong(pcs->lpszProgressTitle), szFrom, ARRAYSIZE(szFrom)); pcs->lpszProgressTitle = szFrom; } SetDlgItemText(hDlg, IDD_NAME, pcs->lpszProgressTitle); // null it so we only set it once pcs->lpszProgressTitle = NULL; } } return FALSE; } if (pcs) { switch (wMsg) { case WM_TIMER: if (IsWindowEnabled(hDlg)) SetProgressTime(pcs); break; case WM_SHOWWINDOW: if (wParam) { int idAni; HWND hwndAnimation; ASSERT(pfouiti->wFunc >= FO_MOVE && pfouiti->wFunc <= FO_DELETE); ASSERT(FO_COPY==FO_MOVE+1); ASSERT(FO_DELETE==FO_COPY+1); ASSERT(IDA_FILECOPY==IDA_FILEMOVE+1); ASSERT(IDA_FILEDEL ==IDA_FILECOPY+1); switch (pfouiti->wFunc) { case FO_DELETE: if (pfouiti->bIsEmptyRBOp) { idAni = IDA_FILENUKE; break; } else if (!(pcs->fFlags & FOF_ALLOWUNDO)) { idAni = IDA_FILEDELREAL; break; } // else fall through default: idAni = (IDA_FILEMOVE + (int)pfouiti->wFunc - FO_MOVE); } hwndAnimation = GetDlgItem(hDlg,IDD_ANIMATE); Animate_Open(hwndAnimation, IntToPtr(idAni)); SetProp(hwndAnimation, TEXT("AnimationID"), IntToPtr(idAni)); // a timer every MS_TIMESLICE seconds to update the progress time estimate SetTimer(hDlg, 1, MS_TIMESLICE, NULL); } break; case WM_ENABLE: if (wParam) { if (pcs->dwPreviousTime) { // if we're enabling it, set the previous time to now // because no action has happened while we were disabled pcs->dwPreviousTime = GetTickCount(); } } else { SetProgressTime(pcs); } PauseAnimation(pcs, wParam == 0); break; case WM_COMMAND: switch (GET_WM_COMMAND_ID(wParam, lParam)) { case IDCANCEL: pcs->bAbort = TRUE; ShowWindow(hDlg, SW_HIDE); break; } break; case PDM_SHUTDOWN: // Make sure this window is shown before telling the user there // is a problem // ignore FOF_NOERRORUI here because of the nature of the situation ShellMessageBox(HINST_THISDLL, hDlg, MAKEINTRESOURCE(IDS_CANTSHUTDOWN), NULL, MB_OK | MB_ICONEXCLAMATION | MB_SETFOREGROUND); break; case PDM_NOOP: // a dummy id that we can take so that folks can post to us and make // us go through the main loop break; case PDM_UPDATE: pcs->dth.fChangePosted = FALSE; UpdateProgressDialog(pcs); break; case WM_QUERYENDSESSION: // Post a message telling the dialog to show the "We can't shutdown now" // dialog and return to USER right away, so we don't have to worry about // the user not clicking the OK button before USER puts up its "this // app didn't respond" dialog PostMessage(hDlg, PDM_SHUTDOWN, 0, 0); // Make sure the dialog box procedure returns FALSE SetWindowLongPtr(hDlg, DWLP_MSGRESULT, FALSE); return TRUE; default: return FALSE; } } return TRUE; } int CALLBACK FOUndo_FileReallyDeletedCallback(UNDOATOM *lpua, LPARAM lParam) { LPTSTR * ppsz = (LPTSTR*)lParam; // this is our signal to nuke the rest if (!*ppsz) return EUA_DELETE; switch (lpua->uType) { case IDS_RENAME: case IDS_COPY: case IDS_MOVE: case IDS_DELETE: { LPFOUNDODATA lpud = (LPFOUNDODATA)lpua->lpData; HDPA hdpa = lpud->hdpa; // only the destinations matter. int i, iMax = DPA_GetPtrCount(hdpa); for (i = 1; i <= iMax; i += 2) { LPTSTR lpsz = DPA_GetPtr(hdpa, i); if (lstrcmpi(lpsz, *ppsz) == 0) { *ppsz = NULL; break; } } } break; } // this is our signal to nuke the rest if (!*ppsz) return EUA_DELETE; else return EUA_DONOTHING; } // someone really really deleted a file. make sure we no longer have // any undo information pointing to it. void FOUndo_FileReallyDeleted(LPTSTR lpszFile) { EnumUndoAtoms(FOUndo_FileReallyDeletedCallback, (LPARAM)&lpszFile); } int CALLBACK FOUndo_FileRestoredCallback(UNDOATOM *lpua, LPARAM lParam) { LPTSTR psz = (LPTSTR)lParam; switch (lpua->uType) { case IDS_DELETE: { LPFOUNDODATA lpud = (LPFOUNDODATA)lpua->lpData; HDPA hdpa = lpud->hdpa; LPTSTR lpsz; int i, iMax; ASSERT(hdpa); // only the destinations matter. iMax = DPA_GetPtrCount(hdpa); for (i = 1; i <= iMax; i += 2) { lpsz = DPA_GetPtr(hdpa, i); if (lstrcmpi(lpsz, psz) == 0) { ENTERCRITICAL; Str_SetPtr(&lpsz, NULL); lpsz = DPA_GetPtr(hdpa, i - 1); Str_SetPtr(&lpsz, NULL); DPA_DeletePtr(hdpa, i); DPA_DeletePtr(hdpa, i - 1); LEAVECRITICAL; if (DPA_GetPtrCount(hdpa)) return EUA_ABORT; else return EUA_DELETEABORT; } } } break; } return EUA_DONOTHING; } // this means someone restored a file (via ui in the bitbucket) // so we need to clean up the undo info. void FOUndo_FileRestored(LPCTSTR lpszFile) { EnumUndoAtoms(FOUndo_FileRestoredCallback, (LPARAM)lpszFile); } void FOUndo_AddInfo(UNDOATOM *lpua, LPTSTR lpszSrc, LPTSTR lpszDest, DWORD dwAttributes) { HDPA hdpa; LPTSTR lpsz = NULL; int i; LPFOUNDODATA lpud; if (lpua->lpData == (void *)-1) return; if (!lpua->lpData) { lpua->lpData = LocalAlloc(LPTR, sizeof(FOUNDODATA)); if (!lpua->lpData) return; ((LPFOUNDODATA)lpua->lpData)->hdpa = (void *)DPA_Create(4); } lpud = lpua->lpData; hdpa = lpud->hdpa; if (!hdpa) return; // if it's a directory that got deleted, we're just going to save it's // attributes so that we can recreate it later. // directories do NOT get moved into the wastebasket if ((lpua->uType == IDS_DELETE) && (dwAttributes & FILE_ATTRIBUTE_DIRECTORY)) { FOUNDO_DELETEDFILEINFO dfi; if (!lpud->hdsa) { lpud->hdsa = DSA_Create(sizeof(FOUNDO_DELETEDFILEINFO), 4); if (!lpud->hdsa) return; } Str_SetPtr(&lpsz, lpszSrc); dfi.lpszName = lpsz; dfi.dwAttributes = dwAttributes; DSA_AppendItem(lpud->hdsa, &dfi); } else { Str_SetPtr(&lpsz, lpszSrc); if (!lpsz) return; if ((i = DPA_AppendPtr(hdpa, lpsz)) == -1) { return; } lpsz = NULL; Str_SetPtr(&lpsz, lpszDest); if (!lpsz || DPA_AppendPtr(hdpa, lpsz) == -1) { DPA_DeletePtr(hdpa, i); } } } LPTSTR DPA_ToFileList(HDPA hdpa, int iStart, int iEnd, int iIncr) { LPTSTR lpsz; LPTSTR lpszReturn; int ichSize; int ichTemp; int i; // undo copy by deleting destinations lpszReturn = (LPTSTR)(void*)LocalAlloc(LPTR, 1); if (!lpszReturn) { return NULL; } ichSize = 1; // build the NULL separated file list // go from the end to the front.. restore in reverse order! for (i = iEnd; i >= iStart ; i -= iIncr) { LPTSTR psz; lpsz = DPA_GetPtr(hdpa, i); ASSERT(lpsz); ichTemp = ichSize - 1; ichSize += (lstrlen(lpsz) + 1); psz = (LPTSTR)(void*)LocalReAlloc((HLOCAL)lpszReturn, ichSize * sizeof(TCHAR), LMEM_MOVEABLE|LMEM_ZEROINIT); if (!psz) { break; } lpszReturn = psz; lstrcpy(lpszReturn + ichTemp, lpsz); } if ((i + iIncr) != iStart) { LocalFree((HLOCAL)lpszReturn); lpszReturn = NULL; } return lpszReturn; } // from dpa to: // 'file 1', 'file 2' and 'file 3' LPTSTR DPA_ToQuotedFileList(HDPA hdpa, int iStart, int iEnd, int iIncr) { LPTSTR lpsz; LPTSTR lpszReturn; TCHAR szFile[MAX_PATH]; int ichSize; int ichTemp; int i; SHELLSTATE ss; // undo copy by deleting destinations lpszReturn = (LPTSTR)(void*)LocalAlloc(LPTR, 1); if (!lpszReturn) { return NULL; } SHGetSetSettings(&ss, SSF_SHOWEXTENSIONS|SSF_SHOWALLOBJECTS, FALSE); ichSize = 1; // build the quoted file list for (i = iStart; i < iEnd ; i += iIncr) { LPTSTR psz; ichTemp = ichSize - 1; // get the name (filename only without extension) lpsz = DPA_GetPtr(hdpa, i); lstrcpy(szFile, PathFindFileName(lpsz)); if (!ss.fShowExtensions) { PathRemoveExtension(szFile); } // grow the buffer and add it in ichSize += lstrlen(szFile) + 2; psz = (LPTSTR)(void*)LocalReAlloc((HLOCAL)lpszReturn, ichSize * sizeof(TCHAR), LMEM_MOVEABLE|LMEM_ZEROINIT); if (!psz) { LocalFree(lpszReturn); lpszReturn = NULL; break; } lpszReturn = psz; // is it too long? if (ichSize >= MAX_PATH) { lstrcat(lpszReturn, c_szEllipses); return lpszReturn; } else { StrCatBuff(lpszReturn, TEXT("'"), ichSize); //A single quote BEFORE the filename. StrCatBuff(lpszReturn, szFile, ichSize); StrCatBuff(lpszReturn, TEXT("'"), ichSize); //A single quote AFTER the filename. } ASSERT(ichSize == ichTemp + (lstrlen(lpszReturn + ichTemp) + 1)); ichTemp = ichSize - 1; // check to see if we need the "and" if ((i + iIncr) < iEnd) { TCHAR szTemp[40]; int id; ichSize += 40; if ((i + (iIncr*2)) >= iEnd) { id = IDS_SPACEANDSPACE; } else { id = IDS_COMMASPACE; } psz = (LPTSTR)LocalReAlloc((HLOCAL)lpszReturn, ichSize * sizeof(TCHAR), LMEM_MOVEABLE|LMEM_ZEROINIT); if (!psz) { LocalFree(lpszReturn); lpszReturn = NULL; break; } lpszReturn = psz; LoadString(HINST_THISDLL, id, szTemp, ARRAYSIZE(szTemp)); StrCatBuff(lpszReturn, szTemp, ichSize); ichSize = ichTemp + (lstrlen(lpszReturn + ichTemp) + 1); } } return lpszReturn; } void CALLBACK FOUndo_GetText(UNDOATOM *lpua, TCHAR * buffer, int type) { LPFOUNDODATA lpud = (LPFOUNDODATA)lpua->lpData; HDPA hdpa = lpud->hdpa; if (type == UNDO_MENUTEXT) { LoadString(HINST_THISDLL, lpua->uType, buffer, MAX_PATH); } else { TCHAR szTemplate[80]; // thank god for growable stacks.. TCHAR szFile1[MAX_PATH]; TCHAR szFile2[MAX_PATH]; TCHAR szFile1Short[30]; TCHAR szFile2Short[30]; TCHAR *lpszFile1; TCHAR *lpszFile2; // get the template LoadString(HINST_THISDLL, lpua->uType + (IDS_UNDO_FILEOPHELP - IDS_UNDO_FILEOP), szTemplate, ARRAYSIZE(szTemplate)); if (lpua->uType == IDS_RENAME) { SHELLSTATE ss; LPTSTR pszTemp; // fill in the file names lpszFile1 = DPA_GetPtr(hdpa, 0); lpszFile2 = DPA_GetPtr(hdpa, 1); lstrcpy(szFile1, PathFindFileName(lpszFile1)); lstrcpy(szFile2, PathFindFileName(lpszFile2)); SHGetSetSettings(&ss, SSF_SHOWEXTENSIONS, FALSE); if (!ss.fShowExtensions) { PathRemoveExtension(szFile1); PathRemoveExtension(szFile2); } // length sanity check // don't just whack "..." at 30 bytes into szFile1 since that may be a dbcs character... PathCompactPathEx(szFile1Short, szFile1, ARRAYSIZE(szFile1Short), 0); PathCompactPathEx(szFile2Short, szFile2, ARRAYSIZE(szFile2Short), 0); pszTemp = ShellConstructMessageString(HINST_THISDLL, szTemplate, szFile1Short, szFile2Short); if (pszTemp) { StrCpyN(buffer, pszTemp, MAX_PATH); LocalFree(pszTemp); } } else { TCHAR *lpszFile1; HDPA hdpaFull = hdpa; // in the case of delete (where ther's an hdsa) // we need to add in the names of folders deleted // we do this by cloning the hdpa and tacking on our names. if (lpud->hdsa) { hdpaFull = DPA_Clone(hdpa, NULL); if (hdpaFull) { int iMax; int i; LPFOUNDO_DELETEDFILEINFO lpdfi; iMax = DSA_GetItemCount(lpud->hdsa); for (i = 0; i < iMax; i++) { lpdfi = DSA_GetItemPtr(lpud->hdsa, i); DPA_AppendPtr(hdpaFull, lpdfi->lpszName); DPA_AppendPtr(hdpaFull, lpdfi->lpszName); } } else { hdpaFull = hdpa; } } lpszFile1 = DPA_ToQuotedFileList(hdpaFull, 0, DPA_GetPtrCount(hdpaFull), 2); wnsprintf(buffer, MAX_PATH, szTemplate, lpszFile1); LocalFree((HLOCAL)lpszFile1); if (hdpaFull != hdpa) { DPA_Destroy(hdpaFull); } } } } void CALLBACK FOUndo_Release(UNDOATOM *lpua) { LPFOUNDODATA lpud = (LPFOUNDODATA)lpua->lpData; int i; LPTSTR lpsz; if (lpud && (lpud != (void *)-1)) { HDPA hdpa = lpud->hdpa; HDSA hdsa = lpud->hdsa; if (hdpa) { i = DPA_GetPtrCount(hdpa) - 1; for (; i >= 0; i--) { lpsz = DPA_FastGetPtr(hdpa, i); Str_SetPtr(&lpsz, NULL); } DPA_Destroy(hdpa); } if (hdsa) { LPFOUNDO_DELETEDFILEINFO lpdfi; i = DSA_GetItemCount(hdsa) - 1; for (; i >= 0 ; i--) { lpdfi = DSA_GetItemPtr(hdsa, i); Str_SetPtr(&lpdfi->lpszName, NULL); } DSA_Destroy(hdsa); } LocalFree(lpud); lpua->lpData = (void *)-1; } } DWORD WINAPI FOUndo_InvokeThreadInit(UNDOATOM *lpua) { LPFOUNDODATA lpud = (LPFOUNDODATA)lpua->lpData; HDPA hdpa = lpud->hdpa; HWND hwnd = lpua->hwnd; BOOL fNukeAtom = TRUE; SHFILEOPSTRUCT sFileOp = { hwnd, 0, NULL, NULL, 0, } ; int iMax; SuspendUndo(TRUE); iMax = DPA_GetPtrCount(hdpa); switch (lpua->uType) { case IDS_RENAME: { TCHAR szFromPath[MAX_PATH + 1]; if (iMax < 2) goto Exit; sFileOp.wFunc = FO_RENAME; sFileOp.pFrom = DPA_GetPtr(hdpa, 1); sFileOp.pTo = DPA_GetPtr(hdpa, 0); if (sFileOp.pFrom && sFileOp.pTo) { lstrcpy(szFromPath, sFileOp.pFrom); szFromPath[lstrlen(sFileOp.pFrom) + 1] = 0; sFileOp.pFrom = szFromPath; SHFileOperation(&sFileOp); if (sFileOp.fAnyOperationsAborted) { fNukeAtom = FALSE; } } // In the rename case the DPA owns these pointers, in all other cases // they must be freed below. To prevent freeing these during a rename // we NULL them out when we're done with them sFileOp.pFrom = NULL; sFileOp.pTo = NULL; } break; case IDS_COPY: sFileOp.pFrom = DPA_ToFileList(hdpa, 1, iMax - 1, 2); if (!sFileOp.pFrom) goto Exit; sFileOp.wFunc = FO_DELETE; // // If this delete is occuring because of an automatic undo caused by // connected files, then do not ask for confirmation. // if (lpua->foFlags & FOF_NOCONFIRMATION) sFileOp.fFlags |= FOF_NOCONFIRMATION; SHFileOperation(&sFileOp); if (sFileOp.fAnyOperationsAborted) { fNukeAtom = FALSE; } break; case IDS_MOVE: sFileOp.pFrom = DPA_ToFileList(hdpa, 1, iMax-1, 2); sFileOp.pTo = DPA_ToFileList(hdpa, 0, iMax-2, 2); if (!sFileOp.pFrom || !sFileOp.pTo) goto Exit; sFileOp.wFunc = FO_MOVE; sFileOp.fFlags = FOF_MULTIDESTFILES; if (lpua->foFlags & FOF_NOCOPYSECURITYATTRIBS) { sFileOp.fFlags |= FOF_NOCOPYSECURITYATTRIBS; } SHFileOperation(&sFileOp); if (sFileOp.fAnyOperationsAborted) { fNukeAtom = FALSE; } break; case IDS_DELETE: { // first create any directories if (lpud->hdsa) { HDSA hdsa = lpud->hdsa; int i; // do it in reverse order to get the parentage right for (i = DSA_GetItemCount(hdsa) - 1; i >= 0; i--) { LPFOUNDO_DELETEDFILEINFO lpdfi = DSA_GetItemPtr(hdsa, i); if (lpdfi) { if (Win32CreateDirectory(lpdfi->lpszName, NULL)) { SetFileAttributes(lpdfi->lpszName, lpdfi->dwAttributes & ~FILE_ATTRIBUTE_DIRECTORY); } } } } if (iMax) { sFileOp.pFrom = DPA_ToFileList(hdpa, 1, iMax-1, 2); sFileOp.pTo = DPA_ToFileList(hdpa, 0, iMax-2, 2); if (!sFileOp.pFrom || !sFileOp.pTo) goto Exit; UndoBBFileDelete(sFileOp.pTo, sFileOp.pFrom); } break; } } SHChangeNotify(0, SHCNF_FLUSH | SHCNF_FLUSHNOWAIT, NULL, NULL); Exit: if (sFileOp.pFrom) LocalFree((HLOCAL)sFileOp.pFrom); if (sFileOp.pTo) LocalFree((HLOCAL)sFileOp.pTo); SuspendUndo(FALSE); if (fNukeAtom) NukeUndoAtom(lpua); return 1; } void CALLBACK FOUndo_Invoke(UNDOATOM *lpua) { DWORD idThread; HANDLE hthread = CreateThread(NULL, 0, FOUndo_InvokeThreadInit, lpua, 0, &idThread); if (hthread) CloseHandle(hthread); } UNDOATOM *FOAllocUndoAtom(LPSHFILEOPSTRUCT lpfo) { UNDOATOM *lpua = (UNDOATOM *)LocalAlloc(LPTR, sizeof(*lpua)); if (lpua) { lpua->uType = FOFuncToStringID(lpfo->wFunc); lpua->GetText = FOUndo_GetText; lpua->Invoke = FOUndo_Invoke; lpua->Release = FOUndo_Release; lpua->foFlags = 0; if (lpfo->fFlags & FOF_NOCOPYSECURITYATTRIBS) { lpua->foFlags |= FOF_NOCOPYSECURITYATTRIBS; } } return lpua; } //============================================================================ // // The following function is the mainline function for COPYing, RENAMEing, // DELETEing, and MOVEing single or multiple files. // // in: // hwnd the parent to create the progress dialog from if FOF_CREATEPROGRESSDLG is set. // // // wFunc operation to be performed: // FO_DELETE - Delete files in pFrom (pTo unused) // FO_RENAME - Rename files // FO_MOVE - Move files in pFrom to pTo // FO_COPY - Copy files in pFrom to pTo // // pFrom list of source file specs either qualified or // unqualified. unqualified names will be qualified based on the current // global current directories. examples include // "foo.txt bar.txt *.bak ..\*.old dir_name" // // pTo destination file spec. // // fFlags flags that control the operation // // returns: // 0 indicates success // != 0 is the DE_ (dos error code) of last failed operation // // //=========================================================================== int WINAPI SHFileOperation(LPSHFILEOPSTRUCT lpfo) { int ret; BOOL bRecycledStuff = FALSE; COPY_STATE *pcs; if (!lpfo || !lpfo->pFrom) { // return an error instead of waiting to AV return ERROR_INVALID_PARAMETER; } lpfo->fAnyOperationsAborted = FALSE; lpfo->hNameMappings = NULL; if (lpfo->wFunc < FO_MOVE || lpfo->wFunc > FO_RENAME) // validate { // NOTE: We used to return 0 here (win95gold -> IE401). // // If we run into app compat bugs because they were relying on the old // buggy return value, then add an app hack here. // // this is not a DE_ error, and I don't care! return ERROR_INVALID_PARAMETER; } pcs = (COPY_STATE*)LocalAlloc(LPTR, sizeof(COPY_STATE)); if (!pcs) { return ERROR_NOT_ENOUGH_MEMORY; } pcs->nRef = 1; // // REVIEW: We want to allow copying of a file within a given directory // by having default renaming on collisions within a directory. // if (!(lpfo->fFlags & FOF_NOCONFIRMATION)) { pcs->cd.fConfirm = CONFIRM_DELETE_FILE | CONFIRM_DELETE_FOLDER | CONFIRM_REPLACE_FILE | CONFIRM_REPLACE_FOLDER | CONFIRM_WONT_RECYCLE_FILE | CONFIRM_WONT_RECYCLE_FOLDER | CONFIRM_PATH_TOO_LONG | // CONFIRM_MOVE_FILE | // CONFIRM_MOVE_FOLDER | // CONFIRM_RENAME_FILE | // CONFIRM_RENAME_FOLDER | CONFIRM_SYSTEM_FILE | CONFIRM_READONLY_FILE | CONFIRM_MULTIPLE | CONFIRM_PROGRAM_FILE | CONFIRM_STREAMLOSS | CONFIRM_FAILED_ENCRYPT | CONFIRM_LFNTOFAT | CONFIRM_WONT_RECYCLE_OFFLINE | CONFIRM_LOST_ENCRYPT_FILE | CONFIRM_LOST_ENCRYPT_FOLDER; } if (lpfo->fFlags & FOF_WANTNUKEWARNING) { // We will warn the user that the thing they thought was going to be recycled is // now really going to be nuked. (eg drag-drop folder on recycle bin, but it turns // out that the folder is too big for the bitbucket, so we confirm on the wont-recycle // cases). // // Also, we keep the system file / readonly file / progran file warnings around for good // measure. pcs->cd.fConfirm |= CONFIRM_WONT_RECYCLE_FILE | CONFIRM_WONT_RECYCLE_FOLDER | CONFIRM_PATH_TOO_LONG | CONFIRM_SYSTEM_FILE | CONFIRM_READONLY_FILE | CONFIRM_PROGRAM_FILE | CONFIRM_WONT_RECYCLE_OFFLINE; } pcs->fFlags = lpfo->fFlags; // duplicate some stuff here pcs->lpszProgressTitle = lpfo->lpszProgressTitle; pcs->lpfo = lpfo; // Check to see if we need to operate on the "connected" files and folders too! if (!(pcs->fFlags & FOF_NO_CONNECTED_ELEMENTS)) { DWORD dwFileFolderConnection = 0; DWORD dwSize = sizeof(dwFileFolderConnection); DWORD dwType = REG_DWORD; if (SHGetValue(HKEY_CURRENT_USER, REGSTR_PATH_EXPLORER, REG_VALUE_NO_FILEFOLDER_CONNECTION, &dwType, &dwFileFolderConnection, &dwSize) == ERROR_SUCCESS) { //If the registry says "No connection", then set the flags accordingly. if (dwFileFolderConnection == 1) { pcs->fFlags = pcs->fFlags | FOF_NO_CONNECTED_ELEMENTS; } } } // Always create a progress dialog // Note that it will be created invisible, and will be shown if the // operation takes longer than a second to perform // Note the parent of this window is NULL so it will get the QUERYENDSESSION // message if (!(pcs->fFlags & FOF_SILENT)) { SHCreateThread(FOUIThreadProc, pcs, 0, AddRefPCS); } else { // To be compatible with Win95 semantics... if (!lpfo->hwnd) { pcs->fFlags |= FOF_NOERRORUI; } } if (lpfo->hwnd) { // The caller will be disabled if we ever show the progress window // We need to make sure this is not disabled now because if it is and // another dialog uses this as its parent, USER code will tell this // window it got the focus while it is still disabled, which keeps it // from passing that focus down to its children // EnableWindow(lpfo->hwnd, FALSE); pcs->hwndDlgParent = lpfo->hwnd; } // do this always.. even if this is not an undoable op, we could be // affecting something that is. SuspendUndo(TRUE); if (lpfo->fFlags & FOF_ALLOWUNDO) { pcs->lpua = FOAllocUndoAtom(lpfo); if (lpfo->wFunc == FO_DELETE) { // We check the shell state to see if the user has turned on the // "Don't confirm deleting recycle bin contents" flag. If yes, // then we store this flag and check against it if this case occures. // Review: Not a super common case, why not just check when the // flag is actually needed? SHELLSTATE ss; SHGetSetSettings(&ss, SSF_NOCONFIRMRECYCLE, FALSE); pcs->fNoConfirmRecycle = ss.fNoConfirmRecycle; if (InitBBGlobals()) { // since we are going to be recycling stuff, we add ourselves to the // global list of threads who are recycling SHGlobalCounterIncrement(g_hgcNumDeleters); bRecycledStuff = TRUE; } else { // this shouldnt happen, but if it does we can't send stuff to the Recycle // Bin, instead we remove the undo flag so that everything is really nuked. lpfo->fFlags &= ~FOF_ALLOWUNDO; LocalFree(pcs->lpua); pcs->lpua = NULL; } } } // While doing the file operation, tell PnP not to suspend // the machine. Otherwise, you could be copying a lot of files // over the network and have the laptop suddenly hibernate on you // because PnP thought you were idle. // // Indicate that we only need the system. It's okay if the display // goes into low-power mode, as long as we can keep copying. // SetThreadExecutionState(ES_CONTINUOUS | ES_SYSTEM_REQUIRED); ret = MoveCopyDriver(pcs); SetThreadExecutionState(ES_CONTINUOUS); if (pcs->bAbort) { ASSERT(pcs->lpfo == lpfo); lpfo->fAnyOperationsAborted = TRUE; } if (bRecycledStuff) { SHUpdateRecycleBinIcon(); if (0 == SHGlobalCounterDecrement(g_hgcNumDeleters)) { // We were the last guy who was deleting stuff. Thus, we need to // check to see if any of the bitbuckets info files neeed compacting or purging CheckCompactAndPurge(); } } if (pcs->lpCopyBuffer) { LocalFree((HLOCAL)pcs->lpCopyBuffer); pcs->lpCopyBuffer = NULL; } if (pcs->lpua) { if (pcs->lpua->lpData && (pcs->lpua->lpData != (void *)-1)) { AddUndoAtom(pcs->lpua); } else { FOUndo_Release(pcs->lpua); NukeUndoAtom(pcs->lpua); } } // NTRAID89119 (toddb): This code is totally busted in respect to mounted volumes. // We will send a change notify for the drive on which your volume is mounted // instead of on the volume which actually had a free space change. We need // to update PathGetDriveNumber to handle mounted volumes // notify of freespace changes // rename doesn't change drive usage if (lpfo->wFunc != FO_RENAME) { int idDriveSrc; int idDriveDest = -1; DWORD dwDrives = 0; // bitfield for drives if (lpfo->wFunc == FO_COPY) { // nothing changes on the source idDriveSrc = -1; } else { idDriveSrc = PathGetDriveNumber(lpfo->pFrom); } if (lpfo->pTo) { idDriveDest = PathGetDriveNumber(lpfo->pTo); } if ((lpfo->wFunc == FO_MOVE) && (idDriveDest == idDriveSrc)) { // no freespace nothing changes idDriveSrc = -1; idDriveDest = -1; } // NTRAID89119: What if idDriveSrc or idDriveDest are > 32? This is totally // possible under NT by using mounted volumes. SHChangeNotify is busted // in this respect. if (idDriveSrc != -1) { dwDrives |= (1 << idDriveSrc); } if (idDriveDest != -1) { dwDrives |= (1 << idDriveDest); } if (dwDrives) { SHChangeNotify(SHCNE_FREESPACE, SHCNF_DWORD, IntToPtr(dwDrives), 0); } } SuspendUndo(FALSE); if (!(lpfo->fFlags & FOF_WANTMAPPINGHANDLE)) { SHFreeNameMappings(lpfo->hNameMappings); lpfo->hNameMappings = NULL; } // shut down the progress dialog // // this is necessary so that the ui thread won't block pcs->fProgressOk = TRUE; ENTERCRITICAL; // need to take critsec to sync w/ the UI thread pcs->fDone = TRUE; if (pcs->hwndProgress) { PostMessage(pcs->hwndProgress, PDM_NOOP, 0, 0); } LEAVECRITICAL; if (lpfo->hwnd) { EnableWindow(lpfo->hwnd, TRUE); } ReleasePCS(pcs); return ret; } #ifdef UNICODE int WINAPI SHFileOperationA(LPSHFILEOPSTRUCTA lpfo) { int iResult; UINT uTotalSize; UINT uSize; UINT uSizeTitle; UINT uSizeW; SHFILEOPSTRUCTW shop; LPCSTR lpAnsi; LPWSTR lpBuffer; LPWSTR lpTemp; COMPILETIME_ASSERT(sizeof(SHFILEOPSTRUCTW) == sizeof(SHFILEOPSTRUCTA)); hmemcpy(&shop, lpfo, sizeof(SHFILEOPSTRUCTW)); // // Thunk the strings as appropriate // uTotalSize = 0; if (lpfo->pFrom) { lpAnsi = lpfo->pFrom; do { uSize = lstrlenA(lpAnsi) + 1; uTotalSize += uSize; lpAnsi += uSize; } while (uSize != 1); } if (lpfo->pTo) { lpAnsi = lpfo->pTo; do { uSize = lstrlenA(lpAnsi) + 1; uTotalSize += uSize; lpAnsi += uSize; } while (uSize != 1); } if ((lpfo->fFlags & FOF_SIMPLEPROGRESS) && lpfo->lpszProgressTitle != NULL) { uSizeTitle = lstrlenA(lpfo->lpszProgressTitle) + 1; uTotalSize += uSizeTitle; } if (uTotalSize != 0) { lpTemp = lpBuffer = LocalAlloc(LPTR, uTotalSize*sizeof(WCHAR)); if (!lpBuffer) { SetLastError(ERROR_OUTOFMEMORY); return ERROR_OUTOFMEMORY; } } else { lpBuffer = NULL; } // // Now convert the strings // if (lpfo->pFrom) { shop.pFrom = lpTemp; lpAnsi = lpfo->pFrom; do { uSize = lstrlenA(lpAnsi) + 1; uSizeW = MultiByteToWideChar(CP_ACP, 0, lpAnsi, uSize, lpTemp, uSize); lpAnsi += uSize; lpTemp += uSizeW; } while (uSize != 1); } else { shop.pFrom = NULL; } if (lpfo->pTo) { shop.pTo = lpTemp; lpAnsi = lpfo->pTo; do { uSize = lstrlenA(lpAnsi) + 1; uSizeW = MultiByteToWideChar(CP_ACP, 0, lpAnsi, uSize, lpTemp, uSize); lpAnsi += uSize; lpTemp += uSizeW; } while (uSize != 1); } else { shop.pTo = NULL; } if ((lpfo->fFlags & FOF_SIMPLEPROGRESS) && lpfo->lpszProgressTitle != NULL) { shop.lpszProgressTitle = lpTemp; MultiByteToWideChar(CP_ACP, 0, lpfo->lpszProgressTitle, uSizeTitle, lpTemp, uSizeTitle); } else { shop.lpszProgressTitle = NULL; } iResult = SHFileOperationW(&shop); // link up the two things in the SHFILEOPSTRUCT that could have changed lpfo->fAnyOperationsAborted = shop.fAnyOperationsAborted; lpfo->hNameMappings = shop.hNameMappings; if (lpBuffer) LocalFree(lpBuffer); return iResult; } #else int WINAPI SHFileOperationW(LPSHFILEOPSTRUCTW lpfo) { return E_NOTIMPL; } #endif // In: // pcs: copy_state structure containing the state of the copy // // feedback: If the estimated time to copmplete a copy is larger than // MINTIME4FEEDBACK, the user is given a time to completion estimate in minutes. // The estimate is calculated using a MS_RUNAVG seconds running average. The // initial estimate is done after MS_TIMESLICE void SetProgressTime(COPY_STATE *pcs) { DWORD dwNow = GetTickCount(); if (pcs->dwPreviousTime) { int iPointsTotal = CountProgressPoints(pcs, &pcs->dth.dtAll); int iPointsDone = CountProgressPoints(pcs, &pcs->dth.dtDone); int iPointsDelta = iPointsDone - pcs->iLastProgressPoints; DWORD dwTimeLeft; // // A couple of times the shell has reported bad time remaining // we need to find out why. // ASSERT(iPointsTotal >= 0); ASSERT(iPointsDone >= 0); ASSERT(iPointsTotal >= iPointsDone); ASSERT(iPointsDelta >= 0); // has enough time elapsed to update the display // We do this every 10 seconds, but we'll do the first one after // only a few seconds if (iPointsDelta && (iPointsDone > 0) && (dwNow - pcs->dwPreviousTime)) { DWORD dwPointsPerSec; DWORD dwTime; // how many tenths of a second have gone by // We take 10 times the number of Points and divide by the number of // tenths of a second to minimize both overflow and roundoff dwTime = (dwNow - pcs->dwPreviousTime)/100; if (dwTime == 0) dwTime = 1; dwPointsPerSec = iPointsDelta * 10 / dwTime; if (!dwPointsPerSec) { // This could happen if the net went to sleep for a couple // minutes while trying to copy a small (512 byte) buffer dwPointsPerSec = 1; } // if we didn't have enough time to get a good sample, // don't use this last bit as a time estimater if ((dwNow - pcs->dwPreviousTime) < (MS_TIMESLICE/2)) { dwPointsPerSec = pcs->dwPointsPerSec; } if (pcs->dwPointsPerSec) { // Take a weighted average of the current transfer rate and the // previously computed one, just to try to smooth out // some random fluctuations dwPointsPerSec = (dwPointsPerSec + (pcs->dwPointsPerSec * 2)) / 3; } // never allow 0 points per second.. just tack it on to next time if (dwPointsPerSec) { pcs->dwPointsPerSec = dwPointsPerSec; // Calculate time remaining (round up by adding 1) // We only get here every 10 seconds, so always update dwTimeLeft = ((iPointsTotal - iPointsDone) / dwPointsPerSec) + 1; // It would be odd to show "1 second left" and then immediately // clear it if (dwTimeLeft >= MIN_MINTIME4FEEDBACK) { // display new estimate of time left SetProgressTimeEst(pcs, dwTimeLeft); } } } // Reset previous time and # of Points read pcs->dwPreviousTime = dwNow; pcs->iLastProgressPoints = iPointsDone; } } void InitClipConfirmDlg(HWND hDlg, CONFDLG_DATA *pcd) { TCHAR szMessage[255]; TCHAR szDeleteWarning[80]; SHFILEINFO sfiDest; LPTSTR pszFileDest = NULL; LPTSTR pszMsg, pszSource; int i; int cxWidth; RECT rc; // get the size of the text boxes GetWindowRect(GetDlgItem(hDlg, pcd->idText), &rc); cxWidth = rc.right - rc.left; // get the source display name pszSource = PathFindFileName(pcd->pFileSource); PathCompactPath(NULL, pszSource, cxWidth); // get the dest display name SHGetFileInfo(pcd->pFileDest, 0, &sfiDest, sizeof(sfiDest), SHGFI_DISPLAYNAME | SHGFI_USEFILEATTRIBUTES); pszFileDest = sfiDest.szDisplayName; PathCompactPath(NULL, pszFileDest, cxWidth); // if we're supposed to show the date info, grab the icons and format the date string if (pcd->bShowDates) { SHFILEINFO sfi2; TCHAR szDateSrc[64], szDateDest[64]; // likely that this data may be incomplete... leave it saying "Unknown date and size" if (BuildDateLine(szDateSrc, pcd->pfdSource, pcd->pFileSource)) SetDlgItemText(hDlg, IDD_FILEINFO_NEW, szDateSrc); BuildDateLine(szDateDest, pcd->pfdDest, pcd->pFileDest); SetDlgItemText(hDlg, IDD_FILEINFO_OLD, szDateDest); SHGetFileInfo(pcd->pFileSource, pcd->pfdSource ? pcd->pfdSource->dwFileAttributes : 0, &sfi2, sizeof(sfi2), pcd->pfdSource ? (SHGFI_USEFILEATTRIBUTES|SHGFI_ICON|SHGFI_LARGEICON) : (SHGFI_ICON|SHGFI_LARGEICON)); ReplaceDlgIcon(hDlg, IDD_ICON_NEW, sfi2.hIcon); SHGetFileInfo(pcd->pFileDest, pcd->pfdDest ? pcd->pfdDest->dwFileAttributes : 0, &sfi2, sizeof(sfi2), pcd->pfdDest ? (SHGFI_USEFILEATTRIBUTES|SHGFI_ICON|SHGFI_LARGEICON) : (SHGFI_ICON|SHGFI_LARGEICON)); ReplaceDlgIcon(hDlg, IDD_ICON_OLD, sfi2.hIcon); } // there are 5 controls: // IDD_TEXT contains regular text (normal file/folder) // IDD_TEXT1 through IDD_TEXT4 contain optional secondary text for (i = IDD_TEXT; i <= IDD_TEXT4; i++) { if (i == pcd->idText) { szMessage[0] = 0; GetDlgItemText(hDlg, i, szMessage, ARRAYSIZE(szMessage)); } else { HWND hwndCtl = GetDlgItem(hDlg, i); if (hwndCtl) { ShowWindow(hwndCtl, SW_HIDE); } } } szDeleteWarning[0] = 0; pszMsg = ShellConstructMessageString(HINST_THISDLL, szMessage, pszSource, pszFileDest, szDeleteWarning); if (pszMsg) { SetDlgItemText(hDlg, pcd->idText, pszMsg); LocalFree(pszMsg); } } void FileDescToWin32FileData(LPFILEDESCRIPTOR pfdsc, LPWIN32_FIND_DATA pwfd) { ZeroMemory(pwfd, sizeof(*pwfd)); if (pfdsc->dwFlags & FD_ATTRIBUTES) pwfd->dwFileAttributes = pfdsc->dwFileAttributes; if (pfdsc->dwFlags & FD_CREATETIME) hmemcpy(&pwfd->ftCreationTime, &pfdsc->ftCreationTime, sizeof(FILETIME)); if (pfdsc->dwFlags & FD_ACCESSTIME) hmemcpy(&pwfd->ftLastAccessTime, &pfdsc->ftLastAccessTime, sizeof(FILETIME)); if (pfdsc->dwFlags & FD_WRITESTIME) hmemcpy(&pwfd->ftLastWriteTime, &pfdsc->ftLastWriteTime, sizeof(FILETIME)); if (pfdsc->dwFlags & FD_FILESIZE) { pwfd->nFileSizeHigh = pfdsc->nFileSizeHigh; pwfd->nFileSizeLow = pfdsc->nFileSizeLow; } lstrcpy(pwfd->cFileName, pfdsc->cFileName); } INT_PTR ValidateCreateFileFromClip(HWND hwnd, LPFILEDESCRIPTOR pfdscSrc, TCHAR *pszPathDest, PYNLIST pynl) { WIN32_FIND_DATA wfdSrc, wfdDest; CONFDLG_DATA cdd; CONFIRM_DATA cd; COPY_STATE cs; INT_PTR result; // // If the destination does not exist, we are done. // HANDLE hff = FindFirstFile(pszPathDest, &wfdDest); if (hff == INVALID_HANDLE_VALUE) { return IDYES; } FindClose(hff); // // Maybe this was just a short name collision and // we can quickly get out of here. // if (ResolveShortNameCollisions(pszPathDest, &wfdDest)) { return IDYES; } // // Most of the helper functions want a WIN32_FILE_DATA // and not a FILEDESCRIPTOR, so we create wfd for the // source file on the fly. // FileDescToWin32FileData(pfdscSrc, &wfdSrc); // // Take care of the easy cases - can't copy a file to a dir // or a dir to a file. // if ((wfdDest.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) && ((wfdSrc.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0)) { ZeroMemory(&cs, sizeof(cs)); cs.hwndDlgParent = hwnd; CopyError(&cs, wfdSrc.cFileName, pszPathDest, DE_FILEDESTISFLD | ERRORONDEST, FO_COPY, OPER_DOFILE); return IDNO; } else if (((wfdDest.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0) && (wfdSrc.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) { ZeroMemory(&cs, sizeof(cs)); cs.hwndDlgParent = hwnd; CopyError(&cs, wfdSrc.cFileName, pszPathDest, DE_FLDDESTISFILE | ERRORONDEST, FO_COPY, OPER_DOFILE); AddToNoList(pynl, pszPathDest); return IDNO; } // // We need a confirmation dialog. Fill in the // ConfirmDialogData (cdd) here. // ZeroMemory(&cdd, sizeof(cdd)); cdd.InitConfirmDlg = InitClipConfirmDlg; cdd.idText = IDD_TEXT; cdd.pFileSource = pfdscSrc->cFileName; cdd.pfdSource = &wfdSrc; cdd.pFileDest = pszPathDest; cdd.pfdDest = &wfdDest; cdd.bShowDates = FALSE; cdd.pcd = &cd; ZeroMemory(&cd, sizeof(cd)); cd.fConfirm = CONFIRM_REPLACE_FILE; cdd.fYesToAllMask = CONFIRM_REPLACE_FILE; if (((wfdDest.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0) && (wfdDest.dwFileAttributes & (FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_READONLY))) { if (wfdDest.dwFileAttributes & FILE_ATTRIBUTE_SYSTEM) { cdd.idText = IDD_TEXT2; } else if (wfdDest.dwFileAttributes & FILE_ATTRIBUTE_READONLY) { cdd.idText = IDD_TEXT1; } } // // What we do now depends on whether we are processing a directory // or a file. // if (wfdDest.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) { // // If this directory is already in the yes list, // the parent directory must have already conflicted // and the user said "yes, move the dir contents over". // if (IsInYesList(pynl, pszPathDest)) { result = IDYES; } else { // // Copying directory to a destination with the same directory. // result = DialogBoxParam(HINST_THISDLL, MAKEINTRESOURCE(DLG_REPLACE_FOLDER), hwnd, ConfirmDlgProc, (LPARAM)&cdd); if (result == IDYES) { if (cd.fConfirm & CONFIRM_REPLACE_FILE) { AddToYesList(pynl, pszPathDest); } else { SetYesToAll(pynl); } } else if (result == IDNO) { AddToNoList(pynl, pszPathDest); } } } else { if (IsInYesList(pynl, pszPathDest)) { result = IDYES; } else { // // Copying a file to a destination with the same file. // cdd.bShowDates = TRUE; result = DialogBoxParam(HINST_THISDLL, MAKEINTRESOURCE(DLG_REPLACE_FILE), hwnd, ConfirmDlgProc, (LPARAM)&cdd); if (result == IDYES) { if ((cd.fConfirm & CONFIRM_REPLACE_FILE) == 0) { SetYesToAll(pynl); } } } } return result; } // We can get transient file locks for moving files, for example extracting a thumbnail on a background task // so we wrap our single check in a loop of multiple checks with a short nap between. We'd expect // to get the ERROR_SHARING_VIOLATION, but in practice we also say ERROR_ACCESS_DENIED, so we'll try that // as well #define MAX_DELETE_ATTEMPTS 5 #define SLEEP_DELETE_ATTEMPT 1000 BOOL _IsFileDeletable(LPCTSTR pszFile) { int iAttempt = 0; BOOL bRet; while (!(bRet = IsFileDeletable(pszFile)) && (iAttempt < MAX_DELETE_ATTEMPTS)) { DWORD dwError = GetLastError(); if ((dwError == ERROR_ACCESS_DENIED) || (dwError == ERROR_SHARING_VIOLATION)) { iAttempt++; Sleep(SLEEP_DELETE_ATTEMPT); } else { break; } } return (bRet); } BOOL _IsDirectoryDeletable(LPCTSTR pszDir) { int iAttempt = 0; BOOL bRet; while (!(bRet = IsDirectoryDeletable(pszDir)) && (iAttempt < MAX_DELETE_ATTEMPTS)) { DWORD dwError = GetLastError(); if ((dwError == ERROR_ACCESS_DENIED) || (dwError == ERROR_SHARING_VIOLATION)) { iAttempt++; Sleep(SLEEP_DELETE_ATTEMPT); } else { break; } } return (bRet); } // This function adds up the sizes of the files in pszDir, and // also makes sure that all those files are "delete-able" // // return: ERROR_SUCCESS - everything is fine, all the files in the dir are deleteable // else - the dir cant be deleted because something inside is non-deletable // // NOTE: other in-out params are in the pfdi // LONG CheckFolderSizeAndDeleteability(LPCTSTR pszDir, FOLDERDELETEINFO* pfdi, LPCOPY_STATE pcs) { LONG lRet = ERROR_SUCCESS; // keep stack to a minimum as this is a recursive function! BOOL bHasChildren = FALSE; if (FOQueryAbort(pcs)) return ERROR_CANCELLED; if (NULL == pszDir) return E_INVALIDARG; // do the root specific processing if (!pfdi->bProcessedRoot) { // since the the destination folder could be something like "DC100000.oldext", calculate how many characters are // going to be in the new destination directory: "C:\recycler\sid" + "\" + "DC100000.oldext" == the new root directory length pfdi->cchDelta = (pfdi->cchBBDir + 1 + 8 + 1 + lstrlen(PathFindExtension(pszDir))) - lstrlen(pszDir); // set this so that we only do the above processing for the root folder pfdi->bProcessedRoot = TRUE; } if (PathCombine(pfdi->szPath, pszDir, c_szStarDotStar)) { HANDLE hfind = FindFirstFile(pfdi->szPath, &pfdi->fd); // remove the *.* we added, because we will be recycling this buffer PathRemoveFileSpec(pfdi->szPath); if (hfind != INVALID_HANDLE_VALUE) { do { if (!PathIsDotOrDotDot(pfdi->fd.cFileName)) { bHasChildren = TRUE; // append the subfile/subfolder to the parent path if (!PathAppend(pfdi->szPath, pfdi->fd.cFileName)) { // PathAppend failed, try to append the short name if (!pfdi->fd.cAlternateFileName[0] || !PathAppend(pfdi->szPath, pfdi->fd.cAlternateFileName)) { // no alternate name or we failed to append that as well, assume we failed because the path is too long lRet = ERROR_FILENAME_EXCED_RANGE; // pass back the name of the non-deleteable file/folder in pfdi->szNonDeletableFile lstrcpyn(pfdi->szNonDeletableFile, pfdi->szPath, ARRAYSIZE(pfdi->szNonDeletableFile)); } } if (lRet == ERROR_SUCCESS) { // we have to check to see if the path will exceed MAX_PATH if we were to move this file to the recycle // bin (C:\Recycler\). the increase in path length due to the recycle bin dir could be enough to // put us over MAX_PATH and we would have problems later. if ((lstrlen(pfdi->szPath) + pfdi->cchDelta + 1) > MAX_PATH) // +1 for NULL { TraceMsg(TF_BITBUCKET, "CheckFolderSizeAndDeleteability: path '%s' would exceed MAX_PATH if moved to the recycle bin!", pfdi->szPath); lRet = ERROR_FILENAME_EXCED_RANGE; // pass back the name of the non-deleteable file/folder in pfdi->szNonDeletableFile lstrcpyn(pfdi->szNonDeletableFile, pfdi->szPath, ARRAYSIZE(pfdi->szNonDeletableFile)); } else { if (pfdi->fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) { // its a directory, so recurse lRet = CheckFolderSizeAndDeleteability(pfdi->szPath, pfdi, pcs); } else { // its a file. ULARGE_INTEGER ulTemp; if (!_IsFileDeletable(pfdi->szPath)) { // we cant delete this file, find out why lRet = GetLastError(); ASSERT(lRet != ERROR_SUCCESS); // pass back the name of the non-deleteable file in pfdi->szNonDeletableFile lstrcpyn(pfdi->szNonDeletableFile, pfdi->szPath, ARRAYSIZE(pfdi->szNonDeletableFile)); } ulTemp.LowPart = pfdi->fd.nFileSizeLow; ulTemp.HighPart = pfdi->fd.nFileSizeHigh; pfdi->cbSize += ulTemp.QuadPart; } } } // remove the file/dir name we appended PathRemoveFileSpec(pfdi->szPath); } } while ((lRet == ERROR_SUCCESS) && FindNextFile(hfind, &pfdi->fd)); FindClose(hfind); // if this dir has no children, see if we can simply delete it if (!bHasChildren && !_IsDirectoryDeletable(pszDir)) { lRet = GetLastError(); ASSERT(lRet != ERROR_SUCCESS); // pass back the name of the non-deleteable file in pfdi->szNonDeletableFile lstrcpyn(pfdi->szNonDeletableFile, pszDir, ARRAYSIZE(pfdi->szNonDeletableFile)); } } else { // if FindFirstFile fails, check to see if the directory itself is deleteable if (!_IsDirectoryDeletable(pszDir)) { lRet = GetLastError(); ASSERT(lRet != ERROR_SUCCESS); // pass back the name of the non-deleteable file in pfdi->szNonDeletableFile lstrcpyn(pfdi->szNonDeletableFile, pszDir, ARRAYSIZE(pfdi->szNonDeletableFile)); } } } else { // if PathCombine fails, assume its because the path is too long lRet = ERROR_FILENAME_EXCED_RANGE; // pass back the name of the non-deleteable file in pfdi->szNonDeletableFile lstrcpyn(pfdi->szNonDeletableFile, pszDir, ARRAYSIZE(pfdi->szNonDeletableFile)); } return lRet; } // This takes over for what BBDeleteFile used to do (init, check, delete)... but does it with the ability to cancel BOOL DeleteFileBB(LPTSTR pszFile, INT *piRet, COPY_STATE *pcs, BOOL fIsDir, WIN32_FIND_DATA *pfd, HDPA *phdpaDeletedFiles) { ULARGE_INTEGER ulSize; int idDrive = DriveIDFromBBPath(pszFile); // Init if (!BBDeleteFileInit(pszFile, piRet)) return FALSE; // Check if we can delete this properly if (fIsDir) { DWORD dwError; FOLDERDELETEINFO fdi = {0}; fdi.cchBBDir = BBRecyclePathLength(idDrive); dwError = CheckFolderSizeAndDeleteability(pszFile, &fdi, pcs); if (dwError != ERROR_SUCCESS) { // if CheckFolderSizeAndDeleteability can fail if a file cant be recycled. // In this case, it appends the name of the file to pszFile, so we know who // the undeletable file is. if ((dwError == ERROR_FILENAME_EXCED_RANGE) || (dwError == ERROR_BUFFER_OVERFLOW)) { // it failed because a new path would be to long after being moveed under the "C:\recycler\sid" directory *piRet = BBDELETE_PATH_TOO_LONG; } else if (dwError == ERROR_CANCELLED) { // user hit the cancel button *piRet = BBDELETE_CANCELLED; } else { // must be a non-deletable directory, so set piRet = BBDELETE_CANNOT_DELETE so our caller // can detect this case, also pass the name of the non-deletable file back out so we can give // a better error message to the user *piRet = BBDELETE_CANNOT_DELETE; ASSERT(*fdi.szPath); lstrcpy(pszFile, fdi.szNonDeletableFile); } TraceMsg(TF_BITBUCKET, "DeleteFileBB : early error (%x) on file (%s)", dwError, pszFile); return FALSE; } ulSize.QuadPart = fdi.cbSize; } else { if (!_IsFileDeletable(pszFile)) { // We set piRet = BBDELETE_CANNOT_DELETE so our caller can detect // that this file cant be recycled. *piRet = BBDELETE_CANNOT_DELETE; return FALSE; } ulSize.LowPart = pfd->nFileSizeLow; ulSize.HighPart = pfd->nFileSizeHigh; } // check to make sure it's not bigger than the allowed wastebasket.. if (!BBCheckDeleteFileSize(idDrive, ulSize)) { // we set piRet = BBDELETE_SIZE_TOO_BIG so our caller can // detect the "file/folder too big" case *piRet = BBDELETE_SIZE_TOO_BIG; return FALSE; } return BBDeleteFile(pszFile, piRet, pcs->lpua, fIsDir, phdpaDeletedFiles, ulSize); } void StartCopyEngine(HANDLE *phEventRunning) { *phEventRunning = CreateEvent(CreateAllAccessSecurityAttributes(NULL, NULL, NULL), TRUE, FALSE, L"ShellCopyEngineRunning"); if (*phEventRunning) { SetEvent(*phEventRunning); } } void EndCopyEngine(HANDLE hEventRunning) { // signal that we're done. this will always trigger so there will be some weirdness if the // user does simultaneous copies, but it's not worth making a semaphore to keep track. HANDLE hEventFinished = CreateEvent(CreateAllAccessSecurityAttributes(NULL, NULL, NULL), TRUE, FALSE, L"ShellCopyEngineFinished"); if (hEventFinished) { SetEvent(hEventFinished); CloseHandle(hEventFinished); } if (hEventRunning) { // close out the event that says we're running. ResetEvent(hEventRunning); CloseHandle(hEventRunning); } } BOOL IsCopyEngineRunning() { BOOL bRet=FALSE; HANDLE hEventCopyRunning = OpenEvent(SYNCHRONIZE, FALSE, L"ShellCopyEngineRunning"); if (hEventCopyRunning) { // probe the event with a wait, if it times out the copy engine isn't running so we're done. bRet = (WAIT_OBJECT_0 == WaitForSingleObject(hEventCopyRunning, 0)); CloseHandle(hEventCopyRunning); } return bRet; }