Multiple connections on the same boost tcp socket object - c++

Question

In this example(async_tcp_echo_server.cpp),
#include <cstdlib>
#include <iostream>
#include <memory>
#include <utility>
#include <boost/asio.hpp>
using boost::asio::ip::tcp;
class session
: public std::enable_shared_from_this<session>
{
public:
session(tcp::socket socket)
: socket_(std::move(socket))
{
}
void start()
{
do_read();
}
private:
void do_read()
{
auto self(shared_from_this());
socket_.async_read_some(boost::asio::buffer(data_, max_length),
[this, self](boost::system::error_code ec, std::size_t length)
{
if (!ec)
{
do_write(length);
}
});
}
void do_write(std::size_t length)
{
auto self(shared_from_this());
boost::asio::async_write(socket_, boost::asio::buffer(data_, length),
[this, self](boost::system::error_code ec, std::size_t /*length*/)
{
if (!ec)
{
do_read();
}
});
}
tcp::socket socket_;
enum { max_length = 1024 };
char data_[max_length];
};
class server
{
public:
server(boost::asio::io_service& io_service, short port)
: acceptor_(io_service, tcp::endpoint(tcp::v4(), port)),
socket_(io_service)
{
do_accept();
}
private:
void do_accept()
{
acceptor_.async_accept(socket_,
[this](boost::system::error_code ec)
{
if (!ec)
{
std::make_shared<session>(std::move(socket_))->start();
}
do_accept();
});
}
tcp::acceptor acceptor_;
tcp::socket socket_;
};
int main(int argc, char* argv[])
{
try
{
if (argc != 2)
{
std::cerr << "Usage: async_tcp_echo_server <port>\n";
return 1;
}
boost::asio::io_service io_service;
server s(io_service, std::atoi(argv[1]));
io_service.run();
}
catch (std::exception& e)
{
std::cerr << "Exception: " << e.what() << "\n";
}
return 0;
}
multiple sessions are using the same boost::ip::tcp::socket object. Inside do_accept() function, upon every incoming connection we are creating a new session object and passing socket_ to it by rvalue reference i.e. by std::move().
Let's say we have two connections (S1 and S2) which are active. The structure will roughly look like this
Server
|
|_ socket_
/\
/ \
/ \
S1 S2
So both S1 and S2 will be using the same socket_ to read/write messages from/to the network.
I have two questions about this:
For the first connection everything is fine, but why is the second connection supposed to work all right? Haven't we already transferred the ownership of socket_ to the first session?
How is it ensured that reply is being sent to the correct client? Whenever something arrives on the socket, can't any one of the two async_read_some get triggered?

Answer 1

For the first connection everything is fine, but why is the second connection supposed to work all right? Haven't we already transferred the ownership of socket_ to the first session?
After moving from the socket, the socket happens to be essentially "empty" or "newly created". That's why this works.
And no, the socket object does not "magically" share identity with the moved instances. In fact, the identity is little more than the underlying socket handle, which is obviously not shared.
But what happens in case of a second connection, as we are using the same socket in all connections?
You're not. You're not using the same socket handle. Neither are you using the same asio::ip::tcp::socket object instance.