Bonjour,
 
voilà je me heurte à un problème d'envoi par l'intermédiaire de socket. Je souhaite en effet envoyer la valeur des pixels d'une image (compris entre 0 et 255) mais dés que cette valeur est à 0 je rencontre des problèmes pour récupérer mes données. Comment faire pour indiquer à la fonction recv() qu'elle ne doit pas prendre en compte les caractères EOF et ne s'intéresser qu'à la taille du buffer que je lui ai mis en paramètre et de s'arrêter une fois qu'il est plein?  
 
Merci

1. Le titre du sujet contient le mot "envoi", qui se fait normalement par sendto et non pas par recv qui est pour la réception. Cela dit, dans les deux cas, il ne devrait pas y avoir de problème avec le caractère binaire zéro.
 
2. La fonction recvfrom() remplit un buffer sans se soucier du type de caractère. Elle met les caractères alphanumérique et tous les caractères binaires non imprimables qu'elle reçoit, sans distinction. Donc, je soupçonne que le problème est ailleurs.
 
3. La taille du buffer donnée à la fonction recvfrom() est une taille maximale. Cela indique de ne pas faire de débordement.

1. c'est vrai j'ai fait une erreur dans le titre. Pour l'envoi j'utilise la fonction send(), il vaut mieux utilisé sendto()?  
 
2. J'espère que le problème est ailleurs mais lorsque que j'envoie des caractères autre que des 0 je n'ai pas de problèmes pour les réceptionner. Donc je  soupçonnait recv() d'être la cause de mon problème.
 
3. ok

Désolé, j'ai pris mon cas pour une génréalité, car j'utilise sendto() et recvfrom(), mais c'est vrai qu'on peut aussi utiliser send() et recv(). Ces deux dernières fonctions, send() et recv(), ne sont pas non plus sensibles au caractère binaire zéro, ni aux autres caractères.

pourtant lorsque j'envoie avec send() et que je verifie la valeur retournée par cette fonction je vois bien que l'intégralité des octets ont été envoyé. Ca ne peut être donc qu'à la lecture que le problème se pose.
Lorsque que j'envoie un tableau de 76800 cases remplie avec une suite de nombre allant de 0 à 255 je me retrouve avec un tableau rempli de 0 alors que lorsque j'envoie une suite de nombre allant de 1 à 255 ça marche!  
L'ensemble de mes valeurs sont stockées dans un char *.

En étant pointilleux, je dirais qu'un char * ne contient que 4 ou 8 octets selon que l'on est en mode 32-bit ou 64-bit car un char * n'est qu'un pointeur. La zone de mémoire allouée à l'adresse pointée par ce pointeur est plus intéressante que le pointeur.
Sans voir le code, il est difficile de trouver la raison du problème. Pour rappel, voici quelques fonctions qui sont sensibles au caractère null : strlen(), strcpy(), strcat(), sprintf(), scanf().

Pour l'instant je travaille en local en mode 32 bits.
 
voici la partie client:
 

 
Partie serveur:
 

 
La partie serveur récupère donc le message en plusieurs passes et le concatène dans un char *image au fur et à mesure.
 

strlen() !!! (le décompe des octets s'arrête au premier zéro binaire trouvé)
Edit : et snprintf(...%s...) !!! (l'affichage des octets s'arrête au premier zéro binaire trouvé)

aahhhh ok!
comment je peux afficher la taille de mon buffer si il n'est remplie que de zero?
 
tu n'aurais pas une idée de la fonction que je pourrais utiliser pour concaténer mes chaînes alors? je viens de regarder pour strncpy et j'ai bien l'impression qu'elle s'arrête également au caractère EOF.

En étant pointileux encore, EOF n'est pas le bon terme, car EOF veut dire End of File et il n'y apas de fichier ici. De plus ce caractère EOF est parfois le control Z qui vaut 26 en binaire, et pas zéro. Donc, il vaut mieux parler du zéro binaire, ou du caractère nul.
 
Pour connaitre la taille du contenu du buffer, c'est nb_lu=recv(...).
Pour la taille du bloc envoyé, il est impossible de la connaître. C'est pourquoi, habituellement, on envoi d'abord un nombre fixe d'octets (par exemple 8) contenant la taille du bloc qui va être envoyé derrière.
 
Pour la concaténation, sprintf() peut être utilisé, mais pas avec un "%s". A la place, il y a une syntaxe où l'on met la longueur maximale entre "%" et le "s", et on rajoute parfois un point ou un signe moins, et parfois une étoile. Je ne me souviens plus de la syntaxe exacte. Voir la documentation. Personnellement, je fais une petite boucle en traitant caractère par caractère, comme ça c'est plus simple et au moins aussi rapide (car sprintf() ou d'autres fonctions font aussi des boucles qui ne vont pas plus vite).

 
ok
 

 
C'est ce que je fais, j'envoie un int contenant le nombre d'octet que j'envoie et je m'en sers pour allouer la mémoire de mon buffer "image" dans lequel je recompose mon image. je vais me renseigner sur les options du sprintf et autrement je ferais une boucle.  
 
merci

bon le choix a été rapide, une petite boucle et on parle plus!
 
merci beaucoup

http://www.bien-programmer.fr/reseaux.htm#binaire
 
Nota :  
- En mode connecté (TCP, par exemple) : send() / recv()
- En mode non-connecté (UDP, par exemple) : sendto() / recvfrom()