I'm going a bit crazy with a simple boost asio TCP conversation.

I have a server and a client. I use length-prefixed messges. The client sends "one" and the server responds with "two". So this is what I see happen:

The client sends, and the server receives, `00 00 00 03 6F 6E 65` (== 0x0003 one).

The server responds by sending `00 00 00 03 74 77 6F` (== 0x0003 two).

Now here is where it is very strange (code below). If the client reads four bytes, I expect it to get `00 00 00 03`. If it reads seven, I expect to see `00 00 00 03 74 77 6F`. (In fact, it will read four (the length header), then three (the body).)

But what I actually see is that, while if I read seven at once I do see `00 00 00 03 74 77 6F`, if I only ask for four, I see `74 77 6F 03`. This doesn't make any sense to me.

Here is the code I'm using to receive it (minus some print statements and such):

```
const int kTcpHeaderSize = 4;
const int kTcpMessageSize = 2048;
std::array<char, kTcpMessageSize + kTcpHeaderSize> receive_buffer_;

void TcpConnection::ReceiveHeader() {
    boost::asio::async_read(
        socket_, boost::asio::buffer(receive_buffer_, kTcpHeaderSize),
        [this](boost::system::error_code error_code,
               std::size_t received_length) {
            if (error_code) {
                LOG_WARNING << "Header read error: " << error_code;
                socket_.close();  // TODO: Recover better.
                return;
            }
            if (received_length != kTcpHeaderSize) {
                LOG_ERROR << "Header length " << received_length
                          << " != " << kTcpHeaderSize;
                socket_.close();  // TODO: Recover better.
                return;
            }
            uint32_t read_length_network;
            memcpy(&read_length_network, receive_buffer_.data(),
                   kTcpHeaderSize);
            uint32_t read_length = ntohl(read_length_network);
            // Error: read_length is in the billions.
            ReceiveBody(read_length);
        });
}

```

Note that `kTcpHeaderSize` is 4. If I change it to 7 (which makes no sense, but just for the experiment) I see the stream of 7 bytes I expect. When it is 4, I see a stream that is not the first four bytes of what I expect.

Any pointers what I am doing wrong?