Add an API to verify that a CborValue is valid

This is the first of two functions and this one does only a basic
validation, which ensures that parsing will be ok, with no errors.

Signed-off-by: Thiago Macieira <[email protected]>

Author: thiagomacieira

src/cbor.h

@@ -248,6 +248,8 @@ typedef struct CborValue CborValue;
 
 CBOR_API CborError cbor_parser_init(const uint8_t *buffer, size_t size, int flags, CborParser *parser, CborValue *it);
 
+CBOR_API CborError cbor_value_validate_basic(const CborValue *it);
+
 CBOR_INLINE_API bool cbor_value_at_end(const CborValue *it)
 { return it->remaining == 0; }
 CBOR_INLINE_API const uint8_t *cbor_value_get_next_byte(const CborValue *it)

src/cborparser.c

@@ -420,6 +420,33 @@ CborError cbor_parser_init(const uint8_t *buffer, size_t size, int flags, CborPa
  * \sa cbor_value_advance(), cbor_valie_at_end(), cbor_value_get_type()
  */
 
+/**
+ * Performs a basic validation of the CBOR stream pointed by \a it and returns
+ * the error it found. If no error was found, it returns CborNoError and the
+ * application can iterate over the items with certainty that no other errors
+ * will appear during parsing.
+ *
+ * A basic validation checks for:
+ * \list
+ *   \li absence of undefined additional information bytes;
+ *   \li well-formedness of all numbers, lengths, and simple values;
+ *   \li string contents match reported sizes;
+ *   \li arrays and maps contain the number of elements they are reported to have;
+ * \endlist
+ *
+ * For further checks, see cbor_value_validate().
+ *
+ * This function has the same timing and memory requirements as
+ * cbor_value_advance().
+ *
+ * \sa cbor_value_validate(), cbor_value_advance()
+ */
+CborError cbor_value_validate_basic(const CborValue *it)
+{
+    CborValue value = *it;
+    return cbor_value_advance(&value);
+}
+
 /**
  * Advances the CBOR value \a it by one fixed-size position. Fixed-size types
  * are: integers, tags, simple types (including boolean, null and undefined
@@ -481,6 +508,9 @@ static CborError advance_recursive(CborValue *it, int nestingLevel)
  * elements or chunks and will use O(n) memory for the number of nested
  * containers).
  *
+ * The number of recursions can be limited at compile time to avoid stack
+ * exhaustion in constrained systems.
+ *
  * \sa cbor_value_at_end(), cbor_value_advance_fixed(), cbor_value_enter_container(), cbor_value_leave_container()
  */
 CborError cbor_value_advance(CborValue *it)

tests/parser/tst_parser.cpp

@@ -222,12 +222,17 @@ void compareOne_real(const QByteArray &data, const QString &expected, int line,
         }
     }
 
+    CborError err2 = cbor_value_validate_basic(&first);
+
     QString decoded;
     err = parseOne(&first, &decoded);
     QVERIFY2(!err, QByteArray::number(line) + ": Got error \"" + cbor_error_string(err) +
                    "\"; decoded stream:\n" + decoded.toLatin1());
     QCOMPARE(decoded, expected);
 
+    // check that the errors are the same
+    QCOMPARE(int(err2), int(err));
+
     // check that we consumed everything
     QCOMPARE((void*)cbor_value_get_next_byte(&first), (void*)data.constEnd());
 
@@ -1520,8 +1525,11 @@ void tst_Parser::validation()
     CborError err = cbor_parser_init(reinterpret_cast<const quint8 *>(data.constData()), data.length(), flags, &parser, &first);
     QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\"");
 
+    CborError err2 = cbor_value_validate_basic(&first);
     err = parseOne(&first, &decoded);
     QCOMPARE(int(err), int(expectedError));
+    if (!QByteArray(QTest::currentDataTag()).contains("utf8"))
+        QCOMPARE(int(err2), int(expectedError));
 }
 
 void tst_Parser::resumeParsing_data()