CDRIVER-3792 Support parsing $uuid as extended JSON (#759)

alcaeus · web-flow · commit da0e8a7d0c96 · 2021-03-25T08:36:49.000+01:00
* Sync bson-corpus spec tests for binary data

* Test parse errors for binary types

* Support parsing $uuid into a binary UUID

* Fix wrong handling of length

* Fix wrong return value when failing to parse UUID

* Make sscanf invocation compatible with more operating systems

* Reformat SSCANF invocation

* Change fall through comment for consistency
diff --git a/src/libbson/src/bson/bson-json.c b/src/libbson/src/bson/bson-json.c
@@ -103,7 +103,8 @@ static const char *read_state_names[] = {FOREACH_READ_STATE (GENERATE_STRING)};
    BS (DECIMAL128)                                                   \
    BS (DBPOINTER)                                                    \
    BS (SYMBOL)                                                       \
-   BS (DBREF)
+   BS (DBREF)                                                        \
+   BS (UUID)
 
 typedef enum {
    FOREACH_BSON_STATE (BSON_STATE_ENUM)
@@ -706,6 +707,7 @@ _bson_json_read_integer (bson_json_reader_t *reader, uint64_t val, int64_t sign)
       case BSON_JSON_LF_OID:
       case BSON_JSON_LF_BINARY:
       case BSON_JSON_LF_TYPE:
+      case BSON_JSON_LF_UUID:
       case BSON_JSON_LF_UNDEFINED:
       case BSON_JSON_LF_DOUBLE:
       case BSON_JSON_LF_DECIMAL128:
@@ -833,8 +835,29 @@ _bson_json_read_int64_or_set_error (bson_json_reader_t *reader, /* IN */
    return true;
 }
 
+static bool
+_unhexlify_uuid (const char *uuid, uint8_t *out, size_t max)
+{
+   unsigned int byte;
+   int x = 0;
+   int i = 0;
+
+   BSON_ASSERT (strlen (uuid) == 32);
+
+   while (SSCANF (&uuid[i], "%2x", &byte) == 1) {
+      if (x >= max) {
+         return false;
+      }
+
+      out[x++] = (uint8_t) byte;
+      i += 2;
+   }
 
-/* parse a value for "base64", "subType" or legacy "$binary" or "$type" */
+   return i == 32;
+}
+
+/* parse a value for "base64", "subType", legacy "$binary" or "$type", or
+ * "$uuid" */
 static void
 _bson_json_parse_binary_elem (bson_json_reader_t *reader,
                               const char *val_w_null,
@@ -894,6 +917,64 @@ _bson_json_parse_binary_elem (bson_json_reader_t *reader,
                               (int) vlen);
          }
       }
+   } else if (bs == BSON_JSON_LF_UUID) {
+      int nread = 0;
+      char uuid[33];
+
+      data->binary.has_binary = true;
+      data->binary.has_subtype = true;
+      data->binary.type = BSON_SUBTYPE_UUID;
+
+      /* Validate the UUID and extract relevant portions */
+      /* We can't use %x here as it allows +, -, and 0x prefixes */
+#ifdef _MSC_VER
+      SSCANF (val_w_null,
+              "%8c-%4c-%4c-%4c-%12c%n",
+              &uuid[0],
+              8,
+              &uuid[8],
+              4,
+              &uuid[12],
+              4,
+              &uuid[16],
+              4,
+              &uuid[20],
+              12,
+              &nread);
+#else
+      SSCANF (val_w_null,
+              "%8c-%4c-%4c-%4c-%12c%n",
+              &uuid[0],
+              &uuid[8],
+              &uuid[12],
+              &uuid[16],
+              &uuid[20],
+              &nread);
+#endif
+
+      uuid[32] = '\0';
+
+      if (nread != 36 || val_w_null[nread] != '\0') {
+         _bson_json_read_set_error (reader,
+                                    "Invalid input string \"%s\", looking for "
+                                    "a dash-separated UUID string",
+                                    val_w_null);
+
+         return;
+      }
+
+      binary_len = 16;
+      _bson_json_buf_ensure (&bson->bson_type_buf[0], (size_t) binary_len + 1);
+
+      if (!_unhexlify_uuid (
+             &uuid[0], bson->bson_type_buf[0].buf, (size_t) binary_len)) {
+         _bson_json_read_set_error (reader,
+                                    "Invalid input string \"%s\", looking for "
+                                    "a dash-separated UUID string",
+                                    val_w_null);
+      }
+
+      bson->bson_type_buf[0].len = (size_t) binary_len;
    }
 }
 
