dd.c 16 KB

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