Only increment session identifier after successful send operations.

7 files changed, 209 insertions, 191 deletions

diff --git a/implementation/routing/include/routing_manager.hpp b/implementation/routing/include/routing_manager.hpp
index 9dd2294..efe1862 100644
--- a/implementation/routing/include/routing_manager.hpp
+++ b/implementation/routing/include/routing_manager.hpp
@@ -23,7 +23,9 @@ class service_info;
 
 class routing_manager {
 public:
-	virtual ~routing_manager() {};
+	virtual ~routing_manager() {
+	}
+	;
 
 	virtual boost::asio::io_service & get_io() = 0;
 
@@ -31,61 +33,60 @@ public:
 	virtual void start() = 0;
 	virtual void stop() = 0;
 
-	virtual void offer_service(client_t _client,
-					service_t _service, instance_t _instance,
-					major_version_t _major, minor_version_t _minor, ttl_t _ttl) = 0;
+	virtual void offer_service(client_t _client, service_t _service,
+			instance_t _instance, major_version_t _major,
+			minor_version_t _minor, ttl_t _ttl) = 0;
 
-	virtual void stop_offer_service(client_t _client,
-					service_t _service, instance_t _instance) = 0;
+	virtual void stop_offer_service(client_t _client, service_t _service,
+			instance_t _instance) = 0;
 
-	virtual void publish_eventgroup(client_t _client,
-					service_t _service, instance_t _instance,
-			 	 	eventgroup_t _eventgroup,
-					major_version_t _major, ttl_t _ttl) = 0;
+	virtual void publish_eventgroup(client_t _client, service_t _service,
+			instance_t _instance, eventgroup_t _eventgroup,
+			major_version_t _major, ttl_t _ttl) = 0;
 
-	virtual void stop_publish_eventgroup(client_t _client,
-					service_t _service, instance_t _instance,
-					eventgroup_t _eventgroup) = 0;
+	virtual void stop_publish_eventgroup(client_t _client, service_t _service,
+			instance_t _instance, eventgroup_t _eventgroup) = 0;
 
-	virtual std::shared_ptr< event > add_event(client_t _client,
-					service_t _service, instance_t _instance,
-					eventgroup_t _eventgroup, event_t _event) = 0;
+	virtual std::shared_ptr<event> add_event(client_t _client,
+			service_t _service, instance_t _instance, eventgroup_t _eventgroup,
+			event_t _event) = 0;
 
-	virtual std::shared_ptr< event > add_field(client_t _client,
-					service_t _service, instance_t _instance,
-					eventgroup_t _eventgroup, event_t _event,
-					std::shared_ptr< payload > _payload) = 0;
+	virtual std::shared_ptr<event> add_field(client_t _client,
+			service_t _service, instance_t _instance, eventgroup_t _eventgroup,
+			event_t _event, std::shared_ptr<payload> _payload) = 0;
 
-	virtual void remove_event_or_field(std::shared_ptr< event > _event) = 0;
+	virtual void remove_event_or_field(std::shared_ptr<event> _event) = 0;
 
-	virtual void request_service(client_t _client,
-					service_t _service, instance_t _instance,
-					major_version_t _major, minor_version_t _minor,	ttl_t _ttl) = 0;
+	virtual void request_service(client_t _client, service_t _service,
+			instance_t _instance, major_version_t _major,
+			minor_version_t _minor, ttl_t _ttl) = 0;
 
-	virtual void release_service(client_t _client,
-					service_t _service, instance_t _instance) = 0;
+	virtual void release_service(client_t _client, service_t _service,
+			instance_t _instance) = 0;
 
-	virtual void subscribe(client_t _client,
-					service_t _service, instance_t _instance, eventgroup_t _eventgroup) = 0;
+	virtual void subscribe(client_t _client, service_t _service,
+			instance_t _instance, eventgroup_t _eventgroup) = 0;
 
-	virtual void unsubscribe(client_t _client,
-					service_t _service, instance_t _instance, eventgroup_t _eventgroup) = 0;
+	virtual void unsubscribe(client_t _client, service_t _service,
+			instance_t _instance, eventgroup_t _eventgroup) = 0;
 
-	virtual void send(client_t _client,
-			std::shared_ptr< message > _message, bool _flush, bool _reliable) = 0;
+	virtual bool send(client_t _client, std::shared_ptr<message> _message,
+			bool _flush, bool _reliable) = 0;
 
-	virtual void send(client_t _client,
-				const byte_t *_data, uint32_t _size, instance_t _instance, bool _flush, bool _reliable) = 0;
+	virtual bool send(client_t _client, const byte_t *_data, uint32_t _size,
+			instance_t _instance, bool _flush, bool _reliable) = 0;
 
-	virtual void set(client_t _client,
-					service_t _service, instance_t _instance,
-			      	event_t _event, const std::vector< byte_t > &_value) = 0;
+	virtual void set(client_t _client, service_t _service, instance_t _instance,
+			event_t _event, const std::vector<byte_t> &_value) = 0;
 
-	virtual bool is_available(service_t _service, instance_t _instance) const = 0;
+	virtual bool is_available(service_t _service,
+			instance_t _instance) const = 0;
 
-	virtual std::shared_ptr< endpoint > find_local(client_t _client) = 0;
-	virtual std::shared_ptr< endpoint > find_local(service_t _service, instance_t _instance) = 0;
-	virtual std::shared_ptr< endpoint > find_or_create_local(client_t _client) = 0;
+	virtual std::shared_ptr<endpoint> find_local(client_t _client) = 0;
+	virtual std::shared_ptr<endpoint> find_local(service_t _service,
+			instance_t _instance) = 0;
+	virtual std::shared_ptr<endpoint> find_or_create_local(
+			client_t _client) = 0;
 	virtual void remove_local(client_t _client) = 0;
 };
 
