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

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

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: python-snap7
-Version: 3.1.0
+Version: 3.1.2
 Summary: Pure Python S7 communication library for Siemens PLCs
 Author-email: Gijs Molenaar <gijsmolenaar@gmail.com>
-License: MIT
+License-Expression: MIT
 Project-URL: Homepage, https://github.com/gijzelaerr/python-snap7
 Project-URL: Documentation, https://python-snap7.readthedocs.io/en/latest/
 Keywords: snap7,s7,siemens,plc

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

@@ -1,10 +1,10 @@
-python_snap7-3.1.0.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=IIWtZ1nwblUZY1Zn0zyLmVQUnp33K0cxl8xVu887Fgs,43911
+snap7/async_client.py,sha256=kc4OT8ZcBpTg3DBd9qEfi3yFlPBOX_EiEVkJV9ZAlRU,44560
 snap7/cli.py,sha256=Td7z1O0gV7t-w9umUaX91MHGw-HuXYEDHKgtUO-9d3Q,13755
-snap7/client.py,sha256=ZKDM20dZ55EP-kEyncqjdq8oxB7M5ckgXtKrmFsN8Iw,95429
-snap7/client_base.py,sha256=2fKWy7eczyr-tdGQswH_USTdDdeIrdyTTQ_1F8LRAyU,7435
-snap7/connection.py,sha256=Aeo5ckyFEUR5cpJO88LZENzGitdKlkWdx7LB2tyQkXA,17643
+snap7/client.py,sha256=wOy7-BzAIl9atE-uYWxEDvUo_HHrhCsRj8vhdMbhQVg,97264
+snap7/client_base.py,sha256=0e1mAU6qsskzMBSYPjccSClznf4jpTNzYGlvGpCC0Cs,7716
+snap7/connection.py,sha256=b2O8iKWQUWoL2n1hJ14TSjIjHh0EWDK8dDvAqND8PR0,18064
 snap7/datatypes.py,sha256=zJgPasEV79_H4qHabivIxYX50j74pNg64apBppAKI2Y,11205
 snap7/demo.py,sha256=JWSKLj2QPIXeSFTZSXuADAJzWVKls712MUZnuqwNkNs,17376
 snap7/discovery.py,sha256=LONPYg83b2quKXht6y_GTTArdxitjD8DoGyaHfe9B1w,3964
@@ -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=I4Tk3IwPjQLVokrp3lOgGLoTwLRTNY6mTrWGSOHOrAM,100283
+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=-rsgcczCYzc1Z_t98Q9_2LriQQipYji9T-VIsg_2lWs,24393
-snap7/util/setters.py,sha256=wi8MrABiGbnsqSj1NYjK5aTtcRVS0NbAHQXP6lLjAVg,27454
+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.0.dist-info/METADATA,sha256=TiHXRRAXn75UcFn9PpNAzDbXQmetvpYH0cDZ8Vvkogk,4652
-python_snap7-3.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
-python_snap7-3.1.0.dist-info/entry_points.txt,sha256=IPZyYr1lKyavXXpAc4xO505afTGwTY8GmNFuy5lsSiM,75
-python_snap7-3.1.0.dist-info/top_level.txt,sha256=VpFXm1w5_73qgJEIN_5OzQWINHyYJBtNoOW4DMoizgw,6
-python_snap7-3.1.0.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,,

