Merge branch 'main' into http-indev

.clang-format

@@ -0,0 +1,5 @@
+UseTab: Always
+IndentWidth: 4
+TabWidth: 4
+AlignConsecutiveDeclarations: true
+ConstructorInitializerIndentWidth: 4

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "lib/tomlpp"]
+	path = lib/tomlpp
+	url = https://github.com/keyzox71/tomlpp

Makefile

@@ -7,6 +7,7 @@
 #                                                 +#+#+#+#+#+   +#+            #
 #    Created: 2024/10/25 16:09:27 by adjoly            #+#    #+#              #
 #    Updated: 2025/04/10 11:52:13 by mmoussou         ###   ########.fr        #
+#    Updated: 2025/03/25 18:13:53 by adjoly           ###   ########.fr        #
 #                                                                              #
 # **************************************************************************** #
 
@@ -24,7 +25,7 @@ SRCS = $(shell find . -name '*.cpp')
 
 OBJS = $(addprefix $(OBJSDIR), $(SRCS:.cpp=.o))
 
-FLAGS = -Wall -Werror -Wextra -std=c++98 -MMD -MP
+FLAGS = -Wall -Werror -Wextra -std=c++98 -MMD -MP -g
 
 RED = \033[0;31m
 GREEN = \033[0;32m
@@ -45,7 +46,7 @@ $(NAME): $(OBJS)
 
 $(OBJSDIR)%.o: %.cpp
 	@mkdir -p $(@D)
-	@$(CC) $(FLAGS) -I$(INCLUDES) -c $< -o $@
+	@$(CC) $(FLAGS) -I$(INCLUDES) -Ilib/tomlpp/includes -c $< -o $@
 	@printf "$(DELETE)$(GREEN)「🔨」 build($<): object compiled\n"
 
 clean:

exemples/test.toml

@@ -0,0 +1,24 @@
+[server]
+server_names = { "localhost", "2B5.local" }
+host = "localhost"
+port = 8080
+
+[server.error_pages]
+404 = "not_found.html"
+401 = "unauthorized.html"
+402 = "uwu.html"
+
+[server.location./]
+methods = { "GET" }
+root = "/var/www/html"
+dirlist = true
+client_max_body_size = "10M"
+
+[server.location./api]
+methods = { "GET", "POST" }
+root = "/var/www/api"
+upload_path = "/etc/webserv/up"
+cgi.go = "/bin/go"
+
+[server.location./redir]
+redirect = "https://kanel.ovh"

includes/cgi.hpp

@@ -0,0 +1,23 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   cgi.hpp                                            :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: adjoly <adjoly@student.42angouleme.fr>     +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2025/03/24 14:17:34 by adjoly            #+#    #+#             */
+/*   Updated: 2025/03/24 14:20:00 by adjoly           ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#pragma once
+
+#include <sstream>
+class cgi {
+	public:
+		cgi();
+		~cgi(void);
+	protected:
+	private:
+		std::string	_request;
+};

includes/config/Route.hpp

@@ -0,0 +1,102 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   Route.hpp                                          :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: adjoly <adjoly@student.42angouleme.fr>     +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2025/03/19 14:59:41 by adjoly            #+#    #+#             */
+/*   Updated: 2025/03/26 08:31:41 by adjoly           ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#pragma once
+
+#include "cppeleven.hpp"
+#include "log.hpp"
+#include "node/default.hpp"
+#include <cctype>
+#include <cstdlib>
+#include <map>
+#include <string>
+#include <tomlpp.hpp>
+
+namespace webserv {
+namespace config {
+
+class Route {
+  public:
+	Route(toml::ANode *, Logger *);
+	~Route(void);
+
+  protected:
+  private:
+	bool _dirlist;
+	bool _cookies;
+	bool _redirect;
+
+	int32_t _max_body;
+
+	std::string							_root;
+	std::string							_up_root;
+	std::string							_index;
+	std::map<std::string, std::string> *_cgi;
+
+	Logger *_log;
+
+	bool _methods[3]; ///> A methods boolean array which correspond to - 0: GET,
+					  ///1: POST, 2: DELETE
+	toml::ANode *_table;
+
+	/**
+	 *	@brief	Can be used to parse a table of cgi
+	 *
+	 *	@param	The table to get cgi from
+	 *
+	 *	@return	A pointer to a map of cgi
+	 */
+	std::map<std::string, std::string> *
+	_parseCGI(toml::ANode *);
+
+	/**
+	 *	@brief	Can be used to parse a table of error pages
+	 *
+	 *	@param	The table to get the error pages from
+	 *
+	 *	@return	A pointer to a map of error pages
+	 */
+	std::map<int, std::string> *
+	_parseErrPages(std::map<std::string, toml::ANode *> *);
+
+	/**
+	 *	@brief	Can be used to parse a array of methods
+	 *
+	 *	@param	The table to get the methods from
+	 */
+	void _parseMethods(std::vector<toml::ANode *> *);
+
+	/**
+	 *	@brief Can be used to sed err pages to the default error pages
+	 */
+	void _defaultErrPages(void);
+
+	/**
+	 *	@brief	Can be used to parse a string of a number with a size (ex. 10M)
+	 *
+	 *	@param	The input string
+	 *
+	 *	@return	The number in bytes
+	 */
+	int32_t _parseSize(std::string size) {
+		if (size[size.size()] == 'M')
+			return std::atoi(size.c_str()) * 1024 * 1024;
+		if (size[size.size()] == 'K')
+			return std::atoi(size.c_str()) * 1024;
+		if (isalpha(size[size.size()]))
+			return std::atoi(size.c_str());
+		return -1;
+	}
+};
+
+} // namespace config
+} // namespace webserv