diff --git a/implementation/routing/include/routing_manager_impl.hpp b/implementation/routing/include/routing_manager_impl.hpp
index bcde868..e5dba21 100644
--- a/implementation/routing/include/routing_manager_impl.hpp
+++ b/implementation/routing/include/routing_manager_impl.hpp
@@ -37,162 +37,167 @@ class service_discovery;
 
 } // namespace sd
 
-class routing_manager_impl:
-		public routing_manager,
+class routing_manager_impl: public routing_manager,
 		public endpoint_host,
 		public sd::service_discovery_host,
-		public std::enable_shared_from_this< routing_manager_impl > {
+		public std::enable_shared_from_this<routing_manager_impl> {
 public:
 	routing_manager_impl(routing_manager_host *_host);
 	~routing_manager_impl();
 
 	boost::asio::io_service & get_io();
-	std::shared_ptr< configuration > get_configuration() const;
+	std::shared_ptr<configuration> get_configuration() const;
 
 	void init();
 	void start();
 	void stop();
 
-	void offer_service(client_t _client,
-			service_t _service, instance_t _instance,
-			major_version_t _major, minor_version_t _minor, ttl_t _ttl);
+	void offer_service(client_t _client, service_t _service,
+			instance_t _instance, major_version_t _major,
+			minor_version_t _minor, ttl_t _ttl);
 
-	void stop_offer_service(client_t _client,
-			service_t _service, instance_t _instance);
+	void stop_offer_service(client_t _client, service_t _service,
+			instance_t _instance);
 
-
-	void publish_eventgroup(client_t _client,
-			service_t _service, instance_t _instance,
-			eventgroup_t _eventgroup,
+	void publish_eventgroup(client_t _client, service_t _service,
+			instance_t _instance, eventgroup_t _eventgroup,
 			major_version_t _major, ttl_t _ttl);
 
-	void stop_publish_eventgroup(client_t _client,
-			service_t _service, instance_t _instance,
-			eventgroup_t _eventgroup);
-
-	std::shared_ptr< event > add_event(client_t _client,
-			service_t _service, instance_t _instance,
-			eventgroup_t _eventgroup, event_t _event);
+	void stop_publish_eventgroup(client_t _client, service_t _service,
+			instance_t _instance, eventgroup_t _eventgroup);
 
-	std::shared_ptr< event > 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> add_event(client_t _client, service_t _service,
+			instance_t _instance, eventgroup_t _eventgroup, event_t _event);
 
-	void remove_event_or_field(std::shared_ptr< event > _event);
+	std::shared_ptr<event> add_field(client_t _client, service_t _service,
+			instance_t _instance, eventgroup_t _eventgroup, event_t _event,
+			std::shared_ptr<payload> _payload);
 
-	void request_service(client_t _client,
-			service_t _service, instance_t _instance,
-			major_version_t _major, minor_version_t _minor, ttl_t _ttl);
+	void remove_event_or_field(std::shared_ptr<event> _event);
 
-	void release_service(client_t _client, service_t _service, instance_t _instance);
+	void request_service(client_t _client, service_t _service,
+			instance_t _instance, major_version_t _major,
+			minor_version_t _minor, ttl_t _ttl);
 
-	void subscribe(client_t _client,
-			service_t _service, instance_t _instance, eventgroup_t _eventgroup);
+	void release_service(client_t _client, service_t _service,
+			instance_t _instance);
 
-	void unsubscribe(client_t _client,
-			service_t _service, instance_t _instance, eventgroup_t _eventgroup);
+	void subscribe(client_t _client, service_t _service, instance_t _instance,
+			eventgroup_t _eventgroup);
 
-	void send(client_t _client,
-			std::shared_ptr< message > _message, bool _flush, bool _reliable);
+	void unsubscribe(client_t _client, service_t _service, instance_t _instance,
+			eventgroup_t _eventgroup);
 
-	void send(client_t _client,
-			const byte_t *_data, uint32_t _size, instance_t _instance, bool _flush, bool _reliable);
+	bool send(client_t _client, std::shared_ptr<message> _message, bool _flush,
+			bool _reliable);
 
-	void set(client_t _client,
-			service_t _service, instance_t _instance,
-	      	event_t _event, const std::vector< byte_t > &_value);
+	bool send(client_t _client, const byte_t *_data, uint32_t _size,
+			instance_t _instance, bool _flush, bool _reliable);
 
+	void set(client_t _client, service_t _service, instance_t _instance,
+			event_t _event, const std::vector<byte_t> &_value);
 
 	bool is_available(service_t _service, instance_t _instance) const;
 
 	// interface to stub
-	std::shared_ptr< endpoint > create_local(client_t _client);
-	std::shared_ptr< endpoint > find_local(client_t _client);
-	std::shared_ptr< endpoint > find_or_create_local(client_t _client);
+	std::shared_ptr<endpoint> create_local(client_t _client);
+	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);
-	void on_disconnect(std::shared_ptr< endpoint > _endpoint);
+	void on_connect(std::shared_ptr<endpoint> _endpoint);
+	void on_disconnect(std::shared_ptr<endpoint> _endpoint);
 	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;
+	const std::map<std::string, std::shared_ptr<servicegroup> > & 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:
-	void 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);
 
-	std::shared_ptr< serviceinfo > find_service(service_t _service, instance_t _instance);
-	std::shared_ptr< serviceinfo > create_service(service_t _service, instance_t _instance,
-										major_version_t _major, minor_version_t _minor, ttl_t _ttl);
-
-	std::shared_ptr< endpoint > find_remote_client(service_t _service, instance_t _instance, bool _reliable);
-
-	std::shared_ptr< endpoint > create_client_endpoint(const boost::asio::ip::address &_address, uint16_t _port, bool _reliable);
-	std::shared_ptr< endpoint > find_client_endpoint(const boost::asio::ip::address &_address, uint16_t _port, bool _reliable);
-	std::shared_ptr< endpoint > find_or_create_client_endpoint(const boost::asio::ip::address &_address, uint16_t _port, bool _reliable);
-
-	std::shared_ptr< endpoint > create_server_endpoint(uint16_t _port, bool _reliable);
-	std::shared_ptr< endpoint > find_server_endpoint(uint16_t _port, bool _reliable);
-	std::shared_ptr< endpoint > find_or_create_server_endpoint(uint16_t _port, bool _reliable);
+	std::shared_ptr<serviceinfo> find_service(service_t _service,
+			instance_t _instance);
+	std::shared_ptr<serviceinfo> create_service(service_t _service,
+			instance_t _instance, major_version_t _major,
+			minor_version_t _minor, ttl_t _ttl);
+
+	std::shared_ptr<endpoint> find_remote_client(service_t _service,
+			instance_t _instance, bool _reliable);
+
+	std::shared_ptr<endpoint> create_client_endpoint(
+			const boost::asio::ip::address &_address, uint16_t _port,
+			bool _reliable);
+	std::shared_ptr<endpoint> find_client_endpoint(
+			const boost::asio::ip::address &_address, uint16_t _port,
+			bool _reliable);
+	std::shared_ptr<endpoint> find_or_create_client_endpoint(
+			const boost::asio::ip::address &_address, uint16_t _port,
+			bool _reliable);
+
+	std::shared_ptr<endpoint> create_server_endpoint(uint16_t _port,
+			bool _reliable);
+	std::shared_ptr<endpoint> find_server_endpoint(uint16_t _port,
+			bool _reliable);
+	std::shared_ptr<endpoint> find_or_create_server_endpoint(uint16_t _port,
+			bool _reliable);
 
 	void init_routing_info();
 	void 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);
