vSomeIP 2.2.42.2.4

1 files changed, 122 insertions, 35 deletions

diff --git a/implementation/service_discovery/include/service_discovery_impl.hpp b/implementation/service_discovery/include/service_discovery_impl.hpp
index 7efb6eb..4e64328 100644
--- a/implementation/service_discovery/include/service_discovery_impl.hpp
+++ b/implementation/service_discovery/include/service_discovery_impl.hpp
@@ -1,4 +1,4 @@
-// Copyright (C) 2014-2015 Bayerische Motoren Werke Aktiengesellschaft (BMW AG)
+// Copyright (C) 2014-2016 Bayerische Motoren Werke Aktiengesellschaft (BMW AG)
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at http://mozilla.org/MPL/2.0/.
@@ -14,8 +14,11 @@
 #include <boost/asio/system_timer.hpp>
 
 #include "service_discovery.hpp"
+#include "../../endpoints/include/endpoint_definition.hpp"
 #include "../../routing/include/types.hpp"
 #include "ip_option_impl.hpp"
+#include "ipv4_option_impl.hpp"
+#include "ipv6_option_impl.hpp"
 
 namespace vsomeip {
 
@@ -35,6 +38,15 @@ class subscription;
 
 typedef std::map<service_t, std::map<instance_t, std::shared_ptr<request> > > requests_t;
 
+struct accepted_subscriber_t {
+    std::shared_ptr < endpoint_definition > subscriber;
+    std::shared_ptr < endpoint_definition > target;
+    std::chrono::high_resolution_clock::time_point its_expiration;
+    vsomeip::service_t service_id;
+    vsomeip::instance_t instance_id;
+    vsomeip::eventgroup_t eventgroup_;
+};
+
 class service_discovery_impl: public service_discovery,
         public std::enable_shared_from_this<service_discovery_impl> {
 public:
@@ -59,18 +71,36 @@ public:
             eventgroup_t _eventgroup, client_t _client);
     void unsubscribe_all(service_t _service, instance_t _instance);
 
-    void send(bool _is_announcing);
+    bool send(bool _is_announcing, bool _is_find);
 
     void on_message(const byte_t *_data, length_t _length,
-            const boost::asio::ip::address &_sender);
+            const boost::asio::ip::address &_sender,
+            const boost::asio::ip::address &_destination);
 
     void on_offer_change();
 
+    void send_unicast_offer_service(const std::shared_ptr<const serviceinfo> &_info,
+            service_t _service, instance_t _instance,
+            major_version_t _major,
+            minor_version_t _minor);
+
+    void send_multicast_offer_service(const std::shared_ptr<const serviceinfo>& _info,
+            service_t _service, instance_t _instance,
+            major_version_t _major,
+            minor_version_t _minor);
+
+    void on_reliable_endpoint_connected(
+            service_t _service, instance_t _instance,
+            const std::shared_ptr<const vsomeip::endpoint> &_endpoint);
+
 private:
+
+
     std::pair<session_t, bool> get_session(const boost::asio::ip::address &_address);
     void increment_session(const boost::asio::ip::address &_address);
 
