Problème avec memcpy

Bonjour,
Enfaîte, je voulais retourner un message qui contient tout ces champs là :
sizeof(unsigned int) + sizeof(char) + sizeof(uid_t) + sizeof(gid_t) + strlen(imprimante) + strlen(reference) + 2

du coup j'ai commencé à programmer un truc mais ça marche pas et aussi je sais pas comment faire pour ajouter à ce message le getuid() et le getgid():

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

#include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/stat.h> #include <unistd.h> #include <dirent.h>       char *message(char *imprimante, char *reference){ char *message1; message1= malloc(sizeof(unsigned int) + sizeof(char) +sizeof(uid_t) + + sizeof(gid_t) + strlen(imprimante) + strlen(reference) + 2); memcpy(message1,imprimante,strlen(imprimante)+ 1); memcpy(message1,reference,strlen(reference)+ 1);   return (message1);   }   int main(){ char *message1; char *message2; message1 = "loulou"; message2 = "lala"; printf("le message est : %s\n",message(message1, message2));   return 0; }

---

Merci pour votre aide.

Tu devrais regarder du côté de sprintf().

Voir :faq:
http://c.developpez.com/faq/?page=st...RINGS_strtonum
http://c.developpez.com/faq/?page=st...STRINGS_strcat

Citation:

---

Envoyé par kahrah

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

memcpy(message1,imprimante,strlen(imprimante)+ 1); memcpy(message1,reference,strlen(reference)+ 1);   return (message1);   }   int main(){ char *message1; char *message2; message1 = "loulou"; message2 = "lala"; printf("le message est : %s\n",message(message1, message2));   return 0; }

---

---

Salut
memcpy() n'est pas fait pour copier des chaines mais des zones mémoires. Donc la zone copiée n'est absolument pas assurée de contenir le '\0' final nécessaire à toute chaine
2 solutions

1. tu rajoutes toi-même le '\0' avant de renvoyer la chaine
2. tu utilises strcpy() au lieu de memcpy()

Ensuite, comme l'a dit Bktero, quand tu veux créer une chaine plus complexe, vaut mieux utiliser sprintf() plus pratique que de le faire à la main (possible mais fastidieux)

@Sve@r: memcpy(dest, src, strlen(src)+1) copie le caractère nul terminal.

@kahrah: Si tu veux les stocker directement sous forme de nombre (plutôt qu'en tant que chaîne de caractères) le seul problème pour ça sera de respecter l'endianness à utiliser (l'ordre des octets du nombre).

Traditionnellement pour des données transmises sur un réseau, il est recommandé d'utilisé l'ordre big-endian (on commence par le poids fort) quelle que soit l'endianness de la machine. Ainsi, on aurait:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57

#include <limits.h>   //Écrit un nombre en big-endian, octet par octet writeNumber(void* buffer, unsigned long long number, size_t numberSize) { //Index commençant à 1 (on va de numberSize à 1 inclus) unsigned char * byteBuffer = buffer; size_t byte1basedIndex = numberSize; for( byte1basedIndex = numberSize ; byte1basedIndex>0 ; byte1basedIndex--) { //Index commençant à zéro (va de numberSize-1 à zéro inclus) size_t byte0basedIndex = byte1basedIndex - 1; //On prend l'octet correspondant unsigned char theByte = (unsigned char)(number >> (byte0basedIndex*CHAR_BIT));   //On l'écrit dans le buffer *byteBuffer = theByte; byteBuffer++; } }   char *creerMessage(int a, char b, char const*imprimante, char const*reference) { char *message1; message1= malloc(sizeof(unsigned int) + sizeof(char) + sizeof(uid_t) + sizeof(gid_t) + strlen(imprimante) + strlen(reference) + 2); if(message1 != NULL) { char* ecriture = message1; //On écrit en avançant le pointeur à chaque fois writeNumber(ecriture, a, sizeof(int)); ecriture += sizeof(int); writeNumber(ecriture, b, sizeof(char)); ecriture += sizeof(char); writeNumber(ecriture, getuid(), sizeof(uid_t)); ecriture += sizeof(uid_t); writeNumber(ecriture, getgid(), sizeof(gid_t)); ecriture += sizeof(gid_t); memcpy(ecriture, imprimante, strlen(imprimante)+1); ecriture += strlen(imprimante)+1; memcpy(ecriture, reference, strlen(reference)+1); ecriture += strlen(reference)+1; }   return (message1); }   int main(void){ char const *message1; char const *message2; char * message3; message1 = "loulou"; message2 = "lala"; message3 = creerMessage(42, 1, message1, message2); //On ne peut pas afficher le message obtenu avec printf() vu qu'il contient des données binaires free(message3); return 0; }

---

Par contre, c'est assez dûr de retrouver la taille. Sauf si le fameux int au début est censé être ça.

Citation:

---

Envoyé par Médinoc

@Sve@r: memcpy(dest, src, strlen(src)+1) copie le caractère nul terminal.

---

Exact, j'avais pas lu l'instruction en détail. Ceci dit, pourquoi faire simple...

Citation:

---

Envoyé par Médinoc

Traditionnellement pour des données transmises sur un réseau, il est recommandé d'utilisé l'ordre big-endian

---

Ca je savais pas. Je sais utiliser les primitives htons() et htonl() et leurs inverses ntohs() et ntohl() mais le fait qu'un "net short" ou "net long" soit big-endian ou little-endian restait pour moi un détail mineur (voire inutile)

Citation:

---

Envoyé par Sve@r

Ceci dit, pourquoi faire simple...

---

Dans le cas actuel, je pense que c'est stupide. Par contre, si tu avais eu:

Code:

---

1 2 3 4

size_t cchSize = strlen(src)+1; size_t cbSize = cchSize * sizeof *src; char* dest = malloc(cbSize); memcpy(dest, src, cbSize);

---

Ce serait sans doute plus rapide avec memcpy() (qui peut copier par mots entiers) qu'avec strcpy() (qui doit vérifier chaque octet).
Mais bien sûr, c'est de l'optimisation prématurée.