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

atomicshop/wrappers/socketw/dns_server.py

@@ -11,7 +11,6 @@ import multiprocessing
 from ...print_api import print_api
 from ..loggingw import loggingw
 from ..psutilw import networks
-from ... import queues
 from ...basics import booleans, tracebacks
 from ...file_io import csvs
 
@@ -145,18 +144,15 @@ class DnsServer:
     # noinspection PyPep8Naming
     def __init__(
             self,
-            listening_interface: str,
-            listening_port: int,
+            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_to_tcp_server_only_tcp_resolve_domains: bool = False,
-            resolve_to_tcp_server_all_domains: bool = False,
-            resolve_regular: bool = False,
+            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,
-            tcp_target_server_ipv4: str = '127.0.0.1',
-            tcp_resolve_domain_list: list = None,
             request_domain_queue: multiprocessing.Queue = None,
             buffer_size_receive: int = 8192,
             response_ttl: int = 60,
@@ -169,9 +165,8 @@ class DnsServer:
         """
         Initialize the DNS Server object with all the necessary settings.
 
-        :param listening_interface: str: Interface that the DNS Server will listen on.
-            Example: '0.0.0.0'. For all interfaces.
-        :param listening_port: int: Port number that the DNS Server will listen on.
+        :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.
@@ -180,15 +175,14 @@ class DnsServer:
             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_to_tcp_server_only_tcp_resolve_domains: bool: If the DNS Server should route only the
-            domains from 'tcp_resolve_domain_list' to the TCP Server in 'tcp_target_server_ipv4'.
-        :param resolve_to_tcp_server_all_domains: bool: If the DNS Server should route all domains to the TCP Server.
-        :param resolve_regular: bool: If the DNS Server should resolve all the domains to the Live DNS Service.
+        :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 tcp_target_server_ipv4: str: IPv4 address of the TCP Server that the specified booleans will resolve
-            the domains to.
-        :param tcp_resolve_domain_list: list: List of domains that will be resolved to the TCP Server.
-            This means that all the requests will be resolved to the specified offline IPv4 address.
         :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.
@@ -205,17 +199,15 @@ class DnsServer:
         You can pass only one of the following: 'logger', 'logging_queue'.
         """
 
-        self.listening_interface: str = listening_interface
-        self.listening_port: int = listening_port
+        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.tcp_target_server_ipv4: str = tcp_target_server_ipv4
-        self.tcp_resolve_domain_list: list = tcp_resolve_domain_list
+        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.resolve_to_tcp_server_only_tcp_resolve_domains: bool = resolve_to_tcp_server_only_tcp_resolve_domains
-        self.resolve_to_tcp_server_all_domains: bool = resolve_to_tcp_server_all_domains
-        self.resolve_regular: bool = resolve_regular
         self.request_domain_queue: multiprocessing.Queue = request_domain_queue
         self.buffer_size_receive: int = buffer_size_receive
         self.response_ttl: int = response_ttl
@@ -227,10 +219,27 @@ class DnsServer:
         if logger and logging_queue:
             raise ValueError("You can pass only one of the following: 'logger', 'logging_queue'.")
 
-        if not tcp_resolve_domain_list:
-            self.tcp_resolve_domain_list = list()
-        else:
-            self.tcp_resolve_domain_list = tcp_resolve_domain_list
+        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_list: list = list()
+        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)
 
         # Settings for static DNS Responses in offline mode.
         self.offline_route_ipv4: str = '10.10.10.10'
@@ -270,7 +279,7 @@ class DnsServer:
                 add_timedfile_with_internal_queue=True,
                 formatter_streamhandler='DEFAULT',
                 formatter_filehandler='DEFAULT',
-                backupCount=backupCount_log_files_x_days
+                backupCount=self.backupCount_log_files_x_days
             )
         elif logger:
             # Create child logger for the provided logger with the module's name.
