Salut !

Voila j'utilise la fonction select pour ne pas bloquer sur un recv lors d'une connexion TCP.
Tout cela fonctionne parfaitement, je recoie uniquement quand le client envoie.

Le probleme c'est à l'inverse quand moi je veux envoyer des données, il n'y a rien qui sort tant que je n'ai pas recu de données....

Pourtant j'ai bien placé mon send à l'exterieur du if(FD_ISSET... donc le send devrait s'executer a chaque tour de boucle..

Voici le bout de code (juste la boucle) :
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
      do
      {
 
           FD_ZERO(&EnsembleLecture); // A chaque tour de boucle on remet a zero l'ensemble
           FD_SET(StructureEchangee->IDSocketClient, &EnsembleLecture); // On met l'id de la socket client dans l'emnsemble de lecture
 
           CodeErreur = select(StructureEchangee->IDSocketClient + 1, &EnsembleLecture, NULL, NULL, NULL); // On vérifie s'il y a des données dans la socket
           if (CodeErreur < 0)
           {
               sprintf(TexteErreur,"Impossible de faire un select sur la socket client du à l'erreur : %d",WSAGetLastError());
               MessageBox(NULL,TexteErreur,"Erreur Générale !",MB_OK | MB_ICONERROR);
               return -1;
           }
 
           if(FD_ISSET(StructureEchangee->IDSocketClient, &EnsembleLecture)) // Si il y a des données dans la socket
           {
                MessageBox(NULL,"select : il y a des donnees","Erreur Générale !",MB_OK | MB_ICONERROR);
                LongueurMessage = recv(StructureEchangee->IDSocketClient, (char*)&StructRecue, sizeof(StructSocket),0); // On recoit la position
                if (LongueurMessage == SOCKET_ERROR)
                {
                    sprintf(TexteErreur,"serv: Impossible de recevoir les données du à l'erreur : %d",WSAGetLastError());
                    MessageBox(NULL,TexteErreur,"Erreur Générale !",MB_OK | MB_ICONERROR);
                    closesocket(StructureEchangee->IDSocketClient);
                    closesocket(StructureEchangee->IDSocketServeur);
                    return -1;
                }
 
                StructureEchangee->PositionJoueurDistant = StructRecue.PositionJoueurLocal; // On met la position du joueur distant dans notre structure locale
 
                if(LongueurMessage == 0) // Recv vaut 0 si on a recu un shutdown
                {
                    StructureEchangee->ActiverTransmission = FALSE; // A notre tour on desactive la transmission ce qui va envoyer un shutdown dans le thread d'emission
                    sleep(2000); // On fait une pause de 1s avant de sortir de la boucle car sinon on ferme la socket avant d'envoyer le shutdown (thread d'envoi)
                }   
            }
 
  //          if((StructureEchangee->PositionJoueurLocal.x != PositionJLocalPrecedente.x) || (StructureEchangee->PositionJoueurLocal.y != PositionJLocalPrecedente.y) || (!StructureEchangee->ActiverTransmission))
   //         { // Si notre position a changé, ou si on recoit une demande d'arret de transmission de l'application principale
 
                 LongueurMessage = send(StructureEchangee->IDSocketClient, (char*)StructureEchangee, sizeof(StructSocket),0);
                 sprintf(TexteErreur,"serv: longeur envoi : %d",LongueurMessage);
                     MessageBox(NULL,TexteErreur,"Erreur Générale !",MB_OK | MB_ICONWARNING);
                 if (LongueurMessage == SOCKET_ERROR)
                 {
                     sprintf(TexteErreur,"serv: Impossible d'envoyer les données du à l'erreur : %d",WSAGetLastError());
                     MessageBox(NULL,TexteErreur,"Erreur Générale !",MB_OK | MB_ICONERROR);
                     return -1;
                 }
 
                 if(!StructureEchangee->ActiverTransmission) // Si on doit arreter la transmission
                 {
                      CodeErreur = shutdown(StructureEchangee->IDSocketClient, 1); // On shutdown les operations sur la socket puisqu'on a 500ms de delai
                      sprintf(TexteErreur,"serv: valeur shutdown : %d",CodeErreur);
                     MessageBox(NULL,TexteErreur,"Erreur Générale !",MB_OK | MB_ICONWARNING);
                      if (LongueurMessage == SOCKET_ERROR)
                      {
                           sprintf(TexteErreur,"Impossible de shutdown la socket du a l'erreur : %d",WSAGetLastError());
                           MessageBox(NULL,TexteErreur,"Erreur Générale !",MB_OK | MB_ICONERROR);
                           return -1;
                      }
                 }
                 else
                 {
                     PositionJLocalPrecedente.x = StructureEchangee->PositionJoueurLocal.x; // On remplace la position precedente par la position actuelle
                     PositionJLocalPrecedente.y = StructureEchangee->PositionJoueurLocal.y; // Ca evite d'envoyer des paquets alors qu'on ne bouge pas
                 }
 
 
      //      }
 
      } while (LongueurMessage != 0); // Shutdown terminé dans les deux sens, on ferme proprement les sockets
Merci!