Permalink
Find file
Fetching contributors…
Cannot retrieve contributors at this time
897 lines (788 sloc) 43.6 KB
This is paxutils.info, produced by makeinfo version 3.12i from
paxutils.texi.
START-INFO-DIR-ENTRY
* pax utilities: (paxutils). pax and other archiving utilities.
* cpio: (paxutils)cpio invocation. Handling cpio archives.
* pax: (paxutils)pax invocation. The POSIX archiver.
* tar: (paxutils)tar invocation. Making tape (or disk) archives.
* mt: (paxutils)mt invocation. Basic tape positioning.
* rmt: (paxutils)rmt invocation. The remote tape facility.
END-INFO-DIR-ENTRY
This file documents `paxutils' 2.4i.
Copyright (C) 1992, 1994, 1995, 1996, 1997, 1998 Free Software
Foundation, Inc.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of
this manual under the conditions for verbatim copying, provided that
the entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this
manual into another language, under the above conditions for modified
versions, except that this permission notice may be stated in a
translation approved by the Foundation.

File: paxutils.info, Node: Archive format, Next: Index, Prev: Date input formats, Up: Top
Format of archive files
***********************
While an archive may contain many files, the archive itself is a
single ordinary file. Like any other file, an archive file can be
written to a storage device such as a tape or disk, sent through a pipe
or over a network, saved on the active file system, or even stored in
another archive. An archive file is not easy to read or manipulate
without using the `tar' utility or other special tools, such as `tar'
mode in GNU Emacs.
Physically, an archive consists of a series of file entries
terminated by an end-of-archive entry (which consists of a block of 512
zero bytes). A file entry usually describes one of the files in the
archive (an "archive member") and consists of a file header and the
contents of the file. File headers contain file names and statistics,
checksum information that `tar' uses to detect file corruption, and
information about file types.
Archives are permitted to have more than one member with the same
member name. One way this situation can occur is if more than one
version of a file has been stored in the archive. For information
about adding new versions of a file to an archive, see *Note update::,
and to learn more about having more than one archive member with the
same name, see *Note backup::.
In addition to entries describing archive members, an archive may
contain entries which `tar' itself uses to store information. *Note
label::, for an example of such an archive entry.
The remainder of this appendix contains a long quote from `tar'
sources, expressing the structure of a header block directly in the C
language. This description encompasses both POSIX and non-POSIX
aspects of the format. The two sections following the C description
provide more explanations about the POSIX standard format, and then
about the extensions to that format which `tar' uses. These sections
also refer to various constants or fields introduced in the C
description.
* Menu:
* tar-h:: The C description of a header block
* Standard format:: The standard format
* Extended format:: Extensions to the archive format