-    bool is_reboot(const boost::asio::ip::address &_address,
+    bool is_reboot(const boost::asio::ip::address &_sender,
+            const boost::asio::ip::address &_destination,
             bool _reboot_flag, session_t _session);
 
     void insert_option(std::shared_ptr<message_impl> &_message,
@@ -78,24 +108,29 @@ private:
             const boost::asio::ip::address &_address, uint16_t _port,
             bool _is_reliable);
     void insert_find_entries(std::shared_ptr<message_impl> &_message,
-            requests_t &_requests);
+            requests_t &_requests, uint32_t _start, uint32_t &_size, bool &_done);
     void insert_offer_entries(std::shared_ptr<message_impl> &_message,
-            services_t &_services);
-    void insert_offer_service(std::shared_ptr<message_impl> _message,
+            services_t &_services, uint32_t &_start, uint32_t _size, bool &_done);
+    bool insert_offer_service(std::shared_ptr<message_impl> _message,
                               service_t _service, instance_t _instance,
-                              const std::shared_ptr<const serviceinfo> &_info);
+                              const std::shared_ptr<const serviceinfo> &_info,
+                              uint32_t &_size);
     void insert_subscription(std::shared_ptr<message_impl> &_message,
             service_t _service, instance_t _instance, eventgroup_t _eventgroup,
+            std::shared_ptr<subscription> &_subscription, bool _insert_reliable, bool _insert_unreliable);
+    void insert_nack_subscription_on_resubscribe(std::shared_ptr<message_impl> &_message,
+            service_t _service, instance_t _instance, eventgroup_t _eventgroup,
             std::shared_ptr<subscription> &_subscription);
     void insert_subscription_ack(std::shared_ptr<message_impl> &_message,
             service_t _service, instance_t _instance, eventgroup_t _eventgroup,
-            std::shared_ptr<eventgroupinfo> &_info, ttl_t _ttl);
+            std::shared_ptr<eventgroupinfo> &_info, ttl_t _ttl, uint8_t _counter, major_version_t _major, uint16_t _reserved);
     void insert_subscription_nack(std::shared_ptr<message_impl> &_message, service_t _service,
             instance_t _instance, eventgroup_t _eventgroup,
-            std::shared_ptr<eventgroupinfo> &_info);
+            uint8_t _counter, major_version_t _major, uint16_t _reserved);
 
     void process_serviceentry(std::shared_ptr<serviceentry_impl> &_entry,
-            const std::vector<std::shared_ptr<option_impl> > &_options);
+            const std::vector<std::shared_ptr<option_impl> > &_options,
+            bool _unicast_flag);
     void process_offerservice_serviceentry(
             service_t _service, instance_t _instance, major_version_t _major,
             minor_version_t _minor, ttl_t _ttl,
@@ -103,39 +138,63 @@ private:
             uint16_t _reliable_port,
             const boost::asio::ip::address &_unreliable_address,
             uint16_t _unreliable_port);
-    void send_unicast_offer_service(const std::shared_ptr<const serviceinfo>& _info,
-                                    service_t _service, instance_t _instance,
-                                    major_version_t _major,
-                                    minor_version_t _minor);
-    void process_findservice_serviceentry(service_t _service,
-                                          instance_t _instance,
-                                          major_version_t _major,
-                                          minor_version_t _minor);
-    void process_eventgroupentry(std::shared_ptr<eventgroupentry_impl> &_entry,
-            const std::vector<std::shared_ptr<option_impl> > &_options);
+    void send_offer_service(
+            const std::shared_ptr<const serviceinfo> &_info, service_t _service,
+            instance_t _instance, major_version_t _major, minor_version_t _minor,
+            bool _unicast_flag);
 
+    void process_findservice_serviceentry(service_t _service,
+            instance_t _instance,
+            major_version_t _major,
+            minor_version_t _minor,
+            bool _unicast_flag);
+    void process_eventgroupentry(
+            std::shared_ptr<eventgroupentry_impl> &_entry,
+            const std::vector<std::shared_ptr<option_impl> > &_options,
+            std::shared_ptr < message_impl > &its_message_response,
+            std::vector <accepted_subscriber_t> &accepted_subscribers);
     void handle_eventgroup_subscription(service_t _service,
             instance_t _instance, eventgroup_t _eventgroup,
-            major_version_t _major, ttl_t _ttl,
-            const boost::asio::ip::address &_reliable_address,
-            uint16_t _reliable_port, uint16_t _unreliable_port);
+            major_version_t _major, ttl_t _ttl, uint8_t _counter, uint16_t _reserved,
+            const boost::asio::ip::address &_first_address, uint16_t _first_port,
+            bool _is_first_reliable,
+            const boost::asio::ip::address &_second_address, uint16_t _second_port,
+            bool _is_second_reliable,
+            std::shared_ptr < message_impl > &its_message,
+            std::vector <accepted_subscriber_t> &accepted_subscribers);
     void handle_eventgroup_subscription_ack(service_t _service,
             instance_t _instance, eventgroup_t _eventgroup,
-            major_version_t _major, ttl_t _ttl,
+            major_version_t _major, ttl_t _ttl, uint8_t _counter,
             const boost::asio::ip::address &_address, uint16_t _port);
