C/C++ Little/Big Endian handler

Question

There are two systems that communicate via TCP. One uses little endian and the second one big endian. The ICD between systems contains a lot of structs (fields). Making bytes swap for each field looks like not the best solution.

Is there any generic solution/practice for handling communication between systems with different endianness?

Answer 1

Generally speaking, values transmitted over a network should be in network byte order, i.e. big endian. So values should be converted from host byte order to network byte order for transmission and converted back when received.

The functions htons and ntohs do this for 16 bit integer values and htonl and ntohl do this for 32 bit integer values. On little endian systems these functions essentially reverse the bytes, while on big endian systems they're a no-op.

So for example if you have the following struct:

struct mystruct {
    char f1[10];
    uint32_t f2;
    uint16_t f3;
};

Then you would serialize the data like this:

// s points to the struct to serialize
// p should be large enough to hold the serialized struct
void serialize(struct mystruct *s, unsigned char *p)
{
    memcpy(p, s->f1, sizeof(s->f1));
    p += sizeof(s->f1);

    uint32_t f2_tmp = htonl(s->f2);
    memcpy(p, &f2_tmp, sizeof(f2_tmp));
    p += sizeof(s->f2);

    uint16_t f3_tmp = htons(s->f3);
    memcpy(p, &f3_tmp, sizeof(f3_tmp));
}

And deserialize it like this:

// s points to a struct which will store the deserialized data
// p points to the buffer received from the network
void deserialize(struct mystruct *s, unsigned char *p)
{
    memcpy(s->f1, p, sizeof(s->f1));
    p += sizeof(s->f1);

    uint32_t f2_tmp;
    memcpy(&f2_tmp, p, sizeof(f2_tmp));
    s->f2 = ntohl(f2_tmp);
    p += sizeof(s->f2);

    uint16_t f3_tmp;
    memcpy(&f3_tmp, p, sizeof(f3_tmp));
    s->f3 = ntohs(f3_tmp);
}

While you could use compiler specific flags to pack the struct so that it has a known size, allowing you to memcpy the whole struct and just convert the integer fields, doing so means that certain fields may not be aligned properly which can be a problem on some architectures. The above will work regardless of the overall size of the struct.