delta.c

/***********************************************************************
*                                                                      *
*               This software is part of the ast package               *
*          Copyright (c) 1987-2011 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 Bell Laboratories
 *
 * pax delta archive support
 */

#include "pax.h"

#include <update.h>

/*
 * interpret delta header/trailer ops
 */

static void
getdeltaops(Archive_t* ap, File_t* f)
{
	register char*	s;
	register char*	e;
	register int	n;
	char		c;

	if (state.delta2delta || (ap->format->flags & DELTAINFO))
		return;
	s = ap->delta->hdrbuf;
	e = s + sizeof(ap->delta->hdrbuf) - 1;
	n = 0;
	while (f->st->st_size > 0 && bread(ap, &c, (off_t)1, (off_t)1, 1) > 0)
	{
		f->st->st_size--;
		if (c == '\t' || c == '\n')
		{
			if (n)
			{
				*s = 0;
				s = ap->delta->hdrbuf;
				switch (n)
				{
				case DELTA_checksum:
					f->delta.checksum = strtoul(s, NiL, 16);
					break;
				case DELTA_index:
					f->delta.index = strtol(s, NiL, 0);
					break;
				case DELTA_trailer:
					if ((n = strtol(s, NiL, 0)) > 0)
					{
						ap->delta->epilogue = -1;
						ap->delta->trailer = n;
						f->st->st_size -= n;
					}
					break;

					/*
					 * ignore unknown ops for future
					 */
				}
				n = 0;
			}
			if (c == '\n')
				break;
		}
		else if (!n) n = c;
		else if (s < e) *s++ = c;
	}
}

/*
 * get supplemental delta header info
 */

void
getdeltaheader(register Archive_t* ap, register File_t* f)
{
	register char*	s;
	int		n;
	unsigned long	sum;
	Sfio_t*		sp;
	char		c;

	if (!(ap->format->flags & COMPRESSED))
	{
		if (ap->delta && ap->delta->format && (ap->delta->format->variant == DELTA_94 || ap->delta->format->variant == DELTA_IGNORE && state.delta2delta))
		{
			ap->delta->index++;
			if (ap->delta->tab && f->name && (f->delta.base = (Member_t*)hashget(ap->delta->tab, f->name)))
				f->delta.base->mark = 1;
			if (!(ap->format->flags & DELTAINFO))
			{
				if (f->st->st_size <= 0 || bread(ap, &c, (off_t)1, (off_t)1, 1) <= 0)
					f->delta.op = DELTA_create;
				else
				{
					f->st->st_size--;
					f->delta.op = c;
					getdeltaops(ap, f);
					if (f->st->st_size >= 12 && (f->delta.op == DELTA_create || f->delta.op == DELTA_update))
					{
						sum = ap->memsum;
						s = ap->delta->hdrbuf;
						n = 12;
						if (bread(ap, s, (off_t)n, (off_t)n, 1) > 0)
						{
							if (ap->delta->format->variant == DELTA_88)
							{
								unsigned char*	u = (unsigned char*)s;
								int		i;

								i = *u++;
								u += (i >> 3) & 07;
								f->uncompressed = 0;
								i &= 07;
								while (i-- > 0)
									f->uncompressed = f->uncompressed * 256 + *u++;
							}
							else if (sp = sfnew(NiL, s + 4, n, -1, SF_READ|SF_STRING))
							{
								f->uncompressed = sfgetu(sp);
								sfclose(sp);
							}
							bunread(ap, s, n);
						}
						ap->memsum = sum;
					}
				}
			}
		}
		else if (state.operation == (IN|OUT))
			f->delta.op = DELTA_pass;
	}
}

/*
 * get supplemental delta trailer info
 */

void
getdeltatrailer(register Archive_t* ap, register File_t* f)
{
	long		n;
	unsigned long	x;

	if (ap->delta && !f->extended)
	{
		if (ap->delta->trailer)
		{
			f->st->st_size += ap->delta->trailer;
			ap->delta->trailer = 0;
			getdeltaops(ap, f);
		}
		if (!f->delta.base)
		{
			if (ap->parent && ap->parent != ap && f->delta.op != DELTA_create)
				error(2, "%s: %s: corrupt archive: not in base archive %s", ap->name, f->name, ap->parent->name);
		}
		else
		{
			x = (ap->format->flags & SUM) ? f->delta.base->info->checksum : ap->memsum;
			if ((f->delta.checksum ^ x) & 0xffffffff)
				error(2, "%s: %s: corrupt archive: checksum mismatch -- expected %08lx, got %08lx", ap->name, f->name, f->delta.checksum & 0xffffffff, x & 0xffffffff);
		}
		if (n = f->delta.index - ap->delta->index)
		{
			if (n > 0)
				error(2, "%s: %s: corrupt archive: %d missing file%s", ap->name, f->name, n, n == 1 ? "" : "s");
			else
				error(2, "%s: %s: corrupt archive: delta index out of sync by %d file%s", ap->name, f->name, -n, -n == 1 ? "" : "s");
			ap->delta->index = n;
		}
	}
}

/*
 * initialize delta header output info
 */

void
setdeltaheader(register Archive_t* ap, register File_t* f)
{
	register char*	s;
	register int	n;

	if (f->delta.op && ap->delta)
	{
		ap->delta->index++;
		if (ap->format->flags & STANDARD)
		{
			switch (f->delta.op)
			{
			case DELTA_create:
				s = "create";
				break;
			case DELTA_delete:
				s = "delete";
				break;
			case DELTA_pass:
				s = "pass";
				break;
			case DELTA_update:
				s = "update";
				break;
			case DELTA_verify:
				s = "verify";
				break;
			}
			putkey(ap, ap->tmp.extended, &options[OPT_delta_op], s, 0);
			putkey(ap, ap->tmp.extended, &options[OPT_uncompressed], NiL, f->uncompressed);
			putkey(ap, ap->tmp.extended, &options[OPT_delta_index], NiL, ap->delta->index);
			if (ap->delta->tab && (f->delta.base = (Member_t*)hashget(ap->delta->tab, f->name)))
				putkey(ap, ap->tmp.extended, &options[OPT_delta_checksum], NiL, f->delta.base->info->checksum & 0xffffffff);
		}
		else
		{
			s = ap->delta->hdrbuf;
			n = sfsprintf(s, sizeof(ap->delta->hdrbuf), "%c%c%d\t%c%d\n", f->delta.op, DELTA_index, ap->delta->index, DELTA_trailer, DELTA_TRAILER);
			ap->delta->hdr = s + n;
			n += DELTA_TRAILER;
			f->st->st_size += n;
			ap->memsum = 0;
			ap->sum = 1;
		}
	}
}

