А вы умеете готовить nested_flatbuffers?

#include "client_builder.h"
#include "client_verifier.h"
#include <stdio.h>

int main(int argc, char ** argv)
{
    printf("Testing on C\n");

    // builder необходим для сериализации: превращения сообщения в байтовый буффер
    flatbuffers_builder_t builder;
    flatcc_builder_init(&builder);

    size_t size = 0;
    void* buf;
    {
        createRequest(&builder);
        buf = flatcc_builder_finalize_aligned_buffer(&builder, &size);
        receiveBuffer(buf, size);
        flatcc_builder_aligned_free(buf);
    }
    {
        flatcc_builder_reset(&builder);
        createResponse(&builder);
        buf = flatcc_builder_finalize_aligned_buffer(&builder, &size);
        receiveBuffer(buf, size);
        flatcc_builder_aligned_free(buf);
    }
    flatcc_builder_clear(&builder);
    return 0;
}

void createRequest(flatbuffers_builder_t* builder)
{
    ns(Type_enum_t) type = ns(Type_request);
    ns(Header_ref_t) header = ns(Header_create(builder, type));
    ns(Message_start_as_root(builder));
        ns(Message_header_create(builder, type));
        ns(Message_content_start_as_root(builder));
            flatbuffers_string_ref_t name = flatbuffers_string_create_str(builder, "This is some string for tests!");
            ns(Request_ref_t) request = ns(Request_create(builder, name));
            ns(CommonMessage_union_ref_t) msg_union = ns(CommonMessage_as_Request(request));
            ns(MessageHolder_data_add(builder, msg_union));
        ns(Message_content_end_as_root(builder));
    ns(Message_end_as_root(builder));
}

void createResponse(flatbuffers_builder_t* builder)
{
    ns(Type_enum_t) type = ns(Type_response);
    ns(Header_ref_t) header = ns(Header_create(builder, type));
    ns(Message_start_as_root(builder));
        ns(Message_header_create(builder, type));
        ns(Message_content_start_as_root(builder));
            ns(Response_ref_t) response = ns(Response_create(builder, 2, 3, 9));
            ns(CommonMessage_union_ref_t) msg_union = ns(CommonMessage_as_Response(response));
            ns(MessageHolder_data_add(builder, msg_union));
        ns(Message_content_end_as_root(builder));
    ns(Message_end_as_root(builder));
}

void receiveBuffer(void* buf, size_t size)
{
    const int verification_result = ns(Message_verify_as_root(buf, size));
    if (flatcc_verify_error_ok != verification_result) {
        printf("Unable to verify flatbuffer message\n");
    }
    ns(Message_table_t) msg = ns(Message_as_root(buf));
    ns(Header_table_t) header = ns(Message_header(msg));
    ns(Type_enum_t) type = ns(Header_type(header));
    printf("Received Type: %u\n", type);
    switch(type) {
	case ns(Type_request):
	    processRequest(&msg);
	    break;
	case ns(Type_response):
	    processResponse(&msg);
	    break;
	default:
   	    printf("Unknown type!\n");
	}
}

void processRequest(ns(Message_table_t)* msg)
{
    ns(MessageHolder_table_t) content = ns(Message_content_as_root(*msg));
    ns(Request_table_t) request = (ns(Request_table_t)) ns(MessageHolder_data(content));
    const char* name = ns(Request_name(request));
    printf("Result request: %s\n", name);
}

void processResponse(ns(Message_table_t)* msg)
{
    ns(MessageHolder_table_t) content = ns(Message_content_as_root(*msg));
    ns(Response_table_t) response = (ns(Response_table_t)) ns(MessageHolder_data(content));
    int x = ns(Response_x(response));
    int y = ns(Response_y(response));
    int z = ns(Response_z(response));
    printf("Result response: %d.%d.%d\n", x, y, z);
}

#include "flatbuffers/flatbuffers.h"
#include "client_generated.h"
#include "server_generated.h"
#include <iostream>
namespace cli = my_project::client;
namespace srv = my_project::server;

