[Langage C] Problème d'affichage Chat 2 clients

Problème d'affichage Chat 2 clients [Langage C] - C - Programmation

Marsh Posté le 22-12-2017 à 13:28:36    

Bonjour,
 
Pour un projet scolaire, je dois développer un chat, avec 2 clients et 1 serveur.
J'arrive à connecter les 2 clients au serveur, à communiquer aucun soucis.
Mon problème survient lorsque je veux déconnecter 1 client, j'ai fait en sorte que si 1 client écrit le mot "disconnect", la connexion se coupe.
 
Seulement, au moment ou la connexion se coupe, la fenêtre du terminal est flood et je n'arrive pas à comprendre d'ou vient le problème.
 
J'ai un truc du genre sur le terminal :
 
Vous : disconnect
Vous :  
Serveur : Extinction du serveur...
Fermeture du processus...Vous : Vous : Vous : Vous : Vous : Vous : Vous : Vous : Vous : Vous : Vous : client-eduroam779:Programmation sous UNIX shin$ Vous : Vous : Vous : Vous : Vous : Vous : Vous : Vous : Vous : Vous : Vous : Vous : Vous : Vous : Vous : Vous : Vous : Vous : Vous : Vous : Vous : Vous : Vous : Vous : Vous : Vous : Vous : Vous : Vous : Vous : Vous : Vous : Vous : Vous : Vous : Vous : Vous : Vous : Vous : Vous : Vous : Vous : Vous : Vous : V
 
Idem sur l'autre client et au niveau du serveur :
Disconnect detected!
......... Indéfiniment
 
J'vous file le code :
 
Client :

Code :
  1. /*
  3. PROGRAMME CLIENT
  5. */
  7. #include <stdio.h>
  8. #include <stdlib.h>
  9. #include <string.h>
  10. #include <unistd.h>
  11. #include <arpa/inet.h>
  12. #include <netdb.h>
  13. #include <netinet/in.h>
  14. #include <sys/types.h>
  15. #include <sys/socket.h>
  18. #define BUFFER_SIZE 256
  20. // LISTE DES PROTOTYPES DES FONCTIONS //
  21. int cree_socket_tcp_ip(char* ip_socket, int port_socket);
  22. int affiche_adresse_socket(int sock);
  24. // FIN DE LA LISTE DES PROTOTYPES DES FONCTIONS //
  26. int cree_socket_tcp_ip(char* ip_socket, int port_socket)
  27. {
  28. int sock;
  29. struct sockaddr_in adresse;
  30. sock = socket(AF_INET, SOCK_STREAM, 0);
  31. // On gère les cas d'erreur
  32. if (sock < 0)
  33. {
  34.  fprintf(stderr, "Erreur socket\n" );
  35.  return -1;
  36. }
  38. memset(&adresse, 0,sizeof(struct sockaddr_in));
  39. adresse.sin_family = AF_INET;
  40. adresse.sin_port = htons(port_socket);
  41. inet_aton(ip_socket, &adresse.sin_addr);
  43. if(connect(sock, (struct sockaddr*) &adresse, sizeof(struct sockaddr_in)) < 0)
  44. {
  45.  close(sock);
  46.  fprintf(stderr, "Erreur connexion\n" );
  47.  return -1;
  48. }
  50. //printf("%u\n", ntohs(adresse.sin_port));
  51. //affiche_adresse_socket(sock);
  53. return sock;
  54. }
  57. int affiche_adresse_socket(int sock)
  58. {
  59. struct sockaddr_in adr;
  60. socklen_t longueur = sizeof(struct sockaddr_in);
  62. if((getpeername(sock, (struct sockaddr*)&adr, &longueur)) < 0)
  63. {
  64.  fprintf(stderr,"Erreur getsockname in Client.c, affiche_adresse_socket function\n" );
  65.  return -1;
  66. }
  68. printf("IP = %s, Port = %u\n", inet_ntoa(adr.sin_addr), ntohs(adr.sin_port));
  70. return 0;
  72. }
  74. int main(int argc, char* argv[]){
  76. // On contrôle si l'utilisateur a rentré le bon nombre d'arguments
  77. if(argc != 3)
  78. {
  79.  fprintf(stderr, "Mauvaise utilisation\n./client ip_adr port\n" );
  80.  exit(-1);
  81. }
  83. int sock;
  84. char bufferR[BUFFER_SIZE];
  85. char bufferW[BUFFER_SIZE];
  86. int nb;
  87. pid_t pid;
  88. // On crée le socket
  89. sock = cree_socket_tcp_ip(argv[1], atoi(argv[2]));
  90. if(sock < 0)
  91. {
  92.  fprintf(stderr, "Erreur creation socket (Main)\n" );
  93.  exit(-1);
  94. }
  96. nb = 3;
  98. //printf("Connexion reussie à l'adresse : " );
  99. pid = fork();
  100. if(pid == -1)
  101. {
  102.  fprintf(stderr,"Client : Fork error!\n" );
  103.  return -1;
  104. }
  105. else if(pid == 0)
  106. {
  107.  while(1)
  108.  {
  109.   printf("Vous : " );
  110.   fgets(bufferW, BUFFER_SIZE, stdin);
  111.   write(sock, bufferW, BUFFER_SIZE);
  112.  }
  113. }
  114. else
  115. {
  116.  while(nb > 0)
  117.  {
  118.   nb = read(sock, bufferR, BUFFER_SIZE);
  119.   if(strncmp(bufferR, "Extinction du serveur...", 24) == 0){
  120.    printf("\nServeur : %s", bufferR);
  121.    printf("\nFermeture du processus..." );
  122.    fflush(stdin);
  123.    fflush(stdout);
  124.    kill(pid);
  125.    sleep(2);
  126.    exit(1);
  127.   }
  128.   else{
  129.    bufferR[nb - 2] = '\0';
  130.    printf("\nUser : %s", bufferR);
  131.   }
  132.  }
  134. }
  136. close(sock);
  138. }


 
