Obwohl alles in Thread läuft werden die Threads
nicht parallel ausgeführt, sondern nacheinander.
Der ganze Scannvorgang zieht sich so von ein
paar Sekunden auf mehrere Stunden!
Könnte das evtl. etwas mit den Sockets zu tun haben,
dass diese nicht parallel laufen können?
???:L
Bitte um Hilfe!
nicht parallel ausgeführt, sondern nacheinander.
Der ganze Scannvorgang zieht sich so von ein
paar Sekunden auf mehrere Stunden!
Code:
package de.cyd.subnetscan;
import java.io.IOException;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.util.Vector;
/**
*
Title: SubNetzScanner</p>
*
*
Description: Durchsucht die PCs eines Subnetzes nach einem gewählten Port.</p>
*
*
Lizenz: Steht unter der GPLv2
*
*
Copyright: Copyright (c) 2007</p>
*
*
Company: Sebastian Grosch </p>
*
* @author Sebastian "CyD" Grosch
* @version 0.0 Start 2007-11-06
* @version 1.0 Erstversion 2007-11-09
*/
public class Subnetscan {
/**
* main Methode zum Testen des Scanners
* @param args
*/
public static void main(String[] args) {
int port = 55200;
int millis = 5000;
new Subnetscan(port, millis).getIpList();
}
private String subnet; // bspw. "192.168.1."
private int port;
// private int ownNumber = 0; // Letzte Ziffer der IP, um nicht den Localhost zu scannen.
/**
* Konstruktor setzt den Port, auf welchem gescannt werden soll.
*
* @param port int
*/
public Subnetscan(int port, int millis) {
System.out.println("Start Subnetscan");
this.port = port; // Standardport
this.subnet = this.getSubnet();
System.out.println(this.subnet);
}
/**
* Ermittelt die eigene IP-Adresse und filtert die letzte Zahl heraus.
* @return String
*/
private String getSubnet() {
String ip; // IP
String mask = ""; // return wert. bspw "192.168.1."
String ownNumber = ""; // Eigene IP Ziffer
try {
ip = InetAddress.getLocalHost().getHostAddress().toString();
int countDots = 0;
for (int i = 0; i < ip.length(); i++) {
if(countDots != 3) { // 3. Punkt erreicht?
if(Character.isDigit(ip.charAt(i))) {
mask = mask + ip.charAt(i);
} else {
countDots++;
mask = mask + ".";
}
} else {
ownNumber = ownNumber + ip.charAt(i);
}
}
// this.ownNumber = new Integer(ownNumber);
} catch (Exception e) {
System.out.println("FEHLER!: "+e.getMessage());
e.printStackTrace();
}
return mask;
}
/**
* Gibt einen Vector<String> mit den gefundnen IPs zurück.
*
* @param port
* @param waitms
* @return
*/
public Vector<String> getIpList() {
Vector<String> ipList = new Vector<String>();
// Startet den Scanner für alle Werte zwischen 1 und 254
for(int i=0;i<253;i++){
// if(i!=this.ownNumber);
new Scanner(this.subnet+(i+1), this.port, ipList).run();
}
return ipList;
}
/**
* Die Scanner class versucht eine Verbindung zu einem angegebenen Port auf einer übernommenen IP aufzubauen.
*
* @author CyD
*
*/
private class Scanner extends Thread {
private String ipAddress = null;
private int port = 0;
private Vector<String> ipList = null;
private Socket socket = null;
/**
* Konstruktor der Klasse Scanner.
*
* @param sns
* @param ipAddress
* @param port
* @param ipList
*/
public Scanner(String ipAddress, int port, Vector<String> ipList) {
super("Subnetscan-Scanner");
this.ipAddress = ipAddress;
this.port = port;
this.ipList = ipList;
}
/**
* Fügt die IP-Adresse in die IP-Liste ein, falls diese erreicht wird.
*
*/
public void run() {
if(this.connectToServer(this.ipAddress, this.port)) {
this.ipList.addElement(this.ipAddress);
this.disconnect();
}
}
/**
* Überprüft, ob eine Verbindung zu dem Ziel hergestellt werden kann und gibt das Ergebnis zurück.
*
* @param ip
* @param port
* @return
*/
private boolean connectToServer(String ip, int port){
boolean bConnected = false;
try{
// Mit Timeout
// this.socket = new Socket();
// this.socket.setSoTimeout(10);
// this.socket.connect(new InetSocketAddress(ip, port));
this.socket = new Socket(ip, port);
bConnected = true;
System.out.println("Erreicht: "+ip);
}catch(IOException e){
System.out.println("Nicht erreicht: "+ip);
e.printStackTrace();
}
return bConnected;
}
/**
* Beendet die Verbindung und schließt das Socket.
*
*/
private void disconnect() {
try {
this.socket.close();
this.socket = null;
} catch (IOException e) {
e.printStackTrace();
}
}
}
}Könnte das evtl. etwas mit den Sockets zu tun haben,
dass diese nicht parallel laufen können?
???:L
Bitte um Hilfe!
