atomicshop 2.17.3__py3-none-any.whl → 2.18.1__py3-none-any.whl

atomicshop/mitm/engines/__parent/parser___parent.py

@@ -10,6 +10,6 @@ class ParserParent:
 
     def parse(self):
         # This is general parser, so we don't parse anything and 'request_body_parsed' gets empty byte string.
-        self.class_client_message.request_body_parsed = b''
+        self.class_client_message.request_custom_parsed = b''
 
-        self.logger.info(f"Parsed: {self.class_client_message.request_body_parsed[0: 100]}...")
+        self.logger.info(f"Parsed: {self.class_client_message.request_custom_parsed[0: 100]}...")

atomicshop/mitm/engines/__parent/recorder___parent.py

@@ -1,35 +1,45 @@
 import os
 from datetime import datetime
 import json
+import queue
+import threading
 
 from ...shared_functions import build_module_names, create_custom_logger
 from ... import message, recs_files
 from .... import filesystem
-from ....file_io import file_io
+from ....file_io import jsons
+from ....print_api import print_api
 
 
 # The class that is responsible for Recording Requests / Responses.
 class RecorderParent:
 
-    def __init__(self, class_client_message: message.ClientMessage, record_path: str):
-        self.class_client_message: message.ClientMessage = class_client_message
+    # noinspection PyTypeChecker
+    def __init__(self, record_path: str):
         self.record_path: str = record_path
+
         self.file_extension: str = ".json"
         self.engine_name = None
         self.module_name = None
         self.engine_record_path: str = str()
         self.record_file_path: str = str()
+        self.class_client_message: message.ClientMessage = None
 
         self.logger = create_custom_logger()
 
         # Get engine name and module name
         self.get_engine_module()
-        # Build full file path.
-        self.build_record_full_file_path()
+
+        # Build the record path with file name
+        self.build_record_path_to_engine()
 
         # Create folder.
         filesystem.create_directory(self.engine_record_path)
 
+        # Initialize a queue to hold messages
+        self.message_queue: queue.Queue = queue.Queue()
+        self.recorder_worker_thread = None
+
     # "self.__module__" is fully qualified module name: classes.engines.ENGINE-NAME.MODULE-NAME
     def get_engine_module(self):
         _, self.engine_name, self.module_name = build_module_names(self.__module__)
@@ -43,12 +53,9 @@ class RecorderParent:
         # Formatting the date and time and converting it to string object
         day_time_format: str = now.strftime(recs_files.REC_FILE_DATE_TIME_FORMAT)
 
-        # Build the record path with file name
-        self.build_record_path_to_engine()
-
         # If HTTP Path is not defined, 'http_path' will be empty, and it will not interfere with file name.
         self.record_file_path: str = (
-            f"{self.engine_record_path}{os.sep}{day_time_format}_"
+            f"{self.engine_record_path}{os.sep}{day_time_format}_th{self.class_client_message.thread_id}_"
             f"{self.class_client_message.server_name}{self.file_extension}")
 
     def convert_messages(self):
@@ -59,27 +66,79 @@ class RecorderParent:
         # We need to check that the values that we want to convert aren't empty or 'None'.
         if self.class_client_message.request_raw_bytes:
             self.class_client_message.request_raw_hex = self.class_client_message.request_raw_bytes.hex()
-        if self.class_client_message.response_list_of_raw_bytes:
-            # We checked that the list isn't empty, now we check if the first value is not empty, since if we
-            # check it in the same expression as check for list is empty, we will get an exception since
-            # the list is empty.
-            if self.class_client_message.response_list_of_raw_bytes[0]:
-                for response_raw_bytes in self.class_client_message.response_list_of_raw_bytes:
-                    self.class_client_message.response_list_of_raw_hex.append(response_raw_bytes.hex())
-
-    def record(self):
+        if self.class_client_message.response_raw_bytes:
+            self.class_client_message.response_raw_hex = self.class_client_message.response_raw_bytes.hex()
+
+    def record(self, class_client_message: message.ClientMessage):
+        self.class_client_message = class_client_message
+
+        # Build full file path if it is not already built.
+        if not self.record_file_path:
+            self.build_record_full_file_path()
+
+        # Start the worker thread if it is not already running
+        if not self.recorder_worker_thread:
+            self.recorder_worker_thread = threading.Thread(
+                target=save_message_worker,
+                args=(self.record_file_path, self.message_queue, self.logger),
+                name=f"Thread-{self.class_client_message.thread_id}_Recorder",
+                daemon=True
+            )
+            self.recorder_worker_thread.start()
+
         self.logger.info("Recording Message...")
 
         # Convert the requests and responses to hex.
         self.convert_messages()
         # Get the message in dict / JSON format
         record_message_dict: dict = dict(self.class_client_message)
