pax.c

/***********************************************************************
*                                                                      *
*               This software is part of the ast package               *
*          Copyright (c) 1987-2012 AT&T Intellectual Property          *
*                      and is licensed under the                       *
*                 Eclipse Public License, Version 1.0                  *
*                    by AT&T Intellectual Property                     *
*                                                                      *
*                A copy of the License is available at                 *
*          http://www.eclipse.org/org/documents/epl-v10.html           *
*         (with md5 checksum b35adb5213ca9657e911e9befb180842)         *
*                                                                      *
*              Information and Software Systems Research               *
*                            AT&T Research                             *
*                           Florham Park NJ                            *
*                                                                      *
*                 Glenn Fowler <[email protected]>                  *
*                                                                      *
***********************************************************************/
#pragma prototyped
/*
 * Glenn Fowler
 * AT&T Research
 *
 * pax -- portable archive interchange
 *
 * test registry:
 *
 *	0000010	dump option table
 *	0000020	force DELTA_TEMP to file
 *	0000040	pretend io device is char special
 *	0000100	don't copy in holes
 *	0000200	sleep(1) between meter displays
 */

static const char usage[] =
"[-?\n@(#)$Id: pax (AT&T Research) 2012-05-25 $\n]"
USAGE_LICENSE
"[+NAME?pax - read, write, and list file archives]"
"[+DESCRIPTION?The pax command reads, writes, and lists archive files in"
"	various formats. There are four operation modes controlled by"
"	combinations of the -\br\b and -\bw\b options.]"
"[+?\bpax -w\b writes the files and directories named by the \apathname\a"
"	arguments to the standard output together with pathname and status"
"	information.  A directory \apathname\a argument refers to the files and"
"	(recursively) subdirectories of that directory.  If no \apathname\a"
"	arguments are given then the standard input is read to get a list of"
"	pathnames to copy, one pathname per line.  In this case only those"
"	pathnames appearing on the standard input are copied.]"
"[+?\bpax -r\b reads the standard input that is assumed to be the result of a"
"	previous \bpax -w\b command.  Only member files with names"
"	that match any of the \apattern\a arguments are selected.  Matching"
"	is done before any \b-i\b or \b-s\b options are applied.  A"
"	\apattern\a is given in the name-generating notation of \bsh\b(1),"
"	except that the \b/\b character is also matched.  The default if no"
"	\apattern\a is given is \b*\b which selects all files.  The selected"
"	files are conditionally created and copied relative to the current"
"	directory tree, subject to the options described below.  By default the"
"	owner and group of selected files will be that of the current user, and"
"	the permissions and modify times will be the same as those in the"
"	archive.]"
"[+?\bpax -rw\b reads the files and directories named in the \apathname\a"
"	arguments and copies them to the destination \adirectory\a."
"	A directory \apathname\a argument refers to the files and (recursively)"
"	subdirectories of that directory.  If no \apathname\a arguments are"
"	given then the standard input is read to get a list of pathnames to"
"	copy, one pathname per l, lineine.  In this case only those pathnames"
"	appearing on the standard input are copied.  \adirectory\a must exist"
"	before the copy.]"
"[+?\bpax\b (\b-r\b and \b-w\b omitted) reads the standard input that is"
"	assumed to be the result of a previous \bpax -w\b command and lists"
"	table of contents of the selected member files on the standard output.]"
"[+?The standard archive formats are automatically detected on input."
"	The default output archive format is \b\fdefault\f\b, but may be"
"	overridden by the \b-x\b option described below. \bpax\b archives may"
"	be concatenated to combine multiple volumes on a single tape or file."
"	This is accomplished by forcing any format prescribed pad data to be"
"	null bytes.  Hard links are not maintained between volumes, and delta"
"	and base archives cannot be multi-volume.]"
"[+?A single archive may span many files/devices.  The second and"
"	subsequent file names are prompted for on the terminal input.  The"
"	response may be:]{"
"		[+!command?Execute \acommand\a via \bsystem\b(3) and prompt"
"			again for file name.]"
"		[+EOF?Terminate processing and exit.]"
"		[+CR?An empty input line retains the previous file name.]"
"		[+pathname?The file name for the next archive part.]"
"}"
"[+?\bgetconf PATH_RESOLVE\b determines how symbolic links are handled. This"
"	can be explicitly overridden by the \b--logical\b, \b--metaphysical\b,"
"	and \b--physical\b options below. \bPATH_RESOLVE\b can be one of:]{"
"		[+logical?Follow all symbolic links.]"
"		[+metaphysical?Follow command argument symbolic links,"
"			otherwise don't follow.]"
"		[+physical?Don't follow symbolic links.]"
"}"
;

/* state.usage is generated at runtime from usage+options+usage2 */

static const char usage2[] =
"\n"
"[ pathname ... ]\n"
"[ pattern ... ]\n"
"[ pathname ... directory ]\n"
"\n"
"[+DIAGNOSTICS?The number of files, blocks, and optionally the number"
"	of volumes and media parts are listed on the standard error."
"	For -\bv\b the input archive formats are also listed on the"
"	standard error.]"
"[+EXAMPLES]{"
"	[+pax -w -t 1m .?Copies the contents of the current directory to"
"		tape drive 1, medium density.]"
"	[+mkdir newdir; cd olddir; pax -rw . newdir?Copies the"
"		\aolddir\a directory hierarchy to \anewdir\a.]"
"}"
"[+SEE ALSO?\bar\b(1), \bcpio\b(1), \bfind\b(1), \bgetconf\b(1), \bgzip\b(1),"
"	\bksh\b(1), \bratz\b(1), \bstar\b(1), \btar\b(1), \btw\b(1),"
"	\bfsync\b(2), \blibdelta\b(3), \bcpio\b(5), \btar\b(5)]"
"[+BUGS?Special privileges may be required to copy special files."
"	Some archive formats have hard upper limits on member string, numeric"
"	and data sizes. Attribute values larger than the standard min-max"
"	values may cause additional header or embedded data records to be"
"	output for some formats; these records are ignored by old versions"
"	of \bcpio\b(1) and \btar\b(1). \b--format=pax\b avoids size and"
"	portability limitations \abut\a requires a working reader on the"
"	receiving side.]"
;

#include "pax.h"

#include <ardir.h>
#include <iconv.h>
#include <tm.h>

char*			definput = "/dev/stdin";
char*			defoutput = "/dev/stdout";
char*			eomprompt = "Change to part %d and hit RETURN: ";

State_t			state;

static int		signals[] =	/* signals caught by interrupt() */
{
	SIGHUP,
	SIGINT,
#if !DEBUG
	SIGQUIT,
#endif
	SIGALRM,
	SIGTERM,
};

static struct
{
	char*		arg0;
	Sfio_t*		ignore_all;
	Sfio_t*		ignore_ext;
	Map_t*		lastmap;
	Sfio_t*		listformat;
	char*		owner;
} opt;

/*
 * clean up dir info before exit
 */

static void
interrupt(int sig)
{
	signal(sig, SIG_IGN);
	switch (sig)
	{
	case SIGINT:
	case SIGQUIT:
		sfprintf(sfstderr, "\n");
		break;
	}
	state.interrupt = sig;
	finish(1);
}

/*
 * enter new substitute expression(s)
 */

