simplify. _new() returns a pointer to the new object

examples/opcuaServer.c

@@ -67,12 +67,10 @@ int main(int argc, char** argv) {
 
 #ifdef BENCHMARK
     UA_UInt32 nodeCount = 500;
-    UA_VariableNode *tmpNode;
-
     UA_Int32 data = 42;
     char str[15];
     for(UA_UInt32 i = 0;i<nodeCount;i++) {
-        UA_VariableNode_new(&tmpNode);
+        UA_VariableNode *tmpNode = UA_VariableNode_new();
         sprintf(str,"%d",i);
         UA_QualifiedName_copycstring(str,&tmpNode->browseName);
         UA_LocalizedText_copycstring(str,&tmpNode->displayName);

include/ua_types.h

@@ -41,7 +41,7 @@ extern "C" {
  * PERMITTED.
  *
  * - <type>_new: Allocates the memory for the type and runs <type>_init on the
- *     returned variable.
+ *     returned variable. Returns null if no memory could be allocated.
  *
  * - <type>_init: Sets all members to a "safe" standard, usually zero. Arrays
  *   (e.g. for strings) are set to a length of -1.
@@ -301,7 +301,7 @@ typedef void UA_InvalidType;
 #endif
     
 #define UA_TYPE_PROTOTYPES(TYPE)                                     \
-    UA_StatusCode UA_EXPORT TYPE##_new(TYPE **p);                    \
+    TYPE UA_EXPORT * TYPE##_new();                                   \
     void UA_EXPORT TYPE##_init(TYPE * p);                            \
     void UA_EXPORT TYPE##_delete(TYPE * p);                          \
     void UA_EXPORT TYPE##_deleteMembers(TYPE * p);                   \
@@ -309,7 +309,7 @@ typedef void UA_InvalidType;
     PRINTTYPE(TYPE)
 
 #define UA_TYPE_PROTOTYPES_NOEXPORT(TYPE)                            \
-    UA_StatusCode TYPE##_new(TYPE **p);                              \
+    TYPE * TYPE##_new();                                             \
     void TYPE##_init(TYPE * p);                                      \
     void TYPE##_delete(TYPE * p);                                    \
     void TYPE##_deleteMembers(TYPE * p);                             \
@@ -453,7 +453,7 @@ typedef struct UA_Encoding {
 struct UA_VTable_Entry {
     UA_NodeId     typeId;
     UA_Byte       *name;
-    UA_StatusCode (*new)(void **p);
+    void *        (*new)();
     void          (*init)(void *p);
     UA_StatusCode (*copy)(void const *src, void *dst);
     void          (*delete)(void *p);
@@ -480,11 +480,10 @@ struct UA_VTable_Entry {
     UA_TYPE_COPY_DEFAULT(TYPE)           \
     
 #define UA_TYPE_NEW_DEFAULT(TYPE)                             \
-    UA_StatusCode TYPE##_new(TYPE **p) {                      \
-        if(!(*p = UA_alloc(sizeof(TYPE))))                    \
-            return UA_STATUSCODE_BADOUTOFMEMORY;              \
-        TYPE##_init(*p);                                      \
-        return UA_STATUSCODE_GOOD;                            \
+    TYPE * TYPE##_new() {                                     \
+        TYPE *p = UA_alloc(sizeof(TYPE));                     \
+        if(p) TYPE##_init(p);                                 \
+        return p;                                             \
     }
 
 #define UA_TYPE_INIT_DEFAULT(TYPE) \
@@ -522,16 +521,19 @@ struct UA_VTable_Entry {
     }
 
 #define UA_TYPE_COPY_AS(TYPE, TYPE_AS)                         \
-    UA_StatusCode 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); \
     }
 
+#ifdef DEBUG //print functions only in debug mode
 #define UA_TYPE_PRINT_AS(TYPE, TYPE_AS)              \
     void TYPE##_print(TYPE const *p, FILE *stream) { \
         TYPE_AS##_print((TYPE_AS *)p, stream);       \
-    }                                                \
+    }
+#else
+#define UA_TYPE_PRINT_AS(TYPE, TYPE_AS)
+#endif
 
-#ifdef DEBUG //print functions only in debug mode
 #define UA_TYPE_AS(TYPE, TYPE_AS)           \
     UA_TYPE_NEW_DEFAULT(TYPE)               \
     UA_TYPE_INIT_AS(TYPE, TYPE_AS)          \
@@ -539,14 +541,6 @@ struct UA_VTable_Entry {
     UA_TYPE_DELETEMEMBERS_AS(TYPE, TYPE_AS) \
     UA_TYPE_COPY_AS(TYPE, TYPE_AS)          \
     UA_TYPE_PRINT_AS(TYPE, TYPE_AS)
-#else
-#define UA_TYPE_AS(TYPE, TYPE_AS)           \
-    UA_TYPE_NEW_DEFAULT(TYPE)               \
-    UA_TYPE_INIT_AS(TYPE, TYPE_AS)          \
-    UA_TYPE_DELETE_AS(TYPE, TYPE_AS)        \
-    UA_TYPE_DELETEMEMBERS_AS(TYPE, TYPE_AS) \
-    UA_TYPE_COPY_AS(TYPE, TYPE_AS)
-#endif
 
 /// @} /* end of group */
 

src/server/ua_server.c

@@ -12,6 +12,7 @@ UA_StatusCode UA_Server_deleteMembers(UA_Server *server) {
     UA_SessionManager_delete(server->sessionManager);
     UA_NodeStore_delete(server->nodestore);
     UA_ByteString_deleteMembers(&server->serverCertificate);
+    UA_Array_delete(server->endpointDescriptions, server->endpointDescriptionsSize, &UA_[UA_ENDPOINTDESCRIPTION]);
     return UA_STATUSCODE_GOOD;
 }
 
@@ -108,8 +109,7 @@ void UA_Server_init(UA_Server *server, UA_String *endpointUrl, UA_ByteString *se
     AddReference(server->nodestore, (UA_Node *)NODE, &NODE##REFTYPE##TARGET_NODEID); \
     } while(0)
     
-    UA_ReferenceTypeNode *references;
-    UA_ReferenceTypeNode_new(&references);
+    UA_ReferenceTypeNode *references = UA_ReferenceTypeNode_new();
     references->nodeId    = RefTypeId_References.nodeId;
     references->nodeClass = UA_NODECLASS_REFERENCETYPE;
     UA_QualifiedName_copycstring("References", &references->browseName);
@@ -119,8 +119,7 @@ void UA_Server_init(UA_Server *server, UA_String *endpointUrl, UA_ByteString *se
     references->symmetric  = UA_TRUE;
     UA_NodeStore_insert(server->nodestore, (UA_Node**)&references, UA_NODESTORE_INSERT_UNIQUE);
 
-    UA_ReferenceTypeNode *hierarchicalreferences;
-    UA_ReferenceTypeNode_new(&hierarchicalreferences);
+    UA_ReferenceTypeNode *hierarchicalreferences = UA_ReferenceTypeNode_new();
     hierarchicalreferences->nodeId    = RefTypeId_HierarchicalReferences.nodeId;
     hierarchicalreferences->nodeClass = UA_NODECLASS_REFERENCETYPE;
     UA_QualifiedName_copycstring("HierarchicalReferences", &hierarchicalreferences->browseName);
@@ -131,8 +130,7 @@ void UA_Server_init(UA_Server *server, UA_String *endpointUrl, UA_ByteString *se
     ADDREFERENCE(hierarchicalreferences, RefTypeId_HasSubtype, UA_TRUE, RefTypeId_References);
     UA_NodeStore_insert(server->nodestore, (UA_Node**)&hierarchicalreferences, UA_NODESTORE_INSERT_UNIQUE);
 
-    UA_ReferenceTypeNode *nonhierarchicalreferences;
-    UA_ReferenceTypeNode_new(&nonhierarchicalreferences);
+    UA_ReferenceTypeNode *nonhierarchicalreferences = UA_ReferenceTypeNode_new();
     nonhierarchicalreferences->nodeId    = RefTypeId_NonHierarchicalReferences.nodeId;
     nonhierarchicalreferences->nodeClass = UA_NODECLASS_REFERENCETYPE;
     UA_QualifiedName_copycstring("NonHierarchicalReferences", &nonhierarchicalreferences->browseName);
@@ -143,8 +141,7 @@ void UA_Server_init(UA_Server *server, UA_String *endpointUrl, UA_ByteString *se
     ADDREFERENCE(nonhierarchicalreferences, RefTypeId_HasSubtype, UA_TRUE, RefTypeId_References);
     UA_NodeStore_insert(server->nodestore, (UA_Node**)&nonhierarchicalreferences, UA_NODESTORE_INSERT_UNIQUE);
 
-    UA_ReferenceTypeNode *haschild;
-    UA_ReferenceTypeNode_new(&haschild);
+    UA_ReferenceTypeNode *haschild = UA_ReferenceTypeNode_new();
     haschild->nodeId    = RefTypeId_HasChild.nodeId;
     haschild->nodeClass = UA_NODECLASS_REFERENCETYPE;
     UA_QualifiedName_copycstring("HasChild", &haschild->browseName);
@@ -155,8 +152,7 @@ void UA_Server_init(UA_Server *server, UA_String *endpointUrl, UA_ByteString *se
     ADDREFERENCE(haschild, RefTypeId_HasSubtype, UA_TRUE, RefTypeId_HierarchicalReferences);
     UA_NodeStore_insert(server->nodestore, (UA_Node**)&haschild, UA_NODESTORE_INSERT_UNIQUE);
 
-    UA_ReferenceTypeNode *organizes;
-    UA_ReferenceTypeNode_new(&organizes);
+    UA_ReferenceTypeNode *organizes = UA_ReferenceTypeNode_new();
     organizes->nodeId    = RefTypeId_Organizes.nodeId;
     organizes->nodeClass = UA_NODECLASS_REFERENCETYPE;
     UA_QualifiedName_copycstring("Organizes", &organizes->browseName);
@@ -168,8 +164,7 @@ void UA_Server_init(UA_Server *server, UA_String *endpointUrl, UA_ByteString *se
     ADDREFERENCE(organizes, RefTypeId_HasSubtype, UA_TRUE, RefTypeId_HierarchicalReferences);
     UA_NodeStore_insert(server->nodestore, (UA_Node**)&organizes, UA_NODESTORE_INSERT_UNIQUE);
 
-    UA_ReferenceTypeNode *haseventsource;
-    UA_ReferenceTypeNode_new(&haseventsource);
+    UA_ReferenceTypeNode *haseventsource = UA_ReferenceTypeNode_new();
     haseventsource->nodeId    = RefTypeId_HasEventSource.nodeId;
     haseventsource->nodeClass = UA_NODECLASS_REFERENCETYPE;
     UA_QualifiedName_copycstring("HasEventSource", &haseventsource->browseName);
@@ -181,8 +176,7 @@ void UA_Server_init(UA_Server *server, UA_String *endpointUrl, UA_ByteString *se
     ADDREFERENCE(haseventsource, RefTypeId_HasSubtype, UA_TRUE, RefTypeId_HierarchicalReferences);
     UA_NodeStore_insert(server->nodestore, (UA_Node**)&haseventsource, UA_NODESTORE_INSERT_UNIQUE);
 
-    UA_ReferenceTypeNode *hasmodellingrule;
-    UA_ReferenceTypeNode_new(&hasmodellingrule);
+    UA_ReferenceTypeNode *hasmodellingrule = UA_ReferenceTypeNode_new();
     hasmodellingrule->nodeId    = RefTypeId_HasModellingRule.nodeId;
     hasmodellingrule->nodeClass = UA_NODECLASS_REFERENCETYPE;
     UA_QualifiedName_copycstring("HasModellingRule", &hasmodellingrule->browseName);
@@ -194,8 +188,7 @@ void UA_Server_init(UA_Server *server, UA_String *endpointUrl, UA_ByteString *se
     ADDREFERENCE(hasmodellingrule, RefTypeId_HasSubtype, UA_TRUE, RefTypeId_NonHierarchicalReferences);
     UA_NodeStore_insert(server->nodestore, (UA_Node**)&hasmodellingrule, UA_NODESTORE_INSERT_UNIQUE);
 
-    UA_ReferenceTypeNode *hasencoding;
-    UA_ReferenceTypeNode_new(&hasencoding);
+    UA_ReferenceTypeNode *hasencoding = UA_ReferenceTypeNode_new();
     hasencoding->nodeId    = RefTypeId_HasEncoding.nodeId;
     hasencoding->nodeClass = UA_NODECLASS_REFERENCETYPE;
     UA_QualifiedName_copycstring("HasEncoding", &hasencoding->browseName);
@@ -207,8 +200,7 @@ void UA_Server_init(UA_Server *server, UA_String *endpointUrl, UA_ByteString *se
     ADDREFERENCE(hasencoding, RefTypeId_HasSubtype, UA_TRUE, RefTypeId_NonHierarchicalReferences);
     UA_NodeStore_insert(server->nodestore, (UA_Node**)&hasencoding, UA_NODESTORE_INSERT_UNIQUE);
 
-    UA_ReferenceTypeNode *hasdescription;
-    UA_ReferenceTypeNode_new(&hasdescription);
+    UA_ReferenceTypeNode *hasdescription = UA_ReferenceTypeNode_new();
     hasdescription->nodeId    = RefTypeId_HasDescription.nodeId;
     hasdescription->nodeClass = UA_NODECLASS_REFERENCETYPE;
     UA_QualifiedName_copycstring("HasDescription", &hasdescription->browseName);
@@ -220,8 +212,7 @@ void UA_Server_init(UA_Server *server, UA_String *endpointUrl, UA_ByteString *se
     ADDREFERENCE(hasdescription, RefTypeId_HasSubtype, UA_TRUE, RefTypeId_NonHierarchicalReferences);
     UA_NodeStore_insert(server->nodestore, (UA_Node**)&hasdescription, UA_NODESTORE_INSERT_UNIQUE);
 
-    UA_ReferenceTypeNode *hastypedefinition;
-    UA_ReferenceTypeNode_new(&hastypedefinition);
+    UA_ReferenceTypeNode *hastypedefinition = UA_ReferenceTypeNode_new();
     hastypedefinition->nodeId    = RefTypeId_HasTypeDefinition.nodeId;
     hastypedefinition->nodeClass = UA_NODECLASS_REFERENCETYPE;
     UA_QualifiedName_copycstring("HasTypeDefinition", &hastypedefinition->browseName);
@@ -233,8 +224,7 @@ void UA_Server_init(UA_Server *server, UA_String *endpointUrl, UA_ByteString *se
     ADDREFERENCE(hastypedefinition, RefTypeId_HasSubtype, UA_TRUE,  RefTypeId_NonHierarchicalReferences);
     UA_NodeStore_insert(server->nodestore, (UA_Node**)&hastypedefinition, UA_NODESTORE_INSERT_UNIQUE);
 
-    UA_ReferenceTypeNode *generatesevent;
-    UA_ReferenceTypeNode_new(&generatesevent);
+    UA_ReferenceTypeNode *generatesevent = UA_ReferenceTypeNode_new();
     generatesevent->nodeId    = RefTypeId_GeneratesEvent.nodeId;
     generatesevent->nodeClass = UA_NODECLASS_REFERENCETYPE;
     UA_QualifiedName_copycstring("GeneratesEvent", &generatesevent->browseName);
@@ -246,8 +236,7 @@ void UA_Server_init(UA_Server *server, UA_String *endpointUrl, UA_ByteString *se
     ADDREFERENCE(generatesevent, RefTypeId_HasSubtype, UA_TRUE, RefTypeId_NonHierarchicalReferences);
     UA_NodeStore_insert(server->nodestore, (UA_Node**)&generatesevent, UA_NODESTORE_INSERT_UNIQUE);
 
-    UA_ReferenceTypeNode *aggregates;
-    UA_ReferenceTypeNode_new(&aggregates);
+    UA_ReferenceTypeNode *aggregates = UA_ReferenceTypeNode_new();
     aggregates->nodeId    = RefTypeId_Aggregates.nodeId;
     aggregates->nodeClass = UA_NODECLASS_REFERENCETYPE;
     UA_QualifiedName_copycstring("Aggregates", &aggregates->browseName);
@@ -258,8 +247,7 @@ void UA_Server_init(UA_Server *server, UA_String *endpointUrl, UA_ByteString *se
     ADDREFERENCE(aggregates, RefTypeId_HasSubtype, UA_TRUE, RefTypeId_HasChild);
     UA_NodeStore_insert(server->nodestore, (UA_Node**)&aggregates, UA_NODESTORE_INSERT_UNIQUE);
 
-    UA_ReferenceTypeNode *hassubtype;
-    UA_ReferenceTypeNode_new(&hassubtype);
+    UA_ReferenceTypeNode *hassubtype = UA_ReferenceTypeNode_new();
     hassubtype->nodeId    = RefTypeId_HasSubtype.nodeId;
     hassubtype->nodeClass = UA_NODECLASS_REFERENCETYPE;
     UA_QualifiedName_copycstring("HasSubtype", &hassubtype->browseName);
@@ -271,8 +259,7 @@ void UA_Server_init(UA_Server *server, UA_String *endpointUrl, UA_ByteString *se
     ADDREFERENCE(hassubtype, RefTypeId_HasSubtype, UA_TRUE, RefTypeId_HasChild);
     UA_NodeStore_insert(server->nodestore, (UA_Node**)&hassubtype, UA_NODESTORE_INSERT_UNIQUE);
 
-    UA_ReferenceTypeNode *hasproperty;
-    UA_ReferenceTypeNode_new(&hasproperty);
+    UA_ReferenceTypeNode *hasproperty = UA_ReferenceTypeNode_new();
     hasproperty->nodeId    = RefTypeId_HasProperty.nodeId;
     hasproperty->nodeClass = UA_NODECLASS_REFERENCETYPE;
     UA_QualifiedName_copycstring("HasProperty", &hasproperty->browseName);
@@ -284,8 +271,7 @@ void UA_Server_init(UA_Server *server, UA_String *endpointUrl, UA_ByteString *se
     ADDREFERENCE(hasproperty, RefTypeId_HasSubtype, UA_TRUE, RefTypeId_Aggregates);
     UA_NodeStore_insert(server->nodestore, (UA_Node**)&hasproperty, UA_NODESTORE_INSERT_UNIQUE);
 
-    UA_ReferenceTypeNode *hascomponent;
-    UA_ReferenceTypeNode_new(&hascomponent);
+    UA_ReferenceTypeNode *hascomponent = UA_ReferenceTypeNode_new();
     hascomponent->nodeId    = RefTypeId_HasComponent.nodeId;
     hascomponent->nodeClass = UA_NODECLASS_REFERENCETYPE;
     UA_QualifiedName_copycstring("HasComponent", &hascomponent->browseName);
@@ -297,8 +283,7 @@ void UA_Server_init(UA_Server *server, UA_String *endpointUrl, UA_ByteString *se
     ADDREFERENCE(hascomponent, RefTypeId_HasSubtype, UA_TRUE, RefTypeId_Aggregates);
     UA_NodeStore_insert(server->nodestore, (UA_Node**)&hascomponent, UA_NODESTORE_INSERT_UNIQUE);
 
-    UA_ReferenceTypeNode *hasnotifier;
-    UA_ReferenceTypeNode_new(&hasnotifier);
+    UA_ReferenceTypeNode *hasnotifier = UA_ReferenceTypeNode_new();
     hasnotifier->nodeId    = RefTypeId_HasNotifier.nodeId;
     hasnotifier->nodeClass = UA_NODECLASS_REFERENCETYPE;
     UA_QualifiedName_copycstring("HasNotifier", &hasnotifier->browseName);
@@ -310,8 +295,7 @@ void UA_Server_init(UA_Server *server, UA_String *endpointUrl, UA_ByteString *se
     ADDREFERENCE(hasnotifier, RefTypeId_HasSubtype, UA_TRUE, RefTypeId_HasEventSource);
     UA_NodeStore_insert(server->nodestore, (UA_Node**)&hasnotifier, UA_NODESTORE_INSERT_UNIQUE);
 
-    UA_ReferenceTypeNode *hasorderedcomponent;
-    UA_ReferenceTypeNode_new(&hasorderedcomponent);
+    UA_ReferenceTypeNode *hasorderedcomponent = UA_ReferenceTypeNode_new();
     hasorderedcomponent->nodeId    = RefTypeId_HasOrderedComponent.nodeId;
     hasorderedcomponent->nodeClass = UA_NODECLASS_REFERENCETYPE;
     UA_QualifiedName_copycstring("HasOrderedComponent", &hasorderedcomponent->browseName);
@@ -323,8 +307,7 @@ void UA_Server_init(UA_Server *server, UA_String *endpointUrl, UA_ByteString *se
     ADDREFERENCE(hasorderedcomponent, RefTypeId_HasSubtype, UA_TRUE, RefTypeId_HasComponent);
     UA_NodeStore_insert(server->nodestore, (UA_Node**)&hasorderedcomponent, UA_NODESTORE_INSERT_UNIQUE);
 
-    UA_ReferenceTypeNode *hasmodelparent;
-    UA_ReferenceTypeNode_new(&hasmodelparent);
+    UA_ReferenceTypeNode *hasmodelparent = UA_ReferenceTypeNode_new();
     hasmodelparent->nodeId    = RefTypeId_HasModelParent.nodeId;
     hasmodelparent->nodeClass = UA_NODECLASS_REFERENCETYPE;
     UA_QualifiedName_copycstring("HasModelParent", &hasmodelparent->browseName);
@@ -336,8 +319,7 @@ void UA_Server_init(UA_Server *server, UA_String *endpointUrl, UA_ByteString *se
     ADDREFERENCE(hasmodelparent, RefTypeId_HasSubtype, UA_TRUE, RefTypeId_NonHierarchicalReferences);
     UA_NodeStore_insert(server->nodestore, (UA_Node**)&hasmodelparent, UA_NODESTORE_INSERT_UNIQUE);
 
-    UA_ReferenceTypeNode *fromstate;
-    UA_ReferenceTypeNode_new(&fromstate);
+    UA_ReferenceTypeNode *fromstate = UA_ReferenceTypeNode_new();
     fromstate->nodeId    = RefTypeId_FromState.nodeId;
     fromstate->nodeClass = UA_NODECLASS_REFERENCETYPE;
     UA_QualifiedName_copycstring("FromState", &fromstate->browseName);
@@ -349,8 +331,7 @@ void UA_Server_init(UA_Server *server, UA_String *endpointUrl, UA_ByteString *se
     ADDREFERENCE(fromstate, RefTypeId_HasSubtype, UA_TRUE, RefTypeId_NonHierarchicalReferences);
     UA_NodeStore_insert(server->nodestore, (UA_Node**)&fromstate, UA_NODESTORE_INSERT_UNIQUE);
 
-    UA_ReferenceTypeNode *tostate;
-    UA_ReferenceTypeNode_new(&tostate);
+    UA_ReferenceTypeNode *tostate = UA_ReferenceTypeNode_new();
     tostate->nodeId    = RefTypeId_ToState.nodeId;
     tostate->nodeClass = UA_NODECLASS_REFERENCETYPE;
     UA_QualifiedName_copycstring("ToState", &tostate->browseName);
@@ -362,8 +343,7 @@ void UA_Server_init(UA_Server *server, UA_String *endpointUrl, UA_ByteString *se
     ADDREFERENCE(tostate, RefTypeId_HasSubtype, UA_TRUE, RefTypeId_NonHierarchicalReferences);
     UA_NodeStore_insert(server->nodestore, (UA_Node**)&tostate, UA_NODESTORE_INSERT_UNIQUE);
 
-    UA_ReferenceTypeNode *hascause;
-    UA_ReferenceTypeNode_new(&hascause);
+    UA_ReferenceTypeNode *hascause = UA_ReferenceTypeNode_new();
     hascause->nodeId    = RefTypeId_HasCause.nodeId;
     hascause->nodeClass = UA_NODECLASS_REFERENCETYPE;
     UA_QualifiedName_copycstring("HasCause", &hascause->browseName);
@@ -375,8 +355,7 @@ void UA_Server_init(UA_Server *server, UA_String *endpointUrl, UA_ByteString *se
     ADDREFERENCE(hascause, RefTypeId_HasSubtype, UA_TRUE, RefTypeId_NonHierarchicalReferences);
     UA_NodeStore_insert(server->nodestore, (UA_Node**)&hascause, UA_NODESTORE_INSERT_UNIQUE);
 
-    UA_ReferenceTypeNode *haseffect;
-    UA_ReferenceTypeNode_new(&haseffect);
+    UA_ReferenceTypeNode *haseffect = UA_ReferenceTypeNode_new();
     haseffect->nodeId    = RefTypeId_HasEffect.nodeId;
     haseffect->nodeClass = UA_NODECLASS_REFERENCETYPE;
     UA_QualifiedName_copycstring("HasEffect", &haseffect->browseName);
@@ -388,8 +367,7 @@ void UA_Server_init(UA_Server *server, UA_String *endpointUrl, UA_ByteString *se
     ADDREFERENCE(haseffect, RefTypeId_HasSubtype, UA_TRUE, RefTypeId_NonHierarchicalReferences);
     UA_NodeStore_insert(server->nodestore, (UA_Node**)&haseffect, UA_NODESTORE_INSERT_UNIQUE);
 
-    UA_ReferenceTypeNode *hashistoricalconfiguration;
-    UA_ReferenceTypeNode_new(&hashistoricalconfiguration);
+    UA_ReferenceTypeNode *hashistoricalconfiguration = UA_ReferenceTypeNode_new();
     hashistoricalconfiguration->nodeId    = RefTypeId_HasHistoricalConfiguration.nodeId;
     hashistoricalconfiguration->nodeClass = UA_NODECLASS_REFERENCETYPE;
     UA_QualifiedName_copycstring("HasHistoricalConfiguration", &hashistoricalconfiguration->browseName);
@@ -417,8 +395,7 @@ void UA_Server_init(UA_Server *server, UA_String *endpointUrl, UA_ByteString *se
     UA_ExpandedNodeId ObjId_State; NS0EXPANDEDNODEID(ObjId_State, 2259);
 
     // FolderType
-    UA_ObjectNode *folderType;
-    UA_ObjectNode_new(&folderType);
+    UA_ObjectNode *folderType = UA_ObjectNode_new();
     folderType->nodeId    = NS0NODEID(61);
     folderType->nodeClass = UA_NODECLASS_OBJECTTYPE; // I should not have to set this manually
     UA_QualifiedName_copycstring("FolderType", &folderType->browseName);
@@ -427,8 +404,7 @@ void UA_Server_init(UA_Server *server, UA_String *endpointUrl, UA_ByteString *se
     UA_NodeStore_insert(server->nodestore, (UA_Node**)&folderType, UA_NODESTORE_INSERT_UNIQUE);
 
     // Root
-    UA_ObjectNode *root;
-    UA_ObjectNode_new(&root);
+    UA_ObjectNode *root = UA_ObjectNode_new();
     root->nodeId    = NS0NODEID(84);
     root->nodeClass = UA_NODECLASS_OBJECT; // I should not have to set this manually
     UA_QualifiedName_copycstring("Root", &root->browseName);
@@ -442,8 +418,7 @@ void UA_Server_init(UA_Server *server, UA_String *endpointUrl, UA_ByteString *se
     UA_NodeStore_insert(server->nodestore, (UA_Node**)&root, UA_NODESTORE_INSERT_UNIQUE | UA_NODESTORE_INSERT_GETMANAGED);
 
     // Objects
-    UA_ObjectNode *objects;
-    UA_ObjectNode_new(&objects);
+    UA_ObjectNode *objects = UA_ObjectNode_new();
     objects->nodeId    = ObjId_ObjectsFolder.nodeId;
     objects->nodeClass = UA_NODECLASS_OBJECT;
     UA_QualifiedName_copycstring("Objects", &objects->browseName);
@@ -454,8 +429,7 @@ void UA_Server_init(UA_Server *server, UA_String *endpointUrl, UA_ByteString *se
     UA_NodeStore_insert(server->nodestore, (UA_Node**)&objects, UA_NODESTORE_INSERT_UNIQUE);
 
     // Types
-    UA_ObjectNode *types;
-    UA_ObjectNode_new(&types);
+    UA_ObjectNode *types = UA_ObjectNode_new();
     types->nodeId    = ObjId_TypesFolder.nodeId;
     types->nodeClass = UA_NODECLASS_OBJECT;
     UA_QualifiedName_copycstring("Types", &types->browseName);
@@ -465,8 +439,7 @@ void UA_Server_init(UA_Server *server, UA_String *endpointUrl, UA_ByteString *se
     UA_NodeStore_insert(server->nodestore, (UA_Node**)&types, UA_NODESTORE_INSERT_UNIQUE);
 
     // Views
-    UA_ObjectNode *views;
-    UA_ObjectNode_new(&views);
+    UA_ObjectNode *views = UA_ObjectNode_new();
     views->nodeId    = ObjId_ViewsFolder.nodeId;
     views->nodeClass = UA_NODECLASS_OBJECT;
     UA_QualifiedName_copycstring("Views", &views->browseName);
@@ -476,8 +449,7 @@ void UA_Server_init(UA_Server *server, UA_String *endpointUrl, UA_ByteString *se
     UA_NodeStore_insert(server->nodestore, (UA_Node**)&views, UA_NODESTORE_INSERT_UNIQUE);
 
     // Server
-    UA_ObjectNode *servernode;
-    UA_ObjectNode_new(&servernode);
+    UA_ObjectNode *servernode = UA_ObjectNode_new();
     servernode->nodeId    = ObjId_Server.nodeId;
     servernode->nodeClass = UA_NODECLASS_OBJECT;
     UA_QualifiedName_copycstring("Server", &servernode->browseName);
@@ -490,14 +462,13 @@ void UA_Server_init(UA_Server *server, UA_String *endpointUrl, UA_ByteString *se
     UA_NodeStore_insert(server->nodestore, (UA_Node**)&servernode, UA_NODESTORE_INSERT_UNIQUE);
 
     // NamespaceArray
-    UA_VariableNode *namespaceArray;
-    UA_VariableNode_new(&namespaceArray);
+    UA_VariableNode *namespaceArray = UA_VariableNode_new();
     namespaceArray->nodeId    = ObjId_NamespaceArray.nodeId;
     namespaceArray->nodeClass = UA_NODECLASS_VARIABLE; //FIXME: this should go into _new?
     UA_QualifiedName_copycstring("NodeStoreArray", &namespaceArray->browseName);
     UA_LocalizedText_copycstring("NodeStoreArray", &namespaceArray->displayName);
     UA_LocalizedText_copycstring("NodeStoreArray", &namespaceArray->description);
-    UA_Array_new((void **)&namespaceArray->value.storage.data.dataPtr, 2, &UA_[UA_STRING]);
+    UA_Array_new(&namespaceArray->value.storage.data.dataPtr, 2, &UA_[UA_STRING]);
     namespaceArray->value.vt = &UA_[UA_STRING];
     namespaceArray->value.storage.data.arrayLength = 2;
     UA_String_copycstring("http://opcfoundation.org/UA/", &((UA_String *)(namespaceArray->value.storage.data.dataPtr))[0]);
@@ -515,15 +486,13 @@ void UA_Server_init(UA_Server *server, UA_String *endpointUrl, UA_ByteString *se
     UA_NodeStore_insert(server->nodestore, (UA_Node**)&namespaceArray, UA_NODESTORE_INSERT_UNIQUE);
 
     // ServerStatus
-    UA_VariableNode *serverstatus;
-    UA_VariableNode_new(&serverstatus);
+    UA_VariableNode *serverstatus = UA_VariableNode_new();
     serverstatus->nodeId    = ObjId_ServerStatus.nodeId;
     serverstatus->nodeClass = UA_NODECLASS_VARIABLE;
     UA_QualifiedName_copycstring("ServerStatus", &serverstatus->browseName);
     UA_LocalizedText_copycstring("ServerStatus", &serverstatus->displayName);
     UA_LocalizedText_copycstring("ServerStatus", &serverstatus->description);
-    UA_ServerStatusDataType *status;
-    UA_ServerStatusDataType_new(&status);
+    UA_ServerStatusDataType *status = UA_ServerStatusDataType_new();
     status->startTime   = UA_DateTime_now();
     status->currentTime = UA_DateTime_now();
     status->state       = UA_SERVERSTATE_RUNNING;
@@ -541,8 +510,7 @@ void UA_Server_init(UA_Server *server, UA_String *endpointUrl, UA_ByteString *se
     UA_NodeStore_insert(server->nodestore, (UA_Node**)&serverstatus, UA_NODESTORE_INSERT_UNIQUE);
 
     // State (Component of ServerStatus)
-    UA_VariableNode *state;
-    UA_VariableNode_new(&state);
+    UA_VariableNode *state = UA_VariableNode_new();
     state->nodeId    = ObjId_State.nodeId;
     state->nodeClass = UA_NODECLASS_VARIABLE;
     UA_QualifiedName_copycstring("State", &state->browseName);
@@ -571,8 +539,7 @@ void UA_Server_addReference(UA_Server *server, const UA_AddReferencesRequest *re
 UA_AddNodesResult UA_Server_addScalarVariableNode(UA_Server *server, UA_String *browseName, void *value,
                                                   const UA_VTable_Entry *vt, UA_ExpandedNodeId *parentNodeId,
                                                   UA_NodeId *referenceTypeId ) {
-    UA_VariableNode *tmpNode;
-    UA_VariableNode_new(&tmpNode);
+    UA_VariableNode *tmpNode = UA_VariableNode_new();
     UA_String_copy(browseName, &tmpNode->browseName.name);
     UA_String_copy(browseName, &tmpNode->displayName.text);
     /* UA_LocalizedText_copycstring("integer value", &tmpNode->description); */

src/server/ua_server_binary.c

@@ -53,8 +53,7 @@ static void processHello(UA_Connection *connection, const UA_ByteString *msg,
     UA_TcpHelloMessage_deleteMembers(&helloMessage);
 }
 
-static void processOpen(UA_Connection *connection, UA_Server *server,
-                        const UA_ByteString *msg, UA_UInt32 *pos) {
+static void processOpen(UA_Connection *connection, UA_Server *server, const UA_ByteString *msg, UA_UInt32 *pos) {
     if(connection->state != UA_CONNECTION_ESTABLISHED) {
         // was hello exchanged before?
         if(connection->state == UA_CONNECTION_OPENING)

src/server/ua_services_attribute.c

@@ -218,8 +218,9 @@ void Service_Read(UA_Server *server, UA_Session *session, const UA_ReadRequest *
         return;
     }
 
-    if(UA_Array_new((void **)&response->results, request->nodesToReadSize, &UA_[UA_DATAVALUE]) != UA_STATUSCODE_GOOD) {
-        response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY;
+    UA_StatusCode retval = UA_Array_new((void**)&response->results, request->nodesToReadSize, &UA_[UA_DATAVALUE]);
+    if(retval) {
+        response->responseHeader.serviceResult = retval;
         return;
     }
 
@@ -361,8 +362,9 @@ 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])) {
-        response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY;
+    UA_StatusCode retval = UA_Array_new((void**)&response->results, request->nodesToWriteSize, &UA_[UA_STATUSCODE]);
+    if(retval) {
+        response->responseHeader.serviceResult = retval;
         return;
     }
     

src/server/ua_services_nodemanagement.c

@@ -32,8 +32,8 @@ static UA_StatusCode parseVariableNode(UA_ExtensionObject *attributes, UA_Node *
     if(UA_VariableAttributes_decodeBinary(&attributes->body, &pos, &attr) != UA_STATUSCODE_GOOD)
         return UA_STATUSCODE_BADNODEATTRIBUTESINVALID;
 
-    UA_VariableNode *vnode;
-    if(UA_VariableNode_new(&vnode) != UA_STATUSCODE_GOOD) {
+    UA_VariableNode *vnode = UA_VariableNode_new();
+    if(!vnode) {
         UA_VariableAttributes_deleteMembers(&attr);
         return UA_STATUSCODE_BADOUTOFMEMORY;
     }
@@ -182,16 +182,14 @@ static void addNodeFromAttributes(UA_Server *server, UA_Session *session, UA_Add
 
 void Service_AddNodes(UA_Server *server, UA_Session *session,
                       const UA_AddNodesRequest *request, UA_AddNodesResponse *response) {
-    UA_assert(server != UA_NULL && session != UA_NULL);
-
     if(request->nodesToAddSize <= 0) {
         response->responseHeader.serviceResult = UA_STATUSCODE_BADNOTHINGTODO;
         return;
     }
 
-    if(UA_Array_new((void **)&response->results, request->nodesToAddSize, &UA_[UA_ADDNODESRESULT])
-       != UA_STATUSCODE_GOOD) {
-        response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY;
+    UA_StatusCode retval = UA_Array_new((void**)&response->results, request->nodesToAddSize, &UA_[UA_ADDNODESRESULT]);
+    if(retval) {
+        response->responseHeader.serviceResult = retval;
         return;
     }
     

src/server/ua_services_view.c

@@ -224,9 +224,9 @@ void Service_Browse(UA_Server *server, UA_Session *session, const UA_BrowseReque
         return;
     }
 
-    if(UA_Array_new((void **)&(response->results), request->nodesToBrowseSize, &UA_[UA_BROWSERESULT])
-       != UA_STATUSCODE_GOOD) {
-        response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY;
+    UA_StatusCode retval = UA_Array_new((void**)&response->results, request->nodesToBrowseSize, &UA_[UA_BROWSERESULT]);
+    if(retval) {
+        response->responseHeader.serviceResult = retval;
         return;
     }
         
@@ -244,14 +244,13 @@ void Service_TranslateBrowsePathsToNodeIds(UA_Server *server, UA_Session *sessio
         return;
     }
 
-    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_STATUSCODE_GOOD) {
-        response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY;
+    UA_StatusCode retval = UA_Array_new((void**)&response->results, request->browsePathsSize, &UA_[UA_BROWSEPATHRESULT]);
+    if(retval) {
+        response->responseHeader.serviceResult = retval;
         return;
     }
 
-    for(UA_Int32 i = 0;i < request->browsePathsSize;i++)
+    response->resultsSize = request->browsePathsSize;
+    for(UA_Int32 i = 0;i < response->resultsSize;i++)
         response->results[i].statusCode = UA_STATUSCODE_BADNOMATCH; //FIXME: implement
 }

src/ua_session.c

@@ -41,11 +41,10 @@ UA_Session adminSession = {
     .validTill = UA_INT64_MAX,
     .channel = UA_NULL};
 
-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_STATUSCODE_GOOD;
+UA_Session * UA_Session_new() {
+    UA_Session *s = UA_alloc(sizeof(UA_Session));
+    if(s) UA_Session_init(s);
+    return s;
 }
 
 /* mock up function to generate tokens for authentication */

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_StatusCode UA_Session_new(UA_Session **session);
+UA_Session * UA_Session_new();
 void UA_Session_init(UA_Session *session);
 void UA_Session_delete(UA_Session *session);
 void UA_Session_deleteMembers(UA_Session *session);

src/ua_types.c

@@ -159,15 +159,18 @@ void UA_String_print(const UA_String *p, FILE *stream) {
 }
 #endif
 
-/* The c-string needs to be null-terminated. */
+/* The c-string needs to be null-terminated. the string cannot be smaller than zero. */
 UA_Int32 UA_String_copycstring(char const *src, UA_String *dst) {
-    dst->length = strlen(src);
-    if(dst->length > 0) {
-        if(!(dst->data = UA_alloc(dst->length))) {
-            dst->length = -1;
-            return UA_STATUSCODE_BADOUTOFMEMORY;
-        }
-        UA_memcpy(dst->data, src, dst->length);
+    UA_Int32 length = strlen(src);
+    if(length == 0) {
+        dst->length = 0;
+        dst->data = UA_NULL;
+    } else if((dst->data = UA_alloc(length)) != UA_NULL) {
+        memcpy(dst->data, src, length);
+        dst->length = length;
+    } else {
+        dst->length = -1;
+        return UA_STATUSCODE_BADOUTOFMEMORY;
     }
     return UA_STATUSCODE_GOOD;
 }
@@ -305,9 +308,9 @@ UA_DateTimeStruct UA_DateTime_toStruct(UA_DateTime time) {
 
 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)))
+    if(!(timeString->data = UA_alloc(32)))
         return UA_STATUSCODE_BADOUTOFMEMORY;
-    timeString->length = 30;
+    timeString->length = 31;
 
     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,
@@ -856,9 +859,11 @@ UA_StatusCode UA_Variant_copySetValue(UA_Variant *v, const UA_VTable_Entry *vt,
     UA_Variant_init(v);
     v->vt = vt;
     v->storage.data.arrayLength = 1; // no array but a single entry
-    UA_StatusCode retval = vt->new(&v->storage.data.dataPtr);
-    if(retval == UA_STATUSCODE_GOOD)
+    UA_StatusCode retval = UA_STATUSCODE_GOOD;
+    if((v->storage.data.dataPtr = vt->new()))
         retval |= vt->copy(value, v->storage.data.dataPtr);
+    else
+        retval = UA_STATUSCODE_BADOUTOFMEMORY;
     if(retval) {
         UA_Variant_deleteMembers(v);
         UA_Variant_init(v);
@@ -989,8 +994,8 @@ UA_StatusCode UA_InvalidType_copy(UA_InvalidType const *src, UA_InvalidType *dst
     return UA_STATUSCODE_BADINTERNALERROR;
 }
 
-UA_StatusCode UA_InvalidType_new(UA_InvalidType **p) {
-    return UA_STATUSCODE_BADINTERNALERROR;
+UA_InvalidType * UA_InvalidType_new() {
+    return UA_NULL;
 }
 
 #ifdef DEBUG
@@ -1008,12 +1013,12 @@ UA_StatusCode UA_Array_new(void **p, UA_Int32 noElements, const UA_VTable_Entry
         *p = UA_NULL;
         return UA_STATUSCODE_GOOD;
     }
-
-    // FIXME! Arrays cannot be larger than 100MB.
-    // This was randomly chosen so that the development VM does not blow up.
-    if(noElements > (2^16)) {
+    
+    // Arrays cannot be larger than 2^16 elements. This was randomly chosen so
+    // that the development VM does not blow up during fuzzing tests.
+    if(noElements > (1<<15)) {
         *p = UA_NULL;
-        return UA_STATUSCODE_BADINTERNALERROR;
+        return UA_STATUSCODE_BADOUTOFMEMORY;
     }
 
     if(!(*p = UA_alloc(vt->memSize * noElements)))
@@ -1045,10 +1050,8 @@ void UA_Array_delete(void *p, UA_Int32 noElements, const UA_VTable_Entry *vt) {
 
 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;
+    if(retval)
         return retval;
-    }
 
     UA_Byte *csrc = (UA_Byte *)src; // so compilers allow pointer arithmetic
     UA_Byte *cdst = (UA_Byte *)*dst;

src/ua_types_encoding_binary.c

@@ -84,13 +84,13 @@ UA_StatusCode UA_Array_decodeBinary(const UA_ByteString *src, UA_UInt32 *offset,
         return UA_STATUSCODE_GOOD;
     }
 
-    UA_StatusCode retval  = UA_Array_new(dst, length, vt);
+    UA_StatusCode retval = UA_Array_new(dst, length, vt);
     if(retval)
         return retval;
-        
-    UA_Byte      *arr     = (UA_Byte *)*dst;
-    UA_Int32      i       = 0;
-    UA_UInt32     memSize = vt->memSize;
+    
+    UA_Byte  *arr     = (UA_Byte *)*dst;
+    UA_Int32  i       = 0;
+    UA_UInt32 memSize = vt->memSize;
     for(;i < length && !retval;i++) {
         retval |= vt->encodings[UA_ENCODING_BINARY].decode(src, offset, arr);
         arr    += memSize;

tests/CMakeLists.txt

@@ -34,7 +34,7 @@ add_test(services_view ${CMAKE_CURRENT_BINARY_DIR}/check_services_view)
 
 add_executable(check_nodestore $<TARGET_OBJECTS:open62541-objects> check_nodestore.c)
 target_link_libraries(check_nodestore ${LIBS})
-add_test(namespace ${CMAKE_CURRENT_BINARY_DIR}/check_nodestore)
+add_test(nodestore ${CMAKE_CURRENT_BINARY_DIR}/check_nodestore)
 
 # add_executable(check_startup check_startup.c)
 # target_link_libraries(check_startup ${LIBS})

tests/check_builtin.c

@@ -642,7 +642,7 @@ START_TEST(UA_Variant_decodeWithOutArrayFlagSetShallSetVTAndAllocateMemoryForArr
 	// then
 	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_ptr_eq((void *)dst.vt, (void *)&UA_[UA_INT32]);
 	ck_assert_int_eq(dst.storage.data.arrayLength, 1);
 	ck_assert_int_eq(*(UA_Int32 *)dst.storage.data.dataPtr, 255);
 	// finally
@@ -664,7 +664,7 @@ START_TEST(UA_Variant_decodeWithArrayFlagSetShallSetVTAndAllocateMemoryForArray)
 	// then
 	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_ptr_eq((void*)dst.vt, (void*)&UA_[UA_INT32]);
 	ck_assert_int_eq(dst.storage.data.arrayLength, 2);
 	ck_assert_int_eq(((UA_Int32 *)dst.storage.data.dataPtr)[0], 255);
 	ck_assert_int_eq(((UA_Int32 *)dst.storage.data.dataPtr)[1], -1);
@@ -1154,6 +1154,7 @@ START_TEST(UA_DateTime_toStringShallWorkOnExample) {
 	ck_assert_int_eq(dst.data[2], '/');
 	ck_assert_int_eq(dst.data[3], '1');
 	ck_assert_int_eq(dst.data[4], '4');
+    UA_String_deleteMembers(&dst);
 }
 END_TEST
 START_TEST(UA_ExtensionObject_copyShallWorkOnExample) {
@@ -1219,7 +1220,7 @@ START_TEST(UA_Array_copyUA_StringShallWorkOnExample) {
 	// given
 	UA_Int32   i, j;
 	UA_String *srcArray;
-	UA_Array_new((void **)&srcArray, 3, &UA_[UA_STRING]);
+    UA_Array_new((void**)&srcArray, 3, &UA_[UA_STRING]);
 	UA_String *dstArray;
 
 	UA_String_copycstring("open", &srcArray[0]);
@@ -1343,6 +1344,8 @@ START_TEST(UA_QualifiedName_copyShallWorkOnInputExample) {
 	ck_assert_int_eq('!', dst.name.data[7]);
 	ck_assert_int_eq(8, dst.name.length);
 	ck_assert_int_eq(5, dst.namespaceIndex);
+    // finally
+    UA_QualifiedName_deleteMembers(&dst);
 }
 END_TEST
 START_TEST(UA_Guid_copyShallWorkOnInputExample) {
@@ -1363,7 +1366,7 @@ START_TEST(UA_Guid_copyShallWorkOnInputExample) {
 END_TEST
 START_TEST(UA_LocalizedText_copycstringShallWorkOnInputExample) {
 	// given
-	const char src[7] = {'t', 'e', 'X', 't', '1', '2', '3'};
+	const char src[8] = {'t', 'e', 'X', 't', '1', '2', '3', (char)0};
 	UA_LocalizedText dst;
 
 	// when
@@ -1375,6 +1378,8 @@ START_TEST(UA_LocalizedText_copycstringShallWorkOnInputExample) {
 	ck_assert_int_eq('1', dst.text.data[4]);
 	ck_assert_int_eq(2, dst.locale.length);
 	ck_assert_int_eq(7, dst.text.length);
+    // finally
+    UA_LocalizedText_deleteMembers(&dst);
 }
 END_TEST
 START_TEST(UA_DataValue_copyShallWorkOnInputExample) {
@@ -1426,7 +1431,7 @@ END_TEST
 START_TEST(UA_Variant_copyShallWorkOn1DArrayExample) {
 	// given
 	UA_String *srcArray;
-	UA_Array_new((void **)&srcArray, 3, &UA_[UA_STRING]);
+    UA_Array_new((void**)&srcArray, 3, &UA_[UA_STRING]);
 	UA_String_copycstring("__open", &srcArray[0]);
 	UA_String_copycstring("_62541", &srcArray[1]);
 	UA_String_copycstring("opc ua", &srcArray[2]);
@@ -1440,9 +1445,9 @@ START_TEST(UA_Variant_copyShallWorkOn1DArrayExample) {
 	UA_Variant_init(&copiedValue);
 
 	value.storage.data.arrayLength = 3;
-	value.storage.data.dataPtr        = (void **)srcArray;
+	value.storage.data.dataPtr  = (void *)srcArray;
 	value.storage.data.arrayDimensionsLength = 1;
-	value.storage.data.arrayDimensions       = dimensions;
+	value.storage.data.arrayDimensions  = dimensions;
 	value.vt = &UA_[UA_STRING];
 
 	//when
@@ -1452,15 +1457,17 @@ START_TEST(UA_Variant_copyShallWorkOn1DArrayExample) {
 	UA_Int32 i1 = value.storage.data.arrayDimensions[0];
 	UA_Int32 i2 = copiedValue.storage.data.arrayDimensions[0];
 	ck_assert_int_eq(i1, i2);
-
+    
 	for(UA_Int32 i = 0;i < 3;i++) {
-		for(UA_Int32 j = 0;j < 6;j++)
-			ck_assert_int_eq(((UA_String *)value.storage.data.dataPtr)[i].data[j], ((UA_String *)copiedValue.storage.data.dataPtr)[i].data[j]);
-		ck_assert_int_eq(((UA_String *)value.storage.data.dataPtr)[i].length, ((UA_String *)copiedValue.storage.data.dataPtr)[i].length);
+		for(UA_Int32 j = 0;j < 6;j++) {
+			ck_assert_int_eq(((UA_String *)value.storage.data.dataPtr)[i].data[j],
+                             ((UA_String *)copiedValue.storage.data.dataPtr)[i].data[j]);
+        }
+		ck_assert_int_eq(((UA_String *)value.storage.data.dataPtr)[i].length,
+                         ((UA_String *)copiedValue.storage.data.dataPtr)[i].length);
 	}
 	ck_assert_int_eq(((UA_String *)copiedValue.storage.data.dataPtr)[0].data[2], 'o');
 	ck_assert_int_eq(((UA_String *)copiedValue.storage.data.dataPtr)[0].data[3], 'p');
-
 	ck_assert_int_eq(value.storage.data.arrayDimensionsLength, copiedValue.storage.data.arrayDimensionsLength);
 	ck_assert_int_eq(value.storage.data.arrayLength, copiedValue.storage.data.arrayLength);
 
@@ -1472,7 +1479,7 @@ END_TEST
 START_TEST(UA_Variant_copyShallWorkOn2DArrayExample) {
 	// given
 	UA_Int32 *srcArray;
-	UA_Array_new((void **)&srcArray, 6, &UA_[UA_INT32]);
+    UA_Array_new((void**)&srcArray, 6, &UA_[UA_INT32]);
 	srcArray[0] = 0;
 	srcArray[1] = 1;
 	srcArray[2] = 2;
@@ -1481,7 +1488,7 @@ START_TEST(UA_Variant_copyShallWorkOn2DArrayExample) {
 	srcArray[5] = 5;
 
 	UA_Int32 *dimensions;
-	UA_Array_new((void **)&dimensions, 2, &UA_[UA_INT32]);
+    UA_Array_new((void**)&dimensions, 2, &UA_[UA_INT32]);
 	UA_Int32  dim1 = 3;
 	UA_Int32  dim2 = 2;
 	dimensions[0] = dim1;
@@ -1637,7 +1644,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

@@ -9,16 +9,15 @@
 
 START_TEST(newAndEmptyObjectShallBeDeleted) {
 	// given
-	UA_Int32 retval;
-	void    *obj;
+	void *obj = UA_[_i].new();
 	// when
-	retval  = UA_[_i].new(&obj);
 #ifdef DEBUG //no print functions if not in debug mode
 	UA_[_i].print(obj, stdout);
 #endif
-	UA_[_i].delete(obj);
 	// then
-	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
+	ck_assert_ptr_ne(obj, UA_NULL);
+    // finally
+	UA_[_i].delete(obj);
 }
 END_TEST
 
@@ -52,13 +51,11 @@ END_TEST
 
 START_TEST(encodeShallYieldDecode) {
 	// given
-	void         *obj1 = UA_NULL, *obj2 = UA_NULL;
 	UA_ByteString msg1, msg2;
-	UA_Int32      retval;
 	UA_UInt32     pos = 0;
-	retval = UA_[_i].new(&obj1);
+	void *obj1 = UA_[_i].new();
 	UA_ByteString_newMembers(&msg1, UA_[_i].encodings[UA_ENCODING_BINARY].calcSize(obj1));
-	retval |= UA_[_i].encodings[UA_ENCODING_BINARY].encode(obj1, &msg1, &pos);
+	UA_StatusCode retval = UA_[_i].encodings[UA_ENCODING_BINARY].encode(obj1, &msg1, &pos);
 	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);
@@ -67,7 +64,7 @@ START_TEST(encodeShallYieldDecode) {
 	}
 
 	// when
-	UA_[_i].new(&obj2);
+	void *obj2 = UA_[_i].new();
 	pos = 0; retval = UA_[_i].encodings[UA_ENCODING_BINARY].decode(&msg1, &pos, obj2);
 	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));
@@ -88,15 +85,14 @@ END_TEST
 
 START_TEST(decodeShallFailWithTruncatedBufferButSurvive) {
 	// given
-	void *obj1 = UA_NULL, *obj2 = UA_NULL;
 	UA_ByteString msg1;
 	UA_UInt32 pos;
-	UA_[_i].new(&obj1);
+	void *obj1 = UA_[_i].new();
 	UA_ByteString_newMembers(&msg1, UA_[_i].encodings[0].calcSize(obj1));
 	pos = 0; UA_[_i].encodings[0].encode(obj1, &msg1, &pos);
 	UA_[_i].delete(obj1);
 	// when
-	UA_[_i].new(&obj2);
+	void *obj2 = UA_[_i].new();
 	pos = 0;
 	msg1.length = msg1.length / 2;
 	//fprintf(stderr,"testing %s with half buffer\n",UA_[_i].name);
@@ -134,7 +130,7 @@ START_TEST(decodeScalarBasicTypeFromRandomBufferShallSucceed) {
 #endif
 		}
 		UA_UInt32 pos = 0;
-		retval |= UA_[_i].new(&obj1);
+		obj1 = UA_[_i].new();
 		retval |= UA_[_i].encodings[0].decode(&msg1, &pos, obj1);
 		//then
 		ck_assert_msg(retval == UA_STATUSCODE_GOOD, "Decoding %s from random buffer", UA_[_i].name);
@@ -147,7 +143,6 @@ END_TEST
 
 START_TEST(decodeComplexTypeFromRandomBufferShallSurvive) {
 	// given
-	void    *obj1 = UA_NULL;
 	UA_ByteString msg1;
 	UA_Int32 retval = UA_STATUSCODE_GOOD;
 	UA_Int32 buflen = 256;
@@ -169,7 +164,7 @@ START_TEST(decodeComplexTypeFromRandomBufferShallSurvive) {
 #endif
 		}
 		UA_UInt32 pos = 0;
-		retval |= UA_[_i].new(&obj1);
+		void *obj1 = UA_[_i].new();
 		retval |= UA_[_i].encodings[0].decode(&msg1, &pos, obj1);
 		UA_[_i].delete(obj1);
 	}

tests/check_nodestore.c

@@ -30,8 +30,8 @@ START_TEST(test_UA_NodeStore) {
 }
 END_TEST
 
-UA_Int32 createNode(UA_Node** p, UA_Int16 nsid, UA_Int32 id) {
-	UA_VariableNode_new((UA_VariableNode **)p);
+UA_StatusCode createNode(UA_Node** p, UA_Int16 nsid, UA_Int32 id) {
+	*p = (UA_Node *)UA_VariableNode_new();
 	(*p)->nodeId.identifierType = UA_NODEIDTYPE_NUMERIC;
 	(*p)->nodeId.namespaceIndex = nsid;
 	(*p)->nodeId.identifier.numeric = id;
@@ -54,7 +54,7 @@ START_TEST(findNodeInUA_NodeStoreWithSingleEntry) {
 	retval = UA_NodeStore_get(ns,&n1->nodeId,&nr);
 	// then
 	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
-	ck_assert_ptr_eq(nr,n1);
+	ck_assert_ptr_eq((void*)nr, (void*)n1);
 	// finally
 	UA_NodeStore_releaseManagedNode(n1);
 	UA_NodeStore_releaseManagedNode(nr);
@@ -112,7 +112,7 @@ START_TEST(findNodeInUA_NodeStoreWithSeveralEntries) {
 	retval = UA_NodeStore_get(ns,&(n3->nodeId),&nr);
 	// then
 	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
-	ck_assert_ptr_eq(nr,n3);
+	ck_assert_ptr_eq((void*)nr, (void*)n3);
 	// finally
 	UA_NodeStore_releaseManagedNode(n3);
 	UA_NodeStore_releaseManagedNode(nr);
@@ -351,7 +351,7 @@ int main (void) {
 	int number_failed =0;
 	Suite *s = namespace_suite ();
 	SRunner *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);

tools/generate_namespace.py

@@ -160,24 +160,24 @@ for row in rows:
     printh('#define '+name.upper()+'_NS0 '+row[1])
 
     printc("\t{.typeId={.namespaceIndex = 0, .identifierType = UA_NODEIDTYPE_NUMERIC, .identifier.numeric=" + row[1] + "}" + 
-          ",\n.name=(UA_Byte*)&\"%(name)s\"" +
-          ",\n.new=(UA_Int32(*)(void **))%(name)s_new" +
-          ",\n.init=(void(*)(void *))%(name)s_init"+
-          ",\n.copy=(UA_Int32(*)(void const * ,void*))%(name)s_copy" +
-          ",\n.delete=(void(*)(void *))%(name)s_delete" +
-          ",\n.deleteMembers=(void(*)(void *))%(name)s_deleteMembers" +
-          ",\n#ifdef DEBUG //FIXME: seems to be okay atm, however a pointer to a noop function would be more safe" + 
-          "\n.print=(void(*)(const void *, FILE *))%(name)s_print," +
-          "\n#endif" + 
-          "\n.memSize=" + ("sizeof(%(name)s)" if (name != "UA_InvalidType") else "0") +
-          ",\n.dynMembers=" + ("UA_FALSE" if (name in fixed_size) else "UA_TRUE") +
+           ",\n.name=(UA_Byte*)&\"%(name)s\"" +
+           ",\n.new=(void *(*)())%(name)s_new" +
+           ",\n.init=(void(*)(void *))%(name)s_init"+
+           ",\n.copy=(UA_Int32(*)(void const * ,void*))%(name)s_copy" +
+           ",\n.delete=(void(*)(void *))%(name)s_delete" +
+           ",\n.deleteMembers=(void(*)(void *))%(name)s_deleteMembers" +
+           ",\n#ifdef DEBUG //FIXME: seems to be okay atm, however a pointer to a noop function would be more safe" + 
+           "\n.print=(void(*)(const void *, FILE *))%(name)s_print," +
+           "\n#endif" + 
+           "\n.memSize=" + ("sizeof(%(name)s)" if (name != "UA_InvalidType") else "0") +
+           ",\n.dynMembers=" + ("UA_FALSE" if (name in fixed_size) else "UA_TRUE") +
            ",\n.encodings={{.calcSize=(UA_Int32(*)(const void*))%(name)s_calcSizeBinary" +
            ",\n.encode=(UA_Int32(*)(const void*,UA_ByteString*,UA_UInt32*))%(name)s_encodeBinary" +
            ",\n.decode=(UA_Int32(*)(const UA_ByteString*,UA_UInt32*,void*))%(name)s_decodeBinary}" +
            (",\n{.calcSize=(UA_Int32(*)(const void*))%(name)s_calcSizeXml" +
             ",\n.encode=(UA_Int32(*)(const void*,UA_ByteString*,UA_UInt32*))%(name)s_encodeXml" +
             ",\n.decode=(UA_Int32(*)(const UA_ByteString*,UA_UInt32*,void*))%(name)s_decodeXml}" if (args.with_xml) else "") +
-          "}},")
+           "}},")
 
 printc('};')