*** empty log message ***

[chaz/tar] / src / tar.c

/* Tar -- a tape archiver.
   Copyright (C) 1988, 1992, 1993 Free Software Foundation

This file is part of GNU Tar.

GNU Tar is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.

GNU Tar is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with GNU Tar; see the file COPYING.  If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */

/*
 * A tar (tape archiver) program.
 *
 * Written by John Gilmore, ihnp4!hoptoad!gnu, starting 25 Aug 85.
 */

#include <stdio.h>
#include <sys/types.h>          /* Needed for typedefs in tar.h */
#include "getopt.h"
#include "regex.h"

/*
 * The following causes "tar.h" to produce definitions of all the
 * global variables, rather than just "extern" declarations of them.
 */
#define TAR_EXTERN              /**/
#include "tar.h"

#include "port.h"
#include "fnmatch.h"

/*
 * We should use a conversion routine that does reasonable error
 * checking -- atoi doesn't.  For now, punt.  FIXME.
 */
#define intconv atoi
PTR ck_malloc ();
PTR ck_realloc ();
extern int getoldopt ();
extern void read_and ();
extern void list_archive ();
extern void extract_archive ();
extern void diff_archive ();
extern void create_archive ();
extern void update_archive ();
extern void junk_archive ();
extern void init_volume_number ();
extern void closeout_volume_number ();

/* JF */
extern time_t get_date ();

time_t new_time;

static FILE *namef;             /* File to read names from */
static char **n_argv;           /* Argv used by name routines */
static int n_argc;              /* Argc used by name routines */
static char **n_ind;            /* Store an array of names */
static int n_indalloc;          /* How big is the array? */
static int n_indused;           /* How many entries does it have? */
static int n_indscan;           /* How many of the entries have we scanned? */


extern FILE *msg_file;

int check_exclude ();
void add_exclude ();
void add_exclude_file ();
void addname ();
void describe ();
void diff_init ();
void extr_init ();
int is_regex ();
void name_add ();
void name_init ();
void options ();
char *un_quote_string ();

#ifndef S_ISLNK
#define lstat stat
#endif

#ifndef DEFBLOCKING
#define DEFBLOCKING 20
#endif

#ifndef DEF_AR_FILE
#define DEF_AR_FILE "tar.out"
#endif

/* For long options that unconditionally set a single flag, we have getopt
   do it.  For the others, we share the code for the equivalent short
   named option, the name of which is stored in the otherwise-unused `val'
   field of the `struct option'; for long options that have no equivalent
   short option, we use nongraphic characters as pseudo short option
   characters, starting (for no particular reason) with character 10. */

struct option long_options[] =
{
  {"create", 0, 0, 'c'},
  {"append", 0, 0, 'r'},
  {"extract", 0, 0, 'x'},
  {"get", 0, 0, 'x'},
  {"list", 0, 0, 't'},
  {"update", 0, 0, 'u'},
  {"catenate", 0, 0, 'A'},
  {"concatenate", 0, 0, 'A'},
  {"compare", 0, 0, 'd'},
  {"diff", 0, 0, 'd'},
  {"delete", 0, 0, 14},
  {"help", 0, 0, 12},

  {"null", 0, 0, 16},
  {"directory", 1, 0, 'C'},
  {"record-number", 0, &f_sayblock, 1},
  {"files-from", 1, 0, 'T'},
  {"label", 1, 0, 'V'},
  {"exclude-from", 1, 0, 'X'},
  {"exclude", 1, 0, 15},
  {"file", 1, 0, 'f'},
  {"block-size", 1, 0, 'b'},
  {"version", 0, 0, 11},
  {"verbose", 0, 0, 'v'},
  {"totals", 0, &f_totals, 1},

  {"read-full-blocks", 0, &f_reblock, 1},
  {"starting-file", 1, 0, 'K'},
  {"to-stdout", 0, &f_exstdout, 1},
  {"ignore-zeros", 0, &f_ignorez, 1},
  {"keep-old-files", 0, 0, 'k'},
  {"same-permissions", 0, &f_use_protection, 1},
  {"preserve-permissions", 0, &f_use_protection, 1},
  {"modification-time", 0, &f_modified, 1},
  {"preserve", 0, 0, 10},
  {"same-order", 0, &f_sorted_names, 1},
  {"same-owner", 0, &f_do_chown, 1},
  {"preserve-order", 0, &f_sorted_names, 1},

  {"newer", 1, 0, 'N'},
  {"after-date", 1, 0, 'N'},
  {"newer-mtime", 1, 0, 13},
  {"incremental", 0, 0, 'G'},
  {"listed-incremental", 1, 0, 'g'},
  {"multi-volume", 0, &f_multivol, 1},
  {"info-script", 1, 0, 'F'},
  {"new-volume-script", 1, 0, 'F'},
  {"absolute-paths", 0, &f_absolute_paths, 1},
  {"interactive", 0, &f_confirm, 1},
  {"confirmation", 0, &f_confirm, 1},

