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

getting ready to pull

Browse Source
This commit is contained in:
Me
2022-08-03 18:56:34 +02:00
parent 16af16084b
commit fef26aee5b
7 changed files with 9 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

400
srcs/config/ConfigParser.cpp Normal file
View File

@@ -0,0 +1,400 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ConfigParser.cpp :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: lperrey <lperrey@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/07/13 22:11:17 by me #+# #+# */
/* Updated: 2022/07/31 13:18:14 by simplonco ### ########.fr */
/* */
/* ************************************************************************** */
#include "ConfigParser.hpp"
// Default
ConfigParser::ConfigParser()
{
std::cout << "Default Constructor\n";
// don't use yet, you have no idea what the defaults are
}
ConfigParser::ConfigParser(const char* path)
{
std::cout << "Param Constructor\n";
std::ifstream file;
std::string buf;
size_t comment;
_content.clear();
file.open(path);
if (file.is_open())
{
// are there more throws i need to add in case of errors, what would
// those errors be?
while (!file.eof())
{
getline(file, buf);
// remove # comments here.
if ((comment = buf.find_first_of("#")) == std::string::npos)
{
// remove empty lines, i think...
if ((buf.find_first_not_of(" \t")) != std::string::npos)
_content.append(buf + '\n');
}
else if (comment > 0 && (buf.find_first_not_of(" \t")) < comment)
{
// is there a comment at the end of the line
std::string tmp = buf.substr(0, comment - 1);
_content.append(tmp + '\n');
}
}
file.close();
}
else
throw std::invalid_argument("open config");
}
ConfigParser::~ConfigParser()
{
// do i need to destroy anything, won't it handle itself?
}
/*
ConfigParser & ConfigParser::operator=(const ConfigParser& rhs)
{
if (this == rhs) // * & ?
return (*this); // * ?
// make some stuff equal
return (*this);
}
*/
std::vector<ServerConfig> * ConfigParser::parse()
{
std::vector<ServerConfig> * ret = new std::vector<ServerConfig>();
// std::vector<ServerConfig> ret;
size_t start = 0;
size_t curr = _content.find_first_not_of(" \t\n", 0);
if (curr == std::string::npos)
throw std::invalid_argument("empty config file");
while (curr != std::string::npos)
{
// why no checks here
// if not here do i need them elsewhere?
start = _content.find_first_not_of(" \t\n", curr);
curr = _content.find_first_of(" \t\n", start);
std::string key = _content.substr(start, curr - start);
if (key != "server")
throw std::invalid_argument("bad config file arguments 1");
ret->push_back(_parse_server(&curr));
}
_post_processing(ret);
return (ret);
}
ServerConfig ConfigParser::_parse_server(size_t *start)
{
ServerConfig ret;
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] != '{')
throw std::invalid_argument("bad config file syntax 1");
curr = _content.find_first_of(" \t\n", curr + 1);
// if (curr == std::string::npos) // are there other things to check for?
// throw std::invalid_argument("bad config file syntax");
while (curr != std::string::npos) // here curr == { + 1
{
// so this moves curr to past the word...
std::string key = _get_first_word(&curr);
// now curr is on space after 1st word.
if (key == "}")
{
// why +1 curr is already after it no?
*start = _content.find_first_not_of(" \t\n", curr + 1);
break ;
}
else if (key == "location")
ret.locations.push_back(_parse_location(&curr));
else
{
std::string values = _get_rest_of_line(&curr);
// curr now should be \n
_set_server_values(&ret, key, values);
}
}
return (ret);
}
LocationConfig ConfigParser::_parse_location(size_t *start)
{
LocationConfig ret;
size_t curr = *start;
// start is after the 1st word aka "location"
ret.client_body_limit = 0;
ret.redirect_status = 0;
ret.path = _get_first_word(&curr);
// in theory now curr should be right after the "path"
curr = _content.find_first_not_of(" \t\n", curr);
if (curr == std::string::npos || _content[curr] != '{')
throw std::invalid_argument("bad config file syntax 2");
curr = _content.find_first_of(" \t\n", curr + 1);
// if (curr == std::string::npos) // are there other things to check for?
// throw std::invalid_argument("bad config file syntax");
while (curr != std::string::npos)
{
// so this moves curr to past the word...
std::string key = _get_first_word(&curr);
// now curr is on space after 1st word.
if (key == "}")
{
*start = curr;
break ;
}
else
{
std::string values = _get_rest_of_line(&curr);
// curr now should be \n
_set_location_values(&ret, key, values);
}
}
return (ret);
}
void ConfigParser::_set_server_values(ServerConfig *server, \
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 == "server_name" && size == 1)
{
for (size_t i = 0; i < server->server_name.size(); i++)
{
if (server->server_name[i].compare(tmp_val[0]) == 0)
throw std::invalid_argument("server_name already exists");
}
server->server_name.push_back(tmp_val[0]);
}
else if (key == "listen" && size == 1 && server->host == "" \
&& server->port == "")
{
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")
{
// 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++)
location->index.push_back(tmp_val[i]);
}
else if (key == "allow_methods" && location->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");
location->allow_methods.push_back(m);
}
}
else if (key == "cgi_info")
{
// you can call cgi_info several times i think.
// ok wtf is all this even doing, figure that out
unsigned long i = value.find_first_of(" ");
if (i == std::string::npos)
throw std::invalid_argument("bad config file arguments 8");
// ok why an int now, we gotta be more consistent!
int j = value.find_first_not_of(" ", i);
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
{
// 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");
}
}

