open62541/src/server/ua_server_addressspace.c

#include "ua_server.h"
#include "ua_server_internal.h"

/* static const UA_TypeVTable * UA_Node_getTypeVT(const UA_Node *node) { */
/*     switch(node->nodeClass) { */
/*     case UA_NODECLASS_OBJECT: */
/*         return &UA_TYPES[UA_OBJECTNODE]; */
/*     case UA_NODECLASS_VARIABLE: */
/*         return &UA_TYPES[UA_VARIABLENODE]; */
/*     case UA_NODECLASS_METHOD: */
/*         return &UA_TYPES[UA_METHODNODE]; */
/*     case UA_NODECLASS_OBJECTTYPE: */
/*         return &UA_TYPES[UA_OBJECTTYPENODE]; */
/*     case UA_NODECLASS_VARIABLETYPE: */
/*         return &UA_TYPES[UA_VARIABLETYPENODE]; */
/*     case UA_NODECLASS_REFERENCETYPE: */
/*         return &UA_TYPES[UA_REFERENCETYPENODE]; */
/*     case UA_NODECLASS_DATATYPE: */
/*         return &UA_TYPES[UA_DATATYPENODE]; */
/*     case UA_NODECLASS_VIEW: */
/*         return &UA_TYPES[UA_VIEWNODE]; */
/*     default: break; */
/*     } */

/*     return &UA_TYPES[UA_INVALIDTYPE]; */
/* } */

UA_StatusCode UA_Server_addScalarVariableNode(UA_Server *server, UA_QualifiedName *browseName,
                                              void *value, const UA_NodeId typeId,
                                              const UA_ExpandedNodeId *parentNodeId,
                                              const UA_NodeId *referenceTypeId ) {
    if(typeId.namespaceIndex != 0)
        return UA_STATUSCODE_BADINTERNALERROR;
    UA_VariableNode *tmpNode = UA_VariableNode_new();
    UA_QualifiedName_copy(browseName, &tmpNode->browseName);
    UA_String_copy(&browseName->name, &tmpNode->displayName.text);
    /* UA_LocalizedText_copycstring("integer value", &tmpNode->description); */
    tmpNode->nodeClass = UA_NODECLASS_VARIABLE;
    tmpNode->valueRank = -1;
    UA_NodeId_copy(&typeId, &tmpNode->dataType);
    UA_NodeId_copy(&typeId, &tmpNode->value.typeId);
    tmpNode->value.storage.data.dataPtr = value;
    tmpNode->value.storageType = UA_VARIANT_DATA;
    tmpNode->value.storage.data.arrayLength = 1;
    size_t i;
    for(i = 0;i<UA_TYPES_COUNT;i++) {
        if(UA_TYPES_IDS[i] == typeId.identifier.numeric)
            break;
    }
    if(i >= UA_TYPES_COUNT) {
        UA_VariableNode_delete(tmpNode);
        return UA_STATUSCODE_BADINTERNALERROR;
    }
    tmpNode->value.type = &UA_TYPES[i];
    UA_Server_addNodeWithSession(server, &adminSession, (const UA_Node**)&tmpNode,
                                 parentNodeId, referenceTypeId);
    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) {
    // use the servers nodestore
    const UA_Node *node = UA_NodeStore_get(server->nodestore, &item->sourceNodeId);
    // todo differentiate between error codes
    if(!node)
        return UA_STATUSCODE_BADINTERNALERROR;

    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:
        UA_assert(UA_FALSE);
    }

    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]);
    UA_StatusCode 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, ++count, &UA_TYPES[UA_TYPES_REFERENCENODE]);
        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;
    const UA_Node *constNode = newNode;
    retval = UA_NodeStore_replace(server->nodestore, node, (const UA_Node **)&constNode, UA_FALSE);
    UA_NodeStore_release(node);
    if(retval != UA_STATUSCODE_BADINTERNALERROR)
        return retval;
    
    // error presumably because the node was replaced and an old version was updated
    // just try again
    deleteNode(newNode);
    return addOneWayReferenceWithSession(server, session, item);
}

UA_StatusCode UA_Server_addReference(UA_Server *server, const UA_AddReferencesItem *item) {
    return UA_Server_addReferenceWithSession(server, &adminSession, item);
}

UA_StatusCode UA_Server_addReferenceWithSession(UA_Server *server, UA_Session *session,
                                                const UA_AddReferencesItem *item) {
    // todo: we don't support references to other servers (expandednodeid) for now
    if(item->targetServerUri.length > 0)
        return UA_STATUSCODE_BADNOTIMPLEMENTED;
    
    // Is this for an external nodestore?
    UA_ExternalNodeStore *ensFirst = UA_NULL;
    UA_ExternalNodeStore *ensSecond = UA_NULL;
    for(UA_Int32 j = 0;j<server->externalNamespacesSize && (!ensFirst || !ensSecond);j++) {
        if(item->sourceNodeId.namespaceIndex == server->externalNamespaces[j].index)
            ensFirst = &server->externalNamespaces[j].externalNodeStore;
        if(item->targetNodeId.nodeId.namespaceIndex == server->externalNamespaces[j].index)
            ensSecond = &server->externalNamespaces[j].externalNodeStore;
    }

    UA_StatusCode retval = UA_STATUSCODE_GOOD;
    if(ensFirst) {
        // todo: use external nodestore
    } else
        retval = addOneWayReferenceWithSession(server, session, item);

    if(retval) return retval;

    UA_AddReferencesItem secondItem;
    secondItem = *item;
    secondItem.targetNodeId.nodeId = item->sourceNodeId;
    secondItem.sourceNodeId = item->targetNodeId.nodeId;
    secondItem.isForward = !item->isForward;
    if(ensSecond) {
        // todo: use external nodestore
    } else
        retval = addOneWayReferenceWithSession (server, session, &secondItem);
    // todo: remove reference if the second direction failed

    return retval;
} 

UA_AddNodesResult UA_Server_addNode(UA_Server *server, const UA_Node **node,
                                    const UA_ExpandedNodeId *parentNodeId, const UA_NodeId *referenceTypeId) {
    return UA_Server_addNodeWithSession(server, &adminSession, node, parentNodeId, referenceTypeId);
}

UA_AddNodesResult UA_Server_addNodeWithSession(UA_Server *server, UA_Session *session, const UA_Node **node,
                                               const UA_ExpandedNodeId *parentNodeId,
                                               const UA_NodeId *referenceTypeId) {
    UA_AddNodesResult result;
    UA_AddNodesResult_init(&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
    if(UA_NodeId_isNull(&(*node)->nodeId)) {
        if(UA_NodeStore_insert(server->nodestore, node, UA_TRUE) != UA_STATUSCODE_GOOD) {
            result.statusCode = UA_STATUSCODE_BADOUTOFMEMORY;
            goto ret2;
        }
        result.addedNodeId = (*node)->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, UA_TRUE) != 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 = (*node)->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(*node);
    *node = UA_NULL;
    
 ret2:
    UA_NodeStore_release((const UA_Node*)referenceType);
 ret:
    UA_NodeStore_release(parent);

    return result;
}