Discussion :

[devdev2003]

bonjour,
voilà mon fichier binaire en hexadecimal :

A1 A2 A3 A4 BB DD AA FF

je voudrais lire les 4 premier octet (ecrit en hexadecimal), en decimal !
la valeur du 4 octet en hexa est lu à partir de la fin !
c.à.d :
hex(A4 A3 A2 A1) = ? (decimal)
voilà ou je suis :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main(int argc, char ** argv) {
FILE *infile;
FILE *outfile;
int i=0;
if ((infile = fopen(argv[1], "rb")) == NULL)
{
fprintf(stderr, "Pb ouverture infile !\n");
return(EXIT_FAILURE);
}
if(!fread(&i,1,4, infile))
{
fprintf(stderr,"fread header Failure !\n");
return(EXIT_FAILURE);
}
printf("%d\n",i);
return(EXIT_SUCCESS);
}

la resultat ne convient pas !
Merci

[Trap D]

Fais un printf("%lu", i); ces 4 octets forment un usigned long.
Déclare unsigned long i;

[devdev2003]

avec :

printf("%lu", i);

il fait la convertion directe.
c.à.d il me donne : le decimal du A1 A2 A3 A4 et non A4 A3 A2 A1 (poids fort/faible).
NB :
sur mon pc (debian avec gcc 3.x) ça marche trés bien (resultat = decimal A4A3A2A1).
mais dans le serveur (HP-UX avec gcc 2.9.x) il fais la convertion directement sans prendre en consideration le poid fort/faible (resultat = decimal A1A2A3A4).[/quote]

[Biosox]

c'est lorsque tu initialise ton entier i que les 4 octets peuvent être lus dans un ordre différent suivant la notation de la machine (big endian ou little endian)

dans ton cas particulier, tu n'as qu'a lire les 4 premiers octets les un apres les autres, et "construire" ton entier i a partir de ces 4 octets: ça donne un truc dans le genre:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
int i=0;
char c1=0;
char c2=0;
char c3=0;
char c4=0;
 
fread(&c1,1,1, infile); //c1 contient A1
fread(&c2,1,1, infile); //c2 contient A2
fread(&c3,1,1, infile); //c3 contient A3
fread(&c4,1,1, infile); //c4 contient A4
 
i=(int)c4+(int)c3*255+(int)c2*255*255+(int)c1*255*255*255;
 
printf("%d\n",i);

Comme ça ca devrait marcher dans tous les cas il me semble

[Emmanuel Delahaye]

Code :

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

1
2
3
4
 
i=(int)c4+(int)c3*255+(int)c2*255*255+(int)c1*255*255*255;
 
printf("%d\n",i);

Comme ça ca devrait marcher dans tous les cas il me semble

Tu as testé ? Il faut multiplier par 256, ou mieux, décaler à gauche de 8...

[Biosox]

non j'ai pas testé. effectivement c'est par 256 qu'il faut multiplier, désolé. Je voulais surtout donner une idée pour prendre les 4 premiers bytes dans l'ordre, pour le reste je suis allé un peu vite.

[Trap D]

Et à mon avis il faut utiliser (unsigned long) plutôt que (int)

[devdev2003]

bonjour,
Merci pour votre aide
voilà ce que j'ai fait :

Code :

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

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
 
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main(int argc, char ** argv) {
FILE *infile;
char c1=0;
char c2=0;
char c3=0;
char c4=0;
unsigned long int i=0;
 
   if ((infile = fopen(argv[1], "rb")) == NULL)
     {
       fprintf(stderr, "Pb ouverture infile !\n");
       return(EXIT_FAILURE);
     }
    fread(&c1,1,1, infile);
    fread(&c2,1,1, infile);
    fread(&c3,1,1, infile);
    fread(&c4,1,1, infile);
    i=(unsigned int)c4+(unsigned int)c3*256+(unsigned int)c2*256*256+(unsigned int)c1*256*256*256;
    printf("%lu\n",i);
    return(EXIT_SUCCESS);
}

si dans mon fichier IN j'ai :

90 02 00 00

résultat :

2416050176 // valeur en hex de 90 02 00 00 et non 00 00 02 90 !!

sur mon pc (debian avec gcc 3.x) ça marche trés bien (resultat = decimal A4A3A2A1) avec ce programme :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main(int argc, char ** argv) {
FILE *infile;
FILE *outfile;
int i=0;
if ((infile = fopen(argv[1], "rb")) == NULL)
{
fprintf(stderr, "Pb ouverture infile !\n");
return(EXIT_FAILURE);
}
if(!fread(&i,1,4, infile))
{
fprintf(stderr,"fread header Failure !\n");
return(EXIT_FAILURE);
}
printf("%d\n",i);
return(EXIT_SUCCESS);
}

mais dans le serveur (HP-UX avec gcc 2.9.x) il fais la convertion directement sans prendre en consideration le poid fort/faible (resultat = decimal A1A2A3A4) !!

[Médinoc]

C'est normal, sur les serveurs HP-UX, le processeur n'est généralement pas un x86, mais un autre processeur qui n'a pas l'ordre des octets identique.

Un truc que tu peux faire, c'est tout sauvegarder avec l'ordre des octets "Réseau", qui est le même pour tous.
Bref, ne pas sauver i, mais htonl(i) (host-to-network-long).
Et ensuite, quand tu charges, tu fais i=ntohl(variable chargée).

Sur un x86, htonl et ntohl inversent l'ordre des octets. (htons et noths font la même chose sur des shorts).
Sur un serveur sous HP-UX, ces fonctions ne font rien.