UpdatePTUDevCtrl/update.cpp

#include "update.h"

#include <QCoreApplication>
#include <QApplication>
#include <QFile>
#include <QTemporaryFile>
#include <QDebug>
#include <QTextStream>
#include <QRegularExpression>

//#include <iostream>
//#include <fstream>
//#include <ctime>

#include "plugins/interfaces.h"

#include <QSharedMemory>
#include <QScopedPointer>
#include <QDir>
#include <QThread>
#include <QDateTime>
#include <QPluginLoader>
#include <QMap>

#define UPDATE_OPKG                 (1)
#define UPDATE_DC                   (1)
#define UPDATE_PRINTER_TEMPLATES    (1)
#define UPDATE_CASH_TEMPLATE        (0)
#define UPDATE_CONF_TEMPLATE        (0)
#define UPDATE_DEVICE_TEMPLATE      (0)

static const QMap<QString, int> baudrateMap = {
  {"1200"   ,   0}, {"9600"   ,   1}, {"19200"  ,   2}, {"38400"  ,   3},
  {"57600"  ,   4}, {"115200" ,   5}
};

hwinf *Update::loadDCPlugin(QDir const &plugInDir, QString const &fname) {
    hwinf *hw = nullptr;
    if (plugInDir.exists()) {
        QString pluginLibName(fname);
        pluginLibName = plugInDir.absoluteFilePath(pluginLibName);
        QFileInfo info(pluginLibName);
        if (info.exists()) {
            pluginLibName = plugInDir.absoluteFilePath(pluginLibName);
            static QPluginLoader pluginLoader(pluginLibName);
            if (!pluginLoader.load()) {
                qCritical() << "in directory" << plugInDir.absolutePath();
                qCritical() << "cannot load plugin" << pluginLoader.fileName();
                qCritical() << pluginLoader.errorString();
                exit(-1);
            }
            if (!pluginLoader.isLoaded()) {
                qCritical() << pluginLoader.errorString();
                exit(-2);
            }
            QObject *plugin = pluginLoader.instance();
            if (!plugin) {
                qCritical() << "cannot start instance";
                exit(-3);
            }
            if (! (hw = qobject_cast<hwinf *>(plugin))) {
                qCritical() << "cannot cast plugin" << plugin << "to hwinf";
                exit(-4);
            }
        } else {
            qCritical() << pluginLibName << "does not exist";
            exit(-5);
        }
    } else {
        qCritical() << "plugins directory" << plugInDir.absolutePath()
                    << "does not exist";
        exit(-6);
    }
    return hw;
}

Update::Update(hwinf *hw,
               QString customerRepository,
               QString customerNrStr,
               QString branchName,
               QString workingDir,
               bool dryRun,
               QObject *parent,
               char const *serialInterface,
               char const *baudrate)
    : QObject(parent)
    , m_hw(hw)
    , m_serialInterface(serialInterface)
    , m_baudrate(baudrate)
    , m_customerRepository(customerRepository)
    , m_customerNrStr(customerNrStr)
    , m_branchName(branchName)
    , m_workingDir(workingDir)
    , m_dryRun(dryRun) {
}

Update::~Update() {
}

Update::DownloadResult Update::sendStatus(int ret) const {
    switch (ret) {                      // return values of dc are:
    case 0:                             // 0: no answer by now
        return DownloadResult::NOP;     // 1: error
    case 10:                            // 10: success
        return DownloadResult::OK;
    default:;
    }
    return DownloadResult::ERROR;
}