static void
substitute(Map_t** lastmap, register char* s)
{
	register Map_t*	mp;
	int		c;

	for (;;)
	{
		while (isspace(*s))
			s++;
		if (!*s)
			break;
		if (!(mp = newof(0, Map_t, 1, 0)))
			error(3, "no space [substitution]");
		if (!(c = regcomp(&mp->re, s, REG_DELIMITED|REG_LENIENT|REG_NULL)))
		{
			s += mp->re.re_npat;
			if (!(c = regsubcomp(&mp->re, s, NiL, 0, 0)))
				s += mp->re.re_npat;
		}
		if (c)
			regfatal(&mp->re, 4, c);
		for (;;)
		{
			switch (*s++)
			{
			case 'i':
				mp->flags |= MAP_INDEX;
				continue;
			}
			s--;
			break;
		}
		if (*s && !isspace(*s))
			error(1, "invalid character after substitution: %s", s);
		if (*lastmap)
			*lastmap = (*lastmap)->next = mp;
		else
			state.maps = *lastmap = mp;
	}
}

/*
 * clear meter line for each error message
 */

static ssize_t
meterror(int fd, const void* buf, size_t n)
{
	if (state.meter.last)
	{
		sfprintf(sfstderr, "%*s\r", state.meter.last, "");
		state.meter.last = 0;
	}
	return write(fd, buf, n);
}

/*
 * construct an action from command
 */

static Filter_t*
action(const char* command, int pattern)
{
	register Filter_t*	fp;
	register char*		s;
	register char*		t;
	register int		c;
	register int		q;
	register int		n;
	regex_t*		re;

	s = (char*)command;
	if (pattern && *s && *s == *(s + 1))
	{
		s += 2;
		pattern = 0;
	}
	if (pattern)
	{
		if (!(re = newof(0, regex_t, 1, 0)))
			nospace();
		if (c = regcomp(re, s, REG_SHELL|REG_AUGMENTED|REG_DELIMITED|REG_LENIENT|REG_NULL|REG_LEFT|REG_RIGHT))
			regfatal(re, 4, c);
		s += re->re_npat;
	}
	else
		re = 0;
	command = (const char*)s;
	q = 0;
	n = 3;
	while (c = *s++)
		if (c == '"' || c == '\'')
		{
			if (!q)
				q = c;
			else if (q == c)
				q = 0;
		}
		else if (c == '\\')
		{
			if (q != '\'' && *s)
				s++;
		}
		else if (!q && isspace(c))
		{
			n++;
			while (isspace(*s))
				s++;
		}
	if (!(fp = newof(0, Filter_t, 1, n * sizeof(char**) + 2 * (s - (char*)command))))
		nospace();
	fp->re = re;
	fp->argv = (char**)(fp + 1);
	fp->command = (char*)(fp->argv + n);
	s = strcopy(fp->command, command) + 1;
	strcpy(s, command);
	fp->argv[0] = s;
	q = 0;
	n = 1;
	t = s;
	while (c = *s++)
		if (c == '"' || c == '\'')
		{
			if (!q)
				q = c;
			else if (q == c)
				q = 0;
			else
				*t++ = c;
		}
		else if (c == '\\')
		{
			if (q == '\'')
				*t++ = c;
			else if (*s)
				*t++ = *s++;
		}
		else if (q || !isspace(c))
			*t++ = c;
		else
		{
			*t++ = 0;
			while (isspace(*s))
				s++;
			if (*(t = s))
				fp->argv[n++] = s;
		}
	*t = 0;
	fp->patharg = fp->argv + n;
	return fp;
}

/*
 * return action for f, 0 if no match
 */

Filter_t*
filter(Archive_t* ap, File_t* f)
{
	register Filter_t*	fp;

	if (f->st->st_size && (fp = state.filter.list))
		do
		{
			if (!fp->re || !regexec(fp->re, f->name, NiL, 0, 0))
				return fp;
		} while (fp = fp->next);
	return 0;
}

/*
 * set options from line if != 0 or argv according to usage
 * type: 0:command EXTTYPE:extended GLBTYPE:global
 */

