Merge pull request #22 from NikolasK-source/main

Release 1.3.0-beta1

Author: NikolasK-source

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.2.3)
+project(Modbus_TCP_client_shm LANGUAGES CXX VERSION 1.3.0)
 
 # settings
 set(Target "modbus-tcp-client-shm")    # Executable name (without file extension!)
@@ -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)
@@ -23,6 +23,8 @@ option(CLANG_TIDY "use clang-tidy" OFF)
 option(OPTIMIZE_FOR_ARCHITECTURE "enable optimizations for specified architecture" OFF)
 option(LTO_ENABLED "enable interprocedural and link time optimizations" ON)
 option(COMPILER_EXTENSIONS "enable compiler specific C++ extensions" OFF)
+option(BETA_VERSION "version is a beta version" ON)
+set(BETA_VERSION_NR 1)
 
 # ======================================================================================================================
 # ======================================================================================================================
@@ -55,7 +57,12 @@ set_target_properties(${Target} PROPERTIES
     )
 
 # compiler definitions
-target_compile_definitions(${Target} PUBLIC "PROJECT_VERSION=\"${CMAKE_PROJECT_VERSION}\"")
+if(BETA_VERSION)
+    target_compile_definitions(${Target} PUBLIC "PROJECT_VERSION=\"${CMAKE_PROJECT_VERSION}-beta${BETA_VERSION_NR}\"")
+else()
+    target_compile_definitions(${Target} PUBLIC "PROJECT_VERSION=\"${CMAKE_PROJECT_VERSION}\"")
+endif()
+
 target_compile_definitions(${Target} PUBLIC "PROJECT_NAME=\"${CMAKE_PROJECT_NAME}\"")
 target_compile_definitions(${Target} PUBLIC "COMPILER_INFO=\"${CMAKE_CXX_COMPILER_ID} ${CMAKE_CXX_COMPILER_VERSION}\"")
 target_compile_definitions(${Target} PUBLIC "SYSTEM_INFO=\"${CMAKE_SYSTEM_NAME} ${CMAKE_SYSTEM_VERSION} ${CMAKE_HOST_SYSTEM_PROCESSOR}\"")

docs/index.md

@@ -78,6 +78,11 @@ setcap 'cap_net_bind_service=+ep' /path/to/binary
 
 ## Install
 
