1 /* *****************************************************************
3 * Copyright 2015 Samsung Electronics All Rights Reserved.
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
19 * *****************************************************************/
28 #include "oic_malloc.h"
29 #include "provisioningdatabasemanager.h"
30 #include "pmutility.h"
31 #include "oic_string.h"
35 #define DB_FILE "PDM.db"
39 #define PDM_STALE_STATE 1
40 #define PDM_ACTIVE_STATE 0
42 #define PDM_FIRST_INDEX 0
43 #define PDM_SECOND_INDEX 1
45 #define PDM_BIND_INDEX_FIRST 1
46 #define PDM_BIND_INDEX_SECOND 2
47 #define PDM_BIND_INDEX_THIRD 3
49 #define PDM_CREATE_T_DEVICE_LIST "create table T_DEVICE_LIST(ID INTEGER PRIMARY KEY AUTOINCREMENT,\
50 UUID BLOB NOT NULL UNIQUE);"
52 #define PDM_CREATE_T_DEVICE_LINK "create table T_DEVICE_LINK_STATE(ID INT NOT NULL, ID2 INT NOT \
53 NULL,STATE INT NOT NULL, PRIMARY KEY (ID, ID2));"
55 * Macro to verify sqlite success.
56 * eg: VERIFY_NON_NULL(TAG, ptrData, ERROR,OC_STACK_ERROR);
58 #define PDM_VERIFY_SQLITE_OK(tag, arg, logLevel, retValue) do{ if (SQLITE_OK != (arg)) \
59 { OC_LOG_V((logLevel), tag, "Error in " #arg ", Error Message: %s", \
60 sqlite3_errmsg(g_db)); return retValue; }}while(0)
62 #define PDM_SQLITE_TRANSACTION_BEGIN "BEGIN TRANSACTION;"
63 #define PDM_SQLITE_TRANSACTION_COMMIT "COMMIT;"
64 #define PDM_SQLITE_TRANSACTION_ROLLBACK "ROLLBACK;"
65 #define PDM_SQLITE_GET_STALE_INFO "SELECT ID,ID2 FROM T_DEVICE_LINK_STATE WHERE STATE = ?"
66 #define PDM_SQLITE_INSERT_T_DEVICE_LIST "INSERT INTO T_DEVICE_LIST VALUES(?,?)"
67 #define PDM_SQLITE_GET_ID "SELECT ID FROM T_DEVICE_LIST WHERE UUID like ?"
68 #define PDM_SQLITE_INSERT_LINK_DATA "INSERT INTO T_DEVICE_LINK_STATE VALUES(?,?,?)"
69 #define PDM_SQLITE_DELETE_LINK "DELETE FROM T_DEVICE_LINK_STATE WHERE ID = ? and ID2 = ?"
70 #define PDM_SQLITE_DELETE_DEVICE_LINK "DELETE FROM T_DEVICE_LINK_STATE WHERE ID = ? or ID2 = ?"
71 #define PDM_SQLITE_DELETE_DEVICE "DELETE FROM T_DEVICE_LIST WHERE ID = ?"
72 #define PDM_SQLITE_UPDATE_LINK "UPDATE T_DEVICE_LINK_STATE SET STATE = ? WHERE ID = ? and ID2 = ?"
73 #define PDM_SQLITE_LIST_ALL_UUID "SELECT UUID FROM T_DEVICE_LIST"
74 #define PDM_SQLITE_GET_UUID "SELECT UUID FROM T_DEVICE_LIST WHERE ID = ?"
75 #define PDM_SQLITE_GET_LINKED_DEVICES "SELECT ID,ID2 FROM T_DEVICE_LINK_STATE WHERE ID = ? or ID2 = ?"
76 #define PDM_SQLITE_GET_DEVICE_LINKS "SELECT ID,ID2 FROM T_DEVICE_LINK_STATE WHERE ID = ? and ID2 = ?"
78 #define ASCENDING_ORDER(id1, id2) do{if( (id1) > (id2) )\
79 { int temp; temp = id1; id1 = id2; id2 = temp; }}while(0)
81 #define CHECK_PDM_INIT(tag) do{if(true != gInit)\
82 { OC_LOG(ERROR, (tag), "PDB is not initialized"); \
83 return OC_STACK_PDM_IS_NOT_INITIALIZED; }}while(0)
85 static sqlite3 *g_db = NULL;
86 static bool gInit = false; /* Only if we can open sqlite db successfully, gInit is true. */
89 * function to create DB in case DB doesn't exists
91 static OCStackResult createDB(const char* path)
95 result = sqlite3_open_v2(path, &g_db, SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE, NULL);
96 PDM_VERIFY_SQLITE_OK(TAG, result, ERROR, OC_STACK_ERROR);
98 result = sqlite3_exec(g_db, PDM_CREATE_T_DEVICE_LIST, NULL, NULL, NULL);
99 PDM_VERIFY_SQLITE_OK(TAG, result, ERROR, OC_STACK_ERROR);
101 OC_LOG(INFO, TAG, "Created T_DEVICE_LIST");
102 result = sqlite3_exec(g_db, PDM_CREATE_T_DEVICE_LINK, NULL, NULL, NULL);
103 PDM_VERIFY_SQLITE_OK(TAG, result, ERROR, OC_STACK_ERROR);
105 OC_LOG(INFO, TAG, "Created T_DEVICE_LINK_STATE");
112 * Function to begin any transaction
114 static OCStackResult begin()
117 res = sqlite3_exec(g_db, PDM_SQLITE_TRANSACTION_BEGIN, NULL, NULL, NULL);
118 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
123 * Function to commit any transaction
125 static OCStackResult commit()
128 res = sqlite3_exec(g_db, PDM_SQLITE_TRANSACTION_COMMIT, NULL, NULL, NULL);
129 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
134 * Function to rollback any transaction
136 static OCStackResult rollback()
139 res = sqlite3_exec(g_db, PDM_SQLITE_TRANSACTION_ROLLBACK, NULL, NULL, NULL);
140 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
145 * Error log callback called by SQLite stack in case of error
147 void errLogCallback(void *pArg, int iErrCode, const char *zMsg)
152 OC_LOG_V(DEBUG,TAG, "(%d) %s", iErrCode, zMsg);
155 OCStackResult PDMInit(const char *path)
158 const char *dbPath = NULL;
159 if (SQLITE_OK != sqlite3_config(SQLITE_CONFIG_LOG, errLogCallback, NULL))
161 OC_LOG(INFO, TAG, "Unable to enable debug log of sqlite");
164 if (NULL == path || !*path)
172 rc = sqlite3_open_v2(dbPath, &g_db, SQLITE_OPEN_READWRITE, NULL);
175 OC_LOG_V(INFO, TAG, "ERROR: Can't open database: %s", sqlite3_errmsg(g_db));
176 return createDB(dbPath);
183 OCStackResult PDMAddDevice(const OicUuid_t *UUID)
188 return OC_STACK_INVALID_PARAM;
191 sqlite3_stmt *stmt = 0;
193 res = sqlite3_prepare_v2(g_db, PDM_SQLITE_INSERT_T_DEVICE_LIST,
194 strlen(PDM_SQLITE_INSERT_T_DEVICE_LIST) + 1, &stmt, NULL);
195 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
197 res = sqlite3_bind_blob(stmt, PDM_BIND_INDEX_SECOND, UUID, UUID_LENGTH, SQLITE_STATIC);
198 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
200 res = sqlite3_step(stmt);
201 if (SQLITE_DONE != res)
203 if (SQLITE_CONSTRAINT == res)
205 //new OCStack result code
206 OC_LOG_V(ERROR, TAG, "Error Occured: %s",sqlite3_errmsg(g_db));
207 sqlite3_finalize(stmt);
208 return OC_STACK_DUPLICATE_UUID;
210 OC_LOG_V(ERROR, TAG, "Error Occured: %s",sqlite3_errmsg(g_db));
211 sqlite3_finalize(stmt);
212 return OC_STACK_ERROR;
214 sqlite3_finalize(stmt);
219 *function to get Id for given UUID
221 static OCStackResult getIdForUUID(const OicUuid_t *UUID , int *id)
223 sqlite3_stmt *stmt = 0;
225 res = sqlite3_prepare_v2(g_db, PDM_SQLITE_GET_ID, strlen(PDM_SQLITE_GET_ID) + 1, &stmt, NULL);
226 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
228 res = sqlite3_bind_blob(stmt, PDM_BIND_INDEX_FIRST, UUID, UUID_LENGTH, SQLITE_STATIC);
229 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
231 OC_LOG(DEBUG, TAG, "Binding Done");
232 while (SQLITE_ROW == sqlite3_step(stmt))
234 int tempId = sqlite3_column_int(stmt, PDM_FIRST_INDEX);
235 OC_LOG_V(DEBUG, TAG, "ID is %d", tempId);
237 sqlite3_finalize(stmt);
240 sqlite3_finalize(stmt);
241 return OC_STACK_INVALID_PARAM;
245 * Function to check duplication of device's Device ID.
247 OCStackResult PDMIsDuplicateDevice(const OicUuid_t* UUID, bool *result)
251 if (NULL == UUID || NULL == result)
253 OC_LOG(ERROR, TAG, "UUID or result is NULL");
254 return OC_STACK_INVALID_PARAM;
256 sqlite3_stmt *stmt = 0;
258 res = sqlite3_prepare_v2(g_db, PDM_SQLITE_GET_ID, strlen(PDM_SQLITE_GET_ID) + 1, &stmt, NULL);
259 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
261 res = sqlite3_bind_blob(stmt, PDM_BIND_INDEX_FIRST, UUID, UUID_LENGTH, SQLITE_STATIC);
262 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
264 OC_LOG(DEBUG, TAG, "Binding Done");
265 bool retValue = false;
266 while(SQLITE_ROW == sqlite3_step(stmt))
268 OC_LOG(INFO, TAG, "Duplicated UUID");
272 sqlite3_finalize(stmt);
278 * Function to add link in sqlite
280 static OCStackResult addlink(int id1, int id2)
282 sqlite3_stmt *stmt = 0;
284 res = sqlite3_prepare_v2(g_db, PDM_SQLITE_INSERT_LINK_DATA,
285 strlen(PDM_SQLITE_INSERT_LINK_DATA) + 1, &stmt, NULL);
286 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
288 res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_FIRST, id1);
289 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
291 res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_SECOND, id2);
292 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
294 res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_THIRD, PDM_ACTIVE_STATE);
295 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
297 if (sqlite3_step(stmt) != SQLITE_DONE)
299 OC_LOG_V(ERROR, TAG, "Error Occured: %s",sqlite3_errmsg(g_db));
300 sqlite3_finalize(stmt);
301 return OC_STACK_ERROR;
303 sqlite3_finalize(stmt);
307 OCStackResult PDMLinkDevices(const OicUuid_t *UUID1, const OicUuid_t *UUID2)
310 if (NULL == UUID1 || NULL == UUID2)
312 OC_LOG(ERROR, TAG, "Invalid PARAM");
313 return OC_STACK_INVALID_PARAM;
316 if (OC_STACK_OK != getIdForUUID(UUID1, &id1))
318 OC_LOG(ERROR, TAG, "Requested value not found");
319 return OC_STACK_INVALID_PARAM;
322 if (OC_STACK_OK != getIdForUUID(UUID2, &id2))
324 OC_LOG(ERROR, TAG, "Requested value not found");
325 return OC_STACK_INVALID_PARAM;
327 ASCENDING_ORDER(id1, id2);
328 return addlink(id1, id2);
332 * Function to remove created link
334 static OCStackResult removeLink(int id1, int id2)
337 sqlite3_stmt *stmt = 0;
338 res = sqlite3_prepare_v2(g_db, PDM_SQLITE_DELETE_LINK, strlen(PDM_SQLITE_DELETE_LINK) + 1, &stmt, NULL);
339 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
341 res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_FIRST, id1);
342 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
344 res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_SECOND, id2);
345 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
347 if (SQLITE_DONE != sqlite3_step(stmt))
349 OC_LOG_V(ERROR, TAG, "Error message: %s", sqlite3_errmsg(g_db));
350 sqlite3_finalize(stmt);
351 return OC_STACK_ERROR;
353 sqlite3_finalize(stmt);
357 OCStackResult PDMUnlinkDevices(const OicUuid_t *UUID1, const OicUuid_t *UUID2)
360 if (NULL == UUID1 || NULL == UUID2)
362 OC_LOG(ERROR, TAG, "Invalid PARAM");
363 return OC_STACK_INVALID_PARAM;
367 if (OC_STACK_OK != getIdForUUID(UUID1, &id1))
369 OC_LOG(ERROR, TAG, "Requested value not found");
370 return OC_STACK_INVALID_PARAM;
374 if (OC_STACK_OK != getIdForUUID(UUID2, &id2))
376 OC_LOG(ERROR, TAG, "Requested value not found");
377 return OC_STACK_INVALID_PARAM;
379 ASCENDING_ORDER(id1, id2);
380 return removeLink(id1, id2);
383 static OCStackResult removeFromDeviceList(int id)
385 sqlite3_stmt *stmt = 0;
387 res = sqlite3_prepare_v2(g_db, PDM_SQLITE_DELETE_DEVICE,
388 strlen(PDM_SQLITE_DELETE_DEVICE) + 1, &stmt, NULL);
389 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
391 res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_FIRST, id);
392 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
394 if (sqlite3_step(stmt) != SQLITE_DONE)
396 OC_LOG_V(ERROR, TAG, "Error message: %s", sqlite3_errmsg(g_db));
397 sqlite3_finalize(stmt);
398 return OC_STACK_ERROR;
400 sqlite3_finalize(stmt);
404 OCStackResult PDMDeleteDevice(const OicUuid_t *UUID)
409 return OC_STACK_INVALID_PARAM;
412 if (OC_STACK_OK != getIdForUUID(UUID, &id))
414 OC_LOG(ERROR, TAG, "Requested value not found");
415 return OC_STACK_INVALID_PARAM;
418 if(OC_STACK_OK != removeFromDeviceList(id))
421 OC_LOG(ERROR, TAG, "Requested value not found");
422 return OC_STACK_ERROR;
429 static OCStackResult updateLinkState(int id1, int id2, int state)
431 sqlite3_stmt *stmt = 0;
433 res = sqlite3_prepare_v2(g_db, PDM_SQLITE_UPDATE_LINK,
434 strlen(PDM_SQLITE_UPDATE_LINK) + 1, &stmt, NULL);
435 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
437 res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_FIRST, state);
438 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
440 res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_SECOND, id1);
441 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
443 res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_THIRD, id2);
444 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
446 if (SQLITE_DONE != sqlite3_step(stmt))
448 OC_LOG_V(ERROR, TAG, "Error message: %s", sqlite3_errmsg(g_db));
449 sqlite3_finalize(stmt);
450 return OC_STACK_ERROR;
452 sqlite3_finalize(stmt);
456 OCStackResult PDMSetLinkStale(const OicUuid_t* uuidOfDevice1, const OicUuid_t* uuidOfDevice2)
459 if (NULL == uuidOfDevice1 || NULL == uuidOfDevice2)
461 OC_LOG(ERROR, TAG, "Invalid PARAM");
462 return OC_STACK_INVALID_PARAM;
466 if (OC_STACK_OK != getIdForUUID(uuidOfDevice1, &id1))
468 OC_LOG(ERROR, TAG, "Requested value not found");
469 return OC_STACK_INVALID_PARAM;
473 if (OC_STACK_OK != getIdForUUID(uuidOfDevice2, &id2))
475 OC_LOG(ERROR, TAG, "Requested value not found");
476 return OC_STACK_INVALID_PARAM;
478 ASCENDING_ORDER(id1, id2);
479 return updateLinkState(id1, id2, PDM_STALE_STATE);
483 OCStackResult PDMGetOwnedDevices(OCUuidList_t **uuidList, size_t *numOfDevices)
486 if (NULL != *uuidList)
488 OC_LOG(ERROR, TAG, "Not null list will cause memory leak");
489 return OC_STACK_INVALID_PARAM;
491 sqlite3_stmt *stmt = 0;
493 res = sqlite3_prepare_v2(g_db, PDM_SQLITE_LIST_ALL_UUID,
494 strlen(PDM_SQLITE_LIST_ALL_UUID) + 1, &stmt, NULL);
495 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
498 while (SQLITE_ROW == sqlite3_step(stmt))
501 const void *ptr = sqlite3_column_blob(stmt, PDM_FIRST_INDEX);
502 OicUuid_t *uid = (OicUuid_t *)ptr;
503 OCUuidList_t *temp = (OCUuidList_t *) OICCalloc(1,sizeof(OCUuidList_t));
506 OC_LOG_V(ERROR, TAG, "Memory allocation problem");
507 sqlite3_finalize(stmt);
508 return OC_STACK_NO_MEMORY;
510 memcpy(&temp->dev.id, uid->id, UUID_LENGTH);
511 LL_PREPEND(*uuidList,temp);
514 *numOfDevices = counter;
515 sqlite3_finalize(stmt);
519 static OCStackResult getUUIDforId(int id, OicUuid_t *uid)
521 sqlite3_stmt *stmt = 0;
523 res = sqlite3_prepare_v2(g_db, PDM_SQLITE_GET_UUID,
524 strlen(PDM_SQLITE_GET_UUID) + 1, &stmt, NULL);
525 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
527 res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_FIRST, id);
528 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
530 while (SQLITE_ROW == sqlite3_step(stmt))
532 const void *ptr = sqlite3_column_blob(stmt, PDM_FIRST_INDEX);
533 memcpy(uid, ptr, sizeof(OicUuid_t));
535 sqlite3_finalize(stmt);
539 OCStackResult PDMGetLinkedDevices(const OicUuid_t *UUID, OCUuidList_t **UUIDLIST, size_t *numOfDevices)
542 if (NULL != *UUIDLIST)
544 OC_LOG(ERROR, TAG, "Not null list will cause memory leak");
545 return OC_STACK_INVALID_PARAM;
549 return OC_STACK_INVALID_PARAM;
552 if (OC_STACK_OK != getIdForUUID(UUID, &id))
554 OC_LOG(ERROR, TAG, "Requested value not found");
555 return OC_STACK_INVALID_PARAM;
558 sqlite3_stmt *stmt = 0;
560 res = sqlite3_prepare_v2(g_db, PDM_SQLITE_GET_LINKED_DEVICES,
561 strlen(PDM_SQLITE_GET_LINKED_DEVICES) + 1, &stmt, NULL);
562 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
564 res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_FIRST, id);
565 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
567 res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_SECOND, id);
568 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
571 while (SQLITE_ROW == sqlite3_step(stmt))
573 int i1 = sqlite3_column_int(stmt, PDM_FIRST_INDEX);
574 int i2 = sqlite3_column_int(stmt, PDM_SECOND_INDEX);
576 OicUuid_t temp = {{0,}};
579 getUUIDforId(i1, &temp);
583 getUUIDforId(i2, &temp);
586 OCUuidList_t *tempNode = (OCUuidList_t *) OICCalloc(1,sizeof(OCUuidList_t));
587 if (NULL == tempNode)
589 OC_LOG(ERROR, TAG, "No Memory");
590 sqlite3_finalize(stmt);
591 return OC_STACK_NO_MEMORY;
593 memcpy(&tempNode->dev.id, &temp.id, UUID_LENGTH);
594 LL_PREPEND(*UUIDLIST,tempNode);
597 *numOfDevices = counter;
598 sqlite3_finalize(stmt);
602 OCStackResult PDMGetToBeUnlinkedDevices(OCPairList_t **staleDevList, size_t *numOfDevices)
605 if (NULL != *staleDevList)
607 OC_LOG(ERROR, TAG, "Not null list will cause memory leak");
608 return OC_STACK_INVALID_PARAM;
611 sqlite3_stmt *stmt = 0;
613 res = sqlite3_prepare_v2(g_db, PDM_SQLITE_GET_STALE_INFO,
614 strlen(PDM_SQLITE_GET_STALE_INFO) + 1, &stmt, NULL);
615 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
617 res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_FIRST, PDM_STALE_STATE);
618 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
621 while (SQLITE_ROW == sqlite3_step(stmt))
623 int i1 = sqlite3_column_int(stmt, PDM_FIRST_INDEX);
624 int i2 = sqlite3_column_int(stmt, PDM_SECOND_INDEX);
625 OicUuid_t temp1 = {{0,}};
626 OicUuid_t temp2 = {{0,}};;
627 getUUIDforId(i1, &temp1);
628 getUUIDforId(i2, &temp2);
630 OCPairList_t *tempNode = (OCPairList_t *) OICCalloc(1, sizeof(OCPairList_t));
631 if (NULL == tempNode)
633 OC_LOG(ERROR, TAG, "No Memory");
634 sqlite3_finalize(stmt);
635 return OC_STACK_NO_MEMORY;
637 memcpy(&tempNode->dev.id, &temp1.id, UUID_LENGTH);
638 memcpy(&tempNode->dev2.id, &temp2.id, UUID_LENGTH);
639 LL_PREPEND(*staleDevList, tempNode);
642 *numOfDevices = counter;
643 sqlite3_finalize(stmt);
647 OCStackResult PDMClose()
651 res = sqlite3_close(g_db);
652 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
656 void PDMDestoryOicUuidLinkList(OCUuidList_t* ptr)
660 OCUuidList_t *tmp1 = NULL,*tmp2=NULL;
661 LL_FOREACH_SAFE(ptr, tmp1, tmp2)
663 LL_DELETE(ptr, tmp1);
669 void PDMDestoryStaleLinkList(OCPairList_t* ptr)
673 OCPairList_t *tmp1 = NULL,*tmp2=NULL;
674 LL_FOREACH_SAFE(ptr, tmp1, tmp2)
676 LL_DELETE(ptr, tmp1);
682 OCStackResult PDMIsLinkExists(const OicUuid_t* uuidOfDevice1, const OicUuid_t* uuidOfDevice2,
686 if (NULL == uuidOfDevice1 || NULL == uuidOfDevice2 || NULL == result)
688 return OC_STACK_INVALID_PARAM;
692 if (OC_STACK_OK != getIdForUUID(uuidOfDevice1, &id1))
694 OC_LOG(ERROR, TAG, "Requested value not found");
695 return OC_STACK_INVALID_PARAM;
698 if (OC_STACK_OK != getIdForUUID(uuidOfDevice2, &id2))
700 OC_LOG(ERROR, TAG, "Requested value not found");
701 return OC_STACK_INVALID_PARAM;
704 ASCENDING_ORDER(id1, id2);
706 sqlite3_stmt *stmt = 0;
708 res = sqlite3_prepare_v2(g_db, PDM_SQLITE_GET_DEVICE_LINKS,
709 strlen(PDM_SQLITE_GET_DEVICE_LINKS) + 1, &stmt, NULL);
710 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
712 res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_FIRST, id1);
713 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
715 res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_SECOND, id2);
716 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
719 while(SQLITE_ROW == sqlite3_step(stmt))
721 OC_LOG(INFO, TAG, "Link already exists between devices");
724 sqlite3_finalize(stmt);