Mise en cache des paquets capturés à partir de pcap

Voici une question complémentaire à celle-ci: reconstruire un paquet à injecter via pcap

Ce que je veux accomplir:

  1. functionA: Capture des paquets avec pcap. Modifier les adresses source / destination. Recalculer les sums de contrôle. Injecter avec pcap.

  2. functionB: Crée deux threads. Le fil 1 envoie un paquet magique au client en veille. Thread 2 capture les paquets avec pcap et les met en cache dans un tableau de u_char *, car pcap place les données de paquet en série dans “u_char * packet”. Lorsque les deux threads se terminent, je modifie ensuite les en-têtes puis injecte chacun des paquets mis en cache.

Qu’est-ce que j’ai besoin d’aide avec:

  1. functionA: Je peux tout faire, mais calculer des sums de contrôle. J’ai essayé de vérifier la sum de contrôle originale en la calculant moi-même avec une fonction, mais celle-ci ne correspond jamais. Cependant, cette question n’est pas aussi importante car je n’en ai pas besoin pour faire la démonstration de mon projet final. Je comprends que si les sums de contrôle IP sont incorrectes, l’ordinateur destinataire éliminera le paquet. Mais lors de ma démonstration, tant que mon ordinateur client peut recevoir la preuve de la réception de ce paquet incorrect, j’ai prouvé mon concept général et n’échouera pas. 🙂

  2. functionB: Je suppose que c’est le problème le plus important. Je ne connais pas de moyen facile de mettre en cache mes paquets capturés. Ce sur quoi je travaille en ce moment est la suivante:

functionB crée un pointeur sur un tableau qui stocke u_char * appelé cachedPackets. Donc, cachedPackets pointe essentiellement sur un tableau qui stocke des “chaînes”.

Ça va être quelque chose comme ça? u_char ** cachedPackets[100] , suffisamment d’éléments de tableau pour 100 paquets.

Après cela, je lance deux threads. Thread1 pour réveiller mon client endormi. Thread2 pour ouvrir une autre session pcap afin qu’aucune donnée ne soit perdue pendant le réveil du client. Thread1 est facile, j’ai déjà testé ma fonction d’envoi de paquet magique indépendamment. Thread2 est l’endroit où je me trompe.

Thread2 appelle finalement int pcap_loop(pcap_t *p, int cut, pcap_handler callback, u_char *user) .

callback est la fonction qui sera exécutée après la capture de chaque paquet. C’est là que je vais mettre le paquet en cache dans le tableau.

callback prend des parameters ( u_char* user, const struct pcap_pkthdr* packet_header, const u_char* packet_data )

utilisateur est la même chaîne dans le 4ème argument de pcap_loop.

Je pensais donc que je pouvais donner à ma fonction de rappel le pointeur sur le tableau de chaînes en le transmettant.

pcap_loop(asdf, asdf, callback, (u_char *)cachedPackets);

Étant donné que je ne sais pas quelle sera la taille des paquets entrants, je vais allouer de manière dynamic suffisamment d’espace dans la fonction de rappel. Je vais également garder une trace de ma position dans le tableau avec un int statique.

Voici à quoi ressemble le rappel:

 void cacheCall(u_char * user, const struct pcap_pkthdr * header, const u_char * packet) static int cacheindex = 0; u_char ** cachethis = (u_char **)user; //u_char * cachething = *cachethis; (*cachethis)[cacheindex] = (u_char *) malloc(header->len); <--- 497 int i = 0; for(i = 0; i len; i++) { (*cachethis)[cacheindex][i] = packet[i]; len); cacheindex++; 

mais quand je comstack, je reçois

 497: warning: assignment makes integer from pointer without a cast 503: error: subscripted value is neither array nor pointer 

C’était assez long, j’espère que ma connaissance de ce que je fais n’est pas complètement mal informée. Toute aide serait géniale! 🙂

 u_char ** cachethis; 

cachethis est un pointeur à pointeur-à-u_char.

Alors:

 *cachethis 

est un pointeur sur u_char, et:

 (*cachethis)[i] 

est un simple u_char .

La ligne 497 essaie donc de stocker un pointeur dans un u_char et la ligne 503 essaie d’ u_char un u_char , les deux étant invalides.

On dirait que ce que vous voulez, c’est simplement:

 cachethis[i] 

et

 cachethis[i][j]