unix socket (file) support

Author: pavelrevak

README.md

@@ -1,17 +1,18 @@
 # Ser2tcp
 
-Simple proxy for connecting over TCP, TELNET or SSL to serial port
+Simple proxy for connecting over TCP, TELNET, SSL or Unix socket to serial port
 
 https://github.com/cortexm/ser2tcp
 
 ## Features
 
 - can serve multiple serial ports using pyserial library
 - each serial port can have multiple servers
-- server can use TCP, TELNET or SSL protocol
+- server can use TCP, TELNET, SSL or SOCKET protocol
   - TCP protocol just bridge whole RAW serial stream to TCP
   - TELNET protocol will send every character immediately and not wait for ENTER, it is useful to use standard `telnet` as serial terminal
   - SSL protocol provides encrypted TCP connection with optional mutual TLS (mTLS) client certificate verification
+  - SOCKET protocol uses Unix domain socket for local IPC
 - servers accepts multiple connections at one time
   - each connected client can sent to serial port
   - serial port send received data to all connected clients
@@ -131,13 +132,29 @@ Match attributes: `vid`, `pid`, `serial_number`, `manufacturer`, `product`, `loc
 
 | Parameter | Description | Default |
 |-----------|-------------|---------|
-| `address` | Bind address | required |
-| `port` | TCP port | required |
-| `protocol` | `tcp`, `telnet` or `ssl` | required |
+| `address` | Bind address (IP for tcp/telnet/ssl, path for socket) | required |
+| `port` | TCP port (not used for socket) | required |
+| `protocol` | `tcp`, `telnet`, `ssl` or `socket` | required |
 | `ssl` | SSL configuration (required for `ssl` protocol) | - |
 | `send_timeout` | Disconnect client if data cannot be sent within this time (seconds) | 5.0 |
 | `buffer_limit` | Maximum send buffer size per client (bytes), `null` for unlimited | null |
 
+#### Socket configuration
+
+For `socket` protocol, `address` is the path to the Unix domain socket:
+
+```json
+{
+    "address": "/tmp/ser2tcp.sock",
+    "protocol": "socket"
+}
+```
+
+- Socket file is created on startup and removed on shutdown
+- If socket file already exists, it is replaced
+- Connect with: `socat - UNIX-CONNECT:/tmp/ser2tcp.sock`
+- Not available on Windows
+
 #### SSL configuration
 
 For `ssl` protocol, add `ssl` object with certificate paths:

ser2tcp/connection.py

@@ -38,7 +38,7 @@ def close(self):
         if self._socket:
             self._socket.close()
             self._socket = None
-            self._log.info("Client disconnected: %s:%d", *self._addr)
+            self._log.info("Client disconnected: %s", self.address_str())
 
     def fileno(self):
         """emulate fileno method of socket"""
@@ -48,6 +48,10 @@ def get_address(self):
         """Return address"""
         return self._addr
 
+    def address_str(self):
+        """Return formatted address string"""
+        return "%s:%d" % self._addr
+
     def send(self, data):
         """Add data to output buffer, return number of bytes added"""
         if not self._socket:

ser2tcp/connection_socket.py

@@ -0,0 +1,31 @@
+"""Connection Socket (Unix domain socket)"""
+
+import ser2tcp.connection as _connection
+
+
+class ConnectionSocket(_connection.Connection):
+    """Unix domain socket connection"""
+
+    def __init__(
+            self, connection, ser, send_timeout=None, buffer_limit=None,
+            log=None):
+        super().__init__(connection, send_timeout, buffer_limit, log)
+        self._serial = ser
+        self._log.info("Client connected: %s SOCKET", self._addr[0])
+
+    def address_str(self):
+        """Return formatted address string"""
+        return self._addr[0]
+
+    def close(self):
+        """Close connection"""
+        if self._socket:
+            addr = self._addr[0]
+            self._socket.close()
+            self._socket = None
+            self._log.info("Client disconnected: %s", addr)
+
+    def on_received(self, data):
+        """Received data from client"""
+        if data:
+            self._serial.send(data)

ser2tcp/connection_ssl.py

@@ -26,4 +26,4 @@ def __init__(
             (ssl_sock, addr), ser, send_timeout, buffer_limit, log)
 
     def _log_connected(self):
-        self._log.info("Client connected: %s:%d SSL", *self._addr)
+        self._log.info("Client connected: %s SSL", self.address_str())

ser2tcp/connection_tcp.py

@@ -14,7 +14,7 @@ def __init__(
         self._log_connected()
 
     def _log_connected(self):
-        self._log.info("Client connected: %s:%d TCP", *self._addr)
+        self._log.info("Client connected: %s TCP", self.address_str())
 
     def on_received(self, data):
         """Received data from client"""

ser2tcp/server.py

@@ -3,9 +3,11 @@
 # pylint: disable=C0209
 
 import logging as _logging
+import os as _os
 import socket as _socket
 import ssl as _ssl
 
+import ser2tcp.connection_socket as _connection_socket
 import ser2tcp.connection_ssl as _connection_ssl
 import ser2tcp.connection_tcp as _connection_tcp
 import ser2tcp.connection_telnet as _connection_telnet
@@ -22,6 +24,7 @@ class Server():
         'TCP': _connection_tcp.ConnectionTcp,
         'TELNET': _connection_telnet.ConnectionTelnet,
         'SSL': _connection_ssl.ConnectionSsl,
+        'SOCKET': _connection_socket.ConnectionSocket,
     }
 
     def __init__(self, config, ser, log=None):
@@ -34,19 +37,32 @@ def __init__(self, config, ser, log=None):
         self._buffer_limit = self._config.get('buffer_limit')
         self._ssl_context = None
         self._socket = None
-        self._log.info(
-            "  Server: %s %d %s",
-            self._config['address'],
-            self._config['port'],
-            self._protocol)
         if self._protocol not in self.CONNECTIONS:
             raise ConfigError('Unknown protocol %s' % self._protocol)
-        if self._protocol == 'SSL':
-            self._ssl_context = self._create_ssl_context()
-        self._socket = _socket.socket(
-            _socket.AF_INET, _socket.SOCK_STREAM, _socket.IPPROTO_TCP)
-        self._socket.setsockopt(_socket.SOL_SOCKET, _socket.SO_REUSEADDR, 1)
-        self._socket.bind((config['address'], config['port']))
+        if self._protocol == 'SOCKET':
+            self._log.info(
+                "  Server: %s %s",
+                self._config['address'],
+                self._protocol)
+            self._socket = _socket.socket(
+                _socket.AF_UNIX, _socket.SOCK_STREAM)
+            sock_path = config['address']
+            if _os.path.exists(sock_path):
+                _os.unlink(sock_path)
+            self._socket.bind(sock_path)
+        else:
+            self._log.info(
+                "  Server: %s %d %s",
+                self._config['address'],
+                self._config['port'],
+                self._protocol)
+            if self._protocol == 'SSL':
+                self._ssl_context = self._create_ssl_context()
+            self._socket = _socket.socket(
+                _socket.AF_INET, _socket.SOCK_STREAM, _socket.IPPROTO_TCP)
+            self._socket.setsockopt(
+                _socket.SOL_SOCKET, _socket.SO_REUSEADDR, 1)
+            self._socket.bind((config['address'], config['port']))
         self._socket.listen(1)
 
     def __del__(self):
@@ -70,6 +86,8 @@ def _create_ssl_context(self):
     def _client_connect(self):
         """connect to client, will accept waiting connection"""
         sock, addr = self._socket.accept()
+        if self._protocol == 'SOCKET':
+            addr = (self._config['address'],)
         kwargs = {
             'connection': (sock, addr),
             'ser': self._serial,
@@ -82,7 +100,8 @@ def _client_connect(self):
         try:
             connection = self.CONNECTIONS[self._protocol](**kwargs)
         except _connection_ssl.SslHandshakeError as err:
-            self._log.info("Client rejected: %s:%d (%s)", *addr, err)
+            self._log.info(
+                "Client rejected: %s:%d (%s)", addr[0], addr[1], err)
             if not self._connections:
                 self._serial.disconnect()
             return
@@ -102,6 +121,10 @@ def close(self):
             self.close_connections()
             self._socket.close()
             self._socket = None
+            if self._protocol == 'SOCKET':
+                sock_path = self._config['address']
+                if _os.path.exists(sock_path):
+                    _os.unlink(sock_path)
 
     def has_connections(self):
         """True if server has some connections"""
@@ -138,9 +161,9 @@ def process_read(self, read_sockets):
                 data = b''
                 try:
                     data = con.socket().recv(4096)
-                    self._log.debug("(%s:%d): %s", *con.get_address(), data)
+                    self._log.debug("(%s): %s", con.address_str(), data)
                 except (ConnectionResetError, _ssl.SSLError) as err:
-                    self._log.info("(%s:%d): %s", *con.get_address(), err)
+                    self._log.info("(%s): %s", con.address_str(), err)
                 if not data:
                     self._remove_connection(con)
                     continue
@@ -153,15 +176,15 @@ def process_write(self, write_sockets):
                 result = con.flush()
                 if result is None:
                     self._log.info(
-                        "(%s:%d): write error", *con.get_address())
+                        "(%s): write error", con.address_str())
                     self._remove_connection(con)
 
     def process_stale(self):
         """Remove stale connections (send timeout expired)"""
         for con in list(self._connections):
             if con.is_stale():
                 self._log.info(
-                    "(%s:%d): send timeout", *con.get_address())
+                    "(%s): send timeout", con.address_str())
                 self._remove_connection(con)
 
     def send(self, data):

tests/test_connection_ssl.py

@@ -67,7 +67,7 @@ def test_log_connected_shows_ssl(self):
         self.assertEqual(
             first_call,
             unittest.mock.call(
-                "Client connected: %s:%d SSL", '127.0.0.1', 12345))
+                "Client connected: %s SSL", '127.0.0.1:12345'))
         conn.close()
 
     def test_on_received_forwards_to_serial(self):