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       int cwd_errno = 0;
 361       for (i = 0; i < n_files; i++)
 362         {
 363           if (cwd_errno != 0 && IS_RELATIVE_FILE_NAME (argv[optind]))
 364             {
 365               error (0, cwd_errno, _("cannot return to working directory"));
 366               ok = false;
 367             }
 368           else
 369             ok &=
 370               make_dir_parents (file[i], mode, mode, owner_id, group_id, false,
 371                                 (x.verbose ? _("creating directory %s") : NULL),
 372                                 &cwd_errno);
 373         }
 374     }
 375   else
 376     {
 377       /* FIXME: it's a little gross that this initialization is
 378          required by copy.c::copy. */
 379       hash_init ();
 380
 381       if (!target_directory)
 382         {
 383           if (mkdir_and_install)
 384             ok = install_file_in_file_parents (file[0], file[1], &x);
 385           else
 386             ok = install_file_in_file (file[0], file[1], &x);
 387         }
 388       else
 389         {
 390           int i;
 391           dest_info_init (&x);
 392           for (i = 0; i < n_files; i++)
 393             {
 394               ok &= install_file_in_dir (file[i], target_directory, &x);
 395             }
 396         }
 397     }
 398
 399   exit (ok ? EXIT_SUCCESS : EXIT_FAILURE);
 400 }
 401
 402 /* Copy file FROM onto file TO, creating any missing parent directories of TO.
 403    Return true if successful.  */
 404
 405 static bool
 406 install_file_in_file_parents (char const *from, char const *to,
 407                               struct cp_options const *x)
 408 {
 409   char *dest_dir = dir_name (to);
 410   bool ok = true;
 411
 412   /* Make sure that the parent of the destination is a directory.  */
 413   if (! STREQ (dest_dir, "."))
 414     {
 415       /* Someone will probably ask for a new option or three to specify
 416          owner, group, and permissions for parent directories.  Remember
 417          that this option is intended mainly to help installers when the
 418          distribution doesn't provide proper install rules.  */
 419       mode_t dir_mode = S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH;
 420       int cwd_errno = 0;
 421       ok = make_dir_parents (dest_dir, dir_mode, dir_mode,
 422                              owner_id, group_id, true,
 423                              (x->verbose ? _("creating directory %s") : NULL),
 424                              &cwd_errno);
 425       if (ok && cwd_errno != 0
 426           && (IS_RELATIVE_FILE_NAME (from) || IS_RELATIVE_FILE_NAME (to)))
 427         {
 428           error (0, cwd_errno, _("cannot return to current directory"));
 429           ok = false;
 430         }
 431     }
 432
 433   free (dest_dir);
 434
 435   if (ok)
 436     ok = install_file_in_file (from, to, x);
 437
 438   return ok;
 439 }
 440
 441 /* Copy file FROM onto file TO and give TO the appropriate
 442    attributes.
 443    Return true if successful.  */
 444
 445 static bool
 446 install_file_in_file (const char *from, const char *to,
 447                       const struct cp_options *x)
 448 {
 449   if (! copy_file (from, to, x))
 450     return false;
 451   if (strip_files)
 452     strip (to);
 453   if (! change_attributes (to))
 454     return false;
 455   if (x->preserve_timestamps)
 456     return change_timestamps (from, to);
 457   return true;
 458 }
 459
 460 /* Copy file FROM into directory TO_DIR, keeping its same name,
 461    and give the copy the appropriate attributes.
 462    Return true if successful.  */
 463
 464 static bool
 465 install_file_in_dir (const char *from, const char *to_dir,
 466                      const struct cp_options *x)
 467 {
 468   const char *from_base = base_name (from);
 469   char *to = file_name_concat (to_dir, from_base, NULL);
 470   bool ret = install_file_in_file (from, to, x);
 471   free (to);
 472   return ret;
 473 }
 474
 475 /* Copy file FROM onto file TO, creating TO if necessary.
 476    Return true if successful.  */
 477
 478 static bool
 479 copy_file (const char *from, const char *to, const struct cp_options *x)
 480 {
 481   bool copy_into_self;
 482
 483   /* Allow installing from non-regular files like /dev/null.
 484      Charles Karney reported that some Sun version of install allows that
 485      and that sendmail's installation process relies on the behavior.
 486      However, since !x->recursive, the call to "copy" will fail if FROM
 487      is a directory.  */
 488
 489   return copy (from, to, false, x, &copy_into_self, NULL);
 490 }
 491
 492 /* Set the attributes of file or directory NAME.
 493    Return true if successful.  */
 494
 495 static bool
 496 change_attributes (char const *name)
 497 {
 498   bool ok = true;
 499
 500   /* chown must precede chmod because on some systems,
 501      chown clears the set[ug]id bits for non-superusers,
 502      resulting in incorrect permissions.
 503      On System V, users can give away files with chown and then not
 504      be able to chmod them.  So don't give files away.
 505
 506      We don't normally ignore errors from chown because the idea of
 507      the install command is that the file is supposed to end up with
 508      precisely the attributes that the user specified (or defaulted).
 509      If the file doesn't end up with the group they asked for, they'll
 510      want to know.  But AFS returns EPERM when you try to change a
 511      file's group; thus the kludge.  */
 512
 513   if (chown (name, owner_id, group_id) != 0
 514 #ifdef AFS
 515       && errno != EPERM
 516 #endif
 517       )
 518     {
 519       error (0, errno, _("cannot change ownership of %s"), quote (name));
 520       ok = false;
 521     }
 522
 523   if (ok && chmod (name, mode) != 0)
 524     {
 525       error (0, errno, _("cannot change permissions of %s"), quote (name));
 526       ok = false;
 527     }
 528
 529   return ok;
 530 }
 531
 532 /* Set the timestamps of file TO to match those of file FROM.
 533    Return true if successful.  */
 534
 535 static bool
 536 change_timestamps (const char *from, const char *to)
 537 {
 538   struct stat stb;
 539   struct timespec timespec[2];
 540
 541   if (stat (from, &stb))
 542     {
 543       error (0, errno, _("cannot obtain time stamps for %s"), quote (from));
 544       return false;
 545     }
 546
 547   timespec[0].tv_sec = stb.st_atime;
 548   timespec[0].tv_nsec = TIMESPEC_NS (stb.st_atim);
 549   timespec[1].tv_sec = stb.st_mtime;
 550   timespec[1].tv_nsec = TIMESPEC_NS (stb.st_mtim);
 551   if (utimens (to, timespec))
 552     {
 553       error (0, errno, _("cannot set time stamps for %s"), quote (to));
 554       return false;
 555     }
 556   return true;
 557 }
 558
 559 /* Strip the symbol table from the file NAME.
 560    We could dig the magic number out of the file first to
 561    determine whether to strip it, but the header files and
 562    magic numbers vary so much from system to system that making
 563    it portable would be very difficult.  Not worth the effort. */
 564
 565 static void
 566 strip (char const *name)
 567 {
 568   int status;
 569   pid_t pid = fork ();
 570
 571   switch (pid)
 572     {
 573     case -1:
 574       error (EXIT_FAILURE, errno, _("fork system call failed"));
 575       break;
 576     case 0:                     /* Child. */
 577       execlp ("strip", "strip", name, NULL);
 578       error (EXIT_FAILURE, errno, _("cannot run strip"));
 579       break;
 580     default:                    /* Parent. */
 581       /* Parent process. */
 582       while (pid != wait (&status))     /* Wait for kid to finish. */
 583         /* Do nothing. */ ;
 584       if (status)
 585         error (EXIT_FAILURE, 0, _("strip failed"));
 586       break;
 587     }
 588 }
 589
 590 /* Initialize the user and group ownership of the files to install. */
 591
 592 static void
 593 get_ids (void)
 594 {
 595   struct passwd *pw;
 596   struct group *gr;
 597
 598   if (owner_name)
 599     {
 600       pw = getpwnam (owner_name);
 601       if (pw == NULL)
 602         {
 603           unsigned long int tmp;
 604           if (xstrtoul (owner_name, NULL, 0, &tmp, NULL) != LONGINT_OK
 605               || UID_T_MAX < tmp)
 606             error (EXIT_FAILURE, 0, _("invalid user %s"), quote (owner_name));
 607           owner_id = tmp;
 608         }
 609       else
 610         owner_id = pw->pw_uid;
 611       endpwent ();
 612     }
 613   else
 614     owner_id = (uid_t) -1;
 615
 616   if (group_name)
 617     {
 618       gr = getgrnam (group_name);
 619       if (gr == NULL)
 620         {
 621           unsigned long int tmp;
 622           if (xstrtoul (group_name, NULL, 0, &tmp, NULL) != LONGINT_OK
 623               || GID_T_MAX < tmp)
 624             error (EXIT_FAILURE, 0, _("invalid group %s"), quote (group_name));
 625           group_id = tmp;
 626         }
 627       else
 628         group_id = gr->gr_gid;
 629       endgrent ();
 630     }
 631   else
 632     group_id = (gid_t) -1;
 633 }
 634
 635 void
 636 usage (int status)
 637 {
 638   if (status != EXIT_SUCCESS)
 639     fprintf (stderr, _("Try `%s --help' for more information.\n"),
 640              program_name);
 641   else
 642     {
 643       printf (_("\
 644 Usage: %s [OPTION]... [-T] SOURCE DEST\n\
 645   or:  %s [OPTION]... SOURCE... DIRECTORY\n\
 646   or:  %s [OPTION]... -t DIRECTORY SOURCE...\n\
 647   or:  %s [OPTION]... -d DIRECTORY...\n\
 648 "),
 649               program_name, program_name, program_name, program_name);
 650       fputs (_("\
 651 In the first three forms, copy SOURCE to DEST or multiple SOURCE(s) to\n\
 652 the existing DIRECTORY, while setting permission modes and owner/group.\n\
 653 In the 4th form, create all components of the given DIRECTORY(ies).\n\
 654 \n\
 655 "), stdout);
 656       fputs (_("\
 657 Mandatory arguments to long options are mandatory for short options too.\n\
 658 "), stdout);
 659       fputs (_("\
 660       --backup[=CONTROL] make a backup of each existing destination file\n\
 661   -b                  like --backup but does not accept an argument\n\
 662   -c                  (ignored)\n\
 663   -d, --directory     treat all arguments as directory names; create all\n\
 664                         components of the specified directories\n\
 665 "), stdout);
 666       fputs (_("\
 667   -D                  create all leading components of DEST except the last,\n\
 668                         then copy SOURCE to DEST\n\
 669   -g, --group=GROUP   set group ownership, instead of process' current group\n\
 670   -m, --mode=MODE     set permission mode (as in chmod), instead of rwxr-xr-x\n\
 671   -o, --owner=OWNER   set ownership (super-user only)\n\
 672 "), stdout);
 673       fputs (_("\
 674   -p, --preserve-timestamps   apply access/modification times of SOURCE files\n\
 675                         to corresponding destination files\n\
 676   -s, --strip         strip symbol tables\n\
 677   -S, --suffix=SUFFIX override the usual backup suffix\n\
 678   -t, --target-directory=DIRECTORY  copy all SOURCE arguments into DIRECTORY\n\
 679   -T, --no-target-directory  treat DEST as a normal file\n\
 680   -v, --verbose       print the name of each directory as it is created\n\
 681 "), stdout);
 682       fputs (HELP_OPTION_DESCRIPTION, stdout);
 683       fputs (VERSION_OPTION_DESCRIPTION, stdout);
 684       fputs (_("\
 685 \n\
 686 The backup suffix is `~', unless set with --suffix or SIMPLE_BACKUP_SUFFIX.\n\
 687 The version control method may be selected via the --backup option or through\n\
 688 the VERSION_CONTROL environment variable.  Here are the values:\n\
 689 \n\
 690 "), stdout);
 691       fputs (_("\
 692   none, off       never make backups (even if --backup is given)\n\
 693   numbered, t     make numbered backups\n\
 694   existing, nil   numbered if numbered backups exist, simple otherwise\n\
 695   simple, never   always make simple backups\n\
 696 "), stdout);
 697       printf (_("\nReport bugs to <%s>.\n"), PACKAGE_BUGREPORT);
 698     }
 699   exit (status);
 700 }