C programming structure passed as cast to char * ?

Question

I have a little problem, in a scenario where:

while (read(dp->fd, (char *) &dirbuf, sizeof(dirbuf)) == sizeof(dirbuf)) { ... }

where dirbuf is:

struct direct dirbuf { 
    ino_t d_ino; char d_name[DIRSIZ]; 
};  

How does C know to read in data contingently into our structure? With the read() Like, the alignment of our dirbuf fits perfectly as a character array? since read accepts a void * for its second argument, passing a structure as a cast to char * makes very little sense to me, how does it cater for other member elements properly?

I'm not sure if I'm even asking this question properly, I hope someone can decipher my problem behind my lunacy and help me out.

Thanks.

Answer 1

It doesn't read and properly align the fields in the structure. It just takes the total size of the structure (from sizeof) and the starting address (from &dirbuf) and reads into that memory without regard to the struct declaration.

The assumption is that whatever was in the file was already properly aligned to fit in the structure.

The (char *) cast is just there to shut the compiler up. (void *) would have done just as well. Or no cast at all, since the compiler will convert pointer type to void* without casting.

Answer 2

Hysterical Raisens

Casting buffers to char * is a legacy code pattern that one sees frequently. It has been used so often that it is still typed in today, long after it ceased to be necessary.

At one point there was no void type, so an API like read(2) would declare the buffer parameter as char * and all callers would cast their data to char *.

But read(2) has been a void * for a long, long, time. It has been that long since it was necessary to have any kind of a cast at the call site.

However, the old code is still around, people still read it, and then they perpetuate the design pattern.

It doesn't do any harm.

With respect to contiguous data, one of two things is happening. Either the data structure and the type is designed to lay out densely on most or all likely machines, or a similar statement was used to write the data out in the first place so pad bytes don't matter unless the data file is to be moved between disparate architectures.

Answer 3

This must be a nod to archaic versions of C langauage, which didn't have void * type and used char * instead. If you are using a non-archaic compiler and the parameter is indeed void *, there's no need to cast anything to char * (and there's no need to cast anything to void * either)

read(dp->fd, &dirbuf, sizeof(dirbuf)) 

And C does not know and does not need to know how to read the data into your specific structure. When you do something like the above, the binary data from the file is blindly read into the raw memory occupied by your dirbuf object. If the layout of that binary data is correct (for example, if the file was created by writing the same structure in the same way), then everything will be aligned properly and everything will automatically fall into its proper place.

Note, that unless you are working with something that is covered by a very strict specification, such a straighforward binary write/read techniques are only useable within a single session of the same program, or maybe between different sessions of the same version of the program on the same platform. Once you start dealing with different platforms and/or different versions of the code on the same platform, thing can easily fall apart once the raw memory layout of the data changes.