-        recorded_message_json_string = json.dumps(record_message_dict)
 
-        # Since we already dumped the object to dictionary string, we'll just save the object to regular file.
-        file_io.write_file(
-            recorded_message_json_string, self.record_file_path, enable_long_file_path=True, **{'logger': self.logger})
-
-        self.logger.info(f"Recorded to file: {self.record_file_path}")
+        # Put the message in the queue to be processed by the worker thread
+        self.message_queue.put(record_message_dict)
 
         return self.record_file_path
+
+
+def save_message_worker(
+        record_file_path: str,
+        message_queue: queue.Queue,
+        logger
+):
+    """Worker function to process messages from the queue and write them to the file."""
+    while True:
+        # Get a message from the queue
+        record_message_dict = message_queue.get()
+
+        # Check for the "stop" signal
+        if record_message_dict is None:
+            break
+
+        # Read existing data from the file
+        try:
+            with open(record_file_path, 'r') as f:
+                current_json_file = json.load(f)
+        except FileNotFoundError:
+            current_json_file: list = []
+
+        # Append the new message to the existing data
+        final_json_list_of_dicts: list[dict] = []
+        if isinstance(current_json_file, list):
+            current_json_file.append(record_message_dict)
+            final_json_list_of_dicts = current_json_file
+        elif isinstance(current_json_file, dict):
+            final_json_list_of_dicts.append(current_json_file)
+            final_json_list_of_dicts.append(record_message_dict)
+        else:
+            error_message = "The current file is neither a list nor a dictionary."
+            print_api(error_message, logger_method="critical", logger=logger)
+            raise TypeError(error_message)
+
+        # Write the data back to the file
+        jsons.write_json_file(
+            final_json_list_of_dicts, record_file_path, indent=2,
+            enable_long_file_path=True, **{'logger': logger})
+
+        logger.info(f"Recorded to file: {record_file_path}")
+
+        # Indicate task completion
+        message_queue.task_done()

atomicshop/mitm/engines/__reference_general/recorder___reference_general.py

@@ -7,7 +7,7 @@ from atomicshop.mitm.message import ClientMessage
 class RecorderGeneral(RecorderParent):
     """The class that is responsible for Recording Requests / Responses"""
     # When initializing main classes through "super" you need to pass parameters to init
-    def __init__(self, class_client_message: ClientMessage, record_path):
-        super().__init__(class_client_message, record_path)
+    def __init__(self, record_path):
+        super().__init__(record_path)
 
         self.logger = create_custom_logger()

atomicshop/mitm/message.py

@@ -8,15 +8,18 @@ from ..basics import dicts
 class ClientMessage:
     """ A class that will store all the message details from the client """
     def __init__(self):
-        self.request_raw_bytes: bytearray = bytearray()
         # noinspection PyTypeChecker
-        self.request_time_received: datetime = None
-        self.request_raw_decoded: Union[http_parse.HTTPRequestParse, any] = None
-        self.request_body_parsed = None
+        self.timestamp: datetime = None
+        # noinspection PyTypeChecker
+        self.request_raw_bytes: bytes = None
+        self.request_auto_parsed: Union[http_parse.HTTPRequestParse, any] = None
+        self.request_custom_parsed: any = None
         self.request_raw_hex: hex = None
-        self.response_list_of_raw_bytes: list = list()
-        self.response_list_of_raw_decoded: list = list()
-        self.response_list_of_raw_hex: list = list()
+        # noinspection PyTypeChecker
+        self.response_raw_bytes: bytes = None
+        self.response_auto_parsed: any = None
+        self.response_custom_parsed: any = None
+        self.response_raw_hex: hex = None
         self.server_name: str = str()
         self.server_ip: str = str()
         self.client_ip: str = str()
@@ -25,26 +28,50 @@ class ClientMessage:
         self.process_name: str = str()
         self.thread_id = None
         self.info: str = str()
-        self.error: str = str()
+        self.errors: list = list()
         self.protocol: str = str()
