qopen62541subscription.cpp

++ // Copyright (C) 2017 The Qt Company Ltd.

++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only

++ // Qt-Security score:significant reason:default

++

++ #include "qopen62541backend.h"

++ #include "qopen62541client.h"

++ #include "qopen62541node.h"

++ #include "qopen62541subscription.h"

++ #include "qopen62541utils.h"

++ #include "qopen62541valueconverter.h"

++ #include "qopen62541utils.h"

++ #include <private/qopcuanode_p.h>

++

++ #include "qopcuacontentfilterelementresult.h"

++

++ #include <QtCore/qloggingcategory.h>

++

++ QT_BEGIN_NAMESPACE

++

++ Q_DECLARE_LOGGING_CATEGORY(QT_OPCUA_PLUGINS_OPEN62541)

++

++ static void monitoredValueHandler(UA_Client *client, UA_UInt32 subId, void *subContext, UA_UInt32 monId, void *monContext, UA_DataValue *value)

++ {

++     Q_UNUSED(client)

++     Q_UNUSED(subId)

++     Q_UNUSED(subContext)

++     QOpen62541Subscription *subscription = static_cast<QOpen62541Subscription *>(monContext);

++     subscription->monitoredValueUpdated(monId, value);

++ }

++

++ static void stateChangeHandler(UA_Client *client, UA_UInt32 subId, void *subContext, UA_StatusChangeNotification *notification)

++ {

++     Q_UNUSED(client);

++     Q_UNUSED(subId);

++

++     if (notification->status != UA_STATUSCODE_BADTIMEOUT)

++         return;

++

++     QOpen62541Subscription *sub = static_cast<QOpen62541Subscription *>(subContext);

++     sub->sendTimeoutNotification();

++ }

++

++ static void eventHandler(UA_Client *client, UA_UInt32 subId, void *subContext, UA_UInt32 monId, void *monContext,

++                          UA_KeyValueMap eventFields)

++ {

++     Q_UNUSED(client);

++     Q_UNUSED(subId);

++     Q_UNUSED(subContext);

++

++     QOpen62541Subscription *subscription = static_cast<QOpen62541Subscription *>(monContext);

++

++     QVariantList list;

++     for (size_t i = 0; i < eventFields.mapSize; ++i)

++         list.append(QOpen62541ValueConverter::toQVariant(eventFields.map[i].value));

++     subscription->eventReceived(monId, list);

++ }

++

++ QOpen62541Subscription::QOpen62541Subscription(Open62541AsyncBackend *backend, const QOpcUaMonitoringParameters &settings)

++     : m_backend(backend)

++     , m_interval(settings.publishingInterval())

++     , m_subscriptionId(0)

++     , m_lifetimeCount(settings.lifetimeCount() ? settings.lifetimeCount() : UA_CreateSubscriptionRequest_default().requestedLifetimeCount)

++     , m_maxKeepaliveCount(settings.maxKeepAliveCount() ? settings.maxKeepAliveCount() : UA_CreateSubscriptionRequest_default().requestedMaxKeepAliveCount)

++     , m_shared(settings.subscriptionType())

++     , m_priority(settings.priority())

++     , m_maxNotificationsPerPublish(settings.maxNotificationsPerPublish())

++     , m_clientHandle(0)

++     , m_timeout(false)

++ {

++ }

++

++ QOpen62541Subscription::~QOpen62541Subscription()

++ {

++     removeOnServer();

++ }

++

++ UA_UInt32 QOpen62541Subscription::createOnServer()

++ {

++     UA_CreateSubscriptionRequest req = UA_CreateSubscriptionRequest_default();

++     req.requestedPublishingInterval = m_interval;

++     req.requestedLifetimeCount = m_lifetimeCount;

++     req.requestedMaxKeepAliveCount = m_maxKeepaliveCount;

++     req.priority = m_priority;

++     req.maxNotificationsPerPublish = m_maxNotificationsPerPublish;

++     UA_CreateSubscriptionResponse res = UA_Client_Subscriptions_create(m_backend->m_uaclient, req, this, stateChangeHandler, nullptr);

++

++     if (res.responseHeader.serviceResult != UA_STATUSCODE_GOOD) {

++         qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Could not create subscription with interval" << m_interval << UA_StatusCode_name(res.responseHeader.serviceResult);

++         return 0;

++     }

++

++     m_subscriptionId = res.subscriptionId;

++     m_maxKeepaliveCount = res.revisedMaxKeepAliveCount;

++     m_lifetimeCount = res.revisedLifetimeCount;

++     m_interval = res.revisedPublishingInterval;

++     return m_subscriptionId;

++ }

++

++ bool QOpen62541Subscription::removeOnServer()

++ {

++     UA_StatusCode res = UA_STATUSCODE_GOOD;

++     if (m_subscriptionId) {

++         res = UA_Client_Subscriptions_deleteSingle(m_backend->m_uaclient, m_subscriptionId);

++         m_subscriptionId = 0;

++     }

++

++     for (auto it : std::as_const(m_itemIdToItemMapping)) {

++         QOpcUaMonitoringParameters s;

++         s.setStatusCode(m_timeout ? QOpcUa::UaStatusCode::BadTimeout : QOpcUa::UaStatusCode::BadDisconnect);

++         emit m_backend->monitoringEnableDisable(it->handle, it->attr, false, s);

++     }

++

++     qDeleteAll(m_itemIdToItemMapping);

++

++     m_itemIdToItemMapping.clear();

++     m_nodeHandleToItemMapping.clear();

++

++     return (res == UA_STATUSCODE_GOOD) ? true : false;

++ }

