clean up the client, improve the datavalue api

examples/client.c

@@ -11,31 +11,28 @@
 int main(int argc, char *argv[]) {
 	UA_Client *client = UA_Client_new();
 	UA_ClientNetworkLayer nl = ClientNetworkLayerTCP_new(UA_ConnectionConfig_standard);
-    //if(UA_Client_connect(client, UA_ConnectionConfig_standard, nl, "opc.tcp://localhost:48020") != UA_STATUSCODE_GOOD)
-	if(UA_Client_connect(client, UA_ConnectionConfig_standard, nl, "opc.tcp://localhost:16664") != UA_STATUSCODE_GOOD)
-    	return 0;
+    UA_StatusCode retval = UA_Client_connect(client, UA_ConnectionConfig_standard, nl,
+                                             "opc.tcp://localhost:16664");
+	if(retval != UA_STATUSCODE_GOOD)
+    	return retval;
 
-    UA_NodeId node;
-    //node.namespaceIndex = 4;
-    //node.identifierType = UA_NODEIDTYPE_STRING;
-    //UA_String_copycstring("Demo.Static.Scalar.Int32", &node.identifier.string);
-    node.namespaceIndex = 1;
-    node.identifierType = UA_NODEIDTYPE_NUMERIC;
-    node.identifier.numeric = 442;
+    UA_ReadRequest req;
+    UA_ReadRequest_init(&req);
+    req.nodesToRead = UA_ReadValueId_new();
+    req.nodesToReadSize = 1;
+    req.nodesToRead[0].nodeId = UA_NODEID_STATIC(1, 442); /* assume this node exists */
+    req.nodesToRead[0].attributeId = UA_ATTRIBUTEID_VALUE;
 
-    UA_ReadRequest read_req;
-    UA_ReadRequest_init(&read_req);
-
-    read_req.nodesToRead = UA_ReadValueId_new();
-    read_req.nodesToReadSize = 1;
-    read_req.nodesToRead[0].nodeId = node;
-    read_req.nodesToRead[0].attributeId = UA_ATTRIBUTEID_VALUE;
-    UA_ReadResponse read_resp;
-    UA_Client_read(client, &read_req, &read_resp);
-    printf("the answer is: %i\n", *(UA_Int32*)read_resp.results[0].value.dataPtr);
-    UA_ReadRequest_deleteMembers(&read_req);
-    UA_ReadResponse_deleteMembers(&read_resp);
+    UA_ReadResponse resp = UA_Client_read(client, &req);
+    if(resp.responseHeader.serviceResult == UA_STATUSCODE_GOOD &&
+       resp.resultsSize > 0 && resp.results[0].hasValue &&
+       resp.results[0].value.data /* an empty array returns a null-ptr */ &&
+       resp.results[0].value.type == &UA_TYPES[UA_TYPES_INT32])
+        printf("the answer is: %i\n", *(UA_Int32*)resp.results[0].value.data);
 
+    UA_ReadRequest_deleteMembers(&req);
+    UA_ReadResponse_deleteMembers(&resp);
     UA_Client_disconnect(client);
     UA_Client_delete(client);
+    return UA_STATUSCODE_GOOD;
 }

examples/server.c

