src/install.c

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