J'ai qqch d'étrange qui se produit avec ma socket TCP
 
Je lance le serveur,
Je lance le client
le clientTCP demande au serveurTCP de lui envoyer un buffer de 3000 octets
le serveur envoi un buffer de 3000 octets
Si j'attend trois minutes ou plus sans rien faire, il ne se passe rien (normal)
 
je fais Ctrl C pour arrêter le client => le client s'arrête
Le serveur agit comme si il avait reçu une nouvelle requete du client
sur sa socket. Il reçoit qqch qui ressemble la requete client précédente mais déformé
 
J'ai sans doute oublié qqch en programmant mais je ne vois pas quoi !!
J'ai fait la même chose avec UDP et il n'y a pas ce problème

et c pas un paquet RST que lui envoie le client pour fermer la connection ?

c'est quoi un paquet RST?

 
v'là le charabiat
en C on peut programmer des socket sans passer par les rst, ack, syn et autres...
 
post le programme, t'as pu oublier n'importe quoi, et ça va être chiant à déterminer comme ça

Merci djoh
 
Je vais essayer de faire qqch pour quitter mon programme autrement qu'avec ctrl C
Mais c'est bizarre, ce qui se passe, c'est comme si au moment où je fait ctrl C, le buffer du client est envoyé au serveur sans que je demande rien

 
mais post ton code, je pense que c'est tout con, mais le déterminé comme ça, c'est pas facile

#include "tcp_serveur.h"
 
char buffer_reception[LG_BUFFER];  
char buffer_emission[LG_BUFFER];  
 
//____________________________________________________________________________________________
//
//       FONCTION serveur_tcp
//____________________________________________________________________________________________
 
int serveur_tcp (const char * hote_serveur, int port_serveur)
{
 int socket_gestion_connexions;
 int socket_connectee;
 struct sockaddr_in adresse;
 socklen_t longueur;
 
 socket_gestion_connexions = cree_socket_stream (hote_serveur, port_serveur);
 if (socket_gestion_connexions < 0)
  return (-1);
 listen (socket_gestion_connexions, 5);
 
 while (! quitter_le_serveur ()) {
  longueur = sizeof (struct sockaddr_in);
  socket_connectee = accept (socket_gestion_connexions, & adresse, & longueur);
  if (socket_connectee < 0) {
   perror ("accept" );
   return (-1);
  }
  switch (fork ()) {
   case 0 : // fils
    close (socket_gestion_connexions);
    traite_connexion (socket_connectee);
    exit (0);
   case -1 :
    perror ("fork" );
    return (-1);
   default : // père
    close (socket_connectee);
  }
 }
 return (0);
}
 
//____________________________________________________________________________________________
//
//       FONCTION creer_socket_stream
//____________________________________________________________________________________________
 
int cree_socket_stream (const char * hote_serveur, int port_serveur)
{
 int sock;
 struct sockaddr_in adresse_serveur;
 
 if ((sock = socket (AF_INET, SOCK_STREAM, 0)) < 0) {
  perror ("socket" );
  return (-1);
 }
 
 memset (&adresse_serveur, 0, sizeof (struct sockaddr_in));
 adresse_serveur.sin_family = AF_INET;
 adresse_serveur.sin_port = htons (port_serveur);
 inet_aton (hote_serveur, & (adresse_serveur.sin_addr));
 
 if (bind (sock, (struct sockaddr *) & adresse_serveur, sizeof (struct sockaddr_in)) < 0) {
  close (sock);
  perror ("bindTCP" );
  return (-1);
 }
     
 return (sock);
}
 
//____________________________________________________________________________________________
//
//       FONCTION quitter_le_serveur
//____________________________________________________________________________________________
 
int quitter_le_serveur (void)
{
 return (0);
}
 
//____________________________________________________________________________________________
//
//       FONCTION traite_connexion
//____________________________________________________________________________________________
 
