pax-slt.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 slt format for ansi and ibm labeled tapes
 */

#include "format.h"

#include <tm.h>

#define ANSI		1
#define IBM		2

#define SLT_ID		"slt"
#define LABEL_MAX	2048
#define HDR_SIZE	80
#define NAME_SIZE	17
#define VARHDR_SIZE	9

typedef struct Slt_s
{
	unsigned char*	mapin;		/* input map			*/
	unsigned char*	mapout;		/* output map			*/
	char		id[NAME_SIZE+1]; /* name id			*/
	char		volume[64];	/* volume id			*/
	char		format[7];	/* format id			*/
	char		implementation[8];/* implementation id		*/
	char		owner[15];	/* owner id			*/
	char		standards[20];	/* standards id			*/
	int		done;		/* label read done		*/
	int		ibm;		/* ibm format			*/
	int		peek;		/* buf (size peek) already read	*/
	int		section;	/* inside section		*/
	int		sequence;	/* sequence number		*/
	int		vol;		/* emit volume prologue		*/
	char		buf[LABEL_MAX]; /* header buffer		*/
	char		last[5];	/* last label			*/
} Slt_t;

/*
 * get label header number
 */

static long
getlabnum(register char* p, int byte, int width, int base)
{
	register char*	e;
	register int	c;
	long		n;

	p += byte - 1;
	c = *(e = p + width);
	*e = 0;
	n = strtol(p, NiL, base);
	*e = c;
	return n;
}

/*
 * get label header string
 */

static char*
getlabstr(register char* p, int byte, int width, register char* s)
{

	register char*	e;
	char*		v;

	v = s;
	p += byte - 1;
	e = p + width;
	while (p < e && (*s = *p++) != ' ')
		s++;
	*s = 0;
	return v;
}

/*
 * return length of next label
 * variable length labels have label number > 3 and Vnnnn at position 5
 * where nnnn is the decimal length of the entire label
 * nnnn may be < HDR_SIZE but label block must be >= HDR_SIZE
 * 0 returned at end of label group
 */

static int
getlabel(Pax_t* pax, register Archive_t* ap, register File_t* f)
{
	register Slt_t*	slt = (Slt_t*)ap->data;
	register int	c;
	register int	n;

	if (c = slt->peek)
	{
		slt->peek = 0;
		return c;
	}
	if (slt->done || (c = paxread(pax, ap, slt->buf, (off_t)HDR_SIZE, (off_t)LABEL_MAX, 0)) < HDR_SIZE)
		return *slt->last = slt->done = c = 0;
	if (slt->buf[4] == 'V' && ((n = getlabnum(slt->buf, 4, 1, 10)) < 1 || n > 3) && (n = getlabnum(slt->buf, 6, 4, 10)) != c)
	{
		if ((c = n - c) > 0)
		{
			if (ap->io->blocked || paxread(pax, ap, slt->buf + HDR_SIZE, (off_t)0, (off_t)c, 1) != c)
			{
				c = HDR_SIZE;
				error(2, "%s: %-*.*s: variable length label record too short", f->name, c, c, slt->buf);
			}
			else
				c = n;
		}
		else if (n <= VARHDR_SIZE)
			c = VARHDR_SIZE;
		else
			c = n;
	}
	if (!ap->io->blocked && !*slt->last && slt->buf[3] == '2' && (strneq(slt->buf, "HDR", 3) || strneq(slt->buf, "EOF", 3) || strneq(slt->buf, "EOV", 3)))
		getlabstr(slt->buf, 26, 4, slt->last);
	if (*slt->last && strneq(slt->buf, slt->last, 4))
		slt->done = 1;
	message((-4, "label: %-*.*s", c, c, slt->buf));
	return c;
}

/*
 * output file HDR/EOF/EOV labels
 */

