python-snap7 3.1.1__py3-none-any.whl → 3.1.2__py3-none-any.whl

{python_snap7-3.1.1.dist-info → python_snap7-3.1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-snap7
-Version: 3.1.1
+Version: 3.1.2
 Summary: Pure Python S7 communication library for Siemens PLCs
 Author-email: Gijs Molenaar <gijsmolenaar@gmail.com>
 License-Expression: MIT

{python_snap7-3.1.1.dist-info → python_snap7-3.1.2.dist-info}/RECORD

@@ -1,6 +1,6 @@
-python_snap7-3.1.1.dist-info/licenses/LICENSE,sha256=PIihE_yP-8gc-ff9ikvQQPOa0biOCZ6Bc-6h3G3xRUQ,1097
+python_snap7-3.1.2.dist-info/licenses/LICENSE,sha256=PIihE_yP-8gc-ff9ikvQQPOa0biOCZ6Bc-6h3G3xRUQ,1097
 snap7/__init__.py,sha256=jWGpca2kG7gskQbcM5qoflWEyMMEJ7655kM0KxVVLaA,980
-snap7/async_client.py,sha256=7GwUslkmK27ADGrZ-BtF2UogbJbnzf6WOCLc-D2V3-8,44157
+snap7/async_client.py,sha256=kc4OT8ZcBpTg3DBd9qEfi3yFlPBOX_EiEVkJV9ZAlRU,44560
 snap7/cli.py,sha256=Td7z1O0gV7t-w9umUaX91MHGw-HuXYEDHKgtUO-9d3Q,13755
 snap7/client.py,sha256=wOy7-BzAIl9atE-uYWxEDvUo_HHrhCsRj8vhdMbhQVg,97264
 snap7/client_base.py,sha256=0e1mAU6qsskzMBSYPjccSClznf4jpTNzYGlvGpCC0Cs,7716
@@ -18,15 +18,15 @@ snap7/s7protocol.py,sha256=a-obZR5fLzHS1wHpZ88N37XxzYjKiS2JgK8SFi5qTjQ,57360
 snap7/szl.py,sha256=VPKNz8MCU7ok_Run-JVuwHKJSeGY-Wcj93SJu56tgtw,3898
 snap7/tags.py,sha256=Qh8dm6rDWcVnYhbSB_htrmqIAXsmWQWcDS8-wXqN_zE,27033
 snap7/type.py,sha256=-ad6v8vQP21DvWFtHCaSlk-BllFGPKOtbhprqKdOlJ0,9391
-snap7/server/__init__.py,sha256=t-BM4Iphw8j5BzCIPf5xOFQaYHQmuLh7X8F-lvDOkaU,101708
+snap7/server/__init__.py,sha256=4l5qeEO1LMSLU77c9ggo6FSK0NH_qs--Kdt7bcrGDv8,106197
 snap7/server/__main__.py,sha256=OdOgyMmFThjSe2jSgvlbkquGYnZcBW6wubs2ldhNSOE,1206
 snap7/util/__init__.py,sha256=d6n2oy7tNYke1ia0TUyWz_ni3l0XN1qvilM5sW0T-Es,1874
 snap7/util/db.py,sha256=geesYS2oyOuTADOJa2me1p1rqJVzPuLTCfye6JIeav0,27120
 snap7/util/getters.py,sha256=g-z6jve3JEQchsXzeS0ajn56cpVepq1nhbRpShAXD9I,24896
 snap7/util/setters.py,sha256=aTd-rrTS87G_tI0hAqNhyWv1T7U4eLxbKs5TkzEfpd0,27111
 snap7/util/symbols.py,sha256=L1dY7I1-HZ5Odtv6ZqGBeLppb3E5hjL64MyATT7XyEw,16454
-python_snap7-3.1.1.dist-info/METADATA,sha256=bZ_pI6rndBbgswfDxQqH5YGw8c0L2Rcw6i0Xs7fR4zc,4663
-python_snap7-3.1.1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-python_snap7-3.1.1.dist-info/entry_points.txt,sha256=IPZyYr1lKyavXXpAc4xO505afTGwTY8GmNFuy5lsSiM,75
-python_snap7-3.1.1.dist-info/top_level.txt,sha256=VpFXm1w5_73qgJEIN_5OzQWINHyYJBtNoOW4DMoizgw,6
-python_snap7-3.1.1.dist-info/RECORD,,
+python_snap7-3.1.2.dist-info/METADATA,sha256=di-S3uFMbV8bIQXkuriHZcQcrDnAUHvzVpxSBblcSJw,4663
+python_snap7-3.1.2.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+python_snap7-3.1.2.dist-info/entry_points.txt,sha256=IPZyYr1lKyavXXpAc4xO505afTGwTY8GmNFuy5lsSiM,75
+python_snap7-3.1.2.dist-info/top_level.txt,sha256=VpFXm1w5_73qgJEIN_5OzQWINHyYJBtNoOW4DMoizgw,6
+python_snap7-3.1.2.dist-info/RECORD,,

snap7/async_client.py

@@ -239,9 +239,17 @@ class AsyncISOTCPConnection:
             param_data = data[offset + 2 : offset + 2 + param_len]
             if param_code == self.COTP_PARAM_PDU_SIZE:
                 if param_len == 1:
-                    self.pdu_size = 1 << param_data[0]
+                    exponent = param_data[0]
+                    if 7 <= exponent <= 13:
+                        self.pdu_size = 1 << exponent
+                    else:
+                        logger.warning(f"Invalid COTP PDU size exponent {exponent}, using default")
                 elif param_len == 2:
-                    self.pdu_size = struct.unpack(">H", param_data)[0]
+                    raw = struct.unpack(">H", param_data)[0]
+                    if 128 <= raw <= 8192:
+                        self.pdu_size = raw
+                    else:
+                        logger.warning(f"Invalid COTP PDU size {raw}, using default")
                 logger.debug(f"Negotiated PDU size: {self.pdu_size}")
             offset += 2 + param_len
 

snap7/server/__init__.py

@@ -53,14 +53,18 @@ class Server:
         >>> server.stop()
     """
 
-    def __init__(self, log: bool = True, **kwargs: object) -> None:
+    def __init__(self, log: bool = True, max_clients: int = 64, **kwargs: object) -> None:
         """
         Initialize S7 server.
 
         Args:
             log: Enable event logging
+            max_clients: Maximum number of simultaneous client connections
             **kwargs: Ignored. Kept for backwards compatibility.
         """
+        if max_clients < 1:
+            raise ValueError("max_clients must be at least 1")
+
         self.server_socket: Optional[socket.socket] = None
         self.server_thread: Optional[threading.Thread] = None
         self.running = False
@@ -86,6 +90,7 @@ class Server:
         # Client connections
         self.clients: List[threading.Thread] = []
         self.client_lock = threading.Lock()
+        self.max_clients = max_clients
 
         # Event queue for pick_event
         self._event_queue: List[SrvEvent] = []
@@ -177,9 +182,13 @@ class Server:
 
         # Close all client connections
         with self.client_lock:
-            for client_thread in self.clients[:]:
-                if client_thread.is_alive():
-                    client_thread.join(timeout=1.0)
+            client_threads = self.clients[:]
+
+        for client_thread in client_threads:
+            if client_thread.is_alive():
+                client_thread.join(timeout=1.0)
+
+        with self.client_lock:
             self.clients.clear()
             self.client_count = 0
 
@@ -448,6 +457,10 @@ class Server:
         """
         if param == Parameter.LocalPort:
             self.port = value
+        elif param == Parameter.MaxClients:
+            if value < 1:
+                raise ValueError("MaxClients must be at least 1")
+            self.max_clients = value
         logger.debug(f"Set parameter {param} = {value}")
         return 0
 
@@ -481,7 +494,7 @@ class Server:
         param_values = {
             Parameter.LocalPort: self.port,
             Parameter.WorkInterval: 100,
-            Parameter.MaxClients: 1024,
+            Parameter.MaxClients: self.max_clients,
         }
         return param_values.get(param, 0)
 
@@ -579,6 +592,10 @@ class Server:
                     client_thread = threading.Thread(target=self._handle_client, args=(client_socket, address), daemon=True)
 
                     with self.client_lock:
+                        if self.client_count >= self.max_clients:
+                            logger.warning(f"Rejecting client {address}: maximum of {self.max_clients} clients reached")
+                            client_socket.close()
+                            continue
                         self.clients.append(client_thread)
                         self.client_count += 1
 
@@ -645,6 +662,11 @@ class Server:
                     self.clients.remove(current_thread)
                 self.client_count = max(0, self.client_count - 1)
 
+            if hasattr(self, "_download_contexts"):
+                self._download_contexts.pop(address, None)
+            if hasattr(self, "_upload_contexts"):
+                self._upload_contexts.pop(address, None)
+
             logger.info(f"Client {address} handler finished")
 
     def _process_request(self, request_data: bytes, client_address: Tuple[str, int]) -> Optional[bytes]:
@@ -2301,22 +2323,55 @@ class Server:
         try:
             raw_params = request.get("raw_parameters", b"")
 
-            # Parse block address from parameters
-            block_type = 0x41  # Default to DB
-            block_num = 1
+            # Parse and validate the target before allocating transfer state.
+            if len(raw_params) < 6:
+                return self._build_error_response(request, 0x8104)
 
-            if len(raw_params) >= 6:
-                addr_len = raw_params[5]
-                if len(raw_params) >= 6 + addr_len:
-                    block_addr = raw_params[6 : 6 + addr_len]
-                    try:
-                        block_type = int(block_addr[0:2], 16)
-                        block_num = int(block_addr[2:7])
-                    except (ValueError, IndexError):
-                        pass
+            addr_len = raw_params[4]
+            address_end = 5 + addr_len
+            if addr_len < 7 or len(raw_params) < address_end:
+                return self._build_error_response(request, 0x8104)
+
+            block_addr = raw_params[5:address_end]
+            try:
+                block_type = int(block_addr[0:2], 16)
+                block_num = int(block_addr[2:7])
+            except (ValueError, IndexError):
+                return self._build_error_response(request, 0x8104)
 
             logger.info(f"Request download from {client_address}: type={block_type:#02x}, num={block_num}")
 
+            if block_type != 0x41:  # Only DB downloads are implemented.
+                return self._build_error_response(request, 0x8104)
+
+            area_key = (S7Area.DB, block_num)
+            if area_key not in self.memory_areas:
+                logger.warning(f"Download rejected: area DB{block_num} not registered")
+                return self._build_error_response(request, 0x8104)
+
+            area_capacity = len(self.memory_areas[area_key])
+
+            # The request includes an ASCII block length. Reject an oversized
+            # transfer early, while still enforcing the limit on every chunk.
+            if len(raw_params) <= address_end:
+                return self._build_error_response(request, 0x8104)
+
+            length_len = raw_params[address_end]
+            length_start = address_end + 1
+            length_end = length_start + length_len
+            if not length_len or len(raw_params) < length_end:
+                return self._build_error_response(request, 0x8104)
+
+            try:
+                declared_size = int(raw_params[length_start:length_end])
+            except ValueError:
+                return self._build_error_response(request, 0x8104)
+            if declared_size < 0 or declared_size > area_capacity:
+                logger.warning(
+                    f"Download rejected: declared size {declared_size} outside DB{block_num} capacity 0..{area_capacity}"
+                )
+                return self._build_error_response(request, 0x8104)
+
             # Store download context
             if not hasattr(self, "_download_contexts"):
                 self._download_contexts: Dict[Tuple[str, int], Dict[str, Any]] = {}
@@ -2324,6 +2379,7 @@ class Server:
                 "block_type": block_type,
                 "block_num": block_num,
                 "data": bytearray(),
+                "max_size": declared_size,
             }
 
             # Build response acknowledging download
