| /* This Source Code Form is subject to the terms of the Mozilla Public | |
| * License, v. 2.0. If a copy of the MPL was not distributed with this file, | |
| * You can obtain one at http://mozilla.org/MPL/2.0/. | |
| */ | |
| /* Written in 2011, 2012 by John Ford <jhford@mozilla.com> | |
| * | |
| * This program is a replacement for the Posix 'rm' utility implemented as | |
| * a native Windows win32 application. Build using accompanying Makefile | |
| * make | |
| * or by running | |
| * cl rm.cpp | |
| */ | |
| #include <windows.h> | |
| #include <Strsafe.h> | |
| #include <string.h> | |
| #include <stdio.h> | |
| /* TODO: | |
| * -should the wow64fsredirection stuff be applicable to the whole app | |
| * or only per empty_directory invocation? | |
| * -support simple unix-style paths (i.e. map /c/dir1/file1 to c:\\dir1\\file1) | |
| * -return non-zero if no files are deleted and -f isn't specified | |
| * -multi-thread deletions | |
| */ | |
| /* This function takes an errNum, filename of the file being operated on and | |
| * a stdio file handle to the file where output should be printed | |
| */ | |
| void print_error(DWORD errNum, wchar_t* filename, FILE* fhandle){ | |
| wchar_t* msg; | |
| FormatMessageW( | |
| FORMAT_MESSAGE_ALLOCATE_BUFFER | | |
| FORMAT_MESSAGE_FROM_SYSTEM | | |
| FORMAT_MESSAGE_IGNORE_INSERTS, | |
| NULL, | |
| errNum, | |
| MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), | |
| (LPWSTR) &msg, | |
| 0, NULL); | |
| fwprintf(fhandle, L"\"%ws\" - %ws", filename, msg); | |
| } | |
| /* Remove an empty directory. This will fail if there are still files or | |
| * other directories in the directory specified by name | |
| */ | |
| BOOL del_directory(wchar_t* name, BOOL force, BOOL verbose, BOOL quiet){ | |
| BOOL rv = TRUE; | |
| if (verbose) { | |
| fwprintf(stdout, L"deleting directory \"%ws\"\n", name); | |
| } | |
| BOOL delStatus = RemoveDirectoryW(name); | |
| if (!delStatus) { | |
| rv = FALSE; | |
| if (!quiet) { | |
| print_error(GetLastError(), name, stderr); | |
| } | |
| } | |
| if (verbose) { | |
| fwprintf(stdout, L"deleted directory \"%ws\"\n", name); | |
| } | |
| return rv; | |
| } | |
| /* Remove a file. If force is true, read only and system file system | |
| * attributes are cleared before deleting the file | |
| */ | |
| BOOL del_file(wchar_t* name, BOOL force, BOOL verbose, BOOL quiet){ | |
| BOOL rv = TRUE; | |
| if (force) { | |
| DWORD fileAttr = GetFileAttributesW(name); | |
| if (fileAttr == INVALID_FILE_ATTRIBUTES) { | |
| if (!quiet) { | |
| fwprintf(stderr, L"invalid file attributes for \"%ws\"\n", name); | |
| } | |
| // Hmm, should I still try to delete the file? | |
| return FALSE; | |
| } | |
| if (fileAttr & FILE_ATTRIBUTE_DIRECTORY) { | |
| if (!quiet) { | |
| fwprintf(stderr, L"%ws is a directory, not a file\n", name); | |
| rv = FALSE; | |
| } | |
| } | |
| // Should really only have one SetFileAttributes | |
| if (fileAttr & FILE_ATTRIBUTE_SYSTEM || | |
| fileAttr & FILE_ATTRIBUTE_READONLY) { | |
| DWORD toSet = FILE_ATTRIBUTE_NORMAL; | |
| if (verbose) { | |
| wprintf(L"changing \"%ws\" file attributes to be removable\n", name); | |
| } | |
| DWORD setAttrStatus = SetFileAttributesW(name, toSet); | |
| if (!setAttrStatus){ | |
| rv = FALSE; | |
| if (!quiet) { | |
| print_error(setAttrStatus, name, stderr); | |
| } | |
| } | |
| } | |
| } | |
| if (verbose) { | |
| fwprintf(stdout, L"deleting \"%ws\"\n", name); | |
| } | |
| BOOL delStatus = DeleteFileW(name); | |
| if (!delStatus) { | |
| rv = FALSE; | |
| if (!quiet) | |
| print_error(GetLastError(), name, stderr); | |
| } else if (verbose) { | |
| fwprintf(stdout, L"deleted \"%ws\"\n", name); | |
| } | |
| return rv; | |
| } | |
| /* This function will recursively remove all files in a directory | |
| * then the directory itself. | |
| */ | |
| BOOL empty_directory(wchar_t* name, BOOL force, BOOL verbose, BOOL quiet){ | |
| BOOL rv = TRUE; | |
| DWORD ffStatus; | |
| WIN32_FIND_DATAW findFileData; | |
| // TODO: Don't waste so much memory! | |
| wchar_t dir[MAX_PATH]; | |
| HANDLE hFind = INVALID_HANDLE_VALUE; | |
| // Used while disabling Wow64 FS Redirection | |
| //Unused for now PVOID* wow64value = NULL; | |
| /* without a trailing \*, the listing for "c:\windows" would show info | |
| * for "c:\windows", not files *inside* of "c:\windows" | |
| */ | |
| StringCchCopyW(dir, MAX_PATH, name); // TODO: Check return | |
| StringCchCatW(dir, MAX_PATH, L"\\*"); | |
| /* We don't know what's going on, but Wow64 redirection | |
| * is not working quite right. Since nothing we have should | |
| * be in a location that needs Wow64, we should be fine to | |
| * ignore it | |
| */ | |
| //Wow64DisableWow64FsRedirection(wow64value); | |
| hFind = FindFirstFileW(dir, &findFileData); | |
| if (hFind == INVALID_HANDLE_VALUE) { | |
| rv = FALSE; | |
| if (!quiet) { | |
| print_error(GetLastError(), name, stderr); | |
| } | |
| return rv; | |
| } | |
| do { | |
| wchar_t fullName[MAX_PATH]; | |
| StringCchCopyW(fullName, MAX_PATH, name); | |
| StringCchCatW(fullName, MAX_PATH, L"\\"); | |
| StringCchCatW(fullName, MAX_PATH, findFileData.cFileName); | |
| if (findFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) { | |
| if (wcscmp(L".", findFileData.cFileName) != 0 && wcscmp(L"..", findFileData.cFileName) != 0){ | |
| if (!empty_directory(fullName, force, verbose, quiet)){ | |
| rv = FALSE; | |
| } | |
| } | |
| } else { | |
| if (!del_file(fullName, force, verbose, quiet)) { | |
| rv = FALSE; | |
| } | |
| } | |
| } while (FindNextFileW(hFind, &findFileData) != 0); | |
| /* if (!Wow64RevertWow64FsRedirection(wow64value)) { | |
| * if (!quiet) { | |
| * fwprintf(stderr, L"Error restoring Wow64 FS Redirection\n"); | |
| * } | |
| * return FALSE; | |
| * } | |
| */ | |
| ffStatus = GetLastError(); | |
| if (ffStatus != ERROR_NO_MORE_FILES) { | |
| print_error(ffStatus, findFileData.cFileName, stderr); | |
| rv = FALSE; | |
| } | |
| FindClose(hFind); | |
| del_directory(name, force, verbose, quiet); | |
| return rv; | |
| } | |
| /* This function is used to delete a file or directory specified by the | |
| * 'name' variable. The type of 'name' is figured out. If the recurse | |
| * option is TRUE, directories will be recursively emptied then deleted. | |
| * If force is TRUE, file attributes will be changed to allow the program | |
| * to delete the file. The verbose option will cause non-fatal error messages | |
| * to print to stderr. The quiet option will supress all but fatal | |
| * error messages | |
| */ | |
| BOOL del(wchar_t* name, BOOL recurse, BOOL force, BOOL verbose, BOOL quiet) { | |
| BOOL rv = TRUE; | |
| DWORD fileAttr = GetFileAttributesW(name); | |
| if (fileAttr == INVALID_FILE_ATTRIBUTES){ | |
| rv = FALSE; | |
| if (!quiet) { | |
| fwprintf(stderr, L"Invalid file attributes for \"%ws\"\n", name); | |
| } | |
| } else if (fileAttr & FILE_ATTRIBUTE_DIRECTORY) { | |
| if (recurse){ | |
| if (!empty_directory(name, force, verbose, quiet)){ | |
| rv = FALSE; | |
| } | |
| } else { | |
| if (!del_directory(name, force, verbose, quiet)){ | |
| rv = FALSE; | |
| } | |
| } | |
| } else { | |
| if (!del_file(name, force, verbose, quiet)){ | |
| rv = FALSE; | |
| } | |
| } | |
| return rv; | |
| } | |
| /* This struct is used by the command line parser */ | |
| struct node{ | |
| node *next; | |
| wchar_t* data; | |
| }; | |
| int wmain(int argc, wchar_t** argv) | |
| { | |
| int exitCode = 0; | |
| int i, j; | |
| BOOL verbose = FALSE, force = FALSE, quiet = FALSE, recurse = FALSE; | |
| BOOL onlyFiles = FALSE; | |
| struct node *previous = NULL; | |
| struct node *start = NULL; | |
| for (i = 1 ; i < argc ; i++) { | |
| if (wcscmp(argv[i], L"--") == 0) { | |
| /* Once we've seen '--' as an arg in the argv, | |
| * we want to interpret everything after that point | |
| * as a file | |
| */ | |
| onlyFiles = TRUE; | |
| } else if (!onlyFiles && argv[i][0] == L'-') { | |
| /* Before the -- appears (if ever), we assume that all | |
| * args starting with - are options. If I wanted to do | |
| * full words, I would have a check for the second char | |
| * being another - in a case and use that case and wsccmp | |
| * to set the options. | |
| */ | |
| for (j = 1 ; j < wcslen(argv[i]) ; j++) { | |
| switch(argv[i][j]){ | |
| case L'v': | |
| verbose = TRUE; | |
| break; | |
| case L'q': | |
| quiet = TRUE; | |
| break; | |
| case L'r': | |
| recurse = TRUE; | |
| break; | |
| case L'f': | |
| force = TRUE; | |
| break; | |
| default: | |
| fwprintf(stderr, L"The option -%wc is not valid\n", argv[i][j]); | |
| exitCode = 1; | |
| } | |
| } | |
| } else { | |
| /* If there are no more options, or we are forcing the rest of the | |
| * args to be files, we add them to the linked list. This list stores | |
| * args in reverse order to what is on the command line. | |
| */ | |
| struct node *nextNode = (struct node *) malloc(sizeof(struct node)); | |
| nextNode->data = argv[i]; | |
| nextNode->next = previous; | |
| previous = nextNode; | |
| start = nextNode; | |
| } | |
| } | |
| if (verbose && quiet) { | |
| fwprintf(stderr, L"The -q (quiet) and -v (verbose) options are incompatible\n"); | |
| exitCode = 1; | |
| } | |
| /* If everything is good, its time to start deleting the files. | |
| * We do this by traversing the linked list, deleting the current | |
| * node then deleting the current node before moving to the next | |
| */ | |
| if (!exitCode) { | |
| struct node* current = start; | |
| while (current != NULL){ | |
| BOOL result = del(current->data, recurse, force, verbose, quiet); | |
| if (!result) { | |
| exitCode = 1; | |
| } | |
| struct node* cleanup = current; | |
| current = current->next; | |
| free(cleanup); | |
| } | |
| } | |
| return exitCode; | |
| } | |