lanscape 1.3.5a1__py3-none-any.whl → 1.3.6a1__py3-none-any.whl

lanscape/libraries/net_tools.py

@@ -1,14 +1,14 @@
+"""Network tools for scanning and managing devices on a network."""
+
 import logging
 import ipaddress
 import traceback
 import subprocess
-from time import sleep
 from typing import List, Dict
 import socket
 import struct
 import re
 import psutil
-from icmplib import ping
 
 from scapy.sendrecv import srp
 from scapy.layers.l2 import ARP, Ether
@@ -18,116 +18,13 @@ from lanscape.libraries.service_scan import scan_service
 from lanscape.libraries.mac_lookup import MacLookup, get_macs
 from lanscape.libraries.ip_parser import get_address_count, MAX_IPS_ALLOWED
 from lanscape.libraries.errors import DeviceError
-from lanscape.libraries.decorators import job_tracker, JobStatsMixin, timeout_enforcer
-from lanscape.libraries.scan_config import ScanType, PingConfig, ArpConfig
+from lanscape.libraries.decorators import job_tracker
 
 log = logging.getLogger('NetTools')
+mac_lookup = MacLookup()
 
 
-class IPAlive(JobStatsMixin):
-    """Class to check if a device is alive using ARP and/or ping scans."""
-    caught_errors: List[DeviceError] = []
-    _icmp_alive: bool = False
-    _arp_alive: bool = False
-    
-
-    @job_tracker
-    def is_alive(
-        self,
-        ip: str,
-        scan_type: ScanType = ScanType.BOTH,
-        arp_config: ArpConfig = ArpConfig(),
-        ping_config: PingConfig = PingConfig()
-    ) -> bool:
-        """
-        Check if a device is alive by performing ARP and/or ping scans.
-        """
-        if scan_type == ScanType.ARP:
-            return self._arp_lookup(ip, arp_config)
-        if scan_type == ScanType.PING:
-            return self._ping_lookup(ip, ping_config)
-        return self._ping_lookup(ip, ping_config) or self._arp_lookup(ip, arp_config)
-
-    @job_tracker
-    def _arp_lookup(
-        self, ip: str,
-        cfg: ArpConfig = ArpConfig()
-    ) -> bool:
-        """Perform an ARP lookup to check if the device is alive."""
-        enforcer_timeout = cfg.timeout * 1.3
-
-        @timeout_enforcer(enforcer_timeout, raise_on_timeout=True)
-        def do_arp_lookup():
-            arp_request = ARP(pdst=ip)
-            broadcast = Ether(dst="ff:ff:ff:ff:ff:ff")
-            packet = broadcast / arp_request
-
-            answered, _ = srp(packet, timeout=cfg.timeout, verbose=False)
-            self._arp_alive = any(resp.psrc == ip for _, resp in answered)
-            return self._arp_alive
-
-        try:
-            for _ in range(cfg.attempts):
-                if do_arp_lookup():
-                    return True
-        except Exception as e:
-            self.caught_errors.append(DeviceError(e))
-        return False
-
-    @job_tracker
-    def _ping_lookup(
-        self, ip: str,
-        cfg: PingConfig = PingConfig()
-    ) -> bool:
-        """Perform a ping lookup to check if the device is alive using icmplib."""
-        enforcer_timeout = cfg.timeout * cfg.ping_count * 1.3
-
-        @timeout_enforcer(enforcer_timeout, raise_on_timeout=False)
-        def do_icmp_ping():
-            try:
-                result = ping(
-                    ip,
-                    count=cfg.ping_count,
-                    interval=cfg.retry_delay,
-                    timeout=cfg.timeout,
-                    privileged=psutil.WINDOWS  # Use privileged mode on Windows
-                )
-                return result.is_alive
-            except Exception as e:
-                self.caught_errors.append(DeviceError(e))
-                # Fallback to system ping command
-                try:
-                    if psutil.WINDOWS:
-                        cmd = [
-                            "ping", "-n", str(cfg.ping_count), 
-                            "-w", str(int(cfg.timeout * 1000)), ip
-                        ]
-                    else:
-                        cmd = ["ping", "-c", str(cfg.ping_count), "-W", str(cfg.timeout), ip]
-
-                    result = subprocess.run(
-                        cmd, stdout=subprocess.PIPE, 
-                        stderr=subprocess.PIPE, 
-                        text=True, check=False
-                    )
-                    return result.returncode == 0
-                except subprocess.CalledProcessError as fallback_error:
-                    self.caught_errors.append(DeviceError(fallback_error))
-                    return False
-
-        try:
-            for _ in range(cfg.attempts):
-                if do_icmp_ping():
-                    self._icmp_alive = True
-                    return True
-                sleep(cfg.retry_delay)
-        except Exception as e:
-            self.caught_errors.append(DeviceError(e))
-        self._icmp_alive = False
-        return False
-
-
-class Device(IPAlive):
+class Device:
     """Represents a network device with metadata and scanning capabilities."""
 
     def __init__(self, ip: str):
