Prüfen, ob einem Zeiger Speicher zugeordnet ist oder nicht

Können wir in C überprüfen, ob ein an eine Funktion übergebener Zeiger mit Speicher belegt ist oder nicht?

Ich habe meine eigene Funktion in C geschrieben, die einen Zeichenzeiger akzeptiert – buf [pointer to a buffer] und Größe – buf_siz [buffer size]. Tatsächlich muss der Benutzer vor dem Aufruf dieser Funktion einen Puffer erstellen und ihm den Speicher von buf_siz zuweisen.

Da die Möglichkeit besteht, dass der Benutzer die Speicherzuweisung vergisst und einfach den Zeiger an meine Funktion weitergibt, möchte ich dies überprüfen. Gibt es also eine Möglichkeit, in meiner Funktion zu überprüfen, ob der übergebene Zeiger wirklich mit der buf_siz-Menge an Speicher belegt ist?

EDIT1: Es scheint, dass es keine Standardbibliothek gibt, um es zu überprüfen. Aber gibt es einen schmutzigen Hack, um es zu überprüfen?

EDIT2: Ich weiß, dass meine Funktion von einem guten C-Programmierer verwendet wird … Aber ich möchte wissen, ob wir das überprüfen können oder nicht … wenn wir können, würde ich gerne davon hören …

Fazit: Es ist also unmöglich zu überprüfen, ob ein bestimmter Zeiger innerhalb einer Funktion mit Speicher belegt ist oder nicht

Sie können dies nicht überprüfen, außer einigen implementierungsspezifischen Hacks.

Pointer haben keine anderen Informationen als wohin sie zeigen. Das Beste, was Sie tun können, ist zu sagen: “Ich weiß, wie diese bestimmte Compiler-Version Speicher zuweist, also dereferenziere ich Speicher, bewege den Zeiger um 4 Bytes zurück, überprüfe die Größe, stelle sicher, dass sie übereinstimmt …” und so weiter. Sie können dies nicht auf standardmäßige Weise tun, da die Speicherzuweisung implementierungsdefiniert ist. Ganz zu schweigen davon, dass sie es möglicherweise überhaupt nicht dynamisch zugewiesen haben.

Sie müssen nur davon ausgehen, dass Ihr Client weiß, wie man in C programmiert. Die einzige Unlösung, die mir einfällt, wäre, den Speicher selbst zuzuweisen und zurückzugeben, aber das ist kaum eine kleine Änderung. (Es ist eine größere Designänderung.)

Der folgende Code ist das, was ich einmal verwendet habe, um zu überprüfen, ob ein Zeiger versucht, auf illegalen Speicher zuzugreifen. Der Mechanismus besteht darin, ein SIGSEGV zu induzieren. Das SEGV-Signal wurde früher auf eine private Funktion umgeleitet, die longjmp verwendet, um zum Programm zurückzukehren. Es ist eine Art Hack, aber es funktioniert.

Der Code kann verbessert werden (verwenden Sie ‘sigaction’ anstelle von ‘signal’ usw.), aber es soll nur eine Idee geben. Es ist auch auf andere Unix-Versionen portierbar, bei Windows bin ich mir nicht sicher. Beachten Sie, dass das SIGSEGV-Signal an keiner anderen Stelle in Ihrem Programm verwendet werden sollte.

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

jmp_buf jump;

void segv (int sig)
{
  longjmp (jump, 1); 
}

int memcheck (void *x) 
{
  volatile char c;
  int illegal = 0;

  signal (SIGSEGV, segv);

  if (!setjmp (jump))
    c = *(char *) (x);
  else
    illegal = 1;

  signal (SIGSEGV, SIG_DFL);

  return (illegal);
}

int main (int argc, char *argv[])
{
  int *i, *j; 

  i = malloc (1);

  if (memcheck (i))
    printf ("i points to illegal memory\n");
  if (memcheck (j))
    printf ("j points to illegal memory\n");

  free (i);

  return (0);
}

Für eine plattformspezifische Lösung könnte Sie die Win32-Funktion interessieren IsBadReadPtr (und andere mögen es). Diese Funktion kann (fast) vorhersagen, ob beim Lesen aus einem bestimmten Speicherabschnitt ein Segmentierungsfehler auftritt.

Dies gilt jedoch nicht schützen Sie im allgemeinen Fall, da das Betriebssystem nichts vom C-Laufzeit-Heap-Manager weiß und wenn ein Aufrufer einen Puffer übergibt, der nicht so groß ist, wie Sie erwarten, bleibt der Rest des Heap-Blocks weiterhin lesbar aus OS-Sicht.

Ich initialisiere Zeiger immer auf den Nullwert. Wenn ich also Speicher zuweise, ändert sich dies. Wenn ich überprüfe, ob Speicher zugewiesen wurde, tue ich das pointer != NULL. Wenn ich Speicher freigebe, setze ich auch den Zeiger auf null. Ich kann mir nicht vorstellen, ob genügend Speicher zugewiesen wurde.

Dies löst Ihr Problem nicht, aber Sie müssen darauf vertrauen, dass jemand, der C-Programme schreibt, über ausreichende Fähigkeiten verfügt, um es richtig zu machen.

