[Gestion de fichiers] Lecture octet par octet

**kendras** · 18/09/2006, 10h09

J'ai écris une fonction qui me permet de lire un fichier et d'en retourner le contenu dans une chaines de caractères.

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
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
static char *pReadFile(const char *filename)
{
	char *buffer = NULL;
	FILE *fSrc = fopen(filename, "r");
	unsigned int	poc=0;
 
	if (fSrc != NULL)
	{
		fseek(fSrc, 0, SEEK_END);       // aller en fin
		unsigned long size = ftell(fSrc);             // lire la taille
		/* ne pas depasser ce que peut contenir un size_t ... */
		if (size < (size_t) - 1)
		{
			rewind(fSrc);    // rétablir la position
 
			/* allouer le bloc + une place pour le 0 */
			buffer = malloc(size + 1);
			if (buffer != NULL)
			{
				int ok = 0;
				/* lire le ficher (in one glup...) */
				poc = fread(buffer, 1,size, fSrc);
 
				if (ferror(fSrc)) {
					Log(3, "FILE_GET", "Erreur de lecture du fichier '%s' ", filename);
					fclose(fSrc);
				}
 
				Log(1, "FILE_GET", "File siez : '%d' (octets)", poc);		
 
				if (poc == size)
				{
					/* ajouter le 0 final */
					buffer[size] = 0;
					ok = 1;
				}
 
				if (!ok)
				{
					Log(3, "FILE_GET", "Erreur sur taille de fichier attendu : %d -> %d", poc, size);
					/* en cas d'erreur de lecture, liberer le bloc ... */
					free (buffer), buffer = NULL;
				}
			}
		}
		fclose(fSrc), fSrc = NULL;
	}
	else
	{
		Log(3, "FILE_GET", "Impossible d'ouvrir le fichier '%s' ", filename);
	}
 
	return buffer;
}

La fonction tourne bien, sauf sur certains fichiers, qui contiennent des octets "vide" ('0'), équivalent au "end of file".

Exemple de fichier (affiché en hexadécimal):

Code :

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

1
2
3
4
5
6
7
8
00 52 F1 00 F8 F7 F3 F0 F0 F8 F8 F3 F0 F0 F0 F0
F5 F1 F5 F5 F8 F0 F6 F0 F7 F2 F4 F0 F0 F0 F1 F0
F2 F0 F0 F0 F0 F0 F0 F0 F0 F0 F0 F0 F0 F0 F0 F0
F0 F0 F1 F4 F4 F8 F0 F3 F0 F6 F0 F7 F2 F5 F8 F7
F2 F1 F1 F0 F6 F0 F7 F2 F4 F2 F2 F3 F4 F0 F0 F0
F0 F0 00 FD F3 F0 F0 F1 F1 5F E0 00 00 F4 F4 F8
F0 F3 F0 F6 F0 F7 F2 F5 F8 F7 F2 F1 F1 F3 F1 F1
F3 F1 F1 F1 F8 F7 F3 F9 F0 F1 F3 F7 F4 F6 F1 F1

Je suis newbie en C.

Comment lire ce genre de fichier, comprennant des octets '0' ?

**Médinoc** · 18/09/2006, 10h10

\0 n'est pas end of file, c'est juste une fin de chaîne.
Le caractère "fin de fichier texte", c'est Ctrl-Z sous DOS/Windows, Ctrl-D sous Unixoïde.

Et je te conseillerait de lire le fichier en mode binaire plutôt qu'en mode texte (ajoute le caractère 'b' au second paramètre de fopen()).

**kendras** · 18/09/2006, 10h12

ce qui veut dire que ma fonction ne devrait pas retourner chaine de caractères mais d'octet ?

**Médinoc** · 18/09/2006, 10h13

Ta fonction devrait retourner un tableau d'octets et sa longueur.

**Jean-Marc.Bourguet** · 18/09/2006, 10h25

Envoyé par kendras

Code :

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

FILE *fSrc = fopen(filename, "r");

Si tu veux lire des fichiers binaires, il faut les ouvrir avec rb, sinon tu risques d'avoir des problèmes avec les fins de lignes avec Windows et d'autres problèmes avec des plateformes plus exotiques.

Envoyé par Médinoc

Le caractère "fin de fichier texte", c'est Ctrl-Z sous DOS/Windows, Ctrl-D sous Unixoïde.

