Attachment #147516 for bug #191263





#include <sys/types.h>

#include <ctype.h>
#include <err.h>
#include <errno.h>
#include <inttypes.h>

	 */
	if (in.offset > OFF_MAX / (ssize_t)in.dbsz ||
	    out.offset > OFF_MAX / (ssize_t)out.dbsz)
		errx(1, "seek offsets cannot be larger than %jd", OFF_MAX);
		    (intmax_t)OFF_MAX);
}

static int

static void
f_bs(char *arg)
{
	uintmax_t res;

	in.dbsz = out.dbsz = get_num(arg);
	if (out.dbsz < 1 || out.dbsz > SSIZE_MAX)
		errx(1, "bs must be between 1 and %jd", SSIZE_MAX);
	in.dbsz = out.dbsz = (size_t)res;
}

static void
f_cbs(char *arg)
{
	uintmax_t res;

	cbsz = get_num(arg);
	if (cbsz < 1 || cbsz > SSIZE_MAX)
		errx(1, "cbs must be between 1 and %jd", SSIZE_MAX);
	cbsz = (size_t)res;
}

static void
f_count(char *arg)
{
	intmax_t res;

	cpy_cnt = get_num(arg);
	if (cpy_cnt == 0)
		cpy_cnt = -1;
	if (res == 0)
		cpy_cnt = (uintmax_t)-1;
	else
		cpy_cnt = (uintmax_t)res;
}

static void


	files_cnt = get_num(arg);
	if (files_cnt < 1)
		errx(1, "files must be between 1 and %ju", SIZE_MAX);
}

static void

static void
f_ibs(char *arg)
{
	uintmax_t res;

	if (!(ddflags & C_BS)) {
		in.dbsz = get_num(arg);
		if (in.dbsz < 1 || in.dbsz > SSIZE_MAX)
			errx(1, "ibs must be between 1 and %ju", SSIZE_MAX);
			    (intmax_t)SSIZE_MAX);
		in.dbsz = (size_t)res;
	}
}


