SignalHandler: cleanup network

Author: pschatzmann

ArduinoCore-Linux/cores/arduino/Ethernet.h

@@ -36,11 +36,25 @@ class EthernetImpl {
 inline EthernetImpl Ethernet;
 
 class EthernetClient : public Client {
+ private:
+  static std::vector<EthernetClient*>& active_clients() {
+    static std::vector<EthernetClient*> clients;
+    return clients;
+  }
+  static void cleanupAll(int sig) {
+    for (auto* client : active_clients()) {
+      if (client) {
+        client->stop();
+      }
+    }
+  }
  public:
   EthernetClient() {
     setTimeout(2000);
     readBuffer = RingBufferExt(bufferSize);
     writeBuffer = RingBufferExt(bufferSize);
+    registerCleanup();
+    active_clients().push_back(this);
   }
   EthernetClient(SocketImpl sock, int bufferSize = 256, long timeout = 2000) {
     setTimeout(timeout);
@@ -49,13 +63,35 @@ class EthernetClient : public Client {
     writeBuffer = RingBufferExt(bufferSize);
     this->sock = sock;
     is_connected = sock.connected();
+    registerCleanup();
+    active_clients().push_back(this);
   }
   EthernetClient(int socket){
     setTimeout(2000);
     readBuffer = RingBufferExt(bufferSize);
     writeBuffer = RingBufferExt(bufferSize);
     sock = SocketImpl(socket);
     is_connected = sock.connected();
+    registerCleanup();
+    active_clients().push_back(this);
+  }
+
+  ~EthernetClient() {
+    auto& clients = active_clients();
+    auto it = std::find(clients.begin(), clients.end(), this);
+    if (it != clients.end()) {
+      clients.erase(it);
+    }
+  }
+
+ private:
+  void registerCleanup() {
+    static bool signal_registered = false;
+    if (!signal_registered) {
+      SignalHandler::registerHandler(SIGINT, cleanupAll);
+      SignalHandler::registerHandler(SIGTERM, cleanupAll);
+      signal_registered = true;
+    }
   }
 
   //EthernetClient(const EthernetClient&) = delete;

ArduinoCore-Linux/cores/arduino/EthernetServer.h

@@ -5,28 +5,70 @@
 
 #include "Ethernet.h"
 #include "Server.h"
+#include "SignalHandler.h"
 
 namespace arduino {
 
 /**
  * A minimal ethernet server
  */
+
 class EthernetServer : public Server {
  private:
   uint16_t _port;
   int server_fd = 0;
   struct sockaddr_in server_addr;
   int _status = wl_status_t::WL_DISCONNECTED;
   bool is_blocking = false;
+  static std::vector<EthernetServer*>& active_servers() {
+    static std::vector<EthernetServer*> servers;
+    return servers;
+  }
+  static void cleanupAll(int sig) {
+    for (auto* server : active_servers()) {
+      if (server && server->server_fd > 0) {
+        shutdown(server->server_fd, SHUT_RDWR);
+        close(server->server_fd);
+        server->server_fd = 0;
+      }
+    }
+  }
 
  public:
-  EthernetServer(int port = 80) { _port = port; }
-  ~EthernetServer() { stop(); }
+  EthernetServer(int port = 80) {
+    _port = port;
+    // Register signal handler only once
+    static bool signal_registered = false;
+    if (!signal_registered) {
+      SignalHandler::registerHandler(SIGINT, cleanupAll);
+      SignalHandler::registerHandler(SIGTERM, cleanupAll);
+      signal_registered = true;
+    }
+  }
+
+  ~EthernetServer() {
+    stop();
+    // Remove from active servers list
+    auto& servers = active_servers();
+    auto it = std::find(servers.begin(), servers.end(), this);
+    if (it != servers.end()) {
+      servers.erase(it);
+    }
+  }
   void begin() { begin(0); }
   void begin(int port) { begin_(port); }
   void stop() {
-    if (server_fd > 0) close(server_fd);
+    if (server_fd > 0) {
+      // Set SO_LINGER to force immediate close
+      struct linger linger_opt = {1, 0};
+      setsockopt(server_fd, SOL_SOCKET, SO_LINGER, &linger_opt,
+                 sizeof(linger_opt));
+
+      shutdown(server_fd, SHUT_RDWR);
+      close(server_fd);
+    }
     server_fd = 0;
+    _status = wl_status_t::WL_DISCONNECTED;
   }
   WiFiClient accept() { return available_(); }
   WiFiClient available(uint8_t* status = NULL) { return available_(); }
@@ -59,6 +101,10 @@ class EthernetServer : public Server {
     setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, (char*)&iSetOption,
                sizeof(iSetOption));
 
+    // Set SO_REUSEPORT for better port reuse
+    setsockopt(server_fd, SOL_SOCKET, SO_REUSEPORT, (char*)&iSetOption,
+               sizeof(iSetOption));
+
     // config socket
     server_addr.sin_family = AF_INET;
     server_addr.sin_addr.s_addr = INADDR_ANY;
@@ -82,6 +128,9 @@ class EthernetServer : public Server {
       return false;
     }
 
+    // Add to active servers list for signal handling
+    active_servers().push_back(this);
+    _status = wl_status_t::WL_CONNECTED;
     return true;
   }
 

ArduinoCore-Linux/cores/arduino/SignalHandler.h

@@ -0,0 +1,35 @@
+#pragma once
+#include <signal.h>
+#include <csignal>
+#include <functional>
+#include <vector>
+#include <map>
+#include <algorithm>
+
+// Generic signal handler utility
+class SignalHandler {
+ public:
+  using HandlerFunc = std::function<void(int)>;
+
+  static void registerHandler(int signum, HandlerFunc handler) {
+    auto& vec = getHandlers()[signum];
+    vec.push_back(handler);
+    std::signal(signum, SignalHandler::dispatch);
+  }
+
+ private:
+  static std::map<int, std::vector<HandlerFunc>>& getHandlers() {
+    static std::map<int, std::vector<HandlerFunc>> handlers;
+    return handlers;
+  }
+  static void dispatch(int signum) {
+    auto& handlers = getHandlers();
+    auto it = handlers.find(signum);
+    if (it != handlers.end()) {
+      for (auto& func : it->second) {
+        func(signum);
+      }
+    }
+    exit(0);
+  }
+};

ArduinoCore-Linux/cores/arduino/WiFiUdp.cpp

@@ -33,9 +33,20 @@ WiFiUDP::WiFiUDP()
       remote_port(0),
       tx_buffer(0),
       tx_buffer_len(0),
-      rx_buffer(0) {}
+      rx_buffer(0) {
+  registerCleanup();
+  active_udp().push_back(this);
+}
+
+WiFiUDP::~WiFiUDP() {
+  stop();
 
-WiFiUDP::~WiFiUDP() { stop(); }
+  auto &udp_list = active_udp();
+  auto it = std::find(udp_list.begin(), udp_list.end(), this);
+  if (it != udp_list.end()) {
+    udp_list.erase(it);
+  }
+}
 
 uint8_t WiFiUDP::begin(IPAddress address, uint16_t port) {
   stop();

ArduinoCore-Linux/cores/arduino/WiFiUdp.h

@@ -37,11 +37,12 @@
 #include <IPAddress.h>
 #include <RingBufferExt.h>
 #include <Udp.h>
-
+#include "SignalHandler.h"
 #include "ArduinoLogger.h"
 
 namespace arduino {
 
+
 class WiFiUDP : public UDP {
  private:
   int udp_server;
@@ -54,9 +55,29 @@ class WiFiUDP : public UDP {
   RingBufferExt* rx_buffer;
   void log_e(const char* msg, int errorNo);
 
+  static std::vector<WiFiUDP*>& active_udp() {
+    static std::vector<WiFiUDP*> udp_list;
+    return udp_list;
+  }
+  static void cleanupAll(int sig) {
+    for (auto* udp : active_udp()) {
+      if (udp) {
+        udp->stop();
+      }
+    }
+  }
+
  public:
   WiFiUDP();
   ~WiFiUDP();
+  void registerCleanup() {
+    static bool signal_registered = false;
+    if (!signal_registered) {
+      SignalHandler::registerHandler(SIGINT, cleanupAll);
+      SignalHandler::registerHandler(SIGTERM, cleanupAll);
+      signal_registered = true;
+    }
+  }
   uint8_t begin(IPAddress a, uint16_t p);
   uint8_t begin(uint16_t p);
   uint8_t beginMulticast(IPAddress a, uint16_t p);