Re: Network/Host byte ordering and bitfields

[Eljay Love-Jensen <eljay at adobe dot com>]

Hi Marcio,

Here's the short example in GCC's C...

- - - a.h - - - - - - - - - - - - - - - - - -

struct A
{
  unsigned int a : 1;
  unsigned int b : 26;
  unsigned int c : 3;
};  __attribute__((packed));
// WARNING:  If this structure changes,
// change the readStructA and writeStructA routines!

extern void readStructA(int fd, struct A*);
extern void writeStructA(int fd, struct A*);

- - - a.c - - - - - - - - - - - - - - - - - -

#include <stdio.h>
#include <unistd.h>
#include <inttypes.h>

/* I'm going to use file descriptors instead of FILE*.  That way, you don't 
have to know what kind out output you are writing to (e.g., a file, a 
socket, a pipe, et cetera).  Feel free to substitute FILE* and the 
analogous file functions instead.
*/

/* Canonical Struct A record format
 * byte a[1];
 * byte b[4]; // in agnostic network order
 * byte c[1];
**/

void writeStructA(int fd, struct A* x)
{
  uint8_t item1 = x->a;
  uint32_t item2 = x->b;
  uint8_t item3 = x->c;
  ssize_t err;

  err = write(fd, &item1, sizeof item1);
  if(err != sizeof item1) Kboom();

  item2 = htonl(item2);
  err = write(fd, &item2, sizeof item2);
  if(err != sizeof item2) Kboom();

  err = write(fd, &item3, sizeof item3);
  if(err != sizeof item3) Kboom();

/* If converting to FILE* and related functions, you MAY want a fflush 
here, and a check to make sure the flush worked.  The low level read/write 
against a file descriptor is normally unbuffered.  Except for IP sockets 
and Nagle's algorithm for buffering packets, but that's a whole 'nother can 
of worms.
*/
}

// C style slicing takes care of our bit twiddling needs.
// But I'm including masking anyway, just for illustration.
void readStructA(int fd, struct A* x)
{
  uint8_t item1;
  uint32_t item2;
  uint8_t item3;
  ssize_t err;

  err = read(fd, &item1, sizeof item1);
  if(err != sizeof item1) Kboom();
  x->a = item1 & 0x01;

  err = read(fd, &item2, sizeof item2);
  if(err != sizeof item2) Kboom();
  item2 = ntohl(item2);
  x->b = item2 & 0x03FFFFFF;

  err = read(fd, &item3, sizeof item3);
  if(err != sizeof item3) Kboom();
  x->c = item3 & 0x07;
}

// Kboom does something appropriate for handling error situations.

- - - - - - - - - - - - - - - - - - - - -

HTH,
--Eljay