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

atomicshop/mitm/connection_thread_worker.py

@@ -1,4 +1,6 @@
 from datetime import datetime
+import threading
+import queue
 
 from ..wrappers.socketw import receiver, sender, socket_client, base
 from .. import websocket_parse
@@ -23,47 +25,45 @@ def thread_worker_main(
         engines_list,
         reference_module
 ):
-    def output_statistics_csv_row():
+    def output_statistics_csv_row(client_message: ClientMessage):
         # If there is no '.code' attribute in HTTPResponse, this means that this is not an HTTP message, so there is no
         # status code.
         try:
-            http_status_code: str = ','.join([str(x.code) for x in client_message.response_list_of_raw_decoded])
+            http_status_code: str = str(client_message.response_auto_parsed.code)
         except AttributeError:
             http_status_code: str = str()
 
         # Same goes for the '.path' attribute, if it is not HTTP message then there will be no path.
         try:
-            http_path: str = client_message.request_raw_decoded.path
+            http_path: str = client_message.response_auto_parsed.path
         except AttributeError:
             http_path: str = str()
 
         # Same goes for the '.command' attribute, if it is not HTTP message then there will be no command.
         try:
-            http_command: str = client_message.request_raw_decoded.command
+            http_command: str = client_message.response_auto_parsed.command
         except AttributeError:
             http_command: str = str()
 
-        response_size_bytes: str = str()
-        for response_index, response in enumerate(client_message.response_list_of_raw_bytes):
-            if response is None:
-                response_size_bytes += ''
-            else:
-                response_size_bytes += str(len(response))
-
-            # If it is not the last entry, add the comma.
-            if response_index + 1 != len(client_message.response_list_of_raw_bytes):
-                response_size_bytes += ','
-
-        # response_size_bytes = ','.join([str(len(x)) for x in client_message.response_list_of_raw_bytes])
+        if client_message.request_raw_bytes is None:
+            request_size_bytes = ''
+        else:
+            request_size_bytes = str(len(client_message.request_raw_bytes))
 
-        if statistics_error_list and len(statistics_error_list) > 1:
-            error_string = '||'.join(statistics_error_list)
-        elif statistics_error_list and len(statistics_error_list) == 1:
-            error_string = statistics_error_list[0]
-        elif not statistics_error_list:
+        if client_message.response_raw_bytes is None:
+            response_size_bytes = ''
+        else:
+            response_size_bytes = str(len(client_message.response_raw_bytes))
+
+        if client_message.errors and len(client_message.errors) > 1:
+            error_string = '||'.join(client_message.errors)
+            error_string = f'Error count: {len(client_message.errors)} | Errors: {error_string}'
+        elif client_message.errors and len(client_message.errors) == 1:
+            error_string = client_message.errors[0]
+        elif not client_message.errors:
             error_string = str()
         else:
