251    std::vector<HTTPPathHandler>::iterator i = pathHandlers.begin();
252    std::vector<HTTPPathHandler>::iterator iend = pathHandlers.end();
253    for (; i != iend; ++i)
254        if (i->prefix == prefix && i->exactMatch == exactMatch)
255            break;
256    if (i != iend)
257    {
258        LogDebug(BCLog::HTTP, "Unregistering HTTP handler for %s (exactmatch %d)\n", prefix, exactMatch);
259        pathHandlers.erase(i);
260    }
261}
262
263using util::Split;
264
265std::optional<std::string> HTTPHeaders::FindFirst(const std::string_view key) const
266{
267    for (const auto& item : m_headers) {
268        if (CaseInsensitiveEqual(key, item.first)) {
269            return item.second;
270        }
271    }
272    return std::nullopt;
273}
274
275std::vector<std::string_view> HTTPHeaders::FindAll(const std::string_view key) const
276{
277    std::vector<std::string_view> ret;
278    for (const auto& item : m_headers) {
279        if (CaseInsensitiveEqual(key, item.first)) {
280            ret.push_back(item.second);
281        }
282    }
283    return ret;
284}
285
286void HTTPHeaders::Write(std::string&& key, std::string&& value)
287{
288    m_headers.emplace_back(std::move(key), std::move(value));
289}
290
291void HTTPHeaders::RemoveAll(std::string_view key)
292{
293    auto moved = std::ranges::remove_if(m_headers, [key] (auto& pair) {
294        return CaseInsensitiveEqual(key, pair.first);
295    });
296    m_headers.erase(moved.begin(), moved.end());
297}
298
299bool HTTPHeaders::Read(util::LineReader& reader, bool write)
300{
301    // Headers https://httpwg.org/specs/rfc9110.html#rfc.section.6.3
302    // A sequence of Field Lines https://httpwg.org/specs/rfc9110.html#rfc.section.5.2
303    size_t start{reader.Consumed()};
304    while (auto maybe_line = reader.ReadLine()) {
305        if (reader.Consumed() - start + m_consumed > MAX_HEADERS_SIZE) throw std::runtime_error("HTTP headers exceed size limit");
306
307        const std::string_view& line = *maybe_line;
308
309        // An empty line indicates end of the headers section https://www.rfc-editor.org/rfc/rfc2616#section-4
310        if (line.empty()) {
311            // Ensure all headers are accounted for in case there is a chunked trailer
312            m_consumed += reader.Consumed() - start;
313            return true;
314        }
315
316        // "Field values containing CR, LF, or NUL characters are invalid and dangerous"
317        // https://httpwg.org/specs/rfc9110.html#rfc.section.5.5
318        // A sender MUST NOT generate a bare CR (a CR character not immediately followed by LF)
319        // within any protocol elements other than the content.
320        // A recipient of such a bare CR MUST consider that element to be invalid...
321        // https://httpwg.org/specs/rfc9112.html#rfc.section.2.2
322        if (line.find_first_of("\r\n\0", 0, 3) != std::string_view::npos) throw std::runtime_error("Header contains invalid character");
323
324        // Header line must have at least one ":"
325        // keys are not allowed to have delimiters like ":" but values are
326        // https://httpwg.org/specs/rfc9110.html#rfc.section.5.6.2
327        const size_t pos{line.find(':')};
328        if (pos == std::string_view::npos) throw std::runtime_error("HTTP header missing colon (:)");
329
330        // Whitespace is strictly not allowed in the field-name (key)
331        // https://www.rfc-editor.org/rfc/rfc9110.html#section-5.6.2
332        std::string_view key = line.substr(0, pos);
333        if (key.find_first_of(" \t\n\r\f\v") != std::string_view::npos) throw std::runtime_error("Invalid header field-name contains whitespace");
334        // Whitespace is optional in the value and can be trimmed
335        std::string value = util::TrimString(std::string_view(line).substr(pos + 1));
336
337        // Header keys are Field Names: https://httpwg.org/specs/rfc9110.html#fields.names
338        // which consist of "tokens": https://httpwg.org/specs/rfc9110.html#rfc.section.5.6.2
339        // that can not be empty.
340        if (key.empty()) throw std::runtime_error("Empty HTTP header name");
341
342        if (write) {
343            Write(std::string(key), std::move(value));
344        }
345    }
346
347    // We have not received all the request headers yet.
348    // Keep track of how much data we have already consumed to enforce
349    // the total limit over multiple read operations.
350    m_consumed += reader.Consumed() - start;
351
352    return false;
353}
354
355std::string HTTPHeaders::Stringify() const
356{
357    std::string out;
358    for (const auto& [key, value] : m_headers) {
359        out += key + ": " + value + "\r\n";
360    }
361
362    // Headers are terminated by an empty line
363    out += "\r\n";
364
365    return out;
366}
367
368std::string HTTPResponse::StringifyHeaders() const
369{
370    return strprintf("HTTP/%d.%d %d %s\r\n%s",
371                     version.major,
372                     version.minor,
373                     status,
374                     HTTPStatusReasonString(status),
375                     headers.Stringify());
376}
377
378bool HTTPRequest::LoadControlData(LineReader& reader)
379{
380    auto maybe_line = reader.ReadLine();
381    if (!maybe_line) return false;
382    const std::string_view& request_line = *maybe_line;
383
384    // Request Line aka Control Data https://httpwg.org/specs/rfc9110.html#rfc.section.6.2
385    // Three words separated by spaces, terminated by \n or \r\n
386    if (request_line.length() < MIN_REQUEST_LINE_LENGTH) throw std::runtime_error("HTTP request line too short");
387
388    // NUL is not a valid tchar and would silently truncate
389    // C-string-based parsers rather than being rejected as malformed.
390    // tchar: https://www.rfc-editor.org/info/rfc7230/#section-3.2.6
391    if (request_line.find('\0') != std::string_view::npos) throw std::runtime_error("Invalid request line contains NUL");
392
393    const std::vector<std::string_view> parts{Split<std::string_view>(request_line, " ")};
394    if (parts.size() != 3) throw std::runtime_error("HTTP request line malformed");
395
396    if (parts[0] == "GET") {
397        m_method = HTTPRequestMethod::GET;
398    } else if (parts[0] == "POST") {
399        m_method = HTTPRequestMethod::POST;
400    } else if (parts[0] == "HEAD") {
401        m_method = HTTPRequestMethod::HEAD;
402    } else if (parts[0] == "PUT") {
403        m_method = HTTPRequestMethod::PUT;
404    } else {
405        m_method = HTTPRequestMethod::UNKNOWN;
406    }
407
408    m_target = parts[1];
409
410    if (parts[2].rfind("HTTP/") != 0) throw std::runtime_error("HTTP request line malformed");
411
412    // Version is exactly two decimal digits separated by a decimal point
413    // https://httpwg.org/specs/rfc9110.html#rfc.section.2.5
414    const std::vector<std::string_view> version_parts{Split<std::string_view>(parts[2].substr(5), ".")};
415    if (version_parts.size() != 2) throw std::runtime_error("HTTP request line malformed");
416    if (version_parts[0].size() != 1 || version_parts[1].size() != 1) throw std::runtime_error("HTTP bad version");
417    auto major = ToIntegral<uint8_t>(version_parts[0]);
418    auto minor = ToIntegral<uint8_t>(version_parts[1]);
419    if (!major || !minor || major != 1 || minor > 9) throw std::runtime_error("HTTP bad version");
420    m_version.major = major.value();
421    m_version.minor = minor.value();
422
423    return true;
424}
425
426bool HTTPRequest::LoadHeaders(LineReader& reader)
427{
428    return m_headers.Read(reader);
429}
430
431bool HTTPRequest::LoadBody(LineReader& reader)
432{
433    // https://httpwg.org/specs/rfc9112.html#message.body
434    auto transfer_encoding_header = m_headers.FindFirst("Transfer-Encoding");
435    if (transfer_encoding_header && ToLower(transfer_encoding_header.value()) == "chunked") {
436        // Transfer-Encoding: https://datatracker.ietf.org/doc/html/rfc7230.html#section-3.3.1
437        // Chunked Transfer Coding: https://datatracker.ietf.org/doc/html/rfc7230.html#section-4.1
438        // see evhttp_handle_chunked_read() in libevent http.c
439        while (reader.Remaining() > 0) {
440            if (!m_chunk_size) {
441                auto maybe_chunk_size = reader.ReadLine();
442                if (!maybe_chunk_size) return false;
443
444                // Allow (but ignore) Chunk Extensions
445                // See https://www.rfc-editor.org/rfc/rfc9112.html#name-chunk-extensions
446                std::string_view chunk_size_noext{maybe_chunk_size.value()};
447                const auto semicolon_pos = chunk_size_noext.find(';');
448                if (semicolon_pos != chunk_size_noext.npos) {
449                    chunk_size_noext.remove_suffix(chunk_size_noext.size() - semicolon_pos);
450                }
451
452                m_chunk_size = ToIntegral<uint64_t>(util::TrimStringView(chunk_size_noext), /*base=*/16);
453                if (!m_chunk_size) throw std::runtime_error("Cannot parse chunk length value");
454
455                if ((m_body.size() > MAX_BODY_SIZE) ||
456                    (*m_chunk_size > MAX_BODY_SIZE - m_body.size()))
457                    throw ContentTooLargeError("Chunk will exceed max body size");
458            }
459
460            // We either just read the chunk size, or we have it saved
461            // from a prior I/O loop iteration
462            Assume(m_chunk_size);
463
464            // Last chunk has size 0
465            if (*m_chunk_size == 0) {
466                // Validate Chunked Trailer section, which is used for
467                // additional headers sent at the end of the message.
468                // Data consumed here is counted towards MAX_HEADERS_SIZE
469                // along with the headers we read in the beginning of the request.
470                // At this time we ignore and drop these data after validating.
471                // See https://httpwg.org/specs/rfc9112.html#rfc.section.7.1.2
472                return m_headers.Read(reader, /*write=*/false);
473            }
474
475            // We have not read the entire chunk from the buffer yet
476            if (m_chunk_read < *m_chunk_size) {
477                // Get what we can from the buffer
478                const uint64_t chunk_need{*m_chunk_size - m_chunk_read};
479                const uint64_t buffer_has{std::min(chunk_need, static_cast<uint64_t>(reader.Remaining()))};
480
481                // Pack [partial] chunk onto body and update state
482                m_body += reader.ReadLength(buffer_has);
483                m_chunk_read += buffer_has;
484            }
485
486            // Even though every chunk size is explicitly declared,
487            // they are still terminated by a CRLF we don't need,
488            // just consume it here.
489            if (m_chunk_read == *m_chunk_size) {
490                auto crlf = reader.ReadLine();
491                if (!crlf) {
492                    // CRLF not found before end of buffer: it has not been received by our socket yet.
493                    return false;
494                }
495                // CRLF was found but there was unexpected data after the chunk_sized chunk
496                if (!crlf.value().empty()) throw std::runtime_error("Improperly terminated chunk");
497
498                // Clear state for next chunk
499                m_chunk_size.reset();
500                m_chunk_read = 0;