void
setoptions(char* line, size_t hdr, char** argv, char* usage, Archive_t* ap, int type)
{
	intmax_t	n;
	int		c;
	int		y;
	int		assignment;
	int		cvt;
	int		index;
	int		offset;
	int		from;
	int		to;
	char*		e;
	char*		s;
	char*		v;
	char*		o;
	char*		end;
	Filter_t*	xp;
	Format_t*	fp;
	Option_t*	op;
	Sfio_t*		sp;
	Value_t*	vp;
	char		tmp1[PATH_MAX];
	char		tmp2[PATH_MAX];

	cvt = 0;
	index = opt_info.index;
	offset = opt_info.offset;
	if (line && hdr)
		end = line + hdr;
	for (;;)
	{
		if (hdr)
		{
			if (!*line)
				break;
			while (isspace(*line))
				line++;
			s = line;
			y = 0;
			while ((c = *line++) >= '0' && c <= '9')
				y = y * 10 + (c - '0');
			if ((e = (s + y - 1)) > end)
				e = end;
			else
				*e++ = 0;
			while (isspace(*line))
				line++;
			o = line;
			assignment = 0;
			for (;;)
			{
				switch (*line++)
				{
				case 0:
					line--;
					break;
				case '=':
					*(line - 1) = 0;
					break;
				case ':':
					if (*line == '=')
					{
						*(line - 1) = 0;
						line++;
						assignment = 1;
						break;
					}
					continue;
				default:
					continue;
				}
				break;
			}
			v = line;
			line = e;
			y = 1;
			if (!(op = (Option_t*)hashget(state.options, o)))
			{
				s = o;
				if (strneq(o, VENDOR ".", sizeof(VENDOR)))
				{
					o += sizeof(VENDOR);
					op = (Option_t*)hashget(state.options, o);
				}
				if (!op && *o == 'n' && *(o + 1) == 'o')
				{
					o += 2;
					y = 0;
					op = (Option_t*)hashget(state.options, o);
				}
				if (!op)
				{
					if (islower(*s) && !strchr(s, '.'))
						error(2, "%s: unknown option", s);
					continue;
				}
			}
			if (!y)
				n = 0;
			else if (!(op->flags & OPT_NUMBER))
				n = 1;
			else
			{
				n = strtonll(v, &e, NiL, 0);
				if (*e)
					error(2, "%s: %s: invalid numeric option value", op->name, v);
			}
		}
		else if (!(c = line ? optstr(line, usage) : optget(argv, usage)))
			break;
		else if (c > 0)
		{
			if (c == '?')
				error(ERROR_USAGE|4, "%s", opt_info.arg);
			if (c == ':' && (!type || islower(*opt_info.name) && !strchr(opt_info.name, '.')))
				error(2, "%s", opt_info.arg);
			continue;
		}
		else
		{
			assignment = opt_info.assignment == ':';
			y = (n = opt_info.number) != 0;
			if (!(v = opt_info.arg))
				v = "";
			else if (!n)
				y = 1;
			op = options - c;
		}

		/*
		 * option precedence levels
		 *
		 *	8	ignore all
		 *	7	command:=
		 *	6	ignore extended
		 *	5	extended:=
		 *	4	extended=
		 *	3	command=
		 *	2	global:=
		 *	1	global=
		 */

		switch (type)
		{
		case EXTTYPE:
			c = 4;
			vp = &op->temp;
			break;
		case GLBTYPE:
			c = 1;
			vp = &op->perm;
			break;
		default:
			c = 3;
			vp = &op->perm;
			break;
		}
		c += assignment;
		message((-5, "option: %c %s level=%d:%d", type ? type : '-', op->name, op->level, c));
		if (op->level > c)
			continue;
		if (y && (op->flags & (OPT_HEADER|OPT_READONLY)) == OPT_HEADER)
		{
			if (vp == &op->temp)
				op->entry = ap->entry;
			else
				op->level = c;
			if (*v)
			{
				op->flags |= OPT_SET;
				if (op->flags & OPT_NUMBER)
					vp->number = n;
				stash(vp, v, 0);
			}
			else
				vp = 0;
		}
		else
			vp = 0;
		message((-4, "option: %c %s%s%s=%s entry=%d:%d level=%d:%d number=%I*u", type ? type : '-', y ? "" : "no", op->name, assignment ? ":" : "", v, op->entry, ap ? ap->entry : 0, op->level, c, sizeof(n), n));
		switch (op->index)
		{
		case OPT_action:
			if (*v)
			{
				xp = action(v, 1);
				if (!xp->re)
					state.filter.all = xp;
				else
				{
					if (state.filter.last)
						state.filter.last->next = xp;
					else
						state.filter.list = xp;
					state.filter.last = xp;
				}
			}
			break;
		case OPT_append:
			state.append = y;
			break;
		case OPT_atime:
			if (vp)
			{
			settime:
				vp->number = strtoul(vp->string, &e, 10);
				vp->fraction = 0;
				if (*e)
				{
					if (*e != '.')
						vp->number = tmdate(vp->string, &e, NiL);
					if (*e == '.')
						vp->fraction = strtoul(s = e + 1, &e, 10);
					if (*e)
						error(2, "%s: invalid %s date string", vp->string, options[op->index].name);
					else if (vp->fraction)
					{
						y = e - s;
						for (y = e - s; y < 9; y++)
							vp->fraction *= 10;
						for (; y > 9; y--)
							vp->fraction /= 10;
					}
				}
			}
			break;
		case OPT_base:
			ap = getarchive(state.operation);
			if (ap->delta)
				error(3, "base archive already specified");
			if (y)
			{
				initdelta(ap, NiL);
				if (!*v || streq(v, "-"))
				{
					state.delta2delta++;
					if (!(state.operation & OUT))
					{
						ap->delta->format = getformat(FMT_IGNORE, 1);
						break;
					}
					v = "/dev/null";
				}
				ap->delta->base = initarchive(strdup(v), O_RDONLY);
			}
			break;
		case OPT_blocksize:
			if (y)
			{
				state.blocksize = n;
				if (state.blocksize < MINBLOCK)
					error(3, "block size must be at least %d", MINBLOCK);
				if (state.blocksize & (BLOCKSIZE - 1))
					error(1, "block size should probably be a multiple of %d", BLOCKSIZE);
			}
			else
				state.blocksize = DEFBLOCKS * BLOCKSIZE;
			break;
		case OPT_blok:
			if (!*v)
				getarchive(IN)->io->blok = getarchive(OUT)->io->blok = n;
			else
				while (*v) switch (*v++)
				{
				case 'i':
					getarchive(IN)->io->blok = 1;
					break;
				case 'o':
					getarchive(OUT)->io->blok = 1;
					break;
				default:
					error(3, "%s: [io] expected", op->name);
					break;
				}
			break;
		case OPT_checksum:
			if (y)
			{
				if (e = strchr(v, ':'))
					*e++ = 0;
				else
				{
					e = v;
					v = "md5";
				}
				state.checksum.name = strdup(e);
				if (!(state.checksum.sum = sumopen(v)))
					error(3, "%s: %s: unknown checksum algorithm", e, v);
			}
			else
				state.checksum.name = 0;
			break;
		case OPT_chmod:
			if (y && *v)
			{
				strperm(v, &e, 0);
				if (*e)
					error(3, "%s: invalid file mode expression", v);
				state.mode = strdup(v);
			}
			else
				state.mode = 0;
			break;
		case OPT_clobber:
			state.clobber = y;
			break;
		case OPT_comment:
			state.header.comment = y ? strdup(v) : (char*)0;
			break;
		case OPT_complete:
			state.complete = y;
			break;
		case OPT_crossdevice:
			if (!y)
				state.ftwflags |= FTW_MOUNT;
			else
				state.ftwflags &= ~FTW_MOUNT;
			break;
		case OPT_ctime:
			if (vp)
				goto settime;
			break;
		case OPT_debug:
			if (y)
			{
				y = error_info.trace;
				error_info.trace = -(int)n;
				if (!y)
					message((-10, "usage %s", usage));
			}
			else
				error_info.trace = 0;
			break;
		case OPT_delete:
			if (y && *v)
				sfprintf(opt.ignore_all, "%s(%s)", sfstrtell(opt.ignore_all) ? "|" : "", v);
			break;
		case OPT_delta_base_checksum:
			if (ap && ap->delta)
				ap->delta->checksum = n;
			break;
		case OPT_delta_base_size:
			if (ap && ap->delta)
				ap->delta->size = n;
			break;
		case OPT_delta_checksum:
			if (ap)
				ap->file.delta.checksum = n;
			break;
		case OPT_delta_compress:
			if (ap && ap->delta)
				ap->delta->compress = 1;
			break;
		case OPT_delta_index:
			if (ap)
			{
				if (type == GLBTYPE)
				{
					if (ap->delta && (c = n - ap->delta->index - 1))
					{
						if (c > 0)
							error(2, "%s: corrupt archive: %d missing file%s", ap->name, c, c == 1 ? "" : "s");
						else
							error(2, "%s: corrupt archive: %d extra file%s", ap->name, -c, -c == 1 ? "" : "s");
					}
				}
				else
					ap->file.delta.index = n;
			}
			break;
		case OPT_delta_method:
			if (ap)
			{
				if (!(fp = getformat(v, 0)) || !(fp->flags & DELTA))
					error(3, "%s: %s: delta method not supported", ap->name, v);
				initdelta(ap, fp);
			}
			break;
		case OPT_delta_op:
			if (ap && ap->delta)
				ap->file.delta.op = line ? *v : n;
			break;
		case OPT_delta_ordered:
			if (ap && ap->delta)
				ap->delta->ordered = n;
			break;
		case OPT_delta_update:
			state.delta.update = y;
			break;
		case OPT_delta_version:
			break;
		case OPT_descend:
			state.descend = y;
			break;
		case OPT_different:
		case OPT_newer:
		case OPT_update:
			state.update = y ? op->index : 0;
			break;
		case OPT_dots:
			state.drop = y;
			break;
		case OPT_edit:
			substitute(&opt.lastmap, (char*)v);
			break;
		case OPT_eom:
			eomprompt = y ? strdup(v) : (char*)0;
			break;
		case OPT_exact:
			state.exact = y;
			break;
		case OPT_extended_name:
			state.header.extended = y ? strdup(v) : (char*)0;
			break;
		case OPT_file:
			ap = getarchive(state.operation);
			if (ap->name)
				error(3, "%s: %s: archive name already specified", v, ap->name);
			ap->name = strdup(v);
			break;
		case OPT_filter:
			if (y && *v)
			{
				state.filter.command = v;
				state.descend = 0;
			}
			else
				state.filter.command = 0;
			break;
		case OPT_format:
			ap = getarchive(state.operation);
			if (!y)
				ap->format = 0;
			else if (s = strdup(v))
			{
				v = s;
				do
				{
					for (e = s, o = 0;;)
					{
						switch (*e++)
						{
						case 0:
							e = 0;
							break;
						case ' ':
						case '\t':
						case '\n':
						case ':':
						case ',':
						case '.':
							*(e - 1) = 0;
							if (*s)
								break;
							s = e;
							continue;
						case '=':
							if (!o)
							{
								*(e - 1) = 0;
								o = e;
							}
							continue;
						default:
							continue;
						}
						break;
					}
					if (!(fp = getformat(s, 0)) && s == v && s[0] == 't' && !strchr(s, ':') && (fp = getformat(s + 1, 0)))
					{
						if (ap->format = getformat("tar", 0))
							s++;
						else
							fp = 0;
					}
					if (!fp)
					{
						if (!pathpath("lib/pax", opt.arg0, PATH_EXECUTE, tmp1, sizeof(tmp1)) || sfsprintf(tmp2, sizeof(tmp2) - 1, "%s/%s.fmt", tmp1, s) <= 0 || !(sp = sfopen(NiL, tmp2, "r")))
							error(3, "%s: unknown archive format", s);
						while (e = sfgetr(sp, '\n', 1))
							if (*e != '#')
							{
								setoptions(e, sfvalue(sp), NiL, state.usage, ap, type);
								if (line && !hdr)
									line += opt_info.offset;
							}
						sfclose(sp);
					}
					else
					{
						fp->details = o;
						switch (fp->flags & (ARCHIVE|COMPRESS|DELTA))
						{
						case ARCHIVE:
							ap->format = fp;
							break;
						case COMPRESS:
							ap->compress = fp;
							break;
						case DELTA:
							initdelta(ap, fp);
							break;
						}
					}
				} while (s = e);
			}
			ap->expected = ap->format;
			if (!state.operation)
				state.format = ap->format;
			break;
		case OPT_from:
		case OPT_to:
			if (!cvt)
			{
				cvt = 1;
				from = to = CC_NATIVE;
			}
			ap = getarchive(state.operation);
			if ((y = ccmapid(v)) < 0)
				error(3, "%s: unknown character code set", v);
			switch (op->index)
			{
			case OPT_from:
				from = y;
				break;
			case OPT_to:
				to = y;
				break;
			}
			break;
		case OPT_global_name:
			state.header.global = y ? strdup(v) : (char*)0;
			break;
		case OPT_header:
			v = y ? strdup(v) : (char*)0;
			if (assignment)
				state.header.extended = v;
			else
				state.header.global = v;
			break;
		case OPT_ignore:
			if (y && *v)
			{
				if (assignment)
					sfprintf(opt.ignore_ext, "%s(%s)", sfstrtell(opt.ignore_ext) ? "|" : "", v);
				else
					sfprintf(opt.ignore_all, "%s(%s)", sfstrtell(opt.ignore_all) ? "|" : "", v);
			}
			break;
		case OPT_install:
			state.install.name = y ? strdup(v) : (char*)0;
			break;
		case OPT_intermediate:
			state.intermediate = y;
			break;
		case OPT_invalid:
			if (line)
			{
				n = 0;
				y = strlen(v);
				s = op->details;
				while (s = strchr(s, '['))
				{
					c = *++s;
					o = ++s;
					for (;;)
					{
						if (strneq(v, o, y))
						{
							s = "";
							n = c;
							break;
						}
						if (!(o = strchr(o, '|')))
							break;
						o++;
					}
				}
			}
			switch ((int)n)
			{
			case 'b':
				state.header.invalid = INVALID_binary;
				break;
			case 'i':
				state.header.invalid = INVALID_ignore;
				break;
			case 'p':
				state.header.invalid = INVALID_prompt;
				break;
			case 't':
				state.header.invalid = INVALID_translate;
				break;
			case 'u':
				state.header.invalid = INVALID_UTF8;
				break;
			default:
				error(2, "%s: %s: unknown option value", op->name, v);
				break;
			}
			break;
		case OPT_invert:
			state.matchsense = !y;
			break;
		case OPT_keepgoing:
			state.keepgoing = y;
			break;
		case OPT_label:
			if (*state.volume)
			{
				if (assignment)
					sfsprintf(tmp1, sizeof(tmp1), "%s %s", v, state.volume);
				else
					sfsprintf(tmp1, sizeof(tmp1), "%s %s", state.volume, v);
				v = tmp1;
			}
			strncpy(state.volume, v, sizeof(state.volume) - 2);
			break;
		case OPT_link:
			if (y)
				state.linkf = link;
			else
				state.linkf = 0;
			break;
		case OPT_linkdata:
			state.header.linkdata = y;
			break;
		case OPT_listformat:
			if (y && *v)
				sfputr(opt.listformat, v, ' ');
			break;
		case OPT_listmacro:
			if (y && *v)
			{
				if (s = strchr(v, '='))
					*s++ = 0;
				if (!(op = (Option_t*)hashget(state.options, v)))
				{
					if (!s)
						break;
					if (!(op = newof(0, Option_t, 1, 0)))
						nospace();
					op->name = hashput(state.options, 0, op);
				}
				if (s)
				{
					op->macro = strdup(s);
					*(s - 1) = 0;
				}
				else
					op->macro = 0;
			}
			break;
		case OPT_local:
			state.local = 1;
			break;
		case OPT_logical:
			if (y)
				state.ftwflags &= ~FTW_PHYSICAL;
			else
				state.ftwflags |= FTW_PHYSICAL;
			break;
		case OPT_maxout:
			state.maxout = n;
			break;
		case OPT_metaphysical:
			if (y)
				state.ftwflags |= FTW_META|FTW_PHYSICAL;
			else
				state.ftwflags &= ~(FTW_META|FTW_PHYSICAL);
			break;
		case OPT_meter:
			if (state.meter.on = y)
			{
				if (!(state.meter.tmp = sfstropen()))
					nospace();
				if (state.meter.fancy = isatty(sffileno(sfstderr)))
				{
					error_info.write = meterror;
					astwinsize(1, NiL, &state.meter.width);
					if (state.meter.width < 2 * (METER_width + 1))
						state.meter.width = 2 * (METER_width + 1);
				}
			}
			break;
		case OPT_mkdir:
			state.mkdir = y;
			break;
		case OPT_mtime:
			if (vp)
				goto settime;
			break;
		case OPT_options:
			if (v)
			{
				setoptions(v, 0, NiL, usage, ap, type);
				if (line && !hdr)
					line += opt_info.offset;
			}
			break;
		case OPT_ordered:
			state.ordered = y;
			break;
		case OPT_owner:
			if (!(state.owner = y))
				opt.owner = 0;
			else if (*v)
				opt.owner = strdup(v);
			break;
		case OPT_passphrase:
			state.passphrase = y ? strdup(v) : (char*)0;
			break;
		case OPT_physical:
			if (y)
			{
				state.ftwflags &= ~FTW_META;
				state.ftwflags |= FTW_PHYSICAL;
			}
			else
				state.ftwflags &= ~FTW_PHYSICAL;
			break;
		case OPT_preserve:
			for (;;)
			{
				switch (*v++)
				{
				case 0:
					break;
				case 'a':
					state.acctime = 0;
					continue;
				case 'e':
					state.acctime = 1;
					state.modtime = 1;
					state.owner = 1;
					state.modemask = 0;
					state.chmod = 1;
					continue;
				case 'm':
					state.modtime = 0;
					continue;
				case 'o':
					state.owner = 1;
					continue;
				case 'p':
					state.modemask &= (S_ISUID|S_ISGID);
					state.chmod = 1;
					continue;
				case 's':
					state.modemask &= ~(S_ISUID|S_ISGID);
					continue;
				default:
					error(1, "%s=%c: unknown flag", op->name, *(v - 1));
					continue;
				}
				break;
			}
			break;
		case OPT_read:
			if (y)
				state.operation |= IN;
			else
				state.operation &= ~IN;
			break;
		case OPT_record_charset:
			state.record.charset = y;
			break;
		case OPT_record_delimiter:
			if (!y)
				state.record.delimiter = 0;
			else
				state.record.delimiter = *v;
			break;
		case OPT_record_format:
			state.record.format = y ? *v : 0;
			break;
		case OPT_record_header:
			if (!y)
			{
				state.record.header = 0;
				state.record.headerlen = 0;
			}
			else if (!(state.record.headerlen = stresc(state.record.header = strdup(v))))
				state.record.headerlen = 1;
			break;
		case OPT_record_line:
			state.record.line = y;
			break;
		case OPT_record_match:
			state.record.pattern = y ? strdup(v) : (char*)0;
			break;
		case OPT_record_pad:
			state.record.pad = y;
			break;
		case OPT_record_size:
			state.record.size = n;
			break;
		case OPT_record_trailer:
			if (!y)
			{
				state.record.trailer = 0;
				state.record.trailerlen = 0;
			}
			else if (!(state.record.trailerlen = stresc(state.record.trailer = strdup(v))))
				state.record.trailerlen = 1;
			break;
		case OPT_reset_atime:
			state.resetacctime = y;
			break;
		case OPT_size:
			break;
		case OPT_strict:
			state.strict = y;
			break;
		case OPT_summary:
			state.summary = y;
			break;
		case OPT_symlink:
			if (y)
				state.linkf = pathsetlink;
			else
				state.linkf = 0;
			break;
		case OPT_sync:
#if _lib_fsync
			state.sync = y;
#else
			error(1, "%s not implemented on this system", op->name);
#endif
			break;
		case OPT_tape:
			ap = getarchive(state.operation);
			if (ap->name)
				error(3, "%s: %s: archive name already specified", v, ap->name);
			s = strtape(v, &e);
			if (*s)
				ap->name = s;
			for (;;)
			{
				switch (*e++)
				{
				case 'k':
					if (!(n = strtonll(e, &e, 0, 1)))
						n = -1;
					ap->io->keep = n;
					ap->io->mode = O_RDWR;
					continue;
				case 's':
					if (!(n = strtonll(e, &e, 0, 1)))
						n = -1;
					ap->io->skip = n;
					ap->io->mode = O_RDWR;
					continue;
				}
				e--;
				break;
			}
			if (*e)
				error(3, "%s: invalid tape unit specification [%s]", v, e);
			break;
		case OPT_test:
			if (y)
				state.test |= (unsigned long)n;
			else
				state.test = 0;
			break;
		case OPT_testdate:
			if (y)
			{
				state.testdate = tmdate(v, &e, NiL);
				if (*e)
					error(3, "%s: invalid %s date string", v, options[op->index].name);
			}
			else
				state.testdate = ~0;
			break;
		case OPT_times:
			if (y)
			{
				setoptions("atime:= ctime:= mtime:=", 0, NiL, usage, ap, type);
				if (line && !hdr)
					line += opt_info.offset;
			}
			break;
		case OPT_unblocked:
			if (!*v)
				getarchive(IN)->io->unblocked = getarchive(OUT)->io->unblocked = y;
			else
				while (*v) switch (*v++)
				{
				case 'i':
					getarchive(IN)->io->unblocked = 1;
					break;
				case 'o':
					getarchive(OUT)->io->unblocked = 1;
					break;
				default:
					error(3, "%s: [io] expected", op->name);
					break;
				}
			break;
		case OPT_uncompressed:
			ap->file.uncompressed = n;
			break;
		case OPT_verbose:
			state.verbose = y;
			break;
		case OPT_verify:
			state.verify = y;
			break;
		case OPT_warn:
			state.warn = y;
			break;
		case OPT_write:
			if (y)
				state.operation |= OUT;
			else
				state.operation &= ~OUT;
			if (!(state.operation & IN) && state.in && !state.out)
			{
				state.out = state.in;
				state.in = 0;
				state.out->io->mode = O_CREAT|O_TRUNC|O_WRONLY;
			}
			break;
		case OPT_yes:
			state.verify = state.yesno = y;
			break;
		default:
			if (!type && !(op->flags & OPT_HEADER) || !(op->flags & (OPT_IGNORE|OPT_SET)))
				error(1, "%s: option ignored [index=%d]", op->name, op->index);
			break;
		}
	}
	if (line && !hdr)
	{
		opt_info.index = index;
		opt_info.offset = offset;
	}
	if (cvt)
	{
		ap->convert[0].on = 1;
		convert(ap, SECTION_DATA, from, to);
	}
}

