atomicshop 2.21.1__py3-none-any.whl → 3.0.1__py3-none-any.whl

atomicshop/wrappers/socketw/accepter.py

@@ -2,12 +2,21 @@ from . import exception_wrapper
 
 
 @exception_wrapper.connection_exception_decorator
-def accept_connection(socket_object, domain_from_dns_server, print_kwargs: dict = None):
+def accept_connection(
+        socket_object,
+        domain_from_dns_server: str = None,
+        print_kwargs: dict = None
+):
     """
     Accept connection from client.
     This function is wrapped with exception wrapper.
     After you execute the function, you can get the error message if there was any with:
         error_message = accept_connection.message
+
+    :param socket_object: The socket object to accept the connection on.
+    :param domain_from_dns_server: The domain that will be printed to console on logger, needed for the decorator.
+        If not provided, the TCP data will be used.
+    :param print_kwargs: Additional arguments for the print_api function, needed for the decorator.
     """
 
     client_socket = None
@@ -33,6 +42,11 @@ def accept_connection_with_error(
         domain_from_dns_server,
         print_kwargs: dict = None
 ):
+    """
+    :param socket_object: The socket object to accept the connection on.
+    :param domain_from_dns_server: The domain that will be printed to console on logger.
+    :param print_kwargs: Additional arguments for the print_api function.
+    """
     client_socket, client_address_tuple = accept_connection(
         socket_object, domain_from_dns_server, print_kwargs=print_kwargs)
     error_message = accept_connection.message

atomicshop/wrappers/socketw/creator.py

