在C中将64位unsigned int来回转换为char缓冲区

Question

我的目标是通过网络发送以网络字节顺序以 64 位无符号整数开头的数据报。所以首先我使用宏将数字转换为大端:

#define htonll(x) ((1==htonl(1)) ? (x) : ((uint64_t)htonl((x) & 0xFFFFFFFF) << 32) | htonl((x) >> 32))
#define ntohll(x) ((1==ntohl(1)) ? (x) : ((uint64_t)ntohl((x) & 0xFFFFFFFF) << 32) | ntohl((x) >> 32))

然后我将它序列化到一个缓冲区中:

unsigned char * serialize_uint64(unsigned char *buffer, uint64_t value) {
  printf("**** seriializing PRIu64 value = %"PRIu64"\n", value);
  int i;
  for (i = 0; i < 8; i++)
    buffer[i] = (value >> (56 - 8 * i)) & 0xFF;
  for (i = 0; i < 8; i++)
    printf("bufer[%d] = %x\n", i, buffer[i]);

  return buffer + 8;
}

然后我反序列化它

uint64_t deserialize_uint64(unsigned char *buffer) {
  uint64_t res = 0;
  printf("*** deserializing buffer:\n");
  int i;
  for (i = 0; i < 8; i++)
    printf("bufer[%d] = %x\n", i, buffer[i]);
  for (i = 0; i < 8; i++)
    res |= buffer[i] << (56 - 8 * i);


  return res;
}

它似乎适用于小整数，但以下测试代码无法正常工作:

uint64_t a = (uint64_t) time(NULL);
printf("PRIu64: a =%"PRIu64"\n", a);

uint64_t z = htonll(a);
uint64_t zz = ntohll(z);
printf("z = %"PRIu64" ==> zz = %"PRIu64" \n", z, zz);

unsigned char buffer[1024];
serialize_uint64(buffer, z);
uint64_t b = deserialize_uint64(buffer);
uint64_t c = ntohll(g);

当我得到

a = 1494157850
htonll(a) = 1876329069679738880 ==> ntohll(htonll(a)) = 1494157850 
**** seriializing PRIu64 value = 1876329069679738880
bufer[0] = 1a
bufer[1] = a
bufer[2] = f
bufer[3] = 59
bufer[4] = 0
bufer[5] = 0
bufer[6] = 0
bufer[7] = 0
*********
*** deserializing buffer:
bufer[0] = 1a
bufer[1] = a
bufer[2] = f
bufer[3] = 59
bufer[4] = 0
bufer[5] = 0
bufer[6] = 0
bufer[7] = 0
===> res = 436866905
c = 6417359100811673600

似乎缓冲区没有捕获更大的数字......

Answer 1

你的序列化器本质上是

unsigned char *serialize_u64(unsigned char *buffer, uint64_t value)
{
    buffer[7] = value & 0xFF;
    value >>= 8;
    buffer[6] = value & 0xFF;
    value >>= 8;
    buffer[5] = value & 0xFF;
    value >>= 8;
    buffer[4] = value & 0xFF;
    value >>= 8;
    buffer[3] = value & 0xFF;
    value >>= 8;
    buffer[2] = value & 0xFF;
    value >>= 8;
    buffer[1] = value & 0xFF;
    value >>= 8;
    buffer[0] = value & 0xFF;
    return buffer + 8;
}

并序列化value从 native 字节顺序到网络字节顺序；不需要宏。

所以，它看起来像 OP 的 serialize_uint64()应该工作得很好。只是根本不应该使用字节顺序宏。

OP 的 deserialize_uint64()应该投 buffer[i]至 (uint64_t)移位前，确保移位结果为64位。就个人而言，我更喜欢将反序列化器编写为

unsigned char *serialize_u64(unsigned char *buffer, uint64_t *valueptr)
{
    uint64_t value = buffer[0];
    value <<= 8;
    value |= buffer[1];
    value <<= 8;
    value |= buffer[2];
    value <<= 8;
    value |= buffer[3];
    value <<= 8;
    value |= buffer[4];
    value <<= 8;
    value |= buffer[5];
    value <<= 8;
    value |= buffer[6];
    value <<= 8;
    value |= buffer[7];
    *valueptr = value;
    return buffer + 8;
}

如果 OP 使用 res |= ((uint64_t)buffer[i]) << (56 - 8 * i);，它执行与 OP 相同的操作相反。

同样，序列化器和反序列化器都已经将数据与网络字节序和本地字节序相互转换；根本不应使用字节顺序宏。