// Terminate with crlf if flag set

if (crlf_end)

str += "\r\n";

// Put the entire contents of str into the buffer

putBytes((const uint8_t* const)str.c_str(), str.size());

for (auto const &[key, value] : headers) {

putLine(std::format("{}: {}", key, value), true);

}

// End with a blank line

putLine();

std::string ret = "";

int32_t startPos = getReadPos();

bool newLineReached = false;

char c = 0;

// Append characters to the return std::string until we hit the end of the buffer, a CR (13) or LF (10)

for (uint32_t i = startPos; i < size(); i++) {

// If the next byte is a \r or \n, we've reached the end of the line and should break out of the loop

c = peek();

if ((c == 13) || (c == 10)) {

newLineReached = true;

break;

}

// Otherwise, append the next character to the std::string

ret += getChar();

}

// If a line termination was never reached, discard the result and conclude there are no more lines to parse

if (!newLineReached) {

setReadPos(startPos); // Reset the position to before the last line read that we are now discarding

ret = "";

return ret;

}

// Increment the read position until the end of a CR or LF chain, so the read position will then point to the next line

// Also, only read a maximum of 2 characters so as to not skip a blank line that is only \r\n

uint32_t k = 0;

for (uint32_t i = getReadPos(); i < size(); i++) {

if (k++ >= 2)

break;

c = getChar();

if ((c != 13) && (c != 10)) {

// Set the Read position back one because the retrived character wasn't a LF or CR

setReadPos(getReadPos() - 1);

break;

}

}

return ret;

int32_t startPos = getReadPos();

if (startPos < 0)

return "";

int32_t endPos = find(delim, startPos);

if (endPos < 0)

return "";

if (startPos > endPos)

return "";

// Calculate the size based on the found ending position

uint32_t size = (endPos + 1) - startPos;

if (size <= 0)

return "";

// Grab the std::string from the ByteBuffer up to the delimiter

auto str = std::make_unique<char[]>(size);

getBytes((uint8_t*)str.get(), size);

str[size - 1] = 0x00; // NULL termination

std::string ret = str.get();

// Increment the read position PAST the delimiter

setReadPos(endPos + 1);

return ret;

std::string hline = "";

std::string app = "";

// Get the first header

hline = getLine();

// Keep pulling headers until a blank line has been reached (signaling the end of headers)

while (hline.size() > 0) {

// Case where values are on multiple lines ending with a comma

app = hline;

while (app[app.size() - 1] == ',') {

app = getLine();

hline += app;

}

addHeader(hline);

hline = getLine();

}

// Content-Length should exist (size of the Body data) if there is body data

std::string hlenstr = "";

hlenstr = getHeaderValue("Content-Length");

// No body data to read:

if (hlenstr.empty())

return true;

uint32_t remainingLen = bytesRemaining();

uint32_t contentLen = atoi(hlenstr.c_str());

// contentLen should NOT exceed the remaining number of bytes in the buffer

// Add 1 to bytesRemaining so it includes the byte at the current read position

if (contentLen > remainingLen + 1) {

// If it exceeds, there's a potential security issue and we can't reliably parse

parseErrorStr = std::format("Content-Length ({}) is greater than remaining bytes ({})", hlenstr, remainingLen);

return false;

} else if (remainingLen > contentLen) {

parseErrorStr = std::format("ByteBuffer remaining size to read ({}) is greater than provided Content-Length {}", remainingLen, contentLen);

return false;

} else if (contentLen == 0) {

// Nothing to read, which is fine

return true;

} else {

// Otherwise, we can probably trust Content-Length is valid and read the specificed number of bytes

this->dataLen = contentLen;

}

// Create a big enough buffer to store the data

this->data = new uint8_t[this->dataLen];

// Grab all the bytes from the current position to the end

uint32_t dIdx = 0;

for (uint32_t i = getReadPos(); i < remainingLen; i++) {

this->data[dIdx] = get(i);

dIdx++;

}

// We could handle chunked Request/Response parsing (with footers) here, but, we won't.

return true;

size_t kpos = line.find(':');

if (kpos == std::string::npos) {

std::print("Could not addHeader: {}\n", line);

return;

}

// We're choosing to reject HTTP Header keys longer than 32 characters

if (kpos > 32)

return;

std::string key = line.substr(0, kpos);

if (key.empty())

return;

int32_t value_len = line.size() - kpos - 1;

if (value_len <= 0)

return;

// We're choosing to reject HTTP header values longer than 4kb

if (value_len > 4096)

return;

std::string value = line.substr(kpos + 1, value_len);

// Skip all leading spaces in the value

int32_t i = 0;

while (i < value.size() && value.at(i) == 0x20) {

i++;

}

value = value.substr(i, value.size());

if (value.empty())

return;

// Add header to the map

addHeader(key, value);

// Lookup in map

auto it = headers.find(key);

// Key wasn't found, try an all lowercase variant as some clients won't always use proper capitalization

if (it == headers.end()) {

auto key_lower = std::string(key);

std::ranges::transform(key_lower.begin(), key_lower.end(), key_lower.begin(),

[](unsigned char c){ return std::tolower(c); });

// Still not found, return empty string to indicate the Header value doesnt exist

it = headers.find(key_lower);

if (it == headers.end())

return "";

}

// Otherwise, return the value

return it->second;

int32_t i = 0;

std::string ret = "";

for (auto const &[key, value] : headers) {

if (i == index) {

ret = std::format("{}: {}", key, value);

break;

}

i++;

}

return ret;