Merge "Remove BSD dd." am: 75d3592cb9 (8cb8504e) · Commits · e / os / android_system_core

toolbox/Android.bp

+1 −27

Original line number	Diff line number	Diff line
		@@ -5,32 +5,8 @@ cc_defaults {
		"-Werror",
		"-Wno-unused-parameter",
		"-Wno-unused-const-variable",
		"-include bsd-compatibility.h",
		"-D_FILE_OFFSET_BITS=64",
		],
		local_include_dirs: ["upstream-netbsd/include/"],
		}

		cc_library_static {
		name: "libtoolbox_dd",
		defaults: ["toolbox_defaults"],
		vendor_available: true,
		srcs: [
		"upstream-netbsd/bin/dd/args.c",
		"upstream-netbsd/bin/dd/conv.c",
		"upstream-netbsd/bin/dd/dd.c",
		"upstream-netbsd/bin/dd/dd_hostops.c",
		"upstream-netbsd/bin/dd/misc.c",
		"upstream-netbsd/bin/dd/position.c",
		"upstream-netbsd/lib/libc/gen/getbsize.c",
		"upstream-netbsd/lib/libc/gen/humanize_number.c",
		"upstream-netbsd/lib/libc/stdlib/strsuftoll.c",
		"upstream-netbsd/lib/libc/string/swab.c",
		"upstream-netbsd/lib/libutil/raise_default_signal.c",
		],
		cflags: [
		"-Dmain=dd_main",
		"-DNO_CONV",
		"-DWITHOUT_NLS",
		],
		}

		@@ -55,10 +31,8 @@ cc_defaults {
		generated_headers: [
		"toolbox_input_labels",
		],
		whole_static_libs: ["libtoolbox_dd"],
		shared_libs: [
		"libbase",
		"libcutils",
		],
		static_libs: ["libpropertyinfoparser"],

toolbox/bsd-compatibility.h

deleted100644 → 0

+0 −84

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2014, The Android Open Source Project
		* All rights reserved.
		*
		* Redistribution and use in source and binary forms, with or without
		* modification, are permitted provided that the following conditions
		* are met:
		* * Redistributions of source code must retain the above copyright
		* notice, this list of conditions and the following disclaimer.
		* * Redistributions in binary form must reproduce the above copyright
		* notice, this list of conditions and the following disclaimer in
		* the documentation and/or other materials provided with the
		* distribution.
		*
		* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
		* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
		* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
		* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
		* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
		* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
		* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
		* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
		* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
		* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
		* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
		* SUCH DAMAGE.
		*/

		#include <stdbool.h>
		#include <sys/types.h>

		/* We want chown to support user.group as well as user:group. */
		#define SUPPORT_DOT

		/* We don't localize /system/bin! */
		#define WITHOUT_NLS

		// NetBSD uses _DIAGASSERT to null-check arguments and the like.
		#include <assert.h>
		#define _DIAGASSERT(e) ((e) ? (void) 0 : __assert2(__FILE__, __LINE__, __func__, #e))

		// TODO: update our <sys/cdefs.h> to support this properly.
		#define __type_fit(t, a) (0 == 0)

		// TODO: should this be in our <sys/cdefs.h>?
		#define __arraycount(a) (sizeof(a) / sizeof((a)[0]))

		// This at least matches GNU dd(1) behavior.
		#define SIGINFO SIGUSR1

		#define S_ISWHT(x) false

		__BEGIN_DECLS

		/* From NetBSD <stdlib.h>. */
		#define HN_DECIMAL 0x01
		#define HN_NOSPACE 0x02
		#define HN_B 0x04
		#define HN_DIVISOR_1000 0x08
		#define HN_GETSCALE 0x10
		#define HN_AUTOSCALE 0x20
		int humanize_number(char , size_t, int64_t, const char , int, int);
		int dehumanize_number(const char , int64_t );
		char getbsize(int , long *);
		long long strsuftoll(const char , const char , long long, long long);
		long long strsuftollx(const char , const char , long long, long long,
		char *, size_t);

		/* From NetBSD <string.h>. */
		void strmode(mode_t, char*);

		/* From NetBSD <sys/param.h>. */
		#define MAXBSIZE 65536

		/* From NetBSD <sys/stat.h>. */
		#define DEFFILEMODE (S_IRUSR \| S_IWUSR)

		/* From NetBSD <unistd.h>. */
		void swab(const void * __restrict, void * __restrict, ssize_t);

		/* From NetBSD <util.h>. */
		int raise_default_signal(int);

		__END_DECLS

toolbox/tools.h

+0 −1

Original line number	Diff line number	Diff line
		TOOL(dd)
		TOOL(getevent)
		TOOL(getprop)
		TOOL(newfs_msdos)

toolbox/upstream-netbsd/bin/dd/args.c

deleted100644 → 0

+0 −391

Original line number	Diff line number	Diff line
		/* $NetBSD: args.c,v 1.38 2013/07/17 12:55:48 christos Exp $ */

		/*-
		* Copyright (c) 1991, 1993, 1994
		* The Regents of the University of California. All rights reserved.
		*
		* This code is derived from software contributed to Berkeley by
		* Keith Muller of the University of California, San Diego and Lance
		* Visser of Convex Computer Corporation.
		*
		* Redistribution and use in source and binary forms, with or without
		* modification, are permitted provided that the following conditions
		* are met:
		* 1. Redistributions of source code must retain the above copyright
		* notice, this list of conditions and the following disclaimer.
		* 2. Redistributions in binary form must reproduce the above copyright
		* notice, this list of conditions and the following disclaimer in the
		* documentation and/or other materials provided with the distribution.
		* 3. Neither the name of the University nor the names of its contributors
		* may be used to endorse or promote products derived from this software
		* without specific prior written permission.
		*
		* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
		* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
		* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
		* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
		* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
		* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
		* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
		* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
		* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
		* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
		* SUCH DAMAGE.
		*/

		#include <sys/cdefs.h>
		#ifndef lint
		#if 0
		static char sccsid[] = "@(#)args.c 8.3 (Berkeley) 4/2/94";
		#else
		__RCSID("$NetBSD: args.c,v 1.38 2013/07/17 12:55:48 christos Exp $");
		#endif
		#endif /* not lint */

		#include <sys/types.h>
		#include <sys/time.h>

		#include <err.h>
		#include <errno.h>
		#include <limits.h>
		#include <stdio.h>
		#include <stdlib.h>
		#include <string.h>

		#include "dd.h"
		#include "extern.h"

		static int c_arg(const void , const void );

		#ifdef NO_MSGFMT
		static void f_msgfmt(char *) __dead;
		#else
		static void f_msgfmt(char *);
		#endif /* NO_MSGFMT */

		#ifdef NO_CONV
		static void f_conv(char *) __dead;
		#else
		static void f_conv(char *);
		static int c_conv(const void , const void );
		#endif /* NO_CONV */

		static void f_bs(char *);
		static void f_cbs(char *);
		static void f_count(char *);
		static void f_files(char *);
		static void f_ibs(char *);
		static void f_if(char *);
		static void f_obs(char *);
		static void f_of(char *);
		static void f_seek(char *);
		static void f_skip(char *);
		static void f_progress(char *);

		static const struct arg {
		const char *name;
		void (f)(char );
		u_int set, noset;
		} args[] = {
		/* the array needs to be sorted by the first column so
		bsearch() can be used to find commands quickly */
		{ "bs", f_bs, C_BS, C_BS\|C_IBS\|C_OBS\|C_OSYNC },
		{ "cbs", f_cbs, C_CBS, C_CBS },
		{ "conv", f_conv, 0, 0 },
		{ "count", f_count, C_COUNT, C_COUNT },
		{ "files", f_files, C_FILES, C_FILES },
		{ "ibs", f_ibs, C_IBS, C_BS\|C_IBS },
		{ "if", f_if, C_IF, C_IF },
		{ "iseek", f_skip, C_SKIP, C_SKIP },
		{ "msgfmt", f_msgfmt, 0, 0 },
		{ "obs", f_obs, C_OBS, C_BS\|C_OBS },
		{ "of", f_of, C_OF, C_OF },
		{ "oseek", f_seek, C_SEEK, C_SEEK },
		{ "progress", f_progress, 0, 0 },
		{ "seek", f_seek, C_SEEK, C_SEEK },
		{ "skip", f_skip, C_SKIP, C_SKIP },
		};

		/*
		* args -- parse JCL syntax of dd.
		*/
		void
		jcl(char **argv)
		{
		struct arg *ap, tmp;
		char oper, arg;

		in.dbsz = out.dbsz = 512;

		while ((oper = *++argv) != NULL) {
		if ((oper = strdup(oper)) == NULL) {
		errx(EXIT_FAILURE,
		"unable to allocate space for the argument %s",
		*argv);
		/* NOTREACHED */
		}
		if ((arg = strchr(oper, '=')) == NULL) {
		errx(EXIT_FAILURE, "unknown operand %s", oper);
		/* NOTREACHED */
		}
		*arg++ = '\0';
		if (!*arg) {
		errx(EXIT_FAILURE, "no value specified for %s", oper);
		/* NOTREACHED */
		}
		tmp.name = oper;
		if (!(ap = bsearch(&tmp, args,
		__arraycount(args), sizeof(*args), c_arg))) {
		errx(EXIT_FAILURE, "unknown operand %s", tmp.name);
		/* NOTREACHED */
		}
		if (ddflags & ap->noset) {
		errx(EXIT_FAILURE,
		"%s: illegal argument combination or already set",
		tmp.name);
		/* NOTREACHED */
		}
		ddflags \|= ap->set;
		ap->f(arg);
		}

		/* Final sanity checks. */

		if (ddflags & C_BS) {
		/*
		* Bs is turned off by any conversion -- we assume the user
		* just wanted to set both the input and output block sizes
		* and didn't want the bs semantics, so we don't warn.
		*/
		if (ddflags & (C_BLOCK \| C_LCASE \| C_SWAB \| C_UCASE \|
		C_UNBLOCK \| C_OSYNC \| C_ASCII \| C_EBCDIC \| C_SPARSE)) {
		ddflags &= ~C_BS;
		ddflags \|= C_IBS\|C_OBS;
		}

		/* Bs supersedes ibs and obs. */
		if (ddflags & C_BS && ddflags & (C_IBS\|C_OBS))
		warnx("bs supersedes ibs and obs");
		}

		/*
		* Ascii/ebcdic and cbs implies block/unblock.
		* Block/unblock requires cbs and vice-versa.
		*/
		if (ddflags & (C_BLOCK\|C_UNBLOCK)) {
		if (!(ddflags & C_CBS)) {
		errx(EXIT_FAILURE, "record operations require cbs");
		/* NOTREACHED */
		}
		cfunc = ddflags & C_BLOCK ? block : unblock;
		} else if (ddflags & C_CBS) {
		if (ddflags & (C_ASCII\|C_EBCDIC)) {
		if (ddflags & C_ASCII) {
		ddflags \|= C_UNBLOCK;
		cfunc = unblock;
		} else {
		ddflags \|= C_BLOCK;
		cfunc = block;
		}
		} else {
		errx(EXIT_FAILURE,
		"cbs meaningless if not doing record operations");
		/* NOTREACHED */
		}
		} else
		cfunc = def;

		/* Read, write and seek calls take off_t as arguments.
		*
		* The following check is not done because an off_t is a quad
		* for current NetBSD implementations.
		*
		* if (in.offset > INT_MAX/in.dbsz \|\| out.offset > INT_MAX/out.dbsz)
		* errx(1, "seek offsets cannot be larger than %d", INT_MAX);
		*/
		}

		static int
		c_arg(const void a, const void b)
		{

		return (strcmp(((const struct arg *)a)->name,
		((const struct arg *)b)->name));
		}

		static void
		f_bs(char *arg)
		{

		in.dbsz = out.dbsz = strsuftoll("block size", arg, 1, UINT_MAX);
		}

		static void
		f_cbs(char *arg)
		{

		cbsz = strsuftoll("conversion record size", arg, 1, UINT_MAX);
		}

		static void
		f_count(char *arg)
		{

		cpy_cnt = strsuftoll("block count", arg, 0, LLONG_MAX);
		if (!cpy_cnt)
		terminate(0);
		}

		static void
		f_files(char *arg)
		{

		files_cnt = (u_int)strsuftoll("file count", arg, 0, UINT_MAX);
		if (!files_cnt)
		terminate(0);
		}

		static void
		f_ibs(char *arg)
		{

		if (!(ddflags & C_BS))
		in.dbsz = strsuftoll("input block size", arg, 1, UINT_MAX);
		}

		static void
		f_if(char *arg)
		{

		in.name = arg;
		}

		#ifdef NO_MSGFMT
		/* Build a small version (i.e. for a ramdisk root) */
		static void
		f_msgfmt(char *arg)
		{

		errx(EXIT_FAILURE, "msgfmt option disabled");
		/* NOTREACHED */
		}
		#else /* NO_MSGFMT */
		static void
		f_msgfmt(char *arg)
		{

		/*
		* If the format string is not valid, dd_write_msg() will print
		* an error and exit.
		*/
		dd_write_msg(arg, 0);

		msgfmt = arg;
		}
		#endif /* NO_MSGFMT */

		static void
		f_obs(char *arg)
		{

		if (!(ddflags & C_BS))
		out.dbsz = strsuftoll("output block size", arg, 1, UINT_MAX);
		}

		static void
		f_of(char *arg)
		{

		out.name = arg;
		}

		static void
		f_seek(char *arg)
		{

		out.offset = strsuftoll("seek blocks", arg, 0, LLONG_MAX);
		}

		static void
		f_skip(char *arg)
		{

		in.offset = strsuftoll("skip blocks", arg, 0, LLONG_MAX);
		}

		static void
		f_progress(char *arg)
		{

		progress = strsuftoll("progress blocks", arg, 0, LLONG_MAX);
		}

		#ifdef NO_CONV
		/* Build a small version (i.e. for a ramdisk root) */
		static void
		f_conv(char *arg)
		{

		errx(EXIT_FAILURE, "conv option disabled");
		/* NOTREACHED */
		}
		#else /* NO_CONV */

		static const struct conv {
		const char *name;
		u_int set, noset;
		const u_char *ctab;
		} clist[] = {
		{ "ascii", C_ASCII, C_EBCDIC, e2a_POSIX },
		{ "block", C_BLOCK, C_UNBLOCK, NULL },
		{ "ebcdic", C_EBCDIC, C_ASCII, a2e_POSIX },
		{ "ibm", C_EBCDIC, C_ASCII, a2ibm_POSIX },
		{ "lcase", C_LCASE, C_UCASE, NULL },
		{ "noerror", C_NOERROR, 0, NULL },
		{ "notrunc", C_NOTRUNC, 0, NULL },
		{ "oldascii", C_ASCII, C_EBCDIC, e2a_32V },
		{ "oldebcdic", C_EBCDIC, C_ASCII, a2e_32V },
		{ "oldibm", C_EBCDIC, C_ASCII, a2ibm_32V },
		{ "osync", C_OSYNC, C_BS, NULL },
		{ "sparse", C_SPARSE, 0, NULL },
		{ "swab", C_SWAB, 0, NULL },
		{ "sync", C_SYNC, 0, NULL },
		{ "ucase", C_UCASE, C_LCASE, NULL },
		{ "unblock", C_UNBLOCK, C_BLOCK, NULL },
		/* If you add items to this table, be sure to add the
		* conversions to the C_BS check in the jcl routine above.
		*/
		};

		static void
		f_conv(char *arg)
		{
		struct conv *cp, tmp;

		while (arg != NULL) {
		tmp.name = strsep(&arg, ",");
		if (!(cp = bsearch(&tmp, clist,
		__arraycount(clist), sizeof(*clist), c_conv))) {
		errx(EXIT_FAILURE, "unknown conversion %s", tmp.name);
		/* NOTREACHED */
		}
		if (ddflags & cp->noset) {
		errx(EXIT_FAILURE,
		"%s: illegal conversion combination", tmp.name);
		/* NOTREACHED */
		}
		ddflags \|= cp->set;
		if (cp->ctab)
		ctab = cp->ctab;
		}
		}

		static int
		c_conv(const void a, const void b)
		{

		return (strcmp(((const struct conv *)a)->name,
		((const struct conv *)b)->name));
		}

		#endif /* NO_CONV */

toolbox/upstream-netbsd/bin/dd/conv.c

deleted100644 → 0

+0 −283

Original line number	Diff line number	Diff line
		/* $NetBSD: conv.c,v 1.17 2003/08/07 09:05:10 agc Exp $ */

		/*-
		* Copyright (c) 1991, 1993, 1994
		* The Regents of the University of California. All rights reserved.
		*
		* This code is derived from software contributed to Berkeley by
		* Keith Muller of the University of California, San Diego and Lance
		* Visser of Convex Computer Corporation.
		*
		* Redistribution and use in source and binary forms, with or without
		* modification, are permitted provided that the following conditions
		* are met:
		* 1. Redistributions of source code must retain the above copyright
		* notice, this list of conditions and the following disclaimer.
		* 2. Redistributions in binary form must reproduce the above copyright
		* notice, this list of conditions and the following disclaimer in the
		* documentation and/or other materials provided with the distribution.
		* 3. Neither the name of the University nor the names of its contributors
		* may be used to endorse or promote products derived from this software
		* without specific prior written permission.
		*
		* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
		* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
		* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
		* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
		* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
		* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
		* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
		* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
		* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
		* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
		* SUCH DAMAGE.
		*/

		#include <sys/cdefs.h>
		#ifndef lint
		#if 0
		static char sccsid[] = "@(#)conv.c 8.3 (Berkeley) 4/2/94";
		#else
		__RCSID("$NetBSD: conv.c,v 1.17 2003/08/07 09:05:10 agc Exp $");
		#endif
		#endif /* not lint */

		#include <sys/param.h>
		#include <sys/time.h>

		#include <err.h>
		#include <string.h>
		#include <stdlib.h>

		#include "dd.h"
		#include "extern.h"

		/*
		* def --
		* Copy input to output. Input is buffered until reaches obs, and then
		* output until less than obs remains. Only a single buffer is used.
		* Worst case buffer calculation is (ibs + obs - 1).
		*/
		void
		def(void)
		{
		uint64_t cnt;
		u_char *inp;
		const u_char *t;

		if ((t = ctab) != NULL)
		for (inp = in.dbp - (cnt = in.dbrcnt); cnt--; ++inp)
		inp = t[inp];

		/* Make the output buffer look right. */
		out.dbp = in.dbp;
		out.dbcnt = in.dbcnt;

		if (in.dbcnt >= out.dbsz) {
		/* If the output buffer is full, write it. */
		dd_out(0);

		/*
		* Ddout copies the leftover output to the beginning of
		* the buffer and resets the output buffer. Reset the
		* input buffer to match it.
		*/
		in.dbp = out.dbp;
		in.dbcnt = out.dbcnt;
		}
		}

		void
		def_close(void)
		{

		/* Just update the count, everything is already in the buffer. */
		if (in.dbcnt)
		out.dbcnt = in.dbcnt;
		}

		#ifdef NO_CONV
		/* Build a smaller version (i.e. for a miniroot) */
		/* These can not be called, but just in case... */
		static const char no_block[] = "unblock and -DNO_CONV?";
		void block(void) { errx(EXIT_FAILURE, "%s", no_block + 2); }
		void block_close(void) { errx(EXIT_FAILURE, "%s", no_block + 2); }
		void unblock(void) { errx(EXIT_FAILURE, "%s", no_block); }
		void unblock_close(void) { errx(EXIT_FAILURE, "%s", no_block); }
		#else /* NO_CONV */

		/*
		* Copy variable length newline terminated records with a max size cbsz
		* bytes to output. Records less than cbs are padded with spaces.
		*
		* max in buffer: MAX(ibs, cbsz)
		* max out buffer: obs + cbsz
		*/
		void
		block(void)
		{
		static int intrunc;
		int ch = 0; /* pacify gcc */
		uint64_t cnt, maxlen;
		u_char inp, outp;
		const u_char *t;

		/*
		* Record truncation can cross block boundaries. If currently in a
		* truncation state, keep tossing characters until reach a newline.
		* Start at the beginning of the buffer, as the input buffer is always
		* left empty.
		*/
		if (intrunc) {
		for (inp = in.db, cnt = in.dbrcnt;
		cnt && *inp++ != '\n'; --cnt);
		if (!cnt) {
		in.dbcnt = 0;
		in.dbp = in.db;
		return;
		}
		intrunc = 0;
		/* Adjust the input buffer numbers. */
		in.dbcnt = cnt - 1;
		in.dbp = inp + cnt - 1;
		}

		/*
		* Copy records (max cbsz size chunks) into the output buffer. The
		* translation is done as we copy into the output buffer.
		*/
		for (inp = in.dbp - in.dbcnt, outp = out.dbp; in.dbcnt;) {
		maxlen = MIN(cbsz, in.dbcnt);
		if ((t = ctab) != NULL)
		for (cnt = 0;
		cnt < maxlen && (ch = *inp++) != '\n'; ++cnt)
		*outp++ = t[ch];
		else
		for (cnt = 0;
		cnt < maxlen && (ch = *inp++) != '\n'; ++cnt)
		*outp++ = ch;
		/*
		* Check for short record without a newline. Reassemble the
		* input block.
		*/
		if (ch != '\n' && in.dbcnt < cbsz) {
		(void)memmove(in.db, in.dbp - in.dbcnt, in.dbcnt);
		break;
		}

		/* Adjust the input buffer numbers. */
		in.dbcnt -= cnt;
		if (ch == '\n')
		--in.dbcnt;

		/* Pad short records with spaces. */
		if (cnt < cbsz)
		(void)memset(outp, ctab ? ctab[' '] : ' ', cbsz - cnt);
		else {
		/*
		* If the next character wouldn't have ended the
		* block, it's a truncation.
		*/
		if (!in.dbcnt \|\| *inp != '\n')
		++st.trunc;

		/* Toss characters to a newline. */
		for (; in.dbcnt && *inp++ != '\n'; --in.dbcnt);
		if (!in.dbcnt)
		intrunc = 1;
		else
		--in.dbcnt;
		}

		/* Adjust output buffer numbers. */
		out.dbp += cbsz;
		if ((out.dbcnt += cbsz) >= out.dbsz)
		dd_out(0);
		outp = out.dbp;
		}
		in.dbp = in.db + in.dbcnt;
		}

		void
		block_close(void)
		{

		/*
		* Copy any remaining data into the output buffer and pad to a record.
		* Don't worry about truncation or translation, the input buffer is
		* always empty when truncating, and no characters have been added for
		* translation. The bottom line is that anything left in the input
		* buffer is a truncated record. Anything left in the output buffer
		* just wasn't big enough.
		*/
		if (in.dbcnt) {
		++st.trunc;
		(void)memmove(out.dbp, in.dbp - in.dbcnt, in.dbcnt);
		(void)memset(out.dbp + in.dbcnt,
		ctab ? ctab[' '] : ' ', cbsz - in.dbcnt);
		out.dbcnt += cbsz;
		}
		}

		/*
		* Convert fixed length (cbsz) records to variable length. Deletes any
		* trailing blanks and appends a newline.
		*
		* max in buffer: MAX(ibs, cbsz) + cbsz
		* max out buffer: obs + cbsz
		*/
		void
		unblock(void)
		{
		uint64_t cnt;
		u_char *inp;
		const u_char *t;

		/* Translation and case conversion. */
		if ((t = ctab) != NULL)
		for (cnt = in.dbrcnt, inp = in.dbp - 1; cnt--; inp--)
		inp = t[inp];
		/*
		* Copy records (max cbsz size chunks) into the output buffer. The
		* translation has to already be done or we might not recognize the
		* spaces.
		*/
		for (inp = in.db; in.dbcnt >= cbsz; inp += cbsz, in.dbcnt -= cbsz) {
		for (t = inp + cbsz - 1; t >= inp && *t == ' '; --t);
		if (t >= inp) {
		cnt = t - inp + 1;
		(void)memmove(out.dbp, inp, cnt);
		out.dbp += cnt;
		out.dbcnt += cnt;
		}
		++out.dbcnt;
		*out.dbp++ = '\n';
		if (out.dbcnt >= out.dbsz)
		dd_out(0);
		}
		if (in.dbcnt)
		(void)memmove(in.db, in.dbp - in.dbcnt, in.dbcnt);
		in.dbp = in.db + in.dbcnt;
		}

		void
		unblock_close(void)
		{
		uint64_t cnt;
		u_char *t;

		if (in.dbcnt) {
		warnx("%s: short input record", in.name);
		for (t = in.db + in.dbcnt - 1; t >= in.db && *t == ' '; --t);
		if (t >= in.db) {
		cnt = t - in.db + 1;
		(void)memmove(out.dbp, in.db, cnt);
		out.dbp += cnt;
		out.dbcnt += cnt;
		}
		++out.dbcnt;
		*out.dbp++ = '\n';
		}
		}

		#endif /* NO_CONV */