++

++ void QOpen62541Subscription::modifyMonitoring(quint64 handle, QOpcUa::NodeAttribute attr, QOpcUaMonitoringParameters::Parameter item, QVariant value)

++ {

++     MonitoredItem *monItem = getItemForAttribute(handle, attr);

++     if (!monItem) {

++         qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Could not modify parameter" << item << "there are no monitored items";

++         QOpcUaMonitoringParameters p;

++         p.setStatusCode(QOpcUa::UaStatusCode::BadAttributeIdInvalid);

++         emit m_backend->monitoringStatusChanged(handle, attr, item, p);

++         return;

++     }

++

++     QOpcUaMonitoringParameters p = monItem->parameters;

++     p.setStatusCode(QOpcUa::UaStatusCode::BadNotImplemented);

++

++     // SetPublishingMode service

++     if (item == QOpcUaMonitoringParameters::Parameter::PublishingEnabled) {

++         if (value.metaType().id() != QMetaType::Bool) {

++             qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "New value for PublishingEnabled is not a boolean";

++             p.setStatusCode(QOpcUa::UaStatusCode::BadTypeMismatch);

++             emit m_backend->monitoringStatusChanged(handle, attr, item, p);

++             return;

++         }

++

++         UA_SetPublishingModeRequest req;

++         UA_SetPublishingModeRequest_init(&req);

++         UaDeleter<UA_SetPublishingModeRequest> requestDeleter(&req, UA_SetPublishingModeRequest_clear);

++         req.publishingEnabled = value.toBool();

++         req.subscriptionIdsSize = 1;

++         req.subscriptionIds = UA_UInt32_new();

++         *req.subscriptionIds = m_subscriptionId;

++         UA_SetPublishingModeResponse res = UA_Client_Subscriptions_setPublishingMode(m_backend->m_uaclient, req);

++         UaDeleter<UA_SetPublishingModeResponse> responseDeleter(&res, UA_SetPublishingModeResponse_clear);

++

++         if (res.responseHeader.serviceResult != UA_STATUSCODE_GOOD) {

++             qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Failed to set publishing mode:" << res.responseHeader.serviceResult;

++             p.setStatusCode(static_cast<QOpcUa::UaStatusCode>(res.responseHeader.serviceResult));

++             emit m_backend->monitoringStatusChanged(handle, attr, item, p);

++             return;

++         }

++

++         if (res.resultsSize && res.results[0] == UA_STATUSCODE_GOOD)

++             p.setPublishingEnabled(value.toBool());

++

++         p.setStatusCode(static_cast<QOpcUa::UaStatusCode>(res.results[0]));

++         emit m_backend->monitoringStatusChanged(handle, attr, item, p);

++

++         return;

++     }

++

++     // SetMonitoringMode service

++     if (item == QOpcUaMonitoringParameters::Parameter::MonitoringMode) {

++         if (value.userType() != QMetaType::fromType<QOpcUaMonitoringParameters::MonitoringMode>().id()) {

++             qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "New value for MonitoringMode is not a monitoring mode";

++             p.setStatusCode(QOpcUa::UaStatusCode::BadTypeMismatch);

++             emit m_backend->monitoringStatusChanged(handle, attr, item, p);

++             return;

++         }

++

++         UA_SetMonitoringModeRequest req;

++         UA_SetMonitoringModeRequest_init(&req);

++         UaDeleter<UA_SetMonitoringModeRequest> requestDeleter(&req, UA_SetMonitoringModeRequest_clear);

++         req.monitoringMode = static_cast<UA_MonitoringMode>(value.value<QOpcUaMonitoringParameters::MonitoringMode>());

++         req.monitoredItemIdsSize = 1;

++         req.monitoredItemIds = UA_UInt32_new();

++         *req.monitoredItemIds = monItem->monitoredItemId;

++         req.subscriptionId = m_subscriptionId;

++         UA_SetMonitoringModeResponse res = UA_Client_MonitoredItems_setMonitoringMode(m_backend->m_uaclient, req);

++         UaDeleter<UA_SetMonitoringModeResponse> responseDeleter(&res, UA_SetMonitoringModeResponse_clear);

++

++         if (res.responseHeader.serviceResult != UA_STATUSCODE_GOOD) {

++             qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Failed to set monitoring mode:" << res.responseHeader.serviceResult;

++             p.setStatusCode(static_cast<QOpcUa::UaStatusCode>(res.responseHeader.serviceResult));

++             emit m_backend->monitoringStatusChanged(handle, attr, item, p);

++             return;

++         }

++

++         if (res.resultsSize && res.results[0] == UA_STATUSCODE_GOOD)

++             p.setMonitoringMode(value.value<QOpcUaMonitoringParameters::MonitoringMode>());

++

++         p.setStatusCode(static_cast<QOpcUa::UaStatusCode>(res.results[0]));

++         emit m_backend->monitoringStatusChanged(handle, attr, item, p);

++         return;

++     }

++

++     // SetTriggering service

++     if (item == QOpcUaMonitoringParameters::Parameter::TriggeredItemIds) {

++         if (!value.canConvert<QSet<quint32>>()) {

++             qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Could not modify triggering item id, value is not a set of quint32";

++             p.setStatusCode(QOpcUa::UaStatusCode::BadTypeMismatch);

++             emit m_backend->monitoringStatusChanged(handle, attr, item, p);

++             return;

++         }

++

++         auto triggeredItemIds = value.value<QSet<quint32>>();

++

++         UA_SetTriggeringRequest triggeringReq;

++         UA_SetTriggeringRequest_init(&triggeringReq);

++         triggeringReq.subscriptionId = m_subscriptionId;

++         triggeringReq.triggeringItemId = monItem->monitoredItemId;

++

++         QList<quint32> itemsToRemove;

++         QList<quint32> itemsToAdd;

++

++         if (triggeredItemIds.isEmpty() && !monItem->parameters.triggeredItemIds().isEmpty()) {

++             itemsToRemove = monItem->parameters.triggeredItemIds().values();

++         } else if (!triggeredItemIds.isEmpty()) {

++             itemsToAdd = triggeredItemIds.values();

++             itemsToRemove = monItem->parameters.triggeredItemIds().subtract(triggeredItemIds).values();

++         }

++

++         if (itemsToAdd.isEmpty() && itemsToRemove.isEmpty()) {

++             qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Nothing to do for TriggeredItemIds";

++             p.setStatusCode(QOpcUa::UaStatusCode::Good);

++             emit m_backend->monitoringStatusChanged(handle, attr, item, p);

++             return;

++         }

++

++         if (!itemsToAdd.isEmpty()) {

++             triggeringReq.linksToAddSize = itemsToAdd.size();

++             triggeringReq.linksToAdd = itemsToAdd.data();

++         }

++

++         if (!itemsToRemove.isEmpty()) {

++             triggeringReq.linksToRemoveSize = itemsToRemove.size();

++             triggeringReq.linksToRemove = itemsToRemove.data();

++         }

++

++         auto triggeringRes = UA_Client_MonitoredItems_setTriggering(m_backend->m_uaclient, triggeringReq);

++

++         QHash<quint32, QOpcUa::UaStatusCode> failedItems;

++

++         if (triggeringRes.responseHeader.serviceResult != UA_STATUSCODE_GOOD) {

++             qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Modifying TriggeredItemIds failed with"

++                                                   << UA_StatusCode_name(triggeringRes.responseHeader.serviceResult);

++

++             for (const auto &entry : std::as_const(itemsToAdd))

++                 failedItems[entry] = QOpcUa::UaStatusCode(triggeringRes.responseHeader.serviceResult);

++             p.setFailedTriggeredItemsStatus(failedItems);

++             p.setStatusCode(QOpcUa::UaStatusCode(triggeringRes.responseHeader.serviceResult));

++             emit m_backend->monitoringStatusChanged(handle, attr, item, p);

++             UA_SetTriggeringResponse_clear(&triggeringRes);

++             return;

++         }

++

++         for (size_t i = 0; i < triggeringRes.addResultsSize; ++i) {

++             if (triggeringRes.addResults[i] != UA_STATUSCODE_GOOD) {

++                 qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Failed to add trigger link" << triggeringReq.triggeringItemId

++                                                       << "->" << itemsToAdd.at(i) << "on subscription" << m_subscriptionId

++                                                       << "with status"

++                                                       << UA_StatusCode_name(triggeringRes.addResults[i]);

++                 failedItems.insert(itemsToAdd.at(i), QOpcUa::UaStatusCode(triggeringRes.addResults[i]));

++                 triggeredItemIds.remove(itemsToAdd.at(i));

++             }

++         }

++

++         UA_SetTriggeringResponse_clear(&triggeringRes);

++

++         monItem->parameters.setTriggeredItemIds(triggeredItemIds);

++         p.setStatusCode(QOpcUa::UaStatusCode::Good);

++         p.setTriggeredItemIds(triggeredItemIds);

++         p.setFailedTriggeredItemsStatus(failedItems);

++         emit m_backend->monitoringStatusChanged(handle, attr, item, p);

++

++         return;

++     }

++

++     if (modifySubscriptionParameters(handle, attr, item, value))

++         return;

++     if (modifyMonitoredItemParameters(handle, attr, item, value))

++         return;

++

++     qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Modifying" << item << "is not implemented";

++     p.setStatusCode(QOpcUa::UaStatusCode::BadNotImplemented);

++     emit m_backend->monitoringStatusChanged(handle, attr, item, p);

++ }

