Add qmodmaster and move udp app to applications

Applications/qModMaster/3rdparty/QsLog/QsLog.cpp

@@ -0,0 +1,193 @@
+// Copyright (c) 2013, Razvan Petru
+// All rights reserved.
+
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above copyright notice, this
+//   list of conditions and the following disclaimer in the documentation and/or other
+//   materials provided with the distribution.
+// * The name of the contributors may not be used to endorse or promote products
+//   derived from this software without specific prior written permission.
+
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+// IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+// OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include "QsLog.h"
+#include "QsLogDest.h"
+#ifdef QS_LOG_SEPARATE_THREAD
+#include <QThreadPool>
+#include <QRunnable>
+#else
+#include <QMutex>
+#endif
+#include <QVector>
+#include <QDateTime>
+#include <QtGlobal>
+#include <cassert>
+#include <cstdlib>
+#include <stdexcept>
+
+namespace QsLogging
+{
+typedef QVector<DestinationPtr> DestinationList;
+
+static const char TraceString[] = "TRACE";
+static const char DebugString[] = "DEBUG";
+static const char InfoString[]  = "INFO";
+static const char WarnString[]  = "WARN";
+static const char ErrorString[] = "ERROR";
+static const char FatalString[] = "FATAL";
+
+// not using Qt::ISODate because we need the milliseconds too
+static const QString fmtDateTime("yyyy-MM-ddThh:mm:ss.zzz");
+
+static const char* LevelToText(Level theLevel)
+{
+    switch (theLevel) {
+        case TraceLevel:
+            return TraceString;
+        case DebugLevel:
+            return DebugString;
+        case InfoLevel:
+            return InfoString;
+        case WarnLevel:
+            return WarnString;
+        case ErrorLevel:
+            return ErrorString;
+        case FatalLevel:
+            return FatalString;
+        case OffLevel:
+            return "";
+        default: {
+            assert(!"bad log level");
+            return InfoString;
+        }
+    }
+}
+
+#ifdef QS_LOG_SEPARATE_THREAD
+class LogWriterRunnable : public QRunnable
+{
+public:
+    LogWriterRunnable(const QString &message, Level level)
+        : mMessage(message)
+        , mLevel(level) {}
+
+    virtual void run()
+    {
+        Logger::instance().write(mMessage, mLevel);
+    }
+
+private:
+    QString mMessage;
+    Level mLevel;
+};
+#endif
+
+class LoggerImpl
+{
+public:
+    LoggerImpl() :
+        level(InfoLevel)
+    {
+        // assume at least file + console
+        destList.reserve(2);
+#ifdef QS_LOG_SEPARATE_THREAD
+        threadPool.setMaxThreadCount(1);
+        threadPool.setExpiryTimeout(-1);
+#endif
+    }
+#ifdef QS_LOG_SEPARATE_THREAD
+    QThreadPool threadPool;
+#else
+    QMutex logMutex;
+#endif
+    Level level;
+    DestinationList destList;
+};
+
+Logger::Logger() :
+    d(new LoggerImpl)
+{
+}
+
+Logger::~Logger()
+{
+    delete d;
+}
+
+void Logger::addDestination(DestinationPtr destination)
+{
+    assert(destination.data());
+    d->destList.push_back(destination);
+}
+
+void Logger::setLoggingLevel(Level newLevel)
+{
+    d->level = newLevel;
+}
+
+Level Logger::loggingLevel() const
+{
+    return d->level;
+}
+
+//! creates the complete log message and passes it to the logger
+void Logger::Helper::writeToLog()
+{
+    const char* const levelName = LevelToText(level);
+    const QString completeMessage(QString("%1 %2 %3")
+                                  .arg(levelName, 5)
+                                  .arg(QDateTime::currentDateTime().toString(fmtDateTime))
+                                  .arg(buffer)
+                                  );
+
+    Logger::instance().enqueueWrite(completeMessage, level);
+}
+
+Logger::Helper::~Helper()
+{
+    try {
+        writeToLog();
+    }
+    catch(std::exception&) {
+        // you shouldn't throw exceptions from a sink
+        assert(!"exception in logger helper destructor");
+        throw;
+    }
+}
+
+//! directs the message to the task queue or writes it directly
+void Logger::enqueueWrite(const QString& message, Level level)
+{
+#ifdef QS_LOG_SEPARATE_THREAD
+    LogWriterRunnable *r = new LogWriterRunnable(message, level);
+    d->threadPool.start(r);
+#else
+    QMutexLocker lock(&d->logMutex);
+    write(message, level);
+#endif
+}
+
+//! Sends the message to all the destinations. The level for this message is passed in case
+//! it's useful for processing in the destination.
+void Logger::write(const QString& message, Level level)
+{
+    for (DestinationList::iterator it = d->destList.begin(),
+        endIt = d->destList.end();it != endIt;++it) {
+        (*it)->write(message, level);
+    }
+}
+
+} // end namespace

Applications/qModMaster/3rdparty/QsLog/QsLog.h

@@ -0,0 +1,138 @@
+// Copyright (c) 2013, Razvan Petru
+// All rights reserved.
+
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above copyright notice, this
+//   list of conditions and the following disclaimer in the documentation and/or other
+//   materials provided with the distribution.
+// * The name of the contributors may not be used to endorse or promote products
+//   derived from this software without specific prior written permission.
+
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+// IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+// OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef QSLOG_H
+#define QSLOG_H
+
+#include "QsLogLevel.h"
+#include "QsLogDest.h"
+#include <QDebug>
+#include <QString>
+
+#define QS_LOG_VERSION "2.0b1"
+
+namespace QsLogging
+{
+class Destination;
+class LoggerImpl; // d pointer
+
+class Logger
+{
+public:
+    static Logger& instance()
+    {
+        static Logger staticLog;
+        return staticLog;
+    }
+
+    //! Adds a log message destination. Don't add null destinations.
+    void addDestination(DestinationPtr destination);
+    //! Logging at a level < 'newLevel' will be ignored
+    void setLoggingLevel(Level newLevel);
+    //! The default level is INFO
+    Level loggingLevel() const;
+
+    //! The helper forwards the streaming to QDebug and builds the final
+    //! log message.
+    class Helper
+    {
+    public:
+        explicit Helper(Level logLevel) :
+            level(logLevel),
+            qtDebug(&buffer) {}
+        ~Helper();
+        QDebug& stream(){ return qtDebug; }
+
+    private:
+        void writeToLog();
+
+        Level level;
+        QString buffer;
+        QDebug qtDebug;
+    };
+
+private:
+    Logger();
+    Logger(const Logger&);
+    Logger& operator=(const Logger&);
+    ~Logger();
+
+    void enqueueWrite(const QString& message, Level level);
+    void write(const QString& message, Level level);
+
+    LoggerImpl* d;
+
+    friend class LogWriterRunnable;
+};
+
+} // end namespace
+
+//! Logging macros: define QS_LOG_LINE_NUMBERS to get the file and line number
+//! in the log output.
+#ifndef QS_LOG_LINE_NUMBERS
+#define QLOG_TRACE() \
+    if (QsLogging::Logger::instance().loggingLevel() > QsLogging::TraceLevel) {} \
+    else QsLogging::Logger::Helper(QsLogging::TraceLevel).stream()
+#define QLOG_DEBUG() \
+    if (QsLogging::Logger::instance().loggingLevel() > QsLogging::DebugLevel) {} \
+    else QsLogging::Logger::Helper(QsLogging::DebugLevel).stream()
+#define QLOG_INFO()  \
+    if (QsLogging::Logger::instance().loggingLevel() > QsLogging::InfoLevel) {} \
+    else QsLogging::Logger::Helper(QsLogging::InfoLevel).stream()
+#define QLOG_WARN()  \
+    if (QsLogging::Logger::instance().loggingLevel() > QsLogging::WarnLevel) {} \
+    else QsLogging::Logger::Helper(QsLogging::WarnLevel).stream()
+#define QLOG_ERROR() \
+    if (QsLogging::Logger::instance().loggingLevel() > QsLogging::ErrorLevel) {} \
+    else QsLogging::Logger::Helper(QsLogging::ErrorLevel).stream()
+#define QLOG_FATAL() \
+    if (QsLogging::Logger::instance().loggingLevel() > QsLogging::FatalLevel) {} \
+    else QsLogging::Logger::Helper(QsLogging::FatalLevel).stream()
+#else
+#define QLOG_TRACE() \
+    if (QsLogging::Logger::instance().loggingLevel() > QsLogging::TraceLevel) {} \
+    else  QsLogging::Logger::Helper(QsLogging::TraceLevel).stream() << __FILE__ << '@' << __LINE__
+#define QLOG_DEBUG() \
+    if (QsLogging::Logger::instance().loggingLevel() > QsLogging::DebugLevel) {} \
+    else QsLogging::Logger::Helper(QsLogging::DebugLevel).stream() << __FILE__ << '@' << __LINE__
+#define QLOG_INFO()  \
+    if (QsLogging::Logger::instance().loggingLevel() > QsLogging::InfoLevel) {} \
+    else QsLogging::Logger::Helper(QsLogging::InfoLevel).stream() << __FILE__ << '@' << __LINE__
+#define QLOG_WARN()  \
+    if (QsLogging::Logger::instance().loggingLevel() > QsLogging::WarnLevel) {} \
+    else QsLogging::Logger::Helper(QsLogging::WarnLevel).stream() << __FILE__ << '@' << __LINE__
+#define QLOG_ERROR() \
+    if (QsLogging::Logger::instance().loggingLevel() > QsLogging::ErrorLevel) {} \
+    else QsLogging::Logger::Helper(QsLogging::ErrorLevel).stream() << __FILE__ << '@' << __LINE__
+#define QLOG_FATAL() \
+    if (QsLogging::Logger::instance().loggingLevel() > QsLogging::FatalLevel) {} \
+    else QsLogging::Logger::Helper(QsLogging::FatalLevel).stream() << __FILE__ << '@' << __LINE__
+#endif
+
+#ifdef QS_LOG_DISABLE
+#include "QsLogDisableForThisFile.h"
+#endif
+
+#endif // QSLOG_H

Applications/qModMaster/3rdparty/QsLog/QsLog.pri

@@ -0,0 +1,19 @@
+INCLUDEPATH += $$PWD
+#DEFINES += QS_LOG_LINE_NUMBERS    # automatically writes the file and line for each log message
+#DEFINES += QS_LOG_DISABLE         # logging code is replaced with a no-op
+#DEFINES += QS_LOG_SEPARATE_THREAD # messages are queued and written from a separate thread
+SOURCES += $$PWD/QsLogDest.cpp \
+    $$PWD/QsLog.cpp \
+    $$PWD/QsLogDestConsole.cpp \
+    $$PWD/QsLogDestFile.cpp
+
+HEADERS += $$PWD/QSLogDest.h \
+    $$PWD/QsLog.h \
+    $$PWD/QsLogDestConsole.h \
+    $$PWD/QsLogLevel.h \
+    $$PWD/QsLogDestFile.h \
+    $$PWD/QsLogDisableForThisFile.h
+
+OTHER_FILES += \
+    $$PWD/QsLogChanges.txt \
+    $$PWD/QsLogReadme.txt

Applications/qModMaster/3rdparty/QsLog/QsLogChanges.txt

@@ -0,0 +1,12 @@
+QsLog version 2.0b1
+
+Changes:
+* destination pointers use shared pointer semantics
+* the file destination supports log rotation. As a consequence, log files are encoded as UTF-8 and
+the log appends rather than truncating on every startup when rotation is enabled.
+* added the posibility of disabling logging either at run time or compile time.
+* added the possibility of using a separate thread for writing to the log destinations.
+
+Fixes:
+* renamed the main.cpp example to avoid QtCreator confusion
+* offer a way to check if the destination creation has failed (for e.g files)

Applications/qModMaster/3rdparty/QsLog/QsLogDest.cpp

@@ -0,0 +1,54 @@
+// Copyright (c) 2013, Razvan Petru
+// All rights reserved.
+
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above copyright notice, this
+//   list of conditions and the following disclaimer in the documentation and/or other
+//   materials provided with the distribution.
+// * The name of the contributors may not be used to endorse or promote products
+//   derived from this software without specific prior written permission.
+
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+// IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+// OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include "QsLogDest.h"
+#include "QsLogDestConsole.h"
+#include "QsLogDestFile.h"
+#include <QString>
+
+namespace QsLogging
+{
+
+//! destination factory
+DestinationPtr DestinationFactory::MakeFileDestination(const QString& filePath, bool enableRotation,
+                                                       qint64 sizeInBytesToRotateAfter, int oldLogsToKeep)
+{
+    if (enableRotation) {
+        QScopedPointer<SizeRotationStrategy> logRotation(new SizeRotationStrategy);
+        logRotation->setMaximumSizeInBytes(sizeInBytesToRotateAfter);
+        logRotation->setBackupCount(oldLogsToKeep);
+
+        return DestinationPtr(new FileDestination(filePath, RotationStrategyPtr(logRotation.take())));
+    }
+
+    return DestinationPtr(new FileDestination(filePath, RotationStrategyPtr(new NullRotationStrategy)));
+}
+
+DestinationPtr DestinationFactory::MakeDebugOutputDestination()
+{
+    return DestinationPtr(new DebugOutputDestination);
+}
+
+} // end namespace

