vsomeip 3.3.7 (#457)

Notes:
- Fix handling of endpoint options
- Fix build on Windows
- Fix client-side logging filters
- Rework in event::set_payload
- Release no longer in use client endpoints
- Rework condition for starting the send operation
- Verify if the event is shadow

Author: DiogoPedrozza

Android.bp

@@ -80,7 +80,7 @@ cc_library_shared {
 
     cflags: [
         "-DWITHOUT_SYSTEMD",
-        "-DVSOMEIP_COMPAT_VERSION=\"3.3.6\"",
+        "-DVSOMEIP_COMPAT_VERSION=\"3.3.7\"",
         "-DVSOMEIP_BASE_PATH=\"/vendor/run/someip/\"",
         "-DUSE_DLT",
     ],

Android.mk

@@ -100,7 +100,7 @@ LOCAL_CFLAGS :=  \
     -frtti \
     -fexceptions \
     -DWITHOUT_SYSTEMD \
-    -DVSOMEIP_VERSION=\"3.3.6\" \
+    -DVSOMEIP_VERSION=\"3.3.7\" \
     -DVSOMEIP_BASE_PATH=\"/vendor/run/someip/\" \
     -Wno-unused-parameter \
     -Wno-non-virtual-dtor \
@@ -147,7 +147,7 @@ LOCAL_CFLAGS := \
     -frtti \
     -fexceptions \
     -DWITHOUT_SYSTEMD \
-    -DVSOMEIP_VERSION=\"3.3.6\" \
+    -DVSOMEIP_VERSION=\"3.3.7\" \
     -DVSOMEIP_BASE_PATH=\"/vendor/run/someip/\" \
     -Wno-unused-parameter \
     -Wno-non-virtual-dtor \
@@ -194,8 +194,8 @@ LOCAL_CFLAGS :=  \
     -frtti \
     -fexceptions \
     -DWITHOUT_SYSTEMD \
-    -DVSOMEIP_VERSION=\"3.3.6\" \
-    -DVSOMEIP_COMPAT_VERSION=\"3.3.6\" \
+    -DVSOMEIP_VERSION=\"3.3.7\" \
+    -DVSOMEIP_COMPAT_VERSION=\"3.3.7\" \
     -DVSOMEIP_BASE_PATH=\"/vendor/run/someip/\" \
     -Wno-unused-parameter \
     -Wno-non-virtual-dtor \

CHANGES

@@ -1,5 +1,13 @@
 Changes
 =======
+v3.3.7
+- Fix handling of endpoint options
+- Fix build on Windows
+- Fix client-side logging filters
+- Rework in event::set_payload
+- Release no longer in use client endpoints
+- Rework condition for starting the send operation
+- Verify if the event is shadow
 
 v3.3.6
 - The "last forwarded" timestamp must be handled per event

CMakeLists.txt

@@ -11,7 +11,7 @@ set (VSOMEIP_COMPAT_NAME vsomeip)
 
 set (VSOMEIP_MAJOR_VERSION 3)
 set (VSOMEIP_MINOR_VERSION 3)
-set (VSOMEIP_PATCH_VERSION 6)
+set (VSOMEIP_PATCH_VERSION 7)
 set (VSOMEIP_HOTFIX_VERSION 0)
 
 set (VSOMEIP_VERSION ${VSOMEIP_MAJOR_VERSION}.${VSOMEIP_MINOR_VERSION}.${VSOMEIP_PATCH_VERSION})
@@ -232,7 +232,7 @@ if (MSVC)
     # add_definitions(-DVSOMEIP_DLL_COMPILATION) now it is controlled per target
     SET(BOOST_WINDOWS_VERSION "0x600" CACHE STRING "Set the same Version as the Version with which Boost was built, otherwise there will be errors. (normaly 0x600 is for Windows 7 and 0x501 is for Windows XP)")
     # Disable warning C4250 since it warns that the compiler is correctly following the C++ Standard. It's a "We-Are-Doing-Things-By-The-Book" notice, not a real warning.
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_CRT_SECURE_NO_WARNINGS -D_SCL_SECURE_NO_WARNINGS -D_WINSOCK_DEPRECATED_NO_WARNINGS -D_WIN32_WINNT=${BOOST_WINDOWS_VERSION} -DWIN32 -DBOOST_ASIO_DISABLE_IOCP /EHsc /std:c++latest /wd4250")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_CRT_SECURE_NO_WARNINGS -D_SCL_SECURE_NO_WARNINGS -D_WINSOCK_DEPRECATED_NO_WARNINGS -D_WIN32_WINNT=${BOOST_WINDOWS_VERSION} -DWIN32 -DBOOST_ASIO_DISABLE_IOCP /EHsc /std:c++14 /wd4250")
     set(USE_RT "")
     link_directories(${Boost_LIBRARY_DIR_DEBUG})
     ADD_DEFINITIONS( -DBOOST_ALL_DYN_LINK )

implementation/endpoints/include/server_endpoint_impl.hpp

@@ -32,7 +32,20 @@ class server_endpoint_impl: public endpoint_impl<Protocol>,
             : train_(std::make_shared<train>()),
               dispatch_timer_(std::make_shared<boost::asio::steady_timer>(_io)),
               has_last_departure_(false),
-              queue_size_(0) {
+              queue_size_(0),
+              is_sending_(false),
+              sent_timer_(_io),
+			  io_(_io) {
+        }
+
+        endpoint_data_type(const endpoint_data_type &&_source)
+        	: train_(_source.train_),
+			  dispatch_timer_(std::make_shared<boost::asio::steady_timer>(_source.io_)),
+			  has_last_departure_(_source.has_last_departure_),
+			  queue_size_(_source.queue_size_),
+			  is_sending_(_source.is_sending_),
+			  sent_timer_(_source.io_),
+			  io_(_source.io_) {
         }
 
         std::shared_ptr<train> train_;
@@ -44,6 +57,11 @@ class server_endpoint_impl: public endpoint_impl<Protocol>,
 
         std::deque<std::pair<message_buffer_ptr_t, uint32_t> > queue_;
         std::size_t queue_size_;
+
+        bool is_sending_;
+        boost::asio::steady_timer sent_timer_;
+
+        boost::asio::io_context &io_;
     };
 
     typedef typename std::map<endpoint_type, endpoint_data_type> target_data_type;
@@ -105,8 +123,7 @@ class server_endpoint_impl: public endpoint_impl<Protocol>,
     bool check_queue_limit(const uint8_t *_data, std::uint32_t _size,
                            std::size_t _current_queue_size) const;
     bool queue_train(const target_data_iterator_type _it,
-            const std::shared_ptr<train> &_train,
-            bool _queue_size_zero_on_entry);
+            const std::shared_ptr<train> &_train);
 
     void send_segments(const tp::tp_split_messages_t &_segments,
             std::uint32_t _separation_time, const endpoint_type &_target);
