pymodbus-dev__pymodbus-1923

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "grep: socket_framer.py: No such file or directory\n",
  "details": {
    "stdout": "pymodbus/framer/base.py:115:    def processIncomingPacket(self, data, callback, slave, **kwargs):\n",
    "stderr": "grep: socket_framer.py: No such file or directory\n",
    "exit_code": 2
  }
}

{
  "status": "ok",
  "stdout": "pymodbus/framer/base.py:115:    def processIncomingPacket(self, data, callback, slave, **kwargs):\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "stdout": "pymodbus/framer/binary_framer.py:121:    def frameProcessIncomingPacket(self, single, callback, slave, _tid=None, **kwargs):\npymodbus/framer/base.py:139:        self.frameProcessIncomingPacket(single, callback, slave, **kwargs)\npymodbus/framer/base.py:141:    def frameProcessIncomingPacket(\npymodbus/framer/socket_framer.py:119:    def frameProcessIncomingPacket(self, single, callback, slave, tid=None, **kwargs):\npymodbus/framer/tls_framer.py:91:    def frameProcessIncomingPacket(self, single, callback, slave, _tid=None, **kwargs):\npymodbus/framer/ascii_framer.py:111:    def frameProcessIncomingPacket(self, single, callback, slave, _tid=None, **kwargs):\npymodbus/framer/rtu_framer.py:208:    def frameProcessIncomingPacket(self, single, callback, slave, _tid=None, **kwargs):\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "pymodbus/framer/base.py",
  "content": "            \"tid\": 0,\n        }\n\n    def populateResult(self, result):\n        \"\"\"Populate the modbus result header.\n\n        The serial packets do not have any header information\n        that is copied.\n\n        :param result: The response packet\n        \"\"\"\n        result.slave_id = self._header.get(\"uid\", 0)\n        result.transaction_id = self._header.get(\"tid\", 0)\n        result.protocol_id = self._header.get(\"pid\", 0)\n\n    def processIncomingPacket(self, data, callback, slave, **kwargs):\n        \"\"\"Process new packet pattern.\n\n        This takes in a new request packet, adds it to the current\n        packet stream, and performs framing on it. That is, checks\n        for complete messages, and once found, will process all that\n        exist.  This handles the case when we read N + 1 or 1 // N\n        messages at a time instead of 1.\n\n        The processed and decoded messages are pushed to the callback\n        function to process and send.\n\n        :param data: The new packet data\n        :param callback: The function to send results to\n        :param slave: Process if slave id matches, ignore otherwise (could be a\n               list of slave ids (server) or single slave id(client/server))\n        :param kwargs:\n        :raises ModbusIOException:\n        \"\"\"\n        Log.debug(\"Processing: {}\", data, \":hex\")\n        self._buffer += data\n        if not isinstance(slave, (list, tuple)):\n            slave = [slave]\n        single = kwargs.pop(\"single\", False)\n        self.frameProcessIncomingPacket(single, callback, slave, **kwargs)\n\n    def frameProcessIncomingPacket(\n        self, _single, _callback, _slave, _tid=None, **kwargs\n    ):\n        \"\"\"Process new packet pattern.\"\"\"",
  "start_line": 100,
  "end_line": 144,
  "total_lines": 144,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "pymodbus/framer/socket_framer.py",
  "content": "            return {\n                \"tid\": tid,\n                \"pid\": pid,\n                \"length\": length,\n                \"slave\": uid,\n                \"fcode\": fcode,\n            }\n        return {}\n\n    def frameProcessIncomingPacket(self, single, callback, slave, tid=None, **kwargs):\n        \"\"\"Process new packet pattern.\n\n        This takes in a new request packet, adds it to the current\n        packet stream, and performs framing on it. That is, checks\n        for complete messages, and once found, will process all that\n        exist.  This handles the case when we read N + 1 or 1 // N\n        messages at a time instead of 1.\n\n        The processed and decoded messages are pushed to the callback\n        function to process and send.\n        \"\"\"\n        while True:\n            if not self.isFrameReady():\n                if len(self._buffer):\n                    # Possible error ???\n                    if self._header[\"len\"] < 2:\n                        self._process(callback, tid, error=True)\n                break\n            if not self.checkFrame():\n                Log.debug(\"Frame check failed, ignoring!!\")\n                self.resetFrame()\n                continue\n            if not self._validate_slave_id(slave, single):\n                header_txt = self._header[\"uid\"]\n                Log.debug(\"Not a valid slave id - {}, ignoring!!\", header_txt)\n                self.resetFrame()\n                continue\n            self._process(callback, tid)\n\n    def _process(self, callback, tid, error=False):\n        \"\"\"Process incoming packets irrespective error condition.\"\"\"\n        data = self._buffer if error else self.getFrame()\n        if (result := self.decoder.decode(data)) is None:\n            self.resetFrame()\n            raise ModbusIOException(\"Unable to decode request\")\n        if error and result.function_code < 0x80:\n            raise InvalidMessageReceivedException(result)\n        self.populateResult(result)\n        self.advanceFrame()\n        if tid and tid != result.transaction_id:\n            self.resetFrame()\n        else:\n            callback(result)  # defer or push to a thread?\n\n    def buildPacket(self, message):\n        \"\"\"Create a ready to send modbus packet.\n\n        :param message: The populated request/response to send\n        \"\"\"\n        data = message.encode()\n        packet = struct.pack(\n            SOCKET_FRAME_HEADER,\n            message.transaction_id,\n            message.protocol_id,\n            len(data) + 2,\n            message.slave_id,\n            message.function_code,\n        )\n        packet += data\n        return packet\n\n\n# __END__",
  "start_line": 110,
  "end_line": 182,
  "total_lines": 182,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "pymodbus/framer/socket_framer.py",
  "content": "\"\"\"Socket framer.\"\"\"\n# pylint: disable=missing-type-doc\nimport struct\n\nfrom pymodbus.exceptions import (\n    InvalidMessageReceivedException,\n    ModbusIOException,\n)\nfrom pymodbus.framer.base import SOCKET_FRAME_HEADER, ModbusFramer\nfrom pymodbus.logging import Log\n\n\n# --------------------------------------------------------------------------- #\n# Modbus TCP Message\n# --------------------------------------------------------------------------- #\n\n\nclass ModbusSocketFramer(ModbusFramer):\n    \"\"\"Modbus Socket Frame controller.\n\n    Before each modbus TCP message is an MBAP header which is used as a\n    message frame.  It allows us to easily separate messages as follows::\n\n        [         MBAP Header         ] [ Function Code] [ Data ] \\\n        [ tid ][ pid ][ length ][ uid ]\n          2b     2b     2b        1b           1b           Nb\n\n        while len(message) > 0:\n            tid, pid, length`, uid = struct.unpack(\">HHHB\", message)\n            request = message[0:7 + length - 1`]\n            message = [7 + length - 1:]\n\n        * length = uid + function code + data\n        * The -1 is to account for the uid byte\n    \"\"\"\n\n    method = \"socket\"\n\n    def __init__(self, decoder, client=None):\n        \"\"\"Initialize a new instance of the framer.\n\n        :param decoder: The decoder factory implementation to use\n        \"\"\"\n        super().__init__(decoder, client)\n        self._hsize = 0x07\n\n    # ----------------------------------------------------------------------- #\n    # Private Helper Functions\n    # ----------------------------------------------------------------------- #\n    def checkFrame(self):\n        \"\"\"Check and decode the next frame.\n\n        Return true if we were successful.\n        \"\"\"\n        if self.isFrameReady():\n            (\n                self._header[\"tid\"],\n                self._header[\"pid\"],\n                self._header[\"len\"],\n                self._header[\"uid\"],\n            ) = struct.unpack(\">HHHB\", self._buffer[0 : self._hsize])\n\n            # someone sent us an error? ignore it\n            if self._header[\"len\"] < 2:\n                self.advanceFrame()\n            # we have at least a complete message, continue\n            elif len(self._buffer) - self._hsize + 1 >= self._header[\"len\"]:\n                return True\n        # we don't have enough of a message yet, wait\n        return False\n\n    def advanceFrame(self):\n        \"\"\"Skip over the current framed message.\n\n        This allows us to skip over the current message after we have processed\n        it or determined that it contains an error. It also has to reset the\n        current frame header handle\n        \"\"\"\n        length = self._hsize + self._header[\"len\"] - 1\n        self._buffer = self._buffer[length:]\n        self._header = {\"tid\": 0, \"pid\": 0, \"len\": 0, \"uid\": 0}\n\n    def isFrameReady(self):\n        \"\"\"Check if we should continue decode logic.\n\n        This is meant to be used in a while loop in the decoding phase to let\n        the decoder factory know that there is still data in the buffer.\n\n        :returns: True if ready, False otherwise\n        \"\"\"\n        return len(self._buffer) > self._hsize\n\n    def getFrame(self):\n        \"\"\"Return the next frame from the buffered data.\n\n        :returns: The next full frame buffer\n        \"\"\"\n        length = self._hsize + self._header[\"len\"] - 1\n        return self._buffer[self._hsize : length]\n\n    # ----------------------------------------------------------------------- #\n    # Public Member Functions\n    # ----------------------------------------------------------------------- #\n    def decode_data(self, data):\n        \"\"\"Decode data.\"\"\"\n        if len(data) > self._hsize:\n            tid, pid, length, uid, fcode = struct.unpack(\n                SOCKET_FRAME_HEADER, data[0 : self._hsize + 1]\n            )\n            return {\n                \"tid\": tid,\n                \"pid\": pid,\n                \"length\": length,\n                \"slave\": uid,\n                \"fcode\": fcode,\n            }\n        return {}\n\n    def frameProcessIncomingPacket(self, single, callback, slave, tid=None, **kwargs):\n        \"\"\"Process new packet pattern.\n\n        This takes in a new request packet, adds it to the current\n        packet stream, and performs framing on it. That is, checks\n        for complete messages, and once found, will process all that\n        exist.  This handles the case when we read N + 1 or 1 // N\n        messages at a time instead of 1.\n\n        The processed and decoded messages are pushed to the callback\n        function to process and send.\n        \"\"\"\n        while True:\n            if not self.isFrameReady():\n                if len(self._buffer):\n                    # Possible error ???\n                    if self._header[\"len\"] < 2:\n                        self._process(callback, tid, error=True)\n                break\n            if not self.checkFrame():\n                Log.debug(\"Frame check failed, ignoring!!\")\n                self.resetFrame()\n                continue\n            if not self._validate_slave_id(slave, single):\n                header_txt = self._header[\"uid\"]\n                Log.debug(\"Not a valid slave id - {}, ignoring!!\", header_txt)\n                self.resetFrame()\n                continue\n            self._process(callback, tid)\n\n    def _process(self, callback, tid, error=False):\n        \"\"\"Process incoming packets irrespective error condition.\"\"\"",
  "start_line": 1,
  "end_line": 150,
  "total_lines": 182,
  "is_truncated": true
}

{
  "status": "ok",
  "filepath": "pymodbus/framer/base.py",
  "content": "\"\"\"Framer start.\"\"\"\n# pylint: disable=missing-type-doc\nfrom __future__ import annotations\n\nfrom typing import Any\n\nfrom pymodbus.factory import ClientDecoder, ServerDecoder\nfrom pymodbus.logging import Log\n\n\n# Unit ID, Function Code\nBYTE_ORDER = \">\"\nFRAME_HEADER = \"BB\"\n\n# Transaction Id, Protocol ID, Length, Unit ID, Function Code\nSOCKET_FRAME_HEADER = BYTE_ORDER + \"HHH\" + FRAME_HEADER\n\n# Function Code\nTLS_FRAME_HEADER = BYTE_ORDER + \"B\"\n\n\nclass ModbusFramer:\n    \"\"\"Base Framer class.\"\"\"\n\n    name = \"\"\n\n    def __init__(\n        self,\n        decoder: ClientDecoder | ServerDecoder,\n        client=None,\n    ) -> None:\n        \"\"\"Initialize a new instance of the framer.\n\n        :param decoder: The decoder implementation to use\n        \"\"\"\n        self.decoder = decoder\n        self.client = client\n        self._header: dict[str, Any] = {\n            \"lrc\": \"0000\",\n            \"len\": 0,\n            \"uid\": 0x00,\n            \"tid\": 0,\n            \"pid\": 0,\n            \"crc\": b\"\\x00\\x00\",\n        }\n        self._buffer = b\"\"\n\n    def _validate_slave_id(self, slaves: list, single: bool) -> bool:\n        \"\"\"Validate if the received data is valid for the client.\n\n        :param slaves: list of slave id for which the transaction is valid\n        :param single: Set to true to treat this as a single context\n        :return:\n        \"\"\"\n        if single:\n            return True\n        if 0 in slaves or 0xFF in slaves:\n            # Handle Modbus TCP slave identifier (0x00 0r 0xFF)\n            # in asynchronous requests\n            return True\n        return self._header[\"uid\"] in slaves\n\n    def sendPacket(self, message):\n        \"\"\"Send packets on the bus.\n\n        With 3.5char delay between frames\n        :param message: Message to be sent over the bus\n        :return:\n        \"\"\"\n        return self.client.send(message)\n\n    def recvPacket(self, size):\n        \"\"\"Receive packet from the bus.\n\n        With specified len\n        :param size: Number of bytes to read\n        :return:\n        \"\"\"\n        return self.client.recv(size)\n\n    def resetFrame(self):\n        \"\"\"Reset the entire message frame.\n\n        This allows us to skip ovver errors that may be in the stream.\n        It is hard to know if we are simply out of sync or if there is\n        an error in the stream as we have no way to check the start or\n        end of the message (python just doesn't have the resolution to\n        check for millisecond delays).\n        \"\"\"\n        Log.debug(\n            \"Resetting frame - Current Frame in buffer - {}\", self._buffer, \":hex\"\n        )\n        self._buffer = b\"\"\n        self._header = {\n            \"lrc\": \"0000\",\n            \"crc\": b\"\\x00\\x00\",\n            \"len\": 0,\n            \"uid\": 0x00,\n            \"pid\": 0,\n            \"tid\": 0,\n        }\n\n    def populateResult(self, result):\n        \"\"\"Populate the modbus result header.\n\n        The serial packets do not have any header information\n        that is copied.\n\n        :param result: The response packet\n        \"\"\"\n        result.slave_id = self._header.get(\"uid\", 0)\n        result.transaction_id = self._header.get(\"tid\", 0)\n        result.protocol_id = self._header.get(\"pid\", 0)\n\n    def processIncomingPacket(self, data, callback, slave, **kwargs):\n        \"\"\"Process new packet pattern.\n\n        This takes in a new request packet, adds it to the current\n        packet stream, and performs framing on it. That is, checks\n        for complete messages, and once found, will process all that\n        exist.  This handles the case when we read N + 1 or 1 // N\n        messages at a time instead of 1.\n\n        The processed and decoded messages are pushed to the callback\n        function to process and send.\n\n        :param data: The new packet data\n        :param callback: The function to send results to\n        :param slave: Process if slave id matches, ignore otherwise (could be a\n               list of slave ids (server) or single slave id(client/server))\n        :param kwargs:\n        :raises ModbusIOException:\n        \"\"\"\n        Log.debug(\"Processing: {}\", data, \":hex\")\n        self._buffer += data\n        if not isinstance(slave, (list, tuple)):\n            slave = [slave]\n        single = kwargs.pop(\"single\", False)\n        self.frameProcessIncomingPacket(single, callback, slave, **kwargs)\n\n    def frameProcessIncomingPacket(\n        self, _single, _callback, _slave, _tid=None, **kwargs\n    ):\n        \"\"\"Process new packet pattern.\"\"\"",
  "start_line": 1,
  "end_line": 144,
  "total_lines": 144,
  "is_truncated": false
}

{
  "error": "Invoking `write_file()` failed as the following mandatory input parameters are not present:\ncontent\nYou could retry calling this tool, but it is IMPORTANT for you to provide all the mandatory parameters."
}

{
  "status": "error",
  "error_type": "FileWriteError",
  "error_message": "Path traversal detected: '/tmp/repro_framer.py' escapes workspace root."
}

{
  "status": "ok",
  "filepath": "repro_framer.py",
  "size": 1678
}

{
  "status": "ok",
  "stdout": "Initial buffer: \nAfter part 1, buffer: \nCallback size after part 1: 0\nFAILED: Modbus Error: [Invalid Message] <__main__.MockDecoder.decode.<locals>.Result object at 0x7461f62dedd0>\n",
  "stderr": "Traceback (most recent call last):\n  File \"/workspace/repro_framer.py\", line 46, in <module>\n    test_reassembly()\n  File \"/workspace/repro_framer.py\", line 37, in test_reassembly\n    framer.processIncomingPacket(part2, cb, slave=1)\n  File \"/workspace/pymodbus/framer/base.py\", line 139, in processIncomingPacket\n    self.frameProcessIncomingPacket(single, callback, slave, **kwargs)\n  File \"/workspace/pymodbus/framer/socket_framer.py\", line 136, in frameProcessIncomingPacket\n    self._process(callback, tid, error=True)\n  File \"/workspace/pymodbus/framer/socket_framer.py\", line 156, in _process\n    raise InvalidMessageReceivedException(result)\npymodbus.exceptions.InvalidMessageReceivedException: Modbus Error: [Invalid Message] <__main__.MockDecoder.decode.<locals>.Result object at 0x7461f62dedd0>\n",
  "exit_code": 0
}