Exact order of actions when running a server with threads - c++

Question

I need to create a server in c++, where it can respond to more than 1 customer, thus use threads.
This is my class Socket, where the actual communication is done:
typedef struct addrinfo addinfo;
class Socket
{
private:
WSADATA _wsaData;
int _iResult;
SOCKET _ListenSocket;
addrinfo* _result;
addrinfo _hints;
int _iSendResult;
char _recvbuf[BUF_LEN];
int _recvbuflen;
std::vector<SOCKET> _ClientSockets;
public:
Socket();
bool Setup();
bool CreateSocket();
bool Bind();
bool Listen();
bool Accept();
bool Send();
bool Shutdown();
~Socket();
};
Socket::Socket()
{
_ListenSocket = INVALID_SOCKET;
_ClientSockets.push_back(INVALID_SOCKET);
_result = NULL;
_recvbuflen = BUF_LEN;
}
bool Socket::Setup() {
_iResult = WSAStartup(MAKEWORD(2, 2), &_wsaData);
if (_iResult != 0) {
std::cout << "WSAStartup failed with error: " << _iResult << std::endl;
return false;
}
ZeroMemory(&_hints, sizeof(_hints));
_hints.ai_family = AF_INET;
_hints.ai_socktype = SOCK_STREAM;
_hints.ai_protocol = IPPROTO_TCP;
_hints.ai_flags = AI_PASSIVE;
_iResult = getaddrinfo(NULL, DEFAULT_PORT, &_hints, &_result);
if (_iResult != 0) {
std::cout << "getaddrinfo failed with error: " << _iResult << std::endl;
WSACleanup();
return false;
}
return true;
}
bool Socket::CreateSocket() {
_ListenSocket = socket(_result->ai_family, _result->ai_socktype, _result->ai_protocol);
if (_ListenSocket == INVALID_SOCKET) {
std::cout << "socket failed with error: " << WSAGetLastError() << std::endl;
freeaddrinfo(_result);
WSACleanup();
return false;
}
return true;
}
bool Socket::Bind() {
_iResult = bind(_ListenSocket, _result->ai_addr, (int)_result->ai_addrlen);
if (_iResult == SOCKET_ERROR) {
std::cout << "bind failed with error: " << WSAGetLastError() << std::endl;
freeaddrinfo(_result);
closesocket(_ListenSocket);
WSACleanup();
return false;
}
freeaddrinfo(_result);
return true;
}
bool Socket::Listen() {
_iResult = listen(_ListenSocket, SOMAXCONN);
if (_iResult == SOCKET_ERROR) {
std::cout << "listen failed with error: " << WSAGetLastError() << std::endl;
closesocket(_ListenSocket);
WSACleanup();
return false;
}
return true;
}
bool Socket::Accept() {
_ClientSockets.push_back(accept(_ListenSocket, NULL, NULL));
if (_ClientSockets[_ClientSockets.size() - 1] == INVALID_SOCKET) {
std::cout << "accept failed with error: " << WSAGetLastError() << std::endl;
closesocket(_ListenSocket);
WSACleanup();
return false;
}
return true;
}
bool Socket::Send() {
closesocket(_ListenSocket);
_iResult = recv(_ClientSockets[_ClientSockets.size() - 1], _recvbuf, _recvbuflen, 0);
if (_iResult > 0) {
_iSendResult = send(_ClientSockets[_ClientSockets.size() - 1], "Accepted", strlen("Accepted"), 0);
if (_iSendResult == SOCKET_ERROR) {
std::cout << "send failed with error: " << WSAGetLastError() << std::endl;
closesocket(_ClientSockets[_ClientSockets.size() - 1]);
WSACleanup();
return false;
}
}
else if (_iResult == 0)
std::cout << "Connection closing..." << std::endl;
else {
std::cout << "recv failed with error: " << WSAGetLastError() << std::endl;
closesocket(_ClientSockets[_ClientSockets.size() - 1]);
WSACleanup();
return false;
}
return true;
}
bool Socket::Shutdown() {
_iResult = shutdown(_ClientSockets[_ClientSockets.size() - 1], SD_SEND);
if (_iResult == SOCKET_ERROR) {
std::cout << "shutdown failed with error: " << WSAGetLastError() << std::endl;
closesocket(_ClientSockets[_ClientSockets.size() - 1]);
WSACleanup();
return false;
}
closesocket(_ClientSockets[_ClientSockets.size() - 1]);
WSACleanup();
return true;
}
Socket::~Socket()
{
}
this is the main file:
void interact(Socket* socket);
int main() {
Socket* socket = new Socket();
socket->Setup();
socket->CreateSocket();
socket->Bind();
socket->Listen();
while (1) {
socket->Accept();
std::thread trd(interact, socket);
trd.join();
system("PAUSE");
}
socket->Shutdown();
system("PAUSE");
return 0;
}
void interact(Socket* socket) {
std::cout << "Accepted" << std::endl;
socket->Send();
}
Communicating with the first client is fine, but after I try to get back to listening and finish communication with the last client, it gives me error code 10038 for accept and 10093 for recv. I can't understand what the error codes actually mean in my code. I suspect it might be with the way I'm using Accept. Is it supposed to be in the interact function, or before i call the thread? Can I have some directing?

Answer 1

So your effective control flow is:
while (1) {
socket->Accept(); // uses socket->_ListenSocket
interact(socket); // calls socket->Send()
socket->Send(); // calls closesocket(_ListenSocket);
since you deliberately closed the listening socket, why would you expect a subsequent call to accept to work?
Other notes:
you're passing the entire server socket to each client thread, which is much more than it needs. Each client task should only need its own client socket, and would then be unable to damage your server socket as it does here.
you're currently serializing everything by joining the thread, but if you want parallelism, you need to detach this instead. This will further break the existing model of each thread taking the last client socket from the Socket's array (without synchronization).
It's often a better idea to have a thread pool for processing tasks, and make each task a client request with its own socket. This way you're not creating and destroying threads all the time, and it forces you to think about what constitutes a self-contained task