Inside Bitcoin

501
502        client->receive("Host: 127.0.0.1\n"
503                        "Content-Length: 10\n\n");
504        BOOST_CHECK(!HTTPRemoteClient::TryReadRequest(client));
505        BOOST_CHECK_EQUAL(client->GetRequest()->GetState(), HTTPRequest::State::NeedsBody);
506
507        client->receive("I miss you\n");
508        auto req{HTTPRemoteClient::TryReadRequest(client)};
509        BOOST_REQUIRE(req);
510        BOOST_CHECK_EQUAL(req->GetState(), HTTPRequest::State::Complete);
511    }
512    {
513        // Read body over multiple data pushes, multiple requests in same push
514        std::shared_ptr<DummyClient> client{std::make_shared<DummyClient>()};
515        BOOST_CHECK(!client->GetRequest());
516
517        client->receive("POST / HTTP/1.0\n"
518                        "Host: 127.0.0.1\n"
519                        "Content-Length: 10\n\n"
520                        "I miss");
521        BOOST_CHECK(!HTTPRemoteClient::TryReadRequest(client));
522        // Because of the Content-Length header we know the body is not complete
523        BOOST_CHECK_EQUAL(client->GetRequest()->GetState(), HTTPRequest::State::NeedsBody);
524
525        // Finish sending first request and include second request in the same buffer
526        client->receive(" you"
527                        "GET /endpoint HTTP/1.0\n\n");
528        auto req{HTTPRemoteClient::TryReadRequest(client)};
529        BOOST_REQUIRE(req);
530        BOOST_CHECK_EQUAL(req->GetState(), HTTPRequest::State::Complete);
531        BOOST_CHECK_EQUAL(req->GetURI(), "/");
532        BOOST_CHECK(!client->GetRequest());
533        BOOST_CHECK_EQUAL(req->ReadBody(), "I miss you");
534        req->WriteReply(HTTP_OK, ""); // Mark client as no longer busy
535        // Next request sitting in buffer
536        BOOST_CHECK_EQUAL(client->GetRecvBuffer().size(), 24);
537
538        // Read second request
539        req = HTTPRemoteClient::TryReadRequest(client);
540        BOOST_REQUIRE(req);
541        BOOST_CHECK(!client->GetRequest());
542        BOOST_CHECK_EQUAL(req->GetState(), HTTPRequest::State::Complete);
543        BOOST_CHECK_EQUAL(req->GetURI(), "/endpoint");
544        BOOST_CHECK_EQUAL(req->ReadBody().size(), 0);
545        // Buffer is cleared
546        BOOST_CHECK_EQUAL(client->GetRecvBuffer().size(), 0);
547    }
548    {
549        // A Content-Length body is drained out of the receive buffer as it
550        // arrives, instead of accumulating there until the request is complete.
551
552        std::shared_ptr<DummyClient> client{std::make_shared<DummyClient>()};
553        BOOST_CHECK(!client->GetRequest());
554
555        client->receive("POST / HTTP/1.0\n"
556                        "Content-Length: 30000\n\n");
557        HTTPRemoteClient::TryReadRequest(client);
558        BOOST_CHECK_EQUAL(client->GetRequest()->GetState(), HTTPRequest::State::NeedsBody);
559
560        // Body arrives in 10kB pieces. Each one is copied onto m_body and
561        // erased from the receive buffer, which never holds more than one piece.
562        for (int i = 1; i <= 3; ++i) {
563            client->receive(std::string(10000, 'x'));
564            BOOST_CHECK_EQUAL(client->GetRecvBuffer().size(), 10000);
565            auto req{HTTPRemoteClient::TryReadRequest(client)};
566            if (i < 3) {
567                BOOST_CHECK(!req.get());
568                BOOST_CHECK_EQUAL(client->GetRequest()->ReadBody().size(), 10000 * i);
569            } else {
570                BOOST_CHECK(req.get());
571                BOOST_CHECK_EQUAL(req->ReadBody().size(), 10000 * i);
572                BOOST_CHECK_EQUAL(req->GetState(), HTTPRequest::State::Complete);
573                BOOST_CHECK(!client->GetRequest());
574            }
575            BOOST_CHECK_EQUAL(client->GetRecvBuffer().size(), 0);
576        }
577    }
578    {
579        // A body sent in the same push as the next request is split correctly
580        std::shared_ptr<DummyClient> client{std::make_shared<DummyClient>()};
581        BOOST_CHECK(!client->GetRequest());
582
583        client->receive("POST / HTTP/1.0\n"
584                        "Content-Length: 4\n\n"
585                        "body"
586                        "GET /next HTTP/1.0\n\n");
587        auto req{HTTPRemoteClient::TryReadRequest(client)};
588        BOOST_CHECK_EQUAL(req->GetState(), HTTPRequest::State::Complete);
589        BOOST_CHECK_EQUAL(req->ReadBody(), "body");
590        // Only the second request is left over
591        BOOST_CHECK_EQUAL(client->GetRecvBuffer().size(), 20);
592    }
593    {
594        // Chunked transfer with state
595        std::shared_ptr<DummyClient> client{std::make_shared<DummyClient>()};
596        BOOST_CHECK(!client->GetRequest());
597
598        // First chunk is incomplete
599        client->receive("GET / HTTP/1.0\n"
600                        "Transfer-Encoding: chunked\n"
601                        "\n"
602                        "10\n"
603                        R"({"method)");
604        BOOST_CHECK(!HTTPRemoteClient::TryReadRequest(client));
605        BOOST_REQUIRE(client->GetRequest()->GetChunkSize());
606        BOOST_CHECK_EQUAL(*client->GetRequest()->GetChunkSize(), 16);
607        BOOST_CHECK_EQUAL(client->GetRequest()->GetChunkProgress(), 8);
608        BOOST_CHECK_EQUAL(client->GetRequest()->ReadBody().size(), 8);
609        BOOST_CHECK_EQUAL(client->GetRequest()->GetState(), HTTPRequest::State::NeedsBody);
610
611        // More data arrives, chunk is completed.
612        client->receive(R"(":"getbl)""\n");
613        BOOST_CHECK(!HTTPRemoteClient::TryReadRequest(client));
614        // State is reset
615        BOOST_CHECK(!client->GetRequest()->GetChunkSize());
616        BOOST_CHECK_EQUAL(client->GetRequest()->GetChunkProgress(), 0);
617        // New data is added to body but body is still incomplete
618        BOOST_CHECK_EQUAL(client->GetRequest()->ReadBody().size(), 16);
619        BOOST_CHECK_EQUAL(client->GetRequest()->GetState(), HTTPRequest::State::NeedsBody);
620
621        // Next chunk arrives without terminal CRLF
622        client->receive("a\n"
623                        R"(ockcount"})");
624        BOOST_CHECK(!HTTPRemoteClient::TryReadRequest(client));
625        BOOST_CHECK(client->GetRequest()->GetChunkSize());
626        BOOST_CHECK_EQUAL(*client->GetRequest()->GetChunkSize(), 10);
627        BOOST_CHECK_EQUAL(client->GetRequest()->GetChunkProgress(), 10);
628        BOOST_CHECK_EQUAL(client->GetRequest()->ReadBody().size(), 26);
629        BOOST_CHECK_EQUAL(client->GetRequest()->GetState(), HTTPRequest::State::NeedsBody);
630
631        // Chunk terminal CRLF arrives with final (size 0) chunk
632        client->receive("\n0\n\n");
633        auto req{HTTPRemoteClient::TryReadRequest(client)};
634        // Body size hasn't changed
635        BOOST_CHECK_EQUAL(req->ReadBody().size(), 26);
636        // We're done
637        BOOST_CHECK_EQUAL(req->GetState(), HTTPRequest::State::Complete);
638        BOOST_CHECK_EQUAL(req->ReadBody(), R"({"method":"getblockcount"})");
639    }
640    {
641        // Invalid headers: error state stops reading
642        std::shared_ptr<DummyClient> client{std::make_shared<DummyClient>()};
643
644        // Request is in the buffer
645        client->receive("POST / HTTP/1.0\n"
646                        "Host: 127.0.0.1\n");
647        BOOST_CHECK(!client->GetRecvBuffer().empty());
648        BOOST_CHECK(!HTTPRemoteClient::TryReadRequest(client));
649        BOOST_CHECK_EQUAL(client->GetRequest()->GetState(), HTTPRequest::State::NeedsHeaders);
650        client->receive("Invalid header with no colon\n"
651                        "\n"
652                        "body is not read");
653        // Reading throws an error, sets state
654        BOOST_CHECK(!HTTPRemoteClient::TryReadRequest(client));
655        BOOST_CHECK_EQUAL(client->GetRequest()->GetState(), HTTPRequest::State::Error);
656
657        // We read up to the invalid line
658        BOOST_CHECK_EQUAL(client->GetRequest()->GetHeader("Host"), "127.0.0.1");
659        // Buffer was cleared, client should just be disconnected now
660        BOOST_CHECK(client->GetRecvBuffer().empty());
661
662        // Even if more data comes in, trying to read again in error state is a no-op
663        client->receive("Content-Length: 2\n\nok");
664        BOOST_CHECK_EQUAL(client->GetRecvBuffer().size(), 21);
665        BOOST_CHECK(!HTTPRemoteClient::TryReadRequest(client));
666        BOOST_CHECK_EQUAL(client->GetRecvBuffer().size(), 21);
667    }
668    {
669        // Headers sent in batches that are below MAX_HEADERS_SIZE but the total is excessive
670        std::shared_ptr<DummyClient> client{std::make_shared<DummyClient>()};
671        BOOST_CHECK(!client->GetRequest());
672        BOOST_CHECK(!HTTPRemoteClient::TryReadRequest(client));
673        BOOST_CHECK_EQUAL(client->GetRequest()->GetState(), HTTPRequest::State::Init);
674
675        client->receive("POST /huge HTTP/1.0\n");
676        BOOST_CHECK(!HTTPRemoteClient::TryReadRequest(client));
677        BOOST_CHECK_EQUAL(client->GetRequest()->GetState(), HTTPRequest::State::NeedsHeaders);
678
679        for (int i = 0; i < 410; ++i) {
680            client->receive("key:value\n");
681        }
682        BOOST_CHECK(!HTTPRemoteClient::TryReadRequest(client));
683        BOOST_CHECK_EQUAL(client->GetRequest()->GetState(), HTTPRequest::State::NeedsHeaders);
684
685        for (int i = 0; i < 409; ++i) {
686            client->receive("key:value\n");
687        }
688        BOOST_CHECK(!HTTPRemoteClient::TryReadRequest(client));
689        BOOST_CHECK_EQUAL(client->GetRequest()->GetState(), HTTPRequest::State::NeedsHeaders);
690
691        // We're at 819 x 10-byte headers
692        // The limit is 8192, three more bytes should throw.
693        client->receive("k:\n");
694        BOOST_CHECK(!HTTPRemoteClient::TryReadRequest(client));
695        BOOST_CHECK_EQUAL(client->GetRequest()->GetState(), HTTPRequest::State::Error);
696    }
697    {
698        // Client sends chunks that are below the limit but the total is excessive
699        std::shared_ptr<DummyClient> client{std::make_shared<DummyClient>()};
700        BOOST_CHECK(!HTTPRemoteClient::TryReadRequest(client));
701        BOOST_CHECK_EQUAL(client->GetRequest()->GetState(), HTTPRequest::State::Init);
702
703        client->receive("POST /huge HTTP/1.0\n");
704        BOOST_CHECK(!HTTPRemoteClient::TryReadRequest(client));
705        BOOST_CHECK_EQUAL(client->GetRequest()->GetState(), HTTPRequest::State::NeedsHeaders);
706
707        client->receive("Transfer-Encoding: chunked\n\n");
708        BOOST_CHECK(!HTTPRemoteClient::TryReadRequest(client));
709        BOOST_CHECK_EQUAL(client->GetRequest()->GetState(), HTTPRequest::State::NeedsBody);
710
711        // Send 16-byte chunk
712        client->receive("10\nno auto updates!\n");
713        BOOST_CHECK(!HTTPRemoteClient::TryReadRequest(client));
714        BOOST_CHECK_EQUAL(client->GetRequest()->GetState(), HTTPRequest::State::NeedsBody);
715
716        // The next chunk will be of size 32MiB - 16 + 1, below the limit
717        // on its own but not if it were added to the total cumulative body so far.
718        // We don't need to actually send or prepare this amount of data.
719        client->receive("1fffff1\n");
720        BOOST_CHECK(!HTTPRemoteClient::TryReadRequest(client));
721        BOOST_CHECK_EQUAL(client->GetRequest()->GetState(), HTTPRequest::State::Error);
722    }
723    {
724        // Ensure chunk trailer is parsed over state lines
725        std::shared_ptr<DummyClient> client{std::make_shared<DummyClient>()};
726        BOOST_CHECK(!client->GetRequest());
727
728        // Send a 1-byte chunk then send the 0-chunk with a trailer but no terminal CRLF
729        client->receive("GET / HTTP/1.0\n"
730                        "Transfer-Encoding: chunked\n"
731                        "\n"
732                        "1\n"
733                        "x\n"
734                        "0\n"
735                        "Digest: sha-4=deadbeef\n");
736        BOOST_CHECK(!HTTPRemoteClient::TryReadRequest(client));
737        BOOST_CHECK_EQUAL(client->GetRequest()->GetState(), HTTPRequest::State::NeedsBody);
738
739        // Send first part of another trailer line
740        client->receive("Expires:");
741        BOOST_CHECK(!HTTPRemoteClient::TryReadRequest(client));
742        BOOST_CHECK_EQUAL(client->GetRequest()->GetState(), HTTPRequest::State::NeedsBody);
743
744        // Finish the trailer line
745        client->receive("never\n");
746        BOOST_CHECK(!HTTPRemoteClient::TryReadRequest(client));
747        BOOST_CHECK_EQUAL(client->GetRequest()->GetState(), HTTPRequest::State::NeedsBody);
748
749        // Terminate
750        client->receive("\n");