Multithreaded Socket programming server is getting messages from only 1 client thread - c++

Question

For a benchmarking task, I'm creating multiple server workers with the same socket descriptor and client workers with separate connections.
Though client threads are sending a copy of the same message for each thread. The server shows it's received only one copy of each message, not all copies, sent by sending by all client threads.
for 4 threads and 2 messages {0,1} , client output
client 3Wrote 0
client 1Wrote 1
client 0Wrote 0
client 1Wrote 0
client 2Wrote 0
client 3Wrote 1
client 2Wrote 1
Where as server output
Server 0 Received - 0
Server 2 Received - 1
Why aren't rest of the messages showing up ? Or they were never actually sent by the client ?
void *clientWorker(void *threadarg) {
struct workDetails *thisWork;
thisWork = (struct workDetails *) threadarg;
int threadcount = thisWork->threadcount;
int chunkSize = thisWork->chunkSize;
char *serverIp = thisWork->serverIp;
char *dataStore = thisWork->dataStore;
int sockfd;
struct sockaddr_in serv_addr;
struct hostent *server;
char *buffer = (char *) calloc(chunkSize, sizeof(char));
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0) error("ERROR opening client socket");
server = gethostbyname(serverIp);
if (server == NULL) error("Could not detect server by node name");
bzero((char *) &serv_addr, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
bcopy((char *) server->h_addr,
(char *) &serv_addr.sin_addr.s_addr,
server->h_length);
serv_addr.sin_port = htons(PORTNO);
if (connect(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0)
error("Server is not up.");
long totalPackets = oneGBtoByte / (chunkSize * threadcount);
long i;
for (i = 0; i < totalPackets; ++i) {
sprintf(buffer, "%ld", i);
if (write(sockfd, buffer, chunkSize) < 0)
error("ERROR writing to socket");
else {
lock_guard<mutex> guard(cout_mutex);
cout << " client " << thisWork->threadid << "Wrote " << i << endl;
}
}
cout << " client " << thisWork->threadid << "Exit";
pthread_exit((void *) NULL);
}
void *serverWorker(void *threadarg) {
struct workDetails *thisWork;
thisWork = (struct workDetails *) threadarg;
int threadcount = thisWork->threadcount;
int chunkSize = thisWork->chunkSize;
char *dataStore = thisWork->dataStore;
int sockfd = thisWork->sockfd;
char *buffer = new char[chunkSize];
while (1) {
if(read(sockfd, buffer, chunkSize) > 0){
lock_guard<mutex> guard(cout_mutex);
cout << "Server " << thisWork->threadid << " Received - " << buffer << endl;
}
}
pthread_exit((void *) NULL);
}

Answer 1

The problem is accept connection code was in the main thread(As not visible in the code). And hence server accepted only one connection though client tried to create 4 connection. And the out put did not reveal this issue as the code doesn't send an acknowledgment back or forth. (No ping pong . ideally most receive is followed by send ack, and every send is followed by recv ack).
When I moved that accept connection code to thread worker . It worked as intended.
void *serverWorker(void *threadarg) {
struct workDetails *thisWork;
thisWork = (struct workDetails *) threadarg;
int threadcount = thisWork->threadcount;
int chunkSize = thisWork->chunkSize;
char *dataStore = thisWork->dataStore;
int sockfd = thisWork->sockfd;
struct sockaddr_in cli_addr; // = thisWork->cli_addr;
char *buffer = new char[chunkSize];
listen(sockfd, 5);
socklen_t clilen = sizeof(cli_addr);
sockfd = ::accept(sockfd, (struct sockaddr *) &cli_addr, &clilen);
if (sockfd < 0)
error("ERROR on accept");
while (1) {
if (recv(sockfd, buffer, chunkSize, 0) > 0) {
//lock_guard<mutex> guard(cout_mutex);
//cout << "Server " << thisWork->threadid << " Received - " << buffer << endl;
buffer[chunkSize] = NULL;
strncat(dataStore, buffer, strlen(buffer));
if (strlen(dataStore) == oneGBtoByte) {
cout << "Done - " << endl;
storeInfile(created, dataStore);
break;
}
}
}
//End
delete[] buffer;
pthread_exit((void *) NULL);
}
How ever what ever #jeremy-friesner or #gil-hamilton told is true. But those issues are not important here , as I'm only interested in total byte received and not who received which chunk.