Applications/qModMaster/3rdparty/QsLog/QsLogDest.h

@@ -0,0 +1,57 @@
+// Copyright (c) 2013, Razvan Petru
+// All rights reserved.
+
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above copyright notice, this
+//   list of conditions and the following disclaimer in the documentation and/or other
+//   materials provided with the distribution.
+// * The name of the contributors may not be used to endorse or promote products
+//   derived from this software without specific prior written permission.
+
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+// IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+// OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef QSLOGDEST_H
+#define QSLOGDEST_H
+
+#include "QsLogLevel.h"
+#include <QSharedPointer>
+#include <QtGlobal>
+class QString;
+
+namespace QsLogging
+{
+
+class Destination
+{
+public:
+    virtual ~Destination(){}
+    virtual void write(const QString& message, Level level) = 0;
+    virtual bool isValid() = 0; // returns whether the destination was created correctly
+};
+typedef QSharedPointer<Destination> DestinationPtr;
+
+//! Creates logging destinations/sinks. The caller will have ownership of 
+//! the newly created destinations.
+class DestinationFactory
+{
+public:
+    static DestinationPtr MakeFileDestination(const QString& filePath, bool enableRotation = false, qint64 sizeInBytesToRotateAfter = 0, int oldLogsToKeep = 0);
+    static DestinationPtr MakeDebugOutputDestination();
+};
+
+} // end namespace
+
+#endif // QSLOGDEST_H

Applications/qModMaster/3rdparty/QsLog/QsLogDestConsole.cpp

@@ -0,0 +1,75 @@
+// Copyright (c) 2013, Razvan Petru
+// All rights reserved.
+
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above copyright notice, this
+//   list of conditions and the following disclaimer in the documentation and/or other
+//   materials provided with the distribution.
+// * The name of the contributors may not be used to endorse or promote products
+//   derived from this software without specific prior written permission.
+
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+// IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+// OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include "QsLogDestConsole.h"
+#include <QString>
+#include <QtGlobal>
+
+#if defined(Q_OS_WIN)
+#define WIN32_LEAN_AND_MEAN
+#include <Windows.h>
+void QsDebugOutput::output( const QString& message )
+{
+   OutputDebugStringW(reinterpret_cast<const WCHAR*>(message.utf16()));
+   OutputDebugStringW(L"\n");
+}
+#elif defined(Q_OS_SYMBIAN)
+#include <e32debug.h>
+void QsDebugOutput::output( const QString& message )
+{
+    const int maxPrintSize = 256;
+    if (message.size() <= maxPrintSize) {
+        TPtrC16 symbianMessage(reinterpret_cast<const TUint16*>(message.utf16()));
+        RDebug::RawPrint(symbianMessage);
+    } else {
+        QString slicedMessage = message;
+        while (!slicedMessage.isEmpty()) {
+            const int sliceSize = qMin(maxPrintSize, slicedMessage.size());
+            const QString slice = slicedMessage.left(sliceSize);
+            slicedMessage.remove(0, sliceSize);
+
+            TPtrC16 symbianSlice(reinterpret_cast<const TUint16*>(slice.utf16()));
+            RDebug::RawPrint(symbianSlice);
+        }
+    }
+}
+#elif defined(Q_OS_UNIX)
+#include <cstdio>
+void QsDebugOutput::output( const QString& message )
+{
+   fprintf(stderr, "%s\n", qPrintable(message));
+   fflush(stderr);
+}
+#endif
+
+void QsLogging::DebugOutputDestination::write(const QString& message, Level)
+{
+    QsDebugOutput::output(message);
+}
+
+bool QsLogging::DebugOutputDestination::isValid()
+{
+    return true;
+}

Applications/qModMaster/3rdparty/QsLog/QsLogDestConsole.h

@@ -0,0 +1,52 @@
+// Copyright (c) 2013, Razvan Petru
+// All rights reserved.
+
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above copyright notice, this
+//   list of conditions and the following disclaimer in the documentation and/or other
+//   materials provided with the distribution.
+// * The name of the contributors may not be used to endorse or promote products
+//   derived from this software without specific prior written permission.
+
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+// IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+// OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef QSLOGDESTCONSOLE_H
+#define QSLOGDESTCONSOLE_H
+
+#include "QsLogDest.h"
+
+class QString;
+
+class QsDebugOutput
+{
+public:
+   static void output(const QString& a_message);
+};
+
+namespace QsLogging
+{
+
+// debugger sink
+class DebugOutputDestination : public Destination
+{
+public:
+    virtual void write(const QString& message, Level level);
+    virtual bool isValid();
+};
+
+}
+
+#endif // QSLOGDESTCONSOLE_H

Applications/qModMaster/3rdparty/QsLog/QsLogDestFile.cpp

@@ -0,0 +1,155 @@
+// Copyright (c) 2013, Razvan Petru
+// All rights reserved.
+
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above copyright notice, this
+//   list of conditions and the following disclaimer in the documentation and/or other
+//   materials provided with the distribution.
+// * The name of the contributors may not be used to endorse or promote products
+//   derived from this software without specific prior written permission.
+
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+// IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+// OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include "QsLogDestFile.h"
+#include <QtCore5Compat/QTextCodec>
+#include <QDateTime>
+#include <QtGlobal>
+#include <iostream>
+
+const int QsLogging::SizeRotationStrategy::MaxBackupCount = 10;
+
+QsLogging::RotationStrategy::~RotationStrategy()
+{
+}
+
+QsLogging::SizeRotationStrategy::SizeRotationStrategy()
+    : mCurrentSizeInBytes(0)
+    , mMaxSizeInBytes(0)
+    , mBackupsCount(0)
+{
+}
+
+void QsLogging::SizeRotationStrategy::setInitialInfo(const QFile &file)
+{
+    mFileName = file.fileName();
+    mCurrentSizeInBytes = file.size();
+}
+
+void QsLogging::SizeRotationStrategy::includeMessageInCalculation(const QString &message)
+{
+    mCurrentSizeInBytes += message.toUtf8().size();
+}
+
+bool QsLogging::SizeRotationStrategy::shouldRotate()
+{
+    return mCurrentSizeInBytes > mMaxSizeInBytes;
+}
+
+// Algorithm assumes backups will be named filename.X, where 1 <= X <= mBackupsCount.
+// All X's will be shifted up.
+void QsLogging::SizeRotationStrategy::rotate()
+{
+    if (!mBackupsCount) {
+        if (!QFile::remove(mFileName))
+            std::cerr << "QsLog: backup delete failed " << qPrintable(mFileName);
+        return;
+    }
+
+     // 1. find the last existing backup than can be shifted up
+     const QString logNamePattern = mFileName + QString::fromUtf8(".%1");
+     int lastExistingBackupIndex = 0;
+     for (int i = 1;i <= mBackupsCount;++i) {
+         const QString backupFileName = logNamePattern.arg(i);
+         if (QFile::exists(backupFileName))
+             lastExistingBackupIndex = qMin(i, mBackupsCount - 1);
+         else
+             break;
+     }
+
+     // 2. shift up
+     for (int i = lastExistingBackupIndex;i >= 1;--i) {
+         const QString oldName = logNamePattern.arg(i);
+         const QString newName = logNamePattern.arg(i + 1);
+         QFile::remove(newName);
+         const bool renamed = QFile::rename(oldName, newName);
+         if (!renamed) {
+             std::cerr << "QsLog: could not rename backup " << qPrintable(oldName)
+                       << " to " << qPrintable(newName);
+         }
+     }
+
+     // 3. rename current log file
+     const QString newName = logNamePattern.arg(1);
+     if (QFile::exists(newName))
+         QFile::remove(newName);
+     if (!QFile::rename(mFileName, newName)) {
+         std::cerr << "QsLog: could not rename log " << qPrintable(mFileName)
+                   << " to " << qPrintable(newName);
+     }
+}
+
+QIODevice::OpenMode QsLogging::SizeRotationStrategy::recommendedOpenModeFlag()
+{
+    return QIODevice::Append;
+}
+
+void QsLogging::SizeRotationStrategy::setMaximumSizeInBytes(qint64 size)
+{
+    Q_ASSERT(size >= 0);
+    mMaxSizeInBytes = size;
+}
+
+void QsLogging::SizeRotationStrategy::setBackupCount(int backups)
+{
+    Q_ASSERT(backups >= 0);
+    mBackupsCount = qMin(backups, SizeRotationStrategy::MaxBackupCount);
+}
+
+
+QsLogging::FileDestination::FileDestination(const QString& filePath, RotationStrategyPtr rotationStrategy)
+    : mRotationStrategy(rotationStrategy)
+{
+    mFile.setFileName(filePath);
+    if (!mFile.open(QFile::WriteOnly | QFile::Text | mRotationStrategy->recommendedOpenModeFlag()))
+        std::cerr << "QsLog: could not open log file " << qPrintable(filePath);
+    mOutputStream.setDevice(&mFile);
+    /*mOutputStream.setCodec(QTextCodec::codecForName("UTF-8"));*/
+
+    mRotationStrategy->setInitialInfo(mFile);
+}
+
+void QsLogging::FileDestination::write(const QString& message, Level)
+{
+    mRotationStrategy->includeMessageInCalculation(message);
+    if (mRotationStrategy->shouldRotate()) {
+        mOutputStream.setDevice(NULL);
+        mFile.close();
+        mRotationStrategy->rotate();
+        if (!mFile.open(QFile::WriteOnly | QFile::Text | mRotationStrategy->recommendedOpenModeFlag()))
+            std::cerr << "QsLog: could not reopen log file " << qPrintable(mFile.fileName());
+        mRotationStrategy->setInitialInfo(mFile);
+        mOutputStream.setDevice(&mFile);
+    }
+
+    mOutputStream << message << Qt::endl;
+    mOutputStream.flush();
+}
+
+bool QsLogging::FileDestination::isValid()
+{
+    return mFile.isOpen();
+}
+

Applications/qModMaster/3rdparty/QsLog/QsLogDestFile.h

@@ -0,0 +1,101 @@
+// Copyright (c) 2013, Razvan Petru
+// All rights reserved.
+
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above copyright notice, this
+//   list of conditions and the following disclaimer in the documentation and/or other
+//   materials provided with the distribution.
+// * The name of the contributors may not be used to endorse or promote products
+//   derived from this software without specific prior written permission.
+
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+// IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+// OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef QSLOGDESTFILE_H
+#define QSLOGDESTFILE_H
+
+#include "QsLogDest.h"
+#include <QFile>
+#include <QTextStream>
+#include <QtGlobal>
+#include <QSharedPointer>
+
+namespace QsLogging
+{
+class RotationStrategy
+{
+public:
+    virtual ~RotationStrategy();
+
+    virtual void setInitialInfo(const QFile &file) = 0;
+    virtual void includeMessageInCalculation(const QString &message) = 0;
+    virtual bool shouldRotate() = 0;
+    virtual void rotate() = 0;
+    virtual QIODevice::OpenMode recommendedOpenModeFlag() = 0;
+};
+
+// Never rotates file, overwrites existing file.
+class NullRotationStrategy : public RotationStrategy
+{
+public:
+    virtual void setInitialInfo(const QFile &) {}
+    virtual void includeMessageInCalculation(const QString &) {}
+    virtual bool shouldRotate() { return false; }
+    virtual void rotate() {}
+    virtual QIODevice::OpenMode recommendedOpenModeFlag() { return QIODevice::Truncate; }
+};
+
+// Rotates after a size is reached, keeps a number of <= 10 backups, appends to existing file.
+class SizeRotationStrategy : public RotationStrategy
+{
+public:
+    SizeRotationStrategy();
+    static const int MaxBackupCount;
+
+    virtual void setInitialInfo(const QFile &file);
+    virtual void includeMessageInCalculation(const QString &message);
+    virtual bool shouldRotate();
+    virtual void rotate();
+    virtual QIODevice::OpenMode recommendedOpenModeFlag();
+
+    void setMaximumSizeInBytes(qint64 size);
+    void setBackupCount(int backups);
+
+private:
+    QString mFileName;
+    qint64 mCurrentSizeInBytes;
+    qint64 mMaxSizeInBytes;
+    int mBackupsCount;
+};
+
+typedef QSharedPointer<RotationStrategy> RotationStrategyPtr;
+
+// file message sink
+class FileDestination : public Destination
+{
+public:
+    FileDestination(const QString& filePath, RotationStrategyPtr rotationStrategy);
+    virtual void write(const QString& message, Level level);
+    virtual bool isValid();
+
+private:
+    QFile mFile;
+    QTextStream mOutputStream;
+    QSharedPointer<RotationStrategy> mRotationStrategy;
+};
+
+}
+
+#endif // QSLOGDESTFILE_H

Applications/qModMaster/3rdparty/QsLog/QsLogDisableForThisFile.h

