libmongocrypt-helper 1.7.4.0.1002 → 1.11.0.0.1001

data/ext/libmongocrypt/libmongocrypt/src/mongocrypt-private.h

@@ -17,181 +17,158 @@
 #ifndef MONGOCRYPT_PRIVATE_H
 #define MONGOCRYPT_PRIVATE_H
 
-#include "mongocrypt.h"
-#include "mongocrypt-config.h"
 #include "bson/bson.h"
+#include "mongocrypt-config.h"
+#include "mongocrypt.h"
 
-#include "mongocrypt-dll-private.h"
-#include "mongocrypt-log-private.h"
 #include "mongocrypt-buffer-private.h"
-#include "mongocrypt-cache-private.h"
 #include "mongocrypt-cache-key-private.h"
+#include "mongocrypt-cache-oauth-private.h"
+#include "mongocrypt-cache-private.h"
+#include "mongocrypt-crypto-private.h"
+#include "mongocrypt-dll-private.h"
+#include "mongocrypt-log-private.h"
 #include "mongocrypt-mutex-private.h"
 #include "mongocrypt-opts-private.h"
-#include "mongocrypt-crypto-private.h"
-#include "mongocrypt-cache-oauth-private.h"
 
 #include "mongo_crypt-v1.h"
 
 #include <mlib/macros.h>
 
-
 #define MONGOCRYPT_GENERIC_ERROR_CODE 1
 
-#define CLIENT_ERR_W_CODE(code, ...) \
-   _mongocrypt_set_error (           \
-      status, MONGOCRYPT_STATUS_ERROR_CLIENT, code, __VA_ARGS__)
-
-#define CLIENT_ERR(...) \
-   CLIENT_ERR_W_CODE (MONGOCRYPT_GENERIC_ERROR_CODE, __VA_ARGS__)
+#define CLIENT_ERR_W_CODE(code, ...) _mongocrypt_set_error(status, MONGOCRYPT_STATUS_ERROR_CLIENT, code, __VA_ARGS__)
 
-#define KMS_ERR_W_CODE(code, ...) \
-   _mongocrypt_set_error (        \
-      status, MONGOCRYPT_STATUS_ERROR_KMS, code, __VA_ARGS__)
+#define CLIENT_ERR(fmt, ...) CLIENT_ERR_W_CODE(MONGOCRYPT_GENERIC_ERROR_CODE, fmt, ##__VA_ARGS__)
 
-#define KMS_ERR(...) KMS_ERR_W_CODE (MONGOCRYPT_GENERIC_ERROR_CODE, __VA_ARGS__)
+#define KMS_ERR_W_CODE(code, ...) _mongocrypt_set_error(status, MONGOCRYPT_STATUS_ERROR_KMS, code, __VA_ARGS__)
 
-#define MONGOCRYPT_STR_AND_LEN(x) (x), (sizeof (x) / sizeof ((x)[0]) - 1)
+#define KMS_ERR(...) KMS_ERR_W_CODE(MONGOCRYPT_GENERIC_ERROR_CODE, __VA_ARGS__)
 
-#define MONGOCRYPT_DATA_AND_LEN(x) \
-   ((uint8_t *) x), (sizeof (x) / sizeof ((x)[0]) - 1)
+#define MONGOCRYPT_STR_AND_LEN(x) (x), (sizeof(x) / sizeof((x)[0]) - 1)
 
-/* TODO: remove after integrating into libmongoc */
-#define BSON_SUBTYPE_ENCRYPTED 6
+#define MONGOCRYPT_DATA_AND_LEN(x) ((uint8_t *)x), (sizeof(x) / sizeof((x)[0]) - 1)
 
 /* TODO: Move these to mongocrypt-log-private.h? */
-const char *
-tmp_json (const bson_t *bson);
+const char *tmp_json(const bson_t *bson);
 
-const char *
-tmp_buf (const _mongocrypt_buffer_t *buf);
+const char *tmp_buf(const _mongocrypt_buffer_t *buf);
 
 // _mongocrypt_set_error sets an error status.
 // `status->message` is set after evaluating `format` and variadic args.
-// It is safe to uses a `status->message` as an argument to wrap an error. For example:
-// _mongocrypt_set_error (
+// It is safe to uses a `status->message` as an argument to wrap an error. For
+// example: _mongocrypt_set_error (
 //    status,
 //    MONGOCRYPT_STATUS_ERROR_CLIENT,
 //    MONGOCRYPT_GENERIC_ERROR_CODE,
 //    "Error occurred. Original error: %s",
 //    mongocrypt_status_message (status, NULL /* len */));