@@ -2370,7 +2426,14 @@ class Server:
             data_info = request.get("data", {})
             block_data = data_info.get("data", b"")
 
-            # Append data to context
+            # Bound accumulated data by the pre-registered target area. The
+            # final storage copy is not the only allocation: this bytearray is
+            # grown for every DOWNLOAD_BLOCK request.
+            if len(ctx["data"]) + len(block_data) > ctx["max_size"]:
+                logger.warning(f"Download rejected: data exceeds target capacity {ctx['max_size']}")
+                del self._download_contexts[client_address]
+                return self._build_error_response(request, 0x8104)
+
             ctx["data"].extend(block_data)
 
             logger.info(f"Download block from {client_address}: received {len(block_data)} bytes")
@@ -2488,6 +2551,9 @@ class Server:
 class ServerISOConnection:
     """ISO connection wrapper for server-side communication."""
 
+    RECEIVE_DEADLINE = 5.0
+    MAX_REASSEMBLED_SIZE = 1024 * 1024
+
     # COTP PDU types
     COTP_CR = 0xE0  # Connection Request
     COTP_CC = 0xD0  # Connection Confirm
@@ -2510,15 +2576,20 @@ class ServerISOConnection:
     def accept_connection(self) -> bool:
         """Accept ISO connection from client."""
         try:
