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

merged from master and relocate headers inside srcs

Browse Source
This commit is contained in:
hugogogo
2022-08-01 20:33:06 +02:00
parent 979a3d20b8 16af16084b
commit b1158fd33b
21 changed files with 552 additions and 374 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
Makefile
View File

@@ -11,8 +11,7 @@ CXXFLAGS += -MMD -MP #header dependencie
VPATH = $(SRCS_D) VPATH = $(SRCS_D)
HEADERS_D = srcs \ HEADERS_D = srcs
headers
SRCS_D = srcs \ SRCS_D = srcs \
srcs/webserv srcs/webserv
@@ -21,9 +20,11 @@ SRCS = main.cpp \
accept.cpp request.cpp response.cpp \ accept.cpp request.cpp response.cpp \
run_loop.cpp \ run_loop.cpp \
ConfigParser.cpp \ ConfigParser.cpp \
ConfigParserUtils.cpp \
ConfigParserPost.cpp \
utils.cpp \ utils.cpp \
cgi_script.cpp \ cgi_script.cpp \
Client.cpp Client.cpp \
OBJS_D = builds OBJS_D = builds
OBJS = $(SRCS:%.cpp=$(OBJS_D)/%.o) OBJS = $(SRCS:%.cpp=$(OBJS_D)/%.o)

1
README.md
View File

@@ -1,5 +1,4 @@
--- ---
## questions ## questions
- mettre les fonctions specifiques a la requete, dans la class client ? - mettre les fonctions specifiques a la requete, dans la class client ?

16
default.config
View File

@@ -6,6 +6,8 @@ server {
listen 0.0.0.0:4040; listen 0.0.0.0:4040;
# client_body_limit asdfa;
# client_body_limit 400;
index index.html; # this is another comment index index.html; # this is another comment
root ./www/; root ./www/;
@@ -13,17 +15,3 @@ server {
allow_methods GET; allow_methods GET;
} }
server {
# this is a comment
server_name our_server;
listen 0.0.0.0:4047;
index index.html; # this is another comment
root ./www/;
allow_methods GET;
}

14
headers/utils.hpp
View File

@@ -1,14 +0,0 @@
#ifndef UTILS_HPP
# define UTILS_HPP
# include <string>
# include <sstream>
# include <vector>
std::vector<std::string> split(std::string input, char delimiter);
std::string itos(int n);
std::string trim(std::string str, char c);
#endif

5
headers/Client.hpp → srcs/Client.hpp
View File

@@ -47,5 +47,8 @@ class Client
}; };
#endif bool operator==(const Client& lhs, const Client& rhs);
bool operator==(const Client& lhs, int fd);
bool operator==(int fd, const Client& rhs);
#endif

450
srcs/ConfigParser.cpp
View File

