1 // Copyright (C) 2014-2018 Bayerische Motoren Werke Aktiengesellschaft (BMW AG) 2 // This Source Code Form is subject to the terms of the Mozilla Public 3 // License, v. 2.0. If a copy of the MPL was not distributed with this 4 // file, You can obtain one at http://mozilla.org/MPL/2.0/. 5 6 #ifndef VSOMEIP_V3_ROUTING_MANAGER_IMPL_HPP_ 7 #define VSOMEIP_V3_ROUTING_MANAGER_IMPL_HPP_ 8 9 #include <map> 10 #include <memory> 11 #include <mutex> 12 #include <vector> 13 #include <list> 14 #include <unordered_set> 15 16 #include <boost/asio/ip/address.hpp> 17 #include <boost/asio/io_service.hpp> 18 #include <boost/asio/steady_timer.hpp> 19 20 #include <vsomeip/primitive_types.hpp> 21 #include <vsomeip/handler.hpp> 22 23 #include "routing_manager_base.hpp" 24 #include "routing_manager_stub_host.hpp" 25 #include "types.hpp" 26 27 #include "../../endpoints/include/netlink_connector.hpp" 28 #include "../../service_discovery/include/service_discovery_host.hpp" 29 #include "../../endpoints/include/endpoint_manager_impl.hpp" 30 31 32 namespace vsomeip_v3 { 33 34 class configuration; 35 class deserializer; 36 class eventgroupinfo; 37 class routing_manager_host; 38 class routing_manager_stub; 39 class servicegroup; 40 class serializer; 41 class service_endpoint; 42 43 namespace sd { 44 class service_discovery; 45 } // namespace sd 46 47 namespace e2e { 48 class e2e_provider; 49 } // namespace e2e 50 51 class routing_manager_impl: public routing_manager_base, 52 public routing_manager_stub_host, 53 public sd::service_discovery_host { 54 public: 55 routing_manager_impl(routing_manager_host *_host); 56 ~routing_manager_impl(); 57 58 boost::asio::io_service & get_io(); 59 client_t get_client() const; 60 61 void init(); 62 void start(); 63 void stop(); 64 65 bool offer_service(client_t _client, 66 service_t _service, instance_t _instance, 67 major_version_t _major, minor_version_t _minor); 68 69 void stop_offer_service(client_t _client, 70 service_t _service, instance_t _instance, 71 major_version_t _major, minor_version_t _minor); 72 73 void request_service(client_t _client, 74 service_t _service, instance_t _instance, 75 major_version_t _major, minor_version_t _minor); 76 77 void release_service(client_t _client, 78 service_t _service, instance_t _instance); 79 80 void subscribe(client_t _client, uid_t _uid, gid_t _gid, 81 service_t _service, instance_t _instance, 82 eventgroup_t _eventgroup, major_version_t _major, event_t _event); 83 84 void unsubscribe(client_t _client, uid_t _uid, gid_t _gid, 85 service_t _service, instance_t _instance, 86 eventgroup_t _eventgroup, event_t _event); 87 88 bool send(client_t _client, std::shared_ptr<message> _message); 89 90 bool send(client_t _client, const byte_t *_data, uint32_t _size, 91 instance_t _instance, bool _reliable, 92 client_t _bound_client = VSOMEIP_ROUTING_CLIENT, 93 credentials_t _credentials = {ANY_UID, ANY_GID}, 94 uint8_t _status_check = 0, bool _sent_from_remote = false); 95 96 bool send_to(const client_t _client, 97 const std::shared_ptr<endpoint_definition> &_target, 98 std::shared_ptr<message> _message); 99 100 bool send_to(const std::shared_ptr<endpoint_definition> &_target, 101 const byte_t *_data, uint32_t _size, 102 instance_t _instance); 103 104 bool send_via_sd(const std::shared_ptr<endpoint_definition> &_target, 105 const byte_t *_data, uint32_t _size, uint16_t _sd_port); 106 107 void register_event(client_t _client, 108 service_t _service, instance_t _instance, 109 event_t _notifier, 110 const std::set<eventgroup_t> &_eventgroups, 111 const event_type_e _type, 112 reliability_type_e _reliability, 113 std::chrono::milliseconds _cycle, bool _change_resets_cycle, 114 bool _update_on_change, 115 epsilon_change_func_t _epsilon_change_func, 116 bool _is_provided, bool _is_shadow, bool _is_cache_placeholder); 117 118 void register_shadow_event(client_t _client, 119 service_t _service, instance_t _instance, 120 event_t _notifier, 121 const std::set<eventgroup_t> &_eventgroups, 122 event_type_e _type, reliability_type_e _reliability, 123 bool _is_provided); 124 125 void unregister_shadow_event(client_t _client, service_t _service, 126 instance_t _instance, event_t _event, 127 bool _is_provided); 128 129 void notify_one(service_t _service, instance_t _instance, 130 event_t _event, std::shared_ptr<payload> _payload, 131 client_t _client, bool _force 132 #ifdef VSOMEIP_ENABLE_COMPAT 133 , bool _remote_subscriber 134 #endif 135 ); 136 137 void on_subscribe_ack(client_t _client, service_t _service, 138 instance_t _instance, eventgroup_t _eventgroup, event_t _event, 139 remote_subscription_id_t _id); 140 141 void on_subscribe_nack(client_t _client, service_t _service, 142 instance_t _instance, eventgroup_t _eventgroup, event_t _event, 143 remote_subscription_id_t _id, bool _simulated); 144 145 146 // interface to stub find_local(client_t _client)147 inline std::shared_ptr<endpoint> find_local(client_t _client) { 148 return ep_mgr_->find_local(_client); 149 } find_or_create_local(client_t _client)150 inline std::shared_ptr<endpoint> find_or_create_local( 151 client_t _client) { 152 return ep_mgr_->find_or_create_local(_client); 153 } 154 155 std::shared_ptr<endpoint> find_or_create_remote_client( 156 service_t _service, instance_t _instance, bool _reliable); 157 158 void remove_local(client_t _client, bool _remove_uid); 159 void on_stop_offer_service(client_t _client, 160 service_t _service, instance_t _instance, 161 major_version_t _major, minor_version_t _minor); 162 163 void on_availability(service_t _service, instance_t _instance, 164 bool _is_available, 165 major_version_t _major, minor_version_t _minor); 166 167 void on_pong(client_t _client); 168 169 void on_subscribe_ack_with_multicast( 170 service_t _service, instance_t _instance, 171 const boost::asio::ip::address &_sender, 172 const boost::asio::ip::address &_address, uint16_t _port); 173 void on_unsubscribe_ack(client_t _client, service_t _service, 174 instance_t _instance, eventgroup_t _eventgroup, 175 remote_subscription_id_t _id); 176 177 void on_connect(const std::shared_ptr<endpoint>& _endpoint); 178 void on_disconnect(const std::shared_ptr<endpoint>& _endpoint); 179 180 void on_message(const byte_t *_data, length_t _size, endpoint *_receiver, 181 const boost::asio::ip::address &_destination, 182 client_t _bound_client, credentials_t _credentials, 183 const boost::asio::ip::address &_remote_address, 184 std::uint16_t _remote_port); 185 bool on_message(service_t _service, instance_t _instance, 186 const byte_t *_data, length_t _size, bool _reliable, 187 client_t _bound_client, credentials_t _credentials, 188 uint8_t _check_status = 0, 189 bool _is_from_remote = false); 190 void on_notification(client_t _client, service_t _service, 191 instance_t _instance, const byte_t *_data, length_t _size, 192 bool _notify_one); 193 194 bool offer_service_remotely(service_t _service, instance_t _instance, 195 std::uint16_t _port, bool _reliable, 196 bool _magic_cookies_enabled); 197 bool stop_offer_service_remotely(service_t _service, instance_t _instance, 198 std::uint16_t _port, bool _reliable, 199 bool _magic_cookies_enabled); 200 201 // interface "service_discovery_host" 202 typedef std::map<std::string, std::shared_ptr<servicegroup> > servicegroups_t; 203 const servicegroups_t & get_servicegroups() const; 204 std::shared_ptr<eventgroupinfo> find_eventgroup(service_t _service, 205 instance_t _instance, eventgroup_t _eventgroup) const; 206 services_t get_offered_services() const; 207 std::shared_ptr<serviceinfo> get_offered_service( 208 service_t _service, instance_t _instance) const; 209 std::map<instance_t, std::shared_ptr<serviceinfo>> get_offered_service_instances( 210 service_t _service) const; 211 212 std::shared_ptr<endpoint> create_service_discovery_endpoint(const std::string &_address, 213 uint16_t _port, bool _reliable); 214 void init_routing_info(); 215 void add_routing_info(service_t _service, instance_t _instance, 216 major_version_t _major, minor_version_t _minor, ttl_t _ttl, 217 const boost::asio::ip::address &_reliable_address, 218 uint16_t _reliable_port, 219 const boost::asio::ip::address &_unreliable_address, 220 uint16_t _unreliable_port); 221 void del_routing_info(service_t _service, instance_t _instance, 222 bool _has_reliable, bool _has_unreliable); 223 void update_routing_info(std::chrono::milliseconds _elapsed); 224 225 // Handle remote subscriptions / subscription acks 226 void on_remote_subscribe( 227 std::shared_ptr<remote_subscription> &_subscription, 228 const remote_subscription_callback_t& _callback); 229 void on_remote_unsubscribe( 230 std::shared_ptr<remote_subscription> &_subscription); 231 232 void expire_subscriptions(const boost::asio::ip::address &_address); 233 void expire_subscriptions(const boost::asio::ip::address &_address, 234 std::uint16_t _port, bool _reliable); 235 void expire_subscriptions(const boost::asio::ip::address &_address, 236 const configuration::port_range_t& _range, 237 bool _reliable); 238 void expire_services(const boost::asio::ip::address &_address); 239 void expire_services(const boost::asio::ip::address &_address, 240 std::uint16_t _port , bool _reliable); 241 void expire_services(const boost::asio::ip::address &_address, 242 const configuration::port_range_t& _range , bool _reliable); 243 244 std::chrono::steady_clock::time_point expire_subscriptions(bool _force); 245 246 void register_client_error_handler(client_t _client, 247 const std::shared_ptr<endpoint> &_endpoint); 248 void handle_client_error(client_t _client); 249 std::shared_ptr<endpoint_manager_impl> get_endpoint_manager() const; 250 251 void set_routing_state(routing_state_e _routing_state); 252 send_get_offered_services_info(client_t _client,offer_type_e _offer_type)253 void send_get_offered_services_info(client_t _client, offer_type_e _offer_type) { 254 (void) _client; 255 (void) _offer_type; 256 } 257 258 void send_initial_events(service_t _service, instance_t _instance, 259 eventgroup_t _eventgroup, 260 const std::shared_ptr<endpoint_definition> &_subscriber); 261 262 void print_stub_status() const; 263 264 void send_error(return_code_e _return_code, const byte_t *_data, 265 length_t _size, instance_t _instance, bool _reliable, 266 endpoint* const _receiver, 267 const boost::asio::ip::address &_remote_address, 268 std::uint16_t _remote_port); 269 void service_endpoint_connected(service_t _service, instance_t _instance, 270 major_version_t _major, minor_version_t _minor, 271 const std::shared_ptr<endpoint>& _endpoint, 272 bool _unreliable_only); 273 void service_endpoint_disconnected(service_t _service, instance_t _instance, 274 major_version_t _major, minor_version_t _minor, 275 const std::shared_ptr<endpoint>& _endpoint); 276 277 void register_sd_acceptance_handler(const sd_acceptance_handler_t& _handler) const; 278 void register_reboot_notification_handler(const reboot_notification_handler_t& _handler) const; 279 void register_routing_ready_handler(const routing_ready_handler_t& _handler); 280 void register_routing_state_handler(const routing_state_handler_t& _handler); 281 void sd_acceptance_enabled(const boost::asio::ip::address& _address, 282 const configuration::port_range_t& _range, 283 bool _reliable); 284 285 void on_resend_provided_events_response(pending_remote_offer_id_t _id); 286 client_t find_local_client(service_t _service, instance_t _instance); 287 std::set<client_t> find_local_clients(service_t _service, instance_t _instance); 288 bool is_subscribe_to_any_event_allowed(credentials_t _credentials, client_t _client, 289 service_t _service, instance_t _instance, eventgroup_t _eventgroup); 290 291 bool update_security_policy_configuration(uint32_t _uid, uint32_t _gid, 292 const std::shared_ptr<policy> &_policy, 293 const std::shared_ptr<payload> &_payload, 294 const security_update_handler_t &_handler); 295 bool remove_security_policy_configuration(uint32_t _uid, uint32_t _gid, 296 const security_update_handler_t &_handler); 297 298 private: 299 bool offer_service(client_t _client, 300 service_t _service, instance_t _instance, 301 major_version_t _major, minor_version_t _minor, 302 bool _must_queue); 303 304 void stop_offer_service(client_t _client, 305 service_t _service, instance_t _instance, 306 major_version_t _major, minor_version_t _minor, 307 bool _must_queue); 308 309 bool deliver_message(const byte_t *_data, length_t _size, 310 instance_t _instance, bool _reliable, client_t _bound_client, 311 credentials_t _credentials, 312 uint8_t _status_check = 0, bool _is_from_remote = false); 313 bool deliver_notification(service_t _service, instance_t _instance, 314 const byte_t *_data, length_t _length, bool _reliable, client_t _bound_client, 315 credentials_t _credentials, 316 uint8_t _status_check = 0, bool _is_from_remote = false); 317 318 319 void init_service_info(service_t _service, 320 instance_t _instance, bool _is_local_service); 321 322 bool is_field(service_t _service, instance_t _instance, 323 event_t _event) const; 324 325 std::shared_ptr<endpoint> find_remote_client(service_t _service, 326 instance_t _instance, bool _reliable, client_t _client); 327 328 std::shared_ptr<endpoint> create_remote_client(service_t _service, 329 instance_t _instance, bool _reliable, client_t _client); 330 331 void clear_client_endpoints(service_t _service, instance_t _instance, bool _reliable); 332 void clear_multicast_endpoints(service_t _service, instance_t _instance); 333 334 std::set<eventgroup_t> get_subscribed_eventgroups(service_t _service, 335 instance_t _instance); 336 337 void clear_targets_and_pending_sub_from_eventgroups(service_t _service, instance_t _instance); 338 void clear_remote_subscriber(service_t _service, instance_t _instance); 339 340 return_code_e check_error(const byte_t *_data, length_t _size, 341 instance_t _instance); 342 343 bool supports_selective(service_t _service, instance_t _instance); 344 345 void clear_remote_subscriber(service_t _service, instance_t _instance, 346 client_t _client, 347 const std::shared_ptr<endpoint_definition> &_target); 348 349 void log_version_timer_cbk(boost::system::error_code const & _error); 350 351 bool handle_local_offer_service(client_t _client, service_t _service, 352 instance_t _instance, major_version_t _major,minor_version_t _minor); 353 354 void send_subscribe(client_t _client, service_t _service, 355 instance_t _instance, eventgroup_t _eventgroup, 356 major_version_t _major, event_t _event); 357 358 void on_net_interface_or_route_state_changed(bool _is_interface, 359 std::string _if, 360 bool _available); 361 362 void start_ip_routing(); 363 364 void requested_service_add(client_t _client, service_t _service, 365 instance_t _instance, major_version_t _major, 366 minor_version_t _minor); 367 void requested_service_remove(client_t _client, service_t _service, 368 instance_t _instance); 369 370 void call_sd_endpoint_connected(const boost::system::error_code& _error, 371 service_t _service, instance_t _instance, 372 const std::shared_ptr<endpoint>& _endpoint, 373 std::shared_ptr<boost::asio::steady_timer> _timer); 374 375 bool create_placeholder_event_and_subscribe(service_t _service, 376 instance_t _instance, 377 eventgroup_t _eventgroup, 378 event_t _event, 379 client_t _client); 380 381 void handle_subscription_state(client_t _client, service_t _service, instance_t _instance, 382 eventgroup_t _eventgroup, event_t _event); 383 384 void memory_log_timer_cbk(boost::system::error_code const & _error); 385 void status_log_timer_cbk(boost::system::error_code const & _error); 386 387 void send_subscription(const client_t _offering_client, 388 const service_t _service, const instance_t _instance, 389 const eventgroup_t _eventgroup, const major_version_t _major, 390 const std::set<client_t> &_clients, 391 const remote_subscription_id_t _id); 392 393 void send_unsubscription(client_t _offering_client, 394 const service_t _service, const instance_t _instance, 395 const eventgroup_t _eventgroup, const major_version_t _major, 396 const std::set<client_t> &_removed, 397 const remote_subscription_id_t _id); 398 399 void send_expired_subscription(client_t _offering_client, 400 const service_t _service, const instance_t _instance, 401 const eventgroup_t _eventgroup, 402 const std::set<client_t> &_removed, 403 const remote_subscription_id_t _id); 404 405 void cleanup_server_endpoint(service_t _service, 406 const std::shared_ptr<endpoint>& _endpoint); 407 408 pending_remote_offer_id_t pending_remote_offer_add(service_t _service, 409 instance_t _instance); 410 std::pair<service_t, instance_t> pending_remote_offer_remove( 411 pending_remote_offer_id_t _id); 412 413 bool insert_offer_command(service_t _service, instance_t _instance, uint8_t _command, 414 client_t _client, major_version_t _major, minor_version_t _minor); 415 bool erase_offer_command(service_t _service, instance_t _instance); 416 417 bool is_last_stop_callback(const uint32_t _callback_id); 418 419 bool insert_event_statistics(service_t _service, instance_t _instance, 420 method_t _method, length_t _length); 421 void statistics_log_timer_cbk(boost::system::error_code const & _error); 422 423 void send_suspend() const; 424 425 private: 426 std::shared_ptr<routing_manager_stub> stub_; 427 std::shared_ptr<sd::service_discovery> discovery_; 428 429 std::mutex requested_services_mutex_; 430 std::map<client_t, 431 std::map<service_t, 432 std::map<instance_t, 433 std::set<std::pair<major_version_t, minor_version_t>>>>> requested_services_; 434 435 std::mutex remote_subscribers_mutex_; 436 std::map<service_t, std::map<instance_t, std::map<client_t, 437 std::set<std::shared_ptr<endpoint_definition>>>>> remote_subscribers_; 438 439 std::shared_ptr<serviceinfo> sd_info_; 440 441 std::mutex version_log_timer_mutex_; 442 boost::asio::steady_timer version_log_timer_; 443 444 bool if_state_running_; 445 bool sd_route_set_; 446 bool routing_running_; 447 std::mutex pending_sd_offers_mutex_; 448 std::vector<std::pair<service_t, instance_t>> pending_sd_offers_; 449 #ifndef _WIN32 450 std::shared_ptr<netlink_connector> netlink_connector_; 451 #endif 452 453 std::mutex pending_offers_mutex_; 454 // map to store pending offers. 455 // 1st client id in tuple: client id of new offering application 456 // 2nd client id in tuple: client id of previously/stored offering application 457 std::map<service_t, 458 std::map<instance_t, 459 std::tuple<major_version_t, minor_version_t, 460 client_t, client_t>>> pending_offers_; 461 462 std::mutex pending_subscription_mutex_; 463 464 std::mutex remote_subscription_state_mutex_; 465 std::map<std::tuple<service_t, instance_t, eventgroup_t, client_t>, 466 subscription_state_e> remote_subscription_state_; 467 468 std::shared_ptr<e2e::e2e_provider> e2e_provider_; 469 470 std::mutex status_log_timer_mutex_; 471 boost::asio::steady_timer status_log_timer_; 472 473 std::mutex memory_log_timer_mutex_; 474 boost::asio::steady_timer memory_log_timer_; 475 476 std::shared_ptr<endpoint_manager_impl> ep_mgr_impl_; 477 478 reboot_notification_handler_t reboot_notification_handler_; 479 480 routing_ready_handler_t routing_ready_handler_; 481 routing_state_handler_t routing_state_handler_; 482 483 std::mutex pending_remote_offers_mutex_; 484 pending_remote_offer_id_t pending_remote_offer_id_; 485 std::map<pending_remote_offer_id_t, std::pair<service_t, instance_t>> pending_remote_offers_; 486 487 std::chrono::steady_clock::time_point last_resume_; 488 489 std::mutex offer_serialization_mutex_; 490 std::map<std::pair<service_t, instance_t>, std::deque<std::tuple<uint8_t, client_t, major_version_t, minor_version_t>>> offer_commands_; 491 492 std::mutex callback_counts_mutex_; 493 std::map<uint32_t, uint16_t> callback_counts_; 494 495 std::mutex statistics_log_timer_mutex_; 496 boost::asio::steady_timer statistics_log_timer_; 497 498 std::mutex message_statistics_mutex_; 499 std::map<std::tuple<service_t, instance_t, method_t>, 500 msg_statistic_t> message_statistics_; 501 std::tuple<service_t, instance_t, method_t> message_to_discard_; 502 uint32_t ignored_statistics_counter_; 503 504 // synchronize update_remote_subscription() and send_(un)subscription() 505 std::mutex update_remote_subscription_mutex_; 506 }; 507 508 } // namespace vsomeip_v3 509 510 #endif // VSOMEIP_V3_ROUTING_MANAGER_IMPL_HPP_ 511