UA_StatusCode
UA_Server_addObjectNode(UA_Server *server, const UA_QualifiedName browseName,
UA_NodeId nodeId, const UA_NodeId parentNodeId, const UA_NodeId referenceTypeId, const UA_NodeId typeDefinition)
{
UA_ObjectNode *node = UA_ObjectNode_new();
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);
if(res.statusCode != UA_STATUSCODE_GOOD) {
UA_ObjectNode_delete(node);
}
UA_AddNodesResult_deleteMembers(&res);
if(!(UA_NodeId_isNull(&typeDefinition))){
UA_ExpandedNodeId typeDefid; // we need an expandednodeid
UA_ExpandedNodeId_init(&typeDefid);
UA_NodeId_copy(&typeDefinition, &typeDefid.nodeId);
ADDREFERENCE(res.addedNodeId, UA_NODEID_NUMERIC(0, UA_NS0ID_HASTYPEDEFINITION), typeDefid);
}
return res.statusCode;
}
static UA_Node *
objectNodeFromAttributes(const UA_AddNodesItem *item, const UA_ObjectAttributes *attr) {
UA_ObjectNode *onode = UA_ObjectNode_new();
if(!onode)
return NULL;
UA_StatusCode retval = copyStandardAttributes((UA_Node*)onode, item, (const UA_NodeAttributes*)attr);
onode->eventNotifier = attr->eventNotifier;
if(retval != UA_STATUSCODE_GOOD) {
UA_Node_deleteAnyNodeClass((UA_Node*)onode);
return NULL;
}
return (UA_Node*)onode;
}
static UA_StatusCode parseObjectNode(UA_ExtensionObject *attributes, UA_Node **new_node) {
if(attributes->typeId.identifier.numeric !=
UA_TYPES[UA_TYPES_OBJECTATTRIBUTES].typeId.identifier.numeric + UA_ENCODINGOFFSET_BINARY)
return UA_STATUSCODE_BADNODEATTRIBUTESINVALID;
UA_ObjectAttributes attr;
size_t pos = 0;
// todo return more informative error codes from decodeBinary
if (UA_ObjectAttributes_decodeBinary(&attributes->body, &pos, &attr) != UA_STATUSCODE_GOOD)
return UA_STATUSCODE_BADNODEATTRIBUTESINVALID;
UA_ObjectNode *vnode = UA_ObjectNode_new();
if(!vnode) {
UA_ObjectAttributes_deleteMembers(&attr);
return UA_STATUSCODE_BADOUTOFMEMORY;
}
// now copy all the attributes. This potentially removes them from the decoded attributes.
COPY_STANDARDATTRIBUTES;
if(attr.specifiedAttributes & UA_NODEATTRIBUTESMASK_EVENTNOTIFIER)
vnode->eventNotifier = attr.eventNotifier;
UA_ObjectAttributes_deleteMembers(&attr);
*new_node = (UA_Node*) vnode;
return UA_STATUSCODE_GOOD;
}
/* 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
}