# Probleme mit kleinem Netzwerk Programm



## ArtooDetoo (18. Feb 2009)

Hallo zusammen,

ich habe mich als Java-Neuling an Netzwerkprogrammierung gewagt. Ich hatte vor, ein Programm zum anzeigen von Verzeichnissen übers Netzwerk zu schreiben.
Dazu habe ich 2 Klassen (NetworkServer und NetworkClient). Alles funktioniert wie es soll, bis auf eine Sache: Wenn der Client die Verbindung abbricht, wird es vom Server nicht erkannt, und er durchläuft die Schleife zum Verarbeiten der Verbindung immer wieder.
Hoffentlich kann mir hier jemand helfen.

Grüße,
R2D2


Quelltexte:

NetworkServer.java

```
import java.io.File;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.URL;
import java.util.Scanner;


public class NetworkServer extends Thread{

    private ServerSocket server;
    private Socket client;
    private ObjectInputStream input;
    private ObjectOutputStream output;
    private String password;
    private File folder;

    public NetworkServer(int port, String password, File folder) {
        this.password = password;
        this.folder = folder;
        try {
            server = new ServerSocket(port);
        } catch (IOException e) {

            System.out.println("Fehler beim Starten des Servers: " + e.getMessage());
        }
    }

    @Override
    public void run() {
        while (true) {
            try {
                client = server.accept();

                try {
                    output = new ObjectOutputStream(client.getOutputStream());
                } catch (IOException e) {
                    System.out.println("Fehler beim öffnen des OutputStreams: " + e.getMessage());
                }
                try {
                    input = new ObjectInputStream(client.getInputStream());
                } catch (IOException e) {
                    System.out.println("Fehler beim öffnen des InputStreams: " + e.getMessage());
                }

            } catch (IOException e) {
                System.out.println("Fehler beim Annehmen der Verbindung des Clients: " + e.getMessage());
            }
            while (!client.isClosed()) {
                String command = (String) receive();

                // Verbindungsherstellung
                if (command != null && command.indexOf("hello") == 0 && command.indexOf(password) > 0) {
                    send("hello");
                } // Dateiauflistung
                else if (command != null && command.indexOf("list") == 0 && command.indexOf(password) > 0) {
                    String path = command.substring(12);
                    Ordner o = new Ordner(folder.getAbsolutePath() + path);
                    send(o.getFiles());
                } // Datei senden
                else if (command != null && command.indexOf("get") == 0 && command.indexOf(password) > 0) {
                } else {
                    send("Error");
                }
            }
        }
    }

    public void send(Object o) {
        try {
            output.writeObject(o);
        } catch (IOException e) {
            System.out.println("Fehler beim Senden an Client: " + e.getMessage());
        }

    }

    public Object receive() {

        Object o = null;
        try {
            o = input.readObject();
        } catch (Exception e) {
            System.out.println("Fehler beim Empfangen vom Client: " + e.getMessage());
        }
        return o;
    }
}
```

NetworkClient.java

```
import java.io.File;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;


public class NetworkClient {

    private Socket client;
    private ObjectOutputStream output;
    private ObjectInputStream input;
    private String password;

    public NetworkClient() {
    }

    public int connect(String host, int port, String password) {
        int ret = 0;
        this.password = password;
        try {
            client = new Socket(host, port);

            try {
                output = new ObjectOutputStream(client.getOutputStream());
            } catch (IOException e) {
                System.out.print("Fehler beim öffnen des OutputStreams: " + e.getMessage());
            }
            try {
                input = new ObjectInputStream(client.getInputStream());
            } catch (IOException e) {
                System.out.println("Fehler beim öffnen des InputStreams: " + e.getMessage());
            }

            send("hello " + password);
            if (((String) receive()).equals("hello")) {
                ret = 1;
            } else {
                ret = 0;
            }
        } catch (IOException e) {
            System.out.println("Fehler beim Verbinden mit dem Server: " + e.getMessage());
            ret = -1;
        }
        return ret;
    }

    public File[] receiveFileList() {
        return receiveFileList("/");
    }

    public File[] receiveFileList(String path) {
        send("list " + password + " " + path);
        return (File[]) receive();
    }

    public void disconnect() {
        if (client.isConnected()) {
            try {
                client.close();
            } catch (IOException e) {
                System.out.println("Fehler beim Schließen der Verbindung: " + e.getMessage());
            }
        }
    }

    public void send(Object o) {
        try {
            output.writeObject(o);
        } catch (IOException e) {
            System.out.println("Fehler beim Senden an Server: " + e.getMessage());
        }
    }

    public Object receive() {
        Object o = null;
        try {
            o = input.readObject();
        } catch (Exception e) {
            System.out.println("Fehler beim Empfangen vom Server: " + e.getMessage());
        }
        return o;
    }
}
```