Il n'y a pas de caractère fin de ligne sous Unix. Le gestionnaire de terminal interprète (généralement, on peut spécifier ce qu'on veut avec stty) CTRL-D comme la nécessité de transmettre le tampon à une application qui serait en attende d'I/O, et les applications interprètent une demande de lecture bloquante retournant 0 bytes comme la fin de fichier.

**Emmanuel Delahaye** · 18/09/2006, 12h11

Envoyé par kendras

J'ai écris une fonction qui me permet de lire un fichier et d'en retourner le contenu dans une chaines de caractères.
<...>
Comment lire ce genre de fichier, comprennant des octets '0' ?

Le fichier semble être un fichier binaire (c'est à dire n'importe quoi, mais pas 'texte').

Pour lire un tel fichier, il fait connaitre sa structure, sinon, on se contente de la lecture octet par octet, mais on ne sait pas quoi en faire, à part les afficher comme le fait l'éditeur hexadécimal que tu as montré.

**kendras** · 18/09/2006, 12h17

En fait, le fichier contient différentes données dans diffférents formats (ASCII, Binaire, et EBCDIC).

Je ne souhaite pas traité le contenu du fichier, mais simplement le lire pour le transférer à une file MQ.

Code :

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

FILE *fSrc = fopen(filename, "rb");

Ca ne fonctionne pas mieux qu'avant.

Code :

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

1
2
poc = fread(buffer, 1,size, fSrc);
printf("\n %s\n", buffer);

Il ne m'affiche rien... pourtant mon fichier fait plus de 5000 octets

**zooro** · 18/09/2006, 12h21

Envoyé par kendras

Code :

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

1
2
poc = fread(buffer, 1,size, fSrc);
printf("\n %s\n", buffer);

Il ne m'affiche rien... pourtant mon fichier fait plus de 5000 octets

Ce n'est pas du texte que tu lis, mais des données binaires. Or le format "%s" est fait pour afficher une chaîne de caractères. C'est donc normal que ça ne fonctionne pas.
Pourtant, dans ton buffer, tu as les données lues dans le fichier. Il te reste à les transférer dans ta file MQ.

**Emmanuel Delahaye** · 18/09/2006, 12h42

Envoyé par kendras

En fait, le fichier contient différentes données dans diffférents formats (ASCII, Binaire, et EBCDIC).

Je ne souhaite pas traité le contenu du fichier, mais simplement le lire pour le transférer à une file MQ.

Code :

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

1
2
poc = fread(buffer, 1,size, fSrc);
printf("\n %s\n", buffer);

Il ne m'affiche rien... pourtant mon fichier fait plus de 5000 octets

Les données ne sont pas du texte mais des octets dont seul celui qui a créé le fichier connait la signification. Tu ne peux pas utiliser printf() si les données ne sont pas du texte pur.

Si tu ne veux que transférer le bloc de données (adresse, longueur), par de problème, mais ne cherche à l'afficher comme ça.

Sinon, ce que je fais dans ces cas là, et à titre de mise au point, c'est d'utiliser une fonction de mon cru qui s'appelle SYS_dump (void const *p, size_t size) qui reçoit une adresse et une longueur, et qui affiche les octets sous forme de valeur hexa avec un champ texte pour ce qui est imprimable...

http://emmanuel-delahaye.developpez.com/clib.htm
Module SYS

**kendras** · 18/09/2006, 13h48

Et comment puis-je faire pour récupérer la taille de mon buffer ?
strlen ne fonctionne pas (à cause de mes octets à 0 qui fausse le résultat), et sizeof me retourne 4 alors que mon fichier test fait 5938 octets

**fearyourself** · 18/09/2006, 13h52

Envoyé par kendras

Et comment puis-je faire pour récupérer la taille de mon buffer ?
strlen ne fonctionne pas (à cause de mes octets à 0 qui fausse le résultat), et sizeof me retourne 4 alors que mon fichier test fait 5938 octets

A ton avis, la variable poc contient quoi, voir la page man en cas de doutes...

Jc

**kendras** · 18/09/2006, 13h55

oui, je sais, mais je voulais savoir s'il n'y avait pas moyen de récupérer la taille autrement.... je suis dans une fonction qui me retourne mon buffer.

