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