lanscape 1.3.2a6__py3-none-any.whl → 1.3.2a9__py3-none-any.whl

lanscape/libraries/scan_config.py

@@ -0,0 +1,97 @@
+from typing import List
+import ipaddress
+from pydantic import BaseModel, Field
+from enum import Enum
+
+from .port_manager import PortManager
+from .ip_parser import parse_ip_input
+
+
+class PingConfig(BaseModel):
+    attempts: int = 1
+    ping_count: int = 2
+    timeout: float = 2.0
+    retry_delay: float = 0.5
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'PingConfig':
+        return cls.model_validate(data)
+
+    def to_dict(self) -> dict:
+        return self.model_dump()
+
+    def __str__(self):
+        return (
+            f"PingCfg(attempts={self.attempts}, "
+            f"ping_count={self.ping_count}, "
+            f"timeout={self.timeout}, "
+            f"retry_delay={self.retry_delay})"
+        )
+
+
+class ArpConfig(BaseModel):
+    """
+    Configuration for ARP scanning.
+    """
+    attempts: int = 1
+    timeout: float = 2.0
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'ArpConfig':
+        return cls.model_validate(data)
+
+    def to_dict(self) -> dict:
+        return self.model_dump()
+
+    def __str__(self):
+        return f'ArpCfg(timeout={self.timeout}, attempts={self.attempts})'
+
+
+class ScanType(Enum):
+    PING = 'ping'
+    ARP = 'arp'
+    BOTH = 'both'
+
+
+class ScanConfig(BaseModel):
+    subnet: str
+    port_list: str
+    t_multiplier: float = 1.0
+    t_cnt_port_scan: int = 10
+    t_cnt_port_test: int = 128
+    t_cnt_isalive: int = 256
+
+    task_scan_ports: bool = True
+    # below wont run if above false
+    task_scan_port_services: bool = False  # disabling until more stable
+
+    lookup_type: ScanType = ScanType.BOTH
+
+    ping_config: PingConfig = Field(default_factory=PingConfig)
+    arp_config: ArpConfig = Field(default_factory=ArpConfig)
+
+    def t_cnt(self, id: str) -> int:
+        return int(int(getattr(self, f't_cnt_{id}')) * float(self.t_multiplier))
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'ScanConfig':
+        # Handle special cases before validation
+        if isinstance(data.get('lookup_type'), str):
+            data['lookup_type'] = ScanType[data['lookup_type'].upper()]
+
+        return cls.model_validate(data)
+
+    def to_dict(self) -> dict:
+        return self.model_dump()
+
+    def get_ports(self) -> List[int]:
+        return PortManager().get_port_list(self.port_list).keys()
+
+    def parse_subnet(self) -> List[ipaddress.IPv4Network]:
+        return parse_ip_input(self.subnet)
+
+    def __str__(self):
+        a = f'subnet={self.subnet}'
+        b = f'ports={self.port_list}'
+        c = f'scan_type={self.lookup_type.value}'
+        return f'ScanConfig({a}, {b}, {c})'

lanscape/libraries/service_scan.py

@@ -0,0 +1,50 @@
+import asyncio
+import logging
+import traceback
+from .app_scope import ResourceManager
+
+log = logging.getLogger('ServiceScan')
+SERVICES = ResourceManager('services').get_jsonc('definitions.jsonc')
+
+# skip printer ports because they cause blank pages to be printed
+PRINTER_PORTS = [9100, 631]
+
+
+def scan_service(ip: str, port: int, timeout=10) -> 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:
+        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 = "GET / HTTP/1.1\r\nHost: {}\r\n\r\n".format(
+                ip).encode("utf-8")
+            writer.write(probe)
+            await writer.drain()
+
+            # Receive the response with a timeout
+            response = await asyncio.wait_for(reader.read(1024), timeout=timeout)
+            writer.close()
+            await writer.wait_closed()
+
+            # 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):
+                    return service
+        except asyncio.TimeoutError:
+            log.warning(f"Timeout scanning {ip}:{port}")
+        except Exception as e:
+            log.error(f"Error scanning {ip}:{port}: {str(e)}")
+            log.debug(traceback.format_exc())
+        return "Unknown"
+
+    # Use asyncio.run to execute the asynchronous logic synchronously
+    return asyncio.run(_async_scan_service(ip, port, timeout=timeout))

lanscape/libraries/subnet_scan.py

