Prevent invalid memory access valgrind C - c

Question

I am trying to understand why valgrind is screaming at me (pretty new to C programming and valgrind).
I implemented a generic linked list (found in github - thanks to fabianosalles) that holds struct that looks like this:
typedef struct symbol_entity
{
/* Symbol name */
char *name;
/* Symbol address */
unsigned int address;
/* Indicates if symbol is extern */
bool is_extern;
/* Indicates if symbol is entry */
bool is_entry;
/* Indicates if symbol is instruction */
bool is_instruction;
/* Indicates if symbol is opcode */
bool is_opcode;
} symbol_entity;
Furthermore, I implemented a method that insert data to the linked list called add_symbol_to_list_with_result.
It returns true and set result_symbol to the one who was added to list in case added successfully. Otherwise if symbol already exists it returns false and should initialize result_symbol to null. (maybe there is a better choice, you are more than welcome to suggest!)
bool add_symbol_to_list_with_result(linked_list **symbols, char *name, bool is_extern, bool is_entry, bool is_instruction, bool is_opcode, unsigned int address, symbol_entity **result_symbol)
{
*result_symbol = (symbol_entity *)verified_malloc(sizeof(symbol_entity));
(*result_symbol)->name = verified_malloc(sizeof(char) * strlen(name));
strncpy((*result_symbol)->name, name, strlen(name));
(*result_symbol)->is_extern = is_extern;
(*result_symbol)->is_entry = is_entry;
(*result_symbol)->is_instruction = is_instruction;
(*result_symbol)->address = address;
(*result_symbol)->is_opcode = is_opcode;
if (!list_contains(*symbols, *result_symbol))
{
list_add(*symbols, *result_symbol);
return TRUE;
}
free(*result_symbol);
result_symbol = NULL;
return FALSE;
}
list_add looks like:
void list_add(linked_list *list, void *data)
{
node_item *newNode;
if (list != NULL && data != NULL)
{
newNode = verified_malloc(sizeof(node_item));
newNode->data = verified_malloc(list->data_size);
memcpy(newNode->data, data, list->data_size);
if (list->head == NULL)
{
list->head = newNode;
list->tail = newNode;
}
else
{
list->tail->next = newNode;
list->tail = newNode;
}
list->count++;
}
}
and of course verified malloc looks like:
void *verified_malloc(long size)
{
void *ptr;
ptr = malloc(size);
if (ptr == NULL)
{
printf("Fatal error! Memory allocation failed!");
exit(1);
}
return ptr;
}
add_symbol_to_list_with_result method get called multiple times, and I can see in valgrind output stuff like that:
==9179== Uninitialised value was created by a heap allocation
==9179== at 0x402D17C: malloc (in /usr/lib/valgrind/vgpreload_memcheck-x86-linux.so)
==9179== by 0x804C074: verified_malloc (in /home/user/.....)
==9179== by 0x804A0F5: list_add (in /home/user/.....)
==9179== by 0x804B4E6: add_symbol_to_list_with_result (in /home/user/.....)
=
.
.
.
==9179== Address 0x4263d94 is 0 bytes after a block of size 4 alloc'd
==9179== at 0x402D17C: malloc (in /usr/lib/valgrind/vgpreload_memcheck-x86-linux.so)
==9179== by 0x804C074: verified_malloc (in /home/user/.....)
==9179== by 0x804B454: add_symbol_to_list_with_result (in /home/user/.....)
Any help with this type of output?
EDIT:
symbols is declared in a different C file:
linked_list *symbols;
linked_list initialized with this method:
linked_list *list_create(int dataSize, callback_free free_callback, callback_compare compare_callback)
{
linked_list *list;
if (dataSize > 0)
{
/* Initialize parameters in linked list */
list = (linked_list *)verified_malloc(sizeof(linked_list));
list->count = 0;
list->data_size = dataSize;
list->head = NULL;
list->tail = NULL;
list->callback_free = free_callback;
list->callback_compare = compare_callback;
}
return list;
}
and is passes to multiple methods using &symbols

Answer 1

Please try
(*result_symbol)->name = verified_malloc(sizeof(char) * (strlen(name)+1));
to account for the required "\0" at end of string.
And after line
strncpy((*result_symbol)->name, name, strlen(name));
include the line
(*result_symbol)->name[strlen(name)]='\0'
just to be sure.
Furthermore, I would guess an allocation problem for **symbol which goes into bool add_symbol_to_list_with_result - please show the allocation for **symbol.
Question
Is list->data_size equal to sizeof(symbol_entity)?
memcpy(newNode->data, data, list->data_size);
Please try
memcpy(newNode->data, data, sizeof(symbol_entity));
Memory handling
Please note that your memory handling of *result_symbol is not accurate: In case of return TRUE, you keep *result_symbol completely, although only char array of name pointer would be required (*result_symbol was copied.)
In case of return FALSE, you free *result_symbol, but not the name pointer.
In both cases some memory is lost.
Missing code
Yes, the additional code which you provided is useful. However, as larger parts, like the other typedef structdefinitions and any memory handling above the provided subroutines is missing, ... I can not see anything more. In the beginning, you refer to github. Do you have link to more (the full) code?