{python_snap7-3.1.0.dist-info → python_snap7-3.1.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (83.0.0)
+Generator: setuptools (84.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

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
 
@@ -389,7 +397,7 @@ class AsyncClient(ClientMixin):
         self.slot = slot
         self._params[Parameter.RemotePort] = tcp_port
 
-        self.remote_tsap = 0x0100 | (rack << 5) | slot
+        self.remote_tsap = (self.connection_type << 8) | (rack << 5) | slot
 
         try:
             start_time = time.time()
@@ -1159,7 +1167,11 @@ class AsyncClient(ClientMixin):
         if response.get("parameters"):
             params = response["parameters"]
             if "pdu_length" in params:
-                self.pdu_length = params["pdu_length"]
+                negotiated = params["pdu_length"]
+                if negotiated < 64:
+                    logger.warning(f"Server negotiated implausible PDU length {negotiated}, using minimum 240")
+                    negotiated = 240
+                self.pdu_length = negotiated
                 self._params[Parameter.PDURequest] = self.pdu_length
                 logger.info(f"Negotiated PDU length: {self.pdu_length}")
 

snap7/client.py

@@ -52,7 +52,7 @@ _VALID_AREA_VALUES: frozenset[int] = frozenset(a.value for a in Area)
 logger = logging.getLogger(__name__)
 
 
-def _decode_tag(tag: Tag, data: bytearray) -> Any:
+def _decode_tag(tag: Tag, data: bytearray, encoding: str = "latin-1") -> Any:
     """Decode a Tag's raw bytes into a typed Python value."""
     upper = tag.datatype.upper()
     # Variable-length string types
@@ -60,9 +60,9 @@ def _decode_tag(tag: Tag, data: bytearray) -> Any:
     if match:
         kind, length = match.group(1), int(match.group(2))
         if kind == "FSTRING":
-            return util.get_fstring(data, 0, length)
+            return util.get_fstring(data, 0, length, encoding=encoding)
         if kind == "STRING":
-            return util.get_string(data, 0)
+            return util.get_string(data, 0, encoding=encoding)
         if kind == "WSTRING":
             return util.get_wstring(data, 0)
 
@@ -129,17 +129,17 @@ def _decode_scalar(datatype: str, data: bytearray, bit: int) -> Any:
     raise ValueError(f"Unsupported tag datatype: {datatype}")
 
 
-def _encode_tag(tag: Tag, buf: bytearray, value: Any) -> None:
+def _encode_tag(tag: Tag, buf: bytearray, value: Any, encoding: str = "latin-1") -> None:
     """Encode a typed Python value into a Tag's byte buffer."""
     upper = tag.datatype.upper()
     match = _STRING_RE.match(upper)
     if match:
         kind, length = match.group(1), int(match.group(2))
         if kind == "FSTRING":
-            util.set_fstring(buf, 0, value, length)
+            util.set_fstring(buf, 0, value, length, encoding=encoding)
             return
         if kind == "STRING":
-            util.set_string(buf, 0, value, length)
+            util.set_string(buf, 0, value, length, encoding=encoding)
             return
         if kind == "WSTRING":
             util.set_wstring(buf, 0, value, length)
@@ -656,7 +656,7 @@ class Client(ClientMixin):
         self._params[Parameter.RemotePort] = port
 
         # Remote TSAP targets the gateway rack/slot
-        self.remote_tsap = 0x0100 | (router_rack << 5) | router_slot
+        self.remote_tsap = (self.connection_type << 8) | (router_rack << 5) | router_slot
 
         try:
             start_time = time.time()
@@ -780,7 +780,7 @@ class Client(ClientMixin):
             struct.pack_into(fmt, data, i * item_size, v)
         return self.db_write(db_number, start, data)
 
-    def read_tag(self, tag: "Union[Tag, str]") -> Any:
+    def read_tag(self, tag: "Union[Tag, str]", encoding: str = "latin-1") -> Any:
         """Read a typed value by :class:`~snap7.tags.Tag` or address string.
 
         Accepts a :class:`~snap7.tags.Tag` or a PLC4X-style address string
@@ -788,6 +788,8 @@ class Client(ClientMixin):
 
         Args:
             tag: A :class:`~snap7.tags.Tag` instance or a parseable address string.
+            encoding: Character encoding for STRING/FSTRING values (default ``"latin-1"``).
+                Use ``"gbk"`` for Chinese PLCs or ``"utf-8"`` for UTF-8 encoded strings.
 
         Returns:
             The typed value (bool/int/float/datetime/str depending on type).
@@ -798,6 +800,7 @@ class Client(ClientMixin):
             client.read_tag("DB1.DBD4:REAL")              # float
             client.read_tag("DB1:20:STRING[30]")          # variable-length string
             client.read_tag(Tag(Area.DB, 1, 0, "REAL"))   # from Tag instance
+            client.read_tag("DB1:34:STRING[10]", encoding="gbk")  # Chinese string
         """
         resolved = Tag.from_string(tag) if isinstance(tag, str) else tag
         if resolved.is_symbolic:
@@ -805,14 +808,15 @@ class Client(ClientMixin):
                 "Symbolic (LID-based) tag access requires S7CommPlus. Use s7.Client instead of snap7.Client."
             )
         data = self.read_area(Area(resolved.area), resolved.db_number, resolved.byte_offset, resolved.size)
-        return _decode_tag(resolved, bytearray(data))
+        return _decode_tag(resolved, bytearray(data), encoding=encoding)
 
-    def write_tag(self, tag: "Union[Tag, str]", value: Any) -> int:
+    def write_tag(self, tag: "Union[Tag, str]", value: Any, encoding: str = "latin-1") -> int:
         """Write a typed value by :class:`~snap7.tags.Tag` or address string.
 
         Args:
             tag: A :class:`~snap7.tags.Tag` instance or a parseable address string.
             value: The value to write (type must match the tag's datatype).
+            encoding: Character encoding for STRING/FSTRING values (default ``"latin-1"``).
 
         Returns:
             0 on success.
@@ -828,10 +832,10 @@ class Client(ClientMixin):
         if resolved.datatype.upper() == "BOOL":
             current = self.read_area(Area(resolved.area), resolved.db_number, resolved.byte_offset, 1)
             buf[0] = current[0]
-        _encode_tag(resolved, buf, value)
+        _encode_tag(resolved, buf, value, encoding=encoding)
         return self.write_area(Area(resolved.area), resolved.db_number, resolved.byte_offset, buf)
 
-    def read_tags(self, tags: "list[Union[Tag, str]]") -> list[Any]:
+    def read_tags(self, tags: "list[Union[Tag, str]]", encoding: str = "latin-1") -> list[Any]:
         """Read multiple tags in a single optimized request.
 
         Uses the multi-variable read optimizer when available to batch
@@ -839,6 +843,7 @@ class Client(ClientMixin):
 
         Args:
             tags: List of :class:`~snap7.tags.Tag` instances or address strings.
+            encoding: Character encoding for STRING/FSTRING values (default ``"latin-1"``).
 
         Returns:
             List of decoded values in the same order as input.
@@ -846,7 +851,7 @@ class Client(ClientMixin):
         resolved = [Tag.from_string(t) if isinstance(t, str) else t for t in tags]
         items = [{"area": Area(t.area), "db_number": t.db_number, "start": t.byte_offset, "size": t.size} for t in resolved]
         _code, data_list = self.read_multi_vars(items)
-        return [_decode_tag(t, bytearray(d)) for t, d in zip(resolved, data_list)]
+        return [_decode_tag(t, bytearray(d), encoding=encoding) for t, d in zip(resolved, data_list)]
 
     def db_read(self, db_number: int, start: int, size: int) -> bytearray:
         """
@@ -1289,8 +1294,13 @@ class Client(ClientMixin):
 
     def _execute_packets_sequential(self, packet_requests: list[Tuple[int, bytes, ReadPacket]]) -> None:
         """Execute multi-block packets one at a time."""
-        for _, request, packet in packet_requests:
-            response = self._send_receive(request)
+        for _, _request, packet in packet_requests:
+            block_specs = [(blk.area, blk.db_number, blk.start_offset, blk.byte_length) for blk in packet.blocks]
+
+            def build_request(specs: list[tuple[int, int, int, int]] = block_specs) -> bytes:
+                return self.protocol.build_multi_read_request(specs)
+
+            response = self._send_receive_with_reconnect(build_request)
             block_data_list = self.protocol.extract_multi_read_data(response, len(packet.blocks))
             for blk, buf in zip(packet.blocks, block_data_list):
                 blk.buffer = buf
@@ -1299,9 +1309,20 @@ class Client(ClientMixin):
         """Execute multi-block packets using parallel dispatch.
 
         Sends up to *max_parallel* PDUs back-to-back before reading
-        responses, reducing round-trip overhead.
+        responses, reducing round-trip overhead.  Falls back to
+        sequential reconnect-aware execution on connection loss.
         """
-        # Process in chunks of max_parallel
+        try:
+            self._execute_packets_parallel_inner(packet_requests)
+        except (S7ConnectionError, OSError) as e:
+            if not self._auto_reconnect:
+                raise
+            logger.warning(f"Connection lost during parallel read: {e}")
+            self._do_reconnect()
+            self._execute_packets_sequential(packet_requests)
+
+    def _execute_packets_parallel_inner(self, packet_requests: list[Tuple[int, bytes, ReadPacket]]) -> None:
+        """Inner parallel dispatch without reconnect handling."""
         for chunk_start in range(0, len(packet_requests), self.max_parallel):
             chunk = packet_requests[chunk_start : chunk_start + self.max_parallel]
             requests = [(pkt_idx, pdu) for pkt_idx, pdu, _ in chunk]
@@ -2641,7 +2662,11 @@ class Client(ClientMixin):
         if response.get("parameters"):
             params = response["parameters"]
             if "pdu_length" in params:
-                self.pdu_length = params["pdu_length"]
+                negotiated = params["pdu_length"]
+                if negotiated < 64:
+                    logger.warning(f"Server negotiated implausible PDU length {negotiated}, using minimum 240")
+                    negotiated = 240
+                self.pdu_length = negotiated
                 self._params[Parameter.PDURequest] = self.pdu_length
                 logger.info(f"Negotiated PDU length: {self.pdu_length}")
 

snap7/client_base.py

@@ -224,16 +224,22 @@ class ClientMixin:
 
         Calculated as PDU length minus overhead:
         12 bytes S7 header + 2 bytes param + 4 bytes data header = 18 bytes.
+
+        Returns at least 1 to prevent infinite loops in chunked reads
+        when the server negotiates an implausibly small PDU.
         """
-        return self.pdu_length - 18
+        return max(1, self.pdu_length - 18)
 
     def _max_write_size(self) -> int:
         """Maximum payload bytes for a single write request.
 
         Calculated as PDU length minus overhead:
         12 bytes S7 header + 14 bytes param + 4 bytes data header + 5 bytes padding = 35 bytes.
+
+        Returns at least 1 to prevent infinite loops in chunked writes
+        when the server negotiates an implausibly small PDU.
         """
-        return self.pdu_length - 35
+        return max(1, self.pdu_length - 35)
 
     def _map_area(self, area: Area) -> S7Area:
         """Map library area enum to native S7 area."""

snap7/connection.py

@@ -371,11 +371,19 @@ class ISOTCPConnection:
             if param_code == self.COTP_PARAM_PDU_SIZE:
                 # PDU Size parameter
                 if param_len == 1:
-                    # ISO 8073 code: size = 2^code
-                    self.pdu_size = 1 << param_data[0]
+                    # ISO 8073 code: size = 2^code, valid range 7-13
+                    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:
                     # Raw 2-byte value
-                    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}")
             else:
                 logger.debug(f"Unsupported COTP parameter: code={param_code:#04x}, length={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]:
@@ -816,9 +838,9 @@ class Server:
             word_len = addr.get("word_len", S7WordLen.BYTE)
 
             # Convert count to bytes
-            if word_len in (S7WordLen.TIMER, S7WordLen.COUNTER, S7WordLen.WORD):
+            if word_len in (S7WordLen.TIMER, S7WordLen.COUNTER, S7WordLen.WORD, S7WordLen.INT):
                 byte_count = count * 2
-            elif word_len in (S7WordLen.DWORD, S7WordLen.REAL):
+            elif word_len in (S7WordLen.DWORD, S7WordLen.REAL, S7WordLen.DINT):
                 byte_count = count * 4
             elif word_len == S7WordLen.BIT:
                 byte_count = 1
@@ -876,9 +898,9 @@ class Server:
                 word_len = addr_spec.get("word_len", S7WordLen.BYTE)
 
                 # Convert count to bytes based on word length
-                if word_len in [S7WordLen.TIMER, S7WordLen.COUNTER, S7WordLen.WORD]:
+                if word_len in [S7WordLen.TIMER, S7WordLen.COUNTER, S7WordLen.WORD, S7WordLen.INT]:
                     byte_count = count * 2  # 16-bit items
-                elif word_len in [S7WordLen.DWORD, S7WordLen.REAL]:
+                elif word_len in [S7WordLen.DWORD, S7WordLen.REAL, S7WordLen.DINT]:
                     byte_count = count * 4  # 32-bit items
                 elif word_len == S7WordLen.BIT:
                     byte_count = 1  # Single bit needs at least 1 byte
@@ -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")
@@ -2418,7 +2481,9 @@ class Server:
             block_num = ctx["block_num"]
             block_data = ctx["data"]
 
-            # Store block data
+            # Store block data — only into pre-registered areas.
+            # Reject downloads to unknown areas to prevent unbounded memory
+            # allocation from attacker-controlled block numbers.
             if block_type == 0x41:  # DB
                 area_key = (S7Area.DB, block_num)
                 if area_key in self.memory_areas:
@@ -2428,9 +2493,9 @@ class Server:
                         copy_len = min(len(block_data), len(existing_area))
                         existing_area[0:copy_len] = block_data[0:copy_len]
                 else:
-                    # Create new area
-                    self.memory_areas[area_key] = bytearray(block_data)
-                    self.area_locks[area_key] = threading.Lock()
+                    logger.warning(f"Download rejected: area DB{block_num} not registered")
+                    del self._download_contexts[client_address]
+                    return self._build_error_response(request, 0x8104)
 
             logger.info(f"Download ended from {client_address}: stored {len(block_data)} bytes to {block_type:#02x}:{block_num}")
 
@@ -2486,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
@@ -2493,6 +2561,9 @@ class ServerISOConnection:
     COTP_DC = 0xC0  # Disconnect Confirm
     COTP_DT = 0xF0  # Data Transfer
 
+    # COTP parameter code for TPDU size (ISO 8073)
+    COTP_PARAM_PDU_SIZE = 0xC0
+
     def __init__(self, client_socket: socket.socket):
         """Initialize server ISO connection."""
         self.socket = client_socket
@@ -2500,19 +2571,25 @@ class ServerISOConnection:
         self.connected = False
         self.src_ref = 0x0001  # Server reference
         self.dst_ref = 0x0000  # Client reference (assigned during handshake)
+        self.tpdu_size = 0x0A  # Default: 1024 bytes (2^10)
 
     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):
