42/42_INT_12_webserv
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

kinda successful merge, weird tho, didn't go as smoothly with VScode as usual...

Browse Source
This commit is contained in:
Me
2022-08-05 22:25:11 +02:00
parent f7dc5ccde4 914d4cb0c0
commit 6f0c3b4d6d
23 changed files with 750 additions and 392 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
srcs/Client.cpp
View File

@@ -1,6 +1,8 @@
#include "Client.hpp"
char Client::buf[MAX_FILESIZE+1];
/*********************************************
* COPLIENS
*********************************************/
@@ -35,7 +37,7 @@ void Client::parse_request()
std::vector<std::string> list;
size_t pos;
pos = (raw_request).find("\r\n\r\n");
pos = (raw_request).find(CRLF CRLF);
sub = (raw_request).substr(0, pos);
list = split(sub, '\n');
// request_line
@@ -45,9 +47,27 @@ void Client::parse_request()
_parse_request_headers(list);
//body- message
_parse_request_body(pos + 4);
// add "raw_request.clear()" after parsing ? for little less memory usage ?
}
void Client::clear()
{
clear_request();
raw_request.clear();
response.clear();
body_size = 0;
status = 0;
}
void Client::clear_request()
{
_request.method = UNKNOWN;
_request.path.clear();
_request.version.clear();
_request.headers.clear();
_request.body.clear();
}
http_method Client::get_method() { return _request.method; }
std::string &Client::get_path() { return _request.path; }

7
srcs/Client.hpp
View File

@@ -10,13 +10,14 @@
struct Request
{
std::map<std::string, std::string> headers;
http_method method;
std::string path;
std::string version;
std::map<std::string, std::string> headers;
std::string body;
};
# define MAX_FILESIZE 1000000 // (1Mo)
class Client
{
public:
@@ -28,6 +29,8 @@ class Client
int fd;
std::string raw_request;
std::string response;
static char buf[MAX_FILESIZE+1];
size_t body_size;
unsigned int status;
// const functions ?
@@ -38,6 +41,8 @@ class Client
std::string &get_headers(const std::string &key);
void parse_request();
void clear();
void clear_request();
private:
struct Request _request;

2
srcs/config/ServerConfig.hpp
View File

@@ -30,7 +30,7 @@ public:
// there can only be one.
std::string root;
int client_body_limit; // set to default max if none set
unsigned int client_body_limit; // set to default max if none set
// might be the only one we let slide if bad input... It remains false...
bool autoindex;

15
srcs/utils.cpp
View File

@@ -124,5 +124,18 @@ int path_is_valid(std::string path)
}
void replace_all_substr(std::string &str, const std::string &ori_substr, const std::string &new_substr)
{
if (ori_substr.empty())
return;
size_t pos = 0;
while (1)
{
pos = str.find(ori_substr, pos);
if (pos == std::string::npos)
break;
str.replace(pos, ori_substr.size(), new_substr);
pos += new_substr.size();
}
}

7
srcs/utils.hpp
View File

@@ -8,9 +8,9 @@
# include <cstdlib> // atoi
# include <sys/stat.h> // stat()
# include <iostream> // tmp
# define CR "\r"
# define LF "\n"
# define CRLF CR LF
// enum http_method
// {
@@ -38,5 +38,6 @@ std::string trim(std::string str, char c);
http_method str_to_http_method(std::string &str);
std::string http_methods_to_str(unsigned int methods);
int path_is_valid(std::string path);
void replace_all_substr(std::string &str, const std::string &ori_substr, const std::string &new_substr)
#endif

21
srcs/webserv/Webserv.hpp
View File

