atomicshop 2.11.47__py3-none-any.whl → 3.10.5__py3-none-any.whl

atomicshop/wrappers/socketw/dns_server.py

@@ -3,47 +3,251 @@ import datetime
 import time
 import threading
 import socket
+import logging
+from pathlib import Path
+from typing import Literal, Optional
+import multiprocessing
 
 from ...print_api import print_api
 from ..loggingw import loggingw
+from ..psutilw import psutil_networks
+from ...basics import booleans, tracebacks
+from ...file_io import csvs
+from ... import networks
 
+# noinspection PyPackageRequirements
 import dnslib
+# noinspection PyPackageRequirements
 from dnslib import DNSRecord, DNSHeader, RR, A
 
 
+class DnsPortInUseError(Exception):
+    pass
+
+
+class DnsConfigurationValuesError(Exception):
+    pass
+
+
+LOGGER_NAME: str = 'dns_traffic'
+DNS_STATISTICS_HEADER: str = (
+    'timestamp,dns_type,client_ipv4,client_port,qname,qtype,qclass,header,error')
+
+
+class DnsStatisticsCSVWriter:
+    """
+    Class to write statistics to CSV file.
+    This can be initiated at the main, and then passed to the thread worker function.
+    """
+    def __init__(
+            self,
+            statistics_directory_path: str
+    ):
+        self.csv_logger = loggingw.create_logger(
+            logger_name=LOGGER_NAME,
+            directory_path=statistics_directory_path,
+            add_timedfile_with_internal_queue=True,
+            formatter_filehandler='MESSAGE',
+            file_type='csv',
+            header=DNS_STATISTICS_HEADER
+        )
+
+    def write_row(
+            self,
+            client_address: tuple,
+            timestamp=None,
+            dns_type: Literal['request', 'response'] = None,
+            dns_request = None,
+            dns_response = None,
+            error: str = None,
+    ):
+        if not timestamp:
+            timestamp = datetime.datetime.now()
+
+        if not dns_type:
+            if not dns_request and not dns_response:
+                raise ValueError("Either DNS Request or DNS Response must be provided.")
+            elif dns_request and dns_response:
+                raise ValueError("Either DNS Request or DNS Response must be provided. Not both.")
+
+        if dns_request:
+            dns_type = 'request'
+        elif dns_response:
+            dns_type = 'response'
+
+        if dns_type not in ['request', 'response']:
+            raise ValueError(f"DNS Type can be only 'request' or 'response'. Provided: {dns_type}")
+
+        client_ipv4, client_port = client_address
+        client_ipv4: str
+        client_port: str = str(client_port)
+
+        qname: str = str()
+        qtype: str = str()
+        qclass: str = str()
+        rr: str = str()
+        header: str = str()
+
+        if dns_request:
+            qname = str(dns_request.q.qname)[:-1]
+            qtype = dnslib.QTYPE[dns_request.q.qtype]
+            qclass = dnslib.CLASS[dns_request.q.qclass]
+
+        if dns_response:
+            qname = str(dns_response.q.qname)[:-1]
+            qtype = dnslib.QTYPE[dns_response.q.qtype]
+            qclass = dnslib.CLASS[dns_response.q.qclass]
+            rr: str = str(dns_response.rr)
+            header = str(dns_response.header)
+
+        escaped_line_string: str = csvs.escape_csv_line_to_string([
+            timestamp,
+            dns_type,
+            client_ipv4,
+            client_port,
+            qname,
+            qtype,
+            qclass,
+            rr,
+            header,
+            error
+        ])
+
+        self.csv_logger.info(escaped_line_string)
+
+    def write_error(
+            self,
+            dns_type: Literal['request', 'response'],
+            error_message: str,
+            client_address: tuple
+    ):
+        """
+        Write the error message to the statistics CSV file.
+        This is used for easier execution, since most of the parameters will be empty on accept.
+
+        :param dns_type: Literal['request', 'response'], DNS request or response.
+        :param error_message: string, error message.
+        :param client_address: tuple, client address (IPv4, Port).
+        :return:
+        """
+
+        self.write_row(
+            dns_type=dns_type,
+            client_address=client_address,
+            error=error_message
+        )
+
+
 class DnsServer:
     """
     DnsServer class is responsible to handle DNS Requests on port 53 based on configuration and send DNS Response back.
     """
