Speicher-Zuweisung bei C-Bibliotheksfunktionen mit Zeigern

[Rentner O. (rentner323)]

Hallihallo,

ich bin mir hier bei ner total trivialen Sache völlig unsicher:

Ich benutzt eine fremde C Bibliothek (pcap) in einem C++ Programm (Qt).

Dort gibt es folgende Funktion:

int pcap_next_ex  ( pcap_t *  p,  
  struct pcap_pkthdr **  pkt_header,  
  const u_char **  pkt_data   
 )

Jetzt übergebe ich der Funktion einen Pointer den ich vorher anlege:

u_char *pkt_data;

Jetzt die frage:
Wie funktioniert in dem Fall die Speicher Zuweisung -> kurz gesagt, muss 
ich den Buffer nach Benutzung wieder löschen?

In dem speziellen Fall beziehe ich mich auf folgendes Beispiel:

int main()
{
pcap_if_t *alldevs;
pcap_if_t *d;
int inum;
int i=0;
pcap_t *adhandle;
int res;
char errbuf[PCAP_ERRBUF_SIZE];
struct tm ltime;
char timestr[16];
struct pcap_pkthdr *header;
const u_char *pkt_data;
time_t local_tv_sec;

    
    //... 

    
    /* Retrieve the packets */
    while((res = pcap_next_ex( adhandle, &header, &pkt_data)) >= 0){
        
        if(res == 0)
            /* Timeout elapsed */
            continue;
        
        /* convert the timestamp to readable format */
        local_tv_sec = header->ts.tv_sec;
        localtime_s(&ltime, &local_tv_sec);
        strftime( timestr, sizeof timestr, "%H:%M:%S", &ltime);
        
        printf("%s,%.6d len:%d\n", timestr, header->ts.tv_usec, header->len);
    }
    
    if(res == -1){
        printf("Error reading the packets: %s\n", pcap_geterr(adhandle));
        return -1;
    }
    
    return 0;
}

Hier mal am Beispiel vom "struct ... *header":
Am Anfang lege ich ja nur einen Zeiger an, dieser wird dann durch die 
Funktion pcap_next_ex aufgefüllt.
Wenn ich nun das Ende der Funktion erreiche, dann wird doch nur der 
Zeiger automatisch gelöscht. Müsste ich nicht das Object explizit aus 
dem Speicher löschen?

[Dr. Sommer (Gast)]

Rentner Opa schrieb:
> Wenn ich nun das Ende der Funktion erreiche, dann wird doch nur der
> Zeiger automatisch gelöscht.
Richtig.
> Müsste ich nicht das Object explizit aus
> dem Speicher löschen?
Das hängt davon ab, was für ein Speicher das ist den pcap_next_ex dir da 
gibt. Die Dokumentation von pcap_next_ex sagt dir, ob du den wieder 
selber freigeben musst oder irgendein anderer Teil von libpcap das 
automatisch macht oder das ein Zeiger auf statischen Speicher ist der 
nicht freigegeben werden muss... Auf Verdacht würde ich aber mal sagen 
dass du das mit free() wieder löschen musst.

[Rufus Τ. F. (rufus)]

Rentner Opa schrieb:
> Müsste ich nicht das Object explizit aus
> dem Speicher löschen?

Nicht unbedingt; es kann sein, daß die Funktion pcap_next_ex den Pointer 
auf einen Puffer setzt, der anderswo verwaltet wird, oder statisch 
angelegt ist.

Wenn die Funktion allerdings tatsächlich via malloc/calloc Speicher 
anfordert, und den Pointer darauf zeigen lässt (und keine eigene 
zusätzliche Speicherverwaltung mit irgendwelchen anderen Funktionen 
betrieben wird, die Du hier nicht erwähnt hast), dann muss in der Tat 
der Speicher "von Hand" wieder freigegeben werden.

Daß der Pointer selbst auf dem Stack liegt und mit dem Beenden Deiner 
Funktion seine Gültigkeit verliert, löscht, wie Du richtig annimmst, den 
Speicher nicht, auf den der Pointer zeigt.

Das wäre im ersten Falle (Pointer zeigt auf statischen Speicher) auch 
ein Problem, denn wie löscht man statischen Speicher?

[Rentner O. (rentner323)]

Auszug aus der Doku zu besagter Funktion:
Read a packet from an interface or from an offline capture.

This function is used to retrieve the next available packet, bypassing 
the callback method traditionally provided by libpcap.

pcap_next_ex fills the pkt_header and pkt_data parameters (see 
pcap_handler()) with the pointers to the header and to the data of the 
next captured packet.

The return value can be:
•1 if the packet has been read without problems
•0 if the timeout set with pcap_open_live() has elapsed. In this case 
pkt_header and pkt_data don't point to a valid packet
•-1 if an error occurred
•-2 if EOF was reached reading from an offline capture


Woher weiß ich denn wie intern die Speicherverwaltung funktioniert?

Das Problem wird bei anderen Funktionen sicherlich auch wieder 
auftreten.

[thestrangler (Gast)]

---
pcap_next_ex() reads the next packet and returns a success/failure 
indication. If the packet was read without problems, the pointer pointed 
to by the pkt_header argument is set to point to the pcap_pkthdr struct 
for the packet, and the pointer pointed to by the pkt_data argument is 
set to point to the data in the packet.

The struct pcap_pkthdr and the packet data are not to be freed by the 
caller, and are not guaranteed to be valid after the next call to 
pcap_next_ex(), pcap_next(), pcap_loop(), or pcap_dispatch(); if the 
code needs them to remain valid, it must make a copy of them.
---

Du darfst den Speicher also nicht selbst freigeben.

[Rentner O. (rentner323)]

Yeah! Danke!

Wo hast du das gefunden (link)?

[thestrangler (Gast)]

Auf http://www.tcpdump.org/

http://www.tcpdump.org/manpages/pcap_next_ex.3pcap.html