[C] bizarre overflow

[Verwijderd]

Ik ben bezig een implementatie voor een watchlist te maken (inotify, ubuntu). Het coden gaat opzich lekker alleen ik krijg een hele rare error. Op het moment dat ik de 5e plek in mijn array probeer te vullen crasht het programma. Voor de rest werken de prekken prima, iemand een suggestie?

code:

char **path_list;
int *wd_list;
int counter;

void addDirs(int fd, char* path)
{
    printf("Counter: %d  path: %s \n",counter,path);
    struct dirent *entry;
    DIR *dp;
    int wd=0;
    counter += 1;
    dp = opendir(path);
    wd = inotify_add_watch(fd, path, IN_CREATE | IN_DELETE | IN_MOVED_FROM | IN_MOVED_TO);
    //path_list[counter] = path;
    path_list[8] = "test";
    
    while((entry = readdir(dp)))
    {       
        if((entry->d_type == DT_DIR) && (strcmp(entry->d_name,".") != 0) && (strcmp(entry->d_name,"..") != 0))
        {
            char tmpDir[strlen(path) + strlen(entry->d_name)];
            sprintf(tmpDir, "%s%s%s", path, "/", entry->d_name);
            addDirs(fd, tmpDir);
        }
    }
    closedir(dp);
}


int main(int argc, char ** argv)
{
    int length, i = 0, both=0, lookup_table_size=0;
    int fd,wd;
    char buffer[EVENT_BUF_LEN];
    char* directory1="/tmp";
    char* directory2="/home/xxxx/Examples";
    fd = inotify_init();    
    counter = 0;
    
    lookup_table_size = countDirs(0, directory1) + countDirs(0, directory2);
    wd_list =(int *) malloc(lookup_table_size);
    path_list = (char **) malloc(lookup_table_size);
    addDirs(fd,directory1);
    addDirs(fd,directory2);

[Reptile209]

Volgens mij ben je zo met pointers en malloc's aan het stunten, dat je daar ergens de mist in moet gaan. Welke waarde krijgt lookup_table_size bijvoorbeeld in regel 40?
En wat probeer je op regel 15 met

C:

path_list[8] = "test";

te doen?
Kortom, loop er eens stap-voor-stap met een debugger overheen en check dan met name of je overal netjes binnen de grenzen van je geheugenblokjes blijft.

[EddoH]

- welke array?
- string literals moet je met const char * declareren
- path_list[8] = "test"; zonder te checken op size?

we zijn geen debugmachine -> graag alleen relevante code posten en duidelijk aangeven wat je geprobeerd hebt en waar het mis gaat.

[Soultaker]

Waar te beginnen? Ik ben het wel met bovenstaande heren eens dat je zelf ook aan het debuggen mag slaan, en dat je hoogstwaarschijnlijk wel een simpelere testcase kunt vinden waar je de mist in gaat.

Je code staat bol van de fouten. Een belangrijke is dat malloc() bytes alloceert, dus malloc(n) alloceert niet genoeg ruimte voor n integers, en ook niet voor n character pointers, waardoor wd_list en path_list niet goed geïnitialiseerd zijn.

Een ander probleem is de tmpDir[] buffer die je op de stack alloceert. Je alloceert ruimte voor de directory en de bestandsnaam, maar niet voor de slash en de zero-byte die je er daarna ook nog naar schrijft: gegarandeerde buffer overflow. Vervolgens geef je een pointer naar de buffer weer door aan addDirs() die 'm doodleuk aan een globale variabele toekent (in die niet-uitgecommentarieerde versie tenminste). Dat gaat mis zodra de onsprokelijke declaratie uit scope verdwijnt, want dan is de bufferruimte ongeldig geworden. Die buffers moeten dus waarschijnlijk dynamisch gealloceerd worden of gekopieerd (bijvoorbeeld met strdup()) als je ze wil bewaren.

Verder is een fundamenteel ontwerpprobleem in je programma dat je blijkbaar éérst telt hoeveel bestanden er in een directory tree zitten en die vervolgens nog eens allemaal langsgaat, maar tussen het moment waarop je telde en het moment waarop je door de directory heenloopt kunnen er best allerlei bestanden toegevoegd of verwijderd zijn, waardoor je eindresultaat dus niet klopt. Deze lookuptable kun je dus ook beter dynamisch alloceren (bijvoorbeeld met een linked list) in plaats van met een array die je van te voren alloceert.