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) \
}
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 =
{
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);
}
}
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;
{
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;
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;
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));
}
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);
}
}
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)
{
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;
OICFree(removedData->data);
removedData->data = NULL;
+ OICFree(removedData->tlsdata);
+ removedData->tlsdata = NULL;
+
OICFree(removedData);
removedData = NULL;
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);
* 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;"
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;
{
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;
}
{
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;
}
{
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;
}
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)
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))
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;
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)
{
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))
{
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)
{
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))
{
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))
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))
{
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))
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))
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;
}
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))
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))
{
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))
{
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))
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))
{