Using structs with attibute packed when parsing binary data

Question

Have seen various code around where one read data into a char or void and then cast it to a struct. Example is parsing of file formats where data has fixed offsets.

Example:

struct some_format {
    char magic[4];
    uint32_t len;
    uint16_t foo;
};

struct some_format *sf = (struct some_format*) buf;

To be sure this is always valid one need to align the struct by using __attribute__((packed)).

struct test {
    uint8_t a;
    uint8_t b;
    uint32_t c;
    uint8_t d[128];
} __attribute__((packed));

When reading big and complex file formats this surely makes things much simpler. Typically reading media format with structs having 30+ members etc.

It is also easy to read in a huge buffer and cast to proper type by for example:

struct mother {
    uint8_t a;
    uint8_t b;
    uint32_t offset_child;
};

struct child {
     ...
}

m = (struct mother*) buf;
c = (struct child*) ((uint8_t*)buf + mother->offset_child);

Or:

read_big_buf(buf, 4096);

a = (struct a*) buf;
b = (struct b*) (buf + sizeof(struct a));
c = (struct c*) (buf + SOME_DEF);
...

It would also be easy to quickly write such structures to file.

---

My question is how good or bad this way of coding is. I am looking at various data structures and would use the best way to handle this.

• Is this how it is done? (As in: is this common practice.)
• Is __attribute__((packed)) always safe?
• Is it better to use sscanf. ^{What was I thinking about?, Thanks @Amardeep}
• Is it better to make functions where one initiates structure with casts and bit shifting.
• etc.

---

As of now I use this mainly in data information tools. Like listing all structures of a certain type with their values in a file format like e.g. a media stream. Information dumping tools.

Answer 1

It is how it is sometimes done. Packed is safe as long as you use it correctly. Using sscanf() would imply you are reading text data, which is a different use case than a binary image from a structure.

If your code does not require portability across compilers and/or platforms (CPU architectures), and your compiler has support for packed structures, then this is a perfectly legitimate way of accessing serialized data.

However, problems may arise if you try to generate data on one platform and use it on another due to:

1. Host Byte Order (Little Endian/Big Endian)
2. Different sizes for language primitive types (long can be 32 or 64 bits for example)
3. Code changes on one side but not the other.

There are libraries that simplify serialization/deserialization and handle most of these issues. The overhead of such operations is easier justified on systems that must span processes and hosts. However, if your structures are very complex, using a ser/des library may be justified simply due to ease of maintenance.