/* Tar -- a tape archiver.
Copyright (C) 1988 Free Software Foundation
GNU tar is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY. No author or distributor accepts responsibility to anyone
for the consequences of using it or for whether it serves any
particular purpose or works at all, unless he says so in writing.
Refer to the GNU tar General Public License for full details.
Everyone is granted permission to copy, modify and redistribute GNU tar,
but only under the conditions described in the GNU tar General Public
License. A copy of this license is supposed to have been given to you
along with GNU tar so you can know your rights and responsibilities. It
should be in a file named COPYING. Among other things, the copyright
notice and this notice must be preserved on all copies.
In other words, go ahead and share GNU tar, but don't try to stop
anyone else from sharing it farther. Help stamp out software hoarding!
* A tar (tape archiver) program.
* Written by John Gilmore, ihnp4!hoptoad!gnu, starting 25 Aug 85.
* @(#)tar.c 1.34 11/6/87 - gnu
#include <sys/types.h> /* Needed for typedefs in tar.h */
#include <sys/stat.h> /* JF */
#define DP_NAMELEN(x) strlen((x)->d_name)
* FIXME: On other systems there is no standard place for the header file
* for the portable directory access routines. Change the #include line
* below to bring it in from wherever it is.
#define DP_NAMELEN(x) (x)->d_namlen
extern char *strcpy(); /* JF */
extern char *strcat(); /* JF */
extern char *optarg
; /* Pointer to argument */
extern int optind
; /* Global argv index from getopt */
extern char *ck_malloc();
extern char *ck_realloc();
* The following causes "tar.h" to produce definitions of all the
* global variables, rather than just "extern" declarations of them.
* We should use a conversion routine that does reasonable error
* checking -- atoi doesn't. For now, punt. FIXME.
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 time_t get_date();
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? */
#define DEF_AR_FILE "tar.out"
/* 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
[] =
{"concatenate", 0, 0, 'A'},
{"directory", 1, 0, 'C'},
{"record-number", 0, &f_sayblock
, 1},
{"files-from", 1, 0, 'T'},
{"exclude-from", 1, 0, 'X'},
{"block-size", 1, 0, 'b'},
{"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},
{"same-order", 0, &f_sorted_names
, 1},
{"same-owner", 0, &f_do_chown
, 1},
{"preserve-order", 0, &f_sorted_names
, 1},
{"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, &f_run_script_at_end
, 1},
{"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'},
extern char version_string
[];
tar
= argv
[0]; /* JF: was "tar" Set program name */
fprintf (stderr
, "Total bytes written: %d\n", tot_written
);
label_pattern
= (struct re_pattern_buffer
*)
ck_malloc (sizeof *label_pattern
);
err
= re_compile_pattern (f_volhdr
, strlen (f_volhdr
),
fprintf (stderr
,"Bad regular expression: %s\n",
read_and(extract_archive
);
label_pattern
= (struct re_pattern_buffer
*)
ck_malloc (sizeof *label_pattern
);
err
= re_compile_pattern (f_volhdr
, strlen (f_volhdr
),
fprintf (stderr
,"Bad regular expression: %s\n",
fprintf(stderr
,"%s\n",version_string
);
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
);
* Parse the options for tar.
register int c
; /* Option letter */
/* Set default option values */
blocking
= DEFBLOCKING
; /* From Makefile */
ar_file
= getenv("TAPE"); /* From environment, or */
ar_file
= DEF_AR_FILE
; /* From Makefile */
while ((c
= getoldopt(argc
, argv
,
"-01234567Ab:BcC:df:F:g:GhikK:lL:mMN:oOpPrRsStT:uvV:wWxX:zZ",
long_options
, &ind
)) != EOF
) {
case 0: /* long options that set a single flag */
/* File name or non-parsed option */
f_use_protection
= f_sorted_names
= 1;
fprintf(stderr
,"This is GNU tar, the tape archiving program.\n");
case 14: /* Delete in the archive */
case 'g': /* We are making a GNU dump; save
directories at the beginning of
the archive, and include in each
directory its contents */
/* JF this'll have to be modified for other
d
=getoldopt(argc
,argv
,"lmh");
sprintf(buf
,"/dev/rmt/%d%c",c
,d
);
else if(d
=='m') add
=MID_NUM
;
else if(d
=='h') add
=HGH_NUM
;
sprintf(buf
,"/dev/rmt%d",add
+c
-'0');
case 'A': /* Arguments are tar files,
just cat them onto the end
case 'b': /* Set blocking factor */
blocking
= intconv(optarg
);
case 'B': /* Try to reblock input */
f_reblock
++; /* For reading 4.2BSD pipes */
case 'c': /* Create an archive */
msg_perror("Can't change directory to %d",optarg);
case 'd': /* Find difference tape/disk */
case 'f': /* Use ar_file for the archive */
/* 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 */
case 'G': /* We are making a GNU dump; save
directories at the beginning of
the archive, and include in each
directory its contents */
f_follow_links
++; /* follow symbolic links */
f_ignorez
++; /* Ignore zero records (eofs) */
* This can't be the default, because Unix tar
* writes two records of zeros, then pads out the
case 'k': /* Don't overwrite files */
msg("can't do -k option on this system");
case 'l': /* When dumping directories, don't
dump files/subdirectories that are
tape_length
= intconv (optarg
);
case 'M': /* Make Multivolume archive:
When we can't write any more
into the archive, re-open it,
case 'N': /* Only write files newer than X */
new_time
=get_date(optarg
,(struct timeb
*)0);
case 'o': /* Generate old archive */
if(f_gnudump
/* || f_dironly */)
case 'r': /* Append files to the archive */
f_sayblock
++; /* Print block #s for debug */
break; /* of bad tar archives */
f_sorted_names
++; /* Names to extr are sorted */
case 'S': /* deal with sparse files */
f_verbose
++; /* "t" output == "cv" or "xv" */
case 'u': /* Append files to the archive that
aren't there, or are newer than the
case 'x': /* Extract files from the archive */
add_exclude_file(optarg
);
case 'z': /* Easy to type */
case 'Z': /* Like the filename extension .Z */
msg("Unknown option. Use '%s +help' for a complete list of options.", tar
);
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, MSDOS and Xenix MSC and PDP-11 V7 Unix have this
msg("choose one of the following:");
+concatenate append tar files to an archive\n\
-c, +create create a new archive\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\
+get extract files from an archive\n",stderr
);
-b, +block-size N block size of Nx512 bytes (default N=%d)\n", DEFBLOCKING
);
-B, +read-full-blocks reblock as we read (for reading 4.2BSD pipes)\n\
-C, +directory DIR change to directory DIR\n\
", stderr
); /* KLUDGE */ fprintf(stderr
, "\
-f, +file [HOSTNAME:]F use archive file or device F (default %s)\n",
-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\
", stderr
); /* KLUDGE */ fputs("\
-m, +modification-time don't extract file modified time\n\
-M, +multi-volume create/list/extract multi-volume archive\n\
+newer DATE only store files newer than DATE\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\
", stderr
); /* KLUDGE */ fputs("\
-R, +record-number show record number within archive with each message\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\
+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\
+confirmation ask for confirmation for every action\n\
", stderr
); /* KLUDGE */ fputs("\
-W, +verify attempt to verify the archive after writing it\n\
-X, +exclude FILE exclude file FILE\n\
+exclude-from FILE exclude files listed in FILE\n\
+uncompress filter the archive through compress\n\
-[0-7][lmh] specify drive and density\n\
if(n_indalloc
==n_indused
) {
n_ind
=(char **)(n_indused
? ck_realloc(n_ind
,n_indalloc
*sizeof(char *)) : ck_malloc(n_indalloc
*sizeof(char *)));
* Set up to gather file names for tar.
* They can either come from stdin or from argv.
msg("too many args with -T option");
if (!strcmp(name_file
, "-")) {
namef
= fopen(name_file
, "r");
msg_perror("can't open file %s",name_file
);
/* Get file names from argv, after options. */
* Get the next name from argv or the name file.
* Result is in static storage and can't be relied upon across two calls.
/* C is non-zero if we should deal with -C */
static char *buffer
; /* Holding pattern */
extern char *un_quote_string();
buffer
=ck_malloc(NAMSIZ
+2);
else if (optind
< n_argc
)
/* Names come from argv, after options */
msg("Missing filename after -C");
/* 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(c
&& !q
&& p
[0]=='-' && p
[1]=='C' && p
[2]=='\0') {
msg_perror("Can't chdir to %s",p
);
/* End of JF quick -C hack */
if(f_exclude
&& check_exclude(p
))
return un_quote_string(p
);
while(p
= fgets(buffer
, buffer_siz
+1 /*nl*/, namef
)) {
q
= p
+strlen(p
)-1; /* Find the newline */
if (q
<= p
) /* Ignore empty lines */
while(q
==p
+buffer_siz
&& *q
!='\n') {
buffer
=ck_realloc(buffer
,buffer_siz
+NAMSIZ
+2);
*q
-- = '\0'; /* Zap the newline */
while (q
> p
&& *q
== '/') /* Zap trailing /s */
if (c
&& !q2
&& p
[0] == '-' && p
[1] == 'C' && p
[2] == '\0') {
msg_perror ("Can't chdir to %s", p
);
if(f_exclude
&& check_exclude(p
))
return un_quote_string(p
);
* Close the name file, if any.
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.
static struct name
*namebuf
; /* One-name buffer */
namebuf
=(struct name
*)ck_malloc(sizeof(struct name
)+NAMSIZ
);
if(*p
=='-' && p
[1]=='C' && p
[2]=='\0') {
msg("Missing file name after -C");
namebuf
->change_dir
=chdir_name
;
namebuf
->length
= strlen(p
);
if (namebuf
->length
>= namelen
) {
namebuf
=(struct name
*)ck_realloc(namebuf
,sizeof(struct name
)+namebuf
->length
);
strncpy(namebuf
->name
, p
, namebuf
->length
);
namebuf
->name
[ namebuf
->length
] = 0;
namebuf
->next
= (struct name
*)NULL
;
/* Non sorted names -- read them all in */
* Add a name to the namelist.
char *name
; /* pointer to name */
register int i
; /* Length of string */
register struct name
*p
; /* Current struct pointer */
if(name
[0]=='-' && name
[1]=='C' && name
[2]=='\0') {
msg("Missing file name after -C");
#if defined(MSDOS) || defined(USG)
if(!getcwd(path
,MAXPATHLEN
))
msg("Couldn't get current directory.");
msg("Couldn't get current directory: %s",path
);
chdir_name
=new_name(path
,chdir_name
);
p
= (struct name
*)malloc((unsigned)(sizeof(struct name
) + i
));
p
= (struct name
*)malloc ((unsigned)(sizeof (struct name
)));
msg("cannot allocate mem for name '%s'.",name
);
msg("cannot allocate mem for chdir record.");
p
->next
= (struct name
*)NULL
;
strncpy(p
->name
, name
, i
);
p
->name
[i
] = '\0'; /* Null term */
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 (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
;
if (!namelist
) namelist
= p
;
* Match a name from an archive, p, with a name from the namelist.
register struct name
*nlp
;
if (0 == (nlp
= namelist
)) /* Empty namelist is easy */
if (nlp
->change_dir
&& chdir (nlp
->change_dir
))
msg_perror ("Can't change to directory %d", nlp
->change_dir
);
for (; nlp
!= 0; nlp
= nlp
->next
) {
/* If first chars don't match, quick skip */
if (nlp
->firstch
&& nlp
->name
[0] != p
[0])
/* Regular expressions */
if (wildmat(p
, nlp
->name
)) {
nlp
->found
= 1; /* Remember it matched */
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 */
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(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
;
* Print the names of things in the namelist that were not matched.
register struct name
*nlp
,*next
;
for (nlp
= namelist
; nlp
!= 0; nlp
= next
) {
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
namelist
= (struct name
*)NULL
;
namelast
= (struct name
*)NULL
;
while (0 != (p
= name_next(1)))
msg("%s not found in archive", p
);
/* These next routines were created by JF */
/* 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 */
register struct name
*nlp
;
if (0 == (nlp
= namelist
)) /* Empty namelist is easy */
for (; nlp
!= 0; nlp
= nlp
->next
) {
/* If first chars don't match, quick skip */
if (nlp
->firstch
&& nlp
->name
[0] != p
[0])
/* Regular expressions */
if (wildmat(p
, nlp
->name
))
return nlp
; /* We got a match */
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
;
gnu_list_name
= namelist
;
while(gnu_list_name
&& gnu_list_name
->found
)
gnu_list_name
=gnu_list_name
->next
;
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
;
for(n
=namelist
;n
;n
=n
->next
)
path_buf
=(char *)malloc(strlen(path
)+strlen(name
)+2);
msg("Can't allocate memory for name '%s/%s",path
,name
);
(void) sprintf(path_buf
,"%s/%s",path
,name
);
/* returns non-zero if the luser typed 'y' or 'Y', zero otherwise. */
static FILE *confirm_file
= 0;
fprintf(msg_file
,"%s %s?", action
, file
);
confirm_file
= (archive
== 0) ? fopen(TTY_NAME
, "r") : stdin
;
msg("Can't read confirmation from user");
for(nl
= c
; nl
!= '\n' && nl
!= EOF
; nl
= getc(confirm_file
))
return (c
=='y' || c
=='Y');
x_buffer
= (char *)ck_malloc(size_buf
+1024);
} else if(free_x_buffer
<=size_buf
) {
x_buffer
= (char *)ck_realloc(x_buffer
,size_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
);
re_exclude
= (char **)(re_exclude
? ck_realloc(re_exclude
,(size_re_exclude
+32)*sizeof(char *)) : ck_malloc(sizeof(char *)*32));
re_exclude
[size_re_exclude
]=x_buffer
+size_x_buffer
;
exclude
=(char **)(exclude
? ck_realloc(exclude
,(size_exclude
+32)*sizeof(char *)) : ck_malloc(sizeof(char *)*32));
exclude
[size_exclude
]=x_buffer
+size_x_buffer
;
strcpy(x_buffer
+size_x_buffer
,name
);
size_x_buffer
+=size_buf
+1;
free_x_buffer
-=size_buf
+1;
/* Let's hope the person knows what they're doing. */
/* Using -X - -T - -f - will get you *REALLY* strange
msg_perror("can't open %s",file
);
while(fgets(buf
,1024,fp
)) {
end_str
=rindex(buf
,'\n');
return index(str
,'*') || index(str
,'[') || index(str
,'?');
/* Returns non-zero if the file 'name' should not be added/extracted */
for(n
=0;n
<size_re_exclude
;n
++) {
if(wildmat(name
,re_exclude
[n
]))
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
if( (str
=strstr(name
,exclude
[n
]))
&& (str
==name
|| str
[-1]=='/')
&& str
[strlen(exclude
[n
])]=='\0')