Merge pull request #132 from acplt/statuscode

Closing #131 with the pull.

CMakeLists.txt

@@ -6,7 +6,7 @@ set(open62541_VERSION_MAJOR 0)
 set(open62541_VERSION_MINOR 1)
 
 set(CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake")
-set(CMAKE_C_FLAGS_DEBUG "-g -DDEBUG")
+set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -DDEBUG")
 
 # main sources of libopen62541
 include_directories("${CMAKE_CURRENT_SOURCE_DIR}/include")

examples/networklayer_tcp.c

@@ -51,22 +51,21 @@ typedef struct TCPConnectionHandle {
 	NetworklayerTCP *layer;
 } TCPConnectionHandle;
 
-UA_Int32 NetworklayerTCP_new(NetworklayerTCP **newlayer, UA_ConnectionConfig localConf,
-							 UA_UInt32 port) {
-    if(!newlayer) return UA_ERROR;
+UA_StatusCode NetworklayerTCP_new(NetworklayerTCP **newlayer, UA_ConnectionConfig localConf,
+                                  UA_UInt32 port) {
     *newlayer = malloc(sizeof(NetworklayerTCP));
     if(*newlayer == UA_NULL)
-        return UA_ERROR;
+        return UA_STATUSCODE_BADOUTOFMEMORY;
 	(*newlayer)->localConf = localConf;
 	(*newlayer)->port = port;
 	(*newlayer)->connectionsSize = 0;
 	(*newlayer)->connections = UA_NULL;
-	return UA_SUCCESS;
+	return UA_STATUSCODE_GOOD;
 }
 
 // copy the array of connections, but _loose_ one. This does not close the
 // actual socket.
-UA_Int32 NetworklayerTCP_remove(NetworklayerTCP *layer, UA_Int32 sockfd) {
+static UA_StatusCode NetworklayerTCP_remove(NetworklayerTCP *layer, UA_Int32 sockfd) {
 	UA_UInt32 index;
 	for(index = 0;index < layer->connectionsSize;index++) {
 		if(layer->connections[index].sockfd == sockfd)
@@ -74,7 +73,7 @@ UA_Int32 NetworklayerTCP_remove(NetworklayerTCP *layer, UA_Int32 sockfd) {
 	}
 
     if(index == layer->connectionsSize)
-        return UA_ERROR;
+        return UA_STATUSCODE_BADINTERNALERROR;
 
     if(layer->connections[index].connection.channel)
         layer->connections[index].connection.channel->connection = UA_NULL;
@@ -89,7 +88,7 @@ UA_Int32 NetworklayerTCP_remove(NetworklayerTCP *layer, UA_Int32 sockfd) {
            sizeof(TCPConnection) * (layer->connectionsSize - index));
     free(layer->connections);
 	layer->connections = newconnections;
-	return UA_SUCCESS;
+	return UA_STATUSCODE_GOOD;
 }
 
 void NetworklayerTCP_delete(NetworklayerTCP *layer) {
@@ -112,7 +111,7 @@ void closeCallback(TCPConnectionHandle *handle) {
 }
 
 /** Callback function */
-UA_Int32 writeCallback(TCPConnectionHandle *handle, UA_ByteStringArray gather_buf) {
+void writeCallback(TCPConnectionHandle *handle, UA_ByteStringArray gather_buf) {
 	UA_UInt32 total_len = 0;
 	UA_UInt32 nWritten = 0;
 #ifdef WIN32
@@ -161,10 +160,9 @@ UA_Int32 writeCallback(TCPConnectionHandle *handle, UA_ByteStringArray gather_bu
 #endif
     for(UA_UInt32 i=0;i<gather_buf.stringsSize;i++)
         free(gather_buf.strings[i].data);
-	return UA_SUCCESS;
 }
 
-UA_Int32 NetworklayerTCP_add(NetworklayerTCP *layer, UA_Int32 newsockfd) {
+static UA_StatusCode NetworklayerTCP_add(NetworklayerTCP *layer, UA_Int32 newsockfd) {
     layer->connectionsSize++;
 	layer->connections = realloc(layer->connections, sizeof(TCPConnection) * layer->connectionsSize);
 	TCPConnection *newconnection = &layer->connections[layer->connectionsSize-1];
@@ -172,34 +170,36 @@ UA_Int32 NetworklayerTCP_add(NetworklayerTCP *layer, UA_Int32 newsockfd) {
 
 	struct TCPConnectionHandle *callbackhandle;
     callbackhandle = malloc(sizeof(struct TCPConnectionHandle));
-	callbackhandle->layer = layer;
+    if(!callbackhandle)
+        return UA_STATUSCODE_BADOUTOFMEMORY;
+    callbackhandle->layer = layer;
 	callbackhandle->sockfd = newsockfd;
 	UA_Connection_init(&newconnection->connection, layer->localConf, callbackhandle,
 					   (UA_Connection_closeCallback)closeCallback, (UA_Connection_writeCallback)writeCallback);
-	return UA_SUCCESS;
+	return UA_STATUSCODE_GOOD;
 }
 
-UA_Int32 setNonBlocking(int sockid) {
+static UA_StatusCode setNonBlocking(int sockid) {
 #ifdef WIN32
 	u_long iMode = 1;
 	int opts = IOCTLSOCKET(sockid, FIONBIO, &iMode);
 	if (opts != NO_ERROR){
 		printf("ioctlsocket failed with error: %ld\n", opts);
-		return - 1;
+		return UA_STATUSCODE_BADINTERNALERROR;
 	}
-	return 0;
+	return UA_STATUSCODE_GOOD;
 #else
 	int opts = fcntl(sockid,F_GETFL);
 	if (opts < 0) {
 		perror("fcntl(F_GETFL)");
-		return -1;
+		return UA_STATUSCODE_BADINTERNALERROR;
 	}
 	opts = (opts | O_NONBLOCK);
 	if (fcntl(sockid,F_SETFL,opts) < 0) {
 		perror("fcntl(F_SETFL)");
-		return -1;
+		return UA_STATUSCODE_BADINTERNALERROR;
 	}
-	return 0;
+	return UA_STATUSCODE_GOOD;
 #endif
 }
 
@@ -260,8 +260,8 @@ void setFDSet(NetworklayerTCP *layer) {
     layer->highestfd++;
 }
 
-UA_Int32 NetworkLayerTCP_run(NetworklayerTCP *layer, UA_Server *server, struct timeval tv,
-                             void(*worker)(UA_Server*), UA_Boolean *running) {
+UA_StatusCode NetworkLayerTCP_run(NetworklayerTCP *layer, UA_Server *server, struct timeval tv,
+                                  void(*worker)(UA_Server*), UA_Boolean *running) {
 #ifdef WIN32
 	WORD wVersionRequested;
 	WSADATA wsaData;
@@ -269,12 +269,12 @@ UA_Int32 NetworkLayerTCP_run(NetworklayerTCP *layer, UA_Server *server, struct t
 	WSAStartup(wVersionRequested, &wsaData);
 	if((layer->serversockfd = socket(PF_INET, SOCK_STREAM,0)) == INVALID_SOCKET) {
 		printf("ERROR opening socket, code: %d\n", WSAGetLastError());
-		return UA_ERROR;
+		return UA_STATUSCODE_BADINTERNALERROR;
 	}
 #else
     if((layer->serversockfd = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
 		perror("ERROR opening socket");
-		return UA_ERROR;
+		return UA_STATUSCODE_BADINTERNALERROR;
 	} 
 #endif
 	struct sockaddr_in serv_addr;
@@ -287,13 +287,13 @@ UA_Int32 NetworkLayerTCP_run(NetworklayerTCP *layer, UA_Server *server, struct t
 	if(setsockopt(layer->serversockfd, SOL_SOCKET, SO_REUSEADDR, (const char *)&optval, sizeof(optval)) == -1) {
 		perror("setsockopt");
 		CLOSESOCKET(layer->serversockfd);
-		return UA_ERROR;
+		return UA_STATUSCODE_BADINTERNALERROR;
 	}
 		
 	if(bind(layer->serversockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0) {
 		perror("binding");
 		CLOSESOCKET(layer->serversockfd);
-		return UA_ERROR;
+		return UA_STATUSCODE_BADINTERNALERROR;
 	}
 
 #define MAXBACKLOG 10
@@ -337,5 +337,5 @@ UA_Int32 NetworkLayerTCP_run(NetworklayerTCP *layer, UA_Server *server, struct t
 #ifdef WIN32
 	WSACleanup();
 #endif
-	return UA_SUCCESS;
+	return UA_STATUSCODE_GOOD;
 }

examples/networklayer_tcp.h

@@ -24,10 +24,9 @@ typedef struct NetworklayerTCP NetworklayerTCP;
 #define BINARYCONNECTION_MAX_CHUNK_COUNT 1
 #define BINARYCONNECTION_MAX_MESSAGE_SIZE 8192
 
-UA_Int32 NetworklayerTCP_new(NetworklayerTCP **newlayer, UA_ConnectionConfig localConf,
-							 UA_UInt32 port);
+UA_StatusCode NetworklayerTCP_new(NetworklayerTCP **newlayer, UA_ConnectionConfig localConf, UA_UInt32 port);
 void NetworklayerTCP_delete(NetworklayerTCP *layer);
-UA_Int32 NetworkLayerTCP_run(NetworklayerTCP *layer, UA_Server *server, struct timeval tv,
-							   void(*worker)(UA_Server*), UA_Boolean *running);
+UA_StatusCode NetworkLayerTCP_run(NetworklayerTCP *layer, UA_Server *server, struct timeval tv,
+                                  void(*worker)(UA_Server*), UA_Boolean *running);
 
 #endif /* NETWORKLAYERTCP_H_ */

examples/opcuaClient.c

@@ -9,6 +9,7 @@
 #include <stdlib.h> // pulls in declaration of malloc, free
 #include "ua_transport_generated.h"
 #include "ua_namespace_0.h"
+#include "ua_util.h"
 
 UA_Int32 sendHello(UA_Int32 sock, UA_String *endpointURL) {
 	UA_ByteString *message;

examples/opcuaServer.c

@@ -16,10 +16,10 @@
 #include "logger_stdout.h"
 #include "networklayer_tcp.h"
 
-UA_Boolean running = UA_TRUE;
+UA_Boolean running = 1;
 
 void stopHandler(int sign) {
-	running = UA_FALSE;
+	running = 0;
 }
 
 void serverCallback(UA_Server *server) {
@@ -28,7 +28,7 @@ void serverCallback(UA_Server *server) {
 
 UA_ByteString loadCertificate() {
     UA_ByteString certificate = UA_STRING_NULL;
-	FILE *fp = UA_NULL;
+	FILE *fp = NULL;
 	//FIXME: a potiential bug of locating the certificate, we need to get the path from the server's config
 	fp=fopen("localhost.der", "rb");
 
@@ -99,5 +99,5 @@ int main(int argc, char** argv) {
 	UA_Server_deleteMembers(&server);
 	NetworklayerTCP_delete(nl);
     UA_String_deleteMembers(&endpointUrl);
-	return retval == UA_SUCCESS ? 0 : retval;
+	return retval == UA_STATUSCODE_GOOD ? 0 : retval;
 }

include/ua_connection.h

@@ -64,9 +64,9 @@ typedef struct UA_Connection {
     UA_Connection_closeCallback close;
 } UA_Connection;
 
-UA_Int32 UA_EXPORT UA_Connection_init(UA_Connection *connection, UA_ConnectionConfig localConf, void *callbackHandle,
+UA_StatusCode UA_EXPORT UA_Connection_init(UA_Connection *connection, UA_ConnectionConfig localConf, void *callbackHandle,
                                          UA_Connection_closeCallback close, UA_Connection_writeCallback write);
-UA_Int32 UA_EXPORT UA_Connection_deleteMembers(UA_Connection *connection);
+void UA_EXPORT UA_Connection_deleteMembers(UA_Connection *connection);
 
 // todo: closing a binaryconnection that was closed on the network level
 

include/ua_server.h

@@ -54,8 +54,8 @@ typedef struct UA_Server {
 } UA_Server;
 
 void UA_EXPORT UA_Server_init(UA_Server *server, UA_String *endpointUrl);
-UA_Int32 UA_EXPORT UA_Server_deleteMembers(UA_Server *server);
-UA_Int32 UA_EXPORT UA_Server_processBinaryMessage(UA_Server *server, UA_Connection *connection, const UA_ByteString *msg);
+UA_StatusCode UA_EXPORT UA_Server_deleteMembers(UA_Server *server);
+void UA_EXPORT UA_Server_processBinaryMessage(UA_Server *server, UA_Connection *connection, const UA_ByteString *msg);
 
 /* Services for local use */
 UA_AddNodesResult UA_EXPORT UA_Server_addScalarVariableNode(UA_Server *server, UA_String *browseName, void *value,

include/ua_types.h

@@ -27,6 +27,16 @@ extern "C" {
 #include <stdio.h>
 #endif
 
+/* For internal use */
+#define UA_NULL ((void *)0)
+#define UA_TRUE (42 == 42)
+#define UA_FALSE (!UA_TRUE)
+
+typedef enum UA_EQUALITY {
+    UA_EQUAL,
+    UA_NOT_EQUAL
+} UA_EQUALITY;
+    
 /**
  * @defgroup types Datatypes
  *
@@ -37,48 +47,32 @@ extern "C" {
  *
  * All datatypes follow the same schema in the naming of relevant functions.
  *
- * - <type>_init: Sets all values to a "safe" standard. For example, if the
- *     datatype contains a string-element, its size will be set to zero.
+ * DO NOT CALL THESE FUNCTIONS WITH NULL-POINTERS IF IT IS NOT EXPLICITLY
+ * PERMITTED.
  *
  * - <type>_new: Allocates the memory for the type and runs <type>_init on the
- *     returned pointer.
+ *     returned variable.
+ *
+ * - <type>_init: Sets all members to a "safe" standard, usually zero. Arrays
+ *   (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 target structure can
- *    be overwritten (do a deleteMembers before if necessary). With one
- *    exception: copying into a variant that points to an external datasource is
- *    not permitted.
+ *    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.
+ * - <type>_delete: Frees the memory where the datatype was stored. This
+ *   performs an _deleteMembers internally if required.
  *
  * - <type>_deleteMembers: Frees the memory of dynamically sized members (e.g. a
  *   string) of a datatype. This is useful when the datatype was allocated on
- *   the stack, whereas the dynamically sized members is heap-allocated.
+ *   the stack, whereas the dynamically sized members is heap-allocated. To
+ *   reuse the variable, the remaining members (not dynamically allocated) need
+ *   to be cleaned up with an _init.
  *
  * @{
  */
 
-#define UA_NULL ((void *)0)
-
-/* Function return values */
-#define UA_SUCCESS 0
-#define UA_NO_ERROR UA_SUCCESS
-#define UA_ERROR (0x01 << 31)
-#define UA_ERR_INCONSISTENT (UA_ERROR | (0x01 << 1))
-#define UA_ERR_INVALID_VALUE (UA_ERROR | (0x01 << 2))
-#define UA_ERR_NO_MEMORY (UA_ERROR | (0x01 << 3))
-#define UA_ERR_NOT_IMPLEMENTED (UA_ERROR | (0x01 << 4))
-
-/* Boolean values and null */
-#define UA_TRUE (42 == 42)
-#define UA_FALSE (!UA_TRUE)
-
-/* Compare values */
-typedef enum UA_EQUALITY {
-    UA_EQUAL,
-    UA_NOT_EQUAL
-} UA_EQUALITY;
-
 /** @brief A two-state logical value (true or false). */
 typedef _Bool UA_Boolean;
 
@@ -309,20 +303,20 @@ typedef void UA_InvalidType;
 /*************/
 
 #ifdef DEBUG
-#define UA_TYPE_PROTOTYPES(TYPE)                                   \
-    UA_Int32 UA_EXPORT TYPE##_new(TYPE **p);                    \
-    void UA_EXPORT     TYPE##_init(TYPE * p);                   \
-    void UA_EXPORT     TYPE##_delete(TYPE * p);                 \
-    void UA_EXPORT     TYPE##_deleteMembers(TYPE * p);          \
-    UA_Int32 UA_EXPORT TYPE##_copy(const TYPE *src, TYPE *dst); \
-    void UA_EXPORT     TYPE##_print(const TYPE *p, FILE *stream);
+#define UA_TYPE_PROTOTYPES(TYPE)                                     \
+    UA_StatusCode UA_EXPORT TYPE##_new(TYPE **p);                    \
+    void UA_EXPORT TYPE##_init(TYPE * p);                            \
+    void UA_EXPORT TYPE##_delete(TYPE * p);                          \
+    void UA_EXPORT TYPE##_deleteMembers(TYPE * p);                   \
+    UA_StatusCode UA_EXPORT TYPE##_copy(const TYPE *src, TYPE *dst); \
+    void UA_EXPORT TYPE##_print(const TYPE *p, FILE *stream);
 #else
-#define UA_TYPE_PROTOTYPES(TYPE)                          \
-    UA_Int32 UA_EXPORT TYPE##_new(TYPE **p);           \
-    void UA_EXPORT     TYPE##_init(TYPE * p);          \
-    void UA_EXPORT     TYPE##_delete(TYPE * p);        \
-    void UA_EXPORT     TYPE##_deleteMembers(TYPE * p); \
-    UA_Int32 UA_EXPORT TYPE##_copy(const TYPE *src, TYPE *dst);
+#define UA_TYPE_PROTOTYPES(TYPE)                                        \
+    UA_StatusCode UA_EXPORT TYPE##_new(TYPE **p);                       \
+    void UA_EXPORT TYPE##_init(TYPE * p);                               \
+    void UA_EXPORT TYPE##_delete(TYPE * p);                             \
+    void UA_EXPORT TYPE##_deleteMembers(TYPE * p);                      \
+    UA_StatusCode UA_EXPORT TYPE##_copy(const TYPE *src, TYPE *dst);
 #endif
 
 /* Functions for all types */
@@ -359,8 +353,8 @@ UA_TYPE_PROTOTYPES(UA_InvalidType)
         VARIABLE.length = sizeof(STRING)-1;     \
         VARIABLE.data   = (UA_Byte *)STRING; } while(0)
 
-UA_Int32 UA_EXPORT UA_String_copycstring(char const *src, UA_String *dst);
-UA_Int32 UA_EXPORT UA_String_copyprintf(char const *fmt, UA_String *dst, ...);
+UA_StatusCode UA_EXPORT UA_String_copycstring(char const *src, UA_String *dst);
+UA_StatusCode UA_EXPORT UA_String_copyprintf(char const *fmt, UA_String *dst, ...);
 UA_EQUALITY UA_EXPORT UA_String_equal(const UA_String *string1, const UA_String *string2);
 #ifdef DEBUG
 void UA_EXPORT UA_String_printf(char const *label, const UA_String *string);
@@ -382,14 +376,14 @@ typedef struct UA_DateTimeStruct {
     UA_Int16 year;
 } UA_DateTimeStruct;
 UA_DateTimeStruct UA_EXPORT UA_DateTime_toStruct(UA_DateTime time);
-UA_Int32 UA_EXPORT UA_DateTime_toString(UA_DateTime time, UA_String *timeString);
+UA_StatusCode UA_EXPORT UA_DateTime_toString(UA_DateTime time, UA_String *timeString);
 
 /* Guid */
 UA_EQUALITY UA_EXPORT UA_Guid_equal(const UA_Guid *g1, const UA_Guid *g2);
 
 /* ByteString */
 UA_EQUALITY UA_EXPORT UA_ByteString_equal(const UA_ByteString *string1, const UA_ByteString *string2);
-UA_Int32 UA_EXPORT UA_ByteString_newMembers(UA_ByteString *p, UA_Int32 length);
+UA_StatusCode UA_EXPORT UA_ByteString_newMembers(UA_ByteString *p, UA_Int32 length);
 #ifdef DEBUG
 void UA_EXPORT UA_ByteString_printf(char *label, const UA_ByteString *string);
 void UA_EXPORT UA_ByteString_printx(char *label, const UA_ByteString *string);
@@ -417,7 +411,7 @@ UA_Boolean UA_EXPORT UA_ExpandedNodeId_isNull(const UA_ExpandedNodeId *p);
 #define UA_QUALIFIEDNAME_STATIC(VARIABLE, STRING) do { \
         VARIABLE.namespaceIndex = 0;                   \
         UA_STRING_STATIC(VARIABLE.name, STRING); } while(0)
-UA_Int32 UA_EXPORT UA_QualifiedName_copycstring(char const *src, UA_QualifiedName *dst);
+UA_StatusCode UA_EXPORT UA_QualifiedName_copycstring(char const *src, UA_QualifiedName *dst);
 #ifdef DEBUG
 void UA_EXPORT UA_QualifiedName_printf(char const *label, const UA_QualifiedName *qn);
 #endif
@@ -427,19 +421,19 @@ void UA_EXPORT UA_QualifiedName_printf(char const *label, const UA_QualifiedName
         UA_STRING_STATIC(VARIABLE.locale, "en");       \
         UA_STRING_STATIC(VARIABLE.text, STRING); } while(0)
 
-UA_Int32 UA_EXPORT UA_LocalizedText_copycstring(char const *src, UA_LocalizedText *dst);
+UA_StatusCode UA_EXPORT UA_LocalizedText_copycstring(char const *src, UA_LocalizedText *dst);
 
 /* Variant */
-UA_Int32 UA_EXPORT UA_Variant_copySetValue(UA_Variant *v, const UA_VTable_Entry *vt, const void *value);
-UA_Int32 UA_EXPORT UA_Variant_copySetArray(UA_Variant *v, const UA_VTable_Entry *vt, UA_Int32 arrayLength, const void *array);
+UA_StatusCode UA_EXPORT UA_Variant_copySetValue(UA_Variant *v, const UA_VTable_Entry *vt, const void *value);
+UA_StatusCode UA_EXPORT UA_Variant_copySetArray(UA_Variant *v, const UA_VTable_Entry *vt, UA_Int32 arrayLength, const void *array);
 
 /* Array operations */
-UA_Int32 UA_EXPORT UA_Array_new(void **p, UA_Int32 noElements, const UA_VTable_Entry *vt);
+UA_StatusCode UA_EXPORT UA_Array_new(void **p, UA_Int32 noElements, const UA_VTable_Entry *vt);
 void UA_EXPORT UA_Array_init(void *p, UA_Int32 noElements, const UA_VTable_Entry *vt);
 void UA_EXPORT UA_Array_delete(void *p, UA_Int32 noElements, const UA_VTable_Entry *vt);
 
 /* @brief The destination array is allocated according to noElements. */
-UA_Int32 UA_EXPORT UA_Array_copy(const void *src, UA_Int32 noElements, const UA_VTable_Entry *vt, void **dst);
+UA_StatusCode UA_EXPORT UA_Array_copy(const void *src, UA_Int32 noElements, const UA_VTable_Entry *vt, void **dst);
 #ifdef DEBUG
 void UA_EXPORT UA_Array_print(const void *p, UA_Int32 noElements, const UA_VTable_Entry *vt, FILE *stream);
 #endif
@@ -452,23 +446,23 @@ typedef struct UA_Encoding {
     /**  Returns the size of the encoded element.*/
     UA_Int32 (*calcSize)(const void *p);
     /** Encodes the type into the destination bytestring. */
-    UA_Int32 (*encode)(const void *src, UA_ByteString *dst, UA_UInt32 *offset);
+    UA_StatusCode (*encode)(const void *src, UA_ByteString *dst, UA_UInt32 *offset);
     /** Decodes a ByteString into an UA datatype. */
-    UA_Int32 (*decode)(const UA_ByteString *src, UA_UInt32 *offset, void *dst);
+    UA_StatusCode (*decode)(const UA_ByteString *src, UA_UInt32 *offset, void *dst);
 } UA_Encoding;
 
 #define UA_ENCODING_BINARY 0 // Binary encoding is always available
 
 struct UA_VTable_Entry {
-    UA_NodeId  typeId;
-    UA_Byte   *name;
-    UA_Int32   (*new)(void **p);
-    void       (*init)(void *p);
-    UA_Int32   (*copy)(void const *src, void *dst);
-    void       (*delete)(void *p);
-    void       (*deleteMembers)(void *p);
+    UA_NodeId     typeId;
+    UA_Byte       *name;
+    UA_StatusCode (*new)(void **p);
+    void          (*init)(void *p);
+    UA_StatusCode (*copy)(void const *src, void *dst);
+    void          (*delete)(void *p);
+    void          (*deleteMembers)(void *p);
 #ifdef DEBUG
-    void       (*print)(const void *p, FILE *stream);
+    void          (*print)(const void *p, FILE *stream);
 #endif
     UA_UInt32  memSize;                        // size of the struct only in memory (no dynamic components)
     UA_Boolean dynMembers;                     // does the type contain members that are dynamically
@@ -487,18 +481,17 @@ struct UA_VTable_Entry {
     UA_TYPE_INIT_DEFAULT(TYPE)           \
     UA_TYPE_NEW_DEFAULT(TYPE)            \
     UA_TYPE_COPY_DEFAULT(TYPE)           \
-
-#define UA_TYPE_NEW_DEFAULT(TYPE)                            \
-    UA_Int32 TYPE##_new(TYPE **p) {                          \
+    
+#define UA_TYPE_NEW_DEFAULT(TYPE)                             \
+    UA_StatusCode TYPE##_new(TYPE **p) {                      \
         if(!(*p = UA_alloc(sizeof(TYPE))))                    \
-            return UA_ERROR;                                 \
-        TYPE##_init(*p);                                     \
-        return UA_SUCCESS;                                   \
+            return UA_STATUSCODE_BADOUTOFMEMORY;              \
+        TYPE##_init(*p);                                      \
+        return UA_STATUSCODE_GOOD;                            \
     }
 
 #define UA_TYPE_INIT_DEFAULT(TYPE) \
     void TYPE##_init(TYPE * p) {   \
-        if(!p) return;             \
         *p = (TYPE)0;              \
     }
 
@@ -509,7 +502,6 @@ struct UA_VTable_Entry {
 
 #define UA_TYPE_DELETE_DEFAULT(TYPE) \
     void TYPE##_delete(TYPE *p) {    \
-        if(!p) return;               \
         TYPE##_deleteMembers(p);     \
         UA_free(p);                  \
     }
@@ -527,14 +519,13 @@ struct UA_VTable_Entry {
 
 /* Use only when the type has no arrays. Otherwise, implement deep copy */
 #define UA_TYPE_COPY_DEFAULT(TYPE)                             \
-    UA_Int32 TYPE##_copy(TYPE const *src, TYPE *dst) {         \
-        if(src == UA_NULL || dst == UA_NULL) return UA_ERROR;  \
+    UA_StatusCode TYPE##_copy(TYPE const *src, TYPE *dst) {    \
         *dst = *src;                                           \
-        return UA_SUCCESS;                                     \
+        return UA_STATUSCODE_GOOD;                             \
     }
 
 #define UA_TYPE_COPY_AS(TYPE, TYPE_AS)                         \
-    UA_Int32 TYPE##_copy(TYPE const *src, TYPE *dst) {         \
+    UA_StatusCode TYPE##_copy(TYPE const *src, TYPE *dst) {         \
         return TYPE_AS##_copy((TYPE_AS *)src, (TYPE_AS *)dst); \
     }
 

src/server/ua_nodestore.c

@@ -162,9 +162,10 @@ static INLINE void clear_entry(UA_NodeStore *ns, const UA_Node **entry) {
     ns->count--;
 }
 
-/* Returns UA_SUCCESS if an entry was found. Otherwise, UA_ERROR is returned and the "entry"
-   argument points to the first free entry under the NodeId. */
-static INLINE UA_Int32 find_entry(const UA_NodeStore *ns, const UA_NodeId *nodeid, const UA_Node ***entry) {
+/* Returns UA_STATUSCODE_GOOD if an entry was found. Otherwise, An error code is
+   returned and the "entry" argument points to the first free entry under the
+   NodeId. */
+static INLINE UA_StatusCode find_entry(const UA_NodeStore *ns, const UA_NodeId *nodeid, const UA_Node ***entry) {
     hash_t          h     = hash(nodeid);
     UA_UInt32       size  = ns->size;
     hash_t          index = mod(h, size);
@@ -172,12 +173,12 @@ static INLINE UA_Int32 find_entry(const UA_NodeStore *ns, const UA_NodeId *nodei
 
     if(*e == UA_NULL) {
         *entry = e;
-        return UA_ERROR;
+        return UA_STATUSCODE_BADINTERNALERROR;
     }
 
     if(UA_NodeId_equal(&(*e)->nodeId, nodeid) == UA_EQUAL) {
         *entry = e;
-        return UA_SUCCESS;
+        return UA_STATUSCODE_GOOD;
     }
 
     hash_t hash2 = mod2(h, size);
@@ -190,27 +191,26 @@ static INLINE UA_Int32 find_entry(const UA_NodeStore *ns, const UA_NodeId *nodei
 
         if(*e == UA_NULL) {
             *entry = e;
-            return UA_ERROR;
+            return UA_STATUSCODE_BADINTERNALERROR;
         }
 
         if(UA_NodeId_equal(&(*e)->nodeId, nodeid) == UA_EQUAL) {
             *entry = e;
-            return UA_SUCCESS;
+            return UA_STATUSCODE_GOOD;
         }
     }
 
     /* NOTREACHED */
-    return UA_SUCCESS;
+    return UA_STATUSCODE_GOOD;
 }
 
 /* The following function changes size of memory allocated for the entries and
    repeatedly inserts the table elements. The occupancy of the table after the
-   call will be about 50%. If memory allocation failures occur, this function
-   will return UA_ERROR. */
-static UA_Int32 expand(UA_NodeStore *ns) {
+   call will be about 50%. */
+static UA_StatusCode expand(UA_NodeStore *ns) {
     const UA_Node **nentries;
     int32_t nsize;
-    UA_UInt32       nindex;
+    UA_UInt32 nindex;
 
     const UA_Node **oentries = ns->entries;
     int32_t osize = ns->size;
@@ -219,7 +219,7 @@ static UA_Int32 expand(UA_NodeStore *ns) {
 
     /* Resize only when table after removal of unused elements is either too full or too empty.  */
     if(count * 2 < osize && (count * 8 > osize || osize <= 32))
-        return UA_SUCCESS;
+        return UA_STATUSCODE_GOOD;
 
     nindex = higher_prime_index(count * 2);
     nsize  = primes[nindex];
@@ -243,14 +243,14 @@ static UA_Int32 expand(UA_NodeStore *ns) {
     } while(p < olimit);
 
     UA_free(oentries);
-    return UA_SUCCESS;
+    return UA_STATUSCODE_GOOD;
 }
 
 /**********************/
 /* Exported functions */
 /**********************/
 
-UA_Int32 UA_NodeStore_new(UA_NodeStore **result) {
+UA_StatusCode UA_NodeStore_new(UA_NodeStore **result) {
     UA_NodeStore *ns;
     UA_UInt32     sizePrimeIndex, size;
     if(!(ns = UA_alloc(sizeof(UA_NodeStore))))
@@ -268,10 +268,10 @@ UA_Int32 UA_NodeStore_new(UA_NodeStore **result) {
 
     *ns     = (UA_NodeStore) {ns->entries, size, 0, sizePrimeIndex };
     *result = ns;
-    return UA_SUCCESS;
+    return UA_STATUSCODE_GOOD;
 }
 
-UA_Int32 UA_NodeStore_delete(UA_NodeStore *ns) {
+void UA_NodeStore_delete(UA_NodeStore *ns) {
     UA_UInt32       size    = ns->size;
     const UA_Node **entries = ns->entries;
 
@@ -280,28 +280,24 @@ UA_Int32 UA_NodeStore_delete(UA_NodeStore *ns) {
 
     UA_free(ns->entries);
     UA_free(ns);
-    return UA_SUCCESS;
 }
 
-UA_Int32 UA_NodeStore_insert(UA_NodeStore *ns, UA_Node **node, UA_Byte flags) {
-    if(ns == UA_NULL || node == UA_NULL || *node == UA_NULL)
-        return UA_ERROR;
-
+UA_StatusCode UA_NodeStore_insert(UA_NodeStore *ns, UA_Node **node, UA_Byte flags) {
     if(ns->size * 3 <= ns->count * 4) {
-        if(expand(ns) != UA_SUCCESS)
-            return UA_ERROR;
+        if(expand(ns) != UA_STATUSCODE_GOOD)
+            return UA_STATUSCODE_BADINTERNALERROR;
     }
 
     const UA_Node **entry;
     UA_Int32 found = find_entry(ns, &(*node)->nodeId, &entry);
 
     if(flags & UA_NODESTORE_INSERT_UNIQUE) {
-        if(found == UA_SUCCESS)
-            return UA_ERROR;    /* There is already an entry for that nodeid */
+        if(found == UA_STATUSCODE_GOOD)
+            return UA_STATUSCODE_BADNODEIDEXISTS;
         else
             *entry = *node;
     } else {
-        if(found == UA_SUCCESS)
+        if(found == UA_STATUSCODE_GOOD)
             clear_entry(ns, entry);
         *entry = *node;
     }
@@ -310,46 +306,39 @@ UA_Int32 UA_NodeStore_insert(UA_NodeStore *ns, UA_Node **node, UA_Byte flags) {
         *node = UA_NULL;
 
     ns->count++;
-    return UA_SUCCESS;
+    return UA_STATUSCODE_GOOD;
 }
 
-UA_Int32 UA_NodeStore_get(const UA_NodeStore *ns, const UA_NodeId *nodeid, const UA_Node **managedNode) {
+UA_StatusCode UA_NodeStore_get(const UA_NodeStore *ns, const UA_NodeId *nodeid, const UA_Node **managedNode) {
     const UA_Node **entry;
-    if(ns == UA_NULL || nodeid == UA_NULL || managedNode == UA_NULL)
-        return UA_ERROR;
-
-    if(find_entry(ns, nodeid, &entry) != UA_SUCCESS)
-        return UA_ERROR;
+    if(find_entry(ns, nodeid, &entry) != UA_STATUSCODE_GOOD)
+        return UA_STATUSCODE_BADNODEIDUNKNOWN;
 
     *managedNode = *entry;
-    return UA_SUCCESS;
+    return UA_STATUSCODE_GOOD;
 }
 
-UA_Int32 UA_NodeStore_remove(UA_NodeStore *ns, const UA_NodeId *nodeid) {
+UA_StatusCode UA_NodeStore_remove(UA_NodeStore *ns, const UA_NodeId *nodeid) {
     const UA_Node **entry;
-    if(find_entry(ns, nodeid, &entry) != UA_SUCCESS)
-        return UA_ERROR;
+    if(find_entry(ns, nodeid, &entry) != UA_STATUSCODE_GOOD)
+        return UA_STATUSCODE_BADNODEIDUNKNOWN;
 
     // Check before if deleting the node makes the UA_NodeStore inconsistent.
     clear_entry(ns, entry);
 
     /* Downsize the hashmap if it is very empty */
     if(ns->count * 8 < ns->size && ns->size > 32)
-        expand(ns);
+        expand(ns); // this can fail. we just continue with the bigger hashmap.
 
-    return UA_SUCCESS;
+    return UA_STATUSCODE_GOOD;
 }
 
-UA_Int32 UA_NodeStore_iterate(const UA_NodeStore *ns, UA_NodeStore_nodeVisitor visitor) {
-    if(ns == UA_NULL || visitor == UA_NULL)
-        return UA_ERROR;
-
+void UA_NodeStore_iterate(const UA_NodeStore *ns, UA_NodeStore_nodeVisitor visitor) {
     for(UA_UInt32 i = 0;i < ns->size;i++) {
         const UA_Node *node = ns->entries[i];
         if(node != UA_NULL)
             visitor(node);
     }
-    return UA_SUCCESS;
 }
 
 void UA_NodeStore_releaseManagedNode(const UA_Node *managed) {

src/server/ua_nodestore.h

@@ -22,10 +22,10 @@
  */
 
 /** @brief Create a new namespace */
-UA_Int32 UA_NodeStore_new(UA_NodeStore **result);
+UA_StatusCode UA_NodeStore_new(UA_NodeStore **result);
 
 /** @brief Delete the namespace and all nodes in it */
-UA_Int32 UA_NodeStore_delete(UA_NodeStore *ns);
+void UA_NodeStore_delete(UA_NodeStore *ns);
 
 #define UA_NODESTORE_INSERT_UNIQUE 1
 #define UA_NODESTORE_INSERT_GETMANAGED 2
@@ -34,17 +34,17 @@ UA_Int32 UA_NodeStore_delete(UA_NodeStore *ns);
     With the UNIQUE flag, the node is only inserted if the nodeid does not
     already exist. With the GETMANAGED flag, the node pointer is replaced with
     the managed pointer. Otherwise, it is set to UA_NULL. */
-UA_Int32 UA_NodeStore_insert(UA_NodeStore *ns, UA_Node **node, UA_Byte flags);
+UA_StatusCode UA_NodeStore_insert(UA_NodeStore *ns, UA_Node **node, UA_Byte flags);
 
 /** @brief Remove a node from the namespace. Always succeeds, even if the node
     was not found. */
-UA_Int32 UA_NodeStore_remove(UA_NodeStore *ns, const UA_NodeId *nodeid);
+UA_StatusCode UA_NodeStore_remove(UA_NodeStore *ns, const UA_NodeId *nodeid);
 
 /** @brief Retrieve a node (read-only) from the namespace. Nodes are immutable.
     They can only be replaced. After the Node is no longer used, the locked
     entry needs to be released. */
-UA_Int32 UA_NodeStore_get(const UA_NodeStore *ns, const UA_NodeId *nodeid,
-                          const UA_Node **managedNode);
+UA_StatusCode UA_NodeStore_get(const UA_NodeStore *ns, const UA_NodeId *nodeid,
+                               const UA_Node **managedNode);
 
 /** @brief Release a managed node. Do never insert a node that isn't stored in a
     namespace. */
@@ -55,7 +55,7 @@ void UA_NodeStore_releaseManagedNode(const UA_Node *managed);
 typedef void (*UA_NodeStore_nodeVisitor)(const UA_Node *node);
 
 /** @brief Iterate over all nodes in a namespace. */
-UA_Int32 UA_NodeStore_iterate(const UA_NodeStore *ns, UA_NodeStore_nodeVisitor visitor);
+void UA_NodeStore_iterate(const UA_NodeStore *ns, UA_NodeStore_nodeVisitor visitor);
 
 /// @} /* end of group */
 

src/server/ua_nodestore_concurrent.c

@@ -7,6 +7,7 @@
 #include <urcu/rculfhash.h>
 
 #define ALIVE_BIT (1 << 15) /* Alive bit in the readcount */
+
 typedef struct UA_NodeStore_Entry {
     struct cds_lfht_node htn;      /* contains next-ptr for urcu-hashmap */
     struct rcu_head      rcu_head; /* For call-rcu */
@@ -176,26 +177,23 @@ void UA_NodeStore_releaseManagedNode(const UA_Node *managed) {
     return;
 }
 
-UA_Int32 UA_NodeStore_new(UA_NodeStore **result) {
+UA_StatusCode UA_NodeStore_new(UA_NodeStore **result) {
     UA_NodeStore *ns;
-    if(UA_alloc((void **)&ns, sizeof(UA_NodeStore)) != UA_SUCCESS)
-        return UA_ERR_NO_MEMORY;
+    if(!(ns = UA_alloc(sizeof(UA_NodeStore))))
+        return UA_STATUSCODE_BADOUTOFMEMORY;
 
     /* 32 is the minimum size for the hashtable. */
     ns->ht = cds_lfht_new(32, 32, 0, CDS_LFHT_AUTO_RESIZE, NULL);
     if(!ns->ht) {
         UA_free(ns);
-        return UA_ERR_NO_MEMORY;
+        return UA_STATUSCODE_BADOUTOFMEMORY;
     }
 
     *result = ns;
-    return UA_SUCCESS;
+    return UA_STATUSCODE_GOOD;
 }
 
-UA_Int32 UA_NodeStore_delete(UA_NodeStore *ns) {
-    if(ns == UA_NULL)
-        return UA_ERROR;
-
+void UA_NodeStore_delete(UA_NodeStore *ns) {
     struct cds_lfht      *ht = ns->ht;
     struct cds_lfht_iter  iter;
     struct cds_lfht_node *found_htn;
@@ -212,17 +210,11 @@ UA_Int32 UA_NodeStore_delete(UA_NodeStore *ns) {
     }
     rcu_read_unlock();
 
-    if(!cds_lfht_destroy(ht, UA_NULL)) {
-        UA_free(ns);
-        return UA_SUCCESS;
-    } else
-        return UA_ERROR;
+    cds_lfht_destroy(ht, UA_NULL);
+    UA_free(ns);
 }
 
-UA_Int32 UA_NodeStore_insert(UA_NodeStore *ns, UA_Node **node, UA_Byte flags) {
-    if(ns == UA_NULL || node == UA_NULL || *node == UA_NULL)
-        return UA_ERROR;
-
+UA_StatusCode UA_NodeStore_insert(UA_NodeStore *ns, UA_Node **node, UA_Byte flags) {
     UA_UInt32 nodesize;
     /* Copy the node into the entry. Then reset the original node. It shall no longer be used. */
     switch((*node)->nodeClass) {
@@ -259,12 +251,12 @@ UA_Int32 UA_NodeStore_insert(UA_NodeStore *ns, UA_Node **node, UA_Byte flags) {
         break;
 
     default:
-        return UA_ERROR;
+        return UA_STATUSCODE_BADINTERNALERROR;
     }
 
     UA_NodeStore_Entry *entry;
-    if(UA_alloc((void **)&entry, sizeof(UA_NodeStore_Entry) - sizeof(UA_Node) + nodesize))
-        return UA_ERR_NO_MEMORY;
+    if(!(entry = UA_alloc(sizeof(UA_NodeStore_Entry) - sizeof(UA_Node) + nodesize)))
+        return UA_STATUSCODE_BADOUTOFMEMORY;
     memcpy(&entry->node, *node, nodesize);
 
     cds_lfht_node_init(&entry->htn);
@@ -282,7 +274,7 @@ UA_Int32 UA_NodeStore_insert(UA_NodeStore *ns, UA_Node **node, UA_Byte flags) {
         /* If the nodeid exists already */
         if(result != &entry->htn) {
             UA_free(entry);
-            return UA_ERROR;     // TODO: define a UA_EXISTS_ALREADY
+            return UA_STATUSCODE_BADNODEIDEXISTS;
         }
     } else {
         rcu_read_lock();
@@ -301,10 +293,10 @@ UA_Int32 UA_NodeStore_insert(UA_NodeStore *ns, UA_Node **node, UA_Byte flags) {
     else
         *node = UA_NULL;
 
-    return UA_SUCCESS;
+    return UA_STATUSCODE_GOOD;
 }
 
-UA_Int32 UA_NodeStore_remove(UA_NodeStore *ns, const UA_NodeId *nodeid) {
+UA_StatusCode UA_NodeStore_remove(UA_NodeStore *ns, const UA_NodeId *nodeid) {
     hash_t nhash = hash(nodeid);
     struct cds_lfht_iter iter;
 
@@ -315,17 +307,17 @@ UA_Int32 UA_NodeStore_remove(UA_NodeStore *ns, const UA_NodeId *nodeid) {
     /* If this fails, then the node has already been removed. */
     if(!found_htn || cds_lfht_del(ns->ht, found_htn) != 0) {
         rcu_read_unlock();
-        return UA_ERROR;
+        return UA_STATUSCODE_BADNODEIDUNKNOWN;
     }
 
     UA_NodeStore_Entry *entry = caa_container_of(found_htn, UA_NodeStore_Entry, htn);
     call_rcu(&entry->rcu_head, markDead);
     rcu_read_unlock();
 
-    return UA_SUCCESS;
+    return UA_STATUSCODE_GOOD;
 }
 
-UA_Int32 UA_NodeStore_get(const UA_NodeStore *ns, const UA_NodeId *nodeid, const UA_Node **managedNode) {
+UA_StatusCode UA_NodeStore_get(const UA_NodeStore *ns, const UA_NodeId *nodeid, const UA_Node **managedNode) {
     hash_t nhash = hash(nodeid);
     struct cds_lfht_iter iter;
 
@@ -335,7 +327,7 @@ UA_Int32 UA_NodeStore_get(const UA_NodeStore *ns, const UA_NodeId *nodeid, const
 
     if(!found_entry) {
         rcu_read_unlock();
-        return UA_ERROR;  // TODO: UA_NOTFOUND
+        return UA_STATUSCODE_BADNODEIDUNKNOWN;
     }
 
     /* This is done within a read-lock. The node will not be marked dead within a read-lock. */
@@ -343,13 +335,10 @@ UA_Int32 UA_NodeStore_get(const UA_NodeStore *ns, const UA_NodeId *nodeid, const
     rcu_read_unlock();
 
     *managedNode = &found_entry->node;
-    return UA_SUCCESS;
+    return UA_STATUSCODE_GOOD;
 }
 
-UA_Int32 UA_NodeStore_iterate(const UA_NodeStore *ns, UA_NodeStore_nodeVisitor visitor) {
-    if(ns == UA_NULL || visitor == UA_NULL)
-        return UA_ERROR;
-
+void UA_NodeStore_iterate(const UA_NodeStore *ns, UA_NodeStore_nodeVisitor visitor) {
     struct cds_lfht     *ht = ns->ht;
     struct cds_lfht_iter iter;
 
@@ -366,6 +355,4 @@ UA_Int32 UA_NodeStore_iterate(const UA_NodeStore *ns, UA_NodeStore_nodeVisitor v
         cds_lfht_next(ht, &iter);
     }
     rcu_read_unlock();
-
-    return UA_SUCCESS;
 }

src/server/ua_securechannel_manager.c

@@ -19,9 +19,9 @@ struct UA_SecureChannelManager {
     UA_UInt32   lastTokenId;
 };
 
-UA_Int32 UA_SecureChannelManager_new(UA_SecureChannelManager **cm, UA_UInt32 maxChannelCount,
-                                     UA_UInt32 tokenLifetime, UA_UInt32 startChannelId,
-                                     UA_UInt32 startTokenId, UA_String *endpointUrl) {
+UA_StatusCode UA_SecureChannelManager_new(UA_SecureChannelManager **cm, UA_UInt32 maxChannelCount,
+                                          UA_UInt32 tokenLifetime, UA_UInt32 startChannelId,
+                                          UA_UInt32 startTokenId, UA_String *endpointUrl) {
     if(!(*cm = UA_alloc(sizeof(UA_SecureChannelManager))))
         return UA_STATUSCODE_BADOUTOFMEMORY;
     UA_SecureChannelManager *channelManager = *cm;
@@ -31,10 +31,10 @@ UA_Int32 UA_SecureChannelManager_new(UA_SecureChannelManager **cm, UA_UInt32 max
     UA_String_copy(endpointUrl, &channelManager->endpointUrl);
     channelManager->maxChannelLifetime = tokenLifetime;
     channelManager->maxChannelCount    = maxChannelCount;
-    return UA_SUCCESS;
+    return UA_STATUSCODE_GOOD;
 }
 
-UA_Int32 UA_SecureChannelManager_delete(UA_SecureChannelManager *cm) {
+void UA_SecureChannelManager_delete(UA_SecureChannelManager *cm) {
     struct channel_list_entry *entry = LIST_FIRST(&cm->channels);
     while(entry) {
         LIST_REMOVE(entry, pointers);
@@ -48,13 +48,12 @@ UA_Int32 UA_SecureChannelManager_delete(UA_SecureChannelManager *cm) {
     }
     UA_String_deleteMembers(&cm->endpointUrl);
     UA_free(cm);
-    return UA_SUCCESS;
 }
 
-UA_Int32 UA_SecureChannelManager_open(UA_SecureChannelManager           *cm,
-                                      UA_Connection                     *conn,
-                                      const UA_OpenSecureChannelRequest *request,
-                                      UA_OpenSecureChannelResponse      *response) {
+UA_StatusCode UA_SecureChannelManager_open(UA_SecureChannelManager           *cm,
+                                           UA_Connection                     *conn,
+                                           const UA_OpenSecureChannelRequest *request,
+                                           UA_OpenSecureChannelResponse      *response) {
     struct channel_list_entry *entry = UA_alloc(sizeof(struct channel_list_entry));
     UA_SecureChannel_init(&entry->channel);
 
@@ -92,17 +91,17 @@ UA_Int32 UA_SecureChannelManager_open(UA_SecureChannelManager           *cm,
 
     conn->channel = &entry->channel;
 
-    return UA_SUCCESS;
+    return UA_STATUSCODE_GOOD;
 }
 
-UA_Int32 UA_SecureChannelManager_renew(UA_SecureChannelManager           *cm,
-                                       UA_Connection                     *conn,
-                                       const UA_OpenSecureChannelRequest *request,
-                                       UA_OpenSecureChannelResponse      *response) {
+UA_StatusCode UA_SecureChannelManager_renew(UA_SecureChannelManager           *cm,
+                                            UA_Connection                     *conn,
+                                            const UA_OpenSecureChannelRequest *request,
+                                            UA_OpenSecureChannelResponse      *response) {
 
     UA_SecureChannel *channel = conn->channel;
     if(channel == UA_NULL)
-        return UA_ERROR;
+        return UA_STATUSCODE_BADINTERNALERROR;
 
     channel->securityToken.tokenId         = cm->lastTokenId++;
     channel->securityToken.createdAt       = UA_DateTime_now(); // todo: is wanted?
@@ -113,23 +112,23 @@ UA_Int32 UA_SecureChannelManager_renew(UA_SecureChannelManager           *cm,
     UA_ByteString_copy(&channel->serverNonce, &response->serverNonce);
     UA_ChannelSecurityToken_copy(&channel->securityToken, &response->securityToken);
 
-    return UA_SUCCESS;
+    return UA_STATUSCODE_GOOD;
 }
 
-UA_Int32 UA_SecureChannelManager_get(UA_SecureChannelManager *cm, UA_UInt32 channelId,
-                                     UA_SecureChannel **channel) {
+UA_StatusCode UA_SecureChannelManager_get(UA_SecureChannelManager *cm, UA_UInt32 channelId,
+                                          UA_SecureChannel **channel) {
     struct channel_list_entry *entry;
     LIST_FOREACH(entry, &cm->channels, pointers) {
         if(entry->channel.securityToken.channelId == channelId) {
             *channel = &entry->channel;
-            return UA_SUCCESS;
+            return UA_STATUSCODE_GOOD;
         }
     }
     *channel = UA_NULL;
-    return UA_ERROR;
+    return UA_STATUSCODE_BADINTERNALERROR;
 }
 
-UA_Int32 UA_SecureChannelManager_close(UA_SecureChannelManager *cm, UA_UInt32 channelId) {
+UA_StatusCode UA_SecureChannelManager_close(UA_SecureChannelManager *cm, UA_UInt32 channelId) {
     //TODO lock access
     // TODO: close the binaryconnection if it is still open. So we dö not have stray pointers..
     struct channel_list_entry *entry;
@@ -138,9 +137,9 @@ UA_Int32 UA_SecureChannelManager_close(UA_SecureChannelManager *cm, UA_UInt32 ch
             UA_SecureChannel_deleteMembers(&entry->channel);
             LIST_REMOVE(entry, pointers);
             UA_free(entry);
-            return UA_SUCCESS;
+            return UA_STATUSCODE_GOOD;
         }
     }
     //TODO notify server application that secureChannel has been closed part 6 - §7.1.4
-    return UA_ERROR;
+    return UA_STATUSCODE_BADINTERNALERROR;
 }

src/server/ua_securechannel_manager.h

@@ -4,18 +4,18 @@
 #include "ua_server.h"
 #include "ua_securechannel.h"
 
-UA_Int32 UA_SecureChannelManager_new(UA_SecureChannelManager **cm, UA_UInt32 maxChannelCount,
-                                     UA_UInt32 tokenLifetime, UA_UInt32 startChannelId,
-                                     UA_UInt32 startTokenId, UA_String *endpointUrl);
-UA_Int32 UA_SecureChannelManager_delete(UA_SecureChannelManager *cm);
-UA_Int32 UA_SecureChannelManager_open(UA_SecureChannelManager *cm, UA_Connection *conn,
-                                      const UA_OpenSecureChannelRequest *request,
-                                      UA_OpenSecureChannelResponse *response);
-UA_Int32 UA_SecureChannelManager_renew(UA_SecureChannelManager *cm, UA_Connection *conn,
-                                       const UA_OpenSecureChannelRequest *request,
-                                       UA_OpenSecureChannelResponse *response);
-UA_Int32 UA_SecureChannelManager_get(UA_SecureChannelManager *cm, UA_UInt32 channelId,
-                                     UA_SecureChannel **channel);
-UA_Int32 UA_SecureChannelManager_close(UA_SecureChannelManager *cm, UA_UInt32 channelId);
+UA_StatusCode UA_SecureChannelManager_new(UA_SecureChannelManager **cm, UA_UInt32 maxChannelCount,
+                                          UA_UInt32 tokenLifetime, UA_UInt32 startChannelId,
+                                          UA_UInt32 startTokenId, UA_String *endpointUrl);
+void UA_SecureChannelManager_delete(UA_SecureChannelManager *cm);
+UA_StatusCode UA_SecureChannelManager_open(UA_SecureChannelManager *cm, UA_Connection *conn,
+                                           const UA_OpenSecureChannelRequest *request,
+                                           UA_OpenSecureChannelResponse *response);
+UA_StatusCode UA_SecureChannelManager_renew(UA_SecureChannelManager *cm, UA_Connection *conn,
+                                            const UA_OpenSecureChannelRequest *request,
+                                            UA_OpenSecureChannelResponse *response);
+UA_StatusCode UA_SecureChannelManager_get(UA_SecureChannelManager *cm, UA_UInt32 channelId,
+                                          UA_SecureChannel **channel);
+UA_StatusCode UA_SecureChannelManager_close(UA_SecureChannelManager *cm, UA_UInt32 channelId);
 
 #endif /* UA_CHANNEL_MANAGER_H_ */

src/server/ua_server.c

@@ -6,13 +6,13 @@
 #include "ua_util.h"
 #include "ua_services.h"
 
-UA_Int32 UA_Server_deleteMembers(UA_Server *server) {
+UA_StatusCode UA_Server_deleteMembers(UA_Server *server) {
     UA_ApplicationDescription_deleteMembers(&server->description);
     UA_SecureChannelManager_delete(server->secureChannelManager);
     UA_SessionManager_delete(server->sessionManager);
     UA_NodeStore_delete(server->nodestore);
     UA_ByteString_deleteMembers(&server->serverCertificate);
-    return UA_SUCCESS;
+    return UA_STATUSCODE_GOOD;
 }
 
 void UA_Server_init(UA_Server *server, UA_String *endpointUrl) {

src/server/ua_server_binary.c

@@ -6,18 +6,18 @@
 #include "ua_session_manager.h"
 #include "ua_util.h"
 
-static UA_Int32 UA_ByteStringArray_deleteMembers(UA_ByteStringArray *stringarray) {
+static UA_StatusCode UA_ByteStringArray_deleteMembers(UA_ByteStringArray *stringarray) {
     if(!stringarray)
-        return UA_ERROR;
+        return UA_STATUSCODE_BADINTERNALERROR;
     for(UA_UInt32 i = 0;i < stringarray->stringsSize;i++)
         UA_String_deleteMembers(&stringarray->strings[i]);
-    return UA_SUCCESS;
+    return UA_STATUSCODE_GOOD;
 }
 
 static void processHello(UA_Connection *connection, const UA_ByteString *msg,
                          UA_UInt32 *pos) {
     UA_TcpHelloMessage helloMessage;
-    if(UA_TcpHelloMessage_decodeBinary(msg, pos, &helloMessage) != UA_SUCCESS) {
+    if(UA_TcpHelloMessage_decodeBinary(msg, pos, &helloMessage) != UA_STATUSCODE_GOOD) {
         connection->close(connection->callbackHandle);
         return;
     }
@@ -126,7 +126,7 @@ static void init_response_header(const UA_RequestHeader *p, UA_ResponseHeader *r
 }
 
 #define CHECK_PROCESS(CODE, CLEANUP) \
-    do { if(CODE != UA_SUCCESS) {    \
+    do { if(CODE != UA_STATUSCODE_GOOD) {    \
             CLEANUP;                 \
             return;                  \
         } } while(0)
@@ -246,7 +246,6 @@ static void processMessage(UA_Connection *connection, UA_Server *server, const U
     }
     break;
 
-
     case UA_READREQUEST_NS0:
         INVOKE_SERVICE(Read);
         break;
@@ -342,15 +341,15 @@ static void processClose(UA_Connection *connection, UA_Server *server, const UA_
 	Service_CloseSecureChannel(server, secureChannelId);
 }
 
-UA_Int32 UA_Server_processBinaryMessage(UA_Server *server, UA_Connection *connection, const UA_ByteString *msg) {
-    UA_Int32  retval = UA_SUCCESS;
+void UA_Server_processBinaryMessage(UA_Server *server, UA_Connection *connection, const UA_ByteString *msg) {
+    UA_Int32  retval = UA_STATUSCODE_GOOD;
     UA_UInt32 pos    = 0;
     UA_TcpMessageHeader tcpMessageHeader;
     // todo: test how far pos advanced must be equal to what is said in the messageheader
     do {
         retval = UA_TcpMessageHeader_decodeBinary(msg, &pos, &tcpMessageHeader);
         UA_UInt32 targetpos = pos - 8 + tcpMessageHeader.messageSize;
-        if(retval == UA_SUCCESS) {
+        if(retval == UA_STATUSCODE_GOOD) {
             // none of the process-functions returns an error its all contained inside.
             switch(tcpMessageHeader.messageType) {
             case UA_MESSAGETYPE_HEL:
@@ -374,7 +373,7 @@ UA_Int32 UA_Server_processBinaryMessage(UA_Server *server, UA_Connection *connec
                 connection->state = UA_CONNECTION_CLOSING;
                 processClose(connection, server, msg, &pos);
                 connection->close(connection->callbackHandle);
-                return retval;
+                return;
             }
             UA_TcpMessageHeader_deleteMembers(&tcpMessageHeader);
         } else {
@@ -389,5 +388,4 @@ UA_Int32 UA_Server_processBinaryMessage(UA_Server *server, UA_Connection *connec
             pos = targetpos;
         }
     } while(msg->length > (UA_Int32)pos);
-    return retval;
 }

src/server/ua_services_attribute.c

@@ -42,12 +42,12 @@ static UA_DataValue service_read_node(UA_Server *server, const UA_ReadValueId *i
 
     UA_Node const *node   = UA_NULL;
     UA_Int32       result = UA_NodeStore_get(server->nodestore, &(id->nodeId), &node);
-    if(result != UA_SUCCESS || node == UA_NULL) {
+    if(result != UA_STATUSCODE_GOOD || node == UA_NULL) {
         v.encodingMask = UA_DATAVALUE_ENCODINGMASK_STATUSCODE;
         v.status       = UA_STATUSCODE_BADNODEIDUNKNOWN;
         return v;
     }
-    UA_Int32 retval = UA_SUCCESS;
+    UA_StatusCode retval = UA_STATUSCODE_GOOD;
 
     switch(id->attributeId) {
     case UA_ATTRIBUTEID_NODEID:
@@ -203,7 +203,7 @@ static UA_DataValue service_read_node(UA_Server *server, const UA_ReadValueId *i
 
     UA_NodeStore_releaseManagedNode(node);
 
-    if(retval != UA_SUCCESS) {
+    if(retval != UA_STATUSCODE_GOOD) {
         v.encodingMask = UA_DATAVALUE_ENCODINGMASK_STATUSCODE;
         v.status       = UA_STATUSCODE_BADNOTREADABLE;
     }
@@ -220,7 +220,7 @@ void Service_Read(UA_Server *server, UA_Session *session,
         return;
     }
 
-    if(UA_Array_new((void **)&response->results, request->nodesToReadSize, &UA_[UA_DATAVALUE]) != UA_SUCCESS) {
+    if(UA_Array_new((void **)&response->results, request->nodesToReadSize, &UA_[UA_DATAVALUE]) != UA_STATUSCODE_GOOD) {
         response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY;
         return;
     }
@@ -230,139 +230,127 @@ void Service_Read(UA_Server *server, UA_Session *session,
         response->results[i] = service_read_node(server, &request->nodesToRead[i]);
 }
 
-UA_Int32 Service_Write_writeNode(UA_Server *server, UA_WriteValue *writeValue,
-                                 UA_StatusCode *result) {
-    UA_Int32 retval = UA_SUCCESS;
+static UA_StatusCode Service_Write_writeNode(UA_Server *server, UA_WriteValue *writeValue) {
+    UA_StatusCode retval = UA_STATUSCODE_GOOD;
     const UA_Node *node;
-    if(UA_NodeStore_get(server->nodestore, &writeValue->nodeId, &node) != UA_SUCCESS)
-        return UA_ERROR;
+    retval = UA_NodeStore_get(server->nodestore, &writeValue->nodeId, &node);
+    if(retval)
+        return retval;
 
     switch(writeValue->attributeId) {
     case UA_ATTRIBUTEID_NODEID:
         /* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){ } */
-        *result = UA_STATUSCODE_BADWRITENOTSUPPORTED;
-        return UA_ERROR;
+        retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
         break;
 
     case UA_ATTRIBUTEID_NODECLASS:
         /* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){ } */
-        *result = UA_STATUSCODE_BADWRITENOTSUPPORTED;
-        return UA_ERROR;
+        retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
         break;
 
     case UA_ATTRIBUTEID_BROWSENAME:
         /* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
-        *result = UA_STATUSCODE_BADWRITENOTSUPPORTED;
-        return UA_ERROR;
+        retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
         break;
 
     case UA_ATTRIBUTEID_DISPLAYNAME:
         /* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
-        *result = UA_STATUSCODE_BADWRITENOTSUPPORTED;
-        return UA_ERROR;
+        retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
         break;
 
     case UA_ATTRIBUTEID_DESCRIPTION:
         /* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
-        *result = UA_STATUSCODE_BADWRITENOTSUPPORTED;
-        return UA_ERROR;
+        retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
         break;
 
     case UA_ATTRIBUTEID_WRITEMASK:
         /* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
+        retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
         break;
 
     case UA_ATTRIBUTEID_USERWRITEMASK:
         /* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
-        *result = UA_STATUSCODE_BADWRITENOTSUPPORTED;
-        return UA_ERROR;
+        retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
         break;
 
     case UA_ATTRIBUTEID_ISABSTRACT:
-
         /* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
-        *result = UA_STATUSCODE_BADWRITENOTSUPPORTED;
-
+        retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
         break;
 
     case UA_ATTRIBUTEID_SYMMETRIC:
         /* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
-        *result = UA_STATUSCODE_BADWRITENOTSUPPORTED;
-        return UA_ERROR;
+        retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
         break;
 
     case UA_ATTRIBUTEID_INVERSENAME:
         /* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
-        *result = UA_STATUSCODE_BADWRITENOTSUPPORTED;
+        retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
         break;
 
     case UA_ATTRIBUTEID_CONTAINSNOLOOPS:
         /* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
-        *result = UA_STATUSCODE_BADWRITENOTSUPPORTED;
-        return UA_ERROR;
+        retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
         break;
 
     case UA_ATTRIBUTEID_EVENTNOTIFIER:
         /* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
-        *result = UA_STATUSCODE_BADWRITENOTSUPPORTED;
+        retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
         break;
 
     case UA_ATTRIBUTEID_VALUE:
         if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT) {
             retval |= UA_Variant_copy(&writeValue->value.value, &((UA_VariableNode *)node)->value); // todo: zero-copy
-            *result = UA_STATUSCODE_GOOD;
         }
-
         break;
 
     case UA_ATTRIBUTEID_DATATYPE:
         /* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
-        *result = UA_STATUSCODE_BADWRITENOTSUPPORTED;
+        retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
         break;
 
     case UA_ATTRIBUTEID_VALUERANK:
         /* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
-        *result = UA_STATUSCODE_BADWRITENOTSUPPORTED;
+        retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
         break;
 
     case UA_ATTRIBUTEID_ARRAYDIMENSIONS:
         /* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
-        *result = UA_STATUSCODE_BADWRITENOTSUPPORTED;
+        retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
         break;
 
     case UA_ATTRIBUTEID_ACCESSLEVEL:
         /* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
-        *result = UA_STATUSCODE_BADWRITENOTSUPPORTED;
+        retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
         break;
 
     case UA_ATTRIBUTEID_USERACCESSLEVEL:
         /* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
-        *result = UA_STATUSCODE_BADWRITENOTSUPPORTED;
-        return UA_ERROR;
+        retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
         break;
 
     case UA_ATTRIBUTEID_MINIMUMSAMPLINGINTERVAL:
         /* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
-        *result = UA_STATUSCODE_BADWRITENOTSUPPORTED;
+        retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
         break;
 
     case UA_ATTRIBUTEID_HISTORIZING:
         /* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
-        *result = UA_STATUSCODE_BADWRITENOTSUPPORTED;
+        retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
         break;
 
     case UA_ATTRIBUTEID_EXECUTABLE:
         /* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
-        *result = UA_STATUSCODE_BADWRITENOTSUPPORTED;
+        retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
         break;
 
     case UA_ATTRIBUTEID_USEREXECUTABLE:
         /* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
-        *result = UA_STATUSCODE_BADWRITENOTSUPPORTED;
+        retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
         break;
 
     default:
-        *result = UA_STATUSCODE_BADATTRIBUTEIDINVALID;
+        retval = UA_STATUSCODE_BADATTRIBUTEIDINVALID;
         break;
     }
 
@@ -375,13 +363,12 @@ void Service_Write(UA_Server *server, UA_Session *session,
                    const UA_WriteRequest *request, UA_WriteResponse *response) {
     UA_assert(server != UA_NULL && session != UA_NULL && request != UA_NULL && response != UA_NULL);
 
-    if(UA_Array_new((void **)&response->results, request->nodesToWriteSize, &UA_[UA_STATUSCODE])
-       != UA_SUCCESS) {
+    if(UA_Array_new((void **)&response->results, request->nodesToWriteSize, &UA_[UA_STATUSCODE])) {
         response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY;
         return;
     }
     
     response->resultsSize = request->nodesToWriteSize;
     for(UA_Int32 i = 0;i < request->nodesToWriteSize;i++)
-        Service_Write_writeNode(server, &request->nodesToWrite[i], &response->results[i]);
+        response->results[i] = Service_Write_writeNode(server, &request->nodesToWrite[i]);
 }

src/server/ua_services_monitoreditems.c

@@ -2,11 +2,11 @@
 #include "ua_namespace_0.h"
 #include "ua_statuscodes.h"
 
-UA_Int32 Service_CreateMonitoredItems(UA_Server *server, UA_Session *session,
-                                      const UA_CreateMonitoredItemsRequest *request,
-                                      UA_CreateMonitoredItemsResponse *response) {
+void Service_CreateMonitoredItems(UA_Server *server, UA_Session *session,
+                                  const UA_CreateMonitoredItemsRequest *request,
+                                  UA_CreateMonitoredItemsResponse *response) {
     if(request->itemsToCreateSize <= 0)
-        return UA_SUCCESS;
+        return;
 
     //mock up
     response->resultsSize = request->itemsToCreateSize;
@@ -24,5 +24,4 @@ UA_Int32 Service_CreateMonitoredItems(UA_Server *server, UA_Session *session,
             response->results[i].statusCode = -1;
         }
     }
-    return UA_SUCCESS;
 }

src/server/ua_services_nodemanagement.c

@@ -29,11 +29,11 @@ static UA_StatusCode parseVariableNode(UA_ExtensionObject *attributes, UA_Node *
     UA_VariableAttributes attr;
     UA_UInt32 pos = 0;
     // todo return more informative error codes from decodeBinary
-    if(UA_VariableAttributes_decodeBinary(&attributes->body, &pos, &attr) != UA_SUCCESS)
+    if(UA_VariableAttributes_decodeBinary(&attributes->body, &pos, &attr) != UA_STATUSCODE_GOOD)
         return UA_STATUSCODE_BADNODEATTRIBUTESINVALID;
 
     UA_VariableNode *vnode;
-    if(UA_VariableNode_new(&vnode) != UA_SUCCESS) {
+    if(UA_VariableNode_new(&vnode) != UA_STATUSCODE_GOOD) {
         UA_VariableAttributes_deleteMembers(&attr);
         return UA_STATUSCODE_BADOUTOFMEMORY;
     }
@@ -94,13 +94,13 @@ UA_AddNodesResult AddNode(UA_Server *server, UA_Session *session, UA_Node **node
     UA_AddNodesResult_init(&result);
     
     const UA_Node *parent;
-    if(UA_NodeStore_get(server->nodestore, &parentNodeId->nodeId, &parent) != UA_SUCCESS) {
+    if(UA_NodeStore_get(server->nodestore, &parentNodeId->nodeId, &parent) != UA_STATUSCODE_GOOD) {
         result.statusCode = UA_STATUSCODE_BADPARENTNODEIDINVALID;
         return result;
     }
 
     const UA_ReferenceTypeNode *referenceType;
-    if(UA_NodeStore_get(server->nodestore, referenceTypeId, (const UA_Node**)&referenceType) != UA_SUCCESS) {
+    if(UA_NodeStore_get(server->nodestore, referenceTypeId, (const UA_Node**)&referenceType) != UA_STATUSCODE_GOOD) {
         result.statusCode = UA_STATUSCODE_BADREFERENCETYPEIDINVALID;
         goto ret;
     }
@@ -119,18 +119,18 @@ UA_AddNodesResult AddNode(UA_Server *server, UA_Session *session, UA_Node **node
 
     if(UA_NodeId_isNull(&(*node)->nodeId)) {
         if(UA_NodeStore_insert(server->nodestore, node,
-                               UA_NODESTORE_INSERT_UNIQUE | UA_NODESTORE_INSERT_GETMANAGED) != UA_SUCCESS) {
+                               UA_NODESTORE_INSERT_UNIQUE | UA_NODESTORE_INSERT_GETMANAGED) != UA_STATUSCODE_GOOD) {
             result.statusCode = UA_STATUSCODE_BADOUTOFMEMORY;
             goto ret2;
         }
         result.addedNodeId = (*node)->nodeId; // cannot fail as unique nodeids are numeric
     } else {
-        if(UA_NodeId_copy(&(*node)->nodeId, &result.addedNodeId) != UA_SUCCESS) {
+        if(UA_NodeId_copy(&(*node)->nodeId, &result.addedNodeId) != UA_STATUSCODE_GOOD) {
             result.statusCode = UA_STATUSCODE_BADOUTOFMEMORY;
             goto ret2;
         }
 
-        if(UA_NodeStore_insert(server->nodestore, node, UA_NODESTORE_INSERT_GETMANAGED) != UA_SUCCESS) {
+        if(UA_NodeStore_insert(server->nodestore, node, UA_NODESTORE_INSERT_GETMANAGED) != UA_STATUSCODE_GOOD) {
             result.statusCode = UA_STATUSCODE_BADNODEIDEXISTS;  // todo: differentiate out of memory
             UA_NodeId_deleteMembers(&result.addedNodeId);
             goto ret2;
@@ -190,7 +190,7 @@ void Service_AddNodes(UA_Server *server, UA_Session *session,
     }
 
     if(UA_Array_new((void **)&response->results, request->nodesToAddSize, &UA_[UA_ADDNODESRESULT])
-       != UA_SUCCESS) {
+       != UA_STATUSCODE_GOOD) {
         response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY;
         return;
     }
@@ -212,7 +212,7 @@ static UA_Int32 AddSingleReference(UA_Node *node, UA_ReferenceNode *reference) {
         return UA_STATUSCODE_BADOUTOFMEMORY;
 
     UA_memcpy(new_refs, old_refs, sizeof(UA_ReferenceNode)*count);
-    if(UA_ReferenceNode_copy(reference, &new_refs[count]) != UA_SUCCESS) {
+    if(UA_ReferenceNode_copy(reference, &new_refs[count]) != UA_STATUSCODE_GOOD) {
         UA_free(new_refs);
         return UA_STATUSCODE_BADOUTOFMEMORY;
     }
@@ -220,19 +220,19 @@ static UA_Int32 AddSingleReference(UA_Node *node, UA_ReferenceNode *reference) {
     node->references     = new_refs;
     node->referencesSize = count+1;
     UA_free(old_refs);
-    return UA_SUCCESS;
+    return UA_STATUSCODE_GOOD;
 }
 
 UA_Int32 AddReference(UA_NodeStore *nodestore, UA_Node *node, UA_ReferenceNode *reference) {
     UA_Int32 retval = AddSingleReference(node, reference);
     UA_Node *targetnode;
     UA_ReferenceNode inversereference;
-    if(retval != UA_SUCCESS || nodestore == UA_NULL)
+    if(retval != UA_STATUSCODE_GOOD || nodestore == UA_NULL)
         return retval;
 
     // Do a copy every time?
-    if(UA_NodeStore_get(nodestore, &reference->targetId.nodeId, (const UA_Node **)&targetnode) != UA_SUCCESS)
-        return UA_ERROR;
+    if(UA_NodeStore_get(nodestore, &reference->targetId.nodeId, (const UA_Node **)&targetnode) != UA_STATUSCODE_GOOD)
+        return UA_STATUSCODE_BADINTERNALERROR;
 
     inversereference.referenceTypeId       = reference->referenceTypeId;
     inversereference.isInverse             = !reference->isInverse;

src/server/ua_services_session.c

@@ -2,6 +2,7 @@
 #include "ua_server.h"
 #include "ua_session_manager.h"
 #include "ua_statuscodes.h"
+#include "ua_util.h"
 
 void Service_CreateSession(UA_Server *server, UA_SecureChannel *channel,
                            const UA_CreateSessionRequest *request,
@@ -52,7 +53,7 @@ void Service_CloseSession(UA_Server *server, const UA_CloseSessionRequest *reque
 	}
 
 
-	if(UA_SessionManager_removeSession(server->sessionManager, &foundSession->sessionId) == UA_SUCCESS){
+	if(UA_SessionManager_removeSession(server->sessionManager, &foundSession->sessionId) == UA_STATUSCODE_GOOD){
 		response->responseHeader.serviceResult = UA_STATUSCODE_GOOD;
 	}else{
 		//still not 100% sure about the return code

src/server/ua_services_view.c

@@ -8,55 +8,43 @@ UA_Int32 Service_Browse_getReferenceDescription(UA_NodeStore *ns, UA_ReferenceNo
                                                 UA_UInt32 nodeClassMask, UA_UInt32 resultMask,
                                                 UA_ReferenceDescription *referenceDescription) {
     const UA_Node *foundNode;
-    if(UA_NodeStore_get(ns, &reference->targetId.nodeId, &foundNode) != UA_SUCCESS)
-        return UA_ERROR;
+    if(UA_NodeStore_get(ns, &reference->targetId.nodeId, &foundNode) != UA_STATUSCODE_GOOD)
+        return UA_STATUSCODE_BADINTERNALERROR;
 
     UA_NodeId_copy(&foundNode->nodeId, &referenceDescription->nodeId.nodeId);
     //TODO ExpandedNodeId is a mockup
     referenceDescription->nodeId.serverIndex = 0;
     referenceDescription->nodeId.namespaceUri.length = -1;
 
-    UA_UInt32 mask = 0;
-    for(mask = 0x01;mask <= 0x40;mask *= 2) {
-        switch(mask & (resultMask)) {
-        case UA_BROWSERESULTMASK_REFERENCETYPEID:
-            UA_NodeId_copy(&reference->referenceTypeId, &referenceDescription->referenceTypeId);
-            break;
-
-        case UA_BROWSERESULTMASK_ISFORWARD:
-            referenceDescription->isForward = !reference->isInverse;
-            break;
-
-        case UA_BROWSERESULTMASK_NODECLASS:
-            UA_NodeClass_copy(&foundNode->nodeClass, &referenceDescription->nodeClass);
-            break;
-
-        case UA_BROWSERESULTMASK_BROWSENAME:
-            UA_QualifiedName_copy(&foundNode->browseName, &referenceDescription->browseName);
-            break;
-
-        case UA_BROWSERESULTMASK_DISPLAYNAME:
-            UA_LocalizedText_copy(&foundNode->displayName, &referenceDescription->displayName);
-            break;
-
-        case UA_BROWSERESULTMASK_TYPEDEFINITION:
-            if(foundNode->nodeClass != UA_NODECLASS_OBJECT &&
-               foundNode->nodeClass != UA_NODECLASS_VARIABLE)
-                break;
-
-            for(UA_Int32 i = 0;i < foundNode->referencesSize;i++) {
-                UA_ReferenceNode *ref = &foundNode->references[i];
-                if(ref->referenceTypeId.identifier.numeric == 40 /* hastypedefinition */) {
-                    UA_ExpandedNodeId_copy(&ref->targetId, &referenceDescription->typeDefinition);
-                    break;
-                }
+    /* UA_UInt32 mask = 0; */
+    /* for(mask = 0x01;mask <= 0x40;mask *= 2) { */
+    /*     switch(mask & (resultMask)) { */
+    if(resultMask & UA_BROWSERESULTMASK_REFERENCETYPEID)
+        UA_NodeId_copy(&reference->referenceTypeId, &referenceDescription->referenceTypeId);
+    if(resultMask & UA_BROWSERESULTMASK_ISFORWARD)
+        referenceDescription->isForward = !reference->isInverse;
+    if(resultMask & UA_BROWSERESULTMASK_NODECLASS)
+        UA_NodeClass_copy(&foundNode->nodeClass, &referenceDescription->nodeClass);
+    if(resultMask & UA_BROWSERESULTMASK_BROWSENAME)
+        UA_QualifiedName_copy(&foundNode->browseName, &referenceDescription->browseName);
+    if(resultMask & UA_BROWSERESULTMASK_DISPLAYNAME)
+        UA_LocalizedText_copy(&foundNode->displayName, &referenceDescription->displayName);
+    if(resultMask & UA_BROWSERESULTMASK_TYPEDEFINITION) {
+        if(foundNode->nodeClass != UA_NODECLASS_OBJECT &&
+           foundNode->nodeClass != UA_NODECLASS_VARIABLE)
+            goto end;
+        
+        for(UA_Int32 i = 0;i < foundNode->referencesSize;i++) {
+            UA_ReferenceNode *ref = &foundNode->references[i];
+            if(ref->referenceTypeId.identifier.numeric == 40 /* hastypedefinition */) {
+                UA_ExpandedNodeId_copy(&ref->targetId, &referenceDescription->typeDefinition);
+                goto end;
             }
-            break;
         }
     }
-
+ end:
     UA_NodeStore_releaseManagedNode(foundNode);
-    return UA_SUCCESS;
+    return UA_STATUSCODE_GOOD;
 }
 
 /* singly-linked list */
@@ -80,7 +68,7 @@ static UA_UInt32 walkReferenceTree(UA_NodeStore *ns, const UA_ReferenceTypeNode
         if(current->references[i].referenceTypeId.identifier.numeric == 45 /* HasSubtype */ &&
            current->references[i].isInverse == UA_FALSE) {
             const UA_Node *node;
-            if(UA_NodeStore_get(ns, &current->references[i].targetId.nodeId, &node) == UA_SUCCESS
+            if(UA_NodeStore_get(ns, &current->references[i].targetId.nodeId, &node) == UA_STATUSCODE_GOOD
                && node->nodeClass == UA_NODECLASS_REFERENCETYPE) {
                 count += walkReferenceTree(ns, (UA_ReferenceTypeNode *)node, list);
                 UA_NodeStore_releaseManagedNode(node);
@@ -99,9 +87,9 @@ static UA_Int32 findSubReferenceTypes(UA_NodeStore *ns, UA_NodeId *rootReference
 
     // walk the tree
     const UA_ReferenceTypeNode *root;
-    if(UA_NodeStore_get(ns, rootReferenceType, (const UA_Node **)&root) != UA_SUCCESS ||
+    if(UA_NodeStore_get(ns, rootReferenceType, (const UA_Node **)&root) != UA_STATUSCODE_GOOD ||
        root->nodeClass != UA_NODECLASS_REFERENCETYPE)
-        return UA_ERROR;
+        return UA_STATUSCODE_BADINTERNALERROR;
     count = walkReferenceTree(ns, root, &list);
     UA_NodeStore_releaseManagedNode((const UA_Node *)root);
 
@@ -115,7 +103,7 @@ static UA_Int32 findSubReferenceTypes(UA_NodeStore *ns, UA_NodeId *rootReference
     }
     *idcount = count;
 
-    return UA_SUCCESS;
+    return UA_STATUSCODE_GOOD;
 }
 
 /* is this a relevant reference? */
@@ -144,7 +132,7 @@ static void Service_Browse_getBrowseResult(UA_NodeStore         *ns,
     const UA_Node *node;
     UA_NodeId     *relevantReferenceTypes = UA_NULL;
     UA_UInt32      relevantReferenceTypesCount = 0;
-    if(UA_NodeStore_get(ns, &browseDescription->nodeId, &node) != UA_SUCCESS) {
+    if(UA_NodeStore_get(ns, &browseDescription->nodeId, &node) != UA_STATUSCODE_GOOD) {
         browseResult->statusCode = UA_STATUSCODE_BADNODEIDUNKNOWN;
         return;
     }
@@ -156,7 +144,7 @@ static void Service_Browse_getBrowseResult(UA_NodeStore         *ns,
     // discover the relevant subtypes
     if(!browseDescription->includeSubtypes ||
        findSubReferenceTypes(ns, &browseDescription->referenceTypeId, &relevantReferenceTypes,
-                             &relevantReferenceTypesCount) != UA_SUCCESS) {
+                             &relevantReferenceTypesCount) != UA_STATUSCODE_GOOD) {
         if(!(relevantReferenceTypes = UA_alloc(sizeof(UA_NodeId)))) {
             return;
         }
@@ -192,8 +180,7 @@ static void Service_Browse_getBrowseResult(UA_NodeStore         *ns,
             continue;
 
         if(Service_Browse_getReferenceDescription(ns, &node->references[i], browseDescription->nodeClassMask,
-                                                  browseDescription->resultMask,
-                                                  &browseResult->references[j]) != UA_SUCCESS)
+                                                  browseDescription->resultMask, &browseResult->references[j]) != UA_STATUSCODE_GOOD)
             browseResult->statusCode = UA_STATUSCODE_UNCERTAINNOTALLNODESAVAILABLE;
         j++;
     }
@@ -216,7 +203,7 @@ void Service_Browse(UA_Server *server, UA_Session *session,
     }
 
     if(UA_Array_new((void **)&(response->results), request->nodesToBrowseSize, &UA_[UA_BROWSERESULT])
-       != UA_SUCCESS) {
+       != UA_STATUSCODE_GOOD) {
         response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY;
         return;
     }
@@ -242,7 +229,7 @@ void Service_TranslateBrowsePathsToNodeIds(UA_Server *server, UA_Session *sessio
     response->resultsSize = request->browsePathsSize;
     // _init of the elements is done in Array_new
     if(UA_Array_new((void **)&response->results, request->browsePathsSize, &UA_[UA_BROWSEPATHRESULT])
-       != UA_SUCCESS) {
+       != UA_STATUSCODE_GOOD) {
         response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY;
         return;
     }

src/server/ua_session_manager.c

@@ -22,9 +22,8 @@ struct UA_SessionManager {
     UA_DateTime  sessionTimeout;
 };
 
-UA_Int32 UA_SessionManager_new(UA_SessionManager **sessionManager, UA_UInt32 maxSessionCount,
-                               UA_UInt32 sessionTimeout, UA_UInt32 startSessionId) {
-    UA_Int32 retval = UA_SUCCESS;
+UA_StatusCode UA_SessionManager_new(UA_SessionManager **sessionManager, UA_UInt32 maxSessionCount,
+                                    UA_UInt32 sessionTimeout, UA_UInt32 startSessionId) {
     if(!(*sessionManager = UA_alloc(sizeof(UA_SessionManager))))
         return UA_STATUSCODE_BADOUTOFMEMORY;
     LIST_INIT(&(*sessionManager)->sessions);
@@ -32,10 +31,10 @@ UA_Int32 UA_SessionManager_new(UA_SessionManager **sessionManager, UA_UInt32 max
     (*sessionManager)->lastSessionId   = startSessionId;
     (*sessionManager)->sessionTimeout  = sessionTimeout;
     (*sessionManager)->currentSessionCount = 0;
-    return retval;
+    return UA_STATUSCODE_GOOD;
 }
 
-UA_Int32 UA_SessionManager_delete(UA_SessionManager *sessionManager) {
+void UA_SessionManager_delete(UA_SessionManager *sessionManager) {
     struct session_list_entry *current = LIST_FIRST(&sessionManager->sessions);
     while(current) {
         LIST_REMOVE(current, pointers);
@@ -46,13 +45,12 @@ UA_Int32 UA_SessionManager_delete(UA_SessionManager *sessionManager) {
         current = LIST_FIRST(&sessionManager->sessions);
     }
     UA_free(sessionManager);
-    return UA_SUCCESS;
 }
 
-UA_Int32 UA_SessionManager_getSessionById(UA_SessionManager *sessionManager, UA_NodeId *sessionId, UA_Session **session) {
+UA_StatusCode UA_SessionManager_getSessionById(UA_SessionManager *sessionManager, UA_NodeId *sessionId, UA_Session **session) {
     if(sessionManager == UA_NULL) {
         *session = UA_NULL;
-        return UA_ERROR;
+        return UA_STATUSCODE_BADINTERNALERROR;
     }
 
     struct session_list_entry *current = UA_NULL;
@@ -63,19 +61,19 @@ UA_Int32 UA_SessionManager_getSessionById(UA_SessionManager *sessionManager, UA_
 
     if(!current) {
         *session = UA_NULL;
-        return UA_ERROR;
+        return UA_STATUSCODE_BADINTERNALERROR;
     }
 
     // Lifetime handling is not done here, but in a regular cleanup by the
     // server. If the session still exists, then it is valid.
     *session = &current->session;
-    return UA_SUCCESS;
+    return UA_STATUSCODE_GOOD;
 }
 
-UA_Int32 UA_SessionManager_getSessionByToken(UA_SessionManager *sessionManager, UA_NodeId *token, UA_Session **session) {
+UA_StatusCode UA_SessionManager_getSessionByToken(UA_SessionManager *sessionManager, UA_NodeId *token, UA_Session **session) {
     if(sessionManager == UA_NULL) {
         *session = UA_NULL;
-        return UA_ERROR;
+        return UA_STATUSCODE_BADINTERNALERROR;
     }
 
     struct session_list_entry *current = UA_NULL;
@@ -86,13 +84,13 @@ UA_Int32 UA_SessionManager_getSessionByToken(UA_SessionManager *sessionManager,
 
     if(!current) {
         *session = UA_NULL;
-        return UA_ERROR;
+        return UA_STATUSCODE_BADINTERNALERROR;
     }
 
     // Lifetime handling is not done here, but in a regular cleanup by the
     // server. If the session still exists, then it is valid.
     *session = &current->session;
-    return UA_SUCCESS;
+    return UA_STATUSCODE_GOOD;
 }
 
 /** Creates and adds a session. */
@@ -121,7 +119,7 @@ UA_StatusCode UA_SessionManager_createSession(UA_SessionManager *sessionManager,
     return UA_STATUSCODE_GOOD;
 }
 
-UA_Int32 UA_SessionManager_removeSession(UA_SessionManager *sessionManager, UA_NodeId  *sessionId) {
+UA_StatusCode UA_SessionManager_removeSession(UA_SessionManager *sessionManager, UA_NodeId  *sessionId) {
     struct session_list_entry *current = UA_NULL;
     LIST_FOREACH(current, &sessionManager->sessions, pointers) {
         if(UA_NodeId_equal(&current->session.sessionId, sessionId) == UA_EQUAL)
@@ -129,12 +127,12 @@ UA_Int32 UA_SessionManager_removeSession(UA_SessionManager *sessionManager, UA_N
     }
 
     if(!current)
-        return UA_ERROR;
+        return UA_STATUSCODE_BADINTERNALERROR;
 
     LIST_REMOVE(current, pointers);
     if(current->session.channel)
         current->session.channel->session = UA_NULL; // the channel is no longer attached to a session
     UA_Session_deleteMembers(&current->session);
     UA_free(current);
-    return UA_SUCCESS;
+    return UA_STATUSCODE_GOOD;
 }

src/server/ua_session_manager.h

@@ -4,16 +4,16 @@
 #include "ua_server.h"
 #include "ua_session.h"
 
-UA_Int32 UA_SessionManager_new(UA_SessionManager **sessionManager, UA_UInt32 maxSessionCount,
-                               UA_UInt32 sessionLifetime, UA_UInt32 startSessionId);
+UA_StatusCode UA_SessionManager_new(UA_SessionManager **sessionManager, UA_UInt32 maxSessionCount,
+                                    UA_UInt32 sessionLifetime, UA_UInt32 startSessionId);
 
-UA_Int32 UA_SessionManager_delete(UA_SessionManager *sessionManager);
+void UA_SessionManager_delete(UA_SessionManager *sessionManager);
 
 UA_StatusCode UA_SessionManager_createSession(UA_SessionManager *sessionManager,
                                               UA_SecureChannel *channel, UA_Session **session);
 
-UA_Int32 UA_SessionManager_removeSession(UA_SessionManager *sessionManager,
-                                         UA_NodeId         *sessionId);
+UA_StatusCode UA_SessionManager_removeSession(UA_SessionManager *sessionManager,
+                                              UA_NodeId         *sessionId);
 
 /**
  * @brief finds the session which is identified by the sessionId
@@ -21,16 +21,16 @@ UA_Int32 UA_SessionManager_removeSession(UA_SessionManager *sessionManager,
  * @param session the session object is returned if no error occurs
  * @return error code
  */
-UA_Int32 UA_SessionManager_getSessionById(UA_SessionManager *sessionManager,
-                                          UA_NodeId *sessionId, UA_Session **session);
+UA_StatusCode UA_SessionManager_getSessionById(UA_SessionManager *sessionManager,
+                                               UA_NodeId *sessionId, UA_Session **session);
 
 /**
  * @param token authentication token which is used to get the session object
  * @param session output, session object which is identified by the authentication token
  * @return error code
  */
-UA_Int32 UA_SessionManager_getSessionByToken(UA_SessionManager *sessionManager,
-                                             UA_NodeId *token, UA_Session **session);
+UA_StatusCode UA_SessionManager_getSessionByToken(UA_SessionManager *sessionManager,
+                                                  UA_NodeId *token, UA_Session **session);
 
 //UA_Int32 UA_SessionManager_updateSessions();
 //UA_Int32 UA_SessionManager_generateToken(UA_Session session, UA_Int32 requestedLifeTime, SecurityTokenRequestType requestType, UA_ChannelSecurityToken* newToken);

src/ua_connection.c

@@ -5,19 +5,17 @@ UA_ConnectionConfig UA_ConnectionConfig_standard = { .protocolVersion = 0,    .s
                                                      .recvBufferSize  = 65536, .maxMessageSize = 65536,
                                                      .maxChunkCount   = 1 };
 
-
-UA_Int32 UA_Connection_init(UA_Connection *connection, UA_ConnectionConfig localConf, void *callbackHandle,
-                            UA_Connection_closeCallback close, UA_Connection_writeCallback write) {
+UA_StatusCode UA_Connection_init(UA_Connection *connection, UA_ConnectionConfig localConf, void *callbackHandle,
+                                 UA_Connection_closeCallback close, UA_Connection_writeCallback write) {
     connection->state          = UA_CONNECTION_OPENING;
     connection->localConf      = localConf;
     connection->channel        = UA_NULL;
     connection->callbackHandle = callbackHandle;
     connection->close          = close;
     connection->write          = write;
-    return UA_SUCCESS;
+    return UA_STATUSCODE_GOOD;
 }
 
-UA_Int32 UA_Connection_deleteMembers(UA_Connection *connection) {
+void UA_Connection_deleteMembers(UA_Connection *connection) {
     UA_free(connection->callbackHandle);
-    return UA_SUCCESS;
 }

src/ua_securechannel.c

@@ -31,30 +31,26 @@ UA_Boolean UA_SecureChannel_compare(UA_SecureChannel *sc1, UA_SecureChannel *sc2
 }
 
 //TODO implement real nonce generator - DUMMY function
-UA_Int32 UA_SecureChannel_generateNonce(UA_ByteString *nonce) {
+UA_StatusCode UA_SecureChannel_generateNonce(UA_ByteString *nonce) {
     if(!(nonce->data = UA_alloc(1)))
         return UA_STATUSCODE_BADOUTOFMEMORY;
     nonce->length  = 1;
     nonce->data[0] = 'a';
-    return UA_SUCCESS;
+    return UA_STATUSCODE_GOOD;
 }
 
-UA_Int32 UA_SecureChannel_updateRequestId(UA_SecureChannel *channel, UA_UInt32 requestId) {
+UA_StatusCode UA_SecureChannel_updateRequestId(UA_SecureChannel *channel, UA_UInt32 requestId) {
     //TODO review checking of request id
-    if(channel->requestId+1  == requestId) {
-        channel->requestId++;
-        return UA_SUCCESS;
-    }
-    return UA_ERROR;
+    if(channel->requestId+1 != requestId)
+        return UA_STATUSCODE_BADINTERNALERROR;
+    channel->requestId++;
+    return UA_STATUSCODE_GOOD;
 }
 
-UA_Int32 UA_SecureChannel_updateSequenceNumber(UA_SecureChannel *channel,
-                                               UA_UInt32         sequenceNumber) {
+UA_Int32 UA_SecureChannel_updateSequenceNumber(UA_SecureChannel *channel, UA_UInt32 sequenceNumber) {
     //TODO review checking of sequence
-    if(channel->sequenceNumber+1  == sequenceNumber) {
-        channel->sequenceNumber++;
-        return UA_SUCCESS;
-    }
-    return UA_ERROR;
-
+    if(channel->sequenceNumber+1  != sequenceNumber)
+        return UA_STATUSCODE_BADINTERNALERROR;
+    channel->sequenceNumber++;
+    return UA_STATUSCODE_GOOD;
 }

src/ua_securechannel.h

@@ -33,7 +33,7 @@ void UA_SecureChannel_deleteMembers(UA_SecureChannel *channel);
 void UA_SecureChannel_delete(UA_SecureChannel *channel);
 UA_Boolean UA_SecureChannel_compare(UA_SecureChannel *sc1, UA_SecureChannel *sc2);
 
-UA_Int32 UA_SecureChannel_generateNonce(UA_ByteString *nonce);
+UA_StatusCode UA_SecureChannel_generateNonce(UA_ByteString *nonce);
 UA_Int32 UA_SecureChannel_updateRequestId(UA_SecureChannel *channel, UA_UInt32 requestId);
 UA_Int32 UA_SecureChannel_updateSequenceNumber(UA_SecureChannel *channel, UA_UInt32 sequenceNumber);
 

src/ua_session.c

@@ -41,23 +41,20 @@ UA_Session adminSession = {
     .validTill = UA_INT64_MAX,
     .channel = UA_NULL};
 
-UA_Int32 UA_Session_new(UA_Session **session) {
+UA_StatusCode UA_Session_new(UA_Session **session) {
     if(!(*session = UA_alloc(sizeof(UA_Session))))
         return UA_STATUSCODE_BADOUTOFMEMORY;
     UA_Session_init(*session);
-    return UA_SUCCESS;
+    return UA_STATUSCODE_GOOD;
 }
 
 /* mock up function to generate tokens for authentication */
-UA_Int32 UA_Session_generateToken(UA_NodeId *newToken) {
+UA_StatusCode UA_Session_generateToken(UA_NodeId *newToken) {
     //Random token generation
-    UA_Int32 retval = UA_SUCCESS;
+    UA_StatusCode retval = UA_STATUSCODE_GOOD;
     srand(time(NULL));
 
-    UA_Int32 i = 0;
-    UA_Int32 r = 0;
-    //retval |= UA_NodeId_new(newToken);
-
+    UA_Int32 i, r = 0;
     newToken->namespaceIndex = 0; // where else?
     newToken->identifierType = UA_NODEIDTYPE_GUID;
     newToken->identifier.guid.data1 = rand();
@@ -108,18 +105,18 @@ UA_Boolean UA_Session_compare(UA_Session *session1, UA_Session *session2) {
     return UA_FALSE;
 }
 
-UA_Int32 UA_Session_setExpirationDate(UA_Session *session) {
+UA_StatusCode UA_Session_setExpirationDate(UA_Session *session) {
     if(!session)
-        return UA_ERROR;
+        return UA_STATUSCODE_BADINTERNALERROR;
 
     session->validTill = UA_DateTime_now() + session->timeout * 100000; //timeout in ms
-    return UA_SUCCESS;
+    return UA_STATUSCODE_GOOD;
 }
 
-UA_Int32 UA_Session_getPendingLifetime(UA_Session *session, UA_Double *pendingLifetime_ms) {
+UA_StatusCode UA_Session_getPendingLifetime(UA_Session *session, UA_Double *pendingLifetime_ms) {
     if(!session)
-        return UA_ERROR;
+        return UA_STATUSCODE_BADINTERNALERROR;
 
     *pendingLifetime_ms = (session->validTill - UA_DateTime_now())/10000000; //difference in ms
-    return UA_SUCCESS;
+    return UA_STATUSCODE_GOOD;
 }

src/ua_session.h

@@ -25,7 +25,7 @@ struct UA_Session {
 extern UA_Session anonymousSession; ///< If anonymous access is allowed, this session is used internally (Session ID: 0)
 extern UA_Session adminSession; ///< Local access to the services (for startup and maintenance) uses this Session with all possible access rights (Session ID: 1)
 
-UA_Int32 UA_Session_new(UA_Session **session);
+UA_StatusCode UA_Session_new(UA_Session **session);
 void UA_Session_init(UA_Session *session);
 void UA_Session_delete(UA_Session *session);
 void UA_Session_deleteMembers(UA_Session *session);
@@ -34,10 +34,10 @@ void UA_Session_deleteMembers(UA_Session *session);
 UA_Boolean UA_Session_compare(UA_Session *session1, UA_Session *session2);
 
 /** If any activity on a session happens, the timeout must be extended */
-UA_Int32 UA_Session_updateLifetime(UA_Session *session);
+UA_StatusCode UA_Session_updateLifetime(UA_Session *session);
 /** Set up the point in time till the session is valid */
-UA_Int32 UA_Session_setExpirationDate(UA_Session *session);
+UA_StatusCode UA_Session_setExpirationDate(UA_Session *session);
 /** Gets the sessions pending lifetime (calculated from the timeout which was set) */
-UA_Int32 UA_Session_getPendingLifetime(UA_Session *session, UA_Double *pendingLifetime);
+UA_StatusCode UA_Session_getPendingLifetime(UA_Session *session, UA_Double *pendingLifetime);
 
 #endif /* UA_SESSION_H_ */

src/ua_transport.c

@@ -5,33 +5,32 @@
 #include "ua_util.h"
 
 UA_TYPE_DEFAULT(UA_MessageType)
-UA_Int32 UA_MessageType_calcSizeBinary(UA_MessageType const *ptr) {
-    if(ptr == UA_NULL) return sizeof(UA_MessageType);
+UA_UInt32 UA_MessageType_calcSizeBinary(UA_MessageType const *ptr) {
     return 3 * sizeof(UA_Byte);
 }
 
-UA_Int32 UA_MessageType_encodeBinary(UA_MessageType const *src, UA_ByteString *dst, UA_UInt32 *offset) {
-    UA_Int32 retval = UA_SUCCESS;
-    UA_Byte  tmpBuf[3];
+UA_StatusCode UA_MessageType_encodeBinary(UA_MessageType const *src, UA_ByteString *dst, UA_UInt32 *offset) {
+    UA_StatusCode retval = UA_STATUSCODE_GOOD;
+    UA_Byte tmpBuf[3];
     tmpBuf[0] = (UA_Byte)((((UA_Int32)*src) >> 16) );
     tmpBuf[1] = (UA_Byte)((((UA_Int32)*src) >> 8));
     tmpBuf[2] = (UA_Byte)(((UA_Int32)*src));
 
-    retval   |= UA_Byte_encodeBinary(&(tmpBuf[0]), dst, offset);
-    retval   |= UA_Byte_encodeBinary(&(tmpBuf[1]), dst, offset);
-    retval   |= UA_Byte_encodeBinary(&(tmpBuf[2]), dst, offset);
+    retval |= UA_Byte_encodeBinary(&(tmpBuf[0]), dst, offset);
+    retval |= UA_Byte_encodeBinary(&(tmpBuf[1]), dst, offset);
+    retval |= UA_Byte_encodeBinary(&(tmpBuf[2]), dst, offset);
     return retval;
 }
 
-UA_Int32 UA_MessageType_decodeBinary(UA_ByteString const *src, UA_UInt32 *offset, UA_MessageType *dst) {
+UA_StatusCode UA_MessageType_decodeBinary(UA_ByteString const *src, UA_UInt32 *offset, UA_MessageType *dst) {
     if(*offset+3 > (UA_UInt32)src->length)
-        return UA_ERROR;
-    UA_Int32 retval = UA_SUCCESS;
-    UA_Byte  tmpBuf[3];
+        return UA_STATUSCODE_BADDECODINGERROR;
+    UA_StatusCode retval = UA_STATUSCODE_GOOD;
+    UA_Byte tmpBuf[3];
     retval |= UA_Byte_decodeBinary(src, offset, &(tmpBuf[0])); //messageType to Byte representation
     retval |= UA_Byte_decodeBinary(src, offset, &(tmpBuf[1]));
     retval |= UA_Byte_decodeBinary(src, offset, &(tmpBuf[2]));
-    *dst    = (UA_MessageType)((UA_Int32)(tmpBuf[0]<<16) + (UA_Int32)(tmpBuf[1]<<8) + (UA_Int32)(tmpBuf[2]));
+    *dst = (UA_MessageType)((UA_Int32)(tmpBuf[0]<<16) + (UA_Int32)(tmpBuf[1]<<8) + (UA_Int32)(tmpBuf[2]));
     return retval;
 }
 

src/ua_types.c

@@ -19,7 +19,6 @@
 
 /* Boolean */
 void UA_Boolean_init(UA_Boolean *p) {
-    if(!p) return;
     *p = UA_FALSE;
 }
 
@@ -29,7 +28,6 @@ UA_TYPE_NEW_DEFAULT(UA_Boolean)
 UA_TYPE_COPY_DEFAULT(UA_Boolean)
 #ifdef DEBUG
 void UA_Boolean_print(const UA_Boolean *p, FILE *stream) {
-    if(p == UA_NULL || stream == UA_NULL) return;
     if(*p) fprintf(stream, "UA_TRUE");
     else fprintf(stream, "UA_FALSE");
 }
@@ -39,7 +37,7 @@ void UA_Boolean_print(const UA_Boolean *p, FILE *stream) {
 UA_TYPE_DEFAULT(UA_SByte)
 #ifdef DEBUG
 void UA_SByte_print(const UA_SByte *p, FILE *stream) {
-    if(p == UA_NULL || stream == UA_NULL) return;
+    if(!p || !stream) return;
     UA_SByte x = *p;
     fprintf(stream, "%s%x\n", x < 0 ? "-" : "", x < 0 ? -x : x);
 }
@@ -49,7 +47,7 @@ void UA_SByte_print(const UA_SByte *p, FILE *stream) {
 UA_TYPE_DEFAULT(UA_Byte)
 #ifdef DEBUG
 void UA_Byte_print(const UA_Byte *p, FILE *stream) {
-    if(p == UA_NULL || stream == UA_NULL) return;
+    if(!p || !stream) return;
     fprintf(stream, "%x", *p);
 }
 #endif
@@ -58,7 +56,7 @@ void UA_Byte_print(const UA_Byte *p, FILE *stream) {
 UA_TYPE_DEFAULT(UA_Int16)
 #ifdef DEBUG
 void UA_Int16_print(const UA_Int16 *p, FILE *stream) {
-    if(p == UA_NULL || stream == UA_NULL) return;
+    if(!p || !stream) return;
     fprintf(stream, "%d", *p);
 }
 #endif
@@ -67,7 +65,7 @@ void UA_Int16_print(const UA_Int16 *p, FILE *stream) {
 UA_TYPE_DEFAULT(UA_UInt16)
 #ifdef DEBUG
 void UA_UInt16_print(const UA_UInt16 *p, FILE *stream) {
-    if(p == UA_NULL || stream == UA_NULL) return;
+    if(!p || !stream) return;
     fprintf(stream, "%u", *p);
 }
 #endif
@@ -76,7 +74,7 @@ void UA_UInt16_print(const UA_UInt16 *p, FILE *stream) {
 UA_TYPE_DEFAULT(UA_Int32)
 #ifdef DEBUG
 void UA_Int32_print(const UA_Int32 *p, FILE *stream) {
-    if(p == UA_NULL || stream == UA_NULL) return;
+    if(!p || !stream) return;
     fprintf(stream, "%d", *p);
 }
 
@@ -86,7 +84,7 @@ void UA_Int32_print(const UA_Int32 *p, FILE *stream) {
 UA_TYPE_DEFAULT(UA_UInt32)
 #ifdef DEBUG
 void UA_UInt32_print(const UA_UInt32 *p, FILE *stream) {
-    if(p == UA_NULL || stream == UA_NULL) return;
+    if(!p || !stream) return;
     fprintf(stream, "%u", *p);
 }
 #endif
@@ -95,7 +93,7 @@ void UA_UInt32_print(const UA_UInt32 *p, FILE *stream) {
 UA_TYPE_DEFAULT(UA_Int64)
 #ifdef DEBUG
 void UA_Int64_print(const UA_Int64 *p, FILE *stream) {
-    if(p == UA_NULL || stream == UA_NULL) return;
+    if(!p || !stream) return;
     fprintf(stream, "%" PRIi64, *p);
 }
 #endif
@@ -104,7 +102,7 @@ void UA_Int64_print(const UA_Int64 *p, FILE *stream) {
 UA_TYPE_DEFAULT(UA_UInt64)
 #ifdef DEBUG
 void UA_UInt64_print(const UA_UInt64 *p, FILE *stream) {
-    if(p == UA_NULL || stream == UA_NULL) return;
+    if(!p || !stream) return;
     fprintf(stream, "%" PRIu64, *p);
 }
 #endif
@@ -113,7 +111,7 @@ void UA_UInt64_print(const UA_UInt64 *p, FILE *stream) {
 UA_TYPE_DEFAULT(UA_Float)
 #ifdef DEBUG
 void UA_Float_print(const UA_Float *p, FILE *stream) {
-    if(p == UA_NULL || stream == UA_NULL) return;
+    if(!p || !stream) return;
     fprintf(stream, "%f", *p);
 }
 #endif
@@ -122,7 +120,7 @@ void UA_Float_print(const UA_Float *p, FILE *stream) {
 UA_TYPE_DEFAULT(UA_Double)
 #ifdef DEBUG
 void UA_Double_print(const UA_Double *p, FILE *stream) {
-    if(p == UA_NULL || stream == UA_NULL) return;
+    if(!p || !stream) return;
     fprintf(stream, "%f", *p);
 }
 #endif
@@ -130,35 +128,31 @@ void UA_Double_print(const UA_Double *p, FILE *stream) {
 /* String */
 UA_TYPE_NEW_DEFAULT(UA_String)
 void UA_String_init(UA_String *p) {
-    if(!p) return;
     p->length = -1;
     p->data   = UA_NULL;
 }
 
 UA_TYPE_DELETE_DEFAULT(UA_String)
 void UA_String_deleteMembers(UA_String *p) {
-    if(p && p->length > 0 && p->data != UA_NULL) {
-        UA_free(p->data);
-        UA_String_init(p);
-    }
+    UA_free(p->data);
+    UA_String_init(p);
 }
 
-UA_Int32 UA_String_copy(UA_String const *src, UA_String *dst) {
-    if(!src || !dst) return UA_ERROR;
+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;
         UA_memcpy((void *)dst->data, src->data, src->length);
     }
     dst->length = src->length;
-    return UA_SUCCESS;
+    return UA_STATUSCODE_GOOD;
 }
 
 #ifdef DEBUG
 void UA_String_print(const UA_String *p, FILE *stream) {
-    if(p == UA_NULL || stream == UA_NULL) return;
     fprintf(stream, "(UA_String){%d,", p->length);
-    if(p->data != UA_NULL)
+    if(p->data)
         fprintf(stream, "\"%.*s\"}", p->length, p->data);
     else
         fprintf(stream, "UA_NULL}");
@@ -173,39 +167,33 @@ UA_Int32 UA_String_copycstring(char const *src, UA_String *dst) {
             return UA_STATUSCODE_BADOUTOFMEMORY;
         UA_memcpy((void *)dst->data, src, dst->length);
     }
-    return UA_SUCCESS;
+    return UA_STATUSCODE_GOOD;
 }
 
 #define UA_STRING_COPYPRINTF_BUFSIZE 1024
-UA_Int32 UA_String_copyprintf(char const *fmt, UA_String *dst, ...) {
-    UA_Int32 retval = UA_SUCCESS;
-    char     src[UA_STRING_COPYPRINTF_BUFSIZE];
-    UA_Int32 len;
-    va_list  ap;
+UA_StatusCode UA_String_copyprintf(char const *fmt, UA_String *dst, ...) {
+    char src[UA_STRING_COPYPRINTF_BUFSIZE];
+    va_list ap;
     va_start(ap, dst);
 #ifndef __MINGW32__
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
 #endif
     // vsnprintf should only take a literal and no variable to be secure
-    len = vsnprintf(src, UA_STRING_COPYPRINTF_BUFSIZE, fmt, ap);
+    UA_Int32 len = vsnprintf(src, UA_STRING_COPYPRINTF_BUFSIZE, fmt, ap);
 #ifndef __MINGW32__
 #pragma GCC diagnostic pop
 #endif
     va_end(ap);
-    if(len < 0) {  // FIXME: old glibc 2.0 would return -1 when truncated
-        dst->length = 0;
-        dst->data   = UA_NULL;
-        retval      = UA_ERR_INVALID_VALUE;
-    } else {
-        // since glibc 2.1 vsnprintf returns len that would have resulted if buf were large enough
-        dst->length = ( len > UA_STRING_COPYPRINTF_BUFSIZE ? UA_STRING_COPYPRINTF_BUFSIZE : len );
-        if((dst->data = UA_alloc(dst->length)))
-            UA_memcpy((void *)dst->data, src, dst->length);
-        else
-            retval = UA_STATUSCODE_BADOUTOFMEMORY;
-    }
-    return retval;
+    if(len < 0)  // FIXME: old glibc 2.0 would return -1 when truncated
+        return UA_STATUSCODE_BADINTERNALERROR;
+    // since glibc 2.1 vsnprintf returns len that would have resulted if buf were large enough
+    len = ( len > UA_STRING_COPYPRINTF_BUFSIZE ? UA_STRING_COPYPRINTF_BUFSIZE : len );
+    if(!(dst->data = UA_alloc(dst->length)))
+        return UA_STATUSCODE_BADOUTOFMEMORY;
+    UA_memcpy((void *)dst->data, src, len);
+    dst->length = len;
+    return UA_STATUSCODE_GOOD;
 }
 
 UA_EQUALITY UA_String_equal(const UA_String *string1, const UA_String *string2) {
@@ -228,9 +216,6 @@ void UA_String_printf(char const *label, const UA_String *string) {
 
 #ifdef DEBUG
 void UA_String_printx(char const *label, const UA_String *string) {
-    if(string == UA_NULL) {
-        printf("%s {NULL}\n", label); return;
-    }
     printf("%s {Length=%d, Data=", label, string->length);
     if(string->length > 0) {
         for(UA_Int32 i = 0;i < string->length;i++) {
@@ -316,7 +301,7 @@ UA_DateTimeStruct UA_DateTime_toStruct(UA_DateTime time) {
     return dateTimeStruct;
 }
 
-UA_Int32 UA_DateTime_toString(UA_DateTime time, UA_String *timeString) {
+UA_StatusCode UA_DateTime_toString(UA_DateTime time, UA_String *timeString) {
     // length of the string is 31 (incl. \0 at the end)
     if(!(timeString->data = UA_alloc(31)))
         return UA_STATUSCODE_BADOUTOFMEMORY;
@@ -325,7 +310,7 @@ UA_Int32 UA_DateTime_toString(UA_DateTime time, UA_String *timeString) {
     UA_DateTimeStruct tSt = UA_DateTime_toStruct(time);
     sprintf((char*)timeString->data, "%2d/%2d/%4d %2d:%2d:%2d.%3d.%3d.%3d", tSt.mounth, tSt.day, tSt.year,
             tSt.hour, tSt.min, tSt.sec, tSt.milliSec, tSt.microSec, tSt.nanoSec);
-    return UA_SUCCESS;
+    return UA_STATUSCODE_GOOD;
 }
 
 /* Guid */
@@ -339,7 +324,6 @@ UA_EQUALITY UA_Guid_equal(const UA_Guid *g1, const UA_Guid *g2) {
 }
 
 void UA_Guid_init(UA_Guid *p) {
-    if(!p) return;
     p->data1 = 0;
     p->data2 = 0;
     p->data3 = 0;
@@ -347,17 +331,14 @@ void UA_Guid_init(UA_Guid *p) {
 }
 
 UA_TYPE_NEW_DEFAULT(UA_Guid)
-UA_Int32 UA_Guid_copy(UA_Guid const *src, UA_Guid *dst) {
-    if(src == UA_NULL || dst == UA_NULL) return UA_ERROR;
+UA_StatusCode UA_Guid_copy(UA_Guid const *src, UA_Guid *dst) {
     UA_memcpy((void *)dst, (void *)src, sizeof(UA_Guid));
-    return UA_SUCCESS;
+    return UA_STATUSCODE_GOOD;
 }
 
 #ifdef DEBUG
 void UA_Guid_print(const UA_Guid *p, FILE *stream) {
-    if(p == UA_NULL || stream == UA_NULL) return;
-    fprintf(stream, "(UA_Guid){%u, %u %u {%x,%x,%x,%x,%x,%x,%x,%x}}", p->data1, p->data2, p->data3,
-            p->data4[0],
+    fprintf(stream, "(UA_Guid){%u, %u %u {%x,%x,%x,%x,%x,%x,%x,%x}}", p->data1, p->data2, p->data3, p->data4[0],
             p->data4[1], p->data4[2], p->data4[3], p->data4[4], p->data4[5], p->data4[6], p->data4[7]);
 }
 #endif
@@ -391,18 +372,21 @@ UA_Byte       UA_Byte_securityPoliceNoneData[] = "http://opcfoundation.org/UA/Se
 UA_ByteString UA_ByteString_securityPoliceNone =
 { sizeof(UA_Byte_securityPoliceNoneData)-1, UA_Byte_securityPoliceNoneData };
 
-UA_Int32 UA_ByteString_newMembers(UA_ByteString *p, UA_Int32 length) {
-    UA_Int32 retval = UA_SUCCESS;
+/** 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) {
     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->length = -1;
+
     p->data   = UA_NULL;
-    return retval;
+    if(length < 0)
+        p->length = -1;
+    else
+        p->length = 0;
+    return UA_STATUSCODE_GOOD;
 }
 
 /* XmlElement */
@@ -410,22 +394,18 @@ UA_TYPE_AS(UA_XmlElement, UA_ByteString)
 
 /* NodeId */
 void UA_NodeId_init(UA_NodeId *p) {
-    if(!p) return;
     p->identifierType = UA_NODEIDTYPE_NUMERIC;
     p->namespaceIndex = 0;
     memset(&p->identifier, 0, sizeof(p->identifier));
 }
 
 UA_TYPE_NEW_DEFAULT(UA_NodeId)
-UA_Int32 UA_NodeId_copy(UA_NodeId const *src, UA_NodeId *dst) {
-    UA_Int32 retval = UA_SUCCESS;
-    if(src == UA_NULL || dst == UA_NULL)
-        return UA_ERROR;
-
+UA_StatusCode UA_NodeId_copy(UA_NodeId const *src, UA_NodeId *dst) {
+    UA_StatusCode retval = UA_STATUSCODE_GOOD;
     switch(src->identifierType) {
     case UA_NODEIDTYPE_NUMERIC:
         *dst = *src;
-        return UA_SUCCESS;
+        return UA_STATUSCODE_GOOD;
         break;
 
     case UA_NODEIDTYPE_STRING: // Table 6, second entry
@@ -439,8 +419,14 @@ UA_Int32 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)
+        UA_NodeId_deleteMembers(dst);
     return retval;
 }
 
@@ -452,8 +438,6 @@ UA_Boolean UA_NodeId_isBasicType(UA_NodeId const *id) {
 
 UA_TYPE_DELETE_DEFAULT(UA_NodeId)
 void UA_NodeId_deleteMembers(UA_NodeId *p) {
-    if(!p) return;
-
     switch(p->identifierType) {
     case UA_NODEIDTYPE_NUMERIC:
         // nothing to do
@@ -474,9 +458,6 @@ void UA_NodeId_deleteMembers(UA_NodeId *p) {
 
 #ifdef DEBUG
 void UA_NodeId_print(const UA_NodeId *p, FILE *stream) {
-    if(p == UA_NULL || stream == UA_NULL)
-        return;
-
     fprintf(stream, "(UA_NodeId){");
     switch(p->identifierType) {
     case UA_NODEIDTYPE_NUMERIC:
@@ -528,7 +509,7 @@ void UA_NodeId_print(const UA_NodeId *p, FILE *stream) {
 #endif
 
 UA_EQUALITY UA_NodeId_equal(const UA_NodeId *n1, const UA_NodeId *n2) {
-    if(n1 == UA_NULL || n2 == UA_NULL || n1->namespaceIndex != n2->namespaceIndex)
+    if(n1->namespaceIndex != n2->namespaceIndex)
         return UA_NOT_EQUAL;
 
     switch(n1->identifierType) {
@@ -553,20 +534,24 @@ UA_EQUALITY UA_NodeId_equal(const UA_NodeId *n1, const UA_NodeId *n2) {
 UA_Boolean UA_NodeId_isNull(const UA_NodeId *p) {
     switch(p->identifierType) {
     case UA_NODEIDTYPE_NUMERIC:
-        if(p->namespaceIndex != 0 || p->identifier.numeric != 0) return UA_FALSE;
+        if(p->namespaceIndex != 0 || p->identifier.numeric != 0)
+            return UA_FALSE;
         break;
 
     case UA_NODEIDTYPE_STRING:
-        if(p->namespaceIndex != 0 || p->identifier.string.length != 0) return UA_FALSE;
+        if(p->namespaceIndex != 0 || p->identifier.string.length != 0)
+            return UA_FALSE;
         break;
 
     case UA_NODEIDTYPE_GUID:
         if(p->namespaceIndex != 0 ||
-           memcmp(&p->identifier.guid, (char[sizeof(UA_Guid)]) { 0 }, sizeof(UA_Guid)) != 0) return UA_FALSE;
+           memcmp(&p->identifier.guid, (char[sizeof(UA_Guid)]) { 0 }, sizeof(UA_Guid)) != 0)
+            return UA_FALSE;
         break;
 
     case UA_NODEIDTYPE_BYTESTRING:
-        if(p->namespaceIndex != 0 || p->identifier.byteString.length != 0) return UA_FALSE;
+        if(p->namespaceIndex != 0 || p->identifier.byteString.length != 0)
+            return UA_FALSE;
         break;
 
     default:
@@ -578,31 +563,29 @@ UA_Boolean UA_NodeId_isNull(const UA_NodeId *p) {
 /* ExpandedNodeId */
 UA_TYPE_DELETE_DEFAULT(UA_ExpandedNodeId)
 void UA_ExpandedNodeId_deleteMembers(UA_ExpandedNodeId *p) {
-    if(!p) return;
     UA_NodeId_deleteMembers(&p->nodeId);
     UA_String_deleteMembers(&p->namespaceUri);
 }
 
 void UA_ExpandedNodeId_init(UA_ExpandedNodeId *p) {
-    if(!p) return;
     UA_NodeId_init(&p->nodeId);
     UA_String_init(&p->namespaceUri);
     p->serverIndex = 0;
 }
 
 UA_TYPE_NEW_DEFAULT(UA_ExpandedNodeId)
-UA_Int32 UA_ExpandedNodeId_copy(UA_ExpandedNodeId const *src, UA_ExpandedNodeId *dst) {
-    UA_Int32 retval = UA_SUCCESS;
-    if(src == UA_NULL || dst == UA_NULL) return UA_ERROR;
-    UA_String_copy(&src->namespaceUri, &dst->namespaceUri);
-    UA_NodeId_copy(&src->nodeId, &dst->nodeId);
-    UA_UInt32_copy(&src->serverIndex, &dst->serverIndex);
+UA_StatusCode UA_ExpandedNodeId_copy(UA_ExpandedNodeId const *src, UA_ExpandedNodeId *dst) {
+    UA_StatusCode retval = UA_STATUSCODE_GOOD;
+    retval |= UA_String_copy(&src->namespaceUri, &dst->namespaceUri);
+    retval |= UA_NodeId_copy(&src->nodeId, &dst->nodeId);
+    dst->serverIndex = src->serverIndex;
+    if(retval)
+        UA_ExpandedNodeId_deleteMembers(dst);
     return retval;
 }
 
 #ifdef DEBUG
 void UA_ExpandedNodeId_print(const UA_ExpandedNodeId *p, FILE *stream) {
-    if(p == UA_NULL || stream == UA_NULL) return;
     fprintf(stream, "(UA_ExpandedNodeId){");
     UA_NodeId_print(&p->nodeId, stream);
     fprintf(stream, ",");
@@ -623,34 +606,31 @@ UA_TYPE_AS(UA_StatusCode, UA_UInt32)
 /* QualifiedName */
 UA_TYPE_DELETE_DEFAULT(UA_QualifiedName)
 void UA_QualifiedName_deleteMembers(UA_QualifiedName *p) {
-    if(!p) return;
     UA_String_deleteMembers(&p->name);
 }
 
 void UA_QualifiedName_init(UA_QualifiedName *p) {
-    if(!p) return;
     UA_String_init(&p->name);
     p->namespaceIndex = 0;
 }
 
 UA_TYPE_NEW_DEFAULT(UA_QualifiedName)
-UA_Int32 UA_QualifiedName_copy(UA_QualifiedName const *src, UA_QualifiedName *dst) {
-    UA_Int32 retval = UA_SUCCESS;
-    if(src == UA_NULL || dst == UA_NULL) return UA_ERROR;
-    retval |= UA_String_copy(&src->name, &dst->name);
-    retval |= UA_UInt16_copy(&src->namespaceIndex, &dst->namespaceIndex);
+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)
+        UA_QualifiedName_deleteMembers(dst);
     return retval;
 
 }
 
-UA_Int32 UA_QualifiedName_copycstring(char const *src, UA_QualifiedName *dst) {
+UA_StatusCode UA_QualifiedName_copycstring(char const *src, UA_QualifiedName *dst) {
     dst->namespaceIndex = 0;
     return UA_String_copycstring(src, &dst->name);
 }
 
 #ifdef DEBUG
 void UA_QualifiedName_print(const UA_QualifiedName *p, FILE *stream) {
-    if(p == UA_NULL || stream == UA_NULL) return;
     fprintf(stream, "(UA_QualifiedName){");
     UA_UInt16_print(&p->namespaceIndex, stream);
     fprintf(stream, ",");
@@ -669,42 +649,36 @@ void UA_QualifiedName_printf(char const *label, const UA_QualifiedName *qn) {
 /* LocalizedText */
 UA_TYPE_DELETE_DEFAULT(UA_LocalizedText)
 void UA_LocalizedText_deleteMembers(UA_LocalizedText *p) {
-    if(!p) return;
     UA_String_deleteMembers(&p->locale);
     UA_String_deleteMembers(&p->text);
 }
 
 void UA_LocalizedText_init(UA_LocalizedText *p) {
-    if(!p) return;
     UA_String_init(&p->locale);
     UA_String_init(&p->text);
 }
 
 UA_TYPE_NEW_DEFAULT(UA_LocalizedText)
-UA_Int32 UA_LocalizedText_copycstring(char const *src, UA_LocalizedText *dst) {
-    if(dst == UA_NULL) return UA_ERROR;
-    UA_LocalizedText_init(dst);
-
-    UA_Int32 retval = UA_SUCCESS;
-    retval |= UA_String_copycstring("en", &dst->locale); // TODO: Are language codes upper case?
-    if(retval != UA_SUCCESS) return retval;
+UA_StatusCode UA_LocalizedText_copycstring(char const *src, UA_LocalizedText *dst) {
+    UA_StatusCode retval = UA_String_copycstring("en", &dst->locale); // TODO: Are language codes upper case?
     retval |= UA_String_copycstring(src, &dst->text);
+    if(retval) {
+        UA_LocalizedText_deleteMembers(dst);
+        UA_LocalizedText_init(dst);
+    }
     return retval;
 }
 
-UA_Int32 UA_LocalizedText_copy(UA_LocalizedText const *src, UA_LocalizedText *dst) {
-    UA_Int32 retval = UA_SUCCESS;
-    if(!src || !dst) return UA_ERROR;
-    UA_LocalizedText_init(dst);
-    retval |= UA_String_copy(&src->locale, &dst->locale);
-    if(retval != UA_SUCCESS) return retval;
+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)
+        UA_LocalizedText_deleteMembers(dst);
     return retval;
 }
 
 #ifdef DEBUG
 void UA_LocalizedText_print(const UA_LocalizedText *p, FILE *stream) {
-    if(p == UA_NULL || stream == UA_NULL) return;
     fprintf(stream, "(UA_LocalizedText){");
     UA_String_print(&p->locale, stream);
     fprintf(stream, ",");
@@ -716,31 +690,28 @@ void UA_LocalizedText_print(const UA_LocalizedText *p, FILE *stream) {
 /* ExtensionObject */
 UA_TYPE_DELETE_DEFAULT(UA_ExtensionObject)
 void UA_ExtensionObject_deleteMembers(UA_ExtensionObject *p) {
-    if(!p) return;
     UA_NodeId_deleteMembers(&p->typeId);
     UA_ByteString_deleteMembers(&p->body);
 }
 
 void UA_ExtensionObject_init(UA_ExtensionObject *p) {
-    if(!p) return;
     UA_NodeId_init(&p->typeId);
     p->encoding = UA_EXTENSIONOBJECT_ENCODINGMASK_NOBODYISENCODED;
     UA_ByteString_init(&p->body);
 }
 
 UA_TYPE_NEW_DEFAULT(UA_ExtensionObject)
-UA_Int32 UA_ExtensionObject_copy(UA_ExtensionObject const *src, UA_ExtensionObject *dst) {
-    UA_Int32 retval = UA_SUCCESS;
-    if(src == UA_NULL || dst == UA_NULL) return UA_ERROR;
-    dst->encoding = src->encoding;
-    retval |= UA_ByteString_copy(&src->body, &dst->body);
+UA_StatusCode UA_ExtensionObject_copy(UA_ExtensionObject const *src, UA_ExtensionObject *dst) {
+    UA_StatusCode retval = UA_ByteString_copy(&src->body, &dst->body);
     retval |= UA_NodeId_copy(&src->typeId, &dst->typeId);
+    dst->encoding = src->encoding;
+    if(retval)
+        UA_ExtensionObject_deleteMembers(dst);
     return retval;
 }
 
 #ifdef DEBUG
 void UA_ExtensionObject_print(const UA_ExtensionObject *p, FILE *stream) {
-    if(p == UA_NULL || stream == UA_NULL) return;
     fprintf(stream, "(UA_ExtensionObject){");
     UA_NodeId_print(&p->typeId, stream);
     if(p->encoding == UA_EXTENSIONOBJECT_ENCODINGMASK_BODYISBYTESTRING)
@@ -757,12 +728,10 @@ void UA_ExtensionObject_print(const UA_ExtensionObject *p, FILE *stream) {
 /* DataValue */
 UA_TYPE_DELETE_DEFAULT(UA_DataValue)
 void UA_DataValue_deleteMembers(UA_DataValue *p) {
-    if(!p) return;
     UA_Variant_deleteMembers(&p->value);
 }
 
 void UA_DataValue_init(UA_DataValue *p) {
-    if(!p) return;
     p->encodingMask      = 0;
     p->serverPicoseconds = 0;
     UA_DateTime_init(&p->serverTimestamp);
@@ -773,22 +742,21 @@ void UA_DataValue_init(UA_DataValue *p) {
 }
 
 UA_TYPE_NEW_DEFAULT(UA_DataValue)
-UA_Int32 UA_DataValue_copy(UA_DataValue const *src, UA_DataValue *dst) {
-    UA_Int32 retval = UA_SUCCESS;
-    if(src == UA_NULL || dst == UA_NULL) return UA_ERROR;
-    UA_Byte_copy(&src->encodingMask, &dst->encodingMask);
-    UA_Int16_copy(&src->serverPicoseconds, &dst->serverPicoseconds);
-    UA_DateTime_copy(&src->serverTimestamp, &dst->serverTimestamp);
-    UA_Int16_copy(&src->sourcePicoseconds, &dst->sourcePicoseconds);
-    UA_DateTime_copy(&src->sourceTimestamp, &dst->sourceTimestamp);
-    UA_StatusCode_copy(&src->status, &dst->status);
-    UA_Variant_copy(&src->value, &dst->value);
+UA_StatusCode UA_DataValue_copy(UA_DataValue const *src, UA_DataValue *dst) {
+    UA_StatusCode retval = UA_DateTime_copy(&src->serverTimestamp, &dst->serverTimestamp);
+    retval |= UA_DateTime_copy(&src->sourceTimestamp, &dst->sourceTimestamp);
+    retval |= UA_Variant_copy(&src->value, &dst->value);
+    dst->encodingMask = src->encodingMask;
+    dst->serverPicoseconds = src->serverPicoseconds;
+    dst->sourcePicoseconds = src->sourcePicoseconds;
+    dst->status = src->status;
+    if(retval)
+        UA_DataValue_deleteMembers(dst);
     return retval;
 }
 
 #ifdef DEBUG
 void UA_DataValue_print(const UA_DataValue *p, FILE *stream) {
-    if(p == UA_NULL || stream == UA_NULL) return;
     fprintf(stream, "(UA_DataValue){");
     UA_Byte_print(&p->encodingMask, stream);
     fprintf(stream, ",");
@@ -811,7 +779,7 @@ void UA_DataValue_print(const UA_DataValue *p, FILE *stream) {
 UA_TYPE_DELETE_DEFAULT(UA_Variant)
 void UA_Variant_deleteMembers(UA_Variant *p) {
     if(p->storageType == UA_VARIANT_DATA) {
-        if(p->storage.data.dataPtr != UA_NULL) {
+        if(p->storage.data.dataPtr) {
             if(p->storage.data.arrayLength == 1)
                 p->vt->delete(p->storage.data.dataPtr);
             else
@@ -833,7 +801,6 @@ void UA_Variant_deleteMembers(UA_Variant *p) {
 
 UA_TYPE_NEW_DEFAULT(UA_Variant)
 void UA_Variant_init(UA_Variant *p) {
-    if(!p) return;
     p->storageType = UA_VARIANT_DATA;
     p->storage.data.arrayLength = -1;  // no element, p->data == UA_NULL
     p->storage.data.dataPtr        = UA_NULL;
@@ -842,46 +809,40 @@ void UA_Variant_init(UA_Variant *p) {
     p->vt = &UA_[UA_INVALIDTYPE];
 }
 
-/** It is not allowed to copy into a variant that points to an external data source. */
-UA_Int32 UA_Variant_copy(UA_Variant const *src, UA_Variant *dst) {
-    if(!src || !dst || dst->storageType == UA_VARIANT_DATASOURCE) return UA_ERROR;
-    UA_Int32 retval = UA_SUCCESS;
-
+/** 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;
+    UA_StatusCode retval = UA_STATUSCODE_GOOD;
     if(src->storageType == UA_VARIANT_DATA || src->storageType == UA_VARIANT_DATA_NODELETE)
         srcdata = &src->storage.data;
     else {
         retval |= src->storage.datasource.read(src->storage.datasource.identifier, &srcdata);
-        if(retval != UA_SUCCESS)
+        if(retval)
             return retval;
     }
 
-    // now copy from srcdata to dstdata.
-    dst->vt = src->vt;
+    // now copy the data to the destination
     retval |= UA_Array_copy(srcdata->dataPtr, srcdata->arrayLength, src->vt, &dstdata->dataPtr);
-    if(retval != UA_SUCCESS)
-        goto clean_up;
-    dstdata->arrayLength = srcdata->arrayLength;
-    if(srcdata->arrayDimensions != UA_NULL) {
-        retval |= UA_Array_copy(srcdata->arrayDimensions, srcdata->arrayDimensionsLength, &UA_[UA_INT32], (void **)&dstdata->arrayDimensions);
-        if(retval != UA_SUCCESS)
-            goto clean_up2;
-        dstdata->arrayDimensionsLength = srcdata->arrayDimensionsLength;
-    }
-
-    // release the src variant if necessary
-    if(src->storageType == UA_VARIANT_DATASOURCE)
-        src->storage.datasource.release(src->storage.datasource.identifier, srcdata);
-
-    return retval;
+    if(retval == UA_STATUSCODE_GOOD) {
+        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);
+            if(retval == UA_STATUSCODE_GOOD)
+                dstdata->arrayDimensionsLength = srcdata->arrayDimensionsLength;
+            else {
+                UA_Variant_deleteMembers(dst);
+                UA_Variant_init(dst);
+            }
+        }
+    } 
 
-    // clean ups are falling through to the "lower levels"
- clean_up2:
-    if(dstdata->arrayDimensions != UA_NULL)
-        UA_Array_delete(dstdata->dataPtr, dstdata->arrayLength, src->vt);
-    
- clean_up:
+    // release the data source if necessary
     if(src->storageType == UA_VARIANT_DATASOURCE)
         src->storage.datasource.release(src->storage.datasource.identifier, srcdata);
 
@@ -889,31 +850,34 @@ UA_Int32 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_Int32 UA_Variant_copySetValue(UA_Variant *v, const UA_VTable_Entry *vt, const void *value) {
-    if(v == UA_NULL || vt == UA_NULL || value == UA_NULL)
-        return UA_ERROR;
+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_Int32 retval = UA_SUCCESS;
-    retval |= vt->new(&v->storage.data.dataPtr);
-    if(retval == UA_SUCCESS)
+    UA_StatusCode retval = vt->new(&v->storage.data.dataPtr);
+    if(retval == UA_STATUSCODE_GOOD)
         retval |= vt->copy(value, v->storage.data.dataPtr);
+    if(retval) {
+        UA_Variant_deleteMembers(v);
+        UA_Variant_init(v);
+    }
     return retval;
 }
-UA_Int32 UA_Variant_copySetArray(UA_Variant *v, const UA_VTable_Entry *vt, UA_Int32 arrayLength,
-                                 const void *array) {
-    if(v == UA_NULL || vt == UA_NULL || array == UA_NULL)
-        return UA_ERROR;
+
+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;
-    return UA_Array_copy(array, arrayLength, vt, &v->storage.data.dataPtr);
+    UA_StatusCode retval = UA_Array_copy(array, arrayLength, vt, &v->storage.data.dataPtr);
+    if(retval) {
+        UA_Variant_deleteMembers(v);
+        UA_Variant_init(v);
+    }
+    return retval;
 }
 
 #ifdef DEBUG
 void UA_Variant_print(const UA_Variant *p, FILE *stream) {
-    if(p == UA_NULL || stream == UA_NULL) return;
     UA_UInt32 ns0id = UA_ns0ToVTableIndex(&p->vt->typeId);
     if(p->storageType == UA_VARIANT_DATASOURCE) {
         fprintf(stream, "Variant from a Datasource");
@@ -939,7 +903,6 @@ void UA_Variant_print(const UA_Variant *p, FILE *stream) {
 /* DiagnosticInfo */
 UA_TYPE_DELETE_DEFAULT(UA_DiagnosticInfo)
 void UA_DiagnosticInfo_deleteMembers(UA_DiagnosticInfo *p) {
-    if(!p) return;
     UA_String_deleteMembers(&p->additionalInfo);
     if((p->encodingMask & UA_DIAGNOSTICINFO_ENCODINGMASK_INNERDIAGNOSTICINFO) && p->innerDiagnosticInfo) {
         UA_DiagnosticInfo_delete(p->innerDiagnosticInfo);
@@ -948,7 +911,6 @@ void UA_DiagnosticInfo_deleteMembers(UA_DiagnosticInfo *p) {
 }
 
 void UA_DiagnosticInfo_init(UA_DiagnosticInfo *p) {
-    if(!p) return;
     UA_String_init(&p->additionalInfo);
     p->encodingMask = 0;
     p->innerDiagnosticInfo = UA_NULL;
@@ -960,30 +922,30 @@ void UA_DiagnosticInfo_init(UA_DiagnosticInfo *p) {
 }
 
 UA_TYPE_NEW_DEFAULT(UA_DiagnosticInfo)
-UA_Int32 UA_DiagnosticInfo_copy(UA_DiagnosticInfo const *src, UA_DiagnosticInfo *dst) {
-    UA_Int32 retval = UA_SUCCESS;
-    if(src == UA_NULL || dst == UA_NULL) return UA_ERROR;
-    retval |= UA_String_copy(&src->additionalInfo, &dst->additionalInfo);
-    retval |= UA_Byte_copy(&src->encodingMask, &dst->encodingMask);
+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
             retval |= UA_STATUSCODE_BADOUTOFMEMORY;
-    } else
-        dst->innerDiagnosticInfo = UA_NULL;
-    retval |= UA_Int32_copy(&src->locale, &dst->locale);
-    retval |= UA_Int32_copy(&src->localizedText, &dst->localizedText);
-    retval |= UA_Int32_copy(&src->namespaceUri, &dst->namespaceUri);
-    retval |= UA_Int32_copy(&src->symbolicId, &dst->symbolicId);
-
+    }
+    dst->locale = src->locale;
+    dst->localizedText = src->localizedText;
+    dst->namespaceUri = src->namespaceUri;
+    dst->symbolicId = src->symbolicId;
+    if(retval) {
+        UA_DiagnosticInfo_deleteMembers(dst);
+        UA_DiagnosticInfo_init(dst);
+    }
     return retval;
 }
 
 #ifdef DEBUG
 void UA_DiagnosticInfo_print(const UA_DiagnosticInfo *p, FILE *stream) {
-    if(p == UA_NULL || stream == UA_NULL) return;
     fprintf(stream, "(UA_DiagnosticInfo){");
     UA_Byte_print(&p->encodingMask, stream);
     fprintf(stream, ",");
@@ -999,7 +961,7 @@ void UA_DiagnosticInfo_print(const UA_DiagnosticInfo *p, FILE *stream) {
     fprintf(stream, ",");
     UA_StatusCode_print(&p->innerStatusCode, stream);
     fprintf(stream, ",");
-    if(p->innerDiagnosticInfo != UA_NULL) {
+    if(p->innerDiagnosticInfo) {
         fprintf(stream, "&");
         UA_DiagnosticInfo_print(p->innerDiagnosticInfo, stream);
     } else
@@ -1021,17 +983,16 @@ void UA_InvalidType_init(UA_InvalidType *p) {
     return;
 }
 
-UA_Int32 UA_InvalidType_copy(UA_InvalidType const *src, UA_InvalidType *dst) {
-    return UA_ERR_INVALID_VALUE;
+UA_StatusCode UA_InvalidType_copy(UA_InvalidType const *src, UA_InvalidType *dst) {
+    return UA_STATUSCODE_BADINTERNALERROR;
 }
 
-UA_Int32 UA_InvalidType_new(UA_InvalidType **p) {
-    return UA_ERR_INVALID_VALUE;
+UA_StatusCode UA_InvalidType_new(UA_InvalidType **p) {
+    return UA_STATUSCODE_BADINTERNALERROR;
 }
 
 #ifdef DEBUG
 void UA_InvalidType_print(const UA_InvalidType *p, FILE *stream) {
-    if(p == UA_NULL || stream == UA_NULL) return;
     fprintf(stream, "(UA_InvalidType){ERROR (invalid type)}");
 }
 #endif
@@ -1040,32 +1001,28 @@ void UA_InvalidType_print(const UA_InvalidType *p, FILE *stream) {
 /* Array */
 /*********/
 
-UA_Int32 UA_Array_new(void **p, UA_Int32 noElements, const UA_VTable_Entry *vt) {
-    if(vt == UA_NULL)
-        return UA_ERROR;
-
+UA_StatusCode UA_Array_new(void **p, UA_Int32 noElements, const UA_VTable_Entry *vt) {
     if(noElements <= 0) {
         *p = UA_NULL;
-        return UA_SUCCESS;
+        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_ERROR;
+        return UA_STATUSCODE_BADINTERNALERROR;
     }
 
     if(!(*p = UA_alloc(vt->memSize * noElements)))
         return UA_STATUSCODE_BADOUTOFMEMORY;
 
     UA_Array_init(*p, noElements, vt);
-    return UA_SUCCESS;
+    return UA_STATUSCODE_GOOD;
 }
 
 void UA_Array_init(void *p, UA_Int32 noElements, const UA_VTable_Entry *vt) {
-    if(!p || !vt) return;
-    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);
@@ -1074,38 +1031,34 @@ 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) {
-    if(!p || !vt || noElements <= 0) return;
-    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_Int32 UA_Array_copy(const void *src, UA_Int32 noElements, const UA_VTable_Entry *vt, void **dst) {
-    UA_Int32 retval;
-    if(src == UA_NULL || dst == UA_NULL || vt == UA_NULL)
-        return UA_ERROR;
-
-    retval = UA_Array_new(dst, noElements, vt);
-    if(retval != UA_SUCCESS) {
+UA_StatusCode UA_Array_copy(const void *src, UA_Int32 noElements, const UA_VTable_Entry *vt, void **dst) {
+    UA_StatusCode retval = UA_Array_new(dst, noElements, vt);
+    if(retval) {
         *dst = UA_NULL;
         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_SUCCESS;i++) {
+    for(;i < noElements && retval == UA_STATUSCODE_GOOD;i++) {
         retval |= vt->copy(csrc, cdst);
         csrc   += memSize;
         cdst   += memSize;
     }
 
-    if(retval != UA_SUCCESS) {
+    if(retval) {
         i--; // undo last increase
         UA_Array_delete(*dst, i, vt);
         *dst = UA_NULL;
@@ -1116,7 +1069,6 @@ UA_Int32 UA_Array_copy(const void *src, UA_Int32 noElements, const UA_VTable_Ent
 
 #ifdef DEBUG
 void UA_Array_print(const void *p, UA_Int32 noElements, const UA_VTable_Entry *vt, FILE *stream) {
-    if(p == UA_NULL || vt == UA_NULL || stream == UA_NULL) return;
     fprintf(stream, "(%s){", vt->name);
     char     *cp      = (char *)p; // so compilers allow pointer arithmetic
     UA_UInt32 memSize = vt->memSize;

src/ua_types_encoding_binary.h

@@ -8,17 +8,22 @@
  * @defgroup encoding Datatype Encoding
  *
  * @brief Datatypes can have several encodings. The methods defined for
- * encodings and their signature are fixed.
+ * encodings and their signature are fixed. When supplied with an inappropriate
+ * null-pointer, these functions _will crash_. Exceptions are documented for the
+ * individual functions.
  *
  * - CalcSize: Returns the size of the (encoded) variable in bytes. This
- *    function is mainly used to allocate the bytestring into which the encoding
- *    is done.
+ *   function is mainly used to allocate the bytestring into which the encoding
+ *   is done.
  *
- * - Encode: Encodes a variable into a bytestring.
+ * - Encode: Encodes a variable into a bytestring. If an error occurs
+ *   (indicated by the return value), the bytestring may be left in an
+ *   inconsistent state.
  *
- * - Decode: Decodes a variable stored in a bytestring. It is assumed that the
- *   input variable (dst) is allocated in memory, but not its dynamically sized
- *   members.
+ * - Decode: Decodes a variable stored in a bytestring. The destination is
+ *   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.
  */
 
 /**
@@ -31,27 +36,18 @@
  * @{
  */
 
-/* Stop decoding at the first failure. Free members that were already allocated.
-   It is assumed that retval is already defined. */
-#define CHECKED_DECODE(DECODE, CLEAN_UP) do { \
-        retval |= DECODE;                     \
-        if(retval != UA_SUCCESS) {            \
-            CLEAN_UP;                         \
-            return retval;                    \
-        } } while(0)
-
 #define UA_TYPE_CALCSIZEBINARY_AS(TYPE, TYPE_AS)       \
-    UA_Int32 TYPE##_calcSizeBinary(TYPE const *p) {    \
+    UA_UInt32 TYPE##_calcSizeBinary(TYPE const *p) {    \
         return TYPE_AS##_calcSizeBinary((TYPE_AS *)p); \
     }
 
-#define UA_TYPE_ENCODEBINARY_AS(TYPE, TYPE_AS)                                             \
-    UA_Int32 TYPE##_encodeBinary(TYPE const *src, UA_ByteString *dst, UA_UInt32 *offset) { \
-        return TYPE_AS##_encodeBinary((TYPE_AS *)src, dst, offset);                        \
+#define UA_TYPE_ENCODEBINARY_AS(TYPE, TYPE_AS)                          \
+    UA_StatusCode TYPE##_encodeBinary(TYPE const *src, UA_ByteString *dst, UA_UInt32 *offset) { \
+        return TYPE_AS##_encodeBinary((TYPE_AS *)src, dst, offset);     \
     }
 
 #define UA_TYPE_DECODEBINARY_AS(TYPE, TYPE_AS)                                             \
-    UA_Int32 TYPE##_decodeBinary(UA_ByteString const *src, UA_UInt32 *offset, TYPE *dst) { \
+    UA_StatusCode TYPE##_decodeBinary(UA_ByteString const *src, UA_UInt32 *offset, TYPE *dst) { \
         return TYPE_AS##_decodeBinary(src, offset, (TYPE_AS *)dst);                        \
     }
 #define UA_TYPE_BINARY_ENCODING_AS(TYPE, TYPE_AS) \
@@ -60,9 +56,9 @@
     UA_TYPE_DECODEBINARY_AS(TYPE, TYPE_AS)
 
 #define UA_TYPE_BINARY_ENCODING(TYPE)                                                     \
-    UA_Int32 TYPE##_calcSizeBinary(TYPE const *p);                                        \
-    UA_Int32 TYPE##_encodeBinary(TYPE const *src, UA_ByteString *dst, UA_UInt32 *offset); \
-    UA_Int32 TYPE##_decodeBinary(UA_ByteString const *src, UA_UInt32 *offset, TYPE *dst);
+    UA_UInt32 TYPE##_calcSizeBinary(TYPE const *p);                                        \
+    UA_StatusCode TYPE##_encodeBinary(TYPE const *src, UA_ByteString *dst, UA_UInt32 *offset); \
+    UA_StatusCode TYPE##_decodeBinary(UA_ByteString const *src, UA_UInt32 *offset, TYPE *dst);
 
 UA_TYPE_BINARY_ENCODING(UA_Boolean)
 UA_TYPE_BINARY_ENCODING(UA_SByte)
@@ -98,15 +94,15 @@ UA_TYPE_BINARY_ENCODING(UA_InvalidType)
 /*********/
 
 /* Computes the size of an array (incl. length field) in a binary blob. */
-UA_Int32 UA_Array_calcSizeBinary(UA_Int32 nElements, const UA_VTable_Entry *vt, const void *data);
+UA_UInt32 UA_Array_calcSizeBinary(UA_Int32 length, const UA_VTable_Entry *vt, const void *data);
 
 /* @brief Encodes an array into a binary blob. The array size is printed as well. */
-UA_Int32 UA_Array_encodeBinary(const void *src, UA_Int32 noElements, const UA_VTable_Entry *vt,
-                               UA_ByteString *dst, UA_UInt32 *offset);
+UA_StatusCode UA_Array_encodeBinary(const void *src, UA_Int32 length, const UA_VTable_Entry *vt,
+                                    UA_ByteString *dst, UA_UInt32 *offset);
 
 /* @brief Decodes an array from a binary blob. The array is allocated automatically before decoding. */
-UA_Int32 UA_Array_decodeBinary(const UA_ByteString *src, UA_UInt32 *offset, UA_Int32 noElements,
-                               const UA_VTable_Entry *vt, void **dst);
+UA_StatusCode UA_Array_decodeBinary(const UA_ByteString *src, UA_UInt32 *offset, UA_Int32 length,
+                                    const UA_VTable_Entry *vt, void **dst);
 
 /// @} /* end of group */
 

src/ua_util.c

@@ -2,11 +2,12 @@
 
 /* the extern inline in a *.c-file is required for other compilation units to
    see the inline function. */
-extern INLINE UA_Int32 _UA_free(void *ptr, char *pname, char *f, UA_Int32 l);
 extern INLINE void UA_memcpy(void *dst, void const *src, UA_Int32 size);
 
 #ifdef DEBUG
+extern INLINE void _UA_free(void *ptr, char *pname, char *f, UA_Int32 l);
 extern INLINE void * _UA_alloc(UA_Int32 size, char *file, UA_Int32 line);
 #else
+extern INLINE void _UA_free(void *ptr);
 extern INLINE void * _UA_alloc(UA_Int32 size);
 #endif

src/ua_util.h

@@ -39,12 +39,18 @@
 #endif
 
 /* Heap memory functions */
+#ifdef DEBUG
 #define UA_free(ptr) _UA_free(ptr, # ptr, __FILE__, __LINE__)
-INLINE UA_Int32 _UA_free(void *ptr, char *pname, char *f, UA_Int32 l) {
+INLINE void _UA_free(void *ptr, char *pname, char *f, UA_Int32 l) {
     DBG_VERBOSE(printf("UA_free;%p;;%s;;%s;%d\n", ptr, pname, f, l); fflush(stdout));
     free(ptr); // checks if ptr != NULL in the background
-    return UA_SUCCESS;
 }
+#else
+#define UA_free(ptr) _UA_free(ptr)
+INLINE void _UA_free(void *ptr) {
+    free(ptr); // checks if ptr != NULL in the background
+}
+#endif
 
 #ifdef DEBUG
 #define UA_alloc(size) _UA_alloc(size, __FILE__, __LINE__) 

tests/check_builtin.c

@@ -14,208 +14,6 @@ enum UA_VARIANT_ENCODINGMASKTYPE_enum {
     UA_VARIANT_ENCODINGMASKTYPE_ARRAY       = (0x01 << 7)      // bit 7
 };
 
-START_TEST(UA_Boolean_calcSizeWithNullArgumentShallReturnStorageSize) {
-	// given
-	UA_Boolean *arg = UA_NULL;
-	// when
-	UA_UInt32   storageSize = UA_Boolean_calcSizeBinary(arg);
-	// then
-	ck_assert_int_eq(storageSize, 1);
-}
-END_TEST
-
-START_TEST(UA_SByte_calcSizeWithNullArgumentShallReturnStorageSize) {
-	// given
-	UA_SByte *arg = UA_NULL;
-	// when
-	UA_UInt32 storageSize = UA_SByte_calcSizeBinary(arg);
-	// then
-	ck_assert_int_ge(storageSize, 1);
-}
-END_TEST
-START_TEST(UA_Byte_calcSizeWithNullArgumentShallReturnStorageSize) {
-	// given
-	UA_Byte  *arg = UA_NULL;
-	// when
-	UA_UInt32 storageSize = UA_Byte_calcSizeBinary(arg);
-	// then
-	ck_assert_int_ge(storageSize, 1);
-}
-END_TEST
-START_TEST(UA_Int16_calcSizeWithNullArgumentShallReturnStorageSize) {
-	// given
-	UA_Int16 *arg = UA_NULL;
-	// when
-	UA_UInt32 storageSize = UA_Int16_calcSizeBinary(arg);
-	// then
-	ck_assert_int_ge(storageSize, 2);
-}
-END_TEST
-START_TEST(UA_UInt16_calcSizeWithNullArgumentShallReturnStorageSize) {
-	// given
-	UA_UInt16 *arg = UA_NULL;
-	// when
-	UA_UInt32  storageSize = UA_UInt16_calcSizeBinary(arg);
-	// then
-	ck_assert_int_ge(storageSize, 2);
-}
-END_TEST
-START_TEST(UA_Int32_calcSizeWithNullArgumentShallReturnStorageSize) {
-	// given
-	UA_Int32 *arg = UA_NULL;
-	// when
-	UA_UInt32 storageSize = UA_Int32_calcSizeBinary(arg);
-	// then
-	ck_assert_int_ge(storageSize, 4);
-}
-END_TEST
-START_TEST(UA_UInt32_calcSizeWithNullArgumentShallReturnStorageSize) {
-	// given
-	UA_UInt32 *arg = UA_NULL;
-	// when
-	UA_UInt32  storageSize = UA_UInt32_calcSizeBinary(arg);
-	// then
-	ck_assert_int_ge(storageSize, 4);
-}
-END_TEST
-START_TEST(UA_Int64_calcSizeWithNullArgumentShallReturnStorageSize) {
-	// given
-	UA_Int64 *arg = UA_NULL;
-	// when
-	UA_UInt32 storageSize = UA_Int64_calcSizeBinary(arg);
-	// then
-	ck_assert_int_ge(storageSize, 8);
-}
-END_TEST
-START_TEST(UA_UInt64_calcSizeWithNullArgumentShallReturnStorageSize) {
-	// given
-	UA_UInt64 *arg = UA_NULL;
-	// when
-	UA_UInt32  storageSize = UA_UInt64_calcSizeBinary(arg);
-	// then
-	ck_assert_int_ge(storageSize, 8);
-}
-END_TEST
-START_TEST(UA_Float_calcSizeWithNullArgumentShallReturnStorageSize) {
-	// given
-	UA_Float *arg = UA_NULL;
-	// when
-	UA_UInt32 storageSize = UA_Float_calcSizeBinary(arg);
-	// then
-	ck_assert_int_ge(storageSize, 4);
-}
-END_TEST
-START_TEST(UA_Double_calcSizeWithNullArgumentShallReturnStorageSize) {
-	// given
-	UA_Double *arg = UA_NULL;
-	// when
-	UA_UInt32  storageSize = UA_Double_calcSizeBinary(arg);
-	// then
-	ck_assert_int_ge(storageSize, 8);
-}
-END_TEST
-START_TEST(UA_String_calcSizeWithNullArgumentShallReturnStorageSize) {
-	// given
-	UA_String *arg = UA_NULL;
-	// when
-	UA_UInt32  storageSize = UA_String_calcSizeBinary(arg);
-	// then
-	ck_assert_int_eq(storageSize, sizeof(UA_String));
-	ck_assert_int_ge(storageSize, sizeof(UA_Int32) + sizeof(UA_NULL));
-}
-END_TEST
-START_TEST(UA_DateTime_calcSizeWithNullArgumentShallReturnStorageSize) {
-	// given
-	UA_DateTime *arg = UA_NULL;
-	// when
-	UA_UInt32    storageSize = UA_DateTime_calcSizeBinary(arg);
-	// then
-	ck_assert_int_ge(storageSize, 8);
-}
-END_TEST
-START_TEST(UA_Guid_calcSizeWithNullArgumentShallReturnStorageSize) {
-	// given
-	UA_Guid  *arg = UA_NULL;
-	// when
-	UA_UInt32 storageSize = UA_Guid_calcSizeBinary(arg);
-	// then
-	ck_assert_int_ge(storageSize, 16);
-}
-END_TEST
-START_TEST(UA_ByteString_calcSizeWithNullArgumentShallReturnStorageSize) {
-	// given
-	UA_ByteString *arg    = UA_NULL;
-	// when
-	UA_UInt32 storageSize = UA_ByteString_calcSizeBinary(arg);
-	// then
-	ck_assert_int_eq(storageSize, sizeof(UA_ByteString));
-	ck_assert_int_ge(storageSize, sizeof(UA_Int32)+sizeof(UA_NULL));
-}
-END_TEST
-START_TEST(UA_XmlElement_calcSizeWithNullArgumentShallReturnStorageSize) {
-	// given
-	UA_XmlElement *arg    = UA_NULL;
-	// when
-	UA_UInt32 storageSize = UA_XmlElement_calcSizeBinary(arg);
-	// then
-	ck_assert_int_eq(storageSize, sizeof(UA_XmlElement));
-	ck_assert_int_ge(storageSize, sizeof(UA_Int32)+sizeof(UA_NULL));
-}
-END_TEST
-START_TEST(UA_NodeId_calcSizeWithNullArgumentShallReturnStorageSize) {
-	// given
-	UA_NodeId *arg = UA_NULL;
-	// when
-	UA_UInt32  storageSize = UA_NodeId_calcSizeBinary(arg);
-	// then
-	ck_assert_int_eq(storageSize, sizeof(UA_NodeId));
-}
-END_TEST
-START_TEST(UA_ExpandedNodeId_calcSizeWithNullArgumentShallReturnStorageSize) {
-	// given
-	UA_ExpandedNodeId *arg = UA_NULL;
-	// when
-	UA_UInt32 storageSize  = UA_ExpandedNodeId_calcSizeBinary(arg);
-	// then
-	ck_assert_int_eq(storageSize, sizeof(UA_ExpandedNodeId));
-}
-END_TEST
-START_TEST(UA_StatusCode_calcSizeWithNullArgumentShallReturnStorageSize) {
-	// given
-	UA_StatusCode *arg    = UA_NULL;
-	// when
-	UA_UInt32 storageSize = UA_StatusCode_calcSizeBinary(arg);
-	// then
-	ck_assert_int_eq(storageSize, sizeof(UA_StatusCode));
-}
-END_TEST
-START_TEST(UA_QualifiedName_calcSizeWithNullArgumentShallReturnStorageSize) {
-	// given
-	UA_QualifiedName *arg = UA_NULL;
-	// when
-	UA_UInt32 storageSize = UA_QualifiedName_calcSizeBinary(arg);
-	// then
-	ck_assert_int_eq(storageSize, sizeof(UA_QualifiedName));
-}
-END_TEST
-START_TEST(UA_LocalizedText_calcSizeWithNullArgumentShallReturnStorageSize) {
-	// given
-	UA_LocalizedText *arg = UA_NULL;
-	// when
-	UA_UInt32 storageSize = UA_LocalizedText_calcSizeBinary(arg);
-	// then
-	ck_assert_int_eq(storageSize, sizeof(UA_LocalizedText));
-}
-END_TEST
-START_TEST(UA_ExtensionObject_calcSizeWithNullArgumentShallReturnStorageSize) {
-	// given
-	UA_ExtensionObject *arg = UA_NULL;
-	// when
-	UA_UInt32 storageSize   = UA_ExtensionObject_calcSizeBinary(arg);
-	// then
-	ck_assert_int_eq(storageSize, sizeof(UA_ExtensionObject));
-}
-END_TEST
 START_TEST(UA_ExtensionObject_calcSizeShallWorkOnExample) {
 	// given
 	UA_Byte data[3] = { 1, 2, 3 };
@@ -258,15 +56,6 @@ START_TEST(UA_DataValue_calcSizeShallWorkOnExample) {
 	ck_assert_int_eq(size, 21);
 }
 END_TEST
-START_TEST(UA_DataValue_calcSizeWithNullArgumentShallReturnStorageSize) {
-	// given
-	UA_DataValue *arg = UA_NULL;
-	// when
-	UA_UInt32     storageSize = UA_DataValue_calcSizeBinary(arg);
-	// then
-	ck_assert_int_eq(storageSize, sizeof(UA_DataValue));
-}
-END_TEST
 START_TEST(UA_DiagnosticInfo_calcSizeShallWorkOnExample) {
 	// given
 	UA_DiagnosticInfo diagnosticInfo;
@@ -281,15 +70,6 @@ START_TEST(UA_DiagnosticInfo_calcSizeShallWorkOnExample) {
 	ck_assert_int_eq(UA_DiagnosticInfo_calcSizeBinary(&diagnosticInfo), 26);
 }
 END_TEST
-START_TEST(UA_DiagnosticInfo_calcSizeWithNullArgumentShallReturnStorageSize) {
-	// given
-	UA_DiagnosticInfo *arg = UA_NULL;
-	// when
-	UA_UInt32 storageSize  = UA_DiagnosticInfo_calcSizeBinary(arg);
-	// then
-	ck_assert_int_eq(storageSize, sizeof(UA_DiagnosticInfo));
-}
-END_TEST
 START_TEST(UA_String_calcSizeWithNegativLengthShallReturnEncodingSize) {
 	// given
 	UA_String arg = { -1, UA_NULL };
@@ -514,9 +294,9 @@ START_TEST(UA_Byte_decodeShallCopyAndAdvancePosition) {
 	UA_UInt32     pos    = 0;
 
 	// when
-	UA_Int32 retval = UA_Byte_decodeBinary(&src, &pos, &dst);
+	UA_StatusCode retval = UA_Byte_decodeBinary(&src, &pos, &dst);
 	// then
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	ck_assert_uint_eq(pos, 1);
 	ck_assert_uint_eq(dst, 0x08);
 }
@@ -528,9 +308,9 @@ START_TEST(UA_Byte_decodeShallModifyOnlyCurrentPosition) {
 	UA_ByteString src    = { 1, data };
 	UA_UInt32     pos    = 0;
 	// when
-	UA_Int32      retval = UA_Byte_decodeBinary(&src, &pos, &dst[1]);
+	UA_StatusCode retval = UA_Byte_decodeBinary(&src, &pos, &dst[1]);
 	// then
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	ck_assert_int_eq(pos, 1);
 	ck_assert_uint_eq(dst[0], 0xFF);
 	ck_assert_uint_eq(dst[1], 0x08);
@@ -547,10 +327,10 @@ START_TEST(UA_Int16_decodeShallAssumeLittleEndian) {
 	UA_ByteString src = { 4, data };
 	// when
 	UA_Int16      val_01_00, val_00_01;
-	UA_Int32      retval = UA_Int16_decodeBinary(&src, &pos, &val_01_00);
+	UA_StatusCode retval = UA_Int16_decodeBinary(&src, &pos, &val_01_00);
 	retval |= UA_Int16_decodeBinary(&src, &pos, &val_00_01);
 	// then
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	ck_assert_int_eq(val_01_00, 1);
 	ck_assert_int_eq(val_00_01, 256);
 	ck_assert_int_eq(pos, 4);
@@ -566,10 +346,10 @@ START_TEST(UA_Int16_decodeShallRespectSign) {
 	UA_ByteString src = { 4, data };
 	// when
 	UA_Int16      val_ff_ff, val_00_80;
-	UA_Int32      retval = UA_Int16_decodeBinary(&src, &pos, &val_ff_ff);
+	UA_StatusCode retval = UA_Int16_decodeBinary(&src, &pos, &val_ff_ff);
 	retval |= UA_Int16_decodeBinary(&src, &pos, &val_00_80);
 	// then
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	ck_assert_int_eq(val_ff_ff, -1);
 	ck_assert_int_eq(val_00_80, -32768);
 }
@@ -584,10 +364,10 @@ START_TEST(UA_UInt16_decodeShallNotRespectSign) {
 	UA_ByteString src = { 4, data };
 	// when
 	UA_UInt16     val_ff_ff, val_00_80;
-	UA_Int32      retval = UA_UInt16_decodeBinary(&src, &pos, &val_ff_ff);
+	UA_StatusCode retval = UA_UInt16_decodeBinary(&src, &pos, &val_ff_ff);
 	retval |= UA_UInt16_decodeBinary(&src, &pos, &val_00_80);
 	// then
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	ck_assert_int_eq(pos, 4);
 	ck_assert_uint_eq(val_ff_ff, (0x01 << 16)-1);
 	ck_assert_uint_eq(val_00_80, (0x01 << 15));
@@ -604,10 +384,10 @@ START_TEST(UA_Int32_decodeShallAssumeLittleEndian) {
 
 	// when
 	UA_Int32 val_01_00, val_00_01;
-	UA_Int32 retval = UA_Int32_decodeBinary(&src, &pos, &val_01_00);
+	UA_StatusCode retval = UA_Int32_decodeBinary(&src, &pos, &val_01_00);
 	retval |= UA_Int32_decodeBinary(&src, &pos, &val_00_01);
 	// then
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	ck_assert_int_eq(val_01_00, 1);
 	ck_assert_int_eq(val_00_01, 256);
 	ck_assert_int_eq(pos, 8);
@@ -624,10 +404,10 @@ START_TEST(UA_Int32_decodeShallRespectSign) {
 
 	// when
 	UA_Int32 val_ff_ff, val_00_80;
-	UA_Int32 retval = UA_Int32_decodeBinary(&src, &pos, &val_ff_ff);
+	UA_StatusCode retval = UA_Int32_decodeBinary(&src, &pos, &val_ff_ff);
 	retval |= UA_Int32_decodeBinary(&src, &pos, &val_00_80);
 	// then
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	ck_assert_int_eq(val_ff_ff, -1);
 	ck_assert_int_eq(val_00_80, -32768);
 }
@@ -643,10 +423,10 @@ START_TEST(UA_UInt32_decodeShallNotRespectSign) {
 
 	// when
 	UA_UInt32 val_ff_ff, val_00_80;
-	UA_Int32  retval = UA_UInt32_decodeBinary(&src, &pos, &val_ff_ff);
+	UA_StatusCode retval = UA_UInt32_decodeBinary(&src, &pos, &val_ff_ff);
 	retval |= UA_UInt32_decodeBinary(&src, &pos, &val_00_80);
 	// then
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	ck_assert_int_eq(pos, 8);
 	ck_assert_uint_eq(val_ff_ff, (UA_UInt32)( (0x01LL << 32 ) - 1 ));
 	ck_assert_uint_eq(val_00_80, (UA_UInt32)(0x01 << 31));
@@ -692,9 +472,9 @@ START_TEST(UA_Float_decodeShallWorkOnExample) {
 	UA_ByteString src    = { 4, data };
 	UA_Float      dst;
 	// when
-	UA_Int32      retval = UA_Float_decodeBinary(&src, &pos, &dst);
+	UA_StatusCode retval = UA_Float_decodeBinary(&src, &pos, &dst);
 	// then
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	ck_assert_int_eq(pos, 4);
 	ck_assert(-6.5000001 < dst);
 	ck_assert(dst < -6.49999999999);
@@ -708,9 +488,9 @@ START_TEST(UA_Double_decodeShallGiveOne) {
 	UA_ByteString src    = { 8, data };                                        // 1
 	UA_Double     dst;
 	// when
-	UA_Int32      retval = UA_Double_decodeBinary(&src, &pos, &dst);
+	UA_StatusCode retval = UA_Double_decodeBinary(&src, &pos, &dst);
 	// then
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	ck_assert_int_eq(pos, 8);
 	ck_assert(0.9999999 < dst);
 	ck_assert(dst < 1.00000000001);
@@ -723,9 +503,9 @@ START_TEST(UA_Double_decodeShallGiveZero) {
 	UA_ByteString src    = { 8, data }; // 1
 	UA_Double     dst;
 	// when
-	UA_Int32      retval = UA_Double_decodeBinary(&src, &pos, &dst);
+	UA_StatusCode retval = UA_Double_decodeBinary(&src, &pos, &dst);
 	// then
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	ck_assert_int_eq(pos, 8);
 	ck_assert(-0.00000001 < dst);
 	ck_assert(dst < 0.000000001);
@@ -739,9 +519,9 @@ START_TEST(UA_Double_decodeShallGiveMinusTwo) {
 
 	UA_Double     dst;
 	// when
-	UA_Int32      retval = UA_Double_decodeBinary(&src, &pos, &dst);
+	UA_StatusCode retval = UA_Double_decodeBinary(&src, &pos, &dst);
 	// then
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	ck_assert_int_eq(pos, 8);
 	ck_assert(-1.9999999 > dst);
 	ck_assert(dst > -2.00000000001);
@@ -756,9 +536,9 @@ START_TEST(UA_String_decodeShallAllocateMemoryAndCopyString) {
 	UA_ByteString src    = { 16, data };
 	UA_String     dst;
 	// when
-	UA_Int32      retval = UA_String_decodeBinary(&src, &pos, &dst);
+	UA_StatusCode retval = UA_String_decodeBinary(&src, &pos, &dst);
 	// then
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	ck_assert_int_eq(dst.length, 8);
 	ck_assert_int_eq(dst.data[3], 'L');
 	// finally
@@ -774,9 +554,9 @@ START_TEST(UA_String_decodeWithNegativeSizeShallNotAllocateMemoryAndNullPtr) {
 
 	UA_String     dst;
 	// when
-	UA_Int32      retval = UA_String_decodeBinary(&src, &pos, &dst);
+	UA_StatusCode retval = UA_String_decodeBinary(&src, &pos, &dst);
 	// then
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	ck_assert_int_eq(dst.length, -1);
 	ck_assert_ptr_eq(dst.data, UA_NULL);
 }
@@ -790,9 +570,9 @@ START_TEST(UA_String_decodeWithZeroSizeShallNotAllocateMemoryAndNullPtr) {
 
 	UA_String     dst    = { 2, (UA_Byte *)"XX" };
 	// when
-	UA_Int32      retval = UA_String_decodeBinary(&src, &pos, &dst);
+	UA_StatusCode retval = UA_String_decodeBinary(&src, &pos, &dst);
 	// then
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	ck_assert_int_eq(dst.length, -1); // shall we keep zero?
 	ck_assert_ptr_eq(dst.data, UA_NULL);
 }
@@ -805,9 +585,9 @@ START_TEST(UA_NodeId_decodeTwoByteShallReadTwoBytesAndSetNamespaceToZero) {
 
 	UA_NodeId     dst;
 	// when
-	UA_Int32      retval = UA_NodeId_decodeBinary(&src, &pos, &dst);
+	UA_StatusCode retval = UA_NodeId_decodeBinary(&src, &pos, &dst);
 	// then
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	ck_assert_int_eq(pos, 2);
 	ck_assert_int_eq(dst.identifierType, UA_NODEIDTYPE_NUMERIC);
 	ck_assert_int_eq(dst.identifier.numeric, 16);
@@ -822,9 +602,9 @@ START_TEST(UA_NodeId_decodeFourByteShallReadFourBytesAndRespectNamespace) {
 
 	UA_NodeId     dst;
 	// when
-	UA_Int32      retval = UA_NodeId_decodeBinary(&src, &pos, &dst);
+	UA_StatusCode retval = UA_NodeId_decodeBinary(&src, &pos, &dst);
 	// then
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	ck_assert_int_eq(pos, 4);
 	ck_assert_int_eq(dst.identifierType, UA_NODEIDTYPE_NUMERIC);
 	ck_assert_int_eq(dst.identifier.numeric, 256);
@@ -839,9 +619,9 @@ START_TEST(UA_NodeId_decodeStringShallAllocateMemory) {
 
 	UA_NodeId     dst;
 	// when
-	UA_Int32      retval = UA_NodeId_decodeBinary(&src, &pos, &dst);
+	UA_StatusCode retval = UA_NodeId_decodeBinary(&src, &pos, &dst);
 	// then
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	ck_assert_int_eq(pos, 10);
 	ck_assert_int_eq(dst.identifierType, UA_NODEIDTYPE_STRING);
 	ck_assert_int_eq(dst.namespaceIndex, 1);
@@ -858,9 +638,9 @@ START_TEST(UA_Variant_decodeWithOutArrayFlagSetShallSetVTAndAllocateMemoryForArr
 	UA_ByteString src    = { 5, data };
 	UA_Variant    dst;
 	// when
-	UA_Int32      retval = UA_Variant_decodeBinary(&src, &pos, &dst);
+	UA_StatusCode retval = UA_Variant_decodeBinary(&src, &pos, &dst);
 	// then
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	ck_assert_int_eq(pos, 5);
 	ck_assert_ptr_eq(dst.vt, &UA_[UA_INT32]);
 	ck_assert_int_eq(dst.storage.data.arrayLength, 1);
@@ -879,10 +659,10 @@ START_TEST(UA_Variant_decodeWithArrayFlagSetShallSetVTAndAllocateMemoryForArray)
 	UA_Variant    dst;
 
 	// when
-	UA_Int32 retval = UA_Variant_decodeBinary(&src, &pos, &dst);
+	UA_StatusCode retval = UA_Variant_decodeBinary(&src, &pos, &dst);
 
 	// then
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	ck_assert_int_eq(pos, 1+4+2*4);
 	ck_assert_ptr_eq(dst.vt, &UA_[UA_INT32]);
 	ck_assert_int_eq(dst.storage.data.arrayLength, 2);
@@ -902,9 +682,9 @@ START_TEST(UA_Variant_decodeWithOutDeleteMembersShallFailInCheckMem) {
 
 	UA_Variant    dst;
 	// when
-	UA_Int32      retval = UA_Variant_decodeBinary(&src, &pos, &dst);
+	UA_StatusCode retval = UA_Variant_decodeBinary(&src, &pos, &dst);
 	// then
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	// finally
 	UA_Variant_deleteMembers(&dst);
 }
@@ -920,9 +700,9 @@ START_TEST(UA_Variant_decodeWithTooSmallSourceShallReturnWithError) {
 
 	UA_Variant    dst;
 	// when
-	UA_Int32      retval = UA_Variant_decodeBinary(&src, &pos, &dst);
+	UA_StatusCode retval = UA_Variant_decodeBinary(&src, &pos, &dst);
 	// then
-	ck_assert_int_ne(retval, UA_SUCCESS);
+	ck_assert_int_ne(retval, UA_STATUSCODE_GOOD);
 	// finally
 	UA_Variant_deleteMembers(&dst);
 }
@@ -945,7 +725,7 @@ START_TEST(UA_Byte_encode_test) {
 	ck_assert_uint_eq(dst.data[0], 0x08);
 	ck_assert_uint_eq(dst.data[1], 0xFF);
 	ck_assert_int_eq(pos, 1);
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 
 	// Test2
 	// given
@@ -957,7 +737,7 @@ START_TEST(UA_Byte_encode_test) {
 	ck_assert_int_eq(dst.data[0], 0xFF);
 	ck_assert_int_eq(dst.data[1], 0x00);
 	ck_assert_int_eq(pos, 1);
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 
 }
 END_TEST
@@ -969,7 +749,7 @@ START_TEST(UA_UInt16_encodeNegativeShallEncodeLittleEndian) {
 		                      0x55,       0x55 };
 	UA_ByteString dst    = { 4, data };
 
-	UA_Int32      retval = 0;
+	UA_StatusCode retval = 0;
 	UA_UInt32     pos    = 0;
 
 	// when test 1
@@ -979,7 +759,7 @@ START_TEST(UA_UInt16_encodeNegativeShallEncodeLittleEndian) {
 	ck_assert_int_eq(pos, 2);
 	ck_assert_int_eq(dst.data[0], 0xFF);
 	ck_assert_int_eq(dst.data[1], 0xFF);
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 
 	// when test 2
 	src    = -32768;
@@ -988,7 +768,7 @@ START_TEST(UA_UInt16_encodeNegativeShallEncodeLittleEndian) {
 	ck_assert_int_eq(pos, 4);
 	ck_assert_int_eq(dst.data[2], 0x00);
 	ck_assert_int_eq(dst.data[3], 0x80);
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 }
 END_TEST
 START_TEST(UA_UInt16_encodeShallEncodeLittleEndian) {
@@ -998,7 +778,7 @@ START_TEST(UA_UInt16_encodeShallEncodeLittleEndian) {
 		                      0x55,       0x55 };
 	UA_ByteString dst    = { 4, data };
 
-	UA_Int32      retval = 0;
+	UA_StatusCode retval = 0;
 	UA_UInt32     pos    = 0;
 
 	// when test 1
@@ -1008,7 +788,7 @@ START_TEST(UA_UInt16_encodeShallEncodeLittleEndian) {
 	ck_assert_int_eq(pos, 2);
 	ck_assert_int_eq(dst.data[0], 0x00);
 	ck_assert_int_eq(dst.data[1], 0x00);
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 
 	// when test 2
 	src    = 32767;
@@ -1017,7 +797,7 @@ START_TEST(UA_UInt16_encodeShallEncodeLittleEndian) {
 	ck_assert_int_eq(pos, 4);
 	ck_assert_int_eq(dst.data[2], 0xFF);
 	ck_assert_int_eq(dst.data[3], 0x7F);
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 }
 END_TEST
 START_TEST(UA_UInt32_encodeShallEncodeLittleEndian) {
@@ -1027,7 +807,7 @@ START_TEST(UA_UInt32_encodeShallEncodeLittleEndian) {
 		                      0x55,       0x55, 0x55,       0x55 };
 	UA_ByteString dst    = { 8, data };
 
-	UA_Int32      retval = 0;
+	UA_StatusCode retval = 0;
 	UA_UInt32     pos    = 0;
 
 	// when test 1
@@ -1039,7 +819,7 @@ START_TEST(UA_UInt32_encodeShallEncodeLittleEndian) {
 	ck_assert_int_eq(dst.data[1], 0xFF);
 	ck_assert_int_eq(dst.data[2], 0xFF);
 	ck_assert_int_eq(dst.data[3], 0xFF);
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 
 	// when test 2
 	src    = 0x0101FF00;
@@ -1050,7 +830,7 @@ START_TEST(UA_UInt32_encodeShallEncodeLittleEndian) {
 	ck_assert_int_eq(dst.data[5], 0xFF);
 	ck_assert_int_eq(dst.data[6], 0x01);
 	ck_assert_int_eq(dst.data[7], 0x01);
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 }
 END_TEST
 START_TEST(UA_Int32_encodeShallEncodeLittleEndian) {
@@ -1072,7 +852,7 @@ START_TEST(UA_Int32_encodeShallEncodeLittleEndian) {
 	ck_assert_int_eq(dst.data[1], 0x00);
 	ck_assert_int_eq(dst.data[2], 0x00);
 	ck_assert_int_eq(dst.data[3], 0x00);
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 
 	// when test 2
 	src    = 0x7FFFFFFF;
@@ -1083,7 +863,7 @@ START_TEST(UA_Int32_encodeShallEncodeLittleEndian) {
 	ck_assert_int_eq(dst.data[5], 0xFF);
 	ck_assert_int_eq(dst.data[6], 0xFF);
 	ck_assert_int_eq(dst.data[7], 0x7F);
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 }
 END_TEST
 START_TEST(UA_Int32_encodeNegativeShallEncodeLittleEndian) {
@@ -1105,7 +885,7 @@ START_TEST(UA_Int32_encodeNegativeShallEncodeLittleEndian) {
 	ck_assert_int_eq(dst.data[1], 0xFF);
 	ck_assert_int_eq(dst.data[2], 0xFF);
 	ck_assert_int_eq(dst.data[3], 0xFF);
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 }
 END_TEST
 START_TEST(UA_UInt64_encodeShallWorkOnExample) {
@@ -1115,7 +895,7 @@ START_TEST(UA_UInt64_encodeShallWorkOnExample) {
 		                      0x55,       0x55, 0x55,       0x55, 0x55,       0x55,       0x55,       0x55 };
 	UA_ByteString dst    = { 16, data };
 
-	UA_Int32      retval = 0;
+	UA_StatusCode retval = 0;
 	UA_UInt32     pos    = 0;
 
 	// when test 1
@@ -1131,7 +911,7 @@ START_TEST(UA_UInt64_encodeShallWorkOnExample) {
 	ck_assert_int_eq(dst.data[5], 0xFF);
 	ck_assert_int_eq(dst.data[6], 0xFF);
 	ck_assert_int_eq(dst.data[7], 0xFF);
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 
 	// when test 2
 	src    = 0x7F0033AA44EE6611;
@@ -1146,7 +926,7 @@ START_TEST(UA_UInt64_encodeShallWorkOnExample) {
 	ck_assert_int_eq(dst.data[13], 0x33);
 	ck_assert_int_eq(dst.data[14], 0x00);
 	ck_assert_int_eq(dst.data[15], 0x7F);
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 }
 END_TEST
 START_TEST(UA_Int64_encodeShallEncodeLittleEndian) {
@@ -1172,7 +952,7 @@ START_TEST(UA_Int64_encodeShallEncodeLittleEndian) {
 	ck_assert_int_eq(dst.data[5], 0x33);
 	ck_assert_int_eq(dst.data[6], 0x00);
 	ck_assert_int_eq(dst.data[7], 0x7F);
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 }
 END_TEST
 START_TEST(UA_Int64_encodeNegativeShallEncodeLittleEndian) {
@@ -1198,7 +978,7 @@ START_TEST(UA_Int64_encodeNegativeShallEncodeLittleEndian) {
 	ck_assert_int_eq(dst.data[5], 0xFF);
 	ck_assert_int_eq(dst.data[6], 0xFF);
 	ck_assert_int_eq(dst.data[7], 0xFF);
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 }
 END_TEST
 START_TEST(UA_Float_encodeShallWorkOnExample) {
@@ -1218,7 +998,7 @@ START_TEST(UA_Float_encodeShallWorkOnExample) {
 	ck_assert_int_eq(pos, 4);
 	ck_assert_int_eq(dst.data[2], 0xD0);
 	ck_assert_int_eq(dst.data[3], 0xC0);
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 }
 END_TEST
 /*START_TEST(UA_Double_encodeShallWorkOnExample)
@@ -1239,7 +1019,7 @@ END_TEST
     ck_assert_int_eq(pos, 8);
     ck_assert_int_eq(dst.data[6], 0xD0);
     ck_assert_int_eq(dst.data[7], 0xC0);
-    ck_assert_int_eq(retval, UA_SUCCESS);
+    ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
    }
    END_TEST*/
 START_TEST(UA_String_encodeShallWorkOnExample) {
@@ -1268,7 +1048,7 @@ START_TEST(UA_String_encodeShallWorkOnExample) {
 	ck_assert_int_eq(dst.data[sizeof(UA_Int32)+3], 'L');
 	ck_assert_int_eq(dst.data[sizeof(UA_Int32)+4], 'T');
 	ck_assert_int_eq(dst.data[sizeof(UA_Int32)+5], 0x20); //Space
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 }
 END_TEST
 START_TEST(UA_DataValue_encodeShallWorkOnExampleWithoutVariant) {
@@ -1298,7 +1078,7 @@ START_TEST(UA_DataValue_encodeShallWorkOnExampleWithoutVariant) {
 	ck_assert_int_eq(dst.data[6], 0);
 	ck_assert_int_eq(dst.data[7], 0);
 	ck_assert_int_eq(dst.data[8], 0);
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 }
 END_TEST
 START_TEST(UA_DataValue_encodeShallWorkOnExampleWithVariant) {
@@ -1332,7 +1112,7 @@ START_TEST(UA_DataValue_encodeShallWorkOnExampleWithVariant) {
 	ck_assert_int_eq(dst.data[5], 0);
 	ck_assert_int_eq(dst.data[6], 80);  // the server timestamp
 	ck_assert_int_eq(dst.data[7], 0);
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 }
 END_TEST
 START_TEST(UA_DateTime_toStructShallWorkOnExample) {
@@ -1498,7 +1278,7 @@ END_TEST
 START_TEST(UA_ApplicationDescription_copyShallWorkOnExample) {
 	//given
 
-	UA_Int32  retval = UA_SUCCESS;
+	UA_StatusCode retval = UA_STATUSCODE_GOOD;
 	UA_String appString = (UA_String){3, (UA_Byte*)"APP"};
 	UA_String discString = (UA_String){4, (UA_Byte*)"DISC"};
 	UA_String gateWayString = (UA_String){7, (UA_Byte*)"GATEWAY"};
@@ -1520,7 +1300,7 @@ START_TEST(UA_ApplicationDescription_copyShallWorkOnExample) {
 	retval = UA_ApplicationDescription_copy(&value, &copiedValue);
 
 	//then
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 
 	for(UA_Int32 i = 0;i < appString.length;i++)
 		ck_assert_int_eq(copiedValue.applicationUri.data[i], value.applicationUri.data[i]);
@@ -1553,78 +1333,43 @@ START_TEST(UA_QualifiedName_copyShallWorkOnInputExample) {
 	// given
 	UA_String srcName = (UA_String){8, (UA_Byte*)"tEsT123!"};
 	UA_QualifiedName src = {5, srcName};
-
 	UA_QualifiedName dst;
-	UA_Int32 ret;
 
 	// when
-	ret = UA_QualifiedName_copy(&src, &dst);
+	UA_StatusCode ret = UA_QualifiedName_copy(&src, &dst);
 	// then
-	ck_assert_int_eq(ret, UA_SUCCESS);
+	ck_assert_int_eq(ret, UA_STATUSCODE_GOOD);
 	ck_assert_int_eq('E', dst.name.data[1]);
 	ck_assert_int_eq('!', dst.name.data[7]);
 	ck_assert_int_eq(8, dst.name.length);
 	ck_assert_int_eq(5, dst.namespaceIndex);
 }
 END_TEST
-START_TEST(UA_QualifiedName_copyNULLInput) {
-	// given
-	UA_QualifiedName *src;
-	src = UA_NULL;
-
-	UA_QualifiedName dst;
-	UA_Int32 ret;
-
-	// when
-	ret = UA_QualifiedName_copy(src, &dst);
-	// then
-	ck_assert_int_eq(ret, UA_ERROR);
-}
-END_TEST
 START_TEST(UA_Guid_copyShallWorkOnInputExample) {
 	//given
 	const UA_Guid src = {3, 45, 1222, {8, 7, 6, 5, 4, 3, 2, 1}};
-
 	UA_Guid dst;
-	UA_Int32 ret;
 
 	//when
-	ret = UA_Guid_copy(&src, &dst);
+	UA_StatusCode ret = UA_Guid_copy(&src, &dst);
 
 	//then
-	ck_assert_int_eq(ret, UA_SUCCESS);
+	ck_assert_int_eq(ret, UA_STATUSCODE_GOOD);
 	ck_assert_int_eq(src.data1, dst.data1);
 	ck_assert_int_eq(src.data3, dst.data3);
 	ck_assert_int_eq(src.data4[4], dst.data4[4]);
 	//finally
 }
 END_TEST
-START_TEST(UA_Guid_copyWithNullArgumentShallReturn) {
-	//given
-	UA_Guid *src = UA_NULL;
-	UA_Guid *dst = UA_NULL;
-	UA_Int32 ret;
-
-	//when
-	ret = UA_Guid_copy(src, dst);
-
-	//then
-	ck_assert_int_eq(ret, UA_ERROR);
-
-	//finally
-}
-END_TEST
 START_TEST(UA_LocalizedText_copycstringShallWorkOnInputExample) {
 	// given
 	const char src[7] = {'t', 'e', 'X', 't', '1', '2', '3'};
-
 	UA_LocalizedText dst;
-	UA_Int32 ret;
 
 	// when
-	ret = UA_LocalizedText_copycstring(src, &dst);
+	UA_StatusCode ret = UA_LocalizedText_copycstring(src, &dst);
 	// then
-	ck_assert_int_eq(ret, UA_SUCCESS);
+	ck_assert_int_eq(ret, UA_STATUSCODE_GOOD);
 	ck_assert_int_eq('e', dst.locale.data[0]);
 	ck_assert_int_eq('n', dst.locale.data[1]);
 	ck_assert_int_eq('1', dst.text.data[4]);
@@ -1632,32 +1377,17 @@ 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_ERROR);
-}
-END_TEST
 START_TEST(UA_DataValue_copyShallWorkOnInputExample) {
 	// given
 	UA_Variant srcVariant;
 	UA_Variant_init(&srcVariant);
 	UA_DataValue src = {5, srcVariant, 44, 4, 77, 58, 8};
-
 	UA_DataValue dst;
-	UA_Int32 ret;
 
 	// when
-	ret = UA_DataValue_copy(&src, &dst);
+	UA_StatusCode ret = UA_DataValue_copy(&src, &dst);
 	// then
-	ck_assert_int_eq(ret, UA_SUCCESS);
+	ck_assert_int_eq(ret, UA_STATUSCODE_GOOD);
 	ck_assert_int_eq(5, dst.encodingMask);
 	ck_assert_int_eq(4, dst.sourceTimestamp);
 	ck_assert_int_eq(77, dst.sourcePicoseconds);
@@ -1805,33 +1535,9 @@ Suite *testSuite_builtin(void) {
 	Suite *s = suite_create("Built-in Data Types 62541-6 Table 1");
 
 	TCase *tc_calcSize = tcase_create("calcSize");
-	tcase_add_test(tc_calcSize, UA_Boolean_calcSizeWithNullArgumentShallReturnStorageSize);
-	tcase_add_test(tc_calcSize, UA_SByte_calcSizeWithNullArgumentShallReturnStorageSize);
-	tcase_add_test(tc_calcSize, UA_Byte_calcSizeWithNullArgumentShallReturnStorageSize);
-	tcase_add_test(tc_calcSize, UA_Int16_calcSizeWithNullArgumentShallReturnStorageSize);
-	tcase_add_test(tc_calcSize, UA_UInt16_calcSizeWithNullArgumentShallReturnStorageSize);
-	tcase_add_test(tc_calcSize, UA_Int32_calcSizeWithNullArgumentShallReturnStorageSize);
-	tcase_add_test(tc_calcSize, UA_UInt32_calcSizeWithNullArgumentShallReturnStorageSize);
-	tcase_add_test(tc_calcSize, UA_Int64_calcSizeWithNullArgumentShallReturnStorageSize);
-	tcase_add_test(tc_calcSize, UA_UInt64_calcSizeWithNullArgumentShallReturnStorageSize);
-	tcase_add_test(tc_calcSize, UA_Float_calcSizeWithNullArgumentShallReturnStorageSize);
-	tcase_add_test(tc_calcSize, UA_Double_calcSizeWithNullArgumentShallReturnStorageSize);
-	tcase_add_test(tc_calcSize, UA_String_calcSizeWithNullArgumentShallReturnStorageSize);
-	tcase_add_test(tc_calcSize, UA_DateTime_calcSizeWithNullArgumentShallReturnStorageSize);
-	tcase_add_test(tc_calcSize, UA_Guid_calcSizeWithNullArgumentShallReturnStorageSize);
-	tcase_add_test(tc_calcSize, UA_ByteString_calcSizeWithNullArgumentShallReturnStorageSize);
-	tcase_add_test(tc_calcSize, UA_XmlElement_calcSizeWithNullArgumentShallReturnStorageSize);
-	tcase_add_test(tc_calcSize, UA_NodeId_calcSizeWithNullArgumentShallReturnStorageSize);
-	tcase_add_test(tc_calcSize, UA_ExpandedNodeId_calcSizeWithNullArgumentShallReturnStorageSize);
-	tcase_add_test(tc_calcSize, UA_StatusCode_calcSizeWithNullArgumentShallReturnStorageSize);
-	tcase_add_test(tc_calcSize, UA_QualifiedName_calcSizeWithNullArgumentShallReturnStorageSize);
-	tcase_add_test(tc_calcSize, UA_LocalizedText_calcSizeWithNullArgumentShallReturnStorageSize);
 	tcase_add_test(tc_calcSize, UA_ExtensionObject_calcSizeShallWorkOnExample);
-	tcase_add_test(tc_calcSize, UA_ExtensionObject_calcSizeWithNullArgumentShallReturnStorageSize);
 	tcase_add_test(tc_calcSize, UA_DataValue_calcSizeShallWorkOnExample);
-	tcase_add_test(tc_calcSize, UA_DataValue_calcSizeWithNullArgumentShallReturnStorageSize);
 	tcase_add_test(tc_calcSize, UA_DiagnosticInfo_calcSizeShallWorkOnExample);
-	tcase_add_test(tc_calcSize, UA_DiagnosticInfo_calcSizeWithNullArgumentShallReturnStorageSize);
 	tcase_add_test(tc_calcSize, UA_String_calcSizeShallReturnEncodingSize);
 	tcase_add_test(tc_calcSize, UA_String_calcSizeWithNegativLengthShallReturnEncodingSize);
 	tcase_add_test(tc_calcSize, UA_String_calcSizeWithNegativLengthAndValidPointerShallReturnEncodingSize);
@@ -1916,11 +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_copyWithNullArgumentShallReturn);
 	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;
@@ -1934,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

@@ -160,8 +160,7 @@ def createStructured(element):
         printh("UA_TYPE_XML_ENCODING(" + name + ")\n")
 
     # 4) CalcSizeBinary
-    printc('''UA_Int32 %(name)s_calcSizeBinary(%(name)s const * ptr) {
-    if(!ptr) return 0;
+    printc('''UA_UInt32 %(name)s_calcSizeBinary(%(name)s const * ptr) {
     return 0''')
     has_fixed_size = True
     for n,t in membermap.iteritems():
@@ -179,29 +178,28 @@ def createStructured(element):
         fixed_size.add(name)
 
     # 5) EncodeBinary
-    printc('''UA_Int32 %(name)s_encodeBinary(%(name)s const * src, UA_ByteString* dst, UA_UInt32 *offset) {
-    UA_Int32 retval = UA_SUCCESS;''')
+    printc('''UA_StatusCode %(name)s_encodeBinary(%(name)s const * src, UA_ByteString* dst, UA_UInt32 *offset) {
+    UA_StatusCode retval = UA_STATUSCODE_GOOD;''')
     for n,t in membermap.iteritems():
         if t.find("*") != -1:
-            printc("\tretval |= UA_Array_encodeBinary(src->%(n)s,src->%(n)sSize,&UA_[" +
-                   t[0:t.find("*")].upper() + "],dst,offset);")
+            printc("\tretval |= UA_Array_encodeBinary(src->%(n)s,src->%(n)sSize,&UA_[" + t[0:t.find("*")].upper() + "],dst,offset);")
         else:
             printc('\tretval |= %(t)s_encodeBinary(&src->%(n)s,dst,offset);')
     printc("\treturn retval;\n}\n")
 
     # 6) DecodeBinary
-    printc('''UA_Int32 %(name)s_decodeBinary(UA_ByteString const * src, UA_UInt32 *offset, %(name)s * dst) {
-    UA_Int32 retval = UA_SUCCESS;''')
+    printc('''UA_StatusCode %(name)s_decodeBinary(UA_ByteString const * src, UA_UInt32 *offset, %(name)s * dst) {
+    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:
             printc('\tretval |= UA_Int32_decodeBinary(src,offset,&dst->%(n)sSize);')
-            printc('\tretval |= UA_Array_decodeBinary(src,offset,dst->%(n)sSize,&UA_[' +
-                   t[0:t.find("*")].upper() + '],(void**)&dst->%(n)s);')
-            printc('\tif(retval != UA_SUCCESS) { dst->%(n)sSize = -1; %(name)s_deleteMembers(dst); return retval;}') # arrays clean up internally. But the size needs to be set here for the eventual deleteMembers.
+            printc('\tif(!retval) { retval |= UA_Array_decodeBinary(src,offset,dst->%(n)sSize,&UA_[' + t[0:t.find("*")].upper() + '],(void**)&dst->%(n)s); }')
+            printc('\tif(retval) { dst->%(n)sSize = -1; }') # arrays clean up internally. But the size needs to be set here for the eventual deleteMembers.
         else:
             printc('\tretval |= %(t)s_decodeBinary(src,offset,&dst->%(n)s);')
-    printc("\tif(retval != UA_SUCCESS) %(name)s_deleteMembers(dst);")
+    printc("\tif(retval) %(name)s_deleteMembers(dst);")
     printc("\treturn retval;\n}\n")
 
     # 7) Xml
@@ -220,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) {
@@ -235,15 +232,14 @@ 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)")
 
     # 12) Copy
-    printc('''UA_Int32 %(name)s_copy(const %(name)s *src,%(name)s *dst) {
-	UA_Int32 retval = UA_SUCCESS;
-    if(src == UA_NULL || dst == UA_NULL) return UA_ERROR;''')
+    printc('''UA_StatusCode %(name)s_copy(const %(name)s *src,%(name)s *dst) {
+	UA_StatusCode retval = UA_STATUSCODE_GOOD;''')
     printc("\t%(name)s_init(dst);")
     for n,t in membermap.iteritems():
         if t.find("*") != -1:
@@ -254,8 +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 != UA_SUCCESS)
-    %(name)s_deleteMembers(dst);''')
+    printc('''\tif(retval)
+    \t%(name)s_deleteMembers(dst);''')
     printc("\treturn retval;\n}\n")
 
     # 13) Print