@@ -39,10 +39,10 @@ static UA_StatusCode readTimeData(const void *handle, UA_Boolean sourceTimeStamp
 	*currentTime = UA_DateTime_now();
 	value->value.type = &UA_TYPES[UA_TYPES_DATETIME];
 	value->value.arrayLength = -1;
-	value->value.dataPtr = currentTime;
+	value->value.data = currentTime;
 	value->value.arrayDimensionsSize = -1;
 	value->value.arrayDimensions = NULL;
-	value->hasVariant = UA_TRUE;
+	value->hasValue = UA_TRUE;
 	if(sourceTimeStamp) {
 		value->hasSourceTimestamp = UA_TRUE;
 		value->sourceTimestamp = *currentTime;
@@ -51,7 +51,7 @@ static UA_StatusCode readTimeData(const void *handle, UA_Boolean sourceTimeStamp
 }
 
 static void releaseTimeData(const void *handle, UA_DataValue *value) {
-	UA_DateTime_delete((UA_DateTime*)value->value.dataPtr);
+	UA_DateTime_delete((UA_DateTime*)value->value.data);
 }
 
 /*****************************/
@@ -76,15 +76,15 @@ static UA_StatusCode readTemperature(const void *handle, UA_Boolean sourceTimeSt
 
 	value->value.type = &UA_TYPES[UA_TYPES_DOUBLE];
 	value->value.arrayLength = -1;
-	value->value.dataPtr = currentTemperature;
+	value->value.data = currentTemperature;
 	value->value.arrayDimensionsSize = -1;
 	value->value.arrayDimensions = NULL;
-	value->hasVariant = UA_TRUE;
+	value->hasValue = UA_TRUE;
 	return UA_STATUSCODE_GOOD;
 }
 
 static void releaseTemperature(const void *handle, UA_DataValue *value) {
-	UA_Double_delete((UA_Double*)value->value.dataPtr);
+	UA_Double_delete((UA_Double*)value->value.data);
 }
 
 /*************************/
@@ -105,10 +105,10 @@ static UA_StatusCode readLedStatus(const void *handle, UA_Boolean sourceTimeStam
 #endif
 	value->value.type = &UA_TYPES[UA_TYPES_BOOLEAN];
 	value->value.arrayLength = -1;
-	value->value.dataPtr = &ledStatus;
+	value->value.data = &ledStatus;
 	value->value.arrayDimensionsSize = -1;
 	value->value.arrayDimensions = NULL;
-	value->hasVariant = UA_TRUE;
+	value->hasValue = UA_TRUE;
 	if(sourceTimeStamp) {
 		value->sourceTimestamp = UA_DateTime_now();
 		value->hasSourceTimestamp = UA_TRUE;
@@ -120,7 +120,7 @@ static void releaseLedStatus(const void *handle, UA_DataValue *value) {
 	/* If we allocated memory for a specific read, free the content of the
        variantdata. */
 	value->value.arrayLength = -1;
-	value->value.dataPtr = NULL;
+	value->value.data = NULL;
 #ifdef UA_MULTITHREADING
 	pthread_rwlock_unlock(&writeLock);
 #endif
@@ -130,8 +130,8 @@ static UA_StatusCode writeLedStatus(const void *handle, const UA_Variant *data)
 #ifdef UA_MULTITHREADING
 	pthread_rwlock_wrlock(&writeLock);
 #endif
-	if(data->dataPtr)
-		ledStatus = *(UA_Boolean*)data->dataPtr;
+	if(data->data)
+		ledStatus = *(UA_Boolean*)data->data;
 
 	if(triggerFile)
 		fseek(triggerFile, 0, SEEK_SET);

include/ua_client.h

@@ -37,20 +37,23 @@ UA_StatusCode UA_EXPORT UA_Client_connect(UA_Client *client, UA_ConnectionConfig
 UA_StatusCode UA_EXPORT UA_Client_disconnect(UA_Client *client);
 
 /* Attribute Service Set */
-//TODO: had to remove const from the 2nd argument
-UA_StatusCode UA_EXPORT UA_Client_read(UA_Client *client, UA_ReadRequest *request, UA_ReadResponse *response);
-
-UA_StatusCode UA_EXPORT UA_Client_write(UA_Client *client, UA_WriteRequest *request, UA_WriteResponse *response);
+UA_ReadResponse UA_EXPORT UA_Client_read(UA_Client *client, UA_ReadRequest *request);
+UA_WriteResponse UA_EXPORT UA_Client_write(UA_Client *client, UA_WriteRequest *request);
 
 /* View Service Set */    
-UA_StatusCode UA_EXPORT UA_Client_browse(UA_Client *client, UA_BrowseRequest *request, UA_BrowseResponse *response);
-UA_StatusCode UA_EXPORT UA_Client_translateBrowsePathsToNodeIds(UA_Client *client, UA_TranslateBrowsePathsToNodeIdsRequest *request, UA_TranslateBrowsePathsToNodeIdsResponse* response);
+UA_BrowseResponse UA_EXPORT UA_Client_browse(UA_Client *client, UA_BrowseRequest *request);
+UA_TranslateBrowsePathsToNodeIdsResponse UA_EXPORT
+    UA_Client_translateTranslateBrowsePathsToNodeIds(UA_Client *client,
+                                                     UA_TranslateBrowsePathsToNodeIdsRequest *request);
 
 /* NodeManagement Service Set */
-UA_StatusCode UA_EXPORT UA_Client_addNodes(UA_Client *client, UA_AddNodesRequest *request, UA_AddNodesResponse* response);
-UA_StatusCode UA_EXPORT UA_Client_addReferences(UA_Client *client, UA_AddReferencesRequest *request, UA_AddReferencesResponse* response);
-UA_StatusCode UA_EXPORT UA_Client_deleteNodes(UA_Client *client, UA_DeleteNodesRequest *request, UA_DeleteNodesResponse* response);
-UA_StatusCode UA_EXPORT UA_Client_deleteReferences(UA_Client *client, UA_DeleteReferencesRequest *request, UA_DeleteReferencesResponse* response);
+UA_AddNodesResponse UA_EXPORT UA_Client_addNodes(UA_Client *client, UA_AddNodesRequest *request);
+UA_AddReferencesResponse UA_EXPORT
+    UA_Client_addReferences(UA_Client *client, UA_AddReferencesRequest *request);
+
+UA_DeleteNodesResponse UA_EXPORT UA_Client_deleteNodes(UA_Client *client, UA_DeleteNodesRequest *request);
+UA_DeleteReferencesResponse UA_EXPORT
+    UA_Client_deleteReferences(UA_Client *client, UA_DeleteReferencesRequest *request);
     
 #ifdef __cplusplus
 } // extern "C"

include/ua_types.h

@@ -216,14 +216,14 @@ typedef struct {
                                        Use a custom datasource with a mutex. */
     } storageType;
     UA_Int32  arrayLength;  ///< the number of elements in the data-pointer
-    void     *dataPtr; ///< points to the scalar or array data
+    void     *data; ///< points to the scalar or array data
     UA_Int32  arrayDimensionsSize; ///< the number of dimensions the data-array has
     UA_Int32 *arrayDimensions; ///< the length of each dimension of the data-array
 } UA_Variant;
 
 /** @brief A data value with an associated status code and timestamps. */
 typedef struct {
-    UA_Boolean    hasVariant : 1;
+    UA_Boolean    hasValue : 1;
     UA_Boolean    hasStatus : 1;
     UA_Boolean    hasSourceTimestamp : 1;
     UA_Boolean    hasServerTimestamp : 1;
@@ -409,10 +409,10 @@ UA_StatusCode UA_EXPORT UA_LocalizedText_copycstring(char const *src, UA_Localiz
 
 /**
  * Variant semantics:
- *  - arrayLength = -1 && dataPtr == NULL: empty variant
- *  - arrayLength = -1 && dataPtr == !NULL: variant holds a single element (a scalar)
+ *  - arrayLength = -1 && data == NULL: empty variant
+ *  - arrayLength = -1 && data == !NULL: variant holds a single element (a scalar)
  *  - arrayLength >= 0: variant holds an array of the appropriate length
- *                    : dataPtr can be NULL if arrayLength == 0
+ *                      data can be NULL if arrayLength == 0
  */
 
 /**

src/client/ua_client.c

@@ -55,6 +55,62 @@ void UA_Client_delete(UA_Client* client){
     free(client);
 }
 
+// The tcp connection is established. Now do the handshake
+static UA_StatusCode HelAckHandshake(UA_Client *c) {
+	UA_TcpMessageHeader messageHeader;
+    messageHeader.messageTypeAndFinal = UA_MESSAGETYPEANDFINAL_HELF;
+
+	UA_TcpHelloMessage hello;
+	UA_String_copy(&c->endpointUrl, &hello.endpointUrl);
+
+    UA_Connection *conn = &c->connection;
+	hello.maxChunkCount = conn->localConf.maxChunkCount;
+	hello.maxMessageSize = conn->localConf.maxMessageSize;
+	hello.protocolVersion = conn->localConf.protocolVersion;
+	hello.receiveBufferSize = conn->localConf.recvBufferSize;
+	hello.sendBufferSize = conn->localConf.sendBufferSize;
+
+	messageHeader.messageSize = UA_TcpHelloMessage_calcSizeBinary((UA_TcpHelloMessage const*) &hello) +
+                                UA_TcpMessageHeader_calcSizeBinary((UA_TcpMessageHeader const*) &messageHeader);
+	UA_ByteString message;
+    message.data = UA_alloca(messageHeader.messageSize);
+    message.length = messageHeader.messageSize;
+
+	size_t offset = 0;
+	UA_TcpMessageHeader_encodeBinary(&messageHeader, &message, &offset);
+	UA_TcpHelloMessage_encodeBinary(&hello, &message, &offset);
+    UA_TcpHelloMessage_deleteMembers(&hello);
+
+    UA_ByteStringArray buf = {.stringsSize = 1, .strings = &message};
+    UA_StatusCode retval = c->networkLayer.send(c->networkLayer.nlHandle, buf);
+    if(retval)
+        return retval;
+
+    UA_Byte replybuf[1024];
+    UA_ByteString reply = {.data = replybuf, .length = 1024};
+    retval = c->networkLayer.awaitResponse(c->networkLayer.nlHandle, &reply, 0);
+	if (retval)
+		return retval;
+
+    offset = 0;
+	UA_TcpMessageHeader_decodeBinary(&reply, &offset, &messageHeader);
+    UA_TcpAcknowledgeMessage ackMessage;
+    retval = UA_TcpAcknowledgeMessage_decodeBinary(&reply, &offset, &ackMessage);
+    if(retval != UA_STATUSCODE_GOOD) {
+        UA_TcpAcknowledgeMessage_deleteMembers(&ackMessage);
+        return retval;
+    }
+    conn->remoteConf.maxChunkCount = ackMessage.maxChunkCount;
+    conn->remoteConf.maxMessageSize = ackMessage.maxMessageSize;
+    conn->remoteConf.protocolVersion = ackMessage.protocolVersion;
+    conn->remoteConf.recvBufferSize = ackMessage.receiveBufferSize;
+    conn->remoteConf.sendBufferSize = ackMessage.sendBufferSize;
+    conn->state = UA_CONNECTION_ESTABLISHED;
+
+    UA_TcpAcknowledgeMessage_deleteMembers(&ackMessage);
+	return UA_STATUSCODE_GOOD;
+}
+
 static UA_StatusCode SecureChannelHandshake(UA_Client *client) {
     UA_ByteString_deleteMembers(&client->clientNonce); // if the handshake is repeated
 	UA_ByteString_newMembers(&client->clientNonce, 1);
@@ -152,74 +208,19 @@ static UA_StatusCode SecureChannelHandshake(UA_Client *client) {
 
 }
 
-// The tcp connection is established. Now do the handshake
-static UA_StatusCode HelAckHandshake(UA_Client *c) {
-	UA_TcpMessageHeader messageHeader;
-    messageHeader.messageTypeAndFinal = UA_MESSAGETYPEANDFINAL_HELF;
-
-	UA_TcpHelloMessage hello;
-	UA_String_copy(&c->endpointUrl, &hello.endpointUrl);
-
-    UA_Connection *conn = &c->connection;
-	hello.maxChunkCount = conn->localConf.maxChunkCount;
-	hello.maxMessageSize = conn->localConf.maxMessageSize;
-	hello.protocolVersion = conn->localConf.protocolVersion;
-	hello.receiveBufferSize = conn->localConf.recvBufferSize;
-	hello.sendBufferSize = conn->localConf.sendBufferSize;
-
-	messageHeader.messageSize = UA_TcpHelloMessage_calcSizeBinary((UA_TcpHelloMessage const*) &hello) +
-                                UA_TcpMessageHeader_calcSizeBinary((UA_TcpMessageHeader const*) &messageHeader);
-	UA_ByteString message;
-    message.data = UA_alloca(messageHeader.messageSize);
-    message.length = messageHeader.messageSize;
-
-	size_t offset = 0;
-	UA_TcpMessageHeader_encodeBinary(&messageHeader, &message, &offset);
-	UA_TcpHelloMessage_encodeBinary(&hello, &message, &offset);
-    UA_TcpHelloMessage_deleteMembers(&hello);
-
-    UA_ByteStringArray buf = {.stringsSize = 1, .strings = &message};
-    UA_StatusCode retval = c->networkLayer.send(c->networkLayer.nlHandle, buf);
-    if(retval)
-        return retval;
-
-    UA_Byte replybuf[1024];
-    UA_ByteString reply = {.data = replybuf, .length = 1024};
-    retval = c->networkLayer.awaitResponse(c->networkLayer.nlHandle, &reply, 0);
-	if (retval)
-		return retval;
-
-    offset = 0;
-	UA_TcpMessageHeader_decodeBinary(&reply, &offset, &messageHeader);
-    UA_TcpAcknowledgeMessage ackMessage;
-    retval = UA_TcpAcknowledgeMessage_decodeBinary(&reply, &offset, &ackMessage);
-    if(retval != UA_STATUSCODE_GOOD) {
-        UA_TcpAcknowledgeMessage_deleteMembers(&ackMessage);
-        return retval;
-    }
-    conn->remoteConf.maxChunkCount = ackMessage.maxChunkCount;
-    conn->remoteConf.maxMessageSize = ackMessage.maxMessageSize;
-    conn->remoteConf.protocolVersion = ackMessage.protocolVersion;
-    conn->remoteConf.recvBufferSize = ackMessage.receiveBufferSize;
-    conn->remoteConf.sendBufferSize = ackMessage.sendBufferSize;
-    conn->state = UA_CONNECTION_ESTABLISHED;
-
-    UA_TcpAcknowledgeMessage_deleteMembers(&ackMessage);
-	return UA_STATUSCODE_GOOD;
-}
-
 /** If the request fails, then the response is cast to UA_ResponseHeader (at the beginning of every
     response) and filled with the appropriate error code */
-static void sendReceiveRequest(const void *request, const UA_DataType *requestType,
-                               void *response, const UA_DataType *responseType, UA_Client *client, UA_Boolean sendOnly)
+static void sendReceiveRequest(UA_RequestHeader *request, const UA_DataType *requestType,
+                               void *response, const UA_DataType *responseType, UA_Client *client,
+                               UA_Boolean sendOnly)
 {
+    UA_NodeId_copy(&client->authenticationToken, &request->authenticationToken);
 
     UA_SecureConversationMessageHeader msgHeader;
-    if(sendOnly){
+    if(sendOnly)
     	msgHeader.messageHeader.messageTypeAndFinal = UA_MESSAGETYPEANDFINAL_CLOF;
-    }else{
+    else
     	msgHeader.messageHeader.messageTypeAndFinal = UA_MESSAGETYPEANDFINAL_MSGF;
-    }
     msgHeader.secureChannelId = client->securityToken.channelId;
 
     UA_SymmetricAlgorithmSecurityHeader symHeader;
@@ -298,15 +299,11 @@ static void sendReceiveRequest(const void *request, const UA_DataType *requestTy
         respHeader->serviceResult = retval;
 }
 
-static void synchronousRequest(const void *request, const UA_DataType *requestType,
+static void synchronousRequest(void *request, const UA_DataType *requestType,
                                void *response, const UA_DataType *responseType, UA_Client *client){
 	sendReceiveRequest(request, requestType, response, responseType, client, UA_FALSE);
 }
 
-static void sendOnlyRequest(const void *request, const UA_DataType *requestType, UA_Client *client){
-	sendReceiveRequest(request, requestType, UA_NULL, UA_NULL, client, UA_TRUE);
-}
-
 static UA_StatusCode ActivateSession(UA_Client *client) {
 	UA_ActivateSessionRequest request;
 	UA_ActivateSessionRequest_init(&request);
@@ -381,10 +378,9 @@ static UA_StatusCode CloseSecureChannel(UA_Client *client) {
     request.requestHeader.requestHandle = 1; //TODO: magic number?
     request.requestHeader.timestamp = UA_DateTime_now();
     request.requestHeader.timeoutHint = 10000;
-
     request.requestHeader.authenticationToken = client->authenticationToken;
-
-    sendOnlyRequest(&request, &UA_TYPES[UA_TYPES_CLOSESECURECHANNELREQUEST], client);
+	sendReceiveRequest(&request.requestHeader, &UA_TYPES[UA_TYPES_CLOSESECURECHANNELREQUEST], UA_NULL, UA_NULL,
+                       client, UA_TRUE);
 
     return UA_STATUSCODE_GOOD;
 
@@ -427,66 +423,61 @@ UA_StatusCode UA_EXPORT UA_Client_disconnect(UA_Client *client) {
     return retval;
 }
 
-UA_StatusCode UA_Client_read(UA_Client *client, UA_ReadRequest *request, UA_ReadResponse *response) {
-    //todo: probably move to synchronousRequest
-    UA_NodeId_copy(&client->authenticationToken, &request->requestHeader.authenticationToken);
-    synchronousRequest(request, &UA_TYPES[UA_TYPES_READREQUEST], response,
+UA_ReadResponse UA_Client_read(UA_Client *client, UA_ReadRequest *request) {
+    UA_ReadResponse response;
+    synchronousRequest(request, &UA_TYPES[UA_TYPES_READREQUEST], &response,
                        &UA_TYPES[UA_TYPES_READRESPONSE], client);
-    return UA_STATUSCODE_GOOD;
+    return response;
 }
 
-UA_StatusCode UA_Client_write(UA_Client *client, UA_WriteRequest *request, UA_WriteResponse *response) {
-	//todo: probably move to synchronousRequest
-    UA_NodeId_copy(&client->authenticationToken, &request->requestHeader.authenticationToken);
-    synchronousRequest(request, &UA_TYPES[UA_TYPES_WRITEREQUEST], response,
+UA_WriteResponse UA_Client_write(UA_Client *client, UA_WriteRequest *request) {
+    UA_WriteResponse response;
+    synchronousRequest(request, &UA_TYPES[UA_TYPES_WRITEREQUEST], &response,
                        &UA_TYPES[UA_TYPES_WRITERESPONSE], client);
-    return UA_STATUSCODE_GOOD;
+    return response;
 }
 
-UA_StatusCode UA_Client_browse(UA_Client *client, UA_BrowseRequest *request, UA_BrowseResponse *response) {
-	//todo: probably move to synchronousRequest
-    UA_NodeId_copy(&client->authenticationToken, &request->requestHeader.authenticationToken);
-    synchronousRequest(request, &UA_TYPES[UA_TYPES_BROWSEREQUEST], response,
+UA_BrowseResponse UA_Client_browse(UA_Client *client, UA_BrowseRequest *request) {
+    UA_BrowseResponse response;
+    synchronousRequest(request, &UA_TYPES[UA_TYPES_BROWSEREQUEST], &response,
                        &UA_TYPES[UA_TYPES_BROWSERESPONSE], client);
-    return UA_STATUSCODE_GOOD;
+    return response;
 }
 
-UA_StatusCode UA_Client_translateBrowsePathsToNodeIds(UA_Client *client, UA_TranslateBrowsePathsToNodeIdsRequest *request, UA_TranslateBrowsePathsToNodeIdsResponse* response){
-	//todo: probably move to synchronousRequest
-	UA_NodeId_copy(&client->authenticationToken, &request->requestHeader.authenticationToken);
-    synchronousRequest(request, &UA_TYPES[UA_TYPES_BROWSEREQUEST], response,
+UA_TranslateBrowsePathsToNodeIdsResponse
+    UA_Client_translateTranslateBrowsePathsToNodeIds(UA_Client *client,
+                                                     UA_TranslateBrowsePathsToNodeIdsRequest *request) {
+    UA_TranslateBrowsePathsToNodeIdsResponse response;
+    synchronousRequest(request, &UA_TYPES[UA_TYPES_BROWSEREQUEST], &response,
                        &UA_TYPES[UA_TYPES_BROWSERESPONSE], client);
-    return UA_STATUSCODE_GOOD;
+    return response;
 }
 
-UA_StatusCode UA_Client_addNodes(UA_Client *client, UA_AddNodesRequest *request, UA_AddNodesResponse* response) {
-	//todo: probably move to synchronousRequest
-	UA_NodeId_copy(&client->authenticationToken, &request->requestHeader.authenticationToken);
-    synchronousRequest(request, &UA_TYPES[UA_TYPES_BROWSEREQUEST], response,
+UA_AddNodesResponse UA_Client_addNodes(UA_Client *client, UA_AddNodesRequest *request) {
+    UA_AddNodesResponse response;
+    synchronousRequest(request, &UA_TYPES[UA_TYPES_BROWSEREQUEST], &response,
                        &UA_TYPES[UA_TYPES_BROWSERESPONSE], client);
-    return UA_STATUSCODE_GOOD;
+    return response;
 }
 
-UA_StatusCode UA_Client_addReferences(UA_Client *client, UA_AddReferencesRequest *request, UA_AddReferencesResponse* response) {
-	//todo: probably move to synchronousRequest
-	UA_NodeId_copy(&client->authenticationToken, &request->requestHeader.authenticationToken);
-    synchronousRequest(request, &UA_TYPES[UA_TYPES_BROWSEREQUEST], response,
+UA_AddReferencesResponse UA_Client_addReferences(UA_Client *client, UA_AddReferencesRequest *request) {
+    UA_AddReferencesResponse response;
+    synchronousRequest(request, &UA_TYPES[UA_TYPES_BROWSEREQUEST], &response,
                        &UA_TYPES[UA_TYPES_BROWSERESPONSE], client);
-    return UA_STATUSCODE_GOOD;
+    return response;
 }
 
-UA_StatusCode UA_Client_deleteNodes(UA_Client *client, UA_DeleteNodesRequest *request, UA_DeleteNodesResponse* response) {
-	//todo: probably move to synchronousRequest
-	UA_NodeId_copy(&client->authenticationToken, &request->requestHeader.authenticationToken);
+UA_DeleteNodesResponse UA_Client_deleteNodes(UA_Client *client, UA_DeleteNodesRequest *request) {
+    UA_DeleteNodesResponse response;
     synchronousRequest(request, &UA_TYPES[UA_TYPES_BROWSEREQUEST], &response,
                        &UA_TYPES[UA_TYPES_BROWSERESPONSE], client);
-    return UA_STATUSCODE_GOOD;
+    return response;
 }
 
-UA_StatusCode UA_Client_deleteReferences(UA_Client *client, UA_DeleteReferencesRequest *request, UA_DeleteReferencesResponse* response) {
-	//todo: probably move to synchronousRequest
-	UA_NodeId_copy(&client->authenticationToken, &request->requestHeader.authenticationToken);
-    synchronousRequest(request, &UA_TYPES[UA_TYPES_BROWSEREQUEST], response,
+UA_DeleteReferencesResponse UA_EXPORT
+UA_Client_deleteReferences(UA_Client *client, UA_DeleteReferencesRequest *request) {
+    UA_DeleteReferencesResponse response;
+    synchronousRequest(request, &UA_TYPES[UA_TYPES_BROWSEREQUEST], &response,
                        &UA_TYPES[UA_TYPES_BROWSERESPONSE], client);
-    return UA_STATUSCODE_GOOD;
+    return response;;
 }

src/server/ua_server.c

@@ -105,10 +105,10 @@ static UA_StatusCode readStatus(const void *handle, UA_Boolean sourceTimeStamp,
     status->secondsTillShutdown = 0;
     value->value.type = &UA_TYPES[UA_TYPES_SERVERSTATUSDATATYPE];
 	value->value.arrayLength = -1;
-    value->value.dataPtr = status;
+    value->value.data = status;
     value->value.arrayDimensionsSize = -1;
     value->value.arrayDimensions = UA_NULL;
-    value->hasVariant = UA_TRUE;
+    value->hasValue = UA_TRUE;
     if(sourceTimeStamp) {
         value->hasSourceTimestamp = UA_TRUE;
         value->sourceTimestamp = UA_DateTime_now();
@@ -127,10 +127,10 @@ static UA_StatusCode readCurrentTime(const void *handle, UA_Boolean sourceTimeSt
 	*currentTime = UA_DateTime_now();
 	value->value.type = &UA_TYPES[UA_TYPES_DATETIME];
 	value->value.arrayLength = -1;
-	value->value.dataPtr = currentTime;
+	value->value.data = currentTime;
 	value->value.arrayDimensionsSize = -1;
 	value->value.arrayDimensions = NULL;
-	value->hasVariant = UA_TRUE;
+	value->hasValue = UA_TRUE;
 	if(sourceTimeStamp) {
 		value->hasSourceTimestamp = UA_TRUE;
 		value->sourceTimestamp = *currentTime;
@@ -139,7 +139,7 @@ static UA_StatusCode readCurrentTime(const void *handle, UA_Boolean sourceTimeSt
 }
 
 static void releaseCurrentTime(const void *handle, UA_DataValue *value) {
-	UA_DateTime_delete((UA_DateTime*)value->value.dataPtr);
+	UA_DateTime_delete((UA_DateTime*)value->value.data);
 }
 
 static void copyNames(UA_Node *node, char *name) {
@@ -622,14 +622,14 @@ UA_Server * UA_Server_new(void) {
    copyNames((UA_Node*)namespaceArray, "NamespaceArray");
    namespaceArray->nodeId.identifier.numeric = UA_NS0ID_SERVER_NAMESPACEARRAY;
    namespaceArray->variableType = UA_VARIABLENODETYPE_VARIANT;
-   namespaceArray->variable.variant.dataPtr = UA_Array_new(&UA_TYPES[UA_TYPES_STRING], 2);
+   namespaceArray->variable.variant.data = UA_Array_new(&UA_TYPES[UA_TYPES_STRING], 2);
    namespaceArray->variable.variant.arrayLength = 2;
    namespaceArray->variable.variant.type = &UA_TYPES[UA_TYPES_STRING];
    // Fixme: Insert the external namespaces
    UA_String_copycstring("http://opcfoundation.org/UA/",
-		   &((UA_String *)(namespaceArray->variable.variant.dataPtr))[0]);
+		   &((UA_String *)(namespaceArray->variable.variant.data))[0]);
    UA_String_copycstring(APPLICATION_URI,
-		   &((UA_String *)(namespaceArray->variable.variant.dataPtr))[1]);
+		   &((UA_String *)(namespaceArray->variable.variant.data))[1]);
    namespaceArray->valueRank = 1;
    namespaceArray->minimumSamplingInterval = 1.0;
    namespaceArray->historizing = UA_FALSE;
@@ -644,11 +644,11 @@ UA_Server * UA_Server_new(void) {
    copyNames((UA_Node*)serverArray, "ServerArray");
    serverArray->nodeId.identifier.numeric = UA_NS0ID_SERVER_SERVERARRAY;
    serverArray->variableType = UA_VARIABLENODETYPE_VARIANT;
-   serverArray->variable.variant.dataPtr = UA_Array_new(&UA_TYPES[UA_TYPES_STRING], 1);
+   serverArray->variable.variant.data = UA_Array_new(&UA_TYPES[UA_TYPES_STRING], 1);
    serverArray->variable.variant.arrayLength = 1;
    serverArray->variable.variant.type = &UA_TYPES[UA_TYPES_STRING];
    UA_String_copycstring(APPLICATION_URI,
- 		   &((UA_String *)(serverArray->variable.variant.dataPtr))[0]);
+ 		   &((UA_String *)(serverArray->variable.variant.data))[0]);
    serverArray->valueRank = 1;
    serverArray->minimumSamplingInterval = 1.0;
    serverArray->historizing = UA_FALSE;
@@ -670,13 +670,13 @@ UA_Server * UA_Server_new(void) {
    copyNames((UA_Node*)localeIdArray, "LocaleIdArray");
    localeIdArray->nodeId.identifier.numeric = UA_NS0ID_SERVER_SERVERCAPABILITIES_LOCALEIDARRAY;
    localeIdArray->variableType = UA_VARIABLENODETYPE_VARIANT;
-   localeIdArray->variable.variant.dataPtr = UA_Array_new(&UA_TYPES[UA_TYPES_STRING], 2);
+   localeIdArray->variable.variant.data = UA_Array_new(&UA_TYPES[UA_TYPES_STRING], 2);
    localeIdArray->variable.variant.arrayLength = 2;
    localeIdArray->variable.variant.type = &UA_TYPES[UA_TYPES_STRING];
    UA_String_copycstring("en",
-		   &((UA_String *)(localeIdArray->variable.variant.dataPtr))[0]);
+		   &((UA_String *)(localeIdArray->variable.variant.data))[0]);
    UA_String_copycstring("de",
-		   &((UA_String *)(localeIdArray->variable.variant.dataPtr))[1]);
+		   &((UA_String *)(localeIdArray->variable.variant.data))[1]);
    localeIdArray->valueRank = 1;
    localeIdArray->minimumSamplingInterval = 1.0;
    localeIdArray->historizing = UA_FALSE;
@@ -703,7 +703,7 @@ UA_Server * UA_Server_new(void) {
    state->variableType = UA_VARIABLENODETYPE_VARIANT;
    state->variable.variant.type = &UA_TYPES[UA_TYPES_SERVERSTATE];
    state->variable.variant.arrayLength = -1;
-   state->variable.variant.dataPtr = stateEnum; // points into the other object.
+   state->variable.variant.data = stateEnum; // points into the other object.
    UA_NodeStore_insert(server->nodestore, (UA_Node*)state, UA_NULL);
    ADDREFERENCE(UA_NODEID_STATIC(0, UA_NS0ID_SERVER_SERVERSTATUS), UA_NODEID_STATIC(0, UA_NS0ID_HASCOMPONENT),
 		   UA_EXPANDEDNODEID_STATIC(0, UA_NS0ID_SERVER_SERVERSTATUS_STATE));

src/server/ua_services_attribute.c

@@ -119,62 +119,62 @@ static void readValue(UA_Server *server, UA_TimestampsToReturn timestamps,
     UA_StatusCode retval = UA_STATUSCODE_GOOD;
     switch(id->attributeId) {
     case UA_ATTRIBUTEID_NODEID:
-        v->hasVariant = UA_TRUE;
+        v->hasValue = UA_TRUE;
         retval |= UA_Variant_setScalarCopy(&v->value, &node->nodeId, &UA_TYPES[UA_TYPES_NODEID]);
         break;
     case UA_ATTRIBUTEID_NODECLASS:
-        v->hasVariant = UA_TRUE;
+        v->hasValue = UA_TRUE;
         retval |= UA_Variant_setScalarCopy(&v->value, &node->nodeClass, &UA_TYPES[UA_TYPES_INT32]);
         break;
     case UA_ATTRIBUTEID_BROWSENAME:
-        v->hasVariant = UA_TRUE;
+        v->hasValue = UA_TRUE;
         retval |= UA_Variant_setScalarCopy(&v->value, &node->browseName, &UA_TYPES[UA_TYPES_QUALIFIEDNAME]);
         break;
     case UA_ATTRIBUTEID_DISPLAYNAME:
         retval |= UA_Variant_setScalarCopy(&v->value, &node->displayName, &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]);
         if(retval == UA_STATUSCODE_GOOD)
-            v->hasVariant = UA_TRUE;
+            v->hasValue = UA_TRUE;
         break;
     case UA_ATTRIBUTEID_DESCRIPTION:
-        v->hasVariant = UA_TRUE;
+        v->hasValue = UA_TRUE;
         retval |= UA_Variant_setScalarCopy(&v->value, &node->description, &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]);
         break;
     case UA_ATTRIBUTEID_WRITEMASK:
-        v->hasVariant = UA_TRUE;
+        v->hasValue = UA_TRUE;
         retval |= UA_Variant_setScalarCopy(&v->value, &node->writeMask, &UA_TYPES[UA_TYPES_UINT32]);
         break;
     case UA_ATTRIBUTEID_USERWRITEMASK:
-        v->hasVariant = UA_TRUE;
+        v->hasValue = UA_TRUE;
         retval |= UA_Variant_setScalarCopy(&v->value, &node->userWriteMask, &UA_TYPES[UA_TYPES_UINT32]);
         break;
     case UA_ATTRIBUTEID_ISABSTRACT:
         CHECK_NODECLASS(UA_NODECLASS_REFERENCETYPE | UA_NODECLASS_OBJECTTYPE | UA_NODECLASS_VARIABLETYPE |
                         UA_NODECLASS_DATATYPE);
-        v->hasVariant = UA_TRUE;
+        v->hasValue = UA_TRUE;
         retval |= UA_Variant_setScalarCopy(&v->value, &((const UA_ReferenceTypeNode *)node)->isAbstract,
                                           &UA_TYPES[UA_TYPES_BOOLEAN]);
         break;
     case UA_ATTRIBUTEID_SYMMETRIC:
         CHECK_NODECLASS(UA_NODECLASS_REFERENCETYPE);
-        v->hasVariant = UA_TRUE;
+        v->hasValue = UA_TRUE;
         retval |= UA_Variant_setScalarCopy(&v->value, &((const UA_ReferenceTypeNode *)node)->symmetric,
                                           &UA_TYPES[UA_TYPES_BOOLEAN]);
         break;
     case UA_ATTRIBUTEID_INVERSENAME:
         CHECK_NODECLASS(UA_NODECLASS_REFERENCETYPE);
-        v->hasVariant = UA_TRUE;
+        v->hasValue = UA_TRUE;
         retval |= UA_Variant_setScalarCopy(&v->value, &((const UA_ReferenceTypeNode *)node)->inverseName,
                                           &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]);
         break;
     case UA_ATTRIBUTEID_CONTAINSNOLOOPS:
         CHECK_NODECLASS(UA_NODECLASS_VIEW);
-        v->hasVariant = UA_TRUE;
+        v->hasValue = UA_TRUE;
         retval |= UA_Variant_setScalarCopy(&v->value, &((const UA_ViewNode *)node)->containsNoLoops,
                                           &UA_TYPES[UA_TYPES_BOOLEAN]);
         break;
     case UA_ATTRIBUTEID_EVENTNOTIFIER:
         CHECK_NODECLASS(UA_NODECLASS_VIEW | UA_NODECLASS_OBJECT);
-        v->hasVariant = UA_TRUE;
+        v->hasValue = UA_TRUE;
         if(node->nodeClass == UA_NODECLASS_VIEW){
         	retval |= UA_Variant_setScalarCopy(&v->value, &((const UA_ViewNode *)node)->eventNotifier,
                                           	  &UA_TYPES[UA_TYPES_BYTE]);
@@ -188,7 +188,7 @@ static void readValue(UA_Server *server, UA_TimestampsToReturn timestamps,
         CHECK_NODECLASS(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
         {
         	if(node->nodeClass != UA_NODECLASS_VARIABLE) {
-    			v->hasVariant = UA_FALSE;
+    			v->hasValue = UA_FALSE;
     			handleSourceTimestamps(timestamps, v);
             }
 
@@ -209,7 +209,7 @@ static void readValue(UA_Server *server, UA_TimestampsToReturn timestamps,
                 else
                     retval |= UA_Variant_copy(&vn->variable.variant, &v->value);
                 if(retval == UA_STATUSCODE_GOOD) {
-                    v->hasVariant = UA_TRUE;
+                    v->hasValue = UA_TRUE;
                     handleSourceTimestamps(timestamps, v);
                 }
             } else {
@@ -231,7 +231,7 @@ static void readValue(UA_Server *server, UA_TimestampsToReturn timestamps,
 
     case UA_ATTRIBUTEID_DATATYPE:
 		CHECK_NODECLASS(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
-		v->hasVariant = UA_TRUE;
+		v->hasValue = UA_TRUE;
 		if(node->nodeClass == UA_NODECLASS_VARIABLETYPE){
 			retval |= UA_Variant_setScalarCopy(&v->value,
 											  &((const UA_VariableTypeNode *)node)->value.type->typeId,
@@ -258,7 +258,7 @@ static void readValue(UA_Server *server, UA_TimestampsToReturn timestamps,
 
     case UA_ATTRIBUTEID_VALUERANK:
         CHECK_NODECLASS(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
-        v->hasVariant = UA_TRUE;
+        v->hasValue = UA_TRUE;
         retval |= UA_Variant_setScalarCopy(&v->value, &((const UA_VariableTypeNode *)node)->valueRank,
                                           &UA_TYPES[UA_TYPES_INT32]);
         break;
@@ -276,14 +276,14 @@ static void readValue(UA_Server *server, UA_TimestampsToReturn timestamps,
                                                  vn->variable.variant.arrayDimensionsSize,
                                                  &UA_TYPES[UA_TYPES_INT32]);
                 if(retval == UA_STATUSCODE_GOOD)
-                    v->hasVariant = UA_TRUE;
+                    v->hasValue = UA_TRUE;
             } else {
                 UA_DataValue val;
                 UA_DataValue_init(&val);
                 retval |= vn->variable.dataSource.read(vn->variable.dataSource.handle, UA_FALSE, &val);
                 if(retval != UA_STATUSCODE_GOOD)
                     break;
-                if(!val.hasVariant)
+                if(!val.hasValue)
                     retval = UA_STATUSCODE_BADNOTREADABLE;
                 else
                     retval = UA_Variant_setArrayCopy(&v->value, val.value.arrayDimensions,
@@ -295,42 +295,42 @@ static void readValue(UA_Server *server, UA_TimestampsToReturn timestamps,
 
     case UA_ATTRIBUTEID_ACCESSLEVEL:
         CHECK_NODECLASS(UA_NODECLASS_VARIABLE);
-        v->hasVariant = UA_TRUE;
+        v->hasValue = UA_TRUE;
         retval |= UA_Variant_setScalarCopy(&v->value, &((const UA_VariableNode *)node)->accessLevel,
                                           &UA_TYPES[UA_TYPES_BYTE]);
         break;
 
     case UA_ATTRIBUTEID_USERACCESSLEVEL:
         CHECK_NODECLASS(UA_NODECLASS_VARIABLE);
-        v->hasVariant = UA_TRUE;
+        v->hasValue = UA_TRUE;
         retval |= UA_Variant_setScalarCopy(&v->value, &((const UA_VariableNode *)node)->userAccessLevel,
                                           &UA_TYPES[UA_TYPES_BYTE]);
         break;
 
     case UA_ATTRIBUTEID_MINIMUMSAMPLINGINTERVAL:
         CHECK_NODECLASS(UA_NODECLASS_VARIABLE);
-        v->hasVariant = UA_TRUE;
+        v->hasValue = UA_TRUE;
         retval |= UA_Variant_setScalarCopy(&v->value, &((const UA_VariableNode *)node)->minimumSamplingInterval,
                                           &UA_TYPES[UA_TYPES_DOUBLE]);
         break;
 
     case UA_ATTRIBUTEID_HISTORIZING:
         CHECK_NODECLASS(UA_NODECLASS_VARIABLE);
-        v->hasVariant = UA_TRUE;
+        v->hasValue = UA_TRUE;
         retval |= UA_Variant_setScalarCopy(&v->value, &((const UA_VariableNode *)node)->historizing,
                                           &UA_TYPES[UA_TYPES_BOOLEAN]);
         break;
 
     case UA_ATTRIBUTEID_EXECUTABLE:
         CHECK_NODECLASS(UA_NODECLASS_METHOD);
-        v->hasVariant = UA_TRUE;
+        v->hasValue = UA_TRUE;
         retval |= UA_Variant_setScalarCopy(&v->value, &((const UA_MethodNode *)node)->executable,
                                           &UA_TYPES[UA_TYPES_BOOLEAN]);
         break;
 
     case UA_ATTRIBUTEID_USEREXECUTABLE:
         CHECK_NODECLASS(UA_NODECLASS_METHOD);
-        v->hasVariant = UA_TRUE;
+        v->hasValue = UA_TRUE;
         retval |= UA_Variant_setScalarCopy(&v->value, &((const UA_MethodNode *)node)->userExecutable,
                                           &UA_TYPES[UA_TYPES_BOOLEAN]);
         break;
@@ -418,7 +418,7 @@ void Service_Read(UA_Server *server, UA_Session *session, const UA_ReadRequest *
 
 		UA_DateTime* expireArray = UA_NULL;
 		expireArray = UA_Array_new(&UA_TYPES[UA_TYPES_DATETIME], request->nodesToReadSize);
-		variant.dataPtr = expireArray;
+		variant.data = expireArray;
 
 		UA_ByteString str;
 		UA_ByteString_init(&str);
@@ -477,7 +477,7 @@ static UA_StatusCode writeValue(UA_Server *server, UA_WriteValue *wvalue) {
 
                 // array sizes are not compared
 
-                if(!wvalue->value.hasVariant) {
+                if(!wvalue->value.hasValue) {
                     retval = UA_STATUSCODE_BADTYPEMISMATCH;
                     break;
                 }
@@ -488,13 +488,13 @@ static UA_StatusCode writeValue(UA_Server *server, UA_WriteValue *wvalue) {
                         // an enum was sent as an int32, or an opaque type as a bytestring
                         wvalue->value.value.type = vn->variable.variant.type;
                     else if(vn->variable.variant.type == &UA_TYPES[UA_TYPES_BYTE] &&
-                            (!vn->variable.variant.dataPtr || vn->variable.variant.arrayLength > -1) /* isArray */ &&
+                            (!vn->variable.variant.data || vn->variable.variant.arrayLength > -1) /* isArray */ &&
                             wvalue->value.value.type == &UA_TYPES[UA_TYPES_BYTESTRING] &&
-                            wvalue->value.value.dataPtr && wvalue->value.value.arrayLength == -1 /* isScalar */) {
+                            wvalue->value.value.data && wvalue->value.value.arrayLength == -1 /* isScalar */) {
                         // a string is written to a byte array
-                        UA_ByteString *str = (UA_ByteString*) wvalue->value.value.dataPtr;
+                        UA_ByteString *str = (UA_ByteString*) wvalue->value.value.data;
                         wvalue->value.value.arrayLength = str->length;
-                        wvalue->value.value.dataPtr = str->data;
+                        wvalue->value.value.data = str->data;
                         wvalue->value.value.type = &UA_TYPES[UA_TYPES_BYTE];
                         UA_free(str);
                     } else {
@@ -525,7 +525,7 @@ static UA_StatusCode writeValue(UA_Server *server, UA_WriteValue *wvalue) {
                     UA_VariableNode_delete(newVn);
             } else if(node->nodeClass == UA_NODECLASS_VARIABLETYPE) {
                 const UA_VariableTypeNode *vtn = (const UA_VariableTypeNode*)node;
-                if(!wvalue->value.hasVariant) {
+                if(!wvalue->value.hasValue) {
                     retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
                     break;
                 }

src/ua_types.c

@@ -550,7 +550,7 @@ UA_TYPE_NEW_DEFAULT(UA_Variant)
 void UA_Variant_init(UA_Variant *p) {
     p->storageType = UA_VARIANT_DATA;
     p->arrayLength = -1;
-    p->dataPtr = UA_NULL;
+    p->data = UA_NULL;
     p->arrayDimensions = UA_NULL;
     p->arrayDimensionsSize = -1;
     p->type = &UA_TYPES[UA_TYPES_BOOLEAN];
@@ -559,11 +559,11 @@ void UA_Variant_init(UA_Variant *p) {
 UA_TYPE_DELETE_DEFAULT(UA_Variant)
 void UA_Variant_deleteMembers(UA_Variant *p) {
     if(p->storageType == UA_VARIANT_DATA) {
-        if(p->dataPtr) {
+        if(p->data) {
             if(p->arrayLength == -1)
                 p->arrayLength = 1;
-            UA_Array_delete(p->dataPtr, p->type, p->arrayLength);
-            p->dataPtr = UA_NULL;
+            UA_Array_delete(p->data, p->type, p->arrayLength);
+            p->data = UA_NULL;
             p->arrayLength = -1;
         }
         if(p->arrayDimensions) {
@@ -576,9 +576,9 @@ void UA_Variant_deleteMembers(UA_Variant *p) {
 UA_StatusCode UA_Variant_copy(UA_Variant const *src, UA_Variant *dst) {
     UA_Variant_init(dst);
     UA_Int32 tmp = src->arrayLength;
-    if(src->arrayLength == -1 && src->dataPtr)
+    if(src->arrayLength == -1 && src->data)
         tmp = 1;
-    UA_StatusCode retval = UA_Array_copy(src->dataPtr, &dst->dataPtr, src->type, tmp);
+    UA_StatusCode retval = UA_Array_copy(src->data, &dst->data, src->type, tmp);
     if(retval != UA_STATUSCODE_GOOD) {
         UA_Variant_deleteMembers(dst);
         UA_Variant_init(dst);
@@ -629,14 +629,14 @@ UA_StatusCode UA_Variant_copyRange(const UA_Variant *src, UA_Variant *dst, const
         count *= (range.dimensions[i].max - range.dimensions[i].min) + 1;
     }
 
-    dst->dataPtr = UA_malloc(src->type->memSize * count);
-    if(!dst->dataPtr)
+    dst->data = UA_malloc(src->type->memSize * count);
+    if(!dst->data)
         return UA_STATUSCODE_BADOUTOFMEMORY;
     
     // copy a subset of the tensor with as few calls as possible.
     // shift from copying single elements to contiguous blocks
     size_t elem_size = src->type->memSize;
-    uintptr_t nextsrc = (uintptr_t)src->dataPtr; // the start ptr of the next copy operation
+    uintptr_t nextsrc = (uintptr_t)src->data; // the start ptr of the next copy operation
     size_t contiguous_elems = src->arrayLength; // the length of the copy operation
     ptrdiff_t jump_length = elem_size * dims[0]; // how far to jump until the next contiguous copy
     size_t copy_count = count; // how often to copy
@@ -658,7 +658,7 @@ UA_StatusCode UA_Variant_copyRange(const UA_Variant *src, UA_Variant *dst, const
     }
 
     UA_StatusCode retval = UA_STATUSCODE_GOOD;
-    uintptr_t nextdst = (uintptr_t)dst->dataPtr;
+    uintptr_t nextdst = (uintptr_t)dst->data;
     size_t copied = 0;
     for(size_t i = 0; i < copy_count; i++) {
         if(src->type->fixedSize) {
@@ -668,7 +668,7 @@ UA_StatusCode UA_Variant_copyRange(const UA_Variant *src, UA_Variant *dst, const
                 retval = UA_copy((const void*)(nextsrc + (j * elem_size)), (void*)(nextdst + (j * elem_size)),
                                  src->type);
             if(retval != UA_STATUSCODE_GOOD) {
-                UA_Array_delete(dst->dataPtr, src->type, copied);
+                UA_Array_delete(dst->data, src->type, copied);
                 return retval;
             }
             copied += contiguous_elems;
@@ -680,7 +680,7 @@ UA_StatusCode UA_Variant_copyRange(const UA_Variant *src, UA_Variant *dst, const
     if(src->arrayDimensionsSize > 0) {
         retval = UA_Array_copy(dims, (void**)&dst->arrayDimensions, &UA_TYPES[UA_TYPES_INT32], dims_count);
         if(retval != UA_STATUSCODE_GOOD) {
-            UA_Array_delete(dst->dataPtr, src->type, copied);
+            UA_Array_delete(dst->data, src->type, copied);
             return retval;
         }
         for(UA_Int32 k = 0; k < dims_count; k++)
@@ -713,7 +713,7 @@ UA_StatusCode UA_Variant_setArray(UA_Variant *v, void *array, UA_Int32 noElement
                                   const UA_DataType *type) {
     v->type = type;
     v->arrayLength = noElements;
-    v->dataPtr = array;
+    v->data = array;
     return UA_STATUSCODE_GOOD;
 }
 

src/ua_types_encoding_binary.c

@@ -602,7 +602,7 @@ UA_StatusCode UA_ExtensionObject_decodeBinary(UA_ByteString const *src, size_t *
 /* DataValue */
 size_t UA_DataValue_calcSizeBinary(UA_DataValue const *p) {
     size_t length = sizeof(UA_Byte);
-    if(p->hasVariant)
+    if(p->hasValue)
         length += UA_Variant_calcSizeBinary(&p->value);
     if(p->hasStatus)
         length += sizeof(UA_UInt32);
@@ -619,7 +619,7 @@ size_t UA_DataValue_calcSizeBinary(UA_DataValue const *p) {
 
 UA_StatusCode UA_DataValue_encodeBinary(UA_DataValue const *src, UA_ByteString *dst, size_t *offset) {
     UA_StatusCode retval = UA_Byte_encodeBinary((const UA_Byte*)src, dst, offset);
-    if(src->hasVariant)
+    if(src->hasValue)
         retval |= UA_Variant_encodeBinary(&src->value, dst, offset);
     if(src->hasStatus)
         retval |= UA_StatusCode_encodeBinary(&src->status, dst, offset);
@@ -640,7 +640,7 @@ UA_StatusCode UA_DataValue_decodeBinary(UA_ByteString const *src, size_t *offset
     UA_StatusCode retval = UA_Byte_decodeBinary(src, offset, (UA_Byte*)dst);
     if(retval != UA_STATUSCODE_GOOD)
         return retval;
-    if(dst->hasVariant)
+    if(dst->hasValue)
         retval |= UA_Variant_decodeBinary(src, offset, &dst->value);
     if(dst->hasStatus)
         retval |= UA_StatusCode_decodeBinary(src, offset, &dst->status);
@@ -678,17 +678,17 @@ enum UA_VARIANT_ENCODINGMASKTYPE_enum {
 };
 
 size_t UA_Variant_calcSizeBinary(UA_Variant const *p) {
-    UA_Boolean isArray = p->arrayLength != -1 || !p->dataPtr;  // a single element is not an array
+    UA_Boolean isArray = p->arrayLength != -1 || !p->data;  // a single element is not an array
     UA_Boolean hasDimensions = isArray && p->arrayDimensions != UA_NULL;
     UA_Boolean isBuiltin = p->type->namespaceZero && UA_IS_BUILTIN(p->type->typeIndex);
     size_t length = sizeof(UA_Byte); //p->encodingMask
     UA_Int32 arrayLength = p->arrayLength;
     if(!isArray) {
     	arrayLength = 1;
-        length += UA_calcSizeBinary(p->dataPtr, p->type);
+        length += UA_calcSizeBinary(p->data, p->type);
     }
     else
-        length += UA_Array_calcSizeBinary(p->dataPtr, arrayLength, p->type);
+        length += UA_Array_calcSizeBinary(p->data, arrayLength, p->type);
         
     // if the type is not builtin, we encode it as an extensionobject
     if(!isBuiltin) {
@@ -704,7 +704,7 @@ size_t UA_Variant_calcSizeBinary(UA_Variant const *p) {
 
 UA_StatusCode UA_Variant_encodeBinary(UA_Variant const *src, UA_ByteString *dst, size_t *offset) {
     UA_Byte encodingByte = 0;
-    UA_Boolean isArray = src->arrayLength != -1 || !src->dataPtr;  // a single element is not an array
+    UA_Boolean isArray = src->arrayLength != -1 || !src->data;  // a single element is not an array
     UA_Boolean hasDimensions = isArray && src->arrayDimensions != UA_NULL;
     UA_Boolean isBuiltin = src->type->namespaceZero && UA_IS_BUILTIN(src->type->typeIndex);
 
@@ -724,7 +724,7 @@ UA_StatusCode UA_Variant_encodeBinary(UA_Variant const *src, UA_ByteString *dst,
 
     if(isArray)
         retval |= UA_Int32_encodeBinary(&src->arrayLength, dst, offset);
-    uintptr_t ptr = (uintptr_t)src->dataPtr;
+    uintptr_t ptr = (uintptr_t)src->data;
     ptrdiff_t memSize = src->type->memSize;
     UA_Int32 numToEncode = src->arrayLength;
     if(!isArray)
@@ -736,7 +736,7 @@ UA_StatusCode UA_Variant_encodeBinary(UA_Variant const *src, UA_ByteString *dst,
             retval |= UA_NodeId_encodeBinary_nodeid_offset(&src->type->typeId, dst, offset, UA_ENCODINGOFFSET_BINARY);
             UA_Byte eoEncoding = UA_EXTENSIONOBJECT_ENCODINGMASK_BODYISBYTESTRING;
             retval |= UA_Byte_encodeBinary(&eoEncoding, dst, offset);
-            UA_Int32 eoEncodingLength = UA_calcSizeBinary(src->dataPtr, src->type);
+            UA_Int32 eoEncodingLength = UA_calcSizeBinary(src->data, src->type);
             retval |= UA_Int32_encodeBinary(&eoEncodingLength, dst, offset);
         }
         retval |= UA_encodeBinary((void*)ptr, src->type, dst, offset);
@@ -770,7 +770,7 @@ UA_StatusCode UA_Variant_decodeBinary(UA_ByteString const *src, size_t *offset,
             if(retval != UA_STATUSCODE_GOOD)
                 return retval;
         }
-        retval |= UA_Array_decodeBinary(src, offset, (!isArray && arraySize==-1) ? 1: arraySize, &dst->dataPtr, dataType);
+        retval |= UA_Array_decodeBinary(src, offset, (!isArray && arraySize==-1) ? 1: arraySize, &dst->data, dataType);
         if(retval != UA_STATUSCODE_GOOD)
             return retval;
         dst->arrayLength = arraySize; // for deleteMembers
@@ -800,7 +800,7 @@ UA_StatusCode UA_Variant_decodeBinary(UA_ByteString const *src, size_t *offset,
             *offset = oldoffset;
             dataType = &UA_TYPES[UA_TYPES_EXTENSIONOBJECT];
         }
-        if((retval |= UA_decodeBinary(src, offset, dst->dataPtr, dataType)) != UA_STATUSCODE_GOOD)
+        if((retval |= UA_decodeBinary(src, offset, dst->data, dataType)) != UA_STATUSCODE_GOOD)
             return retval;
         dst->type = dataType;
         dst->arrayLength = -1;
@@ -811,7 +811,7 @@ UA_StatusCode UA_Variant_decodeBinary(UA_ByteString const *src, size_t *offset,
         retval |= UA_Int32_decodeBinary(src, offset, &dst->arrayDimensionsSize);
         if(retval == UA_STATUSCODE_GOOD)
             retval |= UA_Array_decodeBinary(src, offset, dst->arrayDimensionsSize,
-                                            &dst->dataPtr, &UA_TYPES[UA_TYPES_INT32]);
+                                            &dst->data, &UA_TYPES[UA_TYPES_INT32]);
         if(retval != UA_STATUSCODE_GOOD) {
             dst->arrayDimensionsSize = -1;
             UA_Variant_deleteMembers(dst);

tests/check_builtin.c

@@ -280,7 +280,7 @@ START_TEST(UA_Variant_calcSizeFixedSizeArrayShallReturnEncodingSize) {
 #define ARRAY_LEN 8
 	arg.arrayLength = ARRAY_LEN;
 	UA_Int32 *data[ARRAY_LEN];
-	arg.dataPtr = (void *)data;
+	arg.data = (void *)data;
 
 	// when
 	UA_UInt32 encodingSize = UA_Variant_calcSizeBinary(&arg);
@@ -302,7 +302,7 @@ START_TEST(UA_Variant_calcSizeVariableSizeArrayShallReturnEncodingSize) {
 	strings[0] = (UA_String) {-1, UA_NULL };
 	strings[1] = (UA_String) {3, (UA_Byte *)"PLT" };
 	strings[2] = (UA_String) {47, UA_NULL };
-	arg.dataPtr   = (void *)strings;
+	arg.data   = (void *)strings;
 	// when
 	UA_UInt32 encodingSize = UA_Variant_calcSizeBinary(&arg);
 	// then
@@ -698,7 +698,7 @@ START_TEST(UA_Variant_decodeWithOutArrayFlagSetShallSetVTAndAllocateMemoryForArr
 	//ck_assert_ptr_eq((const void *)dst.type, (const void *)&UA_TYPES[UA_TYPES_INT32]); //does not compile in gcc 4.6
     ck_assert_int_eq((uintptr_t)dst.type, (uintptr_t)&UA_TYPES[UA_TYPES_INT32]); 
 	ck_assert_int_eq(dst.arrayLength, -1);
-	ck_assert_int_eq(*(UA_Int32 *)dst.dataPtr, 255);
+	ck_assert_int_eq(*(UA_Int32 *)dst.data, 255);
 	// finally
 	UA_Variant_deleteMembers(&dst);
 }
@@ -720,8 +720,8 @@ START_TEST(UA_Variant_decodeWithArrayFlagSetShallSetVTAndAllocateMemoryForArray)
 	//ck_assert_ptr_eq((const (void*))dst.type, (const void*)&UA_TYPES[UA_TYPES_INT32]); //does not compile in gcc 4.6
     ck_assert_int_eq((uintptr_t)dst.type,(uintptr_t)&UA_TYPES[UA_TYPES_INT32]);
 	ck_assert_int_eq(dst.arrayLength, 2);
-	ck_assert_int_eq(((UA_Int32 *)dst.dataPtr)[0], 255);
-	ck_assert_int_eq(((UA_Int32 *)dst.dataPtr)[1], -1);
+	ck_assert_int_eq(((UA_Int32 *)dst.data)[0], 255);
+	ck_assert_int_eq(((UA_Int32 *)dst.data)[1], -1);
 	// finally
 	UA_Variant_deleteMembers(&dst);
 }
@@ -1148,12 +1148,12 @@ START_TEST(UA_DataValue_encodeShallWorkOnExampleWithVariant) {
 	UA_DataValue src;
     UA_DataValue_init(&src);
 	src.serverTimestamp    = 80;
-    src.hasVariant = UA_TRUE;
+    src.hasValue = UA_TRUE;
     src.hasServerTimestamp = UA_TRUE;
 	src.value.type = &UA_TYPES[UA_TYPES_INT32];
 	src.value.arrayLength  = -1; // one element (encoded as not an array)
 	UA_Int32  vdata  = 45;
-	src.value.dataPtr = (void *)&vdata;
+	src.value.data = (void *)&vdata;
 
 	UA_Byte data[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@@ -1479,8 +1479,8 @@ START_TEST(UA_Variant_copyShallWorkOnSingleValueExample) {
 	UA_Variant value, copiedValue;
 	UA_Variant_init(&value);
 	UA_Variant_init(&copiedValue);
-	value.dataPtr = UA_malloc(sizeof(UA_String));
-	*((UA_String*)value.dataPtr) = testString;
+	value.data = UA_malloc(sizeof(UA_String));
+	*((UA_String*)value.data) = testString;
     value.type = &UA_TYPES[UA_TYPES_STRING];
 	value.arrayLength = 1;
 
@@ -1488,7 +1488,7 @@ START_TEST(UA_Variant_copyShallWorkOnSingleValueExample) {
 	UA_Variant_copy(&value, &copiedValue);
 
 	//then
-	UA_String copiedString = *(UA_String*)(copiedValue.dataPtr);
+	UA_String copiedString = *(UA_String*)(copiedValue.data);
 	for(UA_Int32 i = 0;i < 5;i++)
 		ck_assert_int_eq(copiedString.data[i], testString.data[i]);
 	ck_assert_int_eq(copiedString.length, testString.length);
@@ -1497,7 +1497,7 @@ START_TEST(UA_Variant_copyShallWorkOnSingleValueExample) {
 	ck_assert_int_eq(value.arrayLength, copiedValue.arrayLength);
 
 	//finally
-	((UA_String*)value.dataPtr)->data = UA_NULL; // the string is statically allocated. do not free it.
+	((UA_String*)value.data)->data = UA_NULL; // the string is statically allocated. do not free it.
 	UA_Variant_deleteMembers(&value);
 	UA_Variant_deleteMembers(&copiedValue);
 }
@@ -1519,7 +1519,7 @@ START_TEST(UA_Variant_copyShallWorkOn1DArrayExample) {
 	UA_Variant_init(&copiedValue);
 
 	value.arrayLength = 3;
-	value.dataPtr = (void *)srcArray;
+	value.data = (void *)srcArray;
 	value.arrayDimensionsSize = 1;
 	value.arrayDimensions = dimensions;
 	value.type = &UA_TYPES[UA_TYPES_STRING];
@@ -1534,14 +1534,14 @@ START_TEST(UA_Variant_copyShallWorkOn1DArrayExample) {
 
 	for(UA_Int32 i = 0;i < 3;i++) {
 		for(UA_Int32 j = 0;j < 6;j++) {
-			ck_assert_int_eq(((UA_String *)value.dataPtr)[i].data[j],
-					((UA_String *)copiedValue.dataPtr)[i].data[j]);
+			ck_assert_int_eq(((UA_String *)value.data)[i].data[j],
+					((UA_String *)copiedValue.data)[i].data[j]);
 		}
-		ck_assert_int_eq(((UA_String *)value.dataPtr)[i].length,
-				((UA_String *)copiedValue.dataPtr)[i].length);
+		ck_assert_int_eq(((UA_String *)value.data)[i].length,
+				((UA_String *)copiedValue.data)[i].length);
 	}
-	ck_assert_int_eq(((UA_String *)copiedValue.dataPtr)[0].data[2], 'o');
-	ck_assert_int_eq(((UA_String *)copiedValue.dataPtr)[0].data[3], 'p');
+	ck_assert_int_eq(((UA_String *)copiedValue.data)[0].data[2], 'o');
+	ck_assert_int_eq(((UA_String *)copiedValue.data)[0].data[3], 'p');
 	ck_assert_int_eq(value.arrayDimensionsSize, copiedValue.arrayDimensionsSize);
 	ck_assert_int_eq(value.arrayLength, copiedValue.arrayLength);
 
@@ -1572,7 +1572,7 @@ START_TEST(UA_Variant_copyShallWorkOn2DArrayExample) {
 	UA_Variant_init(&copiedValue);
 
 	value.arrayLength = 6;
-	value.dataPtr     = srcArray;
+	value.data     = srcArray;
 	value.arrayDimensionsSize = 2;
 	value.arrayDimensions     = dimensions;
 	value.type = &UA_TYPES[UA_TYPES_INT32];
@@ -1596,8 +1596,8 @@ START_TEST(UA_Variant_copyShallWorkOn2DArrayExample) {
 
 
 	for(UA_Int32 i = 0;i < 6;i++) {
-		i1 = ((UA_Int32 *)value.dataPtr)[i];
-		i2 = ((UA_Int32 *)copiedValue.dataPtr)[i];
+		i1 = ((UA_Int32 *)value.data)[i];
+		i2 = ((UA_Int32 *)copiedValue.data)[i];
 		ck_assert_int_eq(i1, i2);
 		ck_assert_int_eq(i2, i);
 	}
@@ -1618,7 +1618,7 @@ START_TEST(UA_ExtensionObject_encodeDecodeShallWorkOnExtensionObject) {
 	varAttr.dataType = UA_TYPES[UA_TYPES_INT32].typeId;
 	UA_Variant_init(&varAttr.value);
 	varAttr.value.type = &UA_TYPES[UA_TYPES_INT32];
-	varAttr.value.dataPtr = &val;
+	varAttr.value.data = &val;
 	varAttr.value.arrayLength = -1;
 	varAttr.userWriteMask = 41;
 	varAttr.specifiedAttributes |= UA_NODEATTRIBUTESMASK_DATATYPE;