nicolas-arnaud
/
Webserv
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

reformat

master
nicolas-arnaud 2 years ago
parent
566505d8b0
commit
4282a88b8a
6 changed files with 442 additions and 560 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 40
      includes/Route.hpp
  2. 25
      includes/Token.hpp
  3. 4
      srcs/load/Env.cpp
  4. 171
      srcs/load/Route.cpp
  5. 544
      srcs/sock/Client.cpp
  6. 218
      srcs/sock/Master.cpp

40
includes/Route.hpp
View File

@ -3,27 +3,27 @@
class Route { class Route {
protected: protected:
Server *_server; Server *_server;
string _location, _root; string _location, _root;
bool _autoindex; bool _autoindex;
public: public:
vec_string _indexs, _allowed_methods; vec_string _indexs, _allowed_methods;
std::map<string, string> _cgi; std::map<string, string> _cgi;
int _client_max_body_size; int _client_max_body_size;
int _timeout; int _timeout;
int _max_requests; int _max_requests;
int _ret_code; int _ret_code;
string _ret_uri; string _ret_uri;
std::map<int, string> _err_page; std::map<int, string> _err_page;
Route(Server *server, string location, JSONNode *datas); Route(Server *server, string location, JSONNode *datas);
~Route(void); ~Route(void);
string getLocation(void); string getLocation(void);
string get_custom_err(int error_code); string get_custom_err(int error_code);
string getRoot(void); string getRoot(void);
string getReturn(void); string getReturn(void);
Server *getServer(void); Server *getServer(void);
string getIndex(string uri, string path); string getIndex(string uri, string path);
string correctUri(string uri); string correctUri(string uri);
}; };

25
includes/Token.hpp
View File

@ -1,32 +1,21 @@
#pragma once #pragma once
#include "webserv.hpp" #include "webserv.hpp"
enum TOKEN { enum TOKEN { CURLY_OPEN, CURLY_CLOSE, COLON, STRING, NUMBER, ARRAY_OPEN, ARRAY_CLOSE, COMMA, BOOLEAN, NULL_TYPE };
CURLY_OPEN,
CURLY_CLOSE,
COLON,
STRING,
NUMBER,
ARRAY_OPEN,
ARRAY_CLOSE,
COMMA,
BOOLEAN,
NULL_TYPE
};
typedef struct Token_s { typedef struct Token_s {
string value; string value;
TOKEN type; TOKEN type;
} Token; } Token;
class Tokenizer { class Tokenizer {
std::fstream file; std::fstream file;
size_t prevPos; size_t prevPos;
public: public:
Tokenizer(string fileName); Tokenizer(string fileName);
bool hasMoreTokens(); bool hasMoreTokens();
char getWithoutWhiteSpace(); char getWithoutWhiteSpace();
void rollBackToken(); void rollBackToken();
Token getToken(); Token getToken();
}; };

4
srcs/load/Env.cpp
View File