-MLIB_ANNOTATE_PRINTF (4, 5)
-void
-_mongocrypt_set_error (mongocrypt_status_t *status,
-                       mongocrypt_status_type_t type,
-                       uint32_t code,
-                       const char *format,
-                       ...);
+MLIB_ANNOTATE_PRINTF(4, 5)
+void _mongocrypt_set_error(mongocrypt_status_t *status,
+                           mongocrypt_status_type_t type,
+                           uint32_t code,
+                           const char *format,
+                           ...);
 
 typedef struct _mongo_crypt_v1_vtable {
-#define MONGOC_CSFLE_FUNCTIONS_X                                             \
-   /* status methods */                                                      \
-   X_FUNC (status_create, mongo_crypt_v1_status *, void)                     \
-   X_FUNC (status_destroy, void, mongo_crypt_v1_status *status)              \
-   X_FUNC (status_get_error, int, const mongo_crypt_v1_status *status)       \
-   X_FUNC (status_get_explanation,                                           \
-           const char *,                                                     \
-           const mongo_crypt_v1_status *status)                              \
-   X_FUNC (status_get_code, int, const mongo_crypt_v1_status *status)        \
-   /* lib methods */                                                         \
-   X_FUNC (lib_create, mongo_crypt_v1_lib *, mongo_crypt_v1_status *status)  \
-   X_FUNC (lib_destroy,                                                      \
-           int,                                                              \
-           mongo_crypt_v1_lib *lib,                                          \
-           mongo_crypt_v1_status *status)                                    \
-   /* query_analyzer methods */                                              \
-   X_FUNC (query_analyzer_create,                                            \
-           mongo_crypt_v1_query_analyzer *,                                  \
-           mongo_crypt_v1_lib *lib,                                          \
-           mongo_crypt_v1_status *status)                                    \
-   X_FUNC (                                                                  \
-      query_analyzer_destroy, void, mongo_crypt_v1_query_analyzer *analyzer) \
-   X_FUNC (analyze_query,                                                    \
-           uint8_t *,                                                        \
-           mongo_crypt_v1_query_analyzer *analyer,                           \
-           const uint8_t *documentBSON,                                      \
-           const char *ns_str,                                               \
-           uint32_t ns_len,                                                  \
-           uint32_t *bson_len,                                               \
-           mongo_crypt_v1_status *status)                                    \
-   X_FUNC (get_version, uint64_t, void)                                      \
-   X_FUNC (get_version_str, const char *, void)                              \
-   /* Free bson data created by csfle */                                     \
-   X_FUNC (bson_free, void, uint8_t *bson)
-
-#define X_FUNC(Name, RetType, ...) RetType (*Name) (__VA_ARGS__);
-   MONGOC_CSFLE_FUNCTIONS_X
+#define MONGOC_CSFLE_FUNCTIONS_X                                                                                       \
+    /* status methods */                                                                                               \
+    X_FUNC(status_create, mongo_crypt_v1_status *, void)                                                               \
+    X_FUNC(status_destroy, void, mongo_crypt_v1_status *status)                                                        \
+    X_FUNC(status_get_error, int, const mongo_crypt_v1_status *status)                                                 \
+    X_FUNC(status_get_explanation, const char *, const mongo_crypt_v1_status *status)                                  \
+    X_FUNC(status_get_code, int, const mongo_crypt_v1_status *status)                                                  \
+    /* lib methods */                                                                                                  \
+    X_FUNC(lib_create, mongo_crypt_v1_lib *, mongo_crypt_v1_status *status)                                            \
+    X_FUNC(lib_destroy, int, mongo_crypt_v1_lib *lib, mongo_crypt_v1_status *status)                                   \
+    /* query_analyzer methods */                                                                                       \
+    X_FUNC(query_analyzer_create,                                                                                      \
+           mongo_crypt_v1_query_analyzer *,                                                                            \
+           mongo_crypt_v1_lib *lib,                                                                                    \
+           mongo_crypt_v1_status *status)                                                                              \
+    X_FUNC(query_analyzer_destroy, void, mongo_crypt_v1_query_analyzer *analyzer)                                      \
+    X_FUNC(analyze_query,                                                                                              \
+           uint8_t *,                                                                                                  \
+           mongo_crypt_v1_query_analyzer *analyer,                                                                     \
+           const uint8_t *documentBSON,                                                                                \
+           const char *ns_str,                                                                                         \
+           uint32_t ns_len,                                                                                            \
+           uint32_t *bson_len,                                                                                         \
+           mongo_crypt_v1_status *status)                                                                              \
+    X_FUNC(get_version, uint64_t, void)                                                                                \
+    X_FUNC(get_version_str, const char *, void)                                                                        \
+    /* Free bson data created by csfle */                                                                              \
+    X_FUNC(bson_free, void, uint8_t *bson)
+
+#define X_FUNC(Name, RetType, ...) RetType (*Name)(__VA_ARGS__);
+    MONGOC_CSFLE_FUNCTIONS_X
 #undef X_FUNC
 
-   /// Whether the vtable is valid and complete
-   bool okay;
+    /// Whether the vtable is valid and complete
+    bool okay;
 } _mongo_crypt_v1_vtable;
 
 struct _mongocrypt_t {
-   bool initialized;
-   _mongocrypt_opts_t opts;
-   mongocrypt_mutex_t mutex;
-   /* The collinfo and key cache are protected with an internal mutex. */
-   _mongocrypt_cache_t cache_collinfo;
-   _mongocrypt_cache_t cache_key;
-   _mongocrypt_log_t log;
-   mongocrypt_status_t *status;
-   _mongocrypt_crypto_t *crypto;
-   /* A counter, protected by mutex, for generating unique context ids */
-   uint32_t ctx_counter;
-   _mongocrypt_cache_oauth_t *cache_oauth_azure;
-   _mongocrypt_cache_oauth_t *cache_oauth_gcp;
-   /// A CSFLE DLL vtable, initialized by mongocrypt_init
-   _mongo_crypt_v1_vtable csfle;
-   /// Pointer to the global csfle_lib object. Should not be freed directly.
-   mongo_crypt_v1_lib *csfle_lib;
+    bool initialized;
+    _mongocrypt_opts_t opts;
+    mongocrypt_mutex_t mutex;
+    /* The collinfo and key cache are protected with an internal mutex. */
+    _mongocrypt_cache_t cache_collinfo;
+    _mongocrypt_cache_t cache_key;
+    _mongocrypt_log_t log;
+    mongocrypt_status_t *status;
+    _mongocrypt_crypto_t *crypto;
+    /* A counter, protected by mutex, for generating unique context ids */
+    uint32_t ctx_counter;
+    mc_mapof_kmsid_to_token_t *cache_oauth;
+    /// A CSFLE DLL vtable, initialized by mongocrypt_init
+    _mongo_crypt_v1_vtable csfle;
+    /// Pointer to the global csfle_lib object. Should not be freed directly.
+    mongo_crypt_v1_lib *csfle_lib;
 };
 
 typedef enum {
-   MONGOCRYPT_ENCRYPTION_ALGORITHM_NONE = 0,
-   MONGOCRYPT_ENCRYPTION_ALGORITHM_DETERMINISTIC = 1,
-   MONGOCRYPT_ENCRYPTION_ALGORITHM_RANDOM = 2
+    MONGOCRYPT_ENCRYPTION_ALGORITHM_NONE = 0,
+    MONGOCRYPT_ENCRYPTION_ALGORITHM_DETERMINISTIC = 1,
+    MONGOCRYPT_ENCRYPTION_ALGORITHM_RANDOM = 2
 } mongocrypt_encryption_algorithm_t;
 
 typedef enum {
-   MONGOCRYPT_FLE2_PLACEHOLDER_TYPE_INSERT = 1,
-   MONGOCRYPT_FLE2_PLACEHOLDER_TYPE_FIND = 2
+    MONGOCRYPT_FLE2_PLACEHOLDER_TYPE_INSERT = 1,
+    MONGOCRYPT_FLE2_PLACEHOLDER_TYPE_FIND = 2
 } mongocrypt_fle2_placeholder_type_t;
 
 typedef enum {
-   MONGOCRYPT_FLE2_ALGORITHM_UNINDEXED = 1,
-   MONGOCRYPT_FLE2_ALGORITHM_EQUALITY = 2,
-   MONGOCRYPT_FLE2_ALGORITHM_RANGE = 3
+    MONGOCRYPT_FLE2_ALGORITHM_UNINDEXED = 1,
+    MONGOCRYPT_FLE2_ALGORITHM_EQUALITY = 2,
+    MONGOCRYPT_FLE2_ALGORITHM_RANGE = 3
 } mongocrypt_fle2_encryption_algorithm_t;
 
