src/install.c

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