Update snapshot(2018-01-31)

Signed-off-by: Hongkuk, Son <hongkuk.son@samsung.com>
Change-Id: I2a12ea6904874b5158458d4882688709a0158575

diff --git a/packaging/snapshot_history.txt b/packaging/snapshot_history.txt
index 9576bd0..5ded465 100755 (executable)
--- a/packaging/snapshot_history.txt
+++ b/packaging/snapshot_history.txt
@@ -1,3 +1,9 @@
+http://suprem.sec.samsung.net/jira/browse/CONPRO-1216
+
+commit_info_2018-01-31.txt
+
+commit_id: a3bb9aca6e4da480448ac8046ed81943df9d697e
+----------------------------------------------------------------------------------------------------------------------------------
 http://suprem.sec.samsung.net/jira/browse/CONPRO-1206
 
 commit_info_2018-01-24.txt

diff --git a/resource/csdk/connectivity/inc/catcpadapter.h b/resource/csdk/connectivity/inc/catcpadapter.h
index caeb8d4..d1e7d20 100644 (file)
--- a/resource/csdk/connectivity/inc/catcpadapter.h
+++ b/resource/csdk/connectivity/inc/catcpadapter.h
@@ -36,6 +36,8 @@ extern "C"
 {
 #endif
 
+// TLS data max size (rfc5246: TLSCiphertext max (2^14+2048+5))
+#define TLS_DATA_MAX_SIZE 18437
 
 typedef enum CAProtocol
 {
@@ -65,7 +67,7 @@ typedef struct
     size_t len;                         /**< received data length */
     size_t totalLen;                    /**< total coap data length required to receive */
     size_t bufLen;                      /**< Buffer length. Buffer will be grown dynamically with respect to data received. */
-    unsigned char tlsdata[18437];       /**< tls data(rfc5246: TLSCiphertext max (2^14+2048+5)) */
+    unsigned char *tlsdata;             /**< tls data(rfc5246: TLSCiphertext max (2^14+2048+5)) */
     size_t tlsLen;                      /**< received tls data length */
     CAProtocol_t protocol;              /**< application-level protocol */
     CATCPConnectionState_t state;       /**< current tcp session state */

diff --git a/resource/csdk/connectivity/src/tcp_adapter/catcpadapter.c b/resource/csdk/connectivity/src/tcp_adapter/catcpadapter.c
index 8056418..cd33343 100644 (file)
--- a/resource/csdk/connectivity/src/tcp_adapter/catcpadapter.c
+++ b/resource/csdk/connectivity/src/tcp_adapter/catcpadapter.c
@@ -480,7 +480,6 @@ CAResult_t CATCPDisconnectSession(const CAEndpoint_t *endpoint)
     if (CA_STATUS_OK != res)
     {
         OIC_LOG(ERROR, TAG, "failed to close TLS session");
-        return res;
     }
 #endif
 

diff --git a/resource/csdk/connectivity/src/tcp_adapter/catcpserver.c b/resource/csdk/connectivity/src/tcp_adapter/catcpserver.c
index 627028e..661612e 100644 (file)
--- a/resource/csdk/connectivity/src/tcp_adapter/catcpserver.c
+++ b/resource/csdk/connectivity/src/tcp_adapter/catcpserver.c
@@ -115,6 +115,7 @@ static void CAReceiveMessage(int fd);
 static void CAReceiveHandler(void *data);
 static CAResult_t CATCPCreateSocket(int family, CATCPSessionInfo_t *svritem);
 static void CATCPInitializeSocket();
+static CATCPSessionInfo_t *CAGetSessionInfoFromFDAsOwner(int fd, size_t *index);
 
 #define CHECKFD(FD) \
     if (FD > caglobals.tcp.maxfd) \
@@ -288,8 +289,20 @@ static void CASelectReturned(fd_set *readFds)
     }
     else
     {
+        int *readFDList = NULL;
+        size_t readFDListSize = 0;
+
         oc_mutex_lock(g_mutexObjectList);
         uint32_t length = u_arraylist_length(caglobals.tcp.svrlist);
+
+        readFDList = (int*) OICCalloc(length, sizeof(int));
+        if (NULL == readFDList)
+        {
+            OIC_LOG_V(ERROR, TAG, "Failed to allocate memory!");
+            oc_mutex_unlock(g_mutexObjectList);
+            return;
+        }
+
         for (size_t i = 0; i < length; i++)
         {
             CATCPSessionInfo_t *svritem =
@@ -298,11 +311,19 @@ static void CASelectReturned(fd_set *readFds)
             {
                 if (FD_ISSET(svritem->fd, readFds))
                 {
-                    CAReceiveMessage(svritem->fd);
+                    readFDList[readFDListSize++] = svritem->fd;
                 }
             }
         }
         oc_mutex_unlock(g_mutexObjectList);
+
+        // Read incomming messages from fds
+        for (size_t i = 0; i < readFDListSize; i++)
+        {
+            CAReceiveMessage(readFDList[i]);
+        }
+
+        OICFree(readFDList);
     }
 }
 