@@ -123,10 +140,6 @@ class server_endpoint_impl: public endpoint_impl<Protocol>,
 
     mutable std::mutex mutex_;
 
-    std::mutex sent_mutex_;
-    bool is_sending_;
-    boost::asio::steady_timer sent_timer_;
-
 private:
     virtual std::string get_remote_information(
             const target_data_iterator_type _queue_iterator) const = 0;

implementation/endpoints/include/tcp_server_endpoint_impl.hpp

@@ -41,7 +41,6 @@ class tcp_server_endpoint_impl: public tcp_server_endpoint_base_impl {
     bool send_error(const std::shared_ptr<endpoint_definition> _target,
                 const byte_t *_data, uint32_t _size);
     bool send_queued(const target_data_iterator_type _it);
-    void send_queued_sync(const target_data_iterator_type _it);
     void get_configured_times_from_endpoint(
             service_t _service, method_t _method,
             std::chrono::nanoseconds *_debouncing,
@@ -83,7 +82,6 @@ class tcp_server_endpoint_impl: public tcp_server_endpoint_base_impl {
         void receive();
 
         void send_queued(const target_data_iterator_type _it);
-        void send_queued_sync(const target_data_iterator_type _it);
 
         void set_remote_info(const endpoint_type &_remote);
         std::string get_address_port_remote() const;

implementation/endpoints/src/endpoint_impl.cpp

@@ -145,14 +145,18 @@ instance_t endpoint_impl<Protocol>::get_instance(service_t _service) {
 }
 
 // Instantiate template
-#if defined(__linux__) || defined(ANDROID)
+#ifdef __linux__
 template class endpoint_impl<boost::asio::local::stream_protocol>;
 #if VSOMEIP_BOOST_VERSION < 106600
 template class endpoint_impl<boost::asio::local::stream_protocol_ext>;
-template class endpoint_impl<boost::asio::ip::udp_ext>;
 #endif
 #endif
+
 template class endpoint_impl<boost::asio::ip::tcp>;
 template class endpoint_impl<boost::asio::ip::udp>;
 
+#if VSOMEIP_BOOST_VERSION < 106600
+template class endpoint_impl<boost::asio::ip::udp_ext>;
+#endif
+
 } // namespace vsomeip_v3

implementation/endpoints/src/endpoint_manager_impl.cpp

@@ -353,8 +353,14 @@ void
 endpoint_manager_impl::clear_client_endpoints(
         service_t _service, instance_t _instance, bool _reliable) {
 
-    std::shared_ptr<endpoint> endpoint_to_delete;
+    std::shared_ptr<endpoint> its_endpoint;
+
+    boost::asio::ip::address its_remote_address;
+    port_t its_local_port(0);
+    port_t its_remote_port(0);
+
     bool other_services_reachable_through_endpoint(false);
+
     {
         std::lock_guard<std::recursive_mutex> its_lock(endpoint_mutex_);
         // Clear client endpoints for remote services (generic and specific ones)
@@ -365,8 +371,7 @@ endpoint_manager_impl::clear_client_endpoints(
                 const auto found_reliability = found_instance->second.find(_reliable);
                 if (found_reliability != found_instance->second.end()) {
                     service_instances_[_service].erase(found_reliability->second.get());
-                    endpoint_to_delete = found_reliability->second;
-
+                    its_endpoint = found_reliability->second;
                     found_instance->second.erase(found_reliability);
                     if (found_instance->second.empty()) {
                         found_service->second.erase(found_instance);
@@ -380,12 +385,12 @@ endpoint_manager_impl::clear_client_endpoints(
 
         // Only stop and delete the endpoint if none of the services
         // reachable through it is online anymore.
-        if (endpoint_to_delete) {
+        if (its_endpoint) {
             for (const auto& service : remote_services_) {
                 for (const auto& instance : service.second) {
                     const auto found_reliability = instance.second.find(_reliable);
                     if (found_reliability != instance.second.end()
-                            && found_reliability->second == endpoint_to_delete) {
+                            && found_reliability->second == its_endpoint) {
                         other_services_reachable_through_endpoint = true;
                         break;
                     }
@@ -395,35 +400,35 @@ endpoint_manager_impl::clear_client_endpoints(
 
             if (!other_services_reachable_through_endpoint) {
                 partition_id_t its_partition;
-                boost::asio::ip::address its_address;
-                std::uint16_t its_port(0);
 
                 its_partition = configuration_->get_partition_id(_service, _instance);
 
                 if (_reliable) {
-                    std::shared_ptr<tcp_client_endpoint_impl> ep =
-                            std::dynamic_pointer_cast<tcp_client_endpoint_impl>(endpoint_to_delete);
-                    if (ep) {
-                        its_port = ep->get_remote_port();
-                        ep->get_remote_address(its_address);
+                    std::shared_ptr<tcp_client_endpoint_impl> its_tcp_client_endpoint =
+                            std::dynamic_pointer_cast<tcp_client_endpoint_impl>(its_endpoint);
+                    if (its_tcp_client_endpoint) {
+                        its_local_port = its_tcp_client_endpoint->get_local_port();
+                        its_remote_port = its_tcp_client_endpoint->get_remote_port();
+                        its_tcp_client_endpoint->get_remote_address(its_remote_address);
                     }
                 } else {
-                    std::shared_ptr<udp_client_endpoint_impl> ep =
-                            std::dynamic_pointer_cast<udp_client_endpoint_impl>(endpoint_to_delete);
-                    if (ep) {
-                        its_port = ep->get_remote_port();
-                        ep->get_remote_address(its_address);
+                    std::shared_ptr<udp_client_endpoint_impl> its_udp_client_endpoint =
+                            std::dynamic_pointer_cast<udp_client_endpoint_impl>(its_endpoint);
+                    if (its_udp_client_endpoint) {
+                        its_local_port = its_udp_client_endpoint->get_local_port();
+                        its_remote_port = its_udp_client_endpoint->get_remote_port();
+                        its_udp_client_endpoint->get_remote_address(its_remote_address);
                     }
                 }
-                const auto found_ip = client_endpoints_by_ip_.find(its_address);
+                const auto found_ip = client_endpoints_by_ip_.find(its_remote_address);
                 if (found_ip != client_endpoints_by_ip_.end()) {
-                    const auto found_port = found_ip->second.find(its_port);
+                    const auto found_port = found_ip->second.find(its_remote_port);
                     if (found_port != found_ip->second.end()) {
                         auto found_reliable = found_port->second.find(_reliable);
                         if (found_reliable != found_port->second.end()) {
                             const auto found_partition = found_reliable->second.find(its_partition);
                             if (found_partition != found_reliable->second.end()) {
-                                if (found_partition->second == endpoint_to_delete) {
+                                if (found_partition->second == its_endpoint) {
                                     found_reliable->second.erase(its_partition);
                                     // delete if necessary
                                     if (0 == found_reliable->second.size()) {
@@ -443,8 +448,11 @@ endpoint_manager_impl::clear_client_endpoints(
             }
         }
     }
-    if (!other_services_reachable_through_endpoint && endpoint_to_delete) {
-        endpoint_to_delete->stop();
+    if (!other_services_reachable_through_endpoint && its_endpoint) {
+        release_used_client_port(its_remote_address, its_remote_port,
+                _reliable, its_local_port);
+
+        its_endpoint->stop();
     }
 }