void createRequest(flatbuffers::FlatBufferBuilder& fbb)
{
    auto type = cli::Type::request;
    auto header = cli::CreateHeader(fbb, type);

    flatbuffers::FlatBufferBuilder fbb2;
    auto name = fbb2.CreateString("This is some string for tests!");
    auto rq = cli::CreateRequest(fbb2, name);
    auto data = cli::CreateMessageHolder(fbb2, cli::CommonMessage::Request, rq.Union());
    fbb2.Finish(data);

    auto content = fbb.CreateVector(fbb2.GetBufferPointer(), fbb2.GetSize());
    auto msg = cli::CreateMessage(fbb, header, content);
    cli::FinishMessageBuffer(fbb, msg);
} 

void createResponse(flatbuffers::FlatBufferBuilder& fbb)
{
    auto type = cli::Type::response;
    auto header = cli::CreateHeader(fbb, type);

    flatbuffers::FlatBufferBuilder fbb2;
    auto rp = cli::CreateResponse(fbb2, 2, 3, 9);
    auto data = cli::CreateMessageHolder(fbb2, cli::CommonMessage::Response, rp.Union());
    fbb2.Finish(data);

    auto content = fbb.CreateVector(fbb2.GetBufferPointer(), fbb2.GetSize());
    auto msg = cli::CreateMessage(fbb, header, content);
    cli::FinishMessageBuffer(fbb, msg);
}

void receiveBuffer(std::uint8_t* buf, std::size_t size)
{
    flatbuffers::Verifier verifier(buf, size);
    if (!cli::VerifyMessageBuffer(verifier))
    {
        std::cerr << "Unable to verify flatbuffer message\n";
        return;
    }

    auto msg = cli::GetMessage(buf);
    auto header = msg->header();
    auto type = header->type();
    std::cout << "Received HeaderType from client: " << static_cast<uint16_t>(type) << "\n";

    switch (type)
    {
        case cli::Type::request:
            processRequest (msg);
            break;
        case cli::Type::response:
            processResponse(msg);
            break;
    }
}

void processRequest(const cli::Message* msg)
{
    auto content = msg->content_nested_root();
    auto rq = content->data_as_Request();
    auto name = rq->name();
    std::cout << "Result request: " << name->str() <<"\n";
}

void processResponse(const cli::Message* msg)
{
    auto content = msg->content_nested_root();
    auto rp = content->data_as_Response();
    auto x = rp->x();
    auto y = rp->y();
    auto z = rp->z();
    std::cout << "Result response: " << x << "."  << y << "." << z <<"\n";
}

// используем глобальный экземпляр для простоты 
flatbuffers::FlatBufferBuilder fbb_;
// общий обработчик сообщения, полученного от клиента
void processClientMessage(const cli::Message* msg)
{
    fbb_.Clear();
    // constructing srv::Message from cli::Message
    switch (msg->header()->type())
    {
        case cli::Type::request:
            forwardMessage(msg, "SERVER-REQUEST");
            break;

        case cli::Type::response:
            forwardMessage(msg, "SERVER-RESPONSE");
            break;
    }
    // processing constructed srv::Message to verify it is correct
    processServerMessage();
}

// Самая интересная часть – пересылка сообщения от клиента без распаковки деталей
void forwardMessage(const cli::Message* msg, const char* extra_info_str)
{
    // Yes, we should recreate header as FlatBuffers don't have API to just copy it from msg->header()
    auto header = cli::CreateHeader(fbb_, msg->header()->type());

    auto extra_info = fbb_.CreateString(extra_info_str);

    // The main part: copying nested buffer from client to server message
    auto client_msg = msg->content();
    auto client_msg_vec = fbb_.CreateVector(client_msg->Data(), client_msg->size());

    auto content = srv::CreateClientData(fbb_, extra_info, client_msg_vec);

    auto server_msg = srv::CreateMessage(fbb_, header, srv::CommonMessage::ClientData, content.Union());
    srv::FinishMessageBuffer(fbb_, server_msg);
}

