ATBUpdateTool/Check/ismas_client.cpp

#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, bool verbose) {

    if (verbose) {
        qInfo() << "REQUEST" << request;
    }

    int sockfd;
    int r;
    errno = 0;
    // socket create and verification
    if ((sockfd = ::socket(AF_INET, SOCK_STREAM, 0)) == -1) {
        if (verbose) {
            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) {
        if (verbose) {
            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);

    if (verbose) {
        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) + ")");
    // }

    if (verbose) {
        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
            if (verbose) {
                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
                if (verbose) {
                    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__