dd.c

/***********************************************************************
*                                                                      *
*               This software is part of the ast package               *
*          Copyright (c) 1989-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 Research
 *
 * posix dd
 */

static const char usage1[] =
"[-1p0?\n@(#)$Id: dd (AT&T Research) 2011-04-21 $\n]"
USAGE_LICENSE
"[+NAME?dd - convert and copy a file]"
"[+DESCRIPTION?\bdd\b copies an input file to an output file with optional"
"	conversions. The standard input and output are used by default."
"	Input and output block sizes can be specified to take advantage of"
"	physical io limitations. Options are of the form \aname=value\a"
"	and may be specified with 0, 1, or 2 leading `-' characters.]"
"[+?A \anumber\a argument may be a scaled number with optional trailing"
" multipliers of the form `* \anumber\a', `x \anumber\a' or `X \anumber\a'."
" Scale suffixes may be one of:]{"
"	[+b|B?512]"
"	[+k|K?1000]"
"	[+ki|Ki?1024]"
"	[+m|M?1000000]"
"	[+mi|Mi?1048576]"
"	[+g|G?1000000000]"
"	[+gi|Gi?1073741824]"
"	[+t|T?1000000000000]"
"	[+ti|Ti?1099511627776]"
"	[+p|P?1000000000000000]"
"	[+pi|Pi?1125899906842624]"
"	[+e|E?1000000000000000000]"
"	[+ei|Ei?1152921504606846976]"
"}"
;

static const char usage2[] =
"[+SEE ALSO?\bcp\b(1), \biconv\b(1), \bpax\b(1), \btr\b(1), \bseek\b(2)]"
;

#include <ast.h>
#include <ctype.h>
#include <ccode.h>
#include <error.h>
#include <iconv.h>
#include <ls.h>
#include <sig.h>
#include <swap.h>

#define CODE		0
#define CONV		1
#define FLAG		2
#define NUMBER		3
#define STRING		4

#define A2E		(1<<0)
#define A2I		(1<<1)
#define A2N		(1<<2)
#define A2O		(1<<3)
#define BLOCK		(1<<4)
#define E2A		(1<<5)
#define IGNERROR	(1<<6)
#define I2A		(1<<7)
#define ISPECIAL	(1<<8)
#define LCASE		(1<<9)
#define N2A		(1<<10)
#define NOERROR		(1<<11)
#define NOTRUNC		(1<<12)
#define O2A		(1<<13)
#define OSPECIAL	(1<<14)
#define SILENT		(1L<<15)
#define SWAP		(1L<<16)
#define SYNC		(1L<<17)
#define UCASE		(1L<<18)
#define UNBLOCK		(1L<<19)

#define BS		512

#define operand_begin	bs
#define operand_end	to

#define conv_begin	a2e
#define conv_end	unblock

typedef struct
{
	const char*	name;
	const char*	help;
} Desc_t;

typedef struct
{
	char*		string;
	Sflong_t	number;
} Value_t;

typedef struct
{
	const char*	name;
	long		type;
	const char*	help;
	Value_t		value;
} Operand_t;

typedef struct
{
	Sfio_t*		fp;
	Sfulong_t	complete;
	Sfulong_t	partial;
	Sfulong_t	truncated;
	Sfulong_t	remains;
	int		special;
} Io_t;

typedef struct
{
	Operand_t	bs;
	Operand_t	cbs;
	Operand_t	conv;
	Operand_t	count;
	Operand_t	from;
	Operand_t	ibs;
	Operand_t	ifn;
	Operand_t	iseek;
	Operand_t	obs;
	Operand_t	ofn;
	Operand_t	oseek;
	Operand_t	silent;
	Operand_t	skip;
	Operand_t	swap;
	Operand_t	to;

	Operand_t	a2e;
	Operand_t	a2i;
	Operand_t	a2n;
	Operand_t	a2o;
	Operand_t	ascii;
	Operand_t	block;
	Operand_t	e2a;
	Operand_t	ebcdic;
	Operand_t	i2a;
	Operand_t	ibm;
	Operand_t	ifix;
	Operand_t	ignerror;
	Operand_t	lcase;
	Operand_t	n2a;
	Operand_t	noerror;
	Operand_t	notrunc;
	Operand_t	o2a;
	Operand_t	ofix;
	Operand_t	swab;
	Operand_t	sync;
	Operand_t	ucase;
	Operand_t	unblock;

	Iconv_disc_t	iconv;
	Io_t		in;
	Io_t		out;
	char*		buffer;
	int		pad;
	iconv_t		cvt;
	Sfio_t*		tmp;
} State_t;

