src/install.c

   1 /* install - copy files and set attributes
   2    Copyright (C) 89, 90, 91, 1995-2009 Free Software Foundation, Inc.
   3
   4    This program is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation, either version 3 of the License, or
   7    (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  16
  17 /* Written by David MacKenzie <djm@gnu.ai.mit.edu> */
  18
  19 #include <config.h>
  20 #include <stdio.h>
  21 #include <getopt.h>
  22 #include <sys/types.h>
  23 #include <signal.h>
  24 #include <pwd.h>
  25 #include <grp.h>
  26 #include <selinux/selinux.h>
  27
  28 #include "system.h"
  29 #include "backupfile.h"
  30 #include "error.h"
  31 #include "cp-hash.h"
  32 #include "copy.h"
  33 #include "filenamecat.h"
  34 #include "full-read.h"
  35 #include "mkancesdirs.h"
  36 #include "mkdir-p.h"
  37 #include "modechange.h"
  38 #include "prog-fprintf.h"
  39 #include "quote.h"
  40 #include "quotearg.h"
  41 #include "savewd.h"
  42 #include "stat-time.h"
  43 #include "utimens.h"
  44 #include "xstrtol.h"
  45
  46 /* The official name of this program (e.g., no `g' prefix).  */
  47 #define PROGRAM_NAME "install"
  48
  49 #define AUTHORS proper_name ("David MacKenzie")
  50
  51 #if HAVE_SYS_WAIT_H
  52 # include <sys/wait.h>
  53 #endif
  54
  55 static int selinux_enabled = 0;
  56 static bool use_default_selinux_context = true;
  57
  58 #if ! HAVE_ENDGRENT
  59 # define endgrent() ((void) 0)
  60 #endif
  61
  62 #if ! HAVE_ENDPWENT
  63 # define endpwent() ((void) 0)
  64 #endif
  65
  66 #if ! HAVE_LCHOWN
  67 # define lchown(name, uid, gid) chown (name, uid, gid)
  68 #endif
  69
  70 #if ! HAVE_MATCHPATHCON_INIT_PREFIX
  71 # define matchpathcon_init_prefix(a, p) /* empty */
  72 #endif
  73
  74 static bool change_timestamps (struct stat const *from_sb, char const *to);
  75 static bool change_attributes (char const *name);
  76 static bool copy_file (const char *from, const char *to,
  77                        const struct cp_options *x);
  78 static bool install_file_in_file_parents (char const *from, char *to,
  79                                           struct cp_options *x);
  80 static bool install_file_in_dir (const char *from, const char *to_dir,
  81                                  const struct cp_options *x);
  82 static bool install_file_in_file (const char *from, const char *to,
  83                                   const struct cp_options *x);
  84 static void get_ids (void);
  85 static void strip (char const *name);
  86 static void announce_mkdir (char const *dir, void *options);
  87 static int make_ancestor (char const *dir, char const *component,
  88                           void *options);
  89 void usage (int status);
  90
  91 /* The user name that will own the files, or NULL to make the owner
  92    the current user ID. */
  93 static char *owner_name;
  94
  95 /* The user ID corresponding to `owner_name'. */
  96 static uid_t owner_id;
  97
  98 /* The group name that will own the files, or NULL to make the group
  99    the current group ID. */
 100 static char *group_name;
 101
 102 /* The group ID corresponding to `group_name'. */
 103 static gid_t group_id;
 104
 105 #define DEFAULT_MODE (S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)
 106
 107 /* The file mode bits to which non-directory files will be set.  The umask has
 108    no effect. */
 109 static mode_t mode = DEFAULT_MODE;
 110
 111 /* Similar, but for directories.  */
 112 static mode_t dir_mode = DEFAULT_MODE;
 113
 114 /* The file mode bits that the user cares about.  This should be a
 115    superset of DIR_MODE and a subset of CHMOD_MODE_BITS.  This matters
 116    for directories, since otherwise directories may keep their S_ISUID
 117    or S_ISGID bits.  */
 118 static mode_t dir_mode_bits = CHMOD_MODE_BITS;
 119
 120 /* Compare files before installing (-C) */
 121 static bool copy_only_if_needed;
 122
 123 /* If true, strip executable files after copying them. */
 124 static bool strip_files;
 125
 126 /* If true, install a directory instead of a regular file. */
 127 static bool dir_arg;
 128
 129 /* Program used to strip binaries, "strip" is default */
 130 static char const *strip_program = "strip";
 131
 132 /* For long options that have no equivalent short option, use a
 133    non-character as a pseudo short option, starting with CHAR_MAX + 1.  */
 134 enum
 135 {
 136   PRESERVE_CONTEXT_OPTION = CHAR_MAX + 1,
 137   PRESERVE_CONTEXT_OPTION_DEPRECATED,
 138   STRIP_PROGRAM_OPTION
 139 };
 140
 141 static struct option const long_options[] =
 142 {
 143   {"backup", optional_argument, NULL, 'b'},
 144   {"compare", no_argument, NULL, 'C'},
 145   {GETOPT_SELINUX_CONTEXT_OPTION_DECL},
 146   {"directory", no_argument, NULL, 'd'},
 147   {"group", required_argument, NULL, 'g'},
 148   {"mode", required_argument, NULL, 'm'},
 149   {"no-target-directory", no_argument, NULL, 'T'},
 150   {"owner", required_argument, NULL, 'o'},
 151   {"preserve-timestamps", no_argument, NULL, 'p'},
 152   {"preserve-context", no_argument, NULL, PRESERVE_CONTEXT_OPTION},
 153   /* --preserve_context was silently supported until Apr 2009.
 154      FIXME: disable altogether in a year or so.  */
 155   {"preserve_context", no_argument, NULL, PRESERVE_CONTEXT_OPTION_DEPRECATED},
 156   {"strip", no_argument, NULL, 's'},
 157   {"strip-program", required_argument, NULL, STRIP_PROGRAM_OPTION},
 158   {"suffix", required_argument, NULL, 'S'},
 159   {"target-directory", required_argument, NULL, 't'},
 160   {"verbose", no_argument, NULL, 'v'},
 161   {GETOPT_HELP_OPTION_DECL},
 162   {GETOPT_VERSION_OPTION_DECL},
 163   {NULL, 0, NULL, 0}
 164 };
 165
 166 /* Compare content of opened files using file descriptors A_FD and B_FD. Return
 167    true if files are equal. */
 168 static bool
 169 have_same_content (int a_fd, int b_fd)
 170 {
 171   enum { CMP_BLOCK_SIZE = 4096 };
 172   static char a_buff[CMP_BLOCK_SIZE];
 173   static char b_buff[CMP_BLOCK_SIZE];
 174
 175   size_t size;
 176   while (0 < (size = full_read (a_fd, a_buff, sizeof a_buff))) {
 177     if (size != full_read (b_fd, b_buff, sizeof b_buff))
 178       return false;
 179
 180     if (memcmp (a_buff, b_buff, size) != 0)
 181       return false;
 182   }
 183
 184   return size == 0;
 185 }
 186
 187 /* Return true for mode with non-permission bits. */
 188 static bool
 189 extra_mode (mode_t input)
 190 {
 191   const mode_t mask = ~S_IRWXUGO & ~S_IFMT;
 192   return !! (input & mask);
 193 }
 194
 195 /* Return true if copy of file SRC_NAME to file DEST_NAME is necessary. */
 196 static bool
 197 need_copy (const char *src_name, const char *dest_name,
 198            const struct cp_options *x)
 199 {
 200   struct stat src_sb, dest_sb;
 201   int src_fd, dest_fd;
 202   bool content_match;
 203
 204   if (extra_mode (mode))
 205     return true;
 206
 207   /* compare files using stat */
 208   if (lstat (src_name, &src_sb) != 0)
 209     return true;
 210
 211   if (lstat (dest_name, &dest_sb) != 0)
 212     return true;
 213
 214   if (!S_ISREG (src_sb.st_mode) || !S_ISREG (dest_sb.st_mode)
 215       || extra_mode (src_sb.st_mode) || extra_mode (dest_sb.st_mode))
 216     return true;
 217
 218   if (src_sb.st_size != dest_sb.st_size
 219       || (dest_sb.st_mode & CHMOD_MODE_BITS) != mode
 220       || dest_sb.st_uid != (owner_id == (uid_t) -1 ? getuid () : owner_id)
 221       || dest_sb.st_gid != (group_id == (gid_t) -1 ? getgid () : group_id))
 222     return true;
 223
 224   /* compare SELinux context if preserving */
 225   if (selinux_enabled && x->preserve_security_context)
 226     {
 227       security_context_t file_scontext = NULL;
 228       security_context_t to_scontext = NULL;
 229       bool scontext_match;
 230
 231       if (getfilecon (src_name, &file_scontext) == -1)
 232         return true;
 233
 234       if (getfilecon (dest_name, &to_scontext) == -1)
 235         {
 236           freecon (file_scontext);
 237           return true;
 238         }
 239
 240       scontext_match = STREQ (file_scontext, to_scontext);
 241
 242       freecon (file_scontext);
 243       freecon (to_scontext);
 244       if (!scontext_match)
 245         return true;
 246     }
 247
 248   /* compare files content */
 249   src_fd = open (src_name, O_RDONLY | O_BINARY);
 250   if (src_fd < 0)
 251     return true;
 252
 253   dest_fd = open (dest_name, O_RDONLY | O_BINARY);
 254   if (dest_fd < 0)
 255     {
 256       close (src_fd);
 257       return true;
 258     }
 259
 260   content_match = have_same_content (src_fd, dest_fd);
 261
 262   close (src_fd);
 263   close (dest_fd);
 264   return !content_match;
 265 }
 266
 267 static void
 268 cp_option_init (struct cp_options *x)
 269 {
 270   cp_options_default (x);
 271   x->copy_as_regular = true;
 272   x->reflink = false;
 273   x->dereference = DEREF_ALWAYS;
 274   x->unlink_dest_before_opening = true;
 275   x->unlink_dest_after_failed_open = false;
 276   x->hard_link = false;
 277   x->interactive = I_UNSPECIFIED;
 278   x->move_mode = false;
 279   x->one_file_system = false;
 280   x->preserve_ownership = false;
 281   x->preserve_links = false;
 282   x->preserve_mode = false;
 283   x->preserve_timestamps = false;
 284   x->reduce_diagnostics=false;
 285   x->require_preserve = false;
 286   x->require_preserve_context = false;
 287   x->require_preserve_xattr = false;
 288   x->recursive = false;
 289   x->sparse_mode = SPARSE_AUTO;
 290   x->symbolic_link = false;
 291   x->backup_type = no_backups;
 292
 293   /* Create destination files initially writable so we can run strip on them.
 294      Although GNU strip works fine on read-only files, some others
 295      would fail.  */
 296   x->set_mode = true;
 297   x->mode = S_IRUSR | S_IWUSR;
 298   x->stdin_tty = false;
 299
 300   x->open_dangling_dest_symlink = false;
 301   x->update = false;
 302   x->preserve_security_context = false;
 303   x->preserve_xattr = false;
 304   x->verbose = false;
 305   x->dest_info = NULL;
 306   x->src_info = NULL;
 307 }
 308
 309 #ifdef ENABLE_MATCHPATHCON
 310 /* Modify file context to match the specified policy.
 311    If an error occurs the file will remain with the default directory
 312    context.  */
 313 static void
 314 setdefaultfilecon (char const *file)
 315 {
 316   struct stat st;
 317   security_context_t scontext = NULL;
 318   static bool first_call = true;
 319
 320   if (selinux_enabled != 1)
 321     {
 322       /* Indicate no context found. */
 323       return;
 324     }
 325   if (lstat (file, &st) != 0)
 326     return;
 327
 328   if (first_call && IS_ABSOLUTE_FILE_NAME (file))
 329     {
 330       /* Calling matchpathcon_init_prefix (NULL, "/first_component/")
 331          is an optimization to minimize the expense of the following
 332          matchpathcon call.  Do it only once, just before the first
 333          matchpathcon call.  We *could* call matchpathcon_fini after
 334          the final matchpathcon call, but that's not necessary, since
 335          by then we're about to exit, and besides, the buffers it
 336          would free are still reachable.  */
 337       char const *p0;
 338       char const *p = file + 1;
 339       while (ISSLASH (*p))
 340         ++p;
 341
 342       /* Record final leading slash, for when FILE starts with two or more.  */
 343       p0 = p - 1;
 344
 345       if (*p)
 346         {
 347           char *prefix;
 348           do
 349             {
 350               ++p;
 351             }
 352           while (*p && !ISSLASH (*p));
 353
 354           prefix = malloc (p - p0 + 2);
 355           if (prefix)
 356             {
 357               stpcpy (stpncpy (prefix, p0, p - p0), "/");
 358               matchpathcon_init_prefix (NULL, prefix);
 359               free (prefix);
 360             }
 361         }
 362     }
 363   first_call = false;
 364
 365   /* If there's an error determining the context, or it has none,
 366      return to allow default context */
 367   if ((matchpathcon (file, st.st_mode, &scontext) != 0) ||
 368       STREQ (scontext, "<<none>>"))
 369     {
 370       if (scontext != NULL)
 371         freecon (scontext);
 372       return;
 373     }
 374
 375   if (lsetfilecon (file, scontext) < 0 && errno != ENOTSUP)
 376     error (0, errno,
 377            _("warning: %s: failed to change context to %s"),
 378            quotearg_colon (file), scontext);
 379
 380   freecon (scontext);
 381   return;
 382 }
 383 #else
 384 static void
 385 setdefaultfilecon (char const *file)
 386 {
 387   (void) file;
 388 }
 389 #endif
 390
 391 /* FILE is the last operand of this command.  Return true if FILE is a
 392    directory.  But report an error there is a problem accessing FILE,
 393    or if FILE does not exist but would have to refer to an existing
 394    directory if it referred to anything at all.  */
 395
 396 static bool
 397 target_directory_operand (char const *file)
 398 {
 399   char const *b = last_component (file);
 400   size_t blen = strlen (b);
 401   bool looks_like_a_dir = (blen == 0 || ISSLASH (b[blen - 1]));
 402   struct stat st;
 403   int err = (stat (file, &st) == 0 ? 0 : errno);
 404   bool is_a_dir = !err && S_ISDIR (st.st_mode);
 405   if (err && err != ENOENT)
 406     error (EXIT_FAILURE, err, _("accessing %s"), quote (file));
 407   if (is_a_dir < looks_like_a_dir)
 408     error (EXIT_FAILURE, err, _("target %s is not a directory"), quote (file));
 409   return is_a_dir;
 410 }
 411
 412 /* Process a command-line file name, for the -d option.  */
 413 static int
 414 process_dir (char *dir, struct savewd *wd, void *options)
 415 {
 416   return (make_dir_parents (dir, wd,
 417                             make_ancestor, options,
 418                             dir_mode, announce_mkdir,
 419                             dir_mode_bits, owner_id, group_id, false)
 420           ? EXIT_SUCCESS
 421           : EXIT_FAILURE);
 422 }
 423
 424 int
 425 main (int argc, char **argv)
 426 {
 427   int optc;
 428   int exit_status = EXIT_SUCCESS;
 429   const char *specified_mode = NULL;
 430   bool make_backups = false;
 431   char *backup_suffix_string;
 432   char *version_control_string = NULL;
 433   bool mkdir_and_install = false;
 434   struct cp_options x;
 435   char const *target_directory = NULL;
 436   bool no_target_directory = false;
 437   int n_files;
 438   char **file;
 439   bool strip_program_specified = false;
 440   security_context_t scontext = NULL;
 441   /* set iff kernel has extra selinux system calls */
 442   selinux_enabled = (0 < is_selinux_enabled ());
 443
 444   initialize_main (&argc, &argv);
 445   set_program_name (argv[0]);
 446   setlocale (LC_ALL, "");
 447   bindtextdomain (PACKAGE, LOCALEDIR);
 448   textdomain (PACKAGE);
 449
 450   atexit (close_stdin);
 451
 452   cp_option_init (&x);
 453
 454   owner_name = NULL;
 455   group_name = NULL;
 456   strip_files = false;
 457   dir_arg = false;
 458   umask (0);
 459
 460   /* FIXME: consider not calling getenv for SIMPLE_BACKUP_SUFFIX unless
 461      we'll actually use backup_suffix_string.  */
 462   backup_suffix_string = getenv ("SIMPLE_BACKUP_SUFFIX");
 463
 464   while ((optc = getopt_long (argc, argv, "bcCsDdg:m:o:pt:TvS:Z:", long_options,
 465                               NULL)) != -1)
 466     {
 467       switch (optc)
 468         {
 469         case 'b':
 470           make_backups = true;
 471           if (optarg)
 472             version_control_string = optarg;
 473           break;
 474         case 'c':
 475           break;
 476         case 'C':
 477           copy_only_if_needed = true;
 478           break;
 479         case 's':
 480           strip_files = true;
 481 #ifdef SIGCHLD
 482           /* System V fork+wait does not work if SIGCHLD is ignored.  */
 483           signal (SIGCHLD, SIG_DFL);
 484 #endif
 485           break;
 486         case STRIP_PROGRAM_OPTION:
 487           strip_program = xstrdup (optarg);
 488           strip_program_specified = true;
 489           break;
 490         case 'd':
 491           dir_arg = true;
 492           break;
 493         case 'D':
 494           mkdir_and_install = true;
 495           break;
 496         case 'v':
 497           x.verbose = true;
 498           break;
 499         case 'g':
 500           group_name = optarg;
 501           break;
 502         case 'm':
 503           specified_mode = optarg;
 504           break;
 505         case 'o':
 506           owner_name = optarg;
 507           break;
 508         case 'p':
 509           x.preserve_timestamps = true;
 510           break;
 511         case 'S':
 512           make_backups = true;
 513           backup_suffix_string = optarg;
 514           break;
 515         case 't':
 516           if (target_directory)
 517             error (EXIT_FAILURE, 0,
 518                    _("multiple target directories specified"));
 519           else
 520             {
 521               struct stat st;
 522               if (stat (optarg, &st) != 0)
 523                 error (EXIT_FAILURE, errno, _("accessing %s"), quote (optarg));
 524               if (! S_ISDIR (st.st_mode))
 525                 error (EXIT_FAILURE, 0, _("target %s is not a directory"),
 526                        quote (optarg));
 527             }
 528           target_directory = optarg;
 529           break;
 530         case 'T':
 531           no_target_directory = true;
 532           break;
 533
 534         case PRESERVE_CONTEXT_OPTION_DEPRECATED:
 535           error (0, 0, _("WARNING: --preserve_context is deprecated; "
 536                          "use --preserve-context instead"));
 537           /* fall through */
 538         case PRESERVE_CONTEXT_OPTION:
 539           if ( ! selinux_enabled)
 540             {
 541               error (0, 0, _("WARNING: ignoring --preserve-context; "
 542                              "this kernel is not SELinux-enabled"));
 543               break;
 544             }
 545           x.preserve_security_context = true;
 546           use_default_selinux_context = false;
 547           break;
 548         case 'Z':
 549           if ( ! selinux_enabled)
 550             {
 551               error (0, 0, _("WARNING: ignoring --context (-Z); "
 552                              "this kernel is not SELinux-enabled"));
 553               break;
 554             }
 555           scontext = optarg;
 556           use_default_selinux_context = false;
 557           break;
 558         case_GETOPT_HELP_CHAR;
 559         case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
 560         default:
 561           usage (EXIT_FAILURE);
 562         }
 563     }
 564
 565   /* Check for invalid combinations of arguments. */
 566   if (dir_arg & strip_files)
 567     error (EXIT_FAILURE, 0,
 568            _("the strip option may not be used when installing a directory"));
 569   if (dir_arg && target_directory)
 570     error (EXIT_FAILURE, 0,
 571            _("target directory not allowed when installing a directory"));
 572
 573   if (x.preserve_security_context && scontext != NULL)
 574     error (EXIT_FAILURE, 0,
 575            _("cannot force target context to %s and preserve it"),
 576            quote (scontext));
 577
 578   if (backup_suffix_string)
 579     simple_backup_suffix = xstrdup (backup_suffix_string);
 580
 581   x.backup_type = (make_backups
 582                    ? xget_version (_("backup type"),
 583                                    version_control_string)
 584                    : no_backups);
 585
 586   if (scontext && setfscreatecon (scontext) < 0)
 587     error (EXIT_FAILURE, errno,
 588            _("failed to set default file creation context to %s"),
 589            quote (scontext));
 590
 591   n_files = argc - optind;
 592   file = argv + optind;
 593
 594   if (n_files <= ! (dir_arg || target_directory))
 595     {
 596       if (n_files <= 0)
 597         error (0, 0, _("missing file operand"));
 598       else
 599         error (0, 0, _("missing destination file operand after %s"),
 600                quote (file[0]));
 601       usage (EXIT_FAILURE);
 602     }
 603
 604   if (no_target_directory)
 605     {
 606       if (target_directory)
 607         error (EXIT_FAILURE, 0,
 608                _("cannot combine --target-directory (-t) "
 609                  "and --no-target-directory (-T)"));
 610       if (2 < n_files)
 611         {
 612           error (0, 0, _("extra operand %s"), quote (file[2]));
 613           usage (EXIT_FAILURE);
 614         }
 615     }
 616   else if (! (dir_arg || target_directory))
 617     {
 618       if (2 <= n_files && target_directory_operand (file[n_files - 1]))
 619         target_directory = file[--n_files];
 620       else if (2 < n_files)
 621         error (EXIT_FAILURE, 0, _("target %s is not a directory"),
 622                quote (file[n_files - 1]));
 623     }
 624
 625   if (specified_mode)
 626     {
 627       struct mode_change *change = mode_compile (specified_mode);
 628       if (!change)
 629         error (EXIT_FAILURE, 0, _("invalid mode %s"), quote (specified_mode));
 630       mode = mode_adjust (0, false, 0, change, NULL);
 631       dir_mode = mode_adjust (0, true, 0, change, &dir_mode_bits);
 632       free (change);
 633     }
 634
 635   if (strip_program_specified && !strip_files)
 636     error (0, 0, _("WARNING: ignoring --strip-program option as -s option was "
 637                    "not specified"));
 638
 639   if (copy_only_if_needed && x.preserve_timestamps)
 640     {
 641       error (0, 0, _("options --compare (-C) and --preserve-timestamps are "
 642                      "mutually exclusive"));
 643       usage (EXIT_FAILURE);
 644     }
 645
 646   if (copy_only_if_needed && strip_files)
 647     {
 648       error (0, 0, _("options --compare (-C) and --strip are mutually "
 649                      "exclusive"));
 650       usage (EXIT_FAILURE);
 651     }
 652
 653   if (copy_only_if_needed && extra_mode (mode))
 654     error (0, 0, _("the --compare (-C) option is ignored when you"
 655                    " specify a mode with non-permission bits"));
 656
 657   get_ids ();
 658
 659   if (dir_arg)
 660     exit_status = savewd_process_files (n_files, file, process_dir, &x);
 661   else
 662     {
 663       /* FIXME: it's a little gross that this initialization is
 664          required by copy.c::copy. */
 665       hash_init ();
 666
 667       if (!target_directory)
 668         {
 669           if (! (mkdir_and_install
 670                  ? install_file_in_file_parents (file[0], file[1], &x)
 671                  : install_file_in_file (file[0], file[1], &x)))
 672             exit_status = EXIT_FAILURE;
 673         }
 674       else
 675         {
 676           int i;
 677           dest_info_init (&x);
 678           for (i = 0; i < n_files; i++)
 679             if (! install_file_in_dir (file[i], target_directory, &x))
 680               exit_status = EXIT_FAILURE;
 681         }
 682     }
 683
 684   exit (exit_status);
 685 }
 686
 687 /* Copy file FROM onto file TO, creating any missing parent directories of TO.
 688    Return true if successful.  */
 689
 690 static bool
 691 install_file_in_file_parents (char const *from, char *to,
 692                               struct cp_options *x)
 693 {
 694   bool save_working_directory =
 695     ! (IS_ABSOLUTE_FILE_NAME (from) && IS_ABSOLUTE_FILE_NAME (to));
 696   int status = EXIT_SUCCESS;
 697
 698   struct savewd wd;
 699   savewd_init (&wd);
 700   if (! save_working_directory)
 701     savewd_finish (&wd);
 702
 703   if (mkancesdirs (to, &wd, make_ancestor, x) == -1)
 704     {
 705       error (0, errno, _("cannot create directory %s"), to);
 706       status = EXIT_FAILURE;
 707     }
 708
 709   if (save_working_directory)
 710     {
 711       int restore_result = savewd_restore (&wd, status);
 712       int restore_errno = errno;
 713       savewd_finish (&wd);
 714       if (EXIT_SUCCESS < restore_result)
 715         return false;
 716       if (restore_result < 0 && status == EXIT_SUCCESS)
 717         {
 718           error (0, restore_errno, _("cannot create directory %s"), to);
 719           return false;
 720         }
 721     }
 722
 723   return (status == EXIT_SUCCESS && install_file_in_file (from, to, x));
 724 }
 725
 726 /* Copy file FROM onto file TO and give TO the appropriate
 727    attributes.
 728    Return true if successful.  */
 729
 730 static bool
 731 install_file_in_file (const char *from, const char *to,
 732                       const struct cp_options *x)
 733 {
 734   struct stat from_sb;
 735   if (x->preserve_timestamps && stat (from, &from_sb) != 0)
 736     {
 737       error (0, errno, _("cannot stat %s"), quote (from));
 738       return false;
 739     }
 740   if (! copy_file (from, to, x))
 741     return false;
 742   if (strip_files)
 743     strip (to);
 744   if (x->preserve_timestamps && (strip_files || ! S_ISREG (from_sb.st_mode))
 745       && ! change_timestamps (&from_sb, to))
 746     return false;
 747   return change_attributes (to);
 748 }
 749
 750 /* Copy file FROM into directory TO_DIR, keeping its same name,
 751    and give the copy the appropriate attributes.
 752    Return true if successful.  */
 753
 754 static bool
 755 install_file_in_dir (const char *from, const char *to_dir,
 756                      const struct cp_options *x)
 757 {
 758   const char *from_base = last_component (from);
 759   char *to = file_name_concat (to_dir, from_base, NULL);
 760   bool ret = install_file_in_file (from, to, x);
 761   free (to);
 762   return ret;
 763 }
 764
 765 /* Copy file FROM onto file TO, creating TO if necessary.
 766    Return true if successful.  */
 767
 768 static bool
 769 copy_file (const char *from, const char *to, const struct cp_options *x)
 770 {
 771   bool copy_into_self;
 772
 773   if (copy_only_if_needed && !need_copy (from, to, x))
 774     return true;
 775
 776   /* Allow installing from non-regular files like /dev/null.
 777      Charles Karney reported that some Sun version of install allows that
 778      and that sendmail's installation process relies on the behavior.
 779      However, since !x->recursive, the call to "copy" will fail if FROM
 780      is a directory.  */
 781
 782   return copy (from, to, false, x, &copy_into_self, NULL);
 783 }
 784
 785 /* Set the attributes of file or directory NAME.
 786    Return true if successful.  */
 787
 788 static bool
 789 change_attributes (char const *name)
 790 {
 791   bool ok = false;
 792   /* chown must precede chmod because on some systems,
 793      chown clears the set[ug]id bits for non-superusers,
 794      resulting in incorrect permissions.
 795      On System V, users can give away files with chown and then not
 796      be able to chmod them.  So don't give files away.
 797
 798      We don't normally ignore errors from chown because the idea of
 799      the install command is that the file is supposed to end up with
 800      precisely the attributes that the user specified (or defaulted).
 801      If the file doesn't end up with the group they asked for, they'll
 802      want to know.  */
 803
 804   if (! (owner_id == (uid_t) -1 && group_id == (gid_t) -1)
 805       && lchown (name, owner_id, group_id) != 0)
 806     error (0, errno, _("cannot change ownership of %s"), quote (name));
 807   else if (chmod (name, mode) != 0)
 808     error (0, errno, _("cannot change permissions of %s"), quote (name));
 809   else
 810     ok = true;
 811
 812   if (use_default_selinux_context)
 813     setdefaultfilecon (name);
 814
 815   return ok;
 816 }
 817
 818 /* Set the timestamps of file TO to match those of file FROM.
 819    Return true if successful.  */
 820
 821 static bool
 822 change_timestamps (struct stat const *from_sb, char const *to)
 823 {
 824   struct timespec timespec[2];
 825   timespec[0] = get_stat_atime (from_sb);
 826   timespec[1] = get_stat_mtime (from_sb);
 827
 828   if (utimens (to, timespec))
 829     {
 830       error (0, errno, _("cannot set time stamps for %s"), quote (to));
 831       return false;
 832     }
 833   return true;
 834 }
 835
 836 /* Strip the symbol table from the file NAME.
 837    We could dig the magic number out of the file first to
 838    determine whether to strip it, but the header files and
 839    magic numbers vary so much from system to system that making
 840    it portable would be very difficult.  Not worth the effort. */
 841
 842 static void
 843 strip (char const *name)
 844 {
 845   int status;
 846   pid_t pid = fork ();
 847
 848   switch (pid)
 849     {
 850     case -1:
 851       error (EXIT_FAILURE, errno, _("fork system call failed"));
 852       break;
 853     case 0:                     /* Child. */
 854       execlp (strip_program, strip_program, name, NULL);
 855       error (EXIT_FAILURE, errno, _("cannot run %s"), strip_program);
 856       break;
 857     default:                    /* Parent. */
 858       if (waitpid (pid, &status, 0) < 0)
 859         error (EXIT_FAILURE, errno, _("waiting for strip"));
 860       else if (! WIFEXITED (status) || WEXITSTATUS (status))
 861         error (EXIT_FAILURE, 0, _("strip process terminated abnormally"));
 862       break;
 863     }
 864 }
 865
 866 /* Initialize the user and group ownership of the files to install. */
 867
 868 static void
 869 get_ids (void)
 870 {
 871   struct passwd *pw;
 872   struct group *gr;
 873
 874   if (owner_name)
 875     {
 876       pw = getpwnam (owner_name);
 877       if (pw == NULL)
 878         {
 879           unsigned long int tmp;
 880           if (xstrtoul (owner_name, NULL, 0, &tmp, NULL) != LONGINT_OK
 881               || UID_T_MAX < tmp)
 882             error (EXIT_FAILURE, 0, _("invalid user %s"), quote (owner_name));
 883           owner_id = tmp;
 884         }
 885       else
 886         owner_id = pw->pw_uid;
 887       endpwent ();
 888     }
 889   else
 890     owner_id = (uid_t) -1;
 891
 892   if (group_name)
 893     {
 894       gr = getgrnam (group_name);
 895       if (gr == NULL)
 896         {
 897           unsigned long int tmp;
 898           if (xstrtoul (group_name, NULL, 0, &tmp, NULL) != LONGINT_OK
 899               || GID_T_MAX < tmp)
 900             error (EXIT_FAILURE, 0, _("invalid group %s"), quote (group_name));
 901           group_id = tmp;
 902         }
 903       else
 904         group_id = gr->gr_gid;
 905       endgrent ();
 906     }
 907   else
 908     group_id = (gid_t) -1;
 909 }
 910
 911 /* Report that directory DIR was made, if OPTIONS requests this.  */
 912 static void
 913 announce_mkdir (char const *dir, void *options)
 914 {
 915   struct cp_options const *x = options;
 916   if (x->verbose)
 917     prog_fprintf (stdout, _("creating directory %s"), quote (dir));
 918 }
 919
 920 /* Make ancestor directory DIR, whose last file name component is
 921    COMPONENT, with options OPTIONS.  Assume the working directory is
 922    COMPONENT's parent.  */
 923 static int
 924 make_ancestor (char const *dir, char const *component, void *options)
 925 {
 926   int r = mkdir (component, DEFAULT_MODE);
 927   if (r == 0)
 928     announce_mkdir (dir, options);
 929   return r;
 930 }
 931
 932 void
 933 usage (int status)
 934 {
 935   if (status != EXIT_SUCCESS)
 936     fprintf (stderr, _("Try `%s --help' for more information.\n"),
 937              program_name);
 938   else
 939     {
 940       printf (_("\
 941 Usage: %s [OPTION]... [-T] SOURCE DEST\n\
 942   or:  %s [OPTION]... SOURCE... DIRECTORY\n\
 943   or:  %s [OPTION]... -t DIRECTORY SOURCE...\n\
 944   or:  %s [OPTION]... -d DIRECTORY...\n\
 945 "),
 946               program_name, program_name, program_name, program_name);
 947       fputs (_("\
 948 \n\
 949 This install program copies files (often just compiled) into destination\n\
 950 locations you choose.  If you want to download and install a ready-to-use\n\
 951 package on a GNU/Linux system, you should instead be using a package manager\n\
 952 like yum(1) or apt-get(1).\n\
 953 \n\
 954 In the first three forms, copy SOURCE to DEST or multiple SOURCE(s) to\n\
 955 the existing DIRECTORY, while setting permission modes and owner/group.\n\
 956 In the 4th form, create all components of the given DIRECTORY(ies).\n\
 957 \n\
 958 "), stdout);
 959       fputs (_("\
 960 Mandatory arguments to long options are mandatory for short options too.\n\
 961 "), stdout);
 962       fputs (_("\
 963       --backup[=CONTROL]  make a backup of each existing destination file\n\
 964   -b                  like --backup but does not accept an argument\n\
 965   -c                  (ignored)\n\
 966   -C, --compare       compare each pair of source and destination files, and\n\
 967                         in some cases, do not modify the destination at all\n\
 968   -d, --directory     treat all arguments as directory names; create all\n\
 969                         components of the specified directories\n\
 970 "), stdout);
 971       fputs (_("\
 972   -D                  create all leading components of DEST except the last,\n\
 973                         then copy SOURCE to DEST\n\
 974   -g, --group=GROUP   set group ownership, instead of process' current group\n\
 975   -m, --mode=MODE     set permission mode (as in chmod), instead of rwxr-xr-x\n\
 976   -o, --owner=OWNER   set ownership (super-user only)\n\
 977 "), stdout);
 978       fputs (_("\
 979   -p, --preserve-timestamps   apply access/modification times of SOURCE files\n\
 980                         to corresponding destination files\n\
 981   -s, --strip         strip symbol tables\n\
 982       --strip-program=PROGRAM  program used to strip binaries\n\
 983   -S, --suffix=SUFFIX  override the usual backup suffix\n\
 984   -t, --target-directory=DIRECTORY  copy all SOURCE arguments into DIRECTORY\n\
 985   -T, --no-target-directory  treat DEST as a normal file\n\
 986   -v, --verbose       print the name of each directory as it is created\n\
 987 "), stdout);
 988       fputs (_("\
 989       --preserve-context  preserve SELinux security context\n\
 990   -Z, --context=CONTEXT  set SELinux security context of files and directories\n\
 991 "), stdout);
 992
 993       fputs (HELP_OPTION_DESCRIPTION, stdout);
 994       fputs (VERSION_OPTION_DESCRIPTION, stdout);
 995       fputs (_("\
 996 \n\
 997 The backup suffix is `~', unless set with --suffix or SIMPLE_BACKUP_SUFFIX.\n\
 998 The version control method may be selected via the --backup option or through\n\
 999 the VERSION_CONTROL environment variable.  Here are the values:\n\
1000 \n\
1001 "), stdout);
1002       fputs (_("\
1003   none, off       never make backups (even if --backup is given)\n\
1004   numbered, t     make numbered backups\n\
1005   existing, nil   numbered if numbered backups exist, simple otherwise\n\
1006   simple, never   always make simple backups\n\
1007 "), stdout);
1008       emit_bug_reporting_address ();
1009     }
1010   exit (status);
1011 }