@@ -6,26 +6,12 @@
/* By: lperrey <lperrey@student.42.fr> +#+ +:+ +#+ */ /* By: lperrey <lperrey@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2022/07/13 22:11:17 by me #+# #+# */ /* Created: 2022/07/13 22:11:17 by me #+# #+# */
/* Updated: 2022/07/30 23:07:42 by lperrey ### ########.fr */ /* Updated: 2022/07/31 13:18:14 by simplonco ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#include "ConfigParser.hpp" #include "ConfigParser.hpp"
/***** Stuf to rework
need to figure out why return std::vector<ServerConfig> * rather than just simple
not a pointer...
is there a good reason?
*/
// Default // Default
ConfigParser::ConfigParser() ConfigParser::ConfigParser()
{ {
@@ -33,8 +19,6 @@ ConfigParser::ConfigParser()
// don't use yet, you have no idea what the defaults are // don't use yet, you have no idea what the defaults are
} }
//ConfigParser::ConfigParser(std::string &path)
//ConfigParser::ConfigParser(char & path)
ConfigParser::ConfigParser(const char* path) ConfigParser::ConfigParser(const char* path)
{ {
std::cout << "Param Constructor\n"; std::cout << "Param Constructor\n";
@@ -61,7 +45,6 @@ ConfigParser::ConfigParser(const char* path)
} }
else if (comment > 0 && (buf.find_first_not_of(" \t")) < comment) else if (comment > 0 && (buf.find_first_not_of(" \t")) < comment)
{ {
// else if (comment > 0 && (buf.find_first_not_of(" \t")) != std::string::npos)
// is there a comment at the end of the line // is there a comment at the end of the line
std::string tmp = buf.substr(0, comment - 1); std::string tmp = buf.substr(0, comment - 1);
_content.append(tmp + '\n'); _content.append(tmp + '\n');
@@ -109,20 +92,19 @@ std::vector<ServerConfig> * ConfigParser::parse()
std::string key = _content.substr(start, curr - start); std::string key = _content.substr(start, curr - start);
if (key != "server") if (key != "server")
throw std::invalid_argument("bad config file arguments 1"); throw std::invalid_argument("bad config file arguments 1");
// Server server = parse_server(&curr);
// ret->push_back(server);
// why not this?
ret->push_back(_parse_server(&curr)); ret->push_back(_parse_server(&curr));
} }
_post_processing(ret);
return (ret); return (ret);
} }
// might need new names for Prev and Curr, not super descriptive...
ServerConfig ConfigParser::_parse_server(size_t *start) ServerConfig ConfigParser::_parse_server(size_t *start)
{ {
ServerConfig ret; ServerConfig ret;
size_t curr = _content.find_first_not_of(" \t\n", *start); size_t curr = _content.find_first_not_of(" \t\n", *start);
ret.client_body_limit = 0;
ret.autoindex = false;
if (curr == std::string::npos || _content[curr] != '{') if (curr == std::string::npos || _content[curr] != '{')
throw std::invalid_argument("bad config file syntax 1"); throw std::invalid_argument("bad config file syntax 1");
@@ -141,17 +123,12 @@ ServerConfig ConfigParser::_parse_server(size_t *start)
break ; break ;
} }
else if (key == "location") else if (key == "location")
{
// this does assume we have locations in Server...
// could change the name but it's so clear...
ret.locations.push_back(_parse_location(&curr)); ret.locations.push_back(_parse_location(&curr));
}
else else
{ {
std::string values = _get_rest_of_line(&curr); std::string values = _get_rest_of_line(&curr);
// curr now should be \n // curr now should be \n
// checking for ; in _set_value, check key and value _set_server_values(&ret, key, values);
_set_server_values(&ret, key, values); // handles the throws
} }
} }
return (ret); return (ret);
@@ -165,12 +142,13 @@ LocationConfig ConfigParser::_parse_location(size_t *start)
size_t curr = *start; size_t curr = *start;
// start is after the 1st word aka "location" // start is after the 1st word aka "location"
ret.client_body_limit = 0;
ret.redirect_status = 0;
ret.path = _get_first_word(&curr); ret.path = _get_first_word(&curr);
// in theory now curr should be right after the "path" // in theory now curr should be right after the "path"
curr = _content.find_first_not_of(" \t\n", curr); curr = _content.find_first_not_of(" \t\n", curr);
if (curr == std::string::npos || _content[curr] != '{') if (curr == std::string::npos || _content[curr] != '{')
throw std::invalid_argument("bad config file syntax 2"); throw std::invalid_argument("bad config file syntax 2");
@@ -191,9 +169,7 @@ LocationConfig ConfigParser::_parse_location(size_t *start)
{ {
std::string values = _get_rest_of_line(&curr); std::string values = _get_rest_of_line(&curr);
// curr now should be \n // curr now should be \n
// checking for ; in _set_value, check key and value _set_location_values(&ret, key, values);
_set_location_values(&ret, key, values); //handles the throws
} }
} }
return (ret); return (ret);
@@ -201,203 +177,185 @@ LocationConfig ConfigParser::_parse_location(size_t *start)
// ok you need to think through these throws, when will each occur?
void ConfigParser::_set_server_values(ServerConfig *server, \ void ConfigParser::_set_server_values(ServerConfig *server, \
const std::string key, std::string value) const std::string key, std::string value)
{ {
value = _pre_set_val_check(key, value);
// check key for ;
// check values for ; at end and right number of words depending on key
if (key.find_first_of(";") != std::string::npos)
throw std::invalid_argument("bad config file arguments 2");
// there shouldn't be any tabs, right? not between values...
if (value.find_first_of("\t") != std::string::npos)
{
std::cout << value << "\n";
throw std::invalid_argument("bad config file arguments 3");
}
size_t i = value.find_first_of(";");
// so you can't have no ;
// you can't have just ;
// and you can't have a ; not at the end or several ;
// in theory value_find_last_of should find the only ;
if (i == std::string::npos || (value.find_last_not_of(" \n")) != i \
|| value.compare(";") == 0)
throw std::invalid_argument("bad config file arguments 4");
// we Trim value.
// is this valid?
// would it be better to shove the result directly in tmp_val?
// like call substr in split?
//value = value.substr(0, i - 1);
value = value.substr(0, i);
std::vector<std::string> tmp_val = split(value, ' ');
size_t size = tmp_val.size();
// would if if be more optimized?
if (size < 1)
throw std::invalid_argument("missing value");
else if (key == "server_name" && size == 1)
{
server->server_name = tmp_val[0];
}
else if (key == "listen" && size == 1)
{
if (tmp_val[0].find_first_of(":") == std::string::npos)
{
// why not store as vector<int> [4] ?
server->host = "0.0.0.0";
server->port = tmp_val[0];
}
else
{
// maybe do this differently?
std::vector<std::string> tmp2 = split(tmp_val[0], ':');
// i might take issue with this, will see
if (server->host != "" && server->host != tmp2[0])
throw std::invalid_argument("bad listen");
server->host = tmp2[0];
server->port = tmp2[1];
}
}
else if (key == "root" && size == 1)
{
server->root = tmp_val[0];
}
else if (key == "autoindex" && size == 1)
{
server->autoindex = (tmp_val[0] == "on" ? true : false);
}
else if (key == "client_body_limit" && size == 1)
{
server->client_body_limit = atoi(tmp_val[0].c_str());
}
else if (key == "recv_timeout" && size == 1)
{
// what is tv_sec and do i need it?
// ok so i don't fully understand this part but ok, keep for now...
server->recv_timeout.tv_sec = atoi(tmp_val[0].c_str());
}
else if (key == "send_timeout" && size == 1)
{
server->send_timeout.tv_sec = atoi(tmp_val[0].c_str());
}
/* else
{
throw std::invalid_argument("should only have 1 value");
// yea ok but it could also be something else like too many
// args
}
*/
else if (key == "index")
{
// could run more tests on value content but meh...
for (unsigned long i = 0; i != tmp_val.size(); i++)
server->index.push_back(tmp_val[i]);
}
else if (key == "allow_methods")
{
// might do something different here
// like change how methods are stored?
for (unsigned long i = 0; i != tmp_val.size(); i++)
server->allow_methods.push_back(_str_to_method_type(tmp_val[i]));
}
else if (key == "return")
{
// could run more checks here too
// like tmp_val.size() must be 2
// and tmp_val[0] should be a number and tmp_val[1] a string?
server->redirect_status = atoi(tmp_val[0].c_str());
server->redirect_uri = tmp_val[1];
}
else if (key == "error_page")
{
// something more complicated?
// like make sure ints then 1 string?
std::string path = tmp_val[tmp_val.size() - 1];
for (unsigned long i = 0; i != tmp_val.size() - 1; i++)
{
int status_code = atoi(tmp_val[i].c_str());
// yea IDK i might not want to store this like that...
if (server->error_pages.find(status_code) != server->error_pages.end())
continue ;
server->error_pages[status_code] = path;
}
}
else
{
throw std::invalid_argument("wrong number of values");
}
}
// again not sure i want an int ret
void ConfigParser::_set_location_values(LocationConfig *location, \
const std::string key, std::string value)
{
// check key for ;
// check values for ; at end and right number of words depending on key
if (key.find_first_of(";") != std::string::npos)
throw std::invalid_argument("bad config file arguments 5");
// there shouldn't be any tabs, right? not between values...
if (value.find_first_of("\t") != std::string::npos)
throw std::invalid_argument("bad config file arguments 6");
size_t i = value.find_first_of(";");
// so you can't have no ;
// you can't have just ;
// and you can't have a ; not at the end or several ;
// in theory value_find_last_of should find the only ;
if (i == std::string::npos || (value.find_last_not_of(" \n")) != i \
|| value.compare(";") == 0)
throw std::invalid_argument("bad config file arguments 7");
// we Trim value.
// is this valid?
// could do like above?
value = value.substr(0, i);
std::vector<std::string> tmp_val = ::split(value, ' '); std::vector<std::string> tmp_val = ::split(value, ' ');
size_t size = tmp_val.size(); size_t size = tmp_val.size();
if (size < 1) if (size < 1)
throw std::invalid_argument("missing value"); throw std::invalid_argument("missing value");
else if (key == "root" && size == 1) else if (key == "server_name" && size == 1)
{ {
location->root = tmp_val[0]; for (size_t i = 0; i < server->server_name.size(); i++)
}
else if (key == "client_body_limit" && size == 1)
{ {
location->client_body_limit = atoi(tmp_val[0].c_str()); if (server->server_name[i].compare(tmp_val[0]) == 0)
throw std::invalid_argument("server_name already exists");
} }
/* else server->server_name.push_back(tmp_val[0]);
}
else if (key == "listen" && size == 1 && server->host == "" \
&& server->port == "")
{ {
throw std::invalid_argument("should only have 1 argument"); if (tmp_val[0].find_first_of(":") == std::string::npos)
{
// should i limit which ports can be used?
if (!::isNumeric(tmp_val[0]))
throw std::invalid_argument("bad port number");
server->host = "0.0.0.0";
server->port = tmp_val[0];
}
else
{
std::vector<std::string> tmp2 = ::split(tmp_val[0], ':');
std::vector<std::string> ip = ::split(tmp2[0], '.');
if (ip.size() != 4)
throw std::invalid_argument("bad host ip");
for (size_t i = 0; i < ip.size(); i++)
{
if (!::isNumeric_btw(0, 255, ip[i]))
throw std::invalid_argument("bad host ip");
}
if (!::isNumeric(tmp2[1]))
throw std::invalid_argument("bad port number");
server->host = tmp2[0];
server->port = tmp2[1];
}
}
else if (key == "root" && size == 1 && server->root == "")
{
DIR* dir = opendir(tmp_val[0].c_str());
if (dir)
closedir(dir);
else
throw std::invalid_argument("root dir could not be opened");
server->root = tmp_val[0];
}
else if (key == "autoindex" && size == 1)
{
// autoindex is a bool, there's no good way for me to see if it has
// bet set already
server->autoindex = (tmp_val[0] == "on" ? true : false);
}
else if (key == "client_body_limit" && size == 1 \
&& server->client_body_limit == 0)
{
if (!::isNumeric(tmp_val[0]))
throw std::invalid_argument("client_body_limit not a number");
server->client_body_limit = atoi(tmp_val[0].c_str());
} }
*/
else if (key == "index") else if (key == "index")
{ {
// i think you can call index several times...
// should i be doing an access?
// since index is at the root, but root might not yet be defined
// will check index later in post
for (unsigned long i = 0; i != tmp_val.size(); i++)
server->index.push_back(tmp_val[i]);
}
else if (key == "allow_methods" && server->allow_methods.empty())
{
for (unsigned long i = 0; i != tmp_val.size(); i++)
{
MethodType m = _str_to_method_type(tmp_val[i]);
if (m == 3)
throw std::invalid_argument("not a valid method");
server->allow_methods.push_back(m);
}
}
else if (key == "error_page")
{
// so it can either be just a /here/is/the/repo
// or it can be http://some_domain.com/here
// wtf... how should we handle...
// you can definitely call Error_pages several times, i think
std::string path = tmp_val[tmp_val.size() - 1];
for (unsigned long i = 0; i != tmp_val.size() - 1; i++)
{
// what are the bounds for Error codes?
if (!(isNumeric_btw(0, 600, tmp_val[i])))
throw std::invalid_argument("value not a valid number");
int status_code = atoi(tmp_val[i].c_str());
// yea cuz here we continue.. why suddenly flexible not throw ?
if (server->error_pages.find(status_code) != server->error_pages.end())
continue ;
server->error_pages[status_code] = path;
}
}
/* else if (key == "recv_timeout" && size == 1 && server->server_name == "")
{
// what is tv_sec and do i need it?
// ok so i don't fully understand this part but ok, keep for now...
server->recv_timeout.tv_sec = atoi(tmp_val[0].c_str());
}
else if (key == "send_timeout" && size == 1 && server->server_name == "")
{
server->send_timeout.tv_sec = atoi(tmp_val[0].c_str());
}
*/ else
{
// means either you didn't write the right key, or the value is
// missing, or the value has already been filled.
throw std::invalid_argument("bad key value pair");
}
}
void ConfigParser::_set_location_values(LocationConfig *location, \
const std::string key, std::string value)
{
value = _pre_set_val_check(key, value);
std::vector<std::string> tmp_val = ::split(value, ' ');
size_t size = tmp_val.size();
if (size < 1)
throw std::invalid_argument("missing value");
else if (key == "root" && size == 1 && location->root == "")
{
DIR* dir = opendir(tmp_val[0].c_str());
if (dir)
closedir(dir);
else
throw std::invalid_argument("root dir could not be opened");
location->root = tmp_val[0];
}
else if (key == "client_body_limit" && size == 1 \
&& location->client_body_limit == 0)
{
if (!::isNumeric(tmp_val[0]))
throw std::invalid_argument("client_body_limit not a number");
location->client_body_limit = atoi(tmp_val[0].c_str());
}
else if (key == "index")
{
// you can definitely call Index several times, i think
for (unsigned long i = 0; i != tmp_val.size(); i++) for (unsigned long i = 0; i != tmp_val.size(); i++)
location->index.push_back(tmp_val[i]); location->index.push_back(tmp_val[i]);
} }
else if (key == "allow_methods") else if (key == "allow_methods" && location->allow_methods.empty())
{ {
for (unsigned long i = 0; i != tmp_val.size(); i++) for (unsigned long i = 0; i != tmp_val.size(); i++)
location->allow_methods.push_back(_str_to_method_type(tmp_val[i])); {
MethodType m = _str_to_method_type(tmp_val[i]);
if (m == 3)
throw std::invalid_argument("not a valid method");
location->allow_methods.push_back(m);
}
} }
else if (key == "cgi_info") else if (key == "cgi_info")
{ {
// you can call cgi_info several times i think.
// ok wtf is all this even doing, figure that out // ok wtf is all this even doing, figure that out
unsigned long i = value.find_first_of(" "); unsigned long i = value.find_first_of(" ");
if (i == std::string::npos) if (i == std::string::npos)
@@ -406,76 +364,32 @@ void ConfigParser::_set_location_values(LocationConfig *location, \
int j = value.find_first_not_of(" ", i); int j = value.find_first_not_of(" ", i);
location->cgi_info[value.substr(0, i)] = value.substr(j, value.length()); location->cgi_info[value.substr(0, i)] = value.substr(j, value.length());
} }
else if (key == "return" && location->redirect_status == 0 \
&& location->redirect_uri == "")
{
// actually i think there can only be one per location...
// you can definitely call return several times, i think
if (tmp_val.size() != 2)
throw std::invalid_argument("wrong number of values");
// and tmp_val[0] should be a number and tmp_val[1] a string?
if (!(::isNumeric(tmp_val[0])))
throw std::invalid_argument("value not a number");
// somehow check that tmp_val[1] is a string? or valid? how?
// something about using access() to see if
location->redirect_status = atoi(tmp_val[0].c_str());
location->redirect_uri = tmp_val[1];
}
else else
{ {
throw std::invalid_argument("bad config file arguments 9"); // means either you didn't write the right key, or the value is
// missing, or the value has already been filled.
throw std::invalid_argument("bad key value pair");
} }
} }
// assumes curr is on a space or \t or \n
// get first word? next word? word?
std::string ConfigParser::_get_first_word(size_t *curr)
{
size_t start;
// are these checks excessive?
if ((start = _content.find_first_not_of(" \t\n", *curr)) == std::string::npos)
throw std::invalid_argument("bad config file arguments");
if ((*curr = _content.find_first_of(" \t\n", start)) == std::string::npos)
throw std::invalid_argument("bad config file arguments");
std::string key = _content.substr(start, *curr - start);
return (key);
}
// also assumes curr is on a space \t or \n
std::string ConfigParser::_get_rest_of_line(size_t *curr)
{
size_t start;
if ((start = _content.find_first_not_of(" \t\n", *curr)) == std::string::npos)
throw std::invalid_argument("bad config file arguments");
// std::cout << "start + 4 = " << _content.substr(start, 4) << "\n";
// std::cout << "curr + 4 = " << _content.substr(*curr, 4) << "\n";
if ((*curr = _content.find_first_of("\n", start)) == std::string::npos)
throw std::invalid_argument("bad config file arguments");
std::string values = _content.substr(start, *curr - start);
// std::cout << "curr + 4 = " << _content.substr(*curr, 4) << "\n";
// std::cout << "rest of Line values: " << values << "\n";
return (values);
}
MethodType ConfigParser::_str_to_method_type(std::string str)
{
if (str == "GET")
return GET;
else if (str == "POST")
return POST;
else if (str == "DELETE")
return DELETE;
return INVALID;
}
void ConfigParser::_print_content() const
{
std::cout << _content;
}
// I might need to make my own Exceptions to throw...

49
headers/ConfigParser.hpp → srcs/ConfigParser.hpp
View File

@@ -13,26 +13,21 @@
#ifndef CONFIGPARSER_HPP #ifndef CONFIGPARSER_HPP
# define CONFIGPARSER_HPP # define CONFIGPARSER_HPP
# include "Webserv.hpp" // easier to just do this?
# include "ServerConfig.hpp" # include "ServerConfig.hpp"
// add includes properly # include "LocationConfig.hpp"
# include "MethodType.hpp"
# include "utils.hpp"
# include <map>
// This is gonna be temporary cuz i don't konw if i like it # include <vector>
#define MAX_REQUEST_SIZE 2048 # include <exception> // exception, what
#define MAX_URI_SIZE 64 # include <stdexcept> // runtime_error, invalid_argument
#define BSIZE 1024 # include <string> // string
# include <cstdlib> // atoi (athough it's already cover by <string>)
/* # include <iostream> // cout, cin
// this can't be here... # include <fstream> // ifstream
enum MethodType //# include <unistd.h> // access()
{ # include <dirent.h> // opendir()
GET,
POST,
DELETE,
INVALID,
};
*/
class ConfigParser { class ConfigParser {
@@ -74,6 +69,9 @@ private:
void _set_location_values(LocationConfig *location, const std::string key, std::string value); void _set_location_values(LocationConfig *location, const std::string key, std::string value);
std::string _pre_set_val_check(const std::string key, \
const std::string value);
std::string _get_first_word(size_t *curr); // const? std::string _get_first_word(size_t *curr); // const?
std::string _get_rest_of_line(size_t *curr); // const? std::string _get_rest_of_line(size_t *curr); // const?
@@ -81,13 +79,24 @@ private:
// why static? it's an enum... // why static? it's an enum...
static MethodType _str_to_method_type(std::string str); static MethodType _str_to_method_type(std::string str);
// just for testing purposes
// some sort of post processing...
void _post_processing(std::vector<ServerConfig> *servers);
}; };
// def needs work line a better name an do i even need this?
// should it be in Utils instead?
class MyException : public std::invalid_argument
{
MyException(const std::string str)
: std::invalid_argument(str) {}
};
#endif #endif

85
srcs/ConfigParserPost.cpp Normal file
View File

@@ -0,0 +1,85 @@
#include "ConfigParser.hpp"
void ConfigParser::_post_processing(std::vector<ServerConfig> *servers)
{
// make certain servers default
// fill out empty settings
// if special settings are empty throw
std::vector<ServerConfig>::iterator it = servers->begin();
while (it != servers->end())
{
// host and port should already be set
if (it->host == "")
throw std::invalid_argument("Config file needs a host and port");
// is that a good default?
if (it->root == "")
it->root = "/";
if (it->client_body_limit == 0)
it->client_body_limit = 5000; // what is the recomended size?
// autoindex should already be false by default right?
// what do we do if Allow methods is left empty?
// all ?
if (it->allow_methods.empty())
throw std::invalid_argument("No methods specified");
// what to do if index is left empty? index.html?
// ok but i still need to check index, no idea how...
// if error_pages is left empty, we'll use the defaults which
// i believe are set elsewhere...
std::vector<LocationConfig>::iterator it_l = it->locations.begin();
while (it_l != it->locations.end())
{
// check that path is feasible...
// opendir?
DIR* dir = opendir(it_l->path.c_str());
if (dir)
closedir(dir);
else
throw std::invalid_argument("location dir could not be opened");
if (it_l->client_body_limit == 0)
it_l->client_body_limit = 5000; // what is the recomended size?
if (it_l->root == "")
it_l->root = it->root;
// fill out allow methods from server?
if (it_l->allow_methods.empty())
it_l->allow_methods = it->allow_methods;
// fill out index from Server?
// or do a bunch of checks on what is in there...
// same for redirect status i think
// maybe do something for Cgi_info?
++it_l;
}
++it;
}
// do the defaults at the end?
}

104
srcs/ConfigParserUtils.cpp Normal file
View File

@@ -0,0 +1,104 @@
#include "ConfigParser.hpp"
std::string ConfigParser::_pre_set_val_check(const std::string key, \
const std::string value)
{
// check key for ;
// check values for ; at end and right number of words depending on key
// std::cout << "pre check\n";
if (key.find_first_of(";") != std::string::npos)
throw std::invalid_argument("bad config file arguments 2");
// there shouldn't be any tabs, right? not between values...
if (value.find_first_of("\t") != std::string::npos)
{
std::cout << value << "\n";
throw std::invalid_argument("bad config file arguments 3");
}
size_t i = value.find_first_of(";");
// so you can't have no ;
// you can't have just ;
// and you can't have a ; not at the end or several ;
// in theory value_find_last_of should find the only ;
if (i == std::string::npos || (value.find_last_not_of(" \n")) != i \
|| value.compare(";") == 0)
throw std::invalid_argument("bad config file arguments 4");
// we Trim value.
// is this valid?
// would it be better to shove the result directly in tmp_val?
// like call substr in split?
//value = value.substr(0, i - 1);
return (value.substr(0, i));
}
// assumes curr is on a space or \t or \n
// get first word? next word? word?
std::string ConfigParser::_get_first_word(size_t *curr)
{
size_t start;
// are these checks excessive?
if ((start = _content.find_first_not_of(" \t\n", *curr)) == std::string::npos)
throw std::invalid_argument("bad config file arguments");
if ((*curr = _content.find_first_of(" \t\n", start)) == std::string::npos)
throw std::invalid_argument("bad config file arguments");
std::string key = _content.substr(start, *curr - start);
return (key);
}
// also assumes curr is on a space \t or \n
std::string ConfigParser::_get_rest_of_line(size_t *curr)
{
size_t start;
if ((start = _content.find_first_not_of(" \t\n", *curr)) == std::string::npos)
throw std::invalid_argument("bad config file arguments");
// std::cout << "start + 4 = " << _content.substr(start, 4) << "\n";
// std::cout << "curr + 4 = " << _content.substr(*curr, 4) << "\n";
if ((*curr = _content.find_first_of("\n", start)) == std::string::npos)
throw std::invalid_argument("bad config file arguments");
std::string values = _content.substr(start, *curr - start);
// std::cout << "rest of Line values: " << values << "\n";
return (values);
}
MethodType ConfigParser::_str_to_method_type(std::string str)
{
if (str == "GET")
return GET;
else if (str == "POST")
return POST;
else if (str == "DELETE")
return DELETE;
return INVALID;
}
void ConfigParser::_print_content() const
{
std::cout << _content;
}
// I might need to make my own Exceptions to throw...

23
headers/LocationConfig.hpp → srcs/LocationConfig.hpp
View File

@@ -13,12 +13,12 @@
#ifndef LOCATIONCONFIG_HPP #ifndef LOCATIONCONFIG_HPP
# define LOCATIONCONFIG_HPP # define LOCATIONCONFIG_HPP
// includes # include "MethodType.hpp"
// add includes properly
# include <string>
# include <vector>
# include <map> # include <map>
# include "Webserv.hpp" # include <vector>
# include <string>
// again, struct instead? // again, struct instead?
class LocationConfig class LocationConfig
@@ -26,20 +26,27 @@ class LocationConfig
public: public:
// canonic stuff? // canonic stuff?
std::string path;
int client_body_limit; int client_body_limit;
std::string path;
std::string root; std::string root;
std::vector<std::string> index; std::vector<std::string> index;
std::vector<MethodType> allow_methods; std::vector<MethodType> allow_methods;
std::map<std::string, std::string> cgi_info; std::map<std::string, std::string> cgi_info;
// wait if i can call several times, shouldn't it be a map?
// wait no there can only be 1 and i think it might have to be in
// location only...
int redirect_status;
std::string redirect_uri;
// au pire you do location / { return 301 http://location; }
// and that's how you get the redirect from the root.
}; };
#endif #endif

