added signal handlers

- added signal handler to reap off zombie processes
- added basic exception handling for smooth exit
- closed unused listening sockets
- added big test files to gitignore

Author: jatin69

.gitignore

@@ -17,4 +17,6 @@ obj/
 *.exe
 *.o
 *.out
-*.gch
+*.gch
+*.html
+*.mp4

makefile

@@ -84,24 +84,18 @@ $(UTILS_OBJ_DIR)/%.o: $(UTILS_SRC_DIR)/%.cpp
 	$(CXX) $(CFLAGS) -c -o $@ $<
 
 
-# ===================== CLEAN UP RULES =====================
+# ================ CLEAN UP RULES ==================
 
 .PHONY: clean
 
-clean: clean-server clean-client clean-utils clean-bin
+clean: clean-obj clean-bin
 	@echo "Cleanup successful."
 
-clean-server:
-	$(RM) $(SERVER_OBJ_FILES)
-
-clean-client:
-	$(RM) $(CLIENT_OBJ_FILES)
-
-clean-utils:
-	$(RM) $(UTILS_OBJ_FILES)
+clean-obj:
+	$(RM) $(shell find ./obj -name "*.o")
 
 clean-bin:
-	$(RM) ./bin/server ./bin/client
+	$(RM) $(shell find ./bin -name "*.o")
 
 # =========================================================
 

src/client/createDataConnection.cpp

@@ -54,5 +54,8 @@ int Client::createDataConnection(int controlConnectionfd) {
 		dataConnectionfd = Accept(dataConnectionSocketfd, ipAddressOfDataServer);
 	}
 
+	// listening is no longer needed
+	close(dataConnectionSocketfd);
+	
 	return dataConnectionfd;
 }

src/client/createSocketAndConnectToHost.cpp

