coreutils-8.25HEADcoreutils-8.25master

1 files changed, 728 insertions, 383 deletions

diff --git a/src/install.c b/src/install.c
index 0457751..2ff279c 100644
--- a/src/install.c
+++ b/src/install.c
@@ -1,10 +1,10 @@
 /* install - copy files and set attributes
-   Copyright (C) 89, 90, 91, 1995-2007 Free Software Foundation, Inc.
+   Copyright (C) 1989-2016 Free Software Foundation, Inc.
 
-   This program is free software; you can redistribute it and/or modify
+   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.
+   the Free Software Foundation, either version 3 of the License, 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
@@ -12,8 +12,7 @@
    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.  */
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 /* Written by David MacKenzie <djm@gnu.ai.mit.edu> */
 
@@ -24,6 +23,8 @@
 #include <signal.h>
 #include <pwd.h>
 #include <grp.h>
+#include <selinux/selinux.h>
+#include <sys/wait.h>
 
 #include "system.h"
 #include "backupfile.h"
@@ -31,23 +32,24 @@
 #include "cp-hash.h"
 #include "copy.h"
 #include "filenamecat.h"
+#include "full-read.h"
 #include "mkancesdirs.h"
 #include "mkdir-p.h"
 #include "modechange.h"
+#include "prog-fprintf.h"
 #include "quote.h"
 #include "savewd.h"
 #include "stat-time.h"
 #include "utimens.h"
 #include "xstrtol.h"
 
-/* The official name of this program (e.g., no `g' prefix).  */
+/* The official name of this program (e.g., no 'g' prefix).  */
 #define PROGRAM_NAME "install"
 
-#define AUTHORS "David MacKenzie"
+#define AUTHORS proper_name ("David MacKenzie")
 
-#if HAVE_SYS_WAIT_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)
@@ -57,47 +59,26 @@
 # define endpwent() ((void) 0)
 #endif
 
-/* Initial number of entries in each hash table entry's table of inodes.  */
-#define INITIAL_HASH_MODULE 100
-
-/* Initial number of entries in the inode hash table.  */
-#define INITIAL_ENTRY_TAB_SIZE 70
-
-/* Number of bytes of a file to copy at a time. */
-#define READ_SIZE (32 * 1024)
-
-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 *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. */
-char *program_name;
+#if ! HAVE_LCHOWN
+# define lchown(name, uid, gid) chown (name, uid, gid)
+#endif
+
+#if ! HAVE_MATCHPATHCON_INIT_PREFIX
+# define matchpathcon_init_prefix(a, p) /* empty */
+#endif
 
 /* The user name that will own the files, or NULL to make the owner
    the current user ID. */
 static char *owner_name;
 
-/* The user ID corresponding to `owner_name'. */
+/* The user ID corresponding to 'owner_name'. */
 static uid_t owner_id;
 
 /* The group name that will own the files, or NULL to make the group
    the current group ID. */
 static char *group_name;
 
-/* The group ID corresponding to `group_name'. */
+/* The group ID corresponding to 'group_name'. */
 static gid_t group_id;
 
 #define DEFAULT_MODE (S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)
@@ -115,22 +96,40 @@ static mode_t dir_mode = DEFAULT_MODE;
    or S_ISGID bits.  */
 static mode_t dir_mode_bits = CHMOD_MODE_BITS;
 
