BDEification process of dd(1). Most of the changes are from BDE's archive. Support for negative offsets is gone again, but the case where you lseek() onto byte -1 of something from a negative offset using seek/skip is fixed; if you end up on -1, you won't get a false positive lseek failure. The biggest changes are to data types (more size_t, for instance) and argument parsing. skip/seek on /dev/{,k}mem now occurs (instead of "read until you reach the offset") due to mem devices now being D_DISK. Some const things are now correctly declared as such, and the "case table" building is better. The only thing that seems to be left to make dd(1) everything TOG wants it to be is l10n.
271 lines
7.1 KiB
C
271 lines
7.1 KiB
C
/*-
|
|
* 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. All advertising materials mentioning features or use of this software
|
|
* must display the following acknowledgement:
|
|
* This product includes software developed by the University of
|
|
* California, Berkeley and its contributors.
|
|
* 4. 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.
|
|
*/
|
|
|
|
#ifndef lint
|
|
#if 0
|
|
static char sccsid[] = "@(#)conv.c 8.3 (Berkeley) 4/2/94";
|
|
#endif
|
|
static const char rcsid[] =
|
|
"$FreeBSD$";
|
|
#endif /* not lint */
|
|
|
|
#include <sys/param.h>
|
|
|
|
#include <err.h>
|
|
#include <string.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()
|
|
{
|
|
u_char *inp;
|
|
const u_char *t;
|
|
size_t cnt;
|
|
|
|
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()
|
|
{
|
|
/* Just update the count, everything is already in the buffer. */
|
|
if (in.dbcnt)
|
|
out.dbcnt = in.dbcnt;
|
|
}
|
|
|
|
/*
|
|
* 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()
|
|
{
|
|
u_char *inp, *outp;
|
|
const u_char *t;
|
|
size_t cnt, maxlen;
|
|
static int intrunc;
|
|
int ch = -1;
|
|
|
|
/*
|
|
* 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.
|
|
*/
|
|
ch = 0;
|
|
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()
|
|
{
|
|
/*
|
|
* 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()
|
|
{
|
|
u_char *inp;
|
|
const u_char *t;
|
|
size_t cnt;
|
|
|
|
/* Translation and case conversion. */
|
|
if ((t = ctab) != NULL)
|
|
for (cnt = in.dbrcnt, inp = in.dbp; cnt--;)
|
|
*--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.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()
|
|
{
|
|
u_char *t;
|
|
size_t cnt;
|
|
|
|
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';
|
|
}
|
|
}
|