vsomeip 2.10.62.10.6

author: Juergen Gehring <juergen.gehring@bmw.de> 2018-01-25 00:40:07 -0800
committer: Juergen Gehring <juergen.gehring@bmw.de> 2018-01-25 00:40:07 -0800
commit: a89a645014e17f383e07b6dc6899a4a8925cc324 (patch)
tree: d1a6f31158cd96ec724e13e2c9d7023378106b64
parent: 8bb2ed134d75803e8e6e3c4f4baa253e4d74edf4 (diff)
download: vSomeIP-a89a645014e17f383e07b6dc6899a4a8925cc324.tar.gz
37 files changed, 1369 insertions, 122 deletions
diff --git a/CHANGES b/CHANGES
index 6f3f91d..d4b9b4f 100644
--- a/CHANGES
+++ b/CHANGES
@@ -1,6 +1,12 @@
 Changes
 =======
 
+v2.10.6
+- Fix concurrency issue leading to a crash when asynchronous
+  subscription handlers were used.
+- Improved packing of subscriptions sent out as answer to incoming
+  offer service messages.
+
 v2.10.5
 - Fix possible deadlock on application shutdown
 - Try to reestablish TCP connection on resubscription if the remote
diff --git a/CMakeLists.txt b/CMakeLists.txt
index e062da1..251784d 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -8,7 +8,7 @@ project (vsomeip)
 
 set (VSOMEIP_MAJOR_VERSION 2)
 set (VSOMEIP_MINOR_VERSION 10)
-set (VSOMEIP_PATCH_VERSION 5)
+set (VSOMEIP_PATCH_VERSION 6)
 set (VSOMEIP_VERSION ${VSOMEIP_MAJOR_VERSION}.${VSOMEIP_MINOR_VERSION}.${VSOMEIP_PATCH_VERSION})
 set (PACKAGE_VERSION ${VSOMEIP_VERSION}) # Used in documentatin/doxygen.in
 set (CMAKE_VERBOSE_MAKEFILE off)
diff --git a/documentation/vsomeipUserGuide b/documentation/vsomeipUserGuide
index 3fb07c3..083669e 100644
--- a/documentation/vsomeipUserGuide
+++ b/documentation/vsomeipUserGuide
@@ -429,7 +429,10 @@ The name of the application.
 +
 ** 'id'
 +
-The id of the application.
+The id of the application. Usually its high byte is equal to the diagnosis address. In this
+case the low byte must be different from zero. Thus, if the diagnosis address is 0x63, valid
+values range from 0x6301 until 0x63FF. It is also possible to use id values with a high byte 
+different from the diagnosis address. 
 +
 ** 'max_dispatchers'
 +
@@ -981,8 +984,10 @@ In general clients can be configured to be allowed/denied to request (means comm
 Every incoming vSomeIP message (request/response/notifcation) as well as offer service requests or local subscriptions are then checked against the policy.
 If an incoming vSomeIP message or another operation (e.g. offer/subscribe) violates the configured policies it is skipped and a message is logged.
 
-Furthermore if an application receives a routing table (information about other clients/services in the system) it must be received from the authenticated routing manager which means the routing manager must be a configured application if security is active.
-This should avoid malicious applications faking the routing manager and therfore could wrongly inform other clients about services running on the system.
+Furthermore if an application receives informations about other clients/services in the system, it must be received from the authenticated routing manager. 
+This is to avoid malicious applications faking the routing manager and therefore being able to wrongly inform other clients about services running on the system.
+Therefore, whenever the "security" tag is specified, the routing manager (e.g. vsomeipd) must be a configured application with a fixed client identifier. 
+See chapter "Configuration File Structure" on how to configure an application to use a specific client identifier.
 
 Credential passing is only possible via Unix-Domain-Sockets and therefore only available for local communication.
 However if security is activated method calls from remote clients to local services are checked as well which means remote clients needs to be explicitly allowed.
@@ -993,7 +998,7 @@ It follows the available configuration switches for the security feature includi
 // Security
 * anchor:config-policy[]'security' (optional)
 +
-If specified the credential passing mechanism is activated. However no credential or security checks are done as long as _check_credentials_ isn't set to _true_.
+If specified the credential passing mechanism is activated. However no credential or security checks are done as long as _check_credentials_ isn't set to _true_, but the routing manager client ID must be configured if security tag is specified and shall not be set to 0x6300.
 
 ** 'check_credentials (optional)'
 +
diff --git a/implementation/endpoints/include/client_endpoint_impl.hpp b/implementation/endpoints/include/client_endpoint_impl.hpp
index 1981bc9..d8c758d 100644
--- a/implementation/endpoints/include/client_endpoint_impl.hpp
+++ b/implementation/endpoints/include/client_endpoint_impl.hpp
@@ -52,7 +52,7 @@ public:
     bool is_client() const;
 
     bool is_connected() const;
-
+    void set_connected(bool _connected);
     virtual bool get_remote_address(boost::asio::ip::address &_address) const;
     virtual std::uint16_t get_remote_port() const;
 
@@ -99,6 +99,7 @@ protected:
 
 private:
     virtual void set_local_port() = 0;
+    virtual std::string get_remote_information() const = 0;
 };
 
 } // namespace vsomeip
diff --git a/implementation/endpoints/include/endpoint.hpp b/implementation/endpoints/include/endpoint.hpp
index 62fe23b..dc97ffe 100644
--- a/implementation/endpoints/include/endpoint.hpp
+++ b/implementation/endpoints/include/endpoint.hpp
@@ -52,6 +52,8 @@ public:
     virtual void register_error_handler(error_handler_t _error) = 0;
 
     virtual void print_status() = 0;
+
+    virtual void set_connected(bool _connected) = 0;
 };
 
 } // namespace vsomeip
diff --git a/implementation/endpoints/include/local_client_endpoint_impl.hpp b/implementation/endpoints/include/local_client_endpoint_impl.hpp
index d6ee995..1f9620c 100644
--- a/implementation/endpoints/include/local_client_endpoint_impl.hpp
+++ b/implementation/endpoints/include/local_client_endpoint_impl.hpp
@@ -60,6 +60,7 @@ private:
     void receive_cbk(boost::system::error_code const &_error,
                      std::size_t _bytes);
     void set_local_port();
+    std::string get_remote_information() const;
 
     message_buffer_t recv_buffer_;
 };
diff --git a/implementation/endpoints/include/local_server_endpoint_impl.hpp b/implementation/endpoints/include/local_server_endpoint_impl.hpp
index d54cf69..aee73c4 100644
--- a/implementation/endpoints/include/local_server_endpoint_impl.hpp
+++ b/implementation/endpoints/include/local_server_endpoint_impl.hpp
@@ -139,6 +139,8 @@ private:
     void remove_connection(connection *_connection);
     void accept_cbk(connection::ptr _connection,
                     boost::system::error_code const &_error);
+    std::string get_remote_information(
+            const queue_iterator_type _queue_iterator) const;
 };
 
 } // namespace vsomeip
diff --git a/implementation/endpoints/include/server_endpoint_impl.hpp b/implementation/endpoints/include/server_endpoint_impl.hpp
index ae89508..ffc768a 100644
--- a/implementation/endpoints/include/server_endpoint_impl.hpp
+++ b/implementation/endpoints/include/server_endpoint_impl.hpp
@@ -39,7 +39,7 @@ public:
     bool is_client() const;
     void restart();
     bool is_connected() const;
-
+    void set_connected(bool _connected);
     bool send(const uint8_t *_data, uint32_t _size, bool _flush);
 
     virtual void stop();
@@ -73,6 +73,10 @@ protected:
     boost::asio::steady_timer flush_timer_;
 
     std::mutex mutex_;
+
+private:
+    virtual std::string get_remote_information(
+            const queue_iterator_type _queue_iterator) const = 0;
 };
 
 } // namespace vsomeip
diff --git a/implementation/endpoints/include/tcp_client_endpoint_impl.hpp b/implementation/endpoints/include/tcp_client_endpoint_impl.hpp
index 1c77664..9738afd 100644
--- a/implementation/endpoints/include/tcp_client_endpoint_impl.hpp
+++ b/implementation/endpoints/include/tcp_client_endpoint_impl.hpp
@@ -59,7 +59,7 @@ private:
             std::size_t _bytes_transferred, std::size_t _bytes_to_send,
             service_t _service, method_t _method, client_t _client, session_t _session,
             std::chrono::steady_clock::time_point _start);
-
+    std::string get_remote_information() const;
 
     const std::uint32_t recv_buffer_size_initial_;
     message_buffer_t recv_buffer_;
diff --git a/implementation/endpoints/include/tcp_server_endpoint_impl.hpp b/implementation/endpoints/include/tcp_server_endpoint_impl.hpp
index 4318c1b..5e9b50b 100644
--- a/implementation/endpoints/include/tcp_server_endpoint_impl.hpp
+++ b/implementation/endpoints/include/tcp_server_endpoint_impl.hpp
@@ -138,6 +138,8 @@ private:
     void remove_connection(connection *_connection);
     void accept_cbk(connection::ptr _connection,
                     boost::system::error_code const &_error);
+    std::string get_remote_information(
+            const queue_iterator_type _queue_iterator) const;
 };
 
 } // namespace vsomeip
diff --git a/implementation/endpoints/include/udp_client_endpoint_impl.hpp b/implementation/endpoints/include/udp_client_endpoint_impl.hpp
index a1d8761..1805813 100644
--- a/implementation/endpoints/include/udp_client_endpoint_impl.hpp
+++ b/implementation/endpoints/include/udp_client_endpoint_impl.hpp
@@ -50,6 +50,7 @@ private:
     void set_local_port();
     const std::string get_address_port_remote() const;
     const std::string get_address_port_local() const;
+    std::string get_remote_information() const;
 
     message_buffer_t recv_buffer_;
 
diff --git a/implementation/endpoints/include/udp_server_endpoint_impl.hpp b/implementation/endpoints/include/udp_server_endpoint_impl.hpp
index 6dcb537..48e4935 100644
--- a/implementation/endpoints/include/udp_server_endpoint_impl.hpp
+++ b/implementation/endpoints/include/udp_server_endpoint_impl.hpp
@@ -61,6 +61,8 @@ private:
     void set_broadcast();
     bool is_joined(const std::string &_address) const;
     bool is_joined(const std::string &_address, bool* _received) const;
+    std::string get_remote_information(
+            const queue_iterator_type _queue_iterator) const;
 
 private:
     socket_type socket_;
diff --git a/implementation/endpoints/include/virtual_server_endpoint_impl.hpp b/implementation/endpoints/include/virtual_server_endpoint_impl.hpp
index 259e91d..303f984 100644
--- a/implementation/endpoints/include/virtual_server_endpoint_impl.hpp
+++ b/implementation/endpoints/include/virtual_server_endpoint_impl.hpp
@@ -25,6 +25,7 @@ public:
     void stop();
 
     bool is_connected() const;
+    void set_connected(bool _connected);
 
     bool send(const byte_t *_data, uint32_t _size, bool _flush);
     bool send_to(const std::shared_ptr<endpoint_definition> _target,
diff --git a/implementation/endpoints/src/client_endpoint_impl.cpp b/implementation/endpoints/src/client_endpoint_impl.cpp
index 2fb9fa9..55316a9 100644
--- a/implementation/endpoints/src/client_endpoint_impl.cpp
+++ b/implementation/endpoints/src/client_endpoint_impl.cpp
@@ -59,7 +59,8 @@ bool client_endpoint_impl<Protocol>::is_connected() const {
 }
 
 template<typename Protocol>
-void client_endpoint_impl<Protocol>::stop() {
+void client_endpoint_impl<Protocol>::set_connected(bool _connected) {
+    is_connected_ = _connected;
+}
+template<typename Protocol>
+void client_endpoint_impl<Protocol>::stop() {
     {
         std::lock_guard<std::mutex> its_lock(mutex_);
         endpoint_impl<Protocol>::sending_blocked_ = true;
@@ -233,7 +234,6 @@ void client_endpoint_impl<Protocol>::connect_cbk(
             connect_timeout_ = VSOMEIP_DEFAULT_CONNECT_TIMEOUT; // TODO: use config variable
             set_local_port();
             if (!is_connected_) {
-                is_connected_ = true;
                 its_host->on_connect(this->shared_from_this());
             }
 
@@ -279,9 +279,37 @@ void client_endpoint_impl<Protocol>::send_cbk(
                 queue_.clear();
                 queue_size_ = 0;
             } else {
+                message_buffer_ptr_t its_buffer;
+                if (queue_.size()) {
+                    its_buffer = queue_.front();
+                }
+                service_t its_service(0);
+                method_t its_method(0);
+                client_t its_client(0);
+                session_t its_session(0);
+                if (its_buffer && its_buffer->size() > VSOMEIP_SESSION_POS_MAX) {
+                    its_service = VSOMEIP_BYTES_TO_WORD(
+                            (*its_buffer)[VSOMEIP_SERVICE_POS_MIN],
+                            (*its_buffer)[VSOMEIP_SERVICE_POS_MAX]);
+                    its_method = VSOMEIP_BYTES_TO_WORD(
+                            (*its_buffer)[VSOMEIP_METHOD_POS_MIN],
+                            (*its_buffer)[VSOMEIP_METHOD_POS_MAX]);
+                    its_client = VSOMEIP_BYTES_TO_WORD(
+                            (*its_buffer)[VSOMEIP_CLIENT_POS_MIN],
+                            (*its_buffer)[VSOMEIP_CLIENT_POS_MAX]);
+                    its_session = VSOMEIP_BYTES_TO_WORD(
+                            (*its_buffer)[VSOMEIP_SESSION_POS_MIN],
+                            (*its_buffer)[VSOMEIP_SESSION_POS_MAX]);
+                }
                 VSOMEIP_WARNING << "cei::send_cbk received error: "
                         << _error.message() << " (" << std::dec
-                        << _error.value() << ") " << std::dec << queue_.size();
+                        << _error.value() << ") " << get_remote_information()
+                        << " " << std::dec << queue_.size()
+                        << " " << std::dec << queue_size_ << " ("
+                        << std::hex << std::setw(4) << std::setfill('0') << its_client <<"): ["
+                        << std::hex << std::setw(4) << std::setfill('0') << its_service << "."
+                        << std::hex << std::setw(4) << std::setfill('0') << its_method << "."
+                        << std::hex << std::setw(4) << std::setfill('0') << its_session << "]";
             }
         }
         if (!stopping) {
@@ -298,8 +326,40 @@ void client_endpoint_impl<Protocol>::send_cbk(
         // endpoint was stopped
         shutdown_and_close_socket(false);
     } else {
-        VSOMEIP_WARNING << "cei::send_cbk received error: " << _error.message()
-                << " (" << std::dec << _error.value() << ")" ;
+        {
+            std::lock_guard<std::mutex> its_lock(mutex_);
+            message_buffer_ptr_t its_buffer;
+            if (queue_.size()) {
+                its_buffer = queue_.front();
+            }
+            service_t its_service(0);
+            method_t its_method(0);
+            client_t its_client(0);
+            session_t its_session(0);
+            if (its_buffer && its_buffer->size() > VSOMEIP_SESSION_POS_MAX) {
+                its_service = VSOMEIP_BYTES_TO_WORD(
+                        (*its_buffer)[VSOMEIP_SERVICE_POS_MIN],
+                        (*its_buffer)[VSOMEIP_SERVICE_POS_MAX]);
+                its_method = VSOMEIP_BYTES_TO_WORD(
+                        (*its_buffer)[VSOMEIP_METHOD_POS_MIN],
+                        (*its_buffer)[VSOMEIP_METHOD_POS_MAX]);
+                its_client = VSOMEIP_BYTES_TO_WORD(
+                        (*its_buffer)[VSOMEIP_CLIENT_POS_MIN],
+                        (*its_buffer)[VSOMEIP_CLIENT_POS_MAX]);
+                its_session = VSOMEIP_BYTES_TO_WORD(
+                        (*its_buffer)[VSOMEIP_SESSION_POS_MIN],
+                        (*its_buffer)[VSOMEIP_SESSION_POS_MAX]);
+            }
+            VSOMEIP_WARNING << "cei::send_cbk received error: " << _error.message()
+                    << " (" << std::dec << _error.value() << ") "
+                    << get_remote_information() << " "
+                    << " " << std::dec << queue_.size()
+                    << " " << std::dec << queue_size_ << " ("
+                    << std::hex << std::setw(4) << std::setfill('0') << its_client <<"): ["
+                    << std::hex << std::setw(4) << std::setfill('0') << its_service << "."
+                    << std::hex << std::setw(4) << std::setfill('0') << its_method << "."
+                    << std::hex << std::setw(4) << std::setfill('0') << its_session << "]";
+        }
         print_status();
     }
 }
diff --git a/implementation/endpoints/src/local_client_endpoint_impl.cpp b/implementation/endpoints/src/local_client_endpoint_impl.cpp
index cc444a9..009ac9f 100644
--- a/implementation/endpoints/src/local_client_endpoint_impl.cpp
+++ b/implementation/endpoints/src/local_client_endpoint_impl.cpp
@@ -275,4 +275,14 @@ void local_client_endpoint_impl::print_status() {
             << its_queue_size << " data: " << its_data_size;
 }
 
+std::string local_client_endpoint_impl::get_remote_information() const {
+#ifdef _WIN32
+    boost::system::error_code ec;
+    return remote_.address().to_string(ec) + ":"
+            + std::to_string(remote_.port());
+#else
+    return remote_.path();
+#endif
+}
+
 } // namespace vsomeip
diff --git a/implementation/endpoints/src/local_server_endpoint_impl.cpp b/implementation/endpoints/src/local_server_endpoint_impl.cpp
index c558661..6ae9c6c 100644
--- a/implementation/endpoints/src/local_server_endpoint_impl.cpp
+++ b/implementation/endpoints/src/local_server_endpoint_impl.cpp
@@ -678,5 +678,15 @@ void local_server_endpoint_impl::print_status() {
                 << " recv_buffer: " << std::dec << its_recv_size;
     }
 }
+std::string local_server_endpoint_impl::get_remote_information(
+        const queue_iterator_type _queue_iterator) const {
+#ifdef _WIN32
+    boost::system::error_code ec;
+    return _queue_iterator->first.address().to_string(ec) + ":"
+            + std::to_string(_queue_iterator->first.port());
+#else
+    return _queue_iterator->first.path();
+#endif
+}
 
 } // namespace vsomeip
diff --git a/implementation/endpoints/src/server_endpoint_impl.cpp b/implementation/endpoints/src/server_endpoint_impl.cpp
index 17e26df..83e3e34 100644
--- a/implementation/endpoints/src/server_endpoint_impl.cpp
+++ b/implementation/endpoints/src/server_endpoint_impl.cpp
@@ -58,7 +58,8 @@ bool server_endpoint_impl<Protocol>::is_connected() const {
 }
 
 template<typename Protocol>
-bool server_endpoint_impl<Protocol>::send(const uint8_t *_data,
+void server_endpoint_impl<Protocol>::set_connected(bool _connected) {
+    (void) _connected;
+}
+template<typename Protocol>
+bool server_endpoint_impl<Protocol>::send(const uint8_t *_data,
         uint32_t _size, bool _flush) {
 #if 0
     std::stringstream msg;
@@ -254,8 +255,39 @@ void server_endpoint_impl<Protocol>::send_cbk(
             send_queued(_queue_iterator);
         }
     } else {
+        message_buffer_ptr_t its_buffer;
+        if (_queue_iterator->second.second.size()) {
+            its_buffer = _queue_iterator->second.second.front();
+        }
+        service_t its_service(0);
+        method_t its_method(0);
+        client_t its_client(0);
+        session_t its_session(0);
+        if (its_buffer && its_buffer->size() > VSOMEIP_SESSION_POS_MAX) {
+            its_service = VSOMEIP_BYTES_TO_WORD(
+                    (*its_buffer)[VSOMEIP_SERVICE_POS_MIN],
+                    (*its_buffer)[VSOMEIP_SERVICE_POS_MAX]);
+            its_method = VSOMEIP_BYTES_TO_WORD(
+                    (*its_buffer)[VSOMEIP_METHOD_POS_MIN],
+                    (*its_buffer)[VSOMEIP_METHOD_POS_MAX]);
+            its_client = VSOMEIP_BYTES_TO_WORD(
+                    (*its_buffer)[VSOMEIP_CLIENT_POS_MIN],
+                    (*its_buffer)[VSOMEIP_CLIENT_POS_MAX]);
+            its_session = VSOMEIP_BYTES_TO_WORD(
+                    (*its_buffer)[VSOMEIP_SESSION_POS_MIN],
+                    (*its_buffer)[VSOMEIP_SESSION_POS_MAX]);
+        }
         // error: sending of outstanding responses isn't started again
         // delete remaining outstanding responses
+        VSOMEIP_WARNING << "sei::send_cbk received error: " << _error.message()
+                << " (" << std::dec << _error.value() << ") "
+                << get_remote_information(_queue_iterator) << " "
+                << std::dec << _queue_iterator->second.second.size() << " "
+                << std::dec << _queue_iterator->second.first << " ("
+                << std::hex << std::setw(4) << std::setfill('0') << its_client <<"): ["
+                << std::hex << std::setw(4) << std::setfill('0') << its_service << "."
+                << std::hex << std::setw(4) << std::setfill('0') << its_method << "."
+                << std::hex << std::setw(4) << std::setfill('0') << its_session << "]";
         queues_.erase(_queue_iterator);
     }
 }
diff --git a/implementation/endpoints/src/tcp_client_endpoint_impl.cpp b/implementation/endpoints/src/tcp_client_endpoint_impl.cpp
index f1d2efc..7921e42 100644
--- a/implementation/endpoints/src/tcp_client_endpoint_impl.cpp
+++ b/implementation/endpoints/src/tcp_client_endpoint_impl.cpp
@@ -371,9 +371,6 @@ void tcp_client_endpoint_impl::receive_cbk(
     VSOMEIP_INFO << msg.str();
 #endif
     std::unique_lock<std::mutex> its_lock(socket_mutex_);
-    if (!is_connected_) {
-        return;
-    }
     std::shared_ptr<endpoint_host> its_host = host_.lock();
     if (its_host) {
         if (!_error && 0 < _bytes) {
@@ -614,4 +611,10 @@ void tcp_client_endpoint_impl::print_status() {
             << " recv_buffer: " << std::dec << its_receive_buffer_capacity;
 }
 
+std::string tcp_client_endpoint_impl::get_remote_information() const {
+    boost::system::error_code ec;
+    return remote_.address().to_string(ec) + ":"
+            + std::to_string(remote_.port());
+}
+
 } // namespace vsomeip
diff --git a/implementation/endpoints/src/tcp_server_endpoint_impl.cpp b/implementation/endpoints/src/tcp_server_endpoint_impl.cpp
index 5a061e1..01c6db1 100644
--- a/implementation/endpoints/src/tcp_server_endpoint_impl.cpp
+++ b/implementation/endpoints/src/tcp_server_endpoint_impl.cpp
@@ -766,4 +766,11 @@ void tcp_server_endpoint_impl::print_status() {
     }
 }
 
+std::string tcp_server_endpoint_impl::get_remote_information(
+        const queue_iterator_type _queue_iterator) const {
+    boost::system::error_code ec;
+    return _queue_iterator->first.address().to_string(ec) + ":"
+            + std::to_string(_queue_iterator->first.port());
+}
+
 }  // namespace vsomeip
diff --git a/implementation/endpoints/src/udp_client_endpoint_impl.cpp b/implementation/endpoints/src/udp_client_endpoint_impl.cpp
index c8ca0e0..a478e69 100644
--- a/implementation/endpoints/src/udp_client_endpoint_impl.cpp
+++ b/implementation/endpoints/src/udp_client_endpoint_impl.cpp
@@ -271,4 +271,10 @@ void udp_client_endpoint_impl::print_status() {
             << " data: " << std::dec << its_data_size;
 }
 
+std::string udp_client_endpoint_impl::get_remote_information() const {
+    boost::system::error_code ec;
+    return remote_.address().to_string(ec) + ":"
+            + std::to_string(remote_.port());
+}
+
 } // namespace vsomeip
