src/install.c

   1 /* install - copy files and set attributes
   2    Copyright (C) 89, 90, 91, 1995-2005 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 2, or (at your option)
   7    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, write to the Free Software Foundation,
  16    Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
  17
  18 /* Written by David MacKenzie <djm@gnu.ai.mit.edu> */
  19
  20 #include <config.h>
  21 #include <stdio.h>
  22 #include <getopt.h>
  23 #include <sys/types.h>
  24 #include <signal.h>
  25 #include <pwd.h>
  26 #include <grp.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 "dirname.h"
  34 #include "filenamecat.h"
  35 #include "mkdir-p.h"
  36 #include "modechange.h"
  37 #include "quote.h"
  38 #include "utimens.h"
  39 #include "xstrtol.h"
  40
  41 /* The official name of this program (e.g., no `g' prefix).  */
  42 #define PROGRAM_NAME "install"
  43
  44 #define AUTHORS "David MacKenzie"
  45
  46 #if HAVE_SYS_WAIT_H
  47 # include <sys/wait.h>
  48 #endif
  49
  50 #if ! HAVE_ENDGRENT
  51 # define endgrent() ((void) 0)
  52 #endif
  53
  54 #if ! HAVE_ENDPWENT
  55 # define endpwent() ((void) 0)
  56 #endif
  57
  58 /* Initial number of entries in each hash table entry's table of inodes.  */
  59 #define INITIAL_HASH_MODULE 100
  60
  61 /* Initial number of entries in the inode hash table.  */
  62 #define INITIAL_ENTRY_TAB_SIZE 70
  63
  64 /* Number of bytes of a file to copy at a time. */
  65 #define READ_SIZE (32 * 1024)
  66
  67 static bool change_timestamps (const char *from, const char *to);
  68 static bool change_attributes (char const *name);
  69 static bool copy_file (const char *from, const char *to,
  70                        const struct cp_options *x);
  71 static bool install_file_in_file_parents (char const *from, char const *to,
  72                                           struct cp_options const *x);
  73 static bool install_file_in_dir (const char *from, const char *to_dir,
  74                                  const struct cp_options *x);
  75 static bool install_file_in_file (const char *from, const char *to,
  76                                   const struct cp_options *x);
  77 static void get_ids (void);
  78 static void strip (char const *name);
  79 void usage (int status);
  80
  81 /* The name this program was run with, for error messages. */
  82 char *program_name;
  83
  84 /* The user name that will own the files, or NULL to make the owner
  85    the current user ID. */
  86 static char *owner_name;
  87
  88 /* The user ID corresponding to `owner_name'. */
  89 static uid_t owner_id;
  90
  91 /* The group name that will own the files, or NULL to make the group
  92    the current group ID. */
  93 static char *group_name;
  94
  95 /* The group ID corresponding to `group_name'. */
  96 static gid_t group_id;
  97
  98 /* The permissions to which the files will be set.  The umask has
  99    no effect. */
 100 static mode_t mode = S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH;
 101
 102 /* If true, strip executable files after copying them. */
 103 static bool strip_files;
 104
 105 /* If true, install a directory instead of a regular file. */
 106 static bool dir_arg;
 107
 108 static struct option const long_options[] =
 109 {
 110   {"backup", optional_argument, NULL, 'b'},
 111   {"directory", no_argument, NULL, 'd'},
 112   {"group", required_argument, NULL, 'g'},
 113   {"mode", required_argument, NULL, 'm'},
 114   {"no-target-directory", no_argument, NULL, 'T'},
 115   {"owner", required_argument, NULL, 'o'},
 116   {"preserve-timestamps", no_argument, NULL, 'p'},
 117   {"strip", no_argument, NULL, 's'},
 118   {"suffix", required_argument, NULL, 'S'},
 119   {"target-directory", required_argument, NULL, 't'},
 120   {"version-control", required_argument, NULL, 'V'}, /* Deprecated. FIXME. */
 121   {"verbose", no_argument, NULL, 'v'},
 122   {GETOPT_HELP_OPTION_DECL},
 123   {GETOPT_VERSION_OPTION_DECL},
 124   {NULL, 0, NULL, 0}
 125 };
 126
 127 static void
 128 cp_option_init (struct cp_options *x)
 129 {
 130   x->copy_as_regular = true;
 131   x->dereference = DEREF_ALWAYS;
 132   x->unlink_dest_before_opening = true;
 133   x->unlink_dest_after_failed_open = false;
 134   x->hard_link = false;
 135   x->interactive = I_UNSPECIFIED;
 136   x->move_mode = false;
 137   x->chown_privileges = chown_privileges ();
 138   x->one_file_system = false;
 139   x->preserve_ownership = false;
 140   x->preserve_links = false;
 141   x->preserve_mode = false;
 142   x->preserve_timestamps = false;
 143   x->require_preserve = false;
 144   x->recursive = false;
 145   x->sparse_mode = SPARSE_AUTO;
 146   x->symbolic_link = false;
 147   x->backup_type = no_backups;
 148
 149   /* Create destination files initially writable so we can run strip on them.
 150      Although GNU strip works fine on read-only files, some others
 151      would fail.  */
 152   x->set_mode = true;
 153   x->mode = S_IRUSR | S_IWUSR;
 154   x->stdin_tty = false;
 155
 156   x->umask_kill = 0;
 157   x->update = false;
 158   x->verbose = false;
 159   x->dest_info = NULL;
 160   x->src_info = NULL;
 161 }
 162
 163 /* FILE is the last operand of this command.  Return true if FILE is a
 164    directory.  But report an error there is a problem accessing FILE,
 165    or if FILE does not exist but would have to refer to an existing
 166    directory if it referred to anything at all.  */
 167
 168 static bool
 169 target_directory_operand (char const *file)
 170 {
 171   char const *b = base_name (file);
 172   size_t blen = strlen (b);
 173   bool looks_like_a_dir = (blen == 0 || ISSLASH (b[blen - 1]));
 174   struct stat st;
 175   int err = (stat (file, &st) == 0 ? 0 : errno);
 176   bool is_a_dir = !err && S_ISDIR (st.st_mode);
 177   if (err && err != ENOENT)
 178     error (EXIT_FAILURE, err, _("accessing %s"), quote (file));
 179   if (is_a_dir < looks_like_a_dir)
 180     error (EXIT_FAILURE, err, _("target %s is not a directory"), quote (file));
 181   return is_a_dir;
 182 }
 183
 184 int
 185 main (int argc, char **argv)
 186 {
 187   int optc;
 188   bool ok = true;
 189   const char *specified_mode = NULL;
 190   bool make_backups = false;
 191   char *backup_suffix_string;
 192   char *version_control_string = NULL;
 193   bool mkdir_and_install = false;
 194   struct cp_options x;
 195   char const *target_directory = NULL;
 196   bool no_target_directory = false;
 197   int n_files;
 198   char **file;
 199
 200   initialize_main (&argc, &argv);
 201   program_name = argv[0];
 202   setlocale (LC_ALL, "");
 203   bindtextdomain (PACKAGE, LOCALEDIR);
 204   textdomain (PACKAGE);
 205
 206   atexit (close_stdout);
 207
 208   cp_option_init (&x);
 209
 210   owner_name = NULL;
 211   group_name = NULL;
 212   strip_files = false;
 213   dir_arg = false;
 214   umask (0);
 215
 216   /* FIXME: consider not calling getenv for SIMPLE_BACKUP_SUFFIX unless
 217      we'll actually use backup_suffix_string.  */
 218   backup_suffix_string = getenv ("SIMPLE_BACKUP_SUFFIX");
 219
 220   while ((optc = getopt_long (argc, argv, "bcsDdg:m:o:pt:TvV:S:", long_options,
 221                               NULL)) != -1)
 222     {
 223       switch (optc)
 224         {
 225         case 'V':  /* FIXME: this is deprecated.  Remove it in 2001.  */
 226           error (0, 0,
 227                  _("warning: --version-control (-V) is obsolete;  support for\
 228  it\nwill be removed in some future release.  Use --backup=%s instead."
 229                    ), optarg);
 230           /* Fall through.  */
 231
 232         case 'b':
 233           make_backups = true;
 234           if (optarg)
 235             version_control_string = optarg;
 236           break;
 237         case 'c':
 238           break;
 239         case 's':
 240           strip_files = true;
 241 #ifdef SIGCHLD
 242           /* System V fork+wait does not work if SIGCHLD is ignored.  */
 243           signal (SIGCHLD, SIG_DFL);
 244 #endif
 245           break;
 246         case 'd':
 247           dir_arg = true;
 248           break;
 249         case 'D':
 250           mkdir_and_install = true;
 251           break;
 252         case 'v':
 253           x.verbose = true;
 254           break;
 255         case 'g':
 256           group_name = optarg;
 257           break;
 258         case 'm':
 259           specified_mode = optarg;
 260           break;
 261         case 'o':
 262           owner_name = optarg;
 263           break;
 264         case 'p':
 265           x.preserve_timestamps = true;
 266           break;
 267         case 'S':
 268           make_backups = true;
 269           backup_suffix_string = optarg;
 270           break;
 271         case 't':
 272           if (target_directory)
 273             error (EXIT_FAILURE, 0,
 274                    _("multiple target directories specified"));
 275           else
 276             {
 277               struct stat st;
 278               if (stat (optarg, &st) != 0)
 279                 error (EXIT_FAILURE, errno, _("accessing %s"), quote (optarg));
 280               if (! S_ISDIR (st.st_mode))
 281                 error (EXIT_FAILURE, 0, _("target %s is not a directory"),
 282                        quote (optarg));
 283             }
 284           target_directory = optarg;
 285           break;
 286         case 'T':
 287           no_target_directory = true;
 288           break;
 289         case_GETOPT_HELP_CHAR;
 290         case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
 291         default:
 292           usage (EXIT_FAILURE);
 293         }
 294     }
 295
 296   /* Check for invalid combinations of arguments. */
 297   if (dir_arg & strip_files)
 298     error (EXIT_FAILURE, 0,
 299            _("the strip option may not be used when installing a directory"));
 300   if (dir_arg && target_directory)
 301     error (EXIT_FAILURE, 0,
 302            _("target directory not allowed when installing a directory"));
 303
 304   if (backup_suffix_string)
 305     simple_backup_suffix = xstrdup (backup_suffix_string);
 306
 307   x.backup_type = (make_backups
 308                    ? xget_version (_("backup type"),
 309                                    version_control_string)
 310                    : no_backups);
 311
 312   n_files = argc - optind;
 313   file = argv + optind;
 314
 315   if (n_files <= ! (dir_arg || target_directory))
 316     {
 317       if (n_files <= 0)
 318         error (0, 0, _("missing file operand"));
 319       else
 320         error (0, 0, _("missing destination file operand after %s"),
 321                quote (file[0]));
 322       usage (EXIT_FAILURE);
 323     }
 324
 325   if (no_target_directory)
 326     {
 327       if (target_directory)
 328         error (EXIT_FAILURE, 0,
 329                _("Cannot combine --target-directory (-t) "
 330                  "and --no-target-directory (-T)"));
 331       if (2 < n_files)
 332         {
 333           error (0, 0, _("extra operand %s"), quote (file[2]));
 334           usage (EXIT_FAILURE);
 335         }
 336     }
 337   else if (! (dir_arg || target_directory))
 338     {
 339       if (2 <= n_files && target_directory_operand (file[n_files - 1]))
 340         target_directory = file[--n_files];
 341       else if (2 < n_files)
 342         error (EXIT_FAILURE, 0, _("target %s is not a directory"),
 343                quote (file[n_files - 1]));
 344     }
 345
 346   if (specified_mode)
 347     {
 348       struct mode_change *change = mode_compile (specified_mode);
 349       if (!change)
 350         error (EXIT_FAILURE, 0, _("invalid mode %s"), quote (specified_mode));
 351       mode = mode_adjust (0, change, 0);
 352       free (change);
 353     }
 354
 355   get_ids ();
 356
 357   if (dir_arg)
 358     {
 359       int i;
 360       bool cwd_not_restored = false;
 361       for (i = 0; i < n_files; i++)
 362         {
 363           if (cwd_not_restored && IS_RELATIVE_FILE_NAME (argv[optind]))
 364             {
 365               error (0, 0,
 366                      _("unable to create relative-named directory, %s,"
 367                        " due to prior failure to return to working directory"),
 368                      quote (argv[optind]));
 369               ok = false;;
 370               continue;
 371             }
 372
 373           ok &=
 374             make_dir_parents (file[i], mode, mode, owner_id, group_id, false,
 375                               (x.verbose ? _("creating directory %s") : NULL),
 376                               &cwd_not_restored);
 377         }
 378     }
 379   else
 380     {
 381       /* FIXME: it's a little gross that this initialization is
 382          required by copy.c::copy. */
 383       hash_init ();
 384
 385       if (!target_directory)
 386         {
 387           if (mkdir_and_install)
 388             ok = install_file_in_file_parents (file[0], file[1], &x);
 389           else
 390             ok = install_file_in_file (file[0], file[1], &x);
 391         }
 392       else
 393         {
 394           int i;
 395           dest_info_init (&x);
 396           for (i = 0; i < n_files; i++)
 397             {
 398               ok &= install_file_in_dir (file[i], target_directory, &x);
 399             }
 400         }
 401     }
 402
 403   exit (ok ? EXIT_SUCCESS : EXIT_FAILURE);
 404 }
 405
 406 /* Copy file FROM onto file TO, creating any missing parent directories of TO.
 407    Return true if successful.  */
 408
 409 static bool
 410 install_file_in_file_parents (char const *from, char const *to,
 411                               struct cp_options const *x)
 412 {
 413   char *dest_dir = dir_name (to);
 414   bool ok = true;
 415
 416   /* Make sure that the parent of the destination is a directory.  */
 417   if (! STREQ (dest_dir, "."))
 418     {
 419       /* Someone will probably ask for a new option or three to specify
 420          owner, group, and permissions for parent directories.  Remember
 421          that this option is intended mainly to help installers when the
 422          distribution doesn't provide proper install rules.  */
 423       mode_t dir_mode = S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH;
 424       bool different_cwd;
 425       ok = make_dir_parents (dest_dir, dir_mode, dir_mode,
 426                              owner_id, group_id, true,
 427                              (x->verbose ? _("creating directory %s") : NULL),
 428                              &different_cwd);
 429       /* Ignore different_cwd, since this function is called at most once.  */
 430     }
 431
 432   free (dest_dir);
 433
 434   if (ok)
 435     ok = install_file_in_file (from, to, x);
 436
 437   return ok;
 438 }
 439
 440 /* Copy file FROM onto file TO and give TO the appropriate
 441    attributes.
 442    Return true if successful.  */
 443
 444 static bool
 445 install_file_in_file (const char *from, const char *to,
 446                       const struct cp_options *x)
 447 {
 448   if (! copy_file (from, to, x))
 449     return false;
 450   if (strip_files)
 451     strip (to);
 452   if (! change_attributes (to))
 453     return false;
 454   if (x->preserve_timestamps)
 455     return change_timestamps (from, to);
 456   return true;
 457 }
 458
 459 /* Copy file FROM into directory TO_DIR, keeping its same name,
 460    and give the copy the appropriate attributes.
 461    Return true if successful.  */
 462
 463 static bool
 464 install_file_in_dir (const char *from, const char *to_dir,
 465                      const struct cp_options *x)
 466 {
 467   const char *from_base = base_name (from);
 468   char *to = file_name_concat (to_dir, from_base, NULL);
 469   bool ret = install_file_in_file (from, to, x);
 470   free (to);
 471   return ret;
 472 }
 473
 474 /* Copy file FROM onto file TO, creating TO if necessary.
 475    Return true if successful.  */
 476
 477 static bool
 478 copy_file (const char *from, const char *to, const struct cp_options *x)
 479 {
 480   bool copy_into_self;
 481
 482   /* Allow installing from non-regular files like /dev/null.
 483      Charles Karney reported that some Sun version of install allows that
 484      and that sendmail's installation process relies on the behavior.
 485      However, since !x->recursive, the call to "copy" will fail if FROM
 486      is a directory.  */
 487
 488   return copy (from, to, false, x, &copy_into_self, NULL);
 489 }
 490
 491 /* Set the attributes of file or directory NAME.
 492    Return true if successful.  */
 493
 494 static bool
 495 change_attributes (char const *name)
 496 {
 497   bool ok = true;
 498
 499   /* chown must precede chmod because on some systems,
 500      chown clears the set[ug]id bits for non-superusers,
 501      resulting in incorrect permissions.
 502      On System V, users can give away files with chown and then not
 503      be able to chmod them.  So don't give files away.
 504
 505      We don't normally ignore errors from chown because the idea of
 506      the install command is that the file is supposed to end up with
 507      precisely the attributes that the user specified (or defaulted).
 508      If the file doesn't end up with the group they asked for, they'll
 509      want to know.  But AFS returns EPERM when you try to change a
 510      file's group; thus the kludge.  */
 511
 512   if (chown (name, owner_id, group_id) != 0
 513 #ifdef AFS
 514       && errno != EPERM
 515 #endif
 516       )
 517     {
 518       error (0, errno, _("cannot change ownership of %s"), quote (name));
 519       ok = false;
 520     }
 521
 522   if (ok && chmod (name, mode) != 0)
 523     {
 524       error (0, errno, _("cannot change permissions of %s"), quote (name));
 525       ok = false;
 526     }
 527
 528   return ok;
 529 }
 530
 531 /* Set the timestamps of file TO to match those of file FROM.
 532    Return true if successful.  */
 533
 534 static bool
 535 change_timestamps (const char *from, const char *to)
 536 {
 537   struct stat stb;
 538   struct timespec timespec[2];
 539
 540   if (stat (from, &stb))
 541     {
 542       error (0, errno, _("cannot obtain time stamps for %s"), quote (from));
 543       return false;
 544     }
 545
 546   timespec[0].tv_sec = stb.st_atime;
 547   timespec[0].tv_nsec = TIMESPEC_NS (stb.st_atim);
 548   timespec[1].tv_sec = stb.st_mtime;
 549   timespec[1].tv_nsec = TIMESPEC_NS (stb.st_mtim);
 550   if (utimens (to, timespec))
 551     {
 552       error (0, errno, _("cannot set time stamps for %s"), quote (to));
 553       return false;
 554     }
 555   return true;
 556 }
 557
 558 /* Strip the symbol table from the file NAME.
 559    We could dig the magic number out of the file first to
 560    determine whether to strip it, but the header files and
 561    magic numbers vary so much from system to system that making
 562    it portable would be very difficult.  Not worth the effort. */
 563
 564 static void
 565 strip (char const *name)
 566 {
 567   int status;
 568   pid_t pid = fork ();
 569
 570   switch (pid)
 571     {
 572     case -1:
 573       error (EXIT_FAILURE, errno, _("fork system call failed"));
 574       break;
 575     case 0:                     /* Child. */
 576       execlp ("strip", "strip", name, NULL);
 577       error (EXIT_FAILURE, errno, _("cannot run strip"));
 578       break;
 579     default:                    /* Parent. */
 580       /* Parent process. */
 581       while (pid != wait (&status))     /* Wait for kid to finish. */
 582         /* Do nothing. */ ;
 583       if (status)
 584         error (EXIT_FAILURE, 0, _("strip failed"));
 585       break;
 586     }
 587 }
 588
 589 /* Initialize the user and group ownership of the files to install. */
 590
 591 static void
 592 get_ids (void)
 593 {
 594   struct passwd *pw;
 595   struct group *gr;
 596
 597   if (owner_name)
 598     {
 599       pw = getpwnam (owner_name);
 600       if (pw == NULL)
 601         {
 602           unsigned long int tmp;
 603           if (xstrtoul (owner_name, NULL, 0, &tmp, NULL) != LONGINT_OK
 604               || UID_T_MAX < tmp)
 605             error (EXIT_FAILURE, 0, _("invalid user %s"), quote (owner_name));
 606           owner_id = tmp;
 607         }
 608       else
 609         owner_id = pw->pw_uid;
 610       endpwent ();
 611     }
 612   else
 613     owner_id = (uid_t) -1;
 614
 615   if (group_name)
 616     {
 617       gr = getgrnam (group_name);
 618       if (gr == NULL)
 619         {
 620           unsigned long int tmp;
 621           if (xstrtoul (group_name, NULL, 0, &tmp, NULL) != LONGINT_OK
 622               || GID_T_MAX < tmp)
 623             error (EXIT_FAILURE, 0, _("invalid group %s"), quote (group_name));
 624           group_id = tmp;
 625         }
 626       else
 627         group_id = gr->gr_gid;
 628       endgrent ();
 629     }
 630   else
 631     group_id = (gid_t) -1;
 632 }
 633
 634 void
 635 usage (int status)
 636 {
 637   if (status != EXIT_SUCCESS)
 638     fprintf (stderr, _("Try `%s --help' for more information.\n"),
 639              program_name);
 640   else
 641     {
 642       printf (_("\
 643 Usage: %s [OPTION]... [-T] SOURCE DEST\n\
 644   or:  %s [OPTION]... SOURCE... DIRECTORY\n\
 645   or:  %s [OPTION]... -t DIRECTORY SOURCE...\n\
 646   or:  %s [OPTION]... -d DIRECTORY...\n\
 647 "),
 648               program_name, program_name, program_name, program_name);
 649       fputs (_("\
 650 In the first three forms, copy SOURCE to DEST or multiple SOURCE(s) to\n\
 651 the existing DIRECTORY, while setting permission modes and owner/group.\n\
 652 In the 4th form, create all components of the given DIRECTORY(ies).\n\
 653 \n\
 654 "), stdout);
 655       fputs (_("\
 656 Mandatory arguments to long options are mandatory for short options too.\n\
 657 "), stdout);
 658       fputs (_("\
 659       --backup[=CONTROL] make a backup of each existing destination file\n\
 660   -b                  like --backup but does not accept an argument\n\
 661   -c                  (ignored)\n\
 662   -d, --directory     treat all arguments as directory names; create all\n\
 663                         components of the specified directories\n\
 664 "), stdout);
 665       fputs (_("\
 666   -D                  create all leading components of DEST except the last,\n\
 667                         then copy SOURCE to DEST\n\
 668   -g, --group=GROUP   set group ownership, instead of process' current group\n\
 669   -m, --mode=MODE     set permission mode (as in chmod), instead of rwxr-xr-x\n\
 670   -o, --owner=OWNER   set ownership (super-user only)\n\
 671 "), stdout);
 672       fputs (_("\
 673   -p, --preserve-timestamps   apply access/modification times of SOURCE files\n\
 674                         to corresponding destination files\n\
 675   -s, --strip         strip symbol tables\n\
 676   -S, --suffix=SUFFIX override the usual backup suffix\n\
 677   -t, --target-directory=DIRECTORY  copy all SOURCE arguments into DIRECTORY\n\
 678   -T, --no-target-directory  treat DEST as a normal file\n\
 679   -v, --verbose       print the name of each directory as it is created\n\
 680 "), stdout);
 681       fputs (HELP_OPTION_DESCRIPTION, stdout);
 682       fputs (VERSION_OPTION_DESCRIPTION, stdout);
 683       fputs (_("\
 684 \n\
 685 The backup suffix is `~', unless set with --suffix or SIMPLE_BACKUP_SUFFIX.\n\
 686 The version control method may be selected via the --backup option or through\n\
 687 the VERSION_CONTROL environment variable.  Here are the values:\n\
 688 \n\
 689 "), stdout);
 690       fputs (_("\
 691   none, off       never make backups (even if --backup is given)\n\
 692   numbered, t     make numbered backups\n\
 693   existing, nil   numbered if numbered backups exist, simple otherwise\n\
 694   simple, never   always make simple backups\n\
 695 "), stdout);
 696       printf (_("\nReport bugs to <%s>.\n"), PACKAGE_BUGREPORT);
 697     }
 698   exit (status);
 699 }