  {"verify", 0, &f_verify, 1},
  {"dereference", 0, &f_follow_links, 1},
  {"one-file-system", 0, &f_local_filesys, 1},
  {"old-archive", 0, 0, 'o'},
  {"portability", 0, 0, 'o'},
  {"compress", 0, 0, 'Z'},
  {"uncompress", 0, 0, 'Z'},
  {"block-compress", 0, &f_compress_block, 1},
  {"gzip", 0, 0, 'z'},
  {"ungzip", 0, 0, 'z'},
  {"use-compress-program", 1, 0, 18},
    

  {"same-permissions", 0, &f_use_protection, 1},
  {"sparse", 0, &f_sparse_files, 1},
  {"tape-length", 1, 0, 'L'},
  {"remove-files", 0, &f_remove_files, 1},
  {"ignore-failed-read", 0, &f_ignore_failed_read, 1},
  {"checkpoint", 0, &f_checkpoint, 1},
  {"show-omitted-dirs", 0, &f_show_omitted_dirs, 1},
  {"volno-file", 1, 0, 17},
  {"force-local", 0, &f_force_local, 1},
  {"atime-preserve", 0, &f_atime_preserve, 1},

  {0, 0, 0, 0}
};

/*
 * Main routine for tar.
 */
void
main (argc, argv)
     int argc;
     char **argv;
{
  extern char version_string[];

  tar = argv[0];                /* JF: was "tar" Set program name */
  filename_terminator = '\n';
  errors = 0;

  options (argc, argv);

  if (!n_argv)
    name_init (argc, argv);

  if (f_volno_file)
    init_volume_number ();

  switch (cmd_mode)
    {
    case CMD_CAT:
    case CMD_UPDATE:
    case CMD_APPEND:
      update_archive ();
      break;
    case CMD_DELETE:
      junk_archive ();
      break;
    case CMD_CREATE:
      create_archive ();
      if (f_totals)
        fprintf (stderr, "Total bytes written: %d\n", tot_written);
      break;
    case CMD_EXTRACT:
      if (f_volhdr)
        {
          const char *err;
          label_pattern = (struct re_pattern_buffer *)
            ck_malloc (sizeof *label_pattern);
          err = re_compile_pattern (f_volhdr, strlen (f_volhdr),
                                    label_pattern);
          if (err)
            {
              fprintf (stderr, "Bad regular expression: %s\n",
                       err);
              errors++;
              break;
            }

        }
      extr_init ();
      read_and (extract_archive);
      break;
    case CMD_LIST:
      if (f_volhdr)
        {
          const char *err;
          label_pattern = (struct re_pattern_buffer *)
            ck_malloc (sizeof *label_pattern);
          err = re_compile_pattern (f_volhdr, strlen (f_volhdr),
                                    label_pattern);
          if (err)
            {
              fprintf (stderr, "Bad regular expression: %s\n",
                       err);
              errors++;
              break;
            }
        }
      read_and (list_archive);
#if 0
      if (!errors)
        errors = different;
#endif
      break;
    case CMD_DIFF:
      diff_init ();
      read_and (diff_archive);
      break;
    case CMD_VERSION:
      fprintf (stderr, "%s\n", version_string);
      break;
    case CMD_NONE:
      msg ("you must specify exactly one of the r, c, t, x, or d options\n");
      fprintf (stderr, "For more information, type ``%s --help''.\n", tar);
      exit (EX_ARGSBAD);
    }
  if (f_volno_file)
    closeout_volume_number ();
  exit (errors);
  /* NOTREACHED */
}


/*
 * Parse the options for tar.
 */
