Set Control Connection Keepalive also on server side (with some improvements)

Author: davidBar-On

configure

@@ -24,7 +24,7 @@
 # file for complete information.
 
 # Initialize the autoconf system for the specified tool, version and mailing list
-AC_PREREQ([2.71])
+AC_PREREQ([2.69])
 AC_INIT([iperf],[3.13],[https://github.com/esnet/iperf],[iperf],[https://software.es.net/iperf/])
 m4_include([config/ax_check_openssl.m4])
 m4_include([config/iperf_config_static_bin.m4])

configure.ac

@@ -1510,6 +1510,13 @@ iperf_parse_arguments(struct iperf_test *test, int argc, char **argv)
                         test->settings->cntl_ka_keepidle = atoi(optarg);
                     }
                 }
+                // Seems that at least in Windows WSL2, TCP keepalive retries full inteval must be
+                // smaller than the idle interval. Otherwise, the keepalive message is sent only once.
+                if (test->settings->cntl_ka_keepidle &&
+                    test->settings->cntl_ka_keepidle <= (test->settings->cntl_ka_count * test->settings->cntl_ka_interval)) {
+                        i_errno = IECNTLKA;
+                        return -1;
+                }
                 break;
 #endif /* HAVE_TCP_KEEPALIVE */
             case 'A':
@@ -3155,10 +3162,6 @@ iperf_reset_test(struct iperf_test *test)
     test->settings->tos = 0;
     test->settings->dont_fragment = 0;
     test->zerocopy = 0;
