libmongocrypt-helper 1.12.0.0.1001 → 1.14.0.0.1001

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

@@ -118,12 +118,6 @@ typedef struct {
     bool use_need_mongo_collinfo_with_db_state;
     bool bypass_query_analysis;
 
-    // When creating new encrypted payloads,
-    // use V2 variants of the FLE2 datatypes.
-    bool use_fle2_v2;
-
-    // Use the Queryable Encryption Range V2 protocol.
-    bool use_range_v2;
 } _mongocrypt_opts_t;
 
 void _mongocrypt_opts_kms_providers_cleanup(_mongocrypt_opts_kms_providers_t *kms_providers);

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

@@ -35,7 +35,6 @@ void _mongocrypt_opts_kms_providers_init(_mongocrypt_opts_kms_providers_t *kms_p
 void _mongocrypt_opts_init(_mongocrypt_opts_t *opts) {
     BSON_ASSERT_PARAM(opts);
     memset(opts, 0, sizeof(*opts));
-    opts->use_range_v2 = true;
     _mongocrypt_opts_kms_providers_init(&opts->kms_providers);
 }
 

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

@@ -39,7 +39,7 @@
 
 #define CLIENT_ERR_W_CODE(code, ...) _mongocrypt_set_error(status, MONGOCRYPT_STATUS_ERROR_CLIENT, code, __VA_ARGS__)
 
-#define CLIENT_ERR(fmt, ...) CLIENT_ERR_W_CODE(MONGOCRYPT_GENERIC_ERROR_CODE, fmt, ##__VA_ARGS__)
+#define CLIENT_ERR(...) CLIENT_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__)
 
@@ -49,6 +49,10 @@
 
 #define MONGOCRYPT_DATA_AND_LEN(x) ((uint8_t *)x), (sizeof(x) / sizeof((x)[0]) - 1)
 
+#define LATEST_STR_ENCODE_VERSION 1
+
+#define MIN_STR_ENCODE_VERSION 1
+
 /* TODO: Move these to mongocrypt-log-private.h? */
 const char *tmp_json(const bson_t *bson);
 
@@ -126,6 +130,7 @@ struct _mongocrypt_t {
     /// Pointer to the global csfle_lib object. Should not be freed directly.
     mongo_crypt_v1_lib *csfle_lib;
     bool retry_enabled;
+    bool multiple_collinfo_enabled;
 };
 
 typedef enum {
@@ -142,7 +147,8 @@ typedef enum {
 typedef enum {
     MONGOCRYPT_FLE2_ALGORITHM_UNINDEXED = 1,
     MONGOCRYPT_FLE2_ALGORITHM_EQUALITY = 2,
-    MONGOCRYPT_FLE2_ALGORITHM_RANGE = 3
+    MONGOCRYPT_FLE2_ALGORITHM_RANGE = 3,
+    MONGOCRYPT_FLE2_ALGORITHM_TEXT_SEARCH = 4
 } mongocrypt_fle2_encryption_algorithm_t;
 
 bool _mongocrypt_validate_and_copy_string(const char *in, int32_t in_len, char **out) MONGOCRYPT_WARN_UNUSED_RESULT;
@@ -161,15 +167,4 @@ 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-traverse-util.c

@@ -45,7 +45,7 @@ static bool _check_first_byte(uint8_t byte, traversal_match_t match) {
             || byte == MC_SUBTYPE_FLE2InsertUpdatePayload || byte == MC_SUBTYPE_FLE2IndexedRangeEncryptedValue
             || byte == MC_SUBTYPE_FLE2InsertUpdatePayloadV2 || byte == MC_SUBTYPE_FLE2UnindexedEncryptedValueV2
             || byte == MC_SUBTYPE_FLE2IndexedEqualityEncryptedValueV2
-            || byte == MC_SUBTYPE_FLE2IndexedRangeEncryptedValueV2;
+            || byte == MC_SUBTYPE_FLE2IndexedRangeEncryptedValueV2 || byte == MC_SUBTYPE_FLE2IndexedTextEncryptedValue;
     case TRAVERSE_MATCH_SUBTYPE6: return true;
     default: break;
     }

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

@@ -18,19 +18,22 @@
 #if defined(__has_include) && !(defined(_GNU_SOURCE) || defined(_DARWIN_C_SOURCE))
 #if __has_include(<features.h>)
 // We're using a glibc-compatible library
+#if !defined(_GNU_SOURCE)
 #define _GNU_SOURCE
+#endif
 #elif __has_include(<Availability.h>)
 // We're on Apple/Darwin
 #define _DARWIN_C_SOURCE
 #endif
 #else // No __has_include
-#if __GNUC__ < 5
+#if __GNUC__ < 5 && !defined(_GNU_SOURCE)
 // Best guess on older GCC is that we are using glibc
 #define _GNU_SOURCE
 #endif
 #endif
 
 #include "mc-check-conversions-private.h"
+#include "mongocrypt-dll-private.h"
 #include "mongocrypt-private.h" // CLIENT_ERR
 #include "mongocrypt-util-private.h"
 
@@ -60,7 +63,7 @@ current_module_result current_module_path(void) {
     int ret_error = 0;
 #ifdef _WIN32
     DWORD acc_size = 512;
-    while (!ret_str.data && !ret_error) {
+    while (!ret_str.raw.data && !ret_error) {
         // Loop until we allocate a large enough buffer or get an error
         wchar_t *path = calloc(acc_size + 1, sizeof(wchar_t));
         SetLastError(0);
@@ -82,7 +85,9 @@ current_module_result current_module_path(void) {
     // Darwin/BSD/glibc define extensions for finding dynamic library info from
     // the address of a symbol.
     Dl_info info = {0};
+    MC_BEGIN_CAST_FUNCTION_TYPE_STRICT_IGNORE
     int rc = dladdr((const void *)current_module_path, &info);
+    MC_END_CAST_FUNCTION_TYPE_STRICT_IGNORE
     if (rc == 0) {
         // Failed to resolve the symbol
         ret_error = ENOENT;

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

@@ -28,6 +28,7 @@
 #include "mongocrypt-cache-private.h"
 #include "mongocrypt-config.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"
@@ -118,8 +119,6 @@ mongocrypt_t *mongocrypt_new(void) {
     crypt->status = mongocrypt_status_new();
     _mongocrypt_opts_init(&crypt->opts);
     _mongocrypt_log_init(&crypt->log);
-    // Default to using FLEv2 (aka QEv2)
-    crypt->opts.use_fle2_v2 = true;
     crypt->ctx_counter = 1;
     crypt->cache_oauth = mc_mapof_kmsid_to_token_new();
     crypt->csfle = (_mongo_crypt_v1_vtable){.okay = false};
@@ -138,7 +137,7 @@ mongocrypt_t *mongocrypt_new(void) {
 }
 
 #define ASSERT_MONGOCRYPT_PARAM_UNINIT(crypt)                                                                          \
-    {                                                                                                                  \
+    if (1) {                                                                                                           \
         const mongocrypt_t *_crypt = (crypt);                                                                          \
         BSON_ASSERT_PARAM(_crypt);                                                                                     \
         if (_crypt->initialized) {                                                                                     \
@@ -146,14 +145,8 @@ mongocrypt_t *mongocrypt_new(void) {
             CLIENT_ERR("options cannot be set after initialization");                                                  \
             return false;                                                                                              \
         }                                                                                                              \
-    }
-
-bool mongocrypt_setopt_fle2v2(mongocrypt_t *crypt, bool enable) {
-    ASSERT_MONGOCRYPT_PARAM_UNINIT(crypt);
-
-    crypt->opts.use_fle2_v2 = enable;
-    return true;
-}
+    } else                                                                                                             \
+        ((void)0)
 
 bool mongocrypt_setopt_use_range_v2(mongocrypt_t *crypt) {
     ASSERT_MONGOCRYPT_PARAM_UNINIT(crypt);
@@ -175,6 +168,12 @@ bool mongocrypt_setopt_retry_kms(mongocrypt_t *crypt, bool enable) {
     return true;
 }
 
+bool mongocrypt_setopt_enable_multiple_collinfo(mongocrypt_t *crypt) {
+    ASSERT_MONGOCRYPT_PARAM_UNINIT(crypt);
+    crypt->multiple_collinfo_enabled = true;
+    return true;
+}
+
 bool mongocrypt_setopt_kms_provider_aws(mongocrypt_t *crypt,
                                         const char *aws_access_key_id,
                                         int32_t aws_access_key_id_len,
@@ -394,14 +393,16 @@ static _loaded_csfle _try_load_csfle(const char *filepath, mongocrypt_status_t *
     // Try to open the dynamic lib
     mcr_dll lib = mcr_dll_open(filepath);
     // Check for errors, which are represented by strings
-    if (lib.error_string.data) {
+    if (lib.error_string.raw.data) {
         // Error opening candidate
         _mongocrypt_log(log,
                         MONGOCRYPT_LOG_LEVEL_WARNING,
-                        "Error while opening candidate for CSFLE dynamic library [%s]: %s",
+                        "Error while opening candidate for crypt_shared dynamic library [%s]: %s",
                         filepath,
-                        lib.error_string.data);
-        CLIENT_ERR("Error while opening candidate for CSFLE dynamic library [%s]: %s", filepath, lib.error_string.data);
+                        lib.error_string.raw.data);
+        CLIENT_ERR("Error while opening candidate for crypt_shared dynamic library [%s]: %s",
+                   filepath,
+                   lib.error_string.raw.data);
         // Free resources, which will include the error string
         mcr_dll_close(lib);
         // Bad:
@@ -409,7 +410,7 @@ static _loaded_csfle _try_load_csfle(const char *filepath, mongocrypt_status_t *
     }
 
     // Successfully opened DLL
-    _mongocrypt_log(log, MONGOCRYPT_LOG_LEVEL_TRACE, "Loading CSFLE dynamic library [%s]", filepath);
+    _mongocrypt_log(log, MONGOCRYPT_LOG_LEVEL_TRACE, "Loading crypt_shared dynamic library [%s]", filepath);
 
     // Construct the library vtable
     _mongo_crypt_v1_vtable vtable = {.okay = true};
@@ -417,12 +418,14 @@ static _loaded_csfle _try_load_csfle(const char *filepath, mongocrypt_status_t *
     {                                                                                                                  \
         /* Symbol names are qualified by the lib name and version: */                                                  \
         const char *symname = "mongo_crypt_v1_" #Name;                                                                 \
-        vtable.Name = mcr_dll_sym(lib, symname);                                                                       \
+        MC_BEGIN_CAST_FUNCTION_TYPE_STRICT_IGNORE                                                                      \
+        vtable.Name = (RetType(*)(__VA_ARGS__))mcr_dll_sym(lib, symname);                                              \
+        MC_END_CAST_FUNCTION_TYPE_STRICT_IGNORE                                                                        \
         if (vtable.Name == NULL) {                                                                                     \
             /* The requested symbol is not present */                                                                  \
             _mongocrypt_log(log,                                                                                       \
                             MONGOCRYPT_LOG_LEVEL_ERROR,                                                                \
-                            "Missing required symbol '%s' from CSFLE dynamic library [%s]",                            \
+                            "Missing required symbol '%s' from crypt_shared dynamic library [%s]",                     \
                             symname,                                                                                   \
                             filepath);                                                                                 \
             /* Mark the vtable as broken, but keep trying to load more symbols to                                      \
@@ -434,17 +437,27 @@ static _loaded_csfle _try_load_csfle(const char *filepath, mongocrypt_status_t *
 #undef X_FUNC
 
     if (!vtable.okay) {
+        // A common mistake is to pass the path to libmongocrypt instead of than crypt_shared.
+        // Check if the library has a libmongocrypt symbol.
+        if (mcr_dll_sym(lib, "mongocrypt_version")) {
+            CLIENT_ERR("Tried to load crypt_shared dynamic library at path [%s] but detected libmongocrypt", filepath);
+            mcr_dll_close(lib);
+            return (_loaded_csfle){.okay = false};
+        }
         mcr_dll_close(lib);
         _mongocrypt_log(log,
                         MONGOCRYPT_LOG_LEVEL_ERROR,
-                        "One or more required symbols are missing from CSFLE dynamic library "
+                        "One or more required symbols are missing from crypt_shared dynamic library "
                         "[%s], so this dynamic library will not be used.",
                         filepath);
+        CLIENT_ERR("One or more required symbols are missing from crypt_shared dynamic library "
+                   "[%s], so this dynamic library will not be used.",
+                   filepath);
         return (_loaded_csfle){.okay = false};
     }
 
     // Success!
-    _mongocrypt_log(log, MONGOCRYPT_LOG_LEVEL_INFO, "Opened CSFLE dynamic library [%s]", filepath);
+    _mongocrypt_log(log, MONGOCRYPT_LOG_LEVEL_INFO, "Opened crypt_shared dynamic library [%s]", filepath);
     return (_loaded_csfle){.okay = true, .lib = lib, .vtable = vtable};
 }
 
@@ -465,7 +478,7 @@ static bool _try_replace_dollar_origin(mstr *filepath, _mongocrypt_log_t *log) {
         return true;
     }
     // Check that the next char is a path separator or end-of-string:
-    char peek = filepath->data[dollar_origin.len];
+    char peek = filepath->raw.data[dollar_origin.len];
     if (peek != 0 && !mpath_is_sep(peek, MPATH_NATIVE)) {
         // Not a single path element
         return true;
@@ -478,9 +491,9 @@ static bool _try_replace_dollar_origin(mstr *filepath, _mongocrypt_log_t *log) {
         _mongocrypt_log(log,
                         MONGOCRYPT_LOG_LEVEL_WARNING,
                         "Error while loading the executable module path for "
-                        "substitution of $ORIGIN in CSFLE search path [%s]: %s",
-                        filepath->data,
-                        error.data);
+                        "substitution of $ORIGIN in crypt_shared search path [%s]: %s",
+                        filepath->raw.data,
+                        error.raw.data);
         mstr_free(error);
         return false;
     }
@@ -496,7 +509,7 @@ static _loaded_csfle _try_find_csfle(mongocrypt_t *crypt) {
 
     BSON_ASSERT_PARAM(crypt);
 
-    if (crypt->opts.crypt_shared_lib_override_path.data) {
+    if (crypt->opts.crypt_shared_lib_override_path.raw.data) {
         // If an override path was specified, skip the library searching behavior
         csfle_cand_filepath = mstr_copy(crypt->opts.crypt_shared_lib_override_path.view);
         if (_try_replace_dollar_origin(&csfle_cand_filepath, &crypt->log)) {
@@ -504,7 +517,7 @@ static _loaded_csfle _try_find_csfle(mongocrypt_t *crypt) {
             // Do not allow a plain filename to go through, as that will cause the
             // DLL load to search the system.
             mstr_assign(&csfle_cand_filepath, mpath_absolute(csfle_cand_filepath.view, MPATH_NATIVE));
-            candidate_csfle = _try_load_csfle(csfle_cand_filepath.data, crypt->status, &crypt->log);
+            candidate_csfle = _try_load_csfle(csfle_cand_filepath.raw.data, crypt->status, &crypt->log);
         }
     } else {
         // No override path was specified, so try to find it on the provided
@@ -526,7 +539,7 @@ static _loaded_csfle _try_find_csfle(mongocrypt_t *crypt) {
                 }
             }
             // Try to load the file:
-            candidate_csfle = _try_load_csfle(csfle_cand_filepath.data, NULL /* status */, &crypt->log);
+            candidate_csfle = _try_load_csfle(csfle_cand_filepath.raw.data, NULL /* status */, &crypt->log);
             if (candidate_csfle.okay) {
                 // Stop searching:
                 break;
@@ -551,13 +564,13 @@ typedef struct csfle_global_lib_state {
     mongo_crypt_v1_lib *csfle_lib;
 } csfle_global_lib_state;
 
-csfle_global_lib_state g_csfle_state;
+static csfle_global_lib_state g_csfle_state;
 
 static void init_csfle_state(void) {
     _mongocrypt_mutex_init(&g_csfle_state.mtx);
 }
 
-mlib_once_flag g_csfle_init_flag = MLIB_ONCE_INITIALIZER;
+static mlib_once_flag g_csfle_init_flag = MLIB_ONCE_INITIALIZER;
 
 /**
  * @brief Verify that `found` refers to the same library that is globally loaded
@@ -589,12 +602,12 @@ static bool _validate_csfle_singleton(mongocrypt_t *crypt, _loaded_csfle found)
 
     // Path to the existing loaded csfle:
     mcr_dll_path_result existing_path_ = mcr_dll_path(g_csfle_state.dll);
-    assert(existing_path_.path.data && "Failed to get path to already-loaded csfle library");
+    assert(existing_path_.path.raw.data && "Failed to get path to already-loaded csfle library");
     mstr_view existing_path = existing_path_.path.view;
     bool okay = true;
     if (!found.okay) {
         // There is one loaded, but we failed to find that same library. Error:
-        CLIENT_ERR("An existing CSFLE library is loaded by the application at "
+        CLIENT_ERR("An existing crypt_shared library is loaded by the application at "
                    "[%s], but the current call to mongocrypt_init() failed to "
                    "find that same library.",
                    existing_path.data);
@@ -602,17 +615,17 @@ static bool _validate_csfle_singleton(mongocrypt_t *crypt, _loaded_csfle found)
     } else {
         // Get the path to what we found:
         mcr_dll_path_result found_path = mcr_dll_path(found.lib);
-        assert(found_path.path.data
+        assert(found_path.path.raw.data
                && "Failed to get the dynamic library filepath of the library that "
                   "was loaded for csfle");
         if (!mstr_eq(found_path.path.view, existing_path)) {
             // Our find-result should only ever find the existing same library.
             // Error:
-            CLIENT_ERR("An existing CSFLE library is loaded by the application at [%s], "
+            CLIENT_ERR("An existing crypt_shared library is loaded by the application at [%s], "
                        "but the current call to mongocrypt_init() attempted to load a "
-                       "second CSFLE library from [%s]. This is not allowed.",
+                       "second crypt_shared library from [%s]. This is not allowed.",
                        existing_path.data,
-                       found_path.path.data);
+                       found_path.path.raw.data);
             okay = false;
         }
         mstr_free(found_path.path);
@@ -787,7 +800,7 @@ static bool _csfle_replace_or_take_validate_singleton(mongocrypt_t *crypt, _load
         have_csfle = true;
         break;
     case LIB_CREATE_FAILED:
-        if (!message.data) {
+        if (!message.raw.data) {
             // We failed to obtain a message about the failure
             _mongocrypt_set_error(crypt->status,
                                   MONGOCRYPT_STATUS_ERROR_CRYPT_SHARED,
@@ -799,7 +812,7 @@ static bool _csfle_replace_or_take_validate_singleton(mongocrypt_t *crypt, _load
                                   MONGOCRYPT_STATUS_ERROR_CRYPT_SHARED,
                                   MONGOCRYPT_GENERIC_ERROR_CODE,
                                   "csfle lib_create() failed: %s [Error %d, code %d]",
-                                  message.data,
+                                  message.raw.data,
                                   err,
                                   code);
         }
@@ -826,7 +839,7 @@ static bool _wants_csfle(mongocrypt_t *c) {
     if (c->opts.bypass_query_analysis) {
         return false;
     }
-    return c->opts.n_crypt_shared_lib_search_paths != 0 || c->opts.crypt_shared_lib_override_path.data != NULL;
+    return c->opts.n_crypt_shared_lib_search_paths != 0 || c->opts.crypt_shared_lib_override_path.raw.data != NULL;
 }
 
 /**
@@ -852,11 +865,11 @@ static bool _try_enable_csfle(mongocrypt_t *crypt) {
 
     // If a crypt_shared override path was specified, but we did not succeed in
     // loading crypt_shared, that is a hard-error.
-    if (crypt->opts.crypt_shared_lib_override_path.data && !found.okay) {
+    if (crypt->opts.crypt_shared_lib_override_path.raw.data && !found.okay) {
         // Wrap error with additional information.
         CLIENT_ERR("A crypt_shared override path was specified [%s], but we failed to open a dynamic "
                    "library at that location. Load error: [%s]",
-                   crypt->opts.crypt_shared_lib_override_path.data,
+                   crypt->opts.crypt_shared_lib_override_path.raw.data,
                    mongocrypt_status_message(crypt->status, NULL /* len */));
         return false;
     }

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

@@ -322,6 +322,17 @@ bool mongocrypt_setopt_log_handler(mongocrypt_t *crypt, mongocrypt_log_fn_t log_
 MONGOCRYPT_EXPORT
 bool mongocrypt_setopt_retry_kms(mongocrypt_t *crypt, bool enable);
 
+/**
+ * Enable support for multiple collection schemas. Required to support $lookup.
+ *
+ * @param[in] crypt The @ref mongocrypt_t object.
+ * @pre @ref mongocrypt_init has not been called on @p crypt.
+ * @returns A boolean indicating success. If false, an error status is set.
+ * Retrieve it with @ref mongocrypt_ctx_status
+ */
+MONGOCRYPT_EXPORT
+bool mongocrypt_setopt_enable_multiple_collinfo(mongocrypt_t *crypt);
+
 /**
  * Configure an AWS KMS provider on the @ref mongocrypt_t object.
  *
@@ -1534,5 +1545,11 @@ bool mongocrypt_setopt_key_expiration(mongocrypt_t *crypt, uint64_t cache_expira
 // DEPRECATED: Support "rangePreview" has been removed in favor of "range".
 #define MONGOCRYPT_QUERY_TYPE_RANGEPREVIEW_DEPRECATED_STR "rangePreview"
 #define MONGOCRYPT_QUERY_TYPE_RANGE_STR "range"
+/// NOTE: "substringPreview" is experimental and may be removed in a future non-major release.
+#define MONGOCRYPT_QUERY_TYPE_SUBSTRINGPREVIEW_STR "substringPreview"
+/// NOTE: "suffixPreview" is experimental and may be removed in a future non-major release.
+#define MONGOCRYPT_QUERY_TYPE_SUFFIXPREVIEW_STR "suffixPreview"
+/// NOTE: "prefixPreview" is experimental and may be removed in a future non-major release.
+#define MONGOCRYPT_QUERY_TYPE_PREFIXPREVIEW_STR "prefixPreview"
 
 #endif /* MONGOCRYPT_H */

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

@@ -2,13 +2,15 @@
 #if defined(__has_include) && !(defined(_GNU_SOURCE) || defined(_DARWIN_C_SOURCE))
 #if __has_include(<features.h>)
 // We're using a glibc-compatible library
+#if !defined(_GNU_SOURCE)
 #define _GNU_SOURCE
+#endif
 #elif __has_include(<Availability.h>)
 // We're on Apple/Darwin
 #define _DARWIN_C_SOURCE
 #endif
 #else // No __has_include
-#if __GNUC__ < 5
+#if __GNUC__ < 5 && !defined(_GNU_SOURCE)
 // Best guess on older GCC is that we are using glibc
 #define _GNU_SOURCE
 #endif
@@ -41,6 +43,8 @@ mcr_dll mcr_dll_open(const char *filepath) {
     }
 }
 
+void mcr_dll_close_handle(mcr_dll); // -Wmissing-prototypes: not for external use despite external linkage.
+
 void mcr_dll_close_handle(mcr_dll dll) {
     if (dll._native_handle) {
         dlclose(dll._native_handle);

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

@@ -46,4 +46,4 @@ void _mongocrypt_mutex_unlock(mongocrypt_mutex_t *mutex) {
     }
 }
 
-#endif /* _WIN32 */
+#endif /* _WIN32 */

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

@@ -36,6 +36,8 @@ mcr_dll mcr_dll_open(const char *filepath_) {
     return (mcr_dll){.error_string = NULL, ._native_handle = lib};
 }
 
+void mcr_dll_close_handle(mcr_dll); // -Wmissing-prototypes: not for external use despite external linkage.
+
 void mcr_dll_close_handle(mcr_dll dll) {
     if (dll._native_handle) {
         FreeLibrary(dll._native_handle);
@@ -50,7 +52,7 @@ 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) {
+    while (!ret_str.raw.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);

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

@@ -34,4 +34,4 @@ void _mongocrypt_mutex_unlock(mongocrypt_mutex_t *mutex) {
     LeaveCriticalSection(mutex);
 }
 
-#endif /* _WIN32 */
+#endif /* _WIN32 */