Disconnect on error

Summary
Close all connections on "client error".
Details
These changes related to e716737 but here it's the server that loses
connection to the client.
Since the server application may not be consuming services from the
client, the process of re-requesting service availability triggers from
the routing host does not work.
Instead, the server will forcibly terminate all connections to the
client, forcing them to re-establish the connections to the server.
An alternative was considered  where the server would instead
try to reconnect to the client when it tried to send something, but it was
a bigger change that introduced several issues during testing.

Author: brunoldsilva

implementation/endpoints/include/local_tcp_server_endpoint_impl.hpp

@@ -69,6 +69,11 @@ class local_tcp_server_endpoint_impl
 
     client_t assign_client(const byte_t *_data, uint32_t _size);
 
+    /// @brief Disconnects from the given client.
+    ///
+    /// @param _client ID of the remote client.
+    void disconnect_from(const client_t _client) override;
+
 private:
     class connection: public std::enable_shared_from_this<connection> {
 

implementation/endpoints/include/local_uds_server_endpoint_impl.hpp

@@ -67,6 +67,11 @@ class local_uds_server_endpoint_impl: public local_uds_server_endpoint_base_impl
 
     client_t assign_client(const byte_t *_data, uint32_t _size);
 
+    /// @brief Disconnects from the given client.
+    ///
+    /// @param _client ID of the remote client.
+    void disconnect_from(const client_t _client) override;
+
 private:
     class connection: public std::enable_shared_from_this<connection> {
 

implementation/endpoints/include/server_endpoint.hpp

@@ -0,0 +1,27 @@
+// Copyright (C) 2025 Bayerische Motoren Werke Aktiengesellschaft (BMW AG)
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef VSOMEIP_V3_SERVER_ENDPOINT_HPP_
+#define VSOMEIP_V3_SERVER_ENDPOINT_HPP_
+
+#include <vsomeip/primitive_types.hpp>
+
+namespace vsomeip_v3 {
+
+/// @brief An endpoint to which clients connect.
+class server_endpoint {
+public:
+    /// @brief Destructor.
+    virtual ~server_endpoint() = default;
+
+    /// @brief Disconnects from the given client.
+    ///
+    /// @param _client ID of the remote client.
+    virtual void disconnect_from(const client_t _client) = 0;
+};
+
+}
+
+#endif //  VSOMEIP_V3_SERVER_ENDPOINT_HPP_

implementation/endpoints/include/server_endpoint_impl.hpp

@@ -18,6 +18,7 @@
 
 #include "buffer.hpp"
 #include "endpoint_impl.hpp"
+#include "server_endpoint.hpp"
 #include "tp.hpp"
 #if defined(__QNX__)
 #include "../../utility/include/qnx_helper.hpp"
@@ -26,7 +27,8 @@
 namespace vsomeip_v3 {
 
 template<typename Protocol>
-class server_endpoint_impl : public endpoint_impl<Protocol>,
+class server_endpoint_impl : public server_endpoint,
+                             public endpoint_impl<Protocol>,
                              public std::enable_shared_from_this<server_endpoint_impl<Protocol>> {
 public:
     typedef typename Protocol::socket socket_type;

implementation/endpoints/include/tcp_server_endpoint_impl.hpp

@@ -65,6 +65,12 @@ class tcp_server_endpoint_impl: public tcp_server_endpoint_base_impl {
     void print_status();
 
     bool is_suspended() const;
+
+    /// @brief Disconnects from the given client.
+    ///
+    /// @param _client ID of the remote client.
+    void disconnect_from(const client_t _client) override;
+
 private:
     class connection: public std::enable_shared_from_this<connection> {
 

implementation/endpoints/include/udp_server_endpoint_impl.hpp

@@ -80,6 +80,11 @@ class udp_server_endpoint_impl: public udp_server_endpoint_base_impl {
     bool is_joined(const std::string &_address) const;
     bool is_joined(const std::string &_address, bool& _received) const;
 
+    /// @brief Disconnects from the given client.
+    ///
+    /// @param _client ID of the remote client.
+    void disconnect_from(const client_t _client) override;
+
 private:
     void leave_unlocked(const std::string &_address);
     void set_broadcast();

implementation/endpoints/src/local_tcp_server_endpoint_impl.cpp

@@ -26,6 +26,7 @@
 #include "../../configuration/include/configuration.hpp"
 #include "../../protocol/include/assign_client_command.hpp"
 #include "../../protocol/include/assign_client_ack_command.hpp"
+#include "../../protocol/include/protocol.hpp"
 #include "../../routing/include/routing_host.hpp"
 #include "../../security/include/policy_manager_impl.hpp"
 #include "../../security/include/security.hpp"
@@ -520,6 +521,15 @@ client_t local_tcp_server_endpoint_impl::assign_client(
             its_command.get_name(), its_command.get_client());
 }
 
+void local_tcp_server_endpoint_impl::disconnect_from(const client_t _client) {
+    std::scoped_lock lock {connections_mutex_};
+    if (connections_.find(_client) == connections_.end()) {
+        return;
+    }
+    connections_.at(_client)->stop();
+    connections_.erase(_client);
+}
+
 void local_tcp_server_endpoint_impl::get_configured_times_from_endpoint(
         service_t _service,
         method_t _method, std::chrono::nanoseconds *_debouncing,
@@ -728,6 +738,18 @@ void local_tcp_server_endpoint_impl::connection::receive_cbk(
                         sec_client_.port = htons(its_port);
                         its_server->configuration_->get_security()->sync_client(&sec_client_);
 
+                        // Associate a client ID to this connection.
+                        if (bound_client_ == VSOMEIP_CLIENT_UNSET) {
+                            client_t its_client = VSOMEIP_CLIENT_UNSET;
+                            std::memcpy(
+                                    &its_client,
+                                    &recv_buffer_[its_start + protocol::COMMAND_POSITION_CLIENT],
+                                    sizeof(client_t));
+
+                            set_bound_client(its_client);
+                            its_server->add_connection(its_client, shared_from_this());
+                        }
+
                         its_host->on_message(&recv_buffer_[its_start],
                                             uint32_t(its_end - its_start), its_server.get(),
                                             false, bound_client_, &sec_client_,

implementation/endpoints/src/local_uds_server_endpoint_impl.cpp

@@ -559,6 +559,15 @@ client_t local_uds_server_endpoint_impl::assign_client(
             its_command.get_name(), its_command.get_client());
 }
 
+void local_uds_server_endpoint_impl::disconnect_from(const client_t _client) {
+    std::scoped_lock lock {connections_mutex_};
+    if (connections_.find(_client) == connections_.end()) {
+        return;
+    }
+    connections_.at(_client)->stop();
+    connections_.erase(_client);
+}
+
 void local_uds_server_endpoint_impl::get_configured_times_from_endpoint(
         service_t _service,
         method_t _method, std::chrono::nanoseconds *_debouncing,

implementation/endpoints/src/tcp_server_endpoint_impl.cpp

@@ -318,6 +318,10 @@ bool tcp_server_endpoint_impl::is_suspended() const {
     return false;
 }
 
+void tcp_server_endpoint_impl::disconnect_from(const client_t) {
+    return;
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // class tcp_service_impl::connection
 ///////////////////////////////////////////////////////////////////////////////

implementation/endpoints/src/udp_server_endpoint_impl.cpp

@@ -539,6 +539,10 @@ void udp_server_endpoint_impl::leave(const std::string& _address) {
     leave_unlocked(_address);
 }
 
+void udp_server_endpoint_impl::disconnect_from(const client_t) {
+    return;
+}
+
 void udp_server_endpoint_impl::leave_unlocked(const std::string& _address) {
 
     try {