diff --git a/implementation/endpoints/src/udp_server_endpoint_impl.cpp b/implementation/endpoints/src/udp_server_endpoint_impl.cpp
index 92990f1..5666821 100644
--- a/implementation/endpoints/src/udp_server_endpoint_impl.cpp
+++ b/implementation/endpoints/src/udp_server_endpoint_impl.cpp
@@ -418,4 +418,11 @@ void udp_server_endpoint_impl::print_status() {
     }
 }
 
+std::string udp_server_endpoint_impl::get_remote_information(
+        const queue_iterator_type _queue_iterator) const {
+    boost::system::error_code ec;
+    return _queue_iterator->first.address().to_string(ec) + ":"
+            + std::to_string(_queue_iterator->first.port());
+}
+
 } // namespace vsomeip
diff --git a/implementation/endpoints/src/virtual_server_endpoint_impl.cpp b/implementation/endpoints/src/virtual_server_endpoint_impl.cpp
index 74bbab6..fe5aa13 100644
--- a/implementation/endpoints/src/virtual_server_endpoint_impl.cpp
+++ b/implementation/endpoints/src/virtual_server_endpoint_impl.cpp
@@ -28,6 +28,10 @@ bool virtual_server_endpoint_impl::is_connected() const {
     return false;
 }
 
+void virtual_server_endpoint_impl::set_connected(bool _connected) {
+    (void) _connected;
+}
+
 bool virtual_server_endpoint_impl::send(const byte_t *_data, uint32_t _size,
         bool _flush) {
     (void)_data;
diff --git a/implementation/routing/include/routing_manager_proxy.hpp b/implementation/routing/include/routing_manager_proxy.hpp
index 806024b..ac7bded 100644
--- a/implementation/routing/include/routing_manager_proxy.hpp
+++ b/implementation/routing/include/routing_manager_proxy.hpp
@@ -218,7 +218,7 @@ private:
     std::set<event_data_t> pending_event_registrations_;
 
     std::map<client_t, std::set<subscription_data_t>> pending_incoming_subscripitons_;
-    std::mutex incoming_subscriptions_mutex_;
+    std::recursive_mutex incoming_subscriptions_mutex_;
 
     std::mutex state_mutex_;
     std::condition_variable state_condition_;
diff --git a/implementation/routing/src/routing_manager_impl.cpp b/implementation/routing/src/routing_manager_impl.cpp
index 6af17a4..15f1201 100644
--- a/implementation/routing/src/routing_manager_impl.cpp
+++ b/implementation/routing/src/routing_manager_impl.cpp
@@ -1283,6 +1283,7 @@ void routing_manager_impl::on_connect(std::shared_ptr<endpoint> _endpoint) {
                             if (found_endpoint->second.get() == _endpoint.get()) {
                                 std::shared_ptr<serviceinfo> its_info(find_service(its_service.first, its_instance.first));
                                 if (!its_info) {
+                                    _endpoint->set_connected(true);
                                     return;
                                 }
                                 services_to_report_.push_front(
@@ -1290,7 +1291,7 @@ void routing_manager_impl::on_connect(std::shared_ptr<endpoint> _endpoint) {
                                                     its_instance.first,
                                                     its_info->get_major(),
                                                     its_info->get_minor(),
-                                                    false, nullptr });
+                                                    false, _endpoint });
                             }
                         }
                         found_endpoint = its_client.second.find(true);
