libmongocrypt-helper 1.7.4.0.1002 → 1.11.0.0.1001

data/ext/libmongocrypt/libmongocrypt/src/mlib/macros.h

@@ -27,9 +27,8 @@
 /// End a C-language-linkage section
 #define MLIB_C_LINKAGE_END _mlibCLinkageEnd
 
-#if (defined(__cpp_constexpr) && __cpp_constexpr >= 201304L) || \
-   (defined(__cplusplus) && __cplusplus >= 201402L) ||          \
-   (defined(_MSVC_LANG) && _MSVC_LANG >= 201402L)
+#if (defined(__cpp_constexpr) && __cpp_constexpr >= 201304L) || (defined(__cplusplus) && __cplusplus >= 201402L)       \
+    || (defined(_MSVC_LANG) && _MSVC_LANG >= 201402L)
 #define _mlibConstexprFn constexpr inline
 #else
 #define _mlibConstexprFn inline
@@ -44,8 +43,8 @@
 #define mlib_constexpr_fn _mlibConstexprFn
 
 #ifdef __GNUC__
-#define MLIB_ANNOTATE_PRINTF(FStringArgAt, VarArgsStartAt) \
-   __attribute__ ((format (__printf__, FStringArgAt, VarArgsStartAt)))
+#define MLIB_ANNOTATE_PRINTF(FStringArgAt, VarArgsStartAt)                                                             \
+    __attribute__((format(__printf__, FStringArgAt, VarArgsStartAt)))
 #else
 #define MLIB_ANNOTATE_PRINTF(FStringArgAt, VarArgsStartAt) /* no-op */
 #endif

data/ext/libmongocrypt/libmongocrypt/src/mlib/path.h

@@ -14,16 +14,16 @@
 #endif
 
 typedef enum mpath_format {
-   /// The POSIX path format
-   MPATH_POSIX = 'p',
-   /// The Win32 path format
-   MPATH_WIN32 = 'w',
-   /// The native path format for the current platform
-   MPATH_NATIVE =
+    /// The POSIX path format
+    MPATH_POSIX = 'p',
+    /// The Win32 path format
+    MPATH_WIN32 = 'w',
+    /// The native path format for the current platform
+    MPATH_NATIVE =
 #ifdef _WIN32
-      MPATH_WIN32,
+        MPATH_WIN32,
 #else
-      MPATH_POSIX,
+        MPATH_POSIX,
 #endif
 } mpath_format;
 
