lanscape 1.2.10a1__tar.gz → 1.3.0__tar.gz

{lanscape-1.2.10a1/src/lanscape.egg-info → lanscape-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lanscape
-Version: 1.2.10a1
+Version: 1.3.0
 Summary: A python based local network scanner
 Author-email: Michael Dennis <michael@dipduo.com>
 Project-URL: Homepage, https://github.com/mdennis281/py-lanscape
@@ -32,11 +32,12 @@ python -m lanscape
 ```
 
 ## Flags
- - `--port <port number>` port of the flask app (default: 5001)
+ - `--port <port number>` port of the flask app (default: automagic)
+ - `--persistent` dont shutdown server when browser tab is closed (default: false)
  - `--reloader` essentially flask debug mode- good for local development (default: false)
  - `--logfile` save log output to lanscape.log
  - `--loglevel <level>` set the logger's log level (default: INFO)
- 
+ - `--flask-logging` turn on flask logging (default: false)
 
 Examples:
 ```shell
@@ -55,6 +56,14 @@ can sometimes require admin-level permissions to retrieve accurate results.
 ### Message "WARNING: No libpcap provider available ! pcap won't be used"
 This is a missing dependency related to the ARP lookup. This is handled in the code, but you would get marginally faster/better results with this installed: [npcap download](https://npcap.com/#download)
 
+### The accuracy of the devices found is low
+I use a combination of ARP and Ping to determine if a device is online. This method drops in stability when used in many threads. 
+Recommendations:
+
+  - Drop parallelism value (advanced dropdown)
+  - Use python > 3.10 im noticing threadpool improvements after this version
+  - Create a bug - I'm curious
+
 
 ### Something else
 Feel free to submit a github issue detailing your experience.

{lanscape-1.2.10a1 → lanscape-1.3.0}/README.md

@@ -10,11 +10,12 @@ python -m lanscape
 ```
 
 ## Flags
- - `--port <port number>` port of the flask app (default: 5001)
+ - `--port <port number>` port of the flask app (default: automagic)
+ - `--persistent` dont shutdown server when browser tab is closed (default: false)
  - `--reloader` essentially flask debug mode- good for local development (default: false)
  - `--logfile` save log output to lanscape.log
  - `--loglevel <level>` set the logger's log level (default: INFO)
- 
+ - `--flask-logging` turn on flask logging (default: false)
 
 Examples:
 ```shell
@@ -33,6 +34,14 @@ can sometimes require admin-level permissions to retrieve accurate results.
 ### Message "WARNING: No libpcap provider available ! pcap won't be used"
 This is a missing dependency related to the ARP lookup. This is handled in the code, but you would get marginally faster/better results with this installed: [npcap download](https://npcap.com/#download)
 
+### The accuracy of the devices found is low
+I use a combination of ARP and Ping to determine if a device is online. This method drops in stability when used in many threads. 
+Recommendations:
+
+  - Drop parallelism value (advanced dropdown)
+  - Use python > 3.10 im noticing threadpool improvements after this version
+  - Create a bug - I'm curious
+
 
 ### Something else
 Feel free to submit a github issue detailing your experience.

{lanscape-1.2.10a1 → lanscape-1.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lanscape"
-version = "1.2.10a1"
+version = "1.3.0"
 authors = [
   { name="Michael Dennis", email="michael@dipduo.com" },
 ]

lanscape-1.3.0/src/lanscape/libraries/errors.py

@@ -0,0 +1,29 @@
+
+
+class SubnetTooLargeError(Exception):
+    """Custom exception raised when the subnet size exceeds the allowed limit."""
+    def __init__(self, subnet):
+        self.subnet = subnet
+        super().__init__(f"Subnet {subnet} exceeds the limit of IP addresses.")
+
+
+class SubnetScanTerminationFailure(Exception):
+    def __init__(self,running_threads):
+        super().__init__(f'Unable to terminate active threads: {running_threads}')
+
+class DeviceError(Exception):
+    def __init__(self, e:Exception):
+        self.base: Exception = e
+        self.method = self._attempt_extract_method()
+    
+    def _attempt_extract_method(self):
+        try:
+            tb = self.base.__traceback__
+            frame = tb.tb_frame
+            return frame.f_code.co_name
+        except Exception as e:
+            print(e)
+            return 'unknown'
+        
+    def __str__(self):
+        return f'Error(source={self.method}, msg={self.base})'

{lanscape-1.2.10a1 → lanscape-1.3.0}/src/lanscape/libraries/logger.py

@@ -3,7 +3,7 @@ from logging.handlers import RotatingFileHandler
 import click
 
 
-def configure_logging(loglevel:str, logfile:bool):
+def configure_logging(loglevel:str, logfile:bool, flask_logging:bool=False) -> None:
     numeric_level = getattr(logging, loglevel.upper(), None)
     if not isinstance(numeric_level, int):
         raise ValueError(f'Invalid log level: {loglevel}')
@@ -12,7 +12,7 @@ def configure_logging(loglevel:str, logfile:bool):
     logging.basicConfig(level=numeric_level, format='[%(name)s] %(levelname)s - %(message)s')
 
     # flask spams too much on info
-    if numeric_level > logging.DEBUG:
+    if not flask_logging:
         disable_flask_logging()
     
     if logfile:

{lanscape-1.2.10a1 → lanscape-1.3.0}/src/lanscape/libraries/net_tools.py

@@ -10,58 +10,92 @@ import subprocess
 from time import sleep
 from typing import List, Dict
 from scapy.all import ARP, Ether, srp
+from concurrent.futures import ThreadPoolExecutor, as_completed
 
 from .service_scan import scan_service
 from .mac_lookup import lookup_mac, get_macs
 from .ip_parser import get_address_count, MAX_IPS_ALLOWED
+from .errors import DeviceError
 
 log = logging.getLogger('NetTools')
 
 
 class IPAlive:
-    
-    def is_alive(self,ip:str) -> bool:
-        try:
-            self.alive = self._arp_lookup(ip)
-        except:
-            self.log.debug('failed ARP, falling back to ping')
-            self.alive = self._ping_lookup(ip)
-
-        return self.alive
-
-    def _arp_lookup(self,ip,timeout=4):
-        arp_request = ARP(pdst=ip)
-        broadcast = Ether(dst="ff:ff:ff:ff:ff:ff")
-        arp_request_broadcast = broadcast / arp_request
+    caught_errors: List[DeviceError] = []
 
-        # Send the packet and receive the response
-        answered, _ = srp(arp_request_broadcast, timeout=timeout, verbose=False)
-
-        for sent, received in answered:
-            if received.psrc == ip:
-                return True
+    def is_alive(self, ip: str) -> bool:
+        """
+        Run ARP and ping in parallel. As soon as one returns True, we shut
+        down the executor (without waiting) and return True. Exceptions
+        from either lookup are caught and treated as False.
+        """
+        executor = ThreadPoolExecutor(max_workers=2)
+        futures = [
+            executor.submit(self._arp_lookup,  ip),
+            executor.submit(self._ping_lookup, ip),
+        ]
+
+        for future in as_completed(futures):
+            try:
+                if future.result():
+                    # one check succeeded — don't block on the other
+                    # Cancel remaining futures in a version-compatible way
+                    for f in futures:
+                        if not f.done():
+                            f.cancel()
+                    
+                    executor.shutdown(wait=False)  # Python 3.8 compatible
+                    return True
+            except Exception as e:
+                # treat any error as a False response
+                log.debug(f'Error while checking {ip}: {e}')
+                self.caught_errors.append(DeviceError(e))
+
+
+        # neither check found the host alive
+        executor.shutdown()
         return False
 
-    def _ping_lookup(self,host, retries=1, retry_delay=1, ping_count=2, timeout=2):
-            """
-            Ping the given host and return True if it's reachable, False otherwise.
-            """
-            os = platform.system().lower()
-            if os == "windows":
-                ping_command = ['ping', '-n', str(ping_count), '-w', str(timeout*1000)]  
-            else:
-                ping_command = ['ping', '-c', str(ping_count), '-W', str(timeout)]
-                
-            for _ in range(retries):
-                try:
-                    output = subprocess.check_output(ping_command + [host], stderr=subprocess.STDOUT, universal_newlines=True)
-                    # Check if 'TTL' or 'time' is in the output to determine success
-                    if 'TTL' in output.upper():
-                        return True
-                except subprocess.CalledProcessError:
-                    pass  # Ping failed
+    def _arp_lookup(self, ip: str, timeout: int = 3) -> bool:
+        arp_request = ARP(pdst=ip)
+        broadcast   = Ether(dst="ff:ff:ff:ff:ff:ff")
+        packet      = broadcast / arp_request
+
+        answered, _ = srp(packet, timeout=timeout, verbose=False)
+        return any(resp.psrc == ip for _, resp in answered)
+
+    def _ping_lookup(
+        self, host: str,
+        retries: int = 1,
+        retry_delay: int = .25,
+        ping_count: int = 2,
+        timeout: int = 2
+    ) -> bool:
+        cmd = []
+        os_name = platform.system().lower()
+        if os_name == "windows":
+            # -n count, -w timeout in ms
+            cmd = ['ping', '-n', str(ping_count), '-w', str(timeout*1000)]
+        else:
+            # -c count, -W timeout in s
+            cmd = ['ping', '-c', str(ping_count), '-W', str(timeout)]
+
+        for r in range(retries):
+            try:
+                output = subprocess.check_output(
+                    cmd + [host],
+                    stderr=subprocess.STDOUT,
+                    universal_newlines=True
+                )
+                # Windows/Linux both include “TTL” on a successful reply
+                if 'TTL' in output.upper():
+                    return True
+            except subprocess.CalledProcessError as e:
+                self.caught_errors.append(DeviceError(e))
+                pass
+            if r < retries - 1:
                 sleep(retry_delay)
-            return False
+        return False
     
 
 
@@ -75,6 +109,7 @@ class Device(IPAlive):
         self.ports: List[int] = []
         self.stage: str = 'found'
         self.services: Dict[str,List[int]] = {}
+        self.caught_errors: List[DeviceError] = []
         self.log = logging.getLogger('Device')
 
     def get_metadata(self):
@@ -128,7 +163,8 @@ class Device(IPAlive):
         try:
             hostname = socket.gethostbyaddr(self.ip)[0]
             return hostname
-        except socket.herror:
+        except socket.herror as e:
+            self.caught_errors.append(DeviceError(e))
             return None
         
     def _get_manufacturer(self,mac_addr=None):

{lanscape-1.2.10a1 → lanscape-1.3.0}/src/lanscape/libraries/runtime_args.py

@@ -9,6 +9,8 @@ class RuntimeArgs:
     port: int = 5001
     logfile: bool = False
     loglevel: str = 'INFO'
+    flask_logging: bool = False
+    persistent: bool = False
 
 def parse_args() -> RuntimeArgs:
     parser = argparse.ArgumentParser(description='LANscape')
@@ -17,6 +19,8 @@ def parse_args() -> RuntimeArgs:
     parser.add_argument('--port', type=int, default=5001, help='Port to run the webserver on')
     parser.add_argument('--logfile', action='store_true', help='Log output to lanscape.log')
     parser.add_argument('--loglevel', default='INFO', help='Set the log level')
+    parser.add_argument('--flask-logging', action='store_true', help='Enable flask logging (disables click output)')
+    parser.add_argument('--persistent', action='store_true', help='Don\'t exit after browser is closed')
 
     # Parse the arguments
     args = parser.parse_args()

{lanscape-1.2.10a1 → lanscape-1.3.0}/src/lanscape/libraries/subnet_scan.py

@@ -10,7 +10,7 @@ from time import sleep
 from typing import List, Union
 from tabulate import tabulate
 from dataclasses import dataclass
-from concurrent.futures import ThreadPoolExecutor
+from concurrent.futures import ThreadPoolExecutor, as_completed
 
 from .net_tools import Device
 from .ip_parser import parse_ip_input
@@ -57,6 +57,9 @@ class ScanConfig:
     
     def parse_subnet(self) -> List[ipaddress.IPv4Network]:
         return parse_ip_input(self.subnet)
+    
+    def __str__(self):
+        return f'ScanCfg(subnet={self.subnet}, ports={self.port_list}, multiplier={self.t_multiplier})'
 
 
 
@@ -91,7 +94,7 @@ class SubnetScanner:
         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 futures:
+            for future in as_completed(futures):
                 ip = futures[future]
                 try:
                     future.result()
@@ -183,12 +186,11 @@ class SubnetScanner:
         Get the MAC address and open ports of the given host.
         """
         device = Device(host)
-        is_alive = self._ping(device)
+        device.alive = self._ping(device)
         self.results.scanned()
-        if not is_alive:
+        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
@@ -290,7 +292,7 @@ class ScannerResults:
         out['devices'] = [device.dict() for device in sortedDevices]
 
         if out_type == str:
-            return json.dumps(out, indent=2)
+            return json.dumps(out,default=str, indent=2)
         # otherwise return dict
         return out
     
@@ -317,44 +319,53 @@ class ScannerResults:
 class ScanManager:
     """
     Maintain active and completed scans in memory for 
-    future reference
+    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):
-        self.scans: List[SubnetScanner] = []
+        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:
+    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
+        Terminate all active scans
         """
         for scan in self.scans:
             if scan.running:
                 scan.terminate()
 
-    def wait_until_complete(self,scan_id:str) -> SubnetScanner:
+    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):
+    def _start(self, scan: SubnetScanner):
         t = threading.Thread(target=scan.start)
         t.start()
         return t
-    
 
 
     

{lanscape-1.2.10a1 → lanscape-1.3.0}/src/lanscape/libraries/version_manager.py

@@ -1,7 +1,7 @@
 import logging 
 import requests
 import traceback
-import pkg_resources
+from importlib.metadata import version, PackageNotFoundError
 from random import randint
 
 from .app_scope import is_local_run
@@ -16,10 +16,14 @@ 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)
-    if installed == LOCAL_VERSION: return False # local
-    if 'a' in installed: return False # alpha
-    if 'b' in installed: return False # beta
 
+    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):
@@ -41,8 +45,8 @@ def lookup_latest_version(package=PACKAGE):
 def get_installed_version(package=PACKAGE):
     if not is_local_run():
         try:
-            return pkg_resources.get_distribution(package).version
-        except:
+            return version(package)
+        except PackageNotFoundError:
             log.debug(traceback.format_exc())
             log.warning(f'Cannot find {package} installation')
     return LOCAL_VERSION

lanscape-1.3.0/src/lanscape/libraries/web_browser.py

@@ -0,0 +1,124 @@
+#!/usr/bin/env python3
+"""
+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
+from ..ui.app import app
+
+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}')
+
+        subprocess.run(f'{exe} --app="{url}"')
+
+        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
+
+    else:
+        raise NotImplementedError(f"Unsupported platform: {sys.platform!r}")

{lanscape-1.2.10a1 → lanscape-1.3.0}/src/lanscape/tests/test_api.py

@@ -3,6 +3,7 @@ import json
 from ..ui.app import app
 from ..libraries.net_tools import get_network_subnet
 from ._helpers import right_size_subnet
+import time
 
 
 
@@ -143,7 +144,47 @@ class ApiTestCase(unittest.TestCase):
             self.assertIsNotNone(data.get('msg'))
             if count == -1:
                 self.assertFalse(data.get('valid'))
-            
+    
+    def test_scan_api(self):
+        """
+        Test the scan API endpoints
+        """
+        # Create a new scan
+        new_scan = {
+            'subnet': right_size_subnet(get_network_subnet()),
+            'port_list': 'small',
+            'parallelism': 1
+        }
+        response = self.app.post('/api/scan', json=new_scan)
+        self.assertEqual(response.status_code, 200)
+        scan_info = json.loads(response.data)
+        self.assertEqual(scan_info['status'], 'running')
+        scan_id = scan_info['scan_id']
+        self.assertIsNotNone(scan_id)
+
+        percent_complete = 0
+        while percent_complete < 100:
+            # Get scan summary
+            response = self.app.get(f'/api/scan/{scan_id}/summary')
+            self.assertEqual(response.status_code, 200)
+            summary = json.loads(response.data)
+            self.assertTrue(summary['running'] or summary['stage'] == 'complete')
+            percent_complete = summary['percent_complete']
+            self.assertGreaterEqual(percent_complete, 0)
+            self.assertLessEqual(percent_complete, 100)
+            # Wait for a bit before checking again
+            time.sleep(2)
+        
+        self.assertEqual(summary['running'], False)
+        self.assertEqual(summary['stage'], 'complete')
+        self.assertGreater(summary['runtime'], 0)
+
+        devices_alive = summary['devices']['alive']
+        devices_scanned = summary['devices']['scanned']
+        devices_total = summary['devices']['total']
+
+        self.assertEqual(devices_scanned, devices_total)
+        self.assertGreater(devices_alive, 0)