experimental: multi master support

Author: NikolasK-source

CMakeLists.txt

@@ -14,7 +14,7 @@ set(ARCHITECTURE "native")        # CPU architecture to optimize for (only relev
 # options
 option(BUILD_DOC "Build documentation" OFF)
 option(COMPILER_WARNINGS "Enable compiler warnings" ON)
-option(ENABLE_MULTITHREADING "Link the default multithreading library for the current target system" OFF)
+option(ENABLE_MULTITHREADING "Link the default multithreading library for the current target system" ON)
 option(MAKE_32_BIT_BINARY "Compile as 32 bit application. No effect on 32 bit Systems" OFF)
 option(OPENMP "enable openmp" OFF)
 option(OPTIMIZE_DEBUG "apply optimizations also in debug mode" ON)

src/CMakeLists.txt

@@ -5,13 +5,15 @@ target_sources(${Target} PRIVATE main.cpp)
 target_sources(${Target} PRIVATE modbus_shm.cpp)
 target_sources(${Target} PRIVATE Modbus_TCP_Client.cpp)
 target_sources(${Target} PRIVATE license.cpp)
+target_sources(${Target} PRIVATE Modbus_TCP_connection.cpp)
 
 
 # ---------------------------------------- header files (*.jpp, *.h, ...) ----------------------------------------------
 # ======================================================================================================================
 target_sources(${Target} PRIVATE modbus_shm.hpp)
 target_sources(${Target} PRIVATE Modbus_TCP_Client.hpp)
 target_sources(${Target} PRIVATE license.hpp)
+target_sources(${Target} PRIVATE Modbus_TCP_connection.hpp)
 
 
 

src/Modbus_TCP_Client.cpp

@@ -12,6 +12,7 @@
 #include <netinet/tcp.h>
 #include <sstream>
 #include <stdexcept>
+#include <sys/poll.h>
 #include <sys/socket.h>
 #include <system_error>
 #include <unistd.h>
@@ -220,7 +221,22 @@ std::string Client::get_listen_addr() {
     return sstr.str();
 }
 
