Merge pull request open62541#4010 from jpfr/merge_10_11

Merge 1.0 to 1.1.

Author: jpfr

CMakeLists.txt

@@ -588,10 +588,13 @@ if(NOT UA_FORCE_CPP AND (CMAKE_COMPILER_IS_GNUCC OR "x${CMAKE_C_COMPILER_ID}" ST
         endif()
     endif()
 
-    if(UA_ENABLE_HARDENING AND ((CMAKE_BUILD_TYPE STREQUAL "Release") OR (CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo")))
-        check_add_cc_flag("-D_FORTIFY_SOURCE=2") # run-time buffer overflow detection (needs at least -O1)
+    if (NOT MINGW)
+        if(UA_ENABLE_HARDENING AND ((CMAKE_BUILD_TYPE STREQUAL "Release") OR (CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo")))
+            check_add_cc_flag("-D_FORTIFY_SOURCE=2") # run-time buffer overflow detection (needs at least -O1)
+        endif()
     endif()
 
+
     # Strip release builds
     if(CMAKE_BUILD_TYPE STREQUAL "MinSizeRel" OR CMAKE_BUILD_TYPE STREQUAL "Release")
         check_add_cc_flag("-ffunction-sections")

include/open62541/plugin/nodestore.h

@@ -207,6 +207,13 @@ typedef struct {
     UA_Byte accessLevel;
     UA_Double minimumSamplingInterval;
     UA_Boolean historizing;
+
+    /* Members specific to open62541 */
+    UA_Boolean isDynamic; /* Some variables are "static" in the sense that they
+                           * are not attached to a dynamic process in the
+                           * background. Only dynamic variables conserve source
+                           * and server timestamp for the value attribute.
+                           * Static variables have timestamps of "now". */
 } UA_VariableNode;
 
 /**

open62541.spec

@@ -1,5 +1,5 @@
 Name:     open62541
-Version:  0.3
+Version:  1.0.1
 Release:  1%{?dist}
 Summary:  OPC UA implementation
 License:  MPLv2.0

src/server/ua_nodes.c

@@ -127,6 +127,7 @@ UA_VariableNode_copy(const UA_VariableNode *src, UA_VariableNode *dst) {
     dst->accessLevel = src->accessLevel;
     dst->minimumSamplingInterval = src->minimumSamplingInterval;
     dst->historizing = src->historizing;
+    dst->isDynamic = src->isDynamic;
     return retval;
 }
 

src/server/ua_server_internal.h

@@ -129,6 +129,8 @@ struct UA_Server {
 
     /* DataChange Subscriptions */
 #ifdef UA_ENABLE_SUBSCRIPTIONS
+    /* Last generated id (to generate server-wide unique ids) */
+    UA_UInt32 lastSubscriptionId;
     /* Num active subscriptions */
     UA_UInt32 numSubscriptions;
     /* Num active monitored items */
@@ -140,7 +142,6 @@ struct UA_Server {
 #ifdef UA_ENABLE_SUBSCRIPTIONS_ALARMS_CONDITIONS
     LIST_HEAD(conditionSourcelisthead, UA_ConditionSource) headConditionSource;
 #endif//UA_ENABLE_SUBSCRIPTIONS_ALARMS_CONDITIONS
-
 #endif
 
     /* Publish/Subscribe */

src/server/ua_services_attribute.c

@@ -180,6 +180,18 @@ readValueAttributeComplete(UA_Server *server, UA_Session *session,
     else
         retval = readValueAttributeFromDataSource(server, session, vn, v, timestamps, rangeptr);
 
+    /* Static Variables and VariableTypes have timestamps of "now". Will be set
+     * below in the absence of predefined timestamps. */
+    if(vn->nodeClass == UA_NODECLASS_VARIABLE) {
+        if(!vn->isDynamic) {
+            v->hasServerTimestamp = false;
+            v->hasSourceTimestamp = false;
+        }
+    } else {
+        v->hasServerTimestamp = false;
+        v->hasSourceTimestamp = false;
+    }
+
     /* Clean up */
     if(rangeptr)
         UA_free(range.dimensions);
@@ -1191,20 +1203,19 @@ writeValueAttribute(UA_Server *server, UA_Session *session,
         }
     }
 
-    /* Ok, do it */
-    if(node->valueSource == UA_VALUESOURCE_DATA) {
-        /* Set the source timestamp if there is none */
-        UA_DateTime now = UA_DateTime_now();
-        if(!adjustedValue.hasSourceTimestamp) {
-            adjustedValue.sourceTimestamp = now;
-            adjustedValue.hasSourceTimestamp = true;
-        }
+    /* Set the source timestamp if there is none */
+    UA_DateTime now = UA_DateTime_now();
+    if(!adjustedValue.hasSourceTimestamp) {
+        adjustedValue.sourceTimestamp = now;
+        adjustedValue.hasSourceTimestamp = true;
+    }
 
-        if(!adjustedValue.hasServerTimestamp) {
-            adjustedValue.serverTimestamp = now;
-            adjustedValue.hasServerTimestamp = true;
-        }
+    /* Update the timestamp when the value was last updated in the server */
+    adjustedValue.serverTimestamp = now;
+    adjustedValue.hasServerTimestamp = true;
 
+    /* Ok, do it */
+    if(node->valueSource == UA_VALUESOURCE_DATA) {
         if(!rangeptr)
             retval = writeValueAttributeWithoutRange(node, &adjustedValue);
         else

src/server/ua_services_nodemanagement.c

@@ -1217,6 +1217,83 @@ recursiveDeleteNode(UA_Server *server, UA_Session *session,
                     UA_ExpandedNodeId *hierarchicalReferences,
                     const UA_Node *node, UA_Boolean removeTargetRefs);
 
+static UA_StatusCode
+setVariableNodeDynamic(UA_Server *server, UA_Session *session,
+                       UA_Node *node, const void *_) {
+    (void)_; /* unused */
+    if(node->nodeClass == UA_NODECLASS_VARIABLE)
+        ((UA_VariableNode*)node)->isDynamic = true;
+    return UA_STATUSCODE_GOOD;
+}
+
+static UA_StatusCode
+checkSetIsDynamicVariable(UA_Server *server, UA_Session *session,
+                          const UA_NodeId *nodeId) {
+    /* Get all hierarchical reference types */
+    UA_ExpandedNodeId *hierarchicalRefs = NULL;
+    size_t hierarchicalRefsSize = 0;
+    UA_NodeId hr = UA_NODEID_NUMERIC(0, UA_NS0ID_HIERARCHICALREFERENCES);
+    browseRecursive(server, 1, &hr, 1, &subtypeId, UA_BROWSEDIRECTION_FORWARD, true,
+                    &hierarchicalRefsSize, &hierarchicalRefs);
+
+    UA_NodeId *hierarchicalRefs2 = (UA_NodeId*)
+        UA_Array_new(hierarchicalRefsSize, &UA_TYPES[UA_TYPES_NODEID]);
+    if(!hierarchicalRefs2) {
+        UA_Array_delete(hierarchicalRefs, hierarchicalRefsSize, &UA_TYPES[UA_TYPES_NODEID]);
+        return UA_STATUSCODE_BADOUTOFMEMORY;
+    }
+
+    for(size_t i = 0; i < hierarchicalRefsSize; i++) {
+        hierarchicalRefs2[i] = hierarchicalRefs[i].nodeId;
+        UA_NodeId_init(&hierarchicalRefs[i].nodeId);
+    }
+    UA_Array_delete(hierarchicalRefs, hierarchicalRefsSize, &UA_TYPES[UA_TYPES_NODEID]);
+
+    /* Is the variable under the server object? */
+    UA_NodeId serverNodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER);
+    if(isNodeInTree(server, nodeId, &serverNodeId,
+                    hierarchicalRefs2, hierarchicalRefsSize)) {
+        UA_Array_delete(hierarchicalRefs2, hierarchicalRefsSize, &UA_TYPES[UA_TYPES_NODEID]);
+        return UA_STATUSCODE_GOOD;
+    }
+
+    /* Is the variable in the type hierarchy? */
+    UA_NodeId typesNodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_TYPESFOLDER);
+    if(isNodeInTree(server, nodeId, &typesNodeId,
+                    hierarchicalRefs2, hierarchicalRefsSize)) {
+        UA_Server_editNode(server, session, nodeId,
+                           (UA_EditNodeCallback)setVariableNodeDynamic, NULL);
+        UA_Array_delete(hierarchicalRefs2, hierarchicalRefsSize, &UA_TYPES[UA_TYPES_NODEID]);
+        return UA_STATUSCODE_GOOD;
+    }
+
+    /* Is the variable a property of a method node (InputArguments /
+     * OutputArguments)? */
+    UA_BrowseDescription bd;
+    UA_BrowseDescription_init(&bd);
+    bd.nodeId = *nodeId;
+    bd.browseDirection = UA_BROWSEDIRECTION_INVERSE;
+    bd.referenceTypeId = UA_NODEID_NUMERIC(0, UA_NS0ID_HASPROPERTY);
+    bd.includeSubtypes = false;
+    bd.nodeClassMask = UA_NODECLASS_METHOD;
+    UA_BrowseResult br;
+    UA_BrowseResult_init(&br);
+    UA_UInt32 maxrefs = 0;
+    Operation_Browse(server, session, &maxrefs, &bd, &br);
+    if(br.referencesSize > 0) {
+        UA_BrowseResult_clear(&br);
+        UA_Array_delete(hierarchicalRefs2, hierarchicalRefsSize, &UA_TYPES[UA_TYPES_NODEID]);
+        return UA_STATUSCODE_GOOD;
+    }
+
+    /* Set the variable to "dynamic" */
+    UA_Server_editNode(server, session, nodeId,
+                       (UA_EditNodeCallback)setVariableNodeDynamic, NULL);
+    
+    UA_Array_delete(hierarchicalRefs2, hierarchicalRefsSize, &UA_TYPES[UA_TYPES_NODEID]);
+    return UA_STATUSCODE_GOOD;
+}
+
 /* Children, references, type-checking, constructors. */
 UA_StatusCode
 AddNode_finish(UA_Server *server, UA_Session *session, const UA_NodeId *nodeId) {
@@ -1250,6 +1327,14 @@ AddNode_finish(UA_Server *server, UA_Session *session, const UA_NodeId *nodeId)
             goto cleanup;
     }
 
+    /* Set variables to dynamic (source and server timestamps are meaningful) if
+     * they fulfill some conditions */
+    if(node->nodeClass == UA_NODECLASS_VARIABLE) {
+        retval = checkSetIsDynamicVariable(server, session, nodeId);
+        if(retval != UA_STATUSCODE_GOOD)
+            goto cleanup;
+    }
+
     /* Call the constructor(s) */
  constructor:
     retval = recursiveCallConstructors(server, session, node, type);

src/server/ua_session.c

@@ -89,7 +89,7 @@ void UA_Session_updateLifetime(UA_Session *session) {
 #ifdef UA_ENABLE_SUBSCRIPTIONS
 
 void UA_Session_addSubscription(UA_Server *server, UA_Session *session, UA_Subscription *newSubscription) {
-    newSubscription->subscriptionId = ++session->lastSubscriptionId;
+    newSubscription->subscriptionId = ++server->lastSubscriptionId;
 
     LIST_INSERT_HEAD(&session->serverSubscriptions, newSubscription, listEntry);
     session->numSubscriptions++;

src/server/ua_session.h

@@ -50,7 +50,6 @@ typedef struct {
     UA_UInt16 availableContinuationPoints;
     ContinuationPoint *continuationPoints;
 #ifdef UA_ENABLE_SUBSCRIPTIONS
-    UA_UInt32 lastSubscriptionId;
     UA_UInt32 lastSeenSubscriptionId;
     LIST_HEAD(UA_ListOfUASubscriptions, UA_Subscription) serverSubscriptions;
     SIMPLEQ_HEAD(UA_ListOfQueuedPublishResponses, UA_PublishResponseEntry) responseQueue;

tests/client/check_client_subscriptions.c

@@ -434,6 +434,157 @@ START_TEST(Client_subscription_createDataChanges) {
 }
 END_TEST
 
+/* An unchanged value shall not be published after a ModifyMonitoredItem */
+START_TEST(Client_subscription_modifyMonitoredItem) {
+    UA_Client *client = UA_Client_new();
+    UA_ClientConfig_setDefault(UA_Client_getConfig(client));
+    UA_StatusCode retval = UA_Client_connect(client, "opc.tcp://localhost:4840");
+    ck_assert_uint_eq(retval, UA_STATUSCODE_GOOD);
+
+    UA_Client_recv = client->connection.recv;
+    client->connection.recv = UA_Client_recvTesting;
+
+    UA_CreateSubscriptionRequest request = UA_CreateSubscriptionRequest_default();
+    UA_CreateSubscriptionResponse response = UA_Client_Subscriptions_create(client, request,
+                                                                            NULL, NULL, NULL);
+    ck_assert_uint_eq(response.responseHeader.serviceResult, UA_STATUSCODE_GOOD);
+    UA_UInt32 subId = response.subscriptionId;
+
+    UA_MonitoredItemCreateRequest items[1];
+    UA_UInt32 newMonitoredItemIds[1];
+    UA_Client_DataChangeNotificationCallback callbacks[1];
+    UA_Client_DeleteMonitoredItemCallback deleteCallbacks[1];
+    void *contexts[1];
+
+    /* Monitor the server state. Does not change during the unit test. */
+    items[0] = UA_MonitoredItemCreateRequest_default(UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERSTATUS_STATE));
+    items[0].requestedParameters.samplingInterval = publishingInterval * 0.2;
+    callbacks[0] = dataChangeHandler;
+    contexts[0] = NULL;
+    deleteCallbacks[0] = NULL;
+
+    UA_CreateMonitoredItemsRequest createRequest;
+    UA_CreateMonitoredItemsRequest_init(&createRequest);
+    createRequest.subscriptionId = subId;
+    createRequest.timestampsToReturn = UA_TIMESTAMPSTORETURN_NEITHER;
+    createRequest.itemsToCreate = items;
+    createRequest.itemsToCreateSize = 1;
+    UA_CreateMonitoredItemsResponse createResponse =
+       UA_Client_MonitoredItems_createDataChanges(client, createRequest, contexts,
+                                                  callbacks, deleteCallbacks);
+
+    ck_assert_uint_eq(createResponse.responseHeader.serviceResult, UA_STATUSCODE_GOOD);
+    ck_assert_uint_eq(createResponse.resultsSize, 1);
+    ck_assert_uint_eq(createResponse.results[0].statusCode, UA_STATUSCODE_GOOD);
+    newMonitoredItemIds[0] = createResponse.results[0].monitoredItemId;
+    UA_CreateMonitoredItemsResponse_deleteMembers(&createResponse);
+
+    UA_fakeSleep((UA_UInt32)publishingInterval + 1);
+
+    /* Receive the initial value */
+    notificationReceived = false;
+    countNotificationReceived = 0;
+    retval = UA_Client_run_iterate(client, (UA_UInt16)(publishingInterval + 1));
+    ck_assert_uint_eq(retval, UA_STATUSCODE_GOOD);
+    ck_assert_uint_eq(notificationReceived, true);
+    ck_assert_uint_eq(countNotificationReceived, 1);
+
+    /* No further update */
+    notificationReceived = false;
+    retval = UA_Client_run_iterate(client, (UA_UInt16)(publishingInterval + 1));
+    ck_assert_uint_eq(retval, UA_STATUSCODE_GOOD);
+    ck_assert_uint_eq(notificationReceived, false);
+    ck_assert_uint_eq(countNotificationReceived, 1);
+
+    /* Modify the MonitoredItem and change the sampling interval */
+    UA_MonitoredItemModifyRequest modify1;
+    UA_MonitoredItemModifyRequest_init(&modify1);
+    modify1.monitoredItemId = newMonitoredItemIds[0];
+    modify1.requestedParameters.samplingInterval = publishingInterval * 1.5;
+
+    UA_ModifyMonitoredItemsRequest modifyRequest;
+    UA_ModifyMonitoredItemsRequest_init(&modifyRequest);
+    modifyRequest.subscriptionId = subId;
+    modifyRequest.itemsToModify = &modify1;
+    modifyRequest.itemsToModifySize = 1;
+
+    UA_ModifyMonitoredItemsResponse modifyResponse =
+        UA_Client_MonitoredItems_modify(client, modifyRequest);
+    ck_assert_uint_eq(modifyResponse.resultsSize, 1);
+    ck_assert_uint_eq(modifyResponse.results[0].statusCode, UA_STATUSCODE_GOOD);
+    UA_ModifyMonitoredItemsResponse_deleteMembers(&modifyResponse);
+
+    /* Sleep longer than the publishing interval */
+    UA_fakeSleep((UA_UInt32)publishingInterval + 1);
+
+    /* Don't receive an immediate update */
+    notificationReceived = false;
+    countNotificationReceived = 0;
+    retval = UA_Client_run_iterate(client, (UA_UInt16)(publishingInterval + 1));
+    ck_assert_uint_eq(retval, UA_STATUSCODE_GOOD);
+    ck_assert_uint_eq(notificationReceived, false);
+    ck_assert_uint_eq(countNotificationReceived, 0);
+
+    /* Modify the MonitoredItem and change the trigger. We want to see an
+     * update. But not immediately. */
+    UA_DataChangeFilter filter;
+    UA_DataChangeFilter_init(&filter);
+    filter.trigger = UA_DATACHANGETRIGGER_STATUSVALUETIMESTAMP;
+    modify1.requestedParameters.filter.content.decoded.data = &filter;
+    modify1.requestedParameters.filter.content.decoded.type =
+        &UA_TYPES[UA_TYPES_DATACHANGEFILTER];
+    modify1.requestedParameters.filter.encoding = UA_EXTENSIONOBJECT_DECODED;
+
+    modifyResponse = UA_Client_MonitoredItems_modify(client, modifyRequest);
+    ck_assert_uint_eq(modifyResponse.resultsSize, 1);
+    ck_assert_uint_eq(modifyResponse.results[0].statusCode, UA_STATUSCODE_GOOD);
+    UA_ModifyMonitoredItemsResponse_deleteMembers(&modifyResponse);
+
+    /* Sleep longer than the publishing interval */
+    UA_fakeSleep((UA_UInt32)publishingInterval + 1);
+    UA_realSleep((UA_UInt32)publishingInterval + 1);
+
+    notificationReceived = false;
+    countNotificationReceived = 0;
+    retval = UA_Client_run_iterate(client, (UA_UInt16)(publishingInterval + 1));
+    ck_assert_uint_eq(retval, UA_STATUSCODE_GOOD);
+    ck_assert_uint_eq(notificationReceived, false);
+    ck_assert_uint_eq(countNotificationReceived, 0);
+
+    /* Sleep long enough to trigger the next sampling.
+     * This should now generate a value with the timestamp. */
+    UA_fakeSleep((UA_UInt32)(publishingInterval * 0.6));
+    UA_realSleep((UA_UInt32)(publishingInterval * 0.6));
+
+    /* Sleep long enough to trigger the publish callback */
+    UA_fakeSleep((UA_UInt32)publishingInterval + 1);
+    retval = UA_Client_run_iterate(client, (UA_UInt16)(publishingInterval + 1));
+    ck_assert_uint_eq(retval, UA_STATUSCODE_GOOD);
+    ck_assert_uint_eq(notificationReceived, true);
+    ck_assert_uint_eq(countNotificationReceived, 1);
+
+    /* Delete and clean up */
+    UA_DeleteMonitoredItemsRequest deleteRequest;
+    UA_DeleteMonitoredItemsRequest_init(&deleteRequest);
+    deleteRequest.subscriptionId = subId;
+    deleteRequest.monitoredItemIds = newMonitoredItemIds;
+    deleteRequest.monitoredItemIdsSize = 1;
+
+    UA_DeleteMonitoredItemsResponse deleteResponse =
+        UA_Client_MonitoredItems_delete(client, deleteRequest);
+
+    ck_assert_uint_eq(deleteResponse.responseHeader.serviceResult, UA_STATUSCODE_GOOD);
+    ck_assert_uint_eq(deleteResponse.resultsSize, 1);
+    UA_DeleteMonitoredItemsResponse_deleteMembers(&deleteResponse);
+
+    retval = UA_Client_Subscriptions_deleteSingle(client, subId);
+    ck_assert_uint_eq(retval, UA_STATUSCODE_GOOD);
+
+    UA_Client_disconnect(client);
+    UA_Client_delete(client);
+}
+END_TEST
+
 START_TEST(Client_subscription_createDataChanges_async) {
     UA_UInt32 reqId = 0;
     UA_Client *client = UA_Client_new();
@@ -1099,6 +1250,7 @@ static Suite* testSuite_Client(void) {
     tcase_add_test(tc_client, Client_subscription_timeout);
     tcase_add_test(tc_client, Client_subscription_connectionClose);
     tcase_add_test(tc_client, Client_subscription_createDataChanges);
+    tcase_add_test(tc_client, Client_subscription_modifyMonitoredItem);
     tcase_add_test(tc_client, Client_subscription_createDataChanges_async);
     tcase_add_test(tc_client, Client_subscription_keepAlive);
     tcase_add_test(tc_client, Client_subscription_without_notification);