@@ -346,12 +367,23 @@ static void CAAcceptConnection(CATransportFlags_t flag, CASocket_t *sock)
         CAConvertAddrToName((struct sockaddr_storage *)&clientaddr, clientlen,
                             svritem->sep.endpoint.addr, &svritem->sep.endpoint.port);
 
+        // Allocate message buffer
+        svritem->tlsdata = (unsigned char*) OICCalloc(TLS_DATA_MAX_SIZE, sizeof(unsigned char));
+        if (!svritem->tlsdata)
+        {
+            OIC_LOG(ERROR, TAG, "Out of memory");
+            close(sockfd);
+            OICFree(svritem);
+            return;
+        }
+
         oc_mutex_lock(g_mutexObjectList);
         bool result = u_arraylist_add(caglobals.tcp.svrlist, svritem);
         if (!result)
         {
             OIC_LOG(ERROR, TAG, "u_arraylist_add failed.");
             close(sockfd);
+            OICFree(svritem->tlsdata);
             OICFree(svritem);
             oc_mutex_unlock(g_mutexObjectList);
             return;
@@ -524,19 +556,21 @@ static void CAReceiveMessage(int fd)
 {
     CAResult_t res = CA_STATUS_OK;
 
+    oc_mutex_lock(g_mutexObjectList);
+
     //get remote device information from file descriptor.
     size_t index = 0;
-    CATCPSessionInfo_t *svritem = CAGetSessionInfoFromFD(fd, &index);
+    CATCPSessionInfo_t *svritem = CAGetSessionInfoFromFDAsOwner(fd, &index);
     if (!svritem)
     {
         OIC_LOG(ERROR, TAG, "there is no connection information in list");
+        oc_mutex_unlock(g_mutexObjectList);
         return;
     }
 
-    // read data
+    CASecureEndpoint_t peerEP = svritem->sep;
     int len = 0;
-
-    if (svritem->sep.endpoint.flags & CA_SECURE)
+    if (svritem->sep.endpoint.flags & CA_SECURE) // Secure connection
     {
         svritem->protocol = TLS;
 
@@ -554,15 +588,12 @@ static void CAReceiveMessage(int fd)
             tlsLength = TLS_HEADER_SIZE +
                             (size_t)((svritem->tlsdata[3] << 8) | svritem->tlsdata[4]);
             OIC_LOG_V(DEBUG, TAG, "total tls length = %u", tlsLength);
-            if (tlsLength > sizeof(svritem->tlsdata))
+            if (tlsLength > TLS_DATA_MAX_SIZE)
             {
                 OIC_LOG_V(ERROR, TAG, "total tls length is too big (buffer size : %u)",
-                                    sizeof(svritem->tlsdata));
-                if (CA_STATUS_OK != CAcloseSslConnection(&svritem->sep.endpoint))
-                {
-                    OIC_LOG(ERROR, TAG, "Failed to close TLS session");
-                }
-                CASearchAndDeleteTCPSession(&(svritem->sep.endpoint));
+                                    TLS_DATA_MAX_SIZE);
+                oc_mutex_unlock(g_mutexObjectList);
+                CATCPDisconnectSession(&peerEP.endpoint);
                 return;
             }
             nbRead = tlsLength - svritem->tlsLen;
@@ -587,21 +618,40 @@ static void CAReceiveMessage(int fd)
                                 nbRead, len, svritem->tlsLen);
             if (tlsLength > 0 && tlsLength == svritem->tlsLen)
             {
-                //when successfully read data - pass them to callback.
-                res = CAdecryptSsl(&svritem->sep, (uint8_t *)svritem->tlsdata, svritem->tlsLen);
-                svritem->tlsLen = 0;
+                // When successfully read data - pass them to callback.
+                // Dont invoke callback locking mutex
+                unsigned char *mesBuf = svritem->tlsdata;
+                size_t mesBufLen = svritem->tlsLen;
+                svritem->tlsdata = NULL;
+                oc_mutex_unlock(g_mutexObjectList);
+
+                res = CAdecryptSsl(&peerEP, (uint8_t *)mesBuf, mesBufLen);
                 OIC_LOG_V(INFO, TAG, "%s: CAdecryptSsl returned %d", __func__, res);
+
+                // Check for the svritem and reset buffer
+                oc_mutex_lock(g_mutexObjectList);
+                svritem = CAGetSessionInfoFromFDAsOwner(fd, &index);
+                if (svritem)
+                {
+                    svritem->tlsdata = mesBuf;
+                    svritem->tlsLen = 0;
+                }
+                else
+                {
+                    // svritem does not exist, thus free the message buffer
+                    OIC_LOG(ERROR, TAG, "svritem not found. Freeing message buffer!");
+                    OICFree(mesBuf);
+                }
             }
         }
 #endif