File: paxutils.info, Node: tar-h, Next: Standard format, Prev: Archive format, Up: Archive format
The C description of a header block
===================================
The header block is defined in C as follows. In the `tar'
distribution, this is part of file `src/tar.h':
/* tar archive format description. */
/* If GNUTAR_COMPATIBILITY is set, tar produces archives which, by default,
are readable by older versions of tar. This can be overridden by using
--posix; in this case, the environment variable POSIXLY_CORRECT can
be set to enforce stricter conformance. If GNUTAR_COMPATIBILITY is zero or
undefined, tar will eventually produces archives which, by default,
will be POSIX compatible; then, either using --posix or defining
POSIXLY_CORRECT will enforce stricter conformance.
This #define will disappear in a few years. FP, June 1995. */
#define GNUTAR_COMPATIBILITY 1
/*---------------------------------------------.
| `tar' Header Block, from POSIX 1003.1-1990. |
`---------------------------------------------*/
/* POSIX header. */
struct posix_header
{ /* byte offset */
char name[100]; /* 0 */
char mode[8]; /* 100 */
char uid[8]; /* 108 */
char gid[8]; /* 116 */
char size[12]; /* 124 */
char mtime[12]; /* 136 */
char chksum[8]; /* 148 */
char typeflag; /* 156 */
char linkname[100]; /* 157 */
char magic[6]; /* 257 */
char version[2]; /* 263 */
char uname[32]; /* 265 */
char gname[32]; /* 297 */
char devmajor[8]; /* 329 */
char devminor[8]; /* 337 */
char prefix[155]; /* 345 */
/* 500 */
};
#define TMAGIC "ustar" /* ustar and a null */
#define TMAGLEN 6
#define TVERSION "00" /* 00 and no null */
#define TVERSLEN 2
/* Values used in typeflag field. */
#define REGTYPE '0' /* regular file */
#define AREGTYPE '\0' /* regular file */
#define LNKTYPE '1' /* link */
#define SYMTYPE '2' /* reserved */
#define CHRTYPE '3' /* character special */
#define BLKTYPE '4' /* block special */
#define DIRTYPE '5' /* directory */
#define FIFOTYPE '6' /* FIFO special */
#define CONTTYPE '7' /* reserved */
/* Bits used in the mode field, values in octal. */
#define TSUID 04000 /* set UID on execution */
#define TSGID 02000 /* set GID on execution */
#define TSVTX 01000 /* reserved */
/* file permissions */
#define TUREAD 00400 /* read by owner */
#define TUWRITE 00200 /* write by owner */
#define TUEXEC 00100 /* execute/search by owner */
#define TGREAD 00040 /* read by group */
#define TGWRITE 00020 /* write by group */
#define TGEXEC 00010 /* execute/search by group */
#define TOREAD 00004 /* read by other */
#define TOWRITE 00002 /* write by other */
#define TOEXEC 00001 /* execute/search by other */
/*-----------------------------------------.
| `tar' Header Block, various extensions. |
`-----------------------------------------*/
/* In tar, SYMTYPE is for symbolic links, and CONTTYPE is for contiguous
files, thus possibly disobeying the `reserved' comment in the POSIX header
description. I suspect these were meant to be used this way, and should
not really have been `reserved' in the published standards. */
/* *BEWARE* that the following information is still in flux, and may change.
Even if the GNUTAR format description should be accurate, the so-called GNU
format is not yet fully decided. It is surely meant to use only extensions
allowed by POSIX, but the sketch below repeats some ugliness from the
GNUTAR format, which should rather go away. Sparse files should be saved
in such a way that they do *not* require two passes at archive creation
time. Huge files cause some POSIX fields to overflow; alternate solutions
have to be sought for this. */
/* Descriptor for a single file hole. */
struct sparse
{ /* byte offset */
char offset[12]; /* 0 */
char numbytes[12]; /* 12 */
/* 24 */
};
/* Sparse files are not supported in POSIX ustar format. For sparse files
with a POSIX header, an extra header is provided which holds overall sparse
information and a few sparse descriptors. When an old GNU header replaces
both the POSIX header and the extra header, it holds some sparse
descriptors too. Whether POSIX or not, if more sparse descriptors are
still needed, they are put into as many successive sparse headers as
necessary. The following constants tell how many sparse descriptors fit in
each kind of header able to hold them. */
#define SPARSES_IN_EXTRA_HEADER 16
#define SPARSES_IN_GNUTAR_HEADER 4
#define SPARSES_IN_SPARSE_HEADER 21
/* The extra header contains some information needed by tar, but not foreseen
in POSIX header format. It is only used after a POSIX header (and never
with old GNU headers), and immediately follows this POSIX header, when
typeflag is a letter rather than a digit, thus signaling an extension. */
struct extra_header
{ /* byte offset */
char atime[12]; /* 0 */
char ctime[12]; /* 12 */
char offset[12]; /* 24 */
char realsize[12]; /* 36 */
char longnames[4]; /* 48 */
char unused_pad1[68]; /* 52 */
struct sparse sp[SPARSES_IN_EXTRA_HEADER];
/* 120 */
char isextended; /* 504 */
/* 505 */
};
/* Extension header for sparse files, used immediately after the extra header,
and used only if all sparse information cannot fit into that extra header.
There might even be many such extension headers, one after the other, until
all sparsity information has been recorded. */
struct sparse_header
{ /* byte offset */
struct sparse sp[SPARSES_IN_SPARSE_HEADER];
/* 0 */
char isextended; /* 504 */
/* 505 */
};
/* The old GNU format header conflicts with POSIX format in such a way that
POSIX archives may fool old tars, and POSIX tars might well be fooled by
old tar archives. An old GNU format header uses the space used by the
prefix field in a POSIX header, and accumulates information normally found
in an extra header. With an old tar header, we never see any POSIX header
nor extra header. Supplementary sparse headers are allowed, however. */
struct gnutar_header
{ /* byte offset */
char unused_pad1[345]; /* 0 */
char atime[12]; /* 345 */
char ctime[12]; /* 357 */
char offset[12]; /* 369 */
char longnames[4]; /* 381 */
char unused_pad2; /* 385 */
struct sparse sp[SPARSES_IN_GNUTAR_HEADER];
/* 386 */
char isextended; /* 482 */
char realsize[12]; /* 483 */
/* 495 */
};
/* GNUTAR_MAGIC uses both magic and version fields, which are contiguous.
Found in an archive, it indicates an old GNU header format, which will
hopefully have become obsolescent. With GNUTAR_MAGIC, uname and gname are
valid, though the header is not truly POSIX conformant. */
#define GNUTAR_MAGIC "ustar " /* 7 chars and a null */
/* The standards committee allows only capital A through capital Z for
user-defined expansion. */
/* This is a dir entry that contains the names of files that were in the dir
at the time the dump was made. */
#define GNUTAR_DUMPDIR 'D'
/* Identifies the *next* file on the tape as having a long linkname. */
#define GNUTAR_LONGLINK 'K'
/* Identifies the *next* file on the tape as having a long name. */
#define GNUTAR_LONGNAME 'L'
/* This is the continuation of a file that began on another volume. */
#define GNUTAR_MULTIVOL 'M'
/* For storing filenames that do not fit into the main header. */
#define GNUTAR_NAMES 'N'
/* This is for sparse files. */
#define GNUTAR_SPARSE 'S'
/* This file is a tape/volume header. Ignore it on extraction. */
#define GNUTAR_VOLHDR 'V'
/* This file is a compressed contiguous regular file. */
#define GNUTAR_CONTIG_COMPRESSED 'X'
/* This file is a compressed sparse regular file. */
#define GNUTAR_SPARSE_COMPRESSED 'Y'
/* This file is a compressed regular file. */
#define GNUTAR_REGULAR_COMPRESSED 'Z'
/*--------------------------------------.
| tar header block, overall structure. |
`--------------------------------------*/
/* tar files are made in basic blocks of this size. */
#define BLOCKSIZE ((size_t) 512)
enum archive_format
{
UNKNOWN_FORMAT, /* format unknown or to be decided later */
BINARY_FORMAT, /* cpio format */
OLD_ASCII_FORMAT, /* cpio format */
NEW_ASCII_FORMAT, /* cpio format */
CRC_ASCII_FORMAT, /* cpio format */
HPUX_OLD_ASCII_FORMAT, /* cpio format */
HPUX_BINARY_FORMAT, /* cpio format */
V7_FORMAT, /* old V7 tar format */
GNUTAR_FORMAT, /* GNU tar format as per before paxutils 3.0 */
POSIX_FORMAT, /* restricted, pure POSIX ustar format */
PAXUTILS_FORMAT /* POSIX format with extensions (vaporware) */
};
union block
{
char buffer[BLOCKSIZE];
struct posix_header header;
struct extra_header extra_header;
struct gnutar_header gnutar_header;
struct sparse_header sparse_header;
};
/* End of format description. */

