qt/qtopcua/src/plugins/opcua/open62541/qopen62541backend.cpp

Revision control

Copy as Markdown

// 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:critical reason:network-protocol
#ifdef USE_SYSTEM_OPEN62541
#include <open62541/client_config_default.h>
#include <open62541/plugin/securitypolicy_default.h>
#include <open62541/plugin/certificategroup_default.h>
#endif
#include "qopen62541backend.h"
#include "qopen62541node.h"
#include "qopen62541utils.h"
#include "qopen62541valueconverter.h"
#include <private/qopcuaclient_p.h>
#include <private/qopcuasecuritypolicyuris_p.h>
#include "qopcuaauthenticationinformation.h"
#include <qopcuaerrorstate.h>
#include <QtCore/QDir>
#include <QtCore/QFile>
#include <QtCore/qloggingcategory.h>
#include <QtCore/qstringlist.h>
#include <QtCore/qurl.h>
#include <QtCore/private/qnumeric_p.h> // for qt_saturate
#include <algorithm>
#include <limits>
using namespace Qt::Literals::StringLiterals;
QT_BEGIN_NAMESPACE
using namespace Qt::Literals::StringLiterals;
Q_DECLARE_LOGGING_CATEGORY(QT_OPCUA_PLUGINS_OPEN62541)
Open62541AsyncBackend::Open62541AsyncBackend(QOpen62541Client *parent)
: QOpcUaBackend()
, m_uaclient(nullptr)
, m_clientImpl(parent)
, m_clientIterateInterval(50)
, m_asyncRequestTimeout(15000)
, m_clientIterateTimer(this)
, m_clientIterateOnDemandTimer(this)
, m_minPublishingInterval(0)
{
QObject::connect(&m_clientIterateTimer, &QTimer::timeout,
this, &Open62541AsyncBackend::iterateClient);
m_clientIterateOnDemandTimer.setSingleShot(true);
QObject::connect(&m_clientIterateOnDemandTimer, &QTimer::timeout,
this, &Open62541AsyncBackend::iterateClient);
QObject::connect(parent, &QOpcUaClientImpl::connectionSettingsChanged,
this, &Open62541AsyncBackend::handleConnectionSettingsChanged);
}
Open62541AsyncBackend::~Open62541AsyncBackend()
{
cleanupSubscriptions();
if (m_uaclient)
UA_Client_delete(m_uaclient);
}
void Open62541AsyncBackend::readAttributes(quint64 handle, UA_NodeId id, QOpcUa::NodeAttributes attr, QString indexRange)
{
UaDeleter<UA_NodeId> nodeIdDeleter(&id, UA_NodeId_clear);
if (!m_uaclient) {
QList<QOpcUaReadResult> resultMetadata;
qt_forEachAttribute(attr, [&](QOpcUa::NodeAttribute attribute){
QOpcUaReadResult temp;
temp.setAttribute(attribute);
resultMetadata.push_back(temp);
});
emit attributesRead(handle, resultMetadata, QOpcUa::UaStatusCode::BadDisconnect);
return;
}
UA_ReadRequest req;
UA_ReadRequest_init(&req);
req.requestHeader.timeoutHint = m_asyncRequestTimeout;
UaDeleter<UA_ReadRequest> requestDeleter(&req, UA_ReadRequest_clear);
req.timestampsToReturn = UA_TIMESTAMPSTORETURN_BOTH;
qt_forEachAttribute(attr, [&req](QOpcUa::NodeAttribute attr) {
Q_UNUSED(attr);
++req.nodesToReadSize;
});
if (req.nodesToReadSize)
req.nodesToRead = static_cast<UA_ReadValueId *>(UA_Array_new(req.nodesToReadSize, &UA_TYPES[UA_TYPES_READVALUEID]));
QList<QOpcUaReadResult> resultMetadata;
size_t index = 0;
qt_forEachAttribute(attr, [&](QOpcUa::NodeAttribute attribute){
auto &current = req.nodesToRead[index++];
current.attributeId = QOpen62541ValueConverter::toUaAttributeId(attribute);
UA_NodeId_copy(&id, &current.nodeId);
if (indexRange.size())
QOpen62541ValueConverter::scalarFromQt<UA_String, QString>(indexRange, &current.indexRange);
QOpcUaReadResult temp;
temp.setAttribute(attribute);
resultMetadata.push_back(temp);
});
quint32 requestId = 0;
UA_StatusCode result = __UA_Client_AsyncService(m_uaclient, &req, &UA_TYPES[UA_TYPES_READREQUEST],
&asyncReadCallback, &UA_TYPES[UA_TYPES_READRESPONSE], this,
&requestId);
if (result != UA_STATUSCODE_GOOD) {
const auto statusCode = static_cast<QOpcUa::UaStatusCode>(result);
for (auto &entry : resultMetadata) {
entry.setStatusCode(statusCode);
}
emit attributesRead(handle, resultMetadata, statusCode);
return;
}
m_asyncReadContext[requestId] = { handle, resultMetadata };
triggerIterateClient();
}
void Open62541AsyncBackend::writeAttribute(quint64 handle, UA_NodeId id, QOpcUa::NodeAttribute attrId, QVariant value, QOpcUa::Types type, QString indexRange)
{
if (!m_uaclient) {
UA_NodeId_clear(&id);
emit attributeWritten(handle, attrId, value, QOpcUa::UaStatusCode::BadDisconnect);
return;
}
if (type == QOpcUa::Types::Undefined && attrId != QOpcUa::NodeAttribute::Value)
type = attributeIdToTypeId(attrId);
UA_WriteRequest req;
UA_WriteRequest_init(&req);
req.requestHeader.timeoutHint = m_asyncRequestTimeout;
UaDeleter<UA_WriteRequest> requestDeleter(&req, UA_WriteRequest_clear);
req.nodesToWriteSize = 1;
req.nodesToWrite = UA_WriteValue_new();
UA_WriteValue_init(req.nodesToWrite);
req.nodesToWrite->attributeId = QOpen62541ValueConverter::toUaAttributeId(attrId);
req.nodesToWrite->nodeId = id;
req.nodesToWrite->value.value = QOpen62541ValueConverter::toOpen62541Variant(value, type);
req.nodesToWrite->value.hasValue = true;
if (indexRange.size())
QOpen62541ValueConverter::scalarFromQt<UA_String, QString>(indexRange, &req.nodesToWrite->indexRange);
quint32 requestId = 0;
UA_StatusCode result = __UA_Client_AsyncService(m_uaclient, &req, &UA_TYPES[UA_TYPES_WRITEREQUEST],
&asyncWriteAttributesCallback, &UA_TYPES[UA_TYPES_WRITERESPONSE], this,
&requestId);
if (result != UA_STATUSCODE_GOOD) {
emit attributeWritten(handle, attrId, value, static_cast<QOpcUa::UaStatusCode>(result));
return;
}
m_asyncWriteAttributesContext[requestId] = { handle, {{attrId, value}} };
triggerIterateClient();
}
void Open62541AsyncBackend::writeAttributes(quint64 handle, UA_NodeId id, QOpcUaNode::AttributeMap toWrite, QOpcUa::Types valueAttributeType)
{
UaDeleter<UA_NodeId> nodeIdDeleter(&id, UA_NodeId_clear);
if (!m_uaclient) {
emit attributeWritten(handle, QOpcUa::NodeAttribute::None, QVariant(), QOpcUa::UaStatusCode::BadDisconnect);
return;
}
if (toWrite.size() == 0) {
qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "No values to be written";
emit attributeWritten(handle, QOpcUa::NodeAttribute::None, QVariant(), QOpcUa::UaStatusCode::BadNothingToDo);
return;
}
UA_WriteRequest req;
UA_WriteRequest_init(&req);
req.requestHeader.timeoutHint = m_asyncRequestTimeout;
UaDeleter<UA_WriteRequest> requestDeleter(&req, UA_WriteRequest_clear);
req.nodesToWriteSize = toWrite.size();
req.nodesToWrite = static_cast<UA_WriteValue *>(UA_Array_new(req.nodesToWriteSize, &UA_TYPES[UA_TYPES_WRITEVALUE]));
size_t index = 0;
for (auto it = toWrite.begin(); it != toWrite.end(); ++it, ++index) {
UA_WriteValue_init(&(req.nodesToWrite[index]));
req.nodesToWrite[index].attributeId = QOpen62541ValueConverter::toUaAttributeId(it.key());
UA_NodeId_copy(&id, &(req.nodesToWrite[index].nodeId));
QOpcUa::Types type = it.key() == QOpcUa::NodeAttribute::Value ? valueAttributeType : attributeIdToTypeId(it.key());
req.nodesToWrite[index].value.value = QOpen62541ValueConverter::toOpen62541Variant(it.value(), type);
}
quint32 requestId = 0;
UA_StatusCode result = __UA_Client_AsyncService(m_uaclient, &req, &UA_TYPES[UA_TYPES_WRITEREQUEST],
&asyncWriteAttributesCallback, &UA_TYPES[UA_TYPES_WRITERESPONSE], this,
&requestId);
if (result != UA_STATUSCODE_GOOD) {
for (auto it = toWrite.begin(); it != toWrite.end(); ++it) {
emit attributeWritten(handle, it.key(), it.value(), static_cast<QOpcUa::UaStatusCode>(result));
}
return;
}
m_asyncWriteAttributesContext[requestId] = { handle, toWrite };
triggerIterateClient();
}
void Open62541AsyncBackend::enableMonitoring(quint64 handle, UA_NodeId id, QOpcUa::NodeAttributes attr, const QOpcUaMonitoringParameters &settings)
{
UaDeleter<UA_NodeId> nodeIdDeleter(&id, UA_NodeId_clear);
if (!m_uaclient) {
qt_forEachAttribute(attr, [&](QOpcUa::NodeAttribute attribute){
QOpcUaMonitoringParameters s;
s.setStatusCode(QOpcUa::UaStatusCode::BadDisconnect);
emit monitoringEnableDisable(handle, attribute, true, s);
});
return;
}
QOpen62541Subscription *usedSubscription = nullptr;
// Create a new subscription if necessary
if (settings.subscriptionId()) {
auto sub = m_subscriptions.find(settings.subscriptionId());
if (sub == m_subscriptions.end()) {
qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "There is no subscription with id" << settings.subscriptionId();
qt_forEachAttribute(attr, [&](QOpcUa::NodeAttribute attribute){
QOpcUaMonitoringParameters s;
s.setStatusCode(QOpcUa::UaStatusCode::BadSubscriptionIdInvalid);
emit monitoringEnableDisable(handle, attribute, true, s);
});
return;
}
usedSubscription = sub.value(); // Ignore interval != subscription.interval
} else {
usedSubscription = getSubscription(settings);
}
if (!usedSubscription) {
qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Could not create subscription with interval" << settings.publishingInterval();
qt_forEachAttribute(attr, [&](QOpcUa::NodeAttribute attribute){
QOpcUaMonitoringParameters s;
s.setStatusCode(QOpcUa::UaStatusCode::BadSubscriptionIdInvalid);
emit monitoringEnableDisable(handle, attribute, true, s);
});
return;
}
qt_forEachAttribute(attr, [&](QOpcUa::NodeAttribute attribute){
if (getSubscriptionForItem(handle, attribute)) {
qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Monitored item for" << attribute << "has already been created";
QOpcUaMonitoringParameters s;
s.setStatusCode(QOpcUa::UaStatusCode::BadEntryExists);
emit monitoringEnableDisable(handle, attribute, true, s);
} else {
bool success = usedSubscription->addAttributeMonitoredItem(handle, attribute, id, settings);
if (success)
m_attributeMapping[handle][attribute] = usedSubscription;
}
});
if (usedSubscription->monitoredItemsCount() == 0)
removeSubscription(usedSubscription->subscriptionId()); // No items were added
}
void Open62541AsyncBackend::disableMonitoring(quint64 handle, QOpcUa::NodeAttributes attr)
{
if (!m_uaclient) {
qt_forEachAttribute(attr, [&](QOpcUa::NodeAttribute attribute){
QOpcUaMonitoringParameters s;
s.setStatusCode(QOpcUa::UaStatusCode::BadDisconnect);
emit monitoringEnableDisable(handle, attribute, false, s);
});
return;
}
qt_forEachAttribute(attr, [&](QOpcUa::NodeAttribute attribute){
QOpen62541Subscription *sub = getSubscriptionForItem(handle, attribute);
if (sub) {
sub->removeAttributeMonitoredItem(handle, attribute);
m_attributeMapping[handle].remove(attribute);
if (sub->monitoredItemsCount() == 0)
removeSubscription(sub->subscriptionId());
} else {
qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "There is no monitored item for this attribute";
QOpcUaMonitoringParameters s;
s.setStatusCode(QOpcUa::UaStatusCode::BadMonitoredItemIdInvalid);
emit monitoringEnableDisable(handle, attribute, false, s);
}
});
}
void Open62541AsyncBackend::modifyMonitoring(quint64 handle, QOpcUa::NodeAttribute attr, QOpcUaMonitoringParameters::Parameter item, QVariant value)
{
if (!m_uaclient) {
QOpcUaMonitoringParameters p;
p.setStatusCode(QOpcUa::UaStatusCode::BadDisconnect);
emit monitoringStatusChanged(handle, attr, item, p);
return;
}
QOpen62541Subscription *subscription = getSubscriptionForItem(handle, attr);
if (!subscription) {
qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Could not modify" << item << ", the monitored item does not exist";
QOpcUaMonitoringParameters p;
p.setStatusCode(QOpcUa::UaStatusCode::BadMonitoredItemIdInvalid);
emit monitoringStatusChanged(handle, attr, item, p);
return;
}
subscription->modifyMonitoring(handle, attr, item, value);
}
QOpen62541Subscription *Open62541AsyncBackend::getSubscription(const QOpcUaMonitoringParameters &settings)
{
if (settings.subscriptionType() == QOpcUaMonitoringParameters::SubscriptionType::Shared) {
// Requesting multiple subscriptions with publishing interval < minimum publishing interval breaks subscription sharing
double interval = revisePublishingInterval(settings.publishingInterval(), m_minPublishingInterval);
for (auto entry : std::as_const(m_subscriptions)) {
if (QtPrivate::fuzzyCompare(entry->interval(), interval) && entry->shared() == QOpcUaMonitoringParameters::SubscriptionType::Shared)
return entry;
}
}
QOpen62541Subscription *sub = new QOpen62541Subscription(this, settings);
UA_UInt32 id = sub->createOnServer();
if (!id) {
delete sub;
return nullptr;
}
m_subscriptions[id] = sub;
if (sub->interval() > settings.publishingInterval()) // The publishing interval has been revised by the server.
m_minPublishingInterval = sub->interval();
// This must be a queued connection to prevent the slot from being called while the client is inside UA_Client_run_iterate().
QObject::connect(sub, &QOpen62541Subscription::timeout, this, &Open62541AsyncBackend::handleSubscriptionTimeout, Qt::QueuedConnection);
return sub;
}
bool Open62541AsyncBackend::removeSubscription(UA_UInt32 subscriptionId)
{
auto sub = m_subscriptions.find(subscriptionId);
if (sub != m_subscriptions.end()) {
sub.value()->removeOnServer();
delete sub.value();
m_subscriptions.remove(subscriptionId);
return true;
}
return false;
}
void Open62541AsyncBackend::callMethod(quint64 handle, UA_NodeId objectId, UA_NodeId methodId, QList<QOpcUa::TypedVariant> args)
{
if (!m_uaclient) {
emit methodCallFinished(handle, Open62541Utils::nodeIdToQString(methodId), QVariant(), QOpcUa::UaStatusCode::BadDisconnect);
UA_NodeId_clear(&objectId);
UA_NodeId_clear(&methodId);
return;
}
UA_Variant *inputArgs = nullptr;
if (args.size()) {
inputArgs = static_cast<UA_Variant *>(UA_Array_new(args.size(), &UA_TYPES[UA_TYPES_VARIANT]));
for (qsizetype i = 0; i < args.size(); ++i)
inputArgs[i] = QOpen62541ValueConverter::toOpen62541Variant(args[i].first, args[i].second);
}
quint32 requestId = 0;
UA_CallRequest request;
UA_CallRequest_init(&request);
request.requestHeader.timeoutHint = m_asyncRequestTimeout;
UaDeleter<UA_CallRequest> requestDeleter(&request, UA_CallRequest_clear);
request.methodsToCallSize = 1;
request.methodsToCall = UA_CallMethodRequest_new();
request.methodsToCall->objectId = objectId;
request.methodsToCall->methodId = methodId;
request.methodsToCall->inputArguments = inputArgs;
request.methodsToCall->inputArgumentsSize = args.size();
UA_StatusCode result = __UA_Client_AsyncService(m_uaclient, &request, &UA_TYPES[UA_TYPES_CALLREQUEST],
&asyncMethodCallback,
&UA_TYPES[UA_TYPES_CALLRESPONSE],
this, &requestId);
if (result != UA_STATUSCODE_GOOD)
emit methodCallFinished(handle, Open62541Utils::nodeIdToQString(methodId), QVariant(),
static_cast<QOpcUa::UaStatusCode>(result));
m_asyncCallContext[requestId] = { handle, Open62541Utils::nodeIdToQString(methodId) };
triggerIterateClient();
}
void Open62541AsyncBackend::resolveBrowsePath(quint64 handle, UA_NodeId startNode, const QList<QOpcUaRelativePathElement> &path)
{
if (!m_uaclient) {
UA_NodeId_clear(&startNode);
emit resolveBrowsePathFinished(handle, {}, path, QOpcUa::UaStatusCode::BadDisconnect);
return;
}
UA_TranslateBrowsePathsToNodeIdsRequest req;
UA_TranslateBrowsePathsToNodeIdsRequest_init(&req);
req.requestHeader.timeoutHint = m_asyncRequestTimeout;
UaDeleter<UA_TranslateBrowsePathsToNodeIdsRequest> requestDeleter(
&req,UA_TranslateBrowsePathsToNodeIdsRequest_clear);
req.browsePathsSize = 1;
req.browsePaths = UA_BrowsePath_new();
UA_BrowsePath_init(req.browsePaths);
req.browsePaths->startingNode = startNode;
req.browsePaths->relativePath.elementsSize = path.size();
req.browsePaths->relativePath.elements = static_cast<UA_RelativePathElement *>(UA_Array_new(path.size(), &UA_TYPES[UA_TYPES_RELATIVEPATHELEMENT]));
for (qsizetype i = 0 ; i < path.size(); ++i) {
req.browsePaths->relativePath.elements[i].includeSubtypes = path[i].includeSubtypes();
req.browsePaths->relativePath.elements[i].isInverse = path[i].isInverse();
req.browsePaths->relativePath.elements[i].referenceTypeId = Open62541Utils::nodeIdFromQString(path[i].referenceTypeId());
req.browsePaths->relativePath.elements[i].targetName = UA_QUALIFIEDNAME_ALLOC(path[i].targetName().namespaceIndex(),
path[i].targetName().name().toUtf8().constData());
}
quint32 requestId = 0;
UA_StatusCode result = __UA_Client_AsyncService(m_uaclient, &req, &UA_TYPES[UA_TYPES_TRANSLATEBROWSEPATHSTONODEIDSREQUEST],
&asyncTranslateBrowsePathCallback,
&UA_TYPES[UA_TYPES_TRANSLATEBROWSEPATHSTONODEIDSRESPONSE],
this, &requestId);
if (result != UA_STATUSCODE_GOOD) {
qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Translate browse path failed:" << UA_StatusCode_name(result);
emit resolveBrowsePathFinished(handle, QList<QOpcUaBrowsePathTarget>(), path,
static_cast<QOpcUa::UaStatusCode>(result));
return;
}
m_asyncTranslateContext[requestId] = { handle, path };
triggerIterateClient();
}
void Open62541AsyncBackend::open62541LogHandler (void *logContext, UA_LogLevel level, UA_LogCategory category,
const char *msg, va_list args) {
Q_UNUSED(logContext)
Q_STATIC_ASSERT(UA_LOGCATEGORY_NETWORK == 0);
Q_STATIC_ASSERT(UA_LOGCATEGORY_SECURECHANNEL == 1);
Q_STATIC_ASSERT(UA_LOGCATEGORY_SESSION == 2);
Q_STATIC_ASSERT(UA_LOGCATEGORY_SERVER == 3);
Q_STATIC_ASSERT(UA_LOGCATEGORY_CLIENT == 4);
Q_STATIC_ASSERT(UA_LOGCATEGORY_USERLAND == 5);
Q_STATIC_ASSERT(UA_LOGCATEGORY_SECURITYPOLICY == 6);
Q_STATIC_ASSERT(UA_LOGCATEGORY_EVENTLOOP == 7);
Q_STATIC_ASSERT(UA_LOGCATEGORY_PUBSUB == 8);
Q_STATIC_ASSERT(UA_LOGCATEGORY_DISCOVERY == 9);
Q_ASSERT(category <= UA_LOGCATEGORY_DISCOVERY);
// The size used by the open62541 default logger
const size_t bufferSize = 512;
char buffer[bufferSize]{};
UA_String bufferStr { bufferSize, reinterpret_cast<quint8 *>(buffer) };
const auto res = UA_String_vformat(&bufferStr, msg, args);
const auto logMessage = res == UA_STATUSCODE_GOOD ? QString::fromUtf8(buffer)
: u"Failed to format log message: %1"_s.arg(msg);
static const QLoggingCategory loggingCategories[] {
QLoggingCategory("qt.opcua.plugins.open62541.sdk.network"),
QLoggingCategory("qt.opcua.plugins.open62541.sdk.securechannel"),
QLoggingCategory("qt.opcua.plugins.open62541.sdk.session"),
QLoggingCategory("qt.opcua.plugins.open62541.sdk.server"),
QLoggingCategory("qt.opcua.plugins.open62541.sdk.client"),
QLoggingCategory("qt.opcua.plugins.open62541.sdk.userland"),
QLoggingCategory("qt.opcua.plugins.open62541.sdk.securitypolicy"),
QLoggingCategory("qt.opcua.plugins.open62541.sdk.eventloop"),
QLoggingCategory("qt.opcua.plugins.open62541.sdk.pubsub"),
QLoggingCategory("qt.opcua.plugins.open62541.sdk.discovery")
};
switch (level) {
case UA_LOGLEVEL_TRACE:
case UA_LOGLEVEL_DEBUG:
qCDebug(loggingCategories[category]).noquote() << logMessage;
break;
case UA_LOGLEVEL_INFO:
qCInfo(loggingCategories[category]).noquote() << logMessage;
break;
case UA_LOGLEVEL_WARNING:
qCWarning(loggingCategories[category]).noquote() << logMessage;
break;
case UA_LOGLEVEL_ERROR:
case UA_LOGLEVEL_FATAL:
qCCritical(loggingCategories[category]).noquote() << logMessage;
break;
default:
qCCritical(loggingCategories[category]).noquote() << "Unknown UA_LOGLEVEL" << logMessage;
break;
}
}
void Open62541AsyncBackend::findServers(const QUrl &url, const QStringList &localeIds, const QStringList &serverUris)
{
UA_ClientConfig initialConfig {};
initialConfig.logging = &m_open62541Logger;
UA_ClientConfig_setDefault(&initialConfig);
UA_Client *tmpClient = UA_Client_newWithConfig(&initialConfig);
UaDeleter<UA_Client> clientDeleter(tmpClient, UA_Client_delete);
UA_String *uaServerUris = nullptr;
if (!serverUris.isEmpty()) {
uaServerUris = static_cast<UA_String *>(UA_Array_new(serverUris.size(), &UA_TYPES[UA_TYPES_STRING]));
for (qsizetype i = 0; i < serverUris.size(); ++i)
QOpen62541ValueConverter::scalarFromQt(serverUris.at(i), &uaServerUris[i]);
}
UaArrayDeleter<UA_TYPES_STRING> serverUrisDeleter(uaServerUris, serverUris.size());
UA_String *uaLocaleIds = nullptr;
if (!localeIds.isEmpty()) {
uaLocaleIds = static_cast<UA_String *>(UA_Array_new(localeIds.size(), &UA_TYPES[UA_TYPES_STRING]));
for (qsizetype i = 0; i < localeIds.size(); ++i)
QOpen62541ValueConverter::scalarFromQt(localeIds.at(i), &uaLocaleIds[i]);
}
UaArrayDeleter<UA_TYPES_STRING> localeIdsDeleter(uaLocaleIds, localeIds.size());
size_t serversSize = 0;
UA_ApplicationDescription *servers = nullptr;
UA_StatusCode result = UA_Client_findServers(tmpClient, url.toString(QUrl::RemoveUserInfo).toUtf8().constData(),
serverUris.size(), uaServerUris, localeIds.size(), uaLocaleIds,
&serversSize, &servers);
UaArrayDeleter<UA_TYPES_APPLICATIONDESCRIPTION> serversDeleter(servers, serversSize);
QList<QOpcUaApplicationDescription> ret;
for (size_t i = 0; i < serversSize; ++i)
ret.append(QOpen62541ValueConverter::scalarToQt<QOpcUaApplicationDescription>(&servers[i]));
if (result != UA_STATUSCODE_GOOD) {
qCDebug(QT_OPCUA_PLUGINS_OPEN62541) << "Failed to get servers:" << static_cast<QOpcUa::UaStatusCode>(result);
}
emit findServersFinished(ret, static_cast<QOpcUa::UaStatusCode>(result), url);
}
void Open62541AsyncBackend::readNodeAttributes(const QList<QOpcUaReadItem> &nodesToRead)
{
if (!m_uaclient) {
emit readNodeAttributesFinished({}, QOpcUa::UaStatusCode::BadDisconnect);
return;
}
if (nodesToRead.size() == 0) {
emit readNodeAttributesFinished(QList<QOpcUaReadResult>(), QOpcUa::UaStatusCode::BadNothingToDo);
return;
}
UA_ReadRequest req;
UA_ReadRequest_init(&req);
req.requestHeader.timeoutHint = m_asyncRequestTimeout;
UaDeleter<UA_ReadRequest> requestDeleter(&req, UA_ReadRequest_clear);
req.nodesToReadSize = nodesToRead.size();
req.nodesToRead = static_cast<UA_ReadValueId *>(UA_Array_new(nodesToRead.size(), &UA_TYPES[UA_TYPES_READVALUEID]));
req.timestampsToReturn = UA_TIMESTAMPSTORETURN_BOTH;
for (qsizetype i = 0; i < nodesToRead.size(); ++i) {
UA_ReadValueId_init(&req.nodesToRead[i]);
req.nodesToRead[i].attributeId = QOpen62541ValueConverter::toUaAttributeId(nodesToRead.at(i).attribute());
req.nodesToRead[i].nodeId = Open62541Utils::nodeIdFromQString(nodesToRead.at(i).nodeId());
if (!nodesToRead[i].indexRange().isEmpty())
QOpen62541ValueConverter::scalarFromQt<UA_String, QString>(nodesToRead.at(i).indexRange(),
&req.nodesToRead[i].indexRange);
}
quint32 requestId = 0;
UA_StatusCode result = __UA_Client_AsyncService(m_uaclient, &req, &UA_TYPES[UA_TYPES_READREQUEST], &asyncBatchReadCallback,
&UA_TYPES[UA_TYPES_READRESPONSE], this, &requestId);
if (result != UA_STATUSCODE_GOOD) {
qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Batch read failed:" << result;
emit readNodeAttributesFinished(QList<QOpcUaReadResult>(), static_cast<QOpcUa::UaStatusCode>(result));
return;
}
m_asyncBatchReadContext[requestId] = { nodesToRead };
triggerIterateClient();
}
void Open62541AsyncBackend::writeNodeAttributes(const QList<QOpcUaWriteItem> &nodesToWrite)
{
if (!m_uaclient) {
emit writeNodeAttributesFinished({}, QOpcUa::UaStatusCode::BadDisconnect);
return;
}
if (nodesToWrite.isEmpty()) {
emit writeNodeAttributesFinished(QList<QOpcUaWriteResult>(), QOpcUa::UaStatusCode::BadNothingToDo);
return;
}
UA_WriteRequest req;
UA_WriteRequest_init(&req);
req.requestHeader.timeoutHint = m_asyncRequestTimeout;
UaDeleter<UA_WriteRequest> requestDeleter(&req, UA_WriteRequest_clear);
req.nodesToWriteSize = nodesToWrite.size();
req.nodesToWrite = static_cast<UA_WriteValue *>(UA_Array_new(nodesToWrite.size(), &UA_TYPES[UA_TYPES_WRITEVALUE]));
for (qsizetype i = 0; i < nodesToWrite.size(); ++i) {
const auto &currentItem = nodesToWrite.at(i);
auto &currentUaItem = req.nodesToWrite[i];
currentUaItem.attributeId = QOpen62541ValueConverter::toUaAttributeId(currentItem.attribute());
currentUaItem.nodeId = Open62541Utils::nodeIdFromQString(currentItem.nodeId());
if (currentItem.hasStatusCode()) {
currentUaItem.value.status = currentItem.statusCode();
currentUaItem.value.hasStatus = UA_TRUE;
}
if (!currentItem.indexRange().isEmpty())
QOpen62541ValueConverter::scalarFromQt<UA_String, QString>(currentItem.indexRange(), &currentUaItem.indexRange);
if (!currentItem.value().isNull()) {
currentUaItem.value.hasValue = true;
currentUaItem.value.value = QOpen62541ValueConverter::toOpen62541Variant(currentItem.value(), currentItem.type());
}
if (currentItem.sourceTimestamp().isValid()) {
QOpen62541ValueConverter::scalarFromQt<UA_DateTime, QDateTime>(currentItem.sourceTimestamp(),
&currentUaItem.value.sourceTimestamp);
currentUaItem.value.hasSourceTimestamp = UA_TRUE;
}
if (currentItem.serverTimestamp().isValid()) {
QOpen62541ValueConverter::scalarFromQt<UA_DateTime, QDateTime>(currentItem.serverTimestamp(),
&currentUaItem.value.serverTimestamp);
currentUaItem.value.hasServerTimestamp = UA_TRUE;
}
}
quint32 requestId = 0;
UA_StatusCode result = __UA_Client_AsyncService(m_uaclient, &req, &UA_TYPES[UA_TYPES_WRITEREQUEST], &asyncBatchWriteCallback,
&UA_TYPES[UA_TYPES_WRITERESPONSE], this, &requestId);
if (result != UA_STATUSCODE_GOOD) {
qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Batch write failed:" << result;
emit writeNodeAttributesFinished(QList<QOpcUaWriteResult>(), static_cast<QOpcUa::UaStatusCode>(result));
return;
}
m_asyncBatchWriteContext[requestId] = { nodesToWrite };
triggerIterateClient();
}
void Open62541AsyncBackend::readHistoryRaw(QOpcUaHistoryReadRawRequest request, QList<QByteArray> continuationPoints, bool releaseContinuationPoints, quint64 handle)
{
if (!m_uaclient) {
emit historyDataAvailable({}, {}, QOpcUa::UaStatusCode::BadDisconnect, handle);
return;
}
if (!continuationPoints.empty() && continuationPoints.size() != request.nodesToRead().size()) {
emit historyDataAvailable({}, {}, QOpcUa::UaStatusCode::BadInternalError, handle);
return;
}
UA_HistoryReadRequest uarequest;
UA_HistoryReadRequest_init(&uarequest);
uarequest.requestHeader.timeoutHint = m_asyncRequestTimeout;
uarequest.nodesToReadSize = request.nodesToRead().size();
uarequest.nodesToRead = static_cast<UA_HistoryReadValueId*>(UA_Array_new(uarequest.nodesToReadSize, &UA_TYPES[UA_TYPES_HISTORYREADVALUEID]));
for (size_t i = 0; i < uarequest.nodesToReadSize; ++i) {
uarequest.nodesToRead[i].nodeId = Open62541Utils::nodeIdFromQString(request.nodesToRead().at(i).nodeId());
QOpen62541ValueConverter::scalarFromQt<UA_String, QString>(request.nodesToRead().at(i).indexRange(), &uarequest.nodesToRead[i].indexRange);
uarequest.nodesToRead[i].dataEncoding = UA_QUALIFIEDNAME_ALLOC(0, "Default Binary");
if (!continuationPoints.isEmpty())
QOpen62541ValueConverter::scalarFromQt<UA_ByteString, QByteArray>(continuationPoints.at(i), &uarequest.nodesToRead[i].continuationPoint);
}
uarequest.timestampsToReturn = static_cast<UA_TimestampsToReturn>(request.timestampsToReturn());
if (releaseContinuationPoints)
uarequest.releaseContinuationPoints = releaseContinuationPoints;
uarequest.historyReadDetails.encoding = UA_EXTENSIONOBJECT_DECODED;
uarequest.historyReadDetails.content.decoded.type = &UA_TYPES[UA_TYPES_READRAWMODIFIEDDETAILS];
UA_ReadRawModifiedDetails *details = UA_ReadRawModifiedDetails_new();
uarequest.historyReadDetails.content.decoded.data = details;
QOpen62541ValueConverter::scalarFromQt<UA_DateTime, QDateTime>(request.startTimestamp(), &details->startTime);
QOpen62541ValueConverter::scalarFromQt<UA_DateTime, QDateTime>(request.endTimestamp(), &details->endTime);
details->isReadModified = UA_FALSE;
details->returnBounds = request.returnBounds();
details->numValuesPerNode = request.numValuesPerNode();
quint32 requestId = 0;
UA_StatusCode resultCode = __UA_Client_AsyncService(m_uaclient, &uarequest, &UA_TYPES[UA_TYPES_HISTORYREADREQUEST], &asyncReadHistoryDataCallBack,
&UA_TYPES[UA_TYPES_HISTORYREADRESPONSE], this, &requestId);
UA_HistoryReadRequest_clear(&uarequest);
if (resultCode != UA_STATUSCODE_GOOD) {
qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Read history data failed:" << resultCode;
emit historyDataAvailable({}, {}, QOpcUa::UaStatusCode(resultCode), handle);
return;
}
m_asyncReadHistoryDataContext[requestId] = {handle, request};
triggerIterateClient();
}
void Open62541AsyncBackend::readHistoryEvents(const QOpcUaHistoryReadEventRequest &request, const QList<QByteArray> &continuationPoints,
bool releaseContinuationPoints, quint64 handle)
{
if (!m_uaclient) {
emit historyDataAvailable({}, {}, QOpcUa::UaStatusCode::BadDisconnect, handle);
return;
}
if (!continuationPoints.empty() && continuationPoints.size() != request.nodesToRead().size()) {
emit historyDataAvailable({}, {}, QOpcUa::UaStatusCode::BadInternalError, handle);
return;
}
UA_HistoryReadRequest uarequest;
UA_HistoryReadRequest_init(&uarequest);
uarequest.requestHeader.timeoutHint = m_asyncRequestTimeout;
uarequest.nodesToReadSize = request.nodesToRead().size();
uarequest.nodesToRead = static_cast<UA_HistoryReadValueId*>(UA_Array_new(uarequest.nodesToReadSize, &UA_TYPES[UA_TYPES_HISTORYREADVALUEID]));
for (size_t i = 0; i < uarequest.nodesToReadSize; ++i) {
uarequest.nodesToRead[i].nodeId = Open62541Utils::nodeIdFromQString(request.nodesToRead().at(i).nodeId());
QOpen62541ValueConverter::scalarFromQt<UA_String, QString>(request.nodesToRead().at(i).indexRange(), &uarequest.nodesToRead[i].indexRange);
uarequest.nodesToRead[i].dataEncoding = UA_QUALIFIEDNAME_ALLOC(0, "Default Binary");
if (!continuationPoints.isEmpty())
QOpen62541ValueConverter::scalarFromQt<UA_ByteString, QByteArray>(continuationPoints.at(i), &uarequest.nodesToRead[i].continuationPoint);
}
uarequest.timestampsToReturn = UA_TIMESTAMPSTORETURN_BOTH;
if (releaseContinuationPoints)
uarequest.releaseContinuationPoints = releaseContinuationPoints;
uarequest.historyReadDetails.encoding = UA_EXTENSIONOBJECT_DECODED;
uarequest.historyReadDetails.content.decoded.type = &UA_TYPES[UA_TYPES_READEVENTDETAILS];
UA_ReadEventDetails *details = UA_ReadEventDetails_new();
uarequest.historyReadDetails.content.decoded.data = details;
QOpen62541ValueConverter::scalarFromQt<UA_DateTime, QDateTime>(request.startTimestamp(), &details->startTime);
QOpen62541ValueConverter::scalarFromQt<UA_DateTime, QDateTime>(request.endTimestamp(), &details->endTime);
details->numValuesPerNode = request.numValuesPerNode();
QOpen62541ValueConverter::scalarFromQt<UA_EventFilter, QOpcUaMonitoringParameters::EventFilter>(request.filter(), &details->filter);
quint32 requestId = 0;
UA_StatusCode resultCode = __UA_Client_AsyncService(m_uaclient, &uarequest, &UA_TYPES[UA_TYPES_HISTORYREADREQUEST], &asyncReadHistoryEventsCallback,
&UA_TYPES[UA_TYPES_HISTORYREADRESPONSE], this, &requestId);
UA_HistoryReadRequest_clear(&uarequest);
if (resultCode != UA_STATUSCODE_GOOD) {
qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Read history data failed:" << resultCode;
emit historyDataAvailable({}, {}, QOpcUa::UaStatusCode(resultCode), handle);
return;
}
m_asyncReadHistoryEventsContext[requestId] = {handle, request};
triggerIterateClient();
}
void Open62541AsyncBackend::addNode(const QOpcUaAddNodeItem &nodeToAdd)
{
if (!m_uaclient) {
emit addNodeFinished(nodeToAdd.requestedNewNodeId(), {}, QOpcUa::UaStatusCode::BadDisconnect);
return;
}
UA_AddNodesRequest req;
UA_AddNodesRequest_init(&req);
req.requestHeader.timeoutHint = m_asyncRequestTimeout;
UaDeleter<UA_AddNodesRequest> requestDeleter(&req, UA_AddNodesRequest_clear);
req.nodesToAddSize = 1;
req.nodesToAdd = UA_AddNodesItem_new();
UA_AddNodesItem_init(req.nodesToAdd);
QOpen62541ValueConverter::scalarFromQt<UA_ExpandedNodeId, QOpcUaExpandedNodeId>(
nodeToAdd.parentNodeId(), &req.nodesToAdd->parentNodeId);
req.nodesToAdd->referenceTypeId = Open62541Utils::nodeIdFromQString(nodeToAdd.referenceTypeId());
QOpen62541ValueConverter::scalarFromQt<UA_ExpandedNodeId, QOpcUaExpandedNodeId>(
nodeToAdd.requestedNewNodeId(), &req.nodesToAdd->requestedNewNodeId);
QOpen62541ValueConverter::scalarFromQt<UA_QualifiedName, QOpcUaQualifiedName>(
nodeToAdd.browseName(), &req.nodesToAdd->browseName);
req.nodesToAdd->nodeClass = static_cast<UA_NodeClass>(nodeToAdd.nodeClass());
req.nodesToAdd->nodeAttributes = QOpen62541ValueConverter::nodeCreationAttributesToUa(
nodeToAdd.nodeAttributes(),
nodeToAdd.nodeClass());
if (!nodeToAdd.typeDefinition().nodeId().isEmpty())
QOpen62541ValueConverter::scalarFromQt<UA_ExpandedNodeId, QOpcUaExpandedNodeId>(
nodeToAdd.typeDefinition(), &req.nodesToAdd->typeDefinition);
quint32 requestId = 0;
UA_StatusCode result = __UA_Client_AsyncService(m_uaclient, &req, &UA_TYPES[UA_TYPES_ADDNODESREQUEST],
&asyncAddNodeCallback,
&UA_TYPES[UA_TYPES_ADDNODESRESPONSE],
this, &requestId);
if (result != UA_STATUSCODE_GOOD) {
qCDebug(QT_OPCUA_PLUGINS_OPEN62541) << "Failed to add node:" << result;
emit addNodeFinished(nodeToAdd.requestedNewNodeId(), QString(), static_cast<QOpcUa::UaStatusCode>(result));
return;
}
m_asyncAddNodeContext[requestId] = { nodeToAdd.requestedNewNodeId() };
triggerIterateClient();
}
void Open62541AsyncBackend::deleteNode(const QString &nodeId, bool deleteTargetReferences)
{
if (!m_uaclient) {
emit deleteNodeFinished(nodeId, QOpcUa::UaStatusCode::BadDisconnect);
return;
}
UA_DeleteNodesRequest request;
UA_DeleteNodesRequest_init(&request);
request.requestHeader.timeoutHint = m_asyncRequestTimeout;
UaDeleter<UA_DeleteNodesRequest> requestDeleter(&request, UA_DeleteNodesRequest_clear);
request.nodesToDeleteSize = 1;
request.nodesToDelete = UA_DeleteNodesItem_new();
request.nodesToDelete->nodeId = Open62541Utils::nodeIdFromQString(nodeId);
request.nodesToDelete->deleteTargetReferences = deleteTargetReferences;
quint32 requestId = 0;
UA_StatusCode result = __UA_Client_AsyncService(m_uaclient, &request, &UA_TYPES[UA_TYPES_DELETENODESREQUEST],
&asyncDeleteNodeCallback,
&UA_TYPES[UA_TYPES_DELETENODESRESPONSE],
this, &requestId);
QOpcUa::UaStatusCode resultStatus = static_cast<QOpcUa::UaStatusCode>(result);
if (result != QOpcUa::UaStatusCode::Good) {
qCDebug(QT_OPCUA_PLUGINS_OPEN62541) << "Failed to delete node" << nodeId << "with status code" << resultStatus;
emit deleteNodeFinished(nodeId, resultStatus);
return;
}
m_asyncDeleteNodeContext[requestId] = { nodeId };
triggerIterateClient();
}
void Open62541AsyncBackend::addReference(const QOpcUaAddReferenceItem &referenceToAdd)
{
if (!m_uaclient) {
emit addReferenceFinished(referenceToAdd.sourceNodeId(), referenceToAdd.referenceTypeId(),
referenceToAdd.targetNodeId(), referenceToAdd.isForwardReference(),
QOpcUa::UaStatusCode::BadDisconnect);
return;
}
UA_AddReferencesRequest request;
UA_AddReferencesRequest_init(&request);
request.requestHeader.timeoutHint = m_asyncRequestTimeout;
UaDeleter<UA_AddReferencesRequest> requestDeleter(&request, UA_AddReferencesRequest_clear);
request.referencesToAddSize = 1;
request.referencesToAdd = UA_AddReferencesItem_new();
request.referencesToAdd->isForward = referenceToAdd.isForwardReference();
QOpen62541ValueConverter::scalarFromQt<UA_NodeId, QString>(referenceToAdd.sourceNodeId(),
&request.referencesToAdd->sourceNodeId);
QOpen62541ValueConverter::scalarFromQt<UA_ExpandedNodeId, QOpcUaExpandedNodeId>(referenceToAdd.targetNodeId(),
&request.referencesToAdd->targetNodeId);
QOpen62541ValueConverter::scalarFromQt<UA_NodeId, QString>(referenceToAdd.referenceTypeId(),
&request.referencesToAdd->referenceTypeId);
request.referencesToAdd->targetNodeClass = static_cast<UA_NodeClass>(referenceToAdd.targetNodeClass());
QOpen62541ValueConverter::scalarFromQt<UA_String, QString>(referenceToAdd.targetServerUri(),
&request.referencesToAdd->targetServerUri);
quint32 requestId = 0;
UA_StatusCode result = __UA_Client_AsyncService(m_uaclient, &request, &UA_TYPES[UA_TYPES_ADDREFERENCESREQUEST],
&asyncAddReferenceCallback,
&UA_TYPES[UA_TYPES_ADDREFERENCESRESPONSE],
this, &requestId);
QOpcUa::UaStatusCode statusCode = static_cast<QOpcUa::UaStatusCode>(result);
if (result != UA_STATUSCODE_GOOD) {
qCDebug(QT_OPCUA_PLUGINS_OPEN62541) << "Failed to add reference from" << referenceToAdd.sourceNodeId() << "to"
<< referenceToAdd.targetNodeId().nodeId() << ":" << statusCode;
emit addReferenceFinished(referenceToAdd.sourceNodeId(), referenceToAdd.referenceTypeId(),
referenceToAdd.targetNodeId(), referenceToAdd.isForwardReference(), statusCode);
return;
}
m_asyncAddReferenceContext[requestId] = { referenceToAdd.sourceNodeId(), referenceToAdd.referenceTypeId(),
referenceToAdd.targetNodeId(), referenceToAdd.isForwardReference() };
triggerIterateClient();
}
void Open62541AsyncBackend::deleteReference(const QOpcUaDeleteReferenceItem &referenceToDelete)
{
if (!m_uaclient) {
emit deleteReferenceFinished(referenceToDelete.sourceNodeId(), referenceToDelete.referenceTypeId(),
referenceToDelete.targetNodeId(), referenceToDelete.isForwardReference(),
QOpcUa::UaStatusCode::BadDisconnect);
return;
}
UA_DeleteReferencesRequest request;
UA_DeleteReferencesRequest_init(&request);
request.requestHeader.timeoutHint = m_asyncRequestTimeout;
UaDeleter<UA_DeleteReferencesRequest> requestDeleter(&request, UA_DeleteReferencesRequest_clear);
request.referencesToDeleteSize = 1;
request.referencesToDelete = UA_DeleteReferencesItem_new();
request.referencesToDelete->isForward = referenceToDelete.isForwardReference();
QOpen62541ValueConverter::scalarFromQt<UA_NodeId, QString>(referenceToDelete.sourceNodeId(),
&request.referencesToDelete->sourceNodeId);
QOpen62541ValueConverter::scalarFromQt<UA_ExpandedNodeId, QOpcUaExpandedNodeId>(referenceToDelete.targetNodeId(),
&request.referencesToDelete->targetNodeId);
QOpen62541ValueConverter::scalarFromQt<UA_NodeId, QString>(referenceToDelete.referenceTypeId(),
&request.referencesToDelete->referenceTypeId);
request.referencesToDelete->deleteBidirectional = referenceToDelete.deleteBidirectional();
quint32 requestId = 0;
UA_StatusCode result = __UA_Client_AsyncService(m_uaclient, &request, &UA_TYPES[UA_TYPES_DELETEREFERENCESREQUEST],
&asyncDeleteReferenceCallback,
&UA_TYPES[UA_TYPES_DELETEREFERENCESRESPONSE],
this, &requestId);
QOpcUa::UaStatusCode statusCode = static_cast<QOpcUa::UaStatusCode>(result);
if (result != UA_STATUSCODE_GOOD) {
qCDebug(QT_OPCUA_PLUGINS_OPEN62541) << "Failed to delete reference from" << referenceToDelete.sourceNodeId() << "to"
<< referenceToDelete.targetNodeId().nodeId() << ":" << statusCode;
emit deleteReferenceFinished(referenceToDelete.sourceNodeId(), referenceToDelete.referenceTypeId(),
referenceToDelete.targetNodeId(),
referenceToDelete.isForwardReference(), statusCode);
return;
}
m_asyncDeleteReferenceContext[requestId] = { referenceToDelete.sourceNodeId(), referenceToDelete.referenceTypeId(),
referenceToDelete.targetNodeId(), referenceToDelete.isForwardReference()};
triggerIterateClient();
}
void Open62541AsyncBackend::browse(quint64 handle, UA_NodeId id, const QOpcUaBrowseRequest &request)
{
if (!m_uaclient) {
emit browseFinished(handle, {}, QOpcUa::UaStatusCode::BadDisconnect);
return;
}
UA_BrowseRequest uaRequest;
UA_BrowseRequest_init(&uaRequest);
uaRequest.requestHeader.timeoutHint = m_asyncRequestTimeout;
UaDeleter<UA_BrowseRequest> requestDeleter(&uaRequest, UA_BrowseRequest_clear);
uaRequest.nodesToBrowse = UA_BrowseDescription_new();
uaRequest.nodesToBrowseSize = 1;
uaRequest.nodesToBrowse->browseDirection = static_cast<UA_BrowseDirection>(request.browseDirection());
uaRequest.nodesToBrowse->includeSubtypes = request.includeSubtypes();
uaRequest.nodesToBrowse->nodeClassMask = static_cast<quint32>(request.nodeClassMask());
uaRequest.nodesToBrowse->nodeId = id;
uaRequest.nodesToBrowse->resultMask = UA_BROWSERESULTMASK_ALL;
uaRequest.nodesToBrowse->referenceTypeId = Open62541Utils::nodeIdFromQString(request.referenceTypeId());
uaRequest.requestedMaxReferencesPerNode = 0; // Let the server choose a maximum value
quint32 requestId = 0;
UA_StatusCode result = __UA_Client_AsyncService(m_uaclient, &uaRequest, &UA_TYPES[UA_TYPES_BROWSEREQUEST], &asyncBrowseCallback,
&UA_TYPES[UA_TYPES_BROWSERESPONSE], this, &requestId);
if (result != UA_STATUSCODE_GOOD) {
emit browseFinished(handle, QList<QOpcUaReferenceDescription>(), static_cast<QOpcUa::UaStatusCode>(result));
return;
}
m_asyncBrowseContext[requestId] = { handle, false, QList<QOpcUaReferenceDescription>() };
triggerIterateClient();
}
void Open62541AsyncBackend::clientStateCallback(UA_Client *client,
UA_SecureChannelState channelState,
UA_SessionState sessionState,
UA_StatusCode connectStatus)
{
Q_UNUSED(channelState)
Q_UNUSED(sessionState)
Q_UNUSED(connectStatus)
Open62541AsyncBackend *backend = static_cast<Open62541AsyncBackend *>(UA_Client_getContext(client));
if (!backend)
return;
// The connection is gone, no need to keep iterating
backend->m_clientIterateTimer.stop();
backend->m_clientIterateOnDemandTimer.stop();
// UA_Client_disconnect() must be called from outside this callback
QMetaObject::invokeMethod(backend, [backend]() {
backend->disconnectInternal(QOpcUaClient::ConnectionError);
}, Qt::QueuedConnection);
}
void Open62541AsyncBackend::inactivityCallback(UA_Client *client)
{
// The client state callback is not called if the background check encounters a timeout.
// This call triggers the disconnect and the appropriate state change
clientStateCallback(client, UA_SECURECHANNELSTATE_CLOSED, UA_SESSIONSTATE_CLOSED, UA_STATUSCODE_BADTIMEOUT);
}
void Open62541AsyncBackend::connectToEndpoint(const QOpcUaEndpointDescription &endpoint)
{
disconnectInternal();
emit stateAndOrErrorChanged(QOpcUaClient::Connecting, QOpcUaClient::NoError);
QString errorMessage;
const auto endpointError = verifyEndpointDescription(endpoint, &errorMessage);
if (endpointError != QOpcUaClient::ClientError::NoError) {
qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << errorMessage;
emit stateAndOrErrorChanged(QOpcUaClient::Disconnected, endpointError);
return;
}
#ifdef UA_ENABLE_ENCRYPTION
const auto pkiConfig = m_clientImpl->m_client->pkiConfiguration();
#endif
if (!m_clientImpl->supportedSecurityPolicies().contains(endpoint.securityPolicy())
#ifdef UA_ENABLE_ENCRYPTION
|| (!pkiConfig.isKeyAndCertificateFileSet() && endpoint.securityPolicy() != QOpcUa::NonePolicy)
#endif
) {
#ifndef UA_ENABLE_ENCRYPTION
qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "The open62541 plugin has been built without encryption support, only the"
<< QOpcUa::NonePolicy << "security policy is supported";
#endif
qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Unsupported security policy:" << endpoint.securityPolicy();
#ifdef UA_ENABLE_ENCRYPTION
if (!pkiConfig.isKeyAndCertificateFileSet()) {
qCWarning(QT_OPCUA_PLUGINS_OPEN62541)
<< "No certificate and private key is set, only the" << QOpcUa::NonePolicy << "security policy is supported";
}
#endif
emit stateAndOrErrorChanged(QOpcUaClient::Disconnected, QOpcUaClient::ClientError::UnsupportedSecurityPolicy);
return;
}
const auto identity = m_clientImpl->m_client->applicationIdentity();
const auto authInfo = m_clientImpl->m_client->authenticationInformation();
if (authInfo.authenticationType() == QOpcUaUserTokenPolicy::TokenType::Certificate) {
#ifndef UA_ENABLE_ENCRYPTION
qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "The open62541 plugin has been built without encryption support, "
"certificate auth is not supported";
emit stateAndOrErrorChanged(QOpcUaClient::Disconnected,
QOpcUaClient::ClientError::UnsupportedAuthenticationInformation);
return;
#else
if (!authInfo.authenticationData().isValid() && !pkiConfig.isKeyAndCertificateFileSet()) {
qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Unable to do certificate auth when no certificate is set";
emit stateAndOrErrorChanged(QOpcUaClient::Disconnected,
QOpcUaClient::ClientError::InvalidAuthenticationInformation);
return;
}
#endif
}
// Possible early out if no token matching the configuration and the client's capabilities is available
// If the token's security policy URI is not None, at least a certificate and a private key must be set
bool suitableTokenFound = false;
const auto userIdentityTokens = endpoint.userIdentityTokens();
for (const auto &token : userIdentityTokens) {
// An empty security policy URI means that the endpoint's policy is to be used
const auto tokenPolicy = token.securityPolicy().isEmpty() ? endpoint.securityPolicy() : token.securityPolicy();
if (token.tokenType() == authInfo.authenticationType() &&
m_clientImpl->supportedSecurityPolicies().contains(tokenPolicy) &&
#ifdef UA_ENABLE_ENCRYPTION
(tokenPolicy == QOpcUa::NonePolicy || pkiConfig.isKeyAndCertificateFileSet())
#else
tokenPolicy == QOpcUa::NonePolicy
#endif
) {
suitableTokenFound = true;
break;
}
}
if (!suitableTokenFound) {
qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "No suitable identity token found in the endpoint";
qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Availabe tokens in the endpoint:";
for (const auto &token : userIdentityTokens) {
qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << " Type:" << token.tokenType()
<< "SecurityPolicyUri:" << token.securityPolicy();
}
emit stateAndOrErrorChanged(QOpcUaClient::Disconnected,
QOpcUaClient::ClientError::NoMatchingUserIdentityTokenFound);
return;
}
UA_ClientConfig initialConfig {};
initialConfig.logging = &m_open62541Logger;
m_uaclient = UA_Client_newWithConfig(&initialConfig);
auto conf = UA_Client_getConfig(m_uaclient);
m_currentConnectionSettings = m_clientImpl->m_client->connectionSettings();
#ifdef UA_ENABLE_ENCRYPTION
if (!setupClientConfigSecurity(authInfo, pkiConfig, endpoint))
return;
#else
const auto setDefaultResult = UA_ClientConfig_setDefault(conf);
if (setDefaultResult != UA_STATUSCODE_GOOD) {
qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Failed to set client config defaults:" << static_cast<QOpcUa::UaStatusCode>(setDefaultResult);
emit stateAndOrErrorChanged(QOpcUaClient::Disconnected, QOpcUaClient::UnknownError);
UA_Client_delete(m_uaclient);
m_uaclient = nullptr;
return;
}
#endif
using Timeout_t = decltype(conf->timeout);
conf->timeout = qt_saturate<Timeout_t>(m_currentConnectionSettings.connectTimeout().count());
conf->secureChannelLifeTime = qt_saturate<Timeout_t>(m_currentConnectionSettings.secureChannelLifeTime().count());
conf->requestedSessionTimeout = qt_saturate<Timeout_t>(m_currentConnectionSettings.sessionTimeout().count());
const auto sessionLocaleIds = m_currentConnectionSettings.sessionLocaleIds();
if (!sessionLocaleIds.isEmpty()) {
conf->sessionLocaleIds = static_cast<UA_String *>(UA_Array_new(sessionLocaleIds.size(), &UA_TYPES[UA_TYPES_STRING]));
for (qsizetype i = 0; i < sessionLocaleIds.size(); ++i)
conf->sessionLocaleIds[i] = UA_STRING_ALLOC(sessionLocaleIds[i].toUtf8().constData());
conf->sessionLocaleIdsSize = sessionLocaleIds.size();
}
UA_LocalizedText_clear(&conf->clientDescription.applicationName);
UA_String_clear(&conf->clientDescription.applicationUri);
UA_String_clear(&conf->clientDescription.productUri);
conf->clientContext = this;
// Send periodic read requests as keepalive
conf->connectivityCheckInterval = 60000;
conf->inactivityCallback = inactivityCallback;
conf->clientDescription.applicationName = UA_LOCALIZEDTEXT_ALLOC("", identity.applicationName().toUtf8().constData());
conf->clientDescription.applicationUri = UA_STRING_ALLOC(identity.applicationUri().toUtf8().constData());
conf->clientDescription.productUri = UA_STRING_ALLOC(identity.productUri().toUtf8().constData());
conf->clientDescription.applicationType = UA_APPLICATIONTYPE_CLIENT;
conf->securityPolicyUri = UA_STRING_ALLOC(endpoint.securityPolicy().toUtf8().constData());
conf->securityMode = static_cast<UA_MessageSecurityMode>(endpoint.securityMode());
conf->allowNonePolicyPassword = true;
establishConnectionInternal(authInfo,
#ifdef UA_ENABLE_ENCRYPTION
pkiConfig,
#endif
endpoint);
}
void Open62541AsyncBackend::disconnectFromEndpoint()
{
disconnectInternal();
}
void Open62541AsyncBackend::requestEndpoints(const QUrl &url)
{
UA_ClientConfig initialConfig {};
initialConfig.logging = &m_open62541Logger;
UA_ClientConfig_setDefault(&initialConfig);
UA_Client *tmpClient = UA_Client_newWithConfig(&initialConfig);
size_t numEndpoints = 0;
UA_EndpointDescription *endpoints = nullptr;
UA_StatusCode res = UA_Client_getEndpoints(tmpClient, url.toString(QUrl::RemoveUserInfo).toUtf8().constData(), &numEndpoints, &endpoints);
UaArrayDeleter<UA_TYPES_ENDPOINTDESCRIPTION> endpointDescriptionDeleter(endpoints, numEndpoints);
QList<QOpcUaEndpointDescription> ret;
using namespace QOpcUa;
if (res == UA_STATUSCODE_GOOD && numEndpoints) {
for (size_t i = 0; i < numEndpoints ; ++i)
ret.append(QOpen62541ValueConverter::scalarToQt<QOpcUaEndpointDescription>(&endpoints[i]));
} else {
if (res == UA_STATUSCODE_GOOD)
qWarning() << "Server returned an empty endpoint list";
else
qWarning() << "Failed to retrieve endpoints from " << url.toString(QUrl::RemoveUserInfo).toUtf8().constData()
<< "with status" << UA_StatusCode_name(res);
}
emit endpointsRequestFinished(ret, static_cast<QOpcUa::UaStatusCode>(res), url);
UA_Client_delete(tmpClient);
}
void Open62541AsyncBackend::handleConnectionSettingsChanged(const QOpcUaConnectionSettings &settings)
{
// If there is no client, the settings will be applied during the next connectToEndpoint() call
if (m_uaclient) {
if (m_currentConnectionSettings.requestTimeout() != settings.requestTimeout()) {
qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Changing the request timeout for an established connection is not supported."
<< "The change will be active after the next connectToEndpoint() call.";
}
if (m_currentConnectionSettings.secureChannelLifeTime() != settings.secureChannelLifeTime()) {
qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Changing the secure channel lifetime for an established connection is not supported."
<< "The change will be active after the next connectToEndpoint() call.";
}
if (m_currentConnectionSettings.sessionTimeout() != settings.sessionTimeout()) {
qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Changing the session timeout for an established connection is not supported."
<< "The change will be active after the next connectToEndpoint() call.";
}
if (m_currentConnectionSettings.connectTimeout() != settings.connectTimeout()) {
qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Changing the connect timeout for an established connection is not supported."
<< "The change will be active after the next connectToEndpoint() call.";
}
if (m_currentConnectionSettings.sessionLocaleIds() != settings.sessionLocaleIds()) {
const auto conf = UA_Client_getConfig(m_uaclient);
if (conf->sessionLocaleIdsSize) {
UA_Array_delete(conf->sessionLocaleIds, conf->sessionLocaleIdsSize, &UA_TYPES[UA_TYPES_LOCALEID]);
conf->sessionLocaleIdsSize = 0;
}
if (!settings.sessionLocaleIds().isEmpty()) {
const auto sessionLocaleIds = settings.sessionLocaleIds();
conf->sessionLocaleIds = static_cast<UA_String *>(UA_Array_new(sessionLocaleIds.size(), &UA_TYPES[UA_TYPES_STRING]));
for (qsizetype i = 0; i < sessionLocaleIds.size(); ++i)
conf->sessionLocaleIds[i] = UA_STRING_ALLOC(sessionLocaleIds[i].toUtf8().constData());
conf->sessionLocaleIdsSize = sessionLocaleIds.size();
}
const auto result = UA_Client_activateCurrentSession(m_uaclient);
if (result != UA_STATUSCODE_GOOD) {
qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Changing the session locale Ids failed with" << UA_StatusCode_name(result);
} else {
qCInfo(QT_OPCUA_PLUGINS_OPEN62541) << "The session locale ids were updated to" << settings.sessionLocaleIds().join(' '_L1);
}
}
m_currentConnectionSettings = settings;
}
}
void Open62541AsyncBackend::iterateClient()
{
if (!m_uaclient)
return;
// If BADSERVERNOTCONNECTED is returned, the subscriptions are gone and local information can be deleted.
if (UA_Client_run_iterate(m_uaclient,
std::max<quint32>(1, m_clientIterateInterval / 2)) == UA_STATUSCODE_BADSERVERNOTCONNECTED) {
qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Unable to send publish request";
cleanupSubscriptions();
}
}
void Open62541AsyncBackend::triggerIterateClient()
{
// This is 5 seconds faster over all client tests compared to just
// calling QTimer::singleShot() every time
if (!m_clientIterateOnDemandTimer.isActive()) {
// Restart the normal iterate timer, no need to have more invocations
if (m_clientIterateTimer.isActive())
m_clientIterateTimer.start(m_clientIterateInterval);
m_clientIterateOnDemandTimer.start(0);
}
}
void Open62541AsyncBackend::handleSubscriptionTimeout(QOpen62541Subscription *sub, QList<std::pair<quint64, QOpcUa::NodeAttribute>> items)
{
for (auto it : std::as_const(items)) {
auto item = m_attributeMapping.find(it.first);
if (item == m_attributeMapping.end())
continue;
item->remove(it.second);
}
m_subscriptions.remove(sub->subscriptionId());
delete sub;
}
QOpen62541Subscription *Open62541AsyncBackend::getSubscriptionForItem(quint64 handle, QOpcUa::NodeAttribute attr)
{
auto nodeEntry = m_attributeMapping.find(handle);
if (nodeEntry == m_attributeMapping.end())
return nullptr;
auto subscription = nodeEntry->find(attr);
if (subscription == nodeEntry->end()) {
return nullptr;
}
return subscription.value();
}
void Open62541AsyncBackend::cleanupSubscriptions()
{
qDeleteAll(m_subscriptions);
m_subscriptions.clear();
m_attributeMapping.clear();
m_minPublishingInterval = 0;
}
void Open62541AsyncBackend::registerNodes(const QStringList &nodesToRegister)
{
if (!m_uaclient) {
emit registerNodesFinished(nodesToRegister, {}, QOpcUa::UaStatusCode::BadDisconnect);
return;
}
UA_RegisterNodesRequest req;
UA_RegisterNodesRequest_init(&req);
req.requestHeader.timeoutHint = m_asyncRequestTimeout;
req.nodesToRegisterSize = nodesToRegister.size();
req.nodesToRegister = static_cast<UA_NodeId *>(UA_Array_new(nodesToRegister.size(), &UA_TYPES[UA_TYPES_NODEID]));
for (int i = 0; i < nodesToRegister.size(); ++i)
QOpen62541ValueConverter::scalarFromQt<UA_NodeId, QString>(nodesToRegister.at(i), &req.nodesToRegister[i]);
quint32 requestId = 0;
UA_StatusCode result = __UA_Client_AsyncService(m_uaclient, &req, &UA_TYPES[UA_TYPES_REGISTERNODESREQUEST],
&asyncRegisterNodesCallback,
&UA_TYPES[UA_TYPES_REGISTERNODESRESPONSE],
this, &requestId);
UA_RegisterNodesRequest_clear(&req);
if (result != UA_STATUSCODE_GOOD) {
emit registerNodesFinished(nodesToRegister, {}, QOpcUa::UaStatusCode(result));
} else {
m_asyncRegisterUnregisterNodesContext[requestId] = { nodesToRegister };
triggerIterateClient();
}
}
void Open62541AsyncBackend::unregisterNodes(const QStringList &nodesToUnregister)
{
if (!m_uaclient) {
emit unregisterNodesFinished(nodesToUnregister, QOpcUa::UaStatusCode::BadDisconnect);
return;
}
UA_UnregisterNodesRequest req;
UA_UnregisterNodesRequest_init(&req);
req.requestHeader.timeoutHint = m_asyncRequestTimeout;
req.nodesToUnregisterSize = nodesToUnregister.size();
req.nodesToUnregister = static_cast<UA_NodeId *>(UA_Array_new(nodesToUnregister.size(), &UA_TYPES[UA_TYPES_NODEID]));
for (int i = 0; i < nodesToUnregister.size(); ++i)
QOpen62541ValueConverter::scalarFromQt<UA_NodeId, QString>(nodesToUnregister.at(i), &req.nodesToUnregister[i]);
quint32 requestId = 0;
UA_StatusCode result = __UA_Client_AsyncService(m_uaclient, &req, &UA_TYPES[UA_TYPES_UNREGISTERNODESREQUEST],
&asyncUnregisterNodesCallback,
&UA_TYPES[UA_TYPES_UNREGISTERNODESRESPONSE],
this, &requestId);
UA_UnregisterNodesRequest_clear(&req);
if (result != UA_STATUSCODE_GOOD) {
emit unregisterNodesFinished(nodesToUnregister, QOpcUa::UaStatusCode(result));
} else {
m_asyncRegisterUnregisterNodesContext[requestId] = { nodesToUnregister };
triggerIterateClient();
}
}
void Open62541AsyncBackend::asyncMethodCallback(UA_Client *client, void *userdata, UA_UInt32 requestId, void *response)
{
Q_UNUSED(client)
Open62541AsyncBackend *backend = static_cast<Open62541AsyncBackend *>(userdata);
const auto context = backend->m_asyncCallContext.take(requestId);
QVariant result;
const auto cr = static_cast<UA_CallResponse *>(response);
if (cr->resultsSize && cr->results->outputArgumentsSize > 1 && cr->results->statusCode == UA_STATUSCODE_GOOD) {
QVariantList temp;
for (size_t i = 0; i < cr->results->outputArgumentsSize; ++i)
temp.append(QOpen62541ValueConverter::toQVariant(cr->results->outputArguments[i]));
result = temp;
} else if (cr->resultsSize && cr->results->outputArgumentsSize == 1 && cr->results->statusCode == UA_STATUSCODE_GOOD) {
result = QOpen62541ValueConverter::toQVariant(cr->results->outputArguments[0]);
}
emit backend->methodCallFinished(context.handle, context.methodNodeId, result,
static_cast<QOpcUa::UaStatusCode>(cr->resultsSize ?
cr->results->statusCode :
cr->responseHeader.serviceResult));
}
void Open62541AsyncBackend::asyncTranslateBrowsePathCallback(UA_Client *client, void *userdata, UA_UInt32 requestId, void *response)
{
Q_UNUSED(client)
Open62541AsyncBackend *backend = static_cast<Open62541AsyncBackend *>(userdata);
const auto context = backend->m_asyncTranslateContext.take(requestId);
const auto res = static_cast<UA_TranslateBrowsePathsToNodeIdsResponse *>(response);
if (res->responseHeader.serviceResult != UA_STATUSCODE_GOOD || res->resultsSize != 1) {
qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Translate browse path failed:" << UA_StatusCode_name(res->responseHeader.serviceResult);
emit backend->resolveBrowsePathFinished(context.handle, QList<QOpcUaBrowsePathTarget>(), context.path,
static_cast<QOpcUa::UaStatusCode>(res->responseHeader.serviceResult));
return;
}
QList<QOpcUaBrowsePathTarget> ret;
for (size_t i = 0; i < res->results->targetsSize ; ++i)
ret.append(QOpen62541ValueConverter::scalarToQt<QOpcUaBrowsePathTarget>(&res->results->targets[i]));
emit backend->resolveBrowsePathFinished(context.handle, ret, context.path, static_cast<QOpcUa::UaStatusCode>(res->results->statusCode));
}
void Open62541AsyncBackend::asyncAddNodeCallback(UA_Client *client, void *userdata, UA_UInt32 requestId, void *response)
{
Q_UNUSED(client)
Open62541AsyncBackend *backend = static_cast<Open62541AsyncBackend *>(userdata);
const auto context = backend->m_asyncAddNodeContext.take(requestId);
const auto res = static_cast<UA_AddNodesResponse *>(response);
QOpcUa::UaStatusCode status = QOpcUa::UaStatusCode::Good;
QString resultId;
if (res->responseHeader.serviceResult == UA_STATUSCODE_GOOD) {
if (res->results->statusCode == UA_STATUSCODE_GOOD)
resultId = Open62541Utils::nodeIdToQString(res->results->addedNodeId);
else {
status = static_cast<QOpcUa::UaStatusCode>(res->results->statusCode);
qCDebug(QT_OPCUA_PLUGINS_OPEN62541) << "Failed to add node:" << status;
}
} else {
status = static_cast<QOpcUa::UaStatusCode>(res->responseHeader.serviceResult);
qCDebug(QT_OPCUA_PLUGINS_OPEN62541) << "Failed to add node:" << status;
}
emit backend->addNodeFinished(context.requestedNodeId, resultId, status);
}
void Open62541AsyncBackend::asyncDeleteNodeCallback(UA_Client *client, void *userdata, UA_UInt32 requestId, void *response)
{
Q_UNUSED(client)
Open62541AsyncBackend *backend = static_cast<Open62541AsyncBackend *>(userdata);
const auto context = backend->m_asyncDeleteNodeContext.take(requestId);
const auto res = static_cast<UA_DeleteNodesResponse *>(response);
emit backend->deleteNodeFinished(context.nodeId,
static_cast<QOpcUa::UaStatusCode>(res->resultsSize ?
res->results[0] : res->responseHeader.serviceResult));
}
void Open62541AsyncBackend::asyncAddReferenceCallback(UA_Client *client, void *userdata, UA_UInt32 requestId, void *response)
{
Q_UNUSED(client)
Open62541AsyncBackend *backend = static_cast<Open62541AsyncBackend *>(userdata);
const auto context = backend->m_asyncAddReferenceContext.take(requestId);
const auto res = static_cast<UA_AddReferencesResponse *>(response);
emit backend->addReferenceFinished(context.sourceNodeId, context.referenceTypeId, context.targetNodeId,
context.isForwardReference,
static_cast<QOpcUa::UaStatusCode>(res->resultsSize ?
res->results[0] : res->responseHeader.serviceResult));
}
void Open62541AsyncBackend::asyncDeleteReferenceCallback(UA_Client *client, void *userdata, UA_UInt32 requestId, void *response)
{
Q_UNUSED(client)
Open62541AsyncBackend *backend = static_cast<Open62541AsyncBackend *>(userdata);
const auto context = backend->m_asyncDeleteReferenceContext.take(requestId);
const auto res = static_cast<UA_DeleteReferencesResponse *>(response);
emit backend->deleteReferenceFinished(context.sourceNodeId, context.referenceTypeId,
context.targetNodeId, context.isForwardReference,
static_cast<QOpcUa::UaStatusCode>(res->resultsSize ?
res->results[0] :
res->responseHeader.serviceResult));
}
void Open62541AsyncBackend::asyncReadCallback(UA_Client *client, void *userdata, UA_UInt32 requestId, void *response)
{
Q_UNUSED(client)
Open62541AsyncBackend *backend = static_cast<Open62541AsyncBackend *>(userdata);
auto context = backend->m_asyncReadContext.take(requestId);
const auto res = static_cast<UA_ReadResponse *>(response);
for (qsizetype i = 0; i < context.results.size(); ++i) {
// Use the service result as status code if there is no specific result for the current value.
// This ensures a result for each attribute when UA_Client_Service_read is called for a disconnected client.
if (static_cast<size_t>(i) >= res->resultsSize) {
context.results[i].setStatusCode(static_cast<QOpcUa::UaStatusCode>(res->responseHeader.serviceResult));
continue;
}
if (res->results[i].hasStatus)
context.results[i].setStatusCode(static_cast<QOpcUa::UaStatusCode>(res->results[i].status));
else
context.results[i].setStatusCode(QOpcUa::UaStatusCode::Good);
if (res->results[i].hasValue && res->results[i].value.data)
context.results[i].setValue(QOpen62541ValueConverter::toQVariant(res->results[i].value));
if (res->results[i].hasSourceTimestamp)
context.results[i].setSourceTimestamp(QOpen62541ValueConverter::scalarToQt<QDateTime, UA_DateTime>(&res->results[i].sourceTimestamp));
if (res->results[i].hasServerTimestamp)
context.results[i].setServerTimestamp(QOpen62541ValueConverter::scalarToQt<QDateTime, UA_DateTime>(&res->results[i].serverTimestamp));
}
emit backend->attributesRead(context.handle, context.results,
static_cast<QOpcUa::UaStatusCode>(res->responseHeader.serviceResult));
}
void Open62541AsyncBackend::asyncWriteAttributesCallback(UA_Client *client, void *userdata, UA_UInt32 requestId, void *response)
{
Q_UNUSED(client)
Open62541AsyncBackend *backend = static_cast<Open62541AsyncBackend *>(userdata);
auto context = backend->m_asyncWriteAttributesContext.take(requestId);
const auto res = static_cast<UA_WriteResponse *>(response);
size_t index = 0;
for (auto it = context.toWrite.begin(); it != context.toWrite.end(); ++it, ++index) {
QOpcUa::UaStatusCode status = index < res->resultsSize ?
static_cast<QOpcUa::UaStatusCode>(res->results[index]) :
static_cast<QOpcUa::UaStatusCode>(res->responseHeader.serviceResult);
emit backend->attributeWritten(context.handle, it.key(), it.value(), status);
}
}
void Open62541AsyncBackend::asyncBrowseCallback(UA_Client *client, void *userdata, UA_UInt32 requestId, void *response)
{
Open62541AsyncBackend *backend = static_cast<Open62541AsyncBackend *>(userdata);
auto context = backend->m_asyncBrowseContext.take(requestId);
UA_StatusCode statusCode = UA_STATUSCODE_GOOD;
size_t referencesSize = 0;
UA_BrowseResult *references = nullptr;
UA_ByteString *continuationPoint = nullptr;
if (context.isBrowseNext) {
const auto res = static_cast<UA_BrowseNextResponse *>(response);
referencesSize = res->resultsSize ? res->results->referencesSize : 0;
references = res->results;
statusCode = referencesSize ? references->statusCode : res->responseHeader.serviceResult;
continuationPoint = res->resultsSize ? &res->results->continuationPoint : nullptr;
} else {
const auto res = static_cast<UA_BrowseResponse *>(response);
referencesSize = res->resultsSize ? res->results->referencesSize : 0;
references = res->results;
statusCode = referencesSize ? references->statusCode : res->responseHeader.serviceResult;
continuationPoint = res->resultsSize ? &res->results->continuationPoint : nullptr;
}
if (references && referencesSize) {
for (size_t i = 0; i < referencesSize; ++i)
context.results.push_back(QOpen62541ValueConverter::scalarToQt<QOpcUaReferenceDescription>(&references->references[i]));
}
if (statusCode == UA_STATUSCODE_GOOD && continuationPoint && continuationPoint->length) {
UA_BrowseNextRequest request;
UA_BrowseNextRequest_init(&request);
request.requestHeader.timeoutHint = backend->m_asyncRequestTimeout;
UaDeleter<UA_BrowseNextRequest> requestDeleter(&request, UA_BrowseNextRequest_clear);
request.continuationPointsSize = 1;
request.continuationPoints = UA_ByteString_new();
UA_ByteString_copy(continuationPoint, request.continuationPoints);
quint32 requestId = 0;
statusCode =__UA_Client_AsyncService(client, &request, &UA_TYPES[UA_TYPES_BROWSENEXTREQUEST], &asyncBrowseCallback,
&UA_TYPES[UA_TYPES_BROWSENEXTRESPONSE], backend, &requestId);
if (statusCode == UA_STATUSCODE_GOOD) {
context.isBrowseNext = true;
backend->m_asyncBrowseContext[requestId] = context;
backend->triggerIterateClient();
return;
}
} else if (statusCode != UA_STATUSCODE_GOOD) {
emit backend->browseFinished(context.handle, QList<QOpcUaReferenceDescription>(),
static_cast<QOpcUa::UaStatusCode>(statusCode));
return;
}
emit backend->browseFinished(context.handle, context.results, static_cast<QOpcUa::UaStatusCode>(statusCode));
}
void Open62541AsyncBackend::asyncBatchReadCallback(UA_Client *client, void *userdata, UA_UInt32 requestId, void *response)
{
Q_UNUSED(client)
Open62541AsyncBackend *backend = static_cast<Open62541AsyncBackend *>(userdata);
auto context = backend->m_asyncBatchReadContext.take(requestId);
const auto res = static_cast<UA_ReadResponse *>(response);
QOpcUa::UaStatusCode serviceResult = static_cast<QOpcUa::UaStatusCode>(res->responseHeader.serviceResult);
if (serviceResult != QOpcUa::UaStatusCode::Good) {
qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Batch read failed:" << serviceResult;
emit backend->readNodeAttributesFinished(QList<QOpcUaReadResult>(), serviceResult);
} else {
QList<QOpcUaReadResult> ret;
for (qsizetype i = 0; i < context.nodesToRead.size(); ++i) {
QOpcUaReadResult item;
item.setAttribute(context.nodesToRead.at(i).attribute());
item.setNodeId(context.nodesToRead.at(i).nodeId());
item.setIndexRange(context.nodesToRead.at(i).indexRange());
if (static_cast<size_t>(i) < res->resultsSize) {
if (res->results[i].hasServerTimestamp)
item.setServerTimestamp(QOpen62541ValueConverter::scalarToQt<QDateTime>(&res->results[i].serverTimestamp));
if (res->results[i].hasSourceTimestamp)
item.setSourceTimestamp(QOpen62541ValueConverter::scalarToQt<QDateTime>(&res->results[i].sourceTimestamp));
if (res->results[i].hasValue)
item.setValue(QOpen62541ValueConverter::toQVariant(res->results[i].value));
if (res->results[i].hasStatus)
item.setStatusCode(static_cast<QOpcUa::UaStatusCode>(res->results[i].status));
else
item.setStatusCode(serviceResult);
} else {
item.setStatusCode(serviceResult);
}
ret.push_back(item);
}
emit backend->readNodeAttributesFinished(ret, serviceResult);
}
}
void Open62541AsyncBackend::asyncBatchWriteCallback(UA_Client *client, void *userdata, UA_UInt32 requestId, void *response)
{
Q_UNUSED(client)
Open62541AsyncBackend *backend = static_cast<Open62541AsyncBackend *>(userdata);
const auto context = backend->m_asyncBatchWriteContext.take(requestId);
const auto res = static_cast<UA_WriteResponse *>(response);
QOpcUa::UaStatusCode serviceResult = QOpcUa::UaStatusCode(res->responseHeader.serviceResult);
if (serviceResult != QOpcUa::UaStatusCode::Good) {
qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Batch write failed:" << serviceResult;
emit backend->writeNodeAttributesFinished(QList<QOpcUaWriteResult>(), serviceResult);
} else {
QList<QOpcUaWriteResult> ret;
for (qsizetype i = 0; i < context.nodesToWrite.size(); ++i) {
QOpcUaWriteResult item;
item.setAttribute(context.nodesToWrite.at(i).attribute());
item.setNodeId(context.nodesToWrite.at(i).nodeId());
item.setIndexRange(context.nodesToWrite.at(i).indexRange());
if (static_cast<size_t>(i) < res->resultsSize)
item.setStatusCode(QOpcUa::UaStatusCode(res->results[i]));
else
item.setStatusCode(serviceResult);
ret.push_back(item);
}
emit backend->writeNodeAttributesFinished(ret, serviceResult);
}
}
void Open62541AsyncBackend::asyncReadHistoryDataCallBack(UA_Client *client, void *userdata, UA_UInt32 requestId, void *response)
{
Q_UNUSED(client);
Open62541AsyncBackend *backend = static_cast<Open62541AsyncBackend *>(userdata);
AsyncReadHistoryDataContext context = backend->m_asyncReadHistoryDataContext.take(requestId);
UA_HistoryReadResponse* res = static_cast<UA_HistoryReadResponse*>(response);
QList<QByteArray> continuationPoints;
QList<QOpcUaHistoryData> historyData;
for (size_t i = 0; i < res->resultsSize; ++i) {
if (res->results[i].historyData.encoding != UA_EXTENSIONOBJECT_DECODED) {
emit backend->historyDataAvailable({}, {}, QOpcUa::UaStatusCode(res->responseHeader.serviceResult), context.handle);
return;
}
historyData.push_back(QOpcUaHistoryData(context.historyReadRawRequest.nodesToRead().at(i).nodeId()));
historyData[i].setStatusCode(QOpcUa::UaStatusCode(res->results[i].statusCode));
if (res->results[i].statusCode != UA_STATUSCODE_GOOD)
continue;
if (res->results[i].historyData.content.decoded.type != &UA_TYPES[UA_TYPES_HISTORYDATA]) {
historyData[i].setStatusCode(QOpcUa::UaStatusCode::BadInternalError);
continue;
}
UA_HistoryData *data = static_cast<UA_HistoryData *>(res->results[i].historyData.content.decoded.data);
for (size_t j = 0; j < data->dataValuesSize; ++j) {
const QOpcUaDataValue value = QOpen62541ValueConverter::scalarToQt<QOpcUaDataValue, UA_DataValue>(&data->dataValues[j]);
historyData[i].addValue(value);
}
continuationPoints.push_back(QOpen62541ValueConverter::scalarToQt<QByteArray, UA_ByteString>(&res->results[i].continuationPoint));
}
emit backend->historyDataAvailable(historyData, continuationPoints, QOpcUa::UaStatusCode(res->responseHeader.serviceResult), context.handle);
}
void Open62541AsyncBackend::asyncRegisterNodesCallback(UA_Client *client, void *userdata, UA_UInt32 requestId, void *response)
{
Q_UNUSED(client)
Open62541AsyncBackend *backend = static_cast<Open62541AsyncBackend *>(userdata);
const auto context = backend->m_asyncRegisterUnregisterNodesContext.take(requestId);
const auto res = static_cast<UA_RegisterNodesResponse *>(response);
const auto serviceResult = QOpcUa::UaStatusCode(res->responseHeader.serviceResult);
if (serviceResult != QOpcUa::UaStatusCode::Good) {
qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Register nodes failed:" << serviceResult;
emit backend->registerNodesFinished(context.nodeIds, {}, serviceResult);
} else {
QStringList resultIds;
for (size_t i = 0; i < res->registeredNodeIdsSize; ++i)
resultIds.push_back(QOpen62541ValueConverter::scalarToQt<QString, UA_NodeId>(&res->registeredNodeIds[i]));
emit backend->registerNodesFinished(context.nodeIds, resultIds, serviceResult);
}
}
void Open62541AsyncBackend::asyncUnregisterNodesCallback(UA_Client *client, void *userdata, UA_UInt32 requestId, void *response)
{
Q_UNUSED(client)
Open62541AsyncBackend *backend = static_cast<Open62541AsyncBackend *>(userdata);
const auto context = backend->m_asyncRegisterUnregisterNodesContext.take(requestId);
const auto res = static_cast<UA_UnregisterNodesResponse *>(response);
const auto serviceResult = QOpcUa::UaStatusCode(res->responseHeader.serviceResult);
if (serviceResult != QOpcUa::UaStatusCode::Good)
qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Unregister nodes failed:" << serviceResult;
emit backend->unregisterNodesFinished(context.nodeIds, serviceResult);
}
void Open62541AsyncBackend::asyncReadHistoryEventsCallback(UA_Client *client, void *userdata, UA_UInt32 requestId, void *response)
{
Q_UNUSED(client);
Open62541AsyncBackend *backend = static_cast<Open62541AsyncBackend *>(userdata);
auto context = backend->m_asyncReadHistoryEventsContext.take(requestId);
auto res = static_cast<UA_HistoryReadResponse*>(response);
QList<QByteArray> continuationPoints;
QList<QOpcUaHistoryEvent> historyEvents;
for (size_t i = 0; i < res->resultsSize; ++i) {
if (res->results[i].historyData.encoding != UA_EXTENSIONOBJECT_DECODED) {
emit backend->historyEventsAvailable({}, {}, QOpcUa::UaStatusCode(res->responseHeader.serviceResult), context.handle);
return;
}
historyEvents.push_back(QOpcUaHistoryEvent(context.historyReadEventRequest.nodesToRead().at(i).nodeId()));
historyEvents[i].setStatusCode(QOpcUa::UaStatusCode(res->results[i].statusCode));
if (res->results[i].statusCode != UA_STATUSCODE_GOOD)
continue;
if (res->results[i].historyData.content.decoded.type != &UA_TYPES[UA_TYPES_HISTORYEVENT]) {
historyEvents[i].setStatusCode(QOpcUa::UaStatusCode::BadInternalError);
continue;
}
auto events = static_cast<UA_HistoryEvent *>(res->results[i].historyData.content.decoded.data);
for (size_t j = 0; j < events->eventsSize; ++j) {
QVariantList eventFields;
for (size_t k = 0; k < events->events[j].eventFieldsSize; ++k)
eventFields.push_back(QOpen62541ValueConverter::toQVariant(events->events[j].eventFields[k]));
historyEvents.back().addEvent(eventFields);
}
continuationPoints.push_back(QOpen62541ValueConverter::scalarToQt<QByteArray, UA_ByteString>(&res->results[i].continuationPoint));
}
emit backend->historyEventsAvailable(historyEvents, continuationPoints, QOpcUa::UaStatusCode(res->responseHeader.serviceResult), context.handle);
}
bool Open62541AsyncBackend::loadFileToByteString(const QString &location, UA_ByteString *target) const
{
if (location.isEmpty()) {
qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Unable to read from empty file path";
return false;
}
if (!target) {
qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "No target ByteString given";
return false;
}
UA_ByteString_init(target);
QFile file(location);
if (!file.open(QFile::ReadOnly)) {
qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Failed to open file" << location << file.errorString();
return false;
}
QByteArray data = file.readAll();
UA_ByteString temp;
temp.length = data.size();
if (data.isEmpty())
temp.data = nullptr;
else {
if (data.startsWith('-')) { // PEM file
// mbedTLS expects PEM encoded data to be null terminated
data = data.append('\0');
temp.length = data.size();
}
temp.data = reinterpret_cast<unsigned char *>(data.data());
}
return UA_ByteString_copy(&temp, target) == UA_STATUSCODE_GOOD;
}
bool Open62541AsyncBackend::loadAllFilesInDirectory(const QString &location, UA_ByteString **target, qsizetype *size) const
{
if (location.isEmpty()) {
qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Unable to read from empty file path";
return false;
}
if (!target) {
qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "No target ByteString given";
return false;
}
*target = nullptr;
*size = 0;
QDir dir(location);
auto entries = dir.entryList(QDir::Files);
if (entries.isEmpty()) {
qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Directory is empty";
return true;
}
const qsizetype tempSize = entries.size();
UA_ByteString *list = static_cast<UA_ByteString *>(UA_Array_new(tempSize, &UA_TYPES[UA_TYPES_BYTESTRING]));
if (!list) {
qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Failed to allocate memory for loading files in" << location;
return false;
}
for (qsizetype i = 0; i < entries.size(); ++i) {
if (!loadFileToByteString(dir.filePath(entries.at(i)), &list[i])) {
qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Failed to open file" << entries.at(i);
UA_Array_delete(list, tempSize, &UA_TYPES[UA_TYPES_BYTESTRING]);
size = 0;
*target = nullptr;
return false;
}
}
*target = list;
*size = tempSize;
return true;
}
void Open62541AsyncBackend::disconnectInternal(QOpcUaClient::ClientError error)
{
m_clientIterateTimer.stop();
m_clientIterateOnDemandTimer.stop();
if (m_uaclient) {
// Disable the state callback, we will emit stateAndOrErrorChanged() here
UA_Client_getConfig(m_uaclient)->stateCallback = nullptr;
UA_Client_getConfig(m_uaclient)->inactivityCallback = nullptr;
}
cleanupSubscriptions();
if (m_uaclient) {
UA_Client_disconnect(m_uaclient);
UA_Client_delete(m_uaclient);
m_uaclient = nullptr;
emit stateAndOrErrorChanged(QOpcUaClient::Disconnected, error);
}
}
#ifdef UA_ENABLE_ENCRYPTION
bool Open62541AsyncBackend::setupClientConfigSecurity(const QOpcUaAuthenticationInformation &authInfo,
const QOpcUaPkiConfiguration &pkiConfig,
const QOpcUaEndpointDescription &endpoint)
{
const auto conf = UA_Client_getConfig(m_uaclient);
if (!conf)
return false;
UA_ByteString privateKey = UA_BYTESTRING_NULL;
UaDeleter<UA_ByteString> privateKeyDeleter(&privateKey, &UA_ByteString_clear);
if (pkiConfig.isKeyAndCertificateFileSet()) {
UA_ByteString localCertificate;
UA_ByteString *trustList = nullptr;
qsizetype trustListSize = 0;
UA_ByteString *revocationList = nullptr;
qsizetype revocationListSize = 0;
UA_ByteString *issuerList = nullptr;
qsizetype issuerListSize = 0;
UA_ByteString *issuerRevocationList = nullptr;
qsizetype issuerRevocationListSize = 0;
bool success = loadFileToByteString(pkiConfig.clientCertificateFile(), &localCertificate);
if (!success) {
qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Failed to load client certificate";
emit stateAndOrErrorChanged(QOpcUaClient::Disconnected, QOpcUaClient::InvalidPki);
UA_Client_delete(m_uaclient);
m_uaclient = nullptr;
return false;
}
UaDeleter<UA_ByteString> clientCertDeleter(&localCertificate, &UA_ByteString_clear);
success = loadPrivateKeyWithPotentialPassword(pkiConfig.privateKeyFile(), privateKey);
if (!success) {
qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Failed to load private key";
emit stateAndOrErrorChanged(QOpcUaClient::Disconnected, QOpcUaClient::InvalidPki);
UA_Client_delete(m_uaclient);
m_uaclient = nullptr;
return false;
}
if (!pkiConfig.trustListDirectory().isEmpty()) {
success = loadAllFilesInDirectory(pkiConfig.trustListDirectory(), &trustList, &trustListSize);
if (!success) {
qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Failed to load trust list";
emit stateAndOrErrorChanged(QOpcUaClient::Disconnected, QOpcUaClient::InvalidPki);
UA_Client_delete(m_uaclient);
m_uaclient = nullptr;
return false;
}
}
UaArrayDeleter<UA_TYPES_BYTESTRING> trustListDeleter(trustList, trustListSize);
if (!pkiConfig.revocationListDirectory().isEmpty()) {
success = loadAllFilesInDirectory(pkiConfig.revocationListDirectory(), &revocationList, &revocationListSize);
if (!success) {
qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Failed to load revocation list";
emit stateAndOrErrorChanged(QOpcUaClient::Disconnected, QOpcUaClient::InvalidPki);
UA_Client_delete(m_uaclient);
m_uaclient = nullptr;
return false;
}
}
UaArrayDeleter<UA_TYPES_BYTESTRING> revocationListDeleter(revocationList, revocationListSize);
if (!pkiConfig.issuerListDirectory().isEmpty()) {
success = loadAllFilesInDirectory(pkiConfig.issuerListDirectory(), &issuerList, &issuerListSize);
if (!success) {
qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Failed to load issuer list";
emit stateAndOrErrorChanged(QOpcUaClient::Disconnected, QOpcUaClient::InvalidPki);
UA_Client_delete(m_uaclient);
m_uaclient = nullptr;
return false;
}
}
UaArrayDeleter<UA_TYPES_BYTESTRING> issuerListDeleter(issuerList, issuerListSize);
if (!pkiConfig.issuerRevocationListDirectory().isEmpty()) {
success = loadAllFilesInDirectory(pkiConfig.issuerRevocationListDirectory(), &issuerRevocationList, &issuerRevocationListSize);
if (!success) {
qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Failed to load issuer revocation list";
emit stateAndOrErrorChanged(QOpcUaClient::Disconnected, QOpcUaClient::InvalidPki);
UA_Client_delete(m_uaclient);
m_uaclient = nullptr;
return false;
}
}
UaArrayDeleter<UA_TYPES_BYTESTRING> issuerRevocationListDeleter(issuerRevocationList, issuerRevocationListSize);
// UA_ClientConfig_setDefaultEncryption() no longer adds Basic128Rsa15 and Basic256 to the security policies in v1.4.7
// This must be done manually (for now).
UA_StatusCode result = UA_ClientConfig_setDefault(conf);
if (result != UA_STATUSCODE_GOOD) {
qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Failed to set client config defaults:" << static_cast<QOpcUa::UaStatusCode>(result);
emit stateAndOrErrorChanged(QOpcUaClient::Disconnected, QOpcUaClient::UnknownError);
UA_Client_delete(m_uaclient);
m_uaclient = nullptr;
return false;
}
if (conf->certificateVerification.clear)
conf->certificateVerification.clear(&conf->certificateVerification);
{
UA_TrustListDataType list {};
list.specifiedLists = UA_TRUSTLISTMASKS_TRUSTEDCRLS | UA_TRUSTLISTMASKS_TRUSTEDCERTIFICATES |
UA_TRUSTLISTMASKS_ISSUERCERTIFICATES | UA_TRUSTLISTMASKS_ISSUERCRLS;
list.trustedCertificates = trustList;
list.trustedCertificatesSize = trustListSize;
list.trustedCrlsSize = revocationListSize;
list.trustedCrls = revocationList;
list.issuerCertificatesSize = issuerListSize;
list.issuerCertificates = issuerList;
list.issuerCrlsSize = issuerRevocationListSize;
list.issuerCrls = issuerRevocationList;
auto defaultApplicationGroup = UA_NS0ID(SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP);
UA_StatusCode result = UA_CertificateGroup_Memorystore(&conf->certificateVerification, &defaultApplicationGroup, &list, conf->logging, nullptr);
if (result != UA_STATUSCODE_GOOD) {
qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Failed to set up certificate verification:" << static_cast<QOpcUa::UaStatusCode>(result);
emit stateAndOrErrorChanged(QOpcUaClient::Disconnected, QOpcUaClient::InvalidPki);
UA_Client_delete(m_uaclient);
m_uaclient = nullptr;
return false;
}
}
result = setAuthSecurityPolicyInClientConfig(conf, localCertificate, privateKey, endpoint, authInfo.authenticationType());
if (result != UA_STATUSCODE_GOOD) {
qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Failed to set up auth security policies:" << static_cast<QOpcUa::UaStatusCode>(result);
emit stateAndOrErrorChanged(QOpcUaClient::Disconnected, QOpcUaClient::InvalidPki);
UA_Client_delete(m_uaclient);
m_uaclient = nullptr;
return false;
}
result = setSecurityPolicyInClientConfig(conf, localCertificate, privateKey, endpoint);
if (result != UA_STATUSCODE_GOOD) {
qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Failed to set up security policies:" << static_cast<QOpcUa::UaStatusCode>(result);
emit stateAndOrErrorChanged(QOpcUaClient::Disconnected, QOpcUaClient::InvalidPki);
UA_Client_delete(m_uaclient);
m_uaclient = nullptr;
return false;
}
} else {
return UA_ClientConfig_setDefault(conf) == UA_STATUSCODE_GOOD;
}
return true;
}
#endif
void Open62541AsyncBackend::establishConnectionInternal(const QOpcUaAuthenticationInformation &authInfo,
#ifdef UA_ENABLE_ENCRYPTION
const QOpcUaPkiConfiguration &pkiConfig,
#endif
const QOpcUaEndpointDescription &endpoint)
{
const auto conf = UA_Client_getConfig(m_uaclient);
if (!conf)
return;
UA_StatusCode ret = UA_STATUSCODE_BADINTERNALERROR;
bool retry = false;
do {
retry = false;
if (authInfo.authenticationType() == QOpcUaUserTokenPolicy::TokenType::Anonymous) {
// Nothing to do, Anonymous is default
} else if (authInfo.authenticationType() == QOpcUaUserTokenPolicy::TokenType::Username) {
const auto credentials = authInfo.authenticationData().value<std::pair<QString, QString>>();
UA_ClientConfig_setAuthenticationUsername(conf, credentials.first.toUtf8().constData(),
credentials.second.toUtf8().constData());
} else if (authInfo.authenticationType() == QOpcUaUserTokenPolicy::TokenType::Certificate) {
#ifdef UA_ENABLE_ENCRYPTION
QString certPath;
QString keyPath;
if (authInfo.authenticationData().canConvert<std::pair<QString, QString>>()) {
const auto authPaths = authInfo.authenticationData().value<std::pair<QString, QString>>();
if (authPaths.first.isEmpty() || authPaths.second.isEmpty()) {
qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Certificate and private key path must be set for certificate auth";
emit stateAndOrErrorChanged(QOpcUaClient::Disconnected, QOpcUaClient::ClientError::InvalidAuthenticationInformation);
UA_Client_delete(m_uaclient);
m_uaclient = nullptr;
return;
}
certPath = authPaths.first;
keyPath = authPaths.second;
} else {
certPath = pkiConfig.clientCertificateFile();
keyPath = pkiConfig.privateKeyFile();
}
UA_ByteString cert = UA_BYTESTRING_NULL;
UA_ByteString key = UA_BYTESTRING_NULL;
if (!loadFileToByteString(certPath, &cert)) {
qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Failed to load certificate for certificate auth";
emit stateAndOrErrorChanged(QOpcUaClient::Disconnected, QOpcUaClient::ClientError::InvalidAuthenticationInformation);
UA_Client_delete(m_uaclient);
m_uaclient = nullptr;
return;
}
UaDeleter<UA_ByteString> certDeleter(&cert, &UA_ByteString_clear);
if (!loadPrivateKeyWithPotentialPassword(keyPath, key)) {
qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Failed to load private key for certificate auth";
emit stateAndOrErrorChanged(QOpcUaClient::Disconnected, QOpcUaClient::ClientError::InvalidAuthenticationInformation);
UA_Client_delete(m_uaclient);
m_uaclient = nullptr;
return;
}
UaDeleter<UA_ByteString> keyDeleter(&key, &UA_ByteString_clear);
// UA_ClientConfig_setAuthenticationCert() overwrites the auth security policies,
// so we must call our custom implementation
UA_X509IdentityToken *token = UA_X509IdentityToken_new();
UA_StatusCode result = UA_ByteString_copy(&cert, &token->certificateData);
UA_ExtensionObject_clear(&conf->userIdentityToken);
conf->userIdentityToken.encoding = UA_EXTENSIONOBJECT_DECODED;
conf->userIdentityToken.content.decoded.type = &UA_TYPES[UA_TYPES_X509IDENTITYTOKEN];
conf->userIdentityToken.content.decoded.data = token;
if (result != UA_STATUSCODE_GOOD) {
qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Failed to initialize certificate auth:" << UA_StatusCode_name(result);
emit stateAndOrErrorChanged(QOpcUaClient::Disconnected, QOpcUaClient::ClientError::UnsupportedAuthenticationInformation);
UA_Client_delete(m_uaclient);
m_uaclient = nullptr;
return;
}
#endif
} else {
emit stateAndOrErrorChanged(QOpcUaClient::Disconnected, QOpcUaClient::UnsupportedAuthenticationInformation);
qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Failed to connect: Selected authentication type"
<< authInfo.authenticationType() << "is not supported.";
UA_Client_delete(m_uaclient);
m_uaclient = nullptr;
return;
}
ret = UA_Client_connect(m_uaclient, endpoint.endpointUrl().toUtf8().constData());
#ifdef UA_ENABLE_ENCRYPTION
if (ret == UA_STATUSCODE_BADCERTIFICATEUNTRUSTED) {
QOpcUaErrorState errorState;
errorState.setClientSideError(true);
errorState.setConnectionStep(QOpcUaErrorState::ConnectionStep::CertificateValidation);
errorState.setErrorCode(QOpcUa::UaStatusCode::BadCertificateUntrusted);
emit QOpcUaBackend::connectError(&errorState);
if (errorState.ignoreError()) {
// Use the AcceptAll certificate verification
UA_CertificateGroup_AcceptAll(&conf->certificateVerification);
retry = true;
}
}
#endif
} while (retry);
if (ret != UA_STATUSCODE_GOOD) {
UA_Client_delete(m_uaclient);
m_uaclient = nullptr;
QOpcUaClient::ClientError error = QOpcUaClient::UnknownError;
switch (ret) {
case UA_STATUSCODE_BADUSERACCESSDENIED:
case UA_STATUSCODE_BADIDENTITYTOKENINVALID: // Intentional fall through
error = QOpcUaClient::AccessDenied;
break;
case UA_STATUSCODE_BADCERTIFICATEUNTRUSTED:
error = QOpcUaClient::CertificateUntrusted;
break;
default:
break;
}
QOpcUaErrorState errorState;
errorState.setConnectionStep(QOpcUaErrorState::ConnectionStep::Unknown);
errorState.setErrorCode(static_cast<QOpcUa::UaStatusCode>(ret));
errorState.setClientSideError(false);
errorState.setIgnoreError(false);
// This signal is connected using Qt::BlockingQueuedConnection. It will place a metacall to a different thread and waits
// until this metacall is fully handled before returning.
emit QOpcUaBackend::connectError(&errorState);
emit stateAndOrErrorChanged(QOpcUaClient::Disconnected, error);
qCWarning(QT_OPCUA_PLUGINS_OPEN62541) << "Open62541: Failed to connect";
return;
}
using Timeout_t = decltype(conf->timeout);
conf->timeout = qt_saturate<Timeout_t>(m_currentConnectionSettings.requestTimeout().count());
// Attach the client state callback after the successful connect
conf->stateCallback = clientStateCallback;
conf->noReconnect = true;
m_clientIterateTimer.start(m_clientIterateInterval);
emit stateAndOrErrorChanged(QOpcUaClient::Connected, QOpcUaClient::NoError);
}
#ifdef UA_ENABLE_ENCRYPTION
bool Open62541AsyncBackend::loadPrivateKeyWithPotentialPassword(const QString &privateKeyPath, UA_ByteString &privateKey)
{
UA_ByteString privateKeyData = UA_BYTESTRING_NULL;
const auto guard = qScopeGuard([&privateKeyData]() {
UA_ByteString_clear(&privateKeyData);
});
const auto success = loadFileToByteString(privateKeyPath, &privateKeyData);
if (!success)
return false;
UA_StatusCode decryptResult = UA_STATUSCODE_BADINTERNALERROR;
QString password;
bool previousTryWasInvalid = false;
do {
auto uaPassword = UA_STRING_ALLOC(password.toUtf8().constData());
decryptResult = UA_CertificateUtils_decryptPrivateKey(privateKeyData, uaPassword, &privateKey);
UA_String_clear(&uaPassword);
// The key was already DER or had no password
if (decryptResult == UA_STATUSCODE_GOOD)
return true;
// Decoding failed, a password may be required or the given password was invalid
if (decryptResult == UA_STATUSCODE_BADSECURITYCHECKSFAILED) {
emit passwordForPrivateKeyRequired(privateKeyPath, &password, previousTryWasInvalid);
// No further attempt requested
if (password.isEmpty())
return false;
previousTryWasInvalid = true;
}
} while (decryptResult == UA_STATUSCODE_BADSECURITYCHECKSFAILED);
return false;
}
// Only add the security policy the requested endpoint requires
UA_StatusCode Open62541AsyncBackend::setSecurityPolicyInClientConfig(UA_ClientConfig *conf, const UA_ByteString &cert, const UA_ByteString &key,
const QOpcUaEndpointDescription &desc)
{
if (desc.securityPolicy() == QOpcUa::NonePolicy)
return UA_STATUSCODE_GOOD;
const size_t numPolicies = conf->securityPoliciesSize + 1;
conf->securityPolicies = static_cast<UA_SecurityPolicy *>(UA_realloc(conf->securityPolicies, sizeof(UA_SecurityPolicy) * numPolicies));
UA_StatusCode result = UA_STATUSCODE_GOOD;
if (desc.securityPolicy() == QOpcUa::Basic128Rsa15Policy)
result = UA_SecurityPolicy_Basic128Rsa15(&conf->securityPolicies[1],
cert, key, conf->logging);
else if (desc.securityPolicy() == QOpcUa::Basic256Policy)
result = UA_SecurityPolicy_Basic256(&conf->securityPolicies[1],
cert, key, conf->logging);
else if (desc.securityPolicy() == QOpcUa::Aes256Sha256RsaPssPolicy)
result = UA_SecurityPolicy_Aes256Sha256RsaPss(&conf->securityPolicies[1],
cert, key, conf->logging);
else if (desc.securityPolicy() == QOpcUa::Basic256Sha256Policy)
result = UA_SecurityPolicy_Basic256Sha256(&conf->securityPolicies[1],
cert, key, conf->logging);
else if (desc.securityPolicy() == QOpcUa::Aes128Sha256RsaOaepPolicy)
result = UA_SecurityPolicy_Aes128Sha256RsaOaep(&conf->securityPolicies[1],
cert, key, conf->logging);
else
result = UA_STATUSCODE_BADINVALIDARGUMENT;
if (result != UA_STATUSCODE_GOOD) {
// UA_ClientConfig_clear() doesn't check for a valid clear() pointer on the policy
// Don't increment securityPoliciesSize in case of an error
return result;
} else {
conf->securityPoliciesSize = numPolicies;
}
return result;
}
// Find the most secure security policy a token of the required type supports
UA_StatusCode Open62541AsyncBackend::setAuthSecurityPolicyInClientConfig(UA_ClientConfig *conf, const UA_ByteString &cert,
const UA_ByteString &key,
const QOpcUaEndpointDescription &desc,
QOpcUaUserTokenPolicy::TokenType tokenType)
{
UA_StatusCode result = UA_STATUSCODE_BADINVALIDARGUMENT;
QString selectedPolicy;
int lastIndex = -1;
const auto tempTokens = desc.userIdentityTokens();
for (const auto &token : tempTokens) {
if (token.tokenType() != tokenType)
continue;
auto currentPolicy = token.securityPolicy();
if (currentPolicy.isEmpty())
currentPolicy = desc.securityPolicy();
// Assumes that supportedSecurityPolicies() is sorted by strength
// The supportedSecurityPolicies() has been modified accordingly.
const auto index = m_clientImpl->supportedSecurityPolicies().indexOf(currentPolicy);
if (index > lastIndex) {
lastIndex = index;
selectedPolicy = currentPolicy;
}
}
if (!selectedPolicy.isEmpty()) {
if (selectedPolicy == QOpcUa::NonePolicy)
return UA_STATUSCODE_GOOD;
const size_t numPolicies = 1;
for (size_t i = 0; i < conf->authSecurityPoliciesSize; i++) {
conf->authSecurityPolicies[i].clear(&conf->authSecurityPolicies[i]);
}
UA_free(conf->authSecurityPolicies);
conf->authSecurityPolicies = static_cast<UA_SecurityPolicy*>(UA_calloc(numPolicies, sizeof(UA_SecurityPolicy)));
conf->authSecurityPoliciesSize = numPolicies;
if (selectedPolicy == QOpcUa::Basic128Rsa15Policy)
result = UA_SecurityPolicy_Basic128Rsa15(&conf->authSecurityPolicies[0],
cert, key, conf->logging);
else if (selectedPolicy == QOpcUa::Basic256Policy)
result = UA_SecurityPolicy_Basic256(&conf->authSecurityPolicies[0],
cert, key, conf->logging);
else if (selectedPolicy == QOpcUa::Aes256Sha256RsaPssPolicy)
result = UA_SecurityPolicy_Aes256Sha256RsaPss(&conf->authSecurityPolicies[0],
cert, key, conf->logging);
else if (selectedPolicy == QOpcUa::Basic256Sha256Policy)
result = UA_SecurityPolicy_Basic256Sha256(&conf->authSecurityPolicies[0],
cert, key, conf->logging);
else if (selectedPolicy == QOpcUa::Aes128Sha256RsaOaepPolicy)
result = UA_SecurityPolicy_Aes128Sha256RsaOaep(&conf->authSecurityPolicies[0],
cert, key, conf->logging);
if (result != UA_STATUSCODE_GOOD) {
// UA_ClientConfig_clear() doesn't check for a valid clear() pointer on the policy
conf->authSecurityPoliciesSize = 0;
UA_free(conf->authSecurityPolicies);
conf->authSecurityPolicies = nullptr;
}
}
return result;
}
#endif
QT_END_NAMESPACE