void
options (argc, argv)
     int argc;
     char **argv;
{
  register int c;               /* Option letter */
  int ind = -1;

  /* Set default option values */
  blocking = DEFBLOCKING;       /* From Makefile */
  ar_files = (char **) ck_malloc (sizeof (char *) * 10);
  ar_files_len = 10;
  n_ar_files = 0;
  cur_ar_file = 0;

  /* Parse options */
  while ((c = getoldopt (argc, argv,
               "-01234567Ab:BcC:df:F:g:GhikK:lL:mMN:oOpPrRsStT:uvV:wWxX:zZ",
                         long_options, &ind)) != EOF)
    {
      switch (c)
        {
        case 0:         /* long options that set a single flag */
          break;
        case 1:
          /* File name or non-parsed option */
          name_add (optarg);
          break;
        case 'C':
          name_add ("-C");
          name_add (optarg);
          break;
        case 10:                /* preserve */
          f_use_protection = f_sorted_names = 1;
          break;
        case 11:
          if (cmd_mode != CMD_NONE)
            goto badopt;
          cmd_mode = CMD_VERSION;
          break;
        case 12:                /* help */
          printf ("This is GNU tar, the tape archiving program.\n");
          describe ();
          exit (1);
        case 13:
          f_new_files++;
          goto get_newer;

        case 14:                /* Delete in the archive */
          if (cmd_mode != CMD_NONE)
            goto badopt;
          cmd_mode = CMD_DELETE;
          break;

        case 15:
          f_exclude++;
          add_exclude (optarg);
          break;

        case 16:                /* -T reads null terminated filenames. */
          filename_terminator = '\0';
          break;

        case 17:
          f_volno_file = optarg;
          break;

        case 18:
          if (f_compressprog)
            {
              msg ("Only one compression option permitted\n");
              exit (EX_ARGSBAD);
            }
          f_compressprog = optarg;
          break;

        case 'g':               /* We are making a GNU dump; save
                                   directories at the beginning of
                                   the archive, and include in each
                                   directory its contents */
          if (f_oldarch)
            goto badopt;
          f_gnudump++;
          gnu_dumpfile = optarg;
          break;


        case '0':
        case '1':
        case '2':
        case '3':
        case '4':
        case '5':
        case '6':
        case '7':
          {
            /* JF this'll have to be modified for other
                                   systems, of course! */
            int d, add;
            static char buf[50];

            d = getoldopt (argc, argv, "lmh");
#ifdef MAYBEDEF
            sprintf (buf, "/dev/rmt/%d%c", c, d);
#else
#ifndef LOW_NUM
#define LOW_NUM 0
#define MID_NUM 8
#define HGH_NUM 16
#endif
            if (d == 'l')
              add = LOW_NUM;
            else if (d == 'm')
              add = MID_NUM;
            else if (d == 'h')
              add = HGH_NUM;
            else
              goto badopt;

            sprintf (buf, "/dev/rmt%d", add + c - '0');
#endif
            if (n_ar_files == ar_files_len)
              ar_files
                = (char **)
                ck_malloc (sizeof (char *)
                           * (ar_files_len *= 2));
            ar_files[n_ar_files++] = buf;
          }
          break;

        case 'A':               /* Arguments are tar files,
                                   just cat them onto the end
                                   of the archive.  */
          if (cmd_mode != CMD_NONE)
            goto badopt;
          cmd_mode = CMD_CAT;
          break;

        case 'b':               /* Set blocking factor */
          blocking = intconv (optarg);
          break;

        case 'B':               /* Try to reblock input */
          f_reblock++;          /* For reading 4.2BSD pipes */
          break;

        case 'c':               /* Create an archive */
          if (cmd_mode != CMD_NONE)
            goto badopt;
          cmd_mode = CMD_CREATE;
          break;

#if 0
        case 'C':
          if (chdir (optarg) < 0)
            msg_perror ("Can't change directory to %d", optarg);
          break;
#endif

        case 'd':               /* Find difference tape/disk */
          if (cmd_mode != CMD_NONE)
            goto badopt;
          cmd_mode = CMD_DIFF;
          break;

        case 'f':               /* Use ar_file for the archive */
          if (n_ar_files == ar_files_len)
            ar_files
              = (char **) ck_malloc (sizeof (char *)
                                     * (ar_files_len *= 2));

          ar_files[n_ar_files++] = optarg;
          break;

        case 'F':
          /* Since -F is only useful with -M , make it implied */
          f_run_script_at_end++;/* run this script at the end */
          info_script = optarg; /* of each tape */
          f_multivol++;
          break;

        case 'G':               /* We are making a GNU dump; save
                                   directories at the beginning of
                                   the archive, and include in each
                                   directory its contents */
          if (f_oldarch)
            goto badopt;
          f_gnudump++;
          gnu_dumpfile = 0;
          break;

        case 'h':
          f_follow_links++;     /* follow symbolic links */
          break;

        case 'i':
          f_ignorez++;          /* Ignore zero records (eofs) */
          /*
                         * This can't be the default, because Unix tar
                         * writes two records of zeros, then pads out the
                         * block with garbage.
                         */
          break;

        case 'k':               /* Don't overwrite files */
#ifdef NO_OPEN3
          msg ("can't keep old files on this system");
          exit (EX_ARGSBAD);
#else
          f_keep++;
#endif
          break;

        case 'K':
          f_startfile++;
          addname (optarg);
          break;

        case 'l':               /* When dumping directories, don't
                                   dump files/subdirectories that are
                                   on other filesystems. */
          f_local_filesys++;
          break;

        case 'L':
          tape_length = intconv (optarg);
          f_multivol++;
          break;
        case 'm':
          f_modified++;
          break;

        case 'M':               /* Make Multivolume archive:
                                   When we can't write any more
                                   into the archive, re-open it,
                                   and continue writing */
          f_multivol++;
          break;

        case 'N':               /* Only write files newer than X */
        get_newer:
          f_new_files++;
          new_time = get_date (optarg, (PTR) 0);
          if (new_time == (time_t) - 1)
            {
              msg ("invalid date format `%s'", optarg);
              exit (EX_ARGSBAD);
            }
          break;

        case 'o':               /* Generate old archive */
          if (f_gnudump /* || f_dironly */ )
            goto badopt;
          f_oldarch++;
          break;

        case 'O':
          f_exstdout++;
          break;

        case 'p':
          f_use_protection++;
          break;

        case 'P':
          f_absolute_paths++;
          break;

        case 'r':               /* Append files to the archive */
          if (cmd_mode != CMD_NONE)
            goto badopt;
          cmd_mode = CMD_APPEND;
          break;

        case 'R':
          f_sayblock++;         /* Print block #s for debug */
          break;                /* of bad tar archives */

        case 's':
          f_sorted_names++;     /* Names to extr are sorted */
          break;

        case 'S':               /* deal with sparse files */
          f_sparse_files++;
          break;
        case 't':
          if (cmd_mode != CMD_NONE)
            goto badopt;
          cmd_mode = CMD_LIST;
          f_verbose++;          /* "t" output == "cv" or "xv" */
          break;

        case 'T':
          name_file = optarg;
          f_namefile++;
          break;

        case 'u':               /* Append files to the archive that
                                   aren't there, or are newer than the
                                   copy in the archive */
          if (cmd_mode != CMD_NONE)
            goto badopt;
          cmd_mode = CMD_UPDATE;
          break;

        case 'v':
          f_verbose++;
          break;

        case 'V':
          f_volhdr = optarg;
          break;

        case 'w':
          f_confirm++;
          break;

        case 'W':
          f_verify++;
          break;

        case 'x':               /* Extract files from the archive */
          if (cmd_mode != CMD_NONE)
            goto badopt;
          cmd_mode = CMD_EXTRACT;
          break;

        case 'X':
          f_exclude++;
          add_exclude_file (optarg);
          break;

        case 'z':
          if (f_compressprog)
            {
              msg ("Only one compression option permitted\n");
              exit (EX_ARGSBAD);
            }
          f_compressprog = "gzip";
          break;

        case 'Z':
          if (f_compressprog)
            {
              msg ("Only one compression option permitted\n");
              exit (EX_ARGSBAD);
            }
          f_compressprog = "compress";
          break;

        case '?':
        badopt:
          msg ("Unknown option.  Use '%s --help' for a complete list of options.", tar);
          exit (EX_ARGSBAD);

        }
    }

  blocksize = blocking * RECORDSIZE;
  if (n_ar_files == 0)
    {
      n_ar_files = 1;
      ar_files[0] = getenv ("TAPE");    /* From environment, or */
      if (ar_files[0] == 0)
        ar_files[0] = DEF_AR_FILE;      /* From Makefile */
    }
  if (n_ar_files > 1 && !f_multivol)
    {
      msg ("Multiple archive files requires --multi-volume\n");
      exit (EX_ARGSBAD);
    }
  if (f_compress_block && !f_compressprog)
    {
      msg ("You must use a compression option (--gzip, --compress\n\
or --use-compress-program) with --block-compress.\n");
      exit (EX_ARGSBAD);
    }
}


