atomicshop 3.2.13__py3-none-any.whl → 3.3.1__py3-none-any.whl

atomicshop/mitm/mitm_main.py

@@ -3,6 +3,7 @@ import multiprocessing
 import time
 import datetime
 import os
+import sys
 import logging
 
 import atomicshop   # Importing atomicshop package to get the version of the package.
@@ -10,9 +11,10 @@ import atomicshop   # Importing atomicshop package to get the version of the pac
 from .. import filesystem, on_exit, print_api, networks, dns
 from ..permissions import permissions
 from ..python_functions import get_current_python_version_string, check_python_version_compliance
-from ..wrappers.socketw import socket_wrapper, dns_server, base
+from ..wrappers.socketw import socket_wrapper, dns_server, base, statistics_csv
 from ..wrappers.loggingw import loggingw
 from ..wrappers.ctyping import win_console
+from ..basics import multiprocesses
 
 from .connection_thread_worker import thread_worker_main
 from . import config_static, recs_files
@@ -64,13 +66,16 @@ IS_SET_DNS_GATEWAY: bool = False
 RECS_PROCESS_INSTANCE: multiprocessing.Process = None
 
 
+STATISTICS_LOGGER_NAME: str = 'statistics'
 EXCEPTIONS_CSV_LOGGER_NAME: str = 'exceptions'
 EXCEPTIONS_CSV_LOGGER_HEADER: str = 'time,exception'
 # noinspection PyTypeChecker
 MITM_ERROR_LOGGER: loggingw.ExceptionCsvLogger = None
 
-# Create logger's queue.
+# Create logger queues.
 NETWORK_LOGGER_QUEUE: multiprocessing.Queue = multiprocessing.Queue()
+STATISTICS_CSV_LOGGER_QUEUE: multiprocessing.Queue = multiprocessing.Queue()
+EXCEPTIONS_CSV_LOGGER_QUEUE: multiprocessing.Queue = multiprocessing.Queue()
 
 # Create finalization queue for the rec archiving process.
 FINALIZE_RECS_ARCHIVE_QUEUE: multiprocessing.Queue = multiprocessing.Queue()
@@ -304,6 +309,7 @@ def get_ipv4s_for_tcp_server():
             if port in ports_to_create_ips_for:
                 engine.port_target_dict[port]['ip'] = engine_ips.pop(0)
 
+
 def mitm_server(config_file_path: str, script_version: str):
     on_exit.register_exit_handler(exit_cleanup, at_exit=False, kill_signal=False)
 
@@ -323,7 +329,11 @@ def mitm_server(config_file_path: str, script_version: str):
 
     global MITM_ERROR_LOGGER
     MITM_ERROR_LOGGER = loggingw.ExceptionCsvLogger(
-        logger_name=EXCEPTIONS_CSV_LOGGER_NAME, directory_path=config_static.LogRec.logs_path)
+        logger_name=EXCEPTIONS_CSV_LOGGER_NAME,
+        directory_path=config_static.LogRec.logs_path,
+        log_queue=EXCEPTIONS_CSV_LOGGER_QUEUE,
+        add_queue_handler_start_listener_multiprocessing=True,
+    )
 
     # Create folders.
     filesystem.create_directory(config_static.LogRec.logs_path)
@@ -334,10 +344,11 @@ def mitm_server(config_file_path: str, script_version: str):
 
     network_logger_name = config_static.MainConfig.LOGGER_NAME
 
