Probleme d'ecrasement de pointeur
Bonjour,
j'ai un probleme d'ecrasement de pointeur , j'ai une fonction qui fais une copie d'adresse entre deux pointeurs génériques :
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
| int
block_list_write_buffer( struct block_list_head * head, void * buffer, unsigned int size )
{
if (check(head != NULL, "Argument head is NULL")&&
check(buffer != NULL, "Argument buffer is NULL")&&
check(size != 0, "Argument size is invalid"))
{
void * ptr_write = NULL;
void * ptr_read = NULL;
unsigned int free_size, size_write, buffer_move = 0;
do
{
ptr_write = block_list_write_begin(head,&free_size);
ptr_read = block_list_get_read(head);
if (size > free_size)
{
size_write = free_size;
}
else
{
size_write = size;
}
memcpy(ptr_write, (void *)((char *)buffer + buffer_move), size_write);
block_list_write_end(head,size_write);
size -= size_write;
buffer_move += size_write;
}
while (size != 0);
return 0;
}
return -1;
} |
la fonction block_list_write_begin retourne l'adresse du pointeur ou il faut ecrire et block_list_write_end decale ce pointeur de N octets que l'on a ecris.
par rapport a ca tout se passe bien, je vous donne d'ailleurs les 2 fonctions :
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
| void *
block_list_write_begin( struct block_list_head * head, unsigned int * size )
{
struct block_list_elem * elem = NULL;
if (check(head != NULL, "Argument head is NULL"))
{
if (!linked_list_is_empty(head))
{
*size = head->free = block_list_get_size_written(head);
}
else
{
elem = block_pool_alloc_as( block_list_elem, head->pool );
if (check(elem != NULL, "Block pool is empty"))
{
block_list_init_elem(elem);
linked_list_append_as( head, elem );
*size = head->free = block_list_get_size_written(head);
}
}
return block_list_get_write(head);
}
return NULL;
} |
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
| int
block_list_write_end( struct block_list_head * head, unsigned int size )
{
if (check(head != NULL, "Argument head is NULL")&&
check(size != 0, "Argument size is invalid"))
{
struct block_list_elem * elem = NULL;
elem = linked_list_last_as( block_list_elem, head );
elem->write += size;
if ( elem->write >= block_pool_size(head->pool) )
{
elem = block_pool_alloc_as( block_list_elem, head->pool );
if (check(elem != NULL, "Block pool is empty"))
{
block_list_init_elem(elem);
linked_list_append_as(head,elem);
}
}
return 0;
}
return -1;
} |
au depart de mon programme j'ai deux pointeurs qui pointent sur la meme adresse , un pointeur write et un pointeur read (normal on a rien ecris ni rien lu), a l'appel de la fonction block_list_write_end ou plutot au second appel mon pointeur read est completement faussé ! il ne pointe plus sur la bonne adresse alors qu'on ne lui a rien demandé !
il semblerais que les elements de la structure contenant le pointeur read sont remplacé par des elements du buffer que je passe en parametre a la fonction block_list_write_buffer.
pour info buffer est un tableau statique d'unsigned int de taille 50.
je bloque depuis hier la dessus et je commence vraiment a secher ! :(
merci d'avance
