ua-daemon/src/ua-manager-device-db.c

   1 /*
   2  * Copyright (c) 2018 Samsung Electronics Co., Ltd. All rights reserved.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License")
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 #include <sqlite3.h>
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <string.h>
  22 #include <dlfcn.h>
  23
  24 #include "ua-manager-common.h"
  25 #include "ua-manager-database.h"
  26
  27 #define SELECT_ALL_DEVICES "SELECT device_id, tech_type, address, " \
  28         "ip_address, timestamp, presence_state, os_type, " \
  29         "user_id, discriminant, service_id, purpose, duid, device_icon FROM devices"
  30
  31 #define SELECT_DEVICE "SELECT device_id, tech_type, address, " \
  32         "ip_address, timestamp, presence_state, os_type, " \
  33         "user_id, discriminant, service_id, purpose, duid, device_icon FROM devices " \
  34         "WHERE device_id = ? AND tech_type = ? AND address = ?"
  35
  36 #define SELECT_DEVICE_NUMBER "SELECT device_number FROM devices " \
  37         "WHERE device_id = ? AND tech_type = ? AND address = ?"
  38
  39 #define INSERT_DEVICE "insert into devices " \
  40         "(device_id, tech_type, address, ip_address, timestamp, " \
  41         "presence_state, os_type, user_id, discriminant, service_id, " \
  42         "purpose, duid, device_icon)" \
  43         "values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"
  44
  45 #define UPDATE_TIMESTAMP "UPDATE devices " \
  46         "SET timestamp = ? WHERE device_id = ? AND tech_type = ? AND address = ?"
  47
  48 #define UPDATE_PRESENCE "UPDATE devices " \
  49         "SET presence_state = ? WHERE device_id = ? AND tech_type = ? AND address = ?"
  50
  51 #define UPDATE_IP_ADDRESS "UPDATE devices " \
  52         "SET ip_address = ? WHERE device_id = ? AND tech_type = ? AND address = ?"
  53
  54 #define UPDATE_DEVICE "UPDATE devices " \
  55         "SET (os_type, discriminant, ip_address, service_id, " \
  56         "purpose, duid, device_icon) = (?, ?, ?, ?, ?, ?, ?) " \
  57         "WHERE device_id = ? AND tech_type = ? AND address = ?"
  58
  59 #define DELETE_ALL_DEVICES "delete from devices "
  60
  61 #define DELETE_DEVICE_INFO "delete from devices " \
  62         "WHERE device_id = ? AND tech_type = ? AND address = ?"
  63
  64 static void __uam_device_finalize_delete(void);
  65
  66 /* DELETE statements */
  67 static sqlite3_stmt *delete_all_devices;
  68 static sqlite3_stmt *delete_device_info;
  69
  70 /* SELECT statements */
  71 static sqlite3_stmt *select_all_devices;
  72 static sqlite3_stmt *select_device;
  73 static sqlite3_stmt *select_device_number;
  74
  75 /* UPDATE statements */
  76 static sqlite3_stmt *update_timestamp;
  77 static sqlite3_stmt *update_presence;
  78 static sqlite3_stmt *update_ip_address;
  79 static sqlite3_stmt *update_device;
  80
  81 /* INSERT statements */
  82 static sqlite3_stmt *insert_device_info;
  83
  84 extern sqlite3 *database_handle;
  85
  86 static void __uam_device_finalize_delete(void)
  87 {
  88         FUNC_ENTRY;
  89
  90         FINALIZE(delete_all_devices);
  91         FINALIZE(delete_device_info);
  92
  93         FUNC_EXIT;
  94 }
  95
  96 static void __uam_device_finalize_select(void)
  97 {
  98         FUNC_ENTRY;
  99
 100         FINALIZE(select_all_devices);
 101         FINALIZE(select_device);
 102         FINALIZE(select_device_number);
 103
 104         FUNC_EXIT;
 105 }
 106
 107 static void __uam_device_finalize_insert(void)
 108 {
 109         FUNC_ENTRY;
 110
 111         FINALIZE(insert_device_info);
 112
 113         FUNC_EXIT;
 114 }
 115
 116 static void __uam_device_finalize_update(void)
 117 {
 118         FUNC_ENTRY;
 119
 120         FINALIZE(update_timestamp);
 121         FINALIZE(update_presence);
 122         FINALIZE(update_ip_address);
 123         FINALIZE(update_device);
 124
 125         FUNC_EXIT;
 126 }
 127
 128 static int __uam_device_prepare_delete(sqlite3 *db)
 129 {
 130         FUNC_ENTRY;
 131         int rc;
 132         static int initialized;
 133
 134         if (initialized) {
 135                 FUNC_EXIT;
 136                 return SQLITE_OK;
 137         }
 138
 139         PREPARE_QUERY(rc, db, delete_all_devices,
 140                 DELETE_ALL_DEVICES,     __uam_device_finalize_delete);
 141         PREPARE_QUERY(rc, db, delete_device_info,
 142                 DELETE_DEVICE_INFO, __uam_device_finalize_delete);
 143
 144         initialized = 1;
 145         FUNC_EXIT;
 146         return rc;
 147 }
 148
 149 static int __uam_device_prepare_select(sqlite3 *db)
 150 {
 151         FUNC_ENTRY;
 152         int rc;
 153         static int initialized;
 154
 155         if (initialized) {
 156                 FUNC_EXIT;
 157                 return SQLITE_OK;
 158         }
 159
 160         PREPARE_QUERY(rc, db, select_all_devices,
 161                 SELECT_ALL_DEVICES, __uam_device_finalize_select);
 162         PREPARE_QUERY(rc, db, select_device,
 163                 SELECT_DEVICE, __uam_device_finalize_select);
 164         PREPARE_QUERY(rc, db, select_device_number,
 165                 SELECT_DEVICE_NUMBER, __uam_device_finalize_select);
 166
 167         initialized = 1;
 168         FUNC_EXIT;
 169         return rc;
 170 }
 171
 172 static int __uam_device_prepare_update(sqlite3 *db)
 173 {
 174         FUNC_ENTRY;
 175         int rc;
 176         static int initialized;
 177
 178         if (initialized) {
 179                 FUNC_EXIT;
 180                 return SQLITE_OK;
 181         }
 182
 183         PREPARE_QUERY(rc, db, update_timestamp,
 184                 UPDATE_TIMESTAMP, __uam_device_finalize_update);
 185         PREPARE_QUERY(rc, db, update_presence,
 186                 UPDATE_PRESENCE, __uam_device_finalize_update);
 187         PREPARE_QUERY(rc, db, update_ip_address,
 188                 UPDATE_IP_ADDRESS, __uam_device_finalize_update);
 189         PREPARE_QUERY(rc, db, update_device,
 190                 UPDATE_DEVICE, __uam_device_finalize_update);
 191
 192         initialized = 1;
 193         FUNC_EXIT;
 194         return rc;
 195 }
 196
 197 static int __uam_device_prepare_insert(sqlite3 *db)
 198 {
 199         FUNC_ENTRY;
 200         int rc;
 201         static int initialized;
 202
 203         if (initialized) {
 204                 FUNC_EXIT;
 205                 return SQLITE_OK;
 206         }
 207
 208         PREPARE_QUERY(rc, db, insert_device_info,
 209                 INSERT_DEVICE, __uam_device_finalize_insert);
 210
 211         initialized = 1;
 212         FUNC_EXIT;
 213         return rc;
 214 }
 215
 216 static int __uam_device_table_devicesinfo_prepare(sqlite3 *db)
 217 {
 218         FUNC_ENTRY;
 219
 220         int error_code = UAM_ERROR_NONE;
 221
 222         if (db == NULL) {
 223                 FUNC_EXIT;
 224                 return UAM_ERROR_DB_FAILED;
 225         }
 226
 227         DB_ACTION(__uam_device_prepare_delete(db), error_code, handle_error);
 228         DB_ACTION(__uam_device_prepare_select(db), error_code, handle_error);
 229         DB_ACTION(__uam_device_prepare_update(db), error_code, handle_error);
 230         DB_ACTION(__uam_device_prepare_insert(db), error_code, handle_error);
 231
 232 handle_error:
 233         FUNC_EXIT;
 234         return error_code;
 235 }
 236
 237 static void __uam_device_table_devicesinfo_finalize(void)
 238 {
 239         FUNC_ENTRY;
 240         __uam_device_finalize_delete();
 241         __uam_device_finalize_select();
 242         __uam_device_finalize_insert();
 243         FUNC_EXIT;
 244 }
 245
 246 int _uam_device_db_deinitialize(void)
 247 {
 248         FUNC_ENTRY;
 249
 250         retv_if(NULL == database_handle, UAM_ERROR_NONE);
 251
 252         __uam_device_table_devicesinfo_finalize();
 253         sqlite3_close(database_handle);
 254
 255         FUNC_EXIT;
 256         return UAM_ERROR_NONE;
 257 }
 258
 259 int _uam_device_db_initialize(void)
 260 {
 261         FUNC_ENTRY;
 262
 263         EXEC(UAM_ERROR_NONE, __uam_device_table_devicesinfo_prepare(database_handle), handle_error);
 264
 265         FUNC_EXIT;
 266         return UAM_ERROR_NONE;
 267
 268 handle_error:
 269         _uam_device_db_deinitialize();
 270         FUNC_EXIT;
 271         return UAM_ERROR_DB_FAILED;
 272 }
 273
 274 int _uam_device_db_update_device_ip_address(char *device_id, int tech_type,
 275         char *address,
 276                 char *ip_address)
 277 {
 278         int error_code = UAM_ERROR_NONE;
 279         sqlite3_stmt *stmt = update_ip_address;
 280         int sql_ret = SQLITE_OK;
 281
 282         retv_if(NULL == device_id, UAM_ERROR_INVALID_PARAMETER);
 283         retv_if(NULL == address, UAM_ERROR_INVALID_PARAMETER);
 284         retv_if(NULL == ip_address, UAM_ERROR_INVALID_PARAMETER);
 285
 286         DB_ACTION(sqlite3_bind_text(stmt, 1, ip_address, -1, SQLITE_TRANSIENT),
 287                 error_code, handle_error);
 288         DB_ACTION(sqlite3_bind_text(stmt, 2, device_id, -1, SQLITE_TRANSIENT),
 289                 error_code, handle_error);
 290         DB_ACTION(sqlite3_bind_int(stmt, 3, tech_type),
 291                 error_code, handle_error);
 292         DB_ACTION(sqlite3_bind_text(stmt, 4, address, -1, SQLITE_TRANSIENT),
 293                 error_code, handle_error);
 294
 295         sql_ret = sqlite3_step(stmt);
 296         if (sql_ret != SQLITE_DONE) {
 297                 UAM_ERR("Failed to update ip address [%d:%s]",
 298                         sql_ret, sqlite3_errmsg(database_handle));
 299
 300                 error_code = UAM_ERROR_DB_FAILED;
 301                 goto handle_error;
 302         }
 303
 304         UAM_DBG("ip address updated [%s]", ip_address);
 305
 306 handle_error:
 307         sqlite3_reset(stmt);
 308         return error_code;
 309 }
 310
 311 int _uam_device_db_update_device_presence(char *device_id, int tech_type,
 312         char *address, int presence_state)
 313 {
 314         int error_code = UAM_ERROR_NONE;
 315         sqlite3_stmt *stmt = update_presence;
 316         int sql_ret = SQLITE_OK;
 317
 318         retv_if(NULL == device_id, UAM_ERROR_INVALID_PARAMETER);
 319         retv_if(NULL == address, UAM_ERROR_INVALID_PARAMETER);
 320
 321         DB_ACTION(sqlite3_bind_int(stmt, 1, presence_state),
 322                 error_code, handle_error);
 323         DB_ACTION(sqlite3_bind_text(stmt, 2, device_id, -1, SQLITE_TRANSIENT),
 324                 error_code, handle_error);
 325         DB_ACTION(sqlite3_bind_int(stmt, 3, tech_type),
 326                 error_code, handle_error);
 327         DB_ACTION(sqlite3_bind_text(stmt, 4, address, -1, SQLITE_TRANSIENT),
 328                 error_code, handle_error);
 329
 330         sql_ret = sqlite3_step(stmt);
 331         if (sql_ret != SQLITE_DONE) {
 332                 UAM_ERR("Failed to update presence [%d:%s]",
 333                         sql_ret, sqlite3_errmsg(database_handle));
 334
 335                 error_code = UAM_ERROR_DB_FAILED;
 336                 goto handle_error;
 337         }
 338
 339         UAM_DBG("presence state updated [%d]", presence_state);
 340
 341 handle_error:
 342         sqlite3_reset(stmt);
 343         return error_code;
 344 }
 345
 346 int _uam_device_db_update_device_timestamp(char *device_id, int tech_type,
 347                                           char *address, long timestamp)
 348 {
 349         int error_code = UAM_ERROR_NONE;
 350         sqlite3_stmt *stmt = update_timestamp;
 351         int sql_ret = SQLITE_OK;
 352
 353         retv_if(NULL == device_id, UAM_ERROR_INVALID_PARAMETER);
 354         retv_if(NULL == address, UAM_ERROR_INVALID_PARAMETER);
 355
 356         DB_ACTION(sqlite3_bind_int64(stmt, 1, timestamp),
 357                 error_code, handle_error);
 358         DB_ACTION(sqlite3_bind_text(stmt, 2, device_id, -1, SQLITE_TRANSIENT),
 359                 error_code, handle_error);
 360         DB_ACTION(sqlite3_bind_int(stmt, 3, tech_type),
 361                 error_code, handle_error);
 362         DB_ACTION(sqlite3_bind_text(stmt, 4, address, -1, SQLITE_TRANSIENT),
 363                 error_code, handle_error);
 364
 365         sql_ret = sqlite3_step(stmt);
 366         if (sql_ret != SQLITE_DONE) {
 367                 UAM_ERR("Failed to update device timestamp [%d:%s]",
 368                         sql_ret, sqlite3_errmsg(database_handle));
 369
 370                 error_code = UAM_ERROR_DB_FAILED;
 371                 goto handle_error;
 372         }
 373
 374         UAM_DBG("Device timestamp updated [%ld]", timestamp);
 375
 376 handle_error:
 377         sqlite3_reset(stmt);
 378         return error_code;
 379 }
 380
 381 int _uam_device_db_update_device_device(char *device_id, int tech_type,
 382         char *address, char *ip, char os_type, char discriminant, uam_ble_payload_s payload)
 383 {
 384         int error_code = UAM_ERROR_NONE;
 385         sqlite3_stmt *stmt = update_device;
 386         int sql_ret = SQLITE_OK;
 387
 388         retv_if(NULL == device_id, UAM_ERROR_INVALID_PARAMETER);
 389         retv_if(NULL == address, UAM_ERROR_INVALID_PARAMETER);
 390
 391         DB_ACTION(sqlite3_bind_int(stmt, 1, os_type),
 392                 error_code, handle_error);
 393         DB_ACTION(sqlite3_bind_int(stmt, 2, discriminant),
 394                 error_code, handle_error);
 395         DB_ACTION(sqlite3_bind_text(stmt, 3, ip, -1, SQLITE_TRANSIENT),
 396                 error_code, handle_error);
 397         DB_ACTION(sqlite3_bind_text(stmt, 4, &(payload.service_id), 1, SQLITE_TRANSIENT),
 398                 error_code, handle_error);
 399         DB_ACTION(sqlite3_bind_text(stmt, 5, &(payload.purpose), 1, SQLITE_TRANSIENT),
 400                 error_code, handle_error);
 401         DB_ACTION(sqlite3_bind_text(stmt, 6, payload.duid, UAM_BLE_PAYLOAD_DUID_LEN + 1, SQLITE_TRANSIENT),
 402                 error_code, handle_error);
 403         DB_ACTION(sqlite3_bind_text(stmt, 7, &(payload.device_icon), 1, SQLITE_TRANSIENT),
 404                 error_code, handle_error);
 405         DB_ACTION(sqlite3_bind_text(stmt, 8, device_id, -1, SQLITE_TRANSIENT),
 406                 error_code, handle_error);
 407         DB_ACTION(sqlite3_bind_int(stmt, 9, tech_type),
 408                 error_code, handle_error);
 409         DB_ACTION(sqlite3_bind_text(stmt, 10, address, -1, SQLITE_TRANSIENT),
 410                 error_code, handle_error);
 411
 412         sql_ret = sqlite3_step(stmt);
 413         if (sql_ret != SQLITE_DONE) {
 414                 UAM_ERR("Failed to update device discriminant [%d:%s]",
 415                         sql_ret, sqlite3_errmsg(database_handle));
 416
 417                 error_code = UAM_ERROR_DB_FAILED;
 418                 goto handle_error;
 419         }
 420
 421         UAM_DBG("Device discriminant updated [%s]", discriminant ? "true" : "false");
 422
 423 handle_error:
 424         sqlite3_reset(stmt);
 425         return error_code;
 426 }
 427
 428 int _uam_device_db_insert_device_info(int user_id,
 429         const uam_device_info_s *dev_info, int presence_state, long timestamp)
 430 {
 431         FUNC_ENTRY;
 432         int error_code = UAM_ERROR_NONE;
 433         sqlite3_stmt *stmt = insert_device_info;
 434         int sql_ret = SQLITE_OK;
 435
 436         retv_if(NULL == dev_info, UAM_ERROR_INVALID_PARAMETER);
 437
 438         UAM_INFO("%s-%d-%s-%s-%ld-%d-%d-%d-%d-0x%2.2X", dev_info->device_id,
 439                         dev_info->type, dev_info->mac, dev_info->ipv4_addr,
 440                         timestamp, presence_state, dev_info->operating_system, dev_info->discriminant,
 441                         user_id, dev_info->payload.service_id);
 442
 443         DB_ACTION(sqlite3_bind_text(stmt, 1, dev_info->device_id, -1, SQLITE_TRANSIENT),
 444                 error_code, handle_error);
 445         DB_ACTION(sqlite3_bind_int(stmt, 2, dev_info->type),
 446                 error_code, handle_error);
 447         DB_ACTION(sqlite3_bind_text(stmt, 3, dev_info->mac, -1, SQLITE_TRANSIENT),
 448                 error_code, handle_error);
 449         DB_ACTION(sqlite3_bind_text(stmt, 4, dev_info->ipv4_addr, -1, SQLITE_TRANSIENT),
 450                 error_code, handle_error);
 451         DB_ACTION(sqlite3_bind_int64(stmt, 5, timestamp),
 452                 error_code, handle_error);
 453         DB_ACTION(sqlite3_bind_int(stmt, 6, presence_state),
 454                 error_code, handle_error);
 455         DB_ACTION(sqlite3_bind_int(stmt, 7, dev_info->operating_system),
 456                 error_code, handle_error);
 457         DB_ACTION(sqlite3_bind_int(stmt, 8, user_id),
 458                 error_code, handle_error);
 459         DB_ACTION(sqlite3_bind_int(stmt, 9, dev_info->discriminant),
 460                 error_code, handle_error);
 461         DB_ACTION(sqlite3_bind_text(stmt, 10, &(dev_info->payload.service_id), 1, SQLITE_TRANSIENT),
 462                 error_code, handle_error);
 463         DB_ACTION(sqlite3_bind_text(stmt, 11, &(dev_info->payload.purpose), 1, SQLITE_TRANSIENT),
 464                 error_code, handle_error);
 465         DB_ACTION(sqlite3_bind_text(stmt, 12, dev_info->payload.duid, UAM_BLE_PAYLOAD_DUID_LEN + 1, SQLITE_TRANSIENT),
 466                 error_code, handle_error);
 467         DB_ACTION(sqlite3_bind_text(stmt, 13, &(dev_info->payload.device_icon), 1, SQLITE_TRANSIENT),
 468                 error_code, handle_error);
 469
 470         sql_ret = sqlite3_step(stmt);
 471         if (sql_ret != SQLITE_DONE) {
 472                 UAM_ERR("Failed to insert device info [%d:%s]",
 473                         sql_ret, sqlite3_errmsg(database_handle));
 474                 error_code = UAM_ERROR_DB_FAILED;
 475                 goto handle_error;
 476         }
 477
 478         UAM_DBG("Device info inserted device_id [%s] ", dev_info->device_id);
 479
 480 handle_error:
 481         sqlite3_reset(stmt);
 482         FUNC_EXIT;
 483         return error_code;
 484 }
 485
 486 int _uam_device_db_delete_device_info(const char *device_id, int tech_type,
 487         const char *address)
 488 {
 489         FUNC_ENTRY;
 490         int error_code = UAM_ERROR_NONE;
 491         sqlite3_stmt *stmt = delete_device_info;
 492         int sql_ret = SQLITE_OK;
 493
 494         UAM_INFO("DeviceId: %s", device_id);
 495
 496         DB_ACTION(sqlite3_bind_text(stmt, 1, device_id, -1, SQLITE_STATIC),
 497                 error_code, handle_error);
 498         DB_ACTION(sqlite3_bind_int(stmt, 2, tech_type),
 499                 error_code, handle_error);
 500         DB_ACTION(sqlite3_bind_text(stmt, 3, address, -1, SQLITE_STATIC),
 501                 error_code, handle_error);
 502
 503         error_code = _uam_db_delete_device_service_mapping(device_id, tech_type, address);
 504         if (UAM_ERROR_NONE != error_code) {
 505                 UAM_ERR("Failed to delete device service mapping");
 506                 goto handle_error;
 507         }
 508
 509         sql_ret = sqlite3_step(stmt);
 510         if (sql_ret != SQLITE_DONE) {
 511                 UAM_ERR("Failed to delete device info [%d:%s]",
 512                         sql_ret, sqlite3_errmsg(database_handle));
 513                 error_code = UAM_ERROR_DB_FAILED;
 514         } else
 515                 UAM_DBG("Device info deleted");
 516
 517 handle_error:
 518         sqlite3_reset(stmt);
 519         FUNC_EXIT;
 520         return error_code;
 521 }
 522
 523 int _uam_device_db_get_device(char *device_id, int tech_type, char *address,
 524                 db_device_info_t *info)
 525 {
 526         FUNC_ENTRY;
 527         int error_code = UAM_ERROR_NONE;
 528         sqlite3_stmt *stmt = select_device;
 529         int sql_ret = SQLITE_OK;
 530
 531         retv_if(NULL == info, UAM_ERROR_INVALID_PARAMETER);
 532
 533         UAM_INFO("UserId: %s", device_id);
 534
 535         DB_ACTION(sqlite3_bind_text(stmt, 1, device_id, -1, SQLITE_STATIC),
 536                 error_code, handle_error);
 537         DB_ACTION(sqlite3_bind_int(stmt, 2, tech_type),
 538                 error_code, handle_error);
 539         DB_ACTION(sqlite3_bind_text(stmt, 3, address, -1, SQLITE_STATIC),
 540                 error_code, handle_error);
 541
 542         sql_ret = sqlite3_step(stmt);
 543         if (sql_ret != SQLITE_DONE) {
 544                 UAM_ERR("Failed to select device info [%d:%s]",
 545                         sql_ret, sqlite3_errmsg(database_handle));
 546                 error_code = UAM_ERROR_DB_FAILED;
 547         } else {
 548                 UAM_DBG("Device info found");
 549                 info = g_new0(db_device_info_t, 1);
 550                 g_strlcpy(info->dev_info.device_id, (char *)sqlite3_column_text(stmt, 0),
 551                         UAM_DEVICE_ID_MAX_STRING_LEN);
 552                 info->dev_info.type = sqlite3_column_int(stmt, 1);
 553                 g_strlcpy(info->dev_info.mac, (char *)sqlite3_column_text(stmt, 2),
 554                         UAM_MAC_ADDRESS_STRING_LEN);
 555                 g_strlcpy(info->dev_info.ipv4_addr, (char *)sqlite3_column_text(stmt, 3),
 556                         UAM_IP_ADDRESS_MAX_STRING_LEN);
 557                 info->timestamp = sqlite3_column_int64(stmt, 4);
 558                 info->presence_state = sqlite3_column_int(stmt, 5);
 559                 info->dev_info.operating_system = sqlite3_column_int(stmt, 6);
 560                 info->user_id = sqlite3_column_int(stmt, 7);
 561                 info->dev_info.discriminant = sqlite3_column_int(stmt, 8);
 562                 memset(info->dev_info.payload.duid, 0, UAM_BLE_PAYLOAD_DUID_LEN + 1);
 563                 info->dev_info.payload.service_id = *(char *)sqlite3_column_text(stmt, 9);
 564                 info->dev_info.payload.purpose = *(char *)sqlite3_column_text(stmt, 10);
 565                 if ((char*)sqlite3_column_text(stmt, 11))
 566                         memcpy(info->dev_info.payload.duid, (char *)sqlite3_column_text(stmt, 11),
 567                                 UAM_BLE_PAYLOAD_DUID_LEN);
 568                 info->dev_info.payload.device_icon = *(char *)sqlite3_column_text(stmt, 12);
 569
 570                 UAM_INFO("%s-%d-%s-%s-%ld-%d-%d-%d-%d-0x%2.2X",
 571                         info->dev_info.device_id,
 572                         info->dev_info.type,
 573                         info->dev_info.mac,
 574                         info->dev_info.ipv4_addr,
 575                         info->timestamp,
 576                         info->presence_state,
 577                         info->dev_info.operating_system,
 578                         info->user_id,
 579                         info->dev_info.discriminant,
 580                         info->dev_info.payload.service_id);
 581         }
 582
 583 handle_error:
 584         sqlite3_reset(stmt);
 585         FUNC_EXIT;
 586         return error_code;
 587 }
 588
 589 int _uam_db_get_device_number(const char *device_id, int tech_type,
 590         const char *address, int *device_number)
 591 {
 592         FUNC_ENTRY;
 593         int error_code = UAM_ERROR_NONE;
 594         sqlite3_stmt *stmt = select_device_number;
 595         int sql_ret = SQLITE_OK;
 596
 597         retv_if(NULL == device_id, UAM_ERROR_INVALID_PARAMETER);
 598         retv_if(NULL == address, UAM_ERROR_INVALID_PARAMETER);
 599
 600         UAM_INFO("UserId: %s", device_id);
 601
 602         DB_ACTION(sqlite3_bind_text(stmt, 1, device_id, -1, SQLITE_STATIC),
 603                 error_code, handle_error);
 604         DB_ACTION(sqlite3_bind_int(stmt, 2, tech_type),
 605                 error_code, handle_error);
 606         DB_ACTION(sqlite3_bind_text(stmt, 3, address, -1, SQLITE_STATIC),
 607                 error_code, handle_error);
 608
 609         do {
 610                 sql_ret = sqlite3_step(stmt);
 611
 612                 switch (sql_ret) {
 613                 case SQLITE_DONE:
 614                         break;
 615                 case SQLITE_ROW:
 616                         UAM_DBG("Device number info found");
 617                         *device_number = sqlite3_column_int(stmt, 0);
 618                         UAM_INFO("device_number %d", *device_number);
 619                         break;
 620                 case SQLITE_ERROR:
 621                 default:
 622                         UAM_ERR("Failed to enumerate device info [%d:%s]",
 623                                 sql_ret, sqlite3_errmsg(database_handle));
 624                 }
 625         } while (sql_ret == SQLITE_ROW);
 626
 627 handle_error:
 628         sqlite3_reset(stmt);
 629         FUNC_EXIT;
 630         return error_code;
 631 }
 632
 633 GSList *_uam_device_db_get_all_devices(void)
 634 {
 635         FUNC_ENTRY;
 636         sqlite3_stmt *stmt = select_all_devices;
 637         GSList *device_list = NULL;
 638         db_device_info_t *info = NULL;
 639         int sql_ret = SQLITE_OK;
 640
 641         do {
 642                 sql_ret = sqlite3_step(stmt);
 643
 644                 switch (sql_ret) {
 645                 case SQLITE_DONE:
 646                         break;
 647                 case SQLITE_ROW:
 648                         info = g_new0(db_device_info_t, 1);
 649                         g_strlcpy(info->dev_info.device_id, (char *)sqlite3_column_text(stmt, 0),
 650                                 UAM_DEVICE_ID_MAX_STRING_LEN);
 651                         info->dev_info.type = sqlite3_column_int(stmt, 1);
 652                         g_strlcpy(info->dev_info.mac, (char *)sqlite3_column_text(stmt, 2),
 653                                 UAM_MAC_ADDRESS_STRING_LEN);
 654                         g_strlcpy(info->dev_info.ipv4_addr, (char *)sqlite3_column_text(stmt, 3),
 655                                 UAM_IP_ADDRESS_MAX_STRING_LEN);
 656                         info->timestamp = sqlite3_column_int64(stmt, 4);
 657                         info->presence_state = sqlite3_column_int(stmt, 5);
 658                         info->dev_info.operating_system = sqlite3_column_int(stmt, 6);
 659                         info->user_id = sqlite3_column_int(stmt, 7);
 660                         info->dev_info.discriminant = sqlite3_column_int(stmt, 8);
 661                         memset(info->dev_info.payload.duid, 0, UAM_BLE_PAYLOAD_DUID_LEN + 1);
 662                         info->dev_info.payload.service_id = *(char *)sqlite3_column_text(stmt, 9);
 663                         info->dev_info.payload.purpose = *(char *)sqlite3_column_text(stmt, 10);
 664                         if ((char*)sqlite3_column_text(stmt, 11))
 665                                 memcpy(info->dev_info.payload.duid, (char *)sqlite3_column_text(stmt, 11),
 666                                         UAM_BLE_PAYLOAD_DUID_LEN);
 667                         info->dev_info.payload.device_icon = *(char *)sqlite3_column_text(stmt, 12);
 668
 669                         UAM_INFO("%s-%d-%s-%s-%ld-%d-%d-%d-%d-0x%2.2X",
 670                                 info->dev_info.device_id,
 671                                 info->dev_info.type,
 672                                 info->dev_info.mac,
 673                                 info->dev_info.ipv4_addr,
 674                                 info->timestamp,
 675                                 info->presence_state,
 676                                 info->dev_info.operating_system,
 677                                 info->user_id,
 678                                 info->dev_info.discriminant,
 679                                 info->dev_info.payload.service_id);
 680
 681                         device_list = g_slist_append(device_list, info);
 682                         break;
 683                 case SQLITE_ERROR:
 684                 default:
 685                         UAM_ERR("Failed to enumerate device info [%d:%s]",
 686                                 sql_ret, sqlite3_errmsg(database_handle));
 687                 }
 688         } while (sql_ret == SQLITE_ROW);
 689
 690         sqlite3_reset(stmt);
 691         FUNC_EXIT;
 692         return device_list;
 693 }
 694
 695 int _uam_device_db_clear(void)
 696 {
 697         int error_code = UAM_ERROR_NONE;
 698         sqlite3_stmt *stmt = delete_all_devices;
 699         int sql_ret = SQLITE_OK;
 700
 701         sql_ret = sqlite3_step(stmt);
 702         if (sql_ret != SQLITE_DONE) {
 703                 UAM_ERR("Failed to delete device data [%d:%s]",
 704                         sql_ret, sqlite3_errmsg(database_handle));
 705                 error_code = UAM_ERROR_DB_FAILED;
 706                 goto handle_error;
 707         }
 708         UAM_DBG("Device data deleted ");
 709
 710 handle_error:
 711         sqlite3_reset(stmt);
 712         return error_code;
 713 }