1/*-
2 * SPDX-License-Identifier: BSD-3-Clause
3 *
4 * Copyright (c) 1991, 1993, 1994
5 *	The Regents of the University of California.  All rights reserved.
6 *
7 * This code is derived from software contributed to Berkeley by
8 * Keith Muller of the University of California, San Diego and Lance
9 * Visser of Convex Computer Corporation.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 *    notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 *    notice, this list of conditions and the following disclaimer in the
18 *    documentation and/or other materials provided with the distribution.
19 * 3. Neither the name of the University nor the names of its contributors
20 *    may be used to endorse or promote products derived from this software
21 *    without specific prior written permission.
22 *
23 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
24 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33 * SUCH DAMAGE.
34 */
35
36#include <sys/param.h>
37
38#include <ctype.h>
39#include <err.h>
40#include <errno.h>
41#include <inttypes.h>
42#include <limits.h>
43#include <signal.h>
44#include <stdlib.h>
45#include <string.h>
46
47#include "dd.h"
48#include "extern.h"
49
50static int	c_arg(const void *, const void *);
51static int	c_conv(const void *, const void *);
52static int	c_iflag(const void *, const void *);
53static int	c_oflag(const void *, const void *);
54static void	f_bs(char *);
55static void	f_cbs(char *);
56static void	f_conv(char *);
57static void	f_count(char *);
58static void	f_files(char *);
59static void	f_fillchar(char *);
60static void	f_ibs(char *);
61static void	f_if(char *);
62static void	f_iflag(char *);
63static void	f_obs(char *);
64static void	f_of(char *);
65static void	f_oflag(char *);
66static void	f_seek(char *);
67static void	f_skip(char *);
68static void	f_speed(char *);
69static void	f_status(char *);
70static uintmax_t get_num(const char *);
71static off_t	get_off_t(const char *);
72
73static const struct arg {
74	const char *name;
75	void (*f)(char *);
76	uint64_t set, noset;
77} args[] = {
78	{ "bs",		f_bs,		C_BS,	 C_BS|C_IBS|C_OBS|C_OSYNC },
79	{ "cbs",	f_cbs,		C_CBS,	 C_CBS },
80	{ "conv",	f_conv,		0,	 0 },
81	{ "count",	f_count,	C_COUNT, C_COUNT },
82	{ "files",	f_files,	C_FILES, C_FILES },
83	{ "fillchar",	f_fillchar,	C_FILL,	 C_FILL },
84	{ "ibs",	f_ibs,		C_IBS,	 C_BS|C_IBS },
85	{ "if",		f_if,		C_IF,	 C_IF },
86	{ "iflag",	f_iflag,	0,	 0 },
87	{ "iseek",	f_skip,		C_SKIP,	 C_SKIP },
88	{ "obs",	f_obs,		C_OBS,	 C_BS|C_OBS },
89	{ "of",		f_of,		C_OF,	 C_OF },
90	{ "oflag",	f_oflag,	0,	 0 },
91	{ "oseek",	f_seek,		C_SEEK,	 C_SEEK },
92	{ "seek",	f_seek,		C_SEEK,	 C_SEEK },
93	{ "skip",	f_skip,		C_SKIP,	 C_SKIP },
94	{ "speed",	f_speed,	0,	 0 },
95	{ "status",	f_status,	C_STATUS,C_STATUS },
96};
97
98static char *oper;
99
100/*
101 * args -- parse JCL syntax of dd.
102 */
103void
104jcl(char **argv)
105{
106	struct arg *ap, tmp;
107	char *arg;
108
109	in.dbsz = out.dbsz = 512;
110
111	while ((oper = *++argv) != NULL) {
112		if ((oper = strdup(oper)) == NULL)
113			errx(1, "unable to allocate space for the argument \"%s\"", *argv);
114		if ((arg = strchr(oper, '=')) == NULL)
115			errx(1, "unknown operand %s", oper);
116		*arg++ = '\0';
117		if (!*arg)
118			errx(1, "no value specified for %s", oper);
119		tmp.name = oper;
120		if (!(ap = (struct arg *)bsearch(&tmp, args,
121		    sizeof(args)/sizeof(struct arg), sizeof(struct arg),
122		    c_arg)))
123			errx(1, "unknown operand %s", tmp.name);
124		if (ddflags & ap->noset)
125			errx(1, "%s: illegal argument combination or already set",
126			    tmp.name);
127		ddflags |= ap->set;
128		ap->f(arg);
129	}
130
131	/* Final sanity checks. */
132
133	if (ddflags & C_BS) {
134		/*
135		 * Bs is turned off by any conversion -- we assume the user
136		 * just wanted to set both the input and output block sizes
137		 * and didn't want the bs semantics, so we don't warn.
138		 */
139		if (ddflags & (C_BLOCK | C_LCASE | C_SWAB | C_UCASE |
140		    C_UNBLOCK))
141			ddflags &= ~C_BS;
142
143		/* Bs supersedes ibs and obs. */
144		if (ddflags & C_BS && ddflags & (C_IBS | C_OBS))
145			warnx("bs supersedes ibs and obs");
146	}
147
148	/*
149	 * Ascii/ebcdic and cbs implies block/unblock.
150	 * Block/unblock requires cbs and vice-versa.
151	 */
152	if (ddflags & (C_BLOCK | C_UNBLOCK)) {
153		if (!(ddflags & C_CBS))
154			errx(1, "record operations require cbs");
155		if (cbsz == 0)
156			errx(1, "cbs cannot be zero");
157		cfunc = ddflags & C_BLOCK ? block : unblock;
158	} else if (ddflags & C_CBS) {
159		if (ddflags & (C_ASCII | C_EBCDIC)) {
160			if (ddflags & C_ASCII) {
161				ddflags |= C_UNBLOCK;
162				cfunc = unblock;
163			} else {
164				ddflags |= C_BLOCK;
165				cfunc = block;
166			}
167		} else
168			errx(1, "cbs meaningless if not doing record operations");
169	} else
170		cfunc = def;
171}
172
173static int
174c_arg(const void *a, const void *b)
175{
176
177	return (strcmp(((const struct arg *)a)->name,
178	    ((const struct arg *)b)->name));
179}
180
181static void
182f_bs(char *arg)
183{
184	uintmax_t res;
185
186	res = get_num(arg);
187	if (res < 1 || res > SSIZE_MAX)
188		errx(1, "bs must be between 1 and %zd", (ssize_t)SSIZE_MAX);
189	in.dbsz = out.dbsz = (size_t)res;
190}
191
192static void
193f_cbs(char *arg)
194{
195	uintmax_t res;
196
197	res = get_num(arg);
198	if (res < 1 || res > SSIZE_MAX)
199		errx(1, "cbs must be between 1 and %zd", (ssize_t)SSIZE_MAX);
200	cbsz = (size_t)res;
201}
202
203static void
204f_count(char *arg)
205{
206	uintmax_t res;
207
208	res = get_num(arg);
209	if (res == UINTMAX_MAX)
210		errc(1, ERANGE, "%s", oper);
211	if (res == 0)
212		cpy_cnt = UINTMAX_MAX;
213	else
214		cpy_cnt = res;
215}
216
217static void
218f_files(char *arg)
219{
220
221	files_cnt = get_num(arg);
222	if (files_cnt < 1)
223		errx(1, "files must be between 1 and %zu", SIZE_MAX);
224}
225
226static void
227f_fillchar(char *arg)
228{
229
230	if (strlen(arg) != 1)
231		errx(1, "need exactly one fill char");
232
233	fill_char = arg[0];
234}
235
236static void
237f_ibs(char *arg)
238{
239	uintmax_t res;
240
241	if (!(ddflags & C_BS)) {
242		res = get_num(arg);
243		if (res < 1 || res > SSIZE_MAX)
244			errx(1, "ibs must be between 1 and %zd",
245			    (ssize_t)SSIZE_MAX);
246		in.dbsz = (size_t)res;
247	}
248}
249
250static void
251f_if(char *arg)
252{
253
254	in.name = arg;
255}
256
257static const struct iflag {
258	const char *name;
259	uint64_t set, noset;
260} ilist[] = {
261	{ "direct",	C_IDIRECT,	0 },
262	{ "fullblock",	C_IFULLBLOCK,	C_SYNC },
263};
264
265static void
266f_iflag(char *arg)
267{
268	struct iflag *ip, tmp;
269
270	while (arg != NULL) {
271		tmp.name = strsep(&arg, ",");
272		ip = bsearch(&tmp, ilist, nitems(ilist), sizeof(struct iflag),
273		    c_iflag);
274		if (ip == NULL)
275			errx(1, "unknown iflag %s", tmp.name);
276		if (ddflags & ip->noset)
277			errx(1, "%s: illegal conversion combination", tmp.name);
278		ddflags |= ip->set;
279	}
280}
281
282static int
283c_iflag(const void *a, const void *b)
284{
285
286	return (strcmp(((const struct iflag *)a)->name,
287	    ((const struct iflag *)b)->name));
288}
289
290static void
291f_obs(char *arg)
292{
293	uintmax_t res;
294
295	if (!(ddflags & C_BS)) {
296		res = get_num(arg);
297		if (res < 1 || res > SSIZE_MAX)
298			errx(1, "obs must be between 1 and %zd",
299			    (ssize_t)SSIZE_MAX);
300		out.dbsz = (size_t)res;
301	}
302}
303
304static void
305f_of(char *arg)
306{
307
308	out.name = arg;
309}
310
311static void
312f_seek(char *arg)
313{
314
315	out.offset = get_off_t(arg);
316}
317
318static void
319f_skip(char *arg)
320{
321
322	in.offset = get_off_t(arg);
323}
324
325static void
326f_speed(char *arg)
327{
328
329	speed = get_num(arg);
330}
331
332static void
333f_status(char *arg)
334{
335
336	if (strcmp(arg, "none") == 0)
337		ddflags |= C_NOINFO;
338	else if (strcmp(arg, "noxfer") == 0)
339		ddflags |= C_NOXFER;
340	else if (strcmp(arg, "progress") == 0)
341		ddflags |= C_PROGRESS;
342	else
343		errx(1, "unknown status %s", arg);
344}
345
346static const struct conv {
347	const char *name;
348	uint64_t set, noset;
349	const u_char *ctab;
350} clist[] = {
351	{ "ascii",	C_ASCII,	C_EBCDIC,	e2a_POSIX },
352	{ "block",	C_BLOCK,	C_UNBLOCK,	NULL },
353	{ "ebcdic",	C_EBCDIC,	C_ASCII,	a2e_POSIX },
354	{ "fdatasync",	C_FDATASYNC,	0,		NULL },
355	{ "fsync",	C_FSYNC,	0,		NULL },
356	{ "ibm",	C_EBCDIC,	C_ASCII,	a2ibm_POSIX },
357	{ "lcase",	C_LCASE,	C_UCASE,	NULL },
358	{ "noerror",	C_NOERROR,	0,		NULL },
359	{ "notrunc",	C_NOTRUNC,	0,		NULL },
360	{ "oldascii",	C_ASCII,	C_EBCDIC,	e2a_32V },
361	{ "oldebcdic",	C_EBCDIC,	C_ASCII,	a2e_32V },
362	{ "oldibm",	C_EBCDIC,	C_ASCII,	a2ibm_32V },
363	{ "osync",	C_OSYNC,	C_BS,		NULL },
364	{ "pareven",	C_PAREVEN,	C_PARODD|C_PARSET|C_PARNONE, NULL},
365	{ "parnone",	C_PARNONE,	C_PARODD|C_PARSET|C_PAREVEN, NULL},
366	{ "parodd",	C_PARODD,	C_PAREVEN|C_PARSET|C_PARNONE, NULL},
367	{ "parset",	C_PARSET,	C_PARODD|C_PAREVEN|C_PARNONE, NULL},
368	{ "sparse",	C_SPARSE,	0,		NULL },
369	{ "swab",	C_SWAB,		0,		NULL },
370	{ "sync",	C_SYNC,		C_IFULLBLOCK,	NULL },
371	{ "ucase",	C_UCASE,	C_LCASE,	NULL },
372	{ "unblock",	C_UNBLOCK,	C_BLOCK,	NULL },
373};
374
375static void
376f_conv(char *arg)
377{
378	struct conv *cp, tmp;
379
380	while (arg != NULL) {
381		tmp.name = strsep(&arg, ",");
382		cp = bsearch(&tmp, clist, nitems(clist), sizeof(struct conv),
383		    c_conv);
384		if (cp == NULL)
385			errx(1, "unknown conversion %s", tmp.name);
386		if (ddflags & cp->noset)
387			errx(1, "%s: illegal conversion combination", tmp.name);
388		ddflags |= cp->set;
389		if (cp->ctab)
390			ctab = cp->ctab;
391	}
392}
393
394static int
395c_conv(const void *a, const void *b)
396{
397
398	return (strcmp(((const struct conv *)a)->name,
399	    ((const struct conv *)b)->name));
400}
401
402static const struct oflag {
403	const char *name;
404	uint64_t set;
405} olist[] = {
406	{ "direct",	C_ODIRECT },
407	{ "fsync",	C_OFSYNC },
408	{ "sync",	C_OFSYNC },
409};
410
411static void
412f_oflag(char *arg)
413{
414	struct oflag *op, tmp;
415
416	while (arg != NULL) {
417		tmp.name = strsep(&arg, ",");
418		op = bsearch(&tmp, olist, nitems(olist), sizeof(struct oflag),
419		    c_oflag);
420		if (op == NULL)
421			errx(1, "unknown open flag %s", tmp.name);
422		ddflags |= op->set;
423	}
424}
425
426static int
427c_oflag(const void *a, const void *b)
428{
429
430	return (strcmp(((const struct oflag *)a)->name,
431	    ((const struct oflag *)b)->name));
432}
433
434static intmax_t
435postfix_to_mult(const char expr)
436{
437	intmax_t mult;
438
439	mult = 0;
440	switch (expr) {
441	case 'B':
442	case 'b':
443		mult = 512;
444		break;
445	case 'K':
446	case 'k':
447		mult = 1 << 10;
448		break;
449	case 'M':
450	case 'm':
451		mult = 1 << 20;
452		break;
453	case 'G':
454	case 'g':
455		mult = 1 << 30;
456		break;
457	case 'T':
458	case 't':
459		mult = (uintmax_t)1 << 40;
460		break;
461	case 'P':
462	case 'p':
463		mult = (uintmax_t)1 << 50;
464		break;
465	case 'W':
466	case 'w':
467		mult = sizeof(int);
468		break;
469	}
470
471	return (mult);
472}
473
474/*
475 * Convert an expression of the following forms to a uintmax_t.
476 * 	1) A positive decimal number.
477 *	2) A positive decimal number followed by a 'b' or 'B' (mult by 512).
478 *	3) A positive decimal number followed by a 'k' or 'K' (mult by 1 << 10).
479 *	4) A positive decimal number followed by a 'm' or 'M' (mult by 1 << 20).
480 *	5) A positive decimal number followed by a 'g' or 'G' (mult by 1 << 30).
481 *	6) A positive decimal number followed by a 't' or 'T' (mult by 1 << 40).
482 *	7) A positive decimal number followed by a 'p' or 'P' (mult by 1 << 50).
483 *	8) A positive decimal number followed by a 'w' or 'W' (mult by sizeof int).
484 *	9) Two or more positive decimal numbers (with/without [BbKkMmGgWw])
485 *	   separated by 'x' or 'X' (also '*' for backwards compatibility),
486 *	   specifying the product of the indicated values.
487 */
488static uintmax_t
489get_num(const char *val)
490{
491	uintmax_t num, mult, prevnum;
492	char *expr;
493
494	errno = 0;
495	num = strtoumax(val, &expr, 0);
496	if (expr == val)			/* No valid digits. */
497		errx(1, "%s: invalid numeric value", oper);
498	if (errno != 0)
499		err(1, "%s", oper);
500
501	mult = postfix_to_mult(*expr);
502
503	if (mult != 0) {
504		prevnum = num;
505		num *= mult;
506		/* Check for overflow. */
507		if (num / mult != prevnum)
508			goto erange;
509		expr++;
510	}
511
512	switch (*expr) {
513		case '\0':
514			break;
515		case '*':			/* Backward compatible. */
516		case 'X':
517		case 'x':
518			mult = get_num(expr + 1);
519			prevnum = num;
520			num *= mult;
521			if (num / mult == prevnum)
522				break;
523erange:
524			errx(1, "%s: %s", oper, strerror(ERANGE));
525		default:
526			errx(1, "%s: illegal numeric value", oper);
527	}
528	return (num);
529}
530
531/*
532 * Convert an expression of the following forms to an off_t.  This is the
533 * same as get_num(), but it uses signed numbers.
534 *
535 * The major problem here is that an off_t may not necessarily be a intmax_t.
536 */
537static off_t
538get_off_t(const char *val)
539{
540	intmax_t num, mult, prevnum;
541	char *expr;
542
543	errno = 0;
544	num = strtoimax(val, &expr, 0);
545	if (expr == val)			/* No valid digits. */
546		errx(1, "%s: invalid numeric value", oper);
547	if (errno != 0)
548		err(1, "%s", oper);
549
550	mult = postfix_to_mult(*expr);
551
552	if (mult != 0) {
553		prevnum = num;
554		num *= mult;
555		/* Check for overflow. */
556		if ((prevnum > 0) != (num > 0) || num / mult != prevnum)
557			goto erange;
558		expr++;
559	}
560
561	switch (*expr) {
562		case '\0':
563			break;
564		case '*':			/* Backward compatible. */
565		case 'X':
566		case 'x':
567			mult = (intmax_t)get_off_t(expr + 1);
568			prevnum = num;
569			num *= mult;
570			if ((prevnum > 0) == (num > 0) && num / mult == prevnum)
571				break;
572erange:
573			errx(1, "%s: %s", oper, strerror(ERANGE));
574		default:
575			errx(1, "%s: illegal numeric value", oper);
576	}
577	return (num);
578}
579