lanscape 1.3.8a1__py3-none-any.whl → 2.4.0a2__py3-none-any.whl

lanscape/{libraries → core}/net_tools.py

@@ -1,77 +1,185 @@
 """Network tools for scanning and managing devices on a network."""
 
-import logging
 import ipaddress
-import traceback
-import subprocess
-from typing import List, Dict
+import logging
+import re
 import socket
 import struct
-import re
-import psutil
+import subprocess
+import traceback
+from time import sleep
+from typing import List, Dict, Optional
 
+import psutil
 from scapy.sendrecv import srp
 from scapy.layers.l2 import ARP, Ether
 from scapy.error import Scapy_Exception
 
-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
+from pydantic import BaseModel, PrivateAttr
+try:
+    from pydantic import ConfigDict, computed_field, model_serializer  # pydantic v2
+    _PYD_V2 = True
+except Exception:  # pragma: no cover
+    CONFIG_DICT = None  # type: ignore  # pylint: disable=invalid-name
+    COMPUTED_FIELD = None  # type: ignore  # pylint: disable=invalid-name
+    MODEL_SERIALIZER = None  # type: ignore  # pylint: disable=invalid-name
+    _PYD_V2 = False
+else:
+    CONFIG_DICT = ConfigDict  # pylint: disable=invalid-name
+    COMPUTED_FIELD = computed_field  # pylint: disable=invalid-name
+    MODEL_SERIALIZER = model_serializer  # pylint: disable=invalid-name
+
+from lanscape.core.service_scan import scan_service
+from lanscape.core.mac_lookup import MacLookup, get_macs
+from lanscape.core.ip_parser import get_address_count, MAX_IPS_ALLOWED, parse_ip_input
+from lanscape.core.errors import DeviceError
+from lanscape.core.decorators import job_tracker, run_once, timeout_enforcer
+from lanscape.core.scan_config import ServiceScanConfig, PortScanConfig, ScanType
 
 log = logging.getLogger('NetTools')
 mac_lookup = MacLookup()
 
 
-class Device:
+class Device(BaseModel):
     """Represents a network device with metadata and scanning capabilities."""
 
-    def __init__(self, ip: str):
-        super().__init__()
-        self.ip: str = ip
-        self.alive: bool = None
-        self.hostname: str = None
-        self.macs: List[str] = []
-        self.manufacturer: str = None
-        self.ports: List[int] = []
-        self.stage: str = 'found'
-        self.services: Dict[str, List[int]] = {}
-        self.caught_errors: List[DeviceError] = []
-        self.log = logging.getLogger('Device')
+    ip: str
+    alive: Optional[bool] = None
+    hostname: Optional[str] = None
+    macs: List[str] = []
+    manufacturer: Optional[str] = None
+    ports: List[int] = []
+    stage: str = 'found'
+    ports_scanned: int = 0
+    services: Dict[str, List[int]] = {}
+    caught_errors: List[DeviceError] = []
+    job_stats: Optional[Dict] = None
+
+    _log: logging.Logger = PrivateAttr(default_factory=lambda: logging.getLogger('Device'))
+    # Support pydantic v1 and v2 configs
+    if _PYD_V2 and CONFIG_DICT:
+        model_config = CONFIG_DICT(arbitrary_types_allowed=True)  # type: ignore[assignment]
+    else:  # pragma: no cover
+        class Config:  # pylint: disable=too-few-public-methods
+            """Pydantic v1 configuration."""
+            arbitrary_types_allowed = True
+            extra = 'allow'
+
+    @property
+    def log(self) -> logging.Logger:
+        """Get the logger instance for this device."""
+        return self._log
+
+    # Computed fields for pydantic v2 (included in model_dump)
+    if _PYD_V2 and COMPUTED_FIELD:
+        @COMPUTED_FIELD(return_type=str)  # type: ignore[misc]
+        @property
+        def mac_addr(self) -> str:
+            """Get the primary MAC address for this device."""
+            return self.get_mac() or ""
+
+        @MODEL_SERIALIZER(mode='wrap')  # type: ignore[misc]
+        def _serialize(self, serializer):
+            """Serialize device data for output."""
+            data = serializer(self)
+            # Remove internals
+            data.pop('job_stats', None)
+            # Ensure mac_addr present (computed_field already adds it)
+            data['mac_addr'] = data.get('mac_addr') or (self.get_mac() or '')
+            # Ensure manufacturer present; prefer explicit model value
+            manuf = data.get('manufacturer')
+            if not manuf:
+                data['manufacturer'] = self._get_manufacturer(
+                    data['mac_addr']) if data['mac_addr'] else None
+            return data
 
     def get_metadata(self):
         """Retrieve metadata such as hostname and MAC addresses."""
         if self.alive:
             self.hostname = self._get_hostname()
             self._get_mac_addresses()