-bool
-_mongocrypt_validate_and_copy_string (const char *in,
-                                      int32_t in_len,
-                                      char **out) MONGOCRYPT_WARN_UNUSED_RESULT;
-
-char *
-_mongocrypt_new_string_from_bytes (const void *in, int len);
+bool _mongocrypt_validate_and_copy_string(const char *in, int32_t in_len, char **out) MONGOCRYPT_WARN_UNUSED_RESULT;
 
-char *
-_mongocrypt_new_json_string_from_binary (mongocrypt_binary_t *binary);
+char *_mongocrypt_new_string_from_bytes(const void *in, int len);
 
-
-bool
-_mongocrypt_parse_kms_providers (
-   mongocrypt_binary_t *kms_providers_definition,
-   _mongocrypt_opts_kms_providers_t *kms_providers,
-   mongocrypt_status_t *status,
-   _mongocrypt_log_t *log);
+char *_mongocrypt_new_json_string_from_binary(mongocrypt_binary_t *binary);
 
 /* _mongocrypt_needs_credentials returns true if @crypt was configured to
  * request credentials for any KMS provider. */
-bool
-_mongocrypt_needs_credentials (mongocrypt_t *crypt);
+bool _mongocrypt_needs_credentials(mongocrypt_t *crypt);
 
 /* _mongocrypt_needs_credentials returns true if @crypt was configured to
- * request credentials for @provider. */
-bool
-_mongocrypt_needs_credentials_for_provider (
-   mongocrypt_t *crypt, _mongocrypt_kms_provider_t provider);
+ * request credentials for @provider and optional @name. @name may be NULL. */
+bool _mongocrypt_needs_credentials_for_provider(mongocrypt_t *crypt,
+                                                _mongocrypt_kms_provider_t provider,
+                                                const char *name);
+
+/**
+ * Enable/disable the use of FLE2v2 payload types for write.
+ *
+ * @param[in] crypt The @ref mongocrypt_t object.
+ * @param[in] enable Whether to enable use of FLE2v2 payloads.
+ *
+ * @returns A boolean indicating success. If false, an error status is set.
+ * Retrieve it with @ref mongocrypt_status
+ */
+bool mongocrypt_setopt_fle2v2(mongocrypt_t *crypt, bool enable);
 
 #endif /* MONGOCRYPT_PRIVATE_H */