-    # If we exit the function, we need to stop the listener: network_logger_queue_listener.stop()
-    network_logger_queue_listener = loggingw.create_logger(
-        get_queue_listener=True,
+    # Start the network logger and its queue listener.
+    _ = loggingw.create_logger(
+        logger_name=network_logger_name,
         log_queue=NETWORK_LOGGER_QUEUE,
+        start_queue_listener_multiprocess_add_queue_handler=True,
         file_path=f'{config_static.LogRec.logs_path}{os.sep}{network_logger_name}.txt',
         add_stream=True,
         add_timedfile=True,
@@ -345,13 +356,16 @@ def mitm_server(config_file_path: str, script_version: str):
         formatter_filehandler='DEFAULT',
         backupCount=config_static.LogRec.store_logs_for_x_days)
 
-    network_logger_with_queue_handler: logging.Logger = loggingw.create_logger(
-        logger_name=network_logger_name,
+    """
+    # Create this in other multiprocesses (You need to pass only the logger_name and log_queue to the other process):
+    logger = loggingw.create_logger(
+        logger_name=logger_name,
         add_queue_handler=True,
-        log_queue=NETWORK_LOGGER_QUEUE)
+        log_queue=NETWORK_LOGGER_QUEUE
+    )
+    """
 
     # Initiate Listener logger, which is a child of network logger, so he uses the same settings and handlers
-    listener_logger: logging.Logger = loggingw.get_logger_with_level(f'{network_logger_name}.listener')
     system_logger: logging.Logger = loggingw.get_logger_with_level(f'{network_logger_name}.system')
 
     if config_static.LogRec.enable_request_response_recordings_in_logs:
@@ -372,7 +386,7 @@ def mitm_server(config_file_path: str, script_version: str):
                 error_type=True, color="red", logger=system_logger, logger_method='critical')
             # Wait for the message to be printed and saved to file.
             time.sleep(1)
-            network_logger_queue_listener.stop()
+            # network_logger_queue_listener.stop()
             return 1
 
     # Logging Startup information.
@@ -380,66 +394,100 @@ def mitm_server(config_file_path: str, script_version: str):
 
     print_api.print_api("Press [Ctrl]+[C] to stop.", color='blue')
 
+    multiprocess_list: list[multiprocessing.Process] = list()
+    # noinspection PyTypeHints
+    is_ready_multiprocessing_event_list: list[multiprocessing.Event] = list()
+
     # === Initialize DNS module ====================================================================================
     if config_static.DNSServer.enable:
+        is_dns_process_ready: multiprocessing.Event = multiprocessing.Event()
+        is_ready_multiprocessing_event_list.append(is_dns_process_ready)
+
+        dns_server_kwargs: dict = dict(
+            listening_address=config_static.DNSServer.listening_address,
+            log_directory_path=config_static.LogRec.logs_path,
+            backupCount_log_files_x_days=config_static.LogRec.store_logs_for_x_days,
+            forwarding_dns_service_ipv4=config_static.DNSServer.forwarding_dns_service_ipv4,
+            forwarding_dns_service_port=config_static.DNSServer.forwarding_dns_service_port,
+            resolve_by_engine=(
+                config_static.DNSServer.resolve_by_engine, config_static.ENGINES_LIST),
+            resolve_regular_pass_thru=config_static.DNSServer.resolve_regular_pass_thru,
+            resolve_all_domains_to_ipv4=(
+                config_static.DNSServer.resolve_all_domains_to_ipv4_enable, config_static.DNSServer.target_ipv4),
+            offline_mode=config_static.MainConfig.offline,
+            cache_timeout_minutes=config_static.DNSServer.cache_timeout_minutes,
+            logging_queue=NETWORK_LOGGER_QUEUE,
+            logger_name=network_logger_name,
+            is_ready_multiprocessing=is_dns_process_ready
+        )
+
         dns_process = multiprocessing.Process(
             target=dns_server.start_dns_server_multiprocessing_worker,
-            kwargs={
-                'listening_address': config_static.DNSServer.listening_address,
-                'log_directory_path': config_static.LogRec.logs_path,
-                'backupCount_log_files_x_days': config_static.LogRec.store_logs_for_x_days,
-                'forwarding_dns_service_ipv4': config_static.DNSServer.forwarding_dns_service_ipv4,
-                'forwarding_dns_service_port': config_static.DNSServer.forwarding_dns_service_port,
-                'resolve_by_engine': (
-                    config_static.DNSServer.resolve_by_engine, config_static.ENGINES_LIST),
-                'resolve_regular_pass_thru': config_static.DNSServer.resolve_regular_pass_thru,
-                'resolve_all_domains_to_ipv4': (
-                    config_static.DNSServer.resolve_all_domains_to_ipv4_enable, config_static.DNSServer.target_ipv4),
-                'offline_mode': config_static.MainConfig.offline,
-                'cache_timeout_minutes': config_static.DNSServer.cache_timeout_minutes,
-                'logging_queue': NETWORK_LOGGER_QUEUE,
-                'logger_name': network_logger_name
-            },
-            name="dns_server")
-        dns_process.daemon = True
+            kwargs=dns_server_kwargs,
+            name="dns_server",
+            daemon=True
+        )
         dns_process.start()
 
