Small fixes (#110)

* Ensure system title in GGC APDU is in bytes

* Fix issues #79 #93 #101 #105

* Fix license metadata in setup.py

Author: Krolken

HISTORY.md

@@ -14,15 +14,33 @@ and this project adheres to [Calendar Versioning](https://calver.org/)
    layer can be disconnected right away.
 
 ### Changed
+* Renamed `TcpTransport` to `IPTransport` to reflect IP-wrapper semantics and kept
+  `TcpTransport` as a backward-compatible alias.
 
 ### Deprecated
 
 ### Removed
 
 ### Fixed
+* Fixed RLRQ context handling so unciphered associations omit user information, and
+  ciphered associations reuse the original proposed xDLMS context from AARQ.
+* Fixed HDLC transport timeout handling so repeated empty serial reads no longer loop
+  forever and now raise a communication timeout error.
+* Implemented encoding and parsing rules for `DateData` and `TimeData`, including
+  support for `datetime` inputs and all-ones wildcard values mapping to `None`.
+* Corrected package metadata license in `setup.py` to match the Business Source
+  License 1.1 used by the project.
 
 ### Security
 
+## 25.1.0 - 2025-03-26
+
+### Added
+* `use_rlrq_rlre` added to DlmsConnectionSettings with default to `True`. If `False` no ReleaseRequest is sent to 
+  server/device and lower layer can be disconnected right away.
+
+### Fixed
+* Missing imports in io.py
 
 ## 24.1.0 - 2024-01-22
 

README.md

@@ -49,19 +49,20 @@ A simple example of reading invocation counters using a public client:
 
 ```python
 from dlms_cosem.client import DlmsClient
-from dlms_cosem.io import TcpTransport, BlockingTcpIO
+from dlms_cosem.io import IPTransport, BlockingTcpIO
 from dlms_cosem.security import NoSecurityAuthentication
 from dlms_cosem import enumerations, cosem
 
 tcp_io = BlockingTcpIO(host="localhost", port=4059)
-tcp_transport = TcpTransport(io=tcp_io, server_logical_address=1, client_logical_address=16)
-client = DlmsClient(transport=tcp_transport, authentication=NoSecurityAuthentication())
+ip_transport = IPTransport(io=tcp_io, server_logical_address=1, client_logical_address=16)
+client = DlmsClient(transport=ip_transport, authentication=NoSecurityAuthentication())
 with client.session() as dlms_client:
     data = dlms_client.get(
         cosem.CosemAttribute(interface=enumerations.CosemInterface.DATA,
                              instance=cosem.Obis(0, 0, 0x2B, 1, 0), attribute=2, ))
 ```
 
+`TcpTransport` is kept as a backward-compatible alias of `IPTransport`.
 
 Look at the different files in the `examples` folder get a better feel on how to fully
 use the library.

devscripts/read_data_into_csv.py

@@ -0,0 +1,166 @@
+import csv
+import logging
+from datetime import datetime, timedelta, timezone
+from pprint import pprint
+from time import sleep
+
+from dateutil import parser as dateparser
+
+from dlms_cosem.utils import parse_as_dlms_data
+from dlms_cosem import a_xdr, cosem, enumerations
+from dlms_cosem.security import (
+    NoSecurityAuthentication,
+    HighLevelSecurityGmacAuthentication,
+)
+from dlms_cosem.client import DlmsClient
+from dlms_cosem.io import BlockingTcpIO, TcpTransport
+from dlms_cosem.cosem import selective_access
+from dlms_cosem.cosem.selective_access import RangeDescriptor
+from dlms_cosem.parsers import ProfileGenericBufferParser
+from dlms_cosem.protocol.xdlms.conformance import Conformance
+
+# set up logging so you get a bit nicer printout of what is happening.
+logging.basicConfig(
+    level=logging.DEBUG,
+    format="%(asctime)s,%(msecs)d : %(levelname)s : %(message)s",
+    datefmt="%H:%M:%S",
+)
+
+c = Conformance(
+    general_protection=False,
+    general_block_transfer=False,
+    delta_value_encoding=False,
+    attribute_0_supported_with_set=False,
+    priority_management_supported=False,
+    attribute_0_supported_with_get=False,
+    block_transfer_with_get_or_read=True,
+    block_transfer_with_set_or_write=False,
+    block_transfer_with_action=True,
+    multiple_references=True,
+    data_notification=False,
+    access=False,
+    get=True,
+    set=True,
+    selective_access=True,
+    event_notification=False,
+    action=True,
+)
+
+encryption_key = bytes.fromhex("990EB3136F283EDB44A79F15F0BFCC21")
+authentication_key = bytes.fromhex("EC29E2F4BD7D697394B190827CE3DD9A")
+auth = enumerations.AuthenticationMechanism.HLS_GMAC
+host = "100.119.108.3"
+port = 4059
+
+
+tcp_io = BlockingTcpIO(host=host, port=port)
+public_tcp_transport = TcpTransport(
+    client_logical_address=16,
+    server_logical_address=1,
+    io=tcp_io,
+)
+public_client = DlmsClient(
+    transport=public_tcp_transport, authentication=NoSecurityAuthentication()
+)
+
+
+with public_client.session() as client:
+
+    response_data = client.get(
+        cosem.CosemAttribute(
+            interface=enumerations.CosemInterface.DATA,
+            instance=cosem.Obis(0, 0, 0x2B, 1, 0),
+            attribute=2,
+        )
+    )
+    data_decoder = a_xdr.AXdrDecoder(
+        encoding_conf=a_xdr.EncodingConf(
+            attributes=[a_xdr.Sequence(attribute_name="data")]
+        )
+    )
+    invocation_counter = data_decoder.decode(response_data)["data"]
+    print(f"meter_initial_invocation_counter = {invocation_counter}")
+
+# we are not reusing the socket as of now. We just need to give the meter some time to
+# close the connection on its side
+sleep(2)
+
+tcp_io = BlockingTcpIO(host=host, port=port)
+management_tcp_transport = TcpTransport(
+    client_logical_address=1,
+    server_logical_address=1,
+    io=tcp_io,
+)
+
+management_client = DlmsClient(
+    transport=management_tcp_transport,
+    authentication=HighLevelSecurityGmacAuthentication(challenge_length=32),
+    encryption_key=encryption_key,
+    authentication_key=authentication_key,
+    client_initial_invocation_counter=invocation_counter + 1,
+)
+
+
+with management_client.session() as client:
+    read_to = dateparser.parse("2024-08-15T00:00:00-01:00")
+    read_from = read_to - timedelta(days=500)
+    profile = client.get(
+        cosem.CosemAttribute(
+            interface=enumerations.CosemInterface.PROFILE_GENERIC,
+            instance=cosem.Obis(1, 0, 99, 2, 0),
+            attribute=2,
+        ),
+        access_descriptor=RangeDescriptor(
+            restricting_object=selective_access.CaptureObject(
+                cosem_attribute=cosem.CosemAttribute(
+                    interface=enumerations.CosemInterface.CLOCK,
+                    instance=cosem.Obis.from_string("0.0.1.0.0.255"),
+                    attribute=2,
+                ),
+                data_index=0,
+            ),
+            from_value=read_from,
+            to_value=read_to,
+        ),
+    )
+
+    time_error = datetime.now(tz=timezone.utc) - read_to
+
+
+    parser = ProfileGenericBufferParser(
+        capture_objects=[
+            cosem.CosemAttribute(
+                interface=enumerations.CosemInterface.CLOCK,
+                instance=cosem.Obis(0, 0, 1, 0, 0, 255),
+                attribute=2,
+            ),
+            cosem.CosemAttribute(
+                interface=enumerations.CosemInterface.DATA,
+                instance=cosem.Obis(0, 0, 96, 10, 1, 255),
+                attribute=2,
+            ),
+            cosem.CosemAttribute(
+                interface=enumerations.CosemInterface.REGISTER,
+                instance=cosem.Obis(1, 0, 1, 8, 0, 255),
+                attribute=2,
+            ),
+            cosem.CosemAttribute(
+                interface=enumerations.CosemInterface.REGISTER,
+                instance=cosem.Obis(1, 0, 2, 8, 0, 255),
+                attribute=2,
+            ),
+        ],
+        capture_period=60,
+    )
+    #result = parser.parse_bytes(profile)
+    result=None
+    pprint(profile)
+    data = parse_as_dlms_data(profile)
+
+
+    with open("data_output.csv", "w", newline="") as csvfile:
+        writer = csv.DictWriter(csvfile, fieldnames=["value"])
+        writer.writeheader()
+        for row in data:
+            writer.writerow({"value": row[2]})
+

dlms_cosem/connection.py

@@ -209,6 +209,13 @@ class DlmsConnection:
         )
     )
 