@@ -142,13 +39,12 @@ class Device(IPAlive):
         self.services: Dict[str, List[int]] = {}
         self.caught_errors: List[DeviceError] = []
         self.log = logging.getLogger('Device')
-        self._mac_lookup = MacLookup()
 
     def get_metadata(self):
         """Retrieve metadata such as hostname and MAC addresses."""
         if self.alive:
             self.hostname = self._get_hostname()
-            self.macs = self._get_mac_addresses()
+            self._get_mac_addresses()
 
     def dict(self) -> dict:
         """Convert the device object to a dictionary."""
@@ -189,9 +85,12 @@ class Device(IPAlive):
     @job_tracker
     def _get_mac_addresses(self):
         """Get the possible MAC addresses of a network device given its IP address."""
-        macs = get_macs(self.ip)
-        mac_selector.import_macs(macs)
-        return macs
+        # job may already be done depending on
+        # the strat from isalive
+        if not self.macs:
+            self.macs = get_macs(self.ip)
+        mac_selector.import_macs(self.macs)
+        return self.macs
 
     @job_tracker
     def _get_hostname(self):
@@ -206,7 +105,7 @@ class Device(IPAlive):
     @job_tracker
     def _get_manufacturer(self, mac_addr=None):
         """Get the manufacturer of a network device given its MAC address."""
-        return self._mac_lookup.lookup_vendor(mac_addr) if mac_addr else None
+        return mac_lookup.lookup_vendor(mac_addr) if mac_addr else None
 
 
 class MacSelector:
@@ -245,6 +144,7 @@ class MacSelector:
             self.macs[mac] = self.macs.get(mac, 0) + 1
 
     def clear(self):
+        """Clear the stored MAC addresses."""
         self.macs = {}
 
 
@@ -281,15 +181,15 @@ def get_ip_address(interface: str):
     # Call the appropriate function based on the platform
     if psutil.WINDOWS:
         return windows()
-    else:  # Linux, macOS, and other Unix-like systems
-        return unix_like()
+
+    # Linux, macOS, and other Unix-like systems
+    return unix_like()
 
 
 def get_netmask(interface: str):
     """
     Get the netmask of a network interface.
     """
-
     def unix_like():  # Combined Linux and macOS
         try:
             # pylint: disable=import-outside-toplevel, import-error
@@ -316,8 +216,9 @@ def get_netmask(interface: str):
 
     if psutil.WINDOWS:
         return windows()
-    else:  # Linux, macOS, and other Unix-like systems
-        return unix_like()
+
+    # Linux, macOS, and other Unix-like systems
+    return unix_like()
 
 
 def get_cidr_from_netmask(netmask: str):
@@ -329,71 +230,122 @@ def get_cidr_from_netmask(netmask: str):
     return str(len(binary_str.rstrip('0')))
 
 
