lanscape 1.3.5a2__py3-none-any.whl → 1.3.6__py3-none-any.whl

lanscape/__init__.py

@@ -3,10 +3,18 @@ Local network scanner
 """
 from lanscape.libraries.subnet_scan import (
     SubnetScanner,
-    ScanConfig,
     ScanManager
 )
 
+from lanscape.libraries.scan_config import (
+    ScanConfig,
+    ArpConfig,
+    PingConfig,
+    PokeConfig,
+    ArpCacheConfig,
+    ScanType
+)
+
 from lanscape.libraries.port_manager import PortManager
 
 from lanscape.libraries import net_tools

lanscape/libraries/decorators.py

@@ -25,6 +25,20 @@ class JobStats:
     timing: DefaultDict[str, float] = field(
         default_factory=lambda: defaultdict(float))
 
+    _instance = None
+
+    def __init__(self):
+        # Only initialize once
+        if not hasattr(self, "running"):
+            self.running = defaultdict(int)
+            self.finished = defaultdict(int)
+            self.timing = defaultdict(float)
+
+    def __new__(cls, *args, **kwargs):
+        if cls._instance is None:
+            cls._instance = super(JobStats, cls).__new__(cls)
+        return cls._instance
+
     def __str__(self):
         """Return a formatted string representation of the job statistics."""
         data = [
@@ -53,9 +67,7 @@ class JobStatsMixin:  # pylint: disable=too-few-public-methods
     @property
     def job_stats(self):
         """Return the shared JobStats instance."""
-        if JobStatsMixin._job_stats is None:
-            JobStatsMixin._job_stats = JobStats()
-        return JobStatsMixin._job_stats
+        return JobStats()
 
 
 def job_tracker(func):
@@ -81,7 +93,7 @@ def job_tracker(func):
     def wrapper(*args, **kwargs):
         """Wrap the function to update job statistics before and after execution."""
         class_instance = args[0]
-        job_stats = class_instance.job_stats
+        job_stats = JobStats()
         fxn = get_fxn_src_name(
             func,
             class_instance

lanscape/libraries/device_alive.py

@@ -0,0 +1,229 @@
+"""
+Handles device alive checks using various methods.
+"""
+
+import re
+import socket
+import subprocess
+import time
+from typing import List
+import psutil
+
+from scapy.sendrecv import srp
+from scapy.layers.l2 import ARP, Ether
+from icmplib import ping
+
+from lanscape.libraries.net_tools import Device
+from lanscape.libraries.scan_config import (
+    ScanConfig, ScanType, PingConfig,
+    ArpConfig, PokeConfig, ArpCacheConfig
+)
+from lanscape.libraries.decorators import timeout_enforcer, job_tracker
+
+
+def is_device_alive(device: Device, scan_config: ScanConfig) -> bool:
+    """
+    Check if a device is alive based on the configured scan type.
+
+    Args:
+        device (Device): The device to check.
+        scan_config (ScanConfig): The configuration for the scan.
+
+    Returns:
+        bool: True if the device is alive, False otherwise.
+    """
+    methods = scan_config.lookup_type
+
+    if ScanType.ICMP in methods:
+        IcmpLookup.execute(device, scan_config.ping_config)
+
+    if ScanType.ARP_LOOKUP in methods and not device.alive:
+        ArpLookup.execute(device, scan_config.arp_config)
+
+    if ScanType.ICMP_THEN_ARP in methods and not device.alive:
+        IcmpLookup.execute(device, scan_config.ping_config)
+        ArpCacheLookup.execute(device, scan_config.arp_cache_config)
+
+    if ScanType.POKE_THEN_ARP in methods and not device.alive:
+        Poker.execute(device, scan_config.poke_config)
+        ArpCacheLookup.execute(device, scan_config.arp_cache_config)
+
+    return device.alive is True
+
+
+class IcmpLookup():
+    """Class to handle ICMP ping lookups for device presence.
+
+    Raises:
+        NotImplementedError: If the platform is not supported.
+
+    Returns:
+        bool: True if the device is reachable via ICMP, False otherwise.
+    """
+    @classmethod
+    @job_tracker
+    def execute(cls, device: Device, cfg: PingConfig) -> bool:
+        """Perform an ICMP ping lookup for the specified device.
+
+        Args:
+            device (Device): The device to look up.
+            cfg (PingConfig): The configuration for the scan.
+
+        Returns:
+            bool: True if the device is reachable via ICMP, False otherwise.
+        """
+        # Perform up to cfg.attempts rounds of ping(count=cfg.ping_count)
+        for _ in range(cfg.attempts):
+            result = ping(
+                device.ip,
+                count=cfg.ping_count,
+                interval=cfg.retry_delay,
+                timeout=cfg.timeout,
+                privileged=psutil.WINDOWS  # Use privileged mode on Windows
+            )
+            if result.is_alive:
+                device.alive = True
+                break
+        return device.alive is True
+
+
+class ArpCacheLookup():
+    """
+    Class to handle ARP cache lookups for device presence.
+    """
+
+    @classmethod
+    @job_tracker
+    def execute(cls, device: Device, cfg: ArpCacheConfig) -> bool:
+        """
+        Perform an ARP cache lookup for the specified device.
+
+        Args:
+            device (Device): The device to look up.
+
+        Returns:
+            bool: True if the device is found in the ARP cache, False otherwise.
+        """
+
+        command = cls._get_platform_arp_command() + [device.ip]
+
+        for _ in range(cfg.attempts):
+            time.sleep(cfg.wait_before)
+            output = subprocess.check_output(command).decode()
+            macs = cls._extract_mac_address(output)
+            if macs:
+                device.macs = macs
+                device.alive = True
+                break
+
+        return device.alive is True
+
+    @classmethod
+    def _get_platform_arp_command(cls) -> List[str]:
+        """
+        Get the ARP command to execute based on the platform.
+
+        Returns:
+            list[str]: The ARP command to execute.
+        """
+        if psutil.WINDOWS:
+            return ['arp', '-a']
+        if psutil.LINUX:
+            return ['arp', '-n']
+        if psutil.MACOS:
+            return ['arp', '-n']
+
+        raise NotImplementedError("Unsupported platform")
+
+    @classmethod
+    def _extract_mac_address(cls, arp_resp: str) -> List[str]:
+        """
+        Extract MAC addresses from ARP output.
+
+        Args:
+            arp_resp (str): The ARP command output.
+
+        Returns:
+            List[str]: A list of extracted MAC addresses (may be empty).
+        """
+        arp_resp = arp_resp.replace('-', ':')
+        return re.findall(r'..:..:..:..:..:..', arp_resp)
+
+
+class ArpLookup():
+    """
+    Class to handle ARP lookups for device presence.
+    NOTE: This lookup method requires elevated privileges to access the ARP cache.
+
+
+    [Arp Lookup Requirements](/support/arp-issues.md)
+    """
+
+    @classmethod
+    @job_tracker
+    def execute(cls, device: Device, cfg: ArpConfig) -> bool:
+        """
+        Perform an ARP lookup for the specified device.
+
+        Args:
+            device (Device): The device to look up.
+
+        Returns:
+            bool: True if the device is found via ARP, False otherwise.
+        """
+        enforcer_timeout = cfg.timeout * 2
+
+        @timeout_enforcer(enforcer_timeout, raise_on_timeout=True)
+        def do_arp_lookup():
+            arp_request = ARP(pdst=device.ip)
+            broadcast = Ether(dst="ff:ff:ff:ff:ff:ff")
+            packet = broadcast / arp_request
+
+            answered, _ = srp(packet, timeout=cfg.timeout, verbose=False)
+            alive = any(resp.psrc == device.ip for _, resp in answered)
+            macs = []
+            if alive:
+                macs = [resp.hwsrc for _, resp in answered if resp.psrc == device.ip]
+            return alive, macs
+
+        alive, macs = do_arp_lookup()
+        if alive:
+            device.alive = True
+            device.macs = macs
+
+        return device.alive is True
+
+
+class Poker():
+    """
+    Class to handle Poking the device to populate the ARP cache.
+    """
+
+    @classmethod
+    @job_tracker
+    def execute(cls, device: Device, cfg: PokeConfig):
+        """
+        Perform a Poke for the specified device.
+        Note: the purpose of this is to simply populate the arp cache.
+
+        Args:
+            device (Device): The device to look up.
+            cfg (PokeConfig): The configuration for the Poke lookup.
+
+        Returns:
+            None: used to populate the arp cache
+        """
+        enforcer_timeout = cfg.timeout * cfg.attempts * 2
+
+        @timeout_enforcer(enforcer_timeout, raise_on_timeout=True)
+        def do_poke():
+            # Use a small set of common ports likely to be filtered but still trigger ARP
+            common_ports = [80, 443, 22]
+            for i in range(cfg.attempts):
+                sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+                sock.settimeout(cfg.timeout)
+                port = common_ports[i % len(common_ports)]
+                sock.connect_ex((device.ip, port))
+                sock.close()
+
+        do_poke()

lanscape/libraries/net_tools.py

@@ -4,13 +4,11 @@ import logging
 import ipaddress
 import traceback
 import subprocess
-from time import sleep
 from typing import List, Dict
 import socket
 import struct
 import re
 import psutil
-from icmplib import ping
 
 from scapy.sendrecv import srp
 from scapy.layers.l2 import ARP, Ether
@@ -20,116 +18,13 @@ from lanscape.libraries.service_scan import scan_service
 from lanscape.libraries.mac_lookup import MacLookup, get_macs
 from lanscape.libraries.ip_parser import get_address_count, MAX_IPS_ALLOWED
 from lanscape.libraries.errors import DeviceError
-from lanscape.libraries.decorators import job_tracker, JobStatsMixin, timeout_enforcer
-from lanscape.libraries.scan_config import ScanType, PingConfig, ArpConfig
+from lanscape.libraries.decorators import job_tracker
 
 log = logging.getLogger('NetTools')
+mac_lookup = MacLookup()
 
 
-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(
-        self,
-        ip: str,
-        scan_type: ScanType = ScanType.BOTH,
-        arp_config: ArpConfig = ArpConfig(),
-        ping_config: PingConfig = PingConfig()
-    ) -> bool:
-        """
-        Check if a device is alive by performing ARP and/or ping scans.
-        """
-        if scan_type == ScanType.ARP:
-            return self._arp_lookup(ip, arp_config)
-        if scan_type == ScanType.PING:
-            return self._ping_lookup(ip, ping_config)
-        return self._ping_lookup(ip, ping_config) or self._arp_lookup(ip, arp_config)
-
-    @job_tracker
-    def _arp_lookup(
-        self, ip: str,
-        cfg: ArpConfig = ArpConfig()
-    ) -> bool:
-        """Perform an ARP lookup to check if the device is alive."""
-        enforcer_timeout = cfg.timeout * 1.3
-
-        @timeout_enforcer(enforcer_timeout, raise_on_timeout=True)
-        def do_arp_lookup():
-            arp_request = ARP(pdst=ip)
-            broadcast = Ether(dst="ff:ff:ff:ff:ff:ff")
-            packet = broadcast / arp_request
-
-            answered, _ = srp(packet, timeout=cfg.timeout, verbose=False)
-            self._arp_alive = any(resp.psrc == ip for _, resp in answered)
-            return self._arp_alive
-
-        try:
-            for _ in range(cfg.attempts):
-                if do_arp_lookup():
-                    return True
-        except Exception as e:
-            self.caught_errors.append(DeviceError(e))
-        return False
-
-    @job_tracker
-    def _ping_lookup(
-        self, ip: str,
-        cfg: PingConfig = PingConfig()
-    ) -> bool:
-        """Perform a ping lookup to check if the device is alive using icmplib."""
-        enforcer_timeout = cfg.timeout * cfg.ping_count * 1.3
-
-        @timeout_enforcer(enforcer_timeout, raise_on_timeout=False)
-        def do_icmp_ping():
-            try:
-                result = ping(
-                    ip,
-                    count=cfg.ping_count,
-                    interval=cfg.retry_delay,
-                    timeout=cfg.timeout,
-                    privileged=psutil.WINDOWS  # Use privileged mode on Windows
-                )
-                return result.is_alive
-            except Exception as e:
-                self.caught_errors.append(DeviceError(e))
-                # Fallback to system ping command
-                try:
-                    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 subprocess.CalledProcessError as fallback_error:
-                    self.caught_errors.append(DeviceError(fallback_error))
-                    return False
-
-        try:
-            for _ in range(cfg.attempts):
-                if do_icmp_ping():
-                    self._icmp_alive = True
-                    return True
-                sleep(cfg.retry_delay)
-        except Exception as e:
-            self.caught_errors.append(DeviceError(e))
-        self._icmp_alive = False
-        return False
-
-
-class Device(IPAlive):
+class Device:
     """Represents a network device with metadata and scanning capabilities."""
 
     def __init__(self, ip: str):
@@ -144,13 +39,12 @@ class Device(IPAlive):
         self.services: Dict[str, List[int]] = {}
         self.caught_errors: List[DeviceError] = []
         self.log = logging.getLogger('Device')
-        self._mac_lookup = MacLookup()
 
     def get_metadata(self):
         """Retrieve metadata such as hostname and MAC addresses."""
         if self.alive:
             self.hostname = self._get_hostname()
-            self.macs = self._get_mac_addresses()
+            self._get_mac_addresses()
 
     def dict(self) -> dict:
         """Convert the device object to a dictionary."""
@@ -191,9 +85,12 @@ class Device(IPAlive):
     @job_tracker
     def _get_mac_addresses(self):
         """Get the possible MAC addresses of a network device given its IP address."""
-        macs = get_macs(self.ip)
-        mac_selector.import_macs(macs)
-        return macs
+        # job may already be done depending on
+        # the strat from isalive
+        if not self.macs:
+            self.macs = get_macs(self.ip)
+        mac_selector.import_macs(self.macs)
+        return self.macs
 
     @job_tracker
     def _get_hostname(self):
@@ -208,7 +105,7 @@ class Device(IPAlive):
     @job_tracker
     def _get_manufacturer(self, mac_addr=None):
         """Get the manufacturer of a network device given its MAC address."""
-        return self._mac_lookup.lookup_vendor(mac_addr) if mac_addr else None
+        return mac_lookup.lookup_vendor(mac_addr) if mac_addr else None
 
 
 class MacSelector:
@@ -562,19 +459,32 @@ def smart_select_primary_subnet(subnets: List[dict] = None) -> str:
     return selected.get("subnet", "")
 
 
+class ArpSupportChecker:
+    """
+    Singleton class to check if ARP requests are supported on the current system.
+    The check is only performed once.
+    """
+    _supported = None
+
+    @classmethod
+    def is_supported(cls):
+        """one time check if ARP requests are supported on this system"""
+        if cls._supported is not None:
+            return cls._supported
+        try:
+            arp_request = ARP(pdst='0.0.0.0')
+            broadcast = Ether(dst="ff:ff:ff:ff:ff:ff")
+            packet = broadcast / arp_request
+            srp(packet, timeout=0, verbose=False)
+            cls._supported = True
+        except (Scapy_Exception, PermissionError, RuntimeError):
+            cls._supported = False
+        return cls._supported
+
+
 def is_arp_supported():
     """
