Request.cpp

Go to the documentation of this file.

/**
 * @file Request.cpp
 * @brief Implementation of the Request class HTTP parser state machine.
 */
 
#include "../includes/Request.hpp"
#include <sstream>
#include <arpa/inet.h>
#include <sys/socket.h>
namespace req_utils
{//sorry, this is ugly but first time creating a namespace, bear with me ;p
 
    std::string trim(const std::string& s)
    {
        int start = 0;
        int end = static_cast<int>(s.size()) - 1;
        while (start <= end && std::isspace(static_cast<unsigned char>(s[start]))) {
            ++start;
        }
        while (end >= start && std::isspace(static_cast<unsigned char>(s[end]))) {
            --end;
        }
        if (start > end) {
            return "";
        }
        return s.substr(start, end - start + 1);
    }
 
    std::string ipv4ToString(const struct ::sockaddr_in& addr)
    {
        unsigned long hostOrder = ntohl(addr.sin_addr.s_addr);
        std::ostringstream oss;
        oss << ((hostOrder >> 24) & 0xFF) << "."
            << ((hostOrder >> 16) & 0xFF) << "."
            << ((hostOrder >> 8) & 0xFF) << "."
            << (hostOrder & 0xFF);
        return oss.str();
    }
}
// Canonical Form
 
Request::Request(): _methodName(UNKNOWN_METHOD), _contentLength(-1), _reqState(REQ_HEADERS), _statusCode("200"), _maxBodySize(0), _totalBytesRead(0), _chunkSize(0), _chunkDecodeOffset(0), _isBodyProcessed(false), _ramParsePos(0)
{}
 
Request::Request(long long maxBodySize): _methodName(UNKNOWN_METHOD), _contentLength(-1), _reqState(REQ_HEADERS), _statusCode("200"), _maxBodySize(static_cast<size_t>(maxBodySize)), _totalBytesRead(0), _chunkSize(0), _chunkDecodeOffset(0), _isBodyProcessed(false), _ramParsePos(0)
{}
 
Request::Request(const Request& other): _methodName(other._methodName), _URL(other._URL), _protocol(other._protocol), _query(other._query), _contentLength(other._contentLength), _body(other._body), _decodedBody(other._decodedBody), _headers(other._headers), _cookies(other._cookies), _reqState(other._reqState), _statusCode(other._statusCode), _maxBodySize(other._maxBodySize), _totalBytesRead(other._totalBytesRead), _chunkSize(other._chunkSize), _chunkDecodeOffset(other._chunkDecodeOffset), _isBodyProcessed(other._isBodyProcessed), _chunkBuffer(other._chunkBuffer), _ramParsePos(other._ramParsePos)
{
}
 
Request& Request::operator=(const Request& other)
{
    if (this != &other)
    {
        _methodName = other._methodName;
        _URL = other._URL;
        _protocol = other._protocol;
        _query = other._query;
        _contentLength = other._contentLength;
        _body = other._body;
        _decodedBody = other._decodedBody;
        _headers = other._headers;
        _cookies = other._cookies;
        _reqState = other._reqState;
        _statusCode = other._statusCode;
        _maxBodySize = other._maxBodySize;
        _totalBytesRead = other._totalBytesRead;
        _chunkSize = other._chunkSize;
        _chunkDecodeOffset = other._chunkDecodeOffset;
        _isBodyProcessed = other._isBodyProcessed;
        _chunkBuffer = other._chunkBuffer;
        _ramParsePos = other._ramParsePos;
    }
    return *this;
}
 
Request::~Request() {}
 
// Getters
 
HTTPMethod Request::getMethod() const {
    return _methodName;
}
 
const std::string& Request::getURL() const {
    return _URL;
}
 
const std::string& Request::getProtocol() const {
    return _protocol;
}
 
const std::string& Request::getQuery() const {
    return _query;
}
 
const std::map<std::string, std::string>& Request::getHeaders() const {
    return _headers;
}
 
const std::map<std::string, std::string>& Request::getCookies() const {
    return _cookies;
}
 
