libmongocrypt-helper 1.12.0.0.1001 → 1.14.0.0.1001

data/ext/libmongocrypt/libmongocrypt/src/mc-writer.c

@@ -21,7 +21,8 @@
 #define CHECK_AND_RETURN(x)                                                                                            \
     if (!(x)) {                                                                                                        \
         return false;                                                                                                  \
-    }
+    } else                                                                                                             \
+        ((void)0)
 
 #define CHECK_REMAINING_BUFFER_AND_RET(write_size)                                                                     \
     if ((write_size) > writer->len - writer->pos) {                                                                    \
@@ -30,7 +31,8 @@
                    (writer->len - writer->pos),                                                                        \
                    (uint64_t)(write_size));                                                                            \
         return false;                                                                                                  \
-    }
+    } else                                                                                                             \
+        ((void)0)
 
 void mc_writer_init(mc_writer_t *writer, uint8_t *ptr, uint64_t len, const char *parser_name) {
     BSON_ASSERT_PARAM(writer);

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

@@ -51,4 +51,4 @@ static inline mstr merror_system_error_string(int errn) {
 #endif
 }
 
-#endif // MLIB_ERROR_PRIVATE_H
+#endif // MLIB_ERROR_PRIVATE_H

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

@@ -9,6 +9,12 @@
 #include <stdlib.h>
 #include <string.h>
 
+// Deliberately using old-style casts for C and C++ compatibility.
+#if defined(__cplusplus) && defined(__clang__)
+_Pragma("clang diagnostic push");
+_Pragma("clang diagnostic ignored \"-Wold-style-cast\"");
+#endif
+
 MLIB_C_LINKAGE_BEGIN
 
 /**
@@ -496,7 +502,7 @@ static mlib_constexpr_fn mlib_int128_divmod_result mlib_int128_divmod(mlib_int12
             u[2] |= (uint32_t)(numer.r.lo >> (64 - d));
             u[4] |= (uint32_t)(numer.r.hi >> (64 - d));
             v[2] |= (uint32_t)(denom.r.lo >> (64 - d));
-        };
+        }
 
         uint32_t q[2] = {0};
         if (has_three) {
@@ -644,4 +650,9 @@ static mlib_constexpr_fn mlib_int128_charbuf mlib_int128_format(mlib_int128 i) {
 
 MLIB_C_LINKAGE_END
 
+// Deliberately using old-style casts for C and C++ compatibility.
+#if defined(__cplusplus) && defined(__clang__)
+_Pragma("clang diagnostic pop");
+#endif
+
 #endif // MLIB_INT128_H_INCLUDED

data/ext/libmongocrypt/libmongocrypt/src/mlib/int128.test.cpp

@@ -10,6 +10,11 @@
 #include <thread>
 #include <vector>
 
+// Deliberately using old-style casts for C and C++ compatibility.
+#if defined(__clang__)
+_Pragma("clang diagnostic ignored \"-Wold-style-cast\"");
+#endif
+
 #if (defined(__GNUC__) && __GNUC__ < 7 && !defined(__clang__)) || (defined(_MSC_VER) && _MSC_VER < 1920)
 // Old GCC and old MSVC have partially-broken constexpr that prevents us from
 // properly using static_assert with from_string()

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

@@ -60,7 +60,7 @@ static inline char 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) {
-#if _WIN32
+#if defined(_WIN32)
     while (1) {
         DWORD len = GetCurrentDirectoryW(0, NULL);
         wchar_t *wstr = calloc(sizeof(wchar_t), len);
@@ -76,12 +76,12 @@ static inline mstr mpath_current_path(void) {
     }
 #else
     mstr_mut mut = mstr_new(8096);
-    char *p = getcwd(mut.data, mut.len);
+    char *p = getcwd(mut.raw.data, mut.raw.len);
     if (p == NULL) {
         mstr_free(mut.mstr);
         return MSTR_NULL;
     }
-    mstr ret = mstr_copy_cstr(mut.data);
+    mstr ret = mstr_copy_cstr(mut.raw.data);
     mstr_free(mut.mstr);
     return ret;
 #endif
@@ -167,7 +167,7 @@ static inline mstr mpath_join(mstr_view base, mstr_view suffix, mpath_format f)
     // 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;
+    char *p = r.raw.data;
     memcpy(p, base.data, base.len);
     p += base.len;
     *p++ = mpath_preferred_sep(f);
@@ -255,7 +255,7 @@ static inline mstr_view mpath_relative_path(mstr_view path, mpath_format f) {
 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;
+    char *out = ret.raw.data;
     const char *stop = path.data + path.len;
     for (; p != stop; ++p, ++out) {
         if (mpath_is_sep(*p, from)) {

data/ext/libmongocrypt/libmongocrypt/src/mlib/path.test.c

@@ -1,8 +1,5 @@
 #include "./path.h"
 
-#define CHECK(Expr)                                                                                                    \
-    ((Expr) ? 0 : ((fprintf(stderr, "%s:%d: Check '%s' failed\n", __FILE__, __LINE__, #Expr), abort()), 0))
-
 #define TEST_DECOMP(Part, Given, Expect)                                                                               \
     MSTR_ASSERT_EQ(mpath_##Part(mstrv_view_cstr(Given), MPATH_NATIVE), mstrv_view_cstr(Expect))
 
@@ -12,7 +9,7 @@ static void test_make_absolute(mpath_format f, const char *part, const char *bas
     mstr_free(result);
 }
 
-int main() {
+int main(void) {
     mstr s = mstr_copy_cstr("/foo/bar/baz.txt");
     MSTR_ASSERT_EQ(mpath_parent(s.view, MPATH_NATIVE), mstrv_lit("/foo/bar"));
     MSTR_ASSERT_EQ(mpath_parent(mpath_parent(s.view, MPATH_NATIVE), MPATH_NATIVE), mstrv_lit("/foo"));
@@ -67,4 +64,4 @@ int main() {
     mstr_assign(&s, mpath_absolute(mstrv_lit("Z:/foo"), MPATH_POSIX));
 
     mstr_free(s);
-}
+}

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

@@ -17,6 +17,12 @@
 #include <strings.h> /* For strncasecmp. */
 #endif
 
+// Deliberately using old-style casts for C and C++ compatibility.
+#if defined(__cplusplus) && defined(__clang__)
+_Pragma("clang diagnostic push");
+_Pragma("clang diagnostic ignored \"-Wold-style-cast\"");
+#endif
+
 MLIB_C_LINKAGE_BEGIN
 
 /**
@@ -70,28 +76,26 @@ typedef struct mstr_view {
  * relinquish ownership of that `mstr` to the callee/caller, respectively.
  * Passing or returning an `mstr_view` is non-owning.
  */
-typedef struct mstr {
-    union {
-        struct {
-            /**
-             * @brief Pointer to the beginning of the code unit array.
-             *
-             * @note DO NOT MODIFY
-             */
-            const char *data;
-            /**
-             * @brief Length of the pointed-to code unit array
-             *
-             * @note DO NOT MODIFY
-             */
-            size_t len;
-        };
-
+typedef union mstr {
+    struct {
         /**
-         * @brief A non-owning `mstr_view` of the string
+         * @brief Pointer to the beginning of the code unit array.
+         *
+         * @note DO NOT MODIFY
          */
-        mstr_view view;
-    };
+        const char *data;
+        /**
+         * @brief Length of the pointed-to code unit array
+         *
+         * @note DO NOT MODIFY
+         */
+        size_t len;
+    } raw;
+
+    /**
+     * @brief A non-owning `mstr_view` of the string
+     */
+    mstr_view view;
 } mstr;
 
 /**
@@ -100,34 +104,32 @@ typedef struct mstr {
  * Returned by @ref mstr_new(). Once initialization is complete, the result can
  * be used as an @ref mstr by accessing the @ref mstr_mut::mstr member.
  */
-typedef struct mstr_mut {
-    union {
-        struct {
-            /**
-             * @brief Pointer to the beginning of the mutable code unit array.
-             *
-             * @note DO NOT MODIFY THE POINTER VALUE. Only modify the pointed-to
-             * characters.
-             */
-            char *data;
-            /**
-             * @brief Length of the pointed-to code unit array.
-             *
-             * @note DO NOT MODIFY
-             */
-            size_t len;
-        };
-        /// Convert the mutable string to an immutable string
-        struct mstr mstr;
-        /// Convert the mutable string to an immutable string view
-        mstr_view view;
-    };
+typedef union mstr_mut {
+    struct {
+        /**
+         * @brief Pointer to the beginning of the mutable code unit array.
+         *
+         * @note DO NOT MODIFY THE POINTER VALUE. Only modify the pointed-to
+         * characters.
+         */
+        char *data;
+        /**
+         * @brief Length of the pointed-to code unit array.
+         *
+         * @note DO NOT MODIFY
+         */
+        size_t len;
+    } raw;
+    /// Convert the mutable string to an immutable string
+    union mstr mstr;
+    /// Convert the mutable string to an immutable string view
+    mstr_view view;
 } mstr_mut;
 
 /**
  * @brief A null @ref mstr
  */
-#define MSTR_NULL (MLIB_INIT(mstr){{{NULL, 0}}})
+#define MSTR_NULL (MLIB_INIT(mstr){{NULL, 0}})
 /**
  * @brief A null @ref mstr_view
  */
@@ -153,7 +155,7 @@ typedef struct mstr_mut {
 static inline mstr_mut mstr_new(size_t len) {
 #ifndef __clang_analyzer__
     assert(len < SIZE_MAX);
-    return MLIB_INIT(mstr_mut){{{(char *)calloc(1, len + 1), len}}};
+    return MLIB_INIT(mstr_mut){{(char *)calloc(1, len + 1), len}};
 #else
     // Clang-analyzer is smart enough to see the calloc(), but not smart enough
     // to link it to the free() in mstr_free()
@@ -195,7 +197,7 @@ static inline mstr_view mstrv_view_cstr(const char *s) {
  */
 static inline mstr mstr_copy_data(const char *s, size_t len) {
     mstr_mut r = mstr_new(len);
-    memcpy(r.data, s, len);
+    memcpy(r.raw.data, s, len);
     return r.mstr;
 }
 
@@ -225,7 +227,7 @@ static inline mstr mstr_copy(mstr_view s) {
  * @param s The string to free
  */
 static inline void mstr_free(mstr s) {
-    free((char *)s.data);
+    free((char *)s.raw.data);
 }
 
 /**
@@ -236,21 +238,21 @@ static inline void mstr_free(mstr s) {
  * @param new_len The new length of the string
  */
 static inline void mstrm_resize(mstr_mut *s, size_t new_len) {
-    if (new_len <= s->len) {
-        s->len = new_len;
+    if (new_len <= s->raw.len) {
+        s->raw.len = new_len;
     } else {
-        const size_t old_len = s->len;
+        const size_t old_len = s->raw.len;
 #ifndef __clang_analyzer__
         // Clang-analyzer is smart enough to see the calloc(), but not smart
         // enough to link it to the free() in mstr_free()
         assert(new_len < SIZE_MAX);
-        s->data = (char *)realloc((char *)s->data, new_len + 1);
+        s->raw.data = (char *)realloc((char *)s->raw.data, new_len + 1);
 #endif
-        s->len = new_len;
+        s->raw.len = new_len;
         assert(new_len >= old_len);
-        memset(s->data + old_len, 0, new_len - old_len);
+        memset(s->raw.data + old_len, 0, new_len - old_len);
     }
-    s->data[new_len] = (char)0;
+    s->raw.data[new_len] = (char)0;
 }
 
 /**
@@ -369,7 +371,7 @@ static inline mstr mstr_splice(mstr_view s, size_t at, size_t del_count, mstr_vi
     assert(s.len - del_count <= SIZE_MAX - insert.len);
     const size_t new_size = s.len - del_count + insert.len;
     mstr_mut ret = mstr_new(new_size);
-    char *p = ret.data;
+    char *p = ret.raw.data;
     memcpy(p, s.data, at);
     p += at;
     if (insert.data) {
@@ -451,7 +453,7 @@ static inline mstr mstr_substr(mstr_view s, size_t at, size_t len) {
         len = remain;
     }
     mstr_mut r = mstr_new(len);
-    memcpy(r.data, s.data + at, len);
+    memcpy(r.raw.data, s.data + at, len);
     return r.mstr;
 }
 
@@ -607,7 +609,7 @@ static inline void _mstr_assert_(mstr_view left,
         if (!B) {
             mstr_assign(&pstr, mstr_prepend(pstr.view, mstrv_lit("not ")));
         }
-        _mstr_assert_fail_(left, pstr.data, right, file, line);
+        _mstr_assert_fail_(left, pstr.raw.data, right, file, line);
     }
 }
 
@@ -767,9 +769,9 @@ static inline mstr_narrow_result mstr_win32_narrow(const wchar_t *wstring) {
                                       wcflags,
                                       wstring,
                                       -1,
-                                      ret.data,
+                                      ret.raw.data,
                                       // Plus one byte for the NUL
-                                      (int)(ret.len + 1),
+                                      (int)(ret.raw.len + 1),
                                       NULL,
                                       NULL);
     assert(length == got_len);
@@ -906,4 +908,9 @@ static mlib_constexpr_fn size_t mlib_strnmcopy(char *dst, size_t dst_bufsize, co
 
 MLIB_C_LINKAGE_END
 
+// Deliberately using old-style casts for C and C++ compatibility.
+#if defined(__cplusplus) && defined(__clang__)
+_Pragma("clang diagnostic pop");
+#endif
+
 #endif // MONGOCRYPT_STR_PRIVATE_H

data/ext/libmongocrypt/libmongocrypt/src/mlib/str.test.c

@@ -5,16 +5,16 @@
 
 #define test_predicate(Bool, Left, Pred, Right) MSTR_ASSERT(Bool, mstrv_lit(Left), Pred, mstrv_lit(Right))
 
-int main() {
+int main(void) {
     // Test the null-initializers:
     mstr str = MSTR_NULL;
     mstr_view null_view = MSTRV_NULL;
     (void)null_view;
 
     str = mstr_copy_cstr("foo");
-    CHECK(str.len == 3);
+    CHECK(str.raw.len == 3);
     MSTR_ASSERT_EQ(str.view, mstrv_lit("foo"));
-    CHECK(strncmp(str.data, "foo", 3) == 0);
+    CHECK(strncmp(str.raw.data, "foo", 3) == 0);
 
     mstr_inplace_append(&str, mstrv_lit("bar"));
     MSTR_ASSERT_EQ(str.view, mstrv_lit("foobar"));

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

@@ -40,7 +40,7 @@ typedef struct mlib_once_flag {
  */
 typedef void (*mlib_init_once_fn_t)(void);
 
-#if _WIN32
+#if defined(_WIN32)
 /**
  * An indirection layer for mlib_once on Windows platforms. Do not use directly.
  */

data/ext/libmongocrypt/libmongocrypt/src/mlib/user-check.h

@@ -1,4 +1,4 @@
 #ifndef MLIB_USER
 #error                                                                                                                 \
     "The file being compiled transitively #include'd a mongo-mlib header, but is not a direct consumer of mlib, which is a private library for MongoDB C driver libraries"
-#endif
+#endif

data/ext/libmongocrypt/libmongocrypt/src/mlib/windows-lean.h

@@ -12,6 +12,8 @@
 #endif
 
 #pragma push_macro("WIN32_LEAN_AND_MEAN")
+// Disable macro redefinition warning
+#undef WIN32_LEAN_AND_MEAN
 #define WIN32_LEAN_AND_MEAN 1
 #include <windows.h>
 #pragma pop_macro("WIN32_LEAN_AND_MEAN")

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

@@ -142,6 +142,11 @@ bool _mongocrypt_buffer_steal_from_string(_mongocrypt_buffer_t *buf, char *str)
  * - Caller must call _mongocrypt_buffer_cleanup. */
 bool _mongocrypt_buffer_from_string(_mongocrypt_buffer_t *buf, const char *str) MONGOCRYPT_WARN_UNUSED_RESULT;
 
+/* _mongocrypt_buffer_from_ initializes @buf from @data with length @len.
+ * @buf retains a pointer to @data.
+ * @data must outlive @buf. */
+void _mongocrypt_buffer_from_data(_mongocrypt_buffer_t *buf, const uint8_t *data, uint32_t len);
+
 /* _mongocrypt_buffer_copy_from_uint64_le initializes @buf from the
  * little-endian byte representation of @value. Caller must call
  * _mongocrypt_buffer_cleanup.
@@ -157,4 +162,10 @@ bool _mongocrypt_buffer_from_subrange(_mongocrypt_buffer_t *out,
                                       uint32_t offset,
                                       uint32_t len) MONGOCRYPT_WARN_UNUSED_RESULT;
 
+/* _mongocrypt_buffer_copy_from_string_as_bson_value initializes @out, wraps the provided string
+ * into a BSON value, and copies the BSON value to @out. No BSON validation is performed on @str.
+ * Caller must call _mongocrypt_buffer_cleanup.
+ */
+void _mongocrypt_buffer_copy_from_string_as_bson_value(_mongocrypt_buffer_t *out, const char *str, int len);
+
 #endif /* MONGOCRYPT_BUFFER_H */

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

@@ -317,7 +317,10 @@ fail:
     return ret;
 }
 
-void _mongocrypt_buffer_from_iter(_mongocrypt_buffer_t *plaintext, bson_iter_t *iter) {
+static void _mongocrypt_buffer_copy_as_bson_value(_mongocrypt_buffer_t *plaintext,
+                                                  bool (*append_func)(bson_t *bson, const void *data, int len),
+                                                  const void *data,
+                                                  int len) {
     bson_t wrapper = BSON_INITIALIZER;
     int32_t offset = INT32_LEN      /* skips document size */
                    + TYPE_LEN       /* element type */
@@ -326,13 +329,14 @@ void _mongocrypt_buffer_from_iter(_mongocrypt_buffer_t *plaintext, bson_iter_t *
     uint8_t *wrapper_data;
 
     BSON_ASSERT_PARAM(plaintext);
-    BSON_ASSERT_PARAM(iter);
+    BSON_ASSERT_PARAM(append_func);
 
     /* It is not straightforward to transform a bson_value_t to a string of
      * bytes. As a workaround, we wrap the value in a bson document with an empty
      * key, then use the raw buffer from inside the new bson_t, skipping the
      * length and type header information and the key name. */
-    bson_append_iter(&wrapper, "", 0, iter);
+    append_func(&wrapper, data, len);
+
     wrapper_data = ((uint8_t *)bson_get_data(&wrapper));
     BSON_ASSERT(wrapper.len >= (uint32_t)offset + NULL_BYTE_LEN);
     plaintext->len = wrapper.len - (uint32_t)offset - NULL_BYTE_LEN; /* the final null byte */
@@ -345,6 +349,25 @@ void _mongocrypt_buffer_from_iter(_mongocrypt_buffer_t *plaintext, bson_iter_t *
     bson_destroy(&wrapper);
 }
 
+static bool _append_iter(bson_t *bson, const void *iter, int len) {
+    return bson_append_iter(bson, "", 0, (const bson_iter_t *)iter);
+}
+
+static bool _append_utf8(bson_t *bson, const void *str, int len) {
+    return bson_append_utf8(bson, "", 0, (const char *)str, len);
+}
+
+void _mongocrypt_buffer_copy_from_string_as_bson_value(_mongocrypt_buffer_t *plaintext, const char *str, int len) {
+    BSON_ASSERT_PARAM(str);
+    BSON_ASSERT(len >= 0);
+    _mongocrypt_buffer_copy_as_bson_value(plaintext, _append_utf8, str, len);
+}
+
+void _mongocrypt_buffer_from_iter(_mongocrypt_buffer_t *plaintext, bson_iter_t *iter) {
+    BSON_ASSERT_PARAM(iter);
+    _mongocrypt_buffer_copy_as_bson_value(plaintext, _append_iter, iter, 0);
+}
+
 bool _mongocrypt_buffer_from_uuid_iter(_mongocrypt_buffer_t *buf, bson_iter_t *iter) {
     const uint8_t *data;
     bson_subtype_t subtype;
@@ -540,6 +563,16 @@ bool _mongocrypt_buffer_from_string(_mongocrypt_buffer_t *buf, const char *str)
     return true;
 }
 
+void _mongocrypt_buffer_from_data(_mongocrypt_buffer_t *buf, const uint8_t *data, uint32_t len) {
+    BSON_ASSERT_PARAM(buf);
+    BSON_ASSERT_PARAM(data);
+
+    _mongocrypt_buffer_init(buf);
+    buf->data = (uint8_t *)data;
+    buf->len = len;
+    buf->owned = false;
+}
+
 void _mongocrypt_buffer_copy_from_uint64_le(_mongocrypt_buffer_t *buf, uint64_t value) {
     uint64_t value_le = MONGOCRYPT_UINT64_TO_LE(value);
 

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

@@ -20,4 +20,4 @@
 
 void _mongocrypt_cache_collinfo_init(_mongocrypt_cache_t *cache);
 
-#endif /* MONGOCRYPT_CACHE_COLLINFO_PRIVATE_H */
+#endif /* MONGOCRYPT_CACHE_COLLINFO_PRIVATE_H */

data/ext/libmongocrypt/libmongocrypt/src/mongocrypt-cache-collinfo.c

@@ -14,6 +14,10 @@
  * limitations under the License.
  */
 
+#include "mongocrypt-cache-collinfo-private.h"
+
+//
+
 #include "mongocrypt-cache-private.h"
 
 /* The collinfo cache.

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

@@ -22,7 +22,7 @@
 #include "mongocrypt.h"
 
 /**
- * Produced by mongocrypt-marking.c from _mongocrypt_marking_t
+ * Produced by mongocrypt-marking.u.fle1.c from _mongocrypt_marking_t
  * as encrypted payloads for blob_subtypes:
  *   FLE1DeterministicEncryptedValue(1)
  *   FLE1RandomEncryptedValue(2)

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

@@ -77,18 +77,18 @@ typedef struct {
 // FLE1 algorithm: AES-256-CBC HMAC/SHA-512-256 (SHA-512 truncated to 256 bits)
 // Algorithm is documented in [FLE and
 // AEAD](https://docs.google.com/document/d/1D8xTXWo1B1dunO0bDZhPdolKTMbbD5fUIgsERubWRmY)
-const _mongocrypt_value_encryption_algorithm_t *_mcFLE1Algorithm();
+const _mongocrypt_value_encryption_algorithm_t *_mcFLE1Algorithm(void);
 
 // FLE2 general algorithm: AES-256-CTR HMAC/SHA-256
 // Algorithm is documented in [AEAD with
 // CTR](https://docs.google.com/document/d/1eCU7R8Kjr-mdyz6eKvhNIDVmhyYQcAaLtTfHeK7a_vE/).
-const _mongocrypt_value_encryption_algorithm_t *_mcFLE2AEADAlgorithm();
+const _mongocrypt_value_encryption_algorithm_t *_mcFLE2AEADAlgorithm(void);
 
 // FLE2 used with FLE2IndexedEncryptedValue: AES-256-CTR no HMAC
-const _mongocrypt_value_encryption_algorithm_t *_mcFLE2Algorithm();
+const _mongocrypt_value_encryption_algorithm_t *_mcFLE2Algorithm(void);
 
 // FLE2AEAD general algorithm: AES-256-CBC HMAC/SHA-256
-const _mongocrypt_value_encryption_algorithm_t *_mcFLE2v2AEADAlgorithm();
+const _mongocrypt_value_encryption_algorithm_t *_mcFLE2v2AEADAlgorithm(void);
 
 bool _mongocrypt_random(_mongocrypt_crypto_t *crypto,
                         _mongocrypt_buffer_t *out,