@@ -2532,25 +2609,46 @@ class ServerISOConnection:
             return False
 
     def receive_data(self) -> bytes:
-        """Receive data from client."""
-        # Receive TPKT header (4 bytes)
-        tpkt_header = self._recv_exact(4)
+        """Receive data from client.
+
+        Reassembles COTP DT fragments by reading frames until the EOT
+        bit (bit 7 of the third COTP header byte) is set, then returns
+        the concatenated payload.
+        """
+        fragments: list[bytes] = []
+        total_size = 0
+        deadline = time.monotonic() + self.RECEIVE_DEADLINE
+        while True:
+            tpkt_header = self._recv_exact(4, deadline)
+            version, reserved, length = struct.unpack(">BBH", tpkt_header)
+
+            if version != 3:
+                raise S7ConnectionError(f"Invalid TPKT version: {version}")
 
-        # Parse TPKT header
-        version, reserved, length = struct.unpack(">BBH", tpkt_header)
+            remaining = length - 4
+            if remaining <= 0:
+                raise S7ConnectionError("Invalid TPKT length")
 
-        if version != 3:
-            raise S7ConnectionError(f"Invalid TPKT version: {version}")
+            payload = self._recv_exact(remaining, deadline)
 
-        # Receive remaining data
-        remaining = length - 4
-        if remaining <= 0:
-            raise S7ConnectionError("Invalid TPKT length")
+            if len(payload) < 3:
+                raise S7ConnectionError("Invalid COTP DT: too short")
 