++

++ bool QOpen62541Subscription::addAttributeMonitoredItem(quint64 handle, QOpcUa::NodeAttribute attr, const UA_NodeId &id, QOpcUaMonitoringParameters settings)

++ {

++     UA_MonitoredItemCreateRequest req;

++     UA_MonitoredItemCreateRequest_init(&req);

++     UaDeleter<UA_MonitoredItemCreateRequest> requestDeleter(&req, UA_MonitoredItemCreateRequest_clear);

++     req.itemToMonitor.attributeId = QOpen62541ValueConverter::toUaAttributeId(attr);

++     UA_NodeId_copy(&id, &(req.itemToMonitor.nodeId));

++     if (settings.indexRange().size())

++         QOpen62541ValueConverter::scalarFromQt<UA_String, QString>(settings.indexRange(), &req.itemToMonitor.indexRange);

++     req.monitoringMode = static_cast<UA_MonitoringMode>(settings.monitoringMode());

++     req.requestedParameters.samplingInterval = qFuzzyIsNull(settings.samplingInterval()) ? m_interval : settings.samplingInterval();

++     req.requestedParameters.queueSize = settings.queueSize() == 0 ? 1 : settings.queueSize();

++     req.requestedParameters.discardOldest = settings.discardOldest();

++     req.requestedParameters.clientHandle = ++m_clientHandle;

++

++     if (settings.filter().isValid()) {

++         UA_ExtensionObject filter = createFilter(settings.filter());

++         if (filter.content.decoded.data)

++             req.requestedParameters.filter = filter;

++         else {

++             qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Could not create monitored item, filter creation failed";

++             QOpcUaMonitoringParameters s;

++             s.setStatusCode(QOpcUa::UaStatusCode::BadInternalError);

++             emit m_backend->monitoringEnableDisable(handle, attr, true, s);

++             return false;

++         }

++     }

++

++     UA_MonitoredItemCreateResult res;

++     UaDeleter<UA_MonitoredItemCreateResult> resultDeleter(&res, UA_MonitoredItemCreateResult_clear);

++

++     if (attr == QOpcUa::NodeAttribute::EventNotifier && settings.filter().canConvert<QOpcUaMonitoringParameters::EventFilter>())

++         res = UA_Client_MonitoredItems_createEvent(m_backend->m_uaclient, m_subscriptionId,

++                                                    UA_TIMESTAMPSTORETURN_BOTH, req, this, eventHandler, nullptr);

++     else

++         res = UA_Client_MonitoredItems_createDataChange(m_backend->m_uaclient, m_subscriptionId, UA_TIMESTAMPSTORETURN_BOTH, req, this, monitoredValueHandler, nullptr);

++

++     if (res.statusCode != UA_STATUSCODE_GOOD) {

++         qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Could not add monitored item for" << attr << "of node" << Open62541Utils::nodeIdToQString(id) << ":" << UA_StatusCode_name(res.statusCode);

++         QOpcUaMonitoringParameters s;

++         s.setStatusCode(static_cast<QOpcUa::UaStatusCode>(res.statusCode));

++         emit m_backend->monitoringEnableDisable(handle, attr, true, s);

++         return false;

++     }

++

++     QSet<quint32> successfulTriggerLinks;

++     QHash<quint32, QOpcUa::UaStatusCode> failedTriggerLinks;

++     if (!settings.triggeredItemIds().isEmpty()) {

++         auto triggeredItems = settings.triggeredItemIds().values();

++

++         UA_SetTriggeringRequest req;

++         UA_SetTriggeringRequest_init(&req);

++         req.subscriptionId = m_subscriptionId;

++         req.triggeringItemId = res.monitoredItemId;

++         req.linksToAddSize = triggeredItems.size();

++         req.linksToAdd = triggeredItems.data();

++

++         auto triggeringRes = UA_Client_MonitoredItems_setTriggering(m_backend->m_uaclient, req);

++

++         if (triggeringRes.responseHeader.serviceResult != UA_STATUSCODE_GOOD) {

++             qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Could not set triggering item it for" << attr << "of node" << Open62541Utils::nodeIdToQString(id) << ":"

++                                                   << UA_StatusCode_name(triggeringRes.responseHeader.serviceResult);

++

++             // Remove the new monitored item

++             UA_DeleteMonitoredItemsRequest deleteRequest;

++             UA_DeleteMonitoredItemsRequest_init(&deleteRequest);

++             deleteRequest.subscriptionId = m_subscriptionId;

++             deleteRequest.monitoredItemIdsSize = 1;

++             deleteRequest.monitoredItemIds = &res.monitoredItemId;

++             UA_Client_MonitoredItems_delete(m_backend->m_uaclient, deleteRequest);

++

++             for (const auto &entry : std::as_const(triggeredItems))

++                 failedTriggerLinks.insert(entry, QOpcUa::UaStatusCode(triggeringRes.responseHeader.serviceResult));

++

++             QOpcUaMonitoringParameters s;

++             s.setStatusCode(static_cast<QOpcUa::UaStatusCode>(triggeringRes.responseHeader.serviceResult));

++             s.setFailedTriggeredItemsStatus(failedTriggerLinks);

++             emit m_backend->monitoringEnableDisable(handle, attr, true, s);

++

++             UA_SetTriggeringResponse_clear(&triggeringRes);

++

++             return false;

++         }

++

++         for (size_t i = 0; i < triggeringRes.addResultsSize; ++i) {

++             if (triggeringRes.addResults[i] == UA_STATUSCODE_GOOD) {

++                 successfulTriggerLinks.insert(triggeredItems.at(i));

++             } else {

++                 qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Failed to add trigger link" << res.monitoredItemId

++                                                       << "->" << triggeredItems.at(i) << "on subscription" << m_subscriptionId

++                                                       << "with status"

++                                                       << UA_StatusCode_name(triggeringRes.addResults[i]);

++                 failedTriggerLinks.insert(triggeredItems.at(i), QOpcUa::UaStatusCode(triggeringRes.addResults[i]));

++             }

++         }

++

++         UA_SetTriggeringResponse_clear(&triggeringRes);

++     }

++

++     MonitoredItem *temp = new MonitoredItem(handle, attr, res.monitoredItemId);

++     m_nodeHandleToItemMapping[handle][attr] = temp;

++     m_itemIdToItemMapping[res.monitoredItemId] = temp;

++

++     QOpcUaMonitoringParameters s = settings;

++     s.setSubscriptionId(m_subscriptionId);

++     s.setPublishingInterval(m_interval);

++     s.setMaxKeepAliveCount(m_maxKeepaliveCount);

++     s.setLifetimeCount(m_lifetimeCount);

++     s.setStatusCode(QOpcUa::UaStatusCode::Good);

++     s.setSamplingInterval(res.revisedSamplingInterval);

++     s.setQueueSize(res.revisedQueueSize);

++     s.setMonitoredItemId(res.monitoredItemId);

++     s.setTriggeredItemIds(successfulTriggerLinks);

++     s.setFailedTriggeredItemsStatus(failedTriggerLinks);

++     temp->parameters = s;

++     temp->clientHandle = m_clientHandle;

++

++     if (res.filterResult.encoding >= UA_EXTENSIONOBJECT_DECODED &&

++             res.filterResult.content.decoded.type == &UA_TYPES[UA_TYPES_EVENTFILTERRESULT])

++         s.setFilterResult(convertEventFilterResult(&res.filterResult));

++     else

++         s.clearFilterResult();

++

++     emit m_backend->monitoringEnableDisable(handle, attr, true, s);

++

++     return true;

++ }

