Is there a simple way to preview the files that rm will remove?

Question

Is there a simple way to evaluate what a given rm command will do when you do not understand it (such as not recognizing how the flags, variables, etc. interact)?

While ls helps catch problems in your rm parameters, ls -abc XYZ does not list the same files that would be affected by rm -abc XYZ. Ideally, I would like to type something like previewrm -abc XYZ and see what would be removed without actually removing anything, including using the -f flag.

I essentially want to run rm in test batch mode. That is, I want to see what actions it would take if it was run for real, preferably without touching it at all. Thus, testout 'rm -abc XYZ' might be the true ideal.

Answer 1

You could use rm -i to be prompted for every single file it will remove. You can pipe no into it repeatedly, (confusingly) using the yes command, to just view prompts (rejecting all of them):

yes no | rm -i files/globs/options

EDIT in response to comments by @user63051

If you are concerned about dangerous flag combinations, you can specify rm -i -- and anything after that will NOT be treated as an option. This of course means that for the -r flag to work, you need to put it before --.

Another suggestion, if you want to try it, is to create a dummy user that doesn't belong to any of the existing groups. If the others permissions of your files don't include write permission (they usually don't unless you specifically want that), you can just login as the other user (su dummy) and do the rm command. It won't have permissions to delete anything so it will simply complain about it. You can also do this to use the suggestion above (as double protection).

I should warn you that all the options that call rm are a bit dangerous. I usually just prefix the entire command I want to run with echo to see what arguments will bash give to the command (how it expands the wildcards and which files it finds). Then just remove echo if everything looks fine. Notice that this won't list contents of recursively found files with -r but you will see the directory it wants to destroy.

In essence - use echo if you want to see what it does. Use -- for protection from runaway flags. Use -i just in case, it will ask about every file and you will notice if it asks about something you don't want to remove. Only if you really want to produce a list, one file per line, it makes sense to do anything else.

Answer 2

When I want to do this, I use 'find' as a wrapper around rm. This is better (for the use case you have in mind) because:

• It's more flexible in terms of matching multiple patterns
• It can handle more filenames than a shell wildcard in subdirs (/.tmp etc.)
• You can do everything rm can do, since it wraps rm, but more besides, such as printing the entire rm command.
• It doesn't call rm too often, when you use + (rather than ;) as part of the -exec args, so it's not really much less efficient than just running rm.

To list files to you might want to delete:

find . -name \*.tmp

To preview deletion:

find . -name \*.tmp -exec echo rm \{\} +

To actually delete them, just remove the 'echo':

find . -name \*.tmp -exec rm \{\} +

Or, you can do more advanced search/delete commands, like this one:

find . \( -name \*.tmp -o -iname cache -o -iname temp \) -exec rm \{\} +

You can also just pipe the output of find into "xargs rm", but use NULs to separate filenames, like so:

find . -name \*.tmp -print0 | xargs -0 rm

Answer 3

The simple way is to use rm -i the way @orion describes. If you want something that will not remove anything but doesn't tweak rm's flags, you can always build your own version of rm, let's call it preview-rm. It's really pretty straightforward, and you can even do it without touching the actual rm source files:

1. Find the source to your system's version of rm. You may need to download a source package, or whatever. GNU rm is part of the "core utilities" and consists of two C files, rm.c and remove.c, and several header files. Once you are set up to compile system utilities, the rest is trivial.

2. Create the file mockrm.c with the following contents. The only non-trivial part is that some versions of rm detect directories by trying to unlink() them and checking for error, so we need to ensure this works correctly:

   #include <stdio.h>
   #include <sys/stat.h>
   #include <errno.h>
   
   int unlink(char *s)
   {
       struct stat sbuf;
       lstat(s, &sbuf);
       /* Simulate unlink error if we're asked to unlink a directory. */
       if (S_ISDIR(sbuf.st_mode)) {
           return EISDIR;
       }
   
       puts(s);
       return 0;
   }    
   
   int rmdir(char *d)
   {
     printf("%s (dir)\n", d);
     return 0;
   }
   

3. Finally, compile your preview-rm executable like this:

   % cc rm.c remove.c mockrm.c -o preview-rm
   

   The functions in mockrm.c will be linked in precedence to the system calls provided by the C library, giving you a toothless clone of rm that you can use for preview. (Do test that it really works before you point it at important files.)

Alternative: If you're on a system that supports the LD_PRELOAD feature (OS X doesn't), you might be able to get the same effect by compiling mockrm.c into a shared library (.so) and forcing it to be loaded by the real rm:

% LD_PRELOAD=/path/to/mockrm.so rm -flags files

But since you need to change the command invocation anyway, why not just create a separate executable as shown above. I know it'd be a little nervous pointing the real rm at valuable files (Edit: and if you update your OS, you'd have to test again and make sure rm hasn't changed in a way that disabled the wrapper.)

Answer 4

Use the i switch. See man rm:

-i   prompt before every removal

Answer 5

If not using the -r option, then you can list the files with

ls -ld <parameters>

or your favorite combination of ls options, as long as it includes -d. The discrepancy between the command line arguments and what ls shows is that if one of the arguments is a directory, ls shows its contents.

If you just want to list the names, echo <parameters> will do, or if you prefer them on separate lines:

printf '%s\n' <parameters>

This list is ambiguous in case a file name contains a newline; this is a concern for automated processing but not when you know that the files weren't produced by a potentially hostile party.

If using the -r option, call find to traverse the directories recursively:

find <parameters>