+/* Compare files before installing (-C) */
+static bool copy_only_if_needed;
+
 /* 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;
 
+/* Program used to strip binaries, "strip" is default */
+static char const *strip_program = "strip";
+
+/* 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,
+  STRIP_PROGRAM_OPTION
+};
+
 static struct option const long_options[] =
 {
   {"backup", optional_argument, NULL, 'b'},
+  {"compare", no_argument, NULL, 'C'},
+  {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},
   {"strip", no_argument, NULL, 's'},
+  {"strip-program", required_argument, NULL, STRIP_PROGRAM_OPTION},
   {"suffix", required_argument, NULL, 'S'},
   {"target-directory", required_argument, NULL, 't'},
   {"verbose", no_argument, NULL, 'v'},
@@ -139,23 +138,147 @@ static struct option const long_options[] =
   {NULL, 0, NULL, 0}
 };
 
+/* Compare content of opened files using file descriptors A_FD and B_FD. Return
+   true if files are equal. */
+static bool
+have_same_content (int a_fd, int b_fd)
+{
+  enum { CMP_BLOCK_SIZE = 4096 };
+  static char a_buff[CMP_BLOCK_SIZE];
+  static char b_buff[CMP_BLOCK_SIZE];
+
+  size_t size;
+  while (0 < (size = full_read (a_fd, a_buff, sizeof a_buff))) {
+    if (size != full_read (b_fd, b_buff, sizeof b_buff))
+      return false;
+
+    if (memcmp (a_buff, b_buff, size) != 0)
+      return false;
+  }
+
+  return size == 0;
+}
+
+/* Return true for mode with non-permission bits. */
+static bool
+extra_mode (mode_t input)
+{
+  mode_t mask = S_IRWXUGO | S_IFMT;
+  return !! (input & ~ mask);
+}
+
+/* Return true if copy of file SRC_NAME to file DEST_NAME is necessary. */
+static bool
+need_copy (const char *src_name, const char *dest_name,
+           const struct cp_options *x)
+{
+  struct stat src_sb, dest_sb;
+  int src_fd, dest_fd;
+  bool content_match;
+
+  if (extra_mode (mode))
+    return true;
+
+  /* compare files using stat */
+  if (lstat (src_name, &src_sb) != 0)
+    return true;
+
+  if (lstat (dest_name, &dest_sb) != 0)
+    return true;
+
+  if (!S_ISREG (src_sb.st_mode) || !S_ISREG (dest_sb.st_mode)
+      || extra_mode (src_sb.st_mode) || extra_mode (dest_sb.st_mode))
+    return true;
+
+  if (src_sb.st_size != dest_sb.st_size
+      || (dest_sb.st_mode & CHMOD_MODE_BITS) != mode)
+    return true;
+
+  if (owner_id == (uid_t) -1)
+    {
+      errno = 0;
+      uid_t ruid = getuid ();
+      if ((ruid == (uid_t) -1 && errno) || dest_sb.st_uid != ruid)
+        return true;
+    }
+  else if (dest_sb.st_uid != owner_id)
+    return true;
+
+  if (group_id == (uid_t) -1)
+    {
+      errno = 0;
+      gid_t rgid = getgid ();
+      if ((rgid == (uid_t) -1 && errno) || dest_sb.st_gid != rgid)
+        return true;
+    }
+  else if (dest_sb.st_gid != group_id)
+    return true;
+
+  /* compare SELinux context if preserving */
+  if (selinux_enabled && x->preserve_security_context)
+    {
+      char *file_scontext = NULL;
+      char *to_scontext = NULL;
+      bool scontext_match;
+
+      if (getfilecon (src_name, &file_scontext) == -1)
+        return true;
+
+      if (getfilecon (dest_name, &to_scontext) == -1)
+        {
+          freecon (file_scontext);
+          return true;
+        }
+
+      scontext_match = STREQ (file_scontext, to_scontext);
+
+      freecon (file_scontext);
+      freecon (to_scontext);
+      if (!scontext_match)
+        return true;
+    }
+
+  /* compare files content */
+  src_fd = open (src_name, O_RDONLY | O_BINARY);
+  if (src_fd < 0)
+    return true;
+
+  dest_fd = open (dest_name, O_RDONLY | O_BINARY);
+  if (dest_fd < 0)
+    {
+      close (src_fd);
+      return true;
+    }
+
+  content_match = have_same_content (src_fd, dest_fd);
+
+  close (src_fd);
+  close (dest_fd);
+  return !content_match;
+}
+
 static void
 cp_option_init (struct cp_options *x)
 {
+  cp_options_default (x);
   x->copy_as_regular = true;
+  x->reflink_mode = REFLINK_NEVER;
   x->dereference = DEREF_ALWAYS;
   x->unlink_dest_before_opening = true;
   x->unlink_dest_after_failed_open = false;
   x->hard_link = false;
   x->interactive = I_UNSPECIFIED;
   x->move_mode = false;
-  x->chown_privileges = chown_privileges ();
   x->one_file_system = false;
   x->preserve_ownership = false;
   x->preserve_links = false;
   x->preserve_mode = false;
   x->preserve_timestamps = false;
+  x->explicit_no_preserve_mode = false;
+  x->reduce_diagnostics=false;
+  x->data_copy_required = true;
   x->require_preserve = false;
+  x->require_preserve_xattr = false;
   x->recursive = false;
   x->sparse_mode = SPARSE_AUTO;
   x->symbolic_link = false;
@@ -168,12 +291,101 @@ cp_option_init (struct cp_options *x)
   x->mode = S_IRUSR | S_IWUSR;
   x->stdin_tty = false;
 
+  x->open_dangling_dest_symlink = false;
   x->update = false;
+  x->require_preserve_context = false;  /* Not used by install currently.  */
+  x->preserve_security_context = false; /* Whether to copy context from src.  */
+  x->set_security_context = false;    /* Whether to set sys default context.  */
+  x->preserve_xattr = false;
   x->verbose = false;
   x->dest_info = NULL;
   x->src_info = NULL;
 }
 