@@ -0,0 +1,22 @@
+#ifndef QSLOGDISABLEFORTHISFILE_H
+#define QSLOGDISABLEFORTHISFILE_H
+
+#include <QtDebug>
+// When included AFTER QsLog.h, this file will disable logging in that C++ file. When included
+// before, it will lead to compiler warnings or errors about macro redefinitions.
+
+#undef QLOG_TRACE
+#undef QLOG_DEBUG
+#undef QLOG_INFO
+#undef QLOG_WARN
+#undef QLOG_ERROR
+#undef QLOG_FATAL
+
+#define QLOG_TRACE() if (1) {} else qDebug()
+#define QLOG_DEBUG() if (1) {} else qDebug()
+#define QLOG_INFO()  if (1) {} else qDebug()
+#define QLOG_WARN()  if (1) {} else qDebug()
+#define QLOG_ERROR() if (1) {} else qDebug()
+#define QLOG_FATAL() if (1) {} else qDebug()
+
+#endif // QSLOGDISABLEFORTHISFILE_H

Applications/qModMaster/3rdparty/QsLog/QsLogLevel.h

@@ -0,0 +1,45 @@
+// Copyright (c) 2013, Razvan Petru
+// All rights reserved.
+
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above copyright notice, this
+//   list of conditions and the following disclaimer in the documentation and/or other
+//   materials provided with the distribution.
+// * The name of the contributors may not be used to endorse or promote products
+//   derived from this software without specific prior written permission.
+
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+// IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+// OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef QSLOGLEVEL_H
+#define QSLOGLEVEL_H
+
+namespace QsLogging
+{
+
+enum Level
+{
+    TraceLevel = 0,
+    DebugLevel,
+    InfoLevel,
+    WarnLevel,
+    ErrorLevel,
+    FatalLevel,
+    OffLevel
+};
+
+}
+
+#endif // QSLOGLEVEL_H

Applications/qModMaster/3rdparty/QsLog/QsLogReadme.txt

@@ -0,0 +1,34 @@
+QsLog - the simple Qt logger
+
+QsLog is an easy to use logger that is based on Qt's QDebug class.
+Features
+
+    Six logging levels (from trace to fatal)
+    Logging level threshold configurable at runtime.
+    Minimum overhead when logging is turned off.
+    Supports multiple destinations, comes with file and debug destinations.
+    Thread-safe
+    Supports logging of common Qt types out of the box.
+    Small dependency: just drop it in your project directly.
+
+Usage
+
+    Include QsLog.h. Include QsLogDest.h only where you create/add destinations.
+    Get the instance of the logger by calling QsLogging::Logger::instance();
+    Optionally set the logging level. Info is default.
+    Create as many destinations as you want by using the QsLogging::DestinationFactory.
+    Add the destinations to the logger instance by calling addDestination.
+
+Disabling logging
+
+Sometimes it's necessary to turn off logging. This can be done in several ways:
+
+    globally, at compile time, by enabling the QS_LOG_DISABLE macro in the supplied .pri file.
+    globally, at run time, by setting the log level to "OffLevel".
+    per file, at compile time, by including QsLogDisableForThisFile.h in the target file.
+
+Thread safety
+
+The Qt docs say: A thread-safe function can be called simultaneously from multiple threads, even when the invocations use shared data, because all references to the shared data are serialized. A reentrant function can also be called simultaneously from multiple threads, but only if each invocation uses its own data.
+
+Since sending the log message to the destinations is protected by a mutex, the logging macros are thread-safe provided that the log has been initialized - i.e: instance() has been called. The instance function and the setup functions (e.g: setLoggingLevel, addDestination) are NOT thread-safe and are NOT reentrant.

Applications/qModMaster/3rdparty/QsLog/examplemain.cpp

@@ -0,0 +1,40 @@
+#include "QsLog.h"
+#include "QsLogDest.h"
+#include <QtCore/QCoreApplication>
+#include <QtCore/QDir>
+#include <iostream>
+
+int main(int argc, char *argv[])
+{
+   QCoreApplication a(argc, argv);
+
+   // init the logging mechanism
+   QsLogging::Logger& logger = QsLogging::Logger::instance();
+   logger.setLoggingLevel(QsLogging::TraceLevel);
+   const QString sLogPath(QDir(a.applicationDirPath()).filePath("log.txt"));
+
+   QsLogging::DestinationPtr fileDestination(
+      QsLogging::DestinationFactory::MakeFileDestination(sLogPath, true, 512, 2) );
+   QsLogging::DestinationPtr debugDestination(
+      QsLogging::DestinationFactory::MakeDebugOutputDestination() );
+   logger.addDestination(debugDestination);
+   logger.addDestination(fileDestination);
+
+   QLOG_INFO() << "Program started";
+   QLOG_INFO() << "Built with Qt" << QT_VERSION_STR << "running on" << qVersion();
+
+   QLOG_TRACE() << "Here's a" << QString::fromUtf8("trace") << "message";
+   QLOG_DEBUG() << "Here's a" << static_cast<int>(QsLogging::DebugLevel) << "message";
+   QLOG_WARN()  << "Uh-oh!";
+   qDebug() << "This message won't be picked up by the logger";
+   QLOG_ERROR() << "An error has occurred";
+   qWarning() << "Neither will this one";
+   QLOG_FATAL() << "Fatal error!";
+
+   logger.setLoggingLevel(QsLogging::OffLevel);
+   for (int i = 0;i < 10000000;++i) {
+       QLOG_ERROR() << QString::fromUtf8("logging is turned off");
+   }
+
+   return 0;
+}

Applications/qModMaster/3rdparty/QsLog/log_example.pro

@@ -0,0 +1,11 @@
+# -------------------------------------------------
+# Project created by QtCreator 2010-03-20T12:17:43
+# -------------------------------------------------
+QT -= gui
+TARGET = log_example
+CONFIG += console
+CONFIG -= app_bundle
+TEMPLATE = app
+SOURCES += \
+    examplemain.cpp
+include(QsLog.pri)

Applications/qModMaster/3rdparty/libmodbus/config.h

@@ -0,0 +1,171 @@
+/* config.h.  Generated from config.h.in by configure.  */
+/* config.h.in.  Generated from configure.ac by autoheader.  */
+
+/* Define to 1 if you have the <arpa/inet.h> header file. */
+#define HAVE_ARPA_INET_H 1
+
+/* Define to 1 if you have the declaration of `TIOCSRS485', and to 0 if you
+   don't. */
+#define HAVE_DECL_TIOCSRS485 0
+
+/* Define to 1 if you have the declaration of `TIOCM_RTS', and to 0 if you
+   don't. */
+#define HAVE_DECL_TIOCM_RTS 0
+
+/* Define to 1 if you have the declaration of `__CYGWIN__', and to 0 if you
+   don't. */
+#define HAVE_DECL___CYGWIN__ 0
+
+/* Define to 1 if you have the <dlfcn.h> header file. */
+#define HAVE_DLFCN_H 1
+
+/* Define to 1 if you have the <errno.h> header file. */
+#define HAVE_ERRNO_H 1
+
+/* Define to 1 if you have the <fcntl.h> header file. */
+#define HAVE_FCNTL_H 1
+
+/* Define to 1 if you have the `fork' function. */
+#define HAVE_FORK 1
+
+/* Define to 1 if you have the `getaddrinfo' function. */
+#define HAVE_GETADDRINFO 1
+
+/* Define to 1 if you have the `gettimeofday' function. */
+#define HAVE_GETTIMEOFDAY 1
+
+/* Define to 1 if you have the `inet_ntoa' function. */
+#define HAVE_INET_NTOA 1
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#define HAVE_INTTYPES_H 1
+
+/* Define to 1 if you have the <limits.h> header file. */
+#define HAVE_LIMITS_H 1
+
+/* Define to 1 if you have the <linux/serial.h> header file. */
+#define HAVE_LINUX_SERIAL_H 1
+
+/* Define to 1 if you have the <memory.h> header file. */
+#define HAVE_MEMORY_H 1
+
+/* Define to 1 if you have the `memset' function. */
+#define HAVE_MEMSET 1
+
+/* Define to 1 if you have the <netdb.h> header file. */
+#define HAVE_NETDB_H 1
+
+/* Define to 1 if you have the <netinet/in.h> header file. */
+#define HAVE_NETINET_IN_H 1
+
+/* Define to 1 if you have the <netinet/tcp.h> header file. */
+#define HAVE_NETINET_TCP_H 1
+
+/* Define to 1 if you have the `select' function. */
+#define HAVE_SELECT 1
+
+/* Define to 1 if you have the `socket' function. */
+#define HAVE_SOCKET 1
+
+/* Define to 1 if you have the <stdint.h> header file. */
+#define HAVE_STDINT_H 1
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#define HAVE_STDLIB_H 1
+
+/* Define to 1 if you have the `strerror' function. */
+#define HAVE_STRERROR 1
+
+/* Define to 1 if you have the <strings.h> header file. */
+#define HAVE_STRINGS_H 1
+
+/* Define to 1 if you have the <string.h> header file. */
+#define HAVE_STRING_H 1
+
+/* Define to 1 if you have the `strlcpy' function. */
+/* #undef HAVE_STRLCPY */
+
+/* Define to 1 if you have the <sys/ioctl.h> header file. */
+#define HAVE_SYS_IOCTL_H 1
+
+/* Define to 1 if you have the <sys/socket.h> header file. */
+#define HAVE_SYS_SOCKET_H 1
+
+/* Define to 1 if you have the <sys/stat.h> header file. */
+#define HAVE_SYS_STAT_H 1
+
+/* Define to 1 if you have the <sys/time.h> header file. */
+#define HAVE_SYS_TIME_H 1
+
+/* Define to 1 if you have the <sys/types.h> header file. */
+#define HAVE_SYS_TYPES_H 1
+
+/* Define to 1 if you have the <termios.h> header file. */
+#define HAVE_TERMIOS_H 1
+
+/* Define to 1 if you have the <time.h> header file. */
+#define HAVE_TIME_H 1
+
+/* Define to 1 if you have the <unistd.h> header file. */
+#define HAVE_UNISTD_H 1
+
+/* Define to 1 if you have the `vfork' function. */
+#define HAVE_VFORK 1
+
+/* Define to 1 if you have the <vfork.h> header file. */
+/* #undef HAVE_VFORK_H */
+
+/* Define to 1 if you have the <winsock2.h> header file. */
+/* #undef HAVE_WINSOCK2_H */
+
+/* Define to 1 if `fork' works. */
+#define HAVE_WORKING_FORK 1
+
+/* Define to 1 if `vfork' works. */
+#define HAVE_WORKING_VFORK 1
+
+/* Define to the sub-directory in which libtool stores uninstalled libraries.
+   */
+#define LT_OBJDIR ".libs/"
+
+/* Name of package */
+#define PACKAGE "libmodbus"
+
+/* Define to the address where bug reports for this package should be sent. */
+#define PACKAGE_BUGREPORT "https://github.com/stephane/libmodbus/issues"
+
+/* Define to the full name of this package. */
+#define PACKAGE_NAME "libmodbus"
+
+/* Define to the full name and version of this package. */
+#define PACKAGE_STRING "libmodbus 3.1.0-1"
+
+/* Define to the one symbol short name of this package. */
+#define PACKAGE_TARNAME "libmodbus"
+
+/* Define to the home page for this package. */
+#define PACKAGE_URL ""
+
+/* Define to the version of this package. */
+#define PACKAGE_VERSION "3.1.0-1"
+
+/* Define to 1 if you have the ANSI C header files. */
+#define STDC_HEADERS 1
+
+/* Define to 1 if you can safely include both <sys/time.h> and <time.h>. */
+#define TIME_WITH_SYS_TIME 1
+
+/* Version number of package */
+#define VERSION "3.1.0-1"
+
+/* Define to empty if `const' does not conform to ANSI C. */
+/* #undef const */
+
+/* Define to `int' if <sys/types.h> does not define. */
+/* #undef pid_t */
+
+/* Define to `unsigned int' if <sys/types.h> does not define. */
+/* #undef size_t */
+
+/* Define as `fork' if `vfork' does not work. */
+/* #undef vfork */

Applications/qModMaster/3rdparty/libmodbus/modbus-data.c

