468 lines
13 KiB
C++
468 lines
13 KiB
C++
|
|
#include "Client.hpp"
|
|
|
|
/*********************************************
|
|
* COPLIENS
|
|
*********************************************/
|
|
|
|
Client::Client()
|
|
: status(0),
|
|
header_complete(false),
|
|
body_complete(false),
|
|
request_complete(false),
|
|
read_body_size(0),
|
|
assigned_server(NULL),
|
|
assigned_location(NULL),
|
|
_fd(0),
|
|
_port(""),
|
|
_ip(""),
|
|
_lsocket(NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
Client::Client(int afd, listen_socket *lsocket, std::string aport, std::string aip)
|
|
: status(0),
|
|
header_complete(false),
|
|
body_complete(false),
|
|
request_complete(false),
|
|
read_body_size(0),
|
|
assigned_server(NULL),
|
|
assigned_location(NULL),
|
|
_fd(afd),
|
|
_port(aport),
|
|
_ip(aip),
|
|
_lsocket(lsocket)
|
|
{
|
|
return;
|
|
}
|
|
|
|
Client::~Client() {
|
|
return;
|
|
}
|
|
|
|
/* // WIP not sure fo what is more logic here
|
|
Client::Client( Client const & src )
|
|
: status ( src.status ),
|
|
header_complete ( src.header_complete ),
|
|
read_body_size ( src.read_body_size ),
|
|
assigned_server ( src.assigned_server ),
|
|
assigned_location ( src.assigned_location ),
|
|
_fd ( src._fd ),
|
|
_port ( src._port ),
|
|
_ip ( src._ip ),
|
|
_lsocket ( src._lsocket )
|
|
{
|
|
raw_request = src.raw_request;
|
|
response = src.response;
|
|
// buf = strdup(src.buf); // TODO: this doesn't work
|
|
return;
|
|
}
|
|
*/
|
|
|
|
/* // WIP placeholder because of const values
|
|
Client & Client::operator=( Client const & rhs )
|
|
{
|
|
if ( this != &rhs )
|
|
{
|
|
// stuff
|
|
}
|
|
return *this;
|
|
}
|
|
*/
|
|
|
|
/*********************************************
|
|
* PUBLIC MEMBER FUNCTIONS
|
|
*********************************************/
|
|
|
|
// http headers :
|
|
// https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers
|
|
// https://www.ibm.com/docs/en/cics-ts/5.3?topic=protocol-http-requests
|
|
// https://www.tutorialspoint.com/http/http_requests.htm
|
|
void Client::parse_request_headers(std::vector<ServerConfig> &servers)
|
|
{
|
|
if (raw_request.find(CRLF CRLF) == NPOS)
|
|
return ;
|
|
header_complete = true;
|
|
clear_request(); // not mandatory
|
|
|
|
_parse_request_line();
|
|
if (status)
|
|
return;
|
|
_parse_request_fields();
|
|
|
|
// DEBUG
|
|
// print_client("headers");
|
|
|
|
if (status)
|
|
return;
|
|
assigned_server = ::_determine_process_server(this, servers);
|
|
assigned_location = ::_determine_location(*assigned_server, _request.abs_path);
|
|
_check_request_errors();
|
|
if (status)
|
|
return;
|
|
_parse_port_hostname(this->get_rq_headers("Host")); // use getter for headers because it works case insensitive
|
|
|
|
// DEBUG
|
|
// std::cerr << get_rq_method_str() << " " << get_rq_target() << " " << get_rq_version() << "\n";
|
|
|
|
// dont clear raw_request, we need it for future reparsing of body
|
|
// see call of parse_request() in _read_request()
|
|
// raw_request.clear();
|
|
}
|
|
|
|
void Client::parse_request_body()
|
|
{
|
|
std::cerr << "parse_request_body()\n";
|
|
size_t pos;
|
|
|
|
pos = raw_request.find(CRLF CRLF);
|
|
if (pos == NPOS)
|
|
{
|
|
std::cerr << "parse_request_body() bad call, header incomplete\n";
|
|
// QUESTION from hugo : don't we change the status here ?
|
|
return;
|
|
}
|
|
pos += CRLF_SIZE*2;
|
|
|
|
// Chunked decoding WIP. Dont work.
|
|
if (!get_rq_headers("Transfer-Encoding").empty()
|
|
&& get_rq_headers("Transfer-Encoding") == "chunked")
|
|
{
|
|
size_t chunk_size = 1;
|
|
size_t chunk_field_end = 0;
|
|
char *endptr = NULL;
|
|
char *endptr_copy = NULL;
|
|
/* TODO: verify if last chunk in raw_request (to avoid multiples complete parsing)
|
|
but how ? with "raw_request.rfind("0" CRLF CRLF)", there no confirmation
|
|
that we have found the last last-chunk OR just some data */
|
|
|
|
_request.body = raw_request.substr(pos);
|
|
|
|
std::cerr << "______Chunked\n" << _request.body << "\n______\n";
|
|
pos = 0;
|
|
while (chunk_size != 0)
|
|
{
|
|
/* if (pos > _request.body.size())
|
|
{
|
|
std::cerr << "parse_request_body(), pos > size()\n";
|
|
// status = 400;
|
|
return;
|
|
} */
|
|
/*
|
|
if (pos == _request.body.size())
|
|
{
|
|
std::cerr << "parse_request_body(), will reread till last chunk\n";
|
|
return;
|
|
} */
|
|
|
|
/* endptr_copy = endptr; */
|
|
(void)endptr_copy;
|
|
chunk_size = std::strtoul(&_request.body[pos], &endptr, 16);
|
|
/* if (chunk_size == LONG_MAX && errno == ERANGE)
|
|
status = 413; */
|
|
/* if (endptr == endptr_copy)
|
|
{
|
|
std::cerr << "parse_request_body(), no conversion possible\n";
|
|
return;
|
|
} */
|
|
|
|
|
|
chunk_field_end = _request.body.find(CRLF, pos);
|
|
if (chunk_field_end == NPOS)
|
|
{
|
|
std::cerr << "parse_request_body(), chunk_field no CRLF\n";
|
|
// status = 400;
|
|
return;
|
|
}
|
|
|
|
chunk_field_end += CRLF_SIZE;
|
|
_request.body.erase(pos, chunk_field_end);
|
|
pos += chunk_size + CRLF_SIZE;
|
|
}
|
|
|
|
_request.headers.erase("Transfer-Encoding");
|
|
body_complete = true;
|
|
}
|
|
else
|
|
{
|
|
std::cerr << "Content-Length = " << std::strtoul(get_rq_headers("Content-Length").c_str(), NULL, 10) << "\n";
|
|
std::cerr << "raw_request.size() - pos = " << raw_request.size() - pos << "\n";
|
|
_request.body = raw_request.substr(pos);
|
|
std::cerr << "_request.body.size() = " << _request.body.size() << "\n";
|
|
|
|
if (raw_request.size() - pos >= std::strtoul(get_rq_headers("Content-Length").c_str(), NULL, 10))
|
|
{
|
|
_request.body = raw_request.substr(pos);
|
|
body_complete = true;
|
|
}
|
|
|
|
/* Should be equivalent */
|
|
// _request.body = raw_request.substr(pos);
|
|
// if (_request.body.size() >= std::strtoul(get_rq_headers("Content-Length").c_str(), NULL, 10))
|
|
// body_complete = true;
|
|
}
|
|
|
|
///////////////
|
|
// Body checks
|
|
if (_request.body.size() > assigned_server->client_body_limit)
|
|
status = 413; // HTTP Client Errors
|
|
}
|
|
|
|
// TODO HUGO : what if the root doesn't start with leading "." ?
|
|
void Client::fill_script_path(std::string &path, size_t pos)
|
|
{
|
|
std::string tmp;
|
|
|
|
// should start with "/"
|
|
// and being relative to the root :
|
|
// if the path to the script is "root/cgi-bin/cgi.php"
|
|
// the path relative to the root would be : /cgi-bin/cgi.php
|
|
// here we receive the path as : "./cgi-bin/cgi.php/optionnal"
|
|
// so we should remove the leading "."
|
|
/*DEBUG*/ std::cout << "\n" << B_PURPLE << "debug path dot" << RESET << "\npath:[" << path << "]\n" << "&path[pos]:[" << &path[pos] << "]\n";
|
|
if (path[0] == '.')
|
|
{
|
|
path.erase(0, 1);
|
|
pos--;
|
|
} /*DEBUG*/ std::cout << "path:[" << path << "]\n" << "&path[pos]:[" << &path[pos] << "]\n";
|
|
|
|
_request.script.path = path.substr(0, pos); /*DEBUG*/ std::cout << "script_path:[" << _request.script.path << "]\n";
|
|
_request.script.info = path.substr(pos); /*DEBUG*/ std::cout << "script_info:[" << _request.script.info << "]\n" << B_PURPLE << "end debug path dot" << RESET << "\n";
|
|
}
|
|
|
|
void Client::clear()
|
|
{
|
|
clear_request();
|
|
header_complete = false;
|
|
body_complete = false;
|
|
request_complete = false;
|
|
read_body_size = 0;
|
|
assigned_server = NULL;
|
|
assigned_location = NULL;
|
|
raw_request.clear();
|
|
response.clear();
|
|
status = 0;
|
|
}
|
|
|
|
void Client::clear_request()
|
|
{
|
|
clear_script();
|
|
_request.method = UNKNOWN;
|
|
_request.target.clear();
|
|
_request.version.clear();
|
|
_request.headers.clear();
|
|
_request.body.clear();
|
|
_request.abs_path.clear();
|
|
_request.query.clear();
|
|
_request.port.clear();
|
|
_request.hostname.clear();
|
|
}
|
|
|
|
void Client::clear_script()
|
|
{
|
|
_request.script.path.clear();
|
|
_request.script.info.clear();
|
|
}
|
|
|
|
// debug
|
|
void Client::print_client(std::string message)
|
|
{
|
|
std::map<std::string, std::string>::iterator it;
|
|
|
|
std::cout << "\n=== DEBUG PRINT CLIENT ===\n";
|
|
std::cout << message << ":\n----------\n\n" << "raw_request:\n__\n";
|
|
::print_special(raw_request);
|
|
std::cout << "\n__\n"
|
|
<< "get_cl_fd() : [" << get_cl_fd() << "]\n"
|
|
<< "get_cl_port() : [" << get_cl_port() << "]\n"
|
|
<< "get_cl_ip() : [" << get_cl_ip() << "]\n"
|
|
<< "get_rq_method_str() : [" << get_rq_method_str() << "]\n"
|
|
<< "get_rq_target() : [" << get_rq_target() << "]\n"
|
|
<< "get_rq_abs_path() : [" << get_rq_abs_path() << "]\n"
|
|
<< "get_rq_query() : [" << get_rq_query() << "]\n"
|
|
<< "get_rq_version() : [" << get_rq_version() << "]\n"
|
|
<< "get_rq_body() : [" << get_rq_body() << "]\n"
|
|
<< "get_rq_port() : [" << get_rq_port() << "]\n"
|
|
<< "get_rq_hostname() : [" << get_rq_hostname() << "]\n"
|
|
<< "get_rq_script_path() : [" << get_rq_script_path() << "]\n"
|
|
<< "get_rq_script_info() : [" << get_rq_script_info() << "]\n"
|
|
<< "headers :\n";
|
|
for (it = _request.headers.begin(); it != _request.headers.end(); it++)
|
|
std::cout << " " << it->first << ": [" << it->second << "]\n";
|
|
std::cout << "\n=== END PRINT CLIENT ===\n\n";
|
|
}
|
|
|
|
/*********************************************
|
|
* GETTERS
|
|
*********************************************/
|
|
|
|
// client side
|
|
int Client::get_cl_fd() const { return _fd; }
|
|
const std::string & Client::get_cl_ip() const { return _ip; }
|
|
const std::string & Client::get_cl_port() const { return _port; }
|
|
const listen_socket * Client::get_cl_lsocket() const { return _lsocket; }
|
|
|
|
// requette
|
|
http_method Client::get_rq_method() const { return _request.method; }
|
|
std::string Client::get_rq_method_str() const
|
|
{ return ::http_methods_to_str(_request.method); }
|
|
std::string Client::get_rq_target() const { return _request.target; }
|
|
std::string Client::get_rq_abs_path() const { return _request.abs_path; }
|
|
std::string Client::get_rq_query() const { return _request.query; }
|
|
std::string Client::get_rq_version() const { return _request.version; }
|
|
std::string Client::get_rq_body() const { return _request.body; }
|
|
std::string Client::get_rq_port() const { return _request.port; }
|
|
std::string Client::get_rq_hostname() const { return _request.hostname; }
|
|
std::string Client::get_rq_script_path()const { return _request.script.path; }
|
|
std::string Client::get_rq_script_info()const { return _request.script.info; }
|
|
|
|
std::string Client::get_rq_headers(const std::string & key) const
|
|
{
|
|
std::map<std::string, std::string>::const_iterator it;
|
|
|
|
it = _request.headers.find(::str_tolower(key));
|
|
if (it == _request.headers.end())
|
|
return "";
|
|
return it->second;
|
|
}
|
|
|
|
|
|
/*********************************************
|
|
* PRIVATE MEMBER FUNCTIONS
|
|
*********************************************/
|
|
|
|
void Client::_parse_request_line()
|
|
{
|
|
std::vector<std::string> line;
|
|
std::string raw_line;
|
|
|
|
raw_line = ::get_line(raw_request, 0, CRLF);
|
|
line = ::split_trim(raw_line, " ");
|
|
if (line.size() != 3)
|
|
{
|
|
std::cerr << "err _parse_first_line(): wrong number of elements (" << line.size() << " instead of 3)\n";
|
|
status = 400; // "bad request"
|
|
}
|
|
else
|
|
{
|
|
_request.method = str_to_http_method(line[0]);
|
|
_request.target = line[1];
|
|
_parse_request_target(line[1]);
|
|
_request.version = line[2];
|
|
}
|
|
}
|
|
|
|
void Client::_parse_request_target( std::string target )
|
|
{
|
|
size_t pos;
|
|
|
|
pos = target.find("?");
|
|
if (pos != NPOS)
|
|
_request.query = target.substr(pos + 1);
|
|
else
|
|
_request.query = "";
|
|
_request.abs_path = target.substr(0, pos);
|
|
}
|
|
|
|
void Client::_parse_request_fields()
|
|
{
|
|
std::string headers;
|
|
size_t pos;
|
|
int ret;
|
|
|
|
headers = raw_request;
|
|
// delete first line
|
|
pos = headers.find(CRLF);
|
|
if (pos != NPOS)
|
|
headers.erase(0, pos + std::string(CRLF).size());
|
|
// delete body part
|
|
pos = headers.find(CRLF CRLF);
|
|
if (pos != NPOS)
|
|
headers.erase(pos);
|
|
else {
|
|
std::cerr << "err _parse_request_fields(): request header doesn't end with empty line\n";
|
|
status = 400; // "bad request"
|
|
}
|
|
// copy result of parser into headers
|
|
ret = ::parse_http_headers(headers, _request.headers);
|
|
if (ret > 0) {
|
|
std::cerr << "err _parse_request_fields(): " << ret << " fields are bad formated\n";
|
|
status = 400; // "bad request"
|
|
}
|
|
::str_map_key_tolower(_request.headers);
|
|
}
|
|
|
|
void Client::_parse_port_hostname(std::string host)
|
|
{
|
|
size_t pos;
|
|
|
|
if (host == "")
|
|
std::cerr << "no host\n";
|
|
|
|
pos = host.find(':');
|
|
// port :
|
|
if (pos == NPOS)
|
|
_request.port = "4040"; // TODO: make equal to default port in config
|
|
else
|
|
_request.port = host.substr(pos);
|
|
if (_request.port == ":")
|
|
_request.port = "";
|
|
// hostname :
|
|
_request.hostname = host.substr(0, pos);
|
|
}
|
|
|
|
void Client::_check_request_errors()
|
|
{
|
|
///////////////////////
|
|
// Request line checks
|
|
if (_request.method == UNKNOWN)
|
|
status = 501; // HTTP Client Errors
|
|
else if (_request.version.compare(0, sizeof("HTTP/1") - 1, "HTTP/1") != 0)
|
|
status = 505; // HTTP Client Errors
|
|
else if (!(assigned_location->allow_methods & _request.method))
|
|
{
|
|
status = 405; // HTTP Client Errors
|
|
response.append("Allow: ");
|
|
response.append(::http_methods_to_str(assigned_location->allow_methods));
|
|
response.append(CRLF);
|
|
}
|
|
else if (assigned_location->redirect_status)
|
|
{ // Weird behavior. Sometimes, the web browser seems to wait for a complete response until timeout.
|
|
// (for codes 301, 302, 303, 307, and 308)
|
|
status = assigned_location->redirect_status;
|
|
response.append("Location: ");
|
|
response.append(assigned_location->redirect_uri);
|
|
response.append(CRLF CRLF);
|
|
}
|
|
|
|
//////////////////
|
|
// Headers checks
|
|
else if (!this->get_rq_headers("Content-Length").empty()
|
|
&& std::strtoul(this->get_rq_headers("Content-Length").c_str(), NULL, 10) > assigned_server->client_body_limit)
|
|
status = 413;
|
|
else if (!this->get_rq_headers("Transfer-Encoding").empty()
|
|
&& this->get_rq_headers("Transfer-Encoding") != "chunked" )
|
|
status = 501;
|
|
else if (!this->get_rq_headers("Content-Encoding").empty())
|
|
{
|
|
status = 415;
|
|
response.append("Accept-Encoding:"); // empty, no encoding accepted
|
|
response.append(CRLF);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
/*********************************************
|
|
* OVERLOAD
|
|
*********************************************/
|
|
|
|
bool operator==(const Client& lhs, const Client& rhs)
|
|
{ return lhs.get_cl_fd() == rhs.get_cl_fd(); }
|
|
bool operator==(const Client& lhs, int fd)
|
|
{ return lhs.get_cl_fd() == fd; }
|
|
bool operator==(int fd, const Client& rhs)
|
|
{ return fd == rhs.get_cl_fd(); }
|
|
|