Блог

В UDP одно send() из них является полным «сообщением», вы не можете разделить «сообщение» на несколько send() s.

Но TCP-это поток байтов, поэтому вы можете совершать несколько последовательных вызовов для send() каждого «сообщения». Итак, просто отправьте длину данных в одном send() , а затем отправьте данные в другом send() . TCP гарантирует, что байты будут получены в том же порядке, в котором они были отправлены. Вам вообще не нужно добавлять байты длины к std::string самому себе.

Это работает особенно хорошо, если включена функция «Отправка сращивания» (она же алгоритм Нэгла), которая обычно используется по умолчанию. Это позволяет стеку сокетов буферизировать исходящие данные, чтобы он мог более эффективно отправлять пакеты по сети. Но даже если Нэгл отключен, эта схема все равно будет работать.

На самом деле, в TCP нет никакой гарантии, что send() он примет все запрошенные байты за один раз, поэтому вы все равно должны быть готовы звонить send() несколько раз.

Попробуйте что-нибудь вроде этого:

 bool sendRaw(int sock, const void *data, size_t len)
{
    const char *pdata = static_cast<const char*>(data);
    while (len > 0)
    {
        int numSent = send(sock, pdata, len, 0);
        if (numSent < 0) return false; // or throw...
        pdata  = numSent;
        len -= numSent;
    }
    return true;
}

bool sendUint16(int sock, uint16_t value)
{
    value = htons(value);
    return sendRaw(sock, amp;value, sizeof(value));
}

bool sendString(int sock, const std::string amp;s)
{
    if (s.size() > 0xFFFF) return false; // or throw...
    uint16_t len = static_cast<uint16_t>(s.size());
    bool ok = sendUint16(sock, len);
    if (ok) ok = sendRaw(sock, s.c_str(), len);
    return ok;
}
 

 std::string udpData = ...;
bool ok = sendString(sock, udpData);
...
 

И тогда вы можете просто повернуть процесс вспять на принимающей стороне, например:

 int recvRaw(int sock, void *data, size_t len)
{
    char *pdata = static_cast<char*>(data);
    while (len > 0)
    {
        int numRecvd = recv(sock, pdata, len, 0);
        if (numRecvd <= 0) return numRecvd; // or throw...
        pdata  = numRecvd;
        len -= numRecvd;
    }
    return 1;
}

int recvUint16(int sock, uint16_t amp;value)
{
    int ret = recvRaw(sock, amp;value, sizeof(value));
    value = (ret == 1) ? ntohs(value) : 0;
    return ret;
}

int recvString(int sock, std::string amp;s)
{
    s.clear();
    uint16_t len;
    int ret = recvUint16(sock, len);
    if ((ret == 1) amp;amp; (len > 0)) {
        s.resize(len);
        ret = recvRaw(sock, s.data()/*amp;s[0]*/, len);
    }
    return ret;
}
 

 std::string udpData;
int ret = recvString(sock, udpData);
...
 

Вероятно, не конец света, чтобы просто сделать это прямо перед отправкой. Выделение временного буфера из стека для пакета UDP (который в любом случае не будет больше 64 КБ) — при условии, что синхронная отправка сокета будет быстрой.

 unsigned char buffer[LONGEST_STRING_LENGTH 2];
size_t len = str.size();
// assert(len <= LONGEST_STRING_LENGTH);
uint16_t lenNBO = (uint16_t)len;
lenNBO = htons(lenNBO);
memcpy(buffer, amp;lenNBO, 2);
memcpy(buffer 2, str.c_str(), len);
send(sock, buffer, len 2, 0);
 

Используете ли вы какую-либо оболочку (C ) для сокетов? В противном случае просто предварительно заполните строку, в которую вы получаете данные, двумя произвольными байтами, а затем добавьте данные, полученные из сокета. После этого запишите длину строки в первые два смещения (минус два).

Что-то вроде

 string x("xx");
// receive your data into x, starting at offset 2
x[0] = (x.length() - 2) amp; 0xff;
x[1] = ((x.length() - 2) amp; 0xff00) >> 8;
// send ...
 

В зависимости от того, какой конец вы хотите, переключите назначение 0 и 1. Приведенный выше код записывает его как little endian. Порядок байтов в сети считается большим конечным.

Но tbh., если вы используете API сокетов напрямую, я бы использовал простой массив символов вместо std::string .