-
-    def dict(self) -> dict:
-        """Convert the device object to a dictionary."""
-        obj = vars(self).copy()
-        obj.pop('log')
-        obj.pop('job_stats', None)  # Remove job_stats if it exists
-        primary_mac = self.get_mac()
-        obj['mac_addr'] = primary_mac
-        obj['manufacturer'] = self._get_manufacturer(primary_mac)
-
-        return obj
-
-    def test_port(self, port: int) -> bool:
+            if not self.manufacturer:
+                self.manufacturer = self._get_manufacturer(
+                    self.get_mac()
+                )
+
+    # Fallback for pydantic v1: use dict() and enrich output
+    if not _PYD_V2:
+        def dict(self, *args, **kwargs) -> dict:  # type: ignore[override]
+            """Generate dictionary representation for pydantic v1."""
+            data = super().dict(*args, **kwargs)
+            data.pop('job_stats', None)
+            mac_addr = self.get_mac() or ''
+            data['mac_addr'] = mac_addr
+            if not data.get('manufacturer'):
+                data['manufacturer'] = self._get_manufacturer(mac_addr) if mac_addr else None
+            return data
+    else:
+        # In v2, route dict() to model_dump() so callers get the serialized enrichment
+        def dict(self, *args, **kwargs) -> dict:  # type: ignore[override]
+            """Generate dictionary representation for pydantic v2."""
+            try:
+                return self.model_dump(*args, **kwargs)  # type: ignore[attr-defined]
+            except Exception:
+                # Safety fallback (shouldn't normally hit)
+                data = self.__dict__.copy()
+                data.pop('_log', None)
+                data.pop('job_stats', None)
+                mac_addr = self.get_mac() or ''
+                data['mac_addr'] = mac_addr
+                if not data.get('manufacturer'):
+                    data['manufacturer'] = self._get_manufacturer(mac_addr) if mac_addr else None
+                return data
+
+    def test_port(self, port: int, port_config: Optional[PortScanConfig] = None) -> bool:
         """Test if a specific port is open on the device."""
-        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        sock.settimeout(1)
-        result = sock.connect_ex((self.ip, port))
-        sock.close()
-        if result == 0:
-            self.ports.append(port)
-            return True
-        return False
+        if port_config is None:
+            port_config = PortScanConfig()  # Use defaults
+
+        # Calculate timeout enforcer: (timeout * (retries+1) * 1.5)
+        enforcer_timeout = port_config.timeout * (port_config.retries + 1) * 1.5
+
+        @timeout_enforcer(enforcer_timeout, False)
+        def do_test():
+            for attempt in range(port_config.retries + 1):
+                sock = None
+                try:
+                    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+                    sock.settimeout(port_config.timeout)
+                    result = sock.connect_ex((self.ip, port))
+                    if result == 0:
+                        if port not in self.ports:
+                            self.ports.append(port)
+                        return True
+                except OSError as e:
+                    # Handle socket creation failures (e.g., "Too many open files")
+                    # Log and continue to retry if attempts remain
+                    log = logging.getLogger('Device.test_port')
+                    log.debug(f"OSError on {self.ip}:{port} attempt {attempt + 1}: {e}")
+                except Exception:
+                    pass  # Connection failed, try again if retries remain
+                finally:
+                    # Always close socket if it was created
+                    if sock is not None:
+                        try:
+                            sock.close()
+                        except Exception:
+                            pass  # Ignore errors during cleanup
+
+                # Wait before retry (except on last attempt)
+                if attempt < port_config.retries:
+                    sleep(port_config.retry_delay)
+
+            return False
+
+        ans = do_test() or False
+        self.ports_scanned += 1
+        return ans
 
     @job_tracker
-    def scan_service(self, port: int):
+    def scan_service(self, port: int, cfg: ServiceScanConfig):
         """Scan a specific port for services."""
-        service = scan_service(self.ip, port)
+        service = scan_service(self.ip, port, cfg)
         service_ports = self.services.get(service, [])
         service_ports.append(port)
         self.services[service] = service_ports
