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 8USE_DD(NEWTOY(dd, 0, TOYFLAG_USR|TOYFLAG_BIN)) 9 10config DD 11 bool "dd" 12 default n 13 help 14 usage: dd [if=FILE] [of=FILE] [ibs=N] [obs=N] [iflag=FLAGS] [oflag=FLAGS] 15 [bs=N] [count=N] [seek=N] [skip=N] 16 [conv=notrunc|noerror|sync|fsync] [status=noxfer|none] 17 18 Copy/convert files. 19 20 if=FILE Read from FILE instead of stdin 21 of=FILE Write to FILE instead of stdout 22 bs=N Read and write N bytes at a time 23 ibs=N Input block size 24 obs=N Output block size 25 count=N Copy only N input blocks 26 skip=N Skip N input blocks 27 seek=N Skip N output blocks 28 iflag=FLAGS Set input flags 29 oflag=FLAGS Set output flags 30 conv=notrunc Don't truncate output file 31 conv=noerror Continue after read errors 32 conv=sync Pad blocks with zeros 33 conv=fsync Physically write data out before finishing 34 status=noxfer Don't show transfer rate 35 status=none Don't show transfer rate or records in/out 36 37 FLAGS is a comma-separated list of: 38 39 count_bytes (iflag) interpret count=N in bytes, not blocks 40 seek_bytes (oflag) interpret seek=N in bytes, not blocks 41 skip_bytes (iflag) interpret skip=N in bytes, not blocks 42 43 Numbers may be suffixed by c (*1), w (*2), b (*512), kD (*1000), k (*1024), 44 MD (*1000*1000), M (*1024*1024), GD (*1000*1000*1000) or G (*1024*1024*1024). 45*/ 46 47#define FOR_dd 48#include "toys.h" 49#define BS_MAX_SIZE INT32_MAX 50 51GLOBALS( 52 int show_xfer, show_records; 53 unsigned long long bytes, c_count, in_full, in_part, out_full, out_part; 54 struct timeval start; 55 struct { 56 char *name; 57 int fd; 58 unsigned char *buff, *bp; 59 long sz, count; 60 unsigned long long offset; 61 } in, out; 62 unsigned conv, iflag, oflag; 63); 64 65struct dd_flag { 66 char *name; 67}; 68 69static const struct dd_flag dd_conv[] = TAGGED_ARRAY(DD_conv, 70 {"fsync"}, {"noerror"}, {"notrunc"}, {"sync"}, 71); 72 73static const struct dd_flag dd_iflag[] = TAGGED_ARRAY(DD_iflag, 74 {"count_bytes"}, {"skip_bytes"}, 75); 76 77static const struct dd_flag dd_oflag[] = TAGGED_ARRAY(DD_oflag, 78 {"seek_bytes"}, 79); 80 81static void status() 82{ 83 double seconds; 84 struct timeval now; 85 86 gettimeofday(&now, NULL); 87 seconds = ((now.tv_sec * 1000000 + now.tv_usec) - 88 (TT.start.tv_sec * 1000000 + TT.start.tv_usec))/1000000.0; 89 90 if (TT.show_records) 91 fprintf(stderr, "%llu+%llu records in\n%llu+%llu records out\n", 92 TT.in_full, TT.in_part, TT.out_full, TT.out_part); 93 94 if (TT.show_xfer) { 95 human_readable(toybuf, TT.bytes, HR_SPACE|HR_B); 96 fprintf(stderr, "%llu bytes (%s) copied, ", TT.bytes, toybuf); 97 human_readable(toybuf, TT.bytes/seconds, HR_SPACE|HR_B); 98 fprintf(stderr, "%f s, %s/s\n", seconds, toybuf); 99 } 100} 101 102static void dd_sigint(int sig) { 103 status(); 104 toys.exitval = sig|128; 105 xexit(); 106} 107 108static void write_out(int all) 109{ 110 TT.out.bp = TT.out.buff; 111 while (TT.out.count) { 112 ssize_t nw = writeall(TT.out.fd, TT.out.bp, ((all)? TT.out.count : TT.out.sz)); 113 114 all = 0; //further writes will be on obs 115 if (nw <= 0) perror_exit("%s: write error", TT.out.name); 116 if (nw == TT.out.sz) TT.out_full++; 117 else TT.out_part++; 118 TT.out.count -= nw; 119 TT.out.bp += nw; 120 TT.bytes += nw; 121 if (TT.out.count < TT.out.sz) break; 122 } 123 if (TT.out.count) memmove(TT.out.buff, TT.out.bp, TT.out.count); //move remainder to front 124} 125 126static void parse_flags(char *what, char *arg, 127 const struct dd_flag* flags, int flag_count, unsigned *result) 128{ 129 char *pre = xstrdup(arg); 130 int i; 131 132 for (i=0; i<flag_count; ++i) { 133 while (comma_remove(pre, flags[i].name)) *result |= 1<<i; 134 } 135 if (*pre) error_exit("bad %s=%s", what, pre); 136 free(pre); 137} 138 139void dd_main() 140{ 141 char **args; 142 unsigned long long bs = 0; 143 int trunc = O_TRUNC; 144 145 TT.show_xfer = TT.show_records = 1; 146 TT.c_count = ULLONG_MAX; 147 148 TT.in.sz = TT.out.sz = 512; //default io block size 149 for (args = toys.optargs; *args; args++) { 150 char *arg = *args; 151 152 // set BS_MAX_SIZE to 1073741824(1G) to avoid malloc too much space later. 153 if (strstart(&arg, "bs=")) bs = atolx_range(arg, 1, BS_MAX_SIZE); 154 else if (strstart(&arg, "ibs=")) TT.in.sz = atolx_range(arg, 1, BS_MAX_SIZE); 155 else if (strstart(&arg, "obs=")) TT.out.sz = atolx_range(arg, 1, BS_MAX_SIZE); 156 else if (strstart(&arg, "count=")) 157 TT.c_count = atolx_range(arg, 0, LLONG_MAX); 158 else if (strstart(&arg, "if=")) TT.in.name = arg; 159 else if (strstart(&arg, "of=")) TT.out.name = arg; 160 else if (strstart(&arg, "seek=")) 161 TT.out.offset = atolx_range(arg, 0, LLONG_MAX); 162 else if (strstart(&arg, "skip=")) 163 TT.in.offset = atolx_range(arg, 0, LLONG_MAX); 164 else if (strstart(&arg, "status=")) { 165 if (!strcmp(arg, "noxfer")) TT.show_xfer = 0; 166 else if (!strcmp(arg, "none")) TT.show_xfer = TT.show_records = 0; 167 else error_exit("unknown status '%s'", arg); 168 } else if (strstart(&arg, "conv=")) { 169 parse_flags("conv", arg, dd_conv, ARRAY_LEN(dd_conv), &TT.conv); 170 fprintf(stderr, "conv=%x\n", TT.conv); 171 } else if (strstart(&arg, "iflag=")) 172 parse_flags("iflag", arg, dd_iflag, ARRAY_LEN(dd_iflag), &TT.iflag); 173 else if (strstart(&arg, "oflag=")) 174 parse_flags("oflag", arg, dd_oflag, ARRAY_LEN(dd_oflag), &TT.oflag); 175 else error_exit("bad arg %s", arg); 176 } 177 if (bs) TT.in.sz = TT.out.sz = bs; 178 179 signal(SIGINT, dd_sigint); 180 signal(SIGUSR1, generic_signal); 181 gettimeofday(&TT.start, NULL); 182 183 // For bs=, in/out is done as it is. so only in.sz is enough. 184 // With Single buffer there will be overflow in a read following partial read. 185 TT.in.buff = TT.out.buff = xmalloc(TT.in.sz + (bs ? 0 : TT.out.sz)); 186 TT.in.bp = TT.out.bp = TT.in.buff; 187 188 if (!TT.in.name) TT.in.name = "stdin"; 189 else TT.in.fd = xopenro(TT.in.name); 190 191 if (TT.conv & _DD_conv_notrunc) trunc = 0; 192 193 if (!TT.out.name) { 194 TT.out.name = "stdout"; 195 TT.out.fd = 1; 196 } else TT.out.fd = xcreate(TT.out.name, 197 O_WRONLY|O_CREAT|(trunc*!TT.out.offset), 0666); 198 199 // Implement skip= 200 if (TT.in.offset) { 201 off_t off = TT.in.offset; 202 203 if (!(TT.iflag & _DD_iflag_skip_bytes)) off *= TT.in.sz; 204 if (lseek(TT.in.fd, off, SEEK_CUR) < 0) { 205 while (off > 0) { 206 int chunk = off < TT.in.sz ? off : TT.in.sz; 207 ssize_t n = read(TT.in.fd, TT.in.bp, chunk); 208 209 if (n < 0) { 210 perror_msg("%s", TT.in.name); 211 if (TT.conv & _DD_conv_noerror) status(); 212 else return; 213 } else if (!n) { 214 xprintf("%s: Can't skip\n", TT.in.name); 215 return; 216 } 217 off -= n; 218 } 219 } 220 } 221 222 // Implement seek= and truncate as necessary. We handled position zero 223 // truncate with O_TRUNC on open, so output to /dev/null and such doesn't 224 // error. 225 bs = TT.out.offset; 226 if (!(TT.oflag & _DD_oflag_seek_bytes)) bs *= TT.out.sz; 227 if (bs) { 228 xlseek(TT.out.fd, bs, SEEK_CUR); 229 if (trunc && ftruncate(TT.out.fd, bs)) perror_exit("ftruncate"); 230 } 231 232 unsigned long long bytes_left = TT.c_count; 233 if (TT.c_count != ULLONG_MAX && !(TT.iflag & _DD_iflag_count_bytes)) { 234 bytes_left *= TT.in.sz; 235 } 236 while (bytes_left) { 237 int chunk = bytes_left < TT.in.sz ? bytes_left : TT.in.sz; 238 ssize_t n; 239 240 // Show progress and exit on SIGINT or just continue on SIGUSR1. 241 if (toys.signal) { 242 status(); 243 if (toys.signal==SIGINT) exit_signal(toys.signal); 244 toys.signal = 0; 245 } 246 247 TT.in.bp = TT.in.buff + TT.in.count; 248 if (TT.conv & _DD_conv_sync) memset(TT.in.bp, 0, TT.in.sz); 249 if (!(n = read(TT.in.fd, TT.in.bp, chunk))) break; 250 if (n < 0) { 251 if (errno == EINTR) continue; 252 //read error case. 253 perror_msg("%s: read error", TT.in.name); 254 if (!(TT.conv & _DD_conv_noerror)) exit(1); 255 status(); 256 xlseek(TT.in.fd, TT.in.sz, SEEK_CUR); 257 if (!(TT.conv & _DD_conv_sync)) continue; 258 // if SYNC, then treat as full block of nuls 259 n = TT.in.sz; 260 } 261 if (n == TT.in.sz) { 262 TT.in_full++; 263 TT.in.count += n; 264 } else { 265 TT.in_part++; 266 if (TT.conv & _DD_conv_sync) TT.in.count += TT.in.sz; 267 else TT.in.count += n; 268 } 269 bytes_left -= n; 270 271 TT.out.count = TT.in.count; 272 if (bs) { 273 write_out(1); 274 TT.in.count = 0; 275 continue; 276 } 277 278 if (TT.in.count >= TT.out.sz) { 279 write_out(0); 280 TT.in.count = TT.out.count; 281 } 282 } 283 if (TT.out.count) write_out(1); //write any remaining input blocks 284 if ((TT.conv & _DD_conv_fsync) && fsync(TT.out.fd)<0) 285 perror_exit("%s: fsync", TT.out.name); 286 287 close(TT.in.fd); 288 close(TT.out.fd); 289 if (TT.in.buff) free(TT.in.buff); 290 291 status(); 292} 293