From b45cbaefca266e77704f41687fa1d55e36511780 Mon Sep 17 00:00:00 2001
From: Viktor Kopp <vifactor@gmail.com>
Date: Sun, 24 Nov 2024 21:35:22 +0100
Subject: [PATCH 1/2] Control message payload parsing

use ctrlmsg parsing function

add test

Signed-off-by: Viktor Kopp <vifactor@gmail.com>
---
 qdlt/CMakeLists.txt            |   2 +
 qdlt/qdltctrlmsg.cpp           | 151 ++++++++++++++++++++++
 qdlt/qdltctrlmsg.h             |  71 +++++++++++
 qdlt/tests/CMakeLists.txt      |   2 +
 qdlt/tests/test_dltctrlmsg.cpp |  28 ++++
 src/mainwindow.cpp             | 226 +++++++++------------------------
 6 files changed, 313 insertions(+), 167 deletions(-)
 create mode 100644 qdlt/qdltctrlmsg.cpp
 create mode 100644 qdlt/qdltctrlmsg.h
 create mode 100644 qdlt/tests/test_dltctrlmsg.cpp

diff --git a/qdlt/CMakeLists.txt b/qdlt/CMakeLists.txt
index de850cfa..163f9b00 100644
--- a/qdlt/CMakeLists.txt
+++ b/qdlt/CMakeLists.txt
@@ -45,6 +45,8 @@ add_library(qdlt SHARED
     qdltlrucache.hpp
     export_c_rules.h
     export_rules.h
+    qdltctrlmsg.cpp
+    qdltctrlmsg.h
 )
 
 target_compile_definitions(qdlt PRIVATE
diff --git a/qdlt/qdltctrlmsg.cpp b/qdlt/qdltctrlmsg.cpp
new file mode 100644
index 00000000..8d4fb332
--- /dev/null
+++ b/qdlt/qdltctrlmsg.cpp
@@ -0,0 +1,151 @@
+#include "qdltctrlmsg.h"
+
+#include "dlt_common.h"
+
+#include <stdexcept>
+#include <cstring>
+#include <array>
+
+#include <QByteArray>
+
+namespace qdlt::msg::payload {
+
+namespace {
+using IdType = std::array<char, DLT_ID_SIZE>;
+
+QString asQString(IdType&& id) {
+    QString str;
+    for (size_t i = 0; i < id.size() && id[i] != '\0'; i++) {
+        str.append(id[i]);
+    }
+    return str;
+}
+
+template <typename T>
+T dltPayloadRead(const char *&dataPtr, int32_t &length, bool isBigEndian)
+{
+    if (sizeof(T) > static_cast<uint32_t>(length)) {
+        throw std::runtime_error("Invalid data length");
+    }
+
+    T value{};
+    std::memcpy(&value, dataPtr, sizeof(T));
+    dataPtr += sizeof(T);
+    length -= sizeof(T);
+
+    if constexpr (sizeof(T) == sizeof(uint32_t)) {
+        value = DLT_ENDIAN_GET_32((isBigEndian ? DLT_HTYP_MSBF : 0), value);
+    }
+
+    if constexpr (sizeof(T) == sizeof(uint16_t)) {
+        value = DLT_ENDIAN_GET_16((isBigEndian ? DLT_HTYP_MSBF : 0), value);
+    }
+
+    return value;
+}
+
+IdType dltPayloadReadId(const char *&dataPtr, int32_t &length)
+{
+    if (DLT_ID_SIZE > length) {
+        throw std::runtime_error("Invalid ID length");
+    }
+    IdType id{};
+    std::copy(dataPtr, dataPtr + DLT_ID_SIZE, id.begin());
+    dataPtr += DLT_ID_SIZE;
+    length -= DLT_ID_SIZE;
+
+    return id;
+}
+
+std::string dltPayloadReadString(const char *&dataPtr, int32_t &length, bool isBigEndian)
+{
+    uint16_t strLength = dltPayloadRead<uint16_t>(dataPtr, length, isBigEndian);
+    if (strLength > length) {
+        throw std::runtime_error("Invalid string length");
+    }
+    std::string str;
+    str.assign(dataPtr, strLength);
+    dataPtr += strLength;
+    length -= strLength;
+
+    return str;
+}
+}
+
+Type parse(const QByteArray& data, bool isBigEndian)
+{
+    int32_t length = data.length();
+    const char *dataPtr = data.data();
+
+    auto service_id = dltPayloadRead<uint32_t>(dataPtr, length, isBigEndian);
+
+    switch (service_id) {
+        case DLT_SERVICE_ID_GET_LOG_INFO:
+        {
+            GetLogInfo msg;
+            msg.status = dltPayloadRead<uint8_t>(dataPtr, length, isBigEndian);
+            if ((msg.status != 6) && (msg.status != 7)) {
+                return msg;
+            }
+
+            const auto numApps = dltPayloadRead<uint16_t>(dataPtr, length, isBigEndian);
+            for (uint16_t i = 0; i < numApps; i++) {
+                GetLogInfo::App app;
+                app.id = asQString(dltPayloadReadId(dataPtr, length));
+                const uint16_t numCtx = dltPayloadRead<uint16_t>(dataPtr, length, isBigEndian);
+                for (uint16_t j = 0; j < numCtx; j++) {
+                    GetLogInfo::App::Ctx ctx;
+                    ctx.id = asQString(dltPayloadReadId(dataPtr, length));
+                    ctx.logLevel = dltPayloadRead<int8_t>(dataPtr, length, isBigEndian);
+                    ctx.traceStatus = dltPayloadRead<int8_t>(dataPtr, length, isBigEndian);
+                    ctx.description = QString::fromStdString(dltPayloadReadString(dataPtr, length, isBigEndian));
+                    app.ctxs.push_back(std::move(ctx));
+                }
+                if (msg.status == 7) {
+                    app.description = QString::fromStdString(dltPayloadReadString(dataPtr, length, isBigEndian));
+                }
+                msg.apps.push_back(std::move(app));
+            }
+            return msg;
+        }
+        case DLT_SERVICE_ID_GET_SOFTWARE_VERSION:
+        {
+            GetSoftwareVersion msg;
+            msg.version = dltPayloadReadString(dataPtr, length, isBigEndian);
+            return msg;
+        }
+        case DLT_SERVICE_ID_GET_DEFAULT_LOG_LEVEL:
+        {
+            GetDefaultLogLevel msg;
+            msg.logLevel = dltPayloadRead<int8_t>(dataPtr, length, isBigEndian);
+            msg.status = dltPayloadRead<uint8_t>(dataPtr, length, isBigEndian);
+            return msg;
+        }
+        case DLT_SERVICE_ID_SET_LOG_LEVEL:
+        {
+            SetLogLevel msg;
+            msg.status = dltPayloadRead<uint8_t>(dataPtr, length, isBigEndian);
+            return msg;
+        }
+        case DLT_SERVICE_ID_TIMEZONE:
+        {
+            Timezone msg;
+            msg.status = dltPayloadRead<uint8_t>(dataPtr, length, isBigEndian);
+            msg.timezone = dltPayloadRead<int32_t>(dataPtr, length, isBigEndian);
+            msg.isDst = dltPayloadRead<uint8_t>(dataPtr, length, isBigEndian);
+            return msg;
+        }
+        case DLT_SERVICE_ID_UNREGISTER_CONTEXT:
+        {
+            UnregisterContext msg;
+            msg.status = dltPayloadRead<uint8_t>(dataPtr, length, isBigEndian);
+            msg.appid = asQString(dltPayloadReadId(dataPtr, length));
+            msg.ctxid = asQString(dltPayloadReadId(dataPtr, length));
+            return msg;
+        }
+    }
+
+    throw std::runtime_error("Unknown service type");
+}
+
+}
diff --git a/qdlt/qdltctrlmsg.h b/qdlt/qdltctrlmsg.h
new file mode 100644
index 00000000..c9fe634b
--- /dev/null
+++ b/qdlt/qdltctrlmsg.h
@@ -0,0 +1,71 @@
+#ifndef QDLTCTRLMSG_H
+#define QDLTCTRLMSG_H
+
+#include <vector>
+#include <variant>
+
+#include <QByteArray>
+#include <QString>
+
+
+namespace qdlt::msg::payload {
+
+struct GetLogInfo {
+    struct App {
+        struct Ctx {
+            QString id;
+            int8_t logLevel;
+            int8_t traceStatus;
+            QString description;
+        };
+
+        QString id;
+        QString description;
+        std::vector<Ctx> ctxs;
+    };
+
+    uint8_t status;
+    std::vector<App> apps;
+};
+
+struct GetSoftwareVersion {
+    std::string version;
+};
+
+struct GetDefaultLogLevel
+{
+    uint8_t logLevel;
+    uint8_t status;
+};
+
+struct SetLogLevel {
+    uint8_t status;
+};
+
+struct Timezone {
+    uint8_t status;
+    int32_t timezone;
+    uint8_t isDst;
+};
+
+struct UnregisterContext {
+    uint8_t status;
+    QString appid;
+    QString ctxid;
+};
+
+using Type = std::variant<GetLogInfo, GetSoftwareVersion, GetDefaultLogLevel, SetLogLevel, Timezone,
+                          UnregisterContext>;
+
+Type parse(const QByteArray&, bool isBigEndian);
+
+} // namespace qdlt::msg::payload
+
+// helper type for the visitor
+template<class... Ts>
+struct overloaded : Ts... { using Ts::operator()...; };
+// explicit deduction guide (not needed as of C++20)
+template<class... Ts>
+overloaded(Ts...) -> overloaded<Ts...>;
+
+#endif // QDLTCTRLMSG_H
diff --git a/qdlt/tests/CMakeLists.txt b/qdlt/tests/CMakeLists.txt
index 7b65fda1..d0cd6863 100644
--- a/qdlt/tests/CMakeLists.txt
+++ b/qdlt/tests/CMakeLists.txt
@@ -1,5 +1,6 @@
 add_executable(test_dltmessagematcher
     test_dltmessagematcher.cpp
+    test_dltctrlmsg.cpp
 )
 target_link_libraries(
   test_dltmessagematcher
@@ -16,6 +17,7 @@ add_test(
 
 add_executable(test_dltoptmanager
     test_dltoptmanager.cpp
+    test_dltctrlmsg.cpp
 )
 
 target_link_libraries(
diff --git a/qdlt/tests/test_dltctrlmsg.cpp b/qdlt/tests/test_dltctrlmsg.cpp
new file mode 100644
index 00000000..f698f52c
--- /dev/null
+++ b/qdlt/tests/test_dltctrlmsg.cpp
@@ -0,0 +1,28 @@
+#include <gtest/gtest.h>
+
+#include <qdltctrlmsg.h>
+
+#include <QByteArray>
+
+TEST(CtrlPayload, parse) {
+    // this is real payload of a dlt control message which collect from dlt-daemon
+    const auto data = QByteArray::fromHex("030000000701005359530001004d475200ffff2200436f6e74657874206f66206d61696e20646c742073797374656d206d616e616765721200444c542053797374656d204d616e6167657272656d6f");
+
+    auto payload = qdlt::msg::payload::parse(data, false);
+
+    ASSERT_TRUE(std::holds_alternative<qdlt::msg::payload::GetLogInfo>(payload));
+    auto getLogInfo = std::get<qdlt::msg::payload::GetLogInfo>(payload);
+    EXPECT_EQ(getLogInfo.status, 7);
+    ASSERT_EQ(getLogInfo.apps.size(), 1);
+
+    auto app = getLogInfo.apps[0];
+    EXPECT_EQ(app.id, "SYS");
+    EXPECT_EQ(app.description, "DLT System Manager");
+    ASSERT_EQ(app.ctxs.size(), 1);
+
+    auto ctx = app.ctxs[0];
+    EXPECT_EQ(ctx.id, "MGR");
+    EXPECT_EQ(ctx.logLevel, '\xff');
+    EXPECT_EQ(ctx.traceStatus, '\xff');
+    EXPECT_EQ(ctx.description, "Context of main dlt system manager");
+}
diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp
index 5f2a5ec6..d3c911ec 100644
--- a/src/mainwindow.cpp
+++ b/src/mainwindow.cpp
@@ -87,6 +87,7 @@ extern "C" {
 #include "tablemodel.h"
 #include "sortfilterproxymodel.h"
 #include "qdltoptmanager.h"
+#include "qdltctrlmsg.h"
 
 
 MainWindow::MainWindow(QWidget *parent) :
@@ -2064,8 +2065,9 @@ void MainWindow::reloadLogFileFinishFilter()
         // FIXME: this is slow operation running in the main loop
         QDltMsg msg;
         for (const auto msgIndex : msgIndexList) {
-            if (qfile.getMsg(msgIndex, msg))
+            if (qfile.getMsg(msgIndex, msg)) {
                 contextLoadingFile(msg);
+            }
         }
     }
 
@@ -4455,172 +4457,62 @@ void MainWindow::onSearchresultsTableSelectionChanged(const QItemSelection & sel
 
 void MainWindow::controlMessage_ReceiveControlMessage(EcuItem *ecuitem, const QDltMsg &msg)
 {
-    const char *ptr;
-    int32_t length;
-
-    QByteArray payload = msg.getPayload();
-    ptr = payload.constData();
-    length = payload.size();
-
-    /* control message was received */
-    uint32_t service_id_tmp=0;
-    DLT_MSG_READ_VALUE(service_id_tmp,ptr,length,uint32_t);
-    uint32_t service_id=DLT_ENDIAN_GET_32( ((msg.getEndianness()==QDlt::DltEndiannessBigEndian)?DLT_HTYP_MSBF:0), service_id_tmp);
-
-    switch (service_id)
-    {
-    case DLT_SERVICE_ID_GET_SOFTWARE_VERSION:
-    {
-        // check if plugin autoload enabled and version string not already parsed
-        if(!autoloadPluginsVersionEcus.contains(msg.getEcuid()))
-        {
-            versionString(msg);
-            autoloadPluginsVersionEcus.append(msg.getEcuid());
-        }
-        break;
-    }
-    case DLT_SERVICE_ID_GET_LOG_INFO:
-    {
-        /* Only status 1,2,6,7,8 is supported yet! */
-
-        uint8_t status=0;
-        DLT_MSG_READ_VALUE(status,ptr,length,uint8_t); /* No endian conversion necessary */
-
-        /* Support for status=8 */
-        if (status==8)
-        {
-            ecuitem->InvalidAll();
-        }
-
-        /* Support for status=6 and status=7 */
-        if ((status==6) || (status==7))
-        {
-            uint16_t count_app_ids=0,count_app_ids_tmp=0;
-            DLT_MSG_READ_VALUE(count_app_ids_tmp,ptr,length,uint16_t);
-            count_app_ids=DLT_ENDIAN_GET_16(((msg.getEndianness()==QDlt::DltEndiannessBigEndian)?DLT_HTYP_MSBF:0), count_app_ids_tmp);
-            for (int32_t num=0;num<count_app_ids;num++)
-            {
-                char apid[DLT_ID_SIZE+1];
-                apid[DLT_ID_SIZE] = 0;
-
-                DLT_MSG_READ_ID(apid,ptr,length);
-
-                uint16_t count_context_ids=0,count_context_ids_tmp=0;
-                DLT_MSG_READ_VALUE(count_context_ids_tmp,ptr,length,uint16_t);
-                count_context_ids=DLT_ENDIAN_GET_16(((msg.getEndianness()==QDlt::DltEndiannessBigEndian)?DLT_HTYP_MSBF:0), count_context_ids_tmp);
-
-                for (int32_t num2=0;num2<count_context_ids;num2++)
-                {
-                    QString contextDescription;
-                    char ctid[DLT_ID_SIZE+1];
-                    ctid[DLT_ID_SIZE] = 0;
-
-                    DLT_MSG_READ_ID(ctid,ptr,length);
-
-                    int8_t log_level=0;
-                    DLT_MSG_READ_VALUE(log_level,ptr,length,int8_t); /* No endian conversion necessary */
-
-                    int8_t trace_status=0;
-                    DLT_MSG_READ_VALUE(trace_status,ptr,length,int8_t); /* No endian conversion necessary */
-
-                    if (status==7)
-                    {
-                        uint16_t context_description_length=0,context_description_length_tmp=0;
-                        DLT_MSG_READ_VALUE(context_description_length_tmp,ptr,length,uint16_t);
-                        context_description_length=DLT_ENDIAN_GET_16(((msg.getEndianness()==QDlt::DltEndiannessBigEndian)?DLT_HTYP_MSBF:0),context_description_length_tmp);
-
-                        if (length<context_description_length)
-                        {
-                            length = -1;
-                        }
-                        else
-                        {
-                            contextDescription = QString(QByteArray((char*)ptr,context_description_length));
-                            ptr+=context_description_length;
-                            length-=context_description_length;
-                        }
-                    }
-
-                    controlMessage_SetContext(ecuitem,QString(apid),QString(ctid),contextDescription,log_level,trace_status);
-                }
-
-                if (status==7)
-                {
-                    QString applicationDescription;
-                    uint16_t application_description_length=0,application_description_length_tmp=0;
-                    DLT_MSG_READ_VALUE(application_description_length_tmp,ptr,length,uint16_t);
-                    application_description_length=DLT_ENDIAN_GET_16(((msg.getEndianness()==QDlt::DltEndiannessBigEndian)?DLT_HTYP_MSBF:0),application_description_length_tmp);
-                    applicationDescription = QString(QByteArray((char*)ptr,application_description_length));
-                    controlMessage_SetApplication(ecuitem,QString(apid),applicationDescription);
-                    ptr+=application_description_length;
-                }
-            }
-        }
-
-        break;
-    }
-    case DLT_SERVICE_ID_GET_DEFAULT_LOG_LEVEL:
-    {
-        uint8_t status=0;
-        DLT_MSG_READ_VALUE(status,ptr,length,uint8_t); /* No endian conversion necessary */
-
-        uint8_t loglevel=0;
-        DLT_MSG_READ_VALUE(loglevel,ptr,length,uint8_t); /* No endian conversion necessary */
-
-        switch (status)
-        {
-        case 0: /* OK */
-        {
-            ecuitem->loglevel = loglevel;
-            ecuitem->status = EcuItem::valid;
-        }
-            break;
-        case 1: /* NOT_SUPPORTED */
-        {
-            ecuitem->status = EcuItem::unknown;
-        }
-            break;
-        case 2: /* ERROR */
-        {
-            ecuitem->status = EcuItem::invalid;
-        }
-            break;
-        }
-        /* update status */
-        ecuitem->update();
-
-        break;
-    }
-    case DLT_SERVICE_ID_SET_LOG_LEVEL:
-    {
-        break;
-    }
-    case DLT_SERVICE_ID_TIMEZONE:
-    {
-        if(payload.size() == sizeof(DltServiceTimezone))
-        {
-            DltServiceTimezone *service;
-            service = (DltServiceTimezone*) payload.constData();
-
-            if(msg.getEndianness() == QDlt::DltEndiannessLittleEndian)
-                controlMessage_Timezone(service->timezone, service->isdst);
-            else
-                controlMessage_Timezone(DLT_SWAP_32(service->timezone), service->isdst);
-        }
-        break;
-    }
-    case DLT_SERVICE_ID_UNREGISTER_CONTEXT:
-    {
-        if(payload.size() == sizeof(DltServiceUnregisterContext))
-        {
-            DltServiceUnregisterContext *service;
-            service = (DltServiceUnregisterContext*) payload.constData();
-
-            controlMessage_UnregisterContext(msg.getEcuid(),QDltMsg::getStringFromId(service->apid),QDltMsg::getStringFromId(service->ctid));
-        }
-        break;
-    }
-    } // switch
+    auto ctrlMsg = qdlt::msg::payload::parse(msg.getPayload(), msg.getEndianness() == QDlt::DltEndiannessBigEndian);
+    std::visit(overloaded{[&](const qdlt::msg::payload::GetSoftwareVersion &) {
+                              // TODO: use parsed payload
+                              // check if plugin autoload enabled and version string not already parsed
+                              if(!autoloadPluginsVersionEcus.contains(msg.getEcuid()))
+                              {
+                                  versionString(msg);
+                                  autoloadPluginsVersionEcus.append(msg.getEcuid());
+                              }
+                          },
+                          [&](const qdlt::msg::payload::GetLogInfo &payload) {
+                              if (payload.status == 8)
+                              {
+                                  ecuitem->InvalidAll();
+                              }
+
+                              if (payload.status == 6 || payload.status == 7) {
+                                  for (const auto &app : payload.apps) {
+                                      for (const auto& ctx : app.ctxs) {
+                                          controlMessage_SetContext(ecuitem, app.id, ctx.id,
+                                          ctx.description, ctx.logLevel,
+                                          ctx.traceStatus);
+                                      }
+                                      if (payload.status == 7) {
+                                          controlMessage_SetApplication(ecuitem, app.id,
+                                          app.description);
+                                      }
+                                  }
+                              }
+                          },
+                          [&](const qdlt::msg::payload::GetDefaultLogLevel &payload) {
+                              switch (payload.status) {
+                              case 0: /* OK */
+                                  ecuitem->loglevel = payload.logLevel;
+                                  ecuitem->status = EcuItem::valid;
+                                  break;
+                              case 1: /* NOT_SUPPORTED */
+                                  ecuitem->status = EcuItem::unknown;
+                                  break;
+                              case 2: /* ERROR */
+                                  ecuitem->status = EcuItem::invalid;
+                                  break;
+                              }
+                              ecuitem->update();
+                          },
+                          [&](const qdlt::msg::payload::Timezone &payload) {
+                              controlMessage_Timezone(payload.timezone, payload.isDst);
+                          },
+                          [&](const qdlt::msg::payload::UnregisterContext &payload) {
+                              controlMessage_UnregisterContext(msg.getEcuid(), payload.appid,
+                              payload.ctxid);
+                          },
+                          [&](const qdlt::msg::payload::SetLogLevel &) {
+                              // nothing to do
+                          }},
+               ctrlMsg);
 }
 
 void MainWindow::controlMessage_SendControlMessage(EcuItem* ecuitem,DltMessage &msg, QString appid, QString contid)

From efa6ca26ff8d88f24fff82b77a9952e1ec391fe9 Mon Sep 17 00:00:00 2001
From: Viktor Kopp <vifactor@gmail.com>
Date: Sun, 22 Dec 2024 18:37:00 +0100
Subject: [PATCH 2/2] populate ecus tree efficiently

fix symbols visibility

Fix macos-13 build

It still uses qmake, so new sources should be added there too

Signed-off-by: Viktor Kopp <vifactor@gmail.com>
---
 qdlt/qdlt.pro      |  2 ++
 qdlt/qdltctrlmsg.h |  4 ++-
 src/CMakeLists.txt |  4 ++-
 src/ecutree.cpp    | 17 ++++++++++
 src/ecutree.h      | 27 ++++++++++++++++
 src/mainwindow.cpp | 78 ++++++++++++++++++++++++++++------------------
 src/mainwindow.h   | 10 ++----
 src/src.pro        |  4 ++-
 8 files changed, 105 insertions(+), 41 deletions(-)
 create mode 100644 src/ecutree.cpp
 create mode 100644 src/ecutree.h

diff --git a/qdlt/qdlt.pro b/qdlt/qdlt.pro
index 244b2a90..610123fa 100644
--- a/qdlt/qdlt.pro
+++ b/qdlt/qdlt.pro
@@ -68,6 +68,7 @@ SOURCES +=  \
     fieldnames.cpp \
     qdltimporter.cpp \
     dltmessagematcher.cpp \
+    qdltctrlmsg.cpp \
 
 HEADERS += qdlt.h \
     export_rules.h \
@@ -101,6 +102,7 @@ HEADERS += qdlt.h \
     fieldnames.h \
     qdltimporter.h \
     dltmessagematcher.h \
+    qdltctrlmsg.h \
 
 unix:VERSION            = 1.0.0
 
diff --git a/qdlt/qdltctrlmsg.h b/qdlt/qdltctrlmsg.h
index c9fe634b..7bca75ca 100644
--- a/qdlt/qdltctrlmsg.h
+++ b/qdlt/qdltctrlmsg.h
@@ -1,6 +1,8 @@
 #ifndef QDLTCTRLMSG_H
 #define QDLTCTRLMSG_H
 
+#include "export_rules.h"
+
 #include <vector>
 #include <variant>
 
@@ -57,7 +59,7 @@ struct UnregisterContext {
 using Type = std::variant<GetLogInfo, GetSoftwareVersion, GetDefaultLogLevel, SetLogLevel, Timezone,
                           UnregisterContext>;
 
-Type parse(const QByteArray&, bool isBigEndian);
+QDLT_EXPORT Type parse(const QByteArray&, bool isBigEndian);
 
 } // namespace qdlt::msg::payload
 
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 30b215dc..73678316 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -51,7 +51,9 @@ add_executable(dlt-viewer
     searchform.cpp
     ${UI_RESOURCES_RCC}
     resources/dlt_viewer.rc
-    )
+    ecutree.h
+    ecutree.cpp
+)
 
 target_link_libraries(dlt-viewer
     qdlt
diff --git a/src/ecutree.cpp b/src/ecutree.cpp
new file mode 100644
index 00000000..dd4b56ce
--- /dev/null
+++ b/src/ecutree.cpp
@@ -0,0 +1,17 @@
+#include "ecutree.h"
+
+void EcuTree::add(const QString& ecuId, const qdlt::msg::payload::GetLogInfo& info)
+{
+    for (const auto& app : info.apps) {
+        App appData;
+        appData.description = app.description;
+        for (const auto& ctx : app.ctxs) {
+            Ctx ctxData;
+            ctxData.description = ctx.description;
+            ctxData.logLevel = ctx.logLevel;
+            ctxData.traceStatus = ctx.traceStatus;
+            appData.contexts[ctx.id] = std::move(ctxData);
+        }
+        ecus[ecuId][app.id] = std::move(appData);
+    }
+}
diff --git a/src/ecutree.h b/src/ecutree.h
new file mode 100644
index 00000000..12b7c933
--- /dev/null
+++ b/src/ecutree.h
@@ -0,0 +1,27 @@
+#ifndef ECUTREEBUILDER_H
+#define ECUTREEBUILDER_H
+
+#include <qdltctrlmsg.h>
+
+#include <map>
+
+struct EcuTree
+{
+    void add(const QString& ecuId, const qdlt::msg::payload::GetLogInfo&);
+
+    using EcuId = QString;
+    using AppId = QString;
+    using CtxId = QString;
+    struct Ctx {
+        QString description;
+        int8_t logLevel;
+        int8_t traceStatus;
+    };
+    struct App {
+        QString description;
+        std::map<CtxId, Ctx> contexts;
+    };
+    std::map<EcuId, std::map<AppId, App>> ecus;
+};
+
+#endif // ECUTREEBUILDER_H
diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp
index d3c911ec..6563572a 100644
--- a/src/mainwindow.cpp
+++ b/src/mainwindow.cpp
@@ -88,6 +88,7 @@ extern "C" {
 #include "sortfilterproxymodel.h"
 #include "qdltoptmanager.h"
 #include "qdltctrlmsg.h"
+#include "ecutree.h"
 
 
 MainWindow::MainWindow(QWidget *parent) :
@@ -1893,45 +1894,52 @@ void MainWindow::on_action_menuFile_Clear_triggered()
     return;
 }
 
-void MainWindow::contextLoadingFile(const QDltMsg &msg)
+void MainWindow::populateEcusTree(EcuTree&& ecuTree)
 {
-    /* find ecu item */
-    EcuItem *ecuitemFound = 0;
-    for(int num = 0; num < project.ecu->topLevelItemCount (); num++)
-    {
-        EcuItem *ecuitem = (EcuItem*)project.ecu->topLevelItem(num);
-        if(ecuitem->id == msg.getEcuid())
-        {
-            ecuitemFound = ecuitem;
-            break;
-        }
-    }
+    QList<QTreeWidgetItem*> ecus;
+    // populate ECUs tree view
+    for (auto& [ecuid, apps] : ecuTree.ecus) {
+        EcuItem* ecuItem = new EcuItem(nullptr);
 
-    if(!ecuitemFound)
-    {
-        /* no Ecuitem found, create a new one */
-        ecuitemFound = new EcuItem(0);
+        ecuItem->id = ecuid;
 
-        /* update ECU item */
-        ecuitemFound->id = msg.getEcuid();
-        ecuitemFound->update();
+        QList<QTreeWidgetItem*> appsItems;
+        for(const auto& [appid, appdata] : apps) {
+            ApplicationItem* appItem = new ApplicationItem(ecuItem);
+            appItem->id = appid;
+            appItem->description = appdata.description;
+            appItem->update();
 
-        /* add ECU to configuration */
-        project.ecu->addTopLevelItem(ecuitemFound);
+            QList<QTreeWidgetItem*> contextsItems;
+            for(const auto& [ctxid, ctxdata] : appdata.contexts) {
+                ContextItem* conItem = new ContextItem(appItem);
+                conItem->id = ctxid;
+                conItem->loglevel = ctxdata.logLevel;
+                conItem->tracestatus = ctxdata.traceStatus;
+                conItem->description = ctxdata.description;
+                conItem->status = ContextItem::valid;
+                conItem->update();
 
-        /* Update the ECU list in control plugins */
-        updatePluginsECUList();
+                contextsItems.append(conItem);
+            }
 
-        pluginManager.stateChanged(project.ecu->indexOfTopLevelItem(ecuitemFound), QDltConnection::QDltConnectionOffline,ecuitemFound->getHostname());
+            appItem->addChildren(contextsItems);
+            appsItems.append(appItem);
+        }
 
-    }
+        ecuItem->addChildren(appsItems);
+        ecuItem->update();
 
-    controlMessage_ReceiveControlMessage(ecuitemFound, msg);
-}
+        pluginManager.stateChanged(ecus.size(), QDltConnection::QDltConnectionOffline,
+                                   ecuItem->getHostname());
 
-void MainWindow::reloadLogFileStop()
-{
+        ecus.append(ecuItem);
+    }
+
+    project.ecu->addTopLevelItems(ecus);
 
+    /* Update the ECU list in control plugins */
+    updatePluginsECUList();
 }
 
 void MainWindow::reloadLogFileProgressMax(int num)
@@ -2062,13 +2070,21 @@ void MainWindow::reloadLogFileFinishFilter()
             settings->updateContextLoadingFile) {
         const QList<int> &msgIndexList = dltIndexer->getGetLogInfoList();
 
-        // FIXME: this is slow operation running in the main loop
         QDltMsg msg;
+        EcuTree ecuTree;
         for (const auto msgIndex : msgIndexList) {
             if (qfile.getMsg(msgIndex, msg)) {
-                contextLoadingFile(msg);
+                auto ctrlMsg = qdlt::msg::payload::parse(msg.getPayload(), msg.getEndianness() == QDlt::DltEndiannessBigEndian);
+                std::visit([&ecuTree, ecuId = msg.getEcuid()](auto&& payload) {
+                    using T = std::decay_t<decltype(payload)>;
+                    if constexpr (std::is_same_v<T, qdlt::msg::payload::GetLogInfo>) {
+                        ecuTree.add(ecuId, payload);
+                    }
+                }, ctrlMsg);
             }
         }
+        project.ecu->clear();
+        populateEcusTree(std::move(ecuTree));
     }
 
     // reconnect ecus again
diff --git a/src/mainwindow.h b/src/mainwindow.h
index fd560c98..ea426557 100644
--- a/src/mainwindow.h
+++ b/src/mainwindow.h
@@ -96,6 +96,8 @@ namespace Ui {
     class MainWindow;
 }
 
+struct EcuTree;
+
 class MainWindow : public QMainWindow
 {
     Q_OBJECT
@@ -236,13 +238,8 @@ class MainWindow : public QMainWindow
 
     void getSelectedItems(EcuItem **ecuitem,ApplicationItem** appitem,ContextItem** conitem);
 
-    /**
-        * @brief Reload the complete log file
-        * @param update if this parameter is false, the file is loaded the first time, if true the reload is performed because of a changed configuration
-        *
-        */
-    void reloadLogFileStop();
     void reloadLogFile(bool update=false, bool multithreaded = true);
+    void populateEcusTree(EcuTree&& ecuTree);
 
     void reloadLogFileDefaultFilter();
 
@@ -275,7 +272,6 @@ class MainWindow : public QMainWindow
     void updatePluginsECUList();
     void updatePlugins();
     void updatePlugin(PluginItem *item);
-    void contextLoadingFile(const QDltMsg &msg);
     void versionString(const QDltMsg &msg);
     void pluginsAutoload(QString version);
 
diff --git a/src/src.pro b/src/src.pro
index 3b42f1ea..b1f056b0 100644
--- a/src/src.pro
+++ b/src/src.pro
@@ -149,6 +149,7 @@ SOURCES += main.cpp \
     dltmsgqueue.cpp \
     dltfileindexerthread.cpp \
     dltfileindexerdefaultfilterthread.cpp \
+    ecutree.cpp \
 
 # Show these headers in the project
 HEADERS += mainwindow.h \
@@ -180,7 +181,8 @@ HEADERS += mainwindow.h \
     dltmsgqueue.h \
     dltfileindexerthread.h \
     dltfileindexerdefaultfilterthread.h \
-    mcudpsocket.h
+    mcudpsocket.h \
+    ecutree.h \
 
 # Compile these UI files
 FORMS += mainwindow.ui \