La variable poc devient donc initulisable car hors context...
J'aimerai éviter d'avoir à la sortir de mon context (à savoir de ma fonction)

**zooro** · 18/09/2006, 13h56

Envoyé par kendras

Et comment puis-je faire pour récupérer la taille de mon buffer ?
strlen ne fonctionne pas (à cause de mes octets à 0 qui fausse le résultat), et sizeof me retourne 4 alors que mon fichier test fait 5938 octets

strlen n'est utilisable que sur des chaînes de caractères (ce qui n'est pas le cas ici, puisque tes données sont BINAIRES).
sizeof renvoie la taille de la variable, qui est ici un pointeur (soit 4 octets).
Le seul moyen de savoir combien d'octets ont été lus est de récupérer l'information retournée par ta fonction de lecture fread.

**kendras** · 18/09/2006, 13h59

Oki, merci.

Bon bah on va faire comme ça alors

Big Thankx les gars

**homeostasie** · 18/09/2006, 14h00

sizeof me retourne 4 alors que mon fichier test fait 5938 octets

Surement que tu fais sizeof(buffer) et buffer pointe sur l'adresse du premier élément de ton tableau, donc sizeof retourne la taille de ton ponteur, soit généralement 4 octets.

A ton avis, la variable poc contient quoi, voir la page man en cas de doutes...

Attention psoc ne contiendra pas le nombre d'octets mais le nombre d'éléments de x octets. Alors il faut bien jouer avec les paramètres de fread().

**Emmanuel Delahaye** · 18/09/2006, 14h13

Envoyé par kendras

Et comment puis-je faire pour récupérer la taille de mon buffer ?
strlen ne fonctionne pas (à cause de mes octets à 0 qui fausse le résultat), et sizeof me retourne 4 alors que mon fichier test fait 5938 octets

Tu peux faire une mesure avec fseek()/ftell(), mais ce n'est pas forcément utile.

Tu peux aussi charger le fichier par blocs avec fread() (dans certaines conditions, fread() retourne le nombre d'octets chargés), et éventuellement chainer ou assembler les blocs...

Il faut apprendre à bien utiliser fread(). Bien lire la doc.

**kendras** · 18/09/2006, 14h13

Envoyé par homeostasie

Attention psoc ne contiendra pas le nombre d'octets mais le nombre d'éléments de x octets. Alors il faut bien jouer avec les paramètres de fread().

bien vu.
Bon bah je vais regarder le manuel.

**kendras** · 18/09/2006, 14h39

* cogite cogite *

size_t fread (void *ptr, size_t size, size_t nmemb, FILE *stream);
La fonction fread lit nmemb éléments de données, chacun d'eux représentant size octets de long, depuis le flux pointé par stream, et les stocke à l'emplacement pointé par ptr.

fread et fwrite renvoient le nombre d'éléments correctement lus ou écrits (et non pas le nombre d'octets). Si une erreur se produit, ou si la fin du fichier est atteinte en lecture, le nombre renvoyé est plus petit que nmemb et peut même être nul.

Donc techniquement :

Code :

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

1
2
unsigned long size = ftell(fSrc);
poc = fread(buffer, 1,size, fSrc);

Je récupère ma taille en octet et je lis mon fichier en un seul jet.
Donc à priori, je suis OK...

**zooro** · 18/09/2006, 14h44

Envoyé par kendras

Code :

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

1
2
unsigned long size = ftell(fSrc);
poc = fread(buffer, 1,size, fSrc);

Je récupère ma taille en octet et je lis mon fichier en un seul jet.
Donc à priori, je suis OK...

Il faut bien sûr que buffer soit correctement dimensionné, et que tu vérifies que tu as bien lu poc=1 éléments.

**homeostasie** · 18/09/2006, 14h59

Code :

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

poc = fread(buffer, 1,size, fSrc);

Je récupère ma taille en octet et je lis mon fichier en un seul jet.
Donc à priori, je suis OK...

Vérifie la valeur retournée dans poc si ca corresponds au nombre d'octets que tu désirais lire.

Il faut bien sûr que buffer soit correctement dimensionné, et que tu vérifies que tu as bien lu poc=1 éléments.

Non dans ce cas, poc = size éléments de 1 octets, c'est à dire égale au nombre d'octets lus.

[Gestion de fichiers] Lecture octet par octet

C

Discussions similaires

Partager

Partager