序列化和序列化德在ANSI C

Question

問題是我已經工作了相當一段時間，解決不了，爲什麼它不能正常工作，希望你能幫助我一起想辦法！我會盡量保持描述性。

的想法是序列化的結構（NIPC分組結構），通過TCP發送到另一個進程，然後反序列化和重新建立該結構。但不知何故，我無法讓它正常工作，只是偏袒。這裏是結構。

typedef struct { 
    char pct_type; 
    short int payload_lenght; 
}__attribute__((__packed__)) t_header; 

typedef struct { 
    char* path; 
    long unsigned int size; 
    long int offset; 
}__attribute__ ((__packed__)) t_payload_read; 

typedef struct { 
    t_header header; 
    t_payload_read payload; 
}__attribute__ ((__packed__)) t_pct_read; 

然後，我第一序列有效載荷（偏移量，大小和路徑），以計算有效負載的長度，則整個分組，包括報頭將其發送。然後反序列化，但沒有辦法讓它工作，另一方面，我得到的標題確定和路徑字段「確定」，但我得到奇怪的數字上的偏移量和大小，例如，使用這個硬編碼值的結構：

type: 4 
offset: 5 
size: 15 
path: ~/Desarrollo/Workspace 

我得到：

pct->header.pct_type: 4 
pct->header.payload_length: 28 
pct->payload.path: ~/Desarrollo/Workspac 
pct->payload.size: 143994937 
pct->payload.offset: 143994941 

在這裏，我追加了序列化和反序列化功能，我設計，我想是爲描述和仔細越好。

char* serialize_read(t_pct_read* packet) { 
    char* buffer = malloc(
      sizeof(t_header) + sizeof(packet->payload.offset) 
        + sizeof(packet->payload.size) 
        + strlen(packet->payload.path + 1)); 
    char* payload = malloc(
      sizeof(packet->payload.offset) + sizeof(packet->payload.size) 
        + strlen(packet->payload.path) + 1); 
    int offset; 

    // First I serialize the Payload, in order to calculate It's lenght 

    memcpy(payload, packet->payload.path, strlen(packet->payload.path) + 1); 

    offset = strlen(packet->payload.path)+1; 

    memcpy(payload + offset, &packet->payload.size, sizeof(long unsigned int)); 

    offset += (sizeof(long unsigned int)); 

    memcpy(payload + offset, &packet->payload.offset, sizeof(long int)); 

    packet->header.payload_lenght = offset+1; // Here I get payload's length 

    offset = 0; 

    // Same procedure here, but for the entire packet, including the header.  

    memcpy(buffer, &packet->header.pct_type, sizeof(char)); 

    offset = sizeof(char); 

    memcpy(buffer + offset, &packet->header.payload_lenght, sizeof(short int)); 

    offset += sizeof(short int); 

    memcpy(buffer + offset, packet->payload.path, 
      strlen(packet->payload.path) + 1); 

    offset += strlen(packet->payload.path + 1); 

    memcpy(buffer + offset, &packet->payload.size, sizeof(long unsigned int)); 

    offset += (sizeof(long unsigned int)); 

    memcpy(buffer + offset, &packet->payload.offset, sizeof(long int)); 

    return buffer; 

} 

t_pct_read* deserialize_read(char* stream) { 
    t_pct_read* packet = malloc(sizeof(t_pct_read)); 

    int offset; 
    int alloc_size; 

    memcpy(&packet->header.pct_type, stream, sizeof(char)); 

    offset = sizeof(char); 

    memcpy(&packet->header.payload_lenght, stream + offset, sizeof(short int)); 

    offset += sizeof(short int); 

    for (alloc_size = 1; (stream + offset)[alloc_size - 1] != '\0'; 
      alloc_size++) { 
     packet->payload.path = malloc(alloc_size)+1; 
    } 

    memcpy(packet->payload.path, stream + offset, alloc_size+1); 

    offset += strlen(packet->payload.path); 

    memcpy(&packet->payload.size, stream + offset, sizeof(long unsigned int)); 

    offset += (sizeof(long unsigned int)); 

    memcpy(&packet->payload.offset, stream + offset, sizeof(long int)); 

    return packet; 
} 

Answer 1

strlen(packet->payload.path + 1)看起來可疑，尤其是相對於strlen(packet->payload.path) + 1)。
你確定這是你的意思嗎？

Answer 2

拋開風格問題，你的反序列化函數中有一個錯誤。取而代之的

offset += strlen(packet->payload.path); 

使用

offset += alloc_size+1