Update main-window

Check/Check.pro

@@ -1,6 +1,6 @@
 QT += core
 
-TARGET = check_update
+TARGET = ATBUpdateCheck
 
 VERSION="1.0.0"
 win32 {
@@ -63,9 +63,13 @@ contains( CONFIG, DesktopLinux ) {
 }
 
 SOURCES += \
-        main.cpp
+        main.cpp \
+        ismas_client.cpp \
+        message_handler.cpp
 
-# HEADERS += \
+HEADERS += \
+        ismas_client.h \
+        message_handler.h
 
 ##########################################################################################
 # for running program on target through QtCreator

Check/ismas_client.cpp

@@ -0,0 +1,364 @@
+#ifdef __WIN32__
+#error "WIN32 NOT SUPPORTED"
+#else
+
+#include "ismas_client.h"
+
+#include <cstring>
+#include <cstdio>
+
+#include <errno.h>
+#include <arpa/inet.h> // inet_addr()
+#include <netdb.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+#include <string.h>
+#include <strings.h> // bzero()
+#include <sys/socket.h>
+#include <unistd.h> // read(), write(), close()
+#include <fcntl.h>
+
+
+#include <QThread>
+#include <QJsonDocument>
+#include <QJsonObject>
+
+#if 0
+########################
+# Spec vom 27.10.2023:
+# U0010 -> %-Werte
+# U0001 -> 100%
+# U0003 -> "FAIL"
+# U0002 -> "" (OK -> WAIT state reset)
+# ISMAS -> "WAIT"
+########################
+#
+# $1: EVENT: U0001 update finished: 100%
+#            U0002 reset TRG
+#            U0003 error
+#            U0010 for update process
+# $2: PERCENT : "only for ISMAS: 0-100%",
+# $3: RESULTCODE : "only for ISMAS",
+#   0: Success
+#   1: no Update nessesary
+#   2: Backup failed
+#   3: Package error/ Wrong package
+#   4: Install Error
+# $4: STEP : "running step (only for us): update_psa...",
+# $5: STEP_RESULT : "error and result text",
+# $6: VERSION : "opkg and conf info; what will be updated"
+#
+#endif
+
+#include <QDateTime>
+#include <QDebug>
+
+void IsmasClient::printDebugMessage(int port,
+                                    QString const &clientIP,
+                                    int clientPort,
+                                    QString const &message) {
+#if 0
+    Q_UNUSED(port);
+    Q_UNUSED(clientIP);
+    Q_UNUSED(clientPort);
+    Q_UNUSED(message);
+#else
+    qDebug().noquote()
+        << "\n"
+        << "SEND-REQUEST-RECEIVE-RESPONSE ..." << "\n"
+        << "hostname ........" << "127.0.0.1"  << "\n"
+        << "port ............" << port << "\n"
+        << "local address ..." << clientIP << "\n"
+        << "local port ......" << clientPort << "\n"
+        << message;
+#endif
+}
+
+void IsmasClient::printInfoMessage(int port,
+                                   QString const &clientIP,
+                                   int clientPort,
+                                   QString const &message) {
+#if 0
+    Q_UNUSED(port);
+    Q_UNUSED(clientIP);
+    Q_UNUSED(clientPort);
+    Q_UNUSED(message);
+#else
+    qInfo().noquote()
+        << "\n"
+        << "SEND-REQUEST-RECEIVE-RESPONSE ..." << "\n"
+        << "hostname ........" << "127.0.0.1"  << "\n"
+        << "port ............" << port << "\n"
+        << "local address ..." << clientIP << "\n"
+        << "local port ......" << clientPort << "\n"
+        << message;
+#endif
+}
+
+void IsmasClient::printErrorMessage(int port,
+                                    QString const &clientIP,
+                                    int clientPort,
+                                    QString const &message) {
+    qCritical().noquote()
+        << "\n"
+        << "SEND-REQUEST-RECEIVE-RESPONSE ..." << "\n"
+        << "hostname ........" << "127.0.0.1"  << "\n"
+        << "port ............" << port << "\n"
+        << "local address ..." << clientIP << "\n"
+        << "local port ......" << clientPort << "\n"
+        << message;
+}
+
+std::optional<QString>
+IsmasClient::sendRequestReceiveResponse(int port, QString const &request) {
+
+    qInfo() << "REQUEST" << request;
+
+    int sockfd;
+    int r;
+    errno = 0;
+    // socket create and verification
+    if ((sockfd = ::socket(AF_INET, SOCK_STREAM, 0)) == -1) {
+        qCritical().noquote()
+            << "\n"
+            << "SEND-REQUEST-RECEIVE-RESPONSE ..." << "\n"
+            << "SOCKET CREATION FAILED (" << strerror(errno) << ")";
+        return std::nullopt;
+    }
+
+    struct sockaddr_in servAddr;
+    bzero(&servAddr, sizeof(servAddr));
+    // assign IP, PORT
+    servAddr.sin_family = AF_INET;
+    servAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
+
+    servAddr.sin_port = htons(port);
+    // connect the client socket to server socket
+    if ((r = ::connect(sockfd, (struct sockaddr *)(&servAddr), sizeof(servAddr))) != 0) {
+        qCritical().noquote()
+            << "\n"
+            << "SEND-REQUEST-RECEIVE-RESPONSE ..." << "\n"
+            << "CONNECTION WITH SERVER FAILED (" << strerror(r) << ")";
+        ::close(sockfd);
+        return std::nullopt;
+    }
+
+    struct sockaddr_in clientAddr;
+    bzero(&clientAddr, sizeof(clientAddr));
+    socklen_t sockLen = sizeof(clientAddr);
+
+    char clientIP[16];
+    bzero(&clientIP, sizeof(clientIP));
+    getsockname(sockfd, (struct sockaddr *)(&clientAddr), &sockLen);
+    inet_ntop(AF_INET, &clientAddr.sin_addr, clientIP, sizeof(clientIP));
+    unsigned int clientPort = ntohs(clientAddr.sin_port);
+
+    printDebugMessage(port, clientIP, clientPort, QString("CONNECTED TO SERVER"));
+
+    struct timeval tv;
+    tv.tv_sec = 10;  /* 10 secs timeout for read and write */
+
+    struct linger so_linger;
+    so_linger.l_onoff = 1;
+    so_linger.l_linger = 0;
+
+    int maxfdp1;
+    fd_set rset;
+    fd_set wset;
+
+    setsockopt(sockfd, SOL_SOCKET, SO_LINGER, &so_linger, sizeof(so_linger));
+    // no reliable, but does not harm, as we use select() as well
+    setsockopt(sockfd, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv));
+    setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
+    int flag = 1;
+    setsockopt(sockfd, IPPROTO_TCP, TCP_NODELAY, (char *) &flag, sizeof(int));
+
+    static char buf[1024*8];
+    bzero(buf, sizeof(buf));
+    int const bytesToWrite = strlen(request.toStdString().c_str());
+    strncpy(buf, request.toStdString().c_str(), sizeof(buf)-1);
+
+    int loop = 0;
+    int bytesWritten = 0;
+    while (bytesWritten < bytesToWrite) {
+        errno = 0;
+        FD_ZERO(&wset);
+        FD_SET(sockfd, &wset);
+        maxfdp1 = sockfd + 1;
+        tv.tv_sec = 60;  /* 60 secs timeout for read and write -> APISM cuts the connection after 30s */
+        tv.tv_usec = 0;
+
+        int const w = select(maxfdp1, NULL, &wset, NULL, &tv);
+        if (w < 0) { // error
+            if (errno == EINTR) {
+                printErrorMessage(port, clientIP, clientPort,
+                    QString("INTERRUPTED BY SIGNAL (1) (") + strerror(errno) + ")");
+                continue;
+            } else {
+                printErrorMessage(port, clientIP, clientPort,
+                        QString("SELECT-ERROR (WRITE) %1(").arg(loop) + strerror(errno) + ")");
+                ::close(sockfd);
+                return std::nullopt;
+            }
+        } else
+        if (w == 0) { // timeout
+            printErrorMessage(port, clientIP, clientPort,
+                    QString("SELECT-TIMEOUT (WRITE) %1(").arg(loop) + strerror(errno) + ")");
+            if (++loop < 10) {
+                QThread::msleep(500);
+                continue;
+            }
+            ::close(sockfd);
+            return std::nullopt;
+        } else
+        if (w > 0) {
+            int n = ::sendto(sockfd, buf+bytesWritten, bytesToWrite-bytesWritten, 0, NULL, 0);
+            if (n >= 0) {
+                bytesWritten += n;
+            } else {
+                if (errno == EWOULDBLOCK) {
+                    if (++loop < 10) {
+                        QThread::msleep(500);
+                        continue;
+                    }
+                    printErrorMessage(port, clientIP, clientPort,
+                        QString("WRITE TIMEOUT %1(").arg(loop) + strerror(errno) + ")");
+                    ::close(sockfd);
+                    return std::nullopt;
+                } else
+                if (errno == EINTR) {
+                    printErrorMessage(port, clientIP, clientPort,
+                        QString("WRITE INTERRUPTED BY SIGNAL (1) (") + strerror(errno) + ")");
+                    continue;
+                }
+            }
+        }
+    }
+
+    // DO NOT USE SHUTDOWN! APISM CAN NOT COPE WITH IT
+    // errno = 0;
+    // if (shutdown(sockfd, SHUT_WR) < 0) {
+    //     printErrorMessage(port, clientIP, clientPort,
+    //        QString("CANNOT CLOSE WRITING END (") + strerror(errno) + ")");
+    // }
+
+    printInfoMessage(port, clientIP, clientPort, QString("MESSAGE SENT <<<") + buf + ">>>");
+
+    loop = 0;
+    bzero(buf, sizeof(buf));
+    int bytesToRead = sizeof(buf)-1;
+    int bytesRead = 0;
+    while (bytesRead < bytesToRead) {
+        errno = 0;
+        FD_ZERO(&rset);
+        FD_SET(sockfd, &rset);
+        maxfdp1 = sockfd + 1;
+        tv.tv_sec = 60;  /* 60 secs timeout for read and write */
+        tv.tv_usec = 0;
+
+        QString const selectStart = QDateTime::currentDateTime().toString(Qt::ISODateWithMs);
+
+        int const r = select(maxfdp1, &rset, NULL, NULL, &tv);
+        if (r < 0) { // error
+            if (errno == EINTR) {
+                printErrorMessage(port, clientIP, clientPort,
+                    QString("INTERRUPTED BY SIGNAL (2) (") + strerror(errno) + ")");
+                continue;
+            } else {
+                printErrorMessage(port, clientIP, clientPort,
+                        QString("SELECT-ERROR (READ) %1(").arg(loop) + strerror(errno) + ")");
+                ::close(sockfd);
+                return std::nullopt;
+            }
+        } else
+        if (r == 0) { // timeout
+            printErrorMessage(port, clientIP, clientPort,
+                    QString("SELECT-TIMEOUT (READ) %1(").arg(loop) + strerror(errno) + ")");
+            if (++loop < 10) {
+                QThread::msleep(500);
+                continue;
+            }
+            ::close(sockfd);
+            return std::nullopt;
+        } else
+        if (r > 0) {
+            if (FD_ISSET(sockfd, &rset)) {
+                int n = ::recvfrom(sockfd, buf+bytesRead, bytesToRead-bytesRead,
+                                   0, NULL, NULL);
+                if (n > 0) { //
+                    bytesRead += n;
+                } else
+                if (n == 0) {
+                    // The return value will be 0 when the peer has performed an orderly shutdown.
+                    printErrorMessage(port, clientIP, clientPort,
+                        QString("PEER CLOSED CONNECTION (") + strerror(errno) + ") START AT" +
+                                selectStart + " NOW " + QDateTime::currentDateTime().toString(Qt::ISODateWithMs));
+                    ::close(sockfd);
+                    return std::nullopt;
+                } else
+                if (n < 0) {
+                    if (errno == EWOULDBLOCK) { // check just in case
+                        if (++loop < 10) {
+                            QThread::msleep(500);
+                            continue;
+                        }
+                        printErrorMessage(port, clientIP, clientPort,
+                                QString("READ TIMEOUT %1(").arg(loop) + strerror(errno) + ")");
+                        ::close(sockfd);
+                        return std::nullopt;
+                    }
+                    if (errno == EINTR) {
+                        printErrorMessage(port, clientIP, clientPort,
+                            QString("INTERRUPTED BY SIGNAL (2) (") + strerror(errno) + ")");
+                        continue;
+                    }
+                }
+            }
+        }
+
+        // printInfoMessage(port, clientIP, clientPort, QString("MESSAGE RECEIVED ") + buf);
+        QString response(buf);
+
+        if (int idx = response.indexOf("{\"error\":\"ISMAS is offline\"}")) {
+            response = response.mid(0, idx);
+        } else
+        if (response.contains("RECORD")) { // RECORD SAVED or RECORD WRITE ABORTED
+            printInfoMessage(port, clientIP, clientPort, QString("IGNORED '") + response + "' RESPONSE");
+            ::close(sockfd);
+            return std::nullopt;
+        }
+
+        QJsonParseError parseError;
+        QJsonDocument document(QJsonDocument::fromJson(response.toUtf8(), &parseError));
+        if (parseError.error == QJsonParseError::NoError) {
+            if (document.isObject()) { // done: received valid APISM response
+                printInfoMessage(port, clientIP, clientPort,
+                   QString("VALID APISM RESPONSE .. \n") + response);
+                ::close(sockfd);
+                return response;
+            } else {
+                printInfoMessage(port, clientIP, clientPort,
+                   QString("CORRUPTED RESPONSE ") + response);
+                ::close(sockfd);
+                return std::nullopt;
+            }
+        } else {
+            if (!response.contains("RECORD")) {
+                // maybe APISM does not send valid JSON: "RECORD SAVED" etc.
+                printDebugMessage(port, clientIP, clientPort,
+                    QString("PARSE ERROR ") + response + " " + parseError.errorString());
+            }
+            ::close(sockfd);
+            return std::nullopt;
+        }
+    }
+    return std::nullopt;
+}
+
+char const *IsmasClient::reason[REASON::ENTRIES] = {
+    "TIME-TRIGGERED", "SERVICE", "DEV-TEST"
+};
+
+#endif // __WIN32__

