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 = ?"
77 #define ASCENDING_ORDER(id1, id2) do{if( (id1) > (id2) )\
78 { int temp; temp = id1; id1 = id2; id2 = temp; }}while(0)
80 #define CHECK_PDM_INIT(tag) do{if(true != gInit)\
81 { OC_LOG(ERROR, (tag), "PDB is not initialized"); \
82 return OC_STACK_PDM_IS_NOT_INITIALIZED; }}while(0)
84 static sqlite3 *g_db = NULL;
85 static bool gInit = false; /* Only if we can open sqlite db successfully, gInit is true. */
88 * function to create DB in case DB doesn't exists
90 static OCStackResult createDB(const char* path)
94 result = sqlite3_open_v2(path, &g_db, SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE, NULL);
95 PDM_VERIFY_SQLITE_OK(TAG, result, ERROR, OC_STACK_ERROR);
97 result = sqlite3_exec(g_db, PDM_CREATE_T_DEVICE_LIST, NULL, NULL, NULL);
98 PDM_VERIFY_SQLITE_OK(TAG, result, ERROR, OC_STACK_ERROR);
100 OC_LOG(INFO, TAG, "Created T_DEVICE_LIST");
101 result = sqlite3_exec(g_db, PDM_CREATE_T_DEVICE_LINK, NULL, NULL, NULL);
102 PDM_VERIFY_SQLITE_OK(TAG, result, ERROR, OC_STACK_ERROR);
104 OC_LOG(INFO, TAG, "Created T_DEVICE_LINK_STATE");
111 * Function to begin any transaction
113 static OCStackResult begin()
116 res = sqlite3_exec(g_db, PDM_SQLITE_TRANSACTION_BEGIN, NULL, NULL, NULL);
117 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
122 * Function to commit any transaction
124 static OCStackResult commit()
127 res = sqlite3_exec(g_db, PDM_SQLITE_TRANSACTION_COMMIT, NULL, NULL, NULL);
128 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
133 * Function to rollback any transaction
135 static OCStackResult rollback()
138 res = sqlite3_exec(g_db, PDM_SQLITE_TRANSACTION_ROLLBACK, NULL, NULL, NULL);
139 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
144 * Error log callback called by SQLite stack in case of error
146 void errLogCallback(void *pArg, int iErrCode, const char *zMsg)
151 OC_LOG_V(DEBUG,TAG, "(%d) %s", iErrCode, zMsg);
154 OCStackResult PDMInit(const char *path)
157 const char *dbPath = NULL;
158 if (SQLITE_OK != sqlite3_config(SQLITE_CONFIG_LOG, errLogCallback, NULL))
160 OC_LOG(INFO, TAG, "Unable to enable debug log of sqlite");
163 if (NULL == path || !*path)
171 rc = sqlite3_open_v2(dbPath, &g_db, SQLITE_OPEN_READWRITE, NULL);
174 OC_LOG_V(INFO, TAG, "ERROR: Can't open database: %s", sqlite3_errmsg(g_db));
175 return createDB(dbPath);
182 OCStackResult PDMAddDevice(const OicUuid_t *UUID)
187 return OC_STACK_INVALID_PARAM;
190 sqlite3_stmt *stmt = 0;
192 res = sqlite3_prepare_v2(g_db, PDM_SQLITE_INSERT_T_DEVICE_LIST,
193 strlen(PDM_SQLITE_INSERT_T_DEVICE_LIST) + 1, &stmt, NULL);
194 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
196 res = sqlite3_bind_blob(stmt, PDM_BIND_INDEX_SECOND, UUID, UUID_LENGTH, SQLITE_STATIC);
197 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
199 res = sqlite3_step(stmt);
200 if (SQLITE_DONE != res)
202 if (SQLITE_CONSTRAINT == res)
204 //new OCStack result code
205 OC_LOG_V(ERROR, TAG, "Error Occured: %s",sqlite3_errmsg(g_db));
206 sqlite3_finalize(stmt);
207 return OC_STACK_DUPLICATE_UUID;
209 OC_LOG_V(ERROR, TAG, "Error Occured: %s",sqlite3_errmsg(g_db));
210 sqlite3_finalize(stmt);
211 return OC_STACK_ERROR;
213 sqlite3_finalize(stmt);
218 *function to get Id for given UUID
220 static OCStackResult getIdForUUID(const OicUuid_t *UUID , int *id)
222 sqlite3_stmt *stmt = 0;
224 res = sqlite3_prepare_v2(g_db, PDM_SQLITE_GET_ID, strlen(PDM_SQLITE_GET_ID) + 1, &stmt, NULL);
225 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
227 res = sqlite3_bind_blob(stmt, PDM_BIND_INDEX_FIRST, UUID, UUID_LENGTH, SQLITE_STATIC);
228 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
230 OC_LOG(DEBUG, TAG, "Binding Done");
231 while (SQLITE_ROW == sqlite3_step(stmt))
233 int tempId = sqlite3_column_int(stmt, PDM_FIRST_INDEX);
234 OC_LOG_V(DEBUG, TAG, "ID is %d", tempId);
236 sqlite3_finalize(stmt);
239 sqlite3_finalize(stmt);
240 return OC_STACK_INVALID_PARAM;
244 * Function to check duplication of device's Device ID.
246 OCStackResult PDMIsDuplicateDevice(const OicUuid_t* UUID, bool *result)
250 if (NULL == UUID || NULL == result)
252 OC_LOG(ERROR, TAG, "UUID or result is NULL");
253 return OC_STACK_INVALID_PARAM;
255 sqlite3_stmt *stmt = 0;
257 res = sqlite3_prepare_v2(g_db, PDM_SQLITE_GET_ID, strlen(PDM_SQLITE_GET_ID) + 1, &stmt, NULL);
258 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
260 res = sqlite3_bind_blob(stmt, PDM_BIND_INDEX_FIRST, UUID, UUID_LENGTH, SQLITE_STATIC);
261 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
263 OC_LOG(DEBUG, TAG, "Binding Done");
264 bool retValue = false;
265 while(SQLITE_ROW == sqlite3_step(stmt))
267 OC_LOG(INFO, TAG, "Duplicated UUID");
271 sqlite3_finalize(stmt);
277 * Function to add link in sqlite
279 static OCStackResult addlink(int id1, int id2)
281 sqlite3_stmt *stmt = 0;
283 res = sqlite3_prepare_v2(g_db, PDM_SQLITE_INSERT_LINK_DATA,
284 strlen(PDM_SQLITE_INSERT_LINK_DATA) + 1, &stmt, NULL);
285 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
287 res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_FIRST, id1);
288 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
290 res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_SECOND, id2);
291 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
293 res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_THIRD, PDM_ACTIVE_STATE);
294 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
296 if (sqlite3_step(stmt) != SQLITE_DONE)
298 OC_LOG_V(ERROR, TAG, "Error Occured: %s",sqlite3_errmsg(g_db));
299 sqlite3_finalize(stmt);
300 return OC_STACK_ERROR;
302 sqlite3_finalize(stmt);
306 OCStackResult PDMLinkDevices(const OicUuid_t *UUID1, const OicUuid_t *UUID2)
309 if (NULL == UUID1 || NULL == UUID2)
311 OC_LOG(ERROR, TAG, "Invalid PARAM");
312 return OC_STACK_INVALID_PARAM;
315 if (OC_STACK_OK != getIdForUUID(UUID1, &id1))
317 OC_LOG(ERROR, TAG, "Requested value not found");
318 return OC_STACK_INVALID_PARAM;
321 if (OC_STACK_OK != getIdForUUID(UUID2, &id2))
323 OC_LOG(ERROR, TAG, "Requested value not found");
324 return OC_STACK_INVALID_PARAM;
326 ASCENDING_ORDER(id1, id2);
327 return addlink(id1, id2);
331 * Function to remove created link
333 static OCStackResult removeLink(int id1, int id2)
336 sqlite3_stmt *stmt = 0;
337 res = sqlite3_prepare_v2(g_db, PDM_SQLITE_DELETE_LINK, strlen(PDM_SQLITE_DELETE_LINK) + 1, &stmt, NULL);
338 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
340 res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_FIRST, id1);
341 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
343 res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_SECOND, id2);
344 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
346 if (SQLITE_DONE != sqlite3_step(stmt))
348 OC_LOG_V(ERROR, TAG, "Error message: %s", sqlite3_errmsg(g_db));
349 sqlite3_finalize(stmt);
350 return OC_STACK_ERROR;
352 sqlite3_finalize(stmt);
356 OCStackResult PDMUnlinkDevices(const OicUuid_t *UUID1, const OicUuid_t *UUID2)
359 if (NULL == UUID1 || NULL == UUID2)
361 OC_LOG(ERROR, TAG, "Invalid PARAM");
362 return OC_STACK_INVALID_PARAM;
366 if (OC_STACK_OK != getIdForUUID(UUID1, &id1))
368 OC_LOG(ERROR, TAG, "Requested value not found");
369 return OC_STACK_INVALID_PARAM;
373 if (OC_STACK_OK != getIdForUUID(UUID2, &id2))
375 OC_LOG(ERROR, TAG, "Requested value not found");
376 return OC_STACK_INVALID_PARAM;
378 ASCENDING_ORDER(id1, id2);
379 return removeLink(id1, id2);
382 static OCStackResult removeFromDeviceList(int id)
384 sqlite3_stmt *stmt = 0;
386 res = sqlite3_prepare_v2(g_db, PDM_SQLITE_DELETE_DEVICE,
387 strlen(PDM_SQLITE_DELETE_DEVICE) + 1, &stmt, NULL);
388 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
390 res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_FIRST, id);
391 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
393 if (sqlite3_step(stmt) != SQLITE_DONE)
395 OC_LOG_V(ERROR, TAG, "Error message: %s", sqlite3_errmsg(g_db));
396 sqlite3_finalize(stmt);
397 return OC_STACK_ERROR;
399 sqlite3_finalize(stmt);
403 OCStackResult PDMDeleteDevice(const OicUuid_t *UUID)
408 return OC_STACK_INVALID_PARAM;
411 if (OC_STACK_OK != getIdForUUID(UUID, &id))
413 OC_LOG(ERROR, TAG, "Requested value not found");
414 return OC_STACK_INVALID_PARAM;
417 if(OC_STACK_OK != removeFromDeviceList(id))
420 OC_LOG(ERROR, TAG, "Requested value not found");
421 return OC_STACK_ERROR;
428 static OCStackResult updateLinkState(int id1, int id2, int state)
430 sqlite3_stmt *stmt = 0;
432 res = sqlite3_prepare_v2(g_db, PDM_SQLITE_UPDATE_LINK,
433 strlen(PDM_SQLITE_UPDATE_LINK) + 1, &stmt, NULL);
434 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
436 res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_FIRST, state);
437 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
439 res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_SECOND, id1);
440 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
442 res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_THIRD, id2);
443 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
445 if (SQLITE_DONE != sqlite3_step(stmt))
447 OC_LOG_V(ERROR, TAG, "Error message: %s", sqlite3_errmsg(g_db));
448 sqlite3_finalize(stmt);
449 return OC_STACK_ERROR;
451 sqlite3_finalize(stmt);
455 OCStackResult PDMSetLinkStale(const OicUuid_t* uuidOfDevice1, const OicUuid_t* uuidOfDevice2)
458 if (NULL == uuidOfDevice1 || NULL == uuidOfDevice2)
460 OC_LOG(ERROR, TAG, "Invalid PARAM");
461 return OC_STACK_INVALID_PARAM;
465 if (OC_STACK_OK != getIdForUUID(uuidOfDevice1, &id1))
467 OC_LOG(ERROR, TAG, "Requested value not found");
468 return OC_STACK_INVALID_PARAM;
472 if (OC_STACK_OK != getIdForUUID(uuidOfDevice2, &id2))
474 OC_LOG(ERROR, TAG, "Requested value not found");
475 return OC_STACK_INVALID_PARAM;
477 ASCENDING_ORDER(id1, id2);
478 return updateLinkState(id1, id2, PDM_STALE_STATE);
482 OCStackResult PDMGetOwnedDevices(OCUuidList_t **uuidList, size_t *numOfDevices)
485 if (NULL != *uuidList)
487 OC_LOG(ERROR, TAG, "Not null list will cause memory leak");
488 return OC_STACK_INVALID_PARAM;
490 sqlite3_stmt *stmt = 0;
492 res = sqlite3_prepare_v2(g_db, PDM_SQLITE_LIST_ALL_UUID,
493 strlen(PDM_SQLITE_LIST_ALL_UUID) + 1, &stmt, NULL);
494 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
497 while (SQLITE_ROW == sqlite3_step(stmt))
500 const void *ptr = sqlite3_column_blob(stmt, PDM_FIRST_INDEX);
501 OicUuid_t *uid = (OicUuid_t *)ptr;
502 OCUuidList_t *temp = (OCUuidList_t *) OICCalloc(1,sizeof(OCUuidList_t));
505 OC_LOG_V(ERROR, TAG, "Memory allocation problem");
506 sqlite3_finalize(stmt);
507 return OC_STACK_NO_MEMORY;
509 memcpy(&temp->dev.id, uid->id, UUID_LENGTH);
510 LL_PREPEND(*uuidList,temp);
513 *numOfDevices = counter;
514 sqlite3_finalize(stmt);
518 static OCStackResult getUUIDforId(int id, OicUuid_t *uid)
520 sqlite3_stmt *stmt = 0;
522 res = sqlite3_prepare_v2(g_db, PDM_SQLITE_GET_UUID,
523 strlen(PDM_SQLITE_GET_UUID) + 1, &stmt, NULL);
524 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
526 res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_FIRST, id);
527 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
529 while (SQLITE_ROW == sqlite3_step(stmt))
531 const void *ptr = sqlite3_column_blob(stmt, PDM_FIRST_INDEX);
532 memcpy(uid, ptr, sizeof(OicUuid_t));
534 sqlite3_finalize(stmt);
538 OCStackResult PDMGetLinkedDevices(const OicUuid_t *UUID, OCUuidList_t **UUIDLIST, size_t *numOfDevices)
541 if (NULL != *UUIDLIST)
543 OC_LOG(ERROR, TAG, "Not null list will cause memory leak");
544 return OC_STACK_INVALID_PARAM;
548 return OC_STACK_INVALID_PARAM;
551 if (OC_STACK_OK != getIdForUUID(UUID, &id))
553 OC_LOG(ERROR, TAG, "Requested value not found");
554 return OC_STACK_INVALID_PARAM;
557 sqlite3_stmt *stmt = 0;
559 res = sqlite3_prepare_v2(g_db, PDM_SQLITE_GET_LINKED_DEVICES,
560 strlen(PDM_SQLITE_GET_LINKED_DEVICES) + 1, &stmt, NULL);
561 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
563 res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_FIRST, id);
564 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
566 res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_SECOND, id);
567 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
570 while (SQLITE_ROW == sqlite3_step(stmt))
572 int i1 = sqlite3_column_int(stmt, PDM_FIRST_INDEX);
573 int i2 = sqlite3_column_int(stmt, PDM_SECOND_INDEX);
575 OicUuid_t temp = {{0,}};
578 getUUIDforId(i1, &temp);
582 getUUIDforId(i2, &temp);
585 OCUuidList_t *tempNode = (OCUuidList_t *) OICCalloc(1,sizeof(OCUuidList_t));
586 if (NULL == tempNode)
588 OC_LOG(ERROR, TAG, "No Memory");
589 sqlite3_finalize(stmt);
590 return OC_STACK_NO_MEMORY;
592 memcpy(&tempNode->dev.id, &temp.id, UUID_LENGTH);
593 LL_PREPEND(*UUIDLIST,tempNode);
596 *numOfDevices = counter;
597 sqlite3_finalize(stmt);
601 OCStackResult PDMGetToBeUnlinkedDevices(OCPairList_t **staleDevList, size_t *numOfDevices)
604 if (NULL != *staleDevList)
606 OC_LOG(ERROR, TAG, "Not null list will cause memory leak");
607 return OC_STACK_INVALID_PARAM;
610 sqlite3_stmt *stmt = 0;
612 res = sqlite3_prepare_v2(g_db, PDM_SQLITE_GET_STALE_INFO,
613 strlen(PDM_SQLITE_GET_STALE_INFO) + 1, &stmt, NULL);
614 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
616 res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_FIRST, PDM_STALE_STATE);
617 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
620 while (SQLITE_ROW == sqlite3_step(stmt))
622 int i1 = sqlite3_column_int(stmt, PDM_FIRST_INDEX);
623 int i2 = sqlite3_column_int(stmt, PDM_SECOND_INDEX);
624 OicUuid_t temp1 = {{0,}};
625 OicUuid_t temp2 = {{0,}};;
626 getUUIDforId(i1, &temp1);
627 getUUIDforId(i2, &temp2);
629 OCPairList_t *tempNode = (OCPairList_t *) OICCalloc(1, sizeof(OCPairList_t));
630 if (NULL == tempNode)
632 OC_LOG(ERROR, TAG, "No Memory");
633 sqlite3_finalize(stmt);
634 return OC_STACK_NO_MEMORY;
636 memcpy(&tempNode->dev.id, &temp1.id, UUID_LENGTH);
637 memcpy(&tempNode->dev2.id, &temp2.id, UUID_LENGTH);
638 LL_PREPEND(*staleDevList, tempNode);
641 *numOfDevices = counter;
642 sqlite3_finalize(stmt);
646 OCStackResult PDMClose()
650 res = sqlite3_close(g_db);
651 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
655 void PDMDestoryOicUuidLinkList(OCUuidList_t* ptr)
659 OCUuidList_t *tmp1 = NULL,*tmp2=NULL;
660 LL_FOREACH_SAFE(ptr, tmp1, tmp2)
662 LL_DELETE(ptr, tmp1);
668 void PDMDestoryStaleLinkList(OCPairList_t* ptr)
672 OCPairList_t *tmp1 = NULL,*tmp2=NULL;
673 LL_FOREACH_SAFE(ptr, tmp1, tmp2)
675 LL_DELETE(ptr, tmp1);
681 OCStackResult PDMIsLinkExists(const OicUuid_t* uuidOfDevice1, const OicUuid_t* uuidOfDevice2,
685 if (NULL == uuidOfDevice1 || NULL == uuidOfDevice2 || NULL == result)
687 return OC_STACK_INVALID_PARAM;
691 if (OC_STACK_OK != getIdForUUID(uuidOfDevice1, &id1))
693 OC_LOG(ERROR, TAG, "Requested value not found");
694 return OC_STACK_INVALID_PARAM;
697 if (OC_STACK_OK != getIdForUUID(uuidOfDevice2, &id2))
699 OC_LOG(ERROR, TAG, "Requested value not found");
700 return OC_STACK_INVALID_PARAM;
703 ASCENDING_ORDER(id1, id2);
705 sqlite3_stmt *stmt = 0;
707 res = sqlite3_prepare_v2(g_db, PDM_SQLITE_GET_LINKED_DEVICES,
708 strlen(PDM_SQLITE_GET_LINKED_DEVICES) + 1, &stmt, NULL);
709 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
711 res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_FIRST, id1);
712 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
714 res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_SECOND, id2);
715 PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
718 while(SQLITE_ROW == sqlite3_step(stmt))
720 OC_LOG(INFO, TAG, "Link already exists between devices");
723 sqlite3_finalize(stmt);