+        self.protocol2: str = str()
+        self.protocol3: str = str()
         self.recorded_file_path: str = str()
+        self.action: str = str()
+
+    def reinitialize_dynamic_vars(self):
+        """
+        Reinitialize the dynamic variables of the class for the new cycle.
+        """
+        self.request_raw_bytes = None
+        self.timestamp = None
+        self.request_auto_parsed = None
+        self.request_custom_parsed = None
+        self.request_raw_hex = None
+        self.response_raw_bytes = None
+        self.response_auto_parsed = None
+        self.response_custom_parsed = None
+        self.response_raw_hex = None
+        self.action = None
+        self.info = str()
+        self.errors = list()
+        self.protocol = str()
+        self.protocol2 = str()
+        self.protocol3 = str()
+        self.recorded_file_path = str()
 
     def __iter__(self):
         # __dict__ returns a dictionary containing the instance's attributes
         for key, value in self.__dict__.items():
             if key == 'request_raw_bytes':
                 value = str(value)
-            elif key == 'request_time_received':
+            elif key == 'timestamp':
                 value = value.strftime('%Y-%m-%d-%H:%M:%S.%f')
-            elif key == 'request_raw_decoded':
+            elif key == 'request_auto_parsed':
                 if isinstance(value, http_parse.HTTPRequestParse):
                     value = dicts.convert_complex_object_to_dict(value)
                 else:
                     value = str(value)
-            elif key == 'request_body_parsed':
+            elif key == 'request_custom_parsed':
+                value = dicts.convert_complex_object_to_dict(value)
+            elif key == 'response_raw_bytes':
+                value = str(value)
+            elif key == 'response_auto_parsed':
                 value = dicts.convert_complex_object_to_dict(value)
-            elif key == 'response_list_of_raw_bytes':
-                value = [str(bytes_response) for bytes_response in value]
-            elif key == 'response_list_of_raw_decoded':
-                value = [dicts.convert_complex_object_to_dict(complex_response) for complex_response in value]
             yield key, value

atomicshop/mitm/mitm_main.py

@@ -272,7 +272,7 @@ def mitm_server(config_file_path: str):
             time.sleep(1)
             return 1
 
-        dns_thread = threading.Thread(target=dns_server_instance.start)
+        dns_thread = threading.Thread(target=dns_server_instance.start, name="dns_server")
         dns_thread.daemon = True
         dns_thread.start()
 
@@ -376,7 +376,8 @@ def mitm_server(config_file_path: str):
             kwargs={
                 'reference_function_name': thread_worker_main,
                 'reference_function_args': (network_logger, statistics_writer, engines_list, reference_module,)
-            }
+            },
+            name="accepting_loop"
         )
 
         socket_thread.daemon = True

atomicshop/mitm/recs_files.py

@@ -7,7 +7,8 @@ from .. import filesystem
 from .. wrappers.loggingw import consts
 
 
-REC_FILE_DATE_TIME_FORMAT: str = f'{consts.DEFAULT_ROTATING_SUFFIXES_FROM_WHEN["S"]}_%f'
+REC_FILE_DATE_TIME_MILLISECONDS_FORMAT: str = f'{consts.DEFAULT_ROTATING_SUFFIXES_FROM_WHEN["S"]}_%f'
+REC_FILE_DATE_TIME_FORMAT: str = f'{consts.DEFAULT_ROTATING_SUFFIXES_FROM_WHEN["S"]}'
 REC_FILE_DATE_FORMAT: str = REC_FILE_DATE_TIME_FORMAT.split('_')[0]
 
 

atomicshop/system_resource_monitor.py

@@ -111,10 +111,18 @@ class SystemResourceMonitor:
         # The shared results' dictionary.
         self.results: dict = {}
 
-    def start(self, print_kwargs: dict = None):
+    def start(
+            self,
+            print_kwargs: dict = None,
+            thread_as_daemon: bool = True
+    ):
         """
         Start the monitoring process.
         :param print_kwargs:
+        :param thread_as_daemon: bool, set the thread as daemon. If you're running the monitoring process in the main
+            process, set it to True. If you're running the monitoring process in a separate process, set it to False.
+            In child processes created by multiprocessing.Process, the thread works differently. You might not
+            get the desired result.
         :return:
         """
 