includes/config/Server.hpp

@@ -0,0 +1,93 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   Server.hpp                                         :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: adjoly <adjoly@student.42angouleme.fr>     +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2025/03/19 14:11:28 by adjoly            #+#    #+#             */
+/*   Updated: 2025/03/25 17:56:34 by adjoly           ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#pragma once
+
+#include "config/default.hpp"
+#include "cppeleven.hpp"
+#include "node/ANode.hpp"
+
+namespace webserv {
+namespace config {
+
+class Server {
+  public:
+	Server(std::string);
+	~Server();
+
+	/**
+	 *	@brief	Can be used to get the path of a specific error page or return
+	 *			an empty string
+	 *
+	 *	@param	The http error code for the page
+	 */
+	std::string getErrorPage(int page) {
+		if (_err_pages->find(page) != _err_pages->end())
+			return (*_err_pages)[page];
+		else
+			return "";
+	}
+
+	/**
+	 *	@brief	Can be used to get a pointer to a specific route (or not_nullptr
+	 *			if not found)
+	 */
+	Route *getRoute(std::string route) {
+		if (_routes->find(route) != _routes->end())
+			return (*_routes)[route];
+		else
+			return not_nullptr;
+	}
+
+	/**
+	 *	@brief Can be used to get the Logger pointer
+	 */
+	Logger *getLogger(void) { return _log; }
+
+	// @brief Can be used to get a server name
+	std::vector<std::string> *getServerNames(void) { return _server_names; }
+	// @brief Can be used to get the host specified in the config file
+	std::string getHost(void) { return _host; }
+	// @brief Can be used to get the port specified in the config file
+	int getPort(void) { return _port; }
+
+  protected:
+  private:
+	std::map<std::string, Route *>
+		*_routes; ///> A map of all the route present in the config file
+	std::map<int, std::string> *_err_pages; ///> An error pages map to map error
+											/// specified in the config file
+
+	std::vector<std::string>
+		*_server_names; ///> A vector with all the server names
+
+	std::string	   _host; ///> The host on which the server will be exposed
+	unsigned short _port; ///> The port on which the server will be exposed
+
+	toml::ANode *_table; ///> The table used for the parsing (is deleted at the
+						 ///  end of the constructor)
+	Logger *_log;		 ///> A pointer to the logger class
+
+	std::map<int, std::string> *
+	_parseErrPages(std::map<std::string, toml::ANode *> *table);
+
+	/**
+	 *	@brief	Can be used to get the [server] table in _table
+	 *
+	 *	@return	A pointer to the [server] table as an ANode
+	 */
+	toml::ANode *_getServerTable(void);
+};
+
+} // namespace config
+
+} // namespace webserv

