From: Gabriel Braga Date: Tue, 9 Apr 2024 15:45:51 +0000 (+0200) Subject: Adding DOCUMENTATION flag to the CMakeLists.txt X-Git-Url: http://developer.intra2net.com/git/?p=libt2n;a=commitdiff_plain;h=HEAD;hp=c209619c4d44a3e9c5b0f537f53ec65564899efb Adding DOCUMENTATION flag to the CMakeLists.txt This enable us to ignore the documentation build when using dmake making this process less verbose. --- diff --git a/CMakeLists.txt b/CMakeLists.txt index 25f4754..74b3e4d 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -31,8 +31,9 @@ include_directories(${XMLPP_INCLUDE_DIRS}) link_directories(${XMLPP_LIBRARY_DIRS}) # Documentation +option(DOCUMENTATION "Generate API documentation with Doxygen" ON) find_package(Doxygen) -if(DOXYGEN_FOUND) +if(DOXYGEN_FOUND AND DOCUMENTATION) # Find doxy config message(STATUS "Doxygen found.") set(DOXY_DIR "${CMAKE_SOURCE_DIR}/doc") @@ -61,9 +62,9 @@ if(DOXYGEN_FOUND) add_custom_target(docs ALL DEPENDS ${CMAKE_BINARY_DIR}/doc/html/index.html) message(STATUS "Generating API documentation with Doxygen.") -else(DOXYGEN_FOUND) +else(DOXYGEN_FOUND AND DOCUMENTATION) message(STATUS "Not generating API documentation.") -endif(DOXYGEN_FOUND) +endif(DOXYGEN_FOUND AND DOCUMENTATION) # Spec file configure_file(${CMAKE_SOURCE_DIR}/libt2n.spec.in ${CMAKE_SOURCE_DIR}/libt2n.spec @ONLY) 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/client_wrapper.hxx b/src/client_wrapper.hxx index 50d5df6..73fda24 100644 --- a/src/client_wrapper.hxx +++ b/src/client_wrapper.hxx @@ -246,7 +246,7 @@ class T2nSingletonWrapper : public T2nSingletonWrapperMessages if (!WrappedConnection->handle(SingletonObject->Stub.get(),call)) { // create an result with default-constructor if the handler could not - // successfully do a call but no exception occured + // successfully do a call but no exception occurred result=typename detail::TypeWrap::type(); } return result; diff --git a/src/connection.cpp b/src/connection.cpp index f686aa0..6879067 100644 --- a/src/connection.cpp +++ b/src/connection.cpp @@ -171,9 +171,9 @@ void connection::add_callback(callback_event_type event, const boost::function + +#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 79b95b4..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 @@ -140,9 +141,9 @@ void server::add_callback(callback_event_type event, const boost::function #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)