[Windows/C] Heap debuggen

[xychix]

Ik heb hieronder een funtie om een complete textfile in te lezen.. echter na een x aantal reallocs (stuk of 10) krijg ik een Heap error.
Als ik met kleinere delen bij realloc (en dus vaker) dan draaid hij langer. de fout treed op bij het overschrijden van grofweg 2k (en ja er zou heap zat moeten zijn)
Hoe kan ik de heap debuggen ? Waarschijnlijk zit er al eerder in mijn programma een heap overflow... Zijn er programma's die dat voor mij kunnen vinden ???

C:

int readfile(char ** out, char * in)
{
    FILE * fp;
    char* pTemp;
    char* pTempTotaal;
    
    fp = fopen(in,"r");

    pTemp = (char *)malloc(MAXDATALEN);
    pTempTotaal = (char *)malloc(MAXDATALEN);

    memset(pTempTotaal,0x00,MAXDATALEN);

    while(fgets(pTemp, MAXDATALEN, fp))
    {
        /*Totaal naar Tussen*/
        /*Nieuwe ruimte voor Totaal*/
        printf("len:%u,res:%u",strlen(pTempTotaal),strlen(pTempTotaal)+strlen(pTemp)+MAXDATALEN);
        realloc(pTempTotaal,strlen(pTempTotaal)+strlen(pTemp)+MAXDATALEN);
        strncat(pTempTotaal, pTemp, MAXDATALEN);
    }

    return(0);
}

[ Voor 11% gewijzigd door xychix op 11-12-2003 09:05 ]

[whoami]

De heap debuggen? hmm.... Ik zou m'n programma debuggen.

Beschouw de heap als een stuk geheugen waarop je geheugen voor je objecten/variabelen kunt alloceren.
Je zult geheugen alloceren, en dat nergens vrijgeven. Op een keer is al het geheugen op.

[xychix]

whoami schreef op 11 december 2003 @ 09:12:
De heap debuggen? hmm.... Ik zou m'n programma debuggen.

Beschouw de heap als een stuk geheugen waarop je geheugen voor je objecten/variabelen kunt alloceren.
Je zult geheugen alloceren, en dat nergens vrijgeven. Op een keer is al het geheugen op.

Ik vermoed dat ik ergens een heap overflow zit.. wanneer de realloc een chunk van meer dan 2000 bytes wil gaat ie zijn fixed size chunk vrijgeven en uit een andere bin een nieuwe halen... je heb dan een FREE() ik denk dat het daarin misgaat.. dat wil zeggen dat een eerder gealloceerde var (dus ook head) te veel data heeft.. (overflow)

maar dit is met de hand bijna niet na te lopen... dus ik zoek eigenlijk een programma dat de lengtes van alle gealloceerde gebieden bijhoud en mij meld zodra ik de heap chunk grenzen overschrijd (overflow).


bovenstaande bin chunk heap geneuzel is gebaseerd op een beetje kennis van linux heap.. ik weet niet of windows het erg anders doet.....
maar ik zou niet weten hoe..

[ Voor 8% gewijzigd door xychix op 11-12-2003 09:18 ]

[Macros]

Zolang je geheugen en je swap bijelkaar nog niet op zijn kan je geen out of memory krijgen. Heap overflows bestaan niet, het is geen stack ofzo.
Als ik jou was zou ik gewoon eerst inlezen hoe groot het bestand is, dan genoeg ruimte alloceren in 1 keer, en dan alles erin kopieren.

[xychix]

Macros schreef op 11 december 2003 @ 09:21:
Zolang je geheugen en je swap bijelkaar nog niet op zijn kan je geen out of memory krijgen. Heap overflows bestaan niet, het is geen stack ofzo.
Als ik jou was zou ik gewoon eerst inlezen hoe groot het bestand is, dan genoeg ruimte alloceren in 1 keer, en dan alles erin kopieren.

Heap overflow bestaat onder linux ZEKER wel..

je alloceerd een chunk van 100 bytes.. dan staan aan begin en eind een soort "tags" die info bevatten over de vorige en volgende chunk.

als je een stuk heap dan TE vol schrijft sloop je zo'n "tag" wanneer je dan een Free doet wordt (in geval van de linux implementatie) er het een en ander gesloopt.. een volgende free (of was het nou de free van de volgende chunk) klapt dan keihard.

Ik krijg ook GEEN out of memory !!! realloc KLAPT en het is niet zo dat hij NULL retourneert!

[ Voor 8% gewijzigd door xychix op 11-12-2003 09:26 ]

[Verwijderd]

Je kan natuurlijk je eigen wrappers rond realloc, malloc, free etc schrijven die iets meer geheugen reserveren dan je nodig hebt. Je zet dan in dat extra geheugen een bepaalde waarde of string. Zodra je buiten je buffer schrijft wordt die string veranderd. Bij een free() check je op die strings en kan je je programma stoppen of debuggen zodra de buffer overschreven bleek.

