boost library multithread socket strangeness - multithreading

Question

I've been stuck for a whole night but can't figure out the problem.
I'm writing a server that accepts connections for a chatroom application. The idea is that the server gives the connected sockets to chat_manager, chat_manager puts them in a waitlist and starts a thread to constantly check if somebody is still in the waitlist. If somebody is in the waitlist, the chat_manager tries to read from the client to determine which room the client wants to join.
main.cpp looks like this :
boost::asio::io_service io_service;
chat_server server(io_service, 8091);
io_service.run();
Chat server code :
chat_server::chat_server(boost::asio::io_service& io_service, int port) : io_service_(io_service),
acceptor_(io_service, tcp::endpoint(tcp::v4(), port)) {
start_accept();
}
void chat_server::start_accept() {
chat_session_ptr new_session(new chat_session(io_service_));
acceptor_.async_accept(new_session->socket(), boost::bind(&chat_server::handle_accept, this, new_session,
boost::asio::placeholders::error));
}
void chat_server::handle_accept(chat_session_ptr s, const boost::system::error_code& error) {
if (!error) { // successfully connected
chat_manager::Instance().chat_session_join(s);
}
start_accept();
}
chat_manager is simply
chat_manager() { // constructor
waitlist_.resize(0);
manager_thread_ = boost::thread(&chat_manager::run, this);
}
int chat_session_join(chat_session_ptr chat_session) {
mutex_.lock();
waitlist_.push_back(chat_session);
mutex_.unlock();
return 1;
}
void run() {
while (1) {
mutex_.lock();
for (auto &s : waitlist_) {
std::string roomname;
if (s->wait_for_join(roomname)) {
...
}
break;
}
mutex_.unlock();
boost::this_thread::sleep( boost::posix_time::milliseconds(10) );
}
}
And session.cpp :
jsoncons::json chat_session::receive_request(boost::system::error_code& error) {
buffer_.consume(buffer_.size());
size_t bytes_transferred;
boost::system::error_code ec = boost::asio::error::would_block;
boost::asio::async_read_until(socket_, buffer_, "\n",
boost::bind(&chat_session::handle_read, shared_from_this(), _1, _2, &ec, &bytes_transferred ));
deadline_.expires_from_now(boost::posix_time::seconds(2));
deadline_.async_wait(boost::bind(&chat_session::check_deadline, shared_from_this()));
do pio_service_->run_one(); while (ec == boost::asio::error::would_block);
std::cout << "got it" << std::endl;
if ( ec || !socket_.is_open() ) {
std::cout << ec.message() << std::endl;
return jsoncons::json();
}
std::istream is(&buffer_);
return jsoncons::json::parse(is);
}
int chat_session::wait_for_join(std::string &roomname) {
boost::system::error_code error;
jsoncons::json request = receive_request(error);
...
}
void chat_session::handle_read(const boost::system::error_code& error, size_t bytes_transferred,
boost::system::error_code* out_error, size_t* out_bytes_transferred) {
deadline_.expires_at(boost::posix_time::pos_infin);
*out_error = error;
*out_bytes_transferred = bytes_transferred;
if (!error) {
} else {
std::cout << "handle_read error:" << error.message() << std::endl;
}
}
What happens is,
1. when the client connects and doesn't send anything, the connection is closed by the server after 2 seconds. which is correct. but
2. if the client sends one string before the connection expires, the server worked its way into handle_read but never gets past pio_service->run_one();
3. if the client send another string, wait_for_join will finish and the run() procedure starts to loop.
To me it seems that the use of io_services here is fine because check_deadline and handle_read worked, but if that really worked it would modify ec != would_block, and the do-while loop should return. What's happening here? I'm really confused.