ua-daemon/src/ua-manager-device-service-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_SERVICE "SELECT S.service_number, S.service_name, S.cycle " \
  28         "FROM device_services as D JOIN services as S USING(service_number) " \
  29         "where D.device_number = ?"
  30
  31 #define SELECT_DEVICE_SERVICES_COUNT "SELECT count(*) " \
  32         "FROM device_services where device_number = ?"
  33
  34 #define SELECT_DEVICE_SERVICES \
  35         "SELECT D.device_id, D.tech_type, S.service_name, P.discriminant, P.last_seen " \
  36         "FROM device_services as P JOIN services as S USING(service_number) JOIN devices as D " \
  37         "USING(device_number)"
  38
  39 #define INSERT_DEVICE_SERVICE "insert into device_services " \
  40         "(device_number, service_number, discriminant, last_seen) values (?, ?, ?, ?)"
  41
  42 #define DELETE_ALL_DEVICE_SERVICES "delete from device_services "
  43
  44 #define DELETE_DEVICE_SERVICE "delete from device_services " \
  45         "WHERE device_number = ? and service_number = ?"
  46
  47 #define DELETE_DEVICE "delete from device_services " \
  48         "WHERE device_number = ?"
  49
  50 #define DELETE_SERVICE "delete from device_services " \
  51         "WHERE service_number = ?"
  52
  53 #define UPDATE_DEVICE_SERVICE_DISCRIMINANT "UPDATE device_services " \
  54         "SET discriminant = ? WHERE device_number = ? AND service_number = ?"
  55
  56 #define UPDATE_DEVICE_SERVICE_LAST_SEEN "UPDATE device_services " \
  57         "SET last_seen = ? WHERE device_number = ? AND service_number = ?"
  58
  59 #define UPDATE_DEVICE_SERVICE_PAYLOAD "UPDATE device_services " \
  60         "SET payload_number = ? WHERE device_number = ? AND service_number = ?"
  61
  62 /* DELETE statements */
  63 static sqlite3_stmt *delete_all_device_services;
  64 static sqlite3_stmt *delete_service;
  65 static sqlite3_stmt *delete_device_service;
  66 static sqlite3_stmt *delete_device;
  67
  68 /* SELECT statements */
  69 static sqlite3_stmt *select_service;
  70 static sqlite3_stmt *select_device_services_count;
  71 static sqlite3_stmt *select_device_services;
  72
  73 /* INSERT statements */
  74 static sqlite3_stmt *insert_device_service;
  75
  76 /* UPDATE statements */
  77 static sqlite3_stmt *update_device_service_discriminant;
  78 static sqlite3_stmt *update_device_service_last_seen;
  79 static sqlite3_stmt *update_device_service_payload;
  80
  81 extern sqlite3 *database_handle;
  82
  83 static void __uam_device_service_finalize_delete(void)
  84 {
  85         FUNC_ENTRY;
  86
  87         FINALIZE(delete_all_device_services);
  88         FINALIZE(delete_service);
  89         FINALIZE(delete_device_service);
  90         FINALIZE(delete_device);
  91
  92         FUNC_EXIT;
  93 }
  94
  95 static void __uam_device_service_finalize_select(void)
  96 {
  97         FUNC_ENTRY;
  98
  99         FINALIZE(select_service);
 100         FINALIZE(select_device_services_count);
 101         FINALIZE(select_device_services);
 102
 103         FUNC_EXIT;
 104 }
 105
 106 static void __uam_device_service_finalize_insert(void)
 107 {
 108         FUNC_ENTRY;
 109
 110         FINALIZE(insert_device_service);
 111
 112         FUNC_EXIT;
 113 }
 114
 115 static void __uam_device_service_finalize_update(void)
 116 {
 117         FUNC_ENTRY;
 118
 119         FINALIZE(update_device_service_discriminant);
 120         FINALIZE(update_device_service_last_seen);
 121         FINALIZE(update_device_service_payload);
 122
 123         FUNC_EXIT;
 124 }
 125
 126 static int __uam_device_service_prepare_delete(sqlite3 *db)
 127 {
 128         FUNC_ENTRY;
 129         int rc;
 130         static int initialized;
 131
 132         if (initialized) {
 133                 FUNC_EXIT;
 134                 return SQLITE_OK;
 135         }
 136
 137         PREPARE_QUERY(rc, db, delete_all_device_services,
 138                 DELETE_ALL_DEVICE_SERVICES, __uam_device_service_finalize_delete);
 139         PREPARE_QUERY(rc, db, delete_service,
 140                 DELETE_SERVICE, __uam_device_service_finalize_delete);
 141         PREPARE_QUERY(rc, db, delete_device_service,
 142                 DELETE_DEVICE_SERVICE, __uam_device_service_finalize_delete);
 143         PREPARE_QUERY(rc, db, delete_device,
 144                 DELETE_DEVICE, __uam_device_service_finalize_delete);
 145
 146         initialized = 1;
 147         FUNC_EXIT;
 148         return rc;
 149 }
 150
 151 static int __uam_device_service_prepare_select(sqlite3 *db)
 152 {
 153         FUNC_ENTRY;
 154         int rc;
 155         static int initialized;
 156
 157         if (initialized) {
 158                 FUNC_EXIT;
 159                 return SQLITE_OK;
 160         }
 161
 162         PREPARE_QUERY(rc, db, select_service,
 163                 SELECT_SERVICE, __uam_device_service_finalize_select);
 164         PREPARE_QUERY(rc, db, select_device_services_count,
 165                 SELECT_DEVICE_SERVICES_COUNT, __uam_device_service_finalize_select);
 166         PREPARE_QUERY(rc, db, select_device_services,
 167                 SELECT_DEVICE_SERVICES, __uam_device_service_finalize_select);
 168
 169         initialized = 1;
 170         FUNC_EXIT;
 171         return rc;
 172 }
 173
 174 static int __uam_device_service_prepare_update(sqlite3 *db)
 175 {
 176         FUNC_ENTRY;
 177         int rc;
 178         static int initialized;
 179
 180         if (initialized) {
 181                 FUNC_EXIT;
 182                 return SQLITE_OK;
 183         }
 184
 185         PREPARE_QUERY(rc, db, update_device_service_discriminant,
 186                 UPDATE_DEVICE_SERVICE_DISCRIMINANT, __uam_device_service_finalize_update);
 187         PREPARE_QUERY(rc, db, update_device_service_last_seen,
 188                 UPDATE_DEVICE_SERVICE_LAST_SEEN, __uam_device_service_finalize_update);
 189         PREPARE_QUERY(rc, db, update_device_service_payload,
 190                 UPDATE_DEVICE_SERVICE_PAYLOAD, __uam_device_service_finalize_update);
 191
 192         initialized = 1;
 193         FUNC_EXIT;
 194         return rc;
 195 }
 196
 197 static int __uam_device_service_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_service,
 209                 INSERT_DEVICE_SERVICE, __uam_device_service_finalize_insert);
 210
 211         initialized = 1;
 212         FUNC_EXIT;
 213         return rc;
 214 }
 215
 216 static int __uam_device_service_table_deviceservicesinfo_prepare(
 217         sqlite3 *db)
 218 {
 219         FUNC_ENTRY;
 220
 221         int error_code = UAM_ERROR_NONE;
 222
 223         if (db == NULL) {
 224                 FUNC_EXIT;
 225                 return UAM_ERROR_DB_FAILED;
 226         }
 227
 228         DB_ACTION(__uam_device_service_prepare_delete(db), error_code, handle_error);
 229         DB_ACTION(__uam_device_service_prepare_select(db), error_code, handle_error);
 230         DB_ACTION(__uam_device_service_prepare_update(db), error_code, handle_error);
 231         DB_ACTION(__uam_device_service_prepare_insert(db), error_code, handle_error);
 232
 233 handle_error:
 234         FUNC_EXIT;
 235         return error_code;
 236 }
 237
 238 static void __uam_device_service_table_devicesinfo_finalize(void)
 239 {
 240         FUNC_ENTRY;
 241         __uam_device_service_finalize_delete();
 242         __uam_device_service_finalize_select();
 243         __uam_device_service_finalize_insert();
 244         __uam_device_service_finalize_update();
 245         FUNC_EXIT;
 246 }
 247
 248 int _uam_device_service_db_deinitialize(void)
 249 {
 250         FUNC_ENTRY;
 251
 252         retv_if(NULL == database_handle, UAM_ERROR_NONE);
 253
 254         __uam_device_service_table_devicesinfo_finalize();
 255         sqlite3_close(database_handle);
 256
 257         FUNC_EXIT;
 258         return UAM_ERROR_NONE;
 259 }
 260
 261 int _uam_device_service_db_initialize(void)
 262 {
 263         FUNC_ENTRY;
 264
 265         EXEC(UAM_ERROR_NONE, __uam_device_service_table_deviceservicesinfo_prepare(
 266                 database_handle), handle_error);
 267
 268         FUNC_EXIT;
 269         return UAM_ERROR_NONE;
 270
 271 handle_error:
 272         _uam_device_service_db_deinitialize();
 273         FUNC_EXIT;
 274         return UAM_ERROR_DB_FAILED;
 275 }
 276
 277 int _uam_db_insert_service(int device_number, int service_number,
 278         gboolean discriminant, unsigned long long last_seen)
 279 {
 280         FUNC_ENTRY;
 281         int error_code = UAM_ERROR_NONE;
 282         sqlite3_stmt *stmt = insert_device_service;
 283         int sql_ret = SQLITE_OK;
 284
 285         UAM_INFO("%d-%d", device_number, service_number);
 286
 287         DB_ACTION(sqlite3_bind_int(stmt, 1, device_number), error_code, handle_error);
 288         DB_ACTION(sqlite3_bind_int(stmt, 2, service_number), error_code, handle_error);
 289         DB_ACTION(sqlite3_bind_int(stmt, 3, discriminant), error_code, handle_error);
 290         DB_ACTION(sqlite3_bind_int64(stmt, 4, last_seen), error_code, handle_error);
 291
 292         sql_ret = sqlite3_step(stmt);
 293         if (sql_ret != SQLITE_DONE) {
 294                 UAM_ERR("Failed to insert device-service info [%d:%s]",
 295                         sql_ret, sqlite3_errmsg(database_handle));
 296                 error_code = UAM_ERROR_DB_FAILED;
 297                 goto handle_error;
 298         }
 299
 300         UAM_DBG("Device-service info inserted [%d] [%d] [%d] [%llu]", device_number,
 301                         service_number, discriminant, last_seen);
 302
 303 handle_error:
 304         sqlite3_reset(stmt);
 305         FUNC_EXIT;
 306         return error_code;
 307 }
 308
 309 int _uam_db_insert_device_service_info(const char *device_id, int tech_type,
 310         const char *address, const char *service_name, int cycle, gboolean discriminant,
 311         unsigned long long last_seen)
 312 {
 313         FUNC_ENTRY;
 314         int ret = UAM_ERROR_NONE;
 315         db_service_info_t info;
 316         int service_number = 0;
 317
 318         UAM_INFO("%s-%d-%s-%s-%d", device_id, tech_type, address, service_name, cycle);
 319
 320         int device_number = 0;
 321         ret = _uam_db_get_device_number(device_id, tech_type, address, &device_number);
 322         if (UAM_ERROR_NONE != ret)
 323                 goto handle_error;
 324
 325         ret = _uam_db_get_service_info(service_name, &info);
 326         if (UAM_ERROR_NONE != ret)
 327                 goto handle_error;
 328
 329         service_number = info.service_number;
 330
 331         UAM_INFO("%d-%d", device_number, service_number);
 332
 333         ret = _uam_db_insert_service(device_number, service_number, discriminant, last_seen);
 334         if (UAM_ERROR_NONE != ret)
 335                 goto handle_error;
 336
 337         UAM_DBG("Device-service info inserted [%d] [%d] [%d] [%llu]", device_number,
 338                         service_number, discriminant, last_seen);
 339
 340 handle_error:
 341         FUNC_EXIT;
 342         return ret;
 343 }
 344
 345 static int __uam_db_update_discriminant(int device_number,
 346         int service_number, gboolean discriminant)
 347 {
 348         FUNC_ENTRY;
 349         int error_code = UAM_ERROR_NONE;
 350         sqlite3_stmt *stmt = update_device_service_discriminant;
 351         int sql_ret = SQLITE_OK;
 352
 353         UAM_INFO("%d-%d", device_number, service_number);
 354
 355         DB_ACTION(sqlite3_bind_int(stmt, 1, discriminant), error_code, handle_error);
 356         DB_ACTION(sqlite3_bind_int(stmt, 2, device_number),
 357                         error_code, handle_error);
 358         DB_ACTION(sqlite3_bind_int(stmt, 3, service_number),
 359                         error_code, handle_error);
 360
 361         sql_ret = sqlite3_step(stmt);
 362         if (sql_ret != SQLITE_DONE) {
 363                 UAM_ERR("Failed to update device-service [%d:%s]",
 364                         sql_ret, sqlite3_errmsg(database_handle));
 365                 error_code = UAM_ERROR_DB_FAILED;
 366                 goto handle_error;
 367         }
 368
 369         UAM_DBG("Device-service info updated [%d] [%d] [%d] ",
 370                 device_number, service_number, discriminant);
 371
 372 handle_error:
 373         sqlite3_reset(stmt);
 374         FUNC_EXIT;
 375         return error_code;
 376 }
 377
 378 static int __uam_db_update_last_seen(int device_number,
 379         int service_number, unsigned long long last_seen)
 380 {
 381         FUNC_ENTRY;
 382         int error_code = UAM_ERROR_NONE;
 383         sqlite3_stmt *stmt = update_device_service_last_seen;
 384         int sql_ret = SQLITE_OK;
 385
 386         UAM_INFO("%d-%d", device_number, service_number);
 387
 388         DB_ACTION(sqlite3_bind_int(stmt, 1, last_seen), error_code, handle_error);
 389         DB_ACTION(sqlite3_bind_int(stmt, 2, device_number),
 390                         error_code, handle_error);
 391         DB_ACTION(sqlite3_bind_int(stmt, 3, service_number),
 392                         error_code, handle_error);
 393
 394         sql_ret = sqlite3_step(stmt);
 395         if (sql_ret != SQLITE_DONE) {
 396                 UAM_ERR("Failed to update device-service [%d:%s]",
 397                         sql_ret, sqlite3_errmsg(database_handle));
 398                 error_code = UAM_ERROR_DB_FAILED;
 399                 goto handle_error;
 400         }
 401
 402         UAM_DBG("Device-service info updated [%d] [%d] [%llu]",
 403                 device_number, service_number, last_seen);
 404
 405 handle_error:
 406         sqlite3_reset(stmt);
 407         FUNC_EXIT;
 408         return error_code;
 409 }
 410
 411 int _uam_db_update_device_service_discriminant(const char *device_id,
 412                 int tech_type, const char *address, const char *service_name,
 413                 gboolean discriminant)
 414 {
 415         FUNC_ENTRY;
 416         int ret = UAM_ERROR_NONE;
 417         db_service_info_t info;
 418         int service_number = 0;
 419
 420         UAM_INFO("%s-%d-%s-%s-%d", device_id, tech_type, address, service_name, discriminant);
 421
 422         int device_number = 0;
 423         ret = _uam_db_get_device_number(device_id, tech_type, address, &device_number);
 424         if (UAM_ERROR_NONE != ret)
 425                 goto handle_error;
 426
 427         ret = _uam_db_get_service_info(service_name, &info);
 428         if (UAM_ERROR_NONE == ret)
 429                 service_number = info.service_number;
 430         else
 431                 goto handle_error;
 432
 433         ret = __uam_db_update_discriminant(device_number, service_number, discriminant);
 434         if (UAM_ERROR_NONE != ret)
 435                 goto handle_error;
 436
 437         UAM_DBG("Device-service info updated [%d] [%d]", device_number, service_number);
 438
 439 handle_error:
 440         FUNC_EXIT;
 441         return ret;
 442 }
 443
 444 int _uam_db_update_device_service_last_seen(const char *device_id,
 445         int tech_type, const char *address, const char *service_name,
 446         unsigned long long last_seen)
 447 {
 448         FUNC_ENTRY;
 449         int ret = UAM_ERROR_NONE;
 450         db_service_info_t info;
 451         int service_number = 0;
 452
 453         UAM_INFO("%s-%d-%s-%s-%llu", device_id, tech_type, address, service_name,
 454                         last_seen);
 455
 456         int device_number = 0;
 457         ret = _uam_db_get_device_number(device_id, tech_type, address,
 458                         &device_number);
 459         if (UAM_ERROR_NONE != ret)
 460                 goto handle_error;
 461
 462         ret = _uam_db_get_service_info(service_name, &info);
 463         if (UAM_ERROR_NONE == ret)
 464                 service_number = info.service_number;
 465         else
 466                 goto handle_error;
 467
 468         ret = __uam_db_update_last_seen(device_number, service_number, last_seen);
 469         if (UAM_ERROR_NONE != ret)
 470                 goto handle_error;
 471
 472         UAM_DBG("Device-service last_seen updated [%d] [%d]", device_number,
 473                         service_number);
 474
 475 handle_error:
 476         FUNC_EXIT;
 477         return ret;
 478 }
 479
 480
 481 int _uam_device_service_db_clear(void)
 482 {
 483         int error_code = UAM_ERROR_NONE;
 484         sqlite3_stmt *stmt = delete_all_device_services;
 485         int sql_ret = SQLITE_OK;
 486
 487         sql_ret = sqlite3_step(stmt);
 488         if (sql_ret != SQLITE_DONE) {
 489                 UAM_ERR("Failed to delete device data [%d:%s]",
 490                         sql_ret, sqlite3_errmsg(database_handle));
 491                 error_code = UAM_ERROR_DB_FAILED;
 492                 goto handle_error;
 493         }
 494
 495         UAM_DBG("User data deleted ");
 496
 497 handle_error:
 498
 499         sqlite3_reset(stmt);
 500         return error_code;
 501 }
 502
 503 int _uam_db_delete_service_number(int service_number)
 504 {
 505         FUNC_ENTRY;
 506         int error_code = UAM_ERROR_NONE;
 507         sqlite3_stmt *stmt = delete_service;
 508         int sql_ret = SQLITE_OK;
 509
 510         UAM_INFO("Service Number: %d", service_number);
 511
 512         DB_ACTION(sqlite3_bind_int(stmt, 1, service_number), error_code, handle_error);
 513
 514         sql_ret = sqlite3_step(stmt);
 515         if (sql_ret != SQLITE_DONE) {
 516                 UAM_ERR("Failed to delete device-service info [%d:%s]",
 517                         sql_ret, sqlite3_errmsg(database_handle));
 518                 error_code = UAM_ERROR_DB_FAILED;
 519         } else
 520                 UAM_DBG("Device-service info deleted");
 521
 522 handle_error:
 523         sqlite3_reset(stmt);
 524         FUNC_EXIT;
 525         return error_code;
 526 }
 527
 528 int _uam_db_delete_device_service_number(int device_number,
 529         int service_number)
 530 {
 531         FUNC_ENTRY;
 532         int error_code = UAM_ERROR_NONE;
 533         sqlite3_stmt *stmt = delete_device_service;
 534         int sql_ret = SQLITE_OK;
 535
 536         UAM_INFO("Device Number: %d Service Number: %d", device_number, service_number);
 537
 538         DB_ACTION(sqlite3_bind_int(stmt, 1, device_number), error_code, handle_error);
 539         DB_ACTION(sqlite3_bind_int(stmt, 2, service_number), error_code, handle_error);
 540
 541         sql_ret = sqlite3_step(stmt);
 542         if (sql_ret != SQLITE_DONE) {
 543                 UAM_ERR("Failed to delete device-service info [%d:%s]",
 544                         sql_ret, sqlite3_errmsg(database_handle));
 545                 error_code = UAM_ERROR_DB_FAILED;
 546         } else
 547                 UAM_DBG("Device-service info deleted");
 548
 549 handle_error:
 550         sqlite3_reset(stmt);
 551         FUNC_EXIT;
 552         return error_code;
 553 }
 554
 555 int _uam_db_delete_device_number(int device_number)
 556 {
 557         FUNC_ENTRY;
 558         int error_code = UAM_ERROR_NONE;
 559         sqlite3_stmt *stmt = delete_device;
 560         int sql_ret = SQLITE_OK;
 561
 562         UAM_INFO("Device Number: %d", device_number);
 563
 564         DB_ACTION(sqlite3_bind_int(stmt, 1, device_number), error_code, handle_error);
 565
 566         sql_ret = sqlite3_step(stmt);
 567         if (sql_ret != SQLITE_DONE) {
 568                 UAM_ERR("Failed to delete device info [%d:%s]",
 569                         sql_ret, sqlite3_errmsg(database_handle));
 570                 error_code = UAM_ERROR_DB_FAILED;
 571         } else
 572                 UAM_DBG("Device info deleted");
 573
 574 handle_error:
 575         sqlite3_reset(stmt);
 576         FUNC_EXIT;
 577         return error_code;
 578 }
 579
 580 int _uam_db_delete_device_service(const char *service_name)
 581 {
 582         FUNC_ENTRY;
 583         db_service_info_t info;
 584         int ret = UAM_ERROR_NONE;
 585         int service_number = 0;
 586         int error_code = UAM_ERROR_NONE;
 587         UAM_INFO("%s", service_name);
 588
 589         ret = _uam_db_get_service_info(service_name, &info);
 590         if (UAM_ERROR_NONE != ret)
 591                 goto handle_error;
 592         service_number = info.service_number;
 593
 594         UAM_INFO("%d", service_number);
 595
 596         ret = _uam_db_delete_service_number(service_number);
 597         if (UAM_ERROR_NONE != ret)
 598                 goto handle_error;
 599
 600         UAM_DBG("Service info deleted [%d]", service_number);
 601
 602 handle_error:
 603         FUNC_EXIT;
 604         return error_code;
 605 }
 606
 607 int _uam_db_delete_device_service_info(const char *device_id, int tech_type,
 608                 const char *address, const char *service_name)
 609 {
 610         FUNC_ENTRY;
 611         db_service_info_t info;
 612         int ret = UAM_ERROR_NONE;
 613         int service_number = 0;
 614         int device_number = 0;
 615         int error_code = UAM_ERROR_NONE;
 616
 617         UAM_INFO("%s-%d-%s-%s", device_id, tech_type, address, service_name);
 618
 619         ret = _uam_db_get_device_number(device_id, tech_type, address, &device_number);
 620         if (UAM_ERROR_NONE != ret)
 621                 goto handle_error;
 622
 623         ret = _uam_db_get_service_info(service_name, &info);
 624         if (UAM_ERROR_NONE != ret)
 625                         goto handle_error;
 626         service_number = info.service_number;
 627
 628         UAM_INFO("%d-%d", device_number, service_number);
 629
 630         ret = _uam_db_delete_device_service_number(device_number, service_number);
 631         if (UAM_ERROR_NONE != ret)
 632                 goto handle_error;
 633
 634         UAM_DBG("Device-service info deleted [%d] [%d]", device_number, service_number);
 635
 636 handle_error:
 637         FUNC_EXIT;
 638         return error_code;
 639 }
 640
 641 int _uam_db_delete_device_service_mapping(const char *device_id,
 642         int tech_type, const char *address)
 643 {
 644         FUNC_ENTRY;
 645         int ret = UAM_ERROR_NONE;
 646         int device_number = 0;
 647         int error_code = UAM_ERROR_NONE;
 648
 649         UAM_INFO("%s-%d-%s", device_id, tech_type, address);
 650
 651         ret = _uam_db_get_device_number(device_id, tech_type, address, &device_number);
 652         if (UAM_ERROR_NONE != ret)
 653                 goto handle_error;
 654
 655         UAM_INFO("%d", device_number);
 656
 657         ret = _uam_db_delete_device_number(device_number);
 658         if (UAM_ERROR_NONE != ret)
 659                 goto handle_error;
 660
 661         UAM_DBG("Device info deleted [%d]", device_number);
 662
 663 handle_error:
 664         FUNC_EXIT;
 665         return error_code;
 666 }
 667
 668 GSList *_uam_db_get_service(int device_number)
 669 {
 670         FUNC_ENTRY;
 671         sqlite3_stmt *stmt = select_service;
 672         GSList *service_list = NULL;
 673         db_service_info_t *info = NULL;
 674         int sql_ret = SQLITE_OK;
 675
 676         if (sqlite3_bind_int(stmt, 1, device_number) != SQLITE_OK)
 677                 goto handle_error;
 678
 679         do {
 680                 sql_ret = sqlite3_step(stmt);
 681                 switch (sql_ret) {
 682                 case SQLITE_DONE:
 683                         break;
 684                 case SQLITE_ROW:
 685                         info = g_new0(db_service_info_t, 1);
 686                         info->service_number = sqlite3_column_int(stmt, 0);
 687                         g_strlcpy(info->service_name, (char *)sqlite3_column_text(stmt, 1),
 688                                 UAM_SERVICE_MAX_STRING_LEN);
 689                         info->cycle = sqlite3_column_int(stmt, 2);
 690
 691                         UAM_INFO("%d-%s-%d", info->service_number, info->service_name, info->cycle);
 692                         service_list = g_slist_append(service_list, info);
 693                         break;
 694                 case SQLITE_ERROR:
 695                 default:
 696                         UAM_ERR("Failed to enumerate device info [%d:%s]",
 697                                 sql_ret, sqlite3_errmsg(database_handle));
 698                 }
 699         } while (sql_ret == SQLITE_ROW);
 700
 701 handle_error:
 702         sqlite3_reset(stmt);
 703         FUNC_EXIT;
 704         return service_list;
 705 }
 706
 707 GSList *_uam_db_get_device_services(const char *device_id, int tech_type,
 708         const char *address)
 709 {
 710         FUNC_ENTRY;
 711         int ret = UAM_ERROR_NONE;
 712         int device_number = 0;
 713         UAM_INFO("%s-%d-%s", device_id, tech_type, address);
 714
 715         GSList *service_list = NULL;
 716         ret = _uam_db_get_device_number(device_id, tech_type, address, &device_number);
 717         if (UAM_ERROR_NONE != ret)
 718                 goto handle_error;
 719
 720         service_list = _uam_db_get_service(device_number);
 721
 722 handle_error:
 723         FUNC_EXIT;
 724         return service_list;
 725 }
 726
 727 int _uam_db_get_device_services_count(const char *device_id, int tech_type,
 728         const char *address, int *svc_count)
 729 {
 730         FUNC_ENTRY;
 731         int error_code = UAM_ERROR_NONE;
 732         sqlite3_stmt *stmt = select_device_services_count;
 733         int device_number = 0;
 734         int sql_ret = SQLITE_OK;
 735
 736         retv_if(NULL == device_id, UAM_ERROR_INVALID_PARAMETER);
 737         retv_if(NULL == address, UAM_ERROR_INVALID_PARAMETER);
 738         UAM_INFO("%s-%d-%s", device_id, tech_type, address);
 739
 740         error_code = _uam_db_get_device_number(device_id, tech_type, address, &device_number);
 741         if (UAM_ERROR_NONE != error_code)
 742                 goto handle_error;
 743
 744         DB_ACTION(sqlite3_bind_int(stmt, 1, device_number),
 745                 error_code, handle_error);
 746
 747         do {
 748                 sql_ret = sqlite3_step(stmt);
 749
 750                 switch (sql_ret) {
 751                 case SQLITE_DONE:
 752                         break;
 753                 case SQLITE_ROW:
 754                         UAM_DBG("Device services count info found");
 755                         *svc_count = sqlite3_column_int(stmt, 0);
 756                         UAM_INFO("device services count %d", *svc_count);
 757                         break;
 758                 case SQLITE_ERROR:
 759                 default:
 760                         UAM_ERR("Failed to enumerate device info [%d:%s]",
 761                                 sql_ret, sqlite3_errmsg(database_handle));
 762                 }
 763         } while (sql_ret == SQLITE_ROW);
 764
 765 handle_error:
 766         sqlite3_reset(stmt);
 767         FUNC_EXIT;
 768         return error_code;
 769 }
 770
 771 GSList *_uam_db_get_service_devices_info()
 772 {
 773         FUNC_ENTRY;
 774         sqlite3_stmt *stmt = select_device_services;
 775         GSList *svc_dev_list = NULL;
 776         db_svc_dev_info_t *info = NULL;
 777         int sql_ret = SQLITE_OK;
 778
 779         do {
 780                 sql_ret = sqlite3_step(stmt);
 781
 782                 switch (sql_ret) {
 783                 case SQLITE_DONE:
 784                         break;
 785                 case SQLITE_ROW:
 786                         UAM_DBG("Device services info found");
 787                         info = g_new0(db_svc_dev_info_t, 1);
 788                         g_strlcpy(info->device_id, (char *)sqlite3_column_text(stmt, 0),
 789                                 UAM_DEVICE_ID_MAX_STRING_LEN);
 790                         info->type = sqlite3_column_int(stmt, 1);
 791                         g_strlcpy(info->svc, (char *)sqlite3_column_text(stmt, 2),
 792                                 UAM_SERVICE_MAX_STRING_LEN);
 793                         info->discriminant = sqlite3_column_int(stmt, 3);
 794                         info->last_seen = sqlite3_column_int64(stmt, 4);
 795
 796                         UAM_INFO("%s-%d-%s-%d-%llu",
 797                                 info->device_id,
 798                                 info->type,
 799                                 info->svc,
 800                                 info->discriminant,
 801                                 info->last_seen);
 802
 803                         svc_dev_list = g_slist_append(svc_dev_list, info);
 804                         break;
 805                 case SQLITE_ERROR:
 806                 default:
 807                         UAM_ERR("Failed to enumerate device info [%d:%s]",
 808                                 sql_ret, sqlite3_errmsg(database_handle));
 809                 }
 810         } while (sql_ret == SQLITE_ROW);
 811
 812         sqlite3_reset(stmt);
 813         FUNC_EXIT;
 814         return svc_dev_list;
 815 }
 816
 817 static int __uam_db_update_dev_svc_payload(int device_number,
 818         int service_number, int payload_number)
 819 {
 820         FUNC_ENTRY;
 821         int error_code = UAM_ERROR_NONE;
 822         sqlite3_stmt *stmt = update_device_service_payload;
 823         int sql_ret = SQLITE_OK;
 824
 825         UAM_INFO("service: %d device: %d payload: %d",
 826                 device_number, service_number, payload_number);
 827
 828         DB_ACTION(sqlite3_bind_int(stmt, 1, payload_number), error_code, handle_error);
 829         DB_ACTION(sqlite3_bind_int(stmt, 2, device_number), error_code, handle_error);
 830         DB_ACTION(sqlite3_bind_int(stmt, 3, service_number), error_code, handle_error);
 831
 832         sql_ret = sqlite3_step(stmt);
 833         if (sql_ret != SQLITE_DONE) {
 834                 UAM_ERR("Failed to update device-service payload [%d:%s]",
 835                         sql_ret, sqlite3_errmsg(database_handle));
 836                 error_code = UAM_ERROR_DB_FAILED;
 837                 goto handle_error;
 838         }
 839
 840         UAM_DBG("Device-service payload info updated [%d] [%d] [%d] ",
 841                 device_number, service_number, payload_number);
 842
 843 handle_error:
 844         sqlite3_reset(stmt);
 845         FUNC_EXIT;
 846         return error_code;
 847 }
 848
 849 int _uam_db_update_device_service_payload_info(
 850         uam_ble_payload_s *payload, char *service_name)
 851 {
 852         FUNC_ENTRY;
 853         int ret = UAM_ERROR_NONE;
 854         db_service_info_t info;
 855         int service_number = 0;
 856         int device_number = 0;
 857         int payload_number = 0;
 858
 859         retv_if(NULL == payload, UAM_ERROR_INVALID_PARAMETER);
 860         retv_if(NULL == service_name, UAM_ERROR_INVALID_PARAMETER);
 861
 862         ret = _uam_db_get_service_info(service_name, &info);
 863         if (UAM_ERROR_NONE != ret)
 864                 goto handle_error;
 865         service_number = info.service_number;
 866
 867         ret = _uam_db_get_payload_device_number(payload, &device_number);
 868         if (UAM_ERROR_NONE != ret)
 869                 goto handle_error;
 870
 871         ret = _uam_db_get_payload_number(payload, &payload_number);
 872         if (UAM_ERROR_NONE != ret)
 873                 goto handle_error;
 874
 875         UAM_INFO("service: %d-%s device: %d payload: %d",
 876                         service_number, service_name,
 877                         device_number, payload_number);
 878
 879         ret = __uam_db_update_dev_svc_payload(device_number,
 880                 service_number, payload_number);
 881         if (UAM_ERROR_NONE != ret)
 882                 goto handle_error;
 883
 884         UAM_DBG("payload-service info inserted [%d] [%d]", device_number,
 885                         service_number);
 886
 887 handle_error:
 888         FUNC_EXIT;
 889         return ret;
 890 }