Automatically freeing memory on exit in a shared library - c

Question

My goal is to wrap malloc() with my own implementation and then inject that implementation into executables using LD_PRELOAD trick for educational purposes.
I've made two files, test.c for testing the injection and wrapper.c which wraps malloc() and is compiled as a shared library.
My question is this:
Is it possible for wrapper to detect that it's caller, test is done (at the end of main()) to free it's memory (dynamic_array)?
I can't add something like deinit() to wrapper because I don't necessarily have access to caller's code like I do in the case of test.
I know it might be best to do it using RAII in C++, but what can be done in C?
// test.c
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
int main(void)
{
(void)malloc(1);
return 0;
}
Built with:
gcc -o test test.c
// wrapper.c
#define _GNU_SOURCE
#include <stdlib.h>
#include <dlfcn.h>
#include <stddef.h>
#include <string.h>
#include <unistd.h>
static void* (*real_malloc)(size_t size) = NULL;
// Untested pseudocode, but you get the idea
void *dynamic_array = NULL;
unsigned dynamic_array_idx = 0;
size_t dynamic_array_size = 100;
void add_ptr(void* ptr)
{
if (!dynamic_array) {
dynamic_array = real_malloc(dynamic_array_size );
}
if (dynamic_array_idx >= dynamic_array_size) {
dynamic_array_size *= 2;
dynamic_array = realloc(dynamic_array, dynamic_array_size);
}
dynamic_array[dynamic_array_idx++] = ptr;
}
void* malloc(size_t size)
{
if (real_malloc == NULL) {
real_malloc = dlsym(RTLD_NEXT, "malloc");
}
void* ptr = real_malloc(size);
add_ptr(ptr);
return ptr;
}
Built with:
gcc -c -fPIC -o wrapper.o wrapper.c
gcc -shared -o wrapper.so wrapper.o
Ran with:
LD_PRELOAD=wrapper.so ./test

Answer 1

When real_malloc is initialized, you can use atexit to designate a function to be called when the program exits. You can use this to clean up your memory.
Also, dynamic_array should have type void ** to store an array of void *.
void cleanup(void)
{
free(dynamic_array);
}
void* malloc(size_t size)
{
if (real_malloc == NULL) {
real_malloc = dlsym(RTLD_NEXT, "malloc");
atexit(cleanup); // register cleanup handler
}
void* ptr = real_malloc(size);
add_ptr(ptr);
return ptr;
}