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