// пример обработки сообщения, сгенерированного сервером
void processServerMessage() const
{
    std::uint8_t* buf = fbb_.GetBufferPointer();
    auto msg = srv::GetMessage(buf);

    auto header = msg->header();
    auto header_type = header->type();
    auto content_type = msg->content_type();

    std::cout << "Received HeaderType from server: " << static_cast<uint16_t>(header_type) << "\n";
    std::cout << "Received ContentType from server: " << static_cast<uint16_t>(content_type) << "\n";

    if (content_type != srv::CommonMessage::ClientData)
    {
        std::cerr << "Not implemented Handler for this content_type\n";
        return;
    }

    // process only ClientData for demonstration purposes
    auto content = msg->content_as_ClientData();
    auto extra_info = content->extra_info();
    auto client_msg = content->client_msg_nested_root();

    std::cout << "Result request from server: extra_info: " << extra_info->str() << "\n";

    switch(header_type)
    {
        case cli::Type::request:
        {
            auto client_rq = client_msg->data_as_Request();
            auto client_name = client_rq->name();
            std::cout << "- client_msg: " << client_name->str() << "\n";
            break;
        }

        case cli::Type::response:
        {
            auto client_rp = client_msg->data_as_Response();
            auto x = client_rp->x();
            auto y = client_rp->y();
            auto z = client_rp->z();
            std::cout << "- client_msg: " << x << "." << y << "." << z << "\n";
            break;
        }
    }
}

extern crate flatbuffers;

#[allow(dead_code, unused_imports, non_snake_case)]
#[path = "../../fbs/client_generated.rs"]
mod client_generated;
pub use client_generated::my_project::client::{
    get_root_as_message,
    Type,
    Request,
    Response,
    Header,
    CommonMessage,
    MessageHolder,
    Message,
    RequestArgs,
    ResponseArgs,
    HeaderArgs,
    MessageHolderArgs,
    MessageArgs};

fn create_request(mut builder: &mut flatbuffers::FlatBufferBuilder)
{
// в Rust слово type является ключевым, поэтому генератор автоматически добавляет _
    let type_ = Type::request;
    let header = Header::create(&mut builder, &mut HeaderArgs{type_});

    let data_builder = {
        let mut b = flatbuffers::FlatBufferBuilder::new();

        let name = b.create_string("This is some string for tests!");
        let rq = Request::create(&mut b, &RequestArgs{name: Some(name)});

        let data = MessageHolder::create(&mut b, &MessageHolderArgs{
            data_type: CommonMessage::Request,
            data: Some(rq.as_union_value())});

        b.finish(data, None);
        b
    };

    let content = builder.create_vector(data_builder.finished_data());

    let msg = Message::create(&mut builder, &MessageArgs{
        header: Some(header),
        content: Some(content)});

    builder.finish(msg, None);
}

fn create_response(mut builder: &mut flatbuffers::FlatBufferBuilder)
{
    let type_ = Type::response;
    let header = Header::create(&mut builder, &mut HeaderArgs{type_});

    let data_builder = {
        let mut b = flatbuffers::FlatBufferBuilder::new();
        let rp = Response::create(&mut b, &ResponseArgs{x: 2, y: 3, z: 9});

        let data = MessageHolder::create(&mut b, &MessageHolderArgs{
            data_type: CommonMessage::Response,
            data: Some(rp.as_union_value())});

        b.finish(data, None);
        b
    };

    let content = builder.create_vector(data_builder.finished_data());

    let msg = Message::create(&mut builder, &MessageArgs{
        header: Some(header),
        content: Some(content)});

    builder.finish(msg, None);
}

fn process_request(msg: &Message)
{
    let content = msg.content_nested_flatbuffer().unwrap();
    let rq = content.data_as_request().unwrap();
    let name = rq.name().unwrap();
    println!("Result request: {:?}", name);
}

fn process_response(msg: &Message)
{
    let content = msg.content_nested_flatbuffer().unwrap();
    let rp = content.data_as_response().unwrap();
    println!("Result response: {}.{}.{}", rp.x(), rp.y(), rp.z());
}

fn receive_buffer(buf: &[u8])
{
    // NOTE: no verification exists in Rust yet
    let msg = get_root_as_message(buf);
    let header = msg.header().unwrap();
    let type_ = header.type_();
    println!("Received Type: {:?}", type_);

    match type_ {
        Type::request => {
            process_request(&msg);
        }

        Type::response => {
            process_response(&msg);
        }
    }
}

fn main() {
    println!("Testing on Rust");

    let mut builder = flatbuffers::FlatBufferBuilder::new_with_capacity(1024);
    {
    	create_request(&mut builder);
    	let buf = builder.finished_data();
	receive_buffer(&buf);
    }
    {
    	builder.reset();
    	create_response(&mut builder);
    	let buf = builder.finished_data();
	receive_buffer(&buf);
    }
}