-        # Wait for the DNS server to start and do the port test.
-        is_alive: bool = False
-        max_wait_time: int = 5
-        while not is_alive:
-            is_alive = dns_process.is_alive()
-            time.sleep(1)
-            max_wait_time -= 1
-            if max_wait_time == 0:
-                message = "DNS Server process didn't start."
-                print_api.print_api(message, error_type=True, color="red", logger=system_logger)
-                # Wait for the message to be printed and saved to file.
-                time.sleep(1)
-                network_logger_queue_listener.stop()
-                return 1
-
-        # Now we can check if the process wasn't terminated after the check.
-        max_wait_time: int = 5
-        while max_wait_time > 0:
-            is_alive = dns_process.is_alive()
-
-            if not is_alive:
-                message = "DNS Server process terminated."
-                print_api.print_api(message, error_type=True, color="red", logger=system_logger)
-                # Wait for the message to be printed and saved to file.
-                time.sleep(1)
-                network_logger_queue_listener.stop()
-                return 1
+        multiprocess_list.append(dns_process)
 
-            time.sleep(1)
-            max_wait_time -= 1
 
     # === EOF Initialize DNS module ================================================================================
     # === Initialize TCP Server ====================================================================================
     if config_static.TCPServer.enable:
-        try:
-            socket_wrapper_instance = socket_wrapper.SocketWrapper(
+        # Get the default network adapter configuration and set the one from config.
+        # We set the virtual IPs in the network adapter here, so the server multiprocessing processes can listen on them.
+        setting_result: int = _add_virtual_ips_set_default_dns_gateway(system_logger)
+        if setting_result != 0:
+            print_api.print_api("Failed to set the default DNS gateway.", error_type=True, color="red",
+                                logger=system_logger)
+            # Wait for the message to be printed and saved to file.
+            time.sleep(1)
+            return setting_result
+
+        # Start statistics CSV Queue listener and the logger.
+        _ = statistics_csv.StatisticsCSVWriter(
+            directory_path=config_static.LogRec.logs_path,
+            log_queue=STATISTICS_CSV_LOGGER_QUEUE,
+            add_queue_handler_start_listener_multiprocessing=True)
+
+        no_engine_usage_enable: bool = config_static.TCPServer.no_engines_usage_to_listen_addresses_enable
+        no_engines_listening_address_list: list[str] = config_static.TCPServer.no_engines_listening_address_list
+
+        # If engines were passed, we will use the listening addresses from the engines.
+        listening_interfaces: list[dict] = list()
+        if not no_engine_usage_enable:
+            for engine in config_static.ENGINES_LIST:
+                # Combine the domain and port dicts.
+                connection_dict: dict = {**engine.domain_target_dict, **engine.port_target_dict}
+
+                # Start all the regular listening interfaces.
+                for domain_or_port, ip_port_dict in connection_dict.items():
+                    current_interface_dict: dict = {
+                        'engine': engine,
+                        'process_name': f'tcp_server-{engine.engine_name}-{domain_or_port}',
+                        'ip': ip_port_dict['ip'],
+                        'port': int(ip_port_dict['port'])
+                    }
+                    listening_interfaces.append(current_interface_dict)
+        else:
+            # If no engines were passed, we will use the listening addresses from the configuration.
+            for address in no_engines_listening_address_list:
+                listening_ip_address, port_str = address.split(':')
+                current_interface_dict: dict = {
+                    'engine': None,  # No engine for this address.
+                    'process_name': f'tcp_server-{listening_ip_address}_{port_str}',
+                    'ip': listening_ip_address,
+                    'port': int(port_str)
+                }
+                listening_interfaces.append(current_interface_dict)
+
+        # Starting the TCP server multiprocessing processes.
+        for interface_dict in listening_interfaces:
+            socket_wrapper_kwargs: dict = dict(
+                ip_address=interface_dict['ip'],
+                port=interface_dict['port'],
+                engine=interface_dict['engine'],
                 ca_certificate_name=config_static.MainConfig.ca_certificate_name,
                 ca_certificate_filepath=config_static.MainConfig.ca_certificate_filepath,
                 ca_certificate_crt_filepath=config_static.MainConfig.ca_certificate_crt_filepath,
@@ -469,109 +517,179 @@ def mitm_server(config_file_path: str, script_version: str):
                 ssh_user=config_static.ProcessName.ssh_user,
                 ssh_pass=config_static.ProcessName.ssh_pass,
                 ssh_script_to_execute=config_static.ProcessName.ssh_script_to_execute,
-                logger=listener_logger,
-                exceptions_logger=MITM_ERROR_LOGGER,
-                statistics_logs_directory=config_static.LogRec.logs_path,
+                logs_directory=config_static.LogRec.logs_path,
+                logger_name=network_logger_name,
+                logger_queue=NETWORK_LOGGER_QUEUE,
+                statistics_logger_name=STATISTICS_LOGGER_NAME,
+                statistics_logger_queue=STATISTICS_CSV_LOGGER_QUEUE,
+                exceptions_logger_name=EXCEPTIONS_CSV_LOGGER_NAME,
+                exceptions_logger_queue=EXCEPTIONS_CSV_LOGGER_QUEUE,
                 forwarding_dns_service_ipv4_list___only_for_localhost=[config_static.DNSServer.forwarding_dns_service_ipv4],
-                skip_extension_id_list=config_static.SkipExtensions.SKIP_EXTENSION_ID_LIST,
-                no_engine_usage_enable=config_static.TCPServer.no_engines_usage_to_listen_addresses_enable,
-                no_engines_listening_address_list=config_static.TCPServer.no_engines_listening_address_list,
-                engines_list=config_static.ENGINES_LIST
+                skip_extension_id_list=config_static.SkipExtensions.SKIP_EXTENSION_ID_LIST
             )
-        except socket_wrapper.SocketWrapperPortInUseError as e:
-            print_api.print_api(e, error_type=True, color="red", logger=system_logger)
-            # Wait for the message to be printed and saved to file.
-            time.sleep(1)
-            network_logger_queue_listener.stop()
-            return 1
-        except socket_wrapper.SocketWrapperConfigurationValuesError as e:
-            print_api.print_api(e, error_type=True, color="red", logger=system_logger, logger_method='critical')
-            # Wait for the message to be printed and saved to file.
-            time.sleep(1)
-            network_logger_queue_listener.stop()
-            return 1
 
-        # ----------------------- Get the default network adapter configuration. --------------------------
-        # This setting is needed only for the dns gateways configurations from the main config on localhost.
-        set_local_dns_gateway: bool = False
-        # Set the default gateway if specified.
-        if config_static.DNSServer.set_default_dns_gateway:
-            dns_gateway_server_list = config_static.DNSServer.set_default_dns_gateway
-            set_local_dns_gateway = True
-        elif config_static.DNSServer.set_default_dns_gateway_to_localhost:
-            dns_gateway_server_list = [base.LOCALHOST_IPV4]
-            set_local_dns_gateway = True
-        elif config_static.DNSServer.set_default_dns_gateway_to_default_interface_ipv4:
-            dns_gateway_server_list = [base.DEFAULT_IPV4]
-            set_local_dns_gateway = True
-        else:
-            dns_gateway_server_list = NETWORK_INTERFACE_SETTINGS.dns_gateways
-
-        if config_static.ENGINES_LIST[0].is_localhost:
-            if set_local_dns_gateway:
-                global IS_SET_DNS_GATEWAY
-                IS_SET_DNS_GATEWAY = True
-
-                # Get current network interface state.
-                global NETWORK_INTERFACE_IS_DYNAMIC, NETWORK_INTERFACE_IPV4_ADDRESS_LIST
-                NETWORK_INTERFACE_IS_DYNAMIC, NETWORK_INTERFACE_IPV4_ADDRESS_LIST = dns.get_default_dns_gateway()
-
-                # Set the DNS gateway to the specified one only if the DNS gateway is dynamic, or it is static but different
-                # from the one specified in the configuration file.
-                if (NETWORK_INTERFACE_IS_DYNAMIC or (not NETWORK_INTERFACE_IS_DYNAMIC and
-                                                     NETWORK_INTERFACE_IPV4_ADDRESS_LIST != dns_gateway_server_list)):
-                    try:
-                        dns.set_connection_dns_gateway_static(
-                            dns_servers=dns_gateway_server_list,
-                            use_default_connection=True
-                        )
-                    except PermissionError as e:
-                        print_api.print_api(e, error_type=True, color="red", logger=system_logger)
-                        # Wait for the message to be printed and saved to file.
-                        time.sleep(1)
-                        network_logger_queue_listener.stop()
-                        return 1
-        else:
-            # Change the adapter settings and add the virtual IPs.
-            try:
-                networks.add_virtual_ips_to_default_adapter_by_current_setting(
-                    virtual_ipv4s_to_add=IPS_TO_ASSIGN, virtual_ipv4_masks_to_add=MASKS_TO_ASSIGN, dns_gateways=dns_gateway_server_list)
-            except PermissionError as e:
-                print_api.print_api(e, error_type=True, color="red", logger=system_logger)
+            is_tcp_process_ready: multiprocessing.Event = multiprocessing.Event()
+            is_ready_multiprocessing_event_list.append(is_tcp_process_ready)
+
+            tcp_process: multiprocessing.Process = multiprocessing.Process(
+                target=_create_tcp_server_process,
+                name=interface_dict['process_name'],
+                args=(
+                    socket_wrapper_kwargs,
+                    config_file_path,
+                    network_logger_name,
+                    NETWORK_LOGGER_QUEUE,
+                    is_tcp_process_ready
+                ),
+                daemon=True
+            )
+            tcp_process.start()
+            multiprocess_list.append(tcp_process)
+
+        # Compress recordings each day in a separate process.
+        recs_archiver_thread = threading.Thread(target=_loop_at_midnight_recs_archive, args=(network_logger_name,), daemon=True)
+        recs_archiver_thread.start()
+
+        # Check that all the multiprocesses are ready.
+        for event in is_ready_multiprocessing_event_list:
+            if not event.wait(timeout=30):
+                print_api.print_api("One of the processes didn't start in time.", error_type=True, color="red",
+                                    logger=system_logger)
                 # Wait for the message to be printed and saved to file.
                 time.sleep(1)
-                network_logger_queue_listener.stop()
                 return 1
 
-        statistics_writer = socket_wrapper_instance.statistics_writer
+    if config_static.DNSServer.enable or config_static.TCPServer.enable:
+        print_api.print_api("The Server is Ready for Operation!", color="green", logger=system_logger)
+        # Get al the queue listener processes (basically this is not necessary, since they're 'daemons', but this is a good practice).
+        multiprocess_list.extend(loggingw.get_listener_processes())
 
-        socket_wrapper_instance.start_listening_sockets(
-            reference_function_name=thread_worker_main,
-            reference_function_args=(
-                network_logger_with_queue_handler, statistics_writer, config_static.ENGINES_LIST,
-                config_static.REFERENCE_MODULE)
-        )
+        # This is needed for Keyboard Exception.
+        while True:
+            # If it is the first cycle and some process had an exception, we will exist before printing that the
+            # server is ready for operation.
+            result, process_name = multiprocesses.is_process_crashed(multiprocess_list)
+            # If result is None, all processes are still alive.
+            if result is not None:
+                # If result is 0 or 1, we can exit the loop.
+                print(f"Process [{process_name}] finished with exit code {result}.")
+                break
 
-        # socket_thread = threading.Thread(
-        #     target=socket_wrapper_instance.loop_for_incoming_sockets,
-        #     kwargs={
-        #         'reference_function_name': thread_worker_main,
-        #         'reference_function_args': (network_logger_with_queue_handler, statistics_writer, engines_list, reference_module,)
-        #     },
-        #     name="accepting_loop"
-        # )
-        #
-        # socket_thread.daemon = True
-        # socket_thread.start()
+            time.sleep(1)
 
-        # Compress recordings each day in a separate process.
-        recs_archiver_thread = threading.Thread(target=_loop_at_midnight_recs_archive, args=(network_logger_name,), daemon=True)
-        recs_archiver_thread.start()
 
-    if config_static.DNSServer.enable or config_static.TCPServer.enable:
-        # This is needed for Keyboard Exception.
+def _create_tcp_server_process(
+        socket_wrapper_kwargs: dict,
+        config_file_path: str,
+        network_logger_name: str,
+        network_logger_queue: multiprocessing.Queue,
+        is_tcp_process_ready: multiprocessing.Event
+):
+    # Load config_static per process, since it is not shared between processes.
+    config_static.load_config(config_file_path, print_kwargs=dict(stdout=False))
+
+    # First create a network logger with a queue handler.
+    _ = loggingw.create_logger(
+        logger_name=network_logger_name,
+        add_queue_handler=True,
+        log_queue=network_logger_queue,
+    )
+
+    # Now get the system logger and listener loggers.
+    system_logger: logging.Logger = loggingw.get_logger_with_level(f'{network_logger_name}.system')
+    # If the listener logger is available in current process, the SocketWrapper will use it.
+    _ = loggingw.get_logger_with_level(f'{network_logger_name}.listener')
+
+    try:
+        # noinspection PyTypeChecker
+        socket_wrapper_instance = socket_wrapper.SocketWrapper(**socket_wrapper_kwargs)
+    except socket_wrapper.SocketWrapperPortInUseError as e:
+        print_api.print_api(e, error_type=True, color="red", logger=system_logger)
+        # Wait for the message to be printed and saved to file.
+        time.sleep(1)
+        # network_logger_queue_listener.stop()
+        sys.exit(1)
+    except socket_wrapper.SocketWrapperConfigurationValuesError as e:
+        print_api.print_api(e, error_type=True, color="red", logger=system_logger, logger_method='critical')
+        # Wait for the message to be printed and saved to file.
+        time.sleep(1)
+        # network_logger_queue_listener.stop()
+        sys.exit(1)
+
+    socket_wrapper_instance.start_listening_socket(
+        callable_function=thread_worker_main, callable_args=(config_static,))
+
+    # Notify that the TCP server is ready.
+    is_tcp_process_ready.set()
+
+    try:
         while True:
+            time.sleep(1)  # Keep the process alive, since the listening socket is in an infinite loop.
+    except KeyboardInterrupt:
+        sys.exit(0)
+
+
+def _add_virtual_ips_set_default_dns_gateway(system_logger: logging.Logger) -> int:
+    """
+    The function reads the current DNS gateway setting and sets the new one.
+
+    :param system_logger: The logger to use for logging messages.
+    :return: 0 if successful, 1 if there was an error.
+    """
+
+    # This setting is needed only for the dns gateways configurations from the main config on localhost.
+    set_local_dns_gateway: bool = False
+    # Set the default gateway if specified.
+    if config_static.DNSServer.set_default_dns_gateway:
+        dns_gateway_server_list = config_static.DNSServer.set_default_dns_gateway
+        set_local_dns_gateway = True
+    elif config_static.DNSServer.set_default_dns_gateway_to_localhost:
+        dns_gateway_server_list = [base.LOCALHOST_IPV4]
+        set_local_dns_gateway = True
+    elif config_static.DNSServer.set_default_dns_gateway_to_default_interface_ipv4:
+        dns_gateway_server_list = [base.DEFAULT_IPV4]
+        set_local_dns_gateway = True
+    else:
+        dns_gateway_server_list = NETWORK_INTERFACE_SETTINGS.dns_gateways
+
+    if config_static.ENGINES_LIST[0].is_localhost:
+        if set_local_dns_gateway:
+            global IS_SET_DNS_GATEWAY
+            IS_SET_DNS_GATEWAY = True
+
+            # Get current network interface state.
+            global NETWORK_INTERFACE_IS_DYNAMIC, NETWORK_INTERFACE_IPV4_ADDRESS_LIST
+            NETWORK_INTERFACE_IS_DYNAMIC, NETWORK_INTERFACE_IPV4_ADDRESS_LIST = dns.get_default_dns_gateway()
+
+            # Set the DNS gateway to the specified one only if the DNS gateway is dynamic, or it is static but different
+            # from the one specified in the configuration file.
+            if (NETWORK_INTERFACE_IS_DYNAMIC or (not NETWORK_INTERFACE_IS_DYNAMIC and
+                                                 NETWORK_INTERFACE_IPV4_ADDRESS_LIST != dns_gateway_server_list)):
+                try:
+                    dns.set_connection_dns_gateway_static(
+                        dns_servers=dns_gateway_server_list,
+                        use_default_connection=True
+                    )
+                except PermissionError as e:
+                    print_api.print_api(e, error_type=True, color="red", logger=system_logger)
+                    # Wait for the message to be printed and saved to file.
+                    time.sleep(1)
+                    # network_logger_queue_listener.stop()
+                    return 1
+    else:
+        # Change the adapter settings and add the virtual IPs.
+        try:
+            networks.add_virtual_ips_to_default_adapter_by_current_setting(
+                virtual_ipv4s_to_add=IPS_TO_ASSIGN, virtual_ipv4_masks_to_add=MASKS_TO_ASSIGN,
+                dns_gateways=dns_gateway_server_list)
+        except PermissionError as e:
+            print_api.print_api(e, error_type=True, color="red", logger=system_logger)
+            # Wait for the message to be printed and saved to file.
             time.sleep(1)
+            # network_logger_queue_listener.stop()
+            return 1
+
+    return 0
 
 
 def _loop_at_midnight_recs_archive(network_logger_name):