libmongocrypt-helper 1.7.4.0.1002 → 1.8.0.0.1001

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

@@ -18,7 +18,6 @@
 
 #include "mongocrypt-cache-private.h"
 
-void
-_mongocrypt_cache_collinfo_init (_mongocrypt_cache_t *cache);
+void _mongocrypt_cache_collinfo_init(_mongocrypt_cache_t *cache);
 
 #endif /* MONGOCRYPT_CACHE_COLLINFO_PRIVATE_H */

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

@@ -15,68 +15,51 @@
  */
 
 #include "mongocrypt-cache-private.h"
+
 /* The collinfo cache.
  *
  * Attribute is a null terminated namespace.
  * Value is a collection info doc (response to listCollections).
  */
 
+static bool _cmp_attr(void *a, void *b, int *out) {
+    BSON_ASSERT_PARAM(a);
+    BSON_ASSERT_PARAM(b);
+    BSON_ASSERT_PARAM(out);
 
-static bool
-_cmp_attr (void *a, void *b, int *out)
-{
-   BSON_ASSERT_PARAM (a);
-   BSON_ASSERT_PARAM (b);
-   BSON_ASSERT_PARAM (out);
-
-   *out = strcmp ((char *) a, (char *) b);
-   return true;
+    *out = strcmp((char *)a, (char *)b);
+    return true;
 }
 
+static void *_copy_attr(void *ns) {
+    BSON_ASSERT_PARAM(ns);
 
-static void *
-_copy_attr (void *ns)
-{
-   BSON_ASSERT_PARAM (ns);
-
-   return bson_strdup ((const char *) ns);
+    return bson_strdup((const char *)ns);
 }
 
-
-static void
-_destroy_attr (void *ns)
-{
-   bson_free (ns);
+static void _destroy_attr(void *ns) {
+    bson_free(ns);
 }
 
+static void *_copy_value(void *bson) {
+    BSON_ASSERT_PARAM(bson);
 
-static void *
-_copy_value (void *bson)
-{
-   BSON_ASSERT_PARAM (bson);
-
-   return bson_copy (bson);
+    return bson_copy(bson);
 }
 
-
-static void
-_destroy_value (void *bson)
-{
-   bson_destroy (bson);
+static void _destroy_value(void *bson) {
+    bson_destroy(bson);
 }
 
-
-void
-_mongocrypt_cache_collinfo_init (_mongocrypt_cache_t *cache)
-{
-   BSON_ASSERT_PARAM (cache);
-
-   cache->cmp_attr = _cmp_attr;
-   cache->copy_attr = _copy_attr;
-   cache->destroy_attr = _destroy_attr;
-   cache->copy_value = _copy_value;
-   cache->destroy_value = _destroy_value;
-   _mongocrypt_mutex_init (&cache->mutex);
-   cache->pair = NULL;
-   cache->expiration = CACHE_EXPIRATION_MS;
+void _mongocrypt_cache_collinfo_init(_mongocrypt_cache_t *cache) {
+    BSON_ASSERT_PARAM(cache);
+
+    cache->cmp_attr = _cmp_attr;
+    cache->copy_attr = _copy_attr;
+    cache->destroy_attr = _destroy_attr;
+    cache->copy_value = _copy_value;
+    cache->destroy_value = _destroy_value;
+    _mongocrypt_mutex_init(&cache->mutex);
+    cache->pair = NULL;
+    cache->expiration = CACHE_EXPIRATION_MS;
 }

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

@@ -25,31 +25,25 @@
 #include "mongocrypt-status-private.h"
 
 typedef struct {
-   _mongocrypt_key_doc_t *key_doc;
-   _mongocrypt_buffer_t decrypted_key_material;
+    _mongocrypt_key_doc_t *key_doc;
+    _mongocrypt_buffer_t decrypted_key_material;
 } _mongocrypt_cache_key_value_t;
 
 typedef struct {
-   _mongocrypt_buffer_t id;               /* may be empty */
-   _mongocrypt_key_alt_name_t *alt_names; /* may be NULL */
+    _mongocrypt_buffer_t id;               /* may be empty */
+    _mongocrypt_key_alt_name_t *alt_names; /* may be NULL */
 } _mongocrypt_cache_key_attr_t;
 
-void
-_mongocrypt_cache_key_init (_mongocrypt_cache_t *cache);
+void _mongocrypt_cache_key_init(_mongocrypt_cache_t *cache);
 
-_mongocrypt_cache_key_attr_t *
-_mongocrypt_cache_key_attr_new (_mongocrypt_buffer_t *id,
-                                _mongocrypt_key_alt_name_t *alt_names);
+_mongocrypt_cache_key_attr_t *_mongocrypt_cache_key_attr_new(_mongocrypt_buffer_t *id,
+                                                             _mongocrypt_key_alt_name_t *alt_names);
 
-_mongocrypt_cache_key_value_t *
-_mongocrypt_cache_key_value_new (_mongocrypt_key_doc_t *key_doc,
-                                 _mongocrypt_buffer_t *decrypted_key_material);
+_mongocrypt_cache_key_value_t *_mongocrypt_cache_key_value_new(_mongocrypt_key_doc_t *key_doc,
+                                                               _mongocrypt_buffer_t *decrypted_key_material);
 
-void
-_mongocrypt_cache_key_value_destroy (void *value);
-
-void
-_mongocrypt_cache_key_attr_destroy (_mongocrypt_cache_key_attr_t *attr);
+void _mongocrypt_cache_key_value_destroy(void *value);
 
+void _mongocrypt_cache_key_attr_destroy(_mongocrypt_cache_key_attr_t *attr);
 
 #endif /* MONGOCRYPT_CACHE_KEY_PRIVATE_H */

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

@@ -15,176 +15,147 @@
  */
 
 #include "mongocrypt-cache-key-private.h"
+
 /* The key cache.
  *
  * Attribute is a UUID in the form of a _mongocrypt_buffer_t.
  * Value contains a key document and decrypted key material.
  */
 
-
 /* returns true on success. out is set to 0 if equal, non-zero otherwise. */
-static bool
-_cmp_attr (void *a, void *b, int *out)
-{
-   _mongocrypt_cache_key_attr_t *attr_a, *attr_b;
-
-   BSON_ASSERT_PARAM (a);
-   BSON_ASSERT_PARAM (b);
-   BSON_ASSERT_PARAM (out);
-
-   *out = 1;
-   attr_a = (_mongocrypt_cache_key_attr_t *) a;
-   attr_b = (_mongocrypt_cache_key_attr_t *) b;
-
-   if (!_mongocrypt_buffer_empty (&attr_a->id) &&
-       !_mongocrypt_buffer_empty (&attr_b->id)) {
-      if (0 == _mongocrypt_buffer_cmp (&attr_a->id, &attr_b->id)) {
-         *out = 0;
-      }
-   }
-
-   if (_mongocrypt_key_alt_name_intersects (attr_a->alt_names,
-                                            attr_b->alt_names)) {
-      *out = 0;
-   }
-
-   /* No error. */
-   return true;
-}
+static bool _cmp_attr(void *a, void *b, int *out) {
+    _mongocrypt_cache_key_attr_t *attr_a, *attr_b;
 
+    BSON_ASSERT_PARAM(a);
+    BSON_ASSERT_PARAM(b);
+    BSON_ASSERT_PARAM(out);
 
-static void *
-_copy_attr (void *attr)
-{
-   _mongocrypt_cache_key_attr_t *src;
+    *out = 1;
+    attr_a = (_mongocrypt_cache_key_attr_t *)a;
+    attr_b = (_mongocrypt_cache_key_attr_t *)b;
 
-   BSON_ASSERT_PARAM (attr);
+    if (!_mongocrypt_buffer_empty(&attr_a->id) && !_mongocrypt_buffer_empty(&attr_b->id)) {
+        if (0 == _mongocrypt_buffer_cmp(&attr_a->id, &attr_b->id)) {
+            *out = 0;
+        }
+    }
 
-   src = (_mongocrypt_cache_key_attr_t *) attr;
+    if (_mongocrypt_key_alt_name_intersects(attr_a->alt_names, attr_b->alt_names)) {
+        *out = 0;
+    }
 
-   return _mongocrypt_cache_key_attr_new (&src->id, src->alt_names);
+    /* No error. */
+    return true;
 }
 
+static void *_copy_attr(void *attr) {
+    _mongocrypt_cache_key_attr_t *src;
+
+    BSON_ASSERT_PARAM(attr);
+
+    src = (_mongocrypt_cache_key_attr_t *)attr;
 
-static void
-_destroy_attr (void *attr)
-{
-   _mongocrypt_cache_key_attr_destroy (attr);
+    return _mongocrypt_cache_key_attr_new(&src->id, src->alt_names);
 }
 
+static void _destroy_attr(void *attr) {
+    _mongocrypt_cache_key_attr_destroy(attr);
+}
 
-static void *
-_copy_contents (void *value)
-{
-   _mongocrypt_cache_key_value_t *key_value;
+static void *_copy_contents(void *value) {
+    _mongocrypt_cache_key_value_t *key_value;
 
-   BSON_ASSERT_PARAM (value);
+    BSON_ASSERT_PARAM(value);
 
-   key_value = (_mongocrypt_cache_key_value_t *) value;
-   return _mongocrypt_cache_key_value_new (key_value->key_doc,
-                                           &key_value->decrypted_key_material);
+    key_value = (_mongocrypt_cache_key_value_t *)value;
+    return _mongocrypt_cache_key_value_new(key_value->key_doc, &key_value->decrypted_key_material);
 }
 
-static void
-_dump_attr (void *attr_in)
-{
-   _mongocrypt_cache_key_attr_t *attr;
-   _mongocrypt_key_alt_name_t *altname;
-   char *hex;
-
-   BSON_ASSERT_PARAM (attr_in);
-
-   attr = (_mongocrypt_cache_key_attr_t *) attr_in;
-   hex = _mongocrypt_buffer_to_hex (&attr->id);
-   printf ("_id=%s,", hex);
-   printf ("keyAltNames=");
-   for (altname = attr->alt_names; NULL != altname; altname = altname->next) {
-      printf ("%s\n", _mongocrypt_key_alt_name_get_string (altname));
-   }
-}
+static void _dump_attr(void *attr_in) {
+    _mongocrypt_cache_key_attr_t *attr;
+    _mongocrypt_key_alt_name_t *altname;
+    char *hex;
 
+    BSON_ASSERT_PARAM(attr_in);
 
-_mongocrypt_cache_key_value_t *
-_mongocrypt_cache_key_value_new (_mongocrypt_key_doc_t *key_doc,
-                                 _mongocrypt_buffer_t *decrypted_key_material)
-{
-   _mongocrypt_cache_key_value_t *key_value;
+    attr = (_mongocrypt_cache_key_attr_t *)attr_in;
+    hex = _mongocrypt_buffer_to_hex(&attr->id);
+    printf("_id=%s,", hex);
+    printf("keyAltNames=");
+    for (altname = attr->alt_names; NULL != altname; altname = altname->next) {
+        printf("%s\n", _mongocrypt_key_alt_name_get_string(altname));
+    }
+}
 
-   BSON_ASSERT_PARAM (key_doc);
-   BSON_ASSERT_PARAM (decrypted_key_material);
+_mongocrypt_cache_key_value_t *_mongocrypt_cache_key_value_new(_mongocrypt_key_doc_t *key_doc,
+                                                               _mongocrypt_buffer_t *decrypted_key_material) {
+    _mongocrypt_cache_key_value_t *key_value;
 
-   key_value = bson_malloc0 (sizeof (*key_value));
-   BSON_ASSERT (key_value);
+    BSON_ASSERT_PARAM(key_doc);
+    BSON_ASSERT_PARAM(decrypted_key_material);
 
-   _mongocrypt_buffer_copy_to (decrypted_key_material,
-                               &key_value->decrypted_key_material);
+    key_value = bson_malloc0(sizeof(*key_value));
+    BSON_ASSERT(key_value);
 
-   key_value->key_doc = _mongocrypt_key_new ();
-   _mongocrypt_key_doc_copy_to (key_doc, key_value->key_doc);
+    _mongocrypt_buffer_copy_to(decrypted_key_material, &key_value->decrypted_key_material);
 
-   return key_value;
-}
+    key_value->key_doc = _mongocrypt_key_new();
+    _mongocrypt_key_doc_copy_to(key_doc, key_value->key_doc);
 
+    return key_value;
+}
 
-void
-_mongocrypt_cache_key_value_destroy (void *value)
-{
-   _mongocrypt_cache_key_value_t *key_value;
+void _mongocrypt_cache_key_value_destroy(void *value) {
+    _mongocrypt_cache_key_value_t *key_value;
 
-   if (!value) {
-      return;
-   }
-   key_value = (_mongocrypt_cache_key_value_t *) value;
-   _mongocrypt_key_destroy (key_value->key_doc);
-   _mongocrypt_buffer_cleanup (&key_value->decrypted_key_material);
-   bson_free (key_value);
+    if (!value) {
+        return;
+    }
+    key_value = (_mongocrypt_cache_key_value_t *)value;
+    _mongocrypt_key_destroy(key_value->key_doc);
+    _mongocrypt_buffer_cleanup(&key_value->decrypted_key_material);
+    bson_free(key_value);
 }
 
-void
-_mongocrypt_cache_key_init (_mongocrypt_cache_t *cache)
-{
-   BSON_ASSERT_PARAM (cache);
-
-   cache->cmp_attr = _cmp_attr;
-   cache->copy_attr = _copy_attr;
-   cache->destroy_attr = _destroy_attr;
-   cache->copy_value = _copy_contents;
-   cache->destroy_value = _mongocrypt_cache_key_value_destroy;
-   cache->dump_attr = _dump_attr;
-   _mongocrypt_mutex_init (&cache->mutex);
-   cache->pair = NULL;
-   cache->expiration = CACHE_EXPIRATION_MS;
+void _mongocrypt_cache_key_init(_mongocrypt_cache_t *cache) {
+    BSON_ASSERT_PARAM(cache);
+
+    cache->cmp_attr = _cmp_attr;
+    cache->copy_attr = _copy_attr;
+    cache->destroy_attr = _destroy_attr;
+    cache->copy_value = _copy_contents;
+    cache->destroy_value = _mongocrypt_cache_key_value_destroy;
+    cache->dump_attr = _dump_attr;
+    _mongocrypt_mutex_init(&cache->mutex);
+    cache->pair = NULL;
+    cache->expiration = CACHE_EXPIRATION_MS;
 }
 
 /* Since key cache may be looked up by either _id or keyAltName,
  * "id" or "alt_names" may be NULL, but not both. Returns NULL on error. */
-_mongocrypt_cache_key_attr_t *
-_mongocrypt_cache_key_attr_new (_mongocrypt_buffer_t *id,
-                                _mongocrypt_key_alt_name_t *alt_names)
-{
-   _mongocrypt_cache_key_attr_t *attr;
-
-   if (NULL == id && NULL == alt_names) {
-      return NULL;
-   }
-
-   attr = bson_malloc0 (sizeof (*attr));
-   BSON_ASSERT (attr);
-
-   if (id) {
-      _mongocrypt_buffer_copy_to (id, &attr->id);
-   }
-   attr->alt_names = _mongocrypt_key_alt_name_copy_all (alt_names);
-   return attr;
+_mongocrypt_cache_key_attr_t *_mongocrypt_cache_key_attr_new(_mongocrypt_buffer_t *id,
+                                                             _mongocrypt_key_alt_name_t *alt_names) {
+    _mongocrypt_cache_key_attr_t *attr;
+
+    if (NULL == id && NULL == alt_names) {
+        return NULL;
+    }
+
+    attr = bson_malloc0(sizeof(*attr));
+    BSON_ASSERT(attr);
+
+    if (id) {
+        _mongocrypt_buffer_copy_to(id, &attr->id);
+    }
+    attr->alt_names = _mongocrypt_key_alt_name_copy_all(alt_names);
+    return attr;
 }
 
-void
-_mongocrypt_cache_key_attr_destroy (_mongocrypt_cache_key_attr_t *attr)
-{
-   if (!attr) {
-      return;
-   }
-   _mongocrypt_buffer_cleanup (&attr->id);
-   _mongocrypt_key_alt_name_destroy_all (attr->alt_names);
-   bson_free (attr);
+void _mongocrypt_cache_key_attr_destroy(_mongocrypt_cache_key_attr_t *attr) {
+    if (!attr) {
+        return;
+    }
+    _mongocrypt_buffer_cleanup(&attr->id);
+    _mongocrypt_key_alt_name_destroy_all(attr->alt_names);
+    bson_free(attr);
 }

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

@@ -21,26 +21,20 @@
 #include "mongocrypt-status-private.h"
 
 typedef struct {
-   bson_t *entry;
-   char *access_token;
-   int64_t expiration_time_us;
-   mongocrypt_mutex_t mutex; /* global lock of cache. */
+    bson_t *entry;
+    char *access_token;
+    int64_t expiration_time_us;
+    mongocrypt_mutex_t mutex; /* global lock of cache. */
 } _mongocrypt_cache_oauth_t;
 
-_mongocrypt_cache_oauth_t *
-_mongocrypt_cache_oauth_new (void);
+_mongocrypt_cache_oauth_t *_mongocrypt_cache_oauth_new(void);
 
-void
-_mongocrypt_cache_oauth_destroy (_mongocrypt_cache_oauth_t *cache);
+void _mongocrypt_cache_oauth_destroy(_mongocrypt_cache_oauth_t *cache);
 
-bool
-_mongocrypt_cache_oauth_add (_mongocrypt_cache_oauth_t *cache,
-                             bson_t *oauth_response,
-                             mongocrypt_status_t *status);
+bool _mongocrypt_cache_oauth_add(_mongocrypt_cache_oauth_t *cache, bson_t *oauth_response, mongocrypt_status_t *status);
 
 /* Returns a copy of the base64 encoded oauth token, or NULL if nothing is
  * cached. */
-char *
-_mongocrypt_cache_oauth_get (_mongocrypt_cache_oauth_t *cache);
+char *_mongocrypt_cache_oauth_get(_mongocrypt_cache_oauth_t *cache);
 
 #endif /* MONGOCRYPT_CACHE_OAUTH_PRIVATE_H */

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

@@ -24,103 +24,91 @@
  */
 #define MONGOCRYPT_OAUTH_CACHE_EVICTION_PERIOD_US 5000 * 1000
 
-_mongocrypt_cache_oauth_t *
-_mongocrypt_cache_oauth_new (void)
-{
-   _mongocrypt_cache_oauth_t *cache;
-
-   cache = bson_malloc0 (sizeof (_mongocrypt_cache_oauth_t));
-   _mongocrypt_mutex_init (&cache->mutex);
-   return cache;
+_mongocrypt_cache_oauth_t *_mongocrypt_cache_oauth_new(void) {
+    _mongocrypt_cache_oauth_t *cache;
+
+    cache = bson_malloc0(sizeof(_mongocrypt_cache_oauth_t));
+    _mongocrypt_mutex_init(&cache->mutex);
+    return cache;
 }
 
-void
-_mongocrypt_cache_oauth_destroy (_mongocrypt_cache_oauth_t *cache)
-{
-   BSON_ASSERT_PARAM (cache);
+void _mongocrypt_cache_oauth_destroy(_mongocrypt_cache_oauth_t *cache) {
+    BSON_ASSERT_PARAM(cache);
 
-   _mongocrypt_mutex_cleanup (&cache->mutex);
-   bson_destroy (cache->entry);
-   bson_free (cache->access_token);
-   bson_free (cache);
+    _mongocrypt_mutex_cleanup(&cache->mutex);
+    bson_destroy(cache->entry);
+    bson_free(cache->access_token);
+    bson_free(cache);
 }
 
-bool
-_mongocrypt_cache_oauth_add (_mongocrypt_cache_oauth_t *cache,
-                             bson_t *oauth_response,
-                             mongocrypt_status_t *status)
-{
-   bson_iter_t iter;
-   int64_t expiration_time_us;
-   int64_t cache_time_us;
-   int64_t expires_in_s;
-   int64_t expires_in_us;
-   const char *access_token;
-
-   BSON_ASSERT_PARAM (cache);
-   BSON_ASSERT_PARAM (oauth_response);
-
-   /* The OAuth spec strongly implies that the value of expires_in is positive,
-    * so the overflow checks in this function don't consider negative values. */
-   if (!bson_iter_init_find (&iter, oauth_response, "expires_in") ||
-       !BSON_ITER_HOLDS_INT (&iter)) {
-      CLIENT_ERR ("OAuth response invalid, no 'expires_in' field.");
-      return false;
-   }
-   cache_time_us = bson_get_monotonic_time ();
-   expires_in_s = bson_iter_as_int64 (&iter);
-   BSON_ASSERT (expires_in_s <= INT64_MAX / 1000 / 1000);
-   expires_in_us = expires_in_s * 1000 * 1000;
-   BSON_ASSERT (expires_in_us <= INT64_MAX - cache_time_us &&
-                expires_in_us + cache_time_us >
-                   MONGOCRYPT_OAUTH_CACHE_EVICTION_PERIOD_US);
-   expiration_time_us =
-      expires_in_us + cache_time_us - MONGOCRYPT_OAUTH_CACHE_EVICTION_PERIOD_US;
-
-   if (!bson_iter_init_find (&iter, oauth_response, "access_token") ||
-       !BSON_ITER_HOLDS_UTF8 (&iter)) {
-      CLIENT_ERR ("OAuth response invalid, no 'access_token' field.");
-      return false;
-   }
-   access_token = bson_iter_utf8 (&iter, NULL);
-
-   _mongocrypt_mutex_lock (&cache->mutex);
-   if (expiration_time_us > cache->expiration_time_us) {
-      bson_destroy (cache->entry);
-      cache->entry = bson_copy (oauth_response);
-      cache->expiration_time_us = expiration_time_us;
-      bson_free (cache->access_token);
-      cache->access_token = bson_strdup (access_token);
-   }
-   _mongocrypt_mutex_unlock (&cache->mutex);
-   return true;
+bool _mongocrypt_cache_oauth_add(_mongocrypt_cache_oauth_t *cache,
+                                 bson_t *oauth_response,
+                                 mongocrypt_status_t *status) {
+    bson_iter_t iter;
+    int64_t expiration_time_us;
+    int64_t cache_time_us;
+    int64_t expires_in_s;
+    int64_t expires_in_us;
+    const char *access_token;
+
+    BSON_ASSERT_PARAM(cache);
+    BSON_ASSERT_PARAM(oauth_response);
+
+    /* The OAuth spec strongly implies that the value of expires_in is positive,
+     * so the overflow checks in this function don't consider negative values. */
+    if (!bson_iter_init_find(&iter, oauth_response, "expires_in") || !BSON_ITER_HOLDS_INT(&iter)) {
+        CLIENT_ERR("OAuth response invalid, no 'expires_in' field.");
+        return false;
+    }
+    cache_time_us = bson_get_monotonic_time();
+    expires_in_s = bson_iter_as_int64(&iter);
+    BSON_ASSERT(expires_in_s <= INT64_MAX / 1000 / 1000);
+    expires_in_us = expires_in_s * 1000 * 1000;
+    BSON_ASSERT(expires_in_us <= INT64_MAX - cache_time_us
+                && expires_in_us + cache_time_us > MONGOCRYPT_OAUTH_CACHE_EVICTION_PERIOD_US);
+    expiration_time_us = expires_in_us + cache_time_us - MONGOCRYPT_OAUTH_CACHE_EVICTION_PERIOD_US;
+
+    if (!bson_iter_init_find(&iter, oauth_response, "access_token") || !BSON_ITER_HOLDS_UTF8(&iter)) {
+        CLIENT_ERR("OAuth response invalid, no 'access_token' field.");
+        return false;
+    }
+    access_token = bson_iter_utf8(&iter, NULL);
+
+    _mongocrypt_mutex_lock(&cache->mutex);
+    if (expiration_time_us > cache->expiration_time_us) {
+        bson_destroy(cache->entry);
+        cache->entry = bson_copy(oauth_response);
+        cache->expiration_time_us = expiration_time_us;
+        bson_free(cache->access_token);
+        cache->access_token = bson_strdup(access_token);
+    }
+    _mongocrypt_mutex_unlock(&cache->mutex);
+    return true;
 }
 
 /* Returns a copy of the base64 encoded oauth token, or NULL if nothing is
  * cached. */
-char *
-_mongocrypt_cache_oauth_get (_mongocrypt_cache_oauth_t *cache)
-{
-   char *access_token;
-
-   BSON_ASSERT_PARAM (cache);
-
-   _mongocrypt_mutex_lock (&cache->mutex);
-   if (!cache->entry) {
-      _mongocrypt_mutex_unlock (&cache->mutex);
-      return NULL;
-   }
-
-   if (bson_get_monotonic_time () >= cache->expiration_time_us) {
-      bson_destroy (cache->entry);
-      cache->entry = NULL;
-      cache->expiration_time_us = 0;
-      _mongocrypt_mutex_unlock (&cache->mutex);
-      return NULL;
-   }
-
-   access_token = bson_strdup (cache->access_token);
-   _mongocrypt_mutex_unlock (&cache->mutex);
-
-   return access_token;
+char *_mongocrypt_cache_oauth_get(_mongocrypt_cache_oauth_t *cache) {
+    char *access_token;
+
+    BSON_ASSERT_PARAM(cache);
+
+    _mongocrypt_mutex_lock(&cache->mutex);
+    if (!cache->entry) {
+        _mongocrypt_mutex_unlock(&cache->mutex);
+        return NULL;
+    }
+
+    if (bson_get_monotonic_time() >= cache->expiration_time_us) {
+        bson_destroy(cache->entry);
+        cache->entry = NULL;
+        cache->expiration_time_us = 0;
+        _mongocrypt_mutex_unlock(&cache->mutex);
+        return NULL;
+    }
+
+    access_token = bson_strdup(cache->access_token);
+    _mongocrypt_mutex_unlock(&cache->mutex);
+
+    return access_token;
 }