@@ -0,0 +1,229 @@
+/*
+ * Copyright © 2010-2014 Stéphane Raimbault <stephane.raimbault@gmail.com>
+ *
+ * SPDX-License-Identifier: LGPL-2.1+
+ */
+
+#include <stdlib.h>
+
+#ifndef _MSC_VER
+#  include <stdint.h>
+#else
+#  include "stdint.h"
+#endif
+
+#include <string.h>
+#include <assert.h>
+
+#if defined(_WIN32)
+#  include <winsock2.h>
+#else
+#  include <arpa/inet.h>
+#endif
+
+#include <config.h>
+
+#include "modbus.h"
+
+#if defined(HAVE_BYTESWAP_H)
+#  include <byteswap.h>
+#endif
+
+#if defined(__APPLE__)
+#  include <libkern/OSByteOrder.h>
+#  define bswap_16 OSSwapInt16
+#  define bswap_32 OSSwapInt32
+#  define bswap_64 OSSwapInt64
+#endif
+
+#if defined(__GNUC__)
+#  define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__ * 10)
+#  if GCC_VERSION >= 430
+// Since GCC >= 4.30, GCC provides __builtin_bswapXX() alternatives so we switch to them
+#    undef bswap_32
+#    define bswap_32 __builtin_bswap32
+#  endif
+#endif
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1400)
+#  define bswap_32 _byteswap_ulong
+#  define bswap_16 _byteswap_ushort
+#endif
+
+#if !defined(__CYGWIN__) && !defined(bswap_16)
+#  warning "Fallback on C functions for bswap_16"
+static inline uint16_t bswap_16(uint16_t x)
+{
+    return (x >> 8) | (x << 8);
+}
+#endif
+
+#if !defined(bswap_32)
+#  warning "Fallback on C functions for bswap_32"
+static inline uint32_t bswap_32(uint32_t x)
+{
+    return (bswap_16(x & 0xffff) << 16) | (bswap_16(x >> 16));
+}
+#endif
+
+/* Sets many bits from a single byte value (all 8 bits of the byte value are
+   set) */
+void modbus_set_bits_from_byte(uint8_t *dest, int idx, const uint8_t value)
+{
+    int i;
+
+    for (i=0; i < 8; i++) {
+        dest[idx+i] = (value & (1 << i)) ? 1 : 0;
+    }
+}
+
+/* Sets many bits from a table of bytes (only the bits between idx and
+   idx + nb_bits are set) */
+void modbus_set_bits_from_bytes(uint8_t *dest, int idx, unsigned int nb_bits,
+                                const uint8_t *tab_byte)
+{
+    unsigned int i;
+    int shift = 0;
+
+    for (i = idx; i < idx + nb_bits; i++) {
+        dest[i] = tab_byte[(i - idx) / 8] & (1 << shift) ? 1 : 0;
+        /* gcc doesn't like: shift = (++shift) % 8; */
+        shift++;
+        shift %= 8;
+    }
+}
+
+/* Gets the byte value from many bits.
+   To obtain a full byte, set nb_bits to 8. */
+uint8_t modbus_get_byte_from_bits(const uint8_t *src, int idx,
+                                  unsigned int nb_bits)
+{
+    unsigned int i;
+    uint8_t value = 0;
+
+    if (nb_bits > 8) {
+        /* Assert is ignored if NDEBUG is set */
+        assert(nb_bits < 8);
+        nb_bits = 8;
+    }
+
+    for (i=0; i < nb_bits; i++) {
+        value |= (src[idx+i] << i);
+    }
+
+    return value;
+}
+
+/* Get a float from 4 bytes (Modbus) without any conversion (ABCD) */
+float modbus_get_float_abcd(const uint16_t *src)
+{
+    float f;
+    uint32_t i;
+
+    i = ntohl(((uint32_t)src[0] << 16) + src[1]);
+    memcpy(&f, &i, sizeof(float));
+
+    return f;
+}
+
+/* Get a float from 4 bytes (Modbus) in inversed format (DCBA) */
+float modbus_get_float_dcba(const uint16_t *src)
+{
+    float f;
+    uint32_t i;
+
+    i = ntohl(bswap_32((((uint32_t)src[0]) << 16) + src[1]));
+    memcpy(&f, &i, sizeof(float));
+
+    return f;
+}
+
+/* Get a float from 4 bytes (Modbus) with swapped bytes (BADC) */
+float modbus_get_float_badc(const uint16_t *src)
+{
+    float f;
+    uint32_t i;
+
+    i = ntohl((uint32_t)(bswap_16(src[0]) << 16) + bswap_16(src[1]));
+    memcpy(&f, &i, sizeof(float));
+
+    return f;
+}
+
+/* Get a float from 4 bytes (Modbus) with swapped words (CDAB) */
+float modbus_get_float_cdab(const uint16_t *src)
+{
+    float f;
+    uint32_t i;
+
+    i = ntohl((((uint32_t)src[1]) << 16) + src[0]);
+    memcpy(&f, &i, sizeof(float));
+
+    return f;
+}
+
+/* DEPRECATED - Get a float from 4 bytes in sort of Modbus format */
+float modbus_get_float(const uint16_t *src)
+{
+    float f;
+    uint32_t i;
+
+    i = (((uint32_t)src[1]) << 16) + src[0];
+    memcpy(&f, &i, sizeof(float));
+
+    return f;
+}
+
+/* Set a float to 4 bytes for Modbus w/o any conversion (ABCD) */
+void modbus_set_float_abcd(float f, uint16_t *dest)
+{
+    uint32_t i;
+
+    memcpy(&i, &f, sizeof(uint32_t));
+    i = htonl(i);
+    dest[0] = (uint16_t)(i >> 16);
+    dest[1] = (uint16_t)i;
+}
+
+/* Set a float to 4 bytes for Modbus with byte and word swap conversion (DCBA) */
+void modbus_set_float_dcba(float f, uint16_t *dest)
+{
+    uint32_t i;
+
+    memcpy(&i, &f, sizeof(uint32_t));
+    i = bswap_32(htonl(i));
+    dest[0] = (uint16_t)(i >> 16);
+    dest[1] = (uint16_t)i;
+}
+
+/* Set a float to 4 bytes for Modbus with byte swap conversion (BADC) */
+void modbus_set_float_badc(float f, uint16_t *dest)
+{
+    uint32_t i;
+
+    memcpy(&i, &f, sizeof(uint32_t));
+    i = htonl(i);
+    dest[0] = (uint16_t)bswap_16(i >> 16);
+    dest[1] = (uint16_t)bswap_16(i & 0xFFFF);
+}
+
+/* Set a float to 4 bytes for Modbus with word swap conversion (CDAB) */
+void modbus_set_float_cdab(float f, uint16_t *dest)
+{
+    uint32_t i;
+
+    memcpy(&i, &f, sizeof(uint32_t));
+    i = htonl(i);
+    dest[0] = (uint16_t)i;
+    dest[1] = (uint16_t)(i >> 16);
+}
+
+/* DEPRECATED - Set a float to 4 bytes in a sort of Modbus format! */
+void modbus_set_float(float f, uint16_t *dest)
+{
+    uint32_t i;
+
+    memcpy(&i, &f, sizeof(uint32_t));
+    dest[0] = (uint16_t)i;
+    dest[1] = (uint16_t)(i >> 16);
+}

Applications/qModMaster/3rdparty/libmodbus/modbus-private.h

@@ -0,0 +1,115 @@
+/*
+ * Copyright © 2010-2012 Stéphane Raimbault <stephane.raimbault@gmail.com>
+ *
+ * SPDX-License-Identifier: LGPL-2.1+
+ */
+
+#ifndef MODBUS_PRIVATE_H
+#define MODBUS_PRIVATE_H
+
+#ifndef _MSC_VER
+# include <stdint.h>
+# include <sys/time.h>
+#else
+# include "stdint.h"
+# include <time.h>
+typedef int ssize_t;
+#endif
+#include <sys/types.h>
+#include <config.h>
+
+#include "modbus.h"
+
+MODBUS_BEGIN_DECLS
+
+/* It's not really the minimal length (the real one is report slave ID
+ * in RTU (4 bytes)) but it's a convenient size to use in RTU or TCP
+ * communications to read many values or write a single one.
+ * Maximum between :
+ * - HEADER_LENGTH_TCP (7) + function (1) + address (2) + number (2)
+ * - HEADER_LENGTH_RTU (1) + function (1) + address (2) + number (2) + CRC (2)
+ */
+#define _MIN_REQ_LENGTH 12
+
+#define _REPORT_SLAVE_ID 180
+
+#define _MODBUS_EXCEPTION_RSP_LENGTH 5
+
+/* Timeouts in microsecond (0.5 s) */
+#define _RESPONSE_TIMEOUT    500000
+#define _BYTE_TIMEOUT        500000
+
+typedef enum {
+    _MODBUS_BACKEND_TYPE_RTU=0,
+    _MODBUS_BACKEND_TYPE_TCP
+} modbus_backend_type_t;
+
+/*
+ *  ---------- Request     Indication ----------
+ *  | Client | ---------------------->| Server |
+ *  ---------- Confirmation  Response ----------
+ */
+typedef enum {
+    /* Request message on the server side */
+    MSG_INDICATION,
+    /* Request message on the client side */
+    MSG_CONFIRMATION
+} msg_type_t;
+
+/* This structure reduces the number of params in functions and so
+ * optimizes the speed of execution (~ 37%). */
+typedef struct _sft {
+    int slave;
+    int function;
+    int t_id;
+} sft_t;
+
+typedef struct _modbus_backend {
+    unsigned int backend_type;
+    unsigned int header_length;
+    unsigned int checksum_length;
+    unsigned int max_adu_length;
+    int (*set_slave) (modbus_t *ctx, int slave);
+    int (*build_request_basis) (modbus_t *ctx, int function, int addr,
+                                int nb, uint8_t *req);
+    int (*build_response_basis) (sft_t *sft, uint8_t *rsp);
+    int (*prepare_response_tid) (const uint8_t *req, int *req_length);
+    int (*send_msg_pre) (uint8_t *req, int req_length);
+    ssize_t (*send) (modbus_t *ctx, const uint8_t *req, int req_length);
+    int (*receive) (modbus_t *ctx, uint8_t *req);
+    ssize_t (*recv) (modbus_t *ctx, uint8_t *rsp, int rsp_length);
+    int (*check_integrity) (modbus_t *ctx, uint8_t *msg,
+                            const int msg_length);
+    int (*pre_check_confirmation) (modbus_t *ctx, const uint8_t *req,
+                                   const uint8_t *rsp, int rsp_length);
+    int (*connect) (modbus_t *ctx);
+    void (*close) (modbus_t *ctx);
+    int (*flush) (modbus_t *ctx);
+    int (*select) (modbus_t *ctx, fd_set *rset, struct timeval *tv, int msg_length);
+    void (*free) (modbus_t *ctx);
+} modbus_backend_t;
+
+struct _modbus {
+    /* Slave address */
+    int slave;
+    /* Socket or file descriptor */
+    int s;
+    int debug;
+    int error_recovery;
+    struct timeval response_timeout;
+    struct timeval byte_timeout;
+    const modbus_backend_t *backend;
+    void *backend_data;
+};
+
+void _modbus_init_common(modbus_t *ctx);
+void _error_print(modbus_t *ctx, const char *context);
+int _modbus_receive_msg(modbus_t *ctx, uint8_t *msg, msg_type_t msg_type);
+
+#ifndef HAVE_STRLCPY
+size_t strlcpy(char *dest, const char *src, size_t dest_size);
+#endif
+
+MODBUS_END_DECLS
+
+#endif  /* MODBUS_PRIVATE_H */

Applications/qModMaster/3rdparty/libmodbus/modbus-rtu-private.h

@@ -0,0 +1,77 @@
+/*
+ * Copyright © 2001-2011 Stéphane Raimbault <stephane.raimbault@gmail.com>
+ *
+ * SPDX-License-Identifier: LGPL-2.1+
+ */
+
+#ifndef MODBUS_RTU_PRIVATE_H
+#define MODBUS_RTU_PRIVATE_H
+
+#ifndef _MSC_VER
+#include <stdint.h>
+#else
+#include "stdint.h"
+#endif
+
+#if defined(_WIN32)
+#include <windows.h>
+#else
+#include <termios.h>
+#endif
+
+#define _MODBUS_RTU_HEADER_LENGTH      1
+#define _MODBUS_RTU_PRESET_REQ_LENGTH  6
+#define _MODBUS_RTU_PRESET_RSP_LENGTH  2
+
+#define _MODBUS_RTU_CHECKSUM_LENGTH    2
+
+#if defined(_WIN32)
+#if !defined(ENOTSUP)
+#define ENOTSUP WSAEOPNOTSUPP
+#endif
+
+/* WIN32: struct containing serial handle and a receive buffer */
+#define PY_BUF_SIZE 512
+struct win32_ser {
+    /* File handle */
+    HANDLE fd;
+    /* Receive buffer */
+    uint8_t buf[PY_BUF_SIZE];
+    /* Received chars */
+    DWORD n_bytes;
+};
+#endif /* _WIN32 */
+
+typedef struct _modbus_rtu {
+    /* Device: "/dev/ttyS0", "/dev/ttyUSB0" or "/dev/tty.USA19*" on Mac OS X. */
+    char *device;
+    /* Bauds: 9600, 19200, 57600, 115200, etc */
+    int baud;
+    /* Data bit */
+    uint8_t data_bit;
+    /* Stop bit */
+    uint8_t stop_bit;
+    /* Parity: 'N', 'O', 'E' */
+    char parity;
+#if defined(_WIN32)
+    struct win32_ser w_ser;
+    DCB old_dcb;
+#else
+    /* Save old termios settings */
+    struct termios old_tios;
+#endif
+#if HAVE_DECL_TIOCSRS485
+    int serial_mode;
+#endif
+//***Not part of libmodbus - added for QModMaster***//
+#if defined(_WIN32) || HAVE_DECL_TIOCM_RTS
+    int rts;
+    int rts_delay;
+    int onebyte_time;
+    void (*set_rts) (modbus_t *ctx, int on);
+#endif
+    /* To handle many slaves on the same link */
+    int confirmation_to_ignore;
+} modbus_rtu_t;
+
+#endif /* MODBUS_RTU_PRIVATE_H */