+    # Keep a copy of the context proposed in AARQ so the same context can be reused in
+    # RLRQ when ciphering is enabled.
+    proposed_initiate_request: Optional[xdlms.InitiateRequest] = attr.ib(
+        default=None,
+        init=False,
+    )
+
     settings: DlmsConnectionSettings = attr.ib(
         default=DlmsConnectionSettings(),
         converter=attr.converters.default_if_none(factory=DlmsConnectionSettings),
@@ -291,6 +298,7 @@ def send(self, event) -> bytes:
             )
 
         self.state.process_event(event)
+        self.register_proposed_context(event)
         LOG.debug(f"Preparing to send DLMS Request", request=event)
 
         if self.use_protection:
@@ -398,6 +406,39 @@ def next_event(self):
     def clear_buffer(self):
         self.buffer = bytearray()
 
+    @staticmethod
+    def copy_initiate_request(
+        initiate_request: xdlms.InitiateRequest,
+    ) -> xdlms.InitiateRequest:
+        return xdlms.InitiateRequest(
+            proposed_conformance=Conformance(
+                **attr.asdict(initiate_request.proposed_conformance)
+            ),
+            proposed_quality_of_service=initiate_request.proposed_quality_of_service,
+            client_max_receive_pdu_size=initiate_request.client_max_receive_pdu_size,
+            proposed_dlms_version_number=initiate_request.proposed_dlms_version_number,
+            response_allowed=initiate_request.response_allowed,
+            dedicated_key=initiate_request.dedicated_key,
+        )
+
+    def register_proposed_context(self, event: Any) -> None:
+        """
+        Keep track of the context proposed in AARQ so it can be reused in RLRQ.
+        """
+        if not isinstance(event, acse.ApplicationAssociationRequest):
+            return
+
+        if not event.user_information:
+            self.proposed_initiate_request = None
+            return
+
+        if not isinstance(event.user_information.content, xdlms.InitiateRequest):
+            return
+
+        self.proposed_initiate_request = self.copy_initiate_request(
+            event.user_information.content
+        )
+
     @property
     def use_protection(self) -> bool:
         """
@@ -587,19 +628,33 @@ def get_aarq(self) -> acse.ApplicationAssociationRequest:
             user_information=acse.UserInformation(content=initiate_request),
         )
 
-    def get_rlrq(self) -> acse.ReleaseRequest:
+    def get_rlrq_initiate_request(self) -> xdlms.InitiateRequest:
         """
-        Returns a ReleaseRequestApdu to release the current association if one should be used.
+        Return the original context proposed in AARQ when available.
         """
 
-        initiate_request = xdlms.InitiateRequest(
+        if self.proposed_initiate_request is not None:
+            return self.copy_initiate_request(self.proposed_initiate_request)
+
+        return xdlms.InitiateRequest(
             proposed_conformance=self.conformance,
             client_max_receive_pdu_size=self.max_pdu_size,
         )
 
+    def get_rlrq(self) -> acse.ReleaseRequest:
+        """
+        Returns a ReleaseRequestApdu to release the current association if one should be used.
+        """
+
+        user_information = None
+
+        if self.use_protection:
+            initiate_request = self.get_rlrq_initiate_request()
+            user_information = acse.UserInformation(content=initiate_request)
+
         return acse.ReleaseRequest(
             reason=enums.ReleaseRequestReason.NORMAL,
-            user_information=acse.UserInformation(content=initiate_request),
+            user_information=user_information,
         )
 
     def update_negotiated_parameters(