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

atomicshop/archiver/zips.py

@@ -1,293 +0,0 @@
-import os
-import time
-import zipfile
-from io import BytesIO
-from typing import Union
-
-from .. import filesystem
-from ..print_api import print_api
-
-
-def is_zip_zipfile(file_object: Union[str, bytes]) -> bool:
-    """
-    Function checks if the file is a zip file.
-    :param file_object: can be two types:
-        string, full path to the file.
-        bytes or BytesIO, the bytes of the file.
-    :return: boolean.
-    """
-
-    try:
-        if isinstance(file_object, bytes):
-            with BytesIO(file_object) as file_object:
-                with zipfile.ZipFile(file_object) as zip_object:
-                    zip_object.testzip()
-                    return True
-        elif isinstance(file_object, str):
-            with zipfile.ZipFile(file_object) as zip_object:
-                zip_object.testzip()
-                return True
-    except zipfile.BadZipFile:
-        return False
-
-
-def is_zip_magic_number(file_path: str) -> bool:
-    """
-    Function checks if the file is a zip file using magic number.
-    :param file_path: string, full path to the file.
-    :return: boolean.
-
-    50 4B 03 04: This is the most common signature, found at the beginning of a ZIP file.
-        It signifies the start of a file within the ZIP archive and is present in almost all ZIP files.
-        Each file within the ZIP archive starts with this signature.
-    50 4B 05 06: This is the end of central directory record signature.
-        It's found at the end of a ZIP file and is essential for identifying the structure of the ZIP archive,
-        especially in cases where the file is split or is a multi-part archive.
-    50 4B 07 08: This signature is used for spanned ZIP archives (also known as split or multi-volume ZIP archives).
-        It's found in the end of central directory locator for ZIP files that are split across multiple volumes.
-    """
-
-    with open(file_path, 'rb') as file:
-        # Read the first 4 bytes of the file
-        signature = file.read(4)
-
-    # Check if the signature matches any of the ZIP signatures
-    return signature in [b'PK\x03\x04', b'PK\x05\x06', b'PK\x07\x08']
-
-
-def extract_archive_with_zipfile(
-        archive_path: str,
-        extract_directory: str = None,
-        files_without_directories: bool = False,
-        remove_first_directory: bool = False,
-        print_kwargs: dict = None
-) -> str:
-    """
-    Function will extract the archive using standard library 'zipfile'.
-    This method preserves original date and time of the files inside the archive.
-
-    :param archive_path: string, full path to archived file.
-    :param extract_directory: string, full path to directory that the files will be extracted to.
-        If not specified, the files will be extracted to the same directory as the archived file, using the file name
-        without extension as the directory name.
-    :param files_without_directories: boolean, default 'False'.
-        'True': All the files in the archive will be extracted without subdirectories hierarchy.
-            Meaning, that if there are duplicate file names, the latest file with the same file name will overwrite
-            all the rest of the files with the same name.
-        'False': Subdirectory hierarchy will be preserved as it is currently in the archived file.
-    :param remove_first_directory: boolean, default is 'False'.
-        'True': all the files will be extracted without first directory in the hierarchy.
-            Example: package_some_name_1.1.1_build/subdir1/file.exe
-            Will be extracted as: subdir/file.exe
-    :param print_kwargs: dict, kwargs for print_api.
-
-    :return: string, full path to directory that the files were extracted to.
-    """
-
-    if print_kwargs is None:
-        print_kwargs = dict()
-
-    # If 'extract_directory' is not specified, extract to the same directory as the archived file.
-    if extract_directory is None:
-        extract_directory = (
-                filesystem.get_file_directory(archive_path) + os.sep +
-                filesystem.get_file_name_without_extension(archive_path))
-
-    print_api(f'Extracting to directory: {extract_directory}', **print_kwargs)
-
-    # initiating the archived file path as 'zipfile.ZipFile' object.
-    with zipfile.ZipFile(archive_path) as zip_object:
-        # '.infolist()' method of the object contains all the directories and files that are in the archive including
-        # information about each one, like date and time of archiving.
-        for zip_info in zip_object.infolist():
-            # '.filename' attribute of the 'infolist()' method is relative path to each directory and file.
-            # If 'filename' ends with '/' it is a directory (it doesn't matter if it is windows or *nix)
-            # If so, skip current iteration.
-            if zip_info.filename[-1] == '/':
-                continue
-
-            if files_without_directories:
-                # Put into 'filename' the string that contains only the filename without subdirectories.
-                zip_info.filename = os.path.basename(zip_info.filename)
-            elif remove_first_directory:
-                # Cut the first directory from the filename.
-                zip_info.filename = zip_info.filename.split('/', maxsplit=1)[1]
-
-            print_api(f'Extracting: {zip_info.filename}', **print_kwargs)
-
-            # Extract current file from the archive using 'zip_info' of the current file with 'filename' that we
-            # updated under specified parameters to specified directory.
-            zip_object.extract(zip_info, extract_directory)
-
-            # === Change the date and time of extracted file from current time to the time specified in 'zip_info'.
-            # Get full path to extracted file.
-            extracted_file_path: str = extract_directory + os.sep + zip_info.filename
-            # Create needed datetime object with original archived datetime from 'zip_info.date_time'.
-            date_time = time.mktime(zip_info.date_time + (0, 0, -1))
-            # Using 'os' library, changed the datetime of the file to the object created in previous step.
-            os.utime(extracted_file_path, (date_time, date_time))
-    print_api('Extraction done.', color="green", **print_kwargs)
-
-    return extract_directory
-
-
-def get_file_list_from_zip(file_path: str) -> list:
-    """
-    Function returns the list of file names and their relative directories inside the zip file.
-    :param file_path: string, full path to the zip file.
-    :return: list of strings.
-    """
-
-    with zipfile.ZipFile(file_path, 'r') as zip_object:
-        return zip_object.namelist()
-
-
-# def search_file_in_zip(
-#         file_path: str = None,
-#         file_bytes: bytes = None,
-#         file_names_to_search: list[str] = None,
-#         case_sensitive: bool = True,
-#         return_first_only: bool = False,
-#         return_empty_list_per_file_name: bool = False,
-#         recursive: bool = False,
-#         callback_functions: list = None,
-#         extract_file_to_path: str = None
-# ) -> dict[str, list[bytes]]:
-#     """
-#     Function searches for the file names inside the zip file and returns a dictionary where the keys are the
-#     names of the callback functions and the values are lists of found file bytes.
-#     :param file_path: string, full path to the zip file.
-#     :param file_bytes: bytes, the bytes of the zip file.
-#     :param file_names_to_search: list of strings, the names of the files to search.
-#     :param case_sensitive: boolean, default is 'True'. Determines if file name search should be case sensitive.
-#     :param return_first_only: boolean, default is 'False'. Return only the first found file for each file name.
-#     :param return_empty_list_per_file_name: boolean, default is 'False'.
-#         True: Return empty list for each file name that wasn't found.
-#         False: Don't return empty list for each file name that wasn't found.
-#     :param recursive: boolean, default is 'False'. If True, search for file names recursively in nested zip files.
-#     :param callback_functions: list of callables, default is None. Each function takes a file name and should return a
-#         boolean that will tell the main function if this file is 'found' or not.
-#     :param extract_file_to_path: string, full path to the directory where the found files should be extracted.
-#     :return: dictionary of lists of bytes.
-#     """
-#
-#     def get_unique_filename(directory, filename):
-#         """
-#         Generates a unique filename by appending a number if the file already exists.
-#         """
-#         name, ext = os.path.splitext(filename)
-#         counter = 1
-#         unique_filename = filename
-#         while os.path.exists(os.path.join(directory, unique_filename)):
-#             unique_filename = f"{name}_{counter}{ext}"
-#             counter += 1
-#         return unique_filename
-#
-#     def is_zip_file(file, zip_obj):
-#         try:
-#             with zip_obj.open(file) as file_data:
-#                 with zipfile.ZipFile(BytesIO(file_data.read())) as zip_file:
-#                     if zip_file.testzip() is None:  # No errors found
-#                         return True
-#         except zipfile.BadZipFile:
-#             return False
-#         return False
-#
-#     def match_file_name(target, current):
-#         if case_sensitive:
-#             return current.endswith(target)
-#         else:
-#             return current.lower().endswith(target.lower())
-#
-#     def search_in_zip(zip_obj, file_names, results, found_set):
-#         for item in zip_obj.infolist():
-#             if item.filename.endswith('/'):  # Skip directories
-#                 continue
-#             is_nested_zip = recursive and is_zip_file(item.filename, zip_obj)
-#
-#             with zip_obj.open(item) as file_data:
-#                 archived_file_bytes = file_data.read()
-#
-#                 # This is needed to know if the file should be extracted to directory or not.
-#                 should_extract = False
-#
-#                 name_matched = False
-#                 if file_names is not None:
-#                     name_matched = any(match_file_name(file_name, item.filename) for file_name in file_names)
-#                     if name_matched:
-#                         should_extract = True
-#
-#                 callback_matched = False
-#                 if callback_functions:
-#                     for callback in callback_functions:
-#                         callback_result = callback(archived_file_bytes)
-#                         if callback_result:
-#                             callback_matched = True
-#                             # Initialize key for callback function name if not present
-#                             if callback.__name__ not in results:
-#                                 results[callback.__name__] = []
-#                             file_info = {
-#                                 'bytes': archived_file_bytes,
-#                                 'name': item.filename,
-#                                 'size': item.file_size,
-#                                 'modified_time': item.date_time
-#                             }
-#                             results[callback.__name__].append(file_info)
-#                             if return_first_only:
-#                                 found_set.add(item.filename)
-#
-#                             should_extract = True
-#                             break  # Stop checking other callbacks if one has found it
-#
-#                 if should_extract and extract_file_to_path:
-#                     unique_filename = get_unique_filename(extract_file_to_path, os.path.basename(item.filename))
-#                     with open(os.path.join(extract_file_to_path, unique_filename), 'wb') as f:
-#                         f.write(archived_file_bytes)
-#
-#                 if not callback_matched:
-#                     if is_nested_zip:
-#                         # If the file is a nested ZIP and hasn't matched a callback, search recursively
-#                         nested_zip_bytes = BytesIO(archived_file_bytes)
-#                         with zipfile.ZipFile(nested_zip_bytes) as nested_zip:
-#                             search_in_zip(nested_zip, file_names, results, found_set)
-#                     elif name_matched:
-#                         # Handle name match when no callbacks are provided or no callback matched
-#                         if item.filename not in results:
-#                             results[item.filename] = []
-#                         file_info = {
-#                             'bytes': archived_file_bytes,
-#                             'name': item.filename,
-#                             'size': item.file_size,
-#                             'modified_time': item.date_time
-#                         }
-#                         results[item.filename].append(file_info)
-#                         if return_first_only:
-#                             found_set.add(item.filename)  # Mark as found
-#
-#                 if file_names is not None and len(found_set) == len(file_names):
-#                     return  # All files found, stop searching
-#
-#     if file_names_to_search is None and callback_functions is None:
-#         raise ValueError("Either file_names_to_search or callback_functions must be provided.")
-#
-#     # Initialize results dictionary.
-#     if callback_functions:
-#         results = {callback.__name__: [] for callback in callback_functions}
-#     else:
-#         results = {}
-#
-#     found_set = set()
-#     if file_bytes is not None:
-#         with zipfile.ZipFile(BytesIO(file_bytes), 'r') as zip_ref:
-#             search_in_zip(zip_ref, file_names_to_search, results, found_set)
-#     elif file_path is not None:
-#         with zipfile.ZipFile(file_path, 'r') as zip_ref:
-#             search_in_zip(zip_ref, file_names_to_search, results, found_set)
-#     else:
-#         raise ValueError("Either file_path or file_bytes must be provided.")
-#
-#     if not return_empty_list_per_file_name:
-#         # Filter out keys with empty lists
-#         results = {key: value for key, value in results.items() if value}
-#
-#     return results

