C writing readdir to char array variable? - c

Question

I am attempting to write a directory list into a char array but getting segmentation faults when attempting to use strcpy or strcat. Is there a better way to go about this?
I am just wanting to modify the following to create a string instead of printing to stdout. I am guessing I am just missing something really simple, but I have not been able to pin it down.
#include <stdio.h>
#include <dirent.h>
int main(void)
{
char returnData[2048];
struct dirent *de; // Pointer for directory entry
// opendir() returns a pointer of DIR type.
DIR *dr = opendir(".");
if (dr == NULL) // opendir returns NULL if couldn't open directory
{
printf("Could not open current directory" );
return 0;
}
// Refer http://pubs.opengroup.org/onlinepubs/7990989775/xsh/readdir.html
// for readdir()
while ((de = readdir(dr)) != NULL)
printf("%s\n", de->d_name); //strcat(returnData, de->d_name); produces segmentation fault here.
closedir(dr);
return 0;
}

Answer 1

First change:
char returnData[2048];
to
char returnData[2048] = { '\0' };
As already mentioned in the comments, you should initialize your Array with Zeros/NUL-Terminator, so the call to strcat is defined as strcat
replaces the '\0' with the src parameter.
And as some compilers complain use strncat or similar instead of strcat.
Also don't forget, that you also need to append '\n' to get the same output as with your printf.
You could either calculate the length beforehand resulting in two loops
or resize the buffer dynamically.
BTW: Why do you want to store it in a single string?

Answer 2

