HttpParser Class Reference

#include <HttpParser.h>

Collaboration diagram for HttpParser:

Static Public Member Functions
static std::pair< std::string, std::string >	receiveHeaderAndLeftover (Tcp &socket)
	Receive raw headers from the socket until \r \r .
static bool	receiveBody (Tcp &socket, const std::map< std::string, std::string > &headers, const std::string &leftoverBody, std::string &outBody, size_t maxLength, bool *wasTruncated)
	Receive the HTTP body from socket, using Content-Length or connection close.
static bool	receiveChunkedBodyToFile (Tcp &socket, const std::string &leftover, std::function< bool(const char *, size_t)> writeFn, size_t maxLength, bool *wasTruncated)
static bool	receiveFixedLengthBodyToFile (Tcp &socket, const std::map< std::string, std::string > &headers, const std::string &leftover, std::function< bool(const char *, size_t)> writeFn, size_t maxLength, bool *wasTruncated)
static int	parseStatusCode (const std::string &statusLine)
	Parses the HTTP status line to extract the status code.
static std::map< std::string, std::string >	parseHeaders (const std::string &rawHeaders)
	Parses the HTTP headers from a raw header string.
static bool	isChunkedEncoding (const std::map< std::string, std::string > &headers)
static bool	receiveChunkedBodyToString (Tcp &socket, const std::string &leftover, std::string &out, size_t maxLength, bool *wasTruncated)
static bool	receiveFixedLengthBodyToString (Tcp &socket, const std::map< std::string, std::string > &headers, const std::string &leftover, std::string &out, size_t maxLength, bool *wasTruncated)
static bool	receiveUnknownLengthBodyToString (Tcp &socket, const std::string &leftover, std::string &out, size_t maxLength, bool *wasTruncated)

Detailed Description

Definition at line 23 of file HttpParser.h.

Member Function Documentation

isChunkedEncoding()

bool HttpParser::isChunkedEncoding ( const std::map< std::string, std::string > &  headers )

static

Definition at line 175 of file HttpParser.cpp.

{
    auto it = headers.find("transfer-encoding");
    return (it != headers.end() && toLower(it->second) == "chunked");
}

References toLower().

Referenced by receiveBody().

Here is the call graph for this function:

Here is the caller graph for this function:

parseHeaders()

std::map< std::string, std::string > HttpParser::parseHeaders ( const std::string &  rawHeaders )

static

Parameters

rawHeaders

The raw HTTP headers as a string.

Returns

A map of header names to their values.

Definition at line 46 of file HttpParser.cpp.

{
    std::map<std::string, std::string> headers;
    std::istringstream stream(rawHeaders);
    std::string line;
 
    while (std::getline(stream, line))
    {
        // Stop on blank line (end of headers)
        if (line == "\r" || line.empty())
        {
            break;
        }
 
        auto colon = line.find(':');
        if (colon == std::string::npos || colon + 1 >= line.size())
        {
            continue;
        }
 
        std::string key = line.substr(0, colon);
        std::string value = line.substr(colon + 1);
 
        // Remove CR and quotes
        key.erase(std::remove(key.begin(), key.end(), '\r'), key.end());
        value.erase(std::remove(value.begin(), value.end(), '\r'), value.end());
        key.erase(std::remove(key.begin(), key.end(), '"'), key.end());
        value.erase(std::remove(value.begin(), value.end(), '"'), value.end());
 
        // Lowercase key
        std::transform(key.begin(), key.end(), key.begin(), ::tolower);
 
        // Trim whitespace from value
        size_t start = value.find_first_not_of(" \t");
        size_t end = value.find_last_not_of(" \t");
        if (start != std::string::npos && end != std::string::npos)
        {
            value = value.substr(start, end - start + 1);
        }
        else
        {
            value = "";
        }
 
        headers[key] = value;
    }
 
    return headers;
}

Referenced by HttpRequest::parseHeaders().

Here is the caller graph for this function:

parseStatusCode()

int HttpParser::parseStatusCode ( const std::string &  statusLine )

static

Parameters

statusLine

The HTTP status line (e.g., "HTTP/1.1 200 OK").

Returns

The HTTP status code as an integer (e.g., 200).

Definition at line 33 of file HttpParser.cpp.

{
    std::istringstream stream(statusLine);
    std::string httpVersion;
    int code = 0;
    stream >> httpVersion >> code;
    return code;
}

receiveBody()

bool HttpParser::receiveBody ( Tcp &  socket, const std::map< std::string, std::string > &  headers, const std::string &  leftoverBody, std::string &  outBody, size_t  maxLength, bool *  wasTruncated  )

static

Receives the HTTP body from a TCP socket based on headers.

Parameters

socket	The TCP socket to read from.
headers	The parsed HTTP headers.
leftoverBody	Any body data that was received after the headers.
outBody	The output string to store the received body.
maxLength	The maximum length of the body to receive.
wasTruncated	Pointer to a boolean that will be set to true if the body was truncated.

Returns

