add a cpio implementation to tools directory

cpio utility is a mess in point of portability.
For example NetBSD cpio implementation does not support
userid and groupid changes for the archive. This
feature is required for initramfs filesystem targets.
This cpio is from the Heirloom project.

Fix needed rebuild of tools, when changing targets.

1 files changed, 7185 insertions, 0 deletions

diff --git a/tools/cpio/src/cpio.c b/tools/cpio/src/cpio.c
new file mode 100644
index 000000000..1300d2d70
--- /dev/null
+++ b/tools/cpio/src/cpio.c
@@ -0,0 +1,7185 @@
+/*
+ * cpio - copy file archives in and out
+ *
+ * Gunnar Ritter, Freiburg i. Br., Germany, April 2003.
+ */
+/*
+ * Copyright (c) 2003 Gunnar Ritter
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty. In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute
+ * it freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ *
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ *
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+/*
+ * Sccsid @(#)cpio.c	1.304 (gritter) 2/14/09
+ */
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#ifdef	__linux__
+#if !defined (__UCLIBC__) && !defined (__dietlibc__)
+#include <linux/fs.h>
+#endif	/* !__UCLIBC__, !__dietlibc__ */
+#include <linux/fd.h>
+#undef	WNOHANG
+#undef	WUNTRACED
+#undef	P_ALL
+#undef	P_PID
+#undef	P_PGID
+#ifdef	__dietlibc__
+#undef	NR_OPEN
+#undef	PATH_MAX
+#endif	/* __dietlibc__ */
+#endif	/* __linux__ */
+#include <sys/wait.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <malloc.h>
+#include <string.h>
+#include <unistd.h>
+#include <signal.h>
+#include "sigset.h"
+#include <time.h>
+#include <utime.h>
+#include <pwd.h>
+#include <grp.h>
+#include <limits.h>
+#include <stdio.h>
+#include <libgen.h>
+#include <errno.h>
+#include <inttypes.h>
+#include <stdarg.h>
+#include <locale.h>
+#include <ctype.h>
+#include "memalign.h"
+
+int	sysv3;
+
+#if USE_ZLIB
+#include <zlib.h>
+#endif	/* USE_ZLIB */
+
+#if USE_BZLIB
+#include <bzlib.h>
+#endif	/* USE_BZLIB */
+
+#include <sys/ioctl.h>
+
+#if defined (__linux__) || defined (__sun) || defined (__FreeBSD__) || \
+	defined (__hpux) || defined (_AIX) || defined (__NetBSD__) || \
+	defined (__OpenBSD__) || defined (__DragonFly__) || defined (__APPLE__)
+#include <sys/mtio.h>
+#else	/* SVR4.2MP */
+#include <sys/scsi.h>
+#include <sys/st01.h>
+#endif	/* SVR4.2MP */
+
+#include <iblok.h>
+#include <sfile.h>
+#include <atoll.h>
+
+#ifdef	_AIX
+#include <sys/sysmacros.h>
+#endif	/* _AIX */
+
+#ifndef	major
+#include <sys/mkdev.h>
+#endif	/* !major */
+
+#include "cpio.h"
+#include "blast.h"
+
+#ifdef	__GLIBC__
+#ifdef	_IO_putc_unlocked
+#undef	putc
+#define	putc(c, f)	_IO_putc_unlocked(c, f)
+#undef	putchar
+#define	putchar(c)	_IO_putc_unlocked(c, stdout)
+#endif	/* _IO_putc_unlocked */
+#endif	/* __GLIBC__ */
+
+/*
+ * The cpio code assumes that all following S_IFMT bits are the same as
+ * those of the mode fields in cpio headers. The only real Unix system
+ * known to deviate from this de facto standard is UNICOS which uses
+ * 0130000 for S_IFLNK. But this software does not run on UNICOS for
+ * a variety of other reasons anyway, so this should not be of much
+ * concern.
+ */
+#if	S_IFIFO	!= 0010000 || \
+	S_IFCHR	!= 0020000 || \
+	S_IFDIR	!= 0040000 || \
+	S_IFBLK	!= 0060000 || \
+	S_IFREG	!= 0100000 || \
+	S_IFLNK	!= 0120000 || \
+	S_IFSOCK!= 0140000 || \
+	S_IFMT	!= 0170000
+#error non-standard S_IFMT bits
+#endif
+
+/*
+ * File types that are not present on all systems but that we want to
+ * recognize nevertheless.
+ */
+#ifndef	S_IFDOOR
+#define	S_IFDOOR	0150000		/* Solaris door */
+#endif
+#ifndef	S_IFNAM
+#define	S_IFNAM		0050000		/* XENIX special named file */
+#endif
+#ifndef	S_INSEM
+#define	S_INSEM		0x1		/* XENIX semaphore subtype of IFNAM */
+#endif
+#ifndef	S_INSHD
+#define	S_INSHD		0x2		/* XENIX shared data subtype of IFNAM */
+#endif
+#ifndef	S_IFNWK
+#define	S_IFNWK		0110000		/* HP-UX network special file */
+#endif
+
+#if defined (__FreeBSD__) || defined (__NetBSD__) || defined (__OpenBSD__) || \
+	defined (__DragonFly__) || defined (__APPLE__)
+/*
+ * For whatever reason, FreeBSD casts the return values of major() and
+ * minor() to signed values so that normal limit comparisons will fail.
+ */
+static unsigned long
+mymajor(long dev)
+{
+	return major(dev) & 0xFFFFFFFFUL;
+}
+#undef	major
+#define	major(a)	mymajor(a)
+static unsigned long
+myminor(long dev)
+{
+	return minor(dev) & 0xFFFFFFFFUL;
+}
+#undef	minor
+#define	minor(a)	myminor(a)
+#endif	/* __FreeBSD__, __NetBSD__, __OpenBSD__, __DragonFly__, __APPLE__ */
+
+/*
+ * Device and inode counts in cpio formats are too small to store the
+ * information used to detect hard links on today's systems. Keep track
+ * of all devices and inodes and store fake counts in the archive.
+ */
+struct ilink {
+	struct ilink	*l_nxt;	/* next link to same i-node */
+	char		*l_nam;	/* link name */
+	size_t		l_siz;	/* link name size */
+};
+
+struct islot {
+	struct islot	*i_lln;	/* left link */
+	struct islot 	*i_rln;	/* right link */
+	struct ilink	*i_lnk;	/* links list */
+	struct stat	*i_st;	/* stat information */
+	char		*i_name;/* name of first link encountered */
+	ino_t		i_ino;	/* real inode number */
+	uint32_t	i_fino;	/* fake inode number */
+	nlink_t		i_nlk;	/* number of remaining links */
+};
+
+struct dslot {
+	struct dslot	*d_nxt;	/* next device */
+	struct islot	*d_isl;	/* inode slots */
+	uint32_t	d_cnt;	/* used inode number count */
+	uint32_t	d_fake;	/* faked device id */
+	dev_t		d_dev;	/* real device id */
+};
+
+union types2 {
+	uint8_t		byte[2];
+	uint16_t	sword;
+};
+
+union types4 {
+	uint8_t		byte[4];
+	uint16_t	sword[2];
+	uint32_t	lword;
+};
+
+/*
+ * Store and retrieve integers in a defined endian order.
+ */
+static uint16_t
+ple16(const char *cp)
+{
+	return (uint16_t)(cp[0]&0377) +
+		((uint16_t)(cp[1]&0377) << 8);
+}
+
+static uint16_t
+pbe16(const char *cp)
+{
+	return (uint16_t)(cp[1]&0377) +
+		((uint16_t)(cp[0]&0377) << 8);
+}
+
+static uint32_t
+ple32(const char *cp)
+{
+	return (uint32_t)(cp[0]&0377) +
+		((uint32_t)(cp[1]&0377) << 8) +
+		((uint32_t)(cp[2]&0377) << 16) +
+		((uint32_t)(cp[3]&0377) << 24);
+}
+
+static uint32_t
+pbe32(const char *cp)
+{
+	return (uint32_t)(cp[3]&0377) +
+		((uint32_t)(cp[2]&0377) << 8) +
+		((uint32_t)(cp[1]&0377) << 16) +
+		((uint32_t)(cp[0]&0377) << 24);
+}
+
+static uint32_t
+pme32(const char *cp)
+{
+	return (uint32_t)(cp[2]&0377) +
+		((uint32_t)(cp[3]&0377) << 8) +
+		((uint32_t)(cp[0]&0377) << 16) +
+		((uint32_t)(cp[1]&0377) << 24);
+}
+
+static uint64_t
+ple64(const char *cp)
+{
+	return (uint64_t)(cp[0]&0377) +
+		((uint64_t)(cp[1]&0377) << 8) +
+		((uint64_t)(cp[2]&0377) << 16) +
+		((uint64_t)(cp[3]&0377) << 24) +
+		((uint64_t)(cp[4]&0377) << 32) +
+		((uint64_t)(cp[5]&0377) << 40) +
+		((uint64_t)(cp[6]&0377) << 48) +
+		((uint64_t)(cp[7]&0377) << 56);
+}
+
+static uint64_t
+pbe64(const char *cp)
+{
+	return (uint64_t)(cp[7]&0377) +
+		((uint64_t)(cp[6]&0377) << 8) +
+		((uint64_t)(cp[5]&0377) << 16) +
+		((uint64_t)(cp[4]&0377) << 24) +
+		((uint64_t)(cp[3]&0377) << 32) +
+		((uint64_t)(cp[2]&0377) << 40) +
+		((uint64_t)(cp[1]&0377) << 48) +
+		((uint64_t)(cp[0]&0377) << 56);
+}
+
+static void
+le16p(uint16_t n, char *cp)
+{
+	cp[0] = (n&0x00ff);
+	cp[1] = (n&0xff00) >> 8;
+}
+
+static void
+be16p(uint16_t n, char *cp)
+{
+	cp[1] = (n&0x00ff);
+	cp[0] = (n&0xff00) >> 8;
+}
+
+static void
+le32p(uint32_t n, char *cp)
+{
+	cp[0] = (n&0x000000ff);
+	cp[1] = (n&0x0000ff00) >> 8;
+	cp[2] = (n&0x00ff0000) >> 16;
+	cp[3] = (n&0xff000000) >> 24;
+}
+
+static void
+be32p(uint32_t n, char *cp)
+{
+	cp[3] = (n&0x000000ff);
+	cp[2] = (n&0x0000ff00) >> 8;
+	cp[1] = (n&0x00ff0000) >> 16;
+	cp[0] = (n&0xff000000) >> 24;
+}
+
+static void
+me32p(uint32_t n, char *cp)
+{
+	cp[2] = (n&0x000000ff);
+	cp[3] = (n&0x0000ff00) >> 8;
+	cp[0] = (n&0x00ff0000) >> 16;
+	cp[1] = (n&0xff000000) >> 24;
+}
+
+static void
+le64p(uint64_t n, char *cp)
+{
+	cp[0] = (n&0x00000000000000ffLL);
+	cp[1] = (n&0x000000000000ff00LL) >> 8;
+	cp[2] = (n&0x0000000000ff0000LL) >> 16;
+	cp[3] = (n&0x00000000ff000000LL) >> 24;
+	cp[4] = (n&0x000000ff00000000LL) >> 32;
+	cp[5] = (n&0x0000ff0000000000LL) >> 40;
+	cp[6] = (n&0x00ff000000000000LL) >> 48;
+	cp[7] = (n&0xff00000000000000LL) >> 56;
+}
+
+static void
+be64p(uint64_t n, char *cp)
+{
+	cp[7] = (n&0x00000000000000ffLL);
+	cp[6] = (n&0x000000000000ff00LL) >> 8;
+	cp[5] = (n&0x0000000000ff0000LL) >> 16;
+	cp[4] = (n&0x00000000ff000000LL) >> 24;
+	cp[3] = (n&0x000000ff00000000LL) >> 32;
+	cp[2] = (n&0x0000ff0000000000LL) >> 40;
+	cp[1] = (n&0x00ff000000000000LL) >> 48;
+	cp[0] = (n&0xff00000000000000LL) >> 56;
+}
+
+#define	TNAMSIZ	100
+#define	TPFXSIZ	155
+#define	TMAGSIZ	6
+#define	TTIMSIZ	12
+
+/*
+ * Structure of an archive header.
+ */
+union bincpio {
+	char		data[4096];
+#define	SIZEOF_hdr_cpio	26
+	struct hdr_cpio {
+		char		c_magic[2];
+		char		c_dev[2];
+		char		c_ino[2];
+		char		c_mode[2];
+		char		c_uid[2];
+		char		c_gid[2];
+		char		c_nlink[2];
+		char		c_rdev[2];
+		char		c_mtime[4];
+		char		c_namesize[2];
+		char		c_filesize[4];
+	} Hdr;
+#define	SIZEOF_cray_hdr	152
+	struct cray_hdr {	/* with thanks to Cray-Cyber.org */
+		char		C_magic[8];
+		char		C_dev[8];
+		char		C_ino[8];
+		char		C_mode[8];
+		char		C_uid[8];
+		char		C_gid[8];
+		char		C_nlink[8];
+		char		C_rdev[8];
+				/*
+				 * The C_param field was introduced with
+				 * UNICOS 6 and is simply not present in
+				 * the earlier format. Following fields
+				 * are the same for both revisions again.
+				 */
+#define	CRAY_PARAMSZ	(8*8)
+		char		C_param[CRAY_PARAMSZ];
+		char		C_mtime[8];
+		char		C_namesize[8];
+		char		C_filesize[8];
+	} Crayhdr;
+#define	SIZEOF_c_hdr	76
+	struct c_hdr {
+		char		c_magic[6];
+		char		c_dev[6];
+		char		c_ino[6];
+		char		c_mode[6];
+		char		c_uid[6];
+		char		c_gid[6];
+		char		c_nlink[6];
+		char		c_rdev[6];
+		char		c_mtime[11];
+		char		c_namesz[6];
+		char		c_filesz[11];
+	} Cdr;
+#define	SIZEOF_d_hdr	86
+	struct d_hdr {
+		char		d_magic[6];
+		char		d_dev[6];
+		char		d_ino[6];
+		char		d_mode[6];
+		char		d_uid[6];
+		char		d_gid[6];
+		char		d_nlink[6];
+		char		d_rmaj[8];
+		char		d_rmin[8];
+		char		d_mtime[11];
+		char		d_namesz[6];
+		char		d_filesz[11];
+	} Ddr;
+#define	SIZEOF_Exp_cpio_hdr	110
+	struct Exp_cpio_hdr {
+		char		E_magic[6];
+		char		E_ino[8];
+		char		E_mode[8];
+		char		E_uid[8];
+		char		E_gid[8];
+		char		E_nlink[8];
+		char		E_mtime[8];
+		char		E_filesize[8];
+		char		E_maj[8];
+		char		E_min[8];
+		char		E_rmaj[8];
+		char		E_rmin[8];
+		char		E_namesize[8];
+		char		E_chksum[8];
+	} Edr;
+	struct tar_header {
+		char		t_name[TNAMSIZ];
+		char		t_mode[8];
+		char		t_uid[8];
+		char		t_gid[8];
+		char		t_size[12];
+		char		t_mtime[TTIMSIZ];
+		char		t_chksum[8];
+		char		t_linkflag;
+		char		t_linkname[TNAMSIZ];
+		char		t_magic[TMAGSIZ];
+		char		t_version[2];
+		char		t_uname[32];
+		char		t_gname[32];
+		char		t_devmajor[8];
+		char		t_devminor[8];
+		char		t_prefix[TPFXSIZ];
+	} Tdr;
+#define	SIZEOF_bar_header	84
+	struct bar_header {
+		char		b_mode[8];
+		char		b_uid[8];
+		char		b_gid[8];
+		char		b_size[12];
+		char		b_mtime[12];
+		char		b_chksum[8];
+		char		b_rdev[8];
+		char		b_linkflag;
+		char		b_bar_magic[2];
+		char		b_volume_num[4];
+		char		b_compressed;
+		char		b_date[12];
+	} Bdr;
+#define	SIZEOF_zip_header	30
+	struct zip_header {
+		char		z_signature[4];
+		char		z_version[2];
+		char		z_gflag[2];
+		char		z_cmethod[2];
+		char		z_modtime[2];
+		char		z_moddate[2];
+		char		z_crc32[4];
+		char		z_csize[4];
+		char		z_nsize[4];
+		char		z_namelen[2];
+		char		z_extralen[2];
+	} Zdr;
+};
+
+#define	BCUT	0177777
+#define	OCUT	0777777
+#define	ECUT	0xFFFFFFFFUL
+
+static const char	trailer[] = "TRAILER!!!";
+
+/*
+ * Structure of per-file extra data for zip format.
+ */
+union zextra {
+	char	data[1];
+#define	SIZEOF_zextra_gn	4
+	struct	zextra_gn {
+		char	ze_gn_tag[2];
+		char	ze_gn_tsize[2];
+	} Ze_gn;
+#define	SIZEOF_zextra_64	32		/* regular size */
+#define	SIZEOF_zextra_64_a	28		/* size without startn field */
+#define	SIZEOF_zextra_64_b	20		/* size without reloff field */
+	struct	zextra_64 {
+		char	ze_64_tag[2];
+		char	ze_64_tsize[2];
+		char	ze_64_nsize[8];
+		char	ze_64_csize[8];
+		char	ze_64_reloff[8];
+		char	ze_64_startn[4];
+	} Ze_64;
+#define	SIZEOF_zextra_pk	16
+	struct	zextra_pk {
+		char	ze_pk_tag[2];
+		char	ze_pk_tsize[2];
+		char	ze_pk_atime[4];
+		char	ze_pk_mtime[4];
+		char	ze_pk_uid[2];
+		char	ze_pk_gid[2];
+	} Ze_pk;
+#define	SIZEOF_zextra_ek	17
+	struct	zextra_et {
+		char	ze_et_tag[2];
+		char	ze_et_tsize[2];
+		char	ze_et_flags[1];
+		char	ze_et_mtime[4];
+		char	ze_et_atime[4];
+		char	ze_et_ctime[4];
+	} Ze_et;
+#define	SIZEOF_zextra_i1	16
+	struct	zextra_i1 {
+	char	ze_i1_tag[2];
+		char	ze_i1_tsize[2];
+		char	ze_i1_atime[4];
+		char	ze_i1_mtime[4];
+		char	ze_i1_uid[2];
+		char	ze_i1_gid[2];
+	} Ze_i1;
+#define	SIZEOF_zextra_i2	8
+	struct	zextra_i2 {
+		char	ze_i2_tag[2];
+		char	ze_i2_tsize[2];
+		char	ze_i2_uid[2];
+		char	ze_i2_gid[2];
+	} Ze_i2;
+#define	SIZEOF_zextra_as	16
+	struct	zextra_as {
+		char	ze_as_tag[2];
+		char	ze_as_tsize[2];
+		char	ze_as_crc[4];
+		char	ze_as_mode[2];
+		char	ze_as_sizdev[4];
+		char	ze_as_uid[2];
+		char	ze_as_gid[2];
+	} Ze_as;
+#define	SIZEOF_zextra_cp	40
+	struct	zextra_cp {
+		char	ze_cp_tag[2];
+		char	ze_cp_tsize[2];
+		char	ze_cp_dev[4];
+		char	ze_cp_ino[4];
+		char	ze_cp_mode[4];
+		char	ze_cp_uid[4];
+		char	ze_cp_gid[4];
+		char	ze_cp_nlink[4];
+		char	ze_cp_rdev[4];
+		char	ze_cp_mtime[4];
+		char	ze_cp_atime[4];
+	} Ze_cp;
+};
+
+static struct	zipstuff {		/* stuff for central directory at EOF */
+	struct zipstuff	*zs_next;
+	char	*zs_name;		/* file name */
+	long long	zs_size;	/* file size */
+	long long	zs_relative;	/* offset of local header */
+	long long	zs_csize;	/* compressed size */
+	uint32_t	zs_crc32;	/* CRC */
+	time_t		zs_mtime;	/* modification time */
+	enum cmethod	zs_cmethod;	/* compression method */
+	int		zs_gflag;	/* general flag */
+	mode_t		zs_mode;	/* file mode */
+} *zipbulk;
+
+/*
+ * Structure of the central zip directory at the end of the file. This
+ * (obligatory) part of a zip file is written by this implementation,
+ * but is completely ignored on copy-in. This means that we miss the
+ * mode_t stored in zc_extralen if zc_versionmade[1] is 3 (Unix). We
+ * have to do this since it contains the S_IFMT bits, thus telling us
+ * whether something is a symbolic link and resulting in different
+ * behavior - but as the input had to be seekable in order to do this,
+ * we had to store entire archives in temporary files if input came
+ * from a pipe to be consistent.
+ */
+#define	SIZEOF_zipcentral	46
+struct	zipcentral {
+	char	zc_signature[4];
+	char	zc_versionmade[2];
+	char	zc_versionextr[2];
+	char	zc_gflag[2];
+	char	zc_cmethod[2];
+	char	zc_modtime[2];
+	char	zc_moddate[2];
+	char	zc_crc32[4];
+	char	zc_csize[4];
+	char	zc_nsize[4];
+	char	zc_namelen[2];
+	char	zc_extralen[2];
+	char	zc_commentlen[2];
+	char	zc_disknstart[2];
+	char	zc_internal[2];
+	char	zc_external[4];
+	char	zc_relative[4];
+};
+
+#define	SIZEOF_zip64end		56
+struct	zip64end {
+	char	z6_signature[4];
+	char	z6_recsize[8];
+	char	z6_versionmade[2];
+	char	z6_versionextr[2];
+	char	z6_thisdiskn[4];
+	char	z6_alldiskn[4];
+	char	z6_thisentries[8];
+	char	z6_allentries[8];
+	char	z6_dirsize[8];
+	char	z6_startsize[8];
+};
+
+#define	SIZEOF_zip64loc		20
+struct	zip64loc {
+	char	z4_signature[4];
+	char	z4_startno[4];
+	char	z4_reloff[8];
+	char	z4_alldiskn[4];
+};
+
+#define	SIZEOF_zipend		22
+struct	zipend {
+	char	ze_signature[4];
+	char	ze_thisdiskn[2];
+	char	ze_alldiskn[2];
+	char	ze_thisentries[2];
+	char	ze_allentries[2];
+	char	ze_dirsize[4];
+	char	ze_startsize[4];
+	char	ze_commentlen[2];
+};
+
+#define	SIZEOF_zipddesc		16
+struct	zipddesc {
+	char	zd_signature[4];
+	char	zd_crc32[4];
+	char	zd_csize[4];
+	char	zd_nsize[4];
+};
+
+#define	SIZEOF_zipddesc64	24
+struct	zipddesc64 {
+	char	zd_signature[4];
+	char	zd_crc32[4];
+	char	zd_csize[8];
+	char	zd_nsize[8];
+};
+
+/*
+ * Magic numbers and strings.
+ */
+static const uint16_t	mag_bin = 070707;
+/*static const uint16_t	mag_bbs = 0143561;*/
+static const char	mag_asc[6] = "070701";
+static const char	mag_crc[6] = "070702";
+static const char	mag_odc[6] = "070707";
+static const long	mag_sco = 0x7ffffe00;
+
+static const char	mag_ustar[6] = "ustar\0";
+static const char	mag_gnutar[8] = "ustar  \0";
+static const char	mag_bar[2] = "V\0";
+
+static const char	mag_zipctr[4] = "PK\1\2";
+static const char	mag_zipsig[4] = "PK\3\4";
+static const char	mag_zipend[4] = "PK\5\6";
+static const char	mag_zip64e[4] = "PK\6\6";
+static const char	mag_zip64l[4] = "PK\6\7";
+static const char	mag_zipdds[4] = "PK\7\10";
+#define			mag_zip64f	0x0001
+#define			mag_zipcpio	0x0707
+
+/*
+ * Fields for the extended pax header.
+ */
+static enum paxrec {
+	PR_NONE		= 0000,
+	PR_ATIME	= 0001,
+	PR_GID		= 0002,
+	PR_LINKPATH	= 0004,
+	PR_MTIME	= 0010,
+	PR_PATH		= 0020,
+	PR_SIZE		= 0040,
+	PR_UID		= 0100,
+	PR_SUN_DEVMAJOR	= 0200,
+	PR_SUN_DEVMINOR	= 0400
+} paxrec, globrec;
+
+/*
+ * Prototype structure, collecting user-defined information
+ * about a file.
+ */
+struct prototype {
+	mode_t	pt_mode;	/* type and permission bits */
+	uid_t	pt_uid;		/* owner */
+	gid_t	pt_gid;		/* group owner */
+	time_t	pt_atime;	/* time of last access */
+	time_t	pt_mtime;	/* time of last modification */
+	dev_t	pt_rdev;	/* device major/minor */
+	enum {
+		PT_NONE	 = 0000,
+		PT_TYPE	 = 0001,
+		PT_OWNER = 0002,
+		PT_GROUP = 0004,
+		PT_MODE  = 0010,
+		PT_ATIME = 0020,
+		PT_MTIME = 0040,
+		PT_RDEV  = 0100
+	}	pt_spec;	/* specified information */
+};
+
+static struct stat	globst;
+
+/*
+ * This sets a sanity check limit on path names. If a longer path name
+ * occurs in an archive, it is treated as corrupt. This is because no
+ * known Unix system can handle path names of arbitrary length; limits
+ * are typically between 1024 and 4096. Trying to extract longer path
+ * names would fail anyway and will cpio eventually fail to allocate
+ * memory.
+ */
+#define			SANELIMIT	0177777
+
+char			*progname;	/* argv[0] to main() */
+static struct dslot	*devices;	/* devices table */
+static struct dslot	*markeddevs;	/* unusable device numbers */
+static char		*blkbuf;	/* block buffer */
+int			blksiz;		/* block buffer size */
+static int		blktop;		/* top of filled part of buffer */
+static int		curpos;		/* position in blkbuf */
+static uint32_t		fakedev;	/* fake device for single link inodes */
+static uint32_t		fakeino;	/* fake inode for single link inodes */
+static uint32_t		harddev;	/* fake device used for hard links */
+static unsigned long long	maxsize;/* maximum size for format */
+static unsigned long long	maxrdev;/* maximum st_rdev for format */
+static unsigned long long	maxmajor;/* maximum major(st_rdev) for format */
+static unsigned long long	maxminor;/* maximum minor(st_rdev) for format */
+static unsigned long long	maxuid;	/* maximum user id for format */
+static unsigned long long	maxgid;	/* maximum group id for format */
+static unsigned long long	maxnlink;/* maximum link count for format */
+static int		mt;		/* magtape file descriptor */
+static int		mfl;		/* magtape flags */
+static struct stat	mtst;		/* fstat() on mt */
+int			aflag;		/* reset access times */
+int			Aflag;		/* append to archive */
+int			bflag;		/* swap bytes */
+int			Bflag;		/* 5120 blocking */
+int			cflag;		/* ascii format */
+int			Cflag;		/* user-defined blocking */
+int			dflag;		/* create directories */
+int			Dflag;		/* do not ask for next device */
+int			eflag;		/* DEC format */
+int			cray_eflag;	/* do not archive if values too large */
+const char		*Eflag;		/* filename for files to be extracted */
+int			fflag;		/* pattern excludes */
+int			Hflag;		/* header format */
+const char		*Iflag;		/* input archive name */
+int			kflag;		/* skipt corrupted parts */
+int			Kflag;		/* IRIX-style large file support */
+int			lflag;		/* link of possible */
+int			Lflag;		/* follow symbolic links */
+int			mflag;		/* retain modification times */
+const char		*Mflag;		/* message when switching media */
+const char		*Oflag;		/* output archive name */
+int			Pflag;		/* prototype file list */
+int			rflag;		/* rename files */
+const char		*Rflag;		/* reassign ownerships */
+static uid_t		Ruid;		/* uid to assign */
+static gid_t		Rgid;		/* gid to assign */
+int			sflag;		/* swap half word bytes */
+int			Sflag;		/* swap word bytes */
+int			tflag;		/* print toc */
+int			uflag;		/* overwrite files unconditionally */
+int			hp_Uflag;	/* use umask when creating files */
+int			vflag;		/* verbose */
+int			Vflag;		/* special verbose */
+int			sixflag;	/* 6th Edition archives */
+int			action;		/* -i -o -p */
+long long		errcnt;		/* error status */
+static unsigned long long	maxpath;/* maximum path length with -i */
+static uint32_t		maxino;		/* maximum inode number with -i */
+static uid_t		myuid;		/* user id of caller */
+static gid_t		mygid;		/* group id of caller */
+static long long	blocks;		/* copying statistics: full blocks */
+static long long	bytes;		/* copying statistics: partial blocks */
+static long long	nwritten;	/* bytes written to archive */
+static off_t		aoffs;		/* offset in archive */
+static off_t		poffs;		/* physical offset in archive */
+static int		tapeblock = -1;	/* physical tape block size */
+struct glist		*patterns;	/* patterns for -i */
+static int		tty;		/* terminal file descriptor */
+static const char	*cur_ofile;	/* current original file */
+static const char	*cur_tfile;	/* current temporary file */
+static mode_t		umsk;		/* user's umask */
+static int		zipclevel;	/* zip compression level */
+static struct islot	*inull;		/* splay tree null element */
+int			printsev;	/* print message severity strings */
+static int		compressed_bar;	/* this is a compressed bar archive */
+static int		formatforced;	/* -k -i -Hfmt forces a format */
+static long long	lineno;		/* input line number */
+
+int			pax_dflag;	/* directory matches only itself */
+int			pax_kflag;	/* do not overwrite files */
+int			pax_nflag;	/* select first archive member only */
+int			pax_sflag;	/* substitute file names */
+int			pax_uflag;	/* add only recent files to archive */
+int			pax_Xflag;	/* do not cross device boundaries */
+static enum {
+	PO_NONE		= 0,
+	PO_LINKDATA	= 01,		/* include link data in type 2 */
+	PO_TIMES	= 02,		/* create atime and mtime fields */
+} pax_oflag;				/* recognized -o options */
+
+static void	copyout(int (*)(const char *, struct stat *));
+static size_t	ofiles_cpio(char **, size_t *);
+static void	dooutp(void);
+static int	outfile(const char *, struct stat *);
+static int	addfile(const char *, struct stat *, uint32_t, uint32_t, int,
+			const char *);
+static void	iflush(struct islot *, uint32_t);
+static void	lflush(void);
+static int	bigendian(void);
+static void	getbuf(char **, size_t *, size_t);
+static void	prdot(int);
+static void	newmedia(int);
+static void	mclose(void);
+static ssize_t	mwrite(int);
+static void	bwrite(const char *, size_t);
+static void	bflush(void);
+static int	sum(int, const char *, struct stat *, char *);
+static int	rstime(const char *, struct stat *, const char *);
+static struct islot	*isplay(ino_t, struct islot *);
+static struct islot	*ifind(ino_t, struct islot **);
+static void	iput(struct islot *, struct islot **);
+static struct dslot	*dfind(struct dslot **, dev_t);
+static void	done(int);
+static void	dopass(const char *);
+static int	passdata(struct file *, const char *, int);
+static int	passfile(const char *, struct stat *);
+static int	filein(struct file *, int (*)(struct file *, const char *, int),
+			char *);
+static int	linkunlink(const char *, const char *);
+static void	tunlink(char **);
+static int	filet(struct file *, int (*)(struct file *, const char *, int));
+static void	filev(struct file *);
+static int	typec(struct stat *);
+static void	permbits(mode_t);
+static void	prtime_cpio(time_t);
+static void	getpath(const char *, char **, char **, size_t *, size_t *);
+static void	setpath(const char *, char **, char **,
+			size_t, size_t *, size_t *);
+static int	imdir(char *);
+static int	setattr(const char *, struct stat *);
+static int	setowner(const char *, struct stat *);
+static int	canlink(const char *, struct stat *, int);
+static void	doinp(void);
+static void	storelink(struct file *);
+static void	flushlinks(struct file *);
+static void	flushnode(struct islot *, struct file *);
+static void	flushrest(int);
+static void	flushtree(struct islot *, int);
+static int	inpone(struct file *, int);
+static int	readhdr(struct file *, union bincpio *);
+static void	whathdr(void);
+static int	infile(struct file *);
+static int	skipfile(struct file *);
+static int	skipdata(struct file *f,
+			int (*)(struct file *, const char *, int));
+static int	indata(struct file *, const char *, int);
+static int	totrailer(void);
+static long long	rdoct(const char *, int);
+static long long	rdhex(const char *, int);
+static ssize_t	mread(void);
+static void	mstat(void);
+static int	skippad(unsigned long long, int);
+static int	allzero(const char *, int);
+static const char	*getuser(uid_t);
+static const char	*getgroup(gid_t);
+static struct glist	*want(struct file *, struct glist **);
+static void	patfile(void);
+static int	ckodd(long long, int, const char *, const char *);
+static int	rname(char **, size_t *);
+static int	redirect(const char *, const char *);
+static char	*tnameof(struct tar_header *, char *);
+static int	tmkname(struct tar_header *, const char *);
+static void	tlinkof(struct tar_header *, struct file *);
+static int	tmklink(struct tar_header *, const char *);
+static int	tlflag(struct stat *);
+static void	tchksum(union bincpio *);
+static int	tcssum(union bincpio *, int);
+static int	trdsum(union bincpio *);
+static mode_t	tifmt(int);
+static void	bchksum(union bincpio *);
+static int	bcssum(union bincpio *);
+static void	blinkof(const char *, struct file *, int);
+static void	dump_barhdr(void);
+static int	zcreat(const char *, mode_t);
+static int	zclose(int);
+static void	markdev(dev_t);
+static int	marked(dev_t);
+static void	cantsup(int, const char *);
+static void	onint(int);
+static int	zipread(struct file *, const char *, int, int);
+static void	zipreaddesc(struct file *);
+static int	cantunzip(struct file *, const char *);
+static time_t	gdostime(const char *, const char *);
+static void	mkdostime(time_t, char *, char *);
+static ssize_t	ziprxtra(struct file *, struct zip_header *);
+static void	ziptrailer(void);
+static void	zipdefer(const char *, struct stat *, long long,
+			uint32_t, long long, const struct zip_header *);
+static int	zipwrite(int, const char *, struct stat *,
+			union bincpio *, size_t, uint32_t, uint32_t,
+			uint32_t *, long long *);
+static int	zipwtemp(int, const char *, struct stat *,
+			union bincpio *, size_t, uint32_t, uint32_t,
+			uint32_t *, long long *);
+#if USE_ZLIB
+static int	zipwdesc(int, const char *, struct stat *,
+			union bincpio *, size_t, uint32_t, uint32_t,
+			uint32_t *, long long *);
+#endif	/* USE_ZLIB */
+static int	zipwxtra(const char *, struct stat *, uint32_t, uint32_t);
+static void	zipinfo(struct file *);
+static void	readK2hdr(struct file *);
+static int	readgnuname(char **, size_t *, long);
+static void	writegnuname(const char *, long, int);
+static void	tgetpax(struct tar_header *, struct file *);
+static enum paxrec	tgetrec(char **, char **, char **);
+static void	wrpax(const char *, const char *, struct stat *);
+static void	addrec(char **, long *, long *,
+			const char *, const char *, long long);
+static void	paxnam(struct tar_header *, const char *);
+static char	*sequence(void);
+static char	*joinpath(const char *, char *);
+static int	utf8(const char *);
+static char	*getproto(char *, struct prototype *);
+
+size_t		(*ofiles)(char **, size_t *) = ofiles_cpio;
+void		(*prtime)(time_t) = prtime_cpio;
+
+int
+main(int argc, char **argv)
+{
+	myuid = getuid();
+	mygid = getgid();
+	umask(umsk = umask(0));
+	progname = basename(argv[0]);
+	setlocale(LC_CTYPE, "");
+	setlocale(LC_TIME, "");
+	inull = scalloc(1, sizeof *inull);
+	inull->i_lln = inull->i_rln = inull;
+	flags(argc, argv);
+	switch (action) {
+	case 'i':
+		if (sigset(SIGINT, SIG_IGN) != SIG_IGN)
+			sigset(SIGINT, onint);
+		doinp();
+		break;
+	case 'o':
+		dooutp();
+		break;
+	case 'p':
+		if (sigset(SIGINT, SIG_IGN) != SIG_IGN)
+			sigset(SIGINT, onint);
+		dopass(argv[optind]);
+		break;
+	}
+	if (tflag)
+		fflush(stdout);
+	else if (Vflag)
+		prdot(1);
+	if (pax != PAX_TYPE_CPIO)
+		pax_onexit();
+	fprintf(stderr, "%llu blocks\n", blocks + ((bytes + 0777) >> 9));
+	mclose();
+	if (errcnt && sysv3 == 0)
+		fprintf(stderr, "%llu error(s)\n", errcnt);
+	return errcnt ? sysv3 ? 1 : 2 : 0;
+}
+
+static size_t
+ofiles_cpio(char **name, size_t *namsiz)
+{
+	static struct iblok	*ip;
+
+	if (ip == NULL)
+		ip = ib_alloc(0, 0);
+	return ib_getlin(ip, name, namsiz, srealloc);
+}
+
+/*
+ * Read the file name list for -o and -p and do initial processing
+ * for each name.
+ */
+static void
+copyout(int (*copyfn)(const char *, struct stat *))
+{
+	char	*name = NULL, *np;
+	size_t	namsiz = 0, namlen;
+	struct stat	st;
+	struct prototype	pt;
+
+	while ((namlen = ofiles(&name, &namsiz)) != 0) {
+		lineno++;
+		if (name[namlen-1] == '\n')
+			name[--namlen] = '\0';
+		if (Pflag)
+			np = getproto(name, &pt);
+		else
+			np = name;
+		while (np[0] == '.' && np[1] == '/') {
+			np += 2;
+			while (*np == '/')
+				np++;
+			if (*np == '\0') {
+				np = name;
+				break;
+			}
+		}
+		if (lstat(np, &st) < 0) {
+			if (Pflag && *np && ((pt.pt_spec &
+			    (PT_TYPE|PT_OWNER|PT_GROUP|PT_MODE|PT_RDEV) &&
+					((pt.pt_mode&S_IFMT) == S_IFBLK ||
+					 (pt.pt_mode&S_IFMT) == S_IFCHR)) ||
+				      (pt.pt_spec &
+		            (PT_TYPE|PT_OWNER|PT_GROUP|PT_MODE) &&
+			    		((pt.pt_mode&S_IFMT) == S_IFDIR ||
+					 (pt.pt_mode&S_IFMT) == S_IFIFO ||
+					 (pt.pt_mode&S_IFMT) == S_IFREG)))) {
+				memset(&st, 0, sizeof st);
+				st.st_mode = pt.pt_mode;
+				st.st_blksize = 4096;
+				st.st_nlink = 1;
+				goto missingok;
+			}
+			else if (sysv3 < 0)
+				msg(2, 0, "< %s > ?\n", np);
+			else if (sysv3 > 0)
+				msg(2, 0, "Cannot obtain information "
+						"about file:  \"%s\".\n",
+						np);
+			else
+				emsg(2, "Error with lstat of \"%s\"", np);
+			errcnt++;
+			continue;
+		}
+	missingok:
+		if (Lflag && (st.st_mode&S_IFMT) == S_IFLNK) {
+			if (stat(np, &st) < 0) {
+				emsg(2, "Cannot follow \"%s\"", np);
+				errcnt++;
+				continue;
+			}
+		}
+		/*
+		 * These file types are essentially useless in an archive
+		 * since they are recreated by any process that needs them.
+		 * We thus ignore them and do not even issue a warning,
+		 * because that would only displace more important messages
+		 * on a terminal and confuse people who just want to copy
+		 * directory hierarchies.--But for pax, POSIX.1-2001 requires
+		 * us to fail!
+		 */
+		if ((st.st_mode&S_IFMT) == S_IFSOCK ||
+				(st.st_mode&S_IFMT) == S_IFDOOR) {
+			if (pax >= PAX_TYPE_PAX2001) {
+				msg(2, 0, "Cannot handle %s \"%s\".\n",
+					(st.st_mode&S_IFMT) == S_IFSOCK ?
+						"socket" : "door", np);
+				errcnt++;
+			}
+			continue;
+		}
+		if (Pflag) {
+			if (pt.pt_spec & PT_TYPE)
+				if ((st.st_mode&S_IFMT) != (pt.pt_mode&S_IFMT))
+					msg(4, 0, "line %lld: types "
+						"do not match\n", lineno);
+			if (pt.pt_spec & PT_OWNER)
+				st.st_uid = pt.pt_uid;
+			if (pt.pt_spec & PT_GROUP)
+				st.st_gid = pt.pt_gid;
+			if (pt.pt_spec & PT_MODE) {
+				st.st_mode &= ~(mode_t)07777;
+				st.st_mode |= pt.pt_mode;
+			}
+			if (pt.pt_spec & PT_ATIME)
+				st.st_atime = pt.pt_atime;
+			if (pt.pt_spec & PT_MTIME)
+				st.st_mtime = pt.pt_mtime;
+			if (pt.pt_spec & PT_RDEV) {
+				if ((st.st_mode&S_IFMT) != S_IFBLK &&
+				    (st.st_mode&S_IFMT) != S_IFCHR)
+					msg(4, 0, "line %lld: device type "
+						"specified for non-device "
+						"file\n", lineno);
+				st.st_rdev = pt.pt_rdev;
+			}
+		}
+		if (pax_track(np, st.st_mtime) == 0)
+			continue;
+		if ((fmttype == FMT_ZIP ||
+					fmttype & TYP_BAR ||
+					fmttype == FMT_GNUTAR)
+				&& (st.st_mode&S_IFMT) == S_IFDIR &&
+				name[namlen-1] != '/') {
+			if (namlen+2 >= namsiz) {
+				size_t	diff = np - name;
+				name = srealloc(name, namsiz = namlen+2);
+				np = &name[diff];
+			}
+			name[namlen++] = '/';
+			name[namlen] = '\0';
+		}
+		errcnt += copyfn(np, &st);
+	}
+}
+
+/*
+ * Execution for -o.
+ */
+static void
+dooutp(void)
+{
+	if (Oflag) {
+		if ((mt = Aflag ? open(Oflag, O_RDWR, 0666) :
+					creat(Oflag, 0666)) < 0) {
+			if (sysv3) {
+				emsg(013, "Cannot open <%s> for %s.", Oflag,
+					Aflag ? "append" : "output");
+				done(1);
+			} else
+				msg(3, -2, "Cannot open \"%s\" for %s\n", Oflag,
+					Aflag ? "append" : "output");
+		}
+	} else
+		mt = dup(1);
+	mstat();
+	blkbuf = svalloc(blksiz, 1);
+	if (Aflag) {
+		if (totrailer() != 0)
+			return;
+	} else if (fmttype == FMT_NONE)
+		fmttype = bigendian() ? FMT_BINBE : FMT_BINLE;
+	if (fmttype & TYP_BINARY) {
+		maxino = 0177777;
+		fakeino = 0177777;
+		maxpath = 256;
+		if (fmttype & TYP_SGI) {
+			maxsize = 0x7FFFFFFFFFFFFFFFLL;
+			maxmajor = 037777;
+			maxminor = 0777777;
+		} else {
+			maxsize = 0x7FFFFFFFLL;
+			maxrdev = 0177777;
+		}
+		maxuid = 0177777;
+		maxgid = 0177777;
+		maxnlink = 0177777;
+	} else if (fmttype == FMT_ODC) {
+		maxino = 0777777;
+		fakeino = 0777777;
+		maxpath = 256;
+		maxsize = 077777777777LL;
+		maxrdev = 0777777;
+		maxuid = 0777777;
+		maxgid = 0777777;
+		maxnlink = 0777777;
+	} else if (fmttype == FMT_DEC) {
+		maxino = 0777777;
+		fakeino = 0777777;
+		maxpath = 256;
+		maxsize = 077777777777LL;
+		maxmajor = 077777777;
+		maxminor = 077777777;
+		maxuid = 0777777;
+		maxgid = 0777777;
+		maxnlink = 0777777;
+	} else if (fmttype & TYP_NCPIO) {
+		maxino = 0xFFFFFFFFUL;
+		fakeino = 0xFFFFFFFFUL;
+		maxpath = 1024;
+		maxsize = fmttype&TYP_SCO ? 0x7FFFFFFFFFFFFFFFLL : 0xFFFFFFFFUL;
+		maxmajor = 0xFFFFFFFFUL;
+		maxminor = 0xFFFFFFFFUL;
+		maxuid = 0xFFFFFFFFUL;
+		maxgid = 0xFFFFFFFFUL;
+		maxnlink = 0xFFFFFFFFUL;
+	} else if (fmttype & TYP_CRAY) {
+		maxino = 0xFFFFFFFFUL;
+		fakeino = 0xFFFFFFFFUL;
+		maxpath = SANELIMIT;
+		maxsize = 0x7FFFFFFFFFFFFFFFLL;
+		maxrdev = 0x7FFFFFFFFFFFFFFFLL;
+		maxuid = 0x7FFFFFFFFFFFFFFFLL;
+		maxgid = 0x7FFFFFFFFFFFFFFFLL;
+		maxnlink = 0x7FFFFFFFFFFFFFFFLL;
+	} else if (fmttype == FMT_GNUTAR) {
+		maxino = 0xFFFFFFFFUL;
+		fakeino = 0xFFFFFFFFUL;
+		maxpath = SANELIMIT;
+		maxsize = 0x7FFFFFFFFFFFFFFFLL;
+		maxmajor = 0x7FFFFFFFFFFFFFFFLL;
+		maxminor = 0x7FFFFFFFFFFFFFFFLL;
+		maxuid = 0x7FFFFFFFFFFFFFFFLL;
+		maxgid = 0x7FFFFFFFFFFFFFFFLL;
+		maxnlink = 0x7FFFFFFFFFFFFFFFLL;
+	} else if (fmttype & TYP_PAX) {
+		maxino = 0xFFFFFFFFUL;
+		fakeino = 0xFFFFFFFFUL;
+		maxpath = SANELIMIT;
+		maxsize = 0x7FFFFFFFFFFFFFFFLL;
+		maxmajor = fmttype==FMT_SUN ? 0x7FFFFFFFFFFFFFFFLL : 07777777;
+		maxminor = fmttype==FMT_SUN ? 0x7FFFFFFFFFFFFFFFLL : 07777777;
+		maxuid = 0x7FFFFFFFFFFFFFFFLL;
+		maxgid = 0x7FFFFFFFFFFFFFFFLL;
+		maxnlink = 0x7FFFFFFFFFFFFFFFLL;
+		if (pax_oflag & PO_TIMES)
+			globrec |= PR_ATIME|PR_MTIME;
+	} else if (fmttype & TYP_BAR) {
+		maxino = 0xFFFFFFFFUL;
+		fakeino = 0xFFFFFFFFUL;
+		maxpath = 512 - SIZEOF_bar_header - 1;
+		maxsize = 077777777777LL;
+		maxrdev = 07777777;
+		maxuid = 07777777;
+		maxgid = 07777777;
+		maxnlink = 0x7FFFFFFFFFFFFFFFLL;
+		if (nwritten == 0)
+			dump_barhdr();
+	} else if (fmttype & TYP_USTAR) {
+		maxino = 0xFFFFFFFFUL;
+		fakeino = 0xFFFFFFFFUL;
+		maxpath = 256;
+		maxsize = 077777777777LL;
+		maxmajor = 07777777;
+		maxminor = 07777777;
+		maxuid = 07777777;
+		maxgid = 07777777;
+		maxnlink = 0x7FFFFFFFFFFFFFFFLL;
+	} else if (fmttype & TYP_OTAR) {
+		maxino = 0xFFFFFFFFUL;
+		fakeino = 0xFFFFFFFFUL;
+		maxpath = 99;
+		maxsize = 077777777777LL;
+		maxuid = 07777777;
+		maxgid = 07777777;
+		maxnlink = 0x7FFFFFFFFFFFFFFFLL;
+	} else if (fmttype == FMT_ZIP) {
+		maxino = 0xFFFFFFFFUL;
+		fakeino = 0xFFFFFFFFUL;
+		maxpath = 60000;
+		maxsize = 0x7FFFFFFFFFFFFFFFLL;
+		maxrdev = 0xFFFFFFFFUL;
+		maxuid = 0xFFFFFFFFUL;
+		maxgid = 0xFFFFFFFFUL;
+		maxnlink = 0xFFFFFFFFUL;
+	} else
+		abort();
+	fakedev = 0177777;
+	harddev = 1;
+	copyout(outfile);
+	if (fmttype & TYP_NCPIO)
+		lflush();
+	if (fmttype & TYP_CPIO) {
+		struct stat	st;
+
+		memset(&st, 0, sizeof st);
+		st.st_nlink = 1;
+		outfile(trailer, &st);
+	}
+	if (fmttype & TYP_TAR) {
+		char b[512];
+
+		memset(b, 0, sizeof b);
+		bwrite(b, sizeof b);
+		bwrite(b, sizeof b);
+	}
+	if (fmttype == FMT_ZIP)
+		ziptrailer();
+	bflush();
+}
+
+/*
+ * Handle a single file for -o, do sanity checks and detect hard links.
+ */
+static int
+outfile(const char *file, struct stat *st)
+{
+	uint32_t dev, ino;
+	size_t pathsz;
+
+	if ((st->st_mode&S_IFMT) == S_IFREG)
+		if (mtst.st_dev == st->st_dev && mtst.st_ino == st->st_ino)
+			return 0;
+	if (st->st_size > maxsize) {
+		msg(2, 0, "Size of %c%s%c >%lluGB. Not dumped\n",
+				sysv3 ? '<' : '"',
+				file,
+				sysv3 ? '>' : '"',
+				(maxsize+1) / (1024*1024*1024));
+		return 1;
+	}
+	if (((st->st_mode&S_IFMT)==S_IFBLK||(st->st_mode&S_IFMT)==S_IFCHR) &&
+		(maxrdev &&
+			(unsigned long long)st->st_rdev > maxrdev ||
+		maxmajor &&
+			(unsigned long long)major(st->st_rdev) > maxmajor ||
+		maxminor &&
+			(unsigned long long)minor(st->st_rdev) > maxminor)) {
+		cantsup(1, file);
+		return 1;
+	}
+	if ((unsigned long long)st->st_uid > maxuid) {
+		if (cray_eflag) {
+			cantsup(1, file);
+			return 1;
+		}
+		cantsup(0, file);
+		st->st_uid = 60001;
+		if ((st->st_mode&S_IFMT) == S_IFREG && st->st_mode & 0111)
+			st->st_mode &= ~(mode_t)S_ISUID;
+		if ((unsigned long long)st->st_gid > maxgid) {
+			st->st_gid = 60001;
+			if ((st->st_mode&S_IFMT)==S_IFREG && st->st_mode&0010)
+				st->st_mode &= ~(mode_t)S_ISGID;
+		}
+	} else if ((unsigned long long)st->st_gid > maxgid) {
+		if (cray_eflag) {
+			cantsup(1, file);
+			return 1;
+		}
+		cantsup(0, file);
+		st->st_gid = 60001;
+		if ((st->st_mode&S_IFMT) == S_IFREG && st->st_mode & 0010)
+			st->st_mode &= ~(mode_t)S_ISGID;
+	}
+	if ((pathsz = strlen(file)) > maxpath) {
+		msg(2, 0, "%s: file name too long\n", file);
+		return 1;
+	}
+	/*
+	 * Detect hard links and compute fake inode counts. The mechanism
+	 * is as follows: If a file has more than one link, a fake device
+	 * number starting at one is used for its device, and a fake inode
+	 * number is used starting at one too.
+	 *
+	 * The information on links of directories is useless, so it is
+	 * dropped and handled like a file with a single link only: Fake
+	 * devices are allocated just below the format's limit, fake
+	 * i-nodes the same.
+	 *
+	 * This way even the binary cpio format can have up to ~4G files.
+	 */
+	if (maxino && st->st_nlink > 1 && (st->st_mode&S_IFMT) != S_IFDIR) {
+		struct dslot *ds, *dp;
+		struct islot *ip;
+
+		dev = 1;
+		ds = devices;
+		dp = NULL;
+nextdev:
+		for (; ds; dp = ds, ds = ds->d_nxt, dev++ /* see below! */)
+			if (ds->d_dev == st->st_dev)
+				break;
+		if (markeddevs && marked(dev)) {
+			dev++;
+			goto nextdev;
+		}
+		if (dev >= fakedev)
+			msg(4, 1, "Too many devices in archive, exiting\n");
+		if (ds == NULL) {
+			ds = scalloc(1, sizeof *ds);
+			ds->d_dev = st->st_dev;
+			ds->d_fake = dev;
+			if (devices == NULL)
+				devices = ds;
+			else
+				dp->d_nxt = ds;
+		}
+		harddev = dev;
+		if ((ip = ifind(st->st_ino, &ds->d_isl)) == NULL) {
+			if (ds->d_cnt >= maxino) {
+				/* corresponds to for loop above */
+				dev++, dp = ds, ds = ds->d_nxt;
+				goto nextdev;
+			}
+			ip = scalloc(1, sizeof *ip);
+			ip->i_ino = st->st_ino;
+			ip->i_fino = ++ds->d_cnt;
+			ip->i_nlk = st->st_nlink;
+			if (fmttype & TYP_TAR)
+				ip->i_name = sstrdup(file);
+			if (fmttype & TYP_NCPIO) {
+				ip->i_st = smalloc(sizeof *ip->i_st);
+				*ip->i_st = *st;
+			}
+			iput(ip, &ds->d_isl);
+		}
+		ino = ip->i_fino;
+		if (fmttype & TYP_NCPIO) {
+			/*
+			 * In SVR4 ascii cpio format, files with multiple
+			 * links are stored with a zero size except for the
+			 * last link, which contains the actual file content.
+			 * As one cannot know which is the last link in
+			 * advance since some links may be outside the
+			 * archive content, all links have to be collected
+			 * and written out at once.
+			 */
+			struct ilink *il, *ik;
+
+			switch (ip->i_nlk) {
+			case 1:
+				/*
+				 * This was the last link to a file. Write
+				 * all previous links and break to write
+				 * the actual file content. Free the pointers
+				 * in islot; islot remains within the tree
+				 * with a remaining link count of zero.
+				 */
+				ip->i_nlk--;
+				free(ip->i_st);
+				ip->i_st = NULL;
+				for (il = ip->i_lnk, ik = NULL; il;
+						ik = il, il = il->l_nxt,
+						ik ? free(ik), 0 : 0) {
+					errcnt += addfile(il->l_nam, st,
+							dev, ino, 1, 0);
+					free(il->l_nam);
+				}
+				break;
+			case 0:
+				/*
+				 * This file got a link during operation, or
+				 * -L was specified and we encountered a link
+				 * more than once. Start with a fresh link
+				 * count again.
+				 */
+				ip->i_nlk = st->st_nlink;
+				ip->i_lnk = NULL;
+				ip->i_st = smalloc(sizeof *ip->i_st);
+				*ip->i_st = *st;
+				/*FALLTHRU*/
+			default:
+				/*
+				 * There are more links to this file. Store
+				 * only the name and return.
+				 */
+				ip->i_nlk--;
+				if (ip->i_lnk) {
+					for (il = ip->i_lnk; il->l_nxt;
+							il = il->l_nxt);
+					il->l_nxt = scalloc(1,sizeof*il->l_nxt);
+					il = il->l_nxt;
+				} else {
+					ip->i_lnk = scalloc(1,sizeof*ip->i_lnk);
+					il = ip->i_lnk;
+				}
+				il->l_nam = smalloc(pathsz + 1);
+				strcpy(il->l_nam, file);
+				return 0;
+			}
+		} else if (fmttype & TYP_TAR) {
+			if (strcmp(ip->i_name, file))
+				return addfile(file, st, dev, ino, 1,
+						ip->i_name);
+		}
+	} else {	/* single-linked or directory */
+		dev = fakedev;
+		while (markeddevs && marked(dev))
+			dev--;
+		if ((ino = fakeino--) == 0) {
+			if (--dev <= harddev)
+				msg(4, 1, "Too many devices in archive, "
+						"exiting\n");
+			fakedev = dev;
+			ino = maxino;
+			fakeino = ino - 1;
+		}
+	}
+	return addfile(file, st, dev, ino, 0, 0);
+}
+
+/*
+ * Add a single file to the archive with -o.
+ */
+static int
+addfile(const char *realfile, struct stat *st,
+		uint32_t dev, uint32_t ino, int zerolink, const char *linkname)
+{
+	union bincpio bc;
+	int fd = -1;
+	long long size;
+	int pad, i;
+	ssize_t rsz = 0, wsz = 0, hsz, fsz, psz;
+	long long remsz, relative, nlink;
+	long long Kbase = 0, Krest = 0, Ksize = 0;
+	struct hdr_cpio	K2hdr;
+	uint32_t	crc = 0;
+	long long	csize = 0;
+	char	*file;
+	char	*symblink = NULL;
+	int	failure = 1;
+
+	file = sstrdup(realfile);
+	if (pax != PAX_TYPE_CPIO && strcmp(file, trailer)) {
+		size_t	junk = 0;
+		if (pax_sflag && pax_sname(&file, &junk) == 0)
+			goto cleanup;
+		if (rflag && rname(&file, &junk) == 0)
+			goto cleanup;
+	}
+	fsz = strlen(file);
+	relative = nwritten;
+	memset(bc.data, 0, sizeof bc.data);
+	if (fmttype == FMT_PAX && pax_oflag & PO_LINKDATA &&
+			(st->st_mode&S_IFMT) == S_IFREG)
+		size = st->st_size;
+	else if (zerolink)
+		size = 0;
+	else if ((st->st_mode&S_IFMT) == S_IFREG)
+		size = st->st_size;
+	else if ((st->st_mode&S_IFMT) == S_IFLNK) {
+		i = st->st_size ? st->st_size : PATH_MAX;
+		symblink = smalloc(i+1);
+		if ((size = readlink(realfile, symblink, i)) < 0) {
+			emsg(3, "Cannot read symbolic link \"%s\"", realfile);
+			goto cleanup;
+		}
+		symblink[size] = '\0';
+	} else
+		size = 0;
+	nlink = ((unsigned long long)st->st_nlink>maxnlink ?
+			maxnlink : st->st_nlink);
+	if (fmttype & TYP_NCPIO) {
+		long	size1;
+		if (fmttype & TYP_SCO && size >= mag_sco) {
+			char	*ofile = file;
+			size1 = mag_sco;
+			fsz += 22;
+			file = smalloc(fsz + 1);
+			snprintf(file, fsz + 1, "%s%csize=%016llx",
+					ofile, 0, size);
+			free(ofile);
+		} else
+			size1 = size;
+		pad = 4;
+		sprintf(bc.data, "%*.*s%08lx%08lx%08lx%08lx%08lx%08lx"
+				"%08lx%08lx%08lx%08lx%08lx%08lx%08lx",
+			(int)(fmttype&TYP_CRC? sizeof mag_crc:sizeof mag_asc),
+			(int)(fmttype&TYP_CRC? sizeof mag_crc:sizeof mag_asc),
+			fmttype & TYP_CRC ? mag_crc : mag_asc,
+			(long)ino & ECUT,
+			(long)st->st_mode & ECUT,
+			(long)st->st_uid & ECUT,
+			(long)st->st_gid & ECUT,
+			(long)nlink & ECUT,
+			(long)st->st_mtime & ECUT,
+			(long)size1 & ECUT,
+			(long)major(dev) & ECUT,
+			(long)minor(dev) & ECUT,
+			(long)major(st->st_rdev) & ECUT,
+			(long)minor(st->st_rdev) & ECUT,
+			(long)++fsz,
+			0L);
+		hsz = SIZEOF_Exp_cpio_hdr;
+		if ((psz = (hsz + fsz) % pad) != 0)
+			psz = pad - psz;
+	} else if (fmttype == FMT_ODC) {
+		pad = 1;
+		sprintf(bc.data, "%*.*s%06lo%06lo%06lo%06lo%06lo%06lo%06lo"
+				"%011lo%06lo%011lo",
+			(int)sizeof mag_odc, (int)sizeof mag_odc, mag_odc,
+			(long)dev & OCUT,
+			(long)ino & OCUT,
+			(long)st->st_mode & OCUT,
+			(long)st->st_uid & OCUT,
+			(long)st->st_gid & OCUT,
+			(long)nlink & OCUT,
+			(long)st->st_rdev & OCUT,
+			(long)st->st_mtime,
+			(long)++fsz,
+			(long)size);
+		hsz = SIZEOF_c_hdr;
+		if ((psz = (hsz + fsz) % pad) != 0)
+			psz = pad - psz;
+	} else if (fmttype == FMT_DEC) {
+		pad = 1;
+		sprintf(bc.data, "%*.*s%06lo%06lo%06lo%06lo%06lo%06lo"
+				"%08lo%08lo%011lo%06lo%011lo",
+			(int)sizeof mag_odc, (int)sizeof mag_odc, mag_odc,
+			(long)dev & OCUT,
+			(long)ino & OCUT,
+			(long)st->st_mode & OCUT,
+			(long)st->st_uid & OCUT,
+			(long)st->st_gid & OCUT,
+			(long)nlink & OCUT,
+			(long)major(st->st_rdev) & 077777777,
+			(long)minor(st->st_rdev) & 077777777,
+			(long)st->st_mtime,
+			(long)++fsz,
+			(long)size);
+		hsz = SIZEOF_d_hdr;
+		if ((psz = (hsz + fsz) % pad) != 0)
+			psz = pad - psz;
+	} else if (fmttype & TYP_BINARY) {
+		/*
+		 * To avoid gcc's stupid 'comparison is always false due to
+		 * limited range of data type' warning.
+		 */
+		unsigned long long	gcccrap;
+		pad = 2;
+		if (fmttype & TYP_BE) {
+			be16p(mag_bin, bc.Hdr.c_magic);
+			be16p(dev, bc.Hdr.c_dev);
+			be16p(ino, bc.Hdr.c_ino);
+			be16p(st->st_mode, bc.Hdr.c_mode);
+			be16p(st->st_uid, bc.Hdr.c_uid);
+			be16p(st->st_gid, bc.Hdr.c_gid);
+			be16p(nlink, bc.Hdr.c_nlink);
+			be16p(st->st_rdev, bc.Hdr.c_rdev);
+			be32p(st->st_mtime, bc.Hdr.c_mtime);
+			be16p(++fsz, bc.Hdr.c_namesize);
+		} else {
+			le16p(mag_bin, bc.Hdr.c_magic);
+			le16p(dev, bc.Hdr.c_dev);
+			le16p(ino, bc.Hdr.c_ino);
+			le16p(st->st_mode, bc.Hdr.c_mode);
+			le16p(st->st_uid, bc.Hdr.c_uid);
+			le16p(st->st_gid, bc.Hdr.c_gid);
+			le16p(nlink, bc.Hdr.c_nlink);
+			le16p(st->st_rdev, bc.Hdr.c_rdev);
+			me32p(st->st_mtime, bc.Hdr.c_mtime);
+			le16p(++fsz, bc.Hdr.c_namesize);
+		}
+		if (fmttype & TYP_SGI && size > 0x7FFFFFFFLL) {
+			Krest = size & 0x7FFFFFFFLL;
+			Kbase = size - Krest;
+			Ksize = 0x100000000LL - (Kbase >> 31);
+			if (fmttype & TYP_BE)
+				be32p(Ksize, bc.Hdr.c_filesize);
+			else
+				me32p(Ksize, bc.Hdr.c_filesize);
+			K2hdr = bc.Hdr;
+			if (fmttype & TYP_BE)
+				be32p(Krest, K2hdr.c_filesize);
+			else
+				me32p(Krest, K2hdr.c_filesize);
+		} else {
+			if (fmttype & TYP_BE)
+				be32p(size, bc.Hdr.c_filesize);
+			else
+				me32p(size, bc.Hdr.c_filesize);
+		}
+		if (fmttype & TYP_SGI &&
+				(((st->st_mode&S_IFMT) == S_IFBLK ||
+				 (st->st_mode&S_IFMT) == S_IFCHR) &&
+				((unsigned long long)major(st->st_rdev)>0xFF ||
+				 (unsigned long long)minor(st->st_rdev)>0xFF) ||
+				(gcccrap = st->st_rdev) > 0177777)) {
+			uint32_t	rdev;
+			rdev = (minor(st->st_rdev) & 0x0003FFFF) +
+				((major(st->st_rdev)<<18) & 0xFFFC0000);
+			if (fmttype & TYP_BE) {
+				be16p(0xFFFF, bc.Hdr.c_rdev);
+				be32p(rdev, bc.Hdr.c_filesize);
+			} else {
+				le16p(0xFFFF, bc.Hdr.c_rdev);
+				me32p(rdev, bc.Hdr.c_filesize);
+			}
+		}
+		hsz = SIZEOF_hdr_cpio;
+		psz = (hsz + fsz) % 2;
+	} else if (fmttype & TYP_CRAY) {
+		int	diff5 = fmttype==FMT_CRAY5 ? CRAY_PARAMSZ : 0;
+		mode_t	mo;
+		pad = 1;
+		be64p(mag_bin, bc.Crayhdr.C_magic);
+		be64p(dev, bc.Crayhdr.C_dev);
+		be64p(ino, bc.Crayhdr.C_ino);
+		if ((st->st_mode&S_IFMT) == S_IFLNK)	/* non-standard */
+			mo = st->st_mode&07777|0130000;	/* S_IFLNK on Cray */
+		else
+			mo = st->st_mode;
+		be64p(mo, bc.Crayhdr.C_mode);
+		be64p(st->st_uid, bc.Crayhdr.C_uid);
+		be64p(st->st_gid, bc.Crayhdr.C_gid);
+		be64p(nlink, bc.Crayhdr.C_nlink);
+		be64p(st->st_rdev, bc.Crayhdr.C_rdev);
+		be64p(st->st_mtime, bc.Crayhdr.C_mtime - diff5);
+		be64p(++fsz, bc.Crayhdr.C_namesize - diff5);
+		be64p(size, bc.Crayhdr.C_filesize - diff5);
+		hsz = SIZEOF_cray_hdr - diff5;
+		psz = 0;
+	} else if (fmttype & TYP_BAR) {
+		int	c, n = 0;
+		pad = 512;
+		sprintf(bc.Bdr.b_mode, "%7.7o",(int)st->st_mode&(07777|S_IFMT));
+		sprintf(bc.Bdr.b_uid, "%7.7lo", (long)st->st_uid);
+		sprintf(bc.Bdr.b_gid, "%7.7lo", (long)st->st_gid);
+		sprintf(bc.Bdr.b_size, "%11.11llo",
+				(st->st_mode&S_IFMT) == S_IFREG && !zerolink ?
+				(long long)st->st_size&077777777777LL : 0LL);
+		sprintf(bc.Bdr.b_mtime, "%11.11lo", (long)st->st_mtime);
+		sprintf(bc.Bdr.b_rdev, "%7.7lo", (long)st->st_rdev);
+		strcpy(&bc.data[SIZEOF_bar_header], file);
+		c = tlflag(st);
+		if (zerolink == 0) {
+			bc.Bdr.b_linkflag = c;
+			if (c == '2') {
+				strncpy(&bc.data[SIZEOF_bar_header+fsz+1],
+						symblink,
+						512-SIZEOF_bar_header-fsz);
+				n = size;
+			}
+		} else {
+			bc.Bdr.b_linkflag = '1';
+			strncpy(&bc.data[SIZEOF_bar_header+fsz+1], linkname,
+					512-SIZEOF_bar_header-fsz-1);
+			n = strlen(linkname);
+		}
+		if (n > 512-SIZEOF_bar_header-fsz-1) {
+			msg(3, 0, "%s: linked name too long\n", realfile);
+			goto cleanup;
+		}
+		bchksum(&bc);
+		hsz = 512;
+		psz = 0;
+		fsz = 0;
+	} else if (fmttype & TYP_TAR) {
+		const char	*cp;
+		int	c;
+		/*
+		 * Many SVR4 cpio derivatives expect the mode field
+		 * to contain S_IFMT bits. The meaning of these bits
+		 * in the mode field of the ustar header is left
+		 * unspecified by IEEE Std 1003.1, 1996, 10.1.1.
+		 */
+		int	mmask = fmttype == FMT_USTAR || fmttype == FMT_PAX ?
+				07777 : 07777|S_IFMT;
+
+		paxrec = globrec;
+		pad = 512;
+		if (tmkname(&bc.Tdr, file) != 0)
+			goto cleanup;
+		sprintf(bc.Tdr.t_mode, "%7.7o", (int)st->st_mode & mmask);
+		if (fmttype == FMT_GNUTAR && st->st_uid > 07777777) {
+			be64p(st->st_uid, bc.Tdr.t_uid);
+			bc.Tdr.t_uid[0] |= 0200;
+		} else {
+			sprintf(bc.Tdr.t_uid, "%7.7lo",
+					(long)st->st_uid&07777777);
+			if (fmttype & TYP_PAX && st->st_uid > 07777777)
+				paxrec |= PR_UID;
+		}
+		if (fmttype == FMT_GNUTAR && st->st_gid > 07777777) {
+			be64p(st->st_gid, bc.Tdr.t_gid);
+			bc.Tdr.t_gid[0] |= 0200;
+		} else {
+			sprintf(bc.Tdr.t_gid, "%7.7lo",
+					(long)st->st_gid&07777777);
+			if (fmttype & TYP_PAX && st->st_gid > 07777777)
+				paxrec |= PR_GID;
+		}
+		if (fmttype == FMT_GNUTAR && (st->st_mode&S_IFMT) == S_IFREG &&
+				st->st_size > 077777777777LL && !zerolink) {
+			bc.Tdr.t_size[0] = '\200';
+			be64p(st->st_size, &bc.Tdr.t_size[4]);
+		} else {
+			sprintf(bc.Tdr.t_size, "%11.11llo",
+				(st->st_mode&S_IFMT) == S_IFREG &&
+				(!zerolink || fmttype == FMT_PAX &&
+				 	pax_oflag & PO_LINKDATA) ?
+				(long long)st->st_size&077777777777LL : 0LL);
+			if (fmttype & TYP_PAX &&
+					(st->st_mode&S_IFMT) == S_IFREG &&
+					st->st_size > 077777777777LL &&
+					(!zerolink || fmttype == FMT_PAX &&
+					 	pax_oflag & PO_LINKDATA))
+				paxrec |= PR_SIZE;
+		}
+		sprintf(bc.Tdr.t_mtime, "%11.11lo", (long)st->st_mtime);
+		if ((c = tlflag(st)) < 0) {
+			if ((st->st_mode&S_IFMT) != S_IFDIR) {
+				msg(2, 0, "%s is not a file. Not dumped\n",
+						realfile);
+				errcnt++;
+			} else
+				failure = 0;
+			goto cleanup;
+		}
+		if (zerolink == 0) {
+			bc.Tdr.t_linkflag = c;
+			if (c == '2') {
+				if (tmklink(&bc.Tdr, symblink) != 0)
+					goto cleanup;
+			}
+		} else {
+			bc.Tdr.t_linkflag = '1';
+			if (tmklink(&bc.Tdr, linkname) != 0)
+				goto cleanup;
+		}
+		if (fmttype & TYP_USTAR) {
+			if (fmttype == FMT_GNUTAR)
+				strcpy(bc.Tdr.t_magic, mag_gnutar);
+			else {
+				strcpy(bc.Tdr.t_magic, mag_ustar);
+				bc.Tdr.t_version[0] = bc.Tdr.t_version[1] = '0';
+			}
+			if ((cp = getuser(st->st_uid)) != NULL)
+				sprintf(bc.Tdr.t_uname, "%.31s", cp);
+			else
+				msg(1, 0, "could not get passwd information "
+						"for %s\n", realfile);
+			if ((cp = getgroup(st->st_gid)) != NULL)
+				sprintf(bc.Tdr.t_gname, "%.31s", cp);
+			else
+				msg(1, 0, "could not get group information "
+						"for %s\n", realfile);
+			if (fmttype == FMT_GNUTAR &&
+					(unsigned long long)major(st->st_rdev)
+					> 077777777) {
+				be64p(major(st->st_rdev), bc.Tdr.t_devmajor);
+				bc.Tdr.t_devmajor[0] |= 0200;
+			} else {
+				if (fmttype == FMT_SUN &&
+					(unsigned long long)major(st->st_rdev)
+						> 077777777 &&
+						((st->st_mode&S_IFMT)==S_IFBLK||
+						 (st->st_mode&S_IFMT)==S_IFCHR))
+					paxrec |= PR_SUN_DEVMAJOR;
+				sprintf(bc.Tdr.t_devmajor, "%7.7o",
+					(int)major(st->st_rdev)&07777777);
+			}
+			if (fmttype == FMT_GNUTAR &&
+					(unsigned long long)minor(st->st_rdev)
+					> 077777777) {
+				be64p(minor(st->st_rdev), bc.Tdr.t_devminor);
+				bc.Tdr.t_devminor[0] |= 0200;
+			} else {
+				if (fmttype == FMT_SUN &&
+					(unsigned long long)minor(st->st_rdev)
+						> 077777777 &&
+						((st->st_mode&S_IFMT)==S_IFBLK||
+						 (st->st_mode&S_IFMT)==S_IFCHR))
+					paxrec |= PR_SUN_DEVMINOR;
+				sprintf(bc.Tdr.t_devminor, "%7.7o",
+					(int)minor(st->st_rdev)&07777777);
+			}
+		}
+		tchksum(&bc);
+		hsz = 512;
+		psz = 0;
+		fsz = 0;
+	} else if (fmttype == FMT_ZIP) {
+		pad = 1;
+		memcpy(bc.Zdr.z_signature, mag_zipsig, sizeof mag_zipsig);
+		bc.Zdr.z_version[0] = 10;
+		mkdostime(st->st_mtime, bc.Zdr.z_modtime, bc.Zdr.z_moddate);
+		if ((st->st_mode&S_IFMT) == S_IFREG ||
+				(st->st_mode&S_IFMT) == S_IFLNK) {
+			le32p(size, bc.Zdr.z_csize);
+			le32p(size, bc.Zdr.z_nsize);
+			csize = size;
+		}
+		le16p(fsz, bc.Zdr.z_namelen);
+		le16p(SIZEOF_zextra_cp, bc.Zdr.z_extralen);
+		hsz = SIZEOF_zip_header;
+		psz = 0;
+	} else
+		abort();
+	/*
+	 * Start writing the file to the archive.
+	 */
+	if ((st->st_mode&S_IFMT) == S_IFREG && st->st_size != 0 &&
+			(zerolink == 0 || fmttype == FMT_PAX &&
+			 	pax_oflag & PO_LINKDATA)) {
+		char	*buf;
+		size_t	bufsize;
+		int	readerr = 0;
+
+		if ((fd = open(realfile, O_RDONLY)) < 0) {
+			if (sysv3 < 0)
+				msg(0, 0, "< %s > ?\n", realfile);
+			else if (sysv3 > 0)
+				fprintf(stderr, "<%s> ?\n", realfile);
+			else
+				msg(0, 0, "\"%s\" ?\n", realfile);
+			goto cleanup;
+		}
+		if (fmttype == FMT_ZIP) {
+			if (zipwrite(fd, file, st, &bc, fsz, dev, ino,
+						&crc, &csize) < 0)
+				goto cleanup2;
+			goto done;
+		}
+		if (fmttype & TYP_CRC)
+			if (sum(fd, realfile, st, bc.Edr.E_chksum) < 0)
+				goto cleanup2;
+		if (fmttype & TYP_PAX && paxrec != PR_NONE)
+			wrpax(file, symblink?symblink:linkname, st);
+		bwrite(bc.data, hsz);
+		if (fsz)
+			bwrite(file, fsz);
+		if (psz)
+			bwrite(&bc.data[hsz], psz);
+		if (Kbase)
+			remsz = Kbase;
+		else
+			remsz = st->st_size;
+		getbuf(&buf, &bufsize, st->st_blksize);
+	again:	while (remsz > 0) {
+			if (fd < 0 || (rsz = read(fd, &buf[wsz],
+							bufsize - wsz)) < 0) {
+				if (readerr == 0) {
+					emsg(3, "Cannot read \"%s\"", realfile);
+					if (fd >= 0)
+						errcnt++;
+					readerr = 1;
+				}
+				if (fd >= 0 && lseek(fd, bufsize - wsz,
+							SEEK_CUR) < 0) {
+					close(fd);
+					fd = -1;
+				}
+				rsz = bufsize - wsz;
+				if (rsz > remsz)
+					rsz = remsz;
+				memset(&buf[wsz], 0, rsz);
+			}
+			if (rsz > remsz)
+				rsz = remsz;
+			wsz += rsz;
+			remsz -= rsz;
+			bwrite(buf, wsz);
+			memset(buf, 0, wsz);
+			size = wsz;
+			wsz = 0;
+		}
+		wsz = size;
+		if (Kbase) {
+			if ((i = Ksize % pad) != 0)
+				bwrite(&bc.data[hsz], i);
+			bwrite((char *)&K2hdr, hsz);
+			if (fsz)
+				bwrite(file, fsz);
+			if (psz)
+				bwrite(&bc.data[hsz], psz);
+			remsz = Krest;
+			Kbase = 0;
+			wsz = 0;
+			goto again;
+		} else if (Ksize)
+			wsz = Krest;
+	} else if ((fmttype == FMT_ZIP || fmttype & TYP_CPIO) &&
+			(st->st_mode&S_IFMT) == S_IFLNK) {
+		wsz = size;
+		if (fmttype == FMT_ZIP) {
+			crc = zipcrc(0, (unsigned char *)symblink, wsz);
+			le32p(crc, bc.Zdr.z_crc32);
+			bwrite(bc.data, SIZEOF_zip_header);
+			bwrite(file, fsz);
+			zipwxtra(file, st, dev, ino);
+			bwrite(symblink, wsz);
+		} else {
+			bwrite(bc.data, hsz);
+			if (fsz)
+				bwrite(file, fsz);
+			if (psz)
+				bwrite(&bc.data[hsz], psz);
+			bwrite(symblink, wsz);
+		}
+	} else {
+		if (fmttype & TYP_PAX && paxrec != PR_NONE)
+			wrpax(file, symblink?symblink:linkname, st);
+		bwrite(bc.data, hsz);
+		if (fsz)
+			bwrite(file, fsz);
+		if (psz)
+			bwrite(&bc.data[hsz], psz);
+		if (fmttype == FMT_ZIP)
+			zipwxtra(file, st, dev, ino);
+	}
+done:	if (fmttype == FMT_ZIP) {
+		zipdefer(file, st, relative, crc, csize, &bc.Zdr);
+	}
+	if ((i = wsz % pad) != 0)
+		bwrite(&bc.data[hsz], pad - i);
+	if (vflag && strcmp(file, trailer))
+		fprintf(stderr, "%s\n", file);
+	else if (Vflag)
+		prdot(0);
+	failure = 0;
+cleanup2:
+	if ((st->st_mode&S_IFMT) == S_IFREG) {
+		if (fd >= 0)
+			close(fd);
+		if (aflag)
+			errcnt += rstime(realfile, st, "access");
+	}
+cleanup:
+	free(file);
+	free(symblink);
+	return failure;
+}
+
+/*
+ * Flush a SVR4 cpio format inode tree for -o.
+ */
+static void
+iflush(struct islot *ip, uint32_t dev)
+{
+	if (ip == inull)
+		return;
+	iflush(ip->i_lln, dev);
+	iflush(ip->i_rln, dev);
+	if (ip->i_nlk > 0 && ip->i_st) {
+		struct ilink *il;
+
+		for (il = ip->i_lnk; il->l_nxt; il = il->l_nxt)
+			errcnt += addfile(il->l_nam, ip->i_st,
+					dev, ip->i_fino, 1, 0);
+		errcnt += addfile(il->l_nam, ip->i_st, dev, ip->i_fino, 0, 0);
+	}
+}
+
+/*
+ * Flush the SVR4 cpio link forest for -o.
+ */
+static void
+lflush(void)
+{
+	struct dslot *ds;
+
+	for (ds = devices; ds; ds = ds->d_nxt)
+		iflush(ds->d_isl, ds->d_fake);
+}
+
+int
+setfmt(char *s)
+{
+	int	i, j;
+
+	struct {
+		const char	*ucs;
+		const char	*lcs;
+		int	type;
+		int	bits;
+	} fs[] = {
+		{ "NEWC",	"newc",		FMT_ASC,	00 },
+		{ "SCO",	"sco",		FMT_SCOASC,	00 },
+		{ "CRC",	"crc",		FMT_CRC,	00 },
+		{ "SCOCRC",	"scocrc",	FMT_SCOCRC,	00 },
+		{ "ODC",	"odc",		FMT_ODC,	00 },
+		{ "DEC",	"dec",		FMT_DEC,	00 },
+		{ "BIN",	"bin",		FMT_NONE,	00 },
+		{ "BBS",	"bbs",		TYP_BE,		00 },
+		{ "SGI",	"sgi",		FMT_SGIBE,	00 },
+		{ "CRAY",	"cray",		FMT_CRAY,	00 },
+		{ "CRAY5",	"cray5",	FMT_CRAY5,	00 },
+		{ "TAR",	"tar",		FMT_TAR,	00 },
+		{ "USTAR",	"ustar",	FMT_USTAR,	00 },
+		{ "PAX:",	"pax:",		FMT_PAX,	00 },
+		{ "SUN",	"sun",		FMT_SUN,	00 },
+		{ "GNU",	"gnu",		FMT_GNUTAR,	00 },
+		{ "OTAR",	"otar",		FMT_OTAR,	00 },
+		{ "BAR",	"bar",		FMT_BAR,	00 },
+		{ "ZIP:",	"zip:",		FMT_ZIP,	00 },
+		{ NULL,		NULL,		0,		00 }
+	};
+	for (i = 0; fs[i].ucs; i++) {
+		for (j = 0; s[j] &&
+				(s[j] == fs[i].ucs[j] || s[j] == fs[i].lcs[j]);
+				j++)
+			if (fs[i].ucs[j] == ':')
+				break;
+		if (s[j] == '\0' &&
+				(fs[i].ucs[j] == '\0' || fs[i].ucs[j] == ':') ||
+				s[j] == ':' && fs[i].ucs[j] == ':') {
+			fmttype = fs[i].type;
+			if (fmttype == FMT_ZIP && s[j] == ':') {
+#if	USE_ZLIB
+				if (strcmp(&s[j+1], "en") == 0)
+					zipclevel = 00;
+				else if (strcmp(&s[j+1], "ex") == 0)
+					zipclevel = 01;
+				else if (strcmp(&s[j+1], "ef") == 0)
+					zipclevel = 02;
+				else if (strcmp(&s[j+1], "es") == 0)
+					zipclevel = 03;
+				else
+#endif	/* USE_ZLIB */
+				if (strcmp(&s[j+1], "e0") == 0)
+					zipclevel = 04;
+				else
+#if	USE_BZLIB
+				if (strcmp(&s[j+1], "bz2") == 0)
+					zipclevel = 07;
+				else
+#endif	/* USE_BZLIB */
+					continue;
+			} else if (fmttype == FMT_NONE)
+				fmttype = bigendian() ? FMT_BINBE : FMT_BINLE;
+			else if (fmttype == TYP_BE)
+				fmttype = bigendian() ? FMT_BINLE : FMT_BINBE;
+			else if (fmttype == FMT_PAX && s[j] == ':') {
+				if (pax_options(&s[j+1], 0) < 0)
+					continue;
+			}
+			return 0;
+		}
+	}
+	msg(3, 0, "Invalid header \"%s\" specified.\n", s);
+	return -1;
+}
+
+static int
+bigendian(void)
+{
+	union {
+		char	u_c[2];
+		int16_t	u_i;
+	} u;
+	u.u_i = 1;
+	return u.u_c[1] == 1;
+}
+
+int
+setreassign(const char *s)
+{
+	struct passwd	*pwd;
+	int	val = 0;
+
+	if (myuid != 0) {
+		msg(3, 0, "R option only valid for super-user.\n");
+		val = -1;
+	}
+	if ((pwd = getpwnam(s)) == NULL) {
+		msg(3, 0, "\"%s\" is not a valid user id\n", s);
+		val = -1;
+	} else {
+		Ruid = pwd->pw_uid;
+		Rgid = pwd->pw_gid;
+	}
+	return val;
+}
+
+void *
+srealloc(void *m, size_t n)
+{
+	if ((m = realloc(m, n)) == NULL) {
+		write(2, "Out of memory.\n", 15);
+		_exit(sysv3 ? 2 : 3);
+	}
+	return m;
+}
+
+void *
+smalloc(size_t n)
+{
+	return srealloc(NULL, n);
+}
+
+void *
+scalloc(size_t nmemb, size_t size)
+{
+	void	*vp;
+
+	if ((vp = calloc(nmemb, size)) == NULL) {
+		write(2, "Out of memory.\n", 15);
+		_exit(sysv3 ? 2 : 3);
+	}
+	return vp;
+}
+
+void *
+svalloc(size_t n, int force)
+{
+	static long	pagesize;
+	void	*vp;
+
+	if (pagesize == 0)
+		if ((pagesize = sysconf(_SC_PAGESIZE)) < 0)
+			pagesize = 4096;
+	if ((vp = memalign(pagesize, n)) == NULL && force) {
+		write(2, "Out of memory.\n", 15);
+		_exit(sysv3 ? 2 : 3);
+	}
+	return vp;
+}
+
+/*
+ * A single static buffer is used for intermediate copying from file
+ * data to the tape buffer and vice versa, for creating checksums, and
+ * for data transfer with -p.
+ */
+static void
+getbuf(char **bufp, size_t *sizep, size_t best)
+{
+	static char	*buf;
+	static size_t	size;
+
+	if (size != best) {
+		if (buf)
+			free(buf);
+		size = best;
+		if (size == 0 || (buf = svalloc(size, 0)) == NULL)
+			buf = svalloc(size = 512, 1);
+	}
+	*bufp = buf;
+	*sizep = size;
+}
+
+static void
+sevprnt(int sev)
+{
+	if (printsev) switch (sev) {
+	case 1:
+		fprintf(stderr, "INFORM: ");
+		break;
+	case 2:
+		fprintf(stderr, "WARNING: ");
+		break;
+	case 3:
+		fprintf(stderr, "ERROR: ");
+		break;
+	case 4:
+		fprintf(stderr, "HALT: ");
+		break;
+	}
+}
+
+void
+msg(int sev, int err, const char *fmt, ...)
+{
+	va_list	ap;
+
+	/*
+	 * The error message should appear near the file it refers to.
+	 */
+	if (tflag)
+		fflush(stdout);
+	else if (Vflag)
+		prdot(1);
+	if (sysv3 >= 0 && sev >= (printsev ? 0 : -1))
+		fprintf(stderr, "%s: ", progname);
+	sevprnt(sev);
+	va_start(ap, fmt);
+	vfprintf(stderr, fmt, ap);
+	va_end(ap);
+	if (err > 0)
+		done(err);
+	else if (err == -2) {
+		if (sysv3)
+			done(1);
+		usage();
+	}
+}
+
+void
+emsg(int sev, const char *fmt, ...)
+{
+	char	_fmt[60];
+	int	i, fl = sev & 030, n;
+	va_list	ap;
+
+	sev &= ~030;
+	i = errno;
+	if (tflag)
+		fflush(stdout);
+	else if (Vflag)
+		prdot(1);
+	fprintf(stderr, "%s: ", progname);
+	sevprnt(sev);
+	va_start(ap, fmt);
+	if (sysv3) {
+		if (fmt[(n=strlen(fmt))-1] == '"' && fmt[n-2] == 's' &&
+				fmt[n-3] == '%' && fmt[n-4] == '"' &&
+				n < sizeof _fmt) {
+			strcpy(_fmt, fmt);
+			_fmt[n-1] = '>';
+			_fmt[n-4] = '<';
+			fmt = _fmt;
+		}
+	}
+	vfprintf(stderr, fmt, ap);
+	va_end(ap);
+	if (sysv3 > 0 && sev >= 0 && fl & 010)
+		fprintf(stderr, "\n\t%s\n", strerror(i));
+	else if (sysv3 < 0) {
+		if (fl & 020)
+			putc('\n', stderr);
+		else
+			fprintf(stderr, " (errno:%d)\n", i);
+	} else
+		fprintf(stderr, ", errno %d, %s\n", i, strerror(i));
+}
+
+static void
+prdot(int flush)
+{
+	static int	column;
+
+	if (flush && column != 0 || column >= 50) {
+		write(action == 'o' && !Oflag ? 2 : 1, "\n", 1);
+		column = 0;
+	}
+	if (!flush) {
+		write(action == 'o' && !Oflag ? 2 : 1, ".", 1);
+		column++;
+	}
+}
+
+/*
+ * Ask the user for new media if applicable, or exit.
+ */
+static void
+newmedia(int err)
+{
+	static int	mediacnt = 1;
+	static char answer[PATH_MAX+1];
+	const char	*mesf = action == 'i' ?
+		(Iflag && !sysv3 ? Iflag : "input") :
+		(Oflag && !sysv3 ? Oflag : "output");
+	char c;
+	int i, j;
+
+	if (mfl == 0 && close(mt) < 0) {
+		emsg(3, "Close error on \"%s\"", mesf);
+		errcnt++;
+	}
+	mfl = -1;
+	if ((mtst.st_mode&S_IFMT)!=S_IFCHR && (mtst.st_mode&S_IFMT)!=S_IFBLK ||
+			Dflag) {
+		if (action == 'o') {
+			switch (err) {
+			case 0:
+				break;
+			case EFBIG:
+				msg(3, 0, "ulimit reached for output file.\n");
+				break;
+			case ENOSPC:
+				msg(3, 0, "No space left for output file.\n");
+				break;
+			default:
+				msg(3, 0, "I/O error - cannot continue, "
+						"errno %d, %s\n",
+						err, strerror(err));
+			}
+		}
+		return;
+	}
+	if (err == ENOSPC || err == ENXIO || err == 0)
+		msg(-2, 0, sysv3 ? "Reached end of medium on %s.\a\n" :
+				"End of medium on \"%s\".\a\n", mesf);
+	else
+		msg(3, 0, "I/O error on \"%s\", errno %d, %s\a\n", mesf,
+				err, strerror(err));
+	mediacnt++;
+	while (mfl < 0) {
+		if (Iflag || Oflag)
+			msg(-2, 0, Mflag ? Mflag :
+					"Change to part %d and press "
+					"RETURN key. [q] ", mediacnt);
+		else
+			msg(-2, 0, sysv3 ? "If you want to go on, "
+					"type device/file name when ready.\n" :
+					"To continue, type device/file name "
+					"when ready.\n");
+		if (tty == 0)
+			if ((tty = open("/dev/tty", O_RDWR)) < 0 ||
+					fcntl(tty, F_SETFD, FD_CLOEXEC) < 0) {
+			cantrt:	errcnt++;
+				msg(4, 1, "Cannot read tty.\n");
+			}
+		i = 0;
+		while ((j = read(tty, &c, 1)) == 1 && c != '\n')
+			if (i < sizeof answer - 1)
+				answer[i++] = c;
+		if (j != 1)
+			goto cantrt;
+		answer[i] = 0;
+		if (Iflag || Oflag) {
+			if (answer[0] == '\0')
+				snprintf(answer, sizeof answer, Iflag ? Iflag :
+						Oflag);
+			else if (answer[0] == 'q')
+				exit(errcnt != 0 ? sysv3 ? 1 : 2 : 0);
+			else if (Iflag)
+				Iflag = sstrdup(answer);
+			else if (Oflag)
+				Oflag = sstrdup(answer);
+		} else if (answer[0] == '\0')
+			return;
+		if ((mt = action == 'i' ? open(answer, O_RDONLY) :
+					creat(answer, 0666)) < 0) {
+			if (sysv3)
+				msg(-2, 0, "That didn't work, "
+						"cannot open \"%s\"\n%s\n",
+						answer, strerror(errno));
+			else
+				emsg(3, "Cannot open \"%s\"", answer);
+		}
+		else
+			mfl = 0;
+	}
+	mstat();
+}
+
+static void
+mclose(void)
+{
+	if (action == 'o' && mt >= 0 && close(mt) < 0) {
+		emsg(3, "Close error on \"%s\"",
+				Oflag && !sysv3 ? Oflag : "output");
+		errcnt++;
+	}
+}
+
+/*
+ * Write the archive buffer to tape.
+ */
+static ssize_t
+mwrite(int max)
+{
+	ssize_t wo, wt = 0;
+
+	do {
+		if ((wo = write(mt, blkbuf + wt, (max?max:blksiz) - wt)) < 0) {
+			if (errno == EINTR) {
+				continue;
+			} else {
+				newmedia(errno);
+				if (mfl == 0) {
+					if (fmttype & TYP_BAR)
+						dump_barhdr();
+					continue;
+				}
+				else
+					done(1);
+			}
+		}
+		poffs += wo;
+		wt += wo;
+	} while (wt < (max?max:blksiz));
+	blocks += wt >> 9;
+	bytes += wt & 0777;
+	return wt;
+}
+
+/*
+ * Buffered writes to tape.
+ */
+static void
+bwrite(const char *data, size_t sz)
+{
+	size_t di;
+
+	nwritten += sz;
+	while (curpos + sz > blksiz) {
+		di = blksiz - curpos;
+		sz -= di;
+		memcpy(&blkbuf[curpos], data, di);
+		mwrite(0);
+		data += di;
+		curpos = 0;
+	}
+	memcpy(&blkbuf[curpos], data, sz);
+	curpos += sz;
+}
+
+/*
+ * Flush the tape write buffer.
+ */
+static void
+bflush(void)
+{
+	if (curpos) {
+		memset(&blkbuf[curpos], 0, blksiz - curpos);
+		mwrite(fmttype==FMT_ZIP && (mtst.st_mode&S_IFMT) == S_IFREG ?
+			curpos : 0);
+	}
+	curpos = 0;
+}
+
+/*
+ * CRC format checksum calculation with -i.
+ */
+static int
+sum(int fd, const char *fn, struct stat *sp, char *tg)
+{
+	char	*buf;
+	size_t	bufsize;
+	uint32_t	size = sp->st_size, sum = 0;
+	ssize_t	rd;
+	char	c;
+
+	getbuf(&buf, &bufsize, sp->st_blksize);
+	/*
+	 * Unfortunately, SVR4 cpio derivatives (as on Solaris 8 and
+	 * UnixWare 2.1) compute the checksum of signed char values,
+	 * whereas GNU cpio and the pax implementations of AT&T and
+	 * BSD use unsigned chars. Since there is no 'open' standard
+	 * for the SVR4 CRC format, the SVR4 implementation should be
+	 * taken as a de facto reference and we thus create SVR4 type
+	 * checksums.
+	 */
+	while ((rd = read(fd, buf, size>bufsize ? bufsize : size )) > 0) {
+		size -= rd;
+		do
+			sum += ((signed char *)buf)[--rd];
+		while (rd);
+	}
+	if (rd < 0) {
+		msg(3, 0, "Error computing checksum\n");
+		return 1;
+	}
+	if (lseek(fd, 0, SEEK_SET) == (off_t)-1) {
+		emsg(3, "Cannot reset file after checksum");
+		return 1;
+	}
+	c = tg[8];
+	sprintf(tg, "%08lx", (long)sum);
+	tg[8] = c;
+	return 0;
+}
+
+static int
+rstime(const char *fn, struct stat *st, const char *which)
+{
+	struct utimbuf	utb;
+
+	utb.actime = st->st_atime;
+	utb.modtime = st->st_mtime;
+	if (pax != PAX_TYPE_CPIO &&
+			(pax_preserve&(PAX_P_ATIME|PAX_P_MTIME)) != 0 &&
+			(pax_preserve&PAX_P_EVERY) == 0) {
+		struct stat	xst;
+		if (stat(fn, &xst) < 0)
+			goto fail;
+		if (pax_preserve&PAX_P_ATIME)
+			utb.actime = xst.st_atime;
+		if (pax_preserve&PAX_P_MTIME)
+			utb.modtime = xst.st_mtime;
+	}
+	if (utime(fn, &utb) < 0) {
+	fail:	emsg(2, "Unable to reset %s time for \"%s\"", which, fn);
+		return 1;
+	}
+	return 0;
+}
+
+/*
+ * Top-down splay function for inode tree.
+ */
+static struct islot *
+isplay(ino_t ino, struct islot *x)
+{
+	struct islot	hdr;
+	struct islot	*leftmax, *rightmin;
+	struct islot	*y;
+
+	hdr.i_lln = hdr.i_rln = inull;
+	leftmax = rightmin = &hdr;
+	inull->i_ino = ino;
+	while (ino != x->i_ino) {
+		if (ino < x->i_ino) {
+			if (ino < x->i_lln->i_ino) {
+				y = x->i_lln;
+				x->i_lln = y->i_rln;
+				y->i_rln = x;
+				x = y;
+			}
+			if (x->i_lln == inull)
+				break;
+			rightmin->i_lln = x;
+			rightmin = x;
+			x = x->i_lln;
+		} else {
+			if (ino > x->i_rln->i_ino) {
+				y = x->i_rln;
+				x->i_rln = y->i_lln;
+				y->i_lln = x;
+				x = y;
+			}
+			if (x->i_rln == inull)
+				break;
+			leftmax->i_rln = x;
+			leftmax = x;
+			x = x->i_rln;
+		}
+	}
+	leftmax->i_rln = x->i_lln;
+	rightmin->i_lln = x->i_rln;
+	x->i_lln = hdr.i_rln;
+	x->i_rln = hdr.i_lln;
+	inull->i_ino = !ino;
+	return x;
+}
+
+/*
+ * Find the inode number ino.
+ */
+static struct islot *
+ifind(ino_t ino, struct islot **it)
+{
+	if (*it == NULL)
+		return NULL;
+	*it = isplay(ino, *it);
+	return (*it)->i_ino == ino ? *it : NULL;
+}
+
+/*
+ * Put ik into the tree.
+ */
+static void
+iput(struct islot *ik, struct islot **it)
+{
+	if ((*it) == NULL) {
+		ik->i_lln = ik->i_rln = inull;
+		(*it) = ik;
+	} else {
+		/* ifind() is always called before */
+		/*(*it) = isplay(ik->i_ino, (*it));*/
+		if (ik->i_ino < (*it)->i_ino) {
+			ik->i_lln = (*it)->i_lln;
+			ik->i_rln = (*it);
+			(*it)->i_lln = inull;
+			(*it) = ik;
+		} else if ((*it)->i_ino < ik->i_ino) {
+			ik->i_rln = (*it)->i_rln;
+			ik->i_lln = (*it);
+			(*it)->i_rln = inull;
+			(*it) = ik;
+		}
+	}
+}
+
+/*
+ * Find the device dev or add it to the device/inode forest if not
+ * already present.
+ */
+static struct dslot *
+dfind(struct dslot **root, dev_t dev)
+{
+	struct dslot	*ds, *dp;
+
+	for (ds = *root, dp = NULL; ds; dp = ds, ds = ds->d_nxt)
+		if (ds->d_dev == dev)
+			break;
+	if (ds == NULL) {
+		ds = scalloc(1, sizeof *ds);
+		ds->d_dev = dev;
+		if (*root == NULL)
+			*root = ds;
+		else
+			dp->d_nxt = ds;
+	}
+	return ds;
+}
+
+/*
+ * Exit on fatal error conditions.
+ */
+static void
+done(int i)
+{
+	if (tflag)
+		fflush(stdout);
+	errcnt += i;
+	mclose();
+	if (errcnt && !sysv3)
+		fprintf(stderr, "%llu errors\n", errcnt);
+	exit(sysv3 ? 2 : 3);
+}
+
+static char	*pcopy, *pcend;
+static size_t	psz, pslen, pss;
+
+/*
+ * Execution for -p.
+ */
+static void
+dopass(const char *target)
+{
+	struct stat	st;
+
+	if (access(target, W_OK) < 0) {
+		emsg(033, sysv3 ? "cannot write in <%s>" :
+				"Error during access() of \"%s\"", target);
+		if (sysv3)
+			done(1);
+		usage();
+	}
+	if (stat(target, &st) < 0) {
+		emsg(023, "Error during stat() of \"%s\"", target);
+		done(1);
+	}
+	if ((st.st_mode&S_IFMT) != S_IFDIR)
+		msg(3, 1, sysv3 ? "<%s> not a directory.\n" :
+				"\"%s\" is not a directory\n", target);
+	getpath(target, &pcopy, &pcend, &psz, &pslen);
+	copyout(passfile);
+}
+
+/*
+ * Callback for sfile().
+ */
+/*ARGSUSED*/
+void
+writerr(void *vp, int count, int written)
+{
+}
+
+/*
+ * Copy file data of regular files with -p.
+ */
+static int
+passdata(struct file *f, const char *tgt, int tfd)
+{
+	char	*buf;
+	size_t	bufsize;
+	ssize_t	rd = 0;
+
+	if (f->f_fd < 0)	/* is a zero-sized unreadable file */
+		return 0;
+#ifdef	__linux__
+	if (f->f_st.st_size > 0) {
+		long long	sent;
+
+		sent = sfile(tfd, f->f_fd, f->f_st.st_mode, f->f_st.st_size);
+		blocks += (sent + 0777) >> 9;
+		if (sent == f->f_st.st_size)
+			return 0;
+		if (sent < 0)
+			goto rerr;
+	}
+#endif	/* __linux__ */
+	getbuf(&buf, &bufsize, f->f_st.st_blksize);
+	while ((rd = read(f->f_fd, buf, bufsize)) > 0) {
+		blocks += (rd + 0777) >> 9;
+		if (write(tfd, buf, rd) != rd) {
+			emsg(3, "Cannot write \"%s\"", tgt);
+			return -1;
+		}
+	}
+	if (rd < 0) {
+#ifdef	__linux__
+	rerr:
+#endif	/* __linux__ */
+		emsg(3, "Cannot read \"%s\"", f->f_name);
+		return -1;
+	}
+	return 0;
+}
+
+/*
+ * Handle a single file for -p.
+ */
+static int
+passfile(const char *fn, struct stat *st)
+{
+	struct file	f;
+	ssize_t	sz;
+	int	val;
+	char	*newfn;
+	size_t	newsz = 0;
+
+	newfn = sstrdup(fn);
+	if (pax != PAX_TYPE_CPIO) {
+		if (pax_sflag && pax_sname(&newfn, &newsz) == 0)
+			return 0;
+		if (rflag && rname(&newfn, &newsz) == 0)
+			return 0;
+	}
+	setpath(newfn, &pcopy, &pcend, pslen, &psz, &pss);
+	free(newfn);
+	memset(&f, 0, sizeof f);
+	f.f_name = sstrdup(fn);
+	f.f_nsiz = strlen(fn) + 1;
+	f.f_st = *st;
+	f.f_fd = -1;
+	if ((st->st_mode&S_IFMT) == S_IFLNK) {
+		sz = st->st_size ? st->st_size : PATH_MAX;
+		f.f_lnam = smalloc(sz+1);
+		if ((sz = readlink(fn, f.f_lnam, sz+1)) < 0) {
+				emsg(3, "Cannot read symbolic link \"%s\"", fn);
+				free(f.f_lnam);
+				return 1;
+		}
+		f.f_lnam[sz] = '\0';
+	} else if ((st->st_mode&S_IFMT) == S_IFREG) {
+		if ((f.f_fd = open(fn, O_RDONLY)) < 0) {
+			if (sysv3)
+				msg(2, 0, "Cannot open file \"%s\".\n", fn);
+			else
+				emsg(2, "Cannot open \"%s\", skipped", fn);
+			if (st->st_size != 0)
+				return 1;
+		}
+	}
+	val = filein(&f, passdata, pcopy);
+	if (f.f_lnam)
+		free(f.f_lnam);
+	free(f.f_name);
+	if (f.f_fd >= 0)
+		close(f.f_fd);
+	if (val <= 1 && aflag && (st->st_mode&S_IFMT) == S_IFREG)
+		errcnt += rstime(fn, st, "access");
+	return val != 0;
+}
+
+/*
+ * Processing of a single file common to -i and -p. Return value: 0 if
+ * successful, 1 at failure if data was read, 2 at failure if no data
+ * was read.
+ */
+static int
+filein(struct file *f, int (*copydata)(struct file *, const char *, int),
+	char *tgt)
+{
+	struct stat	nst;
+	char	*temp = NULL;
+	size_t	len;
+	int	fd, i, j, new;
+	int	failure = 2;
+
+	if (fmttype == FMT_ZIP && (f->f_st.st_mode&S_IFMT) != S_IFREG &&
+			(f->f_st.st_mode&S_IFMT) != S_IFLNK &&
+			(f->f_csize > 0 || f->f_gflag & FG_DESC))
+		skipfile(f);
+	if ((new = lstat(tgt, &nst)) == 0) {
+		if (action == 'p' && f->f_st.st_dev == nst.st_dev &&
+				f->f_st.st_ino == nst.st_ino) {
+			msg(3, 0, sysv3 ?
+				"Attempt to pass file to self!\n" :
+				"Attempt to pass a file to itself.\n");
+			return 1;
+		}
+		if ((f->f_st.st_mode&S_IFMT) == S_IFDIR) {
+			if ((nst.st_mode&S_IFMT) == S_IFDIR)
+				return setattr(tgt, &f->f_st);
+			rmdir(tgt);
+		} else {
+			if (pax_kflag) {
+				failure = 0;
+				goto skip;
+			}
+			if (uflag == 0 && f->f_st.st_mtime <= nst.st_mtime) {
+				if (pax == PAX_TYPE_CPIO)
+					msg(-1, 0, sysv3 ?
+					"current <%s> newer or same age\n" :
+					"Existing \"%s\" same age or newer\n",
+						tgt);
+				else
+					failure = 0;
+				goto skip;
+			}
+		}
+	} else {
+		if (imdir(tgt) < 0)
+			goto skip;
+	}
+	if (Vflag && !vflag)
+		prdot(0);
+	if ((f->f_st.st_mode&S_IFMT) != S_IFDIR && lflag) {
+		if (Lflag) {
+			char	*symblink, *name;
+			struct stat	xst;
+			name = f->f_name;
+			for (;;) {
+				if (lstat(name, &xst) < 0) {
+					emsg(3, "Cannot lstat \"%s\"", name);
+					if (name != f->f_name)
+						free(name);
+					goto cantlink;
+				}
+				if ((xst.st_mode&S_IFMT) != S_IFLNK)
+					break;
+				i = xst.st_size ? xst.st_size : PATH_MAX;
+				symblink = smalloc(i+1);
+				if ((j = readlink(name, symblink, i)) < 0) {
+					emsg(3, "Cannot read symbolic link "
+						"\"%s\"", name);
+					free(symblink);
+					if (name != f->f_name)
+						free(name);
+					goto cantlink;
+				}
+				symblink[j] = '\0';
+				symblink = joinpath(name, symblink);
+				if (name != f->f_name)
+					free(name);
+				name = symblink;
+			}
+			if (linkunlink(name, tgt) == 0) {
+				if (vflag)
+					fprintf(stderr, "%s\n", tgt);
+				if (name != f->f_name)
+					free(name);
+				return 0;
+			}
+			if (name != f->f_name)
+				free(name);
+		} else if (linkunlink(f->f_name, tgt) == 0) {
+			if (vflag)
+				fprintf(stderr, "%s\n", tgt);
+			return 0;
+		}
+cantlink:	errcnt += 1;
+	}
+	if ((f->f_st.st_mode&S_IFMT) != S_IFDIR && f->f_st.st_nlink > 1 &&
+			(fmttype & TYP_CPIO || fmttype == FMT_ZIP
+			 || action == 'p') &&
+			(i = canlink(tgt, &f->f_st, 1)) != 0) {
+		if (i < 0)
+			goto skip;
+		/*
+		 * At this point, hard links in SVR4 cpio format have
+		 * been reordered and data is associated with the first
+		 * link; remaining links have st_size == 0 so don't
+		 * overwrite the data here.
+		 */
+		if (fmttype & TYP_NCPIO && f->f_st.st_size == 0 ||
+				(f->f_st.st_mode&S_IFMT) != S_IFREG) {
+			if (vflag)
+				fprintf(stderr, "%s\n", f->f_name);
+			return 0;
+		}
+		/*
+		 * Make sure we can creat() this file later.
+		 */
+		chmod(tgt, 0600);
+	} else if (fmttype & TYP_TAR && f->f_st.st_nlink > 1) {
+		if (linkunlink(f->f_lnam, f->f_name) == 0) {
+			if (fmttype & TYP_USTAR && f->f_st.st_size > 0)
+				chmod(tgt, 0600);
+			else {
+				if (vflag)
+					fprintf(stderr, "%s\n", f->f_name);
+				return 0;
+			}
+		} else {
+			goto restore;
+		}
+	} else if (new == 0 && (f->f_st.st_mode&S_IFMT) != S_IFDIR) {
+		len = strlen(tgt);
+		temp = smalloc(len + 7);
+		strcpy(temp, tgt);
+		strcpy(&temp[len], "XXXXXX");
+		if ((fd = mkstemp(temp)) < 0 || close(fd) < 0) {
+			emsg(3, "Cannot create temporary file");
+			if (fd < 0) {
+				free(temp);
+				temp = NULL;
+			}
+			goto skip;
+		}
+		cur_ofile = tgt;
+		cur_tfile = temp;
+		if (rename(tgt, temp) < 0) {
+			emsg(3, "Cannot rename current \"%s\"", tgt);
+			tunlink(&temp);
+			goto skip;
+		}
+	}
+	switch (f->f_st.st_mode & S_IFMT) {
+	case S_IFDIR:
+		if (!dflag) {
+			if (action == 'p')
+				msg(-1, 0, "Use -d option to copy \"%s\"\n",
+						f->f_name);
+			goto restore;
+		}
+		if (mkdir(tgt, 0777) < 0 && errno != EEXIST) {
+			emsg(-1, "Cannot create directory \"%s\"", tgt);
+			goto restore;
+		}
+		break;
+	case S_IFLNK:
+		if (symlink(f->f_lnam, tgt) < 0) {
+			emsg(3, "Cannot create \"%s\"", tgt);
+			goto restore;
+		}
+		break;
+	case S_IFREG:
+		if (temp && f->f_fd < 0)
+			goto restore;
+		cur_ofile = tgt;
+		if ((fd = (compressed_bar ? zcreat : creat)(tgt,
+						f->f_st.st_mode & 0777)) < 0) {
+			emsg(3, "Cannot create \"%s\"", tgt);
+			goto skip;
+		}
+		failure = 1;
+		if (copydata(f, tgt, fd) != 0) {
+			close(fd);
+			goto restore;
+		}
+		if ((compressed_bar ? zclose : close)(fd) < 0) {
+			emsg(3, "Close error on \"%s\"", tgt);
+			goto restore;
+		}
+		break;
+	case S_IFBLK:
+	case S_IFCHR:
+	case S_IFIFO:
+	case S_IFNAM:
+	case S_IFNWK:
+		if (mknod(tgt, f->f_st.st_mode&(S_IFMT|0777),
+					f->f_st.st_rdev) < 0) {
+			emsg(3, "Cannot mknod() \"%s\"", tgt);
+			goto restore;
+		}
+		break;
+	default:
+		msg(-1, 0, "Impossible file type\n");
+		goto skip;
+	}
+	if (vflag)
+		fprintf(stderr, "%s\n", f->f_name);
+	tunlink(&temp);
+	return setattr(tgt, &f->f_st);
+skip:	if (copydata == indata)
+		skipdata(f, copydata);
+restore:
+	if (temp) {
+		if (rename(temp, tgt) < 0) {
+			emsg(3, "Cannot recover original version of \"%s\"",
+					tgt);
+			tunlink(&temp);
+		} else
+			fprintf(stderr, "Restoring existing \"%s\"\n", tgt);
+		cur_tfile = cur_ofile = NULL;
+	}
+	return failure;
+}
+
+static int
+linkunlink(const char *path1, const char *path2)
+{
+	int	twice = 0;
+
+	do {
+		if (link(path1, path2) == 0) {
+			if (vflag && pax == PAX_TYPE_CPIO)
+				printf("%s linked to %s\n", path1, path2);
+			return 0;
+		}
+		if (errno == EEXIST && unlink(path2) < 0)
+			emsg(3, sysv3 ? "cannot unlink <%s>" :
+					"Error cannot unlink \"%s\"", path2);
+	} while (twice++ == 0);
+	emsg(023, sysv3 ? "Cannot link <%s> & <%s>" :
+			"Cannot link \"%s\" and \"%s\"", path1, path2);
+	return -1;
+}
+
+static void
+tunlink(char **fn)
+{
+	cur_tfile = cur_ofile = NULL;
+	if (*fn) {
+		if (unlink(*fn) < 0)
+			emsg(3, "Cannot unlink() temp file \"%s\"", *fn);
+		free(*fn);
+		*fn = NULL;
+	}
+}
+
+/*
+ * For -it[v] option.
+ */
+static int
+filet(struct file *f, int (*copydata)(struct file *, const char *, int))
+{
+	if (vflag && (
+		(fmttype == FMT_ZIP && f->f_gflag & FG_DESC &&
+		(f->f_cmethod == C_DEFLATED || f->f_cmethod == C_ENHDEFLD) &&
+				(f->f_gflag & FG_CRYPT) == 0) ||
+		f->f_Kbase)) {
+		/*
+		 * Need to read zip data descriptor located after the
+		 * file contents in order to know the file size. Or
+		 * need to read second header of -K archive.
+		 */
+		int	i;
+		i = skipdata(f, copydata);
+		filev(f);
+		return i;
+	}
+	if (vflag)
+		filev(f);
+	else
+		puts(f->f_name);
+	return skipdata(f, copydata);
+}
+
+static void
+filev(struct file *f)
+{
+	const char	*cp;
+	long	c;
+
+	if (pax == PAX_TYPE_CPIO && fmttype & TYP_TAR && f->f_st.st_nlink > 1)
+		printf("%s linked to %s\n", f->f_lnam, f->f_name);
+	if (sysv3)
+		printf("%-6o", (int)f->f_st.st_mode&(07777|S_IFMT));
+	else {
+		c = typec(&f->f_st);
+		putchar(c);
+		permbits(f->f_st.st_mode);
+	}
+	if (fmttype == FMT_ZIP && vflag > 1)
+		zipinfo(f);
+	else {
+		if (sysv3 == 0)
+			printf(" %3d", fmttype&TYP_TAR &&
+					(f->f_st.st_mode&S_IFMT) == S_IFLNK ?
+					2 : (int)f->f_st.st_nlink);
+		if ((cp = getuser(f->f_st.st_uid)) != NULL)
+			printf(sysv3 ? " %-6s" : " %-8s", cp);
+		else
+			printf(sysv3 ? " %-6lu" : " %-8lu",
+					(long)f->f_st.st_uid);
+		if (sysv3 == 0) {
+			if ((cp = getgroup(f->f_st.st_gid)) != NULL)
+				printf(" %-8s", cp);
+			else
+				printf(" %-8lu", (long)f->f_st.st_gid);
+		}
+	}
+	if (sysv3 || (f->f_st.st_mode&S_IFMT)!=S_IFCHR &&
+			(f->f_st.st_mode&S_IFMT)!=S_IFBLK &&
+			(f->f_st.st_mode&S_IFMT)!=S_IFNAM &&
+			(f->f_st.st_mode&S_IFMT)!=S_IFNWK)
+		printf(pax != PAX_TYPE_CPIO ? "%8llu" :
+				sysv3 ? "%7llu" : " %-7llu", f->f_dsize);
+	else
+		printf(" %3lu,%3lu", (long)f->f_rmajor, (long)f->f_rminor);
+	prtime(f->f_st.st_mtime);
+	printf("%s", f->f_name);
+	if ((f->f_st.st_mode&S_IFMT) == S_IFLNK)
+		printf(" -> %s", f->f_lnam);
+	if (pax != PAX_TYPE_CPIO && (f->f_st.st_mode&S_IFMT) != S_IFDIR &&
+			f->f_st.st_nlink>1) {
+		if (fmttype & TYP_TAR)
+			printf(" == %s", f->f_lnam);
+		else
+			canlink(f->f_name, &f->f_st, 0);
+	}
+	putchar('\n');
+}
+
+static int
+typec(struct stat *st)
+{
+	switch (st->st_mode&S_IFMT) {
+	case S_IFREG:
+		return '-';
+	case S_IFDIR:
+		return 'd';
+	case S_IFLNK:
+		return 'l';
+	case S_IFCHR:
+		return 'c';
+	case S_IFBLK:
+		return 'b';
+	case S_IFIFO:
+		return 'p';
+	case S_IFNWK:
+		return 'n';
+	case S_IFNAM:
+		switch (st->st_rdev) {
+		case S_INSEM:
+			return 's';
+		case S_INSHD:
+			return 'm';
+		}
+		/*FALLTHRU*/
+	default:
+		msg(-1, 0, "Impossible file type\n");
+		errcnt++;
+		return '-';
+	}
+}
+
+static void
+permbits(mode_t mode)
+{
+	mode_t	mask = 0700, shft = 6;
+
+	while (mask) {
+		if (((mode & mask) >> shft) & 04)
+			putchar('r');
+		else
+			putchar('-');
+		if (((mode & mask) >> shft) & 02)
+			putchar('w');
+		else
+			putchar('-');
+		if (mask == 0700 && mode & 04000)
+			putchar('s');
+		else if (mask == 0070 && (mode & 02010) == 02010)
+			putchar('s');
+		else if (mask == 0070 && mode & 02000)
+			putchar('l');
+		else if (mask == 0007 && mode & 01000)
+			putchar('t');
+		else if (((mode & mask) >> shft) & 01)
+			putchar('x');
+		else
+			putchar('-');
+		mask >>= 3;
+		shft -= 3;
+	}
+}
+
+static void
+prtime_cpio(time_t t)
+{
+	char	b[30];
+
+	strftime(b, sizeof b, sysv3 ? "%b %e %H:%M:%S %Y" : "%b %e %H:%M %Y",
+			localtime(&t));
+	printf(sysv3 ? "  %s  " : " %s, ", b);
+}
+
+/*
+ * Prepare path to add names of files below it later.
+ */
+static void
+getpath(const char *path, char **file, char **filend, size_t *sz, size_t *slen)
+{
+	*sz = 14 + strlen(path) + 2;
+	*file = smalloc(*sz);
+	*filend = *file;
+	if (path[0] == '/' && path[1] == '\0')
+		*(*filend)++ = '/';
+	else {
+		const char	*cp = path;
+		while ((*(*filend)++ = *cp++) != '\0');
+		(*filend)[-1] = '/';
+	}
+	*slen = *filend - *file;
+}
+
+/*
+ * Concatenate base (prepared with getpath()) and file.
+ */
+static void
+setpath(const char *base, char **file, char **filend,
+		size_t slen, size_t *sz, size_t *ss)
+{
+	if (slen + (*ss = strlen(base)) >= *sz) {
+		*sz += slen + *ss + 15;
+		*file = srealloc(*file, *sz);
+		*filend = &(*file)[slen];
+	}
+	strcpy(*filend, base);
+}
+
+/*
+ * Create intermediate directories with -m.
+ */
+static int
+imdir(char *fn)
+{
+	struct stat	st;
+	char	*cp;
+	int	dfl = dflag != 0;
+
+	for (cp = fn; *cp == '/'; cp++);
+	do {
+		while (*cp && *cp != '/')
+			cp++;
+		if (*cp == '/') {
+			*cp = '\0';
+			if (stat(fn, &st) < 0) {
+				if (dfl) {
+					if (mkdir(fn, 0777) < 0) {
+						*cp = '/';
+						emsg(-1, "Cannot create "
+							"directory for \"%s\"",
+							fn);
+						return -1;
+					}
+				} else {
+					msg(-1, 0, sysv3 ?
+						"missing 'd' option\n" :
+						"Missing -d option\n");
+					dfl = 2;
+				}
+			}
+			*cp = '/';
+			while (*cp == '/')
+				cp++;
+		}
+	} while (*cp);
+	return 0;
+}
+
+/*
+ * Set file attributes and make sure that suid/sgid bits are only restored
+ * if the owner is the same as on the tape.
+ */
+static int
+setattr(const char *fn, struct stat *st)
+{
+	mode_t	mode = st->st_mode & 07777;
+	uid_t	uid = Rflag ? Ruid : myuid;
+	gid_t	gid = Rflag ? Rgid : mygid;
+
+	if ((pax != PAX_TYPE_CPIO || myuid == 0) &&
+			(pax == PAX_TYPE_CPIO ||
+			 pax_preserve&(PAX_P_OWNER|PAX_P_EVERY))) {
+		if (setowner(fn, st) != 0)
+			return 1;
+	}
+	if (pax != PAX_TYPE_CPIO &&
+			(pax_preserve&(PAX_P_OWNER|PAX_P_EVERY)) == 0)
+		mode &= ~(mode_t)(S_ISUID|S_ISGID);
+	if (myuid != 0 || Rflag) {
+		if (st->st_uid != uid || st->st_gid != gid) {
+			mode &= ~(mode_t)S_ISUID;
+			if ((st->st_mode&S_IFMT) != S_IFDIR && mode & 0010)
+				mode &= ~(mode_t)S_ISGID;
+			if ((st->st_mode&S_IFMT) == S_IFDIR && st->st_gid!=gid)
+				mode &= ~(mode_t)S_ISGID;
+		}
+	}
+	if ((st->st_mode&S_IFMT) == S_IFLNK)
+		return 0;
+	if (hp_Uflag)
+		mode &= ~umsk|S_IFMT;
+	if (pax != PAX_TYPE_CPIO &&
+			(pax_preserve&(PAX_P_MODE|PAX_P_OWNER|PAX_P_EVERY))==0)
+		mode &= 01777|S_IFMT;
+	if ((pax == PAX_TYPE_CPIO || pax_preserve&(PAX_P_MODE|PAX_P_EVERY)) &&
+			chmod(fn, mode) < 0) {
+		emsg(2, "Cannot chmod() \"%s\"", fn);
+		return 1;
+	}
+	if (pax != PAX_TYPE_CPIO ?
+			(pax_preserve&(PAX_P_ATIME|PAX_P_MTIME|PAX_P_EVERY)) !=
+			(PAX_P_ATIME|PAX_P_MTIME) : mflag)
+		return rstime(fn, st, "modification");
+	else
+		return 0;
+}
+
+static int
+setowner(const char *fn, struct stat *st)
+{
+	uid_t	uid = Rflag ? Ruid : myuid ? myuid : st->st_uid;
+	gid_t	gid = Rflag ? Rgid : st->st_gid;
+
+	if (((st->st_mode&S_IFMT)==S_IFLNK?lchown:chown)(fn, uid, gid) < 0) {
+		emsg(2, "Cannot chown() \"%s\"", fn);
+		return 1;
+	}
+	if (pax >= PAX_TYPE_PAX2001 && myuid && myuid != st->st_uid &&
+			pax_preserve & (PAX_P_OWNER|PAX_P_EVERY)) {
+		/*
+		 * Do not even try to preserve user ownership in this case.
+		 * It would either fail, or, without _POSIX_CHOWN_RESTRICTED,
+		 * leave us with a file we do not own and which we thus could
+		 * not chmod() later.
+		 */
+		errno = EPERM;
+		emsg(2, "Cannot chown() \"%s\"", fn);
+		return 1;
+	}
+	return 0;
+}
+
+/*
+ * For -i and -p: Check if device/inode have been created already and
+ * if so, link path (or print the link name).
+ */
+static int
+canlink(const char *path, struct stat *st, int really)
+{
+	struct dslot	*ds;
+	struct islot	*ip;
+
+	ds = dfind(&devices, st->st_dev);
+	if ((ip = ifind(st->st_ino, &ds->d_isl)) == NULL ||
+			ip->i_name == NULL) {
+		if (ip == NULL) {
+			ip = scalloc(1, sizeof *ip);
+			ip->i_ino = st->st_ino;
+			if ((fmttype&(TYP_NCPIO|TYP_TAR)) == 0)
+				ip->i_nlk = st->st_nlink;
+			iput(ip, &ds->d_isl);
+		}
+		ip->i_name = sstrdup(path);
+	} else {
+		if ((fmttype&(TYP_NCPIO|TYP_TAR)) == 0) {
+			/*
+			 * If an archive inode has more links than given in
+			 * st_nlink, write a new disk inode. See the comments
+			 * to storelink() for the rationale.
+			 */
+			if (--ip->i_nlk == 0) {
+				free(ip->i_name);
+				ip->i_name = sstrdup(path);
+				ip->i_nlk = st->st_nlink;
+				return 0;
+			}
+		}
+		if (really) {
+			/*
+			 * If there was file data before the last link with
+			 * SVR4 cpio formats, do not create a hard link.
+			 */
+			if (fmttype & TYP_NCPIO && ip->i_nlk == 0)
+				return 0;
+			if (linkunlink(ip->i_name, path) == 0)
+				return 1;
+			else
+				return -1;
+		} else {
+			printf(" == %s", ip->i_name);
+			return 1;
+		}
+	}
+	return 0;
+}
+
+/*
+ * Execution for -i.
+ */
+static void
+doinp(void)
+{
+	union bincpio	bc;
+	struct file	f;
+	int	n;
+
+	memset(&f, 0, sizeof f);
+	if (Eflag)
+		patfile();
+	if (Iflag) {
+		if ((mt = open(Iflag, O_RDONLY)) < 0) {
+			if (sysv3) {
+				emsg(3, "Cannot open <%s> for input.", Iflag);
+				done(1);
+			}
+			else
+				msg(3, -2, "Cannot open \"%s\" for input\n",
+						Iflag);
+		}
+	} else
+		mt = dup(0);
+	mstat();
+	blkbuf = svalloc(blksiz, 1);
+	if ((n = mread()) == 0)
+		unexeoa();
+	else if (n < 0) {
+		emsg(3, "Read error on \"%s\"",
+			Iflag && !sysv3 ? Iflag : "input");
+		done(1);
+	}
+	if (kflag == 0 && sixflag == 0)
+		fmttype = FMT_NONE;
+	if (fmttype == FMT_NONE)
+		whathdr();
+	else
+		formatforced = 1;
+	while (readhdr(&f, &bc) == 0) {
+		if (fmttype & TYP_NCPIO && f.f_st.st_nlink > 1 &&
+				(f.f_st.st_mode&S_IFMT) != S_IFDIR) {
+			if (f.f_st.st_size != 0)
+				flushlinks(&f);
+			else
+				storelink(&f);
+		} else
+			inpone(&f, 1);
+		f.f_Kbase = f.f_Krest = f.f_Ksize = 0;
+		f.f_oflag = 0;
+	}
+	if (fmttype & TYP_NCPIO)
+		flushrest(f.f_pad);
+}
+
+/*
+ * SVR4 cpio link handling with -i; called if we assume that more links
+ * to this file will follow.
+ */
+static void
+storelink(struct file *f)
+{
+	struct dslot	*ds;
+	struct islot	*ip;
+	struct ilink	*il, *iz;
+
+	ds = dfind(&devices, f->f_st.st_dev);
+	if ((ip = ifind(f->f_st.st_ino, &ds->d_isl)) == NULL) {
+		ip = scalloc(1, sizeof *ip);
+		ip->i_ino = f->f_st.st_ino;
+		ip->i_nlk = f->f_st.st_nlink;
+		ip->i_st = smalloc(sizeof *ip->i_st);
+		*ip->i_st = f->f_st;
+		iput(ip, &ds->d_isl);
+	} else {
+		if (ip->i_nlk == 0) {
+			/*
+			 * More links to an inode than given in the first
+			 * st_nlink occurence are found within this archive.
+			 * This happens if -L was specified and soft links
+			 * point to a file with multiple hard links. We do
+			 * the same as SVR4 cpio implementations here and
+			 * associate these links with a new inode, since it
+			 * is related to the way a file with a single hard
+			 * link but referenced by soft links is unpacked.
+			 */
+			ip->i_nlk = f->f_st.st_nlink;
+			if (ip->i_name)
+				free(ip->i_name);
+			ip->i_name = NULL;
+			ip->i_st = smalloc(sizeof *ip->i_st);
+			*ip->i_st = f->f_st;
+		} else if (ip->i_nlk <= 2) {
+			/*
+			 * We get here if
+			 * - a file with multiple links is empty;
+			 * - a broken implementation has stored file data
+			 *   before the last link;
+			 * - a linked file has been added to the archive later
+			 *   again (does not happen with our implementation).
+			 */
+			flushnode(ip, f);
+			return;
+		} else
+			ip->i_nlk--;
+	}
+	for (il = ip->i_lnk, iz = NULL; il; il = il->l_nxt)
+		iz = il;
+	il = scalloc(1, sizeof *il);
+	il->l_siz = strlen(f->f_name) + 1;
+	il->l_nam = smalloc(il->l_siz);
+	strcpy(il->l_nam, f->f_name);
+	if (iz)
+		iz->l_nxt = il;
+	else
+		ip->i_lnk = il;
+}
+
+/*
+ * Flush all links of a file with SVR4 cpio format and -i.
+ */
+static void
+flushlinks(struct file *f)
+{
+	struct dslot	*ds;
+	struct islot	*ip;
+
+	ds = dfind(&devices, f->f_st.st_dev);
+	ip = ifind(f->f_st.st_ino, &ds->d_isl);
+	flushnode(ip, f);
+}
+
+/*
+ * Data of a multi-linked file shall be transferred now for SVR4 cpio
+ * format and -i.
+ */
+static void
+flushnode(struct islot *ip, struct file *f)
+{
+	struct file	nf;
+	struct ilink	*il, *iz;
+
+	f->f_dsize = f->f_st.st_size;
+	if (ip && ip->i_nlk > 0) {
+		/*
+		 * Write out the file data with the first link the user
+		 * wants to be extracted, but show the same display size
+		 * for all links.
+		 */
+		for (il = ip->i_lnk, iz = NULL; il;
+				iz = il, il = il->l_nxt, iz ? free(iz), 0 : 0) {
+			memset(&nf, 0, sizeof nf);
+			nf.f_name = il->l_nam;
+			nf.f_nsiz = il->l_siz;
+			nf.f_st = f->f_st;
+			nf.f_chksum = f->f_chksum;
+			nf.f_pad = f->f_pad;
+			nf.f_dsize = f->f_dsize;
+			if (inpone(&nf, 0) == 0) {
+				f->f_chksum = 0;
+				f->f_st.st_size = 0;
+			}
+			free(il->l_nam);
+		}
+		ip->i_lnk = NULL;
+		if (ip->i_st)
+			free(ip->i_st);
+		ip->i_st = NULL;
+	}
+	if (f->f_name)
+		inpone(f, 1);
+	if (ip) {
+		if (ip->i_nlk <= 2 && ip->i_name) {
+			free(ip->i_name);
+			ip->i_name = NULL;
+		}
+		ip->i_nlk = 0;
+	}
+}
+
+/*
+ * This writes all remaining multiply linked files, i. e. those with
+ * st_size == 0 and st_nlink > number of links within the archive.
+ */
+static void
+flushrest(int pad)
+{
+	struct dslot	*ds;
+
+	for (ds = devices; ds; ds = ds->d_nxt)
+		if (ds->d_isl != NULL)
+			flushtree(ds->d_isl, pad);
+}
+
+static void
+flushtree(struct islot *ip, int pad)
+{
+	struct file	f;
+
+	if (ip == inull)
+		return;
+	flushtree(ip->i_lln, pad);
+	flushtree(ip->i_rln, pad);
+	if (ip->i_nlk > 0 && ip->i_st) {
+		memset(&f, 0, sizeof f);
+		f.f_st = *ip->i_st;
+		f.f_pad = pad;
+		flushnode(ip, &f);
+	}
+}
+
+/*
+ * See if the user wants to have this file with -i, and extract it or
+ * skip its data on the tape.
+ */
+static int
+inpone(struct file *f, int shallskip)
+{
+	struct glist	*gp = NULL, *gb = NULL;
+	int	val = -1, selected = 0;
+
+	if ((patterns == NULL || (gp = want(f, &gb)) != NULL ^ fflag) &&
+			pax_track(f->f_name, f->f_st.st_mtime)) {
+		selected = 1;
+		if ((pax_sflag == 0 || pax_sname(&f->f_name, &f->f_nsiz)) &&
+				(rflag == 0 || rname(&f->f_name, &f->f_nsiz))) {
+			errcnt += infile(f);
+			val = 0;
+		}
+	} else if (shallskip)
+		errcnt += skipfile(f);
+	if (gp != NULL && selected) {
+		gp->g_gotcha = 1;
+		if (gp->g_nxt && gp->g_nxt->g_art)
+			gp->g_nxt->g_gotcha = 1;
+		else if (gp->g_art && gb)
+			gb->g_gotcha = 1;
+	}
+	return val;
+}
+
+/*
+ * Read the header for a file with -i. Return values: 0 okay, 1 end of
+ * archive, -1 failure.
+ */
+static int
+readhdr(struct file *f, union bincpio *bp)
+{
+	long	namlen, l1, l2, rd, hsz;
+	static long	attempts;
+	long long	skipped = 0;
+
+	if (fmttype & TYP_TAR) {
+		if (f->f_name)
+			f->f_name[0] = '\0';
+		if (f->f_lnam)
+			f->f_lnam[0] = '\0';
+	}
+	paxrec = globrec;
+retry:	f->f_st = globst;
+retry2:	if (fmttype & TYP_BINARY) {
+		hsz = SIZEOF_hdr_cpio;
+		if (attempts == 0 && bread(bp->data, hsz) != hsz)
+			unexeoa();
+		if ((fmttype&TYP_BE ? pbe16(bp->Hdr.c_magic) :
+				ple16(bp->Hdr.c_magic)) != mag_bin)
+			goto badhdr;
+		if (fmttype & TYP_BE) {
+			f->f_st.st_dev = pbe16(bp->Hdr.c_dev)&0177777;
+			f->f_st.st_ino = pbe16(bp->Hdr.c_ino)&0177777;
+			f->f_st.st_mode = pbe16(bp->Hdr.c_mode);
+		} else {
+			f->f_st.st_dev = ple16(bp->Hdr.c_dev)&0177777;
+			f->f_st.st_ino = ple16(bp->Hdr.c_ino)&0177777;
+			f->f_st.st_mode = ple16(bp->Hdr.c_mode);
+		}
+		if (sixflag) {
+			/*
+			 * relevant Unix 6th Edition style mode bits
+			 * (according to /usr/sys/inode.h, untested:)
+			 *
+			 * 060000	IFMT	type of file
+			 * 040000	IFDIR	directory
+			 * 020000	IFCHR	character special
+			 * 060000	IFBLK	block special, 0 is regular
+			 * 007777		permission bits as today
+			 */
+			f->f_st.st_mode &= 067777;
+			if ((f->f_st.st_mode & 060000) == 0)
+				f->f_st.st_mode |= S_IFREG;
+		}
+		if (fmttype & TYP_BE) {
+			f->f_st.st_uid = pbe16(bp->Hdr.c_uid)&0177777;
+			f->f_st.st_gid = pbe16(bp->Hdr.c_gid)&0177777;
+			f->f_st.st_nlink = pbe16(bp->Hdr.c_nlink)&0177777;
+			f->f_st.st_mtime = pbe32(bp->Hdr.c_mtime);
+			f->f_st.st_rdev = pbe16(bp->Hdr.c_rdev);
+			namlen = pbe16(bp->Hdr.c_namesize);
+			f->f_st.st_size = pbe32(bp->Hdr.c_filesize)&0xFFFFFFFF;
+		} else {
+			f->f_st.st_uid = ple16(bp->Hdr.c_uid)&0177777;
+			f->f_st.st_gid = ple16(bp->Hdr.c_gid)&0177777;
+			f->f_st.st_nlink = ple16(bp->Hdr.c_nlink)&0177777;
+			f->f_st.st_mtime = pme32(bp->Hdr.c_mtime);
+			f->f_st.st_rdev = ple16(bp->Hdr.c_rdev);
+			namlen = ple16(bp->Hdr.c_namesize);
+			f->f_st.st_size = pme32(bp->Hdr.c_filesize)&0xFFFFFFFF;
+		}
+		f->f_rmajor = major(f->f_st.st_rdev);
+		f->f_rminor = minor(f->f_st.st_rdev);
+		if ((f->f_st.st_rdev&0xFFFF) == 0xFFFF &&
+				f->f_st.st_size > 0 &&
+				((f->f_st.st_mode&S_IFMT) == S_IFBLK ||
+				 (f->f_st.st_mode&S_IFMT) == S_IFCHR &&
+				 (!formatforced || fmttype & TYP_SGI))) {
+			fmttype |= TYP_SGI;
+			f->f_rmajor = (f->f_st.st_size&0xFFFC0000)>>18;
+			f->f_rminor = f->f_st.st_size&0x0003FFFF;
+			f->f_st.st_rdev = makedev(f->f_rmajor, f->f_rminor);
+			f->f_st.st_size = 0;
+		}
+		if ((f->f_st.st_mode&S_IFMT) == S_IFREG &&
+				f->f_st.st_size&0x80000000 &&
+				(!formatforced || fmttype & TYP_SGI)) {
+			fmttype |= TYP_SGI;
+			f->f_Ksize = f->f_st.st_size&0xFFFFFFFF;
+			f->f_Kbase = (0x100000000LL-f->f_st.st_size) *
+				0x80000000;
+			f->f_st.st_size = 0;
+		}
+		f->f_pad = 2;
+		rd = SIZEOF_hdr_cpio;
+	} else if (fmttype == FMT_ODC) {
+		hsz = SIZEOF_c_hdr;
+		if (attempts == 0 && bread(bp->data, hsz) != hsz)
+			unexeoa();
+		if(memcmp(bp->Cdr.c_magic, mag_odc, sizeof mag_odc))
+			goto badhdr;
+		f->f_st.st_dev = rdoct(bp->Cdr.c_dev, 6);
+		f->f_st.st_ino = rdoct(bp->Cdr.c_ino, 6);
+		f->f_st.st_mode = rdoct(bp->Cdr.c_mode, 6);
+		f->f_st.st_uid = rdoct(bp->Cdr.c_uid, 6);
+		f->f_st.st_gid = rdoct(bp->Cdr.c_gid, 6);
+		f->f_st.st_nlink = rdoct(bp->Cdr.c_nlink, 6);
+		f->f_st.st_rdev = rdoct(bp->Cdr.c_rdev, 6);
+		f->f_rmajor = major(f->f_st.st_rdev);
+		f->f_rminor = minor(f->f_st.st_rdev);
+		f->f_st.st_mtime = rdoct(bp->Cdr.c_mtime, 11);
+		namlen = rdoct(bp->Cdr.c_namesz, 6);
+		f->f_st.st_size = rdoct(bp->Cdr.c_filesz, 11);
+		f->f_pad = 1;
+		rd = SIZEOF_c_hdr;
+	} else if (fmttype == FMT_DEC) {
+		hsz = SIZEOF_d_hdr;
+		if (attempts == 0 && bread(bp->data, hsz) != hsz)
+			unexeoa();
+		if(memcmp(bp->Ddr.d_magic, mag_odc, sizeof mag_odc))
+			goto badhdr;
+		f->f_st.st_dev = rdoct(bp->Ddr.d_dev, 6);
+		f->f_st.st_ino = rdoct(bp->Ddr.d_ino, 6);
+		f->f_st.st_mode = rdoct(bp->Ddr.d_mode, 6);
+		f->f_st.st_uid = rdoct(bp->Ddr.d_uid, 6);
+		f->f_st.st_gid = rdoct(bp->Ddr.d_gid, 6);
+		f->f_st.st_nlink = rdoct(bp->Ddr.d_nlink, 6);
+		f->f_rmajor = rdoct(bp->Ddr.d_rmaj, 8);
+		f->f_rminor = rdoct(bp->Ddr.d_rmin, 8);
+		f->f_st.st_rdev = makedev(f->f_rmajor, f->f_rminor);
+		f->f_st.st_mtime = rdoct(bp->Ddr.d_mtime, 11);
+		namlen = rdoct(bp->Ddr.d_namesz, 6);
+		f->f_st.st_size = rdoct(bp->Ddr.d_filesz, 11);
+		f->f_pad = 1;
+		rd = SIZEOF_d_hdr;
+	} else if (fmttype & TYP_NCPIO) {
+		hsz = SIZEOF_Exp_cpio_hdr;
+		if (attempts == 0 && bread(bp->data, hsz) != hsz)
+			unexeoa();
+		if (memcmp(bp->Edr.E_magic, mag_asc, sizeof mag_asc) &&
+		    memcmp(bp->Edr.E_magic, mag_crc, sizeof mag_crc))
+			goto badhdr;
+		f->f_st.st_ino = rdhex(bp->Edr.E_ino, 8);
+		f->f_st.st_mode = rdhex(bp->Edr.E_mode, 8);
+		f->f_st.st_uid = rdhex(bp->Edr.E_uid, 8);
+		f->f_st.st_gid = rdhex(bp->Edr.E_gid, 8);
+		f->f_st.st_nlink = rdhex(bp->Edr.E_nlink, 8);
+		f->f_st.st_mtime = rdhex(bp->Edr.E_mtime, 8);
+		f->f_st.st_size = rdhex(bp->Edr.E_filesize, 8);
+		l1 = rdhex(bp->Edr.E_maj, 8);
+		l2 = rdhex(bp->Edr.E_min, 8);
+		f->f_st.st_dev = makedev(l1, l2);
+		f->f_rmajor = rdhex(bp->Edr.E_rmaj, 8);
+		f->f_rminor = rdhex(bp->Edr.E_rmin, 8);
+		f->f_st.st_rdev = makedev(f->f_rmajor, f->f_rminor);
+		namlen = rdhex(bp->Edr.E_namesize, 8);
+		f->f_chksum = rdhex(bp->Edr.E_chksum, 8);
+		f->f_pad = 4;
+		rd = SIZEOF_Exp_cpio_hdr;
+	} else if (fmttype & TYP_CRAY) {
+		int	diff5 = fmttype==FMT_CRAY5 ? CRAY_PARAMSZ : 0;
+		hsz = SIZEOF_cray_hdr - diff5;
+		if (attempts == 0 && bread(bp->data, hsz) != hsz)
+			unexeoa();
+		if (pbe64(bp->Crayhdr.C_magic) != mag_bin)
+			goto badhdr;
+		f->f_st.st_dev = pbe64(bp->Crayhdr.C_dev);
+		f->f_st.st_ino = pbe64(bp->Crayhdr.C_ino);
+		f->f_st.st_mode = pbe64(bp->Crayhdr.C_mode);
+		/*
+		 * Some of the S_IFMT bits on Cray UNICOS 9 differ from
+		 * the common Unix values, namely:
+		 *
+		 * S_IFLNK	0130000		symbolic link
+		 * S_IFOFD	0110000		off line, with data
+		 * S_IFOFL	0120000		off line, with no data
+		 *
+		 * We treat the latter ones as regular files.
+		 */
+		if ((f->f_st.st_mode&S_IFMT) == 0130000)
+			f->f_st.st_mode = f->f_st.st_mode&07777|S_IFLNK;
+		else if ((f->f_st.st_mode&S_IFMT) == 0110000 ||
+				(f->f_st.st_mode&S_IFMT) == 0120000)
+			f->f_st.st_mode = f->f_st.st_mode&07777|S_IFREG;
+		f->f_st.st_uid = pbe64(bp->Crayhdr.C_uid);
+		f->f_st.st_gid = pbe64(bp->Crayhdr.C_gid);
+		f->f_st.st_nlink = pbe64(bp->Crayhdr.C_nlink);
+		f->f_st.st_mtime = pbe64(bp->Crayhdr.C_mtime - diff5);
+		f->f_st.st_rdev = pbe64(bp->Crayhdr.C_rdev);
+		f->f_rmajor = major(f->f_st.st_rdev);
+		f->f_rminor = minor(f->f_st.st_rdev);
+		f->f_st.st_size = pbe64(bp->Crayhdr.C_filesize - diff5);
+		namlen = pbe64(bp->Crayhdr.C_namesize - diff5);
+		f->f_pad = 1;
+		rd = SIZEOF_cray_hdr - diff5;
+	} else if (fmttype & TYP_BAR) {
+		hsz = 512;
+		if (attempts == 0 && bread(bp->data, hsz) != hsz)
+			unexeoa();
+		if (bp->data[SIZEOF_bar_header] == '\0') {
+			if (kflag && !allzero(bp->data, hsz))
+				goto badhdr;
+			return 1;
+		}
+		if (trdsum(bp) != 0 && kflag == 0)
+			goto badhdr;
+		bp->data[512] = bp->data[513] = '\0';
+		if (f->f_name == NULL || f->f_name[0] == '\0') {
+			if (f->f_nsiz < 512) {
+				free(f->f_name);
+				f->f_name = smalloc(f->f_nsiz = 512);
+			}
+			strcpy(f->f_name, &bp->data[SIZEOF_bar_header]);
+		}
+		namlen = strlen(f->f_name) + 1;
+		f->f_st.st_mode = rdoct(bp->Bdr.b_mode, 8);
+		f->f_st.st_uid = rdoct(bp->Bdr.b_uid, 8);
+		f->f_st.st_gid = rdoct(bp->Bdr.b_gid, 8);
+		f->f_st.st_size = rdoct(bp->Bdr.b_size, 12);
+		f->f_st.st_mtime = rdoct(bp->Bdr.b_mtime, 12);
+		f->f_st.st_rdev = rdoct(bp->Bdr.b_rdev, 8);
+		f->f_rmajor = major(f->f_st.st_rdev);
+		f->f_rminor = minor(f->f_st.st_rdev);
+		switch (bp->Bdr.b_linkflag) {
+		case '0':
+			f->f_st.st_mode &= 07777;
+			if (f->f_name[namlen-2] == '/')
+				f->f_st.st_mode |= S_IFDIR;
+			else
+				f->f_st.st_mode |= S_IFREG;
+			break;
+		case '1':
+			if (f->f_lnam == NULL || f->f_lnam[0] == '\0')
+				blinkof(bp->data, f, namlen);
+			f->f_st.st_nlink = 2;
+			if ((f->f_st.st_mode&S_IFMT) == 0)
+				f->f_st.st_mode |= S_IFREG;
+			break;
+		case '2':
+			if (f->f_lnam == NULL || f->f_lnam[0] == '\0')
+				blinkof(bp->data, f, namlen);
+			f->f_st.st_mode &= 07777;
+			f->f_st.st_mode |= S_IFLNK;
+		}
+		f->f_pad = 512;
+		rd = 512;
+	} else if (fmttype & TYP_TAR) {
+		hsz = 512;
+		if (attempts == 0 && bread(bp->data, hsz) != hsz)
+			unexeoa();
+		if (bp->Tdr.t_name[0] == '\0') {
+			if (kflag && !allzero(bp->data, hsz))
+				goto badhdr;
+			return 1;
+		}
+		if (fmttype == FMT_GNUTAR) {
+			if (memcmp(bp->Tdr.t_magic, mag_gnutar, 8))
+				goto badhdr;
+		} else if (fmttype & TYP_USTAR) {
+			if (memcmp(bp->Tdr.t_magic, mag_ustar, 6))
+				goto badhdr;
+		}
+		if (trdsum(bp) != 0 && kflag == 0)
+			goto badhdr;
+		if ((fmttype & TYP_PAX) == 0 && (fmttype == FMT_GNUTAR ||
+				strcmp(bp->Tdr.t_name, "././@LongLink") == 0)) {
+			switch (bp->Tdr.t_linkflag) {
+			case 'L':
+				if (readgnuname(&f->f_name, &f->f_nsiz,
+						rdoct(bp->Tdr.t_size, 12)) < 0)
+					goto badhdr;
+				goto retry;
+			case 'K':
+				if (readgnuname(&f->f_lnam, &f->f_lsiz,
+						rdoct(bp->Tdr.t_size, 12)) < 0)
+					goto badhdr;
+				goto retry;
+			}
+		}
+		if (fmttype & TYP_USTAR && fmttype != FMT_GNUTAR) {
+			switch (bp->Tdr.t_linkflag) {
+			case 'g':
+			case 'x':
+				if (formatforced && fmttype != FMT_PAX)
+					break;
+				fmttype = FMT_PAX;
+				tgetpax(&bp->Tdr, f);
+				goto retry2;
+			case 'X':
+				if (formatforced && fmttype != FMT_SUN)
+					break;
+				fmttype = FMT_SUN;
+				tgetpax(&bp->Tdr, f);
+				goto retry2;
+			}
+		}
+		if (f->f_name == NULL || f->f_name[0] == '\0') {
+			if (f->f_nsiz < TNAMSIZ+TPFXSIZ+2) {
+				free(f->f_name);
+				f->f_name= smalloc(f->f_nsiz=TNAMSIZ+TPFXSIZ+2);
+			}
+			tnameof(&bp->Tdr, f->f_name);
+		}
+		namlen = strlen(f->f_name) + 1;
+		f->f_st.st_mode = rdoct(bp->Tdr.t_mode, 8) & 07777;
+		if (paxrec & PR_UID)
+			/*EMPTY*/;
+		else if (fmttype == FMT_GNUTAR && bp->Tdr.t_uid[0] & 0200)
+			f->f_st.st_uid = pbe64(bp->Tdr.t_uid) &
+				0x7FFFFFFFFFFFFFFFLL;
+		else
+			f->f_st.st_uid = rdoct(bp->Tdr.t_uid, 8);
+		if (paxrec & PR_GID)
+			/*EMPTY*/;
+		else if (fmttype == FMT_GNUTAR && bp->Tdr.t_gid[0] & 0200)
+			f->f_st.st_gid = pbe64(bp->Tdr.t_gid) &
+				0x7FFFFFFFFFFFFFFFLL;
+		else
+			f->f_st.st_gid = rdoct(bp->Tdr.t_gid, 8);
+		if (paxrec & PR_SIZE)
+			/*EMPTY*/;
+		else if (fmttype == FMT_GNUTAR && bp->Tdr.t_size[0] == '\200')
+			f->f_st.st_size = pbe64(&bp->Tdr.t_size[4]);
+		else
+			f->f_st.st_size = rdoct(bp->Tdr.t_size, 12);
+		if ((paxrec & PR_MTIME) == 0)
+			f->f_st.st_mtime = rdoct(bp->Tdr.t_mtime, TTIMSIZ);
+		if (bp->Tdr.t_linkflag == '1') {
+			if (f->f_lnam == NULL || f->f_lnam[0] == '\0')
+				tlinkof(&bp->Tdr, f);
+			f->f_st.st_mode |= S_IFREG;	/* for -tv */
+			f->f_st.st_nlink = 2;
+		} else if (bp->Tdr.t_linkflag == '2') {
+			if (f->f_lnam == NULL || f->f_lnam[0] == '\0')
+				tlinkof(&bp->Tdr, f);
+			f->f_st.st_mode |= S_IFLNK;
+		} else if (tflag == 0 && (f->f_name)[namlen-2] == '/')
+			f->f_st.st_mode |= S_IFDIR;
+		else
+			f->f_st.st_mode |= tifmt(bp->Tdr.t_linkflag);
+		if (paxrec & PR_SUN_DEVMAJOR)
+			/*EMPTY*/;
+		else if (fmttype == FMT_GNUTAR && bp->Tdr.t_devmajor[0] & 0200)
+			f->f_rmajor = pbe64(bp->Tdr.t_devmajor) &
+				0x7FFFFFFFFFFFFFFFLL;
+		else
+			f->f_rmajor = rdoct(bp->Tdr.t_devmajor, 8);
+		if (paxrec & PR_SUN_DEVMINOR)
+			/*EMPTY*/;
+		else if (fmttype == FMT_GNUTAR && bp->Tdr.t_devminor[0] & 0200)
+			f->f_rminor = pbe64(bp->Tdr.t_devminor) &
+				0x7FFFFFFFFFFFFFFFLL;
+		else
+			f->f_rminor = rdoct(bp->Tdr.t_devminor, 8);
+		f->f_st.st_rdev = makedev(f->f_rmajor, f->f_rminor);
+		f->f_pad = 512;
+		rd = 512;
+	} else if (fmttype == FMT_ZIP) {
+		hsz = SIZEOF_zip_header;
+		if (attempts == 0 && bread(bp->data, hsz) != hsz)
+			unexeoa();
+		if (memcmp(bp->Zdr.z_signature, mag_zipctr,
+					sizeof mag_zipctr) == 0 ||
+				memcmp(bp->Zdr.z_signature, mag_zipend,
+					sizeof mag_zipend) == 0 ||
+				memcmp(bp->Zdr.z_signature, mag_zip64e,
+					sizeof mag_zip64e) == 0 ||
+				memcmp(bp->Zdr.z_signature, mag_zip64l,
+					sizeof mag_zip64l) == 0)
+			return 1;
+		if (memcmp(bp->Zdr.z_signature, mag_zipsig, sizeof mag_zipsig))
+			goto badhdr;
+		f->f_st.st_uid = myuid;
+		f->f_st.st_gid = mygid;
+		f->f_st.st_nlink = 1;
+		f->f_st.st_mtime =
+			gdostime(bp->Zdr.z_modtime, bp->Zdr.z_moddate);
+		f->f_st.st_size = ple32(bp->Zdr.z_nsize);
+		f->f_csize = ple32(bp->Zdr.z_csize);
+		f->f_cmethod = ple16(bp->Zdr.z_cmethod);
+		f->f_chksum = ple32(bp->Zdr.z_crc32);
+		f->f_gflag = ple16(bp->Zdr.z_gflag);
+		rd = SIZEOF_zip_header;
+		namlen = ple16(bp->Zdr.z_namelen)&0177777;
+		if (f->f_nsiz < namlen+1) {
+			free(f->f_name);
+			f->f_name = smalloc(f->f_nsiz = namlen+1);
+		}
+		if (bread(f->f_name, namlen) != namlen)
+			goto corrupt;
+		(f->f_name)[namlen] = '\0';
+		if (f->f_name[namlen-1] == '/')
+			f->f_st.st_mode = 0777&~(mode_t)umsk|S_IFDIR;
+		else
+			f->f_st.st_mode = 0666&~(mode_t)umsk|S_IFREG;
+		rd += namlen;
+		if ((l1 = ziprxtra(f, &bp->Zdr)) < 0)
+			goto corrupt;
+		rd += l1;
+		f->f_pad = 1;
+	} else
+		abort();
+	if (fmttype & TYP_CPIO) {
+		if (f->f_st.st_nlink <= 0 || namlen <= 0 || namlen >= SANELIMIT)
+			goto corrupt;
+		if (namlen > f->f_nsiz) {
+			if (f->f_name)
+				free(f->f_name);
+			f->f_name = smalloc(f->f_nsiz = namlen);
+		}
+		if (bread(f->f_name, namlen) != namlen)
+			unexeoa();
+		if (f->f_name[namlen-1] != '\0')
+			goto corrupt;
+		rd += namlen;
+		skippad(rd, f->f_pad);
+		if (fmttype & TYP_NCPIO &&
+				(!formatforced || fmttype & TYP_SCO)) {
+			/*
+			 * The UnixWare format is a hack, but not a bad
+			 * one. It is backwards compatible as far as
+			 * possible; old implementations can use the -k
+			 * option and will then get only the beginning
+			 * of a large file, but all other files in the
+			 * archive.
+			 */
+			if (namlen >= 24 && memcmp(&f->f_name[namlen-23],
+						"\0size=", 6) == 0) {
+				fmttype |= TYP_SCO;
+				f->f_st.st_size = rdhex(&f->f_name[namlen-17],
+						16);
+			}
+		}
+	}
+	if (attempts) {
+		if (tflag)
+			fflush(stdout);
+		msg(0, 0, sysv3 < 0 ?
+			"Re-synced after skipping %lld bytes.\n" :
+			"Re-synchronized on magic number/header.\n",
+			skipped);
+	}
+	attempts = 0;
+	if (f->f_st.st_atime == 0 || (pax_preserve&(PAX_P_ATIME|PAX_P_EVERY)) ==
+			PAX_P_ATIME)
+		f->f_st.st_atime = f->f_st.st_mtime;
+	if ((f->f_dsize = f->f_st.st_size) < 0)
+		goto badhdr;
+	if (fmttype & TYP_CPIO && strcmp(f->f_name, trailer) == 0)
+		return 1;
+	return 0;
+corrupt:
+	if (kflag) {
+		if (tflag)
+			fflush(stdout);
+		msg(3, 0, "Corrupt header, file(s) may be lost.\n");
+	}
+badhdr:
+	if (kflag) {
+		int	next = fmttype & TYP_TAR ? 512 : 1;
+		if (attempts++ == 0) {
+			if (tflag)
+				fflush(stdout);
+			msg(1, 0, sysv3 < 0 ? "Out of phase; resyncing.\n" :
+				"Searching for magic number/header.\n");
+			errcnt++;
+		}
+		for (l1 = next; l1 < hsz; l1++)
+			bp->data[l1-next] = bp->data[l1];
+		if (bread(&bp->data[l1-next], next) != next)
+			unexeoa();
+		skipped++;
+		goto retry;
+	}
+	if (tflag)
+		fflush(stdout);
+	msg(3, 1, sysv3 < 0 ? "Out of phase--get help\n" :
+			sysv3 > 0 ? "Out of sync, bad magic number/header.\n" :
+			"Bad magic number/header.\n");
+	/*NOTREACHED*/
+	return -1;
+}
+
+/*
+ * Determine the kind of archive on tape.
+ */
+static void
+whathdr(void)
+{
+again:	if (blktop >= SIZEOF_hdr_cpio &&
+			ple16(blkbuf) == mag_bin) {
+		fmttype = FMT_BINLE;
+	} else if (blktop >= SIZEOF_hdr_cpio &&
+			pbe16(blkbuf) == mag_bin) {
+		fmttype = FMT_BINBE;
+	} else if (blktop >= SIZEOF_c_hdr &&
+			memcmp(blkbuf, mag_odc, sizeof mag_odc) == 0) {
+		/*
+		 * The DEC format is rubbish. Instead of introducing a new
+		 * archive magic, its engineers reused the POSIX/odc magic
+		 * and changed the fields. But there's a workaround: For a
+		 * real odc archive, the byte following the file name is a
+		 * \0 byte (unless the archive is damaged, of course). If
+		 * it is not a \0 byte, but a \0 byte appears at the
+		 * corresponding location for the DEC format, this is
+		 * treated as a DEC archive. It must be noted that the
+		 * Tru64 UNIX 5.1 cpio command is too stupid even for
+		 * doing that - it will spill out a list of complaints
+		 * if an extended archive is read but -e is not given.
+		 */
+		int	ns1, ns2;
+		ns1 = rdoct(((struct c_hdr *)blkbuf)->c_namesz, 6);
+		ns2 = rdoct(((struct d_hdr *)blkbuf)->d_namesz, 6);
+		if (blktop >= SIZEOF_d_hdr &&
+				(ns1 >= blktop - SIZEOF_c_hdr ||
+				 blkbuf[SIZEOF_c_hdr+ns1-1] != '\0') &&
+				ns2 <= blktop - SIZEOF_d_hdr &&
+				blkbuf[SIZEOF_d_hdr+ns2-1] == '\0')
+			fmttype = FMT_DEC;
+		else
+			fmttype = FMT_ODC;
+	} else if (blktop >= SIZEOF_Exp_cpio_hdr &&
+			memcmp(blkbuf, mag_asc, sizeof mag_asc) == 0) {
+		fmttype = FMT_ASC;
+	} else if (blktop >= SIZEOF_Exp_cpio_hdr &&
+			memcmp(blkbuf, mag_crc, sizeof mag_crc) == 0) {
+		fmttype = FMT_CRC;
+	} else if (blktop >= SIZEOF_cray_hdr &&
+			pbe64(blkbuf) == mag_bin) {
+		/*
+		 * Old and new Cray headers are identical in the first
+		 * 64 header bytes (including the magic). cpio(5) on
+		 * UNICOS does not describe what the new param field
+		 * is for.
+		 *
+		 * An archive is treated as old format if the mtime
+		 * and namesize fields make sense and all characters
+		 * of the name are non-null.
+		 */
+		struct cray_hdr	*Cp = (struct cray_hdr *)blkbuf;
+		long long	mtime, namesize;
+		fmttype = FMT_CRAY;
+		mtime = pbe64(Cp->C_mtime - CRAY_PARAMSZ);
+		namesize = pbe64(Cp->C_namesize - CRAY_PARAMSZ);
+		if (mtime > 0 && mtime < (1LL<<31) &&
+				namesize > 0 && namesize < 2048 &&
+				blktop > SIZEOF_cray_hdr-
+					CRAY_PARAMSZ+namesize+1) {
+			int	i;
+			for (i = 0; i < namesize; i++)
+				if (blkbuf[SIZEOF_cray_hdr-
+						CRAY_PARAMSZ+i] == '\0')
+					break;
+			if (i == namesize-1)
+				fmttype = FMT_CRAY5;
+		}
+	} else if (blktop >= 512 &&
+			memcmp(&blkbuf[257], mag_ustar, 6) == 0 &&
+			tcssum((union bincpio *)blkbuf, 1) == 0) {
+		fmttype = FMT_USTAR;
+	} else if (blktop >= 512 &&
+			memcmp(&blkbuf[257], mag_gnutar, 8) == 0 &&
+			tcssum((union bincpio *)blkbuf, 1) == 0) {
+		fmttype = FMT_GNUTAR;
+	} else if (blktop >= 512 && blkbuf[0] &&	/* require filename
+							   to avoid match on
+							   /dev/zero etc. */
+			memcmp(&blkbuf[257], "\0\0\0\0\0", 5) == 0 &&
+			tcssum((union bincpio *)blkbuf, 0) == 0) {
+		fmttype = FMT_OTAR;
+	} else if (blktop >= SIZEOF_zip_header &&
+			(memcmp(blkbuf, mag_zipctr, sizeof mag_zipctr) == 0 ||
+			 memcmp(blkbuf, mag_zipsig, sizeof mag_zipsig) == 0 ||
+			 memcmp(blkbuf, mag_zipend, sizeof mag_zipend) == 0 ||
+			 memcmp(blkbuf, mag_zip64e, sizeof mag_zip64e) == 0 ||
+			 memcmp(blkbuf, mag_zip64l, sizeof mag_zip64l) == 0)) {
+		fmttype = FMT_ZIP;
+	} else if (blktop >= 512 && memcmp(blkbuf,"\0\0\0\0\0\0\0\0",8) == 0 &&
+			memcmp(&blkbuf[65], mag_bar, sizeof mag_bar) == 0 &&
+			bcssum((union bincpio *)blkbuf) == 0) {
+		fmttype = FMT_BAR;
+		compressed_bar = blkbuf[71] == '1';
+		curpos = 512;
+	} else if (!Aflag && blktop > 3 && memcmp(blkbuf, "BZh", 3) == 0 &&
+			redirect("bzip2", "-cd") == 0) {
+		goto zip;
+	} else if (!Aflag && blktop > 2 && memcmp(blkbuf, "\37\235", 2) == 0 &&
+			redirect("zcat", NULL) == 0) {
+		goto zip;
+	} else if (!Aflag && blktop > 2 && memcmp(blkbuf, "\37\213", 2) == 0 &&
+			redirect("gzip", "-cd") == 0) {
+		goto zip;
+	} else if (!Aflag && blktop > 4 &&
+			memcmp(blkbuf, "\355\253\356\333", 4) == 0 &&
+			redirect("rpm2cpio", "-") == 0) {
+		goto zip;
+	} else {
+		msg(3, 0, sysv3 ? "This is not a cpio file, bad header.\n" :
+				"Not a cpio file, bad header.\n");
+		done(1);
+	}
+	return;
+zip:
+	blktop = curpos = 0;
+	blocks = 0;
+	bytes = 0;
+	mfl = 0;
+	mstat();
+	if (mread() == 0)
+		unexeoa();
+	goto again;
+}
+
+/*
+ * Processing of a single file with -i.
+ */
+static int
+infile(struct file *f)
+{
+	int	val;
+
+	if ((fmttype & TYP_CPIO || fmttype == FMT_ZIP && f->f_st.st_size) &&
+			(f->f_st.st_mode&S_IFMT) == S_IFLNK) {
+		if (f->f_lsiz < f->f_st.st_size+1)
+			f->f_lnam = srealloc(f->f_lnam,
+					f->f_lsiz = f->f_st.st_size+1);
+		if (bread(f->f_lnam, f->f_st.st_size) != f->f_st.st_size)
+			unexeoa();
+		f->f_lnam[f->f_st.st_size] = '\0';
+		skippad(f->f_st.st_size, f->f_pad);
+	}
+	if (tflag)
+		val = filet(f, indata);
+	else
+		val = filein(f, indata, f->f_name);
+	return val != 0;
+}
+
+/*
+ * Fetch the data of regular files from tape and write it to tfd or, if
+ * tfd < 0, discard it.
+ */
+static int
+indata(struct file *f, const char *tgt, int tfd)
+{
+	char	*buf;
+	size_t	bufsize;
+	struct stat	ts;
+	long long	size;
+	ssize_t	rd;
+	uint32_t	ssum = 0, usum = 0;
+	int	val = 0;
+	int	doswap = 0;
+
+	size = fmttype == FMT_ZIP ? f->f_csize :
+		f->f_Kbase ? f->f_Kbase : f->f_st.st_size;
+	doswap = ((bflag|sflag) == 0 ||
+			ckodd(size, 2, "bytes", f->f_name) == 0) &
+		((bflag|Sflag) == 0 ||
+			 ckodd(size, 4, "halfwords", f->f_name) == 0) &
+		(bflag|sflag|Sflag);
+	if (fmttype == FMT_ZIP && f->f_cmethod != C_STORED)
+		return zipread(f, tgt, tfd, doswap);
+	if (tfd < 0 || fstat(tfd, &ts) < 0)
+		ts.st_blksize = 4096;
+	getbuf(&buf, &bufsize, ts.st_blksize);
+again:	while (size) {
+		if ((rd = bread(buf, size > bufsize ? bufsize : size)) <= 0)
+			unexeoa();
+		if (doswap)
+			swap(buf, rd, bflag || sflag, bflag || Sflag);
+		if (tfd >= 0 && write(tfd, buf, rd) != rd) {
+			emsg(3, "Cannot write \"%s\"", tgt);
+			tfd = -1;
+			val = -1;
+		}
+		size -= rd;
+		if (fmttype & TYP_CRC)
+			do {
+				rd--;
+				ssum += ((signed char *)buf)[rd];
+				usum += ((unsigned char *)buf)[rd];
+			} while (rd);
+	}
+	if (f->f_Kbase) {
+		skippad(f->f_Ksize, f->f_pad);
+		readK2hdr(f);
+		size = f->f_Krest;
+		goto again;
+	}
+	skippad(fmttype==FMT_ZIP ? f->f_csize :
+			f->f_Ksize ? f->f_Krest : f->f_st.st_size, f->f_pad);
+	if (fmttype & TYP_CRC) {
+		if (f->f_chksum != ssum && f->f_chksum != usum) {
+			msg(3, 0, "\"%s\" - checksum error\n", f->f_name);
+			if (kflag)
+				errcnt++;
+			else
+				val = -1;
+		}
+	}
+	return val;
+}
+
+/*
+ * Skip the data for a file on tape.
+ */
+static int
+skipfile(struct file *f)
+{
+	char	b[4096];
+	long long	size;
+	ssize_t	rd;
+
+	if (fmttype & TYP_TAR && ((f->f_st.st_mode&S_IFMT) == S_IFLNK ||
+			f->f_st.st_nlink > 1)) {
+		if (fmttype & TYP_USTAR && (!formatforced ||
+				fmttype == FMT_PAX) &&
+				f->f_st.st_nlink > 1 &&
+				f->f_st.st_size > 0)
+			/*EMPTY*/;
+		else
+			return 0;
+	}
+	/*
+	 * SVR4 cpio derivatives always ignore the size of these,
+	 * even if not reading tar formats. We do the same for now,
+	 * although POSIX (for -H odc format) says the contrary.
+	 */
+	if (fmttype != FMT_ZIP && ((f->f_st.st_mode&S_IFMT) == S_IFDIR ||
+			(f->f_st.st_mode&S_IFMT) == S_IFCHR ||
+			(f->f_st.st_mode&S_IFMT) == S_IFBLK ||
+			(f->f_st.st_mode&S_IFMT) == S_IFIFO ||
+			(f->f_st.st_mode&S_IFMT) == S_IFNAM ||
+			(f->f_st.st_mode&S_IFMT) == S_IFNWK))
+		return 0;
+	if (fmttype == FMT_ZIP && f->f_gflag & FG_DESC)
+		return zipread(f, f->f_name, -1, 0);
+	size = fmttype == FMT_ZIP ? f->f_csize :
+		f->f_Kbase ? f->f_Kbase : f->f_st.st_size;
+again:	while (size) {
+		if ((rd = bread(b, size > sizeof b ? sizeof b : size)) <= 0)
+			unexeoa();
+		size -= rd;
+	}
+	if (f->f_Kbase) {
+		skippad(f->f_Ksize, f->f_pad);
+		readK2hdr(f);
+		size = f->f_Krest;
+		goto again;
+	}
+	skippad(fmttype==FMT_ZIP ? f->f_csize :
+			f->f_Ksize ? f->f_Krest : f->f_st.st_size, f->f_pad);
+	return 0;
+}
+
+/*
+ * Skip data also, but perform checks as if copying.
+ */
+static int
+skipdata(struct file *f, int (*copydata)(struct file *, const char *, int))
+{
+	switch (f->f_st.st_mode&S_IFMT) {
+	case S_IFLNK:
+		break;
+	case S_IFDIR:
+	case S_IFBLK:
+	case S_IFCHR:
+	case S_IFIFO:
+	case S_IFNAM:
+	case S_IFNWK:
+		if (fmttype != FMT_ZIP)
+			break;
+		/*FALLTHRU*/
+	case S_IFREG:
+	default:
+		if (fmttype & TYP_TAR && f->f_st.st_nlink > 1 &&
+				((fmttype & TYP_USTAR) == 0 ||
+				 formatforced && fmttype != FMT_PAX))
+			break;
+		if (copydata(f, f->f_name, -1) != 0)
+			return 1;
+	}
+	return 0;
+}
+
+/*
+ * Seek to a position in the archive measured from the begin of
+ * operation. Handle media-dependent seeks. n must be a multiple
+ * of the tape device's physical block size.
+ */
+static int
+tseek(off_t n)
+{
+	int	fault;
+
+	if (tapeblock > 0) {
+		int	i = (n - poffs) / tapeblock;
+#if defined (__linux__) || defined (__sun) || defined (__FreeBSD__) || \
+	defined (__hpux) || defined (_AIX) || defined (__NetBSD__) || \
+	defined (__OpenBSD__) || defined (__DragonFly__) || defined (__APPLE__)
+		struct mtop	mo;
+		mo.mt_op = i > 0 ? MTFSR : MTBSR;
+		mo.mt_count = i > 0 ? i : -i;
+		fault = ioctl(mt, MTIOCTOP, &mo);
+#else	/* SVR4.2MP */
+		int	t, a;
+		t = i > 0 ? T_SBF : T_SBB;
+		a = i > 0 ? i : -i;
+		fault = ioctl(mt, t, a);
+#endif	/* SVR4.2MP */
+	} else
+		fault = lseek(mt, n - poffs, SEEK_CUR) == (off_t)-1 ? -1 : 0;
+	if (fault == 0)
+		poffs = n;
+	return fault;
+}
+
+/*
+ * Advance to the trailer on the tape (for -A).
+ */
+static int
+totrailer(void)
+{
+	union bincpio	bc;
+	struct file	f;
+	off_t	ooffs, noffs, diff;
+	int	i;
+
+	if (mread() == 0)
+		unexeoa();
+	if (fmttype == FMT_NONE)
+		whathdr();
+	memset(&f, 0, sizeof f);
+	for (;;) {
+		ooffs = aoffs;
+		if ((i = readhdr(&f, &bc)) < 0)
+			goto fail;
+		if (i > 0)
+			break;
+		markdev(f.f_st.st_dev);
+		if (skipfile(&f) != 0)
+			goto fail;
+		if (fmttype == FMT_ZIP)
+			zipdefer(f.f_name, &f.f_st, ooffs,
+					f.f_chksum, f.f_csize, &bc.Zdr);
+		pax_track(f.f_name, f.f_st.st_mtime);
+	}
+	/*
+	 * Now seek to the position of the trailer, but retain the
+	 * block alignment.
+	 */
+	diff = ooffs % blksiz;
+	noffs = ooffs - diff;
+	if (diff ? tseek(noffs) == 0 && mread() >= diff && tseek(noffs) == 0
+			: tseek(ooffs) == 0) {
+		free(f.f_name);
+		free(f.f_lnam);
+		nwritten = ooffs;
+		curpos = diff;
+		return 0;
+	}
+fail:	msg(4, 1, "Unable to append to this archive\n");
+	/*NOTREACHED*/
+	return 1;
+}
+
+static long long
+rdoct(const char *data, int len)
+{
+	int	i;
+	long long	val = 0;
+
+	for (i = 0; i < len && data[i] == ' '; i++);
+	for ( ; i < len && data[i] && data[i] != ' '; i++) {
+		val <<= 3;
+		val += data[i] - '0';
+	}
+	return val;
+}
+
+static long long
+rdhex(const char *data, int len)
+{
+	int	i;
+	long long	val = 0;
+
+	for (i = 0; i < len && data[i] == ' '; i++);
+	for ( ; i < len && data[i] && data[i] != ' '; i++) {
+		val <<= 4;
+		val += data[i] > '9' ? data[i] > 'F' ? data[i] - 'a' + 10 :
+			data[i] - 'A' + 10 : data[i] - '0';
+	}
+	return val;
+}
+
+void
+unexeoa(void)
+{
+	if (sysv3) {
+		fprintf(stderr,
+		"Can't read input:  end of file encountered "
+			"prior to expected end of archive.\n");
+		done(1);
+	}
+	else
+		msg(3, 1, "Unexpected end-of-archive encountered.\n");
+}
+
+static char	*peekdata;
+static size_t	peekbot, peektop, peeksize;
+
+void
+bunread(const char *data, size_t sz)
+{
+	peekdata = srealloc(peekdata, peeksize += sz);
+	memcpy(&peekdata[peekbot], data, sz);
+	peektop += sz;
+	aoffs -= sz;
+}
+
+/*
+ * Buffered read of data from tape. sz is the amount of data required
+ * by the archive format; if it cannot be retrieved, processing fails.
+ */
+ssize_t
+bread(char *data, size_t sz)
+{
+	ssize_t	rd = 0;
+
+	if (peekdata) {
+		rd = sz>peektop-peekbot ? peektop-peekbot : sz;
+		memcpy(&data[0], &peekdata[peekbot], rd);
+		sz -= rd;
+		peekbot += rd;
+		if (peekbot == peektop) {
+			free(peekdata);
+			peekdata = 0;
+			peeksize = 0;
+			peekbot = peektop = 0;
+		}
+	}
+	while (sz) {
+		if (blktop - curpos >= sz) {
+			memcpy(&data[rd], &blkbuf[curpos], sz);
+			curpos += sz;
+			rd += sz;
+			aoffs += rd;
+			return rd;
+		}
+		if (blktop > curpos) {
+			memcpy(&data[rd], &blkbuf[curpos], blktop - curpos);
+			rd += blktop - curpos;
+			sz -= blktop - curpos;
+			curpos = blktop;
+		}
+		if (mfl < 0) {
+			if (mfl == -1) {
+				emsg(3, "I/O error on \"%s\"",
+						Iflag ? Iflag : "input");
+				if (kflag == 0)
+					break;
+				if (tapeblock < 0 && (
+						(mtst.st_mode&S_IFMT)==S_IFBLK||
+						(mtst.st_mode&S_IFMT)==S_IFCHR||
+						(mtst.st_mode&S_IFMT)==S_IFREG
+						) && lseek(mt, blksiz, SEEK_CUR)
+							== (off_t)-1) {
+					emsg(3, "Cannot lseek()");
+					done(1);
+				}
+			}
+			if (kflag == 0 || mfl == -2) {
+				if ((mtst.st_mode&S_IFMT)!=S_IFCHR &&
+						(mtst.st_mode&S_IFMT)!=S_IFBLK)
+					break;
+				newmedia(mfl == -1 ? errno : 0);
+				if (mfl == -1) {
+					mfl = -2;
+					break;
+				}
+				if (fmttype & TYP_BAR)
+					curpos = 512;
+			}
+		}
+		mread();
+	}
+	aoffs += rd;
+	return rd;
+}
+
+/*
+ * Read a block of data from tape.
+ */
+static ssize_t
+mread(void)
+{
+	ssize_t	ro, rt = 0;
+
+	do {
+		if ((ro = read(mt, blkbuf + rt, blksiz - rt)) <= 0) {
+			if (ro < 0) {
+				if (errno == EINTR)
+					continue;
+				mfl = -1;
+			} else
+				mfl = -2;
+			if (rt > 0) {
+				rt += ro;
+				break;
+			}
+			curpos = blktop = 0;
+			return ro;
+		}
+		rt += ro;
+		poffs += ro;
+		if (tapeblock == 0) {
+			tapeblock = ro;
+			if (!Bflag && !Cflag)
+				blksiz = ro;
+		}
+	} while (rt < blksiz);
+	curpos = 0;
+	blocks += rt >> 9;
+	bytes += rt & 0777;
+	blktop = rt;
+	return rt;
+}
+
+/*
+ * Look what kind of tape or other archive media we are working on and
+ * set the buffer size appropriately (if not specified by the user).
+ */
+static void
+mstat(void)
+{
+	if (fstat(mt, &mtst) < 0) {
+		emsg(3, "Error during stat() of archive");
+		done(1);
+	}
+#if defined (__linux__)
+	if ((mtst.st_mode&S_IFMT) == S_IFCHR) {
+		struct mtget	mg;
+		if (ioctl(mt, MTIOCGET, &mg) == 0)
+			tapeblock = (mg.mt_dsreg&MT_ST_BLKSIZE_MASK) >>
+					MT_ST_BLKSIZE_SHIFT;
+	} else if ((mtst.st_mode&S_IFMT) == S_IFBLK) {
+		/*
+		 * If using a block device, write blocks of the floppy
+		 * disk sector with direct i/o. This enables signals
+		 * after each block is written instead of being ~40
+		 * seconds in uninterruptible sleep when calling close()
+		 * later. For block devices other than floppies, use the 
+		 * kernel defined i/o block size. For floppies, use direct
+		 * i/o even when reading since it is faster.
+		 */
+		struct floppy_struct	fs;
+		int	floppy = -1;
+		int	blkbsz;
+
+		if (blksiz == 0) {
+			if ((floppy = ioctl(mt, FDGETPRM, &fs)) == 0)
+				blksiz = fs.sect * FD_SECTSIZE(&fs);
+#ifdef	BLKBSZGET
+			else if (ioctl(mt, BLKBSZGET, &blkbsz) == 0)
+				blksiz = blkbsz;
+#endif	/* BLKBSZGET */
+		}
+#ifdef	O_DIRECT
+		if ((action == 'o' || floppy == 0) && blksiz != 0) {
+			int	flags;
+			if ((flags = fcntl(mt, F_GETFL)) != -1)
+				fcntl(mt, F_SETFL, flags | O_DIRECT);
+		}
+	}
+#endif	/* O_DIRECT */
+#elif defined (__sun)
+	if ((mtst.st_mode&S_IFMT) == S_IFCHR) {
+		struct mtdrivetype_request	mr;
+		static struct mtdrivetype	md;
+		mr.size = sizeof md;
+		mr.mtdtp = &md;
+		if (ioctl(mt,  MTIOCGETDRIVETYPE, &mr) == 0)
+			tapeblock = md.bsize;
+	}
+#elif defined (__FreeBSD__) || defined (__NetBSD__) || defined (__OpenBSD__) \
+		|| defined (__DragonFly__) || defined (__APPLE__)
+	if ((mtst.st_mode&S_IFMT) == S_IFCHR) {
+		struct mtget	mg;
+		if (ioctl(mt, MTIOCGET, &mg) == 0)
+			tapeblock = mg.mt_blksiz;
+	}
+#elif defined (__hpux) || defined (_AIX)
+#else	/* SVR4.2MP */
+	if ((mtst.st_mode&S_IFMT) == S_IFCHR) {
+		struct blklen	bl;
+		if (ioctl(mt, T_RDBLKLEN, &bl) == 0)
+			/*
+			 * These are not the values we're interested in
+			 * (always 1 and 16M-1 for DAT/DDS tape drives).
+			 */
+			tapeblock = 0;
+	}
+#endif	/* SVR4.2MP */
+	if (blksiz == 0)
+		switch (mtst.st_mode&S_IFMT) {
+		case S_IFREG:
+		case S_IFBLK:
+			blksiz = 4096;
+			break;
+		case S_IFCHR:
+			if (action == 'o' && !Aflag) {
+				if (pax != PAX_TYPE_CPIO) {
+					if (fmttype & TYP_PAX)
+						blksiz = 5120;
+					else if (fmttype & TYP_TAR)
+						blksiz = 10240;
+					else if (fmttype & TYP_CPIO)
+						blksiz = 5120;
+					else
+						blksiz = 512;
+				} else
+					blksiz = tapeblock>0 ? tapeblock : 512;
+			} else
+				blksiz = tapeblock > 0 && tapeblock % 1024 ?
+					tapeblock : tapeblock > 10240 ?
+					tapeblock : 10240;
+			break;
+		default:
+			blksiz = 512;
+		}
+}
+
+/*
+ * Skip tape data such that size becomes aligned to pad.
+ */
+static int
+skippad(unsigned long long size, int pad)
+{
+	char	b[512];
+	int	to;
+
+	if ((to = size % pad) != 0) {
+		if (bread(b, pad - to) != pad - to)
+			unexeoa();
+	}
+	return 0;
+}
+
+static int
+allzero(const char *bp, int n)
+{
+	int	i;
+
+	for (i = 0; i < n; i++)
+		if (bp[i] != '\0')
+			return 0;
+	return 1;
+}
+
+#define	CACHESIZE	16
+
+static const char *
+getuser(uid_t uid)
+{
+	static struct {
+		char	*name;
+		uid_t	uid;
+	} cache[CACHESIZE];
+	static int	last;
+	int	i;
+	struct passwd	*pwd;
+	const char	*name;
+
+	for (i = 0; i < CACHESIZE && cache[i].name; i++)
+		if (cache[i].uid == uid)
+			goto found;
+	if ((pwd = getpwuid(uid)) != NULL)
+		name = pwd->pw_name;
+	else
+		name = "";
+	if (i >= CACHESIZE) {
+		if (last >= CACHESIZE)
+			last = 0;
+		i = last++;
+	}
+	if (cache[i].name)
+		free(cache[i].name);
+	cache[i].name = sstrdup(name);
+	cache[i].uid = uid;
+found:	return cache[i].name[0] ? cache[i].name : NULL;
+}
+
+static const char *
+getgroup(gid_t gid)
+{
+	static struct {
+		char	*name;
+		gid_t	gid;
+	} cache[CACHESIZE];
+	static int	last;
+	int	i;
+	struct group	*grp;
+	const char	*name;
+
+	for (i = 0; i < CACHESIZE && cache[i].name; i++)
+		if (cache[i].gid == gid)
+			goto found;
+	if ((grp = getgrgid(gid)) != NULL)
+		name = grp->gr_name;
+	else
+		name = "";
+	if (i >= CACHESIZE) {
+		if (last >= CACHESIZE)
+			last = 0;
+		i = last++;
+	}
+	if (cache[i].name)
+		free(cache[i].name);
+	cache[i].name = sstrdup(name);
+	cache[i].gid = gid;
+found:	return cache[i].name[0] ? cache[i].name : NULL;
+}
+
+/*
+ * Return a version of the passed string that contains at most one '%d'
+ * and no other printf formats.
+ */
+char *
+oneintfmt(const char *op)
+{
+	char	*new, *np;
+	int	no = 0;
+
+	np = new = smalloc(2 * strlen(op) + 1);
+	do {
+		if (*op == '%') {
+			*np++ = *op++;
+			if (*op != '%')
+				if (*op != 'd' || no++)
+					*np++ = '%';
+		}
+		*np++ = *op;
+	} while (*op++);
+	return new;
+}
+
+char *
+sstrdup(const char *op)
+{
+	char	*np;
+
+	np = smalloc(strlen(op) + 1);
+	strcpy(np, op);
+	return np;
+}
+
+/*
+ * Add this pattern to the extraction list with -i.
+ */
+void
+addg(const char *pattern, int art)
+{
+	struct glist	*gp;
+
+	gp = scalloc(1, sizeof *gp);
+	if (pax == PAX_TYPE_CPIO && pattern[0] == '!') {
+		gp->g_not = 1;
+		pattern++;
+	}
+	gp->g_pat = sstrdup(pattern);
+	gp->g_art = art;
+	if (pax != PAX_TYPE_CPIO) {
+		struct glist	*gb = NULL, *gc;
+		for (gc = patterns; gc; gc = gc->g_nxt)
+			gb = gc;
+		if (gb)
+			gb->g_nxt = gp;
+		else
+			patterns = gp;
+	} else {
+		gp->g_nxt = patterns;
+		patterns = gp;
+	}
+}
+
+/*
+ * Check if the file name s matches any of the given patterns.
+ */
+static struct glist *
+want(struct file *f, struct glist **gb)
+{
+	extern int	gmatch(const char *, const char *);
+	struct glist	*gp;
+
+	for (gp = patterns; gp; gp = gp->g_nxt) {
+		if ((gmatch(f->f_name, gp->g_pat) != 0) ^ gp->g_not &&
+				(pax_nflag == 0 || gp->g_gotcha == 0)) {
+			return gp;
+		}
+		*gb = gp;
+	}
+	return NULL;
+}
+
+static void
+patfile(void)
+{
+	struct iblok	*ip;
+	char	*name = NULL;
+	size_t	namsiz = 0, namlen;
+
+	if ((ip = ib_open(Eflag, 0)) == NULL)
+		msg(3, -2, "Cannot open \"%s\" to read patterns\n", Eflag);
+	while ((namlen = ib_getlin(ip, &name, &namsiz, srealloc)) != 0) {
+		if (name[namlen-1] == '\n')
+			name[--namlen] = '\0';
+		addg(name, 0);
+	}
+	ib_close(ip);
+}
+
+void
+swap(char *b, size_t sz, int s8, int s16)
+{
+	uint8_t	u8;
+	uint16_t	u16;
+	union types2	*t2;
+	union types4	*t4;
+	int	i;
+
+	if (s8) {
+		for (i = 0; i < (sz >> 1); i++) {
+			t2 = &((union types2 *)b)[i];
+			u8 = t2->byte[0];
+			t2->byte[0] = t2->byte[1];
+			t2->byte[1] = u8;
+		}
+	}
+	if (s16) {
+		for (i = 0; i < (sz >> 2); i++) {
+			t4 = &((union types4 *)b)[i];
+			u16 = t4->sword[0];
+			t4->sword[0] = t4->sword[1];
+			t4->sword[1] = u16;
+		}
+	}
+}
+
+static int
+ckodd(long long size, int mod, const char *str, const char *fn)
+{
+	if (size % mod) {
+		msg(3, 0, "Cannot swap %s of \"%s\", odd number of %s\n",
+				str, fn, str);
+		errcnt++;
+		return 1;
+	}
+	return 0;
+}
+
+/*
+ * Interactive rename (-r option).
+ */
+static int
+rname(char **oldp, size_t *olds)
+{
+	char	*new = NULL;
+	size_t	newsize = 0;
+	int	i, r;
+	char	c;
+
+	fprintf(stderr, "Rename \"%s\"? ", *oldp);
+	if (tty == 0)
+		if ((tty = open("/dev/tty", O_RDWR)) < 0 ||
+				fcntl(tty, F_SETFD, FD_CLOEXEC) < 0)
+		err:	msg(3, 1, "Cannot read tty.\n");
+	i = 0;
+	while ((r = read(tty, &c, 1)) == 1 && c != '\n') {
+		if (i+1 >= newsize)
+			new = srealloc(new, newsize += 32);
+		new[i++] = c;
+	}
+	if (r <= 0)
+		goto err;
+	if (new == NULL)
+		return 0;
+	new[i] = '\0';
+	if (new[0] == '.' && new[1] == '\0') {
+		free(new);
+	} else {
+		free(*oldp);
+		*oldp = new;
+		*olds = newsize;
+	}
+	return 1;
+}
+
+/*
+ * Filter data from tape through the commands given in arg?.
+ */
+static int
+redirect(const char *arg0, const char *arg1)
+{
+	int	pd[2];
+
+	if (pipe(pd) < 0)
+		return -1;
+	switch (fork()) {
+	case 0:
+		if (tapeblock>=0 || lseek(mt, -blktop, SEEK_CUR) == (off_t)-1) {
+			int	xpd[2];
+			if (pipe(xpd) == 0 && fork() == 0) {
+				ssize_t	rd, wo, wt;
+				close(xpd[0]);
+				do {
+					wo = wt = 0;
+					do {
+						if ((wo = write(xpd[1],
+								blkbuf + wt,
+								blktop - wt))
+									<= 0) {
+							if (errno == EINTR)
+								continue;
+							_exit(0);
+						}
+						wt += wo;
+					} while (wt < blktop);
+				} while ((rd = mread()) >= 0);
+				if (rd < 0) {
+					emsg(3, "Read error on \"%s\"",
+							Iflag && !sysv3 ?
+							Iflag : "input");
+				}
+				_exit(0);
+			} else {
+				close(xpd[1]);
+				dup2(xpd[0], 0);
+				close(xpd[0]);
+			}
+		} else {
+			dup2(mt, 0);
+		}
+		close(mt);
+		dup2(pd[1], 1);
+		close(pd[0]);
+		close(pd[1]);
+		execlp(arg0, arg0, arg1, NULL);
+		fprintf(stderr, "%s: could not exec %s: %s\n",
+				progname, arg0, strerror(errno));
+		_exit(0177);
+		/*NOTREACHED*/
+	default:
+		dup2(pd[0], mt);
+		close(pd[0]);
+		close(pd[1]);
+		tapeblock = -1;
+		break;
+	case -1:
+		return -1;
+	}
+	return 0;
+}
+
+/*
+ * Get the name stored in a tar header. buf is expected to be at least
+ * TPFXSIZ+TNAMSIZ+2 bytes.
+ */
+static char *
+tnameof(struct tar_header *hp, char *buf)
+{
+	const char	*cp;
+	char	*bp = buf;
+
+	if (fmttype & TYP_USTAR && fmttype != FMT_GNUTAR &&
+			hp->t_prefix[0] != '\0') {
+		cp = hp->t_prefix;
+		while (cp < &hp->t_prefix[TPFXSIZ] && *cp)
+			*bp++ = *cp++;
+		if (bp > buf)
+			*bp++ = '/';
+	}
+	cp = hp->t_name;
+	while (cp < &hp->t_name[TNAMSIZ] && *cp)
+		*bp++ = *cp++;
+	*bp = '\0';
+	return buf;
+}
+
+/*
+ * Store fn as file name in a tar header.
+ */
+static int
+tmkname(struct tar_header *hp, const char *fn)
+{
+	const char	*cp, *cs = NULL;
+
+	for (cp = fn; *cp; cp++) {
+		if (fmttype & TYP_USTAR && *cp == '/' && cp[1] != '\0' &&
+				cp > fn && cp-fn <= TPFXSIZ)
+			cs = cp;
+	}
+	if (fmttype == FMT_GNUTAR && cp - fn > 99) {
+		writegnuname(fn, cp - fn + 1, 'L');
+		cp = &fn[99];
+	} else if (cp - (cs ? &cs[1] : fn) > TNAMSIZ) {
+		if (fmttype & TYP_PAX && utf8(fn)) {
+			paxrec |= PR_PATH;
+			strcpy(hp->t_name, sequence());
+			return 0;
+		}
+		msg(3, 0, "%s: file name too long\n", fn);
+		return -1;
+	}
+	if (cs && cp - fn > TNAMSIZ) {
+		memcpy(hp->t_prefix, fn, cs - fn);
+		if (cs - fn < TPFXSIZ)
+			hp->t_prefix[cs - fn] = '\0';
+		memcpy(hp->t_name, &cs[1], cp - &cs[1]);
+		if (cp - &cs[1] < TNAMSIZ)
+			hp->t_name[cp - &cs[1]] = '\0';
+	} else {
+		memcpy(hp->t_name, fn, cp - fn);
+		if (cp - fn < TNAMSIZ)
+			hp->t_name[cp - fn] = '\0';
+	}
+	return 0;
+}
+
+/*
+ * Get the link name of a tar header.
+ */
+static void
+tlinkof(struct tar_header *hp, struct file *f)
+{
+	const char	*cp;
+	char	*bp;
+
+
+	if (f->f_lsiz < TNAMSIZ+1)
+		f->f_lnam = srealloc(f->f_lnam, f->f_lsiz = TNAMSIZ+1);
+	cp = hp->t_linkname;
+	bp = f->f_lnam;
+	while (cp < &hp->t_linkname[TNAMSIZ] && *cp)
+		*bp++ = *cp++;
+	*bp = '\0';
+}
+
+/*
+ * Create the link name in a tar header.
+ */
+static int
+tmklink(struct tar_header *hp, const char *fn)
+{
+	const char	*cp;
+
+	for (cp = fn; *cp; cp++);
+	if (fmttype == FMT_GNUTAR && cp - fn > 99) {
+		writegnuname(fn, cp - fn + 1, 'K');
+		cp = &fn[99];
+	} else if (cp - fn > TNAMSIZ) {
+		if (fmttype & TYP_PAX && utf8(fn)) {
+			paxrec |= PR_LINKPATH;
+			strcpy(hp->t_linkname, sequence());
+			return 0;
+		}
+		msg(3, 0, "%s: linked name too long\n", fn);
+		return -1;
+	}
+	memcpy(hp->t_linkname, fn, cp - fn);
+	if (cp - fn < TNAMSIZ)
+		hp->t_linkname[cp - fn] = '\0';
+	return 0;
+}
+
+static int
+tlflag(struct stat *st)
+{
+	if (fmttype & TYP_BAR) {
+		switch (st->st_mode & S_IFMT) {
+		case S_IFREG:
+		case S_IFDIR:
+			return '0';
+		case S_IFLNK:
+			return '2';
+		default:
+			return '3';
+		}
+	} else if (fmttype & TYP_USTAR) {
+		switch (st->st_mode & S_IFMT) {
+		case S_IFREG:
+			return '0';
+		case S_IFLNK:
+			return '2';
+		case S_IFCHR:
+			return '3';
+		case S_IFBLK:
+			return '4';
+		case S_IFDIR:
+			return '5';
+		case S_IFIFO:
+			return '6';
+		default:
+			return -1;
+		}
+	} else {
+		switch (st->st_mode & S_IFMT) {
+		case S_IFREG:
+			return '\0';
+		case S_IFLNK:
+			return '2';
+		default:
+			return -1;
+		}
+	}
+}
+
+/*
+ * Ustar checksums are created using unsigned chars, as specified by
+ * POSIX. Traditional tar implementations use signed chars. Some
+ * implementations (notably SVR4 cpio derivatives) use signed chars
+ * even for ustar archives, but this is clearly an implementation bug.
+ */
+static void
+tchksum(union bincpio *bp)
+{
+	uint32_t	sum;
+	char	*cp;
+
+	memset(bp->Tdr.t_chksum, ' ', sizeof bp->Tdr.t_chksum);
+	sum = 0;
+	if (fmttype & TYP_USTAR)
+		for (cp = bp->data; cp < &bp->data[512]; cp++)
+			sum += *((unsigned char *)cp);
+	else
+		for (cp = bp->data; cp < &bp->data[512]; cp++)
+			sum += *((signed char *)cp);
+	sprintf(bp->Tdr.t_chksum, "%7.7o", sum);
+}
+
+static int
+tcssum(union bincpio *bp, int ustar)
+{
+	uint32_t	ssum = 0, usum = 0, osum;
+	char	ochk[sizeof bp->Tdr.t_chksum];
+	char	*cp;
+
+	osum = rdoct(bp->Tdr.t_chksum, 8);
+	memcpy(ochk, bp->Tdr.t_chksum, sizeof ochk);
+	memset(bp->Tdr.t_chksum, ' ', sizeof bp->Tdr.t_chksum);
+	for (cp = bp->data; cp < &bp->data[512]; cp++) {
+		ssum += *((signed char *)cp);
+		usum += *((unsigned char *)cp);
+	}
+	memcpy(bp->Tdr.t_chksum, ochk, sizeof bp->Tdr.t_chksum);
+	return ssum != osum && usum != osum;
+}
+
+static int
+trdsum(union bincpio *bp)
+{
+	int	i;
+
+	if (fmttype & TYP_BAR)
+		i = bcssum(bp);
+	else
+		i = tcssum(bp, fmttype & TYP_USTAR);
+	if (i)
+		msg(3, 0, "Bad header - checksum error.\n");
+	return i;
+}
+
+static mode_t
+tifmt(int c)
+{
+	switch (c) {
+	default:
+	case '\0':
+	case '0':
+		return S_IFREG;
+	case '2':
+		return S_IFLNK;
+	case '3':
+		return S_IFCHR;
+	case '4':
+		return S_IFBLK;
+	case '5':
+		return S_IFDIR;
+	case '6':
+		return S_IFIFO;
+	}
+}
+
+/*
+ * bar format support functions.
+ */
+static void
+bchksum(union bincpio *bp)
+{
+	uint32_t	sum;
+	char	*cp;
+
+	memset(bp->Bdr.b_chksum, ' ', sizeof bp->Bdr.b_chksum);
+	sum = 0;
+	for (cp = bp->data; cp < &bp->data[512]; cp++)
+		sum += *((signed char *)cp);
+	sprintf(bp->Bdr.b_chksum, "%7.7o", sum);
+}
+
+static int
+bcssum(union bincpio *bp)
+{
+	uint32_t	sum, osum;
+	char	ochk[sizeof bp->Bdr.b_chksum];
+	char	*cp;
+
+	osum = rdoct(bp->Bdr.b_chksum, 8);
+	memcpy(ochk, bp->Bdr.b_chksum, sizeof ochk);
+	memset(bp->Bdr.b_chksum, ' ', sizeof bp->Bdr.b_chksum);
+	sum = 0;
+	for (cp = bp->data; cp < &bp->data[512]; cp++)
+		sum += *((signed char *)cp);
+	memcpy(bp->Bdr.b_chksum, ochk, sizeof bp->Bdr.b_chksum);
+	return sum != osum;
+}
+
+static void
+blinkof(const char *cp, struct file *f, int namlen)
+{
+	if (f->f_lsiz < 512)
+		f->f_lnam = srealloc(f->f_lnam, f->f_lsiz = 512);
+	strcpy(f->f_lnam, &cp[SIZEOF_bar_header + namlen]);
+}
+
+static void
+dump_barhdr(void)
+{
+	union bincpio	bc;
+	static int	volno;
+	static time_t	now = -1;
+
+	memset(&bc, 0, 512);
+	sprintf(bc.Bdr.b_uid, "%d", myuid & 07777777);
+	sprintf(bc.Bdr.b_gid, "%d", mygid & 07777777);
+	bc.Bdr.b_size[0] = '0';
+	memcpy(bc.Bdr.b_bar_magic, mag_bar, sizeof bc.Bdr.b_bar_magic);
+	sprintf(bc.Bdr.b_volume_num, "%d", ++volno & 0777);
+	bc.Bdr.b_compressed = '0';
+	if (now == (time_t)-1)
+		time(&now);
+	sprintf(bc.Bdr.b_date, "%llo", now & 077777777777LL);
+	bchksum(&bc);
+	bwrite(bc.data, 512);
+}
+
+/*
+ * Support for compressed bar format (any regular file is piped through zcat).
+ */
+static pid_t	zpid;
+
+static int
+zcreat(const char *name, mode_t mode)
+{
+	int	pd[2];
+	int	fd;
+
+	if (pipe(pd) < 0)
+		return -1;
+	if ((fd = creat(name, mode)) < 0) {
+		fd = errno;
+		close(pd[0]);
+		close(pd[1]);
+		errno = fd;
+		return -1;
+	}
+	switch (zpid = fork()) {
+	case -1:
+		return -1;
+	case 0:
+		dup2(pd[0], 0);
+		dup2(fd, 1);
+		close(pd[0]);
+		close(pd[1]);
+		close(fd);
+		execlp("zcat", "zcat", NULL);
+		_exit(0177);
+		/*NOTREACHED*/
+	}
+	close(pd[0]);
+	close(fd);
+	sigset(SIGPIPE, SIG_IGN);
+	return pd[1];
+}
+
+static int
+zclose(int fd)
+{
+	int	c, s;
+
+	c = close(fd);
+	while (waitpid(zpid, &s, 0) != zpid);
+	return c != 0 || s != 0 ? -1 : 0;
+}
+
+/*
+ * If using the -A option, device numbers that appear in the archive
+ * are not reused for appended files. This avoids wrong hardlink
+ * connections on extraction.
+ *
+ * In fact, this should be done even if we did not fake device and
+ * inode numbers, since it is not guaranteed that the archive was
+ * created on the same machine, or even on the same machine, inode
+ * number could have changed after a file was unlinked.
+ */
+static void
+markdev(dev_t dev)
+{
+	struct dslot	*dp, *dq = NULL;;
+
+	for (dp = markeddevs; dp; dp = dp->d_nxt) {
+		if (dp->d_dev == dev)
+			return;
+		dq = dp;
+	}
+	dp = scalloc(1, sizeof *dp);
+	dp->d_dev = dev;
+	if (markeddevs == NULL)
+		markeddevs = dp;
+	else
+		dq->d_nxt = dp;
+}
+
+static int
+marked(dev_t dev)
+{
+	struct dslot	*dp;
+
+	for (dp = markeddevs; dp; dp = dp->d_nxt)
+		if (dp->d_dev == dev)
+			return 1;
+	return 0;
+}
+
+static void
+cantsup(int err, const char *file)
+{
+	if (sysv3)
+		msg(err ? 3 : 2, 0,
+			"format can't support expanded types on %s\n",
+			file);
+	else
+		msg(0, 0, "%s format can't support expanded types on %s\n",
+			err ? "Error" : "Warning", file);
+	errcnt++;
+}
+
+static void
+onint(int signo)
+{
+	if (cur_ofile && cur_tfile && rename(cur_tfile, cur_ofile) < 0)
+		emsg(3, "Cannot recover original \"%s\"", cur_ofile);
+	if (cur_ofile && cur_tfile == NULL && unlink(cur_ofile) < 0)
+		emsg(3, "Cannot remove incomplete \"%s\"", cur_ofile);
+	exit(signo | 0200);
+}
+
+/*
+ * Read the compressed zip data part for a file.
+ */
+static int
+zipread(struct file *f, const char *tgt, int tfd, int doswap)
+{
+	int	val = 0;
+	uint32_t	crc = 0;
+
+	if (f->f_gflag & FG_DESC) {
+		if (f->f_cmethod != C_DEFLATED && f->f_cmethod != C_ENHDEFLD ||
+				f->f_gflag & FG_CRYPT)
+			msg(4, 1, "Cannot handle zip data descriptor\n");
+		f->f_csize = 0x7FFFFFFFFFFFFFFFLL;
+		f->f_st.st_size = 0x7FFFFFFFFFFFFFFFLL;
+	} else if (tfd < 0)
+		return skipfile(f);
+	if (f->f_gflag & FG_CRYPT)
+		return cantunzip(f, "encrypted");
+	switch (f->f_cmethod) {
+	case C_DEFLATED:
+	case C_ENHDEFLD:
+		val = zipinflate(f, tgt, tfd, doswap, &crc);
+		break;
+	case C_SHRUNK:
+		val = zipunshrink(f, tgt, tfd, doswap, &crc);
+		break;
+	case C_IMPLODED:
+		val = zipexplode(f, tgt, tfd, doswap, &crc);
+		break;
+	case C_REDUCED1:
+	case C_REDUCED2:
+	case C_REDUCED3:
+	case C_REDUCED4:
+		val = zipexpand(f, tgt, tfd, doswap, &crc);
+		break;
+	case C_TOKENIZED:
+		return cantunzip(f, "tokenized");
+	case C_DCLIMPLODED:
+		val = zipblast(f, tgt, tfd, doswap, &crc);
+		break;
+	case C_BZIP2:
+#if USE_BZLIB
+		val = zipunbz2(f, tgt, tfd, doswap, &crc);
+		break;
+#else	/* !USE_BZLIB */
+		return cantunzip(f, "bzip2 compressed");
+#endif	/* !USE_BZLIB */
+	default:
+		return cantunzip(f, "compressed");
+	}
+	if (f->f_gflag & FG_DESC)
+		zipreaddesc(f);
+	if (val == 0 && crc != f->f_chksum) {
+		msg(3, 0, "\"%s\" - checksum error\n", f->f_name);
+		return -1;
+	}
+	return val;
+}
+
+/*
+ * Read a zip data descriptor (i. e. a field after the compressed data
+ * that contains the actual values for sizes and crc).
+ */
+static void
+zipreaddesc(struct file *f)
+{
+	if (f->f_oflag & OF_ZIP64) {
+		struct	zipddesc64	zd64;
+		bread((char *)&zd64, SIZEOF_zipddesc64);
+		if (memcmp(zd64.zd_signature, mag_zipdds, sizeof mag_zipdds))
+			msg(4, 1, "Invalid zip data descriptor\n");
+		f->f_chksum = ple32(zd64.zd_crc32);
+		f->f_dsize = f->f_st.st_size = ple64(zd64.zd_nsize) &
+			0xFFFFFFFFFFFFFFFFULL;
+		f->f_csize = ple64(zd64.zd_csize) &
+			0xFFFFFFFFFFFFFFFFULL;
+	} else {
+		struct	zipddesc zd;
+		bread((char *)&zd, SIZEOF_zipddesc);
+		if (memcmp(zd.zd_signature, mag_zipdds, sizeof mag_zipdds))
+			msg(4, 1, "Invalid zip data descriptor\n");
+		f->f_chksum = ple32(zd.zd_crc32);
+		f->f_dsize = f->f_st.st_size = ple32(zd.zd_nsize)&0xFFFFFFFFUL;
+		f->f_csize = ple32(zd.zd_csize)&0xFFFFFFFFUL;
+	}
+}
+
+static int
+cantunzip(struct file *f, const char *method)
+{
+	msg(3, 0, "Cannot unzip %s file \"%s\"\n", method, f->f_name);
+	errcnt++;
+	return skipfile(f);
+}
+
+/*
+ * PC-DOS time format:
+ *
+ * 31            24      20        15        10           4       0
+ * | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | |
+ * |               |               |               |               |
+ * |year         |months |days     |hours    |minutes    |biseconds|
+ *
+ * refers to local time on the machine it was created on.
+ */
+
+static time_t
+gdostime(const char *tp, const char *dp)
+{
+	uint32_t	v;
+	struct tm	tm;
+
+	v = (int)(tp[0]&0377) +
+		((int)(tp[1]&0377) << 8) +
+		((int)(dp[0]&0377) << 16) +
+		((int)(dp[1]&0377) << 24);
+	memset(&tm, 0, sizeof tm);
+	tm.tm_sec = (v&0x1F) << 1;
+	tm.tm_min = (v&0x7E0) >> 5;
+	tm.tm_hour = (v&0xF800) >> 11;
+	tm.tm_mday = ((v&0x1F0000) >> 16);
+	tm.tm_mon = ((v&0x1E00000) >> 21) - 1;
+	tm.tm_year = ((v&0xFE000000) >> 25) + 80;
+	tm.tm_isdst = -1;
+	return mktime(&tm);
+}
+
+static void
+mkdostime(time_t t, char *tp, char *dp)
+{
+	uint32_t	v;
+	struct tm	*tm;
+
+	tm = localtime(&t);
+	v = (tm->tm_sec >> 1) + (tm->tm_sec&1) + (tm->tm_min << 5) +
+		(tm->tm_hour << 11) + (tm->tm_mday << 16) +
+		((tm->tm_mon+1) << 21) + ((tm->tm_year - 80) << 25);
+	le16p(v&0x0000ffff, tp);
+	le16p((v&0xffff0000) >> 16, dp);
+}
+
+/*
+ * Read and interpret the zip extra field for a file.
+ */
+static ssize_t
+ziprxtra(struct file *f, struct zip_header *z)
+{
+	union zextra	*x, *xp;
+	short	tag, size;
+	ssize_t	len;
+
+	len = ple16(z->z_extralen)&0177777;
+	if (len > 0) {
+		x = smalloc(len);
+		if (bread((char *)x, len) != len)
+			return -1;
+		if (len < 4)
+			return len;
+		xp = x;
+		while (len > 0) {
+			if (len < 4)
+				return -1;
+			tag = ple16(xp->Ze_gn.ze_gn_tag);
+			size = (ple16(xp->Ze_gn.ze_gn_tsize)&0177777) + 4;
+			switch (tag) {
+			case mag_zip64f:	/* ZIP64 extended information */
+				if (size != SIZEOF_zextra_64 &&
+						size != SIZEOF_zextra_64_a &&
+						size != SIZEOF_zextra_64_b)
+					break;
+				if (f->f_st.st_size == 0xffffffff)
+					f->f_st.st_size =
+						ple64(xp->Ze_64.ze_64_nsize);
+				if (f->f_csize == 0xffffffff)
+					f->f_csize =
+						ple64(xp->Ze_64.ze_64_csize);
+				f->f_oflag |= OF_ZIP64;
+				break;
+			case 0x000d:	/* PKWARE Unix Extra Field */
+				if (size != SIZEOF_zextra_pk)
+					break;
+				f->f_st.st_atime = ple32(xp->Ze_pk.ze_pk_atime);
+				f->f_st.st_mtime = ple32(xp->Ze_pk.ze_pk_mtime);
+				f->f_st.st_uid = ple16(xp->Ze_pk.ze_pk_uid) &
+					0177777;
+				f->f_st.st_gid = ple16(xp->Ze_pk.ze_pk_gid) &
+					0177777;
+				break;
+			case 0x5455:	/* Extended Timestamp Extra Field */
+				if (xp->Ze_et.ze_et_flags[0] & 1)
+					f->f_st.st_atime =
+						ple32(xp->Ze_et.ze_et_atime);
+				if (xp->Ze_et.ze_et_flags[0] & 2)
+					f->f_st.st_mtime =
+						ple32(xp->Ze_et.ze_et_mtime);
+				if (xp->Ze_et.ze_et_flags[0] & 3)
+					f->f_st.st_ctime =
+						ple32(xp->Ze_et.ze_et_ctime);
+				break;
+			case 0x5855:	/* Info-ZIP Unix Extra Field #1 */
+				if (size != SIZEOF_zextra_i1)
+					break;
+				f->f_st.st_atime = ple32(xp->Ze_i1.ze_i1_atime);
+				f->f_st.st_mtime = ple32(xp->Ze_i1.ze_i1_mtime);
+				f->f_st.st_uid = ple16(xp->Ze_i1.ze_i1_uid) &
+					0177777;
+				f->f_st.st_gid = ple16(xp->Ze_i1.ze_i1_gid) &
+					0177777;
+				break;
+			case 0x7855:	/* Info-ZIP Unix Extra Field #2 */
+				if (size != SIZEOF_zextra_i2)
+					break;
+				f->f_st.st_uid = ple16(xp->Ze_i2.ze_i2_uid) &
+					0177777;
+				f->f_st.st_gid = ple16(xp->Ze_i2.ze_i2_gid) &
+					0177777;
+				break;
+			case 0x756e:	/* ASi Unix Extra Field */
+				if (size < SIZEOF_zextra_as)
+					break;
+				f->f_st.st_mode = ple16(xp->Ze_as.ze_as_mode);
+				f->f_st.st_uid = ple16(xp->Ze_as.ze_as_uid) &
+					0177777;
+				f->f_st.st_gid = ple16(xp->Ze_as.ze_as_gid) &
+					0177777;
+				if ((f->f_st.st_mode&S_IFMT) == S_IFLNK) {
+					if (f->f_lsiz < size-14+1)
+						f->f_lnam = srealloc(f->f_lnam,
+								f->f_lsiz =
+								size-18+1);
+					memcpy(f->f_lnam, &((char *)xp)[18],
+							size-18);
+					f->f_lnam[size-18] = '\0';
+					f->f_st.st_size = size-18;
+				} else {
+					f->f_st.st_rdev =
+						ple32(xp->Ze_as.ze_as_sizdev);
+					f->f_rmajor = major(f->f_st.st_rdev);
+					f->f_rminor = minor(f->f_st.st_rdev);
+				}
+				break;
+			case mag_zipcpio:
+				if (size != SIZEOF_zextra_cp)
+					break;
+				f->f_st.st_dev = ple32(xp->Ze_cp.ze_cp_dev);
+				f->f_st.st_ino = ple32(xp->Ze_cp.ze_cp_ino);
+				f->f_st.st_mode = ple32(xp->Ze_cp.ze_cp_mode);
+				f->f_st.st_uid = ple32(xp->Ze_cp.ze_cp_uid) &
+					0xFFFFFFFFUL;
+				f->f_st.st_gid = ple32(xp->Ze_cp.ze_cp_gid) &
+					0xFFFFFFFFUL;
+				f->f_st.st_nlink = ple32(xp->Ze_cp.ze_cp_nlink)&
+					0xFFFFFFFFUL;
+				f->f_st.st_rdev = ple32(xp->Ze_cp.ze_cp_rdev);
+				f->f_rmajor = major(f->f_st.st_rdev);
+				f->f_rminor = minor(f->f_st.st_rdev);
+				f->f_st.st_mtime = ple32(xp->Ze_cp.ze_cp_mtime);
+				f->f_st.st_atime = ple32(xp->Ze_cp.ze_cp_atime);
+				break;
+			}
+			xp = (union zextra *)&((char *)xp)[size];
+			len -= size;
+		}
+		free(x);
+	}
+	return len;
+}
+
+/*
+ * Write the central directory and the end of a zip file.
+ */
+static void
+ziptrailer(void)
+{
+	struct zipstuff	*zs;
+	struct zipcentral	zc;
+	struct zipend	ze;
+	long long	cpstart, cpend, entries = 0;
+	size_t	sz;
+
+	cpstart = nwritten;
+	for (zs = zipbulk; zs; zs = zs->zs_next) {
+		entries++;
+		memset(&zc, 0, SIZEOF_zipcentral);
+		memcpy(zc.zc_signature, mag_zipctr, 4);
+		zc.zc_versionmade[0] = 20;
+		zc.zc_versionextr[0] = zs->zs_cmethod == 8 ? 20 : 10;
+		mkdostime(zs->zs_mtime, zc.zc_modtime, zc.zc_moddate);
+		le32p(zs->zs_crc32, zc.zc_crc32);
+		le16p(zs->zs_cmethod, zc.zc_cmethod);
+		le16p(zs->zs_gflag, zc.zc_gflag);
+		/*
+		 * We flag files as created on PC-DOS / FAT filesystem
+		 * and thus set PC-DOS attributes here.
+		 */
+		if ((zs->zs_mode&0222) == 0)
+			zc.zc_external[0] |= 0x01;	/* readonly attribute */
+		if ((zs->zs_mode&S_IFMT) == S_IFDIR)
+			zc.zc_external[0] |= 0x10;	/* directory attr. */
+		sz = strlen(zs->zs_name);
+		le16p(sz, zc.zc_namelen);
+		if (zs->zs_size >= 0xffffffff || zs->zs_csize >= 0xffffffff ||
+				zs->zs_relative >= 0xffffffff) {
+			struct zextra_64	zf;
+
+			memset(&zf, 0, SIZEOF_zextra_64);
+			le16p(mag_zip64f, zf.ze_64_tag);
+			le16p(SIZEOF_zextra_64 - 4, zf.ze_64_tsize);
+			if ((zs->zs_mode&S_IFMT) == S_IFREG ||
+					(zs->zs_mode&S_IFMT) == S_IFLNK) {
+				le32p(0xffffffff, zc.zc_csize);
+				le32p(0xffffffff, zc.zc_nsize);
+				le64p(zs->zs_csize, zf.ze_64_csize);
+				le64p(zs->zs_size, zf.ze_64_nsize);
+			}
+			le64p(zs->zs_relative, zf.ze_64_reloff);
+			le32p(0xffffffff, zc.zc_relative);
+			le16p(SIZEOF_zextra_64, zc.zc_extralen);
+			bwrite((char *)&zc, SIZEOF_zipcentral);
+			bwrite(zs->zs_name, sz);
+			bwrite((char *)&zf, SIZEOF_zextra_64);
+		} else {
+			if ((zs->zs_mode&S_IFMT) == S_IFREG ||
+					(zs->zs_mode&S_IFMT) == S_IFLNK) {
+				le32p(zs->zs_csize, zc.zc_csize);
+				le32p(zs->zs_size, zc.zc_nsize);
+			}
+			le32p(zs->zs_relative, zc.zc_relative);
+			bwrite((char *)&zc, SIZEOF_zipcentral);
+			bwrite(zs->zs_name, sz);
+		}
+	}
+	cpend = nwritten;
+	memset(&ze, 0, SIZEOF_zipend);
+	memcpy(ze.ze_signature, mag_zipend, 4);
+	if (cpend >= 0xffffffff || entries >= 0xffff) {
+		struct zip64end	z6;
+		struct zip64loc	z4;
+
+		memset(&z6, 0, SIZEOF_zip64end);
+		memcpy(z6.z6_signature, mag_zip64e, 4);
+		le64p(SIZEOF_zip64end - 12, z6.z6_recsize);
+		z6.z6_versionmade[0] = 20;
+		z6.z6_versionextr[0] = 20;
+		le64p(entries, z6.z6_thisentries);
+		le64p(entries, z6.z6_allentries);
+		le64p(cpend - cpstart, z6.z6_dirsize);
+		le64p(cpstart, z6.z6_startsize);
+		bwrite((char *)&z6, SIZEOF_zip64end);
+		memset(&z4, 0, SIZEOF_zip64loc);
+		memcpy(z4.z4_signature, mag_zip64l, 4);
+		le64p(cpend, z4.z4_reloff);
+		le32p(1, z4.z4_alldiskn);
+		bwrite((char *)&z4, SIZEOF_zip64loc);
+		le16p(0xffff, ze.ze_thisentries);
+		le16p(0xffff, ze.ze_allentries);
+		le32p(0xffffffff, ze.ze_dirsize);
+		le32p(0xffffffff, ze.ze_startsize);
+	} else {
+		le16p(entries, ze.ze_thisentries);
+		le16p(entries, ze.ze_allentries);
+		le32p(cpend - cpstart, ze.ze_dirsize);
+		le32p(cpstart, ze.ze_startsize);
+	}
+	bwrite((char *)&ze, SIZEOF_zipend);
+}
+
+/*
+ * Store the data later needed for the central directory.
+ */
+static void
+zipdefer(const char *fn, struct stat *st, long long relative,
+		uint32_t crc, long long csize, const struct zip_header *zh)
+{
+	struct zipstuff	*zp;
+
+	zp = scalloc(1, sizeof *zp);
+	zp->zs_name = sstrdup(fn);
+	zp->zs_size = st->st_size;
+	zp->zs_mtime = st->st_mtime;
+	zp->zs_mode = st->st_mode;
+	zp->zs_relative = relative;
+	zp->zs_cmethod = ple16(zh->z_cmethod);
+	zp->zs_gflag = ple16(zh->z_gflag);
+	zp->zs_csize = csize;
+	zp->zs_crc32 = crc;
+	zp->zs_next = zipbulk;
+	zipbulk = zp;
+}
+
+#define	ziptrlevel()	( \
+	zipclevel == 01 ? 9 : 	/* maximum */	\
+	zipclevel == 02 ? 3 : 	/* fast */	\
+	zipclevel == 03 ? 1 :	/* super fast */\
+	/*zipclevel==00*/ 6  	/* normal */	\
+)
+
+/*
+ * Write (and compress) data for a regular file to a zip archive.
+ */
+static int
+zipwrite(int fd, const char *fn, struct stat *st, union bincpio *bp, size_t sz,
+		uint32_t dev, uint32_t ino, uint32_t *crc, long long *csize)
+{
+#if USE_ZLIB
+	struct z_stream_s	z;
+	int	i;
+	size_t	osize = 0;
+#endif	/* USE_ZLIB */
+	char	*ibuf, *obuf = 0;
+
+	if (st->st_size > 196608 || (ibuf = malloc(st->st_size)) == 0) {
+#if USE_ZLIB
+		if (zipclevel < 04)
+			return zipwdesc(fd, fn, st, bp, sz, dev, ino,
+					crc, csize);
+#endif	/* USE_ZLIB */
+		return zipwtemp(fd, fn, st, bp, sz, dev, ino, crc, csize);
+	}
+	*csize = 0;
+	if (read(fd, ibuf, st->st_size) != st->st_size) {
+		free(ibuf);
+		emsg(3, "Cannot read \"%s\"", fn);
+		close(fd);
+		return -1;
+	}
+	*crc = zipcrc(0, (unsigned char *)ibuf, st->st_size);
+#if USE_BZLIB
+	if (zipclevel == 07) {
+		unsigned int	sb;
+		if ((obuf = malloc(sb = st->st_size)) == 0)
+			goto store;
+		if (BZ2_bzBuffToBuffCompress(obuf, &sb, ibuf, st->st_size,
+					9, 0, 0) != BZ_OK)
+			goto store;
+		*csize = sb;
+		bp->Zdr.z_cmethod[0] = C_BZIP2;
+		bp->Zdr.z_version[0] = 0x2e;
+		goto out;
+	}
+#endif /* USE_BZLIB */
+	if (zipclevel > 03)
+		goto store;
+#if USE_ZLIB
+	memset(&z, 0, sizeof z);
+	if (deflateInit2(&z, ziptrlevel(), Z_DEFLATED, -15,
+			8, Z_DEFAULT_STRATEGY) < 0)
+		goto store;
+	z.next_in = (unsigned char *)ibuf;
+	z.avail_in = z.total_in = st->st_size;
+	do {
+		if (z.avail_out == 0) {
+			if ((obuf = realloc(obuf, osize += 4096)) == 0) {
+				deflateEnd(&z);
+				goto store;
+			}
+			z.next_out = (unsigned char *)&obuf[*csize];
+			z.avail_out = osize - *csize;
+		}
+		if ((i = deflate(&z, z.avail_in ? Z_NO_FLUSH : Z_FINISH)) < 0) {
+			deflateEnd(&z);
+			goto store;
+		}
+		*csize = osize - z.avail_out;
+	} while (z.avail_in || i != Z_STREAM_END);
+	deflateEnd(&z);
+	if (*csize < st->st_size) {
+		bp->Zdr.z_cmethod[0] = C_DEFLATED;
+		bp->Zdr.z_gflag[0] |= zipclevel << 1;
+		bp->Zdr.z_version[0] = 20;
+	} else
+#endif	/* USE_ZLIB */
+	store:	*csize = st->st_size;
+#if USE_BZLIB
+out:
+#endif /* USE_BZLIB */
+	le32p(*crc, bp->Zdr.z_crc32);
+	le32p(*csize, bp->Zdr.z_csize);
+	bwrite((char *)bp, SIZEOF_zip_header);
+	bwrite(fn, sz);
+	zipwxtra(fn, st, dev, ino);
+	switch (bp->Zdr.z_cmethod[0]) {
+	case C_DEFLATED:
+	case C_BZIP2:
+		bwrite(obuf, *csize);
+		break;
+	default:
+		bwrite(ibuf, *csize);
+	}
+	free(ibuf);
+	free(obuf);
+	close(fd);
+	return 0;
+}
+
+/*
+ * Write and compress data to a zip archive for a file that is to large
+ * too be kept in memory. If there is an error with the temporary file
+ * (e. g. no space left on device), the file is stored in uncompressed
+ * form.
+ */
+static int
+zipwtemp(int fd, const char *fn, struct stat *st, union bincpio *bp, size_t sz,
+		uint32_t dev, uint32_t ino, uint32_t *crc, long long *csize)
+{
+	static int	tf = -1;
+	static char	tlate[] = "/var/tmp/cpioXXXXXX";
+	char	ibuf[32768];
+#if USE_ZLIB || USE_BZLIB
+	char	obuf[32768];
+#endif	/* USE_ZLIB || USE_BZLIB */
+	struct zextra_64	zf;
+	struct zextra_64	*zfp = 0;
+	long long	size = st->st_size;
+	const char	*sname;
+	int	cuse, sf;
+	ssize_t	rd;
+
+	*csize = 0;
+	*crc = 0;
+#if USE_ZLIB || USE_BZLIB
+	if (tf < 0) {
+		if ((tf = mkstemp(tlate)) >= 0)
+			unlink(tlate);
+	} else if (lseek(tf, 0, SEEK_SET) != 0) {
+		close(tf);
+		tf = -1;
+	}
+#endif	/* USE_ZLIB || USE_BZLIB */
+#if USE_ZLIB
+	if (zipclevel < 04) {
+		struct z_stream_s	z;
+		memset(&z, 0, sizeof z);
+		if ((cuse = deflateInit2(&z, ziptrlevel(), Z_DEFLATED,
+				-15, 8, Z_DEFAULT_STRATEGY)) < 0)
+			goto store;
+		do {
+			if (z.avail_in == 0 && size > 0) {
+				if ((rd = read(fd, ibuf, sizeof ibuf)) <= 0) {
+					emsg(3, "Cannot read \"%s\"", fn);
+					close(fd);
+					ftruncate(tf, 0);
+					return -1;
+				}
+				z.next_in = (unsigned char *)ibuf;
+				z.avail_in = z.total_in = rd;
+				size -= rd;
+				*crc = zipcrc(*crc, (unsigned char *)ibuf, rd);
+			}
+			if (z.next_out == NULL || (char *)z.next_out > obuf) {
+				if (z.next_out && tf >= 0) {
+					if (write(tf, obuf,
+					    (char *)z.next_out-obuf) !=
+					    (char *)z.next_out-obuf) {
+						close(tf);
+						tf = -1;
+					}
+					*csize += (char *)z.next_out - obuf;
+				}
+				z.next_out = (unsigned char *)obuf;
+				z.avail_out = sizeof obuf;
+			}
+			if (cuse >= 0 && cuse != Z_STREAM_END)
+				cuse = deflate(&z,
+					z.avail_in?Z_NO_FLUSH:Z_FINISH);
+			else
+				z.avail_in = 0;
+		} while (size>0 || (char *)z.next_out>obuf ||
+				cuse>=0 && cuse!=Z_STREAM_END);
+		deflateEnd(&z);
+		goto out;
+	}
+#endif	/* USE_ZLIB */
+#if USE_BZLIB
+	if (zipclevel == 07) {
+		bz_stream	bs;
+		int	ok, on;
+		memset(&bs, sizeof bs, 0);
+		if ((ok = BZ2_bzCompressInit(&bs, 9, 0, 0)) != BZ_OK)
+			goto store;
+		cuse = 1;
+		do {
+			if (bs.avail_in == 0 && size > 0) {
+				if ((rd = read(fd, ibuf, sizeof ibuf)) <= 0) {
+					emsg(3, "Cannot read \"%s\"", fn);
+					close(fd);
+					ftruncate(tf, 0);
+					return -1;
+				}
+				bs.next_in = ibuf;
+				bs.avail_in = rd;
+				size -= rd;
+				*crc = zipcrc(*crc, (unsigned char *)ibuf, rd);
+			}
+			if (bs.next_out == NULL || bs.next_out > obuf) {
+				if (bs.next_out && tf >= 0) {
+					on = bs.next_out - obuf;
+					if (write(tf, obuf, on) != on) {
+						close(tf);
+						tf = -1;
+					}
+					*csize += on;
+				}
+				bs.next_out = obuf;
+				bs.avail_out = sizeof obuf;
+			}
+			if (ok != BZ_STREAM_END) {
+				switch (ok = BZ2_bzCompress(&bs,
+					bs.avail_in?BZ_RUN:BZ_FINISH)) {
+				case BZ_RUN_OK:
+				case BZ_FINISH_OK:
+				case BZ_STREAM_END:
+					break;
+				default:
+					msg(3, 1, "Compression error %d "
+							"on \"%s\"\n", ok, fn);
+					close(fd);
+					return -1;
+				}
+			}
+		} while (size > 0 || bs.next_out > obuf || ok != BZ_STREAM_END);
+		BZ2_bzCompressEnd(&bs);
+		goto out;
+	}
+#endif	/* USE_BZLIB */
+store:	cuse = -1;
+	while (size > 0) {
+		if ((rd = read(fd, ibuf, sizeof ibuf)) <= 0) {
+			emsg(3, "Cannot read \"%s\"", fn);
+			close(fd);
+			return -1;
+		}
+		size -= rd;
+		*crc = zipcrc(*crc, (unsigned char *)ibuf, rd);
+	}
+out:	if (tf >= 0 && cuse >= 0 && *csize < st->st_size) {
+		if (zipclevel == 07) {
+			bp->Zdr.z_cmethod[0] = C_BZIP2;
+			bp->Zdr.z_version[0] = 0x2e;
+		} else {
+			bp->Zdr.z_cmethod[0] = C_DEFLATED;
+			bp->Zdr.z_gflag[0] |= zipclevel << 1;
+			bp->Zdr.z_version[0] = 20;
+		}
+		sf = tf;
+		sname = tlate;
+	} else {
+		*csize = st->st_size;
+		sf = fd;
+		sname = fn;
+	}
+	if ((lseek(sf, 0, SEEK_SET)) != 0) {
+		emsg(3, "Cannot rewind \"%s\"", sname);
+		errcnt++;
+		close(fd);
+		ftruncate(tf, 0);
+		return -1;
+	}
+	le32p(*crc, bp->Zdr.z_crc32);
+	if (st->st_size >= 0xffffffff || *csize >= 0xffffffff) {
+		int	n;
+		zfp = &zf;
+		memset(&zf, 0, SIZEOF_zextra_64);
+		le16p(mag_zip64f, zf.ze_64_tag);
+		le16p(SIZEOF_zextra_64 - 4, zf.ze_64_tsize);
+		le64p(st->st_size, zf.ze_64_nsize);
+		le64p(*csize, zf.ze_64_csize);
+		le32p(0xffffffff, bp->Zdr.z_csize);
+		le32p(0xffffffff, bp->Zdr.z_nsize);
+		n = (ple16(bp->Zdr.z_extralen)&0177777) + SIZEOF_zextra_64;
+		le16p(n, bp->Zdr.z_extralen);
+	} else
+		le32p(*csize, bp->Zdr.z_csize);
+	bwrite((char *)bp, SIZEOF_zip_header);
+	bwrite(fn, sz);
+	if (zfp)
+		bwrite((char *)zfp, SIZEOF_zextra_64);
+	zipwxtra(fn, st, dev, ino);
+	size = *csize;
+	while (size) {
+		if ((rd=read(sf, ibuf, size>sizeof ibuf?sizeof ibuf:size)) <= 0)
+			msg(3, 1, "Cannot read \"%s\"\n", sname);
+		bwrite(ibuf, rd);
+		size -= rd;
+	}
+	ftruncate(tf, 0);
+	close(fd);
+	return 0;
+}
+
+#if USE_ZLIB
+/*
+ * Write a zip archive entry using the data descriptor structure.
+ */
+static int
+zipwdesc(int fd, const char *fn, struct stat *st, union bincpio *bp, size_t sz,
+		uint32_t dev, uint32_t ino, uint32_t *crc, long long *csize)
+{
+	struct zextra_64	zf;
+	struct zextra_64	*zfp = 0;
+	char	ibuf[32768], obuf[32768];
+	long long	size = st->st_size;
+	ssize_t	rd;
+	struct z_stream_s	z;
+	int	cuse;
+
+	*csize = 0;
+	*crc = 0;
+	memset(&z, 0, sizeof z);
+	if ((cuse = deflateInit2(&z, ziptrlevel(), Z_DEFLATED,
+					-15, 8, Z_DEFAULT_STRATEGY)) < 0)
+		return zipwtemp(fd, fn, st, bp, sz, dev, ino, crc, csize);
+	bp->Zdr.z_cmethod[0] = C_DEFLATED;
+	bp->Zdr.z_gflag[0] |= zipclevel << 1 | FG_DESC;
+	bp->Zdr.z_version[0] = 20;
+	/*
+	 * RFC 1951 states that deflate compression needs 5 bytes additional
+	 * space per 32k block in the worst case. Thus a compressed size
+	 * greater than 4G-1 can be reached if at least 131052 blocks are
+	 * used.
+	 */
+	if (st->st_size >= 131052LL*32768) {
+		int	n;
+		zfp = &zf;
+		memset(&zf, 0, SIZEOF_zextra_64);
+		le16p(mag_zip64f, zf.ze_64_tag);
+		le16p(SIZEOF_zextra_64 - 4, zf.ze_64_tsize);
+		le32p(0xffffffff, bp->Zdr.z_csize);
+		le32p(0xffffffff, bp->Zdr.z_nsize);
+		n = (ple16(bp->Zdr.z_extralen)&0177777) + SIZEOF_zextra_64;
+		le16p(n, bp->Zdr.z_extralen);
+	}
+	bwrite((char *)bp, SIZEOF_zip_header);
+	bwrite(fn, sz);
+	if (zfp)
+		bwrite((char *)zfp, SIZEOF_zextra_64);
+	zipwxtra(fn, st, dev, ino);
+	do {
+		if (z.avail_in == 0 && size > 0) {
+			if ((rd = read(fd, ibuf, sizeof ibuf)) <= 0) {
+				emsg(3, "Cannot read \"%s\"", fn);
+				st->st_size -= size;
+				size = 0;	/* can't simply stop here */
+				rd = 0;		/* no data */
+			}
+			z.next_in = (unsigned char *)ibuf;
+			z.avail_in = z.total_in = rd;
+			size -= rd;
+			*crc = zipcrc(*crc, (unsigned char *)ibuf, rd);
+		}
+		if (z.next_out == NULL || (char *)z.next_out > obuf) {
+			if (z.next_out) {
+				bwrite(obuf, (char *)z.next_out - obuf);
+				*csize += (char *)z.next_out - obuf;
+			}
+			z.next_out = (unsigned char *)obuf;
+			z.avail_out = sizeof obuf;
+		}
+		if (cuse >= 0 && cuse != Z_STREAM_END)
+			cuse = deflate(&z, z.avail_in?Z_NO_FLUSH:Z_FINISH);
+		else
+			z.avail_in = 0;
+	} while (size > 0 || (char *)z.next_out > obuf ||
+			cuse >= 0 && cuse != Z_STREAM_END);
+	deflateEnd(&z);
+	if (zfp) {
+		struct zipddesc64	zd64;
+		memcpy(zd64.zd_signature, mag_zipdds, sizeof mag_zipdds);
+		le32p(*crc, zd64.zd_crc32);
+		le64p(st->st_size, zd64.zd_nsize);
+		le64p(*csize, zd64.zd_csize);
+		bwrite((char *)&zd64, SIZEOF_zipddesc64);
+	} else {
+		struct zipddesc	zd;
+		memcpy(zd.zd_signature, mag_zipdds, sizeof mag_zipdds);
+		le32p(*crc, zd.zd_crc32);
+		le32p(st->st_size, zd.zd_nsize);
+		le32p(*csize, zd.zd_csize);
+		bwrite((char *)&zd, SIZEOF_zipddesc);
+	}
+	close(fd);
+	return 0;
+}
+#endif	/* USE_ZLIB */
+
+/*
+ * Write the extra fields for a file to a zip archive (currently
+ * our own field type). Note that the z_extralen field in the file
+ * header must correspond to the size of the data written here.
+ */
+static int
+zipwxtra(const char *fn, struct stat *st, uint32_t dev, uint32_t ino)
+{
+	struct zextra_cp	z;
+
+	memset(&z, 0, SIZEOF_zextra_cp);
+	le16p(mag_zipcpio, z.ze_cp_tag);
+	le16p(SIZEOF_zextra_cp - 4, z.ze_cp_tsize);
+	le32p(dev, z.ze_cp_mode);
+	le32p(ino, z.ze_cp_ino);
+	le32p(st->st_mode&(S_IFMT|07777), z.ze_cp_mode);
+	le32p(st->st_uid, z.ze_cp_uid);
+	le32p(st->st_gid, z.ze_cp_gid);
+	le32p(st->st_nlink, z.ze_cp_nlink);
+	le32p(st->st_rdev, z.ze_cp_rdev);
+	le32p(st->st_mtime, z.ze_cp_mtime);
+	le32p(st->st_atime, z.ze_cp_atime);
+	bwrite((char *)&z, SIZEOF_zextra_cp);
+	return SIZEOF_zextra_cp;
+}
+
+static void
+zipinfo(struct file *f)
+{
+	const char	*cp;
+	char	b[5];
+	int	i;
+
+	printf(" %7llu", f->f_csize);
+	if (f->f_dsize) {
+		i = f->f_csize*100 / f->f_dsize;
+		i += f->f_csize*200 / f->f_dsize & 1;
+		i = 100 - i;
+	} else
+		i = 0;
+	printf(" %3d%%", i);
+	switch (f->f_cmethod) {
+	case C_STORED:
+		cp = "stor";
+		break;
+	case C_SHRUNK:
+		cp = "shrk";
+		break;
+	case C_REDUCED1:
+		cp = "re:1";
+		break;
+	case C_REDUCED2:
+		cp = "re:2";
+		break;
+	case C_REDUCED3:
+		cp = "re:3";
+		break;
+	case C_REDUCED4:
+		cp = "re:4";
+		break;
+	case C_IMPLODED:
+		b[0] = 'i';
+		b[1] = f->f_gflag & FG_BIT1 ? '8' : '4';
+		b[2] = ':';
+		b[3] = f->f_gflag & FG_BIT2 ? '3' : '2';
+		b[4] = '\0';
+		cp = b;
+		break;
+	case C_TOKENIZED:
+		cp = "tokn";
+		break;
+	case C_DEFLATED:
+		b[0] = 'd', b[1] = 'e', b[2] = 'f', b[4] = '\0';
+		if (f->f_gflag & FG_BIT2)
+			b[3] = f->f_gflag & FG_BIT1 ? 'S' : 'F';
+		else
+			b[3] = f->f_gflag & FG_BIT1 ? 'X' : 'N';
+		cp = b;
+		break;
+	case C_ENHDEFLD:
+		cp = "edef";
+		break;
+	case C_DCLIMPLODED:
+		cp = "dcli";
+		break;
+	case C_BZIP2:
+		cp = "bz2 ";
+		break;
+	default:
+		snprintf(b, sizeof b, "%4.4X", f->f_cmethod);
+		cp = b;
+	}
+	printf(" %s", cp);
+}
+
+#if USE_BZLIB
+int
+zipunbz2(struct file *f, const char *tgt, int tfd, int doswap, uint32_t *crc)
+{
+	bz_stream	bs;
+	long long	isize = f->f_csize;
+	char	ibuf[4096], obuf[8192];
+	int	in, on, val = 0, ok;
+
+	memset(&bs, 0, sizeof bs);
+
+	if ((ok = BZ2_bzDecompressInit(&bs, 0, 0)) != BZ_OK) {
+		msg(3, 0, "bzip2 initialization error %d on \"%s\"\n",
+				ok, f->f_name);
+		errcnt++;
+		return skipfile(f);
+	}
+	while (isize > 0 || ok == BZ_OK) {
+		if (bs.avail_in == 0 && isize > 0) {
+			in = sizeof ibuf < isize ? sizeof ibuf : isize;
+			isize -= in;
+			if (bread(ibuf, in) != in)
+				unexeoa();
+			if (doswap)
+				swap(ibuf, in, bflag || sflag, bflag || Sflag);
+			bs.next_in = ibuf;
+			bs.avail_in = in;
+		}
+		if (ok == BZ_OK) {
+			bs.next_out = obuf;
+			bs.avail_out = sizeof obuf;
+			switch (ok = BZ2_bzDecompress(&bs)) {
+			case BZ_OK:
+			case BZ_STREAM_END:
+				on = sizeof obuf - bs.avail_out;
+				if (tfd >= 0 && write(tfd, obuf, on) != on) {
+					emsg(3, "Cannot write \"%s\"", tgt);
+					tfd = -1;
+					val = 1;
+				}
+				*crc = zipcrc(*crc, (unsigned char *)obuf, on);
+				break;
+			default:
+				msg(3, 0, "compression error %d on \"%s\"\n",
+					ok, f->f_name);
+				errcnt++;
+				val = 1;
+			}
+		}
+	}
+	BZ2_bzDecompressEnd(&bs);
+	return val;
+}
+#endif	/* USE_BZLIB */
+
+struct	blasthow {
+	struct file	*bh_f;
+	const char	*bh_tgt;
+	long long	bh_isize;
+	uint32_t	*bh_crc;
+	int		bh_tfd;
+	int		bh_doswap;
+	int		bh_val;
+};
+
+static unsigned
+blastin(void *how, unsigned char **buf)
+{
+	const int	chunk = 16384;
+	static unsigned char	*hold;
+	struct blasthow	*bp = how;
+	unsigned	sz;
+
+	if (bp->bh_isize <= 0)
+		return 0;
+	if (hold == NULL)
+		hold = smalloc(chunk);
+	sz = bp->bh_isize > chunk ? chunk : bp->bh_isize;
+	bp->bh_isize -= sz;
+	if (bread((char *)hold, sz) != sz)
+		unexeoa();
+	if (bp->bh_doswap)
+		swap((char *)hold, sz, bflag || sflag, bflag || Sflag);
+	*buf = hold;
+	return sz;
+}
+
+static int
+blastout(void *how, unsigned char *buf, unsigned len)
+{
+	struct blasthow	*bp = how;
+
+	if (bp->bh_tfd >= 0 && write(bp->bh_tfd, buf, len) != len) {
+		emsg(3, "Cannot write \"%s\"", bp->bh_tgt);
+		bp->bh_tfd = -1;
+		bp->bh_val = 1;
+	}
+	*bp->bh_crc = zipcrc(*bp->bh_crc, buf, len);
+	return 0;
+}
+
+int
+zipblast(struct file *f, const char *tgt, int tfd, int doswap, uint32_t *crc)
+{
+	struct blasthow	bh;
+	int	n;
+
+	bh.bh_f = f;
+	bh.bh_tgt = tgt;
+	bh.bh_isize = f->f_csize;
+	bh.bh_crc = crc;
+	bh.bh_tfd = tfd;
+	bh.bh_doswap = doswap;
+	bh.bh_val = 0;
+	switch (n = blast(blastin, &bh, blastout, &bh)) {
+	case 0:
+		break;
+	default:
+		msg(3, 0, "compression error %d on \"%s\"\n", n, f->f_name);
+		errcnt++;
+		bh.bh_val = 1;
+	}
+	while (bh.bh_isize) {
+		char	buf[4096];
+		unsigned	n;
+		n = bh.bh_isize > sizeof buf ? sizeof buf : bh.bh_isize;
+		if (bread(buf, n) != n)
+			unexeoa();
+		bh.bh_isize -= n;
+	}
+	return bh.bh_val;
+}
+
+/*
+ * The SGI -K format was introduced with SGI's IRIX 5.X. It is essentially
+ * a slightly extended binary format. The known additions are:
+ *
+ * - If the major or minor st_rdev device number exceeds the limit of
+ *   255 imposed by the 16-bit c_rdev field, this field is set to 0xFFFF
+ *   and st_rdev is stored in the c_filesize 32-bit field. The first 14
+ *   bits of this field compose the major device number, the minor is
+ *   stored in the remaining 18 bits. This enables implementations to
+ *   read the modified format without special support if they ignore
+ *   the size of device files; otherwise they will try to read a lot
+ *   of archive data and fail.
+ *
+ * - If the file is larger than 2 GB - 1 byte, two nearly identical
+ *   archive headers are stored for it. The only difference is in
+ *   the c_filesize field:
+ *
+ *   [first header: file size X times 2 GB]
+ *    [first data part: X times 2 GB]
+ *   [second header: file size modulo 2 GB]
+ *    [second data part: rest of data]
+ *
+ *   The first header can be recognized by a negative c_filesize. A
+ *   value of 0xFFFFFFFF means that 2 GB follow, 0xFFFFFFFE -> 4 GB
+ *   0xFFFFFFFD -> 6 GB, 0xFFFFFFFC -> 8 GB, and so forth. The second
+ *   is a standard binary cpio header, although the following data is
+ *   meant to be appended to the preceding file.
+ *
+ *   It is important to note that padding follows the number in
+ *   c_filesize, not the amount of data written; thus all data parts
+ *   with odd c_filesize fields (0xFFFFFFFF = 2+ GB, 0xFFFFFFFD = 6+ GB
+ *   etc.) cause the following archive entries to be aligned on an odd
+ *   offset. This seems to be an implementation artifact but has to be
+ *   followed for compatibility.
+ *
+ *   This extension seems a bit weird since no known cpio implementation
+ *   is able to read these archive entries without special support. Thus
+ *   a more straightforward extension (such as storing the size just past
+ *   the file name) would well have had the same effect. Nevertheless,
+ *   the cpio -K format is useful, so it is implemented here.
+ *
+ *   --Note that IRIX 6.X tar also has a -K option. This option extends
+ *   the tar format in essentially the same way as the second extension
+ *   to cpio described above. Unfortunately, the result is definitively
+ *   broken. Contrasting to the binary cpio format, the standard POSIX
+ *   tar format is well able to hold files of size 0xFFFFFFFF and below
+ *   in a regular manner. Thus, a tar -K archive entry is _exactly_ the
+ *   same as two regular POSIX tar entries for the same file. And this
+ *   situation even occurs on a regular basis with tar -r! For this
+ *   reason, we do not implement the IRIX tar -K format and will probably
+ *   never do so unless it is changed (the tar format really has a lot
+ *   of options to indicate extensions that might be used for this).
+ *
+ *   Many thanks to Sven Mascheck who made archiving tests on the IRIX
+ *   machine.
+ */
+/*
+ * This function reads the second header of a SGI -K format archive.
+ */
+static void
+readK2hdr(struct file *f)
+{
+	struct file	n;
+	union bincpio	bc;
+
+	n.f_name = n.f_lnam = NULL;
+	n.f_nsiz = n.f_lsiz = 0;
+	readhdr(&n, &bc);
+	f->f_Krest = n.f_st.st_size;
+	f->f_dsize = f->f_st.st_size = n.f_st.st_size + f->f_Kbase;
+	f->f_Kbase = 0;
+	free(n.f_name);
+	free(n.f_lnam);
+}
+
+/*
+ * Read the data of a GNU filename extra header.
+ */
+static int
+readgnuname(char **np, size_t *sp, long length)
+{
+	if (length > SANELIMIT)
+		return -1;
+	if (*sp == 0 || *sp <= length)
+		*np = srealloc(*np, *sp = length+1);
+	bread(*np, length);
+	(*np)[length] = '\0';
+	skippad(length, 512);
+	return 0;
+}
+
+/*
+ * Write a GNU filename extra header and its data.
+ */
+static void
+writegnuname(const char *fn, long length, int flag)
+{
+	union bincpio	bc;
+
+	memset(bc.data, 0, 512);
+	strcpy(bc.Tdr.t_name, "././@LongLink");
+	sprintf(bc.Tdr.t_mode, "%7.7o", 0);
+	sprintf(bc.Tdr.t_uid, "%7.7o", 0);
+	sprintf(bc.Tdr.t_gid, "%7.7o", 0);
+	sprintf(bc.Tdr.t_size, "%11.11lo", length);
+	sprintf(bc.Tdr.t_mtime, "%11.11lo", 0L);
+	bc.Tdr.t_linkflag = flag;
+	memcpy(bc.Tdr.t_magic, mag_gnutar, 8);
+	strcpy(bc.Tdr.t_uname, "root");
+	strcpy(bc.Tdr.t_gname, "root");
+	tchksum(&bc);
+	bwrite(bc.data, 512);
+	bwrite(fn, length);
+	length %= 512;
+	memset(bc.data, 0, 512 - length);
+	bwrite(bc.data, 512 - length);
+}
+
+/*
+ * POSIX.1-2001 pax format support.
+ */
+static void
+tgetpax(struct tar_header *tp, struct file *f)
+{
+	char	*keyword, *value;
+	char	*block, *bp;
+	long long	n;
+	enum paxrec	pr;
+
+	n = rdoct(tp->t_size, 12);
+	bp = block = smalloc(n+1);
+	bread(block, n);
+	skippad(n, 512);
+	block[n] = '\0';
+	while (bp < &block[n]) {
+		int	c;
+		pr = tgetrec(&bp, &keyword, &value);
+		switch (pr) {
+		case PR_ATIME:
+			f->f_st.st_atime = strtoll(value, NULL, 10);
+			break;
+		case PR_GID:
+			f->f_st.st_gid = strtoll(value, NULL, 10);
+			break;
+		case PR_LINKPATH:
+			c = strlen(value);
+			if (f->f_lnam == NULL || f->f_lsiz < c+1) {
+				f->f_lsiz = c+1;
+				f->f_lnam = srealloc(f->f_lnam, c+1);
+			}
+			strcpy(f->f_lnam, value);
+			break;
+		case PR_MTIME:
+			f->f_st.st_mtime = strtoll(value, NULL, 10);
+			break;
+		case PR_PATH:
+			c = strlen(value);
+			if (f->f_name == NULL || f->f_nsiz < c+1) {
+				f->f_nsiz = c+1;
+				f->f_name = srealloc(f->f_name, c+1);
+			}
+			strcpy(f->f_name, value);
+			break;
+		case PR_SIZE:
+			f->f_st.st_size = strtoll(value, NULL, 10);
+			break;
+		case PR_UID:
+			f->f_st.st_uid = strtoll(value, NULL, 10);
+			break;
+		case PR_SUN_DEVMAJOR:
+			f->f_rmajor = strtoll(value, NULL, 10);
+			break;
+		case PR_SUN_DEVMINOR:
+			f->f_rminor = strtoll(value, NULL, 10);
+			break;
+		}
+		paxrec |= pr;
+	}
+	if (tp->t_linkflag == 'g') {
+		globrec = paxrec & ~(PR_LINKPATH|PR_PATH|PR_SIZE);
+		globst = f->f_st;
+	}
+	free(block);
+}
+
+static enum paxrec
+tgetrec(char **bp, char **keyword, char **value)
+{
+	char	*x;
+	long	n = 0;
+	enum paxrec	pr;
+
+	*keyword = "";
+	*value = "";
+	while (**bp && (n = strtol(*bp, &x, 10)) <= 0 && (*x!=' ' || *x!='\t'))
+		do
+			(*bp)++;
+		while (**bp && **bp != '\n');
+	if (*x == '\0' || **bp == '\0') {
+		(*bp)++;
+		return PR_NONE;
+	}
+	while (x < &(*bp)[n] && (*x == ' ' || *x == '\t'))
+		x++;
+	if (x == &(*bp)[n] || *x == '=')
+		goto out;
+	*keyword = x;
+	while (x < &(*bp)[n] && *x != '=')
+		x++;
+	if (x == &(*bp)[n])
+		goto out;
+	*x = '\0';
+	if (&x[1] < &(*bp)[n])
+		*value = &x[1];
+	(*bp)[n-1] = '\0';
+out:	*bp = &(*bp)[n];
+	if (strcmp(*keyword, "atime") == 0)
+		pr = PR_ATIME;
+	else if (strcmp(*keyword, "gid") == 0)
+		pr = PR_GID;
+	else if (strcmp(*keyword, "linkpath") == 0)
+		pr = PR_LINKPATH;
+	else if (strcmp(*keyword, "mtime") == 0)
+		pr = PR_MTIME;
+	else if (strcmp(*keyword, "path") == 0)
+		pr = PR_PATH;
+	else if (strcmp(*keyword, "size") == 0)
+		pr = PR_SIZE;
+	else if (strcmp(*keyword, "uid") == 0)
+		pr = PR_UID;
+	else if (strcmp(*keyword, "SUN.devmajor") == 0)
+		pr = PR_SUN_DEVMAJOR;
+	else if (strcmp(*keyword, "SUN.devminor") == 0)
+		pr = PR_SUN_DEVMINOR;
+	else
+		pr = PR_NONE;
+	return pr;
+}
+
+static void
+wrpax(const char *longname, const char *linkname, struct stat *sp)
+{
+	union bincpio	bc;
+	char	*pdata = NULL;
+	long	psize = 0, pcur = 0;
+	long long	blocks;
+
+	memset(bc.data, 0, 512);
+	if (paxrec & PR_ATIME)
+		addrec(&pdata, &psize, &pcur, "atime", NULL, sp->st_atime);
+	if (paxrec & PR_GID)
+		addrec(&pdata, &psize, &pcur, "gid", NULL, sp->st_gid);
+	if (paxrec & PR_LINKPATH)
+		addrec(&pdata, &psize, &pcur, "linkpath", linkname, 0);
+	if (paxrec & PR_MTIME)
+		addrec(&pdata, &psize, &pcur, "mtime", NULL, sp->st_mtime);
+	if (paxrec & PR_PATH)
+		addrec(&pdata, &psize, &pcur, "path", longname, 0);
+	if (paxrec & PR_SIZE)
+		addrec(&pdata, &psize, &pcur, "size", NULL, sp->st_size);
+	if (paxrec & PR_UID)
+		addrec(&pdata, &psize, &pcur, "uid", NULL, sp->st_uid);
+	if (paxrec & PR_SUN_DEVMAJOR)
+		addrec(&pdata, &psize, &pcur, "SUN.devmajor", NULL,
+				major(sp->st_rdev));
+	if (paxrec & PR_SUN_DEVMINOR)
+		addrec(&pdata, &psize, &pcur, "SUN.devminor", NULL,
+				minor(sp->st_rdev));
+	paxnam(&bc.Tdr, longname);
+	sprintf(bc.Tdr.t_mode, "%7.7o", fmttype==FMT_SUN ? 0444|S_IFREG : 0444);
+	sprintf(bc.Tdr.t_uid, "%7.7o", 0);
+	sprintf(bc.Tdr.t_gid, "%7.7o", 0);
+	sprintf(bc.Tdr.t_size, "%11.11lo", pcur);
+	sprintf(bc.Tdr.t_mtime, "%11.11o", 0);
+	strcpy(bc.Tdr.t_magic, "ustar");
+	bc.Tdr.t_version[0] = bc.Tdr.t_version[1] = '0';
+	strcpy(bc.Tdr.t_uname, "root");
+	strcpy(bc.Tdr.t_gname, "root");
+	bc.Tdr.t_linkflag = fmttype==FMT_SUN ? 'X' : 'x';
+	tchksum(&bc);
+	bwrite(bc.data, 512);
+	memset(&pdata[pcur], 0, psize - pcur);
+	blocks = (pcur + (512-1)) / 512;
+	bwrite(pdata, blocks * 512);
+	free(pdata);
+}
+
+static void
+addrec(char **pdata, long *psize, long *pcur,
+		const char *keyword, const char *sval, long long lval)
+{
+	char	dval[25], xval[25];
+	long	od, d, r;
+
+	if (sval == 0) {
+		sprintf(xval, "%lld", lval);
+		sval = xval;
+	}
+	r = strlen(keyword) + strlen(sval) + 3;
+	d = 0;
+	do {
+		od = d;
+		d = sprintf(dval, "%ld", od + r);
+	} while (d != od);
+	*psize += d + r + 1 + 512;
+	*pdata = srealloc(*pdata, *psize);
+	sprintf(&(*pdata)[*pcur], "%s %s=%s\n", dval, keyword, sval);
+	*pcur += d + r;
+}
+
+static void
+paxnam(struct tar_header *hp, const char *name)
+{
+	char	buf[257], *bp;
+	const char	*cp, *np;
+	int	bl = 0;
+	static int	pid;
+
+	if (pid == 0)
+		pid = getpid();
+	for (np = name; *np; np++);
+	while (np > name && *np != '/') {
+		np--;
+		bl++;
+	}
+	if ((np > name || *name == '/') && np-name <= 120)
+		for (bp = buf, cp = name; cp < np; bp++, cp++)
+			*bp = *cp;
+	else {
+		*buf = '.';
+		bp = &buf[1];
+	}
+	snprintf(bp, sizeof buf - (bp - buf), "/PaxHeaders.%d/%s",
+			pid, bl < 100 ? np>name?&np[1]:name : sequence());
+	tmkname(hp, buf);
+}
+
+static char *
+sequence(void)
+{
+	static char	buf[25];
+	static long long	d;
+
+	sprintf(buf, "%10.10lld", ++d);
+	return buf;
+}
+
+static int
+pax_oneopt(const char *s, int warn)
+{
+	if (strcmp(s, "linkdata") == 0)
+		pax_oflag |= PO_LINKDATA;
+	else if (strcmp(s, "times") == 0)
+		pax_oflag |= PO_TIMES;
+	else {
+		if (warn)
+			msg(2, 0, "Unknown flag \"-o %s\"\n", s);
+		return -1;
+	}
+	return 0;
+}
+
+int
+pax_options(char *s, int warn)
+{
+	char	*o = s, c;
+	int	val = 0, word = 0;
+
+	do {
+		if (word == 0) {
+			if (isspace(*s&0377))
+				o = &s[1];
+			else
+				word = 1;
+		}
+		if (*s == ',' || *s == '\0') {
+			c = *s;
+			*s = '\0';
+			val |= pax_oneopt(o, warn);
+			*s = c;
+			o = &s[1];
+			word = 0;
+		}
+	} while (*s++);
+	return val;
+}
+
+/*
+ * Given a symbolic link "base" and the result of readlink "name", form
+ * a valid path name for the link target.
+ */
+static char *
+joinpath(const char *base, char *name)
+{
+	const char	*bp = NULL, *cp;
+	char	*new, *np;
+
+	if (*name == '/')
+		return name;
+	for (cp = base; *cp; cp++)
+		if (*cp == '/')
+			bp = cp;
+	if (bp == NULL)
+		return name;
+	np = new = smalloc(bp - base + strlen(name) + 2);
+	for (cp = base; cp < bp; cp++)
+		*np++ = *cp;
+	*np++ = '/';
+	for (cp = name; *cp; cp++)
+		*np++ = *cp;
+	*np = '\0';
+	free(name);
+	return new;
+}
+
+static int
+utf8(const char *cp)
+{
+	int	c, n;
+
+	while (*cp) if ((c = *cp++ & 0377) & 0200) {
+		if (c == (c & 037 | 0300))
+			n = 1;
+		else if (c == (c & 017 | 0340))
+			n = 2;
+		else if (c == (c & 07 | 0360))
+			n = 3;
+		else if (c == (c & 03 | 0370))
+			n = 4;
+		else if (c == (c & 01 | 0374))
+			n = 5;
+		else
+			return 0;
+		while (n--) {
+			c = *cp++ & 0377;
+			if (c != (c & 077 | 0200))
+				return 0;
+		}
+	}
+	return 1;
+}
+
+static time_t
+fetchtime(const char *cp)
+{
+	struct tm	tm;
+	time_t	t;
+	char	*xp;
+	int	n;
+
+	t = strtoll(cp, &xp, 10);
+	if (*xp == '\0')
+		return t;
+	memset(&tm, 0, sizeof tm);
+	n = sscanf(cp, "%4d%2d%2dT%2d%2d%2d",
+			&tm.tm_year, &tm.tm_mon, &tm.tm_mday,
+			&tm.tm_hour, &tm.tm_min, &tm.tm_sec);
+	tm.tm_year -= 1900;
+	tm.tm_mon--;
+	tm.tm_isdst = -1;
+	t = mktime(&tm);
+	if (n < 3 || t == (time_t)-1)
+		msg(4, 1, "line %lld: illegal time \"%s\"\n",
+				lineno, cp);
+	return t;
+}
+
+static char *
+nextfield(char *cp, const char *fieldname)
+{
+	while (*cp && *cp != ':')
+		cp++;
+	if (*cp == 0)
+		msg(4, 1, "line %lld: unterminated \"%s\" field\n",
+				lineno, fieldname);
+	*cp++ = 0;
+	return cp;
+}
+
+static char *
+getproto(char *np, struct prototype *pp)
+{
+	char	*tp, *xp;
+	long long	t, u;
+
+	memset(pp, 0, sizeof *pp);
+	if (*np == ':')
+		np++;
+	else {
+		tp = nextfield(np, "type");
+		if (np[1]) 
+			goto notype;
+		switch (np[0]) {
+		case 'b':
+			pp->pt_mode |= S_IFBLK;
+			break;
+		case 'c':
+			pp->pt_mode |= S_IFCHR;
+			break;
+		case 'd':
+			pp->pt_mode |= S_IFDIR;
+			break;
+		case 'f':
+			pp->pt_mode |= S_IFREG;
+			break;
+		case 'p':
+			pp->pt_mode |= S_IFIFO;
+			break;
+		case 's':
+			pp->pt_mode |= S_IFLNK;
+			break;
+		default:
+		notype:
+			msg(4, 1, "line %lld: unknown type \"%s\"\n",
+					lineno, np);
+		}
+		pp->pt_spec |= PT_TYPE;
+		np = tp;
+	}
+	if (*np == ':')
+		np++;
+	else {
+		struct passwd	*pwd;
+		tp = nextfield(np, "owner");
+		t = strtoll(np, &xp, 10);
+		if (*xp == '\0')
+			pp->pt_uid = t;
+		else {
+			if ((pwd = getpwnam(np)) == NULL)
+				msg(4, 1, "line %lld: unknown user \"%s\"\n",
+						lineno, np);
+			pp->pt_uid = pwd->pw_uid;
+		}
+		pp->pt_spec |= PT_OWNER;
+		np = tp;
+	}
+	if (*np == ':')
+		np++;
+	else {
+		struct group	*grp;
+		tp = nextfield(np, "group");
+		t = strtoll(np, &xp, 10);
+		if (*xp == '\0')
+			pp->pt_gid = t;
+		else {
+			if ((grp = getgrnam(np)) == NULL)
+				msg(4, 1, "line %lld: unknown group \"%s\"\n",
+						lineno, np);
+			pp->pt_gid = grp->gr_gid;
+		}
+		pp->pt_spec |= PT_GROUP;
+		np = tp;
+	}
+	if (*np == ':')
+		np++;
+	else {
+		tp = nextfield(np, "mode");
+		t = strtol(np, &xp, 8);
+		if (t & ~07777 || *xp)
+			msg(4, 1, "line %lld: illegal mode \"%s\"\n",
+					lineno, np);
+		pp->pt_mode |= t;
+		pp->pt_spec |= PT_MODE;
+		np = tp;
+	}
+	if (*np == ':')
+		np++;
+	else {
+		tp = nextfield(np, "access time");
+		pp->pt_atime = fetchtime(np);
+		pp->pt_spec |= PT_ATIME;
+		np = tp;
+	}
+	if (*np == ':')
+		np++;
+	else {
+		tp = nextfield(np, "modification time");
+		pp->pt_mtime = fetchtime(np);
+		pp->pt_spec |= PT_MTIME;
+		np = tp;
+	}
+	if (*np == ':') {
+		np++;
+		if (*np++ != ':')
+		majmin:	msg(4, 1, "line %lld: need either both major and "
+				"minor or none\n",
+				lineno);
+	} else {
+		tp = nextfield(np, "major");
+		t = strtoll(np, &xp, 10);
+		if (*xp)
+			msg(4, 1, "line %lld: illegal major \"%s\"\n",
+					lineno, np);
+		np = tp;
+		if (*np == ':')
+			goto majmin;
+		tp = nextfield(np, "minor");
+		u = strtoll(np, &xp, 10);
+		if (*xp)
+			msg(4, 1, "line %lld: illegal minor \"%s\"\n",
+					lineno, np);
+		np = tp;
+		pp->pt_rdev = makedev(t, u);
+		pp->pt_spec |= PT_RDEV;
+	}
+	return np;
+}