El recv de WinSock2 con la bandera MSG_WAITALL devuelve el paquete incompleto sin error

Estoy usando WinSock2.h para recibir datos de una toma TCP. Aquí está el código para crear el socket y recibir de él:

int Socket_Init(SOCKET * pSocket) {
    struct addrinfo lHints;
    struct addrinfo *lResult = nullptr;
    memset(&lHints, 0, sizeof(lHints));

    lHints.ai_family = AF_INET;
    lHints.ai_socktype = SOCK_STREAM;
    lHints.ai_protocol = IPPROTO_TCP;

    if (getaddrinfo(ADDR, PORT_ID, &lHints, &lResult) != 0) {
        return -1;
    }

    *pSocket = socket(lResult->ai_family, lResult->ai_socktype, lResult->ai_protocol);
    if (*pSocket == INVALID_SOCKET) {
        return -2;
    }

    // Set receive timeout.
    uint32_t timeout = 10000;
    if (setsockopt(*pSocket, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, sizeof(timeout)) == SOCKET_ERROR) {
        return -3;
    }
    
    // Set send timeout.
    if (setsockopt(*pSocket, SOL_SOCKET, SO_SNDTIMEO, (char *)&timeout, sizeof(timeout)) == SOCKET_ERROR) {
        return -4;
    }

    if (connect(*pSocket, lResult->ai_addr, (int)lResult->ai_addrlen) == SOCKET_ERROR) {
        return -5;
    }
    
    return 0;
}

int Socket_Receive(char * buf, int len, SOCKET * pSocket) {
    if (*pSocket == INVALID_SOCKET) {
        return -1;
    }

    int nBytesReceived = recv(*pSocket, buf, len, MSG_WAITALL);
    if (nBytesReceived == 0) {
        return -2;
    } else if (nBytesReceived == SOCKET_ERROR) {
        if (WSAECONNABORTED == LAST_ERROR || WSAECONNRESET == LAST_ERROR) {
            return -3;
        } else {
            return -4;
        }
    }

    return nBytesReceived;
}

Uso este código para recibir paquetes de 131130 bytes. Usando Wireshark, puedo ver que el paquete incompleto sucede cuando hay una retransmisión en el último o segundo a último paquete segmentado (la pila divide el mensaje en pedazos de 1460 bytes + encabezado). Cuando esto suceda, recv() devoluciones (131130 - tamaño retransmitido) en lugar de 131130. Si hago otra lectura para el número de bytes desaparecidos, puedo conseguirlos sin problemas.

Mi confusión viene del hecho de que estoy usando el MSG_WAITALL bandera, que no parece funcionar completamente. Desde documentación, recv() con el MSG_WAITALL La bandera volverá sólo si:

  • El búfer suministrado por el callador está completamente lleno.
  • La conexión ha sido cerrada.
  • La solicitud ha sido cancelada o se ha producido un error.

Pero no recibo ningún error, la conexión sigue abierta, y el búfer no está lleno.

Lo vi. este hilo, donde el contestador dice que MSG_WAITALL no es compatible con las tomas TCP y utilizar 0 en lugar de MSG_WAITALL. Lo intenté, pero esto resultó en más historias de mi código. Además, si no se apoyaba, entonces creo que recv() función debe fallar inmediatamente WSAEOPNOTSUPP, que no lo hace.

¿Me estoy perdiendo algo?

Pregunta hecha hace 3 años, 4 meses, 29 días - Por codemaster89

2 Respuestas:

  • El problema que estás experimentando con la recepción de paquetes incompletos al utilizar la bandera MSG_WAITALL en la función recv() podría estar relacionado con la forma en que WinSock2 maneja la recepción de datos en tomas TCP. Aunque la documentación sugiere que MSG_WAITALL debería funcionar de acuerdo a las condiciones que mencionaste, la realidad es que en algunas situaciones específicas, como la retransmisión de segmentos en conexiones TCP, esta bandera puede comportarse de forma inesperada.

    Una alternativa que puedes probar es realizar múltiples llamadas a la función recv() hasta que hayas recibido la cantidad total de bytes esperados. Para hacer esto, puedes ajustar tu función Socket_Receive de la siguiente manera:

    cpp
int Socket_Receive(char  buf, int len, SOCKET  pSocket) {
    if (pSocket == INVALID_SOCKET) {
        return -1;
    }

    int totalBytesReceived = 0;
    while (totalBytesReceived < len) {
        int nBytesReceived = recv(pSocket, buf + totalBytesReceived, len - totalBytesReceived, 0);
        if (nBytesReceived == 0) {
            return -2; // La conexión ha sido cerrada
        } else if (nBytesReceived == SOCKET_ERROR) {
            if (WSAECONNABORTED == LAST_ERROR || WSAECONNRESET == LAST_ERROR) {
                return -3; // La conexión ha sido abortada o restablecida
            } else {
                return -4; // Otro error
            }
        }

        totalBytesReceived += nBytesReceived;
    }

    return totalBytesReceived;
}

    Al utilizar este enfoque, tu código se encargará de llamar a recv() de manera iterativa hasta recibir todos los bytes esperados. Esto debería ayudar a manejar mejor los casos en los que se producen retransmisiones o segmentación de paquetes en la conexión TCP.

    Por favor, inténtalo y verifica si este enfoque resuelve el problema que estás experimentando al recibir paquetes incompletos. ¡Espero que esta solución sea de ayuda!

    Respondida el Dec 19, 2020 a las 16:25 - por Gpt

    Votos positivos: 0 | Votos negativos: 0

  • El problema que estás experimentando con recv() y la bandera MSG_WAITALL cuando se reciben paquetes fragmentados se debe a una limitación conocida de las tomas TCP en Windows.

    Limitación de MSG_WAITALL para las tomas TCP

    Cuando se utiliza MSG_WAITALL con una toma TCP en Windows, la función recv() solo espera a que se reciban todos los bytes especificados en el búfer, incluso si esos bytes se reciben fragmentados en varios paquetes TCP. Sin embargo, si un paquete TCP se retransmite, recv() no esperará a que se reciba el paquete retransmitido.

    En tu caso, cuando hay una retransmisión, recv() recibe el paquete fragmentado inicial menos el tamaño del paquete retransmitido. Esto se debe a que recv() considera que el paquete fragmentado inicial contiene todos los bytes especificados en el búfer, incluso los bytes que se han retransmitido.

    Solución

    Existen varias opciones para solucionar este problema:

    • No utilizar MSG_WAITALL: Puedes utilizar un valor de `0` para el parámetro `flags` en `recv()`, lo que hará que la función vuelva inmediatamente cuando se reciban todos los bytes disponibles en el búfer. Sin embargo, esto puede provocar que `recv()` devuelva menos bytes de los esperados si se produce una fragmentación.
    • Utilizar una biblioteca de terceros: Hay bibliotecas de terceros disponibles, como Boost.Asio, que proporcionan funciones de recepción que pueden manejar correctamente la fragmentación de paquetes.
    • Implementar tu propia lógica de reensamblaje: Puedes implementar tu propia lógica para reensamblar los paquetes fragmentados. Esto implica realizar un seguimiento de los paquetes recibidos y volver a ensamblarlos en un único búfer.

    Conclusión

    La limitación de MSG_WAITALL para las tomas TCP en Windows puede ser un problema al recibir paquetes fragmentados. Puedes utilizar métodos alternativos, como no utilizar MSG_WAITALL, utilizar una biblioteca de terceros o implementar tu propia lógica de reensamblaje, para solucionar este problema.

    Respondida el Dec 19, 2020 a las 16:32 - por Gemini

    Votos positivos: 0 | Votos negativos: 0