Überschreiben Sie einen Funktionsaufruf in C

Ich möchte bestimmte Funktionsaufrufe an verschiedene APIs überschreiben, um die Aufrufe zu protokollieren, aber ich möchte möglicherweise auch Daten manipulieren, bevor sie an die eigentliche Funktion gesendet werden.

Angenommen, ich verwende eine Funktion namens getObjectName tausendfach in meinem Quellcode. Ich möchte diese Funktion manchmal vorübergehend überschreiben, weil ich das Verhalten dieser Funktion ändern möchte, um das andere Ergebnis zu sehen.

Ich erstelle eine neue Quelldatei wie folgt:

#include <apiheader.h>    

const char *getObjectName (object *anObject)
{
    if (anObject == NULL)
        return "(null)";
    else
        return "name should be here";
}

Ich kompiliere alle meine anderen Quellen wie gewohnt, aber ich verlinke sie zuerst mit dieser Funktion, bevor ich sie mit der API-Bibliothek verlinke. Das funktioniert gut, außer dass ich die eigentliche Funktion offensichtlich nicht innerhalb meiner überschreibenden Funktion aufrufen kann.

Gibt es eine einfachere Möglichkeit, eine Funktion zu “überschreiben”, ohne Verknüpfungs-/Kompilierungsfehler/Warnungen zu erhalten? Idealerweise möchte ich in der Lage sein, die Funktion zu überschreiben, indem ich einfach ein oder zwei zusätzliche Dateien kompiliere und verlinke, anstatt mit Verknüpfungsoptionen herumzuspielen oder den tatsächlichen Quellcode meines Programms zu ändern.

Mit gcc können Sie unter Linux die --wrap Linker-Flag wie folgt:

gcc program.c -Wl,-wrap,getObjectName -o program

und definieren Sie Ihre Funktion als:

const char *__wrap_getObjectName (object *anObject)
{
    if (anObject == NULL)
        return "(null)";
    else
        return __real_getObjectName( anObject ); // call the real function
}

Dadurch wird sichergestellt, dass alle Anrufe zu getObjectName() werden zu Ihrer Wrapper-Funktion umgeleitet (zur Verbindungszeit). Dieses sehr nützliche Flag fehlt jedoch in gcc unter Mac OS X.

Denken Sie daran, die Wrapper-Funktion mit zu deklarieren extern "C" wenn Sie jedoch mit g++ kompilieren.

Wenn Sie die Aufrufe nur für Ihre Quelle erfassen/modifizieren möchten, besteht die einfachste Lösung darin, eine Header-Datei zusammenzustellen (intercept.h) mit:

#ifdef INTERCEPT
    #define getObjectName(x) myGetObjectName(x)
#endif

Anschließend implementieren Sie die Funktion wie folgt (in intercept.c die nicht enthalten intercept.h):

