Problème de réception TCP/IP.

Version imprimable

02/04/2007, 16h09
BigBulle

Problème de réception TCP/IP.

Bonjour à tous :D ,

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.
02/04/2007, 16h23
neptune

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

Merci beaucoup pour ta réponse :D !

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

Code:

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:

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:

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.

02/04/2007, 18h29
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.
02/04/2007, 21h27
BigBulle

Merci pour ta réponse :D

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