1 // Copyright (C) 2014-2017 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_PROXY_HPP 7 #define VSOMEIP_V3_ROUTING_MANAGER_PROXY_HPP 8 9 #include <map> 10 #include <mutex> 11 #include <atomic> 12 #include <tuple> 13 14 #include <boost/asio/io_service.hpp> 15 #include <boost/asio/steady_timer.hpp> 16 17 #include "routing_manager_base.hpp" 18 #include "types.hpp" 19 #include <vsomeip/enumeration_types.hpp> 20 #include <vsomeip/handler.hpp> 21 22 namespace vsomeip_v3 { 23 24 class configuration; 25 class event; 26 class routing_manager_host; 27 28 class routing_manager_proxy: public routing_manager_base { 29 public: 30 routing_manager_proxy(routing_manager_host *_host, bool _client_side_logging, 31 const std::set<std::tuple<service_t, instance_t> > & _client_side_logging_filter); 32 virtual ~routing_manager_proxy(); 33 34 void init(); 35 void start(); 36 void stop(); 37 38 std::shared_ptr<configuration> get_configuration() const; 39 40 bool offer_service(client_t _client, 41 service_t _service, instance_t _instance, 42 major_version_t _major, minor_version_t _minor); 43 44 void stop_offer_service(client_t _client, 45 service_t _service, instance_t _instance, 46 major_version_t _major, minor_version_t _minor); 47 48 void request_service(client_t _client, 49 service_t _service, instance_t _instance, 50 major_version_t _major, minor_version_t _minor); 51 52 void release_service(client_t _client, 53 service_t _service, instance_t _instance); 54 55 void subscribe(client_t _client, uid_t _uid, gid_t _gid, 56 service_t _service, instance_t _instance, 57 eventgroup_t _eventgroup, major_version_t _major, 58 event_t _event); 59 60 void unsubscribe(client_t _client, uid_t _uid, gid_t _gid, 61 service_t _service, instance_t _instance, 62 eventgroup_t _eventgroup, event_t _event); 63 64 bool send(client_t _client, const byte_t *_data, uint32_t _size, 65 instance_t _instance, bool _reliable, 66 client_t _bound_client = VSOMEIP_ROUTING_CLIENT, 67 credentials_t _credentials = {ANY_UID, ANY_GID}, 68 uint8_t _status_check = 0, bool _sent_from_remote = false); 69 70 bool send_to(const client_t _client, 71 const std::shared_ptr<endpoint_definition> &_target, 72 std::shared_ptr<message> _message); 73 74 bool send_to(const std::shared_ptr<endpoint_definition> &_target, 75 const byte_t *_data, uint32_t _size, instance_t _instance); 76 77 void register_event(client_t _client, 78 service_t _service, instance_t _instance, 79 event_t _notifier, 80 const std::set<eventgroup_t> &_eventgroups, 81 const event_type_e _type, 82 reliability_type_e _reliability, 83 std::chrono::milliseconds _cycle, bool _change_resets_cycle, 84 bool _update_on_change, 85 epsilon_change_func_t _epsilon_change_func, 86 bool _is_provided, bool _is_shadow, bool _is_cache_placeholder); 87 88 void unregister_event(client_t _client, service_t _service, 89 instance_t _instance, event_t _notifier, bool _is_provided); 90 91 void on_connect(const std::shared_ptr<endpoint>& _endpoint); 92 void on_disconnect(const std::shared_ptr<endpoint>& _endpoint); 93 void on_message(const byte_t *_data, length_t _size, endpoint *_receiver, 94 const boost::asio::ip::address &_destination, 95 client_t _bound_client, 96 credentials_t _credentials, 97 const boost::asio::ip::address &_remote_address, 98 std::uint16_t _remote_port); 99 100 void on_routing_info(const byte_t *_data, uint32_t _size); 101 102 void register_client_error_handler(client_t _client, 103 const std::shared_ptr<endpoint> &_endpoint); 104 void handle_client_error(client_t _client); 105 106 void on_offered_services_info(const byte_t *_data, uint32_t _size); 107 108 void send_get_offered_services_info(client_t _client, offer_type_e _offer_type); 109 110 private: 111 void assign_client(); 112 void register_application(); 113 void deregister_application(); 114 115 void reconnect(const std::unordered_set<client_t> &_clients); 116 117 void send_pong() const; 118 void send_offer_service(client_t _client, service_t _service, 119 instance_t _instance, major_version_t _major, 120 minor_version_t _minor); 121 void send_release_service(client_t _client, 122 service_t _service, instance_t _instance); 123 void send_register_event(client_t _client, 124 service_t _service, instance_t _instance, 125 event_t _notifier, 126 const std::set<eventgroup_t> &_eventgroups, 127 const event_type_e _type, reliability_type_e _reliability, 128 bool _is_provided); 129 void send_subscribe(client_t _client, service_t _service, 130 instance_t _instance, eventgroup_t _eventgroup, 131 major_version_t _major, event_t _event); 132 133 void send_subscribe_nack(client_t _subscriber, service_t _service, 134 instance_t _instance, eventgroup_t _eventgroup, event_t _event, 135 remote_subscription_id_t _id); 136 137 void send_subscribe_ack(client_t _subscriber, service_t _service, 138 instance_t _instance, eventgroup_t _eventgroup, event_t _event, 139 remote_subscription_id_t _id); 140 141 bool is_field(service_t _service, instance_t _instance, 142 event_t _event) const; 143 144 void on_subscribe_nack(client_t _client, service_t _service, 145 instance_t _instance, eventgroup_t _eventgroup, event_t _event); 146 147 void on_subscribe_ack(client_t _client, service_t _service, 148 instance_t _instance, eventgroup_t _eventgroup, event_t _event); 149 150 void cache_event_payload(const std::shared_ptr<message> &_message); 151 152 void on_stop_offer_service(service_t _service, instance_t _instance, 153 major_version_t _major, minor_version_t _minor); 154 155 void send_pending_commands(); 156 157 void init_receiver(); 158 159 void notify_remote_initially(service_t _service, instance_t _instance, 160 eventgroup_t _eventgroup, const std::set<event_t> &_events_to_exclude); 161 162 uint32_t get_remote_subscriber_count(service_t _service, instance_t _instance, 163 eventgroup_t _eventgroup, bool _increment); 164 void clear_remote_subscriber_count(service_t _service, instance_t _instance); 165 166 void assign_client_timeout_cbk(boost::system::error_code const &_error); 167 168 void register_application_timeout_cbk(boost::system::error_code const &_error); 169 170 void send_registered_ack(); 171 set_routing_state(routing_state_e _routing_state)172 void set_routing_state(routing_state_e _routing_state) { 173 (void)_routing_state; 174 }; 175 176 bool is_client_known(client_t _client); 177 178 bool create_placeholder_event_and_subscribe( 179 service_t _service, instance_t _instance, 180 eventgroup_t _eventgroup, event_t _notifier, client_t _client); 181 182 void request_debounce_timeout_cbk(boost::system::error_code const &_error); 183 184 void send_request_services(std::set<service_data_t>& _requests); 185 186 void send_unsubscribe_ack(service_t _service, instance_t _instance, 187 eventgroup_t _eventgroup, remote_subscription_id_t _id); 188 189 void resend_provided_event_registrations(); 190 void send_resend_provided_event_response(pending_remote_offer_id_t _id); 191 192 void send_update_security_policy_response(pending_security_update_id_t _update_id); 193 void send_remove_security_policy_response(pending_security_update_id_t _update_id); 194 void on_update_security_credentials(const byte_t *_data, uint32_t _size); 195 void on_client_assign_ack(const client_t &_client); 196 197 void on_suspend(); 198 199 private: 200 enum class inner_state_type_e : std::uint8_t { 201 ST_REGISTERED = 0x0, 202 ST_DEREGISTERED = 0x1, 203 ST_REGISTERING = 0x2, 204 ST_ASSIGNING = 0x3, 205 ST_ASSIGNED = 0x4 206 }; 207 208 std::atomic<bool> is_connected_; 209 std::atomic<bool> is_started_; 210 inner_state_type_e state_; 211 212 std::shared_ptr<endpoint> sender_; // --> stub 213 std::shared_ptr<endpoint> receiver_; // --> from everybody 214 215 std::mutex known_clients_mutex_; 216 std::unordered_set<client_t> known_clients_; 217 218 std::set<service_data_t> pending_offers_; 219 std::set<service_data_t> requests_; 220 std::set<service_data_t> requests_to_debounce_; 221 222 struct event_data_t { 223 service_t service_; 224 instance_t instance_; 225 event_t notifier_; 226 event_type_e type_; 227 reliability_type_e reliability_; 228 bool is_provided_; 229 std::set<eventgroup_t> eventgroups_; 230 operator <vsomeip_v3::routing_manager_proxy::event_data_t231 bool operator<(const event_data_t &_other) const { 232 return std::tie(service_, instance_, notifier_, 233 type_, reliability_, is_provided_, eventgroups_) 234 < std::tie(_other.service_, _other.instance_, 235 _other.notifier_, _other.type_, _other.reliability_, 236 _other.is_provided_, _other.eventgroups_); 237 } 238 }; 239 std::set<event_data_t> pending_event_registrations_; 240 241 std::map<client_t, std::set<subscription_data_t>> pending_incoming_subscripitons_; 242 std::recursive_mutex incoming_subscriptions_mutex_; 243 244 std::mutex state_mutex_; 245 std::condition_variable state_condition_; 246 247 std::map<service_t, 248 std::map<instance_t, std::map<eventgroup_t, uint32_t > > > remote_subscriber_count_; 249 std::mutex remote_subscriber_count_mutex_; 250 251 mutable std::mutex sender_mutex_; 252 253 boost::asio::steady_timer register_application_timer_; 254 255 std::mutex request_timer_mutex_; 256 boost::asio::steady_timer request_debounce_timer_; 257 bool request_debounce_timer_running_; 258 259 const bool client_side_logging_; 260 const std::set<std::tuple<service_t, instance_t> > client_side_logging_filter_; 261 262 std::mutex stop_mutex_; 263 }; 264 265 } // namespace vsomeip_v3 266 267 #endif // VSOMEIP_V3_ROUTING_MANAGER_PROXY_HPP_ 268