How to handle multiple clients in socket programming?

Question

I'm new in socket programming. I'm trying to make simple client, server program where the message sent from client appears on the server window. However it works for only one client. How to handle multiple clients. Thanks in advance. Here's my code
Server.c

#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <string.h>
#include <arpa/inet.h>
#include <errno.h>
#include <unistd.h>

#define ERROR -1
#define MAX_DATA 1024

int main(){
  int welcomeSocket, newSocket;
  char buffer[MAX_DATA];
  int data_len;
  struct sockaddr_in serverAddr;
  int addr_size = sizeof(struct sockaddr_in);

  if((welcomeSocket = socket(PF_INET, SOCK_STREAM, 0)) == ERROR){
    printf("Socket: ");
    exit(-1);
  }
  /* Configure settings of the server address struct */
  serverAddr.sin_family = AF_INET;
  serverAddr.sin_port = htons(9999);
  serverAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
  /* Set all bits of the padding field to 0 */
  memset(serverAddr.sin_zero, '\0', sizeof serverAddr.sin_zero);  

  /* Bind the server address struct to the socket */
  bind(welcomeSocket, (struct sockaddr *) &serverAddr, sizeof(serverAddr));

  /* Listen on the socket, with 5 max connection requests queued */
  if(listen(welcomeSocket,5) == 0)
    printf("Listening\n");
  else
    printf("Error\n");

  while(1){
    /* Accept call for the incoming connection */
    if((newSocket = accept(welcomeSocket, (struct sockaddr *)&newSocket, &addr_size)) == ERROR){
      perror("accept");
      exit(-1);
    }
    data_len = 1;
    while(data_len){
      /* receive msg and print */
      data_len = recv(newSocket, buffer, MAX_DATA, 0);
      if(data_len){
        buffer[data_len] = '\0';
        printf("%s\n", buffer);
      }
    }
  }
  printf("Client Disconnected\n");
  close(newSocket);

  return 0;
}

Answer 1

There are a couple of strategies to handle multiple clinets on server. First is to use threading which means a new thread is assigned to each new client and handles all its traffics. This way main thread is not blocked by read/write or rec/send system calls and is free to handle new incomming clients. Second strategy is to use Non blocking I/O which is a little harder than the first strategy but it is quite good in both performance and resource consumption. Third strategy is to use a unique port number for each client, some commercial programs use this strategy but I do not personnaly advise towards it. If I were to write a server application, which I have done more than that could be counted, I would have chosen non blocking I/O, although it's a little hard to get it to work for first few tries, but it is quite worth it and work in any way better than all other strategies. Search for nonblocking I/O and select() for furthur instructions

Answer 2

You can use multithreading to manage multiple clients at one time, so the server can listen "at the same time" new connections while waiting for each client messages to be received.

When your server call accept(), if no client is joining, the call will "block" the execution until someone is joining.

Then, for the same reason, the call of recv() will block the main thread until a client has sent a message.

Using multithreading will cause the blocking of recv() and accept() won't affect the main thread.