* de-__P()
[dragonfly.git] / bin / dd / args.c
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  * 3. All advertising materials mentioning features or use of this software
18  *    must display the following acknowledgement:
19  *      This product includes software developed by the University of
20  *      California, Berkeley and its contributors.
21  * 4. Neither the name of the University nor the names of its contributors
22  *    may be used to endorse or promote products derived from this software
23  *    without specific prior written permission.
24  *
25  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
26  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
28  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
29  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
30  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
31  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
32  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
33  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
34  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
35  * SUCH DAMAGE.
36  *
37  * @(#)args.c   8.3 (Berkeley) 4/2/94
38  * $FreeBSD: src/bin/dd/args.c,v 1.25.2.2 2001/01/23 14:20:03 asmodai Exp $
39  * $DragonFly: src/bin/dd/args.c,v 1.3 2003/09/21 04:19:42 drhodus Exp $
40  */
41
42 #include <sys/types.h>
43
44 #include <err.h>
45 #include <errno.h>
46 #include <limits.h>
47 #include <stdlib.h>
48 #include <string.h>
49
50 #include "dd.h"
51 #include "extern.h"
52
53 static int      c_arg (const void *, const void *);
54 static int      c_conv (const void *, const void *);
55 static void     f_bs (char *);
56 static void     f_cbs (char *);
57 static void     f_conv (char *);
58 static void     f_count (char *);
59 static void     f_files (char *);
60 static void     f_ibs (char *);
61 static void     f_if (char *);
62 static void     f_obs(char *);
63 static void     f_of (char *);
64 static void     f_seek (char *);
65 static void     f_skip (char *);
66 static quad_t   get_num (char *);
67 static off_t    get_offset (char *);
68
69 static const struct arg {
70         const char *name;
71         void (*f) (char *);
72         u_int set, noset;
73 } args[] = {
74         { "bs",         f_bs,           C_BS,    C_BS|C_IBS|C_OBS|C_OSYNC },
75         { "cbs",        f_cbs,          C_CBS,   C_CBS },
76         { "conv",       f_conv,         0,       0 },
77         { "count",      f_count,        C_COUNT, C_COUNT },
78         { "files",      f_files,        C_FILES, C_FILES },
79         { "ibs",        f_ibs,          C_IBS,   C_BS|C_IBS },
80         { "if",         f_if,           C_IF,    C_IF },
81         { "iseek",      f_skip,         C_SKIP,  C_SKIP },
82         { "obs",        f_obs,          C_OBS,   C_BS|C_OBS },
83         { "of",         f_of,           C_OF,    C_OF },
84         { "oseek",      f_seek,         C_SEEK,  C_SEEK },
85         { "seek",       f_seek,         C_SEEK,  C_SEEK },
86         { "skip",       f_skip,         C_SKIP,  C_SKIP },
87 };
88
89 static char *oper;
90
91 /*
92  * args -- parse JCL syntax of dd.
93  */
94 void
95 jcl(argv)
96         char **argv;
97 {
98         struct arg *ap, tmp;
99         char *arg;
100
101         in.dbsz = out.dbsz = 512;
102
103         while ((oper = *++argv) != NULL) {
104                 if ((oper = strdup(oper)) == NULL)
105                         errx(1, "unable to allocate space for the argument \"%s\"", *argv);
106                 if ((arg = strchr(oper, '=')) == NULL)
107                         errx(1, "unknown operand %s", oper);
108                 *arg++ = '\0';
109                 if (!*arg)
110                         errx(1, "no value specified for %s", oper);
111                 tmp.name = oper;
112                 if (!(ap = (struct arg *)bsearch(&tmp, args,
113                     sizeof(args)/sizeof(struct arg), sizeof(struct arg),
114                     c_arg)))
115                         errx(1, "unknown operand %s", tmp.name);
116                 if (ddflags & ap->noset)
117                         errx(1, "%s: illegal argument combination or already set",
118                             tmp.name);
119                 ddflags |= ap->set;
120                 ap->f(arg);
121         }
122
123         /* Final sanity checks. */
124
125         if (ddflags & C_BS) {
126                 /*
127                  * Bs is turned off by any conversion -- we assume the user
128                  * just wanted to set both the input and output block sizes
129                  * and didn't want the bs semantics, so we don't warn.
130                  */
131                 if (ddflags & (C_BLOCK | C_LCASE | C_SWAB | C_UCASE |
132                     C_UNBLOCK))
133                         ddflags &= ~C_BS;
134
135                 /* Bs supersedes ibs and obs. */
136                 if (ddflags & C_BS && ddflags & (C_IBS | C_OBS))
137                         warnx("bs supersedes ibs and obs");
138         }
139
140         /*
141          * Ascii/ebcdic and cbs implies block/unblock.
142          * Block/unblock requires cbs and vice-versa.
143          */
144         if (ddflags & (C_BLOCK | C_UNBLOCK)) {
145                 if (!(ddflags & C_CBS))
146                         errx(1, "record operations require cbs");
147                 if (cbsz == 0)
148                         errx(1, "cbs cannot be zero");
149                 cfunc = ddflags & C_BLOCK ? block : unblock;
150         } else if (ddflags & C_CBS) {
151                 if (ddflags & (C_ASCII | C_EBCDIC)) {
152                         if (ddflags & C_ASCII) {
153                                 ddflags |= C_UNBLOCK;
154                                 cfunc = unblock;
155                         } else {
156                                 ddflags |= C_BLOCK;
157                                 cfunc = block;
158                         }
159                 } else
160                         errx(1, "cbs meaningless if not doing record operations");
161         } else
162                 cfunc = def;
163
164         /*
165          * Bail out if the calculation of a file offset would overflow.
166          */
167         if (in.offset > QUAD_MAX / in.dbsz || out.offset > QUAD_MAX / out.dbsz)
168                 errx(1, "seek offsets cannot be larger than %qd", QUAD_MAX);
169 }
170
171 static int
172 c_arg(a, b)
173         const void *a, *b;
174 {
175
176         return (strcmp(((const struct arg *)a)->name,
177             ((const struct arg *)b)->name));
178 }
179
180 static void
181 f_bs(arg)
182         char *arg;
183 {
184         quad_t res;
185
186         res = get_num(arg);
187         if (res < 1 || res > SSIZE_MAX)
188                 errx(1, "bs must be between 1 and %d", SSIZE_MAX);
189         in.dbsz = out.dbsz = (size_t)res;
190 }
191
192 static void
193 f_cbs(arg)
194         char *arg;
195 {
196         quad_t res;
197
198         res = get_num(arg);
199         if (res < 1 || res > SSIZE_MAX)
200                 errx(1, "cbs must be between 1 and %d", SSIZE_MAX);
201         cbsz = (size_t)res;
202 }
203
204 static void
205 f_count(arg)
206         char *arg;
207 {
208
209         cpy_cnt = get_num(arg);
210         if (cpy_cnt < 0)
211                 errx(1, "count cannot be negative");
212         if (cpy_cnt == 0)
213                 cpy_cnt = -1;
214 }
215
216 static void
217 f_files(arg)
218         char *arg;
219 {
220
221         files_cnt = get_num(arg);
222         if (files_cnt < 1)
223                 errx(1, "files must be between 1 and %qd", QUAD_MAX);
224 }
225
226 static void
227 f_ibs(arg)
228         char *arg;
229 {
230         quad_t res;
231
232         if (!(ddflags & C_BS)) {
233                 res = get_num(arg);
234                 if (res < 1 || res > SSIZE_MAX)
235                         errx(1, "ibs must be between 1 and %d", SSIZE_MAX);
236                 in.dbsz = (size_t)res;
237         }
238 }
239
240 static void
241 f_if(arg)
242         char *arg;
243 {
244
245         in.name = arg;
246 }
247
248 static void
249 f_obs(arg)
250         char *arg;
251 {
252         quad_t res;
253
254         if (!(ddflags & C_BS)) {
255                 res = get_num(arg);
256                 if (res < 1 || res > SSIZE_MAX)
257                         errx(1, "obs must be between 1 and %d", SSIZE_MAX);
258                 out.dbsz = (size_t)res;
259         }
260 }
261
262 static void
263 f_of(arg)
264         char *arg;
265 {
266
267         out.name = arg;
268 }
269
270 static void
271 f_seek(arg)
272         char *arg;
273 {
274
275         out.offset = get_offset(arg);
276 }
277
278 static void
279 f_skip(arg)
280         char *arg;
281 {
282
283         in.offset = get_offset(arg);
284 }
285
286 static const struct conv {
287         const char *name;
288         u_int set, noset;
289         const u_char *ctab;
290 } clist[] = {
291         { "ascii",      C_ASCII,        C_EBCDIC,       e2a_POSIX },
292         { "block",      C_BLOCK,        C_UNBLOCK,      NULL },
293         { "ebcdic",     C_EBCDIC,       C_ASCII,        a2e_POSIX },
294         { "ibm",        C_EBCDIC,       C_ASCII,        a2ibm_POSIX },
295         { "lcase",      C_LCASE,        C_UCASE,        NULL },
296         { "noerror",    C_NOERROR,      0,              NULL },
297         { "notrunc",    C_NOTRUNC,      0,              NULL },
298         { "oldascii",   C_ASCII,        C_EBCDIC,       e2a_32V },
299         { "oldebcdic",  C_EBCDIC,       C_ASCII,        a2e_32V },
300         { "oldibm",     C_EBCDIC,       C_ASCII,        a2ibm_32V },
301         { "osync",      C_OSYNC,        C_BS,           NULL },
302         { "sparse",     C_SPARSE,       0,              NULL },
303         { "swab",       C_SWAB,         0,              NULL },
304         { "sync",       C_SYNC,         0,              NULL },
305         { "ucase",      C_UCASE,        C_LCASE,        NULL },
306         { "unblock",    C_UNBLOCK,      C_BLOCK,        NULL },
307 };
308
309 static void
310 f_conv(arg)
311         char *arg;
312 {
313         struct conv *cp, tmp;
314
315         while (arg != NULL) {
316                 tmp.name = strsep(&arg, ",");
317                 cp = bsearch(&tmp, clist, sizeof(clist) / sizeof(struct conv),
318                     sizeof(struct conv), c_conv);
319                 if (cp == NULL)
320                         errx(1, "unknown conversion %s", tmp.name);
321                 if (ddflags & cp->noset)
322                         errx(1, "%s: illegal conversion combination", tmp.name);
323                 ddflags |= cp->set;
324                 if (cp->ctab)
325                         ctab = cp->ctab;
326         }
327 }
328
329 static int
330 c_conv(a, b)
331         const void *a, *b;
332 {
333
334         return (strcmp(((const struct conv *)a)->name,
335             ((const struct conv *)b)->name));
336 }
337
338 /*
339  * Convert an expression of the following forms to a quad_t.
340  *      1) A positive decimal number.
341  *      2) A positive decimal number followed by a b (mult by 512.)
342  *      3) A positive decimal number followed by a k (mult by 1 << 10.)
343  *      4) A positive decimal number followed by a m (mult by 1 << 20.)
344  *      5) A positive decimal number followed by a g (mult by 1 << 30.)
345  *      5) A positive decimal number followed by a w (mult by sizeof int.)
346  *      6) Two or more positive decimal numbers (with/without [bkmgw])
347  *         separated by x (also * for backwards compatibility), specifying
348  *         the product of the indicated values.
349  */
350 static quad_t
351 get_num(val)
352         char *val;
353 {
354         quad_t num, t;
355         char *expr;
356
357         errno = 0;
358         num = strtoq(val, &expr, 0);
359         if (errno != 0)                         /* Overflow or underflow. */
360                 err(1, "%s", oper);
361         
362         if (expr == val)                        /* No valid digits. */
363                 errx(1, "%s: illegal numeric value", oper);
364
365         switch (*expr) {
366         case 'b':
367                 t = num;
368                 num *= 512;
369                 if (t > num)
370                         goto erange;
371                 ++expr;
372                 break;
373         case 'k':
374                 t = num;
375                 num *= 1 << 10;
376                 if (t > num)
377                         goto erange;
378                 ++expr;
379                 break;
380         case 'm':
381                 t = num;
382                 num *= 1 << 20;
383                 if (t > num)
384                         goto erange;
385                 ++expr;
386                 break;
387         case 'g':
388                 t = num;
389                 num *= 1 << 30;
390                 if (t > num)
391                         goto erange;
392                 ++expr;
393                 break;
394         case 'w':
395                 t = num;
396                 num *= sizeof(int);
397                 if (t > num)
398                         goto erange;
399                 ++expr;
400                 break;
401         }
402
403         switch (*expr) {
404                 case '\0':
405                         break;
406                 case '*':                       /* Backward compatible. */
407                 case 'x':
408                         t = num;
409                         num *= get_num(expr + 1);
410                         if (t <= num)
411                                 break;
412 erange:
413                         errx(1, "%s: %s", oper, strerror(ERANGE));
414                 default:
415                         errx(1, "%s: illegal numeric value", oper);
416         }
417         return (num);
418 }
419
420 static off_t
421 get_offset(val)
422         char *val;
423 {
424         quad_t num;
425
426         num = get_num(val);
427         if (num > QUAD_MAX)     /* XXX can't happen && quad_t != off_t */
428                 errx(1, "%s: illegal offset", oper);    /* Too big. */
429         return ((off_t)num);
430 }