C Memory Leak — 30 Bytes/Req Crashed at 12h

#include <stdio.h>
#include <stdlib.h>

// Demonstrates WHY stack allocation fails for runtime-sized data

// This function CANNOT work — you can't use a runtime value as a stack array size
// in C89/C90 (VLAs in C99 help but have their own problems — stack overflow risk)
void demonstrate_stack_limit(int user_count) {
    // VLA — risky for large counts, stack overflow if user_count is huge
    // int user_ids[user_count]; // C99 only, and dangerous for large values

    // The heap-based approach scales safely to millions:
    int *user_ids = malloc(user_count * sizeof(int));
    if (user_ids == NULL) {
        // Always check: malloc returns NULL if the OS can't satisfy the request
        fprintf(stderr, "Failed to allocate memory for %d users\n", user_count);
        return;
    }

    // Populate with demo data
    for (int i = 0; i < user_count; i++) {
        user_ids[i] = 1000 + i;  // Simulating real user IDs starting at 1000
    }

    printf("Allocated %d user IDs on the heap:\n", user_count);
    for (int i = 0; i < user_count; i++) {
        printf("  user_ids[%d] = %d\n", i, user_ids[i]);
    }

    free(user_ids);  // Return the memory — critical. Without this, it's a leak.
    user_ids = NULL; // Null the pointer so it can't be accidentally used after free
}

