Discussion :

[billone007]

Bonjour à tous,
d'abord, merci à developpez.com d'exister. avec toutes les FAQ, forums, tuto... c'est une vraie mine d'or.
j'ai un client UDP sur mon PC Windows qui possède 2 cartes réseau (l'une pour le réseau entreprise, l'autre pour la carte de test - celle qui nous concerne ici)
le serveur tourne sur un mini-linux embarqué mais ce n'est pas important.
côté client, j'ai un problème d'émission des 1ers paquets à l'ouverture de la connexion : si cela fait plus d'environ 2 min que je n'ai pas communiqué sur cette interface, les 1ers paquets seront perdus (vu avec Wireshark).
si je relance mon test à l'identique mais dans un délai court, tout passe nickel.
de même, si je fais un ping sur cette interface avant de lancer le test, tout passe et je ne perds pas de paquet.
j'en suis revenu à des bases pour le client avec juste un petit exe console et pris du code du site pour isoler le problème mais je ne progresse pas.
il semble que si Windows perd la route pour adresser mon hote serveur, cela va lui prendre du temps à retrouver son chemin (ce qui ne me semble pas délirant)
la question c'est comment faire pour que cette "tache" de Windows soit intégrée au code du client de façon la plus propre possible ?
j'ai tenté en utilisant le bind sur l'adresse de la carte réseau utilisée, utiliser la fonction select avant l'émission mais rien n'y fait
merci d'avance pour votre aide

voici le code du client de test utilisé : [le code provient d'un post du forum d'Emmanuel Delahaye]
dans cet exemple, seule la dernière trame sera visualisée sur Wireshark

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
 
#include <winsock2.h>
#include <stdio.h>
 
struct cnx
{
   SOCKADDR_IN remote;
   SOCKET sock;
};
 
int connexionUDP (struct cnx *p, char *ip, int port)
{
   int ok;
   p->sock = socket (AF_INET, SOCK_DGRAM, IPPROTO_UDP);
   if (p->sock != INVALID_SOCKET)
   {
      p->remote.sin_family = AF_INET;
      p->remote.sin_addr.s_addr = inet_addr (ip);
      p->remote.sin_port = htons (port);
      ok = 1;
   }
   else
   {
      printf ("[udp.cpp][connexionUDP] Connexion UDP impossible\n");
      ok = 0;
   }
   return ok;
}
 
void setMessageUDP (struct cnx *p, char *message)
{
   char msg[255];
   sprintf (msg, "%s\n", message);
 
   sendto (p->sock, msg, strlen (msg), 0, (SOCKADDR *) & p->remote,
           sizeof (SOCKADDR));
}
 
void fermeConnexionUDP (struct cnx *p)
{
   closesocket (p->sock);
}
 
int main (void)
{
   WSADATA wsa_data;
   int err = WSAStartup (MAKEWORD (2, 2), &wsa_data);
   if (!err)
   {
      struct cnx cnx = { 0 };
 
      int ok = connexionUDP (&cnx, "193.1.1.3", 2050);
 
      if (ok)
      {
         setMessageUDP (&cnx, "Hello world 1\n");
         setMessageUDP (&cnx, "Hello world 2\n");
         setMessageUDP (&cnx, "Hello world 3\n");
         setMessageUDP (&cnx, "Hello world 4\n");
         setMessageUDP (&cnx, "Hello world 5\n");
         fermeConnexionUDP (&cnx);
      }
      else
      {
         printf ("error\n");
      }
      WSACleanup ();
   }
   return 0;
}

[billone007]

le problème se produit même en désactivant la carte réseau de l'entreprise, ou entre 2 PC Windows.
La seule solution que j'ai trouvé est de demander un acquittement du serveur après chaque trame émise ==> cela implique qu'à chaque émission, je laisse le temps à Windows de chercher son hote et ainsi toutes les trames sont émises et reçues.

[orfix]

UDP fonctionne en mode non connecté, par conséquent il ne faut pas être surpris si tu ne reçois pas certains messages ou que ces derniers soient désordonnés, autrement comme tu l'as déjà compris il faut implémenter un système d'acquittement et de contrôle de flux, ou tout simplement utiliser TCP par exemple qui lui est fiable.

Cela dit, se serait intéressant de comprendre pourquoi est-ce que précisément seul les premiers paquets sont perdus.

[billone007]

merci pour ta réponse.
en fait, seuls les 1ers paquets sont perdus car le buffer est écrasé par les messages suivants et visiblement non empilés. Le dernier est quant à lui émis car non écrasé par une nouvelle émission.
dans un de mes tests, j'ai émis en boucle jusqu'à voir les 1ers paquets partir : il y avait pas moins d'une 20aine de petits paquets (une 30 aine d'octets chacun) de perdus avant de voir le 1er sur la ligne. Les paquets suivants étaient alors émis sans perte.
pour finir de te répondre, je pensais bien à passer en TCP mais le fait que les trames puissent être concaténées et/ou splittées ne m'arrangeait pas : j'avais la main sur le client mais pas sur le serveur et demander d'ajouter un acquittement sur chaque trame est facile, modifier le protocole, cela ne serait pas passé