static UA_StatusCode
readValueAttributeFromNode(UA_Server *server, UA_Session *session,
const UA_VariableNode *vn, UA_DataValue *v,
UA_NumericRange *rangeptr) {
if(vn->value.data.callback.onRead) {
vn->value.data.callback.onRead(server, &session->sessionId,
session->sessionHandle, &vn->nodeId,
vn->context, rangeptr, &vn->value.data.value);
const UA_Node *old = (const UA_Node *)vn;
/* Reopen the node to see the changes from onRead */
vn = (const UA_VariableNode*)UA_Nodestore_get(server, &vn->nodeId);
UA_Nodestore_release(server, old);
}
if(rangeptr)
return UA_Variant_copyRange(&vn->value.data.value.value, &v->value, *rangeptr);
*v = vn->value.data.value;
v->value.storageType = UA_VARIANT_DATA_NODELETE;
return UA_STATUSCODE_GOOD;
}
static UA_StatusCode
setMonitoredItemSettings(UA_Server *server, UA_MonitoredItem *mon,
UA_MonitoringMode monitoringMode,
const UA_MonitoringParameters *params,
const UA_DataType* dataType) {
/* Filter */
if(params->filter.encoding != UA_EXTENSIONOBJECT_DECODED) {
UA_DataChangeFilter_init(&(mon->filter.dataChangeFilter));
mon->filter.dataChangeFilter.trigger = UA_DATACHANGETRIGGER_STATUSVALUE;
} else if(params->filter.content.decoded.type == &UA_TYPES[UA_TYPES_DATACHANGEFILTER]) {
UA_DataChangeFilter *filter = (UA_DataChangeFilter *)params->filter.content.decoded.data;
// TODO implement EURange to support UA_DEADBANDTYPE_PERCENT
switch(filter->deadbandType) {
case UA_DEADBANDTYPE_NONE:
break;
case UA_DEADBANDTYPE_ABSOLUTE:
if(!dataType || !UA_DataType_isNumeric(dataType))
return UA_STATUSCODE_BADFILTERNOTALLOWED;
break;
case UA_DEADBANDTYPE_PERCENT:
return UA_STATUSCODE_BADMONITOREDITEMFILTERUNSUPPORTED;
default:
return UA_STATUSCODE_BADMONITOREDITEMFILTERUNSUPPORTED;
}
UA_DataChangeFilter_copy(filter, &mon->filter.dataChangeFilter);
#ifdef UA_ENABLE_SUBSCRIPTIONS_EVENTS
} else if (params->filter.content.decoded.type == &UA_TYPES[UA_TYPES_EVENTFILTER]) {
UA_EventFilter_copy((UA_EventFilter *)params->filter.content.decoded.data,
&mon->filter.eventFilter);
#endif
} else {
return UA_STATUSCODE_BADMONITOREDITEMFILTERINVALID;
}
/* <-- The point of no return --> */
/* Unregister the callback */
UA_MonitoredItem_unregisterSampleCallback(server, mon);
/* Remove the old samples */
UA_ByteString_deleteMembers(&mon->lastSampledValue);
UA_Variant_deleteMembers(&mon->lastValue);
/* ClientHandle */
mon->clientHandle = params->clientHandle;
/* SamplingInterval */
UA_Double samplingInterval = params->samplingInterval;
if(mon->attributeId == UA_ATTRIBUTEID_VALUE) {
mon->monitoredItemType = UA_MONITOREDITEMTYPE_CHANGENOTIFY;
const UA_VariableNode *vn = (const UA_VariableNode *)
UA_Nodestore_get(server, &mon->monitoredNodeId);
if(vn) {
if(vn->nodeClass == UA_NODECLASS_VARIABLE &&
samplingInterval < vn->minimumSamplingInterval)
samplingInterval = vn->minimumSamplingInterval;
UA_Nodestore_release(server, (const UA_Node *)vn);
}
} else if(mon->attributeId == UA_ATTRIBUTEID_EVENTNOTIFIER) {
/* TODO: events should not need a samplinginterval */
samplingInterval = 10000.0f; // 10 seconds to reduce the load
mon->monitoredItemType = UA_MONITOREDITEMTYPE_EVENTNOTIFY;
} else {
mon->monitoredItemType = UA_MONITOREDITEMTYPE_CHANGENOTIFY;
}
mon->samplingInterval = samplingInterval;
UA_BOUNDEDVALUE_SETWBOUNDS(server->config.samplingIntervalLimits,
samplingInterval, mon->samplingInterval);
if(samplingInterval != samplingInterval) /* Check for nan */
mon->samplingInterval = server->config.samplingIntervalLimits.min;
UA_assert(mon->monitoredItemType != 0);
/* QueueSize */
UA_BOUNDEDVALUE_SETWBOUNDS(server->config.queueSizeLimits,
params->queueSize, mon->maxQueueSize);
/* DiscardOldest */
mon->discardOldest = params->discardOldest;
/* Register sample callback if reporting is enabled */
mon->monitoringMode = monitoringMode;
if(monitoringMode == UA_MONITORINGMODE_REPORTING)
return UA_MonitoredItem_registerSampleCallback(server, mon);
return UA_STATUSCODE_GOOD;
}
static void
Operation_Read(UA_Server *server, UA_Session *session,
const UA_ReadValueId *id, UA_DataValue *v) {
UA_LOG_DEBUG_SESSION(server->config.logger, session,
"Read the attribute %i", id->attributeId);
/* XML encoding is not supported */
if(id->dataEncoding.name.length > 0 &&
!UA_String_equal(&binEncoding, &id->dataEncoding.name)) {
v->hasStatus = true;
v->status = UA_STATUSCODE_BADDATAENCODINGUNSUPPORTED;
return;
}
/* Index range for an attribute other than value */
if(id->indexRange.length > 0 && id->attributeId != UA_ATTRIBUTEID_VALUE) {
v->hasStatus = true;
v->status = UA_STATUSCODE_BADINDEXRANGENODATA;
return;
}
/* Get the node */
const UA_Node *node = UA_Nodestore_get(server, &id->nodeId);
if(!node) {
v->hasStatus = true;
v->status = UA_STATUSCODE_BADNODEIDUNKNOWN;
return;
}
/* Read the attribute */
UA_StatusCode retval = UA_STATUSCODE_GOOD;
switch(id->attributeId) {
case UA_ATTRIBUTEID_NODEID:
retval = UA_Variant_setScalarCopy(&v->value, &node->nodeId, &UA_TYPES[UA_TYPES_NODEID]);
break;
case UA_ATTRIBUTEID_NODECLASS:
retval = UA_Variant_setScalarCopy(&v->value, &node->nodeClass, &UA_TYPES[UA_TYPES_NODECLASS]);
break;
case UA_ATTRIBUTEID_BROWSENAME:
retval = UA_Variant_setScalarCopy(&v->value, &node->browseName, &UA_TYPES[UA_TYPES_QUALIFIEDNAME]);
break;
case UA_ATTRIBUTEID_DISPLAYNAME:
retval = UA_Variant_setScalarCopy(&v->value, &node->displayName, &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]);
break;
case UA_ATTRIBUTEID_DESCRIPTION:
retval = UA_Variant_setScalarCopy(&v->value, &node->description, &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]);
break;
case UA_ATTRIBUTEID_WRITEMASK:
retval = UA_Variant_setScalarCopy(&v->value, &node->writeMask, &UA_TYPES[UA_TYPES_UINT32]);
break;
case UA_ATTRIBUTEID_USERWRITEMASK: {
UA_UInt32 userWriteMask = getUserWriteMask(server, session, node);
retval = UA_Variant_setScalarCopy(&v->value, &userWriteMask, &UA_TYPES[UA_TYPES_UINT32]);
break; }
case UA_ATTRIBUTEID_ISABSTRACT:
retval = readIsAbstractAttribute(node, &v->value);
break;
case UA_ATTRIBUTEID_SYMMETRIC:
CHECK_NODECLASS(UA_NODECLASS_REFERENCETYPE);
retval = UA_Variant_setScalarCopy(&v->value, &((const UA_ReferenceTypeNode*)node)->symmetric,
&UA_TYPES[UA_TYPES_BOOLEAN]);
break;
case UA_ATTRIBUTEID_INVERSENAME:
CHECK_NODECLASS(UA_NODECLASS_REFERENCETYPE);
retval = UA_Variant_setScalarCopy(&v->value, &((const UA_ReferenceTypeNode*)node)->inverseName,
&UA_TYPES[UA_TYPES_LOCALIZEDTEXT]);
break;
case UA_ATTRIBUTEID_CONTAINSNOLOOPS:
CHECK_NODECLASS(UA_NODECLASS_VIEW);
retval = UA_Variant_setScalarCopy(&v->value, &((const UA_ViewNode*)node)->containsNoLoops,
&UA_TYPES[UA_TYPES_BOOLEAN]);
break;
case UA_ATTRIBUTEID_EVENTNOTIFIER:
CHECK_NODECLASS(UA_NODECLASS_VIEW | UA_NODECLASS_OBJECT);
retval = UA_Variant_setScalarCopy(&v->value, &((const UA_ViewNode*)node)->eventNotifier,
&UA_TYPES[UA_TYPES_BYTE]);
break;
case UA_ATTRIBUTEID_VALUE: {
CHECK_NODECLASS(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
/* VariableTypes don't have the AccessLevel concept. Always allow reading the value. */
if(node->nodeClass == UA_NODECLASS_VARIABLE) {
/* The access to a value variable is granted via the AccessLevel
* and UserAccessLevel attributes */
UA_Byte accessLevel = getAccessLevel(server, session, (const UA_VariableNode*)node);
if(!(accessLevel & (UA_ACCESSLEVELMASK_READ))) {
retval = UA_STATUSCODE_BADNOTREADABLE;
break;
}
accessLevel = getUserAccessLevel(server, session,
(const UA_VariableNode*)node);
if(!(accessLevel & (UA_ACCESSLEVELMASK_READ))) {
retval = UA_STATUSCODE_BADUSERACCESSDENIED;
break;
}
}
retval = readValueAttributeComplete(server, session, (const UA_VariableNode*)node,
op_timestampsToReturn, &id->indexRange, v);
break;
}
case UA_ATTRIBUTEID_DATATYPE:
CHECK_NODECLASS(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
retval = UA_Variant_setScalarCopy(&v->value, &((const UA_VariableTypeNode*)node)->dataType,
&UA_TYPES[UA_TYPES_NODEID]);
break;
case UA_ATTRIBUTEID_VALUERANK:
CHECK_NODECLASS(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
retval = UA_Variant_setScalarCopy(&v->value, &((const UA_VariableTypeNode*)node)->valueRank,
&UA_TYPES[UA_TYPES_INT32]);
break;
case UA_ATTRIBUTEID_ARRAYDIMENSIONS:
CHECK_NODECLASS(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
retval = readArrayDimensionsAttribute((const UA_VariableNode*)node, v);
break;
case UA_ATTRIBUTEID_ACCESSLEVEL:
CHECK_NODECLASS(UA_NODECLASS_VARIABLE);
retval = UA_Variant_setScalarCopy(&v->value, &((const UA_VariableNode*)node)->accessLevel,
&UA_TYPES[UA_TYPES_BYTE]);
break;
case UA_ATTRIBUTEID_USERACCESSLEVEL: {
CHECK_NODECLASS(UA_NODECLASS_VARIABLE);
UA_Byte userAccessLevel = getUserAccessLevel(server, session,
(const UA_VariableNode*)node);
retval = UA_Variant_setScalarCopy(&v->value, &userAccessLevel, &UA_TYPES[UA_TYPES_BYTE]);
break; }
case UA_ATTRIBUTEID_MINIMUMSAMPLINGINTERVAL:
CHECK_NODECLASS(UA_NODECLASS_VARIABLE);
retval = UA_Variant_setScalarCopy(&v->value, &((const UA_VariableNode*)node)->minimumSamplingInterval,
&UA_TYPES[UA_TYPES_DOUBLE]);
break;
case UA_ATTRIBUTEID_HISTORIZING:
CHECK_NODECLASS(UA_NODECLASS_VARIABLE);
retval = UA_Variant_setScalarCopy(&v->value, &((const UA_VariableNode*)node)->historizing,
&UA_TYPES[UA_TYPES_BOOLEAN]);
break;
case UA_ATTRIBUTEID_EXECUTABLE:
CHECK_NODECLASS(UA_NODECLASS_METHOD);
retval = UA_Variant_setScalarCopy(&v->value, &((const UA_MethodNode*)node)->executable,
&UA_TYPES[UA_TYPES_BOOLEAN]);
break;
case UA_ATTRIBUTEID_USEREXECUTABLE: {
CHECK_NODECLASS(UA_NODECLASS_METHOD);
UA_Boolean userExecutable = getUserExecutable(server, session,
(const UA_MethodNode*)node);
retval = UA_Variant_setScalarCopy(&v->value, &userExecutable, &UA_TYPES[UA_TYPES_BOOLEAN]);
break; }
default:
retval = UA_STATUSCODE_BADATTRIBUTEIDINVALID;
}
/* Release nodes */
UA_Nodestore_release(server, node);
/* Return error code when reading has failed */
if(retval != UA_STATUSCODE_GOOD) {
v->hasStatus = true;
v->status = retval;
return;
}
v->hasValue = true;
/* Create server timestamp */
if(op_timestampsToReturn == UA_TIMESTAMPSTORETURN_SERVER ||
op_timestampsToReturn == UA_TIMESTAMPSTORETURN_BOTH) {
v->serverTimestamp = UA_DateTime_now();
v->hasServerTimestamp = true;
}
/* Handle source time stamp */
if(id->attributeId == UA_ATTRIBUTEID_VALUE) {
if(op_timestampsToReturn == UA_TIMESTAMPSTORETURN_SERVER ||
op_timestampsToReturn == UA_TIMESTAMPSTORETURN_NEITHER) {
v->hasSourceTimestamp = false;
v->hasSourcePicoseconds = false;
} else if(!v->hasSourceTimestamp) {
v->sourceTimestamp = UA_DateTime_now();
v->hasSourceTimestamp = true;
}
}
}
/* This function implements the main part of the write service and operates on a
copy of the node (not in single-threaded mode). */
static UA_StatusCode
copyAttributeIntoNode(UA_Server *server, UA_Session *session,
UA_Node *node, const UA_WriteValue *wvalue) {
const void *value = wvalue->value.value.data;
UA_UInt32 userWriteMask = getUserWriteMask(server, session, node);
UA_StatusCode retval = UA_STATUSCODE_GOOD;
const UA_VariableTypeNode *type;
switch(wvalue->attributeId) {
case UA_ATTRIBUTEID_NODEID:
case UA_ATTRIBUTEID_NODECLASS:
case UA_ATTRIBUTEID_USERWRITEMASK:
case UA_ATTRIBUTEID_USERACCESSLEVEL:
case UA_ATTRIBUTEID_USEREXECUTABLE:
retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
break;
case UA_ATTRIBUTEID_BROWSENAME:
CHECK_USERWRITEMASK(UA_WRITEMASK_BROWSENAME);
CHECK_DATATYPE_SCALAR(QUALIFIEDNAME);
UA_QualifiedName_deleteMembers(&node->browseName);
UA_QualifiedName_copy((const UA_QualifiedName *)value, &node->browseName);
break;
case UA_ATTRIBUTEID_DISPLAYNAME:
CHECK_USERWRITEMASK(UA_WRITEMASK_DISPLAYNAME);
CHECK_DATATYPE_SCALAR(LOCALIZEDTEXT);
UA_LocalizedText_deleteMembers(&node->displayName);
UA_LocalizedText_copy((const UA_LocalizedText *)value, &node->displayName);
break;
case UA_ATTRIBUTEID_DESCRIPTION:
CHECK_USERWRITEMASK(UA_WRITEMASK_DESCRIPTION);
CHECK_DATATYPE_SCALAR(LOCALIZEDTEXT);
UA_LocalizedText_deleteMembers(&node->description);
UA_LocalizedText_copy((const UA_LocalizedText *)value, &node->description);
break;
case UA_ATTRIBUTEID_WRITEMASK:
CHECK_USERWRITEMASK(UA_WRITEMASK_WRITEMASK);
CHECK_DATATYPE_SCALAR(UINT32);
node->writeMask = *(const UA_UInt32*)value;
break;
case UA_ATTRIBUTEID_ISABSTRACT:
CHECK_USERWRITEMASK(UA_WRITEMASK_ISABSTRACT);
CHECK_DATATYPE_SCALAR(BOOLEAN);
retval = writeIsAbstractAttribute(node, *(const UA_Boolean*)value);
break;
case UA_ATTRIBUTEID_SYMMETRIC:
CHECK_NODECLASS_WRITE(UA_NODECLASS_REFERENCETYPE);
CHECK_USERWRITEMASK(UA_WRITEMASK_SYMMETRIC);
CHECK_DATATYPE_SCALAR(BOOLEAN);
((UA_ReferenceTypeNode*)node)->symmetric = *(const UA_Boolean*)value;
break;
case UA_ATTRIBUTEID_INVERSENAME:
CHECK_NODECLASS_WRITE(UA_NODECLASS_REFERENCETYPE);
CHECK_USERWRITEMASK(UA_WRITEMASK_INVERSENAME);
CHECK_DATATYPE_SCALAR(LOCALIZEDTEXT);
UA_LocalizedText_deleteMembers(&((UA_ReferenceTypeNode*)node)->inverseName);
UA_LocalizedText_copy((const UA_LocalizedText *)value,
&((UA_ReferenceTypeNode*)node)->inverseName);
break;
case UA_ATTRIBUTEID_CONTAINSNOLOOPS:
CHECK_NODECLASS_WRITE(UA_NODECLASS_VIEW);
CHECK_USERWRITEMASK(UA_WRITEMASK_CONTAINSNOLOOPS);
CHECK_DATATYPE_SCALAR(BOOLEAN);
((UA_ViewNode*)node)->containsNoLoops = *(const UA_Boolean*)value;
break;
case UA_ATTRIBUTEID_EVENTNOTIFIER:
CHECK_NODECLASS_WRITE(UA_NODECLASS_VIEW | UA_NODECLASS_OBJECT);
CHECK_USERWRITEMASK(UA_WRITEMASK_EVENTNOTIFIER);
CHECK_DATATYPE_SCALAR(BYTE);
((UA_ViewNode*)node)->eventNotifier = *(const UA_Byte*)value;
break;
case UA_ATTRIBUTEID_VALUE:
CHECK_NODECLASS_WRITE(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
if(node->nodeClass == UA_NODECLASS_VARIABLE) {
/* The access to a value variable is granted via the AccessLevel
* and UserAccessLevel attributes */
UA_Byte accessLevel = getAccessLevel(server, session, (const UA_VariableNode*)node);
if(!(accessLevel & (UA_ACCESSLEVELMASK_WRITE))) {
retval = UA_STATUSCODE_BADNOTWRITABLE;
break;
}
accessLevel = getUserAccessLevel(server, session,
(const UA_VariableNode*)node);
if(!(accessLevel & (UA_ACCESSLEVELMASK_WRITE))) {
retval = UA_STATUSCODE_BADUSERACCESSDENIED;
break;
}
} else { /* UA_NODECLASS_VARIABLETYPE */
CHECK_USERWRITEMASK(UA_WRITEMASK_VALUEFORVARIABLETYPE);
}
retval = writeValueAttribute(server, session, (UA_VariableNode*)node,
&wvalue->value, &wvalue->indexRange);
break;
case UA_ATTRIBUTEID_DATATYPE:
CHECK_NODECLASS_WRITE(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
CHECK_USERWRITEMASK(UA_WRITEMASK_DATATYPE);
CHECK_DATATYPE_SCALAR(NODEID);
GET_NODETYPE
retval = writeDataTypeAttribute(server, session, (UA_VariableNode*)node,
type, (const UA_NodeId*)value);
UA_Nodestore_release(server, (const UA_Node*)type);
break;
case UA_ATTRIBUTEID_VALUERANK:
CHECK_NODECLASS_WRITE(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
CHECK_USERWRITEMASK(UA_WRITEMASK_VALUERANK);
CHECK_DATATYPE_SCALAR(INT32);
GET_NODETYPE
retval = writeValueRankAttribute(server, session, (UA_VariableNode*)node,
type, *(const UA_Int32*)value);
UA_Nodestore_release(server, (const UA_Node*)type);
break;
case UA_ATTRIBUTEID_ARRAYDIMENSIONS:
CHECK_NODECLASS_WRITE(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
CHECK_USERWRITEMASK(UA_WRITEMASK_ARRRAYDIMENSIONS);
CHECK_DATATYPE_ARRAY(UINT32);
GET_NODETYPE
retval = writeArrayDimensionsAttribute(server, session, (UA_VariableNode*)node,
type, wvalue->value.value.arrayLength,
(UA_UInt32 *)wvalue->value.value.data);
UA_Nodestore_release(server, (const UA_Node*)type);
break;
case UA_ATTRIBUTEID_ACCESSLEVEL:
CHECK_NODECLASS_WRITE(UA_NODECLASS_VARIABLE);
CHECK_USERWRITEMASK(UA_WRITEMASK_ACCESSLEVEL);
CHECK_DATATYPE_SCALAR(BYTE);
((UA_VariableNode*)node)->accessLevel = *(const UA_Byte*)value;
break;
case UA_ATTRIBUTEID_MINIMUMSAMPLINGINTERVAL:
CHECK_NODECLASS_WRITE(UA_NODECLASS_VARIABLE);
CHECK_USERWRITEMASK(UA_WRITEMASK_MINIMUMSAMPLINGINTERVAL);
CHECK_DATATYPE_SCALAR(DOUBLE);
((UA_VariableNode*)node)->minimumSamplingInterval = *(const UA_Double*)value;
break;
case UA_ATTRIBUTEID_HISTORIZING:
CHECK_NODECLASS_WRITE(UA_NODECLASS_VARIABLE);
CHECK_USERWRITEMASK(UA_WRITEMASK_HISTORIZING);
CHECK_DATATYPE_SCALAR(BOOLEAN);
((UA_VariableNode*)node)->historizing = *(const UA_Boolean*)value;
break;
case UA_ATTRIBUTEID_EXECUTABLE:
CHECK_NODECLASS_WRITE(UA_NODECLASS_METHOD);
CHECK_USERWRITEMASK(UA_WRITEMASK_EXECUTABLE);
CHECK_DATATYPE_SCALAR(BOOLEAN);
((UA_MethodNode*)node)->executable = *(const UA_Boolean*)value;
break;
default:
retval = UA_STATUSCODE_BADATTRIBUTEIDINVALID;
break;
}
if(retval != UA_STATUSCODE_GOOD)
UA_LOG_INFO_SESSION(server->config.logger, session,
"WriteRequest returned status code %s",
UA_StatusCode_name(retval));
return retval;
}