Comments

http/http_request.c

@@ -1,5 +1,4 @@
 #include "http_request.h"
-#include "http_method.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -57,18 +56,28 @@ void http_request_set(HttpRequest *__req, char *key, char *value) {
 }
 
 HttpRequest *handle_request(char *__req) {
-	printf("%s\n", __req);
+	// printf("%s\n", __req);
 	HttpRequest *request = malloc(sizeof(HttpRequest));
 	unsigned int line_count = 0;
 	char *line_start = __req;
 	char *line_end;
+	// Nous allons de ligne en ligne
+	// line_end est une chaîne de caractères allant de la nouvelle ligne trouvée
+	// jusqu'à la fin de la requête.
+	// line_start est aussi une chaîne de caractères qui va du début de la
+	// requête (au fil de la boucle, elle deviendra le précédent line_end)
+	// jusqu'à line_end.
 	while ((line_end = strchr(line_start, '\n')) != NULL) {
 		line_count++;
+		// Nous pouvons récupérer la longueur la ligne que nous allons traiter
+		// en faisant cette simple opération.
 		size_t l_length = line_end - line_start;
 		char line[l_length];
 
 		strncpy(line, line_start, l_length);
 		line[l_length - 1] = 0;
+		// La première ligne HTTP est toujours quelque chose suivant ce format:
+		// <METHOD> <PATH> HTTP/<VERSION>
 		if (line_count == 1) {
 			char method[10] = {0};
 			char *path = malloc(sizeof(char) * 1024);
@@ -76,22 +85,29 @@ HttpRequest *handle_request(char *__req) {
 				free(path);
 				return NULL;
 			}
+			// Transforme le string donné depuis la requête en int défini dans
+			// un enum, afin de se faciliter la vie plus tard.
 			request->method = get_http_method(method);
 			request->path = path;
 		} else {
+			// Pour ce qui est du reste, les options fonctionnent comme un
+			// "key-value pair": <KEY>: <VALUE>
 			char key[100] = {0};
 			char *colon_pos = strchr(line, ':');
 			if (colon_pos != NULL) {
 				size_t k_length = colon_pos - line;
 				strncpy(key, line, k_length);
 
+				// Il faut enlever le ':' + ' ' + '\r' => 3
 				size_t v_length = l_length - k_length - 3;
 				char *value = malloc(sizeof(char) * v_length);
+				// colon_pos comprend le ':' + ' ' qui sont indésirables, donc
+				// faut se décaler de 2, le '\r' ne sera pas pris en compte
+				// puisque la chaîne value est trop petite pour que ça rentre.
 				strcpy(value, colon_pos + 2);
 				http_request_set(request, key, value);
 			}
 		}
-		// TODO: Analyze line
 		line_start = line_end + 1;
 	}
 

http/http_request.h

@@ -3,6 +3,9 @@
 
 #include "http_content_type.h"
 #include "http_method.h"
+
+// Beaucoup d'options manques ou d'informations ne seront pas stockées.
+
 typedef struct {
 	HttpMethod method;
 	char *path;
@@ -18,8 +21,13 @@ typedef struct {
 	char *connection;
 } HttpRequest;
 
+// Parse la requête HTTP, afin de la manipuler facilement.
 HttpRequest *handle_request(char *__req);
+
+// Imprime dans le stdout la requête HTTP.
 void print_request(const HttpRequest *__req);
+
+// Libère tout ce qui est en rapport avec HttpRequest.
 void free_request(HttpRequest *__req);
 
 #endif

http/http_response.c

@@ -5,6 +5,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <sys/socket.h>
+#include <sys/wait.h>
 #include <unistd.h>
 
 bool construct_response(HttpResponse __res, char *out) {

http/http_response.h

@@ -6,28 +6,34 @@
 #include "http_status.h"
 #include <stdbool.h>
 #include <stddef.h>
-#include <sys/wait.h>
 
 typedef struct {
-	HttpStatus status_code;
-	HttpContentType content_type;
-	size_t content_length;
-	char *body;
-	bool body_in_heap;
+	HttpStatus status_code;		  // Code HTTP, ex. 200
+	HttpContentType content_type; // ex. HTTP_CT_HTML => text/html
+	size_t content_length;		  // Taille du contenu en bytes
+	char *body;					  // Contenu de la réponse
+	bool body_in_heap; // Si le contenu est défini dans le heap, alors on pourra
+					   // libérer sa mémoire
 } HttpResponse;
 
-// It will create a string respecting the Hypertext Transfer Protocol.
-//
-// To then be sent to the client.
+// Cela crée une chaîne de caractères respectant le protocole HTTP selon la
+// réponse donnée.
 bool construct_response(HttpResponse __res, char *out);
 
-// Respond a http response to the client (clientfd);
+// Envoie la réponse au client.
 void http_respond(HttpResponse *__res, int clientfd);
-// Read a file from a specified path
+
+// Lit un fichier et renvoie son contenu.
 char *read_file(const char *__path);
-// Given a path will return a HttpResponse
+
+// Lit un fichier à un chemin donné et forme une réponse HTTP.
 HttpResponse *from_file(const char *__path);
+
+// Libère tout ce qui est nécessaire en rapport avec la structure HttpResponse.
 void free_response(HttpResponse *__res);
+
+// Execute un programme python à un chemin donné et envoie son STDOUT au socket
+// client.
 HttpServerRunStatus cgi(const char *__path, int clientfd);
 
 #endif

http/http_server.c

@@ -3,17 +3,15 @@
 #include "http_request.h"
 #include "http_response.h"
 #include "http_status.h"
-#include <asm-generic/socket.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <sys/socket.h>
-#include <sys/types.h>
 #include <sys/wait.h>
 #include <unistd.h>
 
 HttpServerRunStatus http_server_setup(HttpServer *s) {
 	int opt = 1;
+	s->pid = 0;
 
 	if ((s->server_fd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
 		return HTTP_SRS_SOCKET_FAILED;
@@ -33,7 +31,7 @@ HttpServerRunStatus http_server_setup(HttpServer *s) {
 		0)
 		return HTTP_SRS_BIND_FAILED;
 
-	if (listen(s->server_fd, s->workers) < 0)
+	if (listen(s->server_fd, s->backlog) < 0)
 		return HTTP_SRS_LISTEN_FAILED;
 
 	return HTTP_SRS_SETUP;
@@ -49,54 +47,85 @@ HttpServerRunStatus http_server_run(HttpServer *s) {
 			 accept(s->server_fd, (struct sockaddr *)s->address, &addrlen)) < 0)
 		return HTTP_SRS_ACCEPT_FAILED;
 
-	char request[BUFSIZ] = {0};
-
-	if ((valread = recv(client_fd, request, 1024 - 1, MSG_PEEK)) < 0)
-		return HTTP_SRS_READ_FAILED;
-
-	HttpRequest *req = handle_request(request);
-	if (req == NULL)
-		return HTTP_SRS_HANDLE_REQUEST_FAILED;
-
-	HttpResponse *res;
-
-	if (!strcmp(req->path, "/")) {
-		res = from_file("./" DEFAULT_HTML);
-	} else if (!strncmp(req->path, "/cgi/", strlen("/cgi/"))) {
-		return cgi(req->path, client_fd);
-	} else {
-		char path[] = ".";
-		strcat(path, req->path);
-		res = from_file(path);
-	}
-	// print_request(req);
-	// free_request(req);
-	if (res == NULL) {
-		char *body = malloc(sizeof(char) * 128);
-		body = "<!DOCTYPE html><html><body><h1>404 Not "
-			   "Found</h1></body></html>";
-		HttpResponse __res = {
-			.status_code = HTTP_NOT_FOUND,
-			.content_length = strlen(body),
-			.content_type = HTTP_CT_HTML,
-			.body = body,
-			.body_in_heap = false, // Lorsqu'on essaie de libérer le body
-								   // sur cette instance, le server crash.
-								   // Alors, on ne le libère pas et ça cause
-								   // des memory leaks.
-		};
-		res = malloc(sizeof(__res));
-		*res = __res;
+	// Après chaque acceptation, nous créons un processus enfant pour gérer la
+	// requête, afin de pouvoir répondre à plusieurs requêtes simultanément.
+	s->pid = fork();
+	if (s->pid < 0) {
+		return HTTP_SRS_FORK_FAILED;
+	}
+
+	if (s->pid == 0) {
+
+		char request[BUFSIZ] = {0};
+
+		if ((valread = recv(client_fd, request, 1024 - 1, MSG_PEEK)) < 0)
+			exit(HTTP_SRS_READ_FAILED);
+
+		// L'objectif est de parser la requête dans une structure afin de non
+		// seulement récuperer les informations utiles, mais aussi pour les
+		// manipuler aisément.
+		HttpRequest *req = handle_request(request);
+		if (req == NULL)
+			exit(HTTP_SRS_HANDLE_REQUEST_FAILED);
+
+		HttpResponse *res;
+
+		// Si le chemin est la racine, nous retournons le fichier par défaut
+		// HTML.
+		if (!strcmp(req->path, "/")) {
+			res = from_file("./" DEFAULT_HTML);
+		}
+		// Si on cherche à faire tourner un script python, nous pouvons le faire
+		// en allant à http://<host>:<port>/cgi/<script>.py
+		else if (!strncmp(req->path, "/cgi/", strlen("/cgi/"))) {
+			exit(cgi(req->path, client_fd));
+		}
+		// Sinon l'url donnée peut correspondre à un fichier se trouvant dans
+		// l'arborescence du "current working directory".
+		else {
+			char path[] = ".";
+			strcat(path, req->path);
+			res = from_file(path);
+		}
+
+		// Si jamais le fichier n'a pas été trouvé, alors nous retournons un 404
+		// NOT FOUND.
+		if (res == NULL) {
+			char *body = malloc(sizeof(char) * 128);
+			body = "<!DOCTYPE html><html><body><h1>404 Not "
+				   "Found</h1></body></html>";
+			HttpResponse __res = {
+				.status_code = HTTP_NOT_FOUND,
+				.content_length = strlen(body),
+				.content_type = HTTP_CT_HTML,
+				.body = body,
+				.body_in_heap = false, // Lorsqu'on essaie de libérer le body
+									   // sur cette instance, le server crash.
+									   // Alors, on ne le libère pas et ça cause
+									   // des memory leaks.
+			};
+			res = malloc(sizeof(__res));
+			*res = __res;
+		}
+
+		// Nous envoyons la réponse au client.
+		http_respond(res, client_fd);
+		free_response(res);
+		exit(HTTP_SRS_RUNNING);
 	}
 
-	http_respond(res, client_fd);
-	free_response(res);
 	close(client_fd);
 	return HTTP_SRS_RUNNING;
 }
 
 HttpServerRunStatus http_server_stop(HttpServer *s) {
 
+	// Nous attendons que tous les processus enfant se termine avant de quitter
+	// le programme.
+	if (s->pid > 0) {
+		wait(NULL);
+	}
+	// Puis on ferme tout ce qui est nécessaire de fermer.
 	close(s->server_fd);
 
 	if (s->address != NULL)

http/http_server.h

@@ -1,9 +1,9 @@
 #ifndef HTTP_SERVER_H
 #define HTTP_SERVER_H
 
-// #include <netinet/in.h>
 #include <arpa/inet.h>
 #include <sys/socket.h>
+#include <sys/types.h>
 
 #ifndef DEFAULT_HTML
 #define DEFAULT_HTML "index.html"
@@ -24,15 +24,25 @@ typedef enum {
 	HTTP_SRS_WONT_HANDLE,
 } HttpServerRunStatus;
 
+// Structure ayant pour objectif de stocker tout ce qui est nécessaire au bon
+// fonctionnement du serveur.
 typedef struct {
-	int port;
-	int server_fd;
-	unsigned int workers;
-	struct sockaddr_in *address;
+	int port;			  // Port du host
+	int server_fd;		  // File descriptor du server
+	unsigned int backlog; // Le nombre de clients possibles pouvant être en
+						  // attente.
+	struct sockaddr_in *address; // L'adresse décrivant une socket internet.
+	pid_t pid;					 // Le pid du parent en attente de requêtes.
 } HttpServer;
 
+// On setup le server, avec son file descriptor, ses options, le bind et le
+// listen.
 HttpServerRunStatus http_server_setup(HttpServer *s);
+// Si tout est ok, on peut lancer le server, tant qu'il tourne, il peut
+// recevoir des clients.
 HttpServerRunStatus http_server_run(HttpServer *s);
+// Si pour quelques raisons il s'arrête, on free tout ce qu'il doit être
+// free.
 HttpServerRunStatus http_server_stop(HttpServer *s);
 
 #endif