//  Core Parsing Behavior
void Request::_parseRequestLine(const std::string& line)
{
    size_t firstSpace = line.find(' ');
    if (firstSpace == std::string::npos)
    {
        _reqState = REQ_ERROR;
        _statusCode = "400"; // Bad Request
        return;
    }
    std::string methodStr = line.substr(0, firstSpace);
    _methodName = AllowedMethods::stringToMethod(methodStr);
    if (_methodName == UNKNOWN_METHOD)
    {
        _reqState = REQ_ERROR;
        _statusCode = "501"; // Not Implemented
        return;
    }
    size_t secondSpace = line.find(' ', firstSpace + 1);
    if (secondSpace == std::string::npos)
    {
        // HTTP/0.9: "GET /path"
        _URL = line.substr(firstSpace + 1);
        if (_URL.empty() || _URL[0] != '/')
        {
            _reqState = REQ_ERROR;
            _statusCode = "400"; // Bad Request
            return;
        }
        _protocol = "HTTP/0.9";
        _extractQueryFromURL();
        _reqState = REQ_DONE;
        return;
    }
    _URL = line.substr(firstSpace + 1, secondSpace - firstSpace - 1);
    _protocol = line.substr(secondSpace + 1);
    if (_protocol != "HTTP/1.0" && _protocol != "HTTP/1.1")
    {
        _reqState = REQ_ERROR;
        _statusCode = "505"; // HTTP Version Not Supported
        return;
    }
    if (_URL.empty() || _URL[0] != '/')
    {
        _reqState = REQ_ERROR;
        _statusCode = "400"; // Bad Request
        return;
    }
    _extractQueryFromURL();
}
 
void Request::_extractQueryFromURL()
{
    size_t queryPos = _URL.find('?');
 
    if (queryPos != std::string::npos)
    {
        _query = _URL.substr(queryPos + 1);
        _URL = _URL.substr(0, queryPos);
    }
}
 
size_t Request::parseHeaders(const std::string& rawBuffer)
{
    size_t headerEnd = rawBuffer.find("\r\n\r\n");
    if (headerEnd == std::string::npos)
        return 0;
    _cookies.clear();
 
    std::string headerSection = rawBuffer.substr(0, headerEnd);
    size_t lineStart = 0;
    bool firstLine = true;
 
    while (lineStart < headerSection.size())
    {
        size_t lineEnd = headerSection.find("\r\n", lineStart);
        if (lineEnd == std::string::npos)
            lineEnd = headerSection.size();
 
        std::string line = headerSection.substr(lineStart, lineEnd - lineStart);
        if (!line.empty())
        {
            if (firstLine)
            {
                _parseRequestLine(line);
                firstLine = false;
            }
            else
                _parseHeaderLine(line);
        }
        lineStart = lineEnd + 2;
    }
    if (_reqState != REQ_ERROR)
        _typeOfReq();
    if (_headers.count("cookie"))
        _parseCookies(_headers["cookie"]);
    return headerEnd + 4;
}
 
void Request::_parseCookies(const std::string& cookieHeader)
{
    size_t pos = 0;
    while (pos < cookieHeader.size())
    {
        size_t semicolonPos = cookieHeader.find(';', pos);
        if (semicolonPos == std::string::npos)
            semicolonPos = cookieHeader.size();
 
        std::string token = req_utils::trim(cookieHeader.substr(pos, semicolonPos - pos));
        size_t eqPos = token.find('=');
        if (eqPos != std::string::npos)
        {
            std::string key = req_utils::trim(token.substr(0, eqPos));
            std::string value = req_utils::trim(token.substr(eqPos + 1));
            if (!key.empty())
                _cookies[key] = value;
        }
        pos = semicolonPos + 1;
    }
}
 
void Request::_typeOfReq()
{
    // determine body transfer mode from the parsed headers
    std::string transferEncoding = getHeader("Transfer-Encoding");
    std::string contentLengthStr = getHeader("Content-Length");
 
    std::string toLower = transferEncoding;
    for (size_t i = 0; i < toLower.size(); ++i)
        toLower[i] = std::tolower(static_cast<unsigned char>(toLower[i]));
    if (toLower.find("chunked") != std::string::npos)
    {
        _contentLength = -1;
        _reqState = REQ_CHUNKED;
    }
    else if (!contentLengthStr.empty())
    {
        char* endPtr = NULL;
        long long cl = strtoll(contentLengthStr.c_str(), &endPtr, 10);
        if (*endPtr != '\0' || cl < 0)
        {
            _reqState = REQ_ERROR;
            _statusCode = "400";
            return ;
        }
        _contentLength = cl;
        if (_maxBodySize > 0 && static_cast<size_t>(_contentLength) > _maxBodySize)
        {
            _reqState = REQ_ERROR;
            _statusCode = "413";
            return ;
        }
        _reqState = (_contentLength == 0) ? REQ_DONE : REQ_BODY;
    }
    else
    {
        _contentLength = 0;
        _reqState = REQ_DONE;
    }
}
 