-    test->settings->cntl_ka = 0;
-    test->settings->cntl_ka_keepidle = 0;
-    test->settings->cntl_ka_interval = 0;
-    test->settings->cntl_ka_count = 0;
 
 #if defined(HAVE_SSL)
     if (test->settings->authtoken) {
@@ -4911,3 +4914,82 @@ iflush(struct iperf_test *test)
 {
     return fflush(test->outfile);
 }
+
+#if defined (HAVE_TCP_KEEPALIVE)
+// Set Control Connection TCP Keepalive (especially useful for long UDP test sessions)
+int
+iperf_set_control_keepalive(struct iperf_test *test)
+{
+    int opt, kaidle, kainterval, kacount;
+    socklen_t len;
+
+    if (test->settings->cntl_ka) {
+        // Set keepalive using system defaults
+        opt = 1;
+        if (setsockopt(test->ctrl_sck, SOL_SOCKET, SO_KEEPALIVE, (char *) &opt, sizeof(opt))) {
+            i_errno = IESETCNTLKA;
+            return -1;
+        }
+
+        // Get default values when not specified
+        if ((kaidle = test->settings->cntl_ka_keepidle) == 0) {
+            len = sizeof(kaidle);
+            if (getsockopt(test->ctrl_sck, IPPROTO_TCP, TCP_KEEPIDLE, (char *) &kaidle, &len)) {
+                i_errno = IESETCNTLKAINTERVAL;
+                return -1;
+            }
+        }
+        if ((kainterval = test->settings->cntl_ka_interval) == 0) {
+            len = sizeof(kainterval);
+            if (getsockopt(test->ctrl_sck, IPPROTO_TCP, TCP_KEEPINTVL, (char *) &kainterval, &len)) {
+                i_errno = IESETCNTLKAINTERVAL;
+                return -1;
+            }
+        }
+        if ((kacount = test->settings->cntl_ka_count) == 0) {
+            len = sizeof(kacount);
+            if (getsockopt(test->ctrl_sck, IPPROTO_TCP, TCP_KEEPCNT, (char *) &kacount, &len)) {
+                i_errno = IESETCNTLKACOUNT;
+                return -1;
+            }
+        }
+   
+        if (test->verbose) {
+            printf("Control connection TCP Keepalive TCP_KEEPIDLE/TCP_KEEPINTVL/TCP_KEEPCNT are set to %d/%d/%d\n",
+                   kaidle, kainterval, kacount);
+        }
+        
+        // Seems that at least in Windows WSL2, TCP keepalive retries full inteval must be
+        // smaller than the idle interval. Otherwise, the keepalive message is sent only once.
+        if (test->settings->cntl_ka_keepidle) {
+            if (test->settings->cntl_ka_keepidle <= (kainterval * kacount)) {
+                iperf_err(test, "Keepalive Idle time (%d) should be greater than Retries-interval (%d) times Retries-count (%d)", kaidle, kainterval, kacount);
+                i_errno = IECNTLKA;
+                return -1;
+            }
+        }
+
+        // Set keep alive values when specified
+        if ((opt = test->settings->cntl_ka_keepidle)) {
+            if (setsockopt(test->ctrl_sck, IPPROTO_TCP, TCP_KEEPIDLE, (char *) &opt, sizeof(opt))) {
+                i_errno = IESETCNTLKAKEEPIDLE;
+                return -1;
+            }
+        }
+        if ((opt = test->settings->cntl_ka_interval)) {
+            if (setsockopt(test->ctrl_sck, IPPROTO_TCP, TCP_KEEPINTVL, (char *) &opt, sizeof(opt))) {
+                i_errno = IESETCNTLKAINTERVAL;
+                return -1;
+            }
+        }
+        if ((opt = test->settings->cntl_ka_count)) {
+            if (setsockopt(test->ctrl_sck, IPPROTO_TCP, TCP_KEEPCNT, (char *) &opt, sizeof(opt))) {
+                i_errno = IESETCNTLKACOUNT;
+                return -1;
+            }
+        }
+    }
+
+    return 0;
+}
+#endif //HAVE_TCP_KEEPALIVE

src/iperf_api.c

@@ -293,6 +293,14 @@ void      iperf_free_stream(struct iperf_stream * sp);
  */
 int       iperf_common_sockopts(struct iperf_test *, int s);
 
+#if defined (HAVE_TCP_KEEPALIVE)
+/**
+ * iperf_set_control_keepalive -- set control connection TCP keepalive
+ *
+ */
+int       iperf_set_control_keepalive(struct iperf_test *test);
+#endif //HAVE_TCP_KEEPALIVE
+
 int has_tcpinfo(void);
 int has_tcpinfo_retransmits(void);
 void save_tcpinfo(struct iperf_stream *sp, struct iperf_interval_results *irp);
@@ -402,7 +410,7 @@ enum {
     IERCVTIMEOUT = 31,      // Illegal message receive timeout
     IERVRSONLYRCVTIMEOUT = 32,  // Client receive timeout is valid only in reverse mode
     IESNDTIMEOUT = 33,      // Illegal message send timeout
-    IECNTLKA = 34,          // Control connection Keepalive period should be larger than retry period (interval * count)
+    IECNTLKA = 34,          // Control connection Keepalive period should be larger than the full retry period (interval * count)
     /* Test errors */
     IENEWTEST = 100,        // Unable to create a new test (check perror)
     IEINITTEST = 101,       // Test initialization failed (check perror)

src/iperf_api.h

@@ -364,9 +364,6 @@ iperf_connect(struct iperf_test *test)
 {
     int opt;
     socklen_t len;
-#if defined(HAVE_TCP_KEEPALIVE)
-    int kainterval, kacount;
-#endif /* HAVE_TCP_KEEPALIVE */
 
     if (NULL == test)
     {
@@ -395,74 +392,9 @@ iperf_connect(struct iperf_test *test)
     }
 
 #if defined (HAVE_TCP_KEEPALIVE)
-    // Set Control Connection TCP Keepalive (especially useful for long UDP test sessions)
-    if (test->settings->cntl_ka) {
-        opt = 1;
-        if (setsockopt(test->ctrl_sck, SOL_SOCKET, SO_KEEPALIVE, (char *) &opt, sizeof(opt))) {
-            i_errno = IESETCNTLKA;
+        // Set Control Connection TCP Keepalive (especially useful for long UDP test sessions)
+        if (iperf_set_control_keepalive(test) < 0)
             return -1;
-        }
-
-        if ((opt = test->settings->cntl_ka_keepidle)) {
-            if (setsockopt(test->ctrl_sck, IPPROTO_TCP, TCP_KEEPIDLE, (char *) &opt, sizeof(opt))) {
-                i_errno = IESETCNTLKAKEEPIDLE;
-                return -1;
-            }
-        }
-
-        // Seems that at least in Windows WSL2, TCP keepalive retries inteval must be smaller
-        // than keepalive interval.  Otherwise, the keepalive message is sent only once.
-        // To make sure issues will not impact the tests in case the keepalive period was set,
-        // when possible it is made sure that the full keepalive retries interval is less
-        // than the the keepalive period.
-        if (test->settings->cntl_ka_keepidle) {
-            if ((kainterval = test->settings->cntl_ka_interval) == 0) {
-                len = sizeof(kainterval);
-                if (getsockopt(test->ctrl_sck, IPPROTO_TCP, TCP_KEEPINTVL, (char *) &kainterval, &len)) {
-                    i_errno = IESETCNTLKAINTERVAL;
-                    return -1;
-                }
-            }
-            if ((kacount = test->settings->cntl_ka_count) == 0) {
-                len = sizeof(kacount);
-                if (getsockopt(test->ctrl_sck, IPPROTO_TCP, TCP_KEEPCNT, (char *) &kacount, &len)) {
-                    i_errno = IESETCNTLKACOUNT;
-                    return -1;
-                }
-            }
-
-            if (test->settings->cntl_ka_keepidle <= (kainterval * kacount)) {
-                if (test->settings->cntl_ka_interval > 0 || test->settings->cntl_ka_count > 0) {
-                    i_errno = IECNTLKA;
-                    return -1;
-                }
-                if (kacount > 0) {
-                    test->settings->cntl_ka_interval = ((test->settings->cntl_ka_keepidle - 1) / kacount);
-                    if (test->settings->cntl_ka_interval <= 0) {
-                        test->settings->cntl_ka_interval = 1;
-                    }
-                }
-            }
-        }
-
-        if ((opt = test->settings->cntl_ka_interval)) {
-            if (setsockopt(test->ctrl_sck, IPPROTO_TCP, TCP_KEEPINTVL, (char *) &opt, sizeof(opt))) {
-                i_errno = IESETCNTLKAINTERVAL;
-                return -1;
-            }
-        }
-        if ((opt = test->settings->cntl_ka_count)) {
-            if (setsockopt(test->ctrl_sck, IPPROTO_TCP, TCP_KEEPCNT, (char *) &opt, sizeof(opt))) {
-                i_errno = IESETCNTLKACOUNT;
-                return -1;
-            }
-        }
-
-        if (test->verbose) {
-            printf("Control connection TCP Keepalive TCP_KEEPIDLE/TCP_KEEPINTVL/TCP_KEEPCNT set to %d/%d/%d (0 is system default)\n",
-                   test->settings->cntl_ka_keepidle, test->settings->cntl_ka_interval, test->settings->cntl_ka_count);
-        }
-    }
 #endif //HAVE_TCP_KEEPALIVE
 
 #if defined(HAVE_TCP_USER_TIMEOUT)

src/iperf_client_api.c

@@ -42,6 +42,9 @@
 /* Define to 1 if you have the <linux/tcp.h> header file. */
 #undef HAVE_LINUX_TCP_H
 
+/* Define to 1 if you have the <memory.h> header file. */
+#undef HAVE_MEMORY_H
+
 /* Define to 1 if you have the <netinet/sctp.h> header file. */
 #undef HAVE_NETINET_SCTP_H
 
@@ -72,9 +75,6 @@
 /* Define to 1 if you have the <stdint.h> header file. */
 #undef HAVE_STDINT_H
 
-/* Define to 1 if you have the <stdio.h> header file. */
-#undef HAVE_STDIO_H
-
 /* Define to 1 if you have the <stdlib.h> header file. */
 #undef HAVE_STDLIB_H
 
@@ -105,6 +105,9 @@
 /* Have tcpi_snd_wnd field in tcp_info. */
 #undef HAVE_TCP_INFO_SND_WND
 
+/* Have TCP_KEEPIDLE sockopt. */
+#undef HAVE_TCP_KEEPALIVE
+
 /* Have TCP_USER_TIMEOUT sockopt. */
 #undef HAVE_TCP_USER_TIMEOUT
 
@@ -135,9 +138,7 @@
 /* Define to the version of this package. */
 #undef PACKAGE_VERSION
 
-/* Define to 1 if all of the C90 standard headers exist (not just the ones
-   required in a freestanding environment). This macro is provided for
-   backward compatibility; new code need not use it. */
+/* Define to 1 if you have the ANSI C header files. */
 #undef STDC_HEADERS
 
 /* Version number of package */

src/iperf_config.h.in

@@ -463,7 +463,7 @@ iperf_strerror(int int_errno)
             perr = 1;
             break;
         case IECNTLKA:
-            snprintf(errstr, len, "control connection Keepalive period should be larger than retry period (interval * count)");
+            snprintf(errstr, len, "control connection Keepalive period should be larger than the full retry period (interval * count)");
             perr = 1;
             break;
         case IESETCNTLKA:

src/iperf_error.c

@@ -140,6 +140,12 @@ iperf_accept(struct iperf_test *test)
         }
 #endif /* HAVE_TCP_USER_TIMEOUT */
 
+#if defined (HAVE_TCP_KEEPALIVE)
+        // Set Control Connection TCP Keepalive (especially useful for long UDP test sessions)
+        if (iperf_set_control_keepalive(test) < 0)
+            return -1;
+#endif //HAVE_TCP_KEEPALIVE
+
         if (Nread(test->ctrl_sck, test->cookie, COOKIE_SIZE, Ptcp) < 0) {
             i_errno = IERECVCOOKIE;
             return -1;