From: Gabriel Braga Date: Thu, 4 Apr 2024 09:01:32 +0000 (+0200) Subject: Switch time() calls to monotonic clock calls (#7597) X-Git-Url: http://developer.intra2net.com/git/?p=libt2n;a=commitdiff_plain;h=HEAD;hp=a63e08b83794273da3840e0b8bf15bf0085fe3c4 Switch time() calls to monotonic clock calls (#7597) In the event of a time warp the use of time() causes connections to collapse. This removes this problem by using a monotonic clock, based on libi2ncommon. --- diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 8eac9eb..6a41eab 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -13,6 +13,7 @@ set(libt2n_SOURCES socket_server.cpp socket_wrapper.cpp t2n_exception.cpp + monotonic_clock.cpp ) set(libt2n_HEADERS client.hxx @@ -32,6 +33,7 @@ set(libt2n_HEADERS types.hxx container.tcc t2n_exception.tcc + monotonic_clock.hxx ) include_directories(BEFORE ${CMAKE_CURRENT_SOURCE_DIR}) diff --git a/src/monotonic_clock.cpp b/src/monotonic_clock.cpp new file mode 100644 index 0000000..3b4e720 --- /dev/null +++ b/src/monotonic_clock.cpp @@ -0,0 +1,56 @@ +/* +Copyright (C) 2024 by Intra2net AG + +The software in this package is distributed under the GNU General +Public License version 2 (with a special exception described below). + +A copy of GNU General Public License (GPL) is included in this distribution, +in the file COPYING.GPL. + +As a special exception, if other files instantiate templates or use macros +or inline functions from this file, or you compile this file and link it +with other works to produce a work based on this file, this file +does not by itself cause the resulting work to be covered +by the GNU General Public License. + +However the source code for this file must still be made available +in accordance with section (3) of the GNU General Public License. + +This exception does not invalidate any other reasons why a work based +on this file might be covered by the GNU General Public License. +*/ + +#include + +#include "monotonic_clock.hxx" + +/** + * @brief fetches the value from the monotonic clock source. + * @param[out] seconds the seconds. + * @param[out] nano_seconds the nano seconds. + * @return @a true if the clock was successfully read. + */ +bool monotonic_clock_gettime(long int& seconds, long int& nano_seconds) +{ + struct timespec tp[1]; + int res= clock_gettime (CLOCK_MONOTONIC, tp); + if (0 == res) + { + seconds= tp->tv_sec; + nano_seconds= tp->tv_nsec; + } + return (res==0); +} + +/** + * @brief fetches the value from the monotonic clock source. + * @return the time since system start in seconds, 0 if read was unsuccessful + */ +int monotonic_clock_gettime_sec() +{ + long int seconds=0; + long int nano_seconds; + + monotonic_clock_gettime(seconds,nano_seconds); + return seconds; +} diff --git a/src/monotonic_clock.hxx b/src/monotonic_clock.hxx new file mode 100644 index 0000000..98a9583 --- /dev/null +++ b/src/monotonic_clock.hxx @@ -0,0 +1,28 @@ +/* +Copyright (C) 2024 by Intra2net AG + +The software in this package is distributed under the GNU General +Public License version 2 (with a special exception described below). + +A copy of GNU General Public License (GPL) is included in this distribution, +in the file COPYING.GPL. + +As a special exception, if other files instantiate templates or use macros +or inline functions from this file, or you compile this file and link it +with other works to produce a work based on this file, this file +does not by itself cause the resulting work to be covered +by the GNU General Public License. + +However the source code for this file must still be made available +in accordance with section (3) of the GNU General Public License. + +This exception does not invalidate any other reasons why a work based +on this file might be covered by the GNU General Public License. +*/ +#ifndef __LIBT2N_MONOTONIC_CLOCK +#define __LIBT2N_MONOTONIC_CLOCK + +bool monotonic_clock_gettime(long int& seconds, long int& nano_seconds); +int monotonic_clock_gettime_sec(); + +#endif \ No newline at end of file diff --git a/src/server.cpp b/src/server.cpp index 600cbef..7ee28f2 100644 --- a/src/server.cpp +++ b/src/server.cpp @@ -28,6 +28,7 @@ on this file might be covered by the GNU General Public License. #include "server.hxx" #include "log.hxx" +#include "monotonic_clock.hxx" namespace libt2n { @@ -65,7 +66,7 @@ std::ostream* server_connection::get_logstream(log_level_values level) /// check if timeout is expired, close connection if so void server_connection::check_timeout() { - if (timeout != -1 && last_action_time+timeout < time(NULL)) + if (timeout != -1 && last_action_time+timeout < monotonic_clock_gettime_sec()) { LOGSTREAM(debug,"timeout on connection " << connection_id << ", closing"); this->close(); @@ -75,7 +76,7 @@ void server_connection::check_timeout() /// reset the timeout, e.g. if something is received void server_connection::reset_timeout() { - last_action_time=time(NULL); + last_action_time=monotonic_clock_gettime_sec(); } /** @brief add a callback to one connection diff --git a/src/server.hxx b/src/server.hxx index cc3c5dd..ad82287 100644 --- a/src/server.hxx +++ b/src/server.hxx @@ -33,6 +33,7 @@ on this file might be covered by the GNU General Public License. #include "connection.hxx" #include "types.hxx" + namespace libt2n { diff --git a/src/socket_client.cpp b/src/socket_client.cpp index fecad13..954bb30 100644 --- a/src/socket_client.cpp +++ b/src/socket_client.cpp @@ -33,6 +33,7 @@ on this file might be covered by the GNU General Public License. #include #include #include + #include #include diff --git a/src/socket_handler.cpp b/src/socket_handler.cpp index 13e5a45..f1f5ef7 100644 --- a/src/socket_handler.cpp +++ b/src/socket_handler.cpp @@ -236,49 +236,55 @@ bool socket_handler::fill_buffer(std::string& buffer, long long usec_timeout, lo */ bool socket_handler::fill_buffer(std::string& buffer) { - bool try_again=false; - char socket_buffer[recv_buffer_size]; - int nbytes = read (sock, socket_buffer, recv_buffer_size); + const int loop_max = 32; /* limit is 32 * (default) 2048 bytes -> 65536 bytes in one go */ + int loop_count = 0; - if (nbytes < 0) + bool read_something = false; + while (loop_count < loop_max) { - if (errno == EAGAIN) - return false; // no data was waiting - else if (errno == EINTR) + const int nbytes = read(sock, socket_buffer, recv_buffer_size); + + if (nbytes < 0) { - // interrupted, try again - LOGSTREAM(debug,"EINTR received on read(), trying again"); - try_again=true; + if (errno == EAGAIN || errno == EWOULDBLOCK) + return read_something; // no (more) data was waiting + else if (errno == EINTR) + { + // interrupted, try again + LOGSTREAM(debug, "EINTR received on read(), trying again"); + } else + EXCEPTIONSTREAM(error, t2n_transfer_error, "error reading from socket : " << strerror(errno)); } - else - EXCEPTIONSTREAM(error,t2n_transfer_error,"error reading from socket : " << strerror(errno)); - } - // End-of-file - if (nbytes == 0 && !try_again) - { - LOGSTREAM(debug,"0 bytes received on read(), closing connection"); - close(); - return false; - } + // End-of-file + if (nbytes == 0) + { + LOGSTREAM(debug, "0 bytes received on read(), closing connection"); + close(); + return read_something; + } - // Data read -> store it - if (nbytes > 0) - { - buffer.append(socket_buffer,nbytes); - LOGSTREAM(debug,nbytes << " bytes read"); - } + // Data read -> store it + if (nbytes > 0) + { + buffer.append(socket_buffer, nbytes); + LOGSTREAM(debug, nbytes << " bytes read"); + read_something = true; + } - // more data waiting -> recurse - if (data_waiting(0)) - fill_buffer(buffer); + // more data waiting -> loop once more (up to loop_max) + if (data_waiting(0)) + { + ++loop_count; + } else + { + break; + } + } - if (nbytes > 0) - return true; - else - return false; + return read_something; } /// writes raw data to the socket. Don't use directly, use the write() function provided by the @@ -295,10 +301,10 @@ void socket_handler::socket_write(const std::string& data) int rtn; while ((rtn=::write(sock, data.data()+offset, write_size)) == -1 && - (errno == EAGAIN || errno == EINTR)) + (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR)) { wait_ready_to_write(sock,write_timeout); - LOGSTREAM(debug,"resuming write() call after EAGAIN or EINTR"); + LOGSTREAM(debug,"resuming write() call after EAGAIN or EINTR or EWOULDBLOCK"); } if (rtn == -1)