static void
putlabels(Pax_t* pax, register Archive_t* ap, register File_t* f, char* type)
{
	register Slt_t*	slt = (Slt_t*)ap->data;
	struct tm*	tm;

	switch (*type)
	{
	case 'E':
		paxwrite(pax, ap, slt->buf, 0);
		break;
	case 'H':
		slt->sequence++;
		break;
	}
	tm = gmtime(&f->st->st_mtime);
	sfsprintf(slt->buf, sizeof(slt->buf), "%s1%-17.17s000001%04d%04d000100 %02d%03d 00000 %06d%-6.6sD%-7.7s       ", type, f->id, slt->section, slt->sequence, tm->tm_year, tm->tm_yday, f->record.blocks, slt->format, slt->implementation);
	paxwrite(pax, ap, slt->buf, HDR_SIZE);
	sfsprintf(slt->buf, sizeof(slt->buf), "%s2%c%05d%05d%010d%s%c                     00                            ", type, state.record.format, state.blocksize, state.record.size, f->st->st_size, type, '2');
	paxwrite(pax, ap, slt->buf, HDR_SIZE);
	paxwrite(pax, ap, slt->buf, 0);
	if (streq(type, "EOV"))
	{
		slt->section++;
		slt->sequence = 0;
	}
	else
		slt->section = 1;
}

static int
slt_getprologue(Pax_t* pax, Format_t* fp, register Archive_t* ap, File_t* f, unsigned char* buf, size_t size)
{
	register Slt_t*		slt;
	char*			s;
	char*			t;
	int			lab;
	long			n;
	off_t			x;
	char			hdr[HDR_SIZE + 1];

	static const char	key[] = "VOL1";

	if (size < HDR_SIZE)
		return 0;
	memcpy(hdr, buf, HDR_SIZE);
	if (fp->flags & CONV)
	{
		ccmapstr(state.map.e2n, hdr, HDR_SIZE);
		if (!strneq(hdr, key, sizeof(key) - 1))
			return 0;
		ccmapstr(state.map.e2n, hdr, HDR_SIZE);
		convert(ap, SECTION_CONTROL, CC_NATIVE, CC_EBCDIC);
		if (!ap->convert[0].on)
			convert(ap, SECTION_DATA, CC_NATIVE, CC_EBCDIC);
	}
	else
	{
		ccmapstr(state.map.a2n, hdr, HDR_SIZE);
		if (!strneq(hdr, key, sizeof(key) - 1))
			return 0;
		convert(ap, SECTION_CONTROL, CC_NATIVE, CC_ASCII);
		if (!ap->convert[0].on)
			convert(ap, SECTION_DATA, CC_NATIVE, CC_ASCII);
	}
	if (!(slt = newof(0, Slt_t, 1, 0)))
	{
		nospace();
		return -1;
	}
	ap->data = slt;
	getlabstr(hdr, 5, 6, state.volume);
	getlabstr(hdr, 25, 6, slt->format);
	getlabstr(hdr, 31, 7, slt->implementation);
	getlabstr(hdr, 38, 14, slt->owner);
	paxget(pax, ap, 0, &x);
	ap->io->blocked = !x;
	if (ap->checkdelta)
	{
		if (!(lab = getlabel(pax, ap, f)))
			return 0;
		if (strneq(slt->buf, "UVL1", 4) && strneq(slt->buf + 5, ID, IDLEN))
		{
			ap->checkdelta = 0;
			s = slt->buf + 10;
			f->st->st_mtime = getlabnum(slt->buf, 14, 10, 10);
			n = getlabnum(slt->buf, 24, 10, 10);
			f->st->st_uid = DELTA_LO(n);
			f->st->st_gid = DELTA_HI(n);
			if (t = strchr(s, ' '))
				*t = 0;
			deltaset(ap, s);
		}
		else
			slt->peek = lab;
	}
	return 1;
}

static int
slt_done(Pax_t* pax, register Archive_t* ap)
{
	if (ap->data)
	{
		free(ap->data);
		ap->data = 0;
	}
	return 0;
}