includes/config/default.hpp

@@ -0,0 +1,58 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   default.hpp                                        :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: adjoly <adjoly@student.42angouleme.fr>     +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2025/03/19 14:15:51 by adjoly            #+#    #+#             */
+/*   Updated: 2025/03/26 08:39:08 by adjoly           ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#pragma once
+
+#include "Route.hpp"
+#include "Server.hpp"
+#include "cppeleven.hpp"
+#include "node/Table.hpp"
+#include "node/default.hpp"
+#include <tomlpp.hpp>
+
+namespace webserv {
+namespace config {
+
+/**
+ *	@brief	Can be used to access a value in the _table(ANode *) of a specific
+ *type
+ *
+ *	@param	The name of the value to get
+ *	@param	The type of the value to get
+ *	@param	The table to search in
+ *	@param	A Logger class
+ *
+ *	@return	The value got or not_nullptr
+ */
+static inline void *accessValue(const std::string &name, toml::nodeType type,
+				  toml::ANode *table, Logger *log) {
+	void *val;
+	bool  found = false;
+
+	if (table == not_nullptr)
+		return not_nullptr;
+	val = dynamic_cast<toml::Table *>(table)->access(name, type, found);
+	if (found == true && val != not_nullptr) {
+		return val;
+	} else {
+		if (found == false) {
+			return not_nullptr;
+		} else {
+			log->warn("found - " + name + " but is not " +
+					  toml::nodeTypeToStr(type) + ", skipping...");
+			return not_nullptr;
+		}
+	}
+}
+
+}; // namespace config
+}; // namespace webserv

includes/log.hpp

