Come gestire i problemi di portabilità in un formato di file binario

Question

Sto progettando un formato di file binario per memorizzare stringhe [senza terminare null per risparmiare spazio] e dati binari.

i. Qual è il modo migliore per gestire sistemi little/big endian? i.a Converte tutto in ordine di byte di rete e viceversa con ntohl()/htonl() funziona?

ii. Le strutture impacchettate avranno le stesse dimensioni su x86, x64 e arm?

iii. Sono la loro debolezza intrinseca con questo approccio?

struct __attribute__((packed)) Header { 
    uint8_t magic; 
    uint8_t flags; 
}; 

struct __attribute__((packed)) Record { 
    uint64_t length; 
    uint32_t crc; 
    uint16_t year; 
    uint8_t day; 
    uint8_t month; 
    uint8_t hour; 
    uint8_t minute; 
    uint8_t second; 
    uint8_t type; 
}; 

codice Tester Sto utilizzando il sviluppano il formato:

#include <stdlib.h> 
#include <unistd.h> 
#include <stdio.h> 
#include <limits.h> 
#include <strings.h> 
#include <stdint.h> 
#include <sys/stat.h> 
#include <fcntl.h> 
#include <string.h> 

struct __attribute__((packed)) Header { 
    uint8_t magic; 
    uint8_t flags; 
}; 

struct __attribute__((packed)) Record { 
    uint64_t length; 
    uint32_t crc; 
    uint16_t year; 
    uint8_t day; 
    uint8_t month; 
    uint8_t hour; 
    uint8_t minute; 
    uint8_t second; 
    uint8_t type; 
}; 

    int main(void) 
    { 

     int fd = open("test.dat", O_RDWR|O_APPEND|O_CREAT, 444); 
     struct Header header = {1, 0}; 
     write(fd, &header, sizeof(header)); 
     char msg[] = {"BINARY"}; 
     struct Record record = {strlen(msg), 0, 0, 0, 0, 0, 0, 0}; 
     write(fd, &record, sizeof(record)); 
     write(fd, msg, record.length); 
     close(fd); 
     fd = open("test.dat", O_RDWR|O_APPEND|O_CREAT, 444); 


     read(fd, &header, sizeof(struct Header)); 
     read(fd, &record, sizeof(struct Record)); 
     int len = record.length; 
     char c; 
     while (len != 0) { 
      read(fd, &c, 1); 
      len--; 
      printf("%c", c); 
     } 
     close(fd); 
    } 

Answer 1

i. Definire il file in un ordine e convertirlo in e dall'ordine "interno", se necessario, durante la lettura/scrittura (forse con ntohl e simili) è, secondo me, l'approccio migliore.

ii. Non mi fido delle strutture imballate. Potrebbero funzionare per questo approccio per quelle piattaforme, ma non ci sono garanzie.

iii. Leggere e scrivere file binari usando fread e fwrite su intere strutture è (sempre secondo me) un approccio intrinsecamente debole. Massimizza la probabilità che ti vengano morsi problemi di dimensioni di parole, problemi di riempimento e allineamento e problemi di ordine dei byte.

Quello che mi piace fare è scrivere piccole funzioni come get16() e put32() che leggono e scrivono un byte alla volta e quindi sono intrinsecamente insensibili alle dimensioni della parola e alle difficoltà nell'ordine dei byte. Quindi scrivo direttamente le funzioni putHeader e getRecord (e simili) in termini di questi.

unsigned int get16(FILE *fp) 
{ 
    unsigned int r; 
    r = getc(fp); 
    r = (r << 8) | getc(fp); 
    return r; 
} 

void put32(unsigned long int x, FILE *fp) 
{ 
    putc((int)((x >> 24) & 0xff), fp); 
    putc((int)((x >> 16) & 0xff), fp); 
    putc((int)((x >> 8) & 0xff), fp); 
    putc((int)(x & 0xff), fp); 
} 

[P.S. Come @Olaf indica correttamente in uno dei commenti, nel codice di produzione è necessario gestire l'EOF e l'errore in queste funzioni. Li ho lasciati fuori per semplicità di presentazione.]