Receiving random data

[rotenKleber]

While trying to send map tiles from a server to a client, I noticed that there were other values interspersed throughout the packet that really should not be there.
The data at the top is the map that should be sent. The data near the bottom is the data that was received. I have highlighted some of the anomalies



To clarify a bit, I am trying to load the entire map onto a single packet, with this bit here

(click to show/hide)

// sending client map data
sf::Packet data;

// sending command (map data)
sf::Uint8 cmd = 0;
data << cmd;

// sending map size
sf::Uint8 size = server->map.size();
data << size;

// sending tiles
for (unsigned int x = 0; x < server->map.size(); x++) {
        for (unsigned int y = 0; y < server->map[y].size(); y++) {
                sf::Uint8 type = (int) server->map[x][y];
                data << type;
        }
}

When pulling out the code, I just do the opposite, extract the "code" telling the client what to do with the info, grab the size of the map, then load all the tiles sent into the map. The issue occurs when there are numbers in the received data that shouldn't be in there, as seen in the image.

Has anyone else experienced this? Does anyone know what this data is / how it gets into the packet or received / how to remove it or prevent it?

[Laurent]

You should print the raw content of the packet right before sending it, and right after receiving it. That would help to figure out if the data gets corrupted before sending, during transmission, or after receiving.

[rotenKleber]

Thanks for the reply! I appreciate your work, by the way.

How would I print the raw data of the packet without disassembling it?

I tried using Packet::get_data(), but I'm not sure what to cast the void pointer to. I tried this with strange results:

std::printf("Data before sending: %d\n", *(reinterpret_cast<const long long*>(data.getData())));

The output being

Code: [Select]

73728
But that const long long* was a wild guess and it changes drastically depending on what I cast it to, not sure if that's the best indicator. Either way, I figured out that the error is occurring when attempting to pull the tiles out of the packet with

for (unsigned int x = 0; x < size; x++) {
    for (unsigned int y = 0; y < size; y++) {
         sf::Uint8 type;

         data >> type;

         printf("Type: %d\n", type);

         map[x][y] = (tile) ((int)type);
     }
}
 

[FRex]

Cast the pointer to unsigned char pointer and iterate through it and print the bytes as hex numbers. Something like:

void printdata(const void * data, int len)
{
        const unsigned char * ptr = reinterpret_cast<const unsigned char*>(data);
        for(int i = 0; i < len; ++i)
                std::printf("%02x ", ptr[i]);
 
        std::printf("\n");
}