Tester.java

```
public class Tester {

    public static void main(String[] args) {
        NetworkServer server = new NetworkServer(1337, "123456", new java.io.File("E:/Spiele"));
        server.start();

        NetworkClient client = new NetworkClient();
        int connect = client.connect("localhost", 1337, "123456");
        if (connect == -1) {
            System.out.println("Server anwortet nicht.");
        } else if (connect == 0) {
            System.out.println("Falsches Passwort.");
        } else if (connect == 1) {
            System.out.println("Verbindung hergestellt.");
        }

        java.io.File[] files = client.receiveFileList();
        for (java.io.File f : files) {
            System.out.println(f.getName());
        }
        client.disconnect();
    }
}
```

Ordner.java

```
import java.io.File;
import java.util.Arrays;
import java.util.Comparator;


public class Ordner {

    private File[] content;
    private String[] filenames;

    public Ordner(String path) {
        content = new File(path).listFiles();
        Comparator<File> vergleich = new OrdnerinhaltComparator();
        Arrays.sort(content, vergleich);
    }

    public File[] getFiles() {
        return content;
    }

    public String[] getFilenames() {
        filenames = new String[content.length];
        for (int i = 0; i < content.length; i++) {
            filenames[i] = content[i].getName();
        }
        return filenames;
    }
}
```

OrdnerinhaltComparator.java

```
import java.io.File;
import java.util.Comparator;


public class OrdnerinhaltComparator implements Comparator<File> {

    public int compare(File o1, File o2) {
        if (o1.isDirectory() && o2.isDirectory() || o1.isFile() && o2.isFile()) {
            return o1.getName().compareTo(o2.getName());
        }
        return o1.isDirectory() ? -1 : 1;
    }
}
```


----------



## ArtooDetoo (18. Feb 2009)

Was ich bisher schon herausgefunden habe:

client.isClosed() ist zwar true, wenn der Server die Verbindung schließt, nicht aber wenn der Client es tut...



> The only way to detect that the remote host has closed the connection is to attempt to read or write from the connection. If the remote host properly closed the connection, read() will return -1. If the connection was not terminated normally, read() and write() will throw an exception.


Das heißt, ich muss eine java.io.EOFException abfangen ... aber vielleicht gibts ja noch einen anderen Weg


----------



## tuxedo (19. Feb 2009)

Nein, nicht ganz. Wenn du ein "read()" auf einen Stream machst der geschlossen/beendet ist, dann kommt "-1" zurück. Und dann weisst du, dass die Verbindung "tot" ist. Steht übrigens auch in der API zu read(). 

Was auch ganz hilfreich ist: http://mindprod.com/jgloss/socket.html#DISCONNECT

Gruß
Alex


----------



## ArtooDetoo (19. Feb 2009)

Danke, jetzt habe ich aber ein neues problem.

ich möchte eine datei über einen input-/output-stream, der _nicht_ geschlossen werden soll, übertragen. ich hatte mir das so vorgestellt, dass ich die dateien immer in 16kb großen buffern schicke, damit ich zB auch eine fortschrittsanzeige realisieren kann. allerdings fehlt mir dann die abbruchbedingung, durch die der client merkt, dass die datei zuende ist.


----------



## tuxedo (19. Feb 2009)

Was du brauchst ist ein Protokoll:

Vor dem Datei senden schaust du nach, wie groß die zu sendende Datei ist. 
Das speicherst du dir in einem int oder einem long.

Bevor du die datei sendest, sendest du die Dateigröße. Der Server muss dann folglich wissen, dass als erstes die Dateigröße ankommt. Der Rest ist dann die Datei selbst. Und da kann er dann mitzählen wieviel er von der Datei schon hat und wann er die Verbindung zu machen kann, bzw. wann die Datei komplett gelesen wurde.

Dafür aber bitte keine Object*Streams benutzen! Benutz für sowas besser die Data*Streams.


- Alex


----------



## ArtooDetoo (19. Feb 2009)