-        payload = self._recv_exact(remaining)
+            pdu_len, pdu_type, eot_num = struct.unpack(">BBB", payload[:3])
 
-        # Parse COTP header and extract data
-        return self._parse_cotp_data(payload)
+            if pdu_type != self.COTP_DT:
+                raise S7ConnectionError(f"Expected COTP DT, got {pdu_type:#02x}")
+
+            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
+
+        return b"".join(fragments)
 
     def send_data(self, data: bytes) -> None:
         """Send data to client."""
@@ -2578,29 +2676,68 @@ class ServerISOConnection:
         # Store client reference
         self.dst_ref = src_ref
 
+        # Parse variable parameters for TPDU size
+        offset = 7
+        while offset + 2 <= len(data):
+            param_code = data[offset]
+            param_len = data[offset + 1]
+            if offset + 2 + param_len > len(data):
+                break
+            if param_code == self.COTP_PARAM_PDU_SIZE and param_len == 1:
+                exponent = data[offset + 2]
+                if 7 <= exponent <= 13:
+                    self.tpdu_size = exponent
+                    logger.debug(f"Client requested TPDU size 2^{exponent} = {1 << exponent}")
+            offset += 2 + param_len
+
         logger.debug(f"Received COTP CR from client ref {src_ref}")
         return True
 
     def _build_cotp_cc(self) -> bytes:
-        """Build COTP Connection Confirm."""
-        # Basic COTP CC
+        """Build COTP Connection Confirm.
+
+        Includes the TPDU size parameter (0xC0) so clients know the
+        negotiated maximum segment size and don't fall back to the
+        ISO 8073 class-0 default of 128 bytes.
+        """
+        pdu_size_param = struct.pack(">BBB", self.COTP_PARAM_PDU_SIZE, 1, self.tpdu_size)
+        pdu_length = 6 + len(pdu_size_param)
         base_pdu = struct.pack(
-            ">BBHHB",
-            6,  # PDU length
+            ">BBBHHB",
+            pdu_length,  # PDU length
             self.COTP_CC,  # PDU type
+            0x00,  # Reserved / CDT
             self.dst_ref,  # Destination reference (client's source ref)
             self.src_ref,  # Source reference (our ref)
             0x00,  # Class/option
         )
 
-        return struct.pack(">B", 6) + base_pdu[1:]
+        return base_pdu + pdu_size_param
+
+    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
 
-    def _recv_exact(self, size: int) -> bytes:
-        """Receive exactly the specified number of bytes."""
         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)
@@ -2617,18 +2754,6 @@ class ServerISOConnection:
         header = struct.pack(">BBB", 2, self.COTP_DT, 0x80)
         return header + data
 