++

++ bool QOpen62541Subscription::removeAttributeMonitoredItem(quint64 handle, QOpcUa::NodeAttribute attr)

++ {

++     MonitoredItem *item = getItemForAttribute(handle, attr);

++     if (!item) {

++         qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "There is no monitored item for this attribute";

++         QOpcUaMonitoringParameters s;

++         s.setStatusCode(QOpcUa::UaStatusCode::BadMonitoredItemIdInvalid);

++         emit m_backend->monitoringEnableDisable(handle, attr, false, s);

++         return false;

++     }

++

++     UA_StatusCode res = UA_Client_MonitoredItems_deleteSingle(m_backend->m_uaclient, m_subscriptionId, item->monitoredItemId);

++     if (res != UA_STATUSCODE_GOOD)

++         qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Could not remove monitored item" << item->monitoredItemId << "from subscription" << m_subscriptionId << ":" << UA_StatusCode_name(res);

++

++     m_itemIdToItemMapping.remove(item->monitoredItemId);

++     const auto it = m_nodeHandleToItemMapping.find(handle);

++     it->remove(attr);

++     if (it->empty())

++         m_nodeHandleToItemMapping.remove(it.key());

++

++     delete item;

++

++     QOpcUaMonitoringParameters s;

++     s.setStatusCode(static_cast<QOpcUa::UaStatusCode>(res));

++     emit m_backend->monitoringEnableDisable(handle, attr, false, s);

++

++     return true;

++ }