+#ifdef ENABLE_MATCHPATHCON
+/* Modify file context to match the specified policy.
+   If an error occurs the file will remain with the default directory
+   context.  Note this sets the context to that returned by matchpathcon,
+   and thus discards MLS levels and user identity of the FILE.  */
+static void
+setdefaultfilecon (char const *file)
+{
+  struct stat st;
+  char *scontext = NULL;
+  static bool first_call = true;
+
+  if (selinux_enabled != 1)
+    {
+      /* Indicate no context found. */
+      return;
+    }
+  if (lstat (file, &st) != 0)
+    return;
+
+  if (first_call && IS_ABSOLUTE_FILE_NAME (file))
+    {
+      /* Calling matchpathcon_init_prefix (NULL, "/first_component/")
+         is an optimization to minimize the expense of the following
+         matchpathcon call.  Do it only once, just before the first
+         matchpathcon call.  We *could* call matchpathcon_fini after
+         the final matchpathcon call, but that's not necessary, since
+         by then we're about to exit, and besides, the buffers it
+         would free are still reachable.  */
+      char const *p0;
+      char const *p = file + 1;
+      while (ISSLASH (*p))
+        ++p;
+
+      /* Record final leading slash, for when FILE starts with two or more.  */
+      p0 = p - 1;
+
+      if (*p)
+        {
+          char *prefix;
+          do
+            {
+              ++p;
+            }
+          while (*p && !ISSLASH (*p));
+
+          prefix = malloc (p - p0 + 2);
+          if (prefix)
+            {
+              stpcpy (stpncpy (prefix, p0, p - p0), "/");
+              matchpathcon_init_prefix (NULL, prefix);
+              free (prefix);
+            }
+        }
+    }
+  first_call = false;
+
+  /* If there's an error determining the context, or it has none,
+     return to allow default context.  Note the "<<none>>" check
+     is only needed for libselinux < 1.20 (2005-01-04).  */
+  if ((matchpathcon (file, st.st_mode, &scontext) != 0)
+      || STREQ (scontext, "<<none>>"))
+    {
+      if (scontext != NULL)
+        freecon (scontext);
+      return;
+    }
+
+  if (lsetfilecon (file, scontext) < 0 && errno != ENOTSUP)
+    error (0, errno,
+           _("warning: %s: failed to change context to %s"),
+           quotef_n (0, file), quote_n (1, scontext));
+
+  freecon (scontext);
+  return;
+}
+#else
+static void
+setdefaultfilecon (char const *file)
+{
+  (void) file;
+}
+#endif
+
 /* 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
@@ -189,295 +401,44 @@ target_directory_operand (char const *file)
   int err = (stat (file, &st) == 0 ? 0 : errno);
   bool is_a_dir = !err && S_ISDIR (st.st_mode);
   if (err && err != ENOENT)
-    error (EXIT_FAILURE, err, _("accessing %s"), quote (file));
+    error (EXIT_FAILURE, err, _("failed to access %s"), quoteaf (file));
   if (is_a_dir < looks_like_a_dir)
-    error (EXIT_FAILURE, err, _("target %s is not a directory"), quote (file));
+    error (EXIT_FAILURE, err, _("target %s is not a directory"),
+           quoteaf (file));
   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;
-  int exit_status = EXIT_SUCCESS;
-  const char *specified_mode = NULL;
-  bool make_backups = false;
-  char *backup_suffix_string;
-  char *version_control_string = NULL;
-  bool mkdir_and_install = false;
-  struct cp_options x;
-  char const *target_directory = NULL;
-  bool no_target_directory = false;
-  int n_files;
-  char **file;
-
-  initialize_main (&argc, &argv);
-  program_name = argv[0];
-  setlocale (LC_ALL, "");
-  bindtextdomain (PACKAGE, LOCALEDIR);
-  textdomain (PACKAGE);
-
-  atexit (close_stdout);
-
-  cp_option_init (&x);
-
-  owner_name = NULL;
-  group_name = NULL;
-  strip_files = false;
-  dir_arg = false;
-  umask (0);
-
-  /* FIXME: consider not calling getenv for SIMPLE_BACKUP_SUFFIX unless
-     we'll actually use backup_suffix_string.  */
-  backup_suffix_string = getenv ("SIMPLE_BACKUP_SUFFIX");
-
-  while ((optc = getopt_long (argc, argv, "bcsDdg:m:o:pt:TvS:", long_options,
-			      NULL)) != -1)
-    {
-      switch (optc)
-	{
-	case 'b':
-	  make_backups = true;
-	  if (optarg)
-	    version_control_string = optarg;
-	  break;
-	case 'c':
-	  break;
-	case 's':
-	  strip_files = true;
-#ifdef SIGCHLD
-	  /* System V fork+wait does not work if SIGCHLD is ignored.  */
-	  signal (SIGCHLD, SIG_DFL);
-#endif
-	  break;
-	case 'd':
-	  dir_arg = true;
-	  break;
-	case 'D':
-	  mkdir_and_install = true;
-	  break;
-	case 'v':
-	  x.verbose = true;
-	  break;
-	case 'g':
-	  group_name = optarg;
-	  break;
-	case 'm':
-	  specified_mode = optarg;
-	  break;
-	case 'o':
-	  owner_name = optarg;
-	  break;
-	case 'p':
-	  x.preserve_timestamps = true;
-	  break;
-	case 'S':
-	  make_backups = true;
-	  backup_suffix_string = optarg;
-	  break;
-	case 't':
-	  if (target_directory)
-	    error (EXIT_FAILURE, 0,
-		   _("multiple target directories specified"));
-	  else
-	    {
-	      struct stat st;
-	      if (stat (optarg, &st) != 0)
-		error (EXIT_FAILURE, errno, _("accessing %s"), quote (optarg));
-	      if (! S_ISDIR (st.st_mode))
-		error (EXIT_FAILURE, 0, _("target %s is not a directory"),
-		       quote (optarg));
-	    }
-	  target_directory = optarg;
-	  break;
-	case 'T':
-	  no_target_directory = true;
-	  break;
-	case_GETOPT_HELP_CHAR;
-	case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
-	default:
-	  usage (EXIT_FAILURE);
-	}
-    }
-
-  /* Check for invalid combinations of arguments. */
-  if (dir_arg & strip_files)
-    error (EXIT_FAILURE, 0,
-	   _("the strip option may not be used when installing a directory"));
-  if (dir_arg && target_directory)
-    error (EXIT_FAILURE, 0,
-	   _("target directory not allowed when installing a directory"));
-
-  if (backup_suffix_string)
-    simple_backup_suffix = xstrdup (backup_suffix_string);
-
-  x.backup_type = (make_backups
-		   ? xget_version (_("backup type"),
-				   version_control_string)
-		   : no_backups);
-
-  n_files = argc - optind;
-  file = argv + optind;
-
-  if (n_files <= ! (dir_arg || target_directory))
-    {
-      if (n_files <= 0)
-	error (0, 0, _("missing file operand"));
-      else
-	error (0, 0, _("missing destination file operand after %s"),
-	       quote (file[0]));
-      usage (EXIT_FAILURE);
-    }
-
-  if (no_target_directory)
-    {
-      if (target_directory)
-	error (EXIT_FAILURE, 0,
-	       _("Cannot combine --target-directory (-t) "
-		 "and --no-target-directory (-T)"));
-      if (2 < n_files)
-	{
-	  error (0, 0, _("extra operand %s"), quote (file[2]));
-	  usage (EXIT_FAILURE);
-	}
-    }
-  else if (! (dir_arg || target_directory))
-    {
-      if (2 <= n_files && target_directory_operand (file[n_files - 1]))
-	target_directory = file[--n_files];
-      else if (2 < n_files)
-	error (EXIT_FAILURE, 0, _("target %s is not a directory"),
-	       quote (file[n_files - 1]));
-    }
-
-  if (specified_mode)
-    {
-      struct mode_change *change = mode_compile (specified_mode);
-      if (!change)
-	error (EXIT_FAILURE, 0, _("invalid mode %s"), quote (specified_mode));
-      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)
-    exit_status = savewd_process_files (n_files, file, process_dir, &x);
-  else
-    {
-      /* FIXME: it's a little gross that this initialization is
-	 required by copy.c::copy. */
-      hash_init ();
-
-      if (!target_directory)
-        {
-          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++)
-	    if (! install_file_in_dir (file[i], target_directory, &x))
-	      exit_status = 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 *to,
-			      struct cp_options *x)
+/* Report that directory DIR was made, if OPTIONS requests this.  */
+static void
+announce_mkdir (char const *dir, void *options)
 {
-  bool save_working_directory =
-    ! (IS_ABSOLUTE_FILE_NAME (from) && IS_ABSOLUTE_FILE_NAME (to));
-  int status = EXIT_SUCCESS;
-
-  struct savewd wd;
-  savewd_init (&wd);
-  if (! save_working_directory)
-    savewd_finish (&wd);
-
-  if (mkancesdirs (to, &wd, make_ancestor, x) == -1)
-    {
-      error (0, errno, _("cannot create directory %s"), to);
-      status = EXIT_FAILURE;
-    }
-
-  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 (status == EXIT_SUCCESS && install_file_in_file (from, to, x));
+  struct cp_options const *x = options;
+  if (x->verbose)
+    prog_fprintf (stdout, _("creating directory %s"), quoteaf (dir));
 }
 