static void
f_obs(char *arg)
{
	uintmax_t res;

	if (!(ddflags & C_BS)) {
		out.dbsz = get_num(arg);
		if (out.dbsz < 1 || out.dbsz > SSIZE_MAX)
			errx(1, "obs must be between 1 and %jd", SSIZE_MAX);
			    (intmax_t)SSIZE_MAX);
		out.dbsz = (size_t)res;
	}
}


	uintmax_t num, mult, prevnum;
	char *expr;

	while (isspace(val[0]))
		val++;

	if (val[0] == '-')
		errx(1, "%s: cannot be negative", oper);

	errno = 0;
	num = strtoull(val, &expr, 0);
	if (errno != 0)				/* Overflow or underflow. */
		err(1, "%s", oper);

	if (expr == val)			/* No valid digits. */
		errx(1, "%s: illegal numeric value", oper);





	 */
	ch = 0;
	for (inp = in.dbp - in.dbcnt, outp = out.dbp; in.dbcnt;) {
		maxlen = MIN(cbsz, (size_t)in.dbcnt);
		if ((t = ctab) != NULL)
			for (cnt = 0; cnt < maxlen && (ch = *inp++) != '\n';
			    ++cnt)

		 * Check for short record without a newline.  Reassemble the
		 * input block.
		 */
		if (ch != '\n' && (size_t)in.dbcnt < cbsz) {
			(void)memmove(in.db, in.dbp - in.dbcnt, in.dbcnt);
			break;
		}

	 * translation has to already be done or we might not recognize the
	 * spaces.
	 */
	for (inp = in.db; (size_t)in.dbcnt >= cbsz; inp += cbsz, in.dbcnt -= cbsz) {
		for (t = inp + cbsz - 1; t >= inp && *t == ' '; --t)
			;
		if (t >= inp) {




	 * record oriented I/O, only need a single buffer.
	 */
	if (!(ddflags & (C_BLOCK | C_UNBLOCK))) {
		if ((in.db = malloc((size_t)out.dbsz + in.dbsz - 1)) == NULL)
			err(1, "input buffer");
		out.db = in.db;
	} else if ((in.db = malloc(MAX((size_t)in.dbsz, cbsz) + cbsz)) == NULL ||
	    (out.db = malloc(out.dbsz + cbsz)) == NULL)
		err(1, "output buffer");


			++st.in_full;

		/* Handle full input blocks. */
		} else if ((size_t)n == (size_t)in.dbsz) {
			in.dbcnt += in.dbrcnt = n;
			++st.in_full;


			outp += nw;
			st.bytes += nw;

			if ((size_t)nw == n && n == (size_t)out.dbsz)
				++st.out_full;
			else
				++st.out_part;




typedef struct {
	u_char		*db;		/* buffer address */
	u_char		*dbp;		/* current buffer I/O address */
	ssize_t		dbcnt;		/* current buffer byte count */
	ssize_t		dbrcnt;		/* last read byte count */
	ssize_t		dbsz;		/* block size */
	size_t		dbsz;		/* block size */

#define	ISCHR		0x01		/* character device (warn on short) */
#define	ISPIPE		0x02		/* pipe-like (see position.c) */

} IO;

typedef struct {
	size_t	in_full;	/* # of full input blocks */
	size_t	in_part;	/* # of partial input blocks */
	size_t	out_full;	/* # of full output blocks */
	size_t	out_part;	/* # of partial output blocks */
	size_t	trunc;		/* # of truncated records */
	size_t	swab;		/* # of odd-length swab blocks */
	size_t	bytes;		/* # of bytes written */
	struct timespec	start;		/* start time of dd */
} STAT;


Lines 178-184 Link Here

(-)bin/dd/position.c (-1 / +1 lines)
178	n = write(out.fd, out.db, out.dbsz);	178	n = write(out.fd, out.db, out.dbsz);
179	if (n == -1)	179	if (n == -1)
180	err(1, "%s", out.name);	180	err(1, "%s", out.name);
181	if ((size_t)n != out.dbsz)	181	if (n != out.dbsz)
182	errx(1, "%s: write failure", out.name);	182	errx(1, "%s: write failure", out.name);
183	}	183	}
184	break;	184	break;

Return to bug 191263

Lines 41-46 Link Here

(-)bin/dd/args.c (-35 / +26 lines)
41		41
42	#include <sys/types.h>	42	#include <sys/types.h>
43		43
		44	#include <ctype.h>
44	#include <err.h>	45	#include <err.h>
45	#include <errno.h>	46	#include <errno.h>
46	#include <inttypes.h>	47	#include <inttypes.h>
Lines 171-178 Link Here
171	*/	172	*/
172	if (in.offset > OFF_MAX / (ssize_t)in.dbsz \|\|	173	if (in.offset > OFF_MAX / (ssize_t)in.dbsz \|\|
173	out.offset > OFF_MAX / (ssize_t)out.dbsz)	174	out.offset > OFF_MAX / (ssize_t)out.dbsz)
174	errx(1, "seek offsets cannot be larger than %jd",	175	errx(1, "seek offsets cannot be larger than %jd", OFF_MAX);
175	(intmax_t)OFF_MAX);
176	}	176	}
177		177
178	static int	178	static int
Lines 186-222 Link Here
186	static void	186	static void
187	f_bs(char *arg)	187	f_bs(char *arg)
188	{	188	{
189	uintmax_t res;
190		189
191	res = get_num(arg);	190	in.dbsz = out.dbsz = get_num(arg);
192	if (res < 1 \|\| res > SSIZE_MAX)	191	if (out.dbsz < 1 \|\| out.dbsz > SSIZE_MAX)
193	errx(1, "bs must be between 1 and %jd", (intmax_t)SSIZE_MAX);	192	errx(1, "bs must be between 1 and %jd", SSIZE_MAX);
194	in.dbsz = out.dbsz = (size_t)res;
195	}	193	}
196		194
197	static void	195	static void
198	f_cbs(char *arg)	196	f_cbs(char *arg)
199	{	197	{
200	uintmax_t res;
201		198
202	res = get_num(arg);	199	cbsz = get_num(arg);
203	if (res < 1 \|\| res > SSIZE_MAX)	200	if (cbsz < 1 \|\| cbsz > SSIZE_MAX)
204	errx(1, "cbs must be between 1 and %jd", (intmax_t)SSIZE_MAX);	201	errx(1, "cbs must be between 1 and %jd", SSIZE_MAX);
205	cbsz = (size_t)res;
206	}	202	}
207		203
208	static void	204	static void
209	f_count(char *arg)	205	f_count(char *arg)
210	{	206	{
211	intmax_t res;
212		207
213	res = (intmax_t)get_num(arg);	208	cpy_cnt = get_num(arg);
214	if (res < 0)	209	if (cpy_cnt == 0)
215	errx(1, "count cannot be negative");	210	cpy_cnt = -1;
216	if (res == 0)
217	cpy_cnt = (uintmax_t)-1;
218	else
219	cpy_cnt = (uintmax_t)res;
220	}	211	}
221		212
222	static void	213	static void
Lines 225-231 Link Here
225		216
226	files_cnt = get_num(arg);	217	files_cnt = get_num(arg);
227	if (files_cnt < 1)	218	if (files_cnt < 1)
228	errx(1, "files must be between 1 and %jd", (uintmax_t)-1);	219	errx(1, "files must be between 1 and %ju", SIZE_MAX);
229	}	220	}
230		221
231	static void	222	static void
Lines 241-254 Link Here
241	static void	232	static void
242	f_ibs(char *arg)	233	f_ibs(char *arg)
243	{	234	{
244	uintmax_t res;
245		235
246	if (!(ddflags & C_BS)) {	236	if (!(ddflags & C_BS)) {
247	res = get_num(arg);	237	in.dbsz = get_num(arg);
248	if (res < 1 \|\| res > SSIZE_MAX)	238	if (in.dbsz < 1 \|\| in.dbsz > SSIZE_MAX)
249	errx(1, "ibs must be between 1 and %jd",	239	errx(1, "ibs must be between 1 and %ju", SSIZE_MAX);
250	(intmax_t)SSIZE_MAX);
251	in.dbsz = (size_t)res;
252	}	240	}
253	}	241	}
254		242
Lines 262-275 Link Here
262	static void	250	static void
263	f_obs(char *arg)	251	f_obs(char *arg)
264	{	252	{
265	uintmax_t res;
266		253
267	if (!(ddflags & C_BS)) {	254	if (!(ddflags & C_BS)) {
268	res = get_num(arg);	255	out.dbsz = get_num(arg);
269	if (res < 1 \|\| res > SSIZE_MAX)	256	if (out.dbsz < 1 \|\| out.dbsz > SSIZE_MAX)
270	errx(1, "obs must be between 1 and %jd",	257	errx(1, "obs must be between 1 and %jd", SSIZE_MAX);
271	(intmax_t)SSIZE_MAX);
272	out.dbsz = (size_t)res;
273	}	258	}
274	}	259	}
275		260
Lines 378-388 Link Here
378	uintmax_t num, mult, prevnum;	363	uintmax_t num, mult, prevnum;
379	char *expr;	364	char *expr;
380		365
		366	while (isspace(val[0]))
		367	val++;
		368
		369	if (val[0] == '-')
		370	errx(1, "%s: cannot be negative", oper);
		371
