Discussion :

[zul]

Il suffit de décomposer ton entier dans la base (char) ( donc une base 256 ). Je suppose que la norme ne parle pas d'entier mais d'un entier de taille fixe. Pour un int32_t par exemple, il peut se mettre sous la forme

a = a1 + a2 * 256 + a3 * (256 * 256 ) + a4 * ( 256 * 256 256 ).


a1,a2,a3,a4 appartenant au domaine des char. Il faut ensuite les mettre dans le bon ordre ( je suppose big endian mais je ne connais pas la norme BER ).

[Emmanuel Delahaye]

Oui enfin je te mettais juste le type de mon tableau, j'aurais pu mettre l'allocation c'est sur mais ça servait a rien ici. C'était juste pour montrer sur quoi je travaillais et ce que je voulais faire.

Désolé d'être sensible à la qualité du code...

J'ai osé le faire en pensant que tu comprendrais la question, et non pour que tu dises "il manque des choses dans ta construction" parce que si je dois copier tout mon code on s'en sors pas.

Ma question ct comment mettre un int dans "unsigned char *chaine", ça ne portait pas sur mon allocation....

OK, mais tu persistes à parler de 'chaine' ce qui est une erreur de conception. Il s'agit d'un codage 'binaire'.

Ensuite la question 'mettre un int dans unsigned char *chaine' n'a aucun sens. chaine est un pointeur. Pourquoi tu veux mettre un int dans un pointeur ?

La vrai question, je la connais, mais je constate que tu n'arrives pas à la formuler... C'est parce que tu ne sais pas exactement de quoi tu parles.

Est-tu capable de répondre à ces questions :

• Qu'est-ce qu'un flux d'octets ?
• Que signifie BER ?
• Qu'est-ce qu'un entier en BER ?
• Quelle est la représentation d'un entier en BER ?

