Discussion :

[AddicTion]

Bonjour

voila je fait un petit programme et un moment je reçois des informations en boucle car je ne connais pas le nombre d'information.

Je voudrais que si l'utilisateur appuie sur 'q' par exemple il parte sur une condition. Est-ce possible ?

Mais ici la fonction recv est bloquante donc si on a fini de recevoir toutes les données le programme restera bloqué sur l'instruction 'recv' donc si 'q' est actionné ça ne marchera pas ? comment faire sinon ?

J'avais pensé à ceci mais je ne suis pas sur que ça fonctionnera:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
while(1)  // boucle qui reçois des données 
  {
   memset(buffer, '\0', sizeof(buffer)); 
   n = recv(s, buffer, sizeof(buffer) - 1, 0);
   printf("%s\n", buffer);
 
   if (getch(q)) // si j'appuie sur 'q' alors: 
    {
         printf("test ok");
    } 
  }

Merci

[uknow]

Bonjour,

getch() étant une fonction bloquante, ça m'étonnerait que tu obtienne le comportement que tu souhaiterais avoir.

En solution alternative (je suppose que tu utilise un thread vu la boucle while(1)) mets le getch() dans un autre thread qui désactivera celui-ci (pour quoi pas dans le main).

[AddicTion]

alors oui.

Se matin j'ai fait un truc de se genre mais la fonction 'recv' une fois qu'elle ne reçois plus rien bloque donc ça ne marche pas. est-il possible de rendre recv non bloquant seulement à cette endroit ? ou de procéder autrement ?

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
 
int frappe;
 
pthread_t thread;
pthread_create(&thread, NULL, touche, &frappe);
 
  while(1)
  {
   memset(buffa, '\0', sizeof(buffa)); 
   n = recv(s, buffa, sizeof(buffa) - 1, 0);
   printf("%s\n", buffa);
 
   if(frappe=='q')
    {
        printf("test ok\n");
    }
 
    else
    {}
  }        
pthread_join(thread, NULL);
 
...
 
void* touche(void* data)
{
   int *frappe = (int *)data;
 
   while(1)
   {
   *frappe=getch();
   }  
}

[uknow]

Oui l'idée n'était très différente de ça, sauf que tu n'arrête pas le thread qui lit la socket, il faut vérifier la saisie juste après le getch, si c'est un 'q' tu arrête le thread (tu le détruits). Ou si tu veux sortir du programme tu mets un exit(0) (sans oublier de libérer les threads que tu as créé de la mémoire). Logiquement ça marche.

En ce qui est de la fonction recv() il est transparent pour toi que ce soit bloquante ou pas, c'est là l'intérrêt d'avoir utilisé un thread. Reste juste à bien les utiliser.
Sinon j'ai lu dans le man de recv qu'elle pouvait être non bloquante mais il faut changer des option lors de l'ouverture de ta socket, je n'ai pas cresé plus loin.

[AddicTion]

alors j'ai corrigé une petite erreur (fermeture de la fonction 'touche' si 'q' est utilisé)

mais recv semble bien bloquant sur se point car normalement comme dit si j'appuie sur 'q' le programme devrait m'afficher "test ok" mais la rien. Temps que le programme ne reçois rien il se fiche de se qu'il y à après j'ai l'impression.

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
 
int frappe;
 
pthread_t thread;
pthread_create(&thread, NULL, touche, &frappe);
 
  while(1)
  {
   memset(buffa, '\0', sizeof(buffa)); 
   n = recv(s, buffa, sizeof(buffa) - 1, 0);
   printf("%s\n", buffa);
 
   if(frappe=='q')
    {
        printf("test ok\n");
    }
 
    else
    {}
  }        
pthread_join(thread, NULL);
 
...
 
void* touche(void* data)
{
   int *frappe = (int *)data;
 
   while(1)
   {
   *frappe=getch();
 
if(*frappe=='q')
    {
        break;
    }
 
    else
    {}
 
   }  
}

[uknow]

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
 
int frappe;
 
pthread_t thread;
pthread_create(&thread, NULL, touche, &frappe);
 
  while(1)
  {
        memset(buffa, '\0', sizeof(buffa)); 
        n = recv(s, buffa, sizeof(buffa) - 1, 0);
        printf("%s\n", buffa);
  }        
pthread_join(thread, NULL);
 
...
 
void* touche(void* data)
{
   int *frappe = (int *)data;
 
   while(1)
   {
   *frappe=getch();
 
    if(*frappe=='q')
    {
        printf("test ok\n");
 
        //c'est à ce niveau qu'il faudrait quitter ton application (ou autre traitements associés à l'appui sur 'q')
 
        break;
    }
 
    else
    {}
 
   }  
}

[AddicTion]

j'y avais pensé mais en réalité une fois les informations récupérées je veut sortir de la boucle qui se trouve dans main (donc faire un 'break;' à la place de "teste ok") pour continué dans mon main.

ou alors se qu'il faudrait que je fasse, mais pareille je ne suis pas sur que ça marchera c'est une condition que si 'recv' = NULL (ne reçois plus rien) alors ...

mais j'ai peur que ça fasse comme pour la condition pour la touche

ou alors de ce type si 'recv' reçois j'affiche les informations
else, je quitte 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
while(1)
  {
   memset(buffa, '\0', sizeof(buffa));
 
   if (n = recv(s, buffa, sizeof(buffa) - 1, 0))
      {
        printf("%s\n", buffa);
      }
 
   else
      {
        getchar();
        break;
      }
 
  }

mais je ne suis pas sur que la condition if (n = recv(s, buffa, sizeof(buffa) - 1, 0)) soit correcte

edite: la condition ne pose pas de problème de compilation mais ça ne marche pas se n'est pas très logique

[Malka1986]

faut utiliser select pour savoir si tu as quelquechose à lire sur le socket / sur l'entrée standard.

[AddicTion]

faut utiliser select pour savoir si tu as quelquechose à lire sur le socket / sur l'entrée standard.

de cette manière ?

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
 
....
fd_set readfs; // création de l'ensemble de lecture
FD_ZERO(&readfs); // vide l'ensemble de lecture
FD_SET(s_client, &readfs); // ajout de la socket client
 
while(1)
  {
   memset(buffa, '\0', sizeof(buffa));
   n = recv(s, buffa, sizeof(buffa) - 1, 0);
   if (FD_ISSET(s_client, &readfs)) //on regarde si la socket client à des choses à lire
    {
       printf("%s\n", buffa);
    }
 
   else
      {
        getchar();
        break;
      }
 
  }