pax-vdb.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

/*
 * pax vdb format
 */

#include "format.h"

#include <vdb.h>

typedef struct Vdb_s
{
	unsigned char	delimiter;	/* header delimiter		*/
	unsigned char	variant;	/* variant header delimiters	*/
	Sfio_t*		directory;	/* directory trailer stream	*/
	struct stat	st;		/* member stat prototype	*/
	struct
	{
	char*		base;		/* header buffer base		*/
	char*		next;		/* next header			*/
	}		header;
} Vdb_t;

static int
vdb_getprologue(Pax_t* pax, Format_t* fp, register Archive_t* ap, File_t* f, unsigned char* buf, size_t size)
{
	register Vdb_t*		vdb = (Vdb_t*)ap->data;
	char*			s;
	char*			t;
	struct stat		st;
	size_t			i;
	off_t			n;

	if (fstat(ap->io->fd, &st))
		return 0;
	s = state.tmp.buffer;
	n = sizeof(VDB_MAGIC) + sizeof(state.volume) + 1;
	if (size < n)
		return 0;
	s = (char*)buf;
	if (s[0] != VDB_DELIMITER || !strneq(s + 1, VDB_MAGIC, sizeof(VDB_MAGIC) - 1) || s[sizeof(VDB_MAGIC)] != VDB_DELIMITER)
		return 0;
	if (s[sizeof(VDB_MAGIC) + 1] != '\n')
	{
		s[n] = 0;
		if (t = strchr(s, '\n'))
			*t = 0;
		strncpy(state.volume, s + sizeof(VDB_MAGIC) + 1, sizeof(state.volume) - 2);
	}
	if (lseek(ap->io->fd, (off_t)(-(VDB_LENGTH + 1)), SEEK_END) <= 0)
		return 0;
	if (read(ap->io->fd, s, VDB_LENGTH + 1) != (VDB_LENGTH + 1))
		return 0;
	if (!vdb)
	{
		if (!(vdb = newof(0, Vdb_t, 1, 0)))
			nospace();
		ap->data = vdb;
	}
	ccmapstr(state.map.a2n, s, VDB_LENGTH + 1);
	vdb->variant = *s++ != '\n';
	if (!strneq(s, VDB_DIRECTORY, sizeof(VDB_DIRECTORY) - 1))
		goto nope;
	vdb->delimiter = s[VDB_OFFSET - 1];
	n = strtol(s + VDB_OFFSET, NiL, 10) - sizeof(VDB_DIRECTORY);
	i = lseek(ap->io->fd, (off_t)0, SEEK_CUR) - n - VDB_LENGTH - vdb->variant;
	if (!(vdb->header.base = newof(0, char, i, 1)))
		nospace();
	if (lseek(ap->io->fd, n, SEEK_SET) != n)
		goto nope;
	if (read(ap->io->fd, vdb->header.base, i) != i)
		goto nope;
	ccmapstr(state.map.a2n, vdb->header.base, i);
	*(vdb->header.base + i) = 0;
	if (!strneq(vdb->header.base, VDB_DIRECTORY, sizeof(VDB_DIRECTORY) - 1))
		goto nope;
	if (!(vdb->header.next = strchr(vdb->header.base, '\n')))
		goto nope;
	vdb->header.next++;
	vdb->st.st_mode = modex(vdb->st.st_mode);
	return 1;
 nope:
	free(vdb);
	return 0;
}

static int
vdb_done(Pax_t* pax, register Archive_t* ap)
{
	register Vdb_t*	vdb = (Vdb_t*)ap->data;

	if (vdb)
	{
		if (vdb->directory)
			sfclose(vdb->directory);
		free(vdb);
		ap->data = 0;
	}
	return 0;
}

static int
vdb_getheader(Pax_t* pax, Archive_t* ap, register File_t* f)
{
	register Vdb_t*	vdb = (Vdb_t*)ap->data;
	char*		s;
	char*		t;
	off_t		n;

	t = vdb->header.next;
	if (!(vdb->header.next = strchr(t, '\n')))
		goto eof;
	*vdb->header.next++ = 0;
	message((-1, "VDB: next=`%s'", t));
	if (vdb->variant)
		vdb->delimiter = *t++;
	f->name = t;
	if (!(t = strchr(t, vdb->delimiter)))
		goto eof;
	*t++ = 0;
	n = strtol(t, &t, 10);
	if (*t++ != vdb->delimiter)
		goto eof;
	if (lseek(ap->io->fd, n, SEEK_SET) != n)
		goto eof;
	*f->st = vdb->st;
	f->st->st_size = strtol(t, &t, 10);
	if (*t++ == vdb->delimiter) do
	{
		if (s = strchr(t, vdb->delimiter))
			*s++ = 0;
		if (strneq(t, VDB_DATE, sizeof(VDB_DATE) - 1))
			f->st->st_mtime = strtol(t + sizeof(VDB_DATE), NiL, 10);
		else if (strneq(t, VDB_MODE, sizeof(VDB_MODE) - 1))
			f->st->st_mode = (strtol(t + sizeof(VDB_MODE), NiL, 8) & X_IPERM) | X_IFREG;
	} while (t = s);
	f->st->st_dev = 0;
	f->st->st_ino = 0;
	f->st->st_nlink = 1;
	IDEVICE(f->st, 0);
	f->linktype = NOLINK;
	f->linkpath = 0;
	f->uidname = 0;
	f->gidname = 0;
	paxsync(pax, ap, 0);
	return 1;
 eof:
	paxsync(pax, ap, 0);
	ap->io->eof = 1;
	ap->io->offset = 0;
	ap->io->count = lseek(ap->io->fd, (off_t)0, SEEK_END);
	return 0;
}

