1 files changed, 24 insertions, 24 deletions

diff --git a/src/main/java/com/it_jaros/network_scanner/Scanner.java b/src/main/java/com/it_jaros/network_scanner/Scanner.java
index 3d85ec2..d70a446 100644
--- a/src/main/java/com/it_jaros/network_scanner/Scanner.java
+++ b/src/main/java/com/it_jaros/network_scanner/Scanner.java
@@ -18,35 +18,35 @@ public class Scanner {
     private final int timeoutInMillis;
     private final long delayInNanos;
     private final int maxWorkersPerHost;
-    private final int maxTargetsLimit;
-    private final boolean disableTargetCheck;
+    private final int maxHostsLimit;
+    private final boolean disableHostCheck;
 
-    public Scanner(int socketLimit, int timeoutInMillis, int delayInMillis, int maxWorkersPerHost, int maxTargetsLimit, boolean disableTargetCheck) {
+    public Scanner(int socketLimit, int timeoutInMillis, int delayInMillis, int maxWorkersPerHost, int maxHostsLimit, boolean disableHostCheck) {
         this.timeoutInMillis = timeoutInMillis;
         this.delayInNanos = TimeUnit.MILLISECONDS.toNanos(Math.max(0, delayInMillis));
         this.socketLimit = new Semaphore(socketLimit);
         this.maxWorkersPerHost = maxWorkersPerHost;
-        this.maxTargetsLimit = maxTargetsLimit;
-        this.disableTargetCheck = disableTargetCheck;
+        this.maxHostsLimit = maxHostsLimit;
+        this.disableHostCheck = disableHostCheck;
     }
 
-    public List<ScanResult> scan(ScanOptions target) {
-        return scanTargets(target.targets(), target.ports());
+    public List<ScanResult> scan(ScanOptions options) {
+        return scanHosts(options.targetHosts(), options.ports());
     }
 
-    public List<ScanResult> scanTargets(List<String> targets, String ports) {
+    public List<ScanResult> scanHosts(List<String> targetHosts, String ports) {
         List<ScanResult> results = new ArrayList<>();
         progressBar.start();
         try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
             List<Future<ScanResult>> futures = new ArrayList<>();
-            Semaphore maxTargets = new Semaphore(maxTargetsLimit);
-            for (String target : targets) {
-                maxTargets.acquireUninterruptibly();
+            Semaphore maxHosts = new Semaphore(maxHostsLimit);
+            for (String host : targetHosts) {
+                maxHosts.acquireUninterruptibly();
                 futures.add(executor.submit(() -> {
                     try {
-                        return scanTarget(target, ports);
+                        return scanHost(host, ports);
                     } finally {
-                        maxTargets.release();
+                        maxHosts.release();
                     }
                 }));
             }
@@ -71,20 +71,20 @@ public class Scanner {
         return results;
     }
 
-    private ScanResult scanTarget(String target, String ports) {
+    private ScanResult scanHost(String host, String ports) {
         PortRange portRange = new PortRange(ports);
         AtomicLong portSlotFactory = new AtomicLong(System.nanoTime());
         Semaphore maxWorkers = new Semaphore(maxWorkersPerHost);
         BitSet openPorts = new BitSet(PortRange.MAX_PORT);
         BitSet filteredPorts = new BitSet(PortRange.MAX_PORT);
 
-        Progress progress = new Progress(target, portRange.getTotal(), new AtomicInteger(), new AtomicInteger(), new AtomicInteger());
+        Progress progress = new Progress(host, portRange.getTotal(), new AtomicInteger(), new AtomicInteger(), new AtomicInteger());
         progressBar.submit(progress);
 
-        if(!disableTargetCheck && !checkHostOnline(target)) {
+        if(!disableHostCheck && !checkHostOnline(host)) {
             // Visually show that this host is basically done
             progress.done().set(progress.total());
-            return new ScanResult(target, openPorts, filteredPorts);
+            return new ScanResult(host, openPorts, filteredPorts);
         }
 
         try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
@@ -95,7 +95,7 @@ public class Scanner {
                 futures.add(executor.submit(() -> {
                     try {
                         waitForSlot(portSlotFactory);
-                        PortState state = getPortState(target, currentPort);
+                        PortState state = getPortState(host, currentPort);
                         if (state.equals(PortState.OPEN)) {
                             progress.open().incrementAndGet();
                         } else if (state.equals(PortState.FILTERED)) {
@@ -128,16 +128,16 @@ public class Scanner {
             }
 
             if (!errors.isEmpty()) {
-                System.out.printf("Errors happened during scan of target %s%nErrors:%s -> %s", target, errors.size(), errors);
+                System.out.printf("Errors happened during scan of host %s%nErrors:%s -> %s", host, errors.size(), errors);
             }
         }
 
-        return new ScanResult(target, openPorts, filteredPorts);
+        return new ScanResult(host, openPorts, filteredPorts);
     }
 
-    private boolean checkHostOnline(String target) {
+    private boolean checkHostOnline(String host) {
         try {
-            return InetAddress.getByName(target).isReachable(timeoutInMillis);
+            return InetAddress.getByName(host).isReachable(timeoutInMillis);
         } catch (IOException e) {
             // something went wrong
         }
@@ -154,11 +154,11 @@ public class Scanner {
         }
     }
 
-    private PortState getPortState(String target, int port) {
+    private PortState getPortState(String host, int port) {
         socketLimit.acquireUninterruptibly();
         counter.inc();
         try (Socket socket = new Socket()) {
-            socket.connect(new InetSocketAddress(target, port), timeoutInMillis);
+            socket.connect(new InetSocketAddress(host, port), timeoutInMillis);
             return PortState.OPEN;
         } catch (NoRouteToHostException ignored) {
             // this can be safely ignored because the port is closed if a host is unreachable