static int
slt_getheader(Pax_t* pax, register Archive_t* ap, register File_t* f, int wfd)
{
	register Slt_t*	slt = (Slt_t*)ap->data;
	register char*	s;
	register int	i;
	register off_t	n;
	int		lab;
	int		type;

 again:
	if (!(lab = getlabel(pax, ap, f)))
		return 0;
	f->st->st_dev = 0;
	f->st->st_ino = 0;
	f->st->st_mode = X_IFREG|X_IRUSR|X_IWUSR|X_IRGRP|X_IROTH;
	f->st->st_uid = state.uid;
	f->st->st_gid = state.gid;
	f->st->st_nlink = 1;
	IDEVICE(f->st, 0);
	f->st->st_size = 0;
	f->linktype = NOLINK;
	f->linkpath = 0;
	f->uidname = 0;
	f->gidname = 0;
	type = 0;
	do
	{
		if (strneq(slt->buf, "HDR", 3))
		{
			if (getlabnum(slt->buf, 4, 1, 10) != ++type)
				error(3, "%s format HDR label out of sequence", ap->format->name);
			if (type == 1)
			{
				s = f->name = paxstash(pax, &ap->stash.head, NiL, NAME_SIZE + 3);
				for (i = 4; i <= NAME_SIZE + 3; i++)
				{
					if (slt->buf[i] == ' ')
					{
						if (i >= NAME_SIZE + 3 || slt->buf[i + 1] == ' ')
							break;
						*s++ = '.';
					}
					else
						*s++ = isupper(slt->buf[i]) ? tolower(slt->buf[i]) : slt->buf[i];
				}
				if ((n = getlabnum(slt->buf, 40, 2, 10)) > 0 && n < 99)
					sfsprintf(s, 3, ".%02d", n);
				else
					*s = 0;
				f->record.section = getlabnum(slt->buf, 28, 4, 10);
				getlabstr(slt->buf, 5, NAME_SIZE, f->id = slt->id);
				getlabstr(slt->buf, 61, 6, slt->format);
				getlabstr(slt->buf, 67, 7, slt->implementation);
#if SAVESET
				if (streq(slt->format, SAVESET_ID) && streq(slt->implementation, SAVESET_IMPL))
					ap->format = SAVESET;
#endif
				f->st->st_mtime = 0;
				if (n = getlabnum(slt->buf, 43, 2, 10))
				{
					if (slt->buf[41] == '0') n += 100;
					if ((i = getlabnum(slt->buf, 45, 3, 10)) >= 0 && i <= 365)
					{
						f->st->st_mtime = i;
						while (n-- > 70) f->st->st_mtime += ((n % 4) || n == 100) ? 365 : 366;
						f->st->st_mtime *= 24L * 60L * 60L;
						f->st->st_mtime += 12L * 60L * 60L;
					}
				}
				if (!f->st->st_mtime)
					f->st->st_mtime = NOW;
			}
			else if (type == 2)
			{
				switch (f->record.format = slt->buf[4])
				{
				case 'D': /* decimal variable	*/
				case 'F': /* fixed length	*/
				case 'S': /* spanned		*/
				case 'U': /* input block size	*/
				case 'V': /* binary variable	*/
					break;
				default:
					error(2, "%s record format %c not supported", ap->format->name, f->record.format);
					f->skip = 1;
				}
				state.blocksize = getlabnum(slt->buf, 6, 5, 10);
				state.record.size = getlabnum(slt->buf, 11, 5, 10);
				if (!ap->io->blocked) f->st->st_size = getlabnum(slt->buf, 16, 10, 10);
				state.record.offset = getlabnum(slt->buf, 51, 2, 10);
			}
		}
		else if (!ap->io->blocked && strneq(slt->buf, "VOL1", 4))
		{
			paxunread(pax, ap, slt->buf, lab);
			if (!(getprologue(ap)))
				return 0;
			goto again;
		}
	} while ((lab = getlabel(pax, ap, f)));
	return 1;
}

