¿Cómo encontrar el estado de conexión del socket en C?

Tengo una conexión TCP. El servidor solo lee los datos del cliente. Ahora, si se pierde la conexión, el cliente obtendrá un error mientras escribe los datos en la tubería (tubería rota), pero el servidor aún escucha en esa tubería. ¿Hay alguna manera de encontrar si la conexión está ACTIVA o NO?

Podría llamar a getsockopt de la siguiente manera:

int error = 0;
socklen_t len = sizeof (error);
int retval = getsockopt (socket_fd, SOL_SOCKET, SO_ERROR, &error, &len);

Para probar si el enchufe está arriba:

if (retval != 0) {
    /* there was a problem getting the error code */
    fprintf(stderr, "error getting socket error code: %s\n", strerror(retval));
    return;
}

if (error != 0) {
    /* socket has a non zero error status */
    fprintf(stderr, "socket error: %s\n", strerror(error));
}

La única forma de detectar de manera confiable si un enchufe aún está conectado es intentar enviar datos periódicamente. Por lo general, es más conveniente definir un paquete ‘ping’ de nivel de aplicación que los clientes ignoren, pero si el protocolo ya está especificado sin tal capacidad, debería poder configurar los sockets tcp para hacer esto configurando el SO_KEEPALIVE opción de enchufe. Me he vinculado a la documentación de winsock, pero la misma funcionalidad debería estar disponible en todas las pilas de sockets similares a BSD.

La opción de socket TCP keepalive (SO_KEEPALIVE) ayudaría en este escenario y cerraría el socket del servidor en caso de pérdida de conexión.

Hay una manera fácil de verificar el estado de la conexión del socket a través de poll llamada. Primero, debe sondear el socket, ya sea que tenga POLLIN evento.

1. Si el socket no está cerrado y hay datos para leer, entonces read devolverá más de cero.
2. Si no hay datos nuevos en el socket, entonces POLLIN se establecerá en 0 en revents
3. Si el enchufe está cerrado, entonces POLLIN la bandera se establecerá en uno y la lectura devolverá 0.

Aquí hay un pequeño fragmento de código:

int client_socket_1, client_socket_2;
if ((client_socket_1 = accept(listen_socket, NULL, NULL)) < 0)
{
    perror("Unable to accept s1");
    abort();
}
if ((client_socket_2 = accept(listen_socket, NULL, NULL)) < 0)
{
    perror("Unable to accept s2");
    abort();
}
pollfd pfd[]={{client_socket_1,POLLIN,0},{client_socket_2,POLLIN,0}};
char sock_buf[1024]; 
while (true)
{
    poll(pfd,2,5);
    if (pfd[0].revents & POLLIN)
    {
        int sock_readden = read(client_socket_1, sock_buf, sizeof(sock_buf));
        if (sock_readden == 0)
            break;
        if (sock_readden > 0)
            write(client_socket_2, sock_buf, sock_readden);
    }
    if (pfd[1].revents & POLLIN)
    {
        int sock_readden = read(client_socket_2, sock_buf, sizeof(sock_buf));
        if (sock_readden == 0)
            break;
        if (sock_readden > 0)
            write(client_socket_1, sock_buf, sock_readden);
    }
}

Tuve un problema similar. Quería saber si el servidor está conectado al cliente o el cliente está conectado al servidor. En tales circunstancias, el valor de retorno de la función recv puede resultar útil. Si el socket no está conectado, devolverá 0 bytes. Por lo tanto, al usar esto, rompí el ciclo y no tuve que usar ningún hilo adicional de funciones. También puede usar este mismo si los expertos consideran que este es el método correcto.

Muy simple, como se muestra en la imagen. recibir.

Para verificar que querrá leer 1 byte del socket con MSG_PEEK y MSG_DONT_WAIT. Esto no eliminará los datos (PEEK) y la operación es sin bloqueo (DONT_WAIT)

while (recv(client->socket,NULL,1, MSG_PEEK | MSG_DONTWAIT) != 0) {
    sleep(rand() % 2); // Sleep for a bit to avoid spam
    fflush(stdin);
    printf("I am alive: %d\n", socket);
}

// When the client has disconnected, this line will execute
printf("Client %d went away :(\n", client->socket);

encontre el ejemplo aquí.

get sock opt puede ser algo útil, sin embargo, otra forma sería tener un controlador de señal instalado para SIGPIPE. Básicamente, cada vez que se rompe la conexión del socket, el kernel enviará una señal SIGPIPE al proceso y luego podrá hacer lo necesario. Pero esto todavía no proporciona la solución para conocer el estado de la conexión. espero que esto ayude.