Check/ismas_client.h

@@ -0,0 +1,51 @@
+#ifndef ISMAS_CLIENT_H_INCLUDED
+#define ISMAS_CLIENT_H_INCLUDED
+
+#include <QObject>
+#include <QString>
+#include <optional>
+
+class IsmasClient : public QObject {
+    Q_OBJECT
+
+public:
+    explicit IsmasClient()  = default;
+
+    enum APISM {
+        DB_PORT = 7777,
+        DIRECT_PORT = 7778
+    };
+
+    enum RESULT_CODE {
+        SUCCESS=0,
+        // if between 00:00 - 04:00 Wait-button state not WAIT, then we assume
+        // that's an automatic nightly (not-necessary) update
+        NO_UPDATE_NECESSARY=1,
+        // if APISM reports the ISMAS is not available (15x, 6s delay each)
+        ISMAS_NO_CONNECTION_ERROR=2,
+        // if not within 00:00-04:00 and WAIT-button was not in state WAIT
+        ISMAS_TRIGGER_ERROR=3,
+    };
+
+    enum REASON {
+        TIME_TRIGGERED = 0,
+        SERVICE,
+        DEV_TEST,
+        ENTRIES
+    };
+
+    static char const *reason[REASON::ENTRIES];
+
+    static std::optional<QString>
+        sendRequestReceiveResponse(int port, QString const &request);
+
+  private:
+    static void printDebugMessage(int port, QString const &clientIP, int clientPort,
+                                  QString const &message);
+    static void printInfoMessage(int port, QString const &clientIP, int clientPort,
+                                 QString const &message);
+    static void printErrorMessage(int port, QString const &clientIP, int clientPort,
+                                  QString const &message);
+};
+
+#endif // ISMAS_CLIENT_H_INCLUDED

