bin/dd/args.c

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