Publishing nanopb-0.2.9.2

Fix build failure due to missing dependency in SConscript
Backport memory leak fix for issue 138.
2015-01-24 17:18:25 +02:00 · 2014-12-27 00:38:22 +02:00 · 2014-12-27 00:01:45 +02:00 · 2014-12-26 23:59:56 +02:00 · 2014-09-11 19:14:45 +03:00 · 2014-09-11 19:13:59 +03:00
62 changed files with 646 additions and 1507 deletions
--- a/CHANGELOG.txt
+++ b/CHANGELOG.txt
@@ -1,22 +1,11 @@
-nanopb-0.3.1 (2014-09-11)
+nanopb-0.2.9.2 (2015-01-24)
+ Fix memory leaks with PB_ENABLE_MALLOC with some submessage hierarchies (issue 138)
+ Fix compilation error with generated initializers for repeated pointer fields
+
+nanopb-0.2.9.1 (2014-09-11)
 Fix security issue due to size_t overflows. (issue 132)
 Fix memory leak with duplicated fields and PB_ENABLE_MALLOC
 Fix crash if pb_release() is called twice.
- Fix cyclic message support (issue 130)
- Fix error in generated initializers for repeated pointer fields.
- Improve tests (issues 113, 126)
-
-nanopb-0.3.0 (2014-08-26)
- NOTE: See docs/migration.html or online at
- http://koti.kapsi.fi/~jpa/nanopb/docs/migration.html
- for changes in this version. Most importantly, you need to add
- pb_common.c to the list of files to compile.
-
- Separated field iterator logic to pb_common.c (issue 128)
- Change the _count fields to use pb_size_t datatype (issue 82)
- Added PB_ prefix to macro names (issue 106)
- Added #if version guard to generated files (issue 129)
- Added migration document

 nanopb-0.2.9 (2014-08-09)
 NOTE: If you are using the -e option with the generator, you have
--- a/docs/Makefile
+++ b/docs/Makefile
@@ -1,4 +1,4 @@
-all: index.html concepts.html reference.html security.html migration.html \
+all: index.html concepts.html reference.html security.html \
 	generator_flow.png

 %.png: %.svg
--- a/docs/menu.rst
+++ b/docs/menu.rst
@@ -4,10 +4,8 @@
    2) `Concepts`_
    3) `API reference`_
    4) `Security model`_
-    5) `Migration from older versions`_
    
 .. _`Overview`: index.html
 .. _`Concepts`: concepts.html
 .. _`API reference`: reference.html
 .. _`Security model`: security.html
-.. _`Migration from older versions`: migration.html
--- a/docs/migration.rst
+++ b/docs/migration.rst
@@ -1,239 +0,0 @@
-=====================================
-Nanopb: Migration from older versions
-=====================================
-
-.. include :: menu.rst
-
-This document details all the breaking changes that have been made to nanopb
-since its initial release. For each change, the rationale and required
-modifications of user applications are explained. Also any error indications
-are included, in order to make it easier to find this document.
-
-.. contents ::
-
-Nanopb-0.3.0 (2014-08-26)
-=========================
-
-Separate field iterator logic to pb_common.c
--------------------------------------------
-**Rationale:** Originally, the field iteration logic was simple enough to be
-duplicated in *pb_decode.c* and *pb_encode.c*. New field types have made the
-logic more complex, which required the creation of a new file to contain the
-common functionality.
-
-**Changes:** There is a new file, *pb_common.c*, which must be included in
-builds.
-
-**Required actions:** Add *pb_common.c* to build rules. This file is always
-required. Either *pb_decode.c* or *pb_encode.c* can still be left out if some
-functionality is not needed.
-
-**Error indications:** Linker error: undefined reference to
-*pb_field_iter_begin*, *pb_field_iter_next* or similar.
-
-Change data type of field counts to pb_size_t
---------------------------------------------
-**Rationale:** Often nanopb is used with small arrays, such as 255 items or
-less. Using a full *size_t* field to store the array count wastes memory if
-there are many arrays. There already exists parameters *PB_FIELD_16BIT* and
-*PB_FIELD_32BIT* which tell nanopb what is the maximum size of arrays in use.
-
-**Changes:** Generator will now use *pb_size_t* for the array *_count* fields.
-The size of the type will be controlled by the *PB_FIELD_16BIT* and
-*PB_FIELD_32BIT* compilation time options.
-
-**Required actions:** Regenerate all *.pb.h* files. In some cases casts to the
-*pb_size_t* type may need to be added in the user code when accessing the
-*_count* fields.
-
-**Error indications:** Incorrect data at runtime, crashes. But note that other
-changes in the same version already require regenerating the files and have
-better indications of errors, so this is only an issue for development
-versions.
-
-Renamed some macros and identifiers
-----------------------------------
-**Rationale:** Some names in nanopb core were badly chosen and conflicted with
-ISO C99 reserved names or lacked a prefix. While they haven't caused trouble
-so far, it is reasonable to switch to non-conflicting names as these are rarely
-used from user code.
-
-**Changes:** The following identifier names have changed:
-
-  * Macros:
-  
-    * STATIC_ASSERT(x) -> PB_STATIC_ASSERT(x)
-    * UNUSED(x) -> PB_UNUSED(x)
-  
-  * Include guards:
-  
-    * _PB_filename_ -> PB_filename_INCLUDED
-  
-  * Structure forward declaration tags:
-  
-    * _pb_field_t -> pb_field_s
-    * _pb_bytes_array_t -> pb_bytes_array_s
-    * _pb_callback_t -> pb_callback_s
-    * _pb_extension_type_t -> pb_extension_type_s
-    * _pb_extension_t -> pb_extension_s
-    * _pb_istream_t -> pb_istream_s
-    * _pb_ostream_t -> pb_ostream_s
-
-**Required actions:** Regenerate all *.pb.c* files. If you use any of the above
-identifiers in your application code, perform search-replace to the new name.
-
-**Error indications:** Compiler errors on lines with the macro/type names.
-
-Nanopb-0.2.9 (2014-08-09)
-=========================
-
-Change semantics of generator -e option
---------------------------------------
-**Rationale:** Some compilers do not accept filenames with two dots (like
-in default extension .pb.c). The *-e* option to the generator allowed changing
-the extension, but not skipping the extra dot.
-
-**Changes:** The *-e* option in generator will no longer add the prepending
-dot. The default value has been adjusted accordingly to *.pb.c* to keep the
-default behaviour the same as before.
-
-**Required actions:** Only if using the generator -e option. Add dot before
-the parameter value on the command line.
-
-**Error indications:** File not found when trying to compile generated files.
-
-Nanopb-0.2.7 (2014-04-07)
-=========================
-
-Changed pointer-type bytes field datatype
-----------------------------------------
-**Rationale:** In the initial pointer encoding support since nanopb-0.2.5,
-the bytes type used a separate *pb_bytes_ptr_t* type to represent *bytes*
-fields. This made it easy to encode data from a separate, user-allocated
-buffer. However, it made the internal logic more complex and was inconsistent
-with the other types.
-
-**Changes:** Dynamically allocated bytes fields now have the *pb_bytes_array_t*
-type, just like statically allocated ones.
-
-**Required actions:** Only if using pointer-type fields with the bytes datatype.
-Change any access to *msg->field.size* to *msg->field->size*. Change any
-allocation to reserve space of amount *PB_BYTES_ARRAY_T_ALLOCSIZE(n)*. If the
-data pointer was begin assigned from external source, implement the field using
-a callback function instead.
-
-**Error indications:** Compiler error: unknown type name *pb_bytes_ptr_t*.
-
-Nanopb-0.2.4 (2013-11-07)
-=========================
-
-Remove the NANOPB_INTERNALS compilation option
----------------------------------------------
-**Rationale:** Having the option in the headers required the functions to
-be non-static, even if the option is not used. This caused errors on some
-static analysis tools.
-
-**Changes:** The *#ifdef* and associated functions were removed from the
-header.
-
-**Required actions:** Only if the *NANOPB_INTERNALS* option was previously
-used. Actions are as listed under nanopb-0.1.3 and nanopb-0.1.6.
-
-**Error indications:** Compiler warning: implicit declaration of function
-*pb_dec_string*, *pb_enc_string*, or similar.
-
-Nanopb-0.2.1 (2013-04-14)
-=========================
-
-Callback function signature
---------------------------
-**Rationale:** Previously the auxilary data to field callbacks was passed
-as *void\**. This allowed passing of any data, but made it unnecessarily
-complex to return a pointer from callback.
-
-**Changes:** The callback function parameter was changed to *void\*\**.
-
-**Required actions:** You can continue using the old callback style by
-defining *PB_OLD_CALLBACK_STYLE*. Recommended action is to:
-
-  * Change the callback signatures to contain *void\*\** for decoders and
-    *void \* const \** for encoders.
-  * Change the callback function body to use *\*arg* instead of *arg*.
-
-**Error indications:** Compiler warning: assignment from incompatible
-pointer type, when initializing *funcs.encode* or *funcs.decode*.
-
-Nanopb-0.2.0 (2013-03-02)
-=========================
-
-Reformatted generated .pb.c file using macros
---------------------------------------------
-**Rationale:** Previously the generator made a list of C *pb_field_t*
-initializers in the .pb.c file. This led to a need to regenerate all .pb.c
-files after even small changes to the *pb_field_t* definition.
-
-**Changes:** Macros were added to pb.h which allow for cleaner definition
-of the .pb.c contents. By changing the macro definitions, changes to the
-field structure are possible without breaking compatibility with old .pb.c
-files.
-
-**Required actions:** Regenerate all .pb.c files from the .proto sources.
-
-**Error indications:** Compiler warning: implicit declaration of function
-*pb_delta_end*.
-
-Changed pb_type_t definitions
-----------------------------
-**Rationale:** The *pb_type_t* was previously an enumeration type. This
-caused warnings on some compilers when using bitwise operations to set flags
-inside the values.
-
-**Changes:** The *pb_type_t* was changed to *typedef uint8_t*. The values
-were changed to *#define*. Some value names were changed for consistency.
-
-**Required actions:** Only if you directly access the `pb_field_t` contents
-in your own code, something which is not usually done. Needed changes:
-
-  * Change *PB_HTYPE_ARRAY* to *PB_HTYPE_REPEATED*.
-  * Change *PB_HTYPE_CALLBACK* to *PB_ATYPE()* and *PB_ATYPE_CALLBACK*.
-
-**Error indications:** Compiler error: *PB_HTYPE_ARRAY* or *PB_HTYPE_CALLBACK*
-undeclared.
-
-Nanopb-0.1.6 (2012-09-02)
-=========================
-
-Refactored field decoder interface
----------------------------------
-**Rationale:** Similarly to field encoders in nanopb-0.1.3.
-
-**Changes:** New functions with names *pb_decode_\** were added.
-
-**Required actions:** By defining NANOPB_INTERNALS, you can still keep using
-the old functions. Recommended action is to replace any calls with the newer
-*pb_decode_\** equivalents.
-
-**Error indications:** Compiler warning: implicit declaration of function
-*pb_dec_string*, *pb_dec_varint*, *pb_dec_submessage* or similar.
-
-Nanopb-0.1.3 (2012-06-12)
-=========================
-
-Refactored field encoder interface
----------------------------------
-**Rationale:** The old *pb_enc_\** functions were designed mostly for the
-internal use by the core. Because they are internally accessed through
-function pointers, their signatures had to be common. This led to a confusing
-interface for external users.
-
-**Changes:** New functions with names *pb_encode_\** were added. These have
-easier to use interfaces. The old functions are now only thin wrappers for
-the new interface.
-
-**Required actions:** By defining NANOPB_INTERNALS, you can still keep using
-the old functions. Recommended action is to replace any calls with the newer
-*pb_encode_\** equivalents.
-
-**Error indications:** Compiler warning: implicit declaration of function
-*pb_enc_string*, *pb_enc_varint, *pb_enc_submessage* or similar.
-
--- a/docs/security.rst
+++ b/docs/security.rst
@@ -26,9 +26,9 @@ The following data is regarded as **trusted**. It must be under the control of
 the application writer. Malicious data in these structures could cause
 security issues, such as execution of arbitrary code:

-1. Callback, pointer and extension fields in message structures given to
-   pb_encode() and pb_decode(). These fields are memory pointers, and are
-   generated depending on the message definition in the .proto file.
+1. Callback and extension fields in message structures given to pb_encode()
+   and pb_decode(). These fields are memory pointers, and are generated
+   depending on the .proto file.
 2. The automatically generated field definitions, i.e. *pb_field_t* lists.
 3. Contents of the *pb_istream_t* and *pb_ostream_t* structures (this does not
   mean the contents of the stream itself, just the stream definition).
@@ -38,7 +38,7 @@ these will cause "garbage in, garbage out" behaviour. It will not cause
 buffer overflows, information disclosure or other security problems:

 1. All data read from *pb_istream_t*.
-2. All fields in message structures, except callbacks, pointers and extensions.
+2. All fields in message structures, except callbacks and extensions.
   (Beginning with nanopb-0.2.4, in earlier versions the field sizes are partially unchecked.)

 Invariants
@@ -76,6 +76,4 @@ The following list is not comprehensive:
   stop a denial of service attack from using an infinite message.
 4. If using network sockets as streams, a timeout should be set to stop
   denial of service attacks.
-5. If using *malloc()* support, some method of limiting memory use should be
-   employed. This can be done by defining custom *pb_realloc()* function.
-   Nanopb will properly detect and handle failed memory allocations.
+
--- a/examples/simple/Makefile
+++ b/examples/simple/Makefile
@@ -10,7 +10,6 @@ CSRC  = simple.c                   # The main program
 CSRC += simple.pb.c                # The compiled protocol definition
 CSRC += $(NANOPB_DIR)/pb_encode.c  # The nanopb encoder
 CSRC += $(NANOPB_DIR)/pb_decode.c  # The nanopb decoder
-CSRC += $(NANOPB_DIR)/pb_common.c  # The nanopb common parts

 # Build rule for the main program
 simple: $(CSRC)
--- a/extra/FindNanopb.cmake
+++ b/extra/FindNanopb.cmake
@@ -182,8 +182,8 @@ mark_as_advanced(NANOPB_INCLUDE_DIRS)
 # Find nanopb source files
 set(NANOPB_SRCS)
 set(NANOPB_HDRS)
-list(APPEND _nanopb_srcs pb_decode.c pb_encode.c pb_common.c)
-list(APPEND _nanopb_hdrs pb_decode.h pb_encode.h pb_common.h pb.h)
+list(APPEND _nanopb_srcs pb_decode.c pb_encode.c)
+list(APPEND _nanopb_hdrs pb_decode.h pb_encode.h pb.h)

 foreach(FIL ${_nanopb_srcs})
  find_file(${FIL}__nano_pb_file NAMES ${FIL} PATHS ${NANOPB_SRC_ROOT_FOLDER} ${NANOPB_INCLUDE_DIRS})
--- a/extra/nanopb.mk
+++ b/extra/nanopb.mk
@@ -5,7 +5,7 @@
 NANOPB_DIR := $(abspath $(dir $(lastword $(MAKEFILE_LIST)))../)

 # Files for the nanopb core
-NANOPB_CORE = $(NANOPB_DIR)/pb_encode.c $(NANOPB_DIR)/pb_decode.c $(NANOPB_DIR)/pb_common.c
+NANOPB_CORE = $(NANOPB_DIR)/pb_encode.c $(NANOPB_DIR)/pb_decode.c

 # Check if we are running on Windows
 ifdef windir
--- a/generator/nanopb_generator.py
+++ b/generator/nanopb_generator.py
@@ -1,7 +1,7 @@
 #!/usr/bin/python

 '''Generate header file for nanopb from a ProtoBuf FileDescriptorSet.'''
-nanopb_version = "nanopb-0.3.1"
+nanopb_version = "nanopb-0.2.9.2"

 import sys

@@ -261,7 +261,7 @@ class Field:
        result = ''
        if self.allocation == 'POINTER':
            if self.rules == 'REPEATED':
-                result += '    pb_size_t ' + self.name + '_count;\n'
+                result += '    size_t ' + self.name + '_count;\n'
            
            if self.pbtype == 'MESSAGE':
                # Use struct definition, so recursive submessages are possible
@@ -277,14 +277,17 @@ class Field:
            if self.rules == 'OPTIONAL' and self.allocation == 'STATIC':
                result += '    bool has_' + self.name + ';\n'
            elif self.rules == 'REPEATED' and self.allocation == 'STATIC':
-                result += '    pb_size_t ' + self.name + '_count;\n'
+                result += '    size_t ' + self.name + '_count;\n'
            result += '    %s %s%s;' % (self.ctype, self.name, self.array_decl)
        return result
    
    def types(self):
        '''Return definitions for any special types this field might need.'''
        if self.pbtype == 'BYTES' and self.allocation == 'STATIC':
-            result = 'typedef PB_BYTES_ARRAY_T(%d) %s;\n' % (self.max_size, self.ctype)
+            result = 'typedef struct {\n'
+            result += '    size_t size;\n'
+            result += '    uint8_t bytes[%d];\n' % self.max_size
+            result += '} %s;\n' % self.ctype
        else:
            result = None
        return result
@@ -361,7 +364,7 @@ class Field:
        '''Return the pb_field_t initializer to use in the constant array.
        prev_field_name is the name of the previous field or None.
        '''
-        result  = '    PB_FIELD(%3d, ' % self.tag
+        result  = '    PB_FIELD2(%3d, ' % self.tag
        result += '%-8s, ' % self.pbtype
        result += '%s, ' % self.rules
        result += '%-8s, ' % self.allocation
@@ -546,7 +549,7 @@ class Message:

    def get_dependencies(self):
        '''Get list of type names that this structure refers to.'''
-        return [str(field.ctype) for field in self.fields if field.allocation == 'STATIC']
+        return [str(field.ctype) for field in self.fields]
    
    def __str__(self):
        result = 'typedef struct _%s {\n' % self.name