-	void del_routing_info(service_t _service, instance_t _instance, bool _reliable);
+			const boost::asio::ip::address &_address, uint16_t _port,
+			bool _reliable);
+	void del_routing_info(service_t _service, instance_t _instance,
+			bool _reliable);
 
 private:
 	boost::asio::io_service &io_;
 	routing_manager_host *host_;
 
-	std::shared_ptr< configuration > configuration_;
+	std::shared_ptr<configuration> configuration_;
 
-	std::shared_ptr< deserializer > deserializer_;
-	std::shared_ptr< serializer > serializer_;
+	std::shared_ptr<deserializer> deserializer_;
+	std::shared_ptr<serializer> serializer_;
 
-	std::shared_ptr< routing_manager_stub > stub_;
-	std::shared_ptr< sd::service_discovery > discovery_;
+	std::shared_ptr<routing_manager_stub> stub_;
+	std::shared_ptr<sd::service_discovery> discovery_;
 
 	// Routing info
 
 	// Local
-	std::map< client_t, std::shared_ptr< endpoint > > local_clients_;
-	std::map< service_t, std::map< instance_t, client_t > > local_services_;
+	std::map<client_t, std::shared_ptr<endpoint> > local_clients_;
+	std::map<service_t, std::map<instance_t, client_t> > local_services_;
 
 	// Server endpoints for local services
