MB-27661 [11/n]: Fix MSVC warnings - C4267

This patch addresses the following generated warnings:

C4267 - var : conversion from 'size_t' to 'type', possible loss of data
        The compiler detected a conversion from size_t to a smaller type.

This is the second and final commit addressing this error.

Change-Id: If23806c43a2024df2d4103f1b40cbd790957f1f0
Reviewed-on: http://review.couchbase.org/90604
Reviewed-by: Dave Rigby <[email protected]>
Tested-by: Build Bot <[email protected]>

Author: Tim Bradgate

cbsasl/sasl_server_test.cc

@@ -24,6 +24,7 @@
 #include <string.h>
 #include <algorithm>
 #include <array>
+#include <gsl/gsl>
 
 char envptr[1024]{"CBSASL_PWFILE=" SOURCE_ROOT "/cbsasl/sasl_server_test.json"};
 
@@ -40,7 +41,7 @@ static int sasl_getopt_callback(void*,
 
     if (strcmp(option, "sasl mechanisms") == 0) {
         *result = mechanisms.c_str();
-        *len = mechanisms.length();
+        *len = gsl::narrow<unsigned>(mechanisms.length());
         return CBSASL_OK;
     }
 

cbsasl/scram-sha/scram-sha.cc

@@ -56,7 +56,7 @@ static std::string hex_encode_nonce(const std::array<char, 8>& nonce) {
  */
 static bool decodeAttributeList(cbsasl_conn_t& conn, const std::string& list,
                                 AttributeMap& attributes) {
-    unsigned long pos = 0;
+    size_t pos = 0;
 
     logging::log(conn,
                  logging::Level::Debug,
@@ -502,7 +502,7 @@ cbsasl_error_t ScramShaServerBackend::step(const char* input,
 
     server_final_message = out.str();
     (*output) = server_final_message.data();
-    (*outputlen) = server_final_message.length();
+    (*outputlen) = gsl::narrow<unsigned>(server_final_message.length());
 
     std::string clientproof = iter->second;
     std::string my_clientproof = Couchbase::Base64::encode(getClientProof());
@@ -713,7 +713,7 @@ cbsasl_error_t ScramShaClientBackend::step(const char* input,
         client_final_message = out.str();
 
         *output = client_final_message.data();
-        *outputlen = client_final_message.length();
+        *outputlen = gsl::narrow<unsigned>(client_final_message.length());
         logging::log(conn, logging::Level::Trace, client_final_message);
         return CBSASL_CONTINUE;
     } else {

daemon/connection_mcbp.cc

@@ -33,6 +33,7 @@
 #include <utilities/protocol2text.h>
 #include <cctype>
 #include <exception>
+#include <gsl/gsl>
 
 bool McbpConnection::unregisterEvent() {
     if (!registered_in_libevent) {

daemon/ssl_context_openssl.cc

@@ -134,10 +134,11 @@ void SslContext::disable() {
 bool SslContext::drainInputSocketBuf() {
     if (!inputPipe.empty()) {
         auto* bio = network;
-        auto n = inputPipe.consume(
-            [bio](cb::const_byte_buffer data) -> ssize_t {
-                return BIO_write(bio, data.data(), data.size());
-            });
+        auto n =
+                inputPipe.consume([bio](cb::const_byte_buffer data) -> ssize_t {
+                    return BIO_write(
+                            bio, data.data(), gsl::narrow<int>(data.size()));
+                });
 
         if (n > 0) {
             // We did move some data
@@ -229,7 +230,8 @@ void SslContext::drainBioSendPipe(SOCKET sfd) {
         if (!outputPipe.full()) {
             auto* bio = network;
             auto n = outputPipe.produce([bio](cb::byte_buffer data) -> ssize_t {
-                return BIO_read(bio, data.data(), data.size());
+                return BIO_read(
+                        bio, data.data(), gsl::narrow<int>(data.size()));
             });
 
             if (n > 0) {

daemon/statemachine_mcbp.cc

@@ -26,6 +26,7 @@
 
 #include <mcbp/mcbp.h>
 #include <platform/strerror.h>
+#include <gsl/gsl>
 
 static bool conn_new_cmd(McbpConnection& connection);
 static bool conn_waiting(McbpConnection& connection);
@@ -372,7 +373,7 @@ bool conn_execute(McbpConnection& connection) {
             throw std::logic_error(
                     "conn_execute: Not enough data in input buffer");
         }
-        return size;
+        return gsl::narrow<ssize_t>(size);
     });
 
     return true;

daemon/stdin_check.cc

@@ -19,7 +19,7 @@ std::function<void()> exit_function;
 
 static char* get_command(char* buffer, size_t buffsize) {
 #ifdef WIN32
-    if (fgets(buffer, buffsize, stdin) == NULL) {
+    if (fgets(buffer, gsl::narrow<int>(buffsize), stdin) == NULL) {
         return NULL;
     }
     return buffer;

daemon/subdocument.cc

@@ -37,6 +37,7 @@
 #include <memcached/types.h>
 #include <platform/histogram.h>
 #include <xattr/blob.h>
+#include <gsl/gsl>
 
 static const std::array<SubdocCmdContext::Phase, 2> phases{{SubdocCmdContext::Phase::XATTR,
                                                             SubdocCmdContext::Phase::Body}};
@@ -67,10 +68,14 @@ static ENGINE_ERROR_CODE subdoc_update(SubdocCmdContext& context,
 static void subdoc_response(Cookie& cookie, SubdocCmdContext& context);
 
 // Debug - print details of the specified subdocument command.
-static void subdoc_print_command(Connection& c, protocol_binary_command cmd,
-                                 const char* key, const uint16_t keylen,
-                                 const char* path, const uint16_t pathlen,
-                                 const char* value, const uint32_t vallen) {
+static void subdoc_print_command(Connection& c,
+                                 protocol_binary_command cmd,
+                                 const char* key,
+                                 const uint16_t keylen,
+                                 const char* path,
+                                 const size_t pathlen,
+                                 const char* value,
+                                 const size_t vallen) {
     char clean_key[KEY_MAX_LENGTH + 32];
     char clean_path[SUBDOC_PATH_MAX_LENGTH];
     char clean_value[80]; // only print the first few characters of the value.
@@ -1406,7 +1411,8 @@ static size_t encode_multi_mutation_result_spec(uint8_t index,
     // Also encode resultlen if status is success.
     if (op.status == PROTOCOL_BINARY_RESPONSE_SUCCESS) {
         const auto& mloc = op.result.matchloc();
-        *reinterpret_cast<uint32_t*>(cursor) = htonl(mloc.length);
+        *reinterpret_cast<uint32_t*>(cursor) =
+                htonl(gsl::narrow<uint32_t>(mloc.length));
         cursor += sizeof(uint32_t);
     }
     return cursor - buffer;
@@ -1534,20 +1540,21 @@ static void subdoc_multi_mutation_response(Cookie& cookie,
     }
 
     // Allocated required resource - build the header.
-    mcbp_add_header(cookie,
-                    status_code,
-                    extlen,
-                    /*keylen*/ 0,
-                    extlen + response_buf_needed + iov_len,
-                    PROTOCOL_BINARY_RAW_BYTES);
+    mcbp_add_header(
+            cookie,
+            status_code,
+            gsl::narrow<uint8_t>(extlen),
+            /*keylen*/ 0,
+            gsl::narrow<uint32_t>(extlen + response_buf_needed + iov_len),
+            PROTOCOL_BINARY_RAW_BYTES);
 
     // Append extras if requested.
     if (extlen > 0) {
         connection.addIov(reinterpret_cast<void*>(extras_ptr), extlen);
     }
 
     // Append the iovecs for each operation result.
-    size_t index = 0;
+    uint8_t index = 0;
     for (auto phase : phases) {
         for (size_t ii = 0; ii < context.getOperations(phase).size(); ii++, index++) {
             const auto& op = context.getOperations(phase)[ii];
@@ -1557,7 +1564,7 @@ static void subdoc_multi_mutation_response(Cookie& cookie,
                 if (op.traits.responseHasValue() && mloc.length > 0) {
                     char* header = response_buf.getCurrent();
                     size_t header_sz =
-                        encode_multi_mutation_result_spec(index, op, header);
+                            encode_multi_mutation_result_spec(index, op, header);
 
                     connection.addIov(reinterpret_cast<void*>(header),
                                       header_sz);
@@ -1570,7 +1577,7 @@ static void subdoc_multi_mutation_response(Cookie& cookie,
                 if (op.status != PROTOCOL_BINARY_RESPONSE_SUCCESS) {
                     char* header = response_buf.getCurrent();
                     size_t header_sz =
-                        encode_multi_mutation_result_spec(index, op, header);
+                            encode_multi_mutation_result_spec(index, op, header);
 
                     connection.addIov(reinterpret_cast<void*>(header),
                                       header_sz);
@@ -1641,7 +1648,7 @@ static void subdoc_multi_lookup_response(Cookie& cookie,
                     status_code,
                     /*extlen*/ 0, /*keylen*/
                     0,
-                    context.response_val_len,
+                    gsl::narrow<uint32_t>(context.response_val_len),
                     PROTOCOL_BINARY_RAW_BYTES);
 
     // Append the iovecs for each operation result.

daemon/timing_histogram.cc

@@ -24,6 +24,7 @@
 #include <atomic>
 #include <chrono>
 #include <functional>
+#include <gsl/gsl>
 #include <sstream>
 #include <string>
 
@@ -161,7 +162,7 @@ std::string TimingHistogram::to_string(void) {
     size_t len = msec.size();
     // element 0 isn't used
     for (size_t ii = 1; ii < len; ii++) {
-        cJSON *obj = cJSON_CreateNumber(get_msec(ii));
+        cJSON* obj = cJSON_CreateNumber(get_msec(gsl::narrow<uint8_t>(ii)));
         cJSON_AddItemToArray(array, obj);
     }
     cJSON_AddItemToObject(root, "ms", array);

daemon/topkeys.cc

@@ -17,13 +17,14 @@
 
 #include "config.h"
 
+#include <inttypes.h>
+#include <platform/platform.h>
+#include <stdlib.h>
+#include <sys/types.h>
 #include <algorithm>
 #include <cstring>
-#include <sys/types.h>
+#include <gsl/gsl>
 #include <stdexcept>
-#include <stdlib.h>
-#include <inttypes.h>
-#include <platform/platform.h>
 
 #include "topkeys.h"
 
@@ -221,7 +222,11 @@ static void tk_iterfunc(const std::string& key, const topkey_item_t& it,
                         ",atime=%" PRIu32, it.ti_access_count,
                         created_time, created_time);
     if (vlen > 0 && vlen < int(sizeof(val_str) - 1)) {
-        c->add_stat(key.c_str(), key.size(), val_str, vlen, c->cookie);
+        c->add_stat(key.c_str(),
+                    gsl::narrow<uint16_t>(key.size()),
+                    val_str,
+                    vlen,
+                    c->cookie);
     }
 }
 

engines/default_engine/items.cc

@@ -1,12 +1,13 @@
 /* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
 #include "config.h"
-#include <fcntl.h>
 #include <errno.h>
-#include <stdlib.h>
+#include <fcntl.h>
+#include <inttypes.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 #include <time.h>
-#include <inttypes.h>
+#include <gsl/gsl>
 
 #include <logger/logger.h>
 #include <memcached/server_api.h>
@@ -1231,8 +1232,7 @@ static bool hash_key_create(hash_key* hkey,
                             const size_t nkey,
                             struct default_engine* engine,
                             const void* cookie) {
-
-    int hash_key_len = sizeof(bucket_id_t) + nkey;
+    uint16_t hash_key_len = gsl::narrow<uint16_t>(sizeof(bucket_id_t) + nkey);
     if (nkey > sizeof(hkey->key_storage.client_key)) {
         hkey->header.full_key =
             static_cast<hash_key_data*>(cb_malloc(hash_key_len));