static State_t		state =
{
	{
		"bs",
		NUMBER,
		"Input and output block size.",
	},
	{
		"cbs",
		NUMBER,
		"Conversion buffer size (logical record length)."
	},
	{
		"conv",
		CONV,
		"Convert input.",
	},
	{
		"count",
		NUMBER,
		"Copy only \anumber\a input blocks.",
	},
	{
		"from",
		CODE,
		"Convert from \acodeset\a to the \bto\b=\acodeset\a"
		" or the local default. \acodeset\a names are matched"
		" by left-anchored case-insensitive \bksh\b(1) patterns.",
	},
	{
		"ibs",
		NUMBER,
		"Input block size.",
		0, BS,
	},
	{
		"if",
		STRING,
		"The input file name; standard input is the default.",
	},
	{
		"iseek",
		NUMBER,
		"Seek \anumber\a blocks from the beginning of the input"
		" file before copying.",
	},
	{
		"obs",
		NUMBER,
		"Output block size.",
		0, BS,
	},
	{
		"of",
		STRING,
		"The output file name; standard output is the default.",
	},
	{
		"oseek|seek",
		NUMBER,
		"Seek \anumber\a blocks from the beginning of the output"
		" file before copying.",
	},
	{
		"silent",
		FLAG,
		"\bsilent\b does not print the total number of io blocks"
		" on exit.",
	},
	{
		"skip",
		NUMBER,
		"Skip \anumber\a blocks before reading.  Seek is used if"
		" possible, otherwise the blocks are read and discarded.",
	},
	{
		"swap",
		NUMBER,
		"Swap bytes acording to the inclusive or of: 1-byte,"
		" 2-short, 4-long, 8-quad, etc.",
	},
	{
		"to",
		CODE,
		"Convert to \acodeset\a from the \bfrom\b=\acodeset\a"
		" or the local default. See \bfrom\b for \acodeset\a names.",
	},

	{
		"a2e",
		A2E,
		"ascii to ebcdic",
	},
	{
		"a2i",
		A2I,
		"ascii to ibm",
	},
	{
		"a2n",
		A2N,
		"ascii to native",
	},
	{
		"a2o",
		A2O,
		"ascii to open edition ebcdic",
	},
	{
		"ascii",
		E2A,
		"ebcdic to ascii",
	},
	{
		"block",
		BLOCK,
		"newline-terminated ascii to fixed record length",
	},
	{
		"e2a",
		E2A,
		"ebcdic to ascii",
	},
	{
		"ebcdic",
		A2E,
		"equivalent to \ba2e\b",
	},
	{
		"i2a",
		I2A,
		"ibm to ascii",
	},
	{
		"ibm",
		A2I,
		"ascii to ibm ebcdic",
	},
	{
		"ignerror",
		IGNERROR,
		"continue processing after errors",
	},
	{
		"ispecial",
		ISPECIAL,
		"currently ignored",
	},
	{
		"lcase",
		LCASE,
		"to lower case",
	},
	{
		"n2a",
		N2A,
		"native to ascii",
	},
	{
		"noerror",
		NOERROR,
		"stop processing only after 5 consecutive errors",
	},
	{
		"notrunc",
		NOTRUNC,
		"do not truncate pre-existing output files",
	},
	{
		"o2a",
		O2A,
		"open edition ibm to ascii",
	},
	{
		"ospecial",
		OSPECIAL,
		"currently ignored"
	},
	{
		"swab",
		SWAP,
		"swap byte pairs",
	},
	{
		"sync",
		SYNC,
		"Pad each input block to \bibs\b. Pad with spaces if"
		" \bconv=block\b or \bconv=unblock\b, otherwise pad"
		" with nulls.",
	},
	{
		"ucase",
		UCASE,
		"to upper case",
	},
	{
		"unblock",
		UNBLOCK,
		"fixed-length records to newline-terminated records",
	},
};

