C unknown-size structure - c

Question

I am writing an app with the following dynamic config structure:
typedef struct {
char apphash[41];
char filenames_count;
char * filename[64];
} config;
But this code is wrong, I can't figure out how to copy data from and to c->filename[0] properly; c is a pointer to config structure, allocated dynamically like
config * c = (config *) malloc( 42 + 64 * 2 ) // alloc for 2 filenames. can realloc() later.
It segfaults if I use something like strcpy(c->filename[0],"file1.txt").
Can someone please help me with this?
Currently, I'm using direct address calculation, like
strcpy(
(char*)
((unsigned long) c + 42 /* apphash + filenames_count */ +
64 * 0 /* first item */ ),
"file1.txt"
);
and it works of course.
You see, I'm more of assembly programmer than of C, but I'd like this code to be more human-readable. This code looks that bad because I'm newcomer in C.
Oh, I gave a bad description of the situation. Sorry for that :(
The real code looks like:
config * c = (config*) malloc( 42 + 64 * 2 );
// we may realloc() it later if we are going to add more filenames.
// failing example how I do copy one default filename
strcpy(c->filename[0],"file1.txt");
// working example (i386)
strcpy((char*)((unsigned long) c + 42 + 64 * 0),"file1.txt");
I am using fully static structure type because it is going to be loaded directly from a file next time. That's why I can't really use pointers inside the structure, I need real data to be placed there.
I do check all lengths, no BOFs in real code, I just omitted all that stuff here.
I still didn't find a good solution to this.
Thanks again and sorry for bad question information.

Answer 1

I assume you have many filenames since you have filenames_count. Try
config_obj.filename[0] = strdup("file1.txt")

Answer 2

In your struct you're allocating an array of pointers to chars, not an array of chars. You must explicitely allocate also the targets of pointers, or at the very least, make the struct contain also the arrays of chars themselves:
char filename[64][MAX_PATH+1];
Replace MAX_PATH with the maximum length of any filename. Mind that this is not a very elegant solution, albeit a really simple one, because you're wasting lots of space.
Your direct address calculation is doing something different: it's placing the string directly in the space allocated for the pointers (and this is a Terribly Wrong Thing To Do™)

Answer 3

Right now config is a type that means the struct you have defined. You don't show us an identifier referring to an actual variable of type config.
So, first thing we need an instance of type config. You will either do
config c;
... c.filename ...
note the structure access operator is a ., or you will do something like
config *p = malloc(config)
/* error checking */
...c->filename ...
where -> is the pointer-dereference-and-access operator. The first form is preferred unless you hve a reason to want dynamic allocation (which, alas, happens a lot in c).
Then you have to figure out just what you want filename to be. As it is you have allocated space for 64 character pointers which don't point at allocated memory (except by purest acident, and then not at the memory you mean). You probably wanted{*} char filename[64] (a single filename allowed to be up to 63 characters long (to leave room for the null termination)) in which case you would use
strcpy(c.filename,"file1.txt");
/* or */
strcpy(p->filename,"file1.txt");
depending on how you allocated the structure in the first place.
If you really wanted a list of filenames, then you may want char *filenames[64], but you will have to allocate a buffer for each name before you can use it
c.filenames[0] = malloc(sizeOfString);
/* error checking */
strcpy(c.filenames[0],...
or as another poster suggested
c.filenames[o] = strdup(...
The first form may be better if you are building your filenames from multiple pieces and can project the total length from the get go.
{*} Later you may want to scrap this fixed length buffer, but leave that for now.

Answer 4

It is currently failing because you aren't allocating memory for the filenames. Either use strdup or malloc+strcpy (I'd use strdup).
Your filename field is an array of pointers to zero terminated string. You need to allocate the memory for the string and copy the string to that memory. You save the address of the new string in one of the pointers, e.g. filename[0].
The direct memory address code doesn't work. It just doesn't crash, yet! That code just overwrites the array of pointers. Don't ever write code like that. Never ever ever!! Writing code like that is morally equivalent to eating baby unicorns.