static int
slt_getdata(Pax_t* pax, register Archive_t* ap, register File_t* f, int wfd)
{
	register Slt_t*	slt = (Slt_t*)ap->data;
	register off_t	n;
	register off_t	size;
	int		c;
	int		i;
	int		j;
	int		k;
	int		nl;
	off_t		m;
	Sfio_t*		wfp;

	if (wfd < 0)
		wfp = 0;
	else if (!(wfp = sfnew(NiL, NiL, SF_UNBOUND, wfd, SF_WRITE)))
	{
		error(2, "%s: cannot write", f->name);
		return -1;
	}
	ap->io->empty = 0;
	nl = state.record.line;
	size = 0;
	for (;;)
	{
		if (ap->io->blocked)
			n = paxread(pax, ap, state.tmp.buffer, (off_t)0, (off_t)state.buffersize, 0);
		else if ((m = f->st->st_size - size) <= 0)
			n = 0;
		else if (wfp) 
		{
			if (m > state.buffersize)
				m = state.buffersize;
			n = paxread(pax, ap, state.tmp.buffer, (off_t)0, m, 1);
		}
		else
			n = paxread(pax, ap, NiL, (off_t)0, m, 1);
		if (n < 0)
			break;
		if (n == 0)
		{
			k = 1;
			ap->sum--;
			while (getlabel(pax, ap, f))
			{
				if (strneq(slt->buf, "EOV1", 4))
					k = 0;
				else if (!strneq(slt->buf, "EOF", 3) && !strneq(slt->buf, "EOV", 3) && !strneq(slt->buf, "UTL", 3) && ++n >= 16 && !state.keepgoing)
					error(3, "%s: %s: %d invalid %s end of file/volume labels detected", ap->name, f->name, n, ap->format->name);
			}
			if (n)
				error(1, "%s: %s: %d invalid %s end of file/volume labels detected", ap->name, f->name, n, ap->format->name);
			if (k)
			{
				ap->sum++;
				break;
			}
			f->record.section++;
			f->id = strcpy(state.tmp.buffer, f->id);
			f->name = strcpy(state.tmp.buffer + NAME_SIZE + 1, f->name);
			for (;;)
			{
				newio(ap, 0, 0);
				if (getprologue(ap))
				{
					File_t		v;
					struct stat	st;

					v.st = &st;
					if (getheader(ap, &v))
					{
						if (streq(f->id, v.id) && streq(f->name, v.name) && f->record.section == v.record.section)
						{
							f->id = v.id;
							f->name = v.name;
							break;
						}
						error(1, "volume containing %s id %s section %d required", f->name, f->id, f->record.section);
					}
					ap->volume--;
				}
				ap->part--;
			}
			ap->sum++;
			continue;
		}
		if (f->record.format == 'V')
		{
			if ((k = ((unsigned char*)state.tmp.buffer)[0] << 8 | ((unsigned char*)state.tmp.buffer)[1]) != n)
				error(3, "%s: invalid %s V format block descriptor [%d!=%d]", f->name, ap->format->name, k, n);
			i = 4;
		}
		else
			i = 0;
		while (i < n)
		{
			i += state.record.offset;
			if (state.tmp.buffer[i] == '^')
				switch (f->record.format)
				{
				case 'F':
					if (slt->ibm)
						break;
					for (j = i; j < n && state.tmp.buffer[j] == '^'; j++);
					if (j < n)
						break;
					/*FALLTHROUGH*/
				case 'D':
				case 'S':
					i = n;
					continue;
				}

			/*
			 * get record size
			 */

			switch (f->record.format)
			{
			case 'D':
				if (sfsscanf(&state.tmp.buffer[i], "%4d", &k) != 1)
					k = -1;
				j = i + 4;
				break;
			case 'F':
				if (i + state.record.size > n)
					k = n - i;
				else if (state.record.line || state.record.offset)
					k = state.record.size;
				else
					k = n;
				j = i;
				break;
			case 'S':
				switch (state.tmp.buffer[i])
				{
				case '0':
				case '3':
					nl = 1;
					break;
				default:
					nl = 0;
					break;
				}
				if (sfsscanf(&state.tmp.buffer[i + 1], "%4d", &k) != 1)
					k = -1;
				j = i + 5;
				break;
			case 'U':
				k = n;
				j = i;
				break;
			case 'V':
				nl = !(state.tmp.buffer[i + 2] & 01);
				k = ((unsigned char*)state.tmp.buffer)[i] << 8 | ((unsigned char*)state.tmp.buffer)[i + 1];
				j = i + 4;
				break;
			}
			if (k < 0)
			{
				error(2, "invalid %s %c record size", ap->format->name, f->record.format);
				break;
			}
			m = i += k;
			if (slt->mapin)
				ccmapstr(slt->mapin, &state.tmp.buffer[j], m - j);
			if (state.record.line)
				switch (f->record.format)
				{
				case 'F':
				case 'U':
					while (--m >= j && state.tmp.buffer[m] == ' ');
					m++;
					break;
				}
			k = m - j + nl;
			size += k;
			if (wfp)
			{
				if (nl)
				{
					c = state.tmp.buffer[m];
					state.tmp.buffer[m] = '\n';
				}
				if (sfwrite(wfp, &state.tmp.buffer[j], k) != k)
				{
					error(ERROR_SYSTEM|1, "%s: write error", f->name);
					break;
				}
				if (nl)
					state.tmp.buffer[m] = c;
			}
		}
	}
	if (f->st->st_size && f->st->st_size != size)
		error(1, "%s: header size %I*d does not match data size %I*d", f->name, sizeof(f->st->st_size), f->st->st_size, sizeof(size), size);
	f->st->st_size = size;
	if (wfp)
	{
		sfclose(wfp);
		setfile(ap, f);
	}
	if (n < 0)
	{
		error(ERROR_SYSTEM|3, "%s: %s: archive read error", ap->name, f->name);
		return -1;
	}
	return 1;
}

