== How _dd_ does blocking

For a conceptually simple program, _dd_ has a number of dark corners.
One of them (at least for me) is how it deals with input and output
block sizes, and how the various blocking arguments change things
around.

* _ibs=_ sets the input block size, the size of the _read()_s that
  _dd_ will make. Since you can get partial reads in various
  situations, this is really the maximum size that _dd_ will ever
  read at once.
* _obs=_ sets the output block size and makes _dd_ 'reblock' output;
  _dd_ will accumulate input until it can write a full sized output
  block (except at EOF, where it may write a final partial block).
* _bs=_ sets the (maximum) IO block size for both reads and writes,
  ~~but it turns off reblocking~~; if _dd_ gets a partial read, it
  will immediately write that partial block.

Because of the reblocking or lack thereof, '_ibs=N obs=N_' is subtly
different from '_bs=N_'. The former will accumulate multiple partial
reads together in order to write N bytes, while the latter won't.

(On top of this is the '_conv=sync_' option, which pads partial reads.)

So if you're reading from a network or a pipe but want to write in large
efficient blocks, you want to use _obs_, not _bs_ (and you probably want
to use _ibs_ too, because otherwise you'll be doing a lot of 512 byte
reads, which are kind of inefficient).