网络协议的字节序

Question

I would like your advise please. I need to implement some protocol using tcp client/server. It has several messeges, some of the with odd number of bytes such as:

typedef struct _msg1
{
unsigned short opcode
unsigned char  value
}msg1;

What do you think is the best way to implement it, in order to avoid byte ordering issues. I thought of the following principles:

1. use pragma pack(1) on struct defintions to avoid padding

2. use htons/htonl when read/write from/into struct for example:

   mymsg1.opcode = htons(0x1234);

   mymsg1.value = 0x56;

Some of the messeges are more ugly such as the following which it's number of bytes is unknown before run-time, and I still not sure what the best way to define it for sending.

typedef struct _msg_errors
{
unsigned short opcode
unsigned char errortable[DEPENDS_ON_NUMBER_OF_REAL_ERRORS]
}msg_errors;

Thanks, Ran

Answer 1

My inclination would be to avoid "overlay casts" as a means of reading structured data. If performance isn't critical, it may be helpful to define methods like:

int getBE16(uint8_t **p) { // Big-endian 16-bit
  uint8_t *pp = *p;
  int result = pp[0]*256 + pp[1];
  (*p)+=2;
}
int getLE16(uint8_t **p) { // Little-endian 16-bit
  uint8_t *pp = *p;
  int result = pp[0] + 256*pp[1];
  (*p)+=2;
}
int getBE32(uint8_t **p) { // Big-endian 32-bit
  uint8_t *pp = *p;
  int result = ((pp[0]*256 + pp[1])*256 + pp[2])*256 + pp[3];
  (*p)+=4;
}
int getLE32(uint8_t **p) { // Little-endian 16-bit
  uint8_t *pp = *p;
  int result = pp[0] + 256*(pp[1] + 256*(pp[2] + 256*pp[3]));
  (*p)+=4;
}

Given an array uint8_t dat[6] and a structure consisting of an 8-bit value, a 16-bit little-endian value, and a 32-bit big-value in that order, one would then write:

uint8_t *p = dat;
mystruct.theByte = *p++;
mystruct.theHalfword = getLE16(&p);
mystruct.theWord = getBE32(&p);

The above code will be portable independent of byte order. It would be nicer if the function calls and pointer arithmetic could be eliminated, but eliminating those would require either explicitly specifying the offset of each field in the data structure, or else using some really icky macros to do so.