@@ -1298,6 +1299,7 @@ void routing_manager_impl::on_connect(std::shared_ptr<endpoint> _endpoint) {
                             if (found_endpoint->second.get() == _endpoint.get()) {
                                 std::shared_ptr<serviceinfo> its_info(find_service(its_service.first, its_instance.first));
                                 if (!its_info) {
+                                    _endpoint->set_connected(true);
                                     return;
                                 }
                                 services_to_report_.push_front(
@@ -1335,6 +1337,9 @@ void routing_manager_impl::on_connect(std::shared_ptr<endpoint> _endpoint) {
             VSOMEIP_ERROR<< "routing_manager_impl::on_connect: " << ec.message();
         }
     }
+    if (services_to_report_.empty()) {
+        _endpoint->set_connected(true);
+    }
 }
 
 void routing_manager_impl::on_disconnect(std::shared_ptr<endpoint> _endpoint) {
@@ -2437,6 +2442,16 @@ void routing_manager_impl::expire_subscriptions(const boost::asio::ip::address &
                     clear_remote_subscriber(its_service.first,
                             its_instance.first, its_client, its_endpoint);
 
+                    if (its_eventgroup.second->get_targets().size() == 0) {
+                        std::set<std::shared_ptr<event> > its_events
+                            = its_eventgroup.second->get_events();
+                        for (auto e : its_events) {
+                            if (e->is_shadow()) {
+                                e->unset_payload();
+                            }
+                        }
+                    }
+
                     if (target) {
                         stub_->send_unsubscribe(target, its_client, its_service.first,
                                 its_instance.first, its_eventgroup.first, ANY_EVENT, true);
@@ -3350,6 +3365,16 @@ routing_manager_impl::expire_subscriptions() {
                     clear_remote_subscriber(its_service.first, its_instance.first,
                             its_client, its_endpoint);
 
+                    if (its_eventgroup.second->get_targets().size() == 0) {
+                        std::set<std::shared_ptr<event> > its_events
+                            = its_eventgroup.second->get_events();
+                        for (auto e : its_events) {
+                            if (e->is_shadow()) {
+                                e->unset_payload();
+                            }
+                        }
+                    }
+
                     if (target) {
                         stub_->send_unsubscribe(target, its_client, its_service.first,
                                 its_instance.first, its_eventgroup.first, ANY_EVENT, true);
@@ -3931,16 +3956,12 @@ void routing_manager_impl::set_routing_state(routing_state_e _routing_state) {
 }
 
 void routing_manager_impl::on_net_if_state_changed(std::string _if, bool _available) {
-    if (_available != if_state_running_) {
-        if (_available) {
-            VSOMEIP_INFO << "Network interface \"" << _if << "\" is up and running.";
-            start_ip_routing();
-#ifndef _WIN32
-            if (netlink_connector_) {
-                netlink_connector_->unregister_net_if_changes_handler();
-            }
-#endif
-        }
+    if (!if_state_running_ && _available) {
+        VSOMEIP_INFO << "Network interface \"" << _if << "\" is up and running.";
+        start_ip_routing();
+    } else {
+        VSOMEIP_WARNING << "Network interface \"" << _if << "\" state changed: "
+                << std::string((_available) ? "up" : "down");
     }
 }
 
@@ -4026,6 +4047,7 @@ void routing_manager_impl::call_sd_endpoint_connected(
     if (_error) {
         return;
     }
+    _endpoint->set_connected(true);
     if (discovery_) {
         discovery_->on_endpoint_connected(_service, _instance,
                 _endpoint);
diff --git a/implementation/routing/src/routing_manager_proxy.cpp b/implementation/routing/src/routing_manager_proxy.cpp
index a4af448..8dd8515 100644
--- a/implementation/routing/src/routing_manager_proxy.cpp
+++ b/implementation/routing/src/routing_manager_proxy.cpp
@@ -774,6 +774,7 @@ bool routing_manager_proxy::send_to(
 }
 
 void routing_manager_proxy::on_connect(std::shared_ptr<endpoint> _endpoint) {
+    _endpoint->set_connected(true);
     {
         std::lock_guard<std::mutex> its_lock(sender_mutex_);
         if (_endpoint != sender_) {
@@ -850,6 +851,7 @@ void routing_manager_proxy::on_message(const byte_t *_data, length_t _size,
     client_t its_subscriber;
     bool its_reliable;
     pending_subscription_id_t its_subscription_id(DEFAULT_SUBSCRIPTION);
+    std::uint32_t its_remote_subscriber_count(0);
 
     if (_size > VSOMEIP_COMMAND_SIZE_POS_MAX) {
         its_command = _data[VSOMEIP_COMMAND_TYPE_POS];
@@ -983,7 +985,7 @@ void routing_manager_proxy::on_message(const byte_t *_data, length_t _size,
             std::memcpy(&its_subscription_id, &_data[VSOMEIP_COMMAND_PAYLOAD_POS + 10],
                     sizeof(its_subscription_id));
             {
-                std::unique_lock<std::mutex> its_lock(incoming_subscriptions_mutex_);
+                std::unique_lock<std::recursive_mutex> its_lock(incoming_subscriptions_mutex_);
                 if (its_subscription_id != DEFAULT_SUBSCRIPTION) {
                     its_lock.unlock();
                     // Remote subscriber: Notify routing manager initially + count subscribes
@@ -991,7 +993,7 @@ void routing_manager_proxy::on_message(const byte_t *_data, length_t _size,
                     host_->on_subscription(its_service, its_instance, its_eventgroup,
                         its_client, true,
                         [this, self, its_client, its_service, its_instance,
-                            its_eventgroup, its_event, its_subscription_id]
+                            its_eventgroup, its_event, its_subscription_id, its_major]
                                 (const bool _subscription_accepted){
                         if(_subscription_accepted) {
                             send_subscribe_ack(its_client, its_service, its_instance,
@@ -1007,7 +1009,17 @@ void routing_manager_proxy::on_message(const byte_t *_data, length_t _size,
                             notify_remote_initially(its_service, its_instance, its_eventgroup,
                                     its_already_subscribed_events);
                         }
-                        (void)get_remote_subscriber_count(its_service, its_instance, its_eventgroup, true);
+                        std::uint32_t its_count = get_remote_subscriber_count(
+                                its_service, its_instance, its_eventgroup, true);
+                        VSOMEIP_INFO << "SUBSCRIBE("
+                            << std::hex << std::setw(4) << std::setfill('0') << its_client <<"): ["
+                            << std::hex << std::setw(4) << std::setfill('0') << its_service << "."
+                            << std::hex << std::setw(4) << std::setfill('0') << its_instance << "."
+                            << std::hex << std::setw(4) << std::setfill('0') << its_eventgroup << ":"
+                            << std::hex << std::setw(4) << std::setfill('0') << its_event << ":"
+                            << std::dec << (uint16_t)its_major << "]"
+                            << (bool)(its_subscription_id != DEFAULT_SUBSCRIPTION) << " "
+                            << std::dec << its_count;
                     });
                 } else if (is_client_known(its_client)) {
                     its_lock.unlock();
@@ -1048,13 +1060,15 @@ void routing_manager_proxy::on_message(const byte_t *_data, length_t _size,
                     pending_incoming_subscripitons_[its_client].insert(subscription);
                 }
             }
-            VSOMEIP_INFO << "SUBSCRIBE("
-                << std::hex << std::setw(4) << std::setfill('0') << its_client <<"): ["
-                << std::hex << std::setw(4) << std::setfill('0') << its_service << "."
-                << std::hex << std::setw(4) << std::setfill('0') << its_instance << "."
-                << std::hex << std::setw(4) << std::setfill('0') << its_eventgroup << ":"
-                << std::hex << std::setw(4) << std::setfill('0') << its_event << ":"
-                << std::dec << (uint16_t)its_major << "]";
+            if (its_subscription_id == DEFAULT_SUBSCRIPTION) { // local subscription
+                VSOMEIP_INFO << "SUBSCRIBE("
+                    << std::hex << std::setw(4) << std::setfill('0') << its_client <<"): ["
+                    << std::hex << std::setw(4) << std::setfill('0') << its_service << "."
+                    << std::hex << std::setw(4) << std::setfill('0') << its_instance << "."
+                    << std::hex << std::setw(4) << std::setfill('0') << its_eventgroup << ":"
+                    << std::hex << std::setw(4) << std::setfill('0') << its_event << ":"
+                    << std::dec << (uint16_t)its_major << "]";
+            }
             break;
 
         case VSOMEIP_UNSUBSCRIBE:
@@ -1078,7 +1092,9 @@ void routing_manager_proxy::on_message(const byte_t *_data, length_t _size,
                 routing_manager_base::unsubscribe(its_client, its_service, its_instance, its_eventgroup, its_event);
             } else {
                 // Remote subscriber: withdraw subscription only if no more remote subscriber exists
-                if (!get_remote_subscriber_count(its_service, its_instance, its_eventgroup, false)) {
+                its_remote_subscriber_count = get_remote_subscriber_count(its_service,
+                        its_instance, its_eventgroup, false);
+                if (!its_remote_subscriber_count) {
                     routing_manager_base::unsubscribe(VSOMEIP_ROUTING_CLIENT, its_service,
                             its_instance, its_eventgroup, its_event);
                 }
@@ -1088,7 +1104,9 @@ void routing_manager_proxy::on_message(const byte_t *_data, length_t _size,
                 << std::hex << std::setw(4) << std::setfill('0') << its_service << "."
                 << std::hex << std::setw(4) << std::setfill('0') << its_instance << "."
                 << std::hex << std::setw(4) << std::setfill('0') << its_eventgroup << "."
-                << std::hex << std::setw(4) << std::setfill('0') << its_event << "]";
+                << std::hex << std::setw(4) << std::setfill('0') << its_event << "] "
+                << (bool)is_remote_subscriber << " "
+                << std::dec << its_remote_subscriber_count;
             break;
 
         case VSOMEIP_SUBSCRIBE_NACK:
@@ -1334,7 +1352,7 @@ void routing_manager_proxy::on_routing_info(const byte_t *_data,
             major_version_t major_;
             event_t event_;
         };
-        std::lock_guard<std::mutex> its_lock(incoming_subscriptions_mutex_);
+        std::lock_guard<std::recursive_mutex> its_lock(incoming_subscriptions_mutex_);
         std::forward_list<struct subscription_info> subscription_actions;
         if (pending_incoming_subscripitons_.size()) {
             {
@@ -1371,7 +1389,10 @@ void routing_manager_proxy::on_routing_info(const byte_t *_data,
                         send_pending_notify_ones(si.service_id_,
                                 si.instance_id_, si.eventgroup_id_, si.client_id_);
                     }
-                    pending_incoming_subscripitons_.erase(si.client_id_);
+                    {
+                        std::lock_guard<std::recursive_mutex> its_lock2(incoming_subscriptions_mutex_);
+                        pending_incoming_subscripitons_.erase(si.client_id_);
+                    }
                 });
             }
         }
diff --git a/implementation/routing/src/routing_manager_stub.cpp b/implementation/routing/src/routing_manager_stub.cpp
index 010c8d0..8d48436 100644
--- a/implementation/routing/src/routing_manager_stub.cpp
+++ b/implementation/routing/src/routing_manager_stub.cpp
@@ -161,7 +161,7 @@ const std::shared_ptr<configuration> routing_manager_stub::get_configuration() c
 }
 
 void routing_manager_stub::on_connect(std::shared_ptr<endpoint> _endpoint) {
-    (void)_endpoint;
+    _endpoint->set_connected(true);
 }
 
 void routing_manager_stub::on_disconnect(std::shared_ptr<endpoint> _endpoint) {
diff --git a/implementation/service_discovery/include/service_discovery_impl.hpp b/implementation/service_discovery/include/service_discovery_impl.hpp
index d3c5f07..020de59 100644
--- a/implementation/service_discovery/include/service_discovery_impl.hpp
+++ b/implementation/service_discovery/include/service_discovery_impl.hpp
@@ -139,14 +139,14 @@ private:
 
     void process_serviceentry(std::shared_ptr<serviceentry_impl> &_entry,
             const std::vector<std::shared_ptr<option_impl> > &_options,
-            bool _unicast_flag);
+            bool _unicast_flag, std::vector<std::pair<std::uint16_t, std::shared_ptr<message_impl>>>* _resubscribes);
     void process_offerservice_serviceentry(
             service_t _service, instance_t _instance, major_version_t _major,
             minor_version_t _minor, ttl_t _ttl,
             const boost::asio::ip::address &_reliable_address,
             uint16_t _reliable_port,
             const boost::asio::ip::address &_unreliable_address,
-            uint16_t _unreliable_port);
+            uint16_t _unreliable_port, std::vector<std::pair<std::uint16_t, std::shared_ptr<message_impl>>>* _resubscribes);
     void send_offer_service(
             const std::shared_ptr<const serviceinfo> &_info, service_t _service,
             instance_t _instance, major_version_t _major, minor_version_t _minor,
@@ -319,6 +319,8 @@ private:
     configuration::ttl_factor_t get_ttl_factor(
             service_t _service, instance_t _instance,
             const configuration::ttl_map_t& _ttl_map) const;
+    void on_last_msg_received_timer_expired(const boost::system::error_code &_error);
+    void stop_last_msg_received_timer();
 
 private:
     boost::asio::io_service &io_;
@@ -411,6 +413,10 @@ private:
 
     configuration::ttl_map_t ttl_factor_offers_;
     configuration::ttl_map_t ttl_factor_subscriptions_;
+
+    std::mutex last_msg_received_timer_mutex_;
+    boost::asio::steady_timer last_msg_received_timer_;
+    std::chrono::milliseconds last_msg_received_timer_timeout_;
 };
 
 }  // namespace sd
diff --git a/implementation/service_discovery/src/service_discovery_impl.cpp b/implementation/service_discovery/src/service_discovery_impl.cpp
index fb13a8b..d617e0c 100644
--- a/implementation/service_discovery/src/service_discovery_impl.cpp
+++ b/implementation/service_discovery/src/service_discovery_impl.cpp
@@ -64,7 +64,10 @@ service_discovery_impl::service_discovery_impl(service_discovery_host *_host)
           find_debounce_timer_(_host->get_io()),
           main_phase_timer_(_host->get_io()),
           is_suspended_(false),
-          is_diagnosis_(false) {
+          is_diagnosis_(false),
+          last_msg_received_timer_(_host->get_io()),
+          last_msg_received_timer_timeout_(VSOMEIP_SD_DEFAULT_CYCLIC_OFFER_DELAY +
+                                           (VSOMEIP_SD_DEFAULT_CYCLIC_OFFER_DELAY / 10)) {
     // TODO: cleanup start condition!
     next_subscription_expiration_ = std::chrono::steady_clock::now() + std::chrono::hours(24);
 }
@@ -134,6 +137,8 @@ void service_discovery_impl::init() {
 
         ttl_factor_offers_ = its_configuration->get_ttl_factor_offers();
         ttl_factor_subscriptions_ = its_configuration->get_ttl_factor_subscribes();
+        last_msg_received_timer_timeout_ = cyclic_offer_delay_
+                + (cyclic_offer_delay_ / 10);
     } else {
         VSOMEIP_ERROR << "SD: no configuration found!";
     }
@@ -172,6 +177,7 @@ void service_discovery_impl::start() {
 void service_discovery_impl::stop() {
     is_suspended_ = true;
     stop_ttl_timer();
+    stop_last_msg_received_timer();
 }
 
 void service_discovery_impl::request_service(service_t _service,
@@ -1121,24 +1127,14 @@ void service_discovery_impl::on_message(const byte_t *_data, length_t _length,
         return;
     }
     if (_destination == sd_multicast_address_) {
-        static std::chrono::steady_clock::time_point last_msg_received =
-                std::chrono::steady_clock::now();
-        std::chrono::steady_clock::time_point now =
-                std::chrono::steady_clock::now();
-        std::chrono::milliseconds time_since_last_message(
-                std::chrono::duration_cast<std::chrono::milliseconds>(
-                        now - last_msg_received));
-        if (time_since_last_message >
-            std::chrono::milliseconds(cyclic_offer_delay_ + (cyclic_offer_delay_ / 10))) {
-            // we didn't receive a multicast message within 110% of the cyclic_offer_delay_
-            VSOMEIP_WARNING << "Didn't receive a multicast SD message for " <<
-                    std::dec << time_since_last_message.count() << "ms.";
-            // rejoin multicast group
-            if (endpoint_) {
-                endpoint_->join(sd_multicast_);
-            }
-        }
-        last_msg_received = now;
+        std::lock_guard<std::mutex> its_lock(last_msg_received_timer_mutex_);
+        boost::system::error_code ec;
+        last_msg_received_timer_.cancel(ec);
+        last_msg_received_timer_.expires_from_now(last_msg_received_timer_timeout_, ec);
+        last_msg_received_timer_.async_wait(
+                std::bind(
+                        &service_discovery_impl::on_last_msg_received_timer_expired,
+                        shared_from_this(), std::placeholders::_1));
     }
 
     current_remote_address_ = _sender;
@@ -1178,6 +1174,10 @@ void service_discovery_impl::on_message(const byte_t *_data, length_t _length,
                         its_message->get_session(), _sender, _destination,
                         its_message_response);
 
+        std::vector<std::pair<std::uint16_t, std::shared_ptr<message_impl>>> its_resubscribes;
+        // 28 Bytes for SD-Header + Length Entries and Options Array
+        its_resubscribes.push_back(std::make_pair(28, its_runtime->create_message()));
+
         const message_impl::entries_t& its_entries = its_message->get_entries();
         const message_impl::entries_t::const_iterator its_end = its_entries.end();
         bool is_stop_subscribe_subscribe(false);
@@ -1188,7 +1188,8 @@ void service_discovery_impl::on_message(const byte_t *_data, length_t _length,
                         std::dynamic_pointer_cast < serviceentry_impl
                                 > (*iter);
                 bool its_unicast_flag = its_message->get_unicast_flag();
-                process_serviceentry(its_service_entry, its_options, its_unicast_flag );
+                process_serviceentry(its_service_entry, its_options,
+                        its_unicast_flag, &its_resubscribes);
             } else {
                 std::shared_ptr < eventgroupentry_impl > its_eventgroup_entry =
                         std::dynamic_pointer_cast < eventgroupentry_impl
@@ -1225,6 +1226,11 @@ void service_discovery_impl::on_message(const byte_t *_data, length_t _length,
                 }
             }
         }
+        for (const auto& response : its_resubscribes) {
+            if (response.second->get_entries().size() && response.second->get_options().size()) {
+                serialize_and_send(response.second, _sender);
+            }
+        }
     } else {
         VSOMEIP_ERROR << "service_discovery_impl::on_message: deserialization error.";
         return;
@@ -1235,7 +1241,8 @@ void service_discovery_impl::on_message(const byte_t *_data, length_t _length,
 void service_discovery_impl::process_serviceentry(
         std::shared_ptr<serviceentry_impl> &_entry,
         const std::vector<std::shared_ptr<option_impl> > &_options,
-        bool _unicast_flag) {
+        bool _unicast_flag,
+        std::vector<std::pair<std::uint16_t, std::shared_ptr<message_impl>>>* _resubscribes) {
 
     // Read service info from entry
     entry_type_e its_type = _entry->get_type();
@@ -1320,7 +1327,7 @@ void service_discovery_impl::process_serviceentry(
                 process_offerservice_serviceentry(its_service, its_instance,
                         its_major, its_minor, its_ttl,
                         its_reliable_address, its_reliable_port,
-                        its_unreliable_address, its_unreliable_port);
+                        its_unreliable_address, its_unreliable_port, _resubscribes);
                 break;
             case entry_type_e::UNKNOWN:
             default:
@@ -1349,7 +1356,8 @@ void service_discovery_impl::process_offerservice_serviceentry(
         const boost::asio::ip::address &_reliable_address,
         uint16_t _reliable_port,
         const boost::asio::ip::address &_unreliable_address,
-        uint16_t _unreliable_port) {
+        uint16_t _unreliable_port,
+        std::vector<std::pair<std::uint16_t, std::shared_ptr<message_impl>>>* _resubscribes) {
     std::shared_ptr < runtime > its_runtime = runtime_.lock();
     if (!its_runtime)
         return;
@@ -1366,14 +1374,24 @@ void service_discovery_impl::process_offerservice_serviceentry(
                             _reliable_address, _reliable_port,
                             _unreliable_address, _unreliable_port);
 
+    const std::function<void(std::uint16_t)> check_space =
+            [&_resubscribes, &its_runtime](std::uint16_t _number) {
+        if (_resubscribes->back().first + _number > VSOMEIP_MAX_UDP_MESSAGE_SIZE) {
+            // 28 Bytes for SD-Header + Length Entries and Options Array
+            _resubscribes->push_back(std::make_pair(28 + _number,
+                                                    its_runtime->create_message()));
+        } else {
+            _resubscribes->back().first =
+                    static_cast<std::uint16_t>(_resubscribes->back().first + _number);
+        }
+    };
+
     std::lock_guard<std::mutex> its_lock(subscribed_mutex_);
     auto found_service = subscribed_.find(_service);
     if (found_service != subscribed_.end()) {
         auto found_instance = found_service->second.find(_instance);
         if (found_instance != found_service->second.end()) {
             if (0 < found_instance->second.size()) {
-                std::shared_ptr<message_impl> its_message
-                    = its_runtime->create_message();
                 for (auto its_eventgroup : found_instance->second) {
                     for (auto its_client : its_eventgroup.second) {
                         std::shared_ptr<subscription> its_subscription(its_client.second);
@@ -1400,22 +1418,42 @@ void service_discovery_impl::process_offerservice_serviceentry(
                                 continue;
                             }
                         }
+
                         if (its_subscription->is_acknowledged()) {
                             if (its_subscription->get_endpoint(true)
                                     && its_subscription->get_endpoint(true)->is_connected()) {
-                                insert_subscription(its_message,
+                                // 40 = 16 (subscription) + 2x12 (option)
+                                check_space(40);
+                                const std::size_t options_size_before =
+                                        _resubscribes->back().second->get_options().size();
+                                insert_subscription(_resubscribes->back().second,
                                         _service, _instance,
                                         its_eventgroup.first,
                                         its_subscription, true, true);
+                                const std::size_t options_size_after =
+                                        _resubscribes->back().second->get_options().size();
+                                const std::size_t diff = options_size_after - options_size_before;
+                                _resubscribes->back().first =
+                                        static_cast<std::uint16_t>(
+                                                _resubscribes->back().first + (12u * diff - 24u));
                             } else {
                                 // don't insert reliable endpoint option if the
                                 // TCP client endpoint is not yet connected
-                                insert_subscription(its_message,
+                                // 28 = 16 (subscription) + 12 (option)
+                                check_space(28);
+                                const std::size_t options_size_before =
+                                        _resubscribes->back().second->get_options().size();
+                                insert_subscription(_resubscribes->back().second,
                                         _service, _instance,
                                         its_eventgroup.first,
                                         its_subscription, false, true);
                                 its_client.second->set_tcp_connection_established(false);
-
+                                const std::size_t options_size_after =
+                                        _resubscribes->back().second->get_options().size();
+                                const std::size_t diff = options_size_after - options_size_before;
+                                _resubscribes->back().first =
+                                        static_cast<std::uint16_t>(
+                                                _resubscribes->back().first + (12u * diff - 12u));
                                 // restart TCP endpoint if not connected
                                 if (its_subscription->get_endpoint(true)
                                         && !its_subscription->get_endpoint(true)->is_connected()) {
@@ -1424,9 +1462,19 @@ void service_discovery_impl::process_offerservice_serviceentry(
                             }
                             its_subscription->set_acknowledged(false);
                         } else {
-                            insert_nack_subscription_on_resubscribe(its_message,
+                            // 56 = 2x16 (subscription) + 2x12 (option)
+                            check_space(56);
+                            const std::size_t options_size_before =
+                                    _resubscribes->back().second->get_options().size();
+                            insert_nack_subscription_on_resubscribe(_resubscribes->back().second,
                                     _service, _instance, its_eventgroup.first,
                                     its_subscription);
+                            const std::size_t options_size_after =
+                                    _resubscribes->back().second->get_options().size();
+                            const std::size_t diff = options_size_after - options_size_before;
+                            _resubscribes->back().first =
+                                    static_cast<std::uint16_t>(
+                                            _resubscribes->back().first + (12u * diff - 24u));
 
                             // restart TCP endpoint if not connected
                             if (its_subscription->get_endpoint(true)
@@ -1436,34 +1484,6 @@ void service_discovery_impl::process_offerservice_serviceentry(
                         }
                     }
                 }
-
-                if (its_message->get_entries().size()
-                        && its_message->get_options().size()) {
-                    std::shared_ptr<endpoint_definition> its_target;
-                    std::pair<session_t, bool> its_session;
-                    std::lock_guard<std::mutex> its_lock(serialize_mutex_);
-                    if (_reliable_port != ILLEGAL_PORT) {
-                        its_target = endpoint_definition::get(
-                                _reliable_address, port_, reliable_, _service, _instance);
-                        its_session = get_session(_reliable_address);
-                    } else if (_unreliable_port != ILLEGAL_PORT) {
-                        its_target = endpoint_definition::get(
-                                _unreliable_address, port_, reliable_, _service, _instance);
-                        its_session = get_session(_unreliable_address);
-                    }
-
-                    if (its_target) {
-                        its_message->set_session(its_session.first);
-                        its_message->set_reboot_flag(its_session.second);
-                        serializer_->serialize(its_message.get());
-                        if (host_->send_to(its_target,
-                                           serializer_->get_data(),
-                                           serializer_->get_size(), port_)) {
-                            increment_session(its_target->get_address());
-                        }
-                        serializer_->reset();
-                    }
-                }
             }
         }
     }
@@ -1751,7 +1771,10 @@ void service_discovery_impl::process_eventgroupentry(
     uint8_t its_counter = _entry->get_counter();
 
     if (_entry->get_owning_message()->get_return_code() != return_code) {
-        VSOMEIP_ERROR << "Invalid return code in SD header";
+        boost::system::error_code ec;
+        VSOMEIP_ERROR << "Invalid return code in SD header "
+                << _message_id->sender_.to_string(ec) << " session: "
+                << std::hex << std::setw(4) << std::setfill('0') << _message_id->session_;
         if(its_ttl > 0) {
             insert_subscription_nack(its_message_response, its_service, its_instance,
                                      its_eventgroup, its_counter, its_major, its_reserved);
@@ -1761,7 +1784,10 @@ void service_discovery_impl::process_eventgroupentry(
 
     if(its_type == entry_type_e::SUBSCRIBE_EVENTGROUP) {
         if( _destination.is_multicast() ) {
-            VSOMEIP_ERROR << "Received a SubscribeEventGroup entry on multicast address";
+            boost::system::error_code ec;
+            VSOMEIP_ERROR << "Received a SubscribeEventGroup entry on multicast address "
+                    << _message_id->sender_.to_string(ec) << " session: "
+                    << std::hex << std::setw(4) << std::setfill('0') << _message_id->session_;
             if(its_ttl > 0) {
                 insert_subscription_nack(its_message_response, its_service, its_instance,
                                          its_eventgroup, its_counter, its_major, its_reserved);
@@ -1770,7 +1796,10 @@ void service_discovery_impl::process_eventgroupentry(
         }
         if (_entry->get_num_options(1) == 0
                 && _entry->get_num_options(2) == 0) {
-            VSOMEIP_ERROR << "Invalid number of options in SubscribeEventGroup entry";
+            boost::system::error_code ec;
+            VSOMEIP_ERROR << "Invalid number of options in SubscribeEventGroup entry "
+                    << _message_id->sender_.to_string(ec) << " session: "
+                    << std::hex << std::setw(4) << std::setfill('0') << _message_id->session_;
             if(its_ttl > 0) {
                 // increase number of required acks by one as number required acks
                 // is calculated based on the number of referenced options
@@ -1781,7 +1810,10 @@ void service_discovery_impl::process_eventgroupentry(
             return;
         }
         if(_entry->get_owning_message()->get_options_length() < 12) {
-            VSOMEIP_ERROR << "Invalid options length in SD message";
+            boost::system::error_code ec;
+            VSOMEIP_ERROR << "Invalid options length in SD message "
+                    << _message_id->sender_.to_string(ec) << " session: "
+                    << std::hex << std::setw(4) << std::setfill('0') << _message_id->session_;
             if(its_ttl > 0) {
                 insert_subscription_nack(its_message_response, its_service, its_instance,
                                          its_eventgroup, its_counter, its_major, its_reserved);
@@ -1793,8 +1825,11 @@ void service_discovery_impl::process_eventgroupentry(
                  // by the + operator on 16 bit or higher machines. 
                  < static_cast<std::vector<std::shared_ptr<option_impl>>::size_type>(
                      (_entry->get_num_options(1)) + (_entry->get_num_options(2)))) {
+            boost::system::error_code ec;
             VSOMEIP_ERROR << "Fewer options in SD message than "
-                             "referenced in EventGroup entry or malformed option received";
+                             "referenced in EventGroup entry or malformed option received "
+                    << _message_id->sender_.to_string(ec) << " session: "
+                    << std::hex << std::setw(4) << std::setfill('0') << _message_id->session_;
             if(its_ttl > 0) {
                 const std::uint8_t num_overreferenced_options =
                 static_cast<std::uint8_t>(_entry->get_num_options(1) +
@@ -1811,10 +1846,13 @@ void service_discovery_impl::process_eventgroupentry(
         }
         if(_entry->get_owning_message()->get_someip_length() < _entry->get_owning_message()->get_length()
                 && its_ttl > 0) {
+            boost::system::error_code ec;
             VSOMEIP_ERROR  << std::dec << "SomeIP length field in SubscribeEventGroup message header: ["
                                 << _entry->get_owning_message()->get_someip_length()
                                 << "] bytes, is shorter than length of deserialized message: ["
-                                << (uint32_t) _entry->get_owning_message()->get_length() << "] bytes.";
+                                << (uint32_t) _entry->get_owning_message()->get_length() << "] bytes. "
+                                << _message_id->sender_.to_string(ec) << " session: "
+                                << std::hex << std::setw(4) << std::setfill('0') << _message_id->session_;
             return;
         }
     }
@@ -1835,9 +1873,13 @@ void service_discovery_impl::process_eventgroupentry(
 #ifdef _WIN32
                 e; // silence MSVC warining C4101
 #endif
+                boost::system::error_code ec;
                 VSOMEIP_ERROR << "Fewer options in SD message than "
                                  "referenced in EventGroup entry for "
-                                 "option run number: " << i;
+                                 "option run number: " << i << " "
+                                 << _message_id->sender_.to_string(ec) << " session: "
+                                 << std::hex << std::setw(4) << std::setfill('0')
+                                 << _message_id->session_;
                 if (entry_type_e::SUBSCRIBE_EVENTGROUP == its_type && its_ttl > 0) {
                     insert_subscription_nack(its_message_response, its_service, its_instance,
                                              its_eventgroup, its_counter, its_major, its_reserved);
@@ -1873,7 +1915,10 @@ void service_discovery_impl::process_eventgroupentry(
                                 insert_subscription_nack(its_message_response, its_service, its_instance,
                                                          its_eventgroup, its_counter, its_major, its_reserved);
                             }
-                            VSOMEIP_ERROR << "Invalid port or IP address in first IPv4 endpoint option specified!";
+                            boost::system::error_code ec;
+                            VSOMEIP_ERROR << "Invalid port or IP address in first IPv4 endpoint option specified! "
+                                    << _message_id->sender_.to_string(ec) << " session: "
+                                    << std::hex << std::setw(4) << std::setfill('0') << _message_id->session_;
                             return;
                         }
                     } else
@@ -1889,15 +1934,21 @@ void service_discovery_impl::process_eventgroupentry(
                                 insert_subscription_nack(its_message_response, its_service, its_instance,
                                                          its_eventgroup, its_counter, its_major, its_reserved);
                             }
-                            VSOMEIP_ERROR << "Invalid port or IP address in second IPv4 endpoint option specified!";
+                            boost::system::error_code ec;
+                            VSOMEIP_ERROR << "Invalid port or IP address in second IPv4 endpoint option specified! "
+                                    << _message_id->sender_.to_string(ec) << " session: "
+                                    << std::hex << std::setw(4) << std::setfill('0') << _message_id->session_;
                             return;
                         }
                     } else {
                         // TODO: error message, too many endpoint options!
                     }
                 } else {
+                    boost::system::error_code ec;
                     VSOMEIP_ERROR
-                            << "Invalid eventgroup option (IPv4 Endpoint)";
+                            << "Invalid eventgroup option (IPv4 Endpoint)"
+                            << _message_id->sender_.to_string(ec) << " session: "
+                            << std::hex << std::setw(4) << std::setfill('0') << _message_id->session_;
                 }
                 break;
             }
@@ -1914,7 +1965,10 @@ void service_discovery_impl::process_eventgroupentry(
                             insert_subscription_nack(its_message_response, its_service, its_instance,
                                                      its_eventgroup, its_counter, its_major, its_reserved);
                         }
-                        VSOMEIP_ERROR << "Invalid layer 4 protocol type in IPv6 endpoint option specified!";
+                        boost::system::error_code ec;
+                        VSOMEIP_ERROR << "Invalid layer 4 protocol type in IPv6 endpoint option specified! "
+                                << _message_id->sender_.to_string(ec) << " session: "
+                                << std::hex << std::setw(4) << std::setfill('0') << _message_id->session_;
                         return;
                     }
 
@@ -1933,8 +1987,11 @@ void service_discovery_impl::process_eventgroupentry(
                         // TODO: error message, too many endpoint options!
                     }
                 } else {
+                    boost::system::error_code ec;
                     VSOMEIP_ERROR
-                            << "Invalid eventgroup option (IPv6 Endpoint)";
+                            << "Invalid eventgroup option (IPv6 Endpoint) "
+                            << _message_id->sender_.to_string(ec) << " session: "
+                            << std::hex << std::setw(4) << std::setfill('0') << _message_id->session_;
                 }
                 break;
             }
@@ -1958,8 +2015,11 @@ void service_discovery_impl::process_eventgroupentry(
                         // TODO: error message, too many endpoint options!
                     }
                 } else {
+                    boost::system::error_code ec;
                     VSOMEIP_ERROR
-                            << "Invalid eventgroup option (IPv4 Multicast)";
+                            << "Invalid eventgroup option (IPv4 Multicast) "
+                            << _message_id->sender_.to_string(ec) << " session: "
+                            << std::hex << std::setw(4) << std::setfill('0') << _message_id->session_;
                 }
                 break;
             case option_type_e::IP6_MULTICAST:
@@ -1982,8 +2042,11 @@ void service_discovery_impl::process_eventgroupentry(
                         // TODO: error message, too many endpoint options!
                     }
                 } else {
+                    boost::system::error_code ec;
                     VSOMEIP_ERROR
-                            << "Invalid eventgroup option (IPv6 Multicast)";
+                            << "Invalid eventgroup option (IPv6 Multicast) "
+                            << _message_id->sender_.to_string(ec) << " session: "
+                            << std::hex << std::setw(4) << std::setfill('0') << _message_id->session_;
                 }
                 break;
             case option_type_e::CONFIGURATION: {
@@ -1992,7 +2055,10 @@ void service_discovery_impl::process_eventgroupentry(
             }
             case option_type_e::UNKNOWN:
             default:
-                VSOMEIP_WARNING << "Unsupported eventgroup option";
+                boost::system::error_code ec;
+                VSOMEIP_WARNING << "Unsupported eventgroup option "
+                    << _message_id->sender_.to_string(ec) << " session: "
+                    << std::hex << std::setw(4) << std::setfill('0') << _message_id->session_;
                 if(its_ttl > 0) {
                     its_message_response->decrease_number_required_acks();
                     insert_subscription_nack(its_message_response, its_service, its_instance,
@@ -2070,7 +2136,9 @@ void service_discovery_impl::handle_eventgroup_subscription(service_t _service,
                     << " not valid: Event configuration does not match the provided "
                     << "endpoint options: "
                     << _first_address.to_string(ec) << ":" << std::dec << _first_port << " "
-                    << _second_address.to_string(ec) << ":" << std::dec << _second_port;
+                    << _second_address.to_string(ec) << ":" << std::dec << _second_port
+                    << " " << _message_id->sender_.to_string(ec) << " session: "
+                    << std::hex << std::setw(4) << std::setfill('0') << _message_id->session_;
             return;
         }
 
@@ -2088,13 +2156,15 @@ void service_discovery_impl::handle_eventgroup_subscription(service_t _service,
         if (!its_info || _major != its_info->get_major()) {
             // Create a temporary info object with TTL=0 --> send NACK
             if( its_info && (_major != its_info->get_major())) {
+                boost::system::error_code ec;
                 VSOMEIP_ERROR << "Requested major version:[" << (uint32_t) _major
                         << "] in subscription to service: ["
                         << std::hex << std::setw(4) << std::setfill('0') << _service << "."
                         << std::hex << std::setw(4) << std::setfill('0') << _instance << "."
                         << std::hex << std::setw(4) << std::setfill('0') << _eventgroup << "]"
                         << " does not match with services major version:[" << (uint32_t) its_info->get_major()
-                        << "]";
+                        << "] " << _message_id->sender_.to_string(ec) << " session: "
+                        << std::hex << std::setw(4) << std::setfill('0') << _message_id->session_;
             } else {
                 VSOMEIP_ERROR << "Requested eventgroup:[" << _eventgroup
                         << "] not found for subscription to service:["
@@ -2122,13 +2192,16 @@ void service_discovery_impl::handle_eventgroup_subscription(service_t _service,
                     if(_ttl > 0 && !is_tcp_connected(_service, _instance, its_targets[0].target_)) {
                         insert_subscription_nack(its_message, _service, _instance,
                             _eventgroup, _counter, _major, _reserved);
+                        boost::system::error_code ec;
                         VSOMEIP_ERROR << "TCP connection to target1: ["
                                 << its_targets[0].target_->get_address().to_string()
                                 << ":" << its_targets[0].target_->get_port()
                                 << "] not established for subscription to: ["
                                 << std::hex << std::setw(4) << std::setfill('0') << _service << "."
                                 << std::hex << std::setw(4) << std::setfill('0') << _instance << "."
-                                << std::hex << std::setw(4) << std::setfill('0') << _eventgroup << "]";
+                                << std::hex << std::setw(4) << std::setfill('0') << _eventgroup << "] "
+                                << _message_id->sender_.to_string(ec) << " session: "
+                                << std::hex << std::setw(4) << std::setfill('0') << _message_id->session_;
                         if (ILLEGAL_PORT != _second_port) {
                             its_message->decrease_number_required_acks();
                         }
@@ -2151,13 +2224,16 @@ void service_discovery_impl::handle_eventgroup_subscription(service_t _service,
                     if(_ttl > 0 && !is_tcp_connected(_service, _instance, its_targets[1].target_)) {
                         insert_subscription_nack(its_message, _service, _instance,
                             _eventgroup, _counter, _major, _reserved);
+                        boost::system::error_code ec;
                         VSOMEIP_ERROR << "TCP connection to target2 : ["
                                 << its_targets[1].target_->get_address().to_string()
                                 << ":" << its_targets[1].target_->get_port()
                                 << "] not established for subscription to: ["
                                 << std::hex << std::setw(4) << std::setfill('0') << _service << "."
                                 << std::hex << std::setw(4) << std::setfill('0') << _instance << "."
-                                << std::hex << std::setw(4) << std::setfill('0') << _eventgroup << "]";
+                                << std::hex << std::setw(4) << std::setfill('0') << _eventgroup << "] "
+                                << _message_id->sender_.to_string(ec) << " session: "
+                                << std::hex << std::setw(4) << std::setfill('0') << _message_id->session_;
                         if (ILLEGAL_PORT != _first_port) {
                             its_message->decrease_number_required_acks();
                         }
@@ -3413,7 +3489,33 @@ configuration::ttl_factor_t service_discovery_impl::get_ttl_factor(
     return its_ttl_factor;
 }
 
+void service_discovery_impl::on_last_msg_received_timer_expired(
+        const boost::system::error_code &_error) {
+    if (!_error) {
+        // we didn't receive a multicast message within 110% of the cyclic_offer_delay_
+        VSOMEIP_WARNING << "Didn't receive a multicast SD message for " <<
+                std::dec << last_msg_received_timer_timeout_.count() << "ms.";
+        // rejoin multicast group
+        if (endpoint_) {
+            endpoint_->join(sd_multicast_);
+        }
+        {
+            boost::system::error_code ec;
+            std::lock_guard<std::mutex> its_lock(last_msg_received_timer_mutex_);
+            last_msg_received_timer_.expires_from_now(last_msg_received_timer_timeout_, ec);
+            last_msg_received_timer_.async_wait(
+                    std::bind(
+                            &service_discovery_impl::on_last_msg_received_timer_expired,
+                            shared_from_this(), std::placeholders::_1));
+        }
+    }
+}
 
+void service_discovery_impl::stop_last_msg_received_timer() {
+    std::lock_guard<std::mutex> its_lock(last_msg_received_timer_mutex_);
+    boost::system::error_code ec;
+    last_msg_received_timer_.cancel(ec);
+}
 
 }  // namespace sd
 }  // namespace vsomeip
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 25ac281..92a2461 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -1985,6 +1985,26 @@ if(NOT ${TESTS_BAT})
         ${TEST_LINK_LIBRARIES}
     )
 
+    # client and service for offer test big sd msg
+    set(TEST_OFFER_BIG_NAME offer_test_big_sd_msg)
+    set(TEST_OFFER_BIG_SERVICE ${TEST_OFFER_BIG_NAME}_service)
+    add_executable(${TEST_OFFER_BIG_SERVICE} offer_tests/${TEST_OFFER_BIG_NAME}_service.cpp)
+    target_link_libraries(${TEST_OFFER_BIG_SERVICE}
+        vsomeip
+        ${Boost_LIBRARIES}
+        ${DL_LIBRARY}
+        ${TEST_LINK_LIBRARIES}
+    )
+
+    set(TEST_OFFER_BIG_CLIENT ${TEST_OFFER_BIG_NAME}_client)
+    add_executable(${TEST_OFFER_BIG_CLIENT} offer_tests/${TEST_OFFER_BIG_NAME}_client.cpp)
+    target_link_libraries(${TEST_OFFER_BIG_CLIENT}
+        vsomeip
+        ${Boost_LIBRARIES}
+        ${DL_LIBRARY}
+        ${TEST_LINK_LIBRARIES}
+    )
+
     # copy starter scripts into builddir
     set(TEST_OFFER_LOCAL_STARTER ${TEST_OFFER_NAME}_local_starter.sh)
     copy_to_builddir(${PROJECT_SOURCE_DIR}/test/offer_tests/${TEST_OFFER_LOCAL_STARTER}
@@ -2023,6 +2043,29 @@ if(NOT ${TESTS_BAT})
         ${TEST_OFFER_SERVICE}
     )
 
+    # generate and copy json files into builddir for big SD message test
+    set(TEST_OFFER_BIG_SLAVE_CONFIG_FILE ${TEST_OFFER_BIG_NAME}_slave.json)
+    configure_file(
+        ${PROJECT_SOURCE_DIR}/test/offer_tests/conf/${TEST_OFFER_BIG_SLAVE_CONFIG_FILE}.in
+        ${PROJECT_SOURCE_DIR}/test/offer_tests/${TEST_OFFER_BIG_SLAVE_CONFIG_FILE}
+        @ONLY)
+    copy_to_builddir(
+        ${PROJECT_SOURCE_DIR}/test/offer_tests/${TEST_OFFER_BIG_SLAVE_CONFIG_FILE}
+        ${PROJECT_BINARY_DIR}/test/${TEST_OFFER_BIG_SLAVE_CONFIG_FILE}
+        ${TEST_OFFER_BIG_SERVICE}
+    )
+
+    set(TEST_OFFER_BIG_MASTER_CONFIG_FILE ${TEST_OFFER_BIG_NAME}_master.json)
+    configure_file(
+        ${PROJECT_SOURCE_DIR}/test/offer_tests/conf/${TEST_OFFER_BIG_MASTER_CONFIG_FILE}.in
+        ${PROJECT_SOURCE_DIR}/test/offer_tests/${TEST_OFFER_BIG_MASTER_CONFIG_FILE}
+        @ONLY)
+    copy_to_builddir(
+        ${PROJECT_SOURCE_DIR}/test/offer_tests/${TEST_OFFER_BIG_MASTER_CONFIG_FILE}
+        ${PROJECT_BINARY_DIR}/test/${TEST_OFFER_BIG_MASTER_CONFIG_FILE}
+        ${TEST_OFFER_BIG_SERVICE}
+    )
+
     # Copy starter scripts for external test to $BUILDDIR/test
     set(TEST_OFFER_EXTERNAL_MASTER_STARTER ${TEST_OFFER_NAME}_external_master_starter.sh)
     configure_file(
@@ -2038,6 +2081,23 @@ if(NOT ${TESTS_BAT})
         ${PROJECT_BINARY_DIR}/test/${TEST_OFFER_EXTERNAL_SLAVE_STARTER}
         ${TEST_OFFER_SERVICE}
     )
+
+    # Copy starter scripts for external test to $BUILDDIR/test
+    set(TEST_OFFER_BIG_MASTER_STARTER ${TEST_OFFER_BIG_NAME}_master_starter.sh)
+    configure_file(
+        ${PROJECT_SOURCE_DIR}/test/offer_tests/conf/${TEST_OFFER_BIG_MASTER_STARTER}.in
+        ${PROJECT_SOURCE_DIR}/test/offer_tests/${TEST_OFFER_BIG_MASTER_STARTER}
+        @ONLY)
+    copy_to_builddir(${PROJECT_SOURCE_DIR}/test/offer_tests/${TEST_OFFER_BIG_MASTER_STARTER}
+        ${PROJECT_BINARY_DIR}/test/${TEST_OFFER_BIG_MASTER_STARTER}
+        ${TEST_OFFER_BIG_SERVICE}
+    )
+    # Copy starter scripts for external test to $BUILDDIR/test
+    set(TEST_OFFER_BIG_EXTERNAL_SLAVE_STARTER ${TEST_OFFER_BIG_NAME}_slave_starter.sh)
+    copy_to_builddir(${PROJECT_SOURCE_DIR}/test/offer_tests/${TEST_OFFER_BIG_EXTERNAL_SLAVE_STARTER}
+        ${PROJECT_BINARY_DIR}/test/${TEST_OFFER_BIG_EXTERNAL_SLAVE_STARTER}
+        ${TEST_OFFER_BIG_SERVICE}
+    )
 endif()
 
 ##############################################################################
@@ -2160,6 +2220,8 @@ if(NOT ${TESTS_BAT})
     add_dependencies(build_tests ${TEST_OFFER_CLIENT})
     add_dependencies(build_tests ${TEST_OFFER_SERVICE_EXTERNAL})
     add_dependencies(build_tests ${TEST_OFFER_EXTERNAL_SD_MESSAGE_SENDER})
+    add_dependencies(build_tests ${TEST_OFFER_BIG_SERVICE})
+    add_dependencies(build_tests ${TEST_OFFER_BIG_CLIENT})
     add_dependencies(build_tests ${TEST_RESTART_ROUTING_SERVICE})
     add_dependencies(build_tests ${TEST_RESTART_ROUTING_CLIENT})
     if (${TEST_SECURITY})
@@ -2552,6 +2614,9 @@ if(NOT ${TESTS_BAT})
     add_test(NAME ${TEST_OFFER_NAME}_external
         COMMAND ${PROJECT_BINARY_DIR}/test/${TEST_OFFER_EXTERNAL_MASTER_STARTER})
     set_tests_properties(${TEST_OFFER_NAME}_local PROPERTIES TIMEOUT 360)
+    add_test(NAME ${TEST_OFFER_BIG_NAME}
+        COMMAND ${PROJECT_BINARY_DIR}/test/${TEST_OFFER_BIG_MASTER_STARTER})
+    set_tests_properties(${TEST_OFFER_BIG_NAME} PROPERTIES TIMEOUT 360)
     
     # offered services info tets
     add_test(NAME ${TEST_OFFERED_SERVICES_INFO_NAME}_local
diff --git a/test/offer_tests/conf/offer_test_big_sd_msg_master.json.in b/test/offer_tests/conf/offer_test_big_sd_msg_master.json.in
new file mode 100644
index 0000000..17158c1
--- /dev/null
+++ b/test/offer_tests/conf/offer_test_big_sd_msg_master.json.in
@@ -0,0 +1,31 @@
+{
+    "unicast":"@TEST_IP_MASTER@",
+    "logging":
+    {
+        "level":"warning",
+        "console":"true",
+        "file":
+        {
+            "enable":"false",
+            "path":"/tmp/vsomeip.log"
+        },
+        "dlt":"false"
+    },
+    "applications" :
+    [
+        {
+             "name" : "offer_test_big_sd_msg_client",
+             "id" : "0x6666"
+        }
+    ],
+    "routing":"vsomeipd",
+    "service-discovery":
+    {
+        "enable":"true",
+        "ttl" : "3",
+        "multicast":"224.0.11.1",
+        "port":"30490",
+        "protocol":"udp",
+        "cyclic_offer_delay" : "1000"
+    }
+}
+\ No newline at end of file
diff --git a/test/offer_tests/conf/offer_test_big_sd_msg_master_starter.sh.in b/test/offer_tests/conf/offer_test_big_sd_msg_master_starter.sh.in
new file mode 100755
index 0000000..2547673
--- /dev/null
+++ b/test/offer_tests/conf/offer_test_big_sd_msg_master_starter.sh.in
@@ -0,0 +1,82 @@
+#!/bin/bash
+# Copyright (C) 2015-2017 Bayerische Motoren Werke Aktiengesellschaft (BMW AG)
+# 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/.
+
+# Purpose: This script is needed to start the services with
+# one command. This is necessary as ctest - which is used to run the
+# tests - isn't able to start multiple binaries for one testcase. Therefore
+# the testcase simply executes this script. This script then runs the services
+# and checks that all exit successfully.
+
+FAIL=0
+
+export VSOMEIP_CONFIGURATION=offer_test_big_sd_msg_master.json
+# start daemon
+../daemon/./vsomeipd &
+PID_VSOMEIPD=$!
+
+./offer_test_big_sd_msg_client &
+CLIENT_PID=$!
+
+
+sleep 1
+
+if [ ! -z "$USE_LXC_TEST" ]; then
+    echo "Waiting for 5s"
+    sleep 5
+    echo "starting offer test on slave LXC offer_test_big_sd_msg_slave_starter.sh"
+    ssh -tt -i $SANDBOX_ROOT_DIR/commonapi_main/lxc-config/.ssh/mgc_lxc/rsa_key_file.pub -o StrictHostKeyChecking=no root@$LXC_TEST_SLAVE_IP "bash -ci \"set -m; cd \\\$SANDBOX_TARGET_DIR/vsomeip/test; ./offer_test_big_sd_msg_slave_starter.sh\"" &
+    echo "remote ssh pid: $!"
+elif [ ! -z "$USE_DOCKER" ]; then
+    docker run --name otems --cap-add NET_ADMIN $DOCKER_IMAGE sh -c "route add -net 224.0.0.0/4 dev eth0 && cd $DOCKER_TESTS && sleep 10; ./offer_test_big_sd_msg_slave_starter.sh" &
+else
+cat <<End-of-message
+*******************************************************************************
+*******************************************************************************
+** Please now run:
+** offer_test_big_sd_msg_slave_starter.sh
+** from an external host to successfully complete this test.
+**
+** You probably will need to adapt the 'unicast' settings in
+** offer_test_big_sd_msg_master.json and
+** offer_test_big_sd_msg_slave.json to your personal setup.
+*******************************************************************************
+*******************************************************************************
+End-of-message
+fi
+
+# Wait until all clients and services are finished
+for job in $CLIENT_PID
+do
+    # Fail gets incremented if a client exits with a non-zero exit code
+    echo "waiting for $job"
+    wait $job || FAIL=$(($FAIL+1))
+done
+
+# kill the services
+kill $PID_VSOMEIPD
+sleep 1
+
+if [ ! -z "$USE_DOCKER" ]; then
+    docker stop otems
+    docker rm otems
+fi
+
+# wait for slave to finish
+for job in $(jobs -p)
+do
+    # Fail gets incremented if either client or service exit
+    # with a non-zero exit code
+    echo "[Master] waiting for job $job"
+    wait $job || ((FAIL+=1))
+done
+
+# Check if everything went well
+if [ $FAIL -eq 0 ]
+then
+    exit 0
+else
+    exit 1
+fi
diff --git a/test/offer_tests/conf/offer_test_big_sd_msg_slave.json.in b/test/offer_tests/conf/offer_test_big_sd_msg_slave.json.in
new file mode 100644
index 0000000..cd5056a
--- /dev/null
+++ b/test/offer_tests/conf/offer_test_big_sd_msg_slave.json.in
@@ -0,0 +1,334 @@
+{
+    "unicast":"@TEST_IP_SLAVE@",
+    "logging":
+    {
+        "level":"warning",
+        "console":"true",
+        "file":
+        {
+            "enable":"false",
+            "path":"/tmp/vsomeip.log"
+        },
+        "dlt":"false"
+    },
+    "applications" :
+    [
+        {
+             "name" : "offer_test_big_sd_msg_service",
+             "id" : "0x7777"
+        }
+    ],
+    "services":
+    [
+        {"service":"0x1","instance":"0x1","unreliable":"30001","reliable":{"port":"30001","enable-magic-cookies":"false"}},
+        {"service":"0x2","instance":"0x1","unreliable":"30002","reliable":{"port":"30002","enable-magic-cookies":"false"}},
+        {"service":"0x3","instance":"0x1","unreliable":"30003","reliable":{"port":"30003","enable-magic-cookies":"false"}},
+        {"service":"0x4","instance":"0x1","unreliable":"30004","reliable":{"port":"30004","enable-magic-cookies":"false"}},
+        {"service":"0x5","instance":"0x1","unreliable":"30005","reliable":{"port":"30005","enable-magic-cookies":"false"}},
+        {"service":"0x6","instance":"0x1","unreliable":"30006","reliable":{"port":"30006","enable-magic-cookies":"false"}},
+        {"service":"0x7","instance":"0x1","unreliable":"30007","reliable":{"port":"60000","enable-magic-cookies":"false"}},
+        {"service":"0x8","instance":"0x1","unreliable":"30008","reliable":{"port":"30008","enable-magic-cookies":"false"}},
+        {"service":"0x9","instance":"0x1","unreliable":"60000","reliable":{"port":"30009","enable-magic-cookies":"false"}},
+        {"service":"0xA","instance":"0x1","unreliable":"30010","reliable":{"port":"30010","enable-magic-cookies":"false"}},
+        {"service":"0xB","instance":"0x1","unreliable":"30011","reliable":{"port":"30011","enable-magic-cookies":"false"}},
+        {"service":"0xC","instance":"0x1","unreliable":"30012","reliable":{"port":"30012","enable-magic-cookies":"false"}},
+        {"service":"0xD","instance":"0x1","unreliable":"30013","reliable":{"port":"30013","enable-magic-cookies":"false"}},
+        {"service":"0xE","instance":"0x1","unreliable":"30014","reliable":{"port":"60000","enable-magic-cookies":"false"}},
+        {"service":"0xF","instance":"0x1","unreliable":"30015","reliable":{"port":"30015","enable-magic-cookies":"false"}},
+        {"service":"0x10","instance":"0x1","unreliable":"30016","reliable":{"port":"30016","enable-magic-cookies":"false"}},
+        {"service":"0x11","instance":"0x1","unreliable":"30017","reliable":{"port":"30017","enable-magic-cookies":"false"}},
+        {"service":"0x12","instance":"0x1","unreliable":"60000","reliable":{"port":"30018","enable-magic-cookies":"false"}},
+        {"service":"0x13","instance":"0x1","unreliable":"30019","reliable":{"port":"30019","enable-magic-cookies":"false"}},
+        {"service":"0x14","instance":"0x1","unreliable":"30020","reliable":{"port":"30020","enable-magic-cookies":"false"}},
+        {"service":"0x15","instance":"0x1","unreliable":"30021","reliable":{"port":"60000","enable-magic-cookies":"false"}},
+        {"service":"0x16","instance":"0x1","unreliable":"30022","reliable":{"port":"30022","enable-magic-cookies":"false"}},
+        {"service":"0x17","instance":"0x1","unreliable":"30023","reliable":{"port":"30023","enable-magic-cookies":"false"}},
+        {"service":"0x18","instance":"0x1","unreliable":"30024","reliable":{"port":"30024","enable-magic-cookies":"false"}},
+        {"service":"0x19","instance":"0x1","unreliable":"30025","reliable":{"port":"30025","enable-magic-cookies":"false"}},
+        {"service":"0x1A","instance":"0x1","unreliable":"30026","reliable":{"port":"30026","enable-magic-cookies":"false"}},
+        {"service":"0x1B","instance":"0x1","unreliable":"60000","reliable":{"port":"30027","enable-magic-cookies":"false"}},
+        {"service":"0x1C","instance":"0x1","unreliable":"30028","reliable":{"port":"60000","enable-magic-cookies":"false"}},
+        {"service":"0x1D","instance":"0x1","unreliable":"30029","reliable":{"port":"30029","enable-magic-cookies":"false"}},
+        {"service":"0x1E","instance":"0x1","unreliable":"30030","reliable":{"port":"30030","enable-magic-cookies":"false"}},
+        {"service":"0x1F","instance":"0x1","unreliable":"30031","reliable":{"port":"30031","enable-magic-cookies":"false"}},
+        {"service":"0x20","instance":"0x1","unreliable":"30032","reliable":{"port":"30032","enable-magic-cookies":"false"}},
+        {"service":"0x21","instance":"0x1","unreliable":"30033","reliable":{"port":"30033","enable-magic-cookies":"false"}},
+        {"service":"0x22","instance":"0x1","unreliable":"30034","reliable":{"port":"30034","enable-magic-cookies":"false"}},
+        {"service":"0x23","instance":"0x1","unreliable":"30035","reliable":{"port":"60000","enable-magic-cookies":"false"}},
+        {"service":"0x24","instance":"0x1","unreliable":"60000","reliable":{"port":"30036","enable-magic-cookies":"false"}},
+        {"service":"0x25","instance":"0x1","unreliable":"30037","reliable":{"port":"30037","enable-magic-cookies":"false"}},
+        {"service":"0x26","instance":"0x1","unreliable":"30038","reliable":{"port":"30038","enable-magic-cookies":"false"}},
+        {"service":"0x27","instance":"0x1","unreliable":"30039","reliable":{"port":"30039","enable-magic-cookies":"false"}},
+        {"service":"0x28","instance":"0x1","unreliable":"30040","reliable":{"port":"30040","enable-magic-cookies":"false"}},
+        {"service":"0x29","instance":"0x1","unreliable":"30041","reliable":{"port":"30041","enable-magic-cookies":"false"}},
+        {"service":"0x2A","instance":"0x1","unreliable":"30042","reliable":{"port":"60000","enable-magic-cookies":"false"}},
+        {"service":"0x2B","instance":"0x1","unreliable":"30043","reliable":{"port":"30043","enable-magic-cookies":"false"}},
+        {"service":"0x2C","instance":"0x1","unreliable":"30044","reliable":{"port":"30044","enable-magic-cookies":"false"}},
+        {"service":"0x2D","instance":"0x1","unreliable":"60000","reliable":{"port":"30045","enable-magic-cookies":"false"}},
+        {"service":"0x2E","instance":"0x1","unreliable":"30046","reliable":{"port":"30046","enable-magic-cookies":"false"}},
+        {"service":"0x2F","instance":"0x1","unreliable":"30047","reliable":{"port":"30047","enable-magic-cookies":"false"}},
+        {"service":"0x30","instance":"0x1","unreliable":"30048","reliable":{"port":"30048","enable-magic-cookies":"false"}},
+        {"service":"0x31","instance":"0x1","unreliable":"30049","reliable":{"port":"60000","enable-magic-cookies":"false"}},
+        {"service":"0x32","instance":"0x1","unreliable":"30050","reliable":{"port":"30050","enable-magic-cookies":"false"}},
+        {"service":"0x33","instance":"0x1","unreliable":"30051","reliable":{"port":"30051","enable-magic-cookies":"false"}},
+        {"service":"0x34","instance":"0x1","unreliable":"30052","reliable":{"port":"30052","enable-magic-cookies":"false"}},
+        {"service":"0x35","instance":"0x1","unreliable":"30053","reliable":{"port":"30053","enable-magic-cookies":"false"}},
+        {"service":"0x36","instance":"0x1","unreliable":"60000","reliable":{"port":"30054","enable-magic-cookies":"false"}},
+        {"service":"0x37","instance":"0x1","unreliable":"30055","reliable":{"port":"30055","enable-magic-cookies":"false"}},
+        {"service":"0x38","instance":"0x1","unreliable":"30056","reliable":{"port":"60000","enable-magic-cookies":"false"}},
+        {"service":"0x39","instance":"0x1","unreliable":"30057","reliable":{"port":"30057","enable-magic-cookies":"false"}},
+        {"service":"0x3A","instance":"0x1","unreliable":"30058","reliable":{"port":"30058","enable-magic-cookies":"false"}},
+        {"service":"0x3B","instance":"0x1","unreliable":"30059","reliable":{"port":"30059","enable-magic-cookies":"false"}},
+        {"service":"0x3C","instance":"0x1","unreliable":"30060","reliable":{"port":"30060","enable-magic-cookies":"false"}},
+        {"service":"0x3D","instance":"0x1","unreliable":"30061","reliable":{"port":"30061","enable-magic-cookies":"false"}},
+        {"service":"0x3E","instance":"0x1","unreliable":"30062","reliable":{"port":"30062","enable-magic-cookies":"false"}},
+        {"service":"0x3F","instance":"0x1","unreliable":"60000","reliable":{"port":"60000","enable-magic-cookies":"false"}},
+        {"service":"0x40","instance":"0x1","unreliable":"30064","reliable":{"port":"30064","enable-magic-cookies":"false"}},
+        {"service":"0x41","instance":"0x1","unreliable":"30065","reliable":{"port":"30065","enable-magic-cookies":"false"}},
+        {"service":"0x42","instance":"0x1","unreliable":"30066","reliable":{"port":"30066","enable-magic-cookies":"false"}},
+        {"service":"0x43","instance":"0x1","unreliable":"30067","reliable":{"port":"30067","enable-magic-cookies":"false"}},
+        {"service":"0x44","instance":"0x1","unreliable":"30068","reliable":{"port":"30068","enable-magic-cookies":"false"}},
+        {"service":"0x45","instance":"0x1","unreliable":"30069","reliable":{"port":"30069","enable-magic-cookies":"false"}},
+        {"service":"0x46","instance":"0x1","unreliable":"30070","reliable":{"port":"60000","enable-magic-cookies":"false"}},
+        {"service":"0x47","instance":"0x1","unreliable":"30071","reliable":{"port":"30071","enable-magic-cookies":"false"}},
+        {"service":"0x48","instance":"0x1","unreliable":"60000","reliable":{"port":"30072","enable-magic-cookies":"false"}},
+        {"service":"0x49","instance":"0x1","unreliable":"30073","reliable":{"port":"30073","enable-magic-cookies":"false"}},
+        {"service":"0x4A","instance":"0x1","unreliable":"30074","reliable":{"port":"30074","enable-magic-cookies":"false"}},
+        {"service":"0x4B","instance":"0x1","unreliable":"30075","reliable":{"port":"30075","enable-magic-cookies":"false"}},
+        {"service":"0x4C","instance":"0x1","unreliable":"30076","reliable":{"port":"30076","enable-magic-cookies":"false"}},
+        {"service":"0x4D","instance":"0x1","unreliable":"30077","reliable":{"port":"60000","enable-magic-cookies":"false"}},
+        {"service":"0x4E","instance":"0x1","unreliable":"30078","reliable":{"port":"30078","enable-magic-cookies":"false"}},
+        {"service":"0x4F","instance":"0x1","unreliable":"30079","reliable":{"port":"30079","enable-magic-cookies":"false"}},
+        {"service":"0x50","instance":"0x1","unreliable":"30080","reliable":{"port":"30080","enable-magic-cookies":"false"}},
+        {"service":"0x51","instance":"0x1","unreliable":"60000","reliable":{"port":"30081","enable-magic-cookies":"false"}},
+        {"service":"0x52","instance":"0x1","unreliable":"30082","reliable":{"port":"30082","enable-magic-cookies":"false"}},
+        {"service":"0x53","instance":"0x1","unreliable":"30083","reliable":{"port":"30083","enable-magic-cookies":"false"}},
+        {"service":"0x54","instance":"0x1","unreliable":"30084","reliable":{"port":"60000","enable-magic-cookies":"false"}},
+        {"service":"0x55","instance":"0x1","unreliable":"30085","reliable":{"port":"30085","enable-magic-cookies":"false"}},
+        {"service":"0x56","instance":"0x1","unreliable":"30086","reliable":{"port":"30086","enable-magic-cookies":"false"}},
+        {"service":"0x57","instance":"0x1","unreliable":"30087","reliable":{"port":"30087","enable-magic-cookies":"false"}},
+        {"service":"0x58","instance":"0x1","unreliable":"30088","reliable":{"port":"30088","enable-magic-cookies":"false"}},
+        {"service":"0x59","instance":"0x1","unreliable":"30089","reliable":{"port":"30089","enable-magic-cookies":"false"}},
+        {"service":"0x5A","instance":"0x1","unreliable":"60000","reliable":{"port":"30090","enable-magic-cookies":"false"}},
+        {"service":"0x5B","instance":"0x1","unreliable":"30091","reliable":{"port":"60000","enable-magic-cookies":"false"}},
+        {"service":"0x5C","instance":"0x1","unreliable":"30092","reliable":{"port":"30092","enable-magic-cookies":"false"}},
+        {"service":"0x5D","instance":"0x1","unreliable":"30093","reliable":{"port":"30093","enable-magic-cookies":"false"}},
+        {"service":"0x5E","instance":"0x1","unreliable":"30094","reliable":{"port":"30094","enable-magic-cookies":"false"}},
+        {"service":"0x5F","instance":"0x1","unreliable":"30095","reliable":{"port":"30095","enable-magic-cookies":"false"}},
+        {"service":"0x60","instance":"0x1","unreliable":"30096","reliable":{"port":"30096","enable-magic-cookies":"false"}},
+        {"service":"0x61","instance":"0x1","unreliable":"30097","reliable":{"port":"30097","enable-magic-cookies":"false"}},
+        {"service":"0x62","instance":"0x1","unreliable":"30098","reliable":{"port":"60000","enable-magic-cookies":"false"}},
+        {"service":"0x63","instance":"0x1","unreliable":"60000","reliable":{"port":"30099","enable-magic-cookies":"false"}},
+        {"service":"0x64","instance":"0x1","unreliable":"30100","reliable":{"port":"30100","enable-magic-cookies":"false"}},
+        {"service":"0x65","instance":"0x1","unreliable":"30101","reliable":{"port":"30101","enable-magic-cookies":"false"}},
+        {"service":"0x66","instance":"0x1","unreliable":"30102","reliable":{"port":"30102","enable-magic-cookies":"false"}},
+        {"service":"0x67","instance":"0x1","unreliable":"30103","reliable":{"port":"30103","enable-magic-cookies":"false"}},
+        {"service":"0x68","instance":"0x1","unreliable":"30104","reliable":{"port":"30104","enable-magic-cookies":"false"}},
+        {"service":"0x69","instance":"0x1","unreliable":"30105","reliable":{"port":"60000","enable-magic-cookies":"false"}},
+        {"service":"0x6A","instance":"0x1","unreliable":"30106","reliable":{"port":"30106","enable-magic-cookies":"false"}},
+        {"service":"0x6B","instance":"0x1","unreliable":"30107","reliable":{"port":"30107","enable-magic-cookies":"false"}},
+        {"service":"0x6C","instance":"0x1","unreliable":"60000","reliable":{"port":"30108","enable-magic-cookies":"false"}},
+        {"service":"0x6D","instance":"0x1","unreliable":"30109","reliable":{"port":"30109","enable-magic-cookies":"false"}},
+        {"service":"0x6E","instance":"0x1","unreliable":"30110","reliable":{"port":"30110","enable-magic-cookies":"false"}},
+        {"service":"0x6F","instance":"0x1","unreliable":"30111","reliable":{"port":"30111","enable-magic-cookies":"false"}},
+        {"service":"0x70","instance":"0x1","unreliable":"30112","reliable":{"port":"60000","enable-magic-cookies":"false"}},
+        {"service":"0x71","instance":"0x1","unreliable":"30113","reliable":{"port":"30113","enable-magic-cookies":"false"}},
+        {"service":"0x72","instance":"0x1","unreliable":"30114","reliable":{"port":"30114","enable-magic-cookies":"false"}},
+        {"service":"0x73","instance":"0x1","unreliable":"30115","reliable":{"port":"30115","enable-magic-cookies":"false"}},
+        {"service":"0x74","instance":"0x1","unreliable":"30116","reliable":{"port":"30116","enable-magic-cookies":"false"}},
+        {"service":"0x75","instance":"0x1","unreliable":"60000","reliable":{"port":"30117","enable-magic-cookies":"false"}},
+        {"service":"0x76","instance":"0x1","unreliable":"30118","reliable":{"port":"30118","enable-magic-cookies":"false"}},
+        {"service":"0x77","instance":"0x1","unreliable":"30119","reliable":{"port":"60000","enable-magic-cookies":"false"}},
+        {"service":"0x78","instance":"0x1","unreliable":"30120","reliable":{"port":"30120","enable-magic-cookies":"false"}},
+        {"service":"0x79","instance":"0x1","unreliable":"30121","reliable":{"port":"30121","enable-magic-cookies":"false"}},
+        {"service":"0x7A","instance":"0x1","unreliable":"30122","reliable":{"port":"30122","enable-magic-cookies":"false"}},
+        {"service":"0x7B","instance":"0x1","unreliable":"30123","reliable":{"port":"30123","enable-magic-cookies":"false"}},
+        {"service":"0x7C","instance":"0x1","unreliable":"30124","reliable":{"port":"30124","enable-magic-cookies":"false"}},
+        {"service":"0x7D","instance":"0x1","unreliable":"30125","reliable":{"port":"30125","enable-magic-cookies":"false"}},
+        {"service":"0x7E","instance":"0x1","unreliable":"60000","reliable":{"port":"60000","enable-magic-cookies":"false"}},
+        {"service":"0x7F","instance":"0x1","unreliable":"30127","reliable":{"port":"30127","enable-magic-cookies":"false"}},
+        {"service":"0x80","instance":"0x1","unreliable":"30128","reliable":{"port":"30128","enable-magic-cookies":"false"}},
+        {"service":"0x81","instance":"0x1","unreliable":"30129","reliable":{"port":"30129","enable-magic-cookies":"false"}},
+        {"service":"0x82","instance":"0x1","unreliable":"30130","reliable":{"port":"30130","enable-magic-cookies":"false"}},
+        {"service":"0x83","instance":"0x1","unreliable":"30131","reliable":{"port":"30131","enable-magic-cookies":"false"}},
+        {"service":"0x84","instance":"0x1","unreliable":"30132","reliable":{"port":"30132","enable-magic-cookies":"false"}},
+        {"service":"0x85","instance":"0x1","unreliable":"30133","reliable":{"port":"60000","enable-magic-cookies":"false"}},
+        {"service":"0x86","instance":"0x1","unreliable":"30134","reliable":{"port":"30134","enable-magic-cookies":"false"}},
+        {"service":"0x87","instance":"0x1","unreliable":"60000","reliable":{"port":"30135","enable-magic-cookies":"false"}},
+        {"service":"0x88","instance":"0x1","unreliable":"30136","reliable":{"port":"30136","enable-magic-cookies":"false"}},
+        {"service":"0x89","instance":"0x1","unreliable":"30137","reliable":{"port":"30137","enable-magic-cookies":"false"}},
+        {"service":"0x8A","instance":"0x1","unreliable":"30138","reliable":{"port":"30138","enable-magic-cookies":"false"}},
+        {"service":"0x8B","instance":"0x1","unreliable":"30139","reliable":{"port":"30139","enable-magic-cookies":"false"}},
+        {"service":"0x8C","instance":"0x1","unreliable":"30140","reliable":{"port":"60000","enable-magic-cookies":"false"}},
+        {"service":"0x8D","instance":"0x1","unreliable":"30141","reliable":{"port":"30141","enable-magic-cookies":"false"}},
+        {"service":"0x8E","instance":"0x1","unreliable":"30142","reliable":{"port":"30142","enable-magic-cookies":"false"}},
+        {"service":"0x8F","instance":"0x1","unreliable":"30143","reliable":{"port":"30143","enable-magic-cookies":"false"}},
+        {"service":"0x90","instance":"0x1","unreliable":"60000","reliable":{"port":"30144","enable-magic-cookies":"false"}},
+        {"service":"0x91","instance":"0x1","unreliable":"30145","reliable":{"port":"30145","enable-magic-cookies":"false"}},
+        {"service":"0x92","instance":"0x1","unreliable":"30146","reliable":{"port":"30146","enable-magic-cookies":"false"}},
+        {"service":"0x93","instance":"0x1","unreliable":"30147","reliable":{"port":"60000","enable-magic-cookies":"false"}},
+        {"service":"0x94","instance":"0x1","unreliable":"30148","reliable":{"port":"30148","enable-magic-cookies":"false"}},
+        {"service":"0x95","instance":"0x1","unreliable":"30149","reliable":{"port":"30149","enable-magic-cookies":"false"}},
+        {"service":"0x96","instance":"0x1","unreliable":"30150","reliable":{"port":"30150","enable-magic-cookies":"false"}},
+        {"service":"0x97","instance":"0x1","unreliable":"30151","reliable":{"port":"30151","enable-magic-cookies":"false"}},
+        {"service":"0x98","instance":"0x1","unreliable":"30152","reliable":{"port":"30152","enable-magic-cookies":"false"}},
+        {"service":"0x99","instance":"0x1","unreliable":"60000","reliable":{"port":"30153","enable-magic-cookies":"false"}},
+        {"service":"0x9A","instance":"0x1","unreliable":"30154","reliable":{"port":"60000","enable-magic-cookies":"false"}},
+        {"service":"0x9B","instance":"0x1","unreliable":"30155","reliable":{"port":"30155","enable-magic-cookies":"false"}},
+        {"service":"0x9C","instance":"0x1","unreliable":"30156","reliable":{"port":"30156","enable-magic-cookies":"false"}},
+        {"service":"0x9D","instance":"0x1","unreliable":"30157","reliable":{"port":"30157","enable-magic-cookies":"false"}},
+        {"service":"0x9E","instance":"0x1","unreliable":"30158","reliable":{"port":"30158","enable-magic-cookies":"false"}},
+        {"service":"0x9F","instance":"0x1","unreliable":"30159","reliable":{"port":"30159","enable-magic-cookies":"false"}},
+        {"service":"0xA0","instance":"0x1","unreliable":"30160","reliable":{"port":"30160","enable-magic-cookies":"false"}},
+        {"service":"0xA1","instance":"0x1","unreliable":"30161","reliable":{"port":"60000","enable-magic-cookies":"false"}},
+        {"service":"0xA2","instance":"0x1","unreliable":"60000","reliable":{"port":"30162","enable-magic-cookies":"false"}},
+        {"service":"0xA3","instance":"0x1","unreliable":"30163","reliable":{"port":"30163","enable-magic-cookies":"false"}},
+        {"service":"0xA4","instance":"0x1","unreliable":"30164","reliable":{"port":"30164","enable-magic-cookies":"false"}},
+        {"service":"0xA5","instance":"0x1","unreliable":"30165","reliable":{"port":"30165","enable-magic-cookies":"false"}},
+        {"service":"0xA6","instance":"0x1","unreliable":"30166","reliable":{"port":"30166","enable-magic-cookies":"false"}},
+        {"service":"0xA7","instance":"0x1","unreliable":"30167","reliable":{"port":"30167","enable-magic-cookies":"false"}},
+        {"service":"0xA8","instance":"0x1","unreliable":"30168","reliable":{"port":"60000","enable-magic-cookies":"false"}},
+        {"service":"0xA9","instance":"0x1","unreliable":"30169","reliable":{"port":"30169","enable-magic-cookies":"false"}},
+        {"service":"0xAA","instance":"0x1","unreliable":"30170","reliable":{"port":"30170","enable-magic-cookies":"false"}},
+        {"service":"0xAB","instance":"0x1","unreliable":"60000","reliable":{"port":"30171","enable-magic-cookies":"false"}},
+        {"service":"0xAC","instance":"0x1","unreliable":"30172","reliable":{"port":"30172","enable-magic-cookies":"false"}},
+        {"service":"0xAD","instance":"0x1","unreliable":"30173","reliable":{"port":"30173","enable-magic-cookies":"false"}},
+        {"service":"0xAE","instance":"0x1","unreliable":"30174","reliable":{"port":"30174","enable-magic-cookies":"false"}},
+        {"service":"0xAF","instance":"0x1","unreliable":"30175","reliable":{"port":"60000","enable-magic-cookies":"false"}},
+        {"service":"0xB0","instance":"0x1","unreliable":"30176","reliable":{"port":"30176","enable-magic-cookies":"false"}},
+        {"service":"0xB1","instance":"0x1","unreliable":"30177","reliable":{"port":"30177","enable-magic-cookies":"false"}},
+        {"service":"0xB2","instance":"0x1","unreliable":"30178","reliable":{"port":"30178","enable-magic-cookies":"false"}},
+        {"service":"0xB3","instance":"0x1","unreliable":"30179","reliable":{"port":"30179","enable-magic-cookies":"false"}},
+        {"service":"0xB4","instance":"0x1","unreliable":"60000","reliable":{"port":"30180","enable-magic-cookies":"false"}},
+        {"service":"0xB5","instance":"0x1","unreliable":"30181","reliable":{"port":"30181","enable-magic-cookies":"false"}},
+        {"service":"0xB6","instance":"0x1","unreliable":"30182","reliable":{"port":"60000","enable-magic-cookies":"false"}},
+        {"service":"0xB7","instance":"0x1","unreliable":"30183","reliable":{"port":"30183","enable-magic-cookies":"false"}},
+        {"service":"0xB8","instance":"0x1","unreliable":"30184","reliable":{"port":"30184","enable-magic-cookies":"false"}},
+        {"service":"0xB9","instance":"0x1","unreliable":"30185","reliable":{"port":"30185","enable-magic-cookies":"false"}},
+        {"service":"0xBA","instance":"0x1","unreliable":"30186","reliable":{"port":"30186","enable-magic-cookies":"false"}},
+        {"service":"0xBB","instance":"0x1","unreliable":"30187","reliable":{"port":"30187","enable-magic-cookies":"false"}},
+        {"service":"0xBC","instance":"0x1","unreliable":"30188","reliable":{"port":"30188","enable-magic-cookies":"false"}},
+        {"service":"0xBD","instance":"0x1","unreliable":"60000","reliable":{"port":"60000","enable-magic-cookies":"false"}},
+        {"service":"0xBE","instance":"0x1","unreliable":"30190","reliable":{"port":"30190","enable-magic-cookies":"false"}},
+        {"service":"0xBF","instance":"0x1","unreliable":"30191","reliable":{"port":"30191","enable-magic-cookies":"false"}},
+        {"service":"0xC0","instance":"0x1","unreliable":"30192","reliable":{"port":"30192","enable-magic-cookies":"false"}},
+        {"service":"0xC1","instance":"0x1","unreliable":"30193","reliable":{"port":"30193","enable-magic-cookies":"false"}},
+        {"service":"0xC2","instance":"0x1","unreliable":"30194","reliable":{"port":"30194","enable-magic-cookies":"false"}},
+        {"service":"0xC3","instance":"0x1","unreliable":"30195","reliable":{"port":"30195","enable-magic-cookies":"false"}},
+        {"service":"0xC4","instance":"0x1","unreliable":"30196","reliable":{"port":"60000","enable-magic-cookies":"false"}},
+        {"service":"0xC5","instance":"0x1","unreliable":"30197","reliable":{"port":"30197","enable-magic-cookies":"false"}},
+        {"service":"0xC6","instance":"0x1","unreliable":"60000","reliable":{"port":"30198","enable-magic-cookies":"false"}},
+        {"service":"0xC7","instance":"0x1","unreliable":"30199","reliable":{"port":"30199","enable-magic-cookies":"false"}},
+        {"service":"0xC8","instance":"0x1","unreliable":"30200","reliable":{"port":"30200","enable-magic-cookies":"false"}},
+        {"service":"0xC9","instance":"0x1","unreliable":"30201","reliable":{"port":"30201","enable-magic-cookies":"false"}},
+        {"service":"0xCA","instance":"0x1","unreliable":"30202","reliable":{"port":"30202","enable-magic-cookies":"false"}},
+        {"service":"0xCB","instance":"0x1","unreliable":"30203","reliable":{"port":"60000","enable-magic-cookies":"false"}},
+        {"service":"0xCC","instance":"0x1","unreliable":"30204","reliable":{"port":"30204","enable-magic-cookies":"false"}},
+        {"service":"0xCD","instance":"0x1","unreliable":"30205","reliable":{"port":"30205","enable-magic-cookies":"false"}},
+        {"service":"0xCE","instance":"0x1","unreliable":"30206","reliable":{"port":"30206","enable-magic-cookies":"false"}},
+        {"service":"0xCF","instance":"0x1","unreliable":"60000","reliable":{"port":"30207","enable-magic-cookies":"false"}},
+        {"service":"0xD0","instance":"0x1","unreliable":"30208","reliable":{"port":"30208","enable-magic-cookies":"false"}},
+        {"service":"0xD1","instance":"0x1","unreliable":"30209","reliable":{"port":"30209","enable-magic-cookies":"false"}},
+        {"service":"0xD2","instance":"0x1","unreliable":"30210","reliable":{"port":"60000","enable-magic-cookies":"false"}},
+        {"service":"0xD3","instance":"0x1","unreliable":"30211","reliable":{"port":"30211","enable-magic-cookies":"false"}},
+        {"service":"0xD4","instance":"0x1","unreliable":"30212","reliable":{"port":"30212","enable-magic-cookies":"false"}},
+        {"service":"0xD5","instance":"0x1","unreliable":"30213","reliable":{"port":"30213","enable-magic-cookies":"false"}},
+        {"service":"0xD6","instance":"0x1","unreliable":"30214","reliable":{"port":"30214","enable-magic-cookies":"false"}},
+        {"service":"0xD7","instance":"0x1","unreliable":"30215","reliable":{"port":"30215","enable-magic-cookies":"false"}},
+        {"service":"0xD8","instance":"0x1","unreliable":"60000","reliable":{"port":"30216","enable-magic-cookies":"false"}},
+        {"service":"0xD9","instance":"0x1","unreliable":"30217","reliable":{"port":"60000","enable-magic-cookies":"false"}},
+        {"service":"0xDA","instance":"0x1","unreliable":"30218","reliable":{"port":"30218","enable-magic-cookies":"false"}},
+        {"service":"0xDB","instance":"0x1","unreliable":"30219","reliable":{"port":"30219","enable-magic-cookies":"false"}},
+        {"service":"0xDC","instance":"0x1","unreliable":"30220","reliable":{"port":"30220","enable-magic-cookies":"false"}},
+        {"service":"0xDD","instance":"0x1","unreliable":"30221","reliable":{"port":"30221","enable-magic-cookies":"false"}},
+        {"service":"0xDE","instance":"0x1","unreliable":"30222","reliable":{"port":"30222","enable-magic-cookies":"false"}},
+        {"service":"0xDF","instance":"0x1","unreliable":"30223","reliable":{"port":"30223","enable-magic-cookies":"false"}},
+        {"service":"0xE0","instance":"0x1","unreliable":"30224","reliable":{"port":"60000","enable-magic-cookies":"false"}},
+        {"service":"0xE1","instance":"0x1","unreliable":"60000","reliable":{"port":"30225","enable-magic-cookies":"false"}},
+        {"service":"0xE2","instance":"0x1","unreliable":"30226","reliable":{"port":"30226","enable-magic-cookies":"false"}},
+        {"service":"0xE3","instance":"0x1","unreliable":"30227","reliable":{"port":"30227","enable-magic-cookies":"false"}},
+        {"service":"0xE4","instance":"0x1","unreliable":"30228","reliable":{"port":"30228","enable-magic-cookies":"false"}},
+        {"service":"0xE5","instance":"0x1","unreliable":"30229","reliable":{"port":"30229","enable-magic-cookies":"false"}},
+        {"service":"0xE6","instance":"0x1","unreliable":"30230","reliable":{"port":"30230","enable-magic-cookies":"false"}},
+        {"service":"0xE7","instance":"0x1","unreliable":"30231","reliable":{"port":"60000","enable-magic-cookies":"false"}},
+        {"service":"0xE8","instance":"0x1","unreliable":"30232","reliable":{"port":"30232","enable-magic-cookies":"false"}},
+        {"service":"0xE9","instance":"0x1","unreliable":"30233","reliable":{"port":"30233","enable-magic-cookies":"false"}},
+        {"service":"0xEA","instance":"0x1","unreliable":"60000","reliable":{"port":"30234","enable-magic-cookies":"false"}},
+        {"service":"0xEB","instance":"0x1","unreliable":"30235","reliable":{"port":"30235","enable-magic-cookies":"false"}},
+        {"service":"0xEC","instance":"0x1","unreliable":"30236","reliable":{"port":"30236","enable-magic-cookies":"false"}},
+        {"service":"0xED","instance":"0x1","unreliable":"30237","reliable":{"port":"30237","enable-magic-cookies":"false"}},
+        {"service":"0xEE","instance":"0x1","unreliable":"30238","reliable":{"port":"60000","enable-magic-cookies":"false"}},
+        {"service":"0xEF","instance":"0x1","unreliable":"30239","reliable":{"port":"30239","enable-magic-cookies":"false"}},
+        {"service":"0xF0","instance":"0x1","unreliable":"30240","reliable":{"port":"30240","enable-magic-cookies":"false"}},
+        {"service":"0xF1","instance":"0x1","unreliable":"30241","reliable":{"port":"30241","enable-magic-cookies":"false"}},
+        {"service":"0xF2","instance":"0x1","unreliable":"30242","reliable":{"port":"30242","enable-magic-cookies":"false"}},
+        {"service":"0xF3","instance":"0x1","unreliable":"60000","reliable":{"port":"30243","enable-magic-cookies":"false"}},
+        {"service":"0xF4","instance":"0x1","unreliable":"30244","reliable":{"port":"30244","enable-magic-cookies":"false"}},
+        {"service":"0xF5","instance":"0x1","unreliable":"30245","reliable":{"port":"60000","enable-magic-cookies":"false"}},
+        {"service":"0xF6","instance":"0x1","unreliable":"30246","reliable":{"port":"30246","enable-magic-cookies":"false"}},
+        {"service":"0xF7","instance":"0x1","unreliable":"30247","reliable":{"port":"30247","enable-magic-cookies":"false"}},
+        {"service":"0xF8","instance":"0x1","unreliable":"30248","reliable":{"port":"30248","enable-magic-cookies":"false"}},
+        {"service":"0xF9","instance":"0x1","unreliable":"30249","reliable":{"port":"30249","enable-magic-cookies":"false"}},
+        {"service":"0xFA","instance":"0x1","unreliable":"30250","reliable":{"port":"30250","enable-magic-cookies":"false"}},
+        {"service":"0xFB","instance":"0x1","unreliable":"30251","reliable":{"port":"30251","enable-magic-cookies":"false"}},
+        {"service":"0xFC","instance":"0x1","unreliable":"60000","reliable":{"port":"60000","enable-magic-cookies":"false"}},
+        {"service":"0xFD","instance":"0x1","unreliable":"30253","reliable":{"port":"30253","enable-magic-cookies":"false"}},
+        {"service":"0xFE","instance":"0x1","unreliable":"30254","reliable":{"port":"30254","enable-magic-cookies":"false"}},
+        {"service":"0xFF","instance":"0x1","unreliable":"30255","reliable":{"port":"30255","enable-magic-cookies":"false"}},
+        {"service":"0x100","instance":"0x1","unreliable":"30256","reliable":{"port":"30256","enable-magic-cookies":"false"}},
+        {"service":"0x101","instance":"0x1","unreliable":"30257","reliable":{"port":"30257","enable-magic-cookies":"false"}},
+        {"service":"0x102","instance":"0x1","unreliable":"30258","reliable":{"port":"30258","enable-magic-cookies":"false"}},
+        {"service":"0x103","instance":"0x1","unreliable":"30259","reliable":{"port":"60000","enable-magic-cookies":"false"}},
+        {"service":"0x104","instance":"0x1","unreliable":"30260","reliable":{"port":"30260","enable-magic-cookies":"false"}},
+        {"service":"0x105","instance":"0x1","unreliable":"60000","reliable":{"port":"30261","enable-magic-cookies":"false"}},
+        {"service":"0x106","instance":"0x1","unreliable":"30262","reliable":{"port":"30262","enable-magic-cookies":"false"}},
+        {"service":"0x107","instance":"0x1","unreliable":"30263","reliable":{"port":"30263","enable-magic-cookies":"false"}},
+        {"service":"0x108","instance":"0x1","unreliable":"30264","reliable":{"port":"30264","enable-magic-cookies":"false"}},
+        {"service":"0x109","instance":"0x1","unreliable":"30265","reliable":{"port":"30265","enable-magic-cookies":"false"}},
+        {"service":"0x10A","instance":"0x1","unreliable":"30266","reliable":{"port":"60000","enable-magic-cookies":"false"}},
+        {"service":"0x10B","instance":"0x1","unreliable":"30267","reliable":{"port":"30267","enable-magic-cookies":"false"}},
+        {"service":"0x10C","instance":"0x1","unreliable":"30268","reliable":{"port":"30268","enable-magic-cookies":"false"}},
+        {"service":"0x10D","instance":"0x1","unreliable":"30269","reliable":{"port":"30269","enable-magic-cookies":"false"}},
+        {"service":"0x10E","instance":"0x1","unreliable":"60000","reliable":{"port":"30270","enable-magic-cookies":"false"}},
+        {"service":"0x10F","instance":"0x1","unreliable":"30271","reliable":{"port":"30271","enable-magic-cookies":"false"}},
+        {"service":"0x110","instance":"0x1","unreliable":"30272","reliable":{"port":"30272","enable-magic-cookies":"false"}},
+        {"service":"0x111","instance":"0x1","unreliable":"30273","reliable":{"port":"60000","enable-magic-cookies":"false"}},
+        {"service":"0x112","instance":"0x1","unreliable":"30274","reliable":{"port":"30274","enable-magic-cookies":"false"}},
+        {"service":"0x113","instance":"0x1","unreliable":"30275","reliable":{"port":"30275","enable-magic-cookies":"false"}},
+        {"service":"0x114","instance":"0x1","unreliable":"30276","reliable":{"port":"30276","enable-magic-cookies":"false"}},
+        {"service":"0x115","instance":"0x1","unreliable":"30277","reliable":{"port":"30277","enable-magic-cookies":"false"}},
+        {"service":"0x116","instance":"0x1","unreliable":"30278","reliable":{"port":"30278","enable-magic-cookies":"false"}},
+        {"service":"0x117","instance":"0x1","unreliable":"60000","reliable":{"port":"30279","enable-magic-cookies":"false"}},
+        {"service":"0x118","instance":"0x1","unreliable":"30280","reliable":{"port":"60000","enable-magic-cookies":"false"}},
+        {"service":"0x119","instance":"0x1","unreliable":"30281","reliable":{"port":"30281","enable-magic-cookies":"false"}},
+        {"service":"0x11A","instance":"0x1","unreliable":"30282","reliable":{"port":"30282","enable-magic-cookies":"false"}},
+        {"service":"0x11B","instance":"0x1","unreliable":"30283","reliable":{"port":"30283","enable-magic-cookies":"false"}},
+        {"service":"0x11C","instance":"0x1","unreliable":"30284","reliable":{"port":"30284","enable-magic-cookies":"false"}},
+        {"service":"0x11D","instance":"0x1","unreliable":"30285","reliable":{"port":"30285","enable-magic-cookies":"false"}},
+        {"service":"0x11E","instance":"0x1","unreliable":"30286","reliable":{"port":"30286","enable-magic-cookies":"false"}},
+        {"service":"0x11F","instance":"0x1","unreliable":"30287","reliable":{"port":"60000","enable-magic-cookies":"false"}},
+        {"service":"0x120","instance":"0x1","unreliable":"60000","reliable":{"port":"30288","enable-magic-cookies":"false"}},
+        {"service":"0x121","instance":"0x1","unreliable":"30289","reliable":{"port":"30289","enable-magic-cookies":"false"}},
+        {"service":"0x122","instance":"0x1","unreliable":"30290","reliable":{"port":"30290","enable-magic-cookies":"false"}},
+        {"service":"0x123","instance":"0x1","unreliable":"30291","reliable":{"port":"30291","enable-magic-cookies":"false"}},
+        {"service":"0x124","instance":"0x1","unreliable":"30292","reliable":{"port":"30292","enable-magic-cookies":"false"}},
+        {"service":"0x125","instance":"0x1","unreliable":"30293","reliable":{"port":"30293","enable-magic-cookies":"false"}},
+        {"service":"0x126","instance":"0x1","unreliable":"30294","reliable":{"port":"60000","enable-magic-cookies":"false"}},
+        {"service":"0x127","instance":"0x1","unreliable":"30295","reliable":{"port":"30295","enable-magic-cookies":"false"}},
+        {"service":"0x128","instance":"0x1","unreliable":"30296","reliable":{"port":"30296","enable-magic-cookies":"false"}},
+        {"service":"0x129","instance":"0x1","unreliable":"60000","reliable":{"port":"30297","enable-magic-cookies":"false"}},
+        {"service":"0x12A","instance":"0x1","unreliable":"30298","reliable":{"port":"30298","enable-magic-cookies":"false"}},
+        {"service":"0x12B","instance":"0x1","unreliable":"30299","reliable":{"port":"30299","enable-magic-cookies":"false"}},
+        {"service":"0x12C","instance":"0x1","unreliable":"30300","reliable":{"port":"30300","enable-magic-cookies":"false"}}
+    ],
+    "routing":"vsomeipd",
+    "service-discovery":
+    {
+        "enable":"true",
+        "ttl" : "3",
+        "multicast":"224.0.11.1",
+        "cyclic_offer_delay" : "1000",
+        "port":"30490",
+        "protocol":"udp"
+    }
+}
+\ No newline at end of file
diff --git a/test/offer_tests/offer_test_big_sd_msg_client.cpp b/test/offer_tests/offer_test_big_sd_msg_client.cpp
new file mode 100644
index 0000000..cf00de7
--- /dev/null
+++ b/test/offer_tests/offer_test_big_sd_msg_client.cpp
@@ -0,0 +1,235 @@
+// Copyright (C) 2014-2017 Bayerische Motoren Werke Aktiengesellschaft (BMW AG)
+// 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/.
+
+#include <chrono>
+#include <condition_variable>
+#include <iomanip>
+#include <iostream>
+#include <sstream>
+#include <thread>
+#include <map>
+#include <algorithm>
+#include <atomic>
+
+#include <gtest/gtest.h>
+
+#include <vsomeip/vsomeip.hpp>
+#include "../../implementation/logging/include/logger.hpp"
+#include "../../implementation/configuration/include/internal.hpp"
+
+#include "offer_test_globals.hpp"
+
+class offer_test_big_sd_msg_client {
+public:
+    offer_test_big_sd_msg_client(struct offer_test::service_info _service_info) :
+            service_info_(_service_info),
+            app_(vsomeip::runtime::get()->create_application("offer_test_big_sd_msg_client")),
+            service_available_(false),
+            wait_until_registered_(true),
+            wait_until_service_available_(true),
+            wait_until_subscribed_(true),
+            wait_for_stop_(true),
+            stop_thread_(std::bind(&offer_test_big_sd_msg_client::wait_for_stop, this)),
+            send_thread_(std::bind(&offer_test_big_sd_msg_client::send, this)) {
+        if (!app_->init()) {
+            ADD_FAILURE() << "Couldn't initialize application";
+            return;
+        }
+        app_->register_state_handler(
+                std::bind(&offer_test_big_sd_msg_client::on_state, this,
+                        std::placeholders::_1));
+
+        app_->register_message_handler(vsomeip::ANY_SERVICE,
+                vsomeip::ANY_INSTANCE, vsomeip::ANY_METHOD,
+                std::bind(&offer_test_big_sd_msg_client::on_message, this,
+                        std::placeholders::_1));
+
+        // register availability for all other services and request their event.
+        app_->register_availability_handler(vsomeip::ANY_SERVICE,
+                vsomeip::ANY_INSTANCE,
+                std::bind(&offer_test_big_sd_msg_client::on_availability, this,
+                        std::placeholders::_1, std::placeholders::_2,
+                        std::placeholders::_3), 0x1, 0x1);
+        std::set<vsomeip::eventgroup_t> its_eventgroups;
+        its_eventgroups.insert(offer_test::big_msg_eventgroup_id);
+        for (std::uint16_t s = 1; s <= offer_test::big_msg_number_services; s++) {
+            app_->request_service(s,0x1,0x1,0x1,false);
+            app_->request_event(s,0x1, offer_test::big_msg_event_id,
+                    its_eventgroups, false);
+            app_->subscribe(s, 0x1,offer_test::big_msg_eventgroup_id, 0x1,
+                    vsomeip::subscription_type_e::SU_RELIABLE_AND_UNRELIABLE,
+                    offer_test::big_msg_event_id);
+            services_available_subribed_[s] = std::make_pair(false,false);
+            app_->register_subscription_status_handler(s,0x1,
+                    offer_test::big_msg_eventgroup_id,
+                    offer_test::big_msg_event_id,
+                    std::bind(&offer_test_big_sd_msg_client::subscription_status_changed, this,
+                              std::placeholders::_1, std::placeholders::_2,
+                              std::placeholders::_3, std::placeholders::_4, std::placeholders::_5));
+        }
+        app_->start();
+    }
+
+    ~offer_test_big_sd_msg_client() {
+        send_thread_.join();
+        stop_thread_.join();
+    }
+
+    void on_state(vsomeip::state_type_e _state) {
+        VSOMEIP_WARNING << "Application " << app_->get_name() << " is "
+        << (_state == vsomeip::state_type_e::ST_REGISTERED ?
+                "registered." : "deregistered.");
+
+        if (_state == vsomeip::state_type_e::ST_REGISTERED) {
+            std::lock_guard<std::mutex> its_lock(mutex_);
+            wait_until_registered_ = false;
+            condition_.notify_one();
+        }
+    }
+
+    void on_availability(vsomeip::service_t _service,
+                         vsomeip::instance_t _instance, bool _is_available) {
+            VSOMEIP_DEBUG << "Service [" << std::setw(4)
+            << std::setfill('0') << std::hex << _service << "." << _instance
+            << "] is " << (_is_available ? "available":"not available") << ".";
+
+            std::lock_guard<std::mutex> its_lock(mutex_);
+            if(_is_available) {
+                auto found_service = services_available_subribed_.find(_service);
+                if (found_service != services_available_subribed_.end()) {
+                    found_service->second.first = true;
+                    if (std::all_of(services_available_subribed_.cbegin(),
+                                    services_available_subribed_.cend(),
+                                    [](const services_available_subribed_t::value_type& v) {
+                                        return v.second.first;
+                                    }
+                    )) {
+                        VSOMEIP_WARNING << "************************************************************";
+                        VSOMEIP_WARNING << "All services available!";
+                        VSOMEIP_WARNING << "************************************************************";
+                        wait_until_service_available_ = false;
+                        condition_.notify_one();
+                    }
+                }
+            }
+    }
+
+    void subscription_status_changed(const vsomeip::service_t _service,
+                                     const vsomeip::instance_t _instance,
+                                     const vsomeip::eventgroup_t _eventgroup,
+                                     const vsomeip::event_t _event,
+                                     const uint16_t _error) {
+        EXPECT_EQ(0x1, _instance);
+        EXPECT_EQ(offer_test::big_msg_eventgroup_id, _eventgroup);
+        EXPECT_EQ(offer_test::big_msg_event_id, _event);
+        VSOMEIP_DEBUG << "Service [" << std::setw(4)
+        << std::setfill('0') << std::hex << _service << "." << _instance
+        << "] has " << (!_error ? "sent subscribe ack":" sent subscribe_nack") << ".";
+        if (_error == 0x0 /*OK*/) {
+
+            std::lock_guard<std::mutex> its_lock(mutex_);
+            auto found_service = services_available_subribed_.find(_service);
+            if (found_service != services_available_subribed_.end()) {
+                found_service->second.second = true;
+                if (std::all_of(services_available_subribed_.cbegin(),
+                                services_available_subribed_.cend(),
+                                [](const services_available_subribed_t::value_type& v) {
+                                    return v.second.second;
+                                }
+                )) {
+                    VSOMEIP_WARNING << "************************************************************";
+                    VSOMEIP_WARNING << "All subscription were acknowledged!";
+                    VSOMEIP_WARNING << "************************************************************";
+                    wait_until_subscribed_ = false;
+                    condition_.notify_one();
+                }
+            }
+        }
+    };
+
+    void on_message(const std::shared_ptr<vsomeip::message> &_message) {
+        if (_message->get_message_type() == vsomeip::message_type_e::MT_RESPONSE) {
+            on_response(_message);
+        }
+    }
+
+    void on_response(const std::shared_ptr<vsomeip::message> &_message) {
+        EXPECT_EQ(0x1, _message->get_service());
+        EXPECT_EQ(service_info_.shutdown_method_id, _message->get_method());
+        EXPECT_EQ(0x1, _message->get_instance());
+        if(service_info_.shutdown_method_id == _message->get_method()) {
+            std::lock_guard<std::mutex> its_lock(stop_mutex_);
+            wait_for_stop_ = false;
+            VSOMEIP_INFO << "going down";
+            stop_condition_.notify_one();
+        }
+    }
+
+    void send() {
+        std::unique_lock<std::mutex> its_lock(mutex_);
+        while (wait_until_registered_) {
+            condition_.wait(its_lock);
+        }
+
+        while (wait_until_service_available_) {
+            condition_.wait(its_lock);
+        }
+
+        while (wait_until_subscribed_) {
+            condition_.wait(its_lock);
+        }
+
+        std::this_thread::sleep_for(std::chrono::seconds(5));
+        std::shared_ptr<vsomeip::message> its_req = vsomeip::runtime::get()->create_request();
+        its_req->set_service(1);
+        its_req->set_instance(1);
+        its_req->set_interface_version(0x1);
+        its_req->set_method(service_info_.shutdown_method_id);
+        app_->send(its_req);
+    }
+
+    void wait_for_stop() {
+        std::unique_lock<std::mutex> its_lock(stop_mutex_);
+        while (wait_for_stop_) {
+            stop_condition_.wait(its_lock);
+        }
+        VSOMEIP_INFO << "going down";
+        app_->clear_all_handler();
+        app_->stop();
+    }
+
+private:
+    struct offer_test::service_info service_info_;
+    std::shared_ptr<vsomeip::application> app_;
+    bool service_available_;
+
+    bool wait_until_registered_;
+    bool wait_until_service_available_;
+    bool wait_until_subscribed_;
+    std::mutex mutex_;
+    std::condition_variable condition_;
+
+    bool wait_for_stop_;
+    std::mutex stop_mutex_;
+    std::condition_variable stop_condition_;
+
+    typedef std::map<vsomeip::service_t,std::pair<bool, bool>> services_available_subribed_t;
+    services_available_subribed_t services_available_subribed_;
+    std::thread stop_thread_;
+    std::thread send_thread_;
+};
+
+TEST(someip_offer_test_big_sd_msg, subscribe_or_call_method_at_service)
+{
+    offer_test_big_sd_msg_client its_sample(offer_test::service);
+}
+
+#ifndef _WIN32
+int main(int argc, char** argv)
+{
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}
+#endif
diff --git a/test/offer_tests/offer_test_big_sd_msg_service.cpp b/test/offer_tests/offer_test_big_sd_msg_service.cpp
new file mode 100644
index 0000000..d5666c8
--- /dev/null
+++ b/test/offer_tests/offer_test_big_sd_msg_service.cpp
@@ -0,0 +1,131 @@
+// Copyright (C) 2014-2017 Bayerische Motoren Werke Aktiengesellschaft (BMW AG)
+// 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/.
+
+#include <chrono>
+#include <condition_variable>
+#include <iomanip>
+#include <iostream>
+#include <sstream>
+#include <thread>
+#include <map>
+#include <algorithm>
+#include <atomic>
+
+#include <gtest/gtest.h>
+
+#include <vsomeip/vsomeip.hpp>
+#include "../../implementation/logging/include/logger.hpp"
+
+#include "offer_test_globals.hpp"
+
+class offer_test_big_sd_msg_service {
+public:
+    offer_test_big_sd_msg_service(struct offer_test::service_info _service_info) :
+            service_info_(_service_info),
+            // service with number 1 uses "vsomeipd" as application name
+            // this way the same json file can be reused for all local tests
+            // including the ones with vsomeipd
+            app_(vsomeip::runtime::get()->create_application("offer_test_big_sd_msg_service")),
+            counter_(0),
+            wait_until_registered_(true),
+            shutdown_method_called_(false),
+            offer_thread_(std::bind(&offer_test_big_sd_msg_service::run, this)) {
+        if (!app_->init()) {
+            ADD_FAILURE() << "Couldn't initialize application";
+            return;
+        }
+        app_->register_state_handler(
+                std::bind(&offer_test_big_sd_msg_service::on_state, this,
+                        std::placeholders::_1));
+
+        // offer field
+        std::set<vsomeip::eventgroup_t> its_eventgroups;
+        its_eventgroups.insert(offer_test::big_msg_eventgroup_id);
+        for (std::uint16_t s = 1; s <= offer_test::big_msg_number_services; s++) {
+            app_->offer_event(s, 0x1,
+                    offer_test::big_msg_event_id, its_eventgroups, false);
+        }
+
+        app_->register_message_handler(vsomeip::ANY_SERVICE,
+                vsomeip::ANY_INSTANCE, service_info_.shutdown_method_id,
+                std::bind(&offer_test_big_sd_msg_service::on_shutdown_method_called, this,
+                        std::placeholders::_1));
+        app_->start();
+    }
+
+    ~offer_test_big_sd_msg_service() {
+        offer_thread_.join();
+    }
+
+    void offer() {
+        for (std::uint16_t s = 1; s <= offer_test::big_msg_number_services; s++) {
+            app_->offer_service(s,0x1,0x1,0x1);
+        }
+    }
+
+    void on_state(vsomeip::state_type_e _state) {
+        VSOMEIP_INFO << "Application " << app_->get_name() << " is "
+        << (_state == vsomeip::state_type_e::ST_REGISTERED ?
+                "registered." : "deregistered.");
+
+        if (_state == vsomeip::state_type_e::ST_REGISTERED) {
+            std::lock_guard<std::mutex> its_lock(mutex_);
+            wait_until_registered_ = false;
+            condition_.notify_one();
+        }
+    }
+
+    void on_shutdown_method_called(const std::shared_ptr<vsomeip::message> &_message) {
+        app_->send(vsomeip::runtime::get()->create_response(_message));
+        std::this_thread::sleep_for(std::chrono::seconds(1));
+        VSOMEIP_WARNING << "************************************************************";
+        VSOMEIP_WARNING << "Shutdown method called -> going down!";
+        VSOMEIP_WARNING << "************************************************************";
+        shutdown_method_called_ = true;
+        for (std::uint16_t s = 1; s <= offer_test::big_msg_number_services; s++) {
+            app_->stop_offer_service(s,0x1,0x1,0x1);
+        }
+        app_->clear_all_handler();
+        app_->stop();
+    }
+
+    void run() {
+        VSOMEIP_DEBUG << "[" << std::setw(4) << std::setfill('0') << std::hex
+                << service_info_.service_id << "] Running";
+        std::unique_lock<std::mutex> its_lock(mutex_);
+        while (wait_until_registered_) {
+            condition_.wait(its_lock);
+        }
+
+        VSOMEIP_DEBUG << "[" << std::setw(4) << std::setfill('0') << std::hex
+                << service_info_.service_id << "] Offering";
+        offer();
+    }
+
+private:
+    struct offer_test::service_info service_info_;
+    std::shared_ptr<vsomeip::application> app_;
+    std::uint32_t counter_;
+
+    bool wait_until_registered_;
+    std::mutex mutex_;
+    std::condition_variable condition_;
+    std::atomic<bool> shutdown_method_called_;
+    std::thread offer_thread_;
+};
+
+TEST(someip_offer_test_big_sd_msg, notify_increasing_counter)
+{
+    offer_test_big_sd_msg_service its_sample(offer_test::service);
+}
+
+
+#ifndef _WIN32
+int main(int argc, char** argv)
+{
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}
+#endif
diff --git a/test/offer_tests/offer_test_big_sd_msg_slave_starter.sh b/test/offer_tests/offer_test_big_sd_msg_slave_starter.sh
new file mode 100755
index 0000000..d83139f
--- /dev/null
+++ b/test/offer_tests/offer_test_big_sd_msg_slave_starter.sh
@@ -0,0 +1,45 @@
+#!/bin/bash
+# Copyright (C) 2015-2017 Bayerische Motoren Werke Aktiengesellschaft (BMW AG)
+# 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/.
+
+FAIL=0
+# Rejecting offer for which there is already a remote offer:
+# * start daemon
+# * start application which offers service
+# * start daemon remotely
+# * start same application which offers the same service again remotely
+#   -> should be rejected as there is already a service instance
+#   running in the network
+
+export VSOMEIP_CONFIGURATION=offer_test_big_sd_msg_slave.json
+# start daemon
+../daemon/./vsomeipd &
+PID_VSOMEIPD=$!
+sleep 1
+# Start the services
+./offer_test_big_sd_msg_service &
+PID_SERVICE_TWO=$!
+sleep 1
+
+# Wait until all clients and services are finished
+for job in $PID_SERVICE_TWO
+do
+    # Fail gets incremented if a client exits with a non-zero exit code
+    wait $job || FAIL=$(($FAIL+1))
+done
+
+# kill the services
+kill $PID_VSOMEIPD
+sleep 1
+
+
+
+# Check if everything went well
+if [ $FAIL -eq 0 ]
+then
+    exit 0
+else
+    exit 1
+fi
diff --git a/test/offer_tests/offer_test_globals.hpp b/test/offer_tests/offer_test_globals.hpp
index 2fc3bde..ba69886 100644
--- a/test/offer_tests/offer_test_globals.hpp
+++ b/test/offer_tests/offer_test_globals.hpp
@@ -20,6 +20,10 @@ struct service_info {
 struct service_info service = { 0x1111, 0x1, 0x1111, 0x1111, 0x1000, 0x1404 };
 
 static constexpr int number_of_messages_to_send = 150;
+
+static constexpr std::uint16_t big_msg_number_services = 300;
+static constexpr vsomeip::event_t big_msg_event_id = 0x8000;
+static constexpr vsomeip::eventgroup_t big_msg_eventgroup_id = 0x1;
 }
 
 #endif /* OFFER_TEST_GLOBALS_HPP_ */
diff --git a/test/subscribe_notify_tests/subscribe_notify_test_one_event_two_eventgroups_client.cpp b/test/subscribe_notify_tests/subscribe_notify_test_one_event_two_eventgroups_client.cpp
index 6461d87..0b88e25 100644
--- a/test/subscribe_notify_tests/subscribe_notify_test_one_event_two_eventgroups_client.cpp
+++ b/test/subscribe_notify_tests/subscribe_notify_test_one_event_two_eventgroups_client.cpp
@@ -153,6 +153,9 @@ public:
                 && _response->get_method() <= static_cast<vsomeip::event_t>(info_.event_id + 3)) {
             std::lock_guard<std::mutex> its_lock(events_mutex_);
             received_events_.push_back(_response->get_payload());
+            if (received_events_.size() > 4) {
+                ADD_FAILURE() << "Received too much events";
+            }
             number_received_events_[_response->get_method()]++;
             events_condition_.notify_one();
         } else {
author	Juergen Gehring <juergen.gehring@bmw.de>	2018-01-25 00:40:07 -0800
committer	Juergen Gehring <juergen.gehring@bmw.de>	2018-01-25 00:40:07 -0800
commit	a89a645014e17f383e07b6dc6899a4a8925cc324 (patch)
tree	d1a6f31158cd96ec724e13e2c9d7023378106b64
parent	8bb2ed134d75803e8e6e3c4f4baa253e4d74edf4 (diff)
download	vSomeIP-a89a645014e17f383e07b6dc6899a4a8925cc324.tar.gz