Serveur :
 

Code :
  1. /*
  3. PROGRAMME SERVEUR avec N-CLIENTS
  5. */
  9. #include <stdio.h>
  10. #include <stdlib.h>
  11. #include <string.h>
  12. #include <unistd.h>
  13. #include <arpa/inet.h>
  14. #include <netdb.h>
  15. #include <netinet/in.h>
  16. #include <sys/types.h>
  17. #include <sys/socket.h>
  18. #include <sys/shm.h>
  19. #include <errno.h>
  20. #include <string.h>
  23. #define BUFFER_SIZE 256
  24. #define NB_CLIENTS 2
  27. // LISTE DES PROTOTYPES DES FONCTIONS
  29. int cree_socket_tcp_ip(char* ip_socket, int port_socket);
  30. int affiche_adresse_socket(int sock);
  31. void traite_connection(int *list_client);
  32. void affiche_client(int *list_client);
  33. void affiche_ip_client(int client_sock);
  35. // FIN
  37. int cree_socket_tcp_ip(char* ip_addr, int port)
  38. {
  39. int sock;
  40. struct sockaddr_in serv_addr;
  41. //On gère les cas d'erreur
  42. sock = socket(PF_INET, SOCK_STREAM, 0);
  43. if(sock < 0)
  44. {
  45.  fprintf(stderr, "Erreur socket (cree_socket_tcp_ip function)\n" );
  46.  return -1;
  47. }
  49. memset(&serv_addr, 0, sizeof(struct sockaddr_in));
  51. serv_addr.sin_family = PF_INET;
  52. serv_addr.sin_addr.s_addr = INADDR_ANY;
  53. serv_addr.sin_port = htons(port);
  54. //On vérifie si le bind c'est bien passé
  55. if(bind(sock, (struct sockaddr*) &serv_addr, sizeof(serv_addr)) < 0)
  56. {
  57.  close(sock);
  58.  fprintf(stderr, "Erreur bind (cree_socket_tcp_ip function)\n" );
  59.  return -1;
  60. }
  62. return sock;
  63. }
  65. int affiche_adresse_socket(int descripteur_sock){
  66.         struct sockaddr_in adresse;
  67.         socklen_t longueur = sizeof(struct sockaddr_in);
  69. if (getpeername(descripteur_sock, (struct sockaddr*) &adresse, &longueur) < 0) {
  70.       fprintf(stderr, "Erreur getpeername" );
  71.       return -1;
  72. }
  73. printf("IP client : %s : %d\n", inet_ntoa(adresse.sin_addr), ntohs(adresse.sin_port));
  75.     return 0;
  76. }
  78. void traite_connection(int *list_client)
  79. {
  80. struct sockaddr_in adresse;
  81. socklen_t lg;
  82. char bufferR[BUFFER_SIZE];
  83. char bufferW[BUFFER_SIZE];
  84. int nb = 3;
  85. pid_t pid;
  86. lg = sizeof(struct sockaddr_in);
  87. int i;
  88. int j;
  90.     affiche_client(list_client);
  92. for(i = 0; i < NB_CLIENTS; i++){
  93.  if(getpeername(list_client[i], (struct sockaddr*)&adresse, &lg) < 0)
  94.  {
  95.   fprintf(stderr,"Erreur getpeername, Socket : %d", list_client[i]);
  96.   return;
  97.  }
  98. }
  100. // On crée autant de fils qu'il y a de clients sur le serveur
  101. for( i = 0; i < NB_CLIENTS; i++)
  102. {
  103.  pid = fork();
  104.  if(pid == -1)
  105.  {
  106.   fprintf(stderr, "Erreur fork lors du traitement de la connexion!\n" );
  107.   return;
  108.  }
  109.  else if(pid == 0) // Child processus
  110.  {
  111.   while(nb > 0)
  112.   {
  113.    nb = read(list_client[i], bufferR, BUFFER_SIZE);
  114.    if(strncmp(bufferR, "disconnect", 10) == 0){
  115.     printf("Disconnect detected!\n" );
  116.     strcpy(bufferW, "Extinction du serveur..." );
  117.     fflush(stdin);
  118.     fflush(stdout);
  119.     //affiche_client(list_client);
  120.     for(j = 0; j < NB_CLIENTS; j++){
  121.      //printf("Ecriture du message d'extinction...\n" );
  122.      write(list_client[j], bufferW, BUFFER_SIZE);
  123.     }
  124.     kill(pid);
  125.    }
  126.    else{
  127.     affiche_ip_client(list_client[i]);
  128.     printf(" : %s", bufferR);
  129.     bufferR[nb - 2] = '\0';
  130.     strcpy(bufferW, bufferR);
  131.     for(j = 0; j < NB_CLIENTS; j++)
  132.     {
  133.      if(j != i)
  134.       write(list_client[j], bufferW, BUFFER_SIZE);
  135.     }
  136.    }
  137.   }
  138.  }
  139.  fflush(stdout);
  140. }
  141. /*for(i = 0; i < NB_CLIENTS; i++)
  142.  wait();*/
  144. }
  146. void affiche_client(int *list_client)
  147. {
  148. int i;
  150. printf("List of client's socket :\n" );
  151. for (i = 0; i < NB_CLIENTS; i++)
  152.  printf(" %d ", list_client[i]);
  153. printf("\n" );
  154. }
  156. void affiche_ip_client(int client_sock)
  157. {
  158. struct sockaddr_in adresse;
  159.     socklen_t longueur = sizeof(struct sockaddr_in);
  161. if (getpeername(client_sock, (struct sockaddr*) &adresse, &longueur) < 0) {
  162.       fprintf(stderr, "Erreur getpeername" );
  163.       return;
  164. }
  165. printf("%s", inet_ntoa(adresse.sin_addr));
  166. }
  168. int main(int argc, char* argv[])
  169. {
  171. if(argc != 3)
  172. {
  173.  fprintf(stderr, "Mauvaise utilisation\n./client ip_adr port\n" );
  174.  exit(-1);
  175. }
  177. int sock_contact;
  178. int list_client[NB_CLIENTS];
  179. struct sockaddr_in client_addr;
  180. socklen_t client_lg = sizeof(client_addr);
  181. pid_t pid;
  183. sock_contact = cree_socket_tcp_ip(argv[1], atoi(argv[2]));
  184. if(sock_contact < 0)
  185. {
  186.  fprintf(stderr, "Erreur création socket_contact (Main function)\n" );
  187.  exit(-1);
  188. }
  190. //printf("Socket cree : %d\n", sock_contact);
  192. if(listen(sock_contact, 5) == -1)
  193. {
  194.  fprintf(stderr, "Server: listen failed!\n" );
  195.  return -1;
  196. }
  198. printf("Adresse du serveur : %s : %u\n", argv[1], atoi(argv[2]));
  199. printf("Waiting for connections...\n" );
  201. while(1)
  202. {
  203.  int i;
  204.  for(i = 0; i < NB_CLIENTS; i++)
  205.  {
  206.   list_client[i] = accept(sock_contact, (struct sockaddr *)&client_addr, &client_lg);
  207.   if(list_client[i] < 0)
  208.   {
  209.    fprintf(stderr,"Acceptation failed! for %d\n", i);
  210.    return -1;
  211.   }
  212.   affiche_adresse_socket(list_client[i]);
  213.  }
  215.  pid = fork();
  216.  if(pid == -1)
  217.  {
  218.   fprintf(stderr, "Erreur fork!\n" );
  219.   return -1;
  220.  }
  221.  if(pid == 0) // FIls se charge de traiter la communication entre les clients
  222.  {
  223.   int j = 0;
  224.   close(sock_contact);
  225.   //affiche_client(list_client);
  226.   traite_connection(list_client);
  227.   for(j= 0; j < NB_CLIENTS; j++)
  228.    close(list_client[j]);
  229.   exit(0);
  230.  }
  231.  else // Père close les sockets
  232.  {
  233.   int j = 0;
  234.   for(j = 0; j < NB_CLIENTS; j++)
  235.    close(list_client[j]);
  236.  }
  237. }
  238. return 0;
  239. }


 
Merci beaucoup! :)

Reply

Marsh Posté le 22-12-2017 à 13:28:36   

Reply

Marsh Posté le 22-12-2017 à 15:11:00    

Lignes 107 à 111 du programme client je dirais. Comment tu sors du while(1) ?


---------------
Astres, outil de help-desk GPL : http://sourceforge.net/projects/astres, ICARE, gestion de conf : http://sourceforge.net/projects/icare, Outil Planeta Calandreta : https://framalibre.org/content/planeta-calandreta
Reply

Marsh Posté le 23-12-2017 à 17:55:32    

Yep en effet, c'était bien ça!
 
Merci beaucoup

Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed