Inside Bitcoin

751        auto req{HTTPRemoteClient::TryReadRequest(client)};
752        BOOST_CHECK_EQUAL(req->GetState(), HTTPRequest::State::Complete);
753        BOOST_CHECK_EQUAL(req->ReadBody(), "x");
754    }
755    {
756        // Ensure chunk trailer counts towards the headers size limit
757        std::shared_ptr<DummyClient> client{std::make_shared<DummyClient>()};
758        BOOST_CHECK(!client->GetRequest());
759
760        client->receive("POST /huge HTTP/1.0\n"
761                        "Transfer-Encoding: chunked\n"); //   27 bytes
762        for (int i = 0; i < 816; ++i) {
763            client->receive("key:value\n");              // 8160
764        }
765        client->receive("\n"                             //    1
766                        "1\n"
767                        "x\n"
768                        "0\n");
769        BOOST_CHECK(!HTTPRemoteClient::TryReadRequest(client));
770        BOOST_CHECK_EQUAL(client->GetRequest()->GetState(), HTTPRequest::State::NeedsBody);
771
772        // We're in the trailer section with a total of 8188 bytes of headers.
773        // The limit is 8192, five more bytes should throw.
774        client->receive("k:vv\n");
775        BOOST_CHECK(!HTTPRemoteClient::TryReadRequest(client));
776        BOOST_CHECK_EQUAL(client->GetRequest()->GetState(), HTTPRequest::State::Error);
777    }
778}
779
780BOOST_AUTO_TEST_CASE(http_server_socket_tests)
781{
782    // Hard code the timestamp for the Date header in the HTTP response
783    // Wed Dec 11 00:47:09 2024 UTC
784    FakeNodeClock clock{1733878029s};
785
786    // Prepare a request handler that just stores received requests so we can examine them.
787    // Mutex is required to prevent a race between this test's main thread and the server's I/O loop.
788    Mutex requests_mutex;
789    std::deque<std::unique_ptr<HTTPRequest>> requests;
790    auto StoreRequest = [&](std::unique_ptr<HTTPRequest>&& req) {
791        LOCK(requests_mutex);
792        requests.push_back(std::move(req));
793    };
794
795    HTTPServer server{StoreRequest};
796    server.InitHTTPAllowList();
797
798    {
799        // We can only bind to NET_IPV4 and NET_IPV6
800        CService onion_address{Lookup("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaam2dqd.onion", /*portDefault=*/0, /*fAllowLookup=*/false).value()};
801        auto result{server.BindAndStartListening(onion_address)};
802        BOOST_REQUIRE(!result);
803        BOOST_CHECK_EQUAL(result.error(), "Bind address family for aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaam2dqd.onion:0 not supported");
804    }
805
806    // This VALID address won't actually get used because we stubbed CreateSock()
807    CService addr_bind{Lookup("0.0.0.0", /*portDefault=*/0, /*fAllowLookup=*/false).value()};
808
809    // Init state
810    BOOST_REQUIRE_EQUAL(server.GetListeningSocketCount(), 0);
811    // Bind to mock Listening Socket
812    BOOST_REQUIRE(server.BindAndStartListening(addr_bind));
813    // We are bound and listening
814    BOOST_REQUIRE_EQUAL(server.GetListeningSocketCount(), 1);
815
816    // Start the I/O loop
817    server.StartSocketsThreads();
818
819    // No connections yet
820    BOOST_CHECK_EQUAL(server.GetConnectionsCount(), 0);
821
822    // Create a mock client with pre-loaded request data and add it to the local CreateSock queue.
823    // Keep a handle for the mock client's send and receive pipes so we can examine
824    // the data it "receives".
825    std::shared_ptr<DynSock::Pipes> mock_client_socket_pipes{ConnectClient(std::as_bytes(std::span(full_request)))};
826
827    // Wait up to a minute to find and connect the client in the I/O loop
828    int attempts{6000};
829    while (server.GetConnectionsCount() < 1) {
830        std::this_thread::sleep_for(10ms);
831        BOOST_REQUIRE(--attempts > 0);
832    }
833
834    // Prepare a pointer to the client, we'll assign it from the request itself.
835    std::shared_ptr<HTTPRemoteClient> client;
836
837    // Wait up to a minute to read the request from the client.
838    // Given that the mock client is itself a mock socket
839    // with hard-coded data it should only take a fraction of that.
840    attempts = 6000;
841    while (true) {
842        {
843            LOCK(requests_mutex);
844            // Connected client should have one request already from the static content.
845            if (requests.size() == 1) {
846                // Check the received request
847                BOOST_CHECK_EQUAL(requests.front()->ReadBody(), R"({"method":"getblockcount","params":[],"id":1})""\n");
848                BOOST_CHECK_EQUAL(requests.front()->GetPeer().ToStringAddrPort(), "5.5.5.5:6789");
849
850                // Inspect the connection pointed to from the request
851                client = requests.front()->GetClient();
852                BOOST_REQUIRE(client);
853                BOOST_CHECK_EQUAL(client->GetOrigin(), "5.5.5.5:6789");
854
855                // Respond to request
856                requests.front()->WriteReply(HTTP_OK, "874140\n");
857
858                break;
859            }
860        }
861        std::this_thread::sleep_for(10ms);
862        BOOST_REQUIRE(--attempts > 0);
863    }
864
865    // Check the sent response from the mock client at the other end of the mock socket
866    std::string actual;
867    // Wait up to one minute for all the bytes to appear in the "send" pipe.
868    char buf[0x10000] = {};
869    attempts = 6000;
870    while (attempts > 0)
871    {
872        ssize_t bytes_read = mock_client_socket_pipes->send.GetBytes(buf, sizeof(buf), 0);
873        if (bytes_read > 0) {
874            actual.append(buf, bytes_read);
875            if (actual.length() == 146) {
876                break;
877            }
878        }
879        std::this_thread::sleep_for(10ms);
880        --attempts;
881    }
882    BOOST_CHECK(actual.starts_with("HTTP/1.1 200 OK\r\n"));
883    BOOST_CHECK(actual.ends_with("\r\n874140\n"));
884    // Headers can be sorted in any order, and will be, since we use unordered_map
885    BOOST_CHECK(actual.find("Connection: close\r\n") != std::string::npos);
886    BOOST_CHECK(actual.find("Content-Length: 7\r\n") != std::string::npos);
887    BOOST_CHECK(actual.find("Content-Type: text/html; charset=ISO-8859-1\r\n") != std::string::npos);
888    BOOST_CHECK(actual.find("Date: Wed, 11 Dec 2024 00:47:09 GMT\r\n") != std::string::npos);
889
890    // Wait up to one minute for connection to be automatically closed, because
891    // keep-alive was not set by the client and we are done responding to their request.
892    attempts = 6000;
893    while (server.GetConnectionsCount() != 0) {
894        std::this_thread::sleep_for(10ms);
895        BOOST_REQUIRE(--attempts > 0);
896    }
897
898    // Stop the I/O loop and shutdown
899    server.InterruptNet();
900    // Wait for I/O loop to finish, after all connected sockets are closed
901    server.JoinSocketsThreads();
902    // Close all listening sockets
903    server.StopListening();
904}
905
906BOOST_AUTO_TEST_CASE(http_socket_error_tests)
907{
908    // Create a tiny threadpool for the HTTPRequest handler
909    ThreadPool workers("http");
910    workers.Start(1);
911
912    // Hard-code the server's request handler to respond to each request with
913    // an incremented block count. Handle the replies in the worker thread.
914    std::atomic<int> height{0};
915    HTTPServer server{[&](std::shared_ptr<HTTPRequest> req) {
916        auto item = [req, &height]() {
917            const int h = height.fetch_add(1);
918            req->WriteReply(HTTP_OK, strprintf("height: %d\n", h));
919        };
920        // Can't call BOOST_REQUIRE from worker thread
921        Assert(workers.Submit(std::move(item)));
922    }};
923    server.InitHTTPAllowList();
924
925    // All replies will be the same size
926    static constexpr std::size_t reply_length = std::string_view{
927        "HTTP/1.1 200 OK\r\n"
928        "Date: Thu, 01 Jan 2026 00:00:00 GMT\r\n"           // All RFC1123 dates are 29 characters
929        "Content-Length: 10\r\n"
930        "Content-Type: text/html; charset=ISO-8859-1\r\n"
931        "\r\n"
932        "height: 0\n"
933    }.size();
934
935    /**
936     * A mocked Sock derived from DynSock whose Send() only succeeds when there is more than
937     * one reply being sent (send buffer length > reply_length). Otherwise it returns
938     * a recoverable error (WSAEAGAIN).
939     *
940     * After it sends successfully once, it continues to always succeed.
941     *
942     * Useful for testing "try again" logic around non-blocking socket Send() failures.
943     */
944    class ErrorSock : public DynSock
945    {
946    public:
947        explicit ErrorSock(std::shared_ptr<Pipes> pipes) : DynSock{std::move(pipes)} {}
948        DynSock& operator=(Sock&&) override { assert(false); return *this; }
949
950        ssize_t Send(const void* buf, size_t len, int flags) const override
951        {
952            if (len <= reply_length && !m_have_sent) {
953                #ifdef WIN32
954                WSASetLastError(WSAEWOULDBLOCK);
955                #else
956                errno = WSAEAGAIN;
957                #endif
958                return -1;
959            } else {
960                m_have_sent = true;
961                return DynSock::Send(buf, len, flags);
962            }
963        }
964
965        mutable bool m_have_sent{false};
966    };
967
968    // Simpler server startup than the last test
969    CService addr_bind{Lookup("0.0.0.0", /*portDefault=*/0, /*fAllowLookup=*/false).value()};
970    BOOST_REQUIRE(server.BindAndStartListening(addr_bind));
971    server.StartSocketsThreads();
972
973    // Prepare initial requests
974    int num_requests = 2;
975    // Use keep-alive so the server holds the connection open for all requests.
976    std::string keepalive_request{full_request};
977    keepalive_request.replace(keepalive_request.find("Connection: close"), 17, "Connection: keep-alive");
978    // Combine all requests so they are read from the socket on a single iteration of the I/O loop
979    std::string all_requests;
980    for (int i = 0; i < num_requests; i++) {
981        all_requests += keepalive_request;
982    }
983
984    // Watch the log messages to ensure that the first two replies were sent
985    // together. This indicates the non-optimistic send path was used
986    // because a reply was already sitting in the send buffer when a second reply
987    // was added.
988    DebugLogHelper find_two_replies{strprintf("Sent %d bytes to client", reply_length * 2),
989                                    [&](const std::string* s) {
990                                        return true;
991                                    }};
992    // Last reply should be sent on its own by optimistic send path, because
993    // the send buffer was empty when the reply was written.
994    DebugLogHelper find_one_reply{strprintf("Sent %d bytes to client", reply_length),
995                                  [&](const std::string* s) {
996                                      return true;
997                                   }};
998
999    // Connect the ErrorSock as mock client with the preloaded data and get a handle on the I/O pipes
1000    std::shared_ptr<ErrorSock::Pipes> mock_client_socket_pipes{