Service availability detection by service discovery is basically

working, but:

1. A concept for handling the case of partly stopped (meaning not on all
offered endpoints) services is needed.

2. The session counter should be incremented after successful send
operations only.

3. The data structures used to within the RM need rework. There are too
many interconnected (by shared pointers) maps.

5 files changed, 180 insertions, 60 deletions

diff --git a/implementation/service_discovery/src/ipv4_option_impl.cpp b/implementation/service_discovery/src/ipv4_option_impl.cpp
index 2b68a07..33dd864 100644
--- a/implementation/service_discovery/src/ipv4_option_impl.cpp
+++ b/implementation/service_discovery/src/ipv4_option_impl.cpp
@@ -30,11 +30,11 @@ bool ipv4_option_impl::operator ==(const option_impl &_other) const {
 	return true;

 }

 

-const std::vector< byte_t > & ipv4_option_impl::get_address() const {

+const ipv4_address_t & ipv4_option_impl::get_address() const {

 	return address_;

 }

 

-void ipv4_option_impl::set_address(const std::vector< byte_t > &_address) {

+void ipv4_option_impl::set_address(const ipv4_address_t &_address) {

 	address_ = _address;

 }

 

@@ -70,8 +70,7 @@ bool ipv4_option_impl::serialize(vsomeip::serializer *_to) const {
 bool ipv4_option_impl::deserialize(vsomeip::deserializer *_from) {

 	bool is_successful = option_impl::deserialize(_from);

 	uint8_t its_reserved;

-	address_.resize(4);

-	_from->deserialize(address_);

+	_from->deserialize(address_.data(), 4);

 	_from->deserialize(its_reserved);

 	_from->deserialize(its_reserved);

 	is_udp_ = (protocol::udp == its_reserved);

diff --git a/implementation/service_discovery/src/ipv6_option_impl.cpp b/implementation/service_discovery/src/ipv6_option_impl.cpp
index 654de29..26a711d 100755
--- a/implementation/service_discovery/src/ipv6_option_impl.cpp
+++ b/implementation/service_discovery/src/ipv6_option_impl.cpp
@@ -32,11 +32,11 @@ bool ipv6_option_impl::operator ==(const option_impl &_other) const {
 	return true; // TODO:

 }

 

-const std::vector< byte_t > & ipv6_option_impl::get_address() const {

+const ipv6_address_t & ipv6_option_impl::get_address() const {

 	return address_;

 }

 

-void ipv6_option_impl::set_address(const std::vector< byte_t > &_address) {

+void ipv6_option_impl::set_address(const ipv6_address_t &_address) {

 	address_ = _address;

 }

 

@@ -68,7 +68,7 @@ bool ipv6_option_impl::serialize(vsomeip::serializer *_to) const {
 bool ipv6_option_impl::deserialize(vsomeip::deserializer *_from) {

 	bool is_successful = option_impl::deserialize(_from);

 	uint8_t its_reserved;

-	_from->deserialize(&address_[0], 16);

+	_from->deserialize(address_.data(), 16);

 	_from->deserialize(its_reserved);

 	_from->deserialize(its_reserved);

 	is_udp_ = (protocol::udp == its_reserved);

diff --git a/implementation/service_discovery/src/message_impl.cpp b/implementation/service_discovery/src/message_impl.cpp
index 63af016..31da16b 100755
--- a/implementation/service_discovery/src/message_impl.cpp
+++ b/implementation/service_discovery/src/message_impl.cpp
@@ -131,11 +131,11 @@ std::shared_ptr< protection_option_impl > message_impl::create_protection_option
 	return its_option;

 }

 

-const std::vector< std::shared_ptr< entry_impl > > message_impl::get_entries() const {

+const std::vector< std::shared_ptr< entry_impl > >  & message_impl::get_entries() const {

 	return entries_;

 }

 

-const std::vector< std::shared_ptr< option_impl > > message_impl::get_options() const {

+const std::vector< std::shared_ptr< option_impl > >  & message_impl::get_options() const {

 	return options_;

 }

 

diff --git a/implementation/service_discovery/src/service_discovery_fsm.cpp b/implementation/service_discovery/src/service_discovery_fsm.cpp
index 60a38a7..df0f070 100644
--- a/implementation/service_discovery/src/service_discovery_fsm.cpp
+++ b/implementation/service_discovery/src/service_discovery_fsm.cpp
@@ -41,7 +41,7 @@ void fsm::timer_expired(const boost::system::error_code &_error) {
 // State "Inactive"
 ///////////////////////////////////////////////////////////////////////////////
 inactive::inactive(my_context context): sc::state< inactive, fsm >(context) {
-	VSOMEIP_DEBUG << "sd<" << outermost_context().fsm_->get_name() << ">::inactive";
+	VSOMEIP_TRACE << "sd<" << outermost_context().fsm_->get_name() << ">::inactive";
 	outermost_context().run_ = 0;
 }
 
@@ -66,7 +66,7 @@ sc::result inactive::react(const ev_status_change &_event) {
 // State "Active"
 ///////////////////////////////////////////////////////////////////////////////
 active::active(my_context _context): sc::state< active, fsm, initial >(_context) {
-	VSOMEIP_DEBUG << "sd<" << outermost_context().fsm_->get_name() << ">::active";
+	VSOMEIP_TRACE << "sd<" << outermost_context().fsm_->get_name() << ">::active";
 }
 
 active::~active() {
@@ -85,7 +85,7 @@ sc::result active::react(const ev_status_change &_event) {
 // State "Active.Initial"
 ///////////////////////////////////////////////////////////////////////////////
 initial::initial(my_context _context): sc::state< initial, active >(_context) {
-	VSOMEIP_DEBUG << "sd<" << outermost_context().fsm_->get_name() << ">::active.initial";
+	VSOMEIP_TRACE << "sd<" << outermost_context().fsm_->get_name() << ">::active.initial";
 	outermost_context().start_timer(outermost_context().initial_delay_);
 }
 
@@ -97,7 +97,7 @@ sc::result initial::react(const ev_timeout &_event) {
 // State "Active.Repeat"
 ///////////////////////////////////////////////////////////////////////////////
 repeat::repeat(my_context _context): sc::state< repeat, active >(_context) {
-	VSOMEIP_DEBUG << "sd<" << outermost_context().fsm_->get_name() << ">::active.repeat";
+	VSOMEIP_TRACE << "sd<" << outermost_context().fsm_->get_name() << ">::active.repeat";
 	uint32_t its_timeout = (outermost_context().repetition_base_delay_ << outermost_context().run_);
 	outermost_context().run_ ++;
 	outermost_context().fsm_->send(false);
@@ -119,7 +119,7 @@ sc::result repeat::react(const ev_find_service &_event) {
 // State "Active.Announce"
 ///////////////////////////////////////////////////////////////////////////////
 announce::announce(my_context _context): sc::state< announce, active  >(_context) {
-	VSOMEIP_DEBUG << "sd<" << outermost_context().fsm_->get_name() << ">::active.announce";
+	VSOMEIP_TRACE << "sd<" << outermost_context().fsm_->get_name() << ">::active.announce";
 	outermost_context().start_timer(outermost_context().cyclic_offer_delay_);
 	outermost_context().fsm_->send(true);
 }
@@ -147,7 +147,7 @@ service_discovery_fsm::service_discovery_fsm(
 	int32_t its_min_initial_delay = its_configuration->get_min_initial_delay(name_);
 	int32_t its_max_initial_delay = its_configuration->get_max_initial_delay(name_);
 
-	VSOMEIP_DEBUG << "Inital delay ["
+	VSOMEIP_TRACE << "Inital delay ["
 			<< its_min_initial_delay << ", " << its_max_initial_delay << "]";
 
 	boost::random::mt19937 its_generator;
diff --git a/implementation/service_discovery/src/service_discovery_impl.cpp b/implementation/service_discovery/src/service_discovery_impl.cpp
index 30f27da..f0b1b19 100644
--- a/implementation/service_discovery/src/service_discovery_impl.cpp
+++ b/implementation/service_discovery/src/service_discovery_impl.cpp
@@ -10,6 +10,8 @@
 #include "../include/constants.hpp"
 #include "../include/defines.hpp"
 #include "../include/deserializer.hpp"
+#include "../include/enumeration_types.hpp"
+#include "../include/eventgroupentry_impl.hpp"
 #include "../include/ipv4_option_impl.hpp"
 #include "../include/ipv6_option_impl.hpp"
 #include "../include/message_impl.hpp"
@@ -18,6 +20,7 @@
 #include "../include/service_discovery_host.hpp"
 #include "../include/service_discovery_impl.hpp"
 #include "../include/serviceentry_impl.hpp"
+#include "../../configuration/include/internal.hpp"
 #include "../../endpoints/include/tcp_server_endpoint_impl.hpp"
 #include "../../endpoints/include/udp_server_endpoint_impl.hpp"
 #include "../../routing/include/servicegroup.hpp"
@@ -83,18 +86,6 @@ void service_discovery_impl::start() {
 void service_discovery_impl::stop() {
 }
 
-void service_discovery_impl::offer_service(service_t _service,
-		instance_t _instance) {
-	VSOMEIP_DEBUG << "sdi::offer_service [" << std::hex << _service << "."
-			<< _instance << "]";
-}
-
-void service_discovery_impl::stop_offer_service(service_t _service,
-		instance_t _instance) {
-	VSOMEIP_DEBUG << "sdi::stop_offer_service [" << std::hex << _service << "."
-			<< _instance << "]";
-}
-
 void service_discovery_impl::request_service(service_t _service,
 		instance_t _instance, major_version_t _major, minor_version_t _minor,
 		ttl_t _ttl) {
@@ -123,6 +114,36 @@ void service_discovery_impl::release_service(service_t _service,
 	}
 }
 
+void service_discovery_impl::insert_service_option(
+		std::shared_ptr< message_impl > &_message,
+		std::shared_ptr< serviceentry_impl > &_entry,
+		std::shared_ptr< endpoint > _endpoint) {
+
+	ipv4_address_t its_address;
+	if (_endpoint->get_address(its_address)) {
+		std::shared_ptr< ipv4_option_impl > its_option
+			= _message->create_ipv4_option(false);
+		if (its_option) {
+			its_option->set_address(its_address);
+			its_option->set_port(_endpoint->get_port());
+			its_option->set_udp(_endpoint->is_udp());
+			_entry->assign_option(its_option, 1);
+		}
+	} else {
+		ipv6_address_t its_address;
+		if (_endpoint->get_address(its_address)) {
+			std::shared_ptr< ipv6_option_impl > its_option
+				= _message->create_ipv6_option(false);
+			if (its_option) {
+				its_option->set_address(its_address);
+				its_option->set_port(_endpoint->get_port());
+				its_option->set_udp(_endpoint->is_udp());
+				_entry->assign_option(its_option, 1);
+			}
+		}
+	}
+}
+
 void service_discovery_impl::insert_service_entries(
 		std::shared_ptr< message_impl > &_message, service_map_t &_services,
 		bool _is_offer) {
@@ -141,37 +162,19 @@ void service_discovery_impl::insert_service_entries(
 				its_entry->set_minor_version(its_info->get_minor());
 				its_entry->set_ttl(its_info->get_ttl());
 
-				std::shared_ptr< endpoint > its_endpoint
-					= its_info->get_reliable_endpoint();
+				std::shared_ptr< endpoint > its_endpoint = its_info->get_endpoint(true);
 				if (its_endpoint) {
-					if (its_endpoint->is_v4()) {
-						std::shared_ptr< ipv4_option_impl > its_option
-							= _message->create_ipv4_option(false);
-						if (its_option) {
-							std::vector< byte_t > its_address;
-							if (its_endpoint->get_address(its_address)) {
-								its_option->set_address(its_address);
-								its_option->set_port(its_endpoint->get_port());
-								its_option->set_udp(its_endpoint->is_udp());
-								its_entry->assign_option(its_option, 1);
-							}
-						}
-					} else {
-						std::shared_ptr< ipv6_option_impl > its_option
-							= _message->create_ipv6_option(false);
-						if (its_option) {
-							std::shared_ptr< ipv4_option_impl > its_option
-								= _message->create_ipv4_option(false);
-							if (its_option) {
-								std::vector< byte_t > its_address;
-								if (its_endpoint->get_address(its_address)) {
-									its_option->set_address(its_address);
-									its_option->set_port(its_endpoint->get_port());
-									its_option->set_udp(its_endpoint->is_udp());
-									its_entry->assign_option(its_option, 1);
-								}
-							}
-						}
+					insert_service_option(_message, its_entry, its_endpoint);
+					if (0 == its_info->get_ttl()) {
+						host_->del_routing_info(its_service.first, its_instance.first, true);
+					}
+				}
+
+				its_endpoint = its_info->get_endpoint(false);
+				if (its_endpoint) {
+					insert_service_option(_message, its_entry, its_endpoint);
+					if (0 == its_info->get_ttl()) {
+						host_->del_routing_info(its_service.first, its_instance.first, false);
 					}
 				}
 			} else {
@@ -183,8 +186,6 @@ void service_discovery_impl::insert_service_entries(
 
 
 void service_discovery_impl::send(const std::string &_name, bool _is_announcing) {
-	//std::unique_lock its_lock(serializer_mutex_);
-
 	std::shared_ptr< message_impl > its_message = runtime::get()->create_message();
 
 	// TODO: optimize building of SD message (common options)
@@ -204,12 +205,132 @@ void service_discovery_impl::send(const std::string &_name, bool _is_announcing)
 
 // Interface endpoint_host
 void service_discovery_impl::on_message(const byte_t *_data, length_t _length) {
+#if 0
+	std::stringstream msg;
+	msg << "sdi::on_message: ";
+	for (length_t i = 0; i < _length; ++i)
+		msg << std::hex << std::setw(2) << std::setfill('0') << (int)_data[i] << " ";
+	VSOMEIP_DEBUG << msg.str();
+#endif
 	deserializer_->set_data(_data, _length);
 	std::shared_ptr< message_impl > its_message(deserializer_->deserialize_sd_message());
 	if (its_message) {
-		VSOMEIP_DEBUG << "Got a Service Discovery message.";
+		std::vector< std::shared_ptr< option_impl > > its_options
+			= its_message->get_options();
+		for (auto its_entry : its_message->get_entries()) {
+			if (its_entry->is_service_entry()) {
+				std::shared_ptr< serviceentry_impl > its_service_entry
+					= std::dynamic_pointer_cast< serviceentry_impl >(its_entry);
+				process_serviceentry(its_service_entry, its_options);
+			} else {
+				std::shared_ptr< eventgroupentry_impl > its_eventgroup_entry
+					= std::dynamic_pointer_cast< eventgroupentry_impl >(its_entry);
+				process_eventgroupentry(its_eventgroup_entry, its_options);
+			}
+		}
+	}
+}
+
+// Entry processing
+void service_discovery_impl::process_serviceentry(
+		std::shared_ptr< serviceentry_impl > &_entry,
+		const std::vector< std::shared_ptr< option_impl > > &_options) {
+	service_t its_service = _entry->get_service();
+	instance_t its_instance = _entry->get_instance();
+	major_version_t its_major = _entry->get_major_version();
+	minor_version_t its_minor = _entry->get_minor_version();
+	ttl_t its_ttl = _entry->get_ttl();
+
+	VSOMEIP_DEBUG << "Service ["
+			<< std::hex << std::setw(4) << std::setfill('0')
+			<< its_service << "." << its_instance
+			<< "], version "
+			<< std::dec
+			<< (int)its_major << "." << its_minor
+			<< " is offered for "
+			<< its_ttl
+			<< " seconds.";
+
+	// process options
+	for (auto i : { 1, 2 }) {
+		for (auto its_index : _entry->get_options(i)) {
+			std::vector< byte_t > its_option_address;
+			uint16_t its_option_port = VSOMEIP_INVALID_PORT;
+			std::shared_ptr< option_impl > its_option = _options[its_index];
+			switch (its_option->get_type()) {
+			case option_type_e::IP4_ENDPOINT:
+			{
+				std::shared_ptr< ipv4_option_impl > its_ipv4_option
+					= std::dynamic_pointer_cast< ipv4_option_impl >(its_option);
+
+				boost::asio::ip::address_v4 its_ipv4_address(its_ipv4_option->get_address());
+				boost::asio::ip::address its_address(its_ipv4_address);
+
+				its_option_port = its_ipv4_option->get_port();
+
+				if (0 < its_ttl) {
+					host_->add_routing_info(its_service, its_instance,
+								its_major, its_minor, its_ttl,
+								its_address, its_option_port,
+								!its_ipv4_option->is_udp());
+				} else {
+					host_->del_routing_info(its_service, its_instance,
+								!its_ipv4_option->is_udp());
+				}
+			}
+			break;
+			case option_type_e::IP6_ENDPOINT:
+			{
+				std::shared_ptr< ipv6_option_impl > its_ipv6_option
+					= std::dynamic_pointer_cast< ipv6_option_impl >(its_option);
+
+				boost::asio::ip::address_v6 its_ipv6_address(its_ipv6_option->get_address());
+				boost::asio::ip::address its_address(its_ipv6_address);
+
+				its_option_port = its_ipv6_option->get_port();
+
+				if (0 < its_ttl) {
+					host_->add_routing_info(its_service, its_instance,
+								its_major, its_minor, its_ttl,
+								its_address, its_option_port,
+								!its_ipv6_option->is_udp());
+				} else {
+					host_->del_routing_info(its_service, its_instance,
+								!its_ipv6_option->is_udp());
+				}
+			}
+			break;
+			case option_type_e::IP4_MULTICAST:
+			case option_type_e::IP6_MULTICAST:
+				VSOMEIP_ERROR << "Invalid service option (Multicast)";
+				break;
+			default:
+				VSOMEIP_WARNING << "Unsupported service option";
+				break;
+			}
+		}
 	}
 }
 
+void service_discovery_impl::process_eventgroupentry(
+		std::shared_ptr< eventgroupentry_impl > &_entry,
+		const std::vector< std::shared_ptr< option_impl > > &_options) {
+	service_t its_service = _entry->get_service();
+	instance_t its_instance = _entry->get_instance();
+	eventgroup_t its_eventgroup = _entry->get_eventgroup();
+	major_version_t its_major = _entry->get_major_version();
+	ttl_t its_ttl = _entry->get_ttl();
+
+	VSOMEIP_DEBUG << "Eventgroup ["
+			<< std::hex << std::setw(4) << std::setfill('0')
+			<< its_service << "." << its_instance << "." << its_eventgroup
+			<< "], version "
+			<< std::dec
+			<< (int)its_major
+			<< " is offered for "
+			<< its_ttl
+			<< " seconds.";
+}
+
 } // namespace sd
 } // namespace vsomeip