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