File: paxutils.info, Node: Standard format, Next: Extended format, Prev: tar-h, Up: Archive format
The standard format
===================
A `tar' archive file contains a series of blocks. Each block
contains `BLOCKSIZE' bytes. Although this format may be thought of as
being on magnetic tape, other media are often used. Each file archived
is represented by a header block which describes the file, followed by
zero or more blocks which give the contents of the file. At the end of
the archive file there may be a block filled with binary zeros as an
end-of-file marker. A reasonable `tar' program should write a block of
zeros at the end, but must not assume that such a block exists when
reading an archive.
The blocks may be further "blocked" into records for physical I/O
subcommands. Each record of N blocks (where N is set by the
`--blocking-factor=BLOCKS' (`-b BLOCKS') option to `tar') is written
with a single `write ()' subcommand. On magnetic tapes, the result of
such a write is a single record. When writing an archive, the last
record of blocks should be written at the full size, with blocks after
the zero block containing all zeros. When reading an archive, `tar'
should properly handle an archive whose last record is shorter than the
rest, or which contains garbage records after a zero block, as such
things exist in practice.
There is no relation between record boundaries and archive member
boundaries. The initial header block for an archive member may start
in any block position within a record, either at the very beginning of
the first record of an archive file, or immediately after the last
block of the preceding archive member, possibly in the same record.
All characters in header blocks are represented by using 8-bit
characters in the local extension of ASCII. Each field within the
structure is contiguous; that is, there is no padding used within the
structure. Each character on the archive medium is stored contiguously.
Bytes representing the contents of files (after the header block of
each file) are not translated in any way and are not constrained to
represent characters in any character set. The `tar' format does not
distinguish text files from binary files, and no translation of file
contents is performed.
The `name', `linkname', `magic', `uname', and `gname' are
null-terminated character strings. All other fileds are zero-filled
octal numbers in ASCII. Each numeric field of width W contains W minus
2 digits, a space, and a null, except `size' and `mtime', which do not
contain the trailing null.
The `name' field is the file name of the file, with directory names
(if any) preceding the file name, separated by slashes.
The `mode' field provides nine bits specifying file permissions and
three bits to specify the setuid, setgid, and Save Text ("sticky")
modes. Values for these bits are defined above. When special
permissions are required to create a file with a given mode, and the
user restoring files from the archive does not hold such permissions,
the mode bit(s) specifying those special permissions are ignored.
Modes which are not supported by the operating system restoring files
from the archive will be ignored. Unsupported modes should be faked up
when creating or updating an archive; for example, the group permission
could be copied from the _other_ permission.
The `uid' and `gid' fields are the numeric user and group IDs of the
file owner, respectively. If the operating system does not support
numeric user or group IDs, these fields should be ignored.
The `size' field is the size of the file in bytes; linked files are
archived with this field specified as zero. *Note Backups::, in
particular the `--incremental' (`-G') option.
The `mtime' field is the modification time of the file at the time
it was archived. It is the ASCII representation of the octal value of
the last time the file was modified, represented as an integer number of
seconds since 1970-01-01, 00:00 Coordinated Universal Time.
The `chksum' field is the ASCII representation of the octal value of
the simple sum of all bytes in the header block. Each 8-bit byte in
the header is added to an unsigned integer, initialized to zero, the
precision of which shall be no less than seventeen bits. When
calculating the checksum, the `chksum' field is treated as if it were
all blanks.
The `typeflag' field specifies the type of file archived. If a
particular implementation does not recognize or permit the specified
type, the file will be extracted as if it were a regular file. As this
action occurs, `tar' issues a warning to the standard error. The POSIX
types are listed in the following table.
`REGTYPE'
`AREGTYPE'
These flags represent a regular file. In order to be compatible
with older versions of `tar', a `typeflag' value of `AREGTYPE'
should be silently recognized as a regular file. New archives
should be created using `REGTYPE'. Also, for backward
compatibility, `tar' treats a regular file whose name ends with a
slash as a directory.
`LNKTYPE'
This flag represents a file linked to another file, of any type,
previously archived. Such files are identified in Unix by each
file having the same device and inode number. The linked-to name
is specified in the `linkname' field with a trailing null.
`SYMTYPE'
This represents a symbolic link to another file. The linked-to
name is specified in the `linkname' field with a trailing null.
`CHRTYPE'
`BLKTYPE'
These represent character special files and block special files
respectively. In this case the `devmajor' and `devminor' fields
will contain the major and minor device numbers respectively.
Operating systems may map the device specifications to their own
local specification, or may ignore the entry.
`DIRTYPE'
This flag specifies a directory or subdirectory. The directory
name in the `name' field should end with a slash. On systems where
disk allocation is performed on a directory basis, the `size' field
will contain the maximum number of bytes (which may be rounded to
the nearest disk block allocation unit) which the directory may
hold. A `size' field of zero indicates no such limit. Systems
which do not support limiting in this manner should ignore the
`size' field.
`FIFOTYPE'
This specifies a FIFO special file. Note that the archiving of a
FIFO file archives the existence of this file and not its contents.
`CONTTYPE'
This specifies a contiguous file, which is the same as a normal
file except that, in operating systems which support it, all its
space is allocated contiguously on the disk. Operating systems
which do not allow contiguous allocation should silently treat this
type as a normal file.
`A' ... `Z'
These are reserved for custom implementations. Some of these are
used in the extended format (*note Extended format::.).
Other values are reserved for specification in future revisions of the
P1003 standard, and should not be used by any `tar' program.
The `atime' and `ctime' fields are used in making incremental
backups; they store, respectively, the particular file's access time
and last inode-change time.
The `offset' is used by the `--multi-volume' (`-M') option, when
making a multi-volume archive. The offset is number of bytes into the
file that we need to restart at to continue the file on the next tape,
that is, where we store the location that a continued file is continued
at.
The `magic' field indicates that this archive was output in the
P1003 archive format. If this field contains `TMAGIC', the `uname' and
`gname' fields will contain the ASCII representation of the owner and
group of the file respectively. If found, the user and group IDs are
used rather than the values in the `uid' and `gid' fields.
For references, see ISO/IEC 9945-1:1990 or IEEE Std 1003.1-1990,
pages 169-173 (section 10.1) for `Archive/Interchange File Format'; and
IEEE Std 1003.2-1992, pages 380-388 (section 4.48) and pages 936-940
(section E.4.48) for `pax--Portable archive interchange'.

