Send length and data through socket c++

Question

So i'm currently working on a app that uses socket, for now everything is working, i just want to know if there is a more efficient way to send the length of the data and the data instead of sending twice.

i.e: Sending everything in one string.

void SendPackage(const SOCKET sock, const std::string package)
{
    int length = package.lenth();

    send(sock, std::to_string(length).c_str(), 10, 0);     //Buffer length is 10 assuming data length
    send(sock, package.c_str(), length, 0);        //will never be greater than 9,999,999,999
}

void ReceivePackage(const SOCKET sock, std::string &package, int bufferLength)
{
    std::vector<char> recvBuffer(10);
    int length, bytesProcessed;

    recv(sock, &recvBuffer[0], 10, 0); //Receiving length
    length = atoi(&recvBuffer[0]);
    recvBuffer.resize(length);

    for (int i = 0; i < length; i += bytesProcessed)
    {
        bytesProcessed = recv(sock, &recvBuffer[0] + i, bufferLength, 0);
        if (bytesProcessed < 0) break;
    }

    package = &recvBuffer[0];
}

Answer 1

send(sock, std::to_string(length).c_str(), 10, 0);

This is UB. You are telling it that the data has 10 bytes, but that's not correct. Apart from that there is no need to convert your int into a string and then send the string. Just sent the int, and to avoid any platform incompatibilities I recommend using a fixed size type:

std::int32_t length = package.length();
send(sock, &length, sizeof(length), 0);

On the receiving end you must make sure that you actually wait for all bytes to be there. You can't simply call recv and assume it gives you all the bytes you need. You need to call it in a loop and check it's return value, which tells you how many bytes you got. To receive the length, you need to read the appropriate amount of bytes into a buffer, then reinterpret that buffer as the type you chose (e.g. std::int32_t.

Additionally you should make sure that the endianness of your int is correct. It is a de facto standard to use big-endian for network data, but at the end of the day this is up to you. Not part of the standard (afaik), but available on common platforms are the helper functions htonl and ntohl, which stand for "host to network, long" and "network to host, long". They take and return a std::int32_t, and you can simply use them to be sure the endianness works for both sides.

Sender:

std::int32_t length = htonl(package.length());
send(sock, &length, sizeof(length), 0);

Receiver:

// after successfully reading all bytes for the length value into an adequately sized buffer:
std::int32_t length = ntohl(*reinterpret_cast<std::int32_t*>(buffer));

Answer 2

As far as the socket interface is concerned, you are not sending twice. The socket just takes everything you stuff in one end with one or more send calls and sends it out in its own time (I'm assuming you don't exceed the socket buffer with the first call, which is a fairly safe assumption). Similarly, you don't need to match your recv calls with the send calls. You could recv the whole lot at once and then break it up later, but really, no big gain to do so.

So it's really a wash whether you pack the string first and then send it, or call send twice. The time and RAM necessary to create a new string with the length concatenated to the start is not going to be more efficient than just called send twice.

However, you should definitely send the length as the int it comes in, not as a string. That way it will always occupy sizeof(int) bytes. Your buffer length of 10 will usually not be true, and result in reading off the end of the string. For instance:

send(sock, &length, sizeof(length), 0);

and

recv(sock, &length, sizeof(length), 0); //Receiving length