-
     }
-    else
+    else // Non-Secure connection
     {
         svritem->protocol = COAP;
 
         // svritem->tlsdata can also be used as receiving buffer in case of raw tcp
-        len = recv(fd, svritem->tlsdata, sizeof(svritem->tlsdata), 0);
+        len = recv(fd, svritem->tlsdata, TLS_DATA_MAX_SIZE, 0);
         if (len < 0)
         {
             OIC_LOG_V(ERROR, TAG, "recv failed %s", strerror(errno));
@@ -614,25 +664,40 @@ static void CAReceiveMessage(int fd)
         }
         else
         {
-            OIC_LOG_V(DEBUG, TAG, "recv() : %d bytes", len);
             //when successfully read data - pass them to callback.
+            OIC_LOG_V(DEBUG, TAG, "recv() : %d bytes", len);
             if (g_packetReceivedCallback)
             {
-                res = g_packetReceivedCallback(&svritem->sep, svritem->tlsdata, len);
+                // Dont invoke callback locking mutex
+                unsigned char *mesBuf = svritem->tlsdata;
+                svritem->tlsdata = NULL;
+                oc_mutex_unlock(g_mutexObjectList);
+
+                res = g_packetReceivedCallback(&peerEP, mesBuf, len);
+
+                // Check for the svritem and reset buffer
+                oc_mutex_lock(g_mutexObjectList);
+                svritem = CAGetSessionInfoFromFDAsOwner(fd, &index);
+                if (svritem)
+                {
+                    svritem->tlsdata = mesBuf;
+                    svritem->tlsLen = 0;
+                }
+                else
+                {
+                    // svritem does not exist, thus free the message buffer
+                    OIC_LOG(ERROR, TAG, "svritem not found. Freeing message buffer!");
+                    OICFree(mesBuf);
+                }
             }
         }
     }
 
-    //disconnect session and clean-up data if any error occurs
+    oc_mutex_unlock(g_mutexObjectList);
+
     if (res != CA_STATUS_OK)
     {
-        if (CA_STATUS_OK != CATCPDisconnectSession(&svritem->sep.endpoint))
-        {
-            CASearchAndDeleteTCPSession(&svritem->sep.endpoint);
-            OIC_LOG(ERROR, TAG, "Failed to disconnect TCP session");
-        }
-
-        return;
+        CATCPDisconnectSession(&peerEP.endpoint);
     }
 }
 
@@ -1207,6 +1272,15 @@ CASocketFd_t CAConnectTCPSession(const CAEndpoint_t *endpoint)
     svritem->state = CONNECTING;
     svritem->isClient = true;
 
