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