python-ipmi 0.5.4__py3-none-any.whl → 0.5.7__py3-none-any.whl

pyipmi/__init__.py

@@ -37,7 +37,7 @@ from . import msgs
 from .errors import IpmiTimeoutError, CompletionCodeError, RetryError
 from .msgs.registry import create_request_by_name
 from .session import Session
-from .utils import check_completion_code, is_string
+from .utils import check_rsp_completion_code, is_string
 
 try:
     from version import __version__
@@ -210,7 +210,7 @@ class Ipmi(bmc.Bmc, chassis.Chassis, dcmi.Dcmi, fru.Fru, picmg.Picmg, hpm.Hpm,
             setattr(req, key, value)
 
         rsp = self.send_message(req)
-        check_completion_code(rsp.completion_code)
+        check_rsp_completion_code(rsp)
         return rsp
 
     def raw_command(self, lun, netfn, raw_bytes):

pyipmi/bmc.py

@@ -24,6 +24,9 @@ class Bmc(object):
     def get_device_id(self):
         return DeviceId(self.send_message_with_name('GetDeviceId'))
 
+    def get_device_guid(self):
+        return DeviceGuid(self.send_message_with_name('GetDeviceGuid'))
+
     def cold_reset(self):
         self.send_message_with_name('ColdReset')
 
@@ -121,6 +124,7 @@ class DeviceId(State):
         string += ' ipmi: %s' % self.ipmi_version
         string += ' manufacturer: %d' % self.manufacturer_id
         string += ' product: %d' % self.product_id
+        string += ' functions: %s' % ','.join(self.supported_functions)
         return string
 
     def supports_function(self, name):
@@ -164,3 +168,14 @@ class DeviceId(State):
         self.aux = None
         if rsp.auxiliary is not None:
             self.aux = list(rsp.auxiliary)
+
+
+class DeviceGuid(State):
+    def __str__(self):
+        return 'Device GUID: %s' % self.device_guid_string
+
+    def _from_response(self, rsp):
+        self.device_guid = rsp.device_guid
+        self.device_guid_string = \
+            '%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-' \
+            '%02x%02x%02x%02x%02x%02x' % tuple(reversed(self.device_guid))

pyipmi/chassis.py

@@ -19,7 +19,7 @@ from enum import Enum
 
 
 from .msgs import create_request_by_name
-from .utils import check_completion_code, ByteBuffer
+from .utils import check_completion_code, check_rsp_completion_code, ByteBuffer
 from .state import State
 
 from .msgs.chassis import \
@@ -178,7 +178,7 @@ class Chassis(object):
         req.set_selector = set_selector
         req.block_selector = block_selector
         rsp = self.send_message(req)
-        check_completion_code(rsp.completion_code)
+        check_rsp_completion_code(rsp)
         return rsp.data
 
     def set_system_boot_options(self, parameter_selector, data,
@@ -188,7 +188,7 @@ class Chassis(object):
         req.parameter_selector.boot_option_parameter_selector = parameter_selector
         req.data = data
         rsp = self.send_message(req)
-        check_completion_code(rsp.completion_code)
+        check_rsp_completion_code(rsp)
 
     def get_boot_mode(self):
         """

pyipmi/constants.py

@@ -30,3 +30,6 @@ ENTITY_ID_PICMG_MICROTCA_CARRIER_HUB = 0xc2
 ENTITY_ID_PICMG_SHELF_MANAGEMENT_CONTROLLER = 0xf0
 ENTITY_ID_PICMG_FILTRATION_UNIT = 0xf1
 ENTITY_ID_PICMG_SHELF_FRU_INFORMATION = 0xf2
+ENTITY_ID_VITA_FRONT_BOARD = 0xa0
+ENTITY_ID_VITA_REAR_TRANSITION_MODULE = 0xc0
+ENTITY_ID_VITA_XMC = 0xc1

pyipmi/emulation.py

@@ -286,7 +286,7 @@ def handle_rmcp_ipmi_msg(context, sdu):
     ipmi_tx = rmcp.IpmiMsg(context.session)
     pdu = ipmi_tx.pack(tx_data)
 
-    if type(req) == pyipmi.msgs.device_messaging.CloseSessionReq:
+    if type(req) is pyipmi.msgs.device_messaging.CloseSessionReq:
         session.session_id = None
         session._auth_type = Session.AUTH_TYPE_NONE
         session._auth_username = None

pyipmi/errors.py

@@ -14,7 +14,7 @@
 # License along with this library; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
 
-from .msgs.constants import COMPLETION_CODE_DESCR
+from .msgs.constants import COMPLETION_CODE_DESCR, CC_ERR_CMD_SPECIFIC_DESC
 
 
 class DecodingError(Exception):
@@ -35,19 +35,26 @@ class IpmiTimeoutError(Exception):
 class CompletionCodeError(Exception):
     """IPMI completion code not OK."""
 
-    def __init__(self, cc, cmdid=None):
+    def __init__(self, cc, cmdid=None, netfn=None, group_extension=None):
         self.cc = cc
-        self.cc_desc = self.find_cc_desc(cc)
+        self.cc_desc = self.find_cc_desc(cc, cmdid, netfn, group_extension)
 
     def __str__(self):
         return "%s cc=0x%02x desc=%s" \
             % (self.__class__.__name__, self.cc, self.cc_desc)
 
     @staticmethod
-    def find_cc_desc(error_cc):
+    def find_cc_desc(error_cc, cmdid=None, netfn=None, group_extension=None):
+        # Search in global completion codes first
         for cc in COMPLETION_CODE_DESCR:
             if error_cc == cc[0]:
                 return cc[1]
+        # Then search in command specific completion codes
+        if cmdid is not None:
+            command_cc = CC_ERR_CMD_SPECIFIC_DESC.get((netfn, cmdid, group_extension), {})
+            descr = command_cc.get(error_cc, "Unknown error description")
+            return descr
+        # Completion code description not found
         return "Unknown error description"
 
 

pyipmi/fields.py

@@ -50,6 +50,18 @@ class VersionField(object):
         return ''.join("%s.%s" % (self.major, self.minor))
 
 
+def _unpack6bitascii(data):
+    """Unpack the 6bit ascii encoded string."""
+    string = ''
+    for i in range(0, len(data), 3):
+        d = data[i:i+3]
+        string += chr(0x20 + (d[0] & 0x3f))
+        string += chr(0x20 + (((d[0] & 0xc0) >> 6) | ((d[1] & 0xf) << 2)))
+        string += chr(0x20 + (((d[1] & 0xf0) >> 4) | ((d[2] & 0x3) << 4)))
+        string += chr(0x20 + ((d[2] & 0xfc) >> 2))
+    return string
+
+
 class TypeLengthString(object):
     """
     This is the TYPE/LENGTH BYTE FORMAT field represenation according the
@@ -82,12 +94,12 @@ class TypeLengthString(object):
 
         self.raw = data[offset+1:offset+1+self.length]
 
-        chr_data = ''.join([chr(c) for c in self.raw])
         if self.field_type == self.TYPE_BCD_PLUS:
-            self.string = chr_data.decode('bcd+')
+            self.string = self.raw.decode('bcd+')
         elif self.field_type == self.TYPE_6BIT_ASCII:
-            self.string = chr_data.decode('6bitascii')
+            self.string = _unpack6bitascii(self.raw)
         else:
+            chr_data = ''.join([chr(c) for c in self.raw])
             self.string = chr_data
 
 

pyipmi/helper.py

@@ -31,8 +31,8 @@ def get_sdr_chunk_helper(send_fn, req, reserve_fn, retry=5):
         if rsp.completion_code == constants.CC_OK:
             break
         elif rsp.completion_code == constants.CC_RES_CANCELED:
+            time.sleep(1)
             req.reservation_id = reserve_fn()
-            time.sleep(0.1)
             continue
         elif rsp.completion_code == constants.CC_TIMEOUT:
             time.sleep(0.1)

pyipmi/hpm.py

@@ -139,7 +139,9 @@ class Hpm(object):
                 raise HpmError('initiate_upgrade_action CC=0x%02x' % e.cc)
 
     def upload_firmware_block(self, block_number, data):
-        data = [ord(c) for c in data]
+        if isinstance(data, str):
+            data = [ord(c) for c in data]
+
         self.send_message_with_name('UploadFirmwareBlock', number=block_number,
                                     data=data)
 

pyipmi/interfaces/aardvark.py

@@ -37,7 +37,8 @@ class Aardvark(object):
     NAME = 'aardvark'
 
     def __init__(self, slave_address=0x20, port=0, serial_number=None,
-                 enable_i2c_pullups=None, enable_target_power=None):
+                 enable_i2c_pullups=None, enable_target_power=None,
+                 enable_fastmode=None):
         if pyaardvark is None:
             raise RuntimeError('No pyaardvark module found. You can not '
                                'use this interface.')
@@ -55,12 +56,23 @@ class Aardvark(object):
         if enable_target_power:
             self.enable_target_power(enable_target_power)
 
+        if enable_fastmode is not None:
+            self.enable_fastmode(enable_fastmode)
+        else:
+            self.enable_fastmode(False)
+
     def enable_pullups(self, enabled):
         self._dev.i2c_pullups = enabled
 
     def enable_target_power(self, enabled):
         self._dev.target_power = enabled
 
+    def enable_fastmode(self, enabled):
+        if enabled:
+            self._dev.i2c_bitrate = 400
+        else:
+            self._dev.i2c_bitrate = 100
+
     def raw_write(self, address, data):
         self._dev.i2c_master_write(address, data)
 

pyipmi/interfaces/ipmb.py

@@ -45,10 +45,6 @@ class IpmbHeader(object):
     *-------*--------------*----------*-------*---------------*-------*
     """
 
-    def __init__(self, data=None):
-        if data:
-            self.decode(data)
-
     rs_sa = None
     rs_lun = None
     rq_sa = None
@@ -58,6 +54,17 @@ class IpmbHeader(object):
     cmdid = None
     checksum = None
 
+    def __init__(self, data=None):
+        if data:
+            self.decode(data)
+
+    def __str__(self):
+        return f'rs_sa=0x{self.rs_sa:02x}, rs_lun={self.rs_lun}, ' \
+               f'rq_sa=0x{self.rq_sa:02x}, rq_lun={self.rq_lun}, ' \
+               f'rq_seq={self.rq_seq}, ' \
+               f'netfn=0x{self.netfn:02x}, ' \
+               f'cmdid=0x{self.cmdid:02x}'
+
 
 class IpmbHeaderReq(IpmbHeader):
     """Representation of the IPMI request message header."""
@@ -214,7 +221,8 @@ def decode_bridged_message(rx_data):
     return rx_data
 
 
-def rx_filter(header, data):
+def rx_filter(header, data, rq_sa=False, rs_sa=False, rq_lun=False,
+              rs_lun=True, rq_seq=True):
     """Check if the message in rx_data matches to the information in header.
 
     The following checks are done:
@@ -234,15 +242,26 @@ def rx_filter(header, data):
     checks = [
         (checksum(data[0:3]), 0, 'Header checksum failed'),
         (checksum(data[3:]), 0, 'payload checksum failed'),
-        # rsp_header.rq_sa, header.rq_sa, 'slave address mismatch'),
         (rsp_header.netfn, header.netfn | 1, 'NetFn mismatch'),
-        # rsp_header.rs_sa, header.rs_sa, 'target address mismatch'),
-        # rsp_header.rq_lun, header.rq_lun, 'request LUN mismatch'),
-        (rsp_header.rs_lun, header.rs_lun, 'responder LUN mismatch'),
-        (rsp_header.rq_seq, header.rq_seq, 'sequence number mismatch'),
         (rsp_header.cmdid, header.cmdid, 'command id mismatch'),
     ]
 
+    # optional checks
+    if rq_sa:
+        checks.append((rsp_header.rq_sa, header.rq_sa, 'slave address mismatch'))
+
+    if rs_sa:
+        checks.append((rsp_header.rs_sa, header.rs_sa, 'target address mismatch'))
+
+    if rq_lun:
+        checks.append((rsp_header.rq_lun, header.rq_lun, 'request LUN mismatch'))
+
+    if rs_lun:
+        checks.append((rsp_header.rs_lun, header.rs_lun, 'responder LUN mismatch'))
+
+    if rq_seq:
+        checks.append((rsp_header.rq_seq, header.rq_seq, 'sequence number mismatch'))
+
     match = True
 
     for left, right, msg in checks:

pyipmi/interfaces/ipmitool.py

@@ -42,12 +42,17 @@ class Ipmitool(object):
     IPMITOOL_PATH = 'ipmitool'
     supported_interfaces = ['lan', 'lanplus', 'serial-terminal', 'open']
 
-    def __init__(self, interface_type='lan'):
+    def __init__(self, interface_type='lan', cipher=None):
         if interface_type in self.supported_interfaces:
             self._interface_type = interface_type
         else:
             raise RuntimeError('interface type %s not supported' %
                                interface_type)
+        if cipher is not None and int(cipher) not in range(0, 255):
+            raise RuntimeError('cipher %s not in allowed range [0-255]' %
+                               cipher)
+        else:
+            self._cipher = cipher
 
         self.re_completion_code = re.compile(
                 r"Unable to send RAW command \(.*rsp=(0x[0-9a-f]+)\)")
@@ -213,6 +218,15 @@ class Ipmitool(object):
 
         return cmd
 
+    def _build_ipmitool_priv_level(self, level):
+        LEVELS = {
+                   Session.PRIV_LEVEL_USER: 'USER',
+                   Session.PRIV_LEVEL_OPERATOR: 'OPERATOR',
+                   Session.PRIV_LEVEL_ADMINISTRATOR: 'ADMINISTRATOR'
+                 }
+
+        return (' -L %s' % LEVELS[level])
+
     def _build_ipmitool_cmd(self, target, lun, netfn, raw_bytes):
         if not hasattr(self, '_session'):
             raise RuntimeError('Session needs to be set')
@@ -222,6 +236,10 @@ class Ipmitool(object):
         cmd += (' -H %s' % self._session.rmcp_host)
         cmd += (' -p %s' % self._session.rmcp_port)
 
+        cmd += self._build_ipmitool_priv_level(self._session.priv_level)
+
+        if self._cipher:
+            cmd += (' -C %s' % self._cipher)
         if self._session.auth_type == Session.AUTH_TYPE_NONE:
             cmd += ' -P ""'
         elif self._session.auth_type == Session.AUTH_TYPE_PASSWORD:

pyipmi/interfaces/rmcp.py

@@ -27,12 +27,13 @@ from ..session import Session
 from ..msgs import (create_message, create_request_by_name,
                     encode_message, decode_message, constants)
 from ..messaging import ChannelAuthenticationCapabilities
-from ..errors import DecodingError, NotSupportedError
+from ..errors import DecodingError, NotSupportedError, RetryError
 from ..logger import log
 from ..interfaces.ipmb import (IpmbHeaderReq, encode_ipmb_msg,
                                encode_bridged_message, decode_bridged_message,
                                rx_filter)
-from ..utils import check_completion_code, py3_array_tobytes
+from ..utils import (check_completion_code, check_rsp_completion_code,
+                     py3_array_tobytes)
 
 
 CLASS_NORMAL_MSG = 0x00
@@ -227,8 +228,9 @@ class IpmiMsg(object):
     HEADER_FORMAT_NO_AUTH = '!BIIB'
     HEADER_FORMAT_AUTH = '!BII16BB'
 
-    def __init__(self, session=None):
+    def __init__(self, session=None, ignore_sdu_length=False):
         self.session = session
+        self.ignore_sdu_length = ignore_sdu_length
 
     def _pack_session_id(self):
         if self.session is not None:
@@ -321,19 +323,28 @@ class IpmiMsg(object):
             (self.auth_type, self.sequence_number, self.session_id,
                 data_len) = struct.unpack(self.HEADER_FORMAT_NO_AUTH, header)
 
-        if len(pdu) < header_len + data_len:
-            raise DecodingError('short SDU')
-        elif len(pdu) > header_len + data_len:
-            raise DecodingError('SDU has extra bytes ({:d},{:d},{:d} )'.format(
-                len(pdu), header_len, data_len))
+        if not self.ignore_sdu_length:
+            if len(pdu) < header_len + data_len:
+                raise DecodingError('short SDU')
+            elif len(pdu) > header_len + data_len:
+                raise DecodingError(
+                    'SDU has extra bytes ({:d},{:d},{:d} )'.format(
+                        len(pdu), header_len, data_len))
 
         if hasattr(self, 'check_header'):
             self.check_header()
 
-        if data_len != 0:
-            sdu = pdu[header_len:header_len + data_len]
+        if not self.ignore_sdu_length:
+            if data_len != 0:
+                sdu = pdu[header_len:header_len + data_len]
+            else:
+                sdu = None
         else:
-            sdu = None
+            try:
+                sdu = pdu[header_len:]
+                sdu = None if sdu == b'' else sdu
+            except IndexError:
+                sdu = None
 
         return sdu
 
@@ -350,19 +361,52 @@ class Rmcp(object):
     _session = None
 
     def __init__(self, slave_address=0x81, host_target_address=0x20,
-                 keep_alive_interval=1):
+                 keep_alive_interval=1, max_retries=0, quirks_cfg=dict()):
+        """Native RMCP interface constructor
+
+        Parameter `quirks_cfg`: a dict of additional configuration parameters
+        for the RMCP object. Supported keys/values are :
+
+        - `rmcp_ignore_sdu_length: bool` whether or not to verify the SDU length
+        of a received IPMI message. If absent or `False` (default), an exception
+        will be raised if there is a mismatch between the received SDU length
+        and the value stored in `payload_length` field of the PDU header. If
+        `True`, ignore the header field `payload_length` and unpack the PDU
+        anyway.
+
+            Example:
+
+            interfaces.create_interface(
+                interface="rmcp",
+                quirks_cfg={'rmcp_ignore_sdu_length': True}
+            )
+
+        - `rmcp_ignore_rq_seq: bool` wheater or not to verify the req_seq field
+        for rx_filter. The default value is `False`.
+
+            Example:
+
+            interfaces.create_interface(
+                interface="rmcp",
+                quirks_cfg={'rmcp_ignore_rq_seq': True}
+            )
+        """
         self.host = None
         self.port = None
         self._sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
         self.seq_number = 0xff
         self.slave_address = slave_address
         self.host_target = Target(host_target_address)
