序列化：char和uint32_t的大小

Question

I have multiple questions.

1. Is the size of char always 1 (Byte) on every system ?
2. Is the size of uint32_t always 4 (Byte) on every system ?

I wrote two little functions to serialize my struct, but I can't tell if this is a good way to do it.

struct udtpackage{
    char version;
    bool eof;
    uint32_t data_size;
    uint32_t encrypted_size;
    char data[BUFFERSIZE+16];
    char hmac[64];
};

void serialize (udtpackage package, unsigned char* buffer){
    uint32_t tmp;

    memcpy(&buffer[0], &package.version, 1);
    (package.eof) ? (buffer[1] = 0xFF) : (buffer[1] = 0x00);
    tmp = htonl(package.data_size);
    memcpy(&buffer[2], &tmp, 4);
    tmp = htonl(package.encrypted_size);
    memcpy(&buffer[6], &tmp, 4);
    memcpy(&buffer[10], &package.data[0], BUFFERSIZE+16);
    memcpy(&buffer[10+BUFFERSIZE+16], &package.hmac[0], 64);
}

void deserialize (udtpackage* package, unsigned char* buffer){
    uint32_t tmp;

    memcpy(&package->version, &buffer[0], 1);
    (buffer[1] & 0xFF) ? (package->eof = true) : (package->eof = false);
    memcpy(&tmp, &buffer[2], 4);
    package->data_size = ntohl(tmp);
    memcpy(&tmp, &buffer[6], 4);
    package->encrypted_size = ntohl(tmp);
    memcpy(&package->data[0], &buffer[10], BUFFERSIZE+16);
    memcpy(&package->hmac[0], &buffer[10+BUFFERSIZE+16], 64);
}

Answer 1

1. Yes. The size of char is always 1. That doesn't mean that there are 8 bits per byte though.

2. No. For example, the implementation may define 32 bits per byte,
   then the size of uint32_t will be 1. If this is the case, some of the fixed width types will not be defined.

Here is a potential problem:

memcpy(&buffer[2], &tmp, 4);    
                         ^

As I mentioned in the second point, the code should be:

memcpy(&buffer[2], &tmp, sizeof(tmp));
                         ^

Going further the buffer offsets should be fixed as well, otherwise you will potentially waste memory:

memcpy(&buffer[6], &tmp, 4);
               ^