@@ -288,10 +297,9 @@ class DnsServer:
         try:
             booleans.is_only_1_true_in_list(
                 booleans_list_of_tuples=[
-                    (self.resolve_to_tcp_server_only_tcp_resolve_domains,
-                     'resolve_to_tcp_server_only_tcp_resolve_domains'),
-                    (self.resolve_to_tcp_server_all_domains, 'resolve_to_tcp_server_all_domains'),
-                    (self.resolve_regular, 'resolve_regular')
+                    (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
             )
@@ -345,19 +353,19 @@ 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.resolve_to_tcp_server_only_tcp_resolve_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.tcp_resolve_domain_list}"
+            message = f"Current all engines domains: {self.intercept_domain_list}"
             print_api(message, logger=self.logger, color='blue')
 
-        if self.resolve_to_tcp_server_all_domains:
-            message = "Routing all domains to Built-in TCP Server."
+        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.resolve_regular:
-            message = f"Routing all domains to Live DNS Service: {self.forwarding_dns_service_ipv4}"
+        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
@@ -462,10 +470,10 @@ class DnsServer:
                         if qtype_string == "A":
                             # 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_to_tcp_server_only_tcp_resolve_domains:
+                            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.tcp_resolve_domain_list):
+                                if any(x in question_domain for x in self.intercept_domain_list):
                                     # If incoming domain contains any of the 'engine_domains' then domain will
                                     # be forwarded to our TCP Server.
                                     forward_to_tcp_server = True
@@ -474,12 +482,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.resolve_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.resolve_regular:
+                            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.
@@ -488,9 +496,33 @@ 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.put(question_domain)
+                            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)
+
+                                        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:
+                                # 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(
@@ -499,7 +531,7 @@ class DnsServer:
                                 # q=DNSQuestion(question_domain),
                                 q=dns_object.q,
                                 a=RR(question_domain,
-                                     rdata=A(self.tcp_target_server_ipv4),
+                                     rdata=A(resolved_target_ipv4),
                                      ttl=self.response_ttl)
                             )
                             # Encode the response that was built above to legit DNS Response