static Desc_t		desc[] =
{
	"codeset",	"",
	"conversion",	"",
	0,		0,
	"number",	0,
	"file",		0,
};

static void
fini(int code)
{
	if (state.in.fp != sfstdin)
		sfclose(state.in.fp);
	if (state.out.fp == sfstdout)
		sfsync(state.out.fp);
	else
		sfclose(state.out.fp);
	if (!state.silent.value.number)
	{
		sfprintf(sfstderr, "%I*u+%I*u records in\n", sizeof(Sfulong_t), (Sfulong_t)state.in.complete, sizeof(Sfulong_t), (Sfulong_t)(state.in.partial + (state.in.remains > 0)));
		sfprintf(sfstderr, "%I*u+%I*u records out\n", sizeof(Sfulong_t), (Sfulong_t)state.out.complete, sizeof(Sfulong_t), (Sfulong_t)(state.out.partial + (state.out.remains > 0)));
		if (state.in.truncated)
			sfprintf(sfstderr, "%I*u truncated record%s\n", sizeof(Sfulong_t), (Sfulong_t)state.in.truncated, state.in.truncated == 1 ? "" : "s");
	}
	exit(code);
}

static void
interrupt(int sig)
{
	signal(sig, SIG_DFL);
	fini(EXIT_TERM(sig));
}

static ssize_t
output(Sfio_t* sp, const Void_t* buf, size_t n, Sfdisc_t* disc)
{
	register ssize_t	r;
	register size_t		x;

	if ((r = sfwr(sp, buf, n, disc)) > 0)
	{
		x = r / state.obs.value.number;
		state.out.complete += x;
		if (x = r - x * state.obs.value.number)
		{
			if (state.out.special)
				state.out.partial++;
			else if ((state.out.remains += x) >= state.obs.value.number)
			{
				state.out.remains -= state.obs.value.number;
				state.out.complete++;
			}
		}
	}
	return r;
}