das hatte ich auch schon gemacht, aber dann bricht der client seltsamerweise zu früh ab. als ob mehr daten gesendet würden, als die datei groß ist


----------



## tuxedo (19. Feb 2009)

bevor du den Stream schließt, solltest du "flush()" aufrufen, um sicher zu gehen, dass auch alles gesendet wurde. 

"zu früh" heisst für mich z.B. "bei 99,8% abgebrochen". 
Das was du da schilderst wäre ein "zu früh bei 100,8% abgebrochen". Und das gibts nicht.

Ja was denn nun?


----------



## ArtooDetoo (19. Feb 2009)

Ich habe eine textdatei mit dem inhalt "Test". Wenn ich sie versende, steht in der Zieldatei "q ~ oTest" ... ich kann mir einfach nicht erklären, wie das kommt.


```
public void sendFile(File f) {
        int len;
        InputStream fileinput = null;
        
        System.out.println("Dateigröße: " + f.length());
        send(f.length());

        try {
            fileinput = new FileInputStream(f);
        } catch (FileNotFoundException e) {
            System.out.println("Datei \"" + f.getAbsolutePath() + "\" wurde nicht gefunden.");
        }
        try {
            byte[] buffer = new byte[16384];
            while ((len = fileinput.read(buffer)) > 0) {
                client.getOutputStream().write(buffer, 0, len);
            }
            fileinput.close();
        } catch (IOException e) {
            System.out.println("Fehler beim lesen der Datei \"" + f.getAbsolutePath() + "\": " + e.getMessage());
        }
    }
```


```
public void receiveFile(String filesrc, File filedest) {
        OutputStream fileoutput = null;

        send("get " + filesrc);

        double size = Double.parseDouble(receive().toString());
        System.out.println("Dateigröße: " + size);

        try {
            fileoutput = new FileOutputStream(filedest);
        } catch (FileNotFoundException e) {
            System.out.println("Fehler beim Schreiben der Datei." + e.getMessage());
        }
        int len = 0;

        try {
            byte[] buffer = new byte[16384];
            for (int i = 0; i <= size / 16384; i++) {
                len = client.getInputStream().read(buffer);
                fileoutput.write(buffer, 0, len);
            }
            fileoutput.close();
        } catch (IOException e) {
            System.out.println("Fehler beim Übertragen der Datei.");
        }
    }
```


----------



## ArtooDetoo (19. Feb 2009)

eben hat er nur "q ~ o" empfangen ...


----------



## tuxedo (19. Feb 2009)

Ich rate dir von ObjectStreams ab wenn du auch noch Dateien schicken willst.
So wie ich das jetzt verstanden habe serialisierst du Ordner-Objekte und andere und schickst sie übers Netz. Auf der anderen Seite "sucht" man sich dann eine Datei raus unf fordert diese zum Download an. Ist das so richtig?

Wenn ja: Das ganze über normale Sockets zu machen ist etwas trickreich da man sich ein dazu passendes Protokoll überlegen muss. Objectstreams sind zum serialisieren okay, Aber dann noch Dateidaten dazu mischen kann ungewollte Nebeneffekte haben.

Ich würde das sauber trennen. Passend wäre hierfür unter anderem RMI (oder meine SIMON implementierung).

Aber mal davon abgesehen: Mehr Logoutput und das "Wissen wie man einen Debugger bedient" schadet nicht bei der Fehlersuche.


----------



## ArtooDetoo (19. Feb 2009)

im beispielcode von eben schicke ich die dateien über den normalen outputStream, nicht über den objectOutputStream, oder verstehe ich das falsch?
durch das debuggen habe ich nur herausgefunden, dass im serverbuffer die richtige bytefolge steht, im clientbuffer jedoch nicht mehr ...


----------



## tuxedo (19. Feb 2009)

Bin mir nicht sicher: Aber auf einer Socketverbindung mal "den einen Stream" und dann "den anderen Stream" zu verwenden könnte gefährlich sein.

Alternativ kannst du auch zwei Socketverbindunggen benutzen: Die eine zum hin und her schicken der Objekte mittels Object*Stream, und die andere zum reinen übertragen der Datei mittels Data*Stream.

- Alex


----------



## ArtooDetoo (19. Feb 2009)

ich glaube das wird am einfachsten sein. vielen dank für deine hilfe


----------



## ArtooDetoo (19. Feb 2009)