Update::DownloadResult Update::sendNextAddress(int bNum) const {
    // sends address only if blockNumber is one of 0, 1024, 2048, 3072, 4096
    int noAnswerCount = 0;
    int errorCount = 0;
    if ( bNum==0 || bNum==1024 || bNum==2048 || bNum==3072 || bNum==4096 ) {
        // qDebug() << "addr-block" << bNum << "...";
        while (noAnswerCount <= 250) {
            m_hw->bl_sendAddress(bNum);
            QThread::msleep(100);
            DownloadResult const res = sendStatus(m_hw->bl_wasSendingAddOK());
            if (res != DownloadResult::NOP) {
                if (res == DownloadResult::ERROR) {
                    if (++errorCount >= 10) {
                        qCritical() << "addr-block" << bNum << "...FAILED";
                        return res;
                    }
                } else { // res == DownloadResult::OK
                    // qInfo() << "addr-block" << bNum << "...OK";
                    return res;
                }
            } else {
                noAnswerCount += 1; // no answer by now
            }
        }
        // wait max. about 3 seconds
        return DownloadResult::TIMEOUT;
    }
    // blockNumber is not one of 0, 1024, 2048, 3072, 4096 -> do nothing
    return DownloadResult::NOP;
}

Update::DownloadResult Update::sendNextDataBlock(QByteArray const &binary,
                                                 int bNum) const {
    uint8_t local[66];
    int const bAddr = bNum * 64;
    int noAnswerCount = 0;
    int errorCount = 0;

    memcpy(local, binary.constData() + bAddr, 64);
    local[64] = local[65] = 0x00;

    // QByteArray b((const char *)(&local[0]), 64);
    // qCritical() << "SNDB" << bNum << b.size() << b.toHex();

    while (noAnswerCount <= 250) {
        m_hw->bl_sendDataBlock(64, local);
        QThread::msleep(10);
        DownloadResult const res = sendStatus(m_hw->bl_wasSendingDataOK());
        if (res != DownloadResult::NOP) {
            if (res == DownloadResult::ERROR) {
                if (++errorCount >= 10) {
                    qCritical() << "data for block" << bNum << "...FAILED";
                    return res;
                }
            } else {
                // qInfo() << "data for block" << bNum << "OK";
                return res;
            }
        } else {
            noAnswerCount += 1; // no answer by now
        }
    }
    // wait max. about 3 seconds
    return DownloadResult::TIMEOUT;
}

Update::DownloadResult Update::dc_downloadBinary(QByteArray const &b) const {
    int const nBlocks = (((b.size())%64)==0) ? (b.size()/64) : (b.size()/64)+1;

    // fill lst block of data to be sent with 0xFF
    QByteArray ba = b.leftJustified(nBlocks*64, (char)(0xFF));

    qInfo() << "total number of bytes to send to dc" << ba.size();
    qInfo() << "total number of blocks to send to dc" << nBlocks;

    int bNum = 0;
    DownloadResult res = DownloadResult::OK;
    fprintf(stderr, "\n64-byte block %04d ", bNum);
    while (res != DownloadResult::ERROR &&  bNum < nBlocks) {
        if ((res = sendNextAddress(bNum)) != DownloadResult::ERROR) {
            if ((res = sendNextDataBlock(ba, bNum)) != DownloadResult::ERROR) {
                bNum += 1;
                fprintf(stderr, ".");
                if ((bNum % 80) == 0) {
                    fprintf(stderr, "\n64-byte block %04d ", bNum);
                }
            }
        }
    }
    fprintf(stderr, "\nlast 64-byte block %04d\n", bNum);

    int const rest = ba.size() % 64;
    int const offset = ba.size() - rest;
    char const *startAddress = ba.constData() + offset;

    if (rest > 0) {
        // SHOULD NEVER HAPPEN !!!
        uint8_t local[66];
        memset(local, 0xFF, sizeof(local));
        memcpy(local, startAddress, rest);
        qCritical() << "ERROR SEND REMAINING" << rest << "BYTES";
        m_hw->bl_sendDataBlock(64, local);
    }

    m_hw->bl_sendLastBlock();
    qInfo() << "last result" << (int)sendStatus(m_hw->bl_wasSendingDataOK());
    return res;
}