Applications/qModMaster/3rdparty/libmodbus/modbus-rtu.h

@@ -0,0 +1,43 @@
+/*
+ * Copyright © 2001-2011 Stéphane Raimbault <stephane.raimbault@gmail.com>
+ *
+ * SPDX-License-Identifier: LGPL-2.1+
+ */
+
+#ifndef MODBUS_RTU_H
+#define MODBUS_RTU_H
+
+#include "modbus.h"
+
+MODBUS_BEGIN_DECLS
+
+/* Modbus_Application_Protocol_V1_1b.pdf Chapter 4 Section 1 Page 5
+ * RS232 / RS485 ADU = 253 bytes + slave (1 byte) + CRC (2 bytes) = 256 bytes
+ */
+#define MODBUS_RTU_MAX_ADU_LENGTH  256
+
+//***Not part of libmodbus - rts param added for QModMaster***//
+MODBUS_API modbus_t* modbus_new_rtu(const char *device, int baud, char parity,
+                                    int data_bit, int stop_bit, int rts);
+
+#define MODBUS_RTU_RS232 0
+#define MODBUS_RTU_RS485 1
+
+MODBUS_API int modbus_rtu_set_serial_mode(modbus_t *ctx, int mode);
+MODBUS_API int modbus_rtu_get_serial_mode(modbus_t *ctx);
+
+#define MODBUS_RTU_RTS_NONE   0
+#define MODBUS_RTU_RTS_UP     1
+#define MODBUS_RTU_RTS_DOWN   2
+
+MODBUS_API int modbus_rtu_set_rts(modbus_t *ctx, int mode);
+MODBUS_API int modbus_rtu_get_rts(modbus_t *ctx);
+
+MODBUS_API int modbus_rtu_set_custom_rts(modbus_t *ctx, void (*set_rts) (modbus_t *ctx, int on));
+
+MODBUS_API int modbus_rtu_set_rts_delay(modbus_t *ctx, int us);
+MODBUS_API int modbus_rtu_get_rts_delay(modbus_t *ctx);
+
+MODBUS_END_DECLS
+
+#endif /* MODBUS_RTU_H */

Applications/qModMaster/3rdparty/libmodbus/modbus-tcp-private.h

@@ -0,0 +1,44 @@
+/*
+ * Copyright © 2001-2011 Stéphane Raimbault <stephane.raimbault@gmail.com>
+ *
+ * SPDX-License-Identifier: LGPL-2.1+
+ */
+
+#ifndef MODBUS_TCP_PRIVATE_H
+#define MODBUS_TCP_PRIVATE_H
+
+#define _MODBUS_TCP_HEADER_LENGTH      7
+#define _MODBUS_TCP_PRESET_REQ_LENGTH 12
+#define _MODBUS_TCP_PRESET_RSP_LENGTH  8
+
+#define _MODBUS_TCP_CHECKSUM_LENGTH    0
+
+/* In both structures, the transaction ID must be placed on first position
+   to have a quick access not dependant of the TCP backend */
+typedef struct _modbus_tcp {
+    /* Extract from MODBUS Messaging on TCP/IP Implementation Guide V1.0b
+       (page 23/46):
+       The transaction identifier is used to associate the future response
+       with the request. This identifier is unique on each TCP connection. */
+    uint16_t t_id;
+    /* TCP port */
+    int port;
+    /* IP address */
+    char ip[16];
+} modbus_tcp_t;
+
+#define _MODBUS_TCP_PI_NODE_LENGTH    1025
+#define _MODBUS_TCP_PI_SERVICE_LENGTH   32
+
+typedef struct _modbus_tcp_pi {
+    /* Transaction ID */
+    uint16_t t_id;
+    /* TCP port */
+    int port;
+    /* Node */
+    char node[_MODBUS_TCP_PI_NODE_LENGTH];
+    /* Service */
+    char service[_MODBUS_TCP_PI_SERVICE_LENGTH];
+} modbus_tcp_pi_t;
+
+#endif /* MODBUS_TCP_PRIVATE_H */

Applications/qModMaster/3rdparty/libmodbus/modbus-tcp.c