-    logger = loggingw.get_logger_with_level("network." + __name__.rpartition('.')[2])
+    # noinspection PyPep8Naming
+    def __init__(
+            self,
+            listening_address: str,
+            log_directory_path: str,
+            backupCount_log_files_x_days: int = 0,
+            forwarding_dns_service_ipv4: str = '8.8.8.8',
+            forwarding_dns_service_port: int = 53,
+            resolve_by_engine: tuple[bool, list] = (False, None),
+            resolve_regular_pass_thru: bool = False,
+            resolve_all_domains_to_ipv4: tuple[bool, str] = (False, '127.0.0.1'),
+            offline_mode: bool = False,
+            buffer_size_receive: int = 8192,
+            response_ttl: int = 60,
+            dns_service_retries: int = 5,
+            cache_timeout_minutes: int = 60,
+            logger: logging.Logger = None,
+            logging_queue: multiprocessing.Queue = None,
+            logger_name: str = None
+    ):
+        """
+        Initialize the DNS Server object with all the necessary settings.
+
+        :param listening_address: str: Interface and a port that the DNS Server will listen on.
+            Example: '0.0.0.0:53'. For all interfaces on port 53.
+        :param log_directory_path: str: Path to the directory where the logs will be saved.
+        :param backupCount_log_files_x_days: int: How many days the log files will be kept.
+            Default is 0, which means that the log files will be kept indefinitely.
+            More than 0 means that the log files will be deleted after the specified days.
+        :param forwarding_dns_service_ipv4: str: IPv4 address of the DNS Service that will be used for resolving.
+            Example: '8.8.8.8'. For Google DNS Service.
+        :param forwarding_dns_service_port: int: Port number of the DNS Service that will be used for resolving.
+            Default is 53.
+        :param resolve_by_engine: tuple(boolean to enable the feature, list of engines).
+            True, The list of predefined engines will be used to resolve the domains.
+                Each list has a list of specific domains that will be routed to specified destination IPv4 address.
+        :param resolve_all_domains_to_ipv4: bool: If the DNS Server should resolve all the domains
+            to the provided origin DNS Service without altering the DNS request/response.
+        :param resolve_all_domains_to_ipv4: tuple(boolean to enable the feature, string IPv4 of the target).
+            True, the DNS Server will route all domains to the specified IPv4.
+        :param offline_mode: bool: If the DNS Server should work in offline mode.
+        :param buffer_size_receive: int: Buffer size of the connection while receiving messages.
+        :param response_ttl: int, Time to live of the DNS Response that will be returned. Default is 60 seconds.
+        :param dns_service_retries: int, How many times the request will be sent to forwarded DNS Service on errors:
+            (socket connect / request send / response receive).
+        :param cache_timeout_minutes: int: Timeout in minutes to clear the DNS Cache.
+            server. Each domain will be pass in the queue as a string.
+
+        :param logger: logging.Logger: Logger object to use for logging. If not provided, a new logger will be created.
+        :param logging_queue: multiprocessing.Queue: Queue to pass the logs to the QueueListener.
+            You will use this in case you run the DNS Server in a separate process.
+            Of course, you need to have a QueueListener to listen to this queue.
+
+        You can pass only one of the following: 'logger', 'logging_queue'.
+        """
+
+        self.listening_address: str = listening_address
+        self.log_directory_path: str = log_directory_path
+        self.backupCount_log_files_x_days: int = backupCount_log_files_x_days
+        self.forwarding_dns_service_ipv4: str = forwarding_dns_service_ipv4
+        self.forwarding_dns_service_port: int = forwarding_dns_service_port
+        self.resolve_by_engine: tuple[bool, list] = resolve_by_engine
+        self.resolve_regular_pass_thru: bool = resolve_regular_pass_thru
+        self.resolve_all_domains_to_ipv4: tuple[bool, str] = resolve_all_domains_to_ipv4
+        self.offline_mode: bool = offline_mode
+        self.buffer_size_receive: int = buffer_size_receive
+        self.response_ttl: int = response_ttl
+        self.dns_service_retries: int = dns_service_retries
+        self.cache_timeout_minutes: int = cache_timeout_minutes
+        self.logging_queue: multiprocessing.Queue = logging_queue
+        self.logging_name: str = logger_name
+
+        if logger and logging_queue:
+            raise ValueError("You can pass only one of the following: 'logger', 'logging_queue'.")
+
+        self.listening_interface, listening_port = self.listening_address.split(':')
+        self.listening_interface: str
+        self.listening_port: int = int(listening_port)
+        self.resolve_by_engine_enable, self.engine_list = self.resolve_by_engine
+        self.resolve_by_engine_enable: bool
+        self.engine_list: list
+        self.resolve_all_domains_to_ipv4_enable, self.resolve_all_domains_target = self.resolve_all_domains_to_ipv4
+        self.resolve_all_domains_to_ipv4_enable: bool
+        self.resolve_all_domains_target: str
+
+        self.intercept_domain_dict: dict = dict()
+        for engine in self.engine_list:
+            # If the engine is not a reference engine.
+            if engine.engine_name != '__reference_general':
+                # Get the domains from the engine.
+
+                self.intercept_domain_dict.update(engine.domain_target_dict)
 
-    def __init__(self, config):
         # Settings for static DNS Responses in offline mode.
-        self.offline_route_ipv4 = '10.10.10.10'
-        self.offline_route_ipv6 = 'fe80::3c09:df29:d52b:af39'
-        self.offline_route_domain = 'domain.com'
-        self.offline_srv_answer = \
+        self.offline_route_ipv4: str = '10.10.10.10'
+        self.offline_route_ipv6: str = 'fe80::3c09:df29:d52b:af39'
+        self.offline_route_domain: str = 'domain.com'
+        self.offline_srv_answer: str = \
             '.                       86391   IN      SOA     domain.com. domain.com. 2022012500 1800 900 604800 86400'
+        # self.offline_https_answer: str = str()
 
-        # Other settings.
-        # Full domain list to pass to TCP Server module.
-        self.domain_list: list = list()
-
-        # Set Buffer size of the connection while receiving messages. The function uses this variable right away.
-        self.buffer_size_receive: int = 8192
-        # TTL variable that is going to be returned in DNS response.
-        self.response_ttl: int = 60
-        # How many times the DNS Service will retry on errors (socket connect / request send / response receive)
-        self.dns_service_retries: int = 5
         # If forwarding to Live DNS Service fails. Currently, we didn't send anything, so it's 'False'.
         self.retried: bool = False
         # Defining cache dictionary for assigning DNS Questions to DNS Answers
         self.dns_questions_to_answers_cache: dict = dict()
 
-        # Queue for all the requested domains that hit the dns server.
-        # self.request_domain_queue: queue.Queue = queue.Queue()
-        self.request_domain_queue = None
-
         # Filename to save all the known domains and their relative IPv4 addresses.
         self.known_domains_filename: str = 'dns_known_domains.txt'
         # Filename to save all the known IPv4 addresses and their relative domains.
@@ -51,13 +255,77 @@ class DnsServer:
         # Filename to save domains and their IPv4 addresses by time they hit the DNS server.
         self.known_dns_ipv4_by_time_filename: str = 'dns_ipv4_by_time.txt'
 
