server client sending receiving structure via raw data errors C++ - c++

Question

I am doing a sending and receiving functions for structure(in my case "frame") via TCP/IP. But the functions don't seem to work out and I cannot find where my errors are. I am asked to store all the data in a char array and send it, while receiving the char array and convert them into the structure.
struct frame {
int length;
int * body;
int tail;
};
void winsock_client::send_frame(frame f) {
char * arr;
char * tx;
int length = 8 + f.length * sizeof(int);
arr = new char[length];
tx = (char*)&f.length;
for (int i = 0; i < sizeof(int); i++) {
arr[i] = *(tx++);
}
for (int i = 0; i < f.length; i++) {
tx =(char*)&f.body[i];
for (int j = 0; j < sizeof(int); j++) {
arr[4 + i * sizeof(int) + j] = *(tx++);
}
}
tx = (char*)&f.tail;
for (int i = 0; i < sizeof(int); i++) {
arr[4 + f.length * sizeof(int) + i] = *(tx++);
}
send(client_socket, arr, sizeof(arr), 0);
}
void winsock_server::receive_frame(frame & f) {
int * rx;
recv(server_socket, rx_buffer, sizeof(rx_buffer), 0);
rx =(int *) &rx_buffer[0];
f.length = *rx;
f.body = new int[f.length];
rx = (int *)&rx_buffer[4];
for (int i = 0; i < f.length; i++) {
f.body[i] = *(rx++);
}
rx = (int*)&rx_buffer[16];
f.tail = *rx;
}
Can anyone tell me what my errors are in my functions?

Answer 1

You are not checking the return values of send() and recv() to make sure that you are actually sending/receiving everything you are expecting. TCP is a streaming transport, there is no 1:1 relationship between sends and receives, like there is in UDP. Both functions can send/receive fewer bytes than requested, so you need to handle that.
Also, your read_frame() is using a fixed-length buffer to receive data, but you aren't taking into account how much data is actually being sent, so your buffer may not receive a full frame, or worse may receive a frame that is larger than it can hold.
The code is just plain ugly to read, too. It should be be re-written.
Try something more like this instead:
bool sendAll(SOCKET s, const void *buf, int len)
{
const char *pbuf = (const char*) buf;
while (len > 0)
{
int sent = send(s, pbuf, len, 0);
if (sent == SOCKET_ERROR)
return false;
pbuf += sent;
len -= sent;
}
return true;
}
bool winsock_client::send_frame(const frame &f)
{
int size = (2 + f.length) * sizeof(u_long);
char *arr = new char[size];
// multi-byte integers should always be transmitted in network
// byte order to avoid any endian issues across machine boundaries...
u_long *ptr = (u_long*) arr;
*ptr++ = htonl(f.length);
for (int i = 0; i < f.length; ++i)
*ptr++ = htonl(f.body[i]);
*ptr = htonl(f.tail);
bool result = sendAll(client_socket, arr, size);
delete[] arr;
return result;
}
bool recvAll(SOCKET s, void *buf, int len)
{
char *pbuf = (char*) buf;
while (len > 0)
{
int recvd = recv(s, pbuf, len, 0);
if (recvd <= 0) // -1 on error, 0 on disconnect
return false;
pbuf += recvd;
len -= recvd;
}
return true;
}
bool winsock_server::receive_frame(frame &f)
{
u_long temp;
if (!recvAll(server_socket, &temp, sizeof(temp)))
return false;
f.length = ntohl(temp);
u_long *arr = new u_long[f.length+1];
if (!recvAll(server_socket, arr, sizeof(u_long) * (f.length + 1)))
{
delete[] arr;
return false;
}
f.body = new int[f.length];
for(int i = 0; i < f.length; ++i)
f.body[i] = ntohl(arr[i]);
f.tail = ntohl(arr[f.length]);
delete[] arr;
return true;
}
Alternatively, you can simplify the code a bit if you take into account that the socket already does its own internal buffering for you:
bool sendAll(SOCKET s, const void *buf, int len)
{
const char *pbuf = (const char*) buf;
while (len > 0)
{
int sent = send(s, pbuf, len, 0);
if (sent == SOCKET_ERROR)
return false;
pbuf += sent;
len -= sent;
}
return true;
}
bool sendInt(SOCKET s, int value)
{
// multi-byte integers should always be transmitted in network
// byte order to avoid any endian issues across machine boundaries...
u_long temp = htonl(value);
return sendAll(s, &temp, sizeof(temp));
}
bool winsock_client::send_frame(const frame &f)
{
if (!sendInt(client_socket, f.length))
return false;
for (int i = 0; i < f.length; ++i)
{
if (!sendInt(client_socket, f.body[i]))
return false;
}
return sendInt(client_socket, f.tail);
}
bool recvAll(SOCKET s, void *buf, int len)
{
char *pbuf = (char*) buf;
while (len > 0)
{
int recvd = recv(s, pbuf, len, 0);
if (recvd <= 0) // -1 on error, 0 on disconnect
return false;
pbuf += recvd;
len -= recvd;
}
return true;
}
bool recvInt(SOCKET s, int &value)
{
u_long temp;
bool result = recvAll(s, &temp, sizeof(temp));
if (result) value = ntohl(temp);
return result;
}
bool winsock_server::receive_frame(frame &f)
{
if (!recvInt(server_socket, f.length))
return false;
f.body = new int[f.length];
for(int i = 0; i < f.length; ++i)
{
if (!recvInt(server_socket, f.body[i]))
{
delete[] f.body;
return false;
}
}
if (!recvInt(server_socket, f.tail))
{
delete[] f.body;
return false;
}
return true;
}