/*
 * option match with VENDOR check
 */

static int
matchopt(const char* name, const char* pattern, Option_t* op)
{
	return strmatch(name, pattern) || (op->flags & OPT_VENDOR) && strmatch(sfprints("%s.%s", VENDOR, name), pattern);
}

/*
 * mark ignored header keywords
 */

static void
ignore(void)
{
	register Option_t*	op;
	Hash_position_t*	pos;
	char*			all;
	char*			ext;
	int			lev;

	if (!sfstrtell(opt.ignore_all))
		all = 0;
	else if (!(all = sfstruse(opt.ignore_all)))
		nospace();
	if (!sfstrtell(opt.ignore_ext))
		ext = 0;
	else if (!(ext = sfstruse(opt.ignore_ext)))
		nospace();
	if ((all || ext) && (pos = hashscan(state.options, 0)))
	{
		while (hashnext(pos))
		{
			op = (Option_t*)pos->bucket->value;
			if (!(op->flags & OPT_READONLY) && (all && matchopt(pos->bucket->name, all, op) && (lev = 8) || ext && matchopt(pos->bucket->name, ext, op) && (lev = 6)) && op->level < lev)
				op->level = lev;
		}
		hashdone(pos);
	}
	sfstrclose(opt.ignore_all);
	sfstrclose(opt.ignore_ext);
}