int main(void) {
    int count = 5;  // In a real app, this comes from user input or a config file
    demonstrate_stack_limit(count);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>  // for memset

// Struct representing a simple task in a to-do list
typedef struct {
    int  task_id;
    int  is_complete;   // 0 = pending, 1 = done
    int  priority;      // 1-5
} Task;

void demonstrate_malloc(void) {
    printf("--- malloc demo ---\n");

    // malloc: fast, but contents are UNDEFINED (garbage)
    Task *task = malloc(sizeof(Task));
    if (task == NULL) {
        fprintf(stderr, "malloc failed\n");
        return;
    }

    // We MUST initialise every field ourselves — there's no zero guarantee
    task->task_id    = 42;
    task->is_complete = 0;  // Explicitly set to pending
    task->priority   = 3;

    printf("Task %d: complete=%d, priority=%d\n",
           task->task_id, task->is_complete, task->priority);

    free(task);
    task = NULL;
}

void demonstrate_calloc(void) {
    printf("--- calloc demo ---\n");

    int task_count = 4;

    // calloc: allocates an array of 4 Task structs, ALL bytes zeroed
    // is_complete will be 0 (pending) for every task — no explicit init needed
    Task *task_list = calloc(task_count, sizeof(Task));
    if (task_list == NULL) {
        fprintf(stderr, "calloc failed\n");
        return;
    }

    // Only set the fields that differ from zero
    for (int i = 0; i < task_count; i++) {
        task_list[i].task_id  = 100 + i;
        task_list[i].priority = i + 1;   // priorities 1 through 4
        // is_complete is already 0 thanks to calloc — nothing to do
    }

    for (int i = 0; i < task_count; i++) {
        printf("Task %d: complete=%d, priority=%d\n",
               task_list[i].task_id,
               task_list[i].is_complete,
               task_list[i].priority);
    }

    free(task_list);
    task_list = NULL;
}

int main(void) {
    demonstrate_malloc();
    demonstrate_calloc();
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// A simple dynamic array of strings (like a growing log buffer)
typedef struct {
    char  **entries;       // Pointer to array of string pointers
    int     count;         // Current number of entries
    int     capacity;      // Total slots currently allocated
} LogBuffer;

// Initialise the log buffer with a small starting capacity
LogBuffer *log_buffer_create(void) {
    LogBuffer *log = malloc(sizeof(LogBuffer));
    if (log == NULL) return NULL;

    log->capacity = 4;   // Start small — we'll grow as needed
    log->count    = 0;
    log->entries  = malloc(log->capacity * sizeof(char *));
    if (log->entries == NULL) {
        free(log);
        return NULL;
    }
    return log;
}

// Append a message — grows the buffer if full
int log_buffer_append(LogBuffer *log, const char *message) {
    // Check if we need to grow
    if (log->count == log->capacity) {
        int new_capacity = log->capacity * 2;  // Double the capacity

        // CRITICAL: use a temp pointer — if realloc fails, we still have the original
        char **resized = realloc(log->entries, new_capacity * sizeof(char *));
        if (resized == NULL) {
            fprintf(stderr, "realloc failed — log buffer could not grow\n");
            return -1;  // Original log->entries is still valid here
        }

        log->entries  = resized;       // Now safe to update the pointer
        log->capacity = new_capacity;
        printf("[Buffer grew to capacity: %d]\n", new_capacity);
    }

    // Duplicate the string onto the heap so the caller's memory doesn't matter
    log->entries[log->count] = malloc(strlen(message) + 1);  // +1 for null terminator
    if (log->entries[log->count] == NULL) return -1;

    strcpy(log->entries[log->count], message);
    log->count++;
    return 0;
}

// Free everything — the strings, the array, then the struct itself
void log_buffer_destroy(LogBuffer *log) {
    for (int i = 0; i < log->count; i++) {
        free(log->entries[i]);   // Free each individual string first
        log->entries[i] = NULL;
    }
    free(log->entries);   // Free the array of pointers
    log->entries = NULL;
    free(log);            // Free the struct itself
    // Caller should set their LogBuffer* to NULL after this
}

int main(void) {
    LogBuffer *app_log = log_buffer_create();
    if (app_log == NULL) {
        fprintf(stderr, "Failed to create log buffer\n");
        return 1;
    }

    // Appending 6 entries will trigger one realloc (capacity 4 -> 8)
    log_buffer_append(app_log, "Server started on port 8080");
    log_buffer_append(app_log, "Database connection established");
    log_buffer_append(app_log, "Config file loaded");
    log_buffer_append(app_log, "Worker threads initialised");  // Triggers realloc here
    log_buffer_append(app_log, "First request received");
    log_buffer_append(app_log, "Health check passed");

    printf("\nLog entries (%d total):\n", app_log->count);
    for (int i = 0; i < app_log->count; i++) {
        printf("  [%d] %s\n", i + 1, app_log->entries[i]);
    }

    log_buffer_destroy(app_log);
    app_log = NULL;  // Prevent any accidental use after destroy
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// Simulates loading configuration values — a common real-world pattern

// BAD VERSION — leaks the allocated string
char *load_config_value_leaky(const char *key) {
    // Pretend we read this from a file; we allocate a new string
    char *value = malloc(64);
    if (value == NULL) return NULL;
    snprintf(value, 64, "value_for_%s", key);  // Populate with demo data
    return value;  // Caller receives ownership — must free this
}

// GOOD VERSION — same function, but caller is reminded of ownership via comment
// Returns heap-allocated string. CALLER MUST FREE the returned pointer.
char *load_config_value(const char *key) {
    char *value = malloc(64);
    if (value == NULL) return NULL;
    snprintf(value, 64, "value_for_%s", key);
    return value;
}

void process_config_leaky(void) {
    // This leaks: we get a heap pointer but never free it
    char *db_host = load_config_value_leaky("db_host");
    printf("Leaky path — db_host: %s\n", db_host);
    // Forgot to call free(db_host) — 64 bytes leaked every call
}

void process_config_correct(void) {
    char *db_host = load_config_value("db_host");
    if (db_host == NULL) {
        fprintf(stderr, "Failed to load db_host config\n");
        return;
    }
    printf("Correct path — db_host: %s\n", db_host);

    free(db_host);   // We own it — we free it
    db_host = NULL;  // Nullify immediately
}

int main(void) {
    process_config_leaky();   // Run with Valgrind to see this reported
    process_config_correct(); // Valgrind will show zero leaks from this path

    // Valgrind command: valgrind --leak-check=full ./leak_detection
    // Leaky path output:
    //   LEAK SUMMARY: definitely lost: 64 bytes in 1 blocks
    //   at 0x...: malloc (in /usr/lib/valgrind/...)
    //   by 0x...: load_config_value_leaky (leak_detection.c:12)
    //   by 0x...: process_config_leaky (leak_detection.c:26)

    return 0;
}

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    // Mistake 1: Not checking malloc's return
    int *data = malloc(100 * sizeof(int));
    // Should check: if (data == NULL) { ... }
    data[0] = 42; // If malloc failed, this dereferences NULL -> crash

    // Mistake 2: Double-free
    free(data);
    free(data); // Crash: double free or corruption

    // Mistake 3: Use-after-free
    // data was freed, but pointer still points to freed memory
    // printf("%d\n", data[0]); // Undefined behaviour

    // CORRECT PATTERN:
    int *safe_data = malloc(100 * sizeof(int));
    if (safe_data == NULL) {
        fprintf(stderr, "malloc failed\n");
        return 1;
    }
    safe_data[0] = 42;
    free(safe_data);
    safe_data = NULL; // Prevent double-free and use-after-free

    // Later accidental free(safe_data) is safe because free(NULL) is no-op
    free(safe_data); // Harmless

    return 0;
}