data/ext/libmongocrypt/libmongocrypt/src/mongocrypt-status-private.h

@@ -19,12 +19,9 @@
 
 #include "mongocrypt.h"
 
-void
-_mongocrypt_status_copy_to (mongocrypt_status_t *src, mongocrypt_status_t *dst);
+void _mongocrypt_status_copy_to(mongocrypt_status_t *src, mongocrypt_status_t *dst);
 
-
-void
-_mongocrypt_status_reset (mongocrypt_status_t *status);
+void _mongocrypt_status_reset(mongocrypt_status_t *status);
 
 /* Append the message of @to_append in @status.
  * Example:
@@ -32,8 +29,6 @@ _mongocrypt_status_reset (mongocrypt_status_t *status);
  * - @to_append has the message "append error"
  * After calling, @status will have the message: "status error: append error"
  */
-void
-_mongocrypt_status_append (mongocrypt_status_t *status,
-                           mongocrypt_status_t *to_append);
+void _mongocrypt_status_append(mongocrypt_status_t *status, mongocrypt_status_t *to_append);
 
 #endif /* MONGOCRYPT_STATUS_PRIVATE_H */

data/ext/libmongocrypt/libmongocrypt/src/mongocrypt-status.c

@@ -18,152 +18,125 @@
 
 #include "mongocrypt-status-private.h"
 
-
 struct _mongocrypt_status_t {
-   mongocrypt_status_type_t type;
-   uint32_t code;
-   char *message;
-   uint32_t len;
+    mongocrypt_status_type_t type;
+    uint32_t code;
+    char *message;
+    uint32_t len;
 };
 
