libmongocrypt-helper 1.6.1.0.1001 → 1.7.4.0.1000

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

@@ -0,0 +1,132 @@
+// 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 __has_include(<features.h>)
+// We're using a glibc-compatible library
+#define _GNU_SOURCE
+#elif __has_include(<Availability.h>)
+// We're on Apple/Darwin
+#define _DARWIN_C_SOURCE
+#endif
+#else // No __has_include
+#if __GNUC__ < 5
+// Best guess on older GCC is that we are using glibc
+#define _GNU_SOURCE
+#endif
+#endif
+
+#include "../mongocrypt-dll-private.h"
+
+#ifndef _WIN32
+
+#include <assert.h>
+#include <string.h>
+#include <stdio.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,
+      };
+   }
+}
+
+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);
+}
+
+#endif
+
+#ifdef __APPLE__
+
+#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")};
+}
+
+#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 ())};
+   }
+}
+
+#elif defined(_WIN32)
+
+// Handled in os_win/os_dll.c
+
+#else
+
+#error "Don't know how to do mcr_dll_path() on this platform"
+
+#endif

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

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2019-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 "../mongocrypt-mutex-private.h"
+
+#ifndef _WIN32
+
+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_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 ();
+   }
+}
+
+#endif /* _WIN32 */

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

@@ -0,0 +1,92 @@
+#include "../mongocrypt-dll-private.h"
+
+#ifdef _WIN32
+
+#include <mlib/str.h>
+#include <mlib/path.h>
+#include <mlib/error.h>
+
+#include <string.h>
+#include <stdio.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};
+}
+
+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);
+}
+
+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

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2019-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 "../mongocrypt-mutex-private.h"
+
+#ifdef _WIN32
+
+void
+_mongocrypt_mutex_init (mongocrypt_mutex_t *mutex)
+{
+   InitializeCriticalSection (mutex);
+}
+
+void
+_mongocrypt_mutex_cleanup (mongocrypt_mutex_t *mutex)
+{
+   DeleteCriticalSection (mutex);
+}
+
+void
+_mongocrypt_mutex_lock (mongocrypt_mutex_t *mutex)
+{
+   EnterCriticalSection (mutex);
+}
+
+void
+_mongocrypt_mutex_unlock (mongocrypt_mutex_t *mutex)
+{
+   LeaveCriticalSection (mutex);
+}
+
+#endif /* _WIN32 */

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

@@ -0,0 +1,155 @@
+/**
+ * This file does not contain test cases.
+ *
+ * This file defines the minimum APIs for crypt_shared to be successfully loaded
+ * (but not necessarily fully used) by libmongocrypt. This is only used to test
+ * the loading and un-loading of the crypt_shared dynamic library file by
+ * libmongocrypt.
+ */
+
+#ifdef _WIN32
+#define EXPORT_API __declspec(dllexport)
+#else
+#define EXPORT_API __attribute__ ((visibility ("default")))
+#endif
+
+#define MONGO_CRYPT_SUPPORT_COMPILING
+
+#include <mongo_crypt-v1.h>
+
+#include <bson/bson.h>
+
+#include <cstring>
+#include <cinttypes>
+
+#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")))
+#endif
+
+struct mongo_crypt_v1_status {
+};
+
+typedef mongo_crypt_v1_status 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;
+}
+
+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";
+}
+
+int
+mongo_crypt_v1_status_get_code (const status_t *)
+{
+   return 0;
+}
+
+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;
+}
+
+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)
+{
+#ifdef UINT64_C
+   return UINT64_C (0x000600020001000);
+#else
+   return 0x000600020001000;
+#endif
+}
+
+
+const char *
+mongo_crypt_v1_get_version_str (void)
+{
+   return "stubbed-crypt_shared";
+}
+
+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;
+}
+
+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"({
+         "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;
+}
+
+void
+mongo_crypt_v1_bson_free (uint8_t *bson)
+{
+   delete[] bson;
+}