negativ array size exception

[Thaflasher]

Hi Forum,

weiss jemand warum ich hier eine negativ array size exception bekomme?

Empfangen:

public void writeFile(Socket socket, String fileLocation) throws IOException, InterruptedException{
	   FileOutputStream fos = new FileOutputStream(createFile(fileLocation));
	   InputStream is = socket.getInputStream();
	   DataInputStream dis = new DataInputStream(is);
	   long sizeinByte = dis.readLong();
		
		byte[] byteArray = new byte[(int) sizeinByte];
		int length;
		byte[] buf;
		int received = 0;
		
		while((length = dis.read(byteArray)) >0){
			
			if(length < (sizeinByte-received)){
				buf = Arrays.copyOf(byteArray, length);
				fos.write(buf);
				received+=length;
				continue;}
				
			else{
				buf = byteArray;
				fos.write(buf);
				fos.close();
				Job job = new Job(newFile, IOController.ID, socket.getInetAddress().toString());
				IOController.ID++;
				receiverQueue.offer(job);
				received = 0;
				try{
				sizeinByte = dis.readLong();
				System.out.println("received: " + sizeinByte);}
				catch(Exception e){
					break;
				}
				byteArray = new byte[(int) sizeinByte];
				fos = new FileOutputStream(createFile(directory+filename+IOController.ID+format));
			}	
		}
		System.out.println("rdy");
   }

Versenden:

public void toByteArray() throws IOException, InterruptedException{
		Job receiveJob = senderQueue.take();
		FileInputStream inputStream = new FileInputStream(receiveJob.getFile());
		DataOutputStream dos = new DataOutputStream(os);

		byte[] byteArray = new byte[(int)receiveJob.getFile().length()];
		inputStream.read(byteArray);
		dos.writeLong(receiveJob.getFile().length());
		dos.write(byteArray);
		Thread.sleep(200);
	}

Beim empfangen crasht er manchmal (nicht immer), da

sizeinByte = dis.readLong();

offenbar etwas negatives zurück gibt. Wie kann das sein? Es sollte eigendlich eine Exception auslösen wenn nichts mehr da ist was man lesen kann und eine negative Länge sollte eigendlich auch nicht möglich sein?

Bin jetzt schon einige male mit dem Debugger durch gegangen werde aber nicht ganz schlau daraus (zumal das Problem ist, das der Fehler nicht immer auftritt).

Wäre es möglich, das es am Paketverlust liegt wenn ich es über das Netzwerk übertrage?

Blubb ???:L bin an dieser Stelle ein wenig ratlos :autsch:

Grüße + Danke

 

[SlaterB]

du postest 26 Zeilen read-Schleife obwohl du schon weißt, dass der Fehler das readLong() am Anfang ist?
das verwirrt ja eher, es sei denn es ist Teil des Problems, was gleich riesige Test-Möglichkeiten bietet:
lasse die Schleife weg, lies auf Client-Seite nur den Long aus, wenn nötig den Rest noch einer kurzen Dummy-Schleife danach,
tritt dann noch das Problem auf?
sofern überhaupt reproduzierbar, das klingt ja besonders schwer bei dir,
beziehst du dich auf Übertragung verschiedener Dateien oder gehts selbst unter komplett gleichen Bedingungen teilweise/ teilweise nicht?

weiteres Vereinfachen könnte dadurch bestehen, beim Sender die Datei wegzulassen und nur konstant bestimmte Longs zu schreiben,
aber wenn es damit dann problemlos klappt wäre auch nicht unbedingt viel an Information gewonnen..

was ist eigentlich sizeinByte genau? Dateien können ja theoretisch auch über die 2.2 GB hinausgehen, die in ein Array passen (Integer.MAX_VALUE),
anderseits dürfte dann schon das Senden abbrechen, gar kein Long gesendet werden..

 

[xehpuk]

Ist der gelesene Wert denn schon negativ? Ansonsten vermute ich den Cast auf int, siehe:

public class LongToInt {
	private static final long UBER_MAX_VALUE = Integer.MAX_VALUE + 1L;

	public static void main(String[] args) {
		System.out.println(UBER_MAX_VALUE);
		System.out.println((int) UBER_MAX_VALUE);
	}
}

 

[nillehammer]

Der Ansatz ist fragwürdig. Daten, von denen man weiß, dass sie mehr Bytes als Integer.MAX_VALUE enthalten können (sonst würdest Du ja keinen long nehmen). In einen Array zu zwängen, der nunmal nicht größer als Integer.MAX_VALUE werden kann.

Darüber hinaus, glaube ich auch, dass die Implementierung fehlerhaft ist, readLong() liest nämlich die nächsten 8 Bytes aus dem Stream und interpretiert sie als long. Das hat nichts mit der Größe zu tun Oder schreibst Du an genau der Stelle auf der anderen Seite des Streams selbst diese Zahl in den Stream? Dann wäre es natürlich ok.

 

[Thaflasher]

Ich verschicke JPG bilder und die alle kleiner sind als 2,2 GB

Auf der Sender-Seite nehme ich die ersten 8 Bytes und schreibe dort mit file.length() die Größe in Bytes in den Stream, anschließend übertrage ich die File. Die writelong() erwartet ein long und da die file.length ein long zurück gibt, hat sich das so angeboten.

Auf der Empfänger-Seite nehme ich die ersten 8 Byte raus (readlong) und stelle so meine Arraygröße ein da ich weiss wieviele Bytes ich erwarte.

Es funktioniert in 7 von 10 Fällen. (Gleiche Files, gleiche Übertragung, jedes mal programm neu gestartet : 2 x negativ array size, 1 x java heap space :autsch: )


Es gibt natürlich auch die writeint() aber dann müsste ich das long von file.length() auf int casten allerdings kann ich gerade die konsequenzen noch nicht ganz abschätzen. Testen werde ich es auf alle fälle mal.

Danke für die Hilfe bisher.

 

[bERt0r]

Normalerweise benutzt man Streams und Buffer so: Buffer mit fixer Größe wird in einer Schleife vom Stream gefüllt und dann abgespeichert bis der Stream leer ist.

 

[faetzminator]

[c]length()[/c] sollte auch bei einem inexistenten File nur [c]0L[/c] zurückgeben. So kann man auch das verwerfen...

 

[Thaflasher]

Das umstellen von writelong auf writeint hatte bisher keine negativen Konsequenzen. War aber leider aber auch nicht die Lösung.

Habe beim Sender das Thread.sleep von 200 auf 500 hoch gestellt. So waren die letzten 15 Testläufe alle erfolgreich.
Bleibt nur noch die Frage warum das die Lösung ist?

@bERt0r: Wie würdest du die Files dann unterscheiden, da du vom Stream ja nur eine lange Kette von bytes bekommst? Den ganzen Stream nach Sonderzeichen absuchen erscheint mir ein wenig zu aufwendig.

 

[SlaterB]

wie viele Zeichen du liest ist von der Buffergröße ziemlich unabhängig, einen kleinen Buffer füllt man eben mehrfach,
durch mitzählen kann man da alles ganz exakt machen,
Beispiel: Buffer 1000, Datei 1 4300, Datei 2 3300:
erst Länge 4300 einlesen, dann 4x den Buffer, dann nur 300 Bytes in den Buffer auch wenn 700 weitere folgen (kann man in der Schleife alles dynamisch zurechtrechnen),
dann zweite Länge auslesen usw.

wenn das große Array den Speicher nicht übermäßig belasten sollte, ist das aber auch nicht so schlimm

bis zum Ende lesen vs. mehrere Files unterscheiden ist eine davon recht unabhängige Frage

-------

zur negativen Zahl fällt mir im Übrigen auch nichts neues ein

 

[bERt0r]

Oder du öffnest einfach pro File einen eigenen Stream. Du könntest sogar pro file einen eigenen Thread machen und das ganze parallel laufen lassen.