libmongocrypt-helper 1.13.2.0.1001 → 1.14.0.0.1001

data/ext/libmongocrypt/libmongocrypt/src/mc-fle2-find-text-payload.c

@@ -0,0 +1,477 @@
+/*
+ * Copyright 2025-present MongoDB, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <bson/bson.h>
+#include <stdlib.h>
+
+#include "mc-fle2-find-text-payload-private.h"
+#include "mc-parse-utils-private.h"
+#include "mongocrypt-buffer-private.h"
+#include "mongocrypt-util-private.h"
+#include "mongocrypt.h"
+
+#define IF_FIELD(Name)                                                                                                 \
+    if (0 == strcmp(field, #Name)) {                                                                                   \
+        if (has_##Name) {                                                                                              \
+            CLIENT_ERR("Error parsing %s: Duplicate field '" #Name "'", class_name);                                   \
+            goto fail;                                                                                                 \
+        }                                                                                                              \
+        has_##Name = true;
+
+#define END_IF_FIELD                                                                                                   \
+    continue;                                                                                                          \
+    }
+
+#define CHECK_HAS(Name)                                                                                                \
+    if (!has_##Name) {                                                                                                 \
+        CLIENT_ERR("Error parsing %s: Missing required field '" #Name "'", class_name);                                \
+        goto fail;                                                                                                     \
+    }
+
+#define PARSE_BINARY(Name, Dest)                                                                                       \
+    IF_FIELD(Name) {                                                                                                   \
+        if (!parse_bindata(BSON_SUBTYPE_BINARY, &iter, Dest, status)) {                                                \
+            goto fail;                                                                                                 \
+        }                                                                                                              \
+    }                                                                                                                  \
+    END_IF_FIELD
+
+typedef struct {
+    _mongocrypt_buffer_t *edcDerivedToken;
+    _mongocrypt_buffer_t *escDerivedToken;
+    _mongocrypt_buffer_t *serverDerivedToken;
+} mc_TextFindTokenSetIndirection_t;
+
+typedef struct {
+    const _mongocrypt_buffer_t *edcDerivedToken;
+    const _mongocrypt_buffer_t *escDerivedToken;
+    const _mongocrypt_buffer_t *serverDerivedToken;
+} mc_TextFindTokenSetIndirectionConst_t;
+
+/* Cleanup code common to all mc_Text<T>FindTokenSet_t types.
+ */
+static void mc_TextFindTokenSetIndirection_cleanup(mc_TextFindTokenSetIndirection_t ts) {
+    _mongocrypt_buffer_cleanup(ts.edcDerivedToken);
+    _mongocrypt_buffer_cleanup(ts.escDerivedToken);
+    _mongocrypt_buffer_cleanup(ts.serverDerivedToken);
+}
+
+/* Serialization code common to all mc_Text<T>FindTokenSet_t types.
+ */
+static bool mc_TextFindTokenSetIndirection_serialize(mc_TextFindTokenSetIndirectionConst_t ts,
+                                                     bson_t *parent,
+                                                     const char *field_name) {
+    BSON_ASSERT_PARAM(ts.edcDerivedToken);
+    BSON_ASSERT_PARAM(ts.escDerivedToken);
+    BSON_ASSERT_PARAM(ts.serverDerivedToken);
+    BSON_ASSERT_PARAM(parent);
+    BSON_ASSERT_PARAM(field_name);
+    bson_t child;
+    if (!BSON_APPEND_DOCUMENT_BEGIN(parent, field_name, &child)) {
+        return false;
+    }
+    if (!_mongocrypt_buffer_append(ts.edcDerivedToken, &child, "d", -1)) {
+        return false;
+    }
+    if (!_mongocrypt_buffer_append(ts.escDerivedToken, &child, "s", -1)) {
+        return false;
+    }
+    if (!_mongocrypt_buffer_append(ts.serverDerivedToken, &child, "l", -1)) {
+        return false;
+    }
+    if (!bson_append_document_end(parent, &child)) {
+        return false;
+    }
+    return true;
+}
+
+/* Parsing code common to all mc_Text<T>FindTokenSet_t types.
+ */
+static bool mc_TextFindTokenSetIndirection_parse(mc_TextFindTokenSetIndirection_t out,
+                                                 const char *class_name,
+                                                 const bson_iter_t *in,
+                                                 mongocrypt_status_t *status) {
+    BSON_ASSERT_PARAM(out.edcDerivedToken);
+    BSON_ASSERT_PARAM(out.escDerivedToken);
+    BSON_ASSERT_PARAM(out.serverDerivedToken);
+    BSON_ASSERT_PARAM(in);
+    bson_iter_t iter;
+    bool has_d = false, has_s = false, has_l = false;
+
+    iter = *in;
+    if (!BSON_ITER_HOLDS_DOCUMENT(&iter)) {
+        CLIENT_ERR("Error parsing %s: field expected to be a document, but got %s",
+                   class_name,
+                   mc_bson_type_to_string(bson_iter_type(&iter)));
+        return false;
+    }
+    bson_iter_recurse(&iter, &iter);
+    while (bson_iter_next(&iter)) {
+        const char *field = bson_iter_key(&iter);
+        BSON_ASSERT(field);
+
+        PARSE_BINARY(d, out.edcDerivedToken);
+        PARSE_BINARY(s, out.escDerivedToken);
+        PARSE_BINARY(l, out.serverDerivedToken);
+
+        CLIENT_ERR("Error parsing %s: Unrecognized field '%s'", class_name, field);
+        goto fail;
+    }
+
+    CHECK_HAS(d);
+    CHECK_HAS(s);
+    CHECK_HAS(l);
+
+    return true;
+fail:
+    return false;
+}
+
+#define INDIRECT(type, ts)                                                                                             \
+    (type) {                                                                                                           \
+        .edcDerivedToken = &(ts).edcDerivedToken, .escDerivedToken = &(ts).escDerivedToken,                            \
+        .serverDerivedToken = &(ts).serverDerivedFromDataToken                                                         \
+    }
+#define INDIRECT_TOKENSET(ts) INDIRECT(mc_TextFindTokenSetIndirection_t, ts)
+#define INDIRECT_TOKENSET_CONST(ts) INDIRECT(mc_TextFindTokenSetIndirectionConst_t, ts)
+
+#define DEF_TEXT_SEARCH_FIND_TOKEN_SET_CLEANUP(Type)                                                                   \
+    static void mc_Text##Type##FindTokenSet_cleanup(mc_Text##Type##FindTokenSet_t *fts) {                              \
+        if (fts) {                                                                                                     \
+            mc_TextFindTokenSetIndirection_cleanup(INDIRECT_TOKENSET(*fts));                                           \
+        }                                                                                                              \
+    }
+DEF_TEXT_SEARCH_FIND_TOKEN_SET_CLEANUP(Exact);
+DEF_TEXT_SEARCH_FIND_TOKEN_SET_CLEANUP(Substring);
+DEF_TEXT_SEARCH_FIND_TOKEN_SET_CLEANUP(Suffix);
+DEF_TEXT_SEARCH_FIND_TOKEN_SET_CLEANUP(Prefix);
+
+#define DEF_TEXT_SEARCH_FIND_TOKEN_SET_SERIALIZE(Type)                                                                 \
+    static bool mc_Text##Type##FindTokenSet_serialize(bson_t *parent,                                                  \
+                                                      const char *field_name,                                          \
+                                                      const mc_Text##Type##FindTokenSet_t *ts) {                       \
+        BSON_ASSERT_PARAM(ts);                                                                                         \
+        return mc_TextFindTokenSetIndirection_serialize(INDIRECT_TOKENSET_CONST(*ts), parent, field_name);             \
+    }
+DEF_TEXT_SEARCH_FIND_TOKEN_SET_SERIALIZE(Exact)
+DEF_TEXT_SEARCH_FIND_TOKEN_SET_SERIALIZE(Substring)
+DEF_TEXT_SEARCH_FIND_TOKEN_SET_SERIALIZE(Suffix)
+DEF_TEXT_SEARCH_FIND_TOKEN_SET_SERIALIZE(Prefix)
+
+#define DEF_TEXT_SEARCH_FIND_TOKEN_SET_PARSE(Type)                                                                     \
+    static bool mc_Text##Type##FindTokenSet_parse(mc_Text##Type##FindTokenSet_t *out,                                  \
+                                                  bson_iter_t *in,                                                     \
+                                                  mongocrypt_status_t *status) {                                       \
+        BSON_ASSERT_PARAM(out);                                                                                        \
+        return mc_TextFindTokenSetIndirection_parse(INDIRECT_TOKENSET(*out), "Text" #Type "FindTokenSet", in, status); \
+    }
+DEF_TEXT_SEARCH_FIND_TOKEN_SET_PARSE(Exact)
+DEF_TEXT_SEARCH_FIND_TOKEN_SET_PARSE(Substring)
+DEF_TEXT_SEARCH_FIND_TOKEN_SET_PARSE(Suffix)
+DEF_TEXT_SEARCH_FIND_TOKEN_SET_PARSE(Prefix)
+
+#undef DEF_TEXT_SEARCH_FIND_TOKEN_SET_CLEANUP
+#undef DEF_TEXT_SEARCH_FIND_TOKEN_SET_SERIALIZE
+#undef DEF_TEXT_SEARCH_FIND_TOKEN_SET_PARSE
+#undef INDIRECT_TOKENSET_CONST
+#undef INDIRECT_TOKENSET
+#undef INDIRECT
+
+void mc_FLE2FindTextPayload_init(mc_FLE2FindTextPayload_t *payload) {
+    BSON_ASSERT_PARAM(payload);
+    memset(payload, 0, sizeof(*payload));
+}
+
+void mc_FLE2FindTextPayload_cleanup(mc_FLE2FindTextPayload_t *payload) {
+    if (!payload) {
+        return;
+    }
+    mc_TextExactFindTokenSet_cleanup(&payload->tokenSets.exact.value);
+    mc_TextSubstringFindTokenSet_cleanup(&payload->tokenSets.substring.value);
+    mc_TextSuffixFindTokenSet_cleanup(&payload->tokenSets.suffix.value);
+    mc_TextPrefixFindTokenSet_cleanup(&payload->tokenSets.prefix.value);
+}
+
+static bool mc_TextSearchFindTokenSets_parse(mc_TextSearchFindTokenSets_t *out,
+                                             const bson_iter_t *in,
+                                             mongocrypt_status_t *status) {
+    BSON_ASSERT_PARAM(out);
+    BSON_ASSERT_PARAM(in);
+
+    bson_iter_t iter;
+    bool has_e = false, has_s = false, has_u = false, has_p = false;
+    uint8_t field_count = 0;
+    const char *class_name = "TextSearchFindTokenSets";
+
+    iter = *in;
+    if (!BSON_ITER_HOLDS_DOCUMENT(&iter)) {
+        CLIENT_ERR("Error parsing %s: field expected to be a document, but got %s",
+                   class_name,
+                   mc_bson_type_to_string(bson_iter_type(&iter)));
+        return false;
+    }
+    bson_iter_recurse(&iter, &iter);
+    while (bson_iter_next(&iter)) {
+        const char *field = bson_iter_key(&iter);
+        BSON_ASSERT(field);
+
+        IF_FIELD(e) {
+            if (!mc_TextExactFindTokenSet_parse(&out->exact.value, &iter, status)) {
+                goto fail;
+            }
+            out->exact.set = true;
+            field_count++;
+        }
+        END_IF_FIELD
+
+        IF_FIELD(s) {
+            if (!mc_TextSubstringFindTokenSet_parse(&out->substring.value, &iter, status)) {
+                goto fail;
+            }
+            out->substring.set = true;
+            field_count++;
+        }
+        END_IF_FIELD
+
+        IF_FIELD(u) {
+            if (!mc_TextSuffixFindTokenSet_parse(&out->suffix.value, &iter, status)) {
+                goto fail;
+            }
+            out->suffix.set = true;
+            field_count++;
+        }
+        END_IF_FIELD
+
+        IF_FIELD(p) {
+            if (!mc_TextPrefixFindTokenSet_parse(&out->prefix.value, &iter, status)) {
+                goto fail;
+            }
+            out->prefix.set = true;
+            field_count++;
+        }
+        END_IF_FIELD
+
+        CLIENT_ERR("Error parsing %s: Unrecognized field '%s'", class_name, field);
+        goto fail;
+    }
+
+    if (!field_count) {
+        CLIENT_ERR("Error parsing %s: exactly one optional field is required", class_name);
+        goto fail;
+    } else if (field_count > 1) {
+        CLIENT_ERR("Error parsing %s: cannot have multiple optional fields present", class_name);
+        goto fail;
+    }
+
+    return true;
+fail:
+    return false;
+}
+
+bool mc_FLE2FindTextPayload_parse(mc_FLE2FindTextPayload_t *out, const bson_t *in, mongocrypt_status_t *status) {
+    bson_iter_t iter;
+    const char *class_name = "FLE2FindTextPayload";
+
+    bool has_ts = false, has_cm = false, has_cf = false, has_df = false; // required fields
+    bool has_ss = false, has_fs = false, has_ps = false;                 // optional fields
+
+    BSON_ASSERT_PARAM(out);
+    BSON_ASSERT_PARAM(in);
+
+    mc_FLE2FindTextPayload_init(out);
+    if (!bson_validate(in, BSON_VALIDATE_NONE, NULL) || !bson_iter_init(&iter, in)) {
+        CLIENT_ERR("invalid BSON");
+        return false;
+    }
+
+    while (bson_iter_next(&iter)) {
+        const char *field = bson_iter_key(&iter);
+        const char *typestr = mc_bson_type_to_string(bson_iter_type(&iter));
+        BSON_ASSERT(field);
+
+        IF_FIELD(ts) {
+            if (!mc_TextSearchFindTokenSets_parse(&out->tokenSets, &iter, status)) {
+                return false;
+            }
+        }
+        END_IF_FIELD
+
+        IF_FIELD(cm) {
+            if (!BSON_ITER_HOLDS_INT64(&iter)) {
+                CLIENT_ERR("Error parsing %s: Field 'cm' expected to be int64, but got %s", class_name, typestr);
+                goto fail;
+            }
+            out->maxContentionFactor = bson_iter_int64(&iter);
+        }
+        END_IF_FIELD
+
+        IF_FIELD(cf) {
+            if (!BSON_ITER_HOLDS_BOOL(&iter)) {
+                CLIENT_ERR("Error parsing %s: Field 'cf' expected to be boolean, but got %s", class_name, typestr);
+                goto fail;
+            }
+            out->caseFold = bson_iter_bool(&iter);
+        }
+        END_IF_FIELD
+
+        IF_FIELD(df) {
+            if (!BSON_ITER_HOLDS_BOOL(&iter)) {
+                CLIENT_ERR("Error parsing %s: Field 'df' expected to be boolean, but got %s", class_name, typestr);
+                goto fail;
+            }
+            out->diacriticFold = bson_iter_bool(&iter);
+        }
+        END_IF_FIELD
+
+        IF_FIELD(ss) {
+            if (!mc_FLE2SubstringInsertSpec_parse(&out->substringSpec.value, &iter, status)) {
+                goto fail;
+            }
+            out->substringSpec.set = true;
+        }
+        END_IF_FIELD
+
+        IF_FIELD(fs) {
+            if (!mc_FLE2SuffixInsertSpec_parse(&out->suffixSpec.value, &iter, status)) {
+                goto fail;
+            }
+            out->suffixSpec.set = true;
+        }
+        END_IF_FIELD
+
+        IF_FIELD(ps) {
+            if (!mc_FLE2PrefixInsertSpec_parse(&out->prefixSpec.value, &iter, status)) {
+                goto fail;
+            }
+            out->prefixSpec.set = true;
+        }
+        END_IF_FIELD
+
+        CLIENT_ERR("Error parsing %s: Unrecognized field '%s'", class_name, field);
+        goto fail;
+    }
+
+    CHECK_HAS(ts);
+    CHECK_HAS(cm);
+    CHECK_HAS(cf);
+    CHECK_HAS(df);
+    return true;
+fail:
+    return false;
+}
+
+bool mc_FLE2FindTextPayload_serialize(const mc_FLE2FindTextPayload_t *payload, bson_t *out) {
+    BSON_ASSERT_PARAM(out);
+    BSON_ASSERT_PARAM(payload);
+
+    // Append token sets "ts"
+    {
+        bson_t child;
+        if (!BSON_APPEND_DOCUMENT_BEGIN(out, "ts", &child)) {
+            return false;
+        }
+        // Append "e" if present
+        if (payload->tokenSets.exact.set) {
+            mc_TextExactFindTokenSet_serialize(&child, "e", &payload->tokenSets.exact.value);
+        }
+        // Append "s" if present
+        if (payload->tokenSets.substring.set) {
+            mc_TextSubstringFindTokenSet_serialize(&child, "s", &payload->tokenSets.substring.value);
+        }
+        // Append "u" if present
+        if (payload->tokenSets.suffix.set) {
+            mc_TextSuffixFindTokenSet_serialize(&child, "u", &payload->tokenSets.suffix.value);
+        }
+        // Append "p" if present
+        if (payload->tokenSets.prefix.set) {
+            mc_TextPrefixFindTokenSet_serialize(&child, "p", &payload->tokenSets.prefix.value);
+        }
+        if (!bson_append_document_end(out, &child)) {
+            return false;
+        }
+    }
+
+    // Append "cm".
+    if (!BSON_APPEND_INT64(out, "cm", payload->maxContentionFactor)) {
+        return false;
+    }
+
+    // Append "cf".
+    if (!BSON_APPEND_BOOL(out, "cf", payload->caseFold)) {
+        return false;
+    }
+
+    // Append "df".
+    if (!BSON_APPEND_BOOL(out, "df", payload->diacriticFold)) {
+        return false;
+    }
+
+    // Append "ss" if present.
+    if (payload->substringSpec.set) {
+        bson_t child;
+        if (!BSON_APPEND_DOCUMENT_BEGIN(out, "ss", &child)) {
+            return false;
+        }
+        if (!BSON_APPEND_INT32(&child, "mlen", (int32_t)payload->substringSpec.value.mlen)) {
+            return false;
+        }
+        if (!BSON_APPEND_INT32(&child, "ub", (int32_t)payload->substringSpec.value.ub)) {
+            return false;
+        }
+        if (!BSON_APPEND_INT32(&child, "lb", (int32_t)payload->substringSpec.value.lb)) {
+            return false;
+        }
+        if (!bson_append_document_end(out, &child)) {
+            return false;
+        }
+    }
+
+    // Append "fs" if present.
+    if (payload->suffixSpec.set) {
+        bson_t child;
+        if (!BSON_APPEND_DOCUMENT_BEGIN(out, "fs", &child)) {
+            return false;
+        }
+        if (!BSON_APPEND_INT32(&child, "ub", (int32_t)payload->suffixSpec.value.ub)) {
+            return false;
+        }
+        if (!BSON_APPEND_INT32(&child, "lb", (int32_t)payload->suffixSpec.value.lb)) {
+            return false;
+        }
+        if (!bson_append_document_end(out, &child)) {
+            return false;
+        }
+    }
+
+    // Append "ps" if present.
+    if (payload->prefixSpec.set) {
+        bson_t child;
+        if (!BSON_APPEND_DOCUMENT_BEGIN(out, "ps", &child)) {
+            return false;
+        }
+        if (!BSON_APPEND_INT32(&child, "ub", (int32_t)payload->prefixSpec.value.ub)) {
+            return false;
+        }
+        if (!BSON_APPEND_INT32(&child, "lb", (int32_t)payload->prefixSpec.value.lb)) {
+            return false;
+        }
+        if (!bson_append_document_end(out, &child)) {
+            return false;
+        }
+    }
+
+    return true;
+}

data/ext/libmongocrypt/libmongocrypt/src/mc-fle2-insert-update-payload-private-v2.h

@@ -158,9 +158,7 @@ const _mongocrypt_buffer_t *mc_FLE2InsertUpdatePayloadV2_decrypt(_mongocrypt_cry
 
 bool mc_FLE2InsertUpdatePayloadV2_serialize(const mc_FLE2InsertUpdatePayloadV2_t *payload, bson_t *out);
 
-bool mc_FLE2InsertUpdatePayloadV2_serializeForRange(const mc_FLE2InsertUpdatePayloadV2_t *payload,
-                                                    bson_t *out,
-                                                    bool use_range_v2);
+bool mc_FLE2InsertUpdatePayloadV2_serializeForRange(const mc_FLE2InsertUpdatePayloadV2_t *payload, bson_t *out);
 
 bool mc_FLE2InsertUpdatePayloadV2_serializeForTextSearch(const mc_FLE2InsertUpdatePayloadV2_t *payload, bson_t *out);
 

data/ext/libmongocrypt/libmongocrypt/src/mc-fle2-insert-update-payload-v2.c

@@ -17,6 +17,7 @@
 #include <bson/bson.h>
 
 #include "mc-fle2-insert-update-payload-private-v2.h"
+#include "mc-parse-utils-private.h"
 #include "mongocrypt-buffer-private.h"
 #include "mongocrypt-util-private.h" // mc_bson_type_to_string
 #include "mongocrypt.h"
@@ -133,21 +134,7 @@ void mc_FLE2InsertUpdatePayloadV2_cleanup(mc_FLE2InsertUpdatePayloadV2_t *payloa
 
 #define PARSE_BINDATA(Name, Type, Dest)                                                                                \
     IF_FIELD(Name) {                                                                                                   \
-        bson_subtype_t subtype;                                                                                        \
-        uint32_t len;                                                                                                  \
-        const uint8_t *data;                                                                                           \
-        if (bson_iter_type(&iter) != BSON_TYPE_BINARY) {                                                               \
-            CLIENT_ERR("Field '" #Name "' expected to be bindata, got: %d", bson_iter_type(&iter));                    \
-            goto fail;                                                                                                 \
-        }                                                                                                              \
-        bson_iter_binary(&iter, &subtype, &len, &data);                                                                \
-        if (subtype != Type) {                                                                                         \
-            CLIENT_ERR("Field '" #Name "' expected to be bindata subtype %d, got: %d", Type, subtype);                 \
-            goto fail;                                                                                                 \
-        }                                                                                                              \
-        if (!_mongocrypt_buffer_copy_from_binary_iter(&out->Dest, &iter)) {                                            \
-            CLIENT_ERR("Unable to create mongocrypt buffer for BSON binary "                                           \
-                       "field in '" #Name "'");                                                                        \
+        if (!parse_bindata(Type, &iter, &out->Dest, status)) {                                                         \
             goto fail;                                                                                                 \
         }                                                                                                              \
     }                                                                                                                  \
@@ -159,7 +146,8 @@ void mc_FLE2InsertUpdatePayloadV2_cleanup(mc_FLE2InsertUpdatePayloadV2_t *payloa
     if (!has_##Name) {                                                                                                 \
         CLIENT_ERR("Missing field '" #Name "' in payload");                                                            \
         goto fail;                                                                                                     \
-    }
+    } else                                                                                                             \
+        ((void)0)
 
 bool mc_FLE2InsertUpdatePayloadV2_parse(mc_FLE2InsertUpdatePayloadV2_t *out,
                                         const _mongocrypt_buffer_t *in,
@@ -306,7 +294,8 @@ fail:
 #define IUPS_APPEND_BINDATA(dst, name, subtype, value)                                                                 \
     if (!_mongocrypt_buffer_append(&(value), dst, name, -1)) {                                                         \
         return false;                                                                                                  \
-    }
+    } else                                                                                                             \
+        ((void)0)
 
 bool mc_FLE2InsertUpdatePayloadV2_serialize(const mc_FLE2InsertUpdatePayloadV2_t *payload, bson_t *out) {
     BSON_ASSERT_PARAM(out);
@@ -329,9 +318,7 @@ bool mc_FLE2InsertUpdatePayloadV2_serialize(const mc_FLE2InsertUpdatePayloadV2_t
     return true;
 }
 
-bool mc_FLE2InsertUpdatePayloadV2_serializeForRange(const mc_FLE2InsertUpdatePayloadV2_t *payload,
-                                                    bson_t *out,
-                                                    bool use_range_v2) {
+bool mc_FLE2InsertUpdatePayloadV2_serializeForRange(const mc_FLE2InsertUpdatePayloadV2_t *payload, bson_t *out) {
     BSON_ASSERT_PARAM(out);
     BSON_ASSERT_PARAM(payload);
 
@@ -375,34 +362,32 @@ bool mc_FLE2InsertUpdatePayloadV2_serializeForRange(const mc_FLE2InsertUpdatePay
         return false;
     }
 
-    if (use_range_v2) {
-        // Encode parameters that were used to generate the payload.
-        BSON_ASSERT(payload->sparsity.set);
-        if (!BSON_APPEND_INT64(out, "sp", payload->sparsity.value)) {
-            return false;
-        }
-
-        // Precision may be unset.
-        if (payload->precision.set) {
-            if (!BSON_APPEND_INT32(out, "pn", payload->precision.value)) {
-                return false;
-            }
-        }
+    // Encode parameters that were used to generate the payload.
+    BSON_ASSERT(payload->sparsity.set);
+    if (!BSON_APPEND_INT64(out, "sp", payload->sparsity.value)) {
+        return false;
+    }
 
-        BSON_ASSERT(payload->trimFactor.set);
-        if (!BSON_APPEND_INT32(out, "tf", payload->trimFactor.value)) {
+    // Precision may be unset.
+    if (payload->precision.set) {
+        if (!BSON_APPEND_INT32(out, "pn", payload->precision.value)) {
             return false;
         }
+    }
 
-        BSON_ASSERT(payload->indexMin.value_type != BSON_TYPE_EOD);
-        if (!BSON_APPEND_VALUE(out, "mn", &payload->indexMin)) {
-            return false;
-        }
+    BSON_ASSERT(payload->trimFactor.set);
+    if (!BSON_APPEND_INT32(out, "tf", payload->trimFactor.value)) {
+        return false;
+    }
 
-        BSON_ASSERT(payload->indexMax.value_type != BSON_TYPE_EOD);
-        if (!BSON_APPEND_VALUE(out, "mx", &payload->indexMax)) {
-            return false;
-        }
+    BSON_ASSERT(payload->indexMin.value_type != BSON_TYPE_EOD);
+    if (!BSON_APPEND_VALUE(out, "mn", &payload->indexMin)) {
+        return false;
+    }
+
+    BSON_ASSERT(payload->indexMax.value_type != BSON_TYPE_EOD);
+    if (!BSON_APPEND_VALUE(out, "mx", &payload->indexMax)) {
+        return false;
     }
 
     return true;

data/ext/libmongocrypt/libmongocrypt/src/mc-fle2-insert-update-payload.c

@@ -17,6 +17,7 @@
 #include <bson/bson.h>
 
 #include "mc-fle2-insert-update-payload-private.h"
+#include "mc-parse-utils-private.h"
 #include "mongocrypt-buffer-private.h"
 #include "mongocrypt.h"
 
@@ -69,21 +70,7 @@ void mc_FLE2InsertUpdatePayload_cleanup(mc_FLE2InsertUpdatePayload_t *payload) {
 
 #define PARSE_BINDATA(Name, Type, Dest)                                                                                \
     IF_FIELD(Name) {                                                                                                   \
-        bson_subtype_t subtype;                                                                                        \
-        uint32_t len;                                                                                                  \
-        const uint8_t *data;                                                                                           \
-        if (bson_iter_type(&iter) != BSON_TYPE_BINARY) {                                                               \
-            CLIENT_ERR("Field '" #Name "' expected to be bindata, got: %d", bson_iter_type(&iter));                    \
-            goto fail;                                                                                                 \
-        }                                                                                                              \
-        bson_iter_binary(&iter, &subtype, &len, &data);                                                                \
-        if (subtype != Type) {                                                                                         \
-            CLIENT_ERR("Field '" #Name "' expected to be bindata subtype %d, got: %d", Type, subtype);                 \
-            goto fail;                                                                                                 \
-        }                                                                                                              \
-        if (!_mongocrypt_buffer_copy_from_binary_iter(&out->Dest, &iter)) {                                            \
-            CLIENT_ERR("Unable to create mongocrypt buffer for BSON binary "                                           \
-                       "field in '" #Name "'");                                                                        \
+        if (!parse_bindata(Type, &iter, &out->Dest, status)) {                                                         \
             goto fail;                                                                                                 \
         }                                                                                                              \
     }                                                                                                                  \
@@ -95,7 +82,8 @@ void mc_FLE2InsertUpdatePayload_cleanup(mc_FLE2InsertUpdatePayload_t *payload) {
     if (!has_##Name) {                                                                                                 \
         CLIENT_ERR("Missing field '" #Name "' in payload");                                                            \
         goto fail;                                                                                                     \
-    }
+    } else                                                                                                             \
+        ((void)0)
 
 bool mc_FLE2InsertUpdatePayload_parse(mc_FLE2InsertUpdatePayload_t *out,
                                       const _mongocrypt_buffer_t *in,
@@ -173,7 +161,8 @@ fail:
 #define IUPS_APPEND_BINDATA(dst, name, subtype, value)                                                                 \
     if (!_mongocrypt_buffer_append(&(value), dst, name, -1)) {                                                         \
         return false;                                                                                                  \
-    }
+    } else                                                                                                             \
+        ((void)0)
 
 bool mc_FLE2InsertUpdatePayload_serialize(const mc_FLE2InsertUpdatePayload_t *payload, bson_t *out) {
     BSON_ASSERT_PARAM(out);