File: paxutils.info, Node: Extended format, Prev: Standard format, Up: Archive format
Extensions to the archive format
================================
The extended format specifies additional values in the `typeflag'
field to describe new types of files in an archive. These are listed
below.
`GNUTAR_DUMPDIR'
`'D''
This represents a directory and a list of files created by the
`--incremental' (`-G') option. The `size' field gives the total
size of the associated list of files. Each file name is preceded
by either a `Y' (the file should be in this archive) or an `N'.
(The file is a directory, or is not stored in the archive.) Each
file name is terminated by `NUL'. There is an additional `NUL'
after the last file name.
`GNUTAR_MULTIVOL'
`'M''
This represents a file continued from another volume of a
multi-volume archive created with the `--multi-volume' (`-M')
option. The original type of the file is not given here. The
`size' field gives the maximum size of this piece of the file
(assuming the volume does not end before the file is written out).
The `offset' field gives the offset from the beginning of the
file where this part of the file begins. Thus `size' plus
`offset' should equal the original size of the file.
`GNUTAR_SPARSE'
`'S''
This flag indicates that we are dealing with a sparse file. Note
that archiving a sparse file requires special subcommands to find
holes in the file, which mark the positions of these holes, along
with the number of bytes of data to be found after the hole.
`GNUTAR_VOLHDR'
`'V''
This file type is used to mark the volume header that was given
with the `--label=ARCHIVE-LABEL' (`-V ARCHIVE-LABEL') option when
the archive was created. The `name' field contains the `name'
given after the `--label=ARCHIVE-LABEL' (`-V ARCHIVE-LABEL')
option. The `size' field is zero. Only the first file in each
volume of an archive should have this type.
You may have trouble reading an extended format archive with some
other `tar' if the options `--incremental' (`-G'), `--multi-volume'
(`-M'), `--sparse' (`-S'), or `--label=ARCHIVE-LABEL' (`-V
ARCHIVE-LABEL') were used when writing the archive. In general, if
`tar' does not use the extension format fields of the header, other
versions of `tar' should be able to read the archive. Otherwise, the
`tar' program will give an error, the most likely one being a checksum
error.
A few fields were added to the POSIX header to deal with sparse
files. A file is "sparse" if it takes in unallocated blocks which end
up being represented as zeros, that is, no useful data. A test to see
if a file is sparse is to look at the number of blocks allocated for it
versus the number of characters in the file; if there are fewer blocks
allocated for the file than would normally be allocated for a file of
that size, then the file is sparse. This is the method `tar' uses to
detect a sparse file, and once such a file is detected, it is treated
differently from non-sparse files.
Sparse files are often `dbm' files, or other database-type files
which have data at some points and emptiness in the greater part of the
file. Such files can appear to be very large when an `ls -l' is done
on them, when in truth there may be a very small amount of important
data contained in the file. It is thus undesirable to have `tar' think
that it must back up this entire file, as great quantities of room are
wasted on empty blocks, which can lead to running out of room on a tape
far earlier than is necessary. Thus, sparse files are dealt with so
that these empty blocks are not written to the tape. Instead, what is
written to the tape is a description, of sorts, of the sparse file:
where the holes are, how big the holes are, and how much data is found
at the end of the hole. This way, the file takes up potentially far
less room on the tape, and when the file is extracted later on, it will
look exactly the way it looked beforehand. The following is a
description of the fields used to handle a sparse file:
The `sp' is an array of `struct sparse'. Each `struct sparse'
contains two 12-character strings which represent an offset into the
file and a number of bytes to be written at that offset. The offset is
absolute, and not relative to the offset in the preceding array element.
The header can hold four of these `struct sparse' at the moment; if
more are needed, they are not stored in the header.
The `isextended' flag is set when an `extended_header' is needed to
deal with a file. Note that this means that this flag can only be set
when dealing with a sparse file, and it is only set in the event that
the description of the file will not fit in the alloted room for sparse
structures in the header. In other words, an extended_header is needed.
The `extended_header' structure is used for sparse files which need
more sparse structures than can fit in the header. The header can fit
4 such structures; if more are needed, the flag `isextended' gets set
and the next block is an `extended_header'.
Each `extended_header' structure contains an array of 21 sparse
structures, along with an `isextended' flag similar to the one that the
header had. There can be an indeterminate number of such
`extended_header's to describe a sparse file.

File: paxutils.info, Node: Index, Prev: Archive format, Up: Top
Index
*****
* Menu:
* -list with file name arguments <1>: list.
* -list with file name arguments: list tutorial.
* -suffix: suffix.
* 8601 Dates (ISO): list.
* abbreviations for months: Calendar date item.
* absolute file names: absolute-names.
* Acting interactively: interactive.
* Adding archives to an archive: concatenate.
* Adding files to an Archive: Appending files.
* Age, excluding files by: Time criteria.
* ago in date strings: Relative item in date strings.
* Alaska-Hawaii Time: Timezone item.
* am in date strings: Time of day item.
* Appending files to an Archive: Appending files.
* archive: Definitions.
* Archive creation <1>: Using file.
* Archive creation: file.
* archive member: Definitions.
* Archive Name: file.
* Archive, create empty: create.
* Archives, Appending files to: Appending files.
* Archives, on remote machines: file.
* Archiving directories: create dir tutorial.
* Atlantic Standard Time: Timezone item.
* Authors of getdate: Authors of getdate.
* Avoiding recursion in directories: no-recursion.
* Azores Time: Timezone item.
* backup files, type made: backup.
* backup options: backup.
* backup suffix: suffix.
* backups, making: backup.
* Baghdad Time: Timezone item.
* beginning of time, for Unix: Date input formats.
* Bellovin, Steven M.: Authors of getdate.
* Berets, Jim: Authors of getdate.
* Berry, K.: Authors of getdate.
* Block number where error occured: Documentation and help.
* Blocking Factor: blocking-factor.
* Blocks per record: blocking-factor.
* bug reports: Reports.
* Bytes per record: blocking-factor.
* Calendar date item: Calendar date item.
* case, ignored in dates: General date syntax.
* cat vs concatenate <1>: Using cat with archives.
* cat vs concatenate: concatenate.
* Central Alaska Time: Timezone item.
* Central European Time: Timezone item.
* Central Standard Time: Timezone item.
* Changing directory mid-stream: directory.
* Character class, excluding characters from: Wildcards.
* China Coast Time: Timezone item.
* Choosing an archive file: file.
* command line options: cpio invocation.
* comments, in dates: General date syntax.
* Compressed archives: gzip.
* Compressed archives, modification of: Archive compression.
* concatenate vs cat <1>: Using cat with archives.
* concatenate vs cat: concatenate.
* Concatenating Archives: concatenate.
* copying directory structures: cpio Tutorial.
* corrupted archives: Full dumps.
* Corrupted archives: Archive compression.
* cpio: What cpio does.
* Create empty archive: create.
* creating a cpio archive: cpio Tutorial.
* DAT blocking: Media types.
* date format, ISO 8601: Calendar date item.
* date input formats: Date input formats.
* Dates format: list.
* day in date strings: Relative item in date strings.
* Day of week item: Day of week item.
* daylight savings time: Timezone item.
* Deleting files from an archive: delete.
* Deleting from tape archives: delete.
* Descending directories, avoiding: no-recursion.
* Directing output: file.
* Directories, Archiving: create dir tutorial.
* Directories, avoiding recursion: no-recursion.
* Directory, changing mid-stream: directory.
* Disk space, running out of: Scarce.
* Displacement of dates: Relative item in date strings.
* Double-checking a write operation: verify.
* dumps, full: Full dumps.
* dumps, incremental: Incremental dumps.
* Duplicate entries: quick.
* East Australian Standard Time: Timezone item.
* Eastern European Time: Timezone item.
* Eastern Standard Time: Timezone item.
* Empty archive, how to create: create.
* End-of-archive entries, ignoring: Reading.
* entry: Stylistic conventions.
* epoch, for Unix: Date input formats.
* Error message, block number of: Documentation and help.
* Exabyte blocking: Media types.
* exclude: exclude.
* exclude-from: exclude-from.
* Excluding characters from a character class: Wildcards.
* Excluding file by age: Time criteria.
* Excluding files by file system: Exclusions.
* Excluding files by name and pattern: Exclusions.
* existing backup method: backup.
* exit status: Synopsis.
* extracting a cpio archive: cpio Tutorial.
* Extracting files on MS-DOS, illegal characters: extract options.
* Extraction <1>: extract.
* Extraction: extract tutorial.
* extraction: Definitions.
* Feedback from tar: Documentation and help.
* file name: Definitions.
* File Name arguments, alternatives: files-from.
* File name arguments, using --list (-t) with <1>: list.
* File name arguments, using --list (-t) with: list tutorial.
* File names, excluding files by: Exclusions.
* File names, terminated by NUL: null.
* File names, using symbolic links: dereference.
* File system boundaries, not crossing: one-file-system.
* File time stamp on MS-DOS/MS-Windows: Time criteria.
* Filenames, illegal characters on MS-DOS: extract options.
* first in date strings: General date syntax.
* Format Options: Media.
* Format Parameters: Media.
* Format, old style: old-archive.
* fortnight in date strings: Relative item in date strings.
* French Winter Time: Timezone item.
* full dumps: Full dumps.
* General date syntax: General date syntax.
* getdate: Date input formats.
* Getting more information: Documentation and help.
* Greenwich Mean Time: Timezone item.
* Guam Standard Time: Timezone item.
* Hawaii Standard Time: Timezone item.
* hour in date strings: Relative item in date strings.
* Ignoring end-of-archive entries: Reading.
* incremental dumps: Incremental dumps.
* Information during operation: Documentation and help.
* Information on progress and status of subcommands: Documentation and help.
* Interactive action: interactive.
* International Date Line East: Timezone item.
* International Date Line West: Timezone item.
* invoking cpio: cpio invocation.
* ISO 8601 date format: Calendar date item.
* ISO 8601 Dates: list.
* items in date strings: General date syntax.
* Japan Standard Time: Timezone item.
* Labeling an archive: label.
* Labelling multi-volume archives: Multi-volume archives.
* Labels on the archive media: label.
* Large lists of file names on small machines: Reading.
* last DAY: Day of week item.
* last in date strings: General date syntax.
* Lists of file names: files-from.
* MacKenzie, David: Authors of getdate.
* member: Definitions.
* member name: Definitions.
* Members, replacing with other members: append.
* Meyering, Jim: Authors of getdate.
* Middle European Time: Timezone item.
* Middle European Winter Time: Timezone item.
* Middle of the archive, starting in the: Scarce.
* midnight in date strings: Time of day item.
* minute in date strings: Relative item in date strings.
* minutes, timezone correction by: Time of day item.
* Mistake: forget archive name: Two mistakes.
* Mistake: use create instead of extract: Two mistakes.
* Mod time differs message on MS-DOS disks: compare.
* Modes of extracted files: Writing.
* Modification time, excluding files by: Time criteria.
* Modification time, on MS-DOS: Time criteria.
* Modification times of extracted files: Writing.
* month in date strings: Relative item in date strings.
* month names in date strings: Calendar date item.
* months, written-out: General date syntax.
* Mountain Standard Time: Timezone item.
* Multi-volume archives: Multi-volume archives.
* Name Prefixes,: name-prefix.
* Naming an archive: file.
* New Zealand Standard Time: Timezone item.
* next DAY: Day of week item.
* next in date strings: General date syntax.
* Nome Standard Time: Timezone item.
* noon in date strings: Time of day item.
* now in date strings: Relative item in date strings.
* ntape device: Many on one.
* NUL terminated file names: null.
* Number of blocks per record: blocking-factor.
* Number of bytes per record: blocking-factor.
* numbered backup method: backup.
* numbers, written-out: General date syntax.
* Old style archives: old-archive.
* Old style format: old-archive.
* option syntax, traditional: Old style.
* Options when reading archives: Reading.
* Options, archive format specifying: Media.
* Options, format specifying: Media.
* ordinal numbers: General date syntax.
* Overwriting old files, prevention: Writing.
* Overwriting prevention on MS-DOS and MS-Windows: Preventing overwrite.
* Pacific Standard Time: Timezone item.
* passing directory structures: cpio Tutorial.
* pax: What pax does.
* Permissions of extracted files: Writing.
* Pinard, F.: Authors of getdate.
* pm in date strings: Time of day item.
* Prefixes, Name: name-prefix.
* Progress information: Documentation and help.
* Protecting old files: Writing.
* Pure numbers in date strings: Pure numbers in date strings.
* Quick extraction: quick.
* Reading file names from a file: files-from.
* Reading incomplete records: Reading.
* Record Size: blocking-factor.
* Records, incomplete: Reading.
* Recursion in directories, avoiding: no-recursion.
* Relative items in date strings: Relative item in date strings.
* Remote archives and MS-DOS file names: file.
* Remote archives specification: file.
* remote tape drive: Remote.
* Removing existing files on MS-DOS: Preventing overwrite.
* Removing files from an archive: delete.
* Replacing members with other members: append.
* reporting bugs: Reports.
* Resurrecting files from an archive <1>: extract.
* Resurrecting files from an archive: extract tutorial.
* Retrieving files from an archive <1>: extract.
* Retrieving files from an archive: extract tutorial.
* return status: Synopsis.
* rmt: Remote.
* Running out of space: Reading.
* Running out of space during extraction: Scarce.
* Salz, Rich: Authors of getdate.
* simple backup method: backup.
* SIMPLE_BACKUP_SUFFIX: suffix.
* Small memory: Reading.
* Space on the disk, recovering from lack of: Scarce.
* Sparse Files: sparse.
* Specifying archive members: Selecting Archive Members.
* Specifying files to act on: Selecting Archive Members.
* Speed versus duplicate entries: quick.
* Standard input and output <1>: Standard archive.
* Standard input and output: file.
* Standard output, writing extracted files to: Writing.
* Status information: Documentation and help.
* Storing archives in compressed format: gzip.
* Swedish Winter Time: Timezone item.
* Symbolic link as file name: dereference.
* tape marks: Many on one.
* tape positioning: Many on one.
* Tapes, using --delete and: delete.
* tar: What tar does.
* tar archive: Definitions.
* tar entry: Stylistic conventions.
* tar file: Stylistic conventions.
* tar to standard input and output <1>: Standard archive.
* tar to standard input and output: file.
* this in date strings: Relative item in date strings.
* Time of day item: Time of day item.
* Timestamp differences, on MS-DOS/MS-Windows filesystems: compare.
* timezone correction: Time of day item.
* Timezone item: Timezone item.
* today in date strings: Relative item in date strings.
* tomorrow in date strings: Relative item in date strings.
* Ultrix 3.1 and write failure: Other tape considerations.
* Universal Coordinated Time: Timezone item.
* unpacking: Definitions.
* Updating an archive: update.
* Using cat to concatenate archives: Using cat with archives.
* USSR Zone: Timezone item.
* uuencode: Applications.
* Verbose subcommand: Documentation and help.
* Verifying a write operation: verify.
* Verifying the currency of an archive: compare.
* Version of the tar program: Documentation and help.
* version-control Emacs variable: backup.
* VERSION_CONTROL: backup.
* week in date strings: Relative item in date strings.
* West African Time: Timezone item.
* West Australian Standard Time: Timezone item.
* Western European Time: Timezone item.
* Where is the archive?: file.
* Working directory, specifying: directory.
* Writing extracted files to standard output: Writing.
* Writing new archives <1>: Using file.
* Writing new archives: file.
* year in date strings: Relative item in date strings.
* yesterday in date strings: Relative item in date strings.
* Yukon Standard Time: Timezone item.