@ -54,11 +54,11 @@ Env::~Env() {
* - for each master socket, call his own post_poll method to check and handle the sockets flaged. * - for each master socket, call his own post_poll method to check and handle the sockets flaged.
*/ */
void Env::cycle(void) { void Env::cycle(void) {
//if (!SILENT) cout << "|===||===| Waiting some HTTP request... |===||===|\n"; // if (!SILENT) cout << "|===||===| Waiting some HTTP request... |===||===|\n";
int pollResult = poll(Master::_pollfds, Master::_poll_id_amount + 1, 5000); int pollResult = poll(Master::_pollfds, Master::_poll_id_amount + 1, 5000);
if ((pollResult < 0) && (errno != EINTR)) std::cerr << "Select: " << strerror(errno) << "\n"; if ((pollResult < 0) && (errno != EINTR)) std::cerr << "Select: " << strerror(errno) << "\n";
if (pollResult > 0) { if (pollResult > 0) {
//if (!SILENT) cout << "==> Handle requests and answers:\n"; // if (!SILENT) cout << "==> Handle requests and answers:\n";
for (std::vector<Master *>::iterator it = this->_masters.begin(); it < this->_masters.end(); it++) try { for (std::vector<Master *>::iterator it = this->_masters.begin(); it < this->_masters.end(); it++) try {
(*it)->check_socket(); (*it)->check_socket();
(*it)->check_childs(this); (*it)->check_childs(this);

171
srcs/load/Route.cpp
View File

@ -18,53 +18,41 @@
* @param location The uri associatied to the route. * @param location The uri associatied to the route.
* @param datas The JSONNode giving configuration. * @param datas The JSONNode giving configuration.
*/ */
Route::Route(Server *server, string location, JSONNode *datas) Route::Route(Server *server, string location, JSONNode *datas) : _server(server), _location(location) {
: _server(server), _location(location) { JSONObject object = datas->obj();
JSONObject object = datas->obj(); JSONNode *tmp;
JSONNode *tmp; _autoindex = false;
_autoindex = false; _client_max_body_size = -1;
_client_max_body_size = -1; if ((tmp = object["root"])) _root = tmp->str();
if ((tmp = object["root"])) if ((tmp = object["return"])) {
_root = tmp->str(); _ret_code = tmp->lst()[0]->nbr();
if ((tmp = object["return"])) { _ret_uri = tmp->lst()[1]->str();
_ret_code = tmp->lst()[0]->nbr(); }
_ret_uri = tmp->lst()[1]->str(); if ((tmp = object["autoindex"])) _autoindex = tmp->boo();
} if ((tmp = object["keepalive_time"])) _timeout = tmp->nbr();
if ((tmp = object["autoindex"])) else _timeout = 0;
_autoindex = tmp->boo(); if ((tmp = object["keepalive_requests"])) _max_requests = tmp->nbr();
if ((tmp = object["keepalive_time"])) else _max_requests = 0;
_timeout = tmp->nbr(); if ((tmp = object["error_pages"])) {
else JSONObject pages = tmp->obj();
_timeout = 0; for (JSONObject::iterator it = pages.begin(); it != pages.end(); it++) {
if ((tmp = object["keepalive_requests"])) JSONList err = (*it).second->lst();
_max_requests = tmp->nbr(); for (JSONList::iterator it2 = err.begin(); it2 != err.end(); it2++) _err_page[(*it2)->nbr()] = (*it).first;
else }
_max_requests = 0; }
if ((tmp = object["error_pages"])) { if ((tmp = object["indexs"])) {
JSONObject pages = tmp->obj(); JSONList indexs = tmp->lst();
for (JSONObject::iterator it = pages.begin(); it != pages.end(); it++) { for (JSONList::iterator it = indexs.begin(); it < indexs.end(); it++) _indexs.push_back((*it)->str());
JSONList err = (*it).second->lst(); }
for (JSONList::iterator it2 = err.begin(); it2 != err.end(); it2++) if ((tmp = object["allowed_methods"])) {
_err_page[(*it2)->nbr()] = (*it).first; JSONList headers = tmp->lst();
} for (JSONList::iterator it = headers.begin(); it < headers.end(); it++) _allowed_methods.push_back((*it)->str());
} }
if ((tmp = object["indexs"])) { if ((tmp = object["cgi"])) {
JSONList indexs = tmp->lst(); JSONObject cgis = tmp->obj();
for (JSONList::iterator it = indexs.begin(); it < indexs.end(); it++) for (JSONObject::iterator it = cgis.begin(); it != cgis.end(); it++) _cgi[(*it).first] = (*it).second->str();
_indexs.push_back((*it)->str()); }
} if ((tmp = object["client_max_body_size"])) _client_max_body_size = tmp->nbr();
if ((tmp = object["allowed_methods"])) {
JSONList headers = tmp->lst();
for (JSONList::iterator it = headers.begin(); it < headers.end(); it++)
_allowed_methods.push_back((*it)->str());
}
if ((tmp = object["cgi"])) {
JSONObject cgis = tmp->obj();
for (JSONObject::iterator it = cgis.begin(); it != cgis.end(); it++)
_cgi[(*it).first] = (*it).second->str();
}
if ((tmp = object["client_max_body_size"]))
_client_max_body_size = tmp->nbr();
} }
/// @brief Destructor /// @brief Destructor
@ -84,41 +72,32 @@ string Route::getRoot(void) { return _root; }
* nothing for him. * nothing for him.
*/ */
string Route::getIndex(string uri, string path) { string Route::getIndex(string uri, string path) {
std::stringstream body, ret; std::stringstream body, ret;
DIR *dir; DIR *dir;
struct dirent *entry; struct dirent *entry;
struct stat info; struct stat info;
vec_string::iterator it; vec_string::iterator it;
if ((dir = opendir(path.c_str()))) { if ((dir = opendir(path.c_str()))) {
if (DEBUG) if (DEBUG) cout << "get index(): path=" << path << "\n";
cout << "get index(): path=" << path << "\n"; body << "<h3 style=\"text-align: center;\">" << path << " files :</h3>\n<ul>\n";
body << "<h3 style=\"text-align: center;\">" << path while ((entry = readdir(dir)) != NULL) {
<< " files :</h3>\n<ul>\n"; if (entry->d_name[0] == '.') continue;
while ((entry = readdir(dir)) != NULL) { for (it = _indexs.begin(); it < _indexs.end(); it++) {
if (entry->d_name[0] == '.') if (entry->d_name == *it) return (file_answer(path + "/" + *it));
continue; }
for (it = _indexs.begin(); it < _indexs.end(); it++) { body << "<li><a href=\"" << uri + "/" + entry->d_name << "\">" << entry->d_name << "</a></li>\n";
if (entry->d_name == *it) if (stat(path.c_str(), &info) != 0) std::cerr << "stat() error on " << path << ": " << strerror(errno) << "\n";
return (file_answer(path + "/" + *it)); }
} body << "</ul>";
body << "<li><a href=\"" << uri + "/" + entry->d_name << "\">" closedir(dir);
<< entry->d_name << "</a></li>\n"; }
if (stat(path.c_str(), &info) != 0) if (!dir || !_autoindex) return "";
std::cerr << "stat() error on " << path << ": " << strerror(errno) if (DEBUG) cout << "Getting autoindex\n";
<< "\n"; ret << "Content-type: text/html \r\n";
} ret << "Content-length: " << body.str().length() << "\r\n";
body << "</ul>"; ret << "\r\n" << body.str();
closedir(dir); return ret.str();
}
if (!dir || !_autoindex)
return "";
if (DEBUG)
cout << "Getting autoindex\n";
ret << "Content-type: text/html \r\n";
ret << "Content-length: " << body.str().length() << "\r\n";
ret << "\r\n" << body.str();
return ret.str();
} }
/** /**
@ -130,22 +109,18 @@ string Route::getIndex(string uri, string path) {
* @deprecated Not used by nginx until config use rewrite keyword. * @deprecated Not used by nginx until config use rewrite keyword.
*/ */
string Route::correctUri(string uri) { string Route::correctUri(string uri) {
std::stringstream ret; std::stringstream ret;
vec_string::iterator loc_word, uri_word; vec_string::iterator loc_word, uri_word;
vec_string loc_words = split(_location, "/"); vec_string loc_words = split(_location, "/");
vec_string uri_words = split(uri, "/"); vec_string uri_words = split(uri, "/");
uri_word = uri_words.begin(); uri_word = uri_words.begin();
for (loc_word = loc_words.begin(); loc_word < loc_words.end(); loc_word++) { for (loc_word = loc_words.begin(); loc_word < loc_words.end(); loc_word++) {
while (uri_word < uri_words.end() && *uri_word == "") while (uri_word < uri_words.end() && *uri_word == "") uri_word++;
uri_word++; while (loc_word < loc_words.end() && *loc_word == "") loc_word++;
while (loc_word < loc_words.end() && *loc_word == "") if (loc_word != loc_words.end()) uri_word++;
loc_word++; }
if (loc_word != loc_words.end()) ret << "./" << _root;
uri_word++; while (uri_word < uri_words.end()) ret << "/" << *(uri_word++);
} return ret.str();
ret << "./" << _root;
while (uri_word < uri_words.end())
ret << "/" << *(uri_word++);
return ret.str();
} }

544
srcs/sock/Client.cpp
View File

@ -11,260 +11,216 @@
#include <iostream> #include <iostream>
inline string get_extension(string str) { inline string get_extension(string str) {
size_t pos = str.rfind('.'); size_t pos = str.rfind('.');
if (pos != string::npos) if (pos != string::npos) return str.substr(pos);
return str.substr(pos); else return "";
else
return "";
} }
Client::Client(int fd, ip_port_t ip_port, Master *parent) Client::Client(int fd, ip_port_t ip_port, Master *parent) : _fd(fd), _ip_port(ip_port), _parent(parent) {
: _fd(fd), _ip_port(ip_port), _parent(parent) { _requests_done = 0;
_requests_done = 0; _death_time = 0;
_death_time = 0; _finish = false;
_finish = false; _route = NULL;
_route = NULL; _server = NULL;
_server = NULL; init();
init(); if (!SILENT)
if (!SILENT) cout << "New connection, socket fd is " << fd << ", ip is : " << _ip_port.ip << ", port : " << _ip_port.port
cout << "New connection, socket fd is " << fd << ", ip is : " << _ip_port.ip << "\n";
<< ", port : " << _ip_port.port << "\n";
} }
Client::~Client(void) { Client::~Client(void) {
close(_fd); close(_fd);
Master::_pollfds[_poll_id].fd = 0; Master::_pollfds[_poll_id].fd = 0;
Master::_pollfds[_poll_id].events = 0; Master::_pollfds[_poll_id].events = 0;
Master::_pollfds[_poll_id].revents = 0; Master::_pollfds[_poll_id].revents = 0;
Master::_poll_id_amount--; Master::_poll_id_amount--;
_headers.clear(); _headers.clear();
if (!SILENT) if (!SILENT) cout << "Host disconnected, ip " << _ip_port.ip << ", port " << _ip_port.port << "\n";
cout << "Host disconnected, ip " << _ip_port.ip << ", port "
<< _ip_port.port << "\n";
} }
void Client::init(void) { void Client::init(void) {
_requests_done++; _requests_done++;
if (_route && _route->_max_requests > 0) { if (_route && _route->_max_requests > 0) {
if (_requests_done > _route->_max_requests) if (_requests_done > _route->_max_requests) _finish = true;
_finish = true; } else if (_server && _server->_max_requests > 0) {
} else if (_server && _server->_max_requests > 0) { if (_requests_done > _server->_max_requests) _finish = true;
if (_requests_done > _server->_max_requests) }
_finish = true; _method = _uri = _host = _header = _body = "";
} _len = 0;
_method = _uri = _host = _header = _body = ""; _last_chunk = false;
_len = 0; _headers.clear();
_last_chunk = false;
_headers.clear();
} }
template <typename T> void tab(T t, const int &width) { template <typename T> void tab(T t, const int &width) {
std::cout << std::left << std::setw(width) << std::setfill(' ') << t; std::cout << std::left << std::setw(width) << std::setfill(' ') << t;
} }
void Client::debug(bool head) { void Client::debug(bool head) {
if (head) { if (head) {
std::cout << "Client " << _poll_id std::cout << "Client " << _poll_id << " debug ===================================\n";
<< " debug ===================================\n"; tab("Fd", 4);
tab("Fd", 4); tab("Ip", 12);
tab("Ip", 12); tab("Port", 6);
tab("Port", 6); tab("Servername", 12);
tab("Servername", 12); tab("Route", 12);
tab("Route", 12); tab("Method", 6);
tab("Method", 6); tab("URI", 20);
tab("URI", 20); tab("Query", 12);
tab("Query", 12); tab("Host", 12);
tab("Host", 12); tab("Len", 6);
tab("Len", 6); tab("Keep", 4);
tab("Keep", 4); tab("Death", 6);
tab("Death", 6); tab("Request", 6);
tab("Request", 6); tab("Finish", 6);
tab("Finish", 6); std::cout << "\n";
std::cout << "\n"; }
} tab(_fd, 4);
tab(_fd, 4); tab(_ip_port.ip, 12);
tab(_ip_port.ip, 12); tab(_ip_port.port, 6);
tab(_ip_port.port, 6); tab(_server->getName(), 12);
tab(_server->getName(), 12); tab(_route->getLocation(), 12);
tab(_route->getLocation(), 12); tab(_method, 6);
tab(_method, 6); tab(_uri, 20);
tab(_uri, 20); tab(_query, 12);
tab(_query, 12); tab(_host, 12);
tab(_host, 12); tab(_len, 6);
tab(_len, 6); tab(_keepalive, 4);
tab(_keepalive, 4); tab(_death_time, 6);
tab(_death_time, 6); tab(_requests_done, 6);
tab(_requests_done, 6); tab(_finish, 6);
tab(_finish, 6); std::cout << "\n";
std::cout << "\n";
} }
bool Client::getRequest(Env *env, string paquet) { bool Client::getRequest(Env *env, string paquet) {
if (DEBUG) if (DEBUG) debug_block("Paquet: ", paquet);
debug_block("Paquet: ", paquet); if (header_pick("Method:", 0) != "") return getBody(paquet);
if (header_pick("Method:", 0) != "") vec_string lines = split(paquet, "\r\n");
return getBody(paquet); for (vec_string::iterator it = lines.begin(); it < lines.end(); it++) {
vec_string lines = split(paquet, "\r\n"); size_t pos = paquet.find("\r\n");
for (vec_string::iterator it = lines.begin(); it < lines.end(); it++) { if (pos != string::npos) paquet.erase(0, pos + 2);
size_t pos = paquet.find("\r\n"); else paquet.clear();
if (pos != string::npos) _header += *it + (it + 1 != lines.end() ? "\r\n" : "");
paquet.erase(0, pos + 2); if (_header.find("\r\n\r\n") != string::npos)
else return !parseHeader(env) ? false : (_len != 0 ? getBody(paquet) : true);
paquet.clear(); }
_header += *it + (it + 1 != lines.end() ? "\r\n" : ""); return false;
if (_header.find("\r\n\r\n") != string::npos)
return !parseHeader(env) ? false : (_len != 0 ? getBody(paquet) : true);
}
return false;
} }
bool Client::getBody(string paquet) { bool Client::getBody(string paquet) {
vec_string lines = split(paquet, "\r\n"); vec_string lines = split(paquet, "\r\n");
vec_string::iterator it; vec_string::iterator it;
for (it = lines.begin(); it < lines.end(); it++) { for (it = lines.begin(); it < lines.end(); it++) {
if (DEBUG) if (DEBUG) cout << "Remaining length: " << _len << "\n";
cout << "Remaining length: " << _len << "\n"; if ((*it).length() && _len <= 0 && header_pick("Transfer-Encoding:", 0) == "chunked") {
if ((*it).length() && _len <= 0 && _len = std::strtol((*it).c_str(), 0, 16) + 2;
header_pick("Transfer-Encoding:", 0) == "chunked") { _last_chunk = _len == 2 ? true : false;
_len = std::strtol((*it).c_str(), 0, 16) + 2; } else if (_len > 0 || it != lines.begin()) {
_last_chunk = _len == 2 ? true : false; _body += *it + "\r\n";
} else if (_len > 0 || it != lines.begin()) { _len -= ((*it).length() + 2);
_body += *it + "\r\n"; }
_len -= ((*it).length() + 2); }
} // if (_body.size())
} _body.resize(_body.length() - 2);
// if (_body.size()) _len += 2;
_body.resize(_body.length() - 2); return (_last_chunk && _len == 0) ? true : false;
_len += 2;
return (_last_chunk && _len == 0) ? true : false;
} }
bool Client::parseHeader(Env *env) { bool Client::parseHeader(Env *env) {
vec_string lines, method, line; vec_string lines, method, line;
if (DEBUG) if (DEBUG) cout << "Parsing header...\n";
cout << "Parsing header...\n"; lines = split(_header, "\r\n");
lines = split(_header, "\r\n"); method = split(lines.at(0), " ");
method = split(lines.at(0), " "); _headers["Method:"] = method;
_headers["Method:"] = method; if (lines.size() > 0) {
if (lines.size() > 0) { for (vec_string::iterator it = lines.begin() + 1; it < lines.end(); it++) {
for (vec_string::iterator it = lines.begin() + 1; it < lines.end(); it++) { line = split(*it, " ");
line = split(*it, " "); _headers[line.at(0)] = vec_string(line.begin() + 1, line.end());
_headers[line.at(0)] = vec_string(line.begin() + 1, line.end()); }
} }
} _method = header_pick("Method:", 0);
_method = header_pick("Method:", 0); if ((_method == "POST" || _method == "PUT") && header_pick("Content-Length:", 0) == "" &&
if ((_method == "POST" || _method == "PUT") && header_pick("Transfer-Encoding:", 0) != "chunked")
header_pick("Content-Length:", 0) == "" && return (send_error(400), false);
header_pick("Transfer-Encoding:", 0) != "chunked") vec_string uri_split = split(header_pick("Method:", 1), "?");
return (send_error(400), false); _uri = uri_split.at(0);
vec_string uri_split = split(header_pick("Method:", 1), "?"); if (uri_split.size() > 1) _query = uri_split.at(1);
_uri = uri_split.at(0); _host = header_pick("Host:", 0);
if (uri_split.size() > 1) _keepalive = header_pick("Connection:", 0) == "keep-alive";
_query = uri_split.at(1); _env = env;
_host = header_pick("Host:", 0); struct timeval t;
_keepalive = header_pick("Connection:", 0) == "keep-alive"; gettimeofday(&t, NULL);
_env = env; _server = _parent->choose_server(env, _host);
struct timeval t; if (_server->_timeout) _death_time = _server->_timeout + t.tv_sec;
gettimeofday(&t, NULL); _route = _server->choose_route(_uri);
_server = _parent->choose_server(env, _host); if (_route->_timeout) _death_time = _route->_timeout + t.tv_sec;
if (_server->_timeout) if (DEBUG) debug_header();
_death_time = _server->_timeout + t.tv_sec; string len = header_pick("Content-Length:", 0).c_str();
_route = _server->choose_route(_uri); if (len != "") {
if (_route->_timeout) _len = std::atoi(len.c_str());
_death_time = _route->_timeout + t.tv_sec; _last_chunk = true;
if (DEBUG) int max_len = _route->_client_max_body_size > 0 ? _route->_client_max_body_size
debug_header(); : _server->_client_max_body_size > 0 ? _server->_client_max_body_size
string len = header_pick("Content-Length:", 0).c_str(); : INT_MAX;
if (len != "") { if (_len > max_len) return (send_error(413), false);
_len = std::atoi(len.c_str()); } else _len = 0;
_last_chunk = true; return true;
int max_len =
_route->_client_max_body_size > 0 ? _route->_client_max_body_size
: _server->_client_max_body_size > 0 ? _server->_client_max_body_size
: INT_MAX;
if (_len > max_len)
return (send_error(413), false);
} else
_len = 0;
return true;
} }
string Client::header_pick(string key, size_t id) { string Client::header_pick(string key, size_t id) { return _headers[key].size() <= id ? "" : _headers[key].at(id); }
return _headers[key].size() <= id ? "" : _headers[key].at(id);
}
bool Client::check_method(void) { bool Client::check_method(void) {
vec_string allowed; vec_string allowed;
if ((_route && (allowed = _route->_allowed_methods).size() > 0) || if ((_route && (allowed = _route->_allowed_methods).size() > 0) ||
(_server && (allowed = _server->_allowed_methods).size() > 0) || (_server && (allowed = _server->_allowed_methods).size() > 0) || ((allowed = _env->_allowed_methods).size() > 0))
((allowed = _env->_allowed_methods).size() > 0)) return std::find(allowed.begin(), allowed.end(), _method) < allowed.end() ? true : false;
return std::find(allowed.begin(), allowed.end(), _method) < allowed.end() else if (_method == "GET" || _method == "POST" || _method == "DELETE" || _method == "PUT") return (true);
? true return (false);
: false;
else if (_method == "GET" || _method == "POST" || _method == "DELETE" ||
_method == "PUT")
return (true);
return (false);
} }
void Client::handleRequest(void) { void Client::handleRequest(void) {
if (DEBUG) { if (DEBUG) {
debug_block("Header: ", _header); debug_block("Header: ", _header);
debug_block("Body: ", _body); debug_block("Body: ", _body);
} }
if (_route->_ret_uri != "") if (_route->_ret_uri != "") send_error(_route->_ret_code, _route->_ret_uri);
send_error(_route->_ret_code, _route->_ret_uri); else if (_server->_ret_uri != "") send_error(_server->_ret_code, _server->_ret_uri);
else if (_server->_ret_uri != "") else {
send_error(_server->_ret_code, _server->_ret_uri); string ret;
else { struct timeval t;
string ret; gettimeofday(&t, NULL);
struct timeval t; if (_death_time && t.tv_sec > _death_time) {
gettimeofday(&t, NULL); send_error(408);
if (_death_time && t.tv_sec > _death_time) { _finish = true;
send_error(408); return;
_finish = true; }
return; string req_path = _route->getRoot() + _uri;
} if (!SILENT) std::cout << "||-> Request for " << req_path << " received <-||\n";
string req_path = _route->getRoot() + _uri; string cgi_path = _route->_cgi.size() ? _route->_cgi[get_extension(req_path)]
if (!SILENT) : _server->_cgi.size() ? _server->_cgi[get_extension(req_path)]
std::cout << "||-> Request for " << req_path << " received <-||\n"; : "";
string cgi_path = if (DEBUG) cout << "Path: " << req_path << "\n";
_route->_cgi.size() ? _route->_cgi[get_extension(req_path)] if (!check_method()) send_error(405);
: _server->_cgi.size() ? _server->_cgi[get_extension(req_path)] else {
: ""; if ((ret = _route->getIndex(_uri, req_path)) == "") ret = file_answer(req_path);
if (DEBUG) if (ret == "404") {
cout << "Path: " << req_path << "\n"; if (_method == "POST" || _method == "PUT") create_file(req_path);
if (!check_method()) else send_error(404);
send_error(405); } else if (ret == "403") send_error(403);
else { else if (_method == "DELETE") std::remove(req_path.c_str());
if ((ret = _route->getIndex(_uri, req_path)) == "") else if (cgi_path != "") cgi(cgi_path, req_path);
ret = file_answer(req_path); else send_answer("HTTP/1.1 200 OK\r\n" + ret);
if (ret == "404") { }
if (_method == "POST" || _method == "PUT") }
create_file(req_path);
else
send_error(404);
} else if (ret == "403")
send_error(403);
else if (_method == "DELETE")
std::remove(req_path.c_str());
else if (cgi_path != "")
cgi(cgi_path, req_path);
else
send_answer("HTTP/1.1 200 OK\r\n" + ret);
}
}
} }
void Client::create_file(string path) { void Client::create_file(string path) {
std::ofstream file(path.c_str()); std::ofstream file(path.c_str());
if (!file.good()) if (!file.good()) send_error(403);
send_error(403); else {
else { file << _body;
file << _body; file.close();
file.close(); send_answer("HTTP/1.1 201 Accepted\r\n\r\n");
send_answer("HTTP/1.1 201 Accepted\r\n\r\n"); }
}
} }
/** /**
@ -275,38 +231,35 @@ void Client::create_file(string path) {
* @param path The path to the file requested. * @param path The path to the file requested.
*/ */
void Client::cgi(string cgi_path, string path) { void Client::cgi(string cgi_path, string path) {
int pipe_in[2]; int pipe_in[2];
send(_fd, "HTTP/1.1 200 OK\r\n", 17, MSG_NOSIGNAL); send(_fd, "HTTP/1.1 200 OK\r\n", 17, MSG_NOSIGNAL);
if (!std::ifstream(cgi_path.c_str()).good()) if (!std::ifstream(cgi_path.c_str()).good()) return send_error(404);
return send_error(404); if (DEBUG) std::cout << "Send cgi\n";
if (DEBUG) if (fork() == 0) {
std::cout << "Send cgi\n"; const char **args = new const char *[cgi_path.length() + 1];
if (fork() == 0) { args[0] = cgi_path.c_str();
const char **args = new const char *[cgi_path.length() + 1]; args[1] = NULL;
args[0] = cgi_path.c_str(); string path_info = "PATH_INFO=" + _route->getRoot();
args[1] = NULL; string query = "QUERY_STRING=" + _query;
string path_info = "PATH_INFO=" + _route->getRoot(); const char **env = new const char *[path_info.length() + query.length() + 2];
string query = "QUERY_STRING=" + _query; env[0] = path_info.c_str();
const char **env = env[1] = query.c_str();
new const char *[path_info.length() + query.length() + 2]; env[2] = NULL;
env[0] = path_info.c_str(); pipe(pipe_in);
env[1] = query.c_str(); std::stringstream tmp;
env[2] = NULL; tmp << std::ifstream(path.c_str()).rdbuf();
pipe(pipe_in); string file = tmp.str();
std::stringstream tmp; write(pipe_in[1], file.c_str(), file.size());
tmp << std::ifstream(path.c_str()).rdbuf(); close(pipe_in[1]);
string file = tmp.str(); dup2(pipe_in[0], STDIN_FILENO);
write(pipe_in[1], file.c_str(), file.size()); close(pipe_in[0]);
close(pipe_in[1]); dup2(_fd, STDOUT_FILENO);
dup2(pipe_in[0], STDIN_FILENO); close(_fd);
close(pipe_in[0]); execve(cgi_path.c_str(), (char **)args, (char **)env);
dup2(_fd, STDOUT_FILENO); exit(1);
close(_fd); }
execve(cgi_path.c_str(), (char **)args, (char **)env); _finish = true;
exit(1);
}
_finish = true;
} }
/** /**
@ -315,50 +268,39 @@ void Client::cgi(string cgi_path, string path) {
* @param error_code The HTTP response code to send. * @param error_code The HTTP response code to send.
*/ */
void Client::send_error(int error_code, string opt) { void Client::send_error(int error_code, string opt) {
string error_path, body; string error_path, body;
error_path = _route->_err_page[error_code]; error_path = _route->_err_page[error_code];
if (error_path == "") { if (error_path == "") {
error_path = _server->_err_page[error_code]; error_path = _server->_err_page[error_code];
if (error_path != "") if (error_path != "") body = file_answer(_server->correctUri(error_path));
body = file_answer(_server->correctUri(error_path)); } else body = file_answer(_route->correctUri(error_path));
} else
body = file_answer(_route->correctUri(error_path));
switch (error_code) { switch (error_code) {
case 301: case 301:
return send_answer("HTTP/1.1 301 Moved Permanently\r\nLocation: " + opt + return send_answer("HTTP/1.1 301 Moved Permanently\r\nLocation: " + opt + "\r\n" + body + "\r\n");
"\r\n" + body + "\r\n"); case 302:
case 302: return send_answer("HTTP/1.1 302 Found\r\nLocation: " + opt + "\r\n" + body + "\r\n");
return send_answer("HTTP/1.1 302 Found\r\nLocation: " + opt + "\r\n" + case 307:
body + "\r\n"); return send_answer("HTTP/1.1 307 Temporary Redirect\r\nLocation: " + opt + "\r\n" + body + "\r\n");
case 307: case 308:
return send_answer("HTTP/1.1 307 Temporary Redirect\r\nLocation: " + opt + return send_answer("HTTP/1.1 308 Permanent Redirect\r\nLocation: " + opt + "\r\n" + body + "\r\n");
"\r\n" + body + "\r\n"); case 400:
case 308: return send_answer("HTTP/1.1 400 Bad Request\r\n" + body + "\r\n");
return send_answer("HTTP/1.1 308 Permanent Redirect\r\nLocation: " + opt + case 403:
"\r\n" + body + "\r\n"); return send_answer("HTTP/1.1 403 Forbidden\r\n" + body + "\r\n");
case 400: case 404:
return send_answer("HTTP/1.1 400 Bad Request\r\n" + body + "\r\n"); return send_answer("HTTP/1.1 404 Not Found\r\n" + body + "\r\n");
case 403: case 405:
return send_answer("HTTP/1.1 403 Forbidden\r\n" + body + "\r\n"); return send_answer("HTTP/1.1 405 Method Not Allowed\r\nConnection: "
case 404: "close\r\n" +
return send_answer("HTTP/1.1 404 Not Found\r\n" + body + "\r\n"); body + "\r\n");
case 405: case 408:
return send_answer("HTTP/1.1 405 Method Not Allowed\r\nConnection: " return send_answer("HTTP/1.1 408 Request Timeout\r\nConnection: close\r\n" + body + "\r\n");
"close\r\n" + case 413:
body + "\r\n"); return send_answer("HTTP/1.1 413 Payload Too Large\r\nConnection: close\r\n" + body + "\r\n");
case 408: case 429:
return send_answer("HTTP/1.1 408 Request Timeout\r\nConnection: close\r\n" + return send_answer("HTTP/1.1 429 Too Many Requests\r\nConnection: close\r\n" + body + "\r\n");
body + "\r\n"); }
case 413:
return send_answer(
"HTTP/1.1 413 Payload Too Large\r\nConnection: close\r\n" + body +
"\r\n");
case 429:
return send_answer(
"HTTP/1.1 429 Too Many Requests\r\nConnection: close\r\n" + body +
"\r\n");
}
} }
/** /**
@ -367,14 +309,12 @@ void Client::send_error(int error_code, string opt) {
* @param msg The HTTP message to send. * @param msg The HTTP message to send.
*/ */
void Client::send_answer(string msg) { void Client::send_answer(string msg) {
if (DEBUG) if (DEBUG) debug_block("ANSWER: ", msg);
debug_block("ANSWER: ", msg);
#ifdef __linux__ #ifdef __linux__
send(_fd, msg.c_str(), msg.length(), MSG_NOSIGNAL); send(_fd, msg.c_str(), msg.length(), MSG_NOSIGNAL);
#elif __APPLE__ #elif __APPLE__
write(_fd, msg.c_str(), msg.length()); write(_fd, msg.c_str(), msg.length());
#endif #endif
init(); init();
if (!_keepalive) if (!_keepalive) _finish = true;
_finish = true;
} }

218
srcs/sock/Master.cpp
View File

@ -11,9 +11,8 @@
* @brief Destructor Close master socket descriptor. * @brief Destructor Close master socket descriptor.
*/ */
Master::~Master(void) { Master::~Master(void) {
close(_fd); close(_fd);
if (DEBUG) if (DEBUG) cout << "Destroyed master socket\n";
cout << "Destroyed master socket\n";
} }
/** /**
@ -26,67 +25,58 @@ Master::~Master(void) {
* listen. * listen.
*/ */
Master::Master(ip_port_t list) : _listen(list) { Master::Master(ip_port_t list) : _listen(list) {
int x = 1, port = _listen.port; int x = 1, port = _listen.port;
string ip = _listen.ip; string ip = _listen.ip;
_fd = socket(AF_INET, SOCK_STREAM, 0); _fd = socket(AF_INET, SOCK_STREAM, 0);
if (_fd == 0) if (_fd == 0) throw std::runtime_error("socket() error" + string(strerror(errno)));
throw std::runtime_error("socket() error" + string(strerror(errno))); if (setsockopt(_fd, SOL_SOCKET, SO_REUSEADDR, (char *)&x, sizeof(x)) < 0 && close(_fd) <= 0)
if (setsockopt(_fd, SOL_SOCKET, SO_REUSEADDR, (char *)&x, sizeof(x)) < 0 && throw std::runtime_error("setsockopt() error: " + string(strerror(errno)));
close(_fd) <= 0) _address.sin_family = AF_INET;
throw std::runtime_error("setsockopt() error: " + string(strerror(errno))); _address.sin_addr.s_addr = inet_addr(ip.c_str());
_address.sin_family = AF_INET; _address.sin_port = htons(port);
_address.sin_addr.s_addr = inet_addr(ip.c_str()); if (bind(_fd, (struct sockaddr *)&_address, sizeof(_address)) && close(_fd) <= 0)
_address.sin_port = htons(port); throw std::runtime_error("bind() error: " + string(strerror(errno)));
if (bind(_fd, (struct sockaddr *)&_address, sizeof(_address)) && if (listen(_fd, 3) < 0 && close(_fd) <= 0) throw std::runtime_error("listen() error: " + string(strerror(errno)));
close(_fd) <= 0)
throw std::runtime_error("bind() error: " + string(strerror(errno)));
if (listen(_fd, 3) < 0 && close(_fd) <= 0)
throw std::runtime_error("listen() error: " + string(strerror(errno)));
#ifdef __APPLE__ #ifdef __APPLE__
fcntl(socket, F_SETFL, O_NONBLOCK); fcntl(socket, F_SETFL, O_NONBLOCK);
#endif #endif
cout << "New master socket with fd " << _fd << " which listen " << ip << ":" cout << "New master socket with fd " << _fd << " which listen " << ip << ":" << port << "\n";
<< port << "\n"; _pollfds[_poll_id_amount].fd = _fd;
_pollfds[_poll_id_amount].fd = _fd; _pollfds[_poll_id_amount].events = POLLIN | POLLPRI;
_pollfds[_poll_id_amount].events = POLLIN | POLLPRI; _poll_id = _poll_id_amount;
_poll_id = _poll_id_amount; _poll_id_amount++;
_poll_id_amount++;
} }
/** /**
* @brief Check master and his clients sockets after poll performed. * @brief Check master and his clients sockets after poll performed.
*/ */
void Master::check_socket(void) { void Master::check_socket(void) {
int addrlen = sizeof(_address); int addrlen = sizeof(_address);
if (_pollfds[_poll_id].revents & POLLIN) { /// < incomming master request if (_pollfds[_poll_id].revents & POLLIN) { /// < incomming master request
int new_socket = int new_socket = accept(_fd, (struct sockaddr *)&_address, (socklen_t *)&addrlen);
accept(_fd, (struct sockaddr *)&_address, (socklen_t *)&addrlen); if (new_socket < 0) throw std::runtime_error("accept() error:" + string(strerror(errno)));
if (new_socket < 0)
throw std::runtime_error("accept() error:" + string(strerror(errno)));
#ifdef __APPLE__ #ifdef __APPLE__
fcntl(new_socket, F_SETFL, O_NONBLOCK); fcntl(new_socket, F_SETFL, O_NONBLOCK);
#endif #endif
ip_port_t cli_listen = ip_port_t cli_listen = get_ip_port_t(inet_ntoa(_address.sin_addr), ntohs(_address.sin_port));
get_ip_port_t(inet_ntoa(_address.sin_addr), ntohs(_address.sin_port)); Client *new_cli = new Client(new_socket, cli_listen, this);
Client *new_cli = new Client(new_socket, cli_listen, this); if (_poll_id_amount > MAX_CLIENTS) {
if (_poll_id_amount > MAX_CLIENTS) { new_cli->send_error(503);
new_cli->send_error(503); delete new_cli;
delete new_cli; } else {
} else { _childs.push_back(new_cli);
_childs.push_back(new_cli); for (int i = _first_cli_id; i < MAX_CLIENTS; i++) {
for (int i = _first_cli_id; i < MAX_CLIENTS; i++) { if (_pollfds[i].fd != 0) continue;
if (_pollfds[i].fd != 0) _pollfds[i].fd = new_socket;
continue; _pollfds[i].events = POLLIN | POLLPRI;
_pollfds[i].fd = new_socket; new_cli->_poll_id = i;
_pollfds[i].events = POLLIN | POLLPRI; _poll_id_amount++;
new_cli->_poll_id = i; break;
_poll_id_amount++; }
break; }
} }
}
}
} }
/** /**
@ -101,31 +91,29 @@ void Master::check_socket(void) {
* @param env The environment object. * @param env The environment object.
*/ */
void Master::check_childs(Env *env) { void Master::check_childs(Env *env) {
int child_fd; int child_fd;
for (std::vector<Client *>::iterator it = _childs.begin(); it < _childs.end(); for (std::vector<Client *>::iterator it = _childs.begin(); it < _childs.end(); it++) {
it++) { child_fd = (*it)->_fd;
child_fd = (*it)->_fd; int i = (*it)->_poll_id;
int i = (*it)->_poll_id; if (_pollfds[i].fd > 0 && _pollfds[i].revents & POLLIN) {
if (_pollfds[i].fd > 0 && _pollfds[i].revents & POLLIN) { char buffer[1024];
char buffer[1024]; int valread = read(child_fd, buffer, 1023);
int valread = read(child_fd, buffer, 1023); buffer[valread] = '\0';
buffer[valread] = '\0'; if (valread == 0) {
if (valread == 0) { delete (*it);
delete (*it); _childs.erase(it);
_childs.erase(it); } else if ((*it)->getRequest(env, buffer)) {
} else if ((*it)->getRequest(env, buffer)) { (*it)->debug(true);
(*it)->debug(true); (*it)->handleRequest();
(*it)->handleRequest(); _pollfds[i].events = POLLIN | POLLPRI | POLLOUT;
_pollfds[i].events = POLLIN | POLLPRI | POLLOUT; (*it)->debug(false);
(*it)->debug(false); if ((*it)->_finish) {
if ((*it)->_finish) { delete (*it);
delete (*it); _childs.erase(it);
_childs.erase(it); }
} } else _pollfds[i].events = POLLIN | POLLPRI;
} else }
_pollfds[i].events = POLLIN | POLLPRI; }
}
}
} }
/** /**
@ -147,48 +135,38 @@ void Master::check_childs(Env *env) {
* @return The server object choosen to handle the request. * @return The server object choosen to handle the request.
*/ */
Server *Master::choose_server(Env *env, string host) { Server *Master::choose_server(Env *env, string host) {
std::vector<Server *> exact, inrange; std::vector<Server *> exact, inrange;
vec_string ip_listen, ip_required; vec_string ip_listen, ip_required;
ip_required = split(_listen.ip, "."); ip_required = split(_listen.ip, ".");
for (std::vector<Server *>::iterator server = env->_servers.begin(); for (std::vector<Server *>::iterator server = env->_servers.begin(); server < env->_servers.end(); server++) {
server < env->_servers.end(); server++) { std::vector<ip_port_t> serv_listens = (*server)->_listens;
std::vector<ip_port_t> serv_listens = (*server)->_listens; for (std::vector<ip_port_t>::iterator it = serv_listens.begin(); it < serv_listens.end(); it++) {
for (std::vector<ip_port_t>::iterator it = serv_listens.begin(); if (_listen.port != (*it).port) continue;
it < serv_listens.end(); it++) { if (_listen.ip == (*it).ip) {
if (_listen.port != (*it).port) exact.push_back(*server);
continue; continue;
if (_listen.ip == (*it).ip) { }
exact.push_back(*server); bool is_inrange = true;
continue; ip_listen = split((*it).ip, ".");
} vec_string::iterator r = ip_required.end();
bool is_inrange = true; vec_string::iterator l = ip_listen.end();
ip_listen = split((*it).ip, "."); while (r > ip_required.begin()) {
vec_string::iterator r = ip_required.end(); if (*(--l) != *(--r) && *l != "0") is_inrange = false;
vec_string::iterator l = ip_listen.end(); }
while (r > ip_required.begin()) { if (is_inrange) inrange.push_back(*server);
if (*(--l) != *(--r) && *l != "0") }
is_inrange = false; }
} if (DEBUG) std::cout << "req: " << _listen.ip << ":" << _listen.port << "\n";
if (is_inrange) if (exact.size() == 0) {
inrange.push_back(*server); for (std::vector<Server *>::iterator server = inrange.begin(); server < inrange.end(); server++) {
} if (host == (*server)->getName()) return *server;
} }
if (DEBUG) return inrange.front();
std::cout << "req: " << _listen.ip << ":" << _listen.port << "\n"; } else {
if (exact.size() == 0) { for (std::vector<Server *>::iterator server = exact.begin(); server < exact.end(); server++) {
for (std::vector<Server *>::iterator server = inrange.begin(); if (host == (*server)->getName()) return *server;
server < inrange.end(); server++) { }
if (host == (*server)->getName()) return exact.front();
return *server; }
}
return inrange.front();
} else {
for (std::vector<Server *>::iterator server = exact.begin();
server < exact.end(); server++) {
if (host == (*server)->getName())
return *server;
}
return exact.front();
}
} }

Write Preview
Loading…
Cancel
Save