libmongocrypt-helper 1.7.4.0.1002 → 1.8.0.0.1001

data/ext/libmongocrypt/libmongocrypt/src/mc-fle2-find-equality-payload-private-v2.h

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2022-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.
+ */
+
+#ifndef MC_FLE2_FIND_EQUALITY_PAYLOAD_PRIVATE_V2_H
+#define MC_FLE2_FIND_EQUALITY_PAYLOAD_PRIVATE_V2_H
+
+#include "mongocrypt-buffer-private.h"
+#include "mongocrypt-private.h"
+#include "mongocrypt.h"
+
+typedef struct {
+    _mongocrypt_buffer_t edcDerivedToken;            // d
+    _mongocrypt_buffer_t escDerivedToken;            // s
+    _mongocrypt_buffer_t serverDerivedFromDataToken; // l
+    int64_t maxContentionCounter;                    // cm
+} mc_FLE2FindEqualityPayloadV2_t;
+
+void mc_FLE2FindEqualityPayloadV2_init(mc_FLE2FindEqualityPayloadV2_t *payload);
+
+bool mc_FLE2FindEqualityPayloadV2_parse(mc_FLE2FindEqualityPayloadV2_t *out,
+                                        const bson_t *in,
+                                        mongocrypt_status_t *status);
+
+bool mc_FLE2FindEqualityPayloadV2_serialize(const mc_FLE2FindEqualityPayloadV2_t *payload, bson_t *out);
+
+void mc_FLE2FindEqualityPayloadV2_cleanup(mc_FLE2FindEqualityPayloadV2_t *payload);
+
+#endif /* MC_FLE2_FIND_EQUALITY_PAYLOAD_PRIVATE_V2_H */

data/ext/libmongocrypt/libmongocrypt/src/mc-fle2-find-equality-payload-private.h

@@ -17,31 +17,24 @@
 #ifndef MC_FLE2_FIND_EQUALITY_PAYLOAD_PRIVATE_H
 #define MC_FLE2_FIND_EQUALITY_PAYLOAD_PRIVATE_H
 
-#include "mongocrypt.h"
-#include "mongocrypt-private.h"
 #include "mongocrypt-buffer-private.h"
+#include "mongocrypt-private.h"
+#include "mongocrypt.h"
 
 typedef struct {
-   _mongocrypt_buffer_t edcDerivedToken;       // d
-   _mongocrypt_buffer_t escDerivedToken;       // s
-   _mongocrypt_buffer_t eccDerivedToken;       // c
-   _mongocrypt_buffer_t serverEncryptionToken; // e
-   int64_t maxContentionCounter;               // cm
+    _mongocrypt_buffer_t edcDerivedToken;       // d
+    _mongocrypt_buffer_t escDerivedToken;       // s
+    _mongocrypt_buffer_t eccDerivedToken;       // c
+    _mongocrypt_buffer_t serverEncryptionToken; // e
+    int64_t maxContentionCounter;               // cm
 } mc_FLE2FindEqualityPayload_t;
 
-void
-mc_FLE2FindEqualityPayload_init (mc_FLE2FindEqualityPayload_t *payload);
+void mc_FLE2FindEqualityPayload_init(mc_FLE2FindEqualityPayload_t *payload);
 
-bool
-mc_FLE2FindEqualityPayload_parse (mc_FLE2FindEqualityPayload_t *out,
-                                  const bson_t *in,
-                                  mongocrypt_status_t *status);
+bool mc_FLE2FindEqualityPayload_parse(mc_FLE2FindEqualityPayload_t *out, const bson_t *in, mongocrypt_status_t *status);
 
-bool
-mc_FLE2FindEqualityPayload_serialize (
-   const mc_FLE2FindEqualityPayload_t *payload, bson_t *out);
+bool mc_FLE2FindEqualityPayload_serialize(const mc_FLE2FindEqualityPayload_t *payload, bson_t *out);
 
-void
-mc_FLE2FindEqualityPayload_cleanup (mc_FLE2FindEqualityPayload_t *payload);
+void mc_FLE2FindEqualityPayload_cleanup(mc_FLE2FindEqualityPayload_t *payload);
 
 #endif /* MC_FLE2_FIND_EQUALITY_PAYLOAD_PRIVATE_H */

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

