Discussion :

[AlexXx_29]

Bonjour tout le monde, j'ai un petit problème de transfert de fichier avec la connexion SSL. Le transfert marcher très bien sans le SSL!

Je vous met le code concerné en dessous:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
 
 
 
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.SocketException;
import java.net.SocketTimeoutException;
import java.util.logging.Logger;
 
import javax.net.ssl.SSLServerSocket;
import javax.net.ssl.SSLSocket;
 
public class Reception_Fichier implements Runnable {
 
	// Après 10 minute sans connection, le serveur s'arrête(1000 = 1 seconde )
	public static final int ACCEPT_TIMEOUT = 60000;
 
	private SSLSocket ssls;
	private final File directory;
	private SSLServerSocket sslss;
	public static byte[] data = new byte[512];
	protected static final Logger logger = Logger.getLogger(Reception_Fichier.class.getName());
	public boolean over = true;
	OutputStream os;
 
	public Reception_Fichier(File directory, int port, SSLSocket s,
			SSLServerSocket ss) {
 
		this.directory = directory;
		this.ssls = s;
		this.sslss = ss;
 
	}
 
	private void transfer(InputStream is, OutputStream os) throws IOException {
		System.out.println("etape3 échange ");
		for (int i = is.read(data); i >= 0; i = is.read(data))
			os.write(data, 0, i);
		System.out.println("fin echange ");
		over = false;
	}
 
	public void run() {
 
		System.out.println("etape1 échange ");
		try {
			sslss.setSoTimeout(ACCEPT_TIMEOUT);
		} catch (SocketException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}
		while (over) {
 
			try {
				os = new BufferedOutputStream(
						new FileOutputStream(new File(directory,
								ssls.getInetAddress() + "-"
										+ ssls.getPort() + ".wma")));
				// Sauvegarde les données dans un fichiers nommé avec
				// l'adresse et le port du client
				try {
					Thread.sleep(6000);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				System.out.println("etape2  échange ");
				transfer(ssls.getInputStream(), os);
				over = false;
 
			} catch (SocketTimeoutException e) {
				System.err
				.println("Le Serveur s'arrête pour cause de non connexion");
				break;
 
			} catch (IOException e) {
				e.printStackTrace();
				//continue; // Treat the next incoming client
			}
 
		}
 
	}
}

Et voici les erreurs reçues:

Un Client veut entamer un échange
etape1 échange
etape2 échange
etape3 échange
java.net.SocketException: Connection reset
at java.net.SocketInputStream.read(SocketInputStream.java:196)
at java.net.SocketInputStream.read(SocketInputStream.java:122)
at sun.security.ssl.InputRecord.readFully(InputRecord.java:442)
at sun.security.ssl.InputRecord.read(InputRecord.java:480)
at sun.security.ssl.SSLSocketImpl.readRecord(SSLSocketImpl.java:927)
at sun.security.ssl.SSLSocketImpl.readDataRecord(SSLSocketImpl.java:884)
at sun.security.ssl.AppInputStream.read(AppInputStream.java:102)
at java.io.InputStream.read(InputStream.java:101)
at Reception_Fichier.transfer(Reception_Fichier.java:39)
at Reception_Fichier.run(Reception_Fichier.java:70)
at java.lang.Thread.run(Thread.java:724)
etape2 échange
etape3 échange javax.net.ssl.SSLException: Connection has been shutdown: javax.net.ssl.SSLException: java.net.SocketException: Connection reset

at sun.security.ssl.SSLSocketImpl.checkEOF(SSLSocketImpl.java:1476)
at sun.security.ssl.AppInputStream.read(AppInputStream.java:92)
at java.io.InputStream.read(InputStream.java:101)
at Reception_Fichier.transfer(Reception_Fichier.java:39)
at Reception_Fichier.run(Reception_Fichier.java:70)
at java.lang.Thread.run(Thread.java:724)
Caused by: javax.net.ssl.SSLException: java.net.SocketException: Connection reset
at sun.security.ssl.Alerts.getSSLException(Alerts.java:208)
at sun.security.ssl.SSLSocketImpl.fatal(SSLSocketImpl.java:1884)
at sun.security.ssl.SSLSocketImpl.fatal(SSLSocketImpl.java:1842)
at sun.security.ssl.SSLSocketImpl.handleException(SSLSocketImpl.java:1806)
at sun.security.ssl.SSLSocketImpl.handleException(SSLSocketImpl.java:1751)
at sun.security.ssl.AppInputStream.read(AppInputStream.java:113)
... 4 more
Caused by: java.net.SocketException: Connection reset
at java.net.SocketInputStream.read(SocketInputStream.java:196)
at java.net.SocketInputStream.read(SocketInputStream.java:122)
at sun.security.ssl.InputRecord.readFully(InputRecord.java:442)
at sun.security.ssl.InputRecord.read(InputRecord.java:480)
at sun.security.ssl.SSLSocketImpl.readRecord(SSLSocketImpl.java:927)
at sun.security.ssl.SSLSocketImpl.readDataRecord(SSLSocketImpl.java:884)
at sun.security.ssl.AppInputStream.read(AppInputStream.java:102)
... 4 more

[tchize_]

On peux voir la partie où tu établis la connexion.
Tu établis bien une connexion sur un port supportant le SSL?

[AlexXx_29]

Oui effectivement j'établi bien une connexion SSL. Le problème c'est que arriver au 3/4 de l'envoi du fichier ces erreurs apparaisses. Voici ma class de connection et celle du service:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
 
 
 
import java.io.*;
import java.util.Properties;
import java.util.logging.FileHandler;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.logging.SimpleFormatter;
 
import javax.net.ssl.SSLPeerUnverifiedException;
import javax.net.ssl.SSLServerSocket;
import javax.net.ssl.SSLSession;
import javax.net.ssl.SSLSocket;
 
 
/**
 * <b>connexion est la classe qui permet d'accepter les connexions entrantes.</b>
 * 
 * @author Dupuis.Alexandre
 * @version 1.0
 */
public class Connexion {
 
 
	/**
     * 
     */
	protected static Logger loggerACS = Logger.getLogger(Connexion.class.getName());
	private String Mod_Auth;
	private Properties properties;
	private SSLServerSocket sslss = null;
	private SSLSocket ssls = null;
	private SSLSession sslsession = null;
	private FileHandler fh = null;
	private Service_AFC apc = null;
	boolean ecoute = true;
 