/*
 * Print as much help as the user's gonna get.
 *
 * We have to sprinkle in the KLUDGE lines because too many compilers
 * cannot handle character strings longer than about 512 bytes.  Yuk!
 * In particular, MS-DOS and Xenix MSC and PDP-11 V7 Unix have this
 * problem.
 */
void
describe ()
{
  puts ("choose one of the following:");
  fputs ("\
-A, --catenate,\n\
    --concatenate       append tar files to an archive\n\
-c, --create            create a new archive\n\
-d, --diff,\n\
    --compare           find differences between archive and file system\n\
--delete                delete from the archive (not for use on mag tapes!)\n\
-r, --append            append files to the end of an archive\n\
-t, --list              list the contents of an archive\n\
-u, --update            only append files that are newer than copy in archive\n\
-x, --extract,\n\
    --get               extract files from an archive\n", stdout);

  fprintf (stdout, "\
Other options:\n\
--atime-preserve        don't change access times on dumped files\n\
-b, --block-size N      block size of Nx512 bytes (default N=%d)\n", DEFBLOCKING);
  fputs ("\
-B, --read-full-blocks  reblock as we read (for reading 4.2BSD pipes)\n\
-C, --directory DIR     change to directory DIR\n\
--checkpoint            print directory names while reading the archive\n\
", stdout);                     /* KLUDGE */
  fprintf (stdout, "\
-f, --file [HOSTNAME:]F use archive file or device F (default %s)\n",
           DEF_AR_FILE);
  fputs ("\
--force-local           archive file is local even if has a colon\n\
-F, --info-script F\n\
    --new-volume-script F run script at end of each tape (implies -M)\n\
-G, --incremental       create/list/extract old GNU-format incremental backup\n\
-g, --listed-incremental F create/list/extract new GNU-format incremental backup\n\
-h, --dereference       don't dump symlinks; dump the files they point to\n\
-i, --ignore-zeros      ignore blocks of zeros in archive (normally mean EOF)\n\
--ignore-failed-read    don't exit with non-zero status on unreadable files\n\
-k, --keep-old-files    keep existing files; don't overwrite them from archive\n\
-K, --starting-file F   begin at file F in the archive\n\
-l, --one-file-system   stay in local file system when creating an archive\n\
-L, --tape-length N     change tapes after writing N*1024 bytes\n\
", stdout);                     /* KLUDGE */
  fputs ("\
-m, --modification-time don't extract file modified time\n\
-M, --multi-volume      create/list/extract multi-volume archive\n\
-N, --after-date DATE,\n\
    --newer DATE        only store files newer than DATE\n\
-o, --old-archive,\n\
    --portability       write a V7 format archive, rather than ANSI format\n\
-O, --to-stdout         extract files to standard output\n\
-p, --same-permissions,\n\
    --preserve-permissions extract all protection information\n\
-P, --absolute-paths    don't strip leading `/'s from file names\n\
--preserve              like -p -s\n\
", stdout);                     /* KLUDGE */
  fputs ("\
-R, --record-number     show record number within archive with each message\n\
--remove-files          remove files after adding them to the archive\n\
-s, --same-order,\n\
    --preserve-order    list of names to extract is sorted to match archive\n\
--same-owner            create extracted files with the same ownership \n\
-S, --sparse            handle sparse files efficiently\n\
-T, --files-from F      get names to extract or create from file F\n\
--null                  -T reads null-terminated names, disable -C\n\
--totals                print total bytes written with --create\n\
-v, --verbose           verbosely list files processed\n\
-V, --label NAME        create archive with volume name NAME\n\
--version               print tar program version number\n\
-w, --interactive,\n\
    --confirmation      ask for confirmation for every action\n\
", stdout);                     /* KLUDGE */
  fputs ("\
-W, --verify            attempt to verify the archive after writing it\n\
--exclude FILE          exclude file FILE\n\
-X, --exclude-from FILE exclude files listed in FILE\n\
-Z, --compress,\n\
    --uncompress        filter the archive through compress\n\
-z, --gzip,\n\
    --ungzip            filter the archive through gzip\n\
--use-compress-program PROG\n\
                        filter the archive through PROG (which must accept -d)\n\
--block-compress        block the output of compression program for tapes\n\
-[0-7][lmh]             specify drive and density\n\
", stdout);
}

