Add parser::has_buffered_data()

Author: ashtum

include/boost/http/parser.hpp

@@ -307,6 +307,28 @@ class parser
     core::string_view
     body() const;
 
+    /** Return true if data is buffered past the message.
+
+        After a complete message, returns true when the
+        parser's buffer still holds octets that lie
+        beyond it, such as the start of a pipelined
+        message or data the peer sent past the message
+        framing. Returns false before the message is
+        complete.
+
+        This does not include the message body, which is
+        retrieved separately via @ref body or
+        @ref pull_body.
+
+        @return true if octets remain buffered past the
+        completed message.
+
+        @see @ref is_complete, @ref release_buffered_data.
+    */
+    BOOST_HTTP_DECL
+    bool
+    has_buffered_data() const noexcept;
+
     /** Return unconsumed data past the last message.
 
         Use this after an upgrade or CONNECT request

src/parser.cpp

@@ -1322,6 +1322,17 @@ class parser::impl
             body_avail_);
     }
 
+    bool
+    has_buffered_data() const noexcept
+    {
+        if(state_ != state::complete)
+            return false;
+
+        if(is_plain())
+            return cb0_.size() > body_avail_;
+        return cb0_.size() > 0;
+    }
+
     void
     set_body_limit(std::uint64_t n)
     {
@@ -1578,6 +1589,14 @@ release_buffered_data() noexcept
     return {};
 }
 
+bool
+parser::
+has_buffered_data() const noexcept
+{
+    BOOST_ASSERT(impl_);
+    return impl_->has_buffered_data();
+}
+
 void
 parser::
 set_body_limit(std::uint64_t n)

test/unit/parser.cpp

@@ -1776,6 +1776,7 @@ struct parser_test
             BOOST_TEST(! ec);
             BOOST_TEST(pr.is_complete());
             BOOST_TEST_EQ(pr.body(), body);
+            BOOST_TEST(pr.has_buffered_data());
         };
 
         check(
@@ -1792,6 +1793,99 @@ struct parser_test
             "okX", "ok");
     }
 
+    void
+    testHasBufferedData()
+    {
+        parser_config cfg{false};
+        cfg.headers.max_size = 100;
+        cfg.min_buffer = 100;
+        auto pcfg = make_parser_config(cfg);
+
+        auto const check = [&pcfg](
+            core::string_view octets,
+            core::string_view body,
+            bool buffered)
+        {
+            response_parser pr(pcfg);
+            pr.reset();
+            pr.start();
+            pr.commit(capy::buffer_copy(
+                pr.prepare(),
+                capy::const_buffer(
+                    octets.data(), octets.size())));
+
+            system::error_code ec;
+            pr.parse(ec);
+            BOOST_TEST(! ec);
+            BOOST_TEST(pr.got_header());
+            pr.parse(ec);
+            BOOST_TEST(! ec);
+            BOOST_TEST(pr.is_complete());
+
+            // the body is not counted as buffered data
+            BOOST_TEST_EQ(pr.body(), body);
+            BOOST_TEST_EQ(pr.has_buffered_data(), buffered);
+        };
+
+        check(
+            "HTTP/1.1 200 OK\r\n"
+            "Content-Length: 2\r\n"
+            "\r\n"
+            "ok", "ok", false);
+
+        check(
+            "HTTP/1.1 200 OK\r\n"
+            "Content-Length: 2\r\n"
+            "\r\n"
+            "ok"
+            "HTTP/1.1 200 OK\r\n", "ok", true);
+
+        check(
+            "HTTP/1.1 200 OK\r\n"
+            "Content-Length: 2\r\n"
+            "\r\n"
+            "okX", "ok", true);
+
+        check(
+            "HTTP/1.1 200 OK\r\n"
+            "Transfer-Encoding: chunked\r\n"
+            "\r\n"
+            "2\r\nok\r\n0\r\n\r\n", "ok", false);
+
+        check(
+            "HTTP/1.1 200 OK\r\n"
+            "Transfer-Encoding: chunked\r\n"
+            "\r\n"
+            "2\r\nok\r\n0\r\n\r\n"
+            "GARBAGE", "ok", true);
+
+        check(
+            "HTTP/1.1 204 No Content\r\n"
+            "\r\n"
+            "GARBAGE", "", true);
+
+        {
+            response_parser pr(pcfg);
+            pr.reset();
+            pr.start();
+            core::string_view octets =
+                "HTTP/1.1 200 OK\r\n"
+                "Content-Length: 10\r\n"
+                "\r\n"
+                "123"; // body incomplete
+            pr.commit(capy::buffer_copy(
+                pr.prepare(),
+                capy::const_buffer(
+                    octets.data(), octets.size())));
+            system::error_code ec;
+            pr.parse(ec);
+            BOOST_TEST(pr.got_header());
+            pr.parse(ec);
+            BOOST_TEST(! pr.is_complete());
+            BOOST_TEST(! pr.has_buffered_data());
+        }
+    }
+
     void
     run()
     {
@@ -1809,6 +1903,7 @@ struct parser_test
         testSetBodyLimit();
         testAccessHeaderAfterBodyError();
         testBodyWithTrailingData();
+        testHasBufferedData();
 #else
         // For profiling
         for(int i = 0; i < 10000; ++i )