Single connection server socket - c++

Question

I want to implement a server c++ server program (under linux) using the standard (socket.h) library which shall accept only one active connection. My understanding of how to implement this is this (i have removed the error checking):
int port = 4711;
int MAXCONNECTIONS = 5;
int m_sock;
m_sock = socket ( AF_INET, SOCK_STREAM, 0 );
int on = 1;
setsockopt ( m_sock, SOL_SOCKET, SO_REUSEADDR, &on, sizeof ( on ) ) < 0
sockaddr_in m_addr;
m_addr.sin_family = AF_INET;
m_addr.sin_addr.s_addr = INADDR_ANY;
m_addr.sin_port = htons ( port );
bind ( m_sock, ( struct sockaddr * ) &m_addr,
sizeof ( m_addr ) );
listen ( m_sock, MAXCONNECTIONS );
// now accept new connection and get socket
int con_sock;
int addr_length = sizeof ( m_addr );
con_sock = accept ( m_sock, ( sockaddr * ) &m_addr, ( socklen_t * ) &addr_length );
This works so far in my code. But the first socket created will still accept connections. As far as I understand it I need to close the first socket now.
close ( m_sock );
This prevents new connections. But now I am unable to reastablish any connections when the first one blows. From my understand I would have to repeat the same procude as above.
What I encounter is that my code runs well until the accept where it would block and wait for connections but client connecting will receive "Connection refused" and I cannot see any LISTEN ports in netstat.
Do you have any ideas?
The option to accept other connections and close them immediately shall not be regarded here.

Answer 1

Just don't accept(2) new connections until you need to. Loop over accepting, processing client dialogue, and closing the connected socket.

Answer 2

To start with, try changing the second line of code (currently int MAXCONNECTIONS = 5;)

Answer 3

Firstly, let's differentiate between a listening socket and a connected socket. A listening socket is one on which the server listens, i.e. waits for clients. Once the call to accept returns, it means that the 3-way handshake with the client is complete and accept returns a connected socket. Connected socket is the one through which the actual communication with the client takes place.
In your example, m_sock is a listening socket and con_sock is the connected socket. When you are closing 'm_sock', you are actually closing the listening socket and therefore the server cannot accept any more connections and that is why the connection refused error on the client side.
If processing only one request at a time is your task, i guess what you need is an iterative server. You don't need to close the listening socket as the next request will be processed only after the previous one has been completely processed.
listen ( m_sock, MAXCONNECTIONS );
// now accept new connection and get socket
int con_sock;
int addr_length = sizeof ( m_addr );
for(;;)
{
con_sock = accept ( m_sock, ( sockaddr * ) &m_addr, ( socklen_t * ) &addr_length );
//do your task
close(con_sock);
}
If you want to refuse the connections to other connections while one request is being processed, you might want to reduce the backlog value to 1. This however will not send ECONNREFUSE error to the client but will just ignore the client request. However, when the server is idle, even then only one connection is what the server will have in its queue. (Not so sure why actually you would want to do this.)