Discussion :

[BigBulle]

Bonjour à tous ,

Je développe actuellement un programme qui joue entre autre le rôle de serveur TCP et j'ai un gros problème lors de la réception des données envoyées par le client:

Dans ma boucle de réception, à un certain moment, la fonction 'Receive' de mon socket de réception, normalement bloquante, retourne directement en me renvoyant un nombre de bytes inférieur à celui demandé.
Ce nombre est toujours soit 404 soit 0. Dans le cas où je reçois 0 byte, ma connexion est irrécupérable et la fonction Receive me retournera toujours 0.
Par contre, lorsque je reçois 404 bytes, je reçois parfois les suivants au Receive suivant...

J'ai l'impression que ce phénomène est du à un débordement du buffer de réception lorsque windows prend la main trop longtemps. Est-ce possible?
Pourquoi la fonction Receive retourne simplement sans balancer d'exception?

Le programme client étant programmé par quelqu'un d'autre, je n'y ai pas directement accès. Mais je suis quasi sûr qu'il continue à envoyer ses données.

J'espère que mes explications sont assez claires

Un tout grand merci d'avance ,

BigBulle.

[neptune]

C'est toujours plus facile avec un bout de code :-) Montre nous ce que tu fait!

[BigBulle]

Merci beaucoup pour ta réponse !

Voici le code qui effectue le lancement de mon thread d'accept:

Code :

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

1
2
3
4
5
6
// Création du serveur Tcp
            tcpServer = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            tcpServer.Bind(new IPEndPoint(IPAddress.Any, tcpLocalPort));
            tcpServer.Listen(50);
            acceptTcpClientThread = new Thread(new ParameterizedThreadStart(AcceptTcpClient));
            acceptTcpClientThread.Start(tcpServer);

Voici le code du thread qui effectue l'accept:

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
void AcceptTcpClient(object server)
        {
            Socket s = (Socket)server;
            while (networkIsRunning)
            {
                try
                {
                    Socket newClient = new Socket(s.Accept());
 
                    receptionThreads.Add(new Thread(new ParameterizedThreadStart(TcpReception)));
                    receptionThreads[receptionThreads.Count - 1].Start(newClient);
                }
                catch (Exception ex)
                {
                    WriteLogInformation(ex);
                    Thread.Sleep(500);
                }
            }
 
        }

Voici le code de mon thread de réception. Il est un peu complexe parce que je m'attend à ne pas recevoir tout les bytes en un coup à cause du problème que j'expose dans ce post...

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
void TcpReception(object socket)
        {
            Socket client = (Socket)socket;
 
            byte[] buffer = new byte[528];
 
            try
            {
                while (networkIsRunning && client.Connected /*&& groundIsRunning*/)
                {
                    // Réception d'un nouveau message
                    int currentread = 0;
                    int totalread = 0;
                    int countzero = 0;
                    SocketError code = SocketError.Success;
 
                    do
                    {
                        currentread = client.Receive(buffer, totalread, buffer.Length - totalread, SocketFlags.None, out code);
                        totalread += currentread;
 
                        if (currentread == 0)
                        {
                            countzero++; Thread.Sleep(10);
                            if (countzero > 10) throw new Exception("La connexion " + client.ToString() + " a été perdue.");
                        }
                        if (currentread < buffer.Length) WriteLogInformation("Attention : Connection " + client.ToString() + " => Réception de " + totalread + " bytes.");
                    }
                    while (totalread < buffer.Length);
                }
            }
            catch (Exception ex)
            {
                WriteLogInformation(ex);
            }
        }

J'espère que ça t'éclairera. J'ai retirer le code de traitement des données (décodage des bytes de réception) qui me semblait pas utile.

Merci d'avance,

A+

BigBulle.

[Graffito]

Bonjour,

Dans notre gestion socket, la réception de 0 bytes par le client indique une déconnection que l'on gère en déconnectant le client puis en essayant de le reconnecter.

[BigBulle]

Merci pour ta réponse

Qu'est-ce qui entraîne une déconnexion?
Ton client invoque-t-il Shutdown() puis Close()?