+def _find_interface_by_default_gateway_windows():
+    """Find the network interface with the default gateway on Windows."""
+    try:
+        output = subprocess.check_output(
+            "route print 0.0.0.0", shell=True, text=True)
+        return _parse_windows_route_output(output)
+    except Exception as e:
+        log.debug(f"Error finding Windows interface by gateway: {e}")
+    return None
+
+
+def _parse_windows_route_output(output):
+    """Parse the output of Windows route command to extract interface index."""
+    lines = output.strip().split('\n')
+    interface_idx = None
+
+    # First find the interface index from the routing table
+    for line in lines:
+        if '0.0.0.0' in line and 'Gateway' not in line:  # Skip header
+            parts = [p for p in line.split() if p]
+            if len(parts) >= 4:
+                interface_idx = parts[3]
+                break
+
+    # If we found an index, find the corresponding interface name
+    if interface_idx:
+        for iface_name in psutil.net_if_addrs():
+            if str(interface_idx) in iface_name:
+                return iface_name
+
+    return None
+
+
+def _find_interface_by_default_gateway_unix():
+    """Find the network interface with the default gateway on Unix-like systems."""
+    try:
+        cmd = "ip route show default 2>/dev/null || netstat -rn | grep default"
+        output = subprocess.check_output(cmd, shell=True, text=True)
+        return _parse_unix_route_output(output)
+    except Exception as e:
+        log.debug(f"Error finding Unix interface by gateway: {e}")
+    return None
+
+
+def _parse_unix_route_output(output):
+    """Parse the output of Unix route commands to extract interface name."""
+    for line in output.split('\n'):
+        # Parse lines with 'default via ... dev ...'
+        if 'default via' in line and 'dev' in line:
+            return line.split('dev')[1].split()[0]
+
+        # Parse simpler 'default ...' lines
+        if 'default' in line:
+            parts = line.split()
+            if len(parts) > 3:
+                # Interface is usually the last column
+                return parts[-1]
+    return None
+
+
+def _get_candidate_interfaces():
+    """Get a list of candidate network interfaces."""
+    candidates = []
+    for interface, addrs in psutil.net_if_addrs().items():
+        stats = psutil.net_if_stats().get(interface)
+        if not stats or not stats.isup:
+            continue
+
+        ipv4_addrs = [addr for addr in addrs if addr.family == socket.AF_INET]
+        if not ipv4_addrs:
+            continue
+
+        # Skip loopback and common virtual interfaces
+        is_loopback = any(addr.address.startswith('127.')
+                          for addr in ipv4_addrs)
+        if is_loopback:
+            continue
+
+        virtual_names = ['loop', 'vmnet', 'vbox', 'docker', 'virtual', 'veth']
+        is_virtual = any(name in interface.lower() for name in virtual_names)
+        if is_virtual:
+            continue
+
+        candidates.append(interface)
+    return candidates
+
+
 def get_primary_interface():
     """
     Get the primary network interface that is likely handling internet traffic.
     Uses heuristics to identify the most probable interface.
     """
     # Try to find the interface with the default gateway
-    try:
-        if psutil.WINDOWS:
-            # On Windows, parse route print output
-            output = subprocess.check_output(
-                "route print 0.0.0.0", shell=True, text=True)
-            lines = output.strip().split('\n')
-            for line in lines:
-                if '0.0.0.0' in line and 'Gateway' not in line:  # Skip header
-                    parts = [p for p in line.split() if p]
-                    if len(parts) >= 4:
-                        interface_idx = parts[3]
-                        # Find interface name in the output
-                        for iface_name, addrs in psutil.net_if_addrs().items():
-                            if str(interface_idx) in iface_name:
-                                return iface_name
-        else:
-            # Linux/Unix/Mac - use ip route or netstat
-            try:
-                output = subprocess.check_output(
-                    "ip route show default 2>/dev/null || netstat -rn | grep default", shell=True, text=True)
-                for line in output.split('\n'):
-                    if 'default via' in line and 'dev' in line:
-                        return line.split('dev')[1].split()[0]
-                    elif 'default' in line:
-                        parts = line.split()
-                        if len(parts) > 3:
-                            # Interface is usually the last column
-                            return parts[-1]
-            except (subprocess.SubprocessError, IndexError, FileNotFoundError):
-                pass
-    except Exception as e:
-        log.debug(f"Error determining primary interface: {e}")
+    if psutil.WINDOWS:
+        interface = _find_interface_by_default_gateway_windows()
+        if interface:
+            return interface
+    else:
+        interface = _find_interface_by_default_gateway_unix()
+        if interface:
+            return interface
 
     # Fallback: Identify likely candidates based on heuristics
