Implemented endpoint options.

9 files changed, 202 insertions, 13 deletions

diff --git a/implementation/service_discovery/src/entry_impl.cpp b/implementation/service_discovery/src/entry_impl.cpp
index 75b2642..ba89c85 100755
--- a/implementation/service_discovery/src/entry_impl.cpp
+++ b/implementation/service_discovery/src/entry_impl.cpp
@@ -82,7 +82,7 @@ const std::vector< uint8_t > & entry_impl::get_options(uint8_t _run) const {
 	return invalid_options;

 }

 

-void entry_impl::assign_option(const option_impl &_option, uint8_t _run) {

+void entry_impl::assign_option(const std::shared_ptr< option_impl > &_option, uint8_t _run) {

 	if (_run > 0 && _run <= VSOMEIP_MAX_OPTION_RUN) {

 		_run--; // Index = Run-1

 

diff --git a/implementation/service_discovery/src/eventgroupentry_impl.cpp b/implementation/service_discovery/src/eventgroupentry_impl.cpp
index ddfe58c..7f2481a 100755
--- a/implementation/service_discovery/src/eventgroupentry_impl.cpp
+++ b/implementation/service_discovery/src/eventgroupentry_impl.cpp
@@ -37,13 +37,13 @@ bool eventgroupentry_impl::serialize(vsomeip::serializer *_to) const {
 	bool is_successful = entry_impl::serialize(_to);

 

 	is_successful = is_successful

-				&& _to->serialize(vsomeip::protocol::reserved_byte);

+				&& _to->serialize(protocol::reserved_byte);

 

 	is_successful = is_successful

 				&& _to->serialize(static_cast< uint32_t >(ttl_), true);

 

 	is_successful = is_successful

-			&& _to->serialize(vsomeip::protocol::reserved_word);

+			&& _to->serialize(protocol::reserved_word);

 

 	is_successful = is_successful

 			&& _to->serialize(static_cast< uint16_t >(eventgroup_));

diff --git a/implementation/service_discovery/src/ipv4_option_impl.cpp b/implementation/service_discovery/src/ipv4_option_impl.cpp
index 272330b..5c1d863 100644
--- a/implementation/service_discovery/src/ipv4_option_impl.cpp
+++ b/implementation/service_discovery/src/ipv4_option_impl.cpp
@@ -6,6 +6,7 @@
 

 #include <vsomeip/constants.hpp>

 

+#include "../include/constants.hpp"

 #include "../include/ipv4_option_impl.hpp"

 #include "../../message/include/deserializer.hpp"

 #include "../../message/include/serializer.hpp"

@@ -29,19 +30,51 @@ bool ipv4_option_impl::operator ==(const option_impl &_other) const {
 	return true;

 }

 

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

+	return address_;

+}

+

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

+	address_ = _address;

+}

+

+unsigned short ipv4_option_impl::get_port() const {

+	return port_;

+}

+

+void ipv4_option_impl::set_port(unsigned short _port) {

+	port_ = _port;

+}

+

+bool ipv4_option_impl::is_udp() const {

+	return is_udp_;

+}

+

+void ipv4_option_impl::set_udp(bool _is_udp) {

+	is_udp_ = _is_udp;

+}

+

 bool ipv4_option_impl::is_multicast() const {

 	return (type_ == option_type_e::IP4_MULTICAST);

 }

 

 bool ipv4_option_impl::serialize(vsomeip::serializer *_to) const {

 	bool is_successful = option_impl::serialize(_to);

-	// TODO: serialize specific part

+	_to->serialize(&address_[0], address_.size());

+	_to->serialize(protocol::reserved_byte);

+	_to->serialize(is_udp_ ? protocol::udp : protocol::tcp);

+	_to->serialize(port_);

 	return is_successful;

 }

 

 bool ipv4_option_impl::deserialize(vsomeip::deserializer *_from) {

 	bool is_successful = option_impl::deserialize(_from);

-	// TODO: serialize specific part

+	uint8_t its_reserved;

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

+	_from->deserialize(its_reserved);

+	_from->deserialize(its_reserved);

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

+	_from->deserialize(port_);

 	return is_successful;

 }

 

diff --git a/implementation/service_discovery/src/ipv6_option_impl.cpp b/implementation/service_discovery/src/ipv6_option_impl.cpp
index 20a7988..9408e43 100755
--- a/implementation/service_discovery/src/ipv6_option_impl.cpp
+++ b/implementation/service_discovery/src/ipv6_option_impl.cpp
@@ -6,6 +6,7 @@
 

 #include <cstring>

 

+#include "../include/constants.hpp"

 #include "../include/ipv6_option_impl.hpp"

 #include "../../message/include/deserializer.hpp"

 #include "../../message/include/serializer.hpp"

@@ -31,16 +32,47 @@ bool ipv6_option_impl::operator ==(const option_impl &_other) const {
 	return true; // TODO:

 }

 

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

+	return address_;

+}

+

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

+	address_ = _address;

+}

+

+unsigned short ipv6_option_impl::get_port() const {

+	return port_;

+}

+