int
main(int argc, char** argv)
{
	register char*		s;
	register char*		v;
	register char*		b;
	register Operand_t*	op;
	register Operand_t*	vp;
	register int		f;
	char*			usage;
	char*			e;
	int			i;
	char*			cb;
	size_t			cc;
	Sfio_t*			sp;
	Sflong_t		c;
	Sflong_t		d;
	Sflong_t		m;
	Sflong_t		n;
	Sflong_t		r;
	Sflong_t		partial;
	struct stat		st;
	Sfdisc_t		disc;

	setlocale(LC_ALL, "");
	error_info.id = "dd";
	iconv_init(&state.iconv, errorf);
	state.from.value.string = state.to.value.string = "";
	if (!(sp = sfstropen()))
		error(ERROR_SYSTEM|3, "out of space");
	sfputr(sp, usage1, '\n');
	for (op = &state.operand_begin; op <= &state.operand_end; op++)
	{
		sfprintf(sp, "[%d:%s?%s", op - &state.operand_begin + 10, op->name, op->help);
		i = ']';
		if (desc[op->type].name)
		{
			if (desc[op->type].help)
			{
				if (*desc[op->type].help)
					sfprintf(sp, " %s", desc[op->type].help);
				else
					sfprintf(sp, " \a%s\a may be one of:", desc[op->type].name);
				sfprintf(sp, "]:[%s", desc[op->type].name);
				desc[op->type].help = 0;
				if (op->type == CONV)
				{
					i = '}';
					sfprintf(sp, "]{\n");
					for (vp = &state.conv_begin; vp <= &state.conv_end; vp++)
						sfprintf(sp, "\t[+%s?%s]\n", vp->name, vp->help);
				}
				else if (op->type == CODE)
				{
					register iconv_list_t*	ic;

					sfputc(sp, ']');
					sfputc(sp, '{');
					for (ic = iconv_list(NiL); ic; ic = iconv_list(ic))
					{
						sfputc(sp, '[');
						sfputc(sp, '+');
						sfputc(sp, '\b');
						optesc(sp, ic->match, '?');
						sfputc(sp, '?');
						optesc(sp, ic->desc, 0);
						sfputc(sp, ']');
						sfputc(sp, '\n');
					}
					i = '}';
				}
			}
			else
				sfprintf(sp, "]:[%s", desc[op->type].name);
		}
		sfputc(sp, i);
		sfputc(sp, '\n');
	}
	sfputr(sp, usage2, '\n');
	if (!(usage = sfstruse(sp)))
		error(ERROR_SYSTEM|3, "out of space");
	if (signal(SIGINT, SIG_IGN) != SIG_IGN)
		signal(SIGINT, interrupt);
	while (f = optget(argv, usage))
	{
		
		if (f > 0)
		{
			if (f == '?')
				error(ERROR_USAGE|4, "%s", opt_info.arg);
			if (f = ':')
				error(2, "%s", opt_info.arg);
			continue;
		}
		op = &state.operand_begin - (f + 10);
		v = opt_info.arg;
		switch (op->type)
		{
		case CODE:
		case STRING:
			op->value.string = v;
			break;
		case CONV:
			do
			{
				if (e = strchr(v, ','))
					*e = 0;
				vp = (Operand_t*)strsearch(&state.conv_begin, &state.conv_end - &state.conv_begin + 1, sizeof(Operand_t), stracmp, v, NiL);
				if (e)
					*e++ = ',';
				if (!vp)
					error(3, "%s: unknown %s value", v, op->name);
				op->value.number |= vp->type;
			} while (v = e);
			break;
		case FLAG:
			op->value.number = opt_info.number;
			break;
		case NUMBER:
			c = 0;
			for (;;)
			{
				n = strtonll(v, &e, NiL, 0);
				if (n < 0)
					error(3, "%s: %s must be >= 0", v, op->name);
				if (!c)
				{
					c = 1;
					op->value.number = n;
				}
				else
					op->value.number *= n;
				for (v = e; isspace(*v); v++);
				if (*v != 'x' && *v != 'X' && *v != '*')
					break;
				while (isspace(*++v));
				if (!*v)
				{
					v = e;
					break;
				}
			}
			if (*v)
				error(3, "%s: %s: invalid numeric expression", op->name, opt_info.arg);
			break;
		}
	}
	if (error_info.errors)
		error(ERROR_USAGE|4, "%s", optusage(NiL));
	error_info.exit = fini;
	switch ((long)(state.conv.value.number & (A2E|A2I|A2N|A2O|E2A|I2A|N2A|O2A)))
	{
	case 0:
		break;
	case A2E:
		state.from.value.string = "ascii";
		state.to.value.string = "ebcdic-e";
		break;
	case A2I:
		state.from.value.string = "ascii";
		state.to.value.string = "ebcdic-i";
		break;
	case A2N:
		state.from.value.string = "ascii";
		state.to.value.string = "";
		break;
	case A2O:
		state.from.value.string = "ascii";
		state.to.value.string = "ebcdic-o";
		break;
	case E2A:
		state.from.value.string = "ebcdic-e";
		state.to.value.string = "ascii";
		break;
	case I2A:
		state.from.value.string = "ebcdic-i";
		state.to.value.string = "ascii";
		break;
	case N2A:
		state.from.value.string = "";
		state.to.value.string = "ascii";
		break;
	case O2A:
		state.from.value.string = "ebcdic-o";
		state.to.value.string = "ascii";
		break;
	default:
		error(3, "only one of %s={%s,%s,%s} may be specified", state.conv.name, state.ascii.value.string, state.ebcdic.value.string, state.ibm.value.string);
	}
	if (streq(state.from.value.string, state.to.value.string))
		state.cvt = (iconv_t)(-1);
	else  if ((state.cvt = iconv_open(state.to.value.string, state.from.value.string)) == (iconv_t)(-1))
		error(3, "cannot convert from %s to %s", *state.from.value.string ? state.from.value.string : ccmapname(CC_NATIVE), *state.to.value.string ? state.to.value.string : ccmapname(CC_NATIVE));
	else if (state.cvt == (iconv_t)(0)) /* ast iconv identity */
		state.cvt = (iconv_t)(-1);
	else if (!(state.tmp = sfstropen()))
		error(ERROR_SYSTEM|3, "out of space");
	if ((state.conv.value.number & (BLOCK|UNBLOCK)) == (BLOCK|UNBLOCK))
		error(3, "only one of %s=%s and %s=%s may be specified", state.conv.name, state.block.value.string, state.conv.name, state.unblock.value.string);
	if ((state.conv.value.number & (SYNC|UNBLOCK)) == (SYNC|UNBLOCK))
	{
		state.conv.value.number &= ~SYNC;
		error(1, "%s=%s ignored for %s=%s", state.conv.name, state.sync.value.string, state.conv.name, state.unblock.value.string);
	}
	if (state.conv.value.number & SWAP)
		state.swap.value.number = 1;
	else if (state.swap.value.number)
		state.conv.value.number |= SWAP;
	if (state.oseek.value.number && (state.conv.value.number & NOTRUNC))
	{
		state.oseek.value.number = 0;
		error(1, "%s ignored for %s=%s", state.oseek.name, state.conv.name, state.notrunc.value.string);
	}
	if ((state.conv.value.number & (LCASE|UCASE)) == (LCASE|UCASE))
		error(3, "only one of %s=%s and %s=%s may be specified", state.conv.name, state.lcase.value.string, state.conv.name, state.ucase.value.string);
	if (state.conv.value.number & (BLOCK|UNBLOCK))
	{
		if (!state.cbs.value.number)
			error(3, "%s must be specified for %s=%s", state.cbs.name, state.conv.name, (state.conv.value.number & BLOCK) ? state.block.value.string : state.unblock.value.string);
		state.pad = ' ';
		if (state.conv.value.number & UNBLOCK)
		{
			state.ibs.value.number = state.cbs.value.number;
			if (state.bs.value.number)
			{
				state.obs.value.number = state.bs.value.number;
				state.bs.value.number = 0;
			}
		}
	}
	else if (state.cbs.value.number)
	{
		state.cbs.value.number = 0;
		error(1, "%s ignored", state.cbs.name);
	}
	if (n = state.bs.value.number)
		state.ibs.value.number = state.obs.value.number = n;
	if (n = state.iseek.value.number)
	{
		if (state.skip.value.number)
			error(3, "only on of %s and %s may be specified", state.skip.name, state.iseek.name);
		if (!state.ibs.value.number)
			error(3, "%s requires %s or %s", state.iseek.name, state.bs.name, state.ibs.name);
		state.skip.value.number = n;
	}
	if (state.oseek.value.number && !state.obs.value.number)
		error(3, "%s requires %s or %s", state.oseek.name, state.bs.name, state.obs.name);
	if (!(s = state.ifn.value.string))
	{
		state.ifn.value.string = "/dev/stdin";
		state.in.fp = sfstdin;
#if O_NONBLOCK
		if ((i = fcntl(sffileno(sfstdin), F_GETFL)) > 0 && (i & O_NONBLOCK))
			fcntl(sffileno(sfstdin), F_SETFL, i & ~O_NONBLOCK);
#endif
	}
	else if (!(state.in.fp = sfopen(NiL, s, "rb")))
		error(ERROR_SYSTEM|3, "%s: cannot read", s);
	if (!(s = state.ofn.value.string))
	{
		state.ofn.value.string = "/dev/stdout";
		state.out.fp = sfstdout;
	}
	else if (!(state.out.fp = sfopen(NiL, s, (state.conv.value.number & NOTRUNC) ? "a+b" : state.oseek.value.number ? "w+b" : "wb")))
		error(ERROR_SYSTEM|3, "%s: cannot write", s);
	if ((state.conv.value.number & ISPECIAL) || fstat(sffileno(state.in.fp), &st) || !S_ISREG(st.st_mode))
		state.in.special = 1;
	if (state.in.special && !(state.conv.value.number & BLOCK) && (n = state.ibs.value.number))
		sfsetbuf(state.in.fp, NiL, n);
	if ((state.conv.value.number & OSPECIAL) || fstat(sffileno(state.out.fp), &st) || !S_ISREG(st.st_mode))
		state.out.special = 1;
	if (state.out.special && !(state.conv.value.number & UNBLOCK) && (n = state.obs.value.number))
		sfsetbuf(state.out.fp, NiL, n);
	state.bs.value.number = state.ibs.value.number;
	if (state.obs.value.number > state.bs.value.number)
		state.bs.value.number = state.obs.value.number;
	if (state.cbs.value.number > state.bs.value.number)
		state.bs.value.number = state.cbs.value.number;
	if (!(state.buffer = newof(0, char, state.bs.value.number, 0)))
		error(ERROR_SYSTEM|3, "out of space");
	if (n = state.skip.value.number)
	{
		if (!state.ibs.value.number)
			error(3, "%s requires %s or %s", state.skip.name, state.bs.name, state.ibs.name);
		n *= state.ibs.value.number;
		if (sfseek(state.in.fp, n, SEEK_SET) != n)
		{
			do
			{
				if (!sfreserve(state.in.fp, state.in.special && state.ibs.value.number < n ? state.ibs.value.number : n, 0))
				{
					if (sfvalue(state.in.fp) > 0)
						error(ERROR_SYSTEM|3, "%s: seek read error", state.ifn.value.string);
					break;
				}
			} while ((n -= sfvalue(state.in.fp)) > 0);
			if (n > 0)
				error(3, "%s: cannot seek past end of file", state.ifn.value.string);
		}
	}
	if (n = state.oseek.value.number)
	{
		n *= state.obs.value.number;
		if (sfseek(state.out.fp, n, SEEK_SET) != n)
		{
			do
			{
				if (!sfreserve(state.out.fp, state.out.special && state.obs.value.number < n ? state.obs.value.number : n, 0))
				{
					if (sfvalue(state.out.fp) > 0)
						error(ERROR_SYSTEM|3, "%s: seek read error", state.ofn.value.string);
					break;
				}
			} while ((n -= sfvalue(state.out.fp)) > 0);
			while (n > 0 && (c = sfwrite(state.out.fp, state.buffer, state.out.special && state.obs.value.number < n ? state.obs.value.number : n)) > 0)
				n -= c;
			if (c < 0)
				error(ERROR_SYSTEM|3, "%s: seek 0 fill write error", state.ofn.value.string);
		}
	}
	if (state.silent.value.number)
		state.iconv.errorf = 0;
	if (state.conv.value.number & NOERROR)
	{
		state.iconv.errorf = 0;
		if (state.conv.value.number & SYNC)
			state.iconv.fill = 0;
		else
			state.iconv.flags |= ICONV_OMIT;
	}
	else
		state.iconv.flags |= ICONV_FATAL;
	memset(&disc, 0, sizeof(disc));
	disc.writef = output;
	sfdisc(state.out.fp, &disc);
	if (!state.obs.value.number)
		state.obs.value.number = BS;
	if (state.conv.value.number & BLOCK)
	{
		c = state.cbs.value.number;
		memset(state.buffer, state.pad, c);
		while ((s = sfgetr(state.in.fp, '\n', 0)) || (s = sfgetr(state.in.fp, '\n', -1)))
		{
			state.in.complete++;
			n = sfvalue(state.in.fp) - 1;
			if (n > c)
			{
				if (sfwrite(state.out.fp, s, c) != c)
					error(ERROR_SYSTEM|3, "%s: write error", state.ofn.value.string);
				state.in.truncated++;
			}
			else
			{
				if (sfwrite(state.out.fp, s, n) != n)
					error(ERROR_SYSTEM|3, "%s: write error", state.ofn.value.string);
				n = c - n;
				if (sfwrite(state.out.fp, state.buffer, n) != n)
					error(ERROR_SYSTEM|3, "%s: write error", state.ofn.value.string);
			}
		}
	}
	else
	{
		if (!(c = state.ibs.value.number))
			c = BS;
		f = state.conv.value.number;
		if (!state.in.special)
			f &= ~NOERROR;
		if (!(r = state.count.value.number))
			r = -1;
		partial = 0;
		while (state.in.complete != r)
		{
			b = sfreserve(state.in.fp, SF_UNBOUND, 0);
			m = sfvalue(state.in.fp);
			if (!b)
			{
				if (!m)
					break;
				error(ERROR_SYSTEM|((f & NOERROR) ? 2 : 3), "%s: read error", state.ifn.value.string);
				memset(b = state.buffer, state.pad, m = c);
			}
			while (state.in.complete != r)
			{
				s = b;

				/*
				 * m is the amount actually read
				 * c is the specified (or default) block size
				 */

				if (m >= c)
				{
					/*
					 * the read gave us at least a complete block
					 */

					state.in.complete++;

					/*
					 * set n (the # of bytes to write) to the block size
					 */

					n = c;

					/*
					 * if we've hit the block count, check to see if the
					 * previous write was in the middle of an output block, and
					 * adjust the # of bytes to write accordingly; don't bother
					 * adjusting the remains, since we're done
					 */

					if (state.in.complete >= r && (state.in.remains + n) >= c)
						n -= state.in.remains;
				}
				else
				{
					/*
					 * read gave us less than a complete block
					 */

					n = m;
					if (state.in.special)
						state.in.partial++;

					/*
					 * see if writing the amount read in will cross an (output) block boundry
					 */

					if ((state.in.remains + n) >= c)
					{
						state.in.complete++;

						/*
						 * see above comment on block count, but also adjust
						 * partial block byte count (remains)
						 */

						if (state.in.complete >= r)
						{
							n = c - state.in.remains;
							state.in.remains += m - c;
						}
						else
						{
							partial++;
							state.in.remains += m - c;
						}
					}
					else
						state.in.remains += n;
					if (f & SYNC)
					{
						s = memcpy(state.buffer, s, n);
						memset(s + n, state.pad, c - n);
						n = c;
					}
				}
				if (f & SWAP)
					swapmem(state.swap.value.number, s, s, n);
				if (state.cvt != (iconv_t)(-1))
				{
					cb = s;
					cc = n;
					state.iconv.errors = 0;
					if ((d = iconv_write(state.cvt, state.tmp, &cb, &cc, &state.iconv)) < 0)
						d = 0;
					if (!(s = sfstruse(state.tmp)))
						error(ERROR_SYSTEM|3, "out of space");
					m -= n - d;
					if (state.iconv.errors && (state.iconv.flags & ICONV_FATAL))
					{
						m -= n;
						n = 0;
					}
				}
				switch (f & (LCASE|UCASE))
				{
				case LCASE:
					for (v = (e = s) + n; s < v; s++)
						if (isupper(*s))
							*s = tolower(*s);
					s = e;
					break;
				case UCASE:
					for (v = (e = s) + n; s < v; s++)
						if (islower(*s))
							*s = toupper(*s);
					s = e;
					break;
				}
				if (f & UNBLOCK)
				{
					for (v = s + n; v > s && *(v - 1) == ' '; v--);
					if (sfwrite(state.out.fp, s, v - s) != (v - s) || sfputc(state.out.fp, '\n') != '\n')
						error(ERROR_SYSTEM|3, "%s: write error", state.ofn.value.string);
				}
				else if (sfwrite(state.out.fp, s, n) != n)
					error(ERROR_SYSTEM|3, "%s: write error", state.ofn.value.string);
				if ((m -= n) <= 0)
					break;
				b += n;
			}
		}
		if (state.in.partial)
		{
			state.in.complete -= partial;
			state.in.remains = 0;
		}
		if (sfsync(state.out.fp))
			error(ERROR_SYSTEM|3, "%s: write error", state.ofn.value.string);
	}
	fini(error_info.errors != 0);
}