@@ -127,7 +135,7 @@ class SystemResourceMonitor:
                 self.interval, self.get_cpu, self.get_memory, self.get_disk_io_bytes, self.get_disk_files_count,
                 self.get_disk_busy_time, self.get_disk_used_percent, self.calculate_maximum_changed_disk_io,
                 self.maximum_disk_io, self.queue_list, self.manager_dict))
-            self.thread.daemon = True
+            self.thread.daemon = thread_as_daemon
             self.thread.start()
         else:
             print_api.print_api("Monitoring is already running.", color='yellow', **print_kwargs)
@@ -205,6 +213,7 @@ def start_monitoring(
         calculate_maximum_changed_disk_io: bool = False,
         queue_list: list = None,
         manager_dict: multiprocessing.managers.DictProxy = None,      # multiprocessing.Manager().dict()
+        get_results_thread_as_daemon: bool = True,
         print_kwargs: dict = None
 ):
     """
@@ -235,6 +244,10 @@ def start_monitoring(
             multiprocessing.Process(
                 target=system_resource_monitor.start_monitoring, kwargs={'manager_dict': shared_dict}).start()
 
+    :param get_results_thread_as_daemon: bool, set the thread as daemon. If you're running the monitoring process in the
+        main process, set it to True. If you're running the monitoring process in a separate process, set it to False.
+        In child processes created by multiprocessing.Process, the thread works differently.
+        You might not get the desired result.
     :param print_kwargs: dict, print kwargs.
     :return:
     """
@@ -257,7 +270,7 @@ def start_monitoring(
             queue_list=queue_list,
             manager_dict=manager_dict
         )
-        SYSTEM_RESOURCES_MONITOR.start()
+        SYSTEM_RESOURCES_MONITOR.start(thread_as_daemon=get_results_thread_as_daemon)
     else:
         print_api.print_api("System resources monitoring is already running.", color='yellow', **(print_kwargs or {}))
 

atomicshop/wrappers/socketw/base.py

@@ -70,3 +70,20 @@ def get_default_ip_address() -> str:
     :return: string.
     """
     return socket.gethostbyname(socket.gethostname())
+
+
+def is_socket_closed(socket_object) -> bool:
+    """
+    Check if the socket is closed.
+    :param socket_object: socket object or ssl socket object.
+    :return: bool.
+    """
+    try:
+        # If the socket is closed, the fileno() method will raise an exception or return -1.
+
+        if socket_object.fileno() == -1:
+            return True
+        else:
+            return False
+    except socket.error:
+        return False

atomicshop/wrappers/socketw/receiver.py

@@ -21,21 +21,25 @@ def peek_first_bytes(client_socket, bytes_amount: int = 1) -> bytes:
     return client_socket.recv(bytes_amount, socket.MSG_PEEK)
 
 
-def is_socket_ready_for_read(client_socket, timeout: int = 0) -> bool:
+def is_socket_ready_for_read(socket_instance, timeout: int = 0) -> bool:
     """
     Check if socket is ready for read.
 