bool Update::startBootloader() const {
    qDebug() << "starting bootloader...";
    int nTry = 5;
    while (--nTry >= 0) {
        m_hw->bl_startBL();
        QThread::msleep(5000);
        m_hw->bl_checkBL();
        if (m_hw->bl_isUp()) {
            qInfo() << "starting bootloader...OK";
            QThread::msleep(5000);
            return true;
        } else {
            qCritical() << "bootloader not up (" << nTry << ")";
        }
    }
    qCritical() << "starting bootloader...FAILED";
    return false;
}

bool Update::stopBootloader() const {
    qDebug() << "stopping bootloader...";
    int nTry = 5;
    while (--nTry >= 0) {
        m_hw->bl_stopBL();
        QThread::msleep(500);
        if (!m_hw->bl_isUp()) {
            qInfo() << "stopping bootloader...OK";
            return true;
        }
    }
    qCritical() << "stopping bootloader...FAILED";
    return false;
}

// br is a index into a table, used for historical reasons.
bool Update::openSerial(int br, QString baudrate, QString comPort) const {
    qDebug() << "opening serial" << br << baudrate << comPort << "...";
    if (m_hw->dc_openSerial(br, baudrate, comPort, 1)) { // 1 for connect
        qInfo() << "opening serial" << br << baudrate << comPort << "...OK";
        return true;
    }
    qCritical() << "opening serial" << br << baudrate << comPort << "...FAILED";
    return false;
}

void Update::closeSerial() const {
    qInfo() << "CLOSED SERIAL" << m_baudrate << m_serialInterface;
    m_hw->dc_closeSerial();
}

bool Update::isSerialOpen() const {
    return m_hw->dc_isPortOpen();
}

bool Update::resetDeviceController() const {
    qDebug() << "resetting device controller...";
    m_hw->bl_rebootDC();
    // wait maximally 3 seconds, before starting bootloader
    QThread::sleep(1);
    qInfo() << "resetting device controller...OK";
    return true;
}

QByteArray Update::loadBinaryDCFile(QString filename) const {
    qDebug() << "loading dc binary" << filename << "...";

    QFile file(filename); // closed in destructor call
    if (!file.exists()) {
        qCritical() << file.fileName() << "does not exist";
        return QByteArray();
    }
    if (!file.open(QIODevice::ReadOnly)) {
        qCritical() << "cannot open file" << file.fileName();
        return QByteArray();
    }
    qInfo() << "loading dc binary" << filename << "...OK";
    return file.readAll();
}

bool Update::downloadBinaryToDC(QString const &bFile) const {
    qDebug() << "sending" << bFile << "to dc...";
    QByteArray const dcBinary = loadBinaryDCFile(bFile);
    if (dcBinary.size() > 0) {
        if (dc_downloadBinary(dcBinary) != DownloadResult::OK) {
            qCritical() << "sending" << bFile << "to dc...FAILED";
            return false;
        } else {
            qInfo() << "sending" << bFile << "to dc...OK";
        }
    } else {
        qCritical() << "sending" << bFile << "to dc...FAILED";
        qCritical() << "loading binary" << bFile << "FAILED";
        return false;
    }
    return true;
}

/*
 Using the DC bootloader:
 1  :   bl_reboot()      // send to application, want DC2 to reset (in order to start
                        // the bootloader)
 2  :   bl_startBL():   // send within 4s after DC poewer-on, otherwise bl is left
 3  :   bl_check():     // send command to verify if bl is up
 4  :   bl_isUp():      // returns true if bl is up and running

 5  :   bl_sendAddress(blockNumber)
                        // send start address, nr of 64-byte block, start with 0
                        // will be sent only for following block-numbers:
                        // 0, 1024, 2048, 3072 and 4096, so basically every 64kByte
                        // for other addresses nothing happens

 6  :   bl_wasSendingAddOK()
                        // return val:  0: no response by now
                        //              1: error
                        //             10: OK

 7  :   bl_sendDataBlock()
                        // send 64 byte from bin file

 8  :   bl_sendLastBlock()
                        // send this command after all data are transferred

 9  :   bl_wasSendingDataOK()
                        // return val:  0: no response by now
                        //              1: error
                        //             10: OK

 10 :   bl_stopBL()     // leave bl and start (the new) application
 */
