--- /dev/null
+/* Tar -- a tape archiver.
+ Copyright (C) 1988 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"
+
+#if defined(_POSIX_VERSION) || defined(DIRENT)
+#include <dirent.h>
+#ifdef direct
+#undef direct
+#endif /* direct */
+#define direct dirent
+#define DP_NAMELEN(x) strlen((x)->d_name)
+#endif /* _POSIX_VERSION or DIRENT */
+#if !defined(_POSIX_VERSION) && !defined(DIRENT) && defined(BSD42)
+#include <sys/dir.h>
+#define DP_NAMELEN(x) (x)->d_namlen
+#endif /* not _POSIX_VERSION and BSD42 */
+#ifdef __MSDOS__
+#include "msd_dir.h"
+#define DP_NAMELEN(x) (x)->d_namlen
+#define direct dirent
+#endif
+#if defined(USG) && !defined(_POSIX_VERSION) && !defined(DIRENT)
+#include <ndir.h>
+#define DP_NAMELEN(x) strlen((x)->d_name)
+#endif /* USG and not _POSIX_VERSION and not DIRENT */
+
+/*
+ * 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();
+
+/* 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();
+int wildmat();
+
+#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'},
+ {"uncompress", 0, &f_compress, 1},
+ {"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'},
+ {"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, &f_compress, 1},
+ {"compress-block", 0, &f_compress, 2},
+ {"sparse", 0, &f_sparse_files, 1},
+ {"tape-length", 1, 0, 'L'},
+
+ {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);
+
+ 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) {
+ 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) {
+ 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);
+ }
+ 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_file = getenv("TAPE"); /* From environment, or */
+ if (ar_file == 0)
+ ar_file = DEF_AR_FILE; /* From Makefile */
+
+ /* 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 '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
+ ar_file=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 */
+ ar_file = 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);
+ 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': /* Easy to type */
+ case 'Z': /* Like the filename extension .Z */
+ f_compress++;
+ break;
+
+ case '?':
+ badopt:
+ msg("Unknown option. Use '%s +help' for a complete list of options.", tar);
+ exit(EX_ARGSBAD);
+
+ }
+ }
+
+ blocksize = blocking * RECORDSIZE;
+}
+
+
+/*
+ * 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\
+-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\
+", stdout); /* KLUDGE */ fprintf(stdout, "\
+-f, +file [HOSTNAME:]F use archive file or device F (default %s)\n",
+ DEF_AR_FILE); fputs("\
+-F, +info-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\
+-k, +keep-old-files keep existing files; don't overwrite them from archive\n\
+-K, +starting-file FILE begin at FILE in the archive\n\
+-l, +one-file-system stay in local file system when creating an archive\n\
+-L, +tape-length LENGTH change tapes after writing LENGTH\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\
+-s, +same-order,\n\
+ +preserve-order list of names to extract is sorted to match archive\n\
++same-order 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, -Z, +compress,\n\
+ +uncompress filter the archive through compress\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(f_exclude && check_exclude(p))
+ goto tryagain;
+ 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(f_exclude && check_exclude(p))
+ goto tryagain;
+ 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(USG) || 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 (wildmat(p, nlp->name)) {
+ 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 (wildmat(p, nlp->name))
+ 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];
+ extern char *rindex();
+
+ 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(wildmat(name,re_exclude[n]))
+ 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;
+}
projects / chaz / tar / commitdiff