You are missing a couple of things. First don't use magic numbers... Where did 2048 come from? (a lick of the finger and holding it up in the air and saying "yep, that should be good enough"?) The limits.h header provides the macro PATH_MAX that is guaranteed to provide sufficient storage for all filesystem entries -- use that instead, e.g.:
#include <limits.h> /* for PATH_MAX */
...
char returnData[PATH_MAX] = ""; /* initialize to all zero is good habit */
(next, a typo I'm sure, but null is not NULL)
If you simply want to copy de->d_name to returnData, then use a function that will copy de->d_name to returnData, like strcpy, e.g.
while ((de = readdir(dr)) != NULL) {
strcpy (returnData, de->d_name);
puts (returnData);
}
(of course, it is overwritten on each iteration, so you are not going to return a list of files using returnData, notwithstanding the fact that returnData is declared within the current function with automatic-storage and if declared within another function could not be returned to begin with...)
So, all this beating around the bush to copy de->d_name to returnData has left you exactly where you began, being able to do no more than output the name of an entry one at a time.
Actually Allocating Storage For Each Directory Entry
What I suspect you are really wanting to do is to read all files in a directory into storage in a way you can return the list of names from a function for further processing within your code. That is common practice, but not something you can do with a single character array.
Instead, you need to declare a pointer-to-pointer-to-char (e.g. a "double-pointer", char **dlist;) which will allow you to allocate for some initial number of pointers (say 8) and then realloc more pointers as required to accommodate all the file or directory names within any directory. You then allocate only the storage required for each name (+1 for the nul-terminating character) and assign the storage for each name to its corresponding pointer and copy the name to the new storage you allocate.
That way you can then return a pointer to your collection of names from wherever you like. (remember objects will allocated-storage type have a lifetime that continues until the memory is freed or the program ends) Something like:
#define NPTRS 8 /* initial number of pointers to allocate */
...
char **dlist = NULL, /* ptr-to-ptr-to-char for names */
size_t idx = 0, /* current index */
nptrs = NPTRS; /* number of pointers allocated */
...
/* allocate/validate nptrs pointers */
if ((dlist = calloc (nptrs, sizeof *dlist)) == NULL) {
perror ("calloc-nptrs");
return EXIT_FAILURE;
}
while ((de = readdir (dp))) {
...
/* check if dlist pointer limit reached - realloc */
if (idx == nptrs) { /* alwasy realloc to temporary pointer */
void *tmp = realloc (dlist, nptrs * 2 * sizeof *dlist);
if (!tmp) { /* validate reallocation */
perror ("realloc-dlist");
break; /* break, don't exit, original storage still valid */
}
dlist = tmp; /* assign reallocated block to dlist */
/* (optional) set all newly allocated memory to zero */
memset (dlist + nptrs, 0, nptrs * sizeof *dlist);
nptrs *= 2; /* update the number of allocated pointers */
}
/* allocate storage for name in dlist */
if ((dlist[idx] = malloc (strlen (de->d_name) + 1)) == NULL) {
char errbuf[PATH_MAX] = ""; /* storage for perror message */
sprintf (errbuf, "malloc failed '%s'", de->d_name);
perror (errbuf);
break;
}
strcpy (dlist[idx++], de->d_name); /* copy to new storage at idx */
}
Now you have all names stored in dlist where idx indicates the number of names stored. You can return dlist from any function (you will also want to return idx through a parameter so the number of files stored is available back in the calling function as well, or move the reallocation below your copy (and include the 'optional' memset) to insure you always have a sentinel NULL pointer following the last valid entry -- which provides another way to indicate the valid names returned.
As you have (or will) find, readdir does not read the directory entries in any particular order. To be useful for output, sorting with qsort is the easiest way to order the filenames you have stored. A simple sort-ascending is shown in the example below.
Putting it altogether, you can read the entries in any directory (passed as the 1st argument to the program or from '.' (current dir) by default). The code will allocate pointers and reallocate as required. The code allocates exactly strlen(de->d_name) + 1 characters of storage for each entry, assigns the new block of memory to dlist[idx] and then copies the entry to dlist[idx] (you can use dlist[idx] = strdup (de->d_name); to allocate and copy in one step if your library provides strdup -- but remember strdup is allocating memory, so you should validate is succeeds before proceeding.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h> /* opendir */
#include <dirent.h> /* opendir, readdir */
#include <limits.h> /* for PATH_MAX */
#define NPTRS 8 /* initial number of pointers to allocate */
/** qsort string comparison (sort ascending) */
int cmpstr (const void *a, const void *b)
{
return strcmp (*(char * const *) a, *(char * const *) b);
}
int main (int argc, char **argv) {
char **dlist = NULL, /* ptr-to-ptr-to-char for names */
*dname = argc > 1 ? argv[1] : "."; /* dirname supplied (. default) */
size_t idx = 0, /* current index */
nptrs = NPTRS; /* number of pointers allocated */
struct dirent *de = NULL; /* dirent pointer (readdir) */
DIR *dp = opendir (dname); /* directory pointer (opendir) */
if (!dp) { /* validate directory open for reading */
char errbuf[PATH_MAX] = ""; /* storage for perror message */
sprintf (errbuf, "opendir failed on '%s'", dname);
perror (errbuf);
return EXIT_FAILURE;
}
/* allocate/validate nptrs pointers */
if ((dlist = calloc (nptrs, sizeof *dlist)) == NULL) {
perror ("calloc-nptrs");
return EXIT_FAILURE;
}
while ((de = readdir (dp))) {
/* skip dot files */
if (!strcmp (de->d_name, ".") || !strcmp (de->d_name, ".."))
continue;
/* check if dlist pointer limit reached - realloc */
if (idx == nptrs) { /* alwasy realloc to temporary pointer */
void *tmp = realloc (dlist, nptrs * 2 * sizeof *dlist);
if (!tmp) { /* validate reallocation */
perror ("realloc-dlist");
break; /* break, don't exit, original storage still valid */
}
dlist = tmp; /* assign reallocated block to dlist */
/* (optional) set all newly allocated memory to zero */
memset (dlist + nptrs, 0, nptrs * sizeof *dlist);
nptrs *= 2; /* update the number of allocated pointers */
}
/* allocate storage for name in dlist */
if ((dlist[idx] = malloc (strlen (de->d_name) + 1)) == NULL) {
char errbuf[PATH_MAX] = ""; /* storage for perror message */
sprintf (errbuf, "malloc failed '%s'", de->d_name);
perror (errbuf);
break;
}
strcpy (dlist[idx++], de->d_name); /* copy to new storage at idx */
}
closedir (dp); /* close directory */
/* qsort names stored in dlist */
qsort (dlist, idx, sizeof *dlist, cmpstr);
/* output all file/directory names stored, freeing memory as you go */
printf ("'%s' contains '%zu' files:\n\n", dname, idx);
for (size_t i = 0; i < idx; i++) {
puts (dlist[i]); /* output name */
free (dlist[i]); /* free storage for name */
}
free (dlist); /* free pointers */
return 0;
}
Example Use/Output
$ ./bin/opendir_readdir_dyn_char_basic .
'.' contains '1860' files:
3darrayaddr.c
3darrayalloc.c
3darrayfill.c
BoggleData.txt
DoubleLinkedList-old.c
DoubleLinkedList.c
DoubleLinkedList.diff
InputFile.txt
MonoSound.wav
...
xsplit.sh
xstrncpy.c
zeronotzero.c
Memory Use/Error Check
Note also in any code you write that dynamically allocates memory, you have 2 responsibilities regarding any block of memory allocated: (1) always preserve a pointer to the starting address for the block of memory so, (2) it can be freed when it is no longer needed.
It is imperative that you use a memory error checking program to insure you do not attempt to access memory or write beyond/outside the bounds of your allocated block, attempt to read or base a conditional jump on an uninitialized value, and finally, to confirm that you free all the memory you have allocated.
For Linux valgrind is the normal choice. There are similar memory checkers for every platform. They are all simple to use, just run your program through it.
$ valgrind ./bin/opendir_readdir_dyn_char_basic .
==16528== Memcheck, a memory error detector
==16528== Copyright (C) 2002-2015, and GNU GPL'd, by Julian Seward et al.
==16528== Using Valgrind-3.12.0 and LibVEX; rerun with -h for copyright info
==16528== Command: ./bin/opendir_readdir_dyn_char_basic .
==16528==
'.' contains '1860' files:
3darrayaddr.c
3darrayalloc.c
3darrayfill.c
BoggleData.txt
DoubleLinkedList-old.c
DoubleLinkedList.c
DoubleLinkedList.diff
InputFile.txt
MonoSound.wav
...
xsplit.sh
xstrncpy.c
zeronotzero.c
==16528==
==16528== HEAP SUMMARY:
==16528== in use at exit: 0 bytes in 0 blocks
==16528== total heap usage: 1,872 allocs, 1,872 frees, 109,843 bytes allocated
==16528==
==16528== All heap blocks were freed -- no leaks are possible
==16528==
==16528== For counts of detected and suppressed errors, rerun with: -v
==16528== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
Always confirm that you have freed all memory you have allocated and that there are no memory errors.
Look things over and let me know if you have further questions.