bool Update::updateBinary(char const *fileToSendToDC) {
    qInfo() << "updating device controller binary" << fileToSendToDC;
    QFile fn(fileToSendToDC);
    bool r;
    if ((r = fn.exists()) == true) {
        QString const linkTarget = fn.symLinkTarget();
        QFileInfo fi(linkTarget);
        qInfo() << "      updating binary (size=" << linkTarget << fi.size() << ")";
        if ((r = updateDC(linkTarget)) == true) {
            qInfo() << "     updating binary (size=" << linkTarget << fi.size() << ") done";
        } else {
            qCritical() << "updating binary (size=" << linkTarget << fi.size() << ")... FAILED";
        }
    } else {
        qCritical() << "symlink" << fileToSendToDC
                    << "does not exist -> NO UPDATE OF DC FIRMWARE";
    }
    return r;
}

bool Update::updateDC(QString bFile) const {
    qDebug() << "updating dc...";
    qDebug() << "updating dc: file to send" << bFile;
    if (!resetDeviceController()) {
        return false;
    }
    if (!startBootloader()) {
        // even when start seems to fail, stopping the boot loader does not harm
        stopBootloader();
        return false;
    }

    if (!downloadBinaryToDC(bFile)) {
        stopBootloader();
        qCritical() << "updating dc: " << bFile << "...FAILED";
        return false;
    }
    qInfo() << "updating dc: " << bFile << "...OK";

    stopBootloader();
    //resetDeviceController();

    QThread::sleep(3);
    return true;
}

QString Update::jsonType(enum FileTypeJson type) {
    switch (type) {
    case FileTypeJson::CASH: return "CASH";
    case FileTypeJson::CONFIG: return "CONFIG";
    case FileTypeJson::PRINTER: return "PRINTER";
    case FileTypeJson::SERIAL: return "SERIAL";
    case FileTypeJson::DEVICE: return "DEVICE";
    case FileTypeJson::TIME: return "TIME";
    }
    return "N/A";
}

bool Update::downloadJson(enum FileTypeJson type,
                          int templateIdx,
                          QString jsFileToSendToDC) const {

    qDebug() << "updating json-file:" << jsFileToSendToDC << "...";
    qDebug() << "    template-index:" << templateIdx;
    qDebug() << "         json-type:" << jsonType(type);

    m_hw->dc_autoRequest(true); // downloading Json needs the AutoEmission flag
    qDebug() << "SET AUTO-REQUEST=TRUE";
    QThread::sleep(1);  // make sure the auto-request flag is acknowledged

    bool ready = false;
    int nTry = 25;
    while ((ready = m_hw->sys_ready4sending()) == false) {
        QThread::msleep(200);
        if (--nTry <= 0) {
            qCritical() << "SYS NOT READY FOR SENDING AFTER 5 SECONDS";
            break;
        }
    }

    bool ret = false;
    if (ready) {
        QFile file(jsFileToSendToDC);
        QFileInfo fi(jsFileToSendToDC); // max. size of template file is 800 bytes
        if (file.exists()) {
            if (file.open(QIODevice::ReadOnly)) {
                if (fi.size() <= 800) {
                    QByteArray ba = file.readAll();
                    if (m_hw->sys_sendJsonFileToDc((uint8_t)(type),
                                                   templateIdx,
                                                   (uint8_t *)ba.data())) {
                        QThread::sleep(1);
                        qDebug() << "SENT" << jsFileToSendToDC;
                        ret = true;
                    }
                } else {
                    qCritical() << "SIZE OF" << jsFileToSendToDC
                                << "TOO BIG (" << fi.size() << "BYTES)";
                }
            } else {
                qCritical() << "CANNOT OPEN" << jsFileToSendToDC << "FOR READING";
            }
        } else {
            qCritical() << jsFileToSendToDC << "DOES NOT EXIST";
        }
    }

    m_hw->dc_autoRequest(false);
    qDebug() << "SET AUTO-REQUEST=FALSE";
    QThread::sleep(1);  // make sure the auto-request flag is acknowledged

    return ret;
}