@@ -28,6 +28,7 @@
# include "Client.hpp"
# include "ServerConfig.hpp"
# include "utils.hpp"
# include "http_status.hpp"
extern bool g_run;
extern int g_last_signal;
@@ -60,6 +61,8 @@ class Webserv
std::vector<int> _listen_sockets;
std::vector<ServerConfig> _servers;
std::vector<Client> _clients;
std::map<int, std::string> _http_status;
std::map<std::string, std::string> _mime_types;
// accept.cpp
void _accept_connection(int fd);
@@ -69,11 +72,23 @@ class Webserv
// response.cpp
void _response(Client *client);
void _send_response(Client *client, ServerConfig &server);
void _append_base_headers(Client *client);
void _construct_response(Client *client, ServerConfig &server);
void _insert_status_line(Client *client, ServerConfig &server);
void _get_ressource(Client *client, ServerConfig &server, LocationConfig &location);
void _process_method(Client *client, ServerConfig &server, LocationConfig &location);
void _insert_status_line(Client *client);
void _error_html_response(Client *client, ServerConfig &server);
void _append_body(Client *client, const char *body, size_t body_size, const std::string &file_extension = "");
void _get(Client *client, ServerConfig &server, LocationConfig &location);
void _get_file(Client *client, const std::string &path);
void _post(Client *client, ServerConfig &server, LocationConfig &location);
void _post_file(Client *client, const std::string &path);
void _delete(Client *client, ServerConfig &server, LocationConfig &location);
void _delete_file(Client *client, const std::string &path);
ServerConfig &_determine_process_server(Client *client);
LocationConfig &_determine_location(ServerConfig &server, std::string &path);
// cgi_script.cpp
@@ -94,6 +109,8 @@ class Webserv
// init.cpp
void _bind(int socket_fd, in_port_t port, std::string host);
void _listen(int socket_fd, unsigned int max_connections);
void _init_http_status_map();
void _init_mime_types_map();
};
#endif

3
srcs/webserv/base.cpp
View File

@@ -12,6 +12,9 @@ Webserv::Webserv()
throw std::runtime_error("Epoll init");
}
_init_http_status_map();
_init_mime_types_map();
std::signal(SIGPIPE, signal_handler);
std::signal(SIGINT, signal_handler);
}

41
srcs/webserv/http_status.hpp Normal file
View File

@@ -0,0 +1,41 @@
#ifndef HTTP_STATUS_HPP
# define HTTP_STATUS_HPP
// https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
/*
First version of macro HTML_ERROR(STATUS) dont work with call like this :
client->response.append( HTML_ERROR( _http_status[client->status].c_str() ) );
so I made the other version with dynamic replacement of STATUS .
*/
// # define HTML_ERROR(STATUS) "\r\n<!DOCTYPE html><html><head><title>"STATUS"</title></head><body><h1 style=\"text-align:center\">"STATUS"</h1><hr><p style=\"text-align:center\">Le Webserv/0.1</p></body></html>"
# define STATUS_PLACEHOLDER "$STATUS"
# define HTML_ERROR \
"<!DOCTYPE html>"\
"<html>"\
"<head>"\
"<title>" STATUS_PLACEHOLDER "</title>"\
"</head>"\
"<body>"\
"<h1 style=\"text-align:center\">" STATUS_PLACEHOLDER "</h1>"\
"<hr>"\
"<p style=\"text-align:center\">Le Webserv/0.1</p>"\
"</body>"\
"</html>"
// When new status added, need to update _init_http_status_map()
# define S200 "200 OK"
# define S201 "201 Created"
# define S204 "204 No Content"
# define S400 "400 Bad Request"
# define S403 "403 Forbidden"
# define S404 "404 Not Found"
# define S405 "405 Method Not Allowed"
# define S413 "413 Content Too Large"
# define S500 "500 Internal Server Error"
#endif

131
srcs/webserv/init.cpp
View File

