Configuration de TCP keepalive après l'accepter

Après la accept() sur un socket, je suis en train de configurer le TCP keepalive.

SockConnected = accept(SockListen, &RemoteAddr,
                   &RemoteLen);
/* A bit of checking goes here */
if (setsockopt (SockConnected , SOL_SOCKET, SO_KEEPALIVE,
                            (ST_CHAR *) &sockopt_on, sizeof (int) ) )
{
   /* Error logging */
}

if (setsockopt(SockConnected , IPPROTO_TCP, TCP_KEEPIDLE, (char*)&(sockopt_tcp_keep_idle), sizeof(sockopt_tcp_keep_idle)))
{
    /* Error logging */
}
if (setsockopt(SockConnected, IPPROTO_TCP, TCP_KEEPINTVL, (char*)&(sockopt_tcp_keep_intvl), sizeof(sockopt_tcp_keep_intvl)))
{
    /* Error logging */
}
if (setsockopt(SockConnected, IPPROTO_TCP, TCP_KEEPCNT, (char*)&(sockopt_tcp_keep_cnt), sizeof(sockopt_tcp_keep_cnt)))
{
    /* Error logging */
}

Après l'appel de getsockopt() pour tous les quatre propriétés, tout semble correct. J'ai vérifié dans Wireshark et il n'existe pas de Garder en vie les paquets envoyés. J'ai dû changer SOL_TCP à IPPROTO_TCP, car lors de l'appel de setsockopt() pour TCP_KEEPIDLE il était de retour errno 92 (Protocole non trouvé).

Je suis en train de faire la même chose après l'appel de socket() pour une connexion sortante, et il fonctionne parfaitement.

Je suis à l'aide de C et Linux.

Est-il une raison pourquoi setsockopt peut ne pas fonctionner après l'accepter?

Les valeurs de la configuration ne peut pas être les valeurs réelles utilisées. La plate-forme possible de les modifier. Utilisation getsockopt() de savoir quelles valeurs sont effectivement utilisés, et de voir si ce qui se passe est d'accord avec ça. NB je crois que vous pouvez faire tout cela à la fois, sur la socket d'écoute, d'où il sera héritée par tous les sockets.
Je l'ai essayé sur la socket d'écoute trop, avec pas de chance. Je vais doubler vérifier les valeurs de retour de getsockopt(). Merci!

OriginalL'auteur Arapajoe | 2015-07-15

  1. 7

    Ici est un travail minimale exemple. Si cela fonctionne pour vous, vous pouvez l'utiliser comme une référence.

    #include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/signal.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#define check(expr) if (!(expr)) { perror(#expr); kill(0, SIGTERM); }
void enable_keepalive(int sock) {
int yes = 1;
check(setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, &yes, sizeof(int)) != -1);
int idle = 1;
check(setsockopt(sock, IPPROTO_TCP, TCP_KEEPIDLE, &idle, sizeof(int)) != -1);
int interval = 1;
check(setsockopt(sock, IPPROTO_TCP, TCP_KEEPINTVL, &interval, sizeof(int)) != -1);
int maxpkt = 10;
check(setsockopt(sock, IPPROTO_TCP, TCP_KEEPCNT, &maxpkt, sizeof(int)) != -1);
}
int main(int argc, char** argv) {
check(argc == 2);
struct sockaddr_in addr;
addr.sin_family = AF_INET;
addr.sin_port = htons(12345);
check(inet_pton(AF_INET, argv[1], &addr.sin_addr) != -1);
int server = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
check(server != -1);
int yes = 1;
check(setsockopt(server, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) != -1);
check(bind(server, (struct sockaddr*)&addr, sizeof(addr)) != -1);
check(listen(server, 1) != -1);
if (fork() == 0) {
int client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
check(client != -1);
check(connect(client, (struct sockaddr*)&addr, sizeof(addr)) != -1);
printf("connected\n");
pause();
}
else {
int client = accept(server, NULL, NULL);
check(client != -1);
enable_keepalive(client);
printf("accepted\n");
wait(NULL);
}
return 0;
}

    Exemple de sortie (tcpdump rapports persistantes paquets à chaque seconde):

    $ ./a.out 127.0.0.1 &
[1] 14010
connected
accepted
$ tcpdump -n -c4 -ilo port 12345
dropped privs to tcpdump
tcpdump: verbose output suppressed, use -v or -vv for full protocol decode
listening on lo, link-type EN10MB (Ethernet), capture size 262144 bytes
18:00:35.173892 IP 127.0.0.1.12345 > 127.0.0.1.60998: Flags [.], ack 510307430, win 342, options [nop,nop,TS val 389745775 ecr 389745675], length 0
18:00:35.173903 IP 127.0.0.1.60998 > 127.0.0.1.12345: Flags [.], ack 1, win 342, options [nop,nop,TS val 389745775 ecr 389745075], length 0
18:00:36.173886 IP 127.0.0.1.12345 > 127.0.0.1.60998: Flags [.], ack 1, win 342, options [nop,nop,TS val 389745875 ecr 389745775], length 0
18:00:36.173898 IP 127.0.0.1.60998 > 127.0.0.1.12345: Flags [.], ack 1, win 342, options [nop,nop,TS val 389745875 ecr 389745075], length 0
4 packets captured
8 packets received by filter
0 packets dropped by kernel
    Merci!!!! J'étais la configuration de tout ce qui est avant le listen() et après la accept(). Si je le fais juste après accept(), keepalive il est activé.

    OriginalL'auteur gavv

  2. 5

    SO_KEEPALIVE doit être utilisé avec SOL_SOCKET, pas IPPROTO_TCP ou SOL_TCP. Voir socket(7) et tcp(7).

    Donc, essayez ceci:

    int val = 1;
setsockopt(SockConnected, SOL_SOCKET, SO_KEEPALIVE, &val, sizeof(val));

    Je suppose que TCP_KEEPIDLE et des options similaires sont tout simplement ignorées si SO_KEEPALIVE n'a pas été réglé correctement, et SOL_TCP est synonyme de IPPROTO_TCP.

    Si cela n'aide pas, pensez à publier un exemple minimal qui reproduit le problème.

    Je vous remercie pour cette. Il s'avère que c'était une faute de frappe lors de l'ouverture de la question ici. J'ai vérifié mon code, et comme vous le dites, SOL_SOCKET est utilisé avec SO_KEEPALIVE.
    Bien, alors je n'ai pas d'idées. Je suggère de commencer à partir de l'exemple minimal qui reproduit votre programme et d'en faire la vérification des erreurs pour tous les appels système, afin que d'autres puissent l'essayer et de vous aider. Je vais poster un exemple minimal qui fonctionne pour moi dans un moment.
    faute de frappe: programme -> problème

    OriginalL'auteur gavv