++

++ void QOpen62541Subscription::monitoredValueUpdated(UA_UInt32 monId, UA_DataValue *value)

++ {

++     auto item = m_itemIdToItemMapping.constFind(monId);

++     if (item == m_itemIdToItemMapping.constEnd())

++         return;

++     QOpcUaReadResult res;

++

++     if (!value || value == UA_EMPTY_ARRAY_SENTINEL) {

++         res.setStatusCode(QOpcUa::UaStatusCode::Good);

++         emit m_backend->dataChangeOccurred(item.value()->handle, res);

++         return;

++     }

++

++     res.setValue(QOpen62541ValueConverter::toQVariant(value->value));

++     res.setAttribute(item.value()->attr);

++     if (value->hasServerTimestamp)

++         res.setServerTimestamp(QOpen62541ValueConverter::scalarToQt<QDateTime, UA_DateTime>(&value->serverTimestamp));

++     if (value->hasSourceTimestamp)

++         res.setSourceTimestamp(QOpen62541ValueConverter::scalarToQt<QDateTime, UA_DateTime>(&value->sourceTimestamp));

++     res.setStatusCode(value->hasStatus ? QOpcUa::UaStatusCode(value->status) : QOpcUa::UaStatusCode::Good);

++     emit m_backend->dataChangeOccurred(item.value()->handle, res);

++ }

++

++ void QOpen62541Subscription::sendTimeoutNotification()

++ {

++     QList<std::pair<quint64, QOpcUa::NodeAttribute>> items;

++     for (const auto &it : std::as_const(m_nodeHandleToItemMapping)) {

++         for (auto item : it) {

++             items.push_back({item->handle, item->attr});

++         }

++     }

++     emit timeout(this, items);

++     m_timeout = true;

++ }

++

++ void QOpen62541Subscription::eventReceived(UA_UInt32 monId, QVariantList list)

++ {

++     auto item = m_itemIdToItemMapping.constFind(monId);

++     if (item == m_itemIdToItemMapping.constEnd())

++         return;

++     emit m_backend->eventOccurred(item.value()->handle, list);

++ }

++

++ double QOpen62541Subscription::interval() const

++ {

++     return m_interval;

++ }

++

++ UA_UInt32 QOpen62541Subscription::subscriptionId() const

++ {

++     return m_subscriptionId;

++ }

++

++ int QOpen62541Subscription::monitoredItemsCount() const

++ {

++     return m_itemIdToItemMapping.size();

++ }

++

++ QOpcUaMonitoringParameters::SubscriptionType QOpen62541Subscription::shared() const

++ {

++     return m_shared;

++ }

++

++ QOpen62541Subscription::MonitoredItem *QOpen62541Subscription::getItemForAttribute(quint64 nodeHandle, QOpcUa::NodeAttribute attr)

