Propriété NetworkStream.DataAvailable incohérente en HTTP et HTTPS
Bonjour,
J'ai une application avec un socket persistant (il est ouvert quand l'application démarre et fermé en même temps qu'elle).
Ce socket est utilisé par le serveur pour envoyer des données au client.
Et comme la connexion peut être en HTTP ou HTTPS, j'ai écrit le code suivant :
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| s_tcpClient = new TcpClient(s_server.CometIp, s_server.CometPort);
s_tcpClient.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, false);
s_tcpClient.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReceiveBuffer, CST_STREAM_BUFFER_SIZE);
s_tcpClient.ReceiveTimeout = 0;
s_networkStream = s_tcpClient.GetStream();
if (s_server.Protocol == "HTTPS")
{
SslStream sslStream = new SslStream(
s_tcpClient.GetStream(),
false,
new RemoteCertificateValidationCallback(ValidateServerCertificate)
);
sslStream.AuthenticateAsClient(s_server.CometIp);
s_cometStream = sslStream as Stream;
}
else
{
s_cometStream = s_networkStream as Stream;
} |
Ainsi, quel que soit le protocole (HTTP ou HTTPS), je me retrouve avec le même objet : s_cometStream.
Ensuite, dans un thread, j'ai la boucle suivante qui attend que des données soient disponibles et qui les lit :
Code:
1
2
3
4
5
6
| while (s_networkStream.DataAvailable)
{
numberOfBytesRead = s_cometStream.Read(buffer, 0, buffer.Length);
message.Append(Encoding.UTF8.GetString(buffer, 0, numberOfBytesRead));
ExtractMessages(ref message);
} |
(Cette boucle est elle-même dans une autre boucle, bien sûr).
Ce code fonctionne parfaitement avec une connexion HTTP.
Dès que je reçois des données, s_cometStream.DataAvailable vaut true et celles-ci sont lues par s_cometStream.Read.
Et si les données sont plus grosses que le buffer, DataAvailable reste à true et ça boucle jusqu'à avoir tout lu.
Mais, et c'est là mon souci, en HTTPS, le comportement de s_networkStream.DataAvailable change puisque dès la première lecture, il passe à false, et je manque donc toutes les données qui dépassent du buffer.
Bien sûr, dès que je reçois d'autres données, DataAvailable repasse à true et je récupère la fin des mes données précédentes.
Pourquoi est-ce que DataAvailable devient false alors qu'il reste des données à lire ?
Et surtout, pourquoi le comportement est-il différent en HTTP et en HTTPS ?
C'est comme si toutes les données étaient lues d'un coup (d'où DataAvailable = false) mais qu'elles restaient bloquées à un autre niveau... Peut-être l'endroit où elles sont décryptées, puisqu'on est en HTTPS...
Merci d'avance à tous ceux qui pourront m'éclairer.