/*
 * output supplementary delta header info
 */

void
putdeltaheader(register Archive_t* ap, register File_t* f)
{
	int	n;

	if (f->delta.op && ap->delta && (n = ap->delta->hdr - ap->delta->hdrbuf))
	{
		bwrite(ap, ap->delta->hdrbuf, n);
		n += DELTA_TRAILER;
		f->st->st_size -= n;
		ap->delta->hdr = ap->delta->hdrbuf;
	}
}

/*
 * output supplementary delta trailer info
 */

void
putdeltatrailer(register Archive_t* ap, register File_t* f)
{
	register char*	s;
	register int	n;

	if (f->delta.op && ap->delta)
	{
		if (!(ap->format->flags & STANDARD))
		{
			ap->sum = 0;
			s = ap->delta->hdrbuf;
			n = sfsprintf(s, sizeof(ap->delta->hdrbuf), "%c%08X\n", DELTA_checksum, ap->memsum);
			if (n != DELTA_TRAILER)
				error(PANIC, "delta trailer size %d shoulda been %d", n, DELTA_TRAILER);
			bwrite(ap, s, n);
		}
	}
}

/*
 * initialize delta tables
 */

void
initdelta(Archive_t* ap, Format_t* dp)
{
	if (!ap->delta && !(ap->delta = newof(0, Delta_t, 1, 0)))
		nospace();
	if (!ap->delta->tab && !(ap->delta->tab = hashalloc(NiL, HASH_set, HASH_ALLOCATE, HASH_name, "delta", 0)))
		nospace();
	ap->delta->format = dp;
}

/*
 * get delta base archive info
 */

void
deltabase(register Archive_t* ap)
{
	register Archive_t*	bp;
	Format_t*		fp;
	struct stat		st;

	if (!ap->delta || ap->delta->initialized)
		return;
	ap->delta->initialized = 1;
	if (!(bp = ap->delta->base))
		bp = ap->delta->base = initarchive("/dev/null", O_RDONLY);
	binit(bp);
	bp->parent = ap;
	if ((bp->io->mode & O_ACCMODE) != O_WRONLY)
		bp->sum++;
	if ((bp->io->fd = open(bp->name, bp->io->mode|O_BINARY)) < 0 || fstat(bp->io->fd, &st))
		error(ERROR_SYSTEM|3, "%s: %s: cannot open base archive", ap->name, bp->name);
	if (S_ISREG(st.st_mode) && st.st_size > 0)
	{
		bp->io->seekable = 1;
		bp->io->size = st.st_size;
	}
	else
		bp->io->seekable = 0;
	if (st.st_size)
	{
		fp = bp->expected;
		bp->expected = 0;
		if (state.ordered)
		{
			if (!getprologue(bp))
				error(3, "%s: %s: base archive is empty", ap->name, bp->name);
			bp->sum--;
			bp->checksum = memsum(bp->io->next, bcount(bp), 0L);
		}
		else
		{
			if (!state.append && !state.update && lseek(bp->io->fd, (off_t)0, SEEK_SET) != 0)
				error(ERROR_SYSTEM|3, "%s: %s: base archive must be seekable", ap->name, bp->name);
			copyin(bp);
			bp->size = bp->io->offset + bp->io->count;
		}
		bp->expected = fp;
		bp->checksum &= 0xffffffff;
	}
	if (state.append || state.update)
		ap->delta->format = st.st_size ? bp->format : ap->format;
	else if (!ap->delta->format)
	{
		ap->delta->format = getformat(FMT_DELTA, 1);
		ap->delta->compress = !st.st_size;
	}
}

/*
 * verify untouched base files
 */

void
deltaverify(Archive_t* ap)
{
	register int		wfd;
	register Member_t*	d;
	register off_t		c;
	register off_t		n;
	Hash_position_t*	pos;

	if (!state.delta.update && !state.list && ap->delta && ap->delta->base != ap && (pos = hashscan(ap->delta->tab, 0)))
	{
		message((-2, "verify untouched base files"));
		while (hashnext(pos))
		{
			d = (Member_t*)pos->bucket->value;
			message((-1, "%s: mark=%d", d->info->name, d->mark));
			if (!d->mark && selectfile(ap, d->info) && (wfd = openout(ap, d->info)) >= 0)
			{
				ap->entries++;
				if (!d->uncompressed)
				{
					if (!state.ordered && lseek(ap->delta->base->io->fd, d->offset, SEEK_SET) != d->offset)
						error(ERROR_SYSTEM|3, "%s: base archive seek error", ap->delta->base->name);
					holeinit(wfd);
					for (c = d->info->st->st_size; c > 0; c -= n)
					{
						n = (c > state.buffersize) ? state.buffersize : c;
						if ((n = state.ordered ? bread(ap, state.tmp.buffer, n, n, 1) : read(ap->delta->base->io->fd, state.tmp.buffer, n)) <= 0)
						{
							error(ERROR_SYSTEM|2, "%s: %s: read error", ap->delta->base->name, d->info->name);
							break;
						}
						else ap->io->count += n;
						if (holewrite(wfd, state.tmp.buffer, n) != n)
						{
							error(ERROR_SYSTEM|2, "%s: write error", d->info->name);
							break;
						}
						ap->io->count += n;
					}
					holedone(wfd);
					closeout(ap, d->info, wfd);
					setfile(ap, d->info);
					listentry(d->info);
				}
				else if (state.ordered) paxdelta(NiL, ap, d->info, DELTA_DEL|DELTA_BIO|DELTA_SIZE, ap->delta->base, d->size, DELTA_TAR|DELTA_FD|DELTA_FREE|DELTA_OUTPUT|DELTA_COUNT|DELTA_LIST, wfd, 0);
				else paxdelta(NiL, ap, d->info, DELTA_DEL|DELTA_FD|DELTA_OFFSET|DELTA_SIZE, ap->delta->base->io->fd, d->offset, d->size, DELTA_TAR|DELTA_FD|DELTA_FREE|DELTA_OUTPUT|DELTA_COUNT|DELTA_LIST, wfd, 0);
			}
		}
		hashdone(pos);
	}
}