++ {

++     auto nodeEntry = m_nodeHandleToItemMapping.constFind(nodeHandle);

++

++     if (nodeEntry == m_nodeHandleToItemMapping.constEnd())

++         return nullptr;

++

++     auto item = nodeEntry->constFind(attr);

++     if (item == nodeEntry->constEnd())

++         return nullptr;

++

++     return item.value();

++ }

++

++ UA_ExtensionObject QOpen62541Subscription::createFilter(const QVariant &filterData)

++ {

++     UA_ExtensionObject obj;

++     UA_ExtensionObject_init(&obj);

++

++     if (filterData.canConvert<QOpcUaMonitoringParameters::DataChangeFilter>()) {

++         createDataChangeFilter(filterData.value<QOpcUaMonitoringParameters::DataChangeFilter>(), &obj);

++         return obj;

++     }

++

++     if (filterData.canConvert<QOpcUaMonitoringParameters::EventFilter>()) {

++         QOpen62541ValueConverter::eventFilterToUa(filterData.value<QOpcUaMonitoringParameters::EventFilter>(), &obj);

++         return obj;

++     }

++

++     if (filterData.isValid())

++         qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Could not create filter, invalid input.";

++

++     return obj;

++ }

++

++ void QOpen62541Subscription::createDataChangeFilter(const QOpcUaMonitoringParameters::DataChangeFilter &filter, UA_ExtensionObject *out)

++ {

++     UA_DataChangeFilter *uaFilter = UA_DataChangeFilter_new();

++     uaFilter->deadbandType = static_cast<UA_UInt32>(filter.deadbandType());

++     uaFilter->deadbandValue = filter.deadbandValue();

++     uaFilter->trigger = static_cast<UA_DataChangeTrigger>(filter.trigger());

++     out->encoding = UA_EXTENSIONOBJECT_DECODED;

++     out->content.decoded.type = &UA_TYPES[UA_TYPES_DATACHANGEFILTER];

++     out->content.decoded.data = uaFilter;

++ }

++

++ QOpcUaEventFilterResult QOpen62541Subscription::convertEventFilterResult(UA_ExtensionObject *obj)

++ {

++     QOpcUaEventFilterResult result;

++

++     if (!obj)

++         return result;

++

++     if (obj->encoding == UA_EXTENSIONOBJECT_DECODED && obj->content.decoded.type == &UA_TYPES[UA_TYPES_EVENTFILTERRESULT]) {

++         UA_EventFilterResult *filterResult = static_cast<UA_EventFilterResult *>(obj->content.decoded.data);

++

++         for (size_t i = 0; i < filterResult->selectClauseResultsSize; ++i)

++             result.selectClauseResultsRef().append(static_cast<QOpcUa::UaStatusCode>(filterResult->selectClauseResults[i]));

++

++         for (size_t i = 0; i < filterResult->whereClauseResult.elementResultsSize; ++i) {

++             QOpcUaContentFilterElementResult temp;

++             temp.setStatusCode(static_cast<QOpcUa::UaStatusCode>(filterResult->whereClauseResult.elementResults[i].statusCode));

++             for (size_t j = 0; j < filterResult->whereClauseResult.elementResults[i].operandStatusCodesSize; ++j)

++                 temp.operandStatusCodesRef().append(static_cast<QOpcUa::UaStatusCode>(

++                                                         filterResult->whereClauseResult.elementResults[i].operandStatusCodes[j]));

++             result.whereClauseResultsRef().append(temp);

++         }

++     }

++

++     return result;

++ }

++

++ bool QOpen62541Subscription::modifySubscriptionParameters(quint64 nodeHandle, QOpcUa::NodeAttribute attr, const QOpcUaMonitoringParameters::Parameter &item, const QVariant &value)