static int
slt_getepilogue(Pax_t* pax, Archive_t* ap)
{
	return 1;
}

static int
slt_backup(Pax_t* pax, Archive_t* ap)
{
#ifdef MTIOCTOP
	struct mtop	mt;

	mt.mt_op = MTBSF;
	mt.mt_count = 1;
	if (ioctl(ap->io->fd, MTIOCTOP, &mt))
	{
		error(ERROR_SYSTEM|3, "%s: %s archive seek MTIO error", ap->name, ap->format->name);
		return -1;
	}
	return 0;
#else
	error(3, "%s: %s archive seek requires MTIO", ap->name, ap->format->name);
	return -1;
#endif
}

static int
slt_putprologue(Pax_t* pax, Archive_t* ap, int append)
{
	register Slt_t*	slt = (Slt_t*)ap->data;

	if (!ap->locked && slt->vol)
	{
		slt->vol = 0;
		ap->locked = 1;
		putlabels(pax, ap, state.record.file, "HDR");
		ap->locked = 0;
	}
	if (ap->format->flags & CONV)
	{
		convert(ap, SECTION_CONTROL, CC_NATIVE, CC_EBCDIC);
		if (!ap->convert[0].on)
			convert(ap, SECTION_DATA, CC_NATIVE, CC_EBCDIC);
	}
#if DEBUG
	if (ap->io->blok)
		ap->io->blocked = 1;
	else
#endif
	ap->io->blocked = !ap->io->unblocked;
	if (!slt->owner[0])
	{
		strncpy(slt->owner, fmtuid(getuid()), sizeof(slt->owner) - 1);
		slt->owner[sizeof(slt->owner) - 1] = 0;
	}
	strupper(slt->owner);
	if (!state.volume[0])
	{
		strncpy(state.volume, slt->owner, sizeof(state.volume) - 1);
		state.volume[sizeof(state.volume) - 1] = 0;
	}
	strupper(state.volume);
	strncpy(slt->format, SLT_ID, sizeof(slt->format) - 1);
	strncpy(slt->implementation, IMPLEMENTATION, sizeof(slt->implementation) - 1);
	if (ap->format->flags & CONV)
		sfsprintf(slt->standards, sizeof(slt->standards), "%-5.5s%-5.5s%-5.5s%-4.4s", "ATT", "1", "EBCDIC", "1979");
	else
		sfsprintf(slt->standards, sizeof(slt->standards), "%-5.5s%-5.5s%-5.5s%-4.4s", "ISO", "646", "IRV", "1990");
	sfsprintf(slt->buf, sizeof(slt->buf), "VOL1%-6.6s              %-6.6s%-7.7s%-14.14s                            4", state.volume, slt->format, slt->implementation, slt->owner);
	paxwrite(pax, ap, slt->buf, HDR_SIZE);
	sfsprintf(slt->buf, sizeof(slt->buf), "VOL2%-19.19s                                                         ", slt->standards);
	paxwrite(pax, ap, slt->buf, HDR_SIZE);
	if (ap->delta && !(ap->delta->format->flags & PSEUDO))
	{
		sfsprintf(slt->buf, sizeof(slt->buf), "UVL1 %-6.6s%c%-6.6s%010ld%010ld                                         ", ID, ap->delta->compress ? TYPE_COMPRESS : TYPE_DELTA, ((Compress_format_t*)ap->delta->format)->variant, state.operation == OUT ? (long)ap->size : (long)0, state.operation == OUT ? ap->checksum : 0L);
		paxwrite(pax, ap, slt->buf, HDR_SIZE);
	}
	return 1;
}

static int
slt_putheader(Pax_t* pax, Archive_t* ap, File_t* f)
{
	if (state.complete)
		complete(ap, f, 4 * HDR_SIZE);
	putlabels(pax, ap, f, "HDR");
	return 1;
}

