Question

I’m writing a web server in C (which I suck with) using Pthreads (which I suck with even more) and I’m stuck at this point. The model for the server is boss-worker so the boss thread instantiates all worker threads at the beginning of the program. There is a global queue that stores the socket of the incoming connection(s). The boss thread is the one that adds all items (sockets) to the queue as the connections are accepted. All of the worker threads then wait for an item to be added to a global queue in order for them to take up the processing.

The server works fine as long as I connect to it less times than the number of worker threads that the server has. Because of that, I think that either something is wrong with my mutexes (maybe the signals are getting lost?) or the threads are being disabled after they run once (which would explain why if there are 8 threads, it can only parse the first 8 http requests).

Here is my global queue variable.

int queue[QUEUE_SIZE];

This is the main thread. It creates a queue struct (defined elsewhere) with methods enqueue, dequeue, empty, etc. When the server accepts a connection, it enqueues the socket that the incoming connection is on. The worker threads which were dispatched at the beginning are constantly checking this queue to see if any jobs have been added, and if there are jobs, then they dequeue the socket, connect to that port, and read/parse/write the incoming http request.

int main(int argc, char* argv[])
{
int hSocket, hServerSocket;  /* handle to socket */
struct hostent* pHostInfo;   /* holds info about a machine */
struct sockaddr_in Address; /* Internet socket address stuct */
int nAddressSize = sizeof(struct sockaddr_in);
int nHostPort;
int numThreads;
int i;

init(&head,&tail);

//**********************************************
//ALL OF THIS JUST SETS UP SERVER (ADDR STRUCT,PORT,HOST INFO, ETC)
if(argc < 3) {
    printf("\nserver-usage port-num num-thread\n");
    return 0;
}
else {
    nHostPort=atoi(argv[1]);
    numThreads=atoi(argv[2]);
}

printf("\nStarting server");

printf("\nMaking socket");
/* make a socket */
hServerSocket=socket(AF_INET,SOCK_STREAM,0);

if(hServerSocket == SOCKET_ERROR)
{
    printf("\nCould not make a socket\n");
    return 0;
}

/* fill address struct */
Address.sin_addr.s_addr = INADDR_ANY;
Address.sin_port = htons(nHostPort);
Address.sin_family = AF_INET;

printf("\nBinding to port %d\n",nHostPort);

/* bind to a port */
if(bind(hServerSocket,(struct sockaddr*)&Address,sizeof(Address)) == SOCKET_ERROR) {
    printf("\nCould not connect to host\n");
    return 0;
}
/*  get port number */
getsockname(hServerSocket, (struct sockaddr *) &Address,(socklen_t *)&nAddressSize);

printf("Opened socket as fd (%d) on port (%d) for stream i/o\n",hServerSocket, ntohs(Address.sin_port));

printf("Server\n\
      sin_family        = %d\n\
      sin_addr.s_addr   = %d\n\
      sin_port          = %d\n"
      , Address.sin_family
      , Address.sin_addr.s_addr
      , ntohs(Address.sin_port)
    );
//Up to this point is boring server set up stuff. I need help below this.
//**********************************************

//instantiate all threads
pthread_t tid[numThreads];

for(i = 0; i < numThreads; i++) {
    pthread_create(&tid[i],NULL,worker,NULL);
}

printf("\nMaking a listen queue of %d elements",QUEUE_SIZE);
/* establish listen queue */
if(listen(hServerSocket,QUEUE_SIZE) == SOCKET_ERROR) {
    printf("\nCould not listen\n");
    return 0;
}

while(1) {

    pthread_mutex_lock(&mtx);
    printf("\nWaiting for a connection");

    while(!empty(head,tail)) {
        pthread_cond_wait (&cond2, &mtx);
    }

    /* get the connected socket */
    hSocket = accept(hServerSocket,(struct sockaddr*)&Address,(socklen_t *)&nAddressSize);

    printf("\nGot a connection");

    enqueue(queue,&tail,hSocket);

    pthread_mutex_unlock(&mtx);
    pthread_cond_signal(&cond);     // wake worker thread
}
}

Here is the worker thread. This should be always running checking for new requests (by seeing if the queue is not empty). At the end of this method, it should be deferring back to the boss thread to wait for the next time it is needed.

void *worker(void *threadarg) {

pthread_mutex_lock(&mtx);

while(empty(head,tail)) {
    pthread_cond_wait(&cond, &mtx);
}
int hSocket = dequeue(queue,&head);

unsigned nSendAmount, nRecvAmount;
char line[BUFFER_SIZE];

nRecvAmount = read(hSocket,line,sizeof line);
printf("\nReceived %s from client\n",line);


//***********************************************
//DO ALL HTTP PARSING (Removed for the sake of space; I can add it back if needed)
//*********************************************** 


nSendAmount = write(hSocket,allText,sizeof(allText));

if(nSendAmount != -1) {
    totalBytesSent = totalBytesSent + nSendAmount;
}
printf("\nSending result: \"%s\" back to client\n",allText);

printf("\nClosing the socket");
/* close socket */
if(close(hSocket) == SOCKET_ERROR) {
    printf("\nCould not close socket\n");
    return 0;
}


pthread_mutex_unlock(&mtx);
pthread_cond_signal(&cond2);
}

Any help would be greatly appreciated. I can post more of the code if anyone needs it, just let me know. I’m not the best with OS stuff, especially in C, but I know the basics of mutexes, cond. variables, semaphores, etc. Like I said, I’ll take all the help I can get. (Also, I’m not sure if I posted the code exactly right since this is my first question. Let me know if I should change the formatting at all to make it more readable.)

Thanks!

Answer 1

Time for a workers’ revolution.

The work threads seem to be missing a while(true) loop. After the HTTP exchange and closing the socket, they should be looping back to wait on the queue for more sockets/requests.