-    def _parse_cotp_data(self, cotp_pdu: bytes) -> bytes:
-        """Parse COTP Data Transfer PDU and extract S7 data."""
-        if len(cotp_pdu) < 3:
-            raise S7ConnectionError("Invalid COTP DT: too short")
-
-        pdu_len, pdu_type, eot_num = struct.unpack(">BBB", cotp_pdu[:3])
-
-        if pdu_type != self.COTP_DT:
-            raise S7ConnectionError(f"Expected COTP DT, got {pdu_type:#02x}")
-
-        return cotp_pdu[3:]  # Return data portion
-
 
 def mainloop(tcp_port: int = 1102, init_standard_values: bool = False) -> None:
     """

snap7/util/getters.py

@@ -149,17 +149,22 @@ def get_real(bytearray_: Buffer, byte_index: int) -> float:
     return real
 
 
-def get_fstring(bytearray_: Buffer, byte_index: int, max_length: int, remove_padding: bool = True) -> str:
+def get_fstring(
+    bytearray_: Buffer, byte_index: int, max_length: int, remove_padding: bool = True, encoding: str = "latin-1"
+) -> str:
     """Parse space-padded fixed-length string from bytearray
 
     Notes:
-        This function supports fixed-length ASCII strings, right-padded with spaces.
+        This function supports fixed-length strings, right-padded with spaces.
+        Use the ``encoding`` parameter to decode multi-byte strings (e.g. ``"gbk"``
+        for Chinese PLCs or ``"utf-8"``).
 
     Args:
         bytearray_: buffer from where to get the string.
         byte_index: byte index from where to start reading.