+    void handle_eventgroup_subscription_nack(service_t _service,
+            instance_t _instance, eventgroup_t _eventgroup, uint8_t _counter);
     void serialize_and_send(std::shared_ptr<message_impl> _message,
             const boost::asio::ip::address &_address);
 
+    bool is_tcp_connected(service_t _service,
+            instance_t _instance,
+            std::shared_ptr<vsomeip::endpoint_definition> its_endpoint);
+
     void start_ttl_timer();
-    ttl_t stop_ttl_timer();
+    std::chrono::milliseconds stop_ttl_timer();
+
     void check_ttl(const boost::system::error_code &_error);
     boost::asio::ip::address get_current_remote_address() const;
+
+    void start_subscription_expiration_timer();
+    void stop_subscription_expiration_timer();
+    void expire_subscriptions(const boost::system::error_code &_error);
+
+    bool check_ipv4_address(boost::asio::ip::address its_address);
+
     bool check_static_header_fields(
             const std::shared_ptr<const message> &_message) const;
     void send_eventgroup_subscription_nack(service_t _service,
                                            instance_t _instance,
                                            eventgroup_t _eventgroup,
-                                           major_version_t _major);
+                                           major_version_t _major,
+                                           uint8_t _counter,
+                                           uint16_t _reserved);
     bool check_layer_four_protocol(
             const std::shared_ptr<const ip_option_impl> _ip_option) const;
     void get_subscription_endpoints(subscription_type_e _subscription_type,
@@ -146,6 +205,28 @@ private:
                                     service_t _service, instance_t _instance,
                                     client_t _client) const;
 
+    void send_subscriptions(service_t _service, instance_t _instance, client_t _client, bool _reliable);
+
+    template<class Option, typename AddressType>
+    std::shared_ptr<option_impl> find_existing_option(
+            std::shared_ptr<message_impl> &_message,
+            AddressType _address, uint16_t _port,
+            layer_four_protocol_e _protocol,
+            option_type_e _option_type);
+    template<class Option, typename AddressType>
+    bool check_message_for_ip_option_and_assign_existing(
+            std::shared_ptr<message_impl> &_message,
+            std::shared_ptr<entry_impl> _entry, AddressType _address,
+            uint16_t _port, layer_four_protocol_e _protocol,
+            option_type_e _option_type);
+    template<class Option, typename AddressType>
+    void assign_ip_option_to_entry(std::shared_ptr<Option> _option,
+                                   AddressType _address, uint16_t _port,
+                                   layer_four_protocol_e _protocol,
+                                   std::shared_ptr<entry_impl> _entry);
+
+    std::shared_ptr<request> find_request(service_t _service, instance_t _instance);
+
 private:
     boost::asio::io_service &io_;
     service_discovery_host *host_;
@@ -165,25 +246,31 @@ private:
     std::mutex requested_mutex_;
     std::map<service_t,
             std::map<instance_t,
-                    std::map<eventgroup_t, std::map<client_t, std::shared_ptr<subscription> > > > > subscribed_;
+                    std::map<eventgroup_t,
+                        std::map<client_t,
+                            std::shared_ptr<subscription> > > > > subscribed_;
     std::mutex subscribed_mutex_;
 
     std::mutex serialize_mutex_;
 
     // Sessions
-    std::map<boost::asio::ip::address, std::pair<session_t, bool> > sessions_;
-    std::map<boost::asio::ip::address, session_t > sessions_receiving_;
-
-    // Reboots
-    std::set<boost::asio::ip::address> reboots_;
+    std::map<boost::asio::ip::address, std::pair<session_t, bool> > sessions_sent_;
+    std::map<boost::asio::ip::address,
+        std::tuple<session_t, session_t, bool> > sessions_received_;
 
     // Runtime
     std::weak_ptr<runtime> runtime_;
 
-    // TTL handling
+    // TTL handling for services offered by other hosts
     boost::asio::system_timer ttl_timer_;
-    ttl_t smallest_ttl_;
+    std::chrono::milliseconds smallest_ttl_;
     ttl_t ttl_;
+
+    // TTL handling for subscriptions done by other hosts
+    boost::asio::system_timer subscription_expiration_timer_;
+    std::chrono::high_resolution_clock::time_point next_subscription_expiration_;
+
+    uint32_t max_message_size_;
 };
 
 }  // namespace sd