path: root/gnu/usr.bin/tar/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"

/*
 * 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 "regex.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},

  {"unlink", 0, &f_unlink, 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\
--unlink		unlink files before creating them\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;
}