+    // Allocate message buffer
+    svritem->tlsdata = (unsigned char*) OICCalloc(TLS_DATA_MAX_SIZE, sizeof(unsigned char));
+    if (!svritem->tlsdata)
+    {
+        OIC_LOG(ERROR, TAG, "Out of memory");
+        OICFree(svritem);
+        return OC_INVALID_SOCKET;
+    }
+
     // #2. add TCP connection info to list
     oc_mutex_lock(g_mutexObjectList);
     if (caglobals.tcp.svrlist)
@@ -1216,6 +1290,7 @@ CASocketFd_t CAConnectTCPSession(const CAEndpoint_t *endpoint)
         {
             OIC_LOG(ERROR, TAG, "u_arraylist_add failed.");
             close(svritem->fd);
+            OICFree(svritem->tlsdata);
             OICFree(svritem);
             oc_mutex_unlock(g_mutexObjectList);
             return OC_INVALID_SOCKET;
@@ -1266,6 +1341,9 @@ CAResult_t CADisconnectTCPSession(size_t index)
     OICFree(removedData->data);
     removedData->data = NULL;
 
+    OICFree(removedData->tlsdata);
+    removedData->tlsdata = NULL;
+
     OICFree(removedData);
     removedData = NULL;
 
@@ -1392,6 +1470,24 @@ CATCPSessionInfo_t *CAGetSessionInfoFromFD(int fd, size_t *index)
     return NULL;
 }
 
+static CATCPSessionInfo_t *CAGetSessionInfoFromFDAsOwner(int fd, size_t *index)
+{
+    CATCPSessionInfo_t *svritem = NULL;
+    uint32_t length = u_arraylist_length(caglobals.tcp.svrlist);
+    for (size_t i = 0; i < length; i++)
+    {
+        svritem = (CATCPSessionInfo_t *) u_arraylist_get(caglobals.tcp.svrlist, i);
+
+        if (svritem && svritem->fd == fd)
+        {
+            *index = i;
+            return svritem;
+        }
+    }
+
+    return NULL;
+}
+
 CAResult_t CASearchAndDeleteTCPSession(const CAEndpoint_t *endpoint)
 {
     oc_mutex_lock(g_mutexObjectList);

diff --git a/resource/csdk/security/provisioning/src/provisioningdatabasemanager.c b/resource/csdk/security/provisioning/src/provisioningdatabasemanager.c
index 359b510..0bf88e0 100644 (file)
--- a/resource/csdk/security/provisioning/src/provisioningdatabasemanager.c
+++ b/resource/csdk/security/provisioning/src/provisioningdatabasemanager.c
@@ -52,9 +52,10 @@
  * Macro to verify sqlite success.
  * eg: VERIFY_NON_NULL(TAG, ptrData, ERROR,OC_STACK_ERROR);
  */
-#define PDM_VERIFY_SQLITE_OK(tag, arg, logLevel, retValue) do{ if (SQLITE_OK != (arg)) \
+#define PDM_VERIFY_SQLITE_OK(tag, arg, stmt, logLevel, retValue) do{ if (SQLITE_OK != (arg)) \
             { OIC_LOG_V((logLevel), tag, "Error in " #arg ", Error Message: %s", \
-               sqlite3_errmsg(g_db)); return retValue; }}while(0)
+               sqlite3_errmsg(g_db)); sqlite3_finalize(stmt); return retValue; }}while(0)
+
 
 #define PDM_SQLITE_TRANSACTION_BEGIN "BEGIN TRANSACTION;"
 #define PDM_SQLITE_TRANSACTION_COMMIT "COMMIT;"
@@ -98,14 +99,14 @@ static OCStackResult createDB(const char* path)
 
     int result = 0;
     result = sqlite3_open_v2(path, &g_db, SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE, NULL);
-    PDM_VERIFY_SQLITE_OK(TAG, result, ERROR, OC_STACK_ERROR);
+    PDM_VERIFY_SQLITE_OK(TAG, result, NULL, ERROR, OC_STACK_ERROR);
 
     result = sqlite3_exec(g_db, PDM_CREATE_T_DEVICE_LIST, NULL, NULL, NULL);
