atomicshop 3.3.28__py3-none-any.whl → 3.10.0__py3-none-any.whl

atomicshop/wrappers/socketw/dns_server.py

@@ -305,7 +305,7 @@ class DnsServer:
 
         # If the listening interface is not localhost, check if the interface can be bound to.
         if not self.listening_interface.startswith('127.'):
-            host_ips: list[str] = networks.get_host_ips(ipv6=False)
+            host_ips: list[str] = networks.get_host_ips_psutil(ipv6=False)
             if self.listening_interface not in host_ips:
                 message = (f"Listening interface [{self.listening_interface}] is not assigned to any of the host "
                            f"network interfaces. Current host IPv4 addresses: {host_ips}")
@@ -478,7 +478,7 @@ class DnsServer:
                     dns_cached_request = False
                     # Check if the received data request from client is already in the cache
                     if client_data in self.dns_questions_to_answers_cache:
-                        # message = "!!! Question / Answer is already in the dictionary..."
+                        # message = "!!! Request / Response is already in the dictionary..."
                         # self.logger.info(message)
 
                         # Get the response from the cached answers list
@@ -561,7 +561,7 @@ class DnsServer:
                                                 f'{self.offline_route_ipv6}')
                                         )
 
-                                        message = f"!!! Question / Answer is in offline mode returning " \
+                                        message = f"!!! Request / Response is in offline mode returning " \
                                                   f"{self.offline_route_ipv6}."
                                         self.logger.info(message)
 
@@ -577,7 +577,7 @@ class DnsServer:
                                     elif qtype_string == "SRV" or qtype_string == "SOA" or qtype_string == "HTTPS":
                                         dns_built_response.add_answer(*RR.fromZone(self.offline_srv_answer))
 
-                                        message = f"!!! Question / Answer is in offline mode returning: " \
+                                        message = f"!!! Request / Response is in offline mode returning: " \
                                                   f"{self.offline_srv_answer}."
                                         self.logger.info(message)
                                     elif qtype_string == "ANY":
@@ -586,7 +586,7 @@ class DnsServer:
                                                          self.offline_route_domain)
                                         )
 
-                                        message = f"!!! Question / Answer is in offline mode returning " \
+                                        message = f"!!! Request / Response is in offline mode returning " \
                                                   f"{self.offline_route_domain}."
                                         self.logger.info(message)
                                     else:
@@ -596,7 +596,7 @@ class DnsServer:
                                                 " " + self.offline_route_ipv4)
                                         )
 
-                                        message = f"!!! Question / Answer is in offline mode returning " \
+                                        message = f"!!! Request / Response is in offline mode returning " \
                                                   f"{self.offline_route_ipv4}."
                                         self.logger.info(message)
                                 # Values error means in most cases that you create wrong response

atomicshop/wrappers/socketw/exception_wrapper.py

@@ -1,7 +1,7 @@
 import ssl
 import functools
 
-from . import base
+from . import socket_base
 from ...print_api import print_api
 from ...inspect_wrapper import get_target_function_default_args_and_combine_with_current
 
@@ -80,14 +80,14 @@ def connection_exception_decorator(function_name):
                 # Getting the exact reason of "ssl.SSLError"
                 if exception_object.reason == "HTTP_REQUEST":
                     message = f"Socket Accept: HTTP Request on SSL Socket: " \
-                              f"{base.get_source_destination(kwargs['socket_object'])}"
+                              f"{socket_base.get_source_destination(kwargs['socket_object'])}"
                     wrapper_handle_connection_exceptions.message = message
                     print_api(message, logger_method='error', traceback_string=True, oneline=True, **kwargs['print_kwargs'])
 
                     excepted = True
                 elif exception_object.reason == "TSV1_ALERT_UNKNOWN_CA":
                     message = f"Socket Accept: Check CA certificate on the client " \
-                              f"{base.get_source_destination(kwargs['socket_object'])}"
+                              f"{socket_base.get_source_destination(kwargs['socket_object'])}"
                     wrapper_handle_connection_exceptions.message = message
                     print_api(message, logger_method='error', traceback_string=True, oneline=True, **kwargs['print_kwargs'])
 

atomicshop/wrappers/socketw/process_getter.py

