/* install - copy files and set attributes
- Copyright (C) 89, 90, 91, 1995-2005 Free Software Foundation, Inc.
+ Copyright (C) 89, 90, 91, 1995-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
#include <signal.h>
#include <pwd.h>
#include <grp.h>
+#include <selinux/selinux.h>
#include "system.h"
#include "backupfile.h"
#include "error.h"
#include "cp-hash.h"
#include "copy.h"
-#include "dirname.h"
#include "filenamecat.h"
+#include "mkancesdirs.h"
#include "mkdir-p.h"
#include "modechange.h"
#include "quote.h"
+#include "quotearg.h"
+#include "savewd.h"
+#include "stat-time.h"
#include "utimens.h"
#include "xstrtol.h"
# include <sys/wait.h>
#endif
+static int selinux_enabled = 0;
+static bool use_default_selinux_context = true;
+
#if ! HAVE_ENDGRENT
# define endgrent() ((void) 0)
#endif
/* Number of bytes of a file to copy at a time. */
#define READ_SIZE (32 * 1024)
-static bool change_timestamps (const char *from, const char *to);
+static bool change_timestamps (struct stat const *from_sb, char const *to);
static bool change_attributes (char const *name);
static bool copy_file (const char *from, const char *to,
const struct cp_options *x);
-static bool install_file_in_file_parents (char const *from, char const *to,
- struct cp_options const *x);
+static bool install_file_in_file_parents (char const *from, char *to,
+ struct cp_options *x);
static bool install_file_in_dir (const char *from, const char *to_dir,
const struct cp_options *x);
static bool install_file_in_file (const char *from, const char *to,
const struct cp_options *x);
static void get_ids (void);
static void strip (char const *name);
+static void announce_mkdir (char const *dir, void *options);
+static int make_ancestor (char const *dir, char const *component,
+ void *options);
void usage (int status);
/* The name this program was run with, for error messages. */
/* The group ID corresponding to `group_name'. */
static gid_t group_id;
-/* The permissions to which the files will be set. The umask has
+#define DEFAULT_MODE (S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)
+
+/* The file mode bits to which non-directory files will be set. The umask has
no effect. */
-static mode_t mode = S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH;
+static mode_t mode = DEFAULT_MODE;
+
+/* Similar, but for directories. */
+static mode_t dir_mode = DEFAULT_MODE;
+
+/* The file mode bits that the user cares about. This should be a
+ superset of DIR_MODE and a subset of CHMOD_MODE_BITS. This matters
+ for directories, since otherwise directories may keep their S_ISUID
+ or S_ISGID bits. */
+static mode_t dir_mode_bits = CHMOD_MODE_BITS;
/* If true, strip executable files after copying them. */
static bool strip_files;
/* If true, install a directory instead of a regular file. */
static bool dir_arg;
+/* For long options that have no equivalent short option, use a
+ non-character as a pseudo short option, starting with CHAR_MAX + 1. */
+enum
+{
+ PRESERVE_CONTEXT_OPTION = CHAR_MAX + 1
+};
+
static struct option const long_options[] =
{
{"backup", optional_argument, NULL, 'b'},
+ {GETOPT_SELINUX_CONTEXT_OPTION_DECL},
{"directory", no_argument, NULL, 'd'},
{"group", required_argument, NULL, 'g'},
{"mode", required_argument, NULL, 'm'},
{"no-target-directory", no_argument, NULL, 'T'},
{"owner", required_argument, NULL, 'o'},
{"preserve-timestamps", no_argument, NULL, 'p'},
+ {"preserve-context", no_argument, NULL, PRESERVE_CONTEXT_OPTION},
+ /* Continue silent support for --preserve_context until Jan 2008. FIXME-obs
+ After that, FIXME-obs: warn in, say, late 2008, and disable altogether
+ a year or two later. */
+ {"preserve_context", no_argument, NULL, PRESERVE_CONTEXT_OPTION},
{"strip", no_argument, NULL, 's'},
{"suffix", required_argument, NULL, 'S'},
{"target-directory", required_argument, NULL, 't'},
- {"version-control", required_argument, NULL, 'V'}, /* Deprecated. FIXME. */
{"verbose", no_argument, NULL, 'v'},
{GETOPT_HELP_OPTION_DECL},
{GETOPT_VERSION_OPTION_DECL},
x->preserve_mode = false;
x->preserve_timestamps = false;
x->require_preserve = false;
+ x->require_preserve_context = false;
x->recursive = false;
x->sparse_mode = SPARSE_AUTO;
x->symbolic_link = false;
x->mode = S_IRUSR | S_IWUSR;
x->stdin_tty = false;
- x->umask_kill = 0;
x->update = false;
+ x->preserve_security_context = false;
x->verbose = false;
x->dest_info = NULL;
x->src_info = NULL;
}
+/* Modify file context to match the specified policy.
+ If an error occurs the file will remain with the default directory
+ context. */
+static void
+setdefaultfilecon (char const *file)
+{
+ struct stat st;
+ security_context_t scontext = NULL;
+ if (selinux_enabled != 1)
+ {
+ /* Indicate no context found. */
+ return;
+ }
+ if (lstat (file, &st) != 0)
+ return;
+
+ /* If there's an error determining the context, or it has none,
+ return to allow default context */
+ if ((matchpathcon (file, st.st_mode, &scontext) != 0) ||
+ (strcmp (scontext, "<<none>>") == 0))
+ {
+ if (scontext != NULL)
+ freecon (scontext);
+ return;
+ }
+
+ if (lsetfilecon (file, scontext) < 0 && errno != ENOTSUP)
+ error (0, errno,
+ _("warning: %s: failed to change context to %s"),
+ quotearg_colon (file), scontext);
+
+ freecon (scontext);
+ return;
+}
+
/* FILE is the last operand of this command. Return true if FILE is a
directory. But report an error there is a problem accessing FILE,
or if FILE does not exist but would have to refer to an existing
static bool
target_directory_operand (char const *file)
{
- char const *b = base_name (file);
+ char const *b = last_component (file);
size_t blen = strlen (b);
bool looks_like_a_dir = (blen == 0 || ISSLASH (b[blen - 1]));
struct stat st;
return is_a_dir;
}
+/* Process a command-line file name, for the -d option. */
+static int
+process_dir (char *dir, struct savewd *wd, void *options)
+{
+ return (make_dir_parents (dir, wd,
+ make_ancestor, options,
+ dir_mode, announce_mkdir,
+ dir_mode_bits, owner_id, group_id, false)
+ ? EXIT_SUCCESS
+ : EXIT_FAILURE);
+}
+
int
main (int argc, char **argv)
{
int optc;
- bool ok = true;
+ int exit_status = EXIT_SUCCESS;
const char *specified_mode = NULL;
bool make_backups = false;
char *backup_suffix_string;
bool no_target_directory = false;
int n_files;
char **file;
+ security_context_t scontext = NULL;
+ /* set iff kernel has extra selinux system calls */
+ selinux_enabled = (0 < is_selinux_enabled ());
initialize_main (&argc, &argv);
program_name = argv[0];
we'll actually use backup_suffix_string. */
backup_suffix_string = getenv ("SIMPLE_BACKUP_SUFFIX");
- while ((optc = getopt_long (argc, argv, "bcsDdg:m:o:pt:TvV:S:", long_options,
+ while ((optc = getopt_long (argc, argv, "bcsDdg:m:o:pt:TvS:Z:", long_options,
NULL)) != -1)
{
switch (optc)
{
- case 'V': /* FIXME: this is deprecated. Remove it in 2001. */
- error (0, 0,
- _("warning: --version-control (-V) is obsolete; support for\
- it\nwill be removed in some future release. Use --backup=%s instead."
- ), optarg);
- /* Fall through. */
-
case 'b':
make_backups = true;
if (optarg)
case 'T':
no_target_directory = true;
break;
+
+ case PRESERVE_CONTEXT_OPTION:
+ if ( ! selinux_enabled)
+ {
+ error (0, 0, _("Warning: ignoring --preserve-context; "
+ "this kernel is not SELinux-enabled."));
+ break;
+ }
+ x.preserve_security_context = true;
+ use_default_selinux_context = false;
+ break;
+ case 'Z':
+ if ( ! selinux_enabled)
+ {
+ error (0, 0, _("Warning: ignoring --context (-Z); "
+ "this kernel is not SELinux-enabled."));
+ break;
+ }
+ scontext = optarg;
+ use_default_selinux_context = false;
+ break;
case_GETOPT_HELP_CHAR;
case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
default:
error (EXIT_FAILURE, 0,
_("target directory not allowed when installing a directory"));
+ if (x.preserve_security_context && scontext != NULL)
+ error (EXIT_FAILURE, 0,
+ _("cannot force target context to %s and preserve it"),
+ quote (scontext));
+
if (backup_suffix_string)
simple_backup_suffix = xstrdup (backup_suffix_string);
version_control_string)
: no_backups);
+ if (scontext && setfscreatecon (scontext) < 0)
+ error (EXIT_FAILURE, errno,
+ _("failed to set default file creation context to %s"),
+ quote (scontext));
+
n_files = argc - optind;
file = argv + optind;
struct mode_change *change = mode_compile (specified_mode);
if (!change)
error (EXIT_FAILURE, 0, _("invalid mode %s"), quote (specified_mode));
- mode = mode_adjust (0, change, 0);
+ mode = mode_adjust (0, false, 0, change, NULL);
+ dir_mode = mode_adjust (0, true, 0, change, &dir_mode_bits);
free (change);
}
get_ids ();
if (dir_arg)
- {
- int i;
- bool cwd_not_restored = false;
- for (i = 0; i < n_files; i++)
- {
- bool different_cwd;
- if (cwd_not_restored && IS_RELATIVE_FILE_NAME (argv[optind]))
- {
- error (0, 0,
- _("unable to create relative-named directory, %s,"
- " due to prior failure to return to working directory"),
- quote (argv[optind]));
- ok = false;;
- continue;
- }
-
- ok &=
- make_dir_parents (file[i], mode, mode, owner_id, group_id, false,
- (x.verbose ? _("creating directory %s") : NULL),
- &different_cwd);
- cwd_not_restored |= different_cwd;
- }
- }
+ exit_status = savewd_process_files (n_files, file, process_dir, &x);
else
{
/* FIXME: it's a little gross that this initialization is
if (!target_directory)
{
- if (mkdir_and_install)
- ok = install_file_in_file_parents (file[0], file[1], &x);
- else
- ok = install_file_in_file (file[0], file[1], &x);
+ if (! (mkdir_and_install
+ ? install_file_in_file_parents (file[0], file[1], &x)
+ : install_file_in_file (file[0], file[1], &x)))
+ exit_status = EXIT_FAILURE;
}
else
{
int i;
dest_info_init (&x);
for (i = 0; i < n_files; i++)
- {
- ok &= install_file_in_dir (file[i], target_directory, &x);
- }
+ if (! install_file_in_dir (file[i], target_directory, &x))
+ exit_status = EXIT_FAILURE;
}
}
- exit (ok ? EXIT_SUCCESS : EXIT_FAILURE);
+ exit (exit_status);
}
/* Copy file FROM onto file TO, creating any missing parent directories of TO.
Return true if successful. */
static bool
-install_file_in_file_parents (char const *from, char const *to,
- struct cp_options const *x)
+install_file_in_file_parents (char const *from, char *to,
+ struct cp_options *x)
{
- char *dest_dir = dir_name (to);
- bool ok = true;
+ bool save_working_directory =
+ ! (IS_ABSOLUTE_FILE_NAME (from) && IS_ABSOLUTE_FILE_NAME (to));
+ int status = EXIT_SUCCESS;
- /* Make sure that the parent of the destination is a directory. */
- if (! STREQ (dest_dir, "."))
+ struct savewd wd;
+ savewd_init (&wd);
+ if (! save_working_directory)
+ savewd_finish (&wd);
+
+ if (mkancesdirs (to, &wd, make_ancestor, x) == -1)
{
- /* Someone will probably ask for a new option or three to specify
- owner, group, and permissions for parent directories. Remember
- that this option is intended mainly to help installers when the
- distribution doesn't provide proper install rules. */
- mode_t dir_mode = S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH;
- bool different_cwd;
- ok = make_dir_parents (dest_dir, dir_mode, dir_mode,
- owner_id, group_id, true,
- (x->verbose ? _("creating directory %s") : NULL),
- &different_cwd);
- /* Ignore different_cwd, since this function is called at most once. */
+ error (0, errno, _("cannot create directory %s"), to);
+ status = EXIT_FAILURE;
}
- free (dest_dir);
-
- if (ok)
- ok = install_file_in_file (from, to, x);
+ if (save_working_directory)
+ {
+ int restore_result = savewd_restore (&wd, status);
+ int restore_errno = errno;
+ savewd_finish (&wd);
+ if (EXIT_SUCCESS < restore_result)
+ return false;
+ if (restore_result < 0 && status == EXIT_SUCCESS)
+ {
+ error (0, restore_errno, _("cannot create directory %s"), to);
+ return false;
+ }
+ }
- return ok;
+ return (status == EXIT_SUCCESS && install_file_in_file (from, to, x));
}
/* Copy file FROM onto file TO and give TO the appropriate
install_file_in_file (const char *from, const char *to,
const struct cp_options *x)
{
+ struct stat from_sb;
+ if (x->preserve_timestamps && stat (from, &from_sb) != 0)
+ {
+ error (0, errno, _("cannot stat %s"), quote (from));
+ return false;
+ }
if (! copy_file (from, to, x))
return false;
if (strip_files)
strip (to);
- if (! change_attributes (to))
+ if (x->preserve_timestamps && (strip_files || ! S_ISREG (from_sb.st_mode))
+ && ! change_timestamps (&from_sb, to))
return false;
- if (x->preserve_timestamps)
- return change_timestamps (from, to);
- return true;
+ return change_attributes (to);
}
/* Copy file FROM into directory TO_DIR, keeping its same name,
install_file_in_dir (const char *from, const char *to_dir,
const struct cp_options *x)
{
- const char *from_base = base_name (from);
+ const char *from_base = last_component (from);
char *to = file_name_concat (to_dir, from_base, NULL);
bool ret = install_file_in_file (from, to, x);
free (to);
static bool
change_attributes (char const *name)
{
- bool ok = true;
-
+ bool ok = false;
/* chown must precede chmod because on some systems,
chown clears the set[ug]id bits for non-superusers,
resulting in incorrect permissions.
the install command is that the file is supposed to end up with
precisely the attributes that the user specified (or defaulted).
If the file doesn't end up with the group they asked for, they'll
- want to know. But AFS returns EPERM when you try to change a
- file's group; thus the kludge. */
+ want to know. */
- if (chown (name, owner_id, group_id) != 0
-#ifdef AFS
- && errno != EPERM
-#endif
- )
- {
- error (0, errno, _("cannot change ownership of %s"), quote (name));
- ok = false;
- }
+ if (! (owner_id == (uid_t) -1 && group_id == (gid_t) -1)
+ && chown (name, owner_id, group_id) != 0)
+ error (0, errno, _("cannot change ownership of %s"), quote (name));
+ else if (chmod (name, mode) != 0)
+ error (0, errno, _("cannot change permissions of %s"), quote (name));
+ else
+ ok = true;
- if (ok && chmod (name, mode) != 0)
- {
- error (0, errno, _("cannot change permissions of %s"), quote (name));
- ok = false;
- }
+ if (use_default_selinux_context)
+ setdefaultfilecon (name);
return ok;
}
Return true if successful. */
static bool
-change_timestamps (const char *from, const char *to)
+change_timestamps (struct stat const *from_sb, char const *to)
{
- struct stat stb;
struct timespec timespec[2];
+ timespec[0] = get_stat_atime (from_sb);
+ timespec[1] = get_stat_mtime (from_sb);
- if (stat (from, &stb))
- {
- error (0, errno, _("cannot obtain time stamps for %s"), quote (from));
- return false;
- }
-
- timespec[0].tv_sec = stb.st_atime;
- timespec[0].tv_nsec = TIMESPEC_NS (stb.st_atim);
- timespec[1].tv_sec = stb.st_mtime;
- timespec[1].tv_nsec = TIMESPEC_NS (stb.st_mtim);
if (utimens (to, timespec))
{
error (0, errno, _("cannot set time stamps for %s"), quote (to));
error (EXIT_FAILURE, errno, _("cannot run strip"));
break;
default: /* Parent. */
- /* Parent process. */
- while (pid != wait (&status)) /* Wait for kid to finish. */
- /* Do nothing. */ ;
- if (status)
- error (EXIT_FAILURE, 0, _("strip failed"));
+ if (waitpid (pid, &status, 0) < 0)
+ error (EXIT_FAILURE, errno, _("waiting for strip"));
+ else if (! WIFEXITED (status) || WEXITSTATUS (status))
+ error (EXIT_FAILURE, 0, _("strip process terminated abnormally"));
break;
}
}
group_id = (gid_t) -1;
}
+/* Report that directory DIR was made, if OPTIONS requests this. */
+static void
+announce_mkdir (char const *dir, void *options)
+{
+ struct cp_options const *x = options;
+ if (x->verbose)
+ error (0, 0, _("creating directory %s"), quote (dir));
+}
+
+/* Make ancestor directory DIR, whose last file name component is
+ COMPONENT, with options OPTIONS. Assume the working directory is
+ COMPONENT's parent. */
+static int
+make_ancestor (char const *dir, char const *component, void *options)
+{
+ int r = mkdir (component, DEFAULT_MODE);
+ if (r == 0)
+ announce_mkdir (dir, options);
+ return r;
+}
+
void
usage (int status)
{
Mandatory arguments to long options are mandatory for short options too.\n\
"), stdout);
fputs (_("\
- --backup[=CONTROL] make a backup of each existing destination file\n\
+ --backup[=CONTROL] make a backup of each existing destination file\n\
-b like --backup but does not accept an argument\n\
-c (ignored)\n\
-d, --directory treat all arguments as directory names; create all\n\
-p, --preserve-timestamps apply access/modification times of SOURCE files\n\
to corresponding destination files\n\
-s, --strip strip symbol tables\n\
- -S, --suffix=SUFFIX override the usual backup suffix\n\
+ -S, --suffix=SUFFIX override the usual backup suffix\n\
-t, --target-directory=DIRECTORY copy all SOURCE arguments into DIRECTORY\n\
-T, --no-target-directory treat DEST as a normal file\n\
-v, --verbose print the name of each directory as it is created\n\
"), stdout);
+ fputs (_("\
+ --preserve-context preserve SELinux security context\n\
+ -Z, --context=CONTEXT set SELinux security context of files and directories\n\
+"), stdout);
+
fputs (HELP_OPTION_DESCRIPTION, stdout);
fputs (VERSION_OPTION_DESCRIPTION, stdout);
fputs (_("\
existing, nil numbered if numbered backups exist, simple otherwise\n\
simple, never always make simple backups\n\
"), stdout);
- printf (_("\nReport bugs to <%s>.\n"), PACKAGE_BUGREPORT);
+ emit_bug_reporting_address ();
}
exit (status);
}
projects / platform / upstream / coreutils.git / blobdiff