void
name_add (name)
     char *name;
{
  if (n_indalloc == n_indused)
    {
      n_indalloc += 10;
      n_ind = (char **) (n_indused ? ck_realloc (n_ind, n_indalloc * sizeof (char *)): ck_malloc (n_indalloc * sizeof (char *)));
    }
  n_ind[n_indused++] = name;
}

/*
 * Set up to gather file names for tar.
 *
 * They can either come from stdin or from argv.
 */
void
name_init (argc, argv)
     int argc;
     char **argv;
{

  if (f_namefile)
    {
      if (optind < argc)
        {
          msg ("too many args with -T option");
          exit (EX_ARGSBAD);
        }
      if (!strcmp (name_file, "-"))
        {
          namef = stdin;
        }
      else
        {
          namef = fopen (name_file, "r");
          if (namef == NULL)
            {
              msg_perror ("can't open file %s", name_file);
              exit (EX_BADFILE);
            }
        }
    }
  else
    {
      /* Get file names from argv, after options. */
      n_argc = argc;
      n_argv = argv;
    }
}

/* Read the next filename read from STREAM and null-terminate it.
   Put it into BUFFER, reallocating and adjusting *PBUFFER_SIZE if necessary.
   Return the new value for BUFFER, or NULL at end of file. */

char *
read_name_from_file (buffer, pbuffer_size, stream)
     char *buffer;
     size_t *pbuffer_size;
     FILE *stream;
{
  register int c;
  register int indx = 0;
  register size_t buffer_size = *pbuffer_size;

  while ((c = getc (stream)) != EOF && c != filename_terminator)
    {
      if (indx == buffer_size)
        {
          buffer_size += NAMSIZ;
          buffer = ck_realloc (buffer, buffer_size + 2);
        }
      buffer[indx++] = c;
    }
  if (indx == 0 && c == EOF)
    return NULL;
  if (indx == buffer_size)
    {
      buffer_size += NAMSIZ;
      buffer = ck_realloc (buffer, buffer_size + 2);
    }
  buffer[indx] = '\0';
  *pbuffer_size = buffer_size;
  return buffer;
}

/*
 * Get the next name from argv or the name file.
 *
 * Result is in static storage and can't be relied upon across two calls.
 *
 * If CHANGE_DIRS is non-zero, treat a filename of the form "-C" as
 * meaning that the next filename is the name of a directory to change to.
 * If `filename_terminator' is '\0', CHANGE_DIRS is effectively always 0.
 */

char *
name_next (change_dirs)
     int change_dirs;
{
  static char *buffer;          /* Holding pattern */
  static int buffer_siz;
  register char *p;
  register char *q = 0;
  register int next_name_is_dir = 0;
  extern char *un_quote_string ();

  if (buffer_siz == 0)
    {
      buffer = ck_malloc (NAMSIZ + 2);
      buffer_siz = NAMSIZ;
    }
  if (filename_terminator == '\0')
    change_dirs = 0;
tryagain:
  if (namef == NULL)
    {
      if (n_indscan < n_indused)
        p = n_ind[n_indscan++];
      else if (optind < n_argc)
        /* Names come from argv, after options */
        p = n_argv[optind++];
      else
        {
          if (q)
            msg ("Missing filename after -C");
          return NULL;
        }

      /* JF trivial support for -C option.  I don't know if
                   chdir'ing at this point is dangerous or not.
                   It seems to work, which is all I ask. */
      if (change_dirs && !q && p[0] == '-' && p[1] == 'C' && p[2] == '\0')
        {
          q = p;
          goto tryagain;
        }
      if (q)
        {
          if (chdir (p) < 0)
            msg_perror ("Can't chdir to %s", p);
          q = 0;
          goto tryagain;
        }
      /* End of JF quick -C hack */

#if 0
      if (f_exclude && check_exclude (p))
        goto tryagain;
#endif
      return un_quote_string (p);
    }
  while (p = read_name_from_file (buffer, &buffer_siz, namef))
    {
      buffer = p;
      if (*p == '\0')
        continue;               /* Ignore empty lines. */
      q = p + strlen (p) - 1;
      while (q > p && *q == '/')/* Zap trailing "/"s. */
        *q-- = '\0';
      if (change_dirs && next_name_is_dir == 0
          && p[0] == '-' && p[1] == 'C' && p[2] == '\0')
        {
          next_name_is_dir = 1;
          goto tryagain;
        }
      if (next_name_is_dir)
        {
          if (chdir (p) < 0)
            msg_perror ("Can't change to directory %s", p);
          next_name_is_dir = 0;
          goto tryagain;
        }
#if 0
      if (f_exclude && check_exclude (p))
        goto tryagain;
#endif
      return un_quote_string (p);
    }
  return NULL;
}