@@ -0,0 +1,902 @@
+/*
+ * Copyright © 2001-2013 Stéphane Raimbault <stephane.raimbault@gmail.com>
+ *
+ * SPDX-License-Identifier: LGPL-2.1+
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#ifndef _MSC_VER
+#include <unistd.h>
+#endif
+#include <signal.h>
+#include <sys/types.h>
+
+#if defined(_WIN32)
+# define OS_WIN32
+/* ws2_32.dll has getaddrinfo and freeaddrinfo on Windows XP and later.
+ * minwg32 headers check WINVER before allowing the use of these */
+# ifndef WINVER
+# define WINVER 0x0501
+# endif
+/* Already set in modbus-tcp.h but it seems order matters in VS2005 */
+# include <winsock2.h>
+# include <ws2tcpip.h>
+# define SHUT_RDWR 2
+# define close closesocket
+#else
+# include <sys/socket.h>
+# include <sys/ioctl.h>
+
+#if defined(__OpenBSD__) || (defined(__FreeBSD__) && __FreeBSD__ < 5)
+# define OS_BSD
+# include <netinet/in_systm.h>
+#endif
+
+# include <netinet/in.h>
+# include <netinet/ip.h>
+# include <netinet/tcp.h>
+# include <arpa/inet.h>
+# include <netdb.h>
+#endif
+
+#if !defined(MSG_NOSIGNAL)
+#define MSG_NOSIGNAL 0
+#endif
+
+#if defined(_AIX) && !defined(MSG_DONTWAIT)
+#define MSG_DONTWAIT MSG_NONBLOCK
+#endif
+
+#include "modbus-private.h"
+
+#include "modbus-tcp.h"
+#include "modbus-tcp-private.h"
+
+#ifdef OS_WIN32
+static int _modbus_tcp_init_win32(void)
+{
+    /* Initialise Windows Socket API */
+    WSADATA wsaData;
+
+    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
+        fprintf(stderr, "WSAStartup() returned error code %d\n",
+                (unsigned int)GetLastError());
+        errno = EIO;
+        return -1;
+    }
+    return 0;
+}
+#endif
+
+static int _modbus_set_slave(modbus_t *ctx, int slave)
+{
+    /* Broadcast address is 0 (MODBUS_BROADCAST_ADDRESS) */
+    //***changed for QModMaster : <= 247***//
+    if (slave >= 0 && slave <= 255) {
+        ctx->slave = slave;
+    } else if (slave == MODBUS_TCP_SLAVE) {
+        /* The special value MODBUS_TCP_SLAVE (0xFF) can be used in TCP mode to
+         * restore the default value. */
+        ctx->slave = slave;
+    } else {
+        errno = EINVAL;
+        return -1;
+    }
+
+    return 0;
+}
+
+/* Builds a TCP request header */
+static int _modbus_tcp_build_request_basis(modbus_t *ctx, int function,
+                                           int addr, int nb,
+                                           uint8_t *req)
+{
+    modbus_tcp_t *ctx_tcp = ctx->backend_data;
+
+    /* Increase transaction ID */
+    if (ctx_tcp->t_id < UINT16_MAX)
+        ctx_tcp->t_id++;
+    else
+        ctx_tcp->t_id = 0;
+    req[0] = ctx_tcp->t_id >> 8;
+    req[1] = ctx_tcp->t_id & 0x00ff;
+
+    /* Protocol Modbus */
+    req[2] = 0;
+    req[3] = 0;
+
+    /* Length will be defined later by set_req_length_tcp at offsets 4
+       and 5 */
+
+    req[6] = ctx->slave;
+    req[7] = function;
+    req[8] = addr >> 8;
+    req[9] = addr & 0x00ff;
+    req[10] = nb >> 8;
+    req[11] = nb & 0x00ff;
+
+    return _MODBUS_TCP_PRESET_REQ_LENGTH;
+}
+
+/* Builds a TCP response header */
+static int _modbus_tcp_build_response_basis(sft_t *sft, uint8_t *rsp)
+{
+    /* Extract from MODBUS Messaging on TCP/IP Implementation
+       Guide V1.0b (page 23/46):
+       The transaction identifier is used to associate the future
+       response with the request. */
+    rsp[0] = sft->t_id >> 8;
+    rsp[1] = sft->t_id & 0x00ff;
+
+    /* Protocol Modbus */
+    rsp[2] = 0;
+    rsp[3] = 0;
+
+    /* Length will be set later by send_msg (4 and 5) */
+
+    /* The slave ID is copied from the indication */
+    rsp[6] = sft->slave;
+    rsp[7] = sft->function;
+
+    return _MODBUS_TCP_PRESET_RSP_LENGTH;
+}
+
+
+static int _modbus_tcp_prepare_response_tid(const uint8_t *req, int *req_length)
+{
+    return (req[0] << 8) + req[1];
+}
+
+static int _modbus_tcp_send_msg_pre(uint8_t *req, int req_length)
+{
+    /* Substract the header length to the message length */
+    int mbap_length = req_length - 6;
+
+    req[4] = mbap_length >> 8;
+    req[5] = mbap_length & 0x00FF;
+
+    return req_length;
+}
+
+static ssize_t _modbus_tcp_send(modbus_t *ctx, const uint8_t *req, int req_length)
+{
+    /* MSG_NOSIGNAL
+       Requests not to send SIGPIPE on errors on stream oriented
+       sockets when the other end breaks the connection.  The EPIPE
+       error is still returned. */
+    return send(ctx->s, (const char *)req, req_length, MSG_NOSIGNAL);
+}
+
+static int _modbus_tcp_receive(modbus_t *ctx, uint8_t *req) {
+    return _modbus_receive_msg(ctx, req, MSG_INDICATION);
+}
+
+static ssize_t _modbus_tcp_recv(modbus_t *ctx, uint8_t *rsp, int rsp_length) {
+    return recv(ctx->s, (char *)rsp, rsp_length, 0);
+}
+
+static int _modbus_tcp_check_integrity(modbus_t *ctx, uint8_t *msg, const int msg_length)
+{
+    return msg_length;
+}
+
+static int _modbus_tcp_pre_check_confirmation(modbus_t *ctx, const uint8_t *req,
+                                              const uint8_t *rsp, int rsp_length)
+{
+    /* Check transaction ID */
+    if (req[0] != rsp[0] || req[1] != rsp[1]) {
+        if (ctx->debug) {
+            fprintf(stderr, "Invalid transaction ID received 0x%X (not 0x%X)\n",
+                    (rsp[0] << 8) + rsp[1], (req[0] << 8) + req[1]);
+        }
+        errno = EMBBADDATA;
+        return -1;
+    }
+
+    /* Check protocol ID */
+    if (rsp[2] != 0x0 && rsp[3] != 0x0) {
+        if (ctx->debug) {
+            fprintf(stderr, "Invalid protocol ID received 0x%X (not 0x0)\n",
+                    (rsp[2] << 8) + rsp[3]);
+        }
+        errno = EMBBADDATA;
+        return -1;
+    }
+
+    return 0;
+}
+
+static int _modbus_tcp_set_ipv4_options(int s)
+{
+    int rc;
+    int option;
+
+    /* Set the TCP no delay flag */
+    /* SOL_TCP = IPPROTO_TCP */
+    option = 1;
+    rc = setsockopt(s, IPPROTO_TCP, TCP_NODELAY,
+                    (const void *)&option, sizeof(int));
+    if (rc == -1) {
+        return -1;
+    }
+
+    /* If the OS does not offer SOCK_NONBLOCK, fall back to setting FIONBIO to
+     * make sockets non-blocking */
+    /* Do not care about the return value, this is optional */
+#if !defined(SOCK_NONBLOCK) && defined(FIONBIO)
+#ifdef OS_WIN32
+    {
+        /* Setting FIONBIO expects an unsigned long according to MSDN */
+        u_long loption = 1;
+        ioctlsocket(s, FIONBIO, &loption);
+    }
+#else
+    option = 1;
+    ioctl(s, FIONBIO, &option);
+#endif
+#endif
+
+#ifndef OS_WIN32
+    /**
+     * Cygwin defines IPTOS_LOWDELAY but can't handle that flag so it's
+     * necessary to workaround that problem.
+     **/
+    /* Set the IP low delay option */
+    option = IPTOS_LOWDELAY;
+    rc = setsockopt(s, IPPROTO_IP, IP_TOS,
+                    (const void *)&option, sizeof(int));
+    if (rc == -1) {
+        return -1;
+    }
+#endif
+
+    return 0;
+}
+
+static int _connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen,
+                    const struct timeval *ro_tv)
+{
+    int rc = connect(sockfd, addr, addrlen);
+
+#ifdef OS_WIN32
+    int wsaError = 0;
+    if (rc == -1) {
+        wsaError = WSAGetLastError();
+    }
+
+    if (wsaError == WSAEWOULDBLOCK || wsaError == WSAEINPROGRESS) {
+#else
+    if (rc == -1 && errno == EINPROGRESS) {
+#endif
+        fd_set wset;
+        int optval;
+        socklen_t optlen = sizeof(optval);
+        struct timeval tv = *ro_tv;
+
+        /* Wait to be available in writing */
+        FD_ZERO(&wset);
+        FD_SET(sockfd, &wset);
+        rc = select(sockfd + 1, NULL, &wset, NULL, &tv);
+        if (rc <= 0) {
+            /* Timeout or fail */
+            return -1;
+        }
+
+        /* The connection is established if SO_ERROR and optval are set to 0 */
+        rc = getsockopt(sockfd, SOL_SOCKET, SO_ERROR, (void *)&optval, &optlen);
+        if (rc == 0 && optval == 0) {
+            return 0;
+        } else {
+            errno = ECONNREFUSED;
+            return -1;
+        }
+    }
+    return rc;
+}
+
+/* Establishes a modbus TCP connection with a Modbus server. */
+static int _modbus_tcp_connect(modbus_t *ctx)
+{
+    int rc;
+    /* Specialized version of sockaddr for Internet socket address (same size) */
+    struct sockaddr_in addr;
+    modbus_tcp_t *ctx_tcp = ctx->backend_data;
+    int flags = SOCK_STREAM;
+
+#ifdef OS_WIN32
+    if (_modbus_tcp_init_win32() == -1) {
+        return -1;
+    }
+#endif
+
+#ifdef SOCK_CLOEXEC
+    flags |= SOCK_CLOEXEC;
+#endif
+
+#ifdef SOCK_NONBLOCK
+    flags |= SOCK_NONBLOCK;
+#endif
+
+    ctx->s = socket(PF_INET, flags, 0);
+    if (ctx->s == -1) {
+        return -1;
+    }
+
+    rc = _modbus_tcp_set_ipv4_options(ctx->s);
+    if (rc == -1) {
+        close(ctx->s);
+        ctx->s = -1;
+        return -1;
+    }
+
+    if (ctx->debug) {
+        printf("Connecting to %s:%d\n", ctx_tcp->ip, ctx_tcp->port);
+    }
+
+    addr.sin_family = AF_INET;
+    addr.sin_port = htons(ctx_tcp->port);
+    addr.sin_addr.s_addr = inet_addr(ctx_tcp->ip);
+    rc = _connect(ctx->s, (struct sockaddr *)&addr, sizeof(addr), &ctx->response_timeout);
+    if (rc == -1) {
+        close(ctx->s);
+        ctx->s = -1;
+        return -1;
+    }
+
+    return 0;
+}
+
+/* Establishes a modbus TCP PI connection with a Modbus server. */
+static int _modbus_tcp_pi_connect(modbus_t *ctx)
+{
+    int rc;
+    struct addrinfo *ai_list;
+    struct addrinfo *ai_ptr;
+    struct addrinfo ai_hints;
+    modbus_tcp_pi_t *ctx_tcp_pi = ctx->backend_data;
+
+#ifdef OS_WIN32
+    if (_modbus_tcp_init_win32() == -1) {
+        return -1;
+    }
+#endif
+
+    memset(&ai_hints, 0, sizeof(ai_hints));
+#ifdef AI_ADDRCONFIG
+    ai_hints.ai_flags |= AI_ADDRCONFIG;
+#endif
+    ai_hints.ai_family = AF_UNSPEC;
+    ai_hints.ai_socktype = SOCK_STREAM;
+    ai_hints.ai_addr = NULL;
+    ai_hints.ai_canonname = NULL;
+    ai_hints.ai_next = NULL;
+
+    ai_list = NULL;
+    rc = getaddrinfo(ctx_tcp_pi->node, ctx_tcp_pi->service,
+                     &ai_hints, &ai_list);
+    if (rc != 0) {
+        if (ctx->debug) {
+            fprintf(stderr, "Error returned by getaddrinfo: %s\n", gai_strerror(rc));
+        }
+        errno = ECONNREFUSED;
+        return -1;
+    }
+
+    for (ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next) {
+        int flags = ai_ptr->ai_socktype;
+        int s;
+
+#ifdef SOCK_CLOEXEC
+        flags |= SOCK_CLOEXEC;
+#endif
+
+#ifdef SOCK_NONBLOCK
+        flags |= SOCK_NONBLOCK;
+#endif
+
+        s = socket(ai_ptr->ai_family, flags, ai_ptr->ai_protocol);
+        if (s < 0)
+            continue;
+
+        if (ai_ptr->ai_family == AF_INET)
+            _modbus_tcp_set_ipv4_options(s);
+
+        if (ctx->debug) {
+            printf("Connecting to [%s]:%s\n", ctx_tcp_pi->node, ctx_tcp_pi->service);
+        }
+
+        rc = _connect(s, ai_ptr->ai_addr, ai_ptr->ai_addrlen, &ctx->response_timeout);
+        if (rc == -1) {
+            close(s);
+            continue;
+        }
+
+        ctx->s = s;
+        break;
+    }
+
+    freeaddrinfo(ai_list);
+
+    if (ctx->s < 0) {
+        return -1;
+    }
+
+    return 0;
+}
+
+/* Closes the network connection and socket in TCP mode */
+static void _modbus_tcp_close(modbus_t *ctx)
+{
+    if (ctx->s != -1) {
+        shutdown(ctx->s, SHUT_RDWR);
+        close(ctx->s);
+        ctx->s = -1;
+    }
+}
+
+static int _modbus_tcp_flush(modbus_t *ctx)
+{
+    int rc;
+    int rc_sum = 0;
+
+    do {
+        /* Extract the garbage from the socket */
+        char devnull[MODBUS_TCP_MAX_ADU_LENGTH];
+#ifndef OS_WIN32
+        rc = recv(ctx->s, devnull, MODBUS_TCP_MAX_ADU_LENGTH, MSG_DONTWAIT);
+#else
+        /* On Win32, it's a bit more complicated to not wait */
+        fd_set rset;
+        struct timeval tv;
+
+        tv.tv_sec = 0;
+        tv.tv_usec = 0;
+        FD_ZERO(&rset);
+        FD_SET(ctx->s, &rset);
+        rc = select(ctx->s+1, &rset, NULL, NULL, &tv);
+        if (rc == -1) {
+            return -1;
+        }
+
+        if (rc == 1) {
+            /* There is data to flush */
+            rc = recv(ctx->s, devnull, MODBUS_TCP_MAX_ADU_LENGTH, 0);
+        }
+#endif
+        if (rc > 0) {
+            rc_sum += rc;
+        }
+    } while (rc == MODBUS_TCP_MAX_ADU_LENGTH);
+
+    return rc_sum;
+}
+
+/* Listens for any request from one or many modbus masters in TCP */
+int modbus_tcp_listen(modbus_t *ctx, int nb_connection)
+{
+    int new_s;
+    int enable;
+    struct sockaddr_in addr;
+    modbus_tcp_t *ctx_tcp;
+
+    if (ctx == NULL) {
+        errno = EINVAL;
+        return -1;
+    }
+
+    ctx_tcp = ctx->backend_data;
+
+#ifdef OS_WIN32
+    if (_modbus_tcp_init_win32() == -1) {
+        return -1;
+    }
+#endif
+
+    new_s = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
+    if (new_s == -1) {
+        return -1;
+    }
+
+    enable = 1;
+    if (setsockopt(new_s, SOL_SOCKET, SO_REUSEADDR,
+                   (char *)&enable, sizeof(enable)) == -1) {
+        close(new_s);
+        return -1;
+    }
+
+    memset(&addr, 0, sizeof(addr));
+    addr.sin_family = AF_INET;
+    /* If the modbus port is < to 1024, we need the setuid root. */
+    addr.sin_port = htons(ctx_tcp->port);
+    if (ctx_tcp->ip[0] == '0') {
+        /* Listen any addresses */
+        addr.sin_addr.s_addr = htonl(INADDR_ANY);
+    } else {
+        /* Listen only specified IP address */
+        addr.sin_addr.s_addr = inet_addr(ctx_tcp->ip);
+    }
+    if (bind(new_s, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
+        close(new_s);
+        return -1;
+    }
+
+    if (listen(new_s, nb_connection) == -1) {
+        close(new_s);
+        return -1;
+    }
+
+    return new_s;
+}
+
+int modbus_tcp_pi_listen(modbus_t *ctx, int nb_connection)
+{
+    int rc;
+    struct addrinfo *ai_list;
+    struct addrinfo *ai_ptr;
+    struct addrinfo ai_hints;
+    const char *node;
+    const char *service;
+    int new_s;
+    modbus_tcp_pi_t *ctx_tcp_pi;
+
+    if (ctx == NULL) {
+        errno = EINVAL;
+        return -1;
+    }
+
+    ctx_tcp_pi = ctx->backend_data;
+
+#ifdef OS_WIN32
+    if (_modbus_tcp_init_win32() == -1) {
+        return -1;
+    }
+#endif
+
+    if (ctx_tcp_pi->node[0] == 0) {
+        node = NULL; /* == any */
+    } else {
+        node = ctx_tcp_pi->node;
+    }
+
+    if (ctx_tcp_pi->service[0] == 0) {
+        service = "502";
+    } else {
+        service = ctx_tcp_pi->service;
+    }
+
+    memset(&ai_hints, 0, sizeof (ai_hints));
+    /* If node is not NULL, than the AI_PASSIVE flag is ignored. */
+    ai_hints.ai_flags |= AI_PASSIVE;
+#ifdef AI_ADDRCONFIG
+    ai_hints.ai_flags |= AI_ADDRCONFIG;
+#endif
+    ai_hints.ai_family = AF_UNSPEC;
+    ai_hints.ai_socktype = SOCK_STREAM;
+    ai_hints.ai_addr = NULL;
+    ai_hints.ai_canonname = NULL;
+    ai_hints.ai_next = NULL;
+
+    ai_list = NULL;
+    rc = getaddrinfo(node, service, &ai_hints, &ai_list);
+    if (rc != 0) {
+        if (ctx->debug) {
+            fprintf(stderr, "Error returned by getaddrinfo: %s\n", gai_strerror(rc));
+        }
+        errno = ECONNREFUSED;
+        return -1;
+    }
+
+    new_s = -1;
+    for (ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next) {
+        int s;
+
+        s = socket(ai_ptr->ai_family, ai_ptr->ai_socktype,
+                   ai_ptr->ai_protocol);
+        if (s < 0) {
+            if (ctx->debug) {
+                perror("socket");
+            }
+            continue;
+        } else {
+            int enable = 1;
+            rc = setsockopt(s, SOL_SOCKET, SO_REUSEADDR,
+                            (void *)&enable, sizeof (enable));
+            if (rc != 0) {
+                close(s);
+                if (ctx->debug) {
+                    perror("setsockopt");
+                }
+                continue;
+            }
+        }
+
+        rc = bind(s, ai_ptr->ai_addr, ai_ptr->ai_addrlen);
+        if (rc != 0) {
+            close(s);
+            if (ctx->debug) {
+                perror("bind");
+            }
+            continue;
+        }
+
+        rc = listen(s, nb_connection);
+        if (rc != 0) {
+            close(s);
+            if (ctx->debug) {
+                perror("listen");
+            }
+            continue;
+        }
+
+        new_s = s;
+        break;
+    }
+    freeaddrinfo(ai_list);
+
+    if (new_s < 0) {
+        return -1;
+    }
+
+    return new_s;
+}
+
+int modbus_tcp_accept(modbus_t *ctx, int *s)
+{
+    struct sockaddr_in addr;
+    socklen_t addrlen;
+
+    if (ctx == NULL) {
+        errno = EINVAL;
+        return -1;
+    }
+
+    addrlen = sizeof(addr);
+#ifdef HAVE_ACCEPT4
+    /* Inherit socket flags and use accept4 call */
+    ctx->s = accept4(*s, (struct sockaddr *)&addr, &addrlen, SOCK_CLOEXEC);
+#else
+    ctx->s = accept(*s, (struct sockaddr *)&addr, &addrlen);
+#endif
+
+    if (ctx->s == -1) {
+        close(*s);
+        *s = -1;
+        return -1;
+    }
+
+    if (ctx->debug) {
+        printf("The client connection from %s is accepted\n",
+               inet_ntoa(addr.sin_addr));
+    }
+
+    return ctx->s;
+}
+
+int modbus_tcp_pi_accept(modbus_t *ctx, int *s)
+{
+    struct sockaddr_storage addr;
+    socklen_t addrlen;
+
+    if (ctx == NULL) {
+        errno = EINVAL;
+        return -1;
+    }
+
+    addrlen = sizeof(addr);
+#ifdef HAVE_ACCEPT4
+    /* Inherit socket flags and use accept4 call */
+    ctx->s = accept4(*s, (struct sockaddr *)&addr, &addrlen, SOCK_CLOEXEC);
+#else
+    ctx->s = accept(*s, (struct sockaddr *)&addr, &addrlen);
+#endif
+    if (ctx->s == -1) {
+        close(*s);
+        *s = -1;
+    }
+
+    if (ctx->debug) {
+        printf("The client connection is accepted.\n");
+    }
+
+    return ctx->s;
+}
+
+static int _modbus_tcp_select(modbus_t *ctx, fd_set *rset, struct timeval *tv, int length_to_read)
+{
+    int s_rc;
+    while ((s_rc = select(ctx->s+1, rset, NULL, NULL, tv)) == -1) {
+        if (errno == EINTR) {
+            if (ctx->debug) {
+                fprintf(stderr, "A non blocked signal was caught\n");
+            }
+            /* Necessary after an error */
+            FD_ZERO(rset);
+            FD_SET(ctx->s, rset);
+        } else {
+            return -1;
+        }
+    }
+
+    if (s_rc == 0) {
+        errno = ETIMEDOUT;
+        return -1;
+    }
+
+    return s_rc;
+}
+
+static void _modbus_tcp_free(modbus_t *ctx) {
+    free(ctx->backend_data);
+    free(ctx);
+}
+
+const modbus_backend_t _modbus_tcp_backend = {
+    _MODBUS_BACKEND_TYPE_TCP,
+    _MODBUS_TCP_HEADER_LENGTH,
+    _MODBUS_TCP_CHECKSUM_LENGTH,
+    MODBUS_TCP_MAX_ADU_LENGTH,
+    _modbus_set_slave,
+    _modbus_tcp_build_request_basis,
+    _modbus_tcp_build_response_basis,
+    _modbus_tcp_prepare_response_tid,
+    _modbus_tcp_send_msg_pre,
+    _modbus_tcp_send,
+    _modbus_tcp_receive,
+    _modbus_tcp_recv,
+    _modbus_tcp_check_integrity,
+    _modbus_tcp_pre_check_confirmation,
+    _modbus_tcp_connect,
+    _modbus_tcp_close,
+    _modbus_tcp_flush,
+    _modbus_tcp_select,
+    _modbus_tcp_free
+};
+
+
+const modbus_backend_t _modbus_tcp_pi_backend = {
+    _MODBUS_BACKEND_TYPE_TCP,
+    _MODBUS_TCP_HEADER_LENGTH,
+    _MODBUS_TCP_CHECKSUM_LENGTH,
+    MODBUS_TCP_MAX_ADU_LENGTH,
+    _modbus_set_slave,
+    _modbus_tcp_build_request_basis,
+    _modbus_tcp_build_response_basis,
+    _modbus_tcp_prepare_response_tid,
+    _modbus_tcp_send_msg_pre,
+    _modbus_tcp_send,
+    _modbus_tcp_receive,
+    _modbus_tcp_recv,
+    _modbus_tcp_check_integrity,
+    _modbus_tcp_pre_check_confirmation,
+    _modbus_tcp_pi_connect,
+    _modbus_tcp_close,
+    _modbus_tcp_flush,
+    _modbus_tcp_select,
+    _modbus_tcp_free
+};
+
+modbus_t* modbus_new_tcp(const char *ip, int port)
+{
+    modbus_t *ctx;
+    modbus_tcp_t *ctx_tcp;
+    size_t dest_size;
+    size_t ret_size;
+
+#if defined(OS_BSD)
+    /* MSG_NOSIGNAL is unsupported on *BSD so we install an ignore
+       handler for SIGPIPE. */
+    struct sigaction sa;
+
+    sa.sa_handler = SIG_IGN;
+    if (sigaction(SIGPIPE, &sa, NULL) < 0) {
+        /* The debug flag can't be set here... */
+        fprintf(stderr, "Coud not install SIGPIPE handler.\n");
+        return NULL;
+    }
+#endif
+
+    ctx = (modbus_t *)malloc(sizeof(modbus_t));
+    _modbus_init_common(ctx);
+
+    /* Could be changed after to reach a remote serial Modbus device */
+    ctx->slave = MODBUS_TCP_SLAVE;
+
+    ctx->backend = &_modbus_tcp_backend;
+
+    ctx->backend_data = (modbus_tcp_t *)malloc(sizeof(modbus_tcp_t));
+    ctx_tcp = (modbus_tcp_t *)ctx->backend_data;
+
+    if (ip != NULL) {
+        dest_size = sizeof(char) * 16;
+        ret_size = strlcpy(ctx_tcp->ip, ip, dest_size);
+        if (ret_size == 0) {
+            fprintf(stderr, "The IP string is empty\n");
+            modbus_free(ctx);
+            errno = EINVAL;
+            return NULL;
+        }
+
+        if (ret_size >= dest_size) {
+            fprintf(stderr, "The IP string has been truncated\n");
+            modbus_free(ctx);
+            errno = EINVAL;
+            return NULL;
+        }
+    } else {
+        ctx_tcp->ip[0] = '0';
+    }
+    ctx_tcp->port = port;
+    ctx_tcp->t_id = 0;
+
+    return ctx;
+}
+
+
+modbus_t* modbus_new_tcp_pi(const char *node, const char *service)
+{
+    modbus_t *ctx;
+    modbus_tcp_pi_t *ctx_tcp_pi;
+    size_t dest_size;
+    size_t ret_size;
+
+    ctx = (modbus_t *)malloc(sizeof(modbus_t));
+    _modbus_init_common(ctx);
+
+    /* Could be changed after to reach a remote serial Modbus device */
+    ctx->slave = MODBUS_TCP_SLAVE;
+
+    ctx->backend = &_modbus_tcp_pi_backend;
+
+    ctx->backend_data = (modbus_tcp_pi_t *)malloc(sizeof(modbus_tcp_pi_t));
+    ctx_tcp_pi = (modbus_tcp_pi_t *)ctx->backend_data;
+
+    if (node == NULL) {
+        /* The node argument can be empty to indicate any hosts */
+        ctx_tcp_pi->node[0] = 0;
+    } else {
+        dest_size = sizeof(char) * _MODBUS_TCP_PI_NODE_LENGTH;
+        ret_size = strlcpy(ctx_tcp_pi->node, node, dest_size);
+        if (ret_size == 0) {
+            fprintf(stderr, "The node string is empty\n");
+            modbus_free(ctx);
+            errno = EINVAL;
+            return NULL;
+        }
+
+        if (ret_size >= dest_size) {
+            fprintf(stderr, "The node string has been truncated\n");
+            modbus_free(ctx);
+            errno = EINVAL;
+            return NULL;
+        }
+    }
+
+    if (service != NULL) {
+        dest_size = sizeof(char) * _MODBUS_TCP_PI_SERVICE_LENGTH;
+        ret_size = strlcpy(ctx_tcp_pi->service, service, dest_size);
+    } else {
+        /* Empty service is not allowed, error catched below. */
+        ret_size = 0;
+    }
+
+    if (ret_size == 0) {
+        fprintf(stderr, "The service string is empty\n");
+        modbus_free(ctx);
+        errno = EINVAL;
+        return NULL;
+    }
+
+    if (ret_size >= dest_size) {
+        fprintf(stderr, "The service string has been truncated\n");
+        modbus_free(ctx);
+        errno = EINVAL;
+        return NULL;
+    }
+
+    ctx_tcp_pi->t_id = 0;
+
+    return ctx;
+}

Applications/qModMaster/3rdparty/libmodbus/modbus-tcp.h

@@ -0,0 +1,52 @@
+/*
+ * Copyright © 2001-2010 Stéphane Raimbault <stephane.raimbault@gmail.com>
+ *
+ * SPDX-License-Identifier: LGPL-2.1+
+ */
+
+#ifndef MODBUS_TCP_H
+#define MODBUS_TCP_H
+
+#include "modbus.h"
+
+MODBUS_BEGIN_DECLS
+
+#if defined(_WIN32) && !defined(__CYGWIN__)
+/* Win32 with MinGW, supplement to <errno.h> */
+#include <winsock2.h>
+#if !defined(ECONNRESET)
+#define ECONNRESET   WSAECONNRESET
+#endif
+#if !defined(ECONNREFUSED)
+#define ECONNREFUSED WSAECONNREFUSED
+#endif
+#if !defined(ETIMEDOUT)
+#define ETIMEDOUT    WSAETIMEDOUT
+#endif
+#if !defined(ENOPROTOOPT)
+#define ENOPROTOOPT  WSAENOPROTOOPT
+#endif
+#if !defined(EINPROGRESS)
+#define EINPROGRESS  WSAEINPROGRESS
+#endif
+#endif
+
+#define MODBUS_TCP_DEFAULT_PORT   502
+#define MODBUS_TCP_SLAVE         0xFF
+
+/* Modbus_Application_Protocol_V1_1b.pdf Chapter 4 Section 1 Page 5
+ * TCP MODBUS ADU = 253 bytes + MBAP (7 bytes) = 260 bytes
+ */
+#define MODBUS_TCP_MAX_ADU_LENGTH  260
+
+MODBUS_API modbus_t* modbus_new_tcp(const char *ip_address, int port);
+MODBUS_API int modbus_tcp_listen(modbus_t *ctx, int nb_connection);
+MODBUS_API int modbus_tcp_accept(modbus_t *ctx, int *s);
+
+MODBUS_API modbus_t* modbus_new_tcp_pi(const char *node, const char *service);
+MODBUS_API int modbus_tcp_pi_listen(modbus_t *ctx, int nb_connection);
+MODBUS_API int modbus_tcp_pi_accept(modbus_t *ctx, int *s);
+
+MODBUS_END_DECLS
+
+#endif /* MODBUS_TCP_H */

Applications/qModMaster/3rdparty/libmodbus/modbus-version.h

@@ -0,0 +1,53 @@
+/*
+ * Copyright © 2010-2014 Stéphane Raimbault <stephane.raimbault@gmail.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef MODBUS_VERSION_H
+#define MODBUS_VERSION_H
+
+/* The major version, (1, if %LIBMODBUS_VERSION is 1.2.3) */
+#define LIBMODBUS_VERSION_MAJOR (3)
+
+/* The minor version (2, if %LIBMODBUS_VERSION is 1.2.3) */
+#define LIBMODBUS_VERSION_MINOR (1)
+
+/* The micro version (3, if %LIBMODBUS_VERSION is 1.2.3) */
+#define LIBMODBUS_VERSION_MICRO (4)
+
+/* The full version, like 1.2.3 */
+#define LIBMODBUS_VERSION        3.1.4
+
+/* The full version, in string form (suited for string concatenation)
+ */
+#define LIBMODBUS_VERSION_STRING "3.1.4"
+
+/* Numerically encoded version, like 0x010203 */
+#define LIBMODBUS_VERSION_HEX ((LIBMODBUS_VERSION_MAJOR << 24) |  \
+                               (LIBMODBUS_VERSION_MINOR << 16) |  \
+                               (LIBMODBUS_VERSION_MICRO << 8))
+
+/* Evaluates to True if the version is greater than @major, @minor and @micro
+ */
+#define LIBMODBUS_VERSION_CHECK(major,minor,micro)      \
+    (LIBMODBUS_VERSION_MAJOR > (major) ||               \
+     (LIBMODBUS_VERSION_MAJOR == (major) &&             \
+      LIBMODBUS_VERSION_MINOR > (minor)) ||             \
+     (LIBMODBUS_VERSION_MAJOR == (major) &&             \
+      LIBMODBUS_VERSION_MINOR == (minor) &&             \
+      LIBMODBUS_VERSION_MICRO >= (micro)))
+
+#endif /* MODBUS_VERSION_H */

Applications/qModMaster/3rdparty/libmodbus/modbus.h

@@ -0,0 +1,289 @@
+/*
+ * Copyright © 2001-2013 Stéphane Raimbault <stephane.raimbault@gmail.com>
+ *
+ * SPDX-License-Identifier: LGPL-2.1+
+ */
+
+#ifndef MODBUS_H
+#define MODBUS_H
+
+/* Add this for macros that defined unix flavor */
+#if (defined(__unix__) || defined(unix)) && !defined(USG)
+#include <sys/param.h>
+#endif
+
+#ifndef _MSC_VER
+#include <stdint.h>
+#else
+#include "stdint.h"
+#endif
+
+#include "modbus-version.h"
+
+#if defined(_MSC_VER)
+# if defined(DLLBUILD)
+/* define DLLBUILD when building the DLL */
+#  define MODBUS_API __declspec(dllexport)
+# else
+#  define MODBUS_API __declspec(dllimport)
+# endif
+#else
+# define MODBUS_API
+#endif
+
+#ifdef  __cplusplus
+# define MODBUS_BEGIN_DECLS  extern "C" {
+# define MODBUS_END_DECLS    }
+#else
+# define MODBUS_BEGIN_DECLS
+# define MODBUS_END_DECLS
+#endif
+
+MODBUS_BEGIN_DECLS
+
+#ifndef FALSE
+#define FALSE 0
+#endif
+
+#ifndef TRUE
+#define TRUE 1
+#endif
+
+#ifndef OFF
+#define OFF 0
+#endif
+
+#ifndef ON
+#define ON 1
+#endif
+
+/* Modbus function codes */
+#define MODBUS_FC_READ_COILS                0x01
+#define MODBUS_FC_READ_DISCRETE_INPUTS      0x02
+#define MODBUS_FC_READ_HOLDING_REGISTERS    0x03
+#define MODBUS_FC_READ_INPUT_REGISTERS      0x04
+#define MODBUS_FC_WRITE_SINGLE_COIL         0x05
+#define MODBUS_FC_WRITE_SINGLE_REGISTER     0x06
+#define MODBUS_FC_READ_EXCEPTION_STATUS     0x07
+#define MODBUS_FC_WRITE_MULTIPLE_COILS      0x0F
+#define MODBUS_FC_WRITE_MULTIPLE_REGISTERS  0x10
+#define MODBUS_FC_REPORT_SLAVE_ID           0x11
+#define MODBUS_FC_MASK_WRITE_REGISTER       0x16
+#define MODBUS_FC_WRITE_AND_READ_REGISTERS  0x17
+
+#define MODBUS_BROADCAST_ADDRESS    0
+
+/* Modbus_Application_Protocol_V1_1b.pdf (chapter 6 section 1 page 12)
+ * Quantity of Coils to read (2 bytes): 1 to 2000 (0x7D0)
+ * (chapter 6 section 11 page 29)
+ * Quantity of Coils to write (2 bytes): 1 to 1968 (0x7B0)
+ */
+#define MODBUS_MAX_READ_BITS              2000
+#define MODBUS_MAX_WRITE_BITS             1968
+
+/* Modbus_Application_Protocol_V1_1b.pdf (chapter 6 section 3 page 15)
+ * Quantity of Registers to read (2 bytes): 1 to 125 (0x7D)
+ * (chapter 6 section 12 page 31)
+ * Quantity of Registers to write (2 bytes) 1 to 123 (0x7B)
+ * (chapter 6 section 17 page 38)
+ * Quantity of Registers to write in R/W registers (2 bytes) 1 to 121 (0x79)
+ */
+#define MODBUS_MAX_READ_REGISTERS          125
+#define MODBUS_MAX_WRITE_REGISTERS         123
+#define MODBUS_MAX_WR_WRITE_REGISTERS      121
+#define MODBUS_MAX_WR_READ_REGISTERS       125
+
+/* The size of the MODBUS PDU is limited by the size constraint inherited from
+ * the first MODBUS implementation on Serial Line network (max. RS485 ADU = 256
+ * bytes). Therefore, MODBUS PDU for serial line communication = 256 - Server
+ * address (1 byte) - CRC (2 bytes) = 253 bytes.
+ */
+#define MODBUS_MAX_PDU_LENGTH              253
+
+/* Consequently:
+ * - RTU MODBUS ADU = 253 bytes + Server address (1 byte) + CRC (2 bytes) = 256
+ *   bytes.
+ * - TCP MODBUS ADU = 253 bytes + MBAP (7 bytes) = 260 bytes.
+ * so the maximum of both backend in 260 bytes. This size can used to allocate
+ * an array of bytes to store responses and it will be compatible with the two
+ * backends.
+ */
+#define MODBUS_MAX_ADU_LENGTH              260
+
+/* Random number to avoid errno conflicts */
+#define MODBUS_ENOBASE 112345678
+
+/* Protocol exceptions */
+enum {
+    MODBUS_EXCEPTION_ILLEGAL_FUNCTION = 0x01,
+    MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS,
+    MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE,
+    MODBUS_EXCEPTION_SLAVE_OR_SERVER_FAILURE,
+    MODBUS_EXCEPTION_ACKNOWLEDGE,
+    MODBUS_EXCEPTION_SLAVE_OR_SERVER_BUSY,
+    MODBUS_EXCEPTION_NEGATIVE_ACKNOWLEDGE,
+    MODBUS_EXCEPTION_MEMORY_PARITY,
+    MODBUS_EXCEPTION_NOT_DEFINED,
+    MODBUS_EXCEPTION_GATEWAY_PATH,
+    MODBUS_EXCEPTION_GATEWAY_TARGET,
+    MODBUS_EXCEPTION_MAX
+};
+
+#define EMBXILFUN  (MODBUS_ENOBASE + MODBUS_EXCEPTION_ILLEGAL_FUNCTION)
+#define EMBXILADD  (MODBUS_ENOBASE + MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS)
+#define EMBXILVAL  (MODBUS_ENOBASE + MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE)
+#define EMBXSFAIL  (MODBUS_ENOBASE + MODBUS_EXCEPTION_SLAVE_OR_SERVER_FAILURE)
+#define EMBXACK    (MODBUS_ENOBASE + MODBUS_EXCEPTION_ACKNOWLEDGE)
+#define EMBXSBUSY  (MODBUS_ENOBASE + MODBUS_EXCEPTION_SLAVE_OR_SERVER_BUSY)
+#define EMBXNACK   (MODBUS_ENOBASE + MODBUS_EXCEPTION_NEGATIVE_ACKNOWLEDGE)
+#define EMBXMEMPAR (MODBUS_ENOBASE + MODBUS_EXCEPTION_MEMORY_PARITY)
+#define EMBXGPATH  (MODBUS_ENOBASE + MODBUS_EXCEPTION_GATEWAY_PATH)
+#define EMBXGTAR   (MODBUS_ENOBASE + MODBUS_EXCEPTION_GATEWAY_TARGET)
+
+/* Native libmodbus error codes */
+#define EMBBADCRC  (EMBXGTAR + 1)
+#define EMBBADDATA (EMBXGTAR + 2)
+#define EMBBADEXC  (EMBXGTAR + 3)
+#define EMBUNKEXC  (EMBXGTAR + 4)
+#define EMBMDATA   (EMBXGTAR + 5)
+#define EMBBADSLAVE (EMBXGTAR + 6)
+
+extern const unsigned int libmodbus_version_major;
+extern const unsigned int libmodbus_version_minor;
+extern const unsigned int libmodbus_version_micro;
+
+typedef struct _modbus modbus_t;
+
+typedef struct {
+    int nb_bits;
+    int start_bits;
+    int nb_input_bits;
+    int start_input_bits;
+    int nb_input_registers;
+    int start_input_registers;
+    int nb_registers;
+    int start_registers;
+    uint8_t *tab_bits;
+    uint8_t *tab_input_bits;
+    uint16_t *tab_input_registers;
+    uint16_t *tab_registers;
+} modbus_mapping_t;
+
+typedef enum
+{
+    MODBUS_ERROR_RECOVERY_NONE          = 0,
+    MODBUS_ERROR_RECOVERY_LINK          = (1<<1),
+    MODBUS_ERROR_RECOVERY_PROTOCOL      = (1<<2)
+} modbus_error_recovery_mode;
+
+MODBUS_API int modbus_set_slave(modbus_t* ctx, int slave);
+MODBUS_API int modbus_set_error_recovery(modbus_t *ctx, modbus_error_recovery_mode error_recovery);
+MODBUS_API int modbus_set_socket(modbus_t *ctx, int s);
+MODBUS_API int modbus_get_socket(modbus_t *ctx);
+
+MODBUS_API int modbus_get_response_timeout(modbus_t *ctx, uint32_t *to_sec, uint32_t *to_usec);
+MODBUS_API int modbus_set_response_timeout(modbus_t *ctx, uint32_t to_sec, uint32_t to_usec);
+
+MODBUS_API int modbus_get_byte_timeout(modbus_t *ctx, uint32_t *to_sec, uint32_t *to_usec);
+MODBUS_API int modbus_set_byte_timeout(modbus_t *ctx, uint32_t to_sec, uint32_t to_usec);
+
+MODBUS_API int modbus_get_header_length(modbus_t *ctx);
+
+MODBUS_API int modbus_connect(modbus_t *ctx);
+MODBUS_API void modbus_close(modbus_t *ctx);
+
+MODBUS_API void modbus_free(modbus_t *ctx);
+
+MODBUS_API int modbus_flush(modbus_t *ctx);
+MODBUS_API int modbus_set_debug(modbus_t *ctx, int flag);
+
+MODBUS_API const char *modbus_strerror(int errnum);
+
+MODBUS_API int modbus_read_bits(modbus_t *ctx, int addr, int nb, uint8_t *dest);
+MODBUS_API int modbus_read_input_bits(modbus_t *ctx, int addr, int nb, uint8_t *dest);
+MODBUS_API int modbus_read_registers(modbus_t *ctx, int addr, int nb, uint16_t *dest);
+MODBUS_API int modbus_read_input_registers(modbus_t *ctx, int addr, int nb, uint16_t *dest);
+MODBUS_API int modbus_write_bit(modbus_t *ctx, int coil_addr, int status);
+MODBUS_API int modbus_write_register(modbus_t *ctx, int reg_addr, int value);
+MODBUS_API int modbus_write_bits(modbus_t *ctx, int addr, int nb, const uint8_t *data);
+MODBUS_API int modbus_write_registers(modbus_t *ctx, int addr, int nb, const uint16_t *data);
+MODBUS_API int modbus_mask_write_register(modbus_t *ctx, int addr, uint16_t and_mask, uint16_t or_mask);
+MODBUS_API int modbus_write_and_read_registers(modbus_t *ctx, int write_addr, int write_nb,
+                                               const uint16_t *src, int read_addr, int read_nb,
+                                               uint16_t *dest);
+MODBUS_API int modbus_report_slave_id(modbus_t *ctx, int max_dest, uint8_t *dest);
+
+MODBUS_API modbus_mapping_t* modbus_mapping_new_start_address(
+    unsigned int start_bits, unsigned int nb_bits,
+    unsigned int start_input_bits, unsigned int nb_input_bits,
+    unsigned int start_registers, unsigned int nb_registers,
+    unsigned int start_input_registers, unsigned int nb_input_registers);
+
+MODBUS_API modbus_mapping_t* modbus_mapping_new(int nb_bits, int nb_input_bits,
+                                                int nb_registers, int nb_input_registers);
+MODBUS_API void modbus_mapping_free(modbus_mapping_t *mb_mapping);
+
+MODBUS_API int modbus_send_raw_request(modbus_t *ctx, uint8_t *raw_req, int raw_req_length);
+
+MODBUS_API int modbus_receive(modbus_t *ctx, uint8_t *req);
+
+MODBUS_API int modbus_receive_confirmation(modbus_t *ctx, uint8_t *rsp);
+
+MODBUS_API int modbus_reply(modbus_t *ctx, const uint8_t *req,
+                            int req_length, modbus_mapping_t *mb_mapping);
+MODBUS_API int modbus_reply_exception(modbus_t *ctx, const uint8_t *req,
+                                      unsigned int exception_code);
+
+/**
+ * UTILS FUNCTIONS
+ **/
+
+#define MODBUS_GET_HIGH_BYTE(data) (((data) >> 8) & 0xFF)
+#define MODBUS_GET_LOW_BYTE(data) ((data) & 0xFF)
+#define MODBUS_GET_INT64_FROM_INT16(tab_int16, index) \
+    (((int64_t)tab_int16[(index)    ] << 48) + \
+     ((int64_t)tab_int16[(index) + 1] << 32) + \
+     ((int64_t)tab_int16[(index) + 2] << 16) + \
+      (int64_t)tab_int16[(index) + 3])
+#define MODBUS_GET_INT32_FROM_INT16(tab_int16, index) ((tab_int16[(index)] << 16) + tab_int16[(index) + 1])
+#define MODBUS_GET_INT16_FROM_INT8(tab_int8, index) ((tab_int8[(index)] << 8) + tab_int8[(index) + 1])
+#define MODBUS_SET_INT16_TO_INT8(tab_int8, index, value) \
+    do { \
+        tab_int8[(index)] = (value) >> 8;  \
+        tab_int8[(index) + 1] = (value) & 0xFF; \
+    } while (0)
+#define MODBUS_SET_INT32_TO_INT16(tab_int16, index, value) \
+    do { \
+        tab_int16[(index)    ] = (value) >> 16; \
+        tab_int16[(index) + 1] = (value); \
+    } while (0)
+#define MODBUS_SET_INT64_TO_INT16(tab_int16, index, value) \
+    do { \
+        tab_int16[(index)    ] = (value) >> 48; \
+        tab_int16[(index) + 1] = (value) >> 32; \
+        tab_int16[(index) + 2] = (value) >> 16; \
+        tab_int16[(index) + 3] = (value); \
+    } while (0)
+
+MODBUS_API void modbus_set_bits_from_byte(uint8_t *dest, int idx, const uint8_t value);
+MODBUS_API void modbus_set_bits_from_bytes(uint8_t *dest, int idx, unsigned int nb_bits,
+                                       const uint8_t *tab_byte);
+MODBUS_API uint8_t modbus_get_byte_from_bits(const uint8_t *src, int idx, unsigned int nb_bits);
+MODBUS_API float modbus_get_float(const uint16_t *src);
+MODBUS_API float modbus_get_float_abcd(const uint16_t *src);
+MODBUS_API float modbus_get_float_dcba(const uint16_t *src);
+MODBUS_API float modbus_get_float_badc(const uint16_t *src);
+MODBUS_API float modbus_get_float_cdab(const uint16_t *src);
+
+MODBUS_API void modbus_set_float(float f, uint16_t *dest);
+MODBUS_API void modbus_set_float_abcd(float f, uint16_t *dest);
+MODBUS_API void modbus_set_float_dcba(float f, uint16_t *dest);
+MODBUS_API void modbus_set_float_badc(float f, uint16_t *dest);
+MODBUS_API void modbus_set_float_cdab(float f, uint16_t *dest);
+
+#include "modbus-tcp.h"
+#include "modbus-rtu.h"
+
+MODBUS_END_DECLS
+
+#endif  /* MODBUS_H */