void traite_connexion (int socket_connectee)
{
 int recu;
 
 int taille_paquets;
 int debit_paquets;
 int duree_envoi_paquets;
 
 while (1)  
 {
  lecture_requete_client_tcp( socket_connectee, &taille_paquets, &debit_paquets,
       &duree_envoi_paquets);
  reponse_requete_client_tcp( socket_connectee, taille_paquets, debit_paquets,  
       duree_envoi_paquets);
  envoi_paquet_fin_tcp(socket_connectee);
 }
 close (socket_connectee);
}
_______________________________________________________
 
 
#include "tcp_client.h"
 
char buffer_reception[LG_BUFFER];  
char buffer_emission[LG_BUFFER];  
 
int client_tcp(const char * hote_serveur, int port_serveur)
{
 int socket_client;
 struct sockaddr_in adresse_serveur;
 int nb_paquets_recus;
 
 // Identification de la socket du serveur
 memset (&adresse_serveur, 0, sizeof (struct sockaddr_in));
 adresse_serveur.sin_family = AF_INET;
 adresse_serveur.sin_port = htons (port_serveur);
 inet_aton (hote_serveur, & (adresse_serveur.sin_addr));
 
 if ((socket_client = socket (AF_INET, SOCK_STREAM, 0)) < 0) {
  perror ("socket" );
  exit (1);
 }
 if (connect (socket_client, (struct sockaddr *) & adresse_serveur, sizeof (struct sockaddr_in)) < 0)
 {
  perror ("connect" );
  exit (1);
 }
 
 while (1)  
 {
  envoi_requete_serveur_tcp(socket_client);
  nb_paquets_recus=0;
  do
  {
  }while(lecture_reponse_serveur_tcp(socket_client, &nb_paquets_recus)!=1);
 }
 return (0);
}

 
si mais en C, tu fais juste un close(socketfd), et c'est tout
c'est un peu plus parlant, et en général, qq'un qui commence à programmer des socket et qui s'est pas renseigné par lui mêmesur tout ce qui est rezo, il ne sait pas ce qu'est un flag rst ou autres

La première fonction appelée par le main est serveur_tcp pour le serveur et client_tcp pour le client.
Après j'ai pas mis les fonction lecture_requete... pour ne pas encombrer le code qui est déjà suffisamment long mais on comprend sans pb ce que font ces fonctions
 

moi je trouve ça pas trop mal, même si c'est pas comme ça que j'ai l'habitude de procéder
 
par contre il manque des fonctions
et je trouve bizarre, ton dernier test, dans le while : en général, le code erreur c'est -1 et pas 1
mais ça dépend comment tu l'as géré dans ta fonction
regarde si c'est pas ça le pb

désolé pour la lisibilité, mais quand j'ai fait le copier coller, les indentations ont disparu

 
pour ça, tu encadre ton code avec les balises :
 [cpp][/cpp]

Le problème ne peut pas venir de envoi_requete serveur et lecture...
envoi_requete_serveur : je fait un send a

 
mais tu es sur qu'elles renvoient 1 en cas d'erreur ?

lecure_requete => le serveur lit la taille du buffer qu'il doit envoyer (recv)
envoi_requete => send buffer
 
Je pense plutôt que ça vient du while(1), parcequ'en fait, le close(socket_connecté) n'est peut être pas atteint

 
 
merde mais je dois parler chinois
la fonction recv ne renvoit pas 1 quand c'est fini
 
et on utilise plutot des read/write pour le tcp

le while(1) c'était à la base pour faire une boucle infinie, mais il faut que je modifie ça
En fait, tant que j'ai pas arrêté le serveur, le client doit poouvoir envoyer un requête au serveur
C'est pour ça que je fais cette boucle infinie
Il faudrait que je puisse savoir quand le client se déconnecte pour pouvoir sortir de cette boucle
et faire le close(socket_connectee)

 
tu peux récupérer le signal enoyé par ^c et exécuter un bout de code
par contre, en général ,c'est le serveur qu'on met en boucle infinie

Comment je peux faire pour que du côté client, après chaque envoi effectué, la socket cliente considère que le buffer est vide
buffer[0]='\0'; j'ai pas trouvé mieux mais si vous savez, prevenez moi