Check/main.cpp

@@ -9,6 +9,43 @@
 #include <QDir>
 #include <QDebug>
 
+#include "commandline_parser.h"
+#include "message_handler.h"
+
 int main(int argc, char **argv) {
+    QByteArray const value = qgetenv("LC_ALL");
+    if (value.isEmpty() || value != "C") {
+        qputenv("LC_ALL", "C");
+    }
+
+
+    // qputenv("XDG_RUNTIME_DIR", "/var/run/user/0");
+
+    openlog("ATB-UPDATE_CHECK", LOG_PERROR | LOG_PID | LOG_CONS, LOG_USER);
+
+    QCoreApplication a(argc, argv);
+    QCoreApplication::setApplicationName("ATBUpdateCheck");
+    QCoreApplication::setApplicationVersion(APP_VERSION);
+
+    if (!messageHandlerInstalled()) { // change internal qt-QDebug-handling
+        atbInstallMessageHandler(nullptr);
+        //atbInstallMessageHandler(atbDebugOutput);
+        setDebugLevel(LOG_NOTICE);
+    }
+
+    QCommandLineParser parser;
+    QCommandLineOption ismasConnectOption("ismas-connected");
+    QCommandLineOption updateRequestedOption("update-requested");
+    parser.addOption(ismasConnectOption);
+    parser.addOption(updateRequestedOption);
+    parser.process(a);
+
+    if (parser.isSet(ismasConnectOption)) {
+        qCritical() << parser.isSet(ismasConnectOption);
+    } else
+    if (parser.isSet(updateRequestedOption)) {
+        qCritical() << parser.isSet(updateRequestedOption);
+    }
+
     return 0;
 }

Check/message_handler.cpp