	public Connexion(Properties properties, Configuration_Connexion cc) {
 
		this.properties = properties;
		this.Mod_Auth = (String) properties.get("Mod_Auth");
		this.ssls = cc.getSsls();
		this.sslss = cc.getSslss();
		initLoggerACS();
 
	}
 
	/**
     * 
     */
	public void start() {
 
		while (ecoute) {
 
			initConnexion();
 
			sslsession = ssls.getSession();
 
			System.out.print("client présent \n");
 
 
 
			try {
 
				if (sslsession.getPeerCertificateChain() != null) {
 
					System.out.println(sslsession.getPeerCertificateChain()
							.toString());
 
 
					if (this.Mod_Auth
							.equalsIgnoreCase("Authentification_Certificat")) {
 
 
						apc = new Service_AFC(ssls, sslss,
								sslsession, properties);
						apc.run();
 
					}
					ecoute = false;
				}
			} catch (SSLPeerUnverifiedException e) {
 
				e.printStackTrace();
				System.out.println("L'identité ou la validation du client n'a pas pu être effectuée\n" + e);
			}
 
		}
	}
 
 
	/**
     *
     */
	public void initConnexion() {
 
		System.out.print("Attendre une connexion ... ");
 
		try {
 
			this.ssls = (SSLSocket) this.sslss.accept();
			System.out.println("Un Client veut se connecter\n");
			loggerACS.log(Level.INFO, ssls.toString() + "\n");
 
		} catch (IOException e) {
 
			e.printStackTrace();
 
			try {
				ssls.close();
			} catch (IOException e1) {
				// TODO Auto-generated catch block
				e.printStackTrace();
 
			}
		}
 
 
	}
 
 
	/**
     *
     */
	public void initLoggerACS() {
 
		try {
			fh = new FileHandler("log/"
					+ Connexion.class.getName() + "%u%g.log");
			SimpleFormatter sf = new SimpleFormatter();
			fh.setFormatter(sf);
 
		} catch (SecurityException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
 
		loggerACS = Logger.getLogger("logger");
		loggerACS.setUseParentHandlers(false); // pour supprimer la console par
		// défaut
		fh.setLevel(Level.ALL); // pour n'accepter que les message de niveau
		// &Ge; INFO
		loggerACS.addHandler(fh);
		loggerACS.log(Level.ALL, "Test de logger");
 
	}
 
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
 
 
 
import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.PrintStream;
import java.io.UnsupportedEncodingException;
import javax.net.ssl.SSLServerSocket;
import javax.net.ssl.SSLSession;
import javax.net.ssl.SSLSocket;
 
 
 
 
import java.util.Properties;
import java.util.logging.FileHandler;
import java.util.logging.Level;
import java.util.logging.Logger;
 
 
public class Service_AFC implements Runnable {
 
	protected static Logger loggerAPC = Logger.getLogger(Service_AFC.class.getName());
	private static Thread t3 = null;
	private Properties properties;
	private SSLServerSocket sslss = null;
	private SSLSocket ssls = null;
	private BufferedReader in = null;
	private SSLSession sslsession = null;
	private FileHandler fh = null;
	private Reception_Fichier frs = null;
	private boolean eof = false;
 
 
	public Service_AFC(SSLSocket ssls,
			SSLServerSocket sslss, SSLSession sslsession, Properties properties) {
 
		this.ssls = ssls;
		this.sslss = sslss;
		this.sslsession = sslsession;
		this.properties = properties;
 
	}
 
	// Lit les messages du client.
	public void run() {
		try {
			Thread.sleep(2000);
			loggerAPC.info("Result=" + ssls.getPort());
		} catch (InterruptedException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
 
		}
		System.out.print("début de la réception ... ");
		/*
		try {
 
			in = new BufferedReader(
					new InputStreamReader(ssls.getInputStream()));
			String read = "start";
 
 
			while (!(in.readLine().isEmpty())) {
 
			try{
 
					read = in.readLine();
 
					System.out.println("Client : " + read);
 
			}
			catch (EOFException e){
			e.printStackTrace();
			ssls.close();
		}
 
	}
		*/
			PrintStream ps;
			try {
				ps = new PrintStream(ssls.getOutputStream(), true,
						"ASCII");
			} catch (UnsupportedEncodingException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (IOException e) {
				loggerAPC.severe("Error1");
				// TODO Auto-generated catch block
				e.printStackTrace();
				loggerAPC.severe("Error2");
			}
			//ps.println("Salutation Client");
			System.out.println("\n\nSalutation envoyé\n\n");
 
			//ssls.close();
			//System.out.println("Connexion fermé");
 
			System.out.println("Mise en place de la réception de commande");
			if(ssls.isConnected()){
 
				service();
			}
 
 
 
 
 
 
		/*	
 
		} catch (IOException e) {
			e.printStackTrace();
			System.out.println("Erreur d'envoi " + e);
		} finally {
 
				if (ssls != null)
					try {
						ssls.close();
					} catch (IOException e ) {
						// TODO Auto-generated catch block
						e.printStackTrace();
 
					}*/
 
 
		}
 
	public void InitLogger(){
 
		try {
			fh = new FileHandler("log/Log." + Service_AFC.class.getName() + "%u%g.log");
 
		} catch (SecurityException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
 
		loggerAPC = Logger.getLogger("logger");
 
		loggerAPC.log(Level.INFO, "Test de loggerAPC");
 
		loggerAPC.setUseParentHandlers(false); // pour supprimer la console par défaut
		fh.setLevel(Level.INFO); // pour n'accepter que les message de niveau &Ge; INFO
		loggerAPC.addHandler(fh);
 
	}
 
	public void service(){
 
		System.out.println("Un Client veut entamer un échange ");
 
		frs = new Reception_Fichier(new File(
				"C:/Documents and Settings/*/Bureau"),
				//"C:/Documents and Settings/Administrateur/Bureau"),
				ssls.getPort(), ssls, sslss);
 
		while(!ssls.isBound()){
 
		}
		Thread t3 = new Thread(frs);
		t3.start();
	}
 
	}

[AlexXx_29]

J'ai trouver pourquoi cette erreur est survenu! C'est du au fait que le client ce déconnecter.
Par contre j'ai un autre problème mon fichier fait 197 058 octets, le client envoi bien tout les octets et au final je ne reçois qu'un fichier de 196 608 octets.

Donc 450 octets passé à la trappe je ne sais ou?

[AlexXx_29]

J'ai trouvé d'ou venait le problème!

Il fallait juste fermer le outputStream sinon les deux ou trois dernier packet reçus n'était pas écrit dans le fichier, ce que je trouve particulièrement bizarre.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
private void transfer(InputStream is, OutputStream os) throws IOException {
 
		System.out.println("etape3 échange ");
		for (int i = is.read(data); i >= 0; i = is.read(data)){
			os.write(data, 0, i);
 
		}
		System.out.println("fin echange ");
		over = false;
	}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
private void transfer(InputStream is, OutputStream os) throws IOException {
 
		System.out.println("etape3 échange ");
		for (int i = is.read(data); i >= 0; i = is.read(data)){
			os.write(data, 0, i);
			System.out.println(i);
 
		}
		System.out.println("fin echange ");
		os.close();
		over = false;
	}

[tchize_]

Il fallait juste fermer le outputStream sinon les deux ou trois dernier packet reçus n'était pas écrit dans le fichier, ce que je trouve particulièrement bizarre.

Ben non c'est normal, sinon ça reste dans les buffers, en attente qu'il y aie suffisament de données que pour justifier un IO.

[thelvin]

En fait, dans le cas présent, il n'est pas nécessaire de fermer l'OutputStream tout de suite : c'est celui de la socket, tu peux en avoir besoin plus tard. Il se fermera quand la socket se fermera.

Par contre, vu que c'est un BufferedOutputStream, si tu ne fais pas close() dessus il faut bien penser à faire flush(). Sinon il ne va pas deviner qu'il doit envoyer ce qu'il y a dans le buffer.

C'est, à mon avis, l'un des cas où flush() sert bel et bien à quelque chose.

[tchize_]

meme sans le BufferedOutputStream, le flush reste nécessaire. L'OS a aussi un buffer pour éviter de faire des packet trop petit

[thelvin]

flush() de Java ne concerne que les objets Java et ne s'intéresse pas à ce que fait l'OS.

C'est close() qui s'occupe de finaliser ce genre de choses, et encore, il ne s'occupe que de demander à l'OS de faire ce qu'il peut pour le garantir dans des délais raisonnables conformément à ce qu'il propose.

[tchize_]

Effectivement, après vérification, SocketOutputStream.flush ne fait rien .

J'aurais cru qu'il demanderait un flush à l'OS.