+void ipv6_option_impl::set_port(unsigned short _port) {

+	port_ = _port;

+}

+

+bool ipv6_option_impl::is_udp() const {

+	return is_udp_;

+}

+

+void ipv6_option_impl::set_udp(bool _is_udp) {

+	is_udp_ = _is_udp;

+}

 

 bool ipv6_option_impl::serialize(vsomeip::serializer *_to) const {

 	bool is_successful = option_impl::serialize(_to);

-	// TODO: deserialize content

+	_to->serialize(&address_[0], address_.size());

+	_to->serialize(protocol::reserved_byte);

+	_to->serialize(is_udp_ ? protocol::udp : protocol::tcp);

+	_to->serialize(port_);

 	return is_successful;

 }

 

 bool ipv6_option_impl::deserialize(vsomeip::deserializer *_from) {

 	bool is_successful = option_impl::deserialize(_from);

-	// TODO: deserialize content

+	uint8_t its_reserved;

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

+	_from->deserialize(its_reserved);

+	_from->deserialize(its_reserved);

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

+	_from->deserialize(port_);

 	return is_successful;

 }

 

diff --git a/implementation/service_discovery/src/message_impl.cpp b/implementation/service_discovery/src/message_impl.cpp
index 8840a47..9cf8c44 100755
--- a/implementation/service_discovery/src/message_impl.cpp
+++ b/implementation/service_discovery/src/message_impl.cpp
@@ -141,11 +141,11 @@ const std::vector< std::shared_ptr< option_impl > > message_impl::get_options()
 }

 

 // TODO: throw exception to signal "OptionNotFound"