[SWfreak]

Wat ik ook een beetje raar vind is dat je realloc aanroept, maar de return value niet opvangt. Het geretourneerde adres kan namelijk best anders zijn dan het meegegeven adres. Dan zou ie bij de strncat de mist in moeten gaan. Ook kan realloc misschien wel NULL teruggeven als het mislukt...

[Macros]

Inderdaad. Je kan je heap verneuken als je buiten je gealloceerde ruimte gaat schrijven.
Malloc returned de pointer naar het gealloceerde geheugen.
Free maakt het gemallocte geheugen vrij en
Realloc probeert het gegeven geheugen gebied te vergroten. Lukt dat niet omdat er te weinig ruimte is, dan probeerd hij een nieuw groter aaneengesloten gebied te vinden. Hij kopieerd de data naar het nieuwe gebied en Freed het nu ongebruikte gebied. Dan veranderd de pointer naar je gealloceerde gebied. Als je dat niet gebruikt dan probeer je buiten het gealloceerde gebied te accessen, dat werkt niet, daarom krijg jij een segfault.

En Realloc klapt niet, jouw programma klapt.

[ Voor 4% gewijzigd door Macros op 11-12-2003 12:18 ]

[curry684]

xychix schreef op 11 december 2003 @ 09:25:
[...]

Heap overflow bestaat onder linux ZEKER wel..

je alloceerd een chunk van 100 bytes.. dan staan aan begin en eind een soort "tags" die info bevatten over de vorige en volgende chunk.

Dat heet een buffer overflow, die 'tags' heten magic numbers, en dit bestaat op ieder platform, maar wordt zelden in release builds toegepast vanwege de performance, en sowieso gooit de MMU van de CPU vanzelf Access Violations bij grove overtredingen

Waar free() je die buffer overigens, ik zie je alleen alloceren?

[curry684]

SWfreak schreef op 11 december 2003 @ 11:23:
Wat ik ook een beetje raar vind is dat je realloc aanroept, maar de return value niet opvangt. Het geretourneerde adres kan namelijk best anders zijn dan het meegegeven adres. Dan zou ie bij de strncat de mist in moeten gaan. Ook kan realloc misschien wel NULL teruggeven als het mislukt...

Lol, had ik nog niet eens gezien, da's de hele bug ja. Realloc naar een groter gebied zal zeker bij grote verschillen zelden tot nooit het zelfde blok geheugen retourneren. Correcte aanroep is:

C:

pTempTotaal = (char*)realloc(pTempTotaal,strlen(pTempTotaal)+strlen(pTemp)+MAXDATALEN); 

[xychix]

curry684 schreef op 11 december 2003 @ 12:22:
[...]

Dat heet een buffer overflow, die 'tags' heten magic numbers, en dit bestaat op ieder platform, maar wordt zelden in release builds toegepast vanwege de performance, en sowieso gooit de MMU van de CPU vanzelf Access Violations bij grove overtredingen

Waar free() je die buffer overigens, ik zie je alleen alloceren?

bufferoverflows zijn er toch in meerdere varianten ??
heap overflow && stack overflow && <vast nog meer>

De fout was inderdaad dat realloc een ander stuk claimed (zover was ik in het begin onbewust al, zie eerste posts) maar ik was in de veronderstelling dat realloc de pointer naar pTempTotaal zelf aanpaste (eerste argument) maar dat kan natuurlijk niet tenzij de input char** was geweest.

bedankt voor jullie hulp.

gewijzigde code:
1: sja we moeten ook nog info teruggeven he en ff netjes Free

C:

*out = strdup(pTempTotaal);
free(pTemp);
free(pTempTotaal);
return(0);

2: de realloc aanpassen

C:

pTempTotaal = (char *)realloc(pTempTotaal,strlen(pTempTotaal)+strlen(pTemp)+128);

3: print eruit

C:

printf("len:%u,res:%u",strlen(pTempTotaal),strlen(pTempTotaal)+strlen(pTemp)+MAXDATALEN);

[ Voor 17% gewijzigd door xychix op 11-12-2003 13:33 ]

[Glimi]

xychix schreef op 11 december 2003 @ 13:31:
bufferoverflows zijn er toch in meerdere varianten ??
heap overflow && stack overflow &&
(...)

Bufferoverflow is op variabele niveau, terwijl een heap (out of mem) error /stack overflow problemen betekenen mbt de containers waarin je alloceert.
Denk bij een bufferoverflow meer aan char[100] waarin 101 characters worden gecopieerd bijvoorbeeld.

[.oisyn]

over het algemeen treden heap errors op door geheugen meerdere keren free'en of het overschrijven van nog niet gealloceerd of al vrijgegeven geheugen