summaryrefslogtreecommitdiff
path: root/coreutils/dd.c (plain)
blob: 2838f63415df3571bd37dbcdd7e859f274345342
1/* vi: set sw=4 ts=4: */
2/*
3 * Mini dd implementation for busybox
4 *
5 *
6 * Copyright (C) 2000,2001 Matt Kraai
7 *
8 * Licensed under GPLv2 or later, see file LICENSE in this source tree.
9 */
10
11//usage:#define dd_trivial_usage
12//usage: "[if=FILE] [of=FILE] " IF_FEATURE_DD_IBS_OBS("[ibs=N] [obs=N] ") "[bs=N] [count=N] [skip=N]\n"
13//usage: " [seek=N]" IF_FEATURE_DD_IBS_OBS(" [conv=notrunc|noerror|sync|fsync]")
14//usage:#define dd_full_usage "\n\n"
15//usage: "Copy a file with converting and formatting\n"
16//usage: "\n if=FILE Read from FILE instead of stdin"
17//usage: "\n of=FILE Write to FILE instead of stdout"
18//usage: "\n bs=N Read and write N bytes at a time"
19//usage: IF_FEATURE_DD_IBS_OBS(
20//usage: "\n ibs=N Read N bytes at a time"
21//usage: )
22//usage: IF_FEATURE_DD_IBS_OBS(
23//usage: "\n obs=N Write N bytes at a time"
24//usage: )
25//usage: "\n count=N Copy only N input blocks"
26//usage: "\n skip=N Skip N input blocks"
27//usage: "\n seek=N Skip N output blocks"
28//usage: IF_FEATURE_DD_IBS_OBS(
29//usage: "\n conv=notrunc Don't truncate output file"
30//usage: "\n conv=noerror Continue after read errors"
31//usage: "\n conv=sync Pad blocks with zeros"
32//usage: "\n conv=fsync Physically write data out before finishing"
33//usage: "\n conv=swab Swap every pair of bytes"
34//usage: )
35//usage: "\n"
36//usage: "\nN may be suffixed by c (1), w (2), b (512), kD (1000), k (1024), MD, M, GD, G"
37//usage:
38//usage:#define dd_example_usage
39//usage: "$ dd if=/dev/zero of=/dev/ram1 bs=1M count=4\n"
40//usage: "4+0 records in\n"
41//usage: "4+0 records out\n"
42
43#include "libbb.h"
44
45/* This is a NOEXEC applet. Be very careful! */
46
47
48enum {
49 ifd = STDIN_FILENO,
50 ofd = STDOUT_FILENO,
51};
52
53static const struct suffix_mult dd_suffixes[] = {
54 { "c", 1 },
55 { "w", 2 },
56 { "b", 512 },
57 { "kD", 1000 },
58 { "k", 1024 },
59 { "K", 1024 }, /* compat with coreutils dd */
60 { "MD", 1000000 },
61 { "M", 1048576 },
62 { "GD", 1000000000 },
63 { "G", 1073741824 },
64 { "", 0 }
65};
66
67struct globals {
68 off_t out_full, out_part, in_full, in_part;
69#if ENABLE_FEATURE_DD_THIRD_STATUS_LINE
70 unsigned long long total_bytes;
71 unsigned long long begin_time_us;
72#endif
73} FIX_ALIASING;
74#define G (*(struct globals*)&bb_common_bufsiz1)
75#define INIT_G() do { \
76 /* we have to zero it out because of NOEXEC */ \
77 memset(&G, 0, sizeof(G)); \
78} while (0)
79
80
81static void dd_output_status(int UNUSED_PARAM cur_signal)
82{
83#if ENABLE_FEATURE_DD_THIRD_STATUS_LINE
84 double seconds;
85 unsigned long long bytes_sec;
86 unsigned long long now_us = monotonic_us(); /* before fprintf */
87#endif
88
89 /* Deliberately using %u, not %d */
90 fprintf(stderr, "%"OFF_FMT"u+%"OFF_FMT"u records in\n"
91 "%"OFF_FMT"u+%"OFF_FMT"u records out\n",
92 G.in_full, G.in_part,
93 G.out_full, G.out_part);
94
95#if ENABLE_FEATURE_DD_THIRD_STATUS_LINE
96 fprintf(stderr, "%llu bytes (%sB) copied, ",
97 G.total_bytes,
98 /* show fractional digit, use suffixes */
99 make_human_readable_str(G.total_bytes, 1, 0)
100 );
101 /* Corner cases:
102 * ./busybox dd </dev/null >/dev/null
103 * ./busybox dd bs=1M count=2000 </dev/zero >/dev/null
104 * (echo DONE) | ./busybox dd >/dev/null
105 * (sleep 1; echo DONE) | ./busybox dd >/dev/null
106 */
107 seconds = (now_us - G.begin_time_us) / 1000000.0;
108 bytes_sec = G.total_bytes / seconds;
109 fprintf(stderr, "%f seconds, %sB/s\n",
110 seconds,
111 /* show fractional digit, use suffixes */
112 make_human_readable_str(bytes_sec, 1, 0)
113 );
114#endif
115}
116
117static ssize_t full_write_or_warn(const void *buf, size_t len,
118 const char *const filename)
119{
120 ssize_t n = full_write(ofd, buf, len);
121 if (n < 0)
122 bb_perror_msg("writing '%s'", filename);
123 return n;
124}
125
126static bool write_and_stats(const void *buf, size_t len, size_t obs,
127 const char *filename)
128{
129 ssize_t n = full_write_or_warn(buf, len, filename);
130 if (n < 0)
131 return 1;
132 if ((size_t)n == obs)
133 G.out_full++;
134 else if (n) /* > 0 */
135 G.out_part++;
136#if ENABLE_FEATURE_DD_THIRD_STATUS_LINE
137 G.total_bytes += n;
138#endif
139 return 0;
140}
141
142#if ENABLE_LFS
143# define XATOU_SFX xatoull_sfx
144#else
145# define XATOU_SFX xatoul_sfx
146#endif
147
148int dd_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
149int dd_main(int argc UNUSED_PARAM, char **argv)
150{
151 enum {
152 /* Must be in the same order as OP_conv_XXX! */
153 /* (see "flags |= (1 << what)" below) */
154 FLAG_NOTRUNC = (1 << 0) * ENABLE_FEATURE_DD_IBS_OBS,
155 FLAG_SYNC = (1 << 1) * ENABLE_FEATURE_DD_IBS_OBS,
156 FLAG_NOERROR = (1 << 2) * ENABLE_FEATURE_DD_IBS_OBS,
157 FLAG_FSYNC = (1 << 3) * ENABLE_FEATURE_DD_IBS_OBS,
158 FLAG_SWAB = (1 << 4) * ENABLE_FEATURE_DD_IBS_OBS,
159 /* end of conv flags */
160 FLAG_TWOBUFS = (1 << 5) * ENABLE_FEATURE_DD_IBS_OBS,
161 FLAG_COUNT = 1 << 6,
162 };
163 static const char keywords[] ALIGN1 =
164 "bs\0""count\0""seek\0""skip\0""if\0""of\0"
165#if ENABLE_FEATURE_DD_IBS_OBS
166 "ibs\0""obs\0""conv\0"
167#endif
168 ;
169#if ENABLE_FEATURE_DD_IBS_OBS
170 static const char conv_words[] ALIGN1 =
171 "notrunc\0""sync\0""noerror\0""fsync\0""swab\0";
172#endif
173 enum {
174 OP_bs = 0,
175 OP_count,
176 OP_seek,
177 OP_skip,
178 OP_if,
179 OP_of,
180#if ENABLE_FEATURE_DD_IBS_OBS
181 OP_ibs,
182 OP_obs,
183 OP_conv,
184 /* Must be in the same order as FLAG_XXX! */
185 OP_conv_notrunc = 0,
186 OP_conv_sync,
187 OP_conv_noerror,
188 OP_conv_fsync,
189 OP_conv_swab,
190 /* Unimplemented conv=XXX: */
191 //nocreat do not create the output file
192 //excl fail if the output file already exists
193 //fdatasync physically write output file data before finishing
194 //lcase change upper case to lower case
195 //ucase change lower case to upper case
196 //block pad newline-terminated records with spaces to cbs-size
197 //unblock replace trailing spaces in cbs-size records with newline
198 //ascii from EBCDIC to ASCII
199 //ebcdic from ASCII to EBCDIC
200 //ibm from ASCII to alternate EBCDIC
201 /* Partially implemented: */
202 //swab swap every pair of input bytes: will abort on non-even reads
203#endif
204 };
205 smallint exitcode = EXIT_FAILURE;
206 int i;
207 size_t ibs = 512;
208 char *ibuf;
209#if ENABLE_FEATURE_DD_IBS_OBS
210 size_t obs = 512;
211 char *obuf;
212#else
213# define obs ibs
214# define obuf ibuf
215#endif
216 /* These are all zeroed at once! */
217 struct {
218 int flags;
219 size_t oc;
220 ssize_t prev_read_size; /* for detecting swab failure */
221 off_t count;
222 off_t seek, skip;
223 const char *infile, *outfile;
224 } Z;
225#define flags (Z.flags )
226#define oc (Z.oc )
227#define prev_read_size (Z.prev_read_size)
228#define count (Z.count )
229#define seek (Z.seek )
230#define skip (Z.skip )
231#define infile (Z.infile )
232#define outfile (Z.outfile)
233
234 memset(&Z, 0, sizeof(Z));
235 INIT_G();
236 //fflush_all(); - is this needed because of NOEXEC?
237
238 for (i = 1; argv[i]; i++) {
239 int what;
240 char *val;
241 char *arg = argv[i];
242
243#if ENABLE_DESKTOP
244 /* "dd --". NB: coreutils 6.9 will complain if they see
245 * more than one of them. We wouldn't. */
246 if (arg[0] == '-' && arg[1] == '-' && arg[2] == '\0')
247 continue;
248#endif
249 val = strchr(arg, '=');
250 if (val == NULL)
251 bb_show_usage();
252 *val = '\0';
253 what = index_in_strings(keywords, arg);
254 if (what < 0)
255 bb_show_usage();
256 /* *val = '='; - to preserve ps listing? */
257 val++;
258#if ENABLE_FEATURE_DD_IBS_OBS
259 if (what == OP_ibs) {
260 /* Must fit into positive ssize_t */
261 ibs = xatoul_range_sfx(val, 1, ((size_t)-1L)/2, dd_suffixes);
262 /*continue;*/
263 }
264 if (what == OP_obs) {
265 obs = xatoul_range_sfx(val, 1, ((size_t)-1L)/2, dd_suffixes);
266 /*continue;*/
267 }
268 if (what == OP_conv) {
269 while (1) {
270 int n;
271 /* find ',', replace them with NUL so we can use val for
272 * index_in_strings() without copying.
273 * We rely on val being non-null, else strchr would fault.
274 */
275 arg = strchr(val, ',');
276 if (arg)
277 *arg = '\0';
278 n = index_in_strings(conv_words, val);
279 if (n < 0)
280 bb_error_msg_and_die(bb_msg_invalid_arg, val, "conv");
281 flags |= (1 << n);
282 if (!arg) /* no ',' left, so this was the last specifier */
283 break;
284 /* *arg = ','; - to preserve ps listing? */
285 val = arg + 1; /* skip this keyword and ',' */
286 }
287 /*continue;*/
288 }
289#endif
290 if (what == OP_bs) {
291 ibs = xatoul_range_sfx(val, 1, ((size_t)-1L)/2, dd_suffixes);
292 obs = ibs;
293 /*continue;*/
294 }
295 /* These can be large: */
296 if (what == OP_count) {
297 flags |= FLAG_COUNT;
298 count = XATOU_SFX(val, dd_suffixes);
299 /*continue;*/
300 }
301 if (what == OP_seek) {
302 seek = XATOU_SFX(val, dd_suffixes);
303 /*continue;*/
304 }
305 if (what == OP_skip) {
306 skip = XATOU_SFX(val, dd_suffixes);
307 /*continue;*/
308 }
309 if (what == OP_if) {
310 infile = val;
311 /*continue;*/
312 }
313 if (what == OP_of) {
314 outfile = val;
315 /*continue;*/
316 }
317 } /* end of "for (argv[i])" */
318
319//XXX:FIXME for huge ibs or obs, malloc'ing them isn't the brightest idea ever
320 ibuf = xmalloc(ibs);
321 obuf = ibuf;
322#if ENABLE_FEATURE_DD_IBS_OBS
323 if (ibs != obs) {
324 flags |= FLAG_TWOBUFS;
325 obuf = xmalloc(obs);
326 }
327#endif
328
329#if ENABLE_FEATURE_DD_SIGNAL_HANDLING
330 signal_SA_RESTART_empty_mask(SIGUSR1, dd_output_status);
331#endif
332#if ENABLE_FEATURE_DD_THIRD_STATUS_LINE
333 G.begin_time_us = monotonic_us();
334#endif
335
336 if (infile) {
337 xmove_fd(xopen(infile, O_RDONLY), ifd);
338 } else {
339 infile = bb_msg_standard_input;
340 }
341 if (outfile) {
342 int oflag = O_WRONLY | O_CREAT;
343
344 if (!seek && !(flags & FLAG_NOTRUNC))
345 oflag |= O_TRUNC;
346
347 xmove_fd(xopen(outfile, oflag), ofd);
348
349 if (seek && !(flags & FLAG_NOTRUNC)) {
350 if (ftruncate(ofd, seek * obs) < 0) {
351 struct stat st;
352
353 if (fstat(ofd, &st) < 0
354 || S_ISREG(st.st_mode)
355 || S_ISDIR(st.st_mode)
356 ) {
357 goto die_outfile;
358 }
359 }
360 }
361 } else {
362 outfile = bb_msg_standard_output;
363 }
364 if (skip) {
365 if (lseek(ifd, skip * ibs, SEEK_CUR) < 0) {
366 do {
367 ssize_t n = safe_read(ifd, ibuf, ibs);
368 if (n < 0)
369 goto die_infile;
370 if (n == 0)
371 break;
372 } while (--skip != 0);
373 }
374 }
375 if (seek) {
376 if (lseek(ofd, seek * obs, SEEK_CUR) < 0)
377 goto die_outfile;
378 }
379
380 while (!(flags & FLAG_COUNT) || (G.in_full + G.in_part != count)) {
381 ssize_t n;
382
383 n = safe_read(ifd, ibuf, ibs);
384 if (n == 0)
385 break;
386 if (n < 0) {
387 /* "Bad block" */
388 if (!(flags & FLAG_NOERROR))
389 goto die_infile;
390 bb_simple_perror_msg(infile);
391 /* GNU dd with conv=noerror skips over bad blocks */
392 xlseek(ifd, ibs, SEEK_CUR);
393 /* conv=noerror,sync writes NULs,
394 * conv=noerror just ignores input bad blocks */
395 n = 0;
396 }
397 if (flags & FLAG_SWAB) {
398 uint16_t *p16;
399 ssize_t n2;
400
401 /* Our code allows only last read to be odd-sized */
402 if (prev_read_size & 1)
403 bb_error_msg_and_die("can't swab %lu byte buffer",
404 (unsigned long)prev_read_size);
405 prev_read_size = n;
406
407 /* If n is odd, last byte is not swapped:
408 * echo -n "qwe" | dd conv=swab
409 * prints "wqe".
410 */
411 p16 = (void*) ibuf;
412 n2 = (n >> 1);
413 while (--n2 >= 0) {
414 *p16 = bswap_16(*p16);
415 p16++;
416 }
417 }
418 if ((size_t)n == ibs)
419 G.in_full++;
420 else {
421 G.in_part++;
422 if (flags & FLAG_SYNC) {
423 memset(ibuf + n, 0, ibs - n);
424 n = ibs;
425 }
426 }
427 if (flags & FLAG_TWOBUFS) {
428 char *tmp = ibuf;
429 while (n) {
430 size_t d = obs - oc;
431
432 if (d > (size_t)n)
433 d = n;
434 memcpy(obuf + oc, tmp, d);
435 n -= d;
436 tmp += d;
437 oc += d;
438 if (oc == obs) {
439 if (write_and_stats(obuf, obs, obs, outfile))
440 goto out_status;
441 oc = 0;
442 }
443 }
444 } else {
445 if (write_and_stats(ibuf, n, obs, outfile))
446 goto out_status;
447 }
448
449 if (flags & FLAG_FSYNC) {
450 if (fsync(ofd) < 0)
451 goto die_outfile;
452 }
453 }
454
455 if (ENABLE_FEATURE_DD_IBS_OBS && oc) {
456 if (write_and_stats(obuf, oc, obs, outfile))
457 goto out_status;
458 }
459 if (close(ifd) < 0) {
460 die_infile:
461 bb_simple_perror_msg_and_die(infile);
462 }
463
464 if (close(ofd) < 0) {
465 die_outfile:
466 bb_simple_perror_msg_and_die(outfile);
467 }
468
469 exitcode = EXIT_SUCCESS;
470 out_status:
471 dd_output_status(0);
472
473 if (ENABLE_FEATURE_CLEAN_UP) {
474 free(obuf);
475 if (flags & FLAG_TWOBUFS)
476 free(ibuf);
477 }
478
479 return exitcode;
480}
481
generated by cgit at 2024-05-16 00:54:07 (GMT)