@@ -967,6 +1048,8 @@ _bson_json_read_string (bson_json_reader_t *reader, /* IN */
       case BSON_JSON_LF_BINARY:
       case BSON_JSON_LF_TYPE:
          bson->bson_type_data.binary.is_legacy = true;
+         /* FALL THROUGH */
+      case BSON_JSON_LF_UUID:
          _bson_json_parse_binary_elem (reader, val_w_null, vlen);
          break;
       case BSON_JSON_LF_INT32: {
@@ -1123,7 +1206,7 @@ _is_known_key (const char *key, size_t len)
           IS_KEY ("$numberDouble") || IS_KEY ("$numberDecimal") ||
           IS_KEY ("$numberInt") || IS_KEY ("$numberLong") ||
           IS_KEY ("$numberDouble") || IS_KEY ("$numberDecimal") ||
-          IS_KEY ("$dbPointer") || IS_KEY ("$symbol"));
+          IS_KEY ("$dbPointer") || IS_KEY ("$symbol") || IS_KEY ("$uuid"));
 
 #undef IS_KEY
 
@@ -1241,6 +1324,8 @@ _bson_json_read_map_key (bson_json_reader_t *reader, /* IN */
          HANDLE_OPTION ("$binary", BSON_TYPE_BINARY, BSON_JSON_LF_BINARY)
       else if
          HANDLE_OPTION ("$type", BSON_TYPE_BINARY, BSON_JSON_LF_TYPE)
+      else if
+         HANDLE_OPTION ("$uuid", BSON_TYPE_BINARY, BSON_JSON_LF_UUID)
       else if
          HANDLE_OPTION ("$date", BSON_TYPE_DATE_TIME, BSON_JSON_LF_DATE)
       else if
diff --git a/src/libbson/tests/json/bson_corpus/binary.json b/src/libbson/tests/json/bson_corpus/binary.json
@@ -39,6 +39,12 @@
             "canonical_bson": "1D000000057800100000000473FFD26444B34C6990E8E7D1DFC035D400",
             "canonical_extjson": "{\"x\" : { \"$binary\" : {\"base64\" : \"c//SZESzTGmQ6OfR38A11A==\", \"subType\" : \"04\"}}}"
         },
+        {
+            "description": "subtype 0x04 UUID",
+            "canonical_bson": "1D000000057800100000000473FFD26444B34C6990E8E7D1DFC035D400",
+            "canonical_extjson": "{\"x\" : { \"$binary\" : {\"base64\" : \"c//SZESzTGmQ6OfR38A11A==\", \"subType\" : \"04\"}}}",
+            "degenerate_extjson": "{\"x\" : { \"$uuid\" : \"73ffd264-44b3-4c69-90e8-e7d1dfc035d4\"}}"
+        },
         {
             "description": "subtype 0x05",
             "canonical_bson": "1D000000057800100000000573FFD26444B34C6990E8E7D1DFC035D400",
@@ -81,5 +87,27 @@
             "description": "subtype 0x02 length negative one",
             "bson": "130000000578000600000002FFFFFFFFFFFF00"
         }
+    ],
+    "parseErrors": [
+        {
+            "description": "$uuid wrong type",
+            "string": "{\"x\" : { \"$uuid\" : { \"data\" : \"73ffd264-44b3-4c69-90e8-e7d1dfc035d4\"}}}"
+        },
+        {
+            "description": "$uuid invalid value--too short",
+            "string": "{\"x\" : { \"$uuid\" : \"73ffd264-44b3-90e8-e7d1dfc035d4\"}}"
+        },
+        {
+            "description": "$uuid invalid value--too long",
+            "string": "{\"x\" : { \"$uuid\" : \"73ffd264-44b3-4c69-90e8-e7d1dfc035d4-789e4\"}}"
+        },
+        {
+            "description": "$uuid invalid value--misplaced hyphens",
+            "string": "{\"x\" : { \"$uuid\" : \"73ff-d26444b-34c6-990e8e-7d1dfc035d4\"}}"
+        },
+        {
+            "description": "$uuid invalid value--too many hyphens",
+            "string": "{\"x\" : { \"$uuid\" : \"----d264-44b3-4--9-90e8-e7d1dfc0----\"}}"
+        }
     ]
 }
diff --git a/src/libbson/tests/test-bson-corpus.c b/src/libbson/tests/test-bson-corpus.c
@@ -239,6 +239,7 @@ test_bson_corpus_parse_error (test_bson_parse_error_type_t *test)
 
    switch (test->bson_type) {
    case BSON_TYPE_EOD: /* top-level document to be parsed as JSON */
+   case BSON_TYPE_BINARY:
       ASSERT (!bson_new_from_json ((uint8_t *) test->str, test->str_len, NULL));
       break;
    case BSON_TYPE_DECIMAL128: {
@@ -251,7 +252,6 @@ test_bson_corpus_parse_error (test_bson_parse_error_type_t *test)
    case BSON_TYPE_UTF8:
    case BSON_TYPE_DOCUMENT:
    case BSON_TYPE_ARRAY:
-   case BSON_TYPE_BINARY:
    case BSON_TYPE_UNDEFINED:
    case BSON_TYPE_OID:
    case BSON_TYPE_BOOL:
