This is my first project in a networks class. I am sorry if my code is attrocious, I'm still trying to wrap my head around socket programming.

I have developed my client-server programs so that I can send messages to the server from multiple clients at once, utilizing detached threads to process all requests. This is no problem. The problem arises in the code to receive an echoed response from the server. I have it so that the server displays the message sent by the client, and this gets jumbled up, sort of like a data race. The echoed message the client gets is also jumbled in the same way. Printing only the buffer (Leaving the explanatory printf() out) works just fine with both the client and the server. My question is: why is my message getting interrupted every 3 characters?

Thanks for reading.

I hope I haven't left too many details out.

Server:
Code:
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#include <netdb.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

 static void *processRequest(void *);

int main(int argc, char *argv[])
{
	int listenFeed, connectionFeed;

	struct sockaddr_in servaddr;


    pthread_t tid;

	listenFeed = socket(AF_INET, SOCK_STREAM, 0);

	bzero(&servaddr, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_port = htons(8888);
	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);

	bind(listenFeed, (struct sockaddr *)&servaddr, sizeof(servaddr));
	listen(listenFeed, 5);

	for( ; ; ){
		connectionFeed = accept(listenFeed, (struct sockaddr *) NULL, NULL);
		pthread_create(&tid, NULL, &processRequest, &connectionFeed);
	}
}

static void *processRequest(void *arg)
    {
		size_t n;
        int     connectionFeed;
    	char buffer[4096];
        connectionFeed = * ((int *) arg);
        pthread_detach (pthread_self());

        bzero(buffer,sizeof(buffer));

    		while ( (n = read(connectionFeed, buffer, sizeof(buffer))) > 0){
    			printf("The message is below");     //<---- this printf gets displayed multiple times and jumbles the received message from the client.
    			printf("%s",buffer);

				write(connectionFeed,buffer,n);
				bzero(buffer,sizeof(buffer));
    		}

    		close(connectionFeed);
    		pthread_exit(0);
    		return (NULL);
    }
And Client:
Code:
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#include <netdb.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>

int createSocket(char * serverName, int port, struct sockaddr_in * dest);
int sendRequest(int sock, char * request, struct sockaddr_in * dest);
int receiveResponse(int sock, char * response);

int main(int argc, char *argv[])
{
	//Declare Variables
	int     	socketFeed, port;
	char    	buffer[4096];
	struct  	sockaddr_in serverAddress;
	struct  	sockaddr_in *serverAddressP;


	port = 8888;
	serverAddressP = &serverAddress; //For use in passing structure to arrays

	//Create the socket and fill in first 3 fields of sockaddr_in structure, then connect to host
	bzero(&serverAddress, sizeof(serverAddress));
	socketFeed = createSocket(argv[1],port,serverAddressP);



	for( ; ; ){
		sendRequest(socketFeed, buffer, serverAddressP);
		receiveResponse(socketFeed, buffer);
	}
	return 0;
}

int createSocket(char * serverName, int port, struct sockaddr_in * dest)
{
	int socketFeed;
	socketFeed = socket(AF_INET, SOCK_STREAM, 0);
	dest->sin_family = AF_INET;
	dest->sin_port = htons(port);
	inet_pton(AF_INET, serverName, &dest->sin_addr);
	connect(socketFeed, (struct sockaddr *)&(*dest), sizeof(*dest));
	return socketFeed;
}

int sendRequest(int sock, char * request, struct sockaddr_in * dest)
{
	bzero(request,sizeof(request));
	fgets(request,sizeof(request),stdin);
	write(sock, request, strlen(request));
}

int receiveResponse(int sock, char * response)
{
	bzero(response,sizeof(response));
	read(sock,response,sizeof(response));     // <---- Troublesome code
	printf("Echo of your message:\n");        // <----
	printf("%s",response);                    // <---- Displays "Echo of your message\n" every 3 displayed characters of the response buffer
}