-    :param client_socket: Socket object.
+    :param socket_instance: Socket object.
     :param timeout: Timeout in seconds. The default is no timeout.
 
     :return: True if socket is ready for read, False otherwise.
     """
 
+    # Check if the socket is closed.
+    if socket_instance.fileno() == -1:
+        return False
+
     # Use select to check if the socket is ready for reading.
     # 'readable' returns a list of sockets that are ready for reading.
     # Since we use only one socket, it will return a list with one element if the socket is ready for reading,
     # or an empty list if the socket is not ready for reading.
-    readable, _, _ = select.select([client_socket], [], [], timeout)
+    readable, _, _ = select.select([socket_instance], [], [], timeout)
     return bool(readable)
 
 
@@ -69,129 +73,115 @@ class Receiver:
             self.logger: logging.Logger = logger
 
     # Function to receive only the buffer, with error handling
-    def socket_receive_message_buffer(self):
+    def chunk_from_buffer(self) -> tuple[bytes, str]:
+        """
+        Receive a chunk from the socket buffer.
+
+        :return: Tuple(received chunk binary bytes data, error message string).
+        """
         # Defining the data variable
-        class_data: bytes = bytes()
+        # noinspection PyTypeChecker
+        received_data: bytes = None
+        # noinspection PyTypeChecker
+        error_message: str = None
 
+        # All excepts will be treated as empty message, indicate that socket was closed and will be handled properly.
         try:
             # "recv(byte buffer size)" to read the server's response.
-            class_data = self.ssl_socket.recv(self.buffer_size_receive)
+            # A signal to close connection will be empty bytes string: b''.
+            received_data = self.ssl_socket.recv(self.buffer_size_receive)
         except ConnectionAbortedError:
-            message = "* Connection was aborted by the client. Exiting..."
-            print_api(message, logger=self.logger, logger_method='critical', traceback_string=True)
-            # This will be treated as empty message - indicate that socket was closed and will be handled properly.
-            pass
+            error_message = "* Connection was aborted by the client. Exiting..."
+            print_api(error_message, logger=self.logger, logger_method='critical', traceback_string=True)
         except ConnectionResetError:
-            message = "* Connection was forcibly closed by the client. Exiting..."
-            print_api(message, logger=self.logger, logger_method='critical', traceback_string=True)
-            # This will be treated as empty message - indicate that socket was closed and will be handled properly.
-            pass
+            error_message = "* Connection was forcibly closed by the client. Exiting..."
+            print_api(error_message, logger=self.logger, logger_method='critical', traceback_string=True)
         except ssl.SSLError:
-            message = "* Encountered SSL error on packet receive. Exiting..."
-            print_api(message, logger=self.logger, logger_method='critical', traceback_string=True)
-            # This will be treated as empty message - indicate that socket was closed and will be handled properly.
-            pass
+            error_message = "* Encountered SSL error on packet receive. Exiting..."
+            print_api(error_message, logger=self.logger, logger_method='critical', traceback_string=True)
 
-        if not class_data:
+        if received_data == b'':
             self.logger.info("Empty message received, socket closed on the other side.")
 
-        return class_data
+        return received_data, error_message
 
-    # Function to receive message
-    def socket_receive_message_full(self):
-        # Setting timeout for the client to receive connections, since there is no way to know when the message has
-        # ended and the message is longer than the receiving buffer.
-        # So we need to set the timeout for the client socket.
-        # If you set "timeout" on the listening main socket, it is not inherited to the child socket when client
-        # connected, so you need to set it for the new socket as well.
-        # Each function need to set the timeout independently
-        self.ssl_socket.settimeout(self.socket_timeout)
-        # variable that is responsible to retry over the same receive session if packet is less than buffer
-        partial_data_received: bool = False
+    def socket_receive_message_full(self) -> tuple[bytes, bool, str]:
+        """
+        Receive the full message from the socket.
 