bool Update::updatePrinterTemplate(int templateIdx, QString jsFile) const {
    return downloadJson(FileTypeJson::PRINTER, templateIdx, jsFile);
}

bool Update::updateConfig(QString jsFile) {
    return downloadJson(FileTypeJson::CONFIG, 0, jsFile);
}

bool Update::updateCashConf(QString jsFile) {
    return downloadJson(FileTypeJson::CASH, 0, jsFile);
}

bool Update::updateDeviceConf(QString jsFile) {
    return downloadJson(FileTypeJson::DEVICE, 0, jsFile);
}

QStringList Update::split(QString line, QChar sep) {
    QStringList lst;
    QString next;
    int start = 0, end;

    while ((end = line.indexOf(sep, start)) != -1) {
        next = line.mid(start, end - start).trimmed();
        lst << next;
        start = end + 1;
    }
    next = line.mid(start, end - start).trimmed();
    lst << next;

    return lst;
}

void Update::readyReadStandardOutput() {
    QProcess *p = (QProcess *)sender();
    QByteArray buf = p->readAllStandardOutput();
    qCritical() << buf;
}

void Update::readyReadStandardError() {
    QProcess *p = (QProcess *)sender();
    QByteArray buf = p->readAllStandardError();
    qCritical() << buf;
}

void Update::finished(int /*exitCode*/, QProcess::ExitStatus /*exitStatus*/) {
    QProcess *p = (QProcess *)sender();
    disconnect(p, SIGNAL(finished(int,QProcess::ExitStatus)), this, SLOT(readyReadStandardOutput()));
    disconnect(p, SIGNAL(finished(int,QProcess::ExitStatus)), this, SLOT(readyReadStandardError()));
}