-        max_length: the maximum length of the string.
+        max_length: the maximum length of the string in bytes.
         remove_padding: whether to remove the right-padding.
+        encoding: character encoding used to decode the raw bytes (default ``"latin-1"``).
 
     Returns:
         String value.
@@ -171,8 +176,8 @@ def get_fstring(bytearray_: Buffer, byte_index: int, max_length: int, remove_pad
         >>> get_fstring(data, 0, 15, remove_padding=False)
         'hello world    '
     """
-    data = map(chr, bytearray_[byte_index : byte_index + max_length])
-    string = "".join(data)
+    raw = bytes(bytearray_[byte_index : byte_index + max_length])
+    string = raw.decode(encoding)
 
     if remove_padding:
         return string.rstrip(" ")
@@ -180,16 +185,19 @@ def get_fstring(bytearray_: Buffer, byte_index: int, max_length: int, remove_pad
         return string
 
 
-def get_string(bytearray_: Buffer, byte_index: int) -> str:
+def get_string(bytearray_: Buffer, byte_index: int, encoding: str = "latin-1") -> str:
     """Parse string from bytearray
 
     Notes:
         The first byte of the buffer will contain the max size posible for a string.
         The second byte contains the length of the string that contains.
+        Use the ``encoding`` parameter to decode multi-byte strings (e.g. ``"gbk"``
+        for Chinese PLCs or ``"utf-8"``).
 
     Args:
         bytearray_: buffer from where to get the string.
         byte_index: byte index from where to start reading.
+        encoding: character encoding used to decode the raw bytes (default ``"latin-1"``).
 
     Returns:
         String value.
@@ -210,8 +218,8 @@ def get_string(bytearray_: Buffer, byte_index: int) -> str:
             "String contains {str_length} chars, but max. {max_string_size} chars are expected or is "
             "larger than 254. Bytearray doesn't seem to be a valid string."
         )
-    data = map(chr, bytearray_[byte_index + 2 : byte_index + 2 + str_length])
-    return "".join(data)
+    raw = bytes(bytearray_[byte_index + 2 : byte_index + 2 + str_length])
+    return raw.decode(encoding)
 
 
 def get_dword(bytearray_: Buffer, byte_index: int) -> int:

snap7/util/setters.py