-    PDM_VERIFY_SQLITE_OK(TAG, result, ERROR, OC_STACK_ERROR);
+    PDM_VERIFY_SQLITE_OK(TAG, result, NULL, ERROR, OC_STACK_ERROR);
 
     OIC_LOG(INFO, TAG, "Created T_DEVICE_LIST");
     result = sqlite3_exec(g_db, PDM_CREATE_T_DEVICE_LINK, NULL, NULL, NULL);
-    PDM_VERIFY_SQLITE_OK(TAG, result, ERROR, OC_STACK_ERROR);
+    PDM_VERIFY_SQLITE_OK(TAG, result, NULL, ERROR, OC_STACK_ERROR);
 
     OIC_LOG(INFO, TAG, "Created T_DEVICE_LINK_STATE");
     gInit = true;
@@ -123,7 +124,7 @@ static OCStackResult begin()
 {
     int res = 0;
     res = sqlite3_exec(g_db, PDM_SQLITE_TRANSACTION_BEGIN, NULL, NULL, NULL);
-    PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
+    PDM_VERIFY_SQLITE_OK(TAG, res, NULL, ERROR, OC_STACK_ERROR);
     return OC_STACK_OK;
 }
 
@@ -134,7 +135,7 @@ static OCStackResult commit()
 {
     int res = 0;
     res = sqlite3_exec(g_db, PDM_SQLITE_TRANSACTION_COMMIT, NULL, NULL, NULL);
-    PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
+    PDM_VERIFY_SQLITE_OK(TAG, res, NULL, ERROR, OC_STACK_ERROR);
     return OC_STACK_OK;
 }
 
@@ -145,7 +146,7 @@ static OCStackResult rollback()
 {
     int res = 0;
     res = sqlite3_exec(g_db, PDM_SQLITE_TRANSACTION_ROLLBACK, NULL, NULL, NULL);
-    PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
+    PDM_VERIFY_SQLITE_OK(TAG, res, NULL, ERROR, OC_STACK_ERROR);
     return OC_STACK_OK;
 }
 
@@ -224,13 +225,13 @@ OCStackResult PDMAddDevice(const OicUuid_t *UUID)
     int res =0;
     res = sqlite3_prepare_v2(g_db, PDM_SQLITE_INSERT_T_DEVICE_LIST,
                               strlen(PDM_SQLITE_INSERT_T_DEVICE_LIST) + 1, &stmt, NULL);
-    PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
+    PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR);
 
     res = sqlite3_bind_blob(stmt, PDM_BIND_INDEX_SECOND, UUID, UUID_LENGTH, SQLITE_STATIC);
-    PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
+    PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR);
 
     res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_THIRD, PDM_DEVICE_INIT);
-    PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
+    PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR);
 
     res = sqlite3_step(stmt);
     if (SQLITE_DONE != res)
@@ -262,10 +263,10 @@ static OCStackResult getIdForUUID(const OicUuid_t *UUID , int *id)
     sqlite3_stmt *stmt = 0;
     int res = 0;
     res = sqlite3_prepare_v2(g_db, PDM_SQLITE_GET_ID, strlen(PDM_SQLITE_GET_ID) + 1, &stmt, NULL);
-    PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
+    PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR);
 
     res = sqlite3_bind_blob(stmt, PDM_BIND_INDEX_FIRST, UUID, UUID_LENGTH, SQLITE_STATIC);
-    PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
+    PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR);
 
     OIC_LOG(DEBUG, TAG, "Binding Done");
     while (SQLITE_ROW == sqlite3_step(stmt))
@@ -297,10 +298,10 @@ OCStackResult PDMIsDuplicateDevice(const OicUuid_t* UUID, bool *result)
     sqlite3_stmt *stmt = 0;
     int res = 0;
     res = sqlite3_prepare_v2(g_db, PDM_SQLITE_GET_ID, strlen(PDM_SQLITE_GET_ID) + 1, &stmt, NULL);
-    PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
+    PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR);
 
     res = sqlite3_bind_blob(stmt, PDM_BIND_INDEX_FIRST, UUID, UUID_LENGTH, SQLITE_STATIC);
-    PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
+    PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR);
 
     OIC_LOG(DEBUG, TAG, "Binding Done");
     bool retValue = false;
