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