write () and send () résoudre les erreurs => difference?

pourrait-il y avoir une différence dans la résolution des erreurs entre ces deux fonctions ?:
A cette question m’a apporté une autre question … le nombre de caractères est-il toujours identique au nombre d’octets?
Pour plus d’informations: Je l’utilise en C sous Linux pour la communication par socket TCP (sys / socket.h) Merci pour vos réponses.

envoyer()
écrire()

Revenir:
écrire():
En cas de succès, le nombre d’octets écrits est renvoyé (zéro indique que rien n’a été écrit). En cas d’erreur, -1 est renvoyé et errno contient le code d’erreur correct. Si count est égal à zéro et que le descripteur de fichier fait référence à un fichier standard, 0 sera renvoyé sans autre effet. Pour un fichier spécial, les résultats ne sont pas portables.

envoyer():
Les appels renvoient le nombre de caractères envoyés, ou -1 en cas d’erreur.

Question de stackoverflow qui dit que ces méthodes devraient être identiques à l’aide de l’indicateur zéro.
ici

int client_sockfd; char* msg; int length = strlen(msg); //first option if(send(client_sockfd, msg, length, 0) != length) return 1; else return 0; //second option if(write(client_sockfd, msg, length) != length) return 1; else return 0; 

Ils renverront tous les deux le même nombre d’octets écrits (== caractères dans ce cas. EXCEPT notez ceci:

Si le message est trop long pour passer de manière atomique à travers le protocole sous-jacent, l’erreur EMSGSIZE est renvoyée et le message n’est pas transmis.

En d’autres termes, en fonction de la taille des données en cours d’écriture, write () peut réussir, où send () peut échouer.

Nombre d’octets == nombre de caractères, car le standard C réutilise ce caractère sous la forme d’un entier de 1 octet.

write() : Oui, il retourne le nombre d’octets écrits. Mais ce n’est pas toujours une erreur si elle ne renvoie pas autant d’octets qu’elle devrait être écrite. Surtout pas pour la communication TCP. Une socket peut être non bloquante ou simplement occupée, auquel cas vous devrez réécrire les octets non encore écrits. Ce comportement peut être obtenu comme ceci:

 char *buf = (however you acquire your byte buffer); ssize_t len = (total number of bytes to be written out); while (len > 0) { ssize_t written = write(sockfd, buf, len); if (written < 0) { /* now THAT is an error */ break; } len -= written; buf += written; /* tricky pointer arythmetic */ } 

read() : La même chose s'applique ici, avec la seule différence que EOF est indiqué en renvoyant 0 et que ce n'est pas une erreur. Encore une fois, vous devez réessayer la lecture si vous souhaitez recevoir toutes les données disponibles d'un socket.

 int readbytes = 0; char buf[512]; do { readbytes = read(sockfd, buf, 512); if (readbytes < 0) { /* error */ break; } if (readbytes > 0) { /* process your freshly read data chunk */ } } while (readbytes > 0); /* until EOF */ 

Vous pouvez voir mon implémentation d'une simple classe d'assistance TCP en utilisant cette technique à l' adresse https://github.com/H2CO3/TCPHelper/blob/master/TCPHelper.m