src/install.c

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