Merge branch 'security-summit' into 'master'
[iotivity.git] / resource / csdk / security / provisioning / src / provisioningdatabasemanager.c
1 /* *****************************************************************
2  *
3  * Copyright 2015 Samsung Electronics All Rights Reserved.
4  *
5  *
6  *
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
10  *
11  *     http://www.apache.org/licenses/LICENSE-2.0
12  *
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.
18  *
19  * *****************************************************************/
20
21 #include <stdio.h>
22 #include <stdbool.h>
23 #include <sqlite3.h>
24 #include <string.h>
25 #include <stdlib.h>
26
27 #include "logger.h"
28 #include "oic_malloc.h"
29 #include "provisioningdatabasemanager.h"
30 #include "pmutility.h"
31 #include "oic_string.h"
32 #include "utlist.h"
33
34
35 #define DB_FILE "PDM.db"
36
37 #define TAG "PDM"
38
39 #define PDM_STALE_STATE 1
40 #define PDM_ACTIVE_STATE 0
41
42 #define PDM_FIRST_INDEX 0
43 #define PDM_SECOND_INDEX 1
44
45 #define PDM_BIND_INDEX_FIRST 1
46 #define PDM_BIND_INDEX_SECOND 2
47 #define PDM_BIND_INDEX_THIRD 3
48
49 #define PDM_CREATE_T_DEVICE_LIST "create table T_DEVICE_LIST(ID INTEGER PRIMARY KEY AUTOINCREMENT,\
50                                   UUID BLOB NOT NULL UNIQUE);"
51
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));"
54 /**
55  * Macro to verify sqlite success.
56  * eg: VERIFY_NON_NULL(TAG, ptrData, ERROR,OC_STACK_ERROR);
57  */
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)
61
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
77 #define ASCENDING_ORDER(id1, id2) do{if( (id1) > (id2) )\
78   { int temp; temp = id1; id1 = id2; id2 = temp; }}while(0)
79
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)
83
84 static sqlite3 *g_db = NULL;
85 static bool gInit = false;  /* Only if we can open sqlite db successfully, gInit is true. */
86
87 /**
88  * function to create DB in case DB doesn't exists
89  */
90 static OCStackResult createDB(const char* path)
91 {
92
93     int result = 0;
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);
96
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);
99
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);
103
104     OC_LOG(INFO, TAG, "Created T_DEVICE_LINK_STATE");
105     gInit = true;
106     return OC_STACK_OK;
107 }
108
109
110 /**
111  * Function to begin any transaction
112  */
113 static OCStackResult begin()
114 {
115     int res = 0;
116     res = sqlite3_exec(g_db, PDM_SQLITE_TRANSACTION_BEGIN, NULL, NULL, NULL);
117     PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
118     return OC_STACK_OK;
119 }
120
121 /**
122  * Function to commit any transaction
123  */
124 static OCStackResult commit()
125 {
126     int res = 0;
127     res = sqlite3_exec(g_db, PDM_SQLITE_TRANSACTION_COMMIT, NULL, NULL, NULL);
128     PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
129     return OC_STACK_OK;
130 }
131
132 /**
133  * Function to rollback any transaction
134  */
135 static OCStackResult rollback()
136 {
137     int res = 0;
138     res = sqlite3_exec(g_db, PDM_SQLITE_TRANSACTION_ROLLBACK, NULL, NULL, NULL);
139     PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
140     return OC_STACK_OK;
141 }
142
143 /**
144  * Error log callback called by SQLite stack in case of error
145  */
146 void errLogCallback(void *pArg, int iErrCode, const char *zMsg)
147 {
148     (void) pArg;
149     (void) iErrCode;
150     (void) zMsg;
151     OC_LOG_V(DEBUG,TAG, "(%d) %s", iErrCode, zMsg);
152 }
153
154 OCStackResult PDMInit(const char *path)
155 {
156     int rc;
157     const char *dbPath = NULL;
158     if (SQLITE_OK !=  sqlite3_config(SQLITE_CONFIG_LOG, errLogCallback, NULL))
159     {
160         OC_LOG(INFO, TAG, "Unable to enable debug log of sqlite");
161     }
162
163     if (NULL == path || !*path)
164     {
165         dbPath = DB_FILE;
166     }
167     else
168     {
169         dbPath = path;
170     }
171     rc = sqlite3_open_v2(dbPath, &g_db, SQLITE_OPEN_READWRITE, NULL);
172     if (SQLITE_OK != rc)
173     {
174         OC_LOG_V(INFO, TAG, "ERROR: Can't open database: %s", sqlite3_errmsg(g_db));
175         return createDB(dbPath);
176     }
177     gInit = true;
178     return OC_STACK_OK;
179 }
180
181
182 OCStackResult PDMAddDevice(const OicUuid_t *UUID)
183 {
184     CHECK_PDM_INIT(TAG);
185     if (NULL == UUID)
186     {
187         return OC_STACK_INVALID_PARAM;
188     }
189
190     sqlite3_stmt *stmt = 0;
191     int res =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);
195
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);
198
199     res = sqlite3_step(stmt);
200     if (SQLITE_DONE != res)
201     {
202         if (SQLITE_CONSTRAINT == res)
203         {
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;
208         }
209         OC_LOG_V(ERROR, TAG, "Error Occured: %s",sqlite3_errmsg(g_db));
210         sqlite3_finalize(stmt);
211         return OC_STACK_ERROR;
212     }
213     sqlite3_finalize(stmt);
214     return OC_STACK_OK;
215 }
216
217 /**
218  *function to get Id for given UUID
219  */
220 static OCStackResult getIdForUUID(const OicUuid_t *UUID , int *id)
221 {
222     sqlite3_stmt *stmt = 0;
223     int res = 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);
226
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);
229
230     OC_LOG(DEBUG, TAG, "Binding Done");
231     while (SQLITE_ROW == sqlite3_step(stmt))
232     {
233         int tempId = sqlite3_column_int(stmt, PDM_FIRST_INDEX);
234         OC_LOG_V(DEBUG, TAG, "ID is %d", tempId);
235         *id = tempId;
236         sqlite3_finalize(stmt);
237         return OC_STACK_OK;
238     }
239     sqlite3_finalize(stmt);
240     return OC_STACK_INVALID_PARAM;
241 }
242
243 /**
244  * Function to check duplication of device's Device ID.
245  */
246 bool PDMIsDuplicateDevice(const OicUuid_t* UUID)
247 {
248     if(gInit)
249     {
250         if (NULL == UUID)
251         {
252             OC_LOG(ERROR, TAG, "UUID is NULL");
253             return true;
254         }
255
256         sqlite3_stmt *stmt = 0;
257         int res = 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);
260
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);
263
264         OC_LOG(DEBUG, TAG, "Binding Done");
265
266         while (SQLITE_ROW == sqlite3_step(stmt))
267         {
268             OC_LOG(ERROR, TAG, "UUID is duplicated");
269             sqlite3_finalize(stmt);
270             return true;
271         }
272         sqlite3_finalize(stmt);
273         return false;
274     }
275     OC_LOG(ERROR, TAG, "PDB is not initialized");
276     return true; // return true will stop futher process.
277 }
278
279 /**
280  * Function to add link in sqlite
281  */
282 static OCStackResult addlink(int id1, int id2)
283 {
284     sqlite3_stmt *stmt = 0;
285     int res = 0;
286     res = sqlite3_prepare_v2(g_db, PDM_SQLITE_INSERT_LINK_DATA,
287                               strlen(PDM_SQLITE_INSERT_LINK_DATA) + 1, &stmt, NULL);
288     PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
289
290     res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_FIRST, id1);
291     PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
292
293     res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_SECOND, id2);
294     PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
295
296     res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_THIRD, PDM_ACTIVE_STATE);
297     PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
298
299     if (sqlite3_step(stmt) != SQLITE_DONE)
300     {
301         OC_LOG_V(ERROR, TAG, "Error Occured: %s",sqlite3_errmsg(g_db));
302         sqlite3_finalize(stmt);
303         return OC_STACK_ERROR;
304     }
305     sqlite3_finalize(stmt);
306     return OC_STACK_OK;
307 }
308
309 OCStackResult PDMLinkDevices(const OicUuid_t *UUID1, const OicUuid_t *UUID2)
310 {
311     CHECK_PDM_INIT(TAG);
312     if (NULL == UUID1 || NULL == UUID2)
313     {
314         OC_LOG(ERROR, TAG, "Invalid PARAM");
315         return  OC_STACK_INVALID_PARAM;
316     }
317     int id1 = 0;
318     if (OC_STACK_OK != getIdForUUID(UUID1, &id1))
319     {
320         OC_LOG(ERROR, TAG, "Requested value not found");
321         return OC_STACK_INVALID_PARAM;
322     }
323     int id2 = 0;
324     if (OC_STACK_OK != getIdForUUID(UUID2, &id2))
325     {
326         OC_LOG(ERROR, TAG, "Requested value not found");
327         return OC_STACK_INVALID_PARAM;
328     }
329     ASCENDING_ORDER(id1, id2);
330     return addlink(id1, id2);
331 }
332
333 /**
334  * Function to remove created link
335  */
336 static OCStackResult removeLink(int id1, int id2)
337 {
338     int res = 0;
339     sqlite3_stmt *stmt = 0;
340     res = sqlite3_prepare_v2(g_db, PDM_SQLITE_DELETE_LINK, strlen(PDM_SQLITE_DELETE_LINK) + 1, &stmt, NULL);
341     PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
342
343     res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_FIRST, id1);
344     PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
345
346     res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_SECOND, id2);
347     PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
348
349     if (SQLITE_DONE != sqlite3_step(stmt))
350     {
351         OC_LOG_V(ERROR, TAG, "Error message: %s", sqlite3_errmsg(g_db));
352         sqlite3_finalize(stmt);
353         return OC_STACK_ERROR;
354     }
355     sqlite3_finalize(stmt);
356     return OC_STACK_OK;
357 }
358
359 OCStackResult PDMUnlinkDevices(const OicUuid_t *UUID1, const OicUuid_t *UUID2)
360 {
361     CHECK_PDM_INIT(TAG);
362     if (NULL == UUID1 || NULL == UUID2)
363     {
364         OC_LOG(ERROR, TAG, "Invalid PARAM");
365         return  OC_STACK_INVALID_PARAM;
366     }
367
368     int id1 = 0;
369     if (OC_STACK_OK != getIdForUUID(UUID1, &id1))
370     {
371         OC_LOG(ERROR, TAG, "Requested value not found");
372         return OC_STACK_INVALID_PARAM;
373     }
374
375     int id2 = 0;
376     if (OC_STACK_OK != getIdForUUID(UUID2, &id2))
377     {
378         OC_LOG(ERROR, TAG, "Requested value not found");
379         return OC_STACK_INVALID_PARAM;
380     }
381     ASCENDING_ORDER(id1, id2);
382     return removeLink(id1, id2);
383 }
384
385 static OCStackResult removeFromDeviceList(int id)
386 {
387     sqlite3_stmt *stmt = 0;
388     int res = 0;
389     res = sqlite3_prepare_v2(g_db, PDM_SQLITE_DELETE_DEVICE,
390                               strlen(PDM_SQLITE_DELETE_DEVICE) + 1, &stmt, NULL);
391     PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
392
393     res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_FIRST, id);
394     PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
395
396     if (sqlite3_step(stmt) != SQLITE_DONE)
397     {
398         OC_LOG_V(ERROR, TAG, "Error message: %s", sqlite3_errmsg(g_db));
399         sqlite3_finalize(stmt);
400         return OC_STACK_ERROR;
401     }
402     sqlite3_finalize(stmt);
403     return OC_STACK_OK;
404 }
405
406 OCStackResult PDMDeleteDevice(const OicUuid_t *UUID)
407 {
408     CHECK_PDM_INIT(TAG);
409     if (NULL == UUID)
410     {
411         return OC_STACK_INVALID_PARAM;
412     }
413     int id = 0;
414     if (OC_STACK_OK != getIdForUUID(UUID, &id))
415     {
416         OC_LOG(ERROR, TAG, "Requested value not found");
417         return OC_STACK_INVALID_PARAM;
418     }
419     begin();
420     if(OC_STACK_OK != removeFromDeviceList(id))
421     {
422         rollback();
423         OC_LOG(ERROR, TAG, "Requested value not found");
424         return OC_STACK_ERROR;
425     }
426     commit();
427     return OC_STACK_OK;
428 }
429
430
431 static OCStackResult updateLinkState(int id1, int id2, int state)
432 {
433     sqlite3_stmt *stmt = 0;
434     int res = 0 ;
435     res = sqlite3_prepare_v2(g_db, PDM_SQLITE_UPDATE_LINK,
436                               strlen(PDM_SQLITE_UPDATE_LINK) + 1, &stmt, NULL);
437     PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
438
439     res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_FIRST, state);
440     PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
441
442     res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_SECOND, id1);
443     PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
444
445     res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_THIRD, id2);
446     PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
447
448     if (SQLITE_DONE != sqlite3_step(stmt))
449     {
450         OC_LOG_V(ERROR, TAG, "Error message: %s", sqlite3_errmsg(g_db));
451         sqlite3_finalize(stmt);
452         return OC_STACK_ERROR;
453     }
454     sqlite3_finalize(stmt);
455     return OC_STACK_OK;
456 }
457
458 OCStackResult PDMSetLinkStale(const OicUuid_t* uuidOfDevice1, const OicUuid_t* uuidOfDevice2)
459 {
460     CHECK_PDM_INIT(TAG);
461     if (NULL == uuidOfDevice1 || NULL == uuidOfDevice2)
462     {
463         OC_LOG(ERROR, TAG, "Invalid PARAM");
464         return  OC_STACK_INVALID_PARAM;
465     }
466
467     int id1 = 0;
468     if (OC_STACK_OK != getIdForUUID(uuidOfDevice1, &id1))
469     {
470         OC_LOG(ERROR, TAG, "Requested value not found");
471         return OC_STACK_INVALID_PARAM;
472     }
473
474     int id2 = 0;
475     if (OC_STACK_OK != getIdForUUID(uuidOfDevice2, &id2))
476     {
477         OC_LOG(ERROR, TAG, "Requested value not found");
478         return OC_STACK_INVALID_PARAM;
479     }
480     ASCENDING_ORDER(id1, id2);
481     return updateLinkState(id1, id2, PDM_STALE_STATE);
482
483 }
484
485 OCStackResult PDMGetOwnedDevices(OCUuidList_t **uuidList, size_t *numOfDevices)
486 {
487     CHECK_PDM_INIT(TAG);
488     if (NULL != *uuidList)
489     {
490         OC_LOG(ERROR, TAG, "Not null list will cause memory leak");
491         return OC_STACK_INVALID_PARAM;
492     }
493     sqlite3_stmt *stmt = 0;
494     int res = 0;
495     res = sqlite3_prepare_v2(g_db, PDM_SQLITE_LIST_ALL_UUID,
496                               strlen(PDM_SQLITE_LIST_ALL_UUID) + 1, &stmt, NULL);
497     PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
498
499     int counter  = 0;
500     while (SQLITE_ROW == sqlite3_step(stmt))
501     {
502
503         const void *ptr = sqlite3_column_blob(stmt, PDM_FIRST_INDEX);
504         OicUuid_t *uid = (OicUuid_t *)ptr;
505         OCUuidList_t *temp = (OCUuidList_t *) OICCalloc(1,sizeof(OCUuidList_t));
506         if (NULL == temp)
507         {
508             OC_LOG_V(ERROR, TAG, "Memory allocation problem");
509             sqlite3_finalize(stmt);
510             return OC_STACK_NO_MEMORY;
511         }
512         memcpy(&temp->dev.id, uid->id, UUID_LENGTH);
513         LL_PREPEND(*uuidList,temp);
514         ++counter;
515     }
516     *numOfDevices = counter;
517     sqlite3_finalize(stmt);
518     return OC_STACK_OK;
519 }
520
521 static OCStackResult getUUIDforId(int id, OicUuid_t *uid)
522 {
523     sqlite3_stmt *stmt = 0;
524     int res = 0;
525     res = sqlite3_prepare_v2(g_db, PDM_SQLITE_GET_UUID,
526                               strlen(PDM_SQLITE_GET_UUID) + 1, &stmt, NULL);
527     PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
528
529     res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_FIRST, id);
530     PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
531
532     while (SQLITE_ROW == sqlite3_step(stmt))
533     {
534         const void *ptr = sqlite3_column_blob(stmt, PDM_FIRST_INDEX);
535         memcpy(uid, ptr, sizeof(OicUuid_t));
536     }
537     sqlite3_finalize(stmt);
538     return OC_STACK_OK;
539 }
540
541 OCStackResult PDMGetLinkedDevices(const OicUuid_t *UUID, OCUuidList_t **UUIDLIST, size_t *numOfDevices)
542 {
543     CHECK_PDM_INIT(TAG);
544     if (NULL != *UUIDLIST)
545     {
546         OC_LOG(ERROR, TAG, "Not null list will cause memory leak");
547         return OC_STACK_INVALID_PARAM;
548     }
549     if (NULL == UUID)
550     {
551         return OC_STACK_INVALID_PARAM;
552     }
553     int id = 0;
554     if (OC_STACK_OK != getIdForUUID(UUID, &id))
555     {
556         OC_LOG(ERROR, TAG, "Requested value not found");
557         return OC_STACK_INVALID_PARAM;
558     }
559
560     sqlite3_stmt *stmt = 0;
561     int res = 0;
562     res = sqlite3_prepare_v2(g_db, PDM_SQLITE_GET_LINKED_DEVICES,
563                               strlen(PDM_SQLITE_GET_LINKED_DEVICES) + 1, &stmt, NULL);
564     PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
565
566     res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_FIRST, id);
567     PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
568
569     res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_SECOND, id);
570     PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
571
572     int counter  = 0;
573     while (SQLITE_ROW == sqlite3_step(stmt))
574     {
575         int i1 = sqlite3_column_int(stmt, PDM_FIRST_INDEX);
576         int i2 = sqlite3_column_int(stmt, PDM_SECOND_INDEX);
577
578         OicUuid_t temp = {{0,}};
579         if (i1 != id)
580         {
581             getUUIDforId(i1, &temp);
582         }
583         if (i2 != id)
584         {
585             getUUIDforId(i2, &temp);
586         }
587
588         OCUuidList_t *tempNode = (OCUuidList_t *) OICCalloc(1,sizeof(OCUuidList_t));
589         if (NULL == tempNode)
590         {
591             OC_LOG(ERROR, TAG, "No Memory");
592             sqlite3_finalize(stmt);
593             return OC_STACK_NO_MEMORY;
594         }
595         memcpy(&tempNode->dev.id, &temp.id, UUID_LENGTH);
596         LL_PREPEND(*UUIDLIST,tempNode);
597         ++counter;
598     }
599     *numOfDevices = counter;
600      sqlite3_finalize(stmt);
601      return OC_STACK_OK;
602 }
603
604 OCStackResult PDMGetToBeUnlinkedDevices(OCPairList_t **staleDevList, size_t *numOfDevices)
605 {
606     CHECK_PDM_INIT(TAG);
607     if (NULL != *staleDevList)
608     {
609         OC_LOG(ERROR, TAG, "Not null list will cause memory leak");
610         return OC_STACK_INVALID_PARAM;
611     }
612
613     sqlite3_stmt *stmt = 0;
614     int res = 0;
615     res = sqlite3_prepare_v2(g_db, PDM_SQLITE_GET_STALE_INFO,
616                               strlen(PDM_SQLITE_GET_STALE_INFO) + 1, &stmt, NULL);
617     PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
618
619     res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_FIRST, PDM_STALE_STATE);
620     PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
621
622     int counter  = 0;
623     while (SQLITE_ROW == sqlite3_step(stmt))
624     {
625         int i1 = sqlite3_column_int(stmt, PDM_FIRST_INDEX);
626         int i2 = sqlite3_column_int(stmt, PDM_SECOND_INDEX);
627         OicUuid_t temp1 = {{0,}};
628         OicUuid_t temp2 = {{0,}};;
629         getUUIDforId(i1, &temp1);
630         getUUIDforId(i2, &temp2);
631
632         OCPairList_t *tempNode = (OCPairList_t *) OICCalloc(1, sizeof(OCPairList_t));
633         if (NULL == tempNode)
634         {
635             OC_LOG(ERROR, TAG, "No Memory");
636             sqlite3_finalize(stmt);
637             return OC_STACK_NO_MEMORY;
638         }
639         memcpy(&tempNode->dev.id, &temp1.id, UUID_LENGTH);
640         memcpy(&tempNode->dev2.id, &temp2.id, UUID_LENGTH);
641         LL_PREPEND(*staleDevList, tempNode);
642         ++counter;
643     }
644     *numOfDevices = counter;
645     sqlite3_finalize(stmt);
646     return OC_STACK_OK;
647 }
648
649 OCStackResult PDMClose()
650 {
651     CHECK_PDM_INIT(TAG);
652     int res = 0;
653     res = sqlite3_close(g_db);
654     PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR);
655     return OC_STACK_OK;
656 }
657
658 void PDMDestoryOicUuidLinkList(OCUuidList_t* ptr)
659 {
660     if(ptr)
661     {
662         OCUuidList_t *tmp1 = NULL,*tmp2=NULL;
663         LL_FOREACH_SAFE(ptr, tmp1, tmp2)
664         {
665             LL_DELETE(ptr, tmp1);
666             OICFree(tmp1);
667         }
668     }
669 }
670
671 void PDMDestoryStaleLinkList(OCPairList_t* ptr)
672 {
673     if(ptr)
674     {
675         OCPairList_t *tmp1 = NULL,*tmp2=NULL;
676         LL_FOREACH_SAFE(ptr, tmp1, tmp2)
677         {
678             LL_DELETE(ptr, tmp1);
679             OICFree(tmp1);
680         }
681     }
682 }