Method on_pong

implementation/routing/src/routing_manager_impl.cpp:2578–2630

}

void routing_manager_impl::on_pong(client_t _client) {
    std::vector<std::pair<service_instance_t, std::set<client_t>>> requests_to_process;
    {
        std::scoped_lock its_lock{services_state_mutex_};
        std::erase_if(pending_offers_, [_client](const auto& service_iter) {
            auto [major, minor, new_client, old_client] = service_iter.second;
            if (old_client == _client) {
                // received pong from an application were another application wants
                // to offer its service, delete the other applications offer as
                // the current offering application is still alive
                VSOMEIP_ERROR << "OFFER(" << hex4(new_client) << "): [" << hex4(service_iter.first.service()) << "."
                              << hex4(service_iter.first.instance()) << ":" << std::uint32_t(major) << "." << minor
                              << "] was rejected as application: " << hex4(_client) << " is still alive";
                return true;
            }
            return false;
        });

        for (auto iter = pending_requests_.begin(); iter != pending_requests_.end();) {
            const auto& its_key = iter->first;
            auto& [offering_client, requesting_clients] = iter->second;

            if (offering_client == _client) {
                // Received pong from an application where another application wants to request its service. Defer request processing until
                // after pending_commands_mutex_ is released to keep lock ordering consistent with request/release paths.
                requests_to_process.emplace_back(its_key, std::move(requesting_clients));
                iter = pending_requests_.erase(iter);
            } else {
                ++iter;
            }
        }
    }

    // The requests_to_process is a local stack copy extracted under lock.
    // Only this thread can access it, and no other thread can obtain a reference to it.
    // This defers processing outside the critical section to maintain lock ordering.
    for (const auto& [service_instance, requesting_clients] : requests_to_process) {
        auto service_id = service_instance.service();
        auto instance_id = service_instance.instance();
        protocol::service its_request(service_id, instance_id, ANY_MAJOR, ANY_MINOR);
        std::set<protocol::service> requests;
        requests.insert(its_request);

        for (auto client_id : requesting_clients) {
            request_service(client_id, service_id, instance_id, ANY_MAJOR, ANY_MINOR);
            if (configuration_->is_security_enabled()) {
                stub_->handle_credentials(client_id, requests);
            }
            stub_->handle_requests(client_id, requests);
            VSOMEIP_INFO << "REQUEST(" << hex4(client_id) << "): [" << hex4(service_id) << "." << hex4(instance_id) << "] processed";
        }
    }
}

void routing_manager_impl::register_client_error_handler(client_t _client, const std::shared_ptr<local_endpoint>& _endpoint) {
    _endpoint->register_cleanup_handler([weak_self = weak_from_this(), _client](bool) {