@@ -770,8 +773,8 @@ def generate_header(dependencies, headername, enums, messages, extensions, optio
        yield '/* Generated by %s at %s. */\n\n' % (nanopb_version, time.asctime())
    
    symbol = make_identifier(headername)
-    yield '#ifndef PB_%s_INCLUDED\n' % symbol
-    yield '#define PB_%s_INCLUDED\n' % symbol
+    yield '#ifndef _PB_%s_\n' % symbol
+    yield '#define _PB_%s_\n' % symbol
    try:
        yield options.libformat % ('pb.h')
    except TypeError:
@@ -784,11 +787,6 @@ def generate_header(dependencies, headername, enums, messages, extensions, optio
        yield options.genformat % (noext + options.extension + '.h')
        yield '\n'

-    yield '#if PB_PROTO_HEADER_VERSION != 30\n'
-    yield '#error Regenerate this file with the current version of nanopb generator.\n'
-    yield '#endif\n'
-    yield '\n'
-
    yield '#ifdef __cplusplus\n'
    yield 'extern "C" {\n'
    yield '#endif\n\n'
@@ -861,11 +859,6 @@ def generate_source(headername, enums, messages, extensions, options):
    yield options.genformat % (headername)
    yield '\n'
    
-    yield '#if PB_PROTO_HEADER_VERSION != 30\n'
-    yield '#error Regenerate this file with the current version of nanopb generator.\n'
-    yield '#endif\n'
-    yield '\n'
-    
    for msg in messages:
        yield msg.default_decl(False)
    
@@ -920,7 +913,7 @@ def generate_source(headername, enums, messages, extensions, options):
                yield ' * numbers or field sizes that are larger than what can fit in 8 or 16 bit\n'
                yield ' * field descriptors.\n'
                yield ' */\n'
-                yield 'PB_STATIC_ASSERT((%s), YOU_MUST_DEFINE_PB_FIELD_32BIT_FOR_MESSAGES_%s)\n'%(assertion,msgs)
+                yield 'STATIC_ASSERT((%s), YOU_MUST_DEFINE_PB_FIELD_32BIT_FOR_MESSAGES_%s)\n'%(assertion,msgs)
            yield '#endif\n\n'
        
        if worst < 65536:
@@ -937,7 +930,7 @@ def generate_source(headername, enums, messages, extensions, options):
                yield ' * numbers or field sizes that are larger than what can fit in the default\n'
                yield ' * 8 bit descriptors.\n'
                yield ' */\n'
-                yield 'PB_STATIC_ASSERT((%s), YOU_MUST_DEFINE_PB_FIELD_16BIT_FOR_MESSAGES_%s)\n'%(assertion,msgs)
+                yield 'STATIC_ASSERT((%s), YOU_MUST_DEFINE_PB_FIELD_16BIT_FOR_MESSAGES_%s)\n'%(assertion,msgs)
            yield '#endif\n\n'
    
    # Add check for sizeof(double)
@@ -953,7 +946,7 @@ def generate_source(headername, enums, messages, extensions, options):
        yield ' * These are not directly supported by nanopb, but see example_avr_double.\n'
        yield ' * To get rid of this error, remove any double fields from your .proto.\n'
        yield ' */\n'
-        yield 'PB_STATIC_ASSERT(sizeof(double) == 8, DOUBLE_MUST_BE_8_BYTES)\n'
+        yield 'STATIC_ASSERT(sizeof(double) == 8, DOUBLE_MUST_BE_8_BYTES)\n'
    
    yield '\n'

--- a/pb.h
+++ b/pb.h
@@ -2,8 +2,8 @@
 * stuff. For the high-level interface, see pb_encode.h and pb_decode.h.
 */

-#ifndef PB_H_INCLUDED
-#define PB_H_INCLUDED
+#ifndef _PB_H_
+#define _PB_H_

 /*****************************************************************
 * Nanopb compilation time options. You can change these here by *
@@ -46,7 +46,7 @@

 /* Version of the nanopb library. Just in case you want to check it in
 * your own program. */
-#define NANOPB_VERSION nanopb-0.3.1
+#define NANOPB_VERSION nanopb-0.2.9.2

 /* Include all the system headers needed by nanopb. You will need the
 * definitions of the following:
@@ -98,27 +98,23 @@
 #endif

 /* Handly macro for suppressing unreferenced-parameter compiler warnings. */
-#ifndef PB_UNUSED
-#define PB_UNUSED(x) (void)(x)
+#ifndef UNUSED
+#define UNUSED(x) (void)(x)
 #endif

 /* Compile-time assertion, used for checking compatible compilation options.
- * If this does not work properly on your compiler, use
- * #define PB_NO_STATIC_ASSERT to disable it.
+ * If this does not work properly on your compiler, use #define STATIC_ASSERT
+ * to disable it.
 *
 * But before doing that, check carefully the error message / place where it
 * comes from to see if the error has a real cause. Unfortunately the error
 * message is not always very clear to read, but you can see the reason better
- * in the place where the PB_STATIC_ASSERT macro was called.
+ * in the place where the STATIC_ASSERT macro was called.
 */
-#ifndef PB_NO_STATIC_ASSERT
-#ifndef PB_STATIC_ASSERT
-#define PB_STATIC_ASSERT(COND,MSG) typedef char PB_STATIC_ASSERT_MSG(MSG, __LINE__, __COUNTER__)[(COND)?1:-1];
-#define PB_STATIC_ASSERT_MSG(MSG, LINE, COUNTER) PB_STATIC_ASSERT_MSG_(MSG, LINE, COUNTER)
-#define PB_STATIC_ASSERT_MSG_(MSG, LINE, COUNTER) pb_static_assertion_##MSG##LINE##COUNTER
-#endif
-#else
-#define PB_STATIC_ASSERT(COND,MSG)
+#ifndef STATIC_ASSERT
+#define STATIC_ASSERT(COND,MSG) typedef char STATIC_ASSERT_MSG(MSG, __LINE__, __COUNTER__)[(COND)?1:-1];
+#define STATIC_ASSERT_MSG(MSG, LINE, COUNTER) STATIC_ASSERT_MSG_(MSG, LINE, COUNTER)
+#define STATIC_ASSERT_MSG_(MSG, LINE, COUNTER) static_assertion_##MSG##LINE##COUNTER
 #endif

 /* Number of required fields to keep track of. */
@@ -191,15 +187,12 @@ typedef uint8_t pb_type_t;
 * and array counts.
 */
 #if defined(PB_FIELD_32BIT)
-#define PB_SIZE_MAX ((uint32_t)-1)
    typedef uint32_t pb_size_t;
    typedef int32_t pb_ssize_t;
 #elif defined(PB_FIELD_16BIT)
-#define PB_SIZE_MAX ((uint16_t)-1)
    typedef uint16_t pb_size_t;
    typedef int16_t pb_ssize_t;
 #else
-#define PB_SIZE_MAX ((uint8_t)-1)
    typedef uint8_t pb_size_t;
    typedef int8_t pb_ssize_t;
 #endif
@@ -213,8 +206,8 @@ typedef uint8_t pb_type_t;
 * PB_FIELD_32BIT.
 */
 PB_PACKED_STRUCT_START
-typedef struct pb_field_s pb_field_t;
-struct pb_field_s {
+typedef struct _pb_field_t pb_field_t;
+struct _pb_field_t {
    pb_size_t tag;
    pb_type_t type;
    pb_size_t data_offset; /* Offset of field data, relative to previous field. */
@@ -235,27 +228,27 @@ PB_PACKED_STRUCT_END
 * If you get errors here, it probably means that your stdint.h is not
 * correct for your platform.
 */
-PB_STATIC_ASSERT(sizeof(int8_t) == 1, INT8_T_WRONG_SIZE)
-PB_STATIC_ASSERT(sizeof(uint8_t) == 1, UINT8_T_WRONG_SIZE)
-PB_STATIC_ASSERT(sizeof(int16_t) == 2, INT16_T_WRONG_SIZE)
-PB_STATIC_ASSERT(sizeof(uint16_t) == 2, UINT16_T_WRONG_SIZE)
-PB_STATIC_ASSERT(sizeof(int32_t) == 4, INT32_T_WRONG_SIZE)
-PB_STATIC_ASSERT(sizeof(uint32_t) == 4, UINT32_T_WRONG_SIZE)
-PB_STATIC_ASSERT(sizeof(int64_t) == 8, INT64_T_WRONG_SIZE)
-PB_STATIC_ASSERT(sizeof(uint64_t) == 8, UINT64_T_WRONG_SIZE)
+STATIC_ASSERT(sizeof(int8_t) == 1, INT8_T_WRONG_SIZE)
+STATIC_ASSERT(sizeof(uint8_t) == 1, UINT8_T_WRONG_SIZE)
+STATIC_ASSERT(sizeof(int16_t) == 2, INT16_T_WRONG_SIZE)
+STATIC_ASSERT(sizeof(uint16_t) == 2, UINT16_T_WRONG_SIZE)
+STATIC_ASSERT(sizeof(int32_t) == 4, INT32_T_WRONG_SIZE)
+STATIC_ASSERT(sizeof(uint32_t) == 4, UINT32_T_WRONG_SIZE)
+STATIC_ASSERT(sizeof(int64_t) == 8, INT64_T_WRONG_SIZE)
+STATIC_ASSERT(sizeof(uint64_t) == 8, UINT64_T_WRONG_SIZE)

 /* This structure is used for 'bytes' arrays.
 * It has the number of bytes in the beginning, and after that an array.
 * Note that actual structs used will have a different length of bytes array.
 */
-#define PB_BYTES_ARRAY_T(n) struct { pb_size_t size; uint8_t bytes[n]; }
+#define PB_BYTES_ARRAY_T(n) struct { size_t size; uint8_t bytes[n]; }
 #define PB_BYTES_ARRAY_T_ALLOCSIZE(n) ((size_t)n + offsetof(pb_bytes_array_t, bytes))

-struct pb_bytes_array_s {
-    pb_size_t size;
+struct _pb_bytes_array_t {
+    size_t size;
    uint8_t bytes[1];
 };
-typedef struct pb_bytes_array_s pb_bytes_array_t;
+typedef struct _pb_bytes_array_t pb_bytes_array_t;

 /* This structure is used for giving the callback function.
 * It is stored in the message structure and filled in by the method that
@@ -275,10 +268,10 @@ typedef struct pb_bytes_array_s pb_bytes_array_t;
 *
 * The callback can be null if you want to skip a field.
 */
-typedef struct pb_istream_s pb_istream_t;
-typedef struct pb_ostream_s pb_ostream_t;
-typedef struct pb_callback_s pb_callback_t;
-struct pb_callback_s {
+typedef struct _pb_istream_t pb_istream_t;
+typedef struct _pb_ostream_t pb_ostream_t;
+typedef struct _pb_callback_t pb_callback_t;
+struct _pb_callback_t {
 #ifdef PB_OLD_CALLBACK_STYLE
    /* Deprecated since nanopb-0.2.1 */
    union {
@@ -311,9 +304,9 @@ typedef enum {
 * if you want to catch all unknown fields, you can also create a custom
 * pb_extension_type_t with your own callback.
 */
-typedef struct pb_extension_type_s pb_extension_type_t;
-typedef struct pb_extension_s pb_extension_t;
-struct pb_extension_type_s {
+typedef struct _pb_extension_type_t pb_extension_type_t;
+typedef struct _pb_extension_t pb_extension_t;
+struct _pb_extension_type_t {
    /* Called for each unknown field in the message.
     * If you handle the field, read off all of its data and return true.
     * If you do not handle the field, do not read anything and return true.
@@ -335,7 +328,7 @@ struct pb_extension_type_s {
    const void *arg;
 };

-struct pb_extension_s {
+struct _pb_extension_t {
    /* Type describing the extension field. Usually you'll initialize
     * this to a pointer to the automatically generated structure. */
    const pb_extension_type_t *type;
@@ -365,9 +358,6 @@ struct pb_extension_s {
 #   endif
 #endif

-/* This is used to inform about need to regenerate .pb.h/.pb.c files. */
-#define PB_PROTO_HEADER_VERSION 30
-
 /* These macros are used to declare pb_field_t's in the constant array. */
 /* Size of a structure member, in bytes. */
 #define pb_membersize(st, m) (sizeof ((st*)0)->m)
@@ -479,15 +469,26 @@ struct pb_extension_s {
 *                 SINT32, SINT64, STRING, UINT32, UINT64 or EXTENSION
 * - Field rules:  REQUIRED, OPTIONAL or REPEATED
 * - Allocation:   STATIC or CALLBACK
- * - Placement: FIRST or OTHER, depending on if this is the first field in structure.
 * - Message name
 * - Field name
 * - Previous field name (or field name again for first field)
 * - Pointer to default value or submsg fields.
 */

-#define PB_FIELD(tag, type, rules, allocation, placement, message, field, prevfield, ptr) \
-        PB_ ## rules ## _ ## allocation(tag, message, field, \
+#define PB_FIELD(tag, type, rules, allocation, message, field, prevfield, ptr) \
+    PB_ ## rules ## _ ## allocation(tag, message, field, \
+        PB_DATAOFFSET_CHOOSE(message, field, prevfield), \
+        PB_LTYPE_MAP_ ## type, ptr)
+
+/* This is a new version of the macro used by nanopb generator from
+ * version 0.2.3 onwards. It avoids the use of a ternary expression in
+ * the initialization, which confused some compilers.
+ *
+ * - Placement: FIRST or OTHER, depending on if this is the first field in structure.
+ *
+ */
+#define PB_FIELD2(tag, type, rules, allocation, placement, message, field, prevfield, ptr) \
+    PB_ ## rules ## _ ## allocation(tag, message, field, \
        PB_DATAOFFSET_ ## placement(message, field, prevfield), \
        PB_LTYPE_MAP_ ## type, ptr)

@@ -501,7 +502,7 @@ struct pb_extension_s {
 #ifdef PB_NO_ERRMSG
 #define PB_RETURN_ERROR(stream,msg) \
    do {\
-        PB_UNUSED(stream); \
+        UNUSED(stream); \
        return false; \
    } while(0)
 #define PB_GET_ERROR(stream) "(errmsg disabled)"
--- a/pb_common.c
+++ b/pb_common.c
@@ -1,90 +0,0 @@
-/* pb_common.c: Common support functions for pb_encode.c and pb_decode.c.
- *
- * 2014 Petteri Aimonen <jpa@kapsi.fi>
- */
-
-#include "pb_common.h"
-
-bool pb_field_iter_begin(pb_field_iter_t *iter, const pb_field_t *fields, void *dest_struct)
-{
-    iter->start = fields;
-    iter->pos = fields;
-    iter->required_field_index = 0;
-    iter->dest_struct = dest_struct;
-    iter->pData = (char*)dest_struct + iter->pos->data_offset;
-    iter->pSize = (char*)iter->pData + iter->pos->size_offset;
-    
-    return (iter->pos->tag != 0);
-}
-
-bool pb_field_iter_next(pb_field_iter_t *iter)
-{
-    const pb_field_t *prev_field = iter->pos;
-
-    if (prev_field->tag == 0)
-    {
-        /* Handle empty message types, where the first field is already the terminator.
-         * In other cases, the iter->pos never points to the terminator. */
-        return false;
-    }
-    
-    iter->pos++;
-    
-    if (iter->pos->tag == 0)
-    {
-        /* Wrapped back to beginning, reinitialize */
-        (void)pb_field_iter_begin(iter, iter->start, iter->dest_struct);
-        return false;
-    }
-    else
-    {
-        /* Increment the pointers based on previous field size */
-        size_t prev_size = prev_field->data_size;
-    
-        if (PB_ATYPE(prev_field->type) == PB_ATYPE_STATIC &&
-            PB_HTYPE(prev_field->type) == PB_HTYPE_REPEATED)
-        {
-            /* In static arrays, the data_size tells the size of a single entry and
-             * array_size is the number of entries */
-            prev_size *= prev_field->array_size;
-        }
-        else if (PB_ATYPE(prev_field->type) == PB_ATYPE_POINTER)
-        {
-            /* Pointer fields always have a constant size in the main structure.
-             * The data_size only applies to the dynamically allocated area. */
-            prev_size = sizeof(void*);
-        }
-        
-        if (PB_HTYPE(prev_field->type) == PB_HTYPE_REQUIRED)
-        {
-            /* Count the required fields, in order to check their presence in the
-             * decoder. */
-            iter->required_field_index++;
-        }
-    
-        iter->pData = (char*)iter->pData + prev_size + iter->pos->data_offset;
-        iter->pSize = (char*)iter->pData + iter->pos->size_offset;
-        return true;
-    }
-}
-
-bool pb_field_iter_find(pb_field_iter_t *iter, uint32_t tag)
-{
-    const pb_field_t *start = iter->pos;
-    
-    do {
-        if (iter->pos->tag == tag &&
-            PB_LTYPE(iter->pos->type) != PB_LTYPE_EXTENSION)
-        {
-            /* Found the wanted field */
-            return true;
-        }
-        
-        (void)pb_field_iter_next(iter);
-    } while (iter->pos != start);
-    
-    /* Searched all the way back to start, and found nothing. */
-    return false;
-}
-
-
--- a/pb_common.h
+++ b/pb_common.h
@@ -1,42 +0,0 @@
-/* pb_common.h: Common support functions for pb_encode.c and pb_decode.c.
- * These functions are rarely needed by applications directly.
- */
-
-#ifndef PB_COMMON_H_INCLUDED
-#define PB_COMMON_H_INCLUDED
-
-#include "pb.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* Iterator for pb_field_t list */
-struct pb_field_iter_s {
-    const pb_field_t *start;       /* Start of the pb_field_t array */
-    const pb_field_t *pos;         /* Current position of the iterator */
-    unsigned required_field_index; /* Zero-based index that counts only the required fields */
-    void *dest_struct;             /* Pointer to start of the structure */
-    void *pData;                   /* Pointer to current field value */
-    void *pSize;                   /* Pointer to count/has field */
-};
-typedef struct pb_field_iter_s pb_field_iter_t;
-
-/* Initialize the field iterator structure to beginning.
- * Returns false if the message type is empty. */
-bool pb_field_iter_begin(pb_field_iter_t *iter, const pb_field_t *fields, void *dest_struct);
-
-/* Advance the iterator to the next field.
- * Returns false when the iterator wraps back to the first field. */
-bool pb_field_iter_next(pb_field_iter_t *iter);
-
-/* Advance the iterator until it points at a field with the given tag.
- * Returns false if no such field exists. */
-bool pb_field_iter_find(pb_field_iter_t *iter, uint32_t tag);
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
-
-#endif
-
--- a/pb_decode.c
+++ b/pb_decode.c
@@ -15,23 +15,37 @@

 #include "pb.h"
 #include "pb_decode.h"
-#include "pb_common.h"

 /**************************************
 * Declarations internal to this file *
 **************************************/

+/* Iterator for pb_field_t list */
+typedef struct {
+    const pb_field_t *start; /* Start of the pb_field_t array */
+    const pb_field_t *pos; /* Current position of the iterator */
+    unsigned field_index; /* Zero-based index of the field. */
+    unsigned required_field_index; /* Zero-based index that counts only the required fields */
+    void *dest_struct; /* Pointer to the destination structure to decode to */
+    void *pData; /* Pointer where to store current field value */
+    void *pSize; /* Pointer where to store the size of current array field */
+} pb_field_iterator_t;
+
 typedef bool (*pb_decoder_t)(pb_istream_t *stream, const pb_field_t *field, void *dest) checkreturn;

 static bool checkreturn buf_read(pb_istream_t *stream, uint8_t *buf, size_t count);
 static bool checkreturn pb_decode_varint32(pb_istream_t *stream, uint32_t *dest);
 static bool checkreturn read_raw_value(pb_istream_t *stream, pb_wire_type_t wire_type, uint8_t *buf, size_t *size);
-static bool checkreturn decode_static_field(pb_istream_t *stream, pb_wire_type_t wire_type, pb_field_iter_t *iter);
-static bool checkreturn decode_callback_field(pb_istream_t *stream, pb_wire_type_t wire_type, pb_field_iter_t *iter);
-static bool checkreturn decode_field(pb_istream_t *stream, pb_wire_type_t wire_type, pb_field_iter_t *iter);
+static void pb_field_init(pb_field_iterator_t *iter, const pb_field_t *fields, void *dest_struct);
+static bool pb_field_next(pb_field_iterator_t *iter);
+static bool checkreturn pb_field_find(pb_field_iterator_t *iter, uint32_t tag);
+static bool checkreturn decode_static_field(pb_istream_t *stream, pb_wire_type_t wire_type, pb_field_iterator_t *iter);
+static bool checkreturn decode_callback_field(pb_istream_t *stream, pb_wire_type_t wire_type, pb_field_iterator_t *iter);
+static bool checkreturn decode_field(pb_istream_t *stream, pb_wire_type_t wire_type, pb_field_iterator_t *iter);
+static void iter_from_extension(pb_field_iterator_t *iter, pb_extension_t *extension);
 static bool checkreturn default_extension_decoder(pb_istream_t *stream, pb_extension_t *extension, uint32_t tag, pb_wire_type_t wire_type);
-static bool checkreturn decode_extension(pb_istream_t *stream, uint32_t tag, pb_wire_type_t wire_type, pb_field_iter_t *iter);
-static bool checkreturn find_extension_field(pb_field_iter_t *iter);
+static bool checkreturn decode_extension(pb_istream_t *stream, uint32_t tag, pb_wire_type_t wire_type, pb_field_iterator_t *iter);
+static bool checkreturn find_extension_field(pb_field_iterator_t *iter);
 static void pb_message_set_to_defaults(const pb_field_t fields[], void *dest_struct);
 static bool checkreturn pb_dec_varint(pb_istream_t *stream, const pb_field_t *field, void *dest);
 static bool checkreturn pb_dec_uvarint(pb_istream_t *stream, const pb_field_t *field, void *dest);
@@ -46,7 +60,7 @@ static bool checkreturn pb_skip_string(pb_istream_t *stream);

 #ifdef PB_ENABLE_MALLOC
 static bool checkreturn allocate_field(pb_istream_t *stream, void *pData, size_t data_size, size_t array_size);
-static void pb_release_single_field(const pb_field_iter_t *iter);
+static void pb_release_single_field(const pb_field_iterator_t *iter);
 #endif

 /* --- Function pointers to field decoders ---
@@ -330,11 +344,75 @@ void pb_close_string_substream(pb_istream_t *stream, pb_istream_t *substream)
 #endif
 }

+static void pb_field_init(pb_field_iterator_t *iter, const pb_field_t *fields, void *dest_struct)
+{
+    iter->start = iter->pos = fields;
+    iter->field_index = 0;
+    iter->required_field_index = 0;
+    iter->pData = (char*)dest_struct + iter->pos->data_offset;
+    iter->pSize = (char*)iter->pData + iter->pos->size_offset;
+    iter->dest_struct = dest_struct;
+}
+
+static bool pb_field_next(pb_field_iterator_t *iter)
+{
+    bool notwrapped = true;
+    size_t prev_size = iter->pos->data_size;
+    
+    if (PB_ATYPE(iter->pos->type) == PB_ATYPE_STATIC &&
+        PB_HTYPE(iter->pos->type) == PB_HTYPE_REPEATED)
+    {
+        prev_size *= iter->pos->array_size;
+    }
+    else if (PB_ATYPE(iter->pos->type) == PB_ATYPE_POINTER)
+    {
+        prev_size = sizeof(void*);
+    }
+    
+    if (iter->pos->tag == 0)
+        return false; /* Only happens with empty message types */
+    
+    if (PB_HTYPE(iter->pos->type) == PB_HTYPE_REQUIRED)
+        iter->required_field_index++;
+    
+    iter->pos++;
+    iter->field_index++;
+    if (iter->pos->tag == 0)
+    {
+        iter->pos = iter->start;
+        iter->field_index = 0;
+        iter->required_field_index = 0;
+        iter->pData = iter->dest_struct;
+        prev_size = 0;
+        notwrapped = false;
+    }
+    
+    iter->pData = (char*)iter->pData + prev_size + iter->pos->data_offset;
+    iter->pSize = (char*)iter->pData + iter->pos->size_offset;
+    return notwrapped;
+}
+
+static bool checkreturn pb_field_find(pb_field_iterator_t *iter, uint32_t tag)
+{
+    unsigned start = iter->field_index;
+    
+    do {
+        if (iter->pos->tag == tag &&
+            PB_LTYPE(iter->pos->type) != PB_LTYPE_EXTENSION)
+        {
+            return true;
+        }
+        (void)pb_field_next(iter);
+    } while (iter->field_index != start);
+    
+    return false;
+}
+
 /*************************
 * Decode a single field *
 *************************/

-static bool checkreturn decode_static_field(pb_istream_t *stream, pb_wire_type_t wire_type, pb_field_iter_t *iter)
+static bool checkreturn decode_static_field(pb_istream_t *stream, pb_wire_type_t wire_type, pb_field_iterator_t *iter)
 {
    pb_type_t type;
    pb_decoder_t func;
@@ -357,7 +435,7 @@ static bool checkreturn decode_static_field(pb_istream_t *stream, pb_wire_type_t
            {
                /* Packed array */
                bool status = true;
-                pb_size_t *size = (pb_size_t*)iter->pSize;
+                size_t *size = (size_t*)iter->pSize;
                pb_istream_t substream;
                if (!pb_make_string_substream(stream, &substream))
                    return false;
@@ -382,7 +460,7 @@ static bool checkreturn decode_static_field(pb_istream_t *stream, pb_wire_type_t
            else
            {
                /* Repeated field */
-                pb_size_t *size = (pb_size_t*)iter->pSize;
+                size_t *size = (size_t*)iter->pSize;
                void *pItem = (uint8_t*)iter->pData + iter->pos->data_size * (*size);
                if (*size >= iter->pos->array_size)
                    PB_RETURN_ERROR(stream, "array overflow");
@@ -437,7 +515,7 @@ static bool checkreturn allocate_field(pb_istream_t *stream, void *pData, size_t
 }

 /* Clear a newly allocated item in case it contains a pointer, or is a submessage. */
-static void initialize_pointer_field(void *pItem, pb_field_iter_t *iter)
+static void initialize_pointer_field(void *pItem, pb_field_iterator_t *iter)
 {
    if (PB_LTYPE(iter->pos->type) == PB_LTYPE_STRING ||
        PB_LTYPE(iter->pos->type) == PB_LTYPE_BYTES)
@@ -451,11 +529,11 @@ static void initialize_pointer_field(void *pItem, pb_field_iter_t *iter)
 }
 #endif

-static bool checkreturn decode_pointer_field(pb_istream_t *stream, pb_wire_type_t wire_type, pb_field_iter_t *iter)
+static bool checkreturn decode_pointer_field(pb_istream_t *stream, pb_wire_type_t wire_type, pb_field_iterator_t *iter)
 {
 #ifndef PB_ENABLE_MALLOC
-    PB_UNUSED(wire_type);
-    PB_UNUSED(iter);
+    UNUSED(wire_type);
+    UNUSED(iter);
    PB_RETURN_ERROR(stream, "no malloc support");
 #else
    pb_type_t type;
@@ -495,7 +573,7 @@ static bool checkreturn decode_pointer_field(pb_istream_t *stream, pb_wire_type_
            {
                /* Packed array, multiple items come in at once. */
                bool status = true;
-                pb_size_t *size = (pb_size_t*)iter->pSize;
+                size_t *size = (size_t*)iter->pSize;
                size_t allocated_size = *size;
                void *pItem;
                pb_istream_t substream;
@@ -505,7 +583,7 @@ static bool checkreturn decode_pointer_field(pb_istream_t *stream, pb_wire_type_
                
                while (substream.bytes_left)
                {
-                    if ((size_t)*size + 1 > allocated_size)
+                    if (*size + 1 > allocated_size)
                    {
                        /* Allocate more storage. This tries to guess the
                         * number of remaining entries. Round the division
@@ -527,16 +605,6 @@ static bool checkreturn decode_pointer_field(pb_istream_t *stream, pb_wire_type_
                        status = false;
                        break;
                    }
-                    
-                    if (*size == PB_SIZE_MAX)
-                    {
-#ifndef PB_NO_ERRMSG
-                        stream->errmsg = "too many array entries";
-#endif
-                        status = false;
-                        break;
-                    }
-                    
                    (*size)++;
                }
                pb_close_string_substream(stream, &substream);
@@ -546,12 +614,9 @@ static bool checkreturn decode_pointer_field(pb_istream_t *stream, pb_wire_type_
            else
            {
                /* Normal repeated field, i.e. only one item at a time. */
-                pb_size_t *size = (pb_size_t*)iter->pSize;
+                size_t *size = (size_t*)iter->pSize;
                void *pItem;
                
-                if (*size == PB_SIZE_MAX)
-                    PB_RETURN_ERROR(stream, "too many array entries");
-                
                (*size)++;
                if (!allocate_field(stream, iter->pData, iter->pos->data_size, *size))
                    return false;
@@ -567,7 +632,7 @@ static bool checkreturn decode_pointer_field(pb_istream_t *stream, pb_wire_type_
 #endif
 }

-static bool checkreturn decode_callback_field(pb_istream_t *stream, pb_wire_type_t wire_type, pb_field_iter_t *iter)
+static bool checkreturn decode_callback_field(pb_istream_t *stream, pb_wire_type_t wire_type, pb_field_iterator_t *iter)
 {
    pb_callback_t *pCallback = (pb_callback_t*)iter->pData;
    
@@ -614,7 +679,7 @@ static bool checkreturn decode_callback_field(pb_istream_t *stream, pb_wire_type
    }
 }

-static bool checkreturn decode_field(pb_istream_t *stream, pb_wire_type_t wire_type, pb_field_iter_t *iter)
+static bool checkreturn decode_field(pb_istream_t *stream, pb_wire_type_t wire_type, pb_field_iterator_t *iter)
 {
    switch (PB_ATYPE(iter->pos->type))
    {
@@ -632,31 +697,38 @@ static bool checkreturn decode_field(pb_istream_t *stream, pb_wire_type_t wire_t
    }
 }

+static void iter_from_extension(pb_field_iterator_t *iter, pb_extension_t *extension)
+{
+    const pb_field_t *field = (const pb_field_t*)extension->type->arg;
+    
+    iter->start = field;
+    iter->pos = field;
+    iter->field_index = 0;
+    iter->required_field_index = 0;
+    iter->dest_struct = extension->dest;
+    iter->pData = extension->dest;
+    iter->pSize = &extension->found;
+}
+
 /* Default handler for extension fields. Expects a pb_field_t structure
 * in extension->type->arg. */
 static bool checkreturn default_extension_decoder(pb_istream_t *stream,
    pb_extension_t *extension, uint32_t tag, pb_wire_type_t wire_type)
 {
    const pb_field_t *field = (const pb_field_t*)extension->type->arg;
-    pb_field_iter_t iter;
+    pb_field_iterator_t iter;
    
    if (field->tag != tag)
        return true;
    
-    /* Fake a field iterator for the extension field.
-     * It is not actually safe to advance this iterator, but decode_field
-     * will not even try to. */
-    (void)pb_field_iter_begin(&iter, field, extension->dest);
-    iter.pData = extension->dest;
-    iter.pSize = &extension->found;
-    
+    iter_from_extension(&iter, extension);
    return decode_field(stream, wire_type, &iter);
 }

 /* Try to decode an unknown field as an extension field. Tries each extension
 * decoder in turn, until one of them handles the field or loop ends. */
 static bool checkreturn decode_extension(pb_istream_t *stream,
-    uint32_t tag, pb_wire_type_t wire_type, pb_field_iter_t *iter)
+    uint32_t tag, pb_wire_type_t wire_type, pb_field_iterator_t *iter)
 {
    pb_extension_t *extension = *(pb_extension_t* const *)iter->pData;
    size_t pos = stream->bytes_left;
@@ -681,15 +753,15 @@ static bool checkreturn decode_extension(pb_istream_t *stream,
 /* Step through the iterator until an extension field is found or until all
 * entries have been checked. There can be only one extension field per
 * message. Returns false if no extension field is found. */
-static bool checkreturn find_extension_field(pb_field_iter_t *iter)
+static bool checkreturn find_extension_field(pb_field_iterator_t *iter)
 {
-    const pb_field_t *start = iter->pos;
+    unsigned start = iter->field_index;
    
    do {
        if (PB_LTYPE(iter->pos->type) == PB_LTYPE_EXTENSION)
            return true;
-        (void)pb_field_iter_next(iter);
-    } while (iter->pos != start);
+        (void)pb_field_next(iter);
+    } while (iter->field_index != start);
    
    return false;
 }
@@ -697,15 +769,17 @@ static bool checkreturn find_extension_field(pb_field_iter_t *iter)
 /* Initialize message fields to default values, recursively */
 static void pb_message_set_to_defaults(const pb_field_t fields[], void *dest_struct)
 {
-    pb_field_iter_t iter;
-
-    if (!pb_field_iter_begin(&iter, fields, dest_struct))
-        return; /* Empty message type */
+    pb_field_iterator_t iter;
+    pb_field_init(&iter, fields, dest_struct);
    
    do
    {
        pb_type_t type;
        type = iter.pos->type;
+    
+        /* Avoid crash on empty message types (zero fields) */
+        if (iter.pos->tag == 0)
+            continue;
        
        if (PB_ATYPE(type) == PB_ATYPE_STATIC)
        {
@@ -718,7 +792,7 @@ static void pb_message_set_to_defaults(const pb_field_t fields[], void *dest_str
            else if (PB_HTYPE(type) == PB_HTYPE_REPEATED)
            {
                /* Set array count to 0, no need to initialize contents. */
-                *(pb_size_t*)iter.pSize = 0;
+                *(size_t*)iter.pSize = 0;
                continue;
            }
            
@@ -746,14 +820,14 @@ static void pb_message_set_to_defaults(const pb_field_t fields[], void *dest_str
            /* Initialize array count to 0. */
            if (PB_HTYPE(type) == PB_HTYPE_REPEATED)
            {
-                *(pb_size_t*)iter.pSize = 0;
+                *(size_t*)iter.pSize = 0;
            }
        }
        else if (PB_ATYPE(type) == PB_ATYPE_CALLBACK)
        {
            /* Don't overwrite callback */
        }
-    } while (pb_field_iter_next(&iter));
+    } while (pb_field_next(&iter));
 }

 /*********************
@@ -764,11 +838,9 @@ bool checkreturn pb_decode_noinit(pb_istream_t *stream, const pb_field_t fields[
 {
    uint8_t fields_seen[(PB_MAX_REQUIRED_FIELDS + 7) / 8] = {0, 0, 0, 0, 0, 0, 0, 0};
    uint32_t extension_range_start = 0;
-    pb_field_iter_t iter;
+    pb_field_iterator_t iter;
    
-    /* Return value ignored, as empty message types will be correctly handled by
-     * pb_field_iter_find() anyway. */
-    (void)pb_field_iter_begin(&iter, fields, dest_struct);
+    pb_field_init(&iter, fields, dest_struct);
    
    while (stream->bytes_left)
    {
@@ -784,7 +856,7 @@ bool checkreturn pb_decode_noinit(pb_istream_t *stream, const pb_field_t fields[
                return false;
        }
        
-        if (!pb_field_iter_find(&iter, tag))
+        if (!pb_field_find(&iter, tag))
        {
            /* No match found, check if it matches an extension. */
            if (tag >= extension_range_start)
@@ -837,7 +909,7 @@ bool checkreturn pb_decode_noinit(pb_istream_t *stream, const pb_field_t fields[
        do {
            req_field_count = iter.required_field_index;
            last_type = iter.pos->type;
-        } while (pb_field_iter_next(&iter));
+        } while (pb_field_next(&iter));
        
        /* Fixup if last field was also required. */
        if (PB_HTYPE(last_type) == PB_HTYPE_REQUIRED && iter.pos->tag != 0)
@@ -886,11 +958,52 @@ bool pb_decode_delimited(pb_istream_t *stream, const pb_field_t fields[], void *
 }

 #ifdef PB_ENABLE_MALLOC
-static void pb_release_single_field(const pb_field_iter_t *iter)
+static void pb_release_single_field(const pb_field_iterator_t *iter)
 {
    pb_type_t type;
    type = iter->pos->type;

+    /* Release anything contained inside an extension or submsg.
+     * This has to be done even if the submsg itself is statically
+     * allocated. */
+    if (PB_LTYPE(type) == PB_LTYPE_EXTENSION)
+    {
+        /* Release fields from all extensions in the linked list */
+        pb_extension_t *ext = *(pb_extension_t**)iter->pData;
+        while (ext != NULL)
+        {
+            pb_field_iterator_t ext_iter;
+            iter_from_extension(&ext_iter, ext);
+            pb_release_single_field(&ext_iter);
+            ext = ext->next;
+        }
+    }
+    else if (PB_LTYPE(type) == PB_LTYPE_SUBMESSAGE)
+    {
+        /* Release fields in submessage or submsg array */
+        void *pItem = iter->pData;
+        pb_size_t count = 1;
+        
+        if (PB_ATYPE(type) == PB_ATYPE_POINTER)
+        {
+            pItem = *(void**)iter->pData;
+        }
+        
+        if (PB_HTYPE(type) == PB_HTYPE_REPEATED)
+        {
+            count = *(pb_size_t*)iter->pSize;
+        }
+        
+        if (pItem)
+        {
+            while (count--)
+            {
+                pb_release((const pb_field_t*)iter->pos->ptr, pItem);
+                pItem = (uint8_t*)pItem + iter->pos->data_size;
+            }
+        }
+    }
+    
    if (PB_ATYPE(type) == PB_ATYPE_POINTER)
    {
        if (PB_HTYPE(type) == PB_HTYPE_REPEATED &&
@@ -905,28 +1018,12 @@ static void pb_release_single_field(const pb_field_iter_t *iter)
                pb_free(*pItem);
                *pItem++ = NULL;
            }
-            *(pb_size_t*)iter->pSize = 0;
        }
-        else if (PB_LTYPE(type) == PB_LTYPE_SUBMESSAGE)
+        
+        if (PB_HTYPE(type) == PB_HTYPE_REPEATED)
        {
-            /* Release fields in submessages */
-            void *pItem = *(void**)iter->pData;
-            if (pItem)
-            {
-                pb_size_t count = 1;
-                
-                if (PB_HTYPE(type) == PB_HTYPE_REPEATED)
-                {
-                    count = *(pb_size_t*)iter->pSize;
-                    *(pb_size_t*)iter->pSize = 0;
-                }
-                
-                while (count--)
-                {
-                    pb_release((const pb_field_t*)iter->pos->ptr, pItem);
-                    pItem = (uint8_t*)pItem + iter->pos->data_size;
-                }
-            }
+            /* We are going to release the array, so set the size to 0 */
+            *(pb_size_t*)iter->pSize = 0;
        }
        
        /* Release main item */
@@ -937,15 +1034,16 @@ static void pb_release_single_field(const pb_field_iter_t *iter)

 void pb_release(const pb_field_t fields[], void *dest_struct)
 {
-    pb_field_iter_t iter;
-    
-    if (!pb_field_iter_begin(&iter, fields, dest_struct))
+    pb_field_iterator_t iter;
+    pb_field_init(&iter, fields, dest_struct);
+
+    if (iter.pos->tag == 0)
        return; /* Empty message type */
    
    do
    {
        pb_release_single_field(&iter);
-    } while (pb_field_iter_next(&iter));
+    } while (pb_field_next(&iter));
 }
 #endif

@@ -1059,13 +1157,13 @@ static bool checkreturn pb_dec_svarint(pb_istream_t *stream, const pb_field_t *f

 static bool checkreturn pb_dec_fixed32(pb_istream_t *stream, const pb_field_t *field, void *dest)
 {
-    PB_UNUSED(field);
+    UNUSED(field);
    return pb_decode_fixed32(stream, dest);
 }

 static bool checkreturn pb_dec_fixed64(pb_istream_t *stream, const pb_field_t *field, void *dest)
 {
-    PB_UNUSED(field);
+    UNUSED(field);
    return pb_decode_fixed64(stream, dest);
 }

@@ -1078,9 +1176,6 @@ static bool checkreturn pb_dec_bytes(pb_istream_t *stream, const pb_field_t *fie
    if (!pb_decode_varint32(stream, &size))
        return false;
    
-    if (size > PB_SIZE_MAX)
-        PB_RETURN_ERROR(stream, "bytes overflow");
-    
    alloc_size = PB_BYTES_ARRAY_T_ALLOCSIZE(size);
    if (size > alloc_size)
        PB_RETURN_ERROR(stream, "size too large");
@@ -1101,8 +1196,9 @@ static bool checkreturn pb_dec_bytes(pb_istream_t *stream, const pb_field_t *fie
            PB_RETURN_ERROR(stream, "bytes overflow");
        bdest = (pb_bytes_array_t*)dest;
    }
+    
+    bdest->size = size;

-    bdest->size = (pb_size_t)size;
    return pb_read(stream, bdest->bytes, size);
 }

--- a/pb_decode.h
+++ b/pb_decode.h
@@ -3,8 +3,8 @@
 * field descriptions created by nanopb_generator.py.
 */

-#ifndef PB_DECODE_H_INCLUDED
-#define PB_DECODE_H_INCLUDED
+#ifndef _PB_DECODE_H_
+#define _PB_DECODE_H_

 #include "pb.h"

@@ -25,7 +25,7 @@ extern "C" {
 *    is different than from the main stream. Don't use bytes_left to compute
 *    any pointers.
 */
-struct pb_istream_s
+struct _pb_istream_t
 {
 #ifdef PB_BUFFER_ONLY
    /* Callback pointer is not used in buffer-only configuration.
--- a/pb_encode.c
+++ b/pb_encode.c
@@ -5,7 +5,6 @@

 #include "pb.h"
 #include "pb_encode.h"
-#include "pb_common.h"

 /* Use the GCC warn_unused_result attribute to check that all return values
 * are propagated correctly. On other compilers and gcc before 3.4.0 just
@@ -246,7 +245,7 @@ static bool checkreturn encode_basic_field(pb_ostream_t *stream,
            break;
        
        case PB_HTYPE_REPEATED:
-            if (!encode_array(stream, field, pData, *(const pb_size_t*)pSize, func))
+            if (!encode_array(stream, field, pData, *(const size_t*)pSize, func))
                return false;
            break;
        
@@ -311,7 +310,7 @@ static bool checkreturn encode_extension_field(pb_ostream_t *stream,
    const pb_field_t *field, const void *pData)
 {
    const pb_extension_t *extension = *(const pb_extension_t* const *)pData;
-    PB_UNUSED(field);
+    UNUSED(field);
    
    while (extension)
    {
@@ -334,38 +333,42 @@ static bool checkreturn encode_extension_field(pb_ostream_t *stream,
 * Encode all fields *
 *********************/

-static void *remove_const(const void *p)
-{
-    /* Note: this casts away const, in order to use the common field iterator
-     * logic for both encoding and decoding. */
-    union {
-        void *p1;
-        const void *p2;
-    } t;
-    t.p2 = p;
-    return t.p1;
-}
-
 bool checkreturn pb_encode(pb_ostream_t *stream, const pb_field_t fields[], const void *src_struct)
 {
-    pb_field_iter_t iter;
-    if (!pb_field_iter_begin(&iter, fields, remove_const(src_struct)))
-        return true; /* Empty message type */
+    const pb_field_t *field = fields;
+    const void *pData = src_struct;
+    size_t prev_size = 0;
    
-    do {
-        if (PB_LTYPE(iter.pos->type) == PB_LTYPE_EXTENSION)
+    while (field->tag != 0)
+    {
+        pData = (const char*)pData + prev_size + field->data_offset;
+        if (PB_ATYPE(field->type) == PB_ATYPE_POINTER)
+            prev_size = sizeof(const void*);
+        else
+            prev_size = field->data_size;
+        
+        /* Special case for static arrays */
+        if (PB_ATYPE(field->type) == PB_ATYPE_STATIC &&
+            PB_HTYPE(field->type) == PB_HTYPE_REPEATED)
+        {
+            prev_size *= field->array_size;
+        }
+        
+        if (PB_LTYPE(field->type) == PB_LTYPE_EXTENSION)
        {
            /* Special case for the extension field placeholder */
-            if (!encode_extension_field(stream, iter.pos, iter.pData))
+            if (!encode_extension_field(stream, field, pData))
                return false;
        }
        else
        {
            /* Regular field */
-            if (!encode_field(stream, iter.pos, iter.pData))
+            if (!encode_field(stream, field, pData))
                return false;
        }
-    } while (pb_field_iter_next(&iter));
+    
+        field++;
+    }
    
    return true;
 }
@@ -599,13 +602,13 @@ static bool checkreturn pb_enc_svarint(pb_ostream_t *stream, const pb_field_t *f

 static bool checkreturn pb_enc_fixed64(pb_ostream_t *stream, const pb_field_t *field, const void *src)
 {
-    PB_UNUSED(field);
+    UNUSED(field);
    return pb_encode_fixed64(stream, src);
 }

 static bool checkreturn pb_enc_fixed32(pb_ostream_t *stream, const pb_field_t *field, const void *src)
 {
-    PB_UNUSED(field);
+    UNUSED(field);
    return pb_encode_fixed32(stream, src);
 }

@@ -630,6 +633,7 @@ static bool checkreturn pb_enc_bytes(pb_ostream_t *stream, const pb_field_t *fie

 static bool checkreturn pb_enc_string(pb_ostream_t *stream, const pb_field_t *field, const void *src)
 {
+    /* strnlen() is not always available, so just use a loop */
    size_t size = 0;
    size_t max_size = field->data_size;
    const char *p = (const char*)src;
@@ -643,7 +647,6 @@ static bool checkreturn pb_enc_string(pb_ostream_t *stream, const pb_field_t *fi
    }
    else
    {
-        /* strnlen() is not always available, so just use a loop */
        while (size < max_size && *p != '\0')
        {
            size++;
--- a/pb_encode.h
+++ b/pb_encode.h
@@ -3,8 +3,8 @@
 * field descriptions created by nanopb_generator.py.
 */

-#ifndef PB_ENCODE_H_INCLUDED
-#define PB_ENCODE_H_INCLUDED
+#ifndef _PB_ENCODE_H_
+#define _PB_ENCODE_H_

 #include "pb.h"

@@ -24,7 +24,7 @@ extern "C" {
 * 4) Substreams will modify max_size and bytes_written. Don't use them
 *    to calculate any pointers.
 */
-struct pb_ostream_s
+struct _pb_ostream_t
 {
 #ifdef PB_BUFFER_ONLY
    /* Callback pointer is not used in buffer-only configuration.
--- a/tests/Makefile
+++ b/tests/Makefile
@@ -10,12 +10,12 @@ coverage:
 	# LCOV does not like the newer gcov format
 	scons CC=gcc-4.6 CXX=gcc-4.6

+	# We are only interested in pb_encode.o and pb_decode.o
+	find build -name '*.gcda' -and \! \( -name '*pb_encode*' -or -name '*pb_decode*' \) -exec rm '{}' \;
+
 	# Collect the data
 	mkdir build/coverage
 	lcov --base-directory . --directory build/ --gcov-tool gcov-4.6 -c -o build/coverage/nanopb.info

-	# Remove the test code from results
-	lcov -r build/coverage/nanopb.info '*tests*' -o build/coverage/nanopb.info
-
 	# Generate HTML
 	genhtml -o build/coverage build/coverage/nanopb.info
--- a/tests/SConstruct
+++ b/tests/SConstruct
@@ -136,12 +136,18 @@ elif 'g++' in env['CXX'] or 'gcc' in env['CXX']:
    env.Append(CXXFLAGS = '-g -Wall -Werror -Wextra -Wno-missing-field-initializers')
 elif 'cl' in env['CXX']:
    env.Append(CXXFLAGS = '/Zi /W2 /WX')
-    
+
 # Now include the SConscript files from all subdirectories
 import os.path
 env['VARIANT_DIR'] = 'build'
 env['BUILD'] = '#' + env['VARIANT_DIR']
 env['COMMON'] = '#' + env['VARIANT_DIR'] + '/common'
+
+# Include common/SConscript first to make sure its exports are available
+# to other SConscripts.
+SConscript("common/SConscript", exports = 'env', variant_dir = env['VARIANT_DIR'] + '/common')
+
 for subdir in Glob('*/SConscript') + Glob('regression/*/SConscript'):
+    if str(subdir).startswith("common"): continue
    SConscript(subdir, exports = 'env', variant_dir = env['VARIANT_DIR'] + '/' + os.path.dirname(str(subdir)))

--- a/tests/alltypes/SConscript
+++ b/tests/alltypes/SConscript
@@ -4,8 +4,8 @@
 Import("env")

 env.NanopbProto(["alltypes", "alltypes.options"])
-enc = env.Program(["encode_alltypes.c", "alltypes.pb.c", "$COMMON/pb_encode.o", "$COMMON/pb_common.o"])
-dec = env.Program(["decode_alltypes.c", "alltypes.pb.c", "$COMMON/pb_decode.o", "$COMMON/pb_common.o"])
+enc = env.Program(["encode_alltypes.c", "alltypes.pb.c", "$COMMON/pb_encode.o"])
+dec = env.Program(["decode_alltypes.c", "alltypes.pb.c", "$COMMON/pb_decode.o"])

 # Test the round-trip from nanopb encoder to nanopb decoder
 env.RunTest(enc)
--- a/tests/alltypes_callback/SConscript
+++ b/tests/alltypes_callback/SConscript
@@ -6,8 +6,8 @@ c = Copy("$TARGET", "$SOURCE")
 env.Command("alltypes.proto", "#alltypes/alltypes.proto", c)

 env.NanopbProto(["alltypes", "alltypes.options"])
-enc = env.Program(["encode_alltypes_callback.c", "alltypes.pb.c", "$COMMON/pb_encode.o", "$COMMON/pb_common.o"])
-dec = env.Program(["decode_alltypes_callback.c", "alltypes.pb.c", "$COMMON/pb_decode.o", "$COMMON/pb_common.o"])
+enc = env.Program(["encode_alltypes_callback.c", "alltypes.pb.c", "$COMMON/pb_encode.o"])
+dec = env.Program(["decode_alltypes_callback.c", "alltypes.pb.c", "$COMMON/pb_decode.o"])

 refdec = "$BUILD/alltypes/decode_alltypes$PROGSUFFIX"

--- a/tests/alltypes_pointer/SConscript
+++ b/tests/alltypes_pointer/SConscript
@@ -1,31 +1,20 @@
 # Encode the AllTypes message using pointers for all fields, and verify the
 # output against the normal AllTypes test case.

-Import("env")
-
-# We need our own pb_decode.o for the malloc support
-env = env.Clone()
-env.Append(CPPDEFINES = {'PB_ENABLE_MALLOC': 1});
-
-# Disable libmudflap, because it will confuse valgrind
-# and other memory leak detection tools.
-if '-fmudflap' in env["CCFLAGS"]:
-    env["CCFLAGS"].remove("-fmudflap")
-    env["LINKFLAGS"].remove("-fmudflap")
-    env["LIBS"].remove("mudflap")
-
-strict = env.Clone()
-strict.Append(CFLAGS = strict['CORECFLAGS'])
-strict.Object("pb_decode_with_malloc.o", "$NANOPB/pb_decode.c")
-strict.Object("pb_encode_with_malloc.o", "$NANOPB/pb_encode.c")
-strict.Object("pb_common_with_malloc.o", "$NANOPB/pb_common.c")
+Import("env", "malloc_env")

 c = Copy("$TARGET", "$SOURCE")
 env.Command("alltypes.proto", "#alltypes/alltypes.proto", c)

 env.NanopbProto(["alltypes", "alltypes.options"])
-enc = env.Program(["encode_alltypes_pointer.c", "alltypes.pb.c", "pb_encode_with_malloc.o", "pb_common_with_malloc.o"])
-dec = env.Program(["decode_alltypes_pointer.c", "alltypes.pb.c", "pb_decode_with_malloc.o", "pb_common_with_malloc.o"])
+enc = malloc_env.Program(["encode_alltypes_pointer.c",
+                          "alltypes.pb.c",
+                          "$COMMON/pb_encode_with_malloc.o",
+                          "$COMMON/malloc_wrappers.o"])
+dec = malloc_env.Program(["decode_alltypes_pointer.c",
+                          "alltypes.pb.c",
+                          "$COMMON/pb_decode_with_malloc.o",
+                          "$COMMON/malloc_wrappers.o"])

 # Encode and compare results to non-pointer alltypes test case
 env.RunTest(enc)
--- a/tests/backwards_compatibility/SConscript
+++ b/tests/backwards_compatibility/SConscript
@@ -3,8 +3,8 @@

 Import("env")

-enc = env.Program(["encode_legacy.c", "alltypes_legacy.c", "$COMMON/pb_encode.o", "$COMMON/pb_common.o"])
-dec = env.Program(["decode_legacy.c", "alltypes_legacy.c", "$COMMON/pb_decode.o", "$COMMON/pb_common.o"])
+enc = env.Program(["encode_legacy.c", "alltypes_legacy.c", "$COMMON/pb_encode.o"])
+dec = env.Program(["decode_legacy.c", "alltypes_legacy.c", "$COMMON/pb_decode.o"])

 env.RunTest(enc)
 env.RunTest([dec, "encode_legacy.output"])
--- a/tests/backwards_compatibility/alltypes_legacy.c
+++ b/tests/backwards_compatibility/alltypes_legacy.c
@@ -1,37 +1,27 @@
 /* Automatically generated nanopb constant definitions */
-/* Generated by nanopb-0.3.0-dev at Tue Aug 19 17:53:24 2014. */
+/* Generated by 0.2.0-dev at Sun Feb 17 00:09:53 2013. */
+/* This is a file generated using nanopb-0.2.0-dev.
+ * It is used as a part of test suite in order to detect any
+ * incompatible changes made to the generator in future versions.
+ */

 #include "alltypes_legacy.h"

-#if PB_PROTO_HEADER_VERSION != 30
-#error Regenerate this file with the current version of nanopb generator.
-#endif
-
 const char SubMessage_substuff1_default[16] = "1";
 const int32_t SubMessage_substuff2_default = 2;
-const uint32_t SubMessage_substuff3_default = 3u;
-const int32_t Limits_int32_min_default = 2147483647;
-const int32_t Limits_int32_max_default = -2147483647;
-const uint32_t Limits_uint32_min_default = 4294967295u;
-const uint32_t Limits_uint32_max_default = 0u;
-const int64_t Limits_int64_min_default = 9223372036854775807ll;
-const int64_t Limits_int64_max_default = -9223372036854775807ll;
-const uint64_t Limits_uint64_min_default = 18446744073709551615ull;
-const uint64_t Limits_uint64_max_default = 0ull;
-const HugeEnum Limits_enum_min_default = HugeEnum_Positive;
-const HugeEnum Limits_enum_max_default = HugeEnum_Negative;
+const uint32_t SubMessage_substuff3_default = 3;
 const int32_t AllTypes_opt_int32_default = 4041;
-const int64_t AllTypes_opt_int64_default = 4042ll;
-const uint32_t AllTypes_opt_uint32_default = 4043u;
-const uint64_t AllTypes_opt_uint64_default = 4044ull;
+const int64_t AllTypes_opt_int64_default = 4042;
+const uint32_t AllTypes_opt_uint32_default = 4043;
+const uint64_t AllTypes_opt_uint64_default = 4044;
 const int32_t AllTypes_opt_sint32_default = 4045;
 const int64_t AllTypes_opt_sint64_default = 4046;
 const bool AllTypes_opt_bool_default = false;
-const uint32_t AllTypes_opt_fixed32_default = 4048u;
+const uint32_t AllTypes_opt_fixed32_default = 4048;
 const int32_t AllTypes_opt_sfixed32_default = 4049;
 const float AllTypes_opt_float_default = 4050;
-const uint64_t AllTypes_opt_fixed64_default = 4051ull;
-const int64_t AllTypes_opt_sfixed64_default = 4052ll;
+const uint64_t AllTypes_opt_fixed64_default = 4051;
+const int64_t AllTypes_opt_sfixed64_default = 4052;
 const double AllTypes_opt_double_default = 4053;
 const char AllTypes_opt_string_default[16] = "4054";
 const AllTypes_opt_bytes_t AllTypes_opt_bytes_default = {4, {0x34,0x30,0x35,0x35}};
@@ -39,115 +29,65 @@ const MyEnum AllTypes_opt_enum_default = MyEnum_Second;


 const pb_field_t SubMessage_fields[4] = {
-    PB_FIELD(  1, STRING  , REQUIRED, STATIC  , FIRST, SubMessage, substuff1, substuff1, &SubMessage_substuff1_default),
-    PB_FIELD(  2, INT32   , REQUIRED, STATIC  , OTHER, SubMessage, substuff2, substuff1, &SubMessage_substuff2_default),
-    PB_FIELD(  3, FIXED32 , OPTIONAL, STATIC  , OTHER, SubMessage, substuff3, substuff2, &SubMessage_substuff3_default),
+    PB_FIELD(  1, STRING  , REQUIRED, STATIC, SubMessage, substuff1, substuff1, &SubMessage_substuff1_default),
+    PB_FIELD(  2, INT32   , REQUIRED, STATIC, SubMessage, substuff2, substuff1, &SubMessage_substuff2_default),
+    PB_FIELD(  3, FIXED32 , OPTIONAL, STATIC, SubMessage, substuff3, substuff2, &SubMessage_substuff3_default),
    PB_LAST_FIELD
 };

-const pb_field_t EmptyMessage_fields[1] = {
+const pb_field_t AllTypes_fields[53] = {
+    PB_FIELD(  1, INT32   , REQUIRED, STATIC, AllTypes, req_int32, req_int32, 0),
+    PB_FIELD(  2, INT64   , REQUIRED, STATIC, AllTypes, req_int64, req_int32, 0),
+    PB_FIELD(  3, UINT32  , REQUIRED, STATIC, AllTypes, req_uint32, req_int64, 0),
+    PB_FIELD(  4, UINT64  , REQUIRED, STATIC, AllTypes, req_uint64, req_uint32, 0),
+    PB_FIELD(  5, SINT32  , REQUIRED, STATIC, AllTypes, req_sint32, req_uint64, 0),
+    PB_FIELD(  6, SINT64  , REQUIRED, STATIC, AllTypes, req_sint64, req_sint32, 0),
+    PB_FIELD(  7, BOOL    , REQUIRED, STATIC, AllTypes, req_bool, req_sint64, 0),
+    PB_FIELD(  8, FIXED32 , REQUIRED, STATIC, AllTypes, req_fixed32, req_bool, 0),
+    PB_FIELD(  9, SFIXED32, REQUIRED, STATIC, AllTypes, req_sfixed32, req_fixed32, 0),
+    PB_FIELD( 10, FLOAT   , REQUIRED, STATIC, AllTypes, req_float, req_sfixed32, 0),
+    PB_FIELD( 11, FIXED64 , REQUIRED, STATIC, AllTypes, req_fixed64, req_float, 0),
+    PB_FIELD( 12, SFIXED64, REQUIRED, STATIC, AllTypes, req_sfixed64, req_fixed64, 0),
+    PB_FIELD( 13, DOUBLE  , REQUIRED, STATIC, AllTypes, req_double, req_sfixed64, 0),
+    PB_FIELD( 14, STRING  , REQUIRED, STATIC, AllTypes, req_string, req_double, 0),
+    PB_FIELD( 15, BYTES   , REQUIRED, STATIC, AllTypes, req_bytes, req_string, 0),
+    PB_FIELD( 16, MESSAGE , REQUIRED, STATIC, AllTypes, req_submsg, req_bytes, &SubMessage_fields),
+    PB_FIELD( 17, ENUM    , REQUIRED, STATIC, AllTypes, req_enum, req_submsg, 0),
+    PB_FIELD( 21, INT32   , REPEATED, STATIC, AllTypes, rep_int32, req_enum, 0),
+    PB_FIELD( 22, INT64   , REPEATED, STATIC, AllTypes, rep_int64, rep_int32, 0),
+    PB_FIELD( 23, UINT32  , REPEATED, STATIC, AllTypes, rep_uint32, rep_int64, 0),
+    PB_FIELD( 24, UINT64  , REPEATED, STATIC, AllTypes, rep_uint64, rep_uint32, 0),
+    PB_FIELD( 25, SINT32  , REPEATED, STATIC, AllTypes, rep_sint32, rep_uint64, 0),
+    PB_FIELD( 26, SINT64  , REPEATED, STATIC, AllTypes, rep_sint64, rep_sint32, 0),
+    PB_FIELD( 27, BOOL    , REPEATED, STATIC, AllTypes, rep_bool, rep_sint64, 0),
+    PB_FIELD( 28, FIXED32 , REPEATED, STATIC, AllTypes, rep_fixed32, rep_bool, 0),
+    PB_FIELD( 29, SFIXED32, REPEATED, STATIC, AllTypes, rep_sfixed32, rep_fixed32, 0),
+    PB_FIELD( 30, FLOAT   , REPEATED, STATIC, AllTypes, rep_float, rep_sfixed32, 0),
+    PB_FIELD( 31, FIXED64 , REPEATED, STATIC, AllTypes, rep_fixed64, rep_float, 0),
+    PB_FIELD( 32, SFIXED64, REPEATED, STATIC, AllTypes, rep_sfixed64, rep_fixed64, 0),
+    PB_FIELD( 33, DOUBLE  , REPEATED, STATIC, AllTypes, rep_double, rep_sfixed64, 0),
+    PB_FIELD( 34, STRING  , REPEATED, STATIC, AllTypes, rep_string, rep_double, 0),
+    PB_FIELD( 35, BYTES   , REPEATED, STATIC, AllTypes, rep_bytes, rep_string, 0),
+    PB_FIELD( 36, MESSAGE , REPEATED, STATIC, AllTypes, rep_submsg, rep_bytes, &SubMessage_fields),
+    PB_FIELD( 37, ENUM    , REPEATED, STATIC, AllTypes, rep_enum, rep_submsg, 0),
+    PB_FIELD( 41, INT32   , OPTIONAL, STATIC, AllTypes, opt_int32, rep_enum, &AllTypes_opt_int32_default),
+    PB_FIELD( 42, INT64   , OPTIONAL, STATIC, AllTypes, opt_int64, opt_int32, &AllTypes_opt_int64_default),
+    PB_FIELD( 43, UINT32  , OPTIONAL, STATIC, AllTypes, opt_uint32, opt_int64, &AllTypes_opt_uint32_default),
+    PB_FIELD( 44, UINT64  , OPTIONAL, STATIC, AllTypes, opt_uint64, opt_uint32, &AllTypes_opt_uint64_default),
+    PB_FIELD( 45, SINT32  , OPTIONAL, STATIC, AllTypes, opt_sint32, opt_uint64, &AllTypes_opt_sint32_default),
+    PB_FIELD( 46, SINT64  , OPTIONAL, STATIC, AllTypes, opt_sint64, opt_sint32, &AllTypes_opt_sint64_default),
+    PB_FIELD( 47, BOOL    , OPTIONAL, STATIC, AllTypes, opt_bool, opt_sint64, &AllTypes_opt_bool_default),
+    PB_FIELD( 48, FIXED32 , OPTIONAL, STATIC, AllTypes, opt_fixed32, opt_bool, &AllTypes_opt_fixed32_default),
+    PB_FIELD( 49, SFIXED32, OPTIONAL, STATIC, AllTypes, opt_sfixed32, opt_fixed32, &AllTypes_opt_sfixed32_default),
+    PB_FIELD( 50, FLOAT   , OPTIONAL, STATIC, AllTypes, opt_float, opt_sfixed32, &AllTypes_opt_float_default),
+    PB_FIELD( 51, FIXED64 , OPTIONAL, STATIC, AllTypes, opt_fixed64, opt_float, &AllTypes_opt_fixed64_default),
+    PB_FIELD( 52, SFIXED64, OPTIONAL, STATIC, AllTypes, opt_sfixed64, opt_fixed64, &AllTypes_opt_sfixed64_default),
+    PB_FIELD( 53, DOUBLE  , OPTIONAL, STATIC, AllTypes, opt_double, opt_sfixed64, &AllTypes_opt_double_default),
+    PB_FIELD( 54, STRING  , OPTIONAL, STATIC, AllTypes, opt_string, opt_double, &AllTypes_opt_string_default),
+    PB_FIELD( 55, BYTES   , OPTIONAL, STATIC, AllTypes, opt_bytes, opt_string, &AllTypes_opt_bytes_default),
+    PB_FIELD( 56, MESSAGE , OPTIONAL, STATIC, AllTypes, opt_submsg, opt_bytes, &SubMessage_fields),
+    PB_FIELD( 57, ENUM    , OPTIONAL, STATIC, AllTypes, opt_enum, opt_submsg, &AllTypes_opt_enum_default),
+    PB_FIELD( 99, INT32   , REQUIRED, STATIC, AllTypes, end, opt_enum, 0),
    PB_LAST_FIELD
 };

-const pb_field_t Limits_fields[11] = {
-    PB_FIELD(  1, INT32   , REQUIRED, STATIC  , FIRST, Limits, int32_min, int32_min, &Limits_int32_min_default),
-    PB_FIELD(  2, INT32   , REQUIRED, STATIC  , OTHER, Limits, int32_max, int32_min, &Limits_int32_max_default),
-    PB_FIELD(  3, UINT32  , REQUIRED, STATIC  , OTHER, Limits, uint32_min, int32_max, &Limits_uint32_min_default),
-    PB_FIELD(  4, UINT32  , REQUIRED, STATIC  , OTHER, Limits, uint32_max, uint32_min, &Limits_uint32_max_default),
-    PB_FIELD(  5, INT64   , REQUIRED, STATIC  , OTHER, Limits, int64_min, uint32_max, &Limits_int64_min_default),
-    PB_FIELD(  6, INT64   , REQUIRED, STATIC  , OTHER, Limits, int64_max, int64_min, &Limits_int64_max_default),
-    PB_FIELD(  7, UINT64  , REQUIRED, STATIC  , OTHER, Limits, uint64_min, int64_max, &Limits_uint64_min_default),
-    PB_FIELD(  8, UINT64  , REQUIRED, STATIC  , OTHER, Limits, uint64_max, uint64_min, &Limits_uint64_max_default),
-    PB_FIELD(  9, ENUM    , REQUIRED, STATIC  , OTHER, Limits, enum_min, uint64_max, &Limits_enum_min_default),
-    PB_FIELD( 10, ENUM    , REQUIRED, STATIC  , OTHER, Limits, enum_max, enum_min, &Limits_enum_max_default),
-    PB_LAST_FIELD
-};
-
-const pb_field_t AllTypes_fields[54] = {
-    PB_FIELD(  1, INT32   , REQUIRED, STATIC  , FIRST, AllTypes, req_int32, req_int32, 0),
-    PB_FIELD(  2, INT64   , REQUIRED, STATIC  , OTHER, AllTypes, req_int64, req_int32, 0),
-    PB_FIELD(  3, UINT32  , REQUIRED, STATIC  , OTHER, AllTypes, req_uint32, req_int64, 0),
-    PB_FIELD(  4, UINT64  , REQUIRED, STATIC  , OTHER, AllTypes, req_uint64, req_uint32, 0),
-    PB_FIELD(  5, SINT32  , REQUIRED, STATIC  , OTHER, AllTypes, req_sint32, req_uint64, 0),
-    PB_FIELD(  6, SINT64  , REQUIRED, STATIC  , OTHER, AllTypes, req_sint64, req_sint32, 0),
-    PB_FIELD(  7, BOOL    , REQUIRED, STATIC  , OTHER, AllTypes, req_bool, req_sint64, 0),
-    PB_FIELD(  8, FIXED32 , REQUIRED, STATIC  , OTHER, AllTypes, req_fixed32, req_bool, 0),
-    PB_FIELD(  9, SFIXED32, REQUIRED, STATIC  , OTHER, AllTypes, req_sfixed32, req_fixed32, 0),
-    PB_FIELD( 10, FLOAT   , REQUIRED, STATIC  , OTHER, AllTypes, req_float, req_sfixed32, 0),
-    PB_FIELD( 11, FIXED64 , REQUIRED, STATIC  , OTHER, AllTypes, req_fixed64, req_float, 0),
-    PB_FIELD( 12, SFIXED64, REQUIRED, STATIC  , OTHER, AllTypes, req_sfixed64, req_fixed64, 0),
-    PB_FIELD( 13, DOUBLE  , REQUIRED, STATIC  , OTHER, AllTypes, req_double, req_sfixed64, 0),
-    PB_FIELD( 14, STRING  , REQUIRED, STATIC  , OTHER, AllTypes, req_string, req_double, 0),
-    PB_FIELD( 15, BYTES   , REQUIRED, STATIC  , OTHER, AllTypes, req_bytes, req_string, 0),
-    PB_FIELD( 16, MESSAGE , REQUIRED, STATIC  , OTHER, AllTypes, req_submsg, req_bytes, &SubMessage_fields),
-    PB_FIELD( 17, ENUM    , REQUIRED, STATIC  , OTHER, AllTypes, req_enum, req_submsg, 0),
-    PB_FIELD( 21, INT32   , REPEATED, STATIC  , OTHER, AllTypes, rep_int32, req_enum, 0),
-    PB_FIELD( 22, INT64   , REPEATED, STATIC  , OTHER, AllTypes, rep_int64, rep_int32, 0),
-    PB_FIELD( 23, UINT32  , REPEATED, STATIC  , OTHER, AllTypes, rep_uint32, rep_int64, 0),
-    PB_FIELD( 24, UINT64  , REPEATED, STATIC  , OTHER, AllTypes, rep_uint64, rep_uint32, 0),
-    PB_FIELD( 25, SINT32  , REPEATED, STATIC  , OTHER, AllTypes, rep_sint32, rep_uint64, 0),
-    PB_FIELD( 26, SINT64  , REPEATED, STATIC  , OTHER, AllTypes, rep_sint64, rep_sint32, 0),
-    PB_FIELD( 27, BOOL    , REPEATED, STATIC  , OTHER, AllTypes, rep_bool, rep_sint64, 0),
-    PB_FIELD( 28, FIXED32 , REPEATED, STATIC  , OTHER, AllTypes, rep_fixed32, rep_bool, 0),
-    PB_FIELD( 29, SFIXED32, REPEATED, STATIC  , OTHER, AllTypes, rep_sfixed32, rep_fixed32, 0),
-    PB_FIELD( 30, FLOAT   , REPEATED, STATIC  , OTHER, AllTypes, rep_float, rep_sfixed32, 0),
-    PB_FIELD( 31, FIXED64 , REPEATED, STATIC  , OTHER, AllTypes, rep_fixed64, rep_float, 0),
-    PB_FIELD( 32, SFIXED64, REPEATED, STATIC  , OTHER, AllTypes, rep_sfixed64, rep_fixed64, 0),
-    PB_FIELD( 33, DOUBLE  , REPEATED, STATIC  , OTHER, AllTypes, rep_double, rep_sfixed64, 0),
-    PB_FIELD( 34, STRING  , REPEATED, STATIC  , OTHER, AllTypes, rep_string, rep_double, 0),
-    PB_FIELD( 35, BYTES   , REPEATED, STATIC  , OTHER, AllTypes, rep_bytes, rep_string, 0),
-    PB_FIELD( 36, MESSAGE , REPEATED, STATIC  , OTHER, AllTypes, rep_submsg, rep_bytes, &SubMessage_fields),
-    PB_FIELD( 37, ENUM    , REPEATED, STATIC  , OTHER, AllTypes, rep_enum, rep_submsg, 0),
-    PB_FIELD( 41, INT32   , OPTIONAL, STATIC  , OTHER, AllTypes, opt_int32, rep_enum, &AllTypes_opt_int32_default),
-    PB_FIELD( 42, INT64   , OPTIONAL, STATIC  , OTHER, AllTypes, opt_int64, opt_int32, &AllTypes_opt_int64_default),
-    PB_FIELD( 43, UINT32  , OPTIONAL, STATIC  , OTHER, AllTypes, opt_uint32, opt_int64, &AllTypes_opt_uint32_default),
-    PB_FIELD( 44, UINT64  , OPTIONAL, STATIC  , OTHER, AllTypes, opt_uint64, opt_uint32, &AllTypes_opt_uint64_default),
-    PB_FIELD( 45, SINT32  , OPTIONAL, STATIC  , OTHER, AllTypes, opt_sint32, opt_uint64, &AllTypes_opt_sint32_default),
-    PB_FIELD( 46, SINT64  , OPTIONAL, STATIC  , OTHER, AllTypes, opt_sint64, opt_sint32, &AllTypes_opt_sint64_default),
-    PB_FIELD( 47, BOOL    , OPTIONAL, STATIC  , OTHER, AllTypes, opt_bool, opt_sint64, &AllTypes_opt_bool_default),
-    PB_FIELD( 48, FIXED32 , OPTIONAL, STATIC  , OTHER, AllTypes, opt_fixed32, opt_bool, &AllTypes_opt_fixed32_default),
-    PB_FIELD( 49, SFIXED32, OPTIONAL, STATIC  , OTHER, AllTypes, opt_sfixed32, opt_fixed32, &AllTypes_opt_sfixed32_default),
-    PB_FIELD( 50, FLOAT   , OPTIONAL, STATIC  , OTHER, AllTypes, opt_float, opt_sfixed32, &AllTypes_opt_float_default),
-    PB_FIELD( 51, FIXED64 , OPTIONAL, STATIC  , OTHER, AllTypes, opt_fixed64, opt_float, &AllTypes_opt_fixed64_default),
-    PB_FIELD( 52, SFIXED64, OPTIONAL, STATIC  , OTHER, AllTypes, opt_sfixed64, opt_fixed64, &AllTypes_opt_sfixed64_default),
-    PB_FIELD( 53, DOUBLE  , OPTIONAL, STATIC  , OTHER, AllTypes, opt_double, opt_sfixed64, &AllTypes_opt_double_default),
-    PB_FIELD( 54, STRING  , OPTIONAL, STATIC  , OTHER, AllTypes, opt_string, opt_double, &AllTypes_opt_string_default),
-    PB_FIELD( 55, BYTES   , OPTIONAL, STATIC  , OTHER, AllTypes, opt_bytes, opt_string, &AllTypes_opt_bytes_default),
-    PB_FIELD( 56, MESSAGE , OPTIONAL, STATIC  , OTHER, AllTypes, opt_submsg, opt_bytes, &SubMessage_fields),
-    PB_FIELD( 57, ENUM    , OPTIONAL, STATIC  , OTHER, AllTypes, opt_enum, opt_submsg, &AllTypes_opt_enum_default),
-    PB_FIELD( 99, INT32   , REQUIRED, STATIC  , OTHER, AllTypes, end, opt_enum, 0),
-    PB_FIELD(200, EXTENSION, OPTIONAL, CALLBACK, OTHER, AllTypes, extensions, end, 0),
-    PB_LAST_FIELD
-};
-
-
-/* Check that field information fits in pb_field_t */
-#if !defined(PB_FIELD_32BIT)
-/* If you get an error here, it means that you need to define PB_FIELD_32BIT
- * compile-time option. You can do that in pb.h or on compiler command line.
- * 
- * The reason you need to do this is that some of your messages contain tag
- * numbers or field sizes that are larger than what can fit in 8 or 16 bit
- * field descriptors.
- */
-PB_STATIC_ASSERT((pb_membersize(AllTypes, req_submsg) < 65536 && pb_membersize(AllTypes, rep_submsg[0]) < 65536 && pb_membersize(AllTypes, opt_submsg) < 65536), YOU_MUST_DEFINE_PB_FIELD_32BIT_FOR_MESSAGES_SubMessage_EmptyMessage_Limits_AllTypes)
-#endif
-
-#if !defined(PB_FIELD_16BIT) && !defined(PB_FIELD_32BIT)
-/* If you get an error here, it means that you need to define PB_FIELD_16BIT
- * compile-time option. You can do that in pb.h or on compiler command line.
- * 
- * The reason you need to do this is that some of your messages contain tag
- * numbers or field sizes that are larger than what can fit in the default
- * 8 bit descriptors.
- */
-PB_STATIC_ASSERT((pb_membersize(AllTypes, req_submsg) < 256 && pb_membersize(AllTypes, rep_submsg[0]) < 256 && pb_membersize(AllTypes, opt_submsg) < 256), YOU_MUST_DEFINE_PB_FIELD_16BIT_FOR_MESSAGES_SubMessage_EmptyMessage_Limits_AllTypes)
-#endif
-
-
-/* On some platforms (such as AVR), double is really float.
- * These are not directly supported by nanopb, but see example_avr_double.
- * To get rid of this error, remove any double fields from your .proto.
- */
-PB_STATIC_ASSERT(sizeof(double) == 8, DOUBLE_MUST_BE_8_BYTES)
-
--- a/tests/backwards_compatibility/alltypes_legacy.h
+++ b/tests/backwards_compatibility/alltypes_legacy.h
@@ -1,24 +1,18 @@
 /* Automatically generated nanopb header */
-/* Generated by nanopb-0.3.0-dev at Tue Aug 19 17:53:24 2014. */
+/* This is a file generated using nanopb-0.2.0-dev.
+ * It is used as a part of test suite in order to detect any
+ * incompatible changes made to the generator in future versions.
+ */

-#ifndef PB_ALLTYPES_LEGACY_H_INCLUDED
-#define PB_ALLTYPES_LEGACY_H_INCLUDED
+#ifndef _PB_ALLTYPES_PB_H_
+#define _PB_ALLTYPES_PB_H_
 #include <pb.h>

-#if PB_PROTO_HEADER_VERSION != 30
-#error Regenerate this file with the current version of nanopb generator.
-#endif
-
 #ifdef __cplusplus
 extern "C" {
 #endif

 /* Enum definitions */
-typedef enum _HugeEnum {
-    HugeEnum_Negative = -2147483647,
-    HugeEnum_Positive = 2147483647
-} HugeEnum;
-
 typedef enum _MyEnum {
    MyEnum_Zero = 0,
    MyEnum_First = 1,
@@ -27,23 +21,6 @@ typedef enum _MyEnum {
 } MyEnum;

 /* Struct definitions */
-typedef struct _EmptyMessage {
-    uint8_t dummy_field;
-} EmptyMessage;
-
-typedef struct _Limits {
-    int32_t int32_min;
-    int32_t int32_max;
-    uint32_t uint32_min;
-    uint32_t uint32_max;
-    int64_t int64_min;
-    int64_t int64_max;
-    uint64_t uint64_min;
-    uint64_t uint64_max;
-    HugeEnum enum_min;
-    HugeEnum enum_max;
-} Limits;
-
 typedef struct _SubMessage {
    char substuff1[16];
    int32_t substuff2;
@@ -51,11 +28,20 @@ typedef struct _SubMessage {
    uint32_t substuff3;
 } SubMessage;

-typedef PB_BYTES_ARRAY_T(16) AllTypes_req_bytes_t;
+typedef struct {
+    size_t size;
+    uint8_t bytes[16];
+} AllTypes_req_bytes_t;

-typedef PB_BYTES_ARRAY_T(16) AllTypes_rep_bytes_t;
+typedef struct {
+    size_t size;
+    uint8_t bytes[16];
+} AllTypes_rep_bytes_t;

-typedef PB_BYTES_ARRAY_T(16) AllTypes_opt_bytes_t;
+typedef struct {
+    size_t size;
+    uint8_t bytes[16];
+} AllTypes_opt_bytes_t;

 typedef struct _AllTypes {
    int32_t req_int32;
@@ -75,39 +61,39 @@ typedef struct _AllTypes {
    AllTypes_req_bytes_t req_bytes;
    SubMessage req_submsg;
    MyEnum req_enum;
-    pb_size_t rep_int32_count;
+    size_t rep_int32_count;
    int32_t rep_int32[5];
-    pb_size_t rep_int64_count;
+    size_t rep_int64_count;
    int64_t rep_int64[5];
-    pb_size_t rep_uint32_count;
+    size_t rep_uint32_count;
    uint32_t rep_uint32[5];
-    pb_size_t rep_uint64_count;
+    size_t rep_uint64_count;
    uint64_t rep_uint64[5];
-    pb_size_t rep_sint32_count;
+    size_t rep_sint32_count;
    int32_t rep_sint32[5];
-    pb_size_t rep_sint64_count;
+    size_t rep_sint64_count;
    int64_t rep_sint64[5];
-    pb_size_t rep_bool_count;
+    size_t rep_bool_count;
    bool rep_bool[5];
-    pb_size_t rep_fixed32_count;
+    size_t rep_fixed32_count;
    uint32_t rep_fixed32[5];
-    pb_size_t rep_sfixed32_count;
+    size_t rep_sfixed32_count;
    int32_t rep_sfixed32[5];
-    pb_size_t rep_float_count;
+    size_t rep_float_count;
    float rep_float[5];
-    pb_size_t rep_fixed64_count;
+    size_t rep_fixed64_count;
    uint64_t rep_fixed64[5];
-    pb_size_t rep_sfixed64_count;
+    size_t rep_sfixed64_count;
    int64_t rep_sfixed64[5];
-    pb_size_t rep_double_count;
+    size_t rep_double_count;
    double rep_double[5];
-    pb_size_t rep_string_count;
+    size_t rep_string_count;
    char rep_string[5][16];
-    pb_size_t rep_bytes_count;
+    size_t rep_bytes_count;
    AllTypes_rep_bytes_t rep_bytes[5];
-    pb_size_t rep_submsg_count;
+    size_t rep_submsg_count;
    SubMessage rep_submsg[5];
-    pb_size_t rep_enum_count;
+    size_t rep_enum_count;
    MyEnum rep_enum[5];
    bool has_opt_int32;
    int32_t opt_int32;
@@ -144,23 +130,12 @@ typedef struct _AllTypes {
    bool has_opt_enum;
    MyEnum opt_enum;
    int32_t end;
-    pb_extension_t *extensions;
 } AllTypes;

 /* Default values for struct fields */
 extern const char SubMessage_substuff1_default[16];
 extern const int32_t SubMessage_substuff2_default;
 extern const uint32_t SubMessage_substuff3_default;
-extern const int32_t Limits_int32_min_default;
-extern const int32_t Limits_int32_max_default;
-extern const uint32_t Limits_uint32_min_default;
-extern const uint32_t Limits_uint32_max_default;
-extern const int64_t Limits_int64_min_default;
-extern const int64_t Limits_int64_max_default;
-extern const uint64_t Limits_uint64_min_default;
-extern const uint64_t Limits_uint64_max_default;
-extern const HugeEnum Limits_enum_min_default;
-extern const HugeEnum Limits_enum_max_default;
 extern const int32_t AllTypes_opt_int32_default;
 extern const int64_t AllTypes_opt_int64_default;
 extern const uint32_t AllTypes_opt_uint32_default;
@@ -178,94 +153,23 @@ extern const char AllTypes_opt_string_default[16];
 extern const AllTypes_opt_bytes_t AllTypes_opt_bytes_default;
 extern const MyEnum AllTypes_opt_enum_default;

-/* Initializer values for message structs */
-#define SubMessage_init_default                  {"1", 2, false, 3u}
-#define EmptyMessage_init_default                {0}
-#define Limits_init_default                      {2147483647, -2147483647, 4294967295u, 0u, 9223372036854775807ll, -9223372036854775807ll, 18446744073709551615ull, 0ull, HugeEnum_Positive, HugeEnum_Negative}
-#define AllTypes_init_default                    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "", {0, {0}}, SubMessage_init_default, (MyEnum)0, 0, {0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0}, 0, {"", "", "", "", ""}, 0, {{0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}}, 0, {SubMessage_init_default, SubMessage_init_default, SubMessage_init_default, SubMessage_init_default, SubMessage_init_default}, 0, {(MyEnum)0, (MyEnum)0, (MyEnum)0, (MyEnum)0, (MyEnum)0}, false, 4041, false, 4042ll, false, 4043u, false, 4044ull, false, 4045, false, 4046, false, false, false, 4048u, false, 4049, false, 4050, false, 4051ull, false, 4052ll, false, 4053, false, "4054", false, {4, {0x34,0x30,0x35,0x35}}, false, SubMessage_init_default, false, MyEnum_Second, 0, NULL}
-#define SubMessage_init_zero                     {"", 0, false, 0}
-#define EmptyMessage_init_zero                   {0}
-#define Limits_init_zero                         {0, 0, 0, 0, 0, 0, 0, 0, (HugeEnum)0, (HugeEnum)0}
-#define AllTypes_init_zero                       {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "", {0, {0}}, SubMessage_init_zero, (MyEnum)0, 0, {0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0}, 0, {"", "", "", "", ""}, 0, {{0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}}, 0, {SubMessage_init_zero, SubMessage_init_zero, SubMessage_init_zero, SubMessage_init_zero, SubMessage_init_zero}, 0, {(MyEnum)0, (MyEnum)0, (MyEnum)0, (MyEnum)0, (MyEnum)0}, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, "", false, {0, {0}}, false, SubMessage_init_zero, false, (MyEnum)0, 0, NULL}
-
-/* Field tags (for use in manual encoding/decoding) */
-#define Limits_int32_min_tag                     1
-#define Limits_int32_max_tag                     2
-#define Limits_uint32_min_tag                    3
-#define Limits_uint32_max_tag                    4
-#define Limits_int64_min_tag                     5
-#define Limits_int64_max_tag                     6
-#define Limits_uint64_min_tag                    7
-#define Limits_uint64_max_tag                    8
-#define Limits_enum_min_tag                      9
-#define Limits_enum_max_tag                      10
-#define SubMessage_substuff1_tag                 1
-#define SubMessage_substuff2_tag                 2
-#define SubMessage_substuff3_tag                 3
-#define AllTypes_req_int32_tag                   1
-#define AllTypes_req_int64_tag                   2
-#define AllTypes_req_uint32_tag                  3
-#define AllTypes_req_uint64_tag                  4
-#define AllTypes_req_sint32_tag                  5
-#define AllTypes_req_sint64_tag                  6
-#define AllTypes_req_bool_tag                    7
-#define AllTypes_req_fixed32_tag                 8
-#define AllTypes_req_sfixed32_tag                9
-#define AllTypes_req_float_tag                   10
-#define AllTypes_req_fixed64_tag                 11
-#define AllTypes_req_sfixed64_tag                12
-#define AllTypes_req_double_tag                  13
-#define AllTypes_req_string_tag                  14
-#define AllTypes_req_bytes_tag                   15
-#define AllTypes_req_submsg_tag                  16
-#define AllTypes_req_enum_tag                    17
-#define AllTypes_rep_int32_tag                   21
-#define AllTypes_rep_int64_tag                   22
-#define AllTypes_rep_uint32_tag                  23
-#define AllTypes_rep_uint64_tag                  24
-#define AllTypes_rep_sint32_tag                  25
-#define AllTypes_rep_sint64_tag                  26
-#define AllTypes_rep_bool_tag                    27
-#define AllTypes_rep_fixed32_tag                 28
-#define AllTypes_rep_sfixed32_tag                29
-#define AllTypes_rep_float_tag                   30
-#define AllTypes_rep_fixed64_tag                 31
-#define AllTypes_rep_sfixed64_tag                32
-#define AllTypes_rep_double_tag                  33
-#define AllTypes_rep_string_tag                  34
-#define AllTypes_rep_bytes_tag                   35
-#define AllTypes_rep_submsg_tag                  36
-#define AllTypes_rep_enum_tag                    37
-#define AllTypes_opt_int32_tag                   41
-#define AllTypes_opt_int64_tag                   42
-#define AllTypes_opt_uint32_tag                  43
-#define AllTypes_opt_uint64_tag                  44
-#define AllTypes_opt_sint32_tag                  45
-#define AllTypes_opt_sint64_tag                  46
-#define AllTypes_opt_bool_tag                    47
-#define AllTypes_opt_fixed32_tag                 48
-#define AllTypes_opt_sfixed32_tag                49
-#define AllTypes_opt_float_tag                   50
-#define AllTypes_opt_fixed64_tag                 51
-#define AllTypes_opt_sfixed64_tag                52
-#define AllTypes_opt_double_tag                  53
-#define AllTypes_opt_string_tag                  54
-#define AllTypes_opt_bytes_tag                   55
-#define AllTypes_opt_submsg_tag                  56
-#define AllTypes_opt_enum_tag                    57
-#define AllTypes_end_tag                         99
-
 /* Struct field encoding specification for nanopb */
 extern const pb_field_t SubMessage_fields[4];
-extern const pb_field_t EmptyMessage_fields[1];
-extern const pb_field_t Limits_fields[11];
-extern const pb_field_t AllTypes_fields[54];
+extern const pb_field_t AllTypes_fields[53];

-/* Maximum encoded size of messages (where known) */
-#define SubMessage_size                          34
-#define EmptyMessage_size                        0
-#define Limits_size                              90
-#define AllTypes_size                            1362
+/* Check that field information fits in pb_field_t */
+#if !defined(PB_FIELD_16BIT) && !defined(PB_FIELD_32BIT)
+STATIC_ASSERT((pb_membersize(AllTypes, req_submsg) < 256 && pb_membersize(AllTypes, rep_submsg[0]) < 256 && pb_membersize(AllTypes, opt_submsg) < 256), YOU_MUST_DEFINE_PB_FIELD_16BIT_FOR_MESSAGES_SubMessage_AllTypes)
+#endif
+
+#if !defined(PB_FIELD_32BIT)
+STATIC_ASSERT((pb_membersize(AllTypes, req_submsg) < 65536 && pb_membersize(AllTypes, rep_submsg[0]) < 65536 && pb_membersize(AllTypes, opt_submsg) < 65536), YOU_MUST_DEFINE_PB_FIELD_32BIT_FOR_MESSAGES_SubMessage_AllTypes)
+#endif
+
+/* On some platforms (such as AVR), double is really float.
+ * These are not directly supported by nanopb, but see example_avr_double.
+ */
+STATIC_ASSERT(sizeof(double) == 8, DOUBLE_MUST_BE_8_BYTES)

 #ifdef __cplusplus
 } /* extern "C" */
--- a/tests/backwards_compatibility/alltypes_legacy.options
+++ b/tests/backwards_compatibility/alltypes_legacy.options
@@ -1,3 +0,0 @@
-* max_size:16
-* max_count:5
-
--- a/tests/backwards_compatibility/alltypes_legacy.proto
+++ b/tests/backwards_compatibility/alltypes_legacy.proto
@@ -1,108 +0,0 @@
-message SubMessage {
-    required string substuff1 = 1 [default = "1"];
-    required int32 substuff2 = 2 [default = 2];
-    optional fixed32 substuff3 = 3 [default = 3];
-}
-
-message EmptyMessage {
-
-}
-
-enum HugeEnum {
-    Negative = -2147483647; /* protoc doesn't accept -2147483648 here */
-    Positive =  2147483647;
-}
-
-message Limits {
-    required int32      int32_min  =  1 [default = 2147483647];
-    required int32      int32_max  =  2 [default = -2147483647];
-    required uint32     uint32_min =  3 [default = 4294967295];
-    required uint32     uint32_max =  4 [default = 0];
-    required int64      int64_min  =  5 [default = 9223372036854775807];
-    required int64      int64_max  =  6 [default = -9223372036854775807];
-    required uint64     uint64_min =  7 [default = 18446744073709551615];
-    required uint64     uint64_max =  8 [default = 0];
-    required HugeEnum   enum_min   =  9 [default = Positive];
-    required HugeEnum   enum_max   = 10 [default = Negative];
-}
-
-enum MyEnum {
-    Zero = 0;
-    First = 1;
-    Second = 2;
-    Truth = 42;
-}
-
-message AllTypes {
-    required int32      req_int32   = 1;
-    required int64      req_int64   = 2;
-    required uint32     req_uint32  = 3;
-    required uint64     req_uint64  = 4;
-    required sint32     req_sint32  = 5;
-    required sint64     req_sint64  = 6;
-    required bool       req_bool    = 7;
-    
-    required fixed32    req_fixed32 = 8;
-    required sfixed32   req_sfixed32= 9;
-    required float      req_float   = 10;
-    
-    required fixed64    req_fixed64 = 11;
-    required sfixed64   req_sfixed64= 12;
-    required double     req_double  = 13;
-    
-    required string     req_string  = 14;
-    required bytes      req_bytes   = 15;
-    required SubMessage req_submsg  = 16;
-    required MyEnum     req_enum    = 17;
-    
-    
-    repeated int32      rep_int32   = 21 [packed = true];
-    repeated int64      rep_int64   = 22 [packed = true];
-    repeated uint32     rep_uint32  = 23 [packed = true];
-    repeated uint64     rep_uint64  = 24 [packed = true];
-    repeated sint32     rep_sint32  = 25 [packed = true];
-    repeated sint64     rep_sint64  = 26 [packed = true];
-    repeated bool       rep_bool    = 27 [packed = true];
-    
-    repeated fixed32    rep_fixed32 = 28 [packed = true];
-    repeated sfixed32   rep_sfixed32= 29 [packed = true];
-    repeated float      rep_float   = 30 [packed = true];
-    
-    repeated fixed64    rep_fixed64 = 31 [packed = true];
-    repeated sfixed64   rep_sfixed64= 32 [packed = true];
-    repeated double     rep_double  = 33 [packed = true];
-    
-    repeated string     rep_string  = 34;
-    repeated bytes      rep_bytes   = 35;
-    repeated SubMessage rep_submsg  = 36;
-    repeated MyEnum     rep_enum    = 37 [packed = true];
-    
-    optional int32      opt_int32   = 41 [default = 4041];
-    optional int64      opt_int64   = 42 [default = 4042];
-    optional uint32     opt_uint32  = 43 [default = 4043];
-    optional uint64     opt_uint64  = 44 [default = 4044];
-    optional sint32     opt_sint32  = 45 [default = 4045];
-    optional sint64     opt_sint64  = 46 [default = 4046];
-    optional bool       opt_bool    = 47 [default = false];
-    
-    optional fixed32    opt_fixed32 = 48 [default = 4048];
-    optional sfixed32   opt_sfixed32= 49 [default = 4049];
-    optional float      opt_float   = 50 [default = 4050];
-    
-    optional fixed64    opt_fixed64 = 51 [default = 4051];
-    optional sfixed64   opt_sfixed64= 52 [default = 4052];
-    optional double     opt_double  = 53 [default = 4053];
-    
-    optional string     opt_string  = 54 [default = "4054"];
-    optional bytes      opt_bytes   = 55 [default = "4055"];
-    optional SubMessage opt_submsg  = 56;
-    optional MyEnum     opt_enum    = 57 [default = Second];
-
-    // Just to make sure that the size of the fields has been calculated
-    // properly, i.e. otherwise a bug in last field might not be detected.
-    required int32      end = 99;
-
-
-    extensions 200 to 255;
-}
-
--- a/tests/basic_buffer/SConscript
+++ b/tests/basic_buffer/SConscript
@@ -2,8 +2,8 @@

 Import("env")

-enc = env.Program(["encode_buffer.c", "$COMMON/person.pb.c", "$COMMON/pb_encode.o", "$COMMON/pb_common.o"])
-dec = env.Program(["decode_buffer.c", "$COMMON/person.pb.c", "$COMMON/pb_decode.o", "$COMMON/pb_common.o"])
+enc = env.Program(["encode_buffer.c", "$COMMON/person.pb.c", "$COMMON/pb_encode.o"])
+dec = env.Program(["decode_buffer.c", "$COMMON/person.pb.c", "$COMMON/pb_decode.o"])

 env.RunTest(enc)
 env.RunTest([dec, "encode_buffer.output"])
--- a/tests/basic_stream/SConscript
+++ b/tests/basic_stream/SConscript
@@ -2,8 +2,8 @@

 Import("env")

-enc = env.Program(["encode_stream.c", "$COMMON/person.pb.c", "$COMMON/pb_encode.o", "$COMMON/pb_common.o"])
-dec = env.Program(["decode_stream.c", "$COMMON/person.pb.c", "$COMMON/pb_decode.o", "$COMMON/pb_common.o"])
+enc = env.Program(["encode_stream.c", "$COMMON/person.pb.c", "$COMMON/pb_encode.o"])
+dec = env.Program(["decode_stream.c", "$COMMON/person.pb.c", "$COMMON/pb_decode.o"])

 env.RunTest(enc)
 env.RunTest([dec, "encode_stream.output"])
--- a/tests/buffer_only/SConscript
+++ b/tests/buffer_only/SConscript
@@ -18,11 +18,10 @@ strict = opts.Clone()
 strict.Append(CFLAGS = strict['CORECFLAGS'])
 strict.Object("pb_decode_bufonly.o", "$NANOPB/pb_decode.c")
 strict.Object("pb_encode_bufonly.o", "$NANOPB/pb_encode.c")
-strict.Object("pb_common_bufonly.o", "$NANOPB/pb_common.c")

 # Now build and run the test normally.
-enc = opts.Program(["encode_alltypes.c", "alltypes.pb.c", "pb_encode_bufonly.o", "pb_common_bufonly.o"])
-dec = opts.Program(["decode_alltypes.c", "alltypes.pb.c", "pb_decode_bufonly.o", "pb_common_bufonly.o"])
+enc = opts.Program(["encode_alltypes.c", "alltypes.pb.c", "pb_encode_bufonly.o"])
+dec = opts.Program(["decode_alltypes.c", "alltypes.pb.c", "pb_decode_bufonly.o"])

 env.RunTest(enc)
 env.RunTest([dec, "encode_alltypes.output"])
--- a/tests/callbacks/SConscript
+++ b/tests/callbacks/SConscript
@@ -3,8 +3,8 @@
 Import("env")

 env.NanopbProto("callbacks")
-enc = env.Program(["encode_callbacks.c", "callbacks.pb.c", "$COMMON/pb_encode.o", "$COMMON/pb_common.o"])
-dec = env.Program(["decode_callbacks.c", "callbacks.pb.c", "$COMMON/pb_decode.o", "$COMMON/pb_common.o"])
+enc = env.Program(["encode_callbacks.c", "callbacks.pb.c", "$COMMON/pb_encode.o"])
+dec = env.Program(["decode_callbacks.c", "callbacks.pb.c", "$COMMON/pb_decode.o"])

 env.RunTest(enc)
 env.RunTest([dec, "encode_callbacks.output"])
--- a/tests/common/SConscript
+++ b/tests/common/SConscript
@@ -8,10 +8,39 @@ env.NanopbProto("unittestproto")
 # Protocol definitions for basic_buffer/stream tests
 env.NanopbProto("person")

+#--------------------------------------------
 # Binaries of the pb_decode.c and pb_encode.c
 # These are built using more strict warning flags.
 strict = env.Clone()
 strict.Append(CFLAGS = strict['CORECFLAGS'])
 strict.Object("pb_decode.o", "$NANOPB/pb_decode.c")
 strict.Object("pb_encode.o", "$NANOPB/pb_encode.c")
-strict.Object("pb_common.o", "$NANOPB/pb_common.c")
+
+#-----------------------------------------------
+# Binaries of pb_decode etc. with malloc support
+# Uses malloc_wrappers.c to count allocations.
+malloc_env = env.Clone()
+malloc_env.Append(CPPDEFINES = {'PB_ENABLE_MALLOC': 1,
+                                'PB_SYSTEM_HEADER': '\\"malloc_wrappers_syshdr.h\\"'})
+malloc_env.Append(CPPPATH = ["$COMMON"])
+
+if 'SYSHDR' in malloc_env:
+    malloc_env.Append(CPPDEFINES = {'PB_OLD_SYSHDR': malloc_env['SYSHDR']})
+
+# Disable libmudflap, because it will confuse valgrind
+# and other memory leak detection tools.
+if '-fmudflap' in env["CCFLAGS"]:
+    malloc_env["CCFLAGS"].remove("-fmudflap")
+    malloc_env["LINKFLAGS"].remove("-fmudflap")
+    malloc_env["LIBS"].remove("mudflap")
+
+malloc_strict = malloc_env.Clone()
+malloc_strict.Append(CFLAGS = malloc_strict['CORECFLAGS'])
+malloc_strict.Object("pb_decode_with_malloc.o", "$NANOPB/pb_decode.c")
+malloc_strict.Object("pb_encode_with_malloc.o", "$NANOPB/pb_encode.c")
+
+malloc_env.Object("malloc_wrappers.o", "malloc_wrappers.c")
+malloc_env.Depends("$NANOPB/pb.h", ["malloc_wrappers_syshdr.h", "malloc_wrappers.h"])
+
+Export("malloc_env")
+
--- a/tests/fuzztest/malloc_wrappers.c
+++ b/tests/fuzztest/malloc_wrappers.c
--- a/tests/fuzztest/malloc_wrappers.h
+++ b/tests/fuzztest/malloc_wrappers.h
--- a/tests/common/malloc_wrappers_syshdr.h
+++ b/tests/common/malloc_wrappers_syshdr.h
--- a/tests/common/unittestproto.proto
+++ b/tests/common/unittestproto.proto
@@ -34,8 +34,3 @@ message CallbackContainer {
 message CallbackContainerContainer {
    required CallbackContainer submsg = 1;
 }
-
-message StringPointerContainer {
-    repeated string rep_str = 1 [(nanopb).type = FT_POINTER];
-}
-
--- a/tests/cxx_main_program/SConscript
+++ b/tests/cxx_main_program/SConscript
@@ -11,15 +11,14 @@ env.Append(CPPDEFINES = ['__STDC_LIMIT_MACROS'])
 c = Copy("$TARGET", "$SOURCE")
 env.Command("pb_encode.cxx", "#../pb_encode.c", c)
 env.Command("pb_decode.cxx", "#../pb_decode.c", c)
-env.Command("pb_common.cxx", "#../pb_common.c", c)
 env.Command("alltypes.pb.h", "$BUILD/alltypes/alltypes.pb.h", c)
 env.Command("alltypes.pb.cxx", "$BUILD/alltypes/alltypes.pb.c", c)
 env.Command("encode_alltypes.cxx", "$BUILD/alltypes/encode_alltypes.c", c)
 env.Command("decode_alltypes.cxx", "$BUILD/alltypes/decode_alltypes.c", c)

 # Now build and run the test normally.
-enc = env.Program(["encode_alltypes.cxx", "alltypes.pb.cxx", "pb_encode.cxx", "pb_common.cxx"])
-dec = env.Program(["decode_alltypes.cxx", "alltypes.pb.cxx", "pb_decode.cxx", "pb_common.cxx"])
+enc = env.Program(["encode_alltypes.cxx", "alltypes.pb.cxx", "pb_encode.cxx"])
+dec = env.Program(["decode_alltypes.cxx", "alltypes.pb.cxx", "pb_decode.cxx"])

 env.RunTest(enc)
 env.RunTest([dec, "encode_alltypes.output"])
--- a/tests/cyclic_messages/SConscript
+++ b/tests/cyclic_messages/SConscript
@@ -1,11 +0,0 @@
-Import("env")
-
-# Encode cyclic messages with callback fields
-
-c = Copy("$TARGET", "$SOURCE")
-env.Command("cyclic_callback.proto", "cyclic.proto", c)
-env.NanopbProto(["cyclic_callback", "cyclic_callback.options"])
-
-enc_callback = env.Program(["encode_cyclic_callback.c", "cyclic_callback.pb.c", "$COMMON/pb_encode.o", "$COMMON/pb_common.o"])
-
-
--- a/tests/cyclic_messages/cyclic.proto
+++ b/tests/cyclic_messages/cyclic.proto
@@ -1,25 +0,0 @@
-// Test structures with cyclic references.
-// These can only be handled in pointer/callback mode,
-// see associated .options files.
-
-message TreeNode
-{
-    optional int32 leaf = 1;
-    optional TreeNode left = 2;
-    optional TreeNode right = 3;
-}
-
-message Dictionary
-{
-    repeated KeyValuePair dictItem = 1;
-}
-
-message KeyValuePair
-{
-    required string key = 1;
-    optional string stringValue = 2;
-    optional int32 intValue = 3;
-    optional Dictionary dictValue = 4;
-    optional TreeNode treeValue = 5;
-}
-
--- a/tests/cyclic_messages/cyclic_callback.options
+++ b/tests/cyclic_messages/cyclic_callback.options
@@ -1,7 +0,0 @@
-TreeNode.left               type:FT_CALLBACK
-TreeNode.right              type:FT_CALLBACK
-
-Dictionary.data             type:FT_CALLBACK
-KeyValuePair.key            max_size:8
-KeyValuePair.stringValue    max_size:8
-KeyValuePair.treeValue      type:FT_CALLBACK
--- a/tests/cyclic_messages/encode_cyclic_callback.c
+++ b/tests/cyclic_messages/encode_cyclic_callback.c
@@ -1,148 +0,0 @@
-/* This program parses an input string in a format a bit like JSON:
- * {'foobar': 1234, 'xyz': 'abc', 'tree': [[[1, 2], 3], [4, 5]]}
- * and encodes it as protobuf
- *
- * Note: The string parsing here is not in any way intended to be robust
- *       nor safe against buffer overflows. It is just for this test.
- */
-
-#include <pb_encode.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include "cyclic_callback.pb.h"
-
-static char *find_end_of_item(char *p)
-{
-    int depth = 0;
-    do {
-        if (*p == '[' || *p == '{') depth++;
-        if (*p == ']' || *p == '}') depth--;
-        p++;
-    } while (depth > 0 || (*p != ',' && *p != '}'));
-    
-    if (*p == '}')
-        return p; /* End of parent dict */
-    
-    p++;
-    while (*p == ' ') p++;
-    return p;
-}
-
-/* Parse a tree in format [[1 2] 3] and encode it directly to protobuf */
-static bool encode_tree(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
-{
-    TreeNode tree = TreeNode_init_zero;
-    char *p = (char*)*arg;
-    
-    if (*p == '[')
-    {
-        /* This is a tree branch */
-        p++;
-        tree.left.funcs.encode = encode_tree;
-        tree.left.arg = p;
-        
-        p = find_end_of_item(p);
-        tree.right.funcs.encode = encode_tree;
-        tree.right.arg = p;
-    }
-    else
-    {
-        /* This is a leaf node */
-        tree.has_leaf = true;
-        tree.leaf = atoi(p);
-    }
-    
-    return pb_encode_tag_for_field(stream, field) &&
-           pb_encode_submessage(stream, TreeNode_fields, &tree);
-}
-
-/* Parse a dictionary in format {'name': value} and encode it directly to protobuf */
-static bool encode_dictionary(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
-{
-    int textlen;
-    char *p = (char*)*arg;
-    if (*p == '{') p++;
-    while (*p != '}')
-    {
-        KeyValuePair pair = KeyValuePair_init_zero;
-        
-        if (*p != '\'')
-            PB_RETURN_ERROR(stream, "invalid key, missing quote");
-        
-        p++; /* Starting quote of key */
-        textlen = strchr(p, '\'') - p;
-        strncpy(pair.key, p, textlen);
-        pair.key[textlen] = 0;
-        p += textlen + 2;
-        
-        while (*p == ' ') p++;
-        
-        if (*p == '[')
-        {
-            /* Value is a tree */
-            pair.treeValue.funcs.encode = encode_tree;
-            pair.treeValue.arg = p;
-        }
-        else if (*p == '\'')
-        {
-            /* Value is a string */
-            pair.has_stringValue = true;
-            p++;
-            textlen = strchr(p, '\'') - p;
-            strncpy(pair.stringValue, p, textlen);
-            pair.stringValue[textlen] = 0;
-        }
-        else if (*p == '{')
-        {
-            /* Value is a dictionary */
-            pair.has_dictValue = true;
-            pair.dictValue.dictItem.funcs.encode = encode_dictionary;
-            pair.dictValue.dictItem.arg = p;
-        }
-        else
-        {
-            /* Value is integer */
-            pair.has_intValue = true;
-            pair.intValue = atoi(p);
-        }
-        
-        p = find_end_of_item(p);
-        
-        if (!pb_encode_tag_for_field(stream, field))
-            return false;
-        
-        if (!pb_encode_submessage(stream, KeyValuePair_fields, &pair))
-            return false;
-    }
-
-    return true;
-}
-
-
-int main(int argc, char *argv[])
-{
-    uint8_t buffer[256];
-    pb_ostream_t stream = pb_ostream_from_buffer(buffer, sizeof(buffer));
-    Dictionary dict = Dictionary_init_zero;
-    
-    if (argc <= 1)
-    {
-        fprintf(stderr, "Usage: %s \"{'foobar': 1234, ...}\"\n", argv[0]);
-        return 1;
-    }
-    
-    dict.dictItem.funcs.encode = encode_dictionary;
-    dict.dictItem.arg = argv[1];
-
-    if (!pb_encode(&stream, Dictionary_fields, &dict))
-    {
-        fprintf(stderr, "Encoding error: %s\n", PB_GET_ERROR(&stream));
-        return 1;
-    }
-    
-    fwrite(buffer, 1, stream.bytes_written, stdout);
-    return 0;
-}
-
-
--- a/tests/decode_unittests/decode_unittests.c
+++ b/tests/decode_unittests/decode_unittests.c
@@ -1,6 +1,5 @@
 /* This includes the whole .c file to get access to static functions. */
 #define PB_ENABLE_MALLOC
-#include "pb_common.c"
 #include "pb_decode.c"

 #include <stdio.h>
@@ -87,20 +86,6 @@ int main()
              pb_decode_varint(&s, (uint64_t*)&i) && i == -1));
        TEST((s = S("\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x01"),
              pb_decode_varint(&s, &u) && u == UINT64_MAX));
-        TEST((s = S("\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x01"),
-              !pb_decode_varint(&s, &u)));
-    }
-    
-    {
-        pb_istream_t s;
-        uint32_t u;
-        
-        COMMENT("Test pb_decode_varint32");
-        TEST((s = S("\x00"), pb_decode_varint32(&s, &u) && u == 0));
-        TEST((s = S("\x01"), pb_decode_varint32(&s, &u) && u == 1));
-        TEST((s = S("\xAC\x02"), pb_decode_varint32(&s, &u) && u == 300));
-        TEST((s = S("\xFF\xFF\xFF\xFF\x0F"), pb_decode_varint32(&s, &u) && u == UINT32_MAX));
-        TEST((s = S("\xFF\xFF\xFF\xFF\xFF\x01"), !pb_decode_varint32(&s, &u)));
    }
    
    {
@@ -184,7 +169,7 @@ int main()
    
    {
        pb_istream_t s;
-        struct { pb_size_t size; uint8_t bytes[5]; } d;
+        struct { size_t size; uint8_t bytes[5]; } d;
        pb_field_t f = {1, PB_LTYPE_BYTES, 0, 0, sizeof(d), 0, 0};
        
        COMMENT("Test pb_dec_bytes")
@@ -265,7 +250,7 @@ int main()
    {
        pb_istream_t s;
        CallbackArray dest;
-        struct { pb_size_t size; uint8_t bytes[10]; } ref;
+        struct { size_t size; uint8_t bytes[10]; } ref;
        dest.data.funcs.decode = &callback_check;
        dest.data.arg = &ref;
        
--- a/tests/encode_unittests/encode_unittests.c
+++ b/tests/encode_unittests/encode_unittests.c
@@ -1,5 +1,4 @@
 /* This includes the whole .c file to get access to static functions. */
-#include "pb_common.c"
 #include "pb_encode.c"

 #include <stdio.h>
@@ -170,7 +169,7 @@ int main()
    {
        uint8_t buffer[30];
        pb_ostream_t s;
-        struct { pb_size_t size; uint8_t bytes[5]; } value = {5, {'x', 'y', 'z', 'z', 'y'}};
+        struct { size_t size; uint8_t bytes[5]; } value = {5, {'x', 'y', 'z', 'z', 'y'}};
    
        COMMENT("Test pb_enc_bytes")
        TEST(WRITES(pb_enc_bytes(&s, &BytesMessage_fields[0], &value), "\x05xyzzy"))
@@ -331,23 +330,6 @@ int main()
        TEST(s.bytes_written == StringMessage_size);
    }
    
-    {
-        uint8_t buffer[128];
-        pb_ostream_t s;
-        StringPointerContainer msg = StringPointerContainer_init_zero;
-        char *strs[1] = {NULL};
-        char zstr[] = "Z";
-        
-        COMMENT("Test string pointer encoding.");
-        
-        msg.rep_str = strs;
-        msg.rep_str_count = 1;
-        TEST(WRITES(pb_encode(&s, StringPointerContainer_fields, &msg), "\x0a\x00"))
-        
-        strs[0] = zstr;
-        TEST(WRITES(pb_encode(&s, StringPointerContainer_fields, &msg), "\x0a\x01Z"))
-    }
-    
    if (status != 0)
        fprintf(stdout, "\n\nSome tests FAILED!\n");
    
--- a/tests/extensions/SConscript
+++ b/tests/extensions/SConscript
@@ -8,8 +8,8 @@ incpath.Append(PROTOCPATH = '$BUILD/alltypes')
 incpath.Append(CPPPATH = '$BUILD/alltypes')

 incpath.NanopbProto(["extensions", "extensions.options"])
-enc = incpath.Program(["encode_extensions.c", "extensions.pb.c", "$BUILD/alltypes/alltypes.pb$OBJSUFFIX", "$COMMON/pb_encode.o", "$COMMON/pb_common.o"])
-dec = incpath.Program(["decode_extensions.c", "extensions.pb.c", "$BUILD/alltypes/alltypes.pb$OBJSUFFIX", "$COMMON/pb_decode.o", "$COMMON/pb_common.o"])
+enc = incpath.Program(["encode_extensions.c", "extensions.pb.c", "$BUILD/alltypes/alltypes.pb$OBJSUFFIX", "$COMMON/pb_encode.o"])
+dec = incpath.Program(["decode_extensions.c", "extensions.pb.c", "$BUILD/alltypes/alltypes.pb$OBJSUFFIX", "$COMMON/pb_decode.o"])

 env.RunTest(enc)
 env.RunTest([dec, "encode_extensions.output"])
--- a/tests/extensions/extensions.proto
+++ b/tests/extensions/extensions.proto
@@ -7,7 +7,6 @@ extend AllTypes {
 message ExtensionMessage {
    extend AllTypes {
        optional ExtensionMessage AllTypes_extensionfield2 = 254;
-	required ExtensionMessage AllTypes_extensionfield3 = 253;
 	repeated ExtensionMessage AllTypes_extensionfield4 = 252;
    }
    
--- a/tests/field_size_16/SConscript
+++ b/tests/field_size_16/SConscript
@@ -19,11 +19,10 @@ strict = opts.Clone()
 strict.Append(CFLAGS = strict['CORECFLAGS'])
 strict.Object("pb_decode_fields16.o", "$NANOPB/pb_decode.c")
 strict.Object("pb_encode_fields16.o", "$NANOPB/pb_encode.c")
-strict.Object("pb_common_fields16.o", "$NANOPB/pb_common.c")

 # Now build and run the test normally.
-enc = opts.Program(["encode_alltypes.c", "alltypes.pb.c", "pb_encode_fields16.o", "pb_common_fields16.o"])
-dec = opts.Program(["decode_alltypes.c", "alltypes.pb.c", "pb_decode_fields16.o", "pb_common_fields16.o"])
+enc = opts.Program(["encode_alltypes.c", "alltypes.pb.c", "pb_encode_fields16.o"])
+dec = opts.Program(["decode_alltypes.c", "alltypes.pb.c", "pb_decode_fields16.o"])

 env.RunTest(enc)
 env.RunTest([dec, "encode_alltypes.output"])
--- a/tests/field_size_32/SConscript
+++ b/tests/field_size_32/SConscript
@@ -19,11 +19,10 @@ strict = opts.Clone()
 strict.Append(CFLAGS = strict['CORECFLAGS'])
 strict.Object("pb_decode_fields32.o", "$NANOPB/pb_decode.c")
 strict.Object("pb_encode_fields32.o", "$NANOPB/pb_encode.c")
-strict.Object("pb_common_fields32.o", "$NANOPB/pb_common.c")

 # Now build and run the test normally.
-enc = opts.Program(["encode_alltypes.c", "alltypes.pb.c", "pb_encode_fields32.o", "pb_common_fields32.o"])
-dec = opts.Program(["decode_alltypes.c", "alltypes.pb.c", "pb_decode_fields32.o", "pb_common_fields32.o"])
+enc = opts.Program(["encode_alltypes.c", "alltypes.pb.c", "pb_encode_fields32.o"])
+dec = opts.Program(["decode_alltypes.c", "alltypes.pb.c", "pb_decode_fields32.o"])

 env.RunTest(enc)
 env.RunTest([dec, "encode_alltypes.output"])
--- a/tests/fuzztest/SConscript
+++ b/tests/fuzztest/SConscript
@@ -1,30 +1,9 @@
 # Run a fuzz test to verify robustness against corrupted/malicious data.

-Import("env")
-
-# We need our own pb_decode.o for the malloc support
-env = env.Clone()
-env.Append(CPPDEFINES = {'PB_ENABLE_MALLOC': 1,
-                         'PB_SYSTEM_HEADER': '\\"fuzz_syshdr.h\\"'})
-env.Append(CPPPATH = ".")
-
-if 'SYSHDR' in env:
-    env.Append(CPPDEFINES = {'PB_OLD_SYSHDR': env['SYSHDR']})
-
-# Disable libmudflap, because it will confuse valgrind
-# and other memory leak detection tools.
-if '-fmudflap' in env["CCFLAGS"]:
-    env["CCFLAGS"].remove("-fmudflap")
-    env["LINKFLAGS"].remove("-fmudflap")
-    env["LIBS"].remove("mudflap")
-
-strict = env.Clone()
-strict.Append(CFLAGS = strict['CORECFLAGS'])
-strict.Object("pb_decode_with_malloc.o", "$NANOPB/pb_decode.c")
-strict.Object("pb_encode_with_malloc.o", "$NANOPB/pb_encode.c")
-strict.Object("pb_common_with_malloc.o", "$NANOPB/pb_common.c")
+Import("env", "malloc_env")

 # We want both pointer and static versions of the AllTypes message
+# Prefix them with package name.
 env.Command("alltypes_static.proto", "#alltypes/alltypes.proto",
            lambda target, source, env:
                open(str(target[0]), 'w').write("package alltypes_static;\n"
@@ -36,23 +15,20 @@ env.Command("alltypes_pointer.proto", "#alltypes/alltypes.proto",

 p1 = env.NanopbProto(["alltypes_pointer", "alltypes_pointer.options"])
 p2 = env.NanopbProto(["alltypes_static", "alltypes_static.options"])
-fuzz = env.Program(["fuzztest.c",
+fuzz = malloc_env.Program(["fuzztest.c",
                    "alltypes_pointer.pb.c",
                    "alltypes_static.pb.c",
-                    "pb_encode_with_malloc.o",
-                    "pb_decode_with_malloc.o",
-                    "pb_common_with_malloc.o",
-                    "malloc_wrappers.c"])
-Depends([p1, p2, fuzz], ["fuzz_syshdr.h", "malloc_wrappers.h"])
+                    "$COMMON/pb_encode_with_malloc.o",
+                    "$COMMON/pb_decode_with_malloc.o",
+                    "$COMMON/malloc_wrappers.o"])

 env.RunTest(fuzz)

-fuzzstub = env.Program(["fuzzstub.c",
+fuzzstub = malloc_env.Program(["fuzzstub.c",
                    "alltypes_pointer.pb.c",
                    "alltypes_static.pb.c",
-                    "pb_encode_with_malloc.o",
-                    "pb_decode_with_malloc.o",
-                    "pb_common_with_malloc.o",
-                    "malloc_wrappers.c"])
+                    "$COMMON/pb_encode_with_malloc.o",
+                    "$COMMON/pb_decode_with_malloc.o",
+                    "$COMMON/malloc_wrappers.o"])


--- a/tests/fuzztest/fuzzstub.c
+++ b/tests/fuzztest/fuzzstub.c
@@ -10,7 +10,7 @@
 #include <string.h>
 #include <assert.h>
 #include <time.h>
-#include "malloc_wrappers.h"
+#include <malloc_wrappers.h>
 #include "alltypes_static.pb.h"
 #include "alltypes_pointer.pb.h"

--- a/tests/fuzztest/fuzztest.c
+++ b/tests/fuzztest/fuzztest.c
@@ -9,7 +9,7 @@
 #include <string.h>
 #include <assert.h>
 #include <time.h>
-#include "malloc_wrappers.h"
+#include <malloc_wrappers.h>
 #include "alltypes_static.pb.h"
 #include "alltypes_pointer.pb.h"

--- a/tests/io_errors/SConscript
+++ b/tests/io_errors/SConscript
@@ -1,15 +0,0 @@
-# Simulate io errors when encoding and decoding
-
-Import("env")
-
-c = Copy("$TARGET", "$SOURCE")
-env.Command("alltypes.proto", "#alltypes/alltypes.proto", c)
-
-env.NanopbProto(["alltypes", "alltypes.options"])
-
-ioerr = env.Program(["io_errors.c", "alltypes.pb.c",
-                     "$COMMON/pb_encode.o", "$COMMON/pb_decode.o", "$COMMON/pb_common.o"])
-
-env.RunTest("io_errors.output", [ioerr, "$BUILD/alltypes/encode_alltypes.output"])
-
-
--- a/tests/io_errors/alltypes.options
+++ b/tests/io_errors/alltypes.options
@@ -1,3 +0,0 @@
-* max_size:16
-* max_count:5
-
--- a/tests/io_errors/io_errors.c
+++ b/tests/io_errors/io_errors.c
@@ -1,140 +0,0 @@
-/* Simulate IO errors after each byte in a stream.
- * Verifies proper error propagation.
- */
-
-#include <stdio.h>
-#include <pb_decode.h>
-#include <pb_encode.h>
-#include "alltypes.pb.h"
-#include "test_helpers.h"
-
-typedef struct
-{
-    uint8_t *buffer;
-    size_t fail_after;
-} faulty_stream_t;
-
-bool read_callback(pb_istream_t *stream, uint8_t *buf, size_t count)
-{
-    faulty_stream_t *state = stream->state;
-    
-    while (count--)
-    {
-        if (state->fail_after == 0)
-            PB_RETURN_ERROR(stream, "simulated");
-        state->fail_after--;
-        *buf++ = *state->buffer++;
-    }
-    
-    return true;
-}
-bool write_callback(pb_ostream_t *stream, const uint8_t *buf, size_t count)
-{
-    faulty_stream_t *state = stream->state;
-    
-    while (count--)
-    {
-        if (state->fail_after == 0)
-            PB_RETURN_ERROR(stream, "simulated");
-        state->fail_after--;
-        *state->buffer++ = *buf++;
-    }
-    
-    return true;
-}
-
-int main()
-{
-    uint8_t buffer[2048];
-    size_t msglen;
-    AllTypes msg = AllTypes_init_zero;
-    
-    /* Get some base data to run the tests with */
-    SET_BINARY_MODE(stdin);
-    msglen = fread(buffer, 1, sizeof(buffer), stdin);
-    
-    /* Test IO errors on decoding */
-    {
-        bool status;
-        pb_istream_t stream = {&read_callback, NULL, SIZE_MAX};
-        faulty_stream_t fs;
-        size_t i;
-        
-        for (i = 0; i < msglen; i++)
-        {
-            stream.bytes_left = msglen;
-            stream.state = &fs;
-            fs.buffer = buffer;
-            fs.fail_after = i;
-
-            status = pb_decode(&stream, AllTypes_fields, &msg);
-            if (status != false)
-            {
-                fprintf(stderr, "Unexpected success in decode\n");
-                return 2;
-            }
-            else if (strcmp(stream.errmsg, "simulated") != 0)
-            {
-                fprintf(stderr, "Wrong error in decode: %s\n", stream.errmsg);
-                return 3;
-            }
-        }
-        
-        stream.bytes_left = msglen;
-        stream.state = &fs;
-        fs.buffer = buffer;
-        fs.fail_after = msglen;
-        status = pb_decode(&stream, AllTypes_fields, &msg);
-        
-        if (!status)
-        {
-            fprintf(stderr, "Decoding failed: %s\n", stream.errmsg);
-            return 4;
-        }
-    }
-    
-    /* Test IO errors on encoding */
-    {
-        bool status;
-        pb_ostream_t stream = {&write_callback, NULL, SIZE_MAX, 0};
-        faulty_stream_t fs;
-        size_t i;
-        
-        for (i = 0; i < msglen; i++)
-        {
-            stream.max_size = msglen;
-            stream.bytes_written = 0;
-            stream.state = &fs;
-            fs.buffer = buffer;
-            fs.fail_after = i;
-
-            status = pb_encode(&stream, AllTypes_fields, &msg);
-            if (status != false)
-            {
-                fprintf(stderr, "Unexpected success in encode\n");
-                return 5;
-            }
-            else if (strcmp(stream.errmsg, "simulated") != 0)
-            {
-                fprintf(stderr, "Wrong error in encode: %s\n", stream.errmsg);
-                return 6;
-            }
-        }
-        
-        stream.max_size = msglen;
-        stream.bytes_written = 0;
-        stream.state = &fs;
-        fs.buffer = buffer;
-        fs.fail_after = msglen;
-        status = pb_encode(&stream, AllTypes_fields, &msg);
-        
-        if (!status)
-        {
-            fprintf(stderr, "Encoding failed: %s\n", stream.errmsg);
-            return 7;
-        }
-    }
-
-    return 0;   
-}
-
--- a/tests/io_errors_pointers/SConscript
+++ b/tests/io_errors_pointers/SConscript
@@ -1,42 +0,0 @@
-# Simulate io errors when encoding and decoding
-
-Import("env")
-
-# We need our own pb_decode.o for the malloc support
-env = env.Clone()
-env.Append(CPPDEFINES = {'PB_ENABLE_MALLOC': 1});
-
-# Disable libmudflap, because it will confuse valgrind
-# and other memory leak detection tools.
-if '-fmudflap' in env["CCFLAGS"]:
-    env["CCFLAGS"].remove("-fmudflap")
-    env["LINKFLAGS"].remove("-fmudflap")
-    env["LIBS"].remove("mudflap")
-
-strict = env.Clone()
-strict.Append(CFLAGS = strict['CORECFLAGS'])
-strict.Object("pb_decode_with_malloc.o", "$NANOPB/pb_decode.c")
-strict.Object("pb_encode_with_malloc.o", "$NANOPB/pb_encode.c")
-strict.Object("pb_common_with_malloc.o", "$NANOPB/pb_common.c")
-
-c = Copy("$TARGET", "$SOURCE")
-env.Command("alltypes.proto", "#alltypes/alltypes.proto", c)
-env.Command("io_errors.c", "#io_errors/io_errors.c", c)
-
-env.NanopbProto(["alltypes", "alltypes.options"])
-
-ioerr = env.Program(["io_errors.c", "alltypes.pb.c",
-                     "pb_encode_with_malloc.o",
-                     "pb_decode_with_malloc.o",
-                     "pb_common_with_malloc.o"])
-
-# Run tests under valgrind if available
-valgrind = env.WhereIs('valgrind')
-kwargs = {}
-if valgrind:
-    kwargs['COMMAND'] = valgrind
-    kwargs['ARGS'] = ["-q", ioerr[0].abspath]
-
-env.RunTest("io_errors.output", [ioerr, "$BUILD/alltypes/encode_alltypes.output"], **kwargs)
-
-
--- a/tests/io_errors_pointers/alltypes.options
+++ b/tests/io_errors_pointers/alltypes.options
@@ -1,3 +0,0 @@
-# Generate all fields as pointers.
-* type:FT_POINTER
-
--- a/tests/mem_release/SConscript
+++ b/tests/mem_release/SConscript
@@ -0,0 +1,12 @@
+Import("env", "malloc_env")
+
+env.NanopbProto("mem_release.proto")
+
+test = malloc_env.Program(["mem_release.c",
+                    "mem_release.pb.c",
+                    "$COMMON/pb_encode_with_malloc.o",
+                    "$COMMON/pb_decode_with_malloc.o",
+                    "$COMMON/malloc_wrappers.o"])
+
+env.RunTest(test)
+
--- a/tests/mem_release/mem_release.c
+++ b/tests/mem_release/mem_release.c
@@ -0,0 +1,106 @@
+/* Make sure that all fields are freed in various scenarios. */
+
+#include <pb_decode.h>
+#include <pb_encode.h>
+#include <malloc_wrappers.h>
+#include <stdio.h>
+#include <test_helpers.h>
+#include "mem_release.pb.h"
+
+#define TEST(x) if (!(x)) { \
+    fprintf(stderr, "Test " #x " on line %d failed.\n", __LINE__); \
+    return false; \
+    }
+
+static char *test_str_arr[] = {"1", "2", ""};
+static SubMessage test_msg_arr[] = {SubMessage_init_zero, SubMessage_init_zero};
+
+static bool do_test()
+{
+    uint8_t buffer[256];
+    size_t msgsize;
+    
+    /* Construct a message with various fields filled in */
+    {
+        TestMessage msg = TestMessage_init_zero;
+        pb_extension_t ext2;
+        pb_ostream_t stream;
+        msg.static_req_submsg.dynamic_str = "12345";
+        msg.static_req_submsg.dynamic_str_arr_count = 3;
+        msg.static_req_submsg.dynamic_str_arr = test_str_arr;
+        msg.static_req_submsg.dynamic_submsg_count = 2;
+        msg.static_req_submsg.dynamic_submsg = test_msg_arr;
+        msg.static_req_submsg.dynamic_submsg[1].dynamic_str = "abc";
+        msg.static_opt_submsg.dynamic_str = "abc";
+        msg.has_static_opt_submsg = true;
+        msg.dynamic_submsg = &msg.static_req_submsg;
+        
+        msg.extensions = &ext2;
+        ext2.type = &static_ext;
+        ext2.dest = &msg.static_req_submsg;
+        ext2.next = NULL;
+        
+        stream = pb_ostream_from_buffer(buffer, sizeof(buffer));
+        if (!pb_encode(&stream, TestMessage_fields, &msg))
+        {
+            fprintf(stderr, "Encode failed: %s\n", PB_GET_ERROR(&stream));
+            return false;
+        }
+        msgsize = stream.bytes_written;
+    }
+    
+    /* Output encoded message for debug */
+    SET_BINARY_MODE(stdout);
+    fwrite(buffer, 1, msgsize, stdout);
+    
+    /* Decode memory using dynamic allocation */
+    {
+        TestMessage msg = TestMessage_init_zero;
+        pb_istream_t stream;
+        SubMessage ext2_dest = SubMessage_init_zero;
+        pb_extension_t ext2;
+        
+        msg.extensions = &ext2;
+        ext2.type = &static_ext;
+        ext2.dest = &ext2_dest;
+        ext2.next = NULL;
+        
+        stream = pb_istream_from_buffer(buffer, msgsize);
+        if (!pb_decode(&stream, TestMessage_fields, &msg))
+        {
+            fprintf(stderr, "Decode failed: %s\n", PB_GET_ERROR(&stream));
+            return false;
+        }
+        
+        /* Make sure it encodes back to same data */
+        {
+            uint8_t buffer2[256];
+            pb_ostream_t ostream = pb_ostream_from_buffer(buffer2, sizeof(buffer2));
+            TEST(pb_encode(&ostream, TestMessage_fields, &msg));
+            TEST(ostream.bytes_written == msgsize);
+            TEST(memcmp(buffer, buffer2, msgsize) == 0);
+        }
+        
+        /* Make sure that malloc counters work */
+        TEST(get_alloc_count() > 0);
+        
+        /* Make sure that pb_release releases everything */
+        pb_release(TestMessage_fields, &msg);
+        TEST(get_alloc_count() == 0);
+        
+        /* Check that double-free is a no-op */
+        pb_release(TestMessage_fields, &msg);
+        TEST(get_alloc_count() == 0);
+    }
+    
+    return true;
+}
+
+int main()
+{
+    if (do_test())
+        return 0;
+    else
+        return 1;
+}
+
--- a/tests/mem_release/mem_release.proto
+++ b/tests/mem_release/mem_release.proto
@@ -0,0 +1,23 @@
+syntax = "proto2";
+import "nanopb.proto";
+
+message SubMessage
+{
+    optional string dynamic_str = 1 [(nanopb).type = FT_POINTER];
+    repeated string dynamic_str_arr = 2 [(nanopb).type = FT_POINTER];
+    repeated SubMessage dynamic_submsg = 3 [(nanopb).type = FT_POINTER];
+}
+
+message TestMessage
+{
+    required SubMessage static_req_submsg = 1 [(nanopb).type = FT_STATIC];
+    optional SubMessage dynamic_submsg = 2 [(nanopb).type = FT_POINTER];
+    optional SubMessage static_opt_submsg = 3 [(nanopb).type = FT_STATIC];
+    extensions 100 to 200;
+}
+
+extend TestMessage
+{
+    optional SubMessage static_ext = 101 [(nanopb).type = FT_STATIC];
+}
+
--- a/tests/missing_fields/SConscript
+++ b/tests/missing_fields/SConscript
@@ -3,6 +3,6 @@
 Import("env")

 env.NanopbProto("missing_fields")
-test = env.Program(["missing_fields.c", "missing_fields.pb.c", "$COMMON/pb_encode.o", "$COMMON/pb_decode.o", "$COMMON/pb_common.o"])
+test = env.Program(["missing_fields.c", "missing_fields.pb.c", "$COMMON/pb_encode.o", "$COMMON/pb_decode.o"])
 env.RunTest(test)

--- a/tests/no_errmsg/SConscript
+++ b/tests/no_errmsg/SConscript
@@ -18,11 +18,10 @@ strict = opts.Clone()
 strict.Append(CFLAGS = strict['CORECFLAGS'])
 strict.Object("pb_decode_noerr.o", "$NANOPB/pb_decode.c")
 strict.Object("pb_encode_noerr.o", "$NANOPB/pb_encode.c")
-strict.Object("pb_common_noerr.o", "$NANOPB/pb_common.c")

 # Now build and run the test normally.
-enc = opts.Program(["encode_alltypes.c", "alltypes.pb.c", "pb_encode_noerr.o", "pb_common_noerr.o"])
-dec = opts.Program(["decode_alltypes.c", "alltypes.pb.c", "pb_decode_noerr.o", "pb_common_noerr.o"])
+enc = opts.Program(["encode_alltypes.c", "alltypes.pb.c", "pb_encode_noerr.o"])
+dec = opts.Program(["decode_alltypes.c", "alltypes.pb.c", "pb_decode_noerr.o"])

 env.RunTest(enc)
 env.RunTest([dec, "encode_alltypes.output"])
--- a/tests/package_name/SConscript
+++ b/tests/package_name/SConscript
@@ -29,7 +29,7 @@ def modify_c(target, source, env):
 env.Command("encode_alltypes.c", "#alltypes/encode_alltypes.c", modify_c)

 # Encode and compare results to original alltypes testcase
-enc = env.Program(["encode_alltypes.c", "alltypes.pb.c", "$COMMON/pb_encode.o", "$COMMON/pb_common.o"])
+enc = env.Program(["encode_alltypes.c", "alltypes.pb.c", "$COMMON/pb_encode.o"])
 refdec = "$BUILD/alltypes/decode_alltypes$PROGSUFFIX"
 env.RunTest(enc)
 env.Compare(["encode_alltypes.output", "$BUILD/alltypes/encode_alltypes.output"])
--- a/tests/splint/SConscript
+++ b/tests/splint/SConscript
@@ -11,6 +11,3 @@ if p:
    env.Command('pb_encode.splint', '$NANOPB/pb_encode.c',
        'splint -f splint/splint.rc $SOURCE 2> $TARGET')

-    env.Command('pb_common.splint', '$NANOPB/pb_common.c',
-        'splint -f splint/splint.rc $SOURCE 2> $TARGET')
-
--- a/tests/splint/splint.rc
+++ b/tests/splint/splint.rc
@@ -2,6 +2,7 @@
 +partial
 +matchanyintegral
 +strictlib
+-isoreserved		# to be fixed in 0.3
 -nullassign
 -predboolint
 -predboolptr
@@ -27,7 +28,6 @@
 -kepttrans
 -branchstate
 -immediatetrans
-mustfreefresh

 # These tests give false positives, compiler typically has
 # better warnings for these.
Author	SHA1	Message	Date
Petteri Aimonen	eb66254b79	Publishing nanopb-0.2.9.2	2015-01-24 17:18:25 +02:00
Petteri Aimonen	641c743b27	Fix build failure due to missing dependency in SConscript	2014-12-27 00:38:22 +02:00
Petteri Aimonen	4ce729df7f	Backport memory leak fix for issue 138.	2014-12-27 00:01:45 +02:00
Petteri Aimonen	83157e3362	Backport mem_release testcase from 0.3.1. Also backports cdbf51 generator bugfix.	2014-12-26 23:59:56 +02:00
Petteri Aimonen	45fc9f3ef6	Publishing nanopb-0.2.9.1	2014-09-11 19:14:45 +03:00
Petteri Aimonen	115de6e555	Update changelog	2014-09-11 19:13:59 +03:00
Petteri Aimonen	9c92410e2a	Add a better fuzz test. Attempts to verify all the properties defined in the security model, while also being portable and able to run on many platforms.	2014-09-11 18:25:23 +03:00
Petteri Aimonen	6df566859d	Protect against size_t overflows in pb_dec_bytes/pb_dec_string. Possible consequences of bug: 1) Denial of service by causing a crash Possible when all of the following apply: - Untrusted data is passed to pb_decode() - The top-level message contains a static string field as the first field. Causes a single write of '0' byte to 1 byte before the message struct. 2) Remote code execution Possible when all of the following apply: - 64-bit platform - The message or a submessage contains a static/pointer string field. - Decoding directly from a custom pb_istream_t - bytes_left on the stream is set to larger than 4 GB Causes a write of up to 4 GB of data past the string field. 3) Possible heap corruption or remote code execution Possible when all of the following apply: - less than 64-bit platform - The message or a submessage contains a pointer-type bytes field. Causes a write of sizeof(pb_size_t) bytes of data past a 0-byte long malloc()ed buffer. On many malloc() implementations, this causes at most a crash. However, remote code execution through a controlled jump cannot be ruled out. -- Detailed analysis follows In the following consideration, I define "platform bitness" as equal to number of bits in size_t datatype. Therefore most 8-bit platforms are regarded as 16-bit for the purposes of this discussion. 1. The overflow in pb_dec_string The overflow happens in this computation: uint32_t size; size_t alloc_size; alloc_size = size + 1; There are two ways in which the overflow can occur: In the uint32_t addition, or in the cast to size_t. This depends on the platform bitness. On 32- and 64-bit platforms, the size has to be UINT32_MAX for the overflow to occur. In that case alloc_size will be 0. On 16-bit platforms, overflow will happen whenever size is more than UINT16_MAX, and resulting alloc_size is attacker controlled. For static fields, the alloc_size value is just checked against the field data size. For pointer fields, the alloc_size value is passed to malloc(). End result in both cases is the same, the storage is 0 or just a few bytes in length. On 16-bit platforms, another overflow occurs in the call to pb_read(), when passing the original size. An attacker will want the passed value to be larger than the alloc_size, therefore the only reasonable choice is to have size = UINT16_MAX and alloc_size = 0. Any larger multiple will truncate to the same values. At this point we have read atleast the tag and the string length of the message, i.e. atleast 3 bytes. The maximum initial value for stream bytes_left is SIZE_MAX, thus at this point at most SIZE_MAX-3 bytes are remaining. On 32-bit and 16-bit platforms this means that the size passed to pb_read() is always larger than the number of remaining bytes. This causes pb_read() to fail immediately, before reading any bytes. On 64-bit platforms, it is possible for the bytes_left value to be set to a value larger than UINT32_MAX, which is the wraparound point in size calculation. In this case pb_read() will succeed and write up to 4 GB of attacker controlled data over the RAM that comes after the string field. On all platforms, there is an unconditional write of a terminating null byte. Because the size of size_t typically reflects the size of the processor address space, a write at UINT16_MAX or UINT32_MAX bytes after the string field actually wraps back to before the string field. Consequently, on 32-bit and 16-bit platforms, the bug causes a single write of '0' byte at one byte before the string field. If the string field is in the middle of a message, this will just corrupt other data in the message struct. Because the message contents is attacker controlled anyway, this is a non-issue. However, if the string field is the first field in the top-level message, it can corrupt other data on the stack/heap before it. Typically a single '0' write at a location not controlled by attacker is enough only for a denial-of-service attack. When using pointer fields and malloc(), the attacker controlled alloc_size will cause a 0-size allocation to happen. By the same logic as before, on 32-bit and 16-bit platforms this causes a '0' byte write only. On 64-bit platforms, however, it will again allow up to 4 GB of malicious data to be written over memory, if the stream length allows the read. 2. The overflow in pb_dec_bytes This overflow happens in the PB_BYTES_ARRAY_T_ALLOCSIZE macro: The computation is done in size_t data type this time. This means that an overflow is possible only when n is larger than SIZE_MAX - offsetof(..). The offsetof value in this case is equal to sizeof(pb_size_t) bytes. Because the incoming size value is limited to 32 bits, no overflow can happen here on 64-bit platforms. The size will be passed to pb_read(). Like before, on 32-bit and 16-bit platforms the read will always fail before writing anything. This leaves only the write of bdest->size as exploitable. On statically allocated fields, the size field will always be allocated, regardless of alloc_size. In this case, no buffer overflow is possible here, but user code could possibly use the attacker controlled size value and read past a buffer. If the field is allocated through malloc(), this will allow a write of sizeof(pb_size_t) attacker controlled bytes to past a 0-byte long buffer. In typical malloc implementations, this will either fit in unused alignment padding area, or cause a heap corruption and a crash. Under very exceptional situation it could allow attacker to influence the behaviour of malloc(), possibly jumping into an attacker-controlled location and thus leading to remote code execution.	2014-09-11 18:25:23 +03:00
Petteri Aimonen	cc1c3a7963	Add just-to-be-sure check to allocate_field(). This check will help to detect bugs earlier, and is quite lightweight compared to malloc() anyway.	2014-09-11 18:25:23 +03:00
Petteri Aimonen	33585924de	Fix memory leak with duplicated fields and PB_ENABLE_MALLOC. If a required or optional field appeared twice in the message data, pb_decode will overwrite the old data with new one. That is fine, but with submessage fields, it didn't release the allocated subfields before overwriting. This bug can manifest if all of the following conditions are true: 1. There is a message with a "optional" or "required" submessage field that has type:FT_POINTER. 2. The submessage contains atleast one field with type:FT_POINTER. 3. The message data to be decoded has the submessage field twice in it.	2014-09-11 18:25:18 +03:00
Petteri Aimonen	b7add1e577	Fix crash in pb_release() if called twice on same message. There was a double-free bug in pb_release() because it didn't set size fields to zero after deallocation. Most commonly this happens if pb_decode() fails, internally calls pb_release() and then application code also calls pb_release().	2014-09-11 18:16:01 +03:00