@@ -0,0 +1,86 @@
+import logging
+
+from . import socket_base
+from ...print_api import print_api
+from ...ssh_remote import SSHRemote
+from ... import package_mains_processor
+
+
+GET_LOCALHOST_FUNCTION_NAME = 'find_cmdline_by_port'
+
+
+class GetCommandLine:
+    def __init__(
+            self,
+            client_ip: str,
+            client_port: int = None,
+            package_processor: package_mains_processor.PackageMainsProcessor = None,
+            ssh_client: SSHRemote = None,
+            logger: logging.Logger = None
+    ):
+        self.client_ip: str = client_ip
+        self.client_port: int = client_port
+        self.package_processor: package_mains_processor.PackageMainsProcessor = package_processor
+        self.ssh_client: SSHRemote = ssh_client
+        self.logger: logging.Logger = logger
+
+    def get_process_name(self, print_kwargs: dict = None):
+        if print_kwargs is None:
+            print_kwargs = {}
+
+        # Checking if we're on localhost. If not, we'll execute SSH connection to get calling process name.
+        if self.client_ip not in socket_base.THIS_DEVICE_IP_LIST:
+            # Tried using paramiko SSH concurrently within threads, but with bigger loads it just breaks.
+            # So, better using it separately for each thread.
+
+            print_api(f"Initializing SSH connection to [{self.client_ip}]", **print_kwargs)
+
+            script_string: str = self.package_processor.read_script_file_to_string()
+
+            execution_output, execution_error = self.ssh_client.connect_get_client_commandline(port=self.client_port, script_string=script_string)
+        # Else, if we're on localhost, then execute the script directly without SSH.
+        else:
+            print_api(f"Executing LOCALHOST command to get the calling process.", **print_kwargs)
+            # execution_output, execution_error, rc = self.package_processor.execute_script_with_subprocess(arguments=[str(client_port)])
+            execution_output = self.package_processor.execute_script_file(
+                function_name=GET_LOCALHOST_FUNCTION_NAME, args=(self.client_port,))
+            execution_error = None
+
+        # This section is generic for both remote SSH and localhost executions of the script.
+        process_name = self.get_commandline_and_error(execution_output, execution_error, print_kwargs=print_kwargs)
+
+        return process_name
+
+    @staticmethod
+    def get_commandline_and_error(
+            execution_output,
+            execution_error,
+            print_kwargs: dict = None
+    ):
+        # If there was known error on localhost / known error on remote or any kind of error on remote, it was
+        # already logged, so we'll just put the error into 'process_name'.
+        if execution_error:
+            process_name = execution_error
+            print_api(
+                f"Error During Command Execution: {process_name}", error_type=True,
+                logger_method='error', **(print_kwargs or {}))
+        # If there wasn't any error of above types, then we can put the output from either local or remote script
+        # execution into 'process_name' and log it / output to console.
+        else:
+            # If the output that was returned is not empty.
+            if execution_output:
+                # Replacing '\r\n' escape lines with string, so that the line will not be escaped in logs.
+                if '\r\n' in execution_output:
+                    execution_output = execution_output.replace('\r\n', '')
+                elif '\n' in execution_output:
+                    execution_output = execution_output.replace('\n', '')
+
+                process_name = execution_output
+                print_api(f"Client Process Command Line: {process_name}", **(print_kwargs or {}))
+            # Else if the script output came back empty.
+            else:
+                process_name = ''
+                message = "Client Process Command Line came back empty after script execution."
+                print_api(message, error_type=True, logger_method='error', **(print_kwargs or {}))
+
+        return process_name

atomicshop/wrappers/socketw/receiver.py

@@ -1,26 +1,44 @@
 import logging
 import socket
 import ssl
-import time
 
 import select
 from pathlib import Path
 
 from ...print_api import print_api
+from ...basics import tracebacks
 from ..loggingw import loggingw
 
 
-def peek_first_bytes(client_socket, bytes_amount: int = 1) -> bytes:
+def peek_first_bytes(
+        client_socket,
+        bytes_amount: int = 1,
+        timeout: float = None
+) -> bytes:
     """
     Peek first byte from the socket without removing it from the buffer.
 
     :param client_socket: Socket object.
     :param bytes_amount: Amount of bytes to peek.
+    :param timeout: float, Timeout in seconds.
 
     :return: the first X bytes from the socket buffer.
     """
 
