TCP server and process client request

[NIUStudent]

New to the forum, 
I run it with this code executable, localhost and a port number on one terminal. On the other terminal i run a given TCP client program, localhost, same port number, and the "GET /" string. On the first terminal says recieve: success. It does with other GET commands as well. Is it going to the error after the read? If so how do i make it so it processes the GET correctly?
Thanks

my code is:
/*
TCP server program 
*/

#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <netinet/in.h>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <errno.h>
#include <dirent.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sstream>

[code]using namespace std;

// function to run the child process
void processRequest(int connSock)
{
	char buffer[1024],
		 path[1024];
	int file;
		 
// read a message from the client			 
	if ((read(connSock, path, sizeof(path))) < 0);
	{
		perror("recieve");
		exit(EXIT_FAILURE);
	}
	 
	string Spath(path);
	
	string v1, v2;

// separate the path after the GET
	std::istringstream iss(Spath);
	iss >> v1;
	iss >>v2;

// decisions for determining if correctly typed by client
	if (v1 == "GET")
	{		  								 	
		if (v2.at(0) == '/' && v2.find("..") != string::npos)				
		{	
			if (v2 == "/")
			v2.append(".");
		}
		
		else
		{
			perror("invalid path");
			exit(EXIT_FAILURE);
		}
	}
	 
	else
	{
		perror("no GET");
		exit(EXIT_FAILURE);
	}

// create stat to determine if the path entered
// by the client is a file or directory
	struct stat newPath;
	
	if(S_ISREG(newPath.st_mode)) {}	
	if(S_ISDIR(newPath.st_mode)) {}
				  
// open directory	
	DIR *dirp = opendir(path);
		
	if (dirp == 0) 
	{
// tell client that an error occurred
// duplicate socket descriptor into error output
		close(2);
		dup(connSock);
		perror(path);
		exit(EXIT_SUCCESS);
	}
		 
// read directory entries
	struct dirent *dirEntry;
		
	while ((dirEntry = readdir(dirp)) != NULL) 
	{
		strcpy(buffer, dirEntry->d_name);
				
		if (write(connSock, buffer, strlen(buffer)) < 0) 
		{
			perror("write");
			exit(EXIT_FAILURE);
		}

// if the directory has index.html send it to client
		if (strcmp(buffer, "index.html"))
		{
			if (write(connSock, path, strlen(path)) < 0) 
			{
				perror("write");
				exit(EXIT_FAILURE);
			}
		}
				 
		else
		{
			strcat(buffer, " ");
		
			if (write(connSock, buffer, strlen(buffer)) < 0) 
			{
				perror("write");
				exit(EXIT_FAILURE);
			}
		}
	}
			 		  
	closedir(dirp);
	
//open the file and display if not a directory
	file = open(path, O_RDONLY);
			 
	if (file == -1)
	{
		cerr << path;
		exit(EXIT_FAILURE);
	}

// print contents of file if the path is a file	  	  
	if (file != -1)
	{
		strcpy(buffer, "... content of ");
		strcat(buffer, path);
		strcat(buffer, "\n");
		strcat(buffer, ".... ");
	}		  	
	
	close(file);
	 
	close(connSock);
	exit(EXIT_SUCCESS);
 }
 
int main(int argc, char* argv[]) 
{
	if (argc != 3) 
	{
		cerr << "USAGE: echoTCPClient server_ip port message\n";
		exit(EXIT_FAILURE);
	}
	int sock = socket(AF_INET, SOCK_STREAM, 0);
	
	if (sock < 0) 
	{
		perror("socket");
		exit(EXIT_FAILURE);
	}
	 	
// create address structures
	struct sockaddr_in server_address;  // structure for address of server
	struct sockaddr_in client_address;  // structure for address of client
	unsigned int addrlen = sizeof(client_address);	

// Construct the server sockaddr_in structure 
	memset(&server_address, 0, sizeof(server_address));   
	server_address.sin_family = AF_INET;                 
	server_address.sin_addr.s_addr = INADDR_ANY;         
	server_address.sin_port = htons(atoi(argv[1]));       

// Bind the socket
	if (bind(sock, (struct sockaddr *) &server_address, sizeof(server_address)) < 0) 
	{
		perror("bind");
		exit(EXIT_FAILURE);
	}	
	 
	if (listen(sock, 64) < 0) 
	{
		perror("listen");
		exit(EXIT_FAILURE);
	}
	 
	while (true) 
	{
		int connSock = accept(sock, (struct sockaddr *) &client_address, &addrlen);
		
		if (connSock < 0) 
		{
			perror("accept");
			exit(EXIT_FAILURE);
		}
		 
		if (fork())
		  close(connSock);
		else
		  processRequest(connSock);
	}
	 
	close(sock);	
	return 0;
}
   

[kbw]

Can you please use the code format tags to format your code.

There's a bit going on that doesn't make sense, it looks like a lot of pasting from different examples.

Take your treatment of fork(), or dup(connSock) or the processing of the input string as examples.

Any chance of reviewing your code and fixing the basics before moving on to processing the input?

[NIUStudent]

I am mainly just looking for help on the proccessRequest(). The rest was given by the teacher.

[kbw]

That code will generate a new zombie process for every client connection.

[NIUStudent]

should I call the wait() process for the parent somewhere to get rid of the zombie process?

[jonnin]

you should think about what you want it to DO.
when a user disconnects, you need to destroy or recycle the connection.
when a user connects, you create or assign one.

It looks like you are starting with too much stuff. Do your programs work now? If not:
Get a small program working that uses a subset of the code and build up. Can you make a client and server program, run them on 2 machines or VMs or whatever, and tell each other one string of test data that you write to the screen?

[NIUStudent]

I want the program to open given directories and files.
The program compiles, and it sends the receive perror back to the server when I try anything from an already given client program.
If I just use the open directory code of the processRequest() it works, but I don't know how to fix what I have now.

[salem c]

Your mis-placed ; means you have this

// read a message from the client			 
	if ((read(connSock, path, sizeof(path))) < 0)
	{
		// Do nothing.
	}
	{
		perror("recieve");
		exit(EXIT_FAILURE);
	}

Also, read() does NOT append a \0 to make it a proper C-style string.
So you would need something like

ssize_t len = read(connSock, path, sizeof(path));
// error check
string Spath(path,len);

You also need to be aware that socket streams only preserve byte order. The client might send "GET foo" in a single call, but you might end up reading only "GE" on the first read call. You would have to call read again (and again) to eventually fetch all of "GET foo".
On a localhost connection, you're probably OK.
But when you're talking to a remote with random bandwidth issues at any point along the way, you will end up with message fragmentation, and correct reassembly is something you need to cater for.