+        :return: Tuple(full data binary bytes, is socket closed boolean, error message string).
+        """
         # Define the variable that is going to aggregate the whole data received
-        class_data: bytearray = bytearray()
-        # Define the variable that will be responsible for receive buffer
-        class_data_received: bytes = bytes()
+        full_data: bytes = bytes()
+        # noinspection PyTypeChecker
+        error_message: str = None
 
         # Infinite loop to accept data from the client
+        # We'll skip the 'is_socket_ready_for_read' check on the first run, since we want to read the data anyway,
+        # to leave the socket in the blocking mode.
+        first_run: bool = True
         while True:
-            # SocketTimeout creates an exception that we need to handle with try and except.
-            try:
-                # The variable needs to be defined before receiving the socket data or else you will get an error
-                # - variable not defined.
-                # function_data_received: bytearray = bytearray()
-                # Receiving data from the socket with "recv" method, while 1024 byte is a buffer size for the data.
-                # "decode()" method converts byte message to string.
-                class_data_received: bytes = self.socket_receive_message_buffer()
-            # If there is no byte data received from the client and also the full message is not empty, then the loop
-            # needs to break, since it is the last message that was received from the client
-            except TimeoutError:
-                if partial_data_received:
-                    self.logger.info(f"Timed out after {self.socket_timeout} seconds - no more packets. "
-                                     f"Passing current request of total {len(class_data)} bytes down the network chain")
-                    # Pass the exception
-                    pass
-                    # Break the while loop, since we already have the request
+            # Check if there is data to be read from the socket.
+            is_there_data: bool = is_socket_ready_for_read(self.ssl_socket, timeout=0)
+            # noinspection PyTypeChecker
+            if is_there_data or first_run:
+                first_run = False
+                # Receive the data from the socket.
+                received_chunk, error_message = self.chunk_from_buffer()
+                received_chunk: bytes
+                error_message: str
+
+                # And if the message received is not empty then aggregate it to the main "data received" variable
+                if received_chunk != b'' and received_chunk is not None:
+                    full_data += received_chunk
+
+                    self.logger.info(f"Received packet bytes: [{len(received_chunk)}] | "
+                                     f"Total aggregated bytes: [{len(full_data)}]")
+
+                elif received_chunk == b'' or received_chunk is None:
+                    # If there received_chunk is None, this means that the socket was closed,
+                    # since it is a connection error.
+                    # Same goes for the empty message.
+                    is_socket_closed = True
                     break
-                else:
-                    self.logger.info(
-                        # Dividing number of seconds by 60 to get minutes
-                        f"{self.socket_timeout/60} minutes timeout reached on 'socket.recv()' - no data received from "
-                        f"{self.class_client_address}:{self.class_client_local_port}. Still waiting...")
-                    # Pass the exception
-                    pass
-                    # Changing the socket timeout back to none since receiving operation has been finished.
-                    self.ssl_socket.settimeout(None)
-                    # Continue to the next iteration inside while
-                    continue
-
-            # And if the message received is not empty then aggregate it to the main "data received" variable
-            if class_data_received:
-                class_data.extend(class_data_received)
-
-                self.logger.info(f"Received packet with {len(class_data_received)} bytes. "
-                                 f"Current aggregated request of total: {len(class_data)} bytes")
-
-                # If the first received session is less than the buffer size, then the full message was received
-                if len(class_data_received) < self.buffer_size_receive:
-                    # Since we already received some data from the other side, the retried variable will be true
-                    partial_data_received = True
-                    self.logger.info(f"Receiving the buffer again...")
-
-                    # In this case the socket timeout will be 2 seconds to wait for more packets.
-                    # If there are no more packets, receiver will end its activity and pass the message to
-                    # the rest of the components in the network chain
-                    if self.socket_timeout != 0.5:
-                        self.socket_timeout = 0.5
-                        self.ssl_socket.settimeout(self.socket_timeout)
-                        self.logger.info(f"Timeout changed to {self.socket_timeout} seconds")
-
-                    # Continue to the next receive on the socket
-                    continue
             else:
-                if class_data:
-                    self.logger.info(f"Since there's request received from the client of total {len(class_data)} "
-                                     f"bytes, we'll first process it, and when the receiver will ask for data from "
-                                     f"client in the next cycle - empty message will be received again, and current "
-                                     f"socket will be finally closed.")
+                # If there is no data to be read from the socket, it doesn't mean that the socket is closed.
+                is_socket_closed = False
+                received_chunk = None
                 break
 
-        return class_data
+        if full_data:
+            self.logger.info(f"Received total: [{len(full_data)}] bytes")
+
+        # In case the full data is empty, and the received chunk is None, it doesn't mean that the socket is closed.
+        # But it means that there was no data to be read from the socket, because of error or timeout.
+        if full_data == b'' and received_chunk is None:
+            full_data = None
+
+        return full_data, is_socket_closed, error_message
+
+    def receive(self) -> tuple[bytes, bool, str]:
+        """
+        Receive the message from the socket.
 
-    # noinspection PyBroadException
-    def receive(self):
-        # Getting client address from the socket
+        :return: Tuple(
+            data binary bytes,
+            is socket closed boolean,
+            error message string if there was a connection exception).
+        """
+        # Getting client address and Local port from the socket
         self.class_client_address = self.ssl_socket.getpeername()[0]
-        # Getting client Local port from the socket
         self.class_client_local_port = self.ssl_socket.getpeername()[1]
 
         # Receiving data from the socket and closing the socket if send is finished.
         self.logger.info(f"Waiting for data from {self.class_client_address}:{self.class_client_local_port}")
-        function_client_data: bytearray = self.socket_receive_message_full()
+        socket_data_bytes, is_socket_closed, error_message = self.socket_receive_message_full()
+        socket_data_bytes: bytes
+        is_socket_closed: bool
+        error_message: str
 
-        if function_client_data:
+        if socket_data_bytes:
             # Put only 100 characters to the log, since we record the message any way in full - later.
-            self.logger.info(f"Received: {function_client_data[0: 100]}...")
+            self.logger.info(f"Received: {socket_data_bytes[0: 100]}...")
 
-        return function_client_data
+        return socket_data_bytes, is_socket_closed, error_message