@@ -883,19 +915,15 @@ class DnsServer:
 
 # noinspection PyPep8Naming
 def start_dns_server_multiprocessing_worker(
-        listening_interface: str,
-        listening_port: int,
+        listening_address: str,
         log_directory_path: str,
         backupCount_log_files_x_days: int,
         forwarding_dns_service_ipv4: str,
-        tcp_target_server_ipv4: str,
-        # 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.
-        tcp_resolve_domain_list: list,
+        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,
-        resolve_to_tcp_server_only_tcp_resolve_domains: bool,
-        resolve_to_tcp_server_all_domains: bool,
-        resolve_regular: bool,
         cache_timeout_minutes: int,
         request_domain_queue: multiprocessing.Queue,
         logging_queue: multiprocessing.Queue,
@@ -907,19 +935,15 @@ def start_dns_server_multiprocessing_worker(
 
     try:
         dns_server_instance = DnsServer(
-            listening_interface=listening_interface,
-            listening_port=listening_port,
+            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,
-            tcp_target_server_ipv4=tcp_target_server_ipv4,
-            # 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.
-            tcp_resolve_domain_list=tcp_resolve_domain_list,
+            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,
-            resolve_to_tcp_server_only_tcp_resolve_domains=resolve_to_tcp_server_only_tcp_resolve_domains,
-            resolve_to_tcp_server_all_domains=resolve_to_tcp_server_all_domains,
-            resolve_regular=resolve_regular,
             cache_timeout_minutes=cache_timeout_minutes,
             request_domain_queue=request_domain_queue,
             logging_queue=logging_queue,

atomicshop/wrappers/socketw/socket_client.py

@@ -28,7 +28,7 @@ class SocketClient:
             service_port: int,
             tls: bool = False,
             connection_ip=None,
-            dns_servers_list=None,
+            dns_servers_list: list[str] = None,
             logger: logging.Logger = None,
             custom_pem_client_certificate_file_path: str = None,
             enable_sslkeylogfile_env_to_client_ssl_context: bool = False

atomicshop/wrappers/socketw/socket_wrapper.py

@@ -5,7 +5,9 @@ from pathlib import Path
 import logging
 import socket
 import multiprocessing
+import queue
 
+from ...mitm import initialize_engines
 from ..psutilw import networks
 from ..certauthw import certauthw
 from ..loggingw import loggingw
@@ -32,7 +34,6 @@ SNI_QUEUE = queues.NonBlockQueue()
 class SocketWrapper:
     def __init__(
             self,
-            listening_address_list: list[str],
             forwarding_dns_service_ipv4_list___only_for_localhost: list = None,
             ca_certificate_name: str = None,
             ca_certificate_filepath: str = None,
@@ -69,15 +70,14 @@ class SocketWrapper:
             exceptions_logger: loggingw.ExceptionCsvLogger = None,
             statistics_logs_directory: str = None,
             request_domain_from_dns_server_queue: multiprocessing.Queue = None,
-            engines_domains: dict = None,
-            engine_no_sni_domain: str = None
+            no_engine_usage_enable: bool = False,
+            no_engines_listening_address_list: list[str] = None,
+            engines_list: list[initialize_engines.ModuleCategory] = None
     ):
         """
         Socket Wrapper class that will be used to create sockets, listen on them, accept connections and send them to
         new threads.
 
-        :param listening_address_list: list, of ips+ports that will be listened on.
-            Example: ['0.0.0.0:443', '0.0.0.0:80']
         :param ca_certificate_name: CA certificate name.
         :param ca_certificate_filepath: CA certificate file path with '.pem' extension.
         :param ca_certificate_crt_filepath: CA certificate file path with '.crt' extension.
@@ -166,19 +166,24 @@ class SocketWrapper:
             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 engines_domains: dictionary of engines that will be used to process the requests. Example:
-            [
-                {'this_is_engine_name': ['example.com', 'example.org']},
-                {'this_is_engine_name2': ['example2.com', 'example2.org']}
-            ]
-
-            the 'engine_name' for statistics.csv file will be taken from the key of the dictionary, while correlated
-            by the domain name from the list in the dictionary.
-        :param engine_no_sni_domain: string, domain name that will be used if there is no SNI in the request,
-            and no domain hit the dns server. This is used 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.
+            Example: ['0.0.0.0:443', '0.0.0.0:80']
+        :param engines_list: list, of engines that will be used to process the requests. Structure of engine_config.toml:
+            [engine]
+            "domains" = ["example.com"]
+
+            [mtls]
+            # "subdomain.domain.com" = "file_name_in_current_dir.pem"
+
+            [no_sni]
+            #get_from_dns = 1         # Blocking, the accept function will wait until the domain is received from DNS.
+            #get_from_engine = 0
+            #try_to_get_from_dns_on_empty_get_from_engine = 0    # Non-blocking, on empty DNS server queue, accept() will connect to the domain from below.
+            #"domain" = "example.com"
         """
 
-        self.listening_address_list: list[str] = listening_address_list
         self.ca_certificate_name: str = ca_certificate_name
         self.ca_certificate_filepath: str = ca_certificate_filepath
         self.ca_certificate_crt_filepath: str = ca_certificate_crt_filepath
@@ -211,8 +216,21 @@ class SocketWrapper:
         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.engines_domains: dict = engines_domains
-        self.engine_no_sni_domain: str = engine_no_sni_domain
+        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
 
@@ -275,6 +293,13 @@ class SocketWrapper:
                 "You can't set both [sni_use_default_callback_function = True] and [sni_custom_callback_function]."
             raise SocketWrapperConfigurationValuesError(message)
 
+        if self.no_engine_usage_enable and not self.no_engines_listening_address_list:
+            message = "You set [no_engine_usage_enable = True], but you didn't set [no_engines_listening_address_list]."
+            raise SocketWrapperConfigurationValuesError(message)
+        elif not self.no_engine_usage_enable and not self.engines_list:
+            message = "You set [no_engine_usage_enable = False], but you didn't set [engines_list]."
+            raise SocketWrapperConfigurationValuesError(message)
+
         try:
             booleans.is_only_1_true_in_list(
                 booleans_list_of_tuples=[
@@ -322,7 +347,16 @@ class SocketWrapper:
                     print_api(message, color='red', logger=self.logger)
                     return 1
 
-        port_in_use = networks.get_processes_using_port_list(self.listening_address_list)
+        # Checking if listening address is in use.
+        listening_check_list: list = list()
+        if self.engines_list:
+            for engine in self.engines_list:
+                for address in engine.tcp_listening_address_list:
+                    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)
         if port_in_use:
             error_messages: list = list()
             for port, process_info in port_in_use.items():
@@ -399,26 +433,74 @@ class SocketWrapper:
 
         return self.socket_object
 
-    def create_tcp_listening_socket_list(self, overwrite_list: bool = False):
-        # If 'overwrite_list' was set to 'True', we will create new list. The default is 'False', since it is meant to`
-        # add new sockets to already existing ones.
-        if overwrite_list:
-            self.listening_sockets = list()
-
-        # Creating a socket for each port in the list set in configuration file
-        for address in self.listening_address_list:
-            ip_address, port_str = address.split(':')
-            port = int(port_str)
-            socket_by_port = self.create_socket_ipv4_tcp(
-                ip_address, port)
-
-            self.listening_sockets.append(socket_by_port)
+    def start_listening_sockets(
+            self,
+            reference_function_name,
+            reference_function_args=(),
+            pass_function_reference_to_thread: bool = True
+    ):
+        """
+        Start listening sockets with parameters.
+        """
 
-    def loop_for_incoming_sockets(
+        # If engines were passed, we will use the listening addresses from the engines.
+        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)
+                    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()
+
+                # 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:
+                ip_address, port_str = 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, None, reference_function_name,
+                          reference_function_args, pass_function_reference_to_thread),
+                    name=f"acceptor-{ip_address}:{port}",
+                    daemon=True
+                ).start()
+
+        # # Creating a socket for each port in the list set in configuration file
+        # for address in self.listening_address_list:
+        #     ip_address, port_str = address.split(':')
+        #     port = int(port_str)
+        #     socket_by_port = self.create_socket_ipv4_tcp(
+        #         ip_address, port)
+        #
+        #     self.listening_sockets.append(socket_by_port)
+
+    def listening_socket_loop(
             self,
+            listening_socket_object: socket.socket,
+            engine: initialize_engines.ModuleCategory,
             reference_function_name,
             reference_function_args=(),
-            listening_socket_list: list = None,
             pass_function_reference_to_thread: bool = True
     ):
         """
@@ -426,6 +508,8 @@ class SocketWrapper:
         The boolean variable was declared True in the beginning of the script and will be set to False if the process
         will be killed or closed.
 
+        :param listening_socket_object: listening socket that was created with bind.
+        :param engine: ModuleCategory.
         :param reference_function_name: callable, function reference that you want to execute when client
             socket received by 'accept()' and connection has been made.
         :param reference_function_args: tuple, that will be passed to 'function_reference' when it will be called.
@@ -439,17 +523,13 @@ class SocketWrapper:
             process_name: string, process name that was gathered from the socket.
             is_tls: boolean, if the socket is SSL/TLS.
             domain_from_dns_server: string, domain that was requested from DNS server.
-        :param listening_socket_list: list, of sockets that you want to listen on.
         :param pass_function_reference_to_thread: boolean, that sets if 'function_reference' will be
             executed as is, or passed to thread. 'function_reference' can include passing to a thread,
             but you don't have to use it, since SocketWrapper can do it for you.
         :return:
         """
 
-        # If 'listening_socket_list' wasn't specified and 'self.listening_sockets' is not empty.
-        if not listening_socket_list and self.listening_sockets:
-            # Then assign 'self.listening_sockets'.
-            listening_socket_list = self.listening_sockets
+        listening_sockets: list = [listening_socket_object]
 
         while True:
             try:
@@ -457,7 +537,7 @@ class SocketWrapper:
                 # operating system types: Windows / Linux / BSD.
                 # To accept connection, we don't need "writable" and "exceptional", since "readable" holds the currently
                 # connected socket.
-                readable, writable, exceptional = select.select(listening_socket_list, [], [])
+                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
@@ -465,11 +545,21 @@ class SocketWrapper:
                 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()
-                    import queue
-                    try:
-                        domain_from_dns_server = self.request_domain_from_dns_server_queue.get_nowait()
-                    except queue.Empty:
-                        domain_from_dns_server = self.engine_no_sni_domain
+                    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}")
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: atomicshop
-Version: 2.20.8
+Version: 2.21.1
 Summary: Atomic functions and classes to make developer life easier
 Author: Denis Kras
 License: MIT License