/*
 * output prefix dirs to the archive first
 */

static void
deltaprefix(Archive_t* ip, Archive_t* op, register Member_t* d)
{
	register char*		s;
	register Member_t*	m;

	d->mark = 1;
	if (s = strrchr(d->info->path, '/'))
	{
		*s = 0;
		if (!(m = (Member_t*)hashget(ip->delta->tab, d->info->name)))
		{
			if (!(m = newof(0, Member_t, 1, 0)))
				nospace();
			m->mark = 1;
			hashput(ip->delta->tab, 0, m);
		}
		else if (!m->mark)
			deltaprefix(ip, op, m);
		*s = '/';
	}
	d->info->fd = -1;
	fileout(op, d->info);
}

/*
 * delta file if necessary and copy out
 */

void
deltaout(Archive_t* ip, Archive_t* op, register File_t* f)
{
	register Member_t*	d;
	int			dfd;
	int			skip;

	skip = !!ip;
	f->delta.same = 0;
	if (d = op->delta && op->delta->tab && f->name ? (Member_t*)hashget(op->delta->tab, f->name) : (Member_t*)0)
		d->mark = 1;
	if (op->delta && (op->delta->format->flags & DELTAIO))
	{
		if (f->type == X_IFREG && f->linktype == NOLINK && (!d || f->st->st_mtime != d->mtime.tv_sec || (f->st->st_mode & X_IPERM) != (d->mode & X_IPERM)))
		{
			if (f->ordered)
			{
				f->ordered = 0;
				fileout(op, f);
				return;
			}
			if (d)
			{
				f->delta.op = DELTA_update;
				f->st->st_dev = d->dev;
				f->st->st_ino = d->ino;
				message((-2, "delta: delta: file=%s offset=%ld size=%ld expand=%d", f->name, d->offset, d->size, d->uncompressed));
				if (state.ordered)
				{
					if (!d->uncompressed)
						paxdelta(ip, op, f, DELTA_SRC|DELTA_BIO|DELTA_SIZE, op->delta->base, d->size, DELTA_TAR|DELTA_FD|DELTA_FREE|DELTA_SIZE, f->fd, f->st->st_size, DELTA_DEL|DELTA_TEMP|DELTA_OUTPUT, &f->fd, 0);
					else if (!paxdelta(ip, op, d->info, DELTA_DEL|DELTA_BIO|DELTA_SIZE, op->delta->base, d->size, DELTA_TAR|DELTA_TEMP|DELTA_OUTPUT, &dfd, 0))
						paxdelta(ip, op, f, DELTA_SRC|DELTA_FD|DELTA_SIZE|DELTA_FREE, dfd, d->uncompressed, DELTA_TAR|DELTA_FD|DELTA_FREE|DELTA_SIZE, f->fd, f->st->st_size, DELTA_DEL|DELTA_TEMP|DELTA_OUTPUT, &f->fd, 0);
				}
				else if (!d->uncompressed)
					paxdelta(ip, op, f, DELTA_SRC|DELTA_FD|DELTA_OFFSET|DELTA_SIZE, op->delta->base->io->fd, d->offset, d->size, DELTA_TAR|DELTA_FD|DELTA_FREE|DELTA_SIZE, f->fd, f->st->st_size, DELTA_DEL|DELTA_TEMP|DELTA_OUTPUT, &f->fd, 0);
				else if (!paxdelta(ip, op, d->info, DELTA_DEL|DELTA_FD|DELTA_OFFSET|DELTA_SIZE, op->delta->base->io->fd, d->offset, d->size, DELTA_TAR|DELTA_TEMP|DELTA_OUTPUT, &dfd, 0))
					paxdelta(ip, op, f, DELTA_SRC|DELTA_FD|DELTA_SIZE|DELTA_FREE, dfd, d->uncompressed, DELTA_TAR|DELTA_FD|DELTA_SIZE|DELTA_FREE, f->fd, f->st->st_size, DELTA_DEL|DELTA_TEMP|DELTA_OUTPUT, &f->fd, 0);
			}
			else
			{
				f->delta.op = DELTA_create;
				message((-2, "delta: create: file=%s", f->name));
				paxdelta(ip, op, f, DELTA_TAR|DELTA_FD|DELTA_FREE|DELTA_SIZE, f->fd, f->st->st_size, DELTA_DEL|DELTA_TEMP|DELTA_OUTPUT, &f->fd, 0);
			}
			skip = 0;
		}
		else
		{
			f->delta.op = (d && (f->type == X_IFREG || f->type == X_IFDIR)) ? DELTA_update : DELTA_create;
			message((-2, "delta: %s: file=%s", f->delta.op == DELTA_update ? "update" : "create", f->name));
			if (skip)
			{
				skip = 0;
				fileskip(ip, f);
			}
			f->st->st_size = 0;
			if (f->delta.op == DELTA_update && f->type != X_IFREG && f->st->st_mode == d->mode)
				f->st->st_mtime = d->mtime.tv_sec;
		}
	}
	if (!d || !f->delta.same && d->mtime.tv_sec != f->st->st_mtime)
	{
		register char*	s;

		if (ip && ip->delta && ip->delta->tab && f->name && (s = strrchr(f->name, '/')))
		{
			*s = 0;
			if ((d = (Member_t*)hashget(ip->delta->tab, f->name)) && !d->mark)
				deltaprefix(ip, op, d);
			*s = '/';
		}
		fileout(op, f);
	}
	else if (f->fd >= 0)
		close(f->fd);
	else if (skip)
		fileskip(ip, f);
}

/*
 * copy file from input to output archive
 */

static void
deltacopy(Archive_t* ip, Archive_t* op, register File_t* f)
{
	if (f->delta.base)
	{
		f->st->st_size = f->delta.base->size;
		if (f->delta.base->uncompressed)
		{
			if (state.ordered) paxdelta(ip, NiL, f->delta.base->info, DELTA_DEL|DELTA_BIO|DELTA_SIZE, ip->delta->base, f->delta.base->size, DELTA_TAR|DELTA_TEMP|DELTA_OUTPUT, &f->fd, 0);
			else paxdelta(ip, NiL, f->delta.base->info, DELTA_DEL|DELTA_FD|DELTA_OFFSET|DELTA_SIZE, ip->delta->base->io->fd, f->delta.base->offset, f->delta.base->size, DELTA_TAR|DELTA_TEMP|DELTA_OUTPUT, &f->fd, 0);
		}
		else if (state.ordered)
		{
			f->ap = ip;
			f->fd = -1;
			f->ordered = 1;
		}
		else if ((f->fd = dup(ip->delta->base->io->fd)) < 0)
			error(ERROR_SYSTEM|3, "%s: cannot reopen", ip->delta->base->name);
		else if (lseek(f->fd, f->delta.base->offset, SEEK_SET) < 0)
			error(ERROR_SYSTEM|3, "%s: base archive seek error", ip->delta->base->name);
	}
	deltaout(ip, op, f);
}

