Datenverlust (zuviele Daten!) über Sockets

[amnesio]

Hallo leute!

Ich habe hier ein eigenartiges Problem. Ich versende Dateien über eine Socketverbindung von einem PC zum Andern. Dies geschieht über Streams. Ich lese die Daten aus einem FileStream und schreibe sie direkt in stream vom socket. auf der anderen seite geschieht genau das umgekehrte, die empfangenen Daten werden direkt in einen fileoutputstream geschrieben.

Wenn ich nun Server und Client programm beides lokal starte, funktioniert das ganze einwandfrei. Das komische ist, wenn ich den Server bei mir laufen lasse, und ein Client auf einem anderen PC ein File sendet, kriege ich ZUVIEL!!! daten. mein empfangenes file ist also grösser als das versandte.

Server IP, SNM, Gateway:
160.59.122.70
255.255.252.0
160.59.120.1

Client IP, SNM, Gateway:
160.59.126.68
255.255.252.0
160.59.124.1

Hat irgendjemand einen Schimmer woher das kommt?

Danke und Gruss

 

[The_S]

kA, aber poste doch mal relevanten Code

 

[amnesio]

Die InputStreams die saveFile() erhält sind die socket.getInputStream()

package com.spak.homer.client.ctrl;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;

import com.spak.homer.core.Log;
import com.spak.homer.data.FileInfo;
import com.spak.homer.data.TransactionInfo;

public class FileOutTransaction extends FileTransaction {

	public FileOutTransaction(File _file, TransactionInfo _transactionInfo, FileInfo _fileInfo) {
		super(_file, _transactionInfo, _fileInfo);
	}

	public void run() {
		if(Thread.currentThread()==getThread()) {
			try {
				Log.debug(getClass(), "Connecting to "+getTransactionInfo().getIp()+" on "+getTransactionInfo().getPort());
				Socket server = new Socket(getTransactionInfo().getIp(), getTransactionInfo().getPort());
				Log.debug(getClass(), "Connected");
				
				OutputStream stream = server.getOutputStream();
				
				FileInputStream fis = new FileInputStream(getFile());
				int b = 0;
				byte[] bytes = new byte[1024];
				Log.debug(getClass(), "Stream ready");
				while((b=fis.read(bytes))!=-1) {
					stream.write(bytes);
					setTransferred(getTransferred()+b);
				}
				Log.debug(getClass(), "Data written");
				fis.close();
				stream.close();
				Log.debug(getClass(), "Connection closed");
				server.close();
			} catch(IOException e) {
				Log.exc(getClass(), e);
			}
		}
	}
}


package com.spak.homer.ctrl;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;

import com.spak.homer.core.Log;
import com.spak.homer.data.FileInfo;

public class FileManager {
	private static FileManager instance;
	
	private String fileRoot;
	
	private FileManager() {
		
	}
	
	public static FileManager getInstance() {
		if(FileManager.instance==null) {
			FileManager.instance = new FileManager();
		}
		return FileManager.instance;
	}
	
	public FileInputStream getFile(FileInfo _file) {
		FileInputStream result = null;
		
		File f = new File(fileRoot+getFilename(_file));
		
		try {
			result = new FileInputStream(f);
		} catch(IOException e) {
			Log.exc(getClass(), e);
		}
		
		return result;
	}
	
	public boolean saveFile(InputStream _stream, FileInfo _file) {
		boolean result = false;
		
		
		File f = new File(fileRoot+getFilename(_file));
		try {
			Log.debug(getClass(), "Creating new file '"+f.getAbsolutePath()+"'");
			f.createNewFile();
		} catch(IOException e) {
			Log.exc(getClass(), e);
		}
		
		try {
			FileOutputStream s = new FileOutputStream(f);
			try {
				Log.debug(getClass(), "Writing bytes to file...");

				int b = 0;
				byte[] bytes = new byte[1024];
				while((b=_stream.read(bytes))!=-1) {
					s.write(bytes);
				}
				Log.debug(getClass(), "Closing streams...");
				
				s.close();

				Log.debug(getClass(), "File written completely.");

				result = true;
			} catch(IOException e) {
				Log.exc(getClass(), e);
			}
		} catch(FileNotFoundException e) {
			Log.exc(getClass(), e);
		}
		
		return result;
	}
	
	private String getFilename(FileInfo _file) {
		return _file.getFilePK()+"_"+_file.getFilename();
	}

	public void setFileRoot(String fileRoot) {
		this.fileRoot = fileRoot;
	}

	public String getFileRoot() {
		return this.fileRoot;
	}
}

 

[Murray]

Sollte es in Zeile 34 nicht heissen:

stream.write(bytes, 0, b);

Im Moment schreibst Du ja immer den ganzen Buffer von 1024 Bytes, auch wenn eventuell weniger gelesen worden sind.

 

[amnesio]

Herrlich, es funktioniert!

ich dachte mir immer dass dies nicht das problem sein könnte weil bis auf den "letzten" buffer immer alle randvoll sein müssten, und die grossen unterschiede der Dateigrössen somit nicht begründet wären. Anscheinend ist dies wohl anders, cool!

vielen dank!