+        self.max_retries = max_retries
         self.set_timeout(2.0)
         self.next_sequence_number = 0
         self.keep_alive_interval = keep_alive_interval
         self._stop_keep_alive = None
         self._q = Queue()
         self.transaction_lock = threading.Lock()
+        self.quirks_cfg = quirks_cfg
+        self.ignore_sdu_length = quirks_cfg.get('rmcp_ignore_sdu_length', False)
+        self.ignore_rq_seq = quirks_cfg.get('rmcp_ignore_rq_seq', False)
 
     def _send_rmcp_msg(self, sdu, class_of_msg):
         rmcp = RmcpMsg(class_of_msg)
@@ -387,11 +431,11 @@ class Rmcp(object):
         tx_data = ipmi.pack(data)
         self._send_rmcp_msg(tx_data, RMCP_CLASS_IPMI)
 
-    def _receive_ipmi_msg(self):
+    def _receive_ipmi_msg(self, ignore_sdu_length=False):
         (_, class_of_msg, pdu) = self._receive_rmcp_msg()
         if class_of_msg != RMCP_CLASS_IPMI:
             raise DecodingError('invalid class field in ASF message')
-        msg = IpmiMsg()
+        msg = IpmiMsg(ignore_sdu_length=ignore_sdu_length)
         data = msg.unpack(pdu)
         log().debug('IPMI RX: {:s}'.format(
             ' '.join('%02x' % b for b in array('B', data))))
