lanscape 1.4.4__py3-none-any.whl → 1.5.0__py3-none-any.whl

lanscape/__init__.py

@@ -3,6 +3,7 @@ Local network scanner
 """
 from lanscape.libraries.subnet_scan import (
     SubnetScanner,
+    ScannerResults,
     ScanManager
 )
 
@@ -12,6 +13,9 @@ from lanscape.libraries.scan_config import (
     PingConfig,
     PokeConfig,
     ArpCacheConfig,
+    PortScanConfig,
+    ServiceScanConfig,
+    ServiceScanStrategy,
     ScanType
 )
 

lanscape/libraries/app_scope.py

@@ -5,7 +5,6 @@ Resource and environment management utilities for Lanscape.
 
 from pathlib import Path
 import json
-import re
 
 
 class ResourceManager:
@@ -32,9 +31,28 @@ class ResourceManager:
         return json.loads(self.get(asset_name))
 
     def get_jsonc(self, asset_name: str):
-        """Get JSON content with comments removed."""
+        """AI Slop to get JSONC (JSON with comments) content of an asset as a JSON object."""
         content = self.get(asset_name)
-        cleaned_content = re.sub(r'//.*', '', content)
+
+        def strip_jsonc_lines(text):
+            result = []
+            in_string = False
+            escape = False
+            for line in text.splitlines():
+                new_line = []
+                i = 0
+                while i < len(line):
+                    char = line[i]
+                    if char == '"' and not escape:
+                        in_string = not in_string
+                    if not in_string and line[i:i + 2] == "//":
+                        break  # Ignore rest of line (comment)
+                    new_line.append(char)
+                    escape = (char == '\\' and not escape)
+                    i += 1
+                result.append(''.join(new_line))
+            return '\n'.join(result)
+        cleaned_content = strip_jsonc_lines(content)
         return json.loads(cleaned_content)
 
     def update(self, asset_name: str, content: str):

lanscape/libraries/decorators.py

@@ -179,7 +179,9 @@ def timeout_enforcer(timeout: int, raise_on_timeout: bool = True):
         @functools.wraps(func)
         def wrapper(*args, **kwargs):
             """Wrap the function to enforce a timeout on its execution."""
-            with concurrent.futures.ThreadPoolExecutor(max_workers=1) as executor:
+            with concurrent.futures.ThreadPoolExecutor(
+                    max_workers=1,
+                    thread_name_prefix="TimeoutEnforcer") as executor:
                 future = executor.submit(func, *args, **kwargs)
                 try:
                     return future.result(

lanscape/libraries/net_tools.py

@@ -1,44 +1,97 @@
 """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 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.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, run_once
