example_network.c

/**
 * @file example_network.c
 * @brief Example demonstrating network serialization (simulated)
 */

#include "binserde.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* Network packet structure */
typedef struct {
    uint16_t packet_id;
    uint16_t sequence;
    uint8_t flags;
    char payload[256];
} NetworkPacket;

/* Simulate sending data over network */
static void simulate_network_send(const uint8_t *data, size_t size) {
    (void)data;  /* Unused in simulation */
    printf("  [Network] Sending %zu bytes...\n", size);
    /* In real application, this would use sockets */
    printf("  [Network] Data sent successfully\n");
}

/* Simulate receiving data from network */
static void simulate_network_receive(uint8_t *dest, const uint8_t *src, size_t size) {
    printf("  [Network] Receiving %zu bytes...\n", size);
    memcpy(dest, src, size);
    printf("  [Network] Data received successfully\n");
}

int main(void) {
    printf("=== Binary Serialization Network Example ===\n\n");
    
    /* Create a packet */
    NetworkPacket packet = {
        .packet_id = 0x1234,
        .sequence = 42,
        .flags = 0x05
    };
    strncpy(packet.payload, "Hello from the network!", sizeof(packet.payload) - 1);
    packet.payload[sizeof(packet.payload) - 1] = '\0';
    
    printf("Original packet:\n");
    printf("  Packet ID: 0x%04X\n", packet.packet_id);
    printf("  Sequence: %u\n", packet.sequence);
    printf("  Flags: 0x%02X\n", packet.flags);
    printf("  Payload: %s\n\n", packet.payload);
    
    /* Serialize packet */
    uint8_t send_buffer[1024];
    binserde_writer_t writer;
    binserde_error_t err;
    
    err = binserde_writer_init(&writer, send_buffer, sizeof(send_buffer), 1);
    if (err != BINSERDE_OK) {
        fprintf(stderr, "Writer init failed: %s\n", binserde_error_string(err));
        return 1;
    }
    
    /* Write header */
    err = binserde_write_header(&writer);
    if (err != BINSERDE_OK) {
        fprintf(stderr, "Write header failed: %s\n", binserde_error_string(err));
        return 1;
    }
    
    /* Write packet data */
    err = binserde_write_uint16(&writer, packet.packet_id);
    if (err != BINSERDE_OK) {
        fprintf(stderr, "Write packet_id failed: %s\n", binserde_error_string(err));
        return 1;
    }
    
    err = binserde_write_uint16(&writer, packet.sequence);
    if (err != BINSERDE_OK) {
        fprintf(stderr, "Write sequence failed: %s\n", binserde_error_string(err));
        return 1;
    }
    
    err = binserde_write_uint8(&writer, packet.flags);
    if (err != BINSERDE_OK) {
        fprintf(stderr, "Write flags failed: %s\n", binserde_error_string(err));
        return 1;
    }
    
    err = binserde_write_string(&writer, packet.payload);
    if (err != BINSERDE_OK) {
        fprintf(stderr, "Write payload failed: %s\n", binserde_error_string(err));
        return 1;
    }
    
    /* Write checksum for data integrity */
    err = binserde_write_checksum(&writer);
    if (err != BINSERDE_OK) {
        fprintf(stderr, "Write checksum failed: %s\n", binserde_error_string(err));
        return 1;
    }
    
    size_t packet_size = binserde_writer_position(&writer);
    printf("Serialized packet: %zu bytes\n\n", packet_size);
    
    /* Print hex dump of first 32 bytes */
    printf("Hex dump (first 32 bytes):\n  ");
    for (size_t i = 0; i < packet_size && i < 32; i++) {
        printf("%02X ", send_buffer[i]);
        if ((i + 1) % 16 == 0) printf("\n  ");
    }
    printf("\n\n");
    
    /* Simulate network transmission */
    printf("Simulating network transmission:\n");
    simulate_network_send(send_buffer, packet_size);
    
    uint8_t recv_buffer[1024];
    simulate_network_receive(recv_buffer, send_buffer, packet_size);
    printf("\n");
    
    /* Deserialize received packet */
    binserde_reader_t reader;
    err = binserde_reader_init(&reader, recv_buffer, packet_size);
    if (err != BINSERDE_OK) {
        fprintf(stderr, "Reader init failed: %s\n", binserde_error_string(err));
        return 1;
    }
    
    /* Read header */
    uint32_t version;
    err = binserde_read_header(&reader, &version);
    if (err != BINSERDE_OK) {
        fprintf(stderr, "Read header failed: %s\n", binserde_error_string(err));
        return 1;
    }
    printf("Received packet with schema version: %u\n\n", version);
    
    /* Read packet data */
    NetworkPacket received = {0};
    
    err = binserde_read_uint16(&reader, &received.packet_id);
    if (err != BINSERDE_OK) {
        fprintf(stderr, "Read packet_id failed: %s\n", binserde_error_string(err));
        return 1;
    }
    
    err = binserde_read_uint16(&reader, &received.sequence);
    if (err != BINSERDE_OK) {
        fprintf(stderr, "Read sequence failed: %s\n", binserde_error_string(err));
        return 1;
    }
    
    err = binserde_read_uint8(&reader, &received.flags);
    if (err != BINSERDE_OK) {
        fprintf(stderr, "Read flags failed: %s\n", binserde_error_string(err));
        return 1;
    }
    
    char *payload_ptr = NULL;
    err = binserde_read_string(&reader, &payload_ptr);
    if (err != BINSERDE_OK) {
        fprintf(stderr, "Read payload failed: %s\n", binserde_error_string(err));
        return 1;
    }
    strncpy(received.payload, payload_ptr, sizeof(received.payload) - 1);
    received.payload[sizeof(received.payload) - 1] = '\0';
    free(payload_ptr);
    
    /* Validate checksum */
    err = binserde_validate_checksum(&reader);
    if (err != BINSERDE_OK) {
        fprintf(stderr, "Checksum validation failed: %s\n", binserde_error_string(err));
        return 1;
    }
    printf("Checksum validated - no data corruption\n\n");
    
    /* Display received packet */
    printf("Received packet:\n");
    printf("  Packet ID: 0x%04X\n", received.packet_id);
    printf("  Sequence: %u\n", received.sequence);
    printf("  Flags: 0x%02X\n", received.flags);
    printf("  Payload: %s\n\n", received.payload);
    
    /* Verify transmission integrity */
    if (received.packet_id == packet.packet_id &&
        received.sequence == packet.sequence &&
        received.flags == packet.flags &&
        strcmp(received.payload, packet.payload) == 0) {
        printf("✓ Network transmission successful!\n");
        printf("✓ Endianness handled correctly (network byte order)\n");
    } else {
        printf("✗ Data corruption detected!\n");
    }
    
    return 0;
}