diff --git a/examples/client-sample.cpp b/examples/client-sample.cpp
index 7cb6862d4..eae5ea818 100644
--- a/examples/client-sample.cpp
+++ b/examples/client-sample.cpp
@@ -50,7 +50,7 @@ class client_sample {
 						  std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
 
 		app_->register_message_handler(
-				vsomeip::VSOMEIP_ANY_SERVICE, SAMPLE_INSTANCE_ID, vsomeip::VSOMEIP_ANY_METHOD,
+				vsomeip::any_service, SAMPLE_INSTANCE_ID, vsomeip::any_method,
 				std::bind(&client_sample::on_message,
 						  this,
 						  std::placeholders::_1));
diff --git a/implementation/configuration/src/configuration_impl.cpp b/implementation/configuration/src/configuration_impl.cpp
index 984a64529..3836880c2 100644
--- a/implementation/configuration/src/configuration_impl.cpp
+++ b/implementation/configuration/src/configuration_impl.cpp
@@ -18,6 +18,7 @@
 #include "../include/servicegroup.hpp"
 #include "../include/service.hpp"
 #include "../../logging/include/logger_impl.hpp"
+#include "../../service_discovery/include/defines.hpp"
 
 namespace vsomeip {
 namespace cfg {
@@ -237,7 +238,7 @@ bool configuration_impl::get_service_configuration(std::shared_ptr< servicegroup
 		bool use_magic_cookies(false);
 
 		std::shared_ptr< service > its_service(std::make_shared< service >());
-		its_service->reliable_ = its_service->unreliable_ = VSOMEIP_ILLEGAL_PORT;
+		its_service->reliable_ = its_service->unreliable_ = illegal_port;
 		its_service->use_magic_cookies_ = false;
 
 		its_service->group_ = _group;
@@ -535,7 +536,7 @@ std::string configuration_impl::get_address(service_t _service, instance_t _inst
 }
 
 uint16_t configuration_impl::get_reliable_port(service_t _service, instance_t _instance) const {
-	uint16_t its_reliable = VSOMEIP_ILLEGAL_PORT;
+	uint16_t its_reliable = illegal_port;
 
 	service *its_service = find_service(_service, _instance);
 	if (its_service) its_reliable = its_service->reliable_;
@@ -556,7 +557,7 @@ bool configuration_impl::has_enabled_magic_cookies(std::string _address, uint16_
 }
 
 uint16_t configuration_impl::get_unreliable_port(service_t _service, instance_t _instance) const {
-	uint16_t its_unreliable = VSOMEIP_ILLEGAL_PORT;
+	uint16_t its_unreliable = illegal_port;
 
 	service *its_service = find_service(_service, _instance);
 	if (its_service) its_unreliable = its_service->unreliable_;
@@ -565,7 +566,7 @@ uint16_t configuration_impl::get_unreliable_port(service_t _service, instance_t
 }
 
 std::string configuration_impl::get_multicast(service_t _service, instance_t _instance) const {
-	std::string its_multicast(VSOMEIP_DEFAULT_MULTICAST);
+	std::string its_multicast(default_multicast);
 
 	service *its_service = find_service(_service, _instance);
 	if (its_service) its_multicast = its_service->multicast_;
diff --git a/implementation/endpoints/src/endpoint_impl.cpp b/implementation/endpoints/src/endpoint_impl.cpp
index 1ce447861..d386b3d45 100644
--- a/implementation/endpoints/src/endpoint_impl.cpp
+++ b/implementation/endpoints/src/endpoint_impl.cpp
@@ -66,14 +66,14 @@ bool endpoint_impl< MaxBufferSize >::resync_on_magic_cookie(message_buffer_t &_b
 
 		if (is_client()) {
 			its_cookie_identifier
-				= static_cast< uint8_t >(VSOMEIP_MAGIC_COOKIE_SERVICE_MESSAGE_ID);
+				= static_cast< uint8_t >(magic_cookie_service_message);
 			its_cookie_type
-				= static_cast< uint8_t >(VSOMEIP_MAGIC_COOKIE_SERVICE_MESSAGE_TYPE);
+				= static_cast< uint8_t >(magic_cookie_service_message_type);
 		} else {
 			its_cookie_identifier
-				= static_cast< uint8_t >(VSOMEIP_MAGIC_COOKIE_CLIENT_MESSAGE_ID);
+				= static_cast< uint8_t >(magic_cookie_client_message);
 			its_cookie_type
-				= static_cast< uint8_t >(VSOMEIP_MAGIC_COOKIE_CLIENT_MESSAGE_TYPE);
+				= static_cast< uint8_t >(magic_cookie_client_message_type);
 		}
 
 		do {
diff --git a/implementation/endpoints/src/udp_server_endpoint_impl.cpp b/implementation/endpoints/src/udp_server_endpoint_impl.cpp
index e4f0e8910..b47b4c5af 100644
--- a/implementation/endpoints/src/udp_server_endpoint_impl.cpp
+++ b/implementation/endpoints/src/udp_server_endpoint_impl.cpp
@@ -62,7 +62,7 @@ void udp_server_endpoint_impl::restart() {
 }
 
 void udp_server_endpoint_impl::send_queued(endpoint_type _target, message_buffer_ptr_t _buffer) {
-#if 0
+#if 1
 		std::stringstream msg;
 		msg << "usei::sq(" << _target.address().to_string() << ":" << _target.port() << "): ";
 		for (std::size_t i = 0; i < _buffer->size(); ++i)
diff --git a/implementation/message/include/deserializer.hpp b/implementation/message/include/deserializer.hpp
index 871cbf41e..7bff4b4cf 100644
--- a/implementation/message/include/deserializer.hpp
+++ b/implementation/message/include/deserializer.hpp
@@ -18,12 +18,12 @@ class message;
 class deserializer {
 public:
 	deserializer();
-	deserializer(uint8_t *_data, std::size_t _length);
+	deserializer(byte_t *_data, std::size_t _length);
 	deserializer(const deserializer& _other);
 	virtual ~deserializer();
 
-	void set_data(const uint8_t *_data, std::size_t _length);
-	void append_data(const uint8_t *_data, std::size_t _length);
+	void set_data(const byte_t *_data, std::size_t _length);
+	void append_data(const byte_t *_data, std::size_t _length);
 	void drop_data(std::size_t _length);
 
 	std::size_t get_available() const;
@@ -46,12 +46,12 @@ class deserializer {
 	bool look_ahead(std::size_t _index, uint32_t &_value) const;
 
 	void reset();
-#ifdef VSOMEIP_DEBUG
-	void show_data() const;
+#ifdef VSOMEIP_DEBUGGING
+	void show() const;
 #endif
 protected:
-	std::vector< uint8_t > data_;
-	std::vector< uint8_t >::iterator position_;
+	std::vector< byte_t > data_;
+	std::vector< byte_t >::iterator position_;
 	std::size_t remaining_;
 };
 
diff --git a/implementation/message/include/serializer.hpp b/implementation/message/include/serializer.hpp
index 57bb7ab15..d07f6690c 100644
--- a/implementation/message/include/serializer.hpp
+++ b/implementation/message/include/serializer.hpp
@@ -7,9 +7,10 @@
 #ifndef VSOMEIP_SERIALIZER_HPP
 #define VSOMEIP_SERIALIZER_HPP
 
-#include <cstdint>
 #include <vector>
 
+#include <vsomeip/primitive_types.hpp>
+
 namespace vsomeip {
 
 class serializable;
@@ -36,13 +37,14 @@ class serializer
 
 	virtual void reset();
 
+#ifdef VSOMEIP_DEBUGGING
 	virtual void show();
-
+#endif
 private:
-	uint8_t * data_;
+	byte_t * data_;
 	uint32_t capacity_;
 
-	uint8_t *position_;
+	byte_t *position_;
 	uint32_t remaining_;
 };
 
diff --git a/implementation/message/src/deserializer.cpp b/implementation/message/src/deserializer.cpp
index c6d3b70e2..05abcf789 100644
--- a/implementation/message/src/deserializer.cpp
+++ b/implementation/message/src/deserializer.cpp
@@ -5,7 +5,13 @@
 // file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 #include <cstring>
-#include <iostream>
+
+#ifdef VSOMEIP_DEBUGGING
+#include <iomanip>
+#include <sstream>
+
+#include <vsomeip/logger.hpp>
+#endif
 
 #include "../include/byteorder.hpp"
 #include "../include/message_impl.hpp"
@@ -18,7 +24,7 @@ deserializer::deserializer()
 	  remaining_(0) {
 }
 
-deserializer::deserializer(uint8_t *_data, std::size_t _length)
+deserializer::deserializer(byte_t *_data, std::size_t _length)
 	: data_(_data, _data + _length),
 	  position_(data_.begin()),
 	  remaining_(_length) {
@@ -92,20 +98,20 @@ bool deserializer::deserialize(uint8_t *_data, std::size_t _length) {
 	if (_length > remaining_)
 		return false;
 
-	::memcpy(_data, &_data[position_ - data_.begin()], _length);
+	std::memcpy(_data, &data_[position_ - data_.begin()], _length);
 	position_ += _length;
 	remaining_ -= _length;
 
 	return true;
 }
 
-bool deserializer::deserialize(std::vector<uint8_t>& _value) {
+bool deserializer::deserialize(std::vector< uint8_t >& _value) {
 	if (_value.capacity() > remaining_)
 		return false;
 
 	_value.assign(position_, position_ + _value.capacity());
-	remaining_ -= _value.capacity();
 	position_ += _value.capacity();
+	remaining_ -= _value.capacity();
 
 	return true;
 }
@@ -151,7 +157,7 @@ message * deserializer::deserialize_message() {
 	return deserialized_message;
 }
 
-void deserializer::set_data(const uint8_t *_data,  std::size_t _length) {
+void deserializer::set_data(const byte_t *_data,  std::size_t _length) {
 	if (0 != _data) {
 		data_.assign(_data, _data + _length);
 		position_ = data_.begin();
@@ -163,7 +169,7 @@ void deserializer::set_data(const uint8_t *_data,  std::size_t _length) {
 	}
 }
 
-void deserializer::append_data(const uint8_t *_data, std::size_t _length) {
+void deserializer::append_data(const byte_t *_data, std::size_t _length) {
 	std::size_t offset = (position_ - data_.begin());
 	data_.insert(data_.end(), _data, _data + _length);
 	position_ = data_.begin() + offset;
@@ -183,14 +189,15 @@ void deserializer::reset() {
 	remaining_ = data_.size();
 }
 
-#ifdef VSOMEIP_DEBUG_
-void deserializer::show_data() const {
-	std::cout << "("
-			  << std::hex << std::setw(2) << std::setfill('0') << (int)*position_ << ", "
-			  << std:: dec << remaining_ << ") ";
+#ifdef VSOMEIP_DEBUGGING
+void deserializer::show() const {
+	std::stringstream its_message;
+	its_message << "("
+			<< std::hex << std::setw(2) << std::setfill('0') << (int)*position_ << ", "
+			<< std:: dec << remaining_ << ") ";
 	for (int i = 0; i < data_.size(); ++i)
-		std::cout << std::hex << std::setw(2) << std::setfill('0') << (int)data_[i] << " ";
-	std::cout << std::dec << std::endl;
+		its_message << std::hex << std::setw(2) << std::setfill('0') << (int)data_[i] << " ";
+	VSOMEIP_DEBUG << its_message;
 }
 #endif
 
diff --git a/implementation/message/src/serializer.cpp b/implementation/message/src/serializer.cpp
index 59441bf03..990bba5e0 100644
--- a/implementation/message/src/serializer.cpp
+++ b/implementation/message/src/serializer.cpp
@@ -5,10 +5,14 @@
 // file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 #include <cstring>
+
+#ifdef VSOMEIP_DEBUGGING
 #include <iomanip>
 #include <sstream>
 
 #include <vsomeip/logger.hpp>
+#endif
+
 #include <vsomeip/serializable.hpp>
 
 #include "../include/byteorder.hpp"
@@ -75,7 +79,7 @@ bool serializer::serialize(const uint8_t *_data, uint32_t _length) {
 	return true;
 }
 
-uint8_t * serializer::get_data() const {
+byte_t * serializer::get_data() const {
 	return data_;
 }
 
@@ -91,7 +95,7 @@ void serializer::create_data(uint32_t _capacity) {
 	if (0 != data_)
 		delete [] data_;
 
-	data_ = new uint8_t[_capacity];
+	data_ = new byte_t[_capacity];
 	position_ = data_;
 	if (0 != data_) {
 		capacity_ = remaining_ = _capacity;
@@ -100,7 +104,7 @@ void serializer::create_data(uint32_t _capacity) {
 	}
 }
 
-void serializer::set_data(uint8_t *_data, uint32_t _capacity) {
+void serializer::set_data(byte_t *_data, uint32_t _capacity) {
 	delete [] data_;
 
 	data_ = _data;
@@ -118,6 +122,7 @@ void serializer::reset() {
 	remaining_ = capacity_;
 }
 
+#ifdef VSOMEIP_DEBUGGING
 void serializer::show() {
 	std::stringstream its_data;
 	its_data << "SERIALIZED: ";
@@ -125,5 +130,6 @@ void serializer::show() {
 		its_data << std::setw(2) << std::setfill('0') << std::hex << (int)data_[i];
 	VSOMEIP_DEBUG << its_data.str();
 }
+#endif
 
 } // namespace vsomeip
diff --git a/implementation/routing/src/routing_manager_impl.cpp b/implementation/routing/src/routing_manager_impl.cpp
index f1dcdf9f0..cb43f6d1e 100644
--- a/implementation/routing/src/routing_manager_impl.cpp
+++ b/implementation/routing/src/routing_manager_impl.cpp
@@ -28,7 +28,7 @@
 #include "../../message/include/deserializer.hpp"
 #include "../../message/include/event_impl.hpp"
 #include "../../message/include/serializer.hpp"
-#include "../../service_discovery/include/constants.hpp"
+#include "../../service_discovery/include/defines.hpp"
 #include "../../service_discovery/include/runtime.hpp"
 #include "../../service_discovery/include/service_discovery_impl.hpp"
 #include "../../utility/include/utility.hpp"
@@ -296,24 +296,29 @@ void routing_manager_impl::on_message(const byte_t *_data, length_t _size, endpo
 #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]);
-		instance_t its_instance = find_instance(its_service, _receiver);
-		if (its_instance != VSOMEIP_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]);
-			}
+		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) {
+				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]);
+				}
 
-			if (its_client == host_->get_client()) {
-				deliver_message(_data, _size, its_instance);
-			} else if (its_client != VSOMEIP_ROUTING_CLIENT) {
-				send(its_client, _data, _size, its_instance, true, false);
+				if (its_client == host_->get_client()) {
+					deliver_message(_data, _size, its_instance);
+				} else if (its_client != VSOMEIP_ROUTING_CLIENT) {
+					send(its_client, _data, _size, its_instance, true, false);
+				} else {
+					VSOMEIP_ERROR << "Could not determine target application!";
+				}
 			} else {
-				VSOMEIP_ERROR << "Could not determine target application!";
+				VSOMEIP_ERROR << "Could not determine service instance for [" << its_service << "]";
 			}
-		} else {
-			VSOMEIP_ERROR << "Could not determine service instance for [" << its_service << "]";
 		}
 	} else {
 		//send_error(); // TODO: send error "malformed message"
@@ -402,7 +407,7 @@ void routing_manager_impl::create_service_discovery_endpoint(
 		its_service_endpoint = create_server_endpoint(_port, is_reliable);
 
 		std::shared_ptr< serviceinfo > its_info(std::make_shared< serviceinfo >(
-				VSOMEIP_ANY_MAJOR, VSOMEIP_ANY_MINOR, VSOMEIP_ANY_TTL));
+				any_major, any_minor, any_ttl));
 		if (is_reliable) {
 			its_info->set_reliable_endpoint(its_service_endpoint);
 		} else {
@@ -410,7 +415,7 @@ void routing_manager_impl::create_service_discovery_endpoint(
 		}
 
 		// routing info
-		services_[vsomeip::sd::VSOMEIP_SD_SERVICE][vsomeip::sd::VSOMEIP_SD_INSTANCE] = its_info;
+		services_[VSOMEIP_SD_SERVICE][VSOMEIP_SD_INSTANCE] = its_info;
 
 		its_service_endpoint->join(_address);
 		its_service_endpoint->start();
@@ -453,7 +458,7 @@ void routing_manager_impl::create_service(
 		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 != VSOMEIP_ILLEGAL_PORT) {
+		if (its_reliable_port != illegal_port) {
 			std::shared_ptr< endpoint > its_reliable_endpoint(
 				find_or_create_server_endpoint(its_reliable_port, true));
 			its_info->set_reliable_endpoint(its_reliable_endpoint);
@@ -462,7 +467,7 @@ void routing_manager_impl::create_service(
 			service_instances_[_service][its_reliable_endpoint.get()] = _instance;
 		}
 
-		if (its_unreliable_port != VSOMEIP_ILLEGAL_PORT) {
+		if (its_unreliable_port != illegal_port) {
 			std::shared_ptr< endpoint > its_unreliable_endpoint(
 				find_or_create_server_endpoint(its_unreliable_port, false));
 			its_info->set_unreliable_endpoint(its_unreliable_endpoint);
@@ -470,7 +475,7 @@ void routing_manager_impl::create_service(
 			service_instances_[_service][its_unreliable_endpoint.get()] = _instance;
 		}
 
-		if (VSOMEIP_ILLEGAL_PORT != its_reliable_port || VSOMEIP_ILLEGAL_PORT != its_unreliable_port) {
+		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()) {
@@ -615,7 +620,7 @@ 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 << VSOMEIP_BASE_PATH << std::hex << _client;
+	its_path << base_path << std::hex << _client;
 
 	std::shared_ptr< endpoint > its_endpoint
 		= std::make_shared< local_client_endpoint_impl >(
@@ -690,7 +695,7 @@ void routing_manager_impl::init_routing_info() {
 	VSOMEIP_INFO << "Service Discovery disabled. Using static routing information.";
 	for (auto i : configuration_->get_remote_services()) {
 		std::shared_ptr< serviceinfo > its_info(std::make_shared< serviceinfo >(
-				VSOMEIP_DEFAULT_MAJOR, VSOMEIP_DEFAULT_MINOR, VSOMEIP_DEFAULT_TTL));
+				default_major, default_minor, default_ttl));
 
 		std::string its_address = configuration_->get_address(i.first, i.second);
 		uint16_t its_reliable_port = configuration_->get_reliable_port(i.first, i.second);
diff --git a/implementation/routing/src/routing_manager_proxy.cpp b/implementation/routing/src/routing_manager_proxy.cpp
index 2092c0d23..a8b6bdc2b 100644
--- a/implementation/routing/src/routing_manager_proxy.cpp
+++ b/implementation/routing/src/routing_manager_proxy.cpp
@@ -55,7 +55,7 @@ void routing_manager_proxy::init() {
 	sender_ = create_local(VSOMEIP_ROUTING_CLIENT);
 
 	std::stringstream its_client;
-	its_client << VSOMEIP_BASE_PATH << std::hex << client_;
+	its_client << base_path << std::hex << client_;
 
 	::unlink(its_client.str().c_str());
 	receiver_ = std::make_shared< local_server_endpoint_impl >(
@@ -85,7 +85,7 @@ void routing_manager_proxy::stop() {
 		receiver_->stop();
 
 	std::stringstream its_client;
-	its_client << VSOMEIP_BASE_PATH << std::hex << client_;
+	its_client << base_path << std::hex << client_;
 	::unlink(its_client.str().c_str());
 }
 
@@ -454,7 +454,7 @@ std::shared_ptr< endpoint > routing_manager_proxy::find_local(client_t _client)
 
 std::shared_ptr< endpoint > routing_manager_proxy::create_local(client_t _client) {
 	std::stringstream its_path;
-	its_path << VSOMEIP_BASE_PATH << std::hex << _client;
+	its_path << base_path << std::hex << _client;
 
 	VSOMEIP_DEBUG << "Connecting to [" << std::hex << _client
 				  << "] at " << its_path.str();
diff --git a/implementation/routing/src/routing_manager_stub.cpp b/implementation/routing/src/routing_manager_stub.cpp
index 07d60b5a3..df16d7e92 100644
--- a/implementation/routing/src/routing_manager_stub.cpp
+++ b/implementation/routing/src/routing_manager_stub.cpp
@@ -30,7 +30,7 @@ routing_manager_stub::~routing_manager_stub() {
 
 void routing_manager_stub::init() {
 	std::stringstream its_endpoint_path;
-	its_endpoint_path << VSOMEIP_BASE_PATH << VSOMEIP_ROUTING_CLIENT;
+	its_endpoint_path << base_path << VSOMEIP_ROUTING_CLIENT;
 	::unlink(its_endpoint_path.str().c_str());
 
 	VSOMEIP_DEBUG << "Routing endpoint at " << its_endpoint_path.str();
@@ -53,7 +53,7 @@ void routing_manager_stub::stop() {
 	endpoint_->stop();
 
 	std::stringstream its_endpoint_path;
-	its_endpoint_path << VSOMEIP_BASE_PATH << VSOMEIP_ROUTING_CLIENT;
+	its_endpoint_path << base_path << VSOMEIP_ROUTING_CLIENT;
 	::unlink(its_endpoint_path.str().c_str());
 }
 
diff --git a/implementation/runtime/src/application_impl.cpp b/implementation/runtime/src/application_impl.cpp
index dd6230e5a..3f6be20ef 100644
--- a/implementation/runtime/src/application_impl.cpp
+++ b/implementation/runtime/src/application_impl.cpp
@@ -281,17 +281,17 @@ void application_impl::on_message(std::shared_ptr< message > _message) {
 	// find list of handlers
 	auto found_service = members_.find(its_service);
 	if (found_service == members_.end()) {
-		found_service = members_.find(VSOMEIP_ANY_SERVICE);
+		found_service = members_.find(any_service);
 	}
 	if (found_service != members_.end()) {
 		auto found_instance = found_service->second.find(its_instance);
 		if (found_instance == found_service->second.end()) {
-			found_instance = found_service->second.find(VSOMEIP_ANY_SERVICE);
+			found_instance = found_service->second.find(any_instance);
 		}
 		if (found_instance != found_service->second.end()) {
 			auto found_method = found_instance->second.find(its_method);
 			if (found_method == found_instance->second.end()) {
-				found_method = found_instance->second.find(VSOMEIP_ANY_METHOD);
+				found_method = found_instance->second.find(any_method);
 			}
 
 			if (found_method != found_instance->second.end()) {
diff --git a/implementation/service_discovery/include/constants.hpp b/implementation/service_discovery/include/constants.hpp
index d08388220..832e87b3c 100644
--- a/implementation/service_discovery/include/constants.hpp
+++ b/implementation/service_discovery/include/constants.hpp
@@ -13,14 +13,14 @@
 namespace vsomeip {
 namespace sd {
 
-const service_t VSOMEIP_SD_SERVICE = 0xFFFF;
-const instance_t VSOMEIP_SD_INSTANCE = 0x0000;
-const method_t  VSOMEIP_SD_METHOD  = 0x8100;
-const client_t VSOMEIP_SD_CLIENT = 0x0000;
-const protocol_version_t VSOMEIP_SD_PROTOCOL_VERSION = 0x01;
-const interface_version_t VSOMEIP_SD_INTERFACE_VERSION = 0x01;
-const message_type_e VSOMEIP_SD_MESSAGE_TYPE = message_type_e::NOTIFICATION;
-const return_code_e VSOMEIP_SD_RETURN_CODE = return_code_e::E_OK;
+const service_t service = 0xFFFF;
+const instance_t instance = 0x0000;
+const method_t  method  = 0x8100;
+const client_t client = 0x0000;
+const protocol_version_t protocol_version = 0x01;
+const interface_version_t interface_version = 0x01;
+const message_type_e message_type = message_type_e::NOTIFICATION;
+const return_code_e return_code = return_code_e::E_OK;
 
 namespace protocol {
 
diff --git a/implementation/service_discovery/include/defines.hpp b/implementation/service_discovery/include/defines.hpp
index ae15416c8..3390940dc 100644
--- a/implementation/service_discovery/include/defines.hpp
+++ b/implementation/service_discovery/include/defines.hpp
@@ -11,4 +11,16 @@
 #define VSOMEIP_SOMEIP_SD_ENTRY_SIZE			16
 #define VSOMEIP_SOMEIP_SD_OPTION_HEADER_SIZE	 3
 
+#define VSOMEIP_SD_SERVICE						0xFFFF
+#define VSOMEIP_SD_INSTANCE						0x0000
+#define VSOMEIP_SD_METHOD						0x8100
+#define VSOMEIP_SD_CLIENT						0x0000
+
+#define VSOMEIP_DEFAULT_MIN_INITIAL_DELAY		0
+#define VSOMEIP_DEFAULT_MAX_INITIAL_DELAY		3000
+#define VSOMEIP_DEFAULT_REPETITION_BASE_DELAY	10
+#define VSOMEIP_DEFAULT_REPETITION_MAX			5
+#define VSOMEIP_DEFAULT_CYCLIC_OFFER_DELAY		1000
+#define VSOMEIP_DEFAULT_CYCLIC_REQUEST_DELAY	2000
+
 #endif // VSOMEIP_SD_DEFINES_HPP
diff --git a/implementation/service_discovery/include/service_discovery.hpp b/implementation/service_discovery/include/service_discovery.hpp
index e49c749fa..4fd2a3040 100644
--- a/implementation/service_discovery/include/service_discovery.hpp
+++ b/implementation/service_discovery/include/service_discovery.hpp
@@ -36,6 +36,8 @@ class service_discovery {
 	virtual void release_service(service_t _service, instance_t _instance) = 0;
 
 	virtual void send(const std::string &_name, bool _is_announcing) = 0;
+
+	virtual void on_message(const byte_t *_data, length_t _length) = 0;
 };
 
 } // namespace sd
diff --git a/implementation/service_discovery/include/service_discovery_impl.hpp b/implementation/service_discovery/include/service_discovery_impl.hpp
index 8110f6c71..7868b5c88 100644
--- a/implementation/service_discovery/include/service_discovery_impl.hpp
+++ b/implementation/service_discovery/include/service_discovery_impl.hpp
@@ -46,8 +46,7 @@ class service_discovery_impl:
 
 	void send(const std::string &_name, bool _is_announcing);
 
-	// endpoint_host
-	void on_message(const byte_t *_data, length_t _length, endpoint *_receiver);
+	void on_message(const byte_t *_data, length_t _length);
 
 private:
 	void insert_service_entries(std::shared_ptr< message_impl > &_message,
@@ -57,6 +56,8 @@ class service_discovery_impl:
 	boost::asio::io_service &io_;
 	service_discovery_host *host_;
 
+	std::shared_ptr< deserializer > deserializer_;
+
 	std::shared_ptr< service_discovery_fsm > default_;
 	std::map< std::string,
 			  std::shared_ptr< service_discovery_fsm > > additional_;
diff --git a/implementation/service_discovery/src/ipv4_option_impl.cpp b/implementation/service_discovery/src/ipv4_option_impl.cpp
index 5c1d863cb..2b68a07ef 100644
--- a/implementation/service_discovery/src/ipv4_option_impl.cpp
+++ b/implementation/service_discovery/src/ipv4_option_impl.cpp
@@ -70,7 +70,8 @@ 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;
-	_from->deserialize(&address_[0], 16);
+	address_.resize(4);
+	_from->deserialize(address_);
 	_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 9408e437f..654de2976 100755
--- a/implementation/service_discovery/src/ipv6_option_impl.cpp
+++ b/implementation/service_discovery/src/ipv6_option_impl.cpp
@@ -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], 4);
+	_from->deserialize(&address_[0], 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 b5c6d05fd..63af01633 100755
--- a/implementation/service_discovery/src/message_impl.cpp
+++ b/implementation/service_discovery/src/message_impl.cpp
@@ -173,12 +173,12 @@ bool message_impl::serialize(vsomeip::serializer *_to) const {
 		is_successful = is_successful && (*it)->serialize(_to);
 
 	uint32_t options_length = 0;
-	for (size_t i = 0; i < options_.size(); ++i)
-		options_length += (options_[i]->get_length() + VSOMEIP_SOMEIP_HEADER_SIZE);
+	for (auto its_option : options_)
+		options_length += its_option->get_length() + VSOMEIP_SOMEIP_SD_OPTION_HEADER_SIZE;
 	is_successful = is_successful && _to->serialize(options_length);
 
-	for (auto it = options_.begin(); it != options_.end(); ++it)
-		is_successful = is_successful && (*it)->serialize(_to);
+	for (auto its_option : options_)
+		is_successful = is_successful && its_option->serialize(_to);
 
 	return is_successful;
 }
diff --git a/implementation/service_discovery/src/runtime_impl.cpp b/implementation/service_discovery/src/runtime_impl.cpp
index b1f9b47eb..6a88d42f6 100644
--- a/implementation/service_discovery/src/runtime_impl.cpp
+++ b/implementation/service_discovery/src/runtime_impl.cpp
@@ -8,6 +8,7 @@
 #include <vsomeip/message.hpp>
 
 #include "../include/constants.hpp"
+#include "../include/defines.hpp"
 #include "../include/message_impl.hpp"
 #include "../include/runtime_impl.hpp"
 #include "../include/service_discovery_impl.hpp"
@@ -34,10 +35,10 @@ std::shared_ptr< message_impl > runtime_impl::create_message() const {
 	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);
+	its_message->set_protocol_version(protocol_version);
+	its_message->set_interface_version(interface_version);
+	its_message->set_message_type(message_type);
+	its_message->set_return_code(return_code);
 	return its_message;
 }
 
diff --git a/implementation/service_discovery/src/service_discovery_impl.cpp b/implementation/service_discovery/src/service_discovery_impl.cpp
index 3b5cebf4c..30f27dafd 100644
--- a/implementation/service_discovery/src/service_discovery_impl.cpp
+++ b/implementation/service_discovery/src/service_discovery_impl.cpp
@@ -8,6 +8,8 @@
 #include <vsomeip/logger.hpp>
 
 #include "../include/constants.hpp"
+#include "../include/defines.hpp"
+#include "../include/deserializer.hpp"
 #include "../include/ipv4_option_impl.hpp"
 #include "../include/ipv6_option_impl.hpp"
 #include "../include/message_impl.hpp"
@@ -25,8 +27,10 @@ namespace vsomeip {
 namespace sd {
 
 service_discovery_impl::service_discovery_impl(service_discovery_host *_host) :
-		host_(_host), io_(_host->get_io()), default_(
-				std::make_shared < service_discovery_fsm > ("default", this)) {
+		host_(_host),
+		io_(_host->get_io()),
+		default_(std::make_shared < service_discovery_fsm > ("default", this)),
+		deserializer_(std::make_shared< deserializer >()) {
 }
 
 service_discovery_impl::~service_discovery_impl() {
@@ -199,9 +203,12 @@ 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,
-		endpoint *_receiver) {
-	VSOMEIP_DEBUG << "sdi::on_message";
+void service_discovery_impl::on_message(const byte_t *_data, length_t _length) {
+	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.";
+	}
 }
 
 } // namespace sd
diff --git a/interface/vsomeip/application.hpp b/interface/vsomeip/application.hpp
index 53277cbcb..03289a538 100644
--- a/interface/vsomeip/application.hpp
+++ b/interface/vsomeip/application.hpp
@@ -32,9 +32,9 @@ class application {
 
 	// Provide services
 	virtual void offer_service(service_t _service, instance_t _instance,
-					major_version_t _major = VSOMEIP_DEFAULT_MAJOR,
-					minor_version_t _minor = VSOMEIP_DEFAULT_MINOR, ttl_t _ttl =
-					VSOMEIP_DEFAULT_TTL) = 0;
+					major_version_t _major = default_major,
+					minor_version_t _minor = default_minor,
+					ttl_t _ttl = default_ttl) = 0;
 
 	virtual void stop_offer_service(service_t _service,
 					instance_t _instance) = 0;
@@ -48,9 +48,9 @@ class application {
 
 	// Consume services
 	virtual void request_service(service_t _service, instance_t _instance,
-					major_version_t _major = VSOMEIP_ANY_MAJOR,
-					minor_version_t _minor = VSOMEIP_ANY_MINOR,
-					ttl_t _ttl = VSOMEIP_ANY_TTL) = 0;
+					major_version_t _major = any_major,
+					minor_version_t _minor = any_minor,
+					ttl_t _ttl = any_ttl) = 0;
 
 	virtual void release_service(service_t _service, instance_t _instance) = 0;
 
diff --git a/interface/vsomeip/constants.hpp b/interface/vsomeip/constants.hpp
index 71c196a80..e15980c3c 100644
--- a/interface/vsomeip/constants.hpp
+++ b/interface/vsomeip/constants.hpp
@@ -14,32 +14,32 @@
 
 namespace vsomeip {
 
-const std::string VSOMEIP_BASE_PATH = "/tmp/vsomeip-";
-
-const major_version_t VSOMEIP_DEFAULT_MAJOR = 0x01;
-const minor_version_t VSOMEIP_DEFAULT_MINOR = 0x000000;
-const ttl_t VSOMEIP_DEFAULT_TTL = 0xFFFFFF; // basically means "forever"
-
-const std::string VSOMEIP_DEFAULT_MULTICAST = "224.0.0.0";
-const uint16_t VSOMEIP_DEFAULT_PORT = 30500;
-const uint16_t VSOMEIP_ILLEGAL_PORT = 0xFFFF;
-
-const service_t VSOMEIP_ANY_SERVICE = 0xFFFF;
-const instance_t VSOMEIP_ANY_INSTANCE = 0xFFFF;
-const method_t VSOMEIP_ANY_METHOD = 0xFFFF;
-const major_version_t VSOMEIP_ANY_MAJOR = 0xFF;
-const minor_version_t VSOMEIP_ANY_MINOR = 0xFFFFFF;
-const ttl_t VSOMEIP_ANY_TTL = 1;
-
-const byte_t VSOMEIP_MAGIC_COOKIE_CLIENT_MESSAGE_ID = 0x00;
-const byte_t VSOMEIP_MAGIC_COOKIE_SERVICE_MESSAGE_ID = 0x80;
-const length_t VSOMEIP_MAGIC_COOKIE_SIZE = 0x00000008;
-const request_t VSOMEIP_MAGIC_COOKIE_REQUEST_ID	= 0xDEADBEEF;
-const protocol_version_t VSOMEIP_MAGIC_COOKIE_PROTOCOL_VERSION = 0x01;
-const interface_version_t VSOMEIP_MAGIC_COOKIE_INTERFACE_VERSION = 0x01;
-const message_type_e VSOMEIP_MAGIC_COOKIE_CLIENT_MESSAGE_TYPE = message_type_e::REQUEST_NO_RETURN;
-const message_type_e VSOMEIP_MAGIC_COOKIE_SERVICE_MESSAGE_TYPE = message_type_e::NOTIFICATION;
-const return_code_e VSOMEIP_MAGIC_COOKIE_RETURN_CODE = return_code_e::E_OK;
+const std::string base_path = "/tmp/vsomeip-";
+
+const major_version_t default_major = 0x01;
+const minor_version_t default_minor = 0x000000;
+const ttl_t default_ttl = 0xFFFFFF; // basically means "forever"
+
+const std::string default_multicast = "224.0.0.0";
+const uint16_t default_port = 30500;
+const uint16_t illegal_port = 0xFFFF;
+
+const service_t any_service = 0xFFFF;
+const instance_t any_instance = 0xFFFF;
+const method_t any_method = 0xFFFF;
+const major_version_t any_major = 0xFF;
+const minor_version_t any_minor = 0xFFFFFF;
+const ttl_t any_ttl = 1;
+
+const byte_t magic_cookie_client_message = 0x00;
+const byte_t magic_cookie_service_message = 0x80;
+const length_t magic_cookie_size = 0x00000008;
+const request_t magic_cookie_request = 0xDEADBEEF;
+const protocol_version_t magic_cookie_protocol_version = 0x01;
+const interface_version_t magic_cookie_interface_version = 0x01;
+const message_type_e magic_cookie_client_message_type = message_type_e::REQUEST_NO_RETURN;
+const message_type_e magic_cookie_service_message_type = message_type_e::NOTIFICATION;
+const return_code_e magic_cookie_return_code = return_code_e::E_OK;
 
 const byte_t client_cookie[] = {
 	0xFF, 0xFF, 0x00, 0x00,
diff --git a/interface/vsomeip/defines.hpp b/interface/vsomeip/defines.hpp
index c3eef1336..a1267a064 100644
--- a/interface/vsomeip/defines.hpp
+++ b/interface/vsomeip/defines.hpp
@@ -39,12 +39,4 @@
 #define VSOMEIP_MESSAGE_TYPE_POS			14
 #define VSOMEIP_RETURN_CODE_POS				15
 
-// SD delays
-#define VSOMEIP_DEFAULT_MIN_INITIAL_DELAY		0
-#define VSOMEIP_DEFAULT_MAX_INITIAL_DELAY		3000
-#define VSOMEIP_DEFAULT_REPETITION_BASE_DELAY	10
-#define VSOMEIP_DEFAULT_REPETITION_MAX			5
-#define VSOMEIP_DEFAULT_CYCLIC_OFFER_DELAY		1000
-#define VSOMEIP_DEFAULT_CYCLIC_REQUEST_DELAY	2000
-
 #endif // VSOMEIP_DEFINES_HPP
diff --git a/test/configuration-test.cpp b/test/configuration-test.cpp
index 14369b0a3..ada2f83b6 100644
--- a/test/configuration-test.cpp
+++ b/test/configuration-test.cpp
@@ -23,7 +23,7 @@
 #define DESIRED_MULTICAST_1234_0022	"225.225.225.1"
 
 #define DESIRED_RELIABLE_1234_0023 	30503
-#define DESIRED_UNRELIABLE_1234_0023	vsomeip::VSOMEIP_ILLEGAL_PORT
+#define DESIRED_UNRELIABLE_1234_0023	vsomeip::illegal_port
 #define DESIRED_MULTICAST_1234_0023	"225.225.225.2"
 
 #define DESIRED_RELIABLE_2277_0022	30505
diff --git a/test/magic-cookies-test-client.cpp b/test/magic-cookies-test-client.cpp
index 881233d8c..8dea758be 100644
--- a/test/magic-cookies-test-client.cpp
+++ b/test/magic-cookies-test-client.cpp
@@ -41,7 +41,7 @@ class client_sample {
 						  std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
 
 		app_->register_message_handler(
-				vsomeip::VSOMEIP_ANY_SERVICE, SAMPLE_INSTANCE_ID, vsomeip::VSOMEIP_ANY_METHOD,
+				vsomeip::any_service, SAMPLE_INSTANCE_ID, vsomeip::any_method,
 				std::bind(&client_sample::on_message,
 						  this,
 						  std::placeholders::_1));
@@ -61,8 +61,8 @@ class client_sample {
 		if (_event == vsomeip::event_type_e::REGISTERED) {
 			VSOMEIP_INFO << "Client registration done.";
 			app_->request_service(SAMPLE_SERVICE_ID, SAMPLE_INSTANCE_ID,
-								  vsomeip::VSOMEIP_ANY_MAJOR, vsomeip::VSOMEIP_ANY_MINOR,
-								  vsomeip::VSOMEIP_ANY_TTL);
+								  vsomeip::any_major, vsomeip::any_minor,
+								  vsomeip::any_ttl);
 		}
 	}