libmongocrypt-helper 1.7.4.0.1002 → 1.11.0.0.1001

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

@@ -18,195 +18,181 @@
 
 #include "mongocrypt-private.h"
 
-void
-_mongocrypt_endpoint_destroy (_mongocrypt_endpoint_t *endpoint)
-{
-   if (!endpoint) {
-      return;
-   }
-   bson_free (endpoint->original);
-   bson_free (endpoint->protocol);
-   bson_free (endpoint->host);
-   bson_free (endpoint->port);
-   bson_free (endpoint->domain);
-   bson_free (endpoint->subdomain);
-   bson_free (endpoint->path);
-   bson_free (endpoint->query);
-   bson_free (endpoint->host_and_port);
-   bson_free (endpoint);
+void _mongocrypt_endpoint_destroy(_mongocrypt_endpoint_t *endpoint) {
+    if (!endpoint) {
+        return;
+    }
+    bson_free(endpoint->original);
+    bson_free(endpoint->protocol);
+    bson_free(endpoint->host);
+    bson_free(endpoint->port);
+    bson_free(endpoint->domain);
+    bson_free(endpoint->subdomain);
+    bson_free(endpoint->path);
+    bson_free(endpoint->query);
+    bson_free(endpoint->host_and_port);
+    bson_free(endpoint);
 }
 
 /* Parses a subset of URIs of the form:
  * [protocol://][host[:port]][path][?query]
  */
-_mongocrypt_endpoint_t *
-_mongocrypt_endpoint_new (const char *endpoint_raw,
-                          int32_t len,
-                          _mongocrypt_endpoint_parse_opts_t *opts,
-                          mongocrypt_status_t *status)
-{
-   _mongocrypt_endpoint_t *endpoint;
-   bool ok = false;
-   char *pos;
-   char *prev;
-   char *colon;
-   char *qmark;
-   char *slash;
-   char *host_start;
-   char *host_end;
-
-   /* opts is checked where it is used below, to allow a more precise error */
-
-   endpoint = bson_malloc0 (sizeof (_mongocrypt_endpoint_t));
-   _mongocrypt_status_reset (status);
-   BSON_ASSERT (endpoint);
-   if (!_mongocrypt_validate_and_copy_string (
-          endpoint_raw, len, &endpoint->original)) {
-      CLIENT_ERR ("Invalid endpoint");
-      goto fail;
-   }
-
-   /* Parse optional protocol. */
-   pos = strstr (endpoint->original, "://");
-   if (pos) {
-      endpoint->protocol =
-         bson_strndup (endpoint->original, (size_t) (pos - endpoint->original));
-      pos += 3;
-   } else {
-      pos = endpoint->original;
-   }
-   host_start = pos;
-
-   /* Parse subdomain. */
-   prev = pos;
-   pos = strstr (pos, ".");
-   if (pos) {
-      BSON_ASSERT (pos >= prev);
-      endpoint->subdomain = bson_strndup (prev, (size_t) (pos - prev));
-      pos += 1;
-   } else {
-      if (!opts || !opts->allow_empty_subdomain) {
-         CLIENT_ERR (
-            "Invalid endpoint, expected dot separator in host, but got: %s",
-            endpoint->original);
-         goto fail;
-      }
-      /* OK, reset pos to the start of the host. */
-      pos = prev;
-   }
-
-   /* Parse domain. */
-   prev = pos;
-   colon = strstr (pos, ":");
-   qmark = strstr (pos, "?");
-   slash = strstr (pos, "/");
-   if (colon) {
-      host_end = colon;
-   } else if (slash) {
-      host_end = slash;
-   } else if (qmark) {
-      host_end = qmark;
-   } else {
-      host_end = NULL;
-   }
-
-   if (host_end) {
-      BSON_ASSERT (host_end >= prev);
-      endpoint->domain = bson_strndup (prev, (size_t) (host_end - prev));
-      BSON_ASSERT (host_end >= host_start);
-      endpoint->host =
-         bson_strndup (host_start, (size_t) (host_end - host_start));
-   } else {
-      endpoint->domain = bson_strdup (prev);
-      endpoint->host = bson_strdup (host_start);
-   }
-
-   /* Parse optional port */
-   if (colon) {
-      prev = colon + 1;
-      qmark = strstr (pos, "?");
-      slash = strstr (pos, "/");
-      if (slash) {
-         endpoint->port = bson_strndup (prev, (size_t) (slash - prev));
-      } else if (qmark) {
-         BSON_ASSERT (qmark >= prev);
-         endpoint->port = bson_strndup (prev, (size_t) (qmark - prev));
-      } else {
-         endpoint->port = bson_strdup (prev);
-      }
-   }
-
-   /* Parse optional path */
-   if (slash) {
-      size_t path_len;
-
-      prev = slash + 1;
-      qmark = strstr (prev, "?");
-      if (qmark) {
-         endpoint->path = bson_strndup (prev, (size_t) (qmark - prev));
-      } else {
-         endpoint->path = bson_strdup (prev);
-      }
-
-      path_len = strlen (endpoint->path);
-      /* Clear a trailing slash if it exists. */
-      if (path_len > 0 && endpoint->path[path_len - 1] == '/') {
-         endpoint->path[path_len - 1] = '\0';
-      }
-   }
-
-   /* Parse optional query */
-   if (qmark) {
-      endpoint->query = bson_strdup (qmark + 1);
-   }
-
-   if (endpoint->port) {
-      endpoint->host_and_port =
-         bson_strdup_printf ("%s:%s", endpoint->host, endpoint->port);
-   } else {
-      endpoint->host_and_port = bson_strdup (endpoint->host);
-   }
-
-   ok = true;
+_mongocrypt_endpoint_t *_mongocrypt_endpoint_new(const char *endpoint_raw,
+                                                 int32_t len,
+                                                 _mongocrypt_endpoint_parse_opts_t *opts,
+                                                 mongocrypt_status_t *status) {
+    _mongocrypt_endpoint_t *endpoint;
+    bool ok = false;
+    char *pos;
+    char *prev;
+    char *colon;
+    char *qmark;
+    char *slash;
+    char *host_start;
+    char *host_end;
+
+    /* opts is checked where it is used below, to allow a more precise error */
+
+    endpoint = bson_malloc0(sizeof(_mongocrypt_endpoint_t));
+    _mongocrypt_status_reset(status);
+    BSON_ASSERT(endpoint);
+    if (!_mongocrypt_validate_and_copy_string(endpoint_raw, len, &endpoint->original)) {
+        CLIENT_ERR("Invalid endpoint");
+        goto fail;
+    }
+
+    /* Parse optional protocol. */
+    pos = strstr(endpoint->original, "://");
+    if (pos) {
+        endpoint->protocol = bson_strndup(endpoint->original, (size_t)(pos - endpoint->original));
+        pos += 3;
+    } else {
+        pos = endpoint->original;
+    }
+    host_start = pos;
+
+    /* Parse subdomain. */
+    prev = pos;
+    pos = strstr(pos, ".");
+    if (pos) {
+        BSON_ASSERT(pos >= prev);
+        endpoint->subdomain = bson_strndup(prev, (size_t)(pos - prev));
+        pos += 1;
+    } else {
+        if (!opts || !opts->allow_empty_subdomain) {
+            CLIENT_ERR("Invalid endpoint, expected dot separator in host, but got: %s", endpoint->original);
+            goto fail;
+        }
+        /* OK, reset pos to the start of the host. */
+        pos = prev;
+    }
+
+    /* Parse domain. */
+    prev = pos;
+    colon = strstr(pos, ":");
+    qmark = strstr(pos, "?");
+    slash = strstr(pos, "/");
+    if (colon) {
+        host_end = colon;
+    } else if (slash) {
+        host_end = slash;
+    } else if (qmark) {
+        host_end = qmark;
+    } else {
+        host_end = NULL;
+    }
+
+    if (host_end) {
+        BSON_ASSERT(host_end >= prev);
+        endpoint->domain = bson_strndup(prev, (size_t)(host_end - prev));
+        BSON_ASSERT(host_end >= host_start);
+        endpoint->host = bson_strndup(host_start, (size_t)(host_end - host_start));
+    } else {
+        endpoint->domain = bson_strdup(prev);
+        endpoint->host = bson_strdup(host_start);
+    }
+
+    /* Parse optional port */
+    if (colon) {
+        prev = colon + 1;
+        qmark = strstr(pos, "?");
+        slash = strstr(pos, "/");
+        if (slash) {
+            endpoint->port = bson_strndup(prev, (size_t)(slash - prev));
+        } else if (qmark) {
+            BSON_ASSERT(qmark >= prev);
+            endpoint->port = bson_strndup(prev, (size_t)(qmark - prev));
+        } else {
+            endpoint->port = bson_strdup(prev);
+        }
+    }
+
+    /* Parse optional path */
+    if (slash) {
+        size_t path_len;
+
+        prev = slash + 1;
+        qmark = strstr(prev, "?");
+        if (qmark) {
+            endpoint->path = bson_strndup(prev, (size_t)(qmark - prev));
+        } else {
+            endpoint->path = bson_strdup(prev);
+        }
+
+        path_len = strlen(endpoint->path);
+        /* Clear a trailing slash if it exists. */
+        if (path_len > 0 && endpoint->path[path_len - 1] == '/') {
+            endpoint->path[path_len - 1] = '\0';
+        }
+    }
+
+    /* Parse optional query */
+    if (qmark) {
+        endpoint->query = bson_strdup(qmark + 1);
+    }
+
+    if (endpoint->port) {
+        endpoint->host_and_port = bson_strdup_printf("%s:%s", endpoint->host, endpoint->port);
+    } else {
+        endpoint->host_and_port = bson_strdup(endpoint->host);
+    }
+
+    ok = true;
 fail:
-   if (!ok) {
-      _mongocrypt_endpoint_destroy (endpoint);
-      return NULL;
-   }
-   return endpoint;
+    if (!ok) {
+        _mongocrypt_endpoint_destroy(endpoint);
+        return NULL;
+    }
+    return endpoint;
 }
 
-_mongocrypt_endpoint_t *
-_mongocrypt_endpoint_copy (_mongocrypt_endpoint_t *src)
-{
-   _mongocrypt_endpoint_t *endpoint;
-
-   if (!src) {
-      return NULL;
-   }
-   endpoint = bson_malloc0 (sizeof (_mongocrypt_endpoint_t));
-   endpoint->original = bson_strdup (src->original);
-   endpoint->protocol = bson_strdup (src->protocol);
-   endpoint->host = bson_strdup (src->host);
-   endpoint->port = bson_strdup (src->port);
-   endpoint->domain = bson_strdup (src->domain);
-   endpoint->subdomain = bson_strdup (src->subdomain);
-   endpoint->path = bson_strdup (src->path);
-   endpoint->query = bson_strdup (src->query);
-   endpoint->host_and_port = bson_strdup (src->host_and_port);
-   return endpoint;
+_mongocrypt_endpoint_t *_mongocrypt_endpoint_copy(_mongocrypt_endpoint_t *src) {
+    _mongocrypt_endpoint_t *endpoint;
+
+    if (!src) {
+        return NULL;
+    }
+    endpoint = bson_malloc0(sizeof(_mongocrypt_endpoint_t));
+    endpoint->original = bson_strdup(src->original);
+    endpoint->protocol = bson_strdup(src->protocol);
+    endpoint->host = bson_strdup(src->host);
+    endpoint->port = bson_strdup(src->port);
+    endpoint->domain = bson_strdup(src->domain);
+    endpoint->subdomain = bson_strdup(src->subdomain);
+    endpoint->path = bson_strdup(src->path);
+    endpoint->query = bson_strdup(src->query);
+    endpoint->host_and_port = bson_strdup(src->host_and_port);
+    return endpoint;
 }
 
-void
-_mongocrypt_apply_default_port (char **endpoint_raw, char *port)
-{
-   BSON_ASSERT_PARAM (endpoint_raw);
-   BSON_ASSERT_PARAM (port);
-   BSON_ASSERT (*endpoint_raw);
-
-   if (strstr (*endpoint_raw, ":") == NULL) {
-      char *tmp = *endpoint_raw;
-      *endpoint_raw = bson_strdup_printf ("%s:%s", *endpoint_raw, port);
-      bson_free (tmp);
-   }
+void _mongocrypt_apply_default_port(char **endpoint_raw, char *port) {
+    BSON_ASSERT_PARAM(endpoint_raw);
+    BSON_ASSERT_PARAM(port);
+    BSON_ASSERT(*endpoint_raw);
+
+    if (strstr(*endpoint_raw, ":") == NULL) {
+        char *tmp = *endpoint_raw;
+        *endpoint_raw = bson_strdup_printf("%s:%s", *endpoint_raw, port);
+        bson_free(tmp);
+    }
 }

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

@@ -19,8 +19,8 @@
 
 #include <bson/bson.h>
 
-#include "mongocrypt.h"
 #include "mongocrypt-endpoint-private.h"
+#include "mongocrypt.h"
 
 /* Defines structs for Key Encryption Keys (KEKs)
  * The KEK is used as part of envelope encryption. It encrypts a Data Encryption
@@ -37,48 +37,53 @@
  *   kms_set |= MONGOCRYPT_KMS_PROVIDER_LOCAL
  */
 typedef enum {
-   MONGOCRYPT_KMS_PROVIDER_NONE = 0,
-   MONGOCRYPT_KMS_PROVIDER_AWS = 1 << 0,
-   MONGOCRYPT_KMS_PROVIDER_LOCAL = 1 << 1,
-   MONGOCRYPT_KMS_PROVIDER_AZURE = 1 << 2,
-   MONGOCRYPT_KMS_PROVIDER_GCP = 1 << 3,
-   MONGOCRYPT_KMS_PROVIDER_KMIP = 1 << 4
+    MONGOCRYPT_KMS_PROVIDER_NONE = 0,
+    MONGOCRYPT_KMS_PROVIDER_AWS = 1 << 0,
+    MONGOCRYPT_KMS_PROVIDER_LOCAL = 1 << 1,
+    MONGOCRYPT_KMS_PROVIDER_AZURE = 1 << 2,
+    MONGOCRYPT_KMS_PROVIDER_GCP = 1 << 3,
+    MONGOCRYPT_KMS_PROVIDER_KMIP = 1 << 4
 } _mongocrypt_kms_provider_t;
 
 typedef struct {
-   _mongocrypt_endpoint_t *key_vault_endpoint;
-   char *key_name;
-   char *key_version;
+    _mongocrypt_endpoint_t *key_vault_endpoint;
+    char *key_name;
+    char *key_version;
 } _mongocrypt_azure_kek_t;
 
 typedef struct {
-   char *project_id;
-   char *location;
-   char *key_ring;
-   char *key_name;
-   char *key_version;                /* optional */
-   _mongocrypt_endpoint_t *endpoint; /* optional. */
+    char *project_id;
+    char *location;
+    char *key_ring;
+    char *key_name;
+    char *key_version;                /* optional */
+    _mongocrypt_endpoint_t *endpoint; /* optional. */
 } _mongocrypt_gcp_kek_t;
 
 typedef struct {
-   char *region;
-   char *cmk;
-   _mongocrypt_endpoint_t *endpoint; /* optional. */
+    char *region;
+    char *cmk;
+    _mongocrypt_endpoint_t *endpoint; /* optional. */
 } _mongocrypt_aws_kek_t;
 
 typedef struct {
-   char *key_id; /* optional on parsing, required on appending. */
-   _mongocrypt_endpoint_t *endpoint; /* optional. */
+    char *key_id;                     /* optional on parsing, required on appending. */
+    _mongocrypt_endpoint_t *endpoint; /* optional. */
+    bool delegated;
 } _mongocrypt_kmip_kek_t;
 
 typedef struct {
-   _mongocrypt_kms_provider_t kms_provider;
-   union {
-      _mongocrypt_azure_kek_t azure;
-      _mongocrypt_gcp_kek_t gcp;
-      _mongocrypt_aws_kek_t aws;
-      _mongocrypt_kmip_kek_t kmip;
-   } provider;
+    _mongocrypt_kms_provider_t kms_provider;
+
+    union {
+        _mongocrypt_azure_kek_t azure;
+        _mongocrypt_gcp_kek_t gcp;
+        _mongocrypt_aws_kek_t aws;
+        _mongocrypt_kmip_kek_t kmip;
+    } provider;
+
+    char *kmsid;
+    const char *kmsid_name;
 } _mongocrypt_kek_t;
 
 /* Parse a document describing a key encryption key.
@@ -87,23 +92,16 @@ typedef struct {
  * mongocrypt_ctx_setopt_key_encryption_key
  * 2. The "masterKey" document from a data encryption key document.
  */
-bool
-_mongocrypt_kek_parse_owned (const bson_t *bson,
-                             _mongocrypt_kek_t *out,
-                             mongocrypt_status_t *status)
-   MONGOCRYPT_WARN_UNUSED_RESULT;
-
-bool
-_mongocrypt_kek_append (const _mongocrypt_kek_t *kek,
-                        bson_t *out,
-                        mongocrypt_status_t *status)
-   MONGOCRYPT_WARN_UNUSED_RESULT;
+bool _mongocrypt_kek_parse_owned(const bson_t *bson,
+                                 _mongocrypt_kek_t *out,
+                                 mongocrypt_status_t *status) MONGOCRYPT_WARN_UNUSED_RESULT;
 
-void
-_mongocrypt_kek_copy_to (const _mongocrypt_kek_t *src, _mongocrypt_kek_t *dst);
+bool _mongocrypt_kek_append(const _mongocrypt_kek_t *kek,
+                            bson_t *out,
+                            mongocrypt_status_t *status) MONGOCRYPT_WARN_UNUSED_RESULT;
 
-void
-_mongocrypt_kek_cleanup (_mongocrypt_kek_t *kek);
+void _mongocrypt_kek_copy_to(const _mongocrypt_kek_t *src, _mongocrypt_kek_t *dst);
 
+void _mongocrypt_kek_cleanup(_mongocrypt_kek_t *kek);
 
-#endif /* MONGOCRYPT_KEK_PRIVATE_H */
+#endif /* MONGOCRYPT_KEK_PRIVATE_H */