Segmentation fault when attempting to get length of file name - c

Question

I have narrowed a segmentation fault down to the specific line of code causing it. Here is a straightforward example showing the issue I am having.
int main()
{
char** files;
int sum;
int i;
DIR *d;
struct dirent *dir;
d = opendir(".");
if (d)
{
sum = file_sum();
char* files[sum];
i = 0;
while ((dir = readdir(d)) != NULL)
{
files[i] = dir->d_name;
i++;
}
closedir(d);
}
else
{
return -1;
}
int len = strlen(files[0]); /*segmentation fault here*/
return 0;
}
Essentially what the program is doing is taking the names of all of the files from the current directory and putting them into an array. I am then going to try to get the sizes of all of the file names, but I have been getting a segmentation fault. My theory is that perhaps the file names are not null-terminated? If this is true, I am unsure of a workaround for that, but any assistance is appreciated.
Thanks
EDIT: Sorry I had an error here. The segmentation fault only occurs when I try to store the strlen return value, as I have now changed the code to above

Answer 1

Inside of your if block, you're defining a variable named files. This masks the variable of the same name at the top of the function. It is not specifying the size of the array at the higher scope, which seems to be your intent. So when you exit the if block, the inner files goes out of scope, and the outer files is left uninitialized. You then dereference the uninitialized pointer, causing the core dump.
What you want to do is dynamically allocate the necessary memory inside of the if block for the memory you need.
Also, the directory name retrieved into dir->d_name probably gets overwritten on each call to readdir, so you need to allocate space for that as well.
EDIT:
You also don't need a separate function to get the file count. You can allocate the array with a default size and realloc to expand as needed:
int main()
{
char** files;
int sum;
int i;
DIR *d;
struct dirent *dir;
d = opendir(".");
if (d)
{
int size = 10;
sum = 0;
files = malloc(size * sizeof(char *)); // allocate the array
if (files == NULL) {
perror("malloc failed");
exit(1);
}
while ((dir = readdir(d)) != NULL)
{
if (sum >= size) {
// if the array is full, realloc twice the size
char **tmp;
size *= 2;
tmp = realloc(size * sizeof(char *));
if (tmp == NULL) {
perror("realloc failed");
exit(1);
}
files = tmp;
}
files[sum] = strdup(dir->d_name); // allocate and copy each string
sum++;
}
closedir(d);
}
else
{
return -1;
}
strlen(files[0]);
// free the individual strings
for (i=0; i<sum; i++) {
free(files[i]);
}
// free the array
free(files);
return 0;
}

Answer 2

Using "char* files[sum]" is only safe under 2 conditons:
you not trying to access the array after the end of it's declaration range: you shouln't try to access the "files" array after the end of the "if" where it's declared
that char* target need to be safely reserved. It's reasonnable to assume that the target is valid right after dir->d_name but after having closed the d DIR it's pretty risky
Here's a simple fix if you know how many files there can be in your directory : copying the dirent struct to dirList is the simplest but it's quite a big struct. You can also copy only a pointer to the dirent using "dirListPtr" but you need to be sure that your dirent struct is still valid. That's why i have put "closedir" a bit farther down.
If you're not sure about the number of files, dynamic allocation is the way to go (see dbush answer). If you want to use the data in another function, allocation is required too.
#include <stdio.h>
#include <sys/types.h>
#include <dirent.h>
#include <string.h>
int main()
{
int sum;
int i;
DIR *d;
struct dirent* dir;
// you must be sure to have less than 255 files
struct dirent dirList[255];
struct dirent* dirListPtr[255];
d = opendir(".");
if (d)
{
i = 0;
while ((dir = readdir(d)) != NULL)
{
// copy the dirent information to our local variable which will live until the end of the main
dirList[i] = *dir;
// or keep only a pointer to the dirent struct: the system will surely not discard the dirent at least as long as d is open
dirListPtr[i] = dir;
i++;
}
}
else
{
return -1;
}
printf("size of filename: %lu size of dirent %lu\n", strlen(dirList[0].d_name), sizeof(dirList[0]));
printf("size of filename: %lu\n", strlen(dirListPtr[0]->d_name));
closedir(d);
return 0;
}
size of filename: 2 size of dirent 280
size of filename: 2