Déterminer si un pointeur reçu est une chaîne, ushort ou un tableau

Question

J'interpose la fonction memcpy() en C car l'application cible l'utilise pour concaténer des chaînes et je veux savoir quelles chaînes sont en cours de création. Le code est:

void * my_memcpy (void * destination, const void * source, size_t num) 
{ 
    void *ret = memcpy(destination, source, num); 
    // printf ("[MEMCPY] = %s \n", ret); 
    return ret; 
} 

La fonction est appelée, mais avec succès le premier paramètre peut être tout ce que je veux seulement tracer si le résultat est une chaîne ou un tableau. Je devrais demander si c'est un tableau ou une chaîne. Je sais que cela ne peut pas être simple: y a-t-il un moyen de savoir sur quoi pointe le RET? Je travaille sous MACOSX et en interposition avec DYLD.

Merci beaucoup.

Answer 1

Comme void* représente un bloc brut de mémoire, il n'y a aucun moyen de déterminer quelles données réelles se trouvent là. Toutefois, vous pouvez effectuer un vidage de la mémoire de type "chaîne" à chaque opération, mais donner à la sortie résultante une sorte de "limite de sortie supérieure".

Cela pourrait être mis en œuvre de la manière suivante:

const size_t kUpperLimit = 32; 

void output_memory_dump(void* memory) { 
    std::cout.write(reinterpret_cast<char*>(memory), kUpperLimit); 
} 

Pour les non-chaîne comme la sortie des données ne serait guère interprétable, mais sinon, vous obtiendrez ce que vous recherchez.

Vous pouvez essayer d'appliquer une approche fondée sur les conjectures comme itérer reinterpret_cast<void*>(memory) et faire is_alphanumeric && is_space contrôles à chaque symbole, mais cette approche ne semble pas très stable (qui sait ce qui pourrait se trouver en fait dans ce void* ...).

De toute façon, pour certaines situations qui pourraient être bien.

Answer 2

ret est égal au pointeur de destination. Mais il n'est pas possible de déterminer si c'est un tableau ou une chaîne, sauf si vous en savez plus sur le tableau ou la chaîne (par exemple, que la chaîne a une certaine longueur et est terminée par un caractère nul).

Answer 3

Vous pouvez d'abord appliquer des heuristiques à la mémoire copiée et, en fonction de cela, vous pouvez décider si vous souhaitez l'imprimer.

static int maybe_string(const void *data, size_t n) { 
    const unsigned char *p; 
    size_t i; 

    p = data; 
    for (i = 0; i < n; i++) { 
    int c = p[i]; 
    if (c == '\n' || c == '\r' || c == '\t') 
     continue; 
    if (1 <= c && c < 32) 
     return 0; /* unusual ASCII control character */ 
    if (c == '\0' && i > 5) 
     return 1; /* null-terminated and more than a few characters long */ 
    } 

    return 0; /* not null-terminated, so it isn't a string */ 
} 

Cette heuristique n'est pas parfaite. Par exemple, il échoue pour le motif suivant:

const char *str = "hello, world"; 
size_t len = strlen(str); 
char *buf = malloc(1024); 
memcpy(buf, str, len); 
buf[len] = '\0'; 

Si vous voulez attraper cela aussi, vous devrez changer la fonction ci-dessus.

Answer 4

Non, vous ne pouvez pas comprendre cela à partir d'un pointeur de type void. De plus, vous ne connaissez pas la taille de la source ou de la destination, donc l'approche heuristique ne fonctionnera pas. Cela ne fonctionnera pas pour d'autres raisons, par exemple, les données binaires stockées dans la zone mémoire pointée par void* peuvent vraiment avoir zéro octet à la fin, mais cela ne signifie pas que c'est une chaîne.