fixed some memory leaks

examples/opcuaServer.c

@@ -53,7 +53,6 @@ UA_ByteString loadCertificate() {
 
     return certificate;
 }
-
 int main(int argc, char** argv) {
 	signal(SIGINT, stopHandler); /* catches ctrl-c */
 
@@ -78,15 +77,16 @@ int main(int argc, char** argv) {
 
 
     UA_Int32 myInteger = 42;
-    UA_QualifiedName *myIntegerName;
-    myIntegerName = UA_QualifiedName_new();
-    UA_QualifiedName_copycstring("the answer is",myIntegerName);
+    UA_QualifiedName myIntegerName;
+
+    UA_QualifiedName_copycstring("the answer is",&myIntegerName);
 
     UA_ExpandedNodeId parentNodeId;
+    UA_ExpandedNodeId_init(&parentNodeId);
     parentNodeId.namespaceUri.length = 0;
     parentNodeId.nodeId = UA_NODEIDS[UA_OBJECTSFOLDER];
-    UA_Server_addScalarVariableNode(server, myIntegerName, (void*)&myInteger, &UA_TYPES[UA_INT32],
-    		&parentNodeId, (UA_NodeId*)&UA_NODEIDS[UA_HASCOMPONENT]);
+    UA_Server_addScalarVariableNode(server, &myIntegerName, (void*)&myInteger, &UA_TYPES[UA_INT32],
+    		&parentNodeId, (UA_NodeId*)&UA_NODEIDS[UA_ORGANIZES]);
 
 #ifdef BENCHMARK
     UA_UInt32 nodeCount = 500;

src/server/nodestore/open62541_nodestore_nodemanagement.c

@@ -10,7 +10,6 @@
 #include "ua_namespace_0.h"
 #include "ua_util.h"
 
-
 static UA_Int32 AddSingleReference(UA_Node *node, UA_ReferenceNode *reference) {
 	// TODO: Check if reference already exists
 	UA_Int32 count = node->referencesSize;
@@ -60,235 +59,327 @@ static UA_Int32 AddReference(open62541NodeStore *nodestore, UA_Node *node,
 	return retval;
 }
 
-//TODO export to types, maybe?
-void UA_String_setToNULL(UA_String* string){
-	string->data = UA_NULL;
-	string->length = -1;
-}
-
-void UA_Node_setAttributes(UA_NodeAttributes *nodeAttributes, UA_Node *node){
 
-	if(nodeAttributes->specifiedAttributes & UA_NODEATTRIBUTESMASK_DISPLAYNAME){
-		node->displayName =  nodeAttributes->displayName;
-		UA_String_setToNULL(&nodeAttributes->displayName.locale);
-		UA_String_setToNULL(&nodeAttributes->displayName.text);
+#define COPY_STANDARDATTRIBUTES do { \
+if(attr.specifiedAttributes & UA_NODEATTRIBUTESMASK_DISPLAYNAME) { \
+vnode->displayName = attr.displayName; \
+UA_LocalizedText_init(&attr.displayName); \
+} \
+if(attr.specifiedAttributes & UA_NODEATTRIBUTESMASK_DESCRIPTION) { \
+vnode->description = attr.description; \
+UA_LocalizedText_init(&attr.description); \
+} \
+if(attr.specifiedAttributes & UA_NODEATTRIBUTESMASK_WRITEMASK) \
+vnode->writeMask = attr.writeMask; \
+if(attr.specifiedAttributes & UA_NODEATTRIBUTESMASK_USERWRITEMASK) \
+vnode->userWriteMask = attr.userWriteMask; \
+} while(0)
+
+
+
+static UA_StatusCode parseVariableNode(UA_ExtensionObject *attributes,
+		UA_Node **new_node, const UA_VTable_Entry **vt) {
+	if (attributes->typeId.identifier.numeric != 357) // VariableAttributes_Encoding_DefaultBinary,357,Object
+		return UA_STATUSCODE_BADNODEATTRIBUTESINVALID;
+	UA_VariableAttributes attr;
+	UA_UInt32 pos = 0;
+// todo return more informative error codes from decodeBinary
+	if (UA_VariableAttributes_decodeBinary(&attributes->body, &pos, &attr)
+			!= UA_STATUSCODE_GOOD)
+		return UA_STATUSCODE_BADNODEATTRIBUTESINVALID;
+	UA_VariableNode *vnode = UA_VariableNode_new();
+	if (!vnode) {
+		UA_VariableAttributes_deleteMembers(&attr);
+		return UA_STATUSCODE_BADOUTOFMEMORY;
 	}
-	if(nodeAttributes->specifiedAttributes & UA_NODEATTRIBUTESMASK_DESCRIPTION){
-		node->description =  nodeAttributes->description;
-		UA_String_setToNULL(&nodeAttributes->description.locale);
-		UA_String_setToNULL(&nodeAttributes->description.text);
+// now copy all the attributes. This potentially removes them from the decoded attributes.
+	COPY_STANDARDATTRIBUTES;
+	if (attr.specifiedAttributes & UA_NODEATTRIBUTESMASK_ACCESSLEVEL)
+		vnode->accessLevel = attr.accessLevel;
+	if (attr.specifiedAttributes & UA_NODEATTRIBUTESMASK_USERACCESSLEVEL)
+		vnode->userAccessLevel = attr.userAccessLevel;
+	if (attr.specifiedAttributes & UA_NODEATTRIBUTESMASK_HISTORIZING)
+		vnode->historizing = attr.historizing;
+	if (attr.specifiedAttributes
+			& UA_NODEATTRIBUTESMASK_MINIMUMSAMPLINGINTERVAL)
+		vnode->minimumSamplingInterval = attr.minimumSamplingInterval;
+	if (attr.specifiedAttributes & UA_NODEATTRIBUTESMASK_VALUERANK)
+		vnode->valueRank = attr.valueRank;
+	if (attr.specifiedAttributes & UA_NODEATTRIBUTESMASK_ARRAYDIMENSIONS) {
+		vnode->arrayDimensionsSize = attr.arrayDimensionsSize;
+		vnode->arrayDimensions = attr.arrayDimensions;
+		attr.arrayDimensionsSize = -1;
+		attr.arrayDimensions = UA_NULL;
 	}
-	if(nodeAttributes->specifiedAttributes & UA_NODEATTRIBUTESMASK_WRITEMASK){
-			node->writeMask = nodeAttributes->writeMask;
+	if ((attr.specifiedAttributes & UA_NODEATTRIBUTESMASK_DATATYPE)
+			|| (attr.specifiedAttributes
+					& UA_NODEATTRIBUTESMASK_OBJECTTYPEORDATATYPE)) {
+		vnode->dataType = attr.dataType;
+		UA_NodeId_init(&attr.dataType);
 	}
-	if(nodeAttributes->specifiedAttributes & UA_NODEATTRIBUTESMASK_USERWRITEMASK){
-		node->userWriteMask = nodeAttributes->userWriteMask;
+	if (attr.specifiedAttributes & UA_NODEATTRIBUTESMASK_VALUE) {
+		vnode->value = attr.value;
+		UA_Variant_init(&attr.value);
 	}
+	UA_VariableAttributes_deleteMembers(&attr);
+	*new_node = (UA_Node*) vnode;
+	*vt = &UA_TYPES[UA_VARIABLENODE];
+	return UA_STATUSCODE_GOOD;
 }
-void UA_ObjectNode_setAttributes(UA_ObjectAttributes *objectAttributes, UA_ObjectNode *node){
-	UA_Node_setAttributes((UA_NodeAttributes*)objectAttributes,(UA_Node*)node);
 
-	if(objectAttributes->specifiedAttributes & UA_NODEATTRIBUTESMASK_EVENTNOTIFIER){
-			node->eventNotifier = objectAttributes->eventNotifier;
+static UA_StatusCode parseObjectNode(UA_ExtensionObject *attributes,
+		UA_Node **new_node, const UA_VTable_Entry **vt) {
+	if (attributes->typeId.identifier.numeric != 354) // VariableAttributes_Encoding_DefaultBinary,357,Object
+		return UA_STATUSCODE_BADNODEATTRIBUTESINVALID;
+	UA_ObjectAttributes attr;
+	UA_UInt32 pos = 0;
+// todo return more informative error codes from decodeBinary
+	if (UA_ObjectAttributes_decodeBinary(&attributes->body, &pos, &attr)
+			!= UA_STATUSCODE_GOOD)
+		return UA_STATUSCODE_BADNODEATTRIBUTESINVALID;
+	UA_ObjectNode *vnode = UA_ObjectNode_new();
+	if (!vnode) {
+		UA_ObjectAttributes_deleteMembers(&attr);
+		return UA_STATUSCODE_BADOUTOFMEMORY;
+	}
+// now copy all the attributes. This potentially removes them from the decoded attributes.
+	COPY_STANDARDATTRIBUTES;
+	if (attr.specifiedAttributes
+			& UA_NODEATTRIBUTESMASK_EVENTNOTIFIER) {
+		vnode->eventNotifier = attr.eventNotifier;
 	}
+	UA_ObjectAttributes_deleteMembers(&attr);
+	*new_node = (UA_Node*) vnode;
+	*vt = &UA_TYPES[UA_OBJECTNODE];
+	return UA_STATUSCODE_GOOD;
 }
 
-void UA_ReferenceTypeNode_setAttributes(UA_ReferenceTypeAttributes *referenceTypeAttributes, UA_ReferenceTypeNode *node){
-	UA_Node_setAttributes((UA_NodeAttributes*)referenceTypeAttributes,(UA_Node*)node);
-
-	if(referenceTypeAttributes->specifiedAttributes & UA_NODEATTRIBUTESMASK_ISABSTRACT){
-			node->isAbstract = referenceTypeAttributes->isAbstract;
+static UA_StatusCode parseReferenceTypeNode(UA_ExtensionObject *attributes,
+		UA_Node **new_node, const UA_VTable_Entry **vt) {
+
+	UA_ReferenceTypeAttributes attr;
+	UA_UInt32 pos = 0;
+// todo return more informative error codes from decodeBinary
+	if (UA_ReferenceTypeAttributes_decodeBinary(&attributes->body, &pos, &attr)
+			!= UA_STATUSCODE_GOOD)
+		return UA_STATUSCODE_BADNODEATTRIBUTESINVALID;
+	UA_ReferenceTypeNode *vnode = UA_ReferenceTypeNode_new();
+	if (!vnode) {
+		UA_ReferenceTypeAttributes_deleteMembers(&attr);
+		return UA_STATUSCODE_BADOUTOFMEMORY;
 	}
-	if(referenceTypeAttributes->specifiedAttributes & UA_NODEATTRIBUTESMASK_SYMMETRIC){
-				node->symmetric = referenceTypeAttributes->symmetric;
+// now copy all the attributes. This potentially removes them from the decoded attributes.
+	COPY_STANDARDATTRIBUTES;
+
+	if (attr.specifiedAttributes
+			& UA_NODEATTRIBUTESMASK_ISABSTRACT) {
+		vnode->isAbstract = attr.isAbstract;
 	}
-	if(referenceTypeAttributes->specifiedAttributes & UA_NODEATTRIBUTESMASK_INVERSENAME){
-		node->inverseName = referenceTypeAttributes->inverseName;
-		UA_String_setToNULL(&referenceTypeAttributes->inverseName.locale);
-		UA_String_setToNULL(&referenceTypeAttributes->inverseName.text);
+	if (attr.specifiedAttributes
+			& UA_NODEATTRIBUTESMASK_SYMMETRIC) {
+		vnode->symmetric = attr.symmetric;
 	}
-}
-void UA_ObjectTypeNode_setAttributes(UA_ObjectTypeAttributes *objectTypeAttributes, UA_ObjectTypeNode *node){
-	UA_Node_setAttributes((UA_NodeAttributes*)objectTypeAttributes,(UA_Node*)node);
+	if (attr.specifiedAttributes
+			& UA_NODEATTRIBUTESMASK_INVERSENAME) {
+		vnode->inverseName = attr.inverseName;
 
-	if(objectTypeAttributes->specifiedAttributes & UA_NODEATTRIBUTESMASK_ISABSTRACT){
-			node->isAbstract = objectTypeAttributes->isAbstract;
 	}
-}
 
-void UA_VariableNode_setAttributes(UA_VariableAttributes *variableAttributes, UA_VariableNode *node){
-	UA_Node_setAttributes((UA_NodeAttributes*)variableAttributes,(UA_Node*)node);
+	UA_ReferenceTypeAttributes_deleteMembers(&attr);
+	*new_node = (UA_Node*) vnode;
+	*vt = &UA_TYPES[UA_REFERENCETYPENODE];
+	return UA_STATUSCODE_GOOD;
+}
 
-	if(variableAttributes->specifiedAttributes & UA_NODEATTRIBUTESMASK_VALUE){
-			UA_Variant_copy(&variableAttributes->value,&node->value);
-	}
-	if(variableAttributes->specifiedAttributes & UA_NODEATTRIBUTESMASK_DATATYPE){
-			UA_NodeId_copy(&variableAttributes->dataType,&node->dataType);
-	}
-	if(variableAttributes->specifiedAttributes & UA_NODEATTRIBUTESMASK_VALUERANK){
-		node->valueRank = variableAttributes->valueRank;
-	}
-	if(variableAttributes->specifiedAttributes & UA_NODEATTRIBUTESMASK_ARRAYDIMENSIONS){
-		node->arrayDimensions = variableAttributes->arrayDimensions;
-		variableAttributes->arrayDimensions = UA_NULL;
-	}
-	if(variableAttributes->specifiedAttributes & UA_NODEATTRIBUTESMASK_ACCESSLEVEL){
-		node->accessLevel = variableAttributes->accessLevel;
-	}
-	if(variableAttributes->specifiedAttributes & UA_NODEATTRIBUTESMASK_USERACCESSLEVEL){
-		node->userAccessLevel = variableAttributes->userAccessLevel;
-	}
-	if(variableAttributes->specifiedAttributes & UA_NODEATTRIBUTESMASK_MINIMUMSAMPLINGINTERVAL){
-		node->minimumSamplingInterval = variableAttributes->minimumSamplingInterval;
+static UA_StatusCode parseObjectTypeNode(UA_ExtensionObject *attributes,
+		UA_Node **new_node, const UA_VTable_Entry **vt) {
+
+	UA_ObjectTypeAttributes attr;
+	UA_UInt32 pos = 0;
+// todo return more informative error codes from decodeBinary
+	if (UA_ObjectTypeAttributes_decodeBinary(&attributes->body, &pos, &attr)
+			!= UA_STATUSCODE_GOOD)
+		return UA_STATUSCODE_BADNODEATTRIBUTESINVALID;
+	UA_ObjectTypeNode *vnode = UA_ObjectTypeNode_new();
+	if (!vnode) {
+		UA_ObjectTypeAttributes_deleteMembers(&attr);
+		return UA_STATUSCODE_BADOUTOFMEMORY;
 	}
-	if(variableAttributes->specifiedAttributes & UA_NODEATTRIBUTESMASK_HISTORIZING){
-		node->historizing = variableAttributes->historizing;
+// now copy all the attributes. This potentially removes them from the decoded attributes.
+	COPY_STANDARDATTRIBUTES;
+
+	if (attr.specifiedAttributes
+			& UA_NODEATTRIBUTESMASK_ISABSTRACT) {
+		vnode->isAbstract = attr.isAbstract;
 	}
+	UA_ObjectTypeAttributes_deleteMembers(&attr);
+	*new_node = (UA_Node*) vnode;
+	*vt = &UA_TYPES[UA_OBJECTTYPENODE];
+	return UA_STATUSCODE_GOOD;
 }
-void UA_ViewNode_setAttributes(UA_ViewAttributes *viewAttributes, UA_ViewNode *node){
-	UA_Node_setAttributes((UA_NodeAttributes*)viewAttributes,(UA_Node*)node);
-	if(viewAttributes->specifiedAttributes & UA_NODEATTRIBUTESMASK_CONTAINSNOLOOPS){
-			node->containsNoLoops = viewAttributes->containsNoLoops;
+
+static UA_StatusCode parseViewNode(UA_ExtensionObject *attributes,
+		UA_Node **new_node, const UA_VTable_Entry **vt) {
+
+	UA_ViewAttributes attr;
+	UA_UInt32 pos = 0;
+// todo return more informative error codes from decodeBinary
+	if (UA_ViewAttributes_decodeBinary(&attributes->body, &pos, &attr)
+			!= UA_STATUSCODE_GOOD)
+		return UA_STATUSCODE_BADNODEATTRIBUTESINVALID;
+	UA_ViewNode *vnode = UA_ViewNode_new();
+	if (!vnode) {
+		UA_ViewAttributes_deleteMembers(&attr);
+		return UA_STATUSCODE_BADOUTOFMEMORY;
 	}
-	if(viewAttributes->specifiedAttributes & UA_NODEATTRIBUTESMASK_EVENTNOTIFIER){
-				node->eventNotifier = viewAttributes->eventNotifier;
+// now copy all the attributes. This potentially removes them from the decoded attributes.
+	COPY_STANDARDATTRIBUTES;
+
+	if (attr.specifiedAttributes
+			& UA_NODEATTRIBUTESMASK_CONTAINSNOLOOPS) {
+		vnode->containsNoLoops = attr.containsNoLoops;
+	}
+	if (attr.specifiedAttributes
+			& UA_NODEATTRIBUTESMASK_EVENTNOTIFIER) {
+		vnode->eventNotifier = attr.eventNotifier;
 	}
+	UA_ViewAttributes_deleteMembers(&attr);
+	*new_node = (UA_Node*) vnode;
+	*vt = &UA_TYPES[UA_VIEWNODE];
+	return UA_STATUSCODE_GOOD;
 }
-void open62541Nodestore_getNewNodeId(UA_ExpandedNodeId *requestedNodeId){
+
+void open62541Nodestore_getNewNodeId(UA_ExpandedNodeId *requestedNodeId) {
 	//check nodeId here
 	return;
 }
 
-UA_Int32 open62541NodeStore_AddReferences(const UA_RequestHeader *requestHeader, UA_AddReferencesItem* referencesToAdd,
-		UA_UInt32 *indices,UA_UInt32 indicesSize, UA_StatusCode *addReferencesResults,
-		UA_DiagnosticInfo *diagnosticInfos)
-{
-	for(UA_UInt32 i = 0;i<indicesSize;i++){
+UA_Int32 open62541NodeStore_AddReferences(const UA_RequestHeader *requestHeader,
+		UA_AddReferencesItem* referencesToAdd, UA_UInt32 *indices,
+		UA_UInt32 indicesSize, UA_StatusCode *addReferencesResults,
+		UA_DiagnosticInfo *diagnosticInfos) {
+	for (UA_UInt32 i = 0; i < indicesSize; i++) {
 		UA_Node *node = UA_NULL;
 		open62541NodeStore *ns = open62541NodeStore_getNodeStore();
-		open62541NodeStore_get((const open62541NodeStore*)ns,(const UA_NodeId*)&referencesToAdd[indices[i]].sourceNodeId, (const UA_Node**)&node);
-		if(node == UA_NULL){
-			addReferencesResults[indices[i]] = UA_STATUSCODE_BADSOURCENODEIDINVALID;
+		open62541NodeStore_get((const open62541NodeStore*) ns,
+				(const UA_NodeId*) &referencesToAdd[indices[i]].sourceNodeId,
+				(const UA_Node**) &node);
+		if (node == UA_NULL) {
+			addReferencesResults[indices[i]] =
+					UA_STATUSCODE_BADSOURCENODEIDINVALID;
 			continue;
 		}
-	    // TODO: Check if reference already exists
-	    UA_Int32 count = node->referencesSize;
-	    UA_ReferenceNode *old_refs = node->references;
-	    UA_ReferenceNode *new_refs;
-	    if(count < 0) count = 0;
-
-	    if(!(new_refs = UA_alloc(sizeof(UA_ReferenceNode)*(count+1))))
-	        return UA_STATUSCODE_BADOUTOFMEMORY;
-
-	    UA_memcpy(new_refs, old_refs, sizeof(UA_ReferenceNode)*count);
-
-	    UA_ReferenceNode *reference = UA_ReferenceNode_new();
-
-	    reference->isInverse = !referencesToAdd[indices[i]].isForward;
-	    UA_NodeId_copy(&referencesToAdd[indices[i]].referenceTypeId,&reference->referenceTypeId);
-	    UA_ExpandedNodeId_copy(&referencesToAdd[indices[i]].targetNodeId,&reference->targetId);
-
-	    addReferencesResults[indices[i]] =  AddReference(ns,node,reference);
-	    UA_ReferenceNode_delete(reference); //FIXME to be removed
-	    //TODO fill diagnostic info if needed
+		// TODO: Check if reference already exists
+		UA_Int32 count = node->referencesSize;
+		UA_ReferenceNode *old_refs = node->references;
+		UA_ReferenceNode *new_refs;
+		if (count < 0)
+			count = 0;
+
+		if (!(new_refs = UA_alloc(sizeof(UA_ReferenceNode) * (count + 1))))
+			return UA_STATUSCODE_BADOUTOFMEMORY;
+
+		UA_memcpy(new_refs, old_refs, sizeof(UA_ReferenceNode) * count);
+
+		//UA_ReferenceNode *reference = UA_ReferenceNode_new();
+		UA_ReferenceNode reference;
+		UA_ReferenceNode_init(&reference);
+		reference.isInverse = !referencesToAdd[indices[i]].isForward;
+		UA_NodeId_copy(&referencesToAdd[indices[i]].referenceTypeId,
+				&reference.referenceTypeId);
+		UA_ExpandedNodeId_copy(&referencesToAdd[indices[i]].targetNodeId,
+				&reference.targetId);
+
+		addReferencesResults[indices[i]] = AddReference(ns, node, &reference);
+		//TODO fill diagnostic info if needed
+		UA_free(new_refs);
 	}
 
 	return UA_STATUSCODE_GOOD;
 }
-UA_Boolean isRootNode(UA_NodeId *nodeId){
-	return nodeId->identifierType == UA_NODEIDTYPE_NUMERIC && nodeId->namespaceIndex == 0 && nodeId->identifier.numeric == 84;
+UA_Boolean isRootNode(UA_NodeId *nodeId) {
+	return nodeId->identifierType == UA_NODEIDTYPE_NUMERIC
+			&& nodeId->namespaceIndex == 0 && nodeId->identifier.numeric == 84;
 }
-UA_Int32 open62541NodeStore_AddNodes(const UA_RequestHeader *requestHeader,UA_AddNodesItem *nodesToAdd,UA_UInt32 *indices,
-		UA_UInt32 indicesSize, UA_AddNodesResult* addNodesResults,
-		UA_DiagnosticInfo *diagnosticInfos){
+UA_Int32 open62541NodeStore_AddNodes(const UA_RequestHeader *requestHeader,
+		UA_AddNodesItem *nodesToAdd, UA_UInt32 *indices, UA_UInt32 indicesSize,
+		UA_AddNodesResult* addNodesResults, UA_DiagnosticInfo *diagnosticInfos) {
 
 	UA_Node *node = UA_NULL;
-	for(UA_UInt32 i=0;i<indicesSize;i++){
+	for (UA_UInt32 i = 0; i < indicesSize; i++) {
 
 		const UA_Node *parent = UA_NULL;
 		//todo what if node is in another namespace, readrequest to test, if it exists?
 		open62541NodeStore *ns = open62541NodeStore_getNodeStore();
 		if (open62541NodeStore_get(ns, &nodesToAdd->parentNodeId.nodeId,
-				&parent) != UA_STATUSCODE_GOOD && !isRootNode(&nodesToAdd->requestedNewNodeId.nodeId)) {
-			addNodesResults[indices[i]].statusCode = UA_STATUSCODE_BADPARENTNODEIDINVALID;
+				&parent) != UA_STATUSCODE_GOOD
+				&& !isRootNode(&nodesToAdd->requestedNewNodeId.nodeId)) {
+			addNodesResults[indices[i]].statusCode =
+					UA_STATUSCODE_BADPARENTNODEIDINVALID;
 			continue;
 		}
 
+		open62541NodeStore_get((const open62541NodeStore*) ns,
+				(const UA_NodeId*) &nodesToAdd[indices[i]].requestedNewNodeId.nodeId,
+				(const UA_Node**) &node);
 
-		open62541NodeStore_get((const open62541NodeStore*)ns, (const UA_NodeId*)&nodesToAdd[indices[i]].requestedNewNodeId.nodeId , (const UA_Node**)&node);
-
-
-		if(node!=UA_NULL){
+		if (node != UA_NULL) {
 			//todo or overwrite existing node?
 			continue;
 		}
 		UA_Node *newNode = UA_NULL;
-		UA_UInt32 offset = 0;
-		switch(nodesToAdd[indices[i]].nodeClass){
-			case UA_NODECLASS_DATATYPE:
-			{
-				addNodesResults[indices[i]].statusCode = UA_STATUSCODE_BADNOTIMPLEMENTED;
-				continue;
-				break;
-			}
-			case UA_NODECLASS_METHOD:
-			{
-				addNodesResults[indices[i]].statusCode = UA_STATUSCODE_BADNOTIMPLEMENTED;
-				continue;
-				break;
-			}
-			case UA_NODECLASS_OBJECT:
-			{
-				UA_ObjectAttributes attributes;
-				UA_ObjectAttributes_init(&attributes);
-				newNode = (UA_Node*)UA_ObjectNode_new();
-				newNode->nodeClass = UA_NODECLASS_OBJECT;
-				UA_ObjectAttributes_decodeBinary(&nodesToAdd[indices[i]].nodeAttributes.body,&offset,&attributes);
-				UA_ObjectNode_setAttributes((UA_ObjectAttributes*)&attributes, (UA_ObjectNode*)newNode);
-				break;
-			}
-			case UA_NODECLASS_OBJECTTYPE:
-			{
-				addNodesResults[indices[i]].statusCode = UA_STATUSCODE_BADNOTIMPLEMENTED;
-				continue;
-				break;
-			}
-			case UA_NODECLASS_REFERENCETYPE:
-			{
-				UA_ReferenceTypeAttributes attributes;
-				UA_ReferenceTypeAttributes_init(&attributes);
-				newNode = (UA_Node*)UA_ReferenceTypeNode_new();
-				newNode->nodeClass = UA_NODECLASS_REFERENCETYPE;
-				UA_ReferenceTypeAttributes_decodeBinary(&nodesToAdd[indices[i]].nodeAttributes.body,&offset,&attributes);
-				UA_ReferenceTypeNode_setAttributes((UA_ReferenceTypeAttributes*)&attributes,(UA_ReferenceTypeNode*)newNode);
-				break;
-			}
-			case UA_NODECLASS_VARIABLE:
-			{
-				UA_VariableAttributes attributes;
-				UA_VariableAttributes_init(&attributes);
-				newNode = (UA_Node*)UA_VariableNode_new();
-				newNode->nodeClass = UA_NODECLASS_VARIABLE;
-				UA_VariableAttributes_decodeBinary(&nodesToAdd[indices[i]].nodeAttributes.body,&offset,&attributes);
-				UA_VariableNode_setAttributes((UA_VariableAttributes*)&attributes,(UA_VariableNode*)newNode);
-				break;
-			}
-			case UA_NODECLASS_VARIABLETYPE:
-			{
-				addNodesResults[indices[i]].statusCode = UA_STATUSCODE_BADNOTIMPLEMENTED;
-				continue;
-				break;
-			}
-			default:
-			{
-				addNodesResults[indices[i]].statusCode = UA_STATUSCODE_BADNOTIMPLEMENTED;
-				continue;
-				break;
-			}
+		const UA_VTable_Entry *newNodeVT = UA_NULL;
+
+		switch (nodesToAdd[indices[i]].nodeClass) {
+		case UA_NODECLASS_DATATYPE: {
+			addNodesResults[indices[i]].statusCode =
+					UA_STATUSCODE_BADNOTIMPLEMENTED;
+			continue;
+			break;
+		}
+		case UA_NODECLASS_METHOD: {
+			addNodesResults[indices[i]].statusCode =
+					UA_STATUSCODE_BADNOTIMPLEMENTED;
+			continue;
+			break;
+		}
+		case UA_NODECLASS_OBJECT: {
+			parseObjectNode(&nodesToAdd[indices[i]].nodeAttributes,&newNode,&newNodeVT);
+			newNode->nodeClass = UA_NODECLASS_OBJECT;
+			break;
+		}
+		case UA_NODECLASS_OBJECTTYPE: {
+			parseObjectTypeNode(&nodesToAdd[indices[i]].nodeAttributes,&newNode,&newNodeVT);
+			newNode->nodeClass = UA_NODECLASS_OBJECTTYPE;
+			break;
+		}
+		case UA_NODECLASS_REFERENCETYPE: {
+			parseReferenceTypeNode(&nodesToAdd[indices[i]].nodeAttributes,&newNode,&newNodeVT);
+			newNode->nodeClass = UA_NODECLASS_REFERENCETYPE;
+			break;
+		}
+		case UA_NODECLASS_VARIABLE: {
+			parseVariableNode(&nodesToAdd[indices[i]].nodeAttributes,&newNode,&newNodeVT);
+			newNode->nodeClass = UA_NODECLASS_VARIABLE;
+			break;
+		}
+		case UA_NODECLASS_VARIABLETYPE: {
+			addNodesResults[indices[i]].statusCode =
+					UA_STATUSCODE_BADNOTIMPLEMENTED;
+			continue;
+			break;
+		}
+		default: {
+			addNodesResults[indices[i]].statusCode =
+					UA_STATUSCODE_BADNOTIMPLEMENTED;
+			continue;
+			break;
+		}
 
 		}
-		open62541Nodestore_getNewNodeId(&nodesToAdd[indices[i]].requestedNewNodeId);
-					newNode->nodeId    = nodesToAdd[indices[i]].requestedNewNodeId.nodeId;
+		open62541Nodestore_getNewNodeId(
+				&nodesToAdd[indices[i]].requestedNewNodeId);
+		newNode->nodeId = nodesToAdd[indices[i]].requestedNewNodeId.nodeId;
 		UA_QualifiedName_copy(&nodesToAdd[indices[i]].browseName,
 				&newNode->browseName);
 
@@ -301,16 +392,15 @@ UA_Int32 open62541NodeStore_AddNodes(const UA_RequestHeader *requestHeader,UA_Ad
 		addRefItem.targetServerUri.length = 0;
 		addRefItem.targetNodeClass = newNode->nodeClass;
 
-
 		open62541NodeStore_insert(ns, (UA_Node**) &newNode,
-				UA_NODESTORE_INSERT_UNIQUE);
+		UA_NODESTORE_INSERT_UNIQUE);
 		if (!isRootNode(&nodesToAdd[indices[i]].requestedNewNodeId.nodeId)) {
 			UA_UInt32 ind = 0;
 			UA_UInt32 indSize = 1;
 			UA_StatusCode result;
 			UA_DiagnosticInfo diagnosticInfo;
-			open62541NodeStore_AddReferences(requestHeader, &addRefItem, &ind, indSize,
-					&result, &diagnosticInfo);
+			open62541NodeStore_AddReferences(requestHeader, &addRefItem, &ind,
+					indSize, &result, &diagnosticInfo);
 		}
 
 	}

src/server/ua_server.c

@@ -8,13 +8,15 @@
 #include "ua_services.h"
 
 void UA_Server_delete(UA_Server *server) {
-    UA_ApplicationDescription_deleteMembers(&server->description);
-    UA_SecureChannelManager_deleteMembers(&server->secureChannelManager);
-    UA_SessionManager_deleteMembers(&server->sessionManager);
-    //UA_NodeStore_delete(server->nodestore);
-    UA_ByteString_deleteMembers(&server->serverCertificate);
-    UA_Array_delete(server->endpointDescriptions, server->endpointDescriptionsSize, &UA_TYPES[UA_ENDPOINTDESCRIPTION]);
-    UA_free(server);
+	UA_ApplicationDescription_deleteMembers(&server->description);
+	UA_SecureChannelManager_deleteMembers(&server->secureChannelManager);
+	UA_SessionManager_deleteMembers(&server->sessionManager);
+	//UA_NodeStore_delete(server->nodestore);
+	UA_ByteString_deleteMembers(&server->serverCertificate);
+	UA_Array_delete(server->endpointDescriptions,
+			server->endpointDescriptionsSize,
+			&UA_TYPES[UA_ENDPOINTDESCRIPTION]);
+	UA_free(server);
 }
 void addSingleReference(UA_Namespace *namespace,
 		UA_AddReferencesItem *addReferencesItem) {
@@ -23,8 +25,8 @@ void addSingleReference(UA_Namespace *namespace,
 	UA_DiagnosticInfo diagnosticInfo;
 	UA_StatusCode result;
 	UA_RequestHeader tmpRequestHeader;
-	namespace->nodeStore->addReferences(&tmpRequestHeader,addReferencesItem, &indices,
-			indicesSize, &result, &diagnosticInfo);
+	namespace->nodeStore->addReferences(&tmpRequestHeader, addReferencesItem,
+			&indices, indicesSize, &result, &diagnosticInfo);
 }
 void addSingleNode(UA_Namespace *namespace, UA_AddNodesItem *addNodesItem) {
 	UA_UInt32 indices = 0;
@@ -33,173 +35,200 @@ void addSingleNode(UA_Namespace *namespace, UA_AddNodesItem *addNodesItem) {
 	UA_AddNodesResult result;
 	UA_RequestHeader tmpRequestHeader;
 
-	namespace->nodeStore->addNodes(&tmpRequestHeader,addNodesItem, &indices, indicesSize, &result,
-			&diagnosticInfo);
+	namespace->nodeStore->addNodes(&tmpRequestHeader, addNodesItem, &indices,
+			indicesSize, &result, &diagnosticInfo);
 }
 
 void ns0_addObjectNode(UA_Server *server, UA_NodeId REFTYPE_NODEID,
 		UA_ExpandedNodeId REQ_NODEID, UA_ExpandedNodeId PARENTNODEID,
 		char* BROWSENAME, char* DISPLAYNAME, char* DESCRIPTION) {
-	UA_ObjectAttributes objAttr;
-	UA_ObjectAttributes_init(&objAttr);
-	UA_AddNodesItem addNodesItem;
-	UA_AddNodesItem_init(&addNodesItem);
+	UA_ObjectAttributes *objAttr = UA_ObjectAttributes_new();
+	UA_ObjectAttributes_init(objAttr);
+	UA_AddNodesItem *addNodesItem = UA_AddNodesItem_new();
+	UA_AddNodesItem_init(addNodesItem);
+
 	UA_Namespace *ns0 = UA_NULL;
 	UA_NamespaceManager_getNamespace(server->namespaceManager, 0, &ns0);
-	addNodesItem.parentNodeId = PARENTNODEID;
-	addNodesItem.requestedNewNodeId = REQ_NODEID;
-	addNodesItem.referenceTypeId = REFTYPE_NODEID;
-	addNodesItem.nodeClass = UA_NODECLASS_OBJECT;\
-	UA_QualifiedName_copycstring(BROWSENAME, &addNodesItem.browseName);
-	UA_LocalizedText_copycstring(DISPLAYNAME, &objAttr.displayName);
-	UA_LocalizedText_copycstring(DESCRIPTION, &objAttr.description);
-	objAttr.userWriteMask = 0;
-	objAttr.writeMask = 0;
-	objAttr.specifiedAttributes |= UA_NODEATTRIBUTESMASK_BROWSENAME;
-	objAttr.specifiedAttributes |= UA_NODEATTRIBUTESMASK_DISPLAYNAME;
-	objAttr.specifiedAttributes |= UA_NODEATTRIBUTESMASK_DESCRIPTION;
+	addNodesItem->parentNodeId = PARENTNODEID;
+	addNodesItem->requestedNewNodeId = REQ_NODEID;
+	addNodesItem->referenceTypeId = REFTYPE_NODEID;
+	addNodesItem->nodeClass = UA_NODECLASS_OBJECT;\
+	UA_QualifiedName_copycstring(BROWSENAME, &addNodesItem->browseName);
+	UA_LocalizedText_copycstring(DISPLAYNAME, &objAttr->displayName);
+	UA_LocalizedText_copycstring(DESCRIPTION, &objAttr->description);
+	objAttr->userWriteMask = 0;
+	objAttr->writeMask = 0;
+	objAttr->specifiedAttributes |= UA_NODEATTRIBUTESMASK_BROWSENAME;
+	objAttr->specifiedAttributes |= UA_NODEATTRIBUTESMASK_DISPLAYNAME;
+	objAttr->specifiedAttributes |= UA_NODEATTRIBUTESMASK_DESCRIPTION;
+	addNodesItem->typeDefinition.nodeId.identifier.numeric = 354;
+	addNodesItem->typeDefinition.nodeId.identifierType = UA_NODEIDTYPE_NUMERIC;
+	addNodesItem->typeDefinition.nodeId.namespaceIndex = 0;
+	addNodesItem->nodeAttributes.typeId = addNodesItem->typeDefinition.nodeId;
 	UA_UInt32 offset = 0;
-	UA_ByteString_newMembers(&addNodesItem.nodeAttributes.body,
-			UA_ObjectAttributes_calcSizeBinary(&objAttr));
-	UA_ObjectAttributes_encodeBinary(&objAttr,
-			&addNodesItem.nodeAttributes.body, &offset);
-	addSingleNode(ns0, &addNodesItem);
+	UA_ByteString_newMembers(&addNodesItem->nodeAttributes.body,
+			UA_ObjectAttributes_calcSizeBinary(objAttr));
+	UA_ObjectAttributes_encodeBinary(objAttr,
+			&addNodesItem->nodeAttributes.body, &offset);
+	addSingleNode(ns0, addNodesItem);
+	UA_AddNodesItem_delete(addNodesItem);
+	UA_ObjectAttributes_delete(objAttr);
 }
 void ns0_addVariableNode(UA_Server *server, UA_NodeId refTypeNodeId,
 		UA_ExpandedNodeId requestedNodeId, UA_ExpandedNodeId parentNodeId,
-		UA_QualifiedName browseName, UA_LocalizedText displayName, UA_LocalizedText description,
-		UA_DataValue *dataValue, UA_Int32 valueRank) {
-	UA_VariableAttributes varAttr;
-	UA_VariableAttributes_init(&varAttr);
-	UA_AddNodesItem addNodesItem;
-	UA_AddNodesItem_init(&addNodesItem);
+		UA_QualifiedName browseName, UA_LocalizedText displayName,
+		UA_LocalizedText description, UA_DataValue *dataValue,
+		UA_Int32 valueRank) {
+	UA_VariableAttributes *varAttr = UA_VariableAttributes_new();
+	UA_VariableAttributes_init(varAttr);
+	UA_AddNodesItem *addNodesItem = UA_AddNodesItem_new();
+	UA_AddNodesItem_init(addNodesItem);
 	UA_Namespace *ns0 = UA_NULL;
 	UA_NamespaceManager_getNamespace(server->namespaceManager, 0, &ns0);
-	addNodesItem.parentNodeId = parentNodeId;
-	addNodesItem.requestedNewNodeId = requestedNodeId;
-	addNodesItem.referenceTypeId = refTypeNodeId;
-	addNodesItem.nodeClass = UA_NODECLASS_VARIABLE;
-	addNodesItem.browseName = browseName;
-	varAttr.displayName = displayName ;
-	varAttr.description = description;
-	varAttr.value = dataValue->value;
-	varAttr.userWriteMask = 0;
-	varAttr.writeMask = 0;
-
-	varAttr.dataType = dataValue->value.vt->typeId;
-
-	varAttr.valueRank = valueRank;
-	varAttr.specifiedAttributes |= UA_NODEATTRIBUTESMASK_VALUERANK;
-
-	varAttr.arrayDimensions = (UA_UInt32*)dataValue->value.storage.data.arrayDimensions;
-	varAttr.arrayDimensionsSize = dataValue->value.storage.data.arrayDimensionsLength;
-
-	varAttr.specifiedAttributes |= UA_NODEATTRIBUTESMASK_BROWSENAME;
-	varAttr.specifiedAttributes |= UA_NODEATTRIBUTESMASK_DISPLAYNAME;
-	varAttr.specifiedAttributes |= UA_NODEATTRIBUTESMASK_DESCRIPTION;
-	varAttr.specifiedAttributes |= UA_NODEATTRIBUTESMASK_VALUE;
-	varAttr.specifiedAttributes |= UA_NODEATTRIBUTESMASK_DATATYPE;
-	varAttr.specifiedAttributes |= UA_NODEATTRIBUTESMASK_ARRAYDIMENSIONS;
-
-
-
+	addNodesItem->parentNodeId = parentNodeId;
+	addNodesItem->requestedNewNodeId = requestedNodeId;
+	addNodesItem->referenceTypeId = refTypeNodeId;
+	addNodesItem->nodeClass = UA_NODECLASS_VARIABLE;
+	addNodesItem->browseName = browseName;
+	addNodesItem->typeDefinition.nodeId.identifier.numeric = 357;
+	addNodesItem->typeDefinition.nodeId.identifierType = UA_NODEIDTYPE_NUMERIC;
+	addNodesItem->typeDefinition.nodeId.namespaceIndex = 0;
+	addNodesItem->nodeAttributes.typeId = addNodesItem->typeDefinition.nodeId;
+	varAttr->displayName = displayName;
+	varAttr->description = description;
+	UA_Variant_copy(&dataValue->value,&varAttr->value);
+	varAttr->userWriteMask = 0;
+	varAttr->writeMask = 0;
+
+	varAttr->dataType = dataValue->value.vt->typeId;
+	varAttr->valueRank = valueRank;
+	varAttr->specifiedAttributes |= UA_NODEATTRIBUTESMASK_VALUERANK;
+
+	varAttr->arrayDimensions =
+			(UA_UInt32*) dataValue->value.storage.data.arrayDimensions;
+	varAttr->arrayDimensionsSize =
+			dataValue->value.storage.data.arrayDimensionsLength;
+
+	varAttr->specifiedAttributes |= UA_NODEATTRIBUTESMASK_BROWSENAME;
+	varAttr->specifiedAttributes |= UA_NODEATTRIBUTESMASK_DISPLAYNAME;
+	varAttr->specifiedAttributes |= UA_NODEATTRIBUTESMASK_DESCRIPTION;
+	varAttr->specifiedAttributes |= UA_NODEATTRIBUTESMASK_VALUE;
+	varAttr->specifiedAttributes |= UA_NODEATTRIBUTESMASK_DATATYPE;
+	varAttr->specifiedAttributes |= UA_NODEATTRIBUTESMASK_ARRAYDIMENSIONS;
 
 	UA_UInt32 offset = 0;
-	UA_ByteString_newMembers(&addNodesItem.nodeAttributes.body,
-			UA_VariableAttributes_calcSizeBinary(&varAttr));
-	UA_VariableAttributes_encodeBinary(&varAttr,
-			&addNodesItem.nodeAttributes.body, &offset);
-	addSingleNode(ns0, &addNodesItem);
+	UA_ByteString_newMembers(&addNodesItem->nodeAttributes.body,
+			UA_VariableAttributes_calcSizeBinary(varAttr));
+	UA_VariableAttributes_encodeBinary(varAttr,
+			&addNodesItem->nodeAttributes.body, &offset);
+	addSingleNode(ns0, addNodesItem);
+	UA_AddNodesItem_delete(addNodesItem);
+	UA_VariableAttributes_delete(varAttr);
 }
 
-void ADD_REFTYPENODE_NS0(UA_Server *server, UA_NodeId REFTYPE_NODEID,UA_ExpandedNodeId REQ_NODEID,UA_ExpandedNodeId PARENTNODEID,char* REFTYPE_BROWSENAME, char* REFTYPE_DISPLAYNAME, char*REFTYPE_DESCRIPTION,UA_Boolean IS_ABSTRACT,UA_Boolean IS_SYMMETRIC)
-{
-	UA_AddNodesItem addNodesItem;
-    UA_Namespace *ns0;
-    UA_NamespaceManager_getNamespace(server->namespaceManager,0,&ns0);
-	UA_ReferenceTypeAttributes refTypeAttr;
-	UA_ReferenceTypeAttributes_init(&refTypeAttr);
-    addNodesItem.parentNodeId= PARENTNODEID;
-    addNodesItem.requestedNewNodeId = REQ_NODEID;
-    addNodesItem.referenceTypeId = REFTYPE_NODEID;
-    addNodesItem.nodeClass = UA_NODECLASS_REFERENCETYPE;
-    UA_QualifiedName_copycstring(REFTYPE_BROWSENAME, &addNodesItem.browseName);
-    UA_LocalizedText_copycstring(REFTYPE_DISPLAYNAME, &refTypeAttr.displayName);
-    UA_LocalizedText_copycstring(REFTYPE_DESCRIPTION, &refTypeAttr.description);
-    refTypeAttr.isAbstract = IS_ABSTRACT;
-    refTypeAttr.symmetric  = IS_SYMMETRIC;
-    refTypeAttr.userWriteMask = 0;
-    refTypeAttr.writeMask = 0;
-    refTypeAttr.inverseName.locale.length = 0;
-    refTypeAttr.inverseName.text.length = 0;
-    refTypeAttr.specifiedAttributes |= UA_NODEATTRIBUTESMASK_BROWSENAME;
-    refTypeAttr.specifiedAttributes |= UA_NODEATTRIBUTESMASK_DISPLAYNAME;
-    refTypeAttr.specifiedAttributes |= UA_NODEATTRIBUTESMASK_DESCRIPTION;
-    refTypeAttr.specifiedAttributes |= UA_NODEATTRIBUTESMASK_ISABSTRACT;
-    refTypeAttr.specifiedAttributes |= UA_NODEATTRIBUTESMASK_SYMMETRIC;
-    UA_UInt32 offset = 0;
-    UA_ByteString_newMembers(&addNodesItem.nodeAttributes.body,UA_ReferenceTypeAttributes_calcSizeBinary(&refTypeAttr));
-    UA_ReferenceTypeAttributes_encodeBinary(&refTypeAttr,&addNodesItem.nodeAttributes.body,&offset);
-    addSingleNode(ns0,&addNodesItem);
+void ns0_addReferenceTypeNode(UA_Server *server, UA_NodeId REFTYPE_NODEID,
+		UA_ExpandedNodeId REQ_NODEID, UA_ExpandedNodeId PARENTNODEID,
+		char* REFTYPE_BROWSENAME, char* REFTYPE_DISPLAYNAME,
+		char*REFTYPE_DESCRIPTION, UA_Boolean IS_ABSTRACT,
+		UA_Boolean IS_SYMMETRIC) {
+	UA_AddNodesItem *addNodesItem = UA_AddNodesItem_new();
+	UA_Namespace *ns0;
+	UA_NamespaceManager_getNamespace(server->namespaceManager, 0, &ns0);
+	UA_ReferenceTypeAttributes *refTypeAttr = UA_ReferenceTypeAttributes_new();
+	UA_ReferenceTypeAttributes_init(refTypeAttr);
+	addNodesItem->parentNodeId = PARENTNODEID;
+	addNodesItem->requestedNewNodeId = REQ_NODEID;
+	addNodesItem->referenceTypeId = REFTYPE_NODEID;
+	addNodesItem->nodeClass = UA_NODECLASS_REFERENCETYPE;
+	UA_QualifiedName_copycstring(REFTYPE_BROWSENAME, &addNodesItem->browseName);
+	UA_LocalizedText_copycstring(REFTYPE_DISPLAYNAME, &refTypeAttr->displayName);
+	UA_LocalizedText_copycstring(REFTYPE_DESCRIPTION, &refTypeAttr->description);
+	refTypeAttr->isAbstract = IS_ABSTRACT;
+	refTypeAttr->symmetric = IS_SYMMETRIC;
+	refTypeAttr->userWriteMask = 0;
+	refTypeAttr->writeMask = 0;
+	refTypeAttr->inverseName.locale.length = 0;
+	refTypeAttr->inverseName.text.length = 0;
+	refTypeAttr->specifiedAttributes |= UA_NODEATTRIBUTESMASK_BROWSENAME;
+	refTypeAttr->specifiedAttributes |= UA_NODEATTRIBUTESMASK_DISPLAYNAME;
+	refTypeAttr->specifiedAttributes |= UA_NODEATTRIBUTESMASK_DESCRIPTION;
+	refTypeAttr->specifiedAttributes |= UA_NODEATTRIBUTESMASK_ISABSTRACT;
+	refTypeAttr->specifiedAttributes |= UA_NODEATTRIBUTESMASK_SYMMETRIC;
+	UA_UInt32 offset = 0;
+	UA_ByteString_newMembers(&addNodesItem->nodeAttributes.body,
+			UA_ReferenceTypeAttributes_calcSizeBinary(refTypeAttr));
+	UA_ReferenceTypeAttributes_encodeBinary(refTypeAttr,
+			&addNodesItem->nodeAttributes.body, &offset);
+	addSingleNode(ns0, addNodesItem);
+	UA_AddNodesItem_delete(addNodesItem);
+	UA_ReferenceTypeAttributes_delete(refTypeAttr);
+
 }
 
-UA_Server * UA_Server_new(UA_String *endpointUrl, UA_ByteString *serverCertificate, UA_NodeStore *ns0Nodestore) {
-    UA_Server *server = UA_alloc(sizeof(UA_Server));
-    if(!server)
-        return server;
-
-    UA_ApplicationDescription_init(&server->description);
-
-    //add namespace zero
-    server->namespaceManager = UA_NamespaceManager_new();
-    UA_NamespaceManager_addNamespace(server->namespaceManager,0,ns0Nodestore);
-    
-
-    // mockup application description
-    UA_ApplicationDescription_init(&server->description);
-    UA_String_copycstring("urn:servername:open62541:application", &server->description.productUri);
-    UA_String_copycstring("http://open62541.info/applications/4711", &server->description.applicationUri);
-    UA_LocalizedText_copycstring("The open62541 application", &server->description.applicationName);
-    server->description.applicationType = UA_APPLICATIONTYPE_SERVER;
-
-    UA_ByteString_init(&server->serverCertificate);
-    if(serverCertificate)
-        UA_ByteString_copy(serverCertificate, &server->serverCertificate);
-
-    // mockup endpoint description
-    server->endpointDescriptionsSize = 1;
-    UA_EndpointDescription *endpoint = UA_alloc(sizeof(UA_EndpointDescription)); // todo: check return code
-
-    endpoint->securityMode = UA_MESSAGESECURITYMODE_NONE;
-    UA_String_copycstring("http://opcfoundation.org/UA/SecurityPolicy#None", &endpoint->securityPolicyUri);
-    UA_String_copycstring("http://opcfoundation.org/UA-Profile/Transport/uatcp-uasc-uabinary", &endpoint->transportProfileUri);
-
-    endpoint->userIdentityTokensSize = 1;
-    endpoint->userIdentityTokens = UA_alloc(sizeof(UA_UserTokenPolicy));
-    UA_UserTokenPolicy_init(endpoint->userIdentityTokens);
-    UA_String_copycstring("my-anonymous-policy", &endpoint->userIdentityTokens->policyId); // defined per server
-    endpoint->userIdentityTokens->tokenType = UA_USERTOKENTYPE_ANONYMOUS;
-
-    UA_String_copy(endpointUrl, &endpoint->endpointUrl);
-    /* The standard says "the HostName specified in the Server Certificate is the
-       same as the HostName contained in the endpointUrl provided in the
-       EndpointDescription */
-    UA_String_copy(&server->serverCertificate, &endpoint->serverCertificate);
-    UA_ApplicationDescription_copy(&server->description, &endpoint->server);
-    server->endpointDescriptions = endpoint;
+UA_Server * UA_Server_new(UA_String *endpointUrl,
+		UA_ByteString *serverCertificate, UA_NodeStore *ns0Nodestore) {
+	UA_Server *server = UA_alloc(sizeof(UA_Server));
+	if (!server)
+		return server;
+
+	UA_ApplicationDescription_init(&server->description);
+
+	//add namespace zero
+	server->namespaceManager = UA_NamespaceManager_new();
+	UA_NamespaceManager_addNamespace(server->namespaceManager, 0, ns0Nodestore);
+
+	// mockup application description
+	UA_ApplicationDescription_init(&server->description);
+	UA_String_copycstring("urn:servername:open62541:application",
+			&server->description.productUri);
+	UA_String_copycstring("http://open62541.info/applications/4711",
+			&server->description.applicationUri);
+	UA_LocalizedText_copycstring("The open62541 application",
+			&server->description.applicationName);
+	server->description.applicationType = UA_APPLICATIONTYPE_SERVER;
+
+	UA_ByteString_init(&server->serverCertificate);
+	if (serverCertificate)
+		UA_ByteString_copy(serverCertificate, &server->serverCertificate);
+
+	// mockup endpoint description
+	server->endpointDescriptionsSize = 1;
+	UA_EndpointDescription *endpoint = UA_alloc(sizeof(UA_EndpointDescription)); // todo: check return code
+
+	endpoint->securityMode = UA_MESSAGESECURITYMODE_NONE;
+	UA_String_copycstring("http://opcfoundation.org/UA/SecurityPolicy#None",
+			&endpoint->securityPolicyUri);
+	UA_String_copycstring(
+			"http://opcfoundation.org/UA-Profile/Transport/uatcp-uasc-uabinary",
+			&endpoint->transportProfileUri);
+
+	endpoint->userIdentityTokensSize = 1;
+	endpoint->userIdentityTokens = UA_alloc(sizeof(UA_UserTokenPolicy));
+	UA_UserTokenPolicy_init(endpoint->userIdentityTokens);
+	UA_String_copycstring("my-anonymous-policy",
+			&endpoint->userIdentityTokens->policyId); // defined per server
+	endpoint->userIdentityTokens->tokenType = UA_USERTOKENTYPE_ANONYMOUS;
+
+	UA_String_copy(endpointUrl, &endpoint->endpointUrl);
+	/* The standard says "the HostName specified in the Server Certificate is the
+	 same as the HostName contained in the endpointUrl provided in the
+	 EndpointDescription */
+	UA_String_copy(&server->serverCertificate, &endpoint->serverCertificate);
+	UA_ApplicationDescription_copy(&server->description, &endpoint->server);
+	server->endpointDescriptions = endpoint;
 
 #define MAXCHANNELCOUNT 100
 #define STARTCHANNELID 1
 #define TOKENLIFETIME 10000
 #define STARTTOKENID 1
-    UA_SecureChannelManager_init(&server->secureChannelManager, MAXCHANNELCOUNT,
-                                 TOKENLIFETIME, STARTCHANNELID, STARTTOKENID, endpointUrl);
-
+	UA_SecureChannelManager_init(&server->secureChannelManager, MAXCHANNELCOUNT,
+	TOKENLIFETIME, STARTCHANNELID, STARTTOKENID, endpointUrl);
 
 #define MAXSESSIONCOUNT 1000
 #define SESSIONLIFETIME 10000
 #define STARTSESSIONID 1
-    UA_SessionManager_init(&server->sessionManager, MAXSESSIONCOUNT, SESSIONLIFETIME, STARTSESSIONID);
+	UA_SessionManager_init(&server->sessionManager, MAXSESSIONCOUNT,
+			SESSIONLIFETIME, STARTSESSIONID);
 
 	//ns0: C2UA_STRING("http://opcfoundation.org/UA/"));
 	//ns1: C2UA_STRING("http://localhost:16664/open62541/"));
@@ -256,8 +285,6 @@ UA_Server * UA_Server_new(UA_String *endpointUrl, UA_ByteString *serverCertifica
 	UA_ExpandedNodeId RefTypeId_HasHistoricalConfiguration;
 	NS0EXPANDEDNODEID(RefTypeId_HasHistoricalConfiguration, 56);
 
-
-
 	/*
 	 #define ADDREFERENCE(NODE, REFTYPE, INVERSE, TARGET_NODEID) do { \
     static struct UA_ReferenceNode NODE##REFTYPE##TARGET_NODEID;    \
@@ -290,237 +317,259 @@ UA_Server * UA_Server_new(UA_String *endpointUrl, UA_ByteString *serverCertifica
 	NS0EXPANDEDNODEID(ObjId_Server, 2253);
 	//UA_ExpandedNodeId VarId_ServerArray;
 	//NS0EXPANDEDNODEID(VarId_ServerArray, 2254);
-    UA_ExpandedNodeId VarId_NamespaceArray; NS0EXPANDEDNODEID(VarId_NamespaceArray, 2255);
-    UA_ExpandedNodeId VarId_ServerStatus; NS0EXPANDEDNODEID(VarId_ServerStatus, 2256);
+	UA_ExpandedNodeId VarId_NamespaceArray;
+	NS0EXPANDEDNODEID(VarId_NamespaceArray, 2255);
+	UA_ExpandedNodeId VarId_ServerStatus;
+	NS0EXPANDEDNODEID(VarId_ServerStatus, 2256);
 //    UA_ExpandedNodeId ObjId_ServerCapabilities; NS0EXPANDEDNODEID(ObjId_ServerCapabilities, 2268);
-    UA_ExpandedNodeId VarId_State; NS0EXPANDEDNODEID(VarId_State, 2259);
+	UA_ExpandedNodeId VarId_State;
+	NS0EXPANDEDNODEID(VarId_State, 2259);
 
-	ns0_addObjectNode(server,RefTypeId_Organizes.nodeId, ObjId_Root, ObjId_Null,
-			"Root", "Root", "Root");
-	ns0_addObjectNode(server,RefTypeId_Organizes.nodeId, ObjId_ObjectsFolder,
+	ns0_addObjectNode(server, RefTypeId_Organizes.nodeId, ObjId_Root,
+			ObjId_Null, "Root", "Root", "Root");
+	ns0_addObjectNode(server, RefTypeId_Organizes.nodeId, ObjId_ObjectsFolder,
 			ObjId_Root, "Objects", "Objects", "Objects");
-	ns0_addObjectNode(server,RefTypeId_Organizes.nodeId, ObjId_Server,
+	ns0_addObjectNode(server, RefTypeId_Organizes.nodeId, ObjId_Server,
 			ObjId_ObjectsFolder, "Server", "Server", "Server");
 
-
-	UA_DataValue *serverArrayValue;
-	serverArrayValue = UA_DataValue_new();
+	UA_DataValue serverArrayValue;
+	UA_DataValue_init(&serverArrayValue);
 	UA_UInt32 namespaceArraySize = 2;
 
-	UA_Array_new((void**)&serverArrayValue->value.storage.data.dataPtr, namespaceArraySize, &UA_TYPES[UA_STRING]);
-	UA_String_copycstring("http://opcfoundation.org/UA/", &((UA_String *)(serverArrayValue->value.storage.data.dataPtr))[0]);
+	UA_Array_new((void**) &serverArrayValue.value.storage.data.dataPtr,
+			namespaceArraySize, &UA_TYPES[UA_STRING]);
+	UA_String_copycstring("http://opcfoundation.org/UA/",
+			&((UA_String *) (serverArrayValue.value.storage.data.dataPtr))[0]);
+	UA_String_copycstring("http://namespace123",
+				&((UA_String *) (serverArrayValue.value.storage.data.dataPtr))[1]);
+
 	UA_Int32 *arrayDim;
 	UA_UInt32 arrayDimSize = 1;
-	UA_Array_new((void**)&arrayDim, arrayDimSize, &UA_TYPES[UA_INT32]);
-
-	serverArrayValue->value.vt = &UA_TYPES[UA_STRING];
-	serverArrayValue->value.storage.data.arrayDimensions = arrayDim;
-	serverArrayValue->value.storage.data.arrayDimensionsLength = 1; // added to ensure encoding in readreponse
-	serverArrayValue->value.storage.data.arrayLength = 1;
-	serverArrayValue->value.storageType = UA_VARIANT_DATA;
-	 {
-		 UA_QualifiedName *browseName;
-		 browseName=UA_QualifiedName_new();
-		 UA_LocalizedText *description;
-		 description = UA_LocalizedText_new();
-		 UA_LocalizedText *displayName;
-		 displayName = UA_LocalizedText_new();
-
-		 UA_QualifiedName_copycstring("NamespaceArray",browseName);
-		 UA_LocalizedText_copycstring("NamespaceArray",description);
-		 UA_LocalizedText_copycstring("NamespaceArray",displayName);
-
-		 ns0_addVariableNode(server, RefTypeId_HasComponent.nodeId,
-				 VarId_NamespaceArray,
-				 ObjId_Server,
-				 *browseName,
-				 *description,
-				 *displayName,
-				 serverArrayValue,1);
-	 }
-
-
-
-	 // ServerStatus
-	 UA_DataValue *serverStatusValue;
-	 serverStatusValue = UA_DataValue_new();
-
-	 UA_ServerStatusDataType *status;
-	 status = UA_ServerStatusDataType_new();
-	 status->startTime   = UA_DateTime_now();
-	 status->currentTime = UA_DateTime_now();
-	 status->state       = UA_SERVERSTATE_RUNNING;
-	 UA_String_copycstring("open62541.org", &status->buildInfo.productUri);
-	 UA_String_copycstring("open62541", &status->buildInfo.manufacturerName);
-	 UA_String_copycstring("open62541", &status->buildInfo.productName);
-	 UA_String_copycstring("0.0", &status->buildInfo.softwareVersion);
-	 UA_String_copycstring("0.0", &status->buildInfo.buildNumber);
-	 status->buildInfo.buildDate     = UA_DateTime_now();
-	 status->secondsTillShutdown     = 99999999;
-	 UA_LocalizedText_copycstring("because", &status->shutdownReason);
-	 serverStatusValue->value.vt          = &UA_TYPES[UA_SERVERSTATUSDATATYPE]; // gets encoded as an extensionobject
-	 serverStatusValue->value.storage.data.arrayLength = 0;
-	 serverStatusValue->value.storage.data.dataPtr        = status;
-	 serverStatusValue->value.storage.data.arrayDimensionsLength = 0;
-	 {
-		 UA_QualifiedName *browseName = UA_QualifiedName_new();
-		 UA_LocalizedText *description = UA_LocalizedText_new();
-		 UA_LocalizedText *displayName = UA_LocalizedText_new();
-
-		 UA_QualifiedName_copycstring("ServerStatus",browseName);
-		 UA_LocalizedText_copycstring("ServerStatus",description);
-		 UA_LocalizedText_copycstring("ServerStatus",displayName);
-
-		 ns0_addVariableNode(server,RefTypeId_HasComponent.nodeId,VarId_ServerStatus,ObjId_Server, *browseName, *description, *displayName ,serverStatusValue,-1);
+	UA_Array_new((void**) &arrayDim, arrayDimSize, &UA_TYPES[UA_INT32]);
+
+	serverArrayValue.value.vt = &UA_TYPES[UA_STRING];
+	serverArrayValue.value.storage.data.arrayDimensions = arrayDim;
+	serverArrayValue.value.storage.data.arrayDimensionsLength = arrayDimSize; // added to ensure encoding in readreponse
+	serverArrayValue.value.storage.data.arrayLength = namespaceArraySize;
+	serverArrayValue.value.storageType = UA_VARIANT_DATA;
+	{
+		UA_QualifiedName browseName;
+
+		UA_LocalizedText description;
+
+		UA_LocalizedText displayName;
+
+
+		UA_QualifiedName_copycstring("NamespaceArray", &browseName);
+		UA_LocalizedText_copycstring("NamespaceArray", &description);
+		UA_LocalizedText_copycstring("NamespaceArray", &displayName);
+
+		ns0_addVariableNode(server, RefTypeId_HasComponent.nodeId,
+				VarId_NamespaceArray, ObjId_Server, browseName, description,
+				displayName, &serverArrayValue, 1);
+
 	}
 
-	 // State (Component of ServerStatus)
 
-	 UA_DataValue *sateValue = UA_DataValue_new();
 
+	// ServerStatus
+	UA_DataValue serverStatusValue;
+	UA_DataValue_init(&serverStatusValue);
+
+	UA_ServerStatusDataType *status = UA_ServerStatusDataType_new();
 
-	 sateValue->value.vt = &UA_TYPES[UA_SERVERSTATE];
-	 sateValue->value.storage.data.arrayDimensionsLength = 0; // added to ensure encoding in readreponse
-	 sateValue->value.storage.data.arrayLength = 0;
-	 sateValue->value.storage.data.dataPtr = &status->state; // points into the other object.
-	 sateValue->value.storageType = UA_VARIANT_DATA;
+	status->startTime = UA_DateTime_now();
+	status->currentTime = UA_DateTime_now();
+	status->state = UA_SERVERSTATE_RUNNING;
+	UA_String_copycstring("open62541.org", &status->buildInfo.productUri);
+	UA_String_copycstring("open62541", &status->buildInfo.manufacturerName);
+	UA_String_copycstring("open62541", &status->buildInfo.productName);
+	UA_String_copycstring("0.0", &status->buildInfo.softwareVersion);
+	UA_String_copycstring("0.0", &status->buildInfo.buildNumber);
+	status->buildInfo.buildDate = UA_DateTime_now();
+	UA_String_copycstring("en",&status->shutdownReason.locale);
+	UA_String_copycstring("because",&status->shutdownReason.text);
+	status->secondsTillShutdown = 99999999;
 
-	 {
-		 UA_QualifiedName *browseName = UA_QualifiedName_new();
-		 UA_LocalizedText *description = UA_LocalizedText_new();
-		 UA_LocalizedText *displayName = UA_LocalizedText_new();
+	serverStatusValue.value.vt = &UA_TYPES[UA_SERVERSTATUSDATATYPE]; // gets encoded as an extensionobject
+	serverStatusValue.value.storage.data.arrayLength = 0;
+	serverStatusValue.value.storage.data.dataPtr = status;
+	serverStatusValue.value.storage.data.arrayDimensionsLength = 0;
+	{
+		UA_QualifiedName browseName;
+		UA_LocalizedText description;
+		UA_LocalizedText displayName;
 
-		 UA_QualifiedName_copycstring("State",browseName);
-		 UA_LocalizedText_copycstring("State",description);
-		 UA_LocalizedText_copycstring("State",displayName);
+		UA_QualifiedName_copycstring("ServerStatus", &browseName);
+		UA_LocalizedText_copycstring("ServerStatus", &description);
+		UA_LocalizedText_copycstring("ServerStatus", &displayName);
 
-		 ns0_addVariableNode(server,RefTypeId_HasComponent.nodeId,VarId_State,ObjId_Server, *browseName, *description,*displayName ,sateValue,-1);
-	 }
+		ns0_addVariableNode(server, RefTypeId_HasComponent.nodeId,
+				VarId_ServerStatus, ObjId_Server, browseName, description,
+				displayName, &serverStatusValue, -1);
 
-	ns0_addObjectNode(server,RefTypeId_Organizes.nodeId, ObjId_TypesFolder, ObjId_Root,
-			"Types", "Types", "Types");
+	}
 
-	ns0_addObjectNode(server,RefTypeId_Organizes.nodeId, ObjId_TypesFolder, ObjId_Root,
-			"Types", "Types", "Types");
-	ns0_addObjectNode(server,RefTypeId_Organizes.nodeId, ObjId_ReferenceTypesFolder,
-			ObjId_TypesFolder, "ReferenceTypes", "ReferenceTypes",
-			"ReferenceTypes");
-	ADD_REFTYPENODE_NS0(server,RefTypeId_Organizes.nodeId, RefTypeId_References,
-			ObjId_ReferenceTypesFolder, "References", "References",
-			"References", UA_TRUE, UA_TRUE);
+	// State (Component of ServerStatus)
 
-	ns0_addObjectNode(server,RefTypeId_Organizes.nodeId, ObjId_ViewsFolder, ObjId_Root,
-			"Views", "Views", "Views");
+	UA_DataValue stateValue;
 
-	ADD_REFTYPENODE_NS0(server,RefTypeId_HasSubtype.nodeId,
+	stateValue.value.vt = &UA_TYPES[UA_SERVERSTATE];
+	stateValue.value.storage.data.arrayDimensionsLength = 0; // added to ensure encoding in readreponse
+	stateValue.value.storage.data.arrayLength = 0;
+	stateValue.value.storage.data.dataPtr = &status->state; // points into the other object.
+	stateValue.value.storageType = UA_VARIANT_DATA;
+
+	{
+		UA_QualifiedName browseName ;
+		UA_LocalizedText description;
+		UA_LocalizedText displayName;
+
+		UA_QualifiedName_copycstring("State", &browseName);
+		UA_LocalizedText_copycstring("State", &description);
+		UA_LocalizedText_copycstring("State", &displayName);
+
+		ns0_addVariableNode(server, RefTypeId_HasComponent.nodeId, VarId_State,
+				ObjId_Server, browseName, description, displayName,
+				&stateValue, -1);
+
+	}
+
+
+	ns0_addObjectNode(server, RefTypeId_Organizes.nodeId, ObjId_TypesFolder,
+			ObjId_Root, "Types", "Types", "Types");
+
+	ns0_addObjectNode(server, RefTypeId_Organizes.nodeId, ObjId_TypesFolder,
+			ObjId_Root, "Types", "Types", "Types");
+	ns0_addObjectNode(server, RefTypeId_Organizes.nodeId,
+			ObjId_ReferenceTypesFolder, ObjId_TypesFolder, "ReferenceTypes",
+			"ReferenceTypes", "ReferenceTypes");
+	ns0_addReferenceTypeNode(server, RefTypeId_Organizes.nodeId,
+			RefTypeId_References, ObjId_ReferenceTypesFolder, "References",
+			"References", "References", UA_TRUE, UA_TRUE);
+
+	ns0_addObjectNode(server, RefTypeId_Organizes.nodeId, ObjId_ViewsFolder,
+			ObjId_Root, "Views", "Views", "Views");
+
+	ns0_addReferenceTypeNode(server, RefTypeId_HasSubtype.nodeId,
 			RefTypeId_NonHierarchicalReferences, RefTypeId_References,
 			"NonHierarchicalReferences", "NonHierarchicalReferences",
 			"NonHierarchicalReferences", UA_TRUE, UA_FALSE);
 
-	ADD_REFTYPENODE_NS0(server,RefTypeId_HasSubtype.nodeId, RefTypeId_HasModelParent,
-			RefTypeId_NonHierarchicalReferences, "HasModelParent",
-			"HasModelParent", "HasModelParent", UA_TRUE, UA_FALSE);
-	ADD_REFTYPENODE_NS0(server,RefTypeId_HasSubtype.nodeId, RefTypeId_GeneratesEvent,
-			RefTypeId_NonHierarchicalReferences, "GeneratesEvent",
-			"GeneratesEvent", "GeneratesEvent", UA_TRUE, UA_FALSE);
-	ADD_REFTYPENODE_NS0(server,RefTypeId_HasSubtype.nodeId, RefTypeId_HasEncoding,
-			RefTypeId_NonHierarchicalReferences, "HasEncoding", "HasEncoding",
-			"HasEncoding", UA_TRUE, UA_FALSE);
-	ADD_REFTYPENODE_NS0(server,RefTypeId_HasSubtype.nodeId, RefTypeId_HasModellingRule,
-			RefTypeId_NonHierarchicalReferences, "HasModellingRule",
-			"HasModellingRule", "HasModellingRule", UA_TRUE, UA_FALSE);
-	ADD_REFTYPENODE_NS0(server,RefTypeId_HasSubtype.nodeId, RefTypeId_HasDescription,
-			RefTypeId_NonHierarchicalReferences, "HasDescription",
-			"HasDescription", "HasDescription", UA_TRUE, UA_FALSE);
-	ADD_REFTYPENODE_NS0(server,RefTypeId_HasSubtype.nodeId,
+	ns0_addReferenceTypeNode(server, RefTypeId_HasSubtype.nodeId,
+			RefTypeId_HasModelParent, RefTypeId_NonHierarchicalReferences,
+			"HasModelParent", "HasModelParent", "HasModelParent", UA_TRUE,
+			UA_FALSE);
+	ns0_addReferenceTypeNode(server, RefTypeId_HasSubtype.nodeId,
+			RefTypeId_GeneratesEvent, RefTypeId_NonHierarchicalReferences,
+			"GeneratesEvent", "GeneratesEvent", "GeneratesEvent", UA_TRUE,
+			UA_FALSE);
+	ns0_addReferenceTypeNode(server, RefTypeId_HasSubtype.nodeId,
+			RefTypeId_HasEncoding, RefTypeId_NonHierarchicalReferences,
+			"HasEncoding", "HasEncoding", "HasEncoding", UA_TRUE, UA_FALSE);
+	ns0_addReferenceTypeNode(server, RefTypeId_HasSubtype.nodeId,
+			RefTypeId_HasModellingRule, RefTypeId_NonHierarchicalReferences,
+			"HasModellingRule", "HasModellingRule", "HasModellingRule", UA_TRUE,
+			UA_FALSE);
+	ns0_addReferenceTypeNode(server, RefTypeId_HasSubtype.nodeId,
+			RefTypeId_HasDescription, RefTypeId_NonHierarchicalReferences,
+			"HasDescription", "HasDescription", "HasDescription", UA_TRUE,
+			UA_FALSE);
+	ns0_addReferenceTypeNode(server, RefTypeId_HasSubtype.nodeId,
 			RefTypeId_HasTypeDefinition, RefTypeId_NonHierarchicalReferences,
 			"HasTypeDefinition", "HasTypeDefinition", "HasTypeDefinition",
 			UA_TRUE, UA_FALSE);
-	ADD_REFTYPENODE_NS0(server,RefTypeId_HasSubtype.nodeId, RefTypeId_FromState,
-			RefTypeId_NonHierarchicalReferences, "FromState", "FromState",
-			"FromState", UA_TRUE, UA_FALSE);
-	ADD_REFTYPENODE_NS0(server,RefTypeId_HasSubtype.nodeId, RefTypeId_ToState,
-			RefTypeId_NonHierarchicalReferences, "ToState", "ToState",
-			"ToState", UA_TRUE, UA_FALSE);
-	ADD_REFTYPENODE_NS0(server,RefTypeId_HasSubtype.nodeId, RefTypeId_HasCause,
-			RefTypeId_NonHierarchicalReferences, "HasCause", "HasCause",
-			"HasCause", UA_TRUE, UA_FALSE);
-	ADD_REFTYPENODE_NS0(server,RefTypeId_HasSubtype.nodeId, RefTypeId_HasEffect,
-			RefTypeId_NonHierarchicalReferences, "HasEffect", "HasEffect",
-			"HasEffect", UA_TRUE, UA_FALSE);
-	ADD_REFTYPENODE_NS0(server,RefTypeId_HasSubtype.nodeId,
+	ns0_addReferenceTypeNode(server, RefTypeId_HasSubtype.nodeId,
+			RefTypeId_FromState, RefTypeId_NonHierarchicalReferences,
+			"FromState", "FromState", "FromState", UA_TRUE, UA_FALSE);
+	ns0_addReferenceTypeNode(server, RefTypeId_HasSubtype.nodeId,
+			RefTypeId_ToState, RefTypeId_NonHierarchicalReferences, "ToState",
+			"ToState", "ToState", UA_TRUE, UA_FALSE);
+	ns0_addReferenceTypeNode(server, RefTypeId_HasSubtype.nodeId,
+			RefTypeId_HasCause, RefTypeId_NonHierarchicalReferences, "HasCause",
+			"HasCause", "HasCause", UA_TRUE, UA_FALSE);
+	ns0_addReferenceTypeNode(server, RefTypeId_HasSubtype.nodeId,
+			RefTypeId_HasEffect, RefTypeId_NonHierarchicalReferences,
+			"HasEffect", "HasEffect", "HasEffect", UA_TRUE, UA_FALSE);
+	ns0_addReferenceTypeNode(server, RefTypeId_HasSubtype.nodeId,
 			RefTypeId_HasHistoricalConfiguration,
 			RefTypeId_NonHierarchicalReferences, "HasHistoricalConfiguration",
 			"HasHistoricalConfiguration", "HasHistoricalConfiguration", UA_TRUE,
 			UA_FALSE);
 
-	ADD_REFTYPENODE_NS0(server,RefTypeId_HasSubtype.nodeId,
+	ns0_addReferenceTypeNode(server, RefTypeId_HasSubtype.nodeId,
 			RefTypeId_HierarchicalReferences, RefTypeId_References,
 			"HierarchicalReferences", "HierarchicalReferences",
 			"HierarchicalReferences", UA_TRUE, UA_FALSE);
-	ADD_REFTYPENODE_NS0(server,RefTypeId_HasSubtype.nodeId, RefTypeId_HasEventSource,
-			RefTypeId_HierarchicalReferences, "HasEventSource",
+	ns0_addReferenceTypeNode(server, RefTypeId_HasSubtype.nodeId,
+			RefTypeId_HasEventSource, RefTypeId_HierarchicalReferences,
+			"HasEventSource", "HasEventSource", "HasEventSource", UA_TRUE,
+			UA_FALSE);
+	ns0_addReferenceTypeNode(server, RefTypeId_HasSubtype.nodeId,
+			RefTypeId_HasNotifier, RefTypeId_HasEventSource, "HasEventSource",
 			"HasEventSource", "HasEventSource", UA_TRUE, UA_FALSE);
-	ADD_REFTYPENODE_NS0(server,RefTypeId_HasSubtype.nodeId, RefTypeId_HasNotifier,
-			RefTypeId_HasEventSource, "HasEventSource", "HasEventSource",
-			"HasEventSource", UA_TRUE, UA_FALSE);
-	ADD_REFTYPENODE_NS0(server,RefTypeId_HasSubtype.nodeId, RefTypeId_HasChild,
-			RefTypeId_HierarchicalReferences, "HasChild", "HasChild",
-			"HasChild", UA_TRUE, UA_FALSE);
-	ADD_REFTYPENODE_NS0(server,RefTypeId_HasSubtype.nodeId, RefTypeId_Aggregates,
-			RefTypeId_HasChild, "Aggregates", "Aggregates", "Aggregates",
+	ns0_addReferenceTypeNode(server, RefTypeId_HasSubtype.nodeId,
+			RefTypeId_HasChild, RefTypeId_HierarchicalReferences, "HasChild",
+			"HasChild", "HasChild", UA_TRUE, UA_FALSE);
+	ns0_addReferenceTypeNode(server, RefTypeId_HasSubtype.nodeId,
+			RefTypeId_Aggregates, RefTypeId_HasChild, "Aggregates",
+			"Aggregates", "Aggregates",
 			UA_TRUE, UA_FALSE);
-	ADD_REFTYPENODE_NS0(server,RefTypeId_HasSubtype.nodeId, RefTypeId_HasProperty,
-			RefTypeId_Aggregates, "HasProperty", "HasProperty", "HasProperty",
+	ns0_addReferenceTypeNode(server, RefTypeId_HasSubtype.nodeId,
+			RefTypeId_HasProperty, RefTypeId_Aggregates, "HasProperty",
+			"HasProperty", "HasProperty",
 			UA_TRUE, UA_FALSE);
-	ADD_REFTYPENODE_NS0(server,RefTypeId_HasSubtype.nodeId, RefTypeId_HasComponent,
-			RefTypeId_Aggregates, "HasComponent", "HasComponent",
-			"HasComponent", UA_TRUE, UA_FALSE);
-	ADD_REFTYPENODE_NS0(server,RefTypeId_HasSubtype.nodeId,
+	ns0_addReferenceTypeNode(server, RefTypeId_HasSubtype.nodeId,
+			RefTypeId_HasComponent, RefTypeId_Aggregates, "HasComponent",
+			"HasComponent", "HasComponent", UA_TRUE, UA_FALSE);
+	ns0_addReferenceTypeNode(server, RefTypeId_HasSubtype.nodeId,
 			RefTypeId_HasOrderedComponent, RefTypeId_HasComponent,
 			"HasOrderedComponent", "HasOrderedComponent", "HasOrderedComponent",
 			UA_TRUE, UA_FALSE);
-	ADD_REFTYPENODE_NS0(server,RefTypeId_HasSubtype.nodeId, RefTypeId_HasSubtype,
-			RefTypeId_HasChild, "HasSubtype", "HasSubtype", "HasSubtype",
+	ns0_addReferenceTypeNode(server, RefTypeId_HasSubtype.nodeId,
+			RefTypeId_HasSubtype, RefTypeId_HasChild, "HasSubtype",
+			"HasSubtype", "HasSubtype",
 			UA_TRUE, UA_FALSE);
-	ADD_REFTYPENODE_NS0(server,RefTypeId_HasSubtype.nodeId, RefTypeId_Organizes,
-			RefTypeId_HierarchicalReferences, "Organizes", "Organizes",
-			"Organizes", UA_TRUE, UA_FALSE);
-    return server;
+	ns0_addReferenceTypeNode(server, RefTypeId_HasSubtype.nodeId,
+			RefTypeId_Organizes, RefTypeId_HierarchicalReferences, "Organizes",
+			"Organizes", "Organizes", UA_TRUE, UA_FALSE);
+	return server;
 }
 
+void UA_Server_addScalarVariableNode(UA_Server *server,
+		UA_QualifiedName *browseName, void *value, const UA_VTable_Entry *vt,
+		UA_ExpandedNodeId *parentNodeId, UA_NodeId *referenceTypeId) {
+	UA_DataValue *dataValue = UA_DataValue_new();
 
-void UA_Server_addScalarVariableNode(UA_Server *server, UA_QualifiedName *browseName, void *value,
-                                                  const UA_VTable_Entry *vt, UA_ExpandedNodeId *parentNodeId,
-                                                  UA_NodeId *referenceTypeId ) {
-    UA_DataValue *dataValue = UA_DataValue_new();
+	/*UA_LocalizedText_copycstring("integer value", &tmpNode->description); */
+	UA_LocalizedText displayName;
+	UA_LocalizedText description;
 
-    /*UA_LocalizedText_copycstring("integer value", &tmpNode->description); */
-    UA_LocalizedText *displayName = UA_LocalizedText_new();
-    UA_LocalizedText *description = UA_LocalizedText_new();
+	UA_LocalizedText_init(&displayName);
+	UA_LocalizedText_init(&description);
 
-    displayName->locale.length = 0;
-    description->locale.length = 0;
 
-    UA_String_copy(&browseName->name, &displayName->text);
-    UA_String_copy(&browseName->name, &description->text);
+	UA_String_copy(&browseName->name, &displayName.text);
+	UA_String_copy(&browseName->name, &description.text);
 
-    dataValue->value.vt = vt;
-    dataValue->value.storage.data.dataPtr = value;
-    dataValue->value.storageType = UA_VARIANT_DATA;
-    dataValue->value.storage.data.arrayLength = 1;
-    UA_ExpandedNodeId reqNodeId;
-    reqNodeId.namespaceUri.length = 0;
-    reqNodeId.nodeId.namespaceIndex = 0;
-    UA_String_copy(&browseName->name,&reqNodeId.nodeId.identifier.string);
-    reqNodeId.nodeId.identifierType = UA_NODEIDTYPE_STRING;
-    ns0_addVariableNode(server,*referenceTypeId,reqNodeId, *parentNodeId,*browseName,*displayName,*description,dataValue,-1);
+	dataValue->value.vt = vt;
+	dataValue->value.storage.data.dataPtr = value;
+	dataValue->value.storageType = UA_VARIANT_DATA;
+	dataValue->value.storage.data.arrayLength = 1;
+	UA_ExpandedNodeId reqNodeId;
+	UA_ExpandedNodeId_init(&reqNodeId);
+	reqNodeId.namespaceUri.length = -1;
+	reqNodeId.nodeId.namespaceIndex = 0;
+	reqNodeId.nodeId.identifier.numeric = 222;
+	reqNodeId.nodeId.identifierType = UA_NODEIDTYPE_NUMERIC;
+	ns0_addVariableNode(server, *referenceTypeId, reqNodeId, *parentNodeId,
+			*browseName, displayName, description, dataValue, -1);
 
 }
 
 UA_Int32 UA_Server_addNamespace(UA_Server *server, UA_UInt16 namespaceIndex,
 		UA_NodeStore *nodeStore) {
 
-	return (UA_Int32)UA_NamespaceManager_addNamespace(server->namespaceManager,
+	return (UA_Int32) UA_NamespaceManager_addNamespace(server->namespaceManager,
 			namespaceIndex, nodeStore);
 }

src/server/ua_services_attribute.c

@@ -229,6 +229,7 @@ void Service_Read(UA_Server *server, UA_Session *session,
 		response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY;
 		return;
 	}
+	response->diagnosticInfosSize = request->nodesToReadSize;
 	response->resultsSize = request->nodesToReadSize;
 
 	UA_Int32 *numberOfFoundIndices;
@@ -318,9 +319,8 @@ void Service_Write(UA_Server *server, UA_Session *session,
 		response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY;
 		return;
 	}
-
-
-	UA_Int32 *numberOfFoundIndices;
+	response->diagnosticInfosSize = request->nodesToWriteSize;
+	UA_UInt32 *numberOfFoundIndices;
 	UA_UInt16 *associatedIndices;
 	UA_UInt32 differentNamespaceIndexCount = 0;
 	if (UA_Array_new((void **) &numberOfFoundIndices, request->nodesToWriteSize,

src/server/ua_services_nodemanagement.c

@@ -21,14 +21,16 @@ void Service_AddNodes(UA_Server *server, UA_Session *session,
 		response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY;
 		return;
 	}
-
+	response->resultsSize = request->nodesToAddSize;
 	if (UA_Array_new((void **) &response->diagnosticInfos,
 			request->nodesToAddSize, &UA_TYPES[UA_DIAGNOSTICINFO])
 			!= UA_STATUSCODE_GOOD) {
 		response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY;
 		return;
 	}
-	response->resultsSize = request->nodesToAddSize;
+	response->diagnosticInfosSize = request->nodesToAddSize;
+
+
 
 	UA_Int32 *numberOfFoundIndices;
 	UA_UInt16 *associatedIndices;
@@ -97,6 +99,7 @@ void Service_AddReferences(UA_Server *server, UA_Session *session,
 		response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY;
 		return;
 	}
+	response->resultsSize = request->referencesToAddSize;
 
 	if (UA_Array_new((void **) &response->diagnosticInfos,
 			request->referencesToAddSize, &UA_TYPES[UA_DIAGNOSTICINFO])
@@ -104,8 +107,7 @@ void Service_AddReferences(UA_Server *server, UA_Session *session,
 		response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY;
 		return;
 	}
-	response->resultsSize = request->referencesToAddSize;
-
+	response->diagnosticInfosSize = request->referencesToAddSize;
 	UA_Int32 *numberOfFoundIndices;
 	UA_UInt16 *associatedIndices;
 	UA_UInt32 differentNamespaceIndexCount = 0;

src/server/ua_services_view.c

@@ -33,6 +33,11 @@ void Service_Browse(UA_Server *server, UA_Session *session,
     	response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY;
     	return ;
     }
+    if(UA_Array_new((void **)&response->diagnosticInfos,request->nodesToBrowseSize,&UA_TYPES[UA_DIAGNOSTICINFO]) != UA_STATUSCODE_GOOD){
+    	response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY;
+    	return ;
+    }
+    response->diagnosticInfosSize = request->nodesToBrowseSize;
 
     BUILD_INDEX_ARRAYS(request->nodesToBrowseSize,request->nodesToBrowse,nodeId,differentNamespaceIndexCount,associatedIndices,numberOfFoundIndices);
 

src/ua_types.c

@@ -165,7 +165,10 @@ UA_Int32 UA_String_copycstring(char const *src, UA_String *dst) {
     if(length == 0) {
         dst->length = 0;
         dst->data = UA_NULL;
-    } else if((dst->data = UA_alloc(length)) != UA_NULL) {
+        return UA_STATUSCODE_GOOD;
+    }
+    dst->data = UA_alloc(length);
+    if(dst->data != UA_NULL) {
         memcpy(dst->data, src, length);
         dst->length = length;
     } else {