@@ -459,32 +567,67 @@ def smart_select_primary_subnet(subnets: List[dict] = None) -> str:
     return selected.get("subnet", "")
 
 
-class ArpSupportChecker:
+def is_internal_block(subnet: str) -> bool:
     """
-    Singleton class to check if ARP requests are supported on the current system.
-    The check is only performed once.
+    Check if a subnet contains only internal/private IP addresses.
+
+    Supports CIDR notation, IP ranges, comma-separated lists, and single IPs.
+    For ranges and complex inputs, samples representative IPs for efficiency.
+
+    Args:
+        subnet: IP subnet string in various formats
+
+    Returns:
+        bool: True if all sampled IPs are private/internal, False otherwise
     """
-    _supported = None
+    try:
+        # Handle comma-separated subnets recursively
+        if ',' in subnet:
+            return all(is_internal_block(part.strip()) for part in subnet.split(','))
 
-    @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
+        # Handle CIDR notation directly
+        if '/' in subnet:
+            return ipaddress.IPv4Network(subnet, strict=False).is_private
 
+        # Handle ranges and single IPs by parsing and sampling
+        ip_list = parse_ip_input(subnet)
+        sample_ips = ([ip_list[0], ip_list[-1]] if len(ip_list) > 1 else ip_list)
+        return all(ipaddress.IPv4Address(ip).is_private for ip in sample_ips)
+
+    except (ValueError, ipaddress.AddressValueError):
+        return False  # Assume external for unparseable input
+
+
+def scan_config_uses_arp(config) -> bool:
+    """
+    Check if a scan configuration uses ARP-based scanning methods.
 
+    Args:
+        config: ScanConfig instance
+
+    Returns:
+        bool: True if the configuration uses ARP scanning, False otherwise
+    """
+    arp_scan_types = {
+        ScanType.ARP_LOOKUP,
+        ScanType.POKE_THEN_ARP,
+        ScanType.ICMP_THEN_ARP
+    }
+
+    return any(scan_type in arp_scan_types for scan_type in config.lookup_type)
+
+
+@run_once
 def is_arp_supported():
     """
     Check if ARP requests are supported on the current system.
     Only runs the check once.
     """
-    return ArpSupportChecker.is_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)
+        return True
+    except (Scapy_Exception, PermissionError, RuntimeError):
+        return False

lanscape/{libraries → core}/runtime_args.py

@@ -14,6 +14,8 @@ class RuntimeArgs:
     loglevel: str = 'INFO'
     flask_logging: bool = False
     persistent: bool = False
+    ws_server: bool = False
+    ws_port: int = 8766
 
 
 def parse_args() -> RuntimeArgs:
@@ -35,6 +37,10 @@ def parse_args() -> RuntimeArgs:
                         help='Don\'t exit after browser is closed')
     parser.add_argument('--debug', action='store_true',
                         help='Shorthand debug mode (equivalent to "--loglevel DEBUG --reloader")')
+    parser.add_argument('--ws-server', action='store_true',
+                        help='Start WebSocket server instead of Flask UI')
+    parser.add_argument('--ws-port', type=int, default=8766,
+                        help='Port for WebSocket server (default: 8766)')
 
     # Parse the arguments
     args = parser.parse_args()

lanscape/{libraries → core}/scan_config.py

@@ -11,8 +11,8 @@ from enum import Enum
 
 from pydantic import BaseModel, Field
 
-from lanscape.libraries.port_manager import PortManager
-from lanscape.libraries.ip_parser import parse_ip_input
+from lanscape.core.port_manager import PortManager
+from lanscape.core.ip_parser import parse_ip_input
 
 
 class PingConfig(BaseModel):
@@ -154,6 +154,87 @@ class PokeConfig(BaseModel):
         return self.model_dump()
 
 