@@ -0,0 +1,97 @@
+#include "message_handler.h"
+
+#include <QDateTime>
+#include <cstring>
+#include <QString>
+#include <QFileInfo>
+#include <QMessageLogContext>
+
+
+static char const *DBG_NAME[] = { "DBG  ", "WARN ", "CRIT ", "FATAL", "INFO " };
+static bool installedMsgHandler = false;
+static int debugLevel = LOG_NOTICE;
+
+int getDebugLevel() { return debugLevel; }
+void setDebugLevel(int newDebugLevel) {
+    debugLevel = newDebugLevel;
+}
+
+bool messageHandlerInstalled() {
+    return installedMsgHandler;
+}
+
+QtMessageHandler atbInstallMessageHandler(QtMessageHandler handler) {
+    installedMsgHandler = (handler != 0);
+    static QtMessageHandler prevHandler = nullptr;
+    if (handler) {
+        prevHandler = qInstallMessageHandler(handler);
+        return prevHandler;
+    } else {
+        return qInstallMessageHandler(prevHandler);
+    }
+}
+
+///
+/// \brief Print message according to given debug level.
+///
+/// \note Install this function using qInstallMsgHandler().
+///
+///  int main(int argc, char **argv) {
+///     installMsgHandler(atbDebugOutput);
+///     QApplication app(argc, argv);
+///     ...
+///     return app.exec();
+///  }
+///
+#if (QT_VERSION > QT_VERSION_CHECK(5, 0, 0) && QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
+void atbDebugOutput(QtMsgType type, const QMessageLogContext &context, const QString &msg) {
+    Q_UNUSED(context);
+    QString const localMsg = QString(DBG_NAME[type]) + msg.toLocal8Bit();
+
+    switch (debugLevel) {
+        case LOG_DEBUG: { // debug-level message
+            syslog(LOG_DEBUG, "%s", localMsg.toStdString().c_str());
+        } break;
+        case LOG_INFO: { // informational message
+            if (type != QtDebugMsg) {
+                syslog(LOG_DEBUG, "%s", localMsg.toStdString().c_str());
+            }
+        } break;
+        case LOG_NOTICE: { // normal, but significant, condition
+            if (type != QtDebugMsg) {
+                syslog(LOG_DEBUG, "%s", localMsg.toStdString().c_str());
+            }
+        } break;
+        case LOG_WARNING: { // warning conditions
+            if (type != QtInfoMsg && type != QtDebugMsg) {
+                syslog(LOG_DEBUG, "%s", localMsg.toStdString().c_str());
+            }
+        } break;
+        case LOG_ERR: { // error conditions
+            if (type != QtInfoMsg && type != QtDebugMsg && type != QtWarningMsg) {
+                syslog(LOG_DEBUG, "%s", localMsg.toStdString().c_str());
+            }
+        } break;
+        case LOG_CRIT: { // critical conditions
+            if (type != QtInfoMsg && type != QtDebugMsg && type != QtWarningMsg) {
+                syslog(LOG_DEBUG, "%s", localMsg.toStdString().c_str());
+            }
+        } break;
+        case LOG_ALERT: { // action must be taken immediately
+            if (type != QtInfoMsg && type != QtDebugMsg && type != QtWarningMsg) {
+                syslog(LOG_DEBUG, "%s", localMsg.toStdString().c_str());
+            }
+        } break;
+        case LOG_EMERG: { // system is unusable
+            if (type != QtInfoMsg && type != QtDebugMsg && type != QtWarningMsg) {
+                syslog(LOG_DEBUG, "%s", localMsg.toStdString().c_str());
+            }
+        } break;
+        default: {
+            //fprintf(stderr, "%s No ErrorLevel defined! %s\n",
+            //    datetime.toStdString().c_str(), msg.toStdString().c_str());
+        }
+    }
+}
+#endif
+

Check/message_handler.h

@@ -0,0 +1,23 @@
+#ifndef MESSAGE_HANDLER_H_INCLUDED
+#define MESSAGE_HANDLER_H_INCLUDED
+
+#include <QtGlobal>
+#ifdef __linux__
+#include <syslog.h>
+#endif
+
+int getDebugLevel();
+void setDebugLevel(int newDebugLevel);
+
+bool messageHandlerInstalled();
+QtMessageHandler atbInstallMessageHandler(QtMessageHandler handler);
+
+#if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
+// typedef void (*QtMessageHandler)(QtMsgType, const char *);
+void atbDebugOutput(QtMsgType type, const char *msg);
+#elif QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
+// typedef void (*QtMessageHandler)(QtMsgType, const QMessageLogContext &, const QString &);
+void atbDebugOutput(QtMsgType type, const QMessageLogContext &context, const QString &msg);
+#endif
+
+#endif // MESSAGE_HANDLER_H_INCLUDED

UpdatePTUDevCtrl/UpdatePTUDevCtrl.pro

@@ -310,7 +310,7 @@ HEADERS += \
         process/check_ismas_connectivity_command.h \
         process/check_update_activation_command.h \
         process/check_and_fetch_customer_repository_command.h \
-        process/exec_opkg_command.cpp \
+        process/exec_opkg_command.h \
         process/show_software_status_command.h \
         message_handler.h \
         worker.h \

UpdatePTUDevCtrl/mainwindow.cpp

@@ -4,6 +4,7 @@
 #include "utils.h"
 #include "progress_event.h"
 #include "update_dc_event.h"
+#include "process/update_command.h"
 #include <DeviceController/interfaces.h>
 
 #include <QDateTime>
@@ -85,7 +86,17 @@ MainWindow::MainWindow(Worker *worker, QWidget *parent)
     connect(m_worker, SIGNAL(showDcDownload(QString)),this,SLOT(onShowDcDownload(QString)));
     connect(m_worker, SIGNAL(showJsonDownload(QString)),this,SLOT(onShowJsonDownload(QString)));
     connect(m_worker, SIGNAL(showTariffUpdate(QString)),this,SLOT(onShowTariffUpdate(QString)));
+
+    // deprecated
     connect(m_worker, SIGNAL(showISMASChecks(QString)),this,SLOT(onShowISMASChecks(QString)));