/*
 * Close the name file, if any.
 */
void
name_close ()
{

  if (namef != NULL && namef != stdin)
    fclose (namef);
}


/*
 * Gather names in a list for scanning.
 * Could hash them later if we really care.
 *
 * If the names are already sorted to match the archive, we just
 * read them one by one.  name_gather reads the first one, and it
 * is called by name_match as appropriate to read the next ones.
 * At EOF, the last name read is just left in the buffer.
 * This option lets users of small machines extract an arbitrary
 * number of files by doing "tar t" and editing down the list of files.
 */
void
name_gather ()
{
  register char *p;
  static struct name *namebuf;  /* One-name buffer */
  static namelen;
  static char *chdir_name;

  if (f_sorted_names)
    {
      if (!namelen)
        {
          namelen = NAMSIZ;
          namebuf = (struct name *) ck_malloc (sizeof (struct name) + NAMSIZ);
        }
      p = name_next (0);
      if (p)
        {
          if (*p == '-' && p[1] == 'C' && p[2] == '\0')
            {
              chdir_name = name_next (0);
              p = name_next (0);
              if (!p)
                {
                  msg ("Missing file name after -C");
                  exit (EX_ARGSBAD);
                }
              namebuf->change_dir = chdir_name;
            }
          namebuf->length = strlen (p);
          if (namebuf->length >= namelen)
            {
              namebuf = (struct name *) ck_realloc (namebuf, sizeof (struct name) + namebuf->length);
              namelen = namebuf->length;
            }
          strncpy (namebuf->name, p, namebuf->length);
          namebuf->name[namebuf->length] = 0;
          namebuf->next = (struct name *) NULL;
          namebuf->found = 0;
          namelist = namebuf;
          namelast = namelist;
        }
      return;
    }

  /* Non sorted names -- read them all in */
  while (p = name_next (0))
    addname (p);
}

/*
 * Add a name to the namelist.
 */
void
addname (name)
     char *name;                /* pointer to name */
{
  register int i;               /* Length of string */
  register struct name *p;      /* Current struct pointer */
  static char *chdir_name;
  char *new_name ();

  if (name[0] == '-' && name[1] == 'C' && name[2] == '\0')
    {
      chdir_name = name_next (0);
      name = name_next (0);
      if (!chdir_name)
        {
          msg ("Missing file name after -C");
          exit (EX_ARGSBAD);
        }
      if (chdir_name[0] != '/')
        {
          char *path = ck_malloc (PATH_MAX);
#if defined(__MSDOS__) || defined(HAVE_GETCWD) || defined(_POSIX_VERSION)
          if (!getcwd (path, PATH_MAX))
            {
              msg ("Couldn't get current directory.");
              exit (EX_SYSTEM);
            }
#else
          char *getwd ();

          if (!getwd (path))
            {
              msg ("Couldn't get current directory: %s", path);
              exit (EX_SYSTEM);
            }
#endif
          chdir_name = new_name (path, chdir_name);
          free (path);
        }
    }

  if (name)
    {
      i = strlen (name);
      /*NOSTRICT*/
      p = (struct name *) malloc ((unsigned) (sizeof (struct name) + i));
    }
  else
    p = (struct name *) malloc ((unsigned) (sizeof (struct name)));
  if (!p)
    {
      if (name)
        msg ("cannot allocate mem for name '%s'.", name);
      else
        msg ("cannot allocate mem for chdir record.");
      exit (EX_SYSTEM);
    }
  p->next = (struct name *) NULL;
  if (name)
    {
      p->fake = 0;
      p->length = i;
      strncpy (p->name, name, i);
      p->name[i] = '\0';        /* Null term */
    }
  else
    p->fake = 1;
  p->found = 0;
  p->regexp = 0;                /* Assume not a regular expression */
  p->firstch = 1;               /* Assume first char is literal */
  p->change_dir = chdir_name;
  p->dir_contents = 0;          /* JF */
  if (name)
    {
      if (index (name, '*') || index (name, '[') || index (name, '?'))
        {
          p->regexp = 1;        /* No, it's a regexp */
          if (name[0] == '*' || name[0] == '[' || name[0] == '?')
            p->firstch = 0;     /* Not even 1st char literal */
        }
    }

  if (namelast)
    namelast->next = p;
  namelast = p;
  if (!namelist)
    namelist = p;
}

/*
 * Return nonzero if name P (from an archive) matches any name from
 * the namelist, zero if not.
 */