106
srcs/config/ConfigParser.hpp Normal file
View File

@@ -0,0 +1,106 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ConfigParser.hpp :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: me <erlazo@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/07/11 23:01:41 by me #+# #+# */
/* Updated: 2022/07/27 19:27:57 by me ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef CONFIGPARSER_HPP
# define CONFIGPARSER_HPP
# include "ServerConfig.hpp"
# include "LocationConfig.hpp"
# include "MethodType.hpp"
# include "utils.hpp"
# include <map>
# include <vector>
# include <exception> // exception, what
# include <stdexcept> // runtime_error, invalid_argument
# include <string> // string
# include <cstdlib> // atoi (athough it's already cover by <string>)
# include <iostream> // cout, cin
# include <fstream> // ifstream
//# include <unistd.h> // access()
# include <dirent.h> // opendir()
class ConfigParser {
public:
// canonical
ConfigParser(const char* path); // a string?
~ConfigParser();
// ideally i wouldn't have one cuz it makes no sense, when would i use it?
// ConfigParser & operator=(const ConfigParser& rhs);
// void parse(); // return void cuz throw exceptions.
std::vector<ServerConfig> * parse(); // const?
// std::vector<ServerConfig> parse(); // const?
// other parses?
// i thought if it were an instance of this class you could call
// private member functions from anywhere...
void _print_content() const;
private:
std::string _content;
// explicit?
// what exaclty does explicit do again?
ConfigParser(); // might need a path as arg?
// should this be in private since it always needs a path?
ServerConfig _parse_server(size_t *start);
LocationConfig _parse_location(size_t *start);
void _set_server_values(ServerConfig *server, 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_rest_of_line(size_t *curr); // const?
// why static? it's an enum...
static MethodType _str_to_method_type(std::string str);
// 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

85
srcs/config/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/config/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...

58
srcs/config/LocationConfig.hpp Normal file
View File

@@ -0,0 +1,58 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* LocationConfig.hpp :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: me <erlazo@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/07/23 16:08:00 by me #+# #+# */
/* Updated: 2022/07/25 20:09:48 by me ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef LOCATIONCONFIG_HPP
# define LOCATIONCONFIG_HPP
# include "MethodType.hpp"
# include <map>
# include <vector>
# include <string>
// again, struct instead?
class LocationConfig
{
public:
// canonic stuff?
std::string path;
int client_body_limit;
std::string root;
std::vector<std::string> index;
std::vector<MethodType> allow_methods;
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

117
srcs/config/ServerConfig.hpp Normal file
View File

@@ -0,0 +1,117 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ServerConfig.hpp :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: me <erlazo@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/07/23 15:55:16 by me #+# #+# */
/* Updated: 2022/07/23 16:19:43 by me ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef SERVERCONFIG_HPP
# define SERVERCONFIG_HPP
# include "MethodType.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?
class ServerConfig
{
public:
// do i need some canonic stuff?
// 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;
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::map<int, std::string> error_pages;
// 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<LocationConfig> locations;
// not convinced we need these...
// struct timeval send_timeout;
// struct timeval recv_timeout;
// fuck maybe i do need return here...
// wait if i can call several times, shouldn't it be a map?
// i think actually there can only be 1 and it can only be in a location?
// int redirect_status;
// std::string redirect_uri;
void print_all()
{
std::cout << "PRINTING A FULL SERVER CONFIG\n\n";
for (size_t i = 0; i < server_name.size(); i++)
std::cout << server_name[i] << " ";
std::cout << "root: " << root << '\n';
std::cout << "index: ";
for (size_t i = 0; i < index.size(); i++)
std::cout << index[i] << " ";
std::cout << "\nerror_pages: ";
for(std::map<int, std::string>::iterator it = error_pages.begin(); \
it != error_pages.end(); it++)
std::cout << it->first << "--" << it->second << " ";
// for (size_t i = 0; i < error_pages.size(); i++)
// std::cout << error_pages->first << "--" << error_pages->second << " ";
std::cout << "\nallow_methods: ";
for (size_t i = 0; i < allow_methods.size(); i++)
std::cout << allow_methods[i] << " ";
std::cout << "\nskiping Locations for now...\n";
std::cout << "also skiping send_timeout and recv\n";
std::cout << "autoindex: " << autoindex << '\n';
std::cout << "client_body_limit: " << client_body_limit << '\n';
// std::cout << "redirect_status: " << redirect_status << '\n';
// std::cout << "redirect_uri: " << redirect_uri << '\n';
std::cout << "host: " << host << '\n';
std::cout << "port: " << port << '\n';
std::cout << "\n----------\n";
}
};
#endif