/*
 * list fp for optinfo()
 */

static void
listformat(register Sfio_t* sp, register Format_t* fp)
{
	register const char*	p;
	register int		c;

	sfprintf(sp, "[+%s", fp->name);
	if (p = fp->match)
	{
		sfputc(sp, '|');
		if (*p == '(')
			p++;
		while (c = *p++)
		{
			if (c == ')' && !*p)
				break;
			if (c == '?' || c == ']')
				sfputc(sp, c);
			sfputc(sp, c);
		}
	}
	sfputc(sp, '?');
	p = fp->desc;
	while (c = *p++)
	{
		if (c == ']')
			sfputc(sp, c);
		sfputc(sp, c);
	}
	switch (fp->flags & (IN|OUT))
	{
	case 0:
		sfputr(sp, "; for listing only", -1);
		break;
	case IN:
		sfputr(sp, "; for input only", -1);
		break;
	case OUT:
		sfputr(sp, "; for output only", -1);
		break;
	}
	sfputc(sp, ']');
}

/*
 * optget() info discipline function
 */

static int
optinfo(Opt_t* op, Sfio_t* sp, const char* s, Optdisc_t* dp)
{
	register Format_t*	fp;
	register iconv_list_t*	ic;
	register const char*	p;
	register int		i;
	register int		c;
	Ardirmeth_t*		ar;

	switch (*s)
	{
	case 'c':
		for (ic = iconv_list(NiL); ic; ic = iconv_list(ic))
		{
			sfputc(sp, '[');
			sfputc(sp, '+');
			sfputc(sp, '\b');
			p = ic->match;
			if (*p == '(')
				p++;
			while (c = *p++)
			{
				if (c == ')' && !*p)
					break;
				if (c == '?' || c == ']')
					sfputc(sp, c);
				sfputc(sp, c);
			}
			sfputc(sp, '?');
			p = ic->desc;
			while (c = *p++)
			{
				if (c == ']')
					sfputc(sp, c);
				sfputc(sp, c);
			}
			sfputc(sp, ']');
		}
		break;
	case 'd':
		sfputr(sp, FMT_DEFAULT, -1);
		break;
	case 'D':
		fp = 0;
		while (fp = nextformat(fp))
			if (fp->flags & DELTA)
			{
				sfprintf(sp, "[+%s", fp->name);
				sfputc(sp, '?');
				p = fp->desc;
				while (c = *p++)
				{
					if (c == ']')
						sfputc(sp, c);
					sfputc(sp, c);
				}
				sfputc(sp, ']');
			}
		break;
	case 'f':
		fp = 0;
		while (fp = nextformat(fp))
			if (fp->flags & ARCHIVE)
				listformat(sp, fp);
		ar = 0;
		while (ar = ardirlist(ar))
			sfprintf(sp, "[+%s?%s; for input only]", ar->name, ar->description);
		sfprintf(sp, "[+----?compression methods ----]");
		fp = 0;
		while (fp = nextformat(fp))
			if (fp->flags & COMPRESS)
				listformat(sp, fp);
		sfprintf(sp, "[+----?delta methods ----]");
		fp = 0;
		while (fp = nextformat(fp))
			if (fp->flags & DELTA)
				listformat(sp, fp);
				break;
		break;
	case 'l':
		for (i = 1; options[i].name; i++)
			if ((options[i].flags & (OPT_GLOBAL|OPT_READONLY)) == OPT_READONLY)
			{
				sfprintf(sp, "[+%s?%s]\n", options[i].name, options[i].description);
				if (options[i].details)
					sfprintf(sp, "{\n%s\n}", options[i].details);
			}
		sfprintf(sp, "%s",
"	[+----?subformats ----]"
"	[+case\b::\bp\b\a1\a::\bs\b\a1\a::...::\bp\b\an\a::\bs\b\an\a?Expands"
"		to \bs\b\ai\a if the value of \aid\a matches the shell"
"		pattern \bp\b\ai\a, or the empty string if there is no"
"		match.]"
"	[+mode?The integral value as a \bfmtmode\b(3) string.]"
"	[+perm?The integral value as a \bfmtperm\b(3) string.]"
"	[+time[=\aformat\a]]?The integral value as a \bstrftime\b(3)"
"		string. For example,"
"		\b--format=\"%8(mtime)u %(ctime:time=%H:%M:%S)s\"\b"
"		lists the mtime in seconds since the epoch and the"
"		ctime as hours:minutes:seconds.]");
		break;
	}
	return 0;
}

