/** Reads a single attribute from a node in the nodestore. */
static void readValue(UA_Server *server, UA_TimestampsToReturn timestamps,
const UA_ReadValueId *id, UA_DataValue *v) {
if(id->dataEncoding.name.length >= 0){
if(memcmp(id->dataEncoding.name.data, "DefaultBinary", 13) != 0 &&
memcmp(id->dataEncoding.name.data, "DefaultXml", 10) != 0) {
v->hasStatus = UA_TRUE;
v->status = UA_STATUSCODE_BADDATAENCODINGINVALID;
return;
}
}
//index range for a non-value
if(id->indexRange.length >= 0 && id->attributeId != UA_ATTRIBUTEID_VALUE){
v->hasStatus = UA_TRUE;
v->status = UA_STATUSCODE_BADINDEXRANGENODATA;
return;
}
UA_Node const *node = UA_NodeStore_get(server->nodestore, &(id->nodeId));
if(!node) {
v->hasStatus = UA_TRUE;
v->status = UA_STATUSCODE_BADNODEIDUNKNOWN;
return;
}
UA_StatusCode retval = UA_STATUSCODE_GOOD;
switch(id->attributeId) {
case UA_ATTRIBUTEID_NODEID:
v->hasValue = UA_TRUE;
retval |= UA_Variant_setScalarCopy(&v->value, &node->nodeId, &UA_TYPES[UA_TYPES_NODEID]);
break;
case UA_ATTRIBUTEID_NODECLASS:
v->hasValue = UA_TRUE;
retval |= UA_Variant_setScalarCopy(&v->value, &node->nodeClass, &UA_TYPES[UA_TYPES_INT32]);
break;
case UA_ATTRIBUTEID_BROWSENAME:
v->hasValue = UA_TRUE;
retval |= UA_Variant_setScalarCopy(&v->value, &node->browseName, &UA_TYPES[UA_TYPES_QUALIFIEDNAME]);
break;
case UA_ATTRIBUTEID_DISPLAYNAME:
retval |= UA_Variant_setScalarCopy(&v->value, &node->displayName, &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]);
if(retval == UA_STATUSCODE_GOOD)
v->hasValue = UA_TRUE;
break;
case UA_ATTRIBUTEID_DESCRIPTION:
v->hasValue = UA_TRUE;
retval |= UA_Variant_setScalarCopy(&v->value, &node->description, &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]);
break;
case UA_ATTRIBUTEID_WRITEMASK:
v->hasValue = UA_TRUE;
retval |= UA_Variant_setScalarCopy(&v->value, &node->writeMask, &UA_TYPES[UA_TYPES_UINT32]);
break;
case UA_ATTRIBUTEID_USERWRITEMASK:
v->hasValue = UA_TRUE;
retval |= UA_Variant_setScalarCopy(&v->value, &node->userWriteMask, &UA_TYPES[UA_TYPES_UINT32]);
break;
case UA_ATTRIBUTEID_ISABSTRACT:
CHECK_NODECLASS(UA_NODECLASS_REFERENCETYPE | UA_NODECLASS_OBJECTTYPE | UA_NODECLASS_VARIABLETYPE |
UA_NODECLASS_DATATYPE);
v->hasValue = UA_TRUE;
retval |= UA_Variant_setScalarCopy(&v->value, &((const UA_ReferenceTypeNode *)node)->isAbstract,
&UA_TYPES[UA_TYPES_BOOLEAN]);
break;
case UA_ATTRIBUTEID_SYMMETRIC:
CHECK_NODECLASS(UA_NODECLASS_REFERENCETYPE);
v->hasValue = UA_TRUE;
retval |= UA_Variant_setScalarCopy(&v->value, &((const UA_ReferenceTypeNode *)node)->symmetric,
&UA_TYPES[UA_TYPES_BOOLEAN]);
break;
case UA_ATTRIBUTEID_INVERSENAME:
CHECK_NODECLASS(UA_NODECLASS_REFERENCETYPE);
v->hasValue = UA_TRUE;
retval |= UA_Variant_setScalarCopy(&v->value, &((const UA_ReferenceTypeNode *)node)->inverseName,
&UA_TYPES[UA_TYPES_LOCALIZEDTEXT]);
break;
case UA_ATTRIBUTEID_CONTAINSNOLOOPS:
CHECK_NODECLASS(UA_NODECLASS_VIEW);
v->hasValue = UA_TRUE;
retval |= UA_Variant_setScalarCopy(&v->value, &((const UA_ViewNode *)node)->containsNoLoops,
&UA_TYPES[UA_TYPES_BOOLEAN]);
break;
case UA_ATTRIBUTEID_EVENTNOTIFIER:
CHECK_NODECLASS(UA_NODECLASS_VIEW | UA_NODECLASS_OBJECT);
v->hasValue = UA_TRUE;
if(node->nodeClass == UA_NODECLASS_VIEW){
retval |= UA_Variant_setScalarCopy(&v->value, &((const UA_ViewNode *)node)->eventNotifier,
&UA_TYPES[UA_TYPES_BYTE]);
} else {
retval |= UA_Variant_setScalarCopy(&v->value, &((const UA_ObjectNode *)node)->eventNotifier,
&UA_TYPES[UA_TYPES_BYTE]);
}
break;
case UA_ATTRIBUTEID_VALUE:
CHECK_NODECLASS(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
{
if(node->nodeClass != UA_NODECLASS_VARIABLE) {
v->hasValue = UA_FALSE;
handleSourceTimestamps(timestamps, v);
}
UA_Boolean hasRange = UA_FALSE;
UA_NumericRange range;
if(id->indexRange.length > 0) {
retval = parse_numericrange(id->indexRange, &range);
if(retval != UA_STATUSCODE_GOOD)
break;
hasRange = UA_TRUE;
}
const UA_VariableNode *vn = (const UA_VariableNode*)node;
if(vn->valueSource == UA_VALUESOURCE_VARIANT) {
if(hasRange)
retval |= UA_Variant_copyRange(&vn->value.variant, &v->value, range);
else
retval |= UA_Variant_copy(&vn->value.variant, &v->value);
if(retval == UA_STATUSCODE_GOOD) {
v->hasValue = UA_TRUE;
handleSourceTimestamps(timestamps, v);
}
} else {
UA_DataValue val;
UA_DataValue_init(&val);
UA_Boolean sourceTimeStamp = (timestamps == UA_TIMESTAMPSTORETURN_SOURCE ||
timestamps == UA_TIMESTAMPSTORETURN_BOTH);
retval |= vn->value.dataSource.read(vn->value.dataSource.handle, sourceTimeStamp, &val);
if(retval == UA_STATUSCODE_GOOD) {
retval |= UA_DataValue_copy(&val, v); // todo: selection of indexranges
}
vn->value.dataSource.release(vn->value.dataSource.handle, &val);
}
if(hasRange)
UA_free(range.dimensions);
}
break;
case UA_ATTRIBUTEID_DATATYPE: {
CHECK_NODECLASS(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
const UA_VariableNode *vn = (const UA_VariableNode*)node;
if(vn->valueSource == UA_VALUESOURCE_VARIANT)
retval = UA_Variant_setScalarCopy(&v->value, &vn->value.variant.type->typeId,
&UA_TYPES[UA_TYPES_NODEID]);
else {
UA_DataValue val;
UA_DataValue_init(&val);
retval = vn->value.dataSource.read(vn->value.dataSource.handle, UA_FALSE, &val);
if(retval != UA_STATUSCODE_GOOD)
break;
retval = UA_Variant_setScalarCopy(&v->value, &val.value.type->typeId, &UA_TYPES[UA_TYPES_NODEID]);
vn->value.dataSource.release(vn->value.dataSource.handle, &val);
}
if(retval == UA_STATUSCODE_GOOD)
v->hasValue = UA_TRUE;
}
break;
case UA_ATTRIBUTEID_VALUERANK:
CHECK_NODECLASS(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
v->hasValue = UA_TRUE;
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);
{
const UA_VariableNode *vn = (const UA_VariableNode *)node;
if(vn->valueSource == UA_VALUESOURCE_VARIANT) {
retval = UA_Variant_setArrayCopy(&v->value, vn->value.variant.arrayDimensions,
vn->value.variant.arrayDimensionsSize,
&UA_TYPES[UA_TYPES_INT32]);
if(retval == UA_STATUSCODE_GOOD)
v->hasValue = UA_TRUE;
} else {
UA_DataValue val;
UA_DataValue_init(&val);
retval |= vn->value.dataSource.read(vn->value.dataSource.handle, UA_FALSE, &val);
if(retval != UA_STATUSCODE_GOOD)
break;
if(!val.hasValue)
retval = UA_STATUSCODE_BADNOTREADABLE;
else
retval = UA_Variant_setArrayCopy(&v->value, val.value.arrayDimensions,
val.value.arrayDimensionsSize, &UA_TYPES[UA_TYPES_INT32]);
vn->value.dataSource.release(vn->value.dataSource.handle, &val);
}
}
break;
case UA_ATTRIBUTEID_ACCESSLEVEL:
CHECK_NODECLASS(UA_NODECLASS_VARIABLE);
v->hasValue = UA_TRUE;
retval |= UA_Variant_setScalarCopy(&v->value, &((const UA_VariableNode *)node)->accessLevel,
&UA_TYPES[UA_TYPES_BYTE]);
break;
case UA_ATTRIBUTEID_USERACCESSLEVEL:
CHECK_NODECLASS(UA_NODECLASS_VARIABLE);
v->hasValue = UA_TRUE;
retval |= UA_Variant_setScalarCopy(&v->value, &((const UA_VariableNode *)node)->userAccessLevel,
&UA_TYPES[UA_TYPES_BYTE]);
break;
case UA_ATTRIBUTEID_MINIMUMSAMPLINGINTERVAL:
CHECK_NODECLASS(UA_NODECLASS_VARIABLE);
v->hasValue = UA_TRUE;
retval |= UA_Variant_setScalarCopy(&v->value, &((const UA_VariableNode *)node)->minimumSamplingInterval,
&UA_TYPES[UA_TYPES_DOUBLE]);
break;
case UA_ATTRIBUTEID_HISTORIZING:
CHECK_NODECLASS(UA_NODECLASS_VARIABLE);
v->hasValue = UA_TRUE;
retval |= UA_Variant_setScalarCopy(&v->value, &((const UA_VariableNode *)node)->historizing,
&UA_TYPES[UA_TYPES_BOOLEAN]);
break;
case UA_ATTRIBUTEID_EXECUTABLE:
CHECK_NODECLASS(UA_NODECLASS_METHOD);
v->hasValue = UA_TRUE;
retval |= UA_Variant_setScalarCopy(&v->value, &((const UA_MethodNode *)node)->executable,
&UA_TYPES[UA_TYPES_BOOLEAN]);
break;
case UA_ATTRIBUTEID_USEREXECUTABLE:
CHECK_NODECLASS(UA_NODECLASS_METHOD);
v->hasValue = UA_TRUE;
retval |= UA_Variant_setScalarCopy(&v->value, &((const UA_MethodNode *)node)->userExecutable,
&UA_TYPES[UA_TYPES_BOOLEAN]);
break;
default:
v->hasStatus = UA_TRUE;
v->status = UA_STATUSCODE_BADATTRIBUTEIDINVALID;
break;
}
UA_NodeStore_release(node);
if(retval != UA_STATUSCODE_GOOD) {
v->hasStatus = UA_TRUE;
v->status = retval;
}
handleServerTimestamps(timestamps, v);
}
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;
}
}
}
/** Reads a single attribute from a node in the nodestore. */
void Service_Read_single(UA_Server *server, UA_Session *session, const UA_TimestampsToReturn timestamps,
const UA_ReadValueId *id, UA_DataValue *v) {
if(id->dataEncoding.name.length > 0 && !UA_String_equal(&binEncoding, &id->dataEncoding.name)) {
v->hasStatus = UA_TRUE;
v->status = UA_STATUSCODE_BADDATAENCODINGINVALID;
return;
}
//index range for a non-value
if(id->indexRange.length > 0 && id->attributeId != UA_ATTRIBUTEID_VALUE){
v->hasStatus = UA_TRUE;
v->status = UA_STATUSCODE_BADINDEXRANGENODATA;
return;
}
UA_Node const *node = UA_NodeStore_get(server->nodestore, &id->nodeId);
if(!node) {
v->hasStatus = UA_TRUE;
v->status = UA_STATUSCODE_BADNODEIDUNKNOWN;
return;
}
/* When setting the value fails in the switch, we get an error code and set hasValue to false */
UA_StatusCode retval = UA_STATUSCODE_GOOD;
v->hasValue = UA_TRUE;
switch(id->attributeId) {
case UA_ATTRIBUTEID_NODEID:
forceVariantSetScalar(&v->value, &node->nodeId, &UA_TYPES[UA_TYPES_NODEID]);
break;
case UA_ATTRIBUTEID_NODECLASS:
forceVariantSetScalar(&v->value, &node->nodeClass, &UA_TYPES[UA_TYPES_INT32]);
break;
case UA_ATTRIBUTEID_BROWSENAME:
forceVariantSetScalar(&v->value, &node->browseName, &UA_TYPES[UA_TYPES_QUALIFIEDNAME]);
break;
case UA_ATTRIBUTEID_DISPLAYNAME:
forceVariantSetScalar(&v->value, &node->displayName, &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]);
break;
case UA_ATTRIBUTEID_DESCRIPTION:
forceVariantSetScalar(&v->value, &node->description, &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]);
break;
case UA_ATTRIBUTEID_WRITEMASK:
forceVariantSetScalar(&v->value, &node->writeMask, &UA_TYPES[UA_TYPES_UINT32]);
break;
case UA_ATTRIBUTEID_USERWRITEMASK:
forceVariantSetScalar(&v->value, &node->userWriteMask, &UA_TYPES[UA_TYPES_UINT32]);
break;
case UA_ATTRIBUTEID_ISABSTRACT:
CHECK_NODECLASS(UA_NODECLASS_REFERENCETYPE | UA_NODECLASS_OBJECTTYPE |
UA_NODECLASS_VARIABLETYPE | UA_NODECLASS_DATATYPE);
forceVariantSetScalar(&v->value, &((const UA_ReferenceTypeNode*)node)->isAbstract,
&UA_TYPES[UA_TYPES_BOOLEAN]);
break;
case UA_ATTRIBUTEID_SYMMETRIC:
CHECK_NODECLASS(UA_NODECLASS_REFERENCETYPE);
forceVariantSetScalar(&v->value, &((const UA_ReferenceTypeNode*)node)->symmetric,
&UA_TYPES[UA_TYPES_BOOLEAN]);
break;
case UA_ATTRIBUTEID_INVERSENAME:
CHECK_NODECLASS(UA_NODECLASS_REFERENCETYPE);
forceVariantSetScalar(&v->value, &((const UA_ReferenceTypeNode*)node)->inverseName,
&UA_TYPES[UA_TYPES_LOCALIZEDTEXT]);
break;
case UA_ATTRIBUTEID_CONTAINSNOLOOPS:
CHECK_NODECLASS(UA_NODECLASS_VIEW);
forceVariantSetScalar(&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);
forceVariantSetScalar(&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);
retval = getVariableNodeValue((const UA_VariableNode*)node, timestamps, id, v);
break;
case UA_ATTRIBUTEID_DATATYPE:
CHECK_NODECLASS(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
retval = getVariableNodeDataType((const UA_VariableNode*)node, v);
break;
case UA_ATTRIBUTEID_VALUERANK:
CHECK_NODECLASS(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
forceVariantSetScalar(&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 = getVariableNodeArrayDimensions((const UA_VariableNode*)node, v);
break;
case UA_ATTRIBUTEID_ACCESSLEVEL:
CHECK_NODECLASS(UA_NODECLASS_VARIABLE);
forceVariantSetScalar(&v->value, &((const UA_VariableNode*)node)->accessLevel,
&UA_TYPES[UA_TYPES_BYTE]);
break;
case UA_ATTRIBUTEID_USERACCESSLEVEL:
CHECK_NODECLASS(UA_NODECLASS_VARIABLE);
forceVariantSetScalar(&v->value, &((const UA_VariableNode*)node)->userAccessLevel,
&UA_TYPES[UA_TYPES_BYTE]);
break;
case UA_ATTRIBUTEID_MINIMUMSAMPLINGINTERVAL:
CHECK_NODECLASS(UA_NODECLASS_VARIABLE);
forceVariantSetScalar(&v->value, &((const UA_VariableNode*)node)->minimumSamplingInterval,
&UA_TYPES[UA_TYPES_DOUBLE]);
break;
case UA_ATTRIBUTEID_HISTORIZING:
CHECK_NODECLASS(UA_NODECLASS_VARIABLE);
forceVariantSetScalar(&v->value, &((const UA_VariableNode*)node)->historizing,
&UA_TYPES[UA_TYPES_BOOLEAN]);
break;
case UA_ATTRIBUTEID_EXECUTABLE:
CHECK_NODECLASS(UA_NODECLASS_METHOD);
forceVariantSetScalar(&v->value, &((const UA_MethodNode*)node)->executable,
&UA_TYPES[UA_TYPES_BOOLEAN]);
break;
case UA_ATTRIBUTEID_USEREXECUTABLE:
CHECK_NODECLASS(UA_NODECLASS_METHOD);
forceVariantSetScalar(&v->value, &((const UA_MethodNode*)node)->userExecutable,
&UA_TYPES[UA_TYPES_BOOLEAN]);
break;
default:
retval = UA_STATUSCODE_BADATTRIBUTEIDINVALID;
break;
}
if(retval != UA_STATUSCODE_GOOD) {
v->hasValue = UA_FALSE;
v->hasStatus = UA_TRUE;
v->status = retval;
}
// Todo: what if the timestamp from the datasource are already present?
handleServerTimestamps(timestamps, v);
}
static UA_DataValue service_read_node(UA_Server *server, const UA_ReadValueId *id) {
UA_DataValue v;
UA_DataValue_init(&v);
UA_Node const *node = UA_NULL;
UA_Int32 result = UA_NodeStore_get(server->nodestore, &(id->nodeId), &node);
if(result != UA_STATUSCODE_GOOD || node == UA_NULL) {
v.encodingMask = UA_DATAVALUE_ENCODINGMASK_STATUSCODE;
v.status = UA_STATUSCODE_BADNODEIDUNKNOWN;
return v;
}
UA_StatusCode retval = UA_STATUSCODE_GOOD;
switch(id->attributeId) {
case UA_ATTRIBUTEID_NODEID:
v.encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
retval |= UA_Variant_copySetValue(&v.value, &UA_TYPES[UA_NODEID], &node->nodeId);
break;
case UA_ATTRIBUTEID_NODECLASS:
v.encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
retval |= UA_Variant_copySetValue(&v.value, &UA_TYPES[UA_INT32], &node->nodeClass);
break;
case UA_ATTRIBUTEID_BROWSENAME:
v.encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
retval |= UA_Variant_copySetValue(&v.value, &UA_TYPES[UA_QUALIFIEDNAME], &node->browseName);
break;
case UA_ATTRIBUTEID_DISPLAYNAME:
v.encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
retval |= UA_Variant_copySetValue(&v.value, &UA_TYPES[UA_LOCALIZEDTEXT], &node->displayName);
break;
case UA_ATTRIBUTEID_DESCRIPTION:
v.encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
retval |= UA_Variant_copySetValue(&v.value, &UA_TYPES[UA_LOCALIZEDTEXT], &node->description);
break;
case UA_ATTRIBUTEID_WRITEMASK:
v.encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
retval |= UA_Variant_copySetValue(&v.value, &UA_TYPES[UA_UINT32], &node->writeMask);
break;
case UA_ATTRIBUTEID_USERWRITEMASK:
v.encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
retval |= UA_Variant_copySetValue(&v.value, &UA_TYPES[UA_UINT32], &node->userWriteMask);
break;
case UA_ATTRIBUTEID_ISABSTRACT:
CHECK_NODECLASS(
UA_NODECLASS_REFERENCETYPE | UA_NODECLASS_OBJECTTYPE | UA_NODECLASS_VARIABLETYPE |
UA_NODECLASS_DATATYPE);
v.encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
retval |=
UA_Variant_copySetValue(&v.value, &UA_TYPES[UA_BOOLEAN], &((UA_ReferenceTypeNode *)node)->isAbstract);
break;
case UA_ATTRIBUTEID_SYMMETRIC:
CHECK_NODECLASS(UA_NODECLASS_REFERENCETYPE);
v.encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
retval |= UA_Variant_copySetValue(&v.value, &UA_TYPES[UA_BOOLEAN],
&((UA_ReferenceTypeNode *)node)->symmetric);
break;
case UA_ATTRIBUTEID_INVERSENAME:
CHECK_NODECLASS(UA_NODECLASS_REFERENCETYPE);
v.encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
retval |= UA_Variant_copySetValue(&v.value, &UA_TYPES[UA_LOCALIZEDTEXT],
&((UA_ReferenceTypeNode *)node)->inverseName);
break;
case UA_ATTRIBUTEID_CONTAINSNOLOOPS:
CHECK_NODECLASS(UA_NODECLASS_VIEW);
v.encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
retval |= UA_Variant_copySetValue(&v.value, &UA_TYPES[UA_BOOLEAN],
&((UA_ViewNode *)node)->containsNoLoops);
break;
case UA_ATTRIBUTEID_EVENTNOTIFIER:
CHECK_NODECLASS(UA_NODECLASS_VIEW | UA_NODECLASS_OBJECT);
v.encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
retval |= UA_Variant_copySetValue(&v.value, &UA_TYPES[UA_BYTE],
&((UA_ViewNode *)node)->eventNotifier);
break;
case UA_ATTRIBUTEID_VALUE:
CHECK_NODECLASS(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
v.encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
retval |= UA_Variant_copy(&((UA_VariableNode *)node)->value, &v.value); // todo: zero-copy
break;
case UA_ATTRIBUTEID_DATATYPE:
CHECK_NODECLASS(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
v.encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
retval |= UA_Variant_copySetValue(&v.value, &UA_TYPES[UA_NODEID],
&((UA_VariableTypeNode *)node)->dataType);
break;
case UA_ATTRIBUTEID_VALUERANK:
CHECK_NODECLASS(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
v.encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
retval |= UA_Variant_copySetValue(&v.value, &UA_TYPES[UA_INT32],
&((UA_VariableTypeNode *)node)->valueRank);
break;
case UA_ATTRIBUTEID_ARRAYDIMENSIONS:
CHECK_NODECLASS(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
v.encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
UA_Variant_copySetArray(&v.value, &UA_TYPES[UA_UINT32],
((UA_VariableTypeNode *)node)->arrayDimensionsSize,
&((UA_VariableTypeNode *)node)->arrayDimensions);
break;
case UA_ATTRIBUTEID_ACCESSLEVEL:
CHECK_NODECLASS(UA_NODECLASS_VARIABLE);
v.encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
retval |= UA_Variant_copySetValue(&v.value, &UA_TYPES[UA_BYTE],
&((UA_VariableNode *)node)->accessLevel);
break;
case UA_ATTRIBUTEID_USERACCESSLEVEL:
CHECK_NODECLASS(UA_NODECLASS_VARIABLE);
v.encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
retval |= UA_Variant_copySetValue(&v.value, &UA_TYPES[UA_BYTE],
&((UA_VariableNode *)node)->userAccessLevel);
break;
case UA_ATTRIBUTEID_MINIMUMSAMPLINGINTERVAL:
CHECK_NODECLASS(UA_NODECLASS_VARIABLE);
v.encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
retval |= UA_Variant_copySetValue(&v.value, &UA_TYPES[UA_DOUBLE],
&((UA_VariableNode *)node)->minimumSamplingInterval);
break;
case UA_ATTRIBUTEID_HISTORIZING:
CHECK_NODECLASS(UA_NODECLASS_VARIABLE);
v.encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
retval |= UA_Variant_copySetValue(&v.value, &UA_TYPES[UA_BOOLEAN],
&((UA_VariableNode *)node)->historizing);
break;
case UA_ATTRIBUTEID_EXECUTABLE:
CHECK_NODECLASS(UA_NODECLASS_METHOD);
v.encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
retval |= UA_Variant_copySetValue(&v.value, &UA_TYPES[UA_BOOLEAN],
&((UA_MethodNode *)node)->executable);
break;
case UA_ATTRIBUTEID_USEREXECUTABLE:
CHECK_NODECLASS(UA_NODECLASS_METHOD);
v.encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
retval |= UA_Variant_copySetValue(&v.value, &UA_TYPES[UA_BOOLEAN],
&((UA_MethodNode *)node)->userExecutable);
break;
default:
v.encodingMask = UA_DATAVALUE_ENCODINGMASK_STATUSCODE;
v.status = UA_STATUSCODE_BADATTRIBUTEIDINVALID;
break;
}
UA_NodeStore_release(node);
if(retval != UA_STATUSCODE_GOOD) {
v.encodingMask = UA_DATAVALUE_ENCODINGMASK_STATUSCODE;
v.status = UA_STATUSCODE_BADNOTREADABLE;
}
return v;
}
