static UA_StatusCode
Service_Write_single_ValueDataSource(UA_Server *server, UA_Session *session, const UA_VariableNode *node,
const UA_WriteValue *wvalue) {
UA_assert(wvalue->attributeId == UA_ATTRIBUTEID_VALUE);
UA_assert(node->nodeClass == UA_NODECLASS_VARIABLE || node->nodeClass == UA_NODECLASS_VARIABLETYPE);
UA_assert(node->valueSource == UA_VALUESOURCE_DATASOURCE);
if(node->value.dataSource.write == NULL)
return UA_STATUSCODE_BADWRITENOTSUPPORTED;
UA_StatusCode retval;
if(wvalue->indexRange.length <= 0) {
retval = node->value.dataSource.write(node->value.dataSource.handle, node->nodeId,
&wvalue->value.value, NULL);
} else {
UA_NumericRange range;
retval = parse_numericrange(&wvalue->indexRange, &range);
if(retval != UA_STATUSCODE_GOOD)
return retval;
retval = node->value.dataSource.write(node->value.dataSource.handle, node->nodeId,
&wvalue->value.value, &range);
UA_free(range.dimensions);
}
return retval;
}
static UA_StatusCode
CopyValueIntoNode(UA_VariableNode *node, const UA_WriteValue *wvalue) {
UA_assert(wvalue->attributeId == UA_ATTRIBUTEID_VALUE);
UA_assert(node->nodeClass == UA_NODECLASS_VARIABLE || node->nodeClass == UA_NODECLASS_VARIABLETYPE);
UA_assert(node->valueSource == UA_VALUESOURCE_VARIANT);
/* Parse the range */
UA_NumericRange range;
UA_NumericRange *rangeptr = NULL;
UA_StatusCode retval = UA_STATUSCODE_GOOD;
if(wvalue->indexRange.length > 0) {
retval = parse_numericrange(&wvalue->indexRange, &range);
if(retval != UA_STATUSCODE_GOOD)
return retval;
rangeptr = ⦥
}
/* The nodeid on the wire may be != the nodeid in the node: opaque types, enums and bytestrings.
nodeV contains the correct type definition. */
const UA_Variant *newV = &wvalue->value.value;
UA_Variant *oldV = &node->value.variant.value;
UA_Variant cast_v;
if (oldV->type != NULL) { // Don't run NodeId_equal on a NULL pointer (happens if the variable never held a variant)
if(!UA_NodeId_equal(&oldV->type->typeId, &newV->type->typeId)) {
cast_v = wvalue->value.value;
newV = &cast_v;
enum type_equivalence te1 = typeEquivalence(oldV->type);
enum type_equivalence te2 = typeEquivalence(newV->type);
if(te1 != TYPE_EQUIVALENCE_NONE && te1 == te2) {
/* An enum was sent as an int32, or an opaque type as a bytestring. This is
detected with the typeIndex indicated the "true" datatype. */
cast_v.type = oldV->type;
} else if(oldV->type == &UA_TYPES[UA_TYPES_BYTE] && !UA_Variant_isScalar(oldV) &&
newV->type == &UA_TYPES[UA_TYPES_BYTESTRING] && UA_Variant_isScalar(newV)) {
/* a string is written to a byte array */
UA_ByteString *str = (UA_ByteString*) newV->data;
cast_v.arrayLength = str->length;
cast_v.data = str->data;
cast_v.type = &UA_TYPES[UA_TYPES_BYTE];
} else {
if(rangeptr)
UA_free(range.dimensions);
return UA_STATUSCODE_BADTYPEMISMATCH;
}
}
}
if(!rangeptr) {
UA_Variant_deleteMembers(&node->value.variant.value);
UA_Variant_copy(newV, &node->value.variant.value);
} else
retval = UA_Variant_setRangeCopy(&node->value.variant.value, newV->data, newV->arrayLength, range);
if(node->value.variant.callback.onWrite)
node->value.variant.callback.onWrite(node->value.variant.callback.handle, node->nodeId,
&node->value.variant.value, rangeptr);
if(rangeptr)
UA_free(range.dimensions);
return retval;
}
}END_TEST
START_TEST(numericRange)
{
//UA_Server *server = makeTestSequence();
UA_NumericRange range;
const UA_String str = (UA_String){9, (UA_Byte*)"1:2,0:3,5"};
UA_StatusCode retval = parse_numericrange(str, &range);
ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
ck_assert_int_eq(range.dimensionsSize,3);
ck_assert_int_eq(range.dimensions[0].min,1);
ck_assert_int_eq(range.dimensions[0].max,2);
ck_assert_int_eq(range.dimensions[1].min,0);
ck_assert_int_eq(range.dimensions[1].max,3);
ck_assert_int_eq(range.dimensions[2].min,5);
ck_assert_int_eq(range.dimensions[2].max,5);
}END_TEST
static UA_StatusCode getVariableNodeValue(const UA_VariableNode *vn, const UA_TimestampsToReturn timestamps,
const UA_ReadValueId *id, UA_DataValue *v) {
UA_NumericRange range;
UA_NumericRange *rangeptr = NULL;
UA_StatusCode retval = UA_STATUSCODE_GOOD;
if(id->indexRange.length > 0) {
retval = parse_numericrange(&id->indexRange, &range);
if(retval != UA_STATUSCODE_GOOD)
return retval;
rangeptr = ⦥
}
if(vn->valueSource == UA_VALUESOURCE_VARIANT) {
if(vn->value.variant.callback.onRead)
vn->value.variant.callback.onRead(vn->value.variant.callback.handle, vn->nodeId,
&v->value, rangeptr);
if(!rangeptr) {
v->value = vn->value.variant.value;
v->value.storageType = UA_VARIANT_DATA_NODELETE;
} else
retval = UA_Variant_copyRange(&vn->value.variant.value, &v->value, range);
if(retval == UA_STATUSCODE_GOOD)
handleSourceTimestamps(timestamps, v);
} else {
if(vn->value.dataSource.read == NULL) {
retval = UA_STATUSCODE_BADINTERNALERROR;
} else {
UA_Boolean sourceTimeStamp = (timestamps == UA_TIMESTAMPSTORETURN_SOURCE ||
timestamps == UA_TIMESTAMPSTORETURN_BOTH);
retval = vn->value.dataSource.read(vn->value.dataSource.handle, vn->nodeId,
sourceTimeStamp, rangeptr, v);
}
}
if(rangeptr)
UA_free(range.dimensions);
return retval;
}
/** 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 UA_StatusCode writeValue(UA_Server *server, UA_WriteValue *wvalue) {
UA_StatusCode retval = UA_STATUSCODE_GOOD;
/* is there a value at all */
if(!wvalue->value.hasValue)
return UA_STATUSCODE_BADTYPEMISMATCH;
// we might repeat writing, e.g. when the node got replaced mid-work
UA_Boolean done = UA_FALSE;
while(!done) {
const UA_Node *node = UA_NodeStore_get(server->nodestore, &wvalue->nodeId);
if(!node)
return UA_STATUSCODE_BADNODEIDUNKNOWN;
switch(wvalue->attributeId) {
case UA_ATTRIBUTEID_NODEID:
case UA_ATTRIBUTEID_NODECLASS:
case UA_ATTRIBUTEID_BROWSENAME:
case UA_ATTRIBUTEID_DISPLAYNAME:
case UA_ATTRIBUTEID_DESCRIPTION:
case UA_ATTRIBUTEID_WRITEMASK:
case UA_ATTRIBUTEID_USERWRITEMASK:
case UA_ATTRIBUTEID_ISABSTRACT:
case UA_ATTRIBUTEID_SYMMETRIC:
case UA_ATTRIBUTEID_INVERSENAME:
case UA_ATTRIBUTEID_CONTAINSNOLOOPS:
case UA_ATTRIBUTEID_EVENTNOTIFIER:
retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
break;
case UA_ATTRIBUTEID_VALUE: {
if(node->nodeClass != UA_NODECLASS_VARIABLE &&
node->nodeClass != UA_NODECLASS_VARIABLETYPE) {
retval = UA_STATUSCODE_BADTYPEMISMATCH;
break;
}
/* parse the range */
UA_Boolean hasRange = UA_FALSE;
UA_NumericRange range;
if(wvalue->indexRange.length > 0) {
retval = parse_numericrange(wvalue->indexRange, &range);
if(retval != UA_STATUSCODE_GOOD)
break;
hasRange = UA_TRUE;
}
/* the relevant members are similar for variables and variabletypes */
const UA_VariableNode *vn = (const UA_VariableNode*)node;
if(vn->valueSource == UA_VALUESOURCE_DATASOURCE) {
if(!vn->value.dataSource.write) {
retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
break;
}
// todo: writing ranges
retval = vn->value.dataSource.write(vn->value.dataSource.handle, &wvalue->value.value);
done = UA_TRUE;
break;
}
const UA_Variant *oldV = &vn->value.variant;
/* the nodeid on the wire may be != the nodeid in the node: opaque types, enums and bytestrings */
if(!UA_NodeId_equal(&oldV->type->typeId, &wvalue->value.value.type->typeId)) {
if(oldV->type->namespaceZero && wvalue->value.value.type->namespaceZero &&
oldV->type->typeIndex == wvalue->value.value.type->typeIndex)
/* An enum was sent as an int32, or an opaque type as a bytestring. This is
detected with the typeIndex indicated the "true" datatype. */
wvalue->value.value.type = oldV->type;
else if(oldV->type == &UA_TYPES[UA_TYPES_BYTE] &&
(!oldV->data || vn->value.variant.arrayLength > -1) /* isArray */ &&
wvalue->value.value.type == &UA_TYPES[UA_TYPES_BYTESTRING] &&
wvalue->value.value.data && wvalue->value.value.arrayLength == -1 /* isScalar */) {
/* a string is written to a byte array */
UA_ByteString *str = (UA_ByteString*) wvalue->value.value.data;
wvalue->value.value.arrayLength = str->length;
wvalue->value.value.data = str->data;
wvalue->value.value.type = &UA_TYPES[UA_TYPES_BYTE];
UA_free(str);
} else {
retval = UA_STATUSCODE_BADTYPEMISMATCH;
break;
}
}
/* copy the node */
UA_VariableNode *newVn = (node->nodeClass == UA_NODECLASS_VARIABLE) ?
UA_VariableNode_new() : (UA_VariableNode*)UA_VariableTypeNode_new();
if(!newVn) {
retval = UA_STATUSCODE_BADOUTOFMEMORY;
break;
}
retval = (node->nodeClass == UA_NODECLASS_VARIABLE) ? UA_VariableNode_copy(vn, newVn) :
UA_VariableTypeNode_copy((const UA_VariableTypeNode*)vn, (UA_VariableTypeNode*)newVn);
if(retval != UA_STATUSCODE_GOOD)
goto clean_up;
/* insert the new value*/
if(hasRange)
retval = UA_Variant_setRange(&newVn->value.variant, wvalue->value.value.data, range);
else {
UA_Variant_deleteMembers(&newVn->value.variant);
retval = UA_Variant_copy(&wvalue->value.value, &newVn->value.variant);
}
if(retval != UA_STATUSCODE_GOOD ||
UA_NodeStore_replace(server->nodestore, node, (UA_Node*)newVn,
UA_NULL) != UA_STATUSCODE_GOOD)
goto clean_up;
if(hasRange)
UA_free(range.dimensions);
done = UA_TRUE;
break;
clean_up:
if(node->nodeClass == UA_NODECLASS_VARIABLE)
UA_VariableNode_delete(newVn);
else
UA_VariableTypeNode_delete((UA_VariableTypeNode*)newVn);
if(hasRange)
UA_free(range.dimensions);
}
break;
case UA_ATTRIBUTEID_DATATYPE:
case UA_ATTRIBUTEID_VALUERANK:
case UA_ATTRIBUTEID_ARRAYDIMENSIONS:
case UA_ATTRIBUTEID_ACCESSLEVEL:
case UA_ATTRIBUTEID_USERACCESSLEVEL:
case UA_ATTRIBUTEID_MINIMUMSAMPLINGINTERVAL:
case UA_ATTRIBUTEID_HISTORIZING:
case UA_ATTRIBUTEID_EXECUTABLE:
case UA_ATTRIBUTEID_USEREXECUTABLE:
retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
break;
default:
retval = UA_STATUSCODE_BADATTRIBUTEIDINVALID;
break;
}
UA_NodeStore_release(node);
if(retval != UA_STATUSCODE_GOOD)
break;
}
return retval;
}
