Salut
 
J'ai fait une application (sous linux) qui envoie un fichier binaire (avec la fonction send())
à une autre appli (qui le réceptionne avec la fonction recv())
 
Problème : les 2 fichiers ne sont pas identiques
           tous les octets des 2 fichiers sont différents  
 
(le fichier réceptionné fait bien la même taille que l'original)
 
Quelqu'un saurait-il ce qu'il faut faire pour échanger correctement 2 fichiers binaires ?

 
Pourrais tu nous montrer les 4 premiers et 4 derniers octets d'un fichier envoyé et ce qui est reçu ? (je suspecte un problème de conversion little/big endian)

les machines emettrices et receptrices sont elles identiques ? normalement il faut faire un encodage (xdr par exemple) avant de balancer des infos...

 
zi_ril_wanou >  
 
fichier source : 4 premier octets -> fc19fc19
                 4 dernier        -> 0226000    
 
fichier recu   : 4 premier octets -> 00000000
                 4 dernier        -> 06000600
 
georges > Les machines emettrices et receptrices sont bien identiques
 

as-tu testé le code retour su send et du recv ? il disent quoi ?

 
Codes de retour send()/recv() corrects :
 
ils contiennent bien le bon nombre d'octets envoyés/recus
de chaque émission/réception.
 
Le fichier source et celui réceptionné contiennent d'ailleurs
exactement le même nombre d'octets.

 
C'est en TCP ou UDP ? Si c'est UDP, c'est normal !
D'aillleurs NFS utilise UDP, en faisant une vérification...

 
C'est du tcp...

Purée ça se corse    
 
Peux-tu nous faire un petit copier/coller des deux bouts de code de reception et d'emission ?    

 
Je stocke les données recues dans une variable du genre
'char buffer[TAILLE_MAX]'
Puis je les écrit dans un fichier avec write()
 
Est-ce qu'il ne pourrait pas y avoir un problème à ce niveau ?
 
(J'ai essayer avec un tableau de unsigned char,  
mais ça n'a rien changé)

ben ce que je me dis c'est que soit :
   - tu n'envoies pas le bon buffer,
   - tu n'ecris pas le buffer que tu as recu...
mais bon c'est une simple supposition.

EMISSION :
 
fdesc = open(nom_fichier, O_RDONLY);
while((ret_read = read(fdesc, tampon_envoi, sizeof(tampon_envoi))) > 0)
  {
    ret_send = send(desc, tampon_envoi, ret_read, 0);
    if(ret_send == ERREUR)
    {
      cout<<"erreur send : "<<strerror(errno)<<endl;
      exit(0);
    }
  }
 
 
RECEPTION :
  fdesc = creat(fichier, S_IRUSR|S_IWUSR);
  nb_octet_recu = 0;
  do
  {
    ret_recv = recv(desc, tampon_reception, sizeof(tampon_reception), 0);
    if(ret_recv < 0)
    {
      cout<<"erreur recv() : "<<strerror(errno)<<endl;
      close(desc);
      exit(0);
    }
    tampon[ret_recv] = 0;
 
    if(write(fdesc, tampon_reception, ret_recv) == ERREUR)
    {
      cout<<"erreur lors de l'écriture dans le fichier "<<fichier<<" : "<<strerror(errno)<<endl;
      close(desc);
      close(fdesc);
      exit(0);
    }
    nb_octet_recu += ret_recv;
  }while(ret_recv && (taille_inconnue || (nb_octet_recu < taille_fichier)));

je dois sortir la, je regarderai plus tard ce soir si tu as pas trouve

grrrr je sèche là, ça m'a l'air tout bon tout ça.
personne a une idée ?
quand c'est comme ca, je fais des trucs bourrins en general, genre tracer les buffers que j'envoie et ceux que je recois, c'est pas brillant mais ca peut permettre de cibler le truc et trouver une idee.

Problème résolu !
 
J'ai enfin trouvé l'erreur
(un peu long à expliquer, j'utilisais un sizeof()
quand il fallait un strlen(), tout ça avant le code
que j'ai publié ici)
 
 
Merci à ceux qui se sont intéressés à mon problème.