/*
 * copy the delta base archive delete entries
 */

void
deltadelete(register Archive_t* ap)
{
	register File_t*	f;
	register Member_t*	d;
	Hash_position_t*	pos;

	if (!state.ordered && ap->delta && ap->delta->tab)
	{
		if (pos = hashscan(ap->delta->tab, 0))
		{
			message((-2, "copy the base delete entries"));
			f = &ap->file;
			while (hashnext(pos))
			{
				d = (Member_t*)pos->bucket->value;
				if (!d->mark && (!d->info || !d->info->ro))
				{
					ap->selected++;
					initfile(ap, f, f->st, pos->bucket->name, X_IFREG|X_IRUSR|X_IWUSR|X_IRGRP|X_IROTH);
					f->delta.op = DELTA_delete;
					if (d->info && d->info->st)
					{
						f->st->st_mode = d->info->st->st_mode;
						f->st->st_gid = d->info->st->st_gid;
						f->st->st_uid = d->info->st->st_uid;
						f->st->st_mtime = d->info->st->st_mtime;
					}
					else
					{
						f->st->st_gid = state.uid;
						f->st->st_uid = state.gid;
						f->st->st_mtime = NOW;
					}
					putheader(ap, f);
					puttrailer(ap, f);
				}
			}
			hashdone(pos);
		}
	}
}

/*
 * update file deltas from archive and output to archive
 */

void
deltapass(Archive_t* ip, Archive_t* op)
{
	register File_t*	f;
	register off_t		c;
	register ssize_t	n;
	Member_t*		d;
	Member_t*		h;
	char*			p;
	Filter_t*		fp;
	Hash_position_t*	pos;

	if (state.delta2delta != 2)
		state.delta2delta = 0;
	message((-1, "delta PASS%s", state.delta2delta ? " delta2delta" : ""));
	deltabase(ip);
	deltabase(op);
	putprologue(op, 0);
	f = &ip->file;
	while (getprologue(ip))
	{
		while (getheader(ip, f))
		{
			f->fd = -1;
			f->ap = ip;
			if (f->ro)
				fileskip(ip, f);
			else if (state.delta2delta)
			{
				if (validout(op, f) && selectfile(op, f))
					fileout(op, f);
				else
					fileskip(ip, f);
			}
			else switch (f->delta.op)
			{
			case DELTA_create:
				if (f->type != X_IFREG || f->linktype != NOLINK)
				{
					f->st->st_size = 0;
					goto pass;
				}
				if (f->delta.base)
					error(3, "%s: base archive mismatch [%s#%d]", f->name, __FILE__, __LINE__);
				if (validout(op, f) && selectfile(op, f))
				{
					paxdelta(ip, op, f, DELTA_TAR|DELTA_TEMP|DELTA_OUTPUT, &f->fd, DELTA_DEL|DELTA_BIO|DELTA_SIZE, ip, f->st->st_size, 0);
					if (op->delta && (op->delta->format->flags & DELTAIO))
					{
						f->delta.op = DELTA_create;
						paxdelta(ip, op, f, DELTA_TAR|DELTA_FD|DELTA_FREE|DELTA_SIZE, f->fd, f->st->st_size, DELTA_DEL|DELTA_TEMP|DELTA_OUTPUT, &f->fd, 0);
					}
					else f->delta.op = 0;
					deltaout(ip, op, f);
				}
				else fileskip(ip, f);
				break;
			case DELTA_pass:
				if (validout(op, f) && selectfile(op, f))
				{
					if (ip->delta && (ip->delta->format->flags & DELTAIO))
					{
						f->delta.op = DELTA_create;
						paxdelta(ip, op, f, DELTA_DEL|DELTA_BIO|DELTA_SIZE, ip, f->st->st_size, DELTA_TAR|DELTA_TEMP|DELTA_OUTPUT, &f->fd, 0);
					}
					else if (fp = filter(op, f))
					{
						int		wfd;

						static char*	tmp;

						if (!tmp)
							tmp = pathtemp(NiL, 0, NiL, error_info.id, NiL);
						if ((wfd = open(tmp, O_CREAT|O_TRUNC|O_WRONLY|O_BINARY, S_IRUSR)) < 0)
						{
							error(2, "%s: cannot create filter temporary %s", f->path, tmp);
							fileskip(ip, f);
							break;
						}
						holeinit(wfd);
						for (c = f->st->st_size; c > 0; c -= state.buffersize)
						{
							n = c > state.buffersize ? state.buffersize : c;
							if (bread(ip, state.tmp.buffer, n, n, 1) <= 0)
							{
								error(ERROR_SYSTEM|2, "%s: read error", f->name);
								break;
							}
							if (holewrite(wfd, state.tmp.buffer, n) != n)
							{
								error(ERROR_SYSTEM|2, "%s: filter temporary write error to %s", f->name, tmp);
								break;
							}
						}
						holedone(wfd);
						close(wfd);
						p = f->path;
						f->path = tmp;
						f->fd = apply(op, f, fp);
						if (remove(f->path))
							error(1, "%s: cannot remove filter temporary", p, f->path);
						f->path = p;
						f->delta.op = 0;
					}
					else f->delta.op = 0;
					deltaout(ip, op, f);
				}
				else fileskip(ip, f);
				break;
			case DELTA_delete:
				if (!f->delta.base)
					error(3, "%s: base archive mismatch [%s#%d]", f->name, __FILE__, __LINE__);
				if (ip->delta && (d = (Member_t*)hashget(ip->delta->tab, f->name)))
					d->info->delta.op = DELTA_delete;
				break;
			case DELTA_update:
				if (!f->delta.base)
					error(3, "%s: base archive mismatch [%s#%d]", f->name, __FILE__, __LINE__);
				if (validout(op, f) && selectfile(op, f))
				{
					if (state.ordered) paxdelta(ip, op, f, DELTA_SRC|DELTA_BIO|DELTA_SIZE, ip->delta->base, f->delta.base->size, DELTA_TAR|DELTA_TEMP|DELTA_OUTPUT, &f->fd, DELTA_DEL|DELTA_BIO|DELTA_SIZE, ip, f->st->st_size, 0);
					else paxdelta(ip, op, f, DELTA_SRC|DELTA_FD|DELTA_OFFSET|DELTA_SIZE, ip->delta->base->io->fd, f->delta.base->offset, f->delta.base->size, DELTA_TAR|DELTA_TEMP|DELTA_OUTPUT, &f->fd, DELTA_DEL|DELTA_BIO|DELTA_SIZE, ip, f->st->st_size, 0);
					if (op->delta && (op->delta->format->flags & DELTAIO))
					{
						f->delta.op = DELTA_create;
						paxdelta(ip, op, f, DELTA_TAR|DELTA_FD|DELTA_FREE|DELTA_SIZE, f->fd, f->st->st_size, DELTA_DEL|DELTA_TEMP|DELTA_OUTPUT, &f->fd, 0);
					}
					else f->delta.op = 0;
					deltaout(ip, op, f);
				}
				else fileskip(ip, f);
				break;
			case DELTA_verify:
				if (!f->delta.base || f->delta.base->mtime.tv_sec != f->st->st_mtime)
					error(3, "%s: base archive mismatch [%s#%d]", f->name, __FILE__, __LINE__);
			pass:
				if (validout(op, f) && selectfile(op, f))
				{
					f->delta.op = 0;
					deltacopy(ip, op, f);
				}
				else fileskip(ip, f);
				break;
			default:
				error(3, "%s: %s: not a delta archive (op=%d)", ip->name, f->name, f->delta.op);
				break;
			}
			gettrailer(ip, f);
		}
		if (!getepilogue(ip))
			break;
	}
	if (ip->delta && ip->delta->tab)
	{
		/*
		 * copy the non-empty untouched base hard links first
		 */

		if (pos = hashscan(ip->delta->tab, 0))
		{
			message((-2, "copy non-empty untouched base hard links"));
			while (hashnext(pos))
			{
				d = (Member_t*)pos->bucket->value;
				if (!d->mark && d->info->linktype != HARDLINK && d->info->st->st_size > 0 && selectfile(op, d->info))
				{
					d->mark = 1;
					deltacopy(ip, op, d->info);
				}
			}
			hashdone(pos);
		}

		/*
		 * copy the remaining untouched base files and deletes
		 */

		if (pos = hashscan(ip->delta->tab, 0))
		{
			message((-2, "copy remaining untouched base files"));
			while (hashnext(pos))
			{
				d = (Member_t*)pos->bucket->value;
				if (!d->mark && selectfile(op, d->info))
				{
					d->mark = 1;
					if (d->info->linktype == HARDLINK)
					{
						if (!(h = (Member_t*)hashget(ip->delta->tab, d->info->linkpath)))
							error(1, "%s: %s: %s: hard link not in base archive", ip->name, d->info->name, d->info->linkpath);
						else if (!h->mark || h->info->delta.op == DELTA_delete)
						{
							h->info->name = d->info->name;
							d = h;
						}
					}
					deltacopy(ip, op, d->info);
				}
			}
			hashdone(pos);
		}
	}
	deltadelete(op);
	putepilogue(op);
	op->volume = 0;
	op->selected = op->entries;
}