-    return client_socket.recv(bytes_amount, socket.MSG_PEEK)
+    error: bool = False
+    client_socket.settimeout(timeout)
+
+    try:
+        peek_a_bytes: bytes = client_socket.recv(bytes_amount, socket.MSG_PEEK)
+    except socket.timeout:
+        error = True
+    finally:
+        client_socket.settimeout(None)
+
+    if error:
+        raise TimeoutError
+
+    return peek_a_bytes
 
 
 def is_socket_ready_for_read(socket_instance, timeout: float = 0) -> bool:
@@ -93,14 +111,16 @@ class Receiver:
             # A signal to close connection will be empty bytes string: b''.
             received_data = self.ssl_socket.recv(self.buffer_size_receive)
         except ConnectionAbortedError:
-            error_message = "ConnectionAbortedError: * Connection was aborted by the other side..."
-            print_api(error_message, logger=self.logger, logger_method='critical', traceback_string=False)
+            error_message = "ConnectionAbortedError: Connection was aborted by local TCP stack (not remote close)..."
         except ConnectionResetError:
-            error_message = "ConnectionResetError: * Connection was forcibly closed by the other side..."
-            print_api(error_message, logger=self.logger, logger_method='critical', traceback_string=False)
+            error_message = "ConnectionResetError: Connection was forcibly closed by the other side..."
+        except TimeoutError as e:
+            if e.errno == 10060:
+                error_message = "TimeoutError: [WinError 10060] Socket receive operation timed out..."
+            else:
+                raise e
         except ssl.SSLError:
-            error_message = "ssl.SSLError: * Encountered SSL error on receive..."
-            print_api(error_message, logger=self.logger, logger_method='critical', traceback_string=True)
+            error_message = f"ssl.SSLError: Encountered SSL error on receive...\n{tracebacks.get_as_string()}"
 
         if received_data == b'':
             self.logger.info("Empty message received, socket closed on the other side.")

atomicshop/wrappers/socketw/sender.py

@@ -1,3 +1,4 @@
+import socket
 import ssl
 import logging
 from pathlib import Path
@@ -6,18 +7,18 @@ from ...print_api import print_api
 from ..loggingw import loggingw
 from ...basics import tracebacks
 
-from . import base
+from . import socket_base
 
 
 class Sender:
     def __init__(
             self,
-            ssl_socket: ssl.SSLSocket,
-            class_message: bytes,
+            ssl_socket: ssl.SSLSocket | socket.socket,
+            bytes_to_send: bytes,
             logger: logging.Logger = None
     ):
-        self.class_message: bytes = class_message
-        self.ssl_socket: ssl.SSLSocket = ssl_socket
+        self.bytes_to_send: bytes = bytes_to_send
+        self.ssl_socket: ssl.SSLSocket | socket.socket = ssl_socket
 
         if logger:
             # Create child logger for the provided logger with the module's name.
@@ -42,7 +43,7 @@ class Sender:
 
         try:
             # Getting byte length of current message
