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