Question

i coded a small program to show you the casting problem

#include <stdlib.h>

struct flags {

    u_char flag1;
    u_char flag2;
    u_short flag3;
    u_char flag4;
    u_short flag5;

    u_char flag7[5];
};


int main(){

    char buffer[] = "\x01\x02\x04\x03\x05\x07\x06\xff\xff\xff\xff\xff";

    struct flags *flag;

    flag = (struct flags *) buffer;

    return 0;
}

my problem is when i cast the flag 5 wrongly takes the “\x06\xff” bytes ignoring the “\x07” and the flag 7 wrongly takes the next 4 “\xff” bytes plus a nul which is the next byte.I also run gdb

(gdb) p/x flag->flag5 
$1 = 0xff06
(gdb) p/x flag->flag7 
$2 = {0xff, 0xff, 0xff, 0xff, 0x0}
(gdb) x/15xb flag
0xbffff53f: 0x01    0x02    0x04    0x03    0x05    0x07    0x06    0xff
0xbffff547: 0xff    0xff    0xff    0xff    0x00    0x00    0x8a

why this is happening and how i can handle it correctly?
thanks

Answer 1

It seems like structure member alignment issues. Unless you know how your compiler packs structure members, you should not make assumptions about the positions of those members in memory.

The reason that the 0x07 is apparently lost, is because the compiler is probably aligning the flag5 member on a 16-bit boundary, skipping the odd memory location that holds the 0x07 value. That value is lost in the padding. Also, what you are doing is overflowing the buffer, a big no-no. In other words:

struct flags { 
    u_char flag1;    // 0x01
    u_char flag2;    // 0x02
    u_short flag3;   // 0x04 0x03
    u_char flag4;    // 0x05
    // 0x07 is in the padding
    u_short flag5;   // 0x06 0xff 
    u_char flag7[5]; // 0xff 0xff 0xff 0xff ... oops, buffer overrun, because your
                     // buffer was less than the sizeof(flags)
}; 

You can often control the packing of structure members with most compilers, but the mechanism is compiler specific.