-/* Copy file FROM onto file TO and give TO the appropriate
-   attributes.
-   Return true if successful.  */
-
-static bool
-install_file_in_file (const char *from, const char *to,
-		      const struct cp_options *x)
+/* 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)
 {
-  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 (x->preserve_timestamps && (strip_files || ! S_ISREG (from_sb.st_mode))
-      && ! change_timestamps (&from_sb, to))
-    return false;
-  return change_attributes (to);
+  int r = mkdir (component, DEFAULT_MODE);
+  if (r == 0)
+    announce_mkdir (dir, options);
+  return r;
 }
 
-/* Copy file FROM into directory TO_DIR, keeping its same name,
-   and give the copy the appropriate attributes.
-   Return true if successful.  */
-
-static bool
-install_file_in_dir (const char *from, const char *to_dir,
-		     const struct cp_options *x)
+/* Process a command-line file name, for the -d option.  */
+static int
+process_dir (char *dir, struct savewd *wd, void *options)
 {
-  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);
-  return ret;
+  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);
 }
 
 /* Copy file FROM onto file TO, creating TO if necessary.
@@ -488,6 +449,9 @@ copy_file (const char *from, const char *to, const struct cp_options *x)
 {
   bool copy_into_self;
 
+  if (copy_only_if_needed && !need_copy (from, to, x))
+    return true;
+
   /* Allow installing from non-regular files like /dev/null.
      Charles Karney reported that some Sun version of install allows that
      and that sendmail's installation process relies on the behavior.
@@ -503,6 +467,7 @@ copy_file (const char *from, const char *to, const struct cp_options *x)
 static bool
 change_attributes (char const *name)
 {
+  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.
@@ -516,29 +481,32 @@ change_attributes (char const *name)
      want to know.  */
 
   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));
