How can I free all instances of dynamically allocated memory in this C code

Question

I've written this C code. In the beginning, I used file handing to read a text file and insert every line as a string in a linked list. I need to free all cases of memory allocation in the program in a separate void function. How do I do that? I only included the parts of the code that are relevant because it's a pretty long program.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <stdbool.h>
#include <ctype.h>



/*Node of linked list*/
typedef struct node {
    char *data;
    struct node *next;
} node;

node *start = NULL;
node *current;

typedef enum {
    not_tested, found, missed
} state;

/*Appending nodes to linked list*/
void add(char *line) {

    node *temp = (node *)malloc(sizeof(node));
    temp->data = strdup(line);
    temp->next = NULL;
    current = start;

    if (start == NULL) {
        start = temp;
    }
    else {
        while (current->next != NULL) {
            current = current->next;
        }
        current->next = temp;
    }
}

/*read text file*/
void readfile(char *filename) {
    FILE *file = fopen(filename, "r");

    if (file == NULL) {
        exit(1);
    }

    char buffer[512];

    while (fgets(buffer, sizeof(buffer), file) != NULL) {
        add(buffer);
    }

    fclose(file);
}

Answer 1

This is not exactly what you're asking for, but I show you how to build a little class that allocates chunks of memory that can bee freed in a single call. This is especially useful when you have lots of small pieces of memory to allocate and therefore to free after usage.

It could seem too many codes for your usage, but note that such a class can be saved in a independent file and reused each time it's needed :

struct Allocator {
    void * buffer;
    size_t capacity;
    size_t usedSize;
};

struct Allocator * newAllocator(size_t initialSize) {
    struct Allocator * allocator = malloc(sizeof(*allocator));
    if (! allocator) return NULL;
    allocator->buffer = malloc(initialSize);
    if (! allocator->buffer) { free(allocator); return NULL; }
    allocator->capacity = initialSize;
    allocator->usedSize = 0;
    return allocator;
}

void freeAllocator(struct Allocator * allocator) {
    if (!allocator) return;
    if (allocator->buffer) free(allocator->buffer);
    free(allocator);
}

void * allocate(struct Allocator * allocator, size_t size) {
    if (size + allocator->usedSize > allocator->capacity) {
        while (size + allocator->usedSize > allocator->capacity) allocator->capacity *= 2;
        allocator->buffer = realloc(allocator->buffer, allocator->capacity);
    }
    void * ptr = allocator->buffer + allocator->usedSize;
    allocator->usedSize += size;
    return ptr;
}
//-------- END ALLOCATOR

struct node {
    //...
};

// How to replace a call to malloc to allocate a node :
void add(struct Allocator *allocator, char *line) {
     struct node *temp = allocate(allocator, sizeof(*temp));
    //...
}

int main()
{
    FILE *file = fopen("myfileName", "r");
    if (file == NULL) exit(1);
    
    // Allocates the buffer and as many nodes as needed 
    struct Allocator *allocator = newAllocator(1024);
    char * buffer = allocate(allocator, 512);
    while (fgets(buffer, 512, file) != NULL) {
        add(allocator, buffer);
    }
    // Free all allocated memory in a single call
    freeAllocator(allocator);
    return 0;
}