++ {

++     UA_ModifySubscriptionRequest req;

++     UA_ModifySubscriptionRequest_init(&req);

++     req.subscriptionId = m_subscriptionId;

++     req.requestedPublishingInterval = m_interval;

++     req.requestedLifetimeCount = m_lifetimeCount;

++     req.requestedMaxKeepAliveCount = m_maxKeepaliveCount;

++     req.maxNotificationsPerPublish = m_maxNotificationsPerPublish;

++

++     bool match = true;

++

++     switch (item) {

++     case QOpcUaMonitoringParameters::Parameter::PublishingInterval: {

++         bool ok;

++         req.requestedPublishingInterval = value.toDouble(&ok);

++         if (!ok) {

++             qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Could not modify PublishingInterval, value is not a double";

++             QOpcUaMonitoringParameters p;

++             p.setStatusCode(QOpcUa::UaStatusCode::BadTypeMismatch);

++             emit m_backend->monitoringStatusChanged(nodeHandle, attr, item, p);

++             return true;

++         }

++         break;

++     }

++     case QOpcUaMonitoringParameters::Parameter::LifetimeCount: {

++         bool ok;

++         req.requestedLifetimeCount = value.toUInt(&ok);

++         if (!ok) {

++             qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Could not modify LifetimeCount, value is not an integer";

++             QOpcUaMonitoringParameters p;

++             p.setStatusCode(QOpcUa::UaStatusCode::BadTypeMismatch);

++             emit m_backend->monitoringStatusChanged(nodeHandle, attr, item, p);

++             return true;

++         }

++         break;

++     }

++     case QOpcUaMonitoringParameters::Parameter::MaxKeepAliveCount: {

++         bool ok;

++         req.requestedMaxKeepAliveCount = value.toUInt(&ok);

++         if (!ok) {

++             qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Could not modify MaxKeepAliveCount, value is not an integer";

++             QOpcUaMonitoringParameters p;

++             p.setStatusCode(QOpcUa::UaStatusCode::BadTypeMismatch);

++             emit m_backend->monitoringStatusChanged(nodeHandle, attr, item, p);

++             return true;

++         }

++         break;

++     }

++     case QOpcUaMonitoringParameters::Parameter::Priority: {

++         bool ok;

++         req.priority = value.toUInt(&ok);

++         if (!ok) {

++             qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Could not modify Priority, value is not an integer";

++             QOpcUaMonitoringParameters p;

++             p.setStatusCode(QOpcUa::UaStatusCode::BadTypeMismatch);

++             emit m_backend->monitoringStatusChanged(nodeHandle, attr, item, p);

++             return true;

++         }

++         break;

++     }

++     case QOpcUaMonitoringParameters::Parameter::MaxNotificationsPerPublish: {

++         bool ok;

++         req.maxNotificationsPerPublish = value.toUInt(&ok);

++         if (!ok) {

++             qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Could not modify MaxNotificationsPerPublish, value is not an integer";

++             QOpcUaMonitoringParameters p;

++             p.setStatusCode(QOpcUa::UaStatusCode::BadTypeMismatch);

++             emit m_backend->monitoringStatusChanged(nodeHandle, attr, item, p);

++             return true;

++         }

++         break;

++     }

++     default:

++         match = false;

++         break;

++     }

++

++     if (match) {

++         UA_ModifySubscriptionResponse res = UA_Client_Subscriptions_modify(m_backend->m_uaclient, req);

++

++         if (res.responseHeader.serviceResult != UA_STATUSCODE_GOOD) {

++             QOpcUaMonitoringParameters p;

++             p.setStatusCode(static_cast<QOpcUa::UaStatusCode>(res.responseHeader.serviceResult));

++             emit m_backend->monitoringStatusChanged(nodeHandle, attr, item, p);

++         } else {

++             QOpcUaMonitoringParameters::Parameters changed = item;

++             if (!QtPrivate::fuzzyCompare(res.revisedPublishingInterval, m_interval))

++                 changed |= QOpcUaMonitoringParameters::Parameter::PublishingInterval;

++             if (res.revisedLifetimeCount != m_lifetimeCount)

++                 changed |= QOpcUaMonitoringParameters::Parameter::LifetimeCount;

++             if (res.revisedMaxKeepAliveCount != m_maxKeepaliveCount)

++                 changed |= QOpcUaMonitoringParameters::Parameter::MaxKeepAliveCount;

++

++             m_lifetimeCount = res.revisedLifetimeCount;

++             m_maxKeepaliveCount = res.revisedMaxKeepAliveCount;

++             m_interval = res.revisedPublishingInterval;

++             if (item == QOpcUaMonitoringParameters::Parameter::Priority)

++                 m_priority = value.toUInt();

++             if (item == QOpcUaMonitoringParameters::Parameter::MaxNotificationsPerPublish)

++                 m_maxNotificationsPerPublish = value.toUInt();

++

++             QOpcUaMonitoringParameters p;

++             p.setStatusCode(QOpcUa::UaStatusCode::Good);

++             p.setPublishingInterval(m_interval);

++             p.setLifetimeCount(m_lifetimeCount);

++             p.setMaxKeepAliveCount(m_maxKeepaliveCount);

++             p.setPriority(m_priority);

++             p.setMaxNotificationsPerPublish(m_maxNotificationsPerPublish);

++

++             for (auto it : std::as_const(m_itemIdToItemMapping))

++                 emit m_backend->monitoringStatusChanged(it->handle, it->attr, changed, p);

++         }

++         return true;

++     }

++     return false;

++ }

++

++ bool QOpen62541Subscription::modifyMonitoredItemParameters(quint64 nodeHandle, QOpcUa::NodeAttribute attr, const QOpcUaMonitoringParameters::Parameter &item, const QVariant &value)

