Mercurial > hg > toybox
annotate toys/pending/dd.c @ 1613:96aa7ec74936 draft
Fix yet another sed bug.
The s/// command would copy the \ of substitutions before deciding what to
do with them (generally overwriting the \ with the new data). When the
substitution was A) at the very end of the new string, B) resolved to nothing,
it could leave a trailing \ that didn't belong there and didn't get overwritten
because the "copy trailing data" part that copies the original string's null
terminator already happened before the \ overwrote it.
The ghostwheel() function restarts regexes after embedded NUL bytes, but
if the string it's passed is _longer_ than the length it's told then it
gets confused (and it means we're off the end of our allocation so segfaults
are likely).
Fix: test for \ first and move the "copy byte" logic into an else case.
| author | Rob Landley <rob@landley.net> |
|---|---|
| date | Mon, 15 Dec 2014 03:34:55 -0600 |
| parents | d48bdc1cb017 |
| children | 8f59893165fa |
| rev | line source |
|---|---|
| 1116 | 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); | |
|
1276
d48bdc1cb017
Switch human_readable() to just outputing decimal kilo/mega/gigabytes, make du use it, move it from lib/pending.c to lib.c.
Rob Landley <rob@landley.net>
parents:
1116
diff
changeset
|
136 human_readable(toybuf, st.bytes); |
|
d48bdc1cb017
Switch human_readable() to just outputing decimal kilo/mega/gigabytes, make du use it, move it from lib/pending.c to lib.c.
Rob Landley <rob@landley.net>
parents:
1116
diff
changeset
|
137 fprintf(stderr, "%llu bytes (%s) copied,",st.bytes, toybuf); |
|
d48bdc1cb017
Switch human_readable() to just outputing decimal kilo/mega/gigabytes, make du use it, move it from lib/pending.c to lib.c.
Rob Landley <rob@landley.net>
parents:
1116
diff
changeset
|
138 human_readable(toybuf, st.bytes/seconds); |
|
d48bdc1cb017
Switch human_readable() to just outputing decimal kilo/mega/gigabytes, make du use it, move it from lib/pending.c to lib.c.
Rob Landley <rob@landley.net>
parents:
1116
diff
changeset
|
139 fprintf(stderr, "%f seconds, %s/s\n", seconds, toybuf); |
| 1116 | 140 } |
| 141 | |
| 142 static void sig_handler(int sig) | |
| 143 { | |
| 144 TT.sig = sig; | |
| 145 } | |
| 146 | |
| 147 static int xmove_fd(int fd) | |
| 148 { | |
| 149 int newfd; | |
| 150 | |
| 151 if (fd > STDERR_FILENO) return fd; | |
| 152 if ((newfd = fcntl(fd, F_DUPFD, 3) < 0)) perror_exit("dupfd IO"); | |
| 153 close(fd); | |
| 154 return newfd; | |
| 155 } | |
| 156 | |
| 157 static void setup_inout() | |
| 158 { | |
| 159 ssize_t n; | |
| 160 | |
| 161 /* for C_BS, in/out is done as it is. so only in.sz is enough. | |
| 162 * With Single buffer there will be overflow in a read following partial read | |
| 163 */ | |
| 164 in.buff = out.buff = xmalloc(in.sz + ((toys.optflags & C_BS)? 0: out.sz)); | |
| 165 in.bp = out.bp = in.buff; | |
| 166 atexit(summary); | |
| 167 //setup input | |
| 168 if (!in.name) { | |
| 169 in.name = "stdin"; | |
| 170 in.fd = STDIN_FILENO; | |
| 171 } else { | |
| 172 in.fd = xopen(in.name, O_RDONLY); | |
| 173 in.fd = xmove_fd(in.fd); | |
| 174 } | |
| 175 //setup outout | |
| 176 if (!out.name) { | |
| 177 out.name = "stdout"; | |
| 178 out.fd = STDOUT_FILENO; | |
| 179 } else { | |
| 180 out.fd = xcreate(out.name, O_WRONLY | O_CREAT, 0666); | |
| 181 out.fd = xmove_fd(out.fd); | |
| 182 } | |
| 183 | |
| 184 if (in.offset) { | |
| 185 if (lseek(in.fd, (off_t)(in.offset * in.sz), SEEK_CUR) < 0) { | |
| 186 while (in.offset--) { | |
| 187 if ((n = read(in.fd, in.bp, in.sz)) < 0) { | |
| 188 if (toys.optflags & C_NOERROR) { //warn message and summary | |
| 189 error_msg("%s: read error", in.name); | |
| 190 summary(); | |
| 191 } else perror_exit("%s: read error", in.name); | |
| 192 } else if (!n) { | |
| 193 xprintf("%s: Can't skip\n", in.name); | |
| 194 exit(0); | |
| 195 } | |
| 196 } | |
| 197 } | |
| 198 } | |
| 199 | |
| 200 if (out.offset) xlseek(out.fd, (off_t)(out.offset * out.sz), SEEK_CUR); | |
| 201 } | |
| 202 | |
| 203 static void write_out(int all) | |
| 204 { | |
| 205 ssize_t nw; | |
| 206 out.bp = out.buff; | |
| 207 while (out.count) { | |
| 208 nw = writeall(out.fd, out.bp, ((all)? out.count : out.sz)); | |
| 209 all = 0; //further writes will be on obs | |
| 210 if (nw <= 0) perror_exit("%s: write error",out.name); | |
| 211 if (nw == out.sz) st.out_full++; | |
| 212 else st.out_part++; | |
| 213 out.count -= nw; | |
| 214 out.bp += nw; | |
| 215 st.bytes += nw; | |
| 216 if (out.count < out.sz) break; | |
| 217 } | |
| 218 if (out.count) memmove(out.buff, out.bp, out.count); //move remainder to front | |
| 219 } | |
| 220 | |
| 221 static void do_dd(void) | |
| 222 { | |
| 223 ssize_t n; | |
| 224 struct sigaction sa; | |
| 225 | |
| 226 memset(&sa, 0, sizeof(sa)); | |
| 227 sa.sa_handler = sig_handler; | |
| 228 sigaction(SIGINT, &sa, NULL); | |
| 229 sigaction(SIGUSR1, &sa, NULL); | |
| 230 setup_inout(); | |
| 231 gettimeofday(&st.start, NULL); | |
| 232 | |
| 233 if (toys.optflags & (C_OF | C_SEEK) && !(toys.optflags & C_NOTRUNC)) | |
| 234 ftruncate(out.fd, (off_t)out.offset * out.sz); | |
| 235 | |
| 236 while (!(toys.optflags & C_COUNT) || (st.in_full + st.in_part) < c_count) { | |
| 237 if (TT.sig == SIGUSR1) { | |
| 238 summary(); | |
| 239 TT.sig = 0; | |
| 240 } else if (TT.sig == SIGINT) exit(TT.sig | 128); | |
| 241 in.bp = in.buff + in.count; | |
| 242 if (toys.optflags & C_SYNC) memset(in.bp, 0, in.sz); | |
| 243 if (!(n = read(in.fd, in.bp, in.sz))) break; | |
| 244 if (n < 0) { | |
| 245 if (errno == EINTR) continue; | |
| 246 //read error case. | |
| 247 perror_msg("%s: read error", in.name); | |
| 248 if (!(toys.optflags & C_NOERROR)) exit(1); | |
| 249 summary(); | |
| 250 xlseek(in.fd, in.sz, SEEK_CUR); | |
| 251 if (!(toys.optflags & C_SYNC)) continue; | |
| 252 // if SYNC, then treat as full block of nuls | |
| 253 n = in.sz; | |
| 254 } | |
| 255 if (n == in.sz) { | |
| 256 st.in_full++; | |
| 257 in.count += n; | |
| 258 } else { | |
| 259 st.in_part++; | |
| 260 if (toys.optflags & C_SYNC) in.count += in.sz; | |
| 261 else in.count += n; | |
| 262 } | |
| 263 | |
| 264 out.count = in.count; | |
| 265 if (toys.optflags & C_BS) { | |
| 266 write_out(1); | |
| 267 in.count = 0; | |
| 268 continue; | |
| 269 } | |
| 270 | |
| 271 if (in.count >= out.sz) { | |
| 272 write_out(0); | |
| 273 in.count = out.count; | |
| 274 } | |
| 275 } | |
| 276 if (out.count) write_out(1); //write any remaining input blocks | |
| 277 if (toys.optflags & C_FSYNC && fsync(out.fd) < 0) | |
| 278 perror_exit("%s: fsync fail", out.name); | |
| 279 | |
| 280 close(in.fd); | |
| 281 close(out.fd); | |
| 282 if (in.buff) free(in.buff); | |
| 283 } | |
| 284 | |
| 285 static int comp(const void *a, const void *b) //const to shut compiler up | |
| 286 { | |
| 287 return strcmp(((struct pair*)a)->name, ((struct pair*)b)->name); | |
| 288 } | |
| 289 | |
| 290 void dd_main() | |
| 291 { | |
| 292 struct pair *res, key; | |
| 293 char *arg; | |
| 294 long sz; | |
| 295 | |
| 296 in.sz = out.sz = 512; //default io block size | |
| 297 while (*toys.optargs) { | |
| 298 if (!(arg = strchr(*toys.optargs, '='))) error_exit("unknown arg %s", *toys.optargs); | |
| 299 *arg++ = '\0'; | |
| 300 if (!*arg) { | |
| 301 toys.exithelp = 1; | |
| 302 error_exit(""); | |
| 303 } | |
| 304 key.name = *toys.optargs; | |
| 305 if (!(res = bsearch(&key, operands, ARRAY_LEN(operands), sizeof(struct pair), | |
| 306 comp))) error_exit("unknown arg %s", key.name); | |
| 307 | |
| 308 toys.optflags |= res->val; | |
| 309 switch(res->val) { | |
| 310 case C_BS: | |
| 311 in.sz = out.sz = strsuftoll(arg, 1, LONG_MAX); | |
| 312 break; | |
| 313 case C_IBS: | |
| 314 sz = strsuftoll(arg, 1, LONG_MAX); | |
| 315 if (!(toys.optflags & C_BS)) in.sz = sz; | |
| 316 break; | |
| 317 case C_OBS: | |
| 318 sz = strsuftoll(arg, 1, LONG_MAX); | |
| 319 if (!(toys.optflags & C_BS)) out.sz = sz; | |
| 320 break; | |
| 321 case C_COUNT: | |
| 322 c_count = strsuftoll(arg, 0, ULLONG_MAX); | |
| 323 break; | |
| 324 case C_IF: | |
| 325 in.name = arg; | |
| 326 break; | |
| 327 case C_OF: | |
| 328 out.name = arg; | |
| 329 break; | |
| 330 case C_SEEK: | |
| 331 out.offset = strsuftoll(arg, 0, ULLONG_MAX); | |
| 332 break; | |
| 333 case C_SKIP: | |
| 334 in.offset = strsuftoll(arg, 0, ULLONG_MAX); | |
| 335 break; | |
| 336 case C_CONV: | |
| 337 while (arg) { | |
| 338 key.name = strsep(&arg, ","); | |
| 339 if (!(res = bsearch(&key, clist, ARRAY_LEN(clist), | |
| 340 sizeof(struct pair), comp))) | |
| 341 error_exit("unknown conversion %s", key.name); | |
| 342 | |
| 343 toys.optflags |= res->val; | |
| 344 } | |
| 345 break; | |
| 346 } | |
| 347 toys.optargs++; | |
| 348 } | |
| 349 | |
| 350 do_dd(); | |
| 351 } |