/* [<][>][^][v][top][bottom][index][help] */
DEFINITIONS
This source file includes following definitions.
- diagnose_leading_hyphen
- usage
- rm_option_init
- main
/* `rm' file deletion utility for GNU.
Copyright (C) 88, 90, 91, 1994-2007 Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software Foundation,
Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
/* Written by Paul Rubin, David MacKenzie, and Richard Stallman.
Reworked to use chdir and avoid recursion by Jim Meyering. */
/* Implementation overview:
In the `usual' case, RM saves no state for directories it is processing.
When a removal fails (either due to an error or to an interactive `no'
reply), the failure is noted (see description of `ht' in remove.c's
remove_cwd_entries function) so that when/if the containing directory
is reopened, RM doesn't try to remove the entry again.
RM may delete arbitrarily deep hierarchies -- even ones in which file
names (from root to leaf) are longer than the system-imposed maximum.
It does this by using chdir to change to each directory in turn before
removing the entries in that directory.
RM detects directory cycles lazily. See lib/cycle-check.c.
RM is careful to avoid forming full file names whenever possible.
A full file name is formed only when it is about to be used -- e.g.
in a diagnostic or in an interactive-mode prompt.
RM minimizes the number of lstat system calls it makes. On systems
that have valid d_type data in directory entries, RM makes only one
lstat call per command line argument -- regardless of the depth of
the hierarchy. */
#include <config.h>
#include <stdio.h>
#include <getopt.h>
#include <sys/types.h>
#include <assert.h>
#include "system.h"
#include "argmatch.h"
#include "error.h"
#include "lstat.h"
#include "quote.h"
#include "quotearg.h"
#include "remove.h"
#include "root-dev-ino.h"
#include "yesno.h"
/* The official name of this program (e.g., no `g' prefix). */
#define PROGRAM_NAME "rm"
#define AUTHORS \
"Paul Rubin", "David MacKenzie, Richard Stallman", "Jim Meyering"
/* Name this program was run with. */
char *program_name;
/* For long options that have no equivalent short option, use a
non-character as a pseudo short option, starting with CHAR_MAX + 1. */
enum
{
INTERACTIVE_OPTION = CHAR_MAX + 1,
ONE_FILE_SYSTEM,
NO_PRESERVE_ROOT,
PRESERVE_ROOT,
PRESUME_INPUT_TTY_OPTION
};
enum interactive_type
{
interactive_never, /* 0: no option or --interactive=never */
interactive_once, /* 1: -I or --interactive=once */
interactive_always /* 2: default, -i or --interactive=always */
};
static struct option const long_opts[] =
{
{"directory", no_argument, NULL, 'd'},
{"force", no_argument, NULL, 'f'},
{"interactive", optional_argument, NULL, INTERACTIVE_OPTION},
{"one-file-system", no_argument, NULL, ONE_FILE_SYSTEM},
{"no-preserve-root", no_argument, NULL, NO_PRESERVE_ROOT},
{"preserve-root", no_argument, NULL, PRESERVE_ROOT},
/* This is solely for testing. Do not document. */
/* It is relatively difficult to ensure that there is a tty on stdin.
Since rm acts differently depending on that, without this option,
it'd be harder to test the parts of rm that depend on that setting. */
{"-presume-input-tty", no_argument, NULL, PRESUME_INPUT_TTY_OPTION},
{"recursive", no_argument, NULL, 'r'},
{"verbose", no_argument, NULL, 'v'},
{GETOPT_HELP_OPTION_DECL},
{GETOPT_VERSION_OPTION_DECL},
{NULL, 0, NULL, 0}
};
static char const *const interactive_args[] =
{
"never", "no", "none",
"once",
"always", "yes", NULL
};
static enum interactive_type const interactive_types[] =
{
interactive_never, interactive_never, interactive_never,
interactive_once,
interactive_always, interactive_always
};
ARGMATCH_VERIFY (interactive_args, interactive_types);
/* Advise the user about invalid usages like "rm -foo" if the file
"-foo" exists, assuming ARGC and ARGV are as with `main'. */
static void
diagnose_leading_hyphen (int argc, char **argv)
{
/* OPTIND is unreliable, so iterate through the arguments looking
for a file name that looks like an option. */
int i;
for (i = 1; i < argc; i++)
{
char const *arg = argv[i];
struct stat st;
if (arg[0] == '-' && arg[1] && lstat (arg, &st) == 0)
{
fprintf (stderr,
_("Try `%s ./%s' to remove the file %s.\n"),
argv[0],
quotearg_n_style (1, shell_quoting_style, arg),
quote (arg));
break;
}
}
}
void
usage (int status)
{
if (status != EXIT_SUCCESS)
fprintf (stderr, _("Try `%s --help' for more information.\n"),
program_name);
else
{
printf (_("Usage: %s [OPTION]... FILE...\n"), program_name);
fputs (_("\
Remove (unlink) the FILE(s).\n\
\n\
-f, --force ignore nonexistent files, never prompt\n\
-i prompt before every removal\n\
"), stdout);
fputs (_("\
-I prompt once before removing more than three files, or\n\
when removing recursively. Less intrusive than -i,\n\
while still giving protection against most mistakes\n\
--interactive[=WHEN] prompt according to WHEN: never, once (-I), or\n\
always (-i). Without WHEN, prompt always\n\
"), stdout);
fputs (_("\
--one-file-system when removing a hierarchy recursively, skip any\n\
directory that is on a file system different from\n\
that of the corresponding command line argument\n\
"), stdout);
fputs (_("\
--no-preserve-root do not treat `/' specially\n\
--preserve-root do not remove `/' (default)\n\
-r, -R, --recursive remove directories and their contents recursively\n\
-v, --verbose explain what is being done\n\
"), stdout);
fputs (HELP_OPTION_DESCRIPTION, stdout);
fputs (VERSION_OPTION_DESCRIPTION, stdout);
fputs (_("\
\n\
By default, rm does not remove directories. Use the --recursive (-r or -R)\n\
option to remove each listed directory, too, along with all of its contents.\n\
"), stdout);
printf (_("\
\n\
To remove a file whose name starts with a `-', for example `-foo',\n\
use one of these commands:\n\
%s -- -foo\n\
\n\
%s ./-foo\n\
"),
program_name, program_name);
fputs (_("\
\n\
Note that if you use rm to remove a file, it is usually possible to recover\n\
the contents of that file. If you want more assurance that the contents are\n\
truly unrecoverable, consider using shred.\n\
"), stdout);
printf (_("\nReport bugs to <%s>.\n"), PACKAGE_BUGREPORT);
}
exit (status);
}
static void
rm_option_init (struct rm_options *x)
{
x->ignore_missing_files = false;
x->interactive = RMI_SOMETIMES;
x->one_file_system = false;
x->recursive = false;
x->root_dev_ino = NULL;
x->stdin_tty = isatty (STDIN_FILENO);
x->verbose = false;
/* Since this program exits immediately after calling `rm', rm need not
expend unnecessary effort to preserve the initial working directory. */
x->require_restore_cwd = false;
}
int
main (int argc, char **argv)
{
bool preserve_root = true;
struct rm_options x;
bool prompt_once = false;
int c;
initialize_main (&argc, &argv);
program_name = argv[0];
setlocale (LC_ALL, "");
bindtextdomain (PACKAGE, LOCALEDIR);
textdomain (PACKAGE);
atexit (close_stdout);
rm_option_init (&x);
while ((c = getopt_long (argc, argv, "dfirvIR", long_opts, NULL)) != -1)
{
switch (c)
{
case 'd':
/* Ignore this option, for backward compatibility with
coreutils 5.92. FIXME: Some time after 2005, change this
to report an error (or perhaps behave like FreeBSD does)
instead of ignoring the option. */
break;
case 'f':
x.interactive = RMI_NEVER;
x.ignore_missing_files = true;
prompt_once = false;
break;
case 'i':
x.interactive = RMI_ALWAYS;
x.ignore_missing_files = false;
prompt_once = false;
break;
case 'I':
x.interactive = RMI_NEVER;
x.ignore_missing_files = false;
prompt_once = true;
break;
case 'r':
case 'R':
x.recursive = true;
break;
case INTERACTIVE_OPTION:
{
int i;
if (optarg)
i = XARGMATCH ("--interactive", optarg, interactive_args,
interactive_types);
else
i = interactive_always;
switch (i)
{
case interactive_never:
x.interactive = RMI_NEVER;
prompt_once = false;
break;
case interactive_once:
x.interactive = RMI_SOMETIMES;
x.ignore_missing_files = false;
prompt_once = true;
break;
case interactive_always:
x.interactive = RMI_ALWAYS;
x.ignore_missing_files = false;
prompt_once = false;
break;
}
break;
}
case ONE_FILE_SYSTEM:
x.one_file_system = true;
break;
case NO_PRESERVE_ROOT:
preserve_root = false;
break;
case PRESERVE_ROOT:
preserve_root = true;
break;
case PRESUME_INPUT_TTY_OPTION:
x.stdin_tty = true;
break;
case 'v':
x.verbose = true;
break;
case_GETOPT_HELP_CHAR;
case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
default:
diagnose_leading_hyphen (argc, argv);
usage (EXIT_FAILURE);
}
}
if (argc <= optind)
{
if (x.ignore_missing_files)
exit (EXIT_SUCCESS);
else
{
error (0, 0, _("missing operand"));
usage (EXIT_FAILURE);
}
}
if (x.recursive & preserve_root)
{
static struct dev_ino dev_ino_buf;
x.root_dev_ino = get_root_dev_ino (&dev_ino_buf);
if (x.root_dev_ino == NULL)
error (EXIT_FAILURE, errno, _("failed to get attributes of %s"),
quote ("/"));
}
size_t n_files = argc - optind;
char const *const *file = (char const *const *) argv + optind;
if (prompt_once && (x.recursive || 3 < n_files))
{
fprintf (stderr,
(x.recursive
? _("%s: remove all arguments recursively? ")
: _("%s: remove all arguments? ")),
program_name);
if (!yesno ())
exit (EXIT_SUCCESS);
}
enum RM_status status = rm (n_files, file, &x);
assert (VALID_STATUS (status));
exit (status == RM_ERROR ? EXIT_FAILURE : EXIT_SUCCESS);
}