@@ -0,0 +1,338 @@
+from .scan_config import ScanConfig
+from .decorators import job_tracker, terminator, JobStatsMixin
+import os
+import json
+import uuid
+import logging
+import ipaddress
+import traceback
+import threading
+from time import time
+from time import sleep
+from typing import List, Union
+from tabulate import tabulate
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+from .net_tools import Device, is_arp_supported
+from .errors import SubnetScanTerminationFailure
+
+
+class SubnetScanner(JobStatsMixin):
+    def __init__(
+        self,
+        config: ScanConfig
+    ):
+        self.cfg = config
+        self.subnet = config.parse_subnet()
+        self.ports: List[int] = config.get_ports()
+        self.running = False
+        self.subnet_str = config.subnet
+
+        self.uid = str(uuid.uuid4())
+        self.results = ScannerResults(self)
+        self.log: logging.Logger = logging.getLogger('SubnetScanner')
+        if not is_arp_supported():
+            self.log.warning(
+                'ARP is not supported with the active runtime context. Device discovery will be limited to ping responses.')
+        self.log.debug(f'Instantiated with uid: {self.uid}')
+        self.log.debug(
+            f'Port Count: {len(self.ports)} | Device Count: {len(self.subnet)}')
+
+    def start(self):
+        """
+        Scan the subnet for devices and open ports.
+        """
+        self._set_stage('scanning devices')
+        self.running = True
+        with ThreadPoolExecutor(max_workers=self.cfg.t_cnt('isalive')) as executor:
+            futures = {executor.submit(self._get_host_details, str(
+                ip)): str(ip) for ip in self.subnet}
+            for future in as_completed(futures):
+                ip = futures[future]
+                try:
+                    future.result()
+                except Exception as e:
+                    self.log.error(
+                        f'[{ip}] scan failed. details below:\n{traceback.format_exc()}')
+                    self.results.errors.append({
+                        'basic': f"Error scanning IP {ip}: {e}",
+                        'traceback': traceback.format_exc(),
+                    })
+
+        self._set_stage('testing ports')
+        if self.cfg.task_scan_ports:
+            self._scan_network_ports()
+        self.running = False
+        self._set_stage('complete')
+
+        return self.results
+
+    def terminate(self):
+        self.running = False
+        self._set_stage('terminating')
+        for i in range(20):
+            if not len(self.job_stats.running.keys()):
+                self._set_stage('terminated')
+                return True
+            sleep(.5)
+        raise SubnetScanTerminationFailure(self.job_stats.running)
+
+    def calc_percent_complete(self) -> int:  # 0 - 100
+        if not self.running:
+            return 100
+
+        # --- Host discovery (isalive) calculations ---
+        avg_host_detail_sec = self.job_stats.timing.get(
+            '_get_host_details', 4.5)
+        # assume 10% alive percentage if the scan just started
+        if len(self.results.devices) and (self.results.devices_scanned):
+            est_subnet_alive_percent = (
+                # avoid div 0
+                len(self.results.devices)) / (self.results.devices_scanned)
+        else:
+            est_subnet_alive_percent = .1
+        est_subnet_devices = est_subnet_alive_percent * self.results.devices_total
+
+        remaining_isalive_sec = (
+            self.results.devices_total - self.results.devices_scanned) * avg_host_detail_sec
+        total_isalive_sec = self.results.devices_total * avg_host_detail_sec
+
+        isalive_multiplier = self.cfg.t_cnt('isalive')
+
+        # --- Port scanning calculations ---
+        device_ports_scanned = self.job_stats.finished.get('_test_port', 0)
+        # remediate initial inaccurate results because open ports reurn quickly
+        avg_port_test_sec = self.job_stats.timing.get(
+            '_test_port', 1) if device_ports_scanned > 20 else 1
+
+        device_ports_unscanned = max(
+            0, (est_subnet_devices * len(self.ports)) - device_ports_scanned)
+
+        remaining_port_test_sec = device_ports_unscanned * avg_port_test_sec
+        total_port_test_sec = est_subnet_devices * \
+            len(self.ports) * avg_port_test_sec
+
+        port_test_multiplier = self.cfg.t_cnt(
+            'port_scan') * self.cfg.t_cnt('port_test')
+
+        # --- Overall progress ---
+        est_total_time = (total_isalive_sec / isalive_multiplier) + \
+            (total_port_test_sec / port_test_multiplier)
+        est_remaining_time = (remaining_isalive_sec / isalive_multiplier) + \
+            (remaining_port_test_sec / port_test_multiplier)
+
+        return int(abs((1 - (est_remaining_time / est_total_time)) * 100))
+
+    def debug_active_scan(self, sleep_sec=1):
+        """
+            Run this after running scan_subnet_threaded
+            to see the progress of the scan
+        """
+        while self.running:
+            percent = self.calc_percent_complete()
+            t_elapsed = time() - self.results.start_time
+            t_remain = int((100 - percent) * (t_elapsed / percent)
+                           ) if percent else '∞'
+            buffer = f'{self.uid} - {self.subnet_str}\n'
+            buffer += f'Elapsed: {int(t_elapsed)} sec - Remain: {t_remain} sec\n'
+            buffer += f'Scanned: {self.results.devices_scanned}/{self.results.devices_total}'
+            buffer += f' - {percent}%\n'
+            buffer += str(self.job_stats)
+            os.system('cls' if os.name == 'nt' else 'clear')
+            print(buffer)
+            sleep(sleep_sec)
+
+    @terminator
+    @job_tracker
+    def _get_host_details(self, host: str):
+        """
+        Get the MAC address and open ports of the given host.
+        """
+        device = Device(host)
+        device.alive = self._ping(device)
+        self.results.scanned()
+        if not device.alive:
+            return None
+        self.log.debug(f'[{host}] is alive, getting metadata')
+        device.get_metadata()
+        self.results.devices.append(device)
+        return True
+
+    @terminator
+    def _scan_network_ports(self):
+        with ThreadPoolExecutor(max_workers=self.cfg.t_cnt('port_scan')) as executor:
+            futures = {executor.submit(
+                self._scan_ports, device): device for device in self.results.devices}
+            for future in futures:
+                future.result()
+
+    @terminator
+    @job_tracker
+    def _scan_ports(self, device: Device):
+        self.log.debug(f'[{device.ip}] Initiating port scan')
+        device.stage = 'scanning'
+        with ThreadPoolExecutor(max_workers=self.cfg.t_cnt('port_test')) as executor:
+            futures = {executor.submit(self._test_port, device, int(
+                port)): port for port in self.ports}
+            for future in futures:
+                future.result()
+        self.log.debug(f'[{device.ip}] Completed port scan')
+        device.stage = 'complete'
+
+    @terminator
+    @job_tracker
+    def _test_port(self, host: Device, port: int):
+        """
+        Test if a port is open on a given host.
+        If port open, determine service.
+        Device class handles tracking open ports.
+        """
+        is_alive = host.test_port(port)
+        if is_alive and self.cfg.task_scan_port_services:
+            host.scan_service(port)
+        return is_alive
+
+    @terminator
+    @job_tracker
+    def _ping(self, host: Device):
+        """
+        Ping the given host and return True if it's reachable, False otherwise.
+        """
+        return host.is_alive(
+            host.ip,
+            scan_type=self.cfg.lookup_type,
+            ping_config=self.cfg.ping_config,
+            arp_config=self.cfg.arp_config
+        )
+
+    def _set_stage(self, stage):
+        self.log.debug(f'[{self.uid}] Moving to Stage: {stage}')
+        self.results.stage = stage
+        if not self.running:
+            self.results.end_time = time()
+
+
+class ScannerResults:
+    def __init__(self, scan: SubnetScanner):
+        self.scan = scan
+        self.port_list: str = scan.cfg.port_list
+        self.subnet: str = scan.subnet_str
+        self.uid = scan.uid
+
+        self.devices_total: int = len(list(scan.subnet))
+        self.devices_scanned: int = 0
+        self.devices: List[Device] = []
+
+        self.errors: List[str] = []
+        self.running: bool = False
+        self.start_time: float = time()
+        self.end_time: int = None
+        self.stage = 'instantiated'
+
+        self.log = logging.getLogger('ScannerResults')
+        self.log.debug(f'Instantiated Logger For Scan: {self.scan.uid}')
+
+    def scanned(self):
+        self.devices_scanned += 1
+
+    def get_runtime(self):
+        if self.scan.running:
+            return int(time() - self.start_time)
+        return int(self.end_time - self.start_time)
+
+    def export(self, out_type=dict) -> Union[str, dict]:
+        """
+            Returns json representation of the scan
+        """
+
+        self.running = self.scan.running
+        self.run_time = int(round(time() - self.start_time, 0))
+        self.devices_alive = len(self.devices)
+
+        out = vars(self).copy()
+        out.pop('scan')
+        out.pop('log')
+        out['cfg'] = vars(self.scan.cfg)
+
+        devices: List[Device] = out.pop('devices')
+        sortedDevices = sorted(
+            devices, key=lambda obj: ipaddress.IPv4Address(obj.ip))
+        out['devices'] = [device.dict() for device in sortedDevices]
+
+        if out_type == str:
+            return json.dumps(out, default=str, indent=2)
+        # otherwise return dict
+        return out
+
+    def __str__(self):
+        # Prepare data for tabulate
+        data = [
+            [device.ip, device.hostname, device.get_mac(
+            ), ", ".join(map(str, device.ports))]
+            for device in self.devices
+        ]
+
+        # Create headers for the table
+        headers = ["IP", "Host", "MAC", "Ports"]
+
+        # Generate the table using tabulate
+        table = tabulate(data, headers=headers, tablefmt="grid")
+
+        # Format and return the complete buffer with table output
+        buffer = f"Scan Results - {self.scan.subnet_str} - {self.uid}\n"
+        buffer += "---------------------------------------------\n\n"
+        buffer += table
+        return buffer
+
+
+class ScanManager:
+    """
+    Maintain active and completed scans in memory for
+    future reference. Singleton implementation.
+    """
+    _instance = None
+
+    def __new__(cls, *args, **kwargs):
+        if not cls._instance:
+            cls._instance = super(ScanManager, cls).__new__(
+                cls, *args, **kwargs)
+        return cls._instance
+
+    def __init__(self):
+        if not hasattr(self, 'scans'):  # Prevent reinitialization
+            self.scans: List[SubnetScanner] = []
+            self.log = logging.getLogger('ScanManager')
+
+    def new_scan(self, config: ScanConfig) -> SubnetScanner:
+        scan = SubnetScanner(config)
+        self._start(scan)
+        self.log.info(f'Scan started - {config}')
+        self.scans.append(scan)
+        return scan
+
+    def get_scan(self, scan_id: str) -> SubnetScanner:
+        """
+        Get scan by scan.uid
+        """
+        for scan in self.scans:
+            if scan.uid == scan_id:
+                return scan
+
+    def terminate_scans(self):
+        """
+        Terminate all active scans
+        """
+        for scan in self.scans:
+            if scan.running:
+                scan.terminate()
+
+    def wait_until_complete(self, scan_id: str) -> SubnetScanner:
+        scan = self.get_scan(scan_id)
+        while scan.running:
+            sleep(.5)
+        return scan
+
+    def _start(self, scan: SubnetScanner):
+        t = threading.Thread(target=scan.start)
+        t.start()
+        return t