int
main(int argc, char** argv)
{
	register int		i;
	register char*		s;
	register Archive_t*	ap;
	char*			p;
	Hash_position_t*	pos;
	Option_t*		op;
	int			n;
	int			pass = 0;
	unsigned long		blocksize;
	struct stat		st;
	Optdisc_t		optdisc;

	static Format_t		rw = { "rw", 0, 0, 0, IN|OUT };

	setlocale(LC_ALL, "");
	paxinit(&state, error_info.id = "pax");
	optinit(&optdisc, optinfo);
	state.strict = !!conformance(0, 0);
	state.gid = getegid();
	state.uid = geteuid();
	state.pid = getpid();
	umask(state.modemask = umask(0));
	state.modemask |= S_ISUID|S_ISGID;
	state.ftwflags = ftwflags()|FTW_DOT;
	state.acctime = 1;
	state.buffersize = DEFBUFFER * DEFBLOCKS;
	state.clobber = 1;
	state.delta.buffersize = DELTA_WINDOW >> 1;
	state.descend = RESETABLE;
	state.format = getformat(FMT_DEFAULT, 1);
	state.header.extended = state.strict ? HEADER_EXTENDED_STD : HEADER_EXTENDED;
	state.header.global = state.strict ? HEADER_GLOBAL_STD : HEADER_GLOBAL;
	state.map.a2n = ccmap(CC_ASCII, CC_NATIVE);
	state.map.e2n = ccmap(CC_EBCDIC, CC_NATIVE);
	state.map.n2e = ccmap(CC_NATIVE, CC_EBCDIC);
	if (!(opt.ignore_all = sfstropen()) || !(opt.ignore_ext = sfstropen()))
		nospace();
	if (!(opt.listformat = sfstropen()))
		nospace();
	state.matchsense = 1;
	state.mkdir = 1;
	state.modtime = 1;
	if (!(state.tmp.fmt = sfstropen()) || !(state.tmp.lst = sfstropen()) || !(state.tmp.str = sfstropen()))
		nospace();
	stash(&options[OPT_release].perm, release(), 0);
	options[OPT_release].flags |= OPT_SET;
	if (!(state.options = hashalloc(NiL, HASH_name, "options", 0)))
		nospace();
	for (i = 1; options[i].name; i++)
	{
		p = options[i].name;
		if (strchr(p, '|'))
			p = strdup(p);
		do
		{
			if (s = strchr(p, '|'))
				*s++ = 0;
			hashput(state.options, p, &options[options[i].index]);
		} while (p = s);
	}
	hashset(state.options, HASH_ALLOCATE);
	state.record.charset = 1;
	state.record.line = 1;
	state.summary = 1;
	state.testdate = ~0;
	if (!(state.tmp.file = pathtemp(NiL, 0, NiL, error_info.id, NiL)))
		nospace();
	sfputr(state.tmp.str, usage, -1);
	for (i = 1; options[i].name; i++)
		if ((options[i].flags & (OPT_GLOBAL|OPT_READONLY)) != OPT_READONLY)
		{
			sfputc(state.tmp.str, '[');
			if (options[i].flag)
			{
				sfputc(state.tmp.str, options[i].flag);
				if (options[i].flags & OPT_INVERT)
					sfputc(state.tmp.str, '!');
			}
			sfprintf(state.tmp.str, "=%d:%s", options[i].index, options[i].name);
			if (options[i].flags & OPT_VENDOR)
			{
				for (s = (char*)options[i].name; p = strchr(s, '|'); s = p + 1)
					sfprintf(state.tmp.str, "|%s.%-.*s", VENDOR, p - s, s);
				sfprintf(state.tmp.str, "|%s.%s", VENDOR, s);
			}
			sfprintf(state.tmp.str, "?%s]", options[i].description);
			if (options[i].argument)
			{
				sfputc(state.tmp.str, (options[i].flags & OPT_NUMBER) ? '#' : ':');
				if (options[i].flags & OPT_OPTIONAL)
					sfputc(state.tmp.str, '?');
				sfprintf(state.tmp.str, "[%s]", options[i].argument);
			}
			if (options[i].details)
				sfprintf(state.tmp.str, "\n{%s}", options[i].details);
			sfputc(state.tmp.str, '\n');
		}
	sfputr(state.tmp.str, usage2, -1);
	if (!(state.usage = sfstruse(state.tmp.str)))
		nospace();
	opt.arg0 = argv[0];
	setoptions(NiL, 0, argv, state.usage, NiL, 0);
	argv += opt_info.index;
	argc -= opt_info.index;
	if (error_info.errors)
		error(ERROR_USAGE|4, "%s", optusage(NiL));
	if (!state.operation)
	{
		state.operation = IN;
		state.list = 1;
	}
	if (!sfstrtell(opt.listformat))
		sfputr(opt.listformat, (state.list && state.verbose) ? "%(mode)s %2(nlink)d %-8(uname)s %-8(gname)s%8(device:case::%(size)llu:*:%(device)s)s %(mtime)s %(delta.op:case:?*:%(delta.op)s )s%(path)s%(linkop:case:?*: %(linkop)s %(linkpath)s)s" : "%(delta.op:case:?*:%(delta.op)s )s%(path)s%(linkop:case:?*: %(linkop)s %(linkpath)s)s", ' ');
	sfstrseek(opt.listformat, -1, SEEK_CUR);
	if (!state.meter.on)
		sfputc(opt.listformat, '\n');
	if (!(state.listformat = strdup(sfstruse(opt.listformat))))
		nospace();
	sfstrclose(opt.listformat);
	ignore();
	if (s = state.filter.command)
	{
		if (streq(s, "-"))
		{
			state.filter.line = -1;
			s = "sh -c";
		}
		state.filter.all = action(s, 0);
	}
	if (state.filter.last)
		state.filter.last->next = state.filter.all;
	else
		state.filter.list = state.filter.all;
	state.statf = (state.ftwflags & FTW_PHYSICAL) ? lstat : pathstat;

	/*
	 * determine the buffer sizes
	 */

	switch (state.operation)
	{
	case IN|OUT:
		if (!state.in)
			break;
		/*FALLTHROUGH*/
	case IN:
	case OUT:
		getarchive(state.operation);
		break;
	}
	blocksize = state.blocksize;
	if (ap = state.out)
	{
		if (!ap->format)
			ap->format = state.format;
		else if (state.operation == (IN|OUT))
			pass = 1;
		if (state.operation == OUT)
		{
			if (state.files)
				state.ftwflags |= FTW_POST;
		}
		if (state.append || state.update)
			ap->io->mode = O_RDWR|O_CREAT;
		ap->io->fd = 1;
		if (!ap->name || streq(ap->name, "-"))
			ap->name = defoutput;
		else
		{
			close(1);
			if (open(ap->name, ap->io->mode|O_BINARY, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH) != 1)
				error(ERROR_SYSTEM|3, "%s: cannot write", ap->name);
		}
		if (fstat(ap->io->fd, &st))
			error(ERROR_SYSTEM|3, "%s: cannot stat", ap->name);
		if (S_ISREG(st.st_mode))
		{
			ap->io->seekable = 1;
			ap->io->size = st.st_size;
		}
		if (!state.blocksize)
		{
			st.st_mode = modex(st.st_mode);
			if (state.test & 0000040)
				st.st_mode = X_IFCHR;
			if (X_ITYPE(st.st_mode) == X_IFREG)
			{
				state.blocksize = ap->format->regular;
				ap->io->unblocked = 1;
			}
			else
				state.blocksize = ap->format->special;
			state.buffersize = state.blocksize *= BLOCKSIZE;
		}
	}
	else
	{
		if (state.blocksize)
			state.buffersize = state.blocksize;
		else
			state.blocksize = (state.operation == (IN|OUT) ? FILBLOCKS : DEFBLOCKS) * BLOCKSIZE;
		if (state.record.size)
			error(1, "record size automatically determined on archive read");
	}
	if (ap = state.in)
	{
		if (!ap->name || streq(ap->name, "-"))
			ap->name = definput;
		else
		{
			close(0);
			if (open(ap->name, ap->io->mode|O_BINARY))
				error(ERROR_SYSTEM|3, "%s: cannot read", ap->name);
		}
		if (fstat(ap->io->fd, &st))
			error(ERROR_SYSTEM|3, "%s: cannot stat", ap->name);
		if (S_ISREG(st.st_mode))
		{
			ap->io->seekable = 1;
			ap->io->size = st.st_size;
		}
		if (state.meter.on && !(state.meter.size = ap->io->size))
			state.meter.on = 0;
	}
	if (!blocksize && (blocksize = bblock(!state.in)))
		state.blocksize = blocksize;
	if (state.buffersize < state.blocksize)
		state.buffersize = state.blocksize;
	state.tmp.buffersize = state.buffersize;
	if (!(state.tmp.buffer = newof(0, char, state.tmp.buffersize, 0)))
		nospace();
	if (state.maxout && state.maxout <= state.blocksize)
		error(3, "--maxout=%#i must be greater than --blocksize=%#i", state.maxout, state.blocksize);
	message((-1, "blocksize=%d buffersize=%d recordsize=%d", state.blocksize, state.buffersize, state.record.size));

	/*
	 * initialize the main io
	 */

	switch (state.operation)
	{
	case IN:
	case OUT:
		getarchive(state.operation);
		break;
	}
	if (ap = state.in)
	{
		binit(ap);
		if (state.append && !state.out)
		{
			error(1, "append ignored for archive read");
			state.append = 0;
		}
	}
	if (ap = state.out)
	{
		if (!ap->format)
			ap->format = state.format;
		if (state.append || state.update)
		{
			if (ap->delta)
			{
				error(1, "append/update ignored for archive delta");
				state.update = 0;
			}
			if (state.append && state.update)
			{
				error(1, "append ignored for archive update");
				state.append = 0;
			}
			if (!ap->io->seekable)
				error(3, "%s: append/update requires seekable archive", ap->name);
			else if (!ap->io->size)
				state.append = state.update = 0;
			else
			{
				initdelta(ap, NiL);
				ap->delta->base = ap;
			}
		}
		binit(ap);
		if (ap->compress)
		{
			Proc_t*		proc;
			List_t*		p;
			char*		cmd[4];

			cmd[0] = ap->compress->name;
			i = 1;
			if (cmd[i] = ((Compress_format_t*)ap->compress->data)->variant)
				i++;
			if (cmd[i] = ap->compress->details)
				i++;
			cmd[i] = 0;
			if (!(proc = procopen(*cmd, cmd, NiL, NiL, PROC_WRITE)))
				error(3, "%s: cannot execute %s filter", ap->name, ap->compress->name);
			n = proc->wfd;
			proc->wfd = 1;
			close(1);
			if (dup(n) != 1)
				error(3, "%s: cannot redirect %s filter output", ap->name, ap->compress->name);
			close(n);
			if (!(p = newof(0, List_t, 1, 0)))
				nospace();
			p->item = (void*)proc;
			p->next = state.proc;
			state.proc = p;
		}
		if (state.checksum.name)
		{
			if (!(state.checksum.path = pathtemp(NiL, 0, NiL, error_info.id, NiL)))
				nospace();
			if (!(state.checksum.sp = sfopen(NiL, state.checksum.path, "w")))
				error(3, "%s: cannot write checksum temporary", state.checksum.path);
			sfprintf(state.checksum.sp, "method=%s\n", state.checksum.sum->name);
			sfprintf(state.checksum.sp, "permissions\n");
		}
		if (state.install.name)
		{
			if (!(state.install.path = pathtemp(NiL, 0, NiL, error_info.id, NiL)))
				nospace();
			if (!(state.install.sp = sfopen(NiL, state.install.path, "w")))
				error(3, "%s: cannot write install temporary", state.install.path);
		}
	}
	if (!(state.linktab = hashalloc(NiL, HASH_set, HASH_ALLOCATE, HASH_namesize, sizeof(Fileid_t), HASH_name, "links", 0)))
		error(3, "cannot allocate hard link table");
	if ((state.operation & IN) && !state.list && !(state.restore = hashalloc(NiL, HASH_set, HASH_ALLOCATE, HASH_name, "restore", 0)))
		error(3, "cannot allocate directory table");
	if (state.owner)
	{
		if (state.operation & IN)
		{
			state.modemask = 0;
			if (opt.owner)
			{
				if ((state.setuid = struid(opt.owner)) < 0 || (state.setgid = strgid(opt.owner)) < 0)
					error(3, "%s: invalid user name", opt.owner);
				state.flags |= SETIDS;
			}
		}
		else
			error(1, "ownership assignment ignored on archive write");
	}
	if (state.verify)
		interactive();
	if (!(state.modemask &= (S_ISUID|S_ISGID|S_ISVTX|S_IRWXU|S_IRWXG|S_IRWXO)))
		umask(0);
	state.modemask = ~state.modemask;
#if DEBUG
	if ((state.test & 0000010) && (pos = hashscan(state.options, 0)))
	{
		while (hashnext(pos))
		{
			op = (Option_t*)pos->bucket->value;
			if (op->name == pos->bucket->name)
				sfprintf(sfstderr, "%-16s %c %2d %d perm=%ld:%s temp=%ld:%s%s%s\n", op->name, op->flag ? op->flag : '-', op->index, op->level, op->perm.number, op->perm.string, op->temp.number, op->temp.string, (op->flags & OPT_HEADER) ? " HEADER" : "", (op->flags & OPT_READONLY) ? " READONLY" : "");
		}
		hashdone(pos);
	}
#endif
	for (i = 0; i < elementsof(signals); i++)
		if (signal(signals[i], interrupt) == SIG_IGN)
			signal(signals[i], SIG_IGN);
	switch (state.operation)
	{
	case IN:
		if (*argv)
		{
			initmatch(argv);
			if (state.exact)
				state.matchsense = 1;
		}
		else if (state.exact)
			error(3, "file arguments expected");
		getcwd(state.pwd, PATH_MAX);
		state.pwdlen = strlen(state.pwd);
		if (state.pwdlen > 1)
			state.pwd[state.pwdlen++] = '/';
		copyin(state.in);
		if (state.exact)
			for (state.pattern = state.patterns; state.pattern->pattern; state.pattern++)
				if (!state.pattern->matched)
					error(2, "%s: %s: file not found in archive", state.in->name, state.pattern->pattern);
		break;

	case OUT:
		if (*argv)
			state.files = argv;
		if (!state.maxout && state.complete)
			error(3, "maximum block count required");
		copy(state.out, copyout);
		break;

	case (IN|OUT):
		if (pass || state.in || state.out)
		{
			state.pass = 1;
			if (*argv)
				initmatch(argv);
			deltapass(getarchive(IN), getarchive(OUT));
		}
		else
		{
			if (--argc < 0)
			{
				error(2, "destination directory required for pass mode");
				error(ERROR_USAGE|4, "%s", optusage(NiL));
			}
			state.destination = argv[argc];
			argv[argc] = 0;
			if (*argv)
				state.files = argv;
			if (state.record.size)
				error(1, "record size ignored in pass mode");

			/*
			 * initialize destination dir
			 */

			pathcanon(state.destination, 0, 0);
			if (stat(state.destination, &st) || !S_ISDIR(st.st_mode))
				error(3, "%s: destination must be a directory", state.destination);
			state.dev = st.st_dev;
			strcpy(state.pwd, state.destination);
			if (state.pwdlen = strlen(state.pwd))
				state.pwd[state.pwdlen++] = '/';
			if (state.update < 0)
				state.update = OPT_newer;
			getarchive(OUT);
			state.out->format = &rw;
			copy(NiL, copyinout);
		}
		break;
	}
	finish(0);
}