@@ -415,13 +459,13 @@ class Rmcp(object):
         self._send_asf_msg(ping)
         self._receive_asf_msg(AsfPong)
 
-    def _get_channel_auth_cap(self):
+    def _get_channel_auth_cap(self, session):
         CHANNEL_NUMBER_FOR_THIS = 0xe
         # get channel auth cap
         req = create_request_by_name('GetChannelAuthenticationCapabilities')
         req.target = self.host_target
         req.channel.number = CHANNEL_NUMBER_FOR_THIS
-        req.privilege_level.requested = Session.PRIV_LEVEL_ADMINISTRATOR
+        req.privilege_level.requested = session.priv_level
         rsp = self.send_and_receive(req)
         check_completion_code(rsp.completion_code)
         caps = ChannelAuthenticationCapabilities(rsp)
@@ -435,7 +479,7 @@ class Rmcp(object):
         if session._auth_username:
             req.user_name = session._auth_username.ljust(16, '\x00')
         rsp = self.send_and_receive(req)
-        check_completion_code(rsp.completion_code)
+        check_rsp_completion_code(rsp)
         return rsp
 
     def _activate_session(self, session, challenge):
@@ -443,13 +487,12 @@ class Rmcp(object):
         req = create_request_by_name('ActivateSession')
         req.target = self.host_target
         req.authentication.type = session.auth_type