ich versuche mir das gerade vorzustellen ... wie teilt der client dem server auf der datei-verbindung mit, welche datei er gerne hätte?
benutze ich da beim client einen objectoutput und datainputstream? oder wie mache ich das?

irgendwie muss der server ja auch erkennen, ob die verbindung für objekte oder dateien gedacht sein soll, wenn sich der client verbindet


----------



## tuxedo (19. Feb 2009)

Du hast zwei Verbindungen:

1) Kommunikationsverbindung
2) Dateiverbindung

Über 1) holt sich der Client eine Liste mit Dateien und wählt eine aus. Runterladen tut der Client dann via 2) mit DataInput- und DataOutputStream in etwa so:

Client -> Server:
String(Dateiname)

Server->Client:
int(Dateigröße)
byte[](Datei selbst in mehreren Blöcken)

2) wird am besten für jede Datei neu aufgebaut und auch wieder geschlossen. idealerweise läuft 2) auf einem anderen Port als 1).

Wenn dich das auch nicht weiter bringt dann weiß ich auch nicht. Geh doch mal an die frische Luft. Mir kommts so vor als ob du den Wald vor lauter Bäumen nicht mehr siehst.

- Alex


----------



## ArtooDetoo (19. Feb 2009)

tuxedo hat gesagt.:


> Mir kommts so vor als ob du den Wald vor lauter Bäumen nicht mehr siehst.



Gut möglich ... ich bin seit vorgestern da am rumüberlegen und verwerfe eine idee nach der anderen


----------



## ArtooDetoo (19. Feb 2009)

ein problem mit dem progressbar habe ich noch. so wird der wert für den balken berechnet:


```
double barplus = 100 * 16384.0 / size;
double barval = 0;
while ((len = datainput.read(buffer)) > 0) {
  fileoutput.write(buffer, 0, len);
  barval += barplus;
  bar.setValue(Math.min(100, (int) barval));
  bar.repaint();
}
```

mir ist aufgefallen, dass der balken über die 100% "rausschießen" würde, wenn er es könnte. je größer die datei, desto weiter. Ich habe das mal an einem Byte Array getestet: Im Buffer waren aus einer 1556 bytes großen datei 1569 felder belegt.


----------



## Murray (19. Feb 2009)

read gibt ja nicht ohne Grund die Anzagl der gelesenen Bytes zurück - das kann maximal die Länge des Buffers sein, muss es aber nicht. Daher musst Du den Progress anhand der konkreten Werten von len berechnen; die Berechnung von barplus kannst Du Dir schenken.

Und warum sollte barval überhaupt ein double sein?


```
int barval = 0;
while ((len = datainput.read(buffer)) > 0) {
  fileoutput.write(buffer, 0, len);
  barval += len/size;
  bar.setValue(barval));
  bar.repaint();
}
```


----------



## ArtooDetoo (19. Feb 2009)

angenommen len/size ist kleiner 1, dann dürfte sich am barval doch nicht viel ändern, wenns ein int ist oder?


----------



## Murray (19. Feb 2009)

ArtooDetoo hat gesagt.:


> angenommen len/size ist kleiner 0, dann dürfte sich am barval doch nicht viel ändern, wenns ein int ist oder?


Kleiner als 0 kann len/size niemals werden - aber trotzdem ist mein Code von vorhin Quatsch, denn len/size ist entweder 1 oder 0. Daran ändert sich allerdings auch nichts, wenn man das Ergebnis einer float- oder double-Variablen zuweist - (float)(len/size) ist entweder 0.0 oder 1.0.

Besser wäre wohl 
barval += Math.round(100.0*len/size);

(immer unter der Voraussetzung, dass der Wertebereich des ProgressBars von 0-100 geht)


----------



## ArtooDetoo (19. Feb 2009)

ich meinte 1 statt 0, hatte mich nur nicht rechtzeitig korrigiert.
deine neue methode kann so auch nicht funktionieren. wenn size sehr groß ist, wird der wert zu 0 abgerundet, barval ändert sich nicht.
das math.round ist da an der falschen stelle.


----------



## Murray (20. Feb 2009)

Stimmt - damit wäre zwar Dein ursprüngliches Problem gelöst: der Wert kommt nicht mehr über 100%, aber korrekt ist es immer noch nicht.

Was meinst Du dazu?

```
long bytesRead = 0L;
while ((len = datainput.read(buffer)) > 0) {
  fileoutput.write(buffer, 0, len);
  bytesRead += len
  bar.setValue( Math.round(100.0d*bytesRead/size)));
  bar.repaint();
}
```


