Match proven simulator logical-node discovery semantics

masarray · Aug 11, 2026 · Aug 11, 2026 · Aug 11, 2026 · Aug 11, 2026 · Aug 11, 2026
commit 17c689f8baf99469fea654af0828b0e4fff6ee70
diff --git a/embedded/mms_dispatcher_hard_profile_smoke.cpp b/embedded/mms_dispatcher_hard_profile_smoke.cpp
@@ -7,6 +7,7 @@
 #include <cstddef>
 #include <cstdint>
 #include <span>
+#include <string_view>
 
 namespace {
 
@@ -28,6 +29,12 @@ constexpr std::array<std::uint8_t, 21U> kDomainContinueRequest{
     0xA1U, 0x02U, 0x80U, 0x00U,
     0x82U, 0x03U, 0x4CU, 0x44U, 0x30U};
 
+constexpr std::array<std::uint8_t, 19U> kNamedVariableDirectoryRequest{
+    0xA0U, 0x11U, 0x02U, 0x01U, 0x16U,
+    0xA1U, 0x0CU,
+    0xA0U, 0x03U, 0x80U, 0x01U, 0x00U,
+    0xA1U, 0x05U, 0x81U, 0x03U, 0x4CU, 0x44U, 0x48U};
+
 constexpr std::array<std::uint8_t, 17U> kDomainFirstResponse{
     0xA1U, 0x0FU, 0x02U, 0x01U, 0x07U,
     0xA1U, 0x0AU, 0xA0U, 0x05U,
@@ -92,6 +99,21 @@ template <std::size_t N>
         std::equal(actual.begin(), actual.end(), expected.begin());
 }
 
+[[nodiscard]] bool identifier_equals(
+    const std::span<const std::uint8_t> identifier,
+    const std::string_view expected) noexcept {
+    if (identifier.size() != expected.size()) {
+        return false;
+    }
+    for (std::size_t index = 0U; index < identifier.size(); ++index) {
+        if (identifier[index] != static_cast<std::uint8_t>(
+                static_cast<unsigned char>(expected[index]))) {
+            return false;
+        }
+    }
+    return true;
+}
+
 [[nodiscard]] wire::EncodeResult read_boolean(
     const void* context,
     const std::span<std::uint8_t> destination) noexcept {
@@ -307,12 +329,72 @@ int main() {
         return 16;
     }
 
+    // ARIEC61850 IED simulator parity: when a root Logical Node object exists,
+    // GetNameList(NamedVariable) advertises the root and leaves its flattened
+    // FC/DO/DA aliases for Read/Write lookup and TypeSpecification traversal.
+    // A flat-only generic MMS item remains discoverable for compatibility.
+    bool hierarchy_value = true;
+    const std::array<mms::MmsStaticObjectEntry, 5U> hierarchy_objects{
+        mms::MmsStaticObjectEntry{
+            "LDH", "LLN0", kBooleanType,
+            read_boolean, &hierarchy_value, false},
+        mms::MmsStaticObjectEntry{
+            "LDH", "LLN0$ST$Mod$stVal", kBooleanType,
+            read_boolean, &hierarchy_value, false},
+        mms::MmsStaticObjectEntry{
+            "LDH", "GGIO1", kBooleanType,
+            read_boolean, &hierarchy_value, false},
+        mms::MmsStaticObjectEntry{
+            "LDH", "GGIO1$ST$Ind1$stVal", kBooleanType,
+            read_boolean, &hierarchy_value, false},
+        mms::MmsStaticObjectEntry{
+            "LDH", "Orphan$ST$stVal", kBooleanType,
+            read_boolean, &hierarchy_value, false}};
+    const mms::MmsStaticObjectTable hierarchy_table{hierarchy_objects};
+    const mms::MmsStaticDispatchPolicy hierarchy_policy{
+        8U,
+        1U,
+        10U,
+        3U,
+        10U};
+    const mms::MmsStaticApplicationDispatcher hierarchy_dispatcher{
+        hierarchy_table,
+        hierarchy_policy};
+    if (!hierarchy_table.valid()) {
+        return 17;
+    }
+
+    dispatched = hierarchy_dispatcher.dispatch(
+        kNamedVariableDirectoryRequest,
+        response,
+        workspace);
+    mms::MmsGetNameListResponseView hierarchy_directory;
+    if (!dispatched.success() ||
+        !mms::MmsServiceSpanCodec::try_decode_get_name_list_response(
+            std::span<const std::uint8_t>{response}.first(dispatched.bytes_written),
+            hierarchy_directory) ||
+        hierarchy_directory.invoke_id != 22U ||
+        hierarchy_directory.identifier_count != 3U ||
+        hierarchy_directory.more_follows) {
+        return 18;
+    }
+
+    std::span<const std::uint8_t> identifier;
+    if (!hierarchy_directory.try_identifier(0U, identifier) ||
+        !identifier_equals(identifier, "LLN0") ||
+        !hierarchy_directory.try_identifier(1U, identifier) ||
+        !identifier_equals(identifier, "GGIO1") ||
+        !hierarchy_directory.try_identifier(2U, identifier) ||
+        !identifier_equals(identifier, "Orphan$ST$stVal")) {
+        return 19;
+    }
+
     for (std::uint32_t iteration = 0U; iteration < 20'000U; ++iteration) {
         relay_state = true;
         const auto read = dispatcher.dispatch(kReadRequest, response, workspace);
         const auto write = dispatcher.dispatch(kWriteRequest, response, workspace);
         if (!read.success() || !write.success() || relay_state) {
-            return 17;
+            return 20;
         }
     }
 

diff --git a/src/mms/static_dispatcher.cpp b/src/mms/static_dispatcher.cpp
@@ -97,6 +97,31 @@ namespace {
     return true;
 }
 
+// IEC 61850 engineering clients discover each Logical Node as one MMS
+// NamedVariable and then walk its hierarchical TypeSpecification. Static
+// profiles also keep flattened leaf aliases in the table so Read/Write can
+// resolve exact FC/DO/DA paths. Do not advertise those aliases as additional
+// top-level NamedVariables when their root Logical Node object is present.
+//
+// The fallback is intentional: a generic MMS profile that only supplies flat
+// names (and no corresponding root entry) keeps the legacy directory behavior.
+[[nodiscard]] bool is_flattened_child_with_root(
+    const MmsStaticObjectTable& objects,
+    const std::string_view domain,
+    const std::string_view item) noexcept {
+    const auto separator = item.find('$');
+    if (separator == std::string_view::npos || separator == 0U) {
+        return false;
+    }
+    const auto root = item.substr(0U, separator);
+    for (const auto& candidate : objects.objects()) {
+        if (candidate.domain == domain && candidate.item == root) {
+            return true;
+        }
+    }
+    return false;
+}
+
 [[nodiscard]] std::size_t collect_names(
     const MmsStaticObjectTable& objects,
     const MmsStaticDataSetTable& data_sets,
@@ -121,11 +146,12 @@ namespace {
     if (request.object_class == MmsNameListObjectClass::named_variable &&
         request.scope == MmsNameScopeKind::domain_specific) {
         for (const auto& object : objects.objects()) {
-            if (span_equals(request.domain_id, object.domain)) {
-                if (count >= names.size()) {
-                    return names.size() + 1U;
-                }
-                names[count++] = object.item;
+            if (!span_equals(request.domain_id, object.domain) ||
+                is_flattened_child_with_root(objects, object.domain, object.item)) {
+                continue;
+            }
+            if (!append_unique(names, count, object.item)) {
+                return names.size() + 1U;
             }
         }
         return count;