-            current_message_length = len(self.class_message)
+            current_message_length = len(self.bytes_to_send)
 
             self.logger.info(
                 f"Sending message to "
@@ -51,7 +52,7 @@ class Sender:
             # Looping through "socket.send()" method while total sent bytes are less than message length
             while total_sent_bytes < current_message_length:
                 # Sending the message and getting the amount of bytes sent
-                sent_bytes = self.ssl_socket.send(self.class_message[total_sent_bytes:])
+                sent_bytes = self.ssl_socket.send(self.bytes_to_send[total_sent_bytes:])
                 # If there were only "0" bytes sent, then connection on the other side was terminated
                 if sent_bytes == 0:
                     error_message = (
@@ -61,13 +62,13 @@ class Sender:
                     break
 
                 # Adding amount of currently sent bytes to the total amount of bytes sent
-                total_sent_bytes = total_sent_bytes + sent_bytes
+                total_sent_bytes += sent_bytes
                 self.logger.info(f"Sent {total_sent_bytes} bytes out of {current_message_length}")
 
             # At this point the sending loop finished successfully
             self.logger.info(f"Sent the message to destination.")
         except Exception as e:
-            source_tuple, destination_tuple = base.get_source_destination(self.ssl_socket)
+            source_tuple, destination_tuple = socket_base.get_source_destination(self.ssl_socket)
             source_address, source_port = source_tuple
             destination_address, destination_port = destination_tuple
             if self.ssl_socket.server_hostname:

atomicshop/wrappers/socketw/sni.py

@@ -47,7 +47,9 @@ class SNISetup:
             tls: bool,
             domain_from_dns_server: str = None,
             skip_extension_id_list: list = None,
-            exceptions_logger: loggingw.ExceptionCsvLogger = None
+            exceptions_logger: loggingw.ExceptionCsvLogger = None,
+            enable_sslkeylogfile_env_to_client_ssl_context: bool = False,
+            sslkeylog_file_path: str = None
     ):
         self.ca_certificate_name = ca_certificate_name
         self.ca_certificate_filepath = ca_certificate_filepath
@@ -74,6 +76,8 @@ class SNISetup:
         self.tls = tls
         self.exceptions_logger = exceptions_logger
         self.certificator_instance = None
+        self.enable_sslkeylogfile_env_to_client_ssl_context: bool = enable_sslkeylogfile_env_to_client_ssl_context
+        self.sslkeylog_file_path: str = sslkeylog_file_path
 
     def wrap_socket_with_ssl_context_server_sni_extended(
             self,
@@ -82,7 +86,9 @@ class SNISetup:
     ):
 
         # Create SSL Socket to wrap the raw socket with.
-        ssl_context: ssl.SSLContext = creator.create_ssl_context_for_server(True)
+        ssl_context: ssl.SSLContext = creator.create_ssl_context_for_server(
+            allow_legacy=True, enable_sslkeylogfile_env_to_client_ssl_context=self.enable_sslkeylogfile_env_to_client_ssl_context,
+            sslkeylog_file_path=self.sslkeylog_file_path)
 
         self.certificator_instance = certificator.Certificator(
             ca_certificate_name=self.ca_certificate_name,
@@ -101,7 +107,9 @@ class SNISetup:
             forwarding_dns_service_ipv4_list___only_for_localhost=(
                 self.forwarding_dns_service_ipv4_list___only_for_localhost),
             skip_extension_id_list=self.skip_extension_id_list,
-            tls=self.tls
+            tls=self.tls,
+            enable_sslkeylogfile_env_to_client_ssl_context=self.enable_sslkeylogfile_env_to_client_ssl_context,
+            sslkeylog_file_path=self.sslkeylog_file_path
         )
 
         # Add SNI callback function to the SSL context.
@@ -160,7 +168,10 @@ class SNISetup:
                 certificator_instance=self.certificator_instance,
                 domain_from_dns_server=self.domain_from_dns_server,
                 default_certificate_domain_list=self.default_certificate_domain_list,
-                exceptions_logger=self.exceptions_logger            )
+                exceptions_logger=self.exceptions_logger,
+                enable_sslkeylogfile_env_to_client_ssl_context=(
+                    self.certificator_instance.enable_sslkeylogfile_env_to_client_ssl_context),
+                sslkeylog_file_path=self.certificator_instance.sslkeylog_file_path)
             ssl_context.set_servername_callback(
                 sni_handler_instance.setup_sni_callback(print_kwargs=print_kwargs))
 
@@ -178,7 +189,9 @@ class SNIHandler:
             certificator_instance: certificator.Certificator,
             domain_from_dns_server: str,
             default_certificate_domain_list: list,
-            exceptions_logger: loggingw.ExceptionCsvLogger
+            exceptions_logger: loggingw.ExceptionCsvLogger,
+            enable_sslkeylogfile_env_to_client_ssl_context: bool,
+            sslkeylog_file_path: str
     ):
         self.sni_use_default_callback_function_extended = sni_use_default_callback_function_extended
         self.sni_add_new_domains_to_default_server_certificate = sni_add_new_domains_to_default_server_certificate
@@ -187,6 +200,8 @@ class SNIHandler:
         self.domain_from_dns_server: str = domain_from_dns_server
         self.default_certificate_domain_list = default_certificate_domain_list
         self.exceptions_logger = exceptions_logger