@@ -328,16 +329,16 @@ static OCStackResult addlink(int id1, int id2)
     int res = 0;
     res = sqlite3_prepare_v2(g_db, PDM_SQLITE_INSERT_LINK_DATA,
                               strlen(PDM_SQLITE_INSERT_LINK_DATA) + 1, &stmt, NULL);
-    PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
+    PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR);
 
     res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_FIRST, id1);
-    PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
+    PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR);
 
     res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_SECOND, id2);
-    PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
+    PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR);
 
     res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_THIRD, PDM_DEVICE_ACTIVE);
-    PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
+    PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR);
 
     if (sqlite3_step(stmt) != SQLITE_DONE)
     {
@@ -413,13 +414,13 @@ static OCStackResult removeLink(int id1, int id2)
     int res = 0;
     sqlite3_stmt *stmt = 0;
     res = sqlite3_prepare_v2(g_db, PDM_SQLITE_DELETE_LINK, strlen(PDM_SQLITE_DELETE_LINK) + 1, &stmt, NULL);
-    PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
+    PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR);
 
     res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_FIRST, id1);
-    PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
+    PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR);
 
     res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_SECOND, id2);
-    PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
+    PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR);
 
     if (SQLITE_DONE != sqlite3_step(stmt))
     {
@@ -469,10 +470,10 @@ static OCStackResult removeFromDeviceList(int id)
     int res = 0;
     res = sqlite3_prepare_v2(g_db, PDM_SQLITE_DELETE_DEVICE,
                               strlen(PDM_SQLITE_DELETE_DEVICE) + 1, &stmt, NULL);
-    PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
+    PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR);
 
     res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_FIRST, id);
-    PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
+    PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR);
 
     if (sqlite3_step(stmt) != SQLITE_DONE)
     {
@@ -521,16 +522,16 @@ static OCStackResult updateLinkState(int id1, int id2, int state)
     int res = 0 ;
     res = sqlite3_prepare_v2(g_db, PDM_SQLITE_UPDATE_LINK,
                               strlen(PDM_SQLITE_UPDATE_LINK) + 1, &stmt, NULL);
-    PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
+    PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR);
 
     res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_FIRST, state);
-    PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
+    PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR);
 
     res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_SECOND, id1);
-    PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
+    PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR);
 
     res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_THIRD, id2);
-    PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
+    PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR);
 
     if (SQLITE_DONE != sqlite3_step(stmt))
     {
@@ -586,7 +587,7 @@ OCStackResult PDMGetOwnedDevices(OCUuidList_t **uuidList, size_t *numOfDevices)
     int res = 0;
     res = sqlite3_prepare_v2(g_db, PDM_SQLITE_LIST_ALL_UUID,
                               strlen(PDM_SQLITE_LIST_ALL_UUID) + 1, &stmt, NULL);
-    PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
+    PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR);
 
     size_t counter  = 0;
     while (SQLITE_ROW == sqlite3_step(stmt))
@@ -618,10 +619,10 @@ static OCStackResult getUUIDforId(int id, OicUuid_t *uid, bool *result)
     int res = 0;
     res = sqlite3_prepare_v2(g_db, PDM_SQLITE_GET_UUID,
                               strlen(PDM_SQLITE_GET_UUID) + 1, &stmt, NULL);
-    PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
+    PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR);
 
     res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_FIRST, id);
-    PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
+    PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR);
 
     while (SQLITE_ROW == sqlite3_step(stmt))
     {
@@ -689,13 +690,13 @@ OCStackResult PDMGetLinkedDevices(const OicUuid_t *UUID, OCUuidList_t **UUIDLIST
     int res = 0;
     res = sqlite3_prepare_v2(g_db, PDM_SQLITE_GET_LINKED_DEVICES,
                               strlen(PDM_SQLITE_GET_LINKED_DEVICES) + 1, &stmt, NULL);
-    PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
+    PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR);
 
     res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_FIRST, id);
-    PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
+    PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR);
 
     res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_SECOND, id);
-    PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
+    PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR);
 
     size_t counter  = 0;
     while (SQLITE_ROW == sqlite3_step(stmt))
@@ -745,10 +746,10 @@ OCStackResult PDMGetToBeUnlinkedDevices(OCPairList_t **staleDevList, size_t *num
     int res = 0;
     res = sqlite3_prepare_v2(g_db, PDM_SQLITE_GET_STALE_INFO,
                               strlen(PDM_SQLITE_GET_STALE_INFO) + 1, &stmt, NULL);
-    PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
+    PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR);
 
     res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_FIRST, PDM_DEVICE_STALE);
