CDRIVER-4599 Reducing Warnings - MSVC and MinGW Compilation Warnings

src/libbson/tests/test-bson.c

@@ -2474,7 +2474,6 @@ static void
 test_bson_as_json_string (void)
 {
    bson_t *all_types;
-   int i;
    char *actual;
    const char *expected =
       "{ \"double\" : { \"$numberDouble\" : \"1.0\" }, \"string\" : "
@@ -2498,9 +2497,9 @@ test_bson_as_json_string (void)
    all_types = bson_with_all_types ();
    actual = bson_as_canonical_extended_json (all_types, NULL);
 
-   for (i = 0; i < strlen (expected); i++) {
+   for (size_t i = 0u; i < strlen (expected); i++) {
       if (expected[i] != actual[i]) {
-         test_error ("character mismatch at %d. Expected: %s, got %s",
+         test_error ("character mismatch at %zu. Expected: %s, got %s",
                      i,
                      expected,
                      actual);

src/libmongoc/CMakeLists.txt

@@ -1011,6 +1011,13 @@ endif ()
 
 if (ENABLE_TESTS)
    add_library (test-libmongoc-lib STATIC ${test-libmongoc-sources})
+   if (MSVC AND MSVC_VERSION VERSION_LESS 1900)
+      message (STATUS "Disabling warning C4756 for VS 2013 and older")
+      # Macro constant INFINITY triggers constant arithmetic overflow warnings in
+      # VS 2013, but VS 2013 doesn't support inline warning suppression.
+      # Remove once support for VS 2013 is dropped.
+      target_compile_options(test-libmongoc-lib PRIVATE /wd4756)
+   endif ()
    target_link_libraries (test-libmongoc-lib PUBLIC mongoc_static)
    # We have tests that test our deprecated api.
    target_compile_options (test-libmongoc-lib

src/libmongoc/examples/client-side-encryption-auto-decryption.c

@@ -166,6 +166,9 @@ main (void)
       goto fail;
    }
 
+   const size_t len = strlen (to_encrypt.value.v_utf8.str);
+   BSON_ASSERT (bson_in_range_unsigned (uint32_t, len));
+
    /* Explicitly encrypt a field. */
    encrypt_opts = mongoc_client_encryption_encrypt_opts_new ();
    mongoc_client_encryption_encrypt_opts_set_algorithm (
@@ -174,7 +177,7 @@ main (void)
       encrypt_opts, "mongoc_encryption_example_4");
    to_encrypt.value_type = BSON_TYPE_UTF8;
    to_encrypt.value.v_utf8.str = "123456789";
-   to_encrypt.value.v_utf8.len = strlen (to_encrypt.value.v_utf8.str);
+   to_encrypt.value.v_utf8.len = (uint32_t) len;
 
    ret = mongoc_client_encryption_encrypt (
       client_encryption, &to_encrypt, encrypt_opts, &encrypted_field, &error);

src/libmongoc/examples/client-side-encryption-explicit.c

@@ -138,14 +138,17 @@ main (void)
       goto fail;
    }
 
+   const size_t len = strlen (to_encrypt.value.v_utf8.str);
+   BSON_ASSERT (bson_in_range_unsigned (uint32_t, len));
+
    /* Explicitly encrypt a field */
    encrypt_opts = mongoc_client_encryption_encrypt_opts_new ();
    mongoc_client_encryption_encrypt_opts_set_algorithm (
       encrypt_opts, MONGOC_AEAD_AES_256_CBC_HMAC_SHA_512_DETERMINISTIC);
    mongoc_client_encryption_encrypt_opts_set_keyid (encrypt_opts, &datakey_id);
    to_encrypt.value_type = BSON_TYPE_UTF8;
    to_encrypt.value.v_utf8.str = "123456789";
-   to_encrypt.value.v_utf8.len = strlen (to_encrypt.value.v_utf8.str);
+   to_encrypt.value.v_utf8.len = (uint32_t) len;
 
    ret = mongoc_client_encryption_encrypt (
       client_encryption, &to_encrypt, encrypt_opts, &encrypted_field, &error);

src/libmongoc/examples/client-side-encryption-helpers.c

@@ -3,26 +3,24 @@
 uint8_t *
 hex_to_bin (const char *hex, uint32_t *len)
 {
-   int i;
-   int hex_len;
-   uint8_t *out;
-
-   hex_len = strlen (hex);
+   const size_t hex_len = strlen (hex);
    if (hex_len % 2 != 0) {
       return NULL;
    }
 
-   *len = hex_len / 2;
-   out = bson_malloc0 (*len);
+   BSON_ASSERT (bson_in_range_unsigned (uint32_t, hex_len / 2u));
+
+   *len = (uint32_t) (hex_len / 2u);
+   uint8_t *const out = bson_malloc0 (*len);
 
-   for (i = 0; i < hex_len; i += 2) {
+   for (size_t i = 0u; i < hex_len; i += 2u) {
       uint32_t hex_char;
 
       if (1 != sscanf (hex + i, "%2x", &hex_char)) {
          bson_free (out);
          return NULL;
       }
-      out[i / 2] = (uint8_t) hex_char;
+      out[i / 2u] = (uint8_t) hex_char;
    }
    return out;
 }

src/libmongoc/src/mongoc/mcd-azure.c

@@ -62,7 +62,7 @@ mcd_azure_imds_request_destroy (mcd_azure_imds_request *req)
    bson_free (req->_owned_path);
    bson_free (req->_owned_host);
    bson_free (req->_owned_headers);
-   *req = (mcd_azure_imds_request){0};
+   *req = MCD_AZURE_IMDS_REQUEST_INIT;
 }
 
 bool
@@ -175,7 +175,7 @@ mcd_azure_access_token_from_imds (mcd_azure_access_token *const out,
    mongoc_http_response_t resp;
    _mongoc_http_response_init (&resp);
 
-   mcd_azure_imds_request req = {0};
+   mcd_azure_imds_request req = MCD_AZURE_IMDS_REQUEST_INIT;
    mcd_azure_imds_request_init (
       &req, opt_imds_host, opt_port, opt_extra_headers);
 

src/libmongoc/src/mongoc/mcd-azure.h

@@ -80,6 +80,13 @@ typedef struct mcd_azure_imds_request {
    char *_owned_headers;
 } mcd_azure_imds_request;
 
+#define MCD_AZURE_IMDS_REQUEST_INIT                         \
+   (mcd_azure_imds_request)                                 \
+   {                                                        \
+      .req = {0}, ._owned_path = NULL, ._owned_host = NULL, \
+      ._owned_headers = NULL,                               \
+   }
+
 /**
  * @brief Initialize a new IMDS HTTP request
  *
@@ -92,10 +99,10 @@ typedef struct mcd_azure_imds_request {
  * @note Currently only supports the vault.azure.net resource
  */
 void
-mcd_azure_imds_request_init (mcd_azure_imds_request *out,
-                             const char *opt_imds_host,
+mcd_azure_imds_request_init (mcd_azure_imds_request *req,
+                             const char *const opt_imds_host,
                              int opt_port,
-                             const char *opt_extra_headers);
+                             const char *const opt_extra_headers);
 
 /**
  * @brief Destroy an IMDS request created with mcd_azure_imds_request_init()
@@ -121,8 +128,8 @@ mcd_azure_imds_request_destroy (mcd_azure_imds_request *req);
  * @note Currently only supports the vault.azure.net resource
  */
 bool
-mcd_azure_access_token_from_imds (mcd_azure_access_token *out,
-                                  const char *opt_imds_host,
+mcd_azure_access_token_from_imds (mcd_azure_access_token *const out,
+                                  const char *const opt_imds_host,
                                   int opt_port,
                                   const char *opt_extra_headers,
                                   bson_error_t *error);

src/libmongoc/src/mongoc/mongoc-async-cmd.c

@@ -311,13 +311,12 @@ _mongoc_async_cmd_phase_send (mongoc_async_cmd_t *acmd)
    size_t total_bytes = 0;
    size_t offset;
    ssize_t bytes;
-   int i;
    /* if a continued write, then iovec will be set to a temporary copy */
    bool used_temp_iovec = false;
    mongoc_iovec_t *iovec = acmd->iovec;
    size_t niovec = acmd->niovec;
 
-   for (i = 0; i < acmd->niovec; i++) {
+   for (size_t i = 0u; i < acmd->niovec; i++) {
       total_bytes += acmd->iovec[i].iov_len;
    }
 
@@ -327,8 +326,10 @@ _mongoc_async_cmd_phase_send (mongoc_async_cmd_t *acmd)
        * iovec entry to be written. */
       offset = acmd->bytes_written;
 
+      size_t i = 0u;
+
       /* subtract the lengths of all iovec entries written so far. */
-      for (i = 0; i < acmd->niovec; i++) {
+      for (i = 0u; i < acmd->niovec; i++) {
          if (offset < acmd->iovec[i].iov_len) {
             break;
          }

src/libmongoc/src/mongoc/mongoc-buffer-private.h

@@ -55,20 +55,20 @@ bool
 _mongoc_buffer_append_from_stream (mongoc_buffer_t *buffer,
                                    mongoc_stream_t *stream,
                                    size_t size,
-                                   int32_t timeout_msec,
+                                   int64_t timeout_msec,
                                    bson_error_t *error);
 
 ssize_t
 _mongoc_buffer_try_append_from_stream (mongoc_buffer_t *buffer,
                                        mongoc_stream_t *stream,
                                        size_t size,
-                                       int32_t timeout_msec);
+                                       int64_t timeout_msec);
 
 ssize_t
 _mongoc_buffer_fill (mongoc_buffer_t *buffer,
                      mongoc_stream_t *stream,
                      size_t min_bytes,
-                     int32_t timeout_msec,
+                     int64_t timeout_msec,
                      bson_error_t *error);
 
 void

src/libmongoc/src/mongoc/mongoc-buffer.c

@@ -172,7 +172,7 @@ bool
 _mongoc_buffer_append_from_stream (mongoc_buffer_t *buffer,
                                    mongoc_stream_t *stream,
                                    size_t size,
-                                   int32_t timeout_msec,
+                                   int64_t timeout_msec,
                                    bson_error_t *error)
 {
    uint8_t *buf;
@@ -197,18 +197,28 @@ _mongoc_buffer_append_from_stream (mongoc_buffer_t *buffer,
 
    BSON_ASSERT ((buffer->len + size) <= buffer->datalen);
 
-   ret = mongoc_stream_read (stream, buf, size, size, timeout_msec);
-   if (ret != size) {
+   if (BSON_UNLIKELY (!bson_in_range_signed (int32_t, timeout_msec))) {
+      // CDRIVER-4589
       bson_set_error (error,
                       MONGOC_ERROR_STREAM,
                       MONGOC_ERROR_STREAM_SOCKET,
-                      "Failed to read %" PRIu64
-                      " bytes: socket error or timeout",
-                      (uint64_t) size);
+                      "timeout_msec value %" PRIu64
+                      " exceeds supported 32-bit range",
+                      timeout_msec);
       RETURN (false);
    }
 
-   buffer->len += ret;
+   ret = mongoc_stream_read (stream, buf, size, size, (int32_t) timeout_msec);
+   if (bson_cmp_not_equal_su (ret, size)) {
+      bson_set_error (error,
+                      MONGOC_ERROR_STREAM,
+                      MONGOC_ERROR_STREAM_SOCKET,
+                      "Failed to read %zu bytes: socket error or timeout",
+                      size);
+      RETURN (false);
+   }
+
+   buffer->len += (size_t) ret;
 
    RETURN (true);
 }
@@ -229,7 +239,7 @@ ssize_t
 _mongoc_buffer_fill (mongoc_buffer_t *buffer,
                      mongoc_stream_t *stream,
                      size_t min_bytes,
-                     int32_t timeout_msec,
+                     int64_t timeout_msec,
                      bson_error_t *error)
 {
    ssize_t ret;
@@ -244,7 +254,8 @@ _mongoc_buffer_fill (mongoc_buffer_t *buffer,
    BSON_ASSERT (buffer->datalen);
 
    if (min_bytes <= buffer->len) {
-      RETURN (buffer->len);
+      BSON_ASSERT (bson_in_range_unsigned (ssize_t, buffer->len));
+      RETURN ((ssize_t) buffer->len);
    }
 
    min_bytes -= buffer->len;
@@ -257,31 +268,46 @@ _mongoc_buffer_fill (mongoc_buffer_t *buffer,
 
    avail_bytes = buffer->datalen - buffer->len;
 
-   ret = mongoc_stream_read (
-      stream, &buffer->data[buffer->len], avail_bytes, min_bytes, timeout_msec);
+   if (BSON_UNLIKELY (!bson_in_range_signed (int32_t, timeout_msec))) {
+      // CDRIVER-4589
+      bson_set_error (error,
+                      MONGOC_ERROR_STREAM,
+                      MONGOC_ERROR_STREAM_SOCKET,
+                      "timeout_msec value %" PRIu64
+                      " exceeds supported 32-bit range",
+                      timeout_msec);
+      RETURN (false);
+   }
+
+   ret = mongoc_stream_read (stream,
+                             &buffer->data[buffer->len],
+                             avail_bytes,
+                             min_bytes,
+                             (int32_t) timeout_msec);
 
-   if (ret == -1) {
+   if (ret < 0) {
       bson_set_error (error,
                       MONGOC_ERROR_STREAM,
                       MONGOC_ERROR_STREAM_SOCKET,
-                      "Failed to buffer %u bytes",
-                      (unsigned) min_bytes);
+                      "Failed to buffer %zu bytes",
+                      min_bytes);
       RETURN (-1);
    }
 
-   buffer->len += ret;
+   buffer->len += (size_t) ret;
 
    if (buffer->len < min_bytes) {
       bson_set_error (error,
                       MONGOC_ERROR_STREAM,
                       MONGOC_ERROR_STREAM_SOCKET,
-                      "Could only buffer %u of %u bytes",
-                      (unsigned) buffer->len,
-                      (unsigned) min_bytes);
+                      "Could only buffer %zu of %zu bytes",
+                      buffer->len,
+                      min_bytes);
       RETURN (-1);
    }
 
-   RETURN (buffer->len);
+   BSON_ASSERT (bson_in_range_unsigned (ssize_t, buffer->len));
+   RETURN ((ssize_t) buffer->len);
 }
 
 
@@ -302,7 +328,7 @@ ssize_t
 _mongoc_buffer_try_append_from_stream (mongoc_buffer_t *buffer,
                                        mongoc_stream_t *stream,
                                        size_t size,
-                                       int32_t timeout_msec)
+                                       int64_t timeout_msec)
 {
    uint8_t *buf;
    ssize_t ret;
@@ -326,10 +352,18 @@ _mongoc_buffer_try_append_from_stream (mongoc_buffer_t *buffer,
 
    BSON_ASSERT ((buffer->len + size) <= buffer->datalen);
 
-   ret = mongoc_stream_read (stream, buf, size, 0, timeout_msec);
+   if (BSON_UNLIKELY (!bson_in_range_signed (int32_t, timeout_msec))) {
+      // CDRIVER-4589
+      MONGOC_ERROR ("timeout_msec value %" PRIu64
+                    " exceeds supported 32-bit range",
+                    timeout_msec);
+      RETURN (-1);
+   }
+
+   ret = mongoc_stream_read (stream, buf, size, 0, (int32_t) timeout_msec);
 
    if (ret > 0) {
-      buffer->len += ret;
+      buffer->len += (size_t) ret;
    }
 
    RETURN (ret);

src/libmongoc/src/mongoc/mongoc-bulk-operation.c

@@ -93,10 +93,9 @@ void
 mongoc_bulk_operation_destroy (mongoc_bulk_operation_t *bulk) /* IN */
 {
    mongoc_write_command_t *command;
-   int i;
 
    if (bulk) {
-      for (i = 0; i < bulk->commands.len; i++) {
+      for (size_t i = 0; i < bulk->commands.len; i++) {
          command =
             &_mongoc_array_index (&bulk->commands, mongoc_write_command_t, i);
          _mongoc_write_command_destroy (command);
@@ -750,7 +749,6 @@ mongoc_bulk_operation_execute (mongoc_bulk_operation_t *bulk, /* IN */
    mongoc_server_stream_t *server_stream;
    bool ret;
    uint32_t offset = 0;
-   int i;
 
    ENTRY;
 
@@ -807,7 +805,7 @@ mongoc_bulk_operation_execute (mongoc_bulk_operation_t *bulk, /* IN */
       GOTO (err);
    }
 
-   for (i = 0; i < bulk->commands.len; i++) {
+   for (size_t i = 0u; i < bulk->commands.len; i++) {
       if (bulk->server_id) {
          server_stream =
             mongoc_cluster_stream_for_server (cluster,