void UA_Node_deleteAnyNodeClass(UA_Node *node) {
switch(node->nodeClass) {
case UA_NODECLASS_OBJECT:
UA_ObjectNode_delete((UA_ObjectNode*)node);
break;
case UA_NODECLASS_VARIABLE:
UA_VariableNode_delete((UA_VariableNode*)node);
break;
case UA_NODECLASS_METHOD:
UA_MethodNode_delete((UA_MethodNode*)node);
break;
case UA_NODECLASS_OBJECTTYPE:
UA_ObjectTypeNode_delete((UA_ObjectTypeNode*)node);
break;
case UA_NODECLASS_VARIABLETYPE:
UA_VariableTypeNode_delete((UA_VariableTypeNode*)node);
break;
case UA_NODECLASS_REFERENCETYPE:
UA_ReferenceTypeNode_delete((UA_ReferenceTypeNode*)node);
break;
case UA_NODECLASS_DATATYPE:
UA_DataTypeNode_delete((UA_DataTypeNode*)node);
break;
case UA_NODECLASS_VIEW:
UA_ViewNode_delete((UA_ViewNode*)node);
break;
default:
break;
}
}
static void addNodeFromAttributes(UA_Server *server, UA_Session *session, UA_AddNodesItem *item,
UA_AddNodesResult *result) {
// adding nodes to ns0 is not allowed over the wire
if(item->requestedNewNodeId.nodeId.namespaceIndex == 0) {
result->statusCode = UA_STATUSCODE_BADNODEIDREJECTED;
return;
}
// parse the node
UA_Node *node = UA_NULL;
switch (item->nodeClass) {
case UA_NODECLASS_OBJECT:
result->statusCode = parseObjectNode(&item->nodeAttributes, &node);
break;
case UA_NODECLASS_OBJECTTYPE:
result->statusCode = parseObjectTypeNode(&item->nodeAttributes, &node);
break;
case UA_NODECLASS_REFERENCETYPE:
result->statusCode = parseReferenceTypeNode(&item->nodeAttributes, &node);
break;
case UA_NODECLASS_VARIABLE:
result->statusCode = parseVariableNode(&item->nodeAttributes, &node);
break;
default:
result->statusCode = UA_STATUSCODE_BADNOTIMPLEMENTED;
}
if(result->statusCode != UA_STATUSCODE_GOOD)
return;
// The BrowseName was not included with the NodeAttribute ExtensionObject
UA_QualifiedName_init(&(node->browseName));
UA_QualifiedName_copy(&(item->browseName), &(node->browseName));
UA_NodeId_copy(&item->requestedNewNodeId.nodeId, &node->nodeId);
// add the node
*result = UA_Server_addNodeWithSession(server, session, node, item->parentNodeId,
item->referenceTypeId);
if(result->statusCode != UA_STATUSCODE_GOOD) {
switch (node->nodeClass) {
case UA_NODECLASS_OBJECT:
UA_ObjectNode_delete((UA_ObjectNode*)node);
break;
case UA_NODECLASS_OBJECTTYPE:
UA_ObjectTypeNode_delete((UA_ObjectTypeNode*)node);
break;
case UA_NODECLASS_REFERENCETYPE:
UA_ReferenceTypeNode_delete((UA_ReferenceTypeNode*)node);
break;
case UA_NODECLASS_VARIABLE:
UA_VariableNode_delete((UA_VariableNode*)node);
break;
default:
UA_assert(UA_FALSE);
}
}
}
UA_StatusCode UA_EXPORT
UA_Server_addDataSourceVariableNode(UA_Server *server, const UA_NodeId requestedNewNodeId,
const UA_NodeId parentNodeId, const UA_NodeId referenceTypeId,
const UA_QualifiedName browseName, const UA_NodeId typeDefinition,
const UA_VariableAttributes attr, const UA_DataSource dataSource,
UA_NodeId *outNewNodeId) {
UA_AddNodesResult result;
UA_AddNodesResult_init(&result);
UA_AddNodesItem item;
UA_AddNodesItem_init(&item);
result.statusCode = UA_QualifiedName_copy(&browseName, &item.browseName);
item.nodeClass = UA_NODECLASS_VARIABLE;
result.statusCode |= UA_NodeId_copy(&parentNodeId, &item.parentNodeId.nodeId);
result.statusCode |= UA_NodeId_copy(&referenceTypeId, &item.referenceTypeId);
result.statusCode |= UA_NodeId_copy(&requestedNewNodeId, &item.requestedNewNodeId.nodeId);
result.statusCode |= UA_NodeId_copy(&typeDefinition, &item.typeDefinition.nodeId);
UA_VariableAttributes attrCopy;
result.statusCode |= UA_VariableAttributes_copy(&attr, &attrCopy);
if(result.statusCode != UA_STATUSCODE_GOOD) {
UA_AddNodesItem_deleteMembers(&item);
UA_VariableAttributes_deleteMembers(&attrCopy);
return result.statusCode;
}
UA_VariableNode *node = UA_VariableNode_new();
if(!node) {
UA_AddNodesItem_deleteMembers(&item);
UA_VariableAttributes_deleteMembers(&attrCopy);
return UA_STATUSCODE_BADOUTOFMEMORY;
}
copyStandardAttributes((UA_Node*)node, &item, (UA_NodeAttributes*)&attrCopy);
node->valueSource = UA_VALUESOURCE_DATASOURCE;
node->value.dataSource = dataSource;
node->accessLevel = attr.accessLevel;
node->userAccessLevel = attr.userAccessLevel;
node->historizing = attr.historizing;
node->minimumSamplingInterval = attr.minimumSamplingInterval;
node->valueRank = attr.valueRank;
UA_Server_addExistingNode(server, &adminSession, (UA_Node*)node, &item.parentNodeId.nodeId,
&item.referenceTypeId, &result);
UA_AddNodesItem_deleteMembers(&item);
UA_VariableAttributes_deleteMembers(&attrCopy);
if(result.statusCode != UA_STATUSCODE_GOOD)
UA_VariableNode_delete(node);
if(outNewNodeId && result.statusCode == UA_STATUSCODE_GOOD)
*outNewNodeId = result.addedNodeId;
else
UA_AddNodesResult_deleteMembers(&result);
return result.statusCode;
}
UA_StatusCode
UA_Server_addDataSourceVariableNode(UA_Server *server, UA_DataSource dataSource,
const UA_QualifiedName browseName, UA_NodeId nodeId,
const UA_NodeId parentNodeId, const UA_NodeId referenceTypeId)
{
UA_VariableNode *node = UA_VariableNode_new();
node->valueSource = UA_VALUESOURCE_DATASOURCE;
node->value.dataSource = dataSource;
UA_NodeId_copy(&nodeId, &node->nodeId);
UA_QualifiedName_copy(&browseName, &node->browseName);
UA_String_copy(&browseName.name, &node->displayName.text);
UA_ExpandedNodeId parentId; // dummy exapndednodeid
UA_ExpandedNodeId_init(&parentId);
UA_NodeId_copy(&parentNodeId, &parentId.nodeId);
UA_AddNodesResult res =
UA_Server_addNodeWithSession(server, &adminSession, (UA_Node*)node, parentId, referenceTypeId);
ADDREFERENCE(res.addedNodeId, UA_NODEID_NUMERIC(0, UA_NS0ID_HASTYPEDEFINITION),
UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE));
if(res.statusCode != UA_STATUSCODE_GOOD)
UA_VariableNode_delete(node);
UA_AddNodesResult_deleteMembers(&res);
return res.statusCode;
}
UA_StatusCode
UA_Server_addVariableNode(UA_Server *server, UA_Variant *value, const UA_QualifiedName browseName,
UA_NodeId nodeId, const UA_NodeId parentNodeId, const UA_NodeId referenceTypeId)
{
UA_VariableNode *node = UA_VariableNode_new();
node->value.variant = *value; // copy content
UA_NodeId_copy(&nodeId, &node->nodeId);
UA_QualifiedName_copy(&browseName, &node->browseName);
UA_String_copy(&browseName.name, &node->displayName.text);
UA_ExpandedNodeId parentId; // we need an expandednodeid
UA_ExpandedNodeId_init(&parentId);
UA_NodeId_copy(&parentNodeId, &parentId.nodeId);
UA_AddNodesResult res =
UA_Server_addNodeWithSession(server, &adminSession, (UA_Node*)node, parentId, referenceTypeId);
ADDREFERENCE(res.addedNodeId, UA_NODEID_NUMERIC(0, UA_NS0ID_HASTYPEDEFINITION),
UA_EXPANDEDNODEID_NUMERIC(0, value->type->typeId.identifier.numeric));
if(res.statusCode != UA_STATUSCODE_GOOD) {
UA_Variant_init(&node->value.variant);
UA_VariableNode_delete(node);
} else
UA_free(value);
UA_AddNodesResult_deleteMembers(&res);
return res.statusCode;
}
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;
}