+      && lchown (name, owner_id, group_id) != 0)
+    error (0, errno, _("cannot change ownership of %s"), quoteaf (name));
   else if (chmod (name, mode) != 0)
-    error (0, errno, _("cannot change permissions of %s"), quote (name));
+    error (0, errno, _("cannot change permissions of %s"), quoteaf (name));
   else
-    return true;
+    ok = true;
 
-  return false;
+  if (use_default_selinux_context)
+    setdefaultfilecon (name);
+
+  return ok;
 }
 
-/* Set the timestamps of file TO to match those of file FROM.
+/* Set the timestamps of file DEST to match those of SRC_SB.
    Return true if successful.  */
 
 static bool
-change_timestamps (struct stat const *from_sb, char const *to)
+change_timestamps (struct stat const *src_sb, char const *dest)
 {
   struct timespec timespec[2];
-  timespec[0] = get_stat_atime (from_sb);
-  timespec[1] = get_stat_mtime (from_sb);
+  timespec[0] = get_stat_atime (src_sb);
+  timespec[1] = get_stat_mtime (src_sb);
 
-  if (utimens (to, timespec))
+  if (utimens (dest, timespec))
     {
-      error (0, errno, _("cannot set time stamps for %s"), quote (to));
+      error (0, errno, _("cannot set time stamps for %s"), quoteaf (dest));
       return false;
     }
   return true;
@@ -550,28 +518,32 @@ change_timestamps (struct stat const *from_sb, char const *to)
    magic numbers vary so much from system to system that making
    it portable would be very difficult.  Not worth the effort. */
 
-static void
+static bool
 strip (char const *name)
 {
   int status;
+  bool ok = false;
   pid_t pid = fork ();
 
   switch (pid)
     {
     case -1:
-      error (EXIT_FAILURE, errno, _("fork system call failed"));
+      error (0, errno, _("fork system call failed"));
       break;
     case 0:			/* Child. */
-      execlp ("strip", "strip", name, NULL);
-      error (EXIT_FAILURE, errno, _("cannot run strip"));
+      execlp (strip_program, strip_program, name, NULL);
+      error (EXIT_FAILURE, errno, _("cannot run %s"), quoteaf (strip_program));
       break;
     default:			/* Parent. */
       if (waitpid (pid, &status, 0) < 0)
-	error (EXIT_FAILURE, errno, _("waiting for strip"));
+        error (0, errno, _("waiting for strip"));
       else if (! WIFEXITED (status) || WEXITSTATUS (status))
-	error (EXIT_FAILURE, 0, _("strip process terminated abnormally"));
+        error (0, 0, _("strip process terminated abnormally"));
+      else
+        ok = true;      /* strip succeeded */
       break;
     }
+  return ok;
 }
 
 /* Initialize the user and group ownership of the files to install. */
@@ -586,15 +558,16 @@ get_ids (void)
     {
       pw = getpwnam (owner_name);
       if (pw == NULL)
-	{
-	  unsigned long int tmp;
-	  if (xstrtoul (owner_name, NULL, 0, &tmp, NULL) != LONGINT_OK
-	      || UID_T_MAX < tmp)
-	    error (EXIT_FAILURE, 0, _("invalid user %s"), quote (owner_name));
-	  owner_id = tmp;
-	}
+        {
+          unsigned long int tmp;
+          if (xstrtoul (owner_name, NULL, 0, &tmp, NULL) != LONGINT_OK
+              || UID_T_MAX < tmp)
+            error (EXIT_FAILURE, 0, _("invalid user %s"),
+                   quote (owner_name));
+          owner_id = tmp;
+        }
       else
-	owner_id = pw->pw_uid;
+        owner_id = pw->pw_uid;
       endpwent ();
     }
   else
@@ -604,48 +577,27 @@ get_ids (void)
     {
       gr = getgrnam (group_name);
       if (gr == NULL)
-	{
-	  unsigned long int tmp;
-	  if (xstrtoul (group_name, NULL, 0, &tmp, NULL) != LONGINT_OK
-	      || GID_T_MAX < tmp)
-	    error (EXIT_FAILURE, 0, _("invalid group %s"), quote (group_name));
-	  group_id = tmp;
-	}
+        {
+          unsigned long int tmp;
+          if (xstrtoul (group_name, NULL, 0, &tmp, NULL) != LONGINT_OK
+              || GID_T_MAX < tmp)
+            error (EXIT_FAILURE, 0, _("invalid group %s"),
+                   quote (group_name));
+          group_id = tmp;
+        }
       else
-	group_id = gr->gr_gid;
+        group_id = gr->gr_gid;
       endgrent ();
     }
   else
     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)
 {
   if (status != EXIT_SUCCESS)
-    fprintf (stderr, _("Try `%s --help' for more information.\n"),
-	     program_name);
+    emit_try_help ();
   else
     {
       printf (_("\
@@ -654,25 +606,33 @@ Usage: %s [OPTION]... [-T] SOURCE DEST\n\
   or:  %s [OPTION]... -t DIRECTORY SOURCE...\n\
   or:  %s [OPTION]... -d DIRECTORY...\n\
 "),
-	      program_name, program_name, program_name, program_name);
+              program_name, program_name, program_name, program_name);
       fputs (_("\
+\n\
+This install program copies files (often just compiled) into destination\n\
+locations you choose.  If you want to download and install a ready-to-use\n\
+package on a GNU/Linux system, you should instead be using a package manager\n\
+like yum(1) or apt-get(1).\n\
+\n\
 In the first three forms, copy SOURCE to DEST or multiple SOURCE(s) to\n\
 the existing DIRECTORY, while setting permission modes and owner/group.\n\
 In the 4th form, create all components of the given DIRECTORY(ies).\n\
-\n\
-"), stdout);
-      fputs (_("\
-Mandatory arguments to long options are mandatory for short options too.\n\
 "), stdout);
+
+      emit_mandatory_arg_note ();
+
       fputs (_("\
       --backup[=CONTROL]  make a backup of each existing destination file\n\
   -b                  like --backup but does not accept an argument\n\
   -c                  (ignored)\n\
+  -C, --compare       compare each pair of source and destination files, and\n\
+                        in some cases, do not modify the destination at all\n\
   -d, --directory     treat all arguments as directory names; create all\n\
                         components of the specified directories\n\
 "), stdout);
       fputs (_("\
   -D                  create all leading components of DEST except the last,\n\
+                        or all components of --target-directory,\n\
                         then copy SOURCE to DEST\n\
   -g, --group=GROUP   set group ownership, instead of process' current group\n\
   -m, --mode=MODE     set permission mode (as in chmod), instead of rwxr-xr-x\n\
@@ -682,16 +642,25 @@ Mandatory arguments to long options are mandatory for short options too.\n\
   -p, --preserve-timestamps   apply access/modification times of SOURCE files\n\
                         to corresponding destination files\n\
   -s, --strip         strip symbol tables\n\
+      --strip-program=PROGRAM  program used to strip binaries\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                      set SELinux security context of destination\n\
+                            file to default type\n\
+      --context[=CTX]     like -Z, or if CTX is specified then set the\n\
+                            SELinux or SMACK security context to CTX\n\
+"), stdout);
+
       fputs (HELP_OPTION_DESCRIPTION, stdout);
       fputs (VERSION_OPTION_DESCRIPTION, stdout);
       fputs (_("\
 \n\
-The backup suffix is `~', unless set with --suffix or SIMPLE_BACKUP_SUFFIX.\n\
+The backup suffix is '~', unless set with --suffix or SIMPLE_BACKUP_SUFFIX.\n\
 The version control method may be selected via the --backup option or through\n\
 the VERSION_CONTROL environment variable.  Here are the values:\n\
 \n\
@@ -702,7 +671,383 @@ the VERSION_CONTROL environment variable.  Here are the values:\n\
   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_ancillary_info (PROGRAM_NAME);
     }
   exit (status);
 }
+
+/* Copy file FROM onto file TO and give TO the appropriate
+   attributes.
+   Return true if successful.  */
+
+static bool
+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"), quoteaf (from));
+      return false;
+    }
+  if (! copy_file (from, to, x))
+    return false;
+  if (strip_files)
+    if (! strip (to))
+      {
+        if (unlink (to) != 0)  /* Cleanup.  */
+          error (EXIT_FAILURE, errno, _("cannot unlink %s"), quoteaf (to));
+        return false;
+      }
+  if (x->preserve_timestamps && (strip_files || ! S_ISREG (from_sb.st_mode))
+      && ! change_timestamps (&from_sb, to))
+    return false;
+  return change_attributes (to);
+}
+
+/* Create any missing parent directories of TO,
+   while maintaining the current Working Directory.
+   Return true if successful.  */
+
+static bool
+mkancesdirs_safe_wd (char const *from, char *to, struct cp_options *x,
+                     bool save_always)
+{
+  bool save_working_directory =
+    save_always
+    || ! (IS_ABSOLUTE_FILE_NAME (from) && IS_ABSOLUTE_FILE_NAME (to));
+  int status = EXIT_SUCCESS;
+
+  struct savewd wd;
+  savewd_init (&wd);
+  if (! save_working_directory)
+    savewd_finish (&wd);
+
+  if (mkancesdirs (to, &wd, make_ancestor, x) == -1)
+    {
+      error (0, errno, _("cannot create directory %s"), quoteaf (to));
+      status = EXIT_FAILURE;
+    }
+
+  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"),
+                 quoteaf (to));
+          return false;
+        }
+    }
+  return status == EXIT_SUCCESS;
+}
+
+/* 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 *to,
+                              const struct cp_options *x)
+{
+  return (mkancesdirs_safe_wd (from, to, (struct cp_options *)x, false)
+          && install_file_in_file (from, to, x));
+}
+
+/* Copy file FROM into directory TO_DIR, keeping its same name,
+   and give the copy the appropriate attributes.
+   Return true if successful.  */
+
+static bool
+install_file_in_dir (const char *from, const char *to_dir,
+                     const struct cp_options *x, bool mkdir_and_install)
+{
+  const char *from_base = last_component (from);
+  char *to = file_name_concat (to_dir, from_base, NULL);
+  bool ret = true;
+
+  if (mkdir_and_install)
+    ret = mkancesdirs_safe_wd (from, to, (struct cp_options *)x, true);
+
+  ret = ret && install_file_in_file (from, to, x);
+  free (to);
+  return ret;
+}
+
+int
+main (int argc, char **argv)
+{
+  int optc;
+  int exit_status = EXIT_SUCCESS;
+  const char *specified_mode = NULL;
+  bool make_backups = false;
+  char *backup_suffix_string;
+  char *version_control_string = NULL;
+  bool mkdir_and_install = false;
+  struct cp_options x;
+  char const *target_directory = NULL;
+  bool no_target_directory = false;
+  int n_files;
+  char **file;
+  bool strip_program_specified = false;
+  char const *scontext = NULL;
+  /* set iff kernel has extra selinux system calls */
+  selinux_enabled = (0 < is_selinux_enabled ());
+
+  initialize_main (&argc, &argv);
+  set_program_name (argv[0]);
+  setlocale (LC_ALL, "");
+  bindtextdomain (PACKAGE, LOCALEDIR);
+  textdomain (PACKAGE);
+
+  atexit (close_stdin);
+
+  cp_option_init (&x);
+
+  owner_name = NULL;
+  group_name = NULL;
+  strip_files = false;
+  dir_arg = false;
+  umask (0);
+
+  /* FIXME: consider not calling getenv for SIMPLE_BACKUP_SUFFIX unless
+     we'll actually use backup_suffix_string.  */
+  backup_suffix_string = getenv ("SIMPLE_BACKUP_SUFFIX");
+
+  while ((optc = getopt_long (argc, argv, "bcCsDdg:m:o:pt:TvS:Z", long_options,
+                              NULL)) != -1)
+    {
+      switch (optc)
+        {
+        case 'b':
+          make_backups = true;
+          if (optarg)
+            version_control_string = optarg;
+          break;
+        case 'c':
+          break;
+        case 'C':
+          copy_only_if_needed = true;
+          break;
+        case 's':
+          strip_files = true;
+#ifdef SIGCHLD
+          /* System V fork+wait does not work if SIGCHLD is ignored.  */
+          signal (SIGCHLD, SIG_DFL);
+#endif
+          break;
+        case STRIP_PROGRAM_OPTION:
+          strip_program = xstrdup (optarg);
+          strip_program_specified = true;
+          break;
+        case 'd':
+          dir_arg = true;
+          break;
+        case 'D':
+          mkdir_and_install = true;
+          break;
+        case 'v':
+          x.verbose = true;
+          break;
+        case 'g':
+          group_name = optarg;
+          break;
+        case 'm':
+          specified_mode = optarg;
+          break;
+        case 'o':
+          owner_name = optarg;
+          break;
+        case 'p':
+          x.preserve_timestamps = true;
+          break;
+        case 'S':
+          make_backups = true;
+          backup_suffix_string = optarg;
+          break;
+        case 't':
+          if (target_directory)
+            error (EXIT_FAILURE, 0,
+                   _("multiple target directories specified"));
+          target_directory = optarg;
+          break;
+        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)
+            {
+              /* Disable use of the install(1) specific setdefaultfilecon().
+                 Note setdefaultfilecon() is different from the newer and more
+                 generic restorecon() in that the former sets the context of
+                 the dest files to that returned by matchpathcon directly,
+                 thus discarding MLS level and user identity of the file.
+                 TODO: consider removing setdefaultfilecon() in future.  */
+              use_default_selinux_context = false;
+
+              if (optarg)
+                scontext = optarg;
+              else
+                x.set_security_context = true;
+            }
+          else if (optarg)
+            {
+              error (0, 0,
+                     _("warning: ignoring --context; "
+                       "it requires an SELinux-enabled kernel"));
+            }
+          break;
+        case_GETOPT_HELP_CHAR;
+        case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
+        default:
+          usage (EXIT_FAILURE);
+        }
+    }
+
+  /* Check for invalid combinations of arguments. */
+  if (dir_arg && strip_files)
+    error (EXIT_FAILURE, 0,
+           _("the strip option may not be used when installing a directory"));
+  if (dir_arg && target_directory)
+    error (EXIT_FAILURE, 0,
+           _("target directory not allowed when installing a directory"));
+
+  if (target_directory)
+    {
+      struct stat st;
+      bool stat_success = stat (target_directory, &st) == 0 ? true : false;
+      if (! mkdir_and_install && ! stat_success)
+        error (EXIT_FAILURE, errno, _("failed to access %s"),
+               quoteaf (target_directory));
+      if (stat_success && ! S_ISDIR (st.st_mode))
+        error (EXIT_FAILURE, 0, _("target %s is not a directory"),
+               quoteaf (target_directory));
+    }
+
+  if (backup_suffix_string)
+    simple_backup_suffix = xstrdup (backup_suffix_string);
+
+  x.backup_type = (make_backups
+                   ? xget_version (_("backup type"),
+                                   version_control_string)
+                   : no_backups);
+
+  if (x.preserve_security_context && (x.set_security_context || scontext))
+    error (EXIT_FAILURE, 0,
+           _("cannot set target context and preserve it"));
+
+  if (scontext && setfscreatecon (se_const (scontext)) < 0)
+    error (EXIT_FAILURE, errno,
+           _("failed to set default file creation context to %s"),
+           quote (scontext));
+
+  n_files = argc - optind;
+  file = argv + optind;
+
+  if (n_files <= ! (dir_arg || target_directory))
+    {
+      if (n_files <= 0)
+        error (0, 0, _("missing file operand"));
+      else
+        error (0, 0, _("missing destination file operand after %s"),
+               quoteaf (file[0]));
+      usage (EXIT_FAILURE);
+    }
+
+  if (no_target_directory)
+    {
+      if (target_directory)
+        error (EXIT_FAILURE, 0,
+               _("cannot combine --target-directory (-t) "
+                 "and --no-target-directory (-T)"));
+      if (2 < n_files)
+        {
+          error (0, 0, _("extra operand %s"), quoteaf (file[2]));
+          usage (EXIT_FAILURE);
+        }
+    }
+  else if (! (dir_arg || target_directory))
+    {
+      if (2 <= n_files && target_directory_operand (file[n_files - 1]))
+        target_directory = file[--n_files];
+      else if (2 < n_files)
+        error (EXIT_FAILURE, 0, _("target %s is not a directory"),
+               quoteaf (file[n_files - 1]));
+    }
+
+  if (specified_mode)
+    {
+      struct mode_change *change = mode_compile (specified_mode);
+      if (!change)
+        error (EXIT_FAILURE, 0, _("invalid mode %s"), quote (specified_mode));
+      mode = mode_adjust (0, false, 0, change, NULL);
+      dir_mode = mode_adjust (0, true, 0, change, &dir_mode_bits);
+      free (change);
+    }
+
+  if (strip_program_specified && !strip_files)
+    error (0, 0, _("WARNING: ignoring --strip-program option as -s option was "
+                   "not specified"));
+
+  if (copy_only_if_needed && x.preserve_timestamps)
+    {
+      error (0, 0, _("options --compare (-C) and --preserve-timestamps are "
+                     "mutually exclusive"));
+      usage (EXIT_FAILURE);
+    }
+
+  if (copy_only_if_needed && strip_files)
+    {
+      error (0, 0, _("options --compare (-C) and --strip are mutually "
+                     "exclusive"));
+      usage (EXIT_FAILURE);
+    }
+
+  if (copy_only_if_needed && extra_mode (mode))
+    error (0, 0, _("the --compare (-C) option is ignored when you"
+                   " specify a mode with non-permission bits"));
+
+  get_ids ();
+
+  if (dir_arg)
+    exit_status = savewd_process_files (n_files, file, process_dir, &x);
+  else
+    {
+      /* FIXME: it's a little gross that this initialization is
+         required by copy.c::copy. */
+      hash_init ();
+
+      if (!target_directory)
+        {
+          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++)
+            if (! install_file_in_dir (file[i], target_directory, &x,
+                                       i == 0 && mkdir_and_install))
+              exit_status = EXIT_FAILURE;
+        }
+    }
+
+  return exit_status;
+}