Segfault when deleting non-empty directory using C - c

Question

I am trying to delete a none-empty directory without system calls and without using extensive libraries. My code so far is...
int rmrf(char *path) {
char* path_copy = (char *) malloc(1024 * sizeof(char));
strcpy(path_copy, path);
DIR *directory = opendir(path_copy);
struct dirent *entry = readdir(directory);
while (entry != NULL) {
if (!strcmp(entry->d_name, ".") || !strcmp(entry->d_name, "..")) { //skip /. and /..
} else if (entry->d_type == DT_DIR) { //directory recurse
strcat(path_copy, "/");
strcat(path_copy, entry->d_name);
rmrf(path_copy);
remove(path);
} else { //file delete
strcat(path_copy, "/");
strcat(path_copy, entry->d_name);
remove(path_copy);
}
entry = readdir(directory);
}
closedir(directory);
return 0;
}
my current file structure looks something like this...
Who
|---Region 1
|---County 1
|---SubCounty 1
|---County 2
|---Region 2
|---County 1
|---Region 3
currently I am getting seg faults but in different places as the day progresses. Earlier today I would get about two levels of recursion deep and then seg fault out but as of now I can't even make past a full level down. I can't figure out what is wrong and when I use gdb to look into the problem I get...
malloc.c: No such file or directory.
Any help would be appreciated!
UPDATE:
I have taken suggestions from paxdiablo and came up with the resulting function...
int rmrf(char *path) {
char* path_copy = malloc(1024);
DIR *directory = opendir(path);
struct dirent *entry = readdir(directory);
while (entry != NULL) {
if (!strcmp(entry->d_name, ".") || !strcmp(entry->d_name, "..")) { //skip /. and /..
} else if (entry->d_type == DT_DIR) { //directory recurse
strcpy(path_copy, path);
strcat(path_copy, "/");
strcat(path_copy, entry->d_name);
rmrf(path_copy);
remove(path);
} else { //file delete
strcpy(path_copy, path);
strcat(path_copy, "/");
strcat(path_copy, entry->d_name);
remove(path_copy);
}
entry = readdir(directory);
}
closedir(directory);
free(path_copy);
return 0;
}
however I am still getting a seg fault though it is getting further in the recursion. The gdb output for the seg fault is as followed...
Program received signal SIGSEGV, Segmentation fault.
_int_malloc (av=av#entry=0x7ffff7dd1b20 <main_arena>, bytes=bytes#entry=32816) at malloc.c:3802
3802 malloc.c: No such file or directory.
(gdb) where
#0 _int_malloc (av=av#entry=0x7ffff7dd1b20 <main_arena>, bytes=bytes#entry=32816) at malloc.c:3802
#1 0x00007ffff7a91184 in __GI___libc_malloc (bytes=32816) at malloc.c:2913
#2 0x00007ffff7ad51ba in __alloc_dir (statp=0x7fffffffe190, flags=0, close_fd=true, fd=6) at ../sysdeps/posix/opendir.c:247
#3 opendir_tail (fd=6) at ../sysdeps/posix/opendir.c:145
#4 __opendir (name=<optimized out>) at ../sysdeps/posix/opendir.c:200
#5 0x0000000000401bca in rmrf ()
#6 0x0000000000401c8d in rmrf ()
#7 0x0000000000401c8d in rmrf ()
#8 0x0000000000402380 in main ()
Thoughts?

Answer 1

For your initial code, you do this once when entering the function:
strcpy(path_copy, path);
Then you do this for each file or directory in the current directory:
strcat(path_copy, "/");
strcat(path_copy, entry->d_name);
That means, if you have the files a, b and c in your current directory /xx, the path_copy variable will cycle through:
/xx/a /xx/a/b /xx/a/b/c
rather than the correct:
/xx/a /xx/b /xx/c
With a sufficiently large number of files, you will easily blow out the 1024 bytes allocates for the path.
If you want to fix that then you should start the variable from scratch each time:
if ((strcmp(entry->d_name, ".") != 0) && (strcmp(entry->d_name, "..") != 0)) {
if (entry->d_type == DT_DIR) {
strcpy(path_copy, path);
strcat(path_copy, "/");
strcat(path_copy, entry->d_name);
rmrf(path_copy);
remove(path);
} else {
sprintf(path_copy, "%s/%s", path, entry->d_name);
remove(path_copy);
}
}
You'll note that I've modified your initial condition a little so that it makes more sense (only do the inner bit if the file is neither . nor ..).
I've also shown, in the else clause, a shorter way of constructing the string to delete using sprintf rather than a set of strcpy/strcat calls. Feel free to do that in the if clause as well if you wish, I've left it using the old method so you can see all you needed to do was add the initial path.
And just a few extra points, applicable to your first and/or second code snippet:
You should also make sure you free the memory you allocate at each level, immediately before returning from the function, between closedir() and return.
You never need to cast the return value of malloc since a void * can be implicitly cast to any other type of pointer. In fact, it's dangerous to do so since it can hide certain subtle errors.
Similarly, you never need to multiply by sizeof(char) - that is, by definition, always one.
You can move the creation of path_copy to before the file/directory check since it's common to both parts.
And, finally, you're going to have troubles if the directory you're processing doesn't actually exist since opendir will return NULL and you will immediately try to pass that to readdir.
With all that in mind, I'd start with the following program which actually walks the tree and prints out all the files it finds. Once you're happy with that, you can add back in the bit that deletes:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <dirent.h>
int rmrf(char *path) {
char *path_copy = malloc(1024);
DIR *directory = opendir(path);
if (directory != NULL) {
struct dirent *entry = readdir(directory);
while (entry != NULL) {
if ((strcmp(entry->d_name, ".") != 0) && (strcmp(entry->d_name, "..") != 0)) {
sprintf(path_copy, "%s/%s", path, entry->d_name);
if (entry->d_type == DT_DIR) {
rmrf(path_copy);
puts(path);
} else {
puts(path_copy);
}
}
entry = readdir(directory);
}
closedir(directory);
}
free(path_copy);
return 0;
}
The main code is just a driver to ensure thinks are set up correctly. Just make sure, before running, you don't have (in your current directory) a paxtest or paxtest2 file or directory you want to keep around.
int main(void) {
system("rm -rf paxjunk");
system("mkdir paxjunk");
system("touch paxjunk/0.txt");
system("mkdir paxjunk/1");
system("touch paxjunk/1/1.txt");
system("mkdir paxjunk/2");
system("touch paxjunk/2/2.txt");
rmrf("paxjunk");
puts("===");
system("rm -rf paxjunk2");
rmrf("paxjunk2");
puts("===");
system("rm -rf paxjunk");
return 0;
}
When you run this, you should see it working okay:
paxjunk/0.txt
paxjunk/1/1.txt
paxjunk
paxjunk/2/2.txt
paxjunk
===
===