libmongocrypt-helper 1.7.4.0.1002 → 1.8.0.0.1001

data/ext/libmongocrypt/libmongocrypt/src/os_posix/os_dll.c

@@ -1,6 +1,5 @@
 // Turn on libc extensions so that we can use dladdr() on Unix-like systems
-#if defined(__has_include) && \
-   !(defined(_GNU_SOURCE) || defined(_DARWIN_C_SOURCE))
+#if defined(__has_include) && !(defined(_GNU_SOURCE) || defined(_DARWIN_C_SOURCE))
 #if __has_include(<features.h>)
 // We're using a glibc-compatible library
 #define _GNU_SOURCE
@@ -20,42 +19,36 @@
 #ifndef _WIN32
 
 #include <assert.h>
-#include <string.h>
 #include <stdio.h>
+#include <string.h>
 
 #include <dlfcn.h>
 
-mcr_dll
-mcr_dll_open (const char *filepath)
-{
-   void *handle = dlopen (filepath, RTLD_LAZY | RTLD_LOCAL);
-   if (handle == NULL) {
-      // Failed to open. Return NULL and copy the error message
-      return (mcr_dll){
-         ._native_handle = NULL,
-         .error_string = mstr_copy_cstr (dlerror ()),
-      };
-   } else {
-      // Okay
-      return (mcr_dll){
-         ._native_handle = handle,
-         .error_string = MSTR_NULL,
-      };
-   }
+mcr_dll mcr_dll_open(const char *filepath) {
+    void *handle = dlopen(filepath, RTLD_LAZY | RTLD_LOCAL);
+    if (handle == NULL) {
+        // Failed to open. Return NULL and copy the error message
+        return (mcr_dll){
+            ._native_handle = NULL,
+            .error_string = mstr_copy_cstr(dlerror()),
+        };
+    } else {
+        // Okay
+        return (mcr_dll){
+            ._native_handle = handle,
+            .error_string = MSTR_NULL,
+        };
+    }
 }
 
-void
-mcr_dll_close_handle (mcr_dll dll)
-{
-   if (dll._native_handle) {
-      dlclose (dll._native_handle);
-   }
+void mcr_dll_close_handle(mcr_dll dll) {
+    if (dll._native_handle) {
+        dlclose(dll._native_handle);
+    }
 }
 
-void *
-mcr_dll_sym (mcr_dll dll, const char *sym)
-{
-   return dlsym (dll._native_handle, sym);
+void *mcr_dll_sym(mcr_dll dll, const char *sym) {
+    return dlsym(dll._native_handle, sym);
 }
 
 #endif
@@ -65,60 +58,55 @@ mcr_dll_sym (mcr_dll dll, const char *sym)
 #include <mach-o/dyld.h>
 #include <mach-o/nlist.h>
 
-mcr_dll_path_result
-mcr_dll_path (mcr_dll dll)
-{
-   // Clear the three low bits of the module handle:
-   uintptr_t needle = ((uintptr_t) dll._native_handle & ~UINT64_C (0x3));
-   // Iterate each loaded dyld image
-   /// NOTE: Not thread safe. Is there a thread-safe way to do this?
-   for (uint32_t idx = 0; idx < _dyld_image_count (); ++idx) {
-      // Get the filepath:
-      /// NOTE: Between here and `dlopen`, `dyld_name` could be invalidated by
-      /// a concurrent call to `dlclose()`. Is there a better way?
-      const char *dyld_name = _dyld_get_image_name (idx);
-      // Try and open it. This will return an equivalent pointer to the original
-      // handle to the loaded image since they are deduplicated and reference
-      // counted.
-      void *try_handle = dlopen (dyld_name, RTLD_LAZY);
-      if (!dyld_name) {
-         // Ouch: `idx` was invalidated before we called _dyld_get_image_name.
-         // This will have caused `dlopen()` to return the default handle:
-         assert (try_handle == RTLD_DEFAULT);
-         continue;
-      }
-      // Copy the string before closing, to shrink the chance of `dyld_name`
-      // being used-after-freed.
-      mstr ret_name = mstr_copy_cstr (dyld_name);
-      // Mask off the mode bits:
-      uintptr_t cur = (uintptr_t) try_handle & ~UINT64_C (0x3);
-      // Close our reference to the image. We only care about the handle value.
-      dlclose (try_handle);
-      if (needle == cur) {
-         // We've found the handle
-         return (mcr_dll_path_result){.path = ret_name};
-      }
-      // Not this name.
-      mstr_free (ret_name);
-   }
-   return (mcr_dll_path_result){
-      .error_string = mstr_copy_cstr ("Handle not found in loaded modules")};
+mcr_dll_path_result mcr_dll_path(mcr_dll dll) {
+    // Clear the three low bits of the module handle:
+    uintptr_t needle = ((uintptr_t)dll._native_handle & ~UINT64_C(0x3));
+    // Iterate each loaded dyld image
+    /// NOTE: Not thread safe. Is there a thread-safe way to do this?
+    for (uint32_t idx = 0; idx < _dyld_image_count(); ++idx) {
+        // Get the filepath:
+        /// NOTE: Between here and `dlopen`, `dyld_name` could be invalidated by
+        /// a concurrent call to `dlclose()`. Is there a better way?
+        const char *dyld_name = _dyld_get_image_name(idx);
+        // Try and open it. This will return an equivalent pointer to the original
+        // handle to the loaded image since they are deduplicated and reference
+        // counted.
+        void *try_handle = dlopen(dyld_name, RTLD_LAZY);
+        if (!dyld_name) {
+            // Ouch: `idx` was invalidated before we called _dyld_get_image_name.
+            // This will have caused `dlopen()` to return the default handle:
+            assert(try_handle == RTLD_DEFAULT);
+            continue;
+        }
+        // Copy the string before closing, to shrink the chance of `dyld_name`
+        // being used-after-freed.
+        mstr ret_name = mstr_copy_cstr(dyld_name);
+        // Mask off the mode bits:
+        uintptr_t cur = (uintptr_t)try_handle & ~UINT64_C(0x3);
+        // Close our reference to the image. We only care about the handle value.
+        dlclose(try_handle);
+        if (needle == cur) {
+            // We've found the handle
+            return (mcr_dll_path_result){.path = ret_name};
+        }
+        // Not this name.
+        mstr_free(ret_name);
+    }
+    return (mcr_dll_path_result){.error_string = mstr_copy_cstr("Handle not found in loaded modules")};
 }
 
 #elif defined(__linux__) || defined(__FreeBSD__)
 
 #include <link.h>
 
-mcr_dll_path_result
-mcr_dll_path (mcr_dll dll)
-{
-   struct link_map *map;
-   int rc = dlinfo (dll._native_handle, RTLD_DI_LINKMAP, &map);
-   if (rc == 0) {
-      return (mcr_dll_path_result){.path = mstr_copy_cstr (map->l_name)};
-   } else {
-      return (mcr_dll_path_result){.error_string = mstr_copy_cstr (dlerror ())};
-   }
+mcr_dll_path_result mcr_dll_path(mcr_dll dll) {
+    struct link_map *map;
+    int rc = dlinfo(dll._native_handle, RTLD_DI_LINKMAP, &map);
+    if (rc == 0) {
+        return (mcr_dll_path_result){.path = mstr_copy_cstr(map->l_name)};
+    } else {
+        return (mcr_dll_path_result){.error_string = mstr_copy_cstr(dlerror())};
+    }
 }
 
 #elif defined(_WIN32)

data/ext/libmongocrypt/libmongocrypt/src/os_posix/os_mutex.c

@@ -18,40 +18,32 @@
 
 #ifndef _WIN32
 
-void
-_mongocrypt_mutex_init (mongocrypt_mutex_t *mutex)
-{
-   int ret = pthread_mutex_init (mutex, NULL);
-   if (ret) {
-      abort ();
-   }
+void _mongocrypt_mutex_init(mongocrypt_mutex_t *mutex) {
+    int ret = pthread_mutex_init(mutex, NULL);
+    if (ret) {
+        abort();
+    }
 }
 
-void
-_mongocrypt_mutex_cleanup (mongocrypt_mutex_t *mutex)
-{
-   int ret = pthread_mutex_destroy (mutex);
-   if (ret) {
-      abort ();
-   }
+void _mongocrypt_mutex_cleanup(mongocrypt_mutex_t *mutex) {
+    int ret = pthread_mutex_destroy(mutex);
+    if (ret) {
+        abort();
+    }
 }
 
-void
-_mongocrypt_mutex_lock (mongocrypt_mutex_t *mutex)
-{
-   int ret = pthread_mutex_lock (mutex);
-   if (ret) {
-      abort ();
-   }
+void _mongocrypt_mutex_lock(mongocrypt_mutex_t *mutex) {
+    int ret = pthread_mutex_lock(mutex);
+    if (ret) {
+        abort();
+    }
 }
 
-void
-_mongocrypt_mutex_unlock (mongocrypt_mutex_t *mutex)
-{
-   int ret = pthread_mutex_unlock (mutex);
-   if (ret) {
-      abort ();
-   }
+void _mongocrypt_mutex_unlock(mongocrypt_mutex_t *mutex) {
+    int ret = pthread_mutex_unlock(mutex);
+    if (ret) {
+        abort();
+    }
 }
 
 #endif /* _WIN32 */

data/ext/libmongocrypt/libmongocrypt/src/os_win/os_dll.c

@@ -2,91 +2,78 @@
 
 #ifdef _WIN32
 
-#include <mlib/str.h>
-#include <mlib/path.h>
 #include <mlib/error.h>
+#include <mlib/path.h>
+#include <mlib/str.h>
 
-#include <string.h>
 #include <stdio.h>
+#include <string.h>
 
 #include <windows.h>
 
-mcr_dll
-mcr_dll_open (const char *filepath_)
-{
-   // Convert all slashes to the native Windows separator
-   mstr filepath =
-      mpath_to_format (MPATH_WIN32, mstrv_view_cstr (filepath_), MPATH_WIN32);
-   // Check if the path is just a filename.
-   bool is_just_filename =
-      mstr_eq (mpath_filename (filepath.view, MPATH_WIN32), filepath.view);
-   if (!is_just_filename) {
-      // If the path is only a filename, we'll allow LoadLibrary() to do a
-      // proper full DLL search. If the path is NOT just a filename, resolve the
-      // given path to a single unambiguous absolute path to suppress
-      // LoadLibrary()'s DLL search behavior.
-      mstr_assign (&filepath, mpath_absolute (filepath.view, MPATH_WIN32));
-   }
-   mstr_widen_result wide = mstr_win32_widen (filepath.view);
-   mstr_free (filepath);
-   if (wide.error) {
-      return (mcr_dll){._native_handle = NULL,
-                       .error_string = merror_system_error_string (wide.error)};
-   }
-   HMODULE lib = LoadLibraryW (wide.wstring);
-   if (lib == NULL) {
-      return (mcr_dll){._native_handle = NULL,
-                       .error_string =
-                          merror_system_error_string (GetLastError ())};
-   }
-   free (wide.wstring);
-   return (mcr_dll){.error_string = NULL, ._native_handle = lib};
+mcr_dll mcr_dll_open(const char *filepath_) {
+    // Convert all slashes to the native Windows separator
+    mstr filepath = mpath_to_format(MPATH_WIN32, mstrv_view_cstr(filepath_), MPATH_WIN32);
+    // Check if the path is just a filename.
+    bool is_just_filename = mstr_eq(mpath_filename(filepath.view, MPATH_WIN32), filepath.view);
+    if (!is_just_filename) {
+        // If the path is only a filename, we'll allow LoadLibrary() to do a
+        // proper full DLL search. If the path is NOT just a filename, resolve the
+        // given path to a single unambiguous absolute path to suppress
+        // LoadLibrary()'s DLL search behavior.
+        mstr_assign(&filepath, mpath_absolute(filepath.view, MPATH_WIN32));
+    }
+    mstr_widen_result wide = mstr_win32_widen(filepath.view);
+    mstr_free(filepath);
+    if (wide.error) {
+        return (mcr_dll){._native_handle = NULL, .error_string = merror_system_error_string(wide.error)};
+    }
+    HMODULE lib = LoadLibraryW(wide.wstring);
+    if (lib == NULL) {
+        return (mcr_dll){._native_handle = NULL, .error_string = merror_system_error_string(GetLastError())};
+    }
+    free(wide.wstring);
+    return (mcr_dll){.error_string = NULL, ._native_handle = lib};
 }
 
-void
-mcr_dll_close_handle (mcr_dll dll)
-{
-   if (dll._native_handle) {
-      FreeLibrary (dll._native_handle);
-   }
+void mcr_dll_close_handle(mcr_dll dll) {
+    if (dll._native_handle) {
+        FreeLibrary(dll._native_handle);
+    }
 }
 
-void *
-mcr_dll_sym (mcr_dll dll, const char *sym)
-{
-   return GetProcAddress (dll._native_handle, sym);
+void *mcr_dll_sym(mcr_dll dll, const char *sym) {
+    return GetProcAddress(dll._native_handle, sym);
 }
 
-mcr_dll_path_result
-mcr_dll_path (mcr_dll dll)
-{
-   mstr ret_str = MSTR_NULL;
-   int ret_error = 0;
-   DWORD acc_size = 512;
-   while (!ret_str.data && !ret_error) {
-      // Loop until we allocate a large enough buffer or get an error
-      wchar_t *path = calloc ((size_t) acc_size + 1u, sizeof (wchar_t));
-      SetLastError (0);
-      GetModuleFileNameW (dll._native_handle, path, acc_size);
-      if (GetLastError () == ERROR_INSUFFICIENT_BUFFER) {
-         // Try again with more buffer
-         /* DWORD is a 32-bit unsigned integer */
-         assert (acc_size <= UINT32_MAX / 2u);
-         acc_size *= 2;
-      } else if (GetLastError () != 0) {
-         ret_error = GetLastError ();
-      } else {
-         mstr_narrow_result narrow = mstr_win32_narrow (path);
-         // GetModuleFileNameW should never return invalid Unicode:
-         assert (narrow.error == 0);
-         ret_str = narrow.string;
-      }
-      free (path);
-   }
-   return (mcr_dll_path_result){
-      .path = ret_str,
-      .error_string = merror_system_error_string (ret_error),
-   };
+mcr_dll_path_result mcr_dll_path(mcr_dll dll) {
+    mstr ret_str = MSTR_NULL;
+    int ret_error = 0;
+    DWORD acc_size = 512;
+    while (!ret_str.data && !ret_error) {
+        // Loop until we allocate a large enough buffer or get an error
+        wchar_t *path = calloc((size_t)acc_size + 1u, sizeof(wchar_t));
+        SetLastError(0);
+        GetModuleFileNameW(dll._native_handle, path, acc_size);
+        if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
+            // Try again with more buffer
+            /* DWORD is a 32-bit unsigned integer */
+            assert(acc_size <= UINT32_MAX / 2u);
+            acc_size *= 2;
+        } else if (GetLastError() != 0) {
+            ret_error = GetLastError();
+        } else {
+            mstr_narrow_result narrow = mstr_win32_narrow(path);
+            // GetModuleFileNameW should never return invalid Unicode:
+            assert(narrow.error == 0);
+            ret_str = narrow.string;
+        }
+        free(path);
+    }
+    return (mcr_dll_path_result){
+        .path = ret_str,
+        .error_string = merror_system_error_string(ret_error),
+    };
 }
 
 #endif

data/ext/libmongocrypt/libmongocrypt/src/os_win/os_mutex.c

@@ -18,28 +18,20 @@
 
 #ifdef _WIN32
 
-void
-_mongocrypt_mutex_init (mongocrypt_mutex_t *mutex)
-{
-   InitializeCriticalSection (mutex);
+void _mongocrypt_mutex_init(mongocrypt_mutex_t *mutex) {
+    InitializeCriticalSection(mutex);
 }
 
-void
-_mongocrypt_mutex_cleanup (mongocrypt_mutex_t *mutex)
-{
-   DeleteCriticalSection (mutex);
+void _mongocrypt_mutex_cleanup(mongocrypt_mutex_t *mutex) {
+    DeleteCriticalSection(mutex);
 }
 
-void
-_mongocrypt_mutex_lock (mongocrypt_mutex_t *mutex)
-{
-   EnterCriticalSection (mutex);
+void _mongocrypt_mutex_lock(mongocrypt_mutex_t *mutex) {
+    EnterCriticalSection(mutex);
 }
 
-void
-_mongocrypt_mutex_unlock (mongocrypt_mutex_t *mutex)
-{
-   LeaveCriticalSection (mutex);
+void _mongocrypt_mutex_unlock(mongocrypt_mutex_t *mutex) {
+    LeaveCriticalSection(mutex);
 }
 
 #endif /* _WIN32 */

data/ext/libmongocrypt/libmongocrypt/test/crypt_shared-stub.cpp

@@ -10,7 +10,7 @@
 #ifdef _WIN32
 #define EXPORT_API __declspec(dllexport)
 #else
-#define EXPORT_API __attribute__ ((visibility ("default")))
+#define EXPORT_API __attribute__((visibility("default")))
 #endif
 
 #define MONGO_CRYPT_SUPPORT_COMPILING
@@ -19,137 +19,107 @@
 
 #include <bson/bson.h>
 
-#include <cstring>
 #include <cinttypes>
+#include <cstring>
 
 #ifdef _WIN32
 #define MONGO_API_CALL __cdecl
 #define MONGO_API_EXPORT __declspec(dllexport)
 #else
 #define MONGO_API_CALL [[]]
-#define MONGO_API_EXPORT __attribute__ ((used, visibility ("default")))
+#define MONGO_API_EXPORT __attribute__((used, visibility("default")))
 #endif
 
-struct mongo_crypt_v1_status {
-};
+struct mongo_crypt_v1_status {};
 
 typedef mongo_crypt_v1_status status_t;
 
-status_t *
-mongo_crypt_v1_status_create (void)
-{
-   return new status_t;
+status_t *mongo_crypt_v1_status_create(void) {
+    return new status_t;
 }
 
-void
-mongo_crypt_v1_status_destroy (status_t *st)
-{
-   delete st;
+void mongo_crypt_v1_status_destroy(status_t *st) {
+    delete st;
 }
 
-int
-mongo_crypt_v1_status_get_error (const status_t *)
-{
-   return 0;
+int mongo_crypt_v1_status_get_error(const status_t *) {
+    return 0;
 }
 
-const char *
-mongo_crypt_v1_status_get_explanation (const status_t *)
-{
-   return "nothing here";
+const char *mongo_crypt_v1_status_get_explanation(const status_t *) {
+    return "nothing here";
 }
 
-int
-mongo_crypt_v1_status_get_code (const status_t *)
-{
-   return 0;
+int mongo_crypt_v1_status_get_code(const status_t *) {
+    return 0;
 }
 
-struct mongo_crypt_v1_lib {
-};
+struct mongo_crypt_v1_lib {};
 
 typedef mongo_crypt_v1_lib lib_t;
 
-lib_t *
-mongo_crypt_v1_lib_create (status_t *)
-{
-   return new lib_t;
+lib_t *mongo_crypt_v1_lib_create(status_t *) {
+    return new lib_t;
 }
 
-int
-mongo_crypt_v1_lib_destroy (lib_t *lib, status_t *)
-{
-   delete lib;
-   return MONGO_CRYPT_V1_SUCCESS;
+int mongo_crypt_v1_lib_destroy(lib_t *lib, status_t *) {
+    delete lib;
+    return MONGO_CRYPT_V1_SUCCESS;
 }
 
-uint64_t
-mongo_crypt_v1_get_version (void)
-{
+uint64_t mongo_crypt_v1_get_version(void) {
 #ifdef UINT64_C
-   return UINT64_C (0x000600020001000);
+    return UINT64_C(0x000600020001000);
 #else
-   return 0x000600020001000;
+    return 0x000600020001000;
 #endif
 }
 
-
-const char *
-mongo_crypt_v1_get_version_str (void)
-{
-   return "stubbed-crypt_shared";
+const char *mongo_crypt_v1_get_version_str(void) {
+    return "stubbed-crypt_shared";
 }
 
-struct mongo_crypt_v1_query_analyzer {
-};
+struct mongo_crypt_v1_query_analyzer {};
 
 typedef mongo_crypt_v1_query_analyzer query_analyzer_t;
 
-query_analyzer_t *
-mongo_crypt_v1_query_analyzer_create (lib_t *, status_t *)
-{
-   return new query_analyzer_t;
+query_analyzer_t *mongo_crypt_v1_query_analyzer_create(lib_t *, status_t *) {
+    return new query_analyzer_t;
 }
 
-void
-mongo_crypt_v1_query_analyzer_destroy (query_analyzer_t *qa)
-{
-   delete qa;
+void mongo_crypt_v1_query_analyzer_destroy(query_analyzer_t *qa) {
+    delete qa;
 }
 
-uint8_t *
-mongo_crypt_v1_analyze_query (query_analyzer_t *qa,
-                              const uint8_t *doc_bson,
-                              const char *ns_str,
-                              uint32_t ns_len,
-                              uint32_t *bson_len_out,
-                              status_t *)
-{
-   std::uint32_t doc_len;
-   std::copy_n (doc_bson, sizeof doc_len, reinterpret_cast<char *> (&doc_len));
-   doc_len = BSON_UINT32_FROM_LE (doc_len);
-   bson_t *given = bson_new_from_data (doc_bson, doc_len);
-   bson_t doc = BSON_INITIALIZER;
-   BSON_APPEND_DOCUMENT (&doc, "originalCommand", given);
-   bson_t tmp_doc;
-   bson_init_from_json ( //
-      &tmp_doc,
-      R"({
+uint8_t *mongo_crypt_v1_analyze_query(query_analyzer_t *qa,
+                                      const uint8_t *doc_bson,
+                                      const char *ns_str,
+                                      uint32_t ns_len,
+                                      uint32_t *bson_len_out,
+                                      status_t *) {
+    std::uint32_t doc_len;
+    std::copy_n(doc_bson, sizeof doc_len, reinterpret_cast<char *>(&doc_len));
+    doc_len = BSON_UINT32_FROM_LE(doc_len);
+    bson_t *given = bson_new_from_data(doc_bson, doc_len);
+    bson_t doc = BSON_INITIALIZER;
+    BSON_APPEND_DOCUMENT(&doc, "originalCommand", given);
+    bson_t tmp_doc;
+    bson_init_from_json( //
+        &tmp_doc,
+        R"({
          "markedDocument": true
       })",
-      -1,
-      NULL);
-   BSON_APPEND_DOCUMENT (&doc, "result", &tmp_doc);
-   uint8_t *buf = new uint8_t[doc.len];
-   std::copy_n (bson_get_data (&doc), doc.len, buf);
-   *bson_len_out = doc.len;
-   bson_destroy (given);
-   bson_destroy (&tmp_doc);
-   return buf;
+        -1,
+        NULL);
+    BSON_APPEND_DOCUMENT(&doc, "result", &tmp_doc);
+    uint8_t *buf = new uint8_t[doc.len];
+    std::copy_n(bson_get_data(&doc), doc.len, buf);
+    *bson_len_out = doc.len;
+    bson_destroy(given);
+    bson_destroy(&tmp_doc);
+    return buf;
 }
 
-void
-mongo_crypt_v1_bson_free (uint8_t *bson)
-{
-   delete[] bson;
+void mongo_crypt_v1_bson_free(uint8_t *bson) {
+    delete[] bson;
 }