Send REQUEST type and generated sequence number in SendHandshakeData (#3761)

* Send REQUEST type and generated sequence number in SendHandshakeData

* Update query type in tests

4 files changed, 38 insertions, 20 deletions

diff --git a/src/components/security_manager/include/security_manager/security_manager_impl.h b/src/components/security_manager/include/security_manager/security_manager_impl.h
index 7cbb19708e..c4a752173e 100644
--- a/src/components/security_manager/include/security_manager/security_manager_impl.h
+++ b/src/components/security_manager/include/security_manager/security_manager_impl.h
@@ -226,17 +226,24 @@ class SecurityManagerImpl : public SecurityManager,
 
  private:
   /**
+   * @brief NextSequentialNumber get next sequential number for request
+   * @return next sequential number
+   */
+  uint32_t NextSequentialNumber();
+
+  /**
    * \brief Sends Handshake binary data to mobile application
    * \param connection_key Unique key used by other components as session
    * identifier
    * \param data pointer to binary data array
    * \param data_size size of binary data array
-   * \param seq_number received from Mobile Application
+   * \param custom_seq_number specific sequential number of request. If omitted,
+   * this will be automatically generated
    */
   void SendHandshakeBinData(const uint32_t connection_key,
                             const uint8_t* const data,
                             const size_t data_size,
-                            const uint32_t seq_number = 0);
+                            const uint32_t custom_seq_number = 0);
   /**
    * \brief Parse SecurityMessage as HandshakeData request
    * \param inMessage SecurityMessage with binary data of handshake
@@ -327,6 +334,8 @@ class SecurityManagerImpl : public SecurityManager,
   std::set<uint32_t> awaiting_certificate_connections_;
   std::set<uint32_t> awaiting_time_connections_;
 
+  uint32_t current_seq_number_;
+
   mutable sync_primitives::Lock waiters_lock_;
   volatile bool waiting_for_certificate_;
   volatile bool waiting_for_time_;
diff --git a/src/components/security_manager/src/security_manager_impl.cc b/src/components/security_manager/src/security_manager_impl.cc
index 914d30003a..f78f859c04 100644
--- a/src/components/security_manager/src/security_manager_impl.cc
+++ b/src/components/security_manager/src/security_manager_impl.cc
@@ -54,6 +54,7 @@ SecurityManagerImpl::SecurityManagerImpl(
     , crypto_manager_(NULL)
     , protocol_handler_(NULL)
     , system_time_handler_(std::move(system_time_handler))
+    , current_seq_number_(0)
     , waiting_for_certificate_(false)
     , waiting_for_time_(false) {
   DCHECK(system_time_handler_);
@@ -596,13 +597,24 @@ bool SecurityManagerImpl::ProcessInternalError(
   return true;
 }
 
-void SecurityManagerImpl::SendHandshakeBinData(const uint32_t connection_key,
-                                               const uint8_t* const data,
-                                               const size_t data_size,
-                                               const uint32_t seq_number) {
-  const SecurityQuery::QueryHeader header(SecurityQuery::NOTIFICATION,
-                                          SecurityQuery::SEND_HANDSHAKE_DATA,
-                                          seq_number);
+uint32_t SecurityManagerImpl::NextSequentialNumber() {
+  if (current_seq_number_ >= std::numeric_limits<uint32_t>::max()) {
+    current_seq_number_ = 0;
+  }
+  current_seq_number_++;
+  return current_seq_number_;
+}
+
+void SecurityManagerImpl::SendHandshakeBinData(
+    const uint32_t connection_key,
+    const uint8_t* const data,
+    const size_t data_size,
+    const uint32_t custom_seq_number) {
+  uint32_t seq_number =
+      (0 == custom_seq_number) ? NextSequentialNumber() : custom_seq_number;
+
+  const SecurityQuery::QueryHeader header(
+      SecurityQuery::REQUEST, SecurityQuery::SEND_HANDSHAKE_DATA, seq_number);
   DCHECK(data_size < 1024 * 1024 * 1024);
   const SecurityQuery query =
       SecurityQuery(header, connection_key, data, data_size);
diff --git a/src/components/security_manager/test/security_manager_test.cc b/src/components/security_manager/test/security_manager_test.cc
index 912ffff4c7..7e0454e840 100644
--- a/src/components/security_manager/test/security_manager_test.cc
+++ b/src/components/security_manager/test/security_manager_test.cc
@@ -152,7 +152,7 @@ class SecurityManagerTest : public ::testing::Test {
   void EmulateMobileMessageHandshake(const uint8_t* const data,
                                      const uint32_t data_size,
                                      const int repeat_count = 1) {
-    const SecurityQuery::QueryHeader header(SecurityQuery::NOTIFICATION,
+    const SecurityQuery::QueryHeader header(SecurityQuery::RESPONSE,
                                             SecurityQuery::SEND_HANDSHAKE_DATA,
                                             kSeqNumber);
     for (int c = 0; c < repeat_count; ++c) {
diff --git a/src/components/security_manager/test/security_query_test.cc b/src/components/security_manager/test/security_query_test.cc
index 6becddaaf9..60e3a20d77 100644
--- a/src/components/security_manager/test/security_query_test.cc
+++ b/src/components/security_manager/test/security_query_test.cc
@@ -53,7 +53,7 @@ class SecurityQueryTest : public ::testing::Test {
  protected:
   void SetUp() OVERRIDE {
     // init_header used for SecurityQuery initialization
-    init_header.query_type = SecurityQuery::NOTIFICATION;
+    init_header.query_type = SecurityQuery::REQUEST;
     init_header.query_id = SecurityQuery::SEND_HANDSHAKE_DATA;
     init_header.seq_number = SEQ_NUMBER;
     init_header.json_size = 0u;
@@ -107,18 +107,17 @@ TEST_F(SecurityQueryTest, QueryHeaderConstructor) {
  * Security QueryHeader shall construct with correct fields
  */
 TEST_F(SecurityQueryTest, QueryHeaderConstructor2) {
-  SecurityQuery::QueryHeader new_header(SecurityQuery::NOTIFICATION,
-                                        SecurityQuery::SEND_HANDSHAKE_DATA,
-                                        SEQ_NUMBER);
-  ASSERT_EQ(new_header.query_type, SecurityQuery::NOTIFICATION);
+  SecurityQuery::QueryHeader new_header(
+      SecurityQuery::REQUEST, SecurityQuery::SEND_HANDSHAKE_DATA, SEQ_NUMBER);
+  ASSERT_EQ(new_header.query_type, SecurityQuery::REQUEST);
   ASSERT_EQ(new_header.query_id, SecurityQuery::SEND_HANDSHAKE_DATA);
   ASSERT_EQ(new_header.seq_number, SEQ_NUMBER);
   ASSERT_EQ(new_header.json_size, 0u);
 
-  SecurityQuery::QueryHeader new_header2(SecurityQuery::RESPONSE,
+  SecurityQuery::QueryHeader new_header2(SecurityQuery::NOTIFICATION,
                                          SecurityQuery::SEND_INTERNAL_ERROR,
                                          SEQ_NUMBER + 1);
-  ASSERT_EQ(new_header2.query_type, SecurityQuery::RESPONSE);
+  ASSERT_EQ(new_header2.query_type, SecurityQuery::NOTIFICATION);
   ASSERT_EQ(new_header2.query_id, SecurityQuery::SEND_INTERNAL_ERROR);
   ASSERT_EQ(new_header2.seq_number, SEQ_NUMBER + 1);
   ASSERT_EQ(new_header2.json_size, 0u);
@@ -385,9 +384,7 @@ TEST_F(SecurityQueryTest, Parse_InvalidQuery_UnknownId_Response) {
  */
 TEST_F(SecurityQueryTest, Parse_Handshake) {
   SecurityQuery::QueryHeader handshake_header(
-      SecurityQuery::NOTIFICATION,
-      SecurityQuery::SEND_HANDSHAKE_DATA,
-      SEQ_NUMBER);
+      SecurityQuery::REQUEST, SecurityQuery::SEND_HANDSHAKE_DATA, SEQ_NUMBER);
   // some sample data
   uint8_t raw_data[] = {0x6, 0x7, 0x8};
   const size_t raw_data_size = sizeof(raw_data) / sizeof(raw_data[0]);