tinycbor bug fixes

- Fix cbor_buf_cmp to do memcmp and return complemented result
- Fix container_size for the container
- cbor_encoder_close_container(): look at isMap flag to determine
  container_size for comparison
- iterate_string_chunks(): fixing NULL compare at the end of string
  and moving it out of the iterate_string_chunks(). This is to avoid
  buffer specific parser calls in the function
- Re-enabling all parser tests
- cbor_value_get_next_byte() is removed in mynewt version of tinycbor,
  so, we track offsets of the buffer which can be used for comparison
  in the parser tests instead of calculating the offset

Author: vrahane

Makefile

@@ -203,7 +203,7 @@ tag: distcheck
 
 cflags := $(CPPFLAGS) -I$(SRCDIR)include
 cflags += -DTINYCBOR_VERSION_SUFFIX=\"$(DIRTYSRC)\"
-cflags += -ggdb -std=c99 $(CFLAGS)
+cflags += -ggdb -std=c99 -O0 $(CFLAGS)
 %.o: %.c
 	@test -d $(@D) || $(MKDIR) $(@D)
 	$(CC) $(cflags) $($(basename $(notdir $@))_CCFLAGS) -c -o $@ $<

src/cbor_buf_reader.c

@@ -60,7 +60,8 @@ cbor_buf_reader_cmp(struct cbor_decoder_reader *d, char *dst, int src_offset,
                     size_t len)
 {
     struct cbor_buf_reader *cb = (struct cbor_buf_reader *) d;
-    return memcmp(dst, cb->buffer + src_offset, len);
+
+    return !memcmp(dst, cb->buffer + src_offset, len);
 }
 
 static uintptr_t

src/cborencoder.c

@@ -203,6 +203,7 @@ void cbor_encoder_init(CborEncoder *encoder, cbor_encoder_writer *writer, int fl
     encoder->writer = writer;
     encoder->added = 0;
     encoder->flags = flags;
+    encoder->container_size = 0;
 }
 
 #if FLOAT_SUPPORT