@@ -0,0 +1,135 @@
+/*
+ * Copyright 2022-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 "mc-fle2-find-equality-payload-private-v2.h"
+#include "mongocrypt-buffer-private.h"
+#include "mongocrypt.h"
+
+void mc_FLE2FindEqualityPayloadV2_init(mc_FLE2FindEqualityPayloadV2_t *payload) {
+    memset(payload, 0, sizeof(mc_FLE2FindEqualityPayloadV2_t));
+}
+
+void mc_FLE2FindEqualityPayloadV2_cleanup(mc_FLE2FindEqualityPayloadV2_t *payload) {
+    BSON_ASSERT_PARAM(payload);
+
+    _mongocrypt_buffer_cleanup(&payload->edcDerivedToken);
+    _mongocrypt_buffer_cleanup(&payload->escDerivedToken);
+    _mongocrypt_buffer_cleanup(&payload->serverDerivedFromDataToken);
+}
+
+#define IF_FIELD(Name)                                                                                                 \
+    if (0 == strcmp(field, #Name)) {                                                                                   \
+        if (has_##Name) {                                                                                              \
+            CLIENT_ERR("Duplicate field '" #Name "' in payload bson");                                                 \
+            goto fail;                                                                                                 \
+        }                                                                                                              \
+        has_##Name = true;
+
+#define END_IF_FIELD                                                                                                   \
+    continue;                                                                                                          \
+    }
+
+#define PARSE_BINARY(Name, 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 != BSON_SUBTYPE_BINARY) {                                                                          \
+            CLIENT_ERR("Field '" #Name "' expected to be bindata subtype %d, got: %d", BSON_SUBTYPE_BINARY, 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 "'");                                                                        \
+            goto fail;                                                                                                 \
+        }                                                                                                              \
+    }                                                                                                                  \
+    END_IF_FIELD
+
+#define CHECK_HAS(Name)                                                                                                \
+    if (!has_##Name) {                                                                                                 \
+        CLIENT_ERR("Missing field '" #Name "' in payload");                                                            \
+        goto fail;                                                                                                     \
+    }
+
+bool mc_FLE2FindEqualityPayloadV2_parse(mc_FLE2FindEqualityPayloadV2_t *out,
+                                        const bson_t *in,
+                                        mongocrypt_status_t *status) {
+    bson_iter_t iter;
+    bool has_d = false, has_s = false, has_l = false, has_cm = false;
+
+    BSON_ASSERT_PARAM(out);
+    BSON_ASSERT_PARAM(in);
+
+    mc_FLE2FindEqualityPayloadV2_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);
+        BSON_ASSERT(field);
+
+        PARSE_BINARY(d, edcDerivedToken)
+        PARSE_BINARY(s, escDerivedToken)
+        PARSE_BINARY(l, serverDerivedFromDataToken)
+        IF_FIELD(cm) {
+            if (!BSON_ITER_HOLDS_INT64(&iter)) {
+                CLIENT_ERR("Field 'cm' expected to hold an int64");
+                goto fail;
+            }
+            out->maxContentionCounter = bson_iter_int64(&iter);
+        }
+        END_IF_FIELD
+    }
+
+    CHECK_HAS(d);
+    CHECK_HAS(s);
+    CHECK_HAS(l);
+    CHECK_HAS(cm);
+
+    return true;
+fail:
+    mc_FLE2FindEqualityPayloadV2_cleanup(out);
+    return false;
+}
+
+#define APPEND_BINDATA(name, value)                                                                                    \
+    if (!_mongocrypt_buffer_append(&(value), out, name, -1)) {                                                         \
+        return false;                                                                                                  \
+    }
+
+bool mc_FLE2FindEqualityPayloadV2_serialize(const mc_FLE2FindEqualityPayloadV2_t *payload, bson_t *out) {
+    BSON_ASSERT_PARAM(payload);
+
+    APPEND_BINDATA("d", payload->edcDerivedToken);
+    APPEND_BINDATA("s", payload->escDerivedToken);
+    APPEND_BINDATA("l", payload->serverDerivedFromDataToken);
+    if (!BSON_APPEND_INT64(out, "cm", payload->maxContentionCounter)) {
+        return false;
+    }
+    return true;
+}
+
+#undef APPEND_BINDATA

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

@@ -17,140 +17,123 @@
 #include <bson/bson.h>
 
 #include "mc-fle2-find-equality-payload-private.h"
-#include "mongocrypt.h"
 #include "mongocrypt-buffer-private.h"
+#include "mongocrypt.h"
 
-void
-mc_FLE2FindEqualityPayload_init (mc_FLE2FindEqualityPayload_t *payload)
-{
-   memset (payload, 0, sizeof (mc_FLE2FindEqualityPayload_t));
+void mc_FLE2FindEqualityPayload_init(mc_FLE2FindEqualityPayload_t *payload) {
+    memset(payload, 0, sizeof(mc_FLE2FindEqualityPayload_t));
 }
 
-void
-mc_FLE2FindEqualityPayload_cleanup (mc_FLE2FindEqualityPayload_t *payload)
-{
-   BSON_ASSERT_PARAM (payload);
+void mc_FLE2FindEqualityPayload_cleanup(mc_FLE2FindEqualityPayload_t *payload) {
+    BSON_ASSERT_PARAM(payload);
 
-   _mongocrypt_buffer_cleanup (&payload->edcDerivedToken);
-   _mongocrypt_buffer_cleanup (&payload->escDerivedToken);
-   _mongocrypt_buffer_cleanup (&payload->eccDerivedToken);
-   _mongocrypt_buffer_cleanup (&payload->serverEncryptionToken);
+    _mongocrypt_buffer_cleanup(&payload->edcDerivedToken);
+    _mongocrypt_buffer_cleanup(&payload->escDerivedToken);
+    _mongocrypt_buffer_cleanup(&payload->eccDerivedToken);
+    _mongocrypt_buffer_cleanup(&payload->serverEncryptionToken);
 }
 
-#define IF_FIELD(Name)                                               \
-   if (0 == strcmp (field, #Name)) {                                 \
-      if (has_##Name) {                                              \
-         CLIENT_ERR ("Duplicate field '" #Name "' in payload bson"); \
-         goto fail;                                                  \
-      }                                                              \
-      has_##Name = true;
-
-#define END_IF_FIELD \
-   continue;         \
-   }
-
-#define PARSE_BINARY(Name, 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 != BSON_SUBTYPE_BINARY) {                                \
-         CLIENT_ERR ("Field '" #Name                                       \
-                     "' expected to be bindata subtype %d, got: %d",       \
-                     BSON_SUBTYPE_BINARY,                                  \
-                     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 "'");                              \
-         goto fail;                                                        \
-      }                                                                    \
-   }                                                                       \
-   END_IF_FIELD
-
-#define CHECK_HAS(Name)                                    \
-   if (!has_##Name) {                                      \
-      CLIENT_ERR ("Missing field '" #Name "' in payload"); \
-      goto fail;                                           \
-   }
-
-bool
-mc_FLE2FindEqualityPayload_parse (mc_FLE2FindEqualityPayload_t *out,
-                                  const bson_t *in,
-                                  mongocrypt_status_t *status)
-{
-   bson_iter_t iter;
-   bool has_d = false, has_s = false, has_c = false, has_e = false,
-        has_cm = false;
-
-   BSON_ASSERT_PARAM (out);
-   BSON_ASSERT_PARAM (in);
-
-   mc_FLE2FindEqualityPayload_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);
-      BSON_ASSERT (field);
-
-      PARSE_BINARY (d, edcDerivedToken)
-      PARSE_BINARY (s, escDerivedToken)
-      PARSE_BINARY (c, eccDerivedToken)
-      PARSE_BINARY (e, serverEncryptionToken)
-      IF_FIELD (cm)
-      {
-         if (!BSON_ITER_HOLDS_INT64 (&iter)) {
-            CLIENT_ERR ("Field 'cm' expected to hold an int64");
-            goto fail;
-         }
-         out->maxContentionCounter = bson_iter_int64 (&iter);
-      }
-      END_IF_FIELD
-   }
-
-   CHECK_HAS (d);
-   CHECK_HAS (s);
-   CHECK_HAS (c);
-   CHECK_HAS (e);
-   CHECK_HAS (cm);
-
-   return true;
+#define IF_FIELD(Name)                                                                                                 \
+    if (0 == strcmp(field, #Name)) {                                                                                   \
+        if (has_##Name) {                                                                                              \
+            CLIENT_ERR("Duplicate field '" #Name "' in payload bson");                                                 \
+            goto fail;                                                                                                 \
+        }                                                                                                              \
+        has_##Name = true;
+
+#define END_IF_FIELD                                                                                                   \
+    continue;                                                                                                          \
+    }
+
+#define PARSE_BINARY(Name, 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 != BSON_SUBTYPE_BINARY) {                                                                          \
+            CLIENT_ERR("Field '" #Name "' expected to be bindata subtype %d, got: %d", BSON_SUBTYPE_BINARY, 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 "'");                                                                        \
+            goto fail;                                                                                                 \
+        }                                                                                                              \
+    }                                                                                                                  \
+    END_IF_FIELD
+
+#define CHECK_HAS(Name)                                                                                                \
+    if (!has_##Name) {                                                                                                 \
+        CLIENT_ERR("Missing field '" #Name "' in payload");                                                            \
+        goto fail;                                                                                                     \
+    }
+
+bool mc_FLE2FindEqualityPayload_parse(mc_FLE2FindEqualityPayload_t *out,
+                                      const bson_t *in,
+                                      mongocrypt_status_t *status) {
+    bson_iter_t iter;
+    bool has_d = false, has_s = false, has_c = false, has_e = false, has_cm = false;
+
+    BSON_ASSERT_PARAM(out);
+    BSON_ASSERT_PARAM(in);
+
+    mc_FLE2FindEqualityPayload_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);
+        BSON_ASSERT(field);
+
+        PARSE_BINARY(d, edcDerivedToken)
+        PARSE_BINARY(s, escDerivedToken)
+        PARSE_BINARY(c, eccDerivedToken)
+        PARSE_BINARY(e, serverEncryptionToken)
+        IF_FIELD(cm) {
+            if (!BSON_ITER_HOLDS_INT64(&iter)) {
+                CLIENT_ERR("Field 'cm' expected to hold an int64");
+                goto fail;
+            }
+            out->maxContentionCounter = bson_iter_int64(&iter);
+        }
+        END_IF_FIELD
+    }
+
+    CHECK_HAS(d);
+    CHECK_HAS(s);
+    CHECK_HAS(c);
+    CHECK_HAS(e);
+    CHECK_HAS(cm);
+
+    return true;
 fail:
-   mc_FLE2FindEqualityPayload_cleanup (out);
-   return false;
+    mc_FLE2FindEqualityPayload_cleanup(out);
+    return false;
 }
 
-#define IUPS_APPEND_BINDATA(name, subtype, value)              \
-   if (!_mongocrypt_buffer_append (&(value), out, name, -1)) { \
-      return false;                                            \
-   }
-
-bool
-mc_FLE2FindEqualityPayload_serialize (
-   const mc_FLE2FindEqualityPayload_t *payload, bson_t *out)
-{
-   BSON_ASSERT_PARAM (payload);
-
-   IUPS_APPEND_BINDATA ("d", BSON_SUBTYPE_BINARY, payload->edcDerivedToken);
-   IUPS_APPEND_BINDATA ("s", BSON_SUBTYPE_BINARY, payload->escDerivedToken);
-   IUPS_APPEND_BINDATA ("c", BSON_SUBTYPE_BINARY, payload->eccDerivedToken);
-   IUPS_APPEND_BINDATA (
-      "e", BSON_SUBTYPE_BINARY, payload->serverEncryptionToken);
-   if (!BSON_APPEND_INT64 (out, "cm", payload->maxContentionCounter)) {
-      return false;
-   }
-   return true;
+#define PAYLOAD_APPEND_BINDATA(name, value)                                                                            \
+    if (!_mongocrypt_buffer_append(&(value), out, name, -1)) {                                                         \
+        return false;                                                                                                  \
+    }
+
+bool mc_FLE2FindEqualityPayload_serialize(const mc_FLE2FindEqualityPayload_t *payload, bson_t *out) {
+    BSON_ASSERT_PARAM(payload);
+
+    PAYLOAD_APPEND_BINDATA("d", payload->edcDerivedToken);
+    PAYLOAD_APPEND_BINDATA("s", payload->escDerivedToken);
+    PAYLOAD_APPEND_BINDATA("c", payload->eccDerivedToken);
+    PAYLOAD_APPEND_BINDATA("e", payload->serverEncryptionToken);
+    if (!BSON_APPEND_INT64(out, "cm", payload->maxContentionCounter)) {
+        return false;
+    }
+    return true;
 }
-#undef IUPS_APPEND_BINDATA
+
+#undef PAYLOAD_APPEND_BINDATA

data/ext/libmongocrypt/libmongocrypt/src/mc-fle2-find-range-payload-private-v2.h

@@ -0,0 +1,88 @@
+/*
+ * Copyright 2022-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.
+ */
+
+#ifndef MC_FLE2_FIND_RANGE_PAYLOAD_PRIVATE_V2_H
+#define MC_FLE2_FIND_RANGE_PAYLOAD_PRIVATE_V2_H
+
+#include "mongocrypt-buffer-private.h"
+#include "mongocrypt-private.h"
+#include "mongocrypt.h"
+
+#include "mc-array-private.h"
+#include "mc-fle2-range-operator-private.h"
+
+/** FLE2FindRangePayloadEdgesInfoV2 represents the token information for a range
+ * find query. It is encoded inside an FLE2FindRangePayloadV2.
+ */
+typedef struct {
+    mc_array_t edgeFindTokenSetArray; // g
+    int64_t maxContentionCounter;     // cm
+} mc_FLE2FindRangePayloadEdgesInfoV2_t;
+
+/**
+ * FLE2FindRangePayloadV2 represents an FLE2 payload of a range indexed field to
+ * query. It is created client side.
+ *
+ * FLE2FindRangePayloadV2 has the following data layout:
+ *
+ * struct {
+ *   uint8_t fle_blob_subtype = 13;
+ *   uint8_t bson[];
+ * } FLE2FindRangePayloadV2;
+ *
+ * bson is a BSON document of this form:
+ * g: array<EdgeFindTokenSetV2> // Array of Edges
+ * cm: <int64> // Queryable Encryption max counter
+ */
+typedef struct {
+    struct {
+        mc_FLE2FindRangePayloadEdgesInfoV2_t value;
+        bool set;
+    } payload;
+
+    // payloadId Id of payload - must be paired with another payload.
+    int32_t payloadId;
+    // firstOperator represents the first query operator for which this payload
+    // was generated.
+    mc_FLE2RangeOperator_t firstOperator;
+    // secondOperator represents the second query operator for which this payload
+    // was generated. Only populated for two-sided ranges. It is 0 if unset.
+    mc_FLE2RangeOperator_t secondOperator;
+} mc_FLE2FindRangePayloadV2_t;
+
+/**
+ * EdgeFindTokenSetV2 is the following BSON document:
+ * d: <binary> // EDCDerivedFromDataTokenAndCounter
+ * s: <binary> // ESCDerivedFromDataTokenAndCounter
+ * l: <binary> // ServerDerivedFromDataToken
+ *
+ * Instances of mc_EdgeFindTokenSetV2_t are expected to be owned by
+ * mc_FLE2FindRangePayloadV2_t and are freed in
+ * mc_FLE2FindRangePayloadV2_cleanup.
+ */
+typedef struct {
+    _mongocrypt_buffer_t edcDerivedToken;            // d
+    _mongocrypt_buffer_t escDerivedToken;            // s
+    _mongocrypt_buffer_t serverDerivedFromDataToken; // l
+} mc_EdgeFindTokenSetV2_t;
+
+void mc_FLE2FindRangePayloadV2_init(mc_FLE2FindRangePayloadV2_t *payload);
+
+bool mc_FLE2FindRangePayloadV2_serialize(const mc_FLE2FindRangePayloadV2_t *payload, bson_t *out);
+
+void mc_FLE2FindRangePayloadV2_cleanup(mc_FLE2FindRangePayloadV2_t *payload);
+
+#endif /* MC_FLE2_FIND_RANGE_PAYLOAD_PRIVATE_V2_H */