True if the body was successfully received, false on error or EOF. This function handles different content transfer methods:

• Chunked transfer encoding
• Content-Length specified in headers
• Unknown length (just read until EOF)

Definition at line 152 of file HttpParser.cpp.

{
    if (wasTruncated)
        *wasTruncated = false;
 
    if (isChunkedEncoding(headers))
    {
        return receiveChunkedBodyToString(socket, leftoverBody, outBody, maxLength, wasTruncated);
    }
 
    if (headers.count("content-length"))
    {
        return receiveFixedLengthBodyToString(socket, headers, leftoverBody, outBody, maxLength, wasTruncated);
    }
 
    return receiveUnknownLengthBodyToString(socket, leftoverBody, outBody, maxLength, wasTruncated);
}

References isChunkedEncoding(), receiveChunkedBodyToString(), receiveFixedLengthBodyToString(), and receiveUnknownLengthBodyToString().

Here is the call graph for this function:

receiveChunkedBodyToFile()

bool HttpParser::receiveChunkedBodyToFile ( Tcp &  socket, const std::string &  leftover, std::function< bool(const char *, size_t)>  writeFn, size_t  maxLength, bool *  wasTruncated  )

static

Definition at line 264 of file HttpParser.cpp.

{
    ChunkedDecoder decoder;
    decoder.feedToFile(leftover, writeFn, maxLength);
 
    char buffer[1460];
    while (!decoder.isComplete()) {
        int n = socket.recv(buffer, sizeof(buffer), HTTP_RECEIVE_TIMEOUT);
        if (n <= 0) {
            printf("Chunked: recv() failed or EOF\n");
            return false;
        }
 
        if (!decoder.feedToFile(std::string(buffer, n), writeFn, maxLength)) {
            printf("Chunked: writeFn failed\n");
            return false;
        }
 
        if (decoder.wasTruncated()) {
            if (wasTruncated) *wasTruncated = true;
            return true;
        }
    }
 
    if (wasTruncated) *wasTruncated = decoder.wasTruncated();
    return true;
}

References ChunkedDecoder::feedToFile(), HTTP_RECEIVE_TIMEOUT, ChunkedDecoder::isComplete(), Tcp::recv(), and ChunkedDecoder::wasTruncated().

Here is the call graph for this function:

receiveChunkedBodyToString()

bool HttpParser::receiveChunkedBodyToString ( Tcp &  socket, const std::string &  leftover, std::string &  out, size_t  maxLength, bool *  wasTruncated  )

static

Definition at line 181 of file HttpParser.cpp.

{
    ChunkedDecoder decoder;
    decoder.feed(leftover, maxLength);
 
    char temp[1460];
    while (!decoder.isComplete()) {
        int n = socket.recv(temp, sizeof(temp), HTTP_RECEIVE_TIMEOUT);
        if (n <= 0) {
            printf("Chunked: recv() failed or EOF");
            return false;
        }
        decoder.feed(std::string(temp, n), maxLength);
        if (decoder.wasTruncated()) {
            outBody = decoder.getDecoded();
            if (wasTruncated) *wasTruncated = true;
            return true;
        }
    }
 
    outBody = decoder.getDecoded();
    return true;
}

References ChunkedDecoder::feed(), ChunkedDecoder::getDecoded(), HTTP_RECEIVE_TIMEOUT, ChunkedDecoder::isComplete(), Tcp::recv(), and ChunkedDecoder::wasTruncated().

Referenced by receiveBody().

Here is the call graph for this function:

Here is the caller graph for this function:

receiveFixedLengthBodyToFile()

bool HttpParser::receiveFixedLengthBodyToFile ( Tcp &  socket, const std::map< std::string, std::string > &  headers, const std::string &  leftover, std::function< bool(const char *, size_t)>  writeFn, size_t  maxLength, bool *  wasTruncated  )

static

Definition at line 297 of file HttpParser.cpp.

{
    if (wasTruncated) *wasTruncated = false;
 
    auto it = headers.find("content-length");
    if (it == headers.end()) return false;
 
    int contentLength = std::stoi(it->second);
    size_t totalWritten = 0;
 
    // Write leftover first
    if (!leftover.empty()) {
        size_t toWrite = std::min(leftover.size(), maxLength);
        if (!writeFn(leftover.data(), toWrite)) return false;
        totalWritten += toWrite;
 
        if (leftover.size() > maxLength) {
            if (wasTruncated) *wasTruncated = true;
            return true;
        }
    }
 
    char buffer[1460];
    int idleCycles = 0;
    while (totalWritten < (size_t)contentLength) {
        size_t remaining = contentLength - totalWritten;
        int toRead = std::min((int)sizeof(buffer), (int)remaining);
        int n = socket.recv(buffer, toRead, HTTP_RECEIVE_TIMEOUT);
 
        if (n <= 0) {
            vTaskDelay(pdMS_TO_TICKS(10));
            if (++idleCycles > 20) return false;
            continue;
        }
 
        idleCycles = 0;
 
        size_t available = maxLength - totalWritten;
        size_t toWrite = std::min((size_t)n, available);
        if (!writeFn(buffer, toWrite)) return false;
        totalWritten += toWrite;
 
        if (toWrite < (size_t)n) {
            if (wasTruncated) *wasTruncated = true;
            return true;
        }
    }
 
    return true;
}

