Merge pull request #29 from NikolasK-source/main

v1.4.0

Author: NikolasK-source

.gitmodules

@@ -7,3 +7,6 @@
 [submodule "libs/cxxshm"]
 	path = libs/cxxshm
 	url = https://github.com/NikolasK-source/cxxshm.git
+[submodule "libs/cxxsemaphore"]
+	path = libs/cxxsemaphore
+	url = https://github.com/NikolasK-source/cxxsemaphore.git

CMakeLists.txt

@@ -4,7 +4,7 @@ cmake_minimum_required(VERSION 3.13.4 FATAL_ERROR)
 # ======================================================================================================================
 
 # project
-project(Modbus_TCP_client_shm LANGUAGES CXX VERSION 1.3.2)
+project(Modbus_TCP_client_shm LANGUAGES CXX VERSION 1.4.0)
 
 # settings
 set(Target "modbus-tcp-client-shm")    # Executable name (without file extension!)

libs/CMakeLists.txt

@@ -13,3 +13,6 @@ target_link_libraries(${Target} PRIVATE cxxopts)
 
 add_subdirectory(cxxshm EXCLUDE_FROM_ALL)
 target_link_libraries(${Target} PRIVATE cxxshm)
+
+add_subdirectory(cxxsemaphore EXCLUDE_FROM_ALL)
+target_link_libraries(${Target} PRIVATE cxxsemaphore)

libs/cxxsemaphore

@@ -1,6 +1,6 @@
 id: network.koesling.modbus-tcp-client-shm
 runtime: org.freedesktop.Platform
-runtime-version: '21.08'
+runtime-version: '23.08'
 sdk: org.freedesktop.Sdk
 command: modbus-tcp-client-shm
 finish-args:

libs/libmodbus

@@ -1,6 +1,6 @@
 id: network.koesling.test-modbus-tcp-client-shm
 runtime: org.freedesktop.Platform
-runtime-version: '21.08'
+runtime-version: '23.08'
 sdk: org.freedesktop.Sdk
 command: modbus-tcp-client-shm
 finish-args:

network.koesling.modbus-tcp-client-shm.yml

