libmongocrypt-helper 1.13.2.0.1001 → 1.14.0.0.1001

data/ext/libmongocrypt/libmongocrypt/src/mc-fle2-encryption-placeholder.c

@@ -24,38 +24,38 @@
 #include "mongocrypt-util-private.h" // mc_bson_type_to_string
 #include "mongocrypt.h"
 
-#define CLIENT_ERR_PREFIXED_HELPER(Prefix, ErrorString, ...) CLIENT_ERR(Prefix ": " ErrorString, ##__VA_ARGS__)
-#define CLIENT_ERR_PREFIXED(ErrorString, ...) CLIENT_ERR_PREFIXED_HELPER(ERROR_PREFIX, ErrorString, ##__VA_ARGS__)
-
 // Common logic for testing field name, tracking duplication, and presence.
 #define IF_FIELD(Name)                                                                                                 \
     if (0 == strcmp(field, #Name)) {                                                                                   \
         if (has_##Name) {                                                                                              \
-            CLIENT_ERR_PREFIXED("Duplicate field '" #Name "' in placeholder bson");                                    \
+            CLIENT_ERR(ERROR_PREFIX "Duplicate field '" #Name "' in placeholder bson");                                \
             goto fail;                                                                                                 \
         }                                                                                                              \
-        has_##Name = true;
+        has_##Name = true;                                                                                             \
+    ((void)0)
 
 #define END_IF_FIELD                                                                                                   \
     continue;                                                                                                          \
-    }
+    }                                                                                                                  \
+    else((void)0)
 
 #define CHECK_HAS(Name)                                                                                                \
     if (!has_##Name) {                                                                                                 \
-        CLIENT_ERR_PREFIXED("Missing field '" #Name "' in placeholder");                                               \
+        CLIENT_ERR(ERROR_PREFIX "Missing field '" #Name "' in placeholder");                                           \
         goto fail;                                                                                                     \
     }
 
 // Common logic for parsing int32 greater than zero
 #define IF_FIELD_INT32_GT0_PARSE(Name, Dest, Iter)                                                                     \
-    IF_FIELD(Name) {                                                                                                   \
+    IF_FIELD(Name);                                                                                                    \
+    {                                                                                                                  \
         if (!BSON_ITER_HOLDS_INT32(&Iter)) {                                                                           \
-            CLIENT_ERR_PREFIXED("'" #Name "' must be an int32");                                                       \
+            CLIENT_ERR(ERROR_PREFIX "'" #Name "' must be an int32");                                                   \
             goto fail;                                                                                                 \
         }                                                                                                              \
         int32_t val = bson_iter_int32(&Iter);                                                                          \
         if (val <= 0) {                                                                                                \
-            CLIENT_ERR_PREFIXED("'" #Name "' must be greater than zero");                                              \
+            CLIENT_ERR(ERROR_PREFIX "'" #Name "' must be greater than zero");                                          \
             goto fail;                                                                                                 \
         }                                                                                                              \
         Dest = (uint32_t)val;                                                                                          \
@@ -66,7 +66,7 @@ void mc_FLE2EncryptionPlaceholder_init(mc_FLE2EncryptionPlaceholder_t *placehold
     memset(placeholder, 0, sizeof(mc_FLE2EncryptionPlaceholder_t));
 }
 
-#define ERROR_PREFIX "Error parsing FLE2EncryptionPlaceholder"
+#define ERROR_PREFIX "Error parsing FLE2EncryptionPlaceholder: "
 
 bool mc_FLE2EncryptionPlaceholder_parse(mc_FLE2EncryptionPlaceholder_t *out,
                                         const bson_t *in,
@@ -81,7 +81,7 @@ bool mc_FLE2EncryptionPlaceholder_parse(mc_FLE2EncryptionPlaceholder_t *out,
 
     mc_FLE2EncryptionPlaceholder_init(out);
     if (!bson_validate(in, BSON_VALIDATE_NONE, NULL) || !bson_iter_init(&iter, in)) {
-        CLIENT_ERR_PREFIXED("invalid BSON");
+        CLIENT_ERR(ERROR_PREFIX "invalid BSON");
         return false;
     }
 
@@ -89,61 +89,65 @@ bool mc_FLE2EncryptionPlaceholder_parse(mc_FLE2EncryptionPlaceholder_t *out,
         const char *field = bson_iter_key(&iter);
         BSON_ASSERT(field);
 
-        IF_FIELD(t) {
+        IF_FIELD(t);
+        {
             int32_t type;
             if (!BSON_ITER_HOLDS_INT32(&iter)) {
-                CLIENT_ERR_PREFIXED("invalid marking, 't' must be an int32");
+                CLIENT_ERR(ERROR_PREFIX "invalid marking, 't' must be an int32");
                 goto fail;
             }
             type = bson_iter_int32(&iter);
             if ((type != MONGOCRYPT_FLE2_PLACEHOLDER_TYPE_INSERT) && (type != MONGOCRYPT_FLE2_PLACEHOLDER_TYPE_FIND)) {
-                CLIENT_ERR_PREFIXED("invalid placeholder type value: %d", type);
+                CLIENT_ERR(ERROR_PREFIX "invalid placeholder type value: %d", type);
                 goto fail;
             }
             out->type = (mongocrypt_fle2_placeholder_type_t)type;
         }
-        END_IF_FIELD
+        END_IF_FIELD;
 
-        IF_FIELD(a) {
+        IF_FIELD(a);
+        {
             int32_t algorithm;
             if (!BSON_ITER_HOLDS_INT32(&iter)) {
-                CLIENT_ERR_PREFIXED("invalid marking, 'a' must be an int32");
+                CLIENT_ERR(ERROR_PREFIX "invalid marking, 'a' must be an int32");
                 goto fail;
             }
             algorithm = bson_iter_int32(&iter);
             if (algorithm != MONGOCRYPT_FLE2_ALGORITHM_UNINDEXED && algorithm != MONGOCRYPT_FLE2_ALGORITHM_EQUALITY
                 && algorithm != MONGOCRYPT_FLE2_ALGORITHM_RANGE && algorithm != MONGOCRYPT_FLE2_ALGORITHM_TEXT_SEARCH) {
-                CLIENT_ERR_PREFIXED("invalid algorithm value: %d", algorithm);
+                CLIENT_ERR(ERROR_PREFIX "invalid algorithm value: %d", algorithm);
                 goto fail;
             }
             out->algorithm = (mongocrypt_fle2_encryption_algorithm_t)algorithm;
         }
-        END_IF_FIELD
+        END_IF_FIELD;
 
-        IF_FIELD(ki) {
+        IF_FIELD(ki);
+        {
             if (!_mongocrypt_buffer_from_uuid_iter(&out->index_key_id, &iter)) {
-                CLIENT_ERR_PREFIXED("index key id must be a UUID");
+                CLIENT_ERR(ERROR_PREFIX "index key id must be a UUID");
                 goto fail;
             }
         }
-        END_IF_FIELD
+        END_IF_FIELD;
 
-        IF_FIELD(ku) {
+        IF_FIELD(ku);
+        {
             if (!_mongocrypt_buffer_from_uuid_iter(&out->user_key_id, &iter)) {
-                CLIENT_ERR_PREFIXED("user key id must be a UUID");
+                CLIENT_ERR(ERROR_PREFIX "user key id must be a UUID");
                 goto fail;
             }
         }
-        END_IF_FIELD
+        END_IF_FIELD;
 
-        IF_FIELD(v) {
-            memcpy(&out->v_iter, &iter, sizeof(bson_iter_t));
-        }
-        END_IF_FIELD
+        IF_FIELD(v);
+        memcpy(&out->v_iter, &iter, sizeof(bson_iter_t));
+        END_IF_FIELD;
 
-        IF_FIELD(cm) {
+        IF_FIELD(cm);
+        {
             if (!BSON_ITER_HOLDS_INT64(&iter)) {
-                CLIENT_ERR_PREFIXED("invalid marking, 'cm' must be an int64");
+                CLIENT_ERR(ERROR_PREFIX "invalid marking, 'cm' must be an int64");
                 goto fail;
             }
             out->maxContentionFactor = bson_iter_int64(&iter);
@@ -151,11 +155,12 @@ bool mc_FLE2EncryptionPlaceholder_parse(mc_FLE2EncryptionPlaceholder_t *out,
                 goto fail;
             }
         }
-        END_IF_FIELD
+        END_IF_FIELD;
 
-        IF_FIELD(s) {
+        IF_FIELD(s);
+        {
             if (!BSON_ITER_HOLDS_INT64(&iter)) {
-                CLIENT_ERR_PREFIXED("invalid marking, 's' must be an int64");
+                CLIENT_ERR(ERROR_PREFIX "invalid marking, 's' must be an int64");
                 goto fail;
             }
             out->sparsity = bson_iter_int64(&iter);
@@ -163,7 +168,7 @@ bool mc_FLE2EncryptionPlaceholder_parse(mc_FLE2EncryptionPlaceholder_t *out,
                 goto fail;
             }
         }
-        END_IF_FIELD
+        END_IF_FIELD;
     }
 
     CHECK_HAS(t)
@@ -191,42 +196,41 @@ void mc_FLE2EncryptionPlaceholder_cleanup(mc_FLE2EncryptionPlaceholder_t *placeh
 }
 
 #undef ERROR_PREFIX
-#define ERROR_PREFIX "Error validating contention"
+#define ERROR_PREFIX "Error validating contention: "
 
 bool mc_validate_contention(int64_t contention, mongocrypt_status_t *status) {
     if (contention < 0) {
-        CLIENT_ERR_PREFIXED("contention must be non-negative, got: %" PRId64, contention);
+        CLIENT_ERR(ERROR_PREFIX "contention must be non-negative, got: %" PRId64, contention);
         return false;
     }
     if (contention == INT64_MAX) {
-        CLIENT_ERR_PREFIXED("contention must be < INT64_MAX, got: %" PRId64, contention);
+        CLIENT_ERR(ERROR_PREFIX "contention must be < INT64_MAX, got: %" PRId64, contention);
         return false;
     }
     return true;
 }
 
 #undef ERROR_PREFIX
-#define ERROR_PREFIX "Error validating sparsity"
+#define ERROR_PREFIX "Error validating sparsity: "
 
 bool mc_validate_sparsity(int64_t sparsity, mongocrypt_status_t *status) {
     if (sparsity < 0) {
-        CLIENT_ERR_PREFIXED("sparsity must be non-negative, got: %" PRId64, sparsity);
+        CLIENT_ERR(ERROR_PREFIX "sparsity must be non-negative, got: %" PRId64, sparsity);
         return false;
     }
     // mc_getEdgesInt expects a size_t sparsity.
     if ((uint64_t)sparsity >= SIZE_MAX) {
-        CLIENT_ERR_PREFIXED("sparsity must be < %zu, got: %" PRId64, SIZE_MAX, sparsity);
+        CLIENT_ERR(ERROR_PREFIX "sparsity must be < %zu, got: %" PRId64, SIZE_MAX, sparsity);
         return false;
     }
     return true;
 }
 
 #undef ERROR_PREFIX
-#define ERROR_PREFIX "Error parsing FLE2RangeFindSpecEdgesInfo"
+#define ERROR_PREFIX "Error parsing FLE2RangeFindSpecEdgesInfo: "
 
 static bool mc_FLE2RangeFindSpecEdgesInfo_parse(mc_FLE2RangeFindSpecEdgesInfo_t *out,
                                                 const bson_iter_t *in,
-                                                bool use_range_v2,
                                                 mongocrypt_status_t *status) {
     bson_iter_t iter;
     bool has_lowerBound = false, has_lbIncluded = false, has_upperBound = false, has_ubIncluded = false,
@@ -238,7 +242,7 @@ static bool mc_FLE2RangeFindSpecEdgesInfo_parse(mc_FLE2RangeFindSpecEdgesInfo_t
     iter = *in;
 
     if (!BSON_ITER_HOLDS_DOCUMENT(&iter)) {
-        CLIENT_ERR_PREFIXED("must be an iterator to a document");
+        CLIENT_ERR(ERROR_PREFIX "must be an iterator to a document");
         return false;
     }
     bson_iter_recurse(&iter, &iter);
@@ -247,73 +251,73 @@ static bool mc_FLE2RangeFindSpecEdgesInfo_parse(mc_FLE2RangeFindSpecEdgesInfo_t
         const char *field = bson_iter_key(&iter);
         BSON_ASSERT(field);
 
-        IF_FIELD(lowerBound) {
-            out->lowerBound = iter;
-        }
-        END_IF_FIELD
+        IF_FIELD(lowerBound);
+        out->lowerBound = iter;
+        END_IF_FIELD;
 
-        IF_FIELD(lbIncluded) {
+        IF_FIELD(lbIncluded);
+        {
             if (!BSON_ITER_HOLDS_BOOL(&iter)) {
-                CLIENT_ERR_PREFIXED("'lbIncluded' must be a bool");
+                CLIENT_ERR(ERROR_PREFIX "'lbIncluded' must be a bool");
                 goto fail;
             }
             out->lbIncluded = bson_iter_bool(&iter);
         }
-        END_IF_FIELD
+        END_IF_FIELD;
 
-        IF_FIELD(upperBound) {
-            out->upperBound = iter;
-        }
-        END_IF_FIELD
+        IF_FIELD(upperBound);
+        out->upperBound = iter;
+        END_IF_FIELD;
 
-        IF_FIELD(ubIncluded) {
+        IF_FIELD(ubIncluded);
+        {
             if (!BSON_ITER_HOLDS_BOOL(&iter)) {
-                CLIENT_ERR_PREFIXED("'ubIncluded' must be a bool");
+                CLIENT_ERR(ERROR_PREFIX "'ubIncluded' must be a bool");
                 goto fail;
             }
             out->ubIncluded = bson_iter_bool(&iter);
         }
-        END_IF_FIELD
+        END_IF_FIELD;
 
-        IF_FIELD(indexMin) {
-            out->indexMin = iter;
-        }
-        END_IF_FIELD
+        IF_FIELD(indexMin);
+        out->indexMin = iter;
+        END_IF_FIELD;
 
-        IF_FIELD(indexMax) {
-            out->indexMax = iter;
-        }
-        END_IF_FIELD
+        IF_FIELD(indexMax);
+        out->indexMax = iter;
+        END_IF_FIELD;
 
-        IF_FIELD(precision) {
+        IF_FIELD(precision);
+        {
             if (!BSON_ITER_HOLDS_INT32(&iter)) {
-                CLIENT_ERR_PREFIXED("'precision' must be an int32");
+                CLIENT_ERR(ERROR_PREFIX "'precision' must be an int32");
                 goto fail;
             }
             int32_t val = bson_iter_int32(&iter);
             if (val < 0) {
-                CLIENT_ERR_PREFIXED("'precision' must be non-negative");
+                CLIENT_ERR(ERROR_PREFIX "'precision' must be non-negative");
                 goto fail;
             }
 
             out->precision = OPT_I32(val);
         }
-        END_IF_FIELD
+        END_IF_FIELD;
 
-        IF_FIELD(trimFactor) {
+        IF_FIELD(trimFactor);
+        {
             if (!BSON_ITER_HOLDS_INT32(&iter)) {
-                CLIENT_ERR_PREFIXED("'trimFactor' must be an int32");
+                CLIENT_ERR(ERROR_PREFIX "'trimFactor' must be an int32");
                 goto fail;
             }
             int32_t val = bson_iter_int32(&iter);
             if (val < 0) {
-                CLIENT_ERR_PREFIXED("'trimFactor' must be non-negative");
+                CLIENT_ERR(ERROR_PREFIX "'trimFactor' must be non-negative");
                 goto fail;
             }
 
             out->trimFactor = OPT_I32(val);
         }
-        END_IF_FIELD
+        END_IF_FIELD;
     }
 
     CHECK_HAS(lowerBound)
@@ -325,11 +329,6 @@ static bool mc_FLE2RangeFindSpecEdgesInfo_parse(mc_FLE2RangeFindSpecEdgesInfo_t
     // Do not error if precision is not present. Precision optional and only
     // applies to double/decimal128.
 
-    if (!use_range_v2 && out->trimFactor.set) {
-        CLIENT_ERR_PREFIXED("'trimFactor' is not supported for QE range v1");
-        return false;
-    }
-
     return true;
 
 fail:
@@ -337,12 +336,9 @@ fail:
 }
 
 #undef ERROR_PREFIX
-#define ERROR_PREFIX "Error parsing FLE2RangeFindSpec"
+#define ERROR_PREFIX "Error parsing FLE2RangeFindSpec: "
 
-bool mc_FLE2RangeFindSpec_parse(mc_FLE2RangeFindSpec_t *out,
-                                const bson_iter_t *in,
-                                bool use_range_v2,
-                                mongocrypt_status_t *status) {
+bool mc_FLE2RangeFindSpec_parse(mc_FLE2RangeFindSpec_t *out, const bson_iter_t *in, mongocrypt_status_t *status) {
     BSON_ASSERT_PARAM(out);
     BSON_ASSERT_PARAM(in);
 
@@ -352,7 +348,7 @@ bool mc_FLE2RangeFindSpec_parse(mc_FLE2RangeFindSpec_t *out,
     *out = (mc_FLE2RangeFindSpec_t){{{{0}}}};
 
     if (!BSON_ITER_HOLDS_DOCUMENT(&iter)) {
-        CLIENT_ERR_PREFIXED("must be an iterator to a document");
+        CLIENT_ERR(ERROR_PREFIX "must be an iterator to a document");
         return false;
     }
     bson_iter_recurse(&iter, &iter);
@@ -361,54 +357,58 @@ bool mc_FLE2RangeFindSpec_parse(mc_FLE2RangeFindSpec_t *out,
         const char *field = bson_iter_key(&iter);
         BSON_ASSERT(field);
 
-        IF_FIELD(edgesInfo) {
-            if (!mc_FLE2RangeFindSpecEdgesInfo_parse(&out->edgesInfo.value, &iter, use_range_v2, status)) {
+        IF_FIELD(edgesInfo);
+        {
+            if (!mc_FLE2RangeFindSpecEdgesInfo_parse(&out->edgesInfo.value, &iter, status)) {
                 goto fail;
             }
             out->edgesInfo.set = true;
         }
-        END_IF_FIELD
+        END_IF_FIELD;
 
-        IF_FIELD(payloadId) {
+        IF_FIELD(payloadId);
+        {
             if (!BSON_ITER_HOLDS_INT32(&iter)) {
-                CLIENT_ERR_PREFIXED("'payloadId' must be an int32");
+                CLIENT_ERR(ERROR_PREFIX "'payloadId' must be an int32");
                 goto fail;
             }
             out->payloadId = bson_iter_int32(&iter);
         }
-        END_IF_FIELD
+        END_IF_FIELD;
 
-        IF_FIELD(firstOperator) {
+        IF_FIELD(firstOperator);
+        {
             if (!BSON_ITER_HOLDS_INT32(&iter)) {
-                CLIENT_ERR_PREFIXED("'firstOperator' must be an int32");
+                CLIENT_ERR(ERROR_PREFIX "'firstOperator' must be an int32");
                 goto fail;
             }
             const int32_t first_op = bson_iter_int32(&iter);
             if (first_op < FLE2RangeOperator_min_val || first_op > FLE2RangeOperator_max_val) {
-                CLIENT_ERR_PREFIXED("'firstOperator' must be between %d and %d",
-                                    FLE2RangeOperator_min_val,
-                                    FLE2RangeOperator_max_val);
+                CLIENT_ERR(ERROR_PREFIX "'firstOperator' must be between %d and %d",
+                           FLE2RangeOperator_min_val,
+                           FLE2RangeOperator_max_val);
                 goto fail;
             }
             out->firstOperator = (mc_FLE2RangeOperator_t)first_op;
         }
-        END_IF_FIELD
+        END_IF_FIELD;
 
-        IF_FIELD(secondOperator) {
+        IF_FIELD(secondOperator);
+        {
             if (!BSON_ITER_HOLDS_INT32(&iter)) {
-                CLIENT_ERR_PREFIXED("'secondOperator' must be an int32");
+                CLIENT_ERR(ERROR_PREFIX "'secondOperator' must be an int32");
                 goto fail;
             }
             const int32_t second_op = bson_iter_int32(&iter);
             if (second_op < FLE2RangeOperator_min_val || second_op > FLE2RangeOperator_max_val) {
-                CLIENT_ERR_PREFIXED("'secondOperator' must be between %d and %d",
-                                    FLE2RangeOperator_min_val,
-                                    FLE2RangeOperator_max_val);
+                CLIENT_ERR(ERROR_PREFIX "'secondOperator' must be between %d and %d",
+                           FLE2RangeOperator_min_val,
+                           FLE2RangeOperator_max_val);
                 goto fail;
             }
             out->secondOperator = (mc_FLE2RangeOperator_t)second_op;
         }
-        END_IF_FIELD
+        END_IF_FIELD;
     }
 
     // edgesInfo is optional. Do not require it.
@@ -422,12 +422,9 @@ fail:
 }
 
 #undef ERROR_PREFIX
-#define ERROR_PREFIX "Error parsing FLE2RangeInsertSpec"
+#define ERROR_PREFIX "Error parsing FLE2RangeInsertSpec: "
 
-bool mc_FLE2RangeInsertSpec_parse(mc_FLE2RangeInsertSpec_t *out,
-                                  const bson_iter_t *in,
-                                  bool use_range_v2,
-                                  mongocrypt_status_t *status) {
+bool mc_FLE2RangeInsertSpec_parse(mc_FLE2RangeInsertSpec_t *out, const bson_iter_t *in, mongocrypt_status_t *status) {
     BSON_ASSERT_PARAM(out);
     BSON_ASSERT_PARAM(in);
 
@@ -437,7 +434,7 @@ bool mc_FLE2RangeInsertSpec_parse(mc_FLE2RangeInsertSpec_t *out,
     bool has_v = false, has_min = false, has_max = false, has_precision = false, has_trimFactor = false;
 
     if (!BSON_ITER_HOLDS_DOCUMENT(&iter)) {
-        CLIENT_ERR_PREFIXED("must be an iterator to a document");
+        CLIENT_ERR(ERROR_PREFIX "must be an iterator to a document");
         return false;
     }
     bson_iter_recurse(&iter, &iter);
@@ -446,48 +443,47 @@ bool mc_FLE2RangeInsertSpec_parse(mc_FLE2RangeInsertSpec_t *out,
         const char *field = bson_iter_key(&iter);
         BSON_ASSERT(field);
 
-        IF_FIELD(v) {
-            out->v = iter;
-        }
-        END_IF_FIELD
+        IF_FIELD(v);
+        out->v = iter;
+        END_IF_FIELD;
 
-        IF_FIELD(min) {
-            out->min = iter;
-        }
-        END_IF_FIELD
+        IF_FIELD(min);
+        out->min = iter;
+        END_IF_FIELD;
 
-        IF_FIELD(max) {
-            out->max = iter;
-        }
-        END_IF_FIELD
+        IF_FIELD(max);
+        out->max = iter;
+        END_IF_FIELD;
 
-        IF_FIELD(precision) {
+        IF_FIELD(precision);
+        {
             if (!BSON_ITER_HOLDS_INT32(&iter)) {
-                CLIENT_ERR_PREFIXED("'precision' must be an int32");
+                CLIENT_ERR(ERROR_PREFIX "'precision' must be an int32");
                 goto fail;
             }
             int32_t val = bson_iter_int32(&iter);
             if (val < 0) {
-                CLIENT_ERR_PREFIXED("'precision' must be non-negative");
+                CLIENT_ERR(ERROR_PREFIX "'precision' must be non-negative");
                 goto fail;
             }
             out->precision = OPT_I32(val);
         }
-        END_IF_FIELD
+        END_IF_FIELD;
 
-        IF_FIELD(trimFactor) {
+        IF_FIELD(trimFactor);
+        {
             if (!BSON_ITER_HOLDS_INT32(&iter)) {
-                CLIENT_ERR_PREFIXED("'trimFactor' must be an int32");
+                CLIENT_ERR(ERROR_PREFIX "'trimFactor' must be an int32");
                 goto fail;
             }
             int32_t val = bson_iter_int32(&iter);
             if (val < 0) {
-                CLIENT_ERR_PREFIXED("'trimFactor' must be non-negative");
+                CLIENT_ERR(ERROR_PREFIX "'trimFactor' must be non-negative");
                 goto fail;
             }
             out->trimFactor = OPT_I32(val);
         }
-        END_IF_FIELD
+        END_IF_FIELD;
     }
 
     CHECK_HAS(v)
@@ -496,11 +492,6 @@ bool mc_FLE2RangeInsertSpec_parse(mc_FLE2RangeInsertSpec_t *out,
     // Do not error if precision is not present. Precision optional and only
     // applies to double/decimal128.
 
-    if (!use_range_v2 && out->trimFactor.set) {
-        CLIENT_ERR_PREFIXED("'trimFactor' is not supported for QE range v1");
-        return false;
-    }
-
     return true;
 
 fail:
@@ -509,11 +500,11 @@ fail:
 
 #undef ERROR_PREFIX
 
-#define ERROR_PREFIX "Error parsing FLE2SubstringInsertSpec"
+#define ERROR_PREFIX "Error parsing FLE2SubstringInsertSpec: "
 
-static bool mc_FLE2SubstringInsertSpec_parse(mc_FLE2SubstringInsertSpec_t *out,
-                                             const bson_iter_t *in,
-                                             mongocrypt_status_t *status) {
+bool mc_FLE2SubstringInsertSpec_parse(mc_FLE2SubstringInsertSpec_t *out,
+                                      const bson_iter_t *in,
+                                      mongocrypt_status_t *status) {
     bson_iter_t iter;
     bool has_mlen = false, has_ub = false, has_lb = false;
     BSON_ASSERT_PARAM(out);
@@ -522,7 +513,7 @@ static bool mc_FLE2SubstringInsertSpec_parse(mc_FLE2SubstringInsertSpec_t *out,
     iter = *in;
 
     if (!BSON_ITER_HOLDS_DOCUMENT(&iter)) {
-        CLIENT_ERR_PREFIXED("must be an iterator to a document");
+        CLIENT_ERR(ERROR_PREFIX "must be an iterator to a document");
         return false;
     }
     bson_iter_recurse(&iter, &iter);
@@ -537,11 +528,11 @@ static bool mc_FLE2SubstringInsertSpec_parse(mc_FLE2SubstringInsertSpec_t *out,
     CHECK_HAS(ub)
     CHECK_HAS(lb)
     if (out->ub < out->lb) {
-        CLIENT_ERR_PREFIXED("upper bound cannot be less than the lower bound");
+        CLIENT_ERR(ERROR_PREFIX "upper bound cannot be less than the lower bound");
         goto fail;
     }
     if (out->mlen < out->ub) {
-        CLIENT_ERR_PREFIXED("maximum indexed length cannot be less than the upper bound");
+        CLIENT_ERR(ERROR_PREFIX "maximum indexed length cannot be less than the upper bound");
         goto fail;
     }
     return true;
@@ -551,10 +542,9 @@ fail:
 
 #undef ERROR_PREFIX
 
-#define ERROR_PREFIX "Error parsing FLE2SuffixInsertSpec"
+#define ERROR_PREFIX "Error parsing FLE2SuffixInsertSpec: "
 
-static bool
-mc_FLE2SuffixInsertSpec_parse(mc_FLE2SuffixInsertSpec_t *out, const bson_iter_t *in, mongocrypt_status_t *status) {
+bool mc_FLE2SuffixInsertSpec_parse(mc_FLE2SuffixInsertSpec_t *out, const bson_iter_t *in, mongocrypt_status_t *status) {
     bson_iter_t iter;
     bool has_ub = false, has_lb = false;
 
@@ -564,7 +554,7 @@ mc_FLE2SuffixInsertSpec_parse(mc_FLE2SuffixInsertSpec_t *out, const bson_iter_t
     iter = *in;
 
     if (!BSON_ITER_HOLDS_DOCUMENT(&iter)) {
-        CLIENT_ERR_PREFIXED("must be an iterator to a document");
+        CLIENT_ERR(ERROR_PREFIX "must be an iterator to a document");
         return false;
     }
     bson_iter_recurse(&iter, &iter);
@@ -577,7 +567,7 @@ mc_FLE2SuffixInsertSpec_parse(mc_FLE2SuffixInsertSpec_t *out, const bson_iter_t
     CHECK_HAS(ub)
     CHECK_HAS(lb)
     if (out->ub < out->lb) {
-        CLIENT_ERR_PREFIXED("upper bound cannot be less than the lower bound");
+        CLIENT_ERR(ERROR_PREFIX "upper bound cannot be less than the lower bound");
         goto fail;
     }
     return true;
@@ -587,10 +577,9 @@ fail:
 
 #undef ERROR_PREFIX
 
-#define ERROR_PREFIX "Error parsing FLE2PrefixInsertSpec"
+#define ERROR_PREFIX "Error parsing FLE2PrefixInsertSpec: "
 
-static bool
-mc_FLE2PrefixInsertSpec_parse(mc_FLE2PrefixInsertSpec_t *out, const bson_iter_t *in, mongocrypt_status_t *status) {
+bool mc_FLE2PrefixInsertSpec_parse(mc_FLE2PrefixInsertSpec_t *out, const bson_iter_t *in, mongocrypt_status_t *status) {
     bson_iter_t iter;
     bool has_ub = false, has_lb = false;
     BSON_ASSERT_PARAM(out);
@@ -599,7 +588,7 @@ mc_FLE2PrefixInsertSpec_parse(mc_FLE2PrefixInsertSpec_t *out, const bson_iter_t
     iter = *in;
 
     if (!BSON_ITER_HOLDS_DOCUMENT(&iter)) {
-        CLIENT_ERR_PREFIXED("must be an iterator to a document");
+        CLIENT_ERR(ERROR_PREFIX "must be an iterator to a document");
         return false;
     }
     bson_iter_recurse(&iter, &iter);
@@ -612,7 +601,7 @@ mc_FLE2PrefixInsertSpec_parse(mc_FLE2PrefixInsertSpec_t *out, const bson_iter_t
     CHECK_HAS(ub)
     CHECK_HAS(lb)
     if (out->ub < out->lb) {
-        CLIENT_ERR_PREFIXED("upper bound cannot be less than the lower bound");
+        CLIENT_ERR(ERROR_PREFIX "upper bound cannot be less than the lower bound");
         goto fail;
     }
     return true;
@@ -622,7 +611,7 @@ fail:
 
 #undef ERROR_PREFIX
 
-#define ERROR_PREFIX "Error parsing FLE2TextSearchInsertSpec"
+#define ERROR_PREFIX "Error parsing FLE2TextSearchInsertSpec: "
 
 bool mc_FLE2TextSearchInsertSpec_parse(mc_FLE2TextSearchInsertSpec_t *out,
                                        const bson_iter_t *in,
@@ -637,7 +626,7 @@ bool mc_FLE2TextSearchInsertSpec_parse(mc_FLE2TextSearchInsertSpec_t *out,
     bool has_substr = false, has_suffix = false, has_prefix = false;
 
     if (!BSON_ITER_HOLDS_DOCUMENT(&iter)) {
-        CLIENT_ERR_PREFIXED("must be an iterator to a document");
+        CLIENT_ERR(ERROR_PREFIX "must be an iterator to a document");
         return false;
     }
     bson_iter_recurse(&iter, &iter);
@@ -646,72 +635,74 @@ bool mc_FLE2TextSearchInsertSpec_parse(mc_FLE2TextSearchInsertSpec_t *out,
         const char *field = bson_iter_key(&iter);
         BSON_ASSERT(field);
 
-        IF_FIELD(v) {
+        IF_FIELD(v);
+        {
             out->v = bson_iter_utf8(&iter, &out->len);
             if (!out->v) {
-                CLIENT_ERR_PREFIXED("unsupported BSON type: %s for text search",
-                                    mc_bson_type_to_string(bson_iter_type(&iter)));
+                CLIENT_ERR(ERROR_PREFIX "unsupported BSON type: %s for text search",
+                           mc_bson_type_to_string(bson_iter_type(&iter)));
                 goto fail;
             }
             out->v_iter = iter;
         }
-        END_IF_FIELD
+        END_IF_FIELD;
 
-        IF_FIELD(casef) {
+        IF_FIELD(casef);
+        {
             if (!BSON_ITER_HOLDS_BOOL(&iter)) {
-                CLIENT_ERR_PREFIXED("'casef' must be a bool");
+                CLIENT_ERR(ERROR_PREFIX "'casef' must be a bool");
                 goto fail;
             }
             out->casef = bson_iter_bool(&iter);
         }
-        END_IF_FIELD
+        END_IF_FIELD;
 
-        IF_FIELD(diacf) {
+        IF_FIELD(diacf);
+        {
             if (!BSON_ITER_HOLDS_BOOL(&iter)) {
-                CLIENT_ERR_PREFIXED("'diacf' must be a bool");
+                CLIENT_ERR(ERROR_PREFIX "'diacf' must be a bool");
                 goto fail;
             }
             out->diacf = bson_iter_bool(&iter);
         }
-        END_IF_FIELD
+        END_IF_FIELD;
 
-        IF_FIELD(substr) {
+        IF_FIELD(substr);
+        {
             if (!mc_FLE2SubstringInsertSpec_parse(&out->substr.value, &iter, status)) {
                 goto fail;
             }
             out->substr.set = true;
         }
-        END_IF_FIELD
+        END_IF_FIELD;
 
-        IF_FIELD(suffix) {
+        IF_FIELD(suffix);
+        {
             if (!mc_FLE2SuffixInsertSpec_parse(&out->suffix.value, &iter, status)) {
                 goto fail;
             }
             out->suffix.set = true;
         }
-        END_IF_FIELD
+        END_IF_FIELD;
 
-        IF_FIELD(prefix) {
+        IF_FIELD(prefix);
+        {
             if (!mc_FLE2PrefixInsertSpec_parse(&out->prefix.value, &iter, status)) {
                 goto fail;
             }
             out->prefix.set = true;
         }
-        END_IF_FIELD
+        END_IF_FIELD;
     }
 
     CHECK_HAS(v)
     CHECK_HAS(casef)
     CHECK_HAS(diacf)
-    // one of substr/suffix/prefix must be set
-    if (!(has_substr || has_suffix || has_prefix)) {
-        CLIENT_ERR_PREFIXED("Must have a substring, suffix, or prefix index specification");
-        goto fail;
-    }
+
     return true;
 
 fail:
     return false;
 }
 
-#undef ERROR_PREFIX
+#undef ERROR_PREFIX