data/ext/libmongocrypt/libmongocrypt/src/mc-fle2-find-range-payload-private.h

@@ -17,9 +17,9 @@
 #ifndef MC_FLE2_FIND_RANGE_PAYLOAD_PRIVATE_H
 #define MC_FLE2_FIND_RANGE_PAYLOAD_PRIVATE_H
 
-#include "mongocrypt.h"
-#include "mongocrypt-private.h"
 #include "mongocrypt-buffer-private.h"
+#include "mongocrypt-private.h"
+#include "mongocrypt.h"
 
 #include "mc-array-private.h"
 #include "mc-fle2-range-operator-private.h"
@@ -30,9 +30,9 @@
  * for the representation in the MongoDB server.
  */
 typedef struct {
-   mc_array_t edgeFindTokenSetArray;           // g
-   _mongocrypt_buffer_t serverEncryptionToken; // e
-   int64_t maxContentionCounter;               // cm
+    mc_array_t edgeFindTokenSetArray;           // g
+    _mongocrypt_buffer_t serverEncryptionToken; // e
+    int64_t maxContentionCounter;               // cm
 } mc_FLE2FindRangePayloadEdgesInfo_t;
 
 /**
@@ -52,18 +52,19 @@ typedef struct {
  * cm: <int64> // Queryable Encryption max counter
  */
 typedef struct {
-   struct {
-      mc_FLE2FindRangePayloadEdgesInfo_t value;
-      bool set;
-   } payload;
-   // payloadId Id of payload - must be paired with another payload.
-   int32_t payloadId;
-   // firstOperator represents the first query operator for which this payload
-   // was generated.
-   mc_FLE2RangeOperator_t firstOperator;
-   // secondOperator represents the second query operator for which this payload
-   // was generated. Only populated for two-sided ranges. It is 0 if unset.
-   mc_FLE2RangeOperator_t secondOperator;
+    struct {
+        mc_FLE2FindRangePayloadEdgesInfo_t value;
+        bool set;
+    } payload;
+
+    // payloadId Id of payload - must be paired with another payload.
+    int32_t payloadId;
+    // firstOperator represents the first query operator for which this payload
+    // was generated.
+    mc_FLE2RangeOperator_t firstOperator;
+    // secondOperator represents the second query operator for which this payload
+    // was generated. Only populated for two-sided ranges. It is 0 if unset.
+    mc_FLE2RangeOperator_t secondOperator;
 } mc_FLE2FindRangePayload_t;
 
 /**
@@ -77,19 +78,15 @@ typedef struct {
  * mc_FLE2FindRangePayload_cleanup.
  */
 typedef struct {
-   _mongocrypt_buffer_t edcDerivedToken; // d
-   _mongocrypt_buffer_t escDerivedToken; // s
-   _mongocrypt_buffer_t eccDerivedToken; // c
+    _mongocrypt_buffer_t edcDerivedToken; // d
+    _mongocrypt_buffer_t escDerivedToken; // s
+    _mongocrypt_buffer_t eccDerivedToken; // c
 } mc_EdgeFindTokenSet_t;
 
-void
-mc_FLE2FindRangePayload_init (mc_FLE2FindRangePayload_t *payload);
+void mc_FLE2FindRangePayload_init(mc_FLE2FindRangePayload_t *payload);
 
-bool
-mc_FLE2FindRangePayload_serialize (const mc_FLE2FindRangePayload_t *payload,
-                                   bson_t *out);
+bool mc_FLE2FindRangePayload_serialize(const mc_FLE2FindRangePayload_t *payload, bson_t *out);
 
-void
-mc_FLE2FindRangePayload_cleanup (mc_FLE2FindRangePayload_t *payload);
+void mc_FLE2FindRangePayload_cleanup(mc_FLE2FindRangePayload_t *payload);
 
 #endif /* MC_FLE2_FIND_RANGE_PAYLOAD_PRIVATE_H */