-	std::map< uint16_t, std::map< bool, std::shared_ptr< endpoint > > > server_endpoints_;
-	std::map< service_t, std::map< endpoint *, instance_t > > service_instances_;
+	std::map<uint16_t, std::map<bool, std::shared_ptr<endpoint> > > server_endpoints_;
+	std::map<service_t, std::map<endpoint *, instance_t> > service_instances_;
 
 	// Client endpoints for remote services
-	std::map< boost::asio::ip::address,
-			  std::map< uint16_t,
-			  	  	    std::map< bool, std::shared_ptr< endpoint > > > > client_endpoints_;
-	std::map< service_t,
-			  std::map< instance_t,
-			  	  	  	std::map< bool, std::shared_ptr< endpoint > > > > remote_services_;
+	std::map<boost::asio::ip::address,
+			std::map<uint16_t, std::map<bool, std::shared_ptr<endpoint> > > > client_endpoints_;
+	std::map<service_t,
+			std::map<instance_t, std::map<bool, std::shared_ptr<endpoint> > > > remote_services_;
 
 	// Servicegroups
-	std::map< std::string, std::shared_ptr< servicegroup > > servicegroups_;
-	std::map< service_t, std::map< instance_t, std::shared_ptr< serviceinfo > > > services_;
+	std::map<std::string, std::shared_ptr<servicegroup> > servicegroups_;
+	std::map<service_t, std::map<instance_t, std::shared_ptr<serviceinfo> > > services_;
 
 	// Eventgroups
-	std::map< service_t,
-			  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_;
+	std::map<service_t,
+			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::set<std::shared_ptr<serviceinfo> > requested_;
 
 	// 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 32e4f72..86e670a 100644
