如何释放读取文件后分配的空指针

Question

i have this structure filled by loading data from a file. I just found out by sanitaizer that string allocated in this way doesn't be free but i don't know how to do it cause it start as a void* item so i can't free it or give me error. I put here my code where, for every row read from the file there will be a leak of byte of an object.

=================================================================
==12111==ERROR: LeakSanitizer: detected memory leaks

Direct leak of 86031 byte(s) in 711 object(s) allocated from:
    #0 0x7ff09a17c867 in __interceptor_malloc ../../../../src/libsanitizer/asan/asan_malloc_linux.cpp:145
    #1 0x55dd7970854b in load_dictionary (/home/matteo/Scrivania/Algo/laboratorio-algoritmi-2021-2022-main/Esercizio 2/ex2/build/main+0x154b)
    #2 0x55dd797086da in main (/home/matteo/Scrivania/Algo/laboratorio-algoritmi-2021-2022-main/Esercizio 2/ex2/build/main+0x16da)
    #3 0x7ff099ec9d8f in __libc_start_call_main ../sysdeps/nptl/libc_start_call_main.h:58

I tried to free directly the variable row but then progema doesn't work cause a free the variable in the skipList and i can't read or search in it. **Where i must put the free of the item? **
I put the code of the allocation and deallocation...with the read of file There is a better and faster way to read the file? Cause the process seems to stock, it takes more than 5/10 minutes to read the file but the algorithm does not proceed. It doesn't seem to freeze but it does nothing. With the sanitaizer it gives the error of memory that needs to be freed.

struct _SkipList {
    Node *head;
    unsigned int max_level;
    int (*compare)(void*, void*);
};
struct _Node {
    Node **next;
    unsigned int size;
    void *item;
};

static unsigned int load_dictionary(char *filename,SkipList *list )
{
  unsigned int words_count = 0;
  FILE *fp = fopen(filename, "r");
  char *line = NULL;
  size_t len = 0;

  if (list == NULL)
  {
    list = create_skip_list();
  }
  char *word;
  while (getline(&line, &len, fp) != -1)
  {
    words_count++;
    word = malloc((len + 1) * sizeof(char));
    strcpy(word, line);
    strtok(word,"\n");
    insert_skip_list(list, word);
  }
  
  free(line);
  fclose(fp);
  return words_count;
}

SkipList* create_skip_list(){
    SkipList *list = malloc(sizeof(SkipList));
    list->max_level = 0;
    list->compare = NULL;
    list->head = create_head_node(NULL,MAX_HEIGHT);
    return list;
}

Node* create_head_node(void* item, int level){
    if(level <1)
        return NULL;

    Node *node = malloc(sizeof(Node));
    if(node == NULL){
        printf("error malloc node\r\n");
        /* Returning here prevent the program from accessing non allocated
         * memory. */
        return NULL;
    }

    node->item = item;
    node->size = level;

    node->next = (Node**)malloc(level * sizeof(Node *));
    if (!node->next) {
        printf("error malloc node next\r\n");
        free(node);
        return NULL;
    }

    for (int i = 0; i < level; i++)
    {
        node->next[i] = NULL;
    }

    return node;
}

void delete_node_array(Node* node){
   if(node == NULL) return; 
   delete_node_array(node->next[0]);
   node = free_node(node);
}

SkipList* delete_skip_list(SkipList *list){
    if(list == NULL) return NULL;
    delete_node_array(list->head);
    free(list);
    list=NULL;
    return list;
}

Node* free_node(Node *node){
    
    free(node->next);
    free(node);
    node = NULL;
    return node;
    
}

int insert_skip_list(SkipList* list,void* item){
    
    if (list == NULL || item ==NULL) return -1;
    Node* node = create_node(item,random_level()); //is the same of create_head_node but without the initial check of the null Item
    if(node == NULL){
        printf("\nisert_skip_list:error malloc node");
        return -1;
    }
   
    if(node->size > list->max_level){
        list->max_level = node->size;
    }
    
    Node *x = list->head;
    for (int k = list->max_level-1; k >= 0; k--)
    {
        if(x->next[k] == NULL || strcmp(item,x->next[k]->item) < 0 ){
            if(k < node->size){
                node->next[k] = x->next[k];
                x->next[k] = node;
            }
        }else{
            x = x->next[k];
            k++;
        }
    }
    return 0;
}

Answer 1

I solved by put in:

Node* free_node(Node *node){
    free(node->item); --> new line
    free(node->next);
    free(node);
    node = NULL;
    return node;
    
}

But this is strange cause the first time didn't work. Otherwise still too slow for a correct solution. Any suggest how to improve the read function's speed?