-        # Configuration object with all the settings.
-        self.config = config
-
         # Logger that logs all the DNS Requests and responses in DNS format. These entries will not present in
         # network log of TCP Server module.
-        self.dns_full_logger = loggingw.get_logger_with_timedfilehandler(
-            logger_name="dns", directory_path=self.config['log']['logs_path'], disable_duplicate_ms=True)
+        self.dns_statistics_csv_writer = DnsStatisticsCSVWriter(statistics_directory_path=log_directory_path)
+
+        if not logger_name and not logger and not logging_queue:
+            self.logger_name = Path(__file__).stem
+        elif logger_name and (logger or logging_queue):
+            self.logger_name = f'{logger_name}.{Path(__file__).stem}'
+
+        # Check if the logger was provided, if not, create a new logger.
+        if not logger and not logging_queue:
+            self.logger: logging.Logger = loggingw.create_logger(
+                logger_name=Path(__file__).stem,
+                directory_path=self.log_directory_path,
+                add_stream=True,
+                add_timedfile_with_internal_queue=True,
+                formatter_streamhandler='DEFAULT',
+                formatter_filehandler='DEFAULT',
+                backupCount=self.backupCount_log_files_x_days
+            )
+        elif logger:
+            # Create child logger for the provided logger with the module's name.
+            self.logger: logging.Logger = loggingw.get_logger_with_level(self.logger_name)
+        elif logging_queue:
+            self.logger: logging.Logger = loggingw.create_logger(
+                logger_name=self.logger_name,
+                add_queue_handler=True,
+                log_queue=self.logging_queue
+            )
+
+        self.test_config()
+
+    def test_config(self):
+        try:
+            booleans.is_only_1_true_in_list(
+                booleans_list_of_tuples=[
+                    (self.resolve_by_engine_enable, 'resolve_by_engine_enable'),
+                    (self.resolve_regular_pass_thru, 'resolve_regular_pass_thru'),
+                    (self.resolve_all_domains_to_ipv4_enable, 'resolve_all_domains_to_ipv4_enable')
+                ],
+                raise_if_all_false=True
+            )
+        except ValueError as e:
+            print_api(f'DnsConfigurationValuesError: {str(e)}', error_type=True, color="red", logger=self.logger)
+            # Wait for the message to be printed and saved to file.
+            time.sleep(1)
+            raise DnsConfigurationValuesError(e)
+
+        # If the listening interface is not localhost, check if the interface can be bound to.
+        if not self.listening_interface.startswith('127.'):
+            host_ips: list[str] = networks.get_host_ips_psutil(ipv6=False)
+            if self.listening_interface not in host_ips:
+                message = (f"Listening interface [{self.listening_interface}] is not assigned to any of the host "
+                           f"network interfaces. Current host IPv4 addresses: {host_ips}")
+                print_api(f'DnsConfigurationValuesError: {str(message)}', error_type=True, color="red", logger=self.logger)
+                # Wait for the message to be printed and saved to file.
+                time.sleep(1)
+                raise DnsConfigurationValuesError(message)
+
+        ips_ports: list[str] = [f'{self.listening_interface}:{self.listening_port}']
+        port_in_use = psutil_networks.get_processes_using_port_list(ips_ports)
+        if port_in_use:
+            error_messages: list = list()
+            for port, process_info in port_in_use.items():
+                error_messages.append(f"Port [{port}] is already in use by process: {process_info}")
+
+            message = "\n".join(error_messages)
+            print_api(f'DnsPortInUseError: {str(message)}', error_type=True, color="red", logger=self.logger)
+            # Wait for the message to be printed and saved to file.
+            time.sleep(1)
+            raise DnsPortInUseError(message)
 
     def thread_worker_empty_dns_cache(self, function_sleep_time: int):
         """
@@ -71,10 +339,15 @@ class DnsServer:
             self.dns_questions_to_answers_cache = dict()
             self.logger.info("*** DNS cache cleared")
 
-    def start(self):
+    def start(
+            self,
+            is_ready_multiprocessing: multiprocessing.Event = None
+    ):
         """
         Main DNS Server function to start it.
 
