probleme de mémoire

**beLz** · 10/07/2007, 13h36

Salut!

J'ai un problème pour lequel j'aurai bien besoin d'un coup de main

Je mets pas le code car il vraiment dégueulasse vous risquez de pas piger grand chose

En gros, j'écris un parser. Le probleme est que je ne sais évidemment pas ce que je vais lire...

Pour ca donc, j'utilise une suite de structures placées avec des mallocs. Mon fichier est divisé en 3 sections chacune pouvant avoir une longueur inconnue. J'ai donc commencé avec 3 malloc ayant une taille fixée cohérente. Si durant le parse, je trouve plus qu'attendant je fais un realloc. Il arrive parfois que je doive stocker des chaines de caracteres. Afin de pouvoir prédire la longueur de mes structures facilement, je mets les chaines dans un malloc et je garde le pointeur dans la structure.

Arrivons au probleme! Les deux premieres étapes se passent correctement. Cependant à la troisieme, j'ai un realloc qui me balance un core dump !

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
 
*** glibc detected *** ./prog: malloc(): memory corruption: 0x0804e218 ***
======= Backtrace: =========
/lib/tls/i686/cmov/libc.so.6[0xb7ecf1cd]
/lib/tls/i686/cmov/libc.so.6[0xb7ed0115]
/lib/tls/i686/cmov/libc.so.6(__libc_realloc+0xff)[0xb7ed0cdf]
./prog[0x804982d]
./prog[0x804b78e]
/lib/tls/i686/cmov/libc.so.6(__libc_start_main+0xdc)[0xb7e7d8cc]
./prog[0x8048a71]
======= Memory map: ========
08048000-0804d000 r-xp 00000000 16:01 1749898    /home/prog
0804d000-0804e000 rw-p 00005000 16:01 1749898    /home/prog
0804e000-0806f000 rw-p 0804e000 00:00 0          [heap]
b7d00000-b7d21000 rw-p b7d00000 00:00 0 
b7d21000-b7e00000 ---p b7d21000 00:00 0 
b7e52000-b7e5c000 r-xp 00000000 16:01 964784     /lib/libgcc_s.so.1
b7e5c000-b7e5d000 rw-p 00009000 16:01 964784     /lib/libgcc_s.so.1
b7e67000-b7e68000 rw-p b7e67000 00:00 0 
b7e68000-b7f95000 r-xp 00000000 16:01 964792     /lib/tls/i686/cmov/libc-2.4.so
b7f95000-b7f97000 r--p 0012c000 16:01 964792     /lib/tls/i686/cmov/libc-2.4.so
b7f97000-b7f99000 rw-p 0012e000 16:01 964792     /lib/tls/i686/cmov/libc-2.4.so
b7f99000-b7f9c000 rw-p b7fAbandon (core dumped)

Ces problemes sont arrivés par le fait que j'ai remarqué que mes structures commencaient à empieter sur les strings stockés avec des malloc. Apres avoir vérifié mes pointeurs, ceux-ci pointaient correctement sauf qu'au bout d'un certain temps ils finissent par écraser les premiers strings enregistrés... J'ai donc vérifié mes realloc pour m'assurer qu'ils étaient corrects. Après avoir tout recalculé, j'obtient le core dump

Help ? :p

**Trap D** · 10/07/2007, 13h51

Montre au moins les structures concernées, et les bouts de code de lecture.

Ces problemes sont arrivés par le fait que j'ai remarqué que mes structures commencaient à empieter sur les strings stockés avec des malloc. Apres avoir vérifié mes pointeurs, ceux-ci pointaient correctement sauf qu'au bout d'un certain temps ils finissent par écraser les premiers strings enregistrés... J'ai donc vérifié mes realloc pour m'assurer qu'ils étaient corrects.

Tu as manifestement mal calculé, ce que tu lis dépasse ce que tu as prévu.

**beLz** · 10/07/2007, 14h03

Héhéhé j'ai recalculé et effectivement j'avais écris une connerie dans mes reallocs...

J'ai plus de core dump mais toujours une réécriture sur mes malloc précédents :s Je revérifie et jvous dis où ça en est

**beLz** · 10/07/2007, 16h48

Bon voila j'ai corrigé l'ensemble mais j'ai toujours un écrasement

mon code ressemble à ca :

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
 
if (c.groups == 0)
	p.group = (struct group *) malloc(2* sizeof(struct group));
	if (c.groups % 2 == 0 && c.groups != 0)
		p.group = realloc(p.group, (c.groups+2)* sizeof(struct group));				
	struct group *curgroup;
	curgroup = p.group + c.groups;
	char *ff;
	curgroup->name = malloc(sizeof(char)*40);
	bzero(curgroup->name, sizeof(char)*40);
	memcpy(curgroup->name, f, size);
	while (TRUE) {
		// remplir la mémoire pour le groupe
		// break qd le groupe est fini
		}
}

Voila l'idée de mon code, je fais un malloc pour le name de chaque groupe. Mon probleme est qu'il met le nom en mémoire à l'adresse 134542552. Mon groupe commence en 134542344. Et au fur et à mesure du remplissage et des realloc, les groupes finissent par passer au dessus du malloc des name. Jpige pas comment il faut eviter le probleme! Heeeelp

**Trap D** · 10/07/2007, 17h02

Ton code n'est pas très "safe" :

Tu ne testes jamais le retour de malloc et de realloc.
On n'utilise pas comme celà le realloc, on prend un pointeur intermédiaire comme résultat du realloc, et si ce pointeur n'est pas NULL, alos on affecte sa valeur au pointeur initial.
Es-tu sur de size dans ton memcpy, s'il dépasse 40 tu es mal