/*
 * set delta info from pseudo file
 */

void
deltaset(register Archive_t* ap, char* s)
{
	Format_t*	dp;
	char*		t;
	int		type;

	dp = 0;
	if ((type = *++s) != TYPE_COMPRESS && type != TYPE_DELTA)
		error(3, "type %c encoding not supported", *s);
	if (*++s == INFO_SEP)
	{
		if (t = strchr(++s, INFO_SEP))
			*t++ = 0;
		if (*s)
		{
			if (isdigit(*s))
				s = sfprints("delta%s", s);
			dp = getformat(s, 1);
		}

		/*
		 * [<INFO_SEP>[<OP>]<VAL>]* may appear here
		 */

		while ((s = t) && *s != INFO_SEP)
		{
			if (t = strchr(s, INFO_SEP))
				*t++ = 0;
			switch (*s++)
			{
			case INFO_ORDERED:
				ap->ordered = 1;
				break;
			}
		}
	}
	if (!dp)
		dp = getformat(FMT_DELTA, 1);
	initdelta(ap, dp);
	ap->delta->compress = type == TYPE_COMPRESS;
	ap->checkdelta = 0;
}

/*
 * check for delta pseudo file
 */

int
deltacheck(register Archive_t* ap, register File_t* f)
{
	register char*		s;
	register Archive_t*	bp;
	register char*		t;
	off_t			size;
	unsigned long		checksum;

	if (!f || !f->st->st_size && !f->st->st_dev && !f->st->st_ino && !(f->st->st_mode & (X_IRWXU|X_IRWXG|X_IRWXO)) && strmatch(f->name, INFO_MATCH))
	{
		if (ap->checkdelta)
		{
			ap->checkdelta = 0;
			if (f)
			{
				s = f->name;
				size = f->st->st_mtime;
				checksum = (DELTA_LO(f->st->st_gid) << 16) | DELTA_LO(f->st->st_uid);
				if (streq(s, "DELTA!!!"))
					initdelta(ap, getformat("delta88", 1));
				else if (*s++ == INFO_SEP)
				{
					if (strneq(s, ID, IDLEN) && (t = strchr(s, INFO_SEP)))
						deltaset(ap, t);
					else
					{
						if (t = strchr(s += 2, INFO_SEP))
							*t = 0;
						error(1, "unknown %s header ignored", s);
						return 0;
					}
				}
			}
			else if (ap->delta)
			{
				size = ap->delta->size;
				checksum = ap->delta->checksum;
			}
			if (ap->delta && ap->delta->format)
			{
				if (!ap->delta->compress && ap->parent)
					error(3, "%s: %s: base archive cannot be a delta", ap->parent->name, ap->name);
				if (bp = ap->delta->base)
				{
					if (ap->delta->format->variant == DELTA_88)
						bp->checksum = bp->old.checksum;
					message((-5, "checkdelta: %s size=%I*d:%I*d checksum=%08x:%08x", ap->delta->format->name, sizeof(size), size, sizeof(bp->size), bp->size, checksum, bp->checksum));
					if (!ap->delta->compress)
					{
						if (!ap->ordered)
						{
							if (state.ordered)
								error(3, "%s: delta archive not ordered", ap->name);
							if (bp->size != size)
								error(3, "%s: %s: base archive size mismatch -- expected %I*u, got %I*u", ap->name, bp->name, sizeof(size), size, sizeof(bp->size), bp->size);
						}
						if ((bp->checksum ^ checksum) & 0xffffffff)
							error(1, "%s: %s: base archive checksum mismatch -- expected %08lx, got %08lx", ap->name, bp->name, checksum & 0xffffffff, bp->checksum & 0xffffffff);
					}
				}
				else if (!ap->delta->compress)
				{
					error(state.list ? 1 : 3, "%s: base archive must be specified", ap->name);
					deltabase(ap);
					ap->delta->compress = 1;
				}
				if (ap->sum <= 0)
					ap->sum++;
				return 1;
			}
			if (f)
				error(1, "%s: %s: unknown control header treated as regular file", ap->name, f->name);
		}
		else if (f && *f->name == INFO_SEP && strneq(f->name + 1, ID, IDLEN) && *(f->name + IDLEN + 1) == INFO_SEP)
		{
			getdeltaheader(ap, f);
			setinfo(ap, f);
			return 1;
		}
	}
	if (f && ap->checkdelta && ap->delta)
		ap->delta->format = getformat(FMT_PATCH, 1);
	return 0;
}