-int16_t message_impl::get_option_index(const option_impl &_option) const {

+int16_t message_impl::get_option_index(const std::shared_ptr< option_impl > &_option) const {

 	int16_t i = 0;

 

 	while (i < options_.size()) {

-		if (*(options_[i].get()) == _option)

+		if (options_[i] == _option)

 			return i;

 		i++;

 	}

@@ -158,7 +158,7 @@ bool message_impl::serialize(vsomeip::serializer *_to) const {
 

 	is_successful = is_successful && _to->serialize(flags_);

 	is_successful = is_successful

-			&& _to->serialize(vsomeip::protocol::reserved_long, true);

+			&& _to->serialize(protocol::reserved_long, true);

 

 	uint32_t entries_length = (entries_.size() * VSOMEIP_SOMEIP_SD_ENTRY_SIZE);

 	is_successful = is_successful && _to->serialize(entries_length);

diff --git a/implementation/service_discovery/src/option_impl.cpp b/implementation/service_discovery/src/option_impl.cpp
index 552aad8..92c3132 100755
--- a/implementation/service_discovery/src/option_impl.cpp
+++ b/implementation/service_discovery/src/option_impl.cpp
@@ -36,7 +36,7 @@ bool option_impl::serialize(vsomeip::serializer *_to) const {
 	return (0 != _to

 			&& _to->serialize(length_)

 			&& _to->serialize(static_cast<uint8_t>(type_))

-			&& _to->serialize(vsomeip::protocol::reserved_byte));

+			&& _to->serialize(protocol::reserved_byte));

 }

 

 bool option_impl::deserialize(vsomeip::deserializer *_from) {

diff --git a/implementation/service_discovery/src/runtime_impl.cpp b/implementation/service_discovery/src/runtime_impl.cpp
index 32c943d..b1f9b47 100644
--- a/implementation/service_discovery/src/runtime_impl.cpp
+++ b/implementation/service_discovery/src/runtime_impl.cpp
@@ -5,7 +5,10 @@
 // file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 #include <vsomeip/defines.hpp>
+#include <vsomeip/message.hpp>
 
+#include "../include/constants.hpp"
+#include "../include/message_impl.hpp"
 #include "../include/runtime_impl.hpp"
 #include "../include/service_discovery_impl.hpp"
 
@@ -24,5 +27,19 @@ std::shared_ptr< service_discovery > runtime_impl::create_service_discovery(serv
 	return std::make_shared< service_discovery_impl >(_host);
 }
 
+std::shared_ptr< message_impl > runtime_impl::create_message() const {
+	std::shared_ptr< message_impl > its_message = std::make_shared< message_impl >();
+	its_message->set_service(VSOMEIP_SD_SERVICE);
+	its_message->set_instance(VSOMEIP_SD_INSTANCE);
+	its_message->set_method(VSOMEIP_SD_METHOD);
+	its_message->set_client(VSOMEIP_SD_CLIENT);
+	// session must be set dynamically
+	its_message->set_protocol_version(VSOMEIP_SD_PROTOCOL_VERSION);
+	its_message->set_interface_version(VSOMEIP_SD_INTERFACE_VERSION);
+	its_message->set_message_type(VSOMEIP_SD_MESSAGE_TYPE);
+	its_message->set_return_code(VSOMEIP_SD_RETURN_CODE);
+	return its_message;
+}
+
 } // namespace sd
 } // namespace vsomeip
diff --git a/implementation/service_discovery/src/service_discovery_fsm.cpp b/implementation/service_discovery/src/service_discovery_fsm.cpp
index 6694c44..7ed190d 100644
--- a/implementation/service_discovery/src/service_discovery_fsm.cpp
+++ b/implementation/service_discovery/src/service_discovery_fsm.cpp
@@ -97,6 +97,7 @@ repeat::repeat(my_context _context): sc::state< repeat, active >(_context) {
 	VSOMEIP_DEBUG << "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);
 	outermost_context().start_timer(its_timeout);
 }
 
@@ -117,6 +118,7 @@ sc::result repeat::react(const ev_find_service &_event) {
 announce::announce(my_context _context): sc::state< announce, active  >(_context) {
 	VSOMEIP_DEBUG << "sd<" << outermost_context().fsm_->get_name() << ">::active.announce";
 	outermost_context().start_timer(outermost_context().cyclic_offer_delay_);
+	outermost_context().fsm_->send(true);
 }
 
 sc::result announce::react(const ev_timeout &_event) {
@@ -176,5 +178,9 @@ void service_discovery_fsm::start() {
 void service_discovery_fsm::stop() {
 }
 
+void service_discovery_fsm::send(bool _is_announcing) {
+	discovery_->send(name_, _is_announcing);
+}
+
 } // namespace sd
 } // namespace vsomeip
diff --git a/implementation/service_discovery/src/service_discovery_impl.cpp b/implementation/service_discovery/src/service_discovery_impl.cpp
index 9675943..bb86bb9 100644
--- a/implementation/service_discovery/src/service_discovery_impl.cpp
+++ b/implementation/service_discovery/src/service_discovery_impl.cpp
@@ -7,12 +7,19 @@
 #include <vsomeip/configuration.hpp>
 #include <vsomeip/logger.hpp>
 
+#include "../include/constants.hpp"
+#include "../include/ipv4_option_impl.hpp"
+#include "../include/ipv6_option_impl.hpp"
+#include "../include/message_impl.hpp"
+#include "../include/runtime.hpp"
 #include "../include/service_discovery_fsm.hpp"
 #include "../include/service_discovery_host.hpp"
 #include "../include/service_discovery_impl.hpp"
+#include "../include/serviceentry_impl.hpp"
 #include "../../endpoints/include/tcp_server_endpoint_impl.hpp"
 #include "../../endpoints/include/udp_server_endpoint_impl.hpp"
 #include "../../routing/include/servicegroup.hpp"
+#include "../../routing/include/serviceinfo.hpp"
 
 namespace vsomeip {
 namespace sd {
@@ -100,12 +107,106 @@ void service_discovery_impl::request_service(service_t _service,
 		ttl_t _ttl) {
 	VSOMEIP_DEBUG << "sdi::request_service [" << std::hex << _service << "."
 			<< _instance << "]";
+	auto find_service = requested_.find(_service);
+	if (find_service != requested_.end()) {
+		auto find_instance = find_service->second.find(_instance);
+		if (find_instance != find_service->second.end()) {
+			// TODO: check version and report errors
+		} else {
+			find_service->second[_instance]
+			    = std::make_shared< serviceinfo >(_major, _minor, _ttl);
+		}
+	} else {
+		requested_[_service][_instance]
+		    = std::make_shared< serviceinfo >(_major, _minor, _ttl);
+	}
 }
 
 void service_discovery_impl::release_service(service_t _service,
 		instance_t _instance) {
-	VSOMEIP_DEBUG << "sdi::release_service [" << std::hex << _service << "."
-			<< _instance << "]";
+	auto find_service = requested_.find(_service);
+	if (find_service != requested_.end()) {
+		find_service->second.erase(_instance);
+	}
+}
+
+void service_discovery_impl::insert_service_entries(
+		std::shared_ptr< message_impl > &_message, service_map_t &_services,
+		bool _is_offer) {
+	for (auto its_service : _services) {
+		for (auto its_instance : its_service.second) {
+			auto its_info = its_instance.second;
+			std::shared_ptr< serviceentry_impl > its_entry
+				= _message->create_service_entry();
+			if (its_entry) {
+				its_entry->set_type((_is_offer ?
+					entry_type_e::OFFER_SERVICE :
+					entry_type_e::FIND_SERVICE));
+				its_entry->set_service(its_service.first);
+				its_entry->set_instance(its_instance.first);
+				its_entry->set_major_version(its_info->get_major());
+				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();
+				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);
+								}
+							}
+						}
+					}
+				}
+			} else {
+				VSOMEIP_ERROR << "Failed to create service entry.";
+			}
+		}
+	}
+}
+
+
+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)
+
+	// If we are the default group and not in main phase, include "FindOffer"-entries
+	if (_name == "default" && !_is_announcing) {
+		insert_service_entries(its_message, requested_, false);
+	}
+
+	// Always include the "OfferService"-entries for the service group
+	service_map_t its_offers = host_->get_offered_services(_name);
+	insert_service_entries(its_message, its_offers, true);
+
+	// Serialize and send
+	host_->send(VSOMEIP_SD_CLIENT, its_message, true, false);
 }
 
 // Interface endpoint_host