@@ -120,7 +120,7 @@ int createSocketAndConnectToHost(const char* host, int portNumber) {
 	// Print out IP address
 	char s[INET6_ADDRSTRLEN];
 	get_ip_str((const struct sockaddr*)p->ai_addr, s, sizeof s);
-	fprintf(stdout, "\n[CLIENT:CONNECTION:test] Connected to %s\n", s);
+	fprintf(stdout, "\n[CLIENT:CONNECTION] Connected to %s\n", s);
 
 	/* Don't need the structure with address info any more
 	 *

src/client/main.cpp

@@ -1,45 +1,31 @@
 #include "./client.hpp"
 
-// prototypes for functions used below
-
 // parsing user's command line arguments
 Client parseArgs(int, char**);
 
-// signal handlers
-void segmentationFaultHandler(int sig);
+// install Required signal handlers
+void InstallSignalHandlers();
 
 // execution of client executable starts from here
 int main(int argc, char** argv) {
-	// segmentation fault handler
-	signal(SIGSEGV, segmentationFaultHandler);
-
-	// create a FTP client
-	Client ftpClient = parseArgs(argc, argv);
-
-	// create a socket and connect to Server
-	int controlConnectionfd = createSocketAndConnectToHost(
-		ftpClient.getControlConnectionIP(), ftpClient.getControlConnectionPortNumber());
-
-	// Start the FTP protocol
-	ftpClient.initiateProtocolInterpreter(controlConnectionfd);
+	try {
+		// installing signal Handlers
+		// Here - segmentation fault
+		InstallSignalHandlers();
+
+		// create a FTP client
+		Client ftpClient = parseArgs(argc, argv);
+
+		// create a socket and connect to Server
+		int controlConnectionfd =
+			createSocketAndConnectToHost(ftpClient.getControlConnectionIP(),
+										 ftpClient.getControlConnectionPortNumber());
+
+		// Start the FTP protocol
+		ftpClient.initiateProtocolInterpreter(controlConnectionfd);
+	} catch (const std::exception& e) {
+		// catch anything thrown within try block that derives from std::exception
+		std::cerr << "\n[THROWN] : " << e.what() << "\n" << endl;
+	}
 	return 0;
-}
-
-/**Segmentation Fault Handler
- *
- * Whenever the SIGSEGV signal is raised,
- * it is redirected here.
- *
-*/
-void segmentationFaultHandler(int sig) {
-	void* array[10];
-	size_t size;
-
-	// get void*'s for all entries on the stack
-	size = backtrace(array, 10);
-
-	// print out all the frames to stderr
-	fprintf(stderr, "Error: signal %d:\n", sig);
-	backtrace_symbols_fd(array, size, STDERR_FILENO);
-	exit(1);
 }

src/client/print.cpp

@@ -5,11 +5,11 @@
  * print the string version of `errno` along with user's custom message
 */
 void printError(const char* msg) {
-	int saveErrNo = errno;
-	fprintf(stderr, "\n[ERROR] : %s \n[ERROR code %d ] : %s\n ", msg, saveErrNo,
-			strerror(saveErrNo));
+	int saved_errno = errno;
+	fprintf(stderr, "\n[ERROR] : %s \n[ERROR code %d ] : %s\n", msg, saved_errno,
+			strerror(saved_errno));
 
-	if (saveErrNo == 32) {
+	if (saved_errno == 32) {
 		printf("\nServer end closed. \nExiting ...\n");
 		exit(0);
 	}

src/client/signalHandlers.cpp

@@ -0,0 +1,144 @@
+#include "./client.hpp"
+
+/**Points to know when handling signals -
+ *
+ * 1.
+ * Prefer `sigaction` over `signal`
+ * link -
+ * https://stackoverflow.com/a/232711
+ *
+ * 2.
+ * When you install a custom signal handler, it overrides the default handler.
+ * So be extremely careful about what you are handling,
+ * and do you need to perform the actions (eg - freeing allocated memory )
+ * what the default handler would have performed.
+ * There are ways to call default signal handler after our custom handler,
+ * but most of them are not pleasant.
+ * The general idea of to reset the handler and raise the exception again.
+ * Only do this when you know what you are doing.
+ * link -
+ * https://stackoverflow.com/questions/6015498/executing-default-signal-handler
+ *
+ * 3.
+ * printf and other printing statements must be avoiding inside the handlers.
+ * A workaround is to use a global volatile flag and set it inside the handler,
+ * then in the main function, check if flag is marked, then use print statements there.
+ * links -
+ * https://stackoverflow.com/a/16891799
+ * https://stackoverflow.com/a/16891065
+ * https://stackoverflow.com/a/21712525
+ *
+*/
+
+// general functions
+void InstallSignalHandlers();
+void installSignalHandler(int signalType, void (*singalHandlerFunction)(int));
+
+// signal handler functions
+void segmentationFaultHandler(int sig);
+void zombieProcessesHandler(int sig);
+
+/**Wrapper function : Install Signal Handlers
+ *
+ * @usage
+ * Cleanly install required signal handlers
+ *
+*/
+void InstallSignalHandlers() {
+	/**Handling segmentation fault
+	 *
+	 * In most cases, you should avoid handling this.
+	 * let the core get dumped, and try debugging from the dump.
+	 * But in some cases, we need more control, for debugging etc
+	 * this is useful in those cases.
+	*/
+	// installSignalHandler(SIGSEGV, segmentationFaultHandler);
+
+	// reap off zombie processes
+	installSignalHandler(SIGCHLD, zombieProcessesHandler);
+}
+
+
+/**install signal handler
+ *
+ * @usage
+ * install a single signal handler cleanly
+ *
+ * Note that,
+ * sigaction is used instead of signal because,
+ * sigaction is portable, predictable and thread safe.
+ *
+*/
+void installSignalHandler(int signalType, void (*singalHandlerFunction)(int)) {
+	struct sigaction sa;
+	sa.sa_handler = singalHandlerFunction;
+	sigemptyset(&sa.sa_mask);
+	sa.sa_flags = SA_RESTART;
+	if (sigaction(signalType, &sa, NULL) == -1) {
+		printError();
+		exit(1);
+	}
+}
+
+/**Segmentation Fault Handler
+ *
+ * Whenever the SIGSEGV signal is raised,
+ * it is redirected here.
+ *
+*/
+void segmentationFaultHandler(int sig[[gnu::unused]]) {
+	// @logging
+	// logs("A Segmentation fault occured.");
+	// fprintf(stderr, "Error: signal %d:\n", sig);
+
+	// @logging : Print stack trace
+
+	void* array[10];
+	size_t size;
+
+	// get void*'s for all entries on the stack
+	size = backtrace(array, 10);
+
+	// print out all the frames to stderr
+	backtrace_symbols_fd(array, size, STDERR_FILENO);
+
+	exit(1);
+}
+
+
+/**Reaper for zombie processes
+ * When the parent doesn't collect the child's status, it becomes a zombie.
+ *
+ * @usage
+ * The server main process (the one which always listens),
+ * does not collect the status of the forked processes created
+ * to handle the incoming clients.
+ *
+ * When the server runs indefinitely, a lot of clients come and go.
+ * A lot of processes are created for these clients.
+ * Therefore, a lot of zombies will be lying around if we don't clean them
+ * 
+ * @exact-use-case on client side
+ * 1. when the named pipe ( a child process ) in executeShellCommand is done.
+ * 2. the job of data connection connection manager process is done.
+ * 
+*/
+void zombieProcessesHandler(int sig[[gnu::unused]]) {
+	// @logging
+	// logs("REAPING OFF ZOMBIE PROCESS");
+	// fprintf(stderr, "Error: signal %d:\n", sig);
+
+	/**
+	 * The usual function of waitpid is to wait for child process to exit.
+	 *
+	 * However, WNOHANG in waitpid
+	 * tells it to return immediately if no child processes have exited yet.
+	 * It does not go into blocking state.
+	 *
+	 * waitpid() might overwrite errno, so we save and restore it
+	*/
+	int saved_errno = errno;
+	while (waitpid(-1, NULL, WNOHANG) > 0)
+		;
+	errno = saved_errno;
+}

src/server/askForHelpAndCreateDataConnection.cpp

@@ -26,6 +26,9 @@ int Server::askForHelpAndCreateDataConnection(int controlConnectionfd) {
 	string ipAddressOfClient;
 	int dataConnectionfd;
 	dataConnectionfd = Accept(helperSocket, ipAddressOfClient);
-
+	
+	// listening is no longer needed
+	close(helperSocket);
+	
 	return dataConnectionfd;
 }

src/server/commands/cmd_LIST.cpp

@@ -35,8 +35,8 @@ void Server::cmd_LIST(int controlConnectionfd, const vector<string>& tokens) {
 		close(controlConnectionfd);
 
 		// @logging
-		logs(getDataConnectionIP());
-		logv(getDataConnectionPortNumber());
+		// logs(getDataConnectionIP());
+		// logv(getDataConnectionPortNumber());
 
 		Send(dataConnectionfd, "Directory Listing is as follows :");
 		string commandToExecute = "ls -lA ";

src/server/commands/cmd_RETR.cpp

@@ -41,8 +41,8 @@ void Server::cmd_RETR(int controlConnectionfd, const vector<string>& args) {
 		close(controlConnectionfd);
 
 		// @logging
-		logs(getDataConnectionIP());
-		logv(getDataConnectionPortNumber());
+		// logs(getDataConnectionIP());
+		// logv(getDataConnectionPortNumber());
 
 		Send(dataConnectionfd, "Sending File in Binary Mode.");
 

src/server/commands/cmd_STOR.cpp

@@ -40,10 +40,9 @@ void Server::cmd_STOR(int controlConnectionfd, const vector<string>& args) {
 		// Child no longer needs control connection, we can close it
 		close(controlConnectionfd);
 
-
 		// @logging
-		logs(getDataConnectionIP());
-		logv(getDataConnectionPortNumber());
+		// logs(getDataConnectionIP());
+		// logv(getDataConnectionPortNumber());
 
 		Recv(dataConnectionfd, ftpResponse);
 		logs(ftpResponse.c_str());

src/server/createDataConnection.cpp

@@ -16,8 +16,7 @@
  *
 */
 int Server::createDataConnection(int controlConnectionfd) {
-	logs("[SERVER] : I am creating a new data Connection");
-
+	printInfo("[SERVER] : I am creating a new data Connection");
 
 	const char* ip = getDataConnectionIP();
 	int port = getDataConnectionPortNumber();
@@ -26,9 +25,7 @@ int Server::createDataConnection(int controlConnectionfd) {
 	bool doesRouteExist = doesRouteToHostExist(ip, port);
 
 	// @logging
-	// logServerConfiguration();
-	logs(ip);
-	logv(port);
+	logServerConfiguration();
 
 	/**Special Note : Race Condition Resolving
 	 *

src/server/createSocketAndConnectToHost.cpp

@@ -125,7 +125,7 @@ int createSocketAndConnectToHost(const char* host, int portNumber) {
 	// Print out IP address
 	char s[INET6_ADDRSTRLEN];
 	get_ip_str((const struct sockaddr*)p->ai_addr, s, sizeof s);
-	fprintf(stdout, "\n[SERVER:CONNECTION] Connected to  %s\n", s);
+	fprintf(stdout, "\n[SERVER-INITIATED:CONNECTION] Connected to  %s\n", s);
 
 	/* Don't need the structure with address info any more
 	 *