+            deadline = time.monotonic() + self.RECEIVE_DEADLINE
+
             # Receive COTP Connection Request
-            tpkt_header = self._recv_exact(4)
+            tpkt_header = self._recv_exact(4, deadline)
             version, reserved, length = struct.unpack(">BBH", tpkt_header)
 
             if version != 3:
                 logger.error(f"Invalid TPKT version: {version}")
                 return False
+            if length < 4:
+                logger.error(f"Invalid TPKT length: {length}")
+                return False
 
-            payload = self._recv_exact(length - 4)
+            payload = self._recv_exact(length - 4, deadline)
 
             # Parse COTP Connection Request
             if not self._parse_cotp_cr(payload):
@@ -2545,8 +2616,10 @@ class ServerISOConnection:
         the concatenated payload.
         """
         fragments: list[bytes] = []
+        total_size = 0
+        deadline = time.monotonic() + self.RECEIVE_DEADLINE
         while True:
-            tpkt_header = self._recv_exact(4)
+            tpkt_header = self._recv_exact(4, deadline)
             version, reserved, length = struct.unpack(">BBH", tpkt_header)
 
             if version != 3:
@@ -2556,7 +2629,7 @@ class ServerISOConnection:
             if remaining <= 0:
                 raise S7ConnectionError("Invalid TPKT length")
 
-            payload = self._recv_exact(remaining)
+            payload = self._recv_exact(remaining, deadline)
 
             if len(payload) < 3:
                 raise S7ConnectionError("Invalid COTP DT: too short")
@@ -2566,7 +2639,11 @@ class ServerISOConnection:
             if pdu_type != self.COTP_DT:
                 raise S7ConnectionError(f"Expected COTP DT, got {pdu_type:#02x}")
 
-            fragments.append(payload[3:])
+            fragment = payload[3:]
+            total_size += len(fragment)
+            if total_size > self.MAX_REASSEMBLED_SIZE:
+                raise S7ConnectionError(f"Reassembled COTP request exceeds {self.MAX_REASSEMBLED_SIZE} bytes")
+            fragments.append(fragment)
 
             if eot_num & 0x80:
                 break
@@ -2637,12 +2714,30 @@ class ServerISOConnection:
 
         return base_pdu + pdu_size_param
 
-    def _recv_exact(self, size: int) -> bytes:
-        """Receive exactly the specified number of bytes."""
+    def _recv_exact(self, size: int, deadline: float | None = None) -> bytes:
+        """Receive exactly the specified bytes within one absolute deadline."""
+        if size < 0:
+            raise S7ConnectionError(f"Invalid receive size: {size}")
+
+        if deadline is None:
+            deadline = time.monotonic() + self.RECEIVE_DEADLINE
+
         data = bytearray()
 
         while len(data) < size:
-            chunk = self.socket.recv(size - len(data))
+            remaining_time = deadline - time.monotonic()
+            if remaining_time <= 0:
+                if data:
+                    raise S7ConnectionError("Receive deadline exceeded after partial frame")
+                raise TimeoutError("Receive deadline exceeded")
+
+            self.socket.settimeout(remaining_time)
+            try:
+                chunk = self.socket.recv(size - len(data))
+            except TimeoutError as e:
+                if data:
+                    raise S7ConnectionError("Receive deadline exceeded after partial frame") from e
+                raise
             if not chunk:
                 raise ConnectionResetError("Connection closed by peer")
             data.extend(chunk)