+from lanscape.libraries.decorators import job_tracker, run_once, timeout_enforcer
+from lanscape.libraries.scan_config import ServiceScanConfig, PortScanConfig
 
 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."""
@@ -46,32 +99,72 @@ class Device:
             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:
+    # 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 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+                sock.settimeout(port_config.timeout)
+                try:
+                    result = sock.connect_ex((self.ip, port))
+                    if result == 0:
+                        if port not in self.ports:
+                            self.ports.append(port)
+                        return True
+                except Exception:
+                    pass  # Connection failed, try again if retries remain
+                finally:
+                    sock.close()
+
+                # 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

lanscape/libraries/scan_config.py

@@ -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
         )
     )
 }

lanscape/libraries/service_scan.py

@@ -1,8 +1,14 @@
-"""Service scanning module for identifying services running on network ports."""
+"""Service scanning module for identifying services running on network ports.
+"""
+
+from typing import Optional, Union
+import sys
 import asyncio
 import logging
 import traceback
+
 from lanscape.libraries.app_scope import ResourceManager
+from lanscape.libraries.scan_config import ServiceScanConfig, ServiceScanStrategy
 
 log = logging.getLogger('ServiceScan')
 SERVICES = ResourceManager('services').get_jsonc('definitions.jsonc')
@@ -11,33 +17,162 @@ SERVICES = ResourceManager('services').get_jsonc('definitions.jsonc')
 PRINTER_PORTS = [9100, 631]
 
 
-def scan_service(ip: str, port: int, timeout=10) -> str:
+async def _try_probe(
+    ip: str,
+    port: int,
+    payload: Optional[Union[str, bytes]] = None,
+    *,
+    timeout: float = 5.0,
+    read_len: int = 1024,
+) -> Optional[str]:
+    """
+    Open a connection, optionally send a payload, and read a single response chunk.
+    Returns the decoded response string or None.
+    """
+    try:
+        reader, writer = await asyncio.wait_for(
+            asyncio.open_connection(ip, port), timeout=timeout
+        )
+        try:
+            if payload is not None:
+                data = payload if isinstance(
+                    payload, (bytes, bytearray)) else str(payload).encode(
+                    "utf-8", errors="ignore")
+                writer.write(data)
+                await writer.drain()
+            try:
+                response = await asyncio.wait_for(reader.read(read_len), timeout=timeout / 2)
+            except asyncio.TimeoutError:
+                response = b""
+            resp_str = response.decode("utf-8", errors="ignore") if response else ""
+            return resp_str if resp_str else None
+        finally:
+            # Guarded close to avoid surfacing connection-lost noise
+            try:
+                writer.close()
+            except Exception:
+                pass
+            try:
+                await asyncio.wait_for(writer.wait_closed(), timeout=0.5)
+            except Exception:
+                pass
+    except Exception as e:
+        # Suppress common/expected network errors that simply indicate no useful banner
+        expected_types = (ConnectionResetError, ConnectionRefusedError, TimeoutError, OSError)
+        expected_errnos = {10054, 10061, 10060}  # reset, refused, timeout (Win specific)
+        eno = getattr(e, 'errno', None)
+        if isinstance(e, expected_types) and (eno in expected_errnos or eno is None):
+            return None
+        log.debug(f"Probe error on {ip}:{port} - {repr(e)}")
+        return None
+
+
+async def _multi_probe_generic(
+    ip: str, port: int, cfg: ServiceScanConfig
+) -> Optional[str]:
+    """
+    Run a small set of generic probes in parallel and return the first non-empty response.
+    """
+    probes = get_port_probes(port, cfg.lookup_type)
+
+    semaphore = asyncio.Semaphore(cfg.max_concurrent_probes)
+
+    async def limited_probe(ip, port, payload, timeout_val):
+        async with semaphore:
+            return await _try_probe(
+                ip, port, payload,
+                timeout=timeout_val
+            )
+
+    tasks = [
+        asyncio.create_task(
+            limited_probe(ip, port, p, cfg.timeout)
+        )
+        for p in probes
+    ]
+
+    try:
+        for fut in asyncio.as_completed(tasks, timeout=cfg.timeout):
+            try:
+                resp = await fut
+            except Exception:
+                resp = None
+            if resp and resp.strip():
+                # Cancel remaining tasks
+                for t in tasks:
+                    if not t.done():
+                        t.cancel()
+                return resp
+    except asyncio.TimeoutError:
+        pass
+    finally:
+        # Ensure remaining tasks are cancelled and awaited to suppress warnings
+        for t in tasks:
+            if not t.done():
+                t.cancel()
+        await asyncio.gather(*tasks, return_exceptions=True)
+
+    return None
+
+
+def get_port_probes(port: int, strategy: ServiceScanStrategy):
+    """
+    Return a list of probe payloads based on the port and strategy.
+    """
+    # For now, we use generic probes for all ports.
+    # This can be extended to use specific probes per port/service.
+
+    probes = [
+        None,  # banner-first protocols (SSH/FTP/SMTP/etc.)
+        b"\r\n",  # nudge for many line-oriented services
+        b"HELP\r\n",  # sometimes yields usage/help (SMTP/POP/IMAP-ish)
+        b"OPTIONS * HTTP/1.0\r\n\r\n",  # elicit Server header without path
+        b"HEAD / HTTP/1.0\r\n\r\n",  # basic HTTP
+        b"QUIT\r\n",  # graceful close if understood
+    ]
+
+    if strategy == ServiceScanStrategy.LAZY:
+        return probes
+
+    if strategy == ServiceScanStrategy.BASIC:
+        for _, detail in SERVICES.items():
+            if port in detail.get("ports", []):
+                if probe := detail.get("probe", ''):
+                    probes.append(probe)
+        return probes
+
+    if strategy == ServiceScanStrategy.AGGRESSIVE:
+        for _, detail in SERVICES.items():
+            if probe := detail.get("probe", ''):
+                probes.append(probe)
+        return probes
+
+    return [None]  # Default to banner grab only
+
+
+def scan_service(ip: str, port: int, cfg: ServiceScanConfig) -> str:
     """
     Synchronous function that attempts to identify the service running on a given port.
     """
 
-    async def _async_scan_service(ip: str, port: int, timeout) -> str:
+    async def _async_scan_service(
+        ip: str, port: int,
+        cfg: ServiceScanConfig
+    ) -> str:
         if port in PRINTER_PORTS:
             return "Printer"
 
         try:
-            # Add a timeout to prevent hanging
-            reader, writer = await asyncio.wait_for(asyncio.open_connection(ip, port), timeout=5)
-
-            # Send a probe appropriate for common services
-            probe = f"GET / HTTP/1.1\r\nHost: {ip}\r\n\r\n".encode("utf-8")
-            writer.write(probe)
-            await writer.drain()
+            # Run multiple generic probes concurrently and take first useful response
+            response_str = await _multi_probe_generic(ip, port, cfg)
+            if not response_str:
+                return "Unknown"
 
-            # Receive the response with a timeout
-            response = await asyncio.wait_for(reader.read(1024), timeout=timeout)
-            writer.close()
-            await writer.wait_closed()
+            log.debug(f"Service scan response from {ip}:{port} - {response_str}")
 
             # Analyze the response to identify the service
-            response_str = response.decode("utf-8", errors="ignore")
-            for service, hints in SERVICES.items():
-                if any(hint.lower() in response_str.lower() for hint in hints):
+            for service, config in SERVICES.items():
+                if any(hint.lower() in response_str.lower() for hint in config.get("hints", [])):
                     return service
         except asyncio.TimeoutError:
             log.warning(f"Timeout scanning {ip}:{port}")
@@ -47,4 +182,23 @@ def scan_service(ip: str, port: int, timeout=10) -> str:
         return "Unknown"
 
     # Use asyncio.run to execute the asynchronous logic synchronously
-    return asyncio.run(_async_scan_service(ip, port, timeout=timeout))
+    return asyncio.run(_async_scan_service(ip, port, cfg=cfg))
+
+
+def asyncio_logger_suppression():
+    """Suppress the noisy asyncio transport errors since they are expected in service scanning."""
+
+    # Reduce noisy asyncio transport errors on Windows by switching to Selector policy
+    if sys.platform.startswith("win"):
+        try:
+            asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
+        except Exception:
+            pass
+    # Also tone down asyncio logger noise from transport callbacks
+    try:
+        logging.getLogger("asyncio").setLevel(logging.WARNING)
+    except Exception:
+        pass
+
+
+asyncio_logger_suppression()