-            raise ValueError(f"Error in statistics error list. Values: {statistics_error_list}")
+            raise ValueError(f"Error in statistics error list. Values: {client_message.errors}")
 
         statistics_writer.write_row(
             thread_id=str(thread_id),
@@ -71,58 +71,78 @@ def thread_worker_main(
             tls_type=tls_type,
             tls_version=tls_version,
             protocol=client_message.protocol,
+            protocol2=client_message.protocol2,
+            protocol3=client_message.protocol3,
             path=http_path,
             status_code=http_status_code,
             command=http_command,
-            request_time_sent=client_message.request_time_received,
-            request_size_bytes=len(client_message.request_raw_bytes),
+            timestamp=client_message.timestamp,
+            request_size_bytes=request_size_bytes,
             response_size_bytes=response_size_bytes,
             recorded_file_path=client_message.recorded_file_path,
             process_cmd=process_commandline,
+            action=client_message.action,
             error=error_string
         )
 
-    def record_and_statistics_write():
+    def record_and_statistics_write(client_message: ClientMessage):
         # If recorder wasn't executed before, then execute it now
         if config_static.LogRec.enable_request_response_recordings_in_logs:
-            recorded_file = recorder(
-                class_client_message=client_message, record_path=config_static.LogRec.recordings_path).record()
+            recorded_file = recorder.record(class_client_message=client_message)
             client_message.recorded_file_path = recorded_file
 
         # Save statistics file.
-        output_statistics_csv_row()
+        output_statistics_csv_row(client_message)
 
-    def parse_http():
-        nonlocal error_message
+    def parse_http(
+            raw_bytes: bytes,
+            client_message: ClientMessage):
         nonlocal protocol
+        nonlocal protocol3
+
         # Parsing the raw bytes as HTTP.
-        request_decoded, is_http_request, request_parsing_info, request_parsing_error = (
-            HTTPRequestParse(client_message.request_raw_bytes).parse())
+        request_http_parsed, is_http_request, request_parsing_error = (
+            HTTPRequestParse(raw_bytes).parse())
+
+        response_http_parsed, is_http_response, response_parsing_error = (
+            HTTPResponseParse(raw_bytes).parse())
 
         if is_http_request:
             if protocol == '':
                 protocol = 'HTTP'
 
-            client_message.request_raw_decoded = request_decoded
-            print_api(request_parsing_info, logger=network_logger, logger_method='info')
-            network_logger.info(f"Method: {request_decoded.command} | Path: {request_decoded.path}")
+            auto_parsed = request_http_parsed
+            network_logger.info(
+                f"HTTP Request Parsed: Method: {request_http_parsed.command} | Path: {request_http_parsed.path}")
+
+            is_http_request_a_websocket(auto_parsed, client_message)
+        elif is_http_response:
+            auto_parsed = response_http_parsed
+            network_logger.info(
+                f"HTTP Response Parsed: Status: {response_http_parsed.code}")
+            protocol3 = auto_parsed.headers.get('Sec-WebSocket-Protocol', None)
+            if protocol3:
+                client_message.protocol3 = protocol3
+        elif protocol == 'Websocket':
+            client_message.protocol2 = 'Frame'
+            auto_parsed = parse_websocket(raw_bytes)
+            if protocol3:
+                client_message.protocol3 = protocol3
         else:
-            # It doesn't matter if we have HTTP Parsing error, since the request may not be really HTTP, so it is OK
-            # not to log it into statistics.
-            # statistics_error_list.append(error_message)
-            print_api(request_parsing_error, logger=network_logger, logger_method='error', color='yellow')
+            auto_parsed = None
 
-        is_http_request_a_websocket()
+        return auto_parsed
 
-    def is_http_request_a_websocket():
+    def is_http_request_a_websocket(
+            auto_parsed,
+            client_message: ClientMessage):
         nonlocal protocol
 
         if protocol == 'HTTP':
-            if (client_message.request_raw_decoded and
-                    hasattr(client_message.request_raw_decoded, 'headers') and
-                    'Upgrade' in client_message.request_raw_decoded.headers):
-                if client_message.request_raw_decoded.headers['Upgrade'] == 'websocket':
+            if auto_parsed and hasattr(auto_parsed, 'headers') and 'Upgrade' in auto_parsed.headers:
+                if auto_parsed.headers['Upgrade'] == 'websocket':
                     protocol = 'Websocket'
+                    client_message.protocol2 = 'Handshake'
 
                     network_logger.info(f'Protocol upgraded to Websocket')
 
@@ -132,72 +152,40 @@ def thread_worker_main(
     def finish_thread():
         # 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.
-        if service_client:
+        # 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 client socket is still opened - close
-        if client_socket:
+        if client_socket.fileno() != -1:
             client_socket.close()
-            network_logger.info(f"Closed client socket [{client_message.client_ip}:{client_message.source_port}]...")
+            network_logger.info(f"Closed client socket [{client_ip}:{source_port}]...")
 
         network_logger.info("Thread Finished. Will continue listening on the Main thread")
 
-    def process_client_raw_data_request() -> bool:
-        """
-        Process the client raw data request.
-
-        :return: True if the socket should be closed, False if not.
-        """
-
-        # If the message is empty, then the connection was closed already by the other side,
-        # so we can close the socket as well.
-        # If the received message from the client is not empty, then continue.
-        if not client_received_raw_data:
-            return True
-
-        # Putting the received message to the aggregating message class.
-        client_message.request_raw_bytes = client_received_raw_data
-
-        parse_http()
-        if protocol != '':
-            client_message.protocol = protocol
-
-        # Parse websocket frames only if it is not the first protocol upgrade request.
-        if protocol == 'Websocket' and cycle_count != 0:
-            client_message.request_raw_decoded = parse_websocket(client_message.request_raw_bytes)
-
-        # Custom parser, should parse HTTP body or the whole message if not HTTP.
-        parser_instance = parser(client_message)
-        parser_instance.parse()
-
-        # Converting body parsed to string on logging, since there is no strict rule for the parameter
-        # to be string.
-        parser_instance.logger.info(f"{str(client_message.request_body_parsed)[0: 100]}...")
-
-        return False
-
-    def create_responder_response():
+    def create_responder_response(client_message: ClientMessage) -> list[bytes]:
         # Since we're in response mode, we'll record the request anyway, after the responder did its job.
         client_message.info = "In Server Response Mode"
 
-        # Re-initiate the 'client_message.response_list_of_raw_bytes' list, since we'll be appending
-        # new entries for empty list.
-        client_message.response_list_of_raw_bytes = list()
-
         # If it's the first cycle and the protocol is Websocket, then we'll create the HTTP Handshake
         # response automatically.
-        if protocol == 'Websocket' and cycle_count == 0:
-            client_message.response_list_of_raw_bytes.append(
+        if protocol == 'Websocket' and client_receive_count == 0:
+            responses: list = list()
+            responses.append(
                 websocket_parse.create_byte_http_response(client_message.request_raw_bytes))
-        # Creating response for parsed message and printing
-        responder.create_response(client_message)
+        else:
+            # Creating response for parsed message and printing
+            responses: list = responder.create_response(client_message)
 
         # Output first 100 characters of all the responses in the list.
-        for response_raw_bytes_single in client_message.response_list_of_raw_bytes:
+        for response_raw_bytes_single in responses:
             responder.logger.info(f"{response_raw_bytes_single[0: 100]}...")
 
-    def create_client_socket():
+        return responses
+
+    def create_client_socket(client_message: ClientMessage):
         # If there is a custom certificate for the client for this domain, then we'll use it.
         # noinspection PyTypeChecker
         custom_client_pem_certificate_path: str = None
@@ -234,59 +222,258 @@ def thread_worker_main(
 
         return service_client_instance
 
-    def process_received_response_from_service_client():
-        if client_message.error is not None:
-            statistics_error_list.append(client_message.error)
-
-        # Since we need a list for raw bytes, we'll add the 'response_raw_bytes' to our list object.
-        # But we need to re-initiate it first.
-        client_message.response_list_of_raw_bytes = list()
-        # If there was error during send or receive from the service and response was None,
-        # It means that there was no response at all because of the error.
-        if client_message.error and response_raw_bytes is None:
-            client_message.response_list_of_raw_bytes.append(None)
-        # If there was no error, but response came empty, it means that the service has closed the
-        # socket after it received the request, without sending any data.
-        elif client_message.error is None and response_raw_bytes is None:
-            client_message.response_list_of_raw_bytes.append("")
-        else:
-            client_message.response_list_of_raw_bytes.append(response_raw_bytes)
-
-        client_message.response_list_of_raw_decoded = list()
-        # Make HTTP Response parsing only if there was response at all.
-        if response_raw_bytes:
-            response_raw_decoded, is_http_response, response_parsing_error = (
-                HTTPResponseParse(response_raw_bytes).parse())
-
-            if is_http_response:
-                client_message.response_list_of_raw_decoded.append(response_raw_decoded)
-            elif protocol == 'Websocket' and cycle_count != 0:
-                response_decoded = parse_websocket(response_raw_bytes)
-                client_message.response_list_of_raw_decoded.append(response_decoded)
+    def process_client_raw_data(
+            client_received_raw_data: bytes,
+            error_string: str,
+            client_message: ClientMessage):
+        """
+        Process the client raw data request.
+        """
+        nonlocal protocol
+
+        client_message.request_raw_bytes = client_received_raw_data
+
+        if error_string:
+            client_message.errors.append(error_string)
+
+        if client_received_raw_data == b'':
+            return
+
+        client_message.response_auto_parsed = parse_http(client_message.request_raw_bytes, client_message)
+        if protocol != '':
+            client_message.protocol = protocol
+
+        # Parse websocket frames only if it is not the first protocol upgrade request.
+        if protocol == 'Websocket' and client_receive_count != 0:
+            client_message.request_auto_parsed = parse_websocket(client_message.request_raw_bytes)
+
+        # Custom parser, should parse HTTP body or the whole message if not HTTP.
+        parser_instance = parser(client_message)
+        parser_instance.parse()
+
+        # Converting body parsed to string on logging, there is no strict rule for the parameter to be string.
+        parser_instance.logger.info(f"{str(client_message.request_custom_parsed)[0: 100]}...")
+
+    def process_server_raw_data(
+            service_received_raw_data: bytes,
+            error_string: str,
+            client_message: ClientMessage
+    ):
+        nonlocal protocol
+
+        client_message.response_raw_bytes = service_received_raw_data
+
+        if error_string:
+            client_message.errors.append(error_string)
+
+        if service_received_raw_data == b'':
+            return
+
+        client_message.response_auto_parsed = parse_http(client_message.response_raw_bytes, client_message)
+        if protocol != '':
+            client_message.protocol = protocol
+
+    def client_message_first_start() -> ClientMessage:
+        client_message: ClientMessage = ClientMessage()
+        client_message.client_ip = client_ip
+        client_message.source_port = source_port
+        client_message.destination_port = destination_port
+        client_message.server_name = server_name
+        client_message.thread_id = thread_id
+        client_message.process_name = process_commandline
+
+        return client_message
+
+    def responder_thread_worker():
+        nonlocal exception_or_close_in_receiving_thread
+
+        client_message: ClientMessage = client_message_first_start()
+        try:
+            while True:
+                client_message = responder_queue.get()
+                raw_responses: list[bytes] = create_responder_response(client_message)
+
+                is_socket_closed: bool = False
+                for response_raw_bytes in raw_responses:
+                    client_message.reinitialize_dynamic_vars()
+                    client_message.timestamp = datetime.now()
+                    client_message.response_raw_bytes = response_raw_bytes
+                    error_on_send: str = sender.Sender(
+                        ssl_socket=client_socket, class_message=client_message.response_raw_bytes,
+                        logger=network_logger).send()
+
+                    # If there was problem with sending data, we'll break the main while loop.
+                    if error_on_send:
+                        client_message.errors.append(error_on_send)
+                        record_and_statistics_write(client_message)
+                        is_socket_closed = True
+
+                if is_socket_closed:
+                    exception_or_close_in_receiving_thread = True
+                    return
+        except Exception as exc:
+            handle_exceptions_on_sub_connection_thread(client_message, client_exception_queue, exc)
+
+    def receive_send_start(
+            receiving_socket,
+            sending_socket = None,
+            exception_queue: queue.Queue = None
+    ):
+        nonlocal client_receive_count
+        nonlocal server_receive_count
+        nonlocal exception_or_close_in_receiving_thread
+
+        # Set the thread name to the custom name for logging
+        # threading.current_thread().name = thread_name
+
+        # Initialize the client message object with current thread's data.
+        client_message: ClientMessage = client_message_first_start()
+
+        try:
+            if receiving_socket is client_socket:
+                side: str = 'Client'
+            elif receiving_socket is service_socket_instance:
+                side: str = 'Service'
+            else:
+                raise ValueError(f"Unknown side of the socket: {receiving_socket}")
+
+            while True:
+                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
+
+                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()
+
+                # Getting current time of message received, either from client or service.
+                client_message.timestamp = datetime.now()
+
+                # 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
+
+                # If we're in response mode, execute responder.
+                if config_static.TCPServer.server_response_mode:
+                    responder_queue.put(client_message)
+                else:
+                    # if side == 'Client':
+                    #     raise NotImplementedError
+                    client_message.reinitialize_dynamic_vars()
+                    error_on_send: str = sender.Sender(
+                        ssl_socket=sending_socket, class_message=received_raw_data,
+                        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, then we'll break the loop.
+                    if is_socket_closed or error_on_send:
+                        exception_or_close_in_receiving_thread = True
+                        finish_thread()
+                        return
+        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
+            #         client_socket.fileno() == -1 and service_socket_instance.fileno() == -1):
+            if isinstance(exc, OSError) and exc.errno == 10038:
+                print_api("Both sockets are closed, breaking the loop", logger=network_logger, logger_method='info')
             else:
-                client_message.response_list_of_raw_decoded.append(None)
+                handle_exceptions_on_sub_connection_thread(client_message, exception_queue, exc)
+
+    def handle_exceptions_on_sub_connection_thread(
+            client_message: ClientMessage,
+            exception_queue: queue.Queue,
+            exc: Exception
+    ):
+        nonlocal exception_or_close_in_receiving_thread
 
-    # Building client message object before the loop only for any exception to occurs, since we write it to
-    # recording file in its current state.
-    client_message: ClientMessage = ClientMessage()
-    # 'recorded' boolean is needed only to write the message in case of exception in the loop or before that.
-    recorded: bool = False
-    statistics_error_list: list[str] = list()
+        exception_or_close_in_receiving_thread=True
+        # handle_exceptions(exc, client_message, recorded)
+        exception_message = tracebacks.get_as_string(one_line=True)
+
+        error_message = f'Socket Thread [{str(thread_id)}] Exception: {exception_message}'
+        print_api("Exception in a thread, forwarding to parent thread.", logger_method='info', logger=network_logger)
+        client_message.errors.append(error_message)
+
+        # if not recorded:
+        #     record_and_statistics_write(client_message)
+
+        finish_thread()
+        exception_queue.put(exc)
+
+    def handle_exceptions_on_main_connection_thread(
+            exc: Exception,
+            client_message: ClientMessage
+    ):
+        exception_message = tracebacks.get_as_string(one_line=True)
+        error_message = f'Socket Thread [{str(thread_id)}] Exception: {exception_message}'
+        print_api(error_message, logger_method='critical', logger=network_logger)
+        client_message.errors.append(error_message)
+
+        # === At this point while loop of 'client_connection_boolean' was broken =======================================
+        # If recorder wasn't executed before, then execute it now
+        record_and_statistics_write(client_message)
+
+        finish_thread()
+
+        # 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
 
     # 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
-        # client_message.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
-    client_message.server_name = server_name
 
     thread_id = threads.current_thread_id()
-    client_message.thread_id = thread_id
 
+    # This is the main protocols.
     protocol: str = str()
+    # This is the secondary protocol in the websocket.
+    protocol3: str = str()
     # # This is Client Masked Frame Parser.
     # websocket_masked_frame_parser = websocket_parse.WebsocketFrameParser()
     # # This is Server UnMasked Frame Parser.
@@ -295,7 +482,7 @@ def thread_worker_main(
 
     # Loading parser by domain, if there is no parser for current domain - general reference parser is loaded.
     # These should be outside any loop and initialized only once entering the thread.
-    parser, responder, recorder, mtls_dict = assign_class_by_domain(
+    parser, responder, recorder_no_init, mtls_dict = assign_class_by_domain(
         engines_usage=config_static.TCPServer.engines_usage,
         engines_list=engines_list,
         message_domain_name=server_name,
@@ -303,140 +490,83 @@ def thread_worker_main(
         logger=network_logger
     )
 
+    recorder = recorder_no_init(record_path=config_static.LogRec.recordings_path)
+
+    # Initializing the client message object with current thread's data.
+    # This is needed only to skip error alerts after 'try'.
+    client_message_connection: ClientMessage = ClientMessage()
+    # This is needed to indicate if there was an exception or socket was closed in any of the receiving thread.
+    exception_or_close_in_receiving_thread: bool = False
+    # Responder queue for ClientMessage objects.
+    responder_queue: queue.Queue = queue.Queue()
+
     try:
         client_ip, source_port = client_socket.getpeername()
-        client_message.client_ip = client_ip
-        client_message.source_port = source_port
-
         destination_port = client_socket.getsockname()[1]
-        client_message.destination_port = destination_port
 
         network_logger.info(f"Thread Created - Client [{client_ip}:{source_port}] | "
                             f"Destination service: [{server_name}:{destination_port}]")
 
-        end_socket: bool = False
-        service_client = None
-        # Loop while received message is not empty, if so, close socket, since other side already closed.
-        # noinspection PyTypeChecker
-        cycle_count: int = None
-        while True:
-            # If cycle count is None, then it's the first cycle, else it's not.
-            # The cycle_count should be added 1 in the beginning of each cycle, and not in the end, since not always
-            # the cycle will be executed till the end.
-            if cycle_count is None:
-                cycle_count = 0
-            else:
-                cycle_count += 1
-
-            recorded: bool = False
-            statistics_error_list: list[str] = list()
-
-            client_message = ClientMessage()
-            client_message.thread_id = thread_id
-            client_message.client_ip = client_ip
-            client_message.source_port = source_port
-            client_message.destination_port = destination_port
-            client_message.process_name = process_commandline
-            client_message.server_name = server_name
-            # Getting current time of message received from client.
-            client_message.request_time_received = datetime.now()
-
-            # Peek if there is some data in the socket.
-            # This is needed to check if the client just connects without sending data, if so we need to try and
-            # receive data from the server and send it to the client.
-            # We will do it only on the first cycle, after that the connection should work as usual.
-            # Sometimes the client will execute connection without sending data, just for the server to send response.
-            is_socket_ready: bool = True
-            if cycle_count == 0:
-                is_socket_ready = receiver.is_socket_ready_for_read(client_socket)
-
-            if is_socket_ready:
-                network_logger.info(f"Initializing Receiver on cycle: {str(cycle_count+1)}")
-                # Getting message from the client over the socket using specific class.
-                client_received_raw_data = receiver.Receiver(
-                    ssl_socket=client_socket, logger=network_logger).receive()
-
-                end_socket = process_client_raw_data_request()
-
-            if not end_socket:
-                # If we're in response mode, execute responder.
-                response_raw_bytes = None
-                if config_static.TCPServer.server_response_mode:
-                    create_responder_response()
-                # Else, we're not in response mode, then execute client connect and record section.
-                else:
-                    # If "service_client" object is not defined, we'll define it.
-                    # If it's defined, then there's still active "ssl_socket" with connection to the service domain.
-                    if not service_client:
-                        service_client = create_client_socket()
-
-                    # Sending current client message and receiving a response.
-                    # If there was an error it will be passed to "client_message" object class and if not, "None" will
-                    # be passed.
-                    # If there was connection error or socket close, then "ssl_socket" of the "service_client"
-                    # will be empty.
-                    response_raw_bytes, client_message.error, client_message.server_ip, service_ssl_socket = (
-                        service_client.send_receive_to_service(client_message.request_raw_bytes, (not is_socket_ready)))
-
-                    process_received_response_from_service_client()
-
-                    # So if the socket was closed and there was an error we can break the loop
-                    if not service_ssl_socket:
-                        record_and_statistics_write()
-                        recorded = True
-                        break
-
-                # If there is a response(s), then send it.
-                if client_message.response_list_of_raw_bytes:
-                    # Sending response/s to client no matter if in record mode or not.
-                    network_logger.info(
-                        f"Sending messages to client: {len(client_message.response_list_of_raw_bytes)}")
-
-                    # Iterate through the list of byte responses.
-                    for response_raw_bytes in client_message.response_list_of_raw_bytes:
-                        error_on_send: str = sender.Sender(
-                            ssl_socket=client_socket, class_message=response_raw_bytes,
-                            logger=network_logger).send()
-
-                        # If there was problem with sending data, we'll break current loop.
-                        if error_on_send:
-                            statistics_error_list.append(error_on_send)
-                            break
-                # If response from server came back empty, then the server has closed the connection,
-                # we will do the same.
-                else:
-                    network_logger.info(f"Response empty, nothing to send to client.")
-                    break
+        # If we're in response mode, we'll start the responder thread.
+        if config_static.TCPServer.server_response_mode:
+            responder_thread: threading.Thread = threading.Thread(
+                target=responder_thread_worker, name=f"Thread-{thread_id}-Responder", daemon=True)
+            responder_thread.start()
 
-                record_and_statistics_write()
-                recorded = True
-
-            # If the message is empty, then the connection was closed already by the other side, also if there will
-            # be empty response from the server, so we can close the socket as well and exceptions will be raised.
-            if end_socket:
-                # If it's the first cycle we will record the message from the client if it came empty.
-                if cycle_count == 0:
-                    record_and_statistics_write()
-
-                # In other cases, we'll just break the loop, since empty message means that the other side closed the
-                # connection.
-                recorded = True
+        service_client = None
+        client_receive_count: int = 0
+        server_receive_count: int = 0
+        client_message_connection = client_message_first_start()
 
-                break
+        # If we're not in response mode, then we'll create the client socket to the service.
+        # noinspection PyTypeChecker
+        connection_error: str = None
+        service_socket_instance = None
+        if not config_static.TCPServer.server_response_mode:
+            # If "service_client" object is not defined, we'll define it.
+            # If it's defined, then there's still active "ssl_socket" with connection to the service domain.
+            if not service_client:
+                service_client = create_client_socket(client_message_connection)
+                service_socket_instance, connection_error = service_client.service_connection()
+        else:
+            client_message_connection.timestamp = datetime.now()
+            client_message_connection.action = 'service_connect'
+            client_message_connection.info = 'Server Response Mode'
+            responder_queue.put(client_message_connection)
+
+        if connection_error:
+            client_message_connection.timestamp = datetime.now()
+            client_message_connection.errors.append(connection_error)
+            client_message_connection.action = 'service_connect'
+            record_and_statistics_write(client_message_connection)
+        else:
+            client_exception_queue: queue.Queue = queue.Queue()
+            service_exception_queue: queue.Queue = queue.Queue()
+
+            client_thread = threading.Thread(
+                target=receive_send_start, args=(client_socket, service_socket_instance, client_exception_queue),
+                name=f"Thread-{thread_id}-Client")
+            client_thread.daemon = True
+            client_thread.start()
+
+            service_thread = threading.Thread(
+                target=receive_send_start, args=(service_socket_instance, client_socket, service_exception_queue),
+                name=f"Thread-{thread_id}-Service")
+            service_thread.daemon = True
+            service_thread.start()
+
+            client_thread.join()
+            service_thread.join()
+
+            # If there was an exception in any of the threads, then we'll raise it here.
+            if not client_exception_queue.empty():
+                raise client_exception_queue.get()
+            if not service_exception_queue.empty():
+                raise service_exception_queue.get()
 
         finish_thread()
     except Exception as e:
-        exception_message = tracebacks.get_as_string(one_line=True)
-        error_message = f'Socket Thread [{str(thread_id)}] Exception: {exception_message}'
-        print_api(error_message, logger_method='critical', logger=network_logger)
-        statistics_error_list.append(error_message)
-
-        # === At this point while loop of 'client_connection_boolean' was broken =======================================
-        # If recorder wasn't executed before, then execute it now
-        if not recorded:
-            record_and_statistics_write()
-
-        finish_thread()
+        if not client_message_connection.timestamp:
+            client_message_connection.timestamp = datetime.now()
 
-        # After the socket clean up, we will still raise the exception to the main thread.
-        raise e
+        handle_exceptions_on_main_connection_thread(e, client_message_connection)