WIP Initial API for delegated streaming out

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

Author: thiagomacieira

.travis.yml

@@ -75,7 +75,7 @@ script:
   - make -s -f Makefile.configure configure | tee .config
   - make -k
         CFLAGS="$CFLAGS -march=native -g1 -Wall -Wextra -Werror"
-        CPPFLAGS="-DNDEBUG -DCBOR_PARSER_READER_CONTROL=-1"
+        CPPFLAGS="-DNDEBUG -DCBOR_ENCODER_WRITER_CONTROL=-1 -DCBOR_PARSER_READER_CONTROL=-1"
         lib/libtinycbor.a
   - size lib/libtinycbor.a | tee sizes
   - make -s clean

src/cbor.h

@@ -203,13 +203,29 @@ typedef enum CborError {
 CBOR_API const char *cbor_error_string(CborError error);
 
 /* Encoder API */
+
+typedef enum CborEncoderAppendType
+{
+    CborEncoderAppendCborData = 0,
+    CborEncoderAppendStringData = 1
+} CborEncoderAppendType;
+
+typedef CborError (*CborEncoderWriteFunction)(void *, const void *, size_t, CborEncoderAppendType);
+
+enum CborEncoderFlags
+{
+    CborIteratorFlag_WriterFunction         = 0x01,
+    CborIteratorFlag_ContainerIsMap_        = 0x20
+};
+
 struct CborEncoder
 {
     union {
         uint8_t *ptr;
         ptrdiff_t bytes_needed;
+        CborEncoderWriteFunction writer;
     } data;
-    const uint8_t *end;
+    uint8_t *end;
     size_t remaining;
     int flags;
 };
@@ -219,6 +235,7 @@ static const size_t CborIndefiniteLength = SIZE_MAX;
 
 #ifndef CBOR_NO_ENCODER_API
 CBOR_API void cbor_encoder_init(CborEncoder *encoder, uint8_t *buffer, size_t size, int flags);
+CBOR_API void cbor_encoder_init_writer(CborEncoder *encoder, CborEncoderWriteFunction writer, void *);
 CBOR_API CborError cbor_encode_uint(CborEncoder *encoder, uint64_t value);
 CBOR_API CborError cbor_encode_int(CborEncoder *encoder, int64_t value);
 CBOR_API CborError cbor_encode_negative_int(CborEncoder *encoder, uint64_t absolute_value);

src/cborencoder.c

@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2016 Intel Corporation
+** Copyright (C) 2021 Intel Corporation
 **
 ** Permission is hereby granted, free of charge, to any person obtaining a copy
 ** of this software and associated documentation files (the "Software"), to deal
@@ -208,6 +208,18 @@ void cbor_encoder_init(CborEncoder *encoder, uint8_t *buffer, size_t size, int f
     encoder->flags = flags;
 }
 
+void cbor_encoder_init_writer(CborEncoder *encoder, CborEncoderWriteFunction writer, void *token)
+{
+#ifdef CBOR_ENCODER_WRITE_FUNCTION
+    (void) writer;
+#else
+    encoder->data.writer = writer;
+#endif
+    encoder->end = (uint8_t *)token;
+    encoder->remaining = 2;
+    encoder->flags = CborIteratorFlag_WriterFunction;
+}
+
 static inline void put16(void *where, uint16_t v)
 {
     uint16_t v_be = cbor_htons(v);
@@ -221,8 +233,12 @@ static inline void put16(void *where, uint16_t v)
  * being created in the tinycbor output */
 static inline bool isOomError(CborError err)
 {
-    (void) err;
-    return true;
+    if (CBOR_ENCODER_WRITER_CONTROL < 0)
+        return true;
+
+    /* CborErrorOutOfMemory is the only negative error code, intentionally
+     * so we can write the test like this */
+    return (int)err < 0;
 }
 
 static inline void put32(void *where, uint32_t v)
@@ -253,8 +269,20 @@ static inline void advance_ptr(CborEncoder *encoder, size_t n)
         encoder->data.bytes_needed += n;
 }
 
-static inline CborError append_to_buffer(CborEncoder *encoder, const void *data, size_t len)
+static inline CborError append_to_buffer(CborEncoder *encoder, const void *data, size_t len,
+                                         CborEncoderAppendType appendType)
 {
+    if (CBOR_ENCODER_WRITER_CONTROL >= 0) {
+        if (encoder->flags & CborIteratorFlag_WriterFunction || CBOR_ENCODER_WRITER_CONTROL != 0) {
+#  ifdef CBOR_ENCODER_WRITE_FUNCTION
+            return CBOR_ENCODER_WRITE_FUNCTION(encoder->end, data, len, appendType);
+#  else
+            return encoder->data.writer(encoder->end, data, len, appendType);
+#  endif
+        }
+    }
+
+#if CBOR_ENCODER_WRITER_CONTROL <= 0
     if (would_overflow(encoder, len)) {
         if (encoder->end != NULL) {
             len -= encoder->end - encoder->data.ptr;
@@ -268,12 +296,13 @@ static inline CborError append_to_buffer(CborEncoder *encoder, const void *data,
 
     memcpy(encoder->data.ptr, data, len);
     encoder->data.ptr += len;
+#endif
     return CborNoError;
 }
 
 static inline CborError append_byte_to_buffer(CborEncoder *encoder, uint8_t byte)
 {
-    return append_to_buffer(encoder, &byte, 1);
+    return append_to_buffer(encoder, &byte, 1, CborEncoderAppendCborData);
 }
 
 static inline CborError encode_number_no_update(CborEncoder *encoder, uint64_t ui, uint8_t shiftedMajorType)
@@ -302,7 +331,7 @@ static inline CborError encode_number_no_update(CborEncoder *encoder, uint64_t u
         *bufstart = shiftedMajorType + Value8Bit + more;
     }
 
-    return append_to_buffer(encoder, bufstart, bufend - bufstart);
+    return append_to_buffer(encoder, bufstart, bufend - bufstart, CborEncoderAppendCborData);
 }
 
 static inline void saturated_decrement(CborEncoder *encoder)
@@ -399,7 +428,7 @@ CborError cbor_encode_floating_point(CborEncoder *encoder, CborType fpType, cons
     else
         put16(buf + 1, *(const uint16_t*)value);
     saturated_decrement(encoder);
-    return append_to_buffer(encoder, buf, size + 1);
+    return append_to_buffer(encoder, buf, size + 1, CborEncoderAppendCborData);
 }
 
 /**
@@ -418,7 +447,7 @@ static CborError encode_string(CborEncoder *encoder, size_t length, uint8_t shif
     CborError err = encode_number(encoder, length, shiftedMajorType);
     if (err && !isOomError(err))
         return err;
-    return append_to_buffer(encoder, string, length);
+    return append_to_buffer(encoder, string, length, CborEncoderAppendStringData);
 }
 
 /**
@@ -466,9 +495,12 @@ static CborError create_container(CborEncoder *encoder, CborEncoder *container,
     saturated_decrement(encoder);
     container->remaining = length + 1;      /* overflow ok on CborIndefiniteLength */
 
+    cbor_static_assert((int)CborIteratorFlag_ContainerIsMap_ == (int)CborIteratorFlag_ContainerIsMap);
     cbor_static_assert(((MapType << MajorTypeShift) & CborIteratorFlag_ContainerIsMap) == CborIteratorFlag_ContainerIsMap);
     cbor_static_assert(((ArrayType << MajorTypeShift) & CborIteratorFlag_ContainerIsMap) == 0);
     container->flags = shiftedMajorType & CborIteratorFlag_ContainerIsMap;
+    if (CBOR_ENCODER_WRITER_CONTROL == 0)
+        container->flags |= encoder->flags & CborIteratorFlag_WriterFunction;
 
     if (length == CborIndefiniteLength) {
         container->flags |= CborIteratorFlag_UnknownLength;

src/cborinternal_p.h

@@ -106,9 +106,13 @@ static inline double decode_half(unsigned short half)
 #  define CBOR_PARSER_MAX_RECURSIONS 1024
 #endif
 
+#ifndef CBOR_ENCODER_WRITER_CONTROL
+#  define CBOR_ENCODER_WRITER_CONTROL   0
+#endif
 #ifndef CBOR_PARSER_READER_CONTROL
 #  define CBOR_PARSER_READER_CONTROL    0
 #endif
+
 /*
  * CBOR Major types
  * Encoded in the high 3 bits of the descriptor byte

tests/encoder/tst_encoder.cpp

@@ -61,6 +61,10 @@ private slots:
     void maps_data() { tags_data(); }
     void maps();
 
+    void writerApi_data() { tags_data(); }
+    void writerApi();
+    void writerApiFail_data() { tags_data(); }
+    void writerApiFail();
     void shortBuffer_data() { tags_data(); }
     void shortBuffer();
     void tooShortArrays_data() { tags_data(); }
@@ -784,6 +788,47 @@ void tst_Encoder::maps()
     if (QTest::currentTestFailed()) return;
 }
 
+void tst_Encoder::writerApi()
+{
+    QFETCH(QVariant, input);
+    QFETCH(QByteArray, output);
+
+    // instead of writing to a QByteArray like all other tests, write to a QBuffer
+    QBuffer buffer;
+    buffer.open(QIODevice::ReadWrite);
+    auto callback = [](void *token, const void *data, size_t len, CborEncoderAppendType) {
+        auto buffer = static_cast<QBuffer *>(token);
+        buffer->write(static_cast<const char *>(data), len);
+        return CborNoError;
+    };
+
+    CborEncoder encoder;
+    cbor_encoder_init_writer(&encoder, callback, &buffer);
+    QCOMPARE(encodeVariant(&encoder, input), CborNoError);
+
+    buffer.reset();
+    QCOMPARE(buffer.readAll(), output);
+}
+
+void tst_Encoder::writerApiFail()
+{
+    QFETCH(QVariant, input);
+    QFETCH(QByteArray, output);
+
+    // same as above, but we'll produce an error during writing and we expect
+    // it to be returned
+    int callCount = 0;
+    auto callback = [](void *token, const void *, size_t, CborEncoderAppendType) {
+        ++*static_cast<int *>(token);
+        return CborErrorIO;
+    };
+
+    CborEncoder encoder;
+    cbor_encoder_init_writer(&encoder, callback, &callCount);
+    QCOMPARE(encodeVariant(&encoder, input), CborErrorIO);
+    QCOMPARE(callCount, 1);
+}
+
 void tst_Encoder::shortBuffer()
 {
     QFETCH(QVariant, input);