-        req.privilege_level.maximum_requested =\
-            Session.PRIV_LEVEL_ADMINISTRATOR
+        req.privilege_level.maximum_requested = session.priv_level
         req.challenge_string = challenge
         req.session_id = self._session.sid
         req.initial_outbound_sequence_number = random.randrange(1, 0xffffffff)
         rsp = self.send_and_receive(req)
-        check_completion_code(rsp.completion_code)
+        check_rsp_completion_code(rsp)
         return rsp
 
     def _set_session_privilege_level(self, level):
@@ -457,7 +500,7 @@ class Rmcp(object):
         req.target = self.host_target
         req.privilege_level.requested = level
         rsp = self.send_and_receive(req)
-        check_completion_code(rsp.completion_code)
+        check_rsp_completion_code(rsp)
         return rsp
 
     def _get_device_id(self):
@@ -476,7 +519,7 @@ class Rmcp(object):
 
         # 1 - Get Channel Authentication Capabilities
         log().debug('Get Channel Authentication Capabilities')
-        caps = self._get_channel_auth_cap()
+        caps = self._get_channel_auth_cap(session)
         log().debug('%s' % caps)
 
         # 2 - Get Session Challenge
@@ -485,6 +528,7 @@ class Rmcp(object):
         rsp = self._get_session_challenge(session)
         session_challenge = rsp.challenge_string
         session.sid = rsp.temporary_session_id
