Switched to json configuration files.

Added event/eventgroup configuration (per service).

8 files changed, 361 insertions, 220 deletions

diff --git a/implementation/routing/include/eventgroupinfo.hpp b/implementation/routing/include/eventgroupinfo.hpp
new file mode 100644
index 0000000..06c92e0
--- /dev/null
+++ b/implementation/routing/include/eventgroupinfo.hpp
@@ -0,0 +1,48 @@
+// Copyright (C) 2014 BMW Group
+// Author: Lutz Bichler (lutz.bichler@bmw.de)
+// 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/.
+
+#ifndef VSOMEIP_EVENTGROUPINFO_HPP
+#define VSOMEIP_EVENTGROUPINFO_HPP
+
+#include <memory>
+#include <set>
+
+#include <vsomeip/primitive_types.hpp>
+
+namespace vsomeip {
+
+class endpoint;
+
+class eventgroupinfo {
+public:
+	eventgroupinfo(major_version_t _major, ttl_t _ttl);
+	~eventgroupinfo();
+
+	servicegroup * get_group() const;
+	void set_group(servicegroup *_group);
+
+	major_version_t get_major() const;
+
+	ttl_t get_ttl() const;
+	void set_ttl(ttl_t _ttl);
+
+	std::shared_ptr<endpoint> & get_multicast();
+	void set_multicast(std::shared_ptr<endpoint> &_multicast);
+
+	void add_client(client_t _client);
+	void remove_client(client_t _client);
+
+private:
+	major_version_t major_;
+	ttl_t ttl_;
+
+	std::shared_ptr<endpoint> multicast_;
+	std::set< client_t > subscribed_;
+};
+
+} // namespace vsomeip
+
+#endif // VSOMEIP_EVENTGROUPINFO_HPP
diff --git a/implementation/routing/include/routing_manager.hpp b/implementation/routing/include/routing_manager.hpp
index efe1862..0dd8974 100644
--- a/implementation/routing/include/routing_manager.hpp
+++ b/implementation/routing/include/routing_manager.hpp
@@ -65,7 +65,8 @@ public:
 			instance_t _instance) = 0;
 
 	virtual void subscribe(client_t _client, service_t _service,
-			instance_t _instance, eventgroup_t _eventgroup) = 0;
+			instance_t _instance, eventgroup_t _eventgroup,
+			major_version_t _major, ttl_t _ttl) = 0;
 
 	virtual void unsubscribe(client_t _client, service_t _service,
 			instance_t _instance, eventgroup_t _eventgroup) = 0;
diff --git a/implementation/routing/include/routing_manager_impl.hpp b/implementation/routing/include/routing_manager_impl.hpp
index e5dba21..7b803b7 100644
--- a/implementation/routing/include/routing_manager_impl.hpp
+++ b/implementation/routing/include/routing_manager_impl.hpp
@@ -24,6 +24,7 @@ namespace vsomeip {
 class client_endpoint;
 class configuration;
 class deserializer;
+class eventgroupinfo;
 class routing_manager_host;
 class routing_manager_stub;
 class servicegroup;
@@ -83,7 +84,7 @@ public:
 			instance_t _instance);
 
 	void subscribe(client_t _client, service_t _service, instance_t _instance,
-			eventgroup_t _eventgroup);
+			eventgroup_t _eventgroup, major_version_t _major, ttl_t _ttl);
 
 	void unsubscribe(client_t _client, service_t _service, instance_t _instance,
 			eventgroup_t _eventgroup);
@@ -104,8 +105,7 @@ public:
 	std::shared_ptr<endpoint> find_local(client_t _client);
 	std::shared_ptr<endpoint> find_or_create_local(client_t _client);
 	void remove_local(client_t _client);
-	std::shared_ptr<endpoint> find_local(service_t _service,
-			instance_t _instance);
+	std::shared_ptr<endpoint> find_local(service_t _service, instance_t _instance);
 
 	// interface "endpoint_host"
 	void on_connect(std::shared_ptr<endpoint> _endpoint);
@@ -113,13 +113,16 @@ public:
 	void on_message(const byte_t *_data, length_t _length, endpoint *_receiver);
 
 	// interface "service_discovery_host"
-	const std::map<std::string, std::shared_ptr<servicegroup> > & get_servicegroups() const;
+	typedef std::map<std::string,
+					 std::shared_ptr<servicegroup> > servicegroups_t;
+	const servicegroups_t  & get_servicegroups() const;
 	service_map_t get_offered_services(const std::string &_name) const;
 	void create_service_discovery_endpoint(const std::string &_address,
 			uint16_t _port, const std::string &_protocol);
 
 private:
-	bool deliver_message(const byte_t *_data, length_t _length,	instance_t _instance);
+	bool deliver_message(const byte_t *_data, length_t _length,
+			instance_t _instance);
 
 	client_t find_local_client(service_t _service, instance_t _instance);
 	instance_t find_instance(service_t _service, endpoint *_endpoint);
@@ -195,9 +198,7 @@ private:
 			std::map<instance_t,
 					std::map<eventgroup_t, std::set<std::shared_ptr<endpoint> > > > > eventgroups_;
 	std::map<service_t, std::map<instance_t, std::map<event_t, eventgroup_t> > > events_;
-
-	// Requested (but unknown)
-	std::set<std::shared_ptr<serviceinfo> > requested_;
+	std::map<eventgroup_t, std::set<client_t> > eventgroup_clients_;
 
 	// Mutexes
 	std::recursive_mutex endpoint_mutex_;
diff --git a/implementation/routing/include/routing_manager_proxy.hpp b/implementation/routing/include/routing_manager_proxy.hpp
index 86e670a..f94472d 100644
--- a/implementation/routing/include/routing_manager_proxy.hpp
+++ b/implementation/routing/include/routing_manager_proxy.hpp
@@ -64,7 +64,7 @@ public:
 			instance_t _instance);
 
 	void subscribe(client_t _client, service_t _service, instance_t _instance,
-			eventgroup_t _eventgroup);
+			eventgroup_t _eventgroup, major_version_t _major, ttl_t _ttl);
 
 	void unsubscribe(client_t _client, service_t _service, instance_t _instance,
 			eventgroup_t _eventgroup);
diff --git a/implementation/routing/include/routing_types.hpp b/implementation/routing/include/routing_types.hpp
index 9016b78..67f0886 100644
--- a/implementation/routing/include/routing_types.hpp
+++ b/implementation/routing/include/routing_types.hpp
@@ -16,10 +16,18 @@ namespace vsomeip {
 
 class serviceinfo;
 
-typedef std::map< service_t,
-				  std::map< instance_t,
-				  	  	    std::shared_ptr< serviceinfo > > > service_map_t;
+typedef std::map<service_t,
+		    std::map<instance_t,
+		    	std::shared_ptr<serviceinfo> > > service_map_t;
 
-} // namespace vsomeip
+class eventgroupinfo;
+
+typedef std::map<service_t,
+			std::map<instance_t,
+				std::map<eventgroup_t,
+					std::shared_ptr<eventgroupinfo> > > > eventgroup_map_t;
+
+}
+// namespace vsomeip
 
 #endif // VSOMEIP_ROUTING_TYPES_HPP