381	errno = 0;	372	errno = 0;
382	num = strtouq(val, &expr, 0);	373	num = strtoull(val, &expr, 0);
383	if (errno != 0) /* Overflow or underflow. */	374	if (errno != 0) /* Overflow or underflow. */
384	err(1, "%s", oper);	375	err(1, "%s", oper);
385		376
386	if (expr == val) /* No valid digits. */	377	if (expr == val) /* No valid digits. */
387	errx(1, "%s: illegal numeric value", oper);	378	errx(1, "%s: illegal numeric value", oper);
388		379

Lines 133-139 Link Here

(-)bin/dd/conv.c (-3 / +3 lines)
133	*/	133	*/
134	ch = 0;	134	ch = 0;
135	for (inp = in.dbp - in.dbcnt, outp = out.dbp; in.dbcnt;) {	135	for (inp = in.dbp - in.dbcnt, outp = out.dbp; in.dbcnt;) {
136	maxlen = MIN(cbsz, in.dbcnt);	136	maxlen = MIN(cbsz, (size_t)in.dbcnt);
137	if ((t = ctab) != NULL)	137	if ((t = ctab) != NULL)
138	for (cnt = 0; cnt < maxlen && (ch = *inp++) != '\n';	138	for (cnt = 0; cnt < maxlen && (ch = *inp++) != '\n';
139	++cnt)	139	++cnt)
Lines 146-152 Link Here
146	* Check for short record without a newline. Reassemble the	146	* Check for short record without a newline. Reassemble the
147	* input block.	147	* input block.
148	*/	148	*/
149	if (ch != '\n' && in.dbcnt < cbsz) {	149	if (ch != '\n' && (size_t)in.dbcnt < cbsz) {
150	(void)memmove(in.db, in.dbp - in.dbcnt, in.dbcnt);	150	(void)memmove(in.db, in.dbp - in.dbcnt, in.dbcnt);
151	break;	151	break;
152	}	152	}
Lines 228-234 Link Here
228	* translation has to already be done or we might not recognize the	228	* translation has to already be done or we might not recognize the
229	* spaces.	229	* spaces.
230	*/	230	*/
231	for (inp = in.db; in.dbcnt >= cbsz; inp += cbsz, in.dbcnt -= cbsz) {	231	for (inp = in.db; (size_t)in.dbcnt >= cbsz; inp += cbsz, in.dbcnt -= cbsz) {
232	for (t = inp + cbsz - 1; t >= inp && *t == ' '; --t)	232	for (t = inp + cbsz - 1; t >= inp && *t == ' '; --t)
233	;	233	;
234	if (t >= inp) {	234	if (t >= inp) {

Lines 168-177 Link Here

(-)bin/dd/dd.c (-4 / +4 lines)
168	* record oriented I/O, only need a single buffer.	168	* record oriented I/O, only need a single buffer.
169	*/	169	*/
170	if (!(ddflags & (C_BLOCK \| C_UNBLOCK))) {	170	if (!(ddflags & (C_BLOCK \| C_UNBLOCK))) {
171	if ((in.db = malloc(out.dbsz + in.dbsz - 1)) == NULL)	171	if ((in.db = malloc((size_t)out.dbsz + in.dbsz - 1)) == NULL)
172	err(1, "input buffer");	172	err(1, "input buffer");
173	out.db = in.db;	173	out.db = in.db;
174	} else if ((in.db = malloc(MAX(in.dbsz, cbsz) + cbsz)) == NULL \|\|	174	} else if ((in.db = malloc(MAX((size_t)in.dbsz, cbsz) + cbsz)) == NULL \|\|
175	(out.db = malloc(out.dbsz + cbsz)) == NULL)	175	(out.db = malloc(out.dbsz + cbsz)) == NULL)
176	err(1, "output buffer");	176	err(1, "output buffer");
177		177
Lines 343-349 Link Here
343	++st.in_full;	343	++st.in_full;
344		344
345	/* Handle full input blocks. */	345	/* Handle full input blocks. */
346	} else if ((size_t)n == in.dbsz) {	346	} else if ((size_t)n == (size_t)in.dbsz) {
347	in.dbcnt += in.dbrcnt = n;	347	in.dbcnt += in.dbrcnt = n;
348	++st.in_full;	348	++st.in_full;
349		349
Lines 493-499 Link Here
493	outp += nw;	493	outp += nw;
494	st.bytes += nw;	494	st.bytes += nw;
495		495
496	if ((size_t)nw == n && n == out.dbsz)	496	if ((size_t)nw == n && n == (size_t)out.dbsz)
497	++st.out_full;	497	++st.out_full;
498	else	498	else
499	++st.out_part;	499	++st.out_part;

Lines 38-47 Link Here

(-)bin/dd/dd.h (-11 / +10 lines)
38	typedef struct {	38	typedef struct {
39	u_char db; / buffer address */	39	u_char db; / buffer address */
40	u_char dbp; / current buffer I/O address */	40	u_char dbp; / current buffer I/O address */
41	/* XXX ssize_t? */	41	ssize_t dbcnt; /* current buffer byte count */
42	size_t dbcnt; /* current buffer byte count */	42	ssize_t dbrcnt; /* last read byte count */
43	size_t dbrcnt; /* last read byte count */	43	ssize_t dbsz; /* block size */
44	size_t dbsz; /* block size */
45		44
46	#define ISCHR 0x01 /* character device (warn on short) */	45	#define ISCHR 0x01 /* character device (warn on short) */
47	#define ISPIPE 0x02 /* pipe-like (see position.c) */	46	#define ISPIPE 0x02 /* pipe-like (see position.c) */
Lines 57-69 Link Here
57	} IO;	56	} IO;
58		57
59	typedef struct {	58	typedef struct {
60	uintmax_t in_full; /* # of full input blocks */	59	size_t in_full; /* # of full input blocks */
61	uintmax_t in_part; /* # of partial input blocks */	60	size_t in_part; /* # of partial input blocks */
62	uintmax_t out_full; /* # of full output blocks */	61	size_t out_full; /* # of full output blocks */
63	uintmax_t out_part; /* # of partial output blocks */	62	size_t out_part; /* # of partial output blocks */
64	uintmax_t trunc; /* # of truncated records */	63	size_t trunc; /* # of truncated records */
65	uintmax_t swab; /* # of odd-length swab blocks */	64	size_t swab; /* # of odd-length swab blocks */
66	uintmax_t bytes; /* # of bytes written */	65	size_t bytes; /* # of bytes written */
67	struct timespec start; /* start time of dd */	66	struct timespec start; /* start time of dd */
68	} STAT;	67	} STAT;
69		68