Method add_connection

implementation/endpoints/src/local_server.cpp:183–281

    }
}
void local_server::add_connection(client_t _client, [[maybe_unused]] client_t _expected_id, std::shared_ptr<local_socket> _socket,
                                  std::shared_ptr<local_receive_buffer> _buffer, uint32_t _lc_count, std::string _environment,
                                  boost::asio::ip::address _routing_address, port_t _routing_port) {
    std::unique_lock lock{mtx_};
    if (_lc_count == lc_count_) {
        if (_expected_id != own_client_id_ && _expected_id != VSOMEIP_CLIENT_UNSET) {
            VSOMEIP_WARNING_P << "Connection refused due to wrong client id, expected: " << hex4(_expected_id)
                              << ", actual: " << hex4(own_client_id_) << ", from client: " << hex4(_client);
            // This should not happen for the router, as the router for tcp needs to be configured, an no other
            // application should be able to claim this ip+port
            _socket->stop(true);
            return;
        }
        if (auto rh = routing_host_.lock(); rh) {
            auto const peer_endpoint = _socket->peer_endpoint();
            // Carful: Order matters. First call lazy_load (lazy load of config for this client), before trying to create
            // the endpoint (as the creation method is trying to reason whether the connection is allowed based on the loaded config).
            // Carful: These calls should happen under the lock to guarantee consistency, and before the endpoint might be removed
            // again from the map
            rh->lazy_load(_environment);

            std::stringstream ss;

            if (is_router_) {
                ss << "Assigned client ID 0x" << hex4(_client) << " to \"" << utility::get_client_name(configuration_, _client) << "\" (\""
                   << _environment << "\")";

                // check if is uds socket
                if (_socket->own_port() != VSOMEIP_SEC_PORT_UNUSED) {
                    ss << " @ " << peer_endpoint.address() << ":" << peer_endpoint.port();
                } else {
                    vsomeip_sec_client_t sec_client{};
                    _socket->update(sec_client, *configuration_);
                    ss << " @ " << sec_client.user << "/" << sec_client.group;
                    if (!_routing_address.is_unspecified() && _routing_port != ILLEGAL_PORT) {
                        ss << " (guest: " << _routing_address.to_string() << ":" << _routing_port << ")";
                    }
                }
            }

            auto ep = local_endpoint::create_server_ep(
                    local_endpoint_context{io_, configuration_, routing_host_},
                    local_endpoint_params{_client, rh->get_client(), std::move(_environment), std::move(_socket),
                                          // For TCP sockets use the real peer endpoint directly.
                                          // For UDS, fall back to what the client advertised in assign_client_command.
                                          !peer_endpoint.address().is_unspecified() ? peer_endpoint.address() : _routing_address,
                                          peer_endpoint.port() != 0 ? static_cast<port_t>(peer_endpoint.port()) : _routing_port},
                    std::move(_buffer));
            if (!ep) {
                VSOMEIP_ERROR_P << "endpoint creation failed for client: " << hex4(_client) << ", self: " << this;
                // socket is closed already in the create_server_ep on failure
                // clean-up id
                utility::release_client_id(configuration_->get_network(), _client);
                return;
            }

            if (std::find(blocked_addresses_.begin(), blocked_addresses_.end(), peer_endpoint.address()) != blocked_addresses_.end()) {
                VSOMEIP_WARNING_P << "connection from client " << hex4(_client) << ", " << ep->name() << ", " << ep->name()