Method subscribe

implementation/routing/src/routing_manager_impl.cpp:526–591

}

void routing_manager_impl::subscribe(client_t _client, [[maybe_unused]] const vsomeip_sec_client_t* _sec_client, service_t _service,
                                     instance_t _instance, eventgroup_t _eventgroup, major_version_t _major, event_t _event,
                                     const std::shared_ptr<debounce_filter_impl_t>& _filter) {

    if (routing_state_ == routing_state_e::RS_SUSPENDED) {
        VSOMEIP_INFO_P << "We are suspended --> do nothing.";
        return;
    }

    VSOMEIP_INFO << "SUBSCRIBE(" << hex4(_client) << "): [" << hex4(_service) << "." << hex4(_instance) << "." << hex4(_eventgroup) << ":"
                 << hex4(_event) << ":" << static_cast<int>(_major) << "]";
    {
        if (discovery_) {
            // Note: The calls to insert_subscription & handle_subscription_state must not
            // run concurrently to a call to on_subscribe_ack. Therefore the lock is acquired
            // before calling insert_subscription and released after the call to
            // handle_subscription_state.
            const client_t its_local_client = find_local_client(_service, _instance);

            if (VSOMEIP_ROUTING_CLIENT == its_local_client) {
                // Guard against stale ON_AVAILABLE and send StopSubscribe/Subscribe
                // on SD once the first offer is received if the subscriber is the
                // rm_host itself: hold event_registration_mutex_ across the check
                // + insert so del_routing_info (which also takes this mutex) cannot
                // race in between. If the service was already torn down, skip insertion;
                // the subscription stays in pending_subscriptions_ and is re-sent
                // on the next ADD_SERVICE.
                std::shared_ptr<eventgroupinfo> its_info;
                bool inserted = false;
                {
                    std::scoped_lock its_critical(event_registration_mutex_);

                    its_info = find_eventgroup(_service, _instance, _eventgroup);
                    if (!find_service(_service, _instance) || !its_info) {
                        VSOMEIP_WARNING << "SUBSCRIBE(" << hex4(_client) << "): [" << hex4(_service) << "." << hex4(_instance) << "."
                                        << hex4(_eventgroup) << "] ignored — service not available.";
                        return;
                    }

                    inserted = insert_subscription(_service, _instance, _eventgroup, _event, _filter, _client, its_critical);
                    if (inserted) {
                        // must be done inside lock
                        handle_subscription_state(_client, _service, _instance, _eventgroup, _event);
                    }
                }
                if (inserted) {
                    // lock can't be held here
                    notify_one_current_value(_client, _service, _instance, _eventgroup, _event);

                    const ttl_t configured_ttl(configuration_->get_sd_ttl());
                    discovery_->subscribe(_service, _instance, _eventgroup, _major, configured_ttl,
                                          its_info->is_selective() ? _client : VSOMEIP_ROUTING_CLIENT, its_info);
                }
            } else {
                // This branch should be unreachable: the routing manager only receives
                // SUBSCRIBE for remote (boardnet) services, so its_local_client is
                // always VSOMEIP_ROUTING_CLIENT.
                VSOMEIP_ERROR_P << "Router received subscription for local service from client: 0x" << hex4(_client) << ": ["