Boost::ASIO cannot write back to client from server - c++

Question

I have a couple questions regarding Boost ASIO.
I'm running into a problem where my clients can connect to a server, and asynchronously send data, but cannot receive anything back. The async_write callback gets error: "The file handle supplied is not valid". I find this strange for a couple reasons:
When the client connects initially, I check socket.isOpen() on the server, and it returns true.
The fact that the client can still send data makes me think that it's a server side problem, or a firewall problem (which I find odd because the server and client are both on the same computer (I'm using "localhost" to connect for now).
Some more info...
TCP Sockets.
I'm using Boost and Allegro side-by-side, and both Boost and Allegro threads are being used. I have my io_service running in a Boost thread like so (server and client):
boost::asio::io_service::work work( io_service );
boost::thread io_thread( boost::bind( &boost::asio::io_service::run, &io_service ) );
and that's being called before I even create the sockets.
The Allegro threads hold the Allegro event loops, nothing special there.
I'd like to not have to post source code, it's pretty large and complicated, and I'd rather not try and simplify it to a basic case. I can if it's necessary though.
My sockets are wrapped by a class in which a shared pointer is created and passed around rather than than a regular pointer (Not sure if that matters, I'm new to Boost).
Thank you for any help you can provide in determining why I cannot write back to the clients I have connected to.
Neil
EDIT: Requested code segments:
async_read/write (server) and callback functions:
void ServerConnection::async_read()
{
if( this->m_socket.is_open() == false )
{
std::cerr << "socket closed... (read)\n";
}
boost::asio::async_read( this->m_socket,
boost::asio::buffer( &m_input, sizeof( m_input ) ),
boost::bind( &ServerConnection::read_callback,
shared_from_this(),
boost::asio::placeholders::error,
boost::asio::placeholders::bytes_transferred ) );
}
void ServerConnection::async_write(const packet_list &packet, packet_id id, uint8_t rr)
{
this->m_output.data = packet;
this->m_output.head.opcode = id;
this->m_output.head.sender_id = 0;
this->m_output.head.response_required = rr;
if( this->m_socket.is_open() )
{
std::cerr << "socket closed... (write)\n";
}
boost::asio::async_write( this->m_socket,
boost::asio::buffer( &m_output, sizeof( m_output ) ),
boost::bind( &ServerConnection::write_callback,
shared_from_this(),
boost::asio::placeholders::error,
boost::asio::placeholders::bytes_transferred ) );
}
void ServerConnection::read_callback( const boost::system::error_code &error,
size_t /*read_count*/ )
{
if( error )
{
std::cerr << "Error reading: " << error.message() << std::endl;
return;
}
std::cerr << "Server reading data...\n";
if( this->m_event_dispatcher != nullptr )
{
ALLEGRO_EVENT event;
if( m_input.head.opcode == C_ACCEPT )
{
event.type = 513;
}
else
{
event.type = 512;
event.user.data1 = (intptr_t)&m_input;
}
al_emit_user_event( this->m_event_dispatcher, &event, nullptr );
}
else
{
std::cerr << "Why is this null....\n";
}
async_read();
}
void ServerConnection::write_callback(const boost::system::error_code &error,
size_t /*write_count*/ )
{
// After a write, we don't need to do anything except error checking.
if( error.value() )
{
std::cerr << "Error writing to client. " << error.message() << std::endl;
}
}