finish usage of UA_StatusCode internally

include/ua_types.h

@@ -57,9 +57,9 @@ typedef enum UA_EQUALITY {
  *   (e.g. for strings) are set to a length of -1.
  *
  * - <type>_copy: Copies a datatype. This performs a deep copy that iterates
- *    over the members. The copy function assumes that the destination is clean
- *    (after an _init). Copying into variants with an external data source is
- *    not permitted. If copying fails, the destination is returned clean.
+ *    over the members. Copying into variants with an external data source is
+ *    not permitted. If copying fails, a deleteMembers is performed and an error
+ *    code returned.
  *
  * - <type>_delete: Frees the memory where the datatype was stored. This
  *   performs an _deleteMembers internally if required.

src/ua_types.c

@@ -139,6 +139,7 @@ void UA_String_deleteMembers(UA_String *p) {
 }
 
 UA_StatusCode UA_String_copy(UA_String const *src, UA_String *dst) {
+    UA_String_init(dst);
     if(src->length > 0) {
         if(!(dst->data = UA_alloc(src->length)))
             return UA_STATUSCODE_BADOUTOFMEMORY;
@@ -369,18 +370,19 @@ UA_ByteString UA_ByteString_securityPoliceNone =
 
 /** Creates a ByteString of the indicated length. The content is not set to zero. */
 UA_StatusCode UA_ByteString_newMembers(UA_ByteString *p, UA_Int32 length) {
-    UA_StatusCode retval = UA_STATUSCODE_GOOD;
     if(length > 0) {
-        if((p->data = UA_alloc(length))) {
-            p->length = length;
-            return retval;
-        }
-        retval = UA_STATUSCODE_BADOUTOFMEMORY;
+        if(!(p->data = UA_alloc(length)))
+            return UA_STATUSCODE_BADOUTOFMEMORY;
+        p->length = length;
+        return UA_STATUSCODE_GOOD;
     }
+
+    p->data   = UA_NULL;
     if(length < 0)
         p->length = -1;
-    p->data   = UA_NULL;
-    return retval;
+    else
+        p->length = 0;
+    return UA_STATUSCODE_GOOD;
 }
 
 /* XmlElement */
@@ -413,12 +415,14 @@ UA_StatusCode UA_NodeId_copy(UA_NodeId const *src, UA_NodeId *dst) {
     case UA_NODEIDTYPE_BYTESTRING: // Table 6, "OPAQUE"
         retval |= UA_ByteString_copy(&src->identifier.byteString, &dst->identifier.byteString);
         break;
+
+    default:
+        UA_NodeId_init(dst);
+        return UA_STATUSCODE_BADINTERNALERROR;
     }
     dst->identifierType = src->identifierType;
-    if(retval) {
+    if(retval)
         UA_NodeId_deleteMembers(dst);
-        UA_NodeId_init(dst);
-    }
     return retval;
 }
 
@@ -571,10 +575,8 @@ UA_StatusCode UA_ExpandedNodeId_copy(UA_ExpandedNodeId const *src, UA_ExpandedNo
     retval |= UA_String_copy(&src->namespaceUri, &dst->namespaceUri);
     retval |= UA_NodeId_copy(&src->nodeId, &dst->nodeId);
     dst->serverIndex = src->serverIndex;
-    if(retval) {
+    if(retval)
         UA_ExpandedNodeId_deleteMembers(dst);
-        UA_ExpandedNodeId_init(dst);
-    }
     return retval;
 }
 
@@ -612,10 +614,8 @@ UA_TYPE_NEW_DEFAULT(UA_QualifiedName)
 UA_StatusCode UA_QualifiedName_copy(UA_QualifiedName const *src, UA_QualifiedName *dst) {
     UA_StatusCode retval = UA_String_copy(&src->name, &dst->name);
     dst->namespaceIndex = src->namespaceIndex;
-    if(retval) {
+    if(retval)
         UA_QualifiedName_deleteMembers(dst);
-        UA_QualifiedName_init(dst);
-    }
     return retval;
 
 }
@@ -668,10 +668,8 @@ UA_StatusCode UA_LocalizedText_copycstring(char const *src, UA_LocalizedText *ds
 UA_StatusCode UA_LocalizedText_copy(UA_LocalizedText const *src, UA_LocalizedText *dst) {
     UA_Int32 retval = UA_String_copy(&src->locale, &dst->locale);
     retval |= UA_String_copy(&src->text, &dst->text);
-    if(retval) {
+    if(retval)
         UA_LocalizedText_deleteMembers(dst);
-        UA_LocalizedText_init(dst);
-    }
     return retval;
 }
 
@@ -703,10 +701,8 @@ UA_StatusCode UA_ExtensionObject_copy(UA_ExtensionObject const *src, UA_Extensio
     UA_StatusCode retval = UA_ByteString_copy(&src->body, &dst->body);
     retval |= UA_NodeId_copy(&src->typeId, &dst->typeId);
     dst->encoding = src->encoding;
-    if(retval) {
+    if(retval)
         UA_ExtensionObject_deleteMembers(dst);
-        UA_ExtensionObject_init(dst);
-    }
     return retval;
 }
 
@@ -750,10 +746,8 @@ UA_StatusCode UA_DataValue_copy(UA_DataValue const *src, UA_DataValue *dst) {
     dst->serverPicoseconds = src->serverPicoseconds;
     dst->sourcePicoseconds = src->sourcePicoseconds;
     dst->status = src->status;
-    if(retval) {
+    if(retval)
         UA_DataValue_deleteMembers(dst);
-        UA_DataValue_init(dst);
-    }
     return retval;
 }
 
@@ -813,6 +807,7 @@ void UA_Variant_init(UA_Variant *p) {
 
 /** This function performs a deep copy. The resulting StorageType is UA_VARIANT_DATA. */
 UA_StatusCode UA_Variant_copy(UA_Variant const *src, UA_Variant *dst) {
+    UA_Variant_init(dst);
     // get the data
     UA_VariantData *dstdata = &dst->storage.data;
     const UA_VariantData *srcdata;
@@ -828,11 +823,12 @@ UA_StatusCode UA_Variant_copy(UA_Variant const *src, UA_Variant *dst) {
     // now copy the data to the destination
     retval |= UA_Array_copy(srcdata->dataPtr, srcdata->arrayLength, src->vt, &dstdata->dataPtr);
     if(retval == UA_STATUSCODE_GOOD) {
-        dst->storageType = UA_VARIANT_DATASOURCE;
+        dst->storageType = UA_VARIANT_DATA;
         dst->vt = src->vt;
         dstdata->arrayLength = srcdata->arrayLength;
         if(srcdata->arrayDimensions) {
-            retval |= UA_Array_copy(srcdata->arrayDimensions, srcdata->arrayDimensionsLength, &UA_[UA_INT32], (void **)&dstdata->arrayDimensions);
+            retval |= UA_Array_copy(srcdata->arrayDimensions, srcdata->arrayDimensionsLength, &UA_[UA_INT32],
+                                    (void **)&dstdata->arrayDimensions);
             if(retval == UA_STATUSCODE_GOOD)
                 dstdata->arrayDimensionsLength = srcdata->arrayDimensionsLength;
             else {
@@ -851,6 +847,7 @@ UA_StatusCode UA_Variant_copy(UA_Variant const *src, UA_Variant *dst) {
 
 /** Copies data into a variant. The target variant has always a storagetype UA_VARIANT_DATA */
 UA_StatusCode UA_Variant_copySetValue(UA_Variant *v, const UA_VTable_Entry *vt, const void *value) {
+    UA_Variant_init(v);
     v->vt = vt;
     v->storage.data.arrayLength = 1; // no array but a single entry
     UA_StatusCode retval = vt->new(&v->storage.data.dataPtr);
@@ -864,6 +861,7 @@ UA_StatusCode UA_Variant_copySetValue(UA_Variant *v, const UA_VTable_Entry *vt,
 }
 
 UA_StatusCode UA_Variant_copySetArray(UA_Variant *v, const UA_VTable_Entry *vt, UA_Int32 arrayLength, const void *array) {
+    UA_Variant_init(v);
     v->vt = vt;
     v->storage.data.arrayLength = arrayLength;
     UA_StatusCode retval = UA_Array_copy(array, arrayLength, vt, &v->storage.data.dataPtr);
@@ -921,10 +919,11 @@ void UA_DiagnosticInfo_init(UA_DiagnosticInfo *p) {
 
 UA_TYPE_NEW_DEFAULT(UA_DiagnosticInfo)
 UA_StatusCode UA_DiagnosticInfo_copy(UA_DiagnosticInfo const *src, UA_DiagnosticInfo *dst) {
+    UA_DiagnosticInfo_init(dst);
     UA_StatusCode retval = UA_String_copy(&src->additionalInfo, &dst->additionalInfo);
     dst->encodingMask = src->encodingMask;
     retval |= UA_StatusCode_copy(&src->innerStatusCode, &dst->innerStatusCode);
-    if(src->innerDiagnosticInfo) {
+    if((src->encodingMask & UA_DIAGNOSTICINFO_ENCODINGMASK_INNERDIAGNOSTICINFO) && src->innerDiagnosticInfo) {
         if((dst->innerDiagnosticInfo = UA_alloc(sizeof(UA_DiagnosticInfo))))
             retval |= UA_DiagnosticInfo_copy(src->innerDiagnosticInfo, dst->innerDiagnosticInfo);
         else
@@ -1004,9 +1003,9 @@ UA_StatusCode UA_Array_new(void **p, UA_Int32 noElements, const UA_VTable_Entry
         return UA_STATUSCODE_GOOD;
     }
 
-    // FIXME! Arrays cannot be larger than 2**20.
+    // FIXME! Arrays cannot be larger than 100MB.
     // This was randomly chosen so that the development VM does not blow up.
-    if(noElements > 1048576) {
+    if(noElements > (2^16)) {
         *p = UA_NULL;
         return UA_STATUSCODE_BADINTERNALERROR;
     }
@@ -1019,7 +1018,7 @@ UA_StatusCode UA_Array_new(void **p, UA_Int32 noElements, const UA_VTable_Entry
 }
 
 void UA_Array_init(void *p, UA_Int32 noElements, const UA_VTable_Entry *vt) {
-    char *cp = (char *)p; // so compilers allow pointer arithmetic
+    UA_Byte *cp = (UA_Byte *)p; // so compilers allow pointer arithmetic
     UA_UInt32 memSize = vt->memSize;
     for(UA_Int32 i = 0;i<noElements;i++) {
         vt->init(cp);
@@ -1028,13 +1027,14 @@ void UA_Array_init(void *p, UA_Int32 noElements, const UA_VTable_Entry *vt) {
 }
 
 void UA_Array_delete(void *p, UA_Int32 noElements, const UA_VTable_Entry *vt) {
-    char *cp = (char *)p; // so compilers allow pointer arithmetic
+    UA_Byte *cp = (UA_Byte *)p; // so compilers allow pointer arithmetic
     UA_UInt32 memSize = vt->memSize;
     for(UA_Int32 i = 0;i<noElements;i++) {
         vt->deleteMembers(cp);
         cp += memSize;
     }
-    UA_free(p);
+    if(noElements > 0)
+        UA_free(p);
 }
 
 UA_StatusCode UA_Array_copy(const void *src, UA_Int32 noElements, const UA_VTable_Entry *vt, void **dst) {
@@ -1044,8 +1044,8 @@ UA_StatusCode UA_Array_copy(const void *src, UA_Int32 noElements, const UA_VTabl
         return retval;
     }
 
-    char     *csrc    = (char *)src; // so compilers allow pointer arithmetic
-    char     *cdst    = (char *)*dst;
+    UA_Byte *csrc = (UA_Byte *)src; // so compilers allow pointer arithmetic
+    UA_Byte *cdst = (UA_Byte *)*dst;
     UA_UInt32 memSize = vt->memSize;
     UA_Int32  i       = 0;
     for(;i < noElements && retval == UA_STATUSCODE_GOOD;i++) {

src/ua_types_encoding_binary.c

@@ -59,11 +59,12 @@ static UA_StatusCode UA_Array_encodeBinary_asExtensionObject(const void *src, UA
     if(length < -1)
         length = -1;
 
-    UA_StatusCode retval   = UA_Int32_encodeBinary(&length, dst, offset);
-    const UA_Byte *csrc    = (const UA_Byte *)src;
-    UA_UInt32      memSize = vt->memSize;
+    UA_StatusCode retval = UA_Int32_encodeBinary(&length, dst, offset);
+    const UA_Byte *csrc = (const UA_Byte *)src;
+    UA_UInt32 memSize = vt->memSize;
+    UA_Boolean isBuiltin = is_builtin(&vt->typeId);
     for(UA_Int32 i = 0;i < length && !retval;i++) {
-        if(!is_builtin(&vt->typeId)) {
+        if(!isBuiltin) {
             // print the extensionobject header
             UA_NodeId_encodeBinary(&vt->typeId, dst, offset);
             UA_Byte  eoEncoding       = UA_EXTENSIONOBJECT_ENCODINGMASK_BODYISBYTESTRING;
@@ -85,6 +86,9 @@ UA_StatusCode UA_Array_decodeBinary(const UA_ByteString *src, UA_UInt32 *offset,
     }
 
     UA_StatusCode retval  = UA_Array_new(dst, length, vt);
+    if(retval)
+        return retval;
+        
     UA_Byte      *arr     = (UA_Byte *)*dst;
     UA_Int32      i       = 0;
     UA_UInt32     memSize = vt->memSize;
@@ -95,8 +99,12 @@ UA_StatusCode UA_Array_decodeBinary(const UA_ByteString *src, UA_UInt32 *offset,
 
     /* If dynamically sized elements have already been decoded into the array. */
     if(retval) {
-        i--; // undo last increase
-        UA_Array_delete(*dst, i, vt);
+        arr = (UA_Byte*) *dst;
+        for(UA_Int32 n=0;n<i;n++) {
+            vt->deleteMembers(arr);
+            arr += memSize;
+        }
+        UA_free(*dst);
         *dst = UA_NULL;
     }
 
@@ -134,7 +142,7 @@ UA_TYPE_ENCODEBINARY(UA_Boolean,
                      UA_memcpy(&dst->data[(*offset)++], &tmpBool, sizeof(UA_Boolean)); )
 UA_TYPE_DECODEBINARY(UA_Boolean,
                      if(*offset + sizeof(UA_Boolean) > (UA_UInt32)src->length )
-                         retval = UA_STATUSCODE_BADDECODINGERROR;
+                         return UA_STATUSCODE_BADDECODINGERROR;
                      *dst = ((UA_Boolean)(src->data[(*offset)++]) > (UA_Byte)0) ? UA_TRUE : UA_FALSE; )
 
 /* SByte */
@@ -142,7 +150,7 @@ UA_TYPE_CALCSIZEBINARY_SIZEOF(UA_SByte)
 UA_TYPE_ENCODEBINARY(UA_SByte, dst->data[(*offset)++] = *src; )
 UA_TYPE_DECODEBINARY(UA_SByte,
                      if(*offset + sizeof(UA_SByte) > (UA_UInt32)src->length )
-                         retval = UA_STATUSCODE_BADDECODINGERROR;
+                         return UA_STATUSCODE_BADDECODINGERROR;
                      *dst = src->data[(*offset)++]; )
 
 /* Byte */
@@ -150,7 +158,7 @@ UA_TYPE_CALCSIZEBINARY_SIZEOF(UA_Byte)
 UA_TYPE_ENCODEBINARY(UA_Byte, dst->data[(*offset)++] = *src; )
 UA_TYPE_DECODEBINARY(UA_Byte,
                      if(*offset + sizeof(UA_Byte) > (UA_UInt32)src->length )
-                         retval = UA_STATUSCODE_BADDECODINGERROR;
+                         return UA_STATUSCODE_BADDECODINGERROR;
                      *dst = src->data[(*offset)++]; )
 
 /* Int16 */
@@ -158,7 +166,7 @@ UA_TYPE_CALCSIZEBINARY_SIZEOF(UA_Int16)
 UA_TYPE_ENCODEBINARY(UA_Int16, retval = UA_UInt16_encodeBinary((UA_UInt16 const *)src, dst, offset); )
 UA_TYPE_DECODEBINARY(UA_Int16,
                      if(*offset + sizeof(UA_Int16) > (UA_UInt32)src->length )
-                         retval = UA_STATUSCODE_BADDECODINGERROR;
+                         return UA_STATUSCODE_BADDECODINGERROR;
                      *dst  = (UA_Int16)(((UA_SByte)(src->data[(*offset)++]) & 0xFF) << 0);
                      *dst |= (UA_Int16)(((UA_SByte)(src->data[(*offset)++]) & 0xFF) << 8); )
 
@@ -169,7 +177,7 @@ UA_TYPE_ENCODEBINARY(UA_UInt16,
                      dst->data[(*offset)++] = (*src & 0xFF00) >> 8; )
 UA_TYPE_DECODEBINARY(UA_UInt16,
                      if(*offset + sizeof(UA_UInt16) > (UA_UInt32)src->length )
-                         retval = UA_STATUSCODE_BADDECODINGERROR;
+                         return UA_STATUSCODE_BADDECODINGERROR;
                      *dst =  (UA_UInt16)src->data[(*offset)++] << 0;
                      *dst |= (UA_UInt16)src->data[(*offset)++] << 8; )
 
@@ -182,7 +190,7 @@ UA_TYPE_ENCODEBINARY(UA_Int32,
                      dst->data[(*offset)++] = (*src & 0xFF000000) >> 24; )
 UA_TYPE_DECODEBINARY(UA_Int32,
                      if(*offset + sizeof(UA_Int32) > (UA_UInt32)src->length )
-                         retval = UA_STATUSCODE_BADDECODINGERROR;
+                         return UA_STATUSCODE_BADDECODINGERROR;
                      *dst  = (UA_Int32)(((UA_SByte)(src->data[(*offset)++]) & 0xFF) << 0);
                      *dst |= (UA_Int32)(((UA_SByte)(src->data[(*offset)++]) & 0xFF) << 8);
                      *dst |= (UA_Int32)(((UA_SByte)(src->data[(*offset)++]) & 0xFF) << 16);
@@ -193,7 +201,7 @@ UA_TYPE_CALCSIZEBINARY_SIZEOF(UA_UInt32)
 UA_TYPE_ENCODEBINARY(UA_UInt32, retval = UA_Int32_encodeBinary((UA_Int32 const *)src, dst, offset); )
 UA_TYPE_DECODEBINARY(UA_UInt32,
                      if(*offset + sizeof(UA_UInt32) > (UA_UInt32)src->length )
-                         retval = UA_STATUSCODE_BADDECODINGERROR;
+                         return UA_STATUSCODE_BADDECODINGERROR;
                      UA_UInt32 t1 = (UA_UInt32)((UA_Byte)(src->data[(*offset)++] & 0xFF));
                      UA_UInt32 t2 = (UA_UInt32)((UA_Byte)(src->data[(*offset)++]& 0xFF) << 8);
                      UA_UInt32 t3 = (UA_UInt32)((UA_Byte)(src->data[(*offset)++]& 0xFF) << 16);
@@ -213,7 +221,7 @@ UA_TYPE_ENCODEBINARY(UA_Int64,
                      dst->data[(*offset)++] = (*src & 0xFF00000000000000) >> 56; )
 UA_TYPE_DECODEBINARY(UA_Int64,
                      if(*offset + sizeof(UA_Int64) > (UA_UInt32)src->length )
-                         retval = UA_STATUSCODE_BADDECODINGERROR;
+                         return UA_STATUSCODE_BADDECODINGERROR;
                      *dst  = (UA_Int64)src->data[(*offset)++] << 0;
                      *dst |= (UA_Int64)src->data[(*offset)++] << 8;
                      *dst |= (UA_Int64)src->data[(*offset)++] << 16;
@@ -228,7 +236,7 @@ UA_TYPE_CALCSIZEBINARY_SIZEOF(UA_UInt64)
 UA_TYPE_ENCODEBINARY(UA_UInt64, return UA_Int64_encodeBinary((UA_Int64 const *)src, dst, offset); )
 UA_TYPE_DECODEBINARY(UA_UInt64,
                      if(*offset + sizeof(UA_UInt64) > (UA_UInt32)src->length )
-                         retval = UA_STATUSCODE_BADDECODINGERROR;
+                         return UA_STATUSCODE_BADDECODINGERROR;
                      UA_UInt64 t1 = (UA_UInt64)src->data[(*offset)++];
                      UA_UInt64 t2 = (UA_UInt64)src->data[(*offset)++] << 8;
                      UA_UInt64 t3 = (UA_UInt64)src->data[(*offset)++] << 16;
@@ -245,7 +253,7 @@ UA_TYPE_CALCSIZEBINARY_SIZEOF(UA_Float)
 UA_Byte UA_FLOAT_ZERO[] = { 0x00, 0x00, 0x00, 0x00 };
 UA_TYPE_DECODEBINARY(UA_Float,
                      if(*offset + sizeof(UA_Float) > (UA_UInt32)src->length )
-                         retval = UA_STATUSCODE_BADDECODINGERROR;
+                         return UA_STATUSCODE_BADDECODINGERROR;
                      UA_Float mantissa;
                      UA_UInt32 biasedExponent;
                      UA_Float sign;
@@ -271,7 +279,7 @@ UA_TYPE_CALCSIZEBINARY_SIZEOF(UA_Double)
 UA_Byte UA_DOUBLE_ZERO[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
 UA_TYPE_DECODEBINARY(UA_Double,
                      if(*offset + sizeof(UA_Double) > (UA_UInt32)src->length )
-                         retval = UA_STATUSCODE_BADDECODINGERROR;
+                         return UA_STATUSCODE_BADDECODINGERROR;
                      UA_Double sign;
                      UA_Double mantissa;
                      UA_UInt32 biasedExponent;
@@ -322,6 +330,7 @@ UA_StatusCode UA_String_encodeBinary(UA_String const *src, UA_ByteString *dst, U
 }
 
 UA_StatusCode UA_String_decodeBinary(UA_ByteString const *src, UA_UInt32 *offset, UA_String *dst) {
+    UA_String_init(dst);
     UA_Int32 length;
     if(UA_Int32_decodeBinary(src, offset, &length))
         return UA_STATUSCODE_BADINTERNALERROR;
@@ -470,6 +479,11 @@ UA_StatusCode UA_NodeId_decodeBinary(UA_ByteString const *src, UA_UInt32 *offset
     UA_Byte   encodingByte;
 
     UA_StatusCode retval = UA_Byte_decodeBinary(src, offset, &encodingByte); // will be cleaned up in the end if sth goes wrong
+    if(retval) {
+        UA_NodeId_init(dst);
+        return retval;
+    }
+    
     switch(encodingByte) {
     case UA_NODEIDTYPE_TWOBYTE: // Table 7
         dst->identifierType     = UA_NODEIDTYPE_NUMERIC;
@@ -511,6 +525,7 @@ UA_StatusCode UA_NodeId_decodeBinary(UA_ByteString const *src, UA_UInt32 *offset
         break;
 
     default:
+        UA_NodeId_init(dst);
         retval |= UA_STATUSCODE_BADINTERNALERROR; // the client sends an encodingByte we do not recognize
         break;
     }
@@ -550,6 +565,7 @@ UA_TYPE_ENCODEBINARY(UA_ExpandedNodeId,
                      )
 
 UA_StatusCode UA_ExpandedNodeId_decodeBinary(UA_ByteString const *src, UA_UInt32 *offset, UA_ExpandedNodeId *dst) {
+    UA_ExpandedNodeId_init(dst);
     // get encodingflags and leave a "clean" nodeidtype
     if((UA_Int32)*offset >= src->length)
         return UA_STATUSCODE_BADDECODINGERROR;
@@ -581,6 +597,7 @@ UA_UInt32 UA_QualifiedName_calcSizeBinary(UA_QualifiedName const *p) {
     return length;
 }
 UA_StatusCode UA_QualifiedName_decodeBinary(UA_ByteString const *src, UA_UInt32 *offset, UA_QualifiedName *dst) {
+    UA_QualifiedName_init(dst);
     UA_StatusCode retval = UA_UInt16_decodeBinary(src, offset, &dst->namespaceIndex);
     retval |= UA_String_decodeBinary(src, offset, &dst->name);
     if(retval)
@@ -617,6 +634,7 @@ UA_TYPE_ENCODEBINARY(UA_LocalizedText,
                          retval |= UA_String_encodeBinary(&src->text, dst, offset); )
 
 UA_StatusCode UA_LocalizedText_decodeBinary(UA_ByteString const *src, UA_UInt32 *offset, UA_LocalizedText *dst) {
+    UA_LocalizedText_init(dst);
     UA_Byte encodingMask = 0;
     UA_StatusCode retval = UA_Byte_decodeBinary(src, offset, &encodingMask);
     if(encodingMask & UA_LOCALIZEDTEXT_ENCODINGMASKTYPE_LOCALE)
@@ -670,11 +688,16 @@ UA_TYPE_ENCODEBINARY(UA_ExtensionObject,
                      )
 
 UA_StatusCode UA_ExtensionObject_decodeBinary(UA_ByteString const *src, UA_UInt32 *offset, UA_ExtensionObject *dst) {
+    UA_ExtensionObject_init(dst);
     UA_Byte encoding;
     UA_StatusCode retval = UA_NodeId_decodeBinary(src, offset, &dst->typeId);
     retval |= UA_Byte_decodeBinary(src, offset, &encoding);
     dst->encoding = encoding;
     retval |= UA_String_copy(&UA_STRING_NULL, (UA_String *)&dst->body);
+    if(retval) {
+        UA_ExtensionObject_init(dst);
+        return retval;
+    }
     switch(dst->encoding) {
     case UA_EXTENSIONOBJECT_ENCODINGMASK_NOBODYISENCODED:
         break;
@@ -695,8 +718,42 @@ UA_StatusCode UA_ExtensionObject_decodeBinary(UA_ByteString const *src, UA_UInt3
 
 /* DataValue */
 //TODO: place this define at the server configuration
+UA_UInt32 UA_DataValue_calcSizeBinary(UA_DataValue const *p) {
+    UA_UInt32 length = sizeof(UA_Byte);
+    if(p->encodingMask & UA_DATAVALUE_ENCODINGMASK_VARIANT)
+        length += UA_Variant_calcSizeBinary(&p->value);
+    if(p->encodingMask & UA_DATAVALUE_ENCODINGMASK_STATUSCODE)
+        length += sizeof(UA_UInt32);   //dataValue->status
+    if(p->encodingMask & UA_DATAVALUE_ENCODINGMASK_SOURCETIMESTAMP)
+        length += sizeof(UA_DateTime);  //dataValue->sourceTimestamp
+    if(p->encodingMask & UA_DATAVALUE_ENCODINGMASK_SOURCEPICOSECONDS)
+        length += sizeof(UA_Int64);    //dataValue->sourcePicoseconds
+    if(p->encodingMask & UA_DATAVALUE_ENCODINGMASK_SERVERTIMESTAMP)
+        length += sizeof(UA_DateTime);  //dataValue->serverTimestamp
+    if(p->encodingMask & UA_DATAVALUE_ENCODINGMASK_SERVERPICOSECONDS)
+        length += sizeof(UA_Int64);    //dataValue->serverPicoseconds
+    return length;
+}
+
+UA_TYPE_ENCODEBINARY(UA_DataValue,
+                     retval |= UA_Byte_encodeBinary(&src->encodingMask, dst, offset);
+                     if(src->encodingMask & UA_DATAVALUE_ENCODINGMASK_VARIANT)
+                         retval |= UA_Variant_encodeBinary(&src->value, dst, offset);
+                     if(src->encodingMask & UA_DATAVALUE_ENCODINGMASK_STATUSCODE)
+                         retval |= UA_StatusCode_encodeBinary(&src->status, dst, offset);
+                     if(src->encodingMask & UA_DATAVALUE_ENCODINGMASK_SOURCETIMESTAMP)
+                         retval |= UA_DateTime_encodeBinary(&src->sourceTimestamp, dst, offset);
+                     if(src->encodingMask & UA_DATAVALUE_ENCODINGMASK_SOURCEPICOSECONDS)
+                         retval |= UA_Int16_encodeBinary(&src->sourcePicoseconds, dst, offset);
+                     if(src->encodingMask & UA_DATAVALUE_ENCODINGMASK_SERVERTIMESTAMP)
+                         retval |= UA_DateTime_encodeBinary(&src->serverTimestamp, dst, offset);
+                     if(src->encodingMask & UA_DATAVALUE_ENCODINGMASK_SERVERPICOSECONDS)
+                         retval |= UA_Int16_encodeBinary(&src->serverPicoseconds, dst, offset);
+                     )
+
 #define MAX_PICO_SECONDS 1000
 UA_StatusCode UA_DataValue_decodeBinary(UA_ByteString const *src, UA_UInt32 *offset, UA_DataValue *dst) {
+    UA_DataValue_init(dst);
     UA_StatusCode retval = UA_Byte_decodeBinary(src, offset, &dst->encodingMask);
     if(dst->encodingMask & UA_DATAVALUE_ENCODINGMASK_VARIANT)
         retval |= UA_Variant_decodeBinary(src, offset, &dst->value);
@@ -721,39 +778,6 @@ UA_StatusCode UA_DataValue_decodeBinary(UA_ByteString const *src, UA_UInt32 *off
     return retval;
 }
 
-UA_TYPE_ENCODEBINARY(UA_DataValue,
-                     retval |= UA_Byte_encodeBinary(&src->encodingMask, dst, offset);
-                     if(src->encodingMask & UA_DATAVALUE_ENCODINGMASK_VARIANT)
-                         retval |= UA_Variant_encodeBinary(&src->value, dst, offset);
-                     if(src->encodingMask & UA_DATAVALUE_ENCODINGMASK_STATUSCODE)
-                         retval |= UA_StatusCode_encodeBinary(&src->status, dst, offset);
-                     if(src->encodingMask & UA_DATAVALUE_ENCODINGMASK_SOURCETIMESTAMP)
-                         retval |= UA_DateTime_encodeBinary(&src->sourceTimestamp, dst, offset);
-                     if(src->encodingMask & UA_DATAVALUE_ENCODINGMASK_SOURCEPICOSECONDS)
-                         retval |= UA_Int16_encodeBinary(&src->sourcePicoseconds, dst, offset);
-                     if(src->encodingMask & UA_DATAVALUE_ENCODINGMASK_SERVERTIMESTAMP)
-                         retval |= UA_DateTime_encodeBinary(&src->serverTimestamp, dst, offset);
-                     if(src->encodingMask & UA_DATAVALUE_ENCODINGMASK_SERVERPICOSECONDS)
-                         retval |= UA_Int16_encodeBinary(&src->serverPicoseconds, dst, offset);
-                     )
-
-UA_UInt32 UA_DataValue_calcSizeBinary(UA_DataValue const *p) {
-    UA_UInt32 length = sizeof(UA_Byte);
-    if(p->encodingMask & UA_DATAVALUE_ENCODINGMASK_VARIANT)
-        length += UA_Variant_calcSizeBinary(&p->value);
-    if(p->encodingMask & UA_DATAVALUE_ENCODINGMASK_STATUSCODE)
-        length += sizeof(UA_UInt32);   //dataValue->status
-    if(p->encodingMask & UA_DATAVALUE_ENCODINGMASK_SOURCETIMESTAMP)
-        length += sizeof(UA_DateTime);  //dataValue->sourceTimestamp
-    if(p->encodingMask & UA_DATAVALUE_ENCODINGMASK_SOURCEPICOSECONDS)
-        length += sizeof(UA_Int64);    //dataValue->sourcePicoseconds
-    if(p->encodingMask & UA_DATAVALUE_ENCODINGMASK_SERVERTIMESTAMP)
-        length += sizeof(UA_DateTime);  //dataValue->serverTimestamp
-    if(p->encodingMask & UA_DATAVALUE_ENCODINGMASK_SERVERPICOSECONDS)
-        length += sizeof(UA_Int64);    //dataValue->serverPicoseconds
-    return length;
-}
-
 /* Variant */
 /* We can store all data types in a variant internally. But for communication we
  * encode them in an ExtensionObject if they are not one of the built in types.
@@ -867,6 +891,7 @@ UA_TYPE_ENCODEBINARY(UA_Variant,
 
 /* For decoding, we read extensionobjects as is. The resulting variant always has the storagetype UA_VARIANT_DATA. */
 UA_StatusCode UA_Variant_decodeBinary(UA_ByteString const *src, UA_UInt32 *offset, UA_Variant *dst) {
+    UA_Variant_init(dst);
     UA_Byte encodingByte;
     UA_StatusCode retval = UA_Byte_decodeBinary(src, offset, &encodingByte);
     if(retval)
@@ -933,7 +958,29 @@ UA_UInt32 UA_DiagnosticInfo_calcSizeBinary(UA_DiagnosticInfo const *ptr) {
     return length;
 }
 
+UA_TYPE_ENCODEBINARY(UA_DiagnosticInfo,
+                     retval |= UA_Byte_encodeBinary(&src->encodingMask, dst, offset);
+                     if(!retval && !src->encodingMask)
+                         return retval;
+
+                     if(src->encodingMask & UA_DIAGNOSTICINFO_ENCODINGMASK_SYMBOLICID)
+                        retval |= UA_Int32_encodeBinary(&src->symbolicId, dst, offset);
+                     if(src->encodingMask & UA_DIAGNOSTICINFO_ENCODINGMASK_NAMESPACE)
+                         retval |= UA_Int32_encodeBinary( &src->namespaceUri, dst, offset);
+                     if(src->encodingMask & UA_DIAGNOSTICINFO_ENCODINGMASK_LOCALIZEDTEXT)
+                         retval |= UA_Int32_encodeBinary(&src->localizedText, dst, offset);
+                     if(src->encodingMask & UA_DIAGNOSTICINFO_ENCODINGMASK_LOCALE)
+                         retval |= UA_Int32_encodeBinary(&src->locale, dst, offset);
+                     if(src->encodingMask & UA_DIAGNOSTICINFO_ENCODINGMASK_ADDITIONALINFO)
+                         retval |= UA_String_encodeBinary(&src->additionalInfo, dst, offset);
+                     if(src->encodingMask & UA_DIAGNOSTICINFO_ENCODINGMASK_INNERSTATUSCODE)
+                         retval |= UA_StatusCode_encodeBinary(&src->innerStatusCode, dst, offset);
+                     if(src->encodingMask & UA_DIAGNOSTICINFO_ENCODINGMASK_INNERDIAGNOSTICINFO)
+                         retval |= UA_DiagnosticInfo_encodeBinary(src->innerDiagnosticInfo, dst, offset);
+                     )
+
 UA_StatusCode UA_DiagnosticInfo_decodeBinary(UA_ByteString const *src, UA_UInt32 *offset, UA_DiagnosticInfo *dst) {
+    UA_DiagnosticInfo_init(dst);
     UA_StatusCode retval = UA_Byte_decodeBinary(src, offset, &dst->encodingMask);
     if(!retval && !dst->encodingMask) // in most cases, the DiagnosticInfo is empty
         return retval;
@@ -951,37 +998,21 @@ UA_StatusCode UA_DiagnosticInfo_decodeBinary(UA_ByteString const *src, UA_UInt32
         retval |= UA_StatusCode_decodeBinary(src, offset, &dst->innerStatusCode);
     if(dst->encodingMask & UA_DIAGNOSTICINFO_ENCODINGMASK_INNERDIAGNOSTICINFO) {
         // innerDiagnosticInfo is a pointer to struct, therefore allocate
-        if(!(dst->innerDiagnosticInfo = UA_alloc(sizeof(UA_DiagnosticInfo)))) {
-            retval |= UA_STATUSCODE_BADOUTOFMEMORY;
-        } else {
-            if(UA_DiagnosticInfo_decodeBinary(src, offset, dst->innerDiagnosticInfo))
+        if((dst->innerDiagnosticInfo = UA_alloc(sizeof(UA_DiagnosticInfo)))) {
+            if(UA_DiagnosticInfo_decodeBinary(src, offset, dst->innerDiagnosticInfo) != UA_STATUSCODE_GOOD) {
                 UA_free(dst->innerDiagnosticInfo);
+                dst->innerDiagnosticInfo = UA_NULL;
+                retval |= UA_STATUSCODE_BADINTERNALERROR;
+            }
+        } else {
+            retval |= UA_STATUSCODE_BADOUTOFMEMORY;
         }
     }
+    if(retval)
+        UA_DiagnosticInfo_deleteMembers(dst);
     return retval;
 }
 
-UA_TYPE_ENCODEBINARY(UA_DiagnosticInfo,
-                     retval |= UA_Byte_encodeBinary(&src->encodingMask, dst, offset);
-                     if(!retval && !src->encodingMask)
-                         return retval;
-
-                     if(src->encodingMask & UA_DIAGNOSTICINFO_ENCODINGMASK_SYMBOLICID)
-                        retval |= UA_Int32_encodeBinary(&src->symbolicId, dst, offset);
-                     if(src->encodingMask & UA_DIAGNOSTICINFO_ENCODINGMASK_NAMESPACE)
-                         retval |= UA_Int32_encodeBinary( &src->namespaceUri, dst, offset);
-                     if(src->encodingMask & UA_DIAGNOSTICINFO_ENCODINGMASK_LOCALIZEDTEXT)
-                         retval |= UA_Int32_encodeBinary(&src->localizedText, dst, offset);
-                     if(src->encodingMask & UA_DIAGNOSTICINFO_ENCODINGMASK_LOCALE)
-                         retval |= UA_Int32_encodeBinary(&src->locale, dst, offset);
-                     if(src->encodingMask & UA_DIAGNOSTICINFO_ENCODINGMASK_ADDITIONALINFO)
-                         retval |= UA_String_encodeBinary(&src->additionalInfo, dst, offset);
-                     if(src->encodingMask & UA_DIAGNOSTICINFO_ENCODINGMASK_INNERSTATUSCODE)
-                         retval |= UA_StatusCode_encodeBinary(&src->innerStatusCode, dst, offset);
-                     if(src->encodingMask & UA_DIAGNOSTICINFO_ENCODINGMASK_INNERDIAGNOSTICINFO)
-                         retval |= UA_DiagnosticInfo_encodeBinary(src->innerDiagnosticInfo, dst, offset);
-                     )
-
 /* InvalidType */
 UA_UInt32 UA_InvalidType_calcSizeBinary(UA_InvalidType const *p) {
     return 0;

src/ua_types_encoding_binary.h

@@ -21,9 +21,9 @@
  *   inconsistent state.
  *
  * - Decode: Decodes a variable stored in a bytestring. The destination is
- *   assumed to be clean (after an _init) before decoding into it. If an error
- *   occurs (indicated by the return value), the destination value is cleaned
- *   up (deleteMembers) before returning.
+ *   cleaned up (init) before decoding into it. If an error occurs (indicated by
+ *   the return value), the destination is cleaned up (deleteMembers, but no
+ *   init) before returning.
  */
 
 /**

tests/check_builtin.c

@@ -1345,17 +1345,6 @@ START_TEST(UA_QualifiedName_copyShallWorkOnInputExample) {
 	ck_assert_int_eq(5, dst.namespaceIndex);
 }
 END_TEST
-START_TEST(UA_QualifiedName_copyNULLInput) {
-	// given
-	UA_QualifiedName *src = UA_NULL;
-	UA_QualifiedName dst;
-
-	// when
-	UA_StatusCode ret = UA_QualifiedName_copy(src, &dst);
-	// then
-	ck_assert_int_eq(ret, UA_STATUSCODE_BADINTERNALERROR);
-}
-END_TEST
 START_TEST(UA_Guid_copyShallWorkOnInputExample) {
 	//given
 	const UA_Guid src = {3, 45, 1222, {8, 7, 6, 5, 4, 3, 2, 1}};
@@ -1388,19 +1377,6 @@ START_TEST(UA_LocalizedText_copycstringShallWorkOnInputExample) {
 	ck_assert_int_eq(7, dst.text.length);
 }
 END_TEST
-START_TEST(UA_LocalizedText_copycstringNULLInput) {
-	// given
-	const char src[7] = {'t', 'e', 'X', 't', '1', '2', '3'};
-
-	UA_LocalizedText *dst = UA_NULL;
-	UA_Int32 ret;
-
-	// when
-	ret = UA_LocalizedText_copycstring(src, dst);
-	// then
-	ck_assert_int_eq(ret, UA_STATUSCODE_BADINTERNALERROR);
-}
-END_TEST
 START_TEST(UA_DataValue_copyShallWorkOnInputExample) {
 	// given
 	UA_Variant srcVariant;
@@ -1646,10 +1622,8 @@ Suite *testSuite_builtin(void) {
 	tcase_add_test(tc_copy, UA_DiagnosticInfo_copyShallWorkOnExample);
 	tcase_add_test(tc_copy, UA_ApplicationDescription_copyShallWorkOnExample);
 	tcase_add_test(tc_copy, UA_QualifiedName_copyShallWorkOnInputExample);
-	tcase_add_test(tc_copy, UA_QualifiedName_copyNULLInput);
 	tcase_add_test(tc_copy, UA_Guid_copyShallWorkOnInputExample);
 	tcase_add_test(tc_copy, UA_LocalizedText_copycstringShallWorkOnInputExample);
-	tcase_add_test(tc_copy, UA_LocalizedText_copycstringNULLInput);
 	tcase_add_test(tc_copy, UA_DataValue_copyShallWorkOnInputExample);
 	suite_add_tcase(s, tc_copy);
 	return s;
@@ -1663,7 +1637,7 @@ int main(void) {
 
 	s  = testSuite_builtin();
 	sr = srunner_create(s);
-	//srunner_set_fork_status(sr, CK_NOFORK);
+	// srunner_set_fork_status(sr, CK_NOFORK);
 	srunner_run_all(sr, CK_NORMAL);
 	number_failed += srunner_ntests_failed(sr);
 	srunner_free(sr);

tests/check_memory.c

@@ -18,7 +18,7 @@ START_TEST(newAndEmptyObjectShallBeDeleted) {
 #endif
 	UA_[_i].delete(obj);
 	// then
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 }
 END_TEST
 
@@ -32,7 +32,7 @@ START_TEST(arrayCopyShallMakeADeepCopy) {
 	UA_String *a2;
 	UA_Int32   retval = UA_Array_copy((const void *)a1, 3, &UA_[UA_STRING], (void **)&a2);
 	// then
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	ck_assert_int_eq(a1[0].length, 1);
 	ck_assert_int_eq(a1[1].length, 2);
 	ck_assert_int_eq(a1[2].length, 3);
@@ -59,7 +59,7 @@ START_TEST(encodeShallYieldDecode) {
 	retval = UA_[_i].new(&obj1);
 	UA_ByteString_newMembers(&msg1, UA_[_i].encodings[UA_ENCODING_BINARY].calcSize(obj1));
 	retval |= UA_[_i].encodings[UA_ENCODING_BINARY].encode(obj1, &msg1, &pos);
-	if(retval != UA_SUCCESS) {
+	if(retval != UA_STATUSCODE_GOOD) {
 		// this happens, e.g. when we encode a variant (with UA_[UA_INVALIDTYPE] in the vtable)
 		UA_[_i].delete(obj1);
 		UA_ByteString_deleteMembers(&msg1);
@@ -69,11 +69,11 @@ START_TEST(encodeShallYieldDecode) {
 	// when
 	UA_[_i].new(&obj2);
 	pos = 0; retval = UA_[_i].encodings[UA_ENCODING_BINARY].decode(&msg1, &pos, obj2);
-	ck_assert_msg(retval == UA_SUCCESS, "messages differ idx=%d,name=%s", _i, UA_[_i].name);
+	ck_assert_msg(retval == UA_STATUSCODE_GOOD, "messages differ idx=%d,name=%s", _i, UA_[_i].name);
 	retval = UA_ByteString_newMembers(&msg2, UA_[_i].encodings[UA_ENCODING_BINARY].calcSize(obj2));
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	pos = 0; retval = UA_[_i].encodings[UA_ENCODING_BINARY].encode(obj2, &msg2, &pos);
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 
 	// then
 	ck_assert_msg(UA_ByteString_equal(&msg1, &msg2) == 0, "messages differ idx=%d,name=%s", _i, UA_[_i].name);
@@ -109,11 +109,13 @@ START_TEST(decodeShallFailWithTruncatedBufferButSurvive) {
 }
 END_TEST
 
+#define RANDOM_TESTS 1000
+
 START_TEST(decodeScalarBasicTypeFromRandomBufferShallSucceed) {
 	// given
 	void *obj1 = UA_NULL;
 	UA_ByteString msg1;
-	UA_Int32 retval = UA_SUCCESS;
+	UA_Int32 retval = UA_STATUSCODE_GOOD;
 	UA_Int32 buflen = 256;
 	UA_ByteString_newMembers(&msg1, buflen); // fixed size
 #ifdef WIN32
@@ -121,7 +123,7 @@ START_TEST(decodeScalarBasicTypeFromRandomBufferShallSucceed) {
 #else
 	srandom(42);
 #endif
-	for(int n = 0;n < 100;n++) {
+	for(int n = 0;n < RANDOM_TESTS;n++) {
 		for(UA_Int32 i = 0;i < buflen;i++) {
 #ifdef WIN32
 			UA_UInt32 rnd;
@@ -135,7 +137,7 @@ START_TEST(decodeScalarBasicTypeFromRandomBufferShallSucceed) {
 		retval |= UA_[_i].new(&obj1);
 		retval |= UA_[_i].encodings[0].decode(&msg1, &pos, obj1);
 		//then
-		ck_assert_msg(retval == UA_SUCCESS, "Decoding %s from random buffer", UA_[_i].name);
+		ck_assert_msg(retval == UA_STATUSCODE_GOOD, "Decoding %s from random buffer", UA_[_i].name);
 		// finally
 		UA_[_i].delete(obj1);
 	}
@@ -147,7 +149,7 @@ START_TEST(decodeComplexTypeFromRandomBufferShallSurvive) {
 	// given
 	void    *obj1 = UA_NULL;
 	UA_ByteString msg1;
-	UA_Int32 retval = UA_SUCCESS;
+	UA_Int32 retval = UA_STATUSCODE_GOOD;
 	UA_Int32 buflen = 256;
 	UA_ByteString_newMembers(&msg1, buflen); // fixed size
 #ifdef WIN32
@@ -156,7 +158,7 @@ START_TEST(decodeComplexTypeFromRandomBufferShallSurvive) {
 	srandom(42);
 #endif
 	// when
-	for(int n = 0;n < 100;n++) {
+	for(int n = 0;n < RANDOM_TESTS;n++) {
 		for(UA_Int32 i = 0;i < buflen;i++){
 #ifdef WIN32
 			UA_UInt32 rnd;
@@ -169,10 +171,6 @@ START_TEST(decodeComplexTypeFromRandomBufferShallSurvive) {
 		UA_UInt32 pos = 0;
 		retval |= UA_[_i].new(&obj1);
 		retval |= UA_[_i].encodings[0].decode(&msg1, &pos, obj1);
-
-		//this is allowed to fail and return UA_ERROR
-		//ck_assert_msg(retval == UA_SUCCESS, "Decoding %s from random buffer", UA_[_i].name);
-		
 		UA_[_i].delete(obj1);
 	}
 
@@ -203,7 +201,7 @@ int main() {
 
 	sr = srunner_create(s);
 	//for debugging puposes only, will break make check
-	//srunner_set_fork_status(sr, CK_NOFORK);
+	srunner_set_fork_status(sr, CK_NOFORK);
 	srunner_run_all (sr, CK_NORMAL);
 	number_failed += srunner_ntests_failed(sr);
 	srunner_free(sr);

tests/check_nodestore.c

@@ -36,7 +36,7 @@ UA_Int32 createNode(UA_Node** p, UA_Int16 nsid, UA_Int32 id) {
 	(*p)->nodeId.namespaceIndex = nsid;
 	(*p)->nodeId.identifier.numeric = id;
 	(*p)->nodeClass = UA_NODECLASS_VARIABLE;
-	return UA_SUCCESS;
+	return UA_STATUSCODE_GOOD;
 }
 
 START_TEST(findNodeInUA_NodeStoreWithSingleEntry) {
@@ -53,7 +53,7 @@ START_TEST(findNodeInUA_NodeStoreWithSingleEntry) {
 	// when
 	retval = UA_NodeStore_get(ns,&n1->nodeId,&nr);
 	// then
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	ck_assert_ptr_eq(nr,n1);
 	// finally
 	UA_NodeStore_releaseManagedNode(n1);
@@ -81,7 +81,7 @@ START_TEST(failToFindNodeInOtherUA_NodeStore) {
 	UA_Node* n; createNode(&n,1,2255);
 	UA_Int32 retval = UA_NodeStore_get(ns,&n->nodeId, &nr);
 	// then
-	ck_assert_int_ne(retval, UA_SUCCESS);
+	ck_assert_int_ne(retval, UA_STATUSCODE_GOOD);
 	// finally
 	UA_Node_delete(n);
 	UA_NodeStore_releaseManagedNode(nr);
@@ -111,7 +111,7 @@ START_TEST(findNodeInUA_NodeStoreWithSeveralEntries) {
 	// when
 	retval = UA_NodeStore_get(ns,&(n3->nodeId),&nr);
 	// then
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	ck_assert_ptr_eq(nr,n3);
 	// finally
 	UA_NodeStore_releaseManagedNode(n3);
@@ -137,13 +137,11 @@ START_TEST(iterateOverUA_NodeStoreShallNotVisitEmptyNodes) {
 	UA_Node* n5; createNode(&n5,0,1); UA_NodeStore_insert(ns, &n5, 0);
 	UA_Node* n6; createNode(&n6,0,12); UA_NodeStore_insert(ns, &n6, 0);
 
-	UA_Int32 retval;
 	// when
 	zeroCnt = 0;
 	visitCnt = 0;
-	retval = UA_NodeStore_iterate(ns,checkZeroVisitor);
+	UA_NodeStore_iterate(ns,checkZeroVisitor);
 	// then
-	ck_assert_int_eq(retval, UA_SUCCESS);
 	ck_assert_int_eq(zeroCnt, 0);
 	ck_assert_int_eq(visitCnt, 6);
 	// finally
@@ -172,7 +170,7 @@ START_TEST(findNodeInExpandedNamespace) {
 	createNode(&n,0,25);
 	retval = UA_NodeStore_get(ns,&(n->nodeId),&nr);
 	// then
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	ck_assert_int_eq(nr->nodeId.identifier.numeric,n->nodeId.identifier.numeric);
 	// finally
 	UA_free((void*)n);
@@ -197,12 +195,10 @@ START_TEST(iterateOverExpandedNamespaceShallNotVisitEmptyNodes) {
 		createNode(&n,0,i); UA_NodeStore_insert(ns, &n, 0);
 	}
 	// when
-	UA_Int32 retval;
 	zeroCnt = 0;
 	visitCnt = 0;
-	retval = UA_NodeStore_iterate(ns,checkZeroVisitor);
+	UA_NodeStore_iterate(ns,checkZeroVisitor);
 	// then
-	ck_assert_int_eq(retval, UA_SUCCESS);
 	ck_assert_int_eq(zeroCnt, 0);
 	ck_assert_int_eq(visitCnt, 200);
 	// finally
@@ -232,7 +228,7 @@ START_TEST(failToFindNonExistantNodeInUA_NodeStoreWithSeveralEntries) {
 	// when
 	retval = UA_NodeStore_get(ns, &(n6->nodeId), &nr);
 	// then
-	ck_assert_int_ne(retval, UA_SUCCESS);
+	ck_assert_int_ne(retval, UA_STATUSCODE_GOOD);
 	// finally
 	UA_free((void *)n6);
 	UA_NodeStore_delete(ns);

tools/generate_builtin.py

@@ -189,7 +189,8 @@ def createStructured(element):
 
     # 6) DecodeBinary
     printc('''UA_StatusCode %(name)s_decodeBinary(UA_ByteString const * src, UA_UInt32 *offset, %(name)s * dst) {
-    UA_StatusCode retval = UA_STATUSCODE_GOOD;''')
+    UA_StatusCode retval = UA_STATUSCODE_GOOD;
+    %(name)s_init(dst);''')
     printc('\t'+name+'_init(dst);')
     for n,t in membermap.iteritems():
         if t.find("*") != -1:
@@ -217,11 +218,10 @@ UA_TYPE_METHOD_DECODEXML_NOTIMPL(%(name)s)''')
     for n,t in membermap.iteritems():
         if not t in fixed_size: # dynamic size on the wire
             if t.find("*") != -1:
-		printc("\tUA_Array_delete((void*)p->%(n)s,p->%(n)sSize,&UA_[" +
-                       t[0:t.find("*")].upper()+"]);")
+		printc("\tUA_Array_delete((void*)p->%(n)s,p->%(n)sSize,&UA_["+t[0:t.find("*")].upper()+"]);")
             else:
 		printc('\t%(t)s_deleteMembers(&p->%(n)s);')
-    printc("\n}\n")
+    printc("}\n")
 
     # 10) Init
     printc('''void %(name)s_init(%(name)s *p) {
@@ -232,7 +232,7 @@ UA_TYPE_METHOD_DECODEXML_NOTIMPL(%(name)s)''')
             printc('\tp->%(n)s = UA_NULL;')
         else:
             printc('\t%(t)s_init(&p->%(n)s);')
-    printc("\n}\n")
+    printc("}\n")
 
     # 11) New
     printc("UA_TYPE_NEW_DEFAULT(%(name)s)")
@@ -250,10 +250,8 @@ UA_TYPE_METHOD_DECODEXML_NOTIMPL(%(name)s)''')
             printc('\tretval |= %(t)s_copy(&src->%(n)s,&dst->%(n)s);')
             continue
         printc("\tdst->%(n)s = src->%(n)s;")
-    printc('''if(retval) {
-    %(name)s_deleteMembers(dst);
-    %(name)s_init(dst);
-    }''')
+    printc('''\tif(retval)
+    \t%(name)s_deleteMembers(dst);''')
     printc("\treturn retval;\n}\n")
 
     # 13) Print