diff --git a/implementation/routing/include/serviceinfo.hpp b/implementation/routing/include/serviceinfo.hpp
index 3d34f25..b38df5a 100644
--- a/implementation/routing/include/serviceinfo.hpp
+++ b/implementation/routing/include/serviceinfo.hpp
@@ -52,4 +52,4 @@ private:
 
 } // namespace vsomeip
 
-#endif // VSOMEIP_SERVICE_ROUTING_INFO_HPP
+#endif // VSOMEIP_SERVICEINFO_HPP
diff --git a/implementation/routing/src/routing_manager_impl.cpp b/implementation/routing/src/routing_manager_impl.cpp
index b8e65bd..b9a5df4 100644
--- a/implementation/routing/src/routing_manager_impl.cpp
+++ b/implementation/routing/src/routing_manager_impl.cpp
@@ -35,12 +35,11 @@
 
 namespace vsomeip {
 
-routing_manager_impl::routing_manager_impl(routing_manager_host *_host)
-	: host_(_host),
-	  io_(_host->get_io()),
-	  deserializer_(std::make_shared< deserializer>()),
-	  serializer_(std::make_shared< serializer >()),
-	  configuration_(host_->get_configuration()) {
+routing_manager_impl::routing_manager_impl(routing_manager_host *_host) :
+		host_(_host), io_(_host->get_io()), deserializer_(
+				std::make_shared<deserializer>()), serializer_(
+				std::make_shared<serializer>()), configuration_(
+				host_->get_configuration()) {
 }
 
 routing_manager_impl::~routing_manager_impl() {
@@ -60,16 +59,15 @@ void routing_manager_impl::init() {
 	serializer_->create_data(its_max_message_size);
 
 	// TODO: Only instantiate the stub if needed
-	stub_ = std::make_shared< routing_manager_stub >(this);
+	stub_ = std::make_shared < routing_manager_stub > (this);
 	stub_->init();
 
 	if (configuration_->is_service_discovery_enabled()) {
 		VSOMEIP_INFO << "Service Discovery enabled.";
-		sd::runtime **its_runtime = static_cast< sd::runtime ** >(
-										utility::load_library(
-										VSOMEIP_SD_LIBRARY,
-										VSOMEIP_SD_RUNTIME_SYMBOL_STRING)
-									);
+		sd::runtime **its_runtime =
+				static_cast<sd::runtime **>(utility::load_library(
+				VSOMEIP_SD_LIBRARY,
+				VSOMEIP_SD_RUNTIME_SYMBOL_STRING));
 
 		if (0 != its_runtime && 0 != (*its_runtime)) {
 			VSOMEIP_INFO << "Service Discovery module loaded.";
@@ -83,7 +81,8 @@ void routing_manager_impl::init() {
 
 void routing_manager_impl::start() {
 	stub_->start();
-	if (discovery_) discovery_->start();
+	if (discovery_)
+		discovery_->start();
 
 	host_->on_event(event_type_e::REGISTERED);
 }
@@ -91,26 +90,28 @@ void routing_manager_impl::start() {
 void routing_manager_impl::stop() {
 	host_->on_event(event_type_e::DEREGISTERED);
 
-	if (discovery_) discovery_->stop();
+	if (discovery_)
+		discovery_->stop();
 	stub_->stop();
 }
 
-void routing_manager_impl::offer_service(client_t _client,
-		service_t _service, instance_t _instance,
-		major_version_t _major, minor_version_t _minor, ttl_t _ttl) {
+void routing_manager_impl::offer_service(client_t _client, service_t _service,
+		instance_t _instance, major_version_t _major, minor_version_t _minor,
+		ttl_t _ttl) {
 	local_services_[_service][_instance] = _client;
 
 	// Remote route (incoming only)
-	std::shared_ptr< serviceinfo > its_info(find_service(_service, _instance));
+	std::shared_ptr<serviceinfo> its_info(find_service(_service, _instance));
 	if (its_info) {
-		if (its_info->get_major() == _major && its_info->get_minor() == _minor) {
+		if (its_info->get_major() == _major
+				&& its_info->get_minor() == _minor) {
 			VSOMEIP_DEBUG << "Setting TTL=" << std::dec << _ttl;
 			its_info->set_ttl(_ttl);
 		} else {
 			host_->on_error(error_code_e::SERVICE_PROPERTY_MISMATCH);
 		}
 	} else {
-		(void)create_service(_service, _instance, _major, _minor, _ttl);
+		(void) create_service(_service, _instance, _major, _minor, _ttl);
 	}
 
 	host_->on_availability(_service, _instance, true);
@@ -127,6 +128,7 @@ void routing_manager_impl::stop_offer_service(client_t its_client,
 			}
 		}
 	} else {
+		// TODO: allow to withdraw a service on one endpoint only
 		del_routing_info(_service, _instance, false);
 		del_routing_info(_service, _instance, true);
 	}
@@ -142,49 +144,51 @@ void routing_manager_impl::stop_publish_eventgroup(client_t its_client,
 
 }
 
-std::shared_ptr< event > routing_manager_impl::add_event(client_t _client,
-		service_t _service, instance_t _instance,
-		eventgroup_t _eventgroup, event_t _event) {
+std::shared_ptr<event> routing_manager_impl::add_event(client_t _client,
+		service_t _service, instance_t _instance, eventgroup_t _eventgroup,
+		event_t _event) {
 
-	return std::make_shared< event_impl >(io_);
+	return std::make_shared < event_impl > (io_);
 }
 
-std::shared_ptr< event > routing_manager_impl::add_field(client_t _client,
-		service_t _service, instance_t _instance,
-		eventgroup_t _eventgroup, event_t _event,
-		std::shared_ptr< payload > _payload) {
-	std::shared_ptr< event > its_event = add_event(_client, _service, _instance,
-												   _eventgroup, _event);
+std::shared_ptr<event> routing_manager_impl::add_field(client_t _client,
+		service_t _service, instance_t _instance, eventgroup_t _eventgroup,
+		event_t _event, std::shared_ptr<payload> _payload) {
+	std::shared_ptr<event> its_event = add_event(_client, _service, _instance,
+			_eventgroup, _event);
 	its_event->set_payload(_payload);
 	return its_event;
 }
 
-void routing_manager_impl::remove_event_or_field(std::shared_ptr< event > _event) {
+void routing_manager_impl::remove_event_or_field(
+		std::shared_ptr<event> _event) {
 
 }
 
-void routing_manager_impl::request_service(client_t _client,
-		service_t _service, instance_t _instance,
-		major_version_t _major, minor_version_t _minor, ttl_t _ttl) {
+void routing_manager_impl::request_service(client_t _client, service_t _service,
+		instance_t _instance, major_version_t _major, minor_version_t _minor,
+		ttl_t _ttl) {
 
-	std::shared_ptr< serviceinfo > its_info(find_service(_service, _instance));
+	std::shared_ptr<serviceinfo> its_info(find_service(_service, _instance));
 	if (its_info) {
-		if ((_major > its_info->get_major()) ||
-			(_major == its_info->get_major() && _minor > its_info->get_minor()) ||
-			(_ttl > its_info->get_ttl())) {
+		if ((_major > its_info->get_major())
+				|| (_major == its_info->get_major()
+						&& _minor > its_info->get_minor())
+				|| (_ttl > its_info->get_ttl())) {
 			host_->on_error(error_code_e::SERVICE_PROPERTY_MISMATCH);
 		} else {
 			its_info->add_client(_client);
 		}
 	} else {
 		if (discovery_)
-			discovery_->request_service(_service, _instance, _major, _minor, _ttl);
+			discovery_->request_service(_service, _instance, _major, _minor,
+					_ttl);
 	}
 }
 
-void routing_manager_impl::release_service(client_t _client,
-		service_t _service, instance_t _instance) {
-	std::shared_ptr< serviceinfo > its_info(find_service(_service, _instance));
+void routing_manager_impl::release_service(client_t _client, service_t _service,
+		instance_t _instance) {
+	std::shared_ptr<serviceinfo> its_info(find_service(_service, _instance));
 	if (its_info) {
 		its_info->remove_client(_client);
 	} else {
@@ -193,36 +197,62 @@ void routing_manager_impl::release_service(client_t _client,
 	}
 }
 
-void routing_manager_impl::subscribe(client_t its_client,
-		service_t _service, instance_t _instance, eventgroup_t _eventgroup) {
+void routing_manager_impl::subscribe(client_t _client, service_t _service,
+		instance_t _instance, eventgroup_t _eventgroup, major_version_t _major, ttl_t _ttl) {
+	if (discovery_) {
+		eventgroup_clients_[_eventgroup].insert(_client);
+		discovery_->subscribe(_service, _instance, _eventgroup, _major, _ttl);
+	} else {
+		VSOMEIP_ERROR << "SOME/IP eventgroups require SD to be enabled!";
+	}
 }
 
-void routing_manager_impl::unsubscribe(client_t its_client,
-		service_t _service, instance_t _instance, eventgroup_t _eventgroup) {
+void routing_manager_impl::unsubscribe(client_t _client, service_t _service,
+		instance_t _instance, eventgroup_t _eventgroup) {
+	if (discovery_) {
+		auto found_eventgroup = eventgroup_clients_.find(_eventgroup);
+		if (found_eventgroup != eventgroup_clients_.end()) {
+			found_eventgroup->second.erase(_client);
+			if (0 == found_eventgroup->second.size()) {
+				eventgroup_clients_.erase(_eventgroup);
+			}
+		}
+		discovery_->unsubscribe(_service, _instance, _eventgroup);
+	} else {
+		VSOMEIP_ERROR << "SOME/IP eventgroups require SD to be enabled!";
+	}
 }
 
 bool routing_manager_impl::send(client_t its_client,
-		std::shared_ptr< message > _message, bool _reliable, bool _flush) {
+		std::shared_ptr<message> _message, bool _reliable, bool _flush) {
 	bool is_sent(false);
-	std::unique_lock< std::mutex > its_lock(serialize_mutex_);
+	std::unique_lock < std::mutex > its_lock(serialize_mutex_);
+
+	if (utility::is_request(_message->get_message_type())) {
+		_message->set_client(its_client);
+	}
+
 	if (serializer_->serialize(_message.get())) {
-		is_sent = send(its_client, serializer_->get_data(), serializer_->get_size(),
-					   _message->get_instance(), _reliable, _flush);
+		is_sent = send(its_client, serializer_->get_data(),
+				serializer_->get_size(), _message->get_instance(), _reliable,
+				_flush);
 		serializer_->reset();
 	}
 	return is_sent;
 }
 
-bool routing_manager_impl::send(client_t _client,
-		const byte_t *_data, length_t _size, instance_t _instance, bool _flush, bool _reliable) {
+bool routing_manager_impl::send(client_t _client, const byte_t *_data,
+		length_t _size, instance_t _instance, bool _flush, bool _reliable) {
 	bool is_sent(false);
 
-	std::shared_ptr< endpoint > its_target;
-
-	client_t its_client = VSOMEIP_BYTES_TO_WORD(_data[VSOMEIP_CLIENT_POS_MIN], _data[VSOMEIP_CLIENT_POS_MAX]);
-	service_t its_service = VSOMEIP_BYTES_TO_WORD(_data[VSOMEIP_SERVICE_POS_MIN], _data[VSOMEIP_SERVICE_POS_MAX]);
+	std::shared_ptr<endpoint> its_target;
 	bool is_request = utility::is_request(_data[VSOMEIP_MESSAGE_TYPE_POS]);
 
+	client_t its_client = VSOMEIP_BYTES_TO_WORD(_data[VSOMEIP_CLIENT_POS_MIN],
+			_data[VSOMEIP_CLIENT_POS_MAX]);
+	service_t its_service = VSOMEIP_BYTES_TO_WORD(
+			_data[VSOMEIP_SERVICE_POS_MIN], _data[VSOMEIP_SERVICE_POS_MAX]);
+
 	if (_size > VSOMEIP_MESSAGE_TYPE_POS) {
 		if (is_request) {
 			its_target = find_local(its_service, _instance);
@@ -231,40 +261,59 @@ bool routing_manager_impl::send(client_t _client,
 		}
 
 		if (its_target) {
-			std::vector< byte_t > its_command(VSOMEIP_COMMAND_HEADER_SIZE + _size + sizeof(instance_t) + sizeof(bool) + sizeof(bool));
+			std::vector<byte_t> its_command(
+					VSOMEIP_COMMAND_HEADER_SIZE + _size + sizeof(instance_t)
+							+ sizeof(bool) + sizeof(bool));
 			its_command[VSOMEIP_COMMAND_TYPE_POS] = VSOMEIP_SEND;
-			std::memcpy(&its_command[VSOMEIP_COMMAND_CLIENT_POS], &_client, sizeof(client_t));
-			std::memcpy(&its_command[VSOMEIP_COMMAND_SIZE_POS_MIN], &_size, sizeof(_size));
-			std::memcpy(&its_command[VSOMEIP_COMMAND_PAYLOAD_POS], _data, _size);
-			std::memcpy(&its_command[VSOMEIP_COMMAND_PAYLOAD_POS + _size], &_instance, sizeof(instance_t));
-			std::memcpy(&its_command[VSOMEIP_COMMAND_PAYLOAD_POS + _size + sizeof(instance_t)], &_reliable, sizeof(bool));
-			std::memcpy(&its_command[VSOMEIP_COMMAND_PAYLOAD_POS + _size + sizeof(instance_t) + sizeof(bool)] , &_flush, sizeof(bool));
-			is_sent = its_target->send(&its_command[0], its_command.size(), _flush);
+			std::memcpy(&its_command[VSOMEIP_COMMAND_CLIENT_POS], &_client,
+					sizeof(client_t));
+			std::memcpy(&its_command[VSOMEIP_COMMAND_SIZE_POS_MIN], &_size,
+					sizeof(_size));
+			std::memcpy(&its_command[VSOMEIP_COMMAND_PAYLOAD_POS], _data,
+					_size);
+			std::memcpy(&its_command[VSOMEIP_COMMAND_PAYLOAD_POS + _size],
+					&_instance, sizeof(instance_t));
+			std::memcpy(
+					&its_command[VSOMEIP_COMMAND_PAYLOAD_POS + _size
+							+ sizeof(instance_t)], &_reliable, sizeof(bool));
+			std::memcpy(
+					&its_command[VSOMEIP_COMMAND_PAYLOAD_POS + _size
+							+ sizeof(instance_t) + sizeof(bool)], &_flush,
+					sizeof(bool));
+			is_sent = its_target->send(&its_command[0], its_command.size(),
+					_flush);
 		} else {
 			// Check whether hosting application should get the message
 			// If not, check routes to external
-			if ((its_client == host_->get_client() && !is_request) ||
-				(find_local_client(its_service, _instance) == host_->get_client() && is_request)) {
+			if ((its_client == host_->get_client() && !is_request)
+					|| (find_local_client(its_service, _instance)
+							== host_->get_client() && is_request)) {
+				// TODO: find out how to handle session id here
 				is_sent = deliver_message(_data, _size, _instance);
 			} else {
 				if (is_request) {
-					its_target = find_remote_client(its_service, _instance, _reliable);
+					its_target = find_remote_client(its_service, _instance,
+							_reliable);
 					if (its_target) {
 						is_sent = its_target->send(_data, _size, _flush);
 					} else {
-						VSOMEIP_ERROR << "Routing error. Client from remote service could not be found!";
+						VSOMEIP_ERROR
+								<< "Routing error. Client from remote service could not be found!";
 					}
 				} else {
-					std::shared_ptr< serviceinfo > its_info(find_service(its_service, _instance));
+					std::shared_ptr<serviceinfo> its_info(
+							find_service(its_service, _instance));
 					if (its_info) {
 						its_target = its_info->get_endpoint(_reliable);
 						if (its_target) {
 							is_sent = its_target->send(_data, _size, _flush);
 						} else {
-							VSOMEIP_ERROR << "Routing error. Service endpoint could not be found!";
+							VSOMEIP_ERROR
+									<< "Routing error. Service endpoint could not be found!";
 						}
 					} else {
-						VSOMEIP_ERROR << "Routing error. Service could not be found!";
+						VSOMEIP_ERROR
+								<< "Routing error. Service could not be found!";
 					}
 				}
 			}
@@ -274,32 +323,36 @@ bool routing_manager_impl::send(client_t _client,
 	return is_sent;
 }
 
-void routing_manager_impl::set(client_t its_client,
-		service_t _service, instance_t _instance,
-		event_t _event, const std::vector< byte_t > &_value) {
+void routing_manager_impl::set(client_t its_client, service_t _service,
+		instance_t _instance, event_t _event,
+		const std::vector<byte_t> &_value) {
 }
 
-void routing_manager_impl::on_message(const byte_t *_data, length_t _size, endpoint *_receiver) {
+void routing_manager_impl::on_message(const byte_t *_data, length_t _size,
+		endpoint *_receiver) {
 #if 0
 	std::stringstream msg;
 	msg << "rmi::on_message: ";
 	for (uint32_t i = 0; i < _size; ++i)
-		msg << std::hex << std::setw(2) << std::setfill('0') << (int)_data[i] << " ";
+	msg << std::hex << std::setw(2) << std::setfill('0') << (int)_data[i] << " ";
 	VSOMEIP_DEBUG << msg.str();
 #endif
 	if (_size >= VSOMEIP_SOMEIP_HEADER_SIZE) {
-		service_t its_service = VSOMEIP_BYTES_TO_WORD(_data[VSOMEIP_SERVICE_POS_MIN], _data[VSOMEIP_SERVICE_POS_MAX]);
+		service_t its_service = VSOMEIP_BYTES_TO_WORD(
+				_data[VSOMEIP_SERVICE_POS_MIN], _data[VSOMEIP_SERVICE_POS_MAX]);
 		if (its_service == VSOMEIP_SD_SERVICE) {
 			if (discovery_)
 				discovery_->on_message(_data, _size);
 		} else {
 			instance_t its_instance = find_instance(its_service, _receiver);
-			if (its_instance != any_instance) {
+			if (its_instance != ANY_INSTANCE) {
 				client_t its_client(VSOMEIP_ROUTING_CLIENT);
 				if (utility::is_request(_data[VSOMEIP_MESSAGE_TYPE_POS])) {
 					its_client = find_local_client(its_service, its_instance);
 				} else {
-					its_client = VSOMEIP_BYTES_TO_WORD(_data[VSOMEIP_CLIENT_POS_MIN], _data[VSOMEIP_CLIENT_POS_MAX]);
+					its_client = VSOMEIP_BYTES_TO_WORD(
+							_data[VSOMEIP_CLIENT_POS_MIN],
+							_data[VSOMEIP_CLIENT_POS_MAX]);
 				}
 
 				if (its_client == host_->get_client()) {
@@ -310,7 +363,8 @@ void routing_manager_impl::on_message(const byte_t *_data, length_t _size, endpo
 					VSOMEIP_ERROR << "Could not determine target application!";
 				}
 			} else {
-				VSOMEIP_ERROR << "Could not determine service instance for [" << its_service << "]";
+				VSOMEIP_ERROR << "Could not determine service instance for ["
+						<< its_service << "]";
 			}
 		}
 	} else {
@@ -318,42 +372,47 @@ void routing_manager_impl::on_message(const byte_t *_data, length_t _size, endpo
 	}
 }
 
-void routing_manager_impl::on_connect(std::shared_ptr< endpoint > _endpoint) {
+void routing_manager_impl::on_connect(std::shared_ptr<endpoint> _endpoint) {
 	for (auto &its_service : remote_services_) {
 		for (auto &its_instance : its_service.second) {
 			auto found_endpoint = its_instance.second.find(false);
 			if (found_endpoint != its_instance.second.end()) {
-				host_->on_availability(its_service.first, its_instance.first, true);
+				host_->on_availability(its_service.first, its_instance.first,
+						true);
 			} else {
 				found_endpoint = its_instance.second.find(true);
 				if (found_endpoint != its_instance.second.end()) {
-					host_->on_availability(its_service.first, its_instance.first, true);
+					host_->on_availability(its_service.first,
+							its_instance.first, true);
 				}
 			}
 		}
 	}
 }
 
-void routing_manager_impl::on_disconnect(std::shared_ptr< endpoint > _endpoint) {
+void routing_manager_impl::on_disconnect(std::shared_ptr<endpoint> _endpoint) {
 	for (auto &its_service : remote_services_) {
 		for (auto &its_instance : its_service.second) {
 			auto found_endpoint = its_instance.second.find(false);
 			if (found_endpoint != its_instance.second.end()) {
-				host_->on_availability(its_service.first, its_instance.first, false);
+				host_->on_availability(its_service.first, its_instance.first,
+						false);
 			} else {
 				found_endpoint = its_instance.second.find(true);
 				if (found_endpoint != its_instance.second.end()) {
-					host_->on_availability(its_service.first, its_instance.first, false);
+					host_->on_availability(its_service.first,
+							its_instance.first, false);
 				}
 			}
 		}
 	}
 }
 
-bool routing_manager_impl::deliver_message(const byte_t *_data, length_t _size, instance_t _instance) {
+bool routing_manager_impl::deliver_message(const byte_t *_data, length_t _size,
+		instance_t _instance) {
 	bool is_sent(false);
 	deserializer_->set_data(_data, _size);
-	std::shared_ptr< message > its_message(deserializer_->deserialize_message());
+	std::shared_ptr<message> its_message(deserializer_->deserialize_message());
 	if (its_message) {
 		its_message->set_instance(_instance);
 		host_->on_message(its_message);
@@ -365,7 +424,8 @@ bool routing_manager_impl::deliver_message(const byte_t *_data, length_t _size,
 	return is_sent;
 }
 
-bool routing_manager_impl::is_available(service_t _service, instance_t _instance) const {
+bool routing_manager_impl::is_available(service_t _service,
+		instance_t _instance) const {
 	auto find_local_service = local_services_.find(_service);
 	if (find_local_service != local_services_.end()) {
 		auto find_local_instance = find_local_service->second.find(_instance);
@@ -385,25 +445,28 @@ bool routing_manager_impl::is_available(service_t _service, instance_t _instance
 	return false;
 }
 
-const std::map< std::string, std::shared_ptr< servicegroup > > &
+const std::map<std::string, std::shared_ptr<servicegroup> > &
 routing_manager_impl::get_servicegroups() const {
 	return servicegroups_;
 }
 
-std::shared_ptr< configuration > routing_manager_impl::get_configuration() const {
+std::shared_ptr<configuration> routing_manager_impl::get_configuration() const {
 	return host_->get_configuration();
 }
 
 void routing_manager_impl::create_service_discovery_endpoint(
-		const std::string &_address, uint16_t _port, const std::string &_protocol) {
+		const std::string &_address, uint16_t _port,
+		const std::string &_protocol) {
 	bool is_reliable = (_protocol != "udp");
 
-	std::shared_ptr< endpoint > its_service_endpoint = find_server_endpoint(_port, is_reliable);
+	std::shared_ptr<endpoint> its_service_endpoint = find_server_endpoint(_port,
+			is_reliable);
 	if (!its_service_endpoint) {
 		its_service_endpoint = create_server_endpoint(_port, is_reliable);
 
-		std::shared_ptr< serviceinfo > its_info(
-				std::make_shared< serviceinfo >(any_major, any_minor, any_ttl));
+		std::shared_ptr<serviceinfo> its_info(
+				std::make_shared < serviceinfo
+						> (ANY_MAJOR, ANY_MINOR, ANY_TTL));
 		its_info->set_endpoint(its_service_endpoint, is_reliable);
 
 		// routing info
@@ -414,7 +477,8 @@ void routing_manager_impl::create_service_discovery_endpoint(
 	}
 }
 
-service_map_t routing_manager_impl::get_offered_services(const std::string &_name) const {
+service_map_t routing_manager_impl::get_offered_services(
+		const std::string &_name) const {
 	service_map_t its_offers;
 
 	auto find_servicegroup = servicegroups_.find(_name);
@@ -428,9 +492,9 @@ service_map_t routing_manager_impl::get_offered_services(const std::string &_nam
 ///////////////////////////////////////////////////////////////////////////////
 // PRIVATE
 ///////////////////////////////////////////////////////////////////////////////
-std::shared_ptr< serviceinfo > routing_manager_impl::find_service(
-									service_t _service, instance_t _instance) {
-	std::shared_ptr< serviceinfo > its_info;
+std::shared_ptr<serviceinfo> routing_manager_impl::find_service(
+		service_t _service, instance_t _instance) {
+	std::shared_ptr<serviceinfo> its_info;
 	auto found_service = services_.find(_service);
 	if (found_service != services_.end()) {
 		auto found_instance = found_service->second.find(_instance);
@@ -441,42 +505,48 @@ std::shared_ptr< serviceinfo > routing_manager_impl::find_service(
 	return its_info;
 }
 
-std::shared_ptr< serviceinfo > routing_manager_impl::create_service(
-	service_t _service, instance_t _instance,
-	major_version_t _major, minor_version_t _minor, ttl_t _ttl) {
-	std::shared_ptr< serviceinfo > its_info;
+std::shared_ptr<serviceinfo> routing_manager_impl::create_service(
+		service_t _service, instance_t _instance, major_version_t _major,
+		minor_version_t _minor, ttl_t _ttl) {
+	std::shared_ptr<serviceinfo> its_info;
 	if (configuration_) {
-		its_info = std::make_shared< serviceinfo >(_major, _minor, _ttl);
+		its_info = std::make_shared < serviceinfo > (_major, _minor, _ttl);
 
-		uint16_t its_reliable_port
-			= configuration_->get_reliable_port(_service, _instance);
-		uint16_t its_unreliable_port
-			= configuration_->get_unreliable_port(_service, _instance);
+		uint16_t its_reliable_port = configuration_->get_reliable_port(_service,
+				_instance);
+		uint16_t its_unreliable_port = configuration_->get_unreliable_port(
+				_service, _instance);
 
-		if (its_reliable_port != illegal_port) {
-			std::shared_ptr< endpoint > its_reliable_endpoint(
-				find_or_create_server_endpoint(its_reliable_port, true));
+		if (ILLEGAL_PORT != its_reliable_port) {
+			std::shared_ptr<endpoint> its_reliable_endpoint(
+					find_or_create_server_endpoint(its_reliable_port, true));
 			its_info->set_endpoint(its_reliable_endpoint, true);
 
 			// TODO: put this in a method and check whether an assignment already exists!
-			service_instances_[_service][its_reliable_endpoint.get()] = _instance;
+			service_instances_[_service][its_reliable_endpoint.get()] =
+					_instance;
 		}
 
-		if (its_unreliable_port != illegal_port) {
-			std::shared_ptr< endpoint > its_unreliable_endpoint(
-				find_or_create_server_endpoint(its_unreliable_port, false));
+		if (ILLEGAL_PORT != its_unreliable_port) {
+			std::shared_ptr<endpoint> its_unreliable_endpoint(
+					find_or_create_server_endpoint(its_unreliable_port, false));
 			its_info->set_endpoint(its_unreliable_endpoint, false);
 
-			service_instances_[_service][its_unreliable_endpoint.get()] = _instance;
+			service_instances_[_service][its_unreliable_endpoint.get()] =
+					_instance;
 		}
 
-		if (illegal_port != its_reliable_port || illegal_port != its_unreliable_port) {
-			std::string its_servicegroup = configuration_->get_group(_service, _instance);
+		if (ILLEGAL_PORT != its_reliable_port
+				|| ILLEGAL_PORT != its_unreliable_port) {
+			std::string its_servicegroup = configuration_->get_group(_service,
+					_instance);
 			auto found_servicegroup = servicegroups_.find(its_servicegroup);
 			if (found_servicegroup == servicegroups_.end()) {
-				servicegroups_[its_servicegroup] = std::make_shared< servicegroup >(its_servicegroup);
+				servicegroups_[its_servicegroup] = std::make_shared
+						< servicegroup > (its_servicegroup);
 			}
-			servicegroups_[its_servicegroup]->add_service(_service, _instance, its_info);
+			servicegroups_[its_servicegroup]->add_service(_service, _instance,
+					its_info);
 			services_[_service][_instance] = its_info;
 		} else {
 			host_->on_error(error_code_e::PORT_CONFIGURATION_MISSING);
@@ -488,41 +558,39 @@ std::shared_ptr< serviceinfo > routing_manager_impl::create_service(
 	return its_info;
 }
 
-std::shared_ptr< endpoint > routing_manager_impl::create_client_endpoint(
-		const boost::asio::ip::address &_address, uint16_t _port, bool _reliable) {
-	std::shared_ptr< endpoint > its_endpoint;
+std::shared_ptr<endpoint> routing_manager_impl::create_client_endpoint(
+		const boost::asio::ip::address &_address, uint16_t _port,
+		bool _reliable) {
+	std::shared_ptr<endpoint> its_endpoint;
 	try {
 		if (_reliable) {
-			its_endpoint = std::make_shared< tcp_client_endpoint_impl >(
-				shared_from_this(),
-				boost::asio::ip::tcp::endpoint(_address, _port),
-				io_
-			);
+			its_endpoint = std::make_shared < tcp_client_endpoint_impl
+					> (shared_from_this(), boost::asio::ip::tcp::endpoint(
+							_address, _port), io_);
 
-			if (configuration_->has_enabled_magic_cookies(_address.to_string(), _port)) {
+			if (configuration_->has_enabled_magic_cookies(_address.to_string(),
+					_port)) {
 				its_endpoint->enable_magic_cookies();
 			}
 		} else {
-			its_endpoint = std::make_shared< udp_client_endpoint_impl >(
-				shared_from_this(),
-				boost::asio::ip::udp::endpoint(_address, _port),
-				io_
-			);
+			its_endpoint = std::make_shared < udp_client_endpoint_impl
+					> (shared_from_this(), boost::asio::ip::udp::endpoint(
+							_address, _port), io_);
 		}
 
 		client_endpoints_[_address][_port][_reliable] = its_endpoint;
 		its_endpoint->start();
-	}
-	catch (std::exception &e) {
+	} catch (std::exception &e) {
 		host_->on_error(error_code_e::CLIENT_ENDPOINT_CREATION_FAILED);
 	}
 
 	return its_endpoint;
 }
 
-std::shared_ptr< endpoint > routing_manager_impl::find_client_endpoint(
-		const boost::asio::ip::address &_address, uint16_t _port, bool _reliable) {
-	std::shared_ptr< endpoint > its_endpoint;
+std::shared_ptr<endpoint> routing_manager_impl::find_client_endpoint(
+		const boost::asio::ip::address &_address, uint16_t _port,
+		bool _reliable) {
+	std::shared_ptr<endpoint> its_endpoint;
 	auto found_address = client_endpoints_.find(_address);
 	if (found_address != client_endpoints_.end()) {
 		auto found_port = found_address->second.find(_port);
@@ -536,54 +604,54 @@ std::shared_ptr< endpoint > routing_manager_impl::find_client_endpoint(
 	return its_endpoint;
 }
 
-std::shared_ptr< endpoint > routing_manager_impl::find_or_create_client_endpoint(
-		const boost::asio::ip::address &_address, uint16_t _port, bool _reliable) {
-	std::shared_ptr< endpoint > its_endpoint = find_client_endpoint(_address, _port, _reliable);
+std::shared_ptr<endpoint> routing_manager_impl::find_or_create_client_endpoint(
+		const boost::asio::ip::address &_address, uint16_t _port,
+		bool _reliable) {
+	std::shared_ptr<endpoint> its_endpoint = find_client_endpoint(_address,
+			_port, _reliable);
 	if (0 == its_endpoint) {
 		its_endpoint = create_client_endpoint(_address, _port, _reliable);
 	}
 	return its_endpoint;
 }
 
-std::shared_ptr< endpoint > routing_manager_impl::create_server_endpoint(uint16_t _port, bool _reliable) {
-	std::shared_ptr< endpoint > its_endpoint;
+std::shared_ptr<endpoint> routing_manager_impl::create_server_endpoint(
+		uint16_t _port, bool _reliable) {
+	std::shared_ptr<endpoint> its_endpoint;
 
 	try {
-		boost::asio::ip::address its_address = configuration_->get_address();
+		boost::asio::ip::address its_unicast = configuration_->get_unicast();
 		if (_reliable) {
-			its_endpoint = std::make_shared< tcp_server_endpoint_impl >(
-				shared_from_this(),
-				boost::asio::ip::tcp::endpoint(its_address, _port),
-				io_
-			);
-			if (configuration_->has_enabled_magic_cookies(its_address.to_string(), _port)) {
+			its_endpoint = std::make_shared < tcp_server_endpoint_impl
+					> (shared_from_this(), boost::asio::ip::tcp::endpoint(
+							its_unicast, _port), io_);
+			if (configuration_->has_enabled_magic_cookies(
+					its_unicast.to_string(), _port)) {
 				its_endpoint->enable_magic_cookies();
 			}
 		} else {
-			if (its_address.is_v4()) {
-				its_address = boost::asio::ip::address_v4::any();
+			if (its_unicast.is_v4()) {
+				its_unicast = boost::asio::ip::address_v4::any();
 			} else {
 				// TODO: how is "ANY" specified in IPv6?
 			}
-			its_endpoint = std::make_shared< udp_server_endpoint_impl >(
-				shared_from_this(),
-				boost::asio::ip::udp::endpoint(its_address, _port),
-				io_
-			);
+			its_endpoint = std::make_shared < udp_server_endpoint_impl
+					> (shared_from_this(), boost::asio::ip::udp::endpoint(
+							its_unicast, _port), io_);
 		}
 
 		server_endpoints_[_port][_reliable] = its_endpoint;
 		its_endpoint->start();
-	}
-	catch (std::exception &e) {
+	} catch (std::exception &e) {
 		host_->on_error(error_code_e::SERVER_ENDPOINT_CREATION_FAILED);
 	}
 
 	return its_endpoint;
 }
 
-std::shared_ptr< endpoint > routing_manager_impl::find_server_endpoint(uint16_t _port, bool _reliable) {
-	std::shared_ptr< endpoint > its_endpoint;
+std::shared_ptr<endpoint> routing_manager_impl::find_server_endpoint(
+		uint16_t _port, bool _reliable) {
+	std::shared_ptr<endpoint> its_endpoint;
 	auto found_port = server_endpoints_.find(_port);
 	if (found_port != server_endpoints_.end()) {
 		auto found_endpoint = found_port->second.find(_reliable);
@@ -594,17 +662,19 @@ std::shared_ptr< endpoint > routing_manager_impl::find_server_endpoint(uint16_t
 	return its_endpoint;
 }
 
-std::shared_ptr< endpoint > routing_manager_impl::find_or_create_server_endpoint(uint16_t _port, bool _reliable) {
-	std::shared_ptr< endpoint > its_endpoint = find_server_endpoint(_port, _reliable);
+std::shared_ptr<endpoint> routing_manager_impl::find_or_create_server_endpoint(
+		uint16_t _port, bool _reliable) {
+	std::shared_ptr<endpoint> its_endpoint = find_server_endpoint(_port,
+			_reliable);
 	if (0 == its_endpoint) {
 		its_endpoint = create_server_endpoint(_port, _reliable);
 	}
 	return its_endpoint;
 }
 
-std::shared_ptr< endpoint > routing_manager_impl::find_local(client_t _client) {
-	std::unique_lock< std::recursive_mutex > its_lock(endpoint_mutex_);
-	std::shared_ptr< endpoint > its_endpoint;
+std::shared_ptr<endpoint> routing_manager_impl::find_local(client_t _client) {
+	std::unique_lock < std::recursive_mutex > its_lock(endpoint_mutex_);
+	std::shared_ptr<endpoint> its_endpoint;
 	auto found_endpoint = local_clients_.find(_client);
 	if (found_endpoint != local_clients_.end()) {
 		its_endpoint = found_endpoint->second;
@@ -612,24 +682,24 @@ std::shared_ptr< endpoint > routing_manager_impl::find_local(client_t _client) {
 	return its_endpoint;
 }
 
-std::shared_ptr< endpoint > routing_manager_impl::create_local(client_t _client) {
-	std::unique_lock< std::recursive_mutex > its_lock(endpoint_mutex_);
+std::shared_ptr<endpoint> routing_manager_impl::create_local(client_t _client) {
+	std::unique_lock < std::recursive_mutex > its_lock(endpoint_mutex_);
 
 	std::stringstream its_path;
 	its_path << base_path << std::hex << _client;
 
-	std::shared_ptr< endpoint > its_endpoint
-		= std::make_shared< local_client_endpoint_impl >(
-				shared_from_this(),
-				boost::asio::local::stream_protocol::endpoint(its_path.str()),
-				io_);
+	std::shared_ptr<endpoint> its_endpoint =
+			std::make_shared < local_client_endpoint_impl
+					> (shared_from_this(), boost::asio::local::stream_protocol::endpoint(
+							its_path.str()), io_);
 	local_clients_[_client] = its_endpoint;
 	its_endpoint->start();
 	return its_endpoint;
 }
 
-std::shared_ptr< endpoint > routing_manager_impl::find_or_create_local(client_t _client) {
-	std::shared_ptr< endpoint > its_endpoint(find_local(_client));
+std::shared_ptr<endpoint> routing_manager_impl::find_or_create_local(
+		client_t _client) {
+	std::shared_ptr<endpoint> its_endpoint(find_local(_client));
 	if (!its_endpoint) {
 		its_endpoint = create_local(_client);
 	}
@@ -637,17 +707,19 @@ std::shared_ptr< endpoint > routing_manager_impl::find_or_create_local(client_t
 }
 
 void routing_manager_impl::remove_local(client_t _client) {
-	std::unique_lock< std::recursive_mutex > its_lock(endpoint_mutex_);
-	std::shared_ptr< endpoint > its_endpoint = find_local(_client);
+	std::unique_lock < std::recursive_mutex > its_lock(endpoint_mutex_);
+	std::shared_ptr<endpoint> its_endpoint = find_local(_client);
 	its_endpoint->stop();
 	local_clients_.erase(_client);
 }
 
-std::shared_ptr< endpoint > routing_manager_impl::find_local(service_t _service, instance_t _instance) {
+std::shared_ptr<endpoint> routing_manager_impl::find_local(service_t _service,
+		instance_t _instance) {
 	return find_local(find_local_client(_service, _instance));
 }
 
-client_t routing_manager_impl::find_local_client(service_t _service, instance_t _instance) {
+client_t routing_manager_impl::find_local_client(service_t _service,
+		instance_t _instance) {
 	client_t its_client(0);
 	auto found_service = local_services_.find(_service);
 	if (found_service != local_services_.end()) {
@@ -659,7 +731,8 @@ client_t routing_manager_impl::find_local_client(service_t _service, instance_t
 	return its_client;
 }
 
-instance_t routing_manager_impl::find_instance(service_t _service, endpoint * _endpoint) {
+instance_t routing_manager_impl::find_instance(service_t _service,
+		endpoint * _endpoint) {
 	instance_t its_instance(0xFFFF);
 	auto found_service = service_instances_.find(_service);
 	if (found_service != service_instances_.end()) {
@@ -671,9 +744,9 @@ instance_t routing_manager_impl::find_instance(service_t _service, endpoint * _e
 	return its_instance;
 }
 
-std::shared_ptr< endpoint > routing_manager_impl::find_remote_client(
+std::shared_ptr<endpoint> routing_manager_impl::find_remote_client(
 		service_t _service, instance_t _instance, bool _reliable) {
-	std::shared_ptr< endpoint > its_endpoint;
+	std::shared_ptr<endpoint> its_endpoint;
 	auto found_service = remote_services_.find(_service);
 	if (found_service != remote_services_.end()) {
 		auto found_instance = found_service->second.find(_instance);
@@ -687,15 +760,16 @@ std::shared_ptr< endpoint > routing_manager_impl::find_remote_client(
 	return its_endpoint;
 }
 
-void routing_manager_impl::add_routing_info(
-		service_t _service, instance_t _instance,
-		major_version_t _major, minor_version_t _minor,	ttl_t _ttl,
-		const boost::asio::ip::address &_address, uint16_t _port, bool _reliable) {
-	std::shared_ptr< serviceinfo > its_info(find_service(_service, _instance));
+void routing_manager_impl::add_routing_info(service_t _service,
+		instance_t _instance, major_version_t _major, minor_version_t _minor,
+		ttl_t _ttl, const boost::asio::ip::address &_address, uint16_t _port,
+		bool _reliable) {
+	std::shared_ptr<serviceinfo> its_info(find_service(_service, _instance));
 	if (!its_info)
 		its_info = create_service(_service, _instance, _major, _minor, _ttl);
 
-	std::shared_ptr< endpoint > its_endpoint(create_client_endpoint(_address, _port, _reliable));
+	std::shared_ptr<endpoint> its_endpoint(
+			create_client_endpoint(_address, _port, _reliable));
 	its_info->set_endpoint(its_endpoint, _reliable);
 	remote_services_[_service][_instance][_reliable] = its_endpoint;
 	service_instances_[_service][its_endpoint.get()] = _instance;
@@ -706,17 +780,19 @@ void routing_manager_impl::add_routing_info(
 		host_->on_availability(_service, _instance, true);
 }
 
-void routing_manager_impl::del_routing_info(
-		service_t _service, instance_t _instance, bool _reliable) {
-	std::shared_ptr< serviceinfo > its_info(find_service(_service, _instance));
+void routing_manager_impl::del_routing_info(service_t _service,
+		instance_t _instance, bool _reliable) {
+	std::shared_ptr<serviceinfo> its_info(find_service(_service, _instance));
 	if (its_info) {
-		std::shared_ptr< endpoint > its_empty_endpoint;
+		std::shared_ptr<endpoint> its_empty_endpoint;
 
 		// TODO: only tell the application if the service is completely gone
 		host_->on_availability(_service, _instance, false);
-		stub_->on_stop_offer_service(VSOMEIP_ROUTING_CLIENT, _service, _instance);
+		stub_->on_stop_offer_service(VSOMEIP_ROUTING_CLIENT, _service,
+				_instance);
 
-		std::shared_ptr< endpoint > its_endpoint = its_info->get_endpoint(_reliable);
+		std::shared_ptr<endpoint> its_endpoint = its_info->get_endpoint(
+				_reliable);
 		if (its_endpoint) {
 			if (1 >= service_instances_[_service].size()) {
 				service_instances_.erase(_service);
@@ -725,7 +801,8 @@ void routing_manager_impl::del_routing_info(
 			}
 
 			remote_services_[_service][_instance].erase(_reliable);
-			auto found_endpoint = remote_services_[_service][_instance].find(!_reliable);
+			auto found_endpoint = remote_services_[_service][_instance].find(
+					!_reliable);
 			if (found_endpoint == remote_services_[_service][_instance].end()) {
 				remote_services_[_service].erase(_instance);
 			}
@@ -748,22 +825,28 @@ void routing_manager_impl::del_routing_info(
 }
 
 void routing_manager_impl::init_routing_info() {
-	VSOMEIP_INFO << "Service Discovery disabled. Using static routing information.";
+	VSOMEIP_INFO
+			<< "Service Discovery disabled. Using static routing information.";
 	for (auto i : configuration_->get_remote_services()) {
-		std::string its_address = configuration_->get_address(i.first, i.second);
-		uint16_t its_reliable = configuration_->get_reliable_port(i.first, i.second);
-		uint16_t its_unreliable = configuration_->get_unreliable_port(i.first, i.second);
+		std::string its_address = configuration_->get_address(i.first,
+				i.second);
+		uint16_t its_reliable = configuration_->get_reliable_port(i.first,
+				i.second);
+		uint16_t its_unreliable = configuration_->get_unreliable_port(i.first,
+				i.second);
 
 		if (VSOMEIP_INVALID_PORT != its_reliable) {
 			add_routing_info(i.first, i.second,
-					default_major, default_minor, default_ttl,
-					boost::asio::ip::address::from_string(its_address), its_reliable, true);
+					DEFAULT_MAJOR, DEFAULT_MINOR, DEFAULT_TTL,
+					boost::asio::ip::address::from_string(its_address),
+					its_reliable, true);
 		}
 
 		if (VSOMEIP_INVALID_PORT != its_unreliable) {
 			add_routing_info(i.first, i.second,
-					default_major, default_minor, default_ttl,
-					boost::asio::ip::address::from_string(its_address), its_reliable, true);
+					DEFAULT_MAJOR, DEFAULT_MINOR, DEFAULT_TTL,
+					boost::asio::ip::address::from_string(its_address),
+					its_unreliable, false);
 		}
 	}
 }
diff --git a/implementation/routing/src/routing_manager_proxy.cpp b/implementation/routing/src/routing_manager_proxy.cpp
index 482e9c4..6971643 100644
--- a/implementation/routing/src/routing_manager_proxy.cpp
+++ b/implementation/routing/src/routing_manager_proxy.cpp
@@ -192,7 +192,7 @@ void routing_manager_proxy::release_service(client_t _client,
 }
 
 void routing_manager_proxy::subscribe(client_t _client,
-		service_t _service, instance_t _instance, eventgroup_t _eventgroup) {
+		service_t _service, instance_t _instance, eventgroup_t _eventgroup, major_version_t _major, ttl_t _ttl) {
 }
 
 void routing_manager_proxy::unsubscribe(client_t _client,