+
+    connect(m_worker, SIGNAL(showISMASConnectivity(QString)),this,SLOT(onShowISMASConnectivity(QString)));
+    connect(m_worker, SIGNAL(showUpdateRequest(QString)),this,SLOT(onShowUpdateRequest(QString)));
+    connect(m_worker, SIGNAL(showCustRepoStatus(QString)),this,SLOT(onShowCustRepoStatus(QString)));
+    connect(m_worker, SIGNAL(showExecOpkgStatus(QString)),this,SLOT(onShowExecOpkgStatus(QString)));
+    connect(m_worker, SIGNAL(showDownloadDCJsonFilesStatus(QString)),this,SLOT(onShowDownloadDCJsonFilesStatus(QString)));
+    connect(m_worker, SIGNAL(showSyncCustRepoStatus(QString)),this,SLOT(onShowSyncCustRepoStatus(QString)));
+    connect(m_worker, SIGNAL(showUpdateDCFirmware(QString)),this,SLOT(onShowUpdateDCFirmware(QString)));
     connect(m_worker, SIGNAL(setDcDownloadProgress(int)),this,SLOT(onSetDcDownloadProgress(int)));
     connect(m_worker, SIGNAL(enableExit()),this,SLOT(onEnableExit()));
     connect(m_worker, SIGNAL(stopStartTimer()),this,SLOT(onStopStartTimer()));
@@ -134,7 +145,170 @@ void MainWindow::onShowTariffUpdate(QString) {
     ui->stepLabel->setText(s);
 }
 
