c++ linux accept() blocking after socket closed

Use: sock.shutdown (socket.SHUT_RD)

Then accept will return EINVAL. No ugly cross thread signals required!

From the Python documentation:"Note close() releases the resource associated with a connection but does not necessarily close the connection immediately. If you want to close the connection in a timely fashion, call shutdown() before close()."

http://docs.python.org/3/library/socket.html#socket.socket.close

I ran into this problem years ago, while programming in C. But I only found the solution today, after running into the same problem in Python, AND pondering using signals (yuck!), AND THEN remembering the note about shutdown!

As for the comments that say you should not close/use sockets across threads... in CPython the global interpreter lock should protect you (assuming you are using file objects rather than raw, integer file descriptors).

Here is example code:

import socket, threading, timesock = socket.socket (socket.AF_INET, socket.SOCK_STREAM)sock.setsockopt (socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)sock.bind (('', 8000))sock.listen (5)def child ():  print ('child  accept ...')  try:  sock.accept ()  except OSError as exc :  print ('child  exception  %s' % exc)  print ('child  exit')threading.Thread ( target = child ).start ()time.sleep (1)print ('main   shutdown')sock.shutdown (socket.SHUT_RD)time.sleep (1)print ('main   close')sock.close ()time.sleep (1)print ('main   exit')

The behavior of accept when called on something which is not a valid socket FD is undefined. "Not a valid socket FD" includes numbers which were once valid sockets but have since been closed. You might say "but Borealid, it's supposed to return EINVAL!", but that's not guaranteed - for instance, the same FD number might be reassigned to a different socket between your close and accept calls.

So, even if you were to isolate and correct whatever makes your program fail, you could still begin to fail again in the future. Don't do it - correct the error that causes you to attempt to accept a connection on a closed socket.

If you meant that a call which was previously made to accept continues blocking after close, then what you should do is send a signal to the thread which is blocked in accept. This will give it EINTR and it can cleanly disengage - and then close the socket. Don't close it from a thread other than the one using it.

The shutdown() function may be what you are looking for. Calling shutdown(Listen_fd, SHUT_RDWR) will cause any blocked call to accept() to return EINVAL. Coupling a call to shutdown() with the use of an atomic flag can help to determine the reason for the EINVAL.

For example, if you have this flag:

std::atomic<bool> safe_shutdown(false);

Then you can instruct the other thread to stop listening via:

shutdown_handler([&]() {  safe_shutdown = true;  shutdown(Listen_fd, SHUT_RDWR);});

For completeness, here's how your thread could call accept:

while (true) {  sockaddr_in clientAddr = {0};  socklen_t clientAddrSize = sizeof(clientAddr);  int connSd = accept(Listen_fd, (sockaddr *)&clientAddr, &clientAddrSize);  if (connSd < 0) {    // If shutdown_handler() was called, then exit gracefully    if (errno == EINVAL && safe_shutdown)      break;    // Otherwise, it's an unrecoverable error    std::terminate();  }  char clientname[1024];  std::cout << "Connected to "            << inet_ntop(AF_INET, &clientAddr.sin_addr, clientname,                         sizeof(clientname))            << std::endl;  service_connection(connSd);}