Accepting multiple connections on a boost asio tcp socket - c++

Question

I want to accept twice on one socket
That is, I listen on a port (an unconnected socket) and want to get two connected sockets in the end.
Said differently, if I accept twice on the same tcp socket, I'm having trouble grokking how to distinguish between the two connected sockets in asio. This is on linux.
I have a relatively simple tcp server class. It assumes that all clients that might connect to it are homogeneous: if a message is waiting to go to a client and none is connected, it can be sent to the next client that does connect. This works great with one connected socket, but now I need to listen on more than one socket (that is, two clients will connect). The homogeneity assumption is still almost true, but now I have the additional constraint that if a message is in response to someone, it should go to that someone. (Replies are often acknowledgements.)
I start by listening and accepting:
short port = kSomethingKnown;
boost::asio::io_service& io_service_;
boost::asio::ip::tcp::socket socket_(io_service_);
boost::asio::ip::tcp::acceptor acceptor_(
io_service_,
boost::asio::ip::tcp::endpoint(tcp::v4(), port));
acceptor_.async_accept(socket_, [this](boost::system::error_code ec) {
if (ec) {
// Failed to accept. Schedule to try again (not shown).
return;
}
// Accepted.
SendMessage(); // Flush any old messages, appropriate with a single client.
ReceiveHeader();
});
Comparison to the BSD socket interface
I'll explain the rest below, but this illustrates the main point. ACCEPT(2) looks like this:
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
The return value, if non-zero, is the file descriptor of the connected socket. That is, if I'm on host H and listening on port P, then sockfd represents an unconnected socket,
(H, P, tcp, 0, 0)
and the file descriptor returned represents a connected socket,
(H, P, tcp, H1, P1)
where H1 is the client host and P1 is the (probably ephemeral) port on the client that is the other side of this socket. If I successfully accept a second time, I'll get another connected socket,
(H, P, tcp, H2, P2)
where at least one of H2 and P2 is different than H1 and P1. I don't see in asio how to refer to these two connected sockets. I've been reading source code, which is teaching me a great deal about how asio works but not how async_accept works.
Ancillary details
Fwiw, here are the details on the send and receive calls, but I think the above is what I really need. Once I understand that, then I use those connected sockets instead of socket_.
SendMessage() exists in a form that takes a message (just pushes it on a deque) and the form above that processes the queue. That second form looks like this:
void SendMessage() {
if (WeAreDead()) {
// This checked that the connection seems valid,
// we aren't being asked to shut down, etc.
return;
}
if (send_queue_.empty()) {
// Nothing to send.
return;
}
boost::asio::async_write(
socket_, boost::asio::buffer(send_queue_.front()),
[this](boost::system::error_code ec, size_t length) {
if (ec) {
// Failed, schedule another attempt, not shown here.
return;
}
send_queue_.pop_front();
if (!send_queue_.empty()) {
SendMessage();
}
});
}
The ReceiveHeader() (and a similar ReceiveBody()) look similar, with the key bit being a call that looks like this:
boost::asio::async_read(
socket_, boost::asio::buffer(receive_buffer_, kTcpHeaderSize),
boost::asio::transfer_exactly(kTcpHeaderSize),
[this](boost::system::error_code ec, std::size_t received_length) {
Again, the part that I'm finding confusing is related to async_accept().

Answer 1

You can do it like this:
acceptor_.async_accept(
[this] (std::error_code ec, tcp::socket&& new_socket) {
In this case you get a new_socket object, which represents the accepted connection. I have taken it from this example.
I hope I understood your question correctly.