std::string Request::getHeader(const std::string& key) const
{
    std::string keyCopy = key;
    for (size_t i = 0; i < key.size(); ++i)
    {
        keyCopy[i] = std::tolower(static_cast<unsigned char>(keyCopy[i]));
    }
    if (_headers.count(keyCopy))
        return _headers.find(keyCopy)->second;
    return "";
}
 
std::string Request::getCookie(const std::string& key) const
{
    std::map<std::string, std::string>::const_iterator it = _cookies.find(key);
    if (it == _cookies.end())
        return "";
    return it->second;
}
 
void Request::_parseHeaderLine(const std::string& line)
{
    size_t colonPos = line.find(':');
    if (colonPos == std::string::npos)
        return;
 
    std::string key = req_utils::trim(line.substr(0, colonPos));
    std::string value = req_utils::trim(line.substr(colonPos + 1));
 
    for (size_t i = 0; i < key.size(); ++i)
        key[i] = std::tolower(static_cast<unsigned char>(key[i]));
    if (!key.empty())
        _headers[key] = value;
}
 
bool Request::processBodySlice()
{
    if (_contentLength >= 0 || _isBodyProcessed || _reqState == REQ_ERROR)
        return true;
 
    std::vector<char> tempBuffer(PARSE_BYTE_SLICE);
    size_t ReadBaytes = _body.read(&tempBuffer[0], tempBuffer.size());
    _totalBytesRead += ReadBaytes;
    _chunkBuffer += std::string(&tempBuffer[0], ReadBaytes);
    while (true)
    {
        size_t crlfPos = _chunkBuffer.find("\r\n");
        if (crlfPos == std::string::npos)
            break;
        std::string hexStr = _chunkBuffer.substr(0, crlfPos);
        size_t semi = hexStr.find(';');
        if (semi != std::string::npos)
            hexStr = hexStr.substr(0, semi);
 
        unsigned long chunkSize = strtoul(hexStr.c_str(), NULL, 16);
        size_t totalBytesNeeded = crlfPos + 2 + chunkSize + 2;
 
        if (_chunkBuffer.size() < totalBytesNeeded)
            break;
        if (_chunkBuffer.substr(crlfPos + 2 + chunkSize, 2) != "\r\n") {
            _reqState = REQ_ERROR;
            _statusCode = "400"; // Malformed chunk formatting
            return true;
        }
        if (chunkSize == 0) {
            _chunkBuffer.erase(0, totalBytesNeeded);
            _isBodyProcessed = true;
            break;
        }
 
        _decodedBody.append(_chunkBuffer.substr(crlfPos + 2, chunkSize));
        if (_maxBodySize > 0 && _decodedBody.getSize() > _maxBodySize) {
            _reqState = REQ_ERROR;
            _statusCode = "413"; // Payload Too Large
            return true;
        }
        _chunkBuffer.erase(0, totalBytesNeeded);
    }
 
    if (_isBodyProcessed) {
        _body = _decodedBody;
        _chunkBuffer.clear();
        _body.resetReadPosition();
        std::stringstream ss;
        ss << _body.getSize();
        std::string str = ss.str();
        _headers["content-length"] = str;
        return true;
    }
    return false;
}
 
bool Request::isChunkedDone(const std::string& newData) const
{
    return newData.find("0\r\n\r\n") != std::string::npos;
}
 
 
//  State Management Getters
 
ReqState    Request::getReqState() const{
    return _reqState;
}
std::string Request::getStatusCode() const{
    return _statusCode;
}
 
// I don't know what to return here
size_t      Request::getMaxBytesToRead() const{
    return _maxBodySize;
}
 
long long Request::getContentLength() const{
    return _contentLength;
}
 
size_t      Request::getTotalBytesRead() const{
    return _totalBytesRead;
}
bool        Request::isComplete() const{
    return _reqState == REQ_DONE;
}
 
DataStore&  Request::getBodyStore(){
    return _body;
}