atomicshop/file_types.py

@@ -1,24 +0,0 @@
-from typing import Union
-
-import magic
-
-
-def get_mime_type(file_object: Union[str, bytes]):
-    """
-    Determine the MIME type of the given input.
-    The input can be a file path (string) or a bytes object.
-
-    :param file_object: File path as a string or bytes object.
-    :return: MIME type as a string.
-    """
-    mime = magic.Magic(mime=True)
-
-    # Check if input is a file path (str) or bytes
-    if isinstance(file_object, str):
-        # Assuming input_data is a file path
-        return mime.from_file(file_object)
-    elif isinstance(file_object, bytes):
-        # Assuming input_data is bytes
-        return mime.from_buffer(file_object)
-    else:
-        raise TypeError("Input must be a file path (str) or bytes object.")

atomicshop/mitm/config_editor.py

@@ -1,37 +0,0 @@
-import configparser
-
-
-class CategoryNotFoundInConfigError(Exception):
-    pass
-
-
-def edit_property(category: str, category_property: str, value: str, config_file_path: str) -> None:
-    """
-    Edit a property in the config file.
-
-    :param category: str, Category in the config file.
-    :param category_property: str, Property in the category.
-    :param value: str, Value to set to the property.
-    :param config_file_path: str, Path to the config file.
-
-    :return: None.
-
-    -----------
-
-    Config Example:
-    [category]
-    category_property = value
-    """
-    config = configparser.ConfigParser()
-    config.read(config_file_path)
-
-    if category not in config:
-        raise CategoryNotFoundInConfigError(f"Category '{category}' not found in the config file.")
-
-    # Change the value of the property if it is different from the current value.
-    current_value = config[category][category_property]
-    if current_value != value:
-        config[category][category_property] = value
-
-        with open(config_file_path, "w") as configfile:
-            config.write(configfile)

