Fixed issue 1 reported by Erik Rosen:

[apps/agl-service-can-low-level.git] / pb_encode.c

diff --git a/pb_encode.c b/pb_encode.c
index 19a531c..995eb3d 100644 (file)
--- a/pb_encode.c
+++ b/pb_encode.c
@@ -7,7 +7,15 @@
 #include "pb_encode.h"
 #include <string.h>
 
-typedef bool (*pb_encoder_t)(pb_ostream_t *stream, const pb_field_t *field, const void *src);
+#ifdef __GNUC__
+/* Verify that we remember to check all return values for proper error propagation */
+#define checkreturn __attribute__((warn_unused_result))
+#else
+#define checkreturn
+#endif
+
+
+typedef bool (*pb_encoder_t)(pb_ostream_t *stream, const pb_field_t *field, const void *src) checkreturn;
 
 /* --- Function pointers to field encoders ---
  * Order in the array must match pb_action_t LTYPE numbering.
@@ -15,7 +23,8 @@ typedef bool (*pb_encoder_t)(pb_ostream_t *stream, const pb_field_t *field, cons
 static const pb_encoder_t PB_ENCODERS[PB_LTYPES_COUNT] = {
     &pb_enc_varint,
     &pb_enc_svarint,
-    &pb_enc_fixed,
+    &pb_enc_fixed32,
+    &pb_enc_fixed64,
     
     &pb_enc_bytes,
     &pb_enc_string,
@@ -24,7 +33,7 @@ static const pb_encoder_t PB_ENCODERS[PB_LTYPES_COUNT] = {
 
 /* pb_ostream_t implementation */
 
-static bool buf_write(pb_ostream_t *stream, const uint8_t *buf, size_t count)
+static bool checkreturn buf_write(pb_ostream_t *stream, const uint8_t *buf, size_t count)
 {
     uint8_t *dest = (uint8_t*)stream->state;
     memcpy(dest, buf, count);
@@ -42,7 +51,7 @@ pb_ostream_t pb_ostream_from_buffer(uint8_t *buf, size_t bufsize)
     return stream;
 }
 