-std::string Client::connect_client() {
+std::shared_ptr<Connection> Client::connect_client() {
+    struct pollfd fd;
+    memset(&fd, 0, sizeof(fd));
+    fd.fd     = socket;
+    fd.events = POLL_IN;
+    do {
+        int tmp = poll(&fd, 1, -1);
+        if (tmp <= 0) {
+            if (errno == EINTR) continue;
+            throw std::system_error(errno, std::generic_category(), "Failed to poll server socket");
+        } else
+            break;
+    } while (true);
+
+    std::lock_guard<decltype(modbus_lock)> guard(modbus_lock);
+
     int tmp = modbus_tcp_pi_accept(modbus, &socket);
     if (tmp < 0) {
         const std::string error_msg = modbus_strerror(errno);
@@ -242,10 +258,12 @@ std::string Client::connect_client() {
     // the port entries have the same offset and size in sockaddr_in and sockaddr_in6
     sstr << ':' << htons(reinterpret_cast<const struct sockaddr_in *>(&peer_addr)->sin_port);
 
-    return sstr.str();
+    return std::make_shared<Connection>(sstr.str(), modbus_get_socket(modbus), modbus_lock, modbus, mappings);
 }
 
 bool Client::handle_request() {
+    std::lock_guard<decltype(modbus_lock)> guard(modbus_lock);
+
     // receive modbus request
     uint8_t query[MODBUS_TCP_MAX_ADU_LENGTH];
     int     rc = modbus_receive(modbus, query);

src/Modbus_TCP_Client.hpp

@@ -5,10 +5,14 @@
 
 #pragma once
 
+#include <memory>
 #include <modbus/modbus.h>
+#include <mutex>
 #include <string>
 #include <unordered_map>
 
+#include "Modbus_TCP_connection.hpp"
+
 namespace Modbus {
 namespace TCP {
 
@@ -22,6 +26,7 @@ class Client {
             *mappings[MAX_CLIENT_IDS];  //!< modbus data objects (one per possible client id) (see libmodbus library)
     modbus_mapping_t *delete_mapping;   //!< contains a pointer to a mapping that is to be deleted
     int               socket = -1;      //!< socket of the modbus connection
+    std::mutex        modbus_lock;
 
 public:
     /*! \brief create modbus client (TCP server)
@@ -71,7 +76,7 @@ class Client {
      *
      * @return ip of the connected client
      */
-    std::string connect_client();
+    std::shared_ptr<Connection> connect_client();
 
     /*! \brief wait for request from Modbus Server and generate reply
      *

src/Modbus_TCP_connection.cpp

@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2022 Nikolas Koesling <nikolas@koesling.info>.
+ * This program is free software. You can redistribute it and/or modify it under the terms of the MIT License.
+ */
+
+#include "Modbus_TCP_connection.hpp"
+
+#include <cstring>
+#include <sys/poll.h>
+
+namespace Modbus {
+namespace TCP {
+
+bool Connection::handle_request() {
+    struct pollfd fd;
+    memset(&fd, 0, sizeof(fd));
+    fd.fd     = socket;
+    fd.events = POLL_IN;
+    do {
+        int tmp = poll(&fd, 1, -1);
+        if (tmp <= 0) {
+            if (errno == EINTR) continue;
+            throw std::system_error(errno, std::generic_category(), "Failed to poll client socket");
+        } else
+            break;
+    } while (true);
+
+
+    std::lock_guard<std::mutex> guard(modbus_lock);
+
+    // set client socket
+    int restore_socket = modbus_get_socket(modbus);
+    modbus_set_socket(modbus, socket);
+
+    // receive modbus request
+    uint8_t query[MODBUS_TCP_MAX_ADU_LENGTH];
+    int     rc = modbus_receive(modbus, query);
+
+    if (rc > 0) {
+        const auto CLIENT_ID = query[6];
+
+        // get mapping
+        auto mapping = mappings[CLIENT_ID];
+
+        // handle request
+        int ret = modbus_reply(modbus, query, rc, mapping);
+        if (ret == -1) {
+            modbus_set_socket(modbus, restore_socket);
+            const std::string error_msg = modbus_strerror(errno);
+            throw std::runtime_error("modbus_reply failed: " + error_msg + ' ' + std::to_string(errno));
+        }
+    } else if (rc == -1) {
+        if (errno == ECONNRESET) {
+            modbus_set_socket(modbus, restore_socket);
+            return true;
+        }
+
+        modbus_set_socket(modbus, restore_socket);
+        const std::string error_msg = modbus_strerror(errno);
+        throw std::runtime_error("modbus_receive failed: " + error_msg + ' ' + std::to_string(errno));
+    }
+
+    modbus_set_socket(modbus, restore_socket);
+    return false;
+}
+
+}  // namespace TCP
+}  // namespace Modbus

src/Modbus_TCP_connection.hpp

@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2022 Nikolas Koesling <nikolas@koesling.info>.
+ * This program is free software. You can redistribute it and/or modify it under the terms of the MIT License.
+ */
+
+#pragma once
+
+#include <modbus/modbus.h>
+#include <mutex>
+#include <string>
+#include <utility>
+
+namespace Modbus {
+namespace TCP {
+
+class Connection {
+private:
+    std::string        peer;
+    int                socket;
+    std::mutex        &modbus_lock;
+    modbus_t          *modbus;
+    modbus_mapping_t **mappings;
+
+public:
+    Connection(std::string peer, int socket, std::mutex &modbus_lock, modbus_t *modbus, modbus_mapping_t **mappings)
+        : peer(std::move(peer)), socket(socket), modbus_lock(modbus_lock), modbus(modbus), mappings(mappings) {}
+
+    /**
+     * @brief wait for request from Modbus Server and generate reply
+     * @return true: connection closed
+     */
+    bool handle_request();
+
+    /**
+     * @brief get connection peer
+     * @return connection peer
+     */
+    [[nodiscard]] const std::string &get_peer() const { return peer; }
+};
+
+}  // namespace TCP
+}  // namespace Modbus