libmongocrypt-helper 1.7.4.0.1002 → 1.8.0.0.1001

data/ext/libmongocrypt/libmongocrypt/src/mongocrypt-traverse-util.c

@@ -16,189 +16,158 @@
 
 #include <bson/bson.h>
 
+#include "mc-fle-blob-subtype-private.h"
 #include "mongocrypt-buffer-private.h"
 #include "mongocrypt-log-private.h"
 #include "mongocrypt-private.h"
 #include "mongocrypt-status-private.h"
 #include "mongocrypt-traverse-util-private.h"
-#include "mc-fle-blob-subtype-private.h"
 
 typedef struct {
-   void *ctx;
-   bson_iter_t iter;
-   bson_t *copy; /* implies transform */
-   char *path;   /* only enabled during tracing. */
-   _mongocrypt_traverse_callback_t traverse_cb;
-   _mongocrypt_transform_callback_t transform_cb;
-   mongocrypt_status_t *status;
-   traversal_match_t match;
-   bson_t child;
+    void *ctx;
+    bson_iter_t iter;
+    bson_t *copy; /* implies transform */
+    char *path;   /* only enabled during tracing. */
+    _mongocrypt_traverse_callback_t traverse_cb;
+    _mongocrypt_transform_callback_t transform_cb;
+    mongocrypt_status_t *status;
+    traversal_match_t match;
+    bson_t child;
 } _recurse_state_t;
 
