lanscape 1.3.4__tar.gz → 1.3.5a1__tar.gz

{lanscape-1.3.4/lanscape.egg-info → lanscape-1.3.5a1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lanscape
-Version: 1.3.4
+Version: 1.3.5a1
 Summary: A python based local network scanner
 Author-email: Michael Dennis <michael@dipduo.com>
 License-Expression: MIT

{lanscape-1.3.4 → lanscape-1.3.5a1}/lanscape/libraries/net_tools.py

@@ -1,5 +1,4 @@
 import logging
-import platform
 import ipaddress
 import traceback
 import subprocess
@@ -28,6 +27,9 @@ log = logging.getLogger('NetTools')
 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(
@@ -95,11 +97,21 @@ class IPAlive(JobStatsMixin):
                 self.caught_errors.append(DeviceError(e))
                 # Fallback to system ping command
                 try:
-                    cmd = ["ping", "-c", str(cfg.ping_count), "-W", str(cfg.timeout), ip] if not psutil.WINDOWS else \
-                          ["ping", "-n", str(cfg.ping_count), "-w", str(cfg.timeout * 1000), ip]
-                    result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+                    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 Exception as fallback_error:
+                except subprocess.CalledProcessError as fallback_error:
                     self.caught_errors.append(DeviceError(fallback_error))
                     return False
 
@@ -117,6 +129,7 @@ class IPAlive(JobStatsMixin):
 
 class Device(IPAlive):
     """Represents a network device with metadata and scanning capabilities."""
+
     def __init__(self, ip: str):
         super().__init__()
         self.ip: str = ip
@@ -245,7 +258,7 @@ def get_ip_address(interface: str):
     def unix_like():  # Combined Linux and macOS
         try:
             # pylint: disable=import-outside-toplevel, import-error
-            import fcntl 
+            import fcntl
             sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
             ip_address = socket.inet_ntoa(fcntl.ioctl(
                 sock.fileno(),
@@ -280,7 +293,7 @@ def get_netmask(interface: str):
     def unix_like():  # Combined Linux and macOS
         try:
             # pylint: disable=import-outside-toplevel, import-error
-            import fcntl 
+            import fcntl
             sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
             netmask = socket.inet_ntoa(fcntl.ioctl(
                 sock.fileno(),

{lanscape-1.3.4 → lanscape-1.3.5a1}/lanscape/libraries/runtime_args.py

@@ -1,3 +1,5 @@
+"""Runtime argument handler for LANscape as module"""
+
 from dataclasses import dataclass, fields
 import argparse
 from typing import Any, Dict, Optional
@@ -5,6 +7,7 @@ from typing import Any, Dict, Optional
 
 @dataclass
 class RuntimeArgs:
+    """Class representing runtime arguments for the application."""
     reloader: bool = False
     port: int = 5001
     logfile: Optional[str] = None
@@ -14,6 +17,9 @@ class RuntimeArgs:
 
 
 def parse_args() -> RuntimeArgs:
+    """
+    Parse command line arguments and return a RuntimeArgs instance.
+    """
     parser = argparse.ArgumentParser(description='LANscape')
 
     parser.add_argument('--reloader', action='store_true',
@@ -27,6 +33,8 @@ def parse_args() -> RuntimeArgs:
                         help='Enable flask logging (disables click output)')
     parser.add_argument('--persistent', action='store_true',
                         help='Don\'t exit after browser is closed')
+    parser.add_argument('--debug', action='store_true',
+                        help='Shorthand debug mode (equivalent to "--loglevel DEBUG --reloader")')
 
     # Parse the arguments
     args = parser.parse_args()
@@ -37,6 +45,10 @@ def parse_args() -> RuntimeArgs:
     field_names = {field.name for field in fields(
         RuntimeArgs)}  # Get dataclass field names
 
+    if args.debug:
+        args_dict['loglevel'] = 'DEBUG'
+        args_dict['reloader'] = True
+
     # Only pass arguments that exist in the Args dataclass
     filtered_args = {name: args_dict[name]
                      for name in field_names if name in args_dict}

{lanscape-1.3.4 → lanscape-1.3.5a1}/lanscape/libraries/scan_config.py

@@ -1,8 +1,9 @@
-from typing import List
+from typing import List, Dict
 import ipaddress
 from pydantic import BaseModel, Field
 from enum import Enum
 
+
 from lanscape.libraries.port_manager import PortManager
 from lanscape.libraries.ip_parser import parse_ip_input
 
@@ -82,7 +83,9 @@ class ScanConfig(BaseModel):
         return cls.model_validate(data)
 
     def to_dict(self) -> dict:
-        return self.model_dump()
+        dump = self.model_dump()
+        dump['lookup_type'] = self.lookup_type.value
+        return dump
 
     def get_ports(self) -> List[int]:
         return PortManager().get_port_list(self.port_list).keys()
@@ -95,3 +98,48 @@ class ScanConfig(BaseModel):
         b = f'ports={self.port_list}'
         c = f'scan_type={self.lookup_type.value}'
         return f'ScanConfig({a}, {b}, {c})'
+
+
+DEFAULT_CONFIGS: Dict[str, ScanConfig] = {
+    'balanced': ScanConfig(subnet='', port_list='medium'),
+    'accurate': ScanConfig(
+        subnet='',
+        port_list='large',
+        t_cnt_port_scan=5,
+        t_cnt_port_test=64,
+        t_cnt_isalive=64,
+        task_scan_ports=True,
+        task_scan_port_services=False,
+        lookup_type=ScanType.BOTH,
+        arp_config=ArpConfig(
+            attempts=3,
+            timeout=2.5
+        ),
+        ping_config=PingConfig(
+            attempts=3,
+            ping_count=2,
+            timeout=1.5,
+            retry_delay=0.5
+        )
+    ),
+    'fast': ScanConfig(
+        subnet='',
+        port_list='small',
+        t_cnt_port_scan=20,
+        t_cnt_port_test=256,
+        t_cnt_isalive=512,
+        task_scan_ports=True,
+        task_scan_port_services=False,
+        lookup_type=ScanType.BOTH,
+        arp_config=ArpConfig(
+            attempts=1,
+            timeout=1.0
+        ),
+        ping_config=PingConfig(
+            attempts=1,
+            ping_count=1,
+            timeout=0.5,
+            retry_delay=0.25
+        )
+    )
+}

{lanscape-1.3.4 → lanscape-1.3.5a1}/lanscape/libraries/web_browser.py

@@ -60,18 +60,8 @@ def open_webapp(url: str) -> bool:
 
 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
+        return windows_get_browser_from_registry()
 
-        # 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
@@ -140,3 +130,64 @@ def get_default_browser_executable() -> Optional[str]:
 
     else:
         raise NotImplementedError(f"Unsupported platform: {sys.platform!r}")
+
+
+def windows_get_browser_from_registry() -> Optional[str]:
+    """Get the default web browser executable path on Windows."""
+
+    import winreg # pylint: disable=import-outside-toplevel
+
+    def get_reg(base, path, key=None):
+        """Helper function to read a registry key."""
+        try:
+            with winreg.OpenKey(base, path) as reg:
+                return winreg.QueryValueEx(reg, key)[0]
+        except FileNotFoundError:
+            return None
+
+    def extract_executable(cmd: str) -> Optional[str]:
+        """Extract the executable path from a command string."""
+        match = re.match(r'"?([^"]+)"?', cmd)
+        return match.group(1) if match else None
+
+    def get_user_preferred_browser():
+        """Get the user preferred browser from the registry."""
+        progid = get_reg(
+            winreg.HKEY_CURRENT_USER,
+            r'Software\Microsoft\Windows\Shell\Associations\UrlAssociations\http\UserChoice',
+            'ProgId'
+        )
+        if not progid:
+            log.debug('No user preferred browser found in registry')
+            return None
+
+        browser_path = get_reg(
+            winreg.HKEY_CLASSES_ROOT,
+            f'{progid}\\shell\\open\\command'
+        )
+
+        if not browser_path:
+            log.debug(f'progid {progid} does not have a command in registry')
+            return None
+
+        return extract_executable(browser_path)
+
+    def get_system_default_browser():
+        """Get the system default browser from the registry."""
+        reg = get_reg(
+            winreg.HKEY_CLASSES_ROOT,
+            r'http\shell\open\command'
+        )
+        if not reg:
+            log.debug('No system default browser found in registry')
+            return None
+
+        return extract_executable(reg)
+
+    user_browser = get_user_preferred_browser()
+    if user_browser:
+        return extract_executable(user_browser)
+
+    system_browser = get_system_default_browser()
+    if system_browser:
+        return extract_executable(system_browser)

{lanscape-1.3.4 → lanscape-1.3.5a1}/lanscape/ui/app.py

@@ -1,13 +1,15 @@
-from flask import Flask, render_template, request
+
 import traceback
 import threading
 import logging
-import os
-
+from flask import Flask, render_template
+from lanscape.ui.blueprints.web import web_bp, routes # pylint: ignore=unused-import
+from lanscape.ui.blueprints.api import api_bp, tools, port, scan # pylint: ignore=unused-import
 from lanscape.libraries.runtime_args import RuntimeArgs, parse_args
 from lanscape.libraries.version_manager import is_update_available, get_installed_version, lookup_latest_version
 from lanscape.libraries.app_scope import is_local_run
 from lanscape.libraries.net_tools import is_arp_supported
+from lanscape.ui.shutdown_handler import FlaskShutdownHandler
 
 app = Flask(
     __name__
@@ -15,9 +17,7 @@ app = Flask(
 log = logging.getLogger('flask')
 
 # Import and register BPs
-################################
-from lanscape.ui.blueprints.api import api_bp, tools, port, scan
-from lanscape.ui.blueprints.web import web_bp, routes
+#################################
 
 app.register_blueprint(api_bp)
 app.register_blueprint(web_bp)
@@ -65,32 +65,8 @@ set_global_safe('is_arp_supported', is_arp_supported)
 # External hook to kill flask server
 ################################
 
-exiting = False
-
-
-@app.route("/shutdown", methods=['GET', 'POST'])
-def exit_app():
-
-    req_type = request.args.get('type')
-    if req_type == 'browser-close':
-        args = parse_args()
-        if args.persistent:
-            log.info('Dectected browser close, not exiting flask.')
-            return "Ignored"
-        log.info('Web browser closed, terminating flask. (disable with --peristent)')
-    elif req_type == 'core':
-        log.info('Core requested exit, terminating flask.')
-    else:
-        log.info('Received external exit request. Terminating flask.')
-    global exiting
-    exiting = True
-    return "Done"
-
-
-@app.teardown_request
-def teardown(exception):
-    if exiting:
-        os._exit(0)
+shutdown_handler = FlaskShutdownHandler(app)
+shutdown_handler.register_endpoints()
 
 # Generalized error handling
 ################################
@@ -111,14 +87,16 @@ def internal_error(e):
 
 
 def start_webserver_daemon(args: RuntimeArgs) -> threading.Thread:
+    """Start the web server in a daemon thread."""
     proc = threading.Thread(target=start_webserver, args=(args,))
     proc.daemon = True  # Kill thread when main thread exits
     proc.start()
-    log.info('Flask server initializing as dameon')
+    log.info('Flask server initializing as daemon')
     return proc
 
 
 def start_webserver(args: RuntimeArgs) -> int:
+    """Start webserver (blocking)"""
     run_args = {
         'host': '0.0.0.0',
         'port': args.port,

{lanscape-1.3.4 → lanscape-1.3.5a1}/lanscape/ui/blueprints/api/scan.py

@@ -68,8 +68,4 @@ def get_scan_config():
     pulls config from the request body
     """
     data = request.get_json()
-    return ScanConfig(
-        subnet=data['subnet'],
-        port_list=data['port_list'],
-        t_multiplier=data.get('parallelism', 1.0)
-    )
+    return ScanConfig.from_dict(data)

{lanscape-1.3.4 → lanscape-1.3.5a1}/lanscape/ui/blueprints/api/tools.py

@@ -1,9 +1,14 @@
+"""
+API endpoints for subnet testing and listing.
+"""
+
+import traceback
 from flask import request, jsonify
 from lanscape.ui.blueprints.api import api_bp
 from lanscape.libraries.net_tools import get_all_network_subnets
 from lanscape.libraries.ip_parser import parse_ip_input
 from lanscape.libraries.errors import SubnetTooLargeError
-import traceback
+from lanscape.libraries.scan_config import DEFAULT_CONFIGS
 
 
 @api_bp.route('/api/tools/subnet/test')
@@ -34,3 +39,13 @@ def list_subnet():
         return jsonify(get_all_network_subnets())
     except BaseException:
         return jsonify({'error': traceback.format_exc()})
+
+
+@api_bp.route('/api/tools/config/defaults')
+def get_default_configs():
+    """
+    Get default scan configurations.
+    """
+    return jsonify(
+        {key: config.to_dict() for key, config in DEFAULT_CONFIGS.items()}
+    )

{lanscape-1.3.4 → lanscape-1.3.5a1}/lanscape/ui/blueprints/web/routes.py

@@ -16,12 +16,10 @@ def index():
     subnet = smart_select_primary_subnet(subnets)
 
     port_list = 'medium'
-    parallelism = 1
     if scan_id := request.args.get('scan_id'):
         if scan := scan_manager.get_scan(scan_id):
             subnet = scan.cfg.subnet
             port_list = scan.cfg.port_list
-            parallelism = scan.cfg.t_multiplier
 
         else:
             log.debug(f'Redirecting, scan {scan_id} doesnt exist in memory')
@@ -30,7 +28,6 @@ def index():
         'main.html',
         subnet=subnet,
         port_list=port_list,
-        parallelism=parallelism,
         alternate_subnets=subnets
     )
 

{lanscape-1.3.4 → lanscape-1.3.5a1}/lanscape/ui/main.py

@@ -7,8 +7,10 @@ import time
 import logging
 import traceback
 import os
+import requests
+
 from lanscape.libraries.logger import configure_logging
-from lanscape.libraries.runtime_args import parse_args, RuntimeArgs
+from lanscape.libraries.runtime_args import parse_args
 from lanscape.libraries.web_browser import open_webapp
 from lanscape.libraries.net_tools import is_arp_supported
 from lanscape.libraries.version_manager import get_installed_version, is_update_available
@@ -25,6 +27,7 @@ IS_FLASK_RELOAD = os.environ.get("WERKZEUG_RUN_MAIN")
 
 
 def main():
+    """core entry point for running lanscape as a module."""
     try:
         _main()
     except KeyboardInterrupt:
@@ -47,10 +50,15 @@ def _main():
     args.port = get_valid_port(args.port)
 
     if not is_arp_supported():
-        log.warning('ARP is not supported, device discovery is degraded. For more information, see the help guide: https://github.com/mdennis281/LANscape/blob/main/support/arp-issues.md')
+        warn = (
+            'ARP is not supported, device discovery is degraded. ',
+            'For more information, see the help guide: ',
+            'https://github.com/mdennis281/LANscape/blob/main/support/arp-issues.md'
+        )
+        log.warning(''.join(warn))
 
     try:
-        start_webserver_ui(args)
+        start_webserver_ui()
         log.info('Exiting...')
     except Exception as e:
         # showing error in debug only because this is handled gracefully
@@ -60,6 +68,7 @@ def _main():
 
 
 def try_check_update():
+    """Check for updates and log if available."""
     try:
         if is_update_available():
             log.info('An update is available!')
@@ -86,7 +95,8 @@ def open_browser(url: str, wait=2) -> bool:
     return False
 
 
-def start_webserver_ui(args: RuntimeArgs):
+def start_webserver_ui():
+    """Start the web server and open the UI in a browser."""
     uri = f'http://127.0.0.1:{args.port}'
 
     # running reloader requires flask to run in main thread
@@ -128,9 +138,9 @@ def get_valid_port(port: int):
 
 
 def terminate():
-    import requests
+    """send a request to the shutdown flask"""
     log.info('Attempting flask shutdown')
-    requests.get(f'http://127.0.0.1:{args.port}/shutdown?type=core')
+    requests.get(f'http://127.0.0.1:{args.port}/shutdown?type=core', timeout=2)
 
 
 if __name__ == "__main__":

lanscape-1.3.5a1/lanscape/ui/shutdown_handler.py

@@ -0,0 +1,53 @@
+import logging
+import os
+from flask import request
+
+
+from lanscape.libraries.runtime_args import parse_args
+
+
+log = logging.getLogger('shutdown_handler')
+
+
+class FlaskShutdownHandler:
+    """Handles shutdown requests for the Flask application.
+    """
+
+    def __init__(self, app):
+        self.app = app
+        self._exiting = False
+
+    def register_endpoints(self):
+        """Register shutdown endpoints to the Flask app."""
+
+        @self.app.route('/shutdown', methods=['POST', 'GET'])
+        def shutdown():
+            req_type = request.args.get('type')
+            self.shutdown_request(req_type)
+            return "Done"
+
+        @self.app.teardown_request
+        def teardown(_):
+            self.exit_if_requested()
+
+    def shutdown_request(self, req_type: str):
+        """Handles shutdown requests based on the type of request.
+        Args:
+            req_type (str): The type of shutdown request.
+        """
+        if req_type == 'browser-close':
+            args = parse_args()
+            if args.persistent:
+                log.info('Detected browser close, not exiting flask.')
+                return "Ignored"
+            log.info('Web browser closed, terminating flask. (disable with --persistent)')
+        elif req_type == 'core':
+            log.info('Core requested exit, terminating flask.')
+        else:
+            log.info('Received external exit request. Terminating flask.')
+        self._exiting = True
+
+    def exit_if_requested(self):
+        """Exits the application if a shutdown request has been made."""
+        if self._exiting:
+            os._exit(0)