@@ -19,8 +19,21 @@
 namespace Modbus {
 namespace TCP {
 
+//* maximum number of Modbus registers (per type)
 static constexpr int MAX_REGS = 0x10000;
 
+//* value to increment error counter if semaphore could not be acquired
+static constexpr long SEMAPHORE_ERROR_INC = 10;
+
+//* value to decrement error counter if semaphore could be acquired
+static constexpr long SEMAPHORE_ERROR_DEC = 1;
+
+//* maximum value of semaphore error counter
+static constexpr long SEMAPHORE_ERROR_MAX = 1000;
+
+//* maximum time to wait for semaphore (100ms)
+static constexpr struct timespec SEMAPHORE_MAX_TIME = {0, 100'000};
+
 Client_Poll::Client_Poll(const std::string &host,
                          const std::string &service,
                          modbus_mapping_t  *mapping,
@@ -56,7 +69,7 @@ Client_Poll::Client_Poll(const std::string &host,
 
     // use mapping for all client ids
     for (std::size_t i = 0; i < MAX_CLIENT_IDS; ++i) {
-        this->mappings[i] = mapping;
+        this->mappings[i] = mb_mapping;
     }
 
     listen();
@@ -174,6 +187,12 @@ void Client_Poll::set_tcp_timeout(std::size_t tcp_timeout) {
 }
 #endif
 
+void Client_Poll::enable_semaphore(const std::string &name, bool force) {
+    if (semaphore) throw std::logic_error("semaphore already enabled");
+
+    semaphore = std::make_unique<cxxsemaphore::Semaphore>(name, 1, force);
+}
+
 void Client_Poll::set_debug(bool debug) {
     if (modbus_set_debug(modbus, debug)) {
         const std::string error_msg = modbus_strerror(errno);
@@ -369,7 +388,28 @@ Client_Poll::run_t Client_Poll::run(int signal_fd, bool reconnect, int timeout)
                     auto mapping = mappings[CLIENT_ID];
 
                     // handle request
+                    if (semaphore) {
+                        if (!semaphore->wait(SEMAPHORE_MAX_TIME)) {
+                            std::cerr << Print_Time::iso << " WARNING: Failed to acquire semaphore '"
+                                      << semaphore->get_name() << "' within 100ms." << std::endl;
+
+                            semaphore_error_counter += SEMAPHORE_ERROR_INC;
+
+                            if (semaphore_error_counter >= SEMAPHORE_ERROR_MAX) {
+                                std::cerr << Print_Time::iso << "ERROR: Repeatedly failed to acquire the semaphore"
+                                          << std::endl;
+                                close_con(client_addrs);
+                                return run_t::semaphore;
+                            }
+                        } else {
+                            semaphore_error_counter -= SEMAPHORE_ERROR_DEC;
+                            if (semaphore_error_counter < 0) semaphore_error_counter = 0;
+                        }
+                    }
+
                     int ret = modbus_reply(modbus, query, rc, mapping);
+                    if (semaphore && semaphore->is_acquired()) semaphore->post();
+
                     if (ret == -1) {
                         std::cerr << Print_Time::iso << " ERROR: modbus_reply failed: " << modbus_strerror(errno)
                                   << std::endl;

network.koesling.test-modbus-tcp-client-shm.yml

@@ -5,6 +5,8 @@
 #pragma once
 
 #include <cstddef>
+#include <cxxsemaphore.hpp>
+#include <memory>
 #include <modbus/modbus.h>
 #include <string>
 #include <sys/poll.h>
@@ -20,13 +22,7 @@ class Client_Poll {
 public:
     static constexpr std::size_t MAX_CLIENT_IDS = 256;
 
-    enum class run_t {
-        term_signal,
-        term_nocon,
-        ok,
-        timeout,
-        interrupted,
-    };
+    enum class run_t { ok, term_signal, term_nocon, timeout, interrupted, semaphore };
 
 private:
     const std::size_t          max_clients;
@@ -39,6 +35,10 @@ class Client_Poll {
     int                                  server_socket = -1;  //!< socket of the modbus connection
     std::unordered_map<int, std::string> client_addrs;
 
+    std::unique_ptr<cxxsemaphore::Semaphore> semaphore;
+
+    long semaphore_error_counter = 0;
+
 public:
     /*! \brief create modbus client (TCP server)
      *
@@ -68,11 +68,19 @@ class Client_Poll {
                 std::size_t        tcp_timeout = 5,
                 std::size_t        max_clients = 1);
 
-    /*! \brief destroy the modbus client
-     *
+    /**
+     * @brief destroy the modbus client
      */
     ~Client_Poll();
 
+    /**
+     * @brief use the semaphore mechanism
+     *
+     * @param name name of the shared
+     * @param force use the semaphore even if it already exists
+     */
+    void enable_semaphore(const std::string &name, bool force = false);
+
     /*! \brief enable/disable debugging output
      *
      * @param debug true: enable debug output

src/Modbus_TCP_Client_poll.cpp

@@ -171,6 +171,14 @@ int main(int argc, char **argv) {
                          ("separate-all",
                           "like --separate, but for all client ids (creates 1028 shared memory files! "
                           "check/set 'ulimit -n' before using this option.)")
+                         ("semaphore",
+                          "protect the shared memory with a named semaphore against simultaneous access",
+                          cxxopts::value<std::string>())
+                          ("semaphore-force",
+                          "Force the use of the semaphore even if it already exists. "
+                          "Do not use this option per default! "
+                          "It should only be used if the semaphore of an improperly terminated instance continues "
+                          "to exist as an orphan and is no longer used.")
                          ("h,help",
                           "print usage")
                          ("version",
@@ -383,6 +391,16 @@ int main(int argc, char **argv) {
         return EX_SOFTWARE;
     }
 
+    // add semaphore if required
+    try {
+        if (args.count("semaphore")) {
+            client->enable_semaphore(args["semaphore"].as<std::string>(), args.count("semaphore-force"));
+        }
+    } catch (const std::system_error &e) {
+        std::cerr << Print_Time::iso << " ERROR: " << e.what() << std::endl;
+        return EX_SOFTWARE;
+    }
+
     auto RECONNECT = args.count("reconnect") != 0;
 
     std::cerr << Print_Time::iso << " INFO: Listening on " << client->get_listen_addr() << " for connections."
@@ -395,6 +413,7 @@ int main(int argc, char **argv) {
 
                 switch (ret) {
                     case Modbus::TCP::Client_Poll::run_t::ok: continue;
+                    case Modbus::TCP::Client_Poll::run_t::semaphore:
                     case Modbus::TCP::Client_Poll::run_t::term_signal: return;
                     case Modbus::TCP::Client_Poll::run_t::term_nocon:
                         std::cerr << Print_Time::iso << " INFO: No more active connections." << std::endl;