Multiple client connections

   .
   .
int sock = socket(PF_INET,SOCK_STREAM,0);
int sock_fd[10];
struct sockaddr_in client_addr[10];
int size = sizeof(&client_addr);

void *Thread1(void *arg){


   for(i=0;i<9;i++){
  sock_fd[i] = accept(sock,(struct sockaddr *)&client_addr[i],size);

}

// Compile gcc server.c -o server -lpthread
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <string.h>
#include <sys/uio.h>
#include <unistd.h>
#include <pthread.h>

// Port that we will be using
#define TCP_PORT   6600

/* function prototypes and global variables */
void *child_thread(void * arg);
pthread_mutex_t lock;
// This is just a cumulative count of how many clients have connected
// since the server was started
int	cumtotalconnections;

int main(void)
{
    int sockfd, newsockfd, clientlength;
    struct sockaddr_in cli_addr, serv_addr;
    pthread_t chld_thread;

    if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
        fprintf(stderr,"server can't open socket\n"), exit(0);

    memset((char *) &serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_addr.sin_port = htons(TCP_PORT);

    if(bind(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0)
        fprintf(stderr,"server can't bind local address\n"), exit(0);
    // The OS threading library maintains a pool of Light Weight Processes, LWPs that it uses to run
    // all the process-scoped user threads.
    // It can reschedule these user threads onto LWPs in the pool as the need arises.
    // The size of this pool can be adjusted via the Pthreads pthread_setconcurrency() function.
    pthread_setconcurrency(5);
    listen(sockfd, 5);
    for(;;) {
        clientlength = sizeof(cli_addr);
        newsockfd = accept(sockfd, (struct sockaddr *) &cli_addr, &clientlength);

        if(newsockfd < 0)
            fprintf(stderr,"server has an accept error\n"), exit(0);

        /* create a new thread to process the incomming request */
        pthread_create(&chld_thread, NULL, child_thread, (void *)newsockfd);
        // the server is now free to accept another socket request
        // since pthread_create is a asynchronous function
    }
    return(0);
}

// Function executed from a new thread

void *child_thread(void *arg)
{
    int 	socketfd = (int) arg;
    char 	data[124]= {0};

    printf("Child thread [%d]: Socket number = %d\n", (int)pthread_self(), socketfd);
    /* read from the given socket */
    read(socketfd, data, 48);
    printf("Child thread [%d]: My data = %s\n", (int)pthread_self(), data);
	// POSIX threads defines a new data type called a mutex, which stands for mutual exclusion.
	// A mutex is used to insure either that only one thread is executing a particular piece of code at
	// once (code locking) or that only one thread is accessing a particular data structure at once (data locking).
	// A mutex belongs either to a particular thread or to no thread (i.e., it is either locked or unlocked).
	// A thread may lock a mutex by calling pthread_mutex_lock. If no other thread has the mutex locked,
	// then the calling thread obtains the lock on the mutex and returns. Otherwise it waits until no other thread has the mutex,
	// and finally returns with the mutex locked. There may, of course, be multiple threads waiting for the mutex to be unlocked.
	// Only one thread can lock the mutex at a time; there is no specified order for which thread gets the mutex next,
	// though the ordering is assumed to be at least somewhat fair.
	// To unlock a mutex, a thread calls pthread_mutex_unlock.

	// use a mutex to update the global cumtotalconnections

    pthread_mutex_lock(&lock);
    cumtotalconnections++;
    pthread_mutex_unlock(&lock);
    /* close the socket and exit this thread */
    close(socketfd);
    pthread_exit((void *)0);
}