[Gestion de fichiers] Lecture octet par octet

Version imprimable

Voir 40 message(s) de cette discussion en une page

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:

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:

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' ?

18/09/2006, 10h10
Médinoc

\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()).
18/09/2006, 10h12
kendras

ce qui veut dire que ma fonction ne devrait pas retourner chaine de caractères mais d'octet ?
18/09/2006, 10h13
Médinoc

Ta fonction devrait retourner un tableau d'octets et sa longueur.
18/09/2006, 10h25
Jean-Marc.Bourguet

Citation:

Envoyé par kendras

Code:

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.

Citation:

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.
18/09/2006, 12h11
Emmanuel Delahaye

Citation:

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é.
18/09/2006, 12h17
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:

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

Ca ne fonctionne pas mieux qu'avant.
Code:

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
18/09/2006, 12h21
zooro
Citation:
Envoyé par kendras

Code:

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.
18/09/2006, 12h42
Emmanuel Delahaye
Citation:
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:

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
18/09/2006, 13h48
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
18/09/2006, 13h52
fearyourself

Citation:

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
18/09/2006, 13h55
kendras

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)
18/09/2006, 13h56
zooro

Citation:

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.
18/09/2006, 13h59
kendras

Oki, merci.

Bon bah on va faire comme ça alors

Big Thankx les gars :king:
18/09/2006, 14h00
homeostasie

Citation:

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.

Citation:

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().;)
18/09/2006, 14h13
Emmanuel Delahaye

Citation:

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.
18/09/2006, 14h13
kendras

Citation:

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.
18/09/2006, 14h39
kendras
* cogite cogite *

Citation:

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:

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...
18/09/2006, 14h44
zooro
Citation:
Envoyé par kendras

Code:

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.
18/09/2006, 14h59
homeostasie

Code:

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

Citation:

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.

Citation:

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.

Voir 40 message(s) de cette discussion en une page