libmongocrypt-helper 1.12.0.0.1001 → 1.14.0.0.1001

data/ext/libmongocrypt/libmongocrypt/src/mc-fle2-payload-iev.c

@@ -27,7 +27,8 @@
 #define CHECK_AND_RETURN(x)                                                                                            \
     if (!(x)) {                                                                                                        \
         return false;                                                                                                  \
-    }
+    } else                                                                                                             \
+        ((void)0)
 
 struct _mc_FLE2IndexedEqualityEncryptedValue_t {
     _mongocrypt_buffer_t S_KeyId;
@@ -58,7 +59,7 @@ bool mc_FLE2IndexedEqualityEncryptedValueTokens_init_from_buffer(mc_FLE2IndexedE
     BSON_ASSERT_PARAM(buf);
 
     mc_reader_t reader;
-    mc_reader_init_from_buffer(&reader, buf, __FUNCTION__);
+    mc_reader_init_from_buffer(&reader, buf, __func__);
 
     CHECK_AND_RETURN(mc_reader_read_u64(&reader, &tokens->counter, status));
 
@@ -78,7 +79,7 @@ static bool mc_fle2IndexedEncryptedValue_encrypt(_mongocrypt_crypto_t *crypto,
                                                  _mongocrypt_buffer_t *out,
                                                  mongocrypt_status_t *status);
 
-bool safe_uint32_t_sum(const uint32_t a, const uint32_t b, uint32_t *out, mongocrypt_status_t *status) {
+static bool safe_uint32_t_sum(const uint32_t a, const uint32_t b, uint32_t *out, mongocrypt_status_t *status) {
     if (a > UINT32_MAX - b) {
         CLIENT_ERR("safe_uint32_t_sum overflow, %" PRIu32 ", %" PRIu32, a, b);
         return false;
@@ -98,7 +99,8 @@ bool mc_FLE2IndexedEncryptedValue_write(_mongocrypt_crypto_t *crypto,
 #define CHECK_AND_GOTO(x)                                                                                              \
     if (!(x)) {                                                                                                        \
         goto cleanup;                                                                                                  \
-    }
+    } else                                                                                                             \
+        ((void)0)
 
     bool ok = false;
 
@@ -130,12 +132,12 @@ bool mc_FLE2IndexedEncryptedValue_write(_mongocrypt_crypto_t *crypto,
                                                         &encryption_out,
                                                         status));
     mc_writer_t writer;
-    mc_writer_init_from_buffer(&writer, buf, __FUNCTION__);
+    mc_writer_init_from_buffer(&writer, buf, __func__);
 
     const uint8_t subtype = (uint8_t)MC_SUBTYPE_FLE2IndexedEqualityEncryptedValue;
 
     if (((int)original_bson_type < 0) || ((int)original_bson_type > 0xFF)) {
-        CLIENT_ERR("Field 't' must be a valid BSON type, got: %d", original_bson_type);
+        CLIENT_ERR("Field 't' must be a valid BSON type, got: %d", (int)original_bson_type);
         CHECK_AND_GOTO(false);
     }
 
@@ -164,7 +166,8 @@ static bool mc_fle2IndexedEncryptedValue_encrypt(_mongocrypt_crypto_t *crypto,
 #define CHECK_AND_GOTO(x)                                                                                              \
     if (!(x)) {                                                                                                        \
         goto cleanup;                                                                                                  \
-    }
+    } else                                                                                                             \
+        ((void)0)
 
     const _mongocrypt_value_encryption_algorithm_t *fle2alg = _mcFLE2Algorithm();
     bool ok = false;
@@ -191,7 +194,7 @@ static bool mc_fle2IndexedEncryptedValue_encrypt(_mongocrypt_crypto_t *crypto,
     _mongocrypt_buffer_resize(out, ciphertext_len);
 
     mc_writer_t writer;
-    mc_writer_init_from_buffer(&writer, &in, __FUNCTION__);
+    mc_writer_init_from_buffer(&writer, &in, __func__);
 
     uint64_t length;
     length = ClientEncryptedValue->len;
@@ -236,7 +239,7 @@ bool mc_FLE2IndexedEncryptedValue_parse(mc_FLE2IndexedEncryptedValue_t *iev,
     }
 
     mc_reader_t reader;
-    mc_reader_init_from_buffer(&reader, buf, __FUNCTION__);
+    mc_reader_init_from_buffer(&reader, buf, __func__);
 
     CHECK_AND_RETURN(mc_reader_read_u8(&reader, &iev->fle_blob_subtype, status));
 
@@ -364,7 +367,7 @@ static bool mc_FLE2IndexedEncryptedValue_decrypt(_mongocrypt_crypto_t *crypto,
     }
 
     mc_reader_t reader;
-    mc_reader_init_from_buffer(&reader, &iev->Inner, __FUNCTION__);
+    mc_reader_init_from_buffer(&reader, &iev->Inner, __func__);
 
     /* Parse Inner for K_KeyId. */
     uint64_t length; /* length is sizeof(K_KeyId) + ClientEncryptedValue_length. */

data/ext/libmongocrypt/libmongocrypt/src/mc-fle2-payload-uev-common.c

@@ -21,7 +21,8 @@
 #define CHECK_AND_RETURN(x)                                                                                            \
     if (!(x)) {                                                                                                        \
         return false;                                                                                                  \
-    }
+    } else                                                                                                             \
+        ((void)0)
 
 bool _mc_FLE2UnindexedEncryptedValueCommon_parse(const _mongocrypt_buffer_t *buf,
                                                  uint8_t *fle_blob_subtype,
@@ -36,7 +37,7 @@ bool _mc_FLE2UnindexedEncryptedValueCommon_parse(const _mongocrypt_buffer_t *buf
     BSON_ASSERT_PARAM(ciphertext);
 
     mc_reader_t reader;
-    mc_reader_init_from_buffer(&reader, buf, __FUNCTION__);
+    mc_reader_init_from_buffer(&reader, buf, __func__);
 
     /* Read fle_blob_subtype. */
     CHECK_AND_RETURN(mc_reader_read_u8(&reader, fle_blob_subtype, status));

data/ext/libmongocrypt/libmongocrypt/src/mc-fle2-rfds.c

@@ -302,10 +302,7 @@ bool mc_FLE2RangeFindDriverSpec_parse(mc_FLE2RangeFindDriverSpec_t *spec,
             spec->upper.included = op.op_type == FLE2RangeOperator_kLte;
             break;
         case FLE2RangeOperator_kNone:
-        default:
-            ERR_WITH_BSON(in, "unsupported operator type %s", op.op_type_str);
-            goto fail;
-            break;
+        default: ERR_WITH_BSON(in, "unsupported operator type %s", op.op_type_str); goto fail;
         }
 
         if (spec->field && 0 != strcmp(spec->field, op.field)) {
@@ -352,7 +349,8 @@ bool mc_makeRangeFindPlaceholder(mc_makeRangeFindPlaceholder_args_t *args,
     if (!(stmt)) {                                                                                                     \
         CLIENT_ERR("error appending BSON for placeholder");                                                            \
         goto fail;                                                                                                     \
-    }
+    } else                                                                                                             \
+        ((void)0)
 
     // create edgesInfo.
 
@@ -431,7 +429,8 @@ bool mc_FLE2RangeFindDriverSpec_to_placeholders(mc_FLE2RangeFindDriverSpec_t *sp
     if (!(stmt)) {                                                                                                     \
         CLIENT_ERR("error transforming BSON for FLE2RangeFindDriverSpec: %s", #stmt);                                  \
         goto fail;                                                                                                     \
-    }
+    } else                                                                                                             \
+        ((void)0)
 
     TRY(bson_iter_init_find(&posInf, &infDoc, "p"));
     TRY(bson_iter_init_find(&negInf, &infDoc, "n"));
@@ -579,6 +578,8 @@ static void payloadId_init_mutex(void) {
     _mongocrypt_mutex_init(&payloadId_mutex);
 }
 
+void mc_reset_payloadId_for_testing(void); // -Wmissing-prototypes: for testing only.
+
 void mc_reset_payloadId_for_testing(void) {
     mlib_call_once(&payloadId_init_flag, payloadId_init_mutex);
     MONGOCRYPT_WITH_MUTEX(payloadId_mutex) {

data/ext/libmongocrypt/libmongocrypt/src/mc-fle2-tag-and-encrypted-metadata-block-private.h

@@ -21,7 +21,9 @@
 #include "mc-writer-private.h"
 #include "mongocrypt-private.h"
 
-typedef struct {
+#define kMetadataLen 96U // encCount(32) + tag(32) + encZeros(32)
+
+typedef struct _mc_FLE2TagAndEncryptedMetadataBlock_t {
     _mongocrypt_buffer_t encryptedCount;
     _mongocrypt_buffer_t tag;
     _mongocrypt_buffer_t encryptedZeros;
@@ -41,4 +43,7 @@ bool mc_FLE2TagAndEncryptedMetadataBlock_serialize(const mc_FLE2TagAndEncryptedM
                                                    _mongocrypt_buffer_t *buf,
                                                    mongocrypt_status_t *status);
 
-#endif /* MC_FLE2_TAG_AND_ENCRYPTED_METADATA_BLOCK_H */
+bool mc_FLE2TagAndEncryptedMetadataBlock_validate(const mc_FLE2TagAndEncryptedMetadataBlock_t *metadata,
+                                                  mongocrypt_status_t *status);
+
+#endif /* MC_FLE2_TAG_AND_ENCRYPTED_METADATA_BLOCK_H */

data/ext/libmongocrypt/libmongocrypt/src/mc-fle2-tag-and-encrypted-metadata-block.c

@@ -22,7 +22,8 @@
 #define CHECK_AND_RETURN(x)                                                                                            \
     if (!(x)) {                                                                                                        \
         return false;                                                                                                  \
-    }
+    } else                                                                                                             \
+        ((void)0)
 
 void mc_FLE2TagAndEncryptedMetadataBlock_init(mc_FLE2TagAndEncryptedMetadataBlock_t *metadata) {
     BSON_ASSERT_PARAM(metadata);
@@ -49,7 +50,7 @@ bool mc_FLE2TagAndEncryptedMetadataBlock_parse(mc_FLE2TagAndEncryptedMetadataBlo
     }
 
     mc_reader_t reader;
-    mc_reader_init_from_buffer(&reader, buf, __FUNCTION__);
+    mc_reader_init_from_buffer(&reader, buf, __func__);
 
     mc_FLE2TagAndEncryptedMetadataBlock_init(metadata);
 
@@ -68,8 +69,9 @@ bool mc_FLE2TagAndEncryptedMetadataBlock_serialize(const mc_FLE2TagAndEncryptedM
     BSON_ASSERT_PARAM(metadata);
     BSON_ASSERT_PARAM(buf);
 
+    _mongocrypt_buffer_resize(buf, kMetadataLen);
     mc_writer_t writer;
-    mc_writer_init_from_buffer(&writer, buf, __FUNCTION__);
+    mc_writer_init_from_buffer(&writer, buf, __func__);
 
     CHECK_AND_RETURN(mc_writer_write_buffer(&writer, &metadata->encryptedCount, kFieldLen, status));
 
@@ -79,3 +81,19 @@ bool mc_FLE2TagAndEncryptedMetadataBlock_serialize(const mc_FLE2TagAndEncryptedM
 
     return true;
 }
+
+#define CHECK(condition, msg)                                                                                          \
+    do {                                                                                                               \
+        if (!(condition)) {                                                                                            \
+            CLIENT_ERR("mc_FLE2TagAndEncryptedMetadataBlock_validate failed: " msg);                                   \
+            return false;                                                                                              \
+        }                                                                                                              \
+    } while (0)
+
+bool mc_FLE2TagAndEncryptedMetadataBlock_validate(const mc_FLE2TagAndEncryptedMetadataBlock_t *metadata,
+                                                  mongocrypt_status_t *status) {
+    CHECK(metadata->encryptedCount.len == kFieldLen, "Length of encrypted count was unexpected");
+    CHECK(metadata->tag.len == kFieldLen, "Length of tag was unexpected");
+    CHECK(metadata->encryptedZeros.len == kFieldLen, "Length of encrypted zeros was unexpected");
+    return true;
+}

data/ext/libmongocrypt/libmongocrypt/src/mc-optional-private.h

@@ -89,7 +89,7 @@ typedef struct {
 #define OPT_DOUBLE_C(val)                                                                                              \
     { .set = true, .value = val }
 
-#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT
+#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT()
 typedef struct {
     bool set;
     mc_dec128 value;

data/ext/libmongocrypt/libmongocrypt/{bindings/java/mongocrypt/benchmarks/build.gradle.kts → src/mc-parse-utils-private.h}

@@ -1,5 +1,5 @@
 /*
- * Copyright 2023-present MongoDB, Inc.
+ * 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.
@@ -12,17 +12,16 @@
  * 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.
- *
  */
 
-plugins {
-    id("application")
-}
+#ifndef MC_PARSE_UTILS_PRIVATE_H
+#define MC_PARSE_UTILS_PRIVATE_H
+
+#include "mongocrypt-buffer-private.h"
 
-application {
-    mainClass.set("com.mongodb.crypt.benchmark.BenchmarkRunner")
-}
+/* Validates that the given bson_iter_t points to bindata element, with
+ * the given subtype. If so, it copies the binary data to @out and returns true.
+ * If validation fails, then it returns false and sets an error in @status.*/
+bool parse_bindata(bson_subtype_t subtype, bson_iter_t *iter, _mongocrypt_buffer_t *out, mongocrypt_status_t *status);
 
-dependencies {
-    implementation(project(":")) // Reference to the parent project
-}
+#endif /* MC_PARSE_UTILS_PRIVATE_H */

data/ext/libmongocrypt/libmongocrypt/src/mc-parse-utils.c

@@ -0,0 +1,48 @@
+/*
+ * 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 "mc-parse-utils-private.h"
+#include "mongocrypt-private.h"
+#include "mongocrypt-util-private.h"
+
+bool parse_bindata(bson_subtype_t subtype, bson_iter_t *iter, _mongocrypt_buffer_t *out, mongocrypt_status_t *status) {
+    BSON_ASSERT_PARAM(iter);
+    BSON_ASSERT_PARAM(out);
+
+    bson_subtype_t parsed_subtype;
+    uint32_t len;
+    const uint8_t *data;
+    const char *field_name = bson_iter_key(iter);
+    if (bson_iter_type(iter) != BSON_TYPE_BINARY) {
+        CLIENT_ERR("Field '%s' expected to be bindata, got: %s",
+                   field_name,
+                   mc_bson_type_to_string(bson_iter_type(iter)));
+        return false;
+    }
+    bson_iter_binary(iter, &parsed_subtype, &len, &data);
+    if (parsed_subtype != subtype) {
+        CLIENT_ERR("Field '%s' expected to be bindata subtype %d, got: %d",
+                   field_name,
+                   (int)subtype,
+                   (int)parsed_subtype);
+        return false;
+    }
+    if (!_mongocrypt_buffer_copy_from_binary_iter(out, iter)) {
+        CLIENT_ERR("Unable to create mongocrypt buffer for BSON binary field in '%s'", field_name);
+        return false;
+    }
+    return true;
+}

data/ext/libmongocrypt/libmongocrypt/src/mc-range-edge-generation-private.h

@@ -53,7 +53,7 @@ typedef struct {
 
 // mc_getEdgesInt32 implements the Edge Generation algorithm described in
 // SERVER-67751 for int32_t.
-mc_edges_t *mc_getEdgesInt32(mc_getEdgesInt32_args_t args, mongocrypt_status_t *status, bool use_range_v2);
+mc_edges_t *mc_getEdgesInt32(mc_getEdgesInt32_args_t args, mongocrypt_status_t *status);
 
 typedef struct {
     int64_t value;
@@ -65,7 +65,7 @@ typedef struct {
 
 // mc_getEdgesInt64 implements the Edge Generation algorithm described in
 // SERVER-67751 for int64_t.
-mc_edges_t *mc_getEdgesInt64(mc_getEdgesInt64_args_t args, mongocrypt_status_t *status, bool use_range_v2);
+mc_edges_t *mc_getEdgesInt64(mc_getEdgesInt64_args_t args, mongocrypt_status_t *status);
 
 typedef struct {
     double value;
@@ -78,9 +78,9 @@ typedef struct {
 
 // mc_getEdgesDouble implements the Edge Generation algorithm described in
 // SERVER-67751 for double.
-mc_edges_t *mc_getEdgesDouble(mc_getEdgesDouble_args_t args, mongocrypt_status_t *status, bool use_range_v2);
+mc_edges_t *mc_getEdgesDouble(mc_getEdgesDouble_args_t args, mongocrypt_status_t *status);
 
-#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT
+#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT()
 typedef struct {
     mc_dec128 value;
     size_t sparsity;
@@ -89,7 +89,7 @@ typedef struct {
     mc_optional_int32_t trimFactor;
 } mc_getEdgesDecimal128_args_t;
 
-mc_edges_t *mc_getEdgesDecimal128(mc_getEdgesDecimal128_args_t args, mongocrypt_status_t *status, bool use_range_v2);
+mc_edges_t *mc_getEdgesDecimal128(mc_getEdgesDecimal128_args_t args, mongocrypt_status_t *status);
 #endif // MONGOCRYPT_HAVE_DECIMAL128_SUPPORT
 
 BSON_STATIC_ASSERT2(ull_is_u64, sizeof(uint64_t) == sizeof(unsigned long long));

data/ext/libmongocrypt/libmongocrypt/src/mc-range-edge-generation.c

@@ -35,11 +35,8 @@ int32_t mc_edges_get_used_trimFactor(const mc_edges_t *edges) {
     return edges->usedTrimFactor;
 }
 
-static mc_edges_t *mc_edges_new(const char *leaf,
-                                size_t sparsity,
-                                mc_optional_int32_t opt_trimFactor,
-                                mongocrypt_status_t *status,
-                                bool use_range_v2) {
+static mc_edges_t *
+mc_edges_new(const char *leaf, size_t sparsity, mc_optional_int32_t opt_trimFactor, mongocrypt_status_t *status) {
     BSON_ASSERT_PARAM(leaf);
     if (sparsity < 1) {
         CLIENT_ERR("sparsity must be 1 or larger");
@@ -47,11 +44,11 @@ static mc_edges_t *mc_edges_new(const char *leaf,
     }
 
     const size_t leaf_len = strlen(leaf);
-    const int32_t trimFactor = trimFactorDefault(leaf_len, opt_trimFactor, use_range_v2);
+    const int32_t trimFactor = trimFactorDefault(leaf_len, opt_trimFactor);
     if (trimFactor != 0 && mc_cmp_greater_equal_su(trimFactor, leaf_len)) {
         // We append a total of leaf_len + 1 (for the root) - trimFactor edges. When this number is equal to 1, we
         // degenerate into equality, which is not desired, so trimFactor must be less than leaf_len.
-        CLIENT_ERR("trimFactor must be less than the number of bits (%ld) used to represent an element of the domain, "
+        CLIENT_ERR("trimFactor must be less than the number of bits (%zu) used to represent an element of the domain, "
                    "but got %" PRId32,
                    leaf_len,
                    trimFactor);
@@ -163,7 +160,7 @@ mc_bitstring mc_convert_to_bitstring_u128(mlib_int128 i) {
     return ret;
 }
 
-mc_edges_t *mc_getEdgesInt32(mc_getEdgesInt32_args_t args, mongocrypt_status_t *status, bool use_range_v2) {
+mc_edges_t *mc_getEdgesInt32(mc_getEdgesInt32_args_t args, mongocrypt_status_t *status) {
     mc_OSTType_Int32 got;
     if (!mc_getTypeInfo32((mc_getTypeInfo32_args_t){.value = args.value, .min = args.min, .max = args.max},
                           &got,
@@ -179,11 +176,11 @@ mc_edges_t *mc_getEdgesInt32(mc_getEdgesInt32_args_t args, mongocrypt_status_t *
     mc_bitstring valueBin = mc_convert_to_bitstring_u32(got.value);
     size_t offset = mc_count_leading_zeros_u32(got.max);
     const char *leaf = valueBin.str + offset;
-    mc_edges_t *ret = mc_edges_new(leaf, args.sparsity, args.trimFactor, status, use_range_v2);
+    mc_edges_t *ret = mc_edges_new(leaf, args.sparsity, args.trimFactor, status);
     return ret;
 }
 
-mc_edges_t *mc_getEdgesInt64(mc_getEdgesInt64_args_t args, mongocrypt_status_t *status, bool use_range_v2) {
+mc_edges_t *mc_getEdgesInt64(mc_getEdgesInt64_args_t args, mongocrypt_status_t *status) {
     mc_OSTType_Int64 got;
     if (!mc_getTypeInfo64((mc_getTypeInfo64_args_t){.value = args.value, .min = args.min, .max = args.max},
                           &got,
@@ -199,19 +196,18 @@ mc_edges_t *mc_getEdgesInt64(mc_getEdgesInt64_args_t args, mongocrypt_status_t *
     mc_bitstring valueBin = mc_convert_to_bitstring_u64(got.value);
     size_t offset = mc_count_leading_zeros_u64(got.max);
     const char *leaf = valueBin.str + offset;
-    mc_edges_t *ret = mc_edges_new(leaf, args.sparsity, args.trimFactor, status, use_range_v2);
+    mc_edges_t *ret = mc_edges_new(leaf, args.sparsity, args.trimFactor, status);
     return ret;
 }
 
-mc_edges_t *mc_getEdgesDouble(mc_getEdgesDouble_args_t args, mongocrypt_status_t *status, bool use_range_v2) {
+mc_edges_t *mc_getEdgesDouble(mc_getEdgesDouble_args_t args, mongocrypt_status_t *status) {
     mc_OSTType_Double got;
     if (!mc_getTypeInfoDouble((mc_getTypeInfoDouble_args_t){.value = args.value,
                                                             .min = args.min,
                                                             .max = args.max,
                                                             .precision = args.precision},
                               &got,
-                              status,
-                              use_range_v2)) {
+                              status)) {
         return NULL;
     }
 
@@ -223,12 +219,12 @@ mc_edges_t *mc_getEdgesDouble(mc_getEdgesDouble_args_t args, mongocrypt_status_t
     mc_bitstring valueBin = mc_convert_to_bitstring_u64(got.value);
     size_t offset = mc_count_leading_zeros_u64(got.max);
     const char *leaf = valueBin.str + offset;
-    mc_edges_t *ret = mc_edges_new(leaf, args.sparsity, args.trimFactor, status, use_range_v2);
+    mc_edges_t *ret = mc_edges_new(leaf, args.sparsity, args.trimFactor, status);
     return ret;
 }
 
-#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT
-mc_edges_t *mc_getEdgesDecimal128(mc_getEdgesDecimal128_args_t args, mongocrypt_status_t *status, bool use_range_v2) {
+#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT()
+mc_edges_t *mc_getEdgesDecimal128(mc_getEdgesDecimal128_args_t args, mongocrypt_status_t *status) {
     mc_OSTType_Decimal128 got;
     if (!mc_getTypeInfoDecimal128(
             (mc_getTypeInfoDecimal128_args_t){
@@ -238,8 +234,7 @@ mc_edges_t *mc_getEdgesDecimal128(mc_getEdgesDecimal128_args_t args, mongocrypt_
                 .precision = args.precision,
             },
             &got,
-            status,
-            use_range_v2)) {
+            status)) {
         return NULL;
     }
 
@@ -248,7 +243,7 @@ mc_edges_t *mc_getEdgesDecimal128(mc_getEdgesDecimal128_args_t args, mongocrypt_
     mc_bitstring bits = mc_convert_to_bitstring_u128(got.value);
     size_t offset = mc_count_leading_zeros_u128(got.max);
     const char *leaf = bits.str + offset;
-    mc_edges_t *ret = mc_edges_new(leaf, args.sparsity, args.trimFactor, status, use_range_v2);
+    mc_edges_t *ret = mc_edges_new(leaf, args.sparsity, args.trimFactor, status);
     return ret;
 }
 #endif // MONGOCRYPT_HAVE_DECIMAL128_SUPPORT

data/ext/libmongocrypt/libmongocrypt/src/mc-range-encoding-private.h

@@ -97,10 +97,9 @@ bool mc_canUsePrecisionModeDouble(double min,
  * `out`. Returns false and sets `status` on error. */
 bool mc_getTypeInfoDouble(mc_getTypeInfoDouble_args_t args,
                           mc_OSTType_Double *out,
-                          mongocrypt_status_t *status,
-                          bool use_range_v2) MONGOCRYPT_WARN_UNUSED_RESULT;
+                          mongocrypt_status_t *status) MONGOCRYPT_WARN_UNUSED_RESULT;
 
-#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT
+#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT()
 /**
  * @brief OST-encoding of a Decimal128
  */
@@ -131,11 +130,10 @@ bool mc_canUsePrecisionModeDecimal(mc_dec128 min,
  */
 bool mc_getTypeInfoDecimal128(mc_getTypeInfoDecimal128_args_t args,
                               mc_OSTType_Decimal128 *out,
-                              mongocrypt_status_t *status,
-                              bool use_range_v2) MONGOCRYPT_WARN_UNUSED_RESULT;
+                              mongocrypt_status_t *status) MONGOCRYPT_WARN_UNUSED_RESULT;
 #endif // MONGOCRYPT_HAVE_DECIMAL128_SUPPORT
 
 extern const int64_t mc_FLERangeSparsityDefault;
 
-int32_t trimFactorDefault(size_t maxlen, mc_optional_int32_t trimFactor, bool use_range_v2);
+int32_t trimFactorDefault(size_t maxlen, mc_optional_int32_t trimFactor);
 #endif /* MC_RANGE_ENCODING_PRIVATE_H */

data/ext/libmongocrypt/libmongocrypt/src/mc-range-encoding.c

@@ -165,7 +165,7 @@ bool mc_getTypeInfo64(mc_getTypeInfo64_args_t args, mc_OSTType_Int64 *out, mongo
 #define exp10Double(x) pow(10, x)
 #define SCALED_DOUBLE_BOUNDS 9007199254740992.0 // 2^53
 
-uint64_t subtract_int64_t(int64_t max, int64_t min) {
+static uint64_t subtract_int64_t(int64_t max, int64_t min) {
     BSON_ASSERT(max > min);
     // If the values have the same sign, then simple subtraction
     // will work because we know max > min.
@@ -180,7 +180,7 @@ uint64_t subtract_int64_t(int64_t max, int64_t min) {
     return u_return;
 }
 
-bool ceil_log2_double(uint64_t i, uint32_t *maxBitsOut, mongocrypt_status_t *status) {
+static bool ceil_log2_double(uint64_t i, uint32_t *maxBitsOut, mongocrypt_status_t *status) {
     if (i == 0) {
         CLIENT_ERR("Invalid input to ceil_log2_double function. Input cannot be 0.");
         return false;
@@ -284,10 +284,7 @@ bool mc_canUsePrecisionModeDouble(double min,
     return true;
 }
 
-bool mc_getTypeInfoDouble(mc_getTypeInfoDouble_args_t args,
-                          mc_OSTType_Double *out,
-                          mongocrypt_status_t *status,
-                          bool use_range_v2) {
+bool mc_getTypeInfoDouble(mc_getTypeInfoDouble_args_t args, mc_OSTType_Double *out, mongocrypt_status_t *status) {
     if (args.min.set != args.max.set || args.min.set != args.precision.set) {
         CLIENT_ERR("min, max, and precision must all be set or must all be unset");
         return false;
@@ -350,7 +347,7 @@ bool mc_getTypeInfoDouble(mc_getTypeInfoDouble_args_t args,
         use_precision_mode =
             mc_canUsePrecisionModeDouble(args.min.value, args.max.value, args.precision.value, &bits_range, status);
 
-        if (!use_precision_mode && use_range_v2) {
+        if (!use_precision_mode) {
             if (!mongocrypt_status_ok(status)) {
                 return false;
             }
@@ -421,7 +418,7 @@ bool mc_getTypeInfoDouble(mc_getTypeInfoDouble_args_t args,
     return true;
 }
 
-#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT
+#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT()
 /**
  * @brief There is no shipped algorithm for creating a full 128-bit integer from
  * a Decimal128, but it's easy enough to write one of our own.
@@ -604,8 +601,7 @@ bool mc_canUsePrecisionModeDecimal(mc_dec128 min,
 
 bool mc_getTypeInfoDecimal128(mc_getTypeInfoDecimal128_args_t args,
                               mc_OSTType_Decimal128 *out,
-                              mongocrypt_status_t *status,
-                              bool use_range_v2) {
+                              mongocrypt_status_t *status) {
     /// Basic param checks
     if (args.min.set != args.max.set || args.min.set != args.precision.set) {
         CLIENT_ERR("min, max, and precision must all be set or must all be unset");
@@ -673,7 +669,7 @@ bool mc_getTypeInfoDecimal128(mc_getTypeInfoDecimal128_args_t args,
         use_precision_mode =
             mc_canUsePrecisionModeDecimal(args.min.value, args.max.value, args.precision.value, &bits_range, status);
 
-        if (use_range_v2 && !use_precision_mode) {
+        if (!use_precision_mode) {
             if (!mongocrypt_status_ok(status)) {
                 return false;
             }
@@ -852,18 +848,13 @@ bool mc_getTypeInfoDecimal128(mc_getTypeInfoDecimal128_args_t args,
 #endif // defined MONGOCRYPT_HAVE_DECIMAL128_SUPPORT
 
 const int64_t mc_FLERangeSparsityDefault = 2;
-const int32_t mc_FLERangeTrimFactorDefault = 6;
+static const int32_t mc_FLERangeTrimFactorDefault = 6;
 
-int32_t trimFactorDefault(size_t maxlen, mc_optional_int32_t trimFactor, bool use_range_v2) {
+int32_t trimFactorDefault(size_t maxlen, mc_optional_int32_t trimFactor) {
     if (trimFactor.set) {
         return trimFactor.value;
     }
 
-    if (!use_range_v2) {
-        // Preserve old default.
-        return 0;
-    }
-
     if (mc_cmp_greater_su(mc_FLERangeTrimFactorDefault, maxlen - 1)) {
         return (int32_t)(maxlen - 1);
     } else {

data/ext/libmongocrypt/libmongocrypt/src/mc-range-mincover-generator.template.h

@@ -100,8 +100,7 @@ static inline DECORATE_NAME(MinCoverGenerator)
                                            UINT_T max,
                                            size_t sparsity,
                                            mc_optional_int32_t opt_trimFactor,
-                                           mongocrypt_status_t *status,
-                                           bool use_range_v2) {
+                                           mongocrypt_status_t *status) {
     BSON_ASSERT_PARAM(status);
 
     if (UINT_COMPARE(rangeMin, rangeMax) > 0) {
@@ -123,9 +122,9 @@ static inline DECORATE_NAME(MinCoverGenerator)
         return NULL;
     }
     size_t maxlen = (size_t)BITS - DECORATE_NAME(mc_count_leading_zeros)(max);
-    int32_t trimFactor = trimFactorDefault(maxlen, opt_trimFactor, use_range_v2);
+    int32_t trimFactor = trimFactorDefault(maxlen, opt_trimFactor);
     if (trimFactor != 0 && mc_cmp_greater_equal_su(trimFactor, maxlen)) {
-        CLIENT_ERR("Trim factor must be less than the number of bits (%ld) used to represent an element of the domain, "
+        CLIENT_ERR("Trim factor must be less than the number of bits (%zu) used to represent an element of the domain, "
                    "but got %" PRId32,
                    maxlen,
                    trimFactor);
@@ -174,7 +173,7 @@ static inline bool DECORATE_NAME(MinCoverGenerator_isLevelStored)(DECORATE_NAME(
     return 0 == maskedBits || (level >= trimFactor_sz && 0 == (level % mcg->_sparsity));
 }
 
-char *
+static char *
 DECORATE_NAME(MinCoverGenerator_toString)(DECORATE_NAME(MinCoverGenerator) * mcg, UINT_T start, size_t maskedBits) {
     BSON_ASSERT_PARAM(mcg);
     BSON_ASSERT(maskedBits <= mcg->_maxlen);

data/ext/libmongocrypt/libmongocrypt/src/mc-range-mincover-private.h

@@ -53,8 +53,7 @@ typedef struct {
 // mc_getMincoverInt32 implements the Mincover Generation algorithm described in
 // SERVER-68600 for int32_t.
 mc_mincover_t *mc_getMincoverInt32(mc_getMincoverInt32_args_t args,
-                                   mongocrypt_status_t *status,
-                                   bool use_range_v2) MONGOCRYPT_WARN_UNUSED_RESULT;
+                                   mongocrypt_status_t *status) MONGOCRYPT_WARN_UNUSED_RESULT;
 
 typedef struct {
     int64_t lowerBound;
@@ -70,8 +69,7 @@ typedef struct {
 // mc_getMincoverInt64 implements the Mincover Generation algorithm described in
 // SERVER-68600 for int64_t.
 mc_mincover_t *mc_getMincoverInt64(mc_getMincoverInt64_args_t args,
-                                   mongocrypt_status_t *status,
-                                   bool use_range_v2) MONGOCRYPT_WARN_UNUSED_RESULT;
+                                   mongocrypt_status_t *status) MONGOCRYPT_WARN_UNUSED_RESULT;
 
 typedef struct {
     double lowerBound;
@@ -88,10 +86,9 @@ typedef struct {
 // mc_getMincoverDouble implements the Mincover Generation algorithm described
 // in SERVER-68600 for double.
 mc_mincover_t *mc_getMincoverDouble(mc_getMincoverDouble_args_t args,
-                                    mongocrypt_status_t *status,
-                                    bool use_range_v2) MONGOCRYPT_WARN_UNUSED_RESULT;
+                                    mongocrypt_status_t *status) MONGOCRYPT_WARN_UNUSED_RESULT;
 
-#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT
+#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT()
 typedef struct {
     mc_dec128 lowerBound;
     bool includeLowerBound;
@@ -106,8 +103,7 @@ typedef struct {
 // mc_getMincoverDecimal128 implements the Mincover Generation algorithm
 // described in SERVER-68600 for Decimal128 (as mc_dec128).
 mc_mincover_t *mc_getMincoverDecimal128(mc_getMincoverDecimal128_args_t args,
-                                        mongocrypt_status_t *status,
-                                        bool use_range_v2) MONGOCRYPT_WARN_UNUSED_RESULT;
+                                        mongocrypt_status_t *status) MONGOCRYPT_WARN_UNUSED_RESULT;
 #endif // MONGOCRYPT_HAVE_DECIMAL128_SUPPORT
 
 #endif /* MC_RANGE_MINCOVER_PRIVATE_H */