+void MainWindow::onShowISMASConnectivity(QString status) {
+    // ausgabe: connected, not connected, connecting
+
+    qCritical() << __func__ << ":" << __LINE__ << "status" << status;
+
+    QString s = ui->stepLabel->text();
+
+    QString tmp("backend connection (ISMAS) ");
+    int len = m_showLineLength - tmp.length();
+    while (--len > 0) {
+       tmp += "&nbsp;";
+    }
+
+    if (status.contains(UpdateCommand::ISMAS_CONNECTED, Qt::CaseInsensitive)) {
+        s += QString("%1 <font color='Green'>connected</font><br />").arg(tmp);
+    } else
+    if (status.contains(UpdateCommand::ISMAS_CONNECTION_IN_PROGRESS, Qt::CaseInsensitive)) {
+        s += QString("%1 <font color='Green'>connecting</font><br />").arg(tmp);
+    } else
+    if (status.contains(UpdateCommand::ISMAS_NOT_CONNECTED, Qt::CaseInsensitive)) {
+        s += QString(  "%1 <font color='Red'>NOT CONNECTED</font><br />").arg(tmp);
+    } else {
+        s += QString(  "%1 <font color='Red'>UNKNOWN STATUS</font><br />").arg(tmp);
+    }
+
+    ui->stepLabel->setText(s);
+}
+
+void MainWindow::onShowCustRepoStatus(QString status) {
+    qCritical() << __func__ << ":" << __LINE__ << "status" << status;
+
+    QString s = ui->stepLabel->text();
+
+    QString tmp("customer repository ");
+    int len = m_showLineLength - tmp.length();
+    while (--len > 0) {
+       tmp += "&nbsp;";
+    }
+
+    if (status.contains(UpdateCommand::GIT_CUSTOMER_REPO_UP_TO_DATE, Qt::CaseInsensitive)) {
+        s += QString("%1 <font color='Green'>up to date</font><br />").arg(tmp);
+    } else {
+        s += QString(  "%1 <font color='Red'>UNKNOWN STATUS</font><br />").arg(tmp);
+    }
+
+    ui->stepLabel->setText(s);
+}
+
+void MainWindow::onShowExecOpkgStatus(QString status) {
+    qCritical() << __func__ << ":" << __LINE__ << "status" << status;
+
+    QString s = ui->stepLabel->text();
+
+    QString tmp = "execute opkg commands ";
+    int len = m_showLineLength - tmp.length();
+
+    while (--len > 0) {
+       tmp += "&nbsp;";
+    }
+
+    if (status.contains(UpdateCommand::EXEC_OPKG_COMMANDS_SUCCESS, Qt::CaseInsensitive)) {
+        s += QString("%1 <font color='Green'>success</font><br />").arg(tmp);
+    } else {
+        s += QString(  "%1 <font color='Red'>UNKNOWN STATUS</font><br />").arg(tmp);
+    }
+
+    ui->stepLabel->setText(s);
+}
+
+void MainWindow::onShowDownloadDCJsonFilesStatus(QString status) {
+    qCritical() << __func__ << ":" << __LINE__ << "status" << status;
+
+    QString s = ui->stepLabel->text();
+
+    QString tmp = "configure device controller ";
+    int len = m_showLineLength - tmp.length();
+
+    while (--len > 0) {
+       tmp += "&nbsp;";
+    }
+
+    if (status.contains(UpdateCommand::UPDATE_DC_JSON_FILES_SUCCESS, Qt::CaseInsensitive)) {
+        s += QString("%1 <font color='Green'>success</font><br />").arg(tmp);
+    } else {
+        s += QString(  "%1 <font color='Red'>UNKNOWN STATUS</font><br />").arg(tmp);
+    }
+
+    ui->stepLabel->setText(s);
+}
+
+void MainWindow::onShowSyncCustRepoStatus(QString status) {
+    qCritical() << __func__ << ":" << __LINE__ << "status" << status;
+
+    QString s = ui->stepLabel->text();
+
+    QString tmp = "synchronize repository/filesystem ";
+    int len = m_showLineLength - tmp.length();
+
+    while (--len > 0) {
+       tmp += "&nbsp;";
+    }
+
+    if (status.contains(UpdateCommand::SYNC_CUSTOMER_REPO_FILES_SUCCESS, Qt::CaseInsensitive)) {
+        s += QString("%1 <font color='Green'>success</font><br />").arg(tmp);
+    } else {
+        s += QString(  "%1 <font color='Red'>UNKNOWN STATUS</font><br />").arg(tmp);
+    }
+
+    ui->stepLabel->setText(s);
+}
+
+void MainWindow::onShowUpdateDCFirmware(QString status) {
+    qCritical() << __func__ << ":" << __LINE__ << "status" << status;
+
+    QString s = ui->stepLabel->text();
+
+    QString tmp = "device controller update ";
+    int len = m_showLineLength - tmp.length();
+
+    while (--len > 0) {
+       tmp += "&nbsp;";
+    }
+
+    if (status.contains(UpdateCommand::UPDATE_DC_FIRMARE_SUCCESS, Qt::CaseInsensitive)) {
+        s += QString("%1 <font color='Green'>success</font><br />").arg(tmp);
+    } else {
+        s += QString(  "%1 <font color='Red'>UNKNOWN STATUS</font><br />").arg(tmp);
+    }
+
+    ui->stepLabel->setText(s);
+}
+
+
+void MainWindow::onShowUpdateRequest(QString status) {
+
+    qCritical() << __func__ << ":" << __LINE__ << "status" << status;
+
+    QString s = ui->stepLabel->text();
+
+    QString tmp = "update request ";
+    int len = m_showLineLength - tmp.length();
+
+    while (--len > 0) {
+       tmp += "&nbsp;";
+    }
+
+    if (status.contains(UpdateCommand::UPDATE_NOT_REQUESTED, Qt::CaseInsensitive)) {
+        s += QString(  "%1 <font color='Red'>NOT REQUESTED</font><br />").arg(tmp);
+    } else
+    if (status.contains(UpdateCommand::UPDATE_REQUESTED, Qt::CaseInsensitive)) {
+        s += QString("%1 <font color='Green'>requested</font><br />").arg(tmp);
+    } else
+    if (status.contains(UpdateCommand::UPDATE_NOT_NECESSARY, Qt::CaseInsensitive)) {
+        s += QString("%1 <font color='Green'>not necessary</font><br />").arg(tmp);
+    } else {
+        s += QString(  "%1 <font color='Red'>UNKNOWN STATUS</font><br />").arg(tmp);
+    }
+
+    ui->stepLabel->setText(s);
+}
+
 void MainWindow::onShowISMASChecks(QString) {
+    // deprecated
+
     QString s = ui->stepLabel->text();
 
     QString tmp("Check ISMAS connectivity ");
@@ -177,7 +351,10 @@ void MainWindow::onShowDcDownload(QString version) {
     ui->exit->setEnabled(false);
 
     // test
-    onShowISMASChecks("");
+    // onShowISMASChecks("");
+    onShowISMASConnectivity("connected");
+    onShowUpdateRequest("activated");
+
     onShowTariffUpdate("");
     onShowJsonDownload("");
 

UpdatePTUDevCtrl/mainwindow.h

@@ -55,6 +55,13 @@ public slots:
     void onShowJsonDownload(QString);
     void onShowTariffUpdate(QString);
     void onShowISMASChecks(QString);
+    void onShowISMASConnectivity(QString);
+    void onShowUpdateRequest(QString);
+    void onShowCustRepoStatus(QString);
+    void onShowExecOpkgStatus(QString);
+    void onShowDownloadDCJsonFilesStatus(QString);
+    void onShowSyncCustRepoStatus(QString);
+    void onShowUpdateDCFirmware(QString);
     void onSetDcDownloadProgress(int);
     void onShowSummary(QString);
 #if EMERGENCY_LEAVE_BL==1

UpdatePTUDevCtrl/process/check_and_fetch_customer_repository_command.cpp

@@ -1,6 +1,21 @@
 #include "process/check_and_fetch_customer_repository_command.h"
+#include "worker.h"
 
 CheckAndFetchCustomerRepositoryCommand::CheckAndFetchCustomerRepositoryCommand(
     QString const &command, Worker *worker, int start_timeout, int finish_timeout)
   : UpdateCommand(command, worker, start_timeout, finish_timeout) {
 }
+
+void CheckAndFetchCustomerRepositoryCommand::readyReadStandardOutput() {
+    QProcess *p = (QProcess *)sender();
+    if (p) {
+        QString s = p->readAllStandardOutput();
+
+        // TODO
+        Worker *w = worker();
+        if (w) {
+    // static constexpr const char *GIT_CUSTOMER_REPO_UP_TO_DATE{"up to date"};
+            emit w->showCustRepoStatus(UpdateCommand::GIT_CUSTOMER_REPO_UP_TO_DATE);
+        }
+    }
+}

UpdatePTUDevCtrl/process/check_and_fetch_customer_repository_command.h

@@ -9,6 +9,8 @@ public:
                                                     Worker *worker,
                                                     int start_timeout = 100000,
                                                     int finish_timeout = 100000);
+protected slots:
+    virtual void readyReadStandardOutput() override;
 };
 
 #endif // CHECK_AND_FETCH_CUSTOMER_REPOSITORY_COMMAND_H_INCLUDED

UpdatePTUDevCtrl/process/check_ismas_connectivity_command.cpp

@@ -1,5 +1,7 @@
 #include "process/check_ismas_connectivity_command.h"
+#include "worker.h"
 
+#include <QDebug>
 
 CheckIsmasConnectivityCommand::CheckIsmasConnectivityCommand(QString const &command,
                                                              Worker *worker,
@@ -7,3 +9,19 @@ CheckIsmasConnectivityCommand::CheckIsmasConnectivityCommand(QString const &comm
                                                              int finish_timeout)
   : UpdateCommand(command, worker, start_timeout, finish_timeout) {
 }
+
+void CheckIsmasConnectivityCommand::readyReadStandardOutput() {
+    QProcess *p = (QProcess *)sender();
+    if (p) {
+        QString s = p->readAllStandardOutput();
+
+        // TODO
+        Worker *w = worker();
+        if (w) {
+    //static constexpr const char *ISMAS_CONNECTED{"connected"};
+    //static constexpr const char *ISMAS_NOT_CONNECTED{"not connected"};
+    //static constexpr const char *ISMAS_CONNECTION_IN_PROGRESS{"connecting"};
+            emit w->showISMASConnectivity(UpdateCommand::ISMAS_CONNECTED);
+        }
+    }
+}

UpdatePTUDevCtrl/process/check_ismas_connectivity_command.h

@@ -9,6 +9,8 @@ public:
                                            Worker *worker,
                                            int start_timeout = 100000,
                                            int finish_timeout = 100000);