static int
recordout(Pax_t* pax, Archive_t* ap, File_t* f, Sfio_t* fp)
{
	register Slt_t*	slt = (Slt_t*)ap->data;
	register int	c;
	register char*	p;
	register char*	recdat;
	register char*	blkdat;
	char*		rec;
	char*		blk;
	int		span;

	int		count = 0;
	int		partial = 0;
	int		truncated = 0;

	static char	span_out[] = "0132";

	if (!fp)
		error(3, "record output from buffer not supported");
	ap->record = f;
	f->record.blocks = 0;
	span = 0;
	blk = state.tmp.buffer;

	/*
	 * file loop
	 */

	for (;;)
	{
		p = blk;
		switch (state.record.format)
		{
		case 'V':
			p += 4;
			break;
		}
		blkdat = p;

		/*
		 * block loop
		 */

		for (;;)
		{
			rec = p;
			switch (state.record.format)
			{
			case 'D':
			case 'V':
				p += 4;
				break;
			case 'S':
				p += 5;
				break;
			}
			recdat = p;

			/*
			 * check for partial record from previous block
			 */

			if (partial)
			{
				memcpy(recdat, f->record.partial, partial);
				p += partial;
				partial = 0;
			}

			/*
			 * record loop
			 */

			span &= 01;
			span <<= 1;
			for (;;)
			{
				if (p >= &rec[state.record.size] && state.record.size)
				{
					if (state.record.line)
					{
						truncated++;
						while ((c = sfgetc(fp)) != EOF && c != '\n');
					}
					break;
				}
				else if (p >= &blk[state.blocksize])
				{
					if (state.record.format == 'S' || state.record.format == 'V')
					{
						if (p > recdat)
						{
							span |= 01;
							break;
						}
					}
					else if (partial = p - recdat)
					{
						/*
						 * save partial record for next block
						 */

						if (!f->record.partial && !(f->record.partial = newof(0, char, state.blocksize, 0)))
							nospace();
						memcpy(f->record.partial, recdat, partial);
					}
					p = rec;
					goto eob;
				}
				else if ((c = sfgetc(fp)) == EOF)
				{
					if (p == recdat)
					{
						if (rec == blkdat) goto eof;
						p = rec;
						goto eob;
					}
					break;
				}
				else if (c == '\n' && state.record.line)
					break;
				else
					*p++ = c;
			}
			switch (state.record.format)
			{
			case 'D':
				c = recdat[0];
				sfsprintf(rec, 4, "%04d", p - rec);
				recdat[0] = c;
				break;
			case 'F':
				if (c != EOF || state.record.pad)
				{
					memset(p, ' ', state.record.size - (p - rec));
					p = rec + state.record.size;
				}
				break;
			case 'S':
				c = recdat[0];
				sfsprintf(rec, 4, "%c%04d", span_out[span], p - rec);
				recdat[0] = c;
				break;
			case 'U':
				if (p == recdat) *p++ = ' ';
				break;
			case 'V':
				rec[0] = ((p - rec) >> 8) & 0xff;
				rec[1] = (p - rec) & 0xff;
				rec[2] = span;
				rec[3] = 0;
				break;
			}
			if (slt->mapout)
				ccmapstr(slt->mapout, recdat, p - recdat);
			count++;
			if (p >= &blk[state.blocksize] || state.record.format == 'U')
				break;
		}
	eob:
		switch (state.record.format)
		{
		case 'D':
		case 'S':
			if (state.record.pad)
			{
				memset(p, '^', state.blocksize - (p - blk));
				p = blk + state.blocksize;
			}
			break;
		case 'V':
			blk[0] = ((p - blk) >> 8) & 0xff;
			blk[1] = (p - blk) & 0xff;
			blk[2] = 0;
			blk[3] = 0;
			break;
		}
		paxwrite(pax, ap, blk, p - blk);
		f->record.blocks++;
	}
 eof:
	ap->record = 0;
	if (truncated)
		error(1, "%s: %d out of %d record%s truncated", f->name, truncated, count, count == 1 ? "" : "s");
	return 0;
}