@@ -34,27 +34,23 @@ typedef enum mpath_format {
  * @param c A path character
  * @param f The path format to use
  */
-static inline bool
-mpath_is_sep (char c, mpath_format f)
-{
-   if (f == MPATH_WIN32) {
-      return c == '/' || c == '\\';
-   } else {
-      return c == '/';
-   }
+static inline bool mpath_is_sep(char c, mpath_format f) {
+    if (f == MPATH_WIN32) {
+        return c == '/' || c == '\\';
+    } else {
+        return c == '/';
+    }
 }
 
 /**
  * @brief Obtain the preferred path separator character for the given format
  */
-static inline char
-mpath_preferred_sep (mpath_format f)
-{
-   if (f == MPATH_WIN32) {
-      return '\\';
-   } else {
-      return '/';
-   }
+static inline char mpath_preferred_sep(mpath_format f) {
+    if (f == MPATH_WIN32) {
+        return '\\';
+    } else {
+        return '/';
+    }
 }
 
 /**
@@ -63,68 +59,62 @@ mpath_preferred_sep (mpath_format f)
  *
  * @return mstr A new string which must be freed with mstr_free()
  */
-static inline mstr
-mpath_current_path (void)
-{
+static inline mstr mpath_current_path(void) {
 #if _WIN32
-   while (1) {
-      DWORD len = GetCurrentDirectoryW (0, NULL);
-      wchar_t *wstr = calloc (sizeof (wchar_t), len);
-      DWORD got_len = GetCurrentDirectoryW (len, wstr);
-      if (got_len > len) {
-         free (wstr);
-         continue;
-      }
-      mstr_narrow_result nar = mstr_win32_narrow (wstr);
-      free (wstr);
-      assert (nar.error == 0);
-      return nar.string;
-   }
+    while (1) {
+        DWORD len = GetCurrentDirectoryW(0, NULL);
+        wchar_t *wstr = calloc(sizeof(wchar_t), len);
+        DWORD got_len = GetCurrentDirectoryW(len, wstr);
+        if (got_len > len) {
+            free(wstr);
+            continue;
+        }
+        mstr_narrow_result nar = mstr_win32_narrow(wstr);
+        free(wstr);
+        assert(nar.error == 0);
+        return nar.string;
+    }
 #else
-   mstr_mut mut = mstr_new (8096);
-   char *p = getcwd (mut.data, mut.len);
-   if (p == NULL) {
-      mstr_free (mut.mstr);
-      return MSTR_NULL;
-   }
-   mstr ret = mstr_copy_cstr (mut.data);
-   mstr_free (mut.mstr);
-   return ret;
+    mstr_mut mut = mstr_new(8096);
+    char *p = getcwd(mut.data, mut.len);
+    if (p == NULL) {
+        mstr_free(mut.mstr);
+        return MSTR_NULL;
+    }
+    mstr ret = mstr_copy_cstr(mut.data);
+    mstr_free(mut.mstr);
+    return ret;
 #endif
 }
 
 /**
  * @brief Determine whether the given path string has a trailing path separator
  */
-static inline bool
-mpath_has_trailing_sep (mstr_view path, mpath_format f)
-{
-   return path.len && mpath_is_sep (path.data[path.len - 1], f);
+static inline bool mpath_has_trailing_sep(mstr_view path, mpath_format f) {
+    return path.len && mpath_is_sep(path.data[path.len - 1], f);
 }
 
 /**
  * @brief Obtain the parent path of the given path.
  */
-static inline mstr_view
-mpath_parent (mstr_view path, mpath_format f)
-{
-   if (mpath_has_trailing_sep (path, f)) {
-      // Remove trailing separators:
-      while (mpath_has_trailing_sep (path, f)) {
-         path = mstrv_remove_suffix (path, 1);
-      }
-      return path;
-   }
-   // Remove everything that isn't a path separator:
-   while (path.len != 0 && !mpath_has_trailing_sep (path, f)) {
-      path = mstrv_remove_suffix (path, 1);
-   }
-   // Remove trailing separators again
-   while (path.len > 1 && mpath_has_trailing_sep (path, f)) {
-      path = mstrv_remove_suffix (path, 1);
-   }
-   // The result is the parent path.
-   return path;
+static inline mstr_view mpath_parent(mstr_view path, mpath_format f) {
+    if (mpath_has_trailing_sep(path, f)) {
+        // Remove trailing separators:
+        while (mpath_has_trailing_sep(path, f)) {
+            path = mstrv_remove_suffix(path, 1);
+        }
+        return path;
+    }
+    // Remove everything that isn't a path separator:
+    while (path.len != 0 && !mpath_has_trailing_sep(path, f)) {
+        path = mstrv_remove_suffix(path, 1);
+    }
+    // Remove trailing separators again
+    while (path.len > 1 && mpath_has_trailing_sep(path, f)) {
+        path = mstrv_remove_suffix(path, 1);
+    }
+    // The result is the parent path.
+    return path;
 }
 
 /**
@@ -133,22 +123,20 @@ mpath_parent (mstr_view path, mpath_format f)
  * The returned path will include no directory separators. If the given path
  * ends with a directory separator, the single-dot '.' path is returned instead.
  */
-static inline mstr_view
-mpath_filename (mstr_view path, mpath_format f)
-{
-   if (!path.len) {
-      return path;
-   }
-   const char *it = path.data + path.len;
-   while (it != path.data && !mpath_is_sep (it[-1], f)) {
-      --it;
-   }
-   size_t off = (size_t) (it - path.data);
-   mstr_view fname = mstrv_subview (path, off, path.len);
-   if (fname.len == 0) {
-      return mstrv_lit (".");
-   }
-   return fname;
+static inline mstr_view mpath_filename(mstr_view path, mpath_format f) {
+    if (!path.len) {
+        return path;
+    }
+    const char *it = path.data + path.len;
+    while (it != path.data && !mpath_is_sep(it[-1], f)) {
+        --it;
+    }
+    size_t off = (size_t)(it - path.data);
+    mstr_view fname = mstrv_subview(path, off, path.len);
+    if (fname.len == 0) {
+        return mstrv_lit(".");
+    }
+    return fname;
 }
 
 /**
@@ -163,30 +151,28 @@ mpath_filename (mstr_view path, mpath_format f)
  * @param f The path format to use
  * @return mstr A new string resulting from the join
  */
-static inline mstr
-mpath_join (mstr_view base, mstr_view suffix, mpath_format f)
-{
-   if (!base.len) {
-      return mstr_copy (suffix);
-   }
-   if (mpath_has_trailing_sep (base, f)) {
-      return mstr_append (base, suffix);
-   }
-   if (!suffix.len) {
-      return mstr_copy (base);
-   }
-   if (mpath_is_sep (suffix.data[0], f)) {
-      return mstr_append (base, suffix);
-   }
-   // We must insert a path separator between the two strings
-   assert (base.len <= SIZE_MAX - suffix.len - 1u);
-   mstr_mut r = mstr_new (base.len + suffix.len + 1);
-   char *p = r.data;
-   memcpy (p, base.data, base.len);
-   p += base.len;
-   *p++ = mpath_preferred_sep (f);
-   memcpy (p, suffix.data, suffix.len);
-   return r.mstr;
+static inline mstr mpath_join(mstr_view base, mstr_view suffix, mpath_format f) {
+    if (!base.len) {
+        return mstr_copy(suffix);
+    }
+    if (mpath_has_trailing_sep(base, f)) {
+        return mstr_append(base, suffix);
+    }
+    if (!suffix.len) {
+        return mstr_copy(base);
+    }
+    if (mpath_is_sep(suffix.data[0], f)) {
+        return mstr_append(base, suffix);
+    }
+    // We must insert a path separator between the two strings
+    assert(base.len <= SIZE_MAX - suffix.len - 1u);
+    mstr_mut r = mstr_new(base.len + suffix.len + 1);
+    char *p = r.data;
+    memcpy(p, base.data, base.len);
+    p += base.len;
+    *p++ = mpath_preferred_sep(f);
+    memcpy(p, suffix.data, suffix.len);
+    return r.mstr;
 }
 
 /**
@@ -195,17 +181,14 @@ mpath_join (mstr_view base, mstr_view suffix, mpath_format f)
  * For the Windows format, this will return the drive letter, if present.
  * Otherwise, this will return an empty string.
  */
-static inline mstr_view
-mpath_root_name (mstr_view path, mpath_format f)
-{
-   if (f == MPATH_WIN32 && path.len > 1) {
-      char c = path.data[0];
-      if (path.len > 2 && path.data[1] == ':' &&
-          ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))) {
-         return mstrv_subview (path, 0, 2);
-      }
-   }
-   return mstrv_subview (path, 0, 0);
+static inline mstr_view mpath_root_name(mstr_view path, mpath_format f) {
+    if (f == MPATH_WIN32 && path.len > 1) {
+        char c = path.data[0];
+        if (path.len > 2 && path.data[1] == ':' && ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))) {
+            return mstrv_subview(path, 0, 2);
+        }
+    }
+    return mstrv_subview(path, 0, 0);
 }
 
 /**
@@ -213,16 +196,14 @@ mpath_root_name (mstr_view path, mpath_format f)
  *
  * @note This will not include the drive letter of a Win32 path.
  */
-static inline mstr_view
-mpath_root_directory (mstr_view path, mpath_format f)
-{
-   mstr_view rname = mpath_root_name (path, f);
-   path = mstrv_subview (path, rname.len, path.len);
-   if (path.len && mpath_is_sep (path.data[0], f)) {
-      return mstrv_subview (path, 0, 1);
-   } else {
-      return mstrv_subview (path, 0, 0);
-   }
+static inline mstr_view mpath_root_directory(mstr_view path, mpath_format f) {
+    mstr_view rname = mpath_root_name(path, f);
+    path = mstrv_subview(path, rname.len, path.len);
+    if (path.len && mpath_is_sep(path.data[0], f)) {
+        return mstrv_subview(path, 0, 1);
+    } else {
+        return mstrv_subview(path, 0, 0);
+    }
 }
 
 /**
@@ -230,13 +211,11 @@ mpath_root_directory (mstr_view path, mpath_format f)
  *
  * This will include both the root name and the root filepath, if present.
  */
-static inline mstr_view
-mpath_root_path (mstr_view path, mpath_format f)
-{
-   mstr_view rname = mpath_root_name (path, f);
-   mstr_view rdir = mpath_root_directory (path, f);
-   assert (rname.len <= SIZE_MAX - rdir.len);
-   return mstrv_subview (path, 0, rname.len + rdir.len);
+static inline mstr_view mpath_root_path(mstr_view path, mpath_format f) {
+    mstr_view rname = mpath_root_name(path, f);
+    mstr_view rdir = mpath_root_directory(path, f);
+    assert(rname.len <= SIZE_MAX - rdir.len);
+    return mstrv_subview(path, 0, rname.len + rdir.len);
 }
 
 /**
@@ -245,18 +224,15 @@ mpath_root_path (mstr_view path, mpath_format f)
  *
  * @note A Win32 filepath without a drive letter is not absolute!
  */
-static inline bool
-mpath_is_absolute (mstr_view path, mpath_format f)
-{
-   if (f == MPATH_WIN32) {
-      // Win32 requires both a root name and a root directory for an absolute
-      // path
-      return mpath_root_name (path, f).len &&
-             mpath_root_directory (path, f).len;
-   } else {
-      // POSIX doesn't have "root names"
-      return mpath_root_directory (path, f).len;
-   }
+static inline bool mpath_is_absolute(mstr_view path, mpath_format f) {
+    if (f == MPATH_WIN32) {
+        // Win32 requires both a root name and a root directory for an absolute
+        // path
+        return mpath_root_name(path, f).len && mpath_root_directory(path, f).len;
+    } else {
+        // POSIX doesn't have "root names"
+        return mpath_root_directory(path, f).len;
+    }
 }
 
 /**
@@ -265,11 +241,9 @@ mpath_is_absolute (mstr_view path, mpath_format f)
  * If the path has a root path, returns the content of the path following that
  * root path, otherwise returns the same path itself.
  */
-static inline mstr_view
-mpath_relative_path (mstr_view path, mpath_format f)
-{
-   mstr_view root = mpath_root_path (path, f);
-   return mstrv_subview (path, root.len, path.len);
+static inline mstr_view mpath_relative_path(mstr_view path, mpath_format f) {
+    mstr_view root = mpath_root_path(path, f);
+    return mstrv_subview(path, root.len, path.len);
 }
 
 /**
@@ -278,30 +252,26 @@ mpath_relative_path (mstr_view path, mpath_format f)
  *
  * @note The return value must be freed with mstr_free()
  */
-static inline mstr
-mpath_to_format (mpath_format from, mstr_view path, mpath_format to)
-{
-   mstr_mut ret = mstr_new (path.len);
-   const char *p = path.data;
-   char *out = ret.data;
-   const char *stop = path.data + path.len;
-   for (; p != stop; ++p, ++out) {
-      if (mpath_is_sep (*p, from)) {
-         *out = mpath_preferred_sep (to);
-      } else {
-         *out = *p;
-      }
-   }
-   return ret.mstr;
+static inline mstr mpath_to_format(mpath_format from, mstr_view path, mpath_format to) {
+    mstr_mut ret = mstr_new(path.len);
+    const char *p = path.data;
+    char *out = ret.data;
+    const char *stop = path.data + path.len;
+    for (; p != stop; ++p, ++out) {
+        if (mpath_is_sep(*p, from)) {
+            *out = mpath_preferred_sep(to);
+        } else {
+            *out = *p;
+        }
+    }
+    return ret.mstr;
 }
 
 /**
  * @brief Determine whether the given path is relative (not absolute)
  */
-static inline bool
-mpath_is_relative (mstr_view path, mpath_format f)
-{
-   return !mpath_is_absolute (path, f);
+static inline bool mpath_is_relative(mstr_view path, mpath_format f) {
+    return !mpath_is_absolute(path, f);
 }
 
 /**
@@ -309,8 +279,7 @@ mpath_is_relative (mstr_view path, mpath_format f)
  *
  * @note The return value must be freed with mstr_free()
  */
-static inline mstr
-mpath_absolute (mstr_view path, mpath_format f);
+static inline mstr mpath_absolute(mstr_view path, mpath_format f);
 
 /**
  * @brief Resolve a path to an absolute path from the given base path.
@@ -322,60 +291,56 @@ mpath_absolute (mstr_view path, mpath_format f);
  * @note If `base` is also a relative path, it will also be given to
  * mpath_absolute() to resolve it.
  */
-static inline mstr
-mpath_absolute_from (mstr_view path, mstr_view base, mpath_format f)
-{
-   mstr_view rname = mpath_root_name (path, f);
-   mstr_view rdir = mpath_root_directory (path, f);
-   if (rname.len) {
-      if (rdir.len) {
-         // The path is already fully absolute
-         return mstr_copy (path);
-      } else {
-         mstr abs_base = mpath_absolute (base, f);
-         mstr_view base_rdir = mpath_root_directory (abs_base.view, f);
-         mstr_view base_relpath = mpath_relative_path (abs_base.view, f);
-         mstr_view relpath = mpath_relative_path (path, f);
-         mstr ret = mstr_copy (rname);
-         mstr_assign (&ret, mpath_join (ret.view, base_rdir, f));
-         mstr_assign (&ret, mpath_join (ret.view, base_relpath, f));
-         mstr_assign (&ret, mpath_join (ret.view, relpath, f));
-         mstr_free (abs_base);
-         return ret;
-      }
-   } else {
-      // No root name
-      if (rdir.len) {
-         if (f == MPATH_POSIX) {
-            // No root name, but a root directory on a POSIX path indicates an
-            // absolute path
-            return mstr_copy (path);
-         }
-         mstr abs_base = mpath_absolute (base, f);
-         mstr_view base_rname = mpath_root_name (abs_base.view, f);
-         mstr ret = mpath_join (base_rname, path, f);
-         mstr_free (abs_base);
-         return ret;
-      } else {
-         mstr abs_base = mpath_absolute (base, f);
-         mstr r = mpath_join (abs_base.view, path, f);
-         mstr_free (abs_base);
-         return r;
-      }
-   }
+static inline mstr mpath_absolute_from(mstr_view path, mstr_view base, mpath_format f) {
+    mstr_view rname = mpath_root_name(path, f);
+    mstr_view rdir = mpath_root_directory(path, f);
+    if (rname.len) {
+        if (rdir.len) {
+            // The path is already fully absolute
+            return mstr_copy(path);
+        } else {
+            mstr abs_base = mpath_absolute(base, f);
+            mstr_view base_rdir = mpath_root_directory(abs_base.view, f);
+            mstr_view base_relpath = mpath_relative_path(abs_base.view, f);
+            mstr_view relpath = mpath_relative_path(path, f);
+            mstr ret = mstr_copy(rname);
+            mstr_assign(&ret, mpath_join(ret.view, base_rdir, f));
+            mstr_assign(&ret, mpath_join(ret.view, base_relpath, f));
+            mstr_assign(&ret, mpath_join(ret.view, relpath, f));
+            mstr_free(abs_base);
+            return ret;
+        }
+    } else {
+        // No root name
+        if (rdir.len) {
+            if (f == MPATH_POSIX) {
+                // No root name, but a root directory on a POSIX path indicates an
+                // absolute path
+                return mstr_copy(path);
+            }
+            mstr abs_base = mpath_absolute(base, f);
+            mstr_view base_rname = mpath_root_name(abs_base.view, f);
+            mstr ret = mpath_join(base_rname, path, f);
+            mstr_free(abs_base);
+            return ret;
+        } else {
+            mstr abs_base = mpath_absolute(base, f);
+            mstr r = mpath_join(abs_base.view, path, f);
+            mstr_free(abs_base);
+            return r;
+        }
+    }
 }
 
-static inline mstr
-mpath_absolute (mstr_view path, mpath_format f)
-{
-   if (mpath_is_absolute (path, f)) {
-      return mstr_copy (path);
-   }
-   mstr cur = mpath_current_path ();
-   mstr ret = mpath_absolute_from (path, cur.view, MPATH_NATIVE);
-   mstr_assign (&ret, mpath_to_format (MPATH_NATIVE, ret.view, f));
-   mstr_free (cur);
-   return ret;
+static inline mstr mpath_absolute(mstr_view path, mpath_format f) {
+    if (mpath_is_absolute(path, f)) {
+        return mstr_copy(path);
+    }
+    mstr cur = mpath_current_path();
+    mstr ret = mpath_absolute_from(path, cur.view, MPATH_NATIVE);
+    mstr_assign(&ret, mpath_to_format(MPATH_NATIVE, ret.view, f));
+    mstr_free(cur);
+    return ret;
 }
 
 #endif // MONGOCRYPT_PATH_PRIVATE_H