Override a function call in C

Overriding Function Calls in C for Debugging and Customization

Explore various techniques to intercept and replace standard C library function calls or custom functions, enhancing debugging capabilities, enabling mock testing, and customizing behavior without modifying source code.

Overriding function calls in C can be a powerful technique for various purposes, including debugging, profiling, testing, and even patching legacy code. This article delves into several methods to achieve function overriding, focusing on techniques that leverage the linker, dynamic loading, and preprocessor directives. We'll examine how these methods work, their advantages, and their limitations, providing practical examples along the way.

Method 1: Linker-based Overriding (LD_PRELOAD)

One of the most common and flexible ways to override functions at runtime on Unix-like systems is by using the LD_PRELOAD environment variable. This mechanism allows you to specify a shared library that the dynamic linker should load before any other libraries, including standard C libraries. If your preloaded library defines a function with the same name as a function in another library, your version will be used.

LD_PRELOAD Mechanism Flow

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <dlfcn.h>

static void *(*original_malloc)(size_t) = NULL;

void *malloc(size_t size) {
    if (!original_malloc) {
        original_malloc = dlsym(RTLD_NEXT, "malloc");
        if (!original_malloc) {
            fprintf(stderr, "Error in dlsym for malloc: %s\n", dlerror());
            exit(EXIT_FAILURE);
        }
    }
    printf("Intercepted malloc call for %zu bytes.\n", size);
    return original_malloc(size);
}

Example of overriding malloc using LD_PRELOAD.

gcc -shared -fPIC -o my_malloc_override.so my_malloc_override.c -ldl
LD_PRELOAD=./my_malloc_override.so ls

Compiling the override library and running a command with LD_PRELOAD.

Method 2: Weak Symbols and Linker Tricks

Another linker-based approach involves using weak symbols. In C, a weak symbol is a function or variable declaration that can be overridden by a strong symbol of the same name during linking. If multiple definitions of a weak symbol exist, the linker typically chooses the first one it encounters or prioritizes strong over weak. This is particularly useful for providing default implementations that can be easily replaced by user-defined ones without modifying the original source.

#include <stdio.h>

// Declare a weak symbol for a function
void __attribute__((weak)) my_custom_function() {
    printf("Default implementation of my_custom_function.\n");
}

void call_custom_function() {
    my_custom_function();
}

Original module with a weak function.

#include <stdio.h>

// Provide a strong symbol to override the weak one
void my_custom_function() {
    printf("Overridden implementation of my_custom_function!\n");
}

Module providing a strong override.

void call_custom_function(); // Declare the function from original_module

int main() {
    call_custom_function();
    return 0;
}

Main program calling the function.

gcc -c original_module.c override_module.c main.c
gcc original_module.o override_module.o main.o -o myapp
./myapp

Compiling with override: the strong symbol takes precedence.

Method 3: Preprocessor Directives (#define)

The simplest form of 'overriding' happens at compile-time using preprocessor directives, specifically #define. This method is not true runtime overriding but rather a textual replacement that occurs before compilation. It's effective for simple cases where you want to replace a function call with another expression or function call across your own source code.

#include <stdio.h>

// Original function
void original_log(const char *message) {
    printf("Original log: %s\n", message);
}

// Define a macro to 'override' original_log
#define original_log(msg) my_custom_log(msg)

// Custom logging function
void my_custom_log(const char *message) {
    printf("Custom log: %s (via #define)\n", message);
}

int main() {
    original_log("This is a test message.");
    return 0;
}

Using #define to replace a function call.