lanscape/libraries/version_manager.py

@@ -0,0 +1,56 @@
+import logging
+import requests
+import traceback
+from importlib.metadata import version, PackageNotFoundError
+from random import randint
+
+from .app_scope import is_local_run
+
+log = logging.getLogger('VersionManager')
+
+PACKAGE = 'lanscape'
+LOCAL_VERSION = '0.0.0'
+
+latest = None  # used to 'remember' pypi version each runtime
+
+
+def is_update_available(package=PACKAGE) -> bool:
+    installed = get_installed_version(package)
+    available = lookup_latest_version(package)
+
+    is_update_exempt = (
+        'a' in installed, 'b' in installed,  # pre-release
+        installed == LOCAL_VERSION
+    )
+    if any(is_update_exempt):
+        return False
+
+    log.debug(f'Installed: {installed} | Available: {available}')
+    return installed != available
+
+
+def lookup_latest_version(package=PACKAGE):
+    # Fetch the latest version from PyPI
+    global latest
+    if not latest:
+        no_cache = f'?cachebust={randint(0, 6969)}'
+        url = f"https://pypi.org/pypi/{package}/json{no_cache}"
+        try:
+            response = requests.get(url, timeout=5)
+            response.raise_for_status()  # Raise an exception for HTTP errors
+            latest = response.json()['info']['version']
+            log.debug(f'Latest pypi version: {latest}')
+        except BaseException:
+            log.debug(traceback.format_exc())
+            log.warning('Unable to fetch package version from PyPi')
+    return latest
+
+
+def get_installed_version(package=PACKAGE):
+    if not is_local_run():
+        try:
+            return version(package)
+        except PackageNotFoundError:
+            log.debug(traceback.format_exc())
+            log.warning(f'Cannot find {package} installation')
+    return LOCAL_VERSION

