From df2abe6604432a82a39e2369fbbab2bf607e9f9b Mon Sep 17 00:00:00 2001 From: 3lswear Date: Fri, 31 Dec 2021 19:09:34 +0300 Subject: [PATCH 01/32] config start --- config/example.toml | 9 +++++++++ src/config/parse.cpp | 9 +++++++++ 2 files changed, 18 insertions(+) create mode 100644 config/example.toml create mode 100644 src/config/parse.cpp diff --git a/config/example.toml b/config/example.toml new file mode 100644 index 0000000..779f903 --- /dev/null +++ b/config/example.toml @@ -0,0 +1,9 @@ +[[server]] + name = "jopaserver" + port = 8080 + host = "127.0.0.1" + error_page = "error.html" + body_size_limit = 10 + [[location]] + location = "/" + root = "/var/www/html/jopa.html" diff --git a/src/config/parse.cpp b/src/config/parse.cpp new file mode 100644 index 0000000..39a8abe --- /dev/null +++ b/src/config/parse.cpp @@ -0,0 +1,9 @@ +#include "webserv.hpp" +#include + +namespace config +{ + void parse( +} + + From e1c414b5557b58009cae374584a08d2a31b1676b Mon Sep 17 00:00:00 2001 From: 3lswear Date: Sun, 2 Jan 2022 03:52:52 +0300 Subject: [PATCH 02/32] changes --- config/example.toml | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/config/example.toml b/config/example.toml index 779f903..4bbe5af 100644 --- a/config/example.toml +++ b/config/example.toml @@ -7,3 +7,13 @@ [[location]] location = "/" root = "/var/www/html/jopa.html" + methods = ["GET", "POST"] + directory_list = true + directory_fallback = "its_a_directory.html" + [[location]] + location = "/secret/" + root = "/var/www/html/secret.html" + methods = ["GET"] + directory_list = false + directory_fallback = "oops.html" + From 013e3c1ddb3e827afb54d6747f42839fe9d2df4c Mon Sep 17 00:00:00 2001 From: 3lswear Date: Tue, 4 Jan 2022 14:48:28 +0300 Subject: [PATCH 03/32] intermid commit --- src/config/TOMLNode.hpp | 66 +++++++++++++++++ src/config/TOMLParser.hpp | 93 ++++++++++++++++++++++++ src/config/Tokenizer.hpp | 145 +++++++++++++++++++++++++++++++++++++ src/config/parse.cpp | 21 +++++- src/config/parse_types.cpp | 6 ++ 5 files changed, 330 insertions(+), 1 deletion(-) create mode 100644 src/config/TOMLNode.hpp create mode 100644 src/config/TOMLParser.hpp create mode 100644 src/config/Tokenizer.hpp create mode 100644 src/config/parse_types.cpp diff --git a/src/config/TOMLNode.hpp b/src/config/TOMLNode.hpp new file mode 100644 index 0000000..ad644c2 --- /dev/null +++ b/src/config/TOMLNode.hpp @@ -0,0 +1,66 @@ +#include "webserv.hpp" +#include +#include +#include +#include +#include +#include + + +class toml_node; + +/* typedef std::vector TOMLArray; */ +/* typedef std::vector TOMLArrayOfMap; */ +typedef std::map TOMLMap; // = JSONObject +typedef std::vector TOMLMapArray; +typedef std::vector TOMLArray; + + +class toml_node +{ + enum e_type + { + STRING, NUM, BOOL, ARRAY, MAP, MAPARRAY, NIL + } type; + + union u_value + { + std::string *str; + int integer; + bool boolean; + /* std::vector *array; */ + TOMLArray *array; + /* std::map *map; */ + TOMLMap *map; + /* std::vector > *map_array; */ + TOMLMapArray *map_array; + } value; + + public: + void setString(std::string *str) + { + value.str = str; + type = STRING; + } + + void setNumber(int num) + { + value.integer = num; + type = NUM; + } + + void setArr(TOMLArray *toml_array) + { + value.array = toml_array; + type = ARRAY; + } + void setBool(bool b) + { + value.boolean = b; + type = BOOL; + } + void setNil(void) + { + type = NIL; + } +}; diff --git a/src/config/TOMLParser.hpp b/src/config/TOMLParser.hpp new file mode 100644 index 0000000..8f74694 --- /dev/null +++ b/src/config/TOMLParser.hpp @@ -0,0 +1,93 @@ +#include "TOMLNode.hpp" +#include "Tokenizer.hpp" + +namespace config +{ + class TOMLParser + { + private: + std::fstream file; + toml_node *root; //root of TOML tree + toml_node *current; //node currently being parsed + Tokenizer tokenizer; + + public: + TOMLParser(const std::string filename) : tokenizer(filename) {} + void parse(void); + + toml_node *parseObject(void); + toml_node *parseString(void); + toml_node *parseNumber(void); + toml_node *parseArray(void); + toml_node *parseBool(void); + toml_node *parseNil(void); + }; + + void TOMLParser::parse(void) + { + std::string key; + key = ""; + + while (tokenizer.hasMoreTokens()) + { + s_token token; + try + { + token = tokenizer.getToken(); + std::cout << token.to_string() << std::endl; + switch (token.type) + { + case ARR_OPEN: + { + toml_node *parsedObject = parseObject(); + /* parsedObject->printNode(0); */ + if (!root) + root = parsedObject; + } + break; + case NUMBER: + { + tokenizer.rollBackToken(); + toml_node *parsedNumber = parseNumber(); + if (!root) + root = parsedNumber; + } + case STRING: + { + tokenizer.rollBackToken(); + toml_node *parsedString = parseString(); + if (!root) + root = parsedString; + } + case BOOL: + { + tokenizer.rollBackToken(); + toml_node *parsedBool = parseBool(); + if (!root) + root = parsedBool; + } + default: + { + throw std::logic_error("JOPA :("); + } + } + } + catch (std::logic_error err) + { + break; + } + } + } + + toml_node *TOMLParser::parseString(void) + { + toml_node *node; + std::string *sValue; + + std::cout << "Parsing string" << std::endl; + s_token token = tokenizer.getToken(); + sValue = new std::string(token.value); + node->setString(sValue); + + } +} diff --git a/src/config/Tokenizer.hpp b/src/config/Tokenizer.hpp new file mode 100644 index 0000000..d467ad7 --- /dev/null +++ b/src/config/Tokenizer.hpp @@ -0,0 +1,145 @@ +#include "webserv.hpp" +#include +#include +#include +#include +#include +#include + + +namespace config +{ + enum e_token + { + ASSIGN, + STRING, + NUMBER, + COMMA, + BOOL, + NIL, + ARR_OPEN, + ARR_CLOSE, + MAP_OPEN, + MAP_CLOSE, + MAPARRAY_OPEN, + MAPARRAY_CLOSE + }; + + struct s_token + { + std::string value; + e_token type; + std::string to_string(void); + }; + + class Tokenizer + { + private: + std::fstream file; + size_t prev_pos; + public: + Tokenizer(std::string filename); + char getWithoutWhiteSpace(); + struct s_token getToken(); + void *hasMoreTokens(); + void rollBackToken(); + }; + + char Tokenizer::getWithoutWhiteSpace(void) + { + char c = ' '; + while ((c == ' ' || c == '\n')) + { + file.get(c); + if ((c == ' ' || c == '\n') && !file.good()) + { + throw std::logic_error("No more tokens!"); + } + else if (!file.good()) + return (c); + } + return (c); + } + + void Tokenizer::rollBackToken(void) + { + if (file.eof()) + file.clear(); + file.seekg(prev_pos); + } + + struct s_token Tokenizer::getToken(void) + { + char c; + struct s_token token; + + if (file.eof()) + { + std::cout << "Tokens exhausted" << std::endl; + } + prev_pos = file.tellg(); + c = getWithoutWhiteSpace(); + + if (c == '"') + { + token.type = STRING; + token.value = ""; + /* TODO: maybe do-while? */ + file.get(c); + while (c != '"') + { + token.value += c; + file.get(c); + } + } + else if (c == '[') + token.type = ARR_OPEN; + else if (c == ']') + token.type = ARR_CLOSE; + else if (c == '=') + token.type = ASSIGN; + else if (c == '-' || isdigit(c)) + { + std::streampos prevCharPos; + token.type = NUMBER; + token.value = ""; + token.value += c; + /* prevCharPos = file.tellg(); */ + while (c == '-' || c == '.' || isdigit(c)) + { + prevCharPos = file.tellg(); + file.get(c); + if (file.eof()) + break; + else + { + if (c == '-' || c == '.' || isdigit(c)) + token.value += c; + else + file.seekg(prevCharPos); + + } + } + } + else if (c == 'f') + { + token.type = BOOL; + token.value = "false"; + file.seekg(4, std::ios_base::cur); + } + else if (c == 't') + { + token.type = BOOL; + token.value = "true"; + file.seekg(3, std::ios_base::cur); + } + else if (c == 'n') + { + token.type = NIL; + file.seekg(3, std::ios_base::cur); + } + else if (c == ',') + token.type = COMMA; + return (token); + } +} diff --git a/src/config/parse.cpp b/src/config/parse.cpp index 39a8abe..ea94994 100644 --- a/src/config/parse.cpp +++ b/src/config/parse.cpp @@ -1,9 +1,28 @@ #include "webserv.hpp" +#include +#include +#include +#include #include +#include + +#include "TOMLNode.cpp" +#include "TOMLParser.cpp" + +/* struct location */ +/* { */ +/* std::string location; */ +/* std::string root; */ + +/* } */ + +/* class config */ +/* { */ +/* std::string name; */ +/* } */ namespace config { - void parse( } diff --git a/src/config/parse_types.cpp b/src/config/parse_types.cpp new file mode 100644 index 0000000..a2a398d --- /dev/null +++ b/src/config/parse_types.cpp @@ -0,0 +1,6 @@ +#include "webserv.hpp" +#include "parse.cpp" + +namespace config +{ +} From 4cc8dfeacecc303800700c61daf6b443d52b2b43 Mon Sep 17 00:00:00 2001 From: 3lswear Date: Tue, 4 Jan 2022 18:29:46 +0300 Subject: [PATCH 04/32] build: add files --- Makefile | 2 ++ 1 file changed, 2 insertions(+) diff --git a/Makefile b/Makefile index 0c7df57..24cb7ea 100644 --- a/Makefile +++ b/Makefile @@ -8,8 +8,10 @@ SANFLAGS = -fsanitize=address CXXFLAGS = -Wall -Wextra -Werror -g -std=c++98 $(SANFLAGS) SRC = $(wildcard ./src/*.cpp) +SRC += $(wildcard ./src/*/*.cpp) HEADERS = $(wildcard ./includes/*.hpp) +HEADERS += $(wildcard src/config/*.hpp) INCLUDES = ./includes/ From 4aec6d46578f95a5826294019679ae0c0fd9a202 Mon Sep 17 00:00:00 2001 From: 3lswear Date: Tue, 4 Jan 2022 18:31:10 +0300 Subject: [PATCH 05/32] changes... --- includes/webserv.hpp | 15 +++ src/config/TOMLNode.hpp | 25 +++-- src/config/TOMLParser.hpp | 203 +++++++++++++++++++++++++++++++++---- src/config/Tokenizer.hpp | 24 ++++- src/config/parse.cpp | 20 +++- src/config/parse_types.cpp | 6 -- 6 files changed, 248 insertions(+), 45 deletions(-) delete mode 100644 src/config/parse_types.cpp diff --git a/includes/webserv.hpp b/includes/webserv.hpp index e1e0a8f..49d3faf 100644 --- a/includes/webserv.hpp +++ b/includes/webserv.hpp @@ -16,4 +16,19 @@ #include #include +#include +#include + +void parse(void); + +class toml_node; + +/* typedef std::vector TOMLArray; */ +/* typedef std::vector TOMLArrayOfMap; */ +typedef std::map TOMLMap; // = JSONObject +typedef std::vector TOMLMapArray; +typedef std::vector TOMLArray; + +void display(TOMLMap *config); + #endif diff --git a/src/config/TOMLNode.hpp b/src/config/TOMLNode.hpp index ad644c2..52e04e7 100644 --- a/src/config/TOMLNode.hpp +++ b/src/config/TOMLNode.hpp @@ -1,3 +1,6 @@ +#ifndef TOMLNODE_HPP +#define TOMLNODE_HPP + #include "webserv.hpp" #include #include @@ -7,13 +10,6 @@ #include -class toml_node; - -/* typedef std::vector TOMLArray; */ -/* typedef std::vector TOMLArrayOfMap; */ -typedef std::map TOMLMap; // = JSONObject -typedef std::vector TOMLMapArray; -typedef std::vector TOMLArray; class toml_node @@ -21,7 +17,7 @@ class toml_node enum e_type { STRING, NUM, BOOL, ARRAY, MAP, MAPARRAY, NIL - } type; + } type; union u_value { @@ -34,9 +30,13 @@ class toml_node TOMLMap *map; /* std::vector > *map_array; */ TOMLMapArray *map_array; - } value; + } value; public: + TOMLMap *getMap(void) + { + return (value.map); + } void setString(std::string *str) { value.str = str; @@ -63,4 +63,11 @@ class toml_node { type = NIL; } + void setObject(TOMLMap *obj) + { + value.map = obj; + type = MAP; + } }; + +#endif diff --git a/src/config/TOMLParser.hpp b/src/config/TOMLParser.hpp index 8f74694..b1f8efa 100644 --- a/src/config/TOMLParser.hpp +++ b/src/config/TOMLParser.hpp @@ -1,5 +1,9 @@ +#ifndef TOMLPARSER_HPP +#define TOMLPARSER_HPP + #include "TOMLNode.hpp" #include "Tokenizer.hpp" +#include namespace config { @@ -8,22 +12,184 @@ namespace config private: std::fstream file; toml_node *root; //root of TOML tree - toml_node *current; //node currently being parsed + /* toml_node *current; //node currently being parsed */ Tokenizer tokenizer; public: TOMLParser(const std::string filename) : tokenizer(filename) {} - void parse(void); + toml_node *parse(void); - toml_node *parseObject(void); - toml_node *parseString(void); - toml_node *parseNumber(void); - toml_node *parseArray(void); - toml_node *parseBool(void); - toml_node *parseNil(void); + toml_node *parseObject(void) + { + std::cout << "Parsing object" << std::endl; + toml_node *node = new toml_node; + TOMLMap *mapObject = new TOMLMap; + bool completed = false; + while (!completed) + { + if (tokenizer.hasMoreTokens()) + { + s_token nextToken = tokenizer.getToken(); + std::string key = nextToken.value; + std::cout << key << std::endl; + tokenizer.getToken(); + nextToken = tokenizer.getToken(); + switch (nextToken.type) + { + case STRING: + { + tokenizer.rollBackToken(); + (*mapObject)[key] = parseString(); + break; + } + case ARR_OPEN: + { + (*mapObject)[key] = parseArray(); + break; + } + case NUMBER: + { + (*mapObject)[key] = parseNumber(); + break; + } + case BOOL: + { + (*mapObject)[key] = parseBool(); + break; + } + default: + { + /* throw std::logic_error("jopa in parseObject"); */ + std::cerr << "Unknown token, marking as complete" << std::endl; + completed = true; + break; + } + } + } + else + { + throw std::logic_error("parseObject: no more tokens"); + } + } + node->setObject(mapObject); + return (node); + } + + toml_node *parseString(void) + { + /* toml_node *node; */ + toml_node *node = new toml_node; + std::string *sValue; + + std::cout << "Parsing string" << std::endl; + s_token token = tokenizer.getToken(); + sValue = new std::string(token.value); + node->setString(sValue); + + return (node); + } + + toml_node *parseNumber(void) + { + toml_node *node = new toml_node; + int value; + + std::cout << "Parsing number" << std::endl; + s_token token = tokenizer.getToken(); + value = std::atoi(token.value.c_str()); + node->setNumber(value); + + return (node); + } + + toml_node *parseArray(void) + { + std::cout << "Parsing array" << std::endl; + toml_node *node = new toml_node; + TOMLArray *array = new TOMLArray; + bool completed = false; + + while (!completed) + { + if (tokenizer.hasMoreTokens()) + { + throw std::logic_error("No more tokens"); + } + else + { + s_token nextToken = tokenizer.getToken(); + switch (nextToken.type) + { + case ARR_OPEN: + { + node = parseArray(); + break; + } + case STRING: + { + tokenizer.rollBackToken(); + node = parseString(); + break; + } + case NUMBER: + { + tokenizer.rollBackToken(); + node = parseNumber(); + break; + } + case BOOL: + { + tokenizer.rollBackToken(); + node = parseBool(); + break; + } + case NIL: + { + node = parseNil(); + break; + } + default: + { + throw std::logic_error("unkown token in parseList"); + } + + } + array->push_back(node); + nextToken = tokenizer.getToken(); + if (nextToken.type == ARR_CLOSE) + completed = true; + } + } + node->setArr(array); + return (node); + } + + toml_node *parseBool(void) + { + toml_node *node = new toml_node; + bool value; + + std::cerr << "Parsing bool" << std::endl; + s_token token = tokenizer.getToken(); + if (token.value == "true") + value = true; + else + value = false; + node->setBool(value); + + return (node); + } + + toml_node *parseNil(void) + { + toml_node *node = new toml_node; + std::cerr << "Parsing NIL" << std::endl; + node->setNil(); + return (node); + } }; - void TOMLParser::parse(void) + toml_node *TOMLParser::parse(void) { std::string key; key = ""; @@ -34,7 +200,7 @@ namespace config try { token = tokenizer.getToken(); - std::cout << token.to_string() << std::endl; + /* std::cout << token.to_string() << std::endl; */ switch (token.type) { case ARR_OPEN: @@ -52,6 +218,7 @@ namespace config if (!root) root = parsedNumber; } + break; case STRING: { tokenizer.rollBackToken(); @@ -59,6 +226,7 @@ namespace config if (!root) root = parsedString; } + break; case BOOL: { tokenizer.rollBackToken(); @@ -66,6 +234,7 @@ namespace config if (!root) root = parsedBool; } + break; default: { throw std::logic_error("JOPA :("); @@ -77,17 +246,7 @@ namespace config break; } } - } - - toml_node *TOMLParser::parseString(void) - { - toml_node *node; - std::string *sValue; - - std::cout << "Parsing string" << std::endl; - s_token token = tokenizer.getToken(); - sValue = new std::string(token.value); - node->setString(sValue); - + return (root); } } +#endif diff --git a/src/config/Tokenizer.hpp b/src/config/Tokenizer.hpp index d467ad7..c2f21c5 100644 --- a/src/config/Tokenizer.hpp +++ b/src/config/Tokenizer.hpp @@ -1,3 +1,6 @@ +#ifndef TOKENIZER_HPP +#define TOKENIZER_HPP + #include "webserv.hpp" #include #include @@ -6,7 +9,6 @@ #include #include - namespace config { enum e_token @@ -29,7 +31,7 @@ namespace config { std::string value; e_token type; - std::string to_string(void); + /* std::string to_string(void); */ }; class Tokenizer @@ -38,10 +40,17 @@ namespace config std::fstream file; size_t prev_pos; public: - Tokenizer(std::string filename); + Tokenizer(std::string filename) + { + file.open(filename.c_str(), std::ios::in); + if (!file.good()) + { + std::cerr << "file didn't open" << std::endl; + } + } char getWithoutWhiteSpace(); struct s_token getToken(); - void *hasMoreTokens(); + bool hasMoreTokens(); void rollBackToken(); }; @@ -61,6 +70,11 @@ namespace config return (c); } + bool Tokenizer::hasMoreTokens(void) + { + return (!file.eof()); + } + void Tokenizer::rollBackToken(void) { if (file.eof()) @@ -143,3 +157,5 @@ namespace config return (token); } } + +#endif diff --git a/src/config/parse.cpp b/src/config/parse.cpp index ea94994..7fece02 100644 --- a/src/config/parse.cpp +++ b/src/config/parse.cpp @@ -6,8 +6,9 @@ #include #include -#include "TOMLNode.cpp" -#include "TOMLParser.cpp" +#include "TOMLNode.hpp" +#include "TOMLParser.hpp" +#include "Tokenizer.hpp" /* struct location */ /* { */ @@ -20,9 +21,20 @@ /* { */ /* std::string name; */ /* } */ - namespace config { + void display(TOMLMap *config) + { + std::cout << "printing config:" << std::endl; + std::cout << (*config)["name"] << std::endl; + std::cout << (*config)["port"] << std::endl; + } } - +void parse(void) +{ + std::string filename = "config/simple.toml"; + config::TOMLParser parser(filename); + toml_node *root = parser.parse(); + config::display(root->getMap()); +} diff --git a/src/config/parse_types.cpp b/src/config/parse_types.cpp deleted file mode 100644 index a2a398d..0000000 --- a/src/config/parse_types.cpp +++ /dev/null @@ -1,6 +0,0 @@ -#include "webserv.hpp" -#include "parse.cpp" - -namespace config -{ -} From 542252489c1abd0e89bbb649ec13e10756f036df Mon Sep 17 00:00:00 2001 From: 3lswear Date: Fri, 7 Jan 2022 01:02:23 +0300 Subject: [PATCH 06/32] build: run with no leaks --- Makefile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Makefile b/Makefile index 24cb7ea..f659bb5 100644 --- a/Makefile +++ b/Makefile @@ -36,6 +36,6 @@ re: $(MAKE) all run: $(NAME) - ./$(NAME) + ASAN_OPTIONS=detect_leaks=0 ./$(NAME) .PHONY: all clean fclean re From acac336b2115df4d61358703f2a224bdb70f1279 Mon Sep 17 00:00:00 2001 From: 3lswear Date: Fri, 7 Jan 2022 01:41:21 +0300 Subject: [PATCH 07/32] fix: array --- includes/webserv.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/includes/webserv.hpp b/includes/webserv.hpp index 49d3faf..926a93e 100644 --- a/includes/webserv.hpp +++ b/includes/webserv.hpp @@ -26,7 +26,7 @@ class toml_node; /* typedef std::vector TOMLArray; */ /* typedef std::vector TOMLArrayOfMap; */ typedef std::map TOMLMap; // = JSONObject -typedef std::vector TOMLMapArray; +typedef std::vector TOMLMapArray; typedef std::vector TOMLArray; void display(TOMLMap *config); From 5639d545199cab9788d08311cfb6a8d0d9afc3fa Mon Sep 17 00:00:00 2001 From: 3lswear Date: Fri, 7 Jan 2022 01:42:51 +0300 Subject: [PATCH 08/32] feat: first working simple version --- config/simple.toml | 2 + src/config/TOMLNode.hpp | 28 ++++++++++ src/config/TOMLParser.hpp | 105 +++++++++++++++++++++++++------------- src/config/Tokenizer.hpp | 47 +++++++++++++++-- src/config/parse.cpp | 4 +- src/main.cpp | 7 +-- 6 files changed, 149 insertions(+), 44 deletions(-) create mode 100644 config/simple.toml diff --git a/config/simple.toml b/config/simple.toml new file mode 100644 index 0000000..0f96880 --- /dev/null +++ b/config/simple.toml @@ -0,0 +1,2 @@ +name = "jopa" +port = 6969 diff --git a/src/config/TOMLNode.hpp b/src/config/TOMLNode.hpp index 52e04e7..0273ac7 100644 --- a/src/config/TOMLNode.hpp +++ b/src/config/TOMLNode.hpp @@ -8,6 +8,8 @@ #include #include #include +#include +#include @@ -33,6 +35,12 @@ class toml_node } value; public: + + enum e_type get_type(void) + { + return (type); + } + TOMLMap *getMap(void) { return (value.map); @@ -68,6 +76,26 @@ class toml_node value.map = obj; type = MAP; } + std::string *toString(void) const + { + switch (type) + { + case STRING: + { + return (value.str); + } + case NUM: + { + std::stringstream ss; + ss << value.integer; + std::string *result = new std::string(); + ss >> *result; + return (result); + } + default: + return ( new std::string("Not implemented :)")); + } + } }; #endif diff --git a/src/config/TOMLParser.hpp b/src/config/TOMLParser.hpp index b1f8efa..1c52704 100644 --- a/src/config/TOMLParser.hpp +++ b/src/config/TOMLParser.hpp @@ -19,7 +19,7 @@ namespace config TOMLParser(const std::string filename) : tokenizer(filename) {} toml_node *parse(void); - toml_node *parseObject(void) + toml_node *parseMap(void) { std::cout << "Parsing object" << std::endl; toml_node *node = new toml_node; @@ -29,10 +29,20 @@ namespace config { if (tokenizer.hasMoreTokens()) { - s_token nextToken = tokenizer.getToken(); + s_token nextToken; + try + { + nextToken = tokenizer.getToken(); + } + catch (std::logic_error e) + { + std::cerr << e.what() << std::endl; + break; + } std::string key = nextToken.value; std::cout << key << std::endl; - tokenizer.getToken(); + if (tokenizer.getToken().type != ASSIGN) + throw std::logic_error("EXPECTED assign!"); nextToken = tokenizer.getToken(); switch (nextToken.type) { @@ -49,6 +59,7 @@ namespace config } case NUMBER: { + tokenizer.rollBackToken(); (*mapObject)[key] = parseNumber(); break; } @@ -59,16 +70,28 @@ namespace config } default: { - /* throw std::logic_error("jopa in parseObject"); */ + /* throw std::logic_error("jopa in parseMap"); */ std::cerr << "Unknown token, marking as complete" << std::endl; completed = true; break; } } + if (tokenizer.hasMoreTokens()) + nextToken = tokenizer.getToken(); + else + break; + if (nextToken.type != NEWLINE) + { + throw std::logic_error("EXPECTED newline"); + } + /* if (tokenizer.getToken().type == NEWLINE) */ + /* completed = true; */ + /* else */ + /* throw std::logic_error("EXPECTED newline"); */ } else { - throw std::logic_error("parseObject: no more tokens"); + throw std::logic_error("parseMap: no more tokens"); } } node->setObject(mapObject); @@ -194,6 +217,9 @@ namespace config std::string key; key = ""; + root = parseMap(); + return (root); + while (tokenizer.hasMoreTokens()) { s_token token; @@ -203,42 +229,49 @@ namespace config /* std::cout << token.to_string() << std::endl; */ switch (token.type) { + case KEY: + { + toml_node *parsedObject = parseString(); + if (!root) + root = parsedObject; + } + case ARR_OPEN: - { - toml_node *parsedObject = parseObject(); - /* parsedObject->printNode(0); */ - if (!root) - root = parsedObject; - } - break; + { + toml_node *parsedObject = parseMap(); + /* parsedObject->printNode(0); */ + if (!root) + root = parsedObject; + } + break; case NUMBER: - { - tokenizer.rollBackToken(); - toml_node *parsedNumber = parseNumber(); - if (!root) - root = parsedNumber; - } - break; + { + tokenizer.rollBackToken(); + toml_node *parsedNumber = parseNumber(); + if (!root) + root = parsedNumber; + } + break; case STRING: - { - tokenizer.rollBackToken(); - toml_node *parsedString = parseString(); - if (!root) - root = parsedString; - } - break; + { + tokenizer.rollBackToken(); + toml_node *parsedString = parseString(); + if (!root) + root = parsedString; + } + break; case BOOL: - { - tokenizer.rollBackToken(); - toml_node *parsedBool = parseBool(); - if (!root) - root = parsedBool; - } - break; + { + tokenizer.rollBackToken(); + toml_node *parsedBool = parseBool(); + if (!root) + root = parsedBool; + } + break; default: - { - throw std::logic_error("JOPA :("); - } + { + throw std::logic_error("JOPA :("); + } } } catch (std::logic_error err) diff --git a/src/config/Tokenizer.hpp b/src/config/Tokenizer.hpp index c2f21c5..76acd5e 100644 --- a/src/config/Tokenizer.hpp +++ b/src/config/Tokenizer.hpp @@ -13,6 +13,8 @@ namespace config { enum e_token { + KEY, + NEWLINE, ASSIGN, STRING, NUMBER, @@ -34,11 +36,20 @@ namespace config /* std::string to_string(void); */ }; + bool istomlkey(char c) + { + if (isalnum(c) || c == '-' || c == '_') + return (true); + else + return (false); + } + class Tokenizer { private: std::fstream file; size_t prev_pos; + e_token last_token; public: Tokenizer(std::string filename) { @@ -51,16 +62,24 @@ namespace config char getWithoutWhiteSpace(); struct s_token getToken(); bool hasMoreTokens(); + bool firstToken() + { + // doesn't account for indent! + if (file.tellg() == 0 || file.tellg() == 1 || (last_token == NEWLINE)) + return (true); + else + return (false); + } void rollBackToken(); }; char Tokenizer::getWithoutWhiteSpace(void) { char c = ' '; - while ((c == ' ' || c == '\n')) + while (c == ' ') { file.get(c); - if ((c == ' ' || c == '\n') && !file.good()) + if ((c == ' ') && !file.good()) { throw std::logic_error("No more tokens!"); } @@ -82,6 +101,16 @@ namespace config file.seekg(prev_pos); } + /* struct s_token Tokenizer::getKey(void) */ + /* { */ + /* char c; */ + /* struct s_token token; */ + /* if (file.eof()) */ + /* { */ + /* std::cout << "Tokens exhausted" << std::endl; */ + /* } */ + /* } */ + struct s_token Tokenizer::getToken(void) { char c; @@ -94,7 +123,16 @@ namespace config prev_pos = file.tellg(); c = getWithoutWhiteSpace(); - if (c == '"') + if (firstToken() && config::istomlkey(c)) + { + token.type = KEY; + while (config::istomlkey(c)) + { + token.value += c; + file.get(c); + } + } + else if (c == '"') { token.type = STRING; token.value = ""; @@ -112,6 +150,8 @@ namespace config token.type = ARR_CLOSE; else if (c == '=') token.type = ASSIGN; + else if (c == '\n') + token.type = NEWLINE; else if (c == '-' || isdigit(c)) { std::streampos prevCharPos; @@ -154,6 +194,7 @@ namespace config } else if (c == ',') token.type = COMMA; + last_token = token.type; return (token); } } diff --git a/src/config/parse.cpp b/src/config/parse.cpp index 7fece02..bd63071 100644 --- a/src/config/parse.cpp +++ b/src/config/parse.cpp @@ -26,8 +26,8 @@ namespace config void display(TOMLMap *config) { std::cout << "printing config:" << std::endl; - std::cout << (*config)["name"] << std::endl; - std::cout << (*config)["port"] << std::endl; + std::cout << "name: " << *(*config)["name"]->toString() << std::endl; + std::cout << "port: " << *(*config)["port"]->toString() << std::endl; } } diff --git a/src/main.cpp b/src/main.cpp index 2504e23..1e42069 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -7,9 +7,10 @@ int main(int argc, char **argv) Server server; - server.readConfig(); - server.setupConfig(); - server.start(); + /* server.readConfig(); */ + /* server.setupConfig(); */ + /* server.start(); */ + parse(); return (0); } From c8ad9407eb4493c068531ba3523de332b38ec128 Mon Sep 17 00:00:00 2001 From: 3lswear Date: Fri, 7 Jan 2022 01:43:08 +0300 Subject: [PATCH 09/32] feat: add new values --- config/example.toml | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/config/example.toml b/config/example.toml index 4bbe5af..f148367 100644 --- a/config/example.toml +++ b/config/example.toml @@ -1,19 +1,22 @@ [[server]] name = "jopaserver" - port = 8080 host = "127.0.0.1" + port = 8080 error_page = "error.html" body_size_limit = 10 [[location]] location = "/" + # redirection ??? root = "/var/www/html/jopa.html" methods = ["GET", "POST"] directory_list = true directory_fallback = "its_a_directory.html" + upload_accept = true + upload_dir = "/var/www/html/upload" + [[location]] location = "/secret/" root = "/var/www/html/secret.html" methods = ["GET"] directory_list = false directory_fallback = "oops.html" - From 6710c8450e55e7c66e590c4eff460e19396ac968 Mon Sep 17 00:00:00 2001 From: 3lswear Date: Fri, 7 Jan 2022 01:58:08 +0300 Subject: [PATCH 10/32] feat: display parsed file --- src/config/parse.cpp | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/src/config/parse.cpp b/src/config/parse.cpp index bd63071..8bb8666 100644 --- a/src/config/parse.cpp +++ b/src/config/parse.cpp @@ -26,8 +26,16 @@ namespace config void display(TOMLMap *config) { std::cout << "printing config:" << std::endl; - std::cout << "name: " << *(*config)["name"]->toString() << std::endl; - std::cout << "port: " << *(*config)["port"]->toString() << std::endl; + + TOMLMap::iterator it; + for (it = config->begin(); it != config->end(); ++it) + { + std::cout << it->first + << ": " + << *(it->second->toString()) + << std::endl; + } + } } From ceb192604006c85bc069653152b8b879396a1e94 Mon Sep 17 00:00:00 2001 From: 3lswear Date: Sat, 8 Jan 2022 00:04:06 +0300 Subject: [PATCH 11/32] feat: add toString for array --- src/config/TOMLNode.hpp | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/src/config/TOMLNode.hpp b/src/config/TOMLNode.hpp index 0273ac7..2d976cb 100644 --- a/src/config/TOMLNode.hpp +++ b/src/config/TOMLNode.hpp @@ -92,6 +92,18 @@ class toml_node ss >> *result; return (result); } + case ARRAY: + { + TOMLArray::iterator it; + std::string *result = new std::string("[ "); + for (it = value.array->begin(); it != value.array->end(); ++it) + { + *result += *((*it)->toString()); + *result += ", "; + } + *result += " ]"; + return (result); + } default: return ( new std::string("Not implemented :)")); } From 0770efd11429e8f37cb841c9b7e0a05a3ff3f785 Mon Sep 17 00:00:00 2001 From: 3lswear Date: Sat, 8 Jan 2022 00:04:42 +0300 Subject: [PATCH 12/32] fix: parseArray --- src/config/TOMLParser.hpp | 41 ++++++++++++++++++++------------------- 1 file changed, 21 insertions(+), 20 deletions(-) diff --git a/src/config/TOMLParser.hpp b/src/config/TOMLParser.hpp index 1c52704..ed632f3 100644 --- a/src/config/TOMLParser.hpp +++ b/src/config/TOMLParser.hpp @@ -21,7 +21,7 @@ namespace config toml_node *parseMap(void) { - std::cout << "Parsing object" << std::endl; + std::cerr << "Parsing object" << std::endl; toml_node *node = new toml_node; TOMLMap *mapObject = new TOMLMap; bool completed = false; @@ -30,17 +30,14 @@ namespace config if (tokenizer.hasMoreTokens()) { s_token nextToken; - try - { - nextToken = tokenizer.getToken(); - } + try { nextToken = tokenizer.getToken(); } catch (std::logic_error e) { std::cerr << e.what() << std::endl; break; } std::string key = nextToken.value; - std::cout << key << std::endl; + std::cerr << key << std::endl; if (tokenizer.getToken().type != ASSIGN) throw std::logic_error("EXPECTED assign!"); nextToken = tokenizer.getToken(); @@ -104,7 +101,7 @@ namespace config toml_node *node = new toml_node; std::string *sValue; - std::cout << "Parsing string" << std::endl; + std::cerr << "Parsing string" << std::endl; s_token token = tokenizer.getToken(); sValue = new std::string(token.value); node->setString(sValue); @@ -117,7 +114,7 @@ namespace config toml_node *node = new toml_node; int value; - std::cout << "Parsing number" << std::endl; + std::cerr << "Parsing number" << std::endl; s_token token = tokenizer.getToken(); value = std::atoi(token.value.c_str()); node->setNumber(value); @@ -127,21 +124,21 @@ namespace config toml_node *parseArray(void) { - std::cout << "Parsing array" << std::endl; - toml_node *node = new toml_node; + std::cerr << "Parsing array" << std::endl; + toml_node *node; + toml_node *result = new toml_node; TOMLArray *array = new TOMLArray; bool completed = false; + s_token current; while (!completed) { - if (tokenizer.hasMoreTokens()) - { + if (!tokenizer.hasMoreTokens()) throw std::logic_error("No more tokens"); - } else { - s_token nextToken = tokenizer.getToken(); - switch (nextToken.type) + current = tokenizer.getToken(); + switch (current.type) { case ARR_OPEN: { @@ -173,18 +170,22 @@ namespace config } default: { - throw std::logic_error("unkown token in parseList"); + throw std::logic_error("unkown token in parseArray"); } } array->push_back(node); - nextToken = tokenizer.getToken(); - if (nextToken.type == ARR_CLOSE) + current = tokenizer.getToken(); + if (current.type == COMMA) + continue; + else if (current.type == ARR_CLOSE) completed = true; + else + throw std::invalid_argument("Unexpected token in array!"); } } - node->setArr(array); - return (node); + result->setArr(array); + return (result); } toml_node *parseBool(void) From 26596a78ede435d0edda6e537848866a444da3fc Mon Sep 17 00:00:00 2001 From: 3lswear Date: Sat, 8 Jan 2022 00:05:08 +0300 Subject: [PATCH 13/32] style.. --- src/config/parse.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/config/parse.cpp b/src/config/parse.cpp index 8bb8666..420e774 100644 --- a/src/config/parse.cpp +++ b/src/config/parse.cpp @@ -25,7 +25,7 @@ namespace config { void display(TOMLMap *config) { - std::cout << "printing config:" << std::endl; + std::cout << ">>> printing config: <<<" << std::endl; TOMLMap::iterator it; for (it = config->begin(); it != config->end(); ++it) From 9f3b12c9868888fdaf4c21594b130be4b6dfac00 Mon Sep 17 00:00:00 2001 From: 3lswear Date: Wed, 12 Jan 2022 12:38:52 +0300 Subject: [PATCH 14/32] more fields --- config/simple.toml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/config/simple.toml b/config/simple.toml index 0f96880..a464a76 100644 --- a/config/simple.toml +++ b/config/simple.toml @@ -1,2 +1,4 @@ name = "jopa" port = 6969 +ip = "127.0.0.1" +methods = ["GET", "POST", 1, "piska", false, false] From 4c4873a25c51f0dc90d51abe67a3b59dbf39b7c5 Mon Sep 17 00:00:00 2001 From: 3lswear Date: Wed, 12 Jan 2022 12:39:16 +0300 Subject: [PATCH 15/32] add Bool case --- src/config/TOMLNode.hpp | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/src/config/TOMLNode.hpp b/src/config/TOMLNode.hpp index 2d976cb..f265d31 100644 --- a/src/config/TOMLNode.hpp +++ b/src/config/TOMLNode.hpp @@ -104,6 +104,15 @@ class toml_node *result += " ]"; return (result); } + case BOOL: + { + std::string *result; + if (value.boolean) + result = new std::string("true"); + else + result = new std::string("false"); + return (result); + } default: return ( new std::string("Not implemented :)")); } From ac23dc656a7597cac2ed10b4c93bc5f238d3041a Mon Sep 17 00:00:00 2001 From: 3lswear Date: Wed, 12 Jan 2022 12:40:15 +0300 Subject: [PATCH 16/32] some bool changes --- src/config/TOMLParser.hpp | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/config/TOMLParser.hpp b/src/config/TOMLParser.hpp index ed632f3..92ed80a 100644 --- a/src/config/TOMLParser.hpp +++ b/src/config/TOMLParser.hpp @@ -62,6 +62,7 @@ namespace config } case BOOL: { + tokenizer.rollBackToken(); (*mapObject)[key] = parseBool(); break; } @@ -197,8 +198,10 @@ namespace config s_token token = tokenizer.getToken(); if (token.value == "true") value = true; - else + else if (token.value == "false") value = false; + else + throw std::invalid_argument("Unexpected bool value"); node->setBool(value); return (node); From 8010863bdaef5b105e274f99c625da14b904718c Mon Sep 17 00:00:00 2001 From: 3lswear Date: Wed, 12 Jan 2022 12:40:37 +0300 Subject: [PATCH 17/32] bool experiments --- src/config/Tokenizer.hpp | 17 +++++++++++++++-- 1 file changed, 15 insertions(+), 2 deletions(-) diff --git a/src/config/Tokenizer.hpp b/src/config/Tokenizer.hpp index 76acd5e..bae68a0 100644 --- a/src/config/Tokenizer.hpp +++ b/src/config/Tokenizer.hpp @@ -180,12 +180,25 @@ namespace config token.type = BOOL; token.value = "false"; file.seekg(4, std::ios_base::cur); + + /* token.value = ""; */ + /* while (std::isalpha(c)) */ + /* { */ + /* token.value += c; */ + /* file.get(c); */ + /* } */ + std::cerr << "value is: " << token.value << std::endl; + std::cerr << "c is: " << c << std::endl; } else if (c == 't') { token.type = BOOL; - token.value = "true"; - file.seekg(3, std::ios_base::cur); + while (std::isalpha(c)) + { + token.value += c; + file.get(c); + } + /* file.seekg(3, std::ios_base::cur); */ } else if (c == 'n') { From 4deafefc7c3b3ab2ec92fb718672b02ddf37af62 Mon Sep 17 00:00:00 2001 From: 3lswear Date: Wed, 12 Jan 2022 12:48:25 +0300 Subject: [PATCH 18/32] build: add .ccls --- .ccls | 8 ++++++++ 1 file changed, 8 insertions(+) create mode 100644 .ccls diff --git a/.ccls b/.ccls new file mode 100644 index 0000000..a66e36d --- /dev/null +++ b/.ccls @@ -0,0 +1,8 @@ +clang++ +-Iincludes +%cpp +%hpp --include=./includes/webserv.hpp +-Wall +-Wextra +-Werror +-std=c++98 From 7ec6f2d8a28883a4921462a0713974e66cfb2f46 Mon Sep 17 00:00:00 2001 From: 3lswear Date: Wed, 12 Jan 2022 13:31:29 +0300 Subject: [PATCH 19/32] add MAPARRAY token detection --- src/config/Tokenizer.hpp | 35 ++++++++++++++++++++++++++++++++--- 1 file changed, 32 insertions(+), 3 deletions(-) diff --git a/src/config/Tokenizer.hpp b/src/config/Tokenizer.hpp index 76acd5e..6efb75b 100644 --- a/src/config/Tokenizer.hpp +++ b/src/config/Tokenizer.hpp @@ -144,10 +144,39 @@ namespace config file.get(c); } } - else if (c == '[') - token.type = ARR_OPEN; else if (c == ']') - token.type = ARR_CLOSE; + { + std::streampos prev_pos = file.tellg(); + file.get(c); + if (c == ']') + { + token.type = MAPARRAY_CLOSE; + } + else + { + token.type = ARR_CLOSE; + file.seekg(prev_pos); + } + } + else if (c == '[') + { + std::streampos prev_pos = file.tellg(); + file.get(c); + if (c == '[') + { + token.type = MAPARRAY_OPEN; + } + else + { + token.type = ARR_OPEN; + file.seekg(prev_pos); + } + + } + /* else if (c == '[') */ + /* token.type = ARR_OPEN; */ + /* else if (c == ']') */ + /* token.type = ARR_CLOSE; */ else if (c == '=') token.type = ASSIGN; else if (c == '\n') From 9e9620687fcd030c6ecd440d0c488cdf16110a47 Mon Sep 17 00:00:00 2001 From: 3lswear Date: Wed, 12 Jan 2022 20:40:02 +0300 Subject: [PATCH 20/32] track ccls --- .gitignore | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/.gitignore b/.gitignore index 3b39428..770e119 100644 --- a/.gitignore +++ b/.gitignore @@ -1,4 +1,3 @@ webserv *.o -.ccls -.vscode \ No newline at end of file +.vscode From 979ce70a2bc3ad71330d29ce28fd6ac6bf9d138e Mon Sep 17 00:00:00 2001 From: 3lswear Date: Wed, 12 Jan 2022 20:40:39 +0300 Subject: [PATCH 21/32] intermed changes --- src/config/TOMLNode.hpp | 5 +++++ src/config/TOMLParser.hpp | 28 ++++++++++++++++++++++++++++ src/config/Tokenizer.hpp | 35 ++++++++++++++--------------------- 3 files changed, 47 insertions(+), 21 deletions(-) diff --git a/src/config/TOMLNode.hpp b/src/config/TOMLNode.hpp index f265d31..5638b46 100644 --- a/src/config/TOMLNode.hpp +++ b/src/config/TOMLNode.hpp @@ -76,6 +76,11 @@ class toml_node value.map = obj; type = MAP; } + void setMapArray(TOMLMapArray *map_array) + { + value.map_array = map_array; + type = MAPARRAY; + } std::string *toString(void) const { switch (type) diff --git a/src/config/TOMLParser.hpp b/src/config/TOMLParser.hpp index 92ed80a..404d339 100644 --- a/src/config/TOMLParser.hpp +++ b/src/config/TOMLParser.hpp @@ -96,6 +96,30 @@ namespace config return (node); } + toml_node *parseMapArray(void) + { + std::cerr << "Parsing MapArray" << std::endl; + toml_node *node = new toml_node; + TOMLMapArray *servers = new TOMLMapArray; + + while (tokenizer.hasMoreTokens()) + { + s_token current; + try { current = tokenizer.getToken(); } + catch (std::logic_error e) + { + std::cerr << e.what() << std::endl; + break; + } + if (current.type == MAPARRAY_DECL) + servers->push_back(parseMap()->getMap()); + else + throw std::logic_error("unexpected token in parseMapArray"); + } + node->setMapArray(servers); + return (node); + } + toml_node *parseString(void) { /* toml_node *node; */ @@ -272,6 +296,10 @@ namespace config root = parsedBool; } break; + case MAPARRAY_DECL: + { + + } default: { throw std::logic_error("JOPA :("); diff --git a/src/config/Tokenizer.hpp b/src/config/Tokenizer.hpp index e2990f3..73148b7 100644 --- a/src/config/Tokenizer.hpp +++ b/src/config/Tokenizer.hpp @@ -25,8 +25,7 @@ namespace config ARR_CLOSE, MAP_OPEN, MAP_CLOSE, - MAPARRAY_OPEN, - MAPARRAY_CLOSE + MAPARRAY_DECL }; struct s_token @@ -144,27 +143,23 @@ namespace config file.get(c); } } - else if (c == ']') - { - std::streampos prev_pos = file.tellg(); - file.get(c); - if (c == ']') - { - token.type = MAPARRAY_CLOSE; - } - else - { - token.type = ARR_CLOSE; - file.seekg(prev_pos); - } - } else if (c == '[') { std::streampos prev_pos = file.tellg(); file.get(c); if (c == '[') { - token.type = MAPARRAY_OPEN; + token.type = MAPARRAY_DECL; + file.get(c); + while (c != ']') + { + token.value += c; + file.get(c); + } + if (c == ']') + file.get(c); + if (c != ']') + throw std::logic_error("error in MAPARRAY_DECL"); } else { @@ -173,10 +168,8 @@ namespace config } } - /* else if (c == '[') */ - /* token.type = ARR_OPEN; */ - /* else if (c == ']') */ - /* token.type = ARR_CLOSE; */ + else if (c == ']') + token.type = ARR_CLOSE; else if (c == '=') token.type = ASSIGN; else if (c == '\n') From 2135c4e82667057d8029271ca5c77f25ae065778 Mon Sep 17 00:00:00 2001 From: 3lswear Date: Thu, 13 Jan 2022 09:24:24 +0300 Subject: [PATCH 22/32] update with multiple servers --- config/simple.toml | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/config/simple.toml b/config/simple.toml index a464a76..29b75ed 100644 --- a/config/simple.toml +++ b/config/simple.toml @@ -1,4 +1,10 @@ -name = "jopa" -port = 6969 -ip = "127.0.0.1" -methods = ["GET", "POST", 1, "piska", false, false] +[[server]] + name = "jopa" + port = 6969 + ip = "127.0.0.1" + methods = ["GET", "POST", "HEAD"] +[[server]] + name = "jopaserv 2" + port = 1337 + ip = "127.0.0.1" + methods = ["GET", "POST" ] From 7c6d0783f170ac7c01df22a27c19af5a95585ed4 Mon Sep 17 00:00:00 2001 From: 3lswear Date: Thu, 13 Jan 2022 09:24:36 +0300 Subject: [PATCH 23/32] fix location syntax --- config/example.toml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/config/example.toml b/config/example.toml index f148367..3246478 100644 --- a/config/example.toml +++ b/config/example.toml @@ -4,7 +4,7 @@ port = 8080 error_page = "error.html" body_size_limit = 10 - [[location]] + [[server.location]] location = "/" # redirection ??? root = "/var/www/html/jopa.html" @@ -14,7 +14,7 @@ upload_accept = true upload_dir = "/var/www/html/upload" - [[location]] + [[server.location]] location = "/secret/" root = "/var/www/html/secret.html" methods = ["GET"] From ebd09bbcdc50b55dc0f99602b3cfe40770e52e31 Mon Sep 17 00:00:00 2001 From: 3lswear Date: Thu, 13 Jan 2022 09:25:04 +0300 Subject: [PATCH 24/32] intermediate changes --- includes/webserv.hpp | 2 +- src/config/TOMLNode.hpp | 15 ++-- src/config/TOMLParser.hpp | 141 +++++++++++++++++++++----------------- src/config/Tokenizer.hpp | 10 ++- src/config/parse.cpp | 26 ++++--- 5 files changed, 115 insertions(+), 79 deletions(-) diff --git a/includes/webserv.hpp b/includes/webserv.hpp index 926a93e..2620e81 100644 --- a/includes/webserv.hpp +++ b/includes/webserv.hpp @@ -26,7 +26,7 @@ class toml_node; /* typedef std::vector TOMLArray; */ /* typedef std::vector TOMLArrayOfMap; */ typedef std::map TOMLMap; // = JSONObject -typedef std::vector TOMLMapArray; +typedef std::pair *> TOMLMapArray; typedef std::vector TOMLArray; void display(TOMLMap *config); diff --git a/src/config/TOMLNode.hpp b/src/config/TOMLNode.hpp index 5638b46..b7b1175 100644 --- a/src/config/TOMLNode.hpp +++ b/src/config/TOMLNode.hpp @@ -16,10 +16,6 @@ class toml_node { - enum e_type - { - STRING, NUM, BOOL, ARRAY, MAP, MAPARRAY, NIL - } type; union u_value { @@ -35,6 +31,11 @@ class toml_node } value; public: + + enum e_type + { + STRING, NUM, BOOL, ARRAY, MAP, MAPARRAY, NIL + } type; enum e_type get_type(void) { @@ -45,6 +46,12 @@ class toml_node { return (value.map); } + + TOMLMapArray *getMapArray(void) + { + return (value.map_array); + } + void setString(std::string *str) { value.str = str; diff --git a/src/config/TOMLParser.hpp b/src/config/TOMLParser.hpp index 404d339..6f423aa 100644 --- a/src/config/TOMLParser.hpp +++ b/src/config/TOMLParser.hpp @@ -101,10 +101,10 @@ namespace config std::cerr << "Parsing MapArray" << std::endl; toml_node *node = new toml_node; TOMLMapArray *servers = new TOMLMapArray; + s_token current; while (tokenizer.hasMoreTokens()) { - s_token current; try { current = tokenizer.getToken(); } catch (std::logic_error e) { @@ -112,9 +112,21 @@ namespace config break; } if (current.type == MAPARRAY_DECL) - servers->push_back(parseMap()->getMap()); + { + if (tokenizer.getToken().type != NEWLINE) + throw std::logic_error("no newline after map_array declaration"); + servers->second->push_back(parseMap()->getMap()); + } else throw std::logic_error("unexpected token in parseMapArray"); + if (tokenizer.hasMoreTokens()) + current = tokenizer.getToken(); + else + break; + if (current.type != NEWLINE) + { + throw std::logic_error("EXPECTED newline"); + } } node->setMapArray(servers); return (node); @@ -245,72 +257,73 @@ namespace config std::string key; key = ""; - root = parseMap(); + /* root = parseMap(); */ + root = parseMapArray(); return (root); - while (tokenizer.hasMoreTokens()) - { - s_token token; - try - { - token = tokenizer.getToken(); - /* std::cout << token.to_string() << std::endl; */ - switch (token.type) - { - case KEY: - { - toml_node *parsedObject = parseString(); - if (!root) - root = parsedObject; - } + /* while (tokenizer.hasMoreTokens()) */ + /* { */ + /* s_token token; */ + /* try */ + /* { */ + /* token = tokenizer.getToken(); */ + /* /1* std::cout << token.to_string() << std::endl; *1/ */ + /* switch (token.type) */ + /* { */ + /* case KEY: */ + /* { */ + /* toml_node *parsedObject = parseString(); */ + /* if (!root) */ + /* root = parsedObject; */ + /* } */ - case ARR_OPEN: - { - toml_node *parsedObject = parseMap(); - /* parsedObject->printNode(0); */ - if (!root) - root = parsedObject; - } - break; - case NUMBER: - { - tokenizer.rollBackToken(); - toml_node *parsedNumber = parseNumber(); - if (!root) - root = parsedNumber; - } - break; - case STRING: - { - tokenizer.rollBackToken(); - toml_node *parsedString = parseString(); - if (!root) - root = parsedString; - } - break; - case BOOL: - { - tokenizer.rollBackToken(); - toml_node *parsedBool = parseBool(); - if (!root) - root = parsedBool; - } - break; - case MAPARRAY_DECL: - { + /* case ARR_OPEN: */ + /* { */ + /* toml_node *parsedObject = parseMap(); */ + /* /1* parsedObject->printNode(0); *1/ */ + /* if (!root) */ + /* root = parsedObject; */ + /* } */ + /* break; */ + /* case NUMBER: */ + /* { */ + /* tokenizer.rollBackToken(); */ + /* toml_node *parsedNumber = parseNumber(); */ + /* if (!root) */ + /* root = parsedNumber; */ + /* } */ + /* break; */ + /* case STRING: */ + /* { */ + /* tokenizer.rollBackToken(); */ + /* toml_node *parsedString = parseString(); */ + /* if (!root) */ + /* root = parsedString; */ + /* } */ + /* break; */ + /* case BOOL: */ + /* { */ + /* tokenizer.rollBackToken(); */ + /* toml_node *parsedBool = parseBool(); */ + /* if (!root) */ + /* root = parsedBool; */ + /* } */ + /* break; */ + /* case MAPARRAY_DECL: */ + /* { */ - } - default: - { - throw std::logic_error("JOPA :("); - } - } - } - catch (std::logic_error err) - { - break; - } - } + /* } */ + /* default: */ + /* { */ + /* throw std::logic_error("JOPA :("); */ + /* } */ + /* } */ + /* } */ + /* catch (std::logic_error err) */ + /* { */ + /* break; */ + /* } */ + /* } */ return (root); } } diff --git a/src/config/Tokenizer.hpp b/src/config/Tokenizer.hpp index 73148b7..791f8a8 100644 --- a/src/config/Tokenizer.hpp +++ b/src/config/Tokenizer.hpp @@ -35,6 +35,14 @@ namespace config /* std::string to_string(void); */ }; + bool isspace(char c) + { + if (c == ' ' || c == '\t') + return (true); + else + return (false); + } + bool istomlkey(char c) { if (isalnum(c) || c == '-' || c == '_') @@ -75,7 +83,7 @@ namespace config char Tokenizer::getWithoutWhiteSpace(void) { char c = ' '; - while (c == ' ') + while (config::isspace(c)) { file.get(c); if ((c == ' ') && !file.good()) diff --git a/src/config/parse.cpp b/src/config/parse.cpp index 420e774..c9c31a0 100644 --- a/src/config/parse.cpp +++ b/src/config/parse.cpp @@ -23,19 +23,27 @@ /* } */ namespace config { - void display(TOMLMap *config) + void display(toml_node *config) { std::cout << ">>> printing config: <<<" << std::endl; + if (config->get_type() != toml_node::MAPARRAY) + throw std::logic_error("Attempting to display not map_array"); + TOMLMapArray *root_map_array = config->getMapArray(); + TOMLMapArray::iterator root_it; TOMLMap::iterator it; - for (it = config->begin(); it != config->end(); ++it) - { - std::cout << it->first - << ": " - << *(it->second->toString()) - << std::endl; - } + for (root_it = root_map_array->begin(); root_it != root_map_array->end(); ++root_it) + { + for (it = (*root_it)->begin(); it != (*root_it)->end(); ++it) + { + std::cout << it->first + << ": " + << *(it->second->toString()) + << std::endl; + } + std::cout << "-------" << std::endl; + } } } @@ -44,5 +52,5 @@ void parse(void) std::string filename = "config/simple.toml"; config::TOMLParser parser(filename); toml_node *root = parser.parse(); - config::display(root->getMap()); + config::display(root); } From 9c19e936b632c95723c2a0d29ea8a39666dcbfbe Mon Sep 17 00:00:00 2001 From: 3lswear Date: Sun, 16 Jan 2022 23:06:06 +0300 Subject: [PATCH 25/32] intermediate changes --- config/example.toml | 25 +++++++++++++++++++++++- includes/webserv.hpp | 2 +- src/config/TOMLNode.hpp | 41 +++++++++++++++++++++++++++++++++++++++ src/config/TOMLParser.hpp | 13 +++++++++++-- src/config/parse.cpp | 3 ++- 5 files changed, 79 insertions(+), 5 deletions(-) diff --git a/config/example.toml b/config/example.toml index 3246478..b2418f2 100644 --- a/config/example.toml +++ b/config/example.toml @@ -1,5 +1,5 @@ [[server]] - name = "jopaserver" + name = "serv1" host = "127.0.0.1" port = 8080 error_page = "error.html" @@ -20,3 +20,26 @@ methods = ["GET"] directory_list = false directory_fallback = "oops.html" + +[[server]] + name = "2222" + host = "10.0.0.1" + port = 8081 + error_page = "error2.html" + body_size_limit = 10 + [[server.location]] + location = "/root2/" + # redirection ??? + root = "/var/www/html/jopa.html" + methods = ["GET", "POST"] + directory_list = true + directory_fallback = "its_a_directory.html" + upload_accept = false + upload_dir = "/var/www/html/upload" + + [[server.location]] + location = "/secret2/" + root = "/var/www/html/secret.html" + methods = ["GET"] + directory_list = false + directory_fallback = "oops.html" diff --git a/includes/webserv.hpp b/includes/webserv.hpp index 2620e81..926a93e 100644 --- a/includes/webserv.hpp +++ b/includes/webserv.hpp @@ -26,7 +26,7 @@ class toml_node; /* typedef std::vector TOMLArray; */ /* typedef std::vector TOMLArrayOfMap; */ typedef std::map TOMLMap; // = JSONObject -typedef std::pair *> TOMLMapArray; +typedef std::vector TOMLMapArray; typedef std::vector TOMLArray; void display(TOMLMap *config); diff --git a/src/config/TOMLNode.hpp b/src/config/TOMLNode.hpp index b7b1175..c7de648 100644 --- a/src/config/TOMLNode.hpp +++ b/src/config/TOMLNode.hpp @@ -88,6 +88,25 @@ class toml_node value.map_array = map_array; type = MAPARRAY; } + + static std::string *TOMLMap_to_string(TOMLMap *map) + { + std::stringstream ss; + std::string *result = new std::string(); + TOMLMap::iterator it; + + for (it = map->begin(); it != map->end(); ++it) + { + ss << it->first + << ": " + << *(it->second->toString()) + << std::endl; + } + + ss >> *result; + return (result); + } + std::string *toString(void) const { switch (type) @@ -116,6 +135,28 @@ class toml_node *result += " ]"; return (result); } + case MAP: + { + return (TOMLMap_to_string(value.map)); + } + case MAPARRAY: + { + std::stringstream ss; + std::string *result = new std::string(); + TOMLMapArray::iterator it; + TOMLMapArray *map_array = value.map_array; + + ss << std::endl; + for (it = map_array->begin(); it != map_array->end(); ++it) + { + ss << (TOMLMap_to_string(*it)); + } + + ss << "-------" << std::endl; + + ss >> *result; + return (result); + } case BOOL: { std::string *result; diff --git a/src/config/TOMLParser.hpp b/src/config/TOMLParser.hpp index 6f423aa..361a032 100644 --- a/src/config/TOMLParser.hpp +++ b/src/config/TOMLParser.hpp @@ -36,6 +36,15 @@ namespace config std::cerr << e.what() << std::endl; break; } + if (nextToken.type == MAPARRAY_DECL) + { + parseMapArray(); + continue; + } + else + { + /* take key make decision */ + } std::string key = nextToken.value; std::cerr << key << std::endl; if (tokenizer.getToken().type != ASSIGN) @@ -257,8 +266,8 @@ namespace config std::string key; key = ""; - /* root = parseMap(); */ - root = parseMapArray(); + root = parseMap(); + /* root = parseMapArray(); */ return (root); /* while (tokenizer.hasMoreTokens()) */ diff --git a/src/config/parse.cpp b/src/config/parse.cpp index c9c31a0..965b6ce 100644 --- a/src/config/parse.cpp +++ b/src/config/parse.cpp @@ -23,7 +23,8 @@ /* } */ namespace config { - void display(toml_node *config) + + void display(toml_node *root_node) { std::cout << ">>> printing config: <<<" << std::endl; if (config->get_type() != toml_node::MAPARRAY) From e7470e9124240b1285ed509e50de72ae63e7156b Mon Sep 17 00:00:00 2001 From: 3lswear Date: Tue, 18 Jan 2022 01:51:17 +0300 Subject: [PATCH 26/32] working map_array parser?? --- src/config/TOMLNode.hpp | 9 +- src/config/TOMLParser.hpp | 203 +++++++++++++++++++++++++++++--------- src/config/parse.cpp | 23 ++--- 3 files changed, 170 insertions(+), 65 deletions(-) diff --git a/src/config/TOMLNode.hpp b/src/config/TOMLNode.hpp index c7de648..662e9a9 100644 --- a/src/config/TOMLNode.hpp +++ b/src/config/TOMLNode.hpp @@ -103,7 +103,8 @@ class toml_node << std::endl; } - ss >> *result; + /* ss >> *result; */ + *result = ss.str(); return (result); } @@ -149,12 +150,14 @@ class toml_node ss << std::endl; for (it = map_array->begin(); it != map_array->end(); ++it) { - ss << (TOMLMap_to_string(*it)); + ss << (*TOMLMap_to_string(*it)); + ss << std::endl; } ss << "-------" << std::endl; - ss >> *result; + /* ss >> *result; */ + *result = ss.str(); return (result); } case BOOL: diff --git a/src/config/TOMLParser.hpp b/src/config/TOMLParser.hpp index 361a032..1a58249 100644 --- a/src/config/TOMLParser.hpp +++ b/src/config/TOMLParser.hpp @@ -11,13 +11,19 @@ namespace config { private: std::fstream file; - toml_node *root; //root of TOML tree + TOMLMap *root; //root of TOML tree /* toml_node *current; //node currently being parsed */ Tokenizer tokenizer; public: TOMLParser(const std::string filename) : tokenizer(filename) {} - toml_node *parse(void); + TOMLMap *parse(void); + + /* get a name possibly with dots and add new map to corresponding map_array*/ + /* void add_to_map_array(std::string name, TOMLMap *new) */ + /* { */ + + /* } */ toml_node *parseMap(void) { @@ -38,12 +44,8 @@ namespace config } if (nextToken.type == MAPARRAY_DECL) { - parseMapArray(); - continue; - } - else - { - /* take key make decision */ + tokenizer.rollBackToken(); + break; } std::string key = nextToken.value; std::cerr << key << std::endl; @@ -75,6 +77,12 @@ namespace config (*mapObject)[key] = parseBool(); break; } + case MAPARRAY_DECL: + { + std::cerr << "reached MAPARRAY_DECL in parseMap" << std::endl; + completed = true; + break; + } default: { /* throw std::logic_error("jopa in parseMap"); */ @@ -105,41 +113,9 @@ namespace config return (node); } - toml_node *parseMapArray(void) - { - std::cerr << "Parsing MapArray" << std::endl; - toml_node *node = new toml_node; - TOMLMapArray *servers = new TOMLMapArray; - s_token current; - - while (tokenizer.hasMoreTokens()) - { - try { current = tokenizer.getToken(); } - catch (std::logic_error e) - { - std::cerr << e.what() << std::endl; - break; - } - if (current.type == MAPARRAY_DECL) - { - if (tokenizer.getToken().type != NEWLINE) - throw std::logic_error("no newline after map_array declaration"); - servers->second->push_back(parseMap()->getMap()); - } - else - throw std::logic_error("unexpected token in parseMapArray"); - if (tokenizer.hasMoreTokens()) - current = tokenizer.getToken(); - else - break; - if (current.type != NEWLINE) - { - throw std::logic_error("EXPECTED newline"); - } - } - node->setMapArray(servers); - return (node); - } + /* toml_node *parseMapArray(void) */ + /* { */ + /* } */ toml_node *parseString(void) { @@ -261,12 +237,145 @@ namespace config } }; - toml_node *TOMLParser::parse(void) + /* parse tha root ! */ + TOMLMap *TOMLParser::parse(void) { - std::string key; - key = ""; + /* root = parseMap()->getMap(); */ + std::cerr << "Parsing ROOT" << std::endl; + /* TOMLMap *mapObject = new TOMLMap; */ + root = new TOMLMap; + /* toml_node *node = new toml_node; */ + bool completed = false; + while (!completed) + { + if (tokenizer.hasMoreTokens()) + { + s_token current; + try { current = tokenizer.getToken(); } + catch (std::logic_error e) + { + std::cerr << e.what() << std::endl; + break; + } + if (current.type == MAPARRAY_DECL) + { + /* parseMapArray(); */ + tokenizer.rollBackToken(); + std::cerr << "Parsing MapArray" << std::endl; + toml_node *map_node; + toml_node *maparr_node; + s_token current; - root = parseMap(); + try { current = tokenizer.getToken(); } + catch (std::logic_error e) + { + std::cerr << e.what() << std::endl; + break; + } + if (current.type == MAPARRAY_DECL) + { + if (tokenizer.getToken().type != NEWLINE) + throw std::logic_error("no newline after map_array declaration"); + map_node = parseMap(); + } + else + throw std::logic_error("unexpected token in parseMapArray"); + /* if (current.type != NEWLINE) */ + /* { */ + /* throw std::logic_error("EXPECTED newline"); */ + /* } */ + + TOMLMap::iterator it; + std::string name = current.value; + + it = root->find(name); + if (it == root->end()) + { + maparr_node = new toml_node; + TOMLMapArray *map_array = new TOMLMapArray; + map_array->push_back(map_node->getMap()); + maparr_node->setMapArray(map_array); + (*root)[name] = maparr_node; + } + else + { + (it->second)->getMapArray()->push_back(map_node->getMap()); + } + + /* if (tokenizer.hasMoreTokens()) */ + /* nextToken = tokenizer.getToken(); */ + /* else */ + /* break; */ + /* if (nextToken.type != NEWLINE) */ + /* { */ + /* throw std::logic_error("EXPECTED newline"); */ + /* } */ + + /* continue; */ + } + else + { + /* take key make decision */ + std::string key = current.value; + std::cerr << key << std::endl; + if (tokenizer.getToken().type != ASSIGN) + throw std::logic_error("EXPECTED assign!"); + current = tokenizer.getToken(); + switch (current.type) + { + case STRING: + { + tokenizer.rollBackToken(); + (*root)[key] = parseString(); + break; + } + case ARR_OPEN: + { + (*root)[key] = parseArray(); + break; + } + case NUMBER: + { + tokenizer.rollBackToken(); + (*root)[key] = parseNumber(); + break; + } + case BOOL: + { + tokenizer.rollBackToken(); + (*root)[key] = parseBool(); + break; + } + default: + { + /* throw std::logic_error("jopa in parseMap"); */ + std::cerr << "Unknown token, marking as complete" << std::endl; + completed = true; + break; + } + } + if (tokenizer.hasMoreTokens()) + current = tokenizer.getToken(); + else + break; + if (current.type != NEWLINE) + { + throw std::logic_error("EXPECTED newline"); + } + /* if (tokenizer.getToken().type == NEWLINE) */ + /* completed = true; */ + /* else */ + /* throw std::logic_error("EXPECTED newline"); */ + } + } + else + { + /* throw std::logic_error("parseMap: no more tokens"); */ + completed = true; + break; + } + /* node->setObject(root); */ + } /* root = parseMapArray(); */ return (root); diff --git a/src/config/parse.cpp b/src/config/parse.cpp index 965b6ce..a49b5ba 100644 --- a/src/config/parse.cpp +++ b/src/config/parse.cpp @@ -24,27 +24,20 @@ namespace config { - void display(toml_node *root_node) + void display(TOMLMap *root_map) { std::cout << ">>> printing config: <<<" << std::endl; - if (config->get_type() != toml_node::MAPARRAY) - throw std::logic_error("Attempting to display not map_array"); - TOMLMapArray *root_map_array = config->getMapArray(); - TOMLMapArray::iterator root_it; TOMLMap::iterator it; - for (root_it = root_map_array->begin(); root_it != root_map_array->end(); ++root_it) + for (it = root_map->begin(); it != root_map->end(); ++it) { - for (it = (*root_it)->begin(); it != (*root_it)->end(); ++it) - { - std::cout << it->first - << ": " - << *(it->second->toString()) - << std::endl; - } - std::cout << "-------" << std::endl; + std::cout << it->first + << ": " + << *(it->second->toString()) + << std::endl; } + std::cout << "-------" << std::endl; } } @@ -52,6 +45,6 @@ void parse(void) { std::string filename = "config/simple.toml"; config::TOMLParser parser(filename); - toml_node *root = parser.parse(); + TOMLMap *root = parser.parse(); config::display(root); } From 77c32c96e8bb2bddec1942459848eda71e50e9c2 Mon Sep 17 00:00:00 2001 From: 3lswear Date: Tue, 18 Jan 2022 17:58:45 +0300 Subject: [PATCH 27/32] clean ups --- config/simple.toml | 1 + src/config/TOMLNode.hpp | 6 +-- src/config/TOMLParser.hpp | 104 -------------------------------------- src/config/parse.cpp | 6 +-- 4 files changed, 7 insertions(+), 110 deletions(-) diff --git a/config/simple.toml b/config/simple.toml index 29b75ed..3690559 100644 --- a/config/simple.toml +++ b/config/simple.toml @@ -1,4 +1,5 @@ [[server]] + a = "b" name = "jopa" port = 6969 ip = "127.0.0.1" diff --git a/src/config/TOMLNode.hpp b/src/config/TOMLNode.hpp index 662e9a9..a590ca5 100644 --- a/src/config/TOMLNode.hpp +++ b/src/config/TOMLNode.hpp @@ -147,14 +147,14 @@ class toml_node TOMLMapArray::iterator it; TOMLMapArray *map_array = value.map_array; - ss << std::endl; + ss << "[\n"; for (it = map_array->begin(); it != map_array->end(); ++it) { ss << (*TOMLMap_to_string(*it)); - ss << std::endl; + ss << ", " << std::endl; } + ss << "]\n"; - ss << "-------" << std::endl; /* ss >> *result; */ *result = ss.str(); diff --git a/src/config/TOMLParser.hpp b/src/config/TOMLParser.hpp index 1a58249..e46033a 100644 --- a/src/config/TOMLParser.hpp +++ b/src/config/TOMLParser.hpp @@ -19,12 +19,6 @@ namespace config TOMLParser(const std::string filename) : tokenizer(filename) {} TOMLMap *parse(void); - /* get a name possibly with dots and add new map to corresponding map_array*/ - /* void add_to_map_array(std::string name, TOMLMap *new) */ - /* { */ - - /* } */ - toml_node *parseMap(void) { std::cerr << "Parsing object" << std::endl; @@ -99,10 +93,6 @@ namespace config { throw std::logic_error("EXPECTED newline"); } - /* if (tokenizer.getToken().type == NEWLINE) */ - /* completed = true; */ - /* else */ - /* throw std::logic_error("EXPECTED newline"); */ } else { @@ -113,10 +103,6 @@ namespace config return (node); } - /* toml_node *parseMapArray(void) */ - /* { */ - /* } */ - toml_node *parseString(void) { /* toml_node *node; */ @@ -240,11 +226,8 @@ namespace config /* parse tha root ! */ TOMLMap *TOMLParser::parse(void) { - /* root = parseMap()->getMap(); */ std::cerr << "Parsing ROOT" << std::endl; - /* TOMLMap *mapObject = new TOMLMap; */ root = new TOMLMap; - /* toml_node *node = new toml_node; */ bool completed = false; while (!completed) { @@ -280,10 +263,6 @@ namespace config } else throw std::logic_error("unexpected token in parseMapArray"); - /* if (current.type != NEWLINE) */ - /* { */ - /* throw std::logic_error("EXPECTED newline"); */ - /* } */ TOMLMap::iterator it; std::string name = current.value; @@ -302,20 +281,9 @@ namespace config (it->second)->getMapArray()->push_back(map_node->getMap()); } - /* if (tokenizer.hasMoreTokens()) */ - /* nextToken = tokenizer.getToken(); */ - /* else */ - /* break; */ - /* if (nextToken.type != NEWLINE) */ - /* { */ - /* throw std::logic_error("EXPECTED newline"); */ - /* } */ - - /* continue; */ } else { - /* take key make decision */ std::string key = current.value; std::cerr << key << std::endl; if (tokenizer.getToken().type != ASSIGN) @@ -362,86 +330,14 @@ namespace config { throw std::logic_error("EXPECTED newline"); } - /* if (tokenizer.getToken().type == NEWLINE) */ - /* completed = true; */ - /* else */ - /* throw std::logic_error("EXPECTED newline"); */ } } else { - /* throw std::logic_error("parseMap: no more tokens"); */ completed = true; break; } - /* node->setObject(root); */ } - /* root = parseMapArray(); */ - return (root); - - /* while (tokenizer.hasMoreTokens()) */ - /* { */ - /* s_token token; */ - /* try */ - /* { */ - /* token = tokenizer.getToken(); */ - /* /1* std::cout << token.to_string() << std::endl; *1/ */ - /* switch (token.type) */ - /* { */ - /* case KEY: */ - /* { */ - /* toml_node *parsedObject = parseString(); */ - /* if (!root) */ - /* root = parsedObject; */ - /* } */ - - /* case ARR_OPEN: */ - /* { */ - /* toml_node *parsedObject = parseMap(); */ - /* /1* parsedObject->printNode(0); *1/ */ - /* if (!root) */ - /* root = parsedObject; */ - /* } */ - /* break; */ - /* case NUMBER: */ - /* { */ - /* tokenizer.rollBackToken(); */ - /* toml_node *parsedNumber = parseNumber(); */ - /* if (!root) */ - /* root = parsedNumber; */ - /* } */ - /* break; */ - /* case STRING: */ - /* { */ - /* tokenizer.rollBackToken(); */ - /* toml_node *parsedString = parseString(); */ - /* if (!root) */ - /* root = parsedString; */ - /* } */ - /* break; */ - /* case BOOL: */ - /* { */ - /* tokenizer.rollBackToken(); */ - /* toml_node *parsedBool = parseBool(); */ - /* if (!root) */ - /* root = parsedBool; */ - /* } */ - /* break; */ - /* case MAPARRAY_DECL: */ - /* { */ - - /* } */ - /* default: */ - /* { */ - /* throw std::logic_error("JOPA :("); */ - /* } */ - /* } */ - /* } */ - /* catch (std::logic_error err) */ - /* { */ - /* break; */ - /* } */ - /* } */ return (root); } } diff --git a/src/config/parse.cpp b/src/config/parse.cpp index a49b5ba..90e806d 100644 --- a/src/config/parse.cpp +++ b/src/config/parse.cpp @@ -34,10 +34,10 @@ namespace config { std::cout << it->first << ": " - << *(it->second->toString()) - << std::endl; + << *(it->second->toString()); + std::cout << ", " << std::endl; + /* << std::endl << "-------" << std::endl; */ } - std::cout << "-------" << std::endl; } } From 2e0dbabff0207b2861bc94293aec6522fcc992e5 Mon Sep 17 00:00:00 2001 From: 3lswear Date: Tue, 18 Jan 2022 19:47:10 +0300 Subject: [PATCH 28/32] a change --- config/simple.toml | 1 + 1 file changed, 1 insertion(+) diff --git a/config/simple.toml b/config/simple.toml index 29b75ed..51d93c2 100644 --- a/config/simple.toml +++ b/config/simple.toml @@ -3,6 +3,7 @@ port = 6969 ip = "127.0.0.1" methods = ["GET", "POST", "HEAD"] + body_size_limit = 10 [[server]] name = "jopaserv 2" port = 1337 From 73d9dd8feb9886b0e0ced1041f35d98cdcd4510b Mon Sep 17 00:00:00 2001 From: 3lswear Date: Wed, 19 Jan 2022 09:32:10 +0300 Subject: [PATCH 29/32] intermediate commit --- src/config/TOMLParser.hpp | 53 ++++++++++++++++++++++++++++++++------- 1 file changed, 44 insertions(+), 9 deletions(-) diff --git a/src/config/TOMLParser.hpp b/src/config/TOMLParser.hpp index e46033a..181a2b1 100644 --- a/src/config/TOMLParser.hpp +++ b/src/config/TOMLParser.hpp @@ -265,20 +265,55 @@ namespace config throw std::logic_error("unexpected token in parseMapArray"); TOMLMap::iterator it; + std::cout << current.value << std::endl; std::string name = current.value; + std::vector full_name; + size_t dot; - it = root->find(name); - if (it == root->end()) + while (1) { - maparr_node = new toml_node; - TOMLMapArray *map_array = new TOMLMapArray; - map_array->push_back(map_node->getMap()); - maparr_node->setMapArray(map_array); - (*root)[name] = maparr_node; + dot = name.find('.'); + if (dot == std::string::npos) + break; + /* std::cout << dot << std::endl; */ + full_name.push_back(name.substr(0, dot)); + name.erase(0, dot + 1); } - else + full_name.push_back(name); + + /* for (size_t i = 0; i < full_name.size(); i++) */ + /* std::cout << full_name[i] << std::endl; */ + + /* throw std::logic_error("tha end"); */ + TOMLMap *local_root; + + std::vector::iterator subname = full_name.begin(); + local_root = root; + while (1) { - (it->second)->getMapArray()->push_back(map_node->getMap()); + if (subname + 1 == full_name.end()) + { + it = local_root->find(*subname); + if (it == local_root->end()) + { + maparr_node = new toml_node; + TOMLMapArray *map_array = new TOMLMapArray; + map_array->push_back(map_node->getMap()); + maparr_node->setMapArray(map_array); + (*local_root)[name] = maparr_node; + } + else + (it->second)->getMapArray()->push_back(map_node->getMap()); + break; + } + else + { + map + TOMLMap *new_map = new TOMLMap; + + + } + ++subname; } } From 6f05954fa49fed2a6d4bc70e2849bbf3c34f5f58 Mon Sep 17 00:00:00 2001 From: 3lswear Date: Wed, 19 Jan 2022 09:32:32 +0300 Subject: [PATCH 30/32] more complex --- config/simple.toml | 40 +++++++++++++++++++++++++++++++--------- 1 file changed, 31 insertions(+), 9 deletions(-) diff --git a/config/simple.toml b/config/simple.toml index c654f02..4abbf7d 100644 --- a/config/simple.toml +++ b/config/simple.toml @@ -1,12 +1,34 @@ [[server]] - a = "b" - name = "jopa" - port = 6969 - ip = "127.0.0.1" - methods = ["GET", "POST", "HEAD"] + name = "serv1" + host = "127.0.0.1" + port = 8080 + error_page = "error.html" body_size_limit = 10 + [[server.location]] + location = "/" + root = "/var/www/html/jopa.html" + methods = ["GET", "POST"] + directory_list = true + directory_fallback = "its_a_directory.html" + upload_accept = true + upload_dir = "/var/www/html/upload" + [[server.location]] + location = "/secret/" + root = "/var/www/html/secret.html" + methods = ["GET"] + directory_list = false + directory_fallback = "oops.html" [[server]] - name = "jopaserv 2" - port = 1337 - ip = "127.0.0.1" - methods = ["GET", "POST" ] + name = "2222" + host = "10.0.0.1" + port = 8081 + error_page = "error2.html" + body_size_limit = 10 + [[server.location]] + location = "/root2/" + root = "/var/www/html/jopa.html" + methods = ["GET", "POST"] + directory_list = true + directory_fallback = "its_a_directory.html" + upload_accept = false + upload_dir = "/var/www/html/upload" From abb4421f676d9832cd533cbbb957b2dedfd24878 Mon Sep 17 00:00:00 2001 From: 3lswear Date: Wed, 19 Jan 2022 23:11:52 +0300 Subject: [PATCH 31/32] feat: prettify TOMLMapToString --- src/config/TOMLNode.hpp | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/config/TOMLNode.hpp b/src/config/TOMLNode.hpp index a590ca5..2cf2c64 100644 --- a/src/config/TOMLNode.hpp +++ b/src/config/TOMLNode.hpp @@ -95,6 +95,7 @@ class toml_node std::string *result = new std::string(); TOMLMap::iterator it; + ss << "{\n"; for (it = map->begin(); it != map->end(); ++it) { ss << it->first @@ -103,6 +104,8 @@ class toml_node << std::endl; } + ss << "}" << std::endl; + /* ss >> *result; */ *result = ss.str(); return (result); From d1a0ae8c1e33346601f56844526746355a9d81bb Mon Sep 17 00:00:00 2001 From: 3lswear Date: Wed, 19 Jan 2022 23:13:25 +0300 Subject: [PATCH 32/32] feat: working parser with TOML maparray --- src/config/TOMLParser.hpp | 25 ++++++++++++++++++++----- 1 file changed, 20 insertions(+), 5 deletions(-) diff --git a/src/config/TOMLParser.hpp b/src/config/TOMLParser.hpp index 181a2b1..556e898 100644 --- a/src/config/TOMLParser.hpp +++ b/src/config/TOMLParser.hpp @@ -281,8 +281,9 @@ namespace config } full_name.push_back(name); - /* for (size_t i = 0; i < full_name.size(); i++) */ - /* std::cout << full_name[i] << std::endl; */ + for (size_t i = 0; i < full_name.size(); i++) + std::cout << full_name[i] << ", "; + std::cout << std::endl; /* throw std::logic_error("tha end"); */ TOMLMap *local_root; @@ -300,7 +301,7 @@ namespace config TOMLMapArray *map_array = new TOMLMapArray; map_array->push_back(map_node->getMap()); maparr_node->setMapArray(map_array); - (*local_root)[name] = maparr_node; + (*local_root)[*subname] = maparr_node; } else (it->second)->getMapArray()->push_back(map_node->getMap()); @@ -308,9 +309,23 @@ namespace config } else { - map - TOMLMap *new_map = new TOMLMap; + it = local_root->find(*subname); + toml_node *map_node2; + map_node2 = new toml_node; + TOMLMap *map = new TOMLMap; + map_node2->setObject(map); + /* subname not found in local_root */ + if (it == local_root->end()) + { + (*local_root)[*subname] = map_node2; + local_root = map; + } + /* subname found in local_root */ + else + { + local_root = *((it->second)->getMapArray()->end() - 1); + } } ++subname;