Attachment #148754 for bug #191263





#include <sys/types.h>

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


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



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


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

	res = get_num(arg);
	if (res == UINTMAX_MAX)
		errc(1, ERANGE, "%s", oper);
	if (res == 0)
		cpy_cnt = UINTMAX_MAX;
	else
		cpy_cnt = res;
}

static void


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

static void

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

	if (!(ddflags & C_BS)) {
		res = get_num(arg);
		if (res < 1 || res > SSIZE_MAX)
			errx(1, "obs must be between 1 and %zd",
			    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;

Lines 38-47 Link Here

(-)dd.h (-4 / +3 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 178-184 Link Here

(-)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

(-)args.c (-15 / +22 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 190-196 Link Here
190		191
191	res = get_num(arg);	192	res = get_num(arg);
192	if (res < 1 \|\| res > SSIZE_MAX)	193	if (res < 1 \|\| res > SSIZE_MAX)
193	errx(1, "bs must be between 1 and %jd", (intmax_t)SSIZE_MAX);	194	errx(1, "bs must be between 1 and %zd", SSIZE_MAX);
194	in.dbsz = out.dbsz = (size_t)res;	195	in.dbsz = out.dbsz = (size_t)res;
195	}	196	}
196		197
Lines 201-207 Link Here
201		202
202	res = get_num(arg);	203	res = get_num(arg);
203	if (res < 1 \|\| res > SSIZE_MAX)	204	if (res < 1 \|\| res > SSIZE_MAX)
204	errx(1, "cbs must be between 1 and %jd", (intmax_t)SSIZE_MAX);	205	errx(1, "cbs must be between 1 and %zd", SSIZE_MAX);
205	cbsz = (size_t)res;	206	cbsz = (size_t)res;
206	}	207	}
207		208
Lines 208-222 Link Here
208	static void	209	static void
209	f_count(char *arg)	210	f_count(char *arg)
210	{	211	{
211	intmax_t res;	212	uintmax_t res;
212		213
213	res = (intmax_t)get_num(arg);	214	res = get_num(arg);
214	if (res < 0)	215	if (res == UINTMAX_MAX)
215	errx(1, "count cannot be negative");	216	errc(1, ERANGE, "%s", oper);
216	if (res == 0)	217	if (res == 0)
217	cpy_cnt = (uintmax_t)-1;	218	cpy_cnt = UINTMAX_MAX;
218	else	219	else
219	cpy_cnt = (uintmax_t)res;	220	cpy_cnt = res;
220	}	221	}
221		222
222	static void	223	static void
Lines 225-231 Link Here
225		226
226	files_cnt = get_num(arg);	227	files_cnt = get_num(arg);
227	if (files_cnt < 1)	228	if (files_cnt < 1)
228	errx(1, "files must be between 1 and %jd", (uintmax_t)-1);	229	errx(1, "files must be between 1 and %zu", SIZE_MAX);
229	}	230	}
230		231
231	static void	232	static void
Lines 246-253 Link Here
246	if (!(ddflags & C_BS)) {	247	if (!(ddflags & C_BS)) {
247	res = get_num(arg);	248	res = get_num(arg);
248	if (res < 1 \|\| res > SSIZE_MAX)	249	if (res < 1 \|\| res > SSIZE_MAX)
249	errx(1, "ibs must be between 1 and %jd",	250	errx(1, "ibs must be between 1 and %zd",
250	(intmax_t)SSIZE_MAX);	251	SSIZE_MAX);
251	in.dbsz = (size_t)res;	252	in.dbsz = (size_t)res;
252	}	253	}
253	}	254	}
Lines 267-274 Link Here
267	if (!(ddflags & C_BS)) {	268	if (!(ddflags & C_BS)) {
268	res = get_num(arg);	269	res = get_num(arg);
269	if (res < 1 \|\| res > SSIZE_MAX)	270	if (res < 1 \|\| res > SSIZE_MAX)
270	errx(1, "obs must be between 1 and %jd",	271	errx(1, "obs must be between 1 and %zd",
271	(intmax_t)SSIZE_MAX);	272	SSIZE_MAX);
272	out.dbsz = (size_t)res;	273	out.dbsz = (size_t)res;
273	}	274	}
274	}	275	}
Lines 378-388 Link Here
378	uintmax_t num, mult, prevnum;	379	uintmax_t num, mult, prevnum;
379	char *expr;	380	char *expr;
380		381
		382	while (isspace(val[0]))
		383	val++;
		384
		385	if (val[0] == '-')
		386	errx(1, "%s: cannot be negative", oper);
		387
381	errno = 0;	388	errno = 0;
382	num = strtouq(val, &expr, 0);	389	num = strtoull(val, &expr, 0);
383	if (errno != 0) /* Overflow or underflow. */	390	if (errno != 0) /* Overflow or underflow. */
384	err(1, "%s", oper);	391	err(1, "%s", oper);
385		392
386	if (expr == val) /* No valid digits. */	393	if (expr == val) /* No valid digits. */
387	errx(1, "%s: illegal numeric value", oper);	394	errx(1, "%s: illegal numeric value", oper);
388		395

Lines 133-139 Link Here

(-)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

(-)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;