-static bool
-_check_first_byte (uint8_t byte, traversal_match_t match)
-{
-   switch (match) {
-   case TRAVERSE_MATCH_MARKING:
-      return byte == MC_SUBTYPE_FLE1EncryptionPlaceholder ||
-             byte == MC_SUBTYPE_FLE2EncryptionPlaceholder;
-   case TRAVERSE_MATCH_CIPHERTEXT:
-      return byte == MC_SUBTYPE_FLE1DeterministicEncryptedValue ||
-             byte == MC_SUBTYPE_FLE1RandomEncryptedValue ||
-             byte == MC_SUBTYPE_FLE2IndexedEqualityEncryptedValue ||
-             byte == MC_SUBTYPE_FLE2UnindexedEncryptedValue ||
-             byte == MC_SUBTYPE_FLE2InsertUpdatePayload ||
-             byte == MC_SUBTYPE_FLE2IndexedRangeEncryptedValue;
-   case TRAVERSE_MATCH_SUBTYPE6:
-      return true;
-   default:
-      break;
-   }
-   return false;
+static bool _check_first_byte(uint8_t byte, traversal_match_t match) {
+    switch (match) {
+    case TRAVERSE_MATCH_MARKING:
+        return byte == MC_SUBTYPE_FLE1EncryptionPlaceholder || byte == MC_SUBTYPE_FLE2EncryptionPlaceholder;
+    case TRAVERSE_MATCH_CIPHERTEXT:
+        return byte == MC_SUBTYPE_FLE1DeterministicEncryptedValue || byte == MC_SUBTYPE_FLE1RandomEncryptedValue
+            || byte == MC_SUBTYPE_FLE2IndexedEqualityEncryptedValue || byte == MC_SUBTYPE_FLE2UnindexedEncryptedValue
+            || byte == MC_SUBTYPE_FLE2InsertUpdatePayload || byte == MC_SUBTYPE_FLE2IndexedRangeEncryptedValue
+            || byte == MC_SUBTYPE_FLE2InsertUpdatePayloadV2 || byte == MC_SUBTYPE_FLE2UnindexedEncryptedValueV2
+            || byte == MC_SUBTYPE_FLE2IndexedEqualityEncryptedValueV2
+            || byte == MC_SUBTYPE_FLE2IndexedRangeEncryptedValueV2;
+    case TRAVERSE_MATCH_SUBTYPE6: return true;
+    default: break;
+    }
+    return false;
 }
 
-static bool
-_recurse (_recurse_state_t *state)
-{
-   mongocrypt_status_t *status;
+static bool _recurse(_recurse_state_t *state) {
+    mongocrypt_status_t *status;
+
+    BSON_ASSERT_PARAM(state);
+
+    status = state->status;
+    while (bson_iter_next(&state->iter)) {
+        if (BSON_ITER_HOLDS_BINARY(&state->iter)) {
+            _mongocrypt_buffer_t value;
+
+            BSON_ASSERT(_mongocrypt_buffer_from_binary_iter(&value, &state->iter));
+
+            if (value.subtype == BSON_SUBTYPE_ENCRYPTED && value.len > 0
+                && _check_first_byte(value.data[0], state->match)) {
+                bool ret;
+                /* call the right callback. */
+                if (state->copy) {
+                    bson_value_t value_out;
+                    ret = state->transform_cb(state->ctx, &value, &value_out, status);
+                    if (ret) {
+                        const uint32_t key_len = bson_iter_key_len(&state->iter);
+                        BSON_ASSERT(key_len <= INT_MAX);
+                        bson_append_value(state->copy, bson_iter_key(&state->iter), (int)key_len, &value_out);
+                        bson_value_destroy(&value_out);
+                    }
+                } else {
+                    ret = state->traverse_cb(state->ctx, &value, status);
+                }
+
+                if (!ret) {
+                    return false;
+                }
+                continue;
+            }
+            /* fall through and copy */
+        }
 
-   BSON_ASSERT_PARAM (state);
+        if (BSON_ITER_HOLDS_ARRAY(&state->iter)) {
+            _recurse_state_t child_state;
+            bool ret;
 
-   status = state->status;
-   while (bson_iter_next (&state->iter)) {
-      if (BSON_ITER_HOLDS_BINARY (&state->iter)) {
-         _mongocrypt_buffer_t value;
+            memcpy(&child_state, state, sizeof(_recurse_state_t));
+            if (!bson_iter_recurse(&state->iter, &child_state.iter)) {
+                CLIENT_ERR("error recursing into array");
+                return false;
+            }
 
-         BSON_ASSERT (
-            _mongocrypt_buffer_from_binary_iter (&value, &state->iter));
+            if (state->copy) {
+                const uint32_t key_len = bson_iter_key_len(&state->iter);
+                BSON_ASSERT(key_len <= INT_MAX);
+                bson_append_array_begin(state->copy, bson_iter_key(&state->iter), (int)key_len, &state->child);
+                child_state.copy = &state->child;
+            }
+            ret = _recurse(&child_state);
+
+            if (state->copy) {
+                bson_append_array_end(state->copy, &state->child);
+            }
+            if (!ret) {
+                return false;
+            }
+            continue;
+        }
 
-         if (value.subtype == BSON_SUBTYPE_ENCRYPTED && value.len > 0 &&
-             _check_first_byte (value.data[0], state->match)) {
+        if (BSON_ITER_HOLDS_DOCUMENT(&state->iter)) {
+            _recurse_state_t child_state;
             bool ret;
-            /* call the right callback. */
+
+            memcpy(&child_state, state, sizeof(_recurse_state_t));
+            if (!bson_iter_recurse(&state->iter, &child_state.iter)) {
+                CLIENT_ERR("error recursing into document");
+                return false;
+            }
+            /* TODO: check for errors everywhere. */
             if (state->copy) {
-               bson_value_t value_out;
-               ret =
-                  state->transform_cb (state->ctx, &value, &value_out, status);
-               if (ret) {
-                  const uint32_t key_len = bson_iter_key_len (&state->iter);
-                  BSON_ASSERT (key_len <= INT_MAX);
-                  bson_append_value (state->copy,
-                                     bson_iter_key (&state->iter),
-                                     (int) key_len,
-                                     &value_out);
-                  bson_value_destroy (&value_out);
-               }
-            } else {
-               ret = state->traverse_cb (state->ctx, &value, status);
+                const uint32_t key_len = bson_iter_key_len(&state->iter);
+                BSON_ASSERT(key_len <= INT_MAX);
+                bson_append_document_begin(state->copy, bson_iter_key(&state->iter), (int)key_len, &state->child);
+                child_state.copy = &state->child;
+            }
+
+            ret = _recurse(&child_state);
+
+            if (state->copy) {
+                if (!bson_append_document_end(state->copy, &state->child)) {
+                    CLIENT_ERR("error appending document");
+                    return false;
+                }
             }
 
             if (!ret) {
-               return false;
+                return false;
             }
             continue;
-         }
-         /* fall through and copy */
-      }
-
-      if (BSON_ITER_HOLDS_ARRAY (&state->iter)) {
-         _recurse_state_t child_state;
-         bool ret;
-
-         memcpy (&child_state, state, sizeof (_recurse_state_t));
-         if (!bson_iter_recurse (&state->iter, &child_state.iter)) {
-            CLIENT_ERR ("error recursing into array");
-            return false;
-         }
-
-         if (state->copy) {
-            const uint32_t key_len = bson_iter_key_len (&state->iter);
-            BSON_ASSERT (key_len <= INT_MAX);
-            bson_append_array_begin (state->copy,
-                                     bson_iter_key (&state->iter),
-                                     (int) key_len,
-                                     &state->child);
-            child_state.copy = &state->child;
-         }
-         ret = _recurse (&child_state);
-
-         if (state->copy) {
-            bson_append_array_end (state->copy, &state->child);
-         }
-         if (!ret) {
-            return false;
-         }
-         continue;
-      }
-
-      if (BSON_ITER_HOLDS_DOCUMENT (&state->iter)) {
-         _recurse_state_t child_state;
-         bool ret;
-
-         memcpy (&child_state, state, sizeof (_recurse_state_t));
-         if (!bson_iter_recurse (&state->iter, &child_state.iter)) {
-            CLIENT_ERR ("error recursing into document");
-            return false;
-         }
-         /* TODO: check for errors everywhere. */
-         if (state->copy) {
-            const uint32_t key_len = bson_iter_key_len (&state->iter);
-            BSON_ASSERT (key_len <= INT_MAX);
-            bson_append_document_begin (state->copy,
-                                        bson_iter_key (&state->iter),
-                                        (int) key_len,
-                                        &state->child);
-            child_state.copy = &state->child;
-         }
-
-         ret = _recurse (&child_state);
-
-         if (state->copy) {
-            if (!bson_append_document_end (state->copy, &state->child)) {
-               CLIENT_ERR ("error appending document");
-               return false;
-            }
-         }
-
-         if (!ret) {
-            return false;
-         }
-         continue;
-      }
-
-      if (state->copy) {
-         const uint32_t key_len = bson_iter_key_len (&state->iter);
-         BSON_ASSERT (key_len <= INT_MAX);
-         bson_append_value (state->copy,
-                            bson_iter_key (&state->iter),
-                            (int) key_len,
-                            bson_iter_value (&state->iter));
-      }
-   }
-   return true;
+        }
+
+        if (state->copy) {
+            const uint32_t key_len = bson_iter_key_len(&state->iter);
+            BSON_ASSERT(key_len <= INT_MAX);
+            bson_append_value(state->copy, bson_iter_key(&state->iter), (int)key_len, bson_iter_value(&state->iter));
+        }
+    }
+    return true;
 }
 
-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)
-{
-   _recurse_state_t starting_state = {ctx,
-                                      *iter,
-                                      out /* copy */,
-                                      NULL /* path */,
-                                      NULL /* traverse callback */,
-                                      cb,
-                                      status,
-                                      match,
-                                      {0}};
-
-   return _recurse (&starting_state);
-}
+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) {
+    _recurse_state_t starting_state =
+        {ctx, *iter, out /* copy */, NULL /* path */, NULL /* traverse callback */, cb, status, match, {0}};
 
+    return _recurse(&starting_state);
+}
 
 /*-----------------------------------------------------------------------------
  *
@@ -213,22 +182,13 @@ _mongocrypt_transform_binary_in_bson (_mongocrypt_transform_callback_t cb,
  *
  *-----------------------------------------------------------------------------
  */
