dd.c 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673
  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]"
  57. //usage: IF_FEATURE_DD_IBS_OBS("\n"
  58. //usage: " [conv=notrunc|noerror|sync|fsync]\n"
  59. //usage: " [iflag=skip_bytes|count_bytes|fullblock|direct] [oflag=seek_bytes|append|direct]"
  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=count_bytes count=N is in bytes"
  83. //usage: "\n oflag=seek_bytes seek=N is in bytes"
  84. //usage: "\n iflag=direct O_DIRECT input"
  85. //usage: "\n oflag=direct O_DIRECT output"
  86. //usage: "\n iflag=fullblock Read full blocks"
  87. //usage: "\n oflag=append Open output in append mode"
  88. //usage: )
  89. //usage: IF_FEATURE_DD_STATUS(
  90. //usage: "\n status=noxfer Suppress rate output"
  91. //usage: "\n status=none Suppress all output"
  92. //usage: )
  93. //usage: "\n"
  94. //usage: "\nN may be suffixed by c (1), w (2), b (512), kB (1000), k (1024), MB, M, GB, G"
  95. //usage:
  96. //usage:#define dd_example_usage
  97. //usage: "$ dd if=/dev/zero of=/dev/ram1 bs=1M count=4\n"
  98. //usage: "4+0 records in\n"
  99. //usage: "4+0 records out\n"
  100. #include "libbb.h"
  101. #include "common_bufsiz.h"
  102. /* This is a NOEXEC applet. Be very careful! */
  103. enum {
  104. ifd = STDIN_FILENO,
  105. ofd = STDOUT_FILENO,
  106. };
  107. struct globals {
  108. off_t out_full, out_part, in_full, in_part;
  109. #if ENABLE_FEATURE_DD_THIRD_STATUS_LINE
  110. unsigned long long total_bytes;
  111. unsigned long long begin_time_us;
  112. #endif
  113. int flags;
  114. } FIX_ALIASING;
  115. #define G (*(struct globals*)bb_common_bufsiz1)
  116. #define INIT_G() do { \
  117. setup_common_bufsiz(); \
  118. /* we have to zero it out because of NOEXEC */ \
  119. memset(&G, 0, sizeof(G)); \
  120. } while (0)
  121. enum {
  122. /* Must be in the same order as OP_conv_XXX! */
  123. /* (see "flags |= (1 << what)" below) */
  124. FLAG_NOTRUNC = (1 << 0) * ENABLE_FEATURE_DD_IBS_OBS,
  125. FLAG_SYNC = (1 << 1) * ENABLE_FEATURE_DD_IBS_OBS,
  126. FLAG_NOERROR = (1 << 2) * ENABLE_FEATURE_DD_IBS_OBS,
  127. FLAG_FSYNC = (1 << 3) * ENABLE_FEATURE_DD_IBS_OBS,
  128. FLAG_SWAB = (1 << 4) * ENABLE_FEATURE_DD_IBS_OBS,
  129. /* end of conv flags */
  130. /* start of input flags */
  131. FLAG_IFLAG_SHIFT = 5,
  132. FLAG_SKIP_BYTES = (1 << 5) * ENABLE_FEATURE_DD_IBS_OBS,
  133. FLAG_COUNT_BYTES = (1 << 6) * ENABLE_FEATURE_DD_IBS_OBS,
  134. FLAG_FULLBLOCK = (1 << 7) * ENABLE_FEATURE_DD_IBS_OBS,
  135. FLAG_IDIRECT = (1 << 8) * ENABLE_FEATURE_DD_IBS_OBS,
  136. /* end of input flags */
  137. /* start of output flags */
  138. FLAG_OFLAG_SHIFT = 9,
  139. FLAG_SEEK_BYTES = (1 << 9) * ENABLE_FEATURE_DD_IBS_OBS,
  140. FLAG_APPEND = (1 << 10) * ENABLE_FEATURE_DD_IBS_OBS,
  141. FLAG_ODIRECT = (1 << 11) * ENABLE_FEATURE_DD_IBS_OBS,
  142. /* end of output flags */
  143. FLAG_TWOBUFS = (1 << 12) * ENABLE_FEATURE_DD_IBS_OBS,
  144. FLAG_COUNT = 1 << 13,
  145. FLAG_STATUS_NONE = 1 << 14,
  146. FLAG_STATUS_NOXFER = 1 << 15,
  147. };
  148. static void dd_output_status(int UNUSED_PARAM cur_signal)
  149. {
  150. #if ENABLE_FEATURE_DD_THIRD_STATUS_LINE
  151. double seconds;
  152. unsigned long long bytes_sec;
  153. unsigned long long now_us = monotonic_us(); /* before fprintf */
  154. #endif
  155. /* Deliberately using %u, not %d */
  156. fprintf(stderr, "%"OFF_FMT"u+%"OFF_FMT"u records in\n"
  157. "%"OFF_FMT"u+%"OFF_FMT"u records out\n",
  158. G.in_full, G.in_part,
  159. G.out_full, G.out_part);
  160. #if ENABLE_FEATURE_DD_THIRD_STATUS_LINE
  161. # if ENABLE_FEATURE_DD_STATUS
  162. if (G.flags & FLAG_STATUS_NOXFER) /* status=noxfer active? */
  163. return;
  164. //TODO: should status=none make dd stop reacting to USR1 entirely?
  165. //So far we react to it (we print the stats),
  166. //status=none only suppresses final, non-USR1 generated status message.
  167. # endif
  168. fprintf(stderr, /*G.total_bytes < 1024
  169. ? "%llu bytes copied, " : */ "%llu bytes (%sB) copied, "
  170. , G.total_bytes,
  171. /* show fractional digit, use suffixes */
  172. make_human_readable_str(G.total_bytes, 1, 0)
  173. );
  174. /* Corner cases:
  175. * ./busybox dd </dev/null >/dev/null
  176. * ./busybox dd bs=1M count=2000 </dev/zero >/dev/null
  177. * (echo DONE) | ./busybox dd >/dev/null
  178. * (sleep 1; echo DONE) | ./busybox dd >/dev/null
  179. */
  180. seconds = (now_us - G.begin_time_us) / 1000000.0;
  181. bytes_sec = G.total_bytes / seconds;
  182. fprintf(stderr, "%f seconds, %sB/s\n",
  183. seconds,
  184. /* show fractional digit, use suffixes */
  185. make_human_readable_str(bytes_sec, 1, 0)
  186. );
  187. #endif
  188. }
  189. #if ENABLE_FEATURE_DD_IBS_OBS
  190. static int clear_O_DIRECT(int fd)
  191. {
  192. if (errno == EINVAL) {
  193. int fl = fcntl(fd, F_GETFL);
  194. if (fl & O_DIRECT) {
  195. fcntl(fd, F_SETFL, fl & ~O_DIRECT);
  196. return 1;
  197. }
  198. }
  199. return 0;
  200. }
  201. #endif
  202. static ssize_t dd_read(void *ibuf, size_t ibs)
  203. {
  204. ssize_t n;
  205. #if ENABLE_FEATURE_DD_IBS_OBS
  206. read_again:
  207. if (G.flags & FLAG_FULLBLOCK)
  208. n = full_read(ifd, ibuf, ibs);
  209. else
  210. #endif
  211. n = safe_read(ifd, ibuf, ibs);
  212. #if ENABLE_FEATURE_DD_IBS_OBS
  213. if (n < 0 && (G.flags & FLAG_IDIRECT) && clear_O_DIRECT(ifd))
  214. goto read_again;
  215. #endif
  216. return n;
  217. }
  218. static bool write_and_stats(const void *buf, size_t len, size_t obs,
  219. const char *filename)
  220. {
  221. ssize_t n;
  222. IF_FEATURE_DD_IBS_OBS(write_again:)
  223. n = full_write(ofd, buf, len);
  224. #if ENABLE_FEATURE_DD_IBS_OBS
  225. if (n < 0 && (G.flags & FLAG_ODIRECT) && clear_O_DIRECT(ofd))
  226. goto write_again;
  227. #endif
  228. #if ENABLE_FEATURE_DD_THIRD_STATUS_LINE
  229. if (n > 0)
  230. G.total_bytes += n;
  231. #endif
  232. if ((size_t)n == obs) {
  233. G.out_full++;
  234. return 0;
  235. }
  236. if ((size_t)n == len) {
  237. G.out_part++;
  238. return 0;
  239. }
  240. /* n is < len (and possibly is -1).
  241. * Even if n >= 0, errno is usually set correctly.
  242. * For example, if writing to block device and getting ENOSPC,
  243. * full_write() first sees a short write, then tries to write
  244. * the remainder and gets errno set to ENOSPC.
  245. * It returns n > 0 (the amount which it did write).
  246. */
  247. bb_perror_msg("error writing '%s'", filename);
  248. return 1;
  249. }
  250. #if ENABLE_LFS
  251. # define XATOU_SFX xatoull_sfx
  252. #else
  253. # define XATOU_SFX xatoul_sfx
  254. #endif
  255. #if ENABLE_FEATURE_DD_IBS_OBS
  256. static int parse_comma_flags(char *val, const char *words, const char *error_in)
  257. {
  258. int flags = 0;
  259. while (1) {
  260. int n;
  261. char *arg;
  262. /* find ',', replace them with NUL so we can use val for
  263. * index_in_strings() without copying.
  264. * We rely on val being non-null, else strchr would fault.
  265. */
  266. arg = strchr(val, ',');
  267. if (arg)
  268. *arg = '\0';
  269. n = index_in_strings(words, val);
  270. if (n < 0)
  271. bb_error_msg_and_die(bb_msg_invalid_arg_to, val, error_in);
  272. flags |= (1 << n);
  273. if (!arg) /* no ',' left, so this was the last specifier */
  274. break;
  275. *arg = ','; /* to preserve ps listing */
  276. val = arg + 1; /* skip this keyword and ',' */
  277. }
  278. return flags;
  279. }
  280. #endif
  281. static void *alloc_buf(size_t size)
  282. {
  283. /* Important for "{i,o}flag=direct" - buffers must be page aligned */
  284. if (size >= bb_getpagesize())
  285. return xmmap_anon(size);
  286. return xmalloc(size);
  287. }
  288. int dd_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
  289. int dd_main(int argc UNUSED_PARAM, char **argv)
  290. {
  291. static const char keywords[] ALIGN1 =
  292. "bs\0""count\0""seek\0""skip\0""if\0""of\0"IF_FEATURE_DD_STATUS("status\0")
  293. #if ENABLE_FEATURE_DD_IBS_OBS
  294. "ibs\0""obs\0""conv\0""iflag\0""oflag\0"
  295. #endif
  296. ;
  297. #if ENABLE_FEATURE_DD_IBS_OBS
  298. static const char conv_words[] ALIGN1 =
  299. "notrunc\0""sync\0""noerror\0""fsync\0""swab\0";
  300. static const char iflag_words[] ALIGN1 =
  301. "skip_bytes\0""count_bytes\0""fullblock\0""direct\0";
  302. static const char oflag_words[] ALIGN1 =
  303. "seek_bytes\0append\0""direct\0";
  304. #endif
  305. #if ENABLE_FEATURE_DD_STATUS
  306. static const char status_words[] ALIGN1 =
  307. "none\0""noxfer\0";
  308. #endif
  309. enum {
  310. OP_bs = 0,
  311. OP_count,
  312. OP_seek,
  313. OP_skip,
  314. OP_if,
  315. OP_of,
  316. IF_FEATURE_DD_STATUS(OP_status,)
  317. #if ENABLE_FEATURE_DD_IBS_OBS
  318. OP_ibs,
  319. OP_obs,
  320. OP_conv,
  321. OP_iflag,
  322. OP_oflag,
  323. /* Must be in the same order as FLAG_XXX! */
  324. OP_conv_notrunc = 0,
  325. OP_conv_sync,
  326. OP_conv_noerror,
  327. OP_conv_fsync,
  328. OP_conv_swab,
  329. /* Unimplemented conv=XXX: */
  330. //nocreat do not create the output file
  331. //excl fail if the output file already exists
  332. //fdatasync physically write output file data before finishing
  333. //lcase change upper case to lower case
  334. //ucase change lower case to upper case
  335. //block pad newline-terminated records with spaces to cbs-size
  336. //unblock replace trailing spaces in cbs-size records with newline
  337. //ascii from EBCDIC to ASCII
  338. //ebcdic from ASCII to EBCDIC
  339. //ibm from ASCII to alternate EBCDIC
  340. /* Partially implemented: */
  341. //swab swap every pair of input bytes: will abort on non-even reads
  342. OP_iflag_skip_bytes,
  343. OP_iflag_count_bytes,
  344. OP_iflag_fullblock,
  345. OP_iflag_direct,
  346. OP_oflag_seek_bytes,
  347. OP_oflag_direct,
  348. #endif
  349. };
  350. smallint exitcode = EXIT_FAILURE;
  351. int i;
  352. size_t ibs = 512;
  353. char *ibuf;
  354. #if ENABLE_FEATURE_DD_IBS_OBS
  355. size_t obs = 512;
  356. char *obuf;
  357. #else
  358. # define obs ibs
  359. # define obuf ibuf
  360. #endif
  361. /* These are all zeroed at once! */
  362. struct {
  363. IF_FEATURE_DD_IBS_OBS(size_t ocount;)
  364. ssize_t prev_read_size; /* for detecting swab failure */
  365. off_t count;
  366. off_t seek, skip;
  367. const char *infile, *outfile;
  368. } Z;
  369. #define ocount (Z.ocount )
  370. #define prev_read_size (Z.prev_read_size)
  371. #define count (Z.count )
  372. #define seek (Z.seek )
  373. #define skip (Z.skip )
  374. #define infile (Z.infile )
  375. #define outfile (Z.outfile)
  376. memset(&Z, 0, sizeof(Z));
  377. INIT_G();
  378. //fflush_all(); - is this needed because of NOEXEC?
  379. for (i = 1; argv[i]; i++) {
  380. int what;
  381. char *val;
  382. char *arg = argv[i];
  383. #if ENABLE_DESKTOP
  384. /* "dd --". NB: coreutils 6.9 will complain if they see
  385. * more than one of them. We wouldn't. */
  386. if (arg[0] == '-' && arg[1] == '-' && arg[2] == '\0')
  387. continue;
  388. #endif
  389. val = strchr(arg, '=');
  390. if (val == NULL)
  391. bb_show_usage();
  392. *val = '\0';
  393. what = index_in_strings(keywords, arg);
  394. if (what < 0)
  395. bb_show_usage();
  396. /* *val = '='; - to preserve ps listing? */
  397. val++;
  398. #if ENABLE_FEATURE_DD_IBS_OBS
  399. if (what == OP_ibs) {
  400. /* Must fit into positive ssize_t */
  401. ibs = xatoul_range_sfx(val, 1, ((size_t)-1L)/2, cwbkMG_suffixes);
  402. /*continue;*/
  403. }
  404. if (what == OP_obs) {
  405. obs = xatoul_range_sfx(val, 1, ((size_t)-1L)/2, cwbkMG_suffixes);
  406. /*continue;*/
  407. }
  408. if (what == OP_conv) {
  409. G.flags |= parse_comma_flags(val, conv_words, "conv");
  410. /*continue;*/
  411. }
  412. if (what == OP_iflag) {
  413. G.flags |= parse_comma_flags(val, iflag_words, "iflag") << FLAG_IFLAG_SHIFT;
  414. /*continue;*/
  415. }
  416. if (what == OP_oflag) {
  417. G.flags |= parse_comma_flags(val, oflag_words, "oflag") << FLAG_OFLAG_SHIFT;
  418. /*continue;*/
  419. }
  420. #endif
  421. if (what == OP_bs) {
  422. ibs = xatoul_range_sfx(val, 1, ((size_t)-1L)/2, cwbkMG_suffixes);
  423. obs = ibs;
  424. /*continue;*/
  425. }
  426. /* These can be large: */
  427. if (what == OP_count) {
  428. G.flags |= FLAG_COUNT;
  429. count = XATOU_SFX(val, cwbkMG_suffixes);
  430. /*continue;*/
  431. }
  432. if (what == OP_seek) {
  433. seek = XATOU_SFX(val, cwbkMG_suffixes);
  434. /*continue;*/
  435. }
  436. if (what == OP_skip) {
  437. skip = XATOU_SFX(val, cwbkMG_suffixes);
  438. /*continue;*/
  439. }
  440. if (what == OP_if) {
  441. infile = val;
  442. /*continue;*/
  443. }
  444. if (what == OP_of) {
  445. outfile = val;
  446. /*continue;*/
  447. }
  448. #if ENABLE_FEATURE_DD_STATUS
  449. if (what == OP_status) {
  450. int n;
  451. n = index_in_strings(status_words, val);
  452. if (n < 0)
  453. bb_error_msg_and_die(bb_msg_invalid_arg_to, val, "status");
  454. G.flags |= FLAG_STATUS_NONE << n;
  455. /*continue;*/
  456. }
  457. #endif
  458. } /* end of "for (argv[i])" */
  459. ibuf = alloc_buf(ibs);
  460. obuf = ibuf;
  461. #if ENABLE_FEATURE_DD_IBS_OBS
  462. if (ibs != obs) {
  463. G.flags |= FLAG_TWOBUFS;
  464. obuf = alloc_buf(obs);
  465. }
  466. #endif
  467. #if ENABLE_FEATURE_DD_SIGNAL_HANDLING
  468. signal_SA_RESTART_empty_mask(SIGUSR1, dd_output_status);
  469. #endif
  470. #if ENABLE_FEATURE_DD_THIRD_STATUS_LINE
  471. G.begin_time_us = monotonic_us();
  472. #endif
  473. if (infile) {
  474. int iflag = O_RDONLY;
  475. #if ENABLE_FEATURE_DD_IBS_OBS
  476. if (G.flags & FLAG_IDIRECT)
  477. iflag |= O_DIRECT;
  478. #endif
  479. xmove_fd(xopen(infile, iflag), ifd);
  480. } else {
  481. infile = bb_msg_standard_input;
  482. }
  483. if (outfile) {
  484. int oflag = O_WRONLY | O_CREAT;
  485. if (!seek && !(G.flags & FLAG_NOTRUNC))
  486. oflag |= O_TRUNC;
  487. if (G.flags & FLAG_APPEND)
  488. oflag |= O_APPEND;
  489. #if ENABLE_FEATURE_DD_IBS_OBS
  490. if (G.flags & FLAG_ODIRECT)
  491. oflag |= O_DIRECT;
  492. #endif
  493. xmove_fd(xopen(outfile, oflag), ofd);
  494. if (seek && !(G.flags & FLAG_NOTRUNC)) {
  495. size_t blocksz = (G.flags & FLAG_SEEK_BYTES) ? 1 : obs;
  496. if (ftruncate(ofd, seek * blocksz) < 0) {
  497. struct stat st;
  498. if (fstat(ofd, &st) < 0
  499. || S_ISREG(st.st_mode)
  500. || S_ISDIR(st.st_mode)
  501. ) {
  502. goto die_outfile;
  503. }
  504. }
  505. }
  506. } else {
  507. outfile = bb_msg_standard_output;
  508. }
  509. if (skip) {
  510. size_t blocksz = (G.flags & FLAG_SKIP_BYTES) ? 1 : ibs;
  511. if (lseek(ifd, skip * blocksz, SEEK_CUR) < 0) {
  512. do {
  513. ssize_t n = dd_read(ibuf, blocksz);
  514. if (n < 0)
  515. goto die_infile;
  516. if (n == 0)
  517. break;
  518. } while (--skip != 0);
  519. }
  520. }
  521. if (seek) {
  522. size_t blocksz = (G.flags & FLAG_SEEK_BYTES) ? 1 : obs;
  523. if (lseek(ofd, seek * blocksz, SEEK_CUR) < 0)
  524. goto die_outfile;
  525. }
  526. while (1) {
  527. ssize_t n = ibs;
  528. if (G.flags & FLAG_COUNT) {
  529. if (count == 0)
  530. break;
  531. if ((G.flags & FLAG_COUNT_BYTES) && count < ibs)
  532. n = count;
  533. }
  534. n = dd_read(ibuf, n);
  535. if (n == 0)
  536. break;
  537. if (n < 0) {
  538. /* "Bad block" */
  539. if (!(G.flags & FLAG_NOERROR))
  540. goto die_infile;
  541. bb_simple_perror_msg(infile);
  542. /* GNU dd with conv=noerror skips over bad blocks */
  543. xlseek(ifd, ibs, SEEK_CUR);
  544. /* conv=noerror,sync writes NULs,
  545. * conv=noerror just ignores input bad blocks */
  546. n = 0;
  547. }
  548. if (G.flags & FLAG_SWAB) {
  549. uint16_t *p16;
  550. ssize_t n2;
  551. /* Our code allows only last read to be odd-sized */
  552. if (prev_read_size & 1)
  553. bb_error_msg_and_die("can't swab %lu byte buffer",
  554. (unsigned long)prev_read_size);
  555. prev_read_size = n;
  556. /* If n is odd, last byte is not swapped:
  557. * echo -n "qwe" | dd conv=swab
  558. * prints "wqe".
  559. */
  560. p16 = (void*) ibuf;
  561. n2 = (n >> 1);
  562. while (--n2 >= 0) {
  563. *p16 = bswap_16(*p16);
  564. p16++;
  565. }
  566. }
  567. count -= (G.flags & FLAG_COUNT_BYTES) ? n : 1;
  568. if ((size_t)n == ibs)
  569. G.in_full++;
  570. else {
  571. G.in_part++;
  572. if (G.flags & FLAG_SYNC) {
  573. memset(ibuf + n, 0, ibs - n);
  574. n = ibs;
  575. }
  576. }
  577. #if ENABLE_FEATURE_DD_IBS_OBS
  578. if (G.flags & FLAG_TWOBUFS) {
  579. char *tmp = ibuf;
  580. while (n) {
  581. size_t d = obs - ocount;
  582. if (d > (size_t)n)
  583. d = n;
  584. memcpy(obuf + ocount, tmp, d);
  585. n -= d;
  586. tmp += d;
  587. ocount += d;
  588. if (ocount == obs) {
  589. if (write_and_stats(obuf, obs, obs, outfile))
  590. goto out_status;
  591. ocount = 0;
  592. }
  593. }
  594. } else
  595. #endif
  596. {
  597. if (write_and_stats(ibuf, n, obs, outfile))
  598. goto out_status;
  599. }
  600. }
  601. if (G.flags & FLAG_FSYNC) {
  602. if (fsync(ofd) < 0)
  603. goto die_outfile;
  604. }
  605. #if ENABLE_FEATURE_DD_IBS_OBS
  606. if (ocount != 0) {
  607. if (write_and_stats(obuf, ocount, obs, outfile))
  608. goto out_status;
  609. }
  610. #endif
  611. if (close(ifd) < 0) {
  612. die_infile:
  613. bb_simple_perror_msg_and_die(infile);
  614. }
  615. if (close(ofd) < 0) {
  616. die_outfile:
  617. bb_simple_perror_msg_and_die(outfile);
  618. }
  619. exitcode = EXIT_SUCCESS;
  620. out_status:
  621. if (!ENABLE_FEATURE_DD_STATUS || !(G.flags & FLAG_STATUS_NONE))
  622. dd_output_status(0);
  623. #if 0 /* can't just free(), they can be mmap()ed */
  624. if (ENABLE_FEATURE_CLEAN_UP) {
  625. free(obuf);
  626. if (G.flags & FLAG_TWOBUFS)
  627. free(ibuf);
  628. }
  629. #endif
  630. return exitcode;
  631. }