@@ -429,7 +430,7 @@ static CborError create_container(CborEncoder *encoder, CborEncoder *container,
     container->writer = encoder->writer;
     ++encoder->added;
     container->added = 0;
-    encoder->container_size = length;
+    container->container_size = length;
 
     cbor_static_assert(((MapType << MajorTypeShift) & CborIteratorFlag_ContainerIsMap) == CborIteratorFlag_ContainerIsMap);
     cbor_static_assert(((ArrayType << MajorTypeShift) & CborIteratorFlag_ContainerIsMap) == 0);
@@ -502,13 +503,21 @@ CborError cbor_encoder_create_map(CborEncoder *encoder, CborEncoder *mapEncoder,
  */
 CborError cbor_encoder_close_container(CborEncoder *encoder, const CborEncoder *containerEncoder)
 {
+    size_t container_size;
+
     encoder->writer = containerEncoder->writer;
 
-    if (containerEncoder->flags & CborIteratorFlag_UnknownLength)
+    if (containerEncoder->flags & CborIteratorFlag_UnknownLength) {
         return append_byte_to_buffer(encoder, BreakByte);
-    else
-      return containerEncoder->container_size == containerEncoder->added ? CborNoError :
-             containerEncoder->container_size < containerEncoder->added ? CborErrorTooManyItems : CborErrorTooFewItems;
+    } else {
+        container_size = containerEncoder->container_size;
+        if (containerEncoder->flags & CborIteratorFlag_ContainerIsMap) {
+            container_size = containerEncoder->container_size * 2;
+        }
+
+        return container_size == containerEncoder->added ? CborNoError :
+            container_size < containerEncoder->added ? CborErrorTooManyItems : CborErrorTooFewItems;
+    }
 }
 
 /**

src/cborparser.c

@@ -1172,16 +1172,6 @@ static CborError iterate_string_chunks(const CborValue *value, char *buffer, siz
         }
     }
 
-    /* is there enough room for the ending NUL byte? */
-    if (*result && *buflen > total) {
-        /* we are just trying to write a NULL byte here,, but this is hard
-         * because this is called by function pointer with an abstract
-         * reader.  Since this is the output buffer, we can assume that if
-         * we have a valid buffer its ok to write a NULL here  */
-        if(buffer) {
-            *(buffer + total) = '\0';
-        }
-    }
     *buflen = total;
 
     if (next) {
@@ -1264,8 +1254,19 @@ CborError _cbor_value_copy_string(const CborValue *value, void *buffer,
     bool copied_all;
     CborError err = iterate_string_chunks(value, (char*)buffer, buflen, &copied_all, next,
                                           buffer ? (IterateFunction) value->parser->d->cpy : iterate_noop);
-    return err ? err :
-                 copied_all ? CborNoError : CborErrorOutOfMemory;
+    if (err) {
+        return err;
+    }
+
+    if (!copied_all) {
+        return CborErrorOutOfMemory;
+    }
+
+    if (buffer) {
+        *((uint8_t *)buffer + *buflen) = '\0';
+    }
+
+    return CborNoError;
 }
 
 /**
@@ -1290,6 +1291,7 @@ CborError cbor_value_text_string_equals(const CborValue *value, const char *stri
 {
     CborValue copy = *value;
     CborError err = cbor_value_skip_tag(&copy);
+
     if (err)
         return err;
     if (!cbor_value_is_text_string(&copy)) {
@@ -1298,8 +1300,17 @@ CborError cbor_value_text_string_equals(const CborValue *value, const char *stri
     }
 
     size_t len = strlen(string);
-    return iterate_string_chunks(&copy, CONST_CAST(char *, string), &len,
-                                 result, NULL, value->parser->d->cmp);
+    err = iterate_string_chunks(&copy, CONST_CAST(char *, string), &len,
+                                result, NULL, value->parser->d->cmp);
+    if (err) {
+        return err;
+    }
+
+    if (*result && string[len] != '\0') {
+        *result = false;
+    }
+
+    return CborNoError;
 }
 
 /**
@@ -1394,7 +1405,7 @@ CborError cbor_value_map_find_value(const CborValue *map, const char *string, Cb
                                         &equals, element, map->parser->d->cmp);
             if (err)
                 goto error;
-            if (equals)
+            if (equals && string[dummyLen] == '\0')
                 return preparse_value(element);
         } else {
             /* skip this key */

tests/parser/tst_parser.cpp

@@ -243,7 +243,7 @@ void compareOne_real(const QByteArray &data, const QString &expected, int line,
     QCOMPARE(int(err2), int(err));
 
     // check that we consumed everything
-    //QCOMPARE((void*)cbor_value_get_next_byte(&first), (void*)data.constEnd());
+    QCOMPARE(cbor_value_at_end(&first), true);
 
     compareFailed = false;
 }
@@ -1543,6 +1543,7 @@ void tst_Parser::validation()
     QFETCH(QByteArray, data);
     QFETCH(int, flags);
     QFETCH(CborError, expectedError);
+    QFETCH(int, offset);
 
     QString decoded;
     CborParser parser;
@@ -1557,6 +1558,7 @@ void tst_Parser::validation()
     CborError err3 = cbor_value_validate(&first, CborValidateBasic);
     err = parseOne(&first, &decoded);
     QCOMPARE(int(err), int(expectedError));
+    QCOMPARE(first.offset, offset);
 
     if (!QByteArray(QTest::currentDataTag()).contains("utf8")) {
         QCOMPARE(int(err2), int(expectedError));
@@ -1978,7 +1980,7 @@ void tst_Parser::endPointer_data()
 void tst_Parser::endPointer()
 {
     QFETCH(QByteArray, data);
-    //QFETCH(int, offset);
+    QFETCH(int, offset);
 
     QString decoded;
     CborParser parser;
@@ -1991,7 +1993,7 @@ void tst_Parser::endPointer()
 
     err = parseOne(&first, &decoded);
     QVERIFY2(!err, QByteArray("Got error \"") + cbor_error_string(err) + "\"");
-    //QCOMPARE(int(first.ptr - reinterpret_cast<const quint8 *>(data.constBegin())), offset);
+    QCOMPARE(first.offset, offset);
 }
 
 void tst_Parser::recursionLimit_data()