cdricms/cweb
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

Comments

Browse Source
This commit is contained in:
cdricms
2024-11-20 00:04:49 +01:00
parent 7b52f5de7d
commit cdae291dd8
8 changed files with 145 additions and 71 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
cgi/hello.py
View File

@@ -1,4 +1,3 @@
code = 200
ct = "text/html"
content = "<!DOCTYPE html><html><body><h1>Bonjour!</h1></body></html>"

22
http/http_request.c
View File

@@ -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;
}

8
http/http_request.h
View File

@@ -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

1
http/http_response.c
View File

@@ -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) {

30
http/http_response.h
View File

@@ -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

51
http/http_server.c
View File

@@ -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,28 +47,49 @@ HttpServerRunStatus http_server_run(HttpServer *s) {
accept(s->server_fd, (struct sockaddr *)s->address, &addrlen)) < 0)
return HTTP_SRS_ACCEPT_FAILED;
// 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)
return HTTP_SRS_READ_FAILED;
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)
return HTTP_SRS_HANDLE_REQUEST_FAILED;
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);
} else if (!strncmp(req->path, "/cgi/", strlen("/cgi/"))) {
return cgi(req->path, client_fd);
} else {
}
// 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);
}
// print_request(req);
// free_request(req);
// 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 "
@@ -89,14 +108,24 @@ HttpServerRunStatus http_server_run(HttpServer *s) {
*res = __res;
}
// Nous envoyons la réponse au client.
http_respond(res, client_fd);
free_response(res);
exit(HTTP_SRS_RUNNING);
}
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)

20
http/http_server.h
View File

@@ -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

17
main.c
View File

@@ -1,18 +1,23 @@
#include "http/http_server.h"
#include <stdio.h>
#include <stdlib.h>
int main() {
HttpServer server = {.port = 8080, .workers = 3};
if (http_server_setup(&server) != HTTP_SRS_SETUP)
exit(1);
// Nous créons une variable server contenant certaines informations
// sur le server HTTP que nous voulons utiliser, notamment son port.
HttpServer server = {.port = 8080, .backlog = 3};
// On setup le server, avec son file descriptor, ses options, le bind et le
// listen.
HttpServerRunStatus status;
if ((status = http_server_setup(&server)) != HTTP_SRS_SETUP)
exit(status);
// Si tout est ok, on peut lancer le server, tant qu'il tourne, il peut
// recevoir des clients.
while ((status = http_server_run(&server)) == HTTP_SRS_RUNNING)
;
printf("Status: %d\n", status);
// Si pour quelques raisons il s'arrête, on free tout ce qu'il doit être
// free.
http_server_stop(&server);
return 0;