atomicshop 3.3.8__py3-none-any.whl → 3.10.0__py3-none-any.whl

atomicshop/mitm/connection_thread_worker.py

@@ -1,9 +1,13 @@
+import multiprocessing
 from datetime import datetime
 import threading
 import queue
 import socket
+import ssl
+from typing import Literal
+import struct
 
-from ..wrappers.socketw import receiver, sender, socket_client, base
+from ..wrappers.socketw import receiver, sender, socket_client, socket_base
 from .. import websocket_parse, ip_addresses
 from ..http_parse import HTTPRequestParse, HTTPResponseParse
 from ..basics import threads, tracebacks
@@ -25,7 +29,7 @@ def thread_worker_main(
         tls_version: str,
         domain_from_dns,
         statistics_writer,
-        engines_list,
+        engines_list: list[initialize_engines.ModuleCategory],
 
         # These parameters come from the main mitm module.
         config_static: cf
@@ -168,32 +172,55 @@ def thread_worker_main(
     def parse_websocket(raw_bytes):
         return websocket_frame_parser.parse_frame_bytes(raw_bytes)
 
-    def finish_thread():
+    def finish_thread(send_connection_reset: bool = False):
+        """
+        Finishing the thread, closing sockets.
+
+        :param send_connection_reset: Whether to send TCP RST flag to the client when closing the socket.
+            Basically what happens is that the server socket is closed abruptly sending us any Connection*Error exception.
+            We can simulate the ConnectionResetError on the client side by sending TCP RST flag when closing the socket.
+            But not the ConnectionAbortedError, since it is caused by other reasons (local TCP stack and has nothing
+            to do with the remote server).
+        """
         # At this stage there could be several times that the same socket was used to the service server - we need to
         # close this socket as well if it still opened.
         # The first part of the condition is to check if the service socket was connected at all.
         # If the service socket couldn't connect, then the instance will be None.
         if service_socket_instance and service_socket_instance.fileno() != -1:
-            if service_client.socket_instance:
-                service_client.close_socket()
+            if origin_service_client_instance.socket_instance:
+                origin_service_client_instance.close_socket()
 
         # If client socket is still opened - close
         if client_socket.fileno() != -1:
+            if send_connection_reset:
+                # Abort the connection
+                linger = struct.pack('ii', 1, 0)
+                client_socket.setsockopt(socket.SOL_SOCKET, socket.SO_LINGER, linger)
             client_socket.close()
-            network_logger.info(f"Closed client socket [{client_ip}:{source_port}]...")
+
+            if send_connection_reset:
+                network_logger.info(f"Closed client socket [{client_ip}:{source_port}] with TCP RST flag (Sent ConnectionResetError)...")
+            else:
+                network_logger.info(f"Closed client socket [{client_ip}:{source_port}]...")
 
         network_logger.info("Thread Finished. Will continue listening on the Main thread")
 
     def create_requester_request(
             client_message: ClientMessage,
             sending_socket: socket.socket
-    ) -> list[bytes]:
+    ) -> tuple[bytes, bool]:
+        request_received_raw: bytes = client_message.request_raw_bytes
         request_custom_raw: bytes = requester.create_request(client_message, sending_socket=sending_socket)
 
-        # Output first 100 characters of the request.
-        requester.logger.info(f"{request_custom_raw[0: 100]}...")
+        if request_custom_raw is None or request_received_raw == request_custom_raw:
+            is_requester_worked: bool = False
+        else:
+            is_requester_worked: bool = True
+
+            # Output first 100 characters of the request.
+            requester.logger.info(f"{request_custom_raw[0: 100]}...")
 
-        return [request_custom_raw]
+        return request_custom_raw, is_requester_worked
 
     def create_responder_response(client_message: ClientMessage) -> list[bytes]:
         if client_message.action == 'service_connect':
@@ -201,13 +228,19 @@ def thread_worker_main(
         else:
             # If we're in offline mode, and it's the first cycle and the protocol is Websocket, then we'll create the HTTP Handshake
             # response automatically.
-            if config_static.MainConfig.offline and protocol == 'Websocket' and client_receive_count == 1:
+            if config_static.MainConfig.is_offline and protocol == 'Websocket' and client_receive_count == 1:
                 responses: list = list()
                 responses.append(
                     websocket_parse.create_byte_http_response(client_message.request_raw_bytes))
+                responder.logger.info(f"Generated automatic WebSocket response in Offline Mode.")
             else:
                 # Creating response for parsed message and printing
-                responses: list = responder.create_response(client_message)
+                responder_responses: list = responder.create_response(client_message)
+                if responder_responses is None:
+                    responses: list = [client_message.response_raw_bytes]
+                else:
+                    responses: list = responder_responses
+                    responder.logger.info(f"Generated {len(responses)} responses from responder.")
 
             # Output first 100 characters of all the responses in the list.
             for response_raw_bytes_single in responses:
@@ -235,13 +268,14 @@ def thread_worker_main(
                 logger=network_logger,
                 custom_pem_client_certificate_file_path=custom_client_pem_certificate_path,
                 enable_sslkeylogfile_env_to_client_ssl_context=(
-                    config_static.Certificates.enable_sslkeylogfile_env_to_client_ssl_context)
+                    config_static.Certificates.enable_sslkeylogfile_env_to_client_ssl_context),
+                sslkeylog_file_path=config_static.Certificates.sslkeylog_file_path
             )
         # If it's a domain name, then we'll use the DNS to resolve it.
         else:
             # If we're on localhost, then use external services list in order to resolve the domain:
             # config['tcp']['forwarding_dns_service_ipv4_list___only_for_localhost']
-            if client_message.client_ip in base.THIS_DEVICE_IP_LIST:
+            if client_message.client_ip in socket_base.THIS_DEVICE_IP_LIST:
                 service_client_instance = socket_client.SocketClient(
                     service_name=client_message.server_name,
                     service_port=client_message.destination_port,
@@ -250,7 +284,8 @@ def thread_worker_main(
                     logger=network_logger,
                     custom_pem_client_certificate_file_path=custom_client_pem_certificate_path,
                     enable_sslkeylogfile_env_to_client_ssl_context=(
-                        config_static.Certificates.enable_sslkeylogfile_env_to_client_ssl_context)
+                        config_static.Certificates.enable_sslkeylogfile_env_to_client_ssl_context),
+                    sslkeylog_file_path=config_static.Certificates.sslkeylog_file_path
                 )
             # If we're not on localhost, then connect to domain directly.
             else:
@@ -261,7 +296,8 @@ def thread_worker_main(
                     logger=network_logger,
                     custom_pem_client_certificate_file_path=custom_client_pem_certificate_path,
                     enable_sslkeylogfile_env_to_client_ssl_context=(
-                        config_static.Certificates.enable_sslkeylogfile_env_to_client_ssl_context)
+                        config_static.Certificates.enable_sslkeylogfile_env_to_client_ssl_context),
+                    sslkeylog_file_path=config_static.Certificates.sslkeylog_file_path
                 )
 
         return service_client_instance