const char *myGetObjectName (object *anObject) {
    if (anObject == NULL) return "(null)";
    return getObjectName(anObject);

Stellen Sie dann sicher, dass jede Quelldatei, in der Sie den Anruf abfangen möchten, oben Folgendes enthält:

#include "intercept.h"

Beim Kompilieren mit “-DINTERCEPT“, werden alle Dateien aufgerufen dein Funktion statt der echten, während Ihre Funktion immer noch die echte aufrufen wird.

Kompilieren ohne “-DINTERCEPT” wird ein Abfangen verhindern.

Etwas kniffliger wird es, wenn Sie alle Aufrufe abfangen wollen (nicht nur die von Ihrer Quelle) – das geht generell mit dynamischem Laden und Auflösung der eigentlichen Funktion (mit dlload- und dlsym-geben Sie Anrufe ein), aber ich denke nicht, dass dies in Ihrem Fall erforderlich ist.

Sie können eine Funktion mit überschreiben LD_PRELOAD Trick – siehe man ld.so. Sie kompilieren die Shared Lib mit Ihrer Funktion und starten die Binärdatei (Sie müssen die Binärdatei nicht einmal ändern!) like LD_PRELOAD=mylib.so myprog.

Im Hauptteil Ihrer Funktion (in Shared Lib) schreiben Sie wie folgt:

const char *getObjectName (object *anObject) {
  static char * (*func)();

  if(!func)
    func = (char *(*)()) dlsym(RTLD_NEXT, "getObjectName");
  printf("Overridden!\n");     
  return(func(anObject));    // call original function
}

Sie können jede Funktion aus der gemeinsam genutzten Bibliothek, sogar aus der stdlib, überschreiben, ohne das Programm zu ändern/neu zu kompilieren, sodass Sie den Trick bei Programmen ausführen können, für die Sie keine Quelle haben. Ist es nicht schön?

Wenn Sie GCC verwenden, können Sie Ihre Funktion ausführen weak. Diese kann überschrieben werden durch nichtschwache Funktionen:

test.c:

#include <stdio.h>

__attribute__((weak)) void test(void) { 
    printf("not overridden!\n"); 
}

int main() {
    test();
}

Was tut es?

$ gcc test.c
$ ./a.out
not overridden!

test1.c:

#include <stdio.h>

void test(void) {
    printf("overridden!\n");
}

Was tut es?

$ gcc test1.c test.c
$ ./a.out
overridden!

Bei anderen Compilern funktioniert das leider nicht. Aber Sie können die schwachen Deklarationen, die überschreibbare Funktionen enthalten, in ihrer eigenen Datei haben, indem Sie nur ein Include in die API-Implementierungsdateien einfügen, wenn Sie mit GCC kompilieren:

schwachdekls.h:

__attribute__((weak)) void test(void);
... other weak function declarations ...

Funktionen.c:

/* for GCC, these will become weak definitions */
#ifdef __GNUC__
#include "weakdecls.h"
#endif

void test(void) { 
    ...
}

... other functions ...

Nachteil davon ist, dass es nicht funktioniert völlig ohne etwas mit den API-Dateien zu tun (wobei diese drei Zeilen und die Weakdecls benötigt werden). Aber sobald Sie diese Änderung vorgenommen haben, können Funktionen einfach überschrieben werden, indem Sie eine globale Definition in eine Datei schreiben und diese einbinden.

Es ist oft wünschenswert, das Verhalten bestehender Codebasen durch Umschließen oder Ersetzen von Funktionen zu ändern. Wenn das Bearbeiten des Quellcodes dieser Funktionen eine praktikable Option ist, kann dies ein unkomplizierter Prozess sein. Wenn die Quelle der Funktionen nicht bearbeitet werden kann (z. B. wenn die Funktionen von der System-C-Bibliothek bereitgestellt werden), dann sind alternative Techniken erforderlich. Hier stellen wir solche Techniken für UNIX-, Windows- und Macintosh OS X-Plattformen vor.

Dies ist ein großartiges PDF, das zeigt, wie dies unter OS X, Linux und Windows gemacht wurde.

Es hat keine erstaunlichen Tricks, die hier nicht dokumentiert wurden (das ist übrigens eine erstaunliche Reihe von Antworten) … aber es ist eine nette Lektüre.

Abfangen beliebiger Funktionen auf Windows-, UNIX- und Macintosh OS X-Plattformen (2004), von Daniel S. Myers und Adam L. Bazinet.

Du kannst Laden Sie das PDF direkt von einem alternativen Speicherort herunter (für Redundanz).

Und schließlich, sollten die beiden vorherigen Quellen irgendwie in Flammen aufgehen, Hier ist ein Google-Suchergebnis dafür.

Sie können einen Funktionszeiger als globale Variable definieren. Die Aufrufer-Syntax würde sich nicht ändern. Wenn Ihr Programm startet, könnte es überprüfen, ob ein Befehlszeilen-Flag oder eine Umgebungsvariable gesetzt ist, um die Protokollierung zu aktivieren, dann den ursprünglichen Wert des Funktionszeigers speichern und ihn durch Ihre Protokollierungsfunktion ersetzen. Sie würden keinen speziellen Build mit aktivierter Protokollierung benötigen. Benutzer könnten die Protokollierung „im Feld“ aktivieren.

Sie müssen in der Lage sein, den Quellcode des Aufrufers zu ändern, aber nicht den Aufgerufenen (dies würde also beim Aufrufen von Bibliotheken von Drittanbietern funktionieren).

foo.h:

typedef const char* (*GetObjectNameFuncPtr)(object *anObject);
extern GetObjectNameFuncPtr GetObjectName;

foo.cpp:

const char* GetObjectName_real(object *anObject)
{
    return "object name";
}

const char* GetObjectName_logging(object *anObject)
{
    if (anObject == null)
        return "(null)";
    else
        return GetObjectName_real(anObject);
}

GetObjectNameFuncPtr GetObjectName = GetObjectName_real;

void main()
{
    GetObjectName(NULL); // calls GetObjectName_real();

    if (isLoggingEnabled)
        GetObjectName = GetObjectName_logging;

    GetObjectName(NULL); // calls GetObjectName_logging();
}

Aufbauend auf der Antwort von @Johannes Schaub mit einer Lösung, die für Code geeignet ist, den Sie nicht besitzen.

Versehen Sie die Funktion, die Sie überschreiben möchten, mit einem Alias ​​für eine schwach definierte Funktion und implementieren Sie sie dann selbst neu.

überschreiben.h

#define foo(x) __attribute__((weak))foo(x)

foo.c

function foo() { return 1234; }

überschreiben.c

function foo() { return 5678; }

Verwenden musterspezifische Variablenwerte in Ihrem Makefile, um das Compiler-Flag hinzuzufügen -include override.h.

%foo.o: ALL_CFLAGS += -include override.h

Nebenbei: Vielleicht könntest du das auch gebrauchen -D 'foo(x) __attribute__((weak))foo(x)' um Ihre Makros zu definieren.

Kompilieren und verknüpfen Sie die Datei mit Ihrer Neuimplementierung (override.c).

• Auf diese Weise können Sie eine einzelne Funktion aus einer beliebigen Quelldatei überschreiben, ohne den Code ändern zu müssen.

• Der Nachteil ist, dass Sie für jede Datei, die Sie überschreiben möchten, eine separate Header-Datei verwenden müssen.