Ich habe einmal einen schmutzigen Hack auf meinem 64-Bit-Solaris verwendet. Im 64-Bit-Modus beginnt der Heap bei 0x1 0000 0000. Durch den Vergleich des Zeigers konnte ich feststellen, ob es sich um einen Zeiger im Daten- oder Codesegment handelte p < (void*)0x100000000ein Zeiger im Heap p > (void*)0x100000000 oder ein Zeiger in einem speicherabgebildeten Bereich (intptr_t)p < 0 (mmap gibt Adressen vom oberen Rand des adressierbaren Bereichs zurück). Dies ermöglichte es meinem Programm, zugewiesene und speicherabgebildete Zeiger in derselben Karte zu halten und mein Kartenmodul die richtigen Zeiger freizugeben.

Aber diese Art von Trick ist höchst unportabel, und wenn Ihr Code auf so etwas angewiesen ist, ist es an der Zeit, die Architektur Ihres Codes zu überdenken. Du machst wahrscheinlich etwas falsch.

Ich weiß, dass dies eine alte Frage ist, aber in C ist fast alles möglich. Es gibt hier bereits ein paar hackige Lösungen, aber eine gültige Methode, um festzustellen, ob der Speicher richtig zugewiesen wurde, besteht darin, ein Orakel anstelle von zu verwenden malloc, calloc, reallocund free. Auf die gleiche Weise können Test-Frameworks (wie cmocka) Speicherprobleme erkennen (z. B. Fehler, nicht freigegebener Speicher usw.). Sie können eine Liste der zugewiesenen Speicheradressen führen, während sie zugewiesen werden, und diese Liste einfach überprüfen, wenn der Benutzer Ihre Funktion verwenden möchte. Ich habe etwas sehr Ähnliches für mein eigenes Testframework implementiert. Einige Beispielcode:

typedef struct memory_ref {
    void       *ptr;
    int        bytes;
    memory_ref *next;
}

memory_ref *HEAD = NULL;

void *__wrap_malloc(size_t bytes) {
    if(HEAD == NULL) {
        HEAD = __real_malloc(sizeof(memory_ref));
    }

    void *tmpPtr = __real_malloc(bytes);

    memory_ref *previousRef = HEAD;
    memory_ref *currentRef = HEAD->next;
    while(current != NULL) {
        previousRef = currentRef;
        currentRef = currentRef->next;
    }

    memory_ref *newRef = (memory_ref *)__real_malloc(sizeof(memory_ref));
    *newRef = (memory_ref){
        .ptr   = tmpPtr,
        .bytes = bytes,
        .next  = NULL
    };

    previousRef->next = newRef;

    return tmpPtr;
}

Sie hätten ähnliche Funktionen für calloc, reallocund freejeder Wrapper mit dem Präfix __wrap_. Die wirkliche malloc ist verfügbar durch die Verwendung von __real_malloc (ähnlich für die anderen Funktionen, die Sie umschließen). Wenn Sie überprüfen möchten, ob der Speicher tatsächlich zugewiesen ist, iterieren Sie einfach über die Verknüpfung memory_ref Liste und suchen Sie nach der Speicheradresse. Wenn Sie es finden und es groß genug ist, wissen Sie sicher, dass die Speicheradresse Ihr Programm nicht zum Absturz bringen wird; Andernfalls wird ein Fehler zurückgegeben. In der Header-Datei, die Ihr Programm verwendet, würden Sie diese Zeilen hinzufügen:

extern void *__real_malloc  (size_t);
extern void *__wrap_malloc  (size_t);
extern void *__real_realloc (size_t);
extern void *__wrap_realloc (size_t);
// Declare all the other functions that will be wrapped...

Meine Bedürfnisse waren ziemlich einfach, also habe ich eine sehr einfache Implementierung implementiert, aber Sie können sich vorstellen, wie dies erweitert werden könnte, um ein besseres Tracking-System zu haben (z struct der neben der Größe auch den Speicherplatz verfolgt). Dann kompilieren Sie den Code einfach mit

gcc src_files -o dest_file -Wl,-wrap,malloc -Wl,-wrap,calloc -Wl,-wrap,realloc -Wl,-wrap,free

Der Nachteil ist, dass der Benutzer seinen Quellcode mit den obigen Anweisungen kompilieren muss; Es ist jedoch alles andere als das Schlimmste, das ich je gesehen habe. Das Zuweisen und Freigeben von Speicher verursacht einen gewissen Overhead, aber beim Hinzufügen von Sicherheit entsteht immer ein gewisser Overhead.

Nein, im Allgemeinen gibt es keine Möglichkeit, dies zu tun.

Wenn Ihre Schnittstelle nur “einen Zeiger auf einen Puffer übergibt, wo ich Sachen ablegen werde”, dann kann der Aufrufer wählen nicht überhaupt Speicher zuzuweisen und stattdessen einen Puffer mit fester Größe zu verwenden, der statisch zugewiesen wird, oder eine automatische Variable oder so etwas. Oder vielleicht ist es ein Zeiger auf einen Teil eines größeren Objekts auf dem Haufen.

Wenn Ihre Schnittstelle ausdrücklich sagt “Übergeben Sie einen Zeiger an zugewiesenen Speicher (weil ich ihn freigeben werde)”, dann sollten Sie damit rechnen, dass der Aufrufer dies tun wird. Ein Versäumnis ist nicht etwas, das Sie zuverlässig erkennen können.