42_adjoly/webserv
1
0
Fork 0
mirror of https://github.com/KeyZox71/webserv.git synced 2025-05-10 23:28:46 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge branch 'main' into http-indev

Browse Source
This commit is contained in:
yosyo
2025-04-10 12:23:54 +02:00
committed by GitHub
parent ebb37d8091 24f7b18ba6
commit 0e90a76508
13 changed files with 711 additions and 4 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
.clang-format Normal file
View File

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

3
.gitmodules vendored Normal file
View File

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

5
Makefile
View File

@ -7,6 +7,7 @@
# +#+#+#+#+#+ +#+ # # +#+#+#+#+#+ +#+ #
# Created: 2024/10/25 16:09:27 by adjoly #+# #+# # # Created: 2024/10/25 16:09:27 by adjoly #+# #+# #
# Updated: 2025/04/10 11:52:13 by mmoussou ### ########.fr # # 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)) 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 RED = \033[0;31m
GREEN = \033[0;32m GREEN = \033[0;32m
@ -45,7 +46,7 @@ $(NAME): $(OBJS)
$(OBJSDIR)%.o: %.cpp $(OBJSDIR)%.o: %.cpp
@mkdir -p $(@D) @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" @printf "$(DELETE)$(GREEN)「🔨」 build($<): object compiled\n"
clean: clean:

24
exemples/test.toml Normal file
View File

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

23
includes/cgi.hpp Normal file
View File

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

102
includes/config/Route.hpp Normal file
View File

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

93
includes/config/Server.hpp Normal file
View File

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

58
includes/config/default.hpp Normal file
View File

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

119
includes/log.hpp Normal file
View File

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

1
lib/tomlpp Submodule

Submodule lib/tomlpp added at d9e507093a

132
src/config/Route.cpp Normal file
View File

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

145
src/config/Server.cpp Normal file
View File

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

5
src/main.cpp
View File

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