int
name_match (p)
     register char *p;
{
  register struct name *nlp;
  register int len;

again:
  if (0 == (nlp = namelist))    /* Empty namelist is easy */
    return 1;
  if (nlp->fake)
    {
      if (nlp->change_dir && chdir (nlp->change_dir))
        msg_perror ("Can't change to directory %d", nlp->change_dir);
      namelist = 0;
      return 1;
    }
  len = strlen (p);
  for (; nlp != 0; nlp = nlp->next)
    {
      /* If first chars don't match, quick skip */
      if (nlp->firstch && nlp->name[0] != p[0])
        continue;

      /* Regular expressions (shell globbing, actually). */
      if (nlp->regexp)
        {
          if (fnmatch (nlp->name, p, FNM_LEADING_DIR) == 0)
            {
              nlp->found = 1;   /* Remember it matched */
              if (f_startfile)
                {
                  free ((void *) namelist);
                  namelist = 0;
                }
              if (nlp->change_dir && chdir (nlp->change_dir))
                msg_perror ("Can't change to directory %s", nlp->change_dir);
              return 1;         /* We got a match */
            }
          continue;
        }

      /* Plain Old Strings */
      if (nlp->length <= len    /* Archive len >= specified */
          && (p[nlp->length] == '\0' || p[nlp->length] == '/')
      /* Full match on file/dirname */
          && strncmp (p, nlp->name, nlp->length) == 0)  /* Name compare */
        {
          nlp->found = 1;       /* Remember it matched */
          if (f_startfile)
            {
              free ((void *) namelist);
              namelist = 0;
            }
          if (nlp->change_dir && chdir (nlp->change_dir))
            msg_perror ("Can't change to directory %s", nlp->change_dir);
          return 1;             /* We got a match */
        }
    }

  /*
         * Filename from archive not found in namelist.
         * If we have the whole namelist here, just return 0.
         * Otherwise, read the next name in and compare it.
         * If this was the last name, namelist->found will remain on.
         * If not, we loop to compare the newly read name.
         */
  if (f_sorted_names && namelist->found)
    {
      name_gather ();           /* Read one more */
      if (!namelist->found)
        goto again;
    }
  return 0;
}


/*
 * Print the names of things in the namelist that were not matched.
 */
void
names_notfound ()
{
  register struct name *nlp, *next;
  register char *p;

  for (nlp = namelist; nlp != 0; nlp = next)
    {
      next = nlp->next;
      if (!nlp->found)
        msg ("%s not found in archive", nlp->name);

      /*
                 * We could free() the list, but the process is about
                 * to die anyway, so save some CPU time.  Amigas and
                 * other similarly broken software will need to waste
                 * the time, though.
                 */
#ifdef amiga
      if (!f_sorted_names)
        free (nlp);
#endif
    }
  namelist = (struct name *) NULL;
  namelast = (struct name *) NULL;

  if (f_sorted_names)
    {
      while (0 != (p = name_next (1)))
        msg ("%s not found in archive", p);
    }
}

/* These next routines were created by JF */

void
name_expand ()
{
  ;
}

/* This is like name_match(), except that it returns a pointer to the name
   it matched, and doesn't set ->found  The caller will have to do that
   if it wants to.  Oh, and if the namelist is empty, it returns 0, unlike
   name_match(), which returns TRUE */

struct name *
name_scan (p)
     register char *p;
{
  register struct name *nlp;
  register int len;

again:
  if (0 == (nlp = namelist))    /* Empty namelist is easy */
    return 0;
  len = strlen (p);
  for (; nlp != 0; nlp = nlp->next)
    {
      /* If first chars don't match, quick skip */
      if (nlp->firstch && nlp->name[0] != p[0])
        continue;

      /* Regular expressions */
      if (nlp->regexp)
        {
          if (fnmatch (nlp->name, p, FNM_LEADING_DIR) == 0)
            return nlp;         /* We got a match */
          continue;
        }

      /* Plain Old Strings */
      if (nlp->length <= len    /* Archive len >= specified */
          && (p[nlp->length] == '\0' || p[nlp->length] == '/')
      /* Full match on file/dirname */
          && strncmp (p, nlp->name, nlp->length) == 0)  /* Name compare */
        return nlp;             /* We got a match */
    }

  /*
         * Filename from archive not found in namelist.
         * If we have the whole namelist here, just return 0.
         * Otherwise, read the next name in and compare it.
         * If this was the last name, namelist->found will remain on.
         * If not, we loop to compare the newly read name.
         */
  if (f_sorted_names && namelist->found)
    {
      name_gather ();           /* Read one more */
      if (!namelist->found)
        goto again;
    }
  return (struct name *) 0;
}

/* This returns a name from the namelist which doesn't have ->found set.
   It sets ->found before returning, so successive calls will find and return
   all the non-found names in the namelist */

struct name *gnu_list_name;

char *
name_from_list ()
{
  if (!gnu_list_name)
    gnu_list_name = namelist;
  while (gnu_list_name && gnu_list_name->found)
    gnu_list_name = gnu_list_name->next;
  if (gnu_list_name)
    {
      gnu_list_name->found++;
      if (gnu_list_name->change_dir)
        if (chdir (gnu_list_name->change_dir) < 0)
          msg_perror ("can't chdir to %s", gnu_list_name->change_dir);
      return gnu_list_name->name;
    }
  return (char *) 0;
}