-    candidates = []
-
-    for interface, addrs in psutil.net_if_addrs().items():
-        stats = psutil.net_if_stats().get(interface)
-        if stats and stats.isup:
-            ipv4_addrs = [
-                addr for addr in addrs if addr.family == socket.AF_INET]
-            if ipv4_addrs:
-                # Skip loopback and common virtual interfaces
-                is_loopback = any(addr.address.startswith('127.')
-                                  for addr in ipv4_addrs)
-                is_virtual = any(name in interface.lower() for name in
-                                 ['loop', 'vmnet', 'vbox', 'docker', 'virtual', 'veth'])
-
-                if not is_loopback and not is_virtual:
-                    candidates.append(interface)
+    candidates = _get_candidate_interfaces()
+    if not candidates:
+        return None
 
     # Prioritize interfaces with names typically used for physical connections
-    for prefix in ['eth', 'en', 'wlan', 'wifi', 'wl', 'wi']:
+    physical_prefixes = ['eth', 'en', 'wlan', 'wifi', 'wl', 'wi']
+    for prefix in physical_prefixes:
         for interface in candidates:
             if interface.lower().startswith(prefix):
                 return interface
 
-    # Otherwise return the first candidate or None
-    return candidates[0] if candidates else None
+    # Otherwise return the first candidate
+    return candidates[0]
 
 
 def get_host_ip_mask(ip_with_cidr: str):
@@ -456,13 +408,16 @@ def network_from_snicaddr(snicaddr: psutil._common.snicaddr) -> str:
     """
     if not snicaddr.address or not snicaddr.netmask:
         return None
-    elif snicaddr.family == socket.AF_INET:
+
+    if snicaddr.family == socket.AF_INET:
         addr = f"{snicaddr.address}/{get_cidr_from_netmask(snicaddr.netmask)}"
-    elif snicaddr.family == socket.AF_INET6:
+        return get_host_ip_mask(addr)
+
+    if snicaddr.family == socket.AF_INET6:
         addr = f"{snicaddr.address}/{snicaddr.netmask}"
-    else:
-        return f"{snicaddr.address}"
-    return get_host_ip_mask(addr)
+        return get_host_ip_mask(addr)
+
+    return f"{snicaddr.address}"
 
 
 def smart_select_primary_subnet(subnets: List[dict] = None) -> str:
@@ -504,19 +459,32 @@ def smart_select_primary_subnet(subnets: List[dict] = None) -> str:
     return selected.get("subnet", "")
 
 
+class ArpSupportChecker:
+    """
+    Singleton class to check if ARP requests are supported on the current system.
+    The check is only performed once.
+    """
+    _supported = None
+
+    @classmethod
+    def is_supported(cls):
+        """one time check if ARP requests are supported on this system"""
+        if cls._supported is not None:
+            return cls._supported
+        try:
+            arp_request = ARP(pdst='0.0.0.0')
+            broadcast = Ether(dst="ff:ff:ff:ff:ff:ff")
+            packet = broadcast / arp_request
+            srp(packet, timeout=0, verbose=False)
+            cls._supported = True
+        except (Scapy_Exception, PermissionError, RuntimeError):
+            cls._supported = False
+        return cls._supported
+
+
 def is_arp_supported():
     """