References HTTP_RECEIVE_TIMEOUT, and Tcp::recv().

Here is the call graph for this function:

receiveFixedLengthBodyToString()

bool HttpParser::receiveFixedLengthBodyToString ( Tcp &  socket, const std::map< std::string, std::string > &  headers, const std::string &  leftover, std::string &  out, size_t  maxLength, bool *  wasTruncated  )

static

Definition at line 205 of file HttpParser.cpp.

{
    int contentLength = std::stoi(headers.at("content-length"));
    outBody = leftover;
 
    if ((int)outBody.size() >= contentLength) {
        outBody = outBody.substr(0, std::min((size_t)contentLength, maxLength));
        if ((size_t)contentLength > maxLength && wasTruncated) *wasTruncated = true;
        return true;
    }
 
    int attempts = 0;
    int idleCycles = 0;
    while ((int)outBody.size() < contentLength && attempts++ < 2000) {
        char buffer[1460];
        int toRead = std::min<int>(sizeof(buffer), contentLength - (int)outBody.size());
        int n = socket.recv(buffer, toRead, HTTP_RECEIVE_TIMEOUT);
 
        if (n <= 0) {
            idleCycles++;
            vTaskDelay(pdMS_TO_TICKS(10));
            if (idleCycles > 20) return false;
            continue;
        }
 
        idleCycles = 0;
        if (outBody.size() + n > maxLength) {
            outBody.append(buffer, maxLength - outBody.size());
            if (wasTruncated) *wasTruncated = true;
            return true;
        }
 
        outBody.append(buffer, n);
    }
 
    return ((int)outBody.size() == contentLength);
}

References HTTP_RECEIVE_TIMEOUT, and Tcp::recv().

Referenced by receiveBody().

Here is the call graph for this function:

Here is the caller graph for this function:

receiveHeaderAndLeftover()

std::pair< std::string, std::string > HttpParser::receiveHeaderAndLeftover ( Tcp &  socket )

static

Receives HTTP headers and any leftover body data from a TCP socket.

Parameters

socket	The socket to receive from
outHeaders	The received headers
leftoverBody	The leftover body after headers

Returns

true on success, false on failure

Parameters

socket

The TCP socket to read from.

Returns

A pair containing the full header text and any leftover body data. If an error occurs, returns an empty header and leftover. This function reads data from the socket until it finds the end of the headers (indicated by a double CRLF "\r\n\r\n"). It accumulates data in a buffer and returns the complete header text along with any leftover body data that may have been received after the headers. It handles cases where the header may be split across multiple TCP packets. If the end of the headers is not found, it continues to read from the socket until it is found or an error occurs.

Note

This function is blocking and will wait until the header is fully received. It is designed for use in an embedded system with FreeRTOS and lwIP.

Definition at line 111 of file HttpParser.cpp.

{
    std::string buffer;
    char temp[1460];
 
    while (true)
    {
        int n = socket.recv(temp, sizeof(temp), HTTP_RECEIVE_TIMEOUT);
        if (n <= 0)
        {
            return {"", ""}; // signal error (empty header)
        }
 
        buffer.append(temp, n);
        std::size_t headerEnd = buffer.find("\r\n\r\n");
 
        if (headerEnd != std::string::npos)
        {
            std::string headerText = buffer.substr(0, headerEnd + 4);
            std::string leftover = buffer.substr(headerEnd + 4);
            return {headerText, leftover};
        }
 
        vTaskDelay(pdMS_TO_TICKS(1));
    }
}

References HTTP_RECEIVE_TIMEOUT, and Tcp::recv().

Here is the call graph for this function:

receiveUnknownLengthBodyToString()

bool HttpParser::receiveUnknownLengthBodyToString ( Tcp &  socket, const std::string &  leftover, std::string &  out, size_t  maxLength, bool *  wasTruncated  )

static

Definition at line 243 of file HttpParser.cpp.

{
    outBody = leftover;
    char buffer[1460];
    while (true) {
        int n = socket.recv(buffer, sizeof(buffer), HTTP_RECEIVE_TIMEOUT);
        if (n <= 0) break;
 
        if (outBody.size() + n > maxLength) {
            outBody.append(buffer, maxLength - outBody.size());
            if (wasTruncated) *wasTruncated = true;
            return true;
        }
 
        outBody.append(buffer, n);
    }
 
    return !outBody.empty();
}

References HTTP_RECEIVE_TIMEOUT, and Tcp::recv().

Referenced by receiveBody().

Here is the call graph for this function:

Here is the caller graph for this function:

---

The documentation for this class was generated from the following files:

• HttpParser.h
• HttpParser.cpp