El contexto de mi problema está en la programación de redes. Digamos que quiero enviar mensajes a través de la red entre dos programas. Por simplicidad, digamos que los mensajes se ven así, y el orden de bytes no es una preocupación. Quiero encontrar una manera correcta, portátil y eficiente de definir estos mensajes como estructuras C. Conozco cuatro enfoques para esto: casting explícito, casting a través de una unión, copiado y marshaling.

struct message {
    uint16_t logical_id;
    uint16_t command;
};

Casting explícito:

void send_message(struct message *msg) {
    uint8_t *bytes = (uint8_t *) msg;
    /* call to write/send/sendto here */
}

void receive_message(uint8_t *bytes, size_t len) {
    assert(len >= sizeof(struct message);
    struct message *msg = (struct message*) bytes;
    /* And now use the message */
    if (msg->command == SELF_DESTRUCT)
        /* ... */
}

Mi entendimiento es que send_message no viola las reglas de aliasing, porque un puntero byte/char puede alias de cualquier tipo. Sin embargo, lo contrario no es cierto, por lo que receive_message viola las reglas de aliasing y por lo tanto tiene un comportamiento indefinido.

Fundición a través de una Unión:

union message_u {
    struct message m;
    uint8_t bytes[sizeof(struct message)];
};

void receive_message_union(uint8_t *bytes, size_t len) {
    assert(len >= sizeof(struct message);
    union message_u *msgu = bytes;
    /* And now use the message */
    if (msgu->m.command == SELF_DESTRUCT)
        /* ... */
}

Sin embargo, esto parece violar la idea de que un sindicato solo contiene a uno de sus miembros en un momento dado. Además, esto parece que podría conducir a problemas de alineación si el búfer de origen no está alineado en una palabra / media palabra límite.

Copiando:

void receive_message_copy(uint8_t *bytes, size_t len) {
    assert(len >= sizeof(struct message);
    struct message msg;
    memcpy(&msg, bytes, sizeof msg);
    /* And now use the message */
    if (msg.command == SELF_DESTRUCT)
        /* ... */
}

Esto parece garantizado para producir el resultado correcto, pero por supuesto que preferiría mucho no tener que copiar los datos.

Marshaling

void send_message(struct message *msg) {
    uint8_t bytes[4];
    bytes[0] = msg.logical_id >> 8;
    bytes[1] = msg.logical_id & 0xff;
    bytes[2] = msg.command >> 8;
    bytes[3] = msg.command & 0xff;
    /* call to write/send/sendto here */
}

void receive_message_marshal(uint8_t *bytes, size_t len) {
    /* No longer relying on the size of the struct being meaningful */
    assert(len >= 4);    
    struct message msg;
    msg.logical_id = (bytes[0] << 8) | bytes[1];    /* Big-endian */
    msg.command = (bytes[2] << 8) | bytes[3];
    /* And now use the message */
    if (msg.command == SELF_DESTRUCT)
        /* ... */
}

Todavía hay que copiar, pero ahora desacoplado de la representación de la estructura. Pero ahora necesitamos ser explícitos con la posición y el tamaño de cada miembro, y la endianidad es un tema mucho más obvio.

Información relacionada:

¿Cuál es el alias estricto la regla?

Arreglo de aliasing con puntero a estructura sin violar el estándar

¿Cuándo es seguro char* para el alias estricto del puntero?

Http://blog.llvm.org/2011/05/what-every-c-programmer-should-know.html

Ejemplo del Mundo Real

He estado buscando ejemplos de código de red para ver cómo se maneja esta situación en otros lugares. El ip ligero tiene algunos casos similares. En el udp.c el archivo contiene el siguiente código:

/**
 * Process an incoming UDP datagram.
 *
 * Given an incoming UDP datagram (as a chain of pbufs) this function
 * finds a corresponding UDP PCB and hands over the pbuf to the pcbs
 * recv function. If no pcb is found or the datagram is incorrect, the
 * pbuf is freed.
 *
 * @param p pbuf to be demultiplexed to a UDP PCB (p->payload pointing to the UDP header)
 * @param inp network interface on which the datagram was received.
 *
 */
void
udp_input(struct pbuf *p, struct netif *inp)
{
  struct udp_hdr *udphdr;

  /* ... */

  udphdr = (struct udp_hdr *)p->payload;

  /* ... */
}

Donde struct udp_hdr es una representación empaquetada de una cabecera udp y p->payload es de tipo void *. Siguiendo mi entendimiento y esta respuesta, esto es definitivamente [editar - no] rompiendo el estricto aliasing y por lo tanto tiene un comportamiento indefinido.