lanscape 2.2.1__tar.gz → 2.3.0a1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lanscape
-Version: 2.2.1
+Version: 2.3.0a1
 Summary: A python based local network scanner
 Author-email: Michael Dennis <michael@dipduo.com>
 License-Expression: MIT
@@ -31,6 +31,8 @@ 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.1 → 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.1 → 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.1 → 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.1 → 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.1 → 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.1 → 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.1 → lanscape-2.3.0a1/lanscape.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lanscape
-Version: 2.2.1
+Version: 2.3.0a1
 Summary: A python based local network scanner
 Author-email: Michael Dennis <michael@dipduo.com>
 License-Expression: MIT
@@ -31,6 +31,8 @@ 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.1 → lanscape-2.3.0a1}/lanscape.egg-info/SOURCES.txt

@@ -85,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.1 → lanscape-2.3.0a1}/lanscape.egg-info/requires.txt

@@ -13,3 +13,5 @@ pytest>=8.0
 pytest-cov>=5.0
 pytest-xdist>=3.0
 openai>=1.0.0
+pylint>=3.0
+autopep8>=2.0

{lanscape-2.2.1 → lanscape-2.3.0a1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lanscape"
-version = "2.2.1"
+version = "2.3.0a1"
 authors = [
   { name="Michael Dennis", email="michael@dipduo.com" },
 ]
@@ -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.1 → 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
@@ -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()