+### Using the Arch User Repository (recommended for Arch based Linux distributions)
+The application is available as [modbus-tcp-client-shm](https://aur.archlinux.org/packages/modbus-tcp-client-shm) in the [Arch User Repository](https://aur.archlinux.org/).
+See the [Arch Wiki](https://wiki.archlinux.org/title/Arch_User_Repository) for information about how to install AUR packages.
+
+
 ### Using the Modbus Collection Flapak Package: Shared Memory Modbus (recommended)
 [SHM-Modbus](https://nikolask-source.github.io/SHM_Modbus/) is a collection of the shared memory modbus tools.
 It is available as flatpak and published on flathub as ```network.koesling.shm-modbs```.

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>
@@ -23,9 +24,15 @@ namespace TCP {
 
 static constexpr int MAX_REGS = 0x10000;
 
-Client::Client(const std::string &ip, unsigned short port, modbus_mapping_t *mapping, std::size_t tcp_timeout) {
+Client::Client(const std::string &host,
+               const std::string &service,
+               modbus_mapping_t  *mapping,
+               std::size_t        tcp_timeout) {
+    const char *host_str = "::";
+    if (!(host.empty() || host == "any")) host_str = host.c_str();
+
     // create modbus object
-    modbus = modbus_new_tcp(ip.c_str(), static_cast<int>(port));
+    modbus = modbus_new_tcp_pi(host_str, service.c_str());
     if (modbus == nullptr) {
         const std::string error_msg = modbus_strerror(errno);
         throw std::runtime_error("failed to create modbus instance: " + error_msg);
@@ -62,9 +69,15 @@ Client::Client(const std::string &ip, unsigned short port, modbus_mapping_t *map
 #endif
 }
 
-Client::Client(const std::string &ip, unsigned short port, modbus_mapping_t **mappings, std::size_t tcp_timeout) {
+Client::Client(const std::string &host,
+               const std::string &service,
+               modbus_mapping_t **mappings,
+               std::size_t        tcp_timeout) {
+    const char *host_str = "::";
+    if (!(host.empty() || host == "any")) host_str = host.c_str();
+
     // create modbus object
-    modbus = modbus_new_tcp(ip.c_str(), static_cast<int>(port));
+    modbus = modbus_new_tcp_pi(host_str, service.c_str());
     if (modbus == nullptr) {
         const std::string error_msg = modbus_strerror(errno);
         throw std::runtime_error("failed to create modbus instance: " + error_msg);
@@ -100,10 +113,14 @@ Client::Client(const std::string &ip, unsigned short port, modbus_mapping_t **ma
 
 void Client::listen() {
     // create tcp socket
-    socket = modbus_tcp_listen(modbus, 1);
+    socket = modbus_tcp_pi_listen(modbus, 1);
     if (socket == -1) {
-        const std::string error_msg = modbus_strerror(errno);
-        throw std::runtime_error("failed to create tcp socket: " + error_msg);
+        if (errno == ECONNREFUSED) {
+            throw std::runtime_error("failed to create tcp socket: unknown or invalid service");
+        } else {
+            const std::string error_msg = modbus_strerror(errno);
+            throw std::runtime_error("failed to create tcp socket: " + error_msg);
+        }
     }
 
     // set socket options
@@ -147,7 +164,6 @@ void Client::set_tcp_timeout(std::size_t tcp_timeout) {
 }
 #endif
 
-
 Client::~Client() {
     if (modbus != nullptr) {
         modbus_close(modbus);
@@ -164,32 +180,90 @@ void Client::set_debug(bool debug) {
     }
 }
 
-std::string Client::connect_client() {
-    int tmp = modbus_tcp_accept(modbus, &socket);
+/**
+ * @brief convert socket address to string
+ * @param sa socket address
+ * @return sa as string
+ */
+static std::string sockaddr_to_str(const sockaddr_storage &sa) {
+    char buffer[INET6_ADDRSTRLEN + 1];
+    if (sa.ss_family == AF_INET) {
+        auto peer_in = reinterpret_cast<const struct sockaddr_in *>(&sa);
+        inet_ntop(sa.ss_family, &peer_in->sin_addr, buffer, sizeof(buffer));
+        std::ostringstream sstr;
+        return buffer;
+    } else if (sa.ss_family == AF_INET6) {
+        auto peer_in6 = reinterpret_cast<const struct sockaddr_in6 *>(&sa);
+        inet_ntop(sa.ss_family, &peer_in6->sin6_addr, buffer, sizeof(buffer));
+        std::ostringstream sstr;
+        sstr << '[' << buffer << ']';
+        return sstr.str();
+    } else {
+        return "UNKNOWN";
+    }
+}
+
+std::string Client::get_listen_addr() {
+    struct sockaddr_storage sock_addr;
+    socklen_t               len = sizeof(sock_addr);
+    int                     tmp = getsockname(socket, reinterpret_cast<struct sockaddr *>(&sock_addr), &len);
+
+    if (tmp < 0) {
+        const std::string error_msg = modbus_strerror(errno);
+        throw std::runtime_error("getsockname failed: " + error_msg);
+    }
+
+    std::ostringstream sstr;
+    sstr << sockaddr_to_str(sock_addr);
+    // the port entries have the same offset and size in sockaddr_in and sockaddr_in6
+    sstr << ':' << htons(reinterpret_cast<const struct sockaddr_in *>(&sock_addr)->sin_port);
+
+    return sstr.str();
+}
+
+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);
         throw std::runtime_error("modbus_tcp_accept failed: " + error_msg);
     }
 
-    struct sockaddr_in peer_addr;
-    socklen_t          len = sizeof(peer_addr);
+    struct sockaddr_storage peer_addr;
+    socklen_t               len = sizeof(peer_addr);
     tmp = getpeername(modbus_get_socket(modbus), reinterpret_cast<struct sockaddr *>(&peer_addr), &len);
 
     if (tmp < 0) {
         const std::string error_msg = modbus_strerror(errno);
         throw std::runtime_error("getpeername failed: " + error_msg);
     }
 
-    char buffer[INET_ADDRSTRLEN];
-    inet_ntop(peer_addr.sin_family, &peer_addr.sin_addr, buffer, sizeof(buffer));
-
     std::ostringstream sstr;
-    sstr << buffer << ':' << htons(peer_addr.sin_port);
 
-    return sstr.str();
+    sstr << sockaddr_to_str(peer_addr);
+    // 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 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,31 +26,32 @@ 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)
      *
-     * @param ip ip to listen for incoming connections (default 0.0.0.0 (any))
-     * @param port port to listen  for incoming connections (default 502)
+     * @param host host to listen for incoming connections (default 0.0.0.0 (any))
+     * @param service service/port to listen  for incoming connections (default 502)
      * @param mapping modbus mapping object for all client ids
      *                nullptr: an mapping object with maximum size is generated
      * @param tcp_timeout tcp timeout (currently only available on linux systems)
      */
-    explicit Client(const std::string &ip          = "0.0.0.0",
-                    short unsigned int port        = 502,
+    explicit Client(const std::string &host        = "any",
+                    const std::string &service     = "502",
                     modbus_mapping_t  *mapping     = nullptr,
                     std::size_t        tcp_timeout = 5);
 
     /**
      * @brief create modbus client (TCP server) with dedicated mappings per client id
      *
-     * @param ip ip to listen for incoming connections
-     * @param port port to listen  for incoming connections
+     * @param host host to listen for incoming connections
+     * @param service service/port to listen  for incoming connections
      * @param mappings modbus mappings (one for each possible id)
      * @param tcp_timeout tcp timeout (currently only available on linux systems)
      */
-    Client(const std::string &ip,
-           short unsigned int port,
+    Client(const std::string &host,
+           const std::string &service,
            modbus_mapping_t  *mappings[MAX_CLIENT_IDS],
            std::size_t        tcp_timeout = 5);
 
@@ -61,11 +66,17 @@ class Client {
      */
     void set_debug(bool debug);
 
+    /** \brief get the address the tcp server is listening on
+     *
+     * @return server listening address
+     */
+    std::string get_listen_addr();
+
     /*! \brief wait for client to connect
      *
      * @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