Method deliver_notification

implementation/routing/src/routing_manager_impl.cpp:1355–1448

}

bool routing_manager_impl::deliver_notification(service_t _service, instance_t _instance, const byte_t* _data, length_t _length,
                                                bool _reliable, [[maybe_unused]] client_t _bound_client,
                                                [[maybe_unused]] const vsomeip_sec_client_t* _sec_client, uint8_t _status_check,
                                                bool _is_from_remote) {

    std::scoped_lock lck(event_registration_mutex_);
    event_t its_event_id = bithelper::read_uint16_be(&_data[VSOMEIP_METHOD_POS_MIN]);
    client_t its_client_id = bithelper::read_uint16_be(&_data[VSOMEIP_CLIENT_POS_MIN]);

    std::shared_ptr<event> its_event = find_event(_service, _instance, its_event_id);
    if (its_event) {
        if (!its_event->is_provided()) {
            if (its_event->get_subscribers().size() == 0) {
                // no subscribers for this specific event / check subscriptions
                // to other events of the event's eventgroups
                bool cache_event = false;
                for (const auto eg : its_event->get_eventgroups()) {
                    std::shared_ptr<eventgroupinfo> egi = find_eventgroup(_service, _instance, eg);
                    if (egi) {
                        for (const auto& e : egi->get_events()) {
                            cache_event = (e->get_subscribers().size() > 0);
                            if (cache_event) {
                                break;
                            }
                        }
                        if (cache_event) {
                            break;
                        }
                    }
                }
                if (!cache_event) {
                    VSOMEIP_WARNING_P << "Dropping [" << hex4(_service) << "." << hex4(_instance) << "." << hex4(its_event_id)
                                      << "]. No subscription to corresponding eventgroup.";
                    return true; // as there is nothing to do
                }
            }
        }

        // Update the event with information which might not have been previously available.
        if (auto service = find_service(_service, _instance)) {
            its_event->set_version(service->get_major());
            its_event->set_reliability(_reliable ? reliability_type_e::RT_RELIABLE : reliability_type_e::RT_UNRELIABLE);
        }

        auto its_length = utility::get_payload_size(_data, _length);
        auto its_payload = runtime::get()->create_payload(&_data[VSOMEIP_PAYLOAD_POS], its_length);

        // incoming events statistics
        (void)insert_event_statistics(_service, _instance, its_event_id, its_length);

        // Ignore the filter for messages coming from other local clients
        // as the filter was already applied there.
        auto its_subscribers = its_event->update_and_get_filtered_subscribers(its_payload, _is_from_remote);
        if (its_event->get_type() != event_type_e::ET_SELECTIVE_EVENT) {
            for (const auto its_local_client : its_subscribers) {
                if (std::shared_ptr<local_endpoint> its_local_target = find_routing_endpoint(its_local_client); its_local_target) {
                    send_local(its_local_target, VSOMEIP_ROUTING_CLIENT, _data, _length, _instance, _reliable, protocol::id_e::SEND_ID,
                               _status_check, VSOMEIP_ROUTING_CLIENT);