@@ -76,3 +76,134 @@ void Webserv::_listen(int socket_fd, unsigned int max_connections)
throw std::runtime_error("Socket listen");
}
}
void Webserv::_init_http_status_map()
{
_http_status[200] = S200;
_http_status[201] = S201;
_http_status[204] = S204;
_http_status[400] = S400;
_http_status[403] = S403;
_http_status[404] = S404;
_http_status[405] = S405;
_http_status[413] = S413;
_http_status[500] = S500;
}
void Webserv::_init_mime_types_map()
{
_mime_types[""] = "application/octet-stream";
_mime_types["html"] = "text/html";
_mime_types["htm"] = "text/html";
_mime_types["shtml"] = "text/html";
_mime_types["css"] = "text/css";
_mime_types["xml"] = "text/xml";
_mime_types["gif"] = "image/gif";
_mime_types["jpeg"] = "image/jpeg";
_mime_types["jpg"] = "image/jpeg";
_mime_types["js"] = "application/javascript";
_mime_types["atom"] = "application/atom+xml";
_mime_types["rss"] = "application/rss+xml";
_mime_types["mml"] = "text/mathml";
_mime_types["txt"] = "text/plain";
_mime_types["jad"] = "text/vnd.sun.j2me.app-descriptor";
_mime_types["wml"] = "text/vnd.wap.wml";
_mime_types["htc"] = "text/x-component";
_mime_types["png"] = "image/png";
_mime_types["tif"] = "image/tiff";
_mime_types["tiff"] = "image/tiff";
_mime_types["wbmp"] = "image/vnd.wap.wbmp";
_mime_types["ico"] = "image/x-icon";
_mime_types["jng"] = "image/x-jng";
_mime_types["bmp"] = "image/x-ms-bmp";
_mime_types["svg"] = "image/svg+xml";
_mime_types["svgz"] = "image/svg+xml";
_mime_types["webp"] = "image/webp";
_mime_types["woff"] = "application/font-woff";
_mime_types["jar"] = "application/java-archive";
_mime_types["war"] = "application/java-archive";
_mime_types["ear"] = "application/java-archive";
_mime_types["json"] = "application/json";
_mime_types["hqx"] = "application/mac-binhex40";
_mime_types["doc"] = "application/msword";
_mime_types["pdf"] = "application/pdf";
_mime_types["ps"] = "application/postscript";
_mime_types["eps"] = "application/postscript";
_mime_types["ai"] = "application/postscript";
_mime_types["rtf"] = "application/rtf";
_mime_types["m3u8"] = "application/vnd.apple.mpegurl";
_mime_types["xls"] = "application/vnd.ms-excel";
_mime_types["eot"] = "application/vnd.ms-fontobject";
_mime_types["ppt"] = "application/vnd.ms-powerpoint";
_mime_types["wmlc"] = "application/vnd.wap.wmlc";
_mime_types["kml"] = "application/vnd.google-earth.kml+xml";
_mime_types["kmz"] = "application/vnd.google-earth.kmz";
_mime_types["7z"] = "application/x-7z-compressed";
_mime_types["cco"] = "application/x-cocoa";
_mime_types["jardiff"] = "application/x-java-archive-diff";
_mime_types["jnlp"] = "application/x-java-jnlp-file";
_mime_types["run"] = "application/x-makeself";
_mime_types["pl"] = "application/x-perl";
_mime_types["pm"] = "application/x-perl";
_mime_types["prc"] = "application/x-pilot";
_mime_types["pdb"] = "application/x-pilot";
_mime_types["rar"] = "application/x-rar-compressed";
_mime_types["rpm"] = "application/x-redhat-package-manager";
_mime_types["sea"] = "application/x-sea";
_mime_types["swf"] = "application/x-shockwave-flash";
_mime_types["sit"] = "application/x-stuffit";
_mime_types["tcl"] = "application/x-tcl";
_mime_types["tk"] = "application/x-tcl";
_mime_types["der"] = "application/x-x509-ca-cert";
_mime_types["pem"] = "application/x-x509-ca-cert";
_mime_types["crt"] = "application/x-x509-ca-cert";
_mime_types["xpi"] = "application/x-xpinstall";
_mime_types["xhtml"] = "application/xhtml+xml";
_mime_types["xspf"] = "application/xspf+xml";
_mime_types["zip"] = "application/zip";
_mime_types["bin"] = "application/octet-stream";
_mime_types["exe"] = "application/octet-stream";
_mime_types["dll"] = "application/octet-stream";
_mime_types["deb"] = "application/octet-stream";
_mime_types["dmg"] = "application/octet-stream";
_mime_types["iso"] = "application/octet-stream";
_mime_types["img"] = "application/octet-stream";
_mime_types["msi"] = "application/octet-stream";
_mime_types["msp"] = "application/octet-stream";
_mime_types["msm"] = "application/octet-stream";
_mime_types["docx"] = "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
_mime_types["xlsx"] = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
_mime_types["pptx"] = "application/vnd.openxmlformats-officedocument.presentationml.presentation";
_mime_types["mid"] = "audio/midi";
_mime_types["midi"] = "audio/midi";
_mime_types["kar"] = "audio/midi";
_mime_types["mp3"] = "audio/mpeg";
_mime_types["ogg"] = "audio/ogg";
_mime_types["m4a"] = "audio/x-m4a";
_mime_types["ra"] = "audio/x-realaudio";
_mime_types["3gpp"] = "video/3gpp";
_mime_types["3gp"] = "video/3gpp";
_mime_types["ts"] = "video/mp2t";
_mime_types["mp4"] = "video/mp4";
_mime_types["mpeg"] = "video/mpeg";
_mime_types["mpg"] = "video/mpeg";
_mime_types["mov"] = "video/quicktime";
_mime_types["webm"] = "video/webm";
_mime_types["flv"] = "video/x-flv";
_mime_types["m4v"] = "video/x-m4v";
_mime_types["mng"] = "video/x-mng";
_mime_types["asx"] = "video/x-ms-asf";
_mime_types["asf"] = "video/x-ms-asf";
_mime_types["wmv"] = "video/x-ms-wmv";
_mime_types["avi"] = "video/x-msvideo";
}