+protected slots:
+    virtual void readyReadStandardOutput() override;
 };
 
 #endif // CHECK_ISMAS_CONNECTIVITY_COMMAND_H_INCLUDED

UpdatePTUDevCtrl/process/check_update_activation_command.cpp

@@ -1,5 +1,7 @@
 #include "process/check_update_activation_command.h"
+#include "worker.h"
 
+#include <QDebug>
 
 CheckUpdateActivationCommand::CheckUpdateActivationCommand(QString const &command,
                                                            Worker *worker,
@@ -7,3 +9,19 @@ CheckUpdateActivationCommand::CheckUpdateActivationCommand(QString const &comman
                                                            int finish_timeout)
   : UpdateCommand(command, worker, start_timeout, finish_timeout) {
 }
+
+void CheckUpdateActivationCommand::readyReadStandardOutput() {
+    QProcess *p = (QProcess *)sender();
+    if (p) {
+        QString s = p->readAllStandardOutput();
+
+        // TODO
+        Worker *w = worker();
+        if (w) {
+    //static constexpr const char *UPDATE_NOT_NECESSARY{"not necessary"};
+    //static constexpr const char *UPDATE_NOT_REQUESTED{"not requested"};
+    //static constexpr const char *UPDATE_REQUESTED{"requested"};
+            emit w->showUpdateRequest(UpdateCommand::UPDATE_REQUESTED);
+        }
+    }
+}

UpdatePTUDevCtrl/process/check_update_activation_command.h

@@ -9,6 +9,8 @@ public:
                                           Worker *worker,
                                           int start_timeout = 100000,
                                           int finish_timeout = 100000);
+protected slots:
+    virtual void readyReadStandardOutput() override;
 };
 
 #endif // CHECK_UPDATE_ACTIVATION_COMMAND_H_INCLUDED

UpdatePTUDevCtrl/process/command.cpp

