Affected files:

• util/net/listen.h
• util/net/listen.cpp

The sockets created by Listener::setupSockets() and stored in Listener::_socks are also passed to ListeningSockets::add(). This creates a point of dual ownership, where ListeningSockets::closeAll() is responsible for closing sockets that Listener::initAndListen() loops over until inShutdown().

More specifically the race comes from:

1. Listener::setupSockets() called
   1. some number of sockets are created
   2. sockets are added to Listener::_socks
   3. sockets are added to ListeningSockets::add()
2. Listener::initAndListen() called
   1. The Listener begins looping over the sockets it created. It does this until inShutdown()
3. ListeningSockets::closeAll() called
   1. the mutex doesn't do anything because Listener has the same set of sockets in it's own private vector
   2. Sockets are all closed immediately
4. Listener::initAndListen() asserts with an invalid socket from either select() or WSAEventSelect()
   1. one of the sockets Listener is iterating over has been closed, and is no longer valid

I'm not entirely clear on whether the server manages this shutdown cleanly (by putting the Listener into inShutdown() before calling closeAll()), or if calling dbexit() leads to an _exit() fast enough to skip by the race. But either way it's awkward in the extreme to make another, ostensibly thread safe, class responsible for resources that Listener owns and continuously works on.

Ideally Listener would either be responsible for it's own sockets, or ListeningSockets would have some kind of api for checking sockets out for a duration to allow for actual thread safe processing.