-    PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
+    PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR);
 
     size_t counter  = 0;
     while (SQLITE_ROW == sqlite3_step(stmt))
@@ -785,7 +786,7 @@ OCStackResult PDMClose()
     CHECK_PDM_INIT(TAG);
     int res = 0;
     res = sqlite3_close(g_db);
-    PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
+    PDM_VERIFY_SQLITE_OK(TAG, res, NULL, ERROR, OC_STACK_ERROR);
     OIC_LOG_V(DEBUG, TAG, "OUT %s", __func__);
     return OC_STACK_OK;
 }
@@ -878,13 +879,13 @@ OCStackResult PDMIsLinkExists(const OicUuid_t* uuidOfDevice1, const OicUuid_t* u
     int res = 0;
     res = sqlite3_prepare_v2(g_db, PDM_SQLITE_GET_DEVICE_LINKS,
                               strlen(PDM_SQLITE_GET_DEVICE_LINKS) + 1, &stmt, NULL);
-    PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
+    PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR);
 
     res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_FIRST, id1);
-    PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
+    PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR);
 
     res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_SECOND, id2);
-    PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
+    PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR);
 
     bool ret = false;
     while(SQLITE_ROW == sqlite3_step(stmt))
@@ -906,13 +907,13 @@ static OCStackResult updateDeviceState(const OicUuid_t *uuid, PdmDeviceState_t s
     int res = 0 ;
     res = sqlite3_prepare_v2(g_db, PDM_SQLITE_UPDATE_DEVICE,
                               strlen(PDM_SQLITE_UPDATE_DEVICE) + 1, &stmt, NULL);
-    PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
+    PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR);
 
     res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_FIRST, state);
-    PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
+    PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR);
 
     res = sqlite3_bind_blob(stmt, PDM_BIND_INDEX_SECOND, uuid, UUID_LENGTH, SQLITE_STATIC);
-    PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
+    PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR);
 
     if (SQLITE_DONE != sqlite3_step(stmt))
     {
@@ -942,13 +943,13 @@ static OCStackResult updateLinkForStaleDevice(const OicUuid_t *devUuid)
     res = sqlite3_prepare_v2(g_db, PDM_SQLITE_UPDATE_LINK_STALE_FOR_STALE_DEVICE,
                               strlen(PDM_SQLITE_UPDATE_LINK_STALE_FOR_STALE_DEVICE) + 1,
                                &stmt, NULL);
-    PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
+    PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR);
 
     res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_FIRST, id);
-    PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
+    PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR);
 
     res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_SECOND, id);
-    PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
+    PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR);
 
     if (SQLITE_DONE != sqlite3_step(stmt))
     {
@@ -1012,10 +1013,10 @@ OCStackResult PDMGetDeviceState(const OicUuid_t *uuid, PdmDeviceState_t* result)
     int res = 0;
     res = sqlite3_prepare_v2(g_db, PDM_SQLITE_GET_DEVICE_STATUS, strlen(PDM_SQLITE_GET_DEVICE_STATUS) + 1,
                               &stmt, NULL);
-    PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
+    PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR);
 
     res = sqlite3_bind_blob(stmt, PDM_BIND_INDEX_FIRST, uuid, UUID_LENGTH, SQLITE_STATIC);
-    PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
+    PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR);
 
     *result = PDM_DEVICE_UNKNOWN;
     while(SQLITE_ROW == sqlite3_step(stmt))
@@ -1044,10 +1045,10 @@ OCStackResult PDMDeleteDeviceWithState(const PdmDeviceState_t state)
     int res =0;
     res = sqlite3_prepare_v2(g_db, PDM_SQLITE_DELETE_DEVICE_WITH_STATE,
                               strlen(PDM_SQLITE_DELETE_DEVICE_WITH_STATE) + 1, &stmt, NULL);
-    PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
+    PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR);
 
     res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_FIRST, state);
-    PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
+    PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR);
 
     if (SQLITE_DONE != sqlite3_step(stmt))
     {