-bool pb_write(pb_ostream_t *stream, const uint8_t *buf, size_t count)
+bool checkreturn pb_write(pb_ostream_t *stream, const uint8_t *buf, size_t count)
 {
     if (stream->callback != NULL)
     {
@@ -59,22 +68,33 @@ bool pb_write(pb_ostream_t *stream, const uint8_t *buf, size_t count)
 
 /* Main encoding stuff */
 
-static bool encode_array(pb_ostream_t *stream, const pb_field_t *field,
+/* Callbacks don't need this function because they usually know the data type
+ * without examining the field structure.
+ * Therefore it is static for now.
+ */
+static bool checkreturn encode_array(pb_ostream_t *stream, const pb_field_t *field,
                          const void *pData, size_t count, pb_encoder_t func)
 {
     int i;
     const void *p;
     size_t size;
     
-    if (PB_LTYPE(field->type) < PB_LTYPE_LAST_PACKABLE)
+    if (count == 0)
+        return true;
+    
+    if (PB_LTYPE(field->type) <= PB_LTYPE_LAST_PACKABLE)
     {
         if (!pb_encode_tag(stream, PB_WT_STRING, field->tag))
             return false;
         
         /* Determine the total size of packed array. */
-        if (PB_LTYPE(field->type) == PB_LTYPE_FIXED)
+        if (PB_LTYPE(field->type) == PB_LTYPE_FIXED32)
         {
-            size = field->data_size * count;
+            size = 4 * count;
+        }
+        else if (PB_LTYPE(field->type) == PB_LTYPE_FIXED64)
+        {
+            size = 8 * count;
         }
         else
         {
@@ -89,7 +109,8 @@ static bool encode_array(pb_ostream_t *stream, const pb_field_t *field,
             size = sizestream.bytes_written;
         }
         
-        pb_encode_varint(stream, size);
+        if (!pb_encode_varint(stream, size))
+            return false;
         
         if (stream->callback == NULL)
             return pb_write(stream, NULL, size); /* Just sizing.. */
@@ -119,19 +140,23 @@ static bool encode_array(pb_ostream_t *stream, const pb_field_t *field,
     return true;
 }
 
-bool pb_encode(pb_ostream_t *stream, const pb_field_t fields[], const void *src_struct)
+bool checkreturn pb_encode(pb_ostream_t *stream, const pb_field_t fields[], const void *src_struct)
 {
     const pb_field_t *field = fields;
     const void *pData = src_struct;
     const void *pSize;
+    size_t prev_size = 0;
     
     while (field->tag != 0)
     {
-        pData = (const char*)pData + field->data_offset;
-        pSize = (const char*)pData + field->size_offset;
-        
         pb_encoder_t func = PB_ENCODERS[PB_LTYPE(field->type)];
+        pData = (const char*)pData + prev_size + field->data_offset;
+        pSize = (const char*)pData + field->size_offset;
         
+        prev_size = field->data_size;
+        if (PB_HTYPE(field->type) == PB_HTYPE_ARRAY)
+            prev_size *= field->array_size;
+                
         switch (PB_HTYPE(field->type))
         {
             case PB_HTYPE_REQUIRED:
@@ -176,7 +201,7 @@ bool pb_encode(pb_ostream_t *stream, const pb_field_t fields[], const void *src_
 }
 
 /* Helper functions */
-bool pb_encode_varint(pb_ostream_t *stream, uint64_t value)
+bool checkreturn pb_encode_varint(pb_ostream_t *stream, uint64_t value)
 {
     uint8_t buffer[10];
     int i = 0;
@@ -195,13 +220,13 @@ bool pb_encode_varint(pb_ostream_t *stream, uint64_t value)
     return pb_write(stream, buffer, i);
 }
 
-bool pb_encode_tag(pb_ostream_t *stream, pb_wire_type_t wiretype, int field_number)
+bool checkreturn pb_encode_tag(pb_ostream_t *stream, pb_wire_type_t wiretype, int field_number)
 {
     int tag = wiretype | (field_number << 3);
     return pb_encode_varint(stream, tag);
 }
 
-bool pb_encode_tag_for_field(pb_ostream_t *stream, const pb_field_t *field)
+bool checkreturn pb_encode_tag_for_field(pb_ostream_t *stream, const pb_field_t *field)
 {
     pb_wire_type_t wiretype;
     switch (PB_LTYPE(field->type))
@@ -211,13 +236,12 @@ bool pb_encode_tag_for_field(pb_ostream_t *stream, const pb_field_t *field)
             wiretype = PB_WT_VARINT;
             break;
         
-        case PB_LTYPE_FIXED:
-            if (field->data_size == 4)
-                wiretype = PB_WT_32BIT;
-            else if (field->data_size == 8)
-                wiretype = PB_WT_64BIT;
-            else
-                return false;
+        case PB_LTYPE_FIXED32:
+            wiretype = PB_WT_32BIT;
+            break;
+        
+        case PB_LTYPE_FIXED64:
+            wiretype = PB_WT_64BIT;
             break;
         
         case PB_LTYPE_BYTES:
@@ -233,7 +257,7 @@ bool pb_encode_tag_for_field(pb_ostream_t *stream, const pb_field_t *field)
     return pb_encode_tag(stream, wiretype, field->tag);
 }
 
-bool pb_encode_string(pb_ostream_t *stream, const uint8_t *buffer, size_t size)
+bool checkreturn pb_encode_string(pb_ostream_t *stream, const uint8_t *buffer, size_t size)
 {
     if (!pb_encode_varint(stream, size))
         return false;
@@ -259,14 +283,14 @@ static void endian_copy(void *dest, const void *src, size_t destsize, size_t src
 #endif
 }
 
-bool pb_enc_varint(pb_ostream_t *stream, const pb_field_t *field, const void *src)
+bool checkreturn pb_enc_varint(pb_ostream_t *stream, const pb_field_t *field, const void *src)
 {
     uint64_t value = 0;
     endian_copy(&value, src, sizeof(value), field->data_size);
     return pb_encode_varint(stream, value);
 }
 
-bool pb_enc_svarint(pb_ostream_t *stream, const pb_field_t *field, const void *src)
+bool checkreturn pb_enc_svarint(pb_ostream_t *stream, const pb_field_t *field, const void *src)
 {
     uint64_t value = 0;
     uint64_t zigzagged;
@@ -283,31 +307,43 @@ bool pb_enc_svarint(pb_ostream_t *stream, const pb_field_t *field, const void *s
     return pb_encode_varint(stream, zigzagged);
 }
 
-bool pb_enc_fixed(pb_ostream_t *stream, const pb_field_t *field, const void *src)
+bool checkreturn pb_enc_fixed64(pb_ostream_t *stream, const pb_field_t *field, const void *src)
 {
     #ifdef __BIG_ENDIAN__
     uint8_t bytes[8] = {0};
-    endian_copy(bytes, src, sizeof(bytes), field->data_size);
+    memcpy(bytes, src, 8);
     uint8_t lebytes[8] = {bytes[7], bytes[6], bytes[5], bytes[4], 
                           bytes[3], bytes[2], bytes[1], bytes[0]};
-    return pb_write(stream, lebytes, field->data_size);
+    return pb_write(stream, lebytes, 8);
+    #else
+    return pb_write(stream, (uint8_t*)src, 8);
+    #endif
+}
+
+bool checkreturn pb_enc_fixed32(pb_ostream_t *stream, const pb_field_t *field, const void *src)
+{
+    #ifdef __BIG_ENDIAN__
+    uint8_t bytes[4] = {0};
+    memcpy(bytes, src, 4);
+    uint8_t lebytes[4] = {bytes[3], bytes[2], bytes[1], bytes[0]};
+    return pb_write(stream, lebytes, 4);
     #else
-    return pb_write(stream, (uint8_t*)src, field->data_size);
+    return pb_write(stream, (uint8_t*)src, 4);
     #endif
 }
 
-bool pb_enc_bytes(pb_ostream_t *stream, const pb_field_t *field, const void *src)
+bool checkreturn pb_enc_bytes(pb_ostream_t *stream, const pb_field_t *field, const void *src)
 {
     pb_bytes_array_t *bytes = (pb_bytes_array_t*)src;
     return pb_encode_string(stream, bytes->bytes, bytes->size);
 }
 
-bool pb_enc_string(pb_ostream_t *stream, const pb_field_t *field, const void *src)
+bool checkreturn pb_enc_string(pb_ostream_t *stream, const pb_field_t *field, const void *src)
 {
     return pb_encode_string(stream, (uint8_t*)src, strlen((char*)src));
 }
 
-bool pb_enc_submessage(pb_ostream_t *stream, const pb_field_t *field, const void *src)
+bool checkreturn pb_enc_submessage(pb_ostream_t *stream, const pb_field_t *field, const void *src)
 {
     pb_ostream_t substream = {0};
     size_t size;
@@ -337,9 +373,10 @@ bool pb_enc_submessage(pb_ostream_t *stream, const pb_field_t *field, const void
     substream.max_size = size;
     substream.bytes_written = 0;
     
-    status = pb_encode(stream, (pb_field_t*)field->ptr, src);
+    status = pb_encode(&substream, (pb_field_t*)field->ptr, src);
     
     stream->bytes_written += substream.bytes_written;
+    stream->state = substream.state;
     
     if (substream.bytes_written != size)
         return false;