fix(sort): skip non-hierarchical refs in topological sort

The topological sort in Nodeset_sort() determines the order in which
nodes are added to the server. Previously, nodeRefsReady() treated ALL
inverse references (except HasTypeDefinition) as ordering dependencies.
This caused infinite-loop deadlocks when two nodes in the same nodeset
referenced each other via a non-hierarchical reference type.

Only inverse hierarchical references (subtypes of HierarchicalReferences
i=33) create true parent-child ordering dependencies. Non-hierarchical
references (e.g. HasCondition, HasSubStateMachine) are cross-references
that do not require ordering.

Instead of hardcoding known hierarchical reference type IDs, this fix
introduces an isHierarchicalRef callback in NL_FileContext. The open62541
backend implements this callback by using UA_Server_browseRecursive to
discover all subtypes of HierarchicalReferences from the server's
reference type hierarchy at init time. This makes the check robust
against future OPC UA spec additions and custom hierarchical reference
types from any namespace.

Author: andreasebner

backends/open62541/src/import.c

@@ -90,13 +90,36 @@ AddNodeContext_init(AddNodeContext *ctx,
     UA_Array_append((void**)&ctx->parentRefTypes,
                     &ctx->parentRefTypesSize, &hasChildExp,
                     &UA_TYPES[UA_TYPES_EXPANDEDNODEID]);
+
+    // Get all hierarchical ReferenceTypes (subtypes of HierarchicalReferences).
+    // Used by the topological sort to distinguish ordering dependencies
+    // from non-hierarchical cross-references.
+    UA_BrowseDescription bd2;
+    UA_BrowseDescription_init(&bd2);
+    bd2.browseDirection = UA_BROWSEDIRECTION_FORWARD;
+    bd2.referenceTypeId = UA_NS0ID(HASSUBTYPE);
+    bd2.nodeId = UA_NS0ID(HIERARCHICALREFERENCES);
+
+    UA_Server_browseRecursive(server, &bd2,
+                              &ctx->hierarchicalRefTypesSize,
+                              &ctx->hierarchicalRefTypes);
+
+    // Include HierarchicalReferences itself
+    UA_ExpandedNodeId hierRefExp;
+    UA_ExpandedNodeId_init(&hierRefExp);
+    hierRefExp.nodeId = UA_NS0ID(HIERARCHICALREFERENCES);
+    UA_Array_append((void**)&ctx->hierarchicalRefTypes,
+                    &ctx->hierarchicalRefTypesSize, &hierRefExp,
+                    &UA_TYPES[UA_TYPES_EXPANDEDNODEID]);
 }
 
 static void
 AddNodeContext_clear(AddNodeContext *ctx) {
     UA_NamespaceMapping_clear(&ctx->nsMapping);
     UA_Array_delete(ctx->parentRefTypes, ctx->parentRefTypesSize,
                     &UA_TYPES[UA_TYPES_EXPANDEDNODEID]);
+    UA_Array_delete(ctx->hierarchicalRefTypes, ctx->hierarchicalRefTypesSize,
+                    &UA_TYPES[UA_TYPES_EXPANDEDNODEID]);
 }
 
 static inline UA_Boolean isValTrue(const char *s) {
@@ -497,6 +520,20 @@ addNodes(NodesetLoader *loader, AddNodeContext *anc) {
     return true;
 }
 
+/* Callback for the topological sort: check whether a reference type is
+ * hierarchical (subtype of HierarchicalReferences i=33). Only hierarchical
+ * inverse references create parent-child ordering dependencies. */
+static bool
+isHierarchicalRef(void *userContext, const UA_NodeId *refType) {
+    AddNodeContext *ctx = (AddNodeContext *)userContext;
+    for(size_t i = 0; i < ctx->hierarchicalRefTypesSize; i++) {
+        if(UA_NodeId_equal(refType,
+                           &ctx->hierarchicalRefTypes[i].nodeId))
+            return true;
+    }
+    return false;
+}
+
 bool
 NodesetLoader_loadFile(struct UA_Server *server, const char *path,
                        NodesetLoader_ExtensionInterface *extensionHandling) {
@@ -524,6 +561,7 @@ NodesetLoader_loadFile(struct UA_Server *server, const char *path,
     handler.file = path;
     handler.extensionHandling = extensionHandling;
     handler.nsMapping = &ctx.nsMapping; // Provide the pre-filled mapping
+    handler.isHierarchicalRef = isHierarchicalRef;
 
     logger->log(logger->context, NODESETLOADER_LOGLEVEL_DEBUG,
                 "Start import nodeset: %s", path);

backends/open62541/src/internal.h

@@ -27,6 +27,12 @@ typedef struct {
     // Inherited from HasChild.
     size_t parentRefTypesSize;
     UA_ExpandedNodeId *parentRefTypes;
+
+    // All hierarchical ReferenceTypes (subtypes of HierarchicalReferences).
+    // Used by the topological sort to distinguish ordering dependencies
+    // from non-hierarchical cross-references.
+    size_t hierarchicalRefTypesSize;
+    UA_ExpandedNodeId *hierarchicalRefTypes;
 } AddNodeContext;
 
 UA_NodeId

include/NodesetLoader/NodesetLoader.h

@@ -145,12 +145,20 @@ typedef void (*NL_addNamespaceCallback)(void *userContext,
                                         UA_String *localNamespaceUris,
                                         UA_NamespaceMapping *nsMapping);
 
+/* Callback to check if a reference type is hierarchical (subtype of
+ * HierarchicalReferences i=33). Used by the topological sort to determine
+ * ordering dependencies. If NULL, all inverse references are conservatively
+ * treated as ordering dependencies. */
+typedef bool (*NL_isHierarchicalRefCallback)(void *userContext,
+                                             const UA_NodeId *refType);
+
 typedef struct NL_FileContext {
     void *userContext;
     const char *file;
     NL_addNamespaceCallback addNamespace;
     NodesetLoader_ExtensionInterface *extensionHandling;
     UA_NamespaceMapping *nsMapping;
+    NL_isHierarchicalRefCallback isHierarchicalRef;
 } NL_FileContext;
 
 struct NodesetLoader;

src/Nodeset.c

@@ -136,18 +136,50 @@ Nodeset_findByNodeId(Nodeset *nodeset, const UA_NodeId *key) {
 
 static UA_NodeId hasTypeDef = {0, UA_NODEIDTYPE_NUMERIC, {40}};
 
+/* Check whether a reference creates an ordering dependency for the
+ * topological sort. Only two kinds of references require the target
+ * to exist before the source node can be added:
+ *
+ * 1. Forward HasTypeDefinition -- the type node must exist first.
+ * 2. Inverse hierarchical references -- the parent node must exist first.
+ *    For example, an Object with an inverse HasComponent to its parent
+ *    cannot be added before the parent exists.
+ *
+ * Non-hierarchical references (like HasCondition or HasSubStateMachine)
+ * do NOT create ordering dependencies. If they are treated as such,
+ * they cause deadlocks when two nodes in the same nodeset reference
+ * each other via a non-hierarchical reference type.
+ *
+ * Whether a reference type is hierarchical is determined via the
+ * isHierarchicalRef callback in the NL_FileContext. The open62541
+ * backend sets this callback using UA_Server_browseRecursive to
+ * discover all subtypes of HierarchicalReferences (i=33) from the
+ * server's reference type hierarchy. If no callback is set, all
+ * inverse references are conservatively treated as dependencies. */
 static bool
-nodeRefsReady(NL_Node *node) {
+nodeRefsReady(Nodeset *nodeset, NL_Node *node) {
+    NL_isHierarchicalRefCallback isHierCb = NULL;
+    void *userCtx = NULL;
+    if(nodeset->fc) {
+        isHierCb = nodeset->fc->isHierarchicalRef;
+        userCtx = nodeset->fc->userContext;
+    }
     for(NL_Reference *ref = node->refs; ref != NULL; ref = ref->next) {
         if(!ref->targetPtr)
             continue;
         if(ref->targetPtr->isDone)
             continue;
         if(UA_NodeId_equal(&hasTypeDef, &ref->refType)) {
+            /* Forward HasTypeDefinition: the type must exist first */
             if(ref->isForward)
                 return false;
-        } else {
-            if(!ref->isForward)
+        } else if(!ref->isForward) {
+            /* Inverse reference: only hierarchical refs create a
+             * parent-child ordering dependency. */
+            bool isHier = true; /* Conservative default */
+            if(isHierCb)
+                isHier = isHierCb(userCtx, &ref->refType);
+            if(isHier)
                 return false;
         }
     }
@@ -166,7 +198,7 @@ Nodeset_sortNodeClass(Nodeset *nodeset, NL_NodeClass nodeClass) {
     oldSize = nc->size;
     for(size_t i = 0; i < nc->size; i++) {
         NL_Node *node = nc->nodes[i];
-        if(!nodeRefsReady(node))
+        if(!nodeRefsReady(nodeset, node))
             continue;
         NodeContainer_add(&nodeset->sortedNodes, node);
         NodeContainer_remove(nc, i);