-    Check if ARP requests are supported on the current platform.
+    Check if ARP requests are supported on the current system.
+    Only runs the check once.
     """
-    try:
-        arp_request = ARP(pdst='0.0.0.0')
-        broadcast = Ether(dst="ff:ff:ff:ff:ff:ff")
-        packet = broadcast / arp_request
-
-        srp(packet, timeout=0, verbose=False)
-        return True
-    # Scapy_Exception = MacOS
-    # PermissionError = Linux
-    # RuntimeError = Windows
-    except (Scapy_Exception, PermissionError, RuntimeError):
-        return False
+    return ArpSupportChecker.is_supported()

lanscape/libraries/scan_config.py

@@ -4,6 +4,7 @@ Provides classes and utilities to configure different types of network scans
 including ping scans, ARP scans, and port scanning.
 """
 
+import os
 from typing import List, Dict
 import ipaddress
 from enum import Enum
@@ -90,17 +91,81 @@ class ArpConfig(BaseModel):
         return f'ArpCfg(timeout={self.timeout}, attempts={self.attempts})'
 
 
+class ArpCacheConfig(BaseModel):
+    """Config for fetching from ARP cache"""
+    attempts: int = 1
+    wait_before: float = 0.2
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'ArpCacheConfig':
+        """
+        Create an ArpCacheConfig instance from a dictionary.
+
+        Args:
+            data: Dictionary containing ArpCacheConfig parameters
+
+        Returns:
+            A new ArpCacheConfig instance with the provided settings
+        """
+        return cls.model_validate(data)
+
+    def to_dict(self) -> dict:
+        """
+        Convert the ArpCacheConfig instance to a dictionary.
+
+        Returns:
+            Dictionary representation of the ArpCacheConfig
+        """
+        return self.model_dump()
+
+    def __str__(self):
+        return f'ArpCacheCfg(wait_before={self.wait_before}, attempts={self.attempts})'
+
+
+class PokeConfig(BaseModel):
+    """
+    Poking essentially involves sending a TCP packet to a specific port on a device
+    to elicit a response. Not so much expecting a response, but it should at least
+    trigger an ARP request.
+    """
+    attempts: int = 1
+    timeout: float = 2.0
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'PokeConfig':
+        """
+        Create a PokeConfig instance from a dictionary.
+
+        Args:
+            data: Dictionary containing PokeConfig parameters
+
+        Returns:
+            A new PokeConfig instance with the provided settings
+        """
+        return cls.model_validate(data)
+
+    def to_dict(self) -> dict:
+        """
+        Convert the PokeConfig instance to a dictionary.
+
+        Returns:
+            Dictionary representation of the PokeConfig
+        """
+        return self.model_dump()
+
+
 class ScanType(Enum):
     """
     Enumeration of supported network scan types.
 
     PING: Uses ICMP echo requests to determine if hosts are alive
     ARP: Uses Address Resolution Protocol to discover hosts on the local network
-    BOTH: Uses both PING and ARP methods for maximum coverage
+
     """