313
srcs/webserv/response.cpp
View File

@@ -3,6 +3,8 @@
void Webserv::_response(Client *client)
{
client->status = 200; // default value
ServerConfig &server = _determine_process_server(client);
_send_response(client, server);
if (g_last_signal)
@@ -14,9 +16,12 @@ void Webserv::_send_response(Client *client, ServerConfig &server)
ssize_t ret;
std::cerr << "send()\n";
// std::cerr << "RAW_REQUEST\n|\n" << client->raw_request << "|\n"; // DEBUG
_append_base_headers(client);
_construct_response(client, server);
_insert_status_line(client);
if (client->status >= 400)
_error_html_response(client, server);
ret = ::send(client->fd, client->response.c_str(), client->response.size(), 0);
if (ret == -1)
@@ -27,30 +32,51 @@ void Webserv::_send_response(Client *client, ServerConfig &server)
return ;
}
if (client->raw_request.find("Connection: close") != std::string::npos)
// Body send (WIP for working binary files)
if (client->body_size)
{
ret = ::send(client->fd, client->buf, client->body_size, 0);
if (ret == -1)
{
std::perror("err send()");
std::cerr << "client.fd =" << client->fd << "\n"; // DEBUG
_close_client(client->fd);
return ;
}
}
if (client->get_headers("Connection") == "close")
_close_client(client->fd);
else
{
_epoll_update(client->fd, EPOLLIN, EPOLL_CTL_MOD);
client->raw_request.clear();
client->response.clear();
client->clear();
}
}
void Webserv::_append_base_headers(Client *client)
{
client->response.append("Server: Webserv/0.1" CRLF);
if (client->get_headers("Connection") == "close")
client->response.append("Connection: close" CRLF);
else
client->response.append("Connection: keep-alive" CRLF);
}
void Webserv::_construct_response(Client *client, ServerConfig &server)
{
if (client->get_body().size() > server.client_body_limit)
{
client->status = 413;
return;
}
LocationConfig &location = _determine_location(server, client->get_path());
_process_method(client, server, location);
}
client->status = 200; // default value
client->response.append("Server: Webserv/0.1\r\n");
if (client->get_headers("Connection") == "close")
client->response.append("Connection: close\r\n");
else
client->response.append("Connection: keep-alive\r\n");
void Webserv::_process_method(Client *client, ServerConfig &server, LocationConfig &location)
{
unsigned int allow_methods = ALL_METHODS; // TEMP VARIABLE
// after update in ConfigParser, use the "allow_methods" of location.
// TODO in ConfigParser : by default if no field in config file, "allow_methods" must be set to ALL_METHODS
@@ -61,72 +87,61 @@ void Webserv::_construct_response(Client *client, ServerConfig &server)
}
else if (allow_methods & client->get_method())
{
if (client->get_method() & GET)
_get_ressource(client, server, location);
else if (client->get_method() & POST)
_post(client, server, location);
else if (client->get_method() & DELETE)
_delete(client, server, location);
switch (client->get_method())
{
case (GET):
_get(client, server, location);
break;
case (POST):
_post(client, server, location);
break;
case (DELETE):
_delete(client, server, location);
break;
default:
break;
}
}
else
{
client->status = 405;
client->response.append("Allow: ");
client->response.append(::http_methods_to_str(allow_methods));
client->response.append("\r\n");
client->response.append(CRLF);
}
_insert_status_line(client, server);
}
// https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
#define HTML_ERROR(STATUS) "\r\n<!DOCTYPE html><html><head><title>"STATUS"</title></head><body><h1 style=\"text-align:center\">"STATUS"</h1><hr><p style=\"text-align:center\">Le Webserv/0.1</p></body></html>"
#define S200 "200 OK"
#define S400 "400 Bad Request"
#define S404 "404 Not Found"
#define S500 "500 Internal Server Error"
void Webserv::_insert_status_line(Client *client, ServerConfig &server)
void Webserv::_insert_status_line(Client *client)
{
std::string status_line;
status_line.append("HTTP/1.1 ");
// WIP, maybe make a map for status response
switch (client->status)
{
case (200):
status_line.append(S200);
break;
case (400):
status_line.append(S400);
client->response.append(HTML_ERROR(S400));
break;
case (404):
status_line.append(S404);
client->response.append(HTML_ERROR(S404));
break;
case (500):
status_line.append(S500);
client->response.append(HTML_ERROR(S500));
break;
}
status_line.append("\r\n");
status_line.append(_http_status[client->status]);
status_line.append(CRLF);
client->response.insert(0, status_line);
}
#define ROOT "www"
#define INDEX "index.html"
#define MAX_FILESIZE 1000000 // (1Mo)
void Webserv::_get_ressource(Client *client, ServerConfig &server, LocationConfig &location)
void Webserv::_error_html_response(Client *client, ServerConfig &server)
{
std::ifstream ifd; // For chunk, ifstream directly in struct CLient for multiples read without close() ?
char buf[MAX_FILESIZE+1];
std::string tmp;
if (server.error_pages[client->status].empty())
{
std::string html_page = HTML_ERROR;
::replace_all_substr(html_page, STATUS_PLACEHOLDER, _http_status[client->status]);
_append_body(client, html_page.c_str(), html_page.size(), "html");
}
else
_get_file(client, server.error_pages[client->status]);
}
#define INDEX "index.html" // temp wip
void Webserv::_get(Client *client, ServerConfig &server, LocationConfig &location)
{
(void)server; // To remove from arg if we determine its useless
std::string path = client->get_path();
if (path == "/") // TODO ; With server config
if (path == "/") // TODO : index and autoindex
path.append(INDEX);
path.insert(0, ROOT);
path.insert(0, location.root);
std::cerr << "path = " << path << "\n";
@@ -140,24 +155,39 @@ void Webserv::_get_ressource(Client *client, ServerConfig &server, LocationConfi
//
// END TMP HUGO
if (access(path.c_str(), R_OK) == -1)
_get_file(client, path);
}
void Webserv::_get_file(Client *client, const std::string &path)
{
std::ifstream ifd; // For chunk, ifstream directly in struct CLient for multiples read without close() ?
// char buf[MAX_FILESIZE+1];
if (access(path.c_str(), F_OK) == -1)
{
std::perror("err access()");
client->status = 404;
return ;
}
if (access(path.c_str(), R_OK) == -1)
{
std::perror("err access()");
client->status = 403;
return ;
}
ifd.open(path.c_str(), std::ios::binary | std::ios::ate); // std::ios::binary (binary for files like images ?)
if (!ifd)
{
std::cerr << path << ": open fail" << '\n';
std::cerr << path << ": ifd.open fail" << '\n';
client->status = 500;
}
else
{
// WIP : Chunk or not chunk (if filesize too big)
std::streampos size = ifd.tellg();
// WIP : Chunk or not chunk (if filesize too big)
if (size > MAX_FILESIZE)
{
// Then chunk
@@ -168,38 +198,161 @@ void Webserv::_get_ressource(Client *client, ServerConfig &server, LocationConfi
}
ifd.seekg(0, std::ios::beg);
ifd.read(buf, size);
buf[ifd.gcount()] = '\0';
ifd.read(client->buf, size);
if (!ifd)
{
std::cerr << path << ": ifd.read fail" << '\n';
client->status = 500;
}
else
{
client->status = 200;
client->buf[ifd.gcount()] = '\0';
client->response.append("Content-Type: text/html; charset=UTF-8\r\n"); // TODO : determine Content-Type
std::string file_ext = "";
size_t dot_pos = path.rfind(".");
std::cerr << "dot_pos = " << dot_pos << "\n";
if (dot_pos != std::string::npos && dot_pos + 1 < path.size())
file_ext = path.substr(dot_pos + 1);
std::cerr << "file_ext = " << file_ext << "\n";
client->response.append("Content-Length: ");
tmp = ::itos(ifd.gcount());
client->response.append(tmp);
client->response.append("\r\n");
// Body
client->response.append("\r\n");
client->response.append(buf);
client->body_size = ifd.gcount();
// WIP, pass empty body argument because append to string mess up binary file
_append_body(client, "", client->body_size, file_ext);
}
ifd.close();
}
}
void Webserv::_post(Client *client, ServerConfig &server, LocationConfig &location)
void Webserv::_append_body(Client *client, const char *body, size_t body_size, const std::string &file_extension)
{
/*
TODO
TODO : determine Content-Type
how ? read the body ?
or before in other way (like based and file extension) and pass here as argument ?
http://nginx.org/en/docs/http/ngx_http_core_module.html#types
Need to look "conf/mime.types" of nginx. Maybe make a map<> based on that.
*/
(void)0;
const std::string &mime_type = _mime_types[file_extension];
client->response.append("Content-Type: ");
client->response.append(mime_type);
if (mime_type.find("text/") != std::string::npos)
client->response.append("; charset=UTF-8");
client->response.append(CRLF);
client->response.append("Content-Length: ");
std::string tmp = ::itos(body_size);
client->response.append(tmp);
client->response.append(CRLF);
client->response.append(CRLF);
client->response.append(body);
}
void Webserv::_post(Client *client, ServerConfig &server, LocationConfig &location)
{
(void)server; // To remove from arg if we determine its useless
/*
WIP
https://www.rfc-editor.org/rfc/rfc9110.html#name-post
*/
std::string path = client->get_path();
path.insert(0, location.root);
/* CGI Here ? */
_post_file(client, path);
}
void Webserv::_post_file(Client *client, const std::string &path)
{
std::ofstream ofd;
bool file_existed;
if (access(path.c_str(), F_OK) == -1)
file_existed = false;
else
file_existed = true;
// How to determine status 403 for file that dont already exist ?
if (file_existed && access(path.c_str(), W_OK) == -1)
{
std::perror("err access()");
client->status = 403;
return ;
}
ofd.open(path.c_str(), std::ios::binary | std::ios::trunc);
if (!ofd)
{
std::cerr << path << ": ofd.open fail" << '\n';
client->status = 500;
}
else
{
// Used body.size() so Content-Length useless at this point ?
// Maybe usefull in _read_request() for rejecting too big content.
// Need to _determine_process_server() as soon as possible,
// like in _read_request() for stopping read if body is too big ?
ofd.write(client->get_body().c_str(), client->get_body().size());
if (!ofd)
{
std::cerr << path << ": ofd.write fail" << '\n';
client->status = 500;
}
else if (file_existed)
{
client->status = 200;
// WIP https://www.rfc-editor.org/rfc/rfc9110.html#name-200-ok
}
else
{
client->status = 201;
// WIP https://www.rfc-editor.org/rfc/rfc9110.html#section-9.3.3-4
}
ofd.close();
}
}
void Webserv::_delete(Client *client, ServerConfig &server, LocationConfig &location)
{
(void)server; // To remove from arg if we determine its useless
/*
TODO
WIP
https://www.rfc-editor.org/rfc/rfc9110.html#name-delete
*/
(void)0;
std::string path = client->get_path();
path.insert(0, location.root);
/* CGI Here ? */
_delete_file(client, path);
}
void Webserv::_delete_file(Client *client, const std::string &path)
{
if (access(path.c_str(), F_OK) == -1)
{
std::perror("err access()");
client->status = 404;
return ;
}
if (access(path.c_str(), W_OK) == -1)
{
std::perror("err access()");
client->status = 403;
return ;
}
if (remove(path.c_str()) == -1)
{
std::perror("err remove()");
client->status = 500;
return ;
}
}
ServerConfig &Webserv::_determine_process_server(Client *client)