#include <vdelta.h>

typedef struct
{
	Vddisc_t	vd;
	Archive_t*	ap;
	off_t		base;
	Archive_t*	bp;
	off_t		offset;
	int*		pfd;
	int		fd;
	int		op;
} Vdio_t;

#define Vdoff_t		long

/*
 * delta discipline read
 */

static int
delread(void* buf, int n, Vdoff_t off, Vddisc_t* vd)
{
	register Vdio_t*	dp = (Vdio_t*)vd;
	register Vdoff_t	diff;

	message((-6, "delread: op=%o buf=%p n=%d off=%I*d nxt=%I*d", dp->op, buf, n, sizeof(off), off, sizeof(dp->offset), dp->offset));
	if (diff = off - dp->offset)
	{
		dp->offset = off;
		if (dp->op & DELTA_BIO)
		{
			if (bseek(dp->bp, diff, SEEK_CUR, 0) < 0)
				error(PANIC, "BIO seek: have=%I*d need=%I*d", sizeof(dp->offset), dp->offset, sizeof(off), off);
		}
		else
		{
			off += dp->base;
			if (lseek(dp->fd, off, SEEK_SET) != off)
			{
				message((-8, "delread: fd=%d n=%d off=%I*d: seek error", dp->fd, n, sizeof(off), off));
				return -1;
			}
		}
	}
	if (n > (dp->vd.size - dp->offset))
		n = dp->vd.size - dp->offset;
	if (n <= 0)
	{
		message((-8, "delread: fd=%d n=%d siz=%I*d off=%I*d: seek error", dp->fd, n, sizeof(dp->vd.size), dp->vd.size, sizeof(dp->offset), dp->offset));
		return 0;
	}
	n = (dp->op & DELTA_BIO) ? bread(dp->bp, buf, (off_t)0, (off_t)n, 1) : read(dp->fd, buf, n);
	if (n > 0)
		dp->offset += n;
	return n;
}

/*
 * delta discipline write
 */

static int
delwrite(void* buf, int n, Vdoff_t off, Vddisc_t* vd)
{
	register Vdio_t*	dp = (Vdio_t*)vd;
	Buffer_t*		bp;
	ssize_t			k;

	message((-6, "delwrite: op=%o buf=%p n=%d off=%I*d", dp->op, buf, n, sizeof(off), off));
	if (dp->op & DELTA_BIO)
	{
		bwrite(dp->bp, buf, n);
		return n;
	}
	if (dp->op & DELTA_HOLE)
		return holewrite(dp->fd, buf, n);
	if (bp = getbuffer(dp->fd))
	{
		if (bp->next + n < bp->past)
		{
			memcpy(bp->next, buf, n);
			bp->next += n;
			return n;
		}
		if ((dp->fd = open(state.tmp.file, O_CREAT|O_TRUNC|O_WRONLY|O_BINARY, S_IRUSR)) < 0)
			error(3, "%s: cannot create delta temporary file", state.tmp.file);
		k = bp->next - bp->base;
		if (k > 0 && write(dp->fd, bp->base, k) != k)
			return -1;
	}
	return write(dp->fd, buf, n);
}

/*
 * delta/update algorithm wrapper
 */