+        :param is_ready_multiprocessing: multiprocessing.Event: Event to signal that the DNS Server is ready.
+
         :return: None.
         """
 
@@ -90,31 +363,32 @@ class DnsServer:
         known_a_records_ipv4_dict: dict = dict()
 
         # Check if 'route_to_tcp_server_only_engine_domains' was set to 'True' and output message accordingly.
-        if self.config['dns']['route_to_tcp_server_only_engine_domains']:
-            message = "Routing only engine domains to Built-in TCP Server."
+        if self.resolve_by_engine_enable:
+            message = "Routing engine domains to the specified IPv4 targets."
             print_api(message, logger=self.logger)
 
-            message = f"Current engine domains: {self.domain_list}"
-            print_api(message, logger=self.logger, color='green')
+            message = f"Current all engines domains: {list(self.intercept_domain_dict.keys())}"
+            print_api(message, logger=self.logger, color='blue')
 
-        if self.config['dns']['route_to_tcp_server_all_domains']:
-            message = "Routing all domains to Built-in TCP Server."
-            print_api(message, logger=self.logger, color='green')
+        if self.resolve_all_domains_to_ipv4_enable:
+            message = f"Routing all domains to the specified target: [{self.resolve_all_domains_target}]"
+            print_api(message, logger=self.logger, color='blue')
 
-        if self.config['dns']['regular_resolving']:
-            message = f"Routing all domains to Live DNS Service: {self.config['dns']['forwarding_dns_service_ipv4']}"
-            print_api(message, logger=self.logger, color='green')
+        if self.resolve_regular_pass_thru:
+            message = f"Routing all domains to the specified Origin DNS Service: {self.forwarding_dns_service_ipv4}:{self.forwarding_dns_service_port}"
+            print_api(message, logger=self.logger, color='blue')
 
         # The list that will hold all the threads that can be joined later
         threads_list: list = list()
 
         # Starting a thread that will empty the DNS Cache lists
         thread_current = threading.Thread(target=self.thread_worker_empty_dns_cache,
-                                          args=(self.config['dns']['cache_timeout_minutes'],))
-        # Append to list of threads, so they can be "joined" later
-        threads_list.append(thread_current)
+                                          args=(self.cache_timeout_minutes,))
+        thread_current.daemon = True
         # Start the thread
         thread_current.start()
+        # Append to list of threads, so they can be "joined" later
+        threads_list.append(thread_current)
 
         # To handle DNS requests UDP socket is needed.
         # AF_INET - Socket family of IPv4
@@ -124,9 +398,15 @@ class DnsServer:
 
             # Binding / assigning the port to the server / this script, that is going to be used for
             # receiving connections.
-            main_socket_object.bind((self.config['dns']['listening_interface'], self.config['dns']['listening_port']))
+            main_socket_object.bind((self.listening_interface, self.listening_port))
+
+            if is_ready_multiprocessing:
+                # If the DNS Server is running in a separate process, signal that the DNS Server is ready.
+                is_ready_multiprocessing.set()
 
             while True:
+                forward_to_tcp_server = False  # reset every request
+
                 # Needed this logging line when DNS was separate process.
                 # self.logger.info("Waiting to receive new requests...")
 
@@ -135,24 +415,30 @@ class DnsServer:
                     client_data: bytes
                     client_address: tuple
                 except ConnectionResetError:
+                    client_address = (str(), int())
+                    traceback_string = tracebacks.get_as_string(one_line=True)
                     # This error happens when the client closes the connection before the server.
                     # This is not an error for a DNS Server, but we'll log it anyway only with the full DNS logger.
-                    message = "Error: to receive DNS request, An existing connection was forcibly closed"
-                    # print_api(message, logger=self.logger, logger_method='error', traceback_string=True, oneline=True)
-                    print_api(
-                        message, logger=self.dns_full_logger, logger_method='error', traceback_string=True,
-                        oneline=True)
-                    self.dns_full_logger.info("==========")
-                    pass
+                    message = (f"Error: to receive DNS request, An existing connection was forcibly closed | "
+                               f"{traceback_string}")
+                    # print_api(message, logger=self.logger, logger_method='critical', traceback_string=True)
+                    self.dns_statistics_csv_writer.write_error(
+                        dns_type='request', client_address=client_address, error_message=message)
                     continue
-                except Exception:
-                    message = "Unknown Exception: to receive DNS request"
-                    print_api(
-                        message, logger=self.logger, logger_method='critical', traceback_string=True, oneline=True)
-                    self.logger.info("==========")
-                    pass
+                except KeyboardInterrupt:
+                    # message = "KeyboardInterrupt: Stopping DNS Server..."
+                    # print_api(message, logger=self.logger, logger_method='info')
+                    # self.logger.info(message)
+                    # Stop the server
+                    break
+                except Exception as e:
+                    message = f"Unknown Exception to receive DNS request: {str(e)}"
+                    print_api(message, logger=self.logger, logger_method='critical', traceback_string=True)
+                    self.dns_statistics_csv_writer.write_error(
+                        dns_type='request', client_address=client_address, error_message=message)
                     continue
 
+                # noinspection PyBroadException
                 try:
                     # This is the real point when the request received was logged, but since it takes too much place
                     # on the screen, moved it to full request logging position.
@@ -162,11 +448,11 @@ class DnsServer:
 
                     # Received DNS request that needs to be parsed to readable format
                     dns_object: dnslib.dns.DNSRecord = DNSRecord.parse(client_data)
-                    # "qtype" returns as numeric identification, we need to convert it to Readable QType (DNS Record Type)
-                    # provided by the dnslib
+                    # "qtype" returns as numeric identification, we need to convert it to
+                    # Readable QType (DNS Record Type) provided by the dnslib
                     # "dns_object.q" is the Question from the client that holds all the DNS question data,
-                    # like which domain was
-                    # questioned for resolving, the class (example: IN), DNS Record Type that was questioned and a header.
+                    # like which domain was questioned for resolving,
+                    # the class (example: IN), DNS Record Type that was questioned and a header.
                     # "dns_object.q.qtype" returns only QType of the Question
                     qtype_string: str = dnslib.QTYPE[dns_object.q.qtype]
                     # "qclass" returns as numeric identification, we need to convert it
@@ -182,25 +468,18 @@ class DnsServer:
                     # "dns_object.q.qname" returns only the questioned domain with "." (dot) in the end,
                     # which needs to be removed.
                     question_domain: str = str(dns_object.q.qname)[:-1]
-                    self.dns_full_logger.info(f"QCLASS: {qclass_string}")
-                    self.dns_full_logger.info(f"QTYPE: {qtype_string}")
-                    self.dns_full_logger.info(f"Question Domain: {question_domain}")
+                    self.dns_statistics_csv_writer.write_row(client_address=client_address, dns_request=dns_object)
 
-                    message = f"Received request from: {client_address}. Full Request: {dns_object.q}"
+                    message = (f"Received DNS request: {question_domain} | {qclass_string} | {qtype_string} |   "
+                               f"From: {client_address}.")
                     self.logger.info(message)
-                    self.dns_full_logger.info(message)
-
-                    self.dns_full_logger.info("--")
 
                     # Nullifying the DNS cache for current request before check.
                     dns_cached_request = False
                     # Check if the received data request from client is already in the cache
                     if client_data in self.dns_questions_to_answers_cache:
-                        message = "!!! Question / Answer is already in the dictionary..."
+                        # message = "!!! Request / Response is already in the dictionary..."
                         # self.logger.info(message)
-                        self.dns_full_logger.info(message)
-
-                        self.dns_full_logger.info("--")
 
                         # Get the response from the cached answers list
                         dns_response = self.dns_questions_to_answers_cache[client_data]
@@ -211,12 +490,12 @@ class DnsServer:
                     else:
                         # Check if the incoming Record is "A" record.
                         if qtype_string == "A":
-                            # Check if 'route_to_tcp_server_only_engine_domains' is set to 'True' in 'config.ini'.
-                            # If so, we need to check if the incoming domain contain any of the 'engine_domains'.
-                            if self.config['dns']['route_to_tcp_server_only_engine_domains']:
+                            # Check if 'resolve_to_tcp_server_only_tcp_resolve_domains' is set to 'True'.
+                            # If so, we need to check if the incoming domain contain any of the domains in the list.
+                            if self.resolve_by_engine_enable:
                                 # If current query domain (+ subdomains) CONTAIN any of the domains from modules config
                                 # files and current request contains "A" (IPv4) record.
-                                if any(x in question_domain for x in self.domain_list):
+                                if any(x in question_domain for x in self.intercept_domain_dict.keys()):
                                     # If incoming domain contains any of the 'engine_domains' then domain will
                                     # be forwarded to our TCP Server.
                                     forward_to_tcp_server = True
@@ -225,12 +504,12 @@ class DnsServer:
 
                             # If 'route_to_tcp_server_all_domains' was set to 'False' in 'config.ini' file then
                             # we'll forward all 'A' records domains to the Built-in TCP Server.
-                            if self.config['dns']['route_to_tcp_server_all_domains']:
+                            if self.resolve_all_domains_to_ipv4_enable:
                                 forward_to_tcp_server = True
 
                             # If 'regular_resolving' was set to 'True' in 'config.ini' file then
                             # we'll forward all 'A' records domains to the Live DNS Service.
-                            if self.config['dns']['regular_resolving']:
+                            if self.resolve_regular_pass_thru:
                                 forward_to_tcp_server = False
 
                         # If incoming record is not an "A" record, then it will not be forwarded to our TCP Server.
@@ -239,9 +518,15 @@ class DnsServer:
 
                         # If 'forward_to_tcp_server' is 'True' we'll resolve the record with our TCP Server IP address.
                         if forward_to_tcp_server:
-                            # If the request is forwarded to TCP server, then we'll put the domain in the domain queue.
-                            # self.request_domain_queue.put(question_domain)
-                            self.request_domain_queue.queue = question_domain
+                            if self.resolve_by_engine_enable:
+                                for engine in self.engine_list:
+                                    resolved_target_ipv4 = get_target_ip_from_engine(question_domain, engine.domain_target_dict)
+                                    # If the domain was found in the current engine's domain list, we can stop the loop.
+                                    if resolved_target_ipv4:
+                                        break
+                            elif self.resolve_all_domains_to_ipv4_enable:
+                                # Assign the target IPv4 address to the resolved target IPv4 variable.
+                                resolved_target_ipv4 = self.resolve_all_domains_target
 
                             # Make DNS response that will refer TCP traffic to our server
                             dns_built_response = DNSRecord(
@@ -250,7 +535,7 @@ class DnsServer:
                                 # q=DNSQuestion(question_domain),
                                 q=dns_object.q,
                                 a=RR(question_domain,
-                                     rdata=A(self.config['dns']['target_tcp_server_ipv4']),
+                                     rdata=A(resolved_target_ipv4),
                                      ttl=self.response_ttl)
                             )
                             # Encode the response that was built above to legit DNS Response
@@ -261,7 +546,7 @@ class DnsServer:
                         # any of the domains from modules config files
                         else:
                             # If we're in offline mode
-                            if self.config['dns']['offline_mode']:
+                            if self.offline_mode:
                                 # Make DNS response that will refer TCP traffic to our server
                                 # dns_question = DNSRecord.question(question_domain)
                                 dns_built_response = dns_object.reply()
@@ -272,14 +557,13 @@ class DnsServer:
                                     if qtype_string == "AAAA":
                                         dns_built_response.add_answer(
                                             *RR.fromZone(
-                                                question_domain + " " + str(self.response_ttl) + " " + qtype_string + " " +
-                                                self.offline_route_ipv6)
+                                                f'{question_domain} {str(self.response_ttl)} {qtype_string} '
+                                                f'{self.offline_route_ipv6}')
                                         )
 
-                                        message = f"!!! Question / Answer is in offline mode returning " \
+                                        message = f"!!! Request / Response is in offline mode returning " \
                                                   f"{self.offline_route_ipv6}."
                                         self.logger.info(message)
-                                        self.dns_full_logger.info(message)
 
                                     # SRV Record type explanation:
                                     # https://www.cloudflare.com/learning/dns/dns-records/dns-srv-record/
@@ -290,44 +574,39 @@ class DnsServer:
                                     # com. domain.com. 2022012500 1800 900 604800 86400
                                     # Basically SOA is the same, but can be with additional fields.
                                     # Since, it's offline and not online - we don't really care.
-                                    elif qtype_string == "SRV" or qtype_string == "SOA":
+                                    elif qtype_string == "SRV" or qtype_string == "SOA" or qtype_string == "HTTPS":
                                         dns_built_response.add_answer(*RR.fromZone(self.offline_srv_answer))
 
-                                        message = f"!!! Question / Answer is in offline mode returning: " \
+                                        message = f"!!! Request / Response is in offline mode returning: " \
                                                   f"{self.offline_srv_answer}."
                                         self.logger.info(message)
-                                        self.dns_full_logger.info(message)
                                     elif qtype_string == "ANY":
                                         dns_built_response.add_answer(
-                                            # *RR.fromZone(question_domain + " " + str(response_ttl) + " " + qclass_string +
-                                            #             " CNAME " + dns_server_offline_route_domain)
                                             *RR.fromZone(question_domain + " " + str(self.response_ttl) + " CNAME " +
                                                          self.offline_route_domain)
                                         )
 
-                                        message = f"!!! Question / Answer is in offline mode returning " \
+                                        message = f"!!! Request / Response is in offline mode returning " \
                                                   f"{self.offline_route_domain}."
                                         self.logger.info(message)
-                                        self.dns_full_logger.info(message)
                                     else:
                                         dns_built_response.add_answer(
                                             *RR.fromZone(
-                                                question_domain + " " + str(self.response_ttl) + " " + qtype_string + " " +
-                                                self.offline_route_ipv4)
+                                                question_domain + " " + str(self.response_ttl) + " " + qtype_string +
+                                                " " + self.offline_route_ipv4)
                                         )
 
-                                        message = f"!!! Question / Answer is in offline mode returning " \
+                                        message = f"!!! Request / Response is in offline mode returning " \
                                                   f"{self.offline_route_ipv4}."
                                         self.logger.info(message)
-                                        self.dns_full_logger.info(message)
                                 # Values error means in most cases that you create wrong response
                                 # for specific type of request.
                                 except ValueError:
                                     message = f"Looks like wrong type of response for QTYPE: {qtype_string}. Response: "
                                     print_api(message, logger=self.logger, logger_method='critical',
-                                              traceback_string=True, oneline=True)
+                                              traceback_string=True)
                                     print_api(f"{dns_built_response}", logger=self.logger, logger_method='critical',
-                                              traceback_string=True, oneline=True)
+                                              traceback_string=True)
                                     # Pass the exception.
                                     pass
                                     # Continue to the next DNS request, since there's nothing to do here right now.
@@ -335,18 +614,15 @@ class DnsServer:
                                 # General exception in response creation.
                                 except Exception:
                                     message = \
-                                        f"Unknown exception while creating response for QTYPE: {qtype_string}. Response: "
+                                        (f"Unknown exception while creating response for QTYPE: {qtype_string}. "
+                                         f"Response: \n{dns_built_response}")
                                     print_api(message, logger=self.logger, logger_method='critical',
-                                              traceback_string=True, oneline=True)
-                                    print_api(f"{dns_built_response}", logger=self.logger, logger_method='critical',
-                                              traceback_string=True, oneline=True)
+                                              traceback_string=True)
                                     # Pass the exception.
                                     pass
                                     # Continue to the next DNS request, since there's nothing to do here right now.
                                     continue
 
-                                self.dns_full_logger.info("--")
-
                                 # Encode the response that was built above to legit DNS Response
                                 dns_response = dns_built_response.pack()
                             # If we're in online mode
@@ -361,26 +637,26 @@ class DnsServer:
                                     # Since, it's probably going to succeed.
                                     if counter > 0:
                                         self.logger.info(f"Retry #: {counter}/{self.dns_service_retries}")
-                                    self.dns_full_logger.info(
+                                    self.logger.info(
                                         f"Forwarding request. Creating UDP socket to: "
-                                        f"{self.config['dns']['forwarding_dns_service_ipv4']}:"
-                                        f"{self.config['dns']['listening_port']}")
+                                        f"{self.forwarding_dns_service_ipv4}:"
+                                        f"{self.forwarding_dns_service_port}")
                                     try:
                                         google_dns_ipv4_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
                                         google_dns_ipv4_socket.settimeout(5)
 
                                         message = "Socket created, Forwarding..."
                                         # self.logger.info(message)
-                                        self.dns_full_logger.info(message)
+                                        self.logger.info(message)
 
                                         google_dns_ipv4_socket.sendto(client_data, (
-                                            self.config['dns']['forwarding_dns_service_ipv4'],
-                                            self.config['dns']['listening_port']
+                                            self.forwarding_dns_service_ipv4,
+                                            self.forwarding_dns_service_port
                                         ))
                                         # The script needs to wait a second or receive can hang
                                         message = "Request sent to the forwarding DNS, Receiving the answer..."
                                         # self.logger.info(message)
-                                        self.dns_full_logger.info(message)
+                                        self.logger.info(message)
 
                                         dns_response, google_address = \
                                             google_dns_ipv4_socket.recvfrom(self.buffer_size_receive)
@@ -399,9 +675,8 @@ class DnsServer:
                                             self.logger.info(
                                                 f"Retried {self.dns_service_retries} times. "
                                                 f"Couldn't forward DNS request to: "
-                                                f"[{self.config['dns']['forwarding_dns_service_ipv4']}]. "
+                                                f"[{self.forwarding_dns_service_ipv4}]. "
                                                 f"Continuing to next request.")
-                                            self.dns_full_logger.info("==========")
 
                                         # From here continue to the next iteration of While loop.
                                         continue
@@ -414,36 +689,28 @@ class DnsServer:
                                 if retried:
                                     continue
 
-                                self.dns_full_logger.info(
-                                    f"Answer received from: {self.config['dns']['forwarding_dns_service_ipv4']}")
+                                self.logger.info(
+                                    f"Answer received from: {self.forwarding_dns_service_ipv4}")
 
                                 # Closing the socket to forwarding service
                                 google_dns_ipv4_socket.close()
-                                self.dns_full_logger.info("Closed socket to forwarding service")
+                                self.logger.info("Closed socket to forwarding service")
 
                                 # Appending current DNS Request and DNS Answer to the Cache
                                 self.dns_questions_to_answers_cache.update({client_data: dns_response})
 
-                            # if dns_object.q.qtype == dnslib.QTYPE.AAAA:
-
-                            # dns_response = dns_object.reply()
-                            # dns_response.add_answer(*RR.fromZone(f"{question_domain} 60 {qtype_object} 8.8.8.8"))
-
-                            # dns_built_response = \
-                            #     DNSRecord(
-                            #         DNSHeader(id=dns_object.header.id, qr=1, aa=1, ra=1), q=DNSQuestion(question_domain),
-                            #     a=RR.fromZone(question_domain + " 60 " + qtype_object + " " + dns_server_offline_ipv4))
-
-                    # If 'forward_to_tcp_server' it means that we built the response, and we don't need to reparse it, since
-                    # we already have all the data.
+                    # If 'forward_to_tcp_server' it means that we built the response, and we don't need to reparse it,
+                    # since we already have all the data.
                     if forward_to_tcp_server:
-                        self.dns_full_logger.info(f"Response IP: {dns_built_response.short()}")
+                        # self.logger.info(f"Response {dns_built_response.short()}")
+                        self.dns_statistics_csv_writer.write_row(
+                            client_address=client_address, dns_response=dns_built_response)
 
                         message = f"Response Details: {dns_built_response.rr}"
-                        print_api(message, logger=self.dns_full_logger, logger_method='info', oneline=True)
+                        print_api(message, logger=self.logger, logger_method='info', oneline=True)
 
-                        message = f"Response Full Details: {dns_built_response.format(prefix='', sort=True)}"
-                        print_api(message, logger=self.dns_full_logger, logger_method='info', oneline=True)
+                        # message = f"Response Full Details: {dns_built_response.format(prefix='', sort=True)}"
+                        # print_api(message, logger=self.logger, logger_method='info', oneline=True)
 
                         # Now we can turn it to false, so it won't trigger this
                         # condition next time if the response was not built
@@ -459,30 +726,34 @@ class DnsServer:
                         # Reinitializing the ipv4 addresses list.
                         ipv4_addresses = list()
 
-                        if dns_response_parsed.a:
+                        # If the DNS answer section isn't empty, and log the returned IPv4 addresses.
+                        if dns_response_parsed.rr:
                             for rr in dns_response_parsed.rr:
                                 if isinstance(rr.rdata, A):
-                                    self.dns_full_logger.info(f"Response IP: {rr.rdata}")
+                                    self.dns_statistics_csv_writer.write_row(
+                                        client_address=client_address, dns_response=dns_response_parsed)
+
+                                    self.logger.info(f"Response IP: {rr.rdata}")
 
                                     # Adding the address to the list as 'str' object and not 'dnslib.dns.A'.
                                     ipv4_addresses.append(str(rr.rdata))
 
-                        message = f"Response Details: {dns_response_parsed.rr}"
-                        print_api(message, logger=self.dns_full_logger, logger_method='info', oneline=True)
-
-                        message = f"Response Full Details: {dns_response_parsed}"
-                        print_api(message, logger=self.dns_full_logger, logger_method='info', oneline=True)
+                        # message = f"Response Details: {dns_response_parsed.rr}"
+                        # print_api(message, logger=self.dns_statistics_csv_writer, logger_method='info', oneline=True)
+                        #
+                        # message = f"Response Full Details: {dns_response_parsed}"
+                        # print_api(message, logger=self.dns_statistics_csv_writer, logger_method='info', oneline=True)
 
-                    self.dns_full_logger.info("Sending DNS response back to client...")
+                    self.logger.info("Sending DNS response back to client...")
                     main_socket_object.sendto(dns_response, client_address)
-                    self.dns_full_logger.info("DNS Response sent...")
+                    self.logger.info("DNS Response sent...")
 
                     # 'ipv4_addresses' list contains entries of type 'dnslib.dns.A' and not string.
                     # We'll convert each entry to string, so strings can be searched in this list.
                     # for index, ip_address in enumerate(ipv4_addresses):
                     #     ipv4_addresses[index] = str(ip_address)
 
-                    # ==============================================================================================================
+                    # ==================================================================================================
                     # # Known domain dictionary of last 2 A records' management.
                     #
                     # # Sorting the addresses, so it will be easier to compare dictionaries in the list.
@@ -504,7 +775,7 @@ class DnsServer:
                     #
                     # dns.logger.info(f"Latest known list: {known_a_records_domains_list_last_entries}")
 
-                    # ==============================================================================================================
+                    # ==================================================================================================
                     # Known domain list management (A Records only)
 
                     # If current request is in the cache,
@@ -550,20 +821,20 @@ class DnsServer:
 
                                 # Save this string object as log file.
                                 with open(
-                                        self.config['log']['logs_path'] + os.sep + self.known_domains_filename, 'w'
+                                        self.log_directory_path + os.sep + self.known_domains_filename, 'w'
                                 ) as output_file:
                                     output_file.write(record_string_line)
 
-                                self.dns_full_logger.info(
-                                    f"Saved new known domains file: "
-                                    f"{self.config['log']['logs_path'] + os.sep + self.known_domains_filename}")
+                                # self.logger.info(
+                                #     f"Saved new known domains file: "
+                                #     f"{self.log_directory_path}{os.sep}{self.known_domains_filename}")
 
                     # Known domain list managements EOF
-                    # ==============================================================================================================
+                    # ==================================================================================================
                     # Known IPv4 address to domains list management (A Records only)
 
                     # If DNS Server 'offline_mode' was set to 'False'.
-                    if not self.config['dns']['offline_mode']:
+                    if not self.offline_mode:
                         dump_ipv4_dictionary_to_file = False
                         # If IPv4 address list is not empty, meaning this DNS request was A type.
                         if ipv4_addresses:
@@ -576,9 +847,9 @@ class DnsServer:
                                     # If so, get the list of current domains for current ipv4 address.
                                     current_domains_list = known_a_records_ipv4_dict[current_ip_address]
 
-                                    # If current question domain is not in the known domains that we had from previous DNS
-                                    # requests for the same IPv4 address, then we'll add this domain to the known domains
-                                    # list for this IPv4.
+                                    # If current question domain is not in the known domains that we had from
+                                    # previous DNS requests for the same IPv4 address, then we'll add this domain
+                                    # to the known domains list for this IPv4.
                                     # And update the dictionary of known IPv4 addresses and their domains.
                                     if question_domain not in current_domains_list:
                                         current_domains_list.append(question_domain)
@@ -609,16 +880,16 @@ class DnsServer:
 
                                     # Save this string object as log file.
                                     with open(
-                                            self.config['log']['logs_path'] + os.sep + self.known_ipv4_filename, 'w'
+                                            self.log_directory_path + os.sep + self.known_ipv4_filename, 'w'
                                     ) as output_file:
                                         output_file.write(record_string_line)
 
-                                    self.dns_full_logger.info(
-                                        f"Saved new known IPv4 addresses file: "
-                                        f"{self.config['log']['logs_path'] + os.sep + self.known_ipv4_filename}")
+                                    # self.logger.info(
+                                    #     f"Saved new known IPv4 addresses file: "
+                                    #     f"{self.log_directory_path}{os.sep}{self.known_ipv4_filename}")
 
                     # Known IPv4 address to domains list management EOF
-                    # ==============================================================================================================
+                    # ==================================================================================================
                     # Writing IPs by time.
 
                     # If IPv4 address list is not empty, meaning this DNS request was A type.
@@ -629,31 +900,87 @@ class DnsServer:
 
                             # Save this string object as log file.
                             with open(
-                                    self.config['log']['logs_path'] + os.sep + self.known_dns_ipv4_by_time_filename, 'a'
+                                    self.log_directory_path + os.sep + self.known_dns_ipv4_by_time_filename, 'a'
                             ) as output_file:
                                 output_file.write(record_string_line + '\n')
 
                     # EOF Writing IPs by time.
-                    # ==============================================================================================================
-                    # SSH Remote / LOCALHOST script execution to identify process section
-
-                    # Starting a thread that will query IPs of the last DNS request.
-                    # thread_current = \
-                    #     threading.Thread(
-                    #         target=thread_worker_check_process_by_ip, args=(ipv4_addresses, client_address[0],))
-                    # # Append to list of threads, so they can be "joined" later
-                    # threads_list.append(thread_current)
-                    # # Start the thread
-                    # thread_current.start()
-
-                    # EOF SSH / LOCALHOST executing process command line harvesting.
-                    # ==================================================================================================================
-
-                    self.dns_full_logger.info("==========")
+                    # ==================================================================================================
+
+                    # self.logger.info("==========")
                 except Exception:
                     message = "Unknown Exception: to parse DNS request"
                     print_api(
-                        message, logger=self.logger, logger_method='critical', traceback_string=True, oneline=True)
+                        message, logger=self.logger, logger_method='critical', traceback_string=True)
                     self.logger.info("==========")
                     pass
                     continue
+
+
+def get_target_ip_from_engine(
+        target_domain: str,
+        engine_domain_target_dict: dict
+) -> Optional[str]:
+    """
+    Get the target IP address from the engine.
+
+    :param target_domain: str: The domain to return the target IP address for.
+    :param engine_domain_target_dict: dict: The dictionary of domains and their target IPs.
+
+    :return: str: The target IP address.
+    """
+    # Iterate through the list of engines.
+    for domain, target_ip_port in engine_domain_target_dict.items():
+        # If the domain is exactly the same as the target domain,
+        if domain == target_domain:
+            # Get the target IP address from the engine.
+            return target_ip_port['ip']
+        elif domain in target_domain:
+            # Get the target IP address from the engine.
+            return target_ip_port['ip']
+
+    return None
+
+
+# noinspection PyPep8Naming
+def start_dns_server_multiprocessing_worker(
+        listening_address: str,
+        log_directory_path: str,
+        backupCount_log_files_x_days: int,
+        forwarding_dns_service_ipv4: str,
+        forwarding_dns_service_port: int,
+        resolve_by_engine: tuple[bool, list],
+        resolve_regular_pass_thru: bool,
+        resolve_all_domains_to_ipv4: tuple[bool, str],
+        offline_mode: bool,
+        cache_timeout_minutes: int,
+        logging_queue: multiprocessing.Queue,
+        logger_name: str,
+        is_ready_multiprocessing: multiprocessing.Event=None
+):
+    # Setting the current thread name to the current process name.
+    current_process_name = multiprocessing.current_process().name
+    threading.current_thread().name = current_process_name
+
+    try:
+        dns_server_instance = DnsServer(
+            listening_address=listening_address,
+            log_directory_path=log_directory_path,
+            backupCount_log_files_x_days=backupCount_log_files_x_days,
+            forwarding_dns_service_ipv4=forwarding_dns_service_ipv4,
+            forwarding_dns_service_port=forwarding_dns_service_port,
+            resolve_by_engine=resolve_by_engine,
+            resolve_regular_pass_thru=resolve_regular_pass_thru,
+            resolve_all_domains_to_ipv4=resolve_all_domains_to_ipv4,
+            offline_mode=offline_mode,
+            cache_timeout_minutes=cache_timeout_minutes,
+            logging_queue=logging_queue,
+            logger_name=logger_name
+        )
+    except (DnsPortInUseError, DnsConfigurationValuesError) as e:
+        _ = e
+        # Wait for the message to be printed and saved to file.
+        time.sleep(1)
+        return 1
+
+    dns_server_instance.start(is_ready_multiprocessing=is_ready_multiprocessing)