+class ServiceScanStrategy(Enum):
+    """
+    Enumeration of strategies for service scanning on open ports.
+
+    LAZY: Several common probes to see if we can identify the service.
+    BASIC: Common probes plus probes correlated to the port number.
+    AGGRESSIVE: All known probes in parallel to try to elicit a response.
+    """
+    LAZY = 'LAZY'
+    BASIC = 'BASIC'
+    AGGRESSIVE = 'AGGRESSIVE'
+
+
+class ServiceScanConfig(BaseModel):
+    """
+    Configuration for service scanning on open ports.
+    """
+    timeout: float = 5.0
+    lookup_type: ServiceScanStrategy = ServiceScanStrategy.BASIC
+    max_concurrent_probes: int = 10
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'ServiceScanConfig':
+        """
+        Create a ServiceScanConfig instance from a dictionary.
+
+        Args:
+            data: Dictionary containing ServiceScanConfig parameters
+
+        Returns:
+            A new ServiceScanConfig instance with the provided settings
+        """
+        return cls.model_validate(data)
+
+    def to_dict(self) -> dict:
+        """
+        Convert the ServiceScanConfig instance to a dictionary.
+
+        Returns:
+            Dictionary representation of the ServiceScanConfig
+        """
+        return self.model_dump()
+
+    def __str__(self):
+        return f'ServiceScanCfg(timeout={self.timeout})'
+
+
+class PortScanConfig(BaseModel):
+    """
+    Configuration for port scanning.
+    """
+    timeout: float = 1.0
+    retries: int = 0
+    retry_delay: float = 0.1
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'PortScanConfig':
+        """
+        Create a PortScanConfig instance from a dictionary.
+
+        Args:
+            data: Dictionary containing PortScanConfig parameters
+
+        Returns:
+            A new PortScanConfig instance with the provided settings
+        """
+        return cls.model_validate(data)
+
+    def to_dict(self) -> dict:
+        """
+        Convert the PortScanConfig instance to a dictionary.
+
+        Returns:
+            Dictionary representation of the PortScanConfig
+        """
+        return self.model_dump()
+
+    def __str__(self):
+        return f'PortScanCfg(timeout={self.timeout}, retry_delay={self.retry_delay})'
+
+
 class ScanType(Enum):
     """
     Enumeration of supported network scan types.
@@ -184,7 +265,7 @@ class ScanConfig(BaseModel):
 
     task_scan_ports: bool = True
     # below wont run if above false
-    task_scan_port_services: bool = False  # disabling until more stable
+    task_scan_port_services: bool = True
 
     lookup_type: List[ScanType] = [ScanType.ICMP_THEN_ARP]
 
@@ -192,6 +273,8 @@ class ScanConfig(BaseModel):
     arp_config: ArpConfig = Field(default_factory=ArpConfig)
     poke_config: PokeConfig = Field(default_factory=PokeConfig)
     arp_cache_config: ArpCacheConfig = Field(default_factory=ArpCacheConfig)
+    port_scan_config: PortScanConfig = Field(default_factory=PortScanConfig)
+    service_scan_config: ServiceScanConfig = Field(default_factory=ServiceScanConfig)
 
     def t_cnt(self, thread_id: str) -> int:
         """
@@ -259,7 +342,7 @@ DEFAULT_CONFIGS: Dict[str, ScanConfig] = {
         t_cnt_port_test=64,
         t_cnt_isalive=64,
         task_scan_ports=True,
-        task_scan_port_services=False,
+        task_scan_port_services=True,
         lookup_type=[ScanType.ICMP_THEN_ARP, ScanType.ARP_LOOKUP],
         arp_config=ArpConfig(
             attempts=3,
@@ -274,6 +357,16 @@ DEFAULT_CONFIGS: Dict[str, ScanConfig] = {
         arp_cache_config=ArpCacheConfig(
             attempts=2,
             wait_before=0.3
+        ),
+        port_scan_config=PortScanConfig(
+            timeout=2.5,
+            retries=1,
+            retry_delay=0.2
+        ),
+        service_scan_config=ServiceScanConfig(
+            timeout=8.0,
+            lookup_type=ServiceScanStrategy.AGGRESSIVE,
+            max_concurrent_probes=5
         )
     ),
     'fast': ScanConfig(
@@ -283,7 +376,7 @@ DEFAULT_CONFIGS: Dict[str, ScanConfig] = {
         t_cnt_port_test=256,
         t_cnt_isalive=512,
         task_scan_ports=True,
-        task_scan_port_services=False,
+        task_scan_port_services=True,
         lookup_type=[ScanType.POKE_THEN_ARP],
         arp_config=ArpConfig(
             attempts=1,
@@ -294,6 +387,11 @@ DEFAULT_CONFIGS: Dict[str, ScanConfig] = {
             ping_count=1,
             timeout=0.5,
             retry_delay=0.25
+        ),
+        service_scan_config=ServiceScanConfig(
+            timeout=2.0,
+            lookup_type=ServiceScanStrategy.LAZY,
+            max_concurrent_probes=15
         )
     )
 }