lanscape 2.2.0a2__tar.gz → 2.3.0a1__tar.gz

{lanscape-2.2.0a2/lanscape.egg-info → lanscape-2.3.0a1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lanscape
-Version: 2.2.0a2
+Version: 2.3.0a1
 Summary: A python based local network scanner
 Author-email: Michael Dennis <michael@dipduo.com>
 License-Expression: MIT
@@ -25,12 +25,14 @@ Requires-Dist: scapy<3.0,>=2.3.2
 Requires-Dist: tabulate==0.9.0
 Requires-Dist: pydantic
 Requires-Dist: icmplib
-Requires-Dist: pwa-launcher>=0.3.0
+Requires-Dist: pwa-launcher>=1.1.0
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0; extra == "dev"
 Requires-Dist: pytest-cov>=5.0; extra == "dev"
 Requires-Dist: pytest-xdist>=3.0; extra == "dev"
 Requires-Dist: openai>=1.0.0; extra == "dev"
+Requires-Dist: pylint>=3.0; extra == "dev"
+Requires-Dist: autopep8>=2.0; extra == "dev"
 Dynamic: license-file
 
 # LANscape

{lanscape-2.2.0a2 → lanscape-2.3.0a1}/lanscape/core/net_tools.py

@@ -138,18 +138,29 @@ class Device(BaseModel):
         @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)
+                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:
-                    sock.close()
+                    # 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:

{lanscape-2.2.0a2 → lanscape-2.3.0a1}/lanscape/core/service_scan.py