-    Check if ARP requests are supported on the current platform.
+    Check if ARP requests are supported on the current system.
+    Only runs the check once.
     """
-    try:
-        arp_request = ARP(pdst='0.0.0.0')
-        broadcast = Ether(dst="ff:ff:ff:ff:ff:ff")
-        packet = broadcast / arp_request
-
-        srp(packet, timeout=0, verbose=False)
-        return True
-    # Scapy_Exception = MacOS
-    # PermissionError = Linux
-    # RuntimeError = Windows
-    except (Scapy_Exception, PermissionError, RuntimeError):
-        return False
+    return ArpSupportChecker.is_supported()

lanscape/libraries/port_manager.py

@@ -1,3 +1,12 @@
+"""
+Port Manager module for managing port list configurations.
+
+This module provides functionality to create, read, update, and delete port lists
+that are stored as JSON files. Each port list contains port numbers and their
+associated services. The module handles validation of port data and provides
+methods for working with port list configurations.
+"""
+
 import json
 from typing import List
 from pathlib import Path
@@ -7,15 +16,46 @@ PORT_DIR = 'ports'
 
 
 class PortManager:
+    """
+    Manager class for port list operations.
+
+    Handles the creation, retrieval, updating, and deletion of port lists.
+    Port lists are stored as JSON files with port numbers as keys and
+    service names as values.
+    """
+
     def __init__(self):
+        """
+        Initialize the PortManager.
+
+        Creates the ports directory if it doesn't exist and initializes
+        the ResourceManager for file operations.
+        """
         Path(PORT_DIR).mkdir(parents=True, exist_ok=True)
         self.rm = ResourceManager(PORT_DIR)
 
     def get_port_lists(self) -> List[str]:
+        """
+        Get a list of all available port list names.
+
+        Returns:
+            List[str]: Names of all available port lists (without .json extension)
+        """
         return [f.replace('.json', '') for f in self.rm.list() if f.endswith('.json')]
 
     def get_port_list(self, port_list: str) -> dict:
+        """
+        Retrieve a port list by name.
+
+        Args:
+            port_list (str): The name of the port list to retrieve
 
+        Returns:
+            dict: A dictionary of port numbers to service names
+
+        Raises:
+            ValueError: If the specified port list does not exist
+        """
         if port_list not in self.get_port_lists():
             msg = f"Port list '{port_list}' does not exist. "
             msg += f"Available port lists: {self.get_port_lists()}"
@@ -26,6 +66,16 @@ class PortManager:
         return data if self.validate_port_data(data) else None
 
     def create_port_list(self, port_list: str, data: dict) -> bool:
+        """
+        Create a new port list.
+
+        Args:
+            port_list (str): Name for the new port list
+            data (dict): Dictionary mapping port numbers to service names
+
+        Returns:
+            bool: True if creation was successful, False otherwise
+        """
         if port_list in self.get_port_lists():
             return False
         if not self.validate_port_data(data):
@@ -36,6 +86,16 @@ class PortManager:
         return True
 
     def update_port_list(self, port_list: str, data: dict) -> bool:
+        """
+        Update an existing port list.
+
+        Args:
+            port_list (str): Name of the port list to update
+            data (dict): New dictionary mapping port numbers to service names
+
+        Returns:
+            bool: True if update was successful, False otherwise
+        """
         if port_list not in self.get_port_lists():
             return False
         if not self.validate_port_data(data):
@@ -46,6 +106,15 @@ class PortManager:
         return True
 
     def delete_port_list(self, port_list: str) -> bool:
+        """
+        Delete a port list.
+
+        Args:
+            port_list (str): Name of the port list to delete
+
+        Returns:
+            bool: True if deletion was successful, False otherwise
+        """
         if port_list not in self.get_port_lists():
             return False
 
@@ -54,6 +123,20 @@ class PortManager:
         return True
 
     def validate_port_data(self, port_data: dict) -> bool:
+        """
+        Validate port data structure and content.
+
+        Ensures that:
+        - Keys can be converted to integers
+        - Values are strings
+        - Port numbers are within valid range (0-65535)
+
+        Args:
+            port_data (dict): Dictionary mapping port numbers to service names
+
+        Returns:
+            bool: True if data is valid, False otherwise
+        """
         try:
             for port, service in port_data.items():
                 port = int(port)  # throws if not int