Intégrité fichier socket

Version imprimable

Bonjour
je suis confronté a un petit problème ,j'effectue un transfert de fichier entre un client et un serveur via les socket ,le problème c'est que la taille des données n'est pas identique :
voici mon code coté client :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
 
 
public class Client  {
	public static void main(String[] args) throws IOException{
	    BufferedOutputStream bos;
	    Socket sock;
	    Socket socket;
	    BufferedReader in;
 
	    try{
	    	socket = new Socket(InetAddress.getLocalHost(),25005);
	    	System.out.println("Connection 1 etabile !");
	    	in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
	    	String nom_fichier = in.readLine();
	    	System.out.println("" + nom_fichier);
	    	socket.close();
 
	    	File f = new File("" + nom_fichier);
	    	bos = new BufferedOutputStream(new FileOutputStream(f));
	    	sock = new Socket(InetAddress.getLocalHost(),25006);
	    	System.out.println("Connection 2 etabile !");
	    	byte buf[] = new byte[1024];
	        int n;
	    	l
	        while((n=sock.getInputStream().read(buf))!=-1){
	            bos.write(buf,0,n);
	        }
	        System.out.println("size :" + f.length());
 
 
	            bos.close();
	    	    sock.close();
	    }
 
	    catch (UnknownHostException e) {
 
            e.printStackTrace();
        }
	    catch (FileNotFoundException e) {
	        e.printStackTrace();
	    } catch (IOException e) {
	        e.printStackTrace();
	      }   
	}
}

et coté serveur :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;
 
 
public class Serveur {
	public static void main(String[] args) throws IOException{
		BufferedInputStream fis;
	    Socket sock;
	    Socket socket;
	    PrintWriter out;
 
	    try{
	    	socket = new  ServerSocket(25005).accept();
	    	out = new PrintWriter(socket.getOutputStream());
 
	    	 File f= new File("merco.jpg");
	    	 String nom_fichier=f.getName();
	    	 System.out.println("" + nom_fichier);
	    	 out.println("" + nom_fichier);
	    	 out.flush();
	    	 out.close();
	    	 socket.close();
 
	    	 fis = new BufferedInputStream(new FileInputStream(f));
 
	    	// String ext = nom_fichier.substring(nom_fichier.lastIndexOf("." ));
 
	         sock = new ServerSocket(25006).accept();
	    	byte buf[] = new byte[1024];
	        int n;
	        while(fis.read(buf)!=-1){
	            sock.getOutputStream().write(buf);
	        }
	        System.out.println("size : " + f.length());
	            fis.close();
	    	    sock.close();
	    }
	    catch (UnknownHostException e) {
 
            e.printStackTrace();
        }
	    catch (FileNotFoundException e) {
	        e.printStackTrace();
	    } catch (IOException e) {
	        e.printStackTrace();
	      }   
	}
}

ce programme transfère bien des données photos et vidéos légère avec une petite différence de taille,mais lors d'un transfert d'une grosse vidéo ,il y a des pertes d'informations conséquentes

merci de vos conseils et/ou suggestion. :ccool:

Bonjour,
essaye de rajouter la ligne suivante avant le close dans le client:

Code:

1
2
3
4
5
6
7
 
...
System.out.println("size :" + f.length());
 
 bos.flush(); // <= Un BufferedOutputStream n'est pas flushé automatiquement à la fermeture, il risque donc de manquer la fin du fichier
	            bos.close();
...

13/02/2013, 14h19
wax78

Quand tu call le close, il flush automatiquement en théorie (cf : Javadoc)
13/02/2013, 14h58
adiGuba
Salut,

Ton problème vient de ce bout de code sur ton serveur :
Code:

1 2 3 while(fis.read(buf)!=-1){ sock.getOutputStream().write(buf); }
:arrow: Tu ne récupère pas le retour de read(), donc tu ne sait pas combien de byte ont été écrit dans le buffer.
Mais malgré cela tu écrits tout le buffer dans la socket (et donc avec potentiellement des octets en trop).

Le pire c'est que tu fait bien cela coté client...

Sinon :
- C'est très "C" de déclarer les variables au début de la méthode :D
- Utilises des try/finally pour libérer les ressources proprement, ou le try-with-ressources de Java 7 si tu peux ;)

a++
13/02/2013, 15h06
Jidefix

Ah damned je venais de trouver :D

Marrant c'était le problème inverse de mon histoire de flush: au lieu de ne pas avoir la fin il l'avait en double!
15/02/2013, 09h38
amath1
Bonjour
j'ai modifié mon code comme vous me l'avez demandé
c'est a dire j'ai mis coté serveur :
Code:

1 2 3 while((n=fis.read(buf))!=-1){ sock.getOutputStream().write(buf,0,n); }
et j'ai flushé le outputstream

je ne comprend pas bien ta remarque adiGuba
quand tu dis que je ne récupère pas le retour du read.
la quantité de donné n'est toujours pas égale
merci de votre aide
15/02/2013, 13h18
adiGuba

Citation:

Envoyé par amath1

je ne comprend pas bien ta remarque adiGuba
quand tu dis que je ne récupère pas le retour du read.
la quantité de donné n'est toujours pas égale

Non et c'est indiqué dans la doc.

read() va lire au minimum un byte, et au maximum de quoi remplir ton tableau. La quantité réel de bytes qui sera lu dépend de l'état du flux.

C'est en particulier vrai dans un flux réseau, où les données ne vont pas arriver forcément en même temps.

Donc il est impératif de lire le retour de read() pour savoir combien de données on été lues, quitte à boucler pour recevoir le reste...

a++