-mongocrypt_status_t *
-mongocrypt_status_new (void)
-{
-   return bson_malloc0 (sizeof (mongocrypt_status_t));
+mongocrypt_status_t *mongocrypt_status_new(void) {
+    return bson_malloc0(sizeof(mongocrypt_status_t));
 }
 
-
-void
-mongocrypt_status_set (mongocrypt_status_t *status,
-                       mongocrypt_status_type_t type,
-                       uint32_t code,
-                       const char *message,
-                       int32_t message_len)
-{
-   if (!status) {
-      return;
-   }
-
-   if (message_len < 0) {
-      message_len = (int32_t) strlen (message) + 1;
-   } else if (message_len == 0) {
-      /* This is really an error, since message_len should be one more than the
-       * string length. But interpret as the empty string */
-      message_len = 1;
-   }
-
-   bson_free (status->message);
-   status->message = bson_malloc ((size_t) message_len);
-   BSON_ASSERT (status->message);
-   status->message[message_len - 1] = '\0';
-   memcpy (status->message, message, (size_t) message_len - 1);
-   status->len = (uint32_t) message_len - 1;
-   status->type = type;
-   status->code = code;
+void mongocrypt_status_set(mongocrypt_status_t *status,
+                           mongocrypt_status_type_t type,
+                           uint32_t code,
+                           const char *message,
+                           int32_t message_len) {
+    if (!status) {
+        return;
+    }
+
+    if (message_len < 0) {
+        message_len = (int32_t)strlen(message) + 1;
+    } else if (message_len == 0) {
+        /* This is really an error, since message_len should be one more than the
+         * string length. But interpret as the empty string */
+        message_len = 1;
+    }
+
+    bson_free(status->message);
+    status->message = bson_malloc((size_t)message_len);
+    BSON_ASSERT(status->message);
+    status->message[message_len - 1] = '\0';
+    memcpy(status->message, message, (size_t)message_len - 1);
+    status->len = (uint32_t)message_len - 1;
+    status->type = type;
+    status->code = code;
 }
 
-const char *
-mongocrypt_status_message (mongocrypt_status_t *status, uint32_t *len)
-{
-   BSON_ASSERT_PARAM (status);
-
-   if (mongocrypt_status_ok (status)) {
-      return NULL;
-   }
-   if (len) {
-      *len = status->len;
-   }
-   return status->message;
-}
+const char *mongocrypt_status_message(mongocrypt_status_t *status, uint32_t *len) {
+    BSON_ASSERT_PARAM(status);
 
+    if (mongocrypt_status_ok(status)) {
+        return NULL;
+    }
+    if (len) {
+        *len = status->len;
+    }
+    return status->message;
+}
 
-uint32_t
-mongocrypt_status_code (mongocrypt_status_t *status)
-{
-   BSON_ASSERT_PARAM (status);
+uint32_t mongocrypt_status_code(mongocrypt_status_t *status) {
+    BSON_ASSERT_PARAM(status);
 
-   return status->code;
+    return status->code;
 }
 
+mongocrypt_status_type_t mongocrypt_status_type(mongocrypt_status_t *status) {
+    BSON_ASSERT_PARAM(status);
 
-mongocrypt_status_type_t
-mongocrypt_status_type (mongocrypt_status_t *status)
-{
-   BSON_ASSERT_PARAM (status);
-
-   return status->type;
+    return status->type;
 }
 
+bool mongocrypt_status_ok(mongocrypt_status_t *status) {
+    BSON_ASSERT_PARAM(status);
 
-bool
-mongocrypt_status_ok (mongocrypt_status_t *status)
-{
-   BSON_ASSERT_PARAM (status);
-
-   return (status->type == MONGOCRYPT_STATUS_OK);
+    return (status->type == MONGOCRYPT_STATUS_OK);
 }
 
-void
-_mongocrypt_status_copy_to (mongocrypt_status_t *src, mongocrypt_status_t *dst)
-{
-   BSON_ASSERT_PARAM (dst);
-   BSON_ASSERT_PARAM (src);
-
-   if (dst == src) {
-      return;
-   }
-
-   dst->type = src->type;
-   dst->code = src->code;
-   dst->len = src->len;
-   if (dst->message) {
-      bson_free (dst->message);
-      dst->message = NULL;
-   }
-
-   if (src->message) {
-      dst->message = bson_strdup (src->message);
-   }
+void _mongocrypt_status_copy_to(mongocrypt_status_t *src, mongocrypt_status_t *dst) {
+    BSON_ASSERT_PARAM(dst);
+    BSON_ASSERT_PARAM(src);
+
+    if (dst == src) {
+        return;
+    }
+
+    dst->type = src->type;
+    dst->code = src->code;
+    dst->len = src->len;
+    if (dst->message) {
+        bson_free(dst->message);
+        dst->message = NULL;
+    }
+
+    if (src->message) {
+        dst->message = bson_strdup(src->message);
+    }
 }
 
-void
-_mongocrypt_status_reset (mongocrypt_status_t *status)
-{
-   BSON_ASSERT_PARAM (status);
+void _mongocrypt_status_reset(mongocrypt_status_t *status) {
+    BSON_ASSERT_PARAM(status);
 
-   status->type = MONGOCRYPT_STATUS_OK;
-   status->code = 0;
-   status->len = 0;
-   bson_free (status->message);
-   status->message = NULL;
+    status->type = MONGOCRYPT_STATUS_OK;
+    status->code = 0;
+    status->len = 0;
+    bson_free(status->message);
+    status->message = NULL;
 }
 
-void
-mongocrypt_status_destroy (mongocrypt_status_t *status)
-{
-   if (!status) {
-      return;
-   }
+void mongocrypt_status_destroy(mongocrypt_status_t *status) {
+    if (!status) {
+        return;
+    }
 
-   bson_free (status->message);
-   bson_free (status);
+    bson_free(status->message);
+    bson_free(status);
 }
 
+void _mongocrypt_status_append(mongocrypt_status_t *status, mongocrypt_status_t *to_append) {
+    char *orig;
 
-void
-_mongocrypt_status_append (mongocrypt_status_t *status,
-                           mongocrypt_status_t *to_append)
-{
-   char *orig;
-
-   BSON_ASSERT_PARAM (status);
-   BSON_ASSERT_PARAM (to_append);
+    BSON_ASSERT_PARAM(status);
+    BSON_ASSERT_PARAM(to_append);
 
-   orig = status->message;
+    orig = status->message;
 
-   if (mongocrypt_status_ok (to_append)) {
-      return;
-   }
-   status->message = bson_strdup_printf ("%s: %s", orig, to_append->message);
-   bson_free (orig);
+    if (mongocrypt_status_ok(to_append)) {
+        return;
+    }
+    status->message = bson_strdup_printf("%s: %s", orig, to_append->message);
+    bson_free(orig);
 }

data/ext/libmongocrypt/libmongocrypt/src/mongocrypt-traverse-util-private.h

@@ -21,39 +21,29 @@
 #include "mongocrypt-status-private.h"
 
 typedef enum {
-   TRAVERSE_MATCH_CIPHERTEXT,
-   TRAVERSE_MATCH_MARKING,
-   TRAVERSE_MATCH_SUBTYPE6,
+    TRAVERSE_MATCH_CIPHERTEXT,
+    TRAVERSE_MATCH_MARKING,
+    TRAVERSE_MATCH_SUBTYPE6,
 } traversal_match_t;
 
-typedef bool (*_mongocrypt_traverse_callback_t) (void *ctx,
+typedef bool (*_mongocrypt_traverse_callback_t)(void *ctx, _mongocrypt_buffer_t *in, mongocrypt_status_t *status);
+
+typedef bool (*_mongocrypt_transform_callback_t)(void *ctx,
                                                  _mongocrypt_buffer_t *in,
+                                                 bson_value_t *out,
                                                  mongocrypt_status_t *status);
 
-
-typedef bool (*_mongocrypt_transform_callback_t) (void *ctx,
-                                                  _mongocrypt_buffer_t *in,
-                                                  bson_value_t *out,
-                                                  mongocrypt_status_t *status);
-
-
-bool
-_mongocrypt_traverse_binary_in_bson (_mongocrypt_traverse_callback_t cb,
-                                     void *ctx,
-                                     traversal_match_t match,
-                                     bson_iter_t *iter,
-                                     mongocrypt_status_t *status)
-   MONGOCRYPT_WARN_UNUSED_RESULT;
-
-
-bool
-_mongocrypt_transform_binary_in_bson (_mongocrypt_transform_callback_t cb,
-                                      void *ctx,
-                                      traversal_match_t match,
-                                      bson_iter_t *iter,
-                                      bson_t *out,
-                                      mongocrypt_status_t *status)
-   MONGOCRYPT_WARN_UNUSED_RESULT;
-
+bool _mongocrypt_traverse_binary_in_bson(_mongocrypt_traverse_callback_t cb,
+                                         void *ctx,
+                                         traversal_match_t match,
+                                         bson_iter_t *iter,
+                                         mongocrypt_status_t *status) MONGOCRYPT_WARN_UNUSED_RESULT;
+
+bool _mongocrypt_transform_binary_in_bson(_mongocrypt_transform_callback_t cb,
+                                          void *ctx,
+                                          traversal_match_t match,
+                                          bson_iter_t *iter,
+                                          bson_t *out,
+                                          mongocrypt_status_t *status) MONGOCRYPT_WARN_UNUSED_RESULT;
 
 #endif /* MONGOCRYPT_TRAVERSE_UTIL_H */