Latest changes

- 1.10.1
- [BUGFIX]  process connections after each batch of packets is read
  This avoids a problem of accumulating a very large list of packets
  (possible when speeds are high and socket's receive buffer is large)
  and processing it all at once.
- If glibc is older than 2.17, link with rt.  This is necessary for
  clock_getres(2).
- Add version macros to lsquic.h; remove unnecessary includes.

CHANGELOG

@@ -1,3 +1,14 @@
+2018-07-10
+
+    - 1.10.1
+    - [BUGFIX]  process connections after each batch of packets is read
+      This avoids a problem of accumulating a very large list of packets
+      (possible when speeds are high and socket's receive buffer is large)
+      and processing it all at once.
+    - If glibc is older than 2.17, link with rt.  This is necessary for
+      clock_getres(2).
+    - Add version macros to lsquic.h; remove unnecessary includes.
+
 2018-06-13
 
     - [BUGFIX] allow multiple parallel connections by default

CMakeLists.txt

@@ -17,6 +17,14 @@ ENDIF()
 
 ENDIF()
 
+# If using older glibc, need to link with -lrt.  See clock_getres(2).
+EXECUTE_PROCESS(
+    COMMAND ${PROJECT_SOURCE_DIR}/print-glibc-version.sh ${CMAKE_C_COMPILER}
+    OUTPUT_VARIABLE GLIBC_VERSION)
+IF(NOT GLIBC_VERSION EQUAL "" AND GLIBC_VERSION VERSION_LESS 2.17)
+    SET(LIBS ${LIBS} rt)
+ENDIF()
+
 # By default, we compile in development mode.  To compile production code,
 # pass -DDEVEL_MODE=0 to cmake (before that, `make clean' and remove any
 # cmake cache files).
@@ -45,7 +53,7 @@ IF(DEVEL_MODE EQUAL 1)
     ENDIF()
     # Uncomment to enable fault injection testing via libfiu:
     #SET (MY_CMAKE_FLAGS "${MY_CMAKE_FLAGS} -DFIU_ENABLE=1")
-    #SET (FIULIB "fiu")
+    #SET(LIBS ${LIBS} fiu)
 ELSE()
     SET(MY_CMAKE_FLAGS "${MY_CMAKE_FLAGS} -O3 -g0")
     SET(MY_CMAKE_FLAGS "${MY_CMAKE_FLAGS} -DNDEBUG")
@@ -73,7 +81,7 @@ SET(MY_CMAKE_FLAGS "${MY_CMAKE_FLAGS} -W4 -WX -Zi -DWIN32_LEAN_AND_MEAN -DNOMINM
 IF(DEVEL_MODE EQUAL 1)
     SET(MY_CMAKE_FLAGS "${MY_CMAKE_FLAGS} -Od")
     #SET (MY_CMAKE_FLAGS "${MY_CMAKE_FLAGS} -DFIU_ENABLE=1")
-    #SET (FIULIB "fiu")
+    #SET(LIBS ${LIBS} fiu)
 ELSE()
     SET(MY_CMAKE_FLAGS "${MY_CMAKE_FLAGS} -Ox")
     SET(MY_CMAKE_FLAGS "${MY_CMAKE_FLAGS} -DNDEBUG")
@@ -120,7 +128,7 @@ add_executable(http_client
     test/prog.c
     test/test_common.c
 )
-target_link_libraries(http_client lsquic event pthread libssl.a libcrypto.a ${FIULIB} z m)
+target_link_libraries(http_client lsquic event pthread libssl.a libcrypto.a ${LIBS} z m)
 
 #MSVC
 ELSE()
@@ -144,11 +152,11 @@ target_link_libraries(http_client
 		optimized  ${VCPKG_BASE_DIR}/lib/zlib.lib
 		optimized  ${BORINGSSL_BASE_LIB_DIR}/ssl/release/ssl.lib
 		optimized  ${BORINGSSL_BASE_LIB_DIR}/crypto/release/crypto.lib
-		${FIULIB} )
+		${LIBS} )
 
 ENDIF()
 
-#target_link_libraries(http_client lsquic event pthread libssl.a libcrypto.a ${FIULIB} z m)
+#target_link_libraries(http_client lsquic event pthread libssl.a libcrypto.a ${LIBS} z m)
 
 add_subdirectory(src)
 

include/lsquic.h

@@ -12,20 +12,21 @@
 #include <lsquic_types.h>
 #ifndef WIN32
 #include <sys/uio.h>
-#include <sys/types.h>
 #include <time.h>
-#include <sys/queue.h>
 #else
 #include <vc_compat.h>
 #endif
 
-struct iovec;
 struct sockaddr;
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
+#define LSQUIC_MAJOR_VERSION 1
+#define LSQUIC_MINOR_VERSION 10
+#define LSQUIC_PATCH_VERSION 1
+
 /**
  * Engine flags:
  */

print-glibc-version.sh

@@ -0,0 +1,13 @@
+#!/bin/sh
+#
+# Determine glibc version and print it to stdout.  I have to resort to
+# using a shell script because it is taking too long to figure out how
+# to do this properly in cmake.
+
+CC=$1
+if [ "" = "$CC" ]; then
+    CC=gcc
+fi
+
+$CC -print-file-name=libc.so.6 \
+    | perl -plne '$_ = readlink if -H; s/\.so$// && s/.*-//'

test/prog.h

@@ -35,19 +35,13 @@ void
 prog_init (struct prog *, unsigned lsquic_engine_flags, struct sport_head *,
                     const struct lsquic_stream_if *, void *stream_if_ctx);
 
-#if HAVE_SENDMMSG
-#   define SENDMMSG_FLAG "g"
-#else
-#   define SENDMMSG_FLAG ""
-#endif
-
 #if LSQUIC_DONTFRAG_SUPPORTED
 #   define IP_DONTFRAG_FLAG "D"
 #else
 #   define IP_DONTFRAG_FLAG ""
 #endif
 
-#define PROG_OPTS "m:c:y:L:l:o:H:s:S:Y:z:" SENDMMSG_FLAG IP_DONTFRAG_FLAG
+#define PROG_OPTS "m:c:y:L:l:o:H:s:S:Y:z:" IP_DONTFRAG_FLAG
 
 /* Returns:
  *  0   Applied

test/test_common.c

@@ -43,6 +43,7 @@
 #include "../src/liblsquic/lsquic_logger.h"
 
 #define MAX(a, b) ((a) > (b) ? (a) : (b))
+#define MIN(a, b) ((a) < (b) ? (a) : (b))
 
 #ifndef WIN32
 #   define SOCKET_TYPE int
@@ -552,6 +553,8 @@ read_handler (evutil_socket_t fd, short flags, void *ctx)
     struct packets_in *packs_in = sport->packs_in;
     struct read_iter iter;
     unsigned n, n_batches;
+    /* Save the value in case program is stopped packs_in is freed: */
+    const unsigned n_alloc = packs_in->n_alloc;
     enum rop rop;
 
     n_batches = 0;
@@ -569,7 +572,7 @@ read_handler (evutil_socket_t fd, short flags, void *ctx)
         n_batches += iter.ri_idx > 0;
 
         for (n = 0; n < iter.ri_idx; ++n)
-            if (0 != lsquic_engine_packet_in(engine,
+            if (0 > lsquic_engine_packet_in(engine,
 #ifndef WIN32
                         packs_in->vecs[n].iov_base,
                         packs_in->vecs[n].iov_len,
@@ -581,14 +584,14 @@ read_handler (evutil_socket_t fd, short flags, void *ctx)
                         (struct sockaddr *) &packs_in->peer_addresses[n],
                         sport))
                 break;
+
+        if (n > 0)
+            prog_process_conns(sport->sp_prog);
     }
-    while (ROP_NOROOM == rop);
+    while (ROP_NOROOM == rop && !prog_is_stopped());
 
     if (n_batches)
-        n += packs_in->n_alloc * (n_batches - 1);
-
-    if (!prog_is_stopped())
-        prog_process_conns(sport->sp_prog);
+        n += n_alloc * (n_batches - 1);
 
     LSQ_DEBUG("read %u packet%.*s in %u batch%s", n, n != 1, "s", n_batches, n_batches != 1 ? "es" : "");
 }

test/unittests/CMakeLists.txt

@@ -11,218 +11,218 @@ set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-unused-value")
 
 
 add_executable(test_rechist test_rechist.c)
-target_link_libraries(test_rechist lsquic pthread libssl.a libcrypto.a z m ${FIULIB})
+target_link_libraries(test_rechist lsquic pthread libssl.a libcrypto.a z m ${LIBS})
 add_test(rechist test_rechist)
 
 add_executable(test_senhist test_senhist.c)
-target_link_libraries(test_senhist lsquic pthread libssl.a libcrypto.a z m ${FIULIB})
+target_link_libraries(test_senhist lsquic pthread libssl.a libcrypto.a z m ${LIBS})
 add_test(senhist test_senhist)
 
 add_executable(test_rtt test_rtt.c)
-target_link_libraries(test_rtt lsquic m ${FIULIB})
+target_link_libraries(test_rtt lsquic m ${LIBS})
 add_test(rtt test_rtt)
 
 add_executable(test_set test_set.c)
-target_link_libraries(test_set lsquic m ${FIULIB})
+target_link_libraries(test_set lsquic m ${LIBS})
 add_test(set test_set)
 
 
 add_executable(test_engine_ctor test_engine_ctor.c)
-target_link_libraries(test_engine_ctor lsquic pthread libssl.a libcrypto.a z m ${FIULIB})
+target_link_libraries(test_engine_ctor lsquic pthread libssl.a libcrypto.a z m ${LIBS})
 add_test(engine_ctor test_engine_ctor)
 
 
 add_executable(test_stream test_stream.c)
-target_link_libraries(test_stream lsquic pthread libssl.a libcrypto.a z m ${FIULIB})
+target_link_libraries(test_stream lsquic pthread libssl.a libcrypto.a z m ${LIBS})
 add_test(stream test_stream)
 add_test(stream_hash test_stream -h)
 add_test(stream_A test_stream -A)
 add_test(stream_hash_A test_stream -A -h)
 
 add_executable(test_spi test_spi.c)
-target_link_libraries(test_spi lsquic pthread libssl.a libcrypto.a z m ${FIULIB})
+target_link_libraries(test_spi lsquic pthread libssl.a libcrypto.a z m ${LIBS})
 add_test(spi test_spi)
 
 add_executable(test_malo test_malo.c)
-target_link_libraries(test_malo lsquic m ${FIULIB})
+target_link_libraries(test_malo lsquic m ${LIBS})
 add_test(malo test_malo)
 
 add_executable(test_conn_hash test_conn_hash.c)
-target_link_libraries(test_conn_hash lsquic m ${FIULIB})
+target_link_libraries(test_conn_hash lsquic m ${LIBS})
 add_test(conn_hash test_conn_hash)
 
 add_executable(test_lsquic_hash test_lsquic_hash.c)
-target_link_libraries(test_lsquic_hash lsquic m ${FIULIB})
+target_link_libraries(test_lsquic_hash lsquic m ${LIBS})
 add_test(lsquic_hash test_lsquic_hash)
 
 add_executable(test_blocked_gquic_le test_blocked_gquic_le.c)
-target_link_libraries(test_blocked_gquic_le lsquic pthread libssl.a libcrypto.a z m ${FIULIB})
+target_link_libraries(test_blocked_gquic_le lsquic pthread libssl.a libcrypto.a z m ${LIBS})
 add_test(blocked_gquic_le test_blocked_gquic_le)
 
 add_executable(test_blocked_gquic_be test_blocked_gquic_be.c)
-target_link_libraries(test_blocked_gquic_be lsquic pthread libssl.a libcrypto.a z m ${FIULIB})
+target_link_libraries(test_blocked_gquic_be lsquic pthread libssl.a libcrypto.a z m ${LIBS})
 add_test(blocked_gquic_be test_blocked_gquic_be)
 
 add_executable(test_rst_stream_gquic_le test_rst_stream_gquic_le.c)
-target_link_libraries(test_rst_stream_gquic_le lsquic pthread libssl.a libcrypto.a z m ${FIULIB})
+target_link_libraries(test_rst_stream_gquic_le lsquic pthread libssl.a libcrypto.a z m ${LIBS})
 add_test(rst_stream_gquic_le test_rst_stream_gquic_le)
 
 add_executable(test_rst_stream_gquic_be test_rst_stream_gquic_be.c)
-target_link_libraries(test_rst_stream_gquic_be lsquic pthread libssl.a libcrypto.a z m ${FIULIB})
+target_link_libraries(test_rst_stream_gquic_be lsquic pthread libssl.a libcrypto.a z m ${LIBS})
 add_test(rst_stream_gquic_be test_rst_stream_gquic_be)
 
 add_executable(test_conn_close_gquic_le test_conn_close_gquic_le.c)
-target_link_libraries(test_conn_close_gquic_le lsquic pthread libssl.a libcrypto.a z m ${FIULIB})
+target_link_libraries(test_conn_close_gquic_le lsquic pthread libssl.a libcrypto.a z m ${LIBS})
 add_test(conn_close_gquic_le test_conn_close_gquic_le)
 
 add_executable(test_conn_close_gquic_be test_conn_close_gquic_be.c)
-target_link_libraries(test_conn_close_gquic_be lsquic pthread libssl.a libcrypto.a z m ${FIULIB})
+target_link_libraries(test_conn_close_gquic_be lsquic pthread libssl.a libcrypto.a z m ${LIBS})
 add_test(conn_close_gquic_be test_conn_close_gquic_be)
 
 add_executable(test_goaway_gquic_le test_goaway_gquic_le.c)
-target_link_libraries(test_goaway_gquic_le lsquic pthread libssl.a libcrypto.a z m ${FIULIB})
+target_link_libraries(test_goaway_gquic_le lsquic pthread libssl.a libcrypto.a z m ${LIBS})
 add_test(goaway_gquic_le test_goaway_gquic_le)
 
 add_executable(test_goaway_gquic_be test_goaway_gquic_be.c)
-target_link_libraries(test_goaway_gquic_be lsquic pthread libssl.a libcrypto.a z m ${FIULIB})
+target_link_libraries(test_goaway_gquic_be lsquic pthread libssl.a libcrypto.a z m ${LIBS})
 add_test(goaway_gquic_be test_goaway_gquic_be)
 
 add_executable(test_wuf_gquic_le test_wuf_gquic_le.c)
-target_link_libraries(test_wuf_gquic_le lsquic pthread libssl.a libcrypto.a z m ${FIULIB})
+target_link_libraries(test_wuf_gquic_le lsquic pthread libssl.a libcrypto.a z m ${LIBS})
 add_test(wuf_gquic_le test_wuf_gquic_le)
 
 add_executable(test_wuf_gquic_be test_wuf_gquic_be.c)
-target_link_libraries(test_wuf_gquic_be lsquic pthread libssl.a libcrypto.a z m ${FIULIB})
+target_link_libraries(test_wuf_gquic_be lsquic pthread libssl.a libcrypto.a z m ${LIBS})
 add_test(wuf_gquic_be test_wuf_gquic_be)
 
 add_executable(test_ackparse_gquic_le test_ackparse_gquic_le.c)
-target_link_libraries(test_ackparse_gquic_le lsquic pthread libssl.a libcrypto.a z m ${FIULIB})
+target_link_libraries(test_ackparse_gquic_le lsquic pthread libssl.a libcrypto.a z m ${LIBS})
 add_test(ackparse_gquic_le test_ackparse_gquic_le)
 
 add_executable(test_ackparse_gquic_be test_ackparse_gquic_be.c)
-target_link_libraries(test_ackparse_gquic_be lsquic pthread libssl.a libcrypto.a z m ${FIULIB})
+target_link_libraries(test_ackparse_gquic_be lsquic pthread libssl.a libcrypto.a z m ${LIBS})
 add_test(ackparse_gquic_be test_ackparse_gquic_be)
 
 add_executable(test_ackgen_gquic_le test_ackgen_gquic_le.c)
-target_link_libraries(test_ackgen_gquic_le lsquic pthread libssl.a libcrypto.a z m ${FIULIB})
+target_link_libraries(test_ackgen_gquic_le lsquic pthread libssl.a libcrypto.a z m ${LIBS})
 add_test(ackgen_gquic_le test_ackgen_gquic_le)
 
 add_executable(test_ackgen_gquic_be test_ackgen_gquic_be.c)
-target_link_libraries(test_ackgen_gquic_be lsquic pthread libssl.a libcrypto.a z m ${FIULIB})
+target_link_libraries(test_ackgen_gquic_be lsquic pthread libssl.a libcrypto.a z m ${LIBS})
 add_test(ackgen_gquic_be test_ackgen_gquic_be)
 
 add_executable(test_sfcw test_sfcw.c)
-target_link_libraries(test_sfcw lsquic pthread libssl.a libcrypto.a z m ${FIULIB})
+target_link_libraries(test_sfcw lsquic pthread libssl.a libcrypto.a z m ${LIBS})
 add_test(sfcw test_sfcw)
 
 add_executable(test_alarmset test_alarmset.c)
-target_link_libraries(test_alarmset lsquic m ${FIULIB})
+target_link_libraries(test_alarmset lsquic m ${LIBS})
 add_test(alarmset test_alarmset)
 
 add_executable(graph_cubic graph_cubic.c)
-target_link_libraries(graph_cubic lsquic m ${FIULIB})
+target_link_libraries(graph_cubic lsquic m ${LIBS})
 
 
 add_executable(test_streamparse test_streamparse.c)
-target_link_libraries(test_streamparse lsquic pthread libssl.a libcrypto.a z m ${FIULIB})
+target_link_libraries(test_streamparse lsquic pthread libssl.a libcrypto.a z m ${LIBS})
 add_test(streamparse test_streamparse)
 
 add_executable(test_packet_out test_packet_out.c)
-target_link_libraries(test_packet_out lsquic pthread libssl.a libcrypto.a z m ${FIULIB})
+target_link_libraries(test_packet_out lsquic pthread libssl.a libcrypto.a z m ${LIBS})
 add_test(packet_out test_packet_out)
 
 add_executable(test_reg_pkt_headergen test_reg_pkt_headergen.c)
-target_link_libraries(test_reg_pkt_headergen lsquic pthread libssl.a libcrypto.a z m ${FIULIB})
+target_link_libraries(test_reg_pkt_headergen lsquic pthread libssl.a libcrypto.a z m ${LIBS})
 add_test(reg_pkt_headergen test_reg_pkt_headergen)
 
 add_executable(test_ver_nego test_ver_nego.c)
-target_link_libraries(test_ver_nego lsquic pthread libssl.a libcrypto.a z m ${FIULIB})
+target_link_libraries(test_ver_nego lsquic pthread libssl.a libcrypto.a z m ${LIBS})
 add_test(ver_nego test_ver_nego)
 
 add_executable(test_packno_len test_packno_len.c)
-target_link_libraries(test_packno_len lsquic pthread libssl.a libcrypto.a z m ${FIULIB})
+target_link_libraries(test_packno_len lsquic pthread libssl.a libcrypto.a z m ${LIBS})
 add_test(packno_len test_packno_len)
 
 
 add_executable(test_streamgen test_streamgen.c)
-target_link_libraries(test_streamgen lsquic pthread libssl.a libcrypto.a z m ${FIULIB})
+target_link_libraries(test_streamgen lsquic pthread libssl.a libcrypto.a z m ${LIBS})
 add_test(streamgen test_streamgen)
 
 add_executable(test_some_packets test_some_packets.c)
-target_link_libraries(test_some_packets lsquic pthread libssl.a libcrypto.a z m ${FIULIB})
+target_link_libraries(test_some_packets lsquic pthread libssl.a libcrypto.a z m ${LIBS})
 add_test(some_packets test_some_packets)
 
 
 add_executable(test_elision test_elision.c)
-target_link_libraries(test_elision lsquic pthread libssl.a libcrypto.a z m ${FIULIB})
+target_link_libraries(test_elision lsquic pthread libssl.a libcrypto.a z m ${LIBS})
 add_test(elision test_elision)
 
 add_executable(test_stop_waiting_gquic_le test_stop_waiting_gquic_le.c)
-target_link_libraries(test_stop_waiting_gquic_le lsquic pthread libssl.a libcrypto.a z m ${FIULIB})
+target_link_libraries(test_stop_waiting_gquic_le lsquic pthread libssl.a libcrypto.a z m ${LIBS})
 add_test(stop_waiting_gquic_le test_stop_waiting_gquic_le)
 
 add_executable(test_stop_waiting_gquic_be test_stop_waiting_gquic_be.c)
-target_link_libraries(test_stop_waiting_gquic_be lsquic pthread libssl.a libcrypto.a z m ${FIULIB})
+target_link_libraries(test_stop_waiting_gquic_be lsquic pthread libssl.a libcrypto.a z m ${LIBS})
 add_test(stop_waiting_gquic_be test_stop_waiting_gquic_be)
 
 add_executable(test_parse_packet_in test_parse_packet_in.c)
-target_link_libraries(test_parse_packet_in lsquic pthread libssl.a libcrypto.a z m ${FIULIB})
+target_link_libraries(test_parse_packet_in lsquic pthread libssl.a libcrypto.a z m ${LIBS})
 add_test(parse_packet_in test_parse_packet_in)
 
 add_executable(test_quic_le_floats test_quic_le_floats.c)
-target_link_libraries(test_quic_le_floats lsquic pthread libssl.a libcrypto.a z m ${FIULIB})
+target_link_libraries(test_quic_le_floats lsquic pthread libssl.a libcrypto.a z m ${LIBS})
 add_test(quic_le_floats test_quic_le_floats)
 
 add_executable(test_quic_be_floats test_quic_be_floats.c)
-target_link_libraries(test_quic_be_floats lsquic pthread libssl.a libcrypto.a z m ${FIULIB})
+target_link_libraries(test_quic_be_floats lsquic pthread libssl.a libcrypto.a z m ${LIBS})
 add_test(quic_be_floats test_quic_be_floats)
 
 add_executable(test_export_key test_export_key.c)
-target_link_libraries(test_export_key lsquic pthread libssl.a libcrypto.a z m ${FIULIB})
+target_link_libraries(test_export_key lsquic pthread libssl.a libcrypto.a z m ${LIBS})
 add_test(export_key test_export_key)
 
 add_executable(test_frame_reader test_frame_reader.c)
-target_link_libraries(test_frame_reader lsquic pthread libssl.a libcrypto.a z m ${FIULIB})
+target_link_libraries(test_frame_reader lsquic pthread libssl.a libcrypto.a z m ${LIBS})
 add_test(frame_reader test_frame_reader)
 
 add_executable(test_frame_writer test_frame_writer.c)
-target_link_libraries(test_frame_writer lsquic pthread libssl.a libcrypto.a z m ${FIULIB})
+target_link_libraries(test_frame_writer lsquic pthread libssl.a libcrypto.a z m ${LIBS})
 add_test(frame_writer test_frame_writer)
 
 add_executable(test_frame_chop test_frame_chop.c)
-target_link_libraries(test_frame_chop lsquic pthread libssl.a libcrypto.a z m ${FIULIB})
+target_link_libraries(test_frame_chop lsquic pthread libssl.a libcrypto.a z m ${LIBS})
 add_test(frame_chop test_frame_chop)
 
 IF (NOT ${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
     add_executable(test_frame_rw test_frame_rw.c)
-    target_link_libraries(test_frame_rw lsquic pthread libssl.a libcrypto.a z m ${FIULIB})
+    target_link_libraries(test_frame_rw lsquic pthread libssl.a libcrypto.a z m ${LIBS})
     add_test(frame_rw test_frame_rw)
 ENDIF()
 
 add_executable(test_hkdf test_hkdf.c)
-target_link_libraries(test_hkdf lsquic pthread libssl.a libcrypto.a m ${FIULIB})
+target_link_libraries(test_hkdf lsquic pthread libssl.a libcrypto.a m ${LIBS})
 add_test(hkdf test_hkdf)
 
 
 
 add_executable(test_attq test_attq.c)
-target_link_libraries(test_attq lsquic pthread libssl.a libcrypto.a m ${FIULIB})
+target_link_libraries(test_attq lsquic pthread libssl.a libcrypto.a m ${LIBS})
 add_test(attq test_attq)
 
 add_executable(test_arr test_arr.c)
-target_link_libraries(test_arr lsquic pthread libssl.a libcrypto.a m ${FIULIB})
+target_link_libraries(test_arr lsquic pthread libssl.a libcrypto.a m ${LIBS})
 add_test(arr test_arr)
 
 add_executable(test_buf test_buf.c)
-target_link_libraries(test_buf lsquic pthread libssl.a libcrypto.a m ${FIULIB})
+target_link_libraries(test_buf lsquic pthread libssl.a libcrypto.a m ${LIBS})
 add_test(buf test_buf)
 
 add_executable(test_cubic test_cubic.c)
-target_link_libraries(test_cubic lsquic pthread libssl.a libcrypto.a m ${FIULIB})
+target_link_libraries(test_cubic lsquic pthread libssl.a libcrypto.a m ${LIBS})
 add_test(cubic test_cubic)
 
 add_executable(test_dec test_dec.c)
-target_link_libraries(test_dec libssl.a libcrypto.a z m pthread ${FIULIB})
+target_link_libraries(test_dec libssl.a libcrypto.a z m pthread ${LIBS})
 
 
 #MSVC
@@ -230,7 +230,7 @@ ELSE()
 
 SET (UGH_LIB_LIST debug  $(SolutionDir)src/liblsquic/debug/lsquic.lib debug  ${VCPKG_BASE_DIR}/debug/lib/event.lib debug  ${VCPKG_BASE_DIR}/debug/lib/zlibd.lib debug  ${BORINGSSL_BASE_LIB_DIR}/ssl/debug/ssl.lib debug  ${BORINGSSL_BASE_LIB_DIR}/crypto/debug/crypto.lib optimized  $(SolutionDir)src/liblsquic/release/lsquic.lib optimized  ${VCPKG_BASE_DIR}/lib/event.lib optimized  ${VCPKG_BASE_DIR}/lib/zlib.lib optimized  ${BORINGSSL_BASE_LIB_DIR}/ssl/Release/ssl.lib optimized  ${BORINGSSL_BASE_LIB_DIR}/crypto/Release/crypto.lib)
 
-set(MIN_LIBS_LIST ${FIULIB} ws2_32)
+set(MIN_LIBS_LIST ${LIBS} ws2_32)
 set(LIBS_LIST ${UGH_LIB_LIST} ${MIN_LIBS_LIST})
 
 add_executable(test_rechist test_rechist.c)