copy_n_fast

Author: kelbon

include/hpack/basic_types.hpp

@@ -1,9 +1,9 @@
 #pragma once
 
+#include <algorithm>
 #include <cstdint>
 #include <iterator>
 #include <string_view>
-
 #include <exception>
 
 namespace hpack {
@@ -21,7 +21,11 @@ struct protocol_error : std::exception {
 
 // thrown if there are not enough data for reading header
 struct incomplete_data_error : hpack::protocol_error {
-  incomplete_data_error() : hpack::protocol_error("incomplete data") {
+  // approx value - how many bytes need to be readen for receiving next part (int or string)
+  size_t required_bytes = 0;
+
+  explicit incomplete_data_error(size_t required_bytes_approx)
+      : hpack::protocol_error("incomplete data"), required_bytes(required_bytes_approx) {
   }
 };
 
@@ -48,6 +52,8 @@ concept Out = std::output_iterator<T, byte_t>;
 
 namespace noexport {
 
+// caches first byte for avoiding *it = x == push_back,
+// so *it | mask will be into next byte (may be with back_inserter)
 template <typename T>
 struct adapted_output_iterator {
   T base_it;
@@ -102,6 +108,54 @@ Original unadapt(byte_t* ptr) {
   return reinterpret_cast<Original>(ptr);
 }
 
+// standard interface (e.g. for vector) for inserting many values at back
+// Note: ignores fact, that someone can make super-bad type with push_back + insert making something wrong
+template <typename T>
+constexpr inline bool can_insert_many =
+    requires(T& value, const char* p) { value.insert(value.end(), p, p); };
+
+// standard back_insert_iterator rly uses protected field exactly for such accessing
+template <typename C>
+C& access_protected_container(std::back_insert_iterator<C> c) {
+  static_assert(std::is_trivially_copyable_v<decltype(c)>);
+  struct accessor : std::back_insert_iterator<C> {
+    C* get() noexcept {
+      return this->container;
+    }
+  };
+  return *accessor(c).get();
+}
+
+template <typename C>
+  requires(can_insert_many<C>)
+std::back_insert_iterator<C> do_copy_n_fast(const char* ptr, size_t sz, std::back_insert_iterator<C> it) {
+  auto& c = access_protected_container(it);
+  c.insert(c.end(), ptr, ptr + sz);
+  return it;  // back insert iterator does not change on ++/* etc
+}
+
+template <typename C>
+  requires(can_insert_many<C>)
+adapted_output_iterator<std::back_insert_iterator<C>> do_copy_n_fast(
+    const char* ptr, size_t sz, adapted_output_iterator<std::back_insert_iterator<C>> it) {
+  auto& c = access_protected_container(it.base_it);
+  c.insert(c.end(), ptr, ptr + sz);
+  return it;  // adapted iterator must be unchanged, since base_it unchanged (its back inserter)
+}
+
+// fallback
+template <typename It>
+It do_copy_n_fast(const char* ptr, size_t sz, It it) {
+  return std::copy_n(ptr, sz, std::move(it));
+}
+
+// makes copy_n, but for back_insert iterator makes insert(end, It, It + n)
+// this converts many push_backs into one uninitialized_copy_n
+template <typename It>
+It copy_n_fast(const char* ptr, size_t sz, It it) {
+  return do_copy_n_fast(ptr, sz, std::move(it));
+}
+
 }  // namespace noexport
 
 struct table_entry {

include/hpack/decoder.hpp

@@ -165,11 +165,12 @@ struct stream_decoder {
 
   // returns where first unparsed byte starts
   template <typename V>
-  In do_feed(std::span<byte_t> chunk, bool last_chunk, V&& visitor) {
+  In do_feed(std::span<byte_t> chunk, bool last_chunk, V&& visitor, size_t& approx) {
     In in = chunk.data();
     In e = in + chunk.size();
     assert(in != e);
     In in_just_before_fail;
+    approx = 0;
     try {
       header_view header;
       while (in != e) {
@@ -182,11 +183,12 @@ struct stream_decoder {
       }
       // successfully parsed all headers
       return e;
-    } catch (hpack::incomplete_data_error&) {
+    } catch (hpack::incomplete_data_error& e) {
+      approx = e.required_bytes;
       if (last_chunk)
         throw;
+      return in_just_before_fail;
     }
-    return in_just_before_fail;
   }
 
  public:
@@ -198,22 +200,27 @@ struct stream_decoder {
 
   // `visitor` should accept two string_views, name and value
   // optimized for case when each `chunk` >> 1 header
+  // returns approx count of bytes required for receiving next part of header
+  // or 0 if there are no unhandled data in chunk
+  // e.g. may be used to detect too big string before receiving it
   template <typename V>
-  void feed(std::span<byte_t> chunk, bool last_chunk, V&& visitor) {
+  size_t feed(std::span<byte_t> chunk, bool last_chunk, V&& visitor) {
     if (chunk.empty()) [[unlikely]]
-      return;
+      return 0;
+    size_t approx;
     if (!incomplete.empty()) {
       incomplete.insert(incomplete.end(), chunk.begin(), chunk.end());
-      In i = do_feed(incomplete, last_chunk, std::forward<V>(visitor));
+      In i = do_feed(incomplete, last_chunk, std::forward<V>(visitor), approx);
       In e = incomplete.data() + incomplete.size();
       auto sz = e - i;
       // avoid UB on .assign (iterators into vector itself)
       memmove(incomplete.data(), i, sz);
       incomplete.resize(sz);
     } else {
-      In i = do_feed(chunk, last_chunk, std::forward<V>(visitor));
+      In i = do_feed(chunk, last_chunk, std::forward<V>(visitor), approx);
       incomplete.assign(i, In(chunk.data()) + chunk.size());
     }
+    return approx;
   }
 
   // makes possible start from beginning, forgetting previous `feed` calls

include/hpack/integers.hpp

@@ -56,7 +56,7 @@ template <std::unsigned_integral UInt = size_type>
   const UInt prefix_mask = (1 << N) - 1;
   auto pull = [&] {
     if (in == e)
-      throw incomplete_data_error();
+      throw incomplete_data_error(2);
     auto i = *in;
     ++in;
     return i;

include/hpack/strings.hpp

@@ -57,7 +57,7 @@ O encode_string(std::string_view str, O _out) {
   if constexpr (!Huffman) {
     *out = 0;  // set H bit to 0
     out = encode_integer(str.size(), 7, out);
-    out = std::copy_n(str.data(), str.size(), out);
+    out = noexport::copy_n_fast(str.data(), str.size(), out);
   } else {
     out = encode_string_huffman(str, out);
   }

src/decoder.cpp

@@ -158,11 +158,11 @@ static size_type decode_dynamic_table_size_update(In& in, In e) {
 
 void decode_string(In& in, In e, decoded_string& out) {
   if (in == e)
-    throw incomplete_data_error();
+    throw incomplete_data_error(1);
   bool is_huffman = *in & 0b1000'0000;
   size_type str_len = decode_integer(in, e, 7);
   if (str_len > std::distance(in, e))
-    throw incomplete_data_error();
+    throw incomplete_data_error(str_len - std::distance(in, e));
   if (is_huffman)
     out.set_huffman((const char*)in, str_len);
   else

tests/test_hpack.cpp

@@ -568,6 +568,23 @@ TEST(stream_decoder) {
   }
 }
 
+TEST(stream_decoder_big_str) {
+  std::string name = "abchdr";
+  std::string value(15000, 'A');
+  hpack::encoder e;
+  bytes_t bytes;
+  e.encode_header_never_indexing(name, value, std::back_inserter(bytes));
+  hpack::decoder d;
+  hpack::stream_decoder sd(d);
+  error_if(bytes.size() < value.size());
+  auto vtor = [](std::string_view, std::string_view) { error_if(true); };
+  size_t required = sd.feed({bytes.data(), bytes.size() - 1}, false, vtor);
+  error_if(required != 1);
+  sd.clear();
+  required = sd.feed({bytes.data(), 8 /*name*/ + 3 /*str size*/ + 1 /*used byte from str*/}, false, vtor);
+  error_if(required != value.size() - 1);
+}
+
 TEST(decode_status) {
   hpack::encoder e;
   hpack::decoder de;
@@ -1102,6 +1119,7 @@ TEST(encode_with_cache) {
 }
 
 int main() {
+  test_stream_decoder_big_str();
   test_stream_decoder();
   test_tg_answer_parts();
   test_dyntable_move();