Probleme : echange de fichiers par socket

Salut,
je vous presente mon probleme : je souhaite realiser un transfert de fichiers entre 2 machines par socket. Lorsque je transfere un petit fichier (du style 50 ko) tout fonctionne bien. Mais quand j'essaie de transferer un fichier un peu plus gros (un mp3 de 3Mo par exemple), le programme transfere seulement une centaine d'octets et la classe qui sert a l'emission me sort l'erreur : java.net.SocketException: Software caused connection abort: socket write error
Je pense que ca doit merder au niveau des tampons ou quelque chose comme ca mais jai pas reussi a resoudre le probleme.
J'ai 2 classes, une gerant l'emission et une gerant la reception. Je vous copie la source ci-dessous. Si quelqu'un a une idée pour m'aider je le remercie d'avance.
Classe pour l'envoi

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
 
public class EmissionFichier extends Emission implements Runnable {
    private DataOutputStream sortieData;
    private BufferedOutputStream sortie;
    private BufferedInputStream entreeFichier;
    private File fichier;
 
    public EmissionFichier(Donnees d, Connexion c, OutputStream o) {
        super (d,c);
        this.sortie = new BufferedOutputStream (o);
        this.sortieData = new DataOutputStream(o);
    }
 
 
    public void setFichier (File f)  {
        this.fichier = f;
        try {
            this.entreeFichier = new BufferedInputStream(new FileInputStream (f));
        } catch (FileNotFoundException e) {
            connexion.addTexte ("Fichier introuvable");
        }
    }
 
 
    public void envoi ()  {
        int octet;
        String nom = fichier.getName ();
        try {
            sortieData.writeLong(fichier.length()); // on envoie la taille du fichier
            sortieData.writeInt(nom.length()); // on envoie la longueur du nom
            sortieData.writeBytes(nom); // on envoie le nom
            while ((octet = entreeFichier.read()) != -1)  {
                sortie.write(octet);
            }
            sortie.flush();
        }
        catch (IOException g)  {
           System.out.println ("Erreur dans l'envoi du fichier : "+g);
        }
        finally {
              connexion.deconnecter();
        }
    }
 
    public void run() {
        if (fichier != null)
           envoi ();
    }
}

Classe pour la reception

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
 
public class ReceptionFichier extends Reception {
    private DataInputStream entree;
    private FileOutputStream sortieFichier;
    private File fichier;
 
    public ReceptionFichier(Donnees d, Connexion c, InputStream i) {
        super(d, c);
        this.entree = new DataInputStream(new BufferedInputStream(i));
    }
 
 
    public void run() {
        int octet;
        long tailleRecue = 0;
        long tailleFichier = 1;
        try {
            tailleFichier = entree.readLong(); // on lit la taille du fichier
            int longueurNom = entree.readInt();
            // lecture du nom du fichier
            String nom = "";
            for (int i = 0; i < longueurNom; i++) {
                nom += (char)entree.readByte();
            }
            try {
                sortieFichier = new FileOutputStream(nom);
            } catch (FileNotFoundException e) {
                System.out.println("Erreur : " + e);
            }
            while ((octet = entree.readByte()) != -1) {
                sortieFichier.write(octet);
                tailleRecue++;
            }
        } catch (IOException e) {
            // verifier si la taille recue est bien la taille originale
            if (tailleRecue < tailleFichier)
                System.out.println("Erreur : " + e);
        } finally {
            connexion.deconnecter();
        }
    }
}