int
paxdelta(Archive_t* ip, Archive_t* ap, File_t* f, int op, ...)
{
	register Vdio_t*	dp;
	va_list			vp;
	ssize_t			n;
	int			bufferclash = 0;
	int			hole = 0;
	Format_t*		fp;
	Buffer_t*		bp;
	Sfio_t*			mp = 0;
	Vdio_t*			gen = 0;
	Vdio_t			data[3];

#if DEBUG
	static const char*	dataname[] = { "src", "tar", "del", "HUH" };
#endif

	va_start(vp, op);
#if 0
	if (ap && ap->delta && !ap->delta->format)
		ap->delta->format = getformat(FMT_DELTA, 1);
	if (ip && ip->delta && !ip->delta->format)
		ip->delta->format = getformat(FMT_DELTA, 1);
#else
	if (ap && ap->delta)
	{
		if (!ap->delta->format)
			ap->delta->format = getformat(FMT_DELTA, 1);
		fp = ap->delta->format;
	}
	if (ip && ip->delta)
	{
		if (!ip->delta->format)
			ip->delta->format = getformat(FMT_DELTA, 1);
		fp = ip->delta->format;
	}
#endif
#if DEBUG
	if (error_info.trace <= -5) mp = sfstropen();
#endif
	memzero(data, sizeof(data));
	while (op)
	{
		dp = &data[op & DELTA_DATA];
		dp->ap = ap && ap->delta ? ap : ip;
#if DEBUG
		if (mp) sfprintf(mp, " %s [", dataname[op & DELTA_DATA]);
#endif
		if (op & DELTA_BIO)
			dp->bp = va_arg(vp, Archive_t*);
		else if (op & DELTA_FD)
		{
			if ((dp->fd = va_arg(vp, int)) == -1)
			{
				op &= ~(DELTA_FD|DELTA_FREE);
				op |= DELTA_BIO;
				dp->bp = ip ? ip : ap;
			}
			else if (bp = getbuffer(dp->fd))
			{
				op &= ~(DELTA_FD|DELTA_FREE);
				op |= DELTA_BUFFER;
				dp->vd.data = bp->base;
				bufferclash = 1;
			}
#if DEBUG
			else if (mp) sfprintf(mp, " fd=%d", dp->fd);
#endif
		}
		else if (op & DELTA_TEMP)
		{
			dp->pfd = va_arg(vp, int*);
			op |= DELTA_FD;
			op &= ~DELTA_FREE;
#if DEBUG
			if (mp) sfprintf(mp, " TEMP");
#endif
		}
		else if (op & DELTA_BUFFER)
		{
			dp->vd.data = va_arg(vp, char*);
#if DEBUG
			if (mp) sfprintf(mp, " buffer=%p", dp->vd.data);
#endif
		}
		if (op & DELTA_OFFSET)
		{
			dp->base = va_arg(vp, off_t);
#if DEBUG
			if (mp) sfprintf(mp, " offset=%I*d", sizeof(dp->base), dp->base);
#endif
		}
		if (op & DELTA_SIZE)
		{
			dp->vd.size = va_arg(vp, off_t);
#if DEBUG
			if (mp) sfprintf(mp, " size=%I*d", sizeof(dp->vd.size), dp->vd.size);
#endif
		}
		if ((op & (DELTA_BIO|DELTA_OUTPUT)) == DELTA_BIO && dp->vd.size > 0 && dp->vd.size <= state.buffersize && (dp->vd.data = bget(dp->bp, dp->vd.size, NiL)))
		{
			op &= ~(DELTA_BIO|DELTA_FREE);
			op |= DELTA_BUFFER;
#if DEBUG
			if (mp) sfprintf(mp, " buffer=%p", dp->vd.data);
#endif
		}
		if (op & (DELTA_BIO|DELTA_FD))
		{
			if (op & DELTA_OUTPUT)
			{
				dp->vd.writef = delwrite;
				if (!hole && (op & (DELTA_FD|DELTA_TEMP)) == DELTA_FD)
				{
					hole = 1;
					op |= DELTA_HOLE;
					holeinit(dp->fd);
				}
			}
			else dp->vd.readf = delread;
			if ((op & (DELTA_FD|DELTA_TEMP)) == DELTA_FD && dp->base && lseek(dp->fd, dp->base, SEEK_SET) != dp->base)
				error(3, "%s: cannot seek delta", f->name);
#if DEBUG
			if (mp && (op & DELTA_BIO)) sfprintf(mp, " bio=%s", dp->bp->name);
#endif
		}
		if (op & DELTA_OUTPUT)
		{
			if (gen) error(PANIC, "paxdelta(): more than one DELTA_OUTPUT");
			gen = dp;
#if DEBUG
			if (mp) sfprintf(mp, " OUTPUT");
#endif
		}
#if DEBUG
		if (mp && (op & DELTA_COUNT)) sfprintf(mp, " COUNT");
#endif
#if DEBUG
		if (mp) sfprintf(mp, " ]");
#endif
		dp->op = op;
		op = va_arg(vp, int);
	}
	va_end(vp);
	if (!gen)
		error(PANIC, "paxdelta(): no DELTA_OUTPUT");
#if 0
	fp = (gen == &data[DELTA_DEL]) ? ap->delta->format : ip->delta->format;
#endif
	if (gen->pfd)
	{
		if (!(state.test & 0000020) && fp->variant != DELTA_88 && (state.buffer[bufferclash ? (state.delta.bufferindex = !state.delta.bufferindex) : state.delta.bufferindex].base || (state.buffer[state.delta.bufferindex].base = newof(0, char, state.delta.buffersize, 0)) || (state.delta.buffersize >>= 1) && (state.buffer[state.delta.bufferindex].base = newof(0, char, state.delta.buffersize, 0))))
		{
			gen->fd = setbuffer(state.delta.bufferindex);
			bp = getbuffer(gen->fd);
			bp->next = bp->base;
			bp->past = bp->base + state.delta.buffersize;
		}
		else if ((gen->fd = open(state.tmp.file, O_CREAT|O_TRUNC|O_WRONLY|O_BINARY, S_IRUSR)) < 0)
			error(3, "%s: cannot create delta temporary file", state.tmp.file);
	}
	switch (fp->variant)
	{
	case DELTA_88:
	case DELTA_PATCH:
		/*
		 * force the new interface into the old
		 * not the most efficient way but at least
		 * the rest of the code is clean
		 */

		{
			static char*	tmp;

			if (gen == &data[DELTA_DEL])
			{
				if (!(data[DELTA_DEL].op & DELTA_FD))
					error(PANIC, "paxdelta: %s %s must be DELTA_TEMP or DELTA_FD", fp->name, dataname[DELTA_DEL]);
				for (op = 0; op < elementsof(data); op++)
				{
					if (op == DELTA_DEL) /*NOP*/;
					else if (!data[op].vd.size)
					{
						data[op].vd.data = state.tmp.buffer;
						data[op].op &= ~DELTA_FREE;
					}
					else switch (data[op].op & (DELTA_BIO|DELTA_FD|DELTA_OUTPUT))
					{
					case DELTA_BIO:
						if (!(data[op].vd.data = malloc(data[op].vd.size)))
							nospace();
						if (bread(data[op].bp, data[op].vd.data, data[op].vd.size, data[op].vd.size, 1) != data[op].vd.size)
							error(3, "%s: delta bread error", f->name);
						data[op].op &= ~DELTA_BIO;
						data[op].op |= DELTA_BUFFER|DELTA_FREE;
						break;
					case DELTA_FD:
						if (!(data[op].vd.data = malloc(data[op].vd.size)))
							nospace();
						if (data[op].base && lseek(data[op].fd, data[op].base, SEEK_SET) != data[op].base)
							error(3, "%s: delta seek error", f->name);
						if (read(data[op].fd, data[op].vd.data, data[op].vd.size) != data[op].vd.size)
							error(3, "%s: delta read error", f->name);
						if (data[op].op & DELTA_FREE)
							close(data[op].fd);
						data[op].op &= ~DELTA_FD;
						data[op].op |= DELTA_BUFFER|DELTA_FREE;
						break;
					}
				}
				switch (fp->variant)
				{
				case DELTA_88:
					n = delta(data[DELTA_SRC].vd.data, data[DELTA_SRC].vd.size, data[DELTA_TAR].vd.data, data[DELTA_TAR].vd.size, data[DELTA_DEL].fd) ? -1L : lseek(data[DELTA_DEL].fd, (off_t)0, SEEK_END);
					break;
				case DELTA_PATCH:
					error(1, "AHA %s %s/%s SRC=%d:%p TAR=%d:%p DEL=%d:%p", fp->name, ap->name, f->path, data[DELTA_SRC].vd.size, data[DELTA_SRC].vd.data, data[DELTA_TAR].vd.size, data[DELTA_TAR].vd.data, data[DELTA_DEL].vd.size, data[DELTA_DEL].vd.data);
					n = 0;
					break;
				}
			}
			else
			{
				if (!(data[DELTA_TAR].op & DELTA_FD))
					error(PANIC, "paxdelta: %s %s must be DELTA_TEMP or DELTA_FD", fp->name, dataname[DELTA_TAR]);
				for (op = 0; op < elementsof(data); op++)
				{
					if (op == DELTA_TAR) /*NOP*/;
					else if (!data[op].vd.size)
					{
						data[op].fd = 0;
						data[op].op &= ~DELTA_FREE;
					}
					else switch (data[op].op & (DELTA_BIO|DELTA_BUFFER|DELTA_OUTPUT))
					{
					case DELTA_BIO:
						if (!(data[op].vd.data = malloc(data[op].vd.size)))
							nospace();
						if (bread(data[op].bp, data[op].vd.data, data[op].vd.size, data[op].vd.size, 1) != data[op].vd.size)
							error(3, "%s: delta bread error", f->name);
						/*FALLTHROUGH*/
					case DELTA_BUFFER:
						if (!tmp) tmp = pathtemp(NiL, 0, NiL, error_info.id, NiL);
						if ((data[op].fd = open(tmp, O_CREAT|O_TRUNC|O_WRONLY|O_BINARY, S_IRUSR)) < 0)
							error(3, "%s: cannot create delta temporary file", tmp);
						if (write(data[op].fd, data[op].vd.data, data[op].vd.size) != data[op].vd.size)
							error(ERROR_SYSTEM|3, "%s: delta write error", f->name);
						close(data[op].fd);
						if ((data[op].fd = open(tmp, O_RDONLY|O_BINARY)) < 0)
							error(ERROR_SYSTEM|3, "%s: cannot read delta temporary file", tmp);
						if (remove(tmp))
							error(ERROR_SYSTEM|1, "%s: cannot remove delta temporary file", tmp);
						if (data[op].op & DELTA_BUFFER)
						{
							if (data[op].op & DELTA_FREE)
								free(data[op].vd.data);
							data[op].vd.data = 0;
						}
						data[op].op &= ~(DELTA_BIO|DELTA_BUFFER);
						data[op].op |= DELTA_FD|DELTA_FREE;
						break;
					}
				}
				switch (fp->variant)
				{
				case DELTA_88:
					n = update(data[DELTA_SRC].fd, data[DELTA_SRC].base, data[DELTA_DEL].fd, data[DELTA_TAR].fd) ? -1L : lseek(data[DELTA_TAR].fd, (off_t)0, SEEK_END);
					break;
				case DELTA_PATCH:
					error(PANIC, "paxdelta: %s update not supported", fp->name);
					break;
				}
			}
		}
		break;
	default:
		if (gen != &data[DELTA_DEL] && !data[DELTA_SRC].vd.size && !data[DELTA_DEL].vd.size)
			n = 0;
		else if (gen == &data[DELTA_DEL])
		{
			n = vddelta((Vddisc_t*)&data[DELTA_SRC], (Vddisc_t*)&data[DELTA_TAR], (Vddisc_t*)&data[DELTA_DEL]);
			if (n == 15)
				f->delta.same = 1;
		}
		else
			n = vdupdate((Vddisc_t*)&data[DELTA_SRC], (Vddisc_t*)&data[DELTA_TAR], (Vddisc_t*)&data[DELTA_DEL]);
		break;
	}
#if DEBUG
	if (mp)
	{
		message((-5, "%s %s: %s:%s return=%ld", gen == &data[DELTA_DEL] ? "delta" : "update", fp->name, f->name, sfstruse(mp), n));
		sfstrclose(mp);
	}
#endif
	if (n < 0)
	{
		error(ERROR_SYSTEM|2, "%s: delta error", f->name);
		return -1;
	}
	f->uncompressed = f->st->st_size;
	f->st->st_size = n;
	for (op = 0; op < elementsof(data); op++)
	{
		if (data[op].op & DELTA_HOLE)
			holedone(data[op].fd);
		switch (data[op].op & (DELTA_BUFFER|DELTA_FD|DELTA_FREE))
		{
		case DELTA_BUFFER|DELTA_FREE:
			free(data[op].vd.data);
			break;
		case DELTA_FD|DELTA_FREE:
			if ((data[op].op & (DELTA_TEMP|DELTA_OUTPUT)) == DELTA_OUTPUT)
				closeout(ap, f, data[op].fd);
			else
				close(data[op].fd);
			if (data[op].vd.data)
				free(data[op].vd.data);
			break;
		}
		if (data[op].op & DELTA_COUNT)
		{
			ap->io->expand += n;
			if (data[op].op & DELTA_OUTPUT)
				setfile(ap, f);
		}
		if (data[op].op & DELTA_LIST)
			listentry(f);
	}
	if (gen->pfd)
	{
		if (bp = getbuffer(gen->fd))
		{
			*gen->pfd = gen->fd;
			bp->next = bp->base;
		}
		else
		{
			close(gen->fd);
			if ((*gen->pfd = open(state.tmp.file, O_RDONLY|O_BINARY)) < 0)
				error(ERROR_SYSTEM|3, "%s: cannot read delta temporary file", state.tmp.file);
			if (remove(state.tmp.file))
				error(ERROR_SYSTEM|1, "%s: cannot remove delta temporary file", state.tmp.file);
		}
	}
	return 0;
}