----------



## ArtooDetoo (22. Feb 2009)

Nun habe ich ein weiteres problem, bei dem ich einfach nicht weiterkomme ...
ich lasse rekursiv einen ordner über die datei-verbindung übertragen. funktioniert anfangs auch wie man sich es vorstellt. nach ca. 1990 (+-5) dateien kommt für alle folgenden dateien nur noch "Address already in use"-Exception. Irgendeine Idee, woran das liegen kann?


----------



## Murray (22. Feb 2009)

Zeig doch mal den Stack-Trace der Fehlermeldung


----------



## ArtooDetoo (22. Feb 2009)

```
java.net.BindException: Address already in use: connect
        at java.net.PlainSocketImpl.socketConnect(Native Method)
        at java.net.PlainSocketImpl.doConnect(PlainSocketImpl.java:333)
        at java.net.PlainSocketImpl.connectToAddress(PlainSocketImpl.java:195)
        at java.net.PlainSocketImpl.connect(PlainSocketImpl.java:182)
        at java.net.SocksSocketImpl.connect(SocksSocketImpl.java:366)
        at java.net.Socket.connect(Socket.java:519)
        at java.net.Socket.connect(Socket.java:469)
        at java.net.Socket.<init>(Socket.java:366)
        at java.net.Socket.<init>(Socket.java:180)
        at NetworkClient.isFile(NetworkClient.java:125)
```
Die isFile-Funktion sieht so aus:
[HIGHLIGHT="Java"]    public int isFile(String path) {
        int isfile = -1;
        try {
            fileclient = new Socket(host, filePort);
            dataoutput = new DataOutputStream(fileclient.getOutputStream());
            datainput = new DataInputStream(fileclient.getInputStream());
            dataoutput.writeUTF("isfile " + password + " " + path);
            isfile = datainput.readInt();
            fileclient.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return isfile;
    }[/HIGHLIGHT]
Die wird auch zwischen den dateiübertragungen oft aufgerufen.


----------



## ArtooDetoo (22. Feb 2009)

ich habe das programm so umgeschrieben, dass die isFile-Funktion auf dem anderen port senden kann, und das nun auch tut. die fehler sind bisher nicht wieder aufgetreten


----------



## ArtooDetoo (22. Feb 2009)

Aah! Großes Problem!
Alles funktionierte. Dann hab ich das Programm im Netz getestet.
Es wird ein Objekt vom Typ File vom Server zum Client übertragen. Dadurch wusste der Client immer, ob er einen Ordner oder Dateien anfordern musste. Das funktioniert jetzt nicht mehr. Wenn der Client auf das vom Server gesendete File-Objekt mit beispielsweise isFile() zugreift, dann wird auf der _lokalen_ Festplatte geschaut...
Fällt jemandem eine einfache Möglichkeit ein, das zu beheben?


----------



## ArtooDetoo (22. Feb 2009)

ok problem gelöst:
eigene file-klasse erzeugt, in der die ganzen daten direkt in objektvariablen geladen werden, und dann übertragen


----------



## tuxedo (23. Feb 2009)

Ja, nicht alles lässt sich so serialisieren wie man's gerne hätte 

Als Fleiß-Übung kannst du das gleiche ja nochmal mit RMI/SIMON nachbauen. Denke du wirst erstaunt sein wie übersichtlich und klein dein Sourcecode auf einmal ist.

- Alex


----------



## ArtooDetoo (23. Feb 2009)

wenns nicht nur übersichtlicher, sondern auch schneller ist, würd ichs mir mal überlegen


----------



## tuxedo (23. Feb 2009)

Naja, RMI/SIMON vereinfacht die ganze Kommunikation drastisch. Du hast nur noch Methodenaufrufe und musst nix mehr durch irgendwelche Streams serialisieren.

Dateien kannst du via SIMON ganz geschickt übertragen. Mit RMI geht's auch, aber halt nicht ganz so schick wie mit SIMON. In beiden Fällen hast du allerdings etwas Overhead bedingt durch das Protokoll. Bei SIMON sionds nur wenige Byte pro Datenblock, bei RMI kommt noch etwas CPU-Overhead dazu, wegen der ganzen reflection/serialisierungegschichte.

Alles in allem: Egal ob RMI oder SIMON: Eine feine Sache und übersichtliche Sache.

- Alex


----------

