use signalfd for signal handling

Author: NikolasK-source

src/Modbus_TCP_Client_poll.cpp

@@ -25,7 +25,7 @@ Client_Poll::Client_Poll(const std::string &host,
                          modbus_mapping_t  *mapping,
                          std::size_t        tcp_timeout,
                          std::size_t        max_clients)
-    : max_clients(max_clients), poll_fds(max_clients + 1, {0, 0, 0}) {
+    : max_clients(max_clients), poll_fds(max_clients + 2, {0, 0, 0}) {
     const char *host_str = "::";
     if (!(host.empty() || host == "any")) host_str = host.c_str();
 
@@ -72,7 +72,7 @@ Client_Poll::Client_Poll(const std::string &host,
                          modbus_mapping_t **mappings,
                          std::size_t        tcp_timeout,
                          std::size_t        max_clients)
-    : max_clients(max_clients), poll_fds(max_clients + 1, {0, 0, 0}) {
+    : max_clients(max_clients), poll_fds(max_clients + 2, {0, 0, 0}) {
     const char *host_str = "::";
     if (!(host.empty() || host == "any")) host_str = host.c_str();
 
@@ -242,9 +242,16 @@ double Client_Poll::get_response_timeout() {
     return static_cast<double>(timeout.sec) + (static_cast<double>(timeout.usec) / (1000.0 * 1000.0));
 }
 
-bool Client_Poll::run(bool reconnect, int timeout) {
+Client_Poll::run_t Client_Poll::run(int signal_fd, bool reconnect, int timeout) {
     std::size_t i = 0;
 
+    // poll signal fd
+    {
+        auto &fd  = poll_fds[i++];
+        fd.fd     = signal_fd;
+        fd.events = POLLIN;
+    }
+
     // do not poll server socket if maximum number of connections is reached
     const auto active_clients = client_addrs.size();
     const bool poll_server    = active_clients < max_clients;
@@ -262,18 +269,31 @@ bool Client_Poll::run(bool reconnect, int timeout) {
     }
 
     // number of files to poll
-    const nfds_t poll_size = active_clients + (poll_server ? 1 : 0);
+    const nfds_t poll_size = active_clients + (poll_server ? 2 : 1);
 
     int tmp = poll(poll_fds.data(), poll_size, timeout);
     if (tmp == -1) {
-        if (errno == EINTR) return true;
+        if (errno == EINTR) return run_t::interrupted;
         throw std::system_error(errno, std::generic_category(), "Failed to poll socket(s)");
     } else if (tmp == 0) {
         // poll timed out
-        return true;
+        return run_t::timeout;
     }
 
     i = 0;
+    {
+        auto &fd = poll_fds[i++];
+        if (fd.revents) {
+            if (fd.revents & POLLNVAL) throw std::logic_error("poll (server socket) returned POLLNVAL");
+            if (fd.revents & POLLERR) throw std::logic_error("poll (signal fd) returned POLLERR");
+            if (fd.revents & POLLHUP) throw std::logic_error("poll (signal fd) returned POLLHUP");
+            if (fd.revents & POLLIN) return run_t::term_signal;
+            std::ostringstream sstr;
+            sstr << "poll (signal fd) returned unknown revent: " << fd.revents;
+            throw std::logic_error(sstr.str());
+        }
+    }
+
     if (poll_server) {
         auto &fd = poll_fds[i++];
 
@@ -377,10 +397,10 @@ bool Client_Poll::run(bool reconnect, int timeout) {
 
     // check if there are any connections
     if (!reconnect) {
-        if (client_addrs.empty()) return false;
+        if (client_addrs.empty()) return run_t::term_nocon;
     }
 
-    return true;
+    return run_t::ok;
 }
 
 std::string Client_Poll::get_listen_addr() {

src/Modbus_TCP_Client_poll.hpp

@@ -20,6 +20,14 @@ class Client_Poll {
 public:
     static constexpr std::size_t MAX_CLIENT_IDS = 256;
 
+    enum class run_t {
+        term_signal,
+        term_nocon,
+        ok,
+        timeout,
+        interrupted,
+    };
+
 private:
     const std::size_t          max_clients;
     std::vector<struct pollfd> poll_fds;
@@ -118,10 +126,11 @@ class Client_Poll {
      * @param reconnect false: terminate once the last active connection disconnects
      *                  true: continue listening for new connections if there is no client (Mosbus Server) left
      * @param timeout timeout valoue for call of poll (see: man 2 poll)
+     * @param signal_fd signal file descriptor for termination signals
      * @return true continue
      * @return false terminate
      */
-    bool run(bool reconnect = true, int timeout = -1);
+    run_t run(int signal_fd, bool reconnect = true, int timeout = -1);
 
 private:
 #ifdef OS_LINUX

src/main.cpp

@@ -9,6 +9,7 @@
 #include <filesystem>
 #include <iostream>
 #include <memory>
+#include <sys/signalfd.h>
 #include <sysexits.h>
 #include <thread>
 #include <unistd.h>
@@ -48,7 +49,6 @@ static int socket = -1;
 /*! \brief signal handler (SIGINT and SIGTERM)
  *
  */
-static void sig_term_handler(int) { terminate = true; }
 
 constexpr std::array<int, 10> TERM_SIGNALS = {SIGINT,
                                               SIGTERM,
@@ -83,16 +83,22 @@ int main(int argc, char **argv) {
 #    pragma clang diagnostic push
 #    pragma clang diagnostic ignored "-Wdisabled-macro-expansion"
 #endif
-    // establish signal handler
-    struct sigaction term_sa;
-    term_sa.sa_handler = sig_term_handler;
-    term_sa.sa_flags   = SA_RESTART;
-    sigemptyset(&term_sa.sa_mask);
+    // create signal fd
+    sigset_t sigmask;
+    sigemptyset(&sigmask);
     for (const auto SIGNO : TERM_SIGNALS) {
-        if (sigaction(SIGNO, &term_sa, nullptr)) {
-            perror("Failed to establish signal handler");
-            return EX_OSERR;
-        }
+        sigaddset(&sigmask, SIGNO);
+    }
+
+    if (sigprocmask(SIG_BLOCK, &sigmask, NULL) == -1) {
+        perror("sigprocmask");
+        return EX_OSERR;
+    }
+
+    int signal_fd = signalfd(-1, &sigmask, 0);
+    if (signal_fd == -1) {
+        perror("signal_fd");
+        return EX_OSERR;
     }
 #ifdef COMPILER_CLANG
 #    pragma clang diagnostic pop
@@ -352,12 +358,21 @@ int main(int argc, char **argv) {
     std::cerr << "Listening on " << client->get_listen_addr() << " for connections." << std::endl;
 
     try {
-        while (true) {
-            if (!client->run(RECONNECT, -1)) {
-                std::cerr << "No more active connections." << std::endl;
-                break;
+        [&]() {
+            while (true) {
+                auto ret = client->run(signal_fd, RECONNECT, -1);
+
+                switch (ret) {
+                    case Modbus::TCP::Client_Poll::run_t::ok: continue;
+                    case Modbus::TCP::Client_Poll::run_t::term_signal: return;
+                    case Modbus::TCP::Client_Poll::run_t::term_nocon:
+                        std::cerr << "No more active connections." << std::endl;
+                        return;
+                    case Modbus::TCP::Client_Poll::run_t::timeout:
+                    case Modbus::TCP::Client_Poll::run_t::interrupted: continue;
+                }
             }
-        }
+        }();
     } catch (const std::exception &e) {
         if (!terminate) std::cerr << e.what() << std::endl;
     }