static int
slt_putdata(Pax_t* pax, Archive_t* ap, File_t* f, int rfd)
{
	register size_t		m;
	register ssize_t	n;
	register off_t		c;
	int			r;
	Buffer_t*		bp;
	Sfio_t*			rfp;

	if (ap->io->blocked)
		return 0;
	r = 1;
	if (f->st->st_size > 0)
	{
		if (state.record.format == 'F' && !state.record.line)
		{
			/*
			 * this is faster than recordout()
			 */

			ap->record = f;
			c = f->st->st_size;
			while (c > 0)
			{
				n = m = c > state.record.size ? state.record.size : c;

				/*
				 * NOTE: we expect that all but the last
				 *	 read returns state.record.size
				 *	 if not the the intermediate short
				 *	 reads are filled with 0's
				 */

				if (!r)
				{
					if (rfd >= 0)
						n = read(rfd, state.tmp.buffer, m);
					else if (bp = getbuffer(rfd))
					{
						memcpy(ap->io->next, bp->next, m);
						bp->next += m;
					}
					else if (paxread(pax, f->ap, state.tmp.buffer, (off_t)0, (off_t)m, 1) <= 0)
						n = -1;
				}
				if (n <= 0)
				{
					if (n)
						error(ERROR_SYSTEM|2, "%s: read error", f->path);
					else
						error(2, "%s: file size changed", f->path);
					memzero(state.tmp.buffer, state.record.size);
					r = -1;
				}
				else
				{
					c -= n;
					if (n < state.record.size && (c > 0 || state.record.pad))
					{
						memzero(state.tmp.buffer + n, state.record.size - n);
						n = state.record.size;
					}
					paxwrite(pax, ap, state.tmp.buffer, n);
				}
			}
			ap->record = 0;
			if (rfd >= 0)
				close(rfd);
		}
		else if (rfd < 0)
			recordout(pax, ap, f, NiL);
		else if (!(rfp = sfnew(NiL, NiL, SF_UNBOUND, rfd, SF_READ)))
		{
			error(1, "%s: cannot read", f->path);
			close(rfd);
		}
		else
		{
			recordout(pax, ap, f, rfp);
			sfclose(rfp);
		}
	}
	return r;
}

static int
slt_puttrailer(Pax_t* pax, Archive_t* ap, File_t* f)
{
	putlabels(pax, ap, f, "EOF");
	return 0;
}

static off_t
slt_putepilogue(Pax_t* pax, Archive_t* ap)
{
	register Slt_t*	slt = (Slt_t*)ap->data;

	if (!ap->locked)
	{
		ap->locked = 1;
		putlabels(pax, ap, state.record.file, "EOV");
		ap->locked = 0;
		slt->vol = 1;
	}
	paxwrite(pax, ap, slt->buf, 0);
	paxwrite(pax, ap, slt->buf, 0);
	return ap->io->count;
}

static int
slt_validate(Pax_t* pax, Archive_t* ap, register File_t* f)
{
	register Slt_t*	slt = (Slt_t*)ap->data;
	register char*	s;

	if (f->type != X_IFREG)
	{
		error(2, "%s: only regular files copied in %s format", f->path, ap->format->name);
		return 0;
	}
	if (s = strrchr(f->name, '/'))
	{
		s++;
		error(1, "%s: file name stripped to %s", f->name, s);
	}
	else
		s = f->name;
	if (strlen(s) > sizeof(slt->id) - 1)
	{
		error(2, "%s: file name too long", f->name);
		return 0;
	}
	f->id = strupper(strcpy(slt->id, s));
	return 1;
}

Format_t	pax_slt_format =
{
	"ansi",
	"slt",
	"ANSI standard label tape; for tape devices only",
	ANSI,
	ARCHIVE|NOHARDLINKS|IN|OUT,
	4,
	4,
	0,
	pax_slt_next,
	0,
	slt_done,
	slt_getprologue,
	0,
	slt_getdata,
	0,
	slt_getepilogue,
	slt_putprologue,
	slt_putheader,
	slt_putdata,
	slt_puttrailer,
	slt_putepilogue,
	0,
	slt_backup,
	0,
	slt_validate
};

static int
ibm_getprologue(Pax_t* pax, Format_t* fp, register Archive_t* ap, File_t* f, unsigned char* buf, size_t size)
{
	register Slt_t*	slt;
	int		n;

	if ((n = slt_getprologue(pax, fp, ap, f, buf, size)) > 0 && state.record.charset)
	{
		slt = (Slt_t*)ap->data;
		slt->mapin = state.map.e2n;
		slt->mapout = state.map.n2e;
	}
	return n;
}

Format_t	pax_ibm_format =
{
	"ibm",
	"elt",
	"EBCDIC standard label tape; for tape devices only",
	IBM,
	ARCHIVE|CONV|NOHARDLINKS|IN|OUT,
	4,
	4,
	0,
	PAXNEXT(ibm),
	0,
	slt_done,
	ibm_getprologue,
	0,
	slt_getdata,
	0,
	slt_getepilogue,
	slt_putprologue,
	slt_putheader,
	slt_putdata,
	slt_puttrailer,
	slt_putepilogue,
	0,
	slt_backup,
	0,
	slt_validate
};

PAXLIB(ibm)