bool Update::doUpdate(QStringList const &filesToWorkOn) {

    //
    // ACHTUNG !!!
    //
    return true;

    bool serialOpened = false;
    bool serialOpen = false;

    if (filesToWorkOn.size() == 0) {
        qCritical() << "NOTHING TO UPDATE";
        return true;
    }

    if (!serialOpen) {
        if (!isSerialOpen()) { // open serial only if not already open
            if ((serialOpened = openSerial(baudrateMap.value(m_baudrate), m_baudrate, m_serialInterface)) == false) {
                qCritical() << "CANNOT OPEN" << m_serialInterface << "(BAUDRATE="
                            << m_baudrate << ")";
                return false;
            }
        }
        serialOpen = true;
        qCritical() << "SERIAL OPEN" << m_serialInterface << "(BAUDRATE=" << m_baudrate << ")";
    }

    QList<QString>::const_iterator it;
    for (it = filesToWorkOn.cbegin(); it != filesToWorkOn.cend(); ++it) {
        bool res = false;
        QString fToWorkOn = (*it).trimmed();


        if (fToWorkOn.contains("dc2c", Qt::CaseInsensitive) &&
            fToWorkOn.endsWith(".bin", Qt::CaseInsensitive)) {

            qDebug() << "sending sw/hw-requests...";
            for (int i=0; i < 3; ++i) { // send explicit reuests to get
                                        // current SW/HW-versions
                m_hw->request_DC2_SWversion();
                m_hw->request_DC2_HWversion();
                QThread::sleep(1);
            }

            QString const hwVersion = m_hw->dc_getHWversion().toLower();
            QString const fwVersion = m_hw->dc_getSWversion().toLower();
            qInfo() << "current dc-hardware-version" << hwVersion;
            qInfo() << "current dc-firmware-version" << fwVersion;

            QFile fn(fToWorkOn);
            QFileInfo linkTarget(fn.symLinkTarget());
            if (!linkTarget.exists()) { // check for broken link
                res = false;
            } else {
                if (false) {
                //if (fwVersion.startsWith(linkTarget.completeBaseName())) {
                //    qCritical() << "current dc-firmware-version" << fwVersion
                //                << "already installed";
                //    res = false;
                } else {
                    res = true;

                    qCritical() << "downloading" << fToWorkOn.trimmed() << "->"
                                << linkTarget.completeBaseName() << "to DC";
#if UPDATE_DC == 1
                    m_hw->dc_autoRequest(false);// default: turn auto-request setting off
                    QThread::sleep(1);          // wait to be sure that there are no more
                                                // commands sent to dc-hardware
                    qDebug() << "SET AUTO-REQUEST=FALSE";

                    if ((res = updateBinary(fToWorkOn.toStdString().c_str())) == true) {
                        qCritical() << "downloaded binary" << fToWorkOn;
                    }

                    m_hw->dc_autoRequest(true); // turn auto-request setting on
                    qDebug() << "SET AUTO-REQUEST=TRUE";
                    qDebug() << "WAIT 10 SECS TO RECEIVE RESPONSES...";

                    QThread::sleep(10); // wait to be sure that responses
                                        // have been received
                    qCritical() << "updated dc-hardware-version" << m_hw->dc_getHWversion();
                    qCritical() << "updated dc-firmware-version" << m_hw->dc_getSWversion();
#endif
                }
            }
        } else if (fToWorkOn.contains("DC2C_print", Qt::CaseInsensitive)
                && fToWorkOn.endsWith(".json", Qt::CaseInsensitive)) {
            res = true;
#if UPDATE_PRINTER_TEMPLATES == 1
            int i = fToWorkOn.indexOf("DC2C_print", Qt::CaseInsensitive);
            int const templateIdx = fToWorkOn.mid(i).midRef(10, 2).toInt();
            if ((templateIdx < 1) || (templateIdx > 32)) {
                qCritical() << "WRONG TEMPLATE INDEX" << templateIdx;
                res = false;
            } else {
                if ((res = updatePrinterTemplate(templateIdx, fToWorkOn))) {
                    qInfo() << "downloaded printer template"<< fToWorkOn;
                }
            }
#endif
        } else if (fToWorkOn.contains("DC2C_cash", Qt::CaseInsensitive)
                && fToWorkOn.endsWith(".json", Qt::CaseInsensitive)) {
            res = true;
#if UPDATE_CASH_TEMPLATE == 1
            if ((res = updateCashConf(name))) {
                qInfo() << "downloaded cash template"<< name;
            }
#endif
        } else if (fToWorkOn.contains("DC2C_conf", Qt::CaseInsensitive)
                && fToWorkOn.endsWith(".json", Qt::CaseInsensitive)) {
            res = true;
#if UPDATE_CONF_TEMPLATE == 1
            if ((res= updateConfig(name))) {
                qInfo() << "downloaded config template"<< name;
            }
#endif
        } else if (fToWorkOn.contains("DC2C_device", Qt::CaseInsensitive)
                && fToWorkOn.endsWith(".json", Qt::CaseInsensitive)) {
            res = true;
#if UPDATE_DEVICE_TEMPLATE == 1
            if ((res = updateDeviceConf(name))) {
                qInfo() << "downloaded device template"<< name;
            }
#endif
        } else {
            qCritical() << "UNKNOWN JSON FILE NAME" << fToWorkOn;
            res = false;
        }
    } // for (it = openLines.cbegin(); it != openLines.end(); ++it) {

    m_hw->dc_autoRequest(true);  // ALWAYS turn autoRequest ON
    qDebug() << "SET AUTO-REQUEST=TRUE";

    return true;
}