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_STUB_
7  #define VSOMEIP_V3_ROUTING_MANAGER_STUB_
8  
9  #include <condition_variable>
10  #include <list>
11  #include <map>
12  #include <memory>
13  #include <mutex>
14  #include <set>
15  #include <thread>
16  #include <atomic>
17  #include <unordered_set>
18  
19  #include <boost/asio/io_service.hpp>
20  #include <boost/asio/steady_timer.hpp>
21  
22  #include <vsomeip/handler.hpp>
23  
24  #include "../../endpoints/include/endpoint_host.hpp"
25  #include "../include/routing_host.hpp"
26  
27  #include "types.hpp"
28  
29  namespace vsomeip_v3 {
30  
31  class configuration;
32  struct policy;
33  class routing_manager_stub_host;
34  
35  class routing_manager_stub: public routing_host,
36          public std::enable_shared_from_this<routing_manager_stub> {
37  public:
38      routing_manager_stub(
39              routing_manager_stub_host *_host,
40              const std::shared_ptr<configuration>& _configuration);
41      virtual ~routing_manager_stub();
42  
43      void init();
44      void start();
45      void stop();
46  
47      void on_message(const byte_t *_data, length_t _size, endpoint *_receiver,
48              const boost::asio::ip::address &_destination,
49              client_t _bound_client,
50              credentials_t _credentials,
51              const boost::asio::ip::address &_remote_address,
52              std::uint16_t _remote_port);
53  
54      void on_offer_service(client_t _client, service_t _service,
55              instance_t _instance, major_version_t _major, minor_version_t _minor);
56      void on_stop_offer_service(client_t _client, service_t _service,
57              instance_t _instance,  major_version_t _major, minor_version_t _minor);
58  
59      bool send_subscribe(const std::shared_ptr<endpoint>& _target,
60              client_t _client, service_t _service, instance_t _instance,
61              eventgroup_t _eventgroup, major_version_t _major, event_t _event,
62              remote_subscription_id_t _id);
63  
64      bool send_unsubscribe(const std::shared_ptr<endpoint>& _target,
65              client_t _client, service_t _service,
66              instance_t _instance, eventgroup_t _eventgroup,
67              event_t _event, remote_subscription_id_t _id);
68  
69      bool send_expired_subscription(const std::shared_ptr<endpoint>& _target,
70              client_t _client, service_t _service,
71              instance_t _instance, eventgroup_t _eventgroup,
72              event_t _event, remote_subscription_id_t _id);
73  
74      void send_subscribe_nack(client_t _client, service_t _service,
75              instance_t _instance, eventgroup_t _eventgroup, event_t _event);
76  
77      void send_subscribe_ack(client_t _client, service_t _service,
78              instance_t _instance, eventgroup_t _eventgroup, event_t _event);
79  
80      bool contained_in_routing_info(client_t _client, service_t _service,
81                                     instance_t _instance, major_version_t _major,
82                                     minor_version_t _minor) const;
83  
84      void create_local_receiver();
85      bool send_ping(client_t _client);
86      bool is_registered(client_t _client) const;
87      client_t get_client() const;
88      void handle_credentials(const client_t _client, std::set<service_data_t>& _requests);
89      void handle_requests(const client_t _client, std::set<service_data_t>& _requests);
90  
91      void update_registration(client_t _client, registration_type_e _type);
92  
93      void print_endpoint_status() const;
94  
95      bool send_provided_event_resend_request(client_t _client,
96                                              pending_remote_offer_id_t _id);
97  
98      bool update_security_policy_configuration(uint32_t _uid, uint32_t _gid,
99              const std::shared_ptr<policy> &_policy,
100              const std::shared_ptr<payload> &_payload,
101              const security_update_handler_t &_handler);
102      bool remove_security_policy_configuration(uint32_t _uid, uint32_t _gid,
103              const security_update_handler_t &_handler);
104      void on_security_update_response(pending_security_update_id_t _id,
105              client_t _client);
106  
107      void policy_cache_add(uint32_t _uid, const std::shared_ptr<payload>& _payload);
108      void policy_cache_remove(uint32_t _uid);
109      bool is_policy_cached(uint32_t _uid);
110  
111      bool send_update_security_policy_request(client_t _client,
112              pending_security_update_id_t _update_id, uint32_t _uid,
113              const std::shared_ptr<payload>& _payload);
114      bool send_remove_security_policy_request(client_t _client,
115              pending_security_update_id_t _update_id, uint32_t _uid, uint32_t _gid);
116  
117      bool send_cached_security_policies(client_t _client);
118  
119      bool add_requester_policies(uid_t _uid, gid_t _gid,
120              const std::set<std::shared_ptr<policy> > &_policies);
121      void remove_requester_policies(uid_t _uid, gid_t _gid);
122  
123      void send_suspend() const;
124  
125  private:
126      void broadcast(const std::vector<byte_t> &_command) const;
127  
128      void on_register_application(client_t _client);
129      void on_deregister_application(client_t _client);
130  
131      void distribute_credentials(client_t _hoster, service_t _service, instance_t _instance);
132  
133      void inform_provider(client_t _hoster, service_t _service,
134              instance_t _instance, major_version_t _major, minor_version_t _minor,
135              routing_info_entry_e _entry);
136      void inform_requesters(client_t _hoster, service_t _service,
137              instance_t _instance, major_version_t _major,
138              minor_version_t _minor, routing_info_entry_e _entry,
139              bool _inform_service);
140  
141      void broadcast_ping() const;
142      void on_pong(client_t _client);
143      void start_watchdog();
144      void check_watchdog();
145  
146      void client_registration_func(void);
147      void init_routing_endpoint();
148      void on_ping_timer_expired(boost::system::error_code const &_error);
149      void remove_from_pinged_clients(client_t _client);
set_routing_state(routing_state_e _routing_state)150      void set_routing_state(routing_state_e _routing_state) {
151          (void)_routing_state;
152      };
153  
154      bool is_already_connected(client_t _source, client_t _sink);
155      void create_client_routing_info(const client_t _target);
156      void insert_client_routing_info(client_t _target, routing_info_entry_e _entry,
157              client_t _client, service_t _service = ANY_SERVICE,
158              instance_t _instance = ANY_INSTANCE,
159              major_version_t _major = ANY_MAJOR,
160              minor_version_t _minor = ANY_MINOR);
161      void send_client_routing_info(const client_t _target);
162  
163      void create_offered_services_info(const client_t _target);
164      void insert_offered_services_info(client_t _target,
165              routing_info_entry_e _entry,
166              service_t _service,
167              instance_t _instance,
168              major_version_t _major,
169              minor_version_t _minor);
170      void send_offered_services_info(const client_t _target);
171  
172      void create_client_credentials_info(const client_t _target);
173      void insert_client_credentials_info(client_t _target, std::set<std::pair<uint32_t, uint32_t>> _credentials);
174      void send_client_credentials_info(const client_t _target);
175  
176      void on_client_id_timer_expired(boost::system::error_code const &_error);
177  
178      void get_requester_policies(uid_t _uid, gid_t _gid,
179              std::set<std::shared_ptr<policy> > &_policies) const;
180      bool send_requester_policies(const std::unordered_set<client_t> &_clients,
181              const std::set<std::shared_ptr<policy> > &_policies);
182  
183      void on_security_update_timeout(
184              const boost::system::error_code &_error,
185              pending_security_update_id_t _id,
186              std::shared_ptr<boost::asio::steady_timer> _timer);
187  
188      pending_security_update_id_t pending_security_update_add(
189              const std::unordered_set<client_t> &_clients);
190  
191      std::unordered_set<client_t> pending_security_update_get(
192              pending_security_update_id_t _id);
193  
194      bool pending_security_update_remove(
195              pending_security_update_id_t _id, client_t _client);
196  
197      bool is_pending_security_update_finished(
198              pending_security_update_id_t _id);
199  
200      void add_pending_security_update_handler(
201              pending_security_update_id_t _id,
202              security_update_handler_t _handler);
203      void add_pending_security_update_timer(
204              pending_security_update_id_t _id);
205  
206  private:
207      routing_manager_stub_host *host_;
208      boost::asio::io_service &io_;
209      std::mutex watchdog_timer_mutex_;
210      boost::asio::steady_timer watchdog_timer_;
211  
212      boost::asio::steady_timer client_id_timer_;
213      std::set<client_t> used_client_ids_;
214      std::mutex used_client_ids_mutex_;
215  
216      std::shared_ptr<endpoint> endpoint_;
217      std::shared_ptr<endpoint> local_receiver_;
218      std::mutex local_receiver_mutex_;
219  
220      std::map<client_t,
221              std::pair<uint8_t, std::map<service_t, std::map<instance_t, std::pair<major_version_t, minor_version_t>> > > > routing_info_;
222      mutable std::mutex routing_info_mutex_;
223      std::shared_ptr<configuration> configuration_;
224  
225      bool is_socket_activated_;
226      std::atomic<bool> client_registration_running_;
227      std::shared_ptr<std::thread> client_registration_thread_;
228      std::mutex client_registration_mutex_;
229      std::condition_variable client_registration_condition_;
230  
231      std::map<client_t, std::vector<registration_type_e>> pending_client_registrations_;
232      const std::uint32_t max_local_message_size_;
233      static const std::vector<byte_t> its_ping_;
234      const std::chrono::milliseconds configured_watchdog_timeout_;
235      boost::asio::steady_timer pinged_clients_timer_;
236      std::mutex pinged_clients_mutex_;
237      std::map<client_t, boost::asio::steady_timer::time_point> pinged_clients_;
238  
239      std::map<client_t, std::map<service_t, std::map<instance_t, std::pair<major_version_t, minor_version_t> > > > service_requests_;
240      std::map<client_t, std::set<client_t>> connection_matrix_;
241  
242      std::map<client_t, std::vector<byte_t>> client_routing_info_;
243      std::map<client_t, std::vector<byte_t>> offered_services_info_;
244      std::map<client_t, std::vector<byte_t>> client_credentials_info_;
245  
246      std::mutex pending_security_updates_mutex_;
247      pending_security_update_id_t pending_security_update_id_;
248      std::map<pending_security_update_id_t, std::unordered_set<client_t>> pending_security_updates_;
249  
250      std::recursive_mutex security_update_handlers_mutex_;
251      std::map<pending_security_update_id_t, security_update_handler_t> security_update_handlers_;
252  
253      std::mutex security_update_timers_mutex_;
254      std::map<pending_security_update_id_t, std::shared_ptr<boost::asio::steady_timer>> security_update_timers_;
255  
256      std::mutex updated_security_policies_mutex_;
257      std::map<uint32_t, std::shared_ptr<payload>> updated_security_policies_;
258  
259      mutable std::mutex requester_policies_mutex_;
260      std::map<uint32_t,
261          std::map<uint32_t,
262              std::set<std::shared_ptr<policy> >
263          >
264      > requester_policies_;
265  };
266  
267  } // namespace vsomeip_v3
268  
269  #endif // VSOMEIP_V3_ROUTING_MANAGER_STUB_
270