static int
vdb_putprologue(Pax_t* pax, register Archive_t* ap, int append)
{
	register Vdb_t*	vdb = (Vdb_t*)ap->data;

	if (!vdb)
	{
		if (!(vdb = newof(0, Vdb_t, 1, 0)) || !(vdb->directory = sfstropen()))
			nospace();
		ap->data = vdb;
	}
	if (append)
		return 0;
	sfprintf(vdb->directory, "%c%s%c%s\n", VDB_DELIMITER, VDB_MAGIC, VDB_DELIMITER, state.volume);
	paxwrite(pax, ap, sfstrbase(vdb->directory), sfstrtell(vdb->directory));
	sfstrseek(vdb->directory, 0, SEEK_SET);
	sfprintf(vdb->directory, "%s\n", VDB_DIRECTORY);
	return 1;
}

static int
vdb_putheader(Pax_t* pax, Archive_t* ap, File_t* f)
{
	register Vdb_t*		vdb = (Vdb_t*)ap->data;
	register unsigned char*	s;
	register int		c;
	int			n;

	if (state.complete)
		complete(ap, f, state.record.header ? state.record.headerlen : f->namesize);
	if (state.record.header)
		paxwrite(pax, ap, state.record.header, state.record.headerlen);
	else
	{
		f->name[f->namesize - 1] = '\n';
		paxwrite(pax, ap, f->name, f->namesize);
		f->name[f->namesize - 1] = 0;
	}
	if (!(c = state.record.delimiter))
	{
		c = VDB_DELIMITER;
		s = (unsigned char*)state.tmp.buffer;
		n = 1024;
		if (f->fd >= 0)
		{
			n = read(f->fd, s, n);
			if (n > 0)
			{
				int		dp;
				int		ds;
				int		mp = 0;
				int		ms = 0;
				unsigned char	hit[UCHAR_MAX + 1];

				/*
				 * to determine the delimiter, if any
				 */

				lseek(f->fd, -n, SEEK_CUR);
				memzero(hit, sizeof(hit));
				while (--n > 0)
					hit[*(s + n)]++;
				for (n = 0; n <= UCHAR_MAX; n++)
					if (n == '_' || n == '/' || n == '.' || n == '\n' || n == '\\')
						/* nop */;
					else if (isspace(n))
					{
						if ((int)hit[n] > ms)
						{
							ms = hit[n];
							ds = n;
						}
					}
					else if ((int)hit[n] > mp && isprint(n) && !isalnum(n))
					{
						mp = hit[n];
						dp = n;
					}
				if (mp)
					c = dp;
				else if (ms)
					c = ds;
			}
		}
	}
	n = (c == '=') ? ':' : '=';
	sfprintf(vdb->directory, "%c%s%c%I*u%c%I*u%c%s%c%I*u%c%s%c0%o\n", c, f->name, c, sizeof(ap->io->offset), ap->io->offset + ap->io->count, c, sizeof(f->st->st_size), f->st->st_size, c, VDB_DATE, n, sizeof(f->st->st_mtime), f->st->st_mtime, c, VDB_MODE, n, modex(f->st->st_mode & X_IPERM));
	return 1;
}

static int
vdb_puttrailer(Pax_t* pax, Archive_t* ap, File_t* f)
{
	if (state.record.trailer)
		paxwrite(pax, ap, state.record.trailer, state.record.trailerlen);
	return 0;
}

static off_t
vdb_putepilogue(Pax_t* pax, Archive_t* ap)
{
	register Vdb_t*	vdb = (Vdb_t*)ap->data;

	if (state.record.header)
		paxwrite(pax, ap, state.record.header, state.record.headerlen);
	sfprintf(vdb->directory, "%c%s%c%0*I*d%c%0*I*d\n", VDB_DELIMITER, VDB_DIRECTORY, VDB_DELIMITER, VDB_FIXED, sizeof(ap->io->offset), ap->io->offset + ap->io->count + sizeof(VDB_DIRECTORY), VDB_DELIMITER, VDB_FIXED, sizeof(Sfoff_t), sftell(vdb->directory) - sizeof(VDB_DIRECTORY) + VDB_LENGTH + 1);
	paxwrite(pax, ap, sfstrbase(vdb->directory), sfstrtell(vdb->directory));
	sfstrclose(vdb->directory);
	return ap->io->count;
}

Format_t	pax_vdb_format =
{
	"vdb",
	0,
	"virtual database",
	0,
	ARCHIVE|NOHARDLINKS|IN|OUT,
	DEFBUFFER,
	DEFBLOCKS,
	0,
	PAXNEXT(vdb),
	0,
	vdb_done,
	vdb_getprologue,
	vdb_getheader,
	0,
	0,
	0,
	vdb_putprologue,
	vdb_putheader,
	0,
	vdb_puttrailer,
	vdb_putepilogue,
};

PAXLIB(vdb)