В чем может быть проблема при передаче контейнера «сложных» объектов по UDP?

Question

[Никита Савиных]

Есть, предположим, вот такой вот набор синтетических конструкций:

#include <cstdint>
#include <deque>
#include <algorithm>

struct Point;
struct Additional;

struct Track
{
    uint64_t id;
    std::deque<Point> points;

    void appendNewPoint(int x, int y, Additional additional);
};


struct Additional
{
    int dx;
    int dy;
};

struct Point
{
    Additional additional_data;
    int x;
    int y;
    uint64_t id;
    Track * parent;
    Point * next();
    Point * prev();
};

Point * Point::next()
{
    auto& container = parent->points;
    auto result = std::find_if(container.begin(), container.end() - 1, [this](Point& n) {
        return this == &n;
    });
    return (result == container.end() - 1 ) ? this : &(*(result + 1));
}

Point * Point::prev()
{
    auto& container = parent->points;
    auto result = std::find_if(container.rbegin(), container.rend() - 1, [this](Point& n) {
        return this == &n;
    });
    return (result == container.rend() - 1 ) ? this :  &(*(result + 1));
}

void Track::appendNewPoint(int x, int y, Additional additional)
{
    Point point = {additional, x, y, this->points.size(), this};
    this->points.push_back(point);
}

Допустим, у меня есть некоторый контейнер, который хранит данные типа Track:
std::unordered_map<uint64_t, Track> Tracks;

Вопрос:
Как мне передать это по UDP пользуясь unix сокетами?
Я так понимаю, это все ведь можно представить как набор данных, представить его как void * выделить под данные пол мегабайта, и отправить это все дело на сервер, а на сервере полученные данные скастовать обратно в std::unordered_map <uint64_t, Track> или нельзя так делать? Если нельзя, то как можно?

P.S.: Методы структур представлены в ознакомительных целях, чтобы показать, что структуры, которые я собираюсь передать также имеют некоторые методы, механика которых не сильно (но все-таки) отличается от приведенных здесь.

Comments

[Никита Савиных]

Набросал простой клиент-сервер, в итоге, как только пытаюсь прочитать любую значение любой точки из трека, сервер сегфолтится

Сервер:

int main() {

    int sockfd = socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP);
    char resBuff[1024];

    sockaddr_in serv_addr, client_addr;
    if (sockfd < 0)
        std::cout << "Error opening socket" << std::endl;

    memset(&serv_addr, 0, sizeof(sockaddr_in));
    memset(&client_addr, 0, sizeof(sockaddr_in));
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(8080);

    bind(sockfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr));
    socklen_t len;

    int n = recvfrom(sockfd, (char *)resBuff, 1024,
                 MSG_WAITALL, ( struct sockaddr *) &serv_addr,
                 &len);

    auto * t = (Track*)resBuff;

    std::cout << t->id << std::endl;
    std::cout << t->points.size() << std::endl;
//    std::cout << t->points[0].x<< std::endl; // Тут segfault
    return 0;
}

Клиент:

#include "Tracker.h"


int main() {
    Track t;
    t.id = 101;
    Additional additional = {1, 1};
    t.appendNewPoint(1, 1, additional);
    t.appendNewPoint(7, 2, additional);
    t.appendNewPoint(4, 3, additional);
    
    int sockfd;
    struct sockaddr_in servaddr;

    if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
        perror("socket creation failed");
        exit(EXIT_FAILURE);
    }

    memset(&servaddr, 0, sizeof(servaddr));

    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(8080);
    servaddr.sin_addr.s_addr = INADDR_ANY;

    sendto(sockfd, &t, 1024,
           MSG_CONFIRM, (const struct sockaddr *) &servaddr,
           sizeof(servaddr));
}

[Евгений Шатунов]

Никита Савиных, изучи.
MSS в UDP, кстати, 1.4КБ (1436Б в среднем роутере). Все что больше этого размера, на роутере подвергнется или фрагментации, или шейпингу. Оба варианта приведут к проблемам. Некоторые роутеры при шейпинге просто забывают дослать все, что превысило MSS.
Не допускай превышения MSS.

[Никита Савиных]

Евгений Шатунов, круто, спасибо, пойду читать.

Answer 1

[Roman]

https://www.boost.org/doc/libs/1_72_0/libs/seriali...
на русском -> https://github.com/Danchetto/Boost.Serialization/b...

Comments

[Никита Савиных]

Надеялся, что силами STL получится справится, но, видимо, не судьба.
Спасибо!

Answer 2

[jcmvbkbc]

Вопрос:
Как мне передать это по UDP пользуясь unix сокетами?

Сериализовать в непрерывную область памяти, убедиться, что она влезет в UDP-пакет (а у него есть ограничение длины, чуть меньше 64Кб), передать, принять, де-сериализовать в свою структуру.

это все ведь можно представить как набор данных, представить его как void * выделить под данные пол мегабайта, и отправить это все дело на сервер, а на сервере полученные данные скастовать обратно в std::unordered_map <uint64_t, Track> или нельзя так делать?

Нельзя так делать, если не знаешь наверняка внутренней структуры того, что посылаешь. Потому что это твой std::unordered_map -- наверняка не один сплошной кусок памяти и содержит указатели. И когда ты его передашь на другую машину, указатели будут указывать неизвестно куда.

Comments

[Никита Савиных]

Ну, в принципе и 64 хватит.
А как можно не слишком сильно утруждаться с тем, чтобы содержимое контейнера... сериализовать? (Вроде у плюсов есть небольшие проблемы с этим)
Есть ли какое-нибудь существующее проверенное решение, которое покрывает данный случай? (В гугле не забанили, но возможно что-нибудь на ум приходит.)

[res2001]

Никита Савиных, В плюсах нет никаких проблем с этим.