@@ -151,13 +151,19 @@ def create_server_ssl_context___load_certificate_and_key(certificate_file_path:
 def wrap_socket_with_ssl_context_server(
         socket_object,
         ssl_context,
-        domain_from_dns_server,
+        domain_from_dns_server: str = None,
         print_kwargs: dict = None
 ):
     """
     This function is wrapped with exception wrapper.
     After you execute the function, you can get the error message if there was any with:
         error_message = wrap_socket_with_ssl_context_server.message
+
+    :param socket_object: The socket object to accept the connection on.
+    :param ssl_context: The SSL context to wrap the socket with.
+    :param domain_from_dns_server: The domain that will be printed to console on logger, needed for the decorator.
+        If not provided, the TCP data will be used.
+    :param print_kwargs: Additional arguments for the print_api function, needed for the decorator.
     """
 
     # Wrapping the server socket with SSL context. This should happen right after setting up the raw socket.

atomicshop/wrappers/socketw/dns_server.py

@@ -5,12 +5,12 @@ import threading
 import socket
 import logging
 from pathlib import Path
-from typing import Literal
+from typing import Literal, Optional
 import multiprocessing
 
 from ...print_api import print_api
 from ..loggingw import loggingw
-from ..psutilw import networks
+from ..psutilw import psutil_networks
 from ...basics import booleans, tracebacks
 from ...file_io import csvs
 
@@ -153,7 +153,6 @@ class DnsServer:
             resolve_regular_pass_thru: bool = False,
             resolve_all_domains_to_ipv4: tuple[bool, str] = (False, '127.0.0.1'),
             offline_mode: bool = False,
-            request_domain_queue: multiprocessing.Queue = None,
             buffer_size_receive: int = 8192,
             response_ttl: int = 60,
             dns_service_retries: int = 5,
@@ -183,7 +182,6 @@ class DnsServer:
         :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 request_domain_queue: multiprocessing Queue to pass all the requested domains that hit the DNS
         :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:
@@ -208,7 +206,6 @@ class DnsServer:
         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.request_domain_queue: multiprocessing.Queue = request_domain_queue
         self.buffer_size_receive: int = buffer_size_receive
         self.response_ttl: int = response_ttl
         self.dns_service_retries: int = dns_service_retries
@@ -229,17 +226,13 @@ class DnsServer:
         self.resolve_all_domains_to_ipv4_enable: bool
         self.resolve_all_domains_target: str
 
-        self.intercept_domain_list: list = list()
+        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_list.extend(engine.domain_list)
 
-                # If the engine has no_sni section enabled, get the domains from it.
-                if engine.no_sni.serve_domain_on_address_enable:
-                    for domain, ip_address in engine.no_sni.serve_domain_on_address_dict.items():
-                        self.intercept_domain_list.append(domain)
+                self.intercept_domain_dict.update(engine.domain_target_dict)
 
         # Settings for static DNS Responses in offline mode.
         self.offline_route_ipv4: str = '10.10.10.10'
@@ -310,7 +303,7 @@ class DnsServer:
             raise DnsConfigurationValuesError(e)
 
         ips_ports: list[str] = [f'{self.listening_interface}:{self.listening_port}']
-        port_in_use = networks.get_processes_using_port_list(ips_ports)
+        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():
@@ -357,7 +350,7 @@ class DnsServer:
             message = "Routing engine domains to the specified IPv4 targets."
             print_api(message, logger=self.logger)
 
-            message = f"Current all engines domains: {self.intercept_domain_list}"
+            message = f"Current all engines domains: {list(self.intercept_domain_dict.keys())}"
             print_api(message, logger=self.logger, color='blue')
 
         if self.resolve_all_domains_to_ipv4_enable:
@@ -473,7 +466,7 @@ class DnsServer:
                             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.intercept_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
@@ -498,32 +491,14 @@ class DnsServer:
                         if forward_to_tcp_server:
                             if self.resolve_by_engine_enable:
                                 for engine in self.engine_list:
-                                    # Check if the incoming domain contain any of the domains in the list.
-                                    if any(x in question_domain for x in engine.domain_list):
-                                        # Get the target IP address from the engine.
-                                        resolved_target_ipv4 = engine.dns_target
-
-                                        if engine.no_sni.get_from_dns:
-                                            # 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.put(question_domain)
-
+                                    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
-
-                                    if engine.no_sni.serve_domain_on_address_enable:
-                                        if question_domain in engine.no_sni.serve_domain_on_address_dict:
-                                            ip_port_address: str = engine.no_sni.serve_domain_on_address_dict[question_domain]
-                                            target_ip = ip_port_address.split(':')[0]
-                                            resolved_target_ipv4 = target_ip
-                                            break
-
-                            if self.resolve_all_domains_to_ipv4_enable:
+                            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
 
-                                # Put the domain in the domain queue.
-                                self.request_domain_queue.put(question_domain)
-
                             # Make DNS response that will refer TCP traffic to our server
                             dns_built_response = DNSRecord(
                                 # dns_object.header,
@@ -913,6 +888,27 @@ class DnsServer:
                     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 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,
@@ -925,7 +921,6 @@ def start_dns_server_multiprocessing_worker(
         resolve_all_domains_to_ipv4: tuple[bool, str],
         offline_mode: bool,
         cache_timeout_minutes: int,
-        request_domain_queue: multiprocessing.Queue,
         logging_queue: multiprocessing.Queue,
         logger_name: str
 ):
@@ -945,7 +940,6 @@ def start_dns_server_multiprocessing_worker(
             resolve_all_domains_to_ipv4=resolve_all_domains_to_ipv4,
             offline_mode=offline_mode,
             cache_timeout_minutes=cache_timeout_minutes,
-            request_domain_queue=request_domain_queue,
             logging_queue=logging_queue,
             logger_name=logger_name
         )
@@ -954,4 +948,4 @@ def start_dns_server_multiprocessing_worker(
         time.sleep(1)
         return 1
 
-    dns_server_instance.start()
+    dns_server_instance.start()

atomicshop/wrappers/socketw/exception_wrapper.py

@@ -14,7 +14,13 @@ def connection_exception_decorator(function_name):
         args, kwargs = get_target_function_default_args_and_combine_with_current(function_name, *args, **kwargs)
 
         wrapper_handle_connection_exceptions.message = None
-        port = kwargs['socket_object'].getsockname()[1]
+        listen_ipv4, port = kwargs['socket_object'].getsockname()
+
+        domain_from_dns_server = kwargs['domain_from_dns_server']
+        if not domain_from_dns_server:
+            # If the domain is not passed, we will use the TCP data.
+            # This is needed for the decorator to work properly.
+            domain_from_dns_server = listen_ipv4
 
         try:
             # Since our 'kwargs' has already all the needed arguments, we don't need 'args'.
@@ -24,12 +30,12 @@ def connection_exception_decorator(function_name):
             # After that second exception will be "pass"-ed. This is an exception inside an exception handling.
             # Looks like was introduced in Python 3 in PEP 3134.
         except ConnectionAbortedError:
-            message = f"Socket Accept: {kwargs['domain_from_dns_server']}:{port}: " \
+            message = f"Socket Accept: {domain_from_dns_server}:{port}: " \
                       f"* Established connection was aborted by software on the host..."
             wrapper_handle_connection_exceptions.message = message
             print_api(message, logger_method='error', traceback_string=True, oneline=True, **kwargs['print_kwargs'])
         except ConnectionResetError:
-            message = f"Socket Accept: {kwargs['domain_from_dns_server']}:{port}: " \
+            message = f"Socket Accept: {domain_from_dns_server}:{port}: " \
                       f"* An existing connection was forcibly closed by the remote host..."
             wrapper_handle_connection_exceptions.message = message
             print_api(message, logger_method='error', traceback_string=True, oneline=True, **kwargs['print_kwargs'])
@@ -43,10 +49,11 @@ def connection_exception_decorator(function_name):
             wrapper_handle_connection_exceptions.message = message
             try:
                 message = \
-                    f"Socket Accept: {kwargs['domain_from_dns_server']}:{port}: {message}"
+                    f"Socket Accept: {domain_from_dns_server}:{port}: {message}"
                 wrapper_handle_connection_exceptions.message = message
                 print_api(message, error_type=True, logger_method='error', oneline=True, **kwargs['print_kwargs'])
-            except Exception:
+            except Exception as e:
+                _ = e
                 message = f"Socket Accept: port {port}: {message}"
                 wrapper_handle_connection_exceptions.message = message
                 print_api(message, logger_method='error', traceback_string=True, oneline=True, **kwargs['print_kwargs'])
@@ -57,10 +64,11 @@ def connection_exception_decorator(function_name):
             wrapper_handle_connection_exceptions.message = message
             try:
                 message = \
-                    f"Socket Accept: {kwargs['domain_from_dns_server']}:{port}: {message}"
+                    f"Socket Accept: {domain_from_dns_server}:{port}: {message}"
                 wrapper_handle_connection_exceptions.message = message
                 print_api(message, logger_method='error', oneline=True, **kwargs['print_kwargs'])
-            except Exception:
+            except Exception as e:
+                _ = e
                 message = f"Socket Accept: port {port}: {message}"
                 wrapper_handle_connection_exceptions.message = message
                 print_api(message, logger_method='error', traceback_string=True, oneline=True, **kwargs['print_kwargs'])
@@ -91,20 +99,21 @@ def connection_exception_decorator(function_name):
                 message = f'ssl.SSLError:{exception_object}'
                 wrapper_handle_connection_exceptions.message = message
                 message = \
-                    f"Socket Accept: {kwargs['domain_from_dns_server']}:{port}: {message}"
+                    f"Socket Accept: {domain_from_dns_server}:{port}: {message}"
                 wrapper_handle_connection_exceptions.message = message
                 print_api(message, logger_method='error', oneline=True, **kwargs['print_kwargs'])
             pass
         except FileNotFoundError:
             message = "'SSLSocket.accept()' crashed: 'FileNotFoundError'. Some problem with SSL during Handshake - " \
                       "Could be certificate, client, or server."
-            message = f"Socket Accept: {kwargs['domain_from_dns_server']}:{port}: {message}"
+            message = f"Socket Accept: {domain_from_dns_server}:{port}: {message}"
             wrapper_handle_connection_exceptions.message = message
             print_api(message, logger_method='error', traceback_string=True, oneline=True, **kwargs['print_kwargs'])
             pass
-        except Exception:
+        except Exception as e:
+            _ = e
             message = "Undocumented exception on accept."
-            message = f"Socket Accept: {kwargs['domain_from_dns_server']}:{port}: {message}"
+            message = f"Socket Accept: {domain_from_dns_server}:{port}: {message}"
             wrapper_handle_connection_exceptions.message = message
             print_api(message, logger_method='error', traceback_string=True, oneline=True, **kwargs['print_kwargs'])
             pass

atomicshop/wrappers/socketw/socket_wrapper.py

@@ -4,11 +4,9 @@ from typing import Literal, Union
 from pathlib import Path
 import logging
 import socket
-import multiprocessing
-import queue
 
 from ...mitm import initialize_engines
-from ..psutilw import networks
+from ..psutilw import psutil_networks
 from ..certauthw import certauthw
 from ..loggingw import loggingw
 from ...script_as_string_processor import ScriptAsStringProcessor
@@ -69,7 +67,6 @@ class SocketWrapper:
             logger: logging.Logger = None,
             exceptions_logger: loggingw.ExceptionCsvLogger = None,
             statistics_logs_directory: str = None,
-            request_domain_from_dns_server_queue: multiprocessing.Queue = None,
             no_engine_usage_enable: bool = False,
             no_engines_listening_address_list: list[str] = None,
             engines_list: list[initialize_engines.ModuleCategory] = None
@@ -162,10 +159,6 @@ class SocketWrapper:
 
             statistics_writer: statistics_csv.StatisticsCSVWriter object, there is a logger object that
                 will be used to write the statistics file.
-        :param request_domain_from_dns_server_queue: multiprocessing queue that will be used
-            to get the domain name that was requested from the DNS server (atomicshop.wrappers.socketw.dns_server).
-            This is used to get the domain name that got to the DNS server and set it to the socket in case SNI
-            was empty (in the SNIHandler class to set the 'server_hostname' for the socket).
         :param no_engine_usage_enable: boolean, if True, 'engines_list' will be used to listen on the addresses,
             but the "no_engines_listening_address_list" parameter will be used instead.
         :param no_engines_listening_address_list: list, of ips+ports that will be listened on.
@@ -215,23 +208,10 @@ class SocketWrapper:
         self.statistics_logs_directory: str = statistics_logs_directory
         self.forwarding_dns_service_ipv4_list___only_for_localhost = (
             forwarding_dns_service_ipv4_list___only_for_localhost)
-        self.request_domain_from_dns_server_queue: multiprocessing.Queue = request_domain_from_dns_server_queue
         self.no_engine_usage_enable: bool = no_engine_usage_enable
         self.no_engines_listening_address_list: list[str] = no_engines_listening_address_list
         self.engines_list: list[initialize_engines.ModuleCategory] = engines_list
 
-        # dictionary of engines that will be used to find the engine name. Example:
-        # [{'this_is_engine_name': ['example.com', 'example.org']},
-        # {'this_is_engine_name2': ['example2.com', 'example2.org']}]
-        self.engines_domains: dict = dict()
-        for engine in self.engines_list:
-            self.engines_domains[engine.engine_name] = engine.domain_list
-
-            if engine.no_sni.serve_domain_on_address_enable:
-                for domain, ip_port_address in engine.no_sni.serve_domain_on_address_dict.items():
-                    if domain not in self.engines_domains[engine.engine_name]:
-                        self.engines_domains[engine.engine_name].append(domain)
-
         self.socket_object = None
 
         # Server certificate file path that will be loaded into SSL Context.
@@ -351,12 +331,13 @@ class SocketWrapper:
         listening_check_list: list = list()
         if self.engines_list:
             for engine in self.engines_list:
-                for address in engine.tcp_listening_address_list:
+                for _, ip_port_dict in engine.domain_target_dict.items():
+                    address: str = f"{ip_port_dict['ip']}:{ip_port_dict['port']}"
                     if address not in listening_check_list:
                         listening_check_list.append(address)
         else:
             listening_check_list = self.no_engines_listening_address_list
-        port_in_use = networks.get_processes_using_port_list(listening_check_list)
+        port_in_use = psutil_networks.get_processes_using_port_list(listening_check_list)
         if port_in_use:
             error_messages: list = list()
             for port, process_info in port_in_use.items():
@@ -447,9 +428,9 @@ class SocketWrapper:
         if not self.no_engine_usage_enable:
             for engine in self.engines_list:
                 # Start all the regular listening interfaces.
-                for address in engine.tcp_listening_address_list:
-                    ip_address, port_str = address.split(':')
-                    port = int(port_str)
+                for domain, ip_port_dict in engine.domain_target_dict.items():
+                    ip_address: str = ip_port_dict['ip']
+                    port = int(ip_port_dict['port'])
                     socket_by_port = self.create_socket_ipv4_tcp(ip_address, port)
                     threading.Thread(
                         target=self.listening_socket_loop,
@@ -458,20 +439,6 @@ class SocketWrapper:
                         name=f"acceptor-{engine.engine_name}-{ip_address}:{port}",
                         daemon=True
                     ).start()
-
-                # Start all the interfaces configured in the no_sni section.
-                if engine.no_sni.serve_domain_on_address_enable:
-                    for domain, ip_port_address in engine.no_sni.serve_domain_on_address_dict.items():
-                        ip_address, port_str = ip_port_address.split(':')
-                        port = int(port_str)
-                        socket_by_port = self.create_socket_ipv4_tcp(ip_address, port)
-                        threading.Thread(
-                            target=self.listening_socket_loop,
-                            args=(socket_by_port, engine, reference_function_name,
-                                  reference_function_args, pass_function_reference_to_thread),
-                            name=f"acceptor-{engine.engine_name}-{ip_address}:{port}",
-                            daemon=True
-                        ).start()
         else:
             # If no engines were passed, we will use the listening addresses from the configuration.
             for address in self.no_engines_listening_address_list:
@@ -540,33 +507,21 @@ class SocketWrapper:
                 readable, writable, exceptional = select.select(listening_sockets, [], [])
                 listening_socket_object = readable[0]
 
-                # Get the domain queue. Tried using "Queue.Queue" object, but it stomped the SSL Sockets
-                # from accepting connections.
-                domain_from_dns_server = None
-                if self.request_domain_from_dns_server_queue is not None:
-                    # domain_from_dns_server = self.request_domain_from_dns_server_queue.get()
-                    if engine.no_sni.get_from_dns:
-                        domain_from_dns_server = self.request_domain_from_dns_server_queue.get()
-
-                    if engine.no_sni.serve_domain_on_address_enable:
-                        # try:
-                        #     domain_from_dns_server = self.request_domain_from_dns_server_queue.get_nowait()
-                        # except queue.Empty:
-                        #     domain_from_dns_server = engine.no_sni['domain']
-
-                        listening_ip, listening_port = listening_socket_object.getsockname()
-                        for domain, ip_port_address in engine.no_sni.serve_domain_on_address_dict.items():
-                            ip_address: str = ip_port_address.split(':')[0]
-                            if ip_address == listening_ip:
-                                domain_from_dns_server = domain
-                                break
-
-                    self.logger.info(f"Requested domain from DNS Server: {domain_from_dns_server}")
+                listening_ip, listening_port = listening_socket_object.getsockname()
+
+                domain_from_engine = None
+                for engine in self.engines_list:
+                    for domain, ip_port_dict in engine.domain_target_dict.items():
+                        if ip_port_dict['ip'] == listening_ip:
+                            domain_from_engine = domain
+                            break
+
+                    self.logger.info(f"NO SNI requested domain setting: {domain_from_engine}")
 
                 # Wait from any connection on "accept()".
                 # 'client_socket' is socket or ssl socket, 'client_address' is a tuple (ip_address, port).
                 client_socket, client_address, accept_error_message = accepter.accept_connection_with_error(
-                    listening_socket_object, domain_from_dns_server=domain_from_dns_server,
+                    listening_socket_object, domain_from_dns_server=domain_from_engine,
                     print_kwargs={'logger': self.logger})
 
                 # This is the earliest stage to ask for process name.
@@ -585,7 +540,7 @@ class SocketWrapper:
 
                 source_ip: str = client_address[0]
                 source_hostname: str = socket.gethostbyaddr(source_ip)[0]
-                engine_name: str = get_engine_name(domain_from_dns_server, self.engines_domains)
+                engine_name: str = get_engine_name(domain_from_engine, self.engines_list)
                 dest_port: int = listening_socket_object.getsockname()[1]
 
                 # If 'accept()' function worked well, SSL worked well, then 'client_socket' won't be empty.
@@ -625,7 +580,7 @@ class SocketWrapper:
                             custom_server_certificate_usage=self.custom_server_certificate_usage,
                             custom_server_certificate_path=self.custom_server_certificate_path,
                             custom_private_key_path=self.custom_private_key_path,
-                            domain_from_dns_server=domain_from_dns_server,
+                            domain_from_dns_server=domain_from_engine,
                             forwarding_dns_service_ipv4_list___only_for_localhost=(
                                 self.forwarding_dns_service_ipv4_list___only_for_localhost),
                             tls=is_tls,
@@ -643,7 +598,7 @@ class SocketWrapper:
                         if engine_name == '':
                             sni_hostname: str = ssl_client_socket.server_hostname
                             if sni_hostname:
-                                engine_name = get_engine_name(sni_hostname, self.engines_domains)
+                                engine_name = get_engine_name(sni_hostname, self.engines_list)
 
                         if accept_error_message:
                             # Write statistics after wrap is there was an error.
@@ -653,7 +608,7 @@ class SocketWrapper:
                                 source_ip=source_ip,
                                 error_message=accept_error_message,
                                 dest_port=str(dest_port),
-                                host=domain_from_dns_server,
+                                host=domain_from_engine,
                                 process_name=process_name)
 
                             continue
@@ -668,7 +623,7 @@ class SocketWrapper:
                         client_socket = None
                         client_socket = ssl_client_socket
                     thread_args = \
-                        ((client_socket, process_name, is_tls, tls_type, tls_version, domain_from_dns_server) +
+                        ((client_socket, process_name, is_tls, tls_type, tls_version, domain_from_engine) +
                          reference_function_args)
                     # If 'pass_function_reference_to_thread' was set to 'False', execute the callable passed function
                     # as is.
@@ -691,7 +646,7 @@ class SocketWrapper:
                         source_ip=source_ip,
                         error_message=accept_error_message,
                         dest_port=str(dest_port),
-                        host=domain_from_dns_server,
+                        host=domain_from_engine,
                         process_name=process_name)
             except Exception as e:
                 self.exceptions_logger.write(e)
@@ -729,20 +684,16 @@ def before_socket_thread_worker(
         exceptions_logger.write(e)
 
 
-def get_engine_name(domain: str, engines_domains: dict):
+def get_engine_name(domain: str, engine_list: list):
     """
     Function that will get the engine name from the domain name.
     :param domain: string, domain name.
-    :param engines_domains: dictionary, dictionary that contains the engine names and domains. Example:
-        [
-            {'this_is_engine_name': ['example.com', 'example.org']},
-            {'this_is_engine_name2': ['example2.com', 'example2.org']}
-        ]
+    :param engine_list: list that contains the engine names and domains.
     :return: string, engine name.
     """
 
-    for engine_name, engine_domain_list in engines_domains.items():
-        if any(engine_domain in domain for engine_domain in engine_domain_list):
-            return engine_name
+    for engine in engine_list:
+        if domain in engine.domain_target_dict:
+            return engine.engine_name
 
     return ''

atomicshop/wrappers/winregw/winreg_network.py

@@ -205,3 +205,23 @@ def get_default_dns_gateway() -> tuple[bool, list[str]]:
 
     # noinspection PyTypeChecker
     return function_result
+
+
+def change_metric_of_network_adapter(
+        adapter_guid: str,
+        metric: int
+) -> None:
+    """
+    Change the metric of a network adapter.
+    After you set new metric you need to restart the network adapter for the changes to take effect.
+
+    :param adapter_guid: str, GUID of the network adapter.
+    :param metric: int, new metric value.
+    :return: None
+    """
+
+    reg_path = fr"SYSTEM\CurrentControlSet\Services\Tcpip\Parameters\Interfaces\{adapter_guid}"
+
+    with winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, reg_path, 0, winreg.KEY_SET_VALUE) as key:
+        winreg.SetValueEx(key, "UseAutomaticMetric", 0, winreg.REG_DWORD, 0)
+        winreg.SetValueEx(key, "InterfaceMetric", 0, winreg.REG_DWORD, metric)

{atomicshop-2.21.1.dist-info → atomicshop-3.0.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: atomicshop
-Version: 2.21.1
+Version: 3.0.1
 Summary: Atomic functions and classes to make developer life easier
 Author: Denis Kras
 License: MIT License
@@ -41,6 +41,7 @@ Requires-Dist: docker
 Requires-Dist: flask-socketio
 Requires-Dist: google-api-python-client
 Requires-Dist: google-generativeai
+Requires-Dist: icmplib
 Requires-Dist: numpy
 Requires-Dist: olefile
 Requires-Dist: openpyxl