0
headers/MethodType.hpp → srcs/MethodType.hpp
View File

0
headers/Server.hpp → srcs/Server.hpp
View File

60
headers/ServerConfig.hpp → srcs/ServerConfig.hpp
View File

@@ -2,53 +2,67 @@
#ifndef SERVERCONFIG_HPP #ifndef SERVERCONFIG_HPP
# define SERVERCONFIG_HPP # define SERVERCONFIG_HPP
// add includes properly...
# include "Webserv.hpp"
# include "MethodType.hpp" # include "MethodType.hpp"
//# include "ConfigParser.hpp"
# include "LocationConfig.hpp" # include "LocationConfig.hpp"
# include <map>
# include <vector>
# include <string> // string
# include <iostream> // cout, cin
// a class that's all public? just so we have options? // a class that's all public? just so we have options?
class ServerConfig class ServerConfig
{ {
public: public:
// i mean i guess i need some canonic stuff? // do i need some canonic stuff?
// although maybe if i make it a struct i can barebones it?
std::string server_name;
// there can be several
std::vector<std::string> server_name;
// we could shove default in here if we wanted to...
// there can only be 1 per server...
std::string host;
std::string port; // port needs to be something else... not quite an int
// should a Server be able to handle several?
// there can only be one.
std::string root; std::string root;
int client_body_limit; // set to default max if none set
// might be the only one we let slide if bad input...
bool autoindex;
// we will check the index in the post processing with access() ?
std::vector<std::string> index; std::vector<std::string> index;
std::map<int, std::string> error_pages; std::map<int, std::string> error_pages;
// i'm tempted to do something diff for storing method types... // i'm tempted to do something diff for storing method types...
// fuck it, you can only call allow_methods once in Server
// once more in each location.
std::vector<MethodType> allow_methods; std::vector<MethodType> allow_methods;
std::vector<LocationConfig> locations; std::vector<LocationConfig> locations;
// might do something diff // not convinced we need these...
struct timeval send_timeout; // struct timeval send_timeout;
struct timeval recv_timeout; // struct timeval recv_timeout;
int client_body_limit;
bool autoindex;
// not sure what these look like in config file // fuck maybe i do need return here...
int redirect_status; // wait if i can call several times, shouldn't it be a map?
std::string redirect_uri; // i think actually there can only be 1 and it can only be in a location?
// int redirect_status;
// is this the best way? // std::string redirect_uri;
std::string host;
std::string port;
// do i need a print all for testing?
void print_all() void print_all()
{ {
std::cout << "PRINTING A FULL SERVER CONFIG\n\n"; std::cout << "PRINTING A FULL SERVER CONFIG\n\n";
std::cout << "Server_name: " << server_name << '\n'; for (size_t i = 0; i < server_name.size(); i++)
std::cout << server_name[i] << " ";
std::cout << "root: " << root << '\n'; std::cout << "root: " << root << '\n';
std::cout << "index: "; std::cout << "index: ";
for (size_t i = 0; i < index.size(); i++) for (size_t i = 0; i < index.size(); i++)
@@ -66,8 +80,8 @@ public:
std::cout << "also skiping send_timeout and recv\n"; std::cout << "also skiping send_timeout and recv\n";
std::cout << "autoindex: " << autoindex << '\n'; std::cout << "autoindex: " << autoindex << '\n';
std::cout << "client_body_limit: " << client_body_limit << '\n'; std::cout << "client_body_limit: " << client_body_limit << '\n';
std::cout << "redirect_status: " << redirect_status << '\n'; // std::cout << "redirect_status: " << redirect_status << '\n';
std::cout << "redirect_uri: " << redirect_uri << '\n'; // std::cout << "redirect_uri: " << redirect_uri << '\n';
std::cout << "host: " << host << '\n'; std::cout << "host: " << host << '\n';
std::cout << "port: " << port << '\n'; std::cout << "port: " << port << '\n';

9
headers/Webserv.hpp → srcs/Webserv.hpp
View File

@@ -27,12 +27,13 @@
# include "Client.hpp" # include "Client.hpp"
# include "ServerConfig.hpp" # include "ServerConfig.hpp"
# include "utils.hpp"
// TODO: A virer // TODO: A virer
# include "ConfigParser.hpp" //# include "ConfigParser.hpp"
# include "LocationConfig.hpp" //# include "LocationConfig.hpp"
# include "MethodType.hpp" //# include "MethodType.hpp"
# include "utils.hpp" //# include "utils.hpp"
// TODO: A virer // TODO: A virer
extern bool g_run; extern bool g_run;

1
srcs/main.cpp
View File

@@ -3,6 +3,7 @@
#include <exception> #include <exception>
#include <stdexcept> #include <stdexcept>
#include "Webserv.hpp" #include "Webserv.hpp"
#include "ConfigParser.hpp"
int main(int ac, char **av) int main(int ac, char **av)
{ {

23
srcs/utils.cpp
View File

@@ -29,3 +29,26 @@ std::string itos(int n)
return ( strs.str() ); return ( strs.str() );
} }
bool isNumeric(std::string str)
{
for (size_t i = 0; i < str.length(); i++)
{
if (std::isdigit(str[i]) == false)
return false;
}
return true;
}
bool isNumeric_btw(int low, int high, std::string str)
{
for (size_t i = 0; i < str.length(); i++)
{
if (std::isdigit(str[i]) == false)
return false;
}
int n = std::atoi(str.c_str());
if (n < low || n > high)
return false;
return true;
}

16
srcs/utils.hpp Normal file
View File

@@ -0,0 +1,16 @@
#ifndef UTILS_HPP
# define UTILS_HPP
# include <vector>
# include <string>
# include <sstream>
# include <cstdlib> // atoi
std::vector<std::string> split(std::string input, char delimiter);
bool isNumeric(std::string str);
bool isNumeric_btw(int low, int high, std::string str);
std::string itos(int n);
std::string trim(std::string str, char c);
#endif

2
srcs/webserv/accept.cpp
View File

@@ -22,5 +22,5 @@ void Webserv::_accept_connection(int fd)
_clients.push_back(Client()); _clients.push_back(Client());
_clients.back().fd = accepted_fd; _clients.back().fd = accepted_fd;
_epoll_update(accepted_fd, EPOLLIN, EPOLL_CTL_ADD, &_clients.back()); _epoll_update(accepted_fd, EPOLLIN, EPOLL_CTL_ADD);
} }

9
srcs/webserv/request.cpp
View File

@@ -15,8 +15,8 @@ void Webserv::_read_request(Client *client)
char buf[BUFSIZE+1]; char buf[BUFSIZE+1];
ssize_t ret; ssize_t ret;
std::cerr << "recv()\n";
ret = ::recv(client->fd, buf, BUFSIZE, 0); ret = ::recv(client->fd, buf, BUFSIZE, 0);
std::cerr << "recv() on fd(" << client->fd << ") returned = " << ret << "\n" ;
if (ret == -1) if (ret == -1)
{ {
std::perror("err recv()"); std::perror("err recv()");
@@ -25,6 +25,11 @@ void Webserv::_read_request(Client *client)
_close_client(client->fd); _close_client(client->fd);
return ; return ;
} }
if (ret == 0) // Not sure what to do in case of 0. Just close ?
{
_close_client(client->fd);
return ;
}
/* /*
if (ret == BUFSIZE) if (ret == BUFSIZE)
// send error like "request too long" to client // send error like "request too long" to client
@@ -35,7 +40,7 @@ void Webserv::_read_request(Client *client)
client->parse_request(); client->parse_request();
// _parse_request(client); // _parse_request(client);
_epoll_update(client->fd, EPOLLOUT, EPOLL_CTL_MOD, client); _epoll_update(client->fd, EPOLLOUT, EPOLL_CTL_MOD);
} }
// // http headers : // // http headers :

25
srcs/webserv/response.cpp
View File

@@ -27,15 +27,14 @@ void Webserv::_send_response(Client *client)
return ; return ;
} }
_close_client(client->fd); if (client->raw_request.find("Connection: close") != std::string::npos)
/* if (client->raw_request.find("Connection: keep-alive") == std::string::npos)
_close_client(client->fd); _close_client(client->fd);
else else
{ {
_epoll_update(client->fd, EPOLLIN, EPOLL_CTL_MOD, client); _epoll_update(client->fd, EPOLLIN, EPOLL_CTL_MOD);
client->raw_request.clear(); client->raw_request.clear();
client->response.clear(); client->response.clear();
} */ }
} }
void Webserv::_construct_response(Client *client) void Webserv::_construct_response(Client *client)
@@ -43,13 +42,17 @@ void Webserv::_construct_response(Client *client)
client->status = 200; client->status = 200;
client->response.append("Server: Webserv/0.1\r\n"); client->response.append("Server: Webserv/0.1\r\n");
if (client->raw_request.find("Connection: close") != std::string::npos)
client->response.append("Connection: close\r\n"); client->response.append("Connection: close\r\n");
else
client->response.append("Connection: keep-alive\r\n");
_get_ressource(client); _get_ressource(client);
_insert_status_line(client); _insert_status_line(client);
} }
#define E400 "\r\n<!DOCTYPE html><html><head><title>400 Bad Request</title></head><body><h1 style=\"text-align:center\">400 Bad Request</h1><hr><p style=\"text-align:center\">Le Webserv/0.1</p></body></html>"
#define E404 "\r\n<!DOCTYPE html><html><head><title>404 Not Found</title></head><body><h1 style=\"text-align:center\">404 Not Found</h1><hr><p style=\"text-align:center\">Le Webserv/0.1</p></body></html>" #define E404 "\r\n<!DOCTYPE html><html><head><title>404 Not Found</title></head><body><h1 style=\"text-align:center\">404 Not Found</h1><hr><p style=\"text-align:center\">Le Webserv/0.1</p></body></html>"
#define E500 "\r\n<!DOCTYPE html><html><head><title>500 Internal Server Error</title></head><body><h1 style=\"text-align:center\">500 Internal Server Error</h1><hr><p style=\"text-align:center\">Le Webserv/0.1</p></body></html>" #define E500 "\r\n<!DOCTYPE html><html><head><title>500 Internal Server Error</title></head><body><h1 style=\"text-align:center\">500 Internal Server Error</h1><hr><p style=\"text-align:center\">Le Webserv/0.1</p></body></html>"
void Webserv::_insert_status_line(Client *client) void Webserv::_insert_status_line(Client *client)
@@ -63,6 +66,10 @@ void Webserv::_insert_status_line(Client *client)
case (200): case (200):
status_line.append("200 OK"); status_line.append("200 OK");
break; break;
case (400):
status_line.append("400 Not Found");
client->response.append(E400);
break;
case (404): case (404):
status_line.append("404 Not Found"); status_line.append("404 Not Found");
client->response.append(E404); client->response.append(E404);
@@ -98,12 +105,21 @@ void Webserv::_get_ressource(Client *client)
// Mini parsing à l'arrache du PATH // Mini parsing à l'arrache du PATH
std::string path; std::string path;
try
{
path = client->raw_request.substr(0, client->raw_request.find("\r\n")); path = client->raw_request.substr(0, client->raw_request.find("\r\n"));
path = path.substr(0, path.rfind(" ")); path = path.substr(0, path.rfind(" "));
path = path.substr(path.find("/")); path = path.substr(path.find("/"));
if (path == "/") if (path == "/")
path.append(INDEX); path.append(INDEX);
path.insert(0, ROOT); path.insert(0, ROOT);
}
catch (std::out_of_range& e)
{
std::cout << e.what() << '\n';
client->status = 400;
return ;
}
if (access(path.data(), R_OK) == -1) if (access(path.data(), R_OK) == -1)
{ {
@@ -141,7 +157,6 @@ void Webserv::_get_ressource(Client *client)
tmp = ::itos(ifd.gcount()); tmp = ::itos(ifd.gcount());
client->response.append(tmp.c_str()); client->response.append(tmp.c_str());
client->response.append("\r\n"); client->response.append("\r\n");
// Body // Body

15
srcs/webserv/run_loop.cpp
View File

@@ -4,6 +4,14 @@
#define MAX_EVENTS 42 // arbitrary #define MAX_EVENTS 42 // arbitrary
#define TIMEOUT 3000 #define TIMEOUT 3000
// Temp. To move in other file
bool operator==(const Client& lhs, const Client& rhs)
{ return lhs.fd == rhs.fd; }
bool operator==(const Client& lhs, int fd)
{ return lhs.fd == fd; }
bool operator==(int fd, const Client& rhs)
{ return fd == rhs.fd; }
void Webserv::run() void Webserv::run()
{ {
std::cerr << "Server started\n"; std::cerr << "Server started\n";
@@ -33,15 +41,14 @@ void Webserv::run()
i = 0; i = 0;
while (i < nfds) while (i < nfds)
{ {
// if ((events[i].data.u32 == SERVER_FD) && (events[i].events & EPOLLIN)) // Dont work, see "SERVER_FD" define // TODO : handle EPOLLERR and EPOLLHUP
// if ((events[i].data.fd == _socket_fd) && (events[i].events & EPOLLIN))
if ((std::find(_listen_sockets.begin(), _listen_sockets.end(), events[i].data.fd) != _listen_sockets.end()) if ((std::find(_listen_sockets.begin(), _listen_sockets.end(), events[i].data.fd) != _listen_sockets.end())
&& (events[i].events & EPOLLIN)) && (events[i].events & EPOLLIN))
_accept_connection(events[i].data.fd); _accept_connection(events[i].data.fd);
else if (events[i].events & EPOLLIN) else if (events[i].events & EPOLLIN)
_request(static_cast<Client*>(events[i].data.ptr)); _request( &(*std::find(_clients.begin(), _clients.end(), events[i].data.fd)) );
else if (events[i].events & EPOLLOUT) else if (events[i].events & EPOLLOUT)
_response(static_cast<Client*>(events[i].data.ptr)); _response( &(*std::find(_clients.begin(), _clients.end(), events[i].data.fd)) );
++i; ++i;
if (!g_run) if (!g_run)
break; break;