В массив записать разнородные данные для передачи этого пакета по сети

// includes..
u_int8_t * newMem = (u_int8_t *)malloc( 17 );
 
u_int8_t * code = 0;
int64_t * count1 = 1024*1024*10;
int64_t * count2 = 1024*1024*10;
 
newMem[0] = code;
((int64_t *)newMem)[1] = count1;
((int64_t *)newMem)[9] = count2;

struct foo {
    int a;
    float b;
    double c;
};
 
struct foo bar[10];
send(, bar, sizeof(bar), 0);

    struct packet
    {
        u_int8_t version;
        u_int8_t command;
        u_int16_t length;
        u_int32_t error;
        void * data;
    };
 
        struct packet pack;
 
        memset(newMem, 0, 5+17*pack->length);
        memcpy(newMem, pack->data, 5);

    struct rcv_traf
    {
        u_int8_t kind;
        int64_t in;
        int64_t out;
    };
 
        struct rcv_traf traf[pack->length];
        for (int i=0; i<pack->length; i++)
        {
                traf[i].kind = code;
                traf[i].in = count1;
                traf[i].out = count2;
        }
        memcpy(&newMem[size_ipcount], &traf, sizeof(traf));

struct some_data {...} *some_data;
 
struct packet some_packet = malloc(sizeof(struct packet) + sizeof(struct some_data) - 1);
/* кастуем раз */
some_data = (struct some_data)&some_packet->data;
some_data->foo = 123;
memcpy(some_data->bar, "bar", 3);
ну и тд

    struct packet
    {
        u_int8_t version;
        u_int8_t command;
        u_int16_t length;
        u_int32_t error;
        void * data;
    };

// 17 байт массива из элементов по 1 байт
u_int8_t * newMem = (u_int8_t *)malloc( 17 );
 
// 2 переменные, по 8 байт каждая
int64_t * count1 = 1024*1024*10;
int64_t * count2 = 1024*1024*10;
 
// заносим 1й элемент - все в порядке, т.к. типы данных одинаковые
u_int8_t * code = 0;
newMem[0] = code;
 
/* обращение к 1 и 9 элементам массива, состоящего из элементов по 8 байт!
   т.е. - ошибка */
((int64_t *)newMem)[1] = count1;
((int64_t *)newMem)[9] = count2;

u_int8_t * newMem = (u_int8_t *)malloc( 17 );
u_int8_t * code = 0;
newMem[0] = code;
 
/* указатель на 1-байтный integer ссылается на 2й элемент массива, 
   состоящего из элементов по 1 байт */
int64_t * temp = &newMem[1];
 
int64_t * count1 = 1024*1024*10;
int64_t * count2 = 1024*1024*10;
 
// записываем данные, соответствующие массиву из 8-байтных элементов
temp[0] = count1;
temp[1] = count2;

void*