void
blank_name_list ()
{
  struct name *n;

  gnu_list_name = 0;
  for (n = namelist; n; n = n->next)
    n->found = 0;
}

char *
new_name (path, name)
     char *path, *name;
{
  char *path_buf;

  path_buf = (char *) malloc (strlen (path) + strlen (name) + 2);
  if (path_buf == 0)
    {
      msg ("Can't allocate memory for name '%s/%s", path, name);
      exit (EX_SYSTEM);
    }
  (void) sprintf (path_buf, "%s/%s", path, name);
  return path_buf;
}

/* returns non-zero if the luser typed 'y' or 'Y', zero otherwise. */

int
confirm (action, file)
     char *action, *file;
{
  int c, nl;
  static FILE *confirm_file = 0;
  extern FILE *msg_file;
  extern char TTY_NAME[];

  fprintf (msg_file, "%s %s?", action, file);
  fflush (msg_file);
  if (!confirm_file)
    {
      confirm_file = (archive == 0) ? fopen (TTY_NAME, "r") : stdin;
      if (!confirm_file)
        {
          msg ("Can't read confirmation from user");
          exit (EX_SYSTEM);
        }
    }
  c = getc (confirm_file);
  for (nl = c; nl != '\n' && nl != EOF; nl = getc (confirm_file))
    ;
  return (c == 'y' || c == 'Y');
}

char *x_buffer = 0;
int size_x_buffer;
int free_x_buffer;

char **exclude = 0;
int size_exclude = 0;
int free_exclude = 0;

char **re_exclude = 0;
int size_re_exclude = 0;
int free_re_exclude = 0;

void
add_exclude (name)
     char *name;
{
  /*    char *rname;*/
  /*    char **tmp_ptr;*/
  int size_buf;

  un_quote_string (name);
  size_buf = strlen (name);

  if (x_buffer == 0)
    {
      x_buffer = (char *) ck_malloc (size_buf + 1024);
      free_x_buffer = 1024;
    }
  else if (free_x_buffer <= size_buf)
    {
      char *old_x_buffer;
      char **tmp_ptr;

      old_x_buffer = x_buffer;
      x_buffer = (char *) ck_realloc (x_buffer, size_x_buffer + 1024);
      free_x_buffer = 1024;
      for (tmp_ptr = exclude; tmp_ptr < exclude + size_exclude; tmp_ptr++)
        *tmp_ptr = x_buffer + ((*tmp_ptr) - old_x_buffer);
      for (tmp_ptr = re_exclude; tmp_ptr < re_exclude + size_re_exclude; tmp_ptr++)
        *tmp_ptr = x_buffer + ((*tmp_ptr) - old_x_buffer);
    }

  if (is_regex (name))
    {
      if (free_re_exclude == 0)
        {
          re_exclude = (char **) (re_exclude ? ck_realloc (re_exclude, (size_re_exclude + 32) * sizeof (char *)): ck_malloc (sizeof (char *) * 32));
          free_re_exclude += 32;
        }
      re_exclude[size_re_exclude] = x_buffer + size_x_buffer;
      size_re_exclude++;
      free_re_exclude--;
    }
  else
    {
      if (free_exclude == 0)
        {
          exclude = (char **) (exclude ? ck_realloc (exclude, (size_exclude + 32) * sizeof (char *)): ck_malloc (sizeof (char *) * 32));
          free_exclude += 32;
        }
      exclude[size_exclude] = x_buffer + size_x_buffer;
      size_exclude++;
      free_exclude--;
    }
  strcpy (x_buffer + size_x_buffer, name);
  size_x_buffer += size_buf + 1;
  free_x_buffer -= size_buf + 1;
}

void
add_exclude_file (file)
     char *file;
{
  FILE *fp;
  char buf[1024];

  if (strcmp (file, "-"))
    fp = fopen (file, "r");
  else
    /* Let's hope the person knows what they're doing. */
    /* Using -X - -T - -f - will get you *REALLY* strange
                   results. . . */
    fp = stdin;

  if (!fp)
    {
      msg_perror ("can't open %s", file);
      exit (2);
    }
  while (fgets (buf, 1024, fp))
    {
      /*                int size_buf;*/
      char *end_str;

      end_str = rindex (buf, '\n');
      if (end_str)
        *end_str = '\0';
      add_exclude (buf);

    }
  fclose (fp);
}

int
is_regex (str)
     char *str;
{
  return index (str, '*') || index (str, '[') || index (str, '?');
}

/* Returns non-zero if the file 'name' should not be added/extracted */
int
check_exclude (name)
     char *name;
{
  int n;
  char *str;
  extern char *strstr ();

  for (n = 0; n < size_re_exclude; n++)
    {
      if (fnmatch (re_exclude[n], name, FNM_LEADING_DIR) == 0)
        return 1;
    }
  for (n = 0; n < size_exclude; n++)
    {
      /* Accept the output from strstr only if it is the last
                   part of the string.  There is certainly a faster way to
                   do this. . . */
      if ((str = strstr (name, exclude[n]))
          && (str == name || str[-1] == '/')
          && str[strlen (exclude[n])] == '\0')
        return 1;
    }
  return 0;
}