@@ -154,7 +154,9 @@ def get_port_probes(port: int, strategy: ServiceScanStrategy):
 
 def scan_service(ip: str, port: int, cfg: ServiceScanConfig) -> str:
     """
-    Synchronous function that attempts to identify the service running on a given port.
+    Synchronous function that attempts to identify the service 
+    running on a given port.
+    TODO: This is AI slop and needs to be reworked properly.
     """
 
     async def _async_scan_service(
@@ -183,5 +185,38 @@ def scan_service(ip: str, port: int, cfg: ServiceScanConfig) -> str:
             log.debug(traceback.format_exc())
         return "Unknown"
 
-    # Use asyncio.run to execute the asynchronous logic synchronously
-    return asyncio.run(_async_scan_service(ip, port, cfg=cfg))
+    # Create and properly manage event loop to avoid file descriptor leaks
+    # Using new_event_loop + explicit close is safer in threaded environments
+    # than asyncio.run() which can leave resources open under heavy load
+    loop = None
+    try:
+        try:
+            # Try to get existing loop first (if running in async context)
+            loop = asyncio.get_running_loop()
+            # If we're already in an async context, just await directly
+            return asyncio.run_coroutine_threadsafe(
+                _async_scan_service(ip, port, cfg=cfg), loop
+            ).result(timeout=cfg.timeout + 5)
+        except RuntimeError:
+            # No running loop, create a new one
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            try:
+                return loop.run_until_complete(_async_scan_service(ip, port, cfg=cfg))
+            finally:
+                # Clean up the loop properly
+                try:
+                    # Cancel all remaining tasks
+                    pending = asyncio.all_tasks(loop)
+                    for task in pending:
+                        task.cancel()
+                    # Run loop once more to process cancellations
+                    if pending:
+                        loop.run_until_complete(asyncio.gather(*pending, return_exceptions=True))
+                except Exception:
+                    pass
+                finally:
+                    loop.close()
+    except Exception as e:
+        log.error(f"Event loop error scanning {ip}:{port}: {e}")
+        return "Unknown"

{lanscape-2.2.0a2 → lanscape-2.3.0a1}/lanscape/ui/blueprints/api/port.py

@@ -21,6 +21,20 @@ def get_port_lists():
     return jsonify(PortManager().get_port_lists())
 
 
+@api_bp.route('/api/port/list/summary', methods=['GET'])
+def get_port_lists_summary():
+    """Get port list names with their port counts."""
+    manager = PortManager()
+    summaries = []
+    for name in manager.get_port_lists():
+        ports = manager.get_port_list(name) or {}
+        summaries.append({
+            'name': name,
+            'count': len(ports)
+        })
+    return jsonify(summaries)
+
+
 @api_bp.route('/api/port/list/<port_list>', methods=['GET'])
 def get_port_list(port_list):
     """

{lanscape-2.2.0a2 → lanscape-2.3.0a1}/lanscape/ui/main.py

@@ -1,20 +1,19 @@
 """Main entry point for the LANscape application when running as a module."""
 import socket
 
-
-import threading
 import time
 import logging
 import traceback
 import os
-import requests
 from subprocess import Popen
+import webbrowser
+import requests
+
+from pwa_launcher import open_pwa, ChromiumNotFoundError
 
-from pwa_launcher import open_pwa
 
 from lanscape.core.logger import configure_logging
 from lanscape.core.runtime_args import parse_args
-from lanscape.core.web_browser import open_webapp
 from lanscape.core.version_manager import get_installed_version, is_update_available
 from lanscape.ui.app import start_webserver_daemon, start_webserver
 # do this so any logs generated on import are displayed
@@ -73,7 +72,7 @@ def try_check_update():
         log.warning('Unable to check for updates.')
 
 
-def open_browser(url: str, wait=2) -> Popen:
+def open_browser(url: str, wait=2) -> Popen | None:
     """
     Open a browser window to the specified
     url after waiting for the server to start
@@ -83,6 +82,12 @@ def open_browser(url: str, wait=2) -> Popen:
         log.info(f'Starting UI - http://127.0.0.1:{args.port}')
         return open_pwa(url)
 
+    except ChromiumNotFoundError:
+        success = webbrowser.open(url)
+        if success:
+            log.warning("Chromium browser not found. Falling back to default web browser.")
+        else:
+            log.warning(f"Cannot find any web browser. LANScape UI running on {url}")
     except BaseException:
         log.debug(traceback.format_exc())
         log.info(f'Unable to open web browser, server running on {url}')
@@ -105,7 +110,6 @@ def start_webserver_ui():
     else:
         flask_thread = start_webserver_daemon(args)
         proc = open_browser(uri)
-        
         if proc:
             app_closed = proc.wait()
         else:

{lanscape-2.2.0a2 → lanscape-2.3.0a1}/lanscape/ui/static/css/style.css

@@ -564,8 +564,8 @@ input[type="range"] {
 /* Service Strategy Select Styles */
 .service-strategy-wrapper {
     position: relative;
-    display: inline-block;
-    width: 60%; /* Narrower than port list */
+    display: block;
+    width: 100%;
 }
 
 .service-strategy {

{lanscape-2.2.0a2 → lanscape-2.3.0a1}/lanscape/ui/static/js/scan-config.js

@@ -139,15 +139,26 @@ function getScanConfig() {
 }
 
 function getPortLists(callback=null) {
-    $.get('/api/port/list', function(data) {
-        const customSelectDropdown = $('#port_list');
+    const customSelectDropdown = $('#port_list');
+
+    const renderOptions = (items) => {
         customSelectDropdown.empty();
-    
-        // Populate the dropdown with the options
-        data.forEach(function(portList) {
-            customSelectDropdown.append('<option>' + portList + '</option>');
+        items.forEach((item) => {
+            const name = item.name || item;
+            const count = item.count;
+            const label = count !== undefined ? `${name} (${count} ports)` : name;
+            customSelectDropdown.append(`<option value="${name}">${label}</option>`);
         });
+    };
+
+    $.get('/api/port/list/summary', function(data) {
+        renderOptions(data || []);
         if (callback) callback();
+    }).fail(function() {
+        $.get('/api/port/list', function(data) {
+            renderOptions(data || []);
+            if (callback) callback();
+        });
     });
 }
 

{lanscape-2.2.0a2 → lanscape-2.3.0a1}/lanscape/ui/templates/scan/config.html

@@ -201,7 +201,7 @@
             <div id="section-service-scan" class="form-group mt-2 config-section div-hide">
                 <h6>Service Scanning</h6>
                 <div class="row">
-                    <div class="col">
+                    <div class="col-12">
                         <label for="service_lookup_type" class="form-label">Strategy</label>
                         <div class="service-strategy-wrapper">
                             <select id="service_lookup_type" class="service-strategy">
@@ -211,11 +211,13 @@
                             </select>
                         </div>
                     </div>
-                    <div class="col">
+                </div>
+                <div class="row mt-2">
+                    <div class="col-12 col-md-6">
                         <label for="service_timeout" class="form-label">Timeout (sec)</label>
                         <input type="number" step="0.1" id="service_timeout" class="form-control">
                     </div>
-                    <div class="col">
+                    <div class="col-12 col-md-6 mt-2 mt-md-0">
                         <label for="service_max_concurrent_probes" class="form-label">Max Concurrent Probes</label>
                         <input type="number" id="service_max_concurrent_probes" class="form-control">
                     </div>

{lanscape-2.2.0a2 → lanscape-2.3.0a1/lanscape.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lanscape
-Version: 2.2.0a2
+Version: 2.3.0a1
 Summary: A python based local network scanner
 Author-email: Michael Dennis <michael@dipduo.com>
 License-Expression: MIT
@@ -25,12 +25,14 @@ Requires-Dist: scapy<3.0,>=2.3.2
 Requires-Dist: tabulate==0.9.0
 Requires-Dist: pydantic
 Requires-Dist: icmplib
-Requires-Dist: pwa-launcher>=0.3.0
+Requires-Dist: pwa-launcher>=1.1.0
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0; extra == "dev"
 Requires-Dist: pytest-cov>=5.0; extra == "dev"
 Requires-Dist: pytest-xdist>=3.0; extra == "dev"
 Requires-Dist: openai>=1.0.0; extra == "dev"
+Requires-Dist: pylint>=3.0; extra == "dev"
+Requires-Dist: autopep8>=2.0; extra == "dev"
 Dynamic: license-file
 
 # LANscape

{lanscape-2.2.0a2 → lanscape-2.3.0a1}/lanscape.egg-info/SOURCES.txt

@@ -25,7 +25,6 @@ lanscape/core/scan_config.py
 lanscape/core/service_scan.py
 lanscape/core/subnet_scan.py
 lanscape/core/version_manager.py
-lanscape/core/web_browser.py
 lanscape/resources/mac_addresses/convert_csv.py
 lanscape/resources/mac_addresses/mac_db.json
 lanscape/resources/ports/convert_csv.py
@@ -86,5 +85,6 @@ tests/test_globals.py
 tests/test_library.py
 tests/test_logging.py
 tests/test_port_scan.py
+tests/test_port_scan_linux_fd_exhaustion.py
 tests/test_service_scan.py
 tests/test_utils.py

{lanscape-2.2.0a2 → lanscape-2.3.0a1}/lanscape.egg-info/requires.txt

@@ -6,10 +6,12 @@ scapy<3.0,>=2.3.2
 tabulate==0.9.0
 pydantic
 icmplib
-pwa-launcher>=0.3.0
+pwa-launcher>=1.1.0
 
 [dev]
 pytest>=8.0
 pytest-cov>=5.0
 pytest-xdist>=3.0
 openai>=1.0.0
+pylint>=3.0
+autopep8>=2.0

{lanscape-2.2.0a2 → lanscape-2.3.0a1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lanscape"
-version = "2.2.0a2"
+version = "2.3.0a1"
 authors = [
   { name="Michael Dennis", email="michael@dipduo.com" },
 ]
@@ -28,7 +28,7 @@ dependencies = [
     "tabulate==0.9.0",
     "pydantic",
     "icmplib",
-    "pwa-launcher>=0.3.0"
+    "pwa-launcher>=1.1.0"
 ]
 
 [project.optional-dependencies]
@@ -36,7 +36,9 @@ dev = [
     "pytest>=8.0",
     "pytest-cov>=5.0",
     "pytest-xdist>=3.0",
-    "openai>=1.0.0"
+    "openai>=1.0.0",
+    "pylint>=3.0",
+    "autopep8>=2.0"
 ]
 [project.urls]
 Homepage = "https://github.com/mdennis281/py-lanscape"

{lanscape-2.2.0a2 → lanscape-2.3.0a1}/tests/test_api.py

@@ -15,6 +15,7 @@ from tests.test_globals import (
     MIN_EXPECTED_ALIVE_DEVICES
 )
 from lanscape.ui.app import app
+import lanscape.ui.blueprints.api.port as port_api
 
 
 @pytest.fixture
@@ -41,7 +42,7 @@ def test_scan_config():
     return {
         'subnet': TEST_SUBNET,
         'port_list': 'test_port_list_scan',
-        'lookup_type': ['ICMP','POKE_THEN_ARP'],  # Use ICMP for reliable external IP detection
+        'lookup_type': ['ICMP', 'POKE_THEN_ARP'],  # Use ICMP for reliable external IP detection
         'ping_config': {'timeout': 0.8, 'attempts': 2}  # Reasonable timeout for external IPs
     }
 
@@ -97,6 +98,34 @@ def test_port_lifecycle(api_client, sample_port_list, updated_port_list):
     response = api_client.delete(f'/api/port/list/{test_list_name}')
     assert response.status_code == 200
 
+
+def test_port_list_summary(api_client, monkeypatch):
+    """Verify port list summary returns names with counts."""
+
+    class FakePortManager:  # pylint: disable=too-few-public-methods
+        """Lightweight fake port manager for summary testing."""
+        def __init__(self):
+            self._lists = {
+                'small': {'80': 'http', '443': 'https'},
+                'custom': {'22': 'ssh'}
+            }
+
+        def get_port_lists(self):
+            """Return available list names."""
+            return list(self._lists.keys())
+
+        def get_port_list(self, name):
+            """Return a specific port list by name."""
+            return self._lists.get(name, {})
+
+    monkeypatch.setattr(port_api, 'PortManager', FakePortManager)
+
+    response = api_client.get('/api/port/list/summary')
+    assert response.status_code == 200
+    data = response.get_json()
+    assert isinstance(data, list)
+    assert {item['name']: item['count'] for item in data} == {'small': 2, 'custom': 1}
+
 # API Scan Tests
 ################
 

lanscape-2.3.0a1/tests/test_port_scan_linux_fd_exhaustion.py

@@ -0,0 +1,297 @@
+"""
+Tests for file descriptor exhaustion during large port scans.
+
+This module tests the scenario where scanning a large number of ports
+can exhaust file descriptors (sockets) on Unix-like systems such as
+Linux and macOS, causing "Too many open files" OSError.
+"""
+
+import sys
+from unittest.mock import patch, MagicMock
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import time
+import pytest
+
+from lanscape.core.net_tools import Device
+from lanscape.core.scan_config import PortScanConfig
+
+# Skip all tests in this module on non-Linux platforms
+pytestmark = pytest.mark.skipif(
+    sys.platform != "linux",
+    reason="File descriptor exhaustion tests are Linux-specific"
+)
+
+try:
+    import resource
+except ImportError:
+    resource = None  # Will be skipped anyway on non-Linux
+
+
+def test_socket_properly_closed_on_success():
+    """Test that sockets are properly closed when connection succeeds."""
+    device = Device(ip="127.0.0.1")
+    config = PortScanConfig(timeout=0.5, retries=0)
+
+    with patch('socket.socket') as mock_socket_class:
+        mock_socket = MagicMock()
+        mock_socket_class.return_value = mock_socket
+        mock_socket.connect_ex.return_value = 0  # Success
+
+        device.test_port(80, config)
+
+        # Verify socket was closed
+        mock_socket.close.assert_called_once()
+
+
+def test_socket_properly_closed_on_failure():
+    """Test that sockets are properly closed when connection fails."""
+    device = Device(ip="127.0.0.1")
+    config = PortScanConfig(timeout=0.5, retries=0)
+
+    with patch('socket.socket') as mock_socket_class:
+        mock_socket = MagicMock()
+        mock_socket_class.return_value = mock_socket
+        mock_socket.connect_ex.return_value = 1  # Failure
+
+        device.test_port(54321, config)
+
+        # Verify socket was closed
+        mock_socket.close.assert_called_once()
+
+
+def test_socket_properly_closed_on_exception():
+    """Test that sockets are properly closed when an exception occurs."""
+    device = Device(ip="127.0.0.1")
+    config = PortScanConfig(timeout=0.5, retries=0)
+
+    with patch('socket.socket') as mock_socket_class:
+        mock_socket = MagicMock()
+        mock_socket_class.return_value = mock_socket
+        mock_socket.connect_ex.side_effect = Exception("Connection error")
+
+        device.test_port(54322, config)
+
+        # Verify socket was closed even with exception
+        mock_socket.close.assert_called_once()
+
+
+def test_socket_properly_closed_with_retries():
+    """Test that sockets are properly closed on each retry attempt."""
+    device = Device(ip="127.0.0.1")
+    config = PortScanConfig(timeout=0.5, retries=2, retry_delay=0.05)
+
+    with patch('socket.socket') as mock_socket_class:
+        # Create multiple mock socket instances
+        mock_sockets = [MagicMock() for _ in range(3)]
+        mock_socket_class.side_effect = mock_sockets
+
+        # All attempts fail
+        for mock_sock in mock_sockets:
+            mock_sock.connect_ex.return_value = 1
+
+        device.test_port(54323, config)
+
+        # Verify each socket was closed (initial + 2 retries = 3 total)
+        for mock_sock in mock_sockets:
+            mock_sock.close.assert_called_once()
+
+
+def test_socket_closed_on_socket_creation_failure():
+    """Test handling when socket creation itself fails (OSError: Too many open files)."""
+    device = Device(ip="127.0.0.1")
+    config = PortScanConfig(timeout=0.5, retries=1, retry_delay=0.05)
+
+    with patch('socket.socket') as mock_socket_class:
+        # First attempt: socket creation fails with "Too many open files"
+        # Second attempt: succeeds
+        mock_socket = MagicMock()
+        mock_socket.connect_ex.return_value = 1
+
+        mock_socket_class.side_effect = [
+            OSError(24, "Too many open files"),
+            mock_socket
+        ]
+
+        # Should not crash, should handle the error gracefully
+        result = device.test_port(54324, config)
+
+        # Should return False since we couldn't connect
+        assert result is False
+
+        # Second socket should have been closed
+        mock_socket.close.assert_called_once()
+
+
+def test_multiple_concurrent_port_scans_socket_cleanup():
+    """Test that concurrent port scans properly clean up sockets."""
+    device = Device(ip="192.168.1.100")
+    config = PortScanConfig(timeout=0.1, retries=0)
+    ports = list(range(8000, 8100))  # 100 ports
+
+    with patch('socket.socket') as mock_socket_class:
+        mock_sockets = []
+
+        def create_mock_socket(*_args, **_kwargs):
+            mock_sock = MagicMock()
+            mock_sock.connect_ex.return_value = 1  # All closed
+            mock_sockets.append(mock_sock)
+            return mock_sock
+
+        mock_socket_class.side_effect = create_mock_socket
+
+        # Scan all ports concurrently (simulating real scenario)
+        with ThreadPoolExecutor(max_workers=20) as executor:
+            futures = [executor.submit(device.test_port, port, config) for port in ports]
+            for future in as_completed(futures):
+                future.result()
+
+        # Verify all sockets were closed
+        assert len(mock_sockets) == 100
+        for mock_sock in mock_sockets:
+            mock_sock.close.assert_called_once()
+
+
+def test_socket_cleanup_with_high_fd_limit():
+    """Test socket cleanup when approaching file descriptor limits."""
+    device = Device(ip="192.168.1.100")
+    config = PortScanConfig(timeout=0.1, retries=1, retry_delay=0.05)
+
+    # Simulate a scenario where we're near the FD limit
+    with patch('socket.socket') as mock_socket_class:
+        call_count = 0
+        max_calls_before_error = 50
+
+        def socket_with_limit(*_args, **_kwargs):
+            nonlocal call_count
+            call_count += 1
+
+            if call_count >= max_calls_before_error:
+                # Simulate "too many open files" error
+                raise OSError(24, "Too many open files")
+
+            mock_sock = MagicMock()
+            mock_sock.connect_ex.return_value = 1
+            return mock_sock
+
+        mock_socket_class.side_effect = socket_with_limit
+
+        # Scan ports until we hit the limit
+        ports_scanned = 0
+        for port in range(8000, 8200):
+            try:
+                device.test_port(port, config)
+                ports_scanned += 1
+            except OSError:
+                # Should handle gracefully
+                break
+
+        # Should have scanned some ports before hitting limit
+        assert ports_scanned > 0
+        # Should not have crashed the entire scan
+
+
+def test_socket_error_handling_retries():
+    """Test that socket errors during retries are handled properly."""
+    device = Device(ip="192.168.1.100")
+    config = PortScanConfig(timeout=0.5, retries=2, retry_delay=0.05)
+
+    with patch('socket.socket') as mock_socket_class:
+        # First attempt: Too many open files
+        # Second attempt: Connection timeout
+        # Third attempt: Success
+        mock_sock2 = MagicMock()
+        mock_sock3 = MagicMock()
+
+        mock_socket_class.side_effect = [
+            OSError(24, "Too many open files"),
+            mock_sock2,
+            mock_sock3
+        ]
+
+        mock_sock2.connect_ex.return_value = 1  # Fail
+        mock_sock3.connect_ex.return_value = 0  # Success
+
+        result = device.test_port(80, config)
+
+        # Should succeed on third attempt
+        assert result is True
+
+        # Both successful socket creations should have been closed
+        mock_sock2.close.assert_called_once()
+        mock_sock3.close.assert_called_once()
+
+
+def test_context_manager_style_socket_would_be_better():
+    """
+    This test documents that using 'with' statement for sockets would be better.
+    This is more of a design verification test.
+    """
+    device = Device(ip="127.0.0.1")
+    config = PortScanConfig(timeout=0.5, retries=0)
+
+    with patch('socket.socket') as mock_socket_class:
+        mock_socket = MagicMock()
+        mock_socket_class.return_value = mock_socket
+
+        # Simulate that the socket supports context manager
+        mock_socket.__enter__ = MagicMock(return_value=mock_socket)
+        mock_socket.__exit__ = MagicMock(return_value=None)
+        mock_socket.connect_ex.return_value = 0
+
+        device.test_port(80, config)
+
+        # Verify close was called
+        # (In the future, if we switch to 'with socket.socket()...',
+        # __exit__ would be called automatically)
+        mock_socket.close.assert_called()
+
+
+@pytest.mark.skipif(
+    not resource or resource.getrlimit(resource.RLIMIT_NOFILE)[0] > 10000,
+    reason="Only run on Linux systems with reasonable FD limits"
+)
+def test_real_socket_exhaustion_scenario():
+    """
+    Test with real sockets to verify the fix handles actual FD exhaustion.
+    This test creates many sockets to approach system limits.
+    """
+    device = Device(ip="192.168.254.254")  # Non-existent IP to ensure timeout
+    config = PortScanConfig(timeout=0.01, retries=0)  # Very short timeout
+
+    # Get current FD limit
+    soft_limit, _ = resource.getrlimit(resource.RLIMIT_NOFILE)
+
+    # Try to scan many ports and collect results
+    results = []
+    for port in range(1, min(200, soft_limit // 10)):
+        result = device.test_port(port, config)
+        results.append(result)
+
+    # All results should be boolean flags (success/failure), and no OSError
+    # should have propagated out of test_port during the scan.
+    assert all(isinstance(r, bool) for r in results)
+    # For a non-existent IP, we expect all failures since the IP doesn't exist
+    assert all(not r for r in results)
+
+
+def test_socket_cleanup_in_timeout_enforcer():
+    """Test that sockets are cleaned up even when timeout_enforcer kills the function."""
+    device = Device(ip="192.168.1.100")
+    # Very short enforcer timeout to trigger timeout: 0.1 * 1 * 1.5 = 0.15s enforcer
+    config = PortScanConfig(timeout=0.1, retries=0)
+
+    with patch('socket.socket') as mock_socket_class:
+        mock_socket = MagicMock()
+        mock_socket_class.return_value = mock_socket
+
+        # Make connect_ex hang longer than timeout (simulate very slow network)
+        def slow_connect(*_args):
+            time.sleep(0.5)  # Sleep longer than 0.15s enforcer timeout
+            return 1
+
+        mock_socket.connect_ex.side_effect = slow_connect
+
+        device.test_port(54325, config)
+
+        # Socket should still be closed
+        mock_socket.close.assert_called()

{lanscape-2.2.0a2 → lanscape-2.3.0a1}/tests/test_utils.py

@@ -252,9 +252,9 @@ def test_is_internal_block_edge_cases():
     ('192.168.1.1-192.168.1.10', True, 'Private range'),
     ('1.1.1.1-1.1.1.5', False, 'Public range'),
     ('192.168.1.1,10.0.0.1', True, 'Multiple private'),
-   ('192.168.1.1, 10.0.0.1', True, 'Multiple private (comma with space)'),
+    ('192.168.1.1, 10.0.0.1', True, 'Multiple private (comma with space)'),
     ('192.168.1.1,8.8.8.8', False, 'Mixed private/public'),
-   ('192.168.1.1, 8.8.8.8', False, 'Mixed private/public (comma with space)'),
+    ('192.168.1.1, 8.8.8.8', False, 'Mixed private/public (comma with space)'),
     ('192.168.1.1', True, 'Single private IP'),
     ('8.8.8.8', False, 'Single public IP'),
     ('invalid', False, 'Invalid input'),

lanscape-2.2.0a2/lanscape/core/web_browser.py

@@ -1,210 +0,0 @@
-"""
-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(
-                '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:
-                # pylint: disable=raise-missing-from
-                raise RuntimeError(
-                    'Unknown error while opening browser tab') from e
-        except Exception as e2:
-            log.warning(
-                'Exhausted all options to open browser, you need to open manually')
-            log.debug(f'As tab error: {e2}')
-            log.info(f'LANScape UI is running on {url}')
-    return False
-
-
-def get_default_browser_executable() -> Optional[str]:
-    """Platform-agnostic method to get the default browser executable path."""
-    if sys.platform.startswith("win"):
-        return windows_get_browser_from_registry()
-
-    if sys.platform.startswith("linux"):
-        return linux_get_browser_executable()
-
-    if 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"
-
-    # Unsupported platform
-    return None
-
-
-def linux_get_browser_executable() -> Optional[str]:
-    """Get the default web browser executable path on 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",
-    ]
-
-    exec_cmd = None
-    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 exec_cmd
-
-
-def windows_get_browser_from_registry() -> Optional[str]:
-    """Get the default web browser executable path on Windows."""
-    # Import winreg only on Windows platforms
-    if not sys.platform.startswith("win"):
-        return None
-
-    try:
-        import winreg  # pylint: disable=import-outside-toplevel
-    except ImportError:
-        log.debug("winreg module not available")
-        return None
-
-    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)