@@ -38,6 +38,8 @@ void Command::readyReadStandardOutput() {
     if (p) {
         QString s = p->readAllStandardOutput();
 
+        // qCritical() << __func__ << ":" << __LINE__ << s;
+
         if (m_worker) {
             int i = -1;
             if ((i = s.indexOf("<DC-VERSION>")) != -1) {

UpdatePTUDevCtrl/process/command.h

@@ -43,10 +43,12 @@ public:
     int exitCode() const { return m_exitCode; }
 
     void setWorker(Worker *worker) {m_worker = worker; }
+    Worker const *worker() const { return m_worker; }
+    Worker *worker() { return m_worker; }
 
 protected slots:
-    void readyReadStandardOutput();
-    void readyReadStandardError();
+    virtual void readyReadStandardOutput();
+    virtual void readyReadStandardError();
     virtual void finished(int exitCode, QProcess::ExitStatus exitStatus);
 };
 

UpdatePTUDevCtrl/process/exec_opkg_command.cpp

@@ -1,5 +1,5 @@
 #include "process/exec_opkg_command.h"
-
+#include "worker.h"
 
 ExecOpkgCommand::ExecOpkgCommand(QString const &command,
                                  Worker *worker,
@@ -7,5 +7,19 @@ ExecOpkgCommand::ExecOpkgCommand(QString const &command,
                                  int start_timeout,
                                  int finish_timeout)
   : UpdateCommand(command, worker, start_timeout, finish_timeout)
-  , m_noaction(m_noaction) {
+  , m_noaction(noaction) {
+}
+
+void ExecOpkgCommand::readyReadStandardOutput() {
+    QProcess *p = (QProcess *)sender();
+    if (p) {
+        QString s = p->readAllStandardOutput();
+
+        // TODO
+        Worker *w = worker();
+        if (w) {
+    // static constexpr const char *EXEC_OPKG_COMMANDS_SUCCESS{"success"};
+            emit w->showExecOpkgStatus(UpdateCommand::EXEC_OPKG_COMMANDS_SUCCESS);
+        }
+    }
 }

UpdatePTUDevCtrl/process/exec_opkg_command.h

@@ -12,6 +12,8 @@ public:
                              bool noaction,
                              int start_timeout = 100000,
                              int finish_timeout = 100000);
+protected slots:
+    virtual void readyReadStandardOutput() override;
 };
 
 #endif // EXEC_OPKG_COMMAND_H_INCLUDED

UpdatePTUDevCtrl/process/show_software_status_command.cpp

@@ -1,4 +1,5 @@
 #include "process/show_software_status_command.h"
+#include "worker.h"
 
 
 ShowSoftwareStatusCommand::ShowSoftwareStatusCommand(QString const &command,
@@ -7,3 +8,17 @@ ShowSoftwareStatusCommand::ShowSoftwareStatusCommand(QString const &command,
                                                      int finish_timeout)
   : UpdateCommand(command, worker, start_timeout, finish_timeout) {
 }
+
+void ShowSoftwareStatusCommand::readyReadStandardOutput() {
+    //QProcess *p = (QProcess *)sender();
+    //if (p) {
+    //    QString s = p->readAllStandardOutput();
+    //
+        // TODO
+        // Worker *w = worker();
+        //if (w) {
+    // static constexpr const char *EXEC_OPKG_COMMANDS_SUCCESS{"success"};
+    //        emit w->showExecOpkgStatus(UpdateCommand::EXEC_OPKG_COMMANDS_SUCCESS);
+    //    }
+    //}
+}

UpdatePTUDevCtrl/process/show_software_status_command.h

@@ -9,5 +9,7 @@ public:
                                        Worker *worker,
                                        int start_timeout = 100000,
                                        int finish_timeout = 100000);
+protected slots:
+    virtual void readyReadStandardOutput() override;
 };
 #endif // SHOW_SOFTWARE_STATUS_COMMAND_H_INCLUDED

UpdatePTUDevCtrl/process/update_command.h

@@ -6,6 +6,19 @@
 class Worker;
 class UpdateCommand : public Command {
 public:
+
+    static constexpr const char *UPDATE_NOT_NECESSARY{"not necessary"};
+    static constexpr const char *UPDATE_NOT_REQUESTED{"not requested"};
+    static constexpr const char *UPDATE_REQUESTED{"requested"};
+    static constexpr const char *ISMAS_CONNECTED{"connected"};
+    static constexpr const char *ISMAS_NOT_CONNECTED{"not connected"};
+    static constexpr const char *ISMAS_CONNECTION_IN_PROGRESS{"connecting"};
+    static constexpr const char *GIT_CUSTOMER_REPO_UP_TO_DATE{"up to date"};
+    static constexpr const char *EXEC_OPKG_COMMANDS_SUCCESS{"success"};
+    static constexpr const char *UPDATE_DC_JSON_FILES_SUCCESS{"success"};
+    static constexpr const char *SYNC_CUSTOMER_REPO_FILES_SUCCESS{"success"};
+    static constexpr const char *UPDATE_DC_FIRMARE_SUCCESS{"success"};
+
     explicit UpdateCommand(QString const &command,
                            Worker *worker,
                            int start_timeout = 100000,

UpdatePTUDevCtrl/process/update_dc_command.cpp

@@ -1,4 +1,5 @@
 #include "process/update_dc_command.h"
+#include "worker.h"
 
 UpdateDCCommand::UpdateDCCommand(QString const &command,
                                  Worker *worker,
@@ -6,3 +7,17 @@ UpdateDCCommand::UpdateDCCommand(QString const &command,
                                  int finish_timeout)
   : UpdateCommand(command, worker, start_timeout, finish_timeout) {
 }
+
+void UpdateDCCommand::readyReadStandardOutput() {
+    QProcess *p = (QProcess *)sender();
+    if (p) {
+        QString s = p->readAllStandardOutput();
+
+        // TODO
+        Worker *w = worker();
+        if (w) {
+    // static constexpr const char *UPDATE_DC_FIRMARE_SUCCESS"success"};
+            emit w->showUpdateDCFirmware(UpdateCommand::UPDATE_DC_FIRMARE_SUCCESS);
+        }
+    }
+}

UpdatePTUDevCtrl/process/update_dc_command.h

@@ -9,6 +9,8 @@ public:
                              Worker *worker,
                              int start_timeout = 100000,
                              int finish_timeout = 100000);
+protected slots:
+    virtual void readyReadStandardOutput() override;
 };
 
 #endif // UPDATE_DC_COMMAND_H_INCLUDED

UpdatePTUDevCtrl/process/update_filesystem_command.cpp

@@ -1,4 +1,5 @@
 #include "process/update_filesystem_command.h"
+#include "worker.h"
 
 UpdateFileSystemCommand::UpdateFileSystemCommand(QString const &command,
                                                  Worker *worker,
@@ -6,3 +7,17 @@ UpdateFileSystemCommand::UpdateFileSystemCommand(QString const &command,
                                                  int finish_timeout)
   : UpdateCommand(command, worker, start_timeout, finish_timeout) {
 }
+
+void UpdateFileSystemCommand::readyReadStandardOutput() {
+    QProcess *p = (QProcess *)sender();
+    if (p) {
+        QString s = p->readAllStandardOutput();
+
+        // TODO
+        Worker *w = worker();
+        if (w) {
+    // static constexpr const char *SYNC_CUSTOMER_REPO_FILES_SUCCESS{"success"};
+            emit w->showSyncCustRepoStatus(UpdateCommand::SYNC_CUSTOMER_REPO_FILES_SUCCESS);
+        }
+    }
+}

UpdatePTUDevCtrl/process/update_filesystem_command.h

@@ -9,6 +9,8 @@ public:
                                      Worker *worker,
                                      int start_timeout = 100000,
                                      int finish_timeout = 100000);
+protected slots:
+    virtual void readyReadStandardOutput() override;
 };
 
 #endif // UPDATE_FS_COMMAND_H_INCLUDED

UpdatePTUDevCtrl/process/update_json_command.cpp

@@ -1,4 +1,8 @@
 #include "process/update_json_command.h"
+#include "worker.h"
+
+#include <QDebug>
+
 
 UpdateJsonCommand::UpdateJsonCommand(QString const &command,
                                      Worker *worker,
@@ -6,3 +10,14 @@ UpdateJsonCommand::UpdateJsonCommand(QString const &command,
                                      int finish_timeout)
   : UpdateCommand(command, worker, start_timeout, finish_timeout) {
 }
+
+void UpdateJsonCommand::readyReadStandardOutput() {
+    QProcess *p = (QProcess *)sender();
+    if (p) {
+        QString s = p->readAllStandardOutput();
+        // qCritical() << __func__ << ":" << __LINE__ << s;
+
+    // static constexpr const char *UPDATE_DC_JSON_FILES_SUCCESS{"success"};
+        emit m_worker->showDownloadDCJsonFilesStatus(UpdateCommand::UPDATE_DC_JSON_FILES_SUCCESS);
+    }
+}

UpdatePTUDevCtrl/process/update_json_command.h

@@ -9,6 +9,8 @@ public:
                                Worker *worker,
                                int start_timeout = 100000,
                                int finish_timeout = 100000);
+protected slots:
+    virtual void readyReadStandardOutput() override;
 };
 
 #endif // UPDATE_JSON_HANDLER_H_INCLUDED

UpdatePTUDevCtrl/worker.h

@@ -493,6 +493,13 @@ signals:
     void showJsonDownload(QString);
     void showTariffUpdate(QString);
     void showISMASChecks(QString);
+    void showISMASConnectivity(QString);
+    void showCustRepoStatus(QString);
+    void showUpdateRequest(QString);
+    void showExecOpkgStatus(QString);
+    void showDownloadDCJsonFilesStatus(QString);
+    void showSyncCustRepoStatus(QString);
+    void showUpdateDCFirmware(QString);
     void showSummary(QString);
     void setDcDownloadProgress(int);