+
         self._session = session
 
         # 3 - Activate Session
@@ -496,7 +540,7 @@ class Rmcp(object):
 
         log().debug('Set Session Privilege Level')
         # 4 - Set Session Privilege Level
-        self._set_session_privilege_level(Session.PRIV_LEVEL_ADMINISTRATOR)
+        self._set_session_privilege_level(session.priv_level)
 
         log().debug('Session opened')
 
@@ -555,25 +599,47 @@ class Rmcp(object):
             tx_data = encode_ipmb_msg(header, payload)
 
         with self.transaction_lock:
-            self._send_ipmi_msg(tx_data)
-
-            received = False
-            while received is False:
-                if not self._q.empty():
-                    rx_data = self._q.get()
-                else:
-                    rx_data = self._receive_ipmi_msg()
-
-                if array('B', rx_data)[5] == constants.CMDID_SEND_MESSAGE:
-                    rx_data = decode_bridged_message(rx_data)
-                    if not rx_data:
-                        # the forwarded reply is expected in the next packet
-                        continue
-
-                received = rx_filter(header, rx_data)
-
-                if not received:
-                    self._q.put(rx_data)
+            retry = 0
+            while retry <= self.max_retries:
+                try:
+                    self._send_ipmi_msg(tx_data)
+
+                    received = False
+                    received_retry = 0
+                    while received is False and received_retry <= self.max_retries:
+                        if not self._q.empty():
+                            rx_data = self._q.get()
+                        else:
+                            rx_data = self._receive_ipmi_msg(self.ignore_sdu_length)
+
+                        if array('B', rx_data)[5] == constants.CMDID_SEND_MESSAGE:
+                            rx_data = decode_bridged_message(rx_data)
+                            if not rx_data:
+                                # the forwarded reply is expected in the next packet
+                                # so we do not increment the retry counter as
+                                # it's not really a retry
+                                continue
+
+                        received = rx_filter(header, rx_data,
+                                             rq_seq=not self.ignore_rq_seq)
+
+                        if not received:
+                            self._q.put(rx_data)
+
+                        received_retry += 1
+
+                    if not received:
+                        raise RetryError("Max retry while checking received"
+                                         "data against request header for rmcp"
+                                         f"host {self.host}")
+                    break
+
+                except socket.timeout:
+                    retry += 1
+
+        if retry > self.max_retries:
+            raise RetryError("Max retry while sending and/or receiving ipmi"
+                             f"message for rmcp host {self.host}")
 
         return rx_data[6:-1]