++ {

++     MonitoredItem *monItem = getItemForAttribute(nodeHandle, attr);

++     QOpcUaMonitoringParameters p = monItem->parameters;

++

++     UA_ModifyMonitoredItemsRequest req;

++     UA_ModifyMonitoredItemsRequest_init(&req);

++     UaDeleter<UA_ModifyMonitoredItemsRequest> requestDeleter(&req, UA_ModifyMonitoredItemsRequest_clear);

++     req.subscriptionId = m_subscriptionId;

++     req.itemsToModifySize = 1;

++     req.itemsToModify = UA_MonitoredItemModifyRequest_new();

++     UA_MonitoredItemModifyRequest_init(req.itemsToModify);

++     req.itemsToModify->monitoredItemId = monItem->monitoredItemId;

++     req.itemsToModify->requestedParameters.discardOldest = monItem->parameters.discardOldest();

++     req.itemsToModify->requestedParameters.queueSize = monItem->parameters.queueSize();

++     req.itemsToModify->requestedParameters.samplingInterval = monItem->parameters.samplingInterval();

++     req.itemsToModify->monitoredItemId = monItem->monitoredItemId;

++     req.itemsToModify->requestedParameters.clientHandle = monItem->clientHandle;

++

++     bool match = true;

++

++     switch (item) {

++     case QOpcUaMonitoringParameters::Parameter::DiscardOldest: {

++         if (value.metaType().id() != QMetaType::Bool) {

++             qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Could not modify DiscardOldest, value is not a bool";

++             p.setStatusCode(QOpcUa::UaStatusCode::BadTypeMismatch);

++             emit m_backend->monitoringStatusChanged(nodeHandle, attr, item, p);

++             return true;

++         }

++         req.itemsToModify->requestedParameters.discardOldest = value.toBool();

++         break;

++     }

++     case QOpcUaMonitoringParameters::Parameter::QueueSize: {

++         if (value.metaType().id() != QMetaType::UInt) {

++             qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Could not modify QueueSize, value is not an integer";

++             p.setStatusCode(QOpcUa::UaStatusCode::BadTypeMismatch);

++             emit m_backend->monitoringStatusChanged(nodeHandle, attr, item, p);

++             return true;

++         }

++         req.itemsToModify->requestedParameters.queueSize = value.toUInt();

++         break;

++     }

++     case QOpcUaMonitoringParameters::Parameter::SamplingInterval: {

++         if (value.metaType().id() != QMetaType::Double) {

++             qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Could not modify SamplingInterval, value is not a double";

++             p.setStatusCode(QOpcUa::UaStatusCode::BadTypeMismatch);

++             emit m_backend->monitoringStatusChanged(nodeHandle, attr, item, p);

++             return true;

++         }

++         req.itemsToModify->requestedParameters.samplingInterval = value.toDouble();

++         break;

++     }

++     case QOpcUaMonitoringParameters::Parameter::Filter: {

++         UA_ExtensionObject filter = createFilter(value);

++         if (filter.content.decoded.data)

++             req.itemsToModify->requestedParameters.filter = filter;

++         else {

++             qCDebug(QT_OPCUA_PLUGINS_OPEN62541) << "Unable to modify filter, filter creation failed";

++             p.setStatusCode(QOpcUa::UaStatusCode::BadInternalError);

++             emit m_backend->monitoringStatusChanged(nodeHandle, attr, item, p);

++             return true;

++         }

++         break;

++     }

++     default:

++         match = false;

++         break;

++     }

++

++     if (match) {

++         if (item != QOpcUaMonitoringParameters::Parameter::Filter && p.filter().isValid()) {

++             UA_ExtensionObject filter = createFilter(monItem->parameters.filter());

++             if (filter.content.decoded.data)

++                 req.itemsToModify->requestedParameters.filter = filter;

++             else {

++                 qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Could not modify monitored item, filter creation failed";

++                 p.setStatusCode(QOpcUa::UaStatusCode::BadInternalError);

++                 emit m_backend->monitoringStatusChanged(nodeHandle, attr, item, p);

++                 return true;

++             }

++         }

++

++         UA_ModifyMonitoredItemsResponse res = UA_Client_MonitoredItems_modify(m_backend->m_uaclient, req);

++         UaDeleter<UA_ModifyMonitoredItemsResponse> responseDeleter(

++                     &res, UA_ModifyMonitoredItemsResponse_clear);

++

++         if (res.responseHeader.serviceResult != UA_STATUSCODE_GOOD || res.results[0].statusCode != UA_STATUSCODE_GOOD) {

++             p.setStatusCode(static_cast<QOpcUa::UaStatusCode>(res.responseHeader.serviceResult == UA_STATUSCODE_GOOD ? res.results[0].statusCode : res.responseHeader.serviceResult));

++             emit m_backend->monitoringStatusChanged(nodeHandle, attr, item, p);

++             return true;

++         } else {

++             p.setStatusCode(QOpcUa::UaStatusCode::Good);

++             QOpcUaMonitoringParameters::Parameters changed = item;

++             if (!QtPrivate::fuzzyCompare(p.samplingInterval(), res.results[0].revisedSamplingInterval)) {

++                 p.setSamplingInterval(res.results[0].revisedSamplingInterval);

++                 changed |= QOpcUaMonitoringParameters::Parameter::SamplingInterval;

++             }

++             if (p.queueSize() != res.results[0].revisedQueueSize) {

++                 p.setQueueSize(res.results[0].revisedQueueSize);

++                 changed |= QOpcUaMonitoringParameters::Parameter::QueueSize;

++             }

++

++             if (item == QOpcUaMonitoringParameters::Parameter::DiscardOldest) {

++                 p.setDiscardOldest(value.toBool());

++                 changed |= QOpcUaMonitoringParameters::Parameter::DiscardOldest;

++             }

++

++             if (item == QOpcUaMonitoringParameters::Parameter::Filter) {

++                 changed |= QOpcUaMonitoringParameters::Parameter::Filter;

++                 if (value.canConvert<QOpcUaMonitoringParameters::DataChangeFilter>())

++                     p.setFilter(value.value<QOpcUaMonitoringParameters::DataChangeFilter>());

++                 else if (value.canConvert<QOpcUaMonitoringParameters::EventFilter>())

++                     p.setFilter(value.value<QOpcUaMonitoringParameters::EventFilter>());

++                 if (res.results[0].filterResult.content.decoded.type == &UA_TYPES[UA_TYPES_EVENTFILTERRESULT])

++                     p.setFilterResult(convertEventFilterResult(&res.results[0].filterResult));

++             }

++

++             emit m_backend->monitoringStatusChanged(nodeHandle, attr, changed, p);

++

++             monItem->parameters = p;

++         }

++         return true;

++     }

++     return false;

++ }

++

++ QT_END_NAMESPACE

Revision control