C and memory alignment for a binary protocol

Question

I will use this code as an example:

typedef struct __attribute__((aligned(XXX),packed))
{
   uint16_t type;
   uint32_t id_index;
} a_msg;

void write_func(){
   a_mesg mymsg
   mymsg.type = htons(1);
   mymsg.id_index = htonl(5);
   write(sock_fd, &mymsg, sizeof(a_mesg));
}

void read_func(){
   a_mesg mymsg
   read(sock_fd, &mymsg, sizeof(a_mesg));
   mymsg.type = ntohs(mymsg.type);
   mymsg.id_index = ntohl(mymsg.id_index);     
}

Note: sock_fd is a tcp socket. This is a bit compressed example and would maybe not work but I think you see what I am trying to exemplify (a program that communicates over a binary protocol).

If the application would only run on two 32 bit machines, that communicate with each other through the application, the alignment (aligned(XXX)) would naturally be set to 4. If we communicate in between a 32 bit machine and a 64 bit machine what would the alignment be?

1. Should XXX be 4 on both 32 and 64 bit machines?
2. Should XXX be 8 on both 32 and 64 bit machines?
3. Should XXX be 8 on 64 machines and 4 on 32 bit machines?
4. XXX is of some other value.

My bet is on alternative 2.

Answer 1

I would use

#pragma pack 1

on structures. This gives you no padding, which means less net traffic (less bytes to send). Easy casting.

ex:

struct S1 {
   char c1;  // Offset 0, 3 bytes padding
   int i;    // Offset 4, no padding
   char c2;  // Offset 8, 3 bytes padding
};  // sizeof(S1)==12, alignment 4

#pragma pack 1

struct S2 {
   char c1;  // Offset 0, no padding
   int i;    // Offset 1, no padding
   char c2;  // Offset 5, no padding
};  // sizeof(S2)==6, alignment 1

Answer 2

I would always used packed structures for any comms protocol. Less scope for confusion, no unecessary overhead, no difficult casting to eliminate the padding at the other end.