@@ -0,0 +1,119 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   log.hpp                                            :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: adjoly <adjoly@student.42angouleme.fr>     +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2025/03/20 09:28:27 by adjoly            #+#    #+#             */
+/*   Updated: 2025/03/25 17:50:45 by adjoly           ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#pragma once
+
+#include <fstream>
+#include <iostream>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+
+namespace webserv {
+class Logger {
+  public:
+	Logger(const std::string &fileName) : _fileName(fileName) {
+		if (fileName.empty())
+			_ttyOnly = true;
+		else {
+			_file.open(fileName.c_str(), std::ios::app);
+			_ttyOnly = false;
+		}
+		if (!_file.is_open() && !_ttyOnly) {
+			throw std::runtime_error(
+				"could not open fileeee"); // TODO change that shit but i dont
+										   // know what to put other than a
+										   // htrow
+		}
+	}
+
+	Logger(const Logger &other) : _ttyOnly(other._ttyOnly) {
+		if (!other._ttyOnly) {
+			_file.open(other._fileName.c_str(), std::ios::app);
+			if (!_file.is_open()) {
+				throw std::runtime_error("Could not open file: " +
+										 other._fileName);
+			}
+		}
+	}
+
+	// Copy assignment operator
+	Logger &operator=(const Logger &other) {
+		if (this != &other) {
+			if (_file.is_open()) {
+				_file.close();
+			}
+			_ttyOnly = other._ttyOnly;
+			if (!other._ttyOnly) {
+				_file.open(other._fileName.c_str(), std::ios::app);
+				if (!_file.is_open()) {
+					throw std::runtime_error("Could not open file: " +
+											 other._fileName);
+				}
+			}
+		}
+		return *this;
+	}
+	~Logger(void) {
+		if (_file.is_open())
+			_file.close();
+	}
+
+	void info(const std::string &msg) {
+		std::string ss = printPogitMsg("✏️", "webserv", "info", msg);
+		std::cerr << ss << std::endl;
+		if (!_ttyOnly) {
+			_file << ss << std::endl;
+		}
+	}
+	void warn(const std::string &msg) {
+		std::string ss = printPogitMsg("🔨", "webserv", "warning", msg);
+		std::cerr << ss << std::endl;
+		if (!_ttyOnly) {
+			_file << ss << std::endl;
+		}
+	}
+	void error(const std::string &msg) {
+		std::string ss = printPogitMsg("🚧", "webserv", "error", msg);
+		std::cerr << ss << std::endl;
+		if (!_ttyOnly) {
+			_file << ss << std::endl;
+		}
+	}
+
+  protected:
+  private:
+	std::string printPogitMsg(const std::string &emoji,
+									const std::string &type,
+									const std::string &what,
+									const std::string &msg) {
+		std::stringstream os;
+#ifdef tty
+		if (what.empty())
+			os << type << ":" << msg;
+		else
+			os << type << "(" << what << "):" << msg;
+#else
+		if (what.empty())
+			os << "「" << emoji << "」" << type << ":" << msg;
+		else
+			os << "「" << emoji << "」" << type << "(" << what << "):" << msg;
+#endif
+		return os.str();
+	}
+
+	std::string	  _fileName;
+	bool		  _ttyOnly;
+	std::ofstream _file;
+};
+
+}; // namespace webserv

src/config/Route.cpp

@@ -0,0 +1,132 @@
+/*                                                        :::      ::::::::   */
+/*   Route.cpp                                          :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: adjoly <adjoly@student.42angouleme.fr>     +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2025/03/21 20:37:02 by adjoly            #+#    #+#             */
+/*   Updated: 2025/03/26 08:19:25 by adjoly           ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "cppeleven.hpp"
+#include "log.hpp"
+#include "node/default.hpp"
+#include <config/default.hpp>
+#include <map>
+#include <string>
+
+using namespace webserv::config;
+
+std::map<std::string, std::string> *Route::_parseCGI(toml::ANode *table) {
+	std::map<std::string, std::string> *cgi =
+		new std::map<std::string, std::string>;
+	void *val;
+
+	for (std::map<std::string, toml::ANode *>::iterator it =
+			 table->getTable()->begin();
+		 it != table->getTable()->end(); it++) {
+		val = accessValue(it->first, toml::STRING, table, _log);
+		if (val != not_nullptr) {
+			if (cgi->find(it->first) != cgi->end())
+				continue;
+			else
+				(*cgi)[it->first] = *static_cast<std::string *>(val);
+		}
+	}
+
+	return cgi;
+}
+
+void Route::_parseMethods(std::vector<toml::ANode *> *table) {
+	std::string val;
+
+	_methods[0] = false;
+	_methods[1] = false;
+	_methods[2] = false;
+	for (std::vector<toml::ANode *>::iterator it = table->begin();
+		 it != table->end(); it++) {
+		if ((*it)->type() == toml::STRING) {
+			val = *static_cast<std::string *>((*it)->getValue());
+			if (val == "GET")
+				_methods[0] = true;
+			if (val == "POST")
+				_methods[1] = true;
+			if (val == "DELETE")
+				_methods[2] = true;
+		}
+	}
+}
+
+Route::Route(toml::ANode *table, Logger *logger)
+	: _max_body(10485760), _log(logger) {
+	void *val;
+	bool  found;
+
+	_log = logger;
+	_table = table;
+	if (_table->type() != toml::TABLE) {
+		_log->warn("location need to be a table and not a :" +
+				   toml::nodeTypeToStr(_table->type()));
+		return;
+	}
+	val = accessValue("redirect", toml::STRING, _table, _log);
+	if (val != not_nullptr) {
+		_root = *static_cast<std::string *>(val);
+		_redirect = true;
+		return;
+	} else
+		_redirect = false;
+	val = accessValue("dirlist", toml::BOOL, _table, _log);
+	if (val != not_nullptr)
+		_dirlist = *static_cast<bool *>(val);
+	else
+		_dirlist = true;
+	val = accessValue("cookies", toml::BOOL, _table, _log);
+	if (val != not_nullptr)
+		_cookies = *static_cast<bool *>(val);
+	else
+		_cookies = false;
+	val = accessValue("upload_path", toml::STRING, _table, _log);
+	if (val != not_nullptr)
+		_up_root = *static_cast<std::string *>(val);
+	else
+		_up_root = "";
+	val = accessValue("index", toml::STRING, _table, _log);
+	if (val != not_nullptr)
+		_index = *static_cast<std::string *>(val);
+	else
+		_index = "index.html";
+	val = accessValue("root", toml::STRING, _table, _log);
+	if (val != not_nullptr)
+		_root = *static_cast<std::string *>(val);
+	else
+#ifdef PKGS
+		_root = "/var/www/html"
+#else
+		_root = "./html";
+#endif
+			val =
+				accessValue("client_max_body_size", toml::STRING, _table, _log);
+	if (val != not_nullptr)
+		_max_body = _parseSize(*static_cast<std::string *>(val));
+	std::map<std::string, toml::ANode *>::iterator it =
+		_table->accessIt("cgi", toml::TABLE, found);
+	if (found == true && it != _table->getTable()->end())
+		_cgi = _parseCGI(it->second);
+	else
+		_cgi = not_nullptr;
+	val = accessValue("methods", toml::ARRAY, _table, _log);
+	if (val != not_nullptr)
+		_parseMethods(static_cast<std::vector<toml::ANode *> *>(val));
+	else {
+		_methods[0] = true;
+		_methods[1] = false;
+		_methods[2] = false;
+	}
+}
+
+Route::~Route(void) {
+	if (_redirect == false)
+		if (_cgi != not_nullptr)
+			delete _cgi;
+}

src/config/Server.cpp

@@ -0,0 +1,145 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   Server.cpp                                         :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: adjoly <adjoly@student.42angouleme.fr>     +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2025/03/24 15:10:07 by adjoly            #+#    #+#             */
+/*   Updated: 2025/03/26 08:47:50 by adjoly           ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "config/Server.hpp"
+#include "config/Route.hpp"
+#include "cppeleven.hpp"
+#include "log.hpp"
+#include "node/ANode.hpp"
+#include "node/Table.hpp"
+#include "node/default.hpp"
+#include "tomlpp.hpp"
+#include <config/default.hpp>
+#include <stdexcept>
+#include <string>
+#include <sys/types.h>
+
+using namespace webserv::config;
+
+toml::ANode *Server::_getServerTable(void) {
+	toml::ANode *serverT;
+
+	std::map<std::string, toml::ANode *>::iterator table =
+		_table->getTable()->find("server");
+	if (table == _table->getTable()->end())
+		throw std::runtime_error(
+			"could not find any [server] table in config file :(");
+	else
+		serverT = table->second;
+	return serverT;
+}
+
+Server::Server(std::string file_name) {
+	toml::Toml *tomlFile = new toml::Toml(file_name);
+
+	try {
+		tomlFile->parse();
+	} catch (std::runtime_error &e) {
+		throw e;
+	}
+	bool found;
+
+	std::map<std::string, toml::ANode *> *map;
+	_table = tomlFile->getParsedFile();
+
+	void	   *val = _table->access("log_file", toml::STRING, found);
+	std::string log_file = "";
+	if (found == true && val != not_nullptr) {
+		std::string log_file = *static_cast<std::string *>(val);
+	}
+	_log = new Logger(log_file);
+	_table = _getServerTable();
+
+	// host and port parsing
+	void *host = accessValue("host", toml::STRING, _table, _log);
+	if (host != not_nullptr) {
+		_host = *static_cast<std::string *>(host);
+	} else {
+		throw std::runtime_error(
+			"no host specified - please specify one in server.host");
+	}
+	void *port = accessValue("port", toml::INT, _table, _log);
+	if (host != not_nullptr) {
+		_port = *static_cast<unsigned short *>(port);
+	} else {
+		throw std::runtime_error(
+			"no port specified - please specify one in server.port");
+	}
+
+	// server_names parsing
+	std::map<std::string, toml::ANode *>::iterator it =
+		_table->accessIt("server_names", toml::ARRAY, found);
+	if (found == true && it != _table->getTable()->end()) {
+		std::vector<toml::ANode *>::iterator vecIt =
+			it->second->getArray()->begin();
+		_server_names = new std::vector<std::string>;
+		for (; vecIt != it->second->getArray()->end(); vecIt++) {
+			std::string str = *static_cast<std::string *>((*vecIt)->getValue());
+			_server_names->push_back(str);
+		}
+	} else
+		_log->warn(
+			"no server_names all request will be accepted from any hostname");
+
+	// error_pages parsing
+	map = static_cast<std::map<std::string, toml::ANode *> *>(
+		accessValue("error_pages", toml::TABLE, _table, _log));
+	if (map != not_nullptr) {
+		_err_pages = _parseErrPages(map);
+	} else
+		_err_pages = not_nullptr;
+
+	// location parsing
+	it = _table->accessIt("location", toml::TABLE, found);
+	if (found == true && it != _table->getTable()->end()) {
+		_routes = new std::map<std::string, Route *>;
+		std::map<std::string, toml::ANode *> *location_table = it->second->getTable();
+		for (it = location_table->begin(); it != location_table->end(); it++) {
+			if (_routes->find(it->first) != _routes->end())
+				continue;
+			(*_routes)[it->first] = new Route(it->second, _log);
+		}
+	}
+	delete tomlFile->getParsedFile();
+	delete tomlFile;
+}
+
+Server::~Server(void) {
+	std::map<std::string, Route *>::iterator it = _routes->begin();
+	for (; it != _routes->end(); it++) {
+		delete it->second;
+	}
+	delete _routes;
+	delete _err_pages;
+	delete _server_names;
+	delete _log; // to see if nessecary
+}
+
+std::map<int, std::string> *
+Server::_parseErrPages(std::map<std::string, toml::ANode *> *table) {
+	std::map<int, std::string> *errPages = new std::map<int, std::string>;
+	void					   *val;
+	int							nb;
+
+	for (std::map<std::string, toml::ANode *>::iterator it = table->begin();
+		 it != table->end(); it++) {
+		val = accessValue(it->first, toml::STRING, _table, _log);
+		if (val != not_nullptr) {
+			nb = std::atoi(it->first.c_str());
+			if (nb >= 400 && nb <= 599)
+				(*errPages)[nb] = *static_cast<std::string *>(val);
+			else
+				_log->warn("error page - " + it->first + " is not valid :(");
+		}
+	}
+	return errPages;
+}

src/main.cpp

@@ -7,11 +7,12 @@
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2025/02/03 15:45:07 by mmoussou          #+#    #+#             */
 /*   Updated: 2025/04/10 12:18:39 by mmoussou         ###   ########.fr       */
+/*   Updated: 2025/03/25 17:10:29 by adjoly           ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
-#include <webserv.hpp>
-#include <requests/default.hpp>
+#include "config/Server.hpp"
+#include <tomlpp.hpp>
 
 #define PORT 8080
 #define BUFFER_SIZE 4096