从 C++ UDP 缓冲区接收字符串

Question

I am attempting to retrieve a string inside a struct from a UDP buffer. The idea here is to first memcpy the the header and use the header.dataSize to tell recv how large the string is, then memcpy from buffer into a new string variable. The string is serialized data that will then be de-serialized into a struct.

The problem I am encountering is that when the receive side attempts to memcpy the string, it giving me an error for invalid pointer.

Error:

Data:
    
free(): invalid pointer
Aborted (core dumped)

Am i using memcpy wrong ? Or is there a better way to copy the specified size of data ? I tried memccpy using 0 as the termination char but that didn't work either.

Send code:

// interface details
std::string destIp = "127.0.0.1";
static uint16_t listPort = 10'000;
static uint16_t destPort = 10'001;

// -----------------------------------------------
// Main
// -----------------------------------------------
int main(){
    // initialize interface
    UDP* udp = new UDP(listPort, destIp, destPort);
    udp->init();

    // create data struct 
    SerialData data1;
    fillSerialData(data1);

    // create the out stream 
    std::ostringstream outStream;
    // serialize
    {
        cereal::BinaryOutputArchive archive_out(outStream);
        archive_out(data1);
    }
    // create message out struct
    SerialMessage send1;
    send1.hdr.domainId = 6;
    send1.hdr.msgId = 1;

    // copy archive into data location in string format
    send1.data = outStream.str();
    send1.hdr.dataSize = sizeof(send1.data);
    send1.hdr.timeStamp = getTimeStamp();

    // send the data
    int nbytes = udp->send(reinterpret_cast<uint8_t *>(&send1), sizeof(send1));

    // output to console. 
    std::cout << "\n\tSerialized Data:\n\t" << send1.data << std::endl << std::endl;
    std::cout << "\tbytes sent: " << nbytes << "\n\tdataSize: " << send1.hdr.dataSize << "\n\ttimeStamp: " << send1.hdr.timeStamp << "\n\n";

    return 0;
}

Receive Code:

int main(int, char **)
{
    std::cout << "Hello, recv!\n";

    // initialize signal handler
    signal(SIGINT, signalHandler);

    // initialize udp interface
    UDP *udp = new UDP(listPort, destIp, destPort);
    udp->init();

    // create buffer to read data into
    int recvSize = 0;
    int bufSize = 65536;
    uint8_t *buffer = new uint8_t[bufSize];
    memset(buffer, 0, bufSize);

    // loop and recv data
    while (!killSignal)
    {
        // receive message
        if ((recvSize = udp->recv(buffer, bufSize)) < 0){
            if (errno == EAGAIN){std::cout << "\n\treceive timeout";}
            else{std::cout << "\n\tERROR: " << strerror(errno) << "\n\n";}
        }
        else{
            std::cout << "\n\tReceived Message, size: " << recvSize << '\n';

            // get incoming message info via header
            Header inHdr;
            memcpy(&inHdr, buffer, sizeof(Header));
            std::string serData;
            memcpy(&serData, buffer, sizeof(inHdr.dataSize));

            std::cout << "\tdID: " << (int)inHdr.domainId << "\n\tmID: " << (int)inHdr.msgId << "\n\tdataLength: " << inHdr.dataSize << "\n\ttimeStamp: " << inHdr.timeStamp << std::endl;
            std::cout << "\nData:\n\t" << serData << std::endl;

            // TODO - remove comment tabs below after serData is showing to be filled with the data from buffer.
            //      deserialization part is good to go.  
/*
            // create in stream
            std::istringstream inStream(sMsg.data);
            // create object to store data in. 
            SerialData data;
            // De-serialize
            {
                cereal::BinaryInputArchive archive_in(inStream);
                archive_in(data);
            }
            std::cout << "Data Retreived From Archive:\n" << std::endl;
            printSerializedMessageData(data);
*/
        }
    }

    // close interface
    udp->close();

    // clear memory
    delete[] buffer;

    return 0;
}

My structs:

struct Header
{
    uint8_t domainId;
    uint8_t msgId;
    int msgCnt;
    uint16_t dataSize;
    uint64_t timeStamp;
};

struct Footer 
{
    uint32_t temp;
};
    
struct Target
{
    std::string type;
    double x, y, z;
    uint64_t timeStamp;
    
    template <class Archive>
    void serialize( Archive & ar ){
        ar( CEREAL_NVP(type), CEREAL_NVP(x), CEREAL_NVP(y), CEREAL_NVP(z), CEREAL_NVP(timeStamp) );
    }
};

struct SerialData
{
    int numTargets;
    std::vector<Target> tgt;

    template <class Archive>
    void serialize( Archive & ar ){
        ar( CEREAL_NVP(numTargets), CEREAL_NVP(tgt) );
    }
};

struct SerialMessage
{
    Header hdr;
    std::string data;
    Footer ftr;
};

Answer 1

        std::string serData;
        memcpy(&serData, buffer, sizeof(inHdr.dataSize));

A std::string is just an ordinary class. A very typical std::string looks like:

class string {
   char *buffer;
   size_t size;
   size_t max_size;
};

That's a capsule summary of what a std::string , more or less. Actual details vary, but this is what it is, in so many words. Hopefully this makes it clear why scribbling over these pointers and data, with what's effectively random junk, is not going to accomplish anything useful, and guarantees a crash.

The correct way to do this would be:

1. Use std::string 's resize() method to resize the size of the string's data.

2. With C++17 you can use its data() method to get a pointer to the string's internal buffer. With earlier C++ standard getting the address of the first character in the string, &serData[0] , will do the trick.

3. And finally, now, after all this work, you actually have a valid buffer to memcpy() your data into.

But an even better approach is to forget memcpy and construct std::string with the data in the first place, using its constructor:

std::string serData{buffer, buffer+inHdr.dataSize};

That's it.