void UA_NodeStore_iterate(const UA_NodeStore *ns, UA_NodeStore_nodeVisitor visitor) {
struct cds_lfht *ht = ns->ht;
struct cds_lfht_iter iter;
rcu_read_lock();
cds_lfht_first(ht, &iter);
while(iter.node != NULL) {
struct nodeEntry *found_entry = (struct nodeEntry *)cds_lfht_iter_get_node(&iter);
uatomic_inc(&found_entry->refcount);
const UA_Node *node = &found_entry->node;
rcu_read_unlock();
visitor(node);
UA_NodeStore_release((const UA_Node *)node);
rcu_read_lock();
cds_lfht_next(ht, &iter);
}
rcu_read_unlock();
}
static const UA_VariableNode *getArgumentsVariableNode(UA_Server *server, const UA_MethodNode *ofMethod,
UA_String withBrowseName) {
const UA_Node *refTarget;
UA_NodeId hasProperty = UA_NODEID_NUMERIC(0, UA_NS0ID_HASPROPERTY);
for(UA_Int32 i = 0; i < ofMethod->referencesSize; i++) {
if(ofMethod->references[i].isInverse == UA_FALSE &&
UA_NodeId_equal(&hasProperty, &ofMethod->references[i].referenceTypeId)) {
refTarget = UA_NodeStore_get(server->nodestore, &ofMethod->references[i].targetId.nodeId);
if(!refTarget)
continue;
if(refTarget->nodeClass == UA_NODECLASS_VARIABLE &&
refTarget->browseName.namespaceIndex == 0 &&
UA_String_equal(&withBrowseName, &refTarget->browseName.name)) {
return (const UA_VariableNode*) refTarget;
}
UA_NodeStore_release(refTarget);
}
}
return UA_NULL;
}
/** 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;
}
/* Adds a one-way reference to the local nodestore */
static UA_StatusCode
addOneWayReferenceWithSession(UA_Server *server, UA_Session *session, const UA_AddReferencesItem *item) {
const UA_Node *node = UA_NodeStore_get(server->nodestore, &item->sourceNodeId);
if(!node)
return UA_STATUSCODE_BADINTERNALERROR;
UA_StatusCode retval = UA_STATUSCODE_GOOD;
#ifndef UA_MULTITHREADING
size_t i = node->referencesSize;
if(node->referencesSize < 0)
i = 0;
size_t refssize = (i+1) | 3; // so the realloc is not necessary every time
UA_ReferenceNode *new_refs = UA_realloc(node->references, sizeof(UA_ReferenceNode) * refssize);
if(!new_refs)
retval = UA_STATUSCODE_BADOUTOFMEMORY;
else {
UA_ReferenceNode_init(&new_refs[i]);
retval = UA_NodeId_copy(&item->referenceTypeId, &new_refs[i].referenceTypeId);
new_refs[i].isInverse = !item->isForward;
retval |= UA_ExpandedNodeId_copy(&item->targetNodeId, &new_refs[i].targetId);
/* hack. be careful! possible only in the single-threaded case. */
UA_Node *mutable_node = (UA_Node*)(uintptr_t)node;
mutable_node->references = new_refs;
if(retval != UA_STATUSCODE_GOOD) {
UA_NodeId_deleteMembers(&new_refs[node->referencesSize].referenceTypeId);
UA_ExpandedNodeId_deleteMembers(&new_refs[node->referencesSize].targetId);
} else
mutable_node->referencesSize = i+1;
}
UA_NodeStore_release(node);
return retval;
#else
UA_Node *newNode = UA_NULL;
void (*deleteNode)(UA_Node*) = UA_NULL;
switch(node->nodeClass) {
case UA_NODECLASS_OBJECT:
newNode = (UA_Node*)UA_ObjectNode_new();
UA_ObjectNode_copy((const UA_ObjectNode*)node, (UA_ObjectNode*)newNode);
deleteNode = (void (*)(UA_Node*))UA_ObjectNode_delete;
break;
case UA_NODECLASS_VARIABLE:
newNode = (UA_Node*)UA_VariableNode_new();
UA_VariableNode_copy((const UA_VariableNode*)node, (UA_VariableNode*)newNode);
deleteNode = (void (*)(UA_Node*))UA_VariableNode_delete;
break;
case UA_NODECLASS_METHOD:
newNode = (UA_Node*)UA_MethodNode_new();
UA_MethodNode_copy((const UA_MethodNode*)node, (UA_MethodNode*)newNode);
deleteNode = (void (*)(UA_Node*))UA_MethodNode_delete;
break;
case UA_NODECLASS_OBJECTTYPE:
newNode = (UA_Node*)UA_ObjectTypeNode_new();
UA_ObjectTypeNode_copy((const UA_ObjectTypeNode*)node, (UA_ObjectTypeNode*)newNode);
deleteNode = (void (*)(UA_Node*))UA_ObjectTypeNode_delete;
break;
case UA_NODECLASS_VARIABLETYPE:
newNode = (UA_Node*)UA_VariableTypeNode_new();
UA_VariableTypeNode_copy((const UA_VariableTypeNode*)node, (UA_VariableTypeNode*)newNode);
deleteNode = (void (*)(UA_Node*))UA_VariableTypeNode_delete;
break;
case UA_NODECLASS_REFERENCETYPE:
newNode = (UA_Node*)UA_ReferenceTypeNode_new();
UA_ReferenceTypeNode_copy((const UA_ReferenceTypeNode*)node, (UA_ReferenceTypeNode*)newNode);
deleteNode = (void (*)(UA_Node*))UA_ReferenceTypeNode_delete;
break;
case UA_NODECLASS_DATATYPE:
newNode = (UA_Node*)UA_DataTypeNode_new();
UA_DataTypeNode_copy((const UA_DataTypeNode*)node, (UA_DataTypeNode*)newNode);
deleteNode = (void (*)(UA_Node*))UA_DataTypeNode_delete;
break;
case UA_NODECLASS_VIEW:
newNode = (UA_Node*)UA_ViewNode_new();
UA_ViewNode_copy((const UA_ViewNode*)node, (UA_ViewNode*)newNode);
deleteNode = (void (*)(UA_Node*))UA_ViewNode_delete;
break;
default:
return UA_STATUSCODE_BADINTERNALERROR;
}
UA_Int32 count = node->referencesSize;
if(count < 0)
count = 0;
UA_ReferenceNode *old_refs = newNode->references;
UA_ReferenceNode *new_refs = UA_malloc(sizeof(UA_ReferenceNode)*(count+1));
if(!new_refs) {
deleteNode(newNode);
UA_NodeStore_release(node);
return UA_STATUSCODE_BADOUTOFMEMORY;
}
// insert the new reference
UA_memcpy(new_refs, old_refs, sizeof(UA_ReferenceNode)*count);
UA_ReferenceNode_init(&new_refs[count]);
retval = UA_NodeId_copy(&item->referenceTypeId, &new_refs[count].referenceTypeId);
new_refs[count].isInverse = !item->isForward;
retval |= UA_ExpandedNodeId_copy(&item->targetNodeId, &new_refs[count].targetId);
if(retval != UA_STATUSCODE_GOOD) {
UA_Array_delete(new_refs, &UA_TYPES[UA_TYPES_REFERENCENODE], ++count);
newNode->references = UA_NULL;
newNode->referencesSize = 0;
deleteNode(newNode);
UA_NodeStore_release(node);
return UA_STATUSCODE_BADOUTOFMEMORY;
}
UA_free(old_refs);
newNode->references = new_refs;
newNode->referencesSize = ++count;
retval = UA_NodeStore_replace(server->nodestore, node, newNode, UA_NULL);
UA_NodeStore_release(node);
if (retval == UA_STATUSCODE_BADINTERNALERROR) {
/* presumably because the node was replaced and an old version was updated at the same time. just try again */
deleteNode(newNode);
return addOneWayReferenceWithSession(server, session, item);
}
return retval;
#endif
}
UA_AddNodesResult
UA_Server_addNodeWithSession(UA_Server *server, UA_Session *session, UA_Node *node,
const UA_ExpandedNodeId parentNodeId, const UA_NodeId referenceTypeId)
{
UA_AddNodesResult result;
UA_AddNodesResult_init(&result);
if(node->nodeId.namespaceIndex >= server->namespacesSize) {
result.statusCode = UA_STATUSCODE_BADNODEIDINVALID;
return result;
}
const UA_Node *parent = UA_NodeStore_get(server->nodestore, &parentNodeId.nodeId);
if(!parent) {
result.statusCode = UA_STATUSCODE_BADPARENTNODEIDINVALID;
return result;
}
const UA_ReferenceTypeNode *referenceType =
(const UA_ReferenceTypeNode *)UA_NodeStore_get(server->nodestore, &referenceTypeId);
if(!referenceType) {
result.statusCode = UA_STATUSCODE_BADREFERENCETYPEIDINVALID;
goto ret;
}
if(referenceType->nodeClass != UA_NODECLASS_REFERENCETYPE) {
result.statusCode = UA_STATUSCODE_BADREFERENCETYPEIDINVALID;
goto ret2;
}
if(referenceType->isAbstract == UA_TRUE) {
result.statusCode = UA_STATUSCODE_BADREFERENCENOTALLOWED;
goto ret2;
}
// todo: test if the referencetype is hierarchical
const UA_Node *managed = UA_NULL;
if(UA_NodeId_isNull(&node->nodeId)) {
if(UA_NodeStore_insert(server->nodestore, node, &managed) != UA_STATUSCODE_GOOD) {
result.statusCode = UA_STATUSCODE_BADOUTOFMEMORY;
goto ret2;
}
result.addedNodeId = managed->nodeId; // cannot fail as unique nodeids are numeric
} else {
if(UA_NodeId_copy(&node->nodeId, &result.addedNodeId) != UA_STATUSCODE_GOOD) {
result.statusCode = UA_STATUSCODE_BADOUTOFMEMORY;
goto ret2;
}
if(UA_NodeStore_insert(server->nodestore, node, &managed) != UA_STATUSCODE_GOOD) {
result.statusCode = UA_STATUSCODE_BADNODEIDEXISTS; // todo: differentiate out of memory
UA_NodeId_deleteMembers(&result.addedNodeId);
goto ret2;
}
}
// reference back to the parent
UA_AddReferencesItem item;
UA_AddReferencesItem_init(&item);
item.sourceNodeId = managed->nodeId;
item.referenceTypeId = referenceType->nodeId;
item.isForward = UA_FALSE;
item.targetNodeId.nodeId = parent->nodeId;
UA_Server_addReference(server, &item);
// todo: error handling. remove new node from nodestore
UA_NodeStore_release(managed);
ret2:
UA_NodeStore_release((const UA_Node*)referenceType);
ret:
UA_NodeStore_release(parent);
return result;
}
void Service_Call(UA_Server *server, UA_Session *session, const UA_CallRequest *request,
UA_CallResponse *response) {
if(request->methodsToCallSize <= 0) {
response->responseHeader.serviceResult = UA_STATUSCODE_BADNOTHINGTODO;
return;
}
response->results = UA_Array_new(&UA_TYPES[UA_TYPES_CALLMETHODRESULT], request->methodsToCallSize);
if(!response->results) {
response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY;
return;
}
response->resultsSize = request->methodsToCallSize;
for(UA_Int32 i = 0; i < request->methodsToCallSize;i++) {
UA_CallMethodRequest *rq = &request->methodsToCall[i];
UA_CallMethodResult *rs = &response->results[i];
/* Get/Check Nodes */
const UA_MethodNode *methodCalled =
(const UA_MethodNode*) UA_NodeStore_get(server->nodestore, &rq->methodId);
if(methodCalled == UA_NULL) {
rs->statusCode = UA_STATUSCODE_BADMETHODINVALID;
continue;
}
const UA_ObjectNode *withObject =
(const UA_ObjectNode *) UA_NodeStore_get(server->nodestore, &rq->objectId);
if(withObject == UA_NULL) {
rs->statusCode = UA_STATUSCODE_BADNODEIDINVALID;
printf("Obj not found\n");
continue;
}
if(methodCalled->nodeClass != UA_NODECLASS_METHOD) {
rs->statusCode = UA_STATUSCODE_BADNODECLASSINVALID;
continue;
}
if(withObject->nodeClass != UA_NODECLASS_OBJECT && withObject->nodeClass != UA_NODECLASS_OBJECTTYPE) {
rs->statusCode = UA_STATUSCODE_BADNODECLASSINVALID;
printf("Obj not found 1\n");
continue;
}
/* Verify method/object relations */
// Object must have a hasComponent reference (or any inherited referenceType from sayd reference)
// to be valid for a methodCall...
for(UA_Int32 i = 0; i < withObject->referencesSize; i++) {
if(withObject->references[i].referenceTypeId.identifier.numeric == UA_NS0ID_HASCOMPONENT) {
// FIXME: Not checking any subtypes of HasComponent at the moment
if(UA_NodeId_equal(&withObject->references[i].targetId.nodeId, &methodCalled->nodeId)) {
rs->statusCode = UA_STATUSCODE_GOOD;
break;
}
}
}
if(rs->statusCode != UA_STATUSCODE_GOOD)
continue;
/* Verify method executable */
if(((const UA_MethodNode *) methodCalled)->executable == UA_FALSE ||
((const UA_MethodNode *) methodCalled)->userExecutable == UA_FALSE ) {
rs->statusCode = UA_STATUSCODE_BADNOTWRITABLE; // There is no NOTEXECUTABLE?
continue;
}
/* Verify Input Argument count, types and sizes */
const UA_VariableNode *inputArguments = getArgumentsVariableNode(server, methodCalled,
UA_STRING("InputArguments"));
if(inputArguments) {
// Expects arguments
rs->statusCode = argConformsToDefinition(rq, inputArguments);
UA_NodeStore_release((const UA_Node*)inputArguments);
if(rs->statusCode != UA_STATUSCODE_GOOD)
continue;
} else if(rq->inputArgumentsSize > 0) {
// Expects no arguments, but got some
rs->statusCode = UA_STATUSCODE_BADINVALIDARGUMENT;
UA_NodeStore_release((const UA_Node*)inputArguments);
continue;
}
const UA_VariableNode *outputArguments = getArgumentsVariableNode(server, methodCalled,
UA_STRING("OutputArguments"));
if(!outputArguments) {
// A MethodNode must have an OutputArguments variable (which may be empty)
rs->statusCode = UA_STATUSCODE_BADINTERNALERROR;
continue;
}
// Call method if available
if(methodCalled->attachedMethod) {
rs->outputArguments = UA_Array_new(&UA_TYPES[UA_TYPES_VARIANT],
outputArguments->value.variant.arrayLength);
rs->outputArgumentsSize = outputArguments->value.variant.arrayLength;
rs->statusCode = methodCalled->attachedMethod(withObject->nodeId, rq->inputArguments,
rs->outputArguments);
}
else
rs->statusCode = UA_STATUSCODE_BADNOTWRITABLE; // There is no NOTEXECUTABLE?
/* FIXME: Verify Output Argument count, types and sizes */
if(outputArguments) {
UA_NodeStore_release((const UA_Node*)outputArguments);
}
UA_NodeStore_release((const UA_Node *)withObject);
UA_NodeStore_release((const UA_Node *)methodCalled);
}
}
static void
callMethod(UA_Server *server, UA_Session *session, UA_CallMethodRequest *request,
UA_CallMethodResult *result) {
const UA_MethodNode *methodCalled = (const UA_MethodNode*)UA_NodeStore_get(server->nodestore, &request->methodId);
if(!methodCalled) {
result->statusCode = UA_STATUSCODE_BADMETHODINVALID;
return;
}
const UA_ObjectNode *withObject = (const UA_ObjectNode*)UA_NodeStore_get(server->nodestore, &request->objectId);
if(!withObject) {
result->statusCode = UA_STATUSCODE_BADNODEIDINVALID;
goto releaseMethodReturn;
}
if(methodCalled->nodeClass != UA_NODECLASS_METHOD) {
result->statusCode = UA_STATUSCODE_BADNODECLASSINVALID;
goto releaseBothReturn;
}
if(withObject->nodeClass != UA_NODECLASS_OBJECT && withObject->nodeClass != UA_NODECLASS_OBJECTTYPE) {
result->statusCode = UA_STATUSCODE_BADNODECLASSINVALID;
goto releaseBothReturn;
}
/* Verify method/object relations */
// Object must have a hasComponent reference (or any inherited referenceType from sayd reference)
// to be valid for a methodCall...
result->statusCode = UA_STATUSCODE_BADMETHODINVALID;
for(UA_Int32 i = 0; i < withObject->referencesSize; i++) {
if(withObject->references[i].referenceTypeId.identifier.numeric == UA_NS0ID_HASCOMPONENT) {
// FIXME: Not checking any subtypes of HasComponent at the moment
if(UA_NodeId_equal(&withObject->references[i].targetId.nodeId, &methodCalled->nodeId)) {
result->statusCode = UA_STATUSCODE_GOOD;
break;
}
}
}
if(result->statusCode != UA_STATUSCODE_GOOD)
goto releaseBothReturn;
/* Verify method executable */
if(methodCalled->executable == UA_FALSE || methodCalled->userExecutable == UA_FALSE) {
result->statusCode = UA_STATUSCODE_BADNOTWRITABLE; // There is no NOTEXECUTABLE?
goto releaseBothReturn;
}
/* Verify Input Argument count, types and sizes */
const UA_VariableNode *inputArguments = getArgumentsVariableNode(server, methodCalled,
UA_STRING("InputArguments"));
if(inputArguments) {
// Expects arguments
result->statusCode = argConformsToDefinition(request, inputArguments);
UA_NodeStore_release((const UA_Node*)inputArguments);
if(result->statusCode != UA_STATUSCODE_GOOD)
goto releaseBothReturn;
} else if(request->inputArgumentsSize > 0) {
// Expects no arguments, but got some
result->statusCode = UA_STATUSCODE_BADINVALIDARGUMENT;
goto releaseBothReturn;
}
const UA_VariableNode *outputArguments = getArgumentsVariableNode(server, methodCalled,
UA_STRING("OutputArguments"));
if(!outputArguments) {
// A MethodNode must have an OutputArguments variable (which may be empty)
result->statusCode = UA_STATUSCODE_BADINTERNALERROR;
goto releaseBothReturn;
}
// Call method if available
if(methodCalled->attachedMethod) {
result->outputArguments = UA_Array_new(&UA_TYPES[UA_TYPES_VARIANT],
outputArguments->value.variant.value.arrayLength);
result->outputArgumentsSize = outputArguments->value.variant.value.arrayLength;
result->statusCode = methodCalled->attachedMethod(withObject->nodeId, request->inputArguments,
result->outputArguments, methodCalled->methodHandle);
}
else
result->statusCode = UA_STATUSCODE_BADNOTWRITABLE; // There is no NOTEXECUTABLE?
/* FIXME: Verify Output Argument count, types and sizes */
if(outputArguments)
UA_NodeStore_release((const UA_Node*)outputArguments);
releaseBothReturn:
UA_NodeStore_release((const UA_Node*)withObject);
releaseMethodReturn:
UA_NodeStore_release((const UA_Node*)methodCalled);
}
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;
}
static UA_StatusCode Service_Write_writeNode(UA_Server *server, UA_WriteValue *writeValue) {
UA_StatusCode retval = UA_STATUSCODE_GOOD;
const UA_Node *node;
retval = UA_NodeStore_get(server->nodestore, &writeValue->nodeId, &node);
if(retval)
return retval;
switch(writeValue->attributeId) {
case UA_ATTRIBUTEID_NODEID:
/* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){ } */
retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
break;
case UA_ATTRIBUTEID_NODECLASS:
/* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){ } */
retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
break;
case UA_ATTRIBUTEID_BROWSENAME:
/* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
break;
case UA_ATTRIBUTEID_DISPLAYNAME:
/* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
break;
case UA_ATTRIBUTEID_DESCRIPTION:
/* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
break;
case UA_ATTRIBUTEID_WRITEMASK:
/* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
break;
case UA_ATTRIBUTEID_USERWRITEMASK:
/* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
break;
case UA_ATTRIBUTEID_ISABSTRACT:
/* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
break;
case UA_ATTRIBUTEID_SYMMETRIC:
/* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
break;
case UA_ATTRIBUTEID_INVERSENAME:
/* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
break;
case UA_ATTRIBUTEID_CONTAINSNOLOOPS:
/* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
break;
case UA_ATTRIBUTEID_EVENTNOTIFIER:
/* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
break;
case UA_ATTRIBUTEID_VALUE:
if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT) {
retval |= UA_Variant_copy(&writeValue->value.value, &((UA_VariableNode *)node)->value); // todo: zero-copy
}
break;
case UA_ATTRIBUTEID_DATATYPE:
/* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
break;
case UA_ATTRIBUTEID_VALUERANK:
/* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
break;
case UA_ATTRIBUTEID_ARRAYDIMENSIONS:
/* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
break;
case UA_ATTRIBUTEID_ACCESSLEVEL:
/* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
break;
case UA_ATTRIBUTEID_USERACCESSLEVEL:
/* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
break;
case UA_ATTRIBUTEID_MINIMUMSAMPLINGINTERVAL:
/* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
break;
case UA_ATTRIBUTEID_HISTORIZING:
/* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
break;
case UA_ATTRIBUTEID_EXECUTABLE:
/* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
break;
case UA_ATTRIBUTEID_USEREXECUTABLE:
/* if(writeValue->value.encodingMask == UA_DATAVALUE_ENCODINGMASK_VARIANT){} */
retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
break;
default:
retval = UA_STATUSCODE_BADATTRIBUTEIDINVALID;
break;
}
UA_NodeStore_release(node);
return retval;
}