@@ -159,19 +159,20 @@ def set_real(bytearray_: Buffer, byte_index: int, real: Union[bool, str, float,
     return bytearray_
 
 
-def set_fstring(bytearray_: Buffer, byte_index: int, value: str, max_length: int) -> Buffer:
+def set_fstring(bytearray_: Buffer, byte_index: int, value: str, max_length: int, encoding: str = "latin-1") -> Buffer:
     """Set space-padded fixed-length string value
 
     Args:
         bytearray_: buffer to write to.
         byte_index: byte index to start writing from.
         value: string to write.
-        max_length: maximum string length, i.e. the fixed size of the string.
+        max_length: maximum string length in bytes, i.e. the fixed size of the string.
+        encoding: character encoding used to encode the string (default ``"latin-1"``).
 
     Raises:
         :obj:`TypeError`: if the `value` is not a :obj:`str`.
-        :obj:`ValueError`: if the length of the `value` is larger than the
-            ``max_size`` or ``value`` contains non-ASCII characters.
+        :obj:`ValueError`: if the encoded byte length of the `value` is larger than
+            ``max_length``.
 
     Examples:
         >>> data = bytearray(20)
@@ -179,38 +180,34 @@ def set_fstring(bytearray_: Buffer, byte_index: int, value: str, max_length: int
         >>> data
             bytearray(b'hello world    \x00\x00\x00\x00\x00')
     """
-    if not value.isascii():
-        raise ValueError("Value contains non-ascii values.")
-    # FAIL HARD WHEN trying to write too much data into PLC
-    size = len(value)
+    encoded = value.encode(encoding)
+    size = len(encoded)
     if size > max_length:
-        raise ValueError(f"size {size} > max_length {max_length} {value}")
+        raise ValueError(f"encoded byte size {size} > max_length {max_length} {value}")
 
-    # fill array with chr integers
-    for i, c in enumerate(value):
-        bytearray_[byte_index + i] = ord(c)
+    bytearray_[byte_index : byte_index + size] = encoded
 
-    # fill the rest with empty space
-    for r in range(len(value), max_length):
+    # fill the rest with spaces
+    for r in range(size, max_length):
         bytearray_[byte_index + r] = ord(" ")
 
     return bytearray_
 
 
-def set_string(bytearray_: Buffer, byte_index: int, value: str, max_size: int = 254) -> Buffer:
+def set_string(bytearray_: Buffer, byte_index: int, value: str, max_size: int = 254, encoding: str = "latin-1") -> Buffer:
     """Set string value
 
     Args:
         bytearray_: buffer to write to.
         byte_index: byte index to start writing from.
         value: string to write.
-        max_size: maximum possible string size, max. 254 as default.
+        max_size: maximum possible string size in bytes, max. 254 as default.
+        encoding: character encoding used to encode the string (default ``"latin-1"``).
 
     Raises:
         :obj:`TypeError`: if the `value` is not a :obj:`str`.
-        :obj:`ValueError`: if the length of the `value` is larger than the
-            ``max_size``, or ``max_size`` is greater than 254, or ``value``
-            contains characters with ordinal > 255.
+        :obj:`ValueError`: if the encoded byte length of the `value` is larger than the
+            ``max_size``, or ``max_size`` is greater than 254.
 
     Examples:
         >>> from snap7.util import set_string
@@ -225,29 +222,21 @@ def set_string(bytearray_: Buffer, byte_index: int, value: str, max_size: int =
     if max_size > 254:
         raise ValueError(f"max_size: {max_size} > max. allowed 254 chars")
 
-    if any(ord(char) < 0 or ord(char) > 255 for char in value):
-        raise ValueError(
-            "Value contains ascii values > 255, which is not compatible with PLC Type STRING. "
-            "Check encoding of value or try set_wstring()."
-        )
-
-    size = len(value)
-    # FAIL HARD WHEN trying to write too much data into PLC
+    encoded = value.encode(encoding)
+    size = len(encoded)
     if size > max_size:
-        raise ValueError(f"size {size} > max_size {max_size} {value}")
+        raise ValueError(f"encoded byte size {size} > max_size {max_size} {value}")
 
     # set max string size
     bytearray_[byte_index] = max_size
 
-    # set len count on first position
-    bytearray_[byte_index + 1] = len(value)
+    # set actual byte length
+    bytearray_[byte_index + 1] = size
 
-    # fill array with chr integers
-    for i, c in enumerate(value):
-        bytearray_[byte_index + 2 + i] = ord(c)
+    bytearray_[byte_index + 2 : byte_index + 2 + size] = encoded
 
-    # fill the rest with empty space
-    for r in range(len(value), bytearray_[byte_index]):
+    # fill the rest with spaces
+    for r in range(size, bytearray_[byte_index]):
         bytearray_[byte_index + 2 + r] = ord(" ")
 
     return bytearray_