fixes within the example implementation

examples/nodestoreAccessExample.c

@@ -5,16 +5,11 @@
  *      Author: opcua
  */
 
+#include "nodestoreAccessExample.h"
 
 
 
 
-#include "ua_statuscodes.h"
-
-
-#include "ua_namespace_0.h"
-#include "ua_util.h"
-#include "nodestoreAccessExample.h"
 
 
 
@@ -43,8 +38,41 @@ enum UA_AttributeId {
     UA_ATTRIBUTEID_USEREXECUTABLE          = 22
 };
 
+static UA_VariableNode *myNode;
+UA_Int32 initMyNode()
+{
+
+    UA_ExpandedNodeId ObjId_NamespaceArray; NS0EXPANDEDNODEID(ObjId_NamespaceArray, 2255);
+
+
+    UA_VariableNode_new(&myNode);
+    myNode->nodeId    = ObjId_NamespaceArray.nodeId;
+    myNode->nodeClass = UA_NODECLASS_VARIABLE; //FIXME: this should go into _new?
+    UA_QualifiedName_copycstring("myNode", &myNode->browseName);
+    UA_LocalizedText_copycstring("myNode", &myNode->displayName);
+    UA_LocalizedText_copycstring("myNode", &myNode->description);
+    UA_Array_new((void **)&myNode->value.storage.data.dataPtr, 2, &UA_[UA_STRING]);
+    myNode->value.vt = &UA_[UA_STRING];
+    myNode->value.storage.data.arrayLength = 2;
+    UA_String_copycstring("http://opcfoundation.org/UA/", &((UA_String *)(myNode->value.storage.data.dataPtr))[0]);
+    UA_String_copycstring("http://localhost:16664/open62541/", &((UA_String *)(myNode->value.storage.data.dataPtr))[1]);
+    myNode->arrayDimensionsSize = 1;
+    UA_UInt32 *dimensions = UA_NULL;
+
+    dimensions = malloc(sizeof(UA_UInt32));
+    *dimensions = 2;
+    myNode->arrayDimensions = dimensions;
+    myNode->dataType = NS0NODEID(UA_STRING_NS0);
+    myNode->valueRank       = 1;
+    myNode->minimumSamplingInterval = 1.0;
+    myNode->historizing     = UA_FALSE;
+    return 0;
+
+}
+
+
 #define CHECK_NODECLASS(CLASS)                                 \