-    PING = 'ping'
-    ARP = 'arp'
-    BOTH = 'both'
+    ICMP = 'ICMP'
+    ARP_LOOKUP = 'ARP_LOOKUP'
+    POKE_THEN_ARP = 'POKE_THEN_ARP'
+    ICMP_THEN_ARP = 'ICMP_THEN_ARP'
 
 
 class ScanConfig(BaseModel):
@@ -113,18 +178,20 @@ class ScanConfig(BaseModel):
     subnet: str
     port_list: str
     t_multiplier: float = 1.0
-    t_cnt_port_scan: int = 10
-    t_cnt_port_test: int = 128
-    t_cnt_isalive: int = 256
+    t_cnt_port_scan: int = os.cpu_count() or 4
+    t_cnt_port_test: int = (os.cpu_count() or 4) * 4
+    t_cnt_isalive: int = (os.cpu_count() or 4) * 6
 
     task_scan_ports: bool = True
     # below wont run if above false
     task_scan_port_services: bool = False  # disabling until more stable
 
-    lookup_type: ScanType = ScanType.BOTH
+    lookup_type: List[ScanType] = [ScanType.ICMP_THEN_ARP]
 
     ping_config: PingConfig = Field(default_factory=PingConfig)
     arp_config: ArpConfig = Field(default_factory=ArpConfig)
+    poke_config: PokeConfig = Field(default_factory=PokeConfig)
+    arp_cache_config: ArpCacheConfig = Field(default_factory=ArpCacheConfig)
 
     def t_cnt(self, thread_id: str) -> int:
         """
@@ -143,32 +210,20 @@ class ScanConfig(BaseModel):
         """
         Create a ScanConfig instance from a dictionary.
 
-        Handles special cases like converting string enum values to proper Enum types.
-
         Args:
             data: Dictionary containing ScanConfig parameters
 
         Returns:
             A new ScanConfig instance with the provided settings
         """
-        # Handle special cases before validation
-        if isinstance(data.get('lookup_type'), str):
-            data['lookup_type'] = ScanType[data['lookup_type'].upper()]
 
         return cls.model_validate(data)
 
     def to_dict(self) -> dict:
         """