Quand tu sauras répondre à ces questions (qui n'ont rien à voir avec le langage C) tu sauras faire le codage quelque soit le langage. On ne peut pas coder si on ne sait pas ce qu'il y a à faire. Commence par exprimer tes besoins clairement avec les mots justes.

[Lolita59]

• Qu'est-ce qu'un flux d'octets ?
  c'est pour moi un ensemble d'octets bout à bout composant une trame qui est envoyé sur un réseau après encapsulation dans UDP (dans mon cas).
• Que signifie BER ?
  Basic Encoding Rules, ce sont les normes du codage de données. Cela fonctionne selon le modèle TLV ( Type Longueur Valeur)
• Qu'est-ce qu'un entier en BER ?
  Un entier en BER est un nombre possédant le tag 0x02 mais sinon c'est juste un entier qui est ensuite codé en binaire
• Quelle est la représentation d'un entier en BER ?
  le tag : 00000010 ou 0x02
  la taille : 00000100
  sa valeur : ********

Donc je sais pas si j'ai tout bien compris mais ma question serait plutot : Comment on crée une chaine binaire dans laquelle mettre tous mes élements en les formatant en binaire en fait ?

Ainsi que ceci : Si je met mes élements dans une chaine de caractères, est-ce que lors de leur envoi dans la trame finale, ceux ci sont codés en binaire ? Et dans quel type faut-il les mettre pour que lors de leur codage en binaire, ils soient décodable de l'autre coté...

[Emmanuel Delahaye]

• Qu'est-ce qu'un flux d'octets ?
  c'est pour moi un ensemble d'octets bout à bout composant une trame qui est envoyé sur un réseau après encapsulation dans UDP (dans mon cas).

OK. Dans un programme C, on utilise une fonction qui envoi un bloc de donnée (sendto()). Ce bloc est matérialisé par un tableau de unsigned char dont on passe l'adresse et le nombre d'élements à envoyer à sendto().

• Que signifie BER ?
  Basic Encoding Rules, ce sont les normes du codage de données. Cela fonctionne selon le modèle TLV (Type Longueur Valeur)

TLV, certes, mais c'est un peu plus complexe que ça. Il y a une notion de structure et de plus le codage de la longueur est assez tordu si je me souviens bien...

• Qu'est-ce qu'un entier en BER ?
  Un entier en BER est un nombre possédant le tag 0x02 mais sinon c'est juste un entier qui est ensuite codé en binaire

Il manque des informations importantes :

• la taille (nombre de bits ou d'octets)
• la représentation (emplacement du MSB etc.)

• Quelle est la représentation d'un entier en BER ?
  le tag : 00000010 ou 0x02
  la taille : 00000100
  sa valeur : ********

Bon, on a la taille (4 octets, je suppose...)

Il manque toujours la représentation mémoire. Zul a esquissé une solution, mais il faudrait être sûr du format (Sur un réseau, les conventions habituelles, c'est 'MSB en tête')

Donc je sais pas si j'ai tout bien compris mais ma question serait plutot : Comment on crée une chaine binaire dans laquelle mettre tous mes élements en les formatant en binaire en fait ?

Ca dépend du format demandé.

Si on admet MSB en tête, on doit donc mettre un mot de 32 bits dans un bloc de 4 octets selon le principe suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
unsigned long data = 123456;
 
bloc[0] = (data >> (8 * 3)) & 0xFF; /* MSB */
bloc[1] = (data >> (8 * 2)) & 0xFF;
bloc[2] = (data >> (8 * 1)) & 0xFF;
bloc[3] = (data >> (8 * 0)) & 0xFF; /* LSB */

Ce bloc peut évidemment faire partie d'un buffer d'émission, dana ce cas, on a (par exemple)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
buffer[0] = 0x02; /* T INTEGER */
buffer[1] = 0x04; /* L */
buffer[2] = (data >> (8 * 3)) & 0xFF; /* V : MSB */
buffer[3] = (data >> (8 * 2)) & 0xFF;
buffer[4] = (data >> (8 * 1)) & 0xFF;
buffer[5] = (data >> (8 * 0)) & 0xFF; /* LSB */

Ainsi que ceci : Si je met mes élements dans une chaine de caractères, est-ce que lors de leur envoi dans la trame finale, ceux ci sont codés en binaire ? Et dans quel type faut-il les mettre pour que lors de leur codage en binaire, ils soient décodable de l'autre coté...

En BER, aucune 'chaine de caractère' au sens 'C' n'est transmise. Néanmoins, si tu as un tag STRING, une simple copie des caractères suffit, précédée, comme d'habitude, des champs T et L.

Par exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
char const *s = "Hello";
 
buffer[0] = STRING; /* T  */
buffer[1] = strlen(s); /* L  SI < 128 */
buffer[2] = s[0]; /* V : 'H' */
buffer[3] = s[1]; /* V : 'e' */
buffer[4] = s[2]; /* V : 'l' */
buffer[5] = s[3]; /* V : 'l' */
buffer[6] = s[4]; /* V : 'l' */
buffer[7] = s[5]; /* V : 'o' */

on peut aussi utiliser memcpy()...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

memcpy (buffer+ 2, s, buffer[1]); /* V : "Hello" */

Attention. Si je me souviens bien, si la longueur est > 127, le codage de celle-ci est différent...

[Lolita59]

effectivement si la longueur est supérieure à 127 on code sur 2 octets

Je suis en train d'essayer

par contre j'ai du mal a comprendre cette ligne

(data >> (8 * 3)) & 0xFF;

[fearyourself]

par contre j'ai du mal a comprendre cette ligne

(data >> (8 * 3)) & 0xFF;

On décale data de 24 (8*3) bits vers la droite, ce qui revient à diviser data par 2^24.

Ensuite on applique un & binaire avec le nombre 0xFF qui est en fait 255.

Dans le cas présent, cela revient à faire un modulo 256...

Jc

[Emmanuel Delahaye]

effectivement si la longueur est supérieure à 127 on code sur 2 octets

OK, corrigé.

par contre j'ai du mal a comprendre cette ligne
(data >> (8 * 3)) & 0xFF;

Si tu ne connais pas les opérateurs bits, tu es mal... Je te conseille de relire ton K&R2 chapitre A7.8 et suivants...

[Lolita59]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
buffer[0] = 0x02; /* T INTEGER */
buffer[1] = 0x04; /* L */
buffer[2] = (data >> (8 * 3)) & 0xFF; /* V : MSB */
buffer[3] = (data >> (8 * 2)) & 0xFF;
buffer[4] = (data >> (8 * 1)) & 0xFF;
buffer[5] = (data >> (8 * 0)) & 0xFF; /* LSB */

En fait les deux font la meme chose la non ?
Pourquoi utiliser l'un plutot que l'autre ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
char const *s = "Hello";
 
 buffer[0] = STRING; /* T  */
buffer[1] = strlen(s); /* L  SI < 128 */
buffer[2] = s[0]; /* V : 'H' */
buffer[3] = s[1]; /* V : 'e' */
buffer[4] = s[2]; /* V : 'l' */
buffer[5] = s[3]; /* V : 'l' */
buffer[6] = s[4]; /* V : 'l' */
buffer[7] = s[5]; /* V : 'o' */

Pour le codage d'integer , n'est-il pas possible d'utiliser la deuxieme méthode en ajoutant juste un test sur la longueur de cet int ( <128) et coder sur deux champs quand c'est le cas?

[Emmanuel Delahaye]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
buffer[0] = 0x02; /* T INTEGER */
buffer[1] = 0x04; /* L */
buffer[2] = (data >> (8 * 3)) & 0xFF; /* V : MSB */
buffer[3] = (data >> (8 * 2)) & 0xFF;
buffer[4] = (data >> (8 * 1)) & 0xFF;
buffer[5] = (data >> (8 * 0)) & 0xFF; /* LSB */

En fait les deux font la meme chose la non ?

Les deux quoi ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
char const *s = "Hello";
 
 buffer[0] = STRING; /* T  */
buffer[1] = strlen(s); /* L  SI < 128 */
buffer[2] = s[0]; /* V : 'H' */
buffer[3] = s[1]; /* V : 'e' */
buffer[4] = s[2]; /* V : 'l' */
buffer[5] = s[3]; /* V : 'l' */
buffer[6] = s[4]; /* V : 'l' */
buffer[7] = s[5]; /* V : 'o' */

Pour le codage d'integer , n'est-il pas possible d'utiliser la deuxieme méthode en ajoutant juste un test sur la longueur de cet int ( <128) et coder sur deux champs quand c'est le cas?

Non. Si je me souviens bien la taille d'un INTEGER est de 32 bits. Il n'y a donc pas d'autre moyen que d'utiliser 4 octets et de faire la décomposition proposée.

Evidemment, il faut faire une fonction, mais je ne vais pas t'apprendre à coder en C...