@@ -327,11 +363,291 @@ def thread_worker_main(
         client_message.destination_port = destination_port
         client_message.server_name = server_name
         client_message.thread_id = thread_id
+        client_message.thread_process = thread_process_name
         client_message.process_name = process_commandline
         client_message.engine_name = engine_name
 
         return client_message
 
+    def receive_send_service_connect(
+            client_connection_message: ClientMessage,
+            sending_socket: ssl.SSLSocket | socket.socket
+    ) -> Literal['continue', 'return'] | None:
+
+        nonlocal exception_or_close_in_receiving_thread
+
+        client_message = client_connection_message
+
+        bytes_to_send_list: list[bytes] = create_responder_response(client_message)
+        print_api(f"Got responses from connect responder, count: [{len(bytes_to_send_list)}]",
+                  logger=network_logger, logger_method='info')
+
+        # If the client message is the connection message, then we'll skip to the next iteration.
+        if not bytes_to_send_list:
+            return 'continue'
+
+        # is_socket_closed: bool = False
+        error_on_send: str = str()
+        for bytes_to_send_single in bytes_to_send_list:
+            client_message.reinitialize_dynamic_vars()
+            client_message.timestamp = datetime.now()
+            client_message.response_raw_bytes = bytes_to_send_single
+            client_message.action = 'service_responder'
+            record_and_statistics_write(client_message)
+
+            # Send the bytes back to the client socket.
+            error_on_send: str = sender.Sender(
+                ssl_socket=sending_socket, bytes_to_send=bytes_to_send_single,
+                logger=network_logger).send()
+
+            if error_on_send:
+                client_message.reinitialize_dynamic_vars()
+                client_message.errors.append(error_on_send)
+                client_message.timestamp = datetime.now()
+                client_message.action = 'client_send'
+                record_and_statistics_write(client_message)
+
+        if error_on_send:
+            exception_or_close_in_receiving_thread = True
+            finish_thread()
+            return 'return'
+
+        return None
+
+    def receive_send_client_offline(
+            client_message: ClientMessage,
+            receiving_socket: ssl.SSLSocket | socket.socket,
+            sending_socket: ssl.SSLSocket | socket.socket
+    ) -> Literal['return'] | None:
+        nonlocal exception_or_close_in_receiving_thread
+        nonlocal client_receive_count
+
+        client_receive_count += 1
+
+        network_logger.info(f"Initializing Receiver for Client cycle: {str(client_receive_count)}")
+        client_message.timestamp = datetime.now()
+
+        received_raw_data, is_socket_closed, error_message = receiver.Receiver(
+            ssl_socket=receiving_socket, logger=network_logger).receive()
+
+        process_client_raw_data(received_raw_data, error_message, client_message)
+        client_message.action = 'client_receive'
+        record_and_statistics_write(client_message)
+        if error_message:
+            print_api(error_message, logger=network_logger, logger_method='critical')
+
+        # If there was an exception in the service thread, then receiving empty bytes doesn't mean that
+        # the socket was closed by the other side, it means that the service thread closed the socket.
+        if (received_raw_data == b'' or error_message) and exception_or_close_in_receiving_thread:
+            print_api("Both sockets are closed, breaking the loop", logger=network_logger,
+                      logger_method='info')
+            return 'return'
+
+        # If the socket was closed on receive, and we're in offline mode, then we'll finish the thread right away.
+        # Since nothing more can be done, like responding to service or using requester.
+        if is_socket_closed:
+            exception_or_close_in_receiving_thread = True
+            finish_thread()
+            return 'return'
+
+        # Send to requester.
+        # THERE IS ALWAYS WILL BE ONLY ONE REQUEST FROM REQUESTER, SINCE THIS IS WHAT WE GOT FROM THE CLIENT.
+        request_custom_raw, is_requester_worked = create_requester_request(client_message, sending_socket=sending_socket)
+        # We will not process the raw data if requester didn't change anything.
+        if is_requester_worked:
+            client_message.reinitialize_dynamic_vars()
+            client_message.timestamp = datetime.now()
+            client_message.request_raw_bytes = request_custom_raw
+            client_message.action = 'client_requester'
+            process_client_raw_data(request_custom_raw, error_message, client_message)
+            record_and_statistics_write(client_message)
+
+        print_api("Offline Mode, sending to responder directly.", logger=network_logger,
+                  logger_method='info')
+        bytes_to_send_list: list[bytes] = create_responder_response(client_message)
+
+        error_on_send: str = str()
+        for bytes_to_send_single in bytes_to_send_list:
+            client_message.reinitialize_dynamic_vars()
+            client_message.timestamp = datetime.now()
+            client_message.response_raw_bytes = bytes_to_send_single
+            client_message.action = 'client_responder_offline'
+            process_server_raw_data(bytes_to_send_single, '', client_message)
+            record_and_statistics_write(client_message)
+
+            error_on_send: str = sender.Sender(
+                ssl_socket=receiving_socket, bytes_to_send=bytes_to_send_single,
+                logger=network_logger).send()
+
+            if error_on_send:
+                client_message.reinitialize_dynamic_vars()
+                client_message.errors.append(error_on_send)
+                client_message.timestamp = datetime.now()
+                client_message.action = 'service_send'
+
+                record_and_statistics_write(client_message)
+
+        # If the socket was closed on message receive, then we'll break the loop only after send.
+        if is_socket_closed or error_on_send:
+            exception_or_close_in_receiving_thread = True
+            finish_thread()
+            return 'return'
+
+        return None
+
+    def receive_send_client(
+            client_message: ClientMessage,
+            receiving_socket: ssl.SSLSocket | socket.socket,
+            sending_socket: ssl.SSLSocket | socket.socket
+    ) -> Literal['return'] | None:
+
+        nonlocal exception_or_close_in_receiving_thread
+        nonlocal client_receive_count
+
+        client_receive_count += 1
+
+        network_logger.info(f"Initializing Receiver for Client cycle: {str(client_receive_count)}")
+
+        # Getting message from the client over the socket using specific class.
+        client_message.timestamp = datetime.now()
+        received_raw_data, is_socket_closed, error_on_receive = receiver.Receiver(
+            ssl_socket=receiving_socket, logger=network_logger).receive()
+
+        process_client_raw_data(received_raw_data, error_on_receive, client_message)
+        client_message.action = 'client_receive'
+
+        # If there was an exception in the service thread, then receiving empty bytes doesn't mean that
+        # the socket was closed by the other side, it means that the service thread closed the socket.
+        if (received_raw_data == b'' or error_on_receive) and exception_or_close_in_receiving_thread:
+            print_api("Both sockets are closed, breaking the loop", logger=network_logger,
+                      logger_method='info')
+            return 'return'
+
+        # We don't need to record aborted socket receives if the socket was closed on receive on the second socket.
+        # Meaning 'exception_or_close_in_receiving_thread=True'.
+        record_and_statistics_write(client_message)
+        if error_on_receive:
+            print_api(error_on_receive, logger=network_logger, logger_method='critical')
+
+        # At this point if the socket was closed on receive, then there's no point to send anything to the service.
+        # So, we check for 'is_socket_closed' here.
+        error_on_send: str = str()
+        if not is_socket_closed:
+            # Send to requester.
+            # THERE IS ALWAYS WILL BE ONLY ONE REQUEST FROM REQUESTER, SINCE THIS IS WHAT WE GOT FROM THE CLIENT.
+            request_custom_raw, is_requester_worked = create_requester_request(client_message, sending_socket=sending_socket)
+            # We will not process the raw data if requester didn't change anything.
+            if is_requester_worked:
+                client_message.reinitialize_dynamic_vars()
+                client_message.timestamp = datetime.now()
+                client_message.request_raw_bytes = request_custom_raw
+                client_message.action = 'client_requester'
+                process_client_raw_data(request_custom_raw, error_on_receive, client_message)
+                record_and_statistics_write(client_message)
+
+            error_on_send: str = sender.Sender(
+                ssl_socket=sending_socket, bytes_to_send=client_message.request_raw_bytes,
+                logger=network_logger).send()
+
+            if error_on_send:
+                client_message.reinitialize_dynamic_vars()
+                client_message.errors.append(error_on_send)
+                client_message.timestamp = datetime.now()
+                client_message.action = 'service_send'
+                record_and_statistics_write(client_message)
+
+        # If the socket was closed on message receive, then we'll break the loop only after send.
+        if is_socket_closed or error_on_send:
+            exception_or_close_in_receiving_thread = True
+            finish_thread()
+            return 'return'
+
+        return None
+
+    def receive_send_service(
+            client_message: ClientMessage,
+            receiving_socket: ssl.SSLSocket | socket.socket,
+            sending_socket: ssl.SSLSocket | socket.socket
+    ) -> Literal['return'] | None:
+
+        nonlocal exception_or_close_in_receiving_thread
+        nonlocal server_receive_count
+
+        server_receive_count += 1
+
+        network_logger.info(f"Initializing Receiver for Service cycle: {str(server_receive_count)}")
+
+        # Getting message from the client over the socket using specific class.
+        client_message.timestamp = datetime.now()
+        received_raw_data, is_socket_closed, error_on_receive = receiver.Receiver(
+            ssl_socket=receiving_socket, logger=network_logger).receive()
+
+        process_server_raw_data(received_raw_data, error_on_receive, client_message)
+        client_message.action = 'service_receive'
+
+        # If there was an exception in the service thread, then receiving empty bytes doesn't mean that
+        # the socket was closed by the other side, it means that the service thread closed the socket.
+        if (received_raw_data == b'' or error_on_receive) and exception_or_close_in_receiving_thread:
+            print_api("Both sockets are closed, breaking the loop", logger=network_logger,
+                      logger_method='info')
+            return 'return'
+
+        # We don't need to record aborted socket receives if the socket was closed on receive on the second socket.
+        # Meaning 'exception_or_close_in_receiving_thread=True'.
+        record_and_statistics_write(client_message)
+        if error_on_receive:
+            print_api(error_on_receive, logger=network_logger, logger_method='critical')
+
+        # At this stage, we have received the response from the service, but there was an exception/error or the socket was simply closed.
+        # Meaning the 'received_raw_data' is None for exception or b'' for just closed socket.
+        # So, there's no point to send anything back to the client.
+        # Close both sockets and finish the threads.
+        # So, we check for 'is_socket_closed' here.
+        error_on_send: str = str()
+        if not is_socket_closed:
+            # Now send it to requester/responder.
+            bytes_to_send_list: list[bytes] = create_responder_response(client_message)
+
+            # is_socket_closed: bool = False
+            for bytes_to_send_single in bytes_to_send_list:
+                client_message.reinitialize_dynamic_vars()
+                client_message.timestamp = datetime.now()
+                client_message.response_raw_bytes = bytes_to_send_single
+
+                # This records the requester or responder output, only if it is not the same as the original
+                # message.
+                if bytes_to_send_single != received_raw_data:
+                    client_message.action = 'service_responder'
+                    record_and_statistics_write(client_message)
+
+                error_on_send: str = sender.Sender(
+                    ssl_socket=sending_socket, bytes_to_send=bytes_to_send_single,
+                    logger=network_logger).send()
+
+                if error_on_send:
+                    client_message.reinitialize_dynamic_vars()
+                    client_message.errors.append(error_on_send)
+                    client_message.timestamp = datetime.now()
+                    client_message.action = 'client_send'
+
+                    record_and_statistics_write(client_message)
+
+        # If the socket was closed on message receive, then we'll break the loop only after send.
+        if is_socket_closed or error_on_send:
+            exception_or_close_in_receiving_thread = True
+
+            if error_on_receive and 'Connection' in error_on_receive and 'Error' in error_on_receive:
+                # If there was a connection error on receive from client, and we're closing the socket to the client,
+                # then we'll send TCP RST flag to simulate ConnectionResetError on the client side.
+                finish_thread(send_connection_reset=True)
+            else:
+                finish_thread()
+
+            return 'return'
+
+        return None
+
+
     def receive_send_start(
             receiving_socket,
             sending_socket = None,
@@ -357,146 +673,25 @@ def thread_worker_main(
                 raise ValueError(f"Unknown side of the socket: {receiving_socket}")
 
             while True:
-                is_socket_closed: bool = False
-                # pass the socket connect to responder.
-                if side == 'Service' and client_connection_message:
-                    client_message = client_connection_message
-
-                    bytes_to_send_list: list[bytes] = create_responder_response(client_message)
-                    print_api(f"Got responses from connect responder, count: [{len(bytes_to_send_list)}]", logger=network_logger,
-                              logger_method='info')
-
-                    received_raw_data = None
-                else:
-                    client_message.reinitialize_dynamic_vars()
+                client_message.reinitialize_dynamic_vars()
 
-                    if side == 'Client':
-                        client_receive_count += 1
-                        current_count = client_receive_count
-                    else:
-                        server_receive_count += 1
-                        current_count = server_receive_count
-
-                    # Getting current time of message received, either from client or service.
-                    client_message.timestamp = datetime.now()
-
-                    # # No need to receive on service socket if we're in offline mode, because there is no service to connect to.
-                    # if config_static.MainConfig.offline and side == 'Service':
-                    #     print_api("Offline Mode, skipping receiving on service socket.", logger=network_logger,
-                    #               logger_method='info')
-                    # else:
-
-                    network_logger.info(
-                        f"Initializing Receiver for {side} cycle: {str(current_count)}")
-
-                    # Getting message from the client over the socket using specific class.
-                    received_raw_data, is_socket_closed, error_message = receiver.Receiver(
-                        ssl_socket=receiving_socket, logger=network_logger).receive()
-
-                    # In case of client socket, we'll process the raw data specifically for the client.
-                    if side == 'Client':
-                        process_client_raw_data(received_raw_data, error_message, client_message)
-                        client_message.action = 'client_receive'
-                    # In case of service socket, we'll process the raw data specifically for the service.
-                    else:
-                        process_server_raw_data(received_raw_data, error_message, client_message)
-                        client_message.action = 'service_receive'
-
-                    # If there was an exception in the service thread, then receiving empty bytes doesn't mean that
-                    # the socket was closed by the other side, it means that the service thread closed the socket.
-                    if (received_raw_data == b'' or error_message) and exception_or_close_in_receiving_thread:
-                        print_api("Both sockets are closed, breaking the loop", logger=network_logger,
-                                  logger_method='info')
-                        return
-
-                    # We will record only if there was no closing signal, because if there was, it means that we initiated
-                    # the close on the opposite socket.
-                    record_and_statistics_write(client_message)
-
-                    # if is_socket_closed:
-                    #     exception_or_close_in_receiving_thread = True
-                    #     finish_thread()
-                    #     return
-
-                    # Now send it to requester/responder.
-                    if side == 'Client':
-                        # Send to requester.
-                        bytes_to_send_list: list[bytes] = create_requester_request(
-                            client_message, sending_socket=sending_socket)
-
-                        # If we're in offline mode, then we'll put the request to the responder right away.
-                        if config_static.MainConfig.offline:
-                            print_api("Offline Mode, sending to responder directly.", logger=network_logger,
-                                      logger_method='info')
-                            process_client_raw_data(bytes_to_send_list[0], error_message, client_message)
-                            bytes_to_send_list = create_responder_response(client_message)
-                    elif side == 'Service':
-                        bytes_to_send_list: list[bytes] = create_responder_response(client_message)
-                        print_api(f"Got responses from responder, count: [{len(bytes_to_send_list)}]",
-                                  logger=network_logger,
-                                  logger_method='info')
-                    else:
-                        raise ValueError(f"Unknown side [{side}] of the socket: {receiving_socket}")
-
-
-                # If nothing was passed from the responder, and the client message is the connection message, then we'll skip to the next iteration.
-                if not bytes_to_send_list and client_connection_message:
+                if side == 'Service' and client_connection_message:
+                    result: Literal['continue', 'return'] | None = (
+                        receive_send_service_connect(client_connection_message, sending_socket))
                     client_connection_message = None
-                    continue
-
-                # is_socket_closed: bool = False
-                error_on_send: str = str()
-                for bytes_to_send_single in bytes_to_send_list:
-                    client_message.reinitialize_dynamic_vars()
-                    client_message.timestamp = datetime.now()
+                    if result == 'continue':
+                        continue
+                elif side == 'Client' and config_static.MainConfig.is_offline:
+                    result: Literal['return'] | None = receive_send_client_offline(client_message, receiving_socket, sending_socket)
+                elif side == 'Client':
+                    result: Literal['return'] | None = receive_send_client(client_message, receiving_socket, sending_socket)
+                elif side == 'Service':
+                    result: Literal['return'] | None = receive_send_service(client_message, receiving_socket, sending_socket)
+                else:
+                    raise ValueError(f"Unknown side [{side}] of the socket: {receiving_socket}")
 
-                    if side == 'Client':
-                        client_message.request_raw_bytes = bytes_to_send_single
-                    else:
-                        client_message.response_raw_bytes = bytes_to_send_single
-
-                    # This records the requester or responder output, only if it is not the same as the original
-                    # message.
-                    if bytes_to_send_single != received_raw_data:
-                        if side == 'Client':
-                            client_message.action = 'client_requester'
-
-                            if config_static.MainConfig.offline:
-                                client_message.action = 'client_responder_offline'
-                        elif side == 'Service':
-                            client_message.action = 'service_responder'
-                        record_and_statistics_write(client_message)
-
-                    # If we're in offline mode, it means we're in the client thread, and we'll send the
-                    # bytes back to the client socket.
-                    if config_static.MainConfig.offline:
-                        error_on_send: str = sender.Sender(
-                            ssl_socket=receiving_socket, class_message=bytes_to_send_single,
-                            logger=network_logger).send()
-                    else:
-                        error_on_send: str = sender.Sender(
-                            ssl_socket=sending_socket, class_message=bytes_to_send_single,
-                            logger=network_logger).send()
-
-                    if error_on_send:
-                        client_message.reinitialize_dynamic_vars()
-                        client_message.errors.append(error_on_send)
-                        client_message.timestamp = datetime.now()
-                        if side == 'Client':
-                            client_message.action = 'service_send'
-                        else:
-                            client_message.action = 'client_send'
-
-                        record_and_statistics_write(client_message)
-
-                # If the socket was closed on message receive, then we'll break the loop only after send.
-                if is_socket_closed or error_on_send:
-                    exception_or_close_in_receiving_thread = True
-                    finish_thread()
+                if result == 'return':
                     return
-
-                # For next iteration to start in case this iteration was responsible to process connection message, we need to set it to None.
-                client_connection_message = None
         except Exception as exc:
             # If the sockets were already closed, then there is nothing to do here besides log.
             # if (isinstance(exc, OSError) and exc.errno == 10038 and
@@ -513,7 +708,7 @@ def thread_worker_main(
     ):
         nonlocal exception_or_close_in_receiving_thread
 
-        exception_or_close_in_receiving_thread=True
+        exception_or_close_in_receiving_thread = True
         # handle_exceptions(exc, client_message, recorded)
         exception_message = tracebacks.get_as_string(one_line=True)
 
@@ -542,24 +737,34 @@ def thread_worker_main(
 
         finish_thread()
 
+        # Add custom attribute to the exception.
+        exc.engine_name = client_message.engine_name
+
         # After the socket clean up, we will still raise the exception to the main thread.
         raise exc
 
     # ================================================================================================================
     # This is the start of the thread_worker_main function
-
     network_logger = loggingw.get_logger_with_level(config_static.MainConfig.LOGGER_NAME)
 
     # Only protocols that are encrypted with TLS have the server name attribute.
     if is_tls:
         # Get current destination domain
         server_name = client_socket.server_hostname
+        # If there is no server name from the TLS handshake, then we'll use the domain from the DNS.
+        if not server_name:
+            server_name = domain_from_dns
     # If the protocol is not TLS, then we'll use the domain from the DNS.
     else:
         server_name = domain_from_dns
 
     thread_id = threads.current_thread_id()
 
+    process_name: str = multiprocessing.current_process().name
+    current_thread = threading.current_thread()
+    thread_process_name: str = f"{process_name} | {current_thread.name}"
+    current_thread.name = thread_process_name
+
     # This is the main protocols.
     protocol: str = str()
     # This is the secondary protocol in the websocket.
@@ -582,6 +787,13 @@ def thread_worker_main(
     responder = found_domain_module.responder_class_object()
     recorder = found_domain_module.recorder_class_object(record_path=config_static.LogRec.recordings_path)
 
+    engine_name: str = recorder.engine_name
+
+    for engine in engines_list:
+        if engine.engine_name == engine_name:
+            responder.add_args(engine=engine)
+            break
+
     network_logger.info(f"Assigned Modules for [{server_name}]: "
         f"{parser.__name__}, "
         f"{requester.__class__.__name__}, "
@@ -597,9 +809,15 @@ def thread_worker_main(
     http_path_queue: queue.Queue = queue.Queue()
 
     try:
-        engine_name: str = recorder.engine_name
         client_ip, source_port = client_socket.getpeername()
-        client_name: str = socket.gethostbyaddr(client_ip)[0]
+
+        try:
+            client_name: str = socket.gethostbyaddr(client_ip)[0]
+        # This can happen if the host changed IP address, but it wasn't propagated over DHCP.
+        except socket.herror:
+            client_name = ""
+
+        client_name = client_name.lower()
         destination_port: int = client_socket.getsockname()[1]
         destination_port_str: str = str(destination_port)
 
@@ -609,7 +827,7 @@ def thread_worker_main(
             _, destination_port_str = initialize_engines.get_ipv4_from_engine_on_connect_port(on_port_connect_value)
             destination_port: int = int(destination_port_str)
 
-        if config_static.MainConfig.offline:
+        if config_static.MainConfig.is_offline:
             # If in offline mode, then we'll get the TCP server's input address.
             server_ip = client_socket.getsockname()[0]
         else:
@@ -619,7 +837,7 @@ def thread_worker_main(
         network_logger.info(f"Thread Created - Client [{client_ip}:{source_port}] | "
                             f"Destination service: [{server_name}:{destination_port}]")
 
-        service_client = None
+        origin_service_client_instance = None
         client_receive_count: int = 0
         server_receive_count: int = 0
         client_message_connection = client_message_first_start()
@@ -631,11 +849,11 @@ def thread_worker_main(
         client_message_connection.action = 'service_connect'
         client_message_connection.timestamp = datetime.now()
 
-        if config_static.MainConfig.offline:
+        if config_static.MainConfig.is_offline:
             client_message_connection.info = 'Offline Mode'
         else:
-            service_client = create_client_socket(client_message_connection)
-            service_socket_instance, connection_error = service_client.service_connection()
+            origin_service_client_instance = create_client_socket(client_message_connection)
+            service_socket_instance, connection_error = origin_service_client_instance.service_connection()
 
             if connection_error:
                 client_message_connection.errors.append(connection_error)
@@ -650,22 +868,22 @@ def thread_worker_main(
             client_thread = threading.Thread(
                 target=receive_send_start,
                 args=(client_socket, service_socket_instance, client_exception_queue, None),
-                name=f"Thread-{thread_id}-Client",
+                name=f"{process_name} | Thread-{thread_id}-Client",
                 daemon=True)
             client_thread.start()
 
             service_exception_queue: queue.Queue = queue.Queue()
-            if not config_static.MainConfig.offline:
+            if not config_static.MainConfig.is_offline:
                 service_thread = threading.Thread(
                     target=receive_send_start,
                     args=(service_socket_instance, client_socket, service_exception_queue, client_message_connection),
-                    name=f"Thread-{thread_id}-Service",
+                    name=f"{process_name} | Thread-{thread_id}-Service",
                     daemon=True)
                 service_thread.start()
 
             client_thread.join()
             # If we're in offline mode, then there is no service thread.
-            if not config_static.MainConfig.offline:
+            if not config_static.MainConfig.is_offline:
                 # If we're not in offline mode, then we'll wait for the service thread to finish.
                 # noinspection PyUnboundLocalVariable
                 service_thread.join()