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

atomicshop/networks.py

@@ -1,18 +1,23 @@
 import socket
 import time
-from typing import Union
+from typing import Union, Literal
 import os
 import psutil
 import ctypes
+from logging import Logger
+import subprocess
 
 from icmplib import ping
 from icmplib.models import Host
 from win32com.client import CDispatch
 
-from .wrappers.pywin32w.wmis import win32networkadapter, win32_networkadapterconfiguration, wmi_helpers, msft_netipaddress
+from .print_api import print_api
+from .wrappers.pywin32w.wmis import win32networkadapter, win32_networkadapterconfiguration, wmi_helpers
 from .wrappers.ctyping import setup_device
 from .wrappers.winregw import winreg_network
 from .wrappers.psutilw import psutil_networks
+from .wrappers import powershell_networking, netshw
+from .wrappers.socketw import socket_base
 
 
 MICROSOFT_LOOPBACK_DEVICE_NAME: str = 'Microsoft KM-TEST Loopback Adapter'
@@ -61,6 +66,7 @@ def is_ip_in_use_arp(
     def _send_arp(ip: str) -> str | None:
         """Return MAC string like 'aa:bb:cc:dd:ee:ff' if IP is claimed on the LAN, else None."""
         # inet_addr returns DWORD in network byte order
+        # noinspection PyUnresolvedReferences
         dest_ip = ws2_32.inet_addr(ip.encode('ascii'))
         if dest_ip == 0xFFFFFFFF:  # INVALID
             raise ValueError(f"Bad IPv4 address: {ip}")
@@ -68,6 +74,7 @@ def is_ip_in_use_arp(
         mac_buf = ctypes.c_uint64(0)  # storage for up to 8 bytes
         mac_len = ctypes.c_ulong(ctypes.sizeof(mac_buf))  # in/out len
         # SrcIP=0 lets Windows pick the right interface
+        # noinspection PyUnresolvedReferences
         rc = iphlpapi.SendARP(dest_ip, 0, ctypes.byref(mac_buf), ctypes.byref(mac_len))
         if rc != 0:  # Non-zero means no ARP reply / not on-link / other error
             return None
@@ -105,32 +112,34 @@ def get_default_internet_ipv4(target: str = "8.8.8.8") -> str:
         return s.getsockname()[0]  # local address of that route
 
 
-def get_hostname() -> str:
+def get_default_interface_name() -> str:
+    default_connection_name_dict: dict = psutil_networks.get_default_connection_name()
+    if not default_connection_name_dict:
+        return ""
+    # Get the first key from the dictionary.
+    connection_name: str = list(default_connection_name_dict.keys())[0]
+    return connection_name
+
+
+def list_network_interfaces() -> list[str]:
     """
-    Get the default network interface name that is being used for internet.
-    :return: string, default network interface name.
+    List all network interfaces on the system.
+    :return: list of strings, network interface names.
     """
 
-    return socket.gethostname()
+    return psutil_networks.list_network_interfaces()
 
 
-def get_default_internet_interface_name() -> str | None:
+def get_hostname() -> str:
     """
     Get the default network interface name that is being used for internet.
     :return: string, default network interface name.
     """
 
-    interface_dict: dict = psutil_networks.get_default_connection_name()
-    if not interface_dict:
-        result = None
-    else:
-        # Get the first interface name from the dictionary.
-        result = next(iter(interface_dict.keys()), None)
-
-    return result
+    return socket.gethostname()
 
 
-def get_interface_ips(
+def get_interface_ips_psutil(
         interface_name: str = None,
         ipv4: bool = True,
         ipv6: bool = True,
@@ -144,7 +153,7 @@ def get_interface_ips(
 
     if default_interface:
         # Get the default interface name.
-        interface_name = get_default_internet_interface_name()
+        interface_name = get_default_interface_name()
 
     physical_ip_types: list[str] = []
     if ipv4:
@@ -169,6 +178,75 @@ def get_interface_ips(
     return ips
 
 
+def get_host_ips_psutil(
+        localhost: bool = True,
+        ipv4: bool = True,
+        ipv6: bool = True
+) -> list[str]:
+    """
+    Yield (ifname, family, ip) for all UP interfaces that have bindable addresses.
+
+    Args:
+        localhost: include 127.0.0.0/8 and ::1 if True.
+        ipv4: include IPv4 addresses if True.
+        ipv6: include IPv6 addresses if True.
+    """
+    stats = psutil.net_if_stats()
+
+    ip_list: list[str] = []
+    for ifname, addrs in psutil.net_if_addrs().items():
+        st = stats.get(ifname)
+        if not st or not st.isup:
+            continue  # interface is down or unknown
+
+        for a in addrs:
+            fam = a.family
+            if fam not in (socket.AF_INET, socket.AF_INET6):
+                continue
+
+            # Family filters
+            if fam == socket.AF_INET and not ipv4:
+                continue
+            if fam == socket.AF_INET6 and not ipv6:
+                continue
+
+            ip = a.address
+
+            # Skip placeholders/wildcards
+            if fam == socket.AF_INET and ip == "0.0.0.0":
+                continue
+            if fam == socket.AF_INET6 and ip in ("::",):
+                continue
+
+            # Optionally skip loopback
+            if not localhost:
+                if fam == socket.AF_INET and ip.startswith("127."):
+                    continue
+                if fam == socket.AF_INET6 and (ip == "::1" or ip.startswith("::1%")):
+                    continue
+
+            # yield ifname, fam, ip
+            ip_list.append(ip)
+
+    return ip_list
+
+
+def get_interface_ips_powershell(
+        interface_name: str = None,
+        ip_type: Literal["virtual", "dynamic", "all"] = "virtual"
+) -> list[str]:
+    """
+    Get the IP addresses of a network interface using PowerShell.
+
+    :param interface_name: string, name of the network interface.
+        If None, all interfaces will be queried.
+    :param ip_type: string, type of IP addresses to retrieve.
+    :return: list of strings, IP addresses of the network interface.
+    """
+
+    return powershell_networking.get_interface_ips(interface_name=interface_name, ip_type=ip_type)
+
+
 def get_microsoft_loopback_device_network_configuration(
         wmi_instance: CDispatch = None,
         timeout: int = 1,
@@ -303,17 +381,14 @@ def change_interface_metric_restart_device(
 
 
 def get_wmi_network_adapter_configuration(
-        use_default_interface: bool = False,
-        connection_name: str = None,
+        interface_name: str = None,
         mac_address: str = None,
         wmi_instance: CDispatch = None,
         get_info_from_network_config: bool = True
 ) -> tuple:
     """
     Get the WMI network configuration for a network adapter.
-    :param use_default_interface: bool, if True, the default network interface will be used.
-        This is the adapter that your internet is being used from.
-    :param connection_name: string, adapter name as shown in the network settings.
+    :param interface_name: string, adapter name as shown in the network settings.
     :param mac_address: string, MAC address of the adapter. Format: '00:00:00:00:00:00'.
     :param wmi_instance: WMI instance. You can get it from:
         wrappers.pywin32s.wmis.wmi_helpers.get_wmi_instance()
@@ -324,14 +399,14 @@ def get_wmi_network_adapter_configuration(
     """
 
     wmi_network_config, wmi_network_adapter = win32_networkadapterconfiguration.get_adapter_network_configuration(
-        use_default_interface=use_default_interface,
-        connection_name=connection_name,
+        interface_name=interface_name,
         mac_address=mac_address,
         wmi_instance=wmi_instance
     )
 
     if get_info_from_network_config:
         adapter_info: dict = win32_networkadapterconfiguration.get_info_from_network_config(wmi_network_config)
+        adapter_info['name'] = wmi_network_adapter.NetConnectionID
     else:
         adapter_info: dict = {}
 
@@ -415,7 +490,7 @@ def generate_unused_ipv4_addresses_from_ip(
     return generated_ips, masks_for_ips
 
 
-def set_dynamic_ip_for_adapter(
+def set_dynamic_ip_for_adapter_wmi(
         network_config: CDispatch,
         reset_dns: bool = True,
         reset_wins: bool = True
@@ -431,7 +506,7 @@ def set_dynamic_ip_for_adapter(
         nic_cfg=network_config, reset_dns=reset_dns, reset_wins=reset_wins)
 
 
-def set_static_ip_for_adapter(
+def set_static_ip_for_adapter_wmi(
         network_config: CDispatch,
         ips: list[str],
         masks: list[str],
@@ -459,19 +534,19 @@ def set_static_ip_for_adapter(
     )
 
 
-def add_virtual_ips_to_default_adapter_by_current_setting(
+def add_virtual_ips_to_network_interface(
+        interface_name: str,
         number_of_ips: int = 0,
         virtual_ipv4s_to_add: list[str] = None,
         virtual_ipv4_masks_to_add: list[str] = None,
         set_virtual_ips_skip_as_source: bool = True,
-        gateways: list[str] | None = None,
-        dns_gateways: list[str] | None = None,
-        availability_wait_seconds: int = 15,
         simulate_only: bool = False,
         locator: CDispatch = None,
         wait_until_applied: bool = True,
-        wait_until_applied_seconds: int = 15
-) -> tuple[list[str], list[str], list[str], list[str]]:
+        wait_until_applied_seconds: int = 15,
+        verbose: bool = False,
+        logger: Logger = None,
+) -> tuple[list[str], list[str]] | None:
     """
     Add virtual IP addresses to the default network adapter.
     The adapter will set to static IP and DNS gateway, instead of dynamic DHCP.
@@ -482,6 +557,8 @@ def add_virtual_ips_to_default_adapter_by_current_setting(
     While generating the IPs, the function will skip the already existing IPs in the adapter, like default gateway
     and DNS servers.
 
+    :param interface_name: string, adapter name as shown in the network settings.
+
     :param number_of_ips: int, number of IPs to generate in addition to the IPv4s that already exist in the adapter.
         Or you add the IPs and masks to the adapter with the parameters virtual_ipv4s_to_add and virtual_ipv4_masks_to_add.
 
@@ -491,15 +568,11 @@ def add_virtual_ips_to_default_adapter_by_current_setting(
 
     :param set_virtual_ips_skip_as_source: bool, if True, the SkipAsSource flag will be set for the virtual IPs.
         This is needed to avoid the endless accept() loop.
-    :param gateways: list of strings, default IPv4 gateways to assign.
-        None: The already existing gateways in the adapter will be used.
-        []: No gateways will be assigned.
-    :param dns_gateways: list of strings, IPv4 DNS servers to assign.
-        None: The already existing DNS servers in the adapter will be used.
-        []: No DNS servers will be assigned.
-    :param availability_wait_seconds: int, seconds to wait for the adapter to be available after setting the IP address.
-    :param simulate_only: bool, if True, the function will only prepare the ip addresses and return them without changing anything.
-    :param locator: CDispatch, WMI locator object. If not specified, it will be created.
+
+    :param simulate_only: bool, if True, the function will only simulate the addition of the IP addresses.
+        No changes will be made to the system.
+    :param locator: CDispatch, WMI locator object. You can get it from:
+        wrappers.pywin32s.wmis.wmi_helpers.get_wmi_instance()
 
     :param wait_until_applied: bool, if True, the function will wait until the IP addresses are applied.
         By default, while WMI command is executed, there is no indication if the addresses were finished applying or not.
@@ -509,7 +582,10 @@ def add_virtual_ips_to_default_adapter_by_current_setting(
         after setting the IP addresses. This is the time to wait for the IP addresses to be
         applied after setting them. If the IP addresses are not applied in this time, a TimeoutError will be raised.
 
-    :return: tuple of lists, (current_ipv4s, current_ipv4_masks, ips_to_assign, masks_to_assign)
+    :param verbose: bool, if True, the function will print verbose output.
+    :param logger: Logger, if provided, the function will log messages to this logger.
+
+    :return: tuple of lists, (ips_to_assign, masks_to_assign)
     """
 
     if virtual_ipv4s_to_add and not virtual_ipv4_masks_to_add:
@@ -526,24 +602,19 @@ def add_virtual_ips_to_default_adapter_by_current_setting(
     # Connect to WMi.
     wmi_civ2_instance, locator = wmi_helpers.get_wmi_instance(locator=locator)
 
-    # initial_default_ipv4: str = socket.gethostbyname(socket.gethostname())
-
-    # Get the default network adapter configuration.
-    default_network_adapter_config, default_network_adapter, default_adapter_info = get_wmi_network_adapter_configuration(
-        use_default_interface=True, wmi_instance=wmi_civ2_instance, get_info_from_network_config=True)
-
-    current_ipv4s: list[str] = default_adapter_info['ipv4s']
-    current_ipv4_masks: list[str] = default_adapter_info['ipv4_subnet_masks']
+    # Get the network adapter configuration.
+    network_adapter_config, network_adapter, adapter_info = get_wmi_network_adapter_configuration(
+        interface_name=interface_name, wmi_instance=wmi_civ2_instance, get_info_from_network_config=True)
 
-    # print(f"Current IPs: {current_ipv4s}")
-    # current_ips_count: int = len(current_ipv4s)
+    current_ipv4s: list[str] = adapter_info['ipv4s']
+    current_ipv4_masks: list[str] = adapter_info['ipv4_subnet_masks']
 
     if number_of_ips > 0:
         ips_to_assign, masks_to_assign = generate_unused_ipv4_addresses_from_ip(
             ip_address=current_ipv4s[0],
             mask=current_ipv4_masks[0],
             number_of_ips=number_of_ips,
-            skip_ips=current_ipv4s + default_adapter_info['default_gateways'] + default_adapter_info['dns_gateways']
+            skip_ips=current_ipv4s + adapter_info['default_gateways'] + adapter_info['dns_gateways']
         )
     elif virtual_ipv4s_to_add and virtual_ipv4_masks_to_add:
         ips_to_assign = virtual_ipv4s_to_add
@@ -553,51 +624,48 @@ def add_virtual_ips_to_default_adapter_by_current_setting(
         masks_to_assign = []
 
     if not simulate_only:
-        # Final list of IPs to assign.
-        ips: list[str] = current_ipv4s + ips_to_assign
-        masks: list[str] = current_ipv4_masks + masks_to_assign
-
-        # ---------- IP assignment --------------------------------------------
-        if ips != current_ipv4s:
-            # print("[+] Setting static IPv4 addresses …")
-            if gateways is None:
-                gateways = default_adapter_info['default_gateways']
-
-            if dns_gateways is None:
-                dns_gateways = default_adapter_info['dns_gateways']
-
-            # We will get the default IP address of the machine.
-            default_ip_address: str = get_default_internet_ipv4()
-            # So we can make it the first IP in the list, but first remove it from the list.
-            _ = ips.pop(ips.index(default_ip_address))
-            # At this point we will copy the list of IPs that we will set the SkipAsSource flag for.
-            ips_for_skip_as_source = ips.copy()
-            # Add it back to the beginning of the list.
-            ips.insert(0, default_ip_address)
-
-            win32_networkadapterconfiguration.set_static_ips(
-                default_network_adapter_config, ips=ips, masks=masks,
-                gateways=gateways, dns_gateways=dns_gateways,
-                availability_wait_seconds=availability_wait_seconds)
-
-            # If there were already virtual IPs assigned to the adapter and already were set SkipAsSource,
-            # we need to set SkipAsSource for them once again as well as for the new IPs.
-            if set_virtual_ips_skip_as_source:
-                wmi_standard_cimv2_instance, _ = wmi_helpers.get_wmi_instance(
-                    namespace='root\\StandardCimv2', wmi_instance=wmi_civ2_instance, locator=locator)
-                msft_netipaddress.set_skip_as_source(ips_for_skip_as_source, enable=True, wmi_instance=wmi_standard_cimv2_instance)
-        else:
-            # print("[!] No new IPs to assign.")
-            pass
+        # Enable DHCP + static IP coexistence on the interface.
+        process_complete: subprocess.CompletedProcess = netshw.enable_dhcp_static_coexistence(interface_name=interface_name)
+        if process_complete.returncode != 0:
+            print_api(f"[!] Failed to enable DHCP + static IP coexistence on interface {interface_name}.\n"
+                      f"    stdout: {process_complete.stdout}\n"
+                      f"    stderr: {process_complete.stderr}", color="red", logger=logger)
+            return None
+
+        for ip, mask in zip(ips_to_assign, masks_to_assign):
+            if verbose:
+                print_api(f"[+] Adding virtual IP {ip} with mask {mask} to interface {interface_name}.", logger=logger)
+
+            netshw.add_virtual_ip(
+                interface_name=interface_name,
+                ip=ip,
+                mask=mask,
+                skip_as_source=set_virtual_ips_skip_as_source
+            )
 
         if wait_until_applied:
             # Wait until the IP addresses are applied.
             for _ in range(wait_until_applied_seconds):
-                current_ips = get_interface_ips(ipv4=True, ipv6=False, localhost=False, default_interface=True)
-                if set(current_ips) == set(ips):
+                current_virtual_ips = get_interface_ips_powershell(interface_name=interface_name, ip_type="virtual")
+                if set(current_virtual_ips) == set(ips_to_assign):
                     break
                 time.sleep(1)
             else:
                 raise TimeoutError("Timeout while waiting for the IP addresses to be applied.")
 
-    return current_ipv4s, current_ipv4_masks, ips_to_assign, masks_to_assign
+    return ips_to_assign, masks_to_assign
+
+
+def wait_for_ip_bindable_socket(
+    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.
+    """
+
+    socket_base.wait_for_ip_bindable(ip=ip, port=port, timeout=timeout, interval=interval)

atomicshop/package_mains_processor.py

@@ -0,0 +1,84 @@
+"""Loading resources using stdlib importlib.resources APIs (Python 3.7+)
+https://docs.python.org/3/library/importlib.html#module-importlib.resources"""
+import importlib.resources
+from contextlib import redirect_stdout
+import io
+import subprocess
+import sys
+from typing import Callable
+
+
+class PackageMainsProcessor:
+    def __init__(
+            self,
+            script_file_stem: str = None
+    ):
+        self.script_file_stem: str = script_file_stem
+        self.resources_directory_name: str = 'a_mains'
+
+    def get_resource_path(self) -> str:
+        return f'{__package__}.{self.resources_directory_name}'
+
+    def read_script_file_to_string(self) -> str:
+        script_string = importlib.resources.read_text(self.get_resource_path(), f'{self.script_file_stem}.py')
+
+        return script_string
+
+    def execute_script_file(
+            self,
+            function_name: str = 'main',
+            args: tuple = None,
+            kwargs: dict = None,
+            get_printed_output: bool = False
+    ) -> str:
+        """
+        Execute a script file from the package resources and get result as string.
+
+        :param function_name: Name of the function to call within the script.
+        :param args: Tuple of positional arguments to pass to the function.
+        :param kwargs: Dictionary of keyword arguments to pass to the function.
+        :param get_printed_output: If True, captures and returns printed output instead of return value.
+
+        :return: Output of the script execution as a string.
+        """
+
+        if not args:
+            args = ()
+        if not kwargs:
+            kwargs = {}
+
+        module_name = f"{self.get_resource_path()}.{self.script_file_stem}"  # script_file_name WITHOUT ".py"
+
+        module = importlib.import_module(module_name)
+        callable_function: Callable = getattr(module, function_name)
+
+        if get_printed_output:
+            with io.StringIO() as buffer, redirect_stdout(buffer):
+                callable_function(*args, **kwargs)
+                result = buffer.getvalue()
+        else:
+            result = callable_function(*args, **kwargs)
+
+        return result
+
+    def execute_script_with_subprocess(
+            self,
+            arguments: list = None
+    ) -> tuple[str, str, int]:
+        """
+        Execute a script file from the package resources using subprocess and get result as string.
+        :param arguments: Dictionary of arguments to pass to the script.
+            Example: ['--port', '8080', '-v']
+        :return: Tuple containing (stdout, stderr, returncode).
+        """
+
+        # script_file_name WITHOUT ".py"
+        module_name = f"{self.get_resource_path()}.{self.script_file_stem}"
+
+        command = [sys.executable, "-m", module_name]
+        if arguments:
+            command.extend(arguments)
+
+        result = subprocess.run(command, capture_output=True, text=True)
+
+        return result.stdout, result.stderr, result.returncode

atomicshop/permissions/ubuntu_permissions.py

@@ -2,6 +2,7 @@ import os
 import stat
 import contextlib
 import subprocess
+import getpass
 
 # Import pwd only on linux.
 if os.name == 'posix':
@@ -20,6 +21,52 @@ def get_sudo_executer_username() -> str:
         return ''
 
 
+def detect_current_user(
+        optional_env_user_var: str = 'CUSTOM_SCRIPTED_USER'
+) -> str:
+    """
+    Try to robustly determine the 'real' installing user.
+
+    Priority:
+      1. FDB_INSTALL_USER env var (explicit override).
+      2. If running as root with sudo: use SUDO_USER.
+      3. Otherwise: use effective uid.
+      4. Fallbacks: getpass.getuser() / $USER.
+
+    :param optional_env_user_var: str, name of the environment variable that can override the user detection.
+    :return: str, username.
+    """
+
+    # 1. Explicit override for weird environments (CI, containers, etc.)
+    env_user = os.getenv(optional_env_user_var)
+    if env_user:
+        return env_user
+
+    # 2. If we are root, prefer the sudo caller if any
+    try:
+        euid = os.geteuid()
+    except AttributeError:  # non-POSIX, very unlikely here
+        euid = None
+
+    if euid == 0:
+        sudo_user = os.environ.get("SUDO_USER")
+        if sudo_user:
+            return sudo_user
+
+    # 3. Normal case: effective uid -> username
+    if euid is not None:
+        try:
+            return pwd.getpwuid(euid).pw_name
+        except Exception:
+            pass
+
+    # 4. Fallbacks that don’t depend on utmp/tty
+    try:
+        return getpass.getuser()
+    except Exception:
+        return os.environ.get("USER", "unknown")
+
+
 def set_executable(file_path: str):
     """
     Function sets the executable permission on a file.

atomicshop/print_api.py

@@ -1,13 +1,14 @@
 import sys
 import logging
+from typing import Any
 
 from .basics import ansi_escape_codes
 from .basics import tracebacks
 
 
 def print_api(
-        message: any,
-        color: any = None,
+        message: Any,
+        color: Any = None,
         print_end: str = '\n',
         rtl: bool = False,
         error_type: bool = False,
@@ -73,7 +74,6 @@ def print_api(
 
     # Inner functions already get all the local variables of the main function.
     def print_or_logger():
-        from .wrappers.loggingw import loggingw
         nonlocal message
         nonlocal color
         nonlocal traceback_string
@@ -83,8 +83,6 @@ def print_api(
 
         # If 'rtl' is set to 'True', we'll add Right-To-Left text conversion to 'message'.
         if rtl:
-            # Lazy importing of 'bidi' library. It's not a problem since python caches the library after first import.
-            # Off-course, it will be imported from the cache each time this section is triggered.
             # pip install python-bidi
             from bidi.algorithm import get_display
             message = get_display(message)

atomicshop/process.py

@@ -316,14 +316,21 @@ def kill_process_by_filename_pattern(pattern: str):
         processes.kill_process_by_pid(running_processes[0]['pid'])
 
 
-def run_powershell_command(command):
+def run_powershell_command(
+        command: str
+):
     try:
         result = subprocess.run(["powershell", "-Command", command], capture_output=True, text=True, check=True)
-        print_api(result.stdout)
+        if result.stdout:
+            print_api(result.stdout)
+        if result.stderr:  # PS can write warnings to stderr even on success
+            print_api(result.stderr, color='yellow')
         return result.stdout
     except subprocess.CalledProcessError as e:
-        print_api(f"An error occurred: {e}", color='red', error_type=True)
-        return e
+        # e.stderr and e.stdout are populated because capture_output=True
+        msg = (e.stderr or e.stdout or f"PowerShell exited with code {e.returncode}")
+        print_api(msg, color='red', error_type=True)
+        return msg
 
 
 """