-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)
-{
-   _recurse_state_t starting_state = {ctx,
-                                      *iter,
-                                      NULL /* copy */,
-                                      NULL /* path */,
-                                      cb,
-                                      NULL /* transform callback */,
-                                      status,
-                                      match,
-                                      {0}};
-
-   return _recurse (&starting_state);
+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) {
+    _recurse_state_t starting_state =
+        {ctx, *iter, NULL /* copy */, NULL /* path */, cb, NULL /* transform callback */, status, match, {0}};
+
+    return _recurse(&starting_state);
 }

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

@@ -29,9 +29,7 @@
 
 /* A utility for safely casting from size_t to uint32_t.
  * Returns false if @in exceeds the maximum value of a uint32_t. */
-bool
-size_to_uint32 (size_t in, uint32_t *out);
-
+bool size_to_uint32(size_t in, uint32_t *out);
 
 /**
  * @brief The result type of mpath_current_exe_path()
@@ -39,10 +37,10 @@ size_to_uint32 (size_t in, uint32_t *out);
  * The @ref current_module_result::path member must be freed with mstr_free()
  */
 typedef struct current_module_result {
-   /// The resulting executable path
-   mstr path;
-   /// An error, if the path could not be obtained
-   int error;
+    /// The resulting executable path
+    mstr path;
+    /// An error, if the path could not be obtained
+    int error;
 } current_module_result;
 
 /**
@@ -56,29 +54,21 @@ typedef struct current_module_result {
  * `.error` member for non-zero. The `.path` member must be freed with
  * mtsr_free()
  */
-current_module_result
-current_module_path (void);
+current_module_result current_module_path(void);
 
 /* mc_bson_type_to_string returns the string representation of a BSON type. */
-const char *
-mc_bson_type_to_string (bson_type_t bson_type);
+const char *mc_bson_type_to_string(bson_type_t bson_type);
 
 /* mc_iter_document_as_bson attempts to read the document from @iter into
  * @bson. */
-bool
-mc_iter_document_as_bson (const bson_iter_t *iter,
-                          bson_t *bson,
-                          mongocrypt_status_t *status);
+bool mc_iter_document_as_bson(const bson_iter_t *iter, bson_t *bson, mongocrypt_status_t *status);
 
 // mc_isnan is a wrapper around isnan. It avoids a conversion warning on glibc.
-bool
-mc_isnan (double d);
+bool mc_isnan(double d);
 // mc_isinf is a wrapper around isinf. It avoids a conversion warning on glibc.
-bool
-mc_isinf (double d);
+bool mc_isinf(double d);
 // mc_isfinite is a wrapper around isfinite. It avoids a conversion warning on
 // glibc.
-bool
-mc_isfinite (double d);
+bool mc_isfinite(double d);
 
 #endif /* MONGOCRYPT_UTIL_PRIVATE_H */