atomicshop/mitm/engines/create_module_template_example.py

@@ -1,13 +0,0 @@
-engine_name = '_example'
-domains = ['example.com']
-# This script should be in 'engines' folder.
-
-
-# === Create template from above settings. ===
-# Get current file directory, should be the 'engines' directory.
-# noinspection PyPep8
-from atomicshop import filesystem
-engines_path = filesystem.get_working_directory()
-# Create the template.
-from atomicshop.mitm.engines.create_module_template import CreateModuleTemplate
-CreateModuleTemplate(engine_name, domains, engines_path)

atomicshop/mitm/initialize_mitm_server.py

@@ -1,268 +0,0 @@
-import os
-import sys
-import threading
-import time
-
-# Importing atomicshop package to get the version of the package.
-import atomicshop
-
-from .import_config import ImportConfig
-from .initialize_engines import ModuleCategory
-from .connection_thread_worker import thread_worker_main
-from .. import filesystem, queues
-from ..python_functions import get_current_python_version_string, check_python_version_compliance
-from ..wrappers.socketw.socket_wrapper import SocketWrapper
-from ..wrappers.socketw import dns_server
-from ..wrappers.psutilw import networks
-from ..basics import dicts_nested
-from ..wrappers.loggingw import loggingw
-from ..print_api import print_api
-
-
-STATISTICS_HEADER: str = \
-    'request_time_sent,host,path,command,status_code,request_size_bytes,response_size_bytes,file_path,process_cmd,error'
-
-
-def initialize_mitm_server(config_static):
-    # Main function should return integer with error code, 0 is successful.
-    # Since listening server is infinite, this will not be reached.
-    # After modules import - we check for python version.
-    check_python_version_compliance(minimum_version='3.11')
-
-    # Preparing everything for the logging module.
-    # Log folder path is in the "config.ini" file, so we need to read it before setting loggers.
-    config_importer = ImportConfig(
-        file_name=config_static.CONFIG_INI_SERVER_FILE_NAME, directory_path=config_static.WORKING_DIRECTORY)
-    config_importer.open()
-    config = config_importer.config
-
-    # Create folders.
-    filesystem.create_directory(config['log']['logs_path'])
-    filesystem.create_directory(config['recorder']['recordings_path'])
-    if config['certificates']['sni_get_server_certificate_from_server_socket']:
-        filesystem.create_directory(
-            config['certificates']['sni_server_certificate_from_server_socket_download_directory'])
-
-    # Create a logger that will log messages to file, Initiate System logger.
-    logger_name = "system"
-    system_logger = loggingw.create_logger(
-        logger_name=logger_name,
-        file_path=f"{config['log']['logs_path']}{os.sep}{logger_name}.txt",
-        add_stream=True,
-        add_timedfile=True,
-        formatter_streamhandler='DEFAULT',
-        formatter_filehandler='DEFAULT'
-    )
-
-    # Writing first log.
-    system_logger.info("======================================")
-
-    if config_importer.admin_rights is not None:
-        if not config_importer.admin_rights:
-            system_logger.error("User continued with errors on Command Line harvesting for system processes.")
-
-    system_logger.info("Server Started.")
-    system_logger.info(f"Python Version: {get_current_python_version_string()}")
-    system_logger.info(f"Script Version: {config_static.SCRIPT_VERSION}")
-    system_logger.info(f"Atomic Workshop Version: {atomicshop.__version__}")
-    system_logger.info(f"Loaded config.ini: {config_importer.config_parser.file_path}")
-    system_logger.info(f"Log folder: {config['log']['logs_path']}")
-    system_logger.info(f"Recordings folder for Requests/Responses: {config['recorder']['recordings_path']}")
-    system_logger.info(f"Loaded system logger: {system_logger}")
-
-    system_logger.info(f"TCP Server Target IP: {config['dns']['target_tcp_server_ipv4']}")
-
-    # Some 'config.ini' settings logging ===========================================================================
-    if config['certificates']['default_server_certificate_usage']:
-        system_logger.info(
-            f"Default server certificate usage enabled, if no SNI available: "
-            f"{config_static.CONFIG_EXTENDED['certificates']['default_server_certificate_directory']}"
-            f"{os.sep}{config_static.CONFIG_EXTENDED['certificates']['default_server_certificate_name']}.pem")
-
-    if config['certificates']['sni_server_certificates_cache_directory']:
-        system_logger.info(
-            f"SNI function certificates creation enabled. Certificates cache: "
-            f"{config['certificates']['sni_server_certificates_cache_directory']}")
-    else:
-        system_logger.info(f"SNI function certificates creation disabled.")
-
-    if config['certificates']['custom_server_certificate_usage']:
-        system_logger.info(f"Custom server certificate usage is enabled.")
-        system_logger.info(f"Custom Certificate Path: {config['certificates']['custom_server_certificate_path']}")
-
-        # If 'custom_private_key_path' field was populated.
-        if config['certificates']['custom_private_key_path']:
-            system_logger.info(
-                f"Custom Certificate Private Key Path: {config['certificates']['custom_private_key_path']}")
-        else:
-            system_logger.info(f"Custom Certificate Private Key Path wasn't provided in [advanced] section. "
-                               f"Assuming the private key is inside the certificate file.")
-
-    # === Importing engine modules =================================================================================
-    system_logger.info("Importing engine modules.")
-
-    # Get full paths of all the 'engine_config.ini' files.
-    engine_config_path_list = filesystem.get_file_paths_from_directory(
-        directory_path=config_static.ENGINES_DIRECTORY_PATH,
-        file_name_check_pattern=config_static.ENGINE_CONFIG_FILE_NAME)
-
-    # Iterate through all the 'engine_config.ini' file paths.
-    domains_engine_list_full: list = list()
-    engines_list: list = list()
-    for engine_config_path in engine_config_path_list:
-        # Initialize engine.
-        current_module = ModuleCategory(config_static.WORKING_DIRECTORY)
-        current_module.fill_engine_fields_from_config(engine_config_path)
-        current_module.initialize_engine(logs_path=config['log']['logs_path'],
-                                         logger=system_logger)
-
-        # Extending the full engine domain list with this list.
-        domains_engine_list_full.extend(current_module.domain_list)
-        # Append the object to the engines list
-        engines_list.append(current_module)
-    # === EOF Importing engine modules =============================================================================
-    # ==== Initialize Reference Module =============================================================================
-    reference_module = ModuleCategory(config_static.WORKING_DIRECTORY)
-    reference_module.fill_engine_fields_from_general_reference(config_static.ENGINES_DIRECTORY_PATH)
-    reference_module.initialize_engine(logs_path=config['log']['logs_path'],
-                                       logger=system_logger, stdout=False, reference_general=True)
-    # === EOF Initialize Reference Module ==========================================================================
-    # === Engine logging ===========================================================================================
-    # Printing the parsers using "start=1" for index to start counting from "1" and not "0"
-    print_api(f"[*] Found Engines:", logger=system_logger)
-    for index, engine in enumerate(engines_list, start=1):
-        message = f"[*] {index}: {engine.engine_name} | {engine.domain_list}"
-        print_api(message, logger=system_logger)
-
-        message = (f"[*] Modules: {engine.parser_class_object.__name__}, "
-                   f"{engine.responder_class_object.__name__}, "
-                   f"{engine.recorder_class_object.__name__}")
-        print_api(message, logger=system_logger)
-
-    if config['dns']['enable_dns_server']:
-        print_api("DNS Server is enabled.", logger=system_logger)
-
-        # If engines were found and dns is set to route by the engine domains.
-        if engines_list and config['dns']['route_to_tcp_server_only_engine_domains']:
-            print_api("Engine domains will be routed by the DNS server to Built-in TCP Server.", logger=system_logger)
-        # If engines were found, but the dns isn't set to route to engines.
-        elif engines_list and not config['dns']['route_to_tcp_server_only_engine_domains']:
-            message = f"[*] Engine domains found, but the DNS routing is set not to use them for routing."
-            print_api(message, color="yellow", logger=system_logger)
-        elif not engines_list and config['dns']['route_to_tcp_server_only_engine_domains']:
-            raise ValueError("No engines were found, but the DNS routing is set to use them for routing.\n"
-                             "Please check your DNS configuration in the 'config.ini' file.")
-
-        if config['dns']['route_to_tcp_server_all_domains']:
-            print_api("All domains will be routed by the DNS server to Built-in TCP Server.", logger=system_logger)
-
-        if config['dns']['regular_resolving']:
-            print_api(
-                "Regular DNS resolving is enabled. Built-in TCP server will not be routed to",
-                logger=system_logger, color="yellow")
-    else:
-        print_api("DNS Server is disabled.", logger=system_logger, color="yellow")
-
-    if config['tcp']['enable_tcp_server']:
-        print_api("TCP Server is enabled.", logger=system_logger)
-
-        if engines_list and not config['tcp']['engines_usage']:
-            message = \
-                f"Engines found, but the TCP server is set not to use them for processing. General responses only."
-            print_api(message, color="yellow", logger=system_logger)
-        elif engines_list and config['tcp']['engines_usage']:
-            message = f"Engines found, and the TCP server is set to use them for processing."
-            print_api(message, logger=system_logger)
-        elif not engines_list and config['tcp']['engines_usage']:
-            raise ValueError("No engines were found, but the TCP server is set to use them for processing.\n"
-                             "Please check your TCP configuration in the 'config.ini' file.")
-    else:
-        print_api("TCP Server is disabled.", logger=system_logger, color="yellow")
-
-    # === EOF Engine Logging =======================================================================================
-
-    # Assigning all the engines domains to all time domains, that will be responsible for adding new domains.
-    config_static.CONFIG_EXTENDED['certificates']['domains_all_times'] = list(domains_engine_list_full)
-
-    # Creating Statistics logger.
-    statistics_logger = loggingw.create_logger(
-        logger_name="statistics",
-        directory_path=config['log']['logs_path'],
-        add_timedfile=True,
-        formatter_filehandler='MESSAGE',
-        file_type='csv',
-        header=STATISTICS_HEADER
-    )
-
-    network_logger_name = "network"
-    network_logger = loggingw.create_logger(
-        logger_name=network_logger_name,
-        directory_path=config['log']['logs_path'],
-        add_stream=True,
-        add_timedfile=True,
-        formatter_streamhandler='DEFAULT',
-        formatter_filehandler='DEFAULT'
-    )
-    system_logger.info(f"Loaded network logger: {network_logger}")
-
-    # Initiate Listener logger, which is a child of network logger, so he uses the same settings and handlers
-    listener_logger = loggingw.get_logger_with_level(f'{network_logger_name}.listener')
-    system_logger.info(f"Loaded listener logger: {listener_logger}")
-
-    # Create request domain queue.
-    domain_queue = queues.NonBlockQueue()
-
-    # === Initialize DNS module ====================================================================================
-    if config['dns']['enable_dns_server']:
-        # Check if the DNS server port is in use.
-        port_in_use = networks.get_processes_using_port_list([config['dns']['listening_port']])
-        if port_in_use:
-            for port, process_info in port_in_use.items():
-                message = f"Port [{port}] is already in use by process: {process_info}"
-                print_api(message, error_type=True, logger_method='critical', logger=system_logger)
-
-            # Wait for the message to be printed and saved to file.
-            time.sleep(1)
-            sys.exit(1)
-
-        # before executing TCP sockets and after executing 'network' logger.
-        dns_server_instance = dns_server.DnsServer(config)
-        # Passing the engine domain list to DNS server to work with.
-        # 'list' function re-initializes the current list, or else it will be the same instance object.
-        dns_server_instance.domain_list = list(domains_engine_list_full)
-
-        dns_server_instance.request_domain_queue = domain_queue
-        # Initiate the thread.
-        dns_thread = threading.Thread(target=dns_server_instance.start)
-        dns_thread.daemon = True
-        dns_thread.start()
-
-    # === EOF Initialize DNS module ================================================================================
-    # === Initialize TCP Server ====================================================================================
-    if config['tcp']['enable_tcp_server']:
-        port_in_use = networks.get_processes_using_port_list(config['tcp']['listening_port_list'])
-        if port_in_use:
-            for port, process_info in port_in_use.items():
-                print_api(f"Port [{port}] is already in use by process: {process_info}", logger=system_logger,
-                          error_type=True, logger_method='critical')
-            # Wait for the message to be printed and saved to file.
-            time.sleep(1)
-            sys.exit(1)
-
-        socket_wrapper = SocketWrapper(
-            config=dicts_nested.merge(config, config_static.CONFIG_EXTENDED), logger=listener_logger,
-            statistics_logger=statistics_logger)
-
-        socket_wrapper.create_tcp_listening_socket_list()
-
-        socket_wrapper.requested_domain_from_dns_server = domain_queue
-
-        # General exception handler will catch all the exceptions that occurred in the threads and write it to the log.
-        try:
-            socket_wrapper.loop_for_incoming_sockets(function_reference=thread_worker_main, reference_args=(
-                network_logger, statistics_logger, engines_list, reference_module, config,))
-        except Exception:
-            message = f"Unhandled Exception occurred in 'loop_for_incoming_sockets' function"
-            print_api(message, error_type=True, color="red", logger=network_logger, traceback_string=True, oneline=True)
-
-    # === EOF Initialize TCP Server ================================================================================