SWIFT-1567 Vendor libmongoc 1.22.0-beta0 (#761)

Author: patrickfreed

Sources/CLibMongoC/bson/bson-decimal128.c

@@ -542,7 +542,7 @@ bson_decimal128_from_string_w_len (const char *string,     /* IN */
          continue;
       }
 
-      if (ndigits_stored < 34) {
+      if (ndigits_stored < BSON_DECIMAL128_MAX_DIGITS) {
          if (*str_read != '0' || found_nonzero) {
             if (!found_nonzero) {
                first_nonzero = ndigits_read;
@@ -634,7 +634,7 @@ bson_decimal128_from_string_w_len (const char *string,     /* IN */
       /* Shift exponent to significand and decrease */
       last_digit++;
 
-      if (last_digit - first_digit > BSON_DECIMAL128_MAX_DIGITS) {
+      if (last_digit - first_digit >= BSON_DECIMAL128_MAX_DIGITS) {
          /* The exponent is too great to shift into the significand. */
          if (significant_digits == 0) {
             /* Value is zero, we are allowed to clamp the exponent. */

Sources/CLibMongoC/bson/bson-iter.c

@@ -1894,8 +1894,8 @@ bson_iter_visit_all (bson_iter_t *iter,             /* INOUT */
                      const bson_visitor_t *visitor, /* IN */
                      void *data)                    /* IN */
 {
-   uint32_t bson_type;
-   const char *key;
+   uint32_t bson_type = 0;
+   const char *key = NULL;
    bool unsupported;
 
    BSON_ASSERT (iter);

Sources/CLibMongoC/bson/bson-json.c

@@ -870,7 +870,7 @@ _bson_json_parse_binary_elem (bson_json_reader_t *reader,
 
    if (bs == BSON_JSON_LF_BINARY) {
       data->binary.has_binary = true;
-      binary_len = COMMON_PREFIX (bson_b64_pton (val_w_null, NULL, 0));
+      binary_len = mcommon_b64_pton (val_w_null, NULL, 0);
       if (binary_len < 0) {
          _bson_json_read_set_error (
             reader,
@@ -879,9 +879,9 @@ _bson_json_parse_binary_elem (bson_json_reader_t *reader,
       }
 
       _bson_json_buf_ensure (&bson->bson_type_buf[0], (size_t) binary_len + 1);
-      if (COMMON_PREFIX (bson_b64_pton (val_w_null,
-                                        bson->bson_type_buf[0].buf,
-                                        (size_t) binary_len + 1) < 0)) {
+      if (mcommon_b64_pton (val_w_null,
+                            bson->bson_type_buf[0].buf,
+                            (size_t) binary_len + 1) < 0) {
          _bson_json_read_set_error (
             reader,
             "Invalid input string \"%s\", looking for base64-encoded binary",
@@ -1178,18 +1178,59 @@ _bson_json_read_start_map (bson_json_reader_t *reader) /* IN */
    BASIC_CB_PREAMBLE;
 
    if (bson->read_state == BSON_JSON_IN_BSON_TYPE) {
-      if (bson->bson_state == BSON_JSON_LF_DATE) {
+      switch (bson->bson_state) {
+      case BSON_JSON_LF_DATE:
          bson->read_state = BSON_JSON_IN_BSON_TYPE_DATE_NUMBERLONG;
-      } else if (bson->bson_state == BSON_JSON_LF_BINARY) {
+         break;
+      case BSON_JSON_LF_BINARY:
          bson->read_state = BSON_JSON_IN_BSON_TYPE_BINARY_VALUES;
-      } else if (bson->bson_state == BSON_JSON_LF_TYPE) {
+         break;
+      case BSON_JSON_LF_TYPE:
          /* special case, we started parsing {$type: {$numberInt: "2"}} and we
           * expected a legacy Binary format. now we see the second "{", so
           * backtrack and parse $type query operator. */
          bson->read_state = BSON_JSON_IN_START_MAP;
          STACK_PUSH_DOC (bson_append_document_begin (
             STACK_BSON_PARENT, key, len, STACK_BSON_CHILD));
          _bson_json_save_map_key (bson, (const uint8_t *) "$type", 5);
+         break;
+      case BSON_JSON_LF_CODE:
+      case BSON_JSON_LF_DECIMAL128:
+      case BSON_JSON_LF_DOUBLE:
+      case BSON_JSON_LF_INT32:
+      case BSON_JSON_LF_INT64:
+      case BSON_JSON_LF_MAXKEY:
+      case BSON_JSON_LF_MINKEY:
+      case BSON_JSON_LF_OID:
+      case BSON_JSON_LF_OPTIONS:
+      case BSON_JSON_LF_REGEX:
+      /**
+       * NOTE: A read_state of BSON_JSON_IN_BSON_TYPE is used when "$regex" is
+       * found, but BSON_JSON_IN_BSON_TYPE_REGEX_STARTMAP is used for
+       * "$regularExpression", which will instead go to a below 'if else' branch
+       * instead of this switch statement. They're both called "regex" in their
+       * respective enumerators, but they behave differently when parsing.
+       */
+      // fallthrough
+      case BSON_JSON_LF_REGULAR_EXPRESSION_OPTIONS:
+      case BSON_JSON_LF_REGULAR_EXPRESSION_PATTERN:
+      case BSON_JSON_LF_SYMBOL:
+      case BSON_JSON_LF_UNDEFINED:
+      case BSON_JSON_LF_UUID:
+         // These special keys do not expect objects as their values. Fail.
+         _bson_json_read_set_error (
+            reader,
+            "Unexpected nested object value for \"%s\" key",
+            reader->bson.unescaped.buf);
+         break;
+      case BSON_JSON_LF_DBPOINTER:
+      case BSON_JSON_LF_SCOPE:
+      case BSON_JSON_LF_TIMESTAMP_I:
+      case BSON_JSON_LF_TIMESTAMP_T:
+      default:
+         // These special LF keys aren't handled with BSON_JSON_IN_BSON_TYPE
+         BSON_UNREACHABLE (
+            "These LF values are handled with a different read_state");
       }
    } else if (bson->read_state == BSON_JSON_IN_BSON_TYPE_TIMESTAMP_STARTMAP) {
       bson->read_state = BSON_JSON_IN_BSON_TYPE_TIMESTAMP_VALUES;

Sources/CLibMongoC/bson/bson-md5.c

@@ -7,18 +7,18 @@
 void
 bson_md5_init (bson_md5_t *pms)
 {
-   COMMON_PREFIX (_bson_md5_init (pms));
+   mcommon_md5_init (pms);
 }
 
 
 void
 bson_md5_append (bson_md5_t *pms, const uint8_t *data, uint32_t nbytes)
 {
-   COMMON_PREFIX (_bson_md5_append (pms, data, nbytes));
+   mcommon_md5_append (pms, data, nbytes);
 }
 
 void
 bson_md5_finish (bson_md5_t *pms, uint8_t digest[16])
 {
-   COMMON_PREFIX (_bson_md5_finish (pms, digest));
+   mcommon_md5_finish (pms, digest);
 }

Sources/CLibMongoC/bson/bson.c

@@ -2696,10 +2696,9 @@ _bson_as_json_visit_binary (const bson_iter_t *iter,
    size_t b64_len;
    char *b64;
 
-   b64_len = COMMON_PREFIX (bson_b64_ntop_calculate_target_size (v_binary_len));
+   b64_len = mcommon_b64_ntop_calculate_target_size (v_binary_len);
    b64 = bson_malloc0 (b64_len);
-   BSON_ASSERT (
-      COMMON_PREFIX (bson_b64_ntop (v_binary, v_binary_len, b64, b64_len) != -1));
+   BSON_ASSERT (mcommon_b64_ntop (v_binary, v_binary_len, b64, b64_len) != -1);
 
    if (state->mode == BSON_JSON_MODE_CANONICAL ||
        state->mode == BSON_JSON_MODE_RELAXED) {

Sources/CLibMongoC/bson/jsonsl.c

@@ -457,13 +457,23 @@ jsonsl_feed(jsonsl_t jsn, const jsonsl_char_t *bytes, size_t nbytes)
                 } else if (state->special_flags & JSONSL_SPECIALf_NULL ||
                            state->special_flags & JSONSL_SPECIALf_NAN) {
                    /* previous char was "n", are we parsing null or nan? */
-                   if (CUR_CHAR != 'u') {
+                   const bool not_u = CUR_CHAR != 'u';
+                   const bool not_a = tolower (CUR_CHAR) != 'a';
+                   if (not_u) {
                       state->special_flags &= ~JSONSL_SPECIALf_NULL;
                    }
-
-                   if (tolower(CUR_CHAR) != 'a') {
+                   if (not_a) {
                       state->special_flags &= ~JSONSL_SPECIALf_NAN;
                    }
+                   if (not_u && not_a) {
+                      /* This verify will always fail, as we have an 'n'
+                       * followed by a character that is neither 'a' nor 'u'
+                       * (and hence cannot be "null"). The purpose of this
+                       * VERIFY_SPECIAL is to generate an error in tokenization
+                       * that stops if a bare 'n' cannot possibly be a "nan" or
+                       * a "null". */
+                      VERIFY_SPECIAL ("null", 4);
+                   }
 #endif
                 }
                 INCR_METRIC(SPECIAL_FASTPATH);

Sources/CLibMongoC/common/common-b64.c

@@ -113,10 +113,11 @@ static const char Pad64 = '=';
  *    characters followed by one "=" padding character.
  */
 
-int COMMON_PREFIX (bson_b64_ntop) (uint8_t const *src,
-                                   size_t srclength,
-                                   char *target,
-                                   size_t targsize)
+int
+mcommon_b64_ntop (uint8_t const *src,
+                  size_t srclength,
+                  char *target,
+                  size_t targsize)
 {
    size_t datalength = 0;
    uint8_t input[3];
@@ -517,9 +518,8 @@ mongoc_b64_pton_len (char const *src)
 }
 
 
-int COMMON_PREFIX (bson_b64_pton) (char const *src,
-                                   uint8_t *target,
-                                   size_t targsize)
+int
+mcommon_b64_pton (char const *src, uint8_t *target, size_t targsize)
 {
    static mongoc_common_once_t once = MONGOC_COMMON_ONCE_INIT;
 
@@ -535,7 +535,8 @@ int COMMON_PREFIX (bson_b64_pton) (char const *src,
       return mongoc_b64_pton_len (src);
 }
 
-size_t COMMON_PREFIX (bson_b64_ntop_calculate_target_size) (size_t raw_size)
+size_t
+mcommon_b64_ntop_calculate_target_size (size_t raw_size)
 {
    size_t num_bits = raw_size * 8;
    /* Calculate how many groups of six bits this contains, adding 5 to round up
@@ -547,8 +548,8 @@ size_t COMMON_PREFIX (bson_b64_ntop_calculate_target_size) (size_t raw_size)
    return num_b64_chars_with_padding + 1;
 }
 
-size_t COMMON_PREFIX (bson_b64_pton_calculate_target_size) (
-   size_t base64_encoded_size)
+size_t
+mcommon_b64_pton_calculate_target_size (size_t base64_encoded_size)
 {
    /* Without inspecting the data, we don't know how many padding characters
     * there are. Assuming none, that means each character represents 6 bits of

Sources/CLibMongoC/common/common-md5.c

@@ -324,7 +324,8 @@ bson_md5_process (bson_md5_t *md5, const uint8_t *data)
    md5->abcd[3] += d;
 }
 
-void COMMON_PREFIX (_bson_md5_init) (bson_md5_t *pms)
+void
+mcommon_md5_init (bson_md5_t *pms)
 {
    pms->count[0] = pms->count[1] = 0;
    pms->abcd[0] = 0x67452301;
@@ -333,9 +334,8 @@ void COMMON_PREFIX (_bson_md5_init) (bson_md5_t *pms)
    pms->abcd[3] = 0x10325476;
 }
 
-void COMMON_PREFIX (_bson_md5_append) (bson_md5_t *pms,
-                                       const uint8_t *data,
-                                       uint32_t nbytes)
+void
+mcommon_md5_append (bson_md5_t *pms, const uint8_t *data, uint32_t nbytes)
 {
    const uint8_t *p = data;
    int left = nbytes;
@@ -373,7 +373,8 @@ void COMMON_PREFIX (_bson_md5_append) (bson_md5_t *pms,
 }
 
 
-void COMMON_PREFIX (_bson_md5_finish) (bson_md5_t *pms, uint8_t digest[16])
+void
+mcommon_md5_finish (bson_md5_t *pms, uint8_t digest[16])
 {
    static const uint8_t pad[64] = {
       0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
@@ -386,10 +387,9 @@ void COMMON_PREFIX (_bson_md5_finish) (bson_md5_t *pms, uint8_t digest[16])
    for (i = 0; i < 8; ++i)
       data[i] = (uint8_t) (pms->count[i >> 2] >> ((i & 3) << 3));
    /* Pad to 56 bytes mod 64. */
-   COMMON_PREFIX (_bson_md5_append)
-   (pms, pad, ((55 - (pms->count[0] >> 3)) & 63) + 1);
+   mcommon_md5_append (pms, pad, ((55 - (pms->count[0] >> 3)) & 63) + 1);
    /* Append the length. */
-   COMMON_PREFIX (_bson_md5_append) (pms, data, sizeof (data));
+   mcommon_md5_append (pms, data, sizeof (data));
    for (i = 0; i < 16; ++i)
       digest[i] = (uint8_t) (pms->abcd[i >> 2] >> ((i & 3) << 3));
 }

Sources/CLibMongoC/common/common-thread.c

@@ -17,37 +17,42 @@
 #include "CLibMongoC_common-thread-private.h"
 
 #if defined(BSON_OS_UNIX)
-int COMMON_PREFIX (thread_create) (bson_thread_t *thread,
-                                   BSON_THREAD_FUN_TYPE (func),
-                                   void *arg)
+int
+mcommon_thread_create (bson_thread_t *thread,
+                       BSON_THREAD_FUN_TYPE (func),
+                       void *arg)
 {
    return pthread_create (thread, NULL, func, arg);
 }
-int COMMON_PREFIX (thread_join) (bson_thread_t thread)
+int
+mcommon_thread_join (bson_thread_t thread)
 {
    return pthread_join (thread, NULL);
 }
 
 #if defined(MONGOC_ENABLE_DEBUG_ASSERTIONS) && defined(BSON_OS_UNIX)
-bool COMMON_PREFIX (mutex_is_locked) (bson_mutex_t *mutex)
+bool
+mcommon_mutex_is_locked (bson_mutex_t *mutex)
 {
    return mutex->valid_tid &&
           pthread_equal (pthread_self (), mutex->lock_owner);
 }
 #endif
 
 #else
-int COMMON_PREFIX (thread_create) (bson_thread_t *thread,
-                                   BSON_THREAD_FUN_TYPE (func),
-                                   void *arg)
+int
+mcommon_thread_create (bson_thread_t *thread,
+                       BSON_THREAD_FUN_TYPE (func),
+                       void *arg)
 {
    *thread = (HANDLE) _beginthreadex (NULL, 0, func, arg, 0, NULL);
    if (0 == *thread) {
       return 1;
    }
    return 0;
 }
-int COMMON_PREFIX (thread_join) (bson_thread_t thread)
+int
+mcommon_thread_join (bson_thread_t thread)
 {
    int ret;