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 }