Inside Bitcoin

501            }
502        }
503
504        // We read all the chunks but never got the last chunk, wait for client to send more
505        return false;
506    } else {
507        // No Content-length or Transfer-Encoding header means no body, see libevent evhttp_get_body()
508        auto content_length_values{m_headers.FindAll("Content-Length")};
509        if (content_length_values.empty()) return true;
510
511        // Duplicate Content-Length headers are allowed only if they all have the same value
512        // https://www.rfc-editor.org/rfc/rfc7230#section-3.3.3
513        const auto& first_content_length_value{content_length_values[0]};
514        for (size_t i = 1; i < content_length_values.size(); ++i) {
515            if (content_length_values[i] != first_content_length_value) throw std::runtime_error("Differing Content-Length values");
516        }
517
518        const auto content_length{ToIntegral<uint64_t>(first_content_length_value)};
519        if (!content_length) throw std::runtime_error("Cannot parse Content-Length value");
520
521        if (*content_length > MAX_BODY_SIZE) throw ContentTooLargeError("Max body size exceeded");
522
523        // A large body may arrive over multiple I/O loop iterations. Copy
524        // whatever the buffer has now; m_body's size tracks our progress.
525        const uint64_t body_need{*content_length - m_body.size()};
526        const uint64_t buffer_has{std::min(body_need, static_cast<uint64_t>(reader.Remaining()))};
527
528        // Pack [partial] body on and update state
529        m_body += reader.ReadLength(buffer_has);
530
531        return m_body.size() == *content_length;
532    }
533}
534
535void HTTPRequest::WriteReply(HTTPStatusCode status, std::span<const std::byte> reply_body)
536{
537    HTTPResponse res;
538
539    // Some response headers are determined in advance and stored in the request
540    res.headers = std::move(m_response_headers);
541
542    // Response version matches request version
543    res.version = m_version;
544
545    // Add response code
546    res.status = status;
547
548    // See libevent evhttp_response_needs_body()
549    // Response headers are different if no body is needed
550    bool needs_body{status != HTTP_NO_CONTENT && (status < 100 || status >= 200)};
551    bool needs_content_length{false};
552
553    bool keep_alive{false};
554
555    // See libevent evhttp_make_header_response()
556    // Expected response headers depend on protocol version
557    if (m_version.major == 1) {
558        // HTTP/1.0
559        if (m_version.minor == 0) {
560            auto connection_header{m_headers.FindFirst("Connection")};
561            if (connection_header && ToLower(connection_header.value()) == "keep-alive") {
562                res.headers.Write("Connection", "keep-alive");
563                keep_alive = true;
564                // HTTP/1.0 connections are closed by default so EOF is sufficient
565                // to indicate end of the body. Adding Content-Length a special case.
566                if (needs_body) needs_content_length = true;
567            }
568        }
569
570        // HTTP/1.1
571        if (m_version.minor >= 1) {
572            const int64_t now_seconds{TicksSinceEpoch<std::chrono::seconds>(NodeClock::now())};
573            res.headers.Write("Date", FormatRFC1123DateTime(now_seconds));
574
575            // HTTP/1.1 connections are kept alive by default and always require Content-Length.
576            if (needs_body) needs_content_length = true;
577
578            // Default for HTTP/1.1
579            keep_alive = true;
580        }
581    }
582
583    if (needs_content_length) {
584        res.headers.Write("Content-Length", util::ToString(reply_body.size()));
585    }
586
587    if (needs_body && !res.headers.FindFirst("Content-Type")) {
588        // Default type from libevent evhttp_new_object()
589        res.headers.Write("Content-Type", "text/html; charset=ISO-8859-1");
590    }
591
592    auto connection_header{m_headers.FindFirst("Connection")};
593    if (connection_header && ToLower(connection_header.value()) == "close") {
594        // Might not exist already but we need to replace it, not append to it
595        res.headers.RemoveAll("Connection");
596
597        res.headers.Write("Connection", "close");
598        keep_alive = false;
599    }
600
601    if (std::shared_ptr client{m_client.lock()}) {
602        client->Send(res, reply_body, keep_alive);
603    }
604}
605
606void HTTPRemoteClient::Send(const HTTPResponse& res, std::span<const std::byte> reply_body, bool keep_alive)
607{
608    m_keep_alive = keep_alive;
609
610    // Serialize the response headers
611    const std::string headers{res.StringifyHeaders()};
612    const auto headers_bytes{std::as_bytes(std::span{headers})};
613
614    bool send_buffer_was_empty{false};
615    // Fill the send buffer with the complete serialized response headers + body
616    {
617        LOCK(m_send_mutex);
618        send_buffer_was_empty = m_send_buffer.empty();
619        m_send_buffer.insert(m_send_buffer.end(), headers_bytes.begin(), headers_bytes.end());
620
621        // We've been using std::span up until now but it is finally time to copy
622        // data. The original data will go out of scope when WriteReply() returns.
623        // This is analogous to the memcpy() in libevent's evbuffer_add()
624        m_send_buffer.insert(m_send_buffer.end(), reply_body.begin(), reply_body.end());
625
626        // If the buffer already held data, the I/O thread is (or soon will be)
627        // draining it, so flag that there is more data to send. This must happen
628        // while holding m_send_mutex and while the buffer is known non-empty:
629        // setting m_send_ready after releasing the lock would race with the I/O
630        // thread draining the buffer to empty and clearing m_send_ready in
631        // between, leaving m_send_ready set on an empty buffer. The I/O loop would
632        // then only ever poll the socket for writeability, never read the client's
633        // next request, and wedge the connection.
634        if (!send_buffer_was_empty) m_send_ready = true;
635    }
636
637    LogDebug(
638        BCLog::HTTP,
639        "HTTPResponse (status code: %d size: %lld) added to send buffer for client %s (id=%llu)",
640        res.status,
641        headers_bytes.size() + reply_body.size(),
642        m_origin,
643        m_id);
644
645    // If the send buffer was empty before we wrote this reply, we can try an
646    // optimistic send akin to CConnman::PushMessage() in which we
647    // push the data directly out the socket to client right now, instead
648    // of waiting for the next iteration of the I/O loop.
649    if (send_buffer_was_empty) {
650        MaybeSendBytesFromBuffer();
651    }
652
653    // Signal to the I/O loop that we are ready to handle the next request.
654    m_req_busy = false;
655}
656
657CService HTTPRequest::GetPeer() const
658{
659    if (std::shared_ptr c{m_client.lock()}) {
660        return c->GetPeer();
661    } else {
662        return {};
663    }
664}
665
666std::optional<std::string> HTTPRequest::GetQueryParameter(const std::string_view key) const
667{
668    return GetQueryParameterFromUri(m_target, key);
669}
670
671// See libevent http.c evhttp_parse_query_impl()
672// and https://www.rfc-editor.org/rfc/rfc3986#section-3.4
673std::optional<std::string> GetQueryParameterFromUri(const std::string_view uri, const std::string_view key)
674{
675    // find query in URI
676    size_t start = uri.find('?');
677    if (start == std::string::npos) return std::nullopt;
678    size_t end = uri.find('#', start);
679    if (end == std::string::npos) {
680        end = uri.length();
681    }
682    const std::string_view query{uri.data() + start + 1, end - start - 1};
683    // find requested parameter in query
684    const std::vector<std::string_view> params{Split<std::string_view>(query, "&")};
685    for (const std::string_view& param : params) {
686        size_t delim = param.find('=');
687        if (key == UrlDecode(param.substr(0, delim))) {
688            if (delim == std::string::npos) {
689                return "";
690            } else {
691                return std::string(UrlDecode(param.substr(delim + 1)));
692            }
693        }
694    }
695    return std::nullopt;
696}
697
698std::optional<std::string> HTTPRequest::GetHeader(const std::string_view hdr) const
699{
700    return m_headers.FindFirst(hdr);
701}
702
703void HTTPRequest::WriteHeader(std::string&& hdr, std::string&& value)
704{
705    m_response_headers.Write(std::move(hdr), std::move(value));
706}
707
708util::Expected<void, std::string> HTTPServer::BindAndStartListening(const CService& to)
709{
710    // Create socket for listening for incoming connections
711    sockaddr_storage storage;
712    auto sa = reinterpret_cast<sockaddr*>(&storage);
713    socklen_t len{sizeof(storage)};
714    if (!to.GetSockAddr(sa, &len)) {
715        return util::Unexpected{strprintf("Bind address family for %s not supported", to.ToStringAddrPort())};
716    }
717
718    std::unique_ptr<Sock> sock{CreateSock(to.GetSAFamily(), SOCK_STREAM, IPPROTO_TCP)};
719    if (!sock) {
720        return util::Unexpected{strprintf("Cannot create %s listen socket: %s",
721                                          to.ToStringAddrPort(),
722                                          NetworkErrorString(WSAGetLastError()))};
723    }
724
725#ifdef WIN32
726    // Prevent another application from binding to the same address and port and
727    // intercepting RPC credentials.
728    // SO_REUSEADDR on Windows is non-exclusive so another process could bind to
729    // the same port.
730    if (sock->SetSockOpt(SOL_SOCKET, SO_EXCLUSIVEADDRUSE, &SOCKET_OPTION_TRUE, sizeof(SOCKET_OPTION_TRUE)) == SOCKET_ERROR) {
731        return util::Unexpected{strprintf("Cannot set SO_EXCLUSIVEADDRUSE on %s listen socket: %s",
732                                          to.ToStringAddrPort(),
733                                          NetworkErrorString(WSAGetLastError()))};
734    }
735#else
736    // Allow binding if the port is still in TIME_WAIT state after
737    // the program was closed and restarted.
738    if (sock->SetSockOpt(SOL_SOCKET, SO_REUSEADDR, &SOCKET_OPTION_TRUE, sizeof(SOCKET_OPTION_TRUE)) == SOCKET_ERROR) {
739        LogDebug(BCLog::HTTP,
740                 "Cannot set SO_REUSEADDR on %s listen socket: %s, continuing anyway",
741                 to.ToStringAddrPort(),
742                 NetworkErrorString(WSAGetLastError()));
743    }
744#endif
745
746    // some systems don't have IPV6_V6ONLY but are always v6only; others do have the option
747    // and enable it by default or not. Try to enable it, if possible.
748    if (to.IsIPv6()) {
749#ifdef IPV6_V6ONLY
750        if (sock->SetSockOpt(IPPROTO_IPV6, IPV6_V6ONLY, &SOCKET_OPTION_TRUE, sizeof(SOCKET_OPTION_TRUE)) == SOCKET_ERROR) {