-    if(!(node->nodeClass & (CLASS))) {                         \
+    if(!(myNode->nodeClass & (CLASS))) {                         \
         v[readValueIdIndices[i]].encodingMask = UA_DATAVALUE_ENCODINGMASK_STATUSCODE; \
         v[readValueIdIndices[i]].status       = UA_STATUSCODE_BADNOTREADABLE;         \
         break;                                                 \
@@ -62,7 +90,6 @@ UA_Int32 readNodes(UA_ReadValueId * readValueIds, UA_UInt32 *readValueIdIndices,
 
 		UA_DataValue_init(&v[readValueIdIndices[i]]);
 
-		UA_Node const *node   = UA_NULL;
 
 		/*Access Node here */
 
@@ -70,39 +97,39 @@ UA_Int32 readNodes(UA_ReadValueId * readValueIds, UA_UInt32 *readValueIdIndices,
 		switch(id->attributeId) {
 		case UA_ATTRIBUTEID_NODEID:
 			v[readValueIdIndices[i]].encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
-			retval |= UA_Variant_copySetValue(&v[readValueIdIndices[i]].value, &UA_[UA_NODEID], &node->nodeId);
+			retval |= UA_Variant_copySetValue(&v[readValueIdIndices[i]].value, &UA_[UA_NODEID], &myNode->nodeId);
 			break;
 
 		case UA_ATTRIBUTEID_NODECLASS:
 			v[readValueIdIndices[i]].encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
-			retval |= UA_Variant_copySetValue(&v[readValueIdIndices[i]].value, &UA_[UA_INT32], &node->nodeClass);
+			retval |= UA_Variant_copySetValue(&v[readValueIdIndices[i]].value, &UA_[UA_INT32], &myNode->nodeClass);
 			break;
 
 		case UA_ATTRIBUTEID_BROWSENAME:
 			v[readValueIdIndices[i]].encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
-			retval |= UA_Variant_copySetValue(&v[readValueIdIndices[i]].value, &UA_[UA_QUALIFIEDNAME], &node->browseName);
+			retval |= UA_Variant_copySetValue(&v[readValueIdIndices[i]].value, &UA_[UA_QUALIFIEDNAME], &myNode->browseName);
 			break;
 
 		case UA_ATTRIBUTEID_DISPLAYNAME:
 			v[readValueIdIndices[i]].encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
 			retval |= UA_Variant_copySetValue(&v[readValueIdIndices[i]].value, &UA_[UA_LOCALIZEDTEXT],
-											  &node->displayName);
+											  &myNode->displayName);
 			break;
 
 		case UA_ATTRIBUTEID_DESCRIPTION:
 			v[readValueIdIndices[i]].encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
 			retval |= UA_Variant_copySetValue(&v[readValueIdIndices[i]].value, &UA_[UA_LOCALIZEDTEXT],
-											  &node->description);
+											  &myNode->description);
 			break;
 
 		case UA_ATTRIBUTEID_WRITEMASK:
 			v[readValueIdIndices[i]].encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
-			retval |= UA_Variant_copySetValue(&v[readValueIdIndices[i]].value, &UA_[UA_UINT32], &node->writeMask);
+			retval |= UA_Variant_copySetValue(&v[readValueIdIndices[i]].value, &UA_[UA_UINT32], &myNode->writeMask);
 			break;
 
 		case UA_ATTRIBUTEID_USERWRITEMASK:
 			v[readValueIdIndices[i]].encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
-			retval |= UA_Variant_copySetValue(&v[readValueIdIndices[i]].value, &UA_[UA_UINT32], &node->userWriteMask);
+			retval |= UA_Variant_copySetValue(&v[readValueIdIndices[i]].value, &UA_[UA_UINT32], &myNode->userWriteMask);
 			break;
 
 		case UA_ATTRIBUTEID_ISABSTRACT:
@@ -112,105 +139,105 @@ UA_Int32 readNodes(UA_ReadValueId * readValueIds, UA_UInt32 *readValueIdIndices,
 			v[readValueIdIndices[i]].encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
 			retval |=
 				UA_Variant_copySetValue(&v[readValueIdIndices[i]].value, &UA_[UA_BOOLEAN],
-										&((UA_ReferenceTypeNode *)node)->isAbstract);
+										&((UA_ReferenceTypeNode *)myNode)->isAbstract);
 			break;
 
 		case UA_ATTRIBUTEID_SYMMETRIC:
 			CHECK_NODECLASS(UA_NODECLASS_REFERENCETYPE);
 			v[readValueIdIndices[i]].encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
 			retval |= UA_Variant_copySetValue(&v[readValueIdIndices[i]].value, &UA_[UA_BOOLEAN],
-											  &((UA_ReferenceTypeNode *)node)->symmetric);
+											  &((UA_ReferenceTypeNode *)myNode)->symmetric);
 			break;
 
 		case UA_ATTRIBUTEID_INVERSENAME:
 			CHECK_NODECLASS(UA_NODECLASS_REFERENCETYPE);
 			v[readValueIdIndices[i]].encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
 			retval |= UA_Variant_copySetValue(&v[readValueIdIndices[i]].value, &UA_[UA_LOCALIZEDTEXT],
-											  &((UA_ReferenceTypeNode *)node)->inverseName);
+											  &((UA_ReferenceTypeNode *)myNode)->inverseName);
 			break;
 
 		case UA_ATTRIBUTEID_CONTAINSNOLOOPS:
 			CHECK_NODECLASS(UA_NODECLASS_VIEW);
 			v[readValueIdIndices[i]].encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
 			retval |= UA_Variant_copySetValue(&v[readValueIdIndices[i]].value, &UA_[UA_BOOLEAN],
-											  &((UA_ViewNode *)node)->containsNoLoops);
+											  &((UA_ViewNode *)myNode)->containsNoLoops);
 			break;
 
 		case UA_ATTRIBUTEID_EVENTNOTIFIER:
 			CHECK_NODECLASS(UA_NODECLASS_VIEW | UA_NODECLASS_OBJECT);
 			v[readValueIdIndices[i]].encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
 			retval |= UA_Variant_copySetValue(&v[readValueIdIndices[i]].value, &UA_[UA_BYTE],
-											  &((UA_ViewNode *)node)->eventNotifier);
+											  &((UA_ViewNode *)myNode)->eventNotifier);
 			break;
 
 		case UA_ATTRIBUTEID_VALUE:
 			CHECK_NODECLASS(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
 			v[readValueIdIndices[i]].encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
-			retval |= UA_Variant_copy(&((UA_VariableNode *)node)->value, &v[readValueIdIndices[i]].value); // todo: zero-copy
+			retval |= UA_Variant_copy(&((UA_VariableNode *)myNode)->value, &v[readValueIdIndices[i]].value); // todo: zero-copy
 			break;
 
 		case UA_ATTRIBUTEID_DATATYPE:
 			CHECK_NODECLASS(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
 			v[readValueIdIndices[i]].encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
 			retval |= UA_Variant_copySetValue(&v[readValueIdIndices[i]].value, &UA_[UA_NODEID],
-											  &((UA_VariableTypeNode *)node)->dataType);
+											  &((UA_VariableTypeNode *)myNode)->dataType);
 			break;
 
 		case UA_ATTRIBUTEID_VALUERANK:
 			CHECK_NODECLASS(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
 			v[readValueIdIndices[i]].encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
 			retval |= UA_Variant_copySetValue(&v[readValueIdIndices[i]].value, &UA_[UA_INT32],
-											  &((UA_VariableTypeNode *)node)->valueRank);
+											  &((UA_VariableTypeNode *)myNode)->valueRank);
 			break;
 
 		case UA_ATTRIBUTEID_ARRAYDIMENSIONS:
 			CHECK_NODECLASS(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
 			v[readValueIdIndices[i]].encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
 			UA_Variant_copySetArray(&v[readValueIdIndices[i]].value, &UA_[UA_UINT32],
-									((UA_VariableTypeNode *)node)->arrayDimensionsSize,
-									&((UA_VariableTypeNode *)node)->arrayDimensions);
+									((UA_VariableTypeNode *)myNode)->arrayDimensionsSize,
+									&((UA_VariableTypeNode *)myNode)->arrayDimensions);
 			break;
 
 		case UA_ATTRIBUTEID_ACCESSLEVEL:
 			CHECK_NODECLASS(UA_NODECLASS_VARIABLE);
 			v[readValueIdIndices[i]].encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
 			retval |= UA_Variant_copySetValue(&v[readValueIdIndices[i]].value, &UA_[UA_BYTE],
-											  &((UA_VariableNode *)node)->accessLevel);
+											  &((UA_VariableNode *)myNode)->accessLevel);
 			break;
 
 		case UA_ATTRIBUTEID_USERACCESSLEVEL:
 			CHECK_NODECLASS(UA_NODECLASS_VARIABLE);
 			v[readValueIdIndices[i]].encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
 			retval |= UA_Variant_copySetValue(&v[readValueIdIndices[i]].value, &UA_[UA_BYTE],
-											  &((UA_VariableNode *)node)->userAccessLevel);
+											  &((UA_VariableNode *)myNode)->userAccessLevel);
 			break;
 
 		case UA_ATTRIBUTEID_MINIMUMSAMPLINGINTERVAL:
 			CHECK_NODECLASS(UA_NODECLASS_VARIABLE);
 			v[readValueIdIndices[i]].encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
 			retval |= UA_Variant_copySetValue(&v[readValueIdIndices[i]].value, &UA_[UA_DOUBLE],
-											  &((UA_VariableNode *)node)->minimumSamplingInterval);
+											  &((UA_VariableNode *)myNode)->minimumSamplingInterval);
 			break;
 
 		case UA_ATTRIBUTEID_HISTORIZING:
 			CHECK_NODECLASS(UA_NODECLASS_VARIABLE);
 			v[readValueIdIndices[i]].encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
 			retval |= UA_Variant_copySetValue(&v[readValueIdIndices[i]].value, &UA_[UA_BOOLEAN],
-											  &((UA_VariableNode *)node)->historizing);
+											  &((UA_VariableNode *)myNode)->historizing);
 			break;
 
 		case UA_ATTRIBUTEID_EXECUTABLE:
 			CHECK_NODECLASS(UA_NODECLASS_METHOD);
 			v[readValueIdIndices[i]].encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
 			retval |= UA_Variant_copySetValue(&v[readValueIdIndices[i]].value, &UA_[UA_BOOLEAN],
-											  &((UA_MethodNode *)node)->executable);
+											  &((UA_MethodNode *)myNode)->executable);
 			break;
 
 		case UA_ATTRIBUTEID_USEREXECUTABLE:
 			CHECK_NODECLASS(UA_NODECLASS_METHOD);
 			v[readValueIdIndices[i]].encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
 			retval |= UA_Variant_copySetValue(&v[readValueIdIndices[i]].value, &UA_[UA_BOOLEAN],
-											  &((UA_MethodNode *)node)->userExecutable);
+											  &((UA_MethodNode *)myNode)->userExecutable);
 			break;
 
 		default:
