C++ boost asio weird buffer overflow - c++

Question

I've been debugging this for 2 days now. I've tried simpler code bases which supposedly reproduce the bug... But they work just fine. I'm not sure if the bug is in how I'm misusing the boost asio functions, or some other C++ feature.
I'm writing a TCP server, where the message structure is defined as:
uint64_t size // Size of the message, in bytes
uint64_t timestamp // Some timestamp
char *text // Some ASCII data
The code
The Header class, which represents the size and timestamp, is declared as:
class Header {
private:
uint64_t buf[2];
void *data() const {
return (void *) &buf[0];
}
public:
Header() {
buf[0] = 0UL;
buf[1] = 0UL;
}
// Reads the header from the socket
void readHeader(boost::asio::ip::tcp::socket &socket, std::function<void (void)> cb);
std::size_t getHeaderSize() const {
return sizeof(buf);
}
uint64_t getDatagramSize() const {
return buf[0];
}
uint64_t getTimestamp() const {
return buf[1];
}
};
The class ImuDatagram holds the whole message, and has methods to read the datagram from the socket.
class ImuDatagram {
public:
Header header;
std::string theJson;
void readDatagram(boost::asio::ip::tcp::socket &socket, std::function<void (void)> cb);
void readBody(boost::asio::ip::tcp::socket &socket, std::function<void (void)> cb);
};
The methods are defined as follows:
void Header::readHeader(boost::asio::ip::tcp::socket &socket,
std::function<void (void)> cb)
{
boost::asio::mutable_buffer asio_buf = boost::asio::buffer(data(), getHeaderSize());
boost::asio::async_read(socket, asio_buf,
[this, cb](const boost::system::error_code &ec, std::size_t bytes_transferred){
// TAG1
// bytes_transferred: 16 (as expected)
// getDatagramSize() == 116 (as expected)
// getTimestamp() == ... (as expected)
cb();
});
}
void ImuDatagram::readBody(boost::asio::ip::tcp::socket &socket, std::function<void (void)> cb) {
uint64_t dgSize = header.getDatagramSize();
uint64_t jsonSize = dgSize - header.getHeaderSize();
// TAG2
// This will throw std::bad_alloc.
theJson.reserve(jsonSize);
boost::asio::async_read(socket, boost::asio::buffer(theJson, jsonSize),
[this, &socket, cb](const boost::system::error_code &ec, std::size_t bytes_transferred) {
// Error checks omitted
cb();
});
}
void ImuDatagram::readDatagram(boost::asio::ip::tcp::socket &socket, std::function<void (void)> cb) {
header.readHeader(socket, [this, &socket, cb](){
readBody(socket, cb);
});
}
Finally, the main that gets everything going is:
tcp::acceptor imuAcceptor(ioc, tcp::endpoint(tcp::v4(), 8081));
imuAcceptor.async_accept(imuSocket, [this](const boost::system::error_code& ec)
{
// Error checks omitted
ImuDatagram imu;
imu.readDatagram(socket, [this, &imu, &socket]() {
// Do work
});
}
Problem Description
Consider TAG1 in Header::readHeader. 16 bytes were read (the size of the header's buffer), as expected. I confirmed that theJson's buffer wasn't overrun. Nothing wrong yet.
We then move to TAG2 in ImuDatagram::readBody. As indicated, this throws std::bad_alloc.
As part of my debugging, I inserted a protection byte after the header to see if it would get written. At TAG1, it is not written. At TAG2, it was written. At first, I thought async_read was writing past the buffer. But it isn't, as verified with the protection byte I added.
Can someone please tell me where this (obscure to me) bug is? I wrote a simpler version of this using STDIN instead of a socket, and it worked just fine. My suspicion is that the problem doesn't come from the socket though.
Thank you.