Move to_bson's binary subtype check into calc_bson_sizes

to_bson() rejected a binary value's subtype above 255 (out_of_range.415)
in write_bson_binary(), which only has the binary_t, not the basic_json
value that holds it, so the exception was created with no JSON_DIAGNOSTICS
context even though the equivalent to_msgpack() check names the value's
path. The check also ran after the document size, all preceding elements,
and this element's header and length had already reached the output
adapter, so a caller-provided std::vector or std::string ended up holding
a truncated document.

calc_bson_sizes() already walks every value before anything is written,
to size embedded documents and arrays and to reject invalid keys
(out_of_range.409) up front. The subtype check now runs there instead,
in calc_bson_binary_size(), which is given the basic_json value so the
exception can use it as context. The now-redundant check in
write_bson_binary() is removed, since calc_bson_sizes() always throws
first if any binary value in the document has an oversized subtype.

Fixes #5675.

Signed-off-by: Niels Lohmann <mail@nlohmann.me>

docs/mkdocs/docs/api/basic_json/to_bson.md

@@ -43,6 +43,9 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
 - Throws [`out_of_range.412`](../../home/exceptions.md#jsonexceptionout_of_range412) if the length of a document, array,
   string, or binary value exceeds the range of the 32-bit BSON length field; example:
   `"BSON length 2147483661 exceeds maximum of 2147483647"`
+- Throws [`out_of_range.415`](../../home/exceptions.md#jsonexceptionout_of_range415) if the subtype of a binary value
+  exceeds 255, the maximum of the BSON binary subtype; example:
+  `"subtype 70000 is too large for the BSON binary subtype (max 255)"`
 
 ## Complexity
 
@@ -78,3 +81,4 @@ pass before anything is written.
 
 - Added in version 3.4.0.
 - Linear in the size of `j`, and no longer limited by the call stack for deeply nested values, since version 3.13.0.
+- `out_of_range.415` is now detected before anything is written, like the other exceptions above, since version 3.13.0.

docs/mkdocs/docs/api/macros/json_brace_init_copy_semantics.md

@@ -50,11 +50,9 @@ The default value is `0` (disabled — existing behavior is preserved).
     ```
 
     Code that relies on these producing arrays must use `json::array()` instead (see below). Lists with more than one
-    element, and a single `[string, value]` pair *written as a braced list*, such as `{{"key", "value"}}`, which still
-    creates an object, are not affected. This exception is based on how the pair is written, not on the shape of its
-    value: an existing JSON value that happens to be a two-element array with a string as its first element, such as
-    `json arr = {"key", 42};`, is still copied by `json j{arr};` rather than turned into an object. The library's own
-    conversions are not affected either: for example, `std::tuple<int>{5}` still becomes `[5]`.
+    element, and a single `[string, value]` pair such as `{{"key", "value"}}`, which still creates an object, are not
+    affected. The library's own conversions are not affected either: for example, `std::tuple<int>{5}` still becomes
+    `[5]`.
 
 !!! note "ABI compatibility"
 

include/nlohmann/detail/json_ref.hpp

@@ -34,7 +34,6 @@ class json_ref
 
     json_ref(std::initializer_list<json_ref> init)
         : owned_value(init)
-        , braced_list(true)
     {}
 
     template <
@@ -70,17 +69,9 @@ class json_ref
         return &** this;
     }
 
-    /// whether the value was written as a braced list, such as {"key", 1},
-    /// rather than given as a value
-    bool is_braced_list() const noexcept
-    {
-        return braced_list;
-    }
-
   private:
     mutable value_type owned_value = nullptr;
     value_type const* value_ref = nullptr;
-    bool braced_list = false;
 };
 
 }  // namespace detail

include/nlohmann/detail/output/binary_writer.hpp

@@ -1055,15 +1055,26 @@ class binary_writer
     }
 
     /*!
-    @return The size of the BSON-encoded binary array @a value
+    @return The size of the BSON-encoded binary array in @a j
+    @throw out_of_range.415 if the subtype of @a j does not fit into a byte,
+           before anything is written
     */
-    static std::size_t calc_bson_binary_size(const typename BasicJsonType::binary_t& value)
+    static std::size_t calc_bson_binary_size(const BasicJsonType& j)
     {
+        const auto& value = *j.m_data.m_value.binary;
+
+        if (value.has_subtype() && JSON_HEDLEY_UNLIKELY(value.subtype() > (std::numeric_limits<std::uint8_t>::max)()))
+        {
+            JSON_THROW(out_of_range::create(415, concat("subtype ", std::to_string(value.subtype()), " is too large for the BSON binary subtype (max 255)"), &j));
+        }
+
         return sizeof(std::int32_t) + value.size() + 1ul;
     }
 
     /*!
     @brief Writes a BSON element with key @a name and binary value @a value
+    @pre    @a value's subtype, if any, fits into a byte; @ref calc_bson_sizes
+            checks this for every binary value in the document beforehand.
     */
     void write_bson_binary(const string_t& name,
                            const binary_t& value)
@@ -1072,11 +1083,6 @@ class binary_writer
 
         write_number<std::int32_t>(to_bson_length(value.size()), true);
 
-        if (value.has_subtype() && JSON_HEDLEY_UNLIKELY(value.subtype() > (std::numeric_limits<std::uint8_t>::max)()))
-        {
-            JSON_THROW(out_of_range::create(415, concat("subtype ", std::to_string(value.subtype()), " is too large for the BSON binary subtype (max 255)"), nullptr));
-        }
-
         write_number(value.has_subtype() ? static_cast<std::uint8_t>(value.subtype()) : static_cast<std::uint8_t>(0x00));
 
         oa.write_characters(reinterpret_cast<const CharType*>(value.data()), value.size());
@@ -1085,13 +1091,15 @@ class binary_writer
     /*!
     @return The size of the value of the BSON document entry for @a j, which
             is neither an object nor an array
+    @throw out_of_range.415 if @a j is binary with a subtype that does not fit
+           into a byte, before anything is written
     */
     static std::size_t calc_bson_value_size(const BasicJsonType& j)
     {
         switch (j.type())
         {
             case value_t::binary:
-                return calc_bson_binary_size(*j.m_data.m_value.binary);
+                return calc_bson_binary_size(j);
 
             case value_t::boolean:
                 return 1ul;
@@ -1217,6 +1225,8 @@ class binary_writer
     @return the size of @a document
     @throw out_of_range.409 if a key contains U+0000, before anything is
            written
+    @throw out_of_range.415 if a binary value's subtype does not fit into a
+           byte, before anything is written
     */
     static std::size_t calc_bson_sizes(const BasicJsonType& document, std::vector<std::size_t>& nested_sizes)
     {

include/nlohmann/json.hpp

@@ -1672,18 +1672,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                bool type_deduction = true,
                value_t manual_type = value_t::array)
     {
-#if JSON_BRACE_INIT_COPY_SEMANTICS
-        // a single element that is a value rather than a braced list is
-        // copied or moved as is, whatever its content looks like
-        if (type_deduction && init.size() == 1 && !init.begin()->is_braced_list())
-        {
-            *this = init.begin()->moved_or_copied();
-            set_parents();
-            assert_invariant();
-            return;
-        }
-#endif
-
         // check if each element is an array with two elements whose first
         // element is a string
         bool is_an_object = std::all_of(init.begin(), init.end(),

single_include/nlohmann/json.hpp

@@ -20047,7 +20047,6 @@ class json_ref
 
     json_ref(std::initializer_list<json_ref> init)
         : owned_value(init)
-        , braced_list(true)
     {}
 
     template <
@@ -20083,17 +20082,9 @@ class json_ref
         return &** this;
     }
 
-    /// whether the value was written as a braced list, such as {"key", 1},
-    /// rather than given as a value
-    bool is_braced_list() const noexcept
-    {
-        return braced_list;
-    }
-
   private:
     mutable value_type owned_value = nullptr;
     value_type const* value_ref = nullptr;
-    bool braced_list = false;
 };
 
 }  // namespace detail
@@ -21394,15 +21385,26 @@ class binary_writer
     }
 
     /*!
-    @return The size of the BSON-encoded binary array @a value
+    @return The size of the BSON-encoded binary array in @a j
+    @throw out_of_range.415 if the subtype of @a j does not fit into a byte,
+           before anything is written
     */
-    static std::size_t calc_bson_binary_size(const typename BasicJsonType::binary_t& value)
+    static std::size_t calc_bson_binary_size(const BasicJsonType& j)
     {
+        const auto& value = *j.m_data.m_value.binary;
+
+        if (value.has_subtype() && JSON_HEDLEY_UNLIKELY(value.subtype() > (std::numeric_limits<std::uint8_t>::max)()))
+        {
+            JSON_THROW(out_of_range::create(415, concat("subtype ", std::to_string(value.subtype()), " is too large for the BSON binary subtype (max 255)"), &j));
+        }
+
         return sizeof(std::int32_t) + value.size() + 1ul;
     }
 
     /*!
     @brief Writes a BSON element with key @a name and binary value @a value
+    @pre    @a value's subtype, if any, fits into a byte; @ref calc_bson_sizes
+            checks this for every binary value in the document beforehand.
     */
     void write_bson_binary(const string_t& name,
                            const binary_t& value)
@@ -21411,11 +21413,6 @@ class binary_writer
 
         write_number<std::int32_t>(to_bson_length(value.size()), true);
 
-        if (value.has_subtype() && JSON_HEDLEY_UNLIKELY(value.subtype() > (std::numeric_limits<std::uint8_t>::max)()))
-        {
-            JSON_THROW(out_of_range::create(415, concat("subtype ", std::to_string(value.subtype()), " is too large for the BSON binary subtype (max 255)"), nullptr));
-        }
-
         write_number(value.has_subtype() ? static_cast<std::uint8_t>(value.subtype()) : static_cast<std::uint8_t>(0x00));
 
         oa.write_characters(reinterpret_cast<const CharType*>(value.data()), value.size());
@@ -21424,13 +21421,15 @@ class binary_writer
     /*!
     @return The size of the value of the BSON document entry for @a j, which
             is neither an object nor an array
+    @throw out_of_range.415 if @a j is binary with a subtype that does not fit
+           into a byte, before anything is written
     */
     static std::size_t calc_bson_value_size(const BasicJsonType& j)
     {
         switch (j.type())
         {
             case value_t::binary:
-                return calc_bson_binary_size(*j.m_data.m_value.binary);
+                return calc_bson_binary_size(j);
 
             case value_t::boolean:
                 return 1ul;
@@ -21556,6 +21555,8 @@ class binary_writer
     @return the size of @a document
     @throw out_of_range.409 if a key contains U+0000, before anything is
            written
+    @throw out_of_range.415 if a binary value's subtype does not fit into a
+           byte, before anything is written
     */
     static std::size_t calc_bson_sizes(const BasicJsonType& document, std::vector<std::size_t>& nested_sizes)
     {
@@ -27762,18 +27763,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                bool type_deduction = true,
                value_t manual_type = value_t::array)
     {
-#if JSON_BRACE_INIT_COPY_SEMANTICS
-        // a single element that is a value rather than a braced list is
-        // copied or moved as is, whatever its content looks like
-        if (type_deduction && init.size() == 1 && !init.begin()->is_braced_list())
-        {
-            *this = init.begin()->moved_or_copied();
-            set_parents();
-            assert_invariant();
-            return;
-        }
-#endif
-
         // check if each element is an array with two elements whose first
         // element is a string
         bool is_an_object = std::all_of(init.begin(), init.end(),

tests/src/unit-brace-init-copy-semantics.cpp

@@ -72,28 +72,6 @@ TEST_CASE("JSON_BRACE_INIT_COPY_SEMANTICS")
         CHECK(j7 == json::array({1, 2}));
     }
 
-    SECTION("single-element brace initialization copies a pair-shaped array value (#5662)")
-    {
-        // a JSON value that happens to be a 2-element array whose first
-        // element is a string must still be copied, not turned into an
-        // object; only a braced list written in the source, such as the
-        // inner {"key", "value"} of {{"key", "value"}}, describes an object
-        json const pair_shaped = json::array({"key", 42});
-
-        json const j1{pair_shaped};
-        CHECK(j1.is_array());
-        CHECK(j1 == pair_shaped);
-
-        json const j2 = {pair_shaped};
-        CHECK(j2.is_array());
-        CHECK(j2 == pair_shaped);
-
-        // the same holds for an rvalue of the same shape
-        json const j3{json::array({"key", 42})};
-        CHECK(j3.is_array());
-        CHECK(j3 == pair_shaped);
-    }
-
     SECTION("what the macro does not change")
     {
         // lists with more than one element are unaffected

tests/src/unit-bson.cpp

@@ -797,7 +797,11 @@ TEST_CASE("regression test - BSON binary subtype rejects a value that doesn't fi
     CHECK(json::from_bson(json::to_bson(doc255))["b"].get_binary().subtype() == 255);
 
     CHECK_THROWS_AS(json::to_bson(json{{"b", json::binary({1, 2}, 256)}}), json::out_of_range);
-    CHECK_THROWS_WITH_AS(json::to_bson(json{{"b", json::binary({1, 2}, 300)}}), "[json.exception.out_of_range.415] subtype 300 is too large for the BSON binary subtype (max 255)", json::out_of_range);
+#if JSON_DIAGNOSTICS
+    CHECK_THROWS_WITH_AS(json::to_bson(json {{"b", json::binary({1, 2}, 300)}}), "[json.exception.out_of_range.415] (/b) subtype 300 is too large for the BSON binary subtype (max 255)", json::out_of_range);
+#else
+    CHECK_THROWS_WITH_AS(json::to_bson(json {{"b", json::binary({1, 2}, 300)}}), "[json.exception.out_of_range.415] subtype 300 is too large for the BSON binary subtype (max 255)", json::out_of_range);
+#endif
 }
 
 TEST_CASE("BSON input/output_adapters")
@@ -1805,6 +1809,21 @@ value = depth % 2 == 0 ? json{{"a", std::move(value)}, {"b", {1, "x"}}} :
         CHECK(output.empty());
     }
 
+    SECTION("a binary subtype that doesn't fit a byte is rejected before anything is written (#5675)")
+    {
+        // the offending value is nested, so this also covers that the check
+        // is not limited to a directly written value's own document
+        json const j = {{"a", {{"b", json::binary({1, 2}, 300)}}}};
+
+        std::vector<std::uint8_t> vector_output;
+        CHECK_THROWS_AS(json::to_bson(j, vector_output), json::out_of_range&);
+        CHECK(vector_output.empty());
+
+        std::string string_output;
+        CHECK_THROWS_AS(json::to_bson(j, string_output), json::out_of_range&);
+        CHECK(string_output.empty());
+    }
+
     SECTION("values nested too deeply for the call stack (#5392)")
     {
         // serializing recursed once per nesting level, and computed every

tests/src/unit-diagnostics.cpp

@@ -101,6 +101,12 @@ TEST_CASE("Regression tests for extended diagnostics")
         CHECK_THROWS_WITH_AS(j.unflatten(), "[json.exception.type_error.315] (/~1foo) values in object must be primitive", json::type_error);
     }
 
+    SECTION("Regression test for issue #5675 - to_bson: out_of_range.415 has no diagnostics context")
+    {
+        json const j = {{"a", {{"b", json::binary({1, 2}, 300)}}}};
+        CHECK_THROWS_WITH_AS(json::to_bson(j), "[json.exception.out_of_range.415] (/a/b) subtype 300 is too large for the BSON binary subtype (max 255)", json::out_of_range);
+    }
+
     SECTION("Regression test for issue #2838 - Assertion failure when inserting into arrays with JSON_DIAGNOSTICS set")
     {
         // void push_back(basic_json&& val)