@@ -227,3 +254,139 @@ UA_Int32 readNodes(UA_ReadValueId * readValueIds, UA_UInt32 *readValueIdIndices,
 	}
 	return retval;
 }
+
+UA_Int32 writeNodes(UA_WriteValue *writeValues,UA_UInt32 *indices ,UA_UInt32 indicesSize, UA_StatusCode *writeNodesResults, UA_DiagnosticInfo *diagnosticInfos)
+{
+    UA_Int32 retval = UA_SUCCESS;
+    for(UA_UInt32 i=0;i<indicesSize;i++){
+		switch(writeValues[indices[i]].attributeId) {
+		case UA_ATTRIBUTEID_NODEID:
+			/* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){ } */
+			writeNodesResults[indices[i]] = UA_STATUSCODE_BADWRITENOTSUPPORTED;
+			return UA_ERROR;
+			break;
+		case UA_ATTRIBUTEID_NODECLASS:
+			/* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){ } */
+			writeNodesResults[indices[i]] = UA_STATUSCODE_BADWRITENOTSUPPORTED;
+			return UA_ERROR;
+			break;
+
+		case UA_ATTRIBUTEID_BROWSENAME:
+			/* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
+			writeNodesResults[indices[i]] = UA_STATUSCODE_BADWRITENOTSUPPORTED;
+			return UA_ERROR;
+			break;
+
+		case UA_ATTRIBUTEID_DISPLAYNAME:
+			/* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
+			writeNodesResults[indices[i]] = UA_STATUSCODE_BADWRITENOTSUPPORTED;
+			return UA_ERROR;
+			break;
+
+		case UA_ATTRIBUTEID_DESCRIPTION:
+			/* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
+			writeNodesResults[indices[i]] = UA_STATUSCODE_BADWRITENOTSUPPORTED;
+			return UA_ERROR;
+			break;
+
+		case UA_ATTRIBUTEID_WRITEMASK:
+			/* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
+			break;
+
+		case UA_ATTRIBUTEID_USERWRITEMASK:
+			/* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
+			writeNodesResults[indices[i]] = UA_STATUSCODE_BADWRITENOTSUPPORTED;
+			return UA_ERROR;
+			break;
+
+		case UA_ATTRIBUTEID_ISABSTRACT:
+
+			/* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
+			writeNodesResults[indices[i]] = UA_STATUSCODE_BADWRITENOTSUPPORTED;
+
+			break;
+
+		case UA_ATTRIBUTEID_SYMMETRIC:
+			/* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
+			writeNodesResults[indices[i]] = UA_STATUSCODE_BADWRITENOTSUPPORTED;
+			return UA_ERROR;
+			break;
+
+		case UA_ATTRIBUTEID_INVERSENAME:
+			/* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
+			writeNodesResults[indices[i]] = UA_STATUSCODE_BADWRITENOTSUPPORTED;
+			break;
+
+		case UA_ATTRIBUTEID_CONTAINSNOLOOPS:
+			/* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
+			writeNodesResults[indices[i]] = UA_STATUSCODE_BADWRITENOTSUPPORTED;
+			return UA_ERROR;
+			break;
+
+		case UA_ATTRIBUTEID_EVENTNOTIFIER:
+			/* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
+			writeNodesResults[indices[i]] = UA_STATUSCODE_BADWRITENOTSUPPORTED;
+			break;
+
+		case UA_ATTRIBUTEID_VALUE:
+			if(writeValues[indices[i]].value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT) {
+				retval |= UA_Variant_copy(&writeValues[indices[i]].value.value, &((UA_VariableNode *)myNode)->value); // todo: zero-copy
+				writeNodesResults[indices[i]] = UA_STATUSCODE_GOOD;
+			}
+
+			break;
+
+		case UA_ATTRIBUTEID_DATATYPE:
+			/* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
+			writeNodesResults[indices[i]]   = UA_STATUSCODE_BADWRITENOTSUPPORTED;
+			break;
+
+		case UA_ATTRIBUTEID_VALUERANK:
+			/* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
+			writeNodesResults[indices[i]]   = UA_STATUSCODE_BADWRITENOTSUPPORTED;
+			break;
+
+		case UA_ATTRIBUTEID_ARRAYDIMENSIONS:
+			/* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
+			writeNodesResults[indices[i]]   = UA_STATUSCODE_BADWRITENOTSUPPORTED;
+			break;
+
+		case UA_ATTRIBUTEID_ACCESSLEVEL:
+			/* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
+			writeNodesResults[indices[i]]   = UA_STATUSCODE_BADWRITENOTSUPPORTED;
+			break;
+
+		case UA_ATTRIBUTEID_USERACCESSLEVEL:
+			/* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
+			writeNodesResults[indices[i]]   = UA_STATUSCODE_BADWRITENOTSUPPORTED;
+			return UA_ERROR;
+			break;
+
+		case UA_ATTRIBUTEID_MINIMUMSAMPLINGINTERVAL:
+			/* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
+			writeNodesResults[indices[i]]   = UA_STATUSCODE_BADWRITENOTSUPPORTED;
+			break;
+
+		case UA_ATTRIBUTEID_HISTORIZING:
+			/* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
+			writeNodesResults[indices[i]]   = UA_STATUSCODE_BADWRITENOTSUPPORTED;
+			break;
+
+		case UA_ATTRIBUTEID_EXECUTABLE:
+			/* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
+			writeNodesResults[indices[i]]   = UA_STATUSCODE_BADWRITENOTSUPPORTED;
+			break;
+
+		case UA_ATTRIBUTEID_USEREXECUTABLE:
+			/* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
+			writeNodesResults[indices[i]]   = UA_STATUSCODE_BADWRITENOTSUPPORTED;
+			break;
+
+		default:
+			writeNodesResults[indices[i]]   = UA_STATUSCODE_BADATTRIBUTEIDINVALID;
+			break;
+		}
+    }
+
+    return retval;
+}

examples/nodestoreAccessExample.h

@@ -7,8 +7,14 @@
 
 #ifndef NODESTOREACCESSEXAMPLE_H_
 #define NODESTOREACCESSEXAMPLE_H_
+#include "ua_types.h"
+#include "ua_statuscodes.h"
+#include "ua_namespace_0.h"
+#include "ua_config.h"
+#include "ua_util.h"
 
 
-UA_Int32 readNodes(UA_ReadValueId * readValueIds, UA_UInt32 *readValueIdIndices, UA_UInt32 readValueIdsSize, UA_DataValue *v, UA_Boolean timeStampToReturn, UA_DiagnosticInfo *diagnosticInfo);
-
+UA_Int32 readNodes(UA_ReadValueId * readValueIds, UA_UInt32 *readValueIdIndices, UA_UInt32 readValueIdsSize, UA_DataValue *v, UA_Boolean timeStampToReturn, UA_DiagnosticInfo *diagnosticInfos);
+UA_Int32 writeNodes(UA_WriteValue *writeValues,UA_UInt32 *indices ,UA_UInt32 indicesSize, UA_StatusCode *writeNodesResults, UA_DiagnosticInfo *diagnosticInfos);
+UA_Int32 initMyNode();
 #endif /* NODESTOREACCESSEXAMPLE_H_ */

examples/opcuaServer.c

@@ -62,7 +62,10 @@ int main(int argc, char** argv) {
 	UA_NodeStore newNodeStore;
 
 	UA_Server_addNamespace(&server,0,&newNodeStore);
+
+	initMyNode();
 	UA_NodeStore_registerReadNodesOperation(&newNodeStore,readNodes);
+	UA_NodeStore_registerWriteNodesOperation(&newNodeStore,writeNodes);
 
 	Logger_Stdout_init(&server.logger);
     server.serverCertificate = loadCertificate();

include/ua_server.h

@@ -60,16 +60,16 @@ struct UA_NamespaceManager;
 typedef struct UA_NamespaceManager UA_NamespaceManager;
 
 
-typedef UA_Int32 (*UA_NodeStore_addNodes)(UA_AddNodesItem *nodesToAdd,UA_UInt32 *indices,UA_UInt32 NodesToAddSize, UA_AddNodesResult* result, UA_DiagnosticInfo *diagnosticInfo);
-typedef UA_Int32 (*UA_NodeStore_addReferences)(UA_AddReferencesItem* referencesToAdd,UA_UInt32 *indices,UA_UInt32 ReferencesToAddSize, UA_StatusCode *result, UA_DiagnosticInfo diagnosticInfo);
+typedef UA_Int32 (*UA_NodeStore_addNodes)(UA_AddNodesItem *nodesToAdd,UA_UInt32 *indices,UA_UInt32 indicesSize, UA_AddNodesResult* addNodesResults, UA_DiagnosticInfo *diagnosticInfos);
+typedef UA_Int32 (*UA_NodeStore_addReferences)(UA_AddReferencesItem* referencesToAdd,UA_UInt32 *indices,UA_UInt32 indicesSize, UA_StatusCode *addReferencesResults, UA_DiagnosticInfo diagnosticInfos);
 
-typedef UA_Int32 (*UA_NodeStore_deleteNodes)(UA_DeleteNodesItem *nodesToDelete,UA_UInt32 *indices,UA_UInt32 NodesToDeleteSize, UA_StatusCode *result, UA_DiagnosticInfo *diagnosticInfo);
-typedef UA_Int32 (*UA_NodeStore_deleteReferences)(UA_DeleteReferencesItem referenceToDelete,UA_UInt32 *indices, UA_UInt32 ReferencesToDeleteSize,UA_StatusCode result, UA_DiagnosticInfo diagnosticInfo);
+typedef UA_Int32 (*UA_NodeStore_deleteNodes)(UA_DeleteNodesItem *nodesToDelete,UA_UInt32 *indices,UA_UInt32 indicesSize, UA_StatusCode *deleteNodesResults, UA_DiagnosticInfo *diagnosticInfos);
+typedef UA_Int32 (*UA_NodeStore_deleteReferences)(UA_DeleteReferencesItem referenceToDelete,UA_UInt32 *indices, UA_UInt32 indicesSize,UA_StatusCode deleteReferencesresults, UA_DiagnosticInfo diagnosticInfos);
 
 
-typedef UA_Int32 (*UA_NodeStore_readNodes)(UA_ReadValueId *readValueIds,UA_UInt32 *indices,UA_UInt32 ReadValueIdsSize,UA_DataValue *value, UA_Boolean timeStampToReturn, UA_DiagnosticInfo *diagnosticInfo);
-typedef UA_Int32 (*UA_NodeStore_writeNodes)(UA_WriteValue *writeValues,UA_UInt32 *indices ,UA_UInt32 WriteValuesSize, UA_StatusCode *result, UA_DiagnosticInfo *diagnosticInfo);
-typedef UA_Int32 (*UA_NodeStore_browseNodes)(UA_UInt32 requestedMaxReferencesPerNode, UA_BrowseDescription *browseDescriptions,UA_Int32 *indices,UA_UInt32 BrowseDescriptionsSize, UA_BrowseResult *browseResult, UA_DiagnosticInfo *diagnosticInfo);
+typedef UA_Int32 (*UA_NodeStore_readNodes)(UA_ReadValueId *readValueIds,UA_UInt32 *indices,UA_UInt32 indicesSize,UA_DataValue *readNodesResults, UA_Boolean timeStampToReturn, UA_DiagnosticInfo *diagnosticInfos);
+typedef UA_Int32 (*UA_NodeStore_writeNodes)(UA_WriteValue *writeValues,UA_UInt32 *indices ,UA_UInt32 indicesSize, UA_StatusCode *writeNodesResults, UA_DiagnosticInfo *diagnosticInfo);
+typedef UA_Int32 (*UA_NodeStore_browseNodes)(UA_UInt32 requestedMaxReferencesPerNode, UA_BrowseDescription *browseDescriptions,UA_Int32 *indices,UA_UInt32 indicesSize, UA_BrowseResult *browseResults, UA_DiagnosticInfo *diagnosticInfos);
 
 
 

src/server/ua_nodestore.c

@@ -50,7 +50,7 @@ UA_Int32 UA_NodeStore_registerReadNodesOperation(UA_NodeStore *nodeStore, UA_Nod
 	return UA_SUCCESS;
 }
 
-UA_Int32 UA_NodeStore_registerWriteOperation(UA_NodeStore *nodeStore, UA_NodeStore_writeNodes writeNodes)
+UA_Int32 UA_NodeStore_registerWriteNodesOperation(UA_NodeStore *nodeStore, UA_NodeStore_writeNodes writeNodes)
 {
 	if(nodeStore==UA_NULL){
 		return UA_ERROR;
@@ -59,7 +59,7 @@ UA_Int32 UA_NodeStore_registerWriteOperation(UA_NodeStore *nodeStore, UA_NodeSto
 	return UA_SUCCESS;
 }
 
-UA_Int32 UA_NodeStore_registerBrowseOperation(UA_NodeStore *nodeStore, UA_NodeStore_browseNodes browseNodes)
+UA_Int32 UA_NodeStore_registerBrowseNodesOperation(UA_NodeStore *nodeStore, UA_NodeStore_browseNodes browseNodes)
 {
 	if(nodeStore==UA_NULL){
 		return UA_ERROR;

src/server/ua_nodestore.h

@@ -12,7 +12,7 @@ UA_Int32 UA_EXPORT UA_NodeStore_registerDeleteNodesOperation(UA_NodeStore *nodeS
 UA_Int32 UA_EXPORT UA_NodeStore_registerDeleteReferencesOperation(UA_NodeStore *nodeStore, UA_NodeStore_deleteReferences deleteReference);
 UA_Int32 UA_EXPORT UA_NodeStore_registerReadNodesOperation(UA_NodeStore *nodeStore, UA_NodeStore_readNodes readNode);
 UA_Int32 UA_EXPORT UA_NodeStore_registerWriteNodesOperation(UA_NodeStore *nodeStore, UA_NodeStore_writeNodes writeNode);
-UA_Int32 UA_EXPORT UA_NodeStore_registerBrowseOperation(UA_NodeStore *nodeStore, UA_NodeStore_browseNodes browseNode);
+UA_Int32 UA_EXPORT UA_NodeStore_registerBrowseNodesOperation(UA_NodeStore *nodeStore, UA_NodeStore_browseNodes browseNode);
 
 #define UA_NODESTORE_INSERT_UNIQUE 1
 #define UA_NODESTORE_INSERT_GETMANAGED 2

src/server/ua_services_attribute.c

@@ -235,7 +235,7 @@ void Service_Read(UA_Server *server, UA_Session *session,
     response->resultsSize = request->nodesToReadSize;
 
     UA_Int32 *numberOfFoundIndices;
-    UA_Int16 *associatedIndices;
+    UA_UInt16 *associatedIndices;
     UA_UInt32 differentNamespaceIndexCount = 0;
     if(UA_Array_new((void **)&numberOfFoundIndices,request->nodesToReadSize,&UA_[UA_UINT32]) != UA_SUCCESS){
     	response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY;
@@ -251,9 +251,12 @@ void Service_Read(UA_Server *server, UA_Session *session,
    for(UA_Int32 i = 0; i<request->nodesToReadSize; i++){
 
     	for(UA_UInt32 j = 0; j <= differentNamespaceIndexCount; j++){
-    		if( associatedIndices[j] == request->nodesToRead[i].nodeId.namespaceIndex){
-    			numberOfFoundIndices[j]++;
-    			break;
+    		if(associatedIndices[j] == request->nodesToRead[i].nodeId.namespaceIndex){
+    			if(j==0){
+    				differentNamespaceIndexCount++;
+    			}
+				numberOfFoundIndices[j]++;
+				break;
     		}
     		else if(j == (differentNamespaceIndexCount - 1)){
     			associatedIndices[j] = request->nodesToRead[i].nodeId.namespaceIndex;
@@ -293,7 +296,7 @@ void Service_Read(UA_Server *server, UA_Session *session,
     	}
     }
     UA_free(readValueIdIndices);
-
+    UA_free(numberOfFoundIndices);
     /*
     for(UA_Int32 i = 0;i < response->resultsSize;i++){
 				response->results[i] = service_read_node(server, &request->nodesToRead[i]);