-        Convert the ScanConfig instance to a dictionary.
-
-        Handles special cases like converting Enum values to strings.
-
-        Returns:
-            Dictionary representation of the ScanConfig
+        Convert the ScanConfig instance to a json-serializable dictionary.
         """
-        dump = self.model_dump()
-        dump['lookup_type'] = self.lookup_type.value
-        return dump
+        return self.model_dump(mode="json")
 
     def get_ports(self) -> List[int]:
         """
@@ -191,7 +246,7 @@ class ScanConfig(BaseModel):
     def __str__(self):
         a = f'subnet={self.subnet}'
         b = f'ports={self.port_list}'
-        c = f'scan_type={self.lookup_type.value}'
+        c = f'scan_type={[st.value for st in self.lookup_type]}'
         return f'ScanConfig({a}, {b}, {c})'
 
 
@@ -205,7 +260,7 @@ DEFAULT_CONFIGS: Dict[str, ScanConfig] = {
         t_cnt_isalive=64,
         task_scan_ports=True,
         task_scan_port_services=False,
-        lookup_type=ScanType.BOTH,
+        lookup_type=[ScanType.ICMP_THEN_ARP, ScanType.ARP_LOOKUP],
         arp_config=ArpConfig(
             attempts=3,
             timeout=2.5
@@ -215,6 +270,10 @@ DEFAULT_CONFIGS: Dict[str, ScanConfig] = {
             ping_count=2,
             timeout=1.5,
             retry_delay=0.5
+        ),
+        arp_cache_config=ArpCacheConfig(
+            attempts=2,
+            wait_before=0.3
         )
     ),
     'fast': ScanConfig(
@@ -225,7 +284,7 @@ DEFAULT_CONFIGS: Dict[str, ScanConfig] = {
         t_cnt_isalive=512,
         task_scan_ports=True,
         task_scan_port_services=False,
-        lookup_type=ScanType.BOTH,
+        lookup_type=[ScanType.POKE_THEN_ARP],
         arp_config=ArpConfig(
             attempts=1,
             timeout=1.0

lanscape/libraries/subnet_scan.py

@@ -21,12 +21,13 @@ from tabulate import tabulate
 
 # Local imports
 from lanscape.libraries.scan_config import ScanConfig
-from lanscape.libraries.decorators import job_tracker, terminator, JobStatsMixin
-from lanscape.libraries.net_tools import Device, is_arp_supported
+from lanscape.libraries.decorators import job_tracker, terminator, JobStats
+from lanscape.libraries.net_tools import Device
 from lanscape.libraries.errors import SubnetScanTerminationFailure
+from lanscape.libraries.device_alive import is_device_alive
 
 
-class SubnetScanner(JobStatsMixin):
+class SubnetScanner():
     """
     Scans a subnet for devices and open ports.
 
@@ -43,6 +44,7 @@ class SubnetScanner(JobStatsMixin):
         self.subnet = config.parse_subnet()
         self.ports: List[int] = config.get_ports()
         self.subnet_str = config.subnet
+        self.job_stats = JobStats()
 
         # Status properties
         self.running = False
@@ -50,11 +52,6 @@ class SubnetScanner(JobStatsMixin):
         self.results = ScannerResults(self)
         self.log: logging.Logger = logging.getLogger('SubnetScanner')
 
-        # Initial logging
-        if not is_arp_supported():
-            self.log.warning(
-                'ARP is not supported with the active runtime context. '
-                'Device discovery will be limited to ping responses.')
         self.log.debug(f'Instantiated with uid: {self.uid}')
         self.log.debug(
             f'Port Count: {len(self.ports)} | Device Count: {len(self.subnet)}')
@@ -175,6 +172,7 @@ class SubnetScanner(JobStatsMixin):
             t_remain = int((100 - percent) * (t_elapsed / percent)
                            ) if percent else '∞'
             buffer = f'{self.uid} - {self.subnet_str}\n'
+            buffer += f'Config: {self.cfg}\n'
             buffer += f'Elapsed: {int(t_elapsed)} sec - Remain: {t_remain} sec\n'
             buffer += f'Scanned: {self.results.devices_scanned}/{self.results.devices_total}'
             buffer += f' - {percent}%\n'
@@ -239,12 +237,7 @@ class SubnetScanner(JobStatsMixin):
         """
         Ping the given host and return True if it's reachable, False otherwise.
         """
-        return host.is_alive(
-            host.ip,
-            scan_type=self.cfg.lookup_type,
-            ping_config=self.cfg.ping_config,
-            arp_config=self.cfg.arp_config
-        )
+        return is_device_alive(host, self.cfg)
 
     def _set_stage(self, stage):
         self.log.debug(f'[{self.uid}] Moving to Stage: {stage}')
@@ -272,7 +265,6 @@ class ScannerResults:
         self.devices_total: int = len(list(scan.subnet))
         self.devices_scanned: int = 0
         self.devices: List[Device] = []
-        self.devices_alive = 0
 
         # Status tracking
         self.errors: List[str] = []
@@ -286,6 +278,11 @@ class ScannerResults:
         self.log = logging.getLogger('ScannerResults')
         self.log.debug(f'Instantiated Logger For Scan: {self.scan.uid}')
 
+    @property
+    def devices_alive(self):
+        """number of alive devices found in the scan"""
+        return len(self.devices)
+
     def scanned(self):
         """
         Increment the count of scanned devices.
@@ -315,7 +312,6 @@ class ScannerResults:
         """
         self.running = self.scan.running
         self.run_time = int(round(time() - self.start_time, 0))
-        self.devices_alive = len(self.devices)
 
         out = vars(self).copy()
         out.pop('scan')
@@ -348,6 +344,7 @@ class ScannerResults:
 
         # Format and return the complete buffer with table output
         buffer = f"Scan Results - {self.scan.subnet_str} - {self.uid}\n"
+        buffer += f'Found/Scanned: {self.devices_alive}/{self.devices_scanned}\n'
         buffer += "---------------------------------------------\n\n"
         buffer += table
         return buffer

lanscape/ui/main.py

@@ -12,7 +12,6 @@ import requests
 from lanscape.libraries.logger import configure_logging
 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
 from lanscape.ui.app import start_webserver_daemon, start_webserver
 # do this so any logs generated on import are displayed
@@ -49,14 +48,6 @@ def _main():
 
     args.port = get_valid_port(args.port)
 
-    if not is_arp_supported():
-        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()
         log.info('Exiting...')

lanscape/ui/static/css/style.css

@@ -159,24 +159,21 @@ details {
     margin-bottom: 0;
 }
 #scan-form input {
+    margin: 0 -1px; /* sneak borders around buttons */
     z-index: 2;
     transition: all .2s ease-in-out;
     border-radius: 5px !important; /* override bootstrap stuff */
-    padding-right: 34px;
-    margin-right: -34px;
-    margin-left: -41px;
-    padding-left: calc(41px + 5px);
+    padding-left: calc(30px + 5px);
 }
 
 
+
 #scan-form .input-group button {
     background-color: var(--primary-bg-accent);
     border: 0;
-    
     transition: all .2s ease-in-out;
     height: 40px;
     margin-top: 1px;
-    transform: translateX(.5px);
     z-index: 3;
     margin-left: 0;
 }
@@ -187,13 +184,19 @@ details {
     background-color: var(--primary-accent);
 }
 #scan-form .input-group button.start {
+    position: absolute;
+    left: 0;
     border-radius: 5px 0 0 5px;
+    padding: 0;
     border-right: 1px var(--border-color) solid;
-    width: 40px; /* added because it looks gross on icon load */
+    width: 30px; /* added because it looks gross on icon load */
 }
 #scan-form .input-group button.end {
     border-radius: 0 5px 5px 0;
     border-left: 1px var(--border-color) solid;
+    position: absolute;
+    width: 30px;
+    right: 0;
 }
 
 .label-container {
@@ -333,6 +336,31 @@ details {
     padding: 5px;
 }
 
+#advanced-modal #lookup-type-group {
+    gap: 12px;
+}
+
+#advanced-modal .modal-body {
+    height: calc(100vh - 200px);
+    overflow-y: scroll;
+}
+
+#advanced-modal #lookup-type-group .form-check {
+    margin-right: 8px;
+    margin-bottom: 6px;
+}
+
+#advanced-modal .arp-help-ico {
+    font-size: 1em;
+    vertical-align: middle;
+    margin-left: 3px;
+    color: var(--text-color);
+    cursor: pointer;
+    opacity: 1;
+}
+#advanced-modal .arp-help-ico:hover {
+    color: var(--text-accent-color);
+}
 
 /* Card Styles */
 .card {
@@ -758,19 +786,6 @@ html {
     background-color: var(--warning-accent);
 }
 
-#arp-error {
-    width: calc(100% + 40px);
-    position: relative;
-    display: flex;
-    justify-content: center;
-    background-color: var(--danger-accent-transparent);
-    color: var(--text-color);
-    transform: translate3d(-20px, -20px, 0);
-    font-size: small;
-}
-#arp-error span {
-    text-align: center;
-}
 
 @media screen and (max-width: 681px) {
     #power-button {
@@ -783,10 +798,6 @@ html {
         width:98%;
         padding: 8px;
     }
-    #arp-error {
-        width: calc(100% + 16px);
-        transform: translate3d(-8px, -8px, 0);
-    }
 }
 
 @media screen and (max-width: 885px) {

lanscape/ui/static/js/scan-config.js

@@ -13,6 +13,9 @@ $(document).ready(function() {
     
     $('#t_cnt_port_scan, #t_cnt_port_test').on('input', updatePortTotals);
     $('#ping_attempts, #ping_ping_count').on('input', updatePingTotals);
+
+    // Lookup type toggles
+    $('.lookup-type-input').on('change', onLookupTypeChanged);
 });
 
 function getScanDefaults(callback=null) {
@@ -39,7 +42,9 @@ function setScanConfig(configName) {
     $('#t_cnt_isalive').val(config.t_cnt_isalive);
     $('#task_scan_ports').prop('checked', config.task_scan_ports);
     $('#task_scan_port_services').prop('checked', config.task_scan_port_services);
-    $('#lookup_type').val(config.lookup_type);
+
+    // lookup type (array of enum values as strings)
+    setLookupTypeUI(config.lookup_type || []);
 
     // ping config
     $('#ping_attempts').val(config.ping_config.attempts);
@@ -51,8 +56,21 @@ function setScanConfig(configName) {
     $('#arp_attempts').val(config.arp_config.attempts);
     $('#arp_timeout').val(config.arp_config.timeout);
 
+    // arp cache config
+    if (config.arp_cache_config) {
+        $('#arp_cache_attempts').val(config.arp_cache_config.attempts);
+        $('#arp_cache_wait_before').val(config.arp_cache_config.wait_before);
+    }
+
+    // poke config
+    if (config.poke_config) {
+        $('#poke_attempts').val(config.poke_config.attempts);
+        $('#poke_timeout').val(config.poke_config.timeout);
+    }
+
     updatePortTotals();
     updatePingTotals();
+    updateVisibility();
 }
 
 function getScanConfig() {
@@ -63,7 +81,7 @@ function getScanConfig() {
         t_cnt_isalive: parseInt($('#t_cnt_isalive').val()),
         task_scan_ports: $('#task_scan_ports').is(':checked'),
         task_scan_port_services: $('#task_scan_port_services').is(':checked'),
-        lookup_type: $('#lookup_type').val(),
+        lookup_type: getSelectedLookupTypes(),
         ping_config: {
             attempts: parseInt($('#ping_attempts').val()),
             ping_count: parseInt($('#ping_ping_count').val()),
@@ -73,6 +91,14 @@ function getScanConfig() {
         arp_config: {
             attempts: parseInt($('#arp_attempts').val()),
             timeout: parseFloat($('#arp_timeout').val())
+        },
+        arp_cache_config: {
+            attempts: parseInt($('#arp_cache_attempts').val()),
+            wait_before: parseFloat($('#arp_cache_wait_before').val())
+        },
+        poke_config: {
+            attempts: parseInt($('#poke_attempts').val()),
+            timeout: parseFloat($('#poke_timeout').val())
         }
     };
 }
@@ -102,6 +128,54 @@ function updatePingTotals() {
     $('#total-ping-attempts').val(attempts * count);
 }
 
+// Lookup type helpers
+function setLookupTypeUI(values) {
+    const set = new Set(values || []);
+    $('.lookup-type-input').each(function() {
+        const val = $(this).val();
+        $(this).prop('checked', set.has(val));
+    });
+    updateVisibility();
+}
+
+function getSelectedLookupTypes() {
+    const selected = [];
+    $('.lookup-type-input:checked').each(function() {
+        selected.push($(this).val());
+    });
+    return selected;
+}
+
+function onLookupTypeChanged() {
+    updateVisibility();
+}
+
+function updateVisibility() {
+    const types = new Set(getSelectedLookupTypes());
+
+    // Show ping if ICMP is used directly or as part of ICMP_THEN_ARP
+    const showPing = types.has('ICMP') || types.has('ICMP_THEN_ARP');
+    toggleSection('#section-ping', showPing);
+
+    // ARP active lookup (scapy) only when ARP_LOOKUP is selected
+    const showArp = types.has('ARP_LOOKUP');
+    toggleSection('#section-arp', showArp);
+
+    // ARP cache is used when we do a staged lookup that relies on cache
+    const showArpCache = types.has('ICMP_THEN_ARP') || types.has('POKE_THEN_ARP');
+    toggleSection('#section-arp-cache', showArpCache);
+
+    // Poke section only when POKE_THEN_ARP is selected
+    const showPoke = types.has('POKE_THEN_ARP');
+    toggleSection('#section-poke', showPoke);
+}
+
+function toggleSection(selector, show) {
+    const $el = $(selector);
+    if (show) $el.removeClass('div-hide');
+    else $el.addClass('div-hide');
+}
+
 // expose functions globally
 window.setScanConfig = setScanConfig;
 window.getScanConfig = getScanConfig;

lanscape/ui/templates/main.html

@@ -53,13 +53,6 @@
 
 <div id="content">
     <div class="container-fluid my-4">
-        <!-- ARP Error -->
-        <div id="arp-error" class="{{ 'div-hide' if is_arp_supported else '' }}">
-            <span>
-                Unable to use ARP lookup. Device discovery is degraded.
-                <a target="_blank" href="https://github.com/mdennis281/LANscape/blob/main/support/arp-issues.md">Steps to fix</a>
-            </span>
-        </div>
         <!-- Scan Results -->
         <div id="scan-results" class="div-hide">
             <div class="d-flex justify-content-between">

lanscape/ui/templates/scan/config.html

@@ -32,14 +32,46 @@
             <h6>Device Detection</h6>
             <div class="row mt-2">
                 <div class="col">
-                    <label for="lookup_type">Lookup Type</label>
-                    <div class="port-list-wrapper">
-                        <select id="lookup_type" class="port-list">
-                            <option value="both">ARP + Ping</option>
-                            <option value="arp">ARP Only</option>
-                            <option value="ping">Ping Only</option>
-                        </select>
+                    <label class="mb-1">Lookup Type</label>
+                    <div id="lookup-type-group" class="d-flex flex-wrap gap-3">
+                        <div class="form-check">
+                            <input class="form-check-input lookup-type-input" type="checkbox" id="lookup_icmp" value="ICMP">
+                            <label class="form-check-label" for="lookup_icmp">ICMP</label>
+                        </div>
+                        <div class="form-check">
+                            <!-- ARP lookup does not always work. Depends on host system -->
+                            <input 
+                            class="form-check-input lookup-type-input" 
+                            type="checkbox" 
+                            id="lookup_arp_lookup" 
+                            value="ARP_LOOKUP" 
+                            {{ '' if is_arp_supported else 'disabled' }}
+                            />
+                            <label class="form-check-label" for="lookup_arp_lookup">
+                                ARP Lookup
+                            </label>
+                            {% if not is_arp_supported %}
+                                <span 
+                                    class="material-symbols-outlined arp-help-ico" 
+                                    data-bs-toggle="tooltip" 
+                                    data-bs-placement="top" 
+                                    title="ARP lookup is not supported on this system, click for more info"
+                                    onclick="window.open('https://github.com/mdennis281/LANscape/blob/main/support/arp-issues.md', '_blank')"
+                                >
+                                    help
+                                </span>
+                            {% endif %}
+                        </div>
+                        <div class="form-check">
+                            <input class="form-check-input lookup-type-input" type="checkbox" id="lookup_icmp_then_arp" value="ICMP_THEN_ARP">
+                            <label class="form-check-label" for="lookup_icmp_then_arp">ICMP then ARP Cache</label>
+                        </div>
+                        <div class="form-check">
+                            <input class="form-check-input lookup-type-input" type="checkbox" id="lookup_poke_then_arp" value="POKE_THEN_ARP">
+                            <label class="form-check-label" for="lookup_poke_then_arp">Poke then ARP Cache</label>
+                        </div>
                     </div>
+                    
                 </div>
                 <div class="col">
                     <label for="t_cnt_isalive">Device Lookup Threads</label>
@@ -49,7 +81,7 @@
         </div>
 
         <hr>
-        <div class="form-group mt-2">
+        <div id="section-ping" class="form-group mt-2">
             <h6>Device Detection <span class=text-color>/</span> Ping Settings</h6>
             <div class="row">
                 <div class="col-3">
@@ -80,8 +112,7 @@
         </div>
 
         <hr>
-
-        <div class="form-group mt-2">
+        <div id="section-arp" class="form-group mt-2">
             <h6>Device Detection <span class=text-color>/</span> ARP Settings</h6>
             <div class="row">
                 <div class="col">
@@ -95,6 +126,36 @@
             </div>
         </div>
 
+        <hr>
+        <div id="section-arp-cache" class="form-group mt-2 div-hide">
+            <h6>Device Detection <span class=text-color>/</span> ARP Cache Settings</h6>
+            <div class="row">
+                <div class="col">
+                    <label for="arp_cache_attempts" class="form-label">Attempts</label>
+                    <input type="number" id="arp_cache_attempts" class="form-control">
+                </div>
+                <div class="col">
+                    <label for="arp_cache_wait_before" class="form-label">Wait Before (sec)</label>
+                    <input type="number" step="0.1" id="arp_cache_wait_before" class="form-control">
+                </div>
+            </div>
+        </div>
+
+        <hr>
+        <div id="section-poke" class="form-group mt-2 div-hide">
+            <h6>Device Detection <span class=text-color>/</span> Poke Settings</h6>
+            <div class="row">
+                <div class="col">
+                    <label for="poke_attempts" class="form-label">Attempts</label>
+                    <input type="number" id="poke_attempts" class="form-control">
+                </div>
+                <div class="col">
+                    <label for="poke_timeout" class="form-label">Timeout (sec)</label>
+                    <input type="number" step="0.1" id="poke_timeout" class="form-control">
+                </div>
+            </div>
+        </div>
+
         <hr>
 
         <div class="form-group mt-2">

{lanscape-1.3.5a2.dist-info → lanscape-1.3.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lanscape
-Version: 1.3.5a2
+Version: 1.3.6
 Summary: A python based local network scanner
 Author-email: Michael Dennis <michael@dipduo.com>
 License-Expression: MIT
@@ -25,9 +25,28 @@ Dynamic: license-file
 # LANscape
 A python based local network scanner.
 
-![screenshot](https://github.com/user-attachments/assets/ba09c656-9fd9-4d74-8426-506d9a5c316c)
+![screenshot](https://github.com/user-attachments/assets/7d77741e-3bad-4b6b-a33f-6a392adde23f)
 
-## Local Run
+
+PyPi Stats: 
+
+![Version](https://img.shields.io/pypi/v/lanscape)
+![Monthly Downloads](https://img.shields.io/pypi/dm/lanscape)
+
+Latest release: 
+
+![Stable](https://img.shields.io/github/v/tag/mdennis281/LANScape?filter=releases%2F*&label=Stable)
+![Beta](https://img.shields.io/github/v/tag/mdennis281/LANScape?filter=pre-releases%2F*b*&label=Beta)
+![Alpha](https://img.shields.io/github/v/tag/mdennis281/LANScape?filter=pre-releases%2F*a*&label=Alpha)
+
+Health: 
+
+![pytest](https://img.shields.io/github/actions/workflow/status/mdennis281/LANscape/test.yml?branch=main&label=pytest) 
+![packaging](https://img.shields.io/github/actions/workflow/status/mdennis281/LANscape/test-package.yml?label=packaging) 
+![pylint](https://img.shields.io/github/actions/workflow/status/mdennis281/LANscape/pylint.yml?branch=main&label=pylint)
+
+
+## Installation
 ```sh
 pip install lanscape
 python -m lanscape
@@ -55,16 +74,14 @@ The program does an ARP lookup to determine the MAC address. This lookup
 can sometimes require admin-level permissions to retrieve accurate results.
 *Try elevating your shell before execution.*
 
-### 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. 
+I use a combination of ARP, ICMP & port testing to determine if a device is online. Sometimes the scan settings can use some tuning to maximize both speed and accuracy.
+
 Recommendations:
 
-  - Drop parallelism value (advanced dropdown)
-  - Use python > 3.10 im noticing threadpool improvements after this version
-  - Create a bug - I'm curious
+  - Adjust scan configuration
+  - Configure ARP lookup [ARP lookup setup](./support/arp-issues.md)
+  - Create a bug
 
 
 ### Something else

{lanscape-1.3.5a2.dist-info → lanscape-1.3.6.dist-info}/RECORD

@@ -1,18 +1,19 @@
-lanscape/__init__.py,sha256=tjBtwEQhJA4njI8gsKddyuWcLBXaPwtpSPM0Wd6qrLg,227
+lanscape/__init__.py,sha256=YVrshFIK9GR9JrtpvJSg3BmsYcffuAdXJVxCoRCGmTE,355
 lanscape/__main__.py,sha256=PuY42yuCLAwHrOREJ6u2DgVyGX5hZKRQeoE9pajkNfM,170
 lanscape/libraries/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lanscape/libraries/app_scope.py,sha256=EqYQRQcbjOPPcIOhFkIepcz2cKHmoUHxWj2JSoRJmzk,2542
-lanscape/libraries/decorators.py,sha256=YyHPUd_oTfO2dLPwbQ0P38ZI7VfjJihWXWv_fnaS-X4,5099
+lanscape/libraries/decorators.py,sha256=SoNqfEInPyL-rrUKY6njK5d6Mwqu7Ix6He-BZRu2VKQ,5394
+lanscape/libraries/device_alive.py,sha256=mwvHJp9rWV1_zfrE57aPKOsGp06fHdzrXOuGDWiZ2T8,6851
 lanscape/libraries/errors.py,sha256=QTf42UzR9Zxj1t1mdwfLvZIp0c9a5EItELOdCR7kTmE,1322
 lanscape/libraries/ip_parser.py,sha256=RgIEvHw_oQEcjUYOrvcpbfm4KThtH8L68WyhSOJNOfE,4201
 lanscape/libraries/logger.py,sha256=nzo6J8UdlMdhRkOJEDOIHKztoE3Du8PQZad7ixvNgeM,2534
 lanscape/libraries/mac_lookup.py,sha256=PxBSMe3wEVDtivCsh5NclSAguZz9rqdAS7QshBiuWvM,3519
-lanscape/libraries/net_tools.py,sha256=E37ad6cjxHMrquW3GsRAExfdzP0TpzUXqDBkUA4xKlU,19185
+lanscape/libraries/net_tools.py,sha256=nIvOV_qYXmWIBYEd5PqWH1Mkadg3I1T0vbcHPkzlw6I,15853
 lanscape/libraries/port_manager.py,sha256=3_ROOb6JEiB0NByZVtADuGcldFkgZwn1RKtvwgs9AIk,4479
 lanscape/libraries/runtime_args.py,sha256=2vIqRrcWr-NHRSBlZGrxh1PdkPY0ytkPguu8KZqy2L8,2543
-lanscape/libraries/scan_config.py,sha256=M412bEeSkRcAfbz9ub609BOGZknllt7orDO6Z_lZ7yY,6685
+lanscape/libraries/scan_config.py,sha256=IOtwAaiy_f1r1KcsyTUVurOmo3kUmWdquAxWh8Gv39A,8329
 lanscape/libraries/service_scan.py,sha256=ZF4LL2gSI0T5oYEMjc8pCVtJkV1KIk4xP-AeEAkSdLc,1944
-lanscape/libraries/subnet_scan.py,sha256=sDpv-XqP5uXIoxL1BESclfzlbXnrbGBhZ9M1yDhvGlQ,14275
+lanscape/libraries/subnet_scan.py,sha256=lL2LzuxoTgPyvsdkPPEcZDqQPbCAGMHAjoX2slKGUKc,14136
 lanscape/libraries/version_manager.py,sha256=fIAv6bVHb_VCOrqT8Do53trxwEgR2mnZV82v3YGxJ14,2944
 lanscape/libraries/web_browser.py,sha256=23MuGIrBYdGhw6ejj6OWxwReeKIlWhtWukc1dKV_3_0,6736
 lanscape/resources/mac_addresses/convert_csv.py,sha256=hvlyLs0XmuuhBuvXBNRGP1cKJzYVRSf8VfUJ1VqROms,1189
@@ -25,7 +26,7 @@ lanscape/resources/ports/small.json,sha256=F_lo_5xHwHBfOVfVgxP7ejblR3R62SNtC1Mm3
 lanscape/resources/services/definitions.jsonc,sha256=4k7XnqIpWr1xuF7EUMgZf7y6aVDxOL_if7GGsT-JEuY,8387
 lanscape/ui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lanscape/ui/app.py,sha256=bL3K3NkGV1RY67kGHEQIWUl-Jm_MVN4WsIlsRQuK-SU,3760
-lanscape/ui/main.py,sha256=5pZa_vmBLX6TLaTWfFpobwv7MkFJcghl-TWBvOURX0o,4559
+lanscape/ui/main.py,sha256=8Be2UL_ezWLpaEYYejjd8iyM2_hG1pXlkHdVjn-lySc,4196
 lanscape/ui/shutdown_handler.py,sha256=eJC9A0MDMgLv_KQnJlUy3Kz2xCGDAf5opVdd8nBtABE,1710
 lanscape/ui/blueprints/__init__.py,sha256=WLnPfPE06684wArgKDDLfsW-1hKFlLe75AR7uLAPlKc,270
 lanscape/ui/blueprints/api/__init__.py,sha256=5Z4Y7B36O-bNFenpomfuNhPuJ9dW_MC0TPUU3pCFVfA,103
@@ -35,7 +36,7 @@ lanscape/ui/blueprints/api/tools.py,sha256=Dm5eAlWajr670H3O6note5hS_BZ888IGp2Rsd
 lanscape/ui/blueprints/web/__init__.py,sha256=NvgnjP0X4LwqVhSEyh5RUzoG45N44kHK1MEFlfvBxTg,118
 lanscape/ui/blueprints/web/routes.py,sha256=883puFTHePUEgwS4a2-Co6-gdLwr5NbOx0goUck7054,3571
 lanscape/ui/static/lanscape.webmanifest,sha256=07CqA-PQsO35KJD8R96sI3Pxix6UuBjijPDCuy9vM3s,446
-lanscape/ui/static/css/style.css,sha256=f5AcXpFMOdvM-EHV-khpLG-v0TvnS3sRr0tCyphiw-k,17472
+lanscape/ui/static/css/style.css,sha256=O2BA0DiLlXYe_wLxM_uzrCc1VjV_SxSWQEHLCghy_0A,17598
 lanscape/ui/static/img/ico/android-chrome-192x192.png,sha256=JmFT6KBCCuoyxMV-mLNtF9_QJbVBvfWPUizKN700fi8,18255
 lanscape/ui/static/img/ico/android-chrome-512x512.png,sha256=88Jjx_1-4XAnZYz64KP6FdTl_kYkNG2_kQIKteQwSh4,138055
 lanscape/ui/static/img/ico/apple-touch-icon.png,sha256=tEJlLwBZtF4v-NC90YCfRJQ2prTsF4i3VQLK_hnv2Mw,16523
@@ -48,26 +49,26 @@ lanscape/ui/static/js/layout-sizing.js,sha256=U2dsyJi-YKpOpudu3kg2whiU4047ghzDTY
 lanscape/ui/static/js/main.js,sha256=zCT_4Vql-XzmoMq9fDjC1p4W8WowjIuctwNJ2ymeonI,6538
 lanscape/ui/static/js/on-tab-close.js,sha256=3icxYWlLpY81iLoW7kQTJeWQ3UnyyboG0dESHF2wLPQ,1376
 lanscape/ui/static/js/quietReload.js,sha256=8POH0t1KVzGCJas9fNsOVbBG-ULwZT2wiS14URgkeAU,702
-lanscape/ui/static/js/scan-config.js,sha256=RVGrjv3djlOmbx3NN1zhaORvHh6EsAh8YtYVjyk6J9E,3683
+lanscape/ui/static/js/scan-config.js,sha256=EOPo-0liYn3UPuhm2kaQrT7G-UumxQ25_rh1c1DaTj4,6021
 lanscape/ui/static/js/shutdown-server.js,sha256=Mx8UGmmktHaCK7DL8TVUxah6VEcN0wwLFfhbCId-K8U,453
 lanscape/ui/static/js/subnet-info.js,sha256=osZM6CGs-TC5QpBJWkNWCtXNOKzjyIiWKHwKi4vlDf8,559
 lanscape/ui/static/js/subnet-selector.js,sha256=2YKCAuKU2Ti1CmJrqi4_vNTD2LQbxx7chIDqND_1eAY,358
 lanscape/ui/templates/base.html,sha256=cnKU-kHUBpt6Xg4gPLE4dWkcXr3H-K4Vz1Im8xDKdOQ,1448
 lanscape/ui/templates/error.html,sha256=bqGJbf_ix9wtpUlXk5zvz_XyFpeTbEO-4f0ImgLtUGk,1033
 lanscape/ui/templates/info.html,sha256=gu8SGFUaFQc46Rm4TkZD8HM4Tnls-ZWsJ0FJNhx9wEs,2545
-lanscape/ui/templates/main.html,sha256=YAuJsyZOGr_euLvUwYBUacB7Gmc8xCcEKSbNf9qix3o,4260
+lanscape/ui/templates/main.html,sha256=ubxKUQcWQ27A0YpvBgj6AnIqgVSfW3exYXyn7EgrKJM,3895
 lanscape/ui/templates/scan.html,sha256=00QX2_1S_1wGzk42r00LjEkJvoioCLs6JgjOibi6r20,376
 lanscape/ui/templates/shutdown.html,sha256=iXVCq2yl5TjZfNFl4esbDJra3gJA2VQpae0jj4ipy9w,701
 lanscape/ui/templates/core/head.html,sha256=eZiebt24xYd_NALe-fFL25rb4uFjUrF4XJjxFH61MgM,779
 lanscape/ui/templates/core/scripts.html,sha256=rSRi4Ut8iejajMPhOc5bzEz-Z3EHxpj_3PxwwyyhmTQ,640
-lanscape/ui/templates/scan/config.html,sha256=CcGWubKAG8M5hwokKCkJhnZN7yGfpqRJJLP4oPzM30E,7815
+lanscape/ui/templates/scan/config.html,sha256=WK0kOq7EintAvch8ospSofFLYB3qCmQ4i-xnVOj-4l0,11376
 lanscape/ui/templates/scan/export.html,sha256=Nvs_unojzT3qhN_ZnEgYHou2C9wqWGr3dVr2UiLnYjY,749
 lanscape/ui/templates/scan/ip-table-row.html,sha256=RANDsfW4xBATdtiLrxUlRouFSjgwetZqdzH-MJgj2mE,4740
 lanscape/ui/templates/scan/ip-table.html,sha256=CP7AG8WHOgy3AyYCIN0wA2wO6n0H1X0F9IOncQtpPvE,914
 lanscape/ui/templates/scan/overview.html,sha256=xWj9jWDPg2KcPLvS8fnSins23_UXjKCdb2NJwNG2U2Q,1176
 lanscape/ui/templates/scan/scan-error.html,sha256=wmAYQ13IJHUoO8fAGNDjMvNml7tu4rsIU3Vav71ETlA,999
-lanscape-1.3.5a2.dist-info/licenses/LICENSE,sha256=VLoE0IrNTIc09dFm7hMN0qzk4T3q8V0NaPcFQqMemDs,1070
-lanscape-1.3.5a2.dist-info/METADATA,sha256=zLd_wdWcjsxCkkWgAVwHMDKthmUmHL72nTZozX2WlNQ,2569
-lanscape-1.3.5a2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lanscape-1.3.5a2.dist-info/top_level.txt,sha256=E9D4sjPz_6H7c85Ycy_pOS2xuv1Wm-ilKhxEprln2ps,9
-lanscape-1.3.5a2.dist-info/RECORD,,
+lanscape-1.3.6.dist-info/licenses/LICENSE,sha256=VLoE0IrNTIc09dFm7hMN0qzk4T3q8V0NaPcFQqMemDs,1070
+lanscape-1.3.6.dist-info/METADATA,sha256=SF8Efe09_0l_fIyoP4BKq5nKNqPawso_zRDG6YOFgMI,3121
+lanscape-1.3.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lanscape-1.3.6.dist-info/top_level.txt,sha256=E9D4sjPz_6H7c85Ycy_pOS2xuv1Wm-ilKhxEprln2ps,9
+lanscape-1.3.6.dist-info/RECORD,,