resource/csdk/resource-directory/src/internal/rd_database.c

   1 //******************************************************************
   2 //
   3 // Copyright 2016 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 a
  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 <stdlib.h>
  22 #include <string.h>
  23
  24 #include "sqlite3.h"
  25 #include "logger.h"
  26 #include "ocpayload.h"
  27 #include "octypes.h"
  28 #include "oic_malloc.h"
  29 #include "oic_string.h"
  30 #include "ocstackinternal.h"
  31
  32 #ifdef RD_SERVER
  33
  34 #define TAG "OIC_RD_DATABASE"
  35
  36 static sqlite3 *gRDDB = NULL;
  37
  38 static const uint8_t device_index = 2;
  39 static const uint8_t ttl_index = 3;
  40 static const uint8_t address_index = 4;
  41
  42 static const uint8_t uri_index = 2;
  43 static const uint8_t p_index = 5;
  44 static const uint8_t mt_index = 7;
  45 static const uint8_t d_index = 8;
  46
  47 static const uint8_t rt_value_index = 1;
  48 static const uint8_t rt_link_id_index = 2;
  49
  50 static const uint8_t if_value_index = 1;
  51 static const uint8_t if_link_id_index = 2;
  52
  53 #define VERIFY_SQLITE(arg) \
  54     if (SQLITE_OK != (arg)) \
  55     { \
  56         OIC_LOG_V(ERROR, TAG, "Error in " #arg ", Error Message: %s",  sqlite3_errmsg(gRDDB)); \
  57         sqlite3_exec(gRDDB, "ROLLBACK", NULL, NULL, NULL); \
  58         return OC_STACK_ERROR; \
  59     }
  60
  61 #define CHECK_DATABASE_INIT \
  62     if (!gRDDB) \
  63     { \
  64         OIC_LOG(ERROR, TAG, "Database is not initialized."); \
  65         return OC_STACK_ERROR; \
  66     }
  67
  68 #define STR(a) #a
  69 #define XSTR(a) STR(a)
  70
  71 #define RD_TABLE \
  72     "create table RD_DEVICE_LIST(ID INTEGER PRIMARY KEY AUTOINCREMENT, " \
  73     XSTR(OC_RSRVD_DEVICE_ID) " UNIQUE NOT NULL, " \
  74     XSTR(OC_RSRVD_TTL) " NOT NULL, " \
  75     "ADDRESS NOT NULL);"
  76
  77 #define RD_LL_TABLE  \
  78     "create table RD_DEVICE_LINK_LIST("XSTR(OC_RSRVD_INS)" INTEGER PRIMARY KEY AUTOINCREMENT, " \
  79     XSTR(OC_RSRVD_HREF)  "," \
  80     XSTR(OC_RSRVD_REL)   ","  \
  81     XSTR(OC_RSRVD_TITLE) "," \
  82     XSTR(OC_RSRVD_BITMAP)"," \
  83     XSTR(OC_RSRVD_TTL)   "," \
  84     XSTR(OC_RSRVD_MEDIA_TYPE) "," \
  85     "DEVICE_ID INT NOT NULL, " \
  86     "FOREIGN KEY(DEVICE_ID) REFERENCES RD_DEVICE_LIST(ID) ON DELETE CASCADE );"
  87
  88 #define RD_RT_TABLE \
  89     "create table RD_LINK_RT(" XSTR(OC_RSRVD_RESOURCE_TYPE) " NOT NULL, " \
  90     "LINK_ID INT NOT NULL, "\
  91     "FOREIGN KEY("XSTR(LINK_ID)") REFERENCES RD_DEVICE_LINK_LIST("XSTR(OC_RSRVD_INS)") " \
  92     "ON DELETE CASCADE);"
  93
  94 #define RD_IF_TABLE \
  95     "create table RD_LINK_IF(" XSTR(OC_RSRVD_INTERFACE) " NOT NULL, " \
  96     "LINK_ID INT NOT NULL, "\
  97     "FOREIGN KEY("XSTR(LINK_ID)") REFERENCES RD_DEVICE_LINK_LIST("XSTR(OC_RSRVD_INS)") " \
  98     "ON DELETE CASCADE);"
  99
 100 static void errorCallback(void *arg, int errCode, const char *errMsg)
 101 {
 102     OC_UNUSED(arg);
 103     OC_UNUSED(errCode);
 104     OC_UNUSED(errMsg);
 105     OIC_LOG_V(ERROR, TAG, "SQLLite Error: %s : %d", errMsg, errCode);
 106 }
 107
 108 OCStackResult OCRDDatabaseInit()
 109 {
 110     if (SQLITE_OK == sqlite3_config(SQLITE_CONFIG_LOG, errorCallback))
 111     {
 112         OIC_LOG_V(INFO, TAG, "SQLite debugging log initialized.");
 113     }
 114
 115     int sqlRet;
 116     sqlRet = sqlite3_open_v2(OCRDDatabaseGetStorageFilename(), &gRDDB,
 117                              SQLITE_OPEN_READWRITE, NULL);
 118     if (SQLITE_OK != sqlRet)
 119     {
 120         OIC_LOG(DEBUG, TAG, "RD database file did not open, as no table exists.");
 121         OIC_LOG(DEBUG, TAG, "RD creating new table.");
 122         sqlRet = sqlite3_open_v2(OCRDDatabaseGetStorageFilename(), &gRDDB,
 123                                  SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL);
 124         if (SQLITE_OK == sqlRet)
 125         {
 126             VERIFY_SQLITE(sqlite3_exec(gRDDB, RD_TABLE, NULL, NULL, NULL));
 127             OIC_LOG(DEBUG, TAG, "RD created RD_DEVICE_LIST table.");
 128
 129             VERIFY_SQLITE(sqlite3_exec(gRDDB, RD_LL_TABLE, NULL, NULL, NULL));
 130             OIC_LOG(DEBUG, TAG, "RD created RD_DEVICE_LINK_LIST table.");
 131
 132             VERIFY_SQLITE(sqlite3_exec(gRDDB, RD_RT_TABLE, NULL, NULL, NULL));
 133             OIC_LOG(DEBUG, TAG, "RD created RD_LINK_RT table.");
 134
 135             VERIFY_SQLITE(sqlite3_exec(gRDDB, RD_IF_TABLE, NULL, NULL, NULL));
 136             OIC_LOG(DEBUG, TAG, "RD created RD_LINK_IF table.");
 137             sqlRet = SQLITE_OK;
 138         }
 139     }
 140
 141     if (sqlRet == SQLITE_OK)
 142     {
 143         sqlite3_stmt *stmt = 0;
 144         VERIFY_SQLITE(sqlite3_prepare_v2 (gRDDB, "PRAGMA foreign_keys = ON;", -1, &stmt, NULL));
 145
 146         if (SQLITE_DONE != sqlite3_step(stmt))
 147         {
 148             sqlite3_finalize(stmt);
 149             return OC_STACK_ERROR;
 150         }
 151
 152         VERIFY_SQLITE(sqlite3_finalize(stmt));
 153     }
 154
 155     return OC_STACK_OK;
 156 }
 157
 158 OCStackResult OCRDDatabaseClose()
 159 {
 160     CHECK_DATABASE_INIT;
 161     VERIFY_SQLITE(sqlite3_close_v2(gRDDB));
 162     return OC_STACK_OK;
 163 }
 164
 165 static int storeResourceType(char **link, size_t size, uint8_t rowid)
 166 {
 167     int res = 1;
 168     VERIFY_SQLITE(sqlite3_exec(gRDDB, "BEGIN TRANSACTION", NULL, NULL, NULL));
 169
 170     const char *insertRT = "INSERT INTO RD_LINK_RT VALUES(?, ?)";
 171     sqlite3_stmt *stmtRT = 0;
 172
 173     for (size_t i = 0; i < size; i++)
 174     {
 175         VERIFY_SQLITE(sqlite3_prepare_v2(gRDDB, insertRT, strlen(insertRT) + 1, &stmtRT, NULL));
 176         if (link[i])
 177         {
 178             VERIFY_SQLITE(sqlite3_bind_text(stmtRT, rt_value_index, link[i],
 179                                             strlen(link[i]), SQLITE_STATIC));
 180
 181             VERIFY_SQLITE(sqlite3_bind_int(stmtRT, rt_link_id_index, rowid));
 182         }
 183         if (sqlite3_step(stmtRT) != SQLITE_DONE)
 184         {
 185             sqlite3_exec(gRDDB, "ROLLBACK", NULL, NULL, NULL);
 186             sqlite3_finalize(stmtRT);
 187             return res;
 188         }
 189     }
 190
 191     VERIFY_SQLITE(sqlite3_finalize(stmtRT));
 192
 193     VERIFY_SQLITE(sqlite3_exec(gRDDB, "COMMIT", NULL, NULL, NULL));
 194     res = SQLITE_OK;
 195
 196     return res;
 197 }
 198
 199
 200 static int storeInterfaceType(char **link, size_t size, uint8_t rowid)
 201 {
 202     int res = 1;
 203
 204     VERIFY_SQLITE(sqlite3_exec(gRDDB, "BEGIN TRANSACTION", NULL, NULL, NULL));
 205
 206     const char *insertIF = "INSERT INTO RD_LINK_IF VALUES(?, ?)";
 207     sqlite3_stmt *stmtIF = 0;
 208
 209     for (size_t i = 0; i < size; i++)
 210     {
 211         VERIFY_SQLITE(sqlite3_prepare_v2(gRDDB, insertIF, strlen(insertIF) + 1, &stmtIF, NULL));
 212
 213         if (link[i])
 214         {
 215             VERIFY_SQLITE(sqlite3_bind_text(stmtIF, if_value_index, link[i], strlen(link[i]), SQLITE_STATIC));
 216             VERIFY_SQLITE(sqlite3_bind_int(stmtIF, if_link_id_index, rowid));
 217         }
 218         if (sqlite3_step(stmtIF) != SQLITE_DONE)
 219         {
 220             sqlite3_exec(gRDDB, "ROLLBACK", NULL, NULL, NULL);
 221             res = sqlite3_finalize(stmtIF);
 222             return res;
 223         }
 224     }
 225     VERIFY_SQLITE(sqlite3_finalize(stmtIF));
 226
 227     VERIFY_SQLITE(sqlite3_exec(gRDDB, "COMMIT", NULL, NULL, NULL));
 228     res = SQLITE_OK;
 229
 230     return res;
 231 }
 232
 233 static int storeLinkPayload(OCRepPayload *rdPayload, int64_t rowid)
 234 {
 235     int res = 1 ;
 236     size_t j = 0;
 237
 238     /*
 239      * Iterate over the properties manually rather than OCRepPayloadGetPropObjectArray to avoid
 240      * the clone since we want to insert the 'ins' values into the payload.
 241      */
 242     OCRepPayloadValue *links;
 243     for (links = rdPayload->values; links; links = links->next)
 244     {
 245         if (0 == strcmp(links->name, OC_RSRVD_LINKS))
 246         {
 247             if (links->type != OCREP_PROP_ARRAY || links->arr.type != OCREP_PROP_OBJECT)
 248             {
 249                 links = NULL;
 250             }
 251             break;
 252         }
 253     }
 254     if (links != NULL)
 255     {
 256         const char *insertDeviceLLList = "INSERT INTO RD_DEVICE_LINK_LIST VALUES(?,?,?,?,?,?,?,?)";
 257         sqlite3_stmt *stmt = 0;
 258
 259         for (size_t i = 0; i < links->arr.dimensions[0]; i++)
 260         {
 261             VERIFY_SQLITE(sqlite3_prepare_v2(gRDDB, insertDeviceLLList, strlen(insertDeviceLLList) + 1, &stmt, NULL));
 262             VERIFY_SQLITE(sqlite3_exec(gRDDB, "BEGIN TRANSACTION", NULL, NULL, NULL));
 263
 264             OCRepPayload *link = links->arr.objArray[i];
 265             char *uri = NULL;
 266             if (OCRepPayloadGetPropString(link, OC_RSRVD_HREF, &uri))
 267             {
 268                 VERIFY_SQLITE(sqlite3_bind_text(stmt, uri_index, uri, strlen(uri), SQLITE_STATIC));
 269             }
 270
 271             OCRepPayload *p = NULL;
 272             if (OCRepPayloadGetPropObject(link, OC_RSRVD_POLICY, &p))
 273             {
 274                 int64_t bm = 0;
 275                 if (OCRepPayloadGetPropInt(p, OC_RSRVD_BITMAP, &bm))
 276                 {
 277                     VERIFY_SQLITE(sqlite3_bind_int(stmt, p_index, bm));
 278                 }
 279             }
 280
 281             size_t mtDim[MAX_REP_ARRAY_DEPTH] = {0};
 282             char **mediaType = NULL;
 283             if (OCRepPayloadGetStringArray(link, OC_RSRVD_MEDIA_TYPE, &mediaType, mtDim))
 284             {
 285                 VERIFY_SQLITE(sqlite3_bind_text(stmt, mt_index, mediaType[0], strlen(mediaType[0]), SQLITE_STATIC));
 286             }
 287
 288             VERIFY_SQLITE(sqlite3_bind_int(stmt, d_index, rowid));
 289
 290             size_t rtDim[MAX_REP_ARRAY_DEPTH] = {0};
 291             char **rt = NULL;
 292             OCRepPayloadGetStringArray(link, OC_RSRVD_RESOURCE_TYPE, &rt, rtDim);
 293
 294             size_t itfDim[MAX_REP_ARRAY_DEPTH] = {0};
 295             char **itf = NULL;
 296             OCRepPayloadGetStringArray(link, OC_RSRVD_INTERFACE, &itf, itfDim);
 297
 298             if (sqlite3_step(stmt) != SQLITE_DONE)
 299             {
 300                 sqlite3_exec(gRDDB, "ROLLBACK", NULL, NULL, NULL);
 301                 sqlite3_finalize(stmt);
 302                 return res;
 303             }
 304             VERIFY_SQLITE(sqlite3_exec(gRDDB, "COMMIT", NULL, NULL, NULL));
 305
 306             int64_t ins = sqlite3_last_insert_rowid(gRDDB);
 307             if (!OCRepPayloadSetPropInt(link, OC_RSRVD_INS, ins))
 308             {
 309                 OIC_LOG_V(ERROR, TAG, "Error setting 'ins' value");
 310                 return OC_STACK_ERROR;
 311             }
 312             VERIFY_SQLITE(storeResourceType(rt, rtDim[0], ins));
 313             VERIFY_SQLITE(storeInterfaceType(itf, itfDim[0], ins));
 314             OICFree(uri);
 315             OCPayloadDestroy((OCPayload *)p);
 316             for (j = 0; j < mtDim[0]; j++)
 317             {
 318                 OICFree(mediaType[j]);
 319             }
 320             OICFree(mediaType);
 321
 322             for (j = 0; j < rtDim[0]; j++)
 323             {
 324                 OICFree(rt[j]);
 325             }
 326             OICFree(rt);
 327
 328             for (j = 0; j < itfDim[0]; j++)
 329             {
 330                 OICFree(itf[j]);
 331             }
 332             OICFree(itf);
 333
 334         }
 335
 336         VERIFY_SQLITE(sqlite3_finalize(stmt));
 337         res = SQLITE_OK;
 338     }
 339     return res;
 340 }
 341
 342 OCStackResult OCRDDatabaseStoreResources(OCRepPayload *payload, const OCDevAddr *address)
 343 {
 344     CHECK_DATABASE_INIT;
 345
 346     VERIFY_SQLITE(sqlite3_exec(gRDDB, "BEGIN TRANSACTION", NULL, NULL, NULL));
 347     const char *insertDeviceList = "INSERT INTO RD_DEVICE_LIST VALUES(?,?,?,?)";
 348     sqlite3_stmt *stmt = 0;
 349     VERIFY_SQLITE(sqlite3_prepare_v2(gRDDB, insertDeviceList, strlen(insertDeviceList) + 1, &stmt, NULL));
 350
 351     char *deviceid = NULL;
 352     if (OCRepPayloadGetPropString(payload, OC_RSRVD_DEVICE_ID, &deviceid))
 353     {
 354         VERIFY_SQLITE(sqlite3_bind_text(stmt, device_index, deviceid, strlen(deviceid), SQLITE_STATIC));
 355     }
 356
 357     int64_t ttl = 0;
 358     if (OCRepPayloadGetPropInt(payload, OC_RSRVD_DEVICE_TTL, &ttl))
 359     {
 360         VERIFY_SQLITE(sqlite3_bind_int(stmt, ttl_index, ttl));
 361     }
 362
 363     char rdAddress[MAX_URI_LENGTH];
 364     snprintf(rdAddress, MAX_URI_LENGTH, "%s:%d", address->addr, address->port);
 365     OIC_LOG_V(DEBUG, TAG, "Address: %s", rdAddress);
 366     VERIFY_SQLITE(sqlite3_bind_text(stmt, address_index, rdAddress, strlen(rdAddress), SQLITE_STATIC));
 367
 368     if (sqlite3_step(stmt) != SQLITE_DONE)
 369     {
 370         sqlite3_exec(gRDDB, "ROLLBACK", NULL, NULL, NULL);
 371         sqlite3_finalize(stmt);
 372         return OC_STACK_ERROR;
 373     }
 374     VERIFY_SQLITE(sqlite3_finalize(stmt));
 375
 376     VERIFY_SQLITE(sqlite3_exec(gRDDB, "COMMIT", NULL, NULL, NULL));
 377
 378     int64_t rowid = sqlite3_last_insert_rowid(gRDDB);
 379     if (rowid)
 380     {
 381         VERIFY_SQLITE(storeLinkPayload(payload, rowid));
 382     }
 383     OICFree(deviceid);
 384     return OC_STACK_OK;
 385 }
 386
 387 OCStackResult OCRDDatabaseDeleteResources(const char *deviceId, const uint8_t *instanceIds, uint8_t nInstanceIds)
 388 {
 389     CHECK_DATABASE_INIT;
 390
 391     VERIFY_SQLITE(sqlite3_exec(gRDDB, "BEGIN TRANSACTION", NULL, NULL, NULL));
 392     sqlite3_stmt *stmt = 0;
 393     if (!instanceIds || !nInstanceIds)
 394     {
 395         char *delDevice = "DELETE FROM RD_DEVICE_LIST WHERE "XSTR(OC_RSRVD_DEVICE_ID)" = ?";
 396         VERIFY_SQLITE(sqlite3_prepare_v2(gRDDB, delDevice, strlen(delDevice) + 1, &stmt, NULL));
 397
 398         VERIFY_SQLITE(sqlite3_bind_text(stmt, 1, deviceId, strlen(deviceId), SQLITE_STATIC));
 399     }
 400     else
 401     {
 402         const char pre[] = "DELETE FROM RD_DEVICE_LINK_LIST "
 403             "WHERE ins IN ("
 404             "SELECT RD_DEVICE_LINK_LIST.ins FROM RD_DEVICE_LINK_LIST "
 405             "INNER JOIN RD_DEVICE_LIST ON RD_DEVICE_LINK_LIST.DEVICE_ID=RD_DEVICE_LIST.ID "
 406             "WHERE RD_DEVICE_LIST.di = ? AND RD_DEVICE_LINK_LIST.ins IN (";
 407         size_t inLen = nInstanceIds + (nInstanceIds - 1);
 408         const char post[] = "))";
 409         size_t len = sizeof(pre) + inLen + sizeof(post);
 410         char *delResource = OICCalloc(len, 1);
 411         if (!delResource)
 412         {
 413             OIC_LOG(ERROR, TAG, "SQL query is NULL");
 414             return OC_STACK_ERROR;
 415         }
 416         OICStrcat(delResource, len, pre);
 417         OICStrcat(delResource, len, "?");
 418         for (uint8_t i = 1; i < nInstanceIds; ++i)
 419         {
 420             OICStrcat(delResource, len, ",?");
 421         }
 422         OICStrcat(delResource, len, post);
 423         int prepareResult = sqlite3_prepare_v2(gRDDB, delResource, strlen(delResource) + 1, &stmt, NULL);
 424         OICFree(delResource);
 425         VERIFY_SQLITE(prepareResult);
 426
 427         VERIFY_SQLITE(sqlite3_bind_text(stmt, 1, deviceId, strlen(deviceId), SQLITE_STATIC));
 428         for (uint8_t i = 0; i < nInstanceIds; ++i)
 429         {
 430             VERIFY_SQLITE(sqlite3_bind_int(stmt, 2 + i, instanceIds[i]));
 431         }
 432     }
 433     if (sqlite3_step(stmt) != SQLITE_DONE)
 434     {
 435         sqlite3_exec(gRDDB, "ROLLBACK", NULL, NULL, NULL);
 436         sqlite3_finalize(stmt);
 437         return OC_STACK_ERROR;
 438     }
 439     VERIFY_SQLITE(sqlite3_finalize(stmt));
 440     VERIFY_SQLITE(sqlite3_exec(gRDDB, "COMMIT", NULL, NULL, NULL));
 441
 442     return OC_STACK_OK;
 443 }
 444
 445 #endif