toys/pending/dd.c

   1 /* dd.c - program to convert and copy a file.
   2  *
   3  * Copyright 2013 Ashwini Kumar <ak.ashwini@gmail.com>
   4  * Copyright 2013 Kyungwan Han <asura321@gmail.com>
   5  *
   6  * See  http://opengroup.org/onlinepubs/9699919799/utilities/dd.html
   7 USE_DD(NEWTOY(dd, NULL, TOYFLAG_USR|TOYFLAG_BIN))
   8
   9 config DD
  10   bool "dd"
  11   default n
  12     help
  13     usage: dd [if=FILE] [of=FILE] [ibs=N] [obs=N] [bs=N] [count=N] [skip=N]
  14             [seek=N] [conv=notrunc|noerror|sync|fsync]
  15
  16     Options:
  17     if=FILE   Read from FILE instead of stdin
  18     of=FILE   Write to FILE instead of stdout
  19     bs=N      Read and write N bytes at a time
  20     ibs=N     Read N bytes at a time
  21     obs=N     Write N bytes at a time
  22     count=N   Copy only N input blocks
  23     skip=N    Skip N input blocks
  24     seek=N    Skip N output blocks
  25     conv=notrunc  Don't truncate output file
  26     conv=noerror  Continue after read errors
  27     conv=sync     Pad blocks with zeros
  28     conv=fsync    Physically write data out before finishing
  29
  30     Numbers may be suffixed by c (x1), w (x2), b (x512), kD (x1000), k (x1024),
  31     MD (x1000000), M (x1048576), GD (x1000000000) or G (x1073741824)
  32     Copy a file, converting and formatting according to the operands.
  33 */
  34 #define FOR_dd
  35 #include "toys.h"
  36
  37 GLOBALS(
  38   int sig;
  39 )
  40 #define C_CONV    0x0000
  41 #define C_BS      0x0001
  42 #define C_COUNT   0x0002
  43 #define C_IBS     0x0004
  44 #define C_OBS     0x0008
  45 #define C_IF      0x0010
  46 #define C_OF      0x0020
  47 #define C_SEEK    0x0040
  48 #define C_SKIP    0x0080
  49 #define C_SYNC    0x0100
  50 #define C_FSYNC   0x0200
  51 #define C_NOERROR 0x0400
  52 #define C_NOTRUNC 0x0800
  53
  54 struct io {
  55   char *name;
  56   int fd;
  57   unsigned char *buff, *bp;
  58   long sz, count;
  59   unsigned long long offset;
  60 };
  61
  62 struct iostat {
  63   unsigned long long in_full, in_part, out_full, out_part, bytes;
  64   struct timeval start;
  65 };
  66
  67 struct pair {
  68   char *name;
  69   unsigned val;
  70 };
  71
  72 static struct pair suffixes[] = {
  73   { "c", 1 }, { "w", 2 }, { "b", 512 },
  74   { "kD", 1000 }, { "k", 1024 }, { "K", 1024 },
  75   { "MD", 1000000 }, { "M", 1048576 },
  76   { "GD", 1000000000 }, { "G", 1073741824 }
  77 };
  78
  79 static struct pair clist[] = {
  80   { "fsync",    C_FSYNC },
  81   { "noerror",  C_NOERROR },
  82   { "notrunc",  C_NOTRUNC },
  83   { "sync",     C_SYNC },
  84 };
  85
  86 static struct pair operands[] = {
  87   // keep the array sorted by name, bsearch() can be used.
  88   { "bs",    C_BS   },
  89   { "conv",  C_CONV },
  90   { "count", C_COUNT},
  91   { "ibs",   C_IBS  },
  92   { "if",    C_IF   },
  93   { "obs",   C_OBS  },
  94   { "of",    C_OF   },
  95   { "seek",  C_SEEK },
  96   { "skip",  C_SKIP },
  97 };
  98
  99 static struct io in, out;
 100 static struct iostat st;
 101 static unsigned long long c_count;
 102
 103 static unsigned long long strsuftoll(char* arg, int def, unsigned long long max)
 104 {
 105   unsigned long long result;
 106   char *endp, *ch = arg;
 107   int i, idx = -1;
 108   errno = 0;
 109
 110   while (isspace(*ch)) ch++;
 111   if (*ch == '-') error_exit("invalid number '%s'",arg);
 112   result = strtoull(arg, &endp, 10);
 113   if (errno == ERANGE || result > max || result < def)
 114     perror_exit("invalid number '%s'",arg);
 115   if (*endp != '\0') {
 116     for (i = 0; i < ARRAY_LEN(suffixes); i++)
 117       if (!strcmp(endp, suffixes[i].name)) idx = i;
 118     if (idx == -1 || (max/suffixes[idx].val < result))
 119       error_exit("invalid number '%s'",arg);
 120     result = result* suffixes[idx].val;
 121   }
 122   return result;
 123 }
 124
 125 static void summary()
 126 {
 127   double seconds = 5.0;
 128   struct timeval now;
 129
 130   gettimeofday(&now, NULL);
 131   seconds = ((now.tv_sec * 1000000 + now.tv_usec) - (st.start.tv_sec * 1000000
 132         + st.start.tv_usec))/1000000.0;
 133   //out to STDERR
 134   fprintf(stderr,"%llu+%llu records in\n%llu+%llu records out\n", st.in_full, st.in_part,
 135       st.out_full, st.out_part);
 136   fprintf(stderr, "%llu bytes (%sB) copied,",st.bytes, human_readable(st.bytes));
 137   fprintf(stderr, "%f seconds, %sB/s\n", seconds, human_readable(st.bytes/seconds));
 138 }
 139
 140 static void sig_handler(int sig)
 141 {
 142   TT.sig = sig;
 143 }
 144
 145 static int xmove_fd(int fd)
 146 {
 147   int newfd;
 148
 149   if (fd > STDERR_FILENO) return fd;
 150   if ((newfd = fcntl(fd, F_DUPFD, 3) < 0)) perror_exit("dupfd IO");
 151   close(fd);
 152   return newfd;
 153 }
 154
 155 static void setup_inout()
 156 {
 157   ssize_t n;
 158
 159   /* for C_BS, in/out is done as it is. so only in.sz is enough.
 160    * With Single buffer there will be overflow in a read following partial read
 161    */
 162   in.buff = out.buff = xmalloc(in.sz + ((toys.optflags & C_BS)? 0: out.sz));
 163   in.bp = out.bp = in.buff;
 164   atexit(summary);
 165   //setup input
 166   if (!in.name) {
 167     in.name = "stdin";
 168     in.fd = STDIN_FILENO;
 169   } else {
 170     in.fd = xopen(in.name, O_RDONLY);
 171     in.fd = xmove_fd(in.fd);
 172   }
 173   //setup outout
 174   if (!out.name) {
 175     out.name = "stdout";
 176     out.fd = STDOUT_FILENO;
 177   } else {
 178     out.fd = xcreate(out.name, O_WRONLY | O_CREAT, 0666);
 179     out.fd = xmove_fd(out.fd);
 180   }
 181
 182   if (in.offset) {
 183     if (lseek(in.fd, (off_t)(in.offset * in.sz), SEEK_CUR) < 0) {
 184       while (in.offset--) {
 185         if ((n = read(in.fd, in.bp, in.sz)) < 0) {
 186           if (toys.optflags & C_NOERROR) { //warn message and summary
 187             error_msg("%s: read error", in.name);
 188             summary();
 189           } else perror_exit("%s: read error", in.name);
 190         } else if (!n) {
 191           xprintf("%s: Can't skip\n", in.name);
 192           exit(0);
 193         }
 194       }
 195     }
 196   }
 197
 198   if (out.offset) xlseek(out.fd, (off_t)(out.offset * out.sz), SEEK_CUR);
 199 }
 200
 201 static void write_out(int all)
 202 {
 203   ssize_t nw;
 204   out.bp = out.buff;
 205   while (out.count) {
 206     nw = writeall(out.fd, out.bp, ((all)? out.count : out.sz));
 207     all = 0; //further writes will be on obs
 208     if (nw <= 0) perror_exit("%s: write error",out.name);
 209     if (nw == out.sz) st.out_full++;
 210     else st.out_part++;
 211     out.count -= nw;
 212     out.bp += nw;
 213     st.bytes += nw;
 214     if (out.count < out.sz) break;
 215   }
 216   if (out.count) memmove(out.buff, out.bp, out.count); //move remainder to front
 217 }
 218
 219 static void do_dd(void)
 220 {
 221   ssize_t n;
 222   struct sigaction sa;
 223
 224   memset(&sa, 0, sizeof(sa));
 225   sa.sa_handler = sig_handler;
 226   sigaction(SIGINT, &sa, NULL);
 227   sigaction(SIGUSR1, &sa, NULL);
 228   setup_inout();
 229   gettimeofday(&st.start, NULL);
 230
 231   if (toys.optflags & (C_OF | C_SEEK) && !(toys.optflags & C_NOTRUNC))
 232     ftruncate(out.fd, (off_t)out.offset * out.sz);
 233
 234   while (!(toys.optflags & C_COUNT) || (st.in_full + st.in_part) < c_count) {
 235     if (TT.sig == SIGUSR1) {
 236       summary();
 237       TT.sig = 0;
 238     } else if (TT.sig == SIGINT) exit(TT.sig | 128);
 239     in.bp = in.buff + in.count;
 240     if (toys.optflags & C_SYNC) memset(in.bp, 0, in.sz);
 241     if (!(n = read(in.fd, in.bp, in.sz))) break;
 242     if (n < 0) {
 243       if (errno == EINTR) continue;
 244       //read error case.
 245       perror_msg("%s: read error", in.name);
 246       if (!(toys.optflags & C_NOERROR)) exit(1);
 247       summary();
 248       xlseek(in.fd, in.sz, SEEK_CUR);
 249       if (!(toys.optflags & C_SYNC)) continue;
 250       // if SYNC, then treat as full block of nuls
 251       n = in.sz;
 252     }
 253     if (n == in.sz) {
 254       st.in_full++;
 255       in.count += n;
 256     } else {
 257       st.in_part++;
 258       if (toys.optflags & C_SYNC) in.count += in.sz;
 259       else in.count += n;
 260     }
 261
 262     out.count = in.count;
 263     if (toys.optflags & C_BS) {
 264       write_out(1);
 265       in.count = 0;
 266       continue;
 267     }
 268
 269     if (in.count >= out.sz) {
 270       write_out(0);
 271       in.count = out.count;
 272     }
 273   }
 274   if (out.count) write_out(1); //write any remaining input blocks
 275   if (toys.optflags & C_FSYNC && fsync(out.fd) < 0)
 276     perror_exit("%s: fsync fail", out.name);
 277
 278   close(in.fd);
 279   close(out.fd);
 280   if (in.buff) free(in.buff);
 281 }
 282
 283 static int comp(const void *a, const void *b) //const to shut compiler up
 284 {
 285   return strcmp(((struct pair*)a)->name, ((struct pair*)b)->name);
 286 }
 287
 288 void dd_main()
 289 {
 290   struct pair *res, key;
 291   char *arg;
 292   long sz;
 293
 294   in.sz = out.sz = 512; //default io block size
 295   while (*toys.optargs) {
 296     if (!(arg = strchr(*toys.optargs, '='))) error_exit("unknown arg %s", *toys.optargs);
 297     *arg++ = '\0';
 298     if (!*arg) {
 299       toys.exithelp = 1;
 300       error_exit("");
 301     }
 302     key.name = *toys.optargs;
 303     if (!(res = bsearch(&key, operands, ARRAY_LEN(operands), sizeof(struct pair),
 304             comp))) error_exit("unknown arg %s", key.name);
 305
 306     toys.optflags |= res->val;
 307     switch(res->val) {
 308       case C_BS:
 309         in.sz = out.sz = strsuftoll(arg, 1, LONG_MAX);
 310         break;
 311       case C_IBS:
 312         sz = strsuftoll(arg, 1, LONG_MAX);
 313         if (!(toys.optflags & C_BS)) in.sz = sz;
 314         break;
 315       case C_OBS:
 316         sz = strsuftoll(arg, 1, LONG_MAX);
 317         if (!(toys.optflags & C_BS)) out.sz = sz;
 318         break;
 319       case C_COUNT:
 320         c_count = strsuftoll(arg, 0, ULLONG_MAX);
 321         break;
 322       case C_IF:
 323         in.name = arg;
 324         break;
 325       case C_OF:
 326         out.name = arg;
 327         break;
 328       case C_SEEK:
 329         out.offset = strsuftoll(arg, 0, ULLONG_MAX);
 330         break;
 331       case C_SKIP:
 332         in.offset = strsuftoll(arg, 0, ULLONG_MAX);
 333         break;
 334       case C_CONV:
 335         while (arg) {
 336           key.name = strsep(&arg, ",");
 337           if (!(res = bsearch(&key, clist, ARRAY_LEN(clist),
 338                   sizeof(struct pair), comp)))
 339             error_exit("unknown conversion %s", key.name);
 340
 341           toys.optflags |= res->val;
 342         }
 343         break;
 344     }
 345     toys.optargs++;
 346   }
 347
 348   do_dd();
 349 }