/*
 * print number of blocks actually copied and exit
 */

void
finish(int code)
{
	register Archive_t*	ap;
	size_t			x = state.buffersize / 4;
	register char*		x1 = &state.tmp.buffer[0];
	register char*		x2 = x1 + x;
	register char*		x3 = x2 + x;
	register char*		x4 = x3 + x;
	register off_t		n;

	while (state.proc)
	{
		procclose((Proc_t*)state.proc->item);
		state.proc = state.proc->next;
	}
	remove(state.tmp.file);
	if (state.checksum.path)
		remove(state.checksum.path);
	if (state.install.path)
		remove(state.install.path);
	if (state.restore)
		hashwalk(state.restore, 0, restore, NiL);
	sfsync(sfstdout);
	if (state.meter.last)
	{
		sfprintf(sfstderr, "%*s\r", state.meter.last, "");
		state.meter.last = 0;
	}
	else if (state.dropcount)
	{
		sfprintf(sfstderr, "\n");
		sfsync(sfstderr);
	}
	if (state.summary)
	{
		ap = getarchive(state.operation);
		n = ap->io->count + ap->io->expand + ap->io->offset;
		message((-1, "%s totals entries=%d count=%I*d expand=%I*d offset=%I*d BLOCKSIZE=%I*d n=%I*d blocks=%I*d", ap->name, ap->entries, sizeof(ap->io->count), ap->io->count, sizeof(ap->io->expand), ap->io->expand, sizeof(ap->io->offset), ap->io->offset, sizeof(BLOCKSIZE), BLOCKSIZE, sizeof(n), n, sizeof(n), (n + BLOCKSIZE - 1) / BLOCKSIZE));
		if (ap->entries)
		{
			if (ap->volume > 1)
				sfsprintf(x1, x, ", %d volumes", ap->volume);
			else
				*x1 = 0;
			if (ap->volume > 0 && ap->part > ap->volume)
				sfsprintf(x2, x, ", %d parts", ap->part - ap->volume + 1);
			else
				*x2 = 0;
			n = (n + BLOCKSIZE - 1) / BLOCKSIZE;
			if (state.verbose || state.meter.on)
			{
				sfsprintf(x3, x, "%I*u file%s, ", sizeof(ap->selected), ap->selected, ap->selected == 1 ? "" : "s");
				if (state.update)
					sfsprintf(x4, x, "%I*u updated, ", sizeof(ap->updated), ap->updated);
				else
					*x4 = 0;
			}
			else
				*x3 = *x4 = 0;
			sfprintf(sfstderr, "%s%s%I*d block%s%s%s\n", x3, x4, sizeof(n), n, n == 1 ? "" : "s", x1, x2);
		}
	}
	sfsync(sfstderr);
	if (state.interrupt)
	{
		signal(state.interrupt, SIG_DFL);
		kill(getpid(), state.interrupt);
		pause();
	}
	exit(code ? code : error_info.errors != 0);
}

/*
 * return release stamp
 */

char*
release(void)
{
	register char*	b;
	register char*	s;
	register char*	t;

	if ((s = strchr(usage, '@')) && (t = strchr(s, '\n')) && (b = fmtbuf(t - s + 1)))
	{
		memcpy(b, s, t - s);
		b[t - s] = 0;
	}
	else
		b = fmtident(usage);
	return b;
}