+        self.enable_sslkeylogfile_env_to_client_ssl_context: bool = enable_sslkeylogfile_env_to_client_ssl_context
+        self.sslkeylog_file_path: str = sslkeylog_file_path
 
         # noinspection PyTypeChecker
         self.sni_received_parameters: SNIReceivedParameters = None
@@ -325,7 +340,9 @@ class SNIHandler:
                     creator.create_server_ssl_context___load_certificate_and_key(
                         default_server_certificate_path,
                         None,
-                        inherit_from=self.sni_received_parameters.ssl_socket.context
+                        inherit_from=self.sni_received_parameters.ssl_socket.context,
+                        enable_sslkeylogfile_env_to_client_ssl_context=self.enable_sslkeylogfile_env_to_client_ssl_context,
+                        sslkeylog_file_path=self.sslkeylog_file_path
                     )
                 )
             else:

atomicshop/wrappers/socketw/{base.py → socket_base.py}

@@ -1,4 +1,5 @@
 import socket
+import time
 
 
 LOCALHOST_IPV4: str = '127.0.0.1'
@@ -99,4 +100,35 @@ def get_host_name_from_ip_address(ip_address: str) -> str:
     host_name, alias_list, ipaddr_list = socket.gethostbyaddr(ip_address)
     _ = alias_list, ipaddr_list
 
-    return host_name
+    return host_name
+
+
+def wait_for_ip_bindable(
+    ip: str,
+    port: int = 0,
+    timeout: float = 15.0,
+    interval: float = 0.5,
+) -> None:
+    """
+    Wait until a single IP is bindable (or timeout).
+
+    Raises TimeoutError if the IP cannot be bound within 'timeout' seconds.
+    """
+    deadline = time.time() + timeout
+    last_err: OSError | None = None
+
+    while time.time() < deadline:
+        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        try:
+            s.bind((ip, port))
+            s.close()
+            return  # success
+        except OSError as e:
+            last_err = e
+            s.close()
+            time.sleep(interval)
+
+    raise TimeoutError(
+        f"IP {ip} not bindable within {timeout} seconds; "
+        f"last error: {last_err}"
+    )

atomicshop/wrappers/socketw/socket_client.py

@@ -218,7 +218,6 @@ class SocketClient:
         self.socket_instance = None
         self.logger.info(f"Closed socket to service server [{self.service_name}:{self.service_port}]")
 
-    # noinspection PyUnusedLocal
     def send_receive_to_service(
             self,
             request_bytes: Union[bytearray, bytes],
@@ -231,9 +230,8 @@ class SocketClient:
         :param skip_send: If True, the data will not be sent to the service server. After the connection is established,
             the function will wait for the response only.
         """
-        # Define variables
-        function_service_data = None
-        error_message = None
+
+        origin_data: bytes | None = None
 
         service_socket, error_message = self.service_connection()
         # If connection to service server wasn't successful
@@ -257,7 +255,7 @@ class SocketClient:
             if not skip_send:
                 # Send the data received from the client to the service over socket
                 error_on_send = Sender(
-                    ssl_socket=self.socket_instance, class_message=request_bytes, logger=self.logger).send()
+                    ssl_socket=self.socket_instance, bytes_to_send=request_bytes, logger=self.logger).send()
 
                 # If the socket disconnected on data send
                 if error_on_send:
@@ -268,17 +266,17 @@ class SocketClient:
 
             # Else if send was successful
             if not error_on_send:
-                function_service_data = Receiver(
+                origin_data, is_socket_closed, error_message = Receiver(
                     ssl_socket=self.socket_instance, logger=self.logger).receive()
 
                 # If data received is empty meaning the socket was closed on the other side
-                if not function_service_data:
+                if not origin_data:
                     error_message = "Service server closed the connection on receive"
 
                     # We'll close the socket and nullify the object
                     self.close_socket()
 
-        return function_service_data, error_message, self.connection_ip, self.socket_instance
+        return origin_data, error_message, self.connection_ip, self.socket_instance
 
     def send_receive_message_list_with_interval(
             self, requests_bytes_list: list, intervals_list: list, intervals_defaults: int, cycles: int = 1):