--- a/implementation/routing/include/routing_manager_proxy.hpp
+++ b/implementation/routing/include/routing_manager_proxy.hpp
@@ -20,10 +20,9 @@ namespace vsomeip {
 class configuration;
 class routing_manager_host;
 
-class routing_manager_proxy:
-		public routing_manager,
+class routing_manager_proxy: public routing_manager,
 		public endpoint_host,
-		public std::enable_shared_from_this< routing_manager_proxy > {
+		public std::enable_shared_from_this<routing_manager_proxy> {
 public:
 	routing_manager_proxy(routing_manager_host *_host);
 	virtual ~routing_manager_proxy();
@@ -34,73 +33,70 @@ public:
 	void start();
 	void stop();
 
-	void offer_service(client_t _client,
-			service_t _service, instance_t _instance,
-			major_version_t _major, minor_version_t _minor, ttl_t _ttl);
+	void offer_service(client_t _client, service_t _service,
+			instance_t _instance, major_version_t _major,
+			minor_version_t _minor, ttl_t _ttl);
 
-	void stop_offer_service(client_t _client,
-			service_t _service, instance_t _instance);
+	void stop_offer_service(client_t _client, service_t _service,
+			instance_t _instance);
 
-
-	void publish_eventgroup(client_t _client,
-			service_t _service, instance_t _instance, eventgroup_t _eventgroup,
+	void publish_eventgroup(client_t _client, service_t _service,
+			instance_t _instance, eventgroup_t _eventgroup,
 			major_version_t _major, ttl_t _ttl);
 
-	void stop_publish_eventgroup(client_t _client,
-			service_t _service, instance_t _instance, eventgroup_t _eventgroup);
+	void stop_publish_eventgroup(client_t _client, service_t _service,
+			instance_t _instance, eventgroup_t _eventgroup);
 
-	std::shared_ptr< event > add_event(client_t _client,
-			service_t _service, instance_t _instance,
-			eventgroup_t _eventgroup, event_t _event);
+	std::shared_ptr<event> add_event(client_t _client, service_t _service,
+			instance_t _instance, eventgroup_t _eventgroup, event_t _event);
 
-	std::shared_ptr< event > 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> add_field(client_t _client, service_t _service,
+			instance_t _instance, eventgroup_t _eventgroup, event_t _event,
+			std::shared_ptr<payload> _payload);
 
-	void remove_event_or_field(std::shared_ptr< event > _event);
+	void remove_event_or_field(std::shared_ptr<event> _event);
 
-	void request_service(client_t _client,
-			service_t _service, instance_t _instance,
-			major_version_t _major, minor_version_t _minor, ttl_t _ttl);
+	void request_service(client_t _client, service_t _service,
+			instance_t _instance, major_version_t _major,
+			minor_version_t _minor, ttl_t _ttl);
 
-	void release_service(client_t _client,
-			service_t _service, instance_t _instance);
+	void release_service(client_t _client, service_t _service,
+			instance_t _instance);
 
-	void subscribe(client_t _client,
-			service_t _service, instance_t _instance, eventgroup_t _eventgroup);
+	void subscribe(client_t _client, service_t _service, instance_t _instance,
+			eventgroup_t _eventgroup);
 
-	void unsubscribe(client_t _client,
-			service_t _service, instance_t _instance, eventgroup_t _eventgroup);
+	void unsubscribe(client_t _client, service_t _service, instance_t _instance,
+			eventgroup_t _eventgroup);
 
-	void send(client_t _client,
-			std::shared_ptr< message > _message, bool _flush, bool _reliable);
+	bool send(client_t _client, std::shared_ptr<message> _message, bool _flush,
+			bool _reliable);
 
-	void send(client_t _client,
-			const byte_t *_data, uint32_t _size, instance_t _instance, bool _flush = true, bool _reliable = false);
+	bool send(client_t _client, const byte_t *_data, uint32_t _size,
+			instance_t _instance, bool _flush = true, bool _reliable = false);
 
-	void set(client_t _client,
-			service_t _service, instance_t _instance,
-	      	event_t _event, const std::vector< byte_t > &_value);
+	void set(client_t _client, service_t _service, instance_t _instance,
+			event_t _event, const std::vector<byte_t> &_value);
 
-	void on_connect(std::shared_ptr< endpoint > _endpoint);
-	void on_disconnect(std::shared_ptr< endpoint > _endpoint);
+	void on_connect(std::shared_ptr<endpoint> _endpoint);
+	void on_disconnect(std::shared_ptr<endpoint> _endpoint);
 	void on_message(const byte_t *_data, length_t _length, endpoint *_receiver);
 
 	void on_routing_info(const byte_t *_data, uint32_t _size);
 
 	bool is_available(service_t _service, instance_t _instance) const;
 
-	std::shared_ptr< endpoint > find_local(client_t _client);
-	std::shared_ptr< endpoint > find_local(service_t _service, instance_t _instance);
-	std::shared_ptr< endpoint > find_or_create_local(client_t _client);
+	std::shared_ptr<endpoint> find_local(client_t _client);
+	std::shared_ptr<endpoint> find_local(service_t _service,
+			instance_t _instance);
+	std::shared_ptr<endpoint> find_or_create_local(client_t _client);
 	void remove_local(client_t _client);
 
 private:
 	void register_application();
 	void deregister_application();
 
-	std::shared_ptr< endpoint > create_local(client_t _client);
+	std::shared_ptr<endpoint> create_local(client_t _client);
 
 	bool is_request(byte_t _message_type) const;
 
@@ -111,14 +107,14 @@ private:
 	routing_manager_host *host_;
 	client_t client_; // store locally as it is needed in each message
 
-	std::shared_ptr< serializer > serializer_;
-	std::shared_ptr< deserializer > deserializer_;
+	std::shared_ptr<serializer> serializer_;
+	std::shared_ptr<deserializer> deserializer_;
 
-	std::shared_ptr< endpoint > sender_;	// --> stub
-	std::shared_ptr< endpoint > receiver_;  // --> from everybody
+	std::shared_ptr<endpoint> sender_;	// --> stub
+	std::shared_ptr<endpoint> receiver_;  // --> from everybody
 
-	std::map< client_t, std::shared_ptr< endpoint > > local_endpoints_;
-	std::map< service_t, std::map< instance_t, client_t > > local_services_;
+	std::map<client_t, std::shared_ptr<endpoint> > local_endpoints_;
+	std::map<service_t, std::map<instance_t, client_t> > local_services_;
 
 	std::mutex send_mutex_;
 	std::mutex serialize_mutex_;
diff --git a/implementation/routing/src/routing_manager_impl.cpp b/implementation/routing/src/routing_manager_impl.cpp
index 26b2b3a..83c705f 100644
--- a/implementation/routing/src/routing_manager_impl.cpp
+++ b/implementation/routing/src/routing_manager_impl.cpp
@@ -201,17 +201,22 @@ void routing_manager_impl::unsubscribe(client_t its_client,
 		service_t _service, instance_t _instance, eventgroup_t _eventgroup) {
 }
 
-void routing_manager_impl::send(client_t its_client,
+bool routing_manager_impl::send(client_t its_client,
 		std::shared_ptr< message > _message, bool _reliable, bool _flush) {
+	bool is_sent(false);
 	std::unique_lock< std::mutex > its_lock(serialize_mutex_);
 	if (serializer_->serialize(_message.get())) {
-		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;
 }
 
-void routing_manager_impl::send(client_t _client,
+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]);
@@ -234,18 +239,18 @@ void routing_manager_impl::send(client_t _client,
 			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));
-			its_target->send(&its_command[0], its_command.size(), _flush);
+			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)) {
-				deliver_message(_data, _size, _instance);
+				is_sent = deliver_message(_data, _size, _instance);
 			} else {
 				if (is_request) {
 					its_target = find_remote_client(its_service, _instance, _reliable);
 					if (its_target) {
-						its_target->send(_data, _size, _flush);
+						is_sent = its_target->send(_data, _size, _flush);
 					} else {
 						VSOMEIP_ERROR << "Routing error. Client from remote service could not be found!";
 					}
@@ -254,7 +259,7 @@ void routing_manager_impl::send(client_t _client,
 					if (its_info) {
 						its_target = its_info->get_endpoint(_reliable);
 						if (its_target) {
-							its_target->send(_data, _size, _flush);
+							is_sent = its_target->send(_data, _size, _flush);
 						} else {
 							VSOMEIP_ERROR << "Routing error. Service endpoint could not be found!";
 						}
@@ -265,6 +270,8 @@ void routing_manager_impl::send(client_t _client,
 			}
 		}
 	}
+
+	return is_sent;
 }
 
 void routing_manager_impl::set(client_t its_client,
@@ -343,16 +350,19 @@ void routing_manager_impl::on_disconnect(std::shared_ptr< endpoint > _endpoint)
 	}
 }
 
-void 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());
 	if (its_message) {
 		its_message->set_instance(_instance);
 		host_->on_message(its_message);
+		is_sent = true;
 	} else {
 		// TODO: send error "Malformed Message"
 		//send_error();
 	}
+	return is_sent;
 }
 
 bool routing_manager_impl::is_available(service_t _service, instance_t _instance) const {
diff --git a/implementation/routing/src/routing_manager_proxy.cpp b/implementation/routing/src/routing_manager_proxy.cpp
index a8b6bdc..482e9c4 100644
--- a/implementation/routing/src/routing_manager_proxy.cpp
+++ b/implementation/routing/src/routing_manager_proxy.cpp
@@ -199,20 +199,23 @@ void routing_manager_proxy::unsubscribe(client_t _client,
 		service_t _service, instance_t _instance, eventgroup_t _eventgroup) {
 }
 
-void routing_manager_proxy::send(client_t its_client,
+bool routing_manager_proxy::send(client_t its_client,
 		std::shared_ptr< message > _message,
 		bool _flush, bool _reliable) {
+	bool is_sent(false);
 	std::unique_lock< std::mutex > its_lock(serialize_mutex_);
 	if (serializer_->serialize(_message.get())) {
-		send(its_client, serializer_->get_data(), serializer_->get_size(), _message->get_instance(), _flush, _reliable);
+		is_sent = send(its_client, serializer_->get_data(), serializer_->get_size(), _message->get_instance(), _flush, _reliable);
 		serializer_->reset();
 	}
+	return is_sent;
 }
 
-void routing_manager_proxy::send(client_t _client,
+bool routing_manager_proxy::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;
 
 	if (_size > VSOMEIP_MESSAGE_TYPE_POS) {
@@ -247,8 +250,9 @@ void routing_manager_proxy::send(client_t _client,
 		std::cout << std::endl;
 #endif
 
-		its_target->send(&its_command[0], its_command.size());
+		is_sent = its_target->send(&its_command[0], its_command.size());
 	}
+	return is_sent;
 }
 
 void routing_manager_proxy::set(client_t _client,
diff --git a/implementation/runtime/src/application_impl.cpp b/implementation/runtime/src/application_impl.cpp
index 3f6be20..ee95c5a 100644
--- a/implementation/runtime/src/application_impl.cpp
+++ b/implementation/runtime/src/application_impl.cpp
@@ -188,9 +188,11 @@ void application_impl::send(std::shared_ptr< message > _message, bool _flush, bo
 	if (routing_) {
 		if (utility::is_request(_message)) {
 			_message->set_client(client_);
-			_message->set_session(session_++);
+			_message->set_session(session_);
+		}
+		if (routing_->send(client_, _message, _flush, _reliable)) {
+			session_++;
 		}
-		routing_->send(client_, _message, _flush, _reliable);
 	}
 }
 
diff --git a/implementation/service_discovery/include/service_discovery_host.hpp b/implementation/service_discovery/include/service_discovery_host.hpp
index ccd0801..4679e0e 100644
--- a/implementation/service_discovery/include/service_discovery_host.hpp
+++ b/implementation/service_discovery/include/service_discovery_host.hpp
@@ -34,7 +34,7 @@ public:
 	virtual service_map_t get_offered_services(
 			const std::string &_name) const = 0;
 
-	virtual void send(client_t _client, std::shared_ptr<message> _message,
+	virtual bool send(client_t _client, std::shared_ptr<message> _message,
 			bool _flush, bool _reliable) = 0;
 
 	virtual void add_routing_info(service_t _service, instance_t _instance,