convertir une structure en une suite de doubles octets

Bonjour,

J'ai la structure suivante qui fait 20 octets au total :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

struct ipv4 { unsigned int version:4; unsigned int tailleh:4; uint8_t tos; uint16_t taillet; uint16_t ident; uint16_t offset; uint8_t ttl; uint8_t proto; uint16_t checksum; u_char * a_src; u_char * a_dst; };

---

que j'initialise avec :

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

struct ipv4 header1; header1.version = 0x4; header1.tailleh = 0x5; header1.tos = 0x00; header1.taillet = 0x05be; header1.ident = 0x8fc4; header1.offset = 0x0000; header1.ttl = 0x39; header1.proto = 0x06; header1.checksum = 0x0000; u_char * as = malloc(4*sizeof(u_char)); as[0] = 0xd1; as[1] = 0x55; as[2] = 0xe5; as[3] = 0x68; u_char * ad = malloc(4*sizeof(u_char)); ad[0] = 0xc0; ad[1] = 0xa8; ad[2] = 0x00; ad[3] = 0x0a;   header1.a_src = as; header1.a_dst = ad;

---

Je voudrais mettre cette structure dans un tableau de 16 bits (unsigned short ?) à partir d'une fonction qui récupère un pointeur vers cette structure pour pouvoir faire la fonction de checksum de l'entête ip :P

Je n'y arrive pas surtout à cause des deux derniers champs de 4 octets chacun qui sont traités comme des pointeurs (error: aggregate value used where an integer was expected).

Quelqu'un pourrait il m'aider ?

Merci d'avance !

Si j'ai bien compris, tu veux copier tous les champs de la structure dans un tableau? 16bits, c'est trop petit! Ensuite pour copier les éléments d'un tableau, il te suffit d'une petite boucle while (désolé pour la présentation, pas de balises sur mon téléphone) :

Code:

---

1 2 3 4 5 6

int i = 0; while ((header1->ad[i] != NULL) && (tab[i] != NULL)) { tab[i] = header1->ad[i]; i++; }

---

Attention ce code suppose que tu malloc 1 case de plus à chaque fois, et que tu donnes à la dernière case du tableau la valeur NULL. (Tu devrais toujours le faire d'ailleurs, ainsi que vérifier le retour de malloc). Il est aussi sous entendu que tab est malloqué à une taille suffisante, et qu'il est du meme type que ad.

Je sais faire ça, mais ce n'est pas bon car mon tableau de unsigned short ne doit pas avoir de trou et surtout je dois mettre des éléments qui sont parfois plus petits et parfois plus grand ou même composé de deux char.

J'ai tenté de faire ça (pour un tableau d'octets simples) :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

int i; uchar * ptr = (uchar *) header; uchar * buffer = (uchar *) malloc(10 * sizeof(uchar)); for(i=0;i<12;i++){ buffer[i] = ptr[i]; } for(i=0;i<4;i++){ buffer[12 + i] = header->a_src[i]; } for(i=0;i<4;i++){ buffer[16 + i] = header->a_dst[i]; }

---

mais je n'ai pas les données correctes, il y a des chevauchements c'est anormal :(

Ton malloc me perturbe, tu alloues 10 cases alors que tu en utilises vingt! De plus, il faut absolument que tu suives mes conseils pour le malloc, sinon tu auras des segmentation faults dès que tu appeleras des fonctions système. Fais toi une fonction xmalloc que tu appeleras à la place de malloc et enlève toi une grosse épine du pied! Par ailleurs, tu ne peux pas copier des éléments de type différent, sauf si le type de destination est plus 'grand' que le type de source.

J'ai remplacé 10 par 20 et ça fonctionne bien mieux, j'ai juste à intervertir des octets dans deux cas.

Pour xmalloc effectivement ça vaudrait le coup que je prenne le temps que je m'en fasse une pour tester mais honnêtement, est ce qu'il est possible que je manque de mémoire sur mon système et qu'un malloc ne puisse pas être fait ? (C'est pas un programme à but professionnel).

Citation:

---

Envoyé par feydaykyn

Fais toi une fonction xmalloc que tu appeleras à la place de malloc et enlève toi une grosse épine du pied!

---

Je reste très dubitatif quant à l'intérêt de cette méthode d'une manière générale. En effet, avec une telle méthode :

• On stoppe nécessairement le programme en cas de problème. Ce qui peut être une façon de gérer l'erreur dans certains cas, mais elle n'est pas généralisable.
• On stoppe violemment avec ce que cela implique : pas de log, pas de libération propre des ressources, etc.

Mis à part dans des codes "one-shot" de démo, sample, PoC, je ne pense pas que ce soit une bonne idée.

Je suis d'accord qu'un xmalloc basique n'est pas une très bonne idée, mais s'il est bien fait j'y vois plusieurs avantages: un code plus condensé, une vérification de la taille demandée au système, le nom de la fonction où a eu lieu l'erreur, et bien sur le test du retour du malloc. La libération des ressources est un gros problème, et cette fonction me sert uniquement lors de la première version de mes programmes, ensuite je mets en place une libération propre. Mais dans un premier temps ou pour un programme perso, mieux vaut une vérification à l'arrache que pas du tout, surtout en phase de debug.