410 lines
13 KiB
C++
410 lines
13 KiB
C++
/* ************************************************************************** */
|
|
/* */
|
|
/* ::: :::::::: */
|
|
/* ConfigParser.cpp :+: :+: :+: */
|
|
/* +:+ +:+ +:+ */
|
|
/* By: me <erlazo@student.42.fr> +#+ +:+ +#+ */
|
|
/* +#+#+#+#+#+ +#+ */
|
|
/* Created: 2022/07/13 22:11:17 by me #+# #+# */
|
|
/* Updated: 2022/07/27 19:27:55 by me ### ########.fr */
|
|
/* */
|
|
/* ************************************************************************** */
|
|
|
|
#include "ConfigParser.hpp"
|
|
|
|
|
|
/***** Stuf to rework
|
|
|
|
I don't love the use of EMPTY and FAILURE and those
|
|
slowly transitioning away...
|
|
|
|
I would rather throw exceptions everywhere...
|
|
|
|
|
|
where do i check if there is only a ";"
|
|
|
|
|
|
need to figure out why return std::vector<ServerConfig> * rather than just simple
|
|
not a pointer...
|
|
is there a good reason?
|
|
|
|
I need to better understand what check_proper_line does
|
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
// Default
|
|
ConfigParser::ConfigParser()
|
|
{
|
|
std::cout << "Default Constructor\n";
|
|
// 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)
|
|
{
|
|
std::cout << "Param Constructor\n";
|
|
|
|
std::ifstream file;
|
|
std::string buf;
|
|
// std::string tmp; // maybe there's a reason we redeclare vars...
|
|
size_t comment; // just a number so fine to reset
|
|
|
|
_content.clear();
|
|
file.open(path);
|
|
if (file.is_open())
|
|
{
|
|
while (!file.eof())
|
|
{
|
|
// if we remove the Emtpy lines as well it simplifies things later...
|
|
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")) != std::string::npos)
|
|
// i think this works cuz it will find # no matter what, so it will find
|
|
// something else first if there is non comment stuff.
|
|
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);
|
|
}
|
|
*/
|
|
|
|
|
|
// ok what exactly is the benefit of returning a pointer here...
|
|
std::vector<Server> * ConfigParser::parse()
|
|
{
|
|
// is this the best way to do this? new?
|
|
std::vector<ServerConfig> *ret = new std::vector<Server>();
|
|
// yea i could do
|
|
std::vector<ServerConfig> ret;
|
|
|
|
size_t prev = 0;
|
|
size_t curr = _content.find_first_not_of(" \t\n", prev);
|
|
|
|
if (curr == std::string::npos)
|
|
throw std::invalid_argument("empty config file");
|
|
while (cur != std::string::npos)
|
|
{
|
|
// ok i don't love her way of scoping out the "server" strings...
|
|
prev = _content.find_first_not_of(" \t\n", curr);
|
|
curr = _content.find_first_of(" \t\n", prev);
|
|
std::string key = _conent.substr(prev, curr - prev);
|
|
if (key != "server")
|
|
throw std::invalid_argument("bad config file arguments");
|
|
// Server server = parse_server(&curr);
|
|
// ret->push_back(server);
|
|
// why not this?
|
|
ret->push_back(parse_server(&curr);
|
|
}
|
|
return (ret);
|
|
// or
|
|
// return (&ret); // wait no, that doesn't work...
|
|
}
|
|
|
|
// could we return a ref instead?
|
|
// i think no
|
|
// might need new names for Prev and Curr, not super descriptive...
|
|
ServerConfig ConfigParser::parse_server(size_t *start)
|
|
{
|
|
ServerConfig ret;
|
|
size_t key_start;
|
|
size_t value_end;
|
|
size_t prev = _content.find_first_not_of(" \t\n", *start);
|
|
|
|
if (prev == std::string::npos || _content[prev] != '{')
|
|
throw std::invalid_argument("bad config file syntax");
|
|
|
|
size_t curr = _content.find_first_of(" \t\n", ++prev);
|
|
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)
|
|
{
|
|
_get_key(&word_start, &blank_start);
|
|
_check_proper_line_end(&prev, &curr); // nope, not an option i think...
|
|
/* if ((prev = _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", prev)) == std::string::npos)
|
|
throw std::invalid_argument("bad config file arguments");
|
|
*/ key_start = prev;
|
|
|
|
std::string key = _content.substr(prev, curr - prev);
|
|
std::string key = _get_key(&word_start, &blank_start);
|
|
switch (key)
|
|
{
|
|
case "}":
|
|
*start = _content.find_first_not_of(" \t\n" curr + 1);
|
|
break ;
|
|
case "location":
|
|
// this does assume we have locations in Server... we could change
|
|
// the name but it's so clear...
|
|
ret.location.push_back(parse_location(&curr));
|
|
default:
|
|
|
|
// ok i figured it out, there's a slight difference!
|
|
|
|
// curr below is this actually, she does go all the way to the end of the line...
|
|
// there has to be a better way of doing this, just like
|
|
// get me the first word, get me all the rest... but like in sub functions...
|
|
if ((curr = _content.find_first_of("\n", prev)) == std::string::npos)
|
|
throw std::invalid_argument("bad config file arguments");
|
|
|
|
_check_proper_line_end(&prev, &curr);
|
|
/* if ((prev = _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", prev)) == std::string::npos)
|
|
throw std::invalid_argument("bad config file arguments");
|
|
*/
|
|
// why bother with the if.. why not throw exception in check_line...
|
|
if ((value_end = _check_for_semicolon(_content.substr(key_start, curr - key_start))) == FAILED)
|
|
throw std::invalid_argument("bad config file arguments");
|
|
// if ((int)value_end == EMPTY)
|
|
// continue ;
|
|
// could i shove this in the _set_server_value() func call?
|
|
std::string value = _content.substr(prev, value_end - prev + key_start + 1)
|
|
// since there's not return anymore
|
|
// if (_set_server_value(&ret, key, value) == FAILED)
|
|
// throw std::invalid_argument("bad config file arguments");
|
|
_set_server_value(&ret, key, value); // it handles the throws
|
|
}
|
|
}
|
|
return (ret);
|
|
}
|
|
|
|
|
|
|
|
LocationConfig ConfigParser::parse_location(size_t *start)
|
|
{
|
|
LocationConfig ret;
|
|
size_t key_start;
|
|
size_t value_end;
|
|
size_t prev = _content.find_first_not_of(" \t\n", *start);
|
|
|
|
if (prev == std::string::npos || _content[prev] != '{')
|
|
throw std::invalid_argument("bad config file syntax");
|
|
|
|
size_t curr = _content.find_first_of(" \t\n", ++prev);
|
|
while (curr != std::string::npos)
|
|
{
|
|
_check_proper_line_end(&prev, &curr);
|
|
key_start = prev;
|
|
|
|
std::string key = _content.substr(prev, curr - prev);
|
|
switch (key)
|
|
{
|
|
case "}":
|
|
*start = curr;
|
|
break ;
|
|
default:
|
|
_check_proper_line_end(&prev, &curr);
|
|
// why bother with the if.. why not throw exception in check_line...
|
|
// ok no we need the if cuz have to set value_end
|
|
if ((value_end = _check_for_semicolon(_content.substr(key_start, curr - key_start))) == FAILED)
|
|
throw std::invalid_argument("bad config file arguments");
|
|
// if we remove all empty lines at the start no need for this
|
|
// if ((int)value_end == EMPTY)
|
|
// continue ;
|
|
// shove this in _set_location_value() func call?
|
|
std::string value = _content.substr(prev, value_end - prev + key_start + 1)
|
|
// if (_set_location_value(&ret, key, value) == FAILED)
|
|
// throw std::invalid_argument("bad config file arguments");
|
|
_set_location_value(&ret, key, value);
|
|
}
|
|
}
|
|
return (ret);
|
|
}
|
|
|
|
// yea ok new plan, this is where a lot of the checks will happen...
|
|
|
|
|
|
void ConfigParser::_set_server_value(Server *server, const std::string key, const std::string value)
|
|
{
|
|
// so turns out here is where i should be checking for the semicolon i think
|
|
// and also making sure there are the right number of values depending on which key it is...
|
|
// like for error page there can be a bunch but you can't have say 1 error code and several error files
|
|
// it's 1 error file per line and
|
|
|
|
// i could do some checks at the start for value being bad or empty? or is
|
|
// that unnecessary since in theory i've already checked that it's good...
|
|
switch (key)
|
|
{
|
|
case "server_name":
|
|
server->server_name = value;
|
|
case "listen":
|
|
if (value.find_first_of(":") == std::string::npos)
|
|
{
|
|
// why not store as vector<int> [4] ?
|
|
server->host = "0.0.0.0";
|
|
server->value = value;
|
|
}
|
|
else
|
|
{
|
|
// maybe do this differently?
|
|
std::vector<std::string> tmp = split(value, ':');
|
|
// i might take issue with this, will see
|
|
if (server->host != "" && server->host != tmp[0])
|
|
throw std::invalid_argument("bad config file arguments");
|
|
server->host = tmp[0];
|
|
server->port = tmp[1];
|
|
}
|
|
case "root":
|
|
server->root = value;
|
|
case "index":
|
|
std::vector<std::string> tmp = split(value, ' ');
|
|
for (unsigned long i = 0; i != tmp.size(); i++)
|
|
server->index.push_back(tmp[i]);
|
|
case "allow_methods":
|
|
std::vector<std::string> tmp = split(value, ' ');
|
|
// might do something different here
|
|
// like change how methods are stored?
|
|
for (unsigned long i = 0; i != tmp.size(); i++)
|
|
server->allow_methods.push_back(str_to_method_type(tmp[i]));
|
|
case "autoindex":
|
|
server->autoindex = (value == "on" ? true : false);
|
|
case "client_body_limit":
|
|
server->client_body_limit = atoi(value.c_str());
|
|
case "recv_timeout":
|
|
// what is tv_sec and do i need it?
|
|
server->recv_timeout.tv_sec = atoi(value.c_str());
|
|
case "send_timeout":
|
|
server->send_timeout.tv_sec = atoi(value.c_str());
|
|
case "return":
|
|
std::vector<std::string> tmp = split(value, ' ');
|
|
server->redirect_status = atoi(tmp[0].c_str());
|
|
server->redirect_uri = tmp[1];
|
|
case "error_page":
|
|
std::vector<std::string> tmp = split(value, ' ');
|
|
std::string path = tmp[tmp.size() - 1];
|
|
for (unsigned long i = 0; i != tmp.size() - 1; i++)
|
|
{
|
|
int status_code = atoi(tmp[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;
|
|
}
|
|
default :
|
|
throw std::invalid_argument("bad config file arguments");
|
|
}
|
|
// return (1); // for now but prolly will change...
|
|
}
|
|
|
|
// again not sure i want an int ret
|
|
int ConfigParser::_set_location_value(Location *location, const std::string key, const std::string value)
|
|
{
|
|
switch (key)
|
|
{
|
|
case "root":
|
|
location->root = value;
|
|
case "index":
|
|
std::vector<std::string> tmp = split(value, ' ');
|
|
for (unsigned long i = 0; i != tmp.size(); i++)
|
|
location->index.push_back(tmp[i]);
|
|
case "allow_methods":
|
|
std::vector<std::string> tmp = split(value, ' ');
|
|
for (unsigned long i = 0; i != tmp.size(); i++)
|
|
location->allow_methods.push_back(str_to_methodtype(tmp[i]));
|
|
case "cgi_info":
|
|
// 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");
|
|
// 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());
|
|
case "client_body_limit":
|
|
location->client_body_limit = atoi(value.c_str());
|
|
default :
|
|
throw std::invalid_argument("bad config file arguments");
|
|
}
|
|
return (1); // again prolly want to change this...
|
|
}
|
|
|
|
|
|
// shit, this doesn't work...
|
|
// wait it might...
|
|
// definitely need a better name...
|
|
// _check_proper_word_break ?
|
|
// get next word ?
|
|
void ConfigParser::_check_proper_line_end(size_t *prev, size_t *curr)
|
|
{
|
|
if ((*prev = _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", *prev)) == std::string::npos)
|
|
throw std::invalid_argument("bad config file arguments");
|
|
}
|
|
|
|
|
|
// no longer returning an int
|
|
// fuck no we have to return an int...
|
|
// ok keep FAILED as being -1
|
|
// i mean we could send a pointer to value_end and then ret void, but why
|
|
// bother chaning it now...
|
|
int ConfigParser::_check_for_semicolon(std::string line)
|
|
{
|
|
// yea ok i just don't like this...
|
|
|
|
// line must be end with semicolon
|
|
size_t semicol;
|
|
size_t find;
|
|
|
|
semicol = line.find_first_of(";");
|
|
if (semicol == std::string::npos)
|
|
return FAILED;
|
|
find = line.find_first_not_of(" \t\n", semicol + 1, line.length() - semicol - 1);
|
|
if (find != std::string::npos)
|
|
return FAILED;
|
|
find = line.find_last_not_of(" \t", semicol - 1);
|
|
return find;
|
|
}
|
|
|
|
|
|
void ConfigParser::_print_content() const
|
|
{
|
|
std::cout << _content;
|
|
}
|
|
|
|
|
|
|
|
|
|
// I might need to make my own Exceptions to throw...
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|