lanscape/libraries/web_browser.py

@@ -0,0 +1,142 @@
+"""
+Get the executable path of the system’s default web browser.
+
+Supports:
+  - Windows (reads from the registry)
+  - Linux   (uses xdg-mime / xdg-settings + .desktop file parsing)
+"""
+
+import sys
+import os
+import subprocess
+import webbrowser
+import logging
+import re
+import time
+from typing import Optional
+
+log = logging.getLogger('WebBrowser')
+
+
+def open_webapp(url: str) -> bool:
+    """
+    will try to open the web page as an app
+    on failure, will open as a tab in default browser
+
+    returns:
+    """
+    start = time.time()
+    try:
+        exe = get_default_browser_executable()
+        if not exe:
+            raise RuntimeError('Unable to find browser binary')
+        log.debug(f'Opening {url} with {exe}')
+
+        cmd = f'"{exe}" --app="{url}"'
+        subprocess.run(cmd, check=True, shell=True)
+
+        if time.time() - start < 2:
+            log.debug(
+                f'Unable to hook into closure of UI, listening for flask shutdown')
+            return False
+        return True
+
+    except Exception as e:
+        log.warning(
+            'Failed to open webpage as app, falling back to browser tab')
+        log.debug(f'As app error: {e}')
+        try:
+            success = webbrowser.open(url)
+            log.debug(f'Opened {url} in browser tab: {success}')
+            if not success:
+                raise RuntimeError('Unknown error while opening browser tab')
+        except Exception as e:
+            log.warning(
+                f'Exhausted all options to open browser, you need to open manually')
+            log.debug(f'As tab error: {e}')
+            log.info(f'LANScape UI is running on {url}')
+    return False
+
+
+def get_default_browser_executable() -> Optional[str]:
+    if sys.platform.startswith("win"):
+        try:
+            import winreg
+            # On Windows the HKEY_CLASSES_ROOT\http\shell\open\command key
+            # holds the command for opening HTTP URLs.
+            with winreg.OpenKey(winreg.HKEY_CLASSES_ROOT, r"http\shell\open\command") as key:
+                cmd, _ = winreg.QueryValueEx(key, None)
+        except Exception:
+            return None
+
+        # cmd usually looks like: '"C:\\Program Files\\Foo\\foo.exe" %1'
+        m = re.match(r'\"?(.+?\.exe)\"?', cmd)
+        return m.group(1) if m else None
+
+    elif sys.platform.startswith("linux"):
+        # First, find the .desktop file name
+        desktop_file = None
+        try:
+            # Try xdg-mime
+            p = subprocess.run(
+                ["xdg-mime", "query", "default", "x-scheme-handler/http"],
+                capture_output=True, text=True,
+                check=True
+            )
+            desktop_file = p.stdout.strip()
+        except subprocess.CalledProcessError:
+            pass
+
+        if not desktop_file:
+            # Fallback to xdg-settings
+            try:
+                p = subprocess.run(
+                    ["xdg-settings", "get", "default-web-browser"],
+                    capture_output=True, text=True,
+                    check=True
+                )
+                desktop_file = p.stdout.strip()
+            except subprocess.CalledProcessError:
+                pass
+
+        # Final fallback: BROWSER environment variable
+        if not desktop_file:
+            return os.environ.get("BROWSER")
+
+        # Look for that .desktop file in standard locations
+        search_paths = [
+            os.path.expanduser("~/.local/share/applications"),
+            "/usr/local/share/applications",
+            "/usr/share/applications",
+        ]
+        for path in search_paths:
+            full_path = os.path.join(path, desktop_file)
+            if os.path.isfile(full_path):
+                with open(full_path, encoding="utf-8", errors="ignore") as f:
+                    for line in f:
+                        if line.startswith("Exec="):
+                            exec_cmd = line[len("Exec="):].strip()
+                            # strip arguments like “%u”, “--flag”, etc.
+                            exec_cmd = exec_cmd.split()[0]
+                            exec_cmd = exec_cmd.split("%")[0]
+            return exec_cmd
+        return None
+
+    elif sys.platform.startswith("darwin"):
+        # macOS: try to find Chrome first for app mode support, fallback to default
+        try:
+            p = subprocess.run(
+                ["mdfind", "kMDItemCFBundleIdentifier == 'com.google.Chrome'"],
+                capture_output=True, text=True, check=True
+            )
+            chrome_paths = p.stdout.strip().split('\n')
+            if chrome_paths and chrome_paths[0]:
+                return f"{chrome_paths[0]}/Contents/MacOS/Google Chrome"
+        except subprocess.CalledProcessError:
+            pass
+
+        # Fallback to system default
+        return "/usr/bin/open"
+
+    else:
+        raise NotImplementedError(f"Unsupported platform: {sys.platform!r}")