C++ websocket server handling message fragmentation - c++

Question

I am trying to send images through websocket from one javascript/html client to another. The problem is that the server is incorrectly receiving the image. I am sending all the images as data URI's in text so that when the javascript client receives it, it can just simply set the src of the img to the URI. The problem (I believe) comes from how I am handling message fragmentation. Sending simple text messages work fine so I led to believe its the size of the message that's causing issues, and the only main code difference is how I handle message fragmentation. From this documentation, I am led to believe that all that must be done is to unmask the payload of each fragmented frame and concatenate the buffers together. The URI read on the server is sufficiently shorter than the actual data URI of the image. On the client end all I am doing is calling the socket.send() function. I have confirmed that the data URI I read in the javascript FileReader is correct (on the client side).
int wSock::readData(/*input socket data buffer*/ char ** sockp, /*output payload*/ char ** buffer, /*output payload info*/ WebSocketFrameData * data) {
char * sock = *sockp;
if (!webSocketIsOpened(sock)) return -32; //checks if the socket is open
u_long package_size;
SOCKET socket;
size_t dataRead = 0;
size_t dr = 0;
size_t firstLength = 0;
memcpy_s(&socket, 4, sock, 4);
ioctlsocket(socket, FIONREAD, &package_size);
if (package_size <= 0) return 1;
char * buf = new char[package_size + 1];
while (dataRead < package_size) {
dr = recv(socket, buf + dataRead, package_size - dataRead, NULL);
if (dr == SOCKET_ERROR) {
delete[] buf;
return WSAGetLastError();
}
dataRead += dr;
}
*(buf + package_size) = '\0';
if (package_size > 0) {
decodeFrame(buf, buffer, &firstLength);
if (data != NULL) {
data->payloadLength = firstLength;
data->opcode = *buf & 0b00001111;
}
}
else return 1;
// code handling other opcodes such as a close frame or a ping
char fin = (*buf) >> 7;
if (!fin) { //start handling message fragmentation
printf("Fragmentation! \n");
FD_SET tempRead;
size_t totalLength = firstLength -1; //firstLength includes the null terminator
char * combinedPayloads = new char[totalLength];
memcpy_s(combinedPayloads, totalLength, *buffer, totalLength);
printf("First frage of size: %u \n", totalLength);
while (fin != 1) {
FD_ZERO(&tempRead);
FD_SET(socket, &tempRead);
select(0, &tempRead, NULL, NULL, NULL);
package_size = 0;
ioctlsocket(socket, FIONREAD, &package_size);
printf("Reading next frag of size: %u \n", package_size);
char * contBuf = new char[package_size];
dataRead = 0;
while (dataRead < package_size) {
dr = recv(socket, contBuf + dataRead, package_size - dataRead, NULL);
if (dr == SOCKET_ERROR) {
delete[] contBuf;
return WSAGetLastError();
}
dataRead += dr;
}
char * payload;
size_t payloadLength = 0;
decodeFrame(contBuf, &payload, &payloadLength);
payloadLength--; //the output payloadLength from the decodeFrame function includes a null terminator
char * backBuffer = new char[totalLength];
memcpy_s(backBuffer, totalLength, combinedPayloads, totalLength);
delete[] combinedPayloads;
combinedPayloads = new char[totalLength + payloadLength];
memcpy_s(combinedPayloads, totalLength, backBuffer, totalLength);
memcpy_s(combinedPayloads + totalLength, payloadLength, payload, payloadLength);
fin = contBuf[0] >> 7;
totalLength += payloadLength;
delete[] backBuffer;
delete[] contBuf;
delete[] payload;
if (fin) break;
}
delete[] *buffer;
*buffer = new char[totalLength + 1];
memcpy_s(*buffer, totalLength, combinedPayloads, totalLength);
(*buffer)[totalLength] = '\0';
delete[] combinedPayloads;
data->payloadLength = totalLength;
printf("Finished fragment! Total size: %u \n", totalLength);
}
delete[] buf;
return 0;
}
And this is the code for decoding each websocket frame. As I mentioned the server works fine for smaller chat messages so I assume the problem is the message re-assembling but I will include the decodeFrame function with hopes that it well help understanding.
int wSock::decodeFrame(char * message, char ** output, size_t * payloadLength)
{
char read;
memcpy_s(&read, 1, message + 1, 1);
unsigned long long size = read & 0b01111111;
//takes bits 9 - 15;
int lastByte = 2;
if (size == 126) {
unsigned short rr;
memcpy_s(&rr, 2, message + 2, 2);
size = ntohs(rr);
lastByte = 4;
}
else if (size == 127) {
unsigned long long data;
memcpy_s(&data, 8, message + 2, 8);
size = ntohll(data);
lastByte = 10;
}
if(payloadLength != NULL)
*payloadLength = size + 1;
char mask[4];
memcpy_s(mask, 4, message + lastByte, 4);
*output = new char[(size + 1)];
lastByte += 4;
for (int i = 0; i < size; i++) {
(*output)[i] = message[lastByte + i] ^ mask.mask[i % 4];
}
(*output)[size] = '\0';
return 0;
}
On the server side for debugging, I took the read message and wrote it into a text file. However, the URI that was written is only about 4,000 - 6,000 characters long and the last 200 - 400 characters are not valid base64 characters, however the characters before these invalid characters do match their corresponding characters on the real data URI. The printf statement during the re-assembling process will tend to read about 262,368 bytes (total) while the actual URI is 389,906 characters long. After reading the URI the server sends it to the clients, which causes them to disconnect. So as I mentioned my guess is that something is going wrong when I'm re-assembling the data frames. Any help will be appreciated.

Answer 1

ioctlsocket(socket, FIONREAD, &package_size);
FIONREAD returns the number of bytes that can be read without blocking. This means that the recv() loop following this line of code is completely futile One recv() will read that amount of data. It can't not.
You are also not handling end of stream correctly (recv() returns zero).

Answer 2

OK, I figured it out. What I forgot to account for was TCP message fragmentation. As #EJP mentioned, ioctlsocket returns only the amount of bytes that can be read in one single recv() call. I was treating each fragment of data received as its own WebSocket frame while that wasn't always the case. Often times (almost all the time) the single recv() call would only read a partial frame, and the next part of the first frame would be read with the first part of the second frame at the second recv() call. Then the second buffer (which is now a mix of two different incomplete frames) would obviously not be demasked properly and the decoded size would be incorrect. The javascript client was fragmenting each WebSocket frame at around 131K bytes and the underlying TCP layer would fragment those frames further into around 65K byte packets. So what I did is I received all the data I could in a single recv() call, and then use a function along the lines of:
unsigned long long wSock::decodeTotalFrameSize(char * frame)
{
char secondByte = 0;
memcpy_s(&secondByte, 1, frame + 1, 1);
unsigned long long size = secondByte & 0b01111111;
int headerSize = 2 + 4;
if (size == 126) {
unsigned short length;
memcpy_s(&length, 2, frame + 2, 2);
size = ntohs(length);
headerSize += 2;
}
else if (size == 127) {
unsigned long long length;
memcpy_s(&length, 8, frame + 2, 8);
size = ntohll(length);
headerSize += 8;
}
return size + headerSize;
}
to get the total WebSocket frame size. Then loop until you read that amount of bytes into a single frame. Something similar to:
FD_ZERO(&tempRead);
FD_SET(socket, &tempRead);
select(0, &tempRead, NULL, NULL, NULL);
package_size = 0;
ioctlsocket(socket, FIONREAD, &package_size);
char * contBuf = new char[package_size];
dataRead = 0;
dr = recv(socket, contBuf, package_size, NULL);
if (dr == SOCKET_ERROR) {
delete[] contBuf;
return WSAGetLastError();
}
unsigned long long actualSize = decodeTotalFrameSize(contBuf);
if (package_size < actualSize) {
char * backBuffer = new char[package_size];
memcpy_s(backBuffer, package_size, contBuf, package_size);
delete[] contBuf;
contBuf = new char[actualSize];
memcpy_s(contBuf, actualSize, backBuffer, package_size);
delete[] backBuffer;
dataRead = package_size;
dr = 0;
while (dataRead < actualSize) {
dr = recv(